sjqmmo_lib/

lib.rs

use std::time::Duration;

use bevy::{
    audio::PlaybackMode,
    core_pipeline::{bloom::BloomSettings, tonemapping::Tonemapping},
    input::keyboard,
    pbr::{NotShadowCaster, NotShadowReceiver},
    prelude::*,
    render::render_resource::{Extent3d, TextureDimension, TextureFormat},
    window::{CursorGrabMode, WindowMode},
};
use bevy_third_person_camera::{
    ThirdPersonCamera, ThirdPersonCameraPlugin, ThirdPersonCameraTarget, Zoom,
};
const USER_GROUP: Group = Group::GROUP_4;
const PLANE_GROUP: Group = Group::GROUP_5;
const BOX_GROUP: Group = Group::GROUP_2;
const EXPLODER_GROUP: Group = Group::GROUP_3;

use bevy_rapier3d::prelude::*;
use rand::Rng;
#[derive(Component, Reflect)]
struct Cube {
    max_speed: f32,
    max_acceleration: f32,
}

#[derive(Component, Reflect)]
struct JumpControl {
    jump: bool,
    remaining_jumps: u8,
    jump_speed: f32,
}

#[derive(States, Debug, Default, Hash, PartialEq, Eq, Clone, Copy)]
enum GameState {
    #[default]
    Init,
    Splash,
}

#[bevy_main]
pub fn main() {
    App::new()
        .add_plugins(
            DefaultPlugins
                .set(ImagePlugin::default_nearest())
                .set(WindowPlugin {
                    primary_window: Some(Window {
                        canvas: Some("#game".to_string()),
                        fit_canvas_to_parent: true,
                        mode: WindowMode::BorderlessFullscreen,
                        ..Default::default()
                    }),
                    ..Default::default()
                }),
        )
        .add_plugins(RapierPhysicsPlugin::<NoUserData>::default())
        .add_state::<GameState>()
        // .add_plugins(FrameTimeDiagnosticsPlugin)
        // .add_plugins(LogDiagnosticsPlugin::default())
        // .add_plugins(RapierDebugRenderPlugin::default())
        // .add_plugins(WorldInspectorPlugin::default())
        .register_type::<Cube>()
        .register_type::<JumpControl>()
        .add_plugins(ThirdPersonCameraPlugin)
        .add_systems(Startup, startup)
        .add_systems(
            Update,
            (
                // update,
                cube_move_keyboard,
                cude_move_gamepad,
                // cube_limit,
                reset_jump,
                cube_jump,
                move_elevator,
            ),
        )
        .add_systems(Update, touch_sensor.run_if(in_state(GameState::Init)))
        .add_systems(
            Update,
            (
                launch,
                destroy,
                explode,
                assend,
                launch_superball,
                add_collider,
            )
                .run_if(in_state(GameState::Splash)),
        )
        .add_systems(OnEnter(GameState::Splash), splash_init)
        .run();
}

#[derive(Component)]
struct DestroyCountdown(f32);

fn destroy(
    mut commands: Commands,
    mut items: Query<(Entity, &mut DestroyCountdown)>,
    time: Res<Time>,
) {
    let delta = time.delta_seconds();
    for (e, mut d) in items.iter_mut() {
        d.0 -= delta;
        if d.0 < 0.0 {
            commands.entity(e).despawn();
        }
    }
}

#[derive(Component)]
struct ExplodCountDown(f32);

#[derive(Component)]
struct AddColliderCountDown(Timer);

#[derive(Resource)]
struct FireWorkMeshes {
    splash_meshes: Vec<Handle<Mesh>>,
    meshes: Vec<Handle<Mesh>>,
    ball_matierials: Vec<Handle<StandardMaterial>>,
    splash_mat: Vec<Handle<StandardMaterial>>,
}

#[derive(Component, Debug, Clone)]
enum FireWorkType {
    White,
    Random,
}

#[derive(Component, Debug, Clone)]
struct FireWorkProps {
    range: f32,
    num: usize,
    count_down: f32,
    scale: f32,
    add_collider: Option<f32>,
    remaining_splash: Option<Box<FireWorkProps>>,
    fire_work_type: FireWorkType,
}

#[derive(Component)]
struct Assending {
    speed: f32,
}

#[derive(Resource)]
struct SplashTimer(Timer);

fn add_collider(
    mut commands: Commands,
    mut items: Query<(Entity, &mut AddColliderCountDown)>,
    time: Res<Time>,
) {
    let delta = time.delta();
    for (e, mut d) in items.iter_mut() {
        d.0.tick(delta);
        if d.0.just_finished() {
            commands.entity(e).insert((
                Collider::cuboid(1., 1., 1.),
                CollisionGroups::new(EXPLODER_GROUP, PLANE_GROUP),
            ));
        }
    }
}

