Fixed collision directionality bug

src/bin/tetris/main.rs

@@ -10,7 +10,7 @@ use games::*;
 fn main() {
     App::new()
         .add_plugins(BaseGamePlugin {
-            name: "falling-block-rpg".into(),
+            name: "falling-block-adventure".into(),
             target_resolution: (640.0, 480.0).into(),
             game_type: GameType::Two,
             ..default()
@@ -24,16 +24,11 @@ fn main() {
                 falling
                     .run_if(in_state(Falling::On))
                     .run_if(clock_cycle(1.0)),
-                set_shape.run_if(
+                update_shape_blocks
-                    any_component_added::<Shape>
+                    .run_if(any_component_added::<Shape>.or(any_component_changed::<Shape>)),
-                        .or(any_component_changed::<Shape>)
-                        .or(any_component_added::<Orientation>)
-                        .or(any_component_changed::<Orientation>),
-                ),
-                update_relative_position,
-                update_position.after(update_relative_position),
                 sync_singleton_to_ui::<Shape>.run_if(any_component_changed::<Shape>),
                 sync_singleton_to_ui::<Orientation>.run_if(any_component_changed::<Orientation>),
+                update_position,
                 add_piece.run_if(not(any_with_component::<Shape>)),
                 clear_line.run_if(any_component_changed::<LineBlocks>),
             ),
@@ -84,37 +79,6 @@ struct Line(u8);
 #[derive(Component, Debug)]
 struct Block;
 
-#[derive(Component, Event, Debug, Clone, Copy, PartialEq)]
-#[require(GridPosition)]
-struct RelativePosition {
-    x: i8,
-    y: i8,
-}
-
-impl RelativePosition {
-    fn up() -> Self {
-        RelativePosition { x: 0, y: 1 }
-    }
-
-    fn down() -> Self {
-        RelativePosition { x: 0, y: -1 }
-    }
-
-    fn left() -> Self {
-        RelativePosition { x: -1, y: 0 }
-    }
-
-    fn right() -> Self {
-        RelativePosition { x: 1, y: 0 }
-    }
-}
-
-impl From<(i8, i8)> for RelativePosition {
-    fn from((x, y): (i8, i8)) -> RelativePosition {
-        RelativePosition { x, y }
-    }
-}
-
 #[derive(Component, Debug, Clone, Copy, PartialEq)]
 #[require(Transform, Visibility)]
 struct GridPosition {
@@ -123,68 +87,31 @@ struct GridPosition {
 }
 
 impl GridPosition {
-    fn move_up(&self) -> Self {
+    fn with_offset(self, other_x: isize, other_y: isize) -> Result<GridPosition, GameError> {
-        Self {
+        let x = self.x as isize + other_x;
-            y: if self.y + 1 < Y_MAX {
+        let y = self.y as isize + other_y;
-                self.y.saturating_add(1)
-            } else {
-                self.y
-            },
-            x: self.x,
-        }
-    }
-
-    fn move_down(&mut self) -> Self {
-        Self {
-            y: self.y.saturating_sub(1),
-            x: self.x,
-        }
-    }
-
-    fn move_left(&mut self) -> Self {
-        Self {
-            x: self.x.saturating_sub(1),
-            y: self.y,
-        }
-    }
 
-    fn move_right(&mut self) -> Self {
+        if x > X_MAX as isize {
-        Self {
+            Err(GameError::OutOfBoundsLeft)
-            x: if self.x + 1 < X_MAX {
+        } else if x < 0 {
-                self.x.saturating_add(1)
-            } else {
-                self.x
-            },
-            y: self.y,
-        }
-    }
-
-    fn is_colliding_with(&self, other: &Self) -> bool {
-        self.x == other.x && self.y.saturating_sub(1) == other.y
-    }
-
-    fn add_relative(
-        &self,
-        RelativePosition { x: x1, y: y1 }: &RelativePosition,
-    ) -> Result<Self, GameError> {
-        let x = self
-            .x
-            .checked_add_signed(*x1 as i32)
-            .ok_or(GameError::OutOfBoundsLeft)?;
-        let y = self
-            .y
-            .checked_add_signed(*y1 as i32)
-            .ok_or(GameError::OutOfBoundsDown)?;
-        if x >= X_MAX {
-            // TODO: y > Y_MAX?
             Err(GameError::OutOfBoundsRight)
+        } else if y < 0 {
+            Err(GameError::OutOfBoundsDown)
         } else {
-            debug!("Moving to {x},{y}");
+            Ok(GridPosition {
-            Ok(GridPosition { x, y })
+                x: x as u32,
+                y: y as u32,
+            })
         }
     }
 }
 
+impl Display for GridPosition {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({},{})", self.x, self.y)
+    }
+}
+
 #[derive(Error, Debug, PartialEq)]
 enum GameError {
     #[error("Coordinates are out of bounds: Left")]
@@ -208,7 +135,6 @@ impl From<&GridPosition> for Vec3 {
         // Grid Positions start in the bottom left of the area
         // So (0, 0) is the bottom left, (0, 9) is the bottom right, etc
 
-        // TODO: Custom offset allowing pieces like O and I to have correct center
         let x_0 = -SCALE * 5.0 + (0.5 * SCALE);
         let x = x_0 + ((*x as f32) * SCALE);
 
@@ -336,7 +262,7 @@ fn init_debug_ui(mut commands: Commands) {
         });
 }
 
-#[derive(Component, Debug)]
+#[derive(Component, Debug, Clone, Copy)]
 enum Shape {
     M4(Mat4),
     M3(Mat3),
@@ -365,63 +291,63 @@ impl Shape {
 
     fn new_o() -> Self {
         Self::from_mat4(Mat4::from_cols_array_2d(&[
-            [0.,0.,0.,0.],
+            [0., 0., 0., 0.],
-            [0.,1.,1.,0.],
+            [0., 1., 1., 0.],
-            [0.,1.,1.,0.],
+            [0., 1., 1., 0.],
-            [0.,0.,0.,0.],
+            [0., 0., 0., 0.],
         ]))
     }
 
     fn new_t() -> Self {
         Self::from_mat3(Mat3::from_cols_array_2d(&[
-            [0.,1.,0.],
+            [0., 1., 0.],
-            [1.,1.,1.],
+            [1., 1., 1.],
-            [0.,0.,0.],
+            [0., 0., 0.],
         ]))
     }
 
     fn new_l() -> Self {
         Self::from_mat4(Mat4::from_cols_array_2d(&[
-            [0.,0.,0.,0.],
+            [0., 0., 0., 0.],
-            [0.,1.,0.,0.],
+            [0., 1., 0., 0.],
-            [0.,1.,0.,0.],
+            [0., 1., 0., 0.],
-            [0.,1.,1.,0.],
+            [0., 1., 1., 0.],
         ]))
     }
 
     fn new_j() -> Self {
         Self::from_mat4(Mat4::from_cols_array_2d(&[
-            [0.,0.,0.,0.],
+            [0., 0., 0., 0.],
-            [0.,0.,1.,0.],
+            [0., 0., 1., 0.],
-            [0.,0.,1.,0.],
+            [0., 0., 1., 0.],
-            [0.,1.,1.,0.],
+            [0., 1., 1., 0.],
         ]))
     }
 
     fn new_s() -> Self {
         Self::from_mat4(Mat4::from_cols_array_2d(&[
-            [0.,0.,0.,0.],
+            [0., 0., 0., 0.],
-            [0.,1.,1.,0.],
+            [0., 1., 1., 0.],
-            [1.,1.,0.,0.],
+            [1., 1., 0., 0.],
-            [0.,0.,0.,0.],
+            [0., 0., 0., 0.],
         ]))
     }
 
     fn new_z() -> Self {
         Self::from_mat4(Mat4::from_cols_array_2d(&[
-            [0.,0.,0.,0.],
+            [0., 0., 0., 0.],
-            [1.,1.,0.,0.],
+            [1., 1., 0., 0.],
-            [0.,1.,1.,0.],
+            [0., 1., 1., 0.],
-            [0.,0.,0.,0.],
+            [0., 0., 0., 0.],
         ]))
     }
 
     fn new_i() -> Self {
         Self::from_mat4(Mat4::from_cols_array_2d(&[
-            [0.,0.,1.,0.],
+            [0., 0., 1., 0.],
-            [0.,0.,1.,0.],
+            [0., 0., 1., 0.],
-            [0.,0.,1.,0.],
+            [0., 0., 1., 0.],
-            [0.,0.,1.,0.],
+            [0., 0., 1., 0.],
         ]))
     }
 
@@ -452,16 +378,18 @@ impl Shape {
         *self = self.rotated();
     }
 
-    // TODO: return impl Iterator<Item = &RelativePosition>
+    fn coordinates(
-    fn relative_coordinates(&self) -> impl Iterator<Item = RelativePosition> {
+        &self,
-        let mut v: Vec<RelativePosition> = Vec::new();
+        center: &GridPosition,
+    ) -> impl Iterator<Item = Result<GridPosition, GameError>> {
+        let mut v: Vec<Result<GridPosition, GameError>> = Vec::new();
         match self {
             Self::M4(inner) => {
                 for (i, y) in (-1..3).rev().enumerate() {
                     let c = inner.col(i);
                     for (j, x) in (-1..3).enumerate() {
                         if c[j] == 1.0 {
-                            v.push(RelativePosition { x, y });
+                            v.push(center.with_offset(x, y));
                         }
                     }
                 }
@@ -471,7 +399,7 @@ impl Shape {
                     let c = inner.col(i);
                     for (j, x) in (-1..2).enumerate() {
                         if c[j] == 1.0 {
-                            v.push(RelativePosition { x, y });
+                            v.push(center.with_offset(x, y));
                         }
                     }
                 }
@@ -480,10 +408,6 @@ impl Shape {
         v.into_iter()
     }
 
-    fn coordinates(&self, center: &GridPosition) -> impl Iterator<Item = Result<GridPosition, GameError>> {
-        self.relative_coordinates().map(|rp| center.add_relative(&rp))
-    }
-
     fn as_ascii(&self) -> String {
         let mut output = String::default();
 
@@ -493,52 +417,19 @@ impl Shape {
                     let col = this.col(i).to_array();
                     output += format!("{}{}{}{}\n", col[0], col[1], col[2], col[3]).as_str();
                 }
-            },
+            }
             Self::M3(this) => {
                 for i in 0..3 {
                     let col = this.col(i).to_array();
                     output += format!("{}{}{}\n", col[0], col[1], col[2]).as_str();
                 }
-            },
+            }
         };
 
         output
     }
 }
 
-fn set_shape(
-    query: Query<
-        (Entity, &Shape, &Orientation),
-        Or<(Added<Shape>, Changed<Shape>)>,
-    >,
-    mut blocks: Query<&mut RelativePosition, With<ShapeBlock>>,
-    mut commands: Commands,
-    visuals: Res<Visuals>,
-) {
-    query.iter().for_each(|(e, s, o)| {
-        debug!("Setting piece: {e:?} {s:?} {o:?}");
-
-        if blocks.is_empty() {
-            let mesh = Mesh2d(visuals.mesh.clone());
-            let mat = MeshMaterial2d(visuals.material.clone());
-            commands
-                .entity(e)
-                .with_related_entities::<ShapeBlock>(|parent| {
-                    s.relative_coordinates().for_each(|rp| {
-                        parent
-                            .spawn((mesh.clone(), mat.clone(), rp, Block))
-                            .observe(movement);
-                    });
-                });
-        } else {
-            let mut p = s.relative_coordinates();
-            blocks.iter_mut().for_each(|mut rp| {
-                *rp = p.next().unwrap();
-            });
-        }
-    });
-}
-
 fn update_position(
     mut changed: Query<
         (Entity, &GridPosition, &mut Transform),
@@ -552,29 +443,38 @@ fn update_position(
             gp, v3
         );
 
-        debug_assert!(gp.x < X_MAX, "block x > x_max");
         t.translation = gp.into();
     });
 }
 
-fn update_relative_position(
+// TODO: Inline this to when movement occurs
-    shape: Single<&GridPosition, With<ShapeBlocks>>,
+fn update_shape_blocks(
-    mut query: Query<
+    query: Query<(Entity, &Shape, &Orientation, &GridPosition), Or<(Added<Shape>, Changed<Shape>)>>,
-        (Entity, &mut GridPosition, &RelativePosition),
+    mut blocks: Query<&mut GridPosition, (With<ShapeBlock>, Without<Shape>)>,
-        (
+    mut commands: Commands,
-            Without<ShapeBlocks>,
+    visuals: Res<Visuals>,
-            Or<(Added<RelativePosition>, Changed<RelativePosition>)>,
-        ),
-    >,
 ) {
-    query.iter_mut().for_each(|(e, mut gp, rp)| {
+    query.iter().for_each(|(e, s, o, center)| {
-        debug!(
+        info!("Setting piece: {e:?} {o:?} {center:?}\n{}", s.as_ascii());
-            "Updating {e} grid position to {:?} + {:?} = {:?}",
+
-            gp,
+        if blocks.is_empty() {
-            rp,
+            let mesh = Mesh2d(visuals.mesh.clone());
-            gp.add_relative(rp).unwrap()
+            let mat = MeshMaterial2d(visuals.material.clone());
-        );
+            commands
-        *gp = (*shape).add_relative(rp).unwrap();
+                .entity(e)
+                .with_related_entities::<ShapeBlock>(|parent| {
+                    s.coordinates(center).for_each(|gp| {
+                        parent
+                            .spawn((mesh.clone(), mat.clone(), gp.unwrap(), Block))
+                            .observe(movement);
+                    });
+                });
+        } else {
+            let mut p = s.coordinates(center);
+            blocks.iter_mut().for_each(|mut gp| {
+                *gp = p.next().unwrap().unwrap();
+            });
+        }
     });
 }
 
@@ -590,23 +490,21 @@ fn kb_input(
              key_code, state, ..
          }| {
             if let ButtonState::Pressed = state {
-                // TODO: Restict movement based on size/orientation of piece
-                // Check if children would be outside play area...
                 query.iter_mut().for_each(|(e, o, mut s)| {
                     match key_code {
                         // Up arrow should rotate if in falling mode
                         // Only move up if in falling::off mode
                         KeyCode::ArrowUp => {
-                            commands.entity(e).trigger(o.prev());
+                            commands.entity(e).trigger(Movement::Rotate);
                         }
                         KeyCode::ArrowDown => {
-                            commands.entity(e).trigger(RelativePosition::down());
+                            commands.entity(e).trigger(Movement::Down);
                         }
                         KeyCode::ArrowLeft => {
-                            commands.entity(e).trigger(RelativePosition::left());
+                            commands.entity(e).trigger(Movement::Left);
                         }
                         KeyCode::ArrowRight => {
-                            commands.entity(e).trigger(RelativePosition::right());
+                            commands.entity(e).trigger(Movement::Right);
                         }
                         KeyCode::Space => next.set(match curr.get() {
                             Falling::On => Falling::Off,
@@ -641,7 +539,7 @@ fn draw_grid(mut gizmos: Gizmos) {
 fn falling(mut shape: Query<Entity, With<Shape>>, mut commands: Commands) {
     shape.iter_mut().for_each(|e| {
         info!("Making {:?} fall", e);
-        commands.entity(e).trigger(RelativePosition::down());
+        commands.entity(e).trigger(Movement::Down);
     });
 }
 
@@ -662,9 +560,12 @@ fn clock_cycle(n: f32) -> impl FnMut(Res<Time>, Local<f32>) -> bool {
 fn add_piece(mut commands: Commands) {
     // TODO: Choose a different piece
     commands
-        .spawn((Orientation::default(), GridPosition::default(), Shape::default()))
+        .spawn((
-        .observe(movement)
+            Orientation::default(),
-        .observe(rotation);
+            GridPosition::default(),
+            Shape::default(),
+        ))
+        .observe(movement);
 }
 
 /// When a line reaches 10 blocks, clear it
@@ -681,87 +582,100 @@ fn clear_line(
     });
 }
 
+#[derive(Event, Copy, Clone, PartialEq)]
+enum Movement {
+    Down,
+    Left,
+    Right,
+    Rotate,
+}
+
+// TODO: When out of bounds left/right, try to move piece away from wall
 fn movement(
-    trigger: Trigger<RelativePosition>,
+    trigger: Trigger<Movement>,
-    mut grid_positions: Query<&mut GridPosition, Or<(With<RelativePosition>, With<Shape>)>>,
+    mut grid_positions: Query<&mut GridPosition, Or<(With<ShapeBlock>, With<ShapeBlocks>)>>,
-    parent: Query<&ShapeBlocks>,
+    mut shape: Query<&mut Shape>,
-    inactive: Query<
+    inactive: Query<&GridPosition, (Without<ShapeBlock>, Without<ShapeBlocks>)>,
-        &GridPosition,
-        (
-            Without<RelativePosition>,
-            Without<Shape>,
-        ),
-    >,
     mut commands: Commands,
 ) {
-    // Do a bunch of checks if this move is valid
+    if let (Ok(this_shape), Ok(center)) = (
-    for block in parent.iter_descendants(trigger.target()) {
+        shape.get_mut(trigger.target()),
-        let block_gp = grid_positions.get(block).unwrap();
+        grid_positions.get(trigger.target()),
-
+    ) {
-        match block_gp.add_relative(trigger.event()) {
+        let (new_center, new_shape) = match trigger.event() {
-            Err(GameError::OutOfBoundsLeft) | Err(GameError::OutOfBoundsRight) => {
+            Movement::Down => (center.with_offset(0, -1), *this_shape),
-                // Hit the left/right wall, just ignore this move
+            Movement::Left => (center.with_offset(-1, 0), *this_shape),
-                return;
+            Movement::Right => (center.with_offset(1, 0), *this_shape),
-            }
+            Movement::Rotate => (Ok(*center), this_shape.rotated()),
+        };
+        info!(
+            "Proposed change: {:?}\n{}",
+            new_center,
+            new_shape.as_ascii()
+        );
+        match new_center {
+            Err(GameError::OutOfBoundsLeft) | Err(GameError::OutOfBoundsRight) => (), // Do nothing
             Err(GameError::OutOfBoundsDown) => {
                 commands.entity(trigger.target()).remove::<Shape>();
-                return;
             }
-            Err(GameError::Collision) => {
+            Err(GameError::Collision) => panic!("This shouldn't happen!"),
-                // Do nothing. add_relative does not return this variant
+            Ok(new_center) => {
-            }
+                let new_blocks = new_shape.coordinates(&new_center);
-            Ok(new_block_gp) => {
+                for block_gp in new_blocks {
-                let collision = inactive
+                    match block_gp {
-                    .iter()
+                        Err(GameError::OutOfBoundsLeft) | Err(GameError::OutOfBoundsRight) => {
-                    .any(|inactive_block_gp| new_block_gp == *inactive_block_gp);
+                            return;
-
+                        } // Do nothing
-                if collision {
+                        Err(GameError::OutOfBoundsDown) => {
-                    commands.entity(trigger.target()).remove::<Shape>();
+                            commands.entity(trigger.target()).remove::<Shape>();
+                            return;
+                        }
+                        Err(GameError::Collision) => panic!("This shouldn't happen!"),
+                        Ok(gp) => {
+                            for other_gp in inactive.iter() {
+                                // If there would be a collision between blocks
+                                if gp == *other_gp {
+                                    // And we are moving down
+                                    if *trigger.event() == Movement::Down {
+                                        // De-activate this piece
+                                        commands.entity(trigger.target()).remove::<Shape>();
+                                    }
+                                    // Regardless, cancel the move
+                                    return;
+                                }
+                            }
+                        }
+                    }
                 }
+                // Update center
+                let mut gp = grid_positions.get_mut(trigger.target()).unwrap();
+                *gp = new_center;
+                // Update shape/rotation
+                let mut s = shape.get_mut(trigger.target()).unwrap();
+                *s = new_shape;
             }
         }
+    } else {
+        warn!("Triggered movement on non-shape entity");
     }
-
-    // Move shape itself
-    if let Ok(mut shape_gp) = grid_positions.get_mut(trigger.target()) {
-        *shape_gp = shape_gp.add_relative(trigger.event()).unwrap();
-    }
-
-    // Move the blocks of this shape
-    parent.iter_descendants(trigger.target()).for_each(|block| {
-        info!("Propogating movement {:?} to child {:?}", trigger.event(), block);
-        commands.entity(block).trigger(*trigger.event());
-    });
-}
-
-fn rotation(trigger: Trigger<Orientation>, mut q: Query<&mut Orientation>) {
-    let mut o = q.get_mut(trigger.target()).unwrap();
-    // If children would go out of bounds going left, move slightly to the right
-    //    If that would cause collision, deactive piece
-    // If children would go out of bounds going right, move slightly to the left
-    //    If that would cause collision, deactive piece
-    // If children would not go out of bounds going down
-    *o = trigger.event().clone();
 }
 
 // TODO: Just despawn?
 fn deactive_shape(
     trigger: Trigger<OnRemove, Shape>,
+    grid_positions: Query<&GridPosition>,
     parent: Query<&ShapeBlocks>,
+    lines: Query<(Entity, &Line), With<LineBlocks>>,
     mut commands: Commands,
 ) {
-    let v: Vec<Entity> = parent.iter_descendants(trigger.target()).collect();
     parent.iter_descendants(trigger.target()).for_each(|block| {
-        commands.entity(block).remove::<RelativePosition>();
+        let GridPosition { y, .. } = grid_positions.get(block).unwrap();
+        let parent_line = lines.iter().find_map(|(e, Line(i))| (*y == *i as u32).then_some(e)).unwrap();
+        commands.entity(parent_line).add_one_related::<LineBlock>(block);
     });
-    commands
+    commands.entity(trigger.target()).despawn();
-        .entity(trigger.target())
-        .remove_related::<ShapeBlock>(v.as_slice())
-        .despawn();
 }
 
-// TODO: When Orientation changed, perform matrix multiplication or something(?)
-
 #[cfg(test)]
 mod test {
     use super::*;
@@ -832,22 +746,6 @@ mod test {
         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();