Refactor a major part of the project

In order to be able to save and load the map, a major rework of the code
seemed necessary, since Vector2 and Rectangle of raylib do not implement
serialize, and it seems cleanest to use the serialize/deserialize traits
of serde, to save for instance to RON. ToolShed was renamed to Editor,
since it should better show, that it does quite a bit more than harbour
tools. The map data is now centrally saved in the editor, instead of
decentralised in the tool structs.

11 files changed, 581 insertions, 123 deletions

diff --git a/src/editor.rs b/src/editor.rs
new file mode 100644
index 0000000..9dcbefc
--- /dev/null
+++ b/src/editor.rs
@@ -0,0 +1,59 @@
+use crate::map_data::MapData;
+use crate::tool::*;
+use crate::transform::Transform;
+use raylib::core::drawing::RaylibDrawHandle;
+use raylib::ffi::KeyboardKey;
+use raylib::RaylibHandle;
+
+pub struct Editor {
+    map_data: MapData,
+    tools: Vec<Box<dyn Tool>>,
+    active: usize,
+}
+
+impl Editor {
+    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()));
+        assert_eq!(ToolType::DeletionTool as u8, 2);
+        tools.push(Box::new(DeletionTool::new()));
+
+        assert_eq!(ToolType::NumTools as usize, tools.len());
+
+        Self {
+            map_data: MapData::new(),
+            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(&self.map_data, rl, transform);
+        }
+
+        self.tools[self.active].active_update(&mut self.map_data, rl, transform);
+    }
+
+    pub fn draw_tools(&self, rld: &mut RaylibDrawHandle, transform: &Transform) {
+        for tool in &self.tools {
+            tool.draw(&self.map_data, rld, transform);
+        }
+    }
+
+    pub fn map_data(&self) -> &MapData {
+        &self.map_data
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 723a1fd..9ba63e0 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,17 +1,18 @@
+pub mod editor;
 pub mod grid;
+pub mod map_data;
 pub mod math;
 pub mod tool;
 pub mod transform;
 
-pub use transform::Transform;
-
+use editor::Editor;
 use raylib::prelude::*;
-use tool::{Tool, ToolShed};
+use transform::Transform;
 
 fn main() {
     let (mut rl, thread) = raylib::init().resizable().title("Hello there!").build();
 
-    let mut tool_shed = ToolShed::new();
+    let mut editor = Editor::new();
 
     let mut transform = Transform::new();
     let mut last_mouse_pos = rl.get_mouse_position();
@@ -21,7 +22,7 @@ fn main() {
 
         // Move the canvas together with the mouse
         if rl.is_mouse_button_down(MouseButton::MOUSE_MIDDLE_BUTTON) {
-            transform.move_by_px(rl.get_mouse_position() - last_mouse_pos);
+            transform.move_by_px((rl.get_mouse_position() - last_mouse_pos).into());
         }
 
         // Handle scrolling of the canvas
@@ -31,7 +32,7 @@ fn main() {
             transform.try_zoom_out();
         }
 
-        tool_shed.update(&rl, &transform);
+        editor.update(&rl, &transform);
 
         // Update the last mouse position
         last_mouse_pos = rl.get_mouse_position();
@@ -42,7 +43,7 @@ fn main() {
             d.clear_background(Color::BLACK);
             grid::draw_grid(&mut d, screen_width, screen_height, &transform);
 
-            tool_shed.draw_tools(&mut d, &transform);
+            editor.draw_tools(&mut d, &transform);
         }
     }
 }
diff --git a/src/map_data.rs b/src/map_data.rs
new file mode 100644
index 0000000..d958736
--- /dev/null
+++ b/src/map_data.rs
@@ -0,0 +1,44 @@
+use crate::math::{Rect, Vec2};
+use serde::{Deserialize, Serialize};
+use std::io;
+use std::path::Path;
+
+/// All the data of the currently opened map. This does not include things that are currently being
+/// drawn, but not finished. It also does not contain Metadata, like the current position of the
+/// transform, or the zoom-level
+#[derive(Serialize, Deserialize)]
+pub struct MapData {
+    rooms: Vec<Rect<f32>>,
+    walls: Vec<(Vec2<f32>, Vec2<f32>)>,
+}
+
+impl MapData {
+    pub fn new() -> Self {
+        Self {
+            rooms: Vec::new(),
+            walls: Vec::new(),
+        }
+    }
+
+    pub fn load_file<P: AsRef<Path>>(&mut self, path: P) -> io::Result<MapData> {
+        todo!()
+    }
+
+    pub fn write_file<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
+        todo!()
+    }
+
+    pub fn rooms(&self) -> &Vec<Rect<f32>> {
+        &self.rooms
+    }
+    pub fn rooms_mut(&mut self) -> &mut Vec<Rect<f32>> {
+        &mut self.rooms
+    }
+
+    pub fn walls(&self) -> &Vec<(Vec2<f32>, Vec2<f32>)> {
+        &self.walls
+    }
+    pub fn walls_mut(&mut self) -> &mut Vec<(Vec2<f32>, Vec2<f32>)> {
+        &mut self.walls
+    }
+}
diff --git a/src/math.rs b/src/math/mod.rs
index 60a53e8..07d518e 100644
--- a/src/math.rs
+++ b/src/math/mod.rs
@@ -1,21 +1,8 @@
-use raylib::math::{Rectangle, Vector2};
+pub mod rect;
+pub use self::rect::*;
 
