Add wall tool

The wall tool is currently just one pixels lines, which must be changed
in the future, of course, but this is also to test changing between
tools.

4 files changed, 141 insertions, 16 deletions

diff --git a/src/main.rs b/src/main.rs
index 3f36123..723a1fd 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,12 +6,12 @@ pub mod transform;
 pub use transform::Transform;
 
 use raylib::prelude::*;
-use tool::{RoomTool, Tool};
+use tool::{Tool, ToolShed};
 
 fn main() {
     let (mut rl, thread) = raylib::init().resizable().title("Hello there!").build();
 
-    let mut current_tool = RoomTool::new();
+    let mut tool_shed = ToolShed::new();
 
     let mut transform = Transform::new();
     let mut last_mouse_pos = rl.get_mouse_position();
@@ -31,7 +31,7 @@ fn main() {
             transform.try_zoom_out();
         }
 
-        current_tool.update(&rl, &transform);
+        tool_shed.update(&rl, &transform);
 
         // Update the last mouse position
         last_mouse_pos = rl.get_mouse_position();
@@ -42,7 +42,7 @@ fn main() {
             d.clear_background(Color::BLACK);
             grid::draw_grid(&mut d, screen_width, screen_height, &transform);
 
-            current_tool.draw(&mut d, &transform);
+            tool_shed.draw_tools(&mut d, &transform);
         }
     }
 }
diff --git a/src/tool/mod.rs b/src/tool/mod.rs
index e0d4f1e..3e6200f 100644
--- a/src/tool/mod.rs
+++ b/src/tool/mod.rs
@@ -1,16 +1,65 @@
 pub mod room_tool;
 pub use room_tool::RoomTool;
 
+pub mod wall_tool;
+pub use wall_tool::WallTool;
+
 use crate::transform::Transform;
-use raylib::core::drawing::RaylibDraw;
+use raylib::core::drawing::RaylibDrawHandle;
+use raylib::ffi::KeyboardKey;
 use raylib::RaylibHandle;
 
