Update to Bevy 0.17 rc2

Cargo.toml

@@ -6,7 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.16.1"
+bevy = "0.17.0-rc.2"
 fastrand = "2.1.1" # ref: https://github.com/bevyengine/bevy/pull/3992
 
 [workspace]

src/game/ai/autofire.rs

@@ -11,23 +11,23 @@ pub struct AutoFirePlugin;
 // Plugin definition
 impl Plugin for AutoFirePlugin {
     fn build(&self, app: &mut App) {
-        app.add_event::<WeaponFiredEvent>()
-            .add_event::<CollisionEvent>()
+        app.add_message::<WeaponFiredEvent>()
+            .add_message::<CollisionEvent>()
             .add_systems(Update, fire_controller.run_if(in_state(AppState::InGame)));
     }
 }
 
 // Fire controller system
 pub fn fire_controller(
     time: Res<Time>,
-    mut bullet_fired_event: EventWriter<WeaponFiredEvent>,
-    mut audio_event: EventWriter<AudioEvent>,
+    mut bullet_fired_event: MessageWriter<WeaponFiredEvent>,
+    mut audio_event: MessageWriter<AudioEvent>,
     mut query: Query<(&Transform, &Collider, &mut Weapon), With<AutoFire>>,
 ) {
     for (transform, collider, mut weapon) in &mut query {
         // ref: https://bevy-cheatbook.github.io/features/time.html
         weapon.cooldown_timer.tick(time.delta());
-        if weapon.cooldown_timer.finished() {
+        if weapon.cooldown_timer.is_finished() {
             let event = WeaponFiredEvent {
                 bullet_type: weapon.bullet_type.clone(),
                 translation: Vec2::new(

src/game/audio/mod.rs

@@ -22,7 +22,7 @@ pub struct AudioPlugin;
 impl Plugin for AudioPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(Startup, setup_resources)
-            .add_event::<AudioEvent>()
+            .add_message::<AudioEvent>()
             .add_systems(Update, on_audio_event);
     }
 }
@@ -45,7 +45,7 @@ pub fn setup_resources(mut commands: Commands, asset_server: ResMut<AssetServer>
     commands.insert_resource(audio_clip_assets);
 }
 
-fn on_audio_event(mut commands: Commands, mut audio_events: EventReader<AudioEvent>) {
+fn on_audio_event(mut commands: Commands, mut audio_events: MessageReader<AudioEvent>) {
     if audio_events.is_empty() {
         return;
     }

src/game/background.rs

@@ -24,7 +24,7 @@ pub fn setup_lights(mut commands: Commands) {
     // Directional Light
     commands.spawn((
         DirectionalLight {
-            illuminance: 25000.0,
+            illuminance: 10000.0,
             color: Color::WHITE,
             ..default()
         },

src/game/collisions.rs

@@ -3,28 +3,28 @@ use crate::game::events::*;
 use bevy::prelude::*;
 use std::cmp::max;
 
-#[derive(Default, Event)]
+#[derive(Default, Message)]
 pub struct CollisionEvent;
 
 pub struct CollisionPlugin;
 
 impl Plugin for CollisionPlugin {
     fn build(&self, app: &mut App) {
-        app.add_event::<WeaponFiredEvent>()
-            .add_event::<CollisionEvent>()
-            .add_event::<PlayerDeathEvent>()
+        app.add_message::<WeaponFiredEvent>()
+            .add_message::<CollisionEvent>()
+            .add_message::<PlayerDeathEvent>()
             .add_systems(FixedUpdate, check_collisions);
     }
 }
 
 pub fn check_collisions(
     mut commands: Commands,
-    mut audio_event: EventWriter<AudioEvent>,
-    mut collision_event: EventWriter<CollisionEvent>,
-    mut camera_shake_event: EventWriter<CameraShakeEvent>,
-    mut explosion_event: EventWriter<ExplosionEvent>,
-    mut player_death_event: EventWriter<PlayerDeathEvent>,
-    mut score_event: EventWriter<ScoreEvent>,
+    mut audio_event: MessageWriter<AudioEvent>,
+    mut collision_event: MessageWriter<CollisionEvent>,
+    mut camera_shake_event: MessageWriter<CameraShakeEvent>,
+    mut explosion_event: MessageWriter<ExplosionEvent>,
+    mut player_death_event: MessageWriter<PlayerDeathEvent>,
+    mut score_event: MessageWriter<ScoreEvent>,
     a_query: Query<(Entity, &Transform, &Collider, Option<&Bullet>)>,
     mut b_query: Query<
         (
@@ -74,7 +74,7 @@ pub fn check_collisions(
 
                 // Play damage sound
                 if a_collider.damage > 0 {
-                    //audio_event.send(AudioEvent {
+                    //audio_event.write(AudioEvent {
                     //    clip: b_health.damage_sound.clone(),
                     //});
                 }

src/game/despawner.rs

@@ -24,7 +24,7 @@ fn timed_despawn(
 ) {
     for (entity, mut despawner) in &mut query {
         despawner.timer.tick(time.delta());
-        if despawner.timer.finished() {
+        if despawner.timer.is_finished() {
             commands.entity(entity).despawn();
         }
     }
@@ -44,7 +44,7 @@ fn timed_oob_despawn(
             || pos.y < BOTTOM_WALL
         {
             despawner.timer.tick(time.delta());
-            if despawner.timer.finished() {
+            if despawner.timer.is_finished() {
                 commands.entity(entity).despawn();
             }
         } else {

src/game/events.rs

@@ -1,37 +1,37 @@
 use super::actor::bullet::BulletType;
 use bevy::prelude::*;
 
-#[derive(Event)]
+#[derive(Message)]
 pub struct LevelEndEvent;
 
-#[derive(Default, Event)]
+#[derive(Default, Message)]
 pub struct PlayerDeathEvent;
 
-#[derive(Event)]
+#[derive(Message)]
 pub struct ScoreEvent {
     pub increment: i32,
 }
 
-#[derive(Event)]
+#[derive(Message)]
 pub struct AudioEvent {
     pub clip: Handle<AudioSource>,
 }
 
-#[derive(Event)]
+#[derive(Message)]
 pub struct WeaponFiredEvent {
     pub bullet_type: BulletType,
     pub translation: Vec2,
     pub rotation: Quat,
     pub hitmask: u8,
 }
 
-#[derive(Event)]
+#[derive(Message)]
 pub struct ExplosionEvent {
     pub position: Vec3,
     pub lifetime: f32,
 }
 
-#[derive(Event)]
+#[derive(Message)]
 pub struct CameraShakeEvent {
     pub magnitude: f32,
     pub duration_secs: f32,

src/game/levels/mod.rs

@@ -25,7 +25,7 @@ pub struct LevelPlugin;
 
 impl Plugin for LevelPlugin {
     fn build(&self, app: &mut App) {
-        app.add_event::<LevelEndEvent>()
+        app.add_message::<LevelEndEvent>()
             .add_systems(OnEnter(AppState::InGame), setup_level)
             .add_systems(OnExit(AppState::InGame), despawn_all::<AiActorSpawner>)
             .add_systems(
@@ -58,7 +58,7 @@ fn level_periodic_spawn(
     time: Res<Time>,
     models: Res<ModelsAssets>,
     audio_clips: Res<AudioClipAssets>,
-    mut level_end_event: EventWriter<LevelEndEvent>,
+    mut level_end_event: MessageWriter<LevelEndEvent>,
     mut query: Query<&mut AiActorSpawner, With<AiActorSpawner>>,
 ) {
     // Run logic for each Spawner Component
@@ -89,7 +89,7 @@ fn level_periodic_spawn(
             }
         }
 
-        if spawner.frequency_timer.finished() {
+        if spawner.frequency_timer.is_finished() {
             let spawn_info = &spawner.spawn_infos[spawner.index as usize];
 
             spawn_from_spawn_info(&mut commands, spawn_info, &audio_clips, &models);
@@ -112,7 +112,7 @@ fn spawn_from_spawn_info(
 }
 
 fn level_ender(
-    mut events: EventReader<LevelEndEvent>,
+    mut events: MessageReader<LevelEndEvent>,
     mut game_state: ResMut<NextState<AppState>>,
     mut menu_state: ResMut<NextState<MenuState>>,
 ) {

src/game/particles/mod.rs

@@ -22,7 +22,7 @@ impl Plugin for BasicParticlesPlugin{
 fn update_emitter(
     time: Res<Time>,
     mut commands: Commands,
-    mut query: Query<(Entity, &mut BasicParticleEmitter)>
+    mut query: Query<(Entity, &mut BasicParticleEmitter)>,
 ) {
     for (entity, emitter) in &mut query{
         emitter.lifetime_timer.tick(time.delta());

src/game/player.rs

@@ -20,10 +20,10 @@ pub struct PlayerPlugin;
 impl Plugin for PlayerPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(Startup, setup_resources)
-            .add_event::<WeaponFiredEvent>()
-            .add_event::<CollisionEvent>()
-            .add_event::<AudioEvent>()
-            .add_event::<PlayerDeathEvent>()
+            .add_message::<WeaponFiredEvent>()
+            .add_message::<CollisionEvent>()
+            .add_message::<AudioEvent>()
+            .add_message::<PlayerDeathEvent>()
             .add_systems(OnEnter(AppState::InGame), spawn_player)
             .add_systems(
                 Update,
@@ -122,8 +122,8 @@ pub fn reflect_from_wall(
 pub fn fire_controller(
     time: Res<Time>,
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut bullet_fired_event: EventWriter<WeaponFiredEvent>,
-    mut audio_event: EventWriter<AudioEvent>,
+    mut bullet_fired_event: MessageWriter<WeaponFiredEvent>,
+    mut audio_event: MessageWriter<AudioEvent>,
     mut query: Query<(&Transform, &mut Weapon, &Collider), With<Player>>,
 ) {
     for (transform, mut weapon, collider) in &mut query {
@@ -158,8 +158,8 @@ fn send_projectile_spawn_event(
     transform: &Transform,
     collider: &Collider,
     weapon: &Weapon,
-    bullet_fired_event: &mut EventWriter<WeaponFiredEvent>,
-    audio_event: &mut EventWriter<AudioEvent>,
+    bullet_fired_event: &mut MessageWriter<WeaponFiredEvent>,
+    audio_event: &mut MessageWriter<AudioEvent>,
 ) {
     let event = WeaponFiredEvent {
         bullet_type: weapon.bullet_type.clone(),
@@ -177,7 +177,7 @@ fn send_projectile_spawn_event(
 }
 
 fn on_player_death(
-    mut death_events: EventReader<PlayerDeathEvent>,
+    mut death_events: MessageReader<PlayerDeathEvent>,
     mut menu_state: ResMut<NextState<MenuState>>,
     mut game_state: ResMut<NextState<AppState>>,
 ) {

src/game/ui/mod.rs

@@ -13,8 +13,8 @@ pub struct UiPlugin;
 impl Plugin for UiPlugin {
     fn build(&self, app: &mut App) {
         app.insert_resource(Scoreboard { score: 0 })
-            .add_event::<ScoreEvent>()
-            .add_event::<AudioEvent>()
+            .add_message::<ScoreEvent>()
+            .add_message::<AudioEvent>()
             .add_systems(OnEnter(AppState::InGame), setup_scoreboard)
             .add_systems(OnExit(AppState::InGame), despawn_all::<PlayerScoreBoard>)
             .add_systems(Update, on_score_event);
@@ -47,15 +47,20 @@ fn setup_scoreboard(
 }
 
 fn on_score_event(
-    mut score_events: EventReader<ScoreEvent>,
+    mut score_events: MessageReader<ScoreEvent>,
     mut scoreboard: ResMut<Scoreboard>,
     mut text_query: Query<&mut Text, With<PlayerScoreBoard>>,
 ) {
+    let mut score_increase = 0;
     for score_event in score_events.read() {
-        scoreboard.score += score_event.increment;
-        if let Ok(mut player_score_text) = text_query.single_mut() {
-            **player_score_text = format!("SCORE: {}", scoreboard.score);
+        score_increase += score_event.increment;
+    }
+
+    if score_increase != 0 {
+        scoreboard.score += score_increase;
+        if let Some(mut player_score_text) = text_query.iter_mut().next() {
+            player_score_text.0 = format!("SCORE: {}", scoreboard.score);
         }
+        score_events.clear();
     }
-    score_events.clear(); // Clear buffer to prevent double registration of scoring events (???)
 }

src/game/vfx/mod.rs

@@ -13,15 +13,15 @@ pub struct VfxPlugin;
 
 impl Plugin for VfxPlugin {
     fn build(&self, app: &mut App) {
-        app.add_event::<CameraShakeEvent>()
-            .add_event::<ExplosionEvent>()
+        app.add_message::<CameraShakeEvent>()
+            .add_message::<ExplosionEvent>()
             .add_systems(Update, shake_camera);
     }
 }
 
 fn shake_camera(
     time: Res<Time>,
-    mut shake_events: EventReader<CameraShakeEvent>,
+    mut shake_events: MessageReader<CameraShakeEvent>,
     mut camera_query: Query<(&mut CameraShaker, &mut Transform), With<Camera>>,
 ) {
     for (mut shaker, mut t) in &mut camera_query {
@@ -53,7 +53,7 @@ fn shake_camera(
 }
 
 fn on_explosion_event(
-    mut events: EventReader<ExplosionEvent>,
+    mut events: MessageReader<ExplosionEvent>,
     mut commands: Commands,
     asset_server: Res<AssetServer>,
 ) {

src/game/weapon/mod.rs

@@ -1,5 +1,4 @@
-use bevy::pbr::{NotShadowCaster, NotShadowReceiver};
-use bevy::prelude::*;
+use bevy::{light::{NotShadowCaster, NotShadowReceiver}, prelude::*};
 
 use super::super::AppState;
 use super::actor::bullet::*;
@@ -10,15 +9,15 @@ pub struct WeaponPlugin;
 
 impl Plugin for WeaponPlugin {
     fn build(&self, app: &mut App) {
-        app.add_event::<WeaponFiredEvent>()
+        app.add_message::<WeaponFiredEvent>()
             .add_systems(Update, on_bullet_fired.run_if(in_state(AppState::InGame)));
     }
 }
 
 pub fn on_bullet_fired(
     mut commands: Commands,
     models: Res<ModelsAssets>,
-    mut bullet_fired_events: EventReader<WeaponFiredEvent>,
+    mut bullet_fired_events: MessageReader<WeaponFiredEvent>,
 ) {
     for event in bullet_fired_events.read() {
         spawn_bullet(&mut commands, &models, event)

src/main.rs

@@ -1,4 +1,4 @@
-use bevy::prelude::*;
+use bevy::{prelude::*, window::WindowResolution};
 //use bevy_hanabi::prelude::*;
 mod menus;
 use menus::MenuPlugin;
@@ -24,7 +24,10 @@ fn main() {
         .add_plugins(DefaultPlugins.set(WindowPlugin {
             primary_window: Some(Window {
                 title: "StarRust".to_string(),
-                resolution: (SCREEN_WIDTH, SCREEN_HEIGHT).into(),
+                resolution: WindowResolution::new(
+                    SCREEN_WIDTH as u32,
+                    SCREEN_HEIGHT as u32,
+                ),
                 ..default()
             }),
             ..default()

src/menus/mod.rs

@@ -101,7 +101,7 @@ fn menu_action(
         (&Interaction, &MenuButtonAction),
         (Changed<Interaction>, With<Button>),
     >,
-    mut app_exit_events: EventWriter<AppExit>,
+    mut app_exit_events: MessageWriter<AppExit>,
     mut menu_state: ResMut<NextState<MenuState>>,
     mut game_state: ResMut<NextState<AppState>>,
 ) {

src/utils.rs

@@ -1,4 +1,5 @@
 use bevy::prelude::*;
+
 // Utility function
 pub fn despawn_all<T: Component>(to_despawn: Query<Entity, With<T>>, mut commands: Commands) {
     for entity in &to_despawn {