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.

1 files changed, 233 insertions, 0 deletions

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()
+}