use bevy::prelude::*;
    let mut r = thread_rng();
    }
}
    for _ in 0..100 {
        commands.spawn(SceneBundle {
            scene: rock.clone(),
            transform: Transform::from_xyz(
                (-0.5 + r.gen::<f32>()) * 100.0,
                (-0.5 + r.gen::<f32>()) * 100.0,
                (-0.5 + r.gen::<f32>()) * 100.0,
            )
            .with_scale(r.gen::<f32>() * Vec3::splat(3.0)),
            ..default()
        });
pub fn scatter(mut commands: Commands, assets: ResMut<AssetServer>) {
    let rock = assets.load("Rock 1.glb#Scene0");
use rand::{thread_rng, Rng};

    fn new(points: Vec<Vec3>, radius: f32, circle_segments: u32, rings: usize) -> Track {

    pub fn new(points: Vec<Vec3>, radius: f32, circle_segments: u32, rings: usize) -> Track {

    fn mesh(&self) -> Mesh {

    pub fn mesh(&self) -> Mesh {

mod level;

mod obstacles;

        .add_systems(Startup, obstacles::scatter)

        .add_systems(Startup, track::set_up_track)

        .add_systems(Startup, level::build_level)

use crate::track::Track;
use bevy::{
    math::{cubic_splines::CubicCurve, vec3},
    prelude::*,
    render::{
        mesh::{Indices, PrimitiveTopology},
        render_asset::RenderAssetUsages,
        texture::{ImageAddressMode, ImageLoaderSettings, ImageSampler, ImageSamplerDescriptor},
    },
};
use std::f32::consts::PI;
use rand::{thread_rng, Rng};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Cube {
    Rock,
    Ring,
    Empty,
}
pub fn build_level(
    mut commands: Commands,
    assets: ResMut<AssetServer>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut images: ResMut<Assets<Image>>,
    mut mat: ResMut<Assets<StandardMaterial>>,
) {
    let mut model: [[[Cube; 10]; 10]; 10] = [[[Cube::Empty; 10]; 10]; 10];
    let mut rocks_ct = 300;
    let rock = assets.load("Rock 1.glb#Scene0");
    let mut r = thread_rng();
    while rocks_ct > 0 {
        let (x, y, z) = (r.gen_range(0..10), r.gen_range(0..10), r.gen_range(0..10));
        if model[x][y][z] == Cube::Empty {
            rocks_ct -= 1;
            model[x][y][z] = Cube::Rock;
        }
    }
    let mut curve_points = vec![Vec3::new(0.0, 0.0, -10.0), Vec3::new(0.0, 0.0, -20.0)];
    for _ in 0..8 {
        let point = vec3(
            (-0.5 + r.gen::<f32>()) * 100.0,
            (-0.5 + r.gen::<f32>()) * 100.0,
            (-0.5 + r.gen::<f32>()) * 100.0,
        );
        let p2 = point.clone();
        model[((p2.x / 10.0).round() + 4.5) as usize][((p2.y / 10.0).round() + 4.5) as usize]
            [((p2.z / 10.0).round() + 4.5) as usize] = Cube::Ring;
        curve_points.push(point);
    }
    for i in 0..10 {
        for j in 0..10 {
            for k in 0..10 {
                if model[i][j][k] == Cube::Rock {
                    commands.spawn(SceneBundle {
                        scene: rock.clone(),
                        transform: Transform::from_xyz(
                            (-5.0 + i as f32) * 20.0,
                            (-5.0 + j as f32) * 20.0,
                            (-5.0 + k as f32) * 20.0,
                        )
                        .with_scale(r.gen::<f32>() * Vec3::splat(3.0)),
                        ..default()
                    });
                }
            }
        }
    }
    // set up track.
    let texture_handle = assets.load_with_settings("checkerboard_albedo.png", |s: &mut _| {
        *s = ImageLoaderSettings {
            sampler: ImageSampler::Descriptor(ImageSamplerDescriptor {
                // rewriting mode to repeat image,
                address_mode_u: ImageAddressMode::Repeat,
                address_mode_v: ImageAddressMode::Repeat,
                ..default()
            }),
            ..default()
        }
    });
    let track = Track::new(curve_points, 1.0, 16, 200);
    let mesh = track.mesh();
    let mut texture_mat = StandardMaterial::default();
    texture_mat.base_color_texture = Some(texture_handle.clone());
    commands.spawn(PbrBundle {
        mesh: meshes.add(mesh),
        material: mat.add(texture_mat),
        ..default()
    });
}