fn assend(time: Res<Time>, mut items: Query<(&mut Transform, &Assending)>) {
    let delta = time.delta_seconds();
    for (mut t, a) in items.iter_mut() {
        t.translation.y += a.speed * delta;
    }
}

fn explode(
    mut commands: Commands,
    time: Res<Time>,
    mut items: Query<(&mut ExplodCountDown, Entity, &FireWorkProps, &mut Transform)>,
    fire_work_meshs: Res<FireWorkMeshes>,
) {
    let delta = time.delta_seconds();
    for (mut cd, et, fs, ts) in items.iter_mut() {
        let FireWorkProps {
            range,
            num,
            count_down,
            scale,
            add_collider,
            remaining_splash,
            fire_work_type,
        } = fs;
        cd.0 -= delta;
        if cd.0 < 0. {
            commands.entity(et).despawn();
            let mut rng = rand::thread_rng();
            // spawn 100 splash
            for _i in 0..*num {
                let init_speed = Vec3::new(
                    rng.gen_range(-1. ..1.),
                    rng.gen_range(-1. ..1.),
                    rng.gen_range(-1. ..1.),
                );
                let mut cmd = commands.spawn((
                    {
                        let material = match fire_work_type {
                            FireWorkType::White => fire_work_meshs.splash_mat[0].clone(),
                            FireWorkType::Random => {
                                fire_work_meshs.splash_mat[rng.gen_range(0..100)].clone()
                            }
                        };
                        PbrBundle {
                            mesh: fire_work_meshs.splash_meshes[rng.gen_range(0..100)].clone(),
                            material,
                            transform: Transform::from_translation(ts.translation)
                                .with_scale(Vec3::splat(*scale)),
                            ..Default::default()
                        }
                    },
                    Velocity {
                        linvel: init_speed * *range,
                        ..Default::default()
                    },
                    NotShadowCaster,
                    NotShadowReceiver,
                    RigidBody::Dynamic,
                ));
                if let Some(time) = add_collider {
                    cmd.insert(AddColliderCountDown(Timer::new(
                        Duration::from_secs_f32(*time),
                        TimerMode::Once,
                    )));
                }
                if let Some(remaining_splash) = remaining_splash {
                    // it will explode again!
                    let remaining_splash = (**remaining_splash).clone();
                    cmd.insert((remaining_splash, ExplodCountDown(*count_down)));
                } else {
                    // just destroy it!
                    cmd.insert(DestroyCountdown(*count_down));
                }
            }
            // let range = fs.1;
        }
    }
}

fn launch_superball(
    mut commands: Commands,
    time: Res<Time>,
    mut timer: ResMut<SuperBigBallTimer>,
    superball: Query<Entity, With<SuperBall>>,
) {
    timer.timer.tick(time.delta());
    if timer.timer.just_finished() {
        println!("launch super ball");
        let super_ball = superball.single();
        let mut super_ball = commands.entity(super_ball);
        super_ball.insert((
            ExplodCountDown(25.),
            FireWorkProps {
                range: 1500.,
                num: 500,
                count_down: 10.,
                scale: 10.,
                add_collider: Some(1.),
                remaining_splash: Some(Box::new(FireWorkProps {
                    range: 500.,
                    num: 10,
                    count_down: 22.,
                    scale: 6.,
                    add_collider: None,
                    remaining_splash: None,
                    fire_work_type: FireWorkType::White,
                })),
                fire_work_type: FireWorkType::Random,
            }, // FireWorkSpeedRange(150., 5000., 1000, 20.),
            Assending { speed: 150. },
        ));
    }
}

