From a4e280904e470af98959a6daddf89ff142141b67 Mon Sep 17 00:00:00 2001
From: alex <spamulo@gmail.com>
Date: Sat, 4 Jun 2022 18:20:37 +0100
Subject: [PATCH 01/11] flappy bevy example

birds sometimes fall out of the sky
---
 Cargo.toml                    |   4 +
 examples/games/flappy_bevy.rs | 278 ++++++++++++++++++++++++++++++++++
 2 files changed, 282 insertions(+)
 create mode 100644 examples/games/flappy_bevy.rs

diff --git a/Cargo.toml b/Cargo.toml
index 999157fea460d..4e6d7f17f6851 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -432,6 +432,10 @@ path = "examples/games/breakout.rs"
 name = "contributors"
 path = "examples/games/contributors.rs"
 
+[[example]]
+name = "flappy_bevy"
+path = "examples/games/flappy_bevy.rs"
+
 [[example]]
 name = "game_menu"
 path = "examples/games/game_menu.rs"
diff --git a/examples/games/flappy_bevy.rs b/examples/games/flappy_bevy.rs
new file mode 100644
index 0000000000000..b5b25625b86d9
--- /dev/null
+++ b/examples/games/flappy_bevy.rs
@@ -0,0 +1,278 @@
+//! A simplified Flappy Bird but with many birds
+
+use bevy::prelude::*;
+
+use bevy::sprite::collide_aabb::collide;
+use bevy::window::PresentMode;
+
+use rand::Rng;
+
+const CHUNK_SIZE: f32 = 300.0;
+const CAMERA_SPEED: f32 = 120.0;
+const GAME_HEIGHT: f32 = 500.0;
+const SCREEN_HEIGHT: f32 = 1500.0;
+const CLEANUP_X_DIST: f32 = 1500.0;
+const CHAOS_AMOUNT_X: f32 = 250.0;
+const CHAOS_AMOUNT_Y: f32 = 600.0;
+const DRIFT_TO_CENTER_AMOUNT: f32 = 0.01;
+const FLAP_STRENGTH: f32 = 250.0;
+const BIRD_SIZE: f32 = 24.0;
+const BIRD_REPRODUCTION_CHANCE: f32 = 1.0;
+const MAX_BIRDS: usize = 500;
+const GRAVITY: f32 = 400.0;
+
+fn randf() -> f32 {
+    rand::thread_rng().gen::<f32>()
+}
+
+pub fn main() {
+    let mut app = App::new();
+
+    app.insert_resource(WindowDescriptor {
+        width: 1600.,
+        height: 900.,
+        title: "Flappy Bevy".to_string(),
+        present_mode: PresentMode::Immediate, // smooth but power hungry
+        resizable: true,
+        ..Default::default()
+    })
+    .add_plugins(DefaultPlugins)
+    .add_startup_system(spawn_camera)
+    .add_startup_system(load_art)
+    .add_startup_system(bird_startup)
+    .add_system(spawn_bird)
+    .add_system(bird_collision)
+    .add_system(bird_reproduction)
+    .add_system(bird_control.after(gravity))
+    .add_system(terrain_gen)
+    .add_system(advance_camera)
+    .add_system(chaos)
+    .add_system(velocity)
+    .add_system(gravity)
+    .add_system(terrain_cleanup)
+    .add_system(drift_to_center)
+    .add_event::<GenerateChunk>()
+    .add_event::<SpawnBird>();
+
+    app.run()
+}
+
+pub struct Art {
+    bird_icon: Handle<Image>,
+}
+
+fn load_art(mut commands: Commands, asset_server: Res<AssetServer>) {
+    commands.insert_resource(Art {
+        bird_icon: asset_server.load("branding/icon.png"),
+    });
+}
+struct GenerateChunk {
+    new_chunk_index: i32,
+}
+
+fn advance_camera(
+    mut q: Query<&mut Transform, With<Camera>>,
+    time: Res<Time>,
+    mut outgoing_generate_chunk_events: EventWriter<GenerateChunk>,
+) {
+    if let Ok(mut transform) = q.get_single_mut() {
+        let chunk_index = (transform.translation.x / CHUNK_SIZE).floor() as i32;
+        transform.translation.x += time.delta().as_secs_f32() * CAMERA_SPEED;
+        let new_chunk_index = (transform.translation.x / CHUNK_SIZE).floor() as i32;
+        if chunk_index != new_chunk_index {
+            outgoing_generate_chunk_events.send(GenerateChunk {
+                new_chunk_index: new_chunk_index + 3,
+            });
+        }
+    }
+}
+
+#[derive(Component)]
+struct Obstacle;
+
+fn terrain_cleanup(
+    mut commands: Commands,
+    q: Query<(Entity, &Transform), With<Obstacle>>,
+    cam: Query<&Transform, With<Camera>>,
+) {
+    let cam_x = cam.single().translation.x;
+    for (e, t) in q.iter() {
+        if t.translation.x < cam_x - CLEANUP_X_DIST {
+            commands.entity(e).despawn();
+        }
+    }
+}
+
+fn terrain_gen(
+    mut commands: Commands,
+    mut incoming_generate_chunk_events: EventReader<GenerateChunk>,
+) {
+    for ev in incoming_generate_chunk_events.iter() {
+        let x_pos = CHUNK_SIZE * ev.new_chunk_index as f32;
+        // generate some terrain within x_pos..x_pos+width
+        let gap_y_pos = GAME_HEIGHT * (randf() - 0.5);
+        let pillar_width = 50.0 + 110.0 * randf();
+        // make the gap no narrower than the pillar is wide
+        let gap_size = (50.0 + 250.0 * randf()).max(pillar_width);
+        for (top_y_pos, bottom_y_pos) in [
+            (-SCREEN_HEIGHT * 0.5, gap_y_pos - gap_size * 0.5),
+            (gap_y_pos + gap_size * 0.5, SCREEN_HEIGHT * 0.5),
+        ] {
+            let pillar_origin = Vec2::new(x_pos, (top_y_pos + bottom_y_pos) * 0.5);
+            let pillar_size = Vec2::new(pillar_width, bottom_y_pos - top_y_pos);
+            commands
+                .spawn_bundle(SpriteBundle {
+                    sprite: Sprite {
+                        color: Color::rgb(0.25, 0.25, 0.75),
+                        custom_size: Some(pillar_size),
+                        ..default()
+                    },
+                    transform: Transform::from_translation(pillar_origin.extend(0.0)),
+                    ..default()
+                })
+                .insert(Obstacle);
+        }
+    }
+}
+
+fn spawn_camera(mut commands: Commands) {
+    commands.spawn_bundle(Camera2dBundle::default());
+}
+
+#[derive(Component, Default)]
+struct Velocity {
+    velocity: Vec2,
+}
+
+#[derive(Component)]
+struct Chaos;
+
+#[derive(Component)]
+struct Gravity;
+
+#[derive(Component)]
+struct Bird;
+
+#[derive(Component)]
+struct DriftToCenter;
+
+struct SpawnBird {
+    new_bird_pos: Vec2,
+    new_bird_velocity: Vec2,
+}
+
+fn bird_startup(mut spawn_bird_events: EventWriter<SpawnBird>) {
+    spawn_bird_events.send(SpawnBird {
+        new_bird_pos: Vec2::ZERO,
+        new_bird_velocity: Vec2::new(CAMERA_SPEED, 0.0),
+    });
+}
+
+fn spawn_bird(
+    mut commands: Commands,
+    mut spawn_bird_events: EventReader<SpawnBird>,
+    art: Res<Art>,
+) {
+    for ev in spawn_bird_events.iter() {
+        commands
+            .spawn_bundle(SpriteBundle {
+                sprite: Sprite {
+                    color: Color::rgb(randf(), randf(), randf()),
+                    custom_size: Some(Vec2::splat(BIRD_SIZE)),
+                    ..default()
+                },
+                texture: art.bird_icon.clone(),
+                transform: Transform::from_translation(ev.new_bird_pos.extend(randf() * 100.0)),
+                ..default()
+            })
+            .insert(Velocity {
+                velocity: ev.new_bird_velocity,
+            })
+            .insert(Gravity)
+            .insert(Bird)
+            .insert(Chaos)
+            .insert(DriftToCenter);
+    }
+}
+
+fn drift_to_center(
+    mut q: Query<(&mut Velocity, &Transform)>,
+    cam: Query<&Transform, With<Camera>>,
+    time: Res<Time>,
+) {
+    for (mut v, t) in q.iter_mut() {
+        v.velocity.x -= (t.translation.x - cam.single().translation.x)
+            * DRIFT_TO_CENTER_AMOUNT
+            * time.delta().as_secs_f32();
+    }
+}
+
+fn velocity(mut q: Query<(&Velocity, &mut Transform)>, time: Res<Time>) {
+    for (v, mut t) in q.iter_mut() {
+        t.translation += (v.velocity * time.delta().as_secs_f32()).extend(0.0);
+    }
+}
+
+fn gravity(mut q: Query<&mut Velocity, With<Gravity>>, time: Res<Time>) {
+    for mut v in q.iter_mut() {
+        v.velocity.y = v.velocity.y - time.delta().as_secs_f32() * GRAVITY;
+    }
+}
+
+fn bird_collision(
+    mut commands: Commands,
+    birds: Query<(Entity, &Sprite, &Transform), With<Bird>>,
+    obstacles: Query<(&Sprite, &Transform), With<Obstacle>>,
+) {
+    for (bird_entity, bird_sprite, bird_transform) in birds.iter() {
+        for (obstacle_sprite, obstacle_transform) in obstacles.iter() {
+            let collision_result = collide(
+                bird_transform.translation,
+                bird_sprite.custom_size.unwrap(),
+                obstacle_transform.translation,
+                obstacle_sprite.custom_size.unwrap(),
+            );
+            if collision_result.is_some() {
+                commands.entity(bird_entity).despawn();
+            }
+        }
+    }
+}
+
+fn bird_reproduction(
+    q: Query<(&Transform, &Velocity), With<Bird>>,
+    time: Res<Time>,
+    mut spawn_bird_events: EventWriter<SpawnBird>,
+) {
+    let mut bird_count = 0;
+    for (_t, _v) in q.iter() {
+        bird_count += 1;
+    }
+    for (t, v) in q.iter() {
+        if bird_count < MAX_BIRDS {
+            if randf() < BIRD_REPRODUCTION_CHANCE * time.delta().as_secs_f32() {
+                spawn_bird_events.send(SpawnBird {
+                    new_bird_pos: t.translation.truncate(),
+                    new_bird_velocity: v.velocity,
+                });
+            }
+        }
+    }
+}
+
+fn chaos(mut q: Query<&mut Velocity, With<Chaos>>, time: Res<Time>) {
+    for mut v in q.iter_mut() {
+        v.velocity += Vec2::new(
+            (randf() - 0.5) * CHAOS_AMOUNT_X,
+            (randf() - 0.5) * CHAOS_AMOUNT_Y,
+        ) * time.delta().as_secs_f32();
+    }
+}
+
+fn bird_control(input: Res<Input<KeyCode>>, mut birds: Query<&mut Velocity, With<Bird>>) {
+    if input.just_pressed(KeyCode::Space) {
+        for mut v in birds.iter_mut() {
+            v.velocity.y = FLAP_STRENGTH;
+        }
+    }
+}

