From 6fd9550975e7bb0cca8e846104ebb7d4918eda8e Mon Sep 17 00:00:00 2001
From: Elijah Voigt <pop@elijah.run>
Date: Mon, 17 Nov 2025 21:50:20 -0800
Subject: [PATCH] Shape colors

This breaks shapes out into having separate colors.

This requires breaking shapes out into an enum describing the shape and
the shape layout, then we can add the mesh and material based on the
shape enum variant.
---
 src/bin/tetris/main.rs | 353 ++++++++++++++++++++++-------------------
 src/lib.rs             |  10 +-
 2 files changed, 194 insertions(+), 169 deletions(-)

diff --git a/src/bin/tetris/main.rs b/src/bin/tetris/main.rs
index f4de31c..070ed90 100644
--- a/src/bin/tetris/main.rs
+++ b/src/bin/tetris/main.rs
@@ -35,7 +35,6 @@ fn main() {
                 init_cameras,
                 init_ui.after(init_cameras),
                 init_battler,
-                init_deck,
             ),
         )
         // Input and basic systems
@@ -56,10 +55,10 @@ fn main() {
                     .after(update_next_shapes),
                 falling
                     .run_if(in_state(GameState::Falling))
-                    .run_if(clock_cycle(1.0)),
+                    .run_if(on_timer(Duration::from_secs(1))),
                 update_position.run_if(any_component_changed::<GridPosition>),
                 update_shape_blocks
-                    .run_if(any_component_added::<Shape>.or(any_component_changed::<Shape>))
+                    .run_if(any_component_changed::<ShapeLayout>.or(any_component_changed::<GridPosition>))
                     .after(update_position),
                 deactivate_shape
                     .run_if(any_component_removed::<Shape>)
@@ -74,7 +73,7 @@ fn main() {
                     .run_if(any_component_changed::<Health>.or(any_component_added::<Health>)),
                 damage_on_place_shape.run_if(any_component_removed::<Shape>),
                 damage_on_clear_line.run_if(any_component_removed::<LineBlock>),
-                damage_over_time.run_if(clock_cycle(5.0)),
+                damage_over_time.run_if(on_timer(Duration::from_secs(5))),
             ),
         )
         // UI systems
@@ -88,6 +87,8 @@ fn main() {
             ),
         )
         .add_observer(deal_damage)
+        .add_observer(on_add_shape_layout)
+        .add_observer(on_add_health)
         .run();
 }
 