fn launch(
    mut commands: Commands,
    time: Res<Time>,
    mut timer: ResMut<SplashTimer>,
    fire_work_meshs: Res<FireWorkMeshes>,
    superball_timer: Res<SuperBigBallTimer>,
) {
    timer.0.tick(time.delta());
    if timer.0.just_finished() && !superball_timer.timer.finished() {
        let mut gen = rand::thread_rng();
        let mesh_id: usize = gen.gen_range(0..100);
        let mat_id: usize = gen.gen_range(0..100);
        let speed: f32 = gen.gen_range(300. ..1000.);
        let range: f32 = gen.gen_range(300. ..2000.);
        let cool_down: f32 = gen.gen_range(2. ..5.);
        commands.spawn((
            NotShadowCaster,
            NotShadowReceiver,
            PbrBundle {
                mesh: fire_work_meshs.meshes[mesh_id].clone(),
                material: fire_work_meshs.ball_matierials[mat_id].clone(),
                transform: Transform::from_translation(Vec3::new(
                    gen.gen_range(-200. ..200.),
                    0.,
                    gen.gen_range(-3500. ..-1000.),
                )),
                ..Default::default()
            },
            ExplodCountDown(cool_down),
            // FireWorkSpeedRange(speed, range, 100, 5.),
            FireWorkProps {
                range,
                num: 30,
                count_down: 2.5,
                scale: 1.,
                add_collider: Some(0.3),
                remaining_splash: Some(Box::new(FireWorkProps {
                    range: 100.,
                    num: 5,
                    count_down: 1.,
                    scale: 1.,
                    add_collider: None,
                    remaining_splash: None,
                    fire_work_type: FireWorkType::White,
                })),
                fire_work_type: FireWorkType::Random,
            },
            Assending { speed },
        ));
    }
}

#[derive(Resource)]
struct SuperBigBallTimer {
    timer: Timer,
}

fn splash_init(
    mut commands: Commands,
    mut meshs: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    asset_server: Res<AssetServer>,
) {
    commands.insert_resource(SplashTimer(Timer::new(
        Duration::from_secs(1),
        TimerMode::Repeating,
    )));
    commands.insert_resource(SuperBigBallTimer {
        timer: Timer::new(Duration::from_secs(60), TimerMode::Once),
    });
    commands.spawn(AudioBundle {
        source: asset_server.load("sounds/back.ogg"),
        settings: PlaybackSettings {
            mode: PlaybackMode::Once,
            ..Default::default()
        },
    });
    let mut mesh_res = FireWorkMeshes {
        splash_meshes: vec![],
        meshes: vec![],
        ball_matierials: vec![],
        splash_mat: vec![],
    };
    // put the default value
    mesh_res.splash_meshes.push(
        meshs.add(
            shape::UVSphere {
                radius: rand::thread_rng().gen_range(2.5..5.0),
                sectors: 16,
                stacks: 16,
            }
            .into(),
        ),
    );
    mesh_res.meshes.push(
        meshs.add(
            shape::UVSphere {
                radius: rand::thread_rng().gen_range(2.5..25.0),
                sectors: 16,
                stacks: 16,
            }
            .into(),
        ),
    );
    mesh_res
        .ball_matierials
        .push(materials.add(StandardMaterial {
            emissive: Color::rgb_linear(5., 5., 5.),
            ..Default::default()
        }));
    mesh_res.splash_mat.push(materials.add(StandardMaterial {
        emissive: Color::rgb_linear(10., 10., 10.),
        ..Default::default()
    }));
    let mut rng = rand::thread_rng();
    for _i in 1..100 {
        mesh_res.meshes.push(
            meshs.add(
                shape::UVSphere {
                    radius: rand::thread_rng().gen_range(2.5..25.0),
                    sectors: 16,
                    stacks: 16,
                }
                .into(),
            ),
        );
        mesh_res
            .ball_matierials
            .push(materials.add(StandardMaterial {
                emissive: Color::rgb_linear(
                    rng.gen_range(0.1..5.),
                    rng.gen_range(0.1..5.),
                    rng.gen_range(0.1..5.),
                ),
                ..Default::default()
            }));
        mesh_res.splash_mat.push(materials.add(StandardMaterial {
            emissive: Color::rgb_linear(
                rng.gen_range(0.1..15.),
                rng.gen_range(0.1..15.),
                rng.gen_range(0.1..15.),
            ),
            ..Default::default()
        }));
        let rect: bool = rng.gen();
        if rect {
            mesh_res
                .splash_meshes
                .push(meshs.add(shape::Cube::new(rng.gen_range(2.5..5.0)).into()));
        } else {
            mesh_res.splash_meshes.push(
                meshs.add(
                    shape::UVSphere {
                        radius: rand::thread_rng().gen_range(2.5..5.0),
                        sectors: 16,
                        stacks: 16,
                    }
                    .into(),
                ),
            );
        }
    }

    commands.insert_resource(mesh_res);
}
fn startup(
    mut commands: Commands,
    mut meshs: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    mut windows: Query<&mut Window>,
    mut images: ResMut<Assets<Image>>,
    assert_server: Res<AssetServer>,
) {
    let mut window = windows.single_mut();
    window.cursor.visible = false;
    window.cursor.grab_mode = CursorGrabMode::Locked;
    spawn_world(
        &mut commands,
        &mut meshs,
        &mut materials,
        &mut images,
        &assert_server,
    );

    // spawn a cube
    commands.spawn((
        PbrBundle {
            mesh: meshs.add(Mesh::from(shape::Cube { size: 1.0 })),
            material: materials.add(StandardMaterial {
                emissive: Color::rgb_linear(13.99, 5.32, 2.),
                ..Default::default()
            }),
            transform: Transform::from_xyz(0.0, 5.0, -2.),
            ..Default::default()
        },
        Collider::cuboid(0.5, 0.5, 0.5),
        RigidBody::Dynamic,
        ExternalForce::default(),
        Velocity::default(),
        Cube {
            max_speed: 10.,
            max_acceleration: 10.,
        },
        JumpControl {
            jump: true,
            remaining_jumps: 2,
            jump_speed: 10.,
        },
        ThirdPersonCameraTarget,
        Name::new("Player"),
        CollisionGroups::new(USER_GROUP, PLANE_GROUP | BOX_GROUP),
    ));
}
#[derive(Resource, Deref, Clone, Copy)]
struct ElevatorStatus {
    /// from 0 - 100
    current_location: f32,
}

