From 3fc0a3e45cbe49921235d72785b5c7e9d4719dea Mon Sep 17 00:00:00 2001
From: Joe Ardent <code@ardent.nebcorp.com>
Date: Sun, 19 Feb 2023 20:54:17 -0800
Subject: [PATCH 01/13] add lean resource

---
 src/action/mod.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/action/mod.rs b/src/action/mod.rs
index 84a2b46..3f6a308 100644
--- a/src/action/mod.rs
+++ b/src/action/mod.rs
@@ -1,6 +1,6 @@
 use bevy::{
     diagnostic::FrameTimeDiagnosticsPlugin,
-    prelude::{App, IntoSystemDescriptor, Plugin},
+    prelude::{App, IntoSystemDescriptor, Plugin, Resource},
 };
 use bevy_rapier3d::prelude::{NoUserData, RapierPhysicsPlugin};
 
@@ -10,6 +10,11 @@ mod systems;
 pub use components::*;
 use systems::*;
 
+#[derive(Resource, Default)]
+struct CyberLean {
+    pub lean: f32,
+}
+
 pub struct CyberActionPlugin;
 impl Plugin for CyberActionPlugin {
     fn build(&self, app: &mut App) {
@@ -17,6 +22,7 @@ impl Plugin for CyberActionPlugin {
             .register_type::<MovementSettings>()
             .init_resource::<CatControllerSettings>()
             .init_resource::<ActionDebugInstant>()
+            .init_resource::<CyberLean>()
             .register_type::<CatControllerSettings>()
             .add_plugin(RapierPhysicsPlugin::<NoUserData>::default())
             .add_plugin(FrameTimeDiagnosticsPlugin::default())

From 5378aef653ae95aa51d4d65ed5ea583106148ac6 Mon Sep 17 00:00:00 2001
From: Joe Ardent <code@ardent.nebcorp.com>
Date: Sun, 19 Feb 2023 21:21:07 -0800
Subject: [PATCH 02/13] checkpoint adding lean mod to cat system

---
 src/action/systems.rs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/action/systems.rs b/src/action/systems.rs
index e36dc74..9b5703f 100644
--- a/src/action/systems.rs
+++ b/src/action/systems.rs
@@ -2,7 +2,9 @@ use std::f32::consts::PI;
 #[cfg(feature = "inspector")]
 use std::time::Instant;
 
-use bevy::prelude::{Commands, Entity, Query, Res, ResMut, Time, Transform, Vec3, With, Without};
+use bevy::prelude::{
+    Commands, Entity, Quat, Query, Res, ResMut, Time, Transform, Vec3, With, Without,
+};
 use bevy_rapier3d::prelude::{
     CollisionGroups, ExternalForce, Group, MultibodyJoint, QueryFilter, RapierConfiguration,
     RapierContext, ReadMassProperties, Velocity,
@@ -10,7 +12,7 @@ use bevy_rapier3d::prelude::{
 
 #[cfg(feature = "inspector")]
 use super::ActionDebugInstant;
-use super::{CatControllerSettings, CatControllerState, MovementSettings, Tunneling};
+use super::{CatControllerSettings, CatControllerState, CyberLean, MovementSettings, Tunneling};
 use crate::{
     bike::{CyberBikeBody, CyberSteering, CyberWheel, BIKE_WHEEL_COLLISION_GROUP},
     input::InputState,
@@ -35,10 +37,13 @@ pub(super) fn falling_cat(
     mut bike_query: Query<(&Transform, &mut ExternalForce, &mut CatControllerState)>,
     time: Res<Time>,
     settings: Res<CatControllerSettings>,
+    lean: Res<CyberLean>,
     #[cfg(feature = "inspector")] mut debug_instant: ResMut<ActionDebugInstant>,
 ) {
     let (xform, mut forces, mut control_vars) = bike_query.single_mut();
-    let wup = xform.translation.normalize();
+    let mut wup = Transform::from_translation(xform.translation);
+    wup.rotate(Quat::from_axis_angle(xform.back(), lean.lean));
+    let wup = wup.up();
     let bike_up = xform.up();
 
     let wright = xform.forward().cross(wup).normalize();

From 9c196861a248e537515361cb2b641e42eb0d553f Mon Sep 17 00:00:00 2001
From: Joe Ardent <code@ardent.nebcorp.com>
Date: Mon, 20 Feb 2023 12:25:43 -0800
Subject: [PATCH 03/13] cherry-pick actiondebuginstant change from main

---
 src/action/components.rs | 12 +++++++++++-
 src/action/systems.rs    |  7 ++-----
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/action/components.rs b/src/action/components.rs
index d6f86e6..8ea7c9f 100644
--- a/src/action/components.rs
+++ b/src/action/components.rs
@@ -1,4 +1,4 @@
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 use bevy::{
     prelude::{Component, ReflectResource, Resource, Vec3},
@@ -14,6 +14,16 @@ impl Default for ActionDebugInstant {
     }
 }
 
+impl ActionDebugInstant {
+    pub fn reset(&mut self) {
+        self.0 = Instant::now();
+    }
+
+    pub fn elapsed(&self) -> Duration {
+        self.0.elapsed()
+    }
+}
+
 #[derive(Debug, Component)]
 pub(super) struct Tunneling {
     pub frames: usize,
diff --git a/src/action/systems.rs b/src/action/systems.rs
index 9b5703f..b32e11e 100644
--- a/src/action/systems.rs
+++ b/src/action/systems.rs
@@ -1,6 +1,4 @@
 use std::f32::consts::PI;
-#[cfg(feature = "inspector")]
-use std::time::Instant;
 
 use bevy::prelude::{
     Commands, Entity, Quat, Query, Res, ResMut, Time, Transform, Vec3, With, Without,
@@ -73,10 +71,9 @@ pub(super) fn falling_cat(
 
     #[cfg(feature = "inspector")]
     {
-        let now = Instant::now();
-        if (now - debug_instant.0).as_millis() > 1000 {
+        if debug_instant.elapsed().as_millis() > 1000 {
             dbg!(&control_vars, mag);
-            debug_instant.0 = now;
+            debug_instant.reset();
         }
     }
     control_vars.decay();

From e6407c13aaba6711ac23ede4cf7171d091feda9a Mon Sep 17 00:00:00 2001
From: Joe Ardent <code@ardent.nebcorp.com>
Date: Mon, 20 Feb 2023 13:29:46 -0800
Subject: [PATCH 04/13] something is wonky, but it's kinda ok

---
 src/action/mod.rs     |  8 ++++++--
 src/action/systems.rs | 31 +++++++++++++++++++++++++++----
 2 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/src/action/mod.rs b/src/action/mod.rs
index 3f6a308..abb282a 100644
--- a/src/action/mod.rs
+++ b/src/action/mod.rs
@@ -1,6 +1,7 @@
 use bevy::{
     diagnostic::FrameTimeDiagnosticsPlugin,
-    prelude::{App, IntoSystemDescriptor, Plugin, Resource},
+    prelude::{App, IntoSystemDescriptor, Plugin, ReflectResource, Resource},
+    reflect::Reflect,
 };
 use bevy_rapier3d::prelude::{NoUserData, RapierPhysicsPlugin};
 
@@ -10,7 +11,8 @@ mod systems;
 pub use components::*;
 use systems::*;
 
-#[derive(Resource, Default)]
+#[derive(Resource, Default, Debug, Reflect)]
+#[reflect(Resource)]
 struct CyberLean {
     pub lean: f32,
 }
@@ -23,11 +25,13 @@ impl Plugin for CyberActionPlugin {
             .init_resource::<CatControllerSettings>()
             .init_resource::<ActionDebugInstant>()
             .init_resource::<CyberLean>()
+            .register_type::<CyberLean>()
             .register_type::<CatControllerSettings>()
             .add_plugin(RapierPhysicsPlugin::<NoUserData>::default())
             .add_plugin(FrameTimeDiagnosticsPlugin::default())
             .add_system(surface_fix.label("surface_fix"))
             .add_system(gravity.before("cat"))
+            .add_system(cyber_lean.before("cat"))
             .add_system(falling_cat.label("cat"))
             .add_system(input_forces.label("iforces").after("cat"))
             .add_system(
diff --git a/src/action/systems.rs b/src/action/systems.rs
index b32e11e..4a9501a 100644
--- a/src/action/systems.rs
+++ b/src/action/systems.rs
@@ -18,6 +18,10 @@ use crate::{
 
 const PITCH_SCALE: f32 = 0.2;
 
+fn yaw_to_angle(yaw: f32) -> f32 {
+    yaw.powi(3) * (PI / 4.0)
+}
+
 /// The gravity vector points from the cyberbike to the center of the planet.
 pub(super) fn gravity(
     mut query: Query<(&Transform, &mut ExternalForce), With<CyberBikeBody>>,
@@ -30,6 +34,25 @@ pub(super) fn gravity(
     forces.torque = Vec3::ZERO;
 }
 
+/// The desired lean angle, given steering input and speed.
+pub(super) fn cyber_lean(
+    velocity: Query<&Velocity, With<CyberBikeBody>>,
+    wheels: Query<&Transform, With<CyberWheel>>,
+    input: Res<InputState>,
+    gravity_settings: Res<MovementSettings>,
+    mut lean: ResMut<CyberLean>,
+) {
+    let vel_squared = velocity.single().linvel.length_squared();
+    let steering_angle = yaw_to_angle(input.yaw);
+    let wheels: Vec<_> = wheels.iter().map(|w| w.translation).collect();
+    let wheel_base = (wheels[0] - wheels[1]).length();
+    let radius = wheel_base / steering_angle.tan();
+    let gravity = gravity_settings.gravity;
+    let tan_theta = vel_squared / (radius * gravity);
+
+    lean.lean = (PI / 2.0) - tan_theta.atan();
+}
+
 /// PID-based controller for stabilizing attitude; keeps the cyberbike upright.
 pub(super) fn falling_cat(
     mut bike_query: Query<(&Transform, &mut ExternalForce, &mut CatControllerState)>,
@@ -72,7 +95,7 @@ pub(super) fn falling_cat(
     #[cfg(feature = "inspector")]
     {
         if debug_instant.elapsed().as_millis() > 1000 {
-            dbg!(&control_vars, mag);
+            dbg!(&control_vars, mag, &lean);
             debug_instant.reset();
         }
     }
@@ -94,13 +117,13 @@ pub(super) fn input_forces(
 
     // thrust
     let thrust = xform.forward() * input.throttle * settings.accel;
-    let point = xform.translation + xform.back() * 0.5;
+    let point = xform.translation + xform.back();
     let force = ExternalForce::at_point(thrust, point, xform.translation);
     *forces += force;
 
     // brake
     for mut motor in braking_query.iter_mut() {
-        let factor = if input.brake { 200.00 } else { 0.0 };
+        let factor = if input.brake { 500.00 } else { 0.0 };
         motor.data = (*motor
             .data
             .as_revolute_mut()
@@ -111,7 +134,7 @@ pub(super) fn input_forces(
     }
 
     // steering
-    let angle = input.yaw.powf(3.0) * (PI / 4.0);
+    let angle = yaw_to_angle(input.yaw);
     let mut steering = steering_query.single_mut();
     steering.data = (*steering
         .data

From 7ee27e61a505fb9d632b13cbf932b1597be7af75 Mon Sep 17 00:00:00 2001
From: Joe Ardent <code@ardent.nebcorp.com>
Date: Mon, 20 Feb 2023 13:35:02 -0800
Subject: [PATCH 05/13] smooth out the planet

---
 src/bike/body.rs | 3 ++-
 src/planet.rs    | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/bike/body.rs b/src/bike/body.rs
index d841c14..be51f86 100644
--- a/src/bike/body.rs
+++ b/src/bike/body.rs
@@ -16,7 +16,8 @@ pub(super) fn spawn_cyberbike(
     wheel_conf: Res<WheelConfig>,
     mut meshterials: Meshterial,
 ) {
-    let altitude = PLANET_RADIUS - 180.0;
+    //let altitude = PLANET_RADIUS - 180.0;
+    let altitude = PLANET_RADIUS + 10.0; // smoothland
 
     let mut xform = Transform::from_translation(Vec3::X * altitude)
         .with_rotation(Quat::from_axis_angle(Vec3::Z, -89.0f32.to_radians()));
diff --git a/src/planet.rs b/src/planet.rs
index 8e6807b..e9076ef 100644
--- a/src/planet.rs
+++ b/src/planet.rs
@@ -87,7 +87,7 @@ fn gen_planet(sphere: Icosphere) -> (Mesh, Collider) {
         .iter()
         .map(|&p| {
             let disp = noise.get(p.as_dvec3().into()) as f32 * 0.04;
-            let pt = p + (p.normalize() * disp);
+            let pt = p; // + (p.normalize() * disp); // smoothland
             pt.into()
         })
         .collect::<Vec<[f32; 3]>>();

From 5aa7cde9aa627dc7247cce8241027761b866494b Mon Sep 17 00:00:00 2001
From: Joe Ardent <code@ardent.nebcorp.com>
Date: Mon, 20 Feb 2023 23:14:02 -0800
Subject: [PATCH 06/13] so close

---
 src/action/components.rs |  6 ++--
 src/action/mod.rs        |  4 +--
 src/action/systems.rs    | 69 ++++++++++++++++++++++++++++------------
 3 files changed, 53 insertions(+), 26 deletions(-)

diff --git a/src/action/components.rs b/src/action/components.rs
index 8ea7c9f..af6817c 100644
--- a/src/action/components.rs
+++ b/src/action/components.rs
@@ -68,9 +68,9 @@ pub struct CatControllerSettings {
 impl Default for CatControllerSettings {
     fn default() -> Self {
         Self {
-            kp: 40.0,
-            kd: 5.0,
-            ki: 0.1,
+            kp: 80.0,
+            kd: 10.0,
+            ki: 0.4,
         }
     }
 }
diff --git a/src/action/mod.rs b/src/action/mod.rs
index abb282a..af13e47 100644
--- a/src/action/mod.rs
+++ b/src/action/mod.rs
@@ -30,8 +30,8 @@ impl Plugin for CyberActionPlugin {
             .add_plugin(RapierPhysicsPlugin::<NoUserData>::default())
             .add_plugin(FrameTimeDiagnosticsPlugin::default())
             .add_system(surface_fix.label("surface_fix"))
-            .add_system(gravity.before("cat"))
-            .add_system(cyber_lean.before("cat"))
+            .add_system(gravity.label("gravity").before("cat"))
+            .add_system(cyber_lean.before("cat").after("gravity"))
             .add_system(falling_cat.label("cat"))
             .add_system(input_forces.label("iforces").after("cat"))
             .add_system(
diff --git a/src/action/systems.rs b/src/action/systems.rs
index 4a9501a..19b9ad9 100644
--- a/src/action/systems.rs
+++ b/src/action/systems.rs
@@ -1,4 +1,4 @@
-use std::f32::consts::PI;
+use std::f32::consts::{FRAC_PI_2, FRAC_PI_3, FRAC_PI_4};
 
 use bevy::prelude::{
     Commands, Entity, Quat, Query, Res, ResMut, Time, Transform, Vec3, With, Without,
@@ -19,7 +19,7 @@ use crate::{
 const PITCH_SCALE: f32 = 0.2;
 
 fn yaw_to_angle(yaw: f32) -> f32 {
-    yaw.powi(3) * (PI / 4.0)
+    yaw.powi(3) * FRAC_PI_4
 }
 
 /// The gravity vector points from the cyberbike to the center of the planet.
@@ -36,21 +36,40 @@ pub(super) fn gravity(
 
 /// The desired lean angle, given steering input and speed.
 pub(super) fn cyber_lean(
-    velocity: Query<&Velocity, With<CyberBikeBody>>,
+    mut bike_state: Query<
+        (
+            &Velocity,
+            &mut ExternalForce,
+            &Transform,
+            &ReadMassProperties,
+        ),
+        With<CyberBikeBody>,
+    >,
     wheels: Query<&Transform, With<CyberWheel>>,
     input: Res<InputState>,
     gravity_settings: Res<MovementSettings>,
     mut lean: ResMut<CyberLean>,
 ) {
-    let vel_squared = velocity.single().linvel.length_squared();
+    let (velocity, mut forces, xform, mass_props) = bike_state.single_mut();
+    let vel = velocity.linvel.dot(xform.forward());
+    let v_squared = vel.powi(2);
     let steering_angle = yaw_to_angle(input.yaw);
     let wheels: Vec<_> = wheels.iter().map(|w| w.translation).collect();
     let wheel_base = (wheels[0] - wheels[1]).length();
     let radius = wheel_base / steering_angle.tan();
     let gravity = gravity_settings.gravity;
-    let tan_theta = vel_squared / (radius * gravity);
+    let v2_r = v_squared / radius;
+    let tan_theta = (v2_r / gravity).clamp(-FRAC_PI_3, FRAC_PI_3);
 
-    lean.lean = (PI / 2.0) - tan_theta.atan();
+    let up = xform.translation.normalize();
+    let right = up.cross(xform.back()).normalize();
+
+    let centripetal = -right * (mass_props.0.mass * v2_r);
+
+    if v2_r.is_normal() {
+        forces.force += centripetal;
+        lean.lean = -tan_theta.atan().clamp(-FRAC_PI_4, FRAC_PI_4);
+    }
 }
 
 /// PID-based controller for stabilizing attitude; keeps the cyberbike upright.
@@ -62,15 +81,23 @@ pub(super) fn falling_cat(
     #[cfg(feature = "inspector")] mut debug_instant: ResMut<ActionDebugInstant>,
 ) {
     let (xform, mut forces, mut control_vars) = bike_query.single_mut();
-    let mut wup = Transform::from_translation(xform.translation);
-    wup.rotate(Quat::from_axis_angle(xform.back(), lean.lean));
-    let wup = wup.up();
+    let wup = xform.translation.normalize(); //Transform::from_translation(xform.translation.normalize());
+    let rot = Quat::from_axis_angle(xform.forward(), lean.lean);
+    let [x, y, z] = wup.to_array();
+    let qup = Quat::from_xyzw(x, y, z, 0.0); // turn our "world up" point into a Quat
+
+    // p' = rot^-1 * qup * rot
+    let wup = rot.inverse() * qup * rot;
+    let wup = Vec3::from_array([wup.x, wup.y, wup.z]).normalize();
     let bike_up = xform.up();
 
-    let wright = xform.forward().cross(wup).normalize();
+    let wright = xform
+        .forward()
+        .cross(xform.translation.normalize())
+        .normalize();
 
-    let roll_error = wright.dot(bike_up);
-    let pitch_error = wup.dot(xform.back());
+    let roll_error = wright.dot(wup);
+    let pitch_error = xform.translation.normalize().dot(xform.forward());
 
     // only try to correct roll if we're not totally vertical
     if pitch_error.abs() < 0.95 {
@@ -80,6 +107,13 @@ pub(super) fn falling_cat(
         if mag.is_finite() {
             forces.torque += xform.back() * mag;
         }
+        #[cfg(feature = "inspector")]
+        {
+            if debug_instant.elapsed().as_millis() > 5000 {
+                dbg!(&control_vars, mag, &wup);
+                debug_instant.reset();
+            }
+        }
     }
 
     // we can do pitch correction any time, it's not coupled to roll
@@ -89,17 +123,10 @@ pub(super) fn falling_cat(
     let mag =
         (settings.kp * scaled_pitch_error) + (settings.ki * integral) + (settings.kd * derivative);
     if mag.is_finite() {
-        forces.torque += wright * mag;
+        //forces.torque += wright * mag;
     }
 
-    #[cfg(feature = "inspector")]
-    {
-        if debug_instant.elapsed().as_millis() > 1000 {
-            dbg!(&control_vars, mag, &lean);
-            debug_instant.reset();
-        }
-    }
-    control_vars.decay();
+    //control_vars.decay();
 }
 
 /// Apply forces to the cyberbike as a result of input.

From 32db4fb383d803d292a31ce72b570c7722797484 Mon Sep 17 00:00:00 2001
From: Joe Ardent <code@ardent.nebcorp.com>
Date: Tue, 21 Feb 2023 12:47:24 -0800
Subject: [PATCH 07/13] working lean code

---
 src/action/systems.rs | 33 +++++++++++++++------------------
 1 file changed, 15 insertions(+), 18 deletions(-)

diff --git a/src/action/systems.rs b/src/action/systems.rs
index 19b9ad9..02208ce 100644
--- a/src/action/systems.rs
+++ b/src/action/systems.rs
@@ -67,8 +67,8 @@ pub(super) fn cyber_lean(
     let centripetal = -right * (mass_props.0.mass * v2_r);
 
     if v2_r.is_normal() {
-        forces.force += centripetal;
-        lean.lean = -tan_theta.atan().clamp(-FRAC_PI_4, FRAC_PI_4);
+        //forces.force += centripetal;
+        lean.lean = tan_theta.atan().clamp(-FRAC_PI_4, FRAC_PI_4);
     }
 }
 
@@ -81,23 +81,20 @@ pub(super) fn falling_cat(
     #[cfg(feature = "inspector")] mut debug_instant: ResMut<ActionDebugInstant>,
 ) {
     let (xform, mut forces, mut control_vars) = bike_query.single_mut();
-    let wup = xform.translation.normalize(); //Transform::from_translation(xform.translation.normalize());
-    let rot = Quat::from_axis_angle(xform.forward(), lean.lean);
-    let [x, y, z] = wup.to_array();
-    let qup = Quat::from_xyzw(x, y, z, 0.0); // turn our "world up" point into a Quat
-
+    let world_up = xform.translation.normalize();
+    let [x, y, z] = world_up.to_array();
+    // turn our "world up" point into a Quat
+    let qup = Quat::from_xyzw(x, y, z, 0.0);
     // p' = rot^-1 * qup * rot
-    let wup = rot.inverse() * qup * rot;
-    let wup = Vec3::from_array([wup.x, wup.y, wup.z]).normalize();
-    let bike_up = xform.up();
+    let rot = Quat::from_axis_angle(xform.back(), lean.lean);
+    let rot_qup = rot.inverse() * qup * rot;
+    let target_up = -Vec3::from_array([rot_qup.x, rot_qup.y, rot_qup.z]).normalize();
+    let bike_right = xform.right();
 
-    let wright = xform
-        .forward()
-        .cross(xform.translation.normalize())
-        .normalize();
+    //let world_right = xform.forward().cross(world_up).normalize();
 
-    let roll_error = wright.dot(wup);
-    let pitch_error = xform.translation.normalize().dot(xform.forward());
+    let roll_error = bike_right.dot(target_up);
+    let pitch_error = world_up.dot(xform.forward());
 
     // only try to correct roll if we're not totally vertical
     if pitch_error.abs() < 0.95 {
@@ -109,8 +106,8 @@ pub(super) fn falling_cat(
         }
         #[cfg(feature = "inspector")]
         {
-            if debug_instant.elapsed().as_millis() > 5000 {
-                dbg!(&control_vars, mag, &wup);
+            if debug_instant.elapsed().as_millis() > 1000 {
+                dbg!(&control_vars, mag, &target_up);
                 debug_instant.reset();
             }
         }

From 7fe4fbe423edbacf1b93e1459d7fda2e9441ad23 Mon Sep 17 00:00:00 2001
From: Joe Ardent <code@ardent.nebcorp.com>
Date: Tue, 21 Feb 2023 12:47:50 -0800
Subject: [PATCH 08/13] silence lint

---
 src/action/components.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/action/components.rs b/src/action/components.rs
index af6817c..705df20 100644
--- a/src/action/components.rs
+++ b/src/action/components.rs
@@ -15,10 +15,12 @@ impl Default for ActionDebugInstant {
 }
 
 impl ActionDebugInstant {
+    #[allow(dead_code)]
     pub fn reset(&mut self) {
         self.0 = Instant::now();
     }
 
+    #[allow(dead_code)]
     pub fn elapsed(&self) -> Duration {
         self.0.elapsed()
     }

From e9fed1940e11b0770572c41fd0ecc97f862d5150 Mon Sep 17 00:00:00 2001
From: Joe Ardent <code@ardent.nebcorp.com>
Date: Tue, 21 Feb 2023 13:25:55 -0800
Subject: [PATCH 09/13] re-enable pitch stabilization

---
 src/action/systems.rs | 28 ++++++----------------------
 1 file changed, 6 insertions(+), 22 deletions(-)

diff --git a/src/action/systems.rs b/src/action/systems.rs
index 02208ce..086bdb0 100644
--- a/src/action/systems.rs
+++ b/src/action/systems.rs
@@ -1,4 +1,4 @@
-use std::f32::consts::{FRAC_PI_2, FRAC_PI_3, FRAC_PI_4};
+use std::f32::consts::{FRAC_PI_3, FRAC_PI_4};
 
 use bevy::prelude::{
     Commands, Entity, Quat, Query, Res, ResMut, Time, Transform, Vec3, With, Without,
@@ -36,21 +36,13 @@ pub(super) fn gravity(
 
 /// The desired lean angle, given steering input and speed.
 pub(super) fn cyber_lean(
-    mut bike_state: Query<
-        (
-            &Velocity,
-            &mut ExternalForce,
-            &Transform,
-            &ReadMassProperties,
-        ),
-        With<CyberBikeBody>,
-    >,
+    bike_state: Query<(&Velocity, &Transform), With<CyberBikeBody>>,
     wheels: Query<&Transform, With<CyberWheel>>,
     input: Res<InputState>,
     gravity_settings: Res<MovementSettings>,
     mut lean: ResMut<CyberLean>,
 ) {
-    let (velocity, mut forces, xform, mass_props) = bike_state.single_mut();
+    let (velocity, xform) = bike_state.single();
     let vel = velocity.linvel.dot(xform.forward());
     let v_squared = vel.powi(2);
     let steering_angle = yaw_to_angle(input.yaw);
@@ -61,13 +53,7 @@ pub(super) fn cyber_lean(
     let v2_r = v_squared / radius;
     let tan_theta = (v2_r / gravity).clamp(-FRAC_PI_3, FRAC_PI_3);
 
-    let up = xform.translation.normalize();
-    let right = up.cross(xform.back()).normalize();
-
-    let centripetal = -right * (mass_props.0.mass * v2_r);
-
     if v2_r.is_normal() {
-        //forces.force += centripetal;
         lean.lean = tan_theta.atan().clamp(-FRAC_PI_4, FRAC_PI_4);
     }
 }
@@ -91,10 +77,10 @@ pub(super) fn falling_cat(
     let target_up = -Vec3::from_array([rot_qup.x, rot_qup.y, rot_qup.z]).normalize();
     let bike_right = xform.right();
 
-    //let world_right = xform.forward().cross(world_up).normalize();
+    let world_right = xform.forward().cross(world_up).normalize();
 
     let roll_error = bike_right.dot(target_up);
-    let pitch_error = world_up.dot(xform.forward());
+    let pitch_error = world_up.dot(xform.back());
 
     // only try to correct roll if we're not totally vertical
     if pitch_error.abs() < 0.95 {
@@ -120,10 +106,8 @@ pub(super) fn falling_cat(
     let mag =
         (settings.kp * scaled_pitch_error) + (settings.ki * integral) + (settings.kd * derivative);
     if mag.is_finite() {
-        //forces.torque += wright * mag;
+        forces.torque += world_right * mag;
     }
-
-    //control_vars.decay();
 }
 
 /// Apply forces to the cyberbike as a result of input.

From 8cd901dadc051d8f9eb3c0a90e4189418f37678b Mon Sep 17 00:00:00 2001
From: Joe Ardent <code@ardent.nebcorp.com>
Date: Tue, 21 Feb 2023 14:04:24 -0800
Subject: [PATCH 10/13] move quat rotation to fn

---
 src/action/systems.rs | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/action/systems.rs b/src/action/systems.rs
index 086bdb0..e3b0b0b 100644
--- a/src/action/systems.rs
+++ b/src/action/systems.rs
@@ -22,6 +22,17 @@ fn yaw_to_angle(yaw: f32) -> f32 {
     yaw.powi(3) * FRAC_PI_4
 }
 
+fn rotate_point(pt: &Vec3, rot: &Quat) -> Vec3 {
+    // thanks to https://danceswithcode.net/engineeringnotes/quaternions/quaternions.html
+    let [x, y, z] = pt.to_array();
+    let qpt = Quat::from_xyzw(x, y, z, 0.0);
+    // p' = rot^-1 * qpt * rot
+    let rot_qpt = rot.inverse() * qpt * *rot;
+
+    // why does this need to be inverted???
+    -Vec3::from_array([rot_qpt.x, rot_qpt.y, rot_qpt.z])
+}
+
 /// The gravity vector points from the cyberbike to the center of the planet.
 pub(super) fn gravity(
     mut query: Query<(&Transform, &mut ExternalForce), With<CyberBikeBody>>,
@@ -68,13 +79,9 @@ pub(super) fn falling_cat(
 ) {
     let (xform, mut forces, mut control_vars) = bike_query.single_mut();
     let world_up = xform.translation.normalize();
-    let [x, y, z] = world_up.to_array();
-    // turn our "world up" point into a Quat
-    let qup = Quat::from_xyzw(x, y, z, 0.0);
-    // p' = rot^-1 * qup * rot
     let rot = Quat::from_axis_angle(xform.back(), lean.lean);
-    let rot_qup = rot.inverse() * qup * rot;
-    let target_up = -Vec3::from_array([rot_qup.x, rot_qup.y, rot_qup.z]).normalize();
+    let target_up = rotate_point(&world_up, &rot).normalize();
+
     let bike_right = xform.right();
 
     let world_right = xform.forward().cross(world_up).normalize();

From 851f2fb65067ea047acf78bc61ae2905cb8c9a28 Mon Sep 17 00:00:00 2001
From: Joe Ardent <code@ardent.nebcorp.com>
Date: Tue, 21 Feb 2023 14:10:49 -0800
Subject: [PATCH 11/13] make lean calc more robust

---
 src/action/systems.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/action/systems.rs b/src/action/systems.rs
index e3b0b0b..88605c9 100644
--- a/src/action/systems.rs
+++ b/src/action/systems.rs
@@ -64,8 +64,10 @@ pub(super) fn cyber_lean(
     let v2_r = v_squared / radius;
     let tan_theta = (v2_r / gravity).clamp(-FRAC_PI_3, FRAC_PI_3);
 
-    if v2_r.is_normal() {
+    if tan_theta.is_finite() && !tan_theta.is_subnormal() {
         lean.lean = tan_theta.atan().clamp(-FRAC_PI_4, FRAC_PI_4);
+    } else {
+        lean.lean = 0.0;
     }
 }
 

From 881e6858dec76c5631d0668443eb36879e599dda Mon Sep 17 00:00:00 2001
From: Joe Ardent <code@ardent.nebcorp.com>
Date: Tue, 21 Feb 2023 14:22:43 -0800
Subject: [PATCH 12/13] unsmooth the planet

---
 src/bike/body.rs | 3 +--
 src/planet.rs    | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/bike/body.rs b/src/bike/body.rs
index be51f86..d841c14 100644
--- a/src/bike/body.rs
+++ b/src/bike/body.rs
@@ -16,8 +16,7 @@ pub(super) fn spawn_cyberbike(
     wheel_conf: Res<WheelConfig>,
     mut meshterials: Meshterial,
 ) {
-    //let altitude = PLANET_RADIUS - 180.0;
-    let altitude = PLANET_RADIUS + 10.0; // smoothland
+    let altitude = PLANET_RADIUS - 180.0;
 
     let mut xform = Transform::from_translation(Vec3::X * altitude)
         .with_rotation(Quat::from_axis_angle(Vec3::Z, -89.0f32.to_radians()));
diff --git a/src/planet.rs b/src/planet.rs
index e9076ef..8e6807b 100644
--- a/src/planet.rs
+++ b/src/planet.rs
@@ -87,7 +87,7 @@ fn gen_planet(sphere: Icosphere) -> (Mesh, Collider) {
         .iter()
         .map(|&p| {
             let disp = noise.get(p.as_dvec3().into()) as f32 * 0.04;
-            let pt = p; // + (p.normalize() * disp); // smoothland
+            let pt = p + (p.normalize() * disp);
             pt.into()
         })
         .collect::<Vec<[f32; 3]>>();

From b6fed0ea4d0bf911e7fd03e3121c17bf30af50d7 Mon Sep 17 00:00:00 2001
From: Joe Ardent <code@ardent.nebcorp.com>
Date: Tue, 21 Feb 2023 14:26:13 -0800
Subject: [PATCH 13/13] remove pitch stabilizing

---
 src/action/components.rs | 20 +-------------------
 src/action/systems.rs    | 14 --------------
 2 files changed, 1 insertion(+), 33 deletions(-)

diff --git a/src/action/components.rs b/src/action/components.rs
index 705df20..1652477 100644
--- a/src/action/components.rs
+++ b/src/action/components.rs
@@ -81,11 +81,8 @@ impl Default for CatControllerSettings {
 pub struct CatControllerState {
     pub roll_integral: f32,
     pub roll_prev: f32,
-    pub pitch_integral: f32,
-    pub pitch_prev: f32,
     decay_factor: f32,
     roll_limit: f32,
-    pitch_limit: f32,
 }
 
 impl Default for CatControllerState {
@@ -93,11 +90,8 @@ impl Default for CatControllerState {
         Self {
             roll_integral: Default::default(),
             roll_prev: Default::default(),
-            pitch_integral: Default::default(),
-            pitch_prev: Default::default(),
             decay_factor: 0.99,
             roll_limit: 1.5,
-            pitch_limit: 0.1,
         }
     }
 }
@@ -107,9 +101,6 @@ impl CatControllerState {
         if self.roll_integral.abs() > 0.001 {
             self.roll_integral *= self.decay_factor;
         }
-        if self.pitch_integral.abs() > 0.001 {
-            self.pitch_integral *= self.decay_factor;
-        }
     }
 
     pub fn update_roll(&mut self, error: f32, dt: f32) -> (f32, f32) {
@@ -120,16 +111,7 @@ impl CatControllerState {
         (derivative, self.roll_integral)
     }
 
-    pub fn update_pitch(&mut self, error: f32, dt: f32) -> (f32, f32) {
-        let lim = self.pitch_limit;
-        self.pitch_integral = (self.pitch_integral + (error * dt)).min(lim).max(-lim);
-        let derivative = (error - self.pitch_prev) / dt;
-        self.pitch_prev = error;
-        (derivative, self.pitch_integral)
-    }
-
-    pub fn set_integral_limits(&mut self, roll: f32, pitch: f32) {
+    pub fn set_integral_limits(&mut self, roll: f32) {
         self.roll_limit = roll;
-        self.pitch_limit = pitch;
     }
 }
diff --git a/src/action/systems.rs b/src/action/systems.rs
index 88605c9..f119bf5 100644
--- a/src/action/systems.rs
+++ b/src/action/systems.rs
@@ -16,8 +16,6 @@ use crate::{
     input::InputState,
 };
 
-const PITCH_SCALE: f32 = 0.2;
-
 fn yaw_to_angle(yaw: f32) -> f32 {
     yaw.powi(3) * FRAC_PI_4
 }
@@ -86,8 +84,6 @@ pub(super) fn falling_cat(
 
     let bike_right = xform.right();
 
-    let world_right = xform.forward().cross(world_up).normalize();
-
     let roll_error = bike_right.dot(target_up);
     let pitch_error = world_up.dot(xform.back());
 
@@ -107,16 +103,6 @@ pub(super) fn falling_cat(
             }
         }
     }
-
-    // we can do pitch correction any time, it's not coupled to roll
-    let scaled_pitch_error = pitch_error * PITCH_SCALE;
-    let (derivative, integral) =
-        control_vars.update_pitch(scaled_pitch_error, time.delta_seconds());
-    let mag =
-        (settings.kp * scaled_pitch_error) + (settings.ki * integral) + (settings.kd * derivative);
-    if mag.is_finite() {
-        forces.torque += world_right * mag;
-    }
 }
 
 /// Apply forces to the cyberbike as a result of input.