1 files changed, 25 insertions, 11 deletions
diff --git a/src/map/wall.rs b/src/map/wall.rs
index 22393bb..f1748bb 100644
--- a/src/map/wall.rs
+++ b/src/map/wall.rs
@@ -1,13 +1,23 @@
+//! Walls, solid barriers that are generally unscaleable.
+//!
+//! This interpretation is generally up to the GM to decide, but generally speaking, a wall cannot be
+//! crossed by a player. If special conditions apply (for instance, when the player wants to scale the
+//! wall), a check is necessary. If a check is not necessary, then maybe you were not thinking about
+//! a wall.
+
 use super::Mappable;
 use crate::colours::DEFAULT_COLOURS;
 use crate::math::{LineSegment, Rect, Vec2};
-use crate::scaleable::Scaleable;
 use crate::transform::Transform;
+use crate::transformable::NonRigidTransformable;
+use nalgebra::Matrix3;
 use raylib::drawing::{RaylibDraw, RaylibDrawHandle};
 use std::ops::{Deref, DerefMut};
 
+/// The data which defines a wall segment completely for serialisation.
 pub type WallData = LineSegment<f64>;
 
+/// A solid wall a player cannot go through, except if special conditions apply.
 pub struct Wall {
     data: WallData,
     selected: bool,
@@ -16,6 +26,7 @@ pub struct Wall {
 }
 
 impl Wall {
+    /// Create a new wall from the deserialised data and information known from internal sources.
     pub fn from_data(data: WallData, round_start: bool, round_end: bool) -> Self {
         Self {
             data,
@@ -25,6 +36,7 @@ impl Wall {
         }
     }
 
+    /// Get the internal data for serialisation
     pub fn data(&self) -> &WallData {
         &self.data
     }
@@ -81,18 +93,20 @@ impl Mappable for Wall {
     fn bounding_rect(&self) -> Rect<f64> {
         Rect::bounding_rect(self.data.start, self.data.end)
     }
-}
 
-impl Scaleable for Wall {
-    fn scale(&mut self, by: &Vec2<f64>) {
-        if by.x <= 0. || by.y <= 0. {
-            panic!("Cannot set dimensions with negative size");
-        }
+    fn as_non_rigid(&self) -> Option<&dyn NonRigidTransformable> {
+        Some(self as &dyn NonRigidTransformable)
+    }
+
+    fn as_non_rigid_mut(&mut self) -> Option<&mut dyn NonRigidTransformable> {
+        Some(self as &mut dyn NonRigidTransformable)
+    }
+}
 
-        self.data.start.x *= by.x;
-        self.data.start.y *= by.y;
-        self.data.end.x *= by.x;
-        self.data.end.y *= by.y;
+impl NonRigidTransformable for Wall {
+    fn apply_matrix(&mut self, matrix: &Matrix3<f64>) {
+        self.data.start = matrix.transform_point(&self.data.start.into()).into();
+        self.data.end = matrix.transform_point(&self.data.end.into()).into();
     }
 }