#[derive(Component, Deref, Clone, Copy)]
struct ElevatorId(u8);

fn get_elevator_location(
    id: ElevatorId,
    current_status: ElevatorStatus,
    total_elevators: u8,
) -> Vec3 {
    let ratio = id.0 as f32 / total_elevators as f32;
    let mut status_id = current_status.current_location + ratio * 100.;
    if status_id > 100. {
        status_id -= 100.;
    }
    if status_id <= 49. {
        Vec3::new(0., status_id / 49. * 49. * 5., 0.)
    } else if status_id <= 50. {
        Vec3::new((status_id - 49.) * 5., 49. * 5., 0.)
    } else if status_id <= 99. {
        Vec3::new(5., 49. * 5. - (status_id - 50.) * 5., 0.)
    } else {
        Vec3::new(5. - (status_id - 99.) * 5., 0., 0.)
    }
}
static ELEVATOR_LOCATION: Vec3 = Vec3::new(10., -1., 0.);
const TOTAL_ELEVATORS: u8 = 20;
#[derive(Resource)]
struct ElevatorSpeed(f32);
fn move_elevator(
    mut ele: Query<(&mut Transform, &ElevatorId)>,
    mut current_status: ResMut<ElevatorStatus>,
    time: Res<Time>,
    elevator_speed: Res<ElevatorSpeed>,
) {
    for (mut trans, e) in ele.iter_mut() {
        let new_position = get_elevator_location(*e, *current_status, TOTAL_ELEVATORS);
        let new_position = new_position + ELEVATOR_LOCATION;
        trans.translation = new_position;
    }
    current_status.current_location += time.delta_seconds() * elevator_speed.0;
    if current_status.current_location > 100. {
        current_status.current_location -= 100.;
    }
}

fn spawn_world(
    commands: &mut Commands,
    meshs: &mut ResMut<Assets<Mesh>>,
    materials: &mut ResMut<Assets<StandardMaterial>>,
    images: &mut ResMut<Assets<Image>>,
    asset_server: &Res<AssetServer>,
) {
    let debug_material = materials.add(StandardMaterial {
        base_color_texture: Some(images.add(uv_debug_texture())),
        ..Default::default()
    });
    let pink_emit = materials.add(StandardMaterial {
        emissive: Color::rgb_linear(10., 0.8, 5.8),
        ..Default::default()
    });
    commands.spawn(PointLightBundle {
        point_light: PointLight {
            color: Color::WHITE,
            intensity: 100000.,
            range: 200.,
            shadows_enabled: true,
            ..Default::default()
        },
        transform: Transform::from_translation(Vec3::new(0., 20., -10.)),
        ..Default::default()
    });
    spawn_basic(commands, meshs, debug_material.clone());

    let light_material = materials.add(StandardMaterial {
        emissive: Color::rgb_linear(2.99, 15.32, 2.),
        ..Default::default()
    });
    let light_cube = meshs.add(Mesh::from(shape::Cube { size: 10.0 }));

    spawn_light(commands, &light_cube, &light_material, meshs, pink_emit);

    spawn_elevator(commands, meshs, materials, asset_server);
    // spawn_elevator(commands, meshs, materials, );
}

