add game over screen

Author: it-me-joda

src/game/audio/sfx.rs

@@ -14,6 +14,7 @@ pub(super) fn plugin(app: &mut App) {
     app.insert_resource(SfxPlaying { states: vec![] });
     app.observe(play_looping_sfx);
     app.observe(stop_looping_sfx);
+    app.observe(stop_all_looping_sfx);
 }
 
 #[derive(Resource)]
@@ -112,6 +113,30 @@ fn stop_looping_sfx(
     }
 }
 
+fn stop_all_looping_sfx(
+    _trigger: Trigger<StopAllLoopingSfx>,
+    mut commands: Commands,
+    audio: Query<(Entity, &LoopingSfx)>,
+    mut sfx_playing: ResMut<SfxPlaying>,
+) {
+    let mut s = sfx_playing.states.clone();
+    let states = sfx_playing.states.iter_mut();
+
+    for (sfx_key, playing) in states {
+        *playing = false;
+
+        for (entity, sfx) in audio.iter() {
+            if sfx == &LoopingSfx(*sfx_key) {
+                s.retain(|(key, _)| *key != *sfx_key);
+                let e = commands.get_entity(entity);
+                if let Some(e) = e {
+                    e.despawn_recursive();
+                }
+            }
+        }
+    }
+}
+
 fn play_sfx(
     trigger: Trigger<PlaySfx>,
     mut commands: Commands,
@@ -147,6 +172,9 @@ pub enum StopLoopingSfx {
     Key(SfxKey),
 }
 
+#[derive(Event)]
+pub struct StopAllLoopingSfx;
+
 fn random_step() -> SfxKey {
     [SfxKey::Step1, SfxKey::Step2, SfxKey::Step3, SfxKey::Step4]
         .choose(&mut rand::thread_rng())

src/game/movement.rs

@@ -10,7 +10,10 @@ use super::{
     audio::sfx::PlaySfx,
     spawn::clock::{Clock, ClockController, Interactable, Positions},
 };
-use crate::{screen::Screen, AppSet};
+use crate::{
+    screen::{PlayingState, Screen},
+    AppSet,
+};
 
 pub(super) fn plugin(app: &mut App) {
     // Record directional input as movement controls.
@@ -19,7 +22,8 @@ pub(super) fn plugin(app: &mut App) {
         Update,
         movement
             .in_set(AppSet::RecordInput)
-            .run_if(in_state(Screen::Playing)),
+            .run_if(in_state(Screen::Playing))
+            .run_if(in_state(PlayingState::Playing)),
     );
 }
 

src/game/spawn/clock.rs

@@ -5,11 +5,11 @@ use crate::{
         assets::{HandleMap, ImageKey, SfxKey},
         audio::sfx::{PlayLoopingSfx, PlaySfx, StopLoopingSfx},
     },
-    screen::Screen,
+    screen::{PlayingState, Screen},
     AppSet,
 };
 
-use super::level::Score;
+use super::level::{Score, Scoresource};
 
 pub(super) fn plugin(app: &mut App) {
     app.observe(spawn_interact_clock);
@@ -19,19 +19,22 @@ pub(super) fn plugin(app: &mut App) {
         (tick_clocks, score_clocks)
             .chain()
             .in_set(AppSet::FixedUpdate)
-            .run_if(in_state(Screen::Playing)),
+            .run_if(in_state(Screen::Playing))
+            .run_if(in_state(PlayingState::Playing)),
     );
     app.add_systems(
         Update,
         record_clock_controller
             .in_set(AppSet::RecordInput)
-            .run_if(in_state(Screen::Playing)),
+            .run_if(in_state(Screen::Playing))
+            .run_if(in_state(PlayingState::Playing)),
     );
     app.add_systems(
         FixedUpdate,
         apply_clock_control
             .in_set(AppSet::Update)
-            .run_if(in_state(Screen::Playing)),
+            .run_if(in_state(Screen::Playing))
+            .run_if(in_state(PlayingState::Playing)),
     );
     app.insert_resource(Positions {
         clock_spawn: Vec2::new(-550.0, -185.0),
@@ -299,6 +302,7 @@ fn score_clocks(
     mut score: Query<(&mut Score, &mut Text)>,
     clocks: Query<(&Clock, &Children)>,
     clock_children: Query<(&Transform, &ClockHandType)>,
+    mut scoresource: ResMut<Scoresource>,
 ) {
     let main = clocks.iter().find(|(clock, _)| clock.is_main).unwrap();
     let main_rotations = get_clock_rotations(main.1, &clock_children);
@@ -352,6 +356,7 @@ fn score_clocks(
         _ => {}
     }
     text.sections[0].value = format!("{:.0}", score.0);
+    scoresource.0 = score.0;
 }
 
 struct ClockRotations {
@@ -511,7 +516,7 @@ fn spawn_interact_clock(
                 SpriteBundle {
                     texture: image_handles[&ImageKey::ClockMinute].clone_weak(),
                     transform: Transform {
-                        translation: Vec3::new(0.0, 0.0, 400.0),
+                        translation: Vec3::new(0.0, 0.0, 350.0),
                         ..default()
                     },
                     sprite: Sprite {

src/game/spawn/level.rs

@@ -4,7 +4,7 @@ use bevy::prelude::*;
 
 use crate::{
     game::assets::{HandleMap, ImageKey},
-    screen::Screen,
+    screen::{PlayingState, Screen},
 };
 
 use super::clock::{Positions, SpawnClock, SpawnMainClock};
@@ -18,6 +18,8 @@ pub(super) fn plugin(app: &mut App) {
     app.observe(spawn_clock_table);
     app.observe(spawn_oil_table);
     app.observe(spawn_background);
+
+    app.insert_resource(Scoresource(0.0));
 }
 
 #[derive(Event, Debug)]
@@ -41,6 +43,9 @@ pub struct SpawnOilTable;
 #[derive(Component)]
 pub struct Score(pub f32);
 
+#[derive(Resource)]
+pub struct Scoresource(pub f32);
+
 #[derive(Event, Debug)]
 pub struct SpawnBackground;
 
@@ -63,7 +68,11 @@ fn spawn_background(
     });
 }
 
-fn spawn_level(_trigger: Trigger<SpawnLevel>, mut commands: Commands) {
+fn spawn_level(
+    _trigger: Trigger<SpawnLevel>,
+    mut commands: Commands,
+    mut scoresource: ResMut<Scoresource>,
+) {
     commands.trigger(SpawnBackground);
     commands.trigger(SpawnPlayer);
     commands.trigger(SpawnTable);
@@ -73,6 +82,7 @@ fn spawn_level(_trigger: Trigger<SpawnLevel>, mut commands: Commands) {
     commands.trigger(SpawnScore);
     commands.trigger(SpawnClockTable);
     commands.trigger(SpawnOilTable);
+    scoresource.0 = 0.0;
 }
 
 fn spawn_table(

src/game/spawn/player.rs

@@ -6,16 +6,26 @@ use crate::{
         audio::sfx::{PlayLoopingSfx, StopLoopingSfx},
         movement::MovementController,
     },
-    screen::Screen,
+    screen::{PlayingState, Screen},
 };
 
 use super::clock::ClockController;
 
 pub(super) fn plugin(app: &mut App) {
     app.observe(spawn_player);
     app.register_type::<Player>();
-    app.add_systems(Update, oil_leak.run_if(in_state(Screen::Playing)));
-    app.add_systems(Update, oil_drink.run_if(in_state(Screen::Playing)));
+    app.add_systems(
+        Update,
+        oil_leak
+            .run_if(in_state(Screen::Playing))
+            .run_if(in_state(PlayingState::Playing)),
+    );
+    app.add_systems(
+        Update,
+        oil_drink
+            .run_if(in_state(Screen::Playing))
+            .run_if(in_state(PlayingState::Playing)),
+    );
 }
 
 #[derive(Event, Debug)]
@@ -53,11 +63,13 @@ fn oil_leak(
     mut query: Query<(&mut Handle<Image>, &mut Sprite), With<OilMeter>>,
     time: Res<Time>,
     images: Res<HandleMap<ImageKey>>,
+    mut next_state: ResMut<NextState<PlayingState>>,
 ) {
     let mut controller = controller.single_mut();
     controller.oil_level -= time.delta_seconds() * controller.oil_leak;
     if controller.oil_level <= 0.0 {
         println!("Game over!");
+        next_state.set(PlayingState::GameOver);
         return;
     }
     controller.oil_leak += time.delta_seconds() * 0.01;

src/screen/mod.rs

@@ -31,3 +31,10 @@ pub enum Screen {
     Credits,
     Playing,
 }
+
+#[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
+pub enum PlayingState {
+    Playing,
+    GameOver,
+    Disabled,
+}