-/// Function to calculate the bounding rectangle that is between two vectors. The order of the
-/// vectors is irrelevent for this. As long as they are diagonally opposite of each other, this
-/// function will work.
-pub fn bounding_rect(pos1: Vector2, pos2: Vector2) -> Rectangle {
-    let min_x = pos1.x.min(pos2.x);
-    let min_y = pos1.y.min(pos2.y);
-    let max_x = pos1.x.max(pos2.x);
-    let max_y = pos1.y.max(pos2.y);
-
-    Rectangle {
-        x: min_x,
-        y: min_y,
-        width: max_x - min_x,
-        height: max_y - min_y,
-    }
-}
+pub mod vec2;
+pub use self::vec2::*;
 
 /// Round a floating point number to the nearest step given by the step argument. For instance, if
 /// the step is 0.5, then all numbers from 0.0 to 0.24999... will be 0., while all numbers from
diff --git a/src/math/rect.rs b/src/math/rect.rs
new file mode 100644
index 0000000..c126d56
--- /dev/null
+++ b/src/math/rect.rs
@@ -0,0 +1,178 @@
+use super::Vec2;
+use nalgebra::{RealField, Scalar};
+use serde::{Deserialize, Serialize};
+use std::ops::{Add, AddAssign};
+
+/// Represents a Rectangle with the value type T.
+#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize)]
+pub struct Rect<T: Scalar + Copy> {
+    /// The x coordinate, or leftmost coordinate of the Rect.
+    pub x: T,
+    /// The y coordinate, or rightmost coordinate of the Rect.
+    pub y: T,
+    /// The width of the Rect.
+    pub w: T,
+    /// The height of the Rect.
+    pub h: T,
+}
+
+// This is sad, but also sadly necessary :/
+impl<T: Into<f32> + Scalar + Copy> Into<raylib::ffi::Rectangle> for Rect<T> {
+    fn into(self) -> raylib::ffi::Rectangle {
+        raylib::ffi::Rectangle {
+            x: self.x.into(),
+            y: self.y.into(),
+            width: self.w.into(),
+            height: self.h.into(),
+        }
+    }
+}
+impl<T: From<f32> + Scalar + Copy> From<raylib::ffi::Rectangle> for Rect<T> {
+    fn from(r: raylib::ffi::Rectangle) -> Self {
+        Self {
+            x: T::from(r.x),
+            y: T::from(r.y),
+            w: T::from(r.width),
+            h: T::from(r.height),
+        }
+    }
+}
+impl<T: Into<f32> + Scalar + Copy> Into<raylib::math::Rectangle> for Rect<T> {
+    fn into(self) -> raylib::math::Rectangle {
+        raylib::math::Rectangle {
+            x: self.x.into(),
+            y: self.y.into(),
+            width: self.w.into(),
+            height: self.h.into(),
+        }
+    }
+}
+impl<T: From<f32> + Scalar + Copy> From<raylib::math::Rectangle> for Rect<T> {
+    fn from(r: raylib::math::Rectangle) -> Self {
+        Self {
+            x: T::from(r.x),
+            y: T::from(r.y),
+            w: T::from(r.width),
+            h: T::from(r.height),
+        }
+    }
+}
+
+impl<T: Scalar + Copy> Rect<T> {
+    pub fn new(x: T, y: T, w: T, h: T) -> Self {
+        Self { x, y, w, h }
+    }
+
+    /// Create a Rectangle from a slice. Indices are [x, y, w, h].
+    pub fn from_slice(slice: [T; 4]) -> Rect<T>
+    where
+        T: Copy,
+    {
+        Rect {
+            x: slice[0],
+            y: slice[1],
+            w: slice[2],
+            h: slice[3],
+        }
+    }
+
+    /// Move by the Vec provided.
+    pub fn translate(&mut self, by: Vec2<T>)
+    where
+        T: AddAssign,
+    {
+        self.x += by.x;
+        self.y += by.y;
+    }
+
+    /// Set the posiotien of the rectangle to the given one without changing its
+    /// size
+    pub fn set_pos(&mut self, pos: Vec2<T>) {
+        self.x = pos.x;
+        self.y = pos.y;
+    }
+
+    /// Test if two rectangles intersect.
+    pub fn intersect<'a>(this: &'a Rect<T>, other: &'a Rect<T>) -> bool
+    where
+        T: Add<Output = T> + PartialOrd + Copy,
+    {
+        !(this.x > other.x + other.w
+            || this.x + this.w < other.x
+            || this.y > other.y + other.h
+            || this.y + this.h < other.y)
+    }
+
+    /// Check if the point is inside this Rect and return true if so.
+    pub fn contains(&self, point: Vec2<T>) -> bool
+    where
+        T: PartialOrd + Add<Output = T>,
+    {
+        point.x >= self.x
+            && point.x <= self.x + self.w
+            && point.y >= self.y
+            && point.y <= self.y + self.h
+    }
+
+    /// Function to calculate the bounding rectangle that is between two vectors. The order of the
+    /// vectors is irrelevent for this. As long as they are diagonally opposite of each other, this
+    /// function will work.
+    pub fn bounding_rect(pos1: Vec2<T>, pos2: Vec2<T>) -> Self
+    where
+        T: RealField,
+    {
+        let min_x = pos1.x.min(pos2.x);
+        let min_y = pos1.y.min(pos2.y);
+        let max_x = pos1.x.max(pos2.x);
+        let max_y = pos1.y.max(pos2.y);
+
+        Self {
+            x: min_x,
+            y: min_y,
+            w: max_x - min_x,
+            h: max_y - min_y,
+        }
+    }
+
+    /// Get the shortest way that must be applied to this Rect to clear out of
+    /// another Rect of the same type so that they would not intersect any more.
+    pub fn shortest_way_out(&self, of: &Rect<T>) -> Vec2<T>
+    where
+        T: RealField,
+    {
+        // Check upwards
+        let mut move_y = of.y - self.y - self.h;
+        // Check downwards
+        let move_down = of.y + of.h - self.y;
+        if move_down < -move_y {
+            move_y = move_down;
+        }
+
+        // Check left
+        let mut move_x = of.x - self.x - self.w;
+        // Check right
+        let move_right = of.x + of.w - self.x;
+        if move_right < -move_x {
+            move_x = move_right;
+        }
+
+        if move_x.abs() < move_y.abs() {
+            Vec2::new(move_x, T::zero())
+        } else {
+            Vec2::new(T::zero(), move_y)
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_intersect() {
+        let a = Rect::from_slice([0, 0, 4, 4]);
+        let b = Rect::from_slice([-1, -1, 1, 1]);
+
+        assert!(Rect::intersect(&a, &b));
+    }
+}
diff --git a/src/math/vec2.rs b/src/math/vec2.rs
new file mode 100644
index 0000000..ea549d7
--- /dev/null
+++ b/src/math/vec2.rs
@@ -0,0 +1,233 @@
+use crate::math::Rect;
+use alga::general::{ClosedAdd, ClosedSub};
+use nalgebra::{RealField, Scalar};
+use serde::{Deserialize, Serialize};
+use std::cmp::Ordering;
+use std::convert::{From, Into};
+use std::fmt;
+use std::ops::{Add, AddAssign, Div, Mul, Sub, SubAssign};
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd, Serialize, Deserialize, Eq)]
+pub struct Vec2<T: Scalar + Copy> {
+    pub x: T,
+    pub y: T,
+}
+
+impl<T: Scalar + Copy> Vec2<T> {
+    pub fn new(x: T, y: T) -> Self {
+        Self { x, y }
+    }
+
+    pub fn len(&self) -> T
+    where
+        T: RealField,
+    {
+        (self.x * self.x + self.y * self.y).sqrt()
+    }
+}
+
+// This is sad, but also sadly necessary :/
+impl<T> Into<raylib::ffi::Vector2> for Vec2<T>
+where
+    T: Into<f32> + Scalar + Copy,
+{
+    fn into(self) -> raylib::ffi::Vector2 {
+        raylib::ffi::Vector2 {
+            x: self.x.into(),
+            y: self.y.into(),
+        }
+    }
+}
+
+impl<T> From<raylib::ffi::Vector2> for Vec2<T>
+where
+    T: From<f32> + Scalar + Copy,
+{
+    fn from(v: raylib::ffi::Vector2) -> Self {
+        Self {
+            x: T::from(v.x),
+            y: T::from(v.y),
+        }
+    }
+}
+impl<T: Scalar + Copy> Into<raylib::math::Vector2> for Vec2<T>
+where
+    T: Into<f32>,
+{
+    fn into(self) -> raylib::math::Vector2 {
+        raylib::math::Vector2 {
+            x: self.x.into(),
+            y: self.y.into(),
+        }
+    }
+}
+
+impl<T: Scalar + Copy> From<raylib::math::Vector2> for Vec2<T>
+where
+    T: From<f32>,
+{
+    fn from(v: raylib::math::Vector2) -> Self {
+        Self {
+            x: T::from(v.x),
+            y: T::from(v.y),
+        }
+    }
+}
+
+// Begin mathematical operators -----------------------------------------------
+
+// Addition
+impl<T: Scalar + ClosedAdd + Copy> Add for Vec2<T> {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self {
+        Vec2::new(self.x + rhs.x, self.y + rhs.y)
+    }
+}
+
+impl<T: Scalar + ClosedAdd + Copy> Add<(T, T)> for Vec2<T> {
+    type Output = Self;
+
+    fn add(self, (x, y): (T, T)) -> Self {
+        Vec2::new(self.x + x, self.y + y)
+    }
+}
+
+impl<T: Scalar + ClosedAdd + Copy> Add<T> for Vec2<T> {
+    type Output = Self;
+
+    fn add(self, rhs: T) -> Self {
+        Vec2::new(self.x + rhs, self.y + rhs)
+    }
+}
+
+impl<T: Scalar + AddAssign + Copy> AddAssign for Vec2<T> {
+    fn add_assign(&mut self, rhs: Self) {
+        self.x += rhs.x;
+        self.y += rhs.y;
+    }
+}
+
+impl<T: Scalar + AddAssign + Copy> AddAssign<(T, T)> for Vec2<T> {
+    fn add_assign(&mut self, (x, y): (T, T)) {
+        self.x += x;
+        self.y += y;
+    }
+}
+
+// Subtraction
+impl<T: Scalar + ClosedSub + Copy> Sub for Vec2<T> {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self {
+        Vec2::new(self.x - rhs.x, self.y - rhs.y)
+    }
+}
+
+impl<T: Scalar + ClosedSub + Copy> Sub<(T, T)> for Vec2<T> {
+    type Output = Self;
+
+    fn sub(self, (x, y): (T, T)) -> Self {
+        Vec2::new(self.x - x, self.y - y)
+    }
+}
+
+impl<T: Scalar + ClosedSub + Copy> Sub<T> for Vec2<T> {
+    type Output = Self;
+
+    fn sub(self, rhs: T) -> Self {
+        Vec2::new(self.x - rhs, self.y - rhs)
+    }
+}
+
+impl<T: Scalar + SubAssign + Copy> SubAssign for Vec2<T> {
+    fn sub_assign(&mut self, rhs: Self) {
+        self.x -= rhs.x;
+        self.y -= rhs.y;
+    }
+}
+
+impl<T: Scalar + SubAssign + Copy> SubAssign<(T, T)> for Vec2<T> {
+    fn sub_assign(&mut self, (x, y): (T, T)) {
+        self.x -= x;
+        self.y -= y;
+    }
+}
+
+// Scalar multiplication
+impl<T: Scalar + Add<Output = T> + Mul<Output = T> + Copy> Mul for Vec2<T> {
+    type Output = T;
+
+    fn mul(self, rhs: Self) -> T {
+        self.x * rhs.x + self.y * rhs.y
+    }
+}
+
+impl<T: Scalar + Mul<Output = T> + Copy> Mul<T> for Vec2<T> {
+    type Output = Self;
+
+    fn mul(self, rhs: T) -> Self {
+        Vec2::new(self.x * rhs, self.y * rhs)
+    }
+}
+
+impl<T: Scalar + Div<Output = T> + Copy> Div<T> for Vec2<T> {
+    type Output = Self;
+
+    fn div(self, rhs: T) -> Self {
+        Vec2::new(self.x / rhs, self.y / rhs)
+    }
+}
+
+// End of mathematical operators ----------------------------------------------
+
+// By default, the coordinates are first compared by their y-coordinates, then
+// their x-coordinates
+impl<T: fmt::Debug> Ord for Vec2<T>
+where
+    T: Ord + Copy + 'static,
+{
+    fn cmp(&self, other: &Self) -> Ordering {
+        match self.y.cmp(&other.y) {
+            Ordering::Equal => self.x.cmp(&other.x),
+            y_order => y_order,
+        }
+    }
+}
+
+// Helper function to determine the absolute positive difference between two
+// Values, which don't have to be signed.
+fn difference_abs<T>(a: T, b: T) -> T
+where
+    T: ClosedSub + PartialOrd,
+{
+    if a > b {
+        a - b
+    } else {
+        b - a
+    }
+}
+
+// Helper function that removes all points inside the vector that are not
+// contained inside the optional limit Rect
+fn retain_inside_limits<T: 'static>(items: Vec<Vec2<T>>, limits: Option<Rect<T>>) -> Vec<Vec2<T>>
+where
+    T: PartialOrd + std::fmt::Debug + Copy + Add<Output = T>,
+{
+    // Fast return in case there are no limits
+    if limits.is_none() {
+        return items;
+    }
+    let limits = limits.unwrap();
+
+    // Retain only items that are within the bounds of the limits rect
+    items
+        .into_iter()
+        .filter(|v| {
+            v.x >= limits.x
+                && v.x <= limits.x + limits.w
+                && v.y >= limits.y
+                && v.y <= limits.y + limits.h
+        })
+        .collect()
+}
diff --git a/src/tool/deletion_tool.rs b/src/tool/deletion_tool.rs
index 4d255d9..3eca92a 100644
--- a/src/tool/deletion_tool.rs
+++ b/src/tool/deletion_tool.rs
@@ -1,4 +1,5 @@
 use super::Tool;
