&mut movement::Moveable,

            &mut movement::Movable,

    moveable: movement::Moveable,

    moveable: movement::Movable,

                ..default()

use crate::movement;

    // highest speed we expect movement-pointered stuff to move at
    const MAX_SPEED: f32 = 1000.0;

                let mixed = lerp_mix(MIN_COLOR, MAX_COLOR, md.1 / MAX_SPEED);

                let mixed = lerp_mix(MIN_COLOR, MAX_COLOR, md.1 / movement::MAX_SPEED);

                // In case we hid the element before
                *vis = Visibility::Inherited;

                *vis = if md.1 > movement::MIN_SPEED * 10. {
                    Visibility::Inherited
                } else {
                    Visibility::Hidden
                };

                        + MAX_POINTER_DELTA * (md.1 / MAX_SPEED).clamp(0.0, 1.0)))

                        + MAX_POINTER_DELTA * (md.1 / movement::MAX_SPEED).clamp(0.0, 1.0)))

        app.add_systems(FixedUpdate, update_transform.in_set(Movement));

        app.add_systems(
            FixedUpdate,
            (fake_friction, update_velocity, update_transform)
                .chain()
                .in_set(Movement),
        );

pub struct Moveable {

pub struct Movable {

    pub acceleration: Vec2,
    pub mass: f32,

impl Default for Moveable {

impl Default for Movable {

            acceleration: default(),
            mass: 1.0,

fn update_transform(

/// Speeds below this should be considered 0.
pub const MIN_SPEED: f32 = 1.0;
// highest speed we expect movement-pointered stuff to move at
pub const MAX_SPEED: f32 = 1000.0;
fn fake_friction(mut query: Query<&mut Movable>) {
    // TODO Allow this to be determined by tiles!
    // This should range from 0.0 to 1.0
    const MU: f32 = 0.7;
    const MU_STATIC: f32 = 0.9;
    const GRAVITY: f32 = 9.8; // m/s^2 on Earth, TODO adjust for feel
    for mut movable in query.iter_mut() {
        let speed = movable.velocity.length();
        if let Some(vnorm) = movable.velocity.try_normalize() {
            // Friction = mu * N where N is the normal force
            // we assume the only normal force is gravity.
            // so friction in our system is
            // mu * mass * gravity
            let mass = movable.mass;
            let friction_magnitude =
                if speed <= MIN_SPEED { MU_STATIC } else { MU } * mass.max(1.0) * GRAVITY;
            movable.acceleration += -vnorm * friction_magnitude;
        }
    }
}
fn update_velocity(

        &mut Transform,
        &Moveable,

        &mut Movable,

    for (mut transform, moveable, maybe_pointer) in query.iter_mut() {

    for (mut movable, maybe_pointer) in query.iter_mut() {
        let acceleration = movable.acceleration;
        movable.velocity += acceleration * time.delta_seconds();
        // Reset accel
        movable.acceleration = Vec2::ZERO;

            pointer.0 = moveable.velocity.normalize_or_zero();
            pointer.1 = moveable.velocity.length();

            pointer.0 = movable.velocity.normalize_or_zero();
            pointer.1 = movable.velocity.length();

    }
}
fn update_transform(mut query: Query<(&mut Transform, &Movable)>, time: Res<Time>) {
    for (mut transform, moveable) in query.iter_mut() {

use crate::{camera, collision, movement_pointer, GameState};

use crate::{camera, collision, movement, movement_pointer, GameState};

            // is_static: true,
            ..default()

    polly: Query<(Entity, Option<&camera::CameraTarget>), With<Polly>>,

    mut polly: Query<
        (
            Entity,
            Option<&camera::CameraTarget>,
            Option<&mut movement::Movable>,
        ),
        With<Polly>,
    >,

            let (polly_entity, cam_target) = polly.single();

            let (polly_entity, cam_target, movable) = polly.single_mut();

            }
            if let Some(mut movable) = movable {
                if ui.button("Static").clicked() {
                    commands.entity(polly_entity).remove::<movement::Movable>();
                }
                ui.add(egui::Slider::new(&mut movable.mass, 5.0..=100.0).text("Mass"));
            } else if ui.button("Dynamic").clicked() {
                commands.entity(polly_entity).insert(movement::Movable {
                    mass: 20.0,
                    ..default()
                });

            .add_systems(FixedUpdate, resolve_collisions.after(movement::Movement));

            .add_systems(FixedUpdate, resolve_collisions.before(movement::Movement));

    /// Can this object be moved by collision? true if not
    pub is_static: bool,

    mut query: Query<(Entity, &GlobalTransform, &mut Transform, &mut Collidable)>,

    mut query: Query<(
        Entity,
        &GlobalTransform,
        &mut Collidable,
        Option<&mut movement::Movable>,
    )>,

        [(entity, gtransform, mut transform, collidable), (oentity, ogtransform, mut otransform, ocollidable)],

        [(entity, gtransform, collidable, movable), (oentity, ogtransform, ocollidable, omovable)],

            let mtv = (axis * magnitude * (oaabb_min_proj - aabb_min_proj).signum()).extend(0.0);
            match (collidable.is_static, ocollidable.is_static) {

            let mtv = axis * magnitude * (oaabb_min_proj - aabb_min_proj).signum();
            const IMPULSE: f32 = 5_000.0;
            // TODO This does not handle rotation, cuz we assume we can't do that.
            match (movable, omovable) {

                (true, true) => continue,
                (true, false) => {

                (None, None) => continue,
                (None, Some(mut omovable)) => {

                    otransform.translation += mtv;

                    // otransform.translation += mtv;
                    let mass = omovable.mass.max(1.0);
                    omovable.acceleration += mtv * mass.recip() * IMPULSE;

                (false, true) => {

                (Some(mut movable), None) => {

                    transform.translation += mtv;

                    let mass = movable.mass.max(1.0);
                    movable.acceleration += mtv * mass.recip() * IMPULSE;

                (false, false) => {

                (Some(mut movable), Some(mut omovable)) => {

                    transform.translation -= mtv / 2.;
                    otransform.translation += mtv / 2.;

                    let mass = movable.mass.max(1.0);
                    let omass = omovable.mass.max(1.0);
                    movable.acceleration += mtv * -IMPULSE * mass.recip();
                    omovable.acceleration += mtv * IMPULSE * omass.recip();