Hook up a few sfx

Author: benfrankel

assets/audio/sfx/Level Up_1.ogg

@@ -1,4 +1,8 @@
 (
-    bpm: 122,
-    zeroth_beat: 0.1,
+    global_volume: 0.6,
+
+    music_bpm: 122,
+    music_zeroth_beat: 0.1,
+    music_volume: 0.7,
+    music_loop_end: 126.1,
 )

assets/audio/sfx/Level Up_1.wav

@@ -3,7 +3,9 @@
         "quarter_note": Projectile(
             name: "Quarter Note",
 
-            texture_path: "image/projectile/quarter_note.png",
+            texture: "image/projectile/quarter_note.png",
+            spawn_sfx: "audio/sfx/Projectile Hits Enemy.ogg",
+            spawn_sfx_volume: 0.5,
 
             lifetime: 1,
             radius: 3.0,
@@ -14,7 +16,9 @@
         "double_beat": Projectile(
             name: "Double Beat",
 
-            texture_path: "image/projectile/quarter_note.png",
+            texture: "image/projectile/quarter_note.png",
+            spawn_sfx: "audio/sfx/Projectile Hits Enemy.ogg",
+            spawn_sfx_volume: 0.5,
 
             lifetime: 2,
             radius: 3.0,

assets/audio/sfx/Projectile Hits Enemy.ogg

@@ -8,7 +8,6 @@ use serde::Serialize;
 use crate::core::UpdateSet;
 use crate::game::actor::faction::Faction;
 use crate::game::combat::projectile::projectile;
-use crate::game::GameLayer;
 use crate::util::prelude::*;
 
 pub(super) fn plugin(app: &mut App) {
@@ -31,7 +30,8 @@ pub struct Attack {
     /// The relative distance to spawn projectiles from.
     pub offset: f32,
     /// The key of the projectile to attack with.
-    pub projectile: Option<String>,
+    #[serde(rename = "projectile")]
+    pub projectile_key: Option<String>,
 }
 
 impl Configure for Attack {
@@ -48,7 +48,7 @@ impl Default for Attack {
             force: 1.0,
             color: Color::WHITE,
             offset: 5.0,
-            projectile: None,
+            projectile_key: None,
         }
     }
 }
@@ -63,24 +63,18 @@ fn apply_attack(
         &Faction,
     )>,
 ) {
-    for (attack, controller, gt, velocity, faction) in &attack_query {
+    for (attack, controller, gt, velocity, &faction) in &attack_query {
         if !controller.fire || controller.aim == Vec2::ZERO {
             continue;
         }
-        let projectile_key = c!(attack.projectile.as_ref());
+        let projectile_key = c!(attack.projectile_key.as_ref());
 
         let translation = gt.translation();
         // Spawn projectile at an initial distance away from attacker.
         let pos = translation.xy() + attack.offset * controller.aim;
         // Render projectile above attacker.
         let translation = pos.extend(translation.z + 2.0);
 
-        let mut target_layers = LayerMask::ALL;
-        // Projectiles cannot collide with each other.
-        target_layers.remove(GameLayer::Projectile);
-        // Projectiles cannot collide with their owner's layer.
-        target_layers.remove(faction.layer());
-
         // Projectiles get a boost if the actor is moving in the same direction.
         let aligned_speed = velocity
             .filter(|v| v.0 != Vec2::ZERO)
@@ -93,14 +87,12 @@ fn apply_attack(
         commands
             .spawn_with(projectile(
                 projectile_key,
+                faction,
                 attack.power,
                 attack.force * controller.aim * speed_force,
                 attack.color,
             ))
-            .insert((
-                Transform::from_translation(translation),
-                CollisionLayers::new(GameLayer::Projectile, target_layers),
-            ));
+            .insert(Transform::from_translation(translation));
     }
 }
 

assets/audio/sfx/Projectile Hits Enemy.wav

@@ -1,9 +1,11 @@
 use bevy::prelude::*;
+use bevy_kira_audio::prelude::*;
 
 use crate::core::UpdateSet;
 use crate::game::actor::level::xp::Xp;
 use crate::game::actor::level::Level;
 use crate::game::actor::level::LevelConfig;
+use crate::screen::playing::PlayingAssets;
 use crate::util::prelude::*;
 
 // TODO: System that enters level up menu on LevelUp event.
@@ -21,6 +23,9 @@ impl Configure for LevelUp {
         app.add_systems(
             Update,
             (
+                play_level_up_sfx
+                    .in_set(UpdateSet::Update)
+                    .run_if(on_event::<Self>()),
                 update_level_up_from_xp.in_set(UpdateSet::TriggerLevelUp),
                 // TODO: Only run if not in level up menu.
                 trigger_level_up.in_set(UpdateSet::TriggerLevelUp),
@@ -66,3 +71,7 @@ fn trigger_level_up(
         level_up_events.send(LevelUp(entity));
     }
 }
+
+fn play_level_up_sfx(audio: Res<Audio>, assets: Res<PlayingAssets>) {
+    audio.play(assets.sfx_level_up.clone()).with_volume(0.8);
+}

assets/audio/sfx/Projectile Hits Player-02.ogg

@@ -1,9 +1,12 @@
 pub mod music;
 
 use bevy::prelude::*;
+use bevy_kira_audio::prelude::*;
 use serde::Deserialize;
 use serde::Serialize;
 
+use crate::game::audio::music::MusicHandle;
+use crate::screen::playing::PlayingAssets;
 use crate::util::prelude::*;
 
 pub(super) fn plugin(app: &mut App) {
@@ -14,13 +17,38 @@ pub(super) fn plugin(app: &mut App) {
 
 #[derive(Asset, Reflect, Serialize, Deserialize)]
 pub struct AudioConfig {
+    pub global_volume: f64,
+
     /// The precise beats-per-minute of the music.
-    pub bpm: f64,
+    pub music_bpm: f64,
     /// The position (in seconds) of the zeroth beat.
-    pub zeroth_beat: f64,
+    pub music_zeroth_beat: f64,
+    pub music_volume: f64,
+    #[serde(default)]
+    pub music_loop_start: f64,
+    pub music_loop_end: f64,
 }
 
 impl Config for AudioConfig {
     const PATH: &'static str = "config/audio.ron";
     const EXTENSION: &'static str = "audio.ron";
+
+    fn on_load(&mut self, world: &mut World) {
+        world.resource::<Audio>().set_volume(self.global_volume);
+
+        if !world
+            .resource::<Assets<AudioInstance>>()
+            .contains(&world.resource::<MusicHandle>().0)
+        {
+            let music_handle = world
+                .resource::<Audio>()
+                .play(world.resource::<PlayingAssets>().music.clone())
+                .with_volume(self.music_volume)
+                .loop_from(self.music_loop_start)
+                .loop_until(self.music_loop_end)
+                .paused()
+                .handle();
+            world.resource_mut::<MusicHandle>().0 = music_handle;
+        }
+    }
 }

assets/audio/sfx/Projectile Hits Player-02.wav

@@ -5,7 +5,6 @@ use pyri_state::prelude::*;
 use crate::core::pause::Pause;
 use crate::core::UpdateSet;
 use crate::game::audio::AudioConfig;
-use crate::screen::playing::PlayingAssets;
 use crate::screen::Screen;
 use crate::util::prelude::*;
 
@@ -21,7 +20,6 @@ impl Configure for MusicHandle {
     fn configure(app: &mut App) {
         app.register_type::<Self>();
         app.init_resource::<Self>();
-        app.add_systems(Startup, spawn_music);
         app.add_systems(
             StateFlush,
             Pause.on_edge(
@@ -33,16 +31,6 @@ impl Configure for MusicHandle {
     }
 }
 
-fn spawn_music(mut commands: Commands, audio: Res<Audio>, assets: Res<PlayingAssets>) {
-    let handle = audio
-        .play(assets.music.clone())
-        .with_volume(0.9)
-        .loop_until(126.1)
-        .paused()
-        .handle();
-    commands.insert_resource(MusicHandle(handle));
-}
-
 pub fn start_music(
     music_handle: Res<MusicHandle>,
     mut audio_instances: ResMut<Assets<AudioInstance>>,
@@ -95,7 +83,8 @@ fn update_beat(
     let music = r!(audio_instances.get(&music_handle.0));
 
     let position = music.state().position().unwrap_or(0.0);
-    let real_beats = ((position - config.zeroth_beat) * config.bpm * 8.0 / 60.0) as usize;
+    let real_beats =
+        ((position - config.music_zeroth_beat) * config.music_bpm * 8.0 / 60.0) as usize;
 
     beat.this_tick = real_beats.saturating_sub(beat.total);
     beat.total = real_beats;

assets/audio/sfx/Restart_1.ogg

@@ -56,7 +56,7 @@ fn double_beat(mut attack_query: Query<(&mut Attack, &mut AttackController, &Dou
     for (mut attack, mut controller, double_beat) in &mut attack_query {
         attack.power = double_beat.0.power;
         attack.force = double_beat.0.force;
-        attack.projectile = double_beat.0.projectile.clone();
+        attack.projectile_key = double_beat.0.projectile_key.clone();
 
         controller.fire = true;
     }

assets/audio/sfx/Restart_1.wav

@@ -2,18 +2,22 @@ use std::time::Duration;
 
 use avian2d::prelude::*;
 use bevy::ecs::system::EntityCommand;
+use bevy::ecs::system::SystemState;
 use bevy::prelude::*;
 use bevy::utils::HashMap;
+use bevy_kira_audio::prelude::*;
 use bevy_tweening::*;
 use serde::Deserialize;
 use serde::Serialize;
 
+use crate::game::actor::faction::Faction;
 use crate::game::cleanup::DespawnOnHit;
 use crate::game::cleanup::DespawnOnTimer;
 use crate::game::cleanup::DespawnRadiusSq;
 use crate::game::combat::damage::HitboxDamage;
 use crate::game::combat::hit::Hitbox;
 use crate::game::combat::knockback::HitboxKnockback;
+use crate::game::GameLayer;
 use crate::game::GameRoot;
 use crate::util::prelude::*;
 
@@ -39,23 +43,38 @@ impl Config for ProjectileConfig {
 
         for projectile in self.projectiles.values_mut() {
             projectile.texture = asset_server.load(&projectile.texture_path);
+            if !projectile.spawn_sfx_path.is_empty() {
+                projectile.spawn_sfx = Some(asset_server.load(&projectile.spawn_sfx_path));
+            }
         }
     }
 
     fn is_ready(&self, asset_server: &AssetServer) -> bool {
         self.projectiles
             .values()
             .all(|x| asset_server.is_loaded_with_dependencies(&x.texture))
+            && self.projectiles.values().all(|x| {
+                !x.spawn_sfx
+                    .as_ref()
+                    .is_some_and(|x| !asset_server.is_loaded_with_dependencies(x))
+            })
     }
 }
 
-#[derive(Reflect, Serialize, Deserialize)]
+#[derive(Reflect, Serialize, Deserialize, Clone)]
 pub struct Projectile {
     pub name: String,
 
+    #[serde(rename = "texture")]
     pub texture_path: String,
     #[serde(skip)]
     pub texture: Handle<Image>,
+    #[serde(rename = "spawn_sfx", default)]
+    pub spawn_sfx_path: String,
+    #[serde(skip)]
+    pub spawn_sfx: Option<Handle<AudioSource>>,
+    #[serde(default = "one")]
+    pub spawn_sfx_volume: f64,
 
     /// Lifetime in seconds, not beats.
     pub lifetime: f32,
@@ -66,27 +85,46 @@ pub struct Projectile {
     pub knockback: f32,
 }
 
+fn one() -> f64 {
+    1.0
+}
+
 const FADE_SECS: f32 = 0.2;
 
 pub fn projectile(
     key: impl Into<String>,
+    faction: Faction,
     power: f32,
     force: Vec2,
     color: impl Into<Color>,
-) -> impl EntityCommand<World> {
+) -> impl EntityCommand {
     let key = key.into();
     let color = color.into();
 
-    move |mut entity: EntityWorldMut| {
-        let config_handle = entity.world().resource::<ConfigHandle<ProjectileConfig>>();
-        let config = r!(entity
-            .world()
-            .resource::<Assets<ProjectileConfig>>()
-            .get(&config_handle.0));
-        let projectile = r!(config.projectiles.get(&key));
-        let parent = entity.world().resource::<GameRoot>().projectiles;
+    move |entity: Entity, world: &mut World| {
+        let mut system_state =
+            SystemState::<(ConfigRef<ProjectileConfig>, Res<GameRoot>, Res<Audio>)>::new(world);
+        let (config, game_root, audio) = system_state.get(world);
+        let config = r!(config.get());
+        let projectile = r!(config.projectiles.get(&key)).clone();
+        let parent = game_root.projectiles;
+        let target_layers = {
+            let mut x = LayerMask::ALL;
+            // Projectiles cannot collide with each other.
+            x.remove(GameLayer::Projectile);
+            // Projectiles cannot collide with their owner's layer.
+            x.remove(faction.layer());
+            x
+        };
+
+        if let (Faction::Player, Some(spawn_sfx)) = (faction, projectile.spawn_sfx) {
+            audio
+                .play(spawn_sfx)
+                .with_volume(projectile.spawn_sfx_volume);
+        }
 
-        entity
+        world
+            .entity_mut(entity)
             .insert((
                 Name::new(projectile.name.replace(' ', "")),
                 // Appearance:
@@ -114,6 +152,7 @@ pub fn projectile(
                 (
                     RigidBody::Kinematic,
                     Collider::circle(projectile.radius),
+                    CollisionLayers::new(GameLayer::Projectile, target_layers),
                     LockedAxes::ROTATION_LOCKED,
                     LinearVelocity(projectile.speed * force),
                 ),

assets/config/audio.ron

@@ -77,6 +77,12 @@ pub struct PlayingAssets {
 
     #[asset(path = "audio/music/Menu Theme.ogg")]
     pub music: Handle<AudioSource>,
+    #[asset(path = "audio/sfx/Restart_1.ogg")]
+    pub sfx_restart: Handle<AudioSource>,
+    #[asset(path = "audio/sfx/Level Up_1.ogg")]
+    pub sfx_level_up: Handle<AudioSource>,
+    #[asset(path = "audio/sfx/Projectile Hits Player-02.ogg")]
+    pub sfx_hurt: Handle<AudioSource>,
 }
 
 impl Configure for PlayingAssets {