Not sure why play does not shuffle...

src/animation.rs

@@ -144,7 +144,7 @@ pub(crate) fn play_selected_animation(
     query
         .get_mut(trigger.entity())
         .unwrap()
-        .play(ai.clone())
+        .start(ai.clone())
         .repeat();
 }
 
@@ -153,7 +153,7 @@ pub(crate) fn stop_selected_animation(
     mut query: Query<(&mut Transform, &mut AnimationPlayer)>,
 ) {
     let (mut t, mut ap) = query.get_mut(trigger.entity()).unwrap();
-    ap.stop_all();
+    ap.rewind_all().stop_all();
     t.rotation = Quat::default();
 }
 
@@ -167,8 +167,7 @@ fn delayed_animation(
         .for_each(|(entity, mut delayed_animation, mut animation_player)| {
             delayed_animation.delay.tick(time.delta());
             if delayed_animation.delay.just_finished() {
-                info!("Playing delayed animation for {:?}", entity);
+                animation_player.start(delayed_animation.animation_index);
-                animation_player.play(delayed_animation.animation_index);
                 commands
                     .entity(entity)
                     .insert(delayed_animation.graph.clone())

src/deck.rs

@@ -1,4 +1,7 @@
-use bevy::{prelude::*, utils::HashMap};
+use bevy::{
+    prelude::*,
+    utils::{HashMap, RandomState},
+};
 
 /// Deck and Cards
 pub struct DeckPlugin;
@@ -48,22 +51,19 @@ impl Deck {
         Self::cards().into_iter()
     }
 
-    pub(crate) fn shuffled() -> Vec<Card> {
+    pub(crate) fn enumerated_shuffled() -> Vec<(usize, Card)> {
-        let mut base = Self::cards();
+        let mut base: Vec<(usize, Card)> = Self::iter_cards().enumerate().map(|x| x).collect();
-
         {
             use rand::seq::SliceRandom;
             use rand::thread_rng;
-
             let mut rng = thread_rng();
-
             base.as_mut_slice().shuffle(&mut rng);
         }
         base
     }
 
-    pub(crate) fn iter_shuffled() -> impl Iterator<Item = Card> {
+    pub(crate) fn iter_enumerated_shuffled() -> impl Iterator<Item = (usize, Card)> {
-        Deck::shuffled().into_iter()
+        Deck::enumerated_shuffled().into_iter()
     }
 }
 

src/play.rs

@@ -3,7 +3,7 @@ use bevy::{prelude::*, utils::RandomState};
 use crate::{
     animation::{AnimationStore, DelayedAnimation},
     deck::{Card, Deck},
-    menu::UiMessage,
+    menu::{SetCounter, UiMessage},
     setup::TopCard,
     view::ViewState,
     GameState,
@@ -15,7 +15,7 @@ impl Plugin for PlayPlugin {
     fn build(&self, app: &mut App) {
         app.add_event::<ServeCards>()
             .add_systems(Update, serve_cards)
-            .add_systems(OnEnter(GameState::NewGame), reset_game)
+            .add_systems(OnEnter(GameState::NewGame), (reset_game, reset_set_counter))
             .add_systems(OnEnter(ViewState::Play), deal_cards)
             .add_systems(Update, deal_cards.run_if(set_added));
     }
@@ -26,7 +26,7 @@ impl Plugin for PlayPlugin {
 pub(crate) struct Selected;
 
 /// Where in the deck a card is
-#[derive(Component, Clone, PartialEq)]
+#[derive(Component, Clone, PartialEq, Debug)]
 pub(crate) struct DeckOrder(pub u8);
 
 /// Where on the board/table/play-space a card is
@@ -213,14 +213,9 @@ fn serve_cards(
                     let candidate = in_deck
                         .iter()
                         .find(|(_entity, _deck_card, order)| order.0 == n as u8);
-                    n = n.saturating_sub(1);
-                    if n == 0 {
-                        **top_card = Visibility::Hidden;
-                    }
-
                     // If that search was fruitful, pull the card from the deck and play it
-                    if let Some((e, _, _)) = candidate {
+                    if let Some((e, card, order)) = candidate {
-                        info!("Inserting location ({},{}) for {}", this_x, this_y, e);
+                        info!("serving #{} {} to {:?}", order.0, card, (this_x, this_y));
                         commands
                             .entity(e)
                             .remove::<DeckOrder>()
@@ -229,6 +224,11 @@ fn serve_cards(
                                 y: this_y,
                             });
                     }
+
+                    n = n.saturating_sub(1);
+                    if n == 0 {
+                        **top_card = Visibility::Hidden;
+                    }
                 }
             }
         }
@@ -251,10 +251,11 @@ pub(crate) fn shuffle_card(
     mut query: Query<(&mut Transform, &mut Visibility, &mut AnimationPlayer)>,
 ) {
     {
-        let (mut t, mut _v, mut ap) = query.get_mut(trigger.entity()).unwrap();
+        let (mut t, mut v, mut ap) = query.get_mut(trigger.entity()).unwrap();
+        *v = Visibility::Hidden;
+        ap.rewind_all().stop_all();
         t.translation = Vec3::new(-400.0, -200.0, 0.0);
-        // *v = Visibility::Hidden;
+        t.rotation = Quat::IDENTITY;
-        ap.rewind_all();
     }
     commands
         .entity(trigger.entity())
@@ -282,8 +283,6 @@ pub(crate) fn place_card(
         .get(&format!("deck->{:?}", (play_location.x, play_location.y)))
         .unwrap();
 
-    info!("Placing card {:?} at {:?}", entity, play_location);
-
     let delay = ((random_state.hash_one(entity) % 9) as f32 / 10.0) + 0.1;
     commands.entity(entity).insert(DelayedAnimation {
         animation_index: animation_index.clone(),
@@ -372,9 +371,13 @@ fn reset_game(
     cards: Query<Entity, With<Card>>,
     mut commands: Commands,
 ) {
-    std::iter::zip(Deck::iter_shuffled().enumerate(), cards.iter()).for_each(|((i, _), entity)| {
+    std::iter::zip(Deck::iter_enumerated_shuffled(), cards.iter()).for_each(|((i, _), entity)| {
         commands.entity(entity).insert(DeckOrder(i as u8));
     });
     view_state.set(ViewState::Play);
     game_state.set(GameState::Main);
 }
+
+fn reset_set_counter(mut query: Query<&mut Text, With<SetCounter>>) {
+    query.single_mut().0 = "##".into();
+}

src/setup.rs

@@ -72,9 +72,8 @@ pub(crate) fn setup_cards(
                     TopCard,
                 ));
             }
-            Deck::iter_shuffled()
+
-                .enumerate()
+            Deck::iter_enumerated_shuffled().for_each(|(i, this_card)| {
-                .for_each(|(i, this_card)| {
                 let this = deck
                     .cards
                     .get(&this_card)
@@ -121,11 +120,14 @@ pub(crate) fn setup_cards(
                             ))
                             .observe(play::shuffle_card)
                             .observe(play::place_card)
-                                .observe(debug::set_debug_card)
-                                .observe(debug::hide_debug_card)
                             .observe(animation::play_selected_animation)
                             .observe(animation::stop_selected_animation)
                             .observe(play::toggle_selected);
+
+                        #[cfg(debug_assertions)]
+                        child
+                            .observe(debug::set_debug_card)
+                            .observe(debug::hide_debug_card);
                     });
             });
         });