fn spawn_elevator(
    commands: &mut Commands<'_, '_>,
    meshs: &mut ResMut<'_, Assets<Mesh>>,
    materials: &mut ResMut<'_, Assets<StandardMaterial>>,
    assert_server: &Res<AssetServer>,
) {
    // load the image
    let image = assert_server.load("images/bibi.png");
    let front_big_wall_matierial = materials.add(StandardMaterial {
        base_color_texture: Some(image.clone()),
        ..Default::default()
    });
    // the bibi_wall
    commands.spawn((
        PbrBundle {
            material: front_big_wall_matierial.clone(),
            mesh: meshs.add(shape::Box::new(100., 40. * 5., 1.).into()),
            transform: Transform::from_translation(
                Vec3::new(0., 40. * 5. / 2., -100.) + ELEVATOR_LOCATION,
            )
            .looking_to(Vec3::Z, Vec3::Y),
            ..Default::default()
        },
        Collider::cuboid(100. / 2.0, 40.0 * 5.0 / 2.0, 0.5),
        CollisionGroups::new(BOX_GROUP, Group::ALL),
    ));
    commands.spawn(PointLightBundle {
        point_light: PointLight {
            color: Color::WHITE,
            intensity: 100000.,
            range: 200.,
            ..Default::default()
        },
        transform: Transform::from_translation(
            Vec3::new(0., 40. * 5. / 2., -48.) + ELEVATOR_LOCATION,
        ),
        ..Default::default()
    });
    // spawn the elevator
    commands.insert_resource(ElevatorStatus {
        current_location: 0.0,
    });
    commands.insert_resource(ElevatorSpeed(1.));

    let elevator_mesh = meshs.add(shape::Box::new(3., 1., 20.).into());
    let elevator_matirerial = materials.add(StandardMaterial {
        emissive: Color::rgb_linear(0.2, 5., 15.),
        ..Default::default()
    });
    // spawn a wall
    let wall_matireial = materials.add(Color::rgba(0.7, 0.6, 0.1, 0.1).into());
    let side_wall_mesh = meshs.add(shape::Box::new(1., 49. * 5., 20.).into());
    let front_wall_mesh = meshs.add(shape::Box::new(3. + 5. + 3., 49. * 5., 1.).into());
    // left
    commands.spawn((
        PbrBundle {
            material: wall_matireial.clone(),
            mesh: side_wall_mesh.clone(),
            transform: Transform::from_translation(
                Vec3::new(-1.5 - 0.5, 49. * 5. / 2. + 2., 0.) + ELEVATOR_LOCATION,
            ),
            ..Default::default()
        },
        Collider::cuboid(0.5, 49.0 * 5.0 / 2.0, 20.0 / 2.0),
        CollisionGroups::new(BOX_GROUP, Group::ALL),
    ));
    // right
    commands.spawn((
        PbrBundle {
            material: wall_matireial.clone(),
            mesh: side_wall_mesh.clone(),
            transform: Transform::from_translation(
                Vec3::new(5. + 1.5 + 0.5, 49. * 5. / 2. + 2., 0.) + ELEVATOR_LOCATION,
            ),
            ..Default::default()
        },
        Collider::cuboid(0.5, 49.0 * 5.0 / 2.0, 20.0 / 2.0),
        CollisionGroups::new(BOX_GROUP, Group::ALL),
    ));
    // middle
    commands.spawn((
        PbrBundle {
            material: wall_matireial.clone(),
            mesh: side_wall_mesh.clone(),
            transform: Transform::from_translation(
                Vec3::new(2.5, 49. * 5. / 2., 0.) + ELEVATOR_LOCATION,
            ),
            ..Default::default()
        },
        Collider::cuboid(0.5, 49.0 * 5.0 / 2.0, 20.0 / 2.0),
        CollisionGroups::new(BOX_GROUP, Group::ALL),
    ));
    // back
    commands.spawn((
        PbrBundle {
            material: wall_matireial.clone(),
            mesh: front_wall_mesh.clone(),
            transform: Transform::from_translation(
                Vec3::new(2.5, 49. * 5. / 2., 10. + 0.5) + ELEVATOR_LOCATION,
            ),
            ..Default::default()
        },
        Collider::cuboid((3.0 + 5.0 + 3.0) / 2.0, 49.0 * 5.0 / 2.0, 0.5),
        CollisionGroups::new(BOX_GROUP, Group::ALL),
    ));
    // front
    commands.spawn((
        PbrBundle {
            material: wall_matireial.clone(),
            mesh: front_wall_mesh.clone(),
            transform: Transform::from_translation(
                Vec3::new(2.5, 49. * 5. / 2., -10. - 0.5) + ELEVATOR_LOCATION,
            ),
            ..Default::default()
        },
        Collider::cuboid((3.0 + 5.0 + 3.0) / 2.0, 49.0 * 5.0 / 2.0, 0.5),
        CollisionGroups::new(BOX_GROUP, Group::ALL),
    ));

    // spawn the top plane
    commands.spawn((
        PbrBundle {
            material: materials.add(Color::WHITE.with_a(0.3).into()),
            mesh: meshs.add(shape::Plane::from_size(200.).into()),
            transform: Transform::from_translation(
                Vec3::new(0.0, 49.0 * 5.0, 0.) + ELEVATOR_LOCATION,
            ),
            ..Default::default()
        },
        Collider::cuboid(100., 0.01, 100.),
        CollisionGroups::new(BOX_GROUP, Group::ALL),
    ));
    commands.spawn(PointLightBundle {
        point_light: PointLight {
            color: Color::WHITE,
            intensity: 100000.,
            range: 200.,
            shadows_enabled: true,
            ..Default::default()
        },
        transform: Transform::from_translation(
            Vec3::new(0., 49. * 5. + 10., 0.) + ELEVATOR_LOCATION,
        ),
        ..Default::default()
    });
    // spawn the gate
    commands.spawn((
        PbrBundle {
            material: materials.add(Color::PINK.with_a(0.2).into()),
            mesh: meshs.add(shape::Box::new(200., 0.5, 1.).into()),
            transform: Transform::from_translation(
                Vec3::new(0.0, 49.0 * 5.0 + 0.25, -100.) + ELEVATOR_LOCATION,
            ),
            ..Default::default()
        },
        Collider::cuboid(100., 0.25, 0.5),
        CollisionGroups::new(BOX_GROUP, Group::ALL),
    ));

    for i in 0..TOTAL_ELEVATORS {
        let location = get_elevator_location(
            ElevatorId(i),
            ElevatorStatus {
                current_location: 0.,
            },
            TOTAL_ELEVATORS,
        );
        commands.spawn((
            PbrBundle {
                mesh: elevator_mesh.clone(),
                material: elevator_matirerial.clone(),
                transform: Transform::from_translation(location + ELEVATOR_LOCATION),
                ..Default::default()
            },
            RigidBody::KinematicPositionBased,
            Collider::cuboid(3. / 2., 1. / 2., 20. / 2.),
            ElevatorId(i),
            CollisionGroups::new(BOX_GROUP, Group::ALL),
        ));
    }

    // spawn a sensor
    commands.spawn((
        Sensor,
        Collider::cylinder(0.1, 1.),
        PbrBundle {
            mesh: meshs.add(
                shape::Cylinder {
                    radius: 1.,
                    height: 0.2,
                    ..Default::default()
                }
                .into(),
            ),
            material: materials.add(Color::RED.into()),
            transform: Transform::from_translation(
                Vec3::new(-15., 49. * 5. + 0.05, -15.) + ELEVATOR_LOCATION,
            ),
            ..Default::default()
        },
        CollisionGroups::new(BOX_GROUP, Group::ALL),
    ));
}

