From 9cb7043eed8b5cbed0c23d72e4a3a92c3ff9823d Mon Sep 17 00:00:00 2001
From: Elijah Voigt <elijah.caine.mv@gmail.com>
Date: Thu, 26 Oct 2023 21:48:33 -0700
Subject: [PATCH] Some improvements... 2d breaks when you select in 3d
 though...

---
 assets/models/Martian Chess.glb |  4 +--
 src/display2d.rs                | 56 ++++++++++++++++++---------------
 src/display3d.rs                | 56 ++++++++++++++++++++-------------
 src/game.rs                     |  9 ++++--
 4 files changed, 72 insertions(+), 53 deletions(-)

diff --git a/assets/models/Martian Chess.glb b/assets/models/Martian Chess.glb
index 85b072c..4f94fb4 100644
--- a/assets/models/Martian Chess.glb	
+++ b/assets/models/Martian Chess.glb	
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e48f65900648c1d5972aa14fea00f39e3cc7d4f8060df34d14f423cc621fc82e
-size 50950760
+oid sha256:3e69424bcc770fe206da12b2539a4a6f0d7dd2649e25e24fdcc5335d70666fa7
+size 29632044
diff --git a/src/display2d.rs b/src/display2d.rs
index af23a79..557a5d9 100644
--- a/src/display2d.rs
+++ b/src/display2d.rs
@@ -45,10 +45,10 @@ impl Plugin for Display2dPlugin {
                         .run_if(any_component_removed::<game::Selected>()),
                     update_background.run_if(on_event::<WindowResized>()),
                     set_transform
-                        .after(game::update_board::<Piece2d>)
+                        .after(game::update_board::<Display2d>)
                         .run_if(any_component_changed::<BoardIndex>),
                     set_piece_sprite.run_if(any_component_changed::<Side>),
-                    set_tile_sprite.run_if(any_component_added::<Tile>),
+                    set_tile_sprite.run_if(any_component_added::<game::Tile>),
                 ),
             )
             .add_systems(OnEnter(GameState::Display2d), activate::<Display2d>)
