Add CLI with save feature

10 files changed, 278 insertions, 16 deletions

diff --git a/src/cli/cmd/mod.rs b/src/cli/cmd/mod.rs
new file mode 100644
index 0000000..29063e8
--- /dev/null
+++ b/src/cli/cmd/mod.rs
@@ -0,0 +1,53 @@
+//! The commands that can be performed in the CLI
+
+pub mod save;
+
+pub use save::*;
+
+use crate::Editor;
+use std::ops::RangeInclusive;
+
+/// Errors that can occur when parsing a command. This is for syntax checking, the
+/// semantics are checked when trying to execute the command.
+#[allow(missing_docs)]
+#[derive(thiserror::Error, Debug)]
+pub enum CmdParseError {
+    #[error("no command specified")]
+    StringEmpty,
+    #[error("the command {0} is unknown")]
+    NoSuchCmd(String),
+    #[error("wrong number of arguments. Expected in range {1:?}, but received {0}")]
+    WrongNumberOfArgs(usize, RangeInclusive<usize>),
+    #[error("{0} cannot be converted into a {1}, which is required")]
+    InvalidArgType(String, &'static str),
+}
+
+/// Attempts to parse a command from the given string. If it is unsuccessful, it returns a
+/// [CmdParseError].
+pub fn parse_command(string: &str) -> Result<Box<dyn Command>, CmdParseError> {
+    if string.is_empty() {
+        return Err(CmdParseError::StringEmpty);
+    }
+
+    let parts: Vec<&str> = string.split_whitespace().collect();
+    match parts[0] {
+        "w" => Ok(Box::new(Save::from_args(&parts[1..])?)),
+        other => Err(CmdParseError::NoSuchCmd(other.to_owned())),
+    }
+}
+
+/// Indicates that this entity (command) can be created from arguments. Make sure to check what is
+/// expected, to pass the arguments to the correct command.
+pub trait FromArgs: Sized {
+    /// Creates a new instance from the arguments provided. If for whatever reason the syntax of the
+    /// given arguments is correct an [ArgParseError] is returned.
+    fn from_args(args: &[&str]) -> Result<Self, CmdParseError>;
+}
+
+/// A common trait for all commands.
+pub trait Command {
+    /// Process this command on the provided context. Returns either a string with the output of the
+    /// command when everything went right with it, or an error string explaining what went wrong,
+    /// which can be displayed to the user.
+    fn process(&self, editor: &mut Editor) -> Result<String, String>;
+}
diff --git a/src/cli/cmd/save.rs b/src/cli/cmd/save.rs
new file mode 100644
index 0000000..2c022cf
--- /dev/null
+++ b/src/cli/cmd/save.rs
@@ -0,0 +1,42 @@
+//! Save the contents of the map to disk
+
+use super::Command;
+use super::{CmdParseError, FromArgs};
+use crate::map::MapData;
+use crate::Editor;
+use std::path::PathBuf;
+
+/// The save command can take any destination in the filesystem the user can write to. Processing
+/// will then save the map contents to that destination, overwriting anything that may be there.
+pub struct Save {
+    destination: PathBuf,
+}
+
+impl FromArgs for Save {
+    fn from_args(args: &[&str]) -> Result<Self, CmdParseError> {
+        if args.len() != 1 {
+            return Err(CmdParseError::WrongNumberOfArgs(args.len(), 1..=1));
+        }
+
+        Ok(Self {
+            destination: PathBuf::from(args[0]),
+        })
+    }
+}
+
+impl Command for Save {
+    fn process(&self, editor: &mut Editor) -> Result<String, String> {
+        let data = MapData::extract_data(editor.map());
+
+        match data.write_to_file(&self.destination) {
+            Ok(_) => Ok(format!(
+                "Successfully wrote contents to `{:?}`",
+                &self.destination
+            )),
+            Err(e) => Err(format!(
+                "Unable to write to `{:?}`. Error: {:?}",
+                &self.destination, e
+            )),
+        }
+    }
+}
diff --git a/src/cli/mod.rs b/src/cli/mod.rs
new file mode 100644
index 0000000..e96070f
--- /dev/null
+++ b/src/cli/mod.rs
@@ -0,0 +1,104 @@
+//! In-window Command line interface. Used for operations that are just easier than with GUI.
+//!
+//! Sometimes it is nice to have a GUI, for instance when a selection has to be made, things have to
+//! be moved etc., however for operations like saving/loading and exporting, no such thing has to be
+//! done and the GUI is really just slowing you down (at least in my opinion). For these operations,
+//! it is much better to simply have a command do that specific thing. It is also much easier to
+//! implement a new command, so features can be tested more quickly. For some things, there should
+//! still be a GUI option. With the example of saving/loading, it is much easier to find some hidden
+//! folder in a GUI, so that is definitely a consideration for the future.
+
+pub mod cmd;
+pub use self::cmd::*;
+
+use crate::colours::DEFAULT_COLOURS;
+use crate::math::Vec2;
+use crate::Editor;
+use raylib::drawing::{RaylibDraw, RaylibDrawHandle};
+use raylib::ffi::KeyboardKey;
+use raylib::RaylibHandle;
+
+/// The command line interface. Should be created only once per program instance.
+pub struct CLI {
+    text: String,
+    active: bool,
+}
+
+impl CLI {
+    /// Create a CLI for this instance
+    pub fn new() -> Self {
+        Self {
+            text: String::new(),
+            active: false,
+        }
+    }
+
+    /// Activates the CLI, which will now capture keyboard input and execute commands accordingly.
+    pub fn activate(&mut self) {
+        if !self.active {
+            self.text = ";".to_owned();
+            self.active = true;
+        }
+    }
+
+    /// Handle input for the command line and perform any commands the user may want to run.
+    pub fn update(&mut self, rl: &mut RaylibHandle, editor: &mut Editor) {
+        /* Check if the CLI is currently active. If not and it should not be activated according to
+         * keyboard input, there is nothing to do.
+         */
+        if !self.active {
+            if rl.is_key_pressed(KeyboardKey::KEY_SEMICOLON) {
+                // Don't write the keypress again.
+                rl.get_key_pressed();
+                self.activate();
+            } else {
+                return;
+            }
+        }
+
+        // The CLI is currently active. Handle input to it.
+        if let Some(key) = rl.get_key_pressed_number() {
+            self.text.push(key as u8 as char);
+        } else if rl.is_key_pressed(KeyboardKey::KEY_BACKSPACE) {
+            self.text.pop();
+        } else if rl.is_key_pressed(KeyboardKey::KEY_ESCAPE) {
+            self.text.clear();
+        }
+
+        // When the text is empty, there is also no command marker, so set as inactive and leave.
+        if self.text.is_empty() {
+            self.active = false;
+            return;
+        }
+
+        // Perform the entered command, when the enter-key is pressed.
+        if rl.is_key_pressed(KeyboardKey::KEY_ENTER) {
+            self.active = false;
+            match cmd::parse_command(&self.text[1..]) {
+                Ok(cmd) => match cmd.process(editor) {
+                    Ok(res) => self.text = format!("SUCCESS: {}", res),
+                    Err(err) => self.text = format!("ERROR: {}", err),
+                },
+                Err(err) => self.text = format!("SYNTAX ERROR: {}", err),
+            }
+        }
+    }
+
+    /// Draw the command line at the bottom of the window.
+    pub fn draw(&self, rld: &mut RaylibDrawHandle) {
+        let pos = Vec2::new(150., rld.get_screen_height() as f32 - 25.);
+
+        rld.draw_rectangle_v(
+            pos,
+            Vec2::new(rld.get_screen_width() as f32 - pos.x, 25.),
+            DEFAULT_COLOURS.cli_background,
+        );
+        rld.draw_text(
+            &self.text,
+            155,
+            rld.get_screen_height() - 22,
+            20,
+            DEFAULT_COLOURS.cli_foreground,
+        );
+    }
+}
diff --git a/src/colours.rs b/src/colours.rs
index d381266..d7c728c 100644
--- a/src/colours.rs
+++ b/src/colours.rs
@@ -39,6 +39,10 @@ pub struct Colours {
     /// The colour used for drawing the lines of the grid which divides the map into chunks of evenly
     /// spaced cells.
     pub grid_lines: Color,
+    /// Color used to draw the background of the Command Line Interface
+    pub cli_background: Color,
+    /// Color used to draw the normal text of the Command Line Interface
+    pub cli_foreground: Color,
 }
 
 impl Colours {
@@ -137,6 +141,18 @@ impl Colours {
                 b: 255,
                 a: 75,
             },
+            cli_background: Color {
+                r: 100,
+                g: 100,
+                b: 100,
+                a: 150,
+            },
+            cli_foreground: Color {
+                r: 255,
+                g: 255,
+                b: 255,
+                a: 200,
+            },
         }
     }
 }