+use crate::map_data::MapData;
 use crate::transform::Transform;
 use raylib::core::drawing::RaylibDrawHandle;
 use raylib::RaylibHandle;
@@ -12,8 +13,8 @@ impl DeletionTool {
 }
 
 impl Tool for DeletionTool {
-    fn update(&mut self, rl: &RaylibHandle, transform: &Transform) {}
-    fn active_update(&mut self, rl: &RaylibHandle, transform: &Transform) {}
+    fn update(&mut self, map_data: &MapData, rl: &RaylibHandle, transform: &Transform) {}
+    fn active_update(&mut self, map_data: &mut MapData, rl: &RaylibHandle, transform: &Transform) {}
 
-    fn draw(&self, _rld: &mut RaylibDrawHandle, _transform: &Transform) {}
+    fn draw(&self, map_data: &MapData, _rld: &mut RaylibDrawHandle, _transform: &Transform) {}
 }
diff --git a/src/tool/mod.rs b/src/tool/mod.rs
index da95c61..73654d9 100644
--- a/src/tool/mod.rs
+++ b/src/tool/mod.rs
@@ -6,9 +6,9 @@ pub use deletion_tool::DeletionTool;
 pub use room_tool::RoomTool;
 pub use wall_tool::WallTool;
 
+use crate::map_data::MapData;
 use crate::transform::Transform;
 use raylib::core::drawing::RaylibDrawHandle;
