From 0fdeca198cb5c10533110b989c7608de9ea42468 Mon Sep 17 00:00:00 2001
From: Waridley <Waridley64@gmail.com>
Date: Fri, 19 Jan 2024 14:49:27 -0600
Subject: [PATCH 1/3] DIY kinematic character controller Fixes some bugs,
 introduces some others, better overall. Now high rendering framerates are
 actually better, as expected. Low framerates have tunnelling and jitter
 issues.

---
 .idea/runConfigurations/Run__debug_.xml   |   4 +-
 rs/assets/pickups/pickup_material.mat.ron |   2 +-
 rs/src/lib.rs                             |  21 +-
 rs/src/pickups.rs                         |   7 +-
 rs/src/player.rs                          | 120 +++---
 rs/src/player/camera.rs                   |   8 +-
 rs/src/player/ctrl.rs                     | 462 +++++++++++++++-------
 rs/src/player/input.rs                    |   3 +-
 rs/src/util.rs                            |  39 +-
 9 files changed, 430 insertions(+), 236 deletions(-)

diff --git a/.idea/runConfigurations/Run__debug_.xml b/.idea/runConfigurations/Run__debug_.xml
index 0c111ef..4bd733a 100644
--- a/.idea/runConfigurations/Run__debug_.xml
+++ b/.idea/runConfigurations/Run__debug_.xml
@@ -9,7 +9,9 @@
     <option name="withSudo" value="false" />
     <option name="buildTarget" value="REMOTE" />
     <option name="backtrace" value="SHORT" />
-    <envs />
+    <envs>
+      <env name="RUSTFLAGS" value="-Zthreads=16" />
+    </envs>
     <option name="isRedirectInput" value="false" />
     <option name="redirectInputPath" value="" />
     <method v="2" />
diff --git a/rs/assets/pickups/pickup_material.mat.ron b/rs/assets/pickups/pickup_material.mat.ron
index a94599e..81688c5 100644
--- a/rs/assets/pickups/pickup_material.mat.ron
+++ b/rs/assets/pickups/pickup_material.mat.ron
@@ -1,6 +1,6 @@
 ExtendedMaterial(
 	extension: BubbleMaterial(
-		glow_color: Rgba ( red: 4.0, green: 1.0, blue: 0.0, alpha: 0.15 ),
+		glow_color: Rgba ( red: 4.0, green: 1.0, blue: 0.0, alpha: 0.12 ),
 	),
 	base: StandardMaterial(
 		specular_transmission: 1.0,
diff --git a/rs/src/lib.rs b/rs/src/lib.rs
index 6136d06..5c03571 100644
--- a/rs/src/lib.rs
+++ b/rs/src/lib.rs
@@ -1,21 +1,25 @@
+#![cfg_attr(
+all(not(debug_assertions), target_os = "windows"),
+windows_subsystem = "windows"
+)]
+
 use crate::mats::BubbleMaterial;
 use bevy::{
 	diagnostic::FrameTimeDiagnosticsPlugin, pbr::ExtendedMaterial, prelude::*,
 	render::RenderPlugin, window::PrimaryWindow,
 };
-use bevy_common_assets::ron::RonAssetPlugin;
 use bevy_kira_audio::AudioPlugin;
 use bevy_pkv::PkvStore;
 use bevy_rapier3d::prelude::*;
 use particles::ParticlesPlugin;
 use player::ctrl::CtrlVel;
 use std::{f32::consts::*, fmt::Debug, time::Duration};
-use util::IntoFnPlugin;
-use util::RonReflectAssetLoader;
+use util::{IntoFnPlugin, RonReflectAssetLoader};
 
 #[allow(unused_imports, clippy::single_component_path_imports)]
 #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
 use bevy_dylib;
+use bevy_rapier3d::plugin::PhysicsSet::StepSimulation;
 
 pub mod enemies;
 pub mod mats;
@@ -33,9 +37,9 @@ pub mod util;
 /// Epsilon
 pub const EPS: f32 = 1.0e-5;
 /// Rotational epsilon in radians
-pub const R_EPS: f32 = TAU / (360.0 * 4.0);
+pub const R_EPS: f32 = TAU / 360.0; // 1 degree
 /// Fixed delta time
-pub const DT: f32 = 1.0 / 128.0;
+pub const DT: f32 = 1.0 / 30.0;
 /// Up vector
 pub const UP: Vect = Vect::Z;
 
@@ -115,7 +119,7 @@ pub fn game_plugin(app: &mut App) -> &mut App {
 		MaterialPlugin::<ExtendedMaterial<StandardMaterial, BubbleMaterial>>::default(),
 	))
 	.add_systems(Startup, startup)
-	.add_systems(Update, (terminal_velocity, fullscreen))
+	.add_systems(Update, (terminal_velocity.before(StepSimulation), fullscreen))
 	.add_systems(PostUpdate, (despawn_oob,));
 	type BubbleMatExt = ExtendedMaterial<StandardMaterial, BubbleMaterial>;
 	let registry = app.world.get_resource::<AppTypeRegistry>().unwrap().clone();
@@ -124,7 +128,10 @@ pub fn game_plugin(app: &mut App) -> &mut App {
 		reg.register::<BubbleMaterial>();
 		reg.register::<BubbleMatExt>();
 	}
-	app.register_asset_loader(RonReflectAssetLoader::<BubbleMatExt>::new(registry, vec!["mat.ron"]));
+	app.register_asset_loader(RonReflectAssetLoader::<BubbleMatExt>::new(
+		registry,
+		vec!["mat.ron"],
+	));
 	app
 }
 