diff --git a/src/editor.rs b/src/editor.rs
index d541fb6..e652ddc 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -121,20 +121,6 @@ impl Editor {
             }
         }
 
-        /*
-        TODO: reintroduce saving and loading
-        // Handle saving and loading the editor contents to the swap file
-        if rl.is_key_pressed(KeyboardKey::KEY_S) {
-            self.map_data
-                .write_file("swap.ron")
-                .expect("Unable to write buffer file");
-        } else if rl.is_key_pressed(KeyboardKey::KEY_L) {
-            self.map_data
-                .load_file("swap.ron")
-                .expect("Unable to read buffer file");
-        }
-        */
-
         let mouse_pos_m = transform.point_px_to_m(&rl.get_mouse_position().into());
         let snapped_mouse_pos = snap_to_grid(mouse_pos_m, SNAP_SIZE);
 
diff --git a/src/gui/tool_sidebar.rs b/src/gui/tool_sidebar.rs
index e6b8867..c123e2f 100644
--- a/src/gui/tool_sidebar.rs
+++ b/src/gui/tool_sidebar.rs
@@ -30,6 +30,9 @@ impl ToolSidebar {
     }
 
     fn panel_rect(screen_height: u16) -> Rect<f32> {
+        /* The width is currently hardcoded as 104, which is
+         * 64 (button-size) + 20 left gap + 20 right gap
+         */
         Rect::new(0., 0., 104., screen_height as f32)
     }
 
