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,62 +72,64 @@ pub(crate) fn setup_cards(
                     TopCard,
                 ));
             }
-            Deck::iter_shuffled()
-                .enumerate()
-                .for_each(|(i, this_card)| {
-                    let this = deck
-                        .cards
-                        .get(&this_card)
-                        .unwrap_or_else(|| panic!("fech card sprite {:?}", this_card))
-                        .clone();
-                    let this_sprite = Sprite {
-                        custom_size: Some(Vec2::new(80.0, 128.0)),
-                        ..this.clone()
-                    };
-                    let order = play::DeckOrder(i as u8);
 
-                    let animation_player = AnimationPlayer::default();
+            Deck::iter_enumerated_shuffled().for_each(|(i, this_card)| {
+                let this = deck
+                    .cards
+                    .get(&this_card)
+                    .unwrap_or_else(|| panic!("fech card sprite {:?}", this_card))
+                    .clone();
+                let this_sprite = Sprite {
+                    custom_size: Some(Vec2::new(80.0, 128.0)),
+                    ..this.clone()
+                };
+                let order = play::DeckOrder(i as u8);
+
+                let animation_player = AnimationPlayer::default();
+
+                let name = Name::new(format!("{}", this_card));
 
-                    let name = Name::new(format!("{}", this_card));
+                let animation_target_id = AnimationTargetId::from_name(&name);
 
-                    let animation_target_id = AnimationTargetId::from_name(&name);
+                let this_transform =
+                    Transform::default().with_translation(Vec3::new(-400.0, -200.0, 0.0));
+                let visibility = Visibility::Hidden;
 
-                    let this_transform =
+                // Spawn card with a simple Transform parent so we can adjust the Z-axis for
-                        Transform::default().with_translation(Vec3::new(-400.0, -200.0, 0.0));
+                // card ordering
-                    let visibility = Visibility::Hidden;
+                parent
+                    .spawn((Transform::default(), Visibility::Inherited))
+                    .with_children(|parent| {
+                        let mut child = parent.spawn_empty();
+                        let entity_id = child.id();
+                        let animation_target = AnimationTarget {
+                            id: animation_target_id,
+                            player: entity_id,
+                        };
+                        child
+                            .insert((
+                                animation_player,
+                                animation_target,
+                                name,
+                                order,
+                                this_card,
+                                this_sprite,
+                                this_transform,
+                                visibility,
+                                animation_store.graph.clone(),
+                            ))
+                            .observe(play::shuffle_card)
+                            .observe(play::place_card)
+                            .observe(animation::play_selected_animation)
+                            .observe(animation::stop_selected_animation)
+                            .observe(play::toggle_selected);
 
-                    // Spawn card with a simple Transform parent so we can adjust the Z-axis for
+                        #[cfg(debug_assertions)]
-                    // card ordering
+                        child
-                    parent
+                            .observe(debug::set_debug_card)
-                        .spawn((Transform::default(), Visibility::Inherited))
+                            .observe(debug::hide_debug_card);
-                        .with_children(|parent| {
+                    });
-                            let mut child = parent.spawn_empty();
+            });
-                            let entity_id = child.id();
-                            let animation_target = AnimationTarget {
-                                id: animation_target_id,
-                                player: entity_id,
-                            };
-                            child
-                                .insert((
-                                    animation_player,
-                                    animation_target,
-                                    name,
-                                    order,
-                                    this_card,
-                                    this_sprite,
-                                    this_transform,
-                                    visibility,
-                                    animation_store.graph.clone(),
-                                ))
-                                .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);
-                        });
-                });
         });
 }