(autoformat)

Oops. Yay for rushed work.

src/card.rs

@@ -1,5 +1,7 @@
 //! TODO: module doc :v
 
+use bevy::ecs::component::Component;
+
 /// Value for the "sub tiles" inside a room tile
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub enum Cell {
@@ -47,7 +49,7 @@ pub enum RotationDir {
 
 /// An invidiual room, or "card" in the player's hand. The room may
 /// *or may not* be valid, yet.
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[derive(Clone, Copy, Component, Debug, Default, PartialEq)]
 pub struct Card {
   cells: [Cell; 9],
   nw: bool,
@@ -616,7 +618,108 @@ mod test {
 
   #[test]
   fn cut_triangle() {
-    todo!();
+    let tri = Card {
+      cells: NW_TRIANGLE,
+      ..Default::default()
+    };
+
+    // Pairs of each different slice option
+    let vert_left_pair = (
+      Card {
+        #[rustfmt::skip]
+        cells: [
+          Cell::Empty, Cell::Empty, Cell::Empty,
+          Cell::Empty, Cell::Empty, Cell::Empty,
+          Cell::NW, Cell::Empty, Cell::Empty,
+        ],
+        ..Default::default()
+      },
+      Card {
+        #[rustfmt::skip]
+        cells: [
+          Cell::Empty, Cell::Empty, Cell::NW,
+          Cell::Empty, Cell::NW, Cell::Filled,
+          Cell::Empty, Cell::Filled, Cell::Filled,
+        ],
+        ..Default::default()
+      },
+    );
+
+    let vert_right_pair = (
+      Card {
+        #[rustfmt::skip]
+        cells: [
+          Cell::Empty, Cell::Empty, Cell::Empty,
+          Cell::Empty, Cell::NW, Cell::Empty,
+          Cell::NW, Cell::Filled, Cell::Empty,
+        ],
+        ..Default::default()
+      },
+      Card {
+        #[rustfmt::skip]
+        cells: [
+          Cell::Empty, Cell::Empty, Cell::NW,
+          Cell::Empty, Cell::Empty, Cell::Filled,
+          Cell::Empty, Cell::Empty, Cell::Filled,
+        ],
+        ..Default::default()
+      },
+    );
+
+    let horiz_top_pair = (
+      Card {
+        #[rustfmt::skip]
+        cells: [
+          Cell::Empty, Cell::Empty, Cell::NW,
+          Cell::Empty, Cell::Empty, Cell::Empty,
+          Cell::Empty, Cell::Empty, Cell::Empty,
+        ],
+        ..Default::default()
+      },
+      Card {
+        #[rustfmt::skip]
+        cells: [
+          Cell::Empty, Cell::Empty, Cell::Empty,
+          Cell::Empty, Cell::NW, Cell::Filled,
+          Cell::NW, Cell::Filled, Cell::Filled,
+        ],
+        ..Default::default()
+      },
+    );
+
+    let horiz_bottom_pair = (
+      Card {
+        #[rustfmt::skip]
+        cells: [
+          Cell::Empty, Cell::Empty, Cell::NW,
+          Cell::Empty, Cell::NW, Cell::Filled,
+          Cell::Empty, Cell::Empty, Cell::Empty,
+        ],
+        ..Default::default()
+      },
+      Card {
+        #[rustfmt::skip]
+        cells: [
+          Cell::Empty, Cell::Empty, Cell::Empty,
+          Cell::Empty, Cell::Empty, Cell::Empty,
+          Cell::NW, Cell::Filled, Cell::Filled,
+        ],
+        ..Default::default()
+      },
+    );
+
+    // Run tests
+    let result_vleft = tri.clone().cut(CutLine::VertLeft);
+    assert_eq!(result_vleft, vert_left_pair);
+
+    let result_vright = tri.clone().cut(CutLine::VertRight);
+    assert_eq!(result_vright, vert_right_pair);
+
+    let result_hupper = tri.clone().cut(CutLine::HorizUpper);
+    assert_eq!(result_hupper, horiz_top_pair);
+
+    let result_hlower = tri.cut(CutLine::HorizLower);
+    assert_eq!(result_hlower, horiz_bottom_pair);
   }
 
   #[test]

src/game/mod.rs

@@ -0,0 +1,51 @@
+use bevy::prelude::*;
+
+/// Data component for info about the player's current set of cards.
+///
+/// [`Self::capacity`] is the maximum hand size.
+///
+/// [`Self::low_water_mark`] is the threshold for drawing new cards on-room-enter.
+#[derive(Component)]
+pub struct PlayerHand {
+  cards: Vec<Entity>,
+  capacity: u8,
+  low_water_mark: u8,
+}
+
+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;
+}
+
+pub mod consumables {
+  use bevy::prelude::*;
+
+  #[derive(Component)]
+  pub struct Fuel(pub u32);
+
+  impl Default for Fuel {
+    fn default() -> Self {
+      Self(5)
+    }
+  }
+  #[derive(Event)]
+  pub struct FuelChanged;
+}

src/main.rs

@@ -1,8 +1,15 @@
-use bevy::{prelude::*, window::WindowResolution};
+use bevy::{color::palettes::css::*, prelude::*, window::WindowResolution};
 use bevy_inspector_egui::{bevy_egui::EguiPlugin, quick::WorldInspectorPlugin};
 
+use crate::{
+  game::machines::{CuttingMachine, FlippingMachine, RotatingMachine, TransposingMachine},
+  resources::UiTheme,
+  widgets::SpawnUi,
+};
+
 mod assets;
 mod card;
+mod game;
 mod resources;
 mod widgets;
 
@@ -17,16 +24,8 @@ fn main() {
     }))
     .add_plugins(EguiPlugin::default())
     .add_plugins(WorldInspectorPlugin::new())
-    .init_resource::<resources::UiTheme>()
+    .add_plugins(widgets::GameUiPlugin)
-    .register_type::<resources::UiTheme>()
+    .add_systems(Startup, (setup, assets::load_assets, dummy_machines))
-    .add_systems(
-      Startup,
-      (
-        setup,
-        assets::load_assets,
-        widgets::spawn_rotator_machine_ui,
-      ),
-    )
     .run();
 }
 