-use raylib::ffi::KeyboardKey;
 use raylib::RaylibHandle;
 
 #[derive(Debug)]
@@ -21,52 +21,8 @@ pub enum ToolType {
 }
 
 pub trait Tool {
-    fn update(&mut self, rl: &RaylibHandle, transform: &Transform) {}
-    fn active_update(&mut self, rl: &RaylibHandle, transform: &Transform);
+    fn update(&mut self, _map: &MapData, _rl: &RaylibHandle, _transform: &Transform) {}
+    fn active_update(&mut self, map: &mut MapData, 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()));
-        assert_eq!(ToolType::DeletionTool as u8, 2);
-        tools.push(Box::new(DeletionTool::new()));
-
-        assert_eq!(ToolType::NumTools as usize, tools.len());
-
-        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);
-    }
-
-    pub fn draw_tools(&self, rld: &mut RaylibDrawHandle, transform: &Transform) {
-        for tool in &self.tools {
-            tool.draw(rld, transform);
-        }
-    }
+    fn draw(&self, _map: &MapData, _rld: &mut RaylibDrawHandle, _transform: &Transform) {}
 }
diff --git a/src/tool/room_tool.rs b/src/tool/room_tool.rs
index 10b9edf..0321ff3 100644
--- a/src/tool/room_tool.rs
+++ b/src/tool/room_tool.rs
@@ -1,35 +1,32 @@
 use super::Tool;
