warning signs, timer

src/core/wave.rs

@@ -1,19 +1,31 @@
-use std::thread::panicking;
+use std::{thread::panicking, time::Duration};
 
-use bevy::prelude::*;
+use bevy::{ecs::system::lifetimeless::SCommands, prelude::*};
 use rand::distr::slice::Empty;
 
 use crate::{
     core::{
         bubble::{Bubble, bubble_spawn_wave},
-        collectible::{CollectableType, collectable_spawn},
-        game_state::{EndGameEvent, EndGameReason, Resetable},
+        collectible::{COLLECTABLE_SCALE, CollectableType, collectable_spawn},
+        game_state::{DispawnOnGameOver, EndGameEvent, EndGameReason, Resetable},
         kirby::Kirby,
         life::Life,
     },
     map::map::{BOTTOM, LEFT, RIGHT, TOP},
 };
 
+#[derive(Event)]
+pub struct NextWaveEvent;
+
+#[derive(Component)]
+#[require(DispawnOnGameOver)]
+pub struct NextWaveTimer {
+    timer: Timer,
+}
+
+#[derive(Event)]
+struct NextWaveTimerTimeout;
+
 pub struct BubbleType {
     pub color: Color,
     pub move_force: f32,
@@ -97,17 +109,81 @@ impl Resetable for BubbleWaves {
     }
 }
 
+#[derive(Resource, Default)] // Default is false
+pub struct EnnemyWaveLock(bool);
+
+impl Resetable for EnnemyWaveLock {
+    fn reset(&mut self) {
+        *self = EnnemyWaveLock::default()
+    }
+}
+
 fn no_ennemy_left(bubble_query: Query<(), With<Bubble>>) -> bool {
     bubble_query.is_empty()
 }
 
-fn change_wave(mut bubble_wave: ResMut<BubbleWaves>, mut commands: Commands, asset_server: Res<AssetServer>) {
+#[derive(Component)]
+#[require(Sprite, Transform, DispawnOnGameOver)]
+struct WarningSign;
+
+fn change_wave(
+    mut lock: ResMut<EnnemyWaveLock>,
+    bubble_wave: Res<BubbleWaves>,
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+) {
+    // Beetwen moment where all ennemies are killed and NextWaveTimer trigger the spawn of the new ennemy
+    // there is some time, and change_wave will be called every frame during this instance
+    // that's why there is an ugly-ass lock
+    if lock.0 {
+        return;
+    }
+    lock.0 = true;
     let max_bubble_wave = bubble_wave.waves.len();
     if bubble_wave.current_wave >= max_bubble_wave {
         commands.trigger(EndGameEvent { reason: EndGameReason::Victory });
         return;
     }
+    let current_bubble_wave = &bubble_wave.waves[bubble_wave.current_wave];
+    for bubble_splash in current_bubble_wave {
+        commands.spawn((
+            WarningSign,
+            Sprite::from_image(asset_server.load("sprites/warning.png")),
+            Transform::from_translation(bubble_splash.center.extend(0.0)).with_scale(Vec3::splat(COLLECTABLE_SCALE)),
+        ));
+    }
 
+    println!("change wave");
+    commands.trigger(NextWaveEvent);
+    commands.spawn((NextWaveTimer { timer: Timer::new(Duration::from_secs(1), TimerMode::Once) },));
+}
+
+fn next_wave_timer_system(
+    next_wave_timer_query: Single<(&mut NextWaveTimer, Entity)>,
+    time: Res<Time>,
+    mut commands: Commands,
+) {
+    let (mut next_wave_timer, timer_id) = next_wave_timer_query.into_inner();
+    next_wave_timer.timer.tick(time.delta());
+    if next_wave_timer.timer.is_finished() {
+        commands.trigger(NextWaveTimerTimeout);
+        commands.entity(timer_id).despawn();
+    }
+}
+
+fn delete_warning_sign(_: On<NextWaveTimerTimeout>, mut commands: Commands, query: Query<Entity, With<WarningSign>>) {
+    for entity in query {
+        commands.entity(entity).despawn();
+    }
+}
+
+fn spawn_wave_ennemy(
+    _: On<NextWaveTimerTimeout>,
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut bubble_wave: ResMut<BubbleWaves>,
+    mut lock: ResMut<EnnemyWaveLock>,
+) {
     let wave = &bubble_wave.waves[bubble_wave.current_wave];
     let collectables = &bubble_wave.collectables[bubble_wave.current_wave];
 
@@ -115,8 +191,8 @@ fn change_wave(mut bubble_wave: ResMut<BubbleWaves>, mut commands: Commands, ass
     for (collectable_type, collectable_pos) in collectables {
         collectable_spawn(&mut commands, &asset_server, *collectable_type, *collectable_pos);
     }
-
     bubble_wave.current_wave += 1;
+    lock.0 = false; // Release lock, ennemy wave is spawnned
 }
 
 fn heal_kirby(query: Query<&mut Life, With<Kirby>>) {
@@ -129,6 +205,11 @@ pub struct WavePlugin;
 
 impl Plugin for WavePlugin {
     fn build(&self, app: &mut App) {
-        app.insert_resource(get_bubble_waves()).add_systems(Update, (change_wave, heal_kirby).run_if(no_ennemy_left));
+        app.insert_resource(get_bubble_waves())
+            .insert_resource(EnnemyWaveLock::default())
+            .add_systems(Update, (change_wave, heal_kirby).run_if(no_ennemy_left))
+            .add_systems(Update, next_wave_timer_system)
+            .add_observer(spawn_wave_ennemy)
+            .add_observer(delete_warning_sign);
     }
 }