From 714a954a8efe20fa200bf18790b49802fff0341a Mon Sep 17 00:00:00 2001
From: alex <spamulo@gmail.com>
Date: Sat, 4 Jun 2022 18:28:29 +0100
Subject: [PATCH 02/11] updated README.md for flappy_bevy example

---
 examples/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/examples/README.md b/examples/README.md
index 7e83f3fd9dbe8..a7a615e34ee8b 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -205,6 +205,7 @@ Example | File | Description
 `alien_cake_addict` | [`games/alien_cake_addict.rs`](./games/alien_cake_addict.rs) | Eat the cakes. Eat them all. An example 3D game
 `breakout` | [`games/breakout.rs`](./games/breakout.rs) | An implementation of the classic game "Breakout"
 `contributors` | [`games/contributors.rs`](./games/contributors.rs) | Displays each contributor as a bouncy bevy-ball!
+`flappy_bevy` | [`games/flappy_bevy.rs`](./games/flappy_bevy.rs) | A flappy bird clone but with many birds
 `game_menu` | [`games/game_menu.rs`](./games/game_menu.rs) | A simple game menu
 
 ## Input

From d7ec550129d9f50b4ca4b922fd9df1ae2d18a212 Mon Sep 17 00:00:00 2001
From: alex <spamulo@gmail.com>
Date: Sat, 4 Jun 2022 18:55:44 +0100
Subject: [PATCH 03/11] flappy bevy example: satisfying clippy