-use crate::math;
+use crate::map_data::MapData;
+use crate::math::{self, Rect, Vec2};
 use crate::transform::Transform;
 use raylib::core::drawing::{RaylibDraw, RaylibDrawHandle};
 use raylib::ffi::{Color, MouseButton};
-use raylib::math::{Rectangle, Vector2};
 use raylib::RaylibHandle;
 
 pub struct RoomTool {
-    /// Vector of all Rectangles representing rooms that have already been drawn.
-    room_rects: Vec<Rectangle>,
     /// The rectangle that is currently being drawn by the user. Once it is finished, it will be
     /// pushed into the room_rects.
-    unfinished_rect: Option<(Vector2, Vector2)>,
+    unfinished_rect: Option<(Vec2<f32>, Vec2<f32>)>,
 }
 
 impl RoomTool {
     /// Create a new room tool where no rooms have been drawn yet.
     pub fn new() -> Self {
         Self {
-            room_rects: Vec::new(),
             unfinished_rect: None,
         }
     }
 }
 
 impl Tool for RoomTool {
-    fn active_update(&mut self, rl: &RaylibHandle, transform: &Transform) {
-        let mouse_pos_m = transform.point_px_to_m(rl.get_mouse_position());
+    fn active_update(&mut self, map_data: &mut MapData, rl: &RaylibHandle, transform: &Transform) {
+        let mouse_pos_m = transform.point_px_to_m(rl.get_mouse_position().into());
         // Update the currently drawn rectangle, if it exists
         if let Some((_, ref mut pos2)) = &mut self.unfinished_rect {
-            let snapped_mouse_pos = Vector2::new(
+            let snapped_mouse_pos = Vec2::new(
                 math::round(mouse_pos_m.x, 0.5),
                 math::round(mouse_pos_m.y, 0.5),
             );
@@ -39,10 +36,10 @@ impl Tool for RoomTool {
         // Start or finish drawing the currently unfinished rectangle
         if rl.is_mouse_button_pressed(MouseButton::MOUSE_LEFT_BUTTON) {
             if let Some((pos1, pos2)) = self.unfinished_rect {
-                self.room_rects.push(math::bounding_rect(pos1, pos2));
+                map_data.rooms_mut().push(Rect::bounding_rect(pos1, pos2));
                 self.unfinished_rect = None;
             } else {
-                let snapped_mouse_pos = Vector2::new(
+                let snapped_mouse_pos = Vec2::new(
                     math::round(mouse_pos_m.x, 0.5),
                     math::round(mouse_pos_m.y, 0.5),
                 );
@@ -56,9 +53,9 @@ impl Tool for RoomTool {
         }
     }
 
-    fn draw(&self, rld: &mut RaylibDrawHandle, transform: &Transform) {
+    fn draw(&self, map_data: &MapData, rld: &mut RaylibDrawHandle, transform: &Transform) {
         // Draw all finished rectangles.
-        for &rect in &self.room_rects {
+        for &rect in map_data.rooms() {
             rld.draw_rectangle_rec(
                 transform.rect_m_to_px(rect),
                 Color {
@@ -73,7 +70,7 @@ impl Tool for RoomTool {
         // Do the same for the unfinished rectangle
         if let Some((pos1, pos2)) = self.unfinished_rect {
             rld.draw_rectangle_rec(
-                transform.rect_m_to_px(math::bounding_rect(pos1, pos2)),
+                transform.rect_m_to_px(Rect::bounding_rect(pos1, pos2)),
                 Color {
                     r: 150,
                     g: 200,
diff --git a/src/tool/wall_tool.rs b/src/tool/wall_tool.rs
index 21eb895..a1d3c15 100644
--- a/src/tool/wall_tool.rs
+++ b/src/tool/wall_tool.rs
@@ -1,30 +1,28 @@
 use super::Tool;
-use crate::math;
+use crate::map_data::MapData;
+use crate::math::{self, Vec2};
 use crate::transform::Transform;
 use raylib::core::drawing::{RaylibDraw, RaylibDrawHandle};
-use raylib::ffi::{Color, MouseButton};
-use raylib::math::Vector2;
+use raylib::ffi::{Color, MouseButton, Vector2};
 use raylib::RaylibHandle;
 
 pub struct WallTool {
-    walls: Vec<(Vector2, Vector2)>,
-    unfinished_wall: Option<(Vector2, Vector2)>,
+    unfinished_wall: Option<(Vec2<f32>, Vec2<f32>)>,
 }
 
 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());
+    fn active_update(&mut self, map_data: &mut MapData, rl: &RaylibHandle, transform: &Transform) {
+        let mouse_pos_m = transform.point_px_to_m(rl.get_mouse_position().into());
         if let Some((_, ref mut pos2)) = &mut self.unfinished_wall {
-            let snapped_mouse_pos = Vector2::new(
+            let snapped_mouse_pos = Vec2::new(
                 math::round(mouse_pos_m.x, 0.5),
                 math::round(mouse_pos_m.y, 0.5),
             );
@@ -33,10 +31,10 @@ impl Tool for WallTool {
 
         if rl.is_mouse_button_pressed(MouseButton::MOUSE_LEFT_BUTTON) {
             if let Some((pos1, pos2)) = self.unfinished_wall {
-                self.walls.push((pos1, pos2));
+                map_data.walls_mut().push((pos1, pos2));
                 self.unfinished_wall = None;
             } else {
-                let snapped_mouse_pos = Vector2::new(
+                let snapped_mouse_pos = Vec2::new(
                     math::round(mouse_pos_m.x, 0.5),
                     math::round(mouse_pos_m.y, 0.5),
                 );
@@ -49,11 +47,13 @@ impl Tool for WallTool {
         }
     }
 
-    fn draw(&self, rld: &mut RaylibDrawHandle, transform: &Transform) {
-        for &(pos1, pos2) in &self.walls {
+    fn draw(&self, map_data: &MapData, rld: &mut RaylibDrawHandle, transform: &Transform) {
+        for &(pos1, pos2) in map_data.walls() {
+            let pos1: Vector2 = transform.point_m_to_px(pos1).into();
+            let pos2: Vector2 = transform.point_m_to_px(pos2).into();
             rld.draw_line_ex(
-                transform.point_m_to_px(pos1),
-                transform.point_m_to_px(pos2),
+                pos1,
+                pos2,
                 5.,
                 Color {
                     r: 200,
@@ -65,9 +65,11 @@ impl Tool for WallTool {
         }
 
         if let Some((pos1, pos2)) = self.unfinished_wall {
+            let pos1: Vector2 = transform.point_m_to_px(pos1).into();
+            let pos2: Vector2 = transform.point_m_to_px(pos2).into();
             rld.draw_line_ex(
-                transform.point_m_to_px(pos1),
-                transform.point_m_to_px(pos2),
+                pos1,
+                pos2,
                 5.,
                 Color {
                     r: 150,
diff --git a/src/transform.rs b/src/transform.rs
index fa24636..f44888b 100644
--- a/src/transform.rs
+++ b/src/transform.rs
@@ -3,7 +3,7 @@
 //! Useful to turn on-screen coordinates into measurements of the "real" world the map describes
 //! and the other way around.
 
-use raylib::prelude::*;
+use crate::math::{Rect, Vec2};
 
 const STANDARD_PIXELS_PER_M: f32 = 64.;
 const MIN_PIXELS_PER_M: f32 = 0.5;
@@ -13,7 +13,7 @@ pub struct Transform {
     /// The (not necessarily natural) number of pixels per m, i.e. the current scale of the map
     pixels_per_m: f32,
     /// The vector the entire on-screen map is moved by in pixels
-    translation_px: Vector2,
+    translation_px: Vec2<f32>,
 }
 
 impl Transform {
@@ -21,13 +21,13 @@ impl Transform {
     pub fn new() -> Self {
         Self {
             pixels_per_m: STANDARD_PIXELS_PER_M,
-            translation_px: Vector2::new(0., 0.),
+            translation_px: Vec2::new(0., 0.),
         }
     }
 
     /// Convert a point that is given in meters into the corresponding point in pixels.
     #[inline]
-    pub fn point_m_to_px(&self, point: Vector2) -> Vector2 {
+    pub fn point_m_to_px(&self, point: Vec2<f32>) -> Vec2<f32> {
         // Start by converting the absolute position in meters into the absolute position in
         // pixels, then add the translation of the screen.
         (point * self.pixels_per_m) + self.translation_px
@@ -35,7 +35,7 @@ impl Transform {
 
     /// Convert an on-screen point into an absolute point with values in meters.
     #[inline]
-    pub fn point_px_to_m(&self, point: Vector2) -> Vector2 {
+    pub fn point_px_to_m(&self, point: Vec2<f32>) -> Vec2<f32> {
         // Start by subtracting the pixel translation and afterwards convert these absolute pixel
         // measurements into meters.
         (point - self.translation_px) / self.pixels_per_m
@@ -55,25 +55,25 @@ impl Transform {
 
     /// Convert a rectangle which has measurements in meters into one of pixels
     #[inline]
-    pub fn rect_m_to_px(&self, rect: Rectangle) -> Rectangle {
-        let left_upper = self.point_m_to_px(Vector2::new(rect.x, rect.y));
-        Rectangle::new(
+    pub fn rect_m_to_px(&self, rect: Rect<f32>) -> Rect<f32> {
+        let left_upper = self.point_m_to_px(Vec2::new(rect.x, rect.y));
+        Rect::new(
             left_upper.x,
             left_upper.y,
-            self.length_m_to_px(rect.width),
-            self.length_m_to_px(rect.height),
+            self.length_m_to_px(rect.w),
+            self.length_m_to_px(rect.h),
         )
     }
 
     /// Convert a rectangle which has measurements in pixels into one of meters
     #[inline]
-    pub fn rect_px_to_m(&self, rect: Rectangle) -> Rectangle {
-        let left_upper = self.point_px_to_m(Vector2::new(rect.x, rect.y));
-        Rectangle::new(
+    pub fn rect_px_to_m(&self, rect: Rect<f32>) -> Rect<f32> {
+        let left_upper = self.point_px_to_m(Vec2::new(rect.x, rect.y));
+        Rect::new(
             left_upper.x,
             left_upper.y,
-            self.length_px_to_m(rect.width),
-            self.length_px_to_m(rect.height),
+            self.length_px_to_m(rect.w),
+            self.length_px_to_m(rect.h),
         )
     }
 
@@ -116,14 +116,14 @@ impl Transform {
     }
 
     /// Move the canvas by the vector in pixels.
-    pub fn move_by_px(&mut self, by: Vector2) {
+    pub fn move_by_px(&mut self, by: Vec2<f32>) {
         self.translation_px += by;
     }
 
     pub fn pixels_per_m(&self) -> f32 {
         self.pixels_per_m
     }
-    pub fn translation_px(&self) -> Vector2 {
+    pub fn translation_px(&self) -> Vec2<f32> {
         self.translation_px
     }
 }