From 53d376eaeef991850d35318b147f75c8f103319d Mon Sep 17 00:00:00 2001 From: Arne Dußin Date: Sun, 27 Dec 2020 21:54:31 +0100 Subject: Change to polygongraph instead of polygon in roomtool The polygon room tool used a convoluted process for determining what the user actually wants to draw. I have changed to the polygon graph instead, which makes the checks easier and restricts the user a bit less. In the process however I found a serious problem with my handling float, so everything needed to change to margin compares (which I of course should have done in the beginning. Guys, take the warning seriously and don't ignore it for ten years like I did. It will come back to haunt you.. apparently) instead of direct equality. --- src/gui/tool_sidebar.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/gui/tool_sidebar.rs') diff --git a/src/gui/tool_sidebar.rs b/src/gui/tool_sidebar.rs index e6b8867..b7618e0 100644 --- a/src/gui/tool_sidebar.rs +++ b/src/gui/tool_sidebar.rs @@ -3,7 +3,7 @@ // TODO: Currently, the keyboard shortcuts for tools are handled by the editor, but a lot speaks for // them being handled by the ToolSidebar instead. -use crate::math::{Rect, Surface, Vec2}; +use crate::math::{ExactSurface, Rect, Vec2}; use crate::tool::ToolType; use crate::Editor; use raylib::core::texture::Texture2D; -- cgit v1.2.3-70-g09d2 From 61d255a420c9d977b46670e7fa9e7735d2acf819 Mon Sep 17 00:00:00 2001 From: Arne Dußin Date: Wed, 6 Jan 2021 21:32:48 +0100 Subject: Add CLI with save feature --- src/cli/cmd/mod.rs | 53 ++++++++++++++++++++++++ src/cli/cmd/save.rs | 42 +++++++++++++++++++ src/cli/mod.rs | 104 ++++++++++++++++++++++++++++++++++++++++++++++++ src/colours.rs | 16 ++++++++ src/editor.rs | 14 ------- src/gui/tool_sidebar.rs | 3 ++ src/main.rs | 6 ++- src/map/data.rs | 31 ++++++++++++++- src/map/mod.rs | 16 ++++++++ src/map/polygon_room.rs | 9 +++++ 10 files changed, 278 insertions(+), 16 deletions(-) create mode 100644 src/cli/cmd/mod.rs create mode 100644 src/cli/cmd/save.rs create mode 100644 src/cli/mod.rs (limited to 'src/gui/tool_sidebar.rs') 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), + #[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, 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; +} + +/// 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; +} 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 { + 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 { + 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 { + /* 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>(&mut self, path: P) -> io::Result { 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 { + &self.rect_rooms + } + + pub fn polygon_rooms(&self) -> &Vec { + &self.polygon_rooms + } + + pub fn walls(&self) -> &Vec { + &self.walls + } + + pub fn icons(&self) -> &Vec { + &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; @@ -85,3 +86,11 @@ impl NonRigidTransformable for PolygonRoom { self.retriangulate(); } } + +impl Deref for PolygonRoom { + type Target = PolygonRoomData; + + fn deref(&self) -> &Self::Target { + &self.data + } +} -- cgit v1.2.3-70-g09d2