---
 examples/games/flappy_bevy.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/examples/games/flappy_bevy.rs b/examples/games/flappy_bevy.rs
index b5b25625b86d9..4bf884e07c91c 100644
--- a/examples/games/flappy_bevy.rs
+++ b/examples/games/flappy_bevy.rs
@@ -54,7 +54,7 @@ pub fn main() {
     .add_event::<GenerateChunk>()
     .add_event::<SpawnBird>();
 
-    app.run()
+    app.run();
 }
 
 pub struct Art {
@@ -215,7 +215,7 @@ fn velocity(mut q: Query<(&Velocity, &mut Transform)>, time: Res<Time>) {
 
 fn gravity(mut q: Query<&mut Velocity, With<Gravity>>, time: Res<Time>) {
     for mut v in q.iter_mut() {
-        v.velocity.y = v.velocity.y - time.delta().as_secs_f32() * GRAVITY;
+        v.velocity.y -= time.delta().as_secs_f32() * GRAVITY;
     }
 }
 
@@ -249,13 +249,13 @@ fn bird_reproduction(
         bird_count += 1;
     }
     for (t, v) in q.iter() {
-        if bird_count < MAX_BIRDS {
-            if randf() < BIRD_REPRODUCTION_CHANCE * time.delta().as_secs_f32() {
+        if bird_count < MAX_BIRDS  &&
+             randf() < BIRD_REPRODUCTION_CHANCE * time.delta().as_secs_f32() {
                 spawn_bird_events.send(SpawnBird {
                     new_bird_pos: t.translation.truncate(),
                     new_bird_velocity: v.velocity,
                 });
-            }
+
         }
     }
 }

From 2964849e31d77a7cde03ac6c79dc9905ba4cfe65 Mon Sep 17 00:00:00 2001
From: alex <spamulo@gmail.com>
Date: Sat, 4 Jun 2022 18:58:01 +0100
Subject: [PATCH 04/11] flappy bevy example style fix

---
 examples/games/flappy_bevy.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/examples/games/flappy_bevy.rs b/examples/games/flappy_bevy.rs
index 4bf884e07c91c..61d3036c1a8c7 100644
--- a/examples/games/flappy_bevy.rs
+++ b/examples/games/flappy_bevy.rs
@@ -46,7 +46,7 @@ pub fn main() {
     .add_system(bird_control.after(gravity))
     .add_system(terrain_gen)
     .add_system(advance_camera)
-    .add_system(chaos)
+    .add_system(brownian_drift)
     .add_system(velocity)
     .add_system(gravity)
     .add_system(terrain_cleanup)
@@ -145,7 +145,7 @@ struct Velocity {
 }
 
 #[derive(Component)]
-struct Chaos;
+struct BrownianDrift;
 
 #[derive(Component)]
 struct Gravity;
@@ -156,6 +156,7 @@ struct Bird;
 #[derive(Component)]
 struct DriftToCenter;
 
+/// Event that causes a new bird to spawn
 struct SpawnBird {
     new_bird_pos: Vec2,
     new_bird_velocity: Vec2,
@@ -190,7 +191,7 @@ fn spawn_bird(
             })
             .insert(Gravity)
             .insert(Bird)
-            .insert(Chaos)
+            .insert(BrownianDrift)
             .insert(DriftToCenter);
     }
 }
@@ -260,7 +261,7 @@ fn bird_reproduction(
     }
 }
 
