update input system

Author: feschber

solitaire-game/src/animation.rs

@@ -4,8 +4,8 @@ use bevy::{
 };
 
 use crate::{
-    PegMoved, Selected,
-    board::{BoardPosition, PEG_POS, PEG_POS_RAISED},
+    Selected,
+    board::{BoardPosition, PEG_POS, PEG_POS_RAISED, Peg},
     viewport_to_world,
 };
 
@@ -16,27 +16,13 @@ pub struct PegAnimation;
 impl Plugin for PegAnimation {
     fn build(&self, app: &mut App) {
         app.add_systems(Update, snap_to_board_grid);
-        app.add_systems(PreUpdate, follow_mouse);
-        app.add_observer(on_peg_move);
+        app.add_systems(Update, follow_mouse);
     }
 }
 
-#[derive(Component)]
-struct SnapToBoardPosition;
-
-fn on_peg_move(
-    moved: On<PegMoved>,
-    mut commands: Commands,
-    mut request_redraw: MessageWriter<RequestRedraw>,
-) {
-    commands.entity(moved.peg).insert(SnapToBoardPosition);
-    request_redraw.write(RequestRedraw);
-}
-
 fn snap_to_board_grid(
-    mut commands: Commands,
-    pegs: Query<Entity, With<SnapToBoardPosition>>,
-    mut pos: Query<(&BoardPosition, &mut Transform), With<SnapToBoardPosition>>,
+    pegs: Query<Entity, (With<Peg>, Without<Selected>)>,
+    mut pos: Query<(&BoardPosition, &mut Transform)>,
     mut request_redraw: MessageWriter<RequestRedraw>,
 ) {
     for peg in pegs {
@@ -46,10 +32,11 @@ fn snap_to_board_grid(
             let mut new_pos = current.lerp(target, 0.2);
             if new_pos.distance_squared(target) < 0.0001 {
                 new_pos = target;
-                commands.entity(peg).remove::<SnapToBoardPosition>();
             }
             transform.translation = new_pos;
-            request_redraw.write(RequestRedraw);
+            if current != new_pos {
+                request_redraw.write(RequestRedraw);
+            }
         }
     }
 }

solitaire-game/src/board.rs

@@ -2,7 +2,7 @@ use bevy::{ecs::entity_disabling::Disabled, prelude::*};
 use bevy_vector_shapes::{prelude::ShapePainter, shapes::DiscPainter};
 use solitaire_solver::{Board, Idx};
 
-use crate::{CurrentBoard, MoveEvent, PegMoved, input::RequestPegMove};
+use crate::{CurrentBoard, MoveEvent, input::RequestPegMove};
 
 pub struct BoardPlugin;
 
@@ -226,5 +226,4 @@ fn on_move_peg(
         moved,
         skipped,
     });
-    commands.trigger(PegMoved { peg: moved });
 }

solitaire-game/src/input.rs

@@ -1,7 +1,12 @@
-use bevy::{input::common_conditions::input_just_pressed, prelude::*, window::PrimaryWindow};
+use bevy::{
+    input::common_conditions::{input_just_pressed, input_just_released},
+    prelude::*,
+    window::PrimaryWindow,
+};
+use solitaire_solver::Board;
 
 use crate::{
-    PegMoved, Selected,
+    Selected,
     board::{BoardPosition, Peg},
     viewport_to_world,
 };
@@ -13,10 +18,13 @@ impl Plugin for Input {
     fn build(&self, app: &mut App) {
         app.add_systems(
             PreUpdate,
-            peg_selection_cursor.run_if(input_just_pressed(MouseButton::Left)),
+            grab_peg.run_if(input_just_pressed(MouseButton::Left)),
+        );
+        app.add_systems(
+            PreUpdate,
+            release_peg.run_if(input_just_released(MouseButton::Left)),
         );
         app.add_systems(PreUpdate, peg_selection_touch);
-        app.add_observer(on_board_clicked);
     }
 }
 
@@ -26,83 +34,74 @@ pub struct RequestPegMove {
     pub dst: BoardPosition,
 }
 