@@ -40,3 +39,55 @@ fn despawn<T: Component>(mut commands: Commands, to_despawn: Query<Entity, With<
     commands.entity(entity).despawn();
   }
 }
+
+/// Dev tool for spawning dummy entities. I'm developing their UIs by hooking
+/// up to these while the TileMap gets ready.
+fn dummy_machines(mut commands: Commands) {
+  // Spawn a dummy Cutting Machine
+  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;
+  // TODO: Hook up the Fuel component (and spawn one so that I can)
+  M::spawn_ui(commands, theme, event.target());
+}

src/resources.rs

@@ -1,11 +1,16 @@
 //! Program constants & defaults
 
-use bevy::{color::palettes::css::*, prelude::*};
+use bevy::{
+  color::palettes::{css::*, tailwind::SLATE_100},
+  prelude::*,
+};
 
 #[derive(Debug, Reflect, Resource)]
 #[reflect(Resource)]
 pub struct UiTheme {
-  // TODO: Panes
+  // Colors for the machine UI panes
+  // (and others, but we're not there yet)
+  pub pane_bg: Color,
 
   // Colors for the "Big Red Buttons" (the main actions of the machines)
   // normal
@@ -17,17 +22,37 @@ pub struct UiTheme {
   // pressed
   pub brb_pressed_bg: Color,
   pub brb_pressed_border: Color,
+
+  // Colors for low-priority buttons
+  // normal
+  pub quiet_bg: Color,
+  pub quiet_border: Color,
+  // hover
+  pub quiet_hover_bg: Color,
+  pub quiet_hover_border: Color,
+  // pressed
+  pub quiet_pressed_bg: Color,
+  pub quiet_pressed_border: Color,
 }
 
 impl FromWorld for UiTheme {
-  fn from_world(world: &mut World) -> Self {
+  fn from_world(_world: &mut World) -> Self {
     Self {
+      pane_bg: SLATE_100.into(),
+
       brb_bg: RED.into(),
       brb_border: DARK_RED.into(),
       brb_hover_bg: PINK.into(),
       brb_hover_border: RED.into(),
       brb_pressed_bg: GREEN.into(),
       brb_pressed_border: DARK_GREEN.into(),
+
+      quiet_bg: GRAY.into(),
+      quiet_border: DARK_GRAY.into(),
+      quiet_hover_bg: DARK_GRAY.into(),
+      quiet_hover_border: LIGHT_GRAY.into(),
+      quiet_pressed_bg: LIGHT_GRAY.into(),
+      quiet_pressed_border: GRAY.into(),
     }
   }
 }

src/widgets/fuel_gauge.rs

@@ -0,0 +1,69 @@
+use bevy::{
+  color::palettes::css::*,
+  ecs::{component::HookContext, world::DeferredWorld},
+  prelude::*,
+  ui::Val::*,
+};
+
+use crate::game::consumables::{Fuel, FuelChanged};
+
+#[derive(Component)]
+#[require(Label)]
+#[component(on_add = FuelGauge::refresh_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);
+  }
+
+  fn refresh_label(mut world: DeferredWorld, ctx: HookContext) {
+    // Get the machine ID from the FuelGauge component.
+    let Some(machine_id) = world.get::<FuelGauge>(ctx.entity).map(|fg| fg.0) else {
+      panic!("Couldn't get a FuelGauge during it's on-add hook run!");
+    };
+    // and fuel level
+    let Some(fuel) = world.get::<Fuel>(machine_id).map(|lvl| lvl.0) else {
+      // TODO: Maybe don't panic and just emit a warning.
+      panic!("Couldn't get a Fuel for a machine during a FuelGauge on-add hook.");
+    };
+
+    // Get an excl ref to the Text component so we can redraw its text
+    let Some(mut label) = world.get_mut::<Text>(ctx.entity) else {
+      panic!()
+    };
+
+    label.0 = format!("Fuel: {}", fuel);
+  }
+}