-fn chaos(mut q: Query<&mut Velocity, With<Chaos>>, time: Res<Time>) {
+fn brownian_drift(mut q: Query<&mut Velocity, With<BrownianDrift>>, time: Res<Time>) {
     for mut v in q.iter_mut() {
         v.velocity += Vec2::new(
             (randf() - 0.5) * CHAOS_AMOUNT_X,

From 35c5f4485e27e2c2f88aeab68e26210a95f368cc Mon Sep 17 00:00:00 2001
From: alex <spamulo@gmail.com>
Date: Sat, 4 Jun 2022 19:02:40 +0100
Subject: [PATCH 05/11] bevy example - format

---
 examples/games/flappy_bevy.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/examples/games/flappy_bevy.rs b/examples/games/flappy_bevy.rs
index 61d3036c1a8c7..f4748689ebd4a 100644
--- a/examples/games/flappy_bevy.rs
+++ b/examples/games/flappy_bevy.rs
@@ -250,13 +250,12 @@ fn bird_reproduction(
         bird_count += 1;
     }
     for (t, v) in q.iter() {
-        if bird_count < MAX_BIRDS  &&
-             randf() < BIRD_REPRODUCTION_CHANCE * time.delta().as_secs_f32() {
-                spawn_bird_events.send(SpawnBird {
-                    new_bird_pos: t.translation.truncate(),
-                    new_bird_velocity: v.velocity,
-                });
-
+        if bird_count < MAX_BIRDS && randf() < BIRD_REPRODUCTION_CHANCE * time.delta().as_secs_f32()
+        {
+            spawn_bird_events.send(SpawnBird {
+                new_bird_pos: t.translation.truncate(),
+                new_bird_velocity: v.velocity,
+            });
         }
     }
 }

From 79a034bbd8ba4163dc5e796e9a9247a50513f83b Mon Sep 17 00:00:00 2001
From: alex <spamulo@gmail.com>
Date: Sun, 5 Jun 2022 21:54:56 +0100
Subject: [PATCH 06/11] remove randf, floor bird cull, tuning, comments

---
 examples/games/flappy_bevy.rs | 63 ++++++++++++++++++-----------------
 1 file changed, 33 insertions(+), 30 deletions(-)

diff --git a/examples/games/flappy_bevy.rs b/examples/games/flappy_bevy.rs
index f4748689ebd4a..2b6f386928a1d 100644
--- a/examples/games/flappy_bevy.rs
+++ b/examples/games/flappy_bevy.rs
@@ -1,30 +1,26 @@
-//! A simplified Flappy Bird but with many birds
+//! A simplified Flappy Bird but with many birds. Press space to flap.
 
 use bevy::prelude::*;
 
-use bevy::sprite::collide_aabb::collide;
+use bevy::sprite::collide_aabb::{collide, Collision};
 use bevy::window::PresentMode;
 
-use rand::Rng;
+use rand::random;
 
 const CHUNK_SIZE: f32 = 300.0;
 const CAMERA_SPEED: f32 = 120.0;
 const GAME_HEIGHT: f32 = 500.0;
 const SCREEN_HEIGHT: f32 = 1500.0;
 const CLEANUP_X_DIST: f32 = 1500.0;
-const CHAOS_AMOUNT_X: f32 = 250.0;
-const CHAOS_AMOUNT_Y: f32 = 600.0;
-const DRIFT_TO_CENTER_AMOUNT: f32 = 0.01;
-const FLAP_STRENGTH: f32 = 250.0;
+const BROWNIAN_DRIFT_AMOUNT_X: f32 = 250.0;
+const BROWNIAN_DRIFT_AMOUNT_Y: f32 = 600.0;
+const DRIFT_TO_CENTER_AMOUNT: f32 = 0.1;
+const FLAP_STRENGTH: f32 = 240.0;
 const BIRD_SIZE: f32 = 24.0;
 const BIRD_REPRODUCTION_CHANCE: f32 = 1.0;
 const MAX_BIRDS: usize = 500;
 const GRAVITY: f32 = 400.0;
 
-fn randf() -> f32 {
-    rand::thread_rng().gen::<f32>()
-}
-
 pub fn main() {
     let mut app = App::new();
 
@@ -79,7 +75,9 @@ fn advance_camera(
         let chunk_index = (transform.translation.x / CHUNK_SIZE).floor() as i32;
         transform.translation.x += time.delta().as_secs_f32() * CAMERA_SPEED;
         let new_chunk_index = (transform.translation.x / CHUNK_SIZE).floor() as i32;
+        // if the camera has moved over a chunk boundary
         if chunk_index != new_chunk_index {
+            // generate a new chunk offscreen to the right
             outgoing_generate_chunk_events.send(GenerateChunk {
                 new_chunk_index: new_chunk_index + 3,
             });
@@ -97,6 +95,7 @@ fn terrain_cleanup(
 ) {
     let cam_x = cam.single().translation.x;
     for (e, t) in q.iter() {
+        // remove obstacles at the left
         if t.translation.x < cam_x - CLEANUP_X_DIST {
             commands.entity(e).despawn();
         }
@@ -110,10 +109,10 @@ fn terrain_gen(
     for ev in incoming_generate_chunk_events.iter() {
         let x_pos = CHUNK_SIZE * ev.new_chunk_index as f32;
         // generate some terrain within x_pos..x_pos+width
-        let gap_y_pos = GAME_HEIGHT * (randf() - 0.5);
-        let pillar_width = 50.0 + 110.0 * randf();
+        let gap_y_pos = GAME_HEIGHT * (random::<f32>() - 0.5) * 0.9;
+        let pillar_width = 50.0 + 110.0 * random::<f32>();
         // make the gap no narrower than the pillar is wide
-        let gap_size = (50.0 + 250.0 * randf()).max(pillar_width);
+        let gap_size = (65.0 + 250.0 * random::<f32>()).max(pillar_width);
         for (top_y_pos, bottom_y_pos) in [
             (-SCREEN_HEIGHT * 0.5, gap_y_pos - gap_size * 0.5),
             (gap_y_pos + gap_size * 0.5, SCREEN_HEIGHT * 0.5),
@@ -178,12 +177,12 @@ fn spawn_bird(
         commands
             .spawn_bundle(SpriteBundle {
                 sprite: Sprite {
-                    color: Color::rgb(randf(), randf(), randf()),
+                    color: Color::rgb(random::<f32>(), random::<f32>(), random::<f32>()),
                     custom_size: Some(Vec2::splat(BIRD_SIZE)),
                     ..default()
                 },
                 texture: art.bird_icon.clone(),
-                transform: Transform::from_translation(ev.new_bird_pos.extend(randf() * 100.0)),
+                transform: Transform::from_translation(ev.new_bird_pos.extend(random::<f32>() * 100.0)),
                 ..default()
             })
             .insert(Velocity {
@@ -196,6 +195,7 @@ fn spawn_bird(
     }
 }
 
+/// The flock has a tendency to drift offscreen - gently bring it back to the center
 fn drift_to_center(
     mut q: Query<(&mut Velocity, &Transform)>,
     cam: Query<&Transform, With<Camera>>,
@@ -226,16 +226,17 @@ fn bird_collision(
     obstacles: Query<(&Sprite, &Transform), With<Obstacle>>,
 ) {
     for (bird_entity, bird_sprite, bird_transform) in birds.iter() {
+        let mut collision_result: Option<Collision> = None;
         for (obstacle_sprite, obstacle_transform) in obstacles.iter() {
-            let collision_result = collide(
+            collision_result = collision_result.or(collide(
                 bird_transform.translation,
                 bird_sprite.custom_size.unwrap(),
                 obstacle_transform.translation,
                 obstacle_sprite.custom_size.unwrap(),
-            );
-            if collision_result.is_some() {
-                commands.entity(bird_entity).despawn();
-            }
+            ));
+        }
+        if collision_result.is_some() || bird_transform.translation.y < -SCREEN_HEIGHT * 0.5 {
+            commands.entity(bird_entity).despawn();
         }
     }
 }
@@ -249,13 +250,15 @@ fn bird_reproduction(
     for (_t, _v) in q.iter() {
         bird_count += 1;
     }
-    for (t, v) in q.iter() {
-        if bird_count < MAX_BIRDS && randf() < BIRD_REPRODUCTION_CHANCE * time.delta().as_secs_f32()
-        {
-            spawn_bird_events.send(SpawnBird {
-                new_bird_pos: t.translation.truncate(),
-                new_bird_velocity: v.velocity,
-            });
+    if bird_count < MAX_BIRDS {
+        for (t, v) in q.iter() {
+            if random::<f32>() < BIRD_REPRODUCTION_CHANCE * time.delta().as_secs_f32()
+            {
+                spawn_bird_events.send(SpawnBird {
+                    new_bird_pos: t.translation.truncate(),
+                    new_bird_velocity: v.velocity,
+                });
+            }
         }
     }
 }
@@ -263,8 +266,8 @@ fn bird_reproduction(
 fn brownian_drift(mut q: Query<&mut Velocity, With<BrownianDrift>>, time: Res<Time>) {
     for mut v in q.iter_mut() {
         v.velocity += Vec2::new(
-            (randf() - 0.5) * CHAOS_AMOUNT_X,
-            (randf() - 0.5) * CHAOS_AMOUNT_Y,
+            (random::<f32>() - 0.5) * BROWNIAN_DRIFT_AMOUNT_X,
+            (random::<f32>() - 0.5) * BROWNIAN_DRIFT_AMOUNT_Y,
         ) * time.delta().as_secs_f32();
     }
 }

From 38a8f726f66884bde0e74fc6b56234aac0fef454 Mon Sep 17 00:00:00 2001
From: alex <spamulo@gmail.com>
Date: Sun, 5 Jun 2022 22:00:38 +0100
Subject: [PATCH 07/11] enforce MAX_BIRDS with iter().count()

---
 examples/games/flappy_bevy.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/examples/games/flappy_bevy.rs b/examples/games/flappy_bevy.rs
index 2b6f386928a1d..00419ef50d286 100644
--- a/examples/games/flappy_bevy.rs
+++ b/examples/games/flappy_bevy.rs
@@ -246,10 +246,7 @@ fn bird_reproduction(
     time: Res<Time>,
     mut spawn_bird_events: EventWriter<SpawnBird>,
 ) {
-    let mut bird_count = 0;
-    for (_t, _v) in q.iter() {
-        bird_count += 1;
-    }
+    let bird_count = q.iter().count();
     if bird_count < MAX_BIRDS {
         for (t, v) in q.iter() {
             if random::<f32>() < BIRD_REPRODUCTION_CHANCE * time.delta().as_secs_f32()

From edb0bcebb8ef3cdfb21fede158052f2aeb08274e Mon Sep 17 00:00:00 2001
From: alex <spamulo@gmail.com>
Date: Sun, 5 Jun 2022 22:01:59 +0100
Subject: [PATCH 08/11] cargo fmt

---
 examples/games/flappy_bevy.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/examples/games/flappy_bevy.rs b/examples/games/flappy_bevy.rs
index 00419ef50d286..91cfc1bfec6b5 100644
--- a/examples/games/flappy_bevy.rs
+++ b/examples/games/flappy_bevy.rs
@@ -182,7 +182,9 @@ fn spawn_bird(
                     ..default()
                 },
                 texture: art.bird_icon.clone(),
-                transform: Transform::from_translation(ev.new_bird_pos.extend(random::<f32>() * 100.0)),
+                transform: Transform::from_translation(
+                    ev.new_bird_pos.extend(random::<f32>() * 100.0),
+                ),
                 ..default()
             })
             .insert(Velocity {
@@ -249,8 +251,7 @@ fn bird_reproduction(
     let bird_count = q.iter().count();
     if bird_count < MAX_BIRDS {
         for (t, v) in q.iter() {
-            if random::<f32>() < BIRD_REPRODUCTION_CHANCE * time.delta().as_secs_f32()
-            {
+            if random::<f32>() < BIRD_REPRODUCTION_CHANCE * time.delta().as_secs_f32() {
                 spawn_bird_events.send(SpawnBird {
                     new_bird_pos: t.translation.truncate(),
                     new_bird_velocity: v.velocity,

From 627f872c5ae5d8825a025a1621e536757b48dfaa Mon Sep 17 00:00:00 2001
From: alex <spamulo@gmail.com>
Date: Sun, 5 Jun 2022 22:18:25 +0100
Subject: [PATCH 09/11] satisfy clippy

---
 examples/games/flappy_bevy.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/examples/games/flappy_bevy.rs b/examples/games/flappy_bevy.rs
index 91cfc1bfec6b5..b8a0a96a27edb 100644
--- a/examples/games/flappy_bevy.rs
+++ b/examples/games/flappy_bevy.rs
@@ -230,12 +230,14 @@ fn bird_collision(
     for (bird_entity, bird_sprite, bird_transform) in birds.iter() {
         let mut collision_result: Option<Collision> = None;
         for (obstacle_sprite, obstacle_transform) in obstacles.iter() {
-            collision_result = collision_result.or(collide(
-                bird_transform.translation,
-                bird_sprite.custom_size.unwrap(),
-                obstacle_transform.translation,
-                obstacle_sprite.custom_size.unwrap(),
-            ));
+            if collision_result.is_none() {
+                collision_result = collide(
+                    bird_transform.translation,
+                    bird_sprite.custom_size.unwrap(),
+                    obstacle_transform.translation,
+                    obstacle_sprite.custom_size.unwrap(),
+                );
+            }
         }
         if collision_result.is_some() || bird_transform.translation.y < -SCREEN_HEIGHT * 0.5 {
             commands.entity(bird_entity).despawn();

From 23857ac2f5ae9a7236694b9900a48e2aab468264 Mon Sep 17 00:00:00 2001
From: alex <spamulo@gmail.com>
Date: Sun, 5 Jun 2022 22:25:18 +0100
Subject: [PATCH 10/11] gap variability into constant

---
 examples/games/flappy_bevy.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/examples/games/flappy_bevy.rs b/examples/games/flappy_bevy.rs
index b8a0a96a27edb..26919e8287206 100644
--- a/examples/games/flappy_bevy.rs
+++ b/examples/games/flappy_bevy.rs
@@ -20,6 +20,7 @@ const BIRD_SIZE: f32 = 24.0;
 const BIRD_REPRODUCTION_CHANCE: f32 = 1.0;
 const MAX_BIRDS: usize = 500;
 const GRAVITY: f32 = 400.0;
+const GAP_VARIABILITY: f32 = 0.9;
 
 pub fn main() {
     let mut app = App::new();
@@ -109,7 +110,7 @@ fn terrain_gen(
     for ev in incoming_generate_chunk_events.iter() {
         let x_pos = CHUNK_SIZE * ev.new_chunk_index as f32;
         // generate some terrain within x_pos..x_pos+width
-        let gap_y_pos = GAME_HEIGHT * (random::<f32>() - 0.5) * 0.9;
+        let gap_y_pos = GAME_HEIGHT * (random::<f32>() - 0.5) * GAP_VARIABILITY;
         let pillar_width = 50.0 + 110.0 * random::<f32>();
         // make the gap no narrower than the pillar is wide
         let gap_size = (65.0 + 250.0 * random::<f32>()).max(pillar_width);

From 2e4f50a3a4318978ff25b1cdf2b2a0ffd76aac9c Mon Sep 17 00:00:00 2001
From: alex <spamulo@gmail.com>
Date: Tue, 7 Jun 2022 14:45:30 +0100
Subject: [PATCH 11/11] autoflap, respawn, fix birds dropping, comments

---
 examples/games/flappy_bevy.rs | 320 ++++++++++++++++++++++------------
 1 file changed, 210 insertions(+), 110 deletions(-)

diff --git a/examples/games/flappy_bevy.rs b/examples/games/flappy_bevy.rs
index 26919e8287206..0b720e3af9b2e 100644
--- a/examples/games/flappy_bevy.rs
+++ b/examples/games/flappy_bevy.rs
@@ -14,13 +14,15 @@ const SCREEN_HEIGHT: f32 = 1500.0;
 const CLEANUP_X_DIST: f32 = 1500.0;
 const BROWNIAN_DRIFT_AMOUNT_X: f32 = 250.0;
 const BROWNIAN_DRIFT_AMOUNT_Y: f32 = 600.0;
-const DRIFT_TO_CENTER_AMOUNT: f32 = 0.1;
+const DRIFT_TO_CENTER_AMOUNT: f32 = 0.05;
 const FLAP_STRENGTH: f32 = 240.0;
 const BIRD_SIZE: f32 = 24.0;
 const BIRD_REPRODUCTION_CHANCE: f32 = 1.0;
 const MAX_BIRDS: usize = 500;
 const GRAVITY: f32 = 400.0;
 const GAP_VARIABILITY: f32 = 0.9;
+const AUTO_FLAP_INTERVAL_SECS: f32 = 1.1;
+const MOURN_TIME_SECS: f32 = 0.5;
 
 pub fn main() {
     let mut app = App::new();
@@ -34,111 +36,83 @@ pub fn main() {
         ..Default::default()
     })
     .add_plugins(DefaultPlugins)
-    .add_startup_system(spawn_camera)
-    .add_startup_system(load_art)
-    .add_startup_system(bird_startup)
-    .add_system(spawn_bird)
-    .add_system(bird_collision)
-    .add_system(bird_reproduction)
-    .add_system(bird_control.after(gravity))
-    .add_system(terrain_gen)
-    .add_system(advance_camera)
-    .add_system(brownian_drift)
-    .add_system(velocity)
-    .add_system(gravity)
-    .add_system(terrain_cleanup)
-    .add_system(drift_to_center)
+    .add_event::<Flap>()
     .add_event::<GenerateChunk>()
-    .add_event::<SpawnBird>();
+    .add_event::<SpawnBird>()
+    .insert_resource(AutoFlapState::default())
+    .insert_resource(MourningState::default())
+    .add_startup_system(load_art)
+    .add_startup_system(bird_startup) // generates a SpawnBird event
+    .add_system(spawn_bird) // responds to SpawnBird events
+    .add_system(input) // generates Flap events
+    .add_system_to_stage(CoreStage::PostUpdate, flap) // responds to Flap events, ordering prevents physics bug
+    .add_system(auto_flap) // play the game automatically at the start
+    .add_system(bird_collision) // despawn birds that collide with pillars or floor
+    .add_system(bird_reproduction) // slowly grow the flock
+    .add_system(brownian_drift) // make the flock drift apart
+    .add_system(velocity) // integrates velocity over time, mutating translation
+    .add_system(gravity) // makes gravity influence to velocity
+    .add_system(drift_to_center) // gently return birds to (0, 0)
+    .add_system(mourn.before(spawn_bird)) // respawn a bird when all die. Ordering necessary because counting birds
+    .add_system(terrain_gen) // generate pillars off-screen to the right
+    .add_system(terrain_cleanup) // remove pillars off-screen to the left
+    .add_startup_system(spawn_camera)
+    .add_system(advance_camera); // move the camera right at a constant speed
 
     app.run();
 }
 
-pub struct Art {
-    bird_icon: Handle<Image>,
+/// Event that causes a new bird to spawn
+struct SpawnBird {
+    new_bird_pos: Option<Vec2>,
+    new_bird_velocity: Vec2,
 }
 
-fn load_art(mut commands: Commands, asset_server: Res<AssetServer>) {
-    commands.insert_resource(Art {
-        bird_icon: asset_server.load("branding/icon.png"),
-    });
+/// Event that causes all birds on screen to flap
+struct Flap;
+
+/// Resource
+struct Art {
+    bird_icon: Handle<Image>,
 }
-struct GenerateChunk {
-    new_chunk_index: i32,
+
+/// Resource
+struct AutoFlapState {
+    active: bool,
+    timer: Timer,
 }
 
-fn advance_camera(
-    mut q: Query<&mut Transform, With<Camera>>,
-    time: Res<Time>,
-    mut outgoing_generate_chunk_events: EventWriter<GenerateChunk>,
-) {
-    if let Ok(mut transform) = q.get_single_mut() {
-        let chunk_index = (transform.translation.x / CHUNK_SIZE).floor() as i32;
-        transform.translation.x += time.delta().as_secs_f32() * CAMERA_SPEED;
-        let new_chunk_index = (transform.translation.x / CHUNK_SIZE).floor() as i32;
-        // if the camera has moved over a chunk boundary
-        if chunk_index != new_chunk_index {
-            // generate a new chunk offscreen to the right
-            outgoing_generate_chunk_events.send(GenerateChunk {
-                new_chunk_index: new_chunk_index + 3,
-            });
+impl Default for AutoFlapState {
+    fn default() -> AutoFlapState {
+        AutoFlapState {
+            active: true,
+            timer: Timer::from_seconds(AUTO_FLAP_INTERVAL_SECS, true),
         }
     }
 }
 
-#[derive(Component)]
-struct Obstacle;
-
-fn terrain_cleanup(
-    mut commands: Commands,
-    q: Query<(Entity, &Transform), With<Obstacle>>,
-    cam: Query<&Transform, With<Camera>>,
-) {
-    let cam_x = cam.single().translation.x;
-    for (e, t) in q.iter() {
-        // remove obstacles at the left
-        if t.translation.x < cam_x - CLEANUP_X_DIST {
-            commands.entity(e).despawn();
-        }
-    }
+/// Resource
+struct MourningState {
+    active: bool,
+    timer: Timer,
 }
 
-fn terrain_gen(
-    mut commands: Commands,
-    mut incoming_generate_chunk_events: EventReader<GenerateChunk>,
-) {
-    for ev in incoming_generate_chunk_events.iter() {
-        let x_pos = CHUNK_SIZE * ev.new_chunk_index as f32;
-        // generate some terrain within x_pos..x_pos+width
-        let gap_y_pos = GAME_HEIGHT * (random::<f32>() - 0.5) * GAP_VARIABILITY;
-        let pillar_width = 50.0 + 110.0 * random::<f32>();
-        // make the gap no narrower than the pillar is wide
-        let gap_size = (65.0 + 250.0 * random::<f32>()).max(pillar_width);
-        for (top_y_pos, bottom_y_pos) in [
-            (-SCREEN_HEIGHT * 0.5, gap_y_pos - gap_size * 0.5),
-            (gap_y_pos + gap_size * 0.5, SCREEN_HEIGHT * 0.5),
-        ] {
-            let pillar_origin = Vec2::new(x_pos, (top_y_pos + bottom_y_pos) * 0.5);
-            let pillar_size = Vec2::new(pillar_width, bottom_y_pos - top_y_pos);
-            commands
-                .spawn_bundle(SpriteBundle {
-                    sprite: Sprite {
-                        color: Color::rgb(0.25, 0.25, 0.75),
-                        custom_size: Some(pillar_size),
-                        ..default()
-                    },
-                    transform: Transform::from_translation(pillar_origin.extend(0.0)),
-                    ..default()
-                })
-                .insert(Obstacle);
+impl Default for MourningState {
+    fn default() -> MourningState {
+        MourningState {
+            active: false,
+            timer: Timer::from_seconds(MOURN_TIME_SECS, false),
         }
     }
 }
 
-fn spawn_camera(mut commands: Commands) {
-    commands.spawn_bundle(Camera2dBundle::default());
+struct GenerateChunk {
+    new_chunk_index: i32,
 }
 
+#[derive(Component)]
+struct Obstacle;
+
 #[derive(Component, Default)]
 struct Velocity {
     velocity: Vec2,
@@ -156,15 +130,15 @@ struct Bird;
 #[derive(Component)]
 struct DriftToCenter;
 
-/// Event that causes a new bird to spawn
-struct SpawnBird {
-    new_bird_pos: Vec2,
-    new_bird_velocity: Vec2,
+fn load_art(mut commands: Commands, asset_server: Res<AssetServer>) {
+    commands.insert_resource(Art {
+        bird_icon: asset_server.load("branding/icon.png"),
+    });
 }
 
 fn bird_startup(mut spawn_bird_events: EventWriter<SpawnBird>) {
     spawn_bird_events.send(SpawnBird {
-        new_bird_pos: Vec2::ZERO,
+        new_bird_pos: Some(Vec2::ZERO),
         new_bird_velocity: Vec2::new(CAMERA_SPEED, 0.0),
     });
 }
@@ -172,9 +146,13 @@ fn bird_startup(mut spawn_bird_events: EventWriter<SpawnBird>) {
 fn spawn_bird(
     mut commands: Commands,
     mut spawn_bird_events: EventReader<SpawnBird>,
+    cam: Query<&Transform, With<Camera>>,
     art: Res<Art>,
 ) {
     for ev in spawn_bird_events.iter() {
+        let camera_pos = cam.single().translation.truncate();
+        // if a bird position is not supplied, spawn in the center of the view
+        let new_bird_pos = ev.new_bird_pos.unwrap_or(camera_pos);
         commands
             .spawn_bundle(SpriteBundle {
                 sprite: Sprite {
@@ -184,7 +162,7 @@ fn spawn_bird(
                 },
                 texture: art.bird_icon.clone(),
                 transform: Transform::from_translation(
-                    ev.new_bird_pos.extend(random::<f32>() * 100.0),
+                    new_bird_pos.extend(random::<f32>() * 100.0),
                 ),
                 ..default()
             })
@@ -198,28 +176,36 @@ fn spawn_bird(
     }
 }
 
-/// The flock has a tendency to drift offscreen - gently bring it back to the center
-fn drift_to_center(
-    mut q: Query<(&mut Velocity, &Transform)>,
-    cam: Query<&Transform, With<Camera>>,
-    time: Res<Time>,
+fn input(
+    input: Res<Input<KeyCode>>,
+    mut flap_events: EventWriter<Flap>,
+    mut auto_flap_state: ResMut<AutoFlapState>,
 ) {
-    for (mut v, t) in q.iter_mut() {
-        v.velocity.x -= (t.translation.x - cam.single().translation.x)
-            * DRIFT_TO_CENTER_AMOUNT
-            * time.delta().as_secs_f32();
+    if input.just_pressed(KeyCode::Space) {
+        flap_events.send(Flap {});
+        auto_flap_state.active = false;
     }
 }
 
-fn velocity(mut q: Query<(&Velocity, &mut Transform)>, time: Res<Time>) {
-    for (v, mut t) in q.iter_mut() {
-        t.translation += (v.velocity * time.delta().as_secs_f32()).extend(0.0);
+fn flap(flap_events: EventReader<Flap>, mut birds: Query<&mut Velocity, With<Bird>>) {
+    if !flap_events.is_empty() {
+        for mut v in birds.iter_mut() {
+            v.velocity.y = FLAP_STRENGTH;
+        }
     }
 }
 
-fn gravity(mut q: Query<&mut Velocity, With<Gravity>>, time: Res<Time>) {
-    for mut v in q.iter_mut() {
-        v.velocity.y -= time.delta().as_secs_f32() * GRAVITY;
+fn auto_flap(
+    time: Res<Time>,
+    mut flap_events: EventWriter<Flap>,
+    mut auto_flap_state: ResMut<AutoFlapState>,
+) {
+    if !auto_flap_state.active {
+        return;
+    }
+    auto_flap_state.timer.tick(time.delta());
+    if auto_flap_state.timer.just_finished() {
+        flap_events.send(Flap {});
     }
 }
 
@@ -256,7 +242,7 @@ fn bird_reproduction(
         for (t, v) in q.iter() {
             if random::<f32>() < BIRD_REPRODUCTION_CHANCE * time.delta().as_secs_f32() {
                 spawn_bird_events.send(SpawnBird {
-                    new_bird_pos: t.translation.truncate(),
+                    new_bird_pos: Some(t.translation.truncate()),
                     new_bird_velocity: v.velocity,
                 });
             }
@@ -273,10 +259,124 @@ fn brownian_drift(mut q: Query<&mut Velocity, With<BrownianDrift>>, time: Res<Ti
     }
 }
 
-fn bird_control(input: Res<Input<KeyCode>>, mut birds: Query<&mut Velocity, With<Bird>>) {
-    if input.just_pressed(KeyCode::Space) {
-        for mut v in birds.iter_mut() {
-            v.velocity.y = FLAP_STRENGTH;
+fn velocity(mut q: Query<(&Velocity, &mut Transform)>, time: Res<Time>) {
+    for (v, mut t) in q.iter_mut() {
+        t.translation += (v.velocity * time.delta().as_secs_f32()).extend(0.0);
+    }
+}
+
+fn gravity(mut q: Query<&mut Velocity, With<Gravity>>, time: Res<Time>) {
+    for mut v in q.iter_mut() {
+        v.velocity.y -= time.delta().as_secs_f32() * GRAVITY;
+    }
+}
+
+/// The flock has a tendency to drift offscreen - gently bring it back to the center
+fn drift_to_center(
+    mut q: Query<(&mut Velocity, &Transform)>,
+    cam: Query<&Transform, With<Camera>>,
+    time: Res<Time>,
+) {
+    for (mut v, t) in q.iter_mut() {
+        v.velocity.x -= (t.translation.x - cam.single().translation.x)
+            * DRIFT_TO_CENTER_AMOUNT
+            * time.delta().as_secs_f32();
+    }
+}
+
+fn mourn(
+    time: Res<Time>,
+    mut mourning_state: ResMut<MourningState>,
+    bird_q: Query<(), With<Bird>>,
+    mut spawn_bird_events: EventWriter<SpawnBird>,
+    mut auto_flap_state: ResMut<AutoFlapState>,
+) {
+    if bird_q.iter().count() == 0 && !mourning_state.active && time.seconds_since_startup() > 1.0 {
+        // don't mourn on the first frame even though there are no birds
+        mourning_state
+            .timer
+            .set_duration(std::time::Duration::from_secs(4));
+        mourning_state.timer.reset();
+        mourning_state.active = true;
+    }
+    if mourning_state.active {
+        mourning_state.timer.tick(time.delta());
+        if mourning_state.timer.just_finished() {
+            mourning_state.active = false;
+            spawn_bird_events.send(SpawnBird {
+                new_bird_pos: None,
+                new_bird_velocity: Vec2::new(CAMERA_SPEED, 0.0),
+            });
+            auto_flap_state.active = true;
+        }
+    }
+}
+
+fn terrain_gen(
+    mut commands: Commands,
+    mut incoming_generate_chunk_events: EventReader<GenerateChunk>,
+) {
+    for ev in incoming_generate_chunk_events.iter() {
+        let x_pos = CHUNK_SIZE * ev.new_chunk_index as f32;
+        // generate some terrain within x_pos..x_pos+width
+        let gap_y_pos = GAME_HEIGHT * (random::<f32>() - 0.5) * GAP_VARIABILITY;
+        let pillar_width = 50.0 + 110.0 * random::<f32>();
+        // make the gap no narrower than the pillar is wide
+        let gap_size = (65.0 + 250.0 * random::<f32>()).max(pillar_width);
+        for (top_y_pos, bottom_y_pos) in [
+            (-SCREEN_HEIGHT * 0.5, gap_y_pos - gap_size * 0.5),
+            (gap_y_pos + gap_size * 0.5, SCREEN_HEIGHT * 0.5),
+        ] {
+            let pillar_origin = Vec2::new(x_pos, (top_y_pos + bottom_y_pos) * 0.5);
+            let pillar_size = Vec2::new(pillar_width, bottom_y_pos - top_y_pos);
+            commands
+                .spawn_bundle(SpriteBundle {
+                    sprite: Sprite {
+                        color: Color::rgb(0.25, 0.25, 0.75),
+                        custom_size: Some(pillar_size),
+                        ..default()
+                    },
+                    transform: Transform::from_translation(pillar_origin.extend(0.0)),
+                    ..default()
+                })
+                .insert(Obstacle);
+        }
+    }
+}
+
+fn terrain_cleanup(
+    mut commands: Commands,
+    q: Query<(Entity, &Transform), With<Obstacle>>,
+    cam: Query<&Transform, With<Camera>>,
+) {
+    let cam_x = cam.single().translation.x;
+    for (e, t) in q.iter() {
+        // remove obstacles at the left
+        if t.translation.x < cam_x - CLEANUP_X_DIST {
+            commands.entity(e).despawn();
+        }
+    }
+}
+
+fn spawn_camera(mut commands: Commands) {
+    commands.spawn_bundle(Camera2dBundle::default());
+}
+
+fn advance_camera(
+    mut q: Query<&mut Transform, With<Camera>>,
+    time: Res<Time>,
+    mut outgoing_generate_chunk_events: EventWriter<GenerateChunk>,
+) {
+    if let Ok(mut transform) = q.get_single_mut() {
+        let chunk_index = (transform.translation.x / CHUNK_SIZE).floor() as i32;
+        transform.translation.x += time.delta().as_secs_f32() * CAMERA_SPEED;
+        let new_chunk_index = (transform.translation.x / CHUNK_SIZE).floor() as i32;
+        // if the camera has moved over a chunk boundary
+        if chunk_index != new_chunk_index {
+            // generate a new chunk offscreen to the right
+            outgoing_generate_chunk_events.send(GenerateChunk {
+                new_chunk_index: new_chunk_index + 3,
+            });
         }
     }
 }