@@ -64,14 +64,7 @@ struct SpriteSheet {
 
 /// Marker component for the 2d entitys
 #[derive(Debug, Component)]
-struct Display2d;
-
-/// Marker for 2d piece entities
-#[derive(Debug, Component)]
-pub(crate) struct Piece2d;
-
-#[derive(Debug, Component)]
-struct Tile2d;
+pub(crate) struct Display2d;
 
 #[derive(Debug, Component)]
 struct BackgroundImage;
@@ -117,6 +110,7 @@ fn set_background(
 ) {
     commands.spawn((
         BackgroundImage,
+        Display2d,
         SpriteBundle {
             texture: server.load("images/mars-daybreak.png"),
             sprite: Sprite {
@@ -172,7 +166,7 @@ fn initialize_board(board: Option<Res<Board>>, mut commands: Commands) {
                     let s = (x % 2) ^ (y % 2);
                     let tile = if s == 0 { Tile::Dark } else { Tile::Light };
 
-                    parent.spawn((tile, index, Tile2d, SpriteSheetBundle { ..default() }));
+                    parent.spawn((tile, index, Display2d, SpriteSheetBundle { ..default() }));
                 }
 
                 // Spawn pieces
@@ -181,7 +175,7 @@ fn initialize_board(board: Option<Res<Board>>, mut commands: Commands) {
 
                     parent.spawn((
                         piece.clone(),
-                        Piece2d,
+                        Display2d,
                         index.clone(),
                         side,
                         SpriteSheetBundle { ..default() },
@@ -199,7 +193,7 @@ fn set_piece_sprite(
             &Piece,
             &Side,
         ),
-        Or<(Added<Piece>, Changed<Side>)>,
+        (With<Display2d>, Or<(Added<Piece>, Changed<Side>)>),
     >,
     sprite_sheet: Option<Res<SpriteSheet>>,
 ) {
@@ -226,7 +220,10 @@ fn set_piece_sprite(
 }
 
 fn set_tile_sprite(
-    mut events: Query<(&mut TextureAtlasSprite, &mut Handle<TextureAtlas>, &Tile), Added<Tile2d>>,
+    mut events: Query<
+        (&mut TextureAtlasSprite, &mut Handle<TextureAtlas>, &Tile),
+        (Added<game::Tile>, With<Display2d>),
+    >,
     sprite_sheet: Option<Res<SpriteSheet>>,
 ) {
     if let Some(sprite_sheet) = sprite_sheet {
@@ -248,7 +245,7 @@ fn set_transform(
     mut events: Query<
         (&mut Transform, &BoardIndex),
         (
-            Or<(With<Piece2d>, With<Tile2d>)>,
+            With<Display2d>,
             Or<(Changed<BoardIndex>, Added<BoardIndex>)>,
         ),
     >,
@@ -309,7 +306,7 @@ fn active_tile(
 
 fn select_piece(
     mut events: EventReader<MouseButtonInput>,
-    pieces: Query<(Entity, &BoardIndex), With<Piece2d>>,
+    pieces: Query<(Entity, &BoardIndex), (With<game::Piece>, With<Display2d>)>,
     active: Res<ActiveTile>,
     mut commands: Commands,
     mut writer: EventWriter<game::GameEvent>,
@@ -334,7 +331,7 @@ fn select_piece(
 
 fn move_piece(
     window: Query<&Window, With<PrimaryWindow>>,
-    mut query: Query<&mut Transform, (With<game::Selected>, With<Piece2d>)>,
+    mut query: Query<&mut Transform, (With<game::Selected>, With<game::Piece>, With<Display2d>)>,
     camera_query: Query<(&Camera, &GlobalTransform), With<Display2d>>,
 ) {
     query.iter_mut().for_each(|mut t| {
@@ -355,8 +352,11 @@ fn move_piece(
 ///
 fn place_piece(
     mut events: EventReader<MouseButtonInput>,
-    current: Query<(Entity, &BoardIndex), (With<game::Selected>, With<Piece2d>)>,
-    pieces: Query<&BoardIndex, (Without<game::Selected>, With<Piece2d>)>,
+    current: Query<
+        (Entity, &BoardIndex),
+        (With<game::Selected>, With<game::Piece>, With<Display2d>),
+    >,
+    pieces: Query<&BoardIndex, (Without<game::Selected>, With<game::Piece>, With<Display2d>)>,
     active: Res<ActiveTile>,
     mut board: ResMut<Board>,
     mut commands: Commands,
@@ -373,11 +373,15 @@ fn place_piece(
             }
         })
         .filter_map(|idx| {
-            (!pieces.iter().any(|board_index| board_index == idx)).then_some((
-                current.single().0,
-                current.single().1,
-                idx,
-            ))
+            if !current.is_empty() {
+                (!pieces.iter().any(|board_index| board_index == idx)).then_some((
+                    current.single().0,
+                    current.single().1,
+                    idx,
+                ))
+            } else {
+                None
+            }
         })
         .for_each(|(entity, from, to)| match board.move_piece(from, to) {
             Ok(moves) => {
@@ -395,7 +399,7 @@ fn place_piece(
 
 fn cancel_place(
     mut events: EventReader<MouseButtonInput>,
-    current: Query<Entity, (With<game::Selected>, With<Piece2d>)>,
+    current: Query<Entity, (With<game::Selected>, With<game::Piece>, With<Display2d>)>,
     mut commands: Commands,
     mut writer: EventWriter<game::GameEvent>,
 ) {
@@ -414,7 +418,7 @@ fn cancel_place(
 
 fn snap_back_cancel(
     mut events: RemovedComponents<game::Selected>,
-    query: Query<&game::BoardIndex, With<Piece2d>>,
+    query: Query<&game::BoardIndex, (With<game::Piece>, With<Display2d>)>,
     mut move_events: EventWriter<game::Move>,
 ) {
     events.iter().for_each(|entity| {
diff --git a/src/display3d.rs b/src/display3d.rs
index 81bd2f9..7846970 100644
--- a/src/display3d.rs
+++ b/src/display3d.rs
@@ -22,8 +22,8 @@ impl Plugin for Display3dPlugin {
                 Update,
                 (
                     menu::exit_to_menu.run_if(in_state(GameState::Display3d)),
-                    set_piece_model.run_if(any_component_added::<Piece3d>),
-                    set_board_model.run_if(any_component_added::<Board3d>),
+                    set_piece_model.run_if(any_component_added::<Piece>),
+                    set_board_model.run_if(any_component_added::<game::BoardComponent>),
                     set_piece_position.run_if(any_component_changed::<BoardIndex>),
                     set_piece_texture.run_if(any_component_changed::<Side>),
                     select_3d
@@ -54,13 +54,7 @@ impl Plugin for Display3dPlugin {
 }
 
 #[derive(Debug, Component)]
-struct Display3d;
-
-#[derive(Debug, Component)]
-pub(crate) struct Piece3d;
-
-#[derive(Debug, Component)]
-pub(crate) struct Board3d;
+pub(crate) struct Display3d;
 
 #[derive(Debug, Resource)]
 struct AssetsMap {
@@ -127,14 +121,14 @@ fn initialize(mut commands: Commands, board: Res<game::Board>, assets: Res<Asset
 
             info!("Intializing 3D Board!");
             parent
-                .spawn((Display3d, Board3d, SceneBundle { ..default() }))
+                .spawn((Display3d, game::BoardComponent, SceneBundle { ..default() }))
                 .with_children(|parent| {
                     board.pieces().iter().for_each(|(index, piece)| {
                         let side = Board::side(index).expect("Spawn valid side");
 
                         parent.spawn((
                             side,
-                            Piece3d,
+                            Display3d,
                             piece.clone(),
                             index.clone(),
                             SceneBundle { ..default() },
@@ -162,7 +156,7 @@ fn fix_skybox(mut images: ResMut<Assets<Image>>, assets: Res<AssetsMap>) {
 
 /// Set the model for each piece based on the game::Piece::* marker
 fn set_piece_model(
-    mut events: Query<(&mut Handle<Scene>, &Piece), Added<Piece3d>>,
+    mut events: Query<(&mut Handle<Scene>, &Piece), (Added<game::Piece>, With<Display3d>)>,
     assets_map: Res<AssetsMap>,
     gltfs: Res<Assets<Gltf>>,
 ) {
@@ -179,7 +173,7 @@ fn set_piece_model(
 }
 
 fn set_board_model(
-    mut events: Query<&mut Handle<Scene>, With<Board3d>>,
+    mut events: Query<&mut Handle<Scene>, (With<game::BoardComponent>, With<Display3d>)>,
     assets_map: Res<AssetsMap>,
     gltfs: Res<Assets<Gltf>>,
 ) {
@@ -195,7 +189,10 @@ fn set_board_model(
 
 /// Sets a piece location given it's board index
 fn set_piece_position(
-    mut events: Query<(&mut Transform, &BoardIndex), (With<Piece3d>, Changed<BoardIndex>)>,
+    mut events: Query<
+        (&mut Transform, &BoardIndex),
+        (With<game::Piece>, With<Display3d>, Changed<BoardIndex>),
+    >,
 ) {
     events.iter_mut().for_each(|(mut t, i)| {
         t.translation = board_translation(i);
@@ -267,8 +264,8 @@ fn mouse_zoom(
 /// PERF: We are saving what to work on in a Vector which is bad.
 /// CAVEAT: We are only exeucting this when a piece changes or state is changed.
 fn set_piece_texture(
-    events: Query<(Entity, &Piece, &Side), (With<Piece3d>, Changed<Side>)>,
-    all: Query<(Entity, &Piece, &Side), With<Piece3d>>,
+    events: Query<(Entity, &Piece, &Side), (With<game::Piece>, With<Display3d>, Changed<Side>)>,
+    all: Query<(Entity, &Piece, &Side), (With<game::Piece>, With<Display3d>)>,
     gltfs: Res<Assets<Gltf>>,
     assets_map: Res<AssetsMap>,
     children: Query<&Children>,
@@ -377,16 +374,17 @@ fn set_piece_texture(
 }
 
 /// Function for selecting entities based on ray intersection
+/// There is a bug where we are selecting multiple entities...
 fn select_3d(
     mut events: EventReader<MouseButtonInput>,
     query: Query<(Entity, &Handle<Mesh>, &GlobalTransform)>,
     meshes: Res<Assets<Mesh>>,
-    cameras: Query<(&Camera, &GlobalTransform)>,
+    cameras: Query<(&Camera, &GlobalTransform), With<Display3d>>,
     windows: Query<&Window, With<PrimaryWindow>>,
-    parents: Query<Entity, (With<Piece3d>, Without<game::Selected>)>,
+    parents: Query<Entity, (With<game::Piece>, With<Display3d>)>,
     children: Query<&Children>,
     mut commands: Commands,
-    selected: Query<Entity, (With<game::Selected>, With<Piece3d>)>,
+    selected: Query<Entity, (With<game::Selected>, With<game::Piece>, With<Display3d>)>,
 ) {
     events
         .iter()
@@ -412,9 +410,12 @@ fn select_3d(
                                             })
                                             .iter()
                                             .for_each(|&parent| {
-                                                // TODO: Only remove/insert component if different
                                                 selected.iter().for_each(|s| {
-                                                    commands.entity(s).remove::<game::Selected>();
+                                                    if s != parent {
+                                                        commands
+                                                            .entity(s)
+                                                            .remove::<game::Selected>();
+                                                    }
                                                 });
                                                 commands.entity(parent).insert(game::Selected);
                                             });
@@ -431,10 +432,21 @@ fn select_3d(
 }
 
 fn selected_gizmo(
-    selected: Query<&Transform, (With<game::Selected>, With<Piece3d>)>,
+    selected: Query<&Transform, (With<game::Selected>, With<game::Piece>, With<Display3d>)>,
     mut gizmos: Gizmos,
 ) {
     selected.iter().for_each(|transform| {
         gizmos.cuboid(transform.clone(), Color::GREEN);
     })
 }
+
+// Animations
+// * QueenPickup
+// * QueenPutDown
+// * QueenIdle
+// * DronePickup
+// * DronePutDown
+// * DroneIdle
+// * PawnPickup
+// * PawnPutDown
+// * PawnIdle
diff --git a/src/game.rs b/src/game.rs
index 9d5afb6..da1d8b0 100644
--- a/src/game.rs
+++ b/src/game.rs
@@ -11,8 +11,8 @@ impl Plugin for GamePlugin {
             .add_systems(
                 Update,
                 (
-                    update_board::<display2d::Piece2d>.run_if(on_event::<Move>()),
-                    update_board::<display3d::Piece3d>.run_if(on_event::<Move>()),
+                    update_board::<display2d::Display2d>.run_if(on_event::<Move>()),
+                    update_board::<display3d::Display3d>.run_if(on_event::<Move>()),
                     set_side.run_if(on_event::<Move>()), // TODO: correct run_if?
                 ),
             )
@@ -39,6 +39,9 @@ pub(crate) enum Tile {
     Light,
 }
 
+#[derive(Debug, Component)]
+pub(crate) struct BoardComponent;
+
 // manually for the type.
 impl std::fmt::Display for Piece {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -266,7 +269,7 @@ fn debug_board(board: Res<Board>, mut debug_info: ResMut<debug::DebugInfo>) {
 /// Only update the tiles without a corresponding board piece
 pub(crate) fn update_board<T: Component>(
     mut events: EventReader<Move>,
-    mut pieces: Query<(Entity, &mut BoardIndex), With<T>>,
+    mut pieces: Query<(Entity, &mut BoardIndex), (With<Piece>, With<T>)>,
     mut commands: Commands,
 ) {
     events.iter().for_each(|Move { from, to, .. }| {