parsnip_plucker/src/physics.rs

/// This module is intended to be used as a fixed-point physics system.
/// The hope is that this will make deterministic physics easier,
/// and therefore networking a bit less of a pain.
use bevy::{math::I64Vec2, prelude::*};

const FIXED_UPDATE_INTERVAL_MS: u128 = 10; // 100 fps physics

#[derive(Default, Debug)]
pub struct Physics2DPlugin;

#[derive(Default, Debug, Resource)]
pub struct Physics2DWorld {
    pub last_update: u128,
}

impl Plugin for Physics2DPlugin {
    fn build(&self, app: &mut bevy::app::App) {
        app.insert_resource(Physics2DWorld::default())
            .add_systems(Update, tick_physics);
    }
}

fn tick_physics(
    mut query: Query<&mut PhysicsBody2D>,
    mut p_world: ResMut<Physics2DWorld>,
    time: Res<Time>,
) {
    let t = time.elapsed().as_millis();
    let delta_t = t - p_world.last_update;

    if delta_t < FIXED_UPDATE_INTERVAL_MS {
        return;
    }

    p_world.last_update = t;

    query.iter_mut().for_each(|mut pb| {
        pb.tick(delta_t as i64);
    });
}

#[derive(Default, Debug, Component)]
pub struct PhysicsBody2D {
    pub pos: I64Vec2,
    pub vel: I64Vec2,
}

impl PhysicsBody2D {
    pub fn tick(&mut self, delta_t: i64) {
        self.pos += self.vel * delta_t;
    }

    pub fn apply_force(&mut self, force: I64Vec2, term_speed: Option<i64>) {
        let mut vel = self.vel + force;
        let Some(max_speed) = term_speed else {
            return;
        };
        if vel.length_squared() >= max_speed.pow(2) {
            let l = vel.length_squared();
            let x = vel.x * vel.x;
            let y = vel.y * vel.y;

            vel.x = match vel.x {
                ..0 => (x * -max_speed) / l,
                _ => (x * max_speed) / l,
            };
            vel.y = match vel.y {
                ..0 => (y * -max_speed) / l,
                _ => (y * max_speed) / l,
            };
        }
        self.vel = vel;
    }
}