update to bevy 0.18

game/main/src/camera_system/camera_plugin.rs

@@ -1,8 +1,8 @@
-use bevy::core_pipeline::experimental::taa::{TemporalAntiAliasBundle, TemporalAntiAliasPlugin, TemporalAntiAliasing};
+use bevy::anti_alias::taa::{TemporalAntiAliasPlugin, TemporalAntiAliasing};
 use bevy::core_pipeline::prepass::DepthPrepass;
 use bevy::input::mouse::{MouseMotion, MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
-use bevy::window::{CursorGrabMode, PrimaryWindow};
+use bevy::window::{CursorGrabMode, CursorOptions, PrimaryWindow};
 use shared::sets::GameplaySet;
 use shared::tags::MainCamera;
 use world_generation::hex_utils::HexCoord;
@@ -30,10 +30,10 @@ impl Plugin for PhosCameraPlugin {
 
 fn init_bounds(
 	mut commands: Commands,
-	mut cam: Query<(&mut Transform, Entity), With<PhosCamera>>,
+	mut cam: Single<(&mut Transform, Entity), With<PhosCamera>>,
 	heightmap: Res<Map>,
 ) {
-	let (mut cam_t, cam_entity) = cam.single_mut();
+	let (mut cam_t, cam_entity) = cam.into_inner();
 	cam_t.translation = heightmap.get_center();
 	commands
 		.entity(cam_entity)
@@ -62,18 +62,17 @@ fn setup(mut commands: Commands) {
 }
 
 fn orbit_camera_upate(
-	mut cam_query: Query<(&mut Transform, &PhosCamera, &mut PhosOrbitCamera, &CameraBounds)>,
-	mut wheel: EventReader<MouseWheel>,
-	mut mouse_motion: EventReader<MouseMotion>,
+	cam_query: Single<(&mut Transform, &PhosCamera, &mut PhosOrbitCamera, &CameraBounds)>,
+	mut wheel: MessageReader<MouseWheel>,
+	mut mouse_motion: MessageReader<MouseMotion>,
 	mouse: Res<ButtonInput<MouseButton>>,
-	mut window_query: Query<&mut Window, With<PrimaryWindow>>,
+	mut cursor_options: Single<&mut CursorOptions, With<PrimaryWindow>>,
 	key: Res<ButtonInput<KeyCode>>,
 	time: Res<Time>,
 	map: Res<Map>,
 	#[cfg(debug_assertions)] mut gizmos: Gizmos,
 ) {
-	let (mut transform, config, mut orbit, bounds) = cam_query.single_mut();
-	let mut window = window_query.single_mut();
+	let (mut transform, config, mut orbit, bounds) = cam_query.into_inner();
 
 	let target = orbit.target;
 	let mut cam_pos = target;
@@ -93,11 +92,11 @@ fn orbit_camera_upate(
 		orbit.forward = rot_x * rot_y * orbit.forward;
 		// orbit.forward.y = orbit.forward.y.clamp(-0.9, 0.0);
 		orbit.forward = orbit.forward.normalize();
-		window.cursor_options.grab_mode = CursorGrabMode::Locked;
-		window.cursor_options.visible = false;
+		cursor_options.grab_mode = CursorGrabMode::Locked;
+		cursor_options.visible = false;
 	} else {
-		window.cursor_options.grab_mode = CursorGrabMode::None;
-		window.cursor_options.visible = true;
+		cursor_options.grab_mode = CursorGrabMode::None;
+		cursor_options.visible = true;
 	}
 	if key.pressed(KeyCode::KeyE) {
 		let rot = Quat::from_axis_angle(Vec3::Y, f32::to_radians(config.speed) * time.delta_secs());

game/main/src/camera_system/components.rs

@@ -1,4 +1,4 @@
-use bevy::{math::Direction3d, prelude::*};
+use bevy::prelude::*;
 use rayon::str;
 use world_generation::{hex_utils::SHORT_DIAGONAL, prelude::Chunk};
 

game/main/src/main.rs

@@ -4,6 +4,8 @@ use bevy::image::{ImageAddressMode, ImageFilterMode, ImageSamplerDescriptor};
 use bevy::pbr::wireframe::WireframePlugin;
 use bevy::prelude::*;
 use bevy::window::PresentMode;
+#[cfg(debug_assertions)]
+use bevy::window::WindowResolution;
 use bevy_inspector_egui::quick::WorldInspectorPlugin;
 use phos::PhosGamePlugin;
 
@@ -24,7 +26,7 @@ fn main() {
 						title: "Phos".into(),
 						name: Some("phos".into()),
 						#[cfg(debug_assertions)]
-						resolution: (1920., 1080.).into(),
+						resolution: WindowResolution::new(1920, 1080),
 						present_mode: PresentMode::AutoNoVsync,
 						#[cfg(not(debug_assertions))]
 						mode: bevy::window::WindowMode::BorderlessFullscreen,
@@ -46,7 +48,7 @@ fn main() {
 					..Default::default()
 				}),
 			WorldInspectorPlugin::new(),
-			WireframePlugin,
+			WireframePlugin::default(),
 			PhosGamePlugin,
 		))
 		.run();

game/main/src/map_rendering/chunk_rebuild.rs

@@ -1,7 +1,6 @@
 use bevy::ecs::world::CommandQueue;
 use bevy::prelude::*;
 use bevy::tasks::*;
-use bevy::utils::futures;
 use bevy_rapier3d::geometry::Collider;
 use bevy_rapier3d::geometry::TriMeshFlags;
 use shared::events::ChunkModifiedEvent;
@@ -20,8 +19,8 @@ pub struct ChunkRebuildPlugin;
 impl Plugin for ChunkRebuildPlugin {
 	fn build(&self, app: &mut App) {
 		app.init_resource::<PhosChunkRegistry>();
-		app.add_event::<ChunkModifiedEvent>();
-		app.add_event::<TileModifiedEvent>();
+		app.add_message::<ChunkModifiedEvent>();
+		app.add_message::<TileModifiedEvent>();
 		app.add_systems(PreUpdate, chunk_rebuilder.run_if(in_state(GeneratorState::Idle)));
 		app.add_systems(PostUpdate, collider_task_resolver);
 	}
@@ -55,7 +54,8 @@ fn chunk_rebuilder(
 				collider_data.0,
 				collider_data.1,
 				TriMeshFlags::DELETE_DUPLICATE_TRIANGLES,
-			);
+			)
+			.expect("Failed to build chunk mesh");
 			#[cfg(feature = "tracing")]
 			drop(trimesh_span);
 			queue.push(move |world: &mut World| {

game/main/src/map_rendering/map_init.rs

@@ -1,7 +1,8 @@
 #[cfg(feature = "tracing")]
 use bevy::log::*;
 use bevy::{
-	pbr::{ExtendedMaterial, NotShadowCaster},
+	light::NotShadowCaster,
+	pbr::ExtendedMaterial,
 	prelude::*,
 	render::render_resource::{ColorTargetState, FragmentState, RenderPipelineDescriptor},
 };
@@ -51,10 +52,7 @@ impl Plugin for MapInitPlugin {
 			ChunkRebuildPlugin,
 			// TerraFormingTestPlugin,
 			MaterialPlugin::<ExtendedMaterial<StandardMaterial, ChunkMaterial>>::default(),
-			MaterialPlugin::<ExtendedMaterial<StandardMaterial, WaterMaterial>> {
-				prepass_enabled: false,
-				..Default::default()
-			},
+			MaterialPlugin::<ExtendedMaterial<StandardMaterial, WaterMaterial>> { ..Default::default() },
 		));
 
 		app.configure_loading_state(
@@ -78,7 +76,7 @@ impl Plugin for MapInitPlugin {
 		app.add_systems(Update, despawn_map.run_if(in_state(GeneratorState::Regenerate)));
 		app.add_systems(
 			Update,
-			spawn_map.run_if(in_state(AssetLoadState::LoadComplete).and_then(in_state(GeneratorState::SpawnMap))),
+			spawn_map.run_if(in_state(AssetLoadState::LoadComplete).and(in_state(GeneratorState::SpawnMap))),
 		);
 
 		app.insert_resource(TileManager::default());

game/main/src/map_rendering/render_distance_system.rs

@@ -53,10 +53,9 @@ impl Default for RenderDistanceVisibility {
 
 fn render_distance_system(
 	mut objects: Query<(&Transform, &mut Visibility, &RenderDistanceVisibility)>,
-	camera_query: Query<&Transform, With<MainCamera>>,
+	camera: Single<&Transform, With<MainCamera>>,
 	settings: Res<RenderDistanceSettings>,
 ) {
-	let camera = camera_query.single();
 	let cam_pos = Vec3::new(camera.translation.x, 0.0, camera.translation.z);
 	for (t, mut vis, r) in objects.iter_mut() {
 		let dist = (cam_pos - (t.translation + r.offset)).length();

game/main/src/map_rendering/terraforming_test.rs

@@ -1,4 +1,4 @@
-use bevy::{prelude::*, utils::hashbrown::HashSet, window::PrimaryWindow};
+use bevy::{platform::collections::HashSet, prelude::*, window::PrimaryWindow};
 use bevy_rapier3d::{pipeline::QueryFilter, plugin::RapierContext};
 use shared::{
 	events::{ChunkModifiedEvent, TileModifiedEvent},
@@ -31,8 +31,8 @@ fn deform(
 	mut heightmap: ResMut<Map>,
 	chunks: Res<PhosChunkRegistry>,
 	tile_under_cursor: Res<TileUnderCursor>,
-	mut chunk_modified: EventWriter<ChunkModifiedEvent>,
-	mut tile_modified: EventWriter<TileModifiedEvent>,
+	mut chunk_modified: MessageWriter<ChunkModifiedEvent>,
+	mut tile_modified: MessageWriter<TileModifiedEvent>,
 ) {
 	let mut multi = 0.;
 	if mouse.just_pressed(MouseButton::Left) {
@@ -53,11 +53,11 @@ fn deform(
 		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_modified.write(ChunkModifiedEvent { index: chunk });
 				chunk_set.insert(chunk);
 				commands.entity(chunks.chunks[chunk]).insert(RebuildChunk);
 			}
-			tile_modified.send(TileModifiedEvent::HeightChanged(tile, height));
+			tile_modified.write(TileModifiedEvent::HeightChanged(tile, height));
 		}
 		// commands.entity(e).insert(RebuildChunk);
 	}

game/main/src/phos.rs

@@ -5,17 +5,16 @@ use crate::ui::build_ui::BuildUIPlugin;
 use crate::utlis::editor_plugin::EditorPlugin;
 use crate::utlis::tile_selection_plugin::TileSelectionPlugin;
 use crate::{camera_system::camera_plugin::PhosCameraPlugin, utlis::debug_plugin::DebugPlugin};
-use bevy::{
-	pbr::{wireframe::WireframeConfig, CascadeShadowConfig},
-	prelude::*,
-};
+use bevy::diagnostic::{EntityCountDiagnosticsPlugin, FrameTimeDiagnosticsPlugin};
+use bevy::light::CascadeShadowConfig;
+use bevy::{pbr::wireframe::WireframeConfig, prelude::*};
 use bevy_asset_loader::prelude::*;
 use bevy_rapier3d::dynamics::{Ccd, RigidBody, Velocity};
 use bevy_rapier3d::geometry::Collider;
 use bevy_rapier3d::plugin::{NoUserData, RapierPhysicsPlugin};
 use buildings::BuildingPugin;
 // use iyes_perf_ui::prelude::*;
-use shared::animation_plugin::SimpleAnimationPlugin;
+// use shared::animation_plugin::SimpleAnimationPlugin;
 use shared::sets::GameplaySet;
 use shared::states::{GameplayState, MenuState};
 use shared::{despawn::DespawnPuglin, states::AssetLoadState};
@@ -40,7 +39,7 @@ impl Plugin for PhosGamePlugin {
 			RenderDistancePlugin,
 			BuildingPugin,
 			BuildUIPlugin,
-			SimpleAnimationPlugin,
+			// SimpleAnimationPlugin,
 			UnitsPlugin,
 			DespawnPuglin,
 			TileSelectionPlugin,
@@ -59,8 +58,8 @@ impl Plugin for PhosGamePlugin {
 		app.add_systems(Update, spawn_sphere);
 
 		//Perf UI
-		app.add_plugins(bevy::diagnostic::FrameTimeDiagnosticsPlugin)
-			.add_plugins(bevy::diagnostic::EntityCountDiagnosticsPlugin)
+		app.add_plugins(FrameTimeDiagnosticsPlugin::default())
+			.add_plugins(EntityCountDiagnosticsPlugin::default())
 			.add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin);
 		// .add_plugins(PerfUiPlugin);
 
@@ -137,21 +136,20 @@ struct SphereMat(Handle<StandardMaterial>);
 
 fn spawn_sphere(
 	mut commands: Commands,
-	cam: Query<&Transform, With<PhosCamera>>,
+	cam: Single<&Transform, With<PhosCamera>>,
 	keyboard_input: Res<ButtonInput<KeyCode>>,
 	mut meshes: ResMut<Assets<Mesh>>,
 	mat: Res<SphereMat>,
 ) {
 	if keyboard_input.just_pressed(KeyCode::KeyF) {
-		let cam_transform = cam.single();
 		commands.spawn((
 			Mesh3d(meshes.add(Sphere::new(0.3))),
 			MeshMaterial3d(mat.0.clone()),
-			Transform::from_translation(cam_transform.translation),
+			Transform::from_translation(cam.translation),
 			Collider::ball(0.3),
 			RigidBody::Dynamic,
 			Ccd::enabled(),
-			Velocity::linear(cam_transform.forward() * 50.),
+			Velocity::linear(cam.forward() * 50.),
 		));
 	}
 }

game/main/src/shader_extensions/chunk_material.rs

@@ -2,8 +2,8 @@ use bevy::asset::{Asset, Handle};
 use bevy::image::Image;
 use bevy::pbr::{Material, MaterialExtension};
 use bevy::reflect::TypePath;
-use bevy::render::mesh::{MeshVertexAttribute, MeshVertexBufferLayoutRef};
-use bevy::render::render_resource::{AsBindGroup, ShaderRef};
+use bevy::render::render_resource::AsBindGroup;
+use bevy::shader::ShaderRef;
 use world_generation::consts::{ATTRIBUTE_PACKED_VERTEX_DATA, ATTRIBUTE_VERTEX_HEIGHT};
 
 #[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
@@ -48,11 +48,11 @@ impl Material for PackedChunkMaterial {
 	// }
 
 	fn specialize(
-		_pipeline: &bevy::pbr::MaterialPipeline<Self>,
+		pipeline: &bevy::pbr::MaterialPipeline,
 		descriptor: &mut bevy::render::render_resource::RenderPipelineDescriptor,
-		layout: &MeshVertexBufferLayoutRef,
-		_key: bevy::pbr::MaterialPipelineKey<Self>,
-	) -> Result<(), bevy::render::render_resource::SpecializedMeshPipelineError> {
+		layout: &bevy::mesh::MeshVertexBufferLayoutRef,
+		key: bevy::pbr::MaterialPipelineKey<Self>,
+	) -> bevy::ecs::error::Result<(), bevy::render::render_resource::SpecializedMeshPipelineError> {
 		let vertex_layout = layout.0.get_layout(&[
 			// Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
 			// Mesh::ATTRIBUTE_UV_0.at_shader_location(1),

game/main/src/shader_extensions/water_material.rs

@@ -3,7 +3,8 @@ use bevy::math::VectorSpace;
 use bevy::pbr::MaterialExtension;
 use bevy::prelude::*;
 use bevy::reflect::Reflect;
-use bevy::render::render_resource::{AsBindGroup, ShaderRef, ShaderType};
+use bevy::render::render_resource::{AsBindGroup, ShaderType};
+use bevy::shader::ShaderRef;
 
 #[derive(Asset, Reflect, AsBindGroup, Debug, Clone, Default)]
 pub struct WaterMaterial {

game/main/src/ui/build_ui.rs

@@ -1,7 +1,4 @@
-use bevy::{
-	prelude::*,
-	render::{camera::RenderTarget, view::RenderLayers},
-};
+use bevy::prelude::*;
 use shared::{states::AssetLoadState, tags::MainCamera};
 pub struct BuildUIPlugin;
 
@@ -13,7 +10,7 @@ impl Plugin for BuildUIPlugin {
 }
 
 fn setup_cameras(mut commands: Commands) {
-	commands.spawn((Camera2d, IsDefaultUiCamera, UiBoxShadowSamples(6)));
+	commands.spawn((Camera2d, IsDefaultUiCamera));
 }
 
 fn spawn_ui(mut commands: Commands) {
@@ -25,7 +22,7 @@ fn spawn_ui(mut commands: Commands) {
 			align_items: AlignItems::End,
 			..default()
 		},))
-		.insert(PickingBehavior::IGNORE)
+		// .insert(PickingBehavior::IGNORE)
 		.with_children(|parent| {
 			parent.spawn((
 				Node {

game/main/src/utlis/chunk_utils.rs

@@ -4,7 +4,7 @@ use bevy::{
 	asset::Assets,
 	ecs::system::Res,
 	math::{IVec2, UVec2, Vec3},
-	render::mesh::Mesh,
+	mesh::Mesh,
 };
 use bevy_rapier3d::geometry::{Collider, TriMeshFlags};
 use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator};
@@ -87,7 +87,8 @@ pub fn prepare_chunk_mesh_with_collider(
 	{
 		#[cfg(feature = "tracing")]
 		let _collider_span = info_span!("Create Collider Trimesh").entered();
-		collider = Collider::trimesh_with_flags(col_verts, col_indicies, TriMeshFlags::DELETE_DUPLICATE_TRIANGLES);
+		collider = Collider::trimesh_with_flags(col_verts, col_indicies, TriMeshFlags::DELETE_DUPLICATE_TRIANGLES)
+			.expect("Failed to generate chunk collision mesh");
 	}
 	return (chunk_mesh, water_mesh, collider, pos, index);
 }

game/main/src/utlis/debug_plugin.rs

@@ -45,7 +45,7 @@ impl Plugin for DebugPlugin {
 }
 
 #[derive(Resource)]
-struct Shape(pub Polyline3d<7>);
+struct Shape(pub Polyline3d);
 
 #[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
 pub enum DebugState {
@@ -87,8 +87,8 @@ fn show_water_corners(pos: Vec3, gizmos: &mut Gizmos) {
 	}
 }
 
-fn camera_debug(mut cam_query: Query<(&PhosCamera, &PhosOrbitCamera)>, mut gizmos: Gizmos) {
-	let (config, orbit) = cam_query.single();
+fn camera_debug(mut cam_query: Single<(&PhosCamera, &PhosOrbitCamera)>, mut gizmos: Gizmos) {
+	let (config, orbit) = cam_query.into_inner();
 
 	gizmos.sphere(orbit.target, 0.3, LinearRgba::RED);
 	let cam_proxy = orbit.target - (orbit.forward * 10.0);

game/main/src/utlis/editor_plugin.rs

@@ -1,4 +1,5 @@
-use bevy::{prelude::*, render::render_asset::RenderAssetUsages};
+use bevy::asset::RenderAssetUsages;
+use bevy::prelude::*;
 use bevy_inspector_egui::bevy_egui::EguiContexts;
 use bevy_inspector_egui::egui::{self};
 use image::{ImageBuffer, Rgba};
@@ -61,7 +62,7 @@ enum MapDisplayType {
 }
 
 fn asset_reloaded(
-	mut asset_events: EventReader<AssetEvent<BiomeAsset>>,
+	mut asset_events: MessageReader<AssetEvent<BiomeAsset>>,
 	mut biomes: ResMut<Assets<BiomeAsset>>,
 	biome_painter: Res<BiomePainterAsset>,
 	mut commands: Commands,
@@ -79,55 +80,55 @@ fn asset_reloaded(
 	}
 }
 
-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());
+// 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());
 
-	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",
-				);
-			});
+// 	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],
-		)));
+// 		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));
-		}
-	});
+// 		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;
-}
+// 	state.target_map_type = map_type;
+// }
 
 fn update_map_render(
 	mut state: ResMut<UIState>,

game/main/src/utlis/tile_selection_plugin.rs

@@ -1,8 +1,5 @@
 use bevy::{prelude::*, window::PrimaryWindow};
-use bevy_rapier3d::{
-	plugin::{RapierContext, ReadDefaultRapierContext},
-	prelude::QueryFilter,
-};
+use bevy_rapier3d::{plugin::RapierContext, prelude::QueryFilter};
 use shared::{
 	resources::{TileContact, TileUnderCursor},
 	tags::MainCamera,
@@ -21,20 +18,14 @@ impl Plugin for TileSelectionPlugin {
 }
 
 fn update_tile_under_cursor(
-	cam_query: Query<(&GlobalTransform, &Camera), With<MainCamera>>,
-	window: Query<&Window, With<PrimaryWindow>>,
-	rapier_context: ReadDefaultRapierContext,
+	cam_query: Single<(&GlobalTransform, &Camera), With<MainCamera>>,
+	window: Single<&Window, With<PrimaryWindow>>,
+	// rapier_context: RapierContext,
 	map: Res<Map>,
 	mut tile_under_cursor: ResMut<TileUnderCursor>,
 ) {
-	let win_r = window.get_single();
-	if win_r.is_err() {
-		return;
-	}
-	let win = win_r.unwrap();
-
-	let (cam_transform, camera) = cam_query.single();
-	let Some(cursor_pos) = win.cursor_position() else {
+	let (cam_transform, camera) = cam_query.into_inner();
+	let Some(cursor_pos) = window.cursor_position() else {
 		return;
 	};
 
@@ -42,29 +33,29 @@ fn update_tile_under_cursor(
 		return;
 	};
 
-	let collision = rapier_context.cast_ray(
-		cam_ray.origin,
-		cam_ray.direction.into(),
-		500.,
-		true,
-		QueryFilter::only_fixed(),
-	);
+	// 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;
-	}
+	// 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;
+	// }
 }