Add a const OCTAGON and use it in map.rs

We could made a bunch of pre-built Card constatns for all the basic
shapes. That way we can `Card::OCTAGON` to create one, instead of typing
out the whole function call.

Cargo.toml

@@ -6,6 +6,7 @@ edition = "2024"
 [dependencies]
 bevy = { version = "0.16.1", features = ["dynamic_linking"] }
 bevy-inspector-egui = "0.33.1"
+bevy_ecs_tilemap = "0.16.0"
 
 [profile.dev]
 opt-level = 1

src/assets.rs

@@ -2,14 +2,14 @@ use bevy::prelude::*;
 use std::path::Path;
 
 pub struct TileImage {
-  name: &'static str,
+  pub name: &'static str,
-  thumbnail_handle: Handle<Image>,
+  pub thumbnail_handle: Handle<Image>,
-  tile_handle: Handle<Image>,
+  pub tile_handle: Handle<Image>,
 }
 
 #[derive(Resource)]
 pub struct AssetLibrary {
-  tile_images: Vec<TileImage>,
+  pub tile_images: Vec<TileImage>,
 }
 
 impl AssetLibrary {
@@ -33,7 +33,8 @@ impl AssetLibrary {
       "corner-sw-3-walls",
       "full-0-walls",
       "full-1-wall",
-      "full-2-walls",
+      "full-2-walls-corner",
+      "full-2-walls-hallway",
       "full-3-walls",
       "full-4-walls",
     ];
@@ -59,6 +60,15 @@ impl AssetLibrary {
     Self { tile_images }
   }
 
+  pub fn get_index(&self, name: &str) -> Option<u32> {
+    self
+      .tile_images
+      .iter()
+      .enumerate()
+      .find(|(_, tile)| tile.name == name)
+      .map(|(index, _)| index as u32)
+  }
+
   pub fn get_thumbnail(&self, name: &str) -> Option<Handle<Image>> {
     self
       .tile_images

src/card.rs

@@ -14,6 +14,25 @@ pub enum Cell {
   Filled,
 }
 
+#[derive(Clone, Copy, Debug)]
+pub struct Walls {
+  pub north: bool,
+  pub east: bool,
+  pub south: bool,
+  pub west: bool,
+}
+
+impl Walls {
+  pub fn new(north: bool, east: bool, south: bool, west: bool) -> Self {
+    Self {
+      north,
+      east,
+      south,
+      west,
+    }
+  }
+}
+
 #[derive(Clone, Copy, Debug)]
 pub enum CutLine {
   VertLeft,
@@ -51,18 +70,36 @@ pub enum RotationDir {
 /// *or may not* be valid, yet.
 #[derive(Clone, Copy, Component, Debug, Default, PartialEq)]
 pub struct Card {
-  cells: [Cell; 9],
+  pub cells: [Cell; 9],
-  nw: bool,
+  pub nw: bool,
-  n: bool,
+  pub n: bool,
-  ne: bool,
+  pub ne: bool,
-  w: bool,
+  pub w: bool,
-  e: bool,
+  pub e: bool,
-  sw: bool,
+  pub sw: bool,
-  s: bool,
+  pub s: bool,
-  se: bool,
+  pub se: bool,
 }
 
 impl Card {
+  /// Create a new card from the given Cell array
+  pub const fn new(cells: [Cell; 9]) -> Self {
+    Self {
+      cells,
+      nw: false,
+      n: false,
+      ne: false,
+      w: false,
+      e: false,
+      sw: false,
+      s: false,
+      se: false,
+    }
+  }
+
+  // TODO: The other shapes
+  pub const OCTAGON: Self = Self::new(OCTAGON);
+
   /// Produces a new card by stacking another on top of this one.
   pub fn merge(self, top: Self) -> (Self, Option<Self>) {
     let mut new_card = Self::default();

src/game/map.rs

@@ -0,0 +1,426 @@
+use bevy::prelude::*;
+use bevy_ecs_tilemap::prelude::*;
+
+use crate::assets::AssetLibrary;
+use crate::card::{Card, Cell, Walls};
+
+pub fn setup_test_tilemap(mut commands: Commands, assets: Res<AssetLibrary>) {
+  let tilemap_entity = commands.spawn_empty().id();
+  let tilemap_id = TilemapId(tilemap_entity);
+
+  let map_size = TilemapSize { x: 9, y: 9 };
+  let mut tile_storage = TileStorage::empty(map_size);
+
+  let card = Card::OCTAGON;
+
+  add_card_to_tilemap(
+    &card,
+    &assets,
+    TilePos { x: 0, y: 2 },
+    tilemap_id,
+    &mut commands,
+    &mut tile_storage,
+  );
+
+  let tile_size = TilemapTileSize { x: 48.0, y: 48.0 };
+  let grid_size = tile_size.into();
+  let map_type = TilemapType::default();
+
+  let texture_handles = assets
+    .tile_images
+    .iter()
+    .map(|image| image.tile_handle.clone())
+    .collect();
+
+  commands.entity(tilemap_entity).insert(TilemapBundle {
+    grid_size,
+    map_type,
+    size: map_size,
+    storage: tile_storage,
+    texture: TilemapTexture::Vector(texture_handles),
+    tile_size,
+    anchor: TilemapAnchor::BottomLeft,
+    ..Default::default()
+  });
+}
+
+/// Returns a cell description for a tilemap, including the texture index and a flip configuration
+fn get_cell_description(
+  cell: &Cell,
+  walls: &Walls,
+  assets: &AssetLibrary,
+) -> Option<(u32, TileFlip)> {
+  // Filter allowed walls
+  let walls = match cell {
+    Cell::NW => Walls {
+      north: false,
+      east: walls.east,
+      south: walls.south,
+      west: false,
+    },
+    Cell::NE => Walls {
+      north: false,
+      east: false,
+      south: walls.south,
+      west: walls.west,
+    },
+    Cell::SE => Walls {
+      north: walls.north,
+      east: false,
+      south: false,
+      west: walls.west,
+    },
+    Cell::SW => Walls {
+      north: walls.north,
+      east: walls.east,
+      south: false,
+      west: false,
+    },
+    _ => *walls,
+  };
+
+  let wall_count = (if walls.north { 1 } else { 0 })
+    + (if walls.east { 1 } else { 0 })
+    + (if walls.south { 1 } else { 0 })
+    + (if walls.west { 1 } else { 0 });
+
+  match (cell, wall_count) {
+    (Cell::Empty, _) => None,
+    (Cell::NW, 0) => Some((
+      assets.get_index("corner-nw-1-wall").unwrap(),
+      TileFlip::default(),
+    )),
+    (Cell::NW, 1) => {
+      if walls.east {
+        Some((
+          assets.get_index("corner-nw-2-walls-east").unwrap(),
+          TileFlip::default(),
+        ))
+      } else if walls.south {
+        Some((
+          assets.get_index("corner-nw-2-walls-south").unwrap(),
+          TileFlip::default(),
+        ))
+      } else {
+        unreachable!()
+      }
+    }
+    (Cell::NW, 2) => Some((
+      assets.get_index("corner-nw-3-walls").unwrap(),
+      TileFlip::default(),
+    )),
+    (Cell::NE, 0) => Some((
+      assets.get_index("corner-ne-1-wall").unwrap(),
+      TileFlip::default(),
+    )),
+    (Cell::NE, 1) => {
+      if walls.west {
+        Some((
+          assets.get_index("corner-ne-2-walls-west").unwrap(),
+          TileFlip::default(),
+        ))
+      } else if walls.south {
+        Some((
+          assets.get_index("corner-ne-2-walls-south").unwrap(),
+          TileFlip::default(),
+        ))
+      } else {
+        unreachable!()
+      }
+    }
+    (Cell::NE, 2) => Some((
+      assets.get_index("corner-ne-3-walls").unwrap(),
+      TileFlip::default(),
+    )),
+    (Cell::SE, 0) => Some((
+      assets.get_index("corner-se-1-wall").unwrap(),
+      TileFlip::default(),
+    )),
+    (Cell::SE, 1) => {
+      if walls.west {
+        Some((
+          assets.get_index("corner-se-2-walls-west").unwrap(),
+          TileFlip::default(),
+        ))
+      } else if walls.north {
+        Some((
+          assets.get_index("corner-se-2-walls-north").unwrap(),
+          TileFlip::default(),
+        ))
+      } else {
+        unreachable!()
+      }
+    }
+    (Cell::SE, 2) => Some((
+      assets.get_index("corner-se-3-walls").unwrap(),
+      TileFlip::default(),
+    )),
+    (Cell::SW, 0) => Some((
+      assets.get_index("corner-sw-1-wall").unwrap(),
+      TileFlip::default(),
+    )),
+    (Cell::SW, 1) => {
+      if walls.east {
+        Some((
+          assets.get_index("corner-sw-2-walls-east").unwrap(),
+          TileFlip::default(),
+        ))
+      } else if walls.north {
+        Some((
+          assets.get_index("corner-sw-2-walls-north").unwrap(),
+          TileFlip::default(),
+        ))
+      } else {
+        unreachable!()
+      }
+    }
+    (Cell::SW, 2) => Some((
+      assets.get_index("corner-sw-3-walls").unwrap(),
+      TileFlip::default(),
+    )),
+    (Cell::Filled, 0) => Some((
+      assets.get_index("full-0-walls").unwrap(),
+      TileFlip::default(),
+    )),
+    (Cell::Filled, 1) => {
+      if walls.north {
+        Some((
+          assets.get_index("full-1-wall").unwrap(),
+          TileFlip::default(),
+        ))
+      } else if walls.east {
+        Some((
+          assets.get_index("full-1-wall").unwrap(),
+          TileFlip {
+            x: true,
+            y: false,
+            d: true,
+          },
+        ))
+      } else if walls.south {
+        Some((
+          assets.get_index("full-1-wall").unwrap(),
+          TileFlip {
+            x: false,
+            y: true,
+            d: false,
+          },
+        ))
+      } else {
+        // walls.west
+        Some((
+          assets.get_index("full-1-wall").unwrap(),
+          TileFlip {
+            x: false,
+            y: false,
+            d: true,
+          },
+        ))
+      }
+    }
+    (Cell::Filled, 2) => {
+      if walls.west && walls.north {
+        Some((
+          assets.get_index("full-2-walls-corner").unwrap(),
+          TileFlip::default(),
+        ))
+      } else if walls.north && walls.east {
+        Some((
+          assets.get_index("full-2-walls-corner").unwrap(),
+          TileFlip {
+            x: true,
+            y: false,
+            d: false,
+          },
+        ))
+      } else if walls.east && walls.south {
+        Some((
+          assets.get_index("full-2-walls-corner").unwrap(),
+          TileFlip {
+            x: true,
+            y: true,
+            d: false,
+          },
+        ))
+      } else if walls.south && walls.west {
+        Some((
+          assets.get_index("full-2-walls-corner").unwrap(),
+          TileFlip {
+            x: false,
+            y: true,
+            d: false,
+          },
+        ))
+      } else if walls.north && walls.south {
+        Some((
+          assets.get_index("full-2-walls-hallway").unwrap(),
+          TileFlip {
+            x: false,
+            y: false,
+            d: false,
+          },
+        ))
+      } else if walls.east && walls.west {
+        Some((
+          assets.get_index("full-2-walls-hallway").unwrap(),
+          TileFlip {
+            x: false,
+            y: false,
+            d: true,
+          },
+        ))
+      } else {
+        unreachable!()
+      }
+    }
+    (Cell::Filled, 3) => {
+      if !walls.north {
+        Some((
+          assets.get_index("full-3-walls").unwrap(),
+          TileFlip {
+            x: false,
+            y: true,
+            d: true,
+          },
+        ))
+      } else if !walls.east {
+        Some((
+          assets.get_index("full-3-walls").unwrap(),
+          TileFlip::default(),
+        ))
+      } else if !walls.south {
+        Some((
+          assets.get_index("full-3-walls").unwrap(),
+          TileFlip {
+            x: false,
+            y: false,
+            d: true,
+          },
+        ))
+      } else if walls.west {
+        Some((
+          assets.get_index("full-3-walls").unwrap(),
+          TileFlip {
+            x: true,
+            y: false,
+            d: false,
+          },
+        ))
+      } else {
+        unreachable!()
+      }
+    }
+    (Cell::Filled, 4) => Some((
+      assets.get_index("full-4-walls").unwrap(),
+      TileFlip::default(),
+    )),
+    _ => unreachable!(),
+  }
+}
+
+/// Returns an array of cell descriptions, starting from the top right tile and moving right to left, top to bottom
+fn get_card_description(card: &Card, assets: &AssetLibrary) -> [Option<(u32, TileFlip)>; 9] {
+  let mut walls = [
+    Walls::new(true, false, false, true),
+    Walls::new(true, false, false, false),
+    Walls::new(true, true, false, false),
+    Walls::new(false, false, false, true),
+    Walls::new(false, false, false, false),
+    Walls::new(false, true, false, false),
+    Walls::new(false, false, true, true),
+    Walls::new(false, false, true, false),
+    Walls::new(false, true, true, false),
+  ];
+
+  if card.cells[0] == Cell::Empty {
+    walls[1].west = true;
+    walls[3].north = true;
+  }
+  if card.cells[1] == Cell::Empty {
+    walls[0].east = true;
+    walls[2].west = true;
+    walls[4].north = true;
+  }
+  if card.cells[2] == Cell::Empty {
+    walls[1].east = true;
+    walls[5].north = true;
+  }
+  if card.cells[3] == Cell::Empty {
+    walls[0].south = true;
+    walls[4].west = true;
+    walls[6].north = true;
+  }
+  if card.cells[4] == Cell::Empty {
+    walls[1].south = true;
+    walls[3].east = true;
+    walls[5].west = true;
+    walls[7].north = true;
+  }
+  if card.cells[5] == Cell::Empty {
+    walls[2].south = true;
+    walls[4].east = true;
+    walls[8].north = true;
+  }
+  if card.cells[6] == Cell::Empty {
+    walls[7].west = true;
+    walls[3].south = true;
+  }
+  if card.cells[7] == Cell::Empty {
+    walls[6].east = true;
+    walls[8].west = true;
+    walls[4].south = true;
+  }
+  if card.cells[8] == Cell::Empty {
+    walls[7].east = true;
+    walls[5].south = true;
+  }
+
+  card
+    .cells
+    .iter()
+    .zip(walls.iter())
+    .map(|(cell, walls)| get_cell_description(cell, walls, assets))
+    .collect::<Vec<_>>()
+    .try_into()
+    .unwrap()
+}
+
+fn add_card_to_tilemap(
+  card: &Card,
+  assets: &AssetLibrary,
+  top_left: TilePos,
+  tilemap_id: TilemapId,
+  commands: &mut Commands,
+  tile_storage: &mut TileStorage,
+) {
+  get_card_description(card, assets)
+    .iter()
+    .enumerate()
+    .for_each(|(index, desc)| {
+      let dx = (index as u32) % 3;
+      let dy = (index as u32) / 3;
+
+      let position = TilePos {
+        x: top_left.x + dx,
+        y: top_left.y - dy,
+      };
+
+      match desc {
+        Some((texture_index, flip)) => {
+          let tile_entity = commands
+            .spawn(TileBundle {
+              position,
+              tilemap_id,
+              texture_index: TileTextureIndex(*texture_index),
+              flip: *flip,
+              ..Default::default()
+            })
+            .id();
+          tile_storage.set(&position, tile_entity);
+        }
+        None => {
+          tile_storage.remove(&position);
+        }
+      };
+    });
+}

src/game/mod.rs

@@ -1,5 +1,8 @@
 use bevy::prelude::*;
 
+pub mod map;
+pub mod player;
+
 /// Data component for info about the player's current set of cards.
 ///
 /// [`Self::capacity`] is the maximum hand size.
@@ -16,22 +19,16 @@ pub mod machines {
 
   use bevy::prelude::*;
 
-  use crate::game::consumables::Fuel;
-
   #[derive(Component)]
-  #[require(Fuel)]
   pub struct CuttingMachine;
 
   #[derive(Component)]
-  #[require(Fuel)]
   pub struct RotatingMachine;
 
   #[derive(Component)]
-  #[require(Fuel)]
   pub struct FlippingMachine;
 
   #[derive(Component)]
-  #[require(Fuel)]
   pub struct TransposingMachine;
 }
 
@@ -39,13 +36,5 @@ pub mod consumables {
   use bevy::prelude::*;
 
   #[derive(Component)]
-  pub struct Fuel(pub u32);
+  pub struct Fuel(u32);
-
-  impl Default for Fuel {
-    fn default() -> Self {
-        Self(5)
-    }
-  }
-  #[derive(Event)]
-  pub struct FuelChanged;
 }

src/game/player.rs

@@ -0,0 +1,28 @@
+use bevy::prelude::*;
+
+#[derive(Component)]
+#[require(Transform)]
+pub struct Player;
+
+pub fn spawn_player(
+  mut commands: Commands,
+  mut meshes: ResMut<Assets<Mesh>>,
+  mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+  let shape = Circle::new(12.0);
+  let mesh = meshes.add(shape);
+
+  let color = Color::srgb(1., 0., 0.);
+  let material = materials.add(color);
+
+  commands.spawn((
+    Player,
+    Mesh2d(mesh),
+    MeshMaterial2d(material),
+    Transform::from_translation(Vec3 {
+      x: 72.,
+      y: 72.,
+      z: 1.,
+    }),
+  ));
+}

src/main.rs

@@ -1,12 +1,10 @@
-use bevy::{color::palettes::css::*, prelude::*, window::WindowResolution};
+use bevy::{color::palettes::css::GREEN, prelude::*, window::WindowResolution};
+use bevy_ecs_tilemap::prelude::*;
 use bevy_inspector_egui::{bevy_egui::EguiPlugin, quick::WorldInspectorPlugin};
 
 use crate::{
-  game::{
+  game::machines::{CuttingMachine, RotatingMachine},
-    machines::{CuttingMachine, FlippingMachine, RotatingMachine, TransposingMachine},
-  },
   resources::UiTheme,
-  widgets::SpawnUi,
 };
 
 mod assets;
@@ -27,12 +25,38 @@ fn main() {
     .add_plugins(EguiPlugin::default())
     .add_plugins(WorldInspectorPlugin::new())
     .add_plugins(widgets::GameUiPlugin)
-    .add_systems(Startup, (setup, assets::load_assets, dummy_machines))
+    .add_plugins(TilemapPlugin)
+    .init_resource::<resources::UiTheme>()
+    .register_type::<resources::UiTheme>()
+    .add_systems(
+      Startup,
+      (
+        setup,
+        assets::load_assets,
+        game::map::setup_test_tilemap,
+        dummy_machine,
+      )
+        .chain(),
+    )
     .run();
 }
 
 fn setup(mut commands: Commands) {
-  commands.spawn(Camera2d);
+  commands.spawn((
+    Camera2d,
+    Projection::Orthographic(OrthographicProjection {
+      scaling_mode: bevy::render::camera::ScalingMode::AutoMin {
+        min_width: 360.0,
+        min_height: 240.0,
+      },
+      ..OrthographicProjection::default_2d()
+    }),
+    Transform::from_translation(Vec3 {
+      x: 72.,
+      y: 72.,
+      z: 0.,
+    }),
+  ));
 }
 
 /// Generic utility for despawning entities that have a given component.
@@ -42,54 +66,26 @@ fn despawn<T: Component>(mut commands: Commands, to_despawn: Query<Entity, With<
   }
 }
 
-/// Dev tool for spawning dummy entities. I'm developing their UIs by hooking
+fn dummy_machine(
-/// up to these while the TileMap gets ready.
+  mut commands: Commands,
-fn dummy_machines(mut commands: Commands) {
+  // mut meshes: ResMut<Assets<Mesh>>,
-  // Spawn a dummy Cutting Machine
+  // mut materials: ResMut<Assets<ColorMaterial>>,
-  commands
-    .spawn((
-      CuttingMachine,
-      Sprite::from_color(RED, Vec2::splat(40.0)),
-      Transform::from_translation(Vec3::new(-40.0, 40.0, 0.0)),
-      Pickable::default(),
-    ))
-    .observe(spawn_machine_ui::<CuttingMachine>);
-
-  commands
-    .spawn((
-      RotatingMachine,
-      Sprite::from_color(GREEN, Vec2::splat(40.0)),
-      Transform::from_translation(Vec3::new(40.0, 40.0, 0.0)),
-      Pickable::default(),
-    ))
-    .observe(spawn_machine_ui::<RotatingMachine>);
-
-  // TODO: The other observers, once they have a spawner struct & impl.
-  commands
-    .spawn((
-      FlippingMachine,
-      Sprite::from_color(PURPLE, Vec2::splat(40.)),
-      Transform::from_translation(Vec3::new(-40.0, -40.0, 0.0)),
-      Pickable::default(),
-    ))
-    .observe(spawn_machine_ui::<FlippingMachine>);
-
-  commands
-    .spawn((
-      TransposingMachine,
-      Sprite::from_color(DARK_ORANGE, Vec2::splat(40.)),
-      Transform::from_translation(Vec3::new(40.0, -40.0, 0.0)),
-      Pickable::default(),
-    ))
-    .observe(spawn_machine_ui::<TransposingMachine>);
-}
-
-fn spawn_machine_ui<M: SpawnUi>(
-  event: Trigger<Pointer<Click>>,
-  commands: Commands,
-  theme: Res<UiTheme>,
 ) {
-  let _entity = event.target;
+  commands
-  // TODO: Hook up the Fuel component (and spawn one so that I can)
+    .spawn((
-  M::spawn_ui(commands, theme, event.target());
+      Sprite::from_color(GREEN, Vec2::splat(40.0)),
+      // WARN: Mesh picking is not part of the `DefaultPlugins` plugin collection!
+      // (but sprite picking is!)
+
+      // Mesh2d(meshes.add(Rectangle::new(25., 25.))),
+      // MeshMaterial2d(materials.add(ColorMaterial::from_color(GREEN))),
+      Transform::default(),
+      Pickable::default(),
+    ))
+    .observe(
+      |event: Trigger<Pointer<Click>>, commands: Commands, theme: Res<UiTheme>| {
+        let entity = event.target;
+        CuttingMachine::spawn_ui(commands, theme);
+      },
+    );
 }

src/widgets/fuel_gauge.rs

@@ -1,44 +0,0 @@
-use bevy::{color::palettes::css::*, prelude::*, ui::Val::*};
-
-use crate::game::consumables::{Fuel, FuelChanged};
-
-#[derive(Component)]
-#[require(Label)]
-pub struct FuelGauge(Entity);
-
-impl FuelGauge {
-  /// Default bundle for a machine's fuel gauge widget. Give it the ID of the
-  /// machine whose info it is displaying.
-  pub fn bundle(target: Entity) -> impl Bundle {
-    (
-      FuelGauge(target),
-      Node {
-        min_width: Px(20.0),
-        min_height: Px(10.0),
-        ..default()
-      },
-      BackgroundColor(GREEN.into()),
-      Text::new("Fuel: "),
-    )
-  }
-
-  /// Observer system to update the [`FuelGauge`] widget when a machine emits a
-  /// [`FuelChanged`] event.
-  pub fn detect_fuel_change(
-    event: Trigger<FuelChanged>,
-    fuel_levels: Query<&Fuel>,
-    mut gauges: Query<(&FuelGauge, &mut Text)>,
-  ) {
-    // Find the FuelGauge that references the same Entity as the event target.
-    // That gauge's `Text` is the one to update.
-    let (_, mut label) = gauges
-      .iter_mut()
-      .find(|(gauge, _label)| gauge.0 == event.target())
-      .expect("Couldn't find any fuel gauges");
-
-    let fuel = fuel_levels.get(event.target()).expect(
-      "Logic error: a `FuelChanged` event was targetted at an entity with no `Fuel` component.",
-    );
-    label.0 = format!("Fuel: {}", fuel.0);
-  }
-}

src/widgets/machines.rs

@@ -1,18 +1,25 @@
-use bevy::{color::palettes::css::*, prelude::*};
+use bevy::{color::palettes::css::*, prelude::*, ui::Val::*};
 
 use crate::{
-  game::{consumables::FuelChanged, machines::*},
+  game::machines::*,
   resources::UiTheme,
-  widgets::{BigRedButton, SpawnUi, fuel_gauge::FuelGauge, machine_ui_base},
+  widgets::{BigRedButton, machine_ui_base},
 };
 
-impl SpawnUi for CuttingMachine {
+impl CuttingMachine {
-  fn spawn_ui(mut commands: Commands, theme: Res<UiTheme>, machine_id: Entity) {
+  pub fn spawn_ui(mut commands: Commands, theme: Res<UiTheme>) {
     let base_entity = machine_ui_base(&mut commands, "Cutting Machine", &theme);
     commands.entity(base_entity).with_children(|commands| {
       // Left panel. For fuel or machine stats or whatever.
-      // TODO: Pass along target machine, not the UI's root entity.
+      commands.spawn((
-      commands.spawn(FuelGauge::bundle(machine_id));
+        Node {
+          padding: UiRect::all(Px(10.0)),
+          ..default()
+        },
+        BackgroundColor(GREEN.into()),
+        Pickable::default(),
+        children![(Text::new("Uses: <n>"), TextColor(BLACK.into()),)],
+      ));
 
       // Center panel (placeholder for the Card view)
       commands.spawn((
@@ -36,11 +43,7 @@ impl SpawnUi for CuttingMachine {
           Pickable::default(),
         ))
         .with_children(|cmds| {
-          let mut button_cmds = cmds.spawn(BigRedButton::bundle("CUT"));
+          let _button_cmds = cmds.spawn(BigRedButton::bundle("CUT"));
-          button_cmds.observe(move |trigger: Trigger<Pointer<Click>>, mut com: Commands| {
-            dbg!("Cut button pressed. Triggering a FuelChanged event");
-            com.trigger_targets(FuelChanged, machine_id);
-          });
           // TODO: Attach on-press observer so this machine can do something
           // in response to that button being pressed
         });
@@ -48,11 +51,19 @@ impl SpawnUi for CuttingMachine {
   }
 }
 
-impl SpawnUi for RotatingMachine {
+impl RotatingMachine {
-  fn spawn_ui(mut commands: Commands, theme: Res<UiTheme>, machine_id: Entity) {
+  pub fn spawn_ui(mut commands: Commands, theme: Res<UiTheme>) {
     let base_entity = machine_ui_base(&mut commands, "Rotating Machine", &theme);
     commands.entity(base_entity).with_children(|commands| {
-      commands.spawn(FuelGauge::bundle(Entity::PLACEHOLDER));
+      commands.spawn((
+        Node {
+          padding: UiRect::all(Px(10.0)),
+          ..Default::default()
+        },
+        BackgroundColor(GREEN.into()),
+        Pickable::default(),
+        children![(Text::new("Uses: <n>"), TextColor(BLACK.into()))],
+      ));
 
       // Center panel (placeholder for input-output rotation)
       commands.spawn((
@@ -82,73 +93,3 @@ impl SpawnUi for RotatingMachine {
     });
   }
 }
-
-impl SpawnUi for FlippingMachine {
-  fn spawn_ui(mut commands: Commands, theme: Res<UiTheme>, machine_id: Entity) {
-    let base_entity = machine_ui_base(&mut commands, "Flipping Machine", &theme);
-    commands.entity(base_entity).with_children(|commands| {
-      commands.spawn(FuelGauge::bundle(Entity::PLACEHOLDER));
-
-      // Center panel (placeholder)
-      commands.spawn((
-        Node::default(),
-        BackgroundColor(BLUE.into()),
-        Pickable::default(),
-        children![
-          Text::new("Card Flipping placeholder"),
-          TextColor(MAGENTA.into()),
-        ],
-      ));
-
-      // Right panel go button
-      commands
-        .spawn((
-          Node {
-            align_items: AlignItems::End,
-            ..Default::default()
-          },
-          BackgroundColor(DARK_GRAY.into()),
-          Pickable::default(),
-        ))
-        .with_children(|cmds| {
-          let _button_cmds = cmds.spawn(BigRedButton::bundle("FLIP"));
-          // TODO: Attach on-press observer to the button.
-        });
-    });
-  }
-}
-
-impl SpawnUi for TransposingMachine {
-  fn spawn_ui(mut commands: Commands, theme: Res<UiTheme>, machine_id: Entity) {
-    let base_entity = machine_ui_base(&mut commands, "Transposing Machine", &theme);
-    commands.entity(base_entity).with_children(|commands| {
-      commands.spawn(FuelGauge::bundle(Entity::PLACEHOLDER));
-
-      // Center panel (placeholder)
-      commands.spawn((
-        Node::default(),
-        BackgroundColor(BLUE.into()),
-        Pickable::default(),
-        children![
-          Text::new("Card Transposition placeholder"),
-          TextColor(MAGENTA.into()),
-        ],
-      ));
-
-      // Right panel go button
-      commands
-        .spawn((
-          Node {
-            align_items: AlignItems::End,
-            ..Default::default()
-          },
-          BackgroundColor(DARK_GRAY.into()),
-          Pickable::default(),
-        ))
-        .with_children(|cmds| {
-          let _button_cmds = cmds.spawn(BigRedButton::bundle("SWAP"));
-          // TODO: Attach on-press observer to the button.
-        });
-    });
-  }
-}

src/widgets/mod.rs

@@ -1,11 +1,10 @@
 //! Catch-all location for UI bits
 
-mod fuel_gauge;
 pub mod machines;
 
 use bevy::{color::palettes::css::*, prelude::*, ui::Val::*};
 
-use crate::{resources::UiTheme, widgets::fuel_gauge::FuelGauge};
+use crate::resources::UiTheme;
 
 /// Plugin to set up systems & resources for the custom UI elements
 ///
@@ -25,19 +24,10 @@ impl Plugin for GameUiPlugin {
       .add_observer(BigRedButton::button_hover_start)
       .add_observer(BigRedButton::button_hover_stop)
       .add_observer(BigRedButton::button_press_start)
-      .add_observer(BigRedButton::button_press_stop)
+      .add_observer(BigRedButton::button_press_stop);
-      .add_observer(FuelGauge::detect_fuel_change);
   }
 }
 
-/// Machines spawn their UI through this trait.
-///
-/// This exists mainly so that I can write generic functions and have the compiler
-/// expand the code for me, instead of doing it by hand.
-pub trait SpawnUi {
-  fn spawn_ui(commands: Commands, theme: Res<UiTheme>, machine_id: Entity);
-}
-
 /// The base panel for the machines that manipulate the room cards.
 ///
 /// This function is not a valid Bevy System because of how the Commands struct