diff --git a/src/play.rs b/src/play.rs
index b914d91..a6cc659 100644
--- a/src/play.rs
+++ b/src/play.rs
@@ -1,7 +1,4 @@
-use bevy::{
-    animation::{AnimationTarget, AnimationTargetId},
-    prelude::*,
-};
+use bevy::{prelude::*, utils::RandomState};
 
 use crate::{deck::Card, menu::UiMessage, setup::AnimationStore, GameState};
 
@@ -12,7 +9,8 @@ impl Plugin for PlayPlugin {
         app.add_event::<ServeCards>()
             .add_observer(serve_cards)
             .add_systems(OnEnter(GameState::Main), deal_cards)
-            .add_systems(Update, deal_cards.run_if(set_added));
+            .add_systems(Update, deal_cards.run_if(set_added))
+            .add_systems(Update, delayed_animation);
     }
 }
 
@@ -40,35 +38,37 @@ pub(crate) fn toggle_selected(
     trigger: Trigger<Pointer<Click>>,
     mut commands: Commands,
     selections: Query<&Selected>,
-    mut query: Query<(&Name, &mut AnimationPlayer)>,
-    store: Res<AnimationStore>,
 ) {
     commands.trigger(UiMessage("".into()));
     let e = trigger.entity();
-    let (g, ai) = store.store.get("rotate".into()).unwrap();
-    let (n, mut ap) = query.get_mut(e).unwrap();
-    ap.stop_all();
     if selections.contains(e) {
         commands.entity(e).remove::<Selected>();
     } else {
-        ap.play(ai.clone()).repeat();
-        commands.entity(e).insert((
-            Selected,
-            g.clone(),
-            AnimationTarget {
-                id: AnimationTargetId::from_name(n),
-                player: e,
-            },
-        ));
+        commands.entity(e).insert(Selected);
     }
 }
 
