cyber_rider/src/physics.rs

use bevy::prelude::*;
use heron::prelude::*;

use crate::{geometry::CyberBike, input::InputState};

/// Mouse sensitivity and movement speed
pub struct MovementSettings {
    pub sensitivity: f32,
    pub accel: f32,
    pub drag: f32,
    pub gravity: f32,
}

impl Default for MovementSettings {
    fn default() -> Self {
        Self {
            sensitivity: 1.0,
            accel: 40.,
            drag: 0.0005,
            gravity: 10.0,
        }
    }
}

#[derive(Component, Default)]
pub(crate) struct PlayerState {
    pub velocity: Vec3,
    pub colliding: bool,
}

fn falling_cat(time: Res<Time>, mut bike_query: Query<(&mut Transform, &CyberBike)>) {
    let dt = time.delta_seconds();

    let (mut bike_xform, _) = bike_query.single_mut();
    let up = bike_xform.translation.normalize();
    let cam_up = bike_xform.up();
    let cos = up.dot(cam_up);

    let theta = cos.acos();
    let rate = if !theta.is_normal() {
        0.0
    } else if theta.is_sign_negative() {
        -0.4
    } else {
        0.4
    } * dt;
    let angle = if rate.is_sign_negative() {
        rate.max(theta)
    } else {
        rate.min(theta)
    };

    let rot = Quat::from_axis_angle(cam_up.cross(up).normalize(), angle);

    if rot.is_finite() && theta.abs() > 0.0085 {
        bike_xform.rotate(rot);
    }
}

fn apply_velocity(
    time: Res<Time>,
    mut bike_query: Query<(&mut Transform, &PlayerState, &CyberBike)>,
) {
    let dt = time.delta_seconds();

    let (mut bike_xform, player_state, _) = bike_query.single_mut();

    if player_state.velocity.is_finite() {
        bike_xform.translation += player_state.velocity * dt;
    }
}

fn update_player_vel(
    time: Res<Time>,
    settings: Res<MovementSettings>,
    input: Res<InputState>,
    mut query: Query<(&Transform, &mut PlayerState, &CyberBike)>,
) {
    let dt = time.delta_seconds();
    let (xform, mut pstate, _) = query.single_mut();

    // first gravity
    let down = -xform.translation.normalize();
    let dvel = down * settings.gravity * dt;
    let mut vel = if pstate.velocity.is_finite() {
        pstate.velocity + dvel
    } else {
        dvel
    };

    // thrust or brake
    let accel = xform.forward() * input.throttle * dt * settings.accel;
    if pstate.velocity.is_finite() {
        vel += accel;
    } else {
        vel = accel;
    }

    // brake
    if input.brake {
        let s = vel.length_squared();
        if s < 0.05 {
            vel = Vec3::ZERO;
        } else {
            vel -= vel.normalize() * settings.accel * dt;
        }
    }

    // drag
    let v2 = vel.length_squared().min(100_000.0);
    if v2 < 0.05 {
        vel = Vec3::ZERO;
    } else {
        let drag = vel * settings.drag * v2 * dt;
        vel -= drag;
    }

    pstate.velocity = vel;
}

fn collision_detection(
    mut events: EventReader<CollisionEvent>,
    mut query: Query<&mut PlayerState>,
) {
    let mut pstate = query.single_mut();

    for event in events.iter() {
        if let CollisionEvent::Started(_, _) = event {
            pstate.colliding = true;
        } else {
            pstate.colliding = false;
        }
    }
}

fn collision_reaction(mut query: Query<(&mut PlayerState, &Transform)>) {
    let (mut pstate, xform) = query.single_mut();

    let down = -xform.translation.normalize();

    // now see if we're currently colliding
    if pstate.colliding {
        let vel = pstate.velocity;
        let dvel = down * vel.dot(down) * 1.02;
        pstate.velocity -= dvel;
    }
}

pub struct CyberPhysicsPlugin;
impl Plugin for CyberPhysicsPlugin {
    fn build(&self, app: &mut App) {
        app.init_resource::<PlayerState>()
            .init_resource::<MovementSettings>()
            .add_plugin(PhysicsPlugin::default())
            .add_system(collision_detection)
            .add_system(collision_reaction)
            .add_system(falling_cat)
            .add_system(update_player_vel)
            .add_system(apply_velocity);
    }
}