implemented project creation

Author: Ivan-1F

src/home.rs

@@ -1,18 +1,38 @@
+use std::path::PathBuf;
+
 use bevy::prelude::*;
 use bevy_egui::EguiContext;
 use rfd::FileDialog;
 
 use crate::{
-    file::{pick_folder, PickingEvent, PickingKind},
-    project::{project_not_loaded, LoadProjectEvent},
+    file::{pick_file, pick_folder, PickingEvent, PickingKind},
+    notification::{ToastsExt, ToastsStorage},
+    project::{create_project, project_not_loaded, LoadProjectEvent, ProjectMeta},
 };
 
+#[derive(Resource, Debug, Default)]
+pub struct CreateProjectForm {
+    meta: ProjectMeta,
+    music: Option<PathBuf>,
+    illustration: Option<PathBuf>,
+}
+
 pub struct HomePlugin;
 
 impl Plugin for HomePlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(Update, ui_system.run_if(project_not_loaded()))
-            .add_systems(Update, load_project_system.run_if(project_not_loaded()));
+        app.insert_resource(CreateProjectForm::default())
+            .add_systems(Update, ui_system.run_if(project_not_loaded()))
+            .add_systems(Update, load_project_system.run_if(project_not_loaded()))
+            .add_systems(
+                Update,
+                (
+                    handle_select_illustration_system,
+                    handle_select_music_system,
+                    handle_create_project_system,
+                )
+                    .run_if(project_not_loaded()),
+            );
     }
 }
 
@@ -27,6 +47,39 @@ fn ui_system(world: &mut World) {
         if ui.button("Load Project").clicked() {
             pick_folder(world, PickingKind::OpenProject, FileDialog::new());
         }
+
+        ui.separator();
+
+        ui.horizontal(|ui| {
+            let form = world.resource_mut::<CreateProjectForm>();
+            ui.label(format!("{:?}", form.music));
+            if ui.button("Select Music").clicked() {
+                pick_file(world, PickingKind::SelectMusic, FileDialog::new());
+            }
+        });
+        ui.horizontal(|ui| {
+            let form = world.resource_mut::<CreateProjectForm>();
+            ui.label(format!("{:?}", form.illustration));
+            if ui.button("Select Illustration").clicked() {
+                pick_file(world, PickingKind::SelectIllustration, FileDialog::new());
+            }
+        });
+
+        let form = world.resource_mut::<CreateProjectForm>();
+        if ui.button("Create Project").clicked() {
+            if form.music.is_none() {
+                let mut toasts = world.resource_mut::<ToastsStorage>();
+                toasts.error("Music is not selected");
+                return;
+            };
+            if form.illustration.is_none() {
+                let mut toasts = world.resource_mut::<ToastsStorage>();
+                toasts.error("Illustration is not selected");
+                return;
+            };
+
+            pick_folder(world, PickingKind::CreateProject, FileDialog::new());
+        }
     });
 }
 
@@ -43,3 +96,65 @@ fn load_project_system(
         }
     }
 }
+
+fn handle_select_illustration_system(
+    mut events: EventReader<PickingEvent>,
+    mut form: ResMut<CreateProjectForm>,
+) {
+    for PickingEvent { path, kind } in events.read() {
+        if !matches!(kind, PickingKind::SelectIllustration) {
+            continue;
+        }
+        form.illustration = path.clone();
+    }
+}
+
+fn handle_select_music_system(
+    mut events: EventReader<PickingEvent>,
+    mut form: ResMut<CreateProjectForm>,
+) {
+    for PickingEvent { path, kind } in events.read() {
+        if !matches!(kind, PickingKind::SelectMusic) {
+            continue;
+        }
+        form.music = path.clone();
+    }
+}
+
+fn handle_create_project_system(
+    mut events: EventReader<PickingEvent>,
+    form: Res<CreateProjectForm>,
+    mut load_project_events: EventWriter<LoadProjectEvent>,
+
+    mut toasts: ResMut<ToastsStorage>,
+) {
+    for PickingEvent { path, kind } in events.read() {
+        if !matches!(kind, PickingKind::CreateProject) {
+            continue;
+        }
+
+        let Some(root_path) = path else {
+            return;
+        };
+
+        let Some(ref music_path) = form.music else {
+            return;
+        };
+
+        let Some(ref illustration_path) = form.illustration else {
+            return;
+        };
+
+        match create_project(
+            root_path.clone(),
+            music_path.clone(),
+            illustration_path.clone(),
+            form.meta.clone(),
+        ) {
+            Ok(_) => {
+                load_project_events.send(LoadProjectEvent(root_path.clone()));
+            },
+            Err(error) => toasts.error(format!("{:?}", error)),
+        }
+    }
+}

src/project.rs

@@ -10,7 +10,7 @@ use crate::{
     serialzation::PhiChainChart,
 };
 
-#[derive(Debug, Serialize, Deserialize, Default)]
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct ProjectMeta {
     pub composer: String,
     pub charter: String,
@@ -124,3 +124,20 @@ fn load_project_system(
 
     events.clear();
 }
+
+pub fn create_project(
+    root_path: PathBuf,
+    music_path: PathBuf,
+    illustration_path: PathBuf,
+    project_meta: ProjectMeta,
+) -> anyhow::Result<()> {
+    let project_path = ProjectPath(root_path);
+    std::fs::copy(music_path, project_path.music_path()).context("Failed to copy music file")?;
+    std::fs::copy(illustration_path, project_path.illustration_path()).context("Failed to copy illustration file")?;
+    let meta_string = serde_json::to_string_pretty(&project_meta).unwrap();
+    std::fs::write(project_path.meta_path(), meta_string).context("Failed to write meta")?;
+    let chart_string = serde_json::to_string_pretty(&PhiChainChart::default()).unwrap();
+    std::fs::write(project_path.chart_path(), chart_string).context("Failed to write meta")?;
+
+    Ok(())
+}

src/serialzation.rs

@@ -9,7 +9,7 @@ use crate::{
     timing::BpmList,
 };
 
-#[derive(Serialize, Deserialize, Default)]
+#[derive(Serialize, Deserialize)]
 pub struct PhiChainChart {
     pub bpm_list: BpmList,
     pub lines: Vec<LineWrapper>,
@@ -21,6 +21,15 @@ impl PhiChainChart {
     }
 }
 
+impl Default for PhiChainChart {
+    fn default() -> Self {
+        Self {
+            bpm_list: Default::default(),
+            lines: vec![Default::default()],
+        }
+    }
+}
+
 /// A wrapper struct to handle line serialzation and deserialzation
 #[derive(Serialize, Deserialize)]
 pub struct LineWrapper(pub Vec<Note>, pub Vec<LineEvent>);