+#[derive(Debug)]
+#[repr(u8)]
+pub enum ToolType {
+    RoomTool,
+    WallTool,
+    NumTools,
+}
+
 pub trait Tool {
-    fn update(&mut self, rl: &RaylibHandle, transform: &Transform);
+    fn update(&mut self, rl: &RaylibHandle, transform: &Transform) {}
+    fn active_update(&mut self, rl: &RaylibHandle, transform: &Transform);
+
+    fn draw(&self, _rld: &mut RaylibDrawHandle, _transform: &Transform) {}
+}
+
+pub struct ToolShed {
+    tools: Vec<Box<dyn Tool>>,
+    active: usize,
+}
+
+impl ToolShed {
+    pub fn new() -> Self {
+        let mut tools: Vec<Box<dyn Tool>> = Vec::with_capacity(ToolType::NumTools as usize);
+        assert_eq!(ToolType::RoomTool as u8, 0);
+        tools.push(Box::new(RoomTool::new()));
+        assert_eq!(ToolType::WallTool as u8, 1);
+        tools.push(Box::new(WallTool::new()));
+
+        Self { tools, active: 0 }
+    }
+
+    pub fn update(&mut self, rl: &RaylibHandle, transform: &Transform) {
+        // Handle keybindings for tool change
+        self.active = if rl.is_key_pressed(KeyboardKey::KEY_R) {
+            ToolType::RoomTool as usize
+        } else if rl.is_key_pressed(KeyboardKey::KEY_W) {
+            ToolType::WallTool as usize
+        } else {
+            self.active
+        };
+
+        for tool in &mut self.tools {
+            tool.update(rl, transform);
+        }
+
+        self.tools[self.active].active_update(rl, transform);
+    }
 
-    fn draw<D>(&self, _rld: &mut D, _transform: &Transform)
-    where
-        D: RaylibDraw,
-    {
+    pub fn draw_tools(&self, rld: &mut RaylibDrawHandle, transform: &Transform) {
+        for tool in &self.tools {
+            tool.draw(rld, transform);
+        }
     }
 }
diff --git a/src/tool/room_tool.rs b/src/tool/room_tool.rs
index 6a9ad55..10b9edf 100644
--- a/src/tool/room_tool.rs
+++ b/src/tool/room_tool.rs
@@ -1,7 +1,7 @@
 use super::Tool;
 use crate::math;
 use crate::transform::Transform;
-use raylib::core::drawing::RaylibDraw;
+use raylib::core::drawing::{RaylibDraw, RaylibDrawHandle};
 use raylib::ffi::{Color, MouseButton};
 use raylib::math::{Rectangle, Vector2};
 use raylib::RaylibHandle;
@@ -25,7 +25,7 @@ impl RoomTool {
 }
 
 impl Tool for RoomTool {
-    fn update(&mut self, rl: &RaylibHandle, transform: &Transform) {
+    fn active_update(&mut self, rl: &RaylibHandle, transform: &Transform) {
         let mouse_pos_m = transform.point_px_to_m(rl.get_mouse_position());
         // Update the currently drawn rectangle, if it exists
         if let Some((_, ref mut pos2)) = &mut self.unfinished_rect {
@@ -56,10 +56,7 @@ impl Tool for RoomTool {
         }
     }
 
-    fn draw<D>(&self, rld: &mut D, transform: &Transform)
-    where
-        D: RaylibDraw,
-    {
+    fn draw(&self, rld: &mut RaylibDrawHandle, transform: &Transform) {
         // Draw all finished rectangles.
         for &rect in &self.room_rects {
             rld.draw_rectangle_rec(
diff --git a/src/tool/wall_tool.rs b/src/tool/wall_tool.rs
new file mode 100644
index 0000000..8d018c6
--- /dev/null
+++ b/src/tool/wall_tool.rs
@@ -0,0 +1,79 @@
+use super::Tool;
+use crate::math;
+use crate::transform::Transform;
+use raylib::core::drawing::{RaylibDraw, RaylibDrawHandle};
+use raylib::ffi::{Color, MouseButton};
+use raylib::math::Vector2;
+use raylib::RaylibHandle;
+
+pub struct WallTool {
+    walls: Vec<(Vector2, Vector2)>,
+    unfinished_wall: Option<(Vector2, Vector2)>,
+}
+
+impl WallTool {
+    pub fn new() -> Self {
+        Self {
+            walls: Vec::new(),
+            unfinished_wall: None,
+        }
+    }
+}
+
+impl Tool for WallTool {
+    fn active_update(&mut self, rl: &RaylibHandle, transform: &Transform) {
+        let mouse_pos_m = transform.point_px_to_m(rl.get_mouse_position());
+        if let Some((_, ref mut pos2)) = &mut self.unfinished_wall {
+            let snapped_mouse_pos = Vector2::new(
+                math::round(mouse_pos_m.x, 0.5),
+                math::round(mouse_pos_m.y, 0.5),
+            );
+            *pos2 = snapped_mouse_pos;
+        }
+
+        if rl.is_mouse_button_pressed(MouseButton::MOUSE_LEFT_BUTTON) {
+            if let Some((pos1, pos2)) = self.unfinished_wall {
+                self.walls.push((pos1, pos2));
+                self.unfinished_wall = None;
+            } else {
+                let snapped_mouse_pos = Vector2::new(
+                    math::round(mouse_pos_m.x, 0.5),
+                    math::round(mouse_pos_m.y, 0.5),
+                );
+                self.unfinished_wall = Some((snapped_mouse_pos, snapped_mouse_pos))
+            }
+        }
+
+        if rl.is_mouse_button_pressed(MouseButton::MOUSE_RIGHT_BUTTON) {
+            self.unfinished_wall = None;
+        }
+    }
+
+    fn draw(&self, rld: &mut RaylibDrawHandle, transform: &Transform) {
+        for &(pos1, pos2) in &self.walls {
+            rld.draw_line_v(
+                transform.point_m_to_px(pos1),
+                transform.point_m_to_px(pos2),
+                Color {
+                    r: 200,
+                    g: 150,
+                    b: 150,
+                    a: 255,
+                },
+            );
+        }
+
+        if let Some((pos1, pos2)) = self.unfinished_wall {
+            rld.draw_line_v(
+                transform.point_m_to_px(pos1),
+                transform.point_m_to_px(pos2),
+                Color {
+                    r: 150,
+                    g: 200,
+                    b: 150,
+                    a: 255,
+                },
+            );
+        }
+    }
+}