collectables per wave

src/core/collectible.rs

@@ -21,12 +21,11 @@ pub enum CollectableType {
 #[require(SphereCollider, Sprite, DispawnOnGameOver)]
 pub struct Collectable(CollectableType);
 
-// Not a system.
 pub fn collectable_spawn(
     commands: &mut Commands,
     asset_server: &Res<AssetServer>,
     collectable_type: CollectableType,
-    pos: Vec3,
+    pos: Vec2,
 ) {
     let asset_name = ASSETS_NAME[collectable_type as usize];
     let asset_path = Path::new("sprites").join(asset_name);
@@ -34,16 +33,11 @@ pub fn collectable_spawn(
     commands.spawn((
         Collectable(collectable_type),
         SphereCollider::new(COLLECTABLE_COLLIDER_RADIUS),
-        Transform::from_translation(pos).with_scale(Vec3::splat(5.0)),
+        Transform::from_translation(pos.extend(0.0)).with_scale(Vec3::splat(2.5)),
         sprite,
     ));
 }
 
-pub struct CollectableSpawner;
-pub fn collectable_spawner_init(mut commands: Commands, asset_server: Res<AssetServer>) {
-    collectable_spawn(&mut commands, &asset_server, CollectableType::NewKirby, Vec3::new(250.0, 250.0, 0.0));
-}
-
 pub fn collectable_actions_system(
     mut commands: Commands,
     mut kirby_query: Query<(&mut Kirby, &SphereCollider, &Transform)>,
@@ -110,8 +104,6 @@ pub struct CollectablePlugin;
 
 impl Plugin for CollectablePlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(OnEnter(GameState::Starting), collectable_spawner_init.in_set(GameStartupSet))
+        app.add_systems(FixedUpdate, collectable_actions_system).add_systems(Update, kirby_spawn_timer);
-            .add_systems(FixedUpdate, collectable_actions_system)
-            .add_systems(Update, kirby_spawn_timer);
     }
 }

src/core/game_state.rs

@@ -3,12 +3,12 @@ use bevy::{ecs::system::SystemParam, prelude::*};
 use crate::core::{kirby::Kirby, wave::BubbleWaves};
 
 #[derive(Event)]
-struct EndGameEvent {
+pub struct EndGameEvent {
     pub reason: EndGameReason,
 }
 
 #[derive(Clone, Copy, Debug)]
-enum EndGameReason {
+pub enum EndGameReason {
     Die,
     Victory,
 }

src/core/wave.rs

@@ -6,7 +6,8 @@ use rand::distr::slice::Empty;
 use crate::{
     core::{
         bubble::{Bubble, bubble_spawn_wave},
-        game_state::Resetable,
+        collectible::{CollectableType, collectable_spawn},
+        game_state::{EndGameEvent, EndGameReason, Resetable},
         kirby::Kirby,
         life::Life,
     },
@@ -56,11 +57,12 @@ const GREEN_BUBBLE: BubbleType = BubbleType {
 #[derive(Resource)]
 pub struct BubbleWaves {
     waves: Vec<Vec<BubbleSplash>>,
+    collectables: Vec<Vec<(CollectableType, Vec2)>>,
     pub current_wave: usize,
 }
 
 fn get_bubble_waves() -> BubbleWaves {
-    BubbleWaves {
+    let return_thing = BubbleWaves {
         waves: vec![
             vec![BubbleSplash::new(NORMAL_BUBBLE, RIGHT, 10.0, 10)],
             vec![BubbleSplash::new(NORMAL_BUBBLE, RIGHT, 10.0, 10), BubbleSplash::new(NORMAL_BUBBLE, TOP, 10.0, 10)],
@@ -76,8 +78,17 @@ fn get_bubble_waves() -> BubbleWaves {
                 BubbleSplash::new(RED_BUBBLE, LEFT, 10.0, 100),
             ],
         ],
+        collectables: vec![
+            vec![],
+            vec![(CollectableType::NewKirby, LEFT)],
+            vec![(CollectableType::SpeedBoost, BOTTOM)],
+            vec![(CollectableType::ShieldBoost, BOTTOM)],
+            vec![],
+        ],
         current_wave: 0,
-    }
+    };
+    assert!(return_thing.waves.len() == return_thing.collectables.len());
+    return return_thing;
 }
 
 impl Resetable for BubbleWaves {
@@ -92,11 +103,20 @@ fn no_ennemy_left(bubble_query: Query<(), With<Bubble>>) -> bool {
 
 fn change_wave(mut bubble_wave: ResMut<BubbleWaves>, mut commands: Commands, asset_server: Res<AssetServer>) {
     let max_bubble_wave = bubble_wave.waves.len();
-    bubble_wave.current_wave += 1;
     if bubble_wave.current_wave >= max_bubble_wave {
-        panic!("GG you win");
+        commands.trigger(EndGameEvent { reason: EndGameReason::Victory });
+        return;
     }
-    bubble_spawn_wave(&mut commands, &asset_server, bubble_wave.waves[bubble_wave.current_wave].as_slice());
+
+    let wave = &bubble_wave.waves[bubble_wave.current_wave];
+    let collectables = &bubble_wave.collectables[bubble_wave.current_wave];
+
+    bubble_spawn_wave(&mut commands, &asset_server, wave.as_slice());
+    for (collectable_type, collectable_pos) in collectables {
+        collectable_spawn(&mut commands, &asset_server, *collectable_type, *collectable_pos);
+    }
+
+    bubble_wave.current_wave += 1;
 }
 
 fn heal_kirby(query: Query<&mut Life, With<Kirby>>) {