@@ -227,8 +228,14 @@ enum GameState {
 
 #[derive(Resource, Debug)]
 struct Visuals {
-    material: Handle<ColorMaterial>,
     mesh: Handle<Mesh>,
+    material_o: Handle<ColorMaterial>,
+    material_t: Handle<ColorMaterial>,
+    material_l: Handle<ColorMaterial>,
+    material_j: Handle<ColorMaterial>,
+    material_s: Handle<ColorMaterial>,
+    material_z: Handle<ColorMaterial>,
+    material_i: Handle<ColorMaterial>,
 }
 
 #[derive(Resource, Debug, Default)]
@@ -266,7 +273,7 @@ struct ShapeStore(Option<Shape>);
 impl Display for ShapeStore {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self.0 {
-            Some(inner) => write!(f, "{}", inner.as_ascii()),
+            Some(s) => write!(f, "{}", ShapeLayout::from_shape(s).as_ascii()),
             None => write!(f, "---"),
         }
     }
@@ -281,17 +288,36 @@ fn init_tetris(
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
     let mesh = meshes.add(Rectangle::new(SCALE, SCALE));
-    let block_material = materials.add(ColorMaterial {
-        color: WHITE.into(),
-        ..default()
-    });
-    let grid_material = materials.add(ColorMaterial {
-        color: BLACK.into(),
-        ..default()
-    });
     commands.insert_resource(Visuals {
-        material: block_material.clone(),
         mesh: mesh.clone(),
+        material_o: materials.add(ColorMaterial {
+            color: YELLOW.into(),
+            ..default()
+        }),
+        material_t: materials.add(ColorMaterial {
+            color: PURPLE.into(),
+            ..default()
+        }),
+        material_l: materials.add(ColorMaterial {
+            color: ORANGE.into(),
+            ..default()
+        }),
+        material_j: materials.add(ColorMaterial {
+            color: BLUE.into(),
+            ..default()
+        }),
+        material_s: materials.add(ColorMaterial {
+            color: LIME.into(),
+            ..default()
+        }),
+        material_z: materials.add(ColorMaterial {
+            color: RED.into(),
+            ..default()
+        }),
+        material_i: materials.add(ColorMaterial {
+            color: AQUA.into(),
+            ..default()
+        }),
     });
 
     (0..Y_MAX).for_each(|y| {
@@ -299,7 +325,10 @@ fn init_tetris(
         (0..X_MAX).for_each(|x| {
             commands.spawn((
                 Mesh2d(mesh.clone()),
-                MeshMaterial2d(grid_material.clone()),
+                MeshMaterial2d(materials.add(ColorMaterial {
+                    color: BLACK.into(),
+                    ..default()
+                })),
                 GridPosition { x, y },
                 Transform::from_xyz(0.0, 0.0, -1.0),
                 GridBackground,
@@ -312,12 +341,6 @@ fn init_tetris(
     });
 }
 
-fn init_deck(
-    mut commands: Commands,
-) {
-    todo!()
-}
-
 #[derive(Component, Debug)]
 struct Protagonist;
 
@@ -579,32 +602,63 @@ fn init_debug_ui(mut commands: Commands) {
         });
 }
 
+/// Enum describing a shape option
 #[derive(Component, Debug, Clone)]
-struct Shape {
-    layout: ShapeBlockLayout,
+enum Shape {
+    O,
+    T,
+    L,
+    J,
+    S,
+    Z,
+    I,
 }
 
 impl Default for Shape {
     fn default() -> Self {
-        Self::new_t()
+        Self::T
     }
 }
 
 impl Display for Shape {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.layout.as_ascii())
+        write!(f, "{self:?}")
     }
 }
 
-impl From<Vec<Vec<u8>>> for Shape {
-    fn from(inner: Vec<Vec<u8>>) -> Shape {
-        Shape {
-            layout: ShapeBlockLayout { inner },
-        }
+impl Shape {
+    fn reposition(
+        (x_offset, y_offset): (isize, isize),
+        center: &GridPosition,
+    ) -> Result<GridPosition, OutOfBoundsError> {
+        center.with_offset(x_offset, y_offset)
     }
 }
 
-impl Shape {
+#[derive(Component, Debug, Clone, PartialEq, Eq)]
+struct ShapeLayout {
+    inner: Vec<Vec<u8>>,
+}
+
+impl From<Vec<Vec<u8>>> for ShapeLayout {
+    fn from(inner: Vec<Vec<u8>>) -> Self {
+        Self { inner }
+    }
+}
+
+impl ShapeLayout {
+    fn from_shape(s: &Shape) -> Self {
+        match s {
+            Shape::O => Self::new_o(),
+            Shape::T => Self::new_t(),
+            Shape::L => Self::new_l(),
+            Shape::J => Self::new_j(),
+            Shape::S => Self::new_s(),
+            Shape::Z => Self::new_z(),
+            Shape::I => Self::new_i(),
+        }
+    }
+
     fn new_o() -> Self {
         vec![vec![1, 1], vec![1, 1]].into()
     }
@@ -637,45 +691,6 @@ impl Shape {
         vec![vec![1], vec![1], vec![1], vec![1]].into()
     }
 
-    // Rotates 90 degrees to the right
-    // https://stackoverflow.com/a/8664879
-    fn rotated(&self) -> Self {
-        Self {
-            layout: self.layout.rotated(),
-        }
-    }
-
-    fn reposition(
-        (x_offset, y_offset): (isize, isize),
-        center: &GridPosition,
-    ) -> Result<GridPosition, OutOfBoundsError> {
-        center.with_offset(x_offset, y_offset)
-    }
-
-    fn coordinates(
-        &self,
-        center: &GridPosition,
-    ) -> impl Iterator<Item = Result<GridPosition, OutOfBoundsError>> {
-        self.layout
-            .coordinates()
-            .map(|(x, y)| Shape::reposition((x, y), center))
-    }
-
-    fn as_ascii(&self) -> String {
-        self.layout.as_ascii()
-    }
-
-    fn height(&self) -> usize {
-        self.layout.height()
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-struct ShapeBlockLayout {
-    inner: Vec<Vec<u8>>,
-}
-
-impl ShapeBlockLayout {
     fn rotated(&self) -> Self {
         let mut inner = vec![];
         for _ in 0..self.inner[0].len() {
@@ -686,7 +701,7 @@ impl ShapeBlockLayout {
                 inner[j].insert(0, *x);
             }
         }
-        ShapeBlockLayout { inner }
+        ShapeLayout { inner }
     }
 
     fn center(&self) -> (usize, usize) {
@@ -709,6 +724,14 @@ impl ShapeBlockLayout {
         (mid_x, mid_y)
     }
 
+    fn coordinates_at(
+        &self,
+        center: &GridPosition,
+    ) -> impl Iterator<Item = Result<GridPosition, OutOfBoundsError>> {
+        self.coordinates()
+            .map(|(x, y)| Shape::reposition((x, y), center))
+    }
+
     fn coordinates(&self) -> impl Iterator<Item = (isize, isize)> {
         let (mid_x, mid_y) = self.center();
         // Loop over outer vec (i)
@@ -771,45 +794,57 @@ fn update_position(
 // TODO: Move to event
 fn update_shape_blocks(
     query: Query<
-        (Entity, &Shape, &GridPosition),
+        (Entity, &ShapeLayout, &GridPosition),
         Or<(
-            Added<Shape>,
-            Changed<Shape>,
-            Added<GridPosition>,
+            Changed<ShapeLayout>,
             Changed<GridPosition>,
         )>,
     >,
-    mut blocks: Query<&mut GridPosition, (With<ShapeBlock>, Without<Shape>)>,
-    mut commands: Commands,
-    visuals: Res<Visuals>,
+    mut blocks: Query<&mut GridPosition, (With<ShapeBlock>, Without<ShapeLayout>)>,
 ) {
-    query.iter().for_each(|(e, s, center)| {
-        debug!("Setting piece: {e:?} {center:?}\n{}", s.as_ascii());
+    query.iter().for_each(|(e, sl, center)| {
+        debug!("Setting piece: {e:?} {center:?}\n{}", sl.as_ascii());
 
-        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.coordinates(center).for_each(|gp| {
-                        parent
-                            .spawn((mesh.clone(), mat.clone(), gp.unwrap(), Block, TETRIS))
-                            .observe(movement);
-                    });
-                });
-        } else {
-            let mut p = s.coordinates(center);
-            blocks.iter_mut().for_each(|mut gp| {
-                *gp = p.next().unwrap().unwrap();
-            });
-        }
+        debug_assert!(!blocks.is_empty());
+
+        let mut p = sl.coordinates_at(center);
+        blocks.iter_mut().for_each(|mut gp| {
+            *gp = p.next().unwrap().unwrap();
+        });
     });
 }
 
+fn on_add_shape_layout(
+    trigger: On<Add, ShapeLayout>,
+    visuals: Res<Visuals>,
+    query: Query<(Entity, &Shape, &ShapeLayout, &GridPosition)>,
+    mut commands: Commands,
+) {
+    let (e, s, sl, center) = query.get(trigger.entity).unwrap();
+    let mesh = Mesh2d(visuals.mesh.clone());
+    let mat = match s {
+        Shape::O => &visuals.material_o,
+        Shape::T => &visuals.material_t,
+        Shape::L => &visuals.material_l,
+        Shape::J => &visuals.material_j,
+        Shape::S => &visuals.material_s,
+        Shape::Z => &visuals.material_z,
+        Shape::I => &visuals.material_i,
+    };
+    commands
+        .entity(e)
+        .with_related_entities::<ShapeBlock>(|parent| {
+            sl.coordinates_at(center).for_each(|gp| {
+                parent
+                    .spawn((mesh.clone(), MeshMaterial2d(mat.clone()), gp.unwrap(), Block, TETRIS))
+                    .observe(movement);
+            });
+        });
+}
+
 fn kb_input(
     mut events: MessageReader<KeyboardInput>,
-    mut query: Query<(Entity, &mut Shape)>,
+    mut query: Query<Entity, With<Shape>>,
     curr: Res<State<GameState>>,
     mut next: ResMut<NextState<GameState>>,
     mut commands: Commands,
@@ -819,7 +854,7 @@ fn kb_input(
              key_code, state, ..
          }| {
             if let ButtonState::Pressed = state {
-                query.iter_mut().for_each(|(e, mut s)| {
+                query.iter_mut().for_each(|e| {
                     match key_code {
                         // Up arrow should rotate if in falling mode
                         // Only move up if in falling::off mode
@@ -860,13 +895,6 @@ fn kb_input(
                             GameState::Falling => GameState::Pause,
                             GameState::Pause => GameState::Falling,
                         }),
-                        KeyCode::Digit1 => *s = Shape::new_t(),
-                        KeyCode::Digit2 => *s = Shape::new_o(),
-                        KeyCode::Digit3 => *s = Shape::new_l(),
-                        KeyCode::Digit4 => *s = Shape::new_j(),
-                        KeyCode::Digit5 => *s = Shape::new_s(),
-                        KeyCode::Digit6 => *s = Shape::new_z(),
-                        KeyCode::Digit7 => *s = Shape::new_i(),
                         _ => (),
                     }
                 });
@@ -885,29 +913,17 @@ fn falling(mut shape: Query<Entity, With<Shape>>, mut commands: Commands) {
     });
 }
 
-// Run condition that returns `true` every `n` seconds
-// TODO: Update a resource with the current tick
-fn clock_cycle(n: f32) -> impl FnMut(Res<Time>, Local<f32>) -> bool {
-    move |t: Res<Time>, mut buf: Local<f32>| -> bool {
-        *buf += t.delta_secs();
-        if *buf > n {
-            *buf = 0.0;
-            true
-        } else {
-            false
-        }
-    }
-}
-
 fn add_piece(mut commands: Commands, mut shapes: ResMut<ShapesBuffer>) {
-    let this_shape = shapes.next.pop_front().unwrap();
+    let shape = shapes.next.pop_front().unwrap();
+    let shape_layout = ShapeLayout::from_shape(&shape);
     commands
         .spawn((
             GridPosition {
-                y: Y_MAX - this_shape.height(),
+                y: Y_MAX - shape_layout.height(),
                 ..default()
             },
-            this_shape,
+            shape_layout,
+            shape,
             TETRIS,
         ))
         .observe(movement)
@@ -1025,12 +1041,12 @@ fn movement(
         &mut GridPosition,
         Or<(With<ShapeBlock>, With<ShapeBlocks>, Without<LineBlock>)>,
     >,
-    mut shape: Query<&mut Shape>,
+    mut shape_layouts: Query<&mut ShapeLayout>,
     inactive: Query<&GridPosition, (Without<ShapeBlock>, Without<ShapeBlocks>, With<LineBlock>)>,
     mut commands: Commands,
 ) {
-    if let (Ok(this_shape), Ok(center)) = (
-        shape.get_mut(event.entity),
+    if let (Ok(this_shape_layout), Ok(center)) = (
+        shape_layouts.get_mut(event.entity),
         grid_positions.get(event.entity),
     ) {
         let new_positions = match event.event().direction {
@@ -1042,17 +1058,17 @@ fn movement(
                 .map(|i| center.with_offset(0, -(i as isize)))
                 .collect(),
         };
-        let new_shape = match event.event().direction {
+        let new_shape_layout = match event.event().direction {
             MovementDirection::Down
             | MovementDirection::Left
             | MovementDirection::Right
-            | MovementDirection::Skip => this_shape.clone(),
-            MovementDirection::Rotate => this_shape.rotated(),
+            | MovementDirection::Skip => this_shape_layout.clone(),
+            MovementDirection::Rotate => this_shape_layout.rotated(),
         };
         debug!(
             "Proposed change: {:?}\n{}",
             new_positions,
-            new_shape.as_ascii()
+            new_shape_layout.as_ascii()
         );
         for position in new_positions {
             match position {
@@ -1061,7 +1077,7 @@ fn movement(
                     commands.entity(event.entity).remove::<Shape>();
                 }
                 Ok(new_center) => {
-                    let new_blocks = new_shape.coordinates(&new_center);
+                    let new_blocks = new_shape_layout.coordinates_at(&new_center);
                     for block_gp in new_blocks {
                         match block_gp {
                             Err(OutOfBoundsError::Left) | Err(OutOfBoundsError::Right) => {
@@ -1094,8 +1110,8 @@ fn movement(
                     *gp = new_center;
 
                     // Update shape/rotation
-                    let mut s = shape.get_mut(event.entity).unwrap();
-                    *s = new_shape.clone();
+                    let mut sl = shape_layouts.get_mut(event.entity).unwrap();
+                    *sl = new_shape_layout.clone();
                 }
             }
         }
@@ -1161,13 +1177,13 @@ fn update_next_shapes(mut buffer: ResMut<ShapesBuffer>) {
     while buffer.next.len() < 8 {
         // TODO: Shuffle these!
         buffer.next.extend([
-            Shape::new_o(),
-            Shape::new_t(),
-            Shape::new_l(),
-            Shape::new_j(),
-            Shape::new_s(),
-            Shape::new_z(),
-            Shape::new_i(),
+            Shape::O,
+            Shape::T,
+            Shape::L,
+            Shape::J,
+            Shape::S,
+            Shape::Z,
+            Shape::I,
         ]);
     }
 }
@@ -1181,35 +1197,40 @@ fn assert_grid_position_uniqueness(
 }
 
 fn sync_health(
-    query: Query<(Entity, &Health, &Mesh2d), Or<(Changed<Health>, Added<Health>)>>,
+    query: Query<(Entity, &Health), Changed<Health>>,
     parent: Query<&Children>,
-    meshes: Res<Assets<Mesh>>,
     mut texts: Query<&mut Text2d>,
-    mut commands: Commands,
 ) {
-    query.iter().for_each(|(e, h, m)| {
-        if let Some(child) = parent
+    query.iter().for_each(|(e, h)| {
+        let child = parent
             .iter_descendants(e)
             .find(|child| texts.contains(*child))
-        {
-            info!("Updating health");
-            let mut t = texts.get_mut(child).unwrap();
-            t.0 = format!("{}", h.0);
-        } else {
-            info!("Creating health display");
-            commands.entity(e).with_children(|parent| {
-                let mesh = meshes.get(&m.0).unwrap();
-                let aabb = mesh.compute_aabb().unwrap();
-                let offset = Vec3::new(0.0, aabb.half_extents.y + 10.0, 0.0);
-                parent.spawn((
-                    Text2d(format!("{}", h.0)),
-                    TextColor(BLACK.into()),
-                    Transform::from_translation(offset),
-                    BATTLER,
-                ));
-            });
-        }
-    })
+            .unwrap();
+        debug!("Updating health");
+        let mut t = texts.get_mut(child).unwrap();
+        t.0 = format!("{}", h.0);
+    });
+}
+
+fn on_add_health(
+    event: On<Add, Health>,
+    query: Query<(&Health, &Mesh2d)>,
+    meshes: Res<Assets<Mesh>>,
+    mut commands: Commands,
+) {
+    let (h, m) = query.get(event.entity).unwrap();
+    info!("Creating health display");
+    commands.entity(event.entity).with_children(|parent| {
+        let mesh = meshes.get(&m.0).unwrap();
+        let aabb = mesh.compute_aabb().unwrap();
+        let offset = Vec3::new(0.0, aabb.half_extents.y + 10.0, 0.0);
+        parent.spawn((
+            Text2d(format!("{}", h.0)),
+            TextColor(BLACK.into()),
+            Transform::from_translation(offset),
+            BATTLER,
+        ));
+    });
 }
 
 #[derive(Message, EntityEvent)]
diff --git a/src/lib.rs b/src/lib.rs
index f6c33ee..f719abc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -13,12 +13,16 @@ mod ui;
 mod version;
 
 // Rust stdlib
-pub use std::collections::VecDeque;
-pub use std::f32::consts::PI;
-pub use std::fmt::Display;
+pub use std::{
+    collections::VecDeque,
+    f32::consts::PI,
+    fmt::Display,
+};
+pub use core::time::Duration;
 
 // Community libraries
 pub use bevy::{
+    time::common_conditions::*,
     asset::{
         AssetLoader, AssetMetaCheck, LoadContext, LoadState, LoadedFolder, RenderAssetUsages,
         io::Reader, uuid_handle,