diff --git a/rs/src/pickups.rs b/rs/src/pickups.rs
index 8f043dd..b709674 100644
--- a/rs/src/pickups.rs
+++ b/rs/src/pickups.rs
@@ -36,12 +36,7 @@ pub fn plugin(app: &mut App) -> &mut App {
 #[derive(Resource, Default, Debug, Clone, Deref, DerefMut)]
 pub struct PopSfx(pub Handle<AudioSource>);
 
-pub fn setup(
-	mut cmds: Commands,
-	mut meshes: ResMut<Assets<Mesh>>,
-	mut mats: ResMut<Assets<ExtendedMaterial<StandardMaterial, BubbleMaterial>>>,
-	asset_server: Res<AssetServer>,
-) {
+pub fn setup(mut cmds: Commands, mut meshes: ResMut<Assets<Mesh>>, asset_server: Res<AssetServer>) {
 	cmds.insert_resource(SpawnTimer(Timer::new(
 		Duration::from_secs(2),
 		TimerMode::Repeating,
diff --git a/rs/src/player.rs b/rs/src/player.rs
index 2f568ed..97887f0 100644
--- a/rs/src/player.rs
+++ b/rs/src/player.rs
@@ -1,5 +1,6 @@
 use crate::{terminal_velocity, TerminalVelocity, R_EPS};
 
+use crate::{pickups::MissSfx, settings::Settings, util::IntoFnPlugin};
 use bevy::{
 	ecs::system::EntityCommands,
 	prelude::{
@@ -19,8 +20,9 @@ use bevy_rapier3d::{
 	prelude::{RigidBody::KinematicPositionBased, *},
 };
 use camera::spawn_camera;
-use ctrl::CtrlVel;
+use ctrl::{CtrlState, CtrlVel};
 use enum_components::{ERef, EntityEnumCommands, EnumComponent};
+use input::{AoESound, PlayerAction};
 use leafwing_input_manager::prelude::*;
 use nanorand::Rng;
 use particles::{
@@ -28,13 +30,21 @@ use particles::{
 	InitialGlobalTransform, InitialTransform, Lifetime, ParticleBundle, PreviousGlobalTransform,
 	PreviousTransform, Spewer, SpewerBundle,
 };
-use rapier3d::{math::Point, prelude::Aabb};
+use prefs::PlayerPrefs;
+use rapier3d::{
+	math::Point,
+	prelude::{Aabb, Ball, SharedShape},
+};
 use std::{
 	f32::consts::*,
 	num::NonZeroU8,
 	ops::{Deref, DerefMut},
 	time::Duration,
 };
+use bevy::transform::systems::{propagate_transforms, sync_simple_transforms};
+use bevy_rapier3d::na::Vector3;
+use bevy_rapier3d::parry::math::Isometry;
+use bevy_rapier3d::plugin::PhysicsSet::StepSimulation;
 
 pub mod camera;
 pub mod ctrl;
@@ -51,29 +61,38 @@ pub const SLIDE_ANGLE: f32 = FRAC_PI_3 - R_EPS;
 pub const HOVER_HEIGHT: f32 = 2.0;
 const G1: Group = Group::GROUP_1;
 
+pub const CHAR_COLLIDER: Ball = Ball { radius: 1.2 };
+
+#[derive(SystemSet, Debug, Hash, PartialEq, Eq, Clone)]
+pub enum InterpolatedXforms {
+	Propagate,
+	Sync
+}
+
 pub fn plugin(app: &mut App) -> &mut App {
 	app.add_plugins(input::plugin.plugfn())
 		.add_systems(Startup, setup)
 		.add_systems(
 			Update,
 			(
-				ctrl::gravity,
-				ctrl::repel_ground.after(ctrl::gravity),
-				ctrl::reset_jump_on_ground.after(ctrl::repel_ground),
+				ctrl::gravity.before(terminal_velocity),
+				// ctrl::repel_ground.after(ctrl::gravity),
 				input::movement_input.before(terminal_velocity),
 				camera::position_target.after(terminal_velocity),
 				camera::follow_target.after(camera::position_target),
-				ctrl::move_player
-					.after(terminal_velocity)
-					.before(update_character_controls),
-				save_tmp_transform
-					.after(update_character_controls)
-					.before(Writeback),
-				load_tmp_transform.after(Writeback),
+				ctrl::move_player.before(StepSimulation).after(terminal_velocity),
+				ctrl::reset_jump_on_ground.after(ctrl::move_player),
+				// propagate_transforms.in_set(InterpolatedXforms::Propagate),
+				// sync_simple_transforms.in_set(InterpolatedXforms::Sync),
+				// ctrl::save_tmp_transform
+				// 	.after(ctrl::move_player)
+				// 	.before(Writeback),
+				// ctrl::load_tmp_transform.after(Writeback),
 				idle,
 				play_death_sound,
 			),
 		)
+		// .configure_sets(Update, (InterpolatedXforms::Propagate, InterpolatedXforms::Sync).chain().after(ctrl::move_player))
 		.add_systems(
 			Last,
 			(reset_oob, countdown_respawn, spawn_players, kill_on_key),
@@ -193,16 +212,6 @@ pub enum PlayerEntity {
 	Arms,
 	Arm(PlayerArm),
 }
-use crate::{
-	pickups::MissSfx,
-	player::{
-		ctrl::{load_tmp_transform, save_tmp_transform, CtrlState},
-		input::{AoESound, PlayerAction},
-		prefs::PlayerPrefs,
-	},
-	settings::Settings,
-	util::IntoFnPlugin,
-};
 use player_entity::*;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -282,14 +291,14 @@ pub fn spawn_players(
 
 		let id = event.id;
 		let owner = BelongsToPlayer::with_id(id);
-		let char_collider = Collider::ball(1.2);
+		let char_collider = Collider::from(SharedShape::new(CHAR_COLLIDER));
 		let mut root = cmds
 			.spawn((
 				Name::new(format!("Player{}", owner.0.get())),
 				owner,
 				TerminalVelocity(Velocity {
-					linvel: Vect::splat(128.0),
-					angvel: Vect::new(0.0, 0.0, TAU * 60.0), // one rotation per frame at 60 fps
+					linvel: Vect::splat(96.0),
+					angvel: Vect::new(0.0, 0.0, PI / crate::DT), // Half a rotation per physics tick
 				}),
 				KinematicPositionBased,
 				TransformBundle::default(),
@@ -328,19 +337,7 @@ fn build_player_scene(
 	arm_particle_mesh: Handle<Mesh>,
 ) {
 	player_controller(root, owner, char_collider);
-	player_vis(root, owner, vis, particle_mesh);
-
-	root.with_children(|builder| {
-		let mut arms = builder
-			.spawn((
-				Name::new(format!("Player{}.Arms", owner.0.get())),
-				TransformBundle::default(),
-				VisibilityBundle::default(),
-				RotVel::new(8.0),
-			))
-			.with_enum(Arms);
-		player_arms(&mut arms, owner, arm_meshes, arm_particle_mesh);
-	});
+	player_vis(root, owner, vis, particle_mesh, arm_meshes, arm_particle_mesh);
 }
 
 fn player_controller(root: &mut EntityCommands, owner: BelongsToPlayer, char_collider: Collider) {
@@ -356,19 +353,21 @@ fn player_controller(root: &mut EntityCommands, owner: BelongsToPlayer, char_col
 				Name::new(format!("Player{}.Controller", owner.0.get())),
 				owner,
 				char_collider,
+				Restitution::new(0.5),
+				Ccd::enabled(),
 				TransformBundle::default(),
 				CtrlVel::default(),
 				CollisionGroups::new(Group::GROUP_1, !Group::GROUP_1),
-				KinematicCharacterController {
-					up: Vect::Z,
-					snap_to_ground: None,
-					autostep: None,
-					max_slope_climb_angle: CLIMB_ANGLE,
-					min_slope_slide_angle: SLIDE_ANGLE,
-					filter_flags: QueryFilterFlags::EXCLUDE_SENSORS,
-					filter_groups: Some(CollisionGroups::new(G1, !G1)),
-					..default()
-				},
+				// KinematicCharacterController {
+				// 	up: Vect::Z,
+				// 	snap_to_ground: None,
+				// 	autostep: None,
+				// 	max_slope_climb_angle: CLIMB_ANGLE,
+				// 	min_slope_slide_angle: SLIDE_ANGLE,
+				// 	filter_flags: QueryFilterFlags::EXCLUDE_SENSORS,
+				// 	filter_groups: Some(CollisionGroups::new(G1, !G1)),
+				// 	..default()
+				// },
 				InputManagerBundle::<PlayerAction> {
 					input_map,
 					..default()
@@ -386,6 +385,8 @@ fn player_vis(
 	owner: BelongsToPlayer,
 	vis: SceneBundle,
 	particle_mesh: MaterialMeshBundle<StandardMaterial>,
+	arm_meshes: [(MaterialMeshBundle<StandardMaterial>, PlayerArm); 3],
+	arm_particle_mesh: Handle<Mesh>,
 ) {
 	let camera_pivot = camera::spawn_pivot(root.commands(), owner).id();
 	let ship_center = root
@@ -393,12 +394,8 @@ fn player_vis(
 		.spawn((
 			Name::new(format!("Player{}.ShipCenter", owner.0.get())),
 			owner,
-			TransformBundle::from_transform(Transform {
-				translation: Vec3::NEG_Z * 0.64,
-				rotation: Quat::from_rotation_x(FRAC_PI_2),
-				..default()
-			}),
-			// TransformBundle::default(),
+			TransformBundle::from_transform(Transform::from_translation(Vec3::NEG_Z * 0.64)),
+			TransformInterpolation { start: None, end: Some(Isometry::new(Vector3::new(0.0, 0.0, -0.64), Vector3::default())) },
 			VisibilityBundle::default(), // for children ComputedVisibility
 		))
 		.set_enum(ShipCenter)
@@ -408,7 +405,7 @@ fn player_vis(
 				.spawn((
 					Name::new(format!("Player{}.ShipCenter.Ship", owner.0.get())),
 					owner,
-					TransformBundle::default(),
+					TransformBundle::from_transform(Transform::from_rotation(Quat::from_rotation_x(FRAC_PI_2))),
 					VisibilityBundle::default(),
 				))
 				.set_enum(Ship)
@@ -493,6 +490,17 @@ fn player_vis(
 					));
 				});
 		})
+		.with_children(|builder| {
+			let mut arms = builder
+				.spawn((
+					Name::new(format!("Player{}.ShipCenter.Arms", owner.0.get())),
+					TransformBundle::from_transform(Transform::from_translation(Vec3::Z * 0.64)),
+					VisibilityBundle::default(),
+					RotVel::new(8.0),
+				))
+				.with_enum(Arms);
+			player_arms(&mut arms, owner, arm_meshes, arm_particle_mesh);
+		})
 		.add_child(camera_pivot)
 		.id();
 	root.add_child(ship_center);
@@ -582,7 +590,7 @@ fn player_arms(
 			};
 			builder
 				.spawn((
-					Name::new(format!("Player{}.Arms.{which:?}", owner.0.get())),
+					Name::new(format!("Player{}.ShipCenter.Arms.{which:?}", owner.0.get())),
 					owner,
 					arm,
 					spewer,
diff --git a/rs/src/player/camera.rs b/rs/src/player/camera.rs
index a3f392c..7eeb48c 100644
--- a/rs/src/player/camera.rs
+++ b/rs/src/player/camera.rs
@@ -5,7 +5,10 @@ use super::{
 use crate::{planet::sky::SkyShader, player::PlayerId, settings::Settings};
 
 use bevy::{
-	core_pipeline::{bloom::BloomSettings, clear_color::ClearColorConfig, fxaa::Fxaa, Skybox},
+	core_pipeline::{
+		bloom::BloomSettings, clear_color::ClearColorConfig, fxaa::Fxaa, tonemapping::Tonemapping,
+		Skybox,
+	},
 	ecs::system::{EntityCommands, Res},
 	prelude::*,
 	render::{
@@ -26,7 +29,6 @@ use bevy_rapier3d::{
 };
 use enum_components::{ERef, EntityEnumCommands};
 use std::f32::consts::FRAC_PI_2;
-use bevy::core_pipeline::tonemapping::Tonemapping;
 
 pub const CAM_ACCEL: f32 = 12.0;
 const MAX_CAM_DIST: f32 = 24.0;
@@ -166,7 +168,7 @@ pub fn spawn_pivot<'w, 's, 'a>(
 			owner,
 			CameraVertSlider(0.4),
 			TransformBundle::from_transform(Transform {
-				translation: Vect::new(0.0, 6.4, 0.0),
+				translation: Vect::new(0.0, 0.0, 6.4),
 				..default()
 			}),
 		))
diff --git a/rs/src/player/ctrl.rs b/rs/src/player/ctrl.rs
index 7b4801c..7d16cf1 100644
--- a/rs/src/player/ctrl.rs
+++ b/rs/src/player/ctrl.rs
@@ -1,19 +1,32 @@
-use crate::{
-	player::{
-		input::PlayerAction,
-		player_entity::{Controller, Root},
-		BelongsToPlayer, G1, HOVER_HEIGHT, PLAYER_GRAVITY, SLIDE_ANGLE,
-	},
-	UP,
-};
+use crate::{EPS, player::{
+	input::PlayerAction,
+	player_entity::{Controller, Root},
+	BelongsToPlayer, CHAR_COLLIDER, G1, HOVER_HEIGHT, PLAYER_GRAVITY, SLIDE_ANGLE,
+}, UP};
 use bevy::prelude::*;
+use bevy::render::primitives::{Aabb, Sphere};
 use bevy_rapier3d::{na::Vector3, prelude::*};
+use bevy_rapier3d::na::Translation;
+use bevy_rapier3d::parry::query::{DefaultQueryDispatcher, PersistentQueryDispatcher};
+use bevy_rapier3d::parry::shape::Capsule;
 use enum_components::ERef;
+use rapier3d::math::Isometry;
+use rapier3d::parry::query::ContactManifold;
+use rapier3d::prelude::{ContactManifoldData, ContactData};
 use leafwing_abilities::prelude::*;
+use crate::player::player_entity::ShipCenter;
 
 #[derive(Component, Default)]
 pub struct CtrlState {
-	pub grounded: bool,
+	pub touching_ground: bool,
+	pub bottomed_out: bool,
+}
+
+impl CtrlState {
+	pub fn bottom_out(&mut self) {
+		self.touching_ground = true;
+		self.bottomed_out = true;
+	}
 }
 
 #[derive(Component, Debug, Default, Copy, Clone, Reflect)]
@@ -28,96 +41,118 @@ pub fn repel_ground(
 		(
 			&Parent,
 			&GlobalTransform,
+			&Collider,
 			&mut CtrlVel,
-			&mut KinematicCharacterControllerOutput,
 			&mut CtrlState,
 		),
 		ERef<Controller>,
 	>,
-	t: Res<Time>,
 ) {
-	for (body_id, global, mut ctrl_vel, mut state, mut ctrl_state) in &mut q {
-		let global = global.compute_transform();
-		let col = Collider::ball(1.0);
+	for (
+		body_id,
+		global,
+		col,
+		ctrl_vel,
+		ctrl_state
+	) in &mut q {
+		player_repel_ground(
+			ctx.reborrow(),
+			body_id,
+			global,
+			col,
+			ctrl_vel,
+			ctrl_state,
+			crate::DT,
+		)
+	}
+}
 
-		let max_toi = HOVER_HEIGHT;
-		let result = ctx.cast_shape(
-			global.translation + ((global.rotation * ctrl_vel.linvel) * t.delta_seconds()), // predict next frame
-			global.rotation,
-			-UP,
-			&col,
-			max_toi,
+pub fn player_repel_ground(
+	mut ctx: Mut<RapierContext>,
+	body_id: &Parent,
+	global: &GlobalTransform,
+	col: &Collider,
+	mut ctrl_vel: Mut<CtrlVel>,
+	mut ctrl_state: Mut<CtrlState>,
+	dt: f32,
+) {
+	let global = global.compute_transform();
+	
+	let max_toi = HOVER_HEIGHT;
+	let result = ctx.cast_shape(
+		global.translation,
+		global.rotation,
+		-UP,
+		col,
+		max_toi,
+		true,
+		QueryFilter::new()
+			.exclude_sensors()
+			.exclude_rigid_body(**body_id)
+			.groups(CollisionGroups::new(G1, !G1)),
+	);
+	
+	if let Some((
+		id,
+		Toi {
+			toi,
+			details: Some(details),
+			..
+		},
+	)) = result
+	{
+		let angle = details.normal1.angle_between(UP);
+		let x = max_toi - toi; // Spring compression distance
+		let body = ctx.entity2body()[&id];
+		ctx.bodies.get_mut(body).unwrap().apply_impulse_at_point(
+			Vector3::from(global.rotation * details.normal2) * x * 100.0,
+			details.witness1.into(),
 			true,
-			QueryFilter::new()
-				.exclude_sensors()
-				.exclude_rigid_body(**body_id)
-				.groups(CollisionGroups::new(G1, !G1)),
 		);
-
-		if let Some((
-			id,
-			Toi {
-				toi,
-				details: Some(details),
-				..
-			},
-		)) = result
-		{
-			let angle = details.normal1.angle_between(UP);
-			let x = max_toi - toi; // Spring compression distance
-			let body = ctx.entity2body()[&id];
-			ctx.bodies.get_mut(body).unwrap().apply_impulse_at_point(
-				Vector3::from(global.rotation * details.normal2) * x * 100.0,
-				details.witness1.into(),
-				true,
-			);
-			if angle < SLIDE_ANGLE {
-				ctrl_state.grounded = true;
-				state.grounded = true;
-
-				// Empirically decided
-				let stiffness = 256.0;
-				let damping = 0.98;
-
-				// Think of the antigrav spring as radiating out in a spherical cone (sector),
-				// so the spring coefficient for a constant-area contact patch follows the inverse square law,
-				// not a constant like typical hooke's law springs.
-				let repel_accel = x * x * stiffness;
-
-				ctrl_vel.linvel.z += (PLAYER_GRAVITY * t.delta_seconds()) // Resist gravity for this frame
-					+ repel_accel * f32::min(t.delta_seconds(), 0.125); // don't let low framerate eject player
-
-				ctrl_vel.linvel.z *= damping;
-			} else {
-				ctrl_state.grounded = false;
-				state.grounded = false;
-
-				if ctrl_vel.linvel.z < 0.0 {
-					let norm = global.rotation.inverse() * details.normal1; // To player's local space
-					let v_dot_norm = ctrl_vel.linvel.dot(norm);
-					if v_dot_norm < 0.0 {
-						// Player is moving "into" the slope
-
-						ctrl_vel.linvel -= v_dot_norm * norm; // Remove the penetrating part
-
-						if ctrl_vel.linvel.z > 0.0 {
-							// Remove any upwards sliding
-							ctrl_vel.linvel.z = 0.0;
-						}
+		if angle < SLIDE_ANGLE {
+			ctrl_state.touching_ground = true;
+			
+			// Empirically decided
+			let stiffness = 256.0;
+			let damping = 4.0;
+			
+			// Think of the antigrav spring as radiating out in a spherical cone (sector),
+			// so the spring coefficient for a constant-area contact patch follows the inverse square law,
+			// not a constant like typical hooke's law springs.
+			let repel_accel = x * x * stiffness;
+			
+			ctrl_vel.linvel.z += (PLAYER_GRAVITY * dt) // Resist gravity for this frame
+				+ repel_accel * f32::min(dt, 0.125); // don't let low framerate eject player
+			
+			ctrl_vel.linvel.z *= 1.0 - (damping * dt);
+		} else {
+			ctrl_state.touching_ground = false;
+			
+			if ctrl_vel.linvel.z < 0.0 {
+				let norm = global.rotation.inverse() * details.normal1; // To player's local space
+				let v_dot_norm = ctrl_vel.linvel.dot(norm);
+				if v_dot_norm < 0.0 {
+					// Player is moving "into" the slope
+					
+					ctrl_vel.linvel -= v_dot_norm * norm; // Remove the penetrating part
+					
+					if ctrl_vel.linvel.z > 0.0 {
+						// Remove any upwards sliding
+						ctrl_vel.linvel.z = 0.0;
 					}
-				} else {
-					// Let player keep sliding up until gravity stops them
 				}
+			} else {
+				// Let player keep sliding up until gravity stops them
 			}
-		} else {
-			ctrl_state.grounded = false;
 		}
+	} else {
+		ctrl_state.touching_ground = false;
 	}
 }
 
 pub fn reset_jump_on_ground(mut q: Query<(AbilityState<PlayerAction>, &CtrlState)>) {
 	for (mut state, ctrl_state) in &mut q {
-		if ctrl_state.grounded
+		if ctrl_state.touching_ground
 			&& state
 				.cooldowns
 				.get(PlayerAction::Jump)
@@ -132,9 +167,9 @@ pub fn reset_jump_on_ground(mut q: Query<(AbilityState<PlayerAction>, &CtrlState
 	}
 }
 
-pub fn gravity(mut q: Query<(&mut CtrlVel, &KinematicCharacterControllerOutput)>, t: Res<Time>) {
-	for (mut ctrl_vel, out) in q.iter_mut() {
-		if out.grounded {
+pub fn gravity(mut q: Query<(&mut CtrlVel, &CtrlState)>, t: Res<Time>) {
+	for (mut ctrl_vel, state) in q.iter_mut() {
+		if state.bottomed_out {
 			// Only when actual collider is grounded, not the antigrav pulses.
 			// Let `repel_ground` handle counteracting gravity when hovering.
 			ctrl_vel.linvel.z = f32::max(ctrl_vel.linvel.z, 0.0)
@@ -147,87 +182,228 @@ pub fn gravity(mut q: Query<(&mut CtrlVel, &KinematicCharacterControllerOutput)>
 }
 
 pub fn move_player(
-	ctx: Res<RapierContext>,
-	mut body_q: Query<(Entity, &mut Transform, &BelongsToPlayer), ERef<Root>>,
+	mut ctx: ResMut<RapierContext>,
+	mut body_q: Query<(Entity, &mut Transform, &GlobalTransform, &BelongsToPlayer), ERef<Root>>,
 	mut ctrl_q: Query<
 		(
-			&CtrlVel,
-			&mut KinematicCharacterController,
+			Entity,
+			&Parent,
+			&GlobalTransform,
+			&mut CtrlVel,
+			&Collider,
 			&BelongsToPlayer,
+			&mut CtrlState,
 		),
 		ERef<Controller>,
 	>,
-	_sim_to_render: Res<SimulationToRenderTime>,
+	mut vis_q: Query<(&mut Transform, &mut TransformInterpolation, &BelongsToPlayer), ERef<ShipCenter>>,
+	sim_to_render: Res<SimulationToRenderTime>,
 	t: Res<Time>,
 ) {
-	let dt = t.delta_seconds();
-	for (ctrl_vel, mut ctrl, ctrl_owner) in &mut ctrl_q {
-		let (id, mut body_xform) = body_q
-			.iter_mut()
-			.find_map(|(id, xform, owner)|
-				// Todo: cache owner->entity map
-				(owner == ctrl_owner).then_some((id, xform)))
-			.unwrap();
-
-		let Some(&body) = ctx.entity2body().get(&id) else {
-			continue;
-		};
-		let body = &ctx.bodies[body];
-		let _body_rapier_pos = Vec3::from(*body.translation());
-
-		// if let Some(end) = ctrl.translation {
-		// 	vis_xform.translation = Vec3::ZERO.lerp(end, (DT + sim_to_render.diff) / DT);
-		// 	// interp.end.map(|end| {
-		// 	// 	let end = iso_to_transform(&end, 1.0);
-		// 	// 	vis_xform.rotation = body_xform.rotation.slerp(end.rotation, (DT + sim_to_render.diff) / DT);
-		// 	// 	vis_xform.translation = body_xform.translation.lerp(end.translation, (DT + sim_to_render.diff) / DT);
-		// 	// 	// *vis_xform = iso_to_transform(&Isometry::default().lerp_slerp(&Isometry {
-		// 	// 	// 	rotation: *Unit::from_ref_unchecked(&(*interp.end.unwrap().rotation * Quaternion::from(-body_xform.rotation))),
-		// 	// 	// 	translation: (interp.end.unwrap().translation.vector - Translation::from(body_xform.translation).vector).into(),
-		// 	// 	// }, sim_to_render.diff), 1.0);
-		// 	// });
-		// } else {
-		// 	vis_xform.translation = Vec3::ZERO;
-		// }
-
-		// if let (Some(start), Some(end)) = (interp.start, interp.end) {
-		// 	kin_interp.start = Some(start);
-		// 	kin_interp.end = Some(end);
-		// }
-		// if let Some(interp) = kin_interp.lerp_slerp((DT + accum.diff) / DT) {
-		// 	let new_xform = iso_to_transform(&interp, 1.0);
-		// 	if *body_xform != new_xform {
-		// 		*body_xform = new_xform;
-		// 	};
-		// }
-
-		let rot = ctrl_vel.angvel * dt;
-		let rot = Quat::from_euler(EulerRot::ZXY, rot.z, rot.x, rot.y);
-		body_xform.rotate_local(rot);
-
-		let slide = body_xform.rotation * ctrl_vel.linvel * dt;
-		ctrl.translation = Some(slide);
+	let dt = crate::DT;
+	let mut diff = sim_to_render.diff + t.delta_seconds();
+	let mut iters = 4;
+	while diff > 0.0 && iters > 0 {
+		diff -= dt;
+		iters -= 1;
+		
+		for (col_id, body_id, global, mut ctrl_vel, col, ctrl_owner, mut ctrl_state) in &mut ctrl_q {
+			let Some(&body_handle) = ctx.entity2body().get(&body_id) else { continue };
+			player_repel_ground(ctx.reborrow(), body_id, global, col, ctrl_vel.reborrow(), ctrl_state.reborrow(), dt);
+			
+			let Some((body_id, mut body_xform, body_global)) = body_q
+				.iter_mut()
+				.find_map(|(id, xform, global, owner)|
+					// Todo: cache owner->entity map
+					(owner == ctrl_owner).then_some((id, xform, global.compute_transform())))
+				else { return };
+			let (mut vis_xform, mut vis_interp) = vis_q
+				.iter_mut()
+				.find_map(|(xform, interp, owner)| (owner == ctrl_owner).then_some((xform, interp)))
+				.unwrap();
+			
+			let rot = ctrl_vel.angvel * dt;
+			let rot = Quat::from_euler(EulerRot::ZXY, rot.z, rot.x, rot.y);
+			body_xform.rotate_local(rot);
+			
+			let vel = body_xform.rotation * ctrl_vel.linvel;
+			
+			let filter = QueryFilter {
+				flags: QueryFilterFlags::EXCLUDE_SENSORS,
+				groups: Some(CollisionGroups::new(G1, !G1)),
+				exclude_collider: None,
+				exclude_rigid_body: Some(body_id),
+				predicate: None,
+			};
+			
+			const BUFFER: f32 = 0.1;
+			
+			let mut rem = dt;
+			let mut result = Vec3::ZERO;
+			let mut dir = vel;
+			let mut manifolds: Vec<ContactManifold<ContactManifoldData, ContactData>> = vec![];
+			let mut contacts = vec![];
+			let mut pen_fix_iters = 20;
+			while rem > dt * BUFFER {
+				// Using custom shape casting because of too many bugs/design choices I don't want with rapier's character controller.
+				match ctx.cast_shape(
+					body_global.translation + result,
+					body_global.rotation,
+					dir,
+					col,
+					rem * (1.0 + BUFFER),
+					true,
+					filter,
+				) {
+					Some((_, Toi { toi, details: Some(hit), status: _status })) => {
+						let safe_toi = (toi - (dt * BUFFER)).clamp(0.0, rem);
+						let penetrating_part = dir * ((rem - toi) / rem);
+						let reaction = -penetrating_part.dot(hit.normal1) * (hit.normal1 * 1.01);
+						let slide_dir = penetrating_part + reaction;
+						
+						let angle = hit.normal1.angle_between(UP);
+						if angle < SLIDE_ANGLE {
+							ctrl_state.bottom_out();
+							// Let player slide like normal
+							result += dir * safe_toi;
+							dir = slide_dir;
+							rem -= toi;
+						} else {
+							ctrl_state.bottomed_out = false;
+							
+							let already_moving_up = vel.z > BUFFER;
+							
+							let v_dot_norm = dir.dot(hit.normal1);
+							if v_dot_norm <= 0.0 {
+								// Player is moving "into" the slope
+								
+								let slide_dir = if !already_moving_up && hit.normal1.z > -BUFFER {
+									// Don't slide up a steep slope.
+									Vec3::new(slide_dir.x, slide_dir.y, f32::min(0.0, slide_dir.z))
+								} else {
+									// Either let player keep moving up due to their existing velocity,
+									// or let player slide down the slope.
+									slide_dir
+								};
+								result += dir * safe_toi;
+								dir = slide_dir;
+								rem -= toi;
+							} else {
+								// I don't think this can happen if `details` exists, but if it does, it means the Player is moving
+								// away from the slope, probably penetrating, and so we want to get out of that state.
+								#[cfg(debug_assertions)]
+								warn!("I thought this was unreachable. Status: {_status:?}");
+								result += dir * rem;
+								rem = 0.0;
+								dir = Vec3::ZERO;
+							}
+						}
+					}
+					Some((_, Toi { status: TOIStatus::Penetrating, .. })) => {
+						let q = DefaultQueryDispatcher;
+						contacts.clear();
+						let pos = body_global.translation + result;
+						let iso = Isometry::new(pos.into(), UP.into());
+						let ball = col.as_ball().unwrap();
+						let aabb = Aabb::from(Sphere { center: pos.into(), radius: ball.raw.radius + (vel * dt).length() });
+						
+						// Attempt to prevent tunnelling by using an extruded sphere (capsule) instead
+						let capsule = Capsule::new((-vel * dt).into(), Vec3::ZERO.into(), ball.raw.radius);
+						
+						ctx.colliders_with_aabb_intersecting_aabb(aabb, |handle| {
+							if handle == col_id { return true }
+							let Some(handle) = ctx.entity2collider().get(&handle) else { return true };
+							if let Some(other_col) = ctx.colliders.get(*handle) {
+								manifolds.clear();
+								let rel = iso.inv_mul(other_col.position());
+								if q.contact_manifolds(&rel, &capsule, other_col.shape(), BUFFER, &mut manifolds, &mut None).is_err() {
+									warn!("Cannot check if player is penetrating {:?}", other_col.shape().shape_type())
+								}
+								for manifold in &manifolds {
+									let Some(contact) = manifold.find_deepest_contact() else { continue };
+									let mut dist = contact.dist;
+									if dist >= 0.0 {
+										continue
+									}
+									let mut norm = Vec3::from(manifold.local_n1);
+									if norm.angle_between(UP) < SLIDE_ANGLE {
+										// Any shallow-enough slope bottoms us out
+										ctrl_state.bottom_out()
+									} else {
+										// // Don't push player up steep slope
+										// norm.z = f32::min(0.0, norm.z);
+										// let len = norm.length();
+										// dist /= len;
+										// norm /= len;
+									}
+									contacts.push((norm, dist));
+								}
+							}
+							true
+						});
+						let mut fix = Vec3::ZERO;
+						for (dir, dist) in contacts.drain(..) {
+							fix += dir * f32::min(dt, dist * (1.0 + BUFFER));
+						}
+						if fix.angle_between(UP) < SLIDE_ANGLE {
+							// Even if individual surfaces were all too steep, getting stuck in a V should still bottom us out.
+							ctrl_state.bottom_out()
+						}
+						result += dbg!(fix);
+						pen_fix_iters -= 1;
+						if pen_fix_iters == 0 {
+							rem = 0.0;
+						}
+					}
+					toi => {
+						if let Some(toi) = toi { dbg!(toi); }
+						ctrl_state.bottomed_out = false;
+						result += dir * rem;
+						rem = 0.0;
+						dir = Vec3::ZERO;
+					}
+				}
+			}
+			let body = ctx.bodies.get_mut(body_handle).unwrap();
+			body.set_rotation(body_xform.rotation.into(), true);
+			if result.length() > 0.0 {
+				vis_xform.translation -= result;
+				let end = vis_interp.end.unwrap();
+				vis_interp.start = Some(Isometry::new(end.translation.vector - Vector3::from(body_xform.rotation.inverse() * result), (Quat::from(end.rotation) * rot).to_scaled_axis().into()));
+				body_xform.translation += result;
+				body.set_translation(body_xform.translation.into(), true);
+			}
+		}
+	}
+	for (mut xform, interp, _) in &mut vis_q {
+		let new = interp.lerp_slerp(1.0 + diff / dt).unwrap_or_else(|| interp.end.unwrap());
+		xform.translation = new.translation.into();
+		xform.rotation = new.rotation.into();
 	}
 }
 
+/// Hack to work around `bevy_rapier` overwriting transform changes
 pub fn save_tmp_transform(
 	mut cmds: Commands,
-	mut q: Query<(Entity, &Transform, Option<&mut TmpPos>), ERef<Root>>,
+	mut q: Query<(Entity, &Transform, Option<&mut TmpXform>), ERef<Root>>,
 ) {
 	for (id, xform, tmp) in &mut q {
 		if let Some(mut tmp) = tmp {
-			**tmp = xform.translation;
+			tmp.0 = xform.translation;
+			tmp.1 = xform.rotation;
 		} else {
-			cmds.entity(id).insert(TmpPos(xform.translation));
+			cmds.entity(id).insert(TmpXform(xform.translation, xform.rotation));
 		}
 	}
 }
 
-pub fn load_tmp_transform(mut q: Query<(&mut Transform, &TmpPos), ERef<Root>>) {
+/// Hack to work around `bevy_rapier` overwriting transform changes
+pub fn load_tmp_transform(mut q: Query<(&mut Transform, &TmpXform), ERef<Root>>) {
 	for (mut xform, tmp) in &mut q {
-		xform.translation = **tmp;
+		xform.translation = tmp.0;
+		xform.rotation = tmp.1;
 	}
 }
 
-#[derive(Component, Debug, Default, Deref, DerefMut)]
-pub struct TmpPos(Vec3);
+#[derive(Component, Debug, Default)]
+pub struct TmpXform(Vec3, Quat);
diff --git a/rs/src/player/input.rs b/rs/src/player/input.rs
index 63043f8..7a25326 100644
--- a/rs/src/player/input.rs
+++ b/rs/src/player/input.rs
@@ -29,6 +29,7 @@ use std::{
 	f32::consts::{FRAC_PI_3, PI, TAU},
 	time::Duration,
 };
+use std::f32::consts::FRAC_PI_2;
 
 pub fn plugin(app: &mut App) -> &mut App {
 	app.add_plugins((
@@ -320,7 +321,7 @@ pub fn look_input(
 			slider.0 = (slider.0 + mouse.y * 0.1).clamp(0.0, 1.0);
 		}
 
-		let angle = (-PI).lerp(-PI * 0.1, slider.0);
+		let angle = (-FRAC_PI_2).lerp(FRAC_PI_2 * 0.9, slider.0);
 		xform.rotation = xform.rotation.slerp(Quat::from_rotation_x(angle), delta);
 	}
 }
diff --git a/rs/src/util.rs b/rs/src/util.rs
index 0ffa8d0..e4dd265 100644
--- a/rs/src/util.rs
+++ b/rs/src/util.rs
@@ -1,29 +1,25 @@
 use bevy::{
+	asset::{io::Reader, AssetLoader, AsyncReadExt, BoxedFuture, LoadContext},
 	ecs::{
 		event::Event,
 		query::ReadOnlyWorldQuery,
 		system::{EntityCommands, StaticSystemParam, SystemParam, SystemParamItem},
 	},
 	prelude::*,
+	reflect::{serde::TypedReflectDeserializer, TypeRegistration, Typed},
+	scene::{SceneLoaderError, SceneLoaderError::RonSpannedError},
 };
 use num_traits::NumCast;
+use ron::Error::InvalidValueForType;
+use serde::de::DeserializeSeed;
 use std::{
 	cmp::Ordering,
 	collections::VecDeque,
+	hash::Hash,
 	iter::Sum,
+	marker::PhantomData,
 	ops::{Add, Div, Index, IndexMut, Mul, Sub},
 };
-use std::marker::PhantomData;
-use bevy::asset::{AssetLoader, AsyncReadExt, BoxedFuture, LoadContext};
-use bevy::asset::io::Reader;
-use bevy::reflect::serde::TypedReflectDeserializer;
-use bevy::reflect::{DynamicStruct, Typed, TypeRegistration, TypeRegistry, TypeRegistryArc};
-use bevy::scene::SceneLoaderError;
-use bevy::scene::SceneLoaderError::RonSpannedError;
-use futures_lite::StreamExt;
-use ron::de::SpannedError;
-use ron::Error::InvalidValueForType;
-use serde::de::DeserializeSeed;
 
 #[inline(always)]
 pub fn quantize<const BITS: u32>(value: f32) -> f32 {
@@ -339,8 +335,13 @@ impl<'this, T: Reflect + FromReflect + Asset> AssetLoader for RonReflectAssetLoa
 	type Asset = T;
 	type Settings = ();
 	type Error = SceneLoaderError;
-	
-	fn load<'a>(&'a self, reader: &'a mut Reader, _settings: &'a Self::Settings, _load_context: &'a mut LoadContext) -> BoxedFuture<'a, Result<Self::Asset, Self::Error>> {
+
+	fn load<'a>(
+		&'a self,
+		reader: &'a mut Reader,
+		_settings: &'a Self::Settings,
+		_load_context: &'a mut LoadContext,
+	) -> BoxedFuture<'a, Result<Self::Asset, Self::Error>> {
 		let registration = self.registration.clone();
 		let registry = self.registry.clone();
 		Box::pin(async move {
@@ -349,16 +350,18 @@ impl<'this, T: Reflect + FromReflect + Asset> AssetLoader for RonReflectAssetLoa
 			let registry = registry.read();
 			let seed = TypedReflectDeserializer::new(&registration, &*registry);
 			let mut de = ron::Deserializer::from_bytes(&*buf)?;
-			let val = seed.deserialize(&mut de)
+			let val = seed
+				.deserialize(&mut de)
 				.map_err(|e| RonSpannedError(de.span_error(e)))?;
-			T::take_from_reflect(val)
-				.map_err(|e| RonSpannedError(de.span_error(InvalidValueForType {
+			T::take_from_reflect(val).map_err(|e| {
+				RonSpannedError(de.span_error(InvalidValueForType {
 					expected: T::type_path().into(),
 					found: format!("{e:?}"),
-				})))
+				}))
+			})
 		})
 	}
-	
+
 	fn extensions(&self) -> &[&str] {
 		&self.extensions
 	}

From 3111b38ea1a0706b842e969554a0fa6799cb5170 Mon Sep 17 00:00:00 2001
From: Waridley <Waridley64@gmail.com>
Date: Tue, 23 Jan 2024 20:47:46 -0600
Subject: [PATCH 2/3] Never despawn camera Just reset transform to zero if it
 goes too crazy

---
 rs/src/lib.rs           | 28 ++++++++++++++++++++--------
 rs/src/player/camera.rs |  4 +++-
 2 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/rs/src/lib.rs b/rs/src/lib.rs
index 5c03571..3207c63 100644
--- a/rs/src/lib.rs
+++ b/rs/src/lib.rs
@@ -1,6 +1,6 @@
 #![cfg_attr(
-all(not(debug_assertions), target_os = "windows"),
-windows_subsystem = "windows"
+	all(not(debug_assertions), target_os = "windows"),
+	windows_subsystem = "windows"
 )]
 
 use crate::mats::BubbleMaterial;
@@ -119,7 +119,10 @@ pub fn game_plugin(app: &mut App) -> &mut App {
 		MaterialPlugin::<ExtendedMaterial<StandardMaterial, BubbleMaterial>>::default(),
 	))
 	.add_systems(Startup, startup)
-	.add_systems(Update, (terminal_velocity.before(StepSimulation), fullscreen))
+	.add_systems(
+		Update,
+		(terminal_velocity.before(StepSimulation), fullscreen),
+	)
 	.add_systems(PostUpdate, (despawn_oob,));
 	type BubbleMatExt = ExtendedMaterial<StandardMaterial, BubbleMaterial>;
 	let registry = app.world.get_resource::<AppTypeRegistry>().unwrap().clone();
@@ -153,11 +156,20 @@ impl AbsoluteBounds {
 
 pub type InBounds = bool;
 
-fn despawn_oob(mut cmds: Commands, bounds: Res<AbsoluteBounds>, q: Query<(Entity, &Transform)>) {
-	for (id, xform) in &q {
-		if !bounds.test(xform.translation) {
-			bevy::log::warn!("Entity {id:?} is way out of bounds. Despawning.");
-			cmds.entity(id).despawn()
+#[derive(Component, Debug)]
+pub struct NeverDespawn;
+
+fn despawn_oob(mut cmds: Commands, bounds: Res<AbsoluteBounds>, mut q: Query<(Entity, &mut GlobalTransform, Has<NeverDespawn>)>) {
+	for (id, mut xform, never_despawn) in &mut q {
+		if !bounds.test(xform.translation()) {
+			let plan = if never_despawn {
+				*xform = GlobalTransform::default();
+				"Resetting transform to zero"
+			} else {
+				cmds.entity(id).despawn();
+				"Despawning"
+			};
+			bevy::log::warn!("Entity {id:?} is way out of bounds. {plan}...");
 		}
 	}
 }
diff --git a/rs/src/player/camera.rs b/rs/src/player/camera.rs
index 7eeb48c..cff7d91 100644
--- a/rs/src/player/camera.rs
+++ b/rs/src/player/camera.rs
@@ -2,7 +2,7 @@ use super::{
 	player_entity::{Cam, CamPivot},
 	BelongsToPlayer, G1,
 };
-use crate::{planet::sky::SkyShader, player::PlayerId, settings::Settings};
+use crate::{NeverDespawn, planet::sky::SkyShader, player::PlayerId, settings::Settings};
 
 use bevy::{
 	core_pipeline::{
@@ -113,6 +113,7 @@ pub fn spawn_camera<'w, 's, 'a>(
 		Collider::ball(2.0),
 		CollisionGroups::new(Group::empty(), Group::empty()),
 		CamTarget::default(),
+		NeverDespawn,
 	));
 	cmds.set_enum(Cam).with_children(|builder| {
 		let manual_tv_handle = ManualTextureViewHandle(player_id.get() as u32 - 1);
@@ -154,6 +155,7 @@ pub fn spawn_camera<'w, 's, 'a>(
 				enabled: settings.fxaa,
 				..default()
 			},
+			NeverDespawn,
 		));
 	});
 	cmds

From 72b1a7e79586ea7849abcfa84e408302a7b2203a Mon Sep 17 00:00:00 2001
From: Waridley <Waridley64@gmail.com>
Date: Tue, 23 Jan 2024 20:52:03 -0600
Subject: [PATCH 3/3] Format character controller improvements

---
 rs/src/player.rs       |  36 +++++---
 rs/src/player/ctrl.rs  | 198 +++++++++++++++++++++++++++--------------
 rs/src/player/input.rs |   7 +-
 rs/src/util.rs         |  15 ++--
 4 files changed, 170 insertions(+), 86 deletions(-)

diff --git a/rs/src/player.rs b/rs/src/player.rs
index 97887f0..df554fd 100644
--- a/rs/src/player.rs
+++ b/rs/src/player.rs
@@ -12,11 +12,12 @@ use bevy::{
 };
 use bevy_kira_audio::{Audio, AudioControl};
 use bevy_rapier3d::{
-	control::KinematicCharacterController,
 	dynamics::{CoefficientCombineRule::Min, Velocity},
 	geometry::{Collider, Friction},
 	math::Vect,
-	plugin::{systems::update_character_controls, PhysicsSet::Writeback},
+	na::Vector3,
+	parry::math::Isometry,
+	plugin::PhysicsSet::StepSimulation,
 	prelude::{RigidBody::KinematicPositionBased, *},
 };
 use camera::spawn_camera;
@@ -41,10 +42,6 @@ use std::{
 	ops::{Deref, DerefMut},
 	time::Duration,
 };
-use bevy::transform::systems::{propagate_transforms, sync_simple_transforms};
-use bevy_rapier3d::na::Vector3;
-use bevy_rapier3d::parry::math::Isometry;
-use bevy_rapier3d::plugin::PhysicsSet::StepSimulation;
 
 pub mod camera;
 pub mod ctrl;
@@ -66,7 +63,7 @@ pub const CHAR_COLLIDER: Ball = Ball { radius: 1.2 };
 #[derive(SystemSet, Debug, Hash, PartialEq, Eq, Clone)]
 pub enum InterpolatedXforms {
 	Propagate,
-	Sync
+	Sync,
 }
 
 pub fn plugin(app: &mut App) -> &mut App {
@@ -80,7 +77,9 @@ pub fn plugin(app: &mut App) -> &mut App {
 				input::movement_input.before(terminal_velocity),
 				camera::position_target.after(terminal_velocity),
 				camera::follow_target.after(camera::position_target),
-				ctrl::move_player.before(StepSimulation).after(terminal_velocity),
+				ctrl::move_player
+					.before(StepSimulation)
+					.after(terminal_velocity),
 				ctrl::reset_jump_on_ground.after(ctrl::move_player),
 				// propagate_transforms.in_set(InterpolatedXforms::Propagate),
 				// sync_simple_transforms.in_set(InterpolatedXforms::Sync),
@@ -337,7 +336,14 @@ fn build_player_scene(
 	arm_particle_mesh: Handle<Mesh>,
 ) {
 	player_controller(root, owner, char_collider);
-	player_vis(root, owner, vis, particle_mesh, arm_meshes, arm_particle_mesh);
+	player_vis(
+		root,
+		owner,
+		vis,
+		particle_mesh,
+		arm_meshes,
+		arm_particle_mesh,
+	);
 }
 
 fn player_controller(root: &mut EntityCommands, owner: BelongsToPlayer, char_collider: Collider) {
@@ -395,7 +401,13 @@ fn player_vis(
 			Name::new(format!("Player{}.ShipCenter", owner.0.get())),
 			owner,
 			TransformBundle::from_transform(Transform::from_translation(Vec3::NEG_Z * 0.64)),
-			TransformInterpolation { start: None, end: Some(Isometry::new(Vector3::new(0.0, 0.0, -0.64), Vector3::default())) },
+			TransformInterpolation {
+				start: None,
+				end: Some(Isometry::new(
+					Vector3::new(0.0, 0.0, -0.64),
+					Vector3::default(),
+				)),
+			},
 			VisibilityBundle::default(), // for children ComputedVisibility
 		))
 		.set_enum(ShipCenter)
@@ -405,7 +417,9 @@ fn player_vis(
 				.spawn((
 					Name::new(format!("Player{}.ShipCenter.Ship", owner.0.get())),
 					owner,
-					TransformBundle::from_transform(Transform::from_rotation(Quat::from_rotation_x(FRAC_PI_2))),
+					TransformBundle::from_transform(Transform::from_rotation(
+						Quat::from_rotation_x(FRAC_PI_2),
+					)),
 					VisibilityBundle::default(),
 				))
 				.set_enum(Ship)
diff --git a/rs/src/player/ctrl.rs b/rs/src/player/ctrl.rs
index 7d16cf1..d13dd8c 100644
--- a/rs/src/player/ctrl.rs
+++ b/rs/src/player/ctrl.rs
@@ -1,20 +1,30 @@
-use crate::{EPS, player::{
-	input::PlayerAction,
-	player_entity::{Controller, Root},
-	BelongsToPlayer, CHAR_COLLIDER, G1, HOVER_HEIGHT, PLAYER_GRAVITY, SLIDE_ANGLE,
-}, UP};
-use bevy::prelude::*;
-use bevy::render::primitives::{Aabb, Sphere};
-use bevy_rapier3d::{na::Vector3, prelude::*};
-use bevy_rapier3d::na::Translation;
-use bevy_rapier3d::parry::query::{DefaultQueryDispatcher, PersistentQueryDispatcher};
-use bevy_rapier3d::parry::shape::Capsule;
+use crate::{
+	player::{
+		input::PlayerAction,
+		player_entity::{Controller, Root, ShipCenter},
+		BelongsToPlayer, CHAR_COLLIDER, G1, HOVER_HEIGHT, PLAYER_GRAVITY, SLIDE_ANGLE,
+	},
+	EPS, UP,
+};
+use bevy::{
+	prelude::*,
+	render::primitives::{Aabb, Sphere},
+};
+use bevy_rapier3d::{
+	na::{Translation, Vector3},
+	parry::{
+		query::{DefaultQueryDispatcher, PersistentQueryDispatcher},
+		shape::Capsule,
+	},
+	prelude::*,
+};
 use enum_components::ERef;
-use rapier3d::math::Isometry;
-use rapier3d::parry::query::ContactManifold;
-use rapier3d::prelude::{ContactManifoldData, ContactData};
 use leafwing_abilities::prelude::*;
-use crate::player::player_entity::ShipCenter;
+use rapier3d::{
+	math::Isometry,
+	parry::query::ContactManifold,
+	prelude::{ContactData, ContactManifoldData},
+};
 
 #[derive(Component, Default)]
 pub struct CtrlState {
@@ -48,13 +58,7 @@ pub fn repel_ground(
 		ERef<Controller>,
 	>,
 ) {
-	for (
-		body_id,
-		global,
-		col,
-		ctrl_vel,
-		ctrl_state
-	) in &mut q {
+	for (body_id, global, col, ctrl_vel, ctrl_state) in &mut q {
 		player_repel_ground(
 			ctx.reborrow(),
 			body_id,
@@ -77,7 +81,7 @@ pub fn player_repel_ground(
 	dt: f32,
 ) {
 	let global = global.compute_transform();
-	
+
 	let max_toi = HOVER_HEIGHT;
 	let result = ctx.cast_shape(
 		global.translation,
@@ -91,7 +95,7 @@ pub fn player_repel_ground(
 			.exclude_rigid_body(**body_id)
 			.groups(CollisionGroups::new(G1, !G1)),
 	);
-	
+
 	if let Some((
 		id,
 		Toi {
@@ -111,31 +115,31 @@ pub fn player_repel_ground(
 		);
 		if angle < SLIDE_ANGLE {
 			ctrl_state.touching_ground = true;
-			
+
 			// Empirically decided
 			let stiffness = 256.0;
 			let damping = 4.0;
-			
+
 			// Think of the antigrav spring as radiating out in a spherical cone (sector),
 			// so the spring coefficient for a constant-area contact patch follows the inverse square law,
 			// not a constant like typical hooke's law springs.
 			let repel_accel = x * x * stiffness;
-			
+
 			ctrl_vel.linvel.z += (PLAYER_GRAVITY * dt) // Resist gravity for this frame
 				+ repel_accel * f32::min(dt, 0.125); // don't let low framerate eject player
-			
+
 			ctrl_vel.linvel.z *= 1.0 - (damping * dt);
 		} else {
 			ctrl_state.touching_ground = false;
-			
+
 			if ctrl_vel.linvel.z < 0.0 {
 				let norm = global.rotation.inverse() * details.normal1; // To player's local space
 				let v_dot_norm = ctrl_vel.linvel.dot(norm);
 				if v_dot_norm < 0.0 {
 					// Player is moving "into" the slope
-					
+
 					ctrl_vel.linvel -= v_dot_norm * norm; // Remove the penetrating part
-					
+
 					if ctrl_vel.linvel.z > 0.0 {
 						// Remove any upwards sliding
 						ctrl_vel.linvel.z = 0.0;
@@ -196,7 +200,14 @@ pub fn move_player(
 		),
 		ERef<Controller>,
 	>,
-	mut vis_q: Query<(&mut Transform, &mut TransformInterpolation, &BelongsToPlayer), ERef<ShipCenter>>,
+	mut vis_q: Query<
+		(
+			&mut Transform,
+			&mut TransformInterpolation,
+			&BelongsToPlayer,
+		),
+		ERef<ShipCenter>,
+	>,
 	sim_to_render: Res<SimulationToRenderTime>,
 	t: Res<Time>,
 ) {
@@ -206,28 +217,40 @@ pub fn move_player(
 	while diff > 0.0 && iters > 0 {
 		diff -= dt;
 		iters -= 1;
-		
-		for (col_id, body_id, global, mut ctrl_vel, col, ctrl_owner, mut ctrl_state) in &mut ctrl_q {
-			let Some(&body_handle) = ctx.entity2body().get(&body_id) else { continue };
-			player_repel_ground(ctx.reborrow(), body_id, global, col, ctrl_vel.reborrow(), ctrl_state.reborrow(), dt);
-			
-			let Some((body_id, mut body_xform, body_global)) = body_q
-				.iter_mut()
-				.find_map(|(id, xform, global, owner)|
+
+		for (col_id, body_id, global, mut ctrl_vel, col, ctrl_owner, mut ctrl_state) in &mut ctrl_q
+		{
+			let Some(&body_handle) = ctx.entity2body().get(&body_id) else {
+				continue;
+			};
+			player_repel_ground(
+				ctx.reborrow(),
+				body_id,
+				global,
+				col,
+				ctrl_vel.reborrow(),
+				ctrl_state.reborrow(),
+				dt,
+			);
+
+			let Some((body_id, mut body_xform, body_global)) =
+				body_q.iter_mut().find_map(|(id, xform, global, owner)|
 					// Todo: cache owner->entity map
 					(owner == ctrl_owner).then_some((id, xform, global.compute_transform())))
-				else { return };
+			else {
+				return;
+			};
 			let (mut vis_xform, mut vis_interp) = vis_q
 				.iter_mut()
 				.find_map(|(xform, interp, owner)| (owner == ctrl_owner).then_some((xform, interp)))
 				.unwrap();
-			
+
 			let rot = ctrl_vel.angvel * dt;
 			let rot = Quat::from_euler(EulerRot::ZXY, rot.z, rot.x, rot.y);
 			body_xform.rotate_local(rot);
-			
+
 			let vel = body_xform.rotation * ctrl_vel.linvel;
-			
+
 			let filter = QueryFilter {
 				flags: QueryFilterFlags::EXCLUDE_SENSORS,
 				groups: Some(CollisionGroups::new(G1, !G1)),
@@ -235,9 +258,9 @@ pub fn move_player(
 				exclude_rigid_body: Some(body_id),
 				predicate: None,
 			};
-			
+
 			const BUFFER: f32 = 0.1;
-			
+
 			let mut rem = dt;
 			let mut result = Vec3::ZERO;
 			let mut dir = vel;
@@ -255,12 +278,19 @@ pub fn move_player(
 					true,
 					filter,
 				) {
-					Some((_, Toi { toi, details: Some(hit), status: _status })) => {
+					Some((
+						_,
+						Toi {
+							toi,
+							details: Some(hit),
+							status: _status,
+						},
+					)) => {
 						let safe_toi = (toi - (dt * BUFFER)).clamp(0.0, rem);
 						let penetrating_part = dir * ((rem - toi) / rem);
 						let reaction = -penetrating_part.dot(hit.normal1) * (hit.normal1 * 1.01);
 						let slide_dir = penetrating_part + reaction;
-						
+
 						let angle = hit.normal1.angle_between(UP);
 						if angle < SLIDE_ANGLE {
 							ctrl_state.bottom_out();
@@ -270,13 +300,13 @@ pub fn move_player(
 							rem -= toi;
 						} else {
 							ctrl_state.bottomed_out = false;
-							
+
 							let already_moving_up = vel.z > BUFFER;
-							
+
 							let v_dot_norm = dir.dot(hit.normal1);
 							if v_dot_norm <= 0.0 {
 								// Player is moving "into" the slope
-								
+
 								let slide_dir = if !already_moving_up && hit.normal1.z > -BUFFER {
 									// Don't slide up a steep slope.
 									Vec3::new(slide_dir.x, slide_dir.y, f32::min(0.0, slide_dir.z))
@@ -299,31 +329,59 @@ pub fn move_player(
 							}
 						}
 					}
-					Some((_, Toi { status: TOIStatus::Penetrating, .. })) => {
+					Some((
+						_,
+						Toi {
+							status: TOIStatus::Penetrating,
+							..
+						},
+					)) => {
 						let q = DefaultQueryDispatcher;
 						contacts.clear();
 						let pos = body_global.translation + result;
 						let iso = Isometry::new(pos.into(), UP.into());
 						let ball = col.as_ball().unwrap();
-						let aabb = Aabb::from(Sphere { center: pos.into(), radius: ball.raw.radius + (vel * dt).length() });
-						
+						let aabb = Aabb::from(Sphere {
+							center: pos.into(),
+							radius: ball.raw.radius + (vel * dt).length(),
+						});
+
 						// Attempt to prevent tunnelling by using an extruded sphere (capsule) instead
-						let capsule = Capsule::new((-vel * dt).into(), Vec3::ZERO.into(), ball.raw.radius);
-						
+						let capsule =
+							Capsule::new((-vel * dt).into(), Vec3::ZERO.into(), ball.raw.radius);
+
 						ctx.colliders_with_aabb_intersecting_aabb(aabb, |handle| {
-							if handle == col_id { return true }
-							let Some(handle) = ctx.entity2collider().get(&handle) else { return true };
+							if handle == col_id {
+								return true;
+							}
+							let Some(handle) = ctx.entity2collider().get(&handle) else {
+								return true;
+							};
 							if let Some(other_col) = ctx.colliders.get(*handle) {
 								manifolds.clear();
 								let rel = iso.inv_mul(other_col.position());
-								if q.contact_manifolds(&rel, &capsule, other_col.shape(), BUFFER, &mut manifolds, &mut None).is_err() {
-									warn!("Cannot check if player is penetrating {:?}", other_col.shape().shape_type())
+								if q.contact_manifolds(
+									&rel,
+									&capsule,
+									other_col.shape(),
+									BUFFER,
+									&mut manifolds,
+									&mut None,
+								)
+								.is_err()
+								{
+									warn!(
+										"Cannot check if player is penetrating {:?}",
+										other_col.shape().shape_type()
+									)
 								}
 								for manifold in &manifolds {
-									let Some(contact) = manifold.find_deepest_contact() else { continue };
+									let Some(contact) = manifold.find_deepest_contact() else {
+										continue;
+									};
 									let mut dist = contact.dist;
 									if dist >= 0.0 {
-										continue
+										continue;
 									}
 									let mut norm = Vec3::from(manifold.local_n1);
 									if norm.angle_between(UP) < SLIDE_ANGLE {
@@ -356,7 +414,9 @@ pub fn move_player(
 						}
 					}
 					toi => {
-						if let Some(toi) = toi { dbg!(toi); }
+						if let Some(toi) = toi {
+							dbg!(toi);
+						}
 						ctrl_state.bottomed_out = false;
 						result += dir * rem;
 						rem = 0.0;
@@ -369,14 +429,19 @@ pub fn move_player(
 			if result.length() > 0.0 {
 				vis_xform.translation -= result;
 				let end = vis_interp.end.unwrap();
-				vis_interp.start = Some(Isometry::new(end.translation.vector - Vector3::from(body_xform.rotation.inverse() * result), (Quat::from(end.rotation) * rot).to_scaled_axis().into()));
+				vis_interp.start = Some(Isometry::new(
+					end.translation.vector - Vector3::from(body_xform.rotation.inverse() * result),
+					(Quat::from(end.rotation) * rot).to_scaled_axis().into(),
+				));
 				body_xform.translation += result;
 				body.set_translation(body_xform.translation.into(), true);
 			}
 		}
 	}
 	for (mut xform, interp, _) in &mut vis_q {
-		let new = interp.lerp_slerp(1.0 + diff / dt).unwrap_or_else(|| interp.end.unwrap());
+		let new = interp
+			.lerp_slerp(1.0 + diff / dt)
+			.unwrap_or_else(|| interp.end.unwrap());
 		xform.translation = new.translation.into();
 		xform.rotation = new.rotation.into();
 	}
@@ -392,7 +457,8 @@ pub fn save_tmp_transform(
 			tmp.0 = xform.translation;
 			tmp.1 = xform.rotation;
 		} else {
-			cmds.entity(id).insert(TmpXform(xform.translation, xform.rotation));
+			cmds.entity(id)
+				.insert(TmpXform(xform.translation, xform.rotation));
 		}
 	}
 }
diff --git a/rs/src/player/input.rs b/rs/src/player/input.rs
index 7a25326..3092f32 100644
--- a/rs/src/player/input.rs
+++ b/rs/src/player/input.rs
@@ -26,10 +26,9 @@ use leafwing_input_manager::prelude::*;
 use particles::Spewer;
 use serde::{Deserialize, Serialize};
 use std::{
-	f32::consts::{FRAC_PI_3, PI, TAU},
+	f32::consts::{FRAC_PI_2, FRAC_PI_3, PI, TAU},
 	time::Duration,
 };
-use std::f32::consts::FRAC_PI_2;
 
 pub fn plugin(app: &mut App) -> &mut App {
 	app.add_plugins((
@@ -386,7 +385,9 @@ pub fn grab_mouse(
 	key: Res<Input<KeyCode>>,
 	ui_hovered: Res<UiHovered>,
 ) {
-	let mut window = windows.single_mut();
+	let Ok(mut window) = windows.get_single_mut() else { // probably exiting if window is missing
+		return;
+	};
 
 	if mouse.just_pressed(MouseButton::Left) && !**ui_hovered {
 		window.cursor.visible = false;
diff --git a/rs/src/util.rs b/rs/src/util.rs
index e4dd265..12fbfae 100644
--- a/rs/src/util.rs
+++ b/rs/src/util.rs
@@ -85,19 +85,21 @@ pub fn consume_spawn_events<T: Spawnable>(
 	}
 }
 
-pub trait Lerp<R, T>
+pub trait Lerp<Rhs, T>
 where
 	Self: Clone,
-	R: Sub<Self>,
-	<R as Sub<Self>>::Output: Mul<T>,
-	<<R as Sub<Self>>::Output as Mul<T>>::Output: Add<Self>,
+	Rhs: Sub<Self>,
+	<Rhs as Sub<Self>>::Output: Mul<T>,
+	<<Rhs as Sub<Self>>::Output as Mul<T>>::Output: Add<Self>,
 {
+	type Output;
+
 	#[inline(always)]
 	fn lerp(
 		self,
-		rhs: R,
+		rhs: Rhs,
 		t: T,
-	) -> <<<R as Sub<Self>>::Output as Mul<T>>::Output as Add<Self>>::Output {
+	) -> <<<Rhs as Sub<Self>>::Output as Mul<T>>::Output as Add<Self>>::Output {
 		((rhs - self.clone()) * t) + self
 	}
 }
@@ -109,6 +111,7 @@ where
 	<R as Sub<This>>::Output: Mul<T>,
 	<<R as Sub<This>>::Output as Mul<T>>::Output: Add<This>,
 {
+	type Output = <<<R as Sub<This>>::Output as Mul<T>>::Output as Add<This>>::Output;
 }
 
 #[derive(Resource, Component)]