From 6e4a60fa3eadf5480ad409313cb3a2c58c0a0365 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Sun, 18 May 2025 22:04:11 +0200
Subject: [PATCH 1/4] add initial implementation of the Flappy Bird example

---
 Cargo.toml                    |  11 ++
 examples/README.md            |   1 +
 examples/games/flappy_bird.rs | 360 ++++++++++++++++++++++++++++++++++
 3 files changed, 372 insertions(+)
 create mode 100644 examples/games/flappy_bird.rs

diff --git a/Cargo.toml b/Cargo.toml
index a3d3a2ab63e51..2fdf729522eeb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4361,3 +4361,14 @@ name = "Extended Bindless Material"
 description = "Demonstrates bindless `ExtendedMaterial`"
 category = "Shaders"
 wasm = false
+
+[[example]]
+name = "flappy_bird"
+path = "examples/games/flappy_bird.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.flappy_bird]
+name = "Flappy Bird"
+description = "An implementation of the game \"Flappy Bird\"."
+category = "Games"
+wasm = true
diff --git a/examples/README.md b/examples/README.md
index 060683f96d891..6a42d7010d3b5 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -349,6 +349,7 @@ Example | Description
 [Breakout](../examples/games/breakout.rs) | An implementation of the classic game "Breakout".
 [Contributors](../examples/games/contributors.rs) | Displays each contributor as a bouncy bevy-ball!
 [Desk Toy](../examples/games/desk_toy.rs) | Bevy logo as a desk toy using transparent windows! Now with Googly Eyes!
+[Flappy Bird](../examples/games/flappy_bird.rs) | An implementation of the game "Flappy Bird".
 [Game Menu](../examples/games/game_menu.rs) | A simple game menu
 [Loading Screen](../examples/games/loading_screen.rs) | Demonstrates how to create a loading screen that waits for all assets to be loaded and render pipelines to be compiled.
 