fn touch_sensor(
    mut commands: Commands,
    sensor: Query<Entity, With<Sensor>>,
    cube: Query<Entity, With<Cube>>,
    rapier_context: Res<RapierContext>,

    mut next_state: ResMut<NextState<GameState>>,
) {
    let s = sensor.single();
    let cube = cube.single();
    if rapier_context.intersection_pair(cube, s) == Some(true) {
        println!("touch sensor");
        commands.entity(s).despawn();
        next_state.set(GameState::Splash);
    }
}
#[derive(Component)]
struct SuperBall;
fn spawn_light(
    commands: &mut Commands<'_, '_>,
    light_cube: &Handle<Mesh>,
    light_material: &Handle<StandardMaterial>,
    meshs: &mut ResMut<'_, Assets<Mesh>>,
    pink_emit: Handle<StandardMaterial>,
) {
    // spawn 100 light cube and a light ball
    for i in 0..100 {
        commands.spawn(PbrBundle {
            mesh: light_cube.clone(),
            material: light_material.clone(),
            transform: Transform::from_translation(Vec3::new(i as f32 * 10. - 500., 20., -4490.)),
            ..Default::default()
        });
    }
    commands.spawn((PbrBundle {
        mesh: meshs.add(
            shape::Icosphere {
                radius: 2.,
                subdivisions: 4,
            }
            .try_into()
            .unwrap(),
        ),
        material: light_material.clone(),
        transform: Transform::from_translation(Vec3::new(0., 10., -4495.)),
        ..Default::default()
    },));
    commands.spawn(PointLightBundle {
        point_light: PointLight {
            color: Color::PINK,
            intensity: 100000.,
            range: 200.,
            ..Default::default()
        },
        transform: Transform::from_translation(Vec3::new(0., 10., -4495.)),
        ..Default::default()
    });

    commands.spawn((
        PbrBundle {
            mesh: meshs.add(
                shape::Icosphere {
                    radius: 200.,
                    subdivisions: 4,
                }
                .try_into()
                .unwrap(),
            ),
            material: pink_emit.clone(),
            transform: Transform::from_translation(Vec3::new(0., 300., -4295.)),
            ..Default::default()
        },
        SuperBall,
    ));
    commands.spawn(PointLightBundle {
        point_light: PointLight {
            color: Color::PINK,
            intensity: 100000.,
            range: 500.,
            ..Default::default()
        },
        transform: Transform::from_translation(Vec3::new(0., 300., -4295.)),
        ..Default::default()
    });
    // // spawn 100 light cubes
    // for i in 0..10 {
    //     for j in 0..10 {
    //         commands.spawn(PbrBundle {
    //             mesh: light_cube.clone(),
    //             material: light_material.clone(),
    //             transform: Transform::from_translation(Vec3::new(
    //                 i as f32 * 100. - 500.,
    //                 j as f32 * 100.,
    //                 -1000.,
    //             )),
    //             ..Default::default()
    //         });
    //     }
    // }
}