diff --git a/src/main.rs b/src/main.rs
index 1cfc31b..78be56b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -22,6 +22,7 @@
 extern crate log;
 
 pub mod button;
+pub mod cli;
 pub mod colours;
 pub mod config;
 pub mod editor;
@@ -34,6 +35,7 @@ pub mod tool;
 pub mod transform;
 pub mod transformable;
 
+use cli::CLI;
 use config::Config;
 use editor::Editor;
 use gui::{DimensionIndicator, ToolSidebar};
@@ -86,6 +88,7 @@ fn main() {
     let mut editor = Editor::new(&mut rl, &thread, config);
     let mut dimension_indicator = DimensionIndicator::new();
     let tool_sidebar = ToolSidebar::new(&mut rl, &thread);
+    let mut cli = CLI::new();
 
     let mut transform = Transform::new();
     let mut last_mouse_pos = rl.get_mouse_position();
@@ -110,8 +113,8 @@ fn main() {
             );
         }
 
+        cli.update(&mut rl, &mut editor);
         dimension_indicator.update(editor.map_mut(), &mut rl);
-
         editor.update(
             &mut rl,
             &transform,
@@ -129,6 +132,7 @@ fn main() {
             gui::position_indicator_draw(&mut d, last_mouse_pos.into(), &transform);
             dimension_indicator.draw(&mut d, &transform);
             tool_sidebar.draw(screen_height as u16, &mut d, &mut editor);
+            cli.draw(&mut d);
         }
     }
 }
diff --git a/src/map/data.rs b/src/map/data.rs
index 1031d3c..b7719cd 100644
--- a/src/map/data.rs
+++ b/src/map/data.rs
@@ -1,6 +1,6 @@
 //! Module containing the raw map data version of the map.
 
-use super::{IconData, PolygonRoomData, RectRoomData, WallData};
+use super::{IconData, Map, PolygonRoomData, RectRoomData, WallData};
 use ron::de::from_reader;
 use ron::ser::{to_string_pretty, PrettyConfig};
 use serde::{Deserialize, Serialize};
@@ -35,6 +35,35 @@ impl MapData {
         }
     }
 
+    /// Creates a data struct from the Map. It is important to note, that this data element is not
+    /// bound to the Map in any way after this, so changing anything won't change anything in the map.
+    /// It is useful however to for instance serialize this map without extra rendering information
+    /// included.
+    pub fn extract_data(map: &Map) -> Self {
+        Self {
+            rect_rooms: map
+                .rect_rooms()
+                .iter()
+                .map(|r| (r as &RectRoomData).clone())
+                .collect(),
+            polygon_rooms: map
+                .polygon_rooms()
+                .iter()
+                .map(|p| (p as &PolygonRoomData).clone())
+                .collect(),
+            walls: map
+                .walls()
+                .iter()
+                .map(|w| (w as &WallData).clone())
+                .collect(),
+            icons: map
+                .icons()
+                .iter()
+                .map(|i| (i as &IconData).clone())
+                .collect(),
+        }
+    }
+
     /// Load the map data from a file. Fails if the file does not exist or cannot be correctly parsed.
     pub fn load_from_file<P: AsRef<Path>>(&mut self, path: P) -> io::Result<Self> {
         let file = File::open(&path)?;
diff --git a/src/map/mod.rs b/src/map/mod.rs
index 88a7e6c..28025ad 100644
--- a/src/map/mod.rs
+++ b/src/map/mod.rs
@@ -146,4 +146,20 @@ impl Map {
             .chain(self.walls.iter_mut().map(|w| w as &mut dyn Mappable))
             .chain(self.icons.iter_mut().map(|i| i as &mut dyn Mappable))
     }
+
+    pub fn rect_rooms(&self) -> &Vec<RectRoom> {
+        &self.rect_rooms
+    }
+
+    pub fn polygon_rooms(&self) -> &Vec<PolygonRoom> {
+        &self.polygon_rooms
+    }
+
+    pub fn walls(&self) -> &Vec<Wall> {
+        &self.walls
+    }
+
+    pub fn icons(&self) -> &Vec<Icon> {
+        &self.icons
+    }
 }
diff --git a/src/map/polygon_room.rs b/src/map/polygon_room.rs
index fd4122e..a57f5e4 100644
--- a/src/map/polygon_room.rs
+++ b/src/map/polygon_room.rs
@@ -8,6 +8,7 @@ use crate::transform::Transform;
 use crate::transformable::NonRigidTransformable;
 use nalgebra::{Matrix3, Point2};
 use raylib::drawing::{RaylibDraw, RaylibDrawHandle};
+use std::ops::Deref;
 
 /// Data type for the Polygon room.
 pub type PolygonRoomData = Polygon<f64>;
@@ -85,3 +86,11 @@ impl NonRigidTransformable for PolygonRoom {
         self.retriangulate();
     }
 }
+
+impl Deref for PolygonRoom {
+    type Target = PolygonRoomData;
+
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}