diff --git a/examples/games/flappy_bird.rs b/examples/games/flappy_bird.rs
new file mode 100644
index 0000000000000..4b498c8323613
--- /dev/null
+++ b/examples/games/flappy_bird.rs
@@ -0,0 +1,360 @@
+//! An implementation of the game "Flappy Bird".
+
+use std::time::Duration;
+
+use bevy::math::{
+    bounding::{Aabb2d, BoundingCircle, IntersectsVolume},
+    ops::exp,
+};
+use bevy::prelude::*;
+use rand::Rng;
+
+const BACKGROUND_COLOR: Color = Color::srgb(0.9, 0.9, 0.9);
+
+/// Timer spawning a pipe each time it finishes
+const PIPE_TIMER_DURATION: Duration = Duration::from_millis(2000);
+
+/// Movement speed of the pipes
+const PIPE_SPEED: f32 = 200.;
+
+/// The size of each pipe rectangle
+const PIPE_SIZE: Vec2 = Vec2::new(100., 500.);
+
+/// How large the gap is between the pipes
+const GAP_HEIGHT: f32 = 300.;
+
+/// Gravity applied to the bird
+const GRAVITY: f32 = 700.;
+
+/// Size of the bird sprite
+const BIRD_SIZE: f32 = 100.;
+
+/// Acceleration the bird is set to on a flap
+const FLAP_POWER: f32 = 400.;
+
+/// Horizontal position of the bird
+const BIRD_POSITION: f32 = -500.;
+
+#[derive(Component)]
+struct Bird;
+
+#[derive(Component)]
+struct Pipe;
+
+#[derive(Component)]
+struct PipeMarker;
+
+/// Marker component for the text displaying the score
+#[derive(Component)]
+struct ScoreText;
+
+/// This resource tracks the game's score
+#[derive(Resource, Deref, DerefMut)]
+struct Score(usize);
+
+/// 2-dimensional velocity
+#[derive(Component, Deref, DerefMut)]
+struct Velocity(Vec2);
+
+/// Timer that determines when new pipes are spawned
+#[derive(Resource, Deref, DerefMut)]
+struct PipeTimer(Timer);
+
+/// The size of the window at the start of the game
+///
+/// Handling resizing while the game is playing is quite hard, so we ignore that
+#[derive(Resource, Deref, DerefMut)]
+struct WindowSize(Vec2);
+
+/// Event emitted when the bird touches the edges or a pipe
+#[derive(Event, Default)]
+struct CollisionEvent;
+
+/// Event emitted when a new pipe should be spawned
+#[derive(Event, Default)]
+struct SpawnPipeEvent;
+
+/// Sound that should be played when a pipe is passed
+#[derive(Resource, Deref)]
+struct ScoreSound(Handle<AudioSource>);
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, (set_window_size, setup))
+        .add_systems(
+            FixedUpdate,
+            (
+                reset,
+                add_pipes,
+                spawn_pipe,
+                flap,
+                apply_gravity,
+                apply_velocity,
+                check_collisions,
+                increase_score,
+                remove_pipes,
+            ),
+        )
+        .insert_resource(Score(0))
+        .insert_resource(ClearColor(BACKGROUND_COLOR))
+        .insert_resource(PipeTimer(Timer::new(
+            PIPE_TIMER_DURATION,
+            TimerMode::Repeating,
+        )))
+        .insert_resource(WindowSize(Vec2::ZERO))
+        .add_event::<CollisionEvent>()
+        .add_event::<SpawnPipeEvent>()
+        .run();
+}
+
+/// Set up the camera and score UI
+fn setup(
+    mut commands: Commands,
+    mut collision_events: EventWriter<CollisionEvent>,
+    asset_server: Res<AssetServer>,
+) {
+    commands.spawn(Camera2d);
+
+    let score_sound = asset_server.load("sounds/breakout_collision.ogg");
+    commands.insert_resource(ScoreSound(score_sound));
+
+    // Spawn the score UI.
+    commands.spawn((
+        Node {
+            width: Val::Percent(100.0),
+            height: Val::Percent(100.0),
+            align_items: AlignItems::Start,
+            justify_content: JustifyContent::Center,
+            padding: UiRect::all(Val::Px(10.0)),
+            ..default()
+        },
+        children![(
+            ScoreText,
+            Text::new("0"),
+            TextFont {
+                font_size: 66.0,
+                ..default()
+            },
+            TextColor(Color::srgb(0.3, 0.3, 0.9)),
+        )],
+    ));
+
+    // Create a collision event to trigger a reset
+    collision_events.write_default();
+}
+
+/// Clear everything and put everything to its start state
+fn reset(
+    mut commands: Commands,
+    mut timer: ResMut<PipeTimer>,
+    mut score: ResMut<Score>,
+    mut collision_events: EventReader<CollisionEvent>,
+    mut spawn_pipe_events: EventWriter<SpawnPipeEvent>,
+    score_text: Query<&mut Text, With<ScoreText>>,
+    pipes: Query<Entity, With<Pipe>>,
+    pipe_markers: Query<Entity, With<PipeMarker>>,
+    bird: Query<Entity, With<Bird>>,
+    asset_server: Res<AssetServer>,
+) {
+    if collision_events.is_empty() {
+        return;
+    }
+
+    collision_events.clear();
+
+    // Remove any entities left over from the previous game (if any)
+    for ent in bird {
+        commands.entity(ent).despawn();
+    }
+
+    for ent in pipes {
+        commands.entity(ent).despawn();
+    }
+
+    for ent in pipe_markers {
+        commands.entity(ent).despawn();
+    }
+
+    // Set the score to 0
+    score.0 = 0;
+    for mut text in score_text {
+        text.0 = 0.to_string();
+    }
+
+    // Spawn a new bird
+    commands.spawn((
+        Bird,
+        Sprite {
+            image: asset_server.load("branding/icon.png"),
+            custom_size: Some(Vec2::splat(BIRD_SIZE)),
+            ..default()
+        },
+        Transform::from_xyz(BIRD_POSITION, 0., 0.),
+        Velocity(Vec2::new(0., FLAP_POWER)),
+    ));
+
+    timer.reset();
+    spawn_pipe_events.write_default();
+}
+
+fn set_window_size(window: Single<&mut Window>, mut window_size: ResMut<WindowSize>) {
+    window_size.0 = Vec2::new(window.resolution.width(), window.resolution.height());
+}
+
+/// Flap on a spacebar or left mouse button press
+fn flap(
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    mouse_input: Res<ButtonInput<MouseButton>>,
+    mut bird_velocity: Single<&mut Velocity, With<Bird>>,
+) {
+    if keyboard_input.pressed(KeyCode::Space) || mouse_input.pressed(MouseButton::Left) {
+        bird_velocity.y = FLAP_POWER;
+    }
+}
+
+/// Apply gravity to the bird and set its rotation
+fn apply_gravity(mut bird: Single<(&mut Transform, &mut Velocity), With<Bird>>, time: Res<Time>) {
+    /// The logistic function, which is an example of a sigmoid function
+    fn logistic(x: f32) -> f32 {
+        1. / (1. + exp(-x))
+    }
+
+    bird.1.y -= GRAVITY * time.delta_secs();
+
+    // We determine the rotation based on the y-component of the velocity.
+    // This is tweaked such that a velocity of 100 is pretty much a 90 degree
+    // rotation. We take the output of the sigmoid function, which goes from
+    // 0 to 1 and stretch it to -1 to 1. Then we multiply with PI/2 to get
+    // a rotation in radians.
+    let rotation = std::f32::consts::PI / 2. * 2. * (logistic(bird.1.y / 600.) - 0.5);
+    bird.0.rotation = Quat::from_rotation_z(rotation);
+}
+
+/// Apply velocity to everything with a `Velocity` component
+fn apply_velocity(mut query: Query<(&mut Transform, &Velocity)>, time: Res<Time>) {
+    for (mut transform, velocity) in &mut query {
+        transform.translation.x += velocity.x * time.delta_secs();
+        transform.translation.y += velocity.y * time.delta_secs();
+    }
+}
+
+/// Check for collision with the borders of the window and the pipes
+fn check_collisions(
+    bird: Single<&Transform, With<Bird>>,
+    pipes: Query<&Transform, With<Pipe>>,
+    window_size: Res<WindowSize>,
+    mut collision_events: EventWriter<CollisionEvent>,
+) {
+    if bird.translation.y.abs() > window_size.y / 2. {
+        collision_events.write_default();
+        return;
+    }
+
+    let bird_collider = BoundingCircle::new(bird.translation.truncate(), BIRD_SIZE / 2.);
+    for pipe in pipes {
+        let pipe_collider = Aabb2d::new(pipe.translation.truncate(), PIPE_SIZE / 2.);
+        if bird_collider.intersects(&pipe_collider) {
+            collision_events.write_default();
+            return;
+        }
+    }
+}
+
+/// Add a pipe each time the timer finishes
+fn add_pipes(
+    mut timer: ResMut<PipeTimer>,
+    time: Res<Time>,
+    mut events: EventWriter<SpawnPipeEvent>,
+) {
+    timer.tick(time.delta());
+
+    if timer.finished() {
+        events.write_default();
+    }
+}
+
+fn spawn_pipe(
+    mut events: EventReader<SpawnPipeEvent>,
+    window_size: Res<WindowSize>,
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    if events.is_empty() {
+        return;
+    }
+    events.clear();
+
+    let color = Color::BLACK;
+    let shape = meshes.add(Rectangle::new(PIPE_SIZE.x, PIPE_SIZE.y));
+
+    let mut rng = rand::thread_rng();
+    let gap_offset: i64 = rng.gen_range(-200..=200);
+    let gap_offset: f32 = gap_offset as f32;
+
+    let pipe_offset = PIPE_SIZE.y / 2. + GAP_HEIGHT / 2.;
+
+    let pipe_location = window_size.x / 2. + PIPE_SIZE.x / 2.;
+
+    // We first spawn in invisible marker that will increase the score once
+    // it passes the bird position and then despawns. This assures that each
+    // pipe is counted once.
+    commands.spawn((
+        PipeMarker,
+        Transform::from_xyz(pipe_location, 0.0, 0.0),
+        Velocity(Vec2::new(-PIPE_SPEED, 0.)),
+    ));
+
+    // bottom pipe
+    commands.spawn((
+        Pipe,
+        Mesh2d(shape.clone()),
+        MeshMaterial2d(materials.add(color)),
+        Transform::from_xyz(pipe_location, pipe_offset + gap_offset, 0.0),
+        Velocity(Vec2::new(-PIPE_SPEED, 0.)),
+    ));
+
+    // top pipe
+    commands.spawn((
+        Pipe,
+        Mesh2d(shape),
+        MeshMaterial2d(materials.add(color)),
+        Transform::from_xyz(pipe_location, -pipe_offset + gap_offset, 0.0),
+        Velocity(Vec2::new(-PIPE_SPEED, 0.)),
+    ));
+}
+
+/// Increase the score every time a pipe marker passes the bird
+fn increase_score(
+    mut commands: Commands,
+    mut marker_query: Query<(Entity, &mut Transform), With<PipeMarker>>,
+    mut text_query: Query<&mut Text, With<ScoreText>>,
+    mut score: ResMut<Score>,
+    sound: Res<ScoreSound>,
+) {
+    for (entity, transform) in &mut marker_query {
+        if transform.translation.x < BIRD_POSITION {
+            commands.entity(entity).despawn();
+            score.0 += 1;
+            text_query.single_mut().unwrap().0 = score.0.to_string();
+            commands.spawn((AudioPlayer(sound.clone()), PlaybackSettings::DESPAWN));
+        }
+    }
+}
+
+/// Remove pipes that have left the screen
+fn remove_pipes(
+    mut commands: Commands,
+    mut query: Query<(Entity, &mut Transform), With<Pipe>>,
+    window_size: Res<WindowSize>,
+) {
+    for (entity, transform) in &mut query {
+        // The entire pipe needs to have left the screen, not just its origin,
+        // so we check that the right side of the pipe is off screen.
+        let right_side_of_pipe = transform.translation.x + PIPE_SIZE.x / 2.;
+        if right_side_of_pipe < -window_size.x / 2. {
+            commands.entity(entity).despawn();
+        }
+    }
+}