fn spawn_basic(
    commands: &mut Commands<'_, '_>,
    meshs: &mut ResMut<'_, Assets<Mesh>>,
    debug_material: Handle<StandardMaterial>,
) {
    // spawn a plane
    commands.spawn((
        PbrBundle {
            mesh: meshs.add(Mesh::from(shape::Plane {
                size: 10000.0,
                subdivisions: 0,
            })),
            material: debug_material.clone(),
            ..Default::default()
        },
        Collider::halfspace(Vec3::Y).unwrap(),
        CollisionGroups::new(PLANE_GROUP, Group::ALL),
    ));

    // spawn a camera
    commands.spawn((
        Camera3dBundle {
            transform: Transform::from_xyz(0.0, 5.0, 10.0).looking_to(-Vec3::Z, Vec3::Y),
            camera: Camera {
                hdr: true,
                ..Default::default()
            },
            tonemapping: Tonemapping::TonyMcMapface,
            ..Default::default()
        },
        BloomSettings::default(),
        ThirdPersonCamera {
            cursor_lock_active: true,
            cursor_lock_toggle_enabled: true,
            cursor_lock_key: keyboard::KeyCode::L,
            zoom_enabled: true,
            zoom: Zoom::new(8., 10.),
            ..Default::default()
        },
    ));

    // spawn a light
    commands.insert_resource(AmbientLight {
        color: Color::WHITE,
        brightness: 0.4,
    });

    // spawn some fixed cubes
    let positions = [
        Vec3::new(-10., 2., -30.),
        Vec3::new(10., 3., -20.),
        Vec3::new(0., 4., -10.),
        Vec3::new(0., 4., -5000.),
    ];
    let sizes = [1., 2., 3., 1000.];
    for (mut p, s) in positions.into_iter().zip(sizes) {
        p.y = s / 2.;
        commands.spawn((
            PbrBundle {
                mesh: meshs.add(Mesh::from(shape::Cube { size: s })),
                material: debug_material.clone(),
                transform: Transform::from_translation(p),
                ..Default::default()
            },
            Collider::cuboid(s / 2., s / 2., s / 2.),
            CollisionGroups::new(BOX_GROUP, Group::ALL),
        ));
    }
}

fn cude_move_gamepad(
    gamepads: Res<Gamepads>,
    button_inputs: Res<Input<GamepadButton>>,
    axes: Res<Axis<GamepadAxis>>,
    mut cube: Query<
        (&mut Velocity, &mut Transform, &mut JumpControl, &Cube),
        Without<ThirdPersonCamera>,
    >,
    camera: Query<&Transform, With<ThirdPersonCamera>>,
) {
    let (mut velocity, mut transform, mut jump_contorl, cube) = cube.single_mut();
    let camera = camera.single();

    for game_pad in gamepads.iter() {
        if button_inputs.just_pressed(GamepadButton::new(game_pad, GamepadButtonType::North)) {
            transform.translation = Vec3::new(0.0, 5.0, 0.0);
        }
        if button_inputs.just_pressed(GamepadButton::new(game_pad, GamepadButtonType::West)) {
            velocity.linvel.x = 0.;
            velocity.linvel.z = 0.;
        }
        if button_inputs.just_pressed(GamepadButton::new(game_pad, GamepadButtonType::South))
            && jump_contorl.remaining_jumps > 0
        {
            // jump
            velocity.linvel.y = jump_contorl.jump_speed;
            jump_contorl.remaining_jumps -= 1;
        }
        let left_stick_x = axes.get(GamepadAxis::new(game_pad, GamepadAxisType::LeftStickX));
        let left_stick_y = axes.get(GamepadAxis::new(game_pad, GamepadAxisType::LeftStickY));
        match (left_stick_x, left_stick_y) {
            (Some(x), Some(y)) => {
                if x.abs() > 0.1 || y.abs() > 0.1 {
                    let max_speed = cube.max_speed;
                    let mut forward_direction = camera.forward();
                    forward_direction.y = 0.;
                    forward_direction = forward_direction.normalize();
                    let mut right_direction = camera.right();
                    right_direction.y = 0.;
                    right_direction = right_direction.normalize();

                    let speed = y * forward_direction + x * right_direction;
                    let speed = speed * max_speed;
                    let old_y = velocity.linvel.y;
                    velocity.linvel = speed;
                    velocity.linvel.y = old_y;
                }
            }
            _ => {}
        };
    }
}