-/// Observer system for resetting rotation when a card is de-selected
-pub(crate) fn reset_rotation(
+pub(crate) fn play_selected_animation(
+    trigger: Trigger<OnAdd, Selected>,
+    mut query: Query<&mut AnimationPlayer>,
+    store: Res<AnimationStore>,
+    mut commands: Commands,
+) {
+    let e = trigger.entity();
+    info!("Play selected animation {:?}", e);
+    let (g, ai) = store.store.get("rotate".into()).unwrap();
+    commands.entity(e).insert(g.clone());
+    query.get_mut(e).unwrap().play(ai.clone()).repeat();
+}
+
+pub(crate) fn stop_selected_animation(
     trigger: Trigger<OnRemove, Selected>,
-    mut transforms: Query<&mut Transform>,
+    mut query: Query<(&mut Transform, &mut AnimationPlayer)>,
 ) {
-    let mut t = transforms.get_mut(trigger.entity()).unwrap();
+    let e = trigger.entity();
+    info!("Stop selected animation {:?}", e);
+    let (mut t, mut ap) = query.get_mut(e).unwrap();
+    ap.stop_all();
     t.rotation = Quat::default();
 }
 
@@ -223,6 +223,12 @@ fn set_added(query: Query<Entity, Added<SetNumber>>) -> bool {
     !query.is_empty()
 }
 
+#[derive(Component)]
+struct DelayedAnimation {
+    graph: AnimationGraphHandle,
+    delay: Timer,
+}
+
 /// When a card is added to the board, place it on the screen
 pub(crate) fn place_card(
     trigger: Trigger<OnAdd, PlayLocation>,
@@ -235,6 +241,7 @@ pub(crate) fn place_card(
     )>,
     animation_store: Res<AnimationStore>,
     mut commands: Commands,
+    random_state: Local<RandomState>,
 ) {
     let (entity, play_location, mut visibility, name, mut player) =
         query.get_mut(trigger.entity()).unwrap();
@@ -246,18 +253,35 @@ pub(crate) fn place_card(
 
     player.play(animation_index.clone());
 
-    commands.entity(entity).insert((
-        graph_handle.clone(),
-        AnimationTarget {
-            id: AnimationTargetId::from_name(name),
-            player: entity,
-        },
-    ));
+    let delay = ((random_state.hash_one(entity) % 9) as f32 / 10.0) + 0.1;
+    info!("Delay: {:?}", delay);
+    commands.entity(entity).insert((DelayedAnimation {
+        graph: graph_handle.clone(),
+        delay: Timer::from_seconds(delay, TimerMode::Once),
+    },));
 
     // Set it to visible
     *visibility = Visibility::Inherited;
 }
 
+fn delayed_animation(
+    mut query: Query<(Entity, &mut DelayedAnimation)>,
+    mut commands: Commands,
+    time: Res<Time>,
+) {
+    query
+        .iter_mut()
+        .for_each(|(entity, mut delayed_animation)| {
+            delayed_animation.delay.tick(time.delta());
+            if delayed_animation.delay.just_finished() {
+                commands
+                    .entity(entity)
+                    .insert(delayed_animation.graph.clone())
+                    .remove::<DelayedAnimation>();
+            }
+        });
+}
+
 pub(crate) fn card_placement(PlayLocation { x, y }: &PlayLocation) -> Vec3 {
     let card_size = [100.0, 160.0];
     let offset = Vec2::new(card_size[0] * 4.0, card_size[1] * 4.0) / 2.5;
diff --git a/src/setup.rs b/src/setup.rs
index 44fda02..adb5059 100644
--- a/src/setup.rs
+++ b/src/setup.rs
@@ -2,7 +2,7 @@ use std::{f32::consts::PI, ops::RangeInclusive};
 
 use crate::{deck::*, *};
 use bevy::{
-    animation::{animated_field, AnimationTargetId},
+    animation::{animated_field, AnimationTarget, AnimationTargetId},
     prelude::*,
     utils::HashMap,
 };
@@ -59,19 +59,35 @@ pub(crate) fn setup_cards(mut commands: Commands, deck: Res<Deck>) {
                     let animation_player = AnimationPlayer::default();
 
                     let name = Name::new(format!("{}", this_card));
-                    parent
-                        .spawn((
-                            this_sprite,
-                            this_card,
-                            order,
-                            Visibility::Hidden,
-                            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 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,
                         ))
                         .observe(play::place_card)
                         .observe(debug::set_debug_card)
                         .observe(debug::hide_debug_card)
-                        .observe(play::reset_rotation)
+                        .observe(play::play_selected_animation)
+                        .observe(play::stop_selected_animation)
                         .observe(play::toggle_selected);
                 });
         });
@@ -95,18 +111,13 @@ fn setup_animations(
         targets.iter().for_each(|target| {
             let curve = AnimatableCurve::new(
                 animated_field!(Transform::rotation),
-                AnimatableKeyframeCurve::new(
-                    [0.0, 1.0, 2.0, 3.0, 4.0]
-                        .map(|i| i * 5.0) // TODO: Make this tuneable
-                        .into_iter()
-                        .zip([
-                            Quat::IDENTITY,
-                            Quat::from_axis_angle(Vec3::Z, PI / 2.),
-                            Quat::from_axis_angle(Vec3::Z, PI / 2. * 2.),
-                            Quat::from_axis_angle(Vec3::Z, PI / 2. * 3.),
-                            Quat::IDENTITY,
-                        ]),
-                )
+                AnimatableKeyframeCurve::new([0.0, 5.0, 10.0, 15.0, 20.0].into_iter().zip([
+                    Quat::IDENTITY,
+                    Quat::from_axis_angle(Vec3::Z, PI / 2.),
+                    Quat::from_axis_angle(Vec3::Z, PI / 2. * 2.),
+                    Quat::from_axis_angle(Vec3::Z, PI / 2. * 3.),
+                    Quat::IDENTITY,
+                ]))
                 .expect("Rotation animation"),
             );
             animation.add_curve_to_target(*target, curve);
@@ -125,7 +136,7 @@ fn setup_animations(
             RangeInclusive::<u8>::new(0, 3).for_each(|y| {
                 let a = Vec3::new(-400.0, -200.0, 0.0);
                 let b = play::card_placement(&play::PlayLocation { x, y });
-                let c = Vec3::new(-400.0, 200.0, 0.0);
+                let c = Vec3::new(400.0, -200.0, 0.0);
 
                 // Serve Deck -> Spot Animation
                 {