src/widgets/machines.rs

@@ -0,0 +1,154 @@
+use bevy::{color::palettes::css::*, prelude::*};
+
+use crate::{
+  game::{consumables::FuelChanged, machines::*},
+  resources::UiTheme,
+  widgets::{BigRedButton, SpawnUi, fuel_gauge::FuelGauge, machine_ui_base},
+};
+
+impl SpawnUi for CuttingMachine {
+  fn spawn_ui(mut commands: Commands, theme: Res<UiTheme>, machine_id: Entity) {
+    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(FuelGauge::bundle(machine_id));
+
+      // Center panel (placeholder for the Card view)
+      commands.spawn((
+        Node::default(),
+        BackgroundColor(BLUE.into()),
+        Pickable::default(),
+        children![(
+          Text::new("Card cut view placeholder"),
+          TextColor(MAGENTA.into()),
+          TextShadow::default(),
+        ),],
+      ));
+      // Right panel for the "CUT" button
+      commands
+        .spawn((
+          Node {
+            align_items: AlignItems::End,
+            ..Default::default()
+          },
+          BackgroundColor(DARK_GRAY.into()),
+          Pickable::default(),
+        ))
+        .with_children(|cmds| {
+          let mut 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
+        });
+    });
+  }
+}
+
+impl SpawnUi for RotatingMachine {
+  fn spawn_ui(mut commands: Commands, theme: Res<UiTheme>, machine_id: Entity) {
+    let base_entity = machine_ui_base(&mut commands, "Rotating Machine", &theme);
+    commands.entity(base_entity).with_children(|commands| {
+      commands.spawn(FuelGauge::bundle(machine_id));
+
+      // Center panel (placeholder for input-output rotation)
+      commands.spawn((
+        Node::default(),
+        BackgroundColor(BLUE.into()),
+        Pickable::default(),
+        children![
+          Text::new("Card rotation side-by-side placeholder"),
+          TextColor(MAGENTA.into()),
+        ],
+      ));
+
+      // Right panel for the rotation controls
+      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("TURN"));
+          // TODO: Attach on-press observer to the button.
+        });
+    });
+  }
+}
+
+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(machine_id));
+
+      // 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(machine_id));
+
+      // 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,95 +1,52 @@
 //! Catch-all location for UI bits
 
-use bevy::{
+mod fuel_gauge;
-  color::palettes::{css::*, tailwind::*},
+pub mod machines;
-  prelude::*,
-  ui::Val::*,
-};
 