fn cube_move_keyboard(
    keyboard_input: Res<Input<keyboard::KeyCode>>,
    mut cube: Query<(&mut Transform, &mut Velocity, &Cube), Without<ThirdPersonCamera>>,
    camera: Query<&Transform, With<ThirdPersonCamera>>,
) {
    let (mut transform, mut velocity, cube) = cube.single_mut();
    if keyboard_input.just_pressed(keyboard::KeyCode::R) {
        transform.translation = Vec3::new(0.0, 5.0 * 50., 0.0);
    }
    if keyboard_input.just_pressed(KeyCode::ShiftLeft) {
        velocity.linvel.x = 0.;
        velocity.linvel.z = 0.;
    }
    let camera = camera.single();
    let mut direction = Vec3::ZERO;
    let mut forward_direction = camera.forward();
    forward_direction.y = 0.;
    forward_direction = forward_direction.normalize();
    let mut right_direction = camera.right();
    right_direction.y = 0.;
    right_direction = right_direction.normalize();
    let mut moved = false;

    if keyboard_input.pressed(keyboard::KeyCode::W) {
        direction += forward_direction;
        moved = true;
    }
    if keyboard_input.pressed(keyboard::KeyCode::S) {
        direction -= forward_direction;
        moved = true;
    }
    if keyboard_input.pressed(keyboard::KeyCode::A) {
        direction -= right_direction;
        moved = true;
    }
    if keyboard_input.pressed(keyboard::KeyCode::D) {
        direction += right_direction;
        moved = true;
    }
    if moved {
        let old_y = velocity.linvel.y;
        velocity.linvel = direction * cube.max_speed;
        velocity.linvel.y = old_y;
    }
}
fn cube_jump(
    keyboard_input: Res<Input<keyboard::KeyCode>>,
    mut cube: Query<(&mut Velocity, &mut JumpControl)>,
) {
    let (mut v, mut jump) = cube.single_mut();
    if keyboard_input.just_pressed(keyboard::KeyCode::Space)
        && jump.jump
        && jump.remaining_jumps > 0
    {
        v.linvel.y = jump.jump_speed;
        jump.remaining_jumps -= 1;
    }
}

fn reset_jump(
    mut cube: Query<(&mut JumpControl, Entity), With<Cube>>,
    rapier_context: Res<RapierContext>,
) {
    let (mut cube, e) = cube.single_mut();

    let contacts = rapier_context.contact_pairs_with(e);
    for _contact in contacts {
        if _contact.has_any_active_contacts() {
            cube.remaining_jumps = 2;
            return;
        }
    }
}
/// Creates a colorful test pattern
fn uv_debug_texture() -> Image {
    const TEXTURE_SIZE: usize = 8;

    let mut palette: [u8; 32] = [
        255, 102, 159, 255, 255, 159, 102, 255, 236, 255, 102, 255, 121, 255, 102, 255, 102, 255,
        198, 255, 102, 198, 255, 255, 121, 102, 255, 255, 236, 102, 255, 255,
    ];

    let mut texture_data = [0; TEXTURE_SIZE * TEXTURE_SIZE * 4];
    for y in 0..TEXTURE_SIZE {
        let offset = TEXTURE_SIZE * y * 4;
        texture_data[offset..(offset + TEXTURE_SIZE * 4)].copy_from_slice(&palette);
        palette.rotate_right(4);
    }

    Image::new_fill(
        Extent3d {
            width: TEXTURE_SIZE as u32,
            height: TEXTURE_SIZE as u32,
            depth_or_array_layers: 1,
        },
        TextureDimension::D2,
        &texture_data,
        TextureFormat::Rgba8UnormSrgb,
    )
}