use crate::movement;

            &mut Transform,

            &mut movement::Moveable,

            &mut movement_pointer::MovementDirection,

    time: Res<Time>,

    for (action_state, mut transform, maybe_sprite, dash, mut md) in query.iter_mut() {

    for (action_state, mut moveable, maybe_sprite, dash) in query.iter_mut() {

                transform.translation += movement_norm.extend(0.0) * speed * time.delta_seconds();
                md.0 = movement_norm;
                md.1 = speed;

                moveable.velocity = movement_norm * speed;

                md.0 = Vec2::ZERO;
                md.1 = 0.0;

                moveable.velocity = Vec2::ZERO;

    pub(crate) moveable: movement::Moveable,

            moveable: default(),

//! Handles moving things *and* them colliding
use bevy::prelude::*;
use crate::movement_pointer;
#[derive(Component)]
pub struct Moveable {
    pub velocity: Vec2,
}
impl Default for Moveable {
    fn default() -> Self {
        Self {
            velocity: default(),
        }
    }
}
pub fn update_transform(
    mut query: Query<(
        &mut Transform,
        &Moveable,
        Option<&mut movement_pointer::MovementDirection>,
    )>,
    time: Res<Time>,
) {
    for (mut transform, moveable, maybe_pointer) in query.iter_mut() {
        // If we have a movement pointer, update it
        if let Some(mut pointer) = maybe_pointer {
            pointer.0 = moveable.velocity.normalize_or_zero();
            pointer.1 = moveable.velocity.length();
        }
        // Update transform
        transform.translation += moveable.velocity.extend(0.0) * time.delta_seconds();
    }
}

mod movement;

            // Shader plugins
            post_process::ChromaticAberrationPlugin,

            // Our "subplugins"
            camera::CameraPlugin,

// TODO Don't be afraid of Plugins that add Plugins! Modularize!

            .add_systems(Startup, camera::setup_camera)

                    camera::update_camera,

            .add_systems(
                FixedUpdate,
                (camera::update_camera).run_if(in_state(GameState::InRun)),
            )

            .add_systems(FixedUpdate, movement::update_transform)
            // configure our fixed timestep schedule to run 60 times per second
            .insert_resource(Time::<Fixed>::from_seconds(60.0f64.recip()))

use std::time::Duration;

pub struct CameraPlugin;
impl Plugin for CameraPlugin {
    fn build(&self, app: &mut App) {
        app.add_plugins((
            // Shader plugins
            post_process::ChromaticAberrationPlugin,
        ))
        .init_resource::<CameraRig>()
        .add_systems(Startup, setup_camera)
        .add_systems(FixedUpdate, update_camera);
    }
}

#[derive(Resource)]
pub struct CameraRig {
    lag: f32,
    /// how long should the lerp take?
    pub snap_duration: Duration,
}
impl CameraRig {
    /// Camera lag - [0.0, 1.0) lower is snappier, higher is smoother
    pub fn lag(&self) -> f32 {
        self.lag
    }
    pub fn set_lag(&mut self, lag: f32) {
        self.lag = lag.clamp(0.0, 1.0 - f32::EPSILON);
    }
}
impl Default for CameraRig {
    fn default() -> Self {
        Self {
            lag: 0.7,
            snap_duration: Duration::from_secs_f32(10f32.recip()),
        }
    }
}

pub(crate) struct Camera;

struct Camera;

pub(crate) struct CameraBundle {
    pub(crate) camera: Camera,
    pub(crate) camera_2d: Camera2dBundle,
    pub(crate) pixel_camera: PixelCamera,

struct CameraBundle {
    camera: Camera,
    camera_2d: Camera2dBundle,
    pixel_camera: PixelCamera,

    pub(crate) chroma_aberration: post_process::ChromaticAberattionSettings,

    chroma_aberration: post_process::ChromaticAberattionSettings,

pub(crate) fn setup_camera(mut commands: Commands) {

fn setup_camera(mut commands: Commands) {

pub(crate) fn update_camera(

fn update_camera(

    rig: Res<CameraRig>,
    time: Res<Time>,

            let diff = goal - source;
            let lerped = source + diff * 0.1; //* time.delta_seconds();
            camera.subpixel_pos = lerped.xy();

            let adjusted_lag = rig.lag;
            let lerped = source * adjusted_lag + goal * (1.0 - adjusted_lag);
            let lerp_delta = lerped - source;
            camera.subpixel_pos +=
                lerp_delta.xy() * time.delta_seconds() / rig.snap_duration.as_secs_f32();

        <link data-trunk rel="rust" data-cargo-features="webgl" />

        <link data-trunk rel="rust" data-cargo-features="webgpu webgl" />