From 216205a8002156b0721eaa3b2672fc9b43b100fd Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Mon, 19 May 2025 12:52:59 +0200
Subject: [PATCH 2/4] adapt Flappy Bird example to review comments

---
 examples/games/flappy_bird.rs | 25 +++++++------------------
 1 file changed, 7 insertions(+), 18 deletions(-)

diff --git a/examples/games/flappy_bird.rs b/examples/games/flappy_bird.rs
index 4b498c8323613..ad190b38f96f4 100644
--- a/examples/games/flappy_bird.rs
+++ b/examples/games/flappy_bird.rs
@@ -116,6 +116,7 @@ fn setup(
 ) {
     commands.spawn(Camera2d);
 
+    // TODO: Replace with a custom sound, or rename file
     let score_sound = asset_server.load("sounds/breakout_collision.ogg");
     commands.insert_resource(ScoreSound(score_sound));
 
@@ -151,10 +152,8 @@ fn reset(
     mut score: ResMut<Score>,
     mut collision_events: EventReader<CollisionEvent>,
     mut spawn_pipe_events: EventWriter<SpawnPipeEvent>,
-    score_text: Query<&mut Text, With<ScoreText>>,
-    pipes: Query<Entity, With<Pipe>>,
-    pipe_markers: Query<Entity, With<PipeMarker>>,
-    bird: Query<Entity, With<Bird>>,
+    mut score_text: Single<&mut Text, With<ScoreText>>,
+    to_remove: Query<Entity, Or<(With<Bird>, With<Pipe>, With<PipeMarker>)>>,
     asset_server: Res<AssetServer>,
 ) {
     if collision_events.is_empty() {
@@ -164,23 +163,13 @@ fn reset(
     collision_events.clear();
 
     // Remove any entities left over from the previous game (if any)
-    for ent in bird {
-        commands.entity(ent).despawn();
-    }
-
-    for ent in pipes {
-        commands.entity(ent).despawn();
-    }
-
-    for ent in pipe_markers {
+    for ent in to_remove {
         commands.entity(ent).despawn();
     }
 
     // Set the score to 0
     score.0 = 0;
-    for mut text in score_text {
-        text.0 = 0.to_string();
-    }
+    score_text.0 = 0.to_string();
 
     // Spawn a new bird
     commands.spawn((
@@ -264,8 +253,8 @@ fn check_collisions(
 /// Add a pipe each time the timer finishes
 fn add_pipes(
     mut timer: ResMut<PipeTimer>,
-    time: Res<Time>,
     mut events: EventWriter<SpawnPipeEvent>,
+    time: Res<Time>,
 ) {
     timer.tick(time.delta());
 
@@ -276,10 +265,10 @@ fn add_pipes(
 
 fn spawn_pipe(
     mut events: EventReader<SpawnPipeEvent>,
-    window_size: Res<WindowSize>,
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<ColorMaterial>>,
+    window_size: Res<WindowSize>,
 ) {
     if events.is_empty() {
         return;

From c1f36684fdf2af4e52e6f64a63f120ad1fea87ef Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Mon, 19 May 2025 13:15:05 +0200
Subject: [PATCH 3/4] introduce a Settings struct to the Flappy Bird example

---
 examples/games/flappy_bird.rs | 104 ++++++++++++++++++++++------------
 1 file changed, 68 insertions(+), 36 deletions(-)

diff --git a/examples/games/flappy_bird.rs b/examples/games/flappy_bird.rs
index ad190b38f96f4..ee9a394799e43 100644
--- a/examples/games/flappy_bird.rs
+++ b/examples/games/flappy_bird.rs
@@ -9,31 +9,50 @@ use bevy::math::{
 use bevy::prelude::*;
 use rand::Rng;
 
-const BACKGROUND_COLOR: Color = Color::srgb(0.9, 0.9, 0.9);
+#[derive(Resource, Reflect)]
+struct Settings {
+    background_color: Color,
 
-/// Timer spawning a pipe each time it finishes
-const PIPE_TIMER_DURATION: Duration = Duration::from_millis(2000);
+    /// Timer spawning a pipe each time it finishes
+    pipe_timer_duration: Duration,
 
-/// Movement speed of the pipes
-const PIPE_SPEED: f32 = 200.;
+    /// Movement speed of the pipes
+    pipe_speed: f32,
 
-/// The size of each pipe rectangle
-const PIPE_SIZE: Vec2 = Vec2::new(100., 500.);
+    /// The size of each pipe rectangle
+    pipe_size: Vec2,
 
-/// How large the gap is between the pipes
-const GAP_HEIGHT: f32 = 300.;
+    /// How large the gap is between the pipes
+    gap_height: f32,
 
-/// Gravity applied to the bird
-const GRAVITY: f32 = 700.;
+    /// Gravity applied to the bird
+    gravity: f32,
 
-/// Size of the bird sprite
-const BIRD_SIZE: f32 = 100.;
+    /// Size of the bird sprite
+    bird_size: f32,
 
-/// Acceleration the bird is set to on a flap
-const FLAP_POWER: f32 = 400.;
+    /// Acceleration the bird is set to on a flap
+    flap_power: f32,
 
-/// Horizontal position of the bird
-const BIRD_POSITION: f32 = -500.;
+    /// Horizontal position of the bird
+    bird_position: f32,
+}
+
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            background_color: Color::srgb(0.9, 0.9, 0.9),
+            pipe_timer_duration: Duration::from_millis(2000),
+            pipe_speed: 200.,
+            pipe_size: Vec2::new(100., 500.),
+            gap_height: 300.,
+            gravity: 700.,
+            bird_size: 100.,
+            flap_power: 400.,
+            bird_position: -500.,
+        }
+    }
+}
 
 #[derive(Component)]
 struct Bird;
@@ -79,6 +98,7 @@ struct SpawnPipeEvent;
 struct ScoreSound(Handle<AudioSource>);
 
 fn main() {
+    let settings = Settings::default();
     App::new()
         .add_plugins(DefaultPlugins)
         .add_systems(Startup, (set_window_size, setup))
@@ -97,12 +117,13 @@ fn main() {
             ),
         )
         .insert_resource(Score(0))
-        .insert_resource(ClearColor(BACKGROUND_COLOR))
+        .insert_resource(ClearColor(settings.background_color))
         .insert_resource(PipeTimer(Timer::new(
-            PIPE_TIMER_DURATION,
+            settings.pipe_timer_duration,
             TimerMode::Repeating,
         )))
         .insert_resource(WindowSize(Vec2::ZERO))
+        .insert_resource(settings)
         .add_event::<CollisionEvent>()
         .add_event::<SpawnPipeEvent>()
         .run();
@@ -155,6 +176,7 @@ fn reset(
     mut score_text: Single<&mut Text, With<ScoreText>>,
     to_remove: Query<Entity, Or<(With<Bird>, With<Pipe>, With<PipeMarker>)>>,
     asset_server: Res<AssetServer>,
+    settings: Res<Settings>,
 ) {
     if collision_events.is_empty() {
         return;
@@ -176,11 +198,11 @@ fn reset(
         Bird,
         Sprite {
             image: asset_server.load("branding/icon.png"),
-            custom_size: Some(Vec2::splat(BIRD_SIZE)),
+            custom_size: Some(Vec2::splat(settings.bird_size)),
             ..default()
         },
-        Transform::from_xyz(BIRD_POSITION, 0., 0.),
-        Velocity(Vec2::new(0., FLAP_POWER)),
+        Transform::from_xyz(settings.bird_position, 0., 0.),
+        Velocity(Vec2::new(0., settings.flap_power)),
     ));
 
     timer.reset();
@@ -196,20 +218,25 @@ fn flap(
     keyboard_input: Res<ButtonInput<KeyCode>>,
     mouse_input: Res<ButtonInput<MouseButton>>,
     mut bird_velocity: Single<&mut Velocity, With<Bird>>,
+    settings: Res<Settings>,
 ) {
     if keyboard_input.pressed(KeyCode::Space) || mouse_input.pressed(MouseButton::Left) {
-        bird_velocity.y = FLAP_POWER;
+        bird_velocity.y = settings.flap_power;
     }
 }
 
 /// Apply gravity to the bird and set its rotation
-fn apply_gravity(mut bird: Single<(&mut Transform, &mut Velocity), With<Bird>>, time: Res<Time>) {
+fn apply_gravity(
+    mut bird: Single<(&mut Transform, &mut Velocity), With<Bird>>,
+    time: Res<Time>,
+    settings: Res<Settings>,
+) {
     /// The logistic function, which is an example of a sigmoid function
     fn logistic(x: f32) -> f32 {
         1. / (1. + exp(-x))
     }
 
-    bird.1.y -= GRAVITY * time.delta_secs();
+    bird.1.y -= settings.gravity * time.delta_secs();
 
     // We determine the rotation based on the y-component of the velocity.
     // This is tweaked such that a velocity of 100 is pretty much a 90 degree
@@ -230,19 +257,20 @@ fn apply_velocity(mut query: Query<(&mut Transform, &Velocity)>, time: Res<Time>
 
 /// Check for collision with the borders of the window and the pipes
 fn check_collisions(
+    mut collision_events: EventWriter<CollisionEvent>,
     bird: Single<&Transform, With<Bird>>,
     pipes: Query<&Transform, With<Pipe>>,
     window_size: Res<WindowSize>,
-    mut collision_events: EventWriter<CollisionEvent>,
+    settings: Res<Settings>,
 ) {
     if bird.translation.y.abs() > window_size.y / 2. {
         collision_events.write_default();
         return;
     }
 
-    let bird_collider = BoundingCircle::new(bird.translation.truncate(), BIRD_SIZE / 2.);
+    let bird_collider = BoundingCircle::new(bird.translation.truncate(), settings.bird_size / 2.);
     for pipe in pipes {
-        let pipe_collider = Aabb2d::new(pipe.translation.truncate(), PIPE_SIZE / 2.);
+        let pipe_collider = Aabb2d::new(pipe.translation.truncate(), settings.pipe_size / 2.);
         if bird_collider.intersects(&pipe_collider) {
             collision_events.write_default();
             return;
@@ -269,6 +297,7 @@ fn spawn_pipe(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<ColorMaterial>>,
     window_size: Res<WindowSize>,
+    settings: Res<Settings>,
 ) {
     if events.is_empty() {
         return;
@@ -276,15 +305,16 @@ fn spawn_pipe(
     events.clear();
 
     let color = Color::BLACK;
-    let shape = meshes.add(Rectangle::new(PIPE_SIZE.x, PIPE_SIZE.y));
+    let size = settings.pipe_size;
+    let shape = meshes.add(Rectangle::new(size.x, size.y));
 
     let mut rng = rand::thread_rng();
     let gap_offset: i64 = rng.gen_range(-200..=200);
     let gap_offset: f32 = gap_offset as f32;
 
-    let pipe_offset = PIPE_SIZE.y / 2. + GAP_HEIGHT / 2.;
+    let pipe_offset = size.y / 2. + settings.gap_height / 2.;
 
-    let pipe_location = window_size.x / 2. + PIPE_SIZE.x / 2.;
+    let pipe_location = window_size.x / 2. + size.x / 2.;
 
     // We first spawn in invisible marker that will increase the score once
     // it passes the bird position and then despawns. This assures that each
@@ -292,7 +322,7 @@ fn spawn_pipe(
     commands.spawn((
         PipeMarker,
         Transform::from_xyz(pipe_location, 0.0, 0.0),
-        Velocity(Vec2::new(-PIPE_SPEED, 0.)),
+        Velocity(Vec2::new(-settings.pipe_speed, 0.)),
     ));
 
     // bottom pipe
@@ -301,7 +331,7 @@ fn spawn_pipe(
         Mesh2d(shape.clone()),
         MeshMaterial2d(materials.add(color)),
         Transform::from_xyz(pipe_location, pipe_offset + gap_offset, 0.0),
-        Velocity(Vec2::new(-PIPE_SPEED, 0.)),
+        Velocity(Vec2::new(-settings.pipe_speed, 0.)),
     ));
 
     // top pipe
@@ -310,7 +340,7 @@ fn spawn_pipe(
         Mesh2d(shape),
         MeshMaterial2d(materials.add(color)),
         Transform::from_xyz(pipe_location, -pipe_offset + gap_offset, 0.0),
-        Velocity(Vec2::new(-PIPE_SPEED, 0.)),
+        Velocity(Vec2::new(-settings.pipe_speed, 0.)),
     ));
 }
 
@@ -321,9 +351,10 @@ fn increase_score(
     mut text_query: Query<&mut Text, With<ScoreText>>,
     mut score: ResMut<Score>,
     sound: Res<ScoreSound>,
+    settings: Res<Settings>,
 ) {
     for (entity, transform) in &mut marker_query {
-        if transform.translation.x < BIRD_POSITION {
+        if transform.translation.x < settings.bird_position {
             commands.entity(entity).despawn();
             score.0 += 1;
             text_query.single_mut().unwrap().0 = score.0.to_string();
@@ -337,11 +368,12 @@ fn remove_pipes(
     mut commands: Commands,
     mut query: Query<(Entity, &mut Transform), With<Pipe>>,
     window_size: Res<WindowSize>,
+    settings: Res<Settings>,
 ) {
     for (entity, transform) in &mut query {
         // The entire pipe needs to have left the screen, not just its origin,
         // so we check that the right side of the pipe is off screen.
-        let right_side_of_pipe = transform.translation.x + PIPE_SIZE.x / 2.;
+        let right_side_of_pipe = transform.translation.x + settings.pipe_size.x / 2.;
         if right_side_of_pipe < -window_size.x / 2. {
             commands.entity(entity).despawn();
         }

From da63a76cec9bd7778e01372dbf5a7b05bb027293 Mon Sep 17 00:00:00 2001
From: Terts Diepraam <terts.diepraam@gmail.com>
Date: Mon, 19 May 2025 14:40:19 +0200
Subject: [PATCH 4/4] add menus to the flappy bird example

---
 examples/games/flappy_bird.rs | 263 +++++++++++++++++++++++++---------
 1 file changed, 199 insertions(+), 64 deletions(-)

diff --git a/examples/games/flappy_bird.rs b/examples/games/flappy_bird.rs
index ee9a394799e43..5c82384da6f49 100644
--- a/examples/games/flappy_bird.rs
+++ b/examples/games/flappy_bird.rs
@@ -9,6 +9,14 @@ use bevy::math::{
 use bevy::prelude::*;
 use rand::Rng;
 
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Default, States)]
+enum State {
+    #[default]
+    MainMenu,
+    InGame,
+    GameOver,
+}
+
 #[derive(Resource, Reflect)]
 struct Settings {
     background_color: Color,
@@ -67,6 +75,18 @@ struct PipeMarker;
 #[derive(Component)]
 struct ScoreText;
 
+#[derive(Component)]
+struct StartButton;
+
+#[derive(Component)]
+struct OnMainMenu;
+
+#[derive(Component)]
+struct OnGameScreen;
+
+#[derive(Component)]
+struct OnGameOverScreen;
+
 /// This resource tracks the game's score
 #[derive(Resource, Deref, DerefMut)]
 struct Score(usize);
@@ -79,16 +99,6 @@ struct Velocity(Vec2);
 #[derive(Resource, Deref, DerefMut)]
 struct PipeTimer(Timer);
 
-/// The size of the window at the start of the game
-///
-/// Handling resizing while the game is playing is quite hard, so we ignore that
-#[derive(Resource, Deref, DerefMut)]
-struct WindowSize(Vec2);
-
-/// Event emitted when the bird touches the edges or a pipe
-#[derive(Event, Default)]
-struct CollisionEvent;
-
 /// Event emitted when a new pipe should be spawned
 #[derive(Event, Default)]
 struct SpawnPipeEvent;
@@ -101,11 +111,24 @@ fn main() {
     let settings = Settings::default();
     App::new()
         .add_plugins(DefaultPlugins)
-        .add_systems(Startup, (set_window_size, setup))
+        .add_systems(Startup, setup)
+        .add_systems(OnEnter(State::MainMenu), setup_main_menu)
+        .add_systems(OnExit(State::MainMenu), despawn_screen::<OnMainMenu>)
+        .add_systems(OnEnter(State::GameOver), setup_game_over)
+        .add_systems(OnExit(State::GameOver), despawn_screen::<OnGameOverScreen>)
+        .add_systems(
+            Update,
+            handle_start_button.run_if(in_state(State::MainMenu)),
+        )
+        .add_systems(
+            Update,
+            handle_start_button.run_if(in_state(State::GameOver)),
+        )
+        .add_systems(OnEnter(State::InGame), setup_game)
+        .add_systems(OnExit(State::InGame), teardown_game)
         .add_systems(
             FixedUpdate,
             (
-                reset,
                 add_pipes,
                 spawn_pipe,
                 flap,
@@ -114,7 +137,8 @@ fn main() {
                 check_collisions,
                 increase_score,
                 remove_pipes,
-            ),
+            )
+                .run_if(in_state(State::InGame)),
         )
         .insert_resource(Score(0))
         .insert_resource(ClearColor(settings.background_color))
@@ -122,27 +146,157 @@ fn main() {
             settings.pipe_timer_duration,
             TimerMode::Repeating,
         )))
-        .insert_resource(WindowSize(Vec2::ZERO))
         .insert_resource(settings)
-        .add_event::<CollisionEvent>()
+        .insert_state(State::MainMenu)
         .add_event::<SpawnPipeEvent>()
         .run();
 }
 
+fn despawn_screen<T: Component>(menu: Single<Entity, With<T>>, mut commands: Commands) {
+    commands.entity(*menu).despawn();
+}
+
 /// Set up the camera and score UI
-fn setup(
-    mut commands: Commands,
-    mut collision_events: EventWriter<CollisionEvent>,
-    asset_server: Res<AssetServer>,
-) {
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     commands.spawn(Camera2d);
 
     // TODO: Replace with a custom sound, or rename file
     let score_sound = asset_server.load("sounds/breakout_collision.ogg");
     commands.insert_resource(ScoreSound(score_sound));
+}
+
+fn setup_main_menu(mut commands: Commands) {
+    commands.spawn((
+        OnMainMenu,
+        Node {
+            width: Val::Percent(100.0),
+            height: Val::Percent(100.0),
+            align_items: AlignItems::Center,
+            justify_content: JustifyContent::Center,
+            flex_direction: FlexDirection::Column,
+            ..default()
+        },
+        children![
+            (
+                Text::new("Flipper Birb"),
+                TextFont {
+                    font_size: 66.0,
+                    ..default()
+                },
+                TextColor(Color::BLACK),
+            ),
+            (
+                Button,
+                StartButton,
+                Node {
+                    width: Val::Px(150.0),
+                    height: Val::Px(65.0),
+                    border: UiRect::all(Val::Px(5.0)),
+                    justify_content: JustifyContent::Center,
+                    align_items: AlignItems::Center,
+                    margin: UiRect::top(Val::Px(20.0)),
+                    ..default()
+                },
+                BorderColor(Color::BLACK),
+                BorderRadius::MAX,
+                BackgroundColor(Color::srgb(0.15, 0.15, 0.15)),
+                children![(
+                    Text::new("Start"),
+                    TextFont {
+                        font_size: 33.0,
+                        ..default()
+                    },
+                    TextColor(Color::srgb(0.9, 0.9, 0.9)),
+                    TextShadow::default(),
+                )]
+            )
+        ],
+    ));
+}
+
+fn handle_start_button(
+    query: Query<&Interaction, (Changed<Interaction>, With<StartButton>, With<Button>)>,
+    mut next_state: ResMut<NextState<State>>,
+) {
+    for interaction in query {
+        if *interaction == Interaction::Pressed {
+            next_state.set(State::InGame);
+        }
+    }
+}
+
+fn setup_game_over(mut commands: Commands, score: Res<Score>) {
+    commands.spawn((
+        OnGameOverScreen,
+        Node {
+            width: Val::Percent(100.0),
+            height: Val::Percent(100.0),
+            align_items: AlignItems::Center,
+            justify_content: JustifyContent::Center,
+            flex_direction: FlexDirection::Column,
+            column_gap: Val::Px(10.0),
+            ..default()
+        },
+        children![
+            (
+                Text::new("Your score was:"),
+                TextFont {
+                    font_size: 30.0,
+                    ..default()
+                },
+                TextColor(Color::BLACK),
+            ),
+            (
+                Text::new(score.to_string()),
+                TextFont {
+                    font_size: 120.0,
+                    ..default()
+                },
+                TextColor(Color::BLACK),
+            ),
+            (
+                Button,
+                StartButton,
+                Node {
+                    width: Val::Px(250.0),
+                    height: Val::Px(65.0),
+                    border: UiRect::all(Val::Px(5.0)),
+                    justify_content: JustifyContent::Center,
+                    align_items: AlignItems::Center,
+                    margin: UiRect::top(Val::Px(20.0)),
+                    ..default()
+                },
+                BorderColor(Color::BLACK),
+                BorderRadius::MAX,
+                BackgroundColor(Color::srgb(0.15, 0.15, 0.15)),
+                children![(
+                    Text::new("Try Again!"),
+                    TextFont {
+                        font_size: 33.0,
+                        ..default()
+                    },
+                    TextColor(Color::srgb(0.9, 0.9, 0.9)),
+                    TextShadow::default(),
+                )]
+            )
+        ],
+    ));
+}
+
+fn setup_game(
+    mut score: ResMut<Score>,
+    mut commands: Commands,
+    mut spawn_pipe_events: EventWriter<SpawnPipeEvent>,
+    mut timer: ResMut<PipeTimer>,
+    asset_server: Res<AssetServer>,
+    settings: Res<Settings>,
+) {
+    // Set the score to 0
+    score.0 = 0;
 
     // Spawn the score UI.
     commands.spawn((
+        OnGameScreen,
         Node {
             width: Val::Percent(100.0),
             height: Val::Percent(100.0),
@@ -162,37 +316,6 @@ fn setup(
         )],
     ));
 
-    // Create a collision event to trigger a reset
-    collision_events.write_default();
-}
-
-/// Clear everything and put everything to its start state
-fn reset(
-    mut commands: Commands,
-    mut timer: ResMut<PipeTimer>,
-    mut score: ResMut<Score>,
-    mut collision_events: EventReader<CollisionEvent>,
-    mut spawn_pipe_events: EventWriter<SpawnPipeEvent>,
-    mut score_text: Single<&mut Text, With<ScoreText>>,
-    to_remove: Query<Entity, Or<(With<Bird>, With<Pipe>, With<PipeMarker>)>>,
-    asset_server: Res<AssetServer>,
-    settings: Res<Settings>,
-) {
-    if collision_events.is_empty() {
-        return;
-    }
-
-    collision_events.clear();
-
-    // Remove any entities left over from the previous game (if any)
-    for ent in to_remove {
-        commands.entity(ent).despawn();
-    }
-
-    // Set the score to 0
-    score.0 = 0;
-    score_text.0 = 0.to_string();
-
     // Spawn a new bird
     commands.spawn((
         Bird,
@@ -209,8 +332,20 @@ fn reset(
     spawn_pipe_events.write_default();
 }
 
-fn set_window_size(window: Single<&mut Window>, mut window_size: ResMut<WindowSize>) {
-    window_size.0 = Vec2::new(window.resolution.width(), window.resolution.height());
+/// Clear everything and put everything to its start state
+fn teardown_game(
+    mut commands: Commands,
+    to_remove: Query<Entity, Or<(With<Bird>, With<Pipe>, With<PipeMarker>)>>,
+    game_ui: Single<Entity, With<OnGameScreen>>,
+) {
+    // Remove any entities left over from the previous game (if any)
+    for ent in to_remove {
+        commands.entity(ent).despawn();
+    }
+
+    let mut ent = commands.entity(*game_ui);
+    ent.despawn_related::<Children>();
+    ent.despawn();
 }
 
 /// Flap on a spacebar or left mouse button press
@@ -257,14 +392,14 @@ fn apply_velocity(mut query: Query<(&mut Transform, &Velocity)>, time: Res<Time>
 
 /// Check for collision with the borders of the window and the pipes
 fn check_collisions(
-    mut collision_events: EventWriter<CollisionEvent>,
+    mut next_state: ResMut<NextState<State>>,
     bird: Single<&Transform, With<Bird>>,
     pipes: Query<&Transform, With<Pipe>>,
-    window_size: Res<WindowSize>,
+    window: Single<&Window>,
     settings: Res<Settings>,
 ) {
-    if bird.translation.y.abs() > window_size.y / 2. {
-        collision_events.write_default();
+    if bird.translation.y.abs() + settings.bird_size / 2. > window.resolution.height() / 2. {
+        next_state.set(State::GameOver);
         return;
     }
 
@@ -272,7 +407,7 @@ fn check_collisions(
     for pipe in pipes {
         let pipe_collider = Aabb2d::new(pipe.translation.truncate(), settings.pipe_size / 2.);
         if bird_collider.intersects(&pipe_collider) {
-            collision_events.write_default();
+            next_state.set(State::GameOver);
             return;
         }
     }
@@ -296,7 +431,7 @@ fn spawn_pipe(
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<ColorMaterial>>,
-    window_size: Res<WindowSize>,
+    window: Single<&Window>,
     settings: Res<Settings>,
 ) {
     if events.is_empty() {
@@ -314,7 +449,7 @@ fn spawn_pipe(
 
     let pipe_offset = size.y / 2. + settings.gap_height / 2.;
 
-    let pipe_location = window_size.x / 2. + size.x / 2.;
+    let pipe_location = window.resolution.width() / 2. + size.x / 2.;
 
     // We first spawn in invisible marker that will increase the score once
     // it passes the bird position and then despawns. This assures that each
@@ -325,7 +460,7 @@ fn spawn_pipe(
         Velocity(Vec2::new(-settings.pipe_speed, 0.)),
     ));
 
-    // bottom pipe
+    // Spawn the bottom pipe
     commands.spawn((
         Pipe,
         Mesh2d(shape.clone()),
@@ -334,7 +469,7 @@ fn spawn_pipe(
         Velocity(Vec2::new(-settings.pipe_speed, 0.)),
     ));
 
-    // top pipe
+    // Spawn the top pipe
     commands.spawn((
         Pipe,
         Mesh2d(shape),
@@ -367,14 +502,14 @@ fn increase_score(
 fn remove_pipes(
     mut commands: Commands,
     mut query: Query<(Entity, &mut Transform), With<Pipe>>,
-    window_size: Res<WindowSize>,
+    window: Single<&Window>,
     settings: Res<Settings>,
 ) {
     for (entity, transform) in &mut query {
         // The entire pipe needs to have left the screen, not just its origin,
         // so we check that the right side of the pipe is off screen.
         let right_side_of_pipe = transform.translation.x + settings.pipe_size.x / 2.;
-        if right_side_of_pipe < -window_size.x / 2. {
+        if right_side_of_pipe < -window.resolution.width() / 2. {
             commands.entity(entity).despawn();
         }
     }