-#[derive(Resource)]
-struct SelectedPos(BoardPosition);
-
-#[derive(Event)]
-struct PosClicked(BoardPosition);
-
-fn on_board_clicked(
-    clicked_pos: On<PosClicked>,
+fn grab_peg(
     mut commands: Commands,
-    selected_pos: Option<ResMut<SelectedPos>>,
+    window: Single<&Window, With<PrimaryWindow>>,
+    camera_query: Single<(&Camera, &GlobalTransform)>,
     pegs: Query<(Entity, &BoardPosition), With<Peg>>,
 ) {
-    let clicked = pegs.iter().find(|(_, p)| **p == clicked_pos.0);
-    let selected =
-        selected_pos.map(|selected_pos| pegs.iter().find(|(_, p)| **p == selected_pos.0).unwrap());
-
-    match (selected, clicked) {
-        (None, Some((clicked, clicked_pos))) => {
-            commands.insert_resource(SelectedPos(*clicked_pos));
-            commands.entity(clicked).insert(Selected);
-        }
-        (Some((selected, selected_pos)), clicked) => {
-            commands.entity(selected).remove::<Selected>();
-            commands.remove_resource::<SelectedPos>();
-            commands.trigger(PegMoved { peg: selected }); // snap back
-            if let Some((clicked, clicked_pos)) = clicked {
-                if selected != clicked {
-                    commands.insert_resource(SelectedPos(*clicked_pos));
-                    commands.entity(clicked).insert(Selected);
+    let (camera, camera_transform) = *camera_query;
+    if let Some(cursor_pos) = window.cursor_position() {
+        if let Some(world_pos_cursor) = viewport_to_world(cursor_pos, camera, camera_transform) {
+            let board_pos = BoardPosition::from_world_space(world_pos_cursor.xy());
+            if Board::inbounds(board_pos.into()) {
+                if let Some(peg) = pegs.iter().find(|(_, p)| **p == board_pos).map(|(p, _)| p) {
+                    commands.entity(peg).insert(Selected);
                 }
-            } else {
-                commands.trigger(RequestPegMove {
-                    src: *selected_pos,
-                    dst: clicked_pos.0,
-                });
             }
-        }
-        _ => {}
+        };
     }
 }
 
-fn peg_selection_cursor(
+fn release_peg(
     mut commands: Commands,
     window: Single<&Window, With<PrimaryWindow>>,
     camera_query: Single<(&Camera, &GlobalTransform)>,
+    selected_pegs: Query<(Entity, &BoardPosition), (With<Peg>, With<Selected>)>,
 ) {
+    let (camera, camera_transform) = *camera_query;
     if let Some(cursor_pos) = window.cursor_position() {
-        let (camera, camera_transform) = *camera_query;
-        let Some(world_pos_cursor) = viewport_to_world(cursor_pos, camera, camera_transform) else {
-            return;
+        if let Some(world_pos_cursor) = viewport_to_world(cursor_pos, camera, camera_transform) {
+            let board_pos = BoardPosition::from_world_space(world_pos_cursor.xy());
+            for (selected_peg, &current_pos) in selected_pegs {
+                commands.entity(selected_peg).remove::<Selected>();
+                commands.trigger(RequestPegMove {
+                    src: current_pos,
+                    dst: board_pos,
+                });
+            }
         };
-        let board_pos = BoardPosition::from_world_space(world_pos_cursor.xy());
-        commands.trigger(PosClicked(board_pos));
     }
 }
 
-#[derive(Resource, PartialEq, Eq)]
-struct CurrentTouchId(u64);
-
 fn peg_selection_touch(
     mut commands: Commands,
     touches: Res<Touches>,
     camera_query: Single<(&Camera, &GlobalTransform)>,
-    current_touch_id: Option<Res<CurrentTouchId>>,
+    pegs: Query<(Entity, &BoardPosition), With<Peg>>,
+    selected_pegs: Query<(Entity, &BoardPosition), (With<Peg>, With<Selected>)>,
 ) {
-    for touch in touches.iter() {
-        if touches.just_pressed(touch.id())
-            || Some(touch.id()) != current_touch_id.as_ref().map(|id| id.0)
-        {
-            let (camera, camera_transform) = *camera_query;
-            let Some(world_pos) = viewport_to_world(touch.position(), camera, camera_transform)
-            else {
-                return;
-            };
+    let (camera, camera_transform) = *camera_query;
+    for touch in touches.iter_just_pressed() {
+        if let Some(world_pos) = viewport_to_world(touch.position(), camera, camera_transform) {
+            let board_pos = BoardPosition::from_world_space(world_pos.xy());
+            if Board::inbounds(board_pos.into()) {
+                if let Some(peg) = pegs.iter().find(|(_, p)| **p == board_pos).map(|(p, _)| p) {
+                    commands.entity(peg).insert(Selected);
+                }
+            }
+        }
+    }
+    for touch in touches.iter_just_released() {
+        if let Some(world_pos) = viewport_to_world(touch.position(), camera, camera_transform) {
             let board_pos = BoardPosition::from_world_space(world_pos.xy());
-            commands.trigger(PosClicked(board_pos));
+            for (selected_peg, &current_pos) in selected_pegs {
+                commands.entity(selected_peg).remove::<Selected>();
+                commands.trigger(RequestPegMove {
+                    src: current_pos,
+                    dst: board_pos,
+                });
+            }
         }
-        commands.insert_resource(CurrentTouchId(touch.id()));
     }
 }