tacmap back as canvas. begin work on fleet scheduling

1 files changed, 150 insertions, 0 deletions

diff --git a/src/ui/fleet_schedule.rs b/src/ui/fleet_schedule.rs
new file mode 100644
index 0000000..b0e5dd7
--- /dev/null
+++ b/src/ui/fleet_schedule.rs
@@ -0,0 +1,150 @@
+use crate::solar_system::SolarSystem;
+use crate::solar_system::body::BodyId;
+use crate::fleet::{Fleet, FleetId, FleetsManager};
+
+#[derive(Clone)]
+pub struct FleetScheduleWindow
+{
+    pub target: (Option<BodyId>, Option<FleetId>),
+    pub linear_acceleration_limit: f32,
+    pub angular_acceleration_limit: f32,
+}
+
+impl Default for FleetScheduleWindow
+{
+    fn default() -> Self {
+        Self { 
+            target: Default::default(), 
+            linear_acceleration_limit: 9.81, 
+            angular_acceleration_limit: 15.0 
+        }
+    }
+}
+
+impl FleetScheduleWindow
+{
+    pub fn paint(
+        &mut self,
+        star_systems: &[SolarSystem],
+        fleets_man: &FleetsManager,
+        fleet: &Fleet,
+        ui: &mut egui::Ui)
+    {
+        ui.horizontal(|limits_ui| {
+            limits_ui.vertical(|linear_limit_ui| {
+                linear_limit_ui.label("Linear acceleration limit");
+                linear_limit_ui.add(
+                    egui::DragValue::new(&mut self.linear_acceleration_limit)
+                    .range(0.0..=(9.8*2.0))
+                    .clamp_existing_to_range(true)
+                    .suffix(" m/s^2")
+                    .speed(0.1)
+                    .max_decimals_opt(Some(2))
+                );
+            });
+            limits_ui.separator();
+            limits_ui.vertical(|angular_limit_ui| {
+                angular_limit_ui.label("Angular acceleration limit");
+                angular_limit_ui.add(
+                    egui::DragValue::new(&mut self.angular_acceleration_limit)
+                    .range(0.0..=30.0)
+                    .clamp_existing_to_range(true)
+                    .suffix(" °/s^2")
+                    .speed(0.1)
+                    .max_decimals_opt(Some(2))
+                );
+            });
+        });
+        ui.separator();
+
+        let fleet_system = &star_systems[fleet.system().unwrap_or(0)];
+        let bodies = fleet_system.bodies();
+        let bodies_order = fleet_system.heirarchy().traverse_preorder();
+        let system_fleets = fleet_system.fleets(fleets_man);
+
+        let row_height = ui.spacing().interact_size.y;
+        ui.horizontal(|panel_ui| 
+        {
+            panel_ui.vertical(|vertical_ui| {
+                vertical_ui.set_max_width(128.0);
+                vertical_ui.vertical_centered(|centered_ui| {
+                    centered_ui.label("Target");
+                });
+                egui::ScrollArea::vertical()
+                    .id_salt("fleet_schedule_objs")
+                    .auto_shrink(false)
+                    .min_scrolled_height(256.0)
+                    .show_rows(vertical_ui, row_height, bodies.len() + system_fleets.len(),
+                |objs_ui, rows| {
+                    let fleet_rows_start = 0;
+                    let bodies_rows_start = system_fleets.len();
+
+                    for row in rows {
+                        match row < bodies_rows_start {
+                            true => {
+                                let id = system_fleets[row - fleet_rows_start];
+                                let selected = self.target.1
+                                    .is_some_and(|v| { v == id });
+                                let fleet = fleets_man.fleet(id);
+                                if let Some(fleet) = fleet {
+                                    if objs_ui.selectable_label(selected, fleet.name()).clicked() {
+                                        self.select_fleet_from_schedule_objs(id, selected);
+                                    }
+                                }
+                            },
+                            false => {
+                                let id = *bodies_order[row - bodies_rows_start];
+                                let selected = self.target.0
+                                    .is_some_and(|v| { v == id });
+                                let body = &bodies[id];
+                                if objs_ui.selectable_label(selected, body.name()).clicked() {
+                                    self.select_body_from_schedule_objs(id, selected);
+                                }
+                            }
+                        }
+                    }
+                });
+            });
+
+            panel_ui.vertical(|vertical_ui| {
+                vertical_ui.set_max_width(128.0);
+                vertical_ui.vertical_centered(|centered_ui| {
+                    centered_ui.label("Commands");
+                });
+                egui::ScrollArea::vertical()
+                    .id_salt("fleet_schedule_commands")
+                    .auto_shrink(false)
+                    .min_scrolled_height(256.0)
+                    .show_rows(vertical_ui, row_height, 0,
+                |cmd_ui, rows| {
+
+                });
+            });
+            
+            panel_ui.vertical(|vertical_ui| {
+                vertical_ui.set_max_width(128.0);
+                vertical_ui.vertical_centered(|centered_ui| {
+                    centered_ui.label("Schedule");
+                });
+            });
+        });
+    }
+
+    fn select_body_from_schedule_objs(
+        &mut self,
+        id: BodyId,
+        selected: bool)
+    {
+        self.target =
+            (if selected { None } else { Some(id) }, None);
+    }
+
+    fn select_fleet_from_schedule_objs(
+        &mut self,
+        id: FleetId,
+        selected: bool)
+    {
+        self.target =
+            (None, if selected { None } else { Some(id) });
+    }
+}