Drawing piece based on shape matrix works!

src/bin/tetris/main.rs

@@ -480,7 +480,7 @@ impl Shape {
         v.into_iter()
     }
 
-    fn computed_coordinates(&self, center: &GridPosition) -> impl Iterator<Item = Result<GridPosition, GameError>> {
+    fn coordinates(&self, center: &GridPosition) -> impl Iterator<Item = Result<GridPosition, GameError>> {
         self.relative_coordinates().map(|rp| center.add_relative(&rp))
     }
 
@@ -506,111 +506,6 @@ impl Shape {
     }
 }
 
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_shape_t() {
-        let mut shape = Shape::new_t();
-
-        let expected_up = "010\n\
-                           111\n\
-                           000\n";
-
-        let expected_right = "010\n\
-                              011\n\
-                              010\n";
-
-        let expected_down = "000\n\
-                             111\n\
-                             010\n";
-
-        let expected_left = "010\n\
-                             110\n\
-                             010\n";
-
-        assert_eq!(shape.as_ascii(), expected_up);
-        shape.rotate();
-        assert_eq!(shape.as_ascii(), expected_right);
-        shape.rotate();
-        assert_eq!(shape.as_ascii(), expected_down);
-        shape.rotate();
-        assert_eq!(shape.as_ascii(), expected_left);
-        shape.rotate();
-        assert_eq!(shape.as_ascii(), expected_up);
-    }
-
-    #[test]
-    fn test_shape_i() {
-        let mut shape = Shape::new_i();
-
-        let expected_up = "0010\n\
-                           0010\n\
-                           0010\n\
-                           0010\n";
-
-        let expected_right = "0000\n\
-                              0000\n\
-                              1111\n\
-                              0000\n";
-
-        let expected_down = "0100\n\
-                             0100\n\
-                             0100\n\
-                             0100\n";
-
-        let expected_left = "0000\n\
-                             1111\n\
-                             0000\n\
-                             0000\n";
-
-        assert_eq!(shape.as_ascii(), expected_up);
-        shape.rotate();
-        assert_eq!(shape.as_ascii(), expected_right);
-        shape.rotate();
-        assert_eq!(shape.as_ascii(), expected_down);
-        shape.rotate();
-        assert_eq!(shape.as_ascii(), expected_left);
-        shape.rotate();
-        assert_eq!(shape.as_ascii(), expected_up);
-    }
-
-    #[test]
-    fn test_relative_coordinates() {
-        let shape = Shape::new_t();
-
-        let expected: Vec<RelativePosition> = vec![
-            (0, 1).into(),
-            (-1, 0).into(),
-            (0, 0).into(),
-            (1, 0).into(),
-        ];
-
-        let actual: Vec<RelativePosition> = shape.relative_coordinates().collect();
-
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn test_computed_coordinates() {
-        let shape = Shape::new_t();
-
-        let center = GridPosition { x: 5, y: 5 };
-
-        let expected: Vec<Result<GridPosition, GameError>> = vec![
-            Ok((5, 6).into()),
-            Ok((4, 5).into()),
-            Ok((5, 5).into()),
-            Ok((6, 5).into()),
-        ];
-
-        let actual: Vec<Result<GridPosition, GameError>> = shape.computed_coordinates(&center).collect();
-
-        assert_eq!(actual, expected);
-    }
-}
-
 fn set_shape(
     query: Query<
         (Entity, &Shape, &Orientation),
@@ -623,24 +518,20 @@ fn set_shape(
     query.iter().for_each(|(e, s, o)| {
         debug!("Setting piece: {e:?} {s:?} {o:?}");
 
-        let mesh = visuals.mesh.clone();
-        let mat = visuals.material.clone();
-        let positions: [RelativePosition;4] = todo!();
-
-        // todo: map positions to coordinates
-
         if blocks.is_empty() {
+            let mesh = Mesh2d(visuals.mesh.clone());
+            let mat = MeshMaterial2d(visuals.material.clone());
             commands
                 .entity(e)
                 .with_related_entities::<ShapeBlock>(|parent| {
-                    positions.into_iter().for_each(|rp| {
+                    s.relative_coordinates().for_each(|rp| {
                         parent
-                            .spawn((Mesh2d(mesh.clone()), MeshMaterial2d(mat.clone()), rp, Block))
+                            .spawn((mesh.clone(), mat.clone(), rp, Block))
                             .observe(movement);
                     });
                 });
         } else {
-            let mut p = positions.into_iter();
+            let mut p = s.relative_coordinates();
             blocks.iter_mut().for_each(|mut rp| {
                 *rp = p.next().unwrap();
             });
@@ -870,3 +761,108 @@ fn deactive_shape(
 }
 
 // TODO: When Orientation changed, perform matrix multiplication or something(?)
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_shape_t() {
+        let mut shape = Shape::new_t();
+
+        let expected_up = "010\n\
+                           111\n\
+                           000\n";
+
+        let expected_right = "010\n\
+                              011\n\
+                              010\n";
+
+        let expected_down = "000\n\
+                             111\n\
+                             010\n";
+
+        let expected_left = "010\n\
+                             110\n\
+                             010\n";
+
+        assert_eq!(shape.as_ascii(), expected_up);
+        shape.rotate();
+        assert_eq!(shape.as_ascii(), expected_right);
+        shape.rotate();
+        assert_eq!(shape.as_ascii(), expected_down);
+        shape.rotate();
+        assert_eq!(shape.as_ascii(), expected_left);
+        shape.rotate();
+        assert_eq!(shape.as_ascii(), expected_up);
+    }
+
+    #[test]
+    fn test_shape_i() {
+        let mut shape = Shape::new_i();
+
+        let expected_up = "0010\n\
+                           0010\n\
+                           0010\n\
+                           0010\n";
+
+        let expected_right = "0000\n\
+                              0000\n\
+                              1111\n\
+                              0000\n";
+
+        let expected_down = "0100\n\
+                             0100\n\
+                             0100\n\
+                             0100\n";
+
+        let expected_left = "0000\n\
+                             1111\n\
+                             0000\n\
+                             0000\n";
+
+        assert_eq!(shape.as_ascii(), expected_up);
+        shape.rotate();
+        assert_eq!(shape.as_ascii(), expected_right);
+        shape.rotate();
+        assert_eq!(shape.as_ascii(), expected_down);
+        shape.rotate();
+        assert_eq!(shape.as_ascii(), expected_left);
+        shape.rotate();
+        assert_eq!(shape.as_ascii(), expected_up);
+    }
+
+    #[test]
+    fn test_relative_coordinates() {
+        let shape = Shape::new_t();
+
+        let expected: Vec<RelativePosition> = vec![
+            (0, 1).into(),
+            (-1, 0).into(),
+            (0, 0).into(),
+            (1, 0).into(),
+        ];
+
+        let actual: Vec<RelativePosition> = shape.relative_coordinates().collect();
+
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_coordinates() {
+        let shape = Shape::new_t();
+
+        let center = GridPosition { x: 5, y: 5 };
+
+        let expected: Vec<Result<GridPosition, GameError>> = vec![
+            Ok((5, 6).into()),
+            Ok((4, 5).into()),
+            Ok((5, 5).into()),
+            Ok((6, 5).into()),
+        ];
+
+        let actual: Vec<Result<GridPosition, GameError>> = shape.coordinates(&center).collect();
+
+        assert_eq!(actual, expected);
+    }
+}