use crate::camera_controller::CameraController;

    commands.spawn((
        Camera3dBundle {
            transform: Transform::from_xyz(0.0, 0.0, 0.0),
            ..default()
        },
        CameraController::default(),
        Skybox {
            image: skybox.clone(),
            brightness: 100.0,
        },
    ));

    commands.spawn(Skybox {
        image: skybox.clone(),
        brightness: 100.0,
    });

use bevy::prelude::*;

use bevy::{prelude::*, render::render_resource::AsBindGroupShaderType};
use leafwing_input_manager::prelude::*;
use crate::input::{self, Action};
#[derive(Component)]
pub struct Player {
    joy: Vec2,
}

    let player_transform = Transform::from_xyz(0.0, 0.0, 0.0);
    let camera_transform = Transform::from_xyz(0.0, 8.0, 20.0);

            transform: Transform::from_xyz(0.0, 0.0, 0.0),

            transform: player_transform.clone(),

        .insert(InputManagerBundle::with_map(input::default_input_map()))
        .insert(Player { joy: Vec2::ZERO })

        .insert(RigidBody::default());

        .insert(RigidBody::Dynamic)
        .insert(ExternalForce::default().with_persistence(false))
        .insert(ExternalTorque::default().with_persistence(false))
        .insert(LinearDamping(0.01))
        .insert(AngularDamping(3.0))
        .with_children(|parent| {
            parent.spawn(Camera3dBundle {
                transform: camera_transform,
                ..default()
            });
        });
}
pub fn move_player(
    mut query: Query<(
        &mut Player,
        &Transform,
        &mut ExternalForce,
        &mut ExternalTorque,
        &LinearVelocity,
        &ActionState<Action>,
    )>,
    time: Res<Time>,
) {
    let speed = 100.0;
    let key_multiplier = 10.0;
    let turn_speed = 0.1;
    let dt = time.delta_seconds();
    let (mut player, xform, mut force, mut torque, velocity, actions) = query.single_mut();
    let strafe = actions.axis_pair(&Action::StrafeXZ);
    let mut momentum = key_multiplier
        * (xform.right().as_vec3() * strafe[0] + xform.forward().as_vec3() * strafe[1]);
    if actions.pressed(&Action::StrafePosX) {
        momentum = momentum + key_multiplier * xform.right().as_vec3();
    }
    if actions.pressed(&Action::StrafeNegX) {
        momentum = momentum + key_multiplier * xform.left().as_vec3();
    }
    if actions.pressed(&Action::StrafePosY) {
        momentum = momentum + key_multiplier * xform.up().as_vec3();
    }
    if actions.pressed(&Action::StrafeNegY) {
        momentum = momentum + key_multiplier * xform.down().as_vec3();
    }
    if actions.pressed(&Action::StrafePosZ) {
        momentum = momentum + key_multiplier * xform.forward().as_vec3();
    }
    if actions.pressed(&Action::StrafeNegZ) {
        momentum = momentum + key_multiplier * xform.back().as_vec3();
    }
    force.apply_force(momentum * speed * dt);
    let py = actions.axis_pair(&Action::PitchYaw);
    player.joy += py;
    if actions.pressed(&Action::Brake) {
        player.joy = Vec2::ZERO;
        momentum += (-0.5 * dt * velocity.0);
    }
    player.joy.clamp(Vec2::splat(-1.0), Vec2::splat(1.0));
    if player.joy.length() < 0.1 {
        player.joy = Vec2::ZERO;
    }
    torque.apply_torque(
        dt * turn_speed * (xform.down() * player.joy.x + xform.left() * player.joy.y),
    );
    let mut roll = 0.0;
    if actions.pressed(&Action::PosRoll) {
        roll += turn_speed;
    }
    if actions.pressed(&Action::NegRoll) {
        roll -= turn_speed;
    }
    torque.apply_torque(key_multiplier * xform.forward() * dt * roll);

use bevy::prelude::*;

use avian3d::prelude::*;
use bevy::{log::tracing_subscriber::util::SubscriberInitExt, prelude::*};
use leafwing_input_manager::plugin::InputManagerPlugin;

        .add_plugins(camera_controller::CameraControllerPlugin)

        .add_plugins(PhysicsPlugins::default())
        .add_plugins(InputManagerPlugin::<input::Action>::default())

        .add_systems(Startup, player::set_up_player)

        .add_systems(FixedUpdate, player::move_player)
        .insert_resource(Gravity::ZERO)

use bevy::log::tracing_subscriber::util::SubscriberInitExt;

    Brake,

pub fn input_bundle() -> InputManagerBundle<Action> {

pub fn default_input_map() -> InputMap<Action> {

    input_map.insert(Action::Brake, KeyCode::KeyX);

    input_map.insert_dual_axis(Action::PitchYaw, MouseMove::default());
    input_map
}
pub fn input_bundle() -> InputManagerBundle<Action> {
    let input_map = default_input_map();