RustPhysicsMQ/src/main.rs

use macroquad::prelude as mq;

mod engine;
use engine::*;
mod camera;
mod config;
mod drone;
mod helpers;
mod rendering;
mod simulation;

mod graphics_util;

use crate::drone::input::*;
use crate::simulation::{SimMode, Simulation};

use crate::config::SimulationConfig;
use helpers::list_files;
use std::fs;

const INPUTS_DIR: &str = "inputs/";
const CONFIGS_DIR: &str = "configurations/";
const RESULTS_DIR: &str = "results/";

fn window_conf() -> mq::Conf {
    mq::Conf {
        window_title: "RustDroneSim".to_owned(),
        window_resizable: true,
        platform: mq::miniquad::conf::Platform {
            ..Default::default()
        },
        ..Default::default()
    }
}

use std::env;
use std::path::PathBuf;
use std::thread::JoinHandle;

enum RunMode {
    Batch,
    Record { output: String },
}

fn parse_cli() -> RunMode {
    let mut args = env::args().skip(1);

    match args.next().as_deref() {
        Some("record") => {
            let output = args.next().expect("record mode requires output file path");
            RunMode::Record { output }
        }
        Some("batch") | None => RunMode::Batch,
        Some(other) => panic!("Unknown mode: {}", other),
    }
}

#[macroquad::main(window_conf)]
async fn main() {
    match parse_cli() {
        RunMode::Batch => run_batch().await,
        RunMode::Record { output } => run_record(output).await,
    }
}

async fn run_batch() {
    fs::remove_dir_all(RESULTS_DIR).unwrap();
    fs::create_dir_all(RESULTS_DIR).unwrap();

    let input_files = list_files(INPUTS_DIR);
    let config_files = list_files(CONFIGS_DIR);

    let mut handles: Vec<JoinHandle<()>> = Default::default();

    for input_path in input_files {
        for config_path in &config_files {
            let cp = config_path.clone();
            let ip = input_path.clone();
            handles.push(std::thread::spawn(move || {
                run(&ip, &cp);
            }));
        }
    }
    for handle in handles {
        handle.join().unwrap();
    }

    println!("All simulations completed.");
}

fn run(input_path: &PathBuf, config_path: &PathBuf) {
    let input_name = input_path.file_stem().unwrap().to_string_lossy();

    let inputs = InputRecording::load_inputs_from_csv(input_path.to_str().unwrap())
        .expect("Failed to load input recording");
    let config_name = config_path.file_stem().unwrap().to_string_lossy();

    let config: SimulationConfig =
        toml::from_str(&fs::read_to_string(config_path).unwrap()).expect("Invalid config file");

    println!(
        "Running simulation: input={} config={}",
        input_name, config_name
    );

    /* World */
    let mut world = World::new(config.tickrate);

    /* Drone */
    let drone = drone::Drone::new(
        &mut world,
        Box::new(drone::pidcontroller::PIDController {
            target_rate: config.target_rate,
            proportional_multiplier: config.proportional(),
            integral_multiplier: config.integral(),
            diferential_multiplier: config.diferential(),
            ..Default::default()
        }),
        drone::MotorCharacteristics {
            max_thrust: config.max_thrust,
            max_torque: config.max_torque,
            ..Default::default()
        },
        config.mass,
    );

    let result_file = format!("{}/{}_{}.csv", RESULTS_DIR, input_name, config_name);

    let mut sim = Simulation::new(
        drone,
        world,
        false,
        SimMode::Playback(inputs.clone(), 0.0),
        Some(result_file),
        config.drone_tick_rate,
    );

    sim.run().unwrap();
}

async fn run_record(output: String) {
    println!("Recording inputs to {}", output);

    let tickrate = 60000.0;
    let mut world = World::new(tickrate);

    let drone = drone::Drone::new(
        &mut world,
        Box::new(drone::pidcontroller::PIDController {
            ..Default::default()
        }),
        drone::MotorCharacteristics {
            max_thrust: 2.6,
            max_torque: 0.5,
            ..Default::default()
        },
        0.350,
    );

    let mut sim = Simulation::new(
        drone,
        world,
        true,
        SimMode::Record(InputRecording::default(), output),
        None,
        600,
    );

    sim.run().unwrap();
}