-use crate::resources::UiTheme;
+use bevy::{color::palettes::css::*, prelude::*, ui::Val::*};
 
-pub fn spawn_cutter_machine_ui(mut commands: Commands) {
+use crate::{resources::UiTheme, widgets::fuel_gauge::FuelGauge};
-  commands
-    .spawn((machine_ui_base("Cutting Machine"),))
-    .with_children(|commands| {
-      // Left panel. For fuel or machine stats or whatever.
-      commands.spawn((
-        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)
+/// Plugin to set up systems & resources for the custom UI elements
-      commands.spawn((
+///
-        Node::default(),
+/// The UiTheme resource is initialized and the button press Observers
-        BackgroundColor(BLUE.into()),
+/// are registered here.
-        Pickable::default(),
+pub struct GameUiPlugin;
-        children![(
+
-          Text::new("Card cut view placeholder"),
+impl Plugin for GameUiPlugin {
-          TextColor(MAGENTA.into()),
+  fn build(&self, app: &mut App) {
-          TextShadow::default(),
+    app
-        ),],
+      .init_resource::<UiTheme>()
-      ));
+      .register_type::<UiTheme>()
-      // Right panel for the "CUT" button
+      .add_observer(CloseButton::hover_start)
-      commands
+      .add_observer(CloseButton::hover_stop)
-        .spawn((
+      .add_observer(CloseButton::press_start)
-          Node {
+      .add_observer(CloseButton::press_stop)
-            align_items: AlignItems::End,
+      .add_observer(BigRedButton::button_hover_start)
-            ..Default::default()
+      .add_observer(BigRedButton::button_hover_stop)
-          },
+      .add_observer(BigRedButton::button_press_start)
-          BackgroundColor(DARK_GRAY.into()),
+      .add_observer(BigRedButton::button_press_stop)
-          Pickable::default(),
+      .add_observer(FuelGauge::detect_fuel_change);
-        ))
+  }
-        .with_children(|cmds| spawn_machine_button(cmds, "CUT"));
-    });
 }
 
-pub fn spawn_rotator_machine_ui(mut commands: Commands) {
+/// Machines spawn their UI through this trait.
-  commands
+///
-    .spawn((machine_ui_base("Rotating Machine"),))
+/// This exists mainly so that I can write generic functions and have the compiler
-    .with_children(|commands| {
+/// expand the code for me, instead of doing it by hand.
-      commands.spawn((
+pub trait SpawnUi {
-        Node {
+  fn spawn_ui(commands: Commands, theme: Res<UiTheme>, machine_id: Entity);
-          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((
-        Node::default(),
-        BackgroundColor(BLUE.into()),
-        Pickable::default(),
-        children![
-          Text::new("Card rotation side-by-side placeholder"),
-          TextColor(MAGENTA.into()),
-        ]
-      ));
-
-      // Right panel for the rotation controls
-      commands
-        .spawn((
-          Node {
-            align_items: AlignItems::End,
-            ..Default::default()
-          },
-          BackgroundColor(DARK_GRAY.into()),
-          Pickable::default(),
-        ))
-        .with_children(|cmds| spawn_machine_button(cmds, "TURN"));
-    });
 }
 
 /// The base panel for the machines that manipulate the room cards.
-fn machine_ui_base(header: impl Into<String>) -> impl Bundle {
+///
-  (
+/// This function is not a valid Bevy System because of how the Commands struct
+/// is passed through. Users are meant to call this *from* a System to create a
+/// base UI Node. That system then re-acquires an [`EntityCommands`] and adds
+/// child nodes to fill out the panel.
+fn machine_ui_base(commands: &mut Commands, header: impl Into<String>, theme: &UiTheme) -> Entity {
+  let root_pane = commands
+    .spawn((
       Node {
         // Position & size
         position_type: PositionType::Relative,
@@ -113,13 +70,13 @@ fn machine_ui_base(header: impl Into<String>) -> impl Bundle {
 
         ..default()
       },
-    BackgroundColor(SLATE_100.into()),
+      BackgroundColor(theme.pane_bg),
       BorderRadius::all(Percent(2.0)),
       children![(
         // TODO: A real node with stuff in it (buttons, maybe?)
         Node {
           justify_content: JustifyContent::Center,
-        grid_column: GridPlacement::span(3),
+          grid_column: GridPlacement::span(2),
           ..default()
         },
         BackgroundColor(RED.into()),
@@ -129,14 +86,32 @@ fn machine_ui_base(header: impl Into<String>) -> impl Bundle {
           TextColor(BLACK.into()),
           // TODO: Text shadow, maybe. I couldn't make it look good.
         )],
-    )],
+      ),],
-  )
+    ))
+    .id();
+
+  commands.entity(root_pane).with_children(|cmds| {
+    cmds.spawn(CloseButton::bundle(root_pane));
+  });
+  root_pane
 }
 
-// TODO: Hook up action handling (callback? Observer? Some other weird component?)
+/// The "Big Red Button" that makes a machine perform it's action.
-fn spawn_machine_button(commands: &mut ChildSpawnerCommands, text: impl Into<String>) {
+#[derive(Component)]
-  let mut builder = commands.spawn((
+pub struct BigRedButton;
+
+impl BigRedButton {
+  /// Default bundle for a Big Red Button. Remember to attach on-press observers!
+  ///
+  /// I haven't figure out what will receive the on-press events, so I'm moving
+  /// the problem. It will not be the button's job to hook up the event notice.
+  ///
+  /// TODO: Pass in the UiTheme struct
+  fn bundle(text: impl Into<String>) -> impl Bundle {
+    (
+      // TODO: Remove `Button`? Add `Button` to the `CloseButton` bundle?
       Button,
+      BigRedButton,
       Node {
         width: Px(60.0),
         height: Px(60.0),
@@ -158,60 +133,143 @@ fn spawn_machine_button(commands: &mut ChildSpawnerCommands, text: impl Into<Str
         TextColor(WHITE.into()),
         TextShadow::default(),
       ],
-  ));
+    )
-  builder.observe(button_hover_start);
+  }
-  builder.observe(button_hover_stop);
-  builder.observe(button_press_start);
-  builder.observe(button_press_stop);
-}
 
-/// Re-color the button when a pointer passes over it
+  /// Re-color the button when a pointer passes over it
-fn button_hover_start(
+  fn button_hover_start(
     event: Trigger<Pointer<Over>>,
     // Get button background and border colors so we can change them.
     // Filter for *changed* interactions, and only entities with a [`Button`]
-  mut button_colors: Query<(&mut BackgroundColor, &mut BorderColor), With<Button>>,
+    mut button_colors: Query<(&mut BackgroundColor, &mut BorderColor), With<BigRedButton>>,
     ui_theme: Res<UiTheme>,
-) {
+  ) {
     // Get the components for only the Trigger's target entity
     if let Ok((mut bg, mut border)) = button_colors.get_mut(event.target()) {
       bg.0 = ui_theme.brb_hover_bg;
       border.0 = ui_theme.brb_hover_border;
     }
-}
+  }
 
-// TODO: Consolidate these with the help of a NewType enum and `trigger_map()`
+  // TODO: Consolidate these with the help of a NewType enum and `trigger_map()`
-// see: https://github.com/bevyengine/bevy/issues/14649
+  // see: https://github.com/bevyengine/bevy/issues/14649
 
-fn button_hover_stop(
+  fn button_hover_stop(
     event: Trigger<Pointer<Out>>,
-  mut button_colors: Query<(&mut BackgroundColor, &mut BorderColor), With<Button>>,
+    mut button_colors: Query<(&mut BackgroundColor, &mut BorderColor), With<BigRedButton>>,
     ui_theme: Res<UiTheme>,
-) {
+  ) {
     if let Ok((mut bg, mut border)) = button_colors.get_mut(event.target()) {
       bg.0 = ui_theme.brb_bg;
       border.0 = ui_theme.brb_border;
     }
-}
+  }
 
-fn button_press_start(
+  fn button_press_start(
     event: Trigger<Pointer<Pressed>>,
-  mut button_colors: Query<(&mut BackgroundColor, &mut BorderColor), With<Button>>,
+    mut button_colors: Query<(&mut BackgroundColor, &mut BorderColor), With<BigRedButton>>,
     ui_theme: Res<UiTheme>,
-) {
+  ) {
     if let Ok((mut bg, mut border)) = button_colors.get_mut(event.target()) {
       bg.0 = ui_theme.brb_pressed_bg;
       border.0 = ui_theme.brb_pressed_border;
     }
-}
+  }
 
-fn button_press_stop(
+  fn button_press_stop(
     event: Trigger<Pointer<Released>>,
-  mut button_colors: Query<(&mut BackgroundColor, &mut BorderColor), With<Button>>,
+    mut button_colors: Query<(&mut BackgroundColor, &mut BorderColor), With<BigRedButton>>,
     ui_theme: Res<UiTheme>,
-) {
+  ) {
     if let Ok((mut bg, mut border)) = button_colors.get_mut(event.target()) {
       bg.0 = ui_theme.brb_bg;
       border.0 = ui_theme.brb_border;
     }
+  }
+}
+
+/// Button marker for closing (despawning) an in-game menu entity.
+#[derive(Component)]
+#[require(Button)]
+pub struct CloseButton(Entity);
+
+impl CloseButton {
+  /// Default bundle for a panel's close button. Pass in the entity to despawn.
+  ///
+  /// TODO: Pass in the UiTheme struct
+  fn bundle(target: Entity) -> impl Bundle {
+    (
+      // TODO: Add `Button`? Remove `Button` from the BigRedButton bundle?
+      CloseButton(target),
+      Node {
+        width: Px(20.0),
+        height: Px(20.0),
+        aspect_ratio: Some(1.0),
+        align_items: AlignItems::Center,
+        justify_content: JustifyContent::Center,
+        border: UiRect::all(Px(1.0)),
+        ..Default::default()
+      },
+      // TODO: Get colors *somehow.*
+      // - Turn this function into a Bevy System, require `Res<...>`
+      // - Just pass in the colors, let the caller figure out sourcing them.
+      BackgroundColor(GRAY.into()),
+      BorderColor(DARK_GRAY.into()),
+      BorderRadius::all(Px(2.0)),
+      children![(
+        // TODO: Replace with an icon/sprite
+        Text::new("X"),
+        TextColor(BLACK.into()),
+      )],
+    )
+  }
+
+  fn hover_start(
+    event: Trigger<Pointer<Over>>,
+    // Get button background and border colors so we can change them.
+    // Filter for *changed* interactions, and only entities with a [`Button`]
+    mut button_colors: Query<(&mut BackgroundColor, &mut BorderColor), With<CloseButton>>,
+    ui_theme: Res<UiTheme>,
+  ) {
+    // Get the components for only the Trigger's target entity
+    if let Ok((mut bg, mut border)) = button_colors.get_mut(event.target()) {
+      bg.0 = ui_theme.quiet_hover_bg;
+      border.0 = ui_theme.quiet_hover_border;
+    }
+  }
+
+  fn hover_stop(
+    event: Trigger<Pointer<Out>>,
+    mut button_colors: Query<(&mut BackgroundColor, &mut BorderColor), With<CloseButton>>,
+    ui_theme: Res<UiTheme>,
+  ) {
+    if let Ok((mut bg, mut border)) = button_colors.get_mut(event.target()) {
+      bg.0 = ui_theme.quiet_bg;
+      border.0 = ui_theme.quiet_border;
+    }
+  }
+
+  fn press_start(
+    event: Trigger<Pointer<Pressed>>,
+    mut button_colors: Query<(&mut BackgroundColor, &mut BorderColor), With<CloseButton>>,
+    ui_theme: Res<UiTheme>,
+  ) {
+    if let Ok((mut bg, mut border)) = button_colors.get_mut(event.target()) {
+      bg.0 = ui_theme.quiet_pressed_bg;
+      border.0 = ui_theme.quiet_pressed_border;
+    }
+  }
+
+  fn press_stop(
+    event: Trigger<Pointer<Released>>,
+    mut commands: Commands,
+    mut button_colors: Query<(&mut BackgroundColor, &mut BorderColor, &CloseButton)>,
+    ui_theme: Res<UiTheme>,
+  ) {
+    if let Ok((mut bg, mut border, CloseButton(target))) = button_colors.get_mut(event.target()) {
+      bg.0 = ui_theme.quiet_bg;
+      border.0 = ui_theme.quiet_border;
+      commands.entity(*target).despawn();
+    }
+  }
 }