Cargo.toml

@@ -13,11 +13,12 @@ speech_dispatcher_0_10 = ["bevy_tts/speech_dispatcher_0_10"]
 speech_dispatcher_0_11 = ["bevy_tts/speech_dispatcher_0_11"]
 
 [dependencies.bevy]
-version = "0.10"
+version = "0.9"
 default-features = false
 features = [
     "bevy_gilrs",
     "bevy_winit",
+    "render",
     "x11",
     "wayland",
     "serialize",
@@ -25,14 +26,14 @@ features = [
 
 [dependencies]
 backtrace = "0.3"
-bevy_rapier2d = "0.21"
-bevy_synthizer = "0.2"
-bevy_tts = { version = "0.5", default-features = false, features = ["tolk"] }
+bevy_rapier2d = "0.20"
+bevy_synthizer = "0.1"
+bevy_tts = { version = "0.4", default-features = false, features = ["tolk"] }
 coord_2d = "0.3"
 futures-lite = "1"
 gilrs = "0.10"
-here_be_dragons = { version = "0.3", features = ["serde"] }
-leafwing-input-manager = "0.9"
+here_be_dragons = "0.2"
+leafwing-input-manager = { git = "https://github.com/ndarilek/leafwing-input-manager" }
 maze_generator = "2"
 once_cell = "1"
 pathfinding = "4"

src/core.rs

@@ -2,11 +2,12 @@ use std::{
     cmp::{max, min},
     f32::consts::PI,
     fmt::Display,
+    marker::PhantomData,
     ops::Sub,
     sync::RwLock,
 };
 
-use bevy::{app::PluginGroupBuilder, prelude::*, utils::FloatOrd};
+use bevy::{app::PluginGroupBuilder, ecs::query::WorldQuery, prelude::*, utils::FloatOrd};
 use bevy_rapier2d::{
     parry::query::{closest_points, distance, ClosestPoints},
     prelude::*,
@@ -656,21 +657,23 @@ fn sync_config(config: Res<CoreConfig>) {
     }
 }
 
-pub struct CorePlugin {
+pub struct CorePlugin<RapierUserData> {
     pub relative_direction_mode: RelativeDirectionMode,
     pub pixels_per_unit: u8,
+    pub rapier_user_data: PhantomData<RapierUserData>,
 }
 
-impl Default for CorePlugin {
+impl<RapierUserData> Default for CorePlugin<RapierUserData> {
     fn default() -> Self {
         Self {
             relative_direction_mode: RelativeDirectionMode::Directional,
             pixels_per_unit: 1,
+            rapier_user_data: default(),
         }
     }
 }
 
-impl Plugin for CorePlugin {
+impl<RapierUserData: 'static + WorldQuery + Send + Sync> Plugin for CorePlugin<RapierUserData> {
     fn build(&self, app: &mut App) {
         let config = CoreConfig {
             relative_direction_mode: self.relative_direction_mode,
@@ -678,7 +681,7 @@ impl Plugin for CorePlugin {
         };
         app.insert_resource(config)
             .register_type::<CardinalDirection>()
-            .add_plugin(RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(
+            .add_plugin(RapierPhysicsPlugin::<RapierUserData>::pixels_per_meter(
                 config.pixels_per_unit as f32,
             ))
             .add_startup_system(setup)
@@ -686,13 +689,21 @@ impl Plugin for CorePlugin {
     }
 }
 
-pub struct CorePlugins;
+pub struct CorePlugins<RapierUserData>(PhantomData<RapierUserData>);
 
-impl PluginGroup for CorePlugins {
+impl<RapierUserData> Default for CorePlugins<RapierUserData> {
+    fn default() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<RapierUserData: 'static + WorldQuery + Send + Sync> PluginGroup
+    for CorePlugins<RapierUserData>
+{
     fn build(self) -> PluginGroupBuilder {
         PluginGroupBuilder::start::<Self>()
             .add(crate::bevy_tts::TtsPlugin)
             .add(crate::bevy_synthizer::SynthizerPlugin::default())
-            .add(CorePlugin::default())
+            .add(CorePlugin::<RapierUserData>::default())
     }
 }

src/exploration.rs

@@ -62,7 +62,7 @@ where
     ExplorationType: Component + Default + Copy + Ord,
     State: 'static + Clone + Debug + Eq + Hash + Send + Sync,
 {
-    for (actions, visible, mut focused) in &mut explorers {
+    for (actions, visible, mut focused) in explorers.iter_mut() {
         let mut types: Vec<ExplorationType> = vec![];
         for e in visible.iter() {
             if let Ok(t) = features.get(*e) {
@@ -128,7 +128,7 @@ where
     ExplorationType: Component + Default + PartialEq,
     State: 'static + Clone + Debug + Eq + Hash + Send + Sync,
 {
-    for (entity, actions, visible_entities, focused_type, exploring) in &explorers {
+    for (entity, actions, visible_entities, focused_type, exploring) in explorers.iter() {
         let mut features = features
             .iter()
             .filter(|v| visible_entities.contains(&v.0))
@@ -177,7 +177,7 @@ fn exploration_type_changed_announcement<ExplorationType>(
     focused: Query<
         (
             &FocusedExplorationType<ExplorationType>,
-            Ref<FocusedExplorationType<ExplorationType>>,
+            ChangeTrackers<FocusedExplorationType<ExplorationType>>,
         ),
         Changed<FocusedExplorationType<ExplorationType>>,
     >,
@@ -185,7 +185,7 @@ fn exploration_type_changed_announcement<ExplorationType>(
 where
     ExplorationType: Component + Default + Copy + Into<String>,
 {
-    for (focused, changed) in &focused {
+    for (focused, changed) in focused.iter() {
         if changed.is_added() {
             return Ok(());
         }
@@ -218,7 +218,7 @@ fn exploration_focus<State, MapData>(
     State: 'static + Clone + Debug + Eq + Hash + Send + Sync,
     MapData: 'static + Clone + Default + Send + Sync,
 {
-    for (entity, actions, transform, exploring) in &explorers {
+    for (entity, actions, transform, exploring) in explorers.iter() {
         let coordinates = transform.translation;
         let mut exploring = if let Some(exploring) = exploring {
             **exploring
@@ -260,8 +260,8 @@ fn navigate_to_explored<State, MapData>(
     State: 'static + Clone + Debug + Eq + Hash + Send + Sync,
     MapData: 'static + Clone + Default + Send + Sync,
 {
-    for (entity, actions, exploring) in &explorers {
-        for (map, revealed_tiles) in &map {
+    for (entity, actions, exploring) in explorers.iter() {
+        for (map, revealed_tiles) in map.iter() {
             let point = **exploring;
             let idx = point.to_index(map.width);
             let known = revealed_tiles[idx];
@@ -363,19 +363,25 @@ fn cleanup(
     explorers: Query<Entity, With<Exploring>>,
     focus: Query<Entity, With<ExplorationFocused>>,
 ) {
-    for entity in &explorers {
+    for entity in explorers.iter() {
         commands.entity(entity).remove::<Exploring>();
     }
-    for entity in &focus {
+    for entity in focus.iter() {
         commands.entity(entity).remove::<ExplorationFocused>();
     }
 }
 
-#[derive(Resource, Clone, Debug, Default)]
+#[derive(Resource, Clone, Debug)]
 struct ExplorationConfig<State> {
     states: Vec<State>,
 }
 
+impl<State> Default for ExplorationConfig<State> {
+    fn default() -> Self {
+        Self { states: vec![] }
+    }
+}
+
 #[derive(Resource, Clone, Default)]
 pub struct ExplorationPlugin<ExplorationType, State, MapData> {
     pub states: Vec<State>,
@@ -386,7 +392,7 @@ pub struct ExplorationPlugin<ExplorationType, State, MapData> {
 impl<ExplorationType, State, MapData> Plugin for ExplorationPlugin<ExplorationType, State, MapData>
 where
     ExplorationType: 'static + Component + Default + Copy + Ord + PartialEq + Into<String>,
-    State: States,
+    State: 'static + Clone + Debug + Eq + Hash + Send + Sync,
     MapData: 'static + Clone + Default + Send + Sync,
 {
     fn build(&self, app: &mut App) {
@@ -402,32 +408,33 @@ where
                 exploration_changed_announcement::<ExplorationType, MapData>.pipe(error_handler),
             );
         if config.states.is_empty() {
-            app.add_systems((
-                exploration_focus::<State, MapData>,
-                exploration_type_focus::<ExplorationType, State>.pipe(error_handler),
-                exploration_type_change::<ExplorationType, State>.pipe(error_handler),
-                navigate_to_explored::<State, MapData>,
-            ))
-            .add_system(
-                exploration_type_changed_announcement::<ExplorationType>
-                    .pipe(error_handler)
-                    .in_base_set(CoreSet::PostUpdate),
-            );
+            app.add_system(exploration_focus::<State, MapData>)
+                .add_system(exploration_type_focus::<ExplorationType, State>.pipe(error_handler))
+                .add_system(exploration_type_change::<ExplorationType, State>.pipe(error_handler))
+                .add_system(navigate_to_explored::<State, MapData>)
+                .add_system_to_stage(
+                    CoreStage::PostUpdate,
+                    exploration_type_changed_announcement::<ExplorationType>.pipe(error_handler),
+                );
         } else {
             let states = config.states;
             for state in states {
-                app.add_systems(
-                    (
-                        exploration_focus::<State, MapData>,
-                        exploration_type_focus::<ExplorationType, State>.pipe(error_handler),
-                        exploration_type_change::<ExplorationType, State>.pipe(error_handler),
-                        navigate_to_explored::<State, MapData>,
-                        exploration_type_changed_announcement::<ExplorationType>
-                            .pipe(error_handler),
-                    )
-                        .in_set(OnUpdate(state.clone())),
+                app.add_system_set(
+                    SystemSet::on_update(state.clone())
+                        .with_system(exploration_focus::<State, MapData>)
+                        .with_system(
+                            exploration_type_focus::<ExplorationType, State>.pipe(error_handler),
+                        )
+                        .with_system(
+                            exploration_type_change::<ExplorationType, State>.pipe(error_handler),
+                        )
+                        .with_system(navigate_to_explored::<State, MapData>)
+                        .with_system(
+                            exploration_type_changed_announcement::<ExplorationType>
+                                .pipe(error_handler),
+                        ),
                 )
-                .add_system(cleanup.in_schedule(OnExit(state)));
+                .add_system_set(SystemSet::on_exit(state).with_system(cleanup));
             }
         }
     }

src/lib.rs

@@ -20,6 +20,7 @@ pub mod log;
 pub mod map;
 pub mod navigation;
 pub mod pathfinding;
+pub mod pitch_shift;
 pub use rand;
 pub use shadowcast;
 pub mod sound;

src/log.rs

@@ -41,7 +41,7 @@ fn read_log(
     mut position: Local<usize>,
     log: Query<&Log, Changed<Log>>,
 ) -> Result<(), Box<dyn Error>> {
-    for log in &log {
+    for log in log.iter() {
         if *position >= log.len() {
             *position = 0;
         }
@@ -61,10 +61,6 @@ impl Plugin for LogPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<LogEntry>()
             .add_startup_system(setup)
-            .add_system(
-                read_log
-                    .pipe(error_handler)
-                    .in_base_set(CoreSet::PostUpdate),
-            );
+            .add_system_to_stage(CoreStage::PostUpdate, read_log.pipe(error_handler));
     }
 }

src/map.rs

@@ -183,7 +183,7 @@ fn spawn_colliders<D: 'static + Clone + Default + Send + Sync>(
     mut commands: Commands,
     maps: Query<(Entity, &Map<D>, &SpawnColliders), Changed<SpawnColliders>>,
 ) {
-    for (map_entity, map, spawn_colliders) in &maps {
+    for (map_entity, map, spawn_colliders) in maps.iter() {
         if **spawn_colliders {
             commands
                 .entity(map_entity)
@@ -244,7 +244,7 @@ fn spawn_portals<D: 'static + Clone + Default + Send + Sync>(
     mut commands: Commands,
     map: Query<(Entity, &Map<D>, &SpawnPortals), Changed<SpawnPortals>>,
 ) {
-    for (map_entity, map, spawn_portals) in &map {
+    for (map_entity, map, spawn_portals) in map.iter() {
         if **spawn_portals {
             commands.entity(map_entity).remove::<SpawnPortals>();
             let mut portals: Vec<(f32, f32)> = vec![];
@@ -297,9 +297,9 @@ fn spawn_portal_colliders<D: 'static + Clone + Default + Send + Sync>(
     map: Query<(Entity, &SpawnColliders), With<Map<D>>>,
     portals: Query<Entity, (With<Portal>, Without<Collider>)>,
 ) {
-    for (entity, spawn_colliders) in &map {
+    for (entity, spawn_colliders) in map.iter() {
         if **spawn_colliders {
-            for portal_entity in &portals {
+            for portal_entity in portals.iter() {
                 commands
                     .entity(portal_entity)
                     .insert((Collider::cuboid(0.5, 0.5), Sensor));
@@ -328,13 +328,8 @@ impl<MapData: 'static + Clone + Default + Send + Sync> Plugin for MapPlugin<MapD
     fn build(&self, app: &mut App) {
         app.insert_resource(self.clone())
             .register_type::<Portal>()
-            .add_systems(
-                (
-                    spawn_colliders::<MapData>,
-                    spawn_portals::<MapData>,
-                    spawn_portal_colliders::<MapData>,
-                )
-                    .in_base_set(CoreSet::PreUpdate),
-            );
+            .add_system_to_stage(CoreStage::PreUpdate, spawn_colliders::<MapData>)
+            .add_system_to_stage(CoreStage::PreUpdate, spawn_portals::<MapData>)
+            .add_system_to_stage(CoreStage::PreUpdate, spawn_portal_colliders::<MapData>);
     }
 }

src/navigation.rs

@@ -224,7 +224,7 @@ fn controls(
         }
         if cleanup {
             commands.entity(entity).remove::<Exploring>();
-            for entity in &exploration_focused {
+            for entity in exploration_focused.iter() {
                 commands.entity(entity).remove::<ExplorationFocused>();
             }
         }
@@ -289,7 +289,7 @@ fn update_direction(
         (With<Player>, Changed<Transform>),
     >,
 ) {
-    for (entity, transform, direction) in &mut query {
+    for (entity, transform, direction) in query.iter_mut() {
         let yaw = transform.yaw();
         let new_direction: CardinalDirection = yaw.into();
         if let Some(mut direction) = direction {
@@ -304,10 +304,10 @@ fn update_direction(
 
 fn remove_direction(
     mut commands: Commands,
-    mut removed: RemovedComponents<Transform>,
+    removed: RemovedComponents<Transform>,
     directions: Query<&CardinalDirection>,
 ) {
-    for entity in &mut removed {
+    for entity in removed.iter() {
         if directions.contains(entity) {
             commands.run_if_exists(entity, |mut entity| {
                 entity.remove::<CardinalDirection>();
@@ -319,7 +319,7 @@ fn remove_direction(
 fn speak_direction(
     mut tts: ResMut<Tts>,
     player: Query<
-        (&CardinalDirection, Ref<CardinalDirection>),
+        (&CardinalDirection, ChangeTrackers<CardinalDirection>),
         (With<Player>, Changed<CardinalDirection>),
     >,
 ) -> Result<(), Box<dyn Error>> {
@@ -333,7 +333,7 @@ fn speak_direction(
 }
 
 fn add_speed(mut commands: Commands, query: Query<Entity, (Added<Speed>, Without<Velocity>)>) {
-    for entity in &query {
+    for entity in query.iter() {
         commands.entity(entity).insert(Velocity {
             linvel: Vec2::ZERO,
             ..default()
@@ -384,8 +384,7 @@ fn log_area_descriptions<State>(
     }
 }
 
-#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
-pub struct MovementControls;
+pub const MOVEMENT_CONTROLS: &str = "MOVEMENT_CONTROLS";
 
 #[derive(Resource, Clone, Debug)]
 pub struct NavigationPlugin<State> {
@@ -406,7 +405,7 @@ impl<State> Default for NavigationPlugin<State> {
 
 impl<State> Plugin for NavigationPlugin<State>
 where
-    State: States,
+    State: 'static + Clone + Copy + Debug + Eq + Hash + Send + Sync,
 {
     fn build(&self, app: &mut App) {
         app.insert_resource(self.clone());
@@ -417,23 +416,21 @@ where
             .register_type::<RotationSpeed>()
             .register_type::<Speed>()
             .add_plugin(InputManagerPlugin::<NavigationAction>::default())
-            .add_system(update_direction.in_base_set(CoreSet::PreUpdate))
-            .add_systems(
-                (remove_direction, log_area_descriptions::<State>).in_base_set(CoreSet::PostUpdate),
-            )
-            .add_systems((
-                tick_snap_timers,
-                speak_direction.pipe(error_handler),
-                add_speed,
-            ));
+            .add_system_to_stage(CoreStage::PreUpdate, update_direction)
+            .add_system_to_stage(CoreStage::PostUpdate, remove_direction)
+            .add_system(tick_snap_timers)
+            .add_system(speak_direction.pipe(error_handler))
+            .add_system(add_speed)
+            .add_system_to_stage(CoreStage::PostUpdate, log_area_descriptions::<State>);
         if self.states.is_empty() {
-            app.add_systems((controls.in_set(MovementControls), snap.pipe(error_handler)).chain());
+            app.add_system(controls.label(MOVEMENT_CONTROLS))
+                .add_system(snap.pipe(error_handler).before(MOVEMENT_CONTROLS));
         } else {
             for state in &self.states {
-                app.add_systems(
-                    (controls.in_set(MovementControls), snap.pipe(error_handler))
-                        .chain()
-                        .in_set(OnUpdate(state.clone())),
+                app.add_system_set(
+                    SystemSet::on_update(*state)
+                        .with_system(controls.label(MOVEMENT_CONTROLS))
+                        .with_system(snap.pipe(error_handler).before(MOVEMENT_CONTROLS)),
                 );
             }
         }

src/pathfinding.rs

@@ -244,7 +244,7 @@ fn calculate_path(
 }
 
 fn poll_tasks(mut commands: Commands, mut query: Query<(Entity, &mut Calculating)>) {
-    for (entity, mut calculating) in &mut query {
+    for (entity, mut calculating) in query.iter_mut() {
         if let Some(result) = future::block_on(future::poll_once(&mut **calculating)) {
             if let Some(path) = result {
                 trace!("{entity:?}: Path: {path:?}");
@@ -261,9 +261,9 @@ fn poll_tasks(mut commands: Commands, mut query: Query<(Entity, &mut Calculating
 fn remove_destination(
     mut commands: Commands,
     entities: &Entities,
-    mut removed: RemovedComponents<Destination>,
+    removed: RemovedComponents<Destination>,
 ) {
-    for entity in &mut removed {
+    for entity in removed.iter() {
         if entities.contains(entity) {
             commands.entity(entity).remove::<Calculating>();
         }
@@ -324,7 +324,7 @@ fn negotiate_path(
                 start,
                 transform.yaw().radians(),
                 direction,
-                collider,
+                &*collider,
                 rapier_context.integration_parameters.dt,
                 QueryFilter::new()
                     .exclude_sensors()
@@ -408,13 +408,18 @@ impl Plugin for PathfindingPlugin {
             .register_type::<NoPath>()
             .register_type::<Path>()
             .register_type::<CostMap>()
-            .add_systems((negotiate_path, poll_tasks).in_base_set(CoreSet::PreUpdate))
-            .add_systems(
-                (actions, calculate_path)
-                    .chain()
-                    .in_base_set(CoreSet::PreUpdate)
-                    .after(InputManagerSystem::Tick),
+            .add_system_to_stage(CoreStage::PreUpdate, calculate_path)
+            .add_system_to_stage(CoreStage::PostUpdate, remove_destination)
+            .add_system_to_stage(CoreStage::PreUpdate, poll_tasks)
+            .add_system_to_stage(
+                CoreStage::PreUpdate,
+                negotiate_path.after(InputManagerSystem::Tick),
             )
-            .add_system(remove_destination.in_base_set(CoreSet::PostUpdate));
+            .add_system_to_stage(
+                CoreStage::PreUpdate,
+                actions
+                    .after(InputManagerSystem::Update)
+                    .before(calculate_path),
+            );
     }
 }

src/pitch_shift.rs

@@ -22,7 +22,7 @@ fn tag_behind(
     if config.downshift_behind {
         if let Ok(listener_transform) = listener.get_single() {
             let listener_forward = listener_transform.forward();
-            for (entity, transform, sound, icon) in &sounds {
+            for (entity, transform, sound, icon) in sounds.iter() {
                 if icon.is_none() && sound.is_none() {
                     continue;
                 }
@@ -41,7 +41,7 @@ fn tag_behind(
             }
         }
     } else {
-        for entity in &behind {
+        for entity in behind.iter() {
             commands.run_if_exists(entity, |mut entity| {
                 entity.remove::<Behind>();
             });
@@ -61,7 +61,7 @@ fn behind_added(
     mut last_sound_pitch: ResMut<LastSoundPitch>,
     mut query: Query<(Entity, Option<&mut SoundIcon>, Option<&mut Sound>), Added<Behind>>,
 ) {
-    for (entity, icon, sound) in &mut query {
+    for (entity, icon, sound) in query.iter_mut() {
         if let Some(mut icon) = icon {
             icon.pitch *= config.downshift;
             last_icon_pitch.insert(entity, icon.pitch);
@@ -76,12 +76,12 @@ fn behind_removed(
     config: Res<PitchShiftPlugin>,
     mut last_icon_pitch: ResMut<LastIconPitch>,
     mut last_sound_pitch: ResMut<LastSoundPitch>,
-    mut removed: RemovedComponents<Behind>,
+    removed: RemovedComponents<Behind>,
     mut icons: Query<&mut SoundIcon>,
     mut sounds: Query<&mut Sound>,
 ) {
     let downshift = 1. / config.downshift;
-    for entity in &mut removed {
+    for entity in removed.iter() {
         if let Ok(mut icon) = icons.get_mut(entity) {
             icon.pitch *= downshift;
             last_icon_pitch.remove(&entity);
@@ -97,7 +97,7 @@ fn sound_icon_changed(
     mut last_icon_pitch: ResMut<LastIconPitch>,
     mut icons: Query<(Entity, &mut SoundIcon), (With<Behind>, Changed<SoundIcon>)>,
 ) {
-    for (entity, mut icon) in &mut icons {
+    for (entity, mut icon) in icons.iter_mut() {
         let should_change = if let Some(pitch) = last_icon_pitch.get(&entity) {
             *pitch != icon.pitch
         } else {
@@ -115,7 +115,7 @@ fn sound_changed(
     mut last_sound_pitch: ResMut<LastSoundPitch>,
     mut sounds: Query<(Entity, &mut Sound), (With<Behind>, Without<SoundIcon>, Changed<Sound>)>,
 ) {
-    for (entity, mut sound) in &mut sounds {
+    for (entity, mut sound) in sounds.iter_mut() {
         let should_change = if let Some(pitch) = last_sound_pitch.get(&entity) {
             *pitch != sound.pitch
         } else {
@@ -134,7 +134,7 @@ fn sync_config(
     behind: Query<Entity, With<Behind>>,
 ) {
     if config.is_changed() {
-        for entity in &behind {
+        for entity in behind.iter() {
             commands.entity(entity).remove::<Behind>();
         }
     }
@@ -161,8 +161,11 @@ impl Plugin for PitchShiftPlugin {
             .register_type::<Behind>()
             .init_resource::<LastIconPitch>()
             .init_resource::<LastSoundPitch>()
-            .add_system(tag_behind.in_base_set(CoreSet::PreUpdate))
-            .add_systems((behind_added, sound_icon_changed, sound_changed, sync_config))
-            .add_system(behind_removed.in_base_set(CoreSet::PostUpdate));
+            .add_system_to_stage(CoreStage::PreUpdate, tag_behind)
+            .add_system(behind_added)
+            .add_system_to_stage(CoreStage::PostUpdate, behind_removed)
+            .add_system(sound_icon_changed)
+            .add_system(sound_changed)
+            .add_system(sync_config);
     }
 }

src/sound/footstep.rs

@@ -29,11 +29,11 @@ impl Default for Footstep {
 }
 
 fn added(mut commands: Commands, footsteps: Query<(Entity, &Footstep), Added<Footstep>>) {
-    for (entity, footstep) in &footsteps {
+    for (entity, footstep) in footsteps.iter() {
         let buffer = footstep.buffer.clone();
         commands.run_if_exists(entity, move |mut entity| {
             entity.insert(Sound {
-                audio: buffer.into(),
+                buffer,
                 paused: true,
                 ..default()
             });
@@ -46,7 +46,7 @@ fn update(
     mut footsteps: Query<(Entity, &Footstep, &Parent, &mut Sound)>,
     transforms_storage: Query<&GlobalTransform>,
 ) {
-    for (entity, footstep, parent, mut sound) in &mut footsteps {
+    for (entity, footstep, parent, mut sound) in footsteps.iter_mut() {
         if let Ok(transform) = transforms_storage.get(**parent) {
             if let Some(last) = last_step_distance.get(&entity) {
                 let distance = last.0 + (last.1.distance(transform));
@@ -76,11 +76,10 @@ pub struct FootstepPlugin;
 impl Plugin for FootstepPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<Footstep>()
-            .add_system(added.in_base_set(CoreSet::PreUpdate))
-            .add_system(
-                update
-                    .after(TransformSystem::TransformPropagate)
-                    .in_base_set(CoreSet::PostUpdate),
+            .add_system_to_stage(CoreStage::PreUpdate, added)
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                update.after(TransformSystem::TransformPropagate),
             );
     }
 }

src/sound/icon.rs

@@ -1,7 +1,7 @@
-use std::{fmt::Debug, time::Duration};
+use std::{fmt::Debug, hash::Hash, time::Duration};
 
 use bevy::prelude::*;
-use bevy_synthizer::{Audio, Buffer, Sound};
+use bevy_synthizer::{Buffer, Sound};
 
 use rand::random;
 
@@ -39,14 +39,14 @@ impl Default for SoundIcon {
 }
 
 fn added(mut commands: Commands, icons: Query<(Entity, &SoundIcon), Added<SoundIcon>>) {
-    for (entity, icon) in &icons {
+    for (entity, icon) in icons.iter() {
         let buffer = icon.buffer.clone();
         let gain = icon.gain;
         let pitch = icon.pitch;
         let looping = icon.interval.is_none();
         commands.run_if_exists(entity, move |mut entity| {
             entity.insert(Sound {
-                audio: buffer.into(),
+                buffer,
                 gain,
                 pitch,
                 looping,
@@ -70,13 +70,13 @@ fn update<S>(
         &mut Sound,
     )>,
 ) where
-    S: States,
+    S: 'static + Clone + Debug + Eq + Hash + Send + Sync,
 {
-    if !config.states.is_empty() && !config.states.contains(&state.0) {
+    if !config.states.is_empty() && !config.states.contains(state.current()) {
         return;
     }
-    for visible in &viewers {
-        for (icon_entity, mut icon, visibility, parent, mut sound) in &mut icons {
+    for visible in viewers.iter() {
+        for (icon_entity, mut icon, visibility, parent, mut sound) in icons.iter_mut() {
             let entity = if visibility.is_some() {
                 Some(icon_entity)
             } else if parent.is_some() {
@@ -97,9 +97,8 @@ fn update<S>(
                         }
                     }
                     let buffer = icon.buffer.clone();
-                    let audio: Audio = buffer.into();
-                    if sound.audio != audio {
-                        sound.audio = audio;
+                    if sound.buffer != buffer {
+                        sound.buffer = buffer;
                     }
                     sound.gain = icon.gain;
                     sound.pitch = icon.pitch;
@@ -118,7 +117,7 @@ fn exploration_focus_changed(
     mut icons: Query<&mut SoundIcon>,
 ) {
     const ICON_GAIN: f64 = 3.;
-    for (entity, children) in &mut focused {
+    for (entity, children) in focused.iter_mut() {
         if let Ok(mut icon) = icons.get_mut(entity) {
             icon.gain *= ICON_GAIN;
         }
@@ -133,12 +132,12 @@ fn exploration_focus_changed(
 }
 
 fn exploration_focus_removed(
-    mut removed: RemovedComponents<ExplorationFocused>,
+    removed: RemovedComponents<ExplorationFocused>,
     mut query: Query<&mut SoundIcon>,
     children: Query<&Children>,
 ) {
     const ICON_GAIN: f64 = 3.;
-    for entity in &mut removed {
+    for entity in removed.iter() {
         if let Ok(mut icon) = query.get_mut(entity) {
             icon.gain /= ICON_GAIN;
         }
@@ -197,23 +196,21 @@ impl<S> Default for SoundIconPlugin<S> {
 
 impl<S> Plugin for SoundIconPlugin<S>
 where
-    S: States,
+    S: 'static + Clone + Debug + Eq + Hash + Send + Sync,
 {
     fn build(&self, app: &mut App) {
         app.insert_resource(self.clone())
             .register_type::<SoundIcon>()
             .add_system(added)
-            .add_system(update::<S>.in_base_set(CoreSet::PostUpdate))
-            .add_system(
-                exploration_focus_changed
-                    .in_base_set(CoreSet::PostUpdate)
-                    .after(update::<S>),
+            .add_system_to_stage(CoreStage::PostUpdate, update::<S>)
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                exploration_focus_changed.after(update::<S>),
             )
-            .add_system(
-                exploration_focus_removed
-                    .in_base_set(CoreSet::PostUpdate)
-                    .after(exploration_focus_changed),
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                exploration_focus_removed.after(exploration_focus_changed),
             )
-            .add_system(reset_timer_on_visibility_gain.in_base_set(CoreSet::PostUpdate));
+            .add_system_to_stage(CoreStage::PostUpdate, reset_timer_on_visibility_gain);
     }
 }

src/sound/mod.rs

@@ -1,18 +1,18 @@
+use std::{fmt::Debug, hash::Hash};
+
 use bevy::{app::PluginGroupBuilder, prelude::*};
 
 pub mod footstep;
 pub mod icon;
-pub mod pitch_shift;
 pub mod volumetric;
 
 pub use footstep::Footstep;
 pub use icon::{SoundIcon, SoundIconPlugin};
-pub use pitch_shift::PitchShiftPlugin;
 pub use volumetric::Volumetric;
 
 /*fn scale_sounds(config: Res<CoreConfig>, mut sounds: Query<&mut Sound>) {
     let pixels_per_unit = config.pixels_per_unit as f32;
-    for mut sound in &mut sounds {
+    for mut sound in sounds.iter_mut() {
         sound.reference_distance *= pixels_per_unit;
         if sound.max_distance != f32::MAX {
             sound.max_distance *= pixels_per_unit;
@@ -30,13 +30,12 @@ impl<'a, S> Default for SoundPlugins<'a, S> {
 
 impl<S> PluginGroup for SoundPlugins<'static, S>
 where
-    S: States,
+    S: 'static + Clone + Debug + Eq + Hash + Send + Sync,
 {
     fn build(self) -> PluginGroupBuilder {
         PluginGroupBuilder::start::<Self>()
             .add(footstep::FootstepPlugin)
             .add(icon::SoundIconPlugin::<S>::default())
-            .add(pitch_shift::PitchShiftPlugin::default())
             .add(volumetric::VolumetricPlugin)
         // .add_system(scale_sounds);
     }

src/sound/volumetric.rs

@@ -39,8 +39,8 @@ fn update(
     }
 }
 
-fn removed(mut commands: Commands, mut removed: RemovedComponents<Volumetric>) {
-    for entity in &mut removed {
+fn removed(mut commands: Commands, removed: RemovedComponents<Volumetric>) {
+    for entity in removed.iter() {
         commands.run_if_exists(entity, |mut entity| {
             entity.insert(TransformBundle::default());
         });
@@ -52,11 +52,10 @@ pub struct VolumetricPlugin;
 impl Plugin for VolumetricPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<Volumetric>()
-            .add_system(
-                update
-                    .in_base_set(CoreSet::PostUpdate)
-                    .before(TransformSystem::TransformPropagate),
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                update.before(TransformSystem::TransformPropagate),
             )
-            .add_system(removed.in_base_set(CoreSet::PostUpdate));
+            .add_system_to_stage(CoreStage::PostUpdate, removed);
     }
 }

src/visibility.rs

@@ -253,7 +253,7 @@ fn add_visibility_indices<MapData: 'static + Clone + Default + Send + Sync>(
     map_config: Res<MapPlugin<MapData>>,
     query: Query<(Entity, &Map<MapData>), (Added<Map<MapData>>, Without<RevealedTiles>)>,
 ) {
-    for (entity, map) in &query {
+    for (entity, map) in query.iter() {
         let count = map.width * map.height;
         commands
             .entity(entity)
@@ -262,11 +262,11 @@ fn add_visibility_indices<MapData: 'static + Clone + Default + Send + Sync>(
 }
 
 fn viewshed_removed(
-    mut query: RemovedComponents<Viewshed>,
+    query: RemovedComponents<Viewshed>,
     visible_entities: Query<&VisibleEntities>,
     mut events: EventWriter<VisibilityChanged>,
 ) {
-    for entity in &mut query {
+    for entity in query.iter() {
         if let Ok(visible) = visible_entities.get(entity) {
             for e in visible.iter() {
                 events.send(VisibilityChanged::Lost {
@@ -314,7 +314,8 @@ fn update_viewshed(
         return;
     }
     let mut cache = HashMap::new();
-    for (viewer_entity, mut viewshed, mut visible_entities, viewer_transform) in &mut viewers {
+    for (viewer_entity, mut viewshed, mut visible_entities, viewer_transform) in viewers.iter_mut()
+    {
         viewshed.update(
             &viewer_entity,
             &mut visible_entities,
@@ -329,7 +330,7 @@ fn update_viewshed(
 }
 
 fn remove_visible(
-    mut removed: RemovedComponents<Visible>,
+    removed: RemovedComponents<Visible>,
     mut viewers: Query<(
         Entity,
         &mut Viewshed,
@@ -341,10 +342,10 @@ fn remove_visible(
     obstructions: Query<&MapObstruction>,
     mut changed: EventWriter<VisibilityChanged>,
 ) {
-    if !removed.is_empty() {
+    if removed.iter().len() != 0 {
         let mut cache = HashMap::new();
-        for removed in &mut removed {
-            for (viewer_entity, mut viewshed, mut visible_entities, start) in &mut viewers {
+        for removed in removed.iter() {
+            for (viewer_entity, mut viewshed, mut visible_entities, start) in viewers.iter_mut() {
                 if !visible_entities.contains(&removed) {
                     continue;
                 }
@@ -368,8 +369,8 @@ fn update_revealed_tiles<D: 'static + Clone + Default + Send + Sync>(
     mut map: Query<(&Map<D>, &mut RevealedTiles)>,
     viewers: Query<&Viewshed, (With<Player>, Changed<Viewshed>)>,
 ) {
-    for viewshed in &viewers {
-        for (map, mut revealed_tiles) in &mut map {
+    for viewshed in viewers.iter() {
+        for (map, mut revealed_tiles) in map.iter_mut() {
             for v in viewshed.visible_points.iter() {
                 let idx = v.to_index(map.width);
                 if idx >= revealed_tiles.len() {
@@ -440,15 +441,11 @@ impl<MapData: 'static + Clone + Default + Send + Sync> Default for VisibilityPlu
 impl<MapData: 'static + Clone + Default + Send + Sync> Plugin for VisibilityPlugin<MapData> {
     fn build(&self, app: &mut App) {
         app.add_event::<VisibilityChanged>()
-            .add_systems(
-                (
-                    add_visibility_indices::<MapData>,
-                    update_viewshed,
-                    update_revealed_tiles::<MapData>,
-                    log_visible,
-                )
-                    .in_base_set(CoreSet::PreUpdate),
-            )
-            .add_systems((viewshed_removed, remove_visible).in_base_set(CoreSet::PostUpdate));
+            .add_system_to_stage(CoreStage::PreUpdate, add_visibility_indices::<MapData>)
+            .add_system_to_stage(CoreStage::PreUpdate, update_viewshed)
+            .add_system_to_stage(CoreStage::PostUpdate, viewshed_removed)
+            .add_system_to_stage(CoreStage::PostUpdate, remove_visible)
+            .add_system_to_stage(CoreStage::PreUpdate, update_revealed_tiles::<MapData>)
+            .add_system_to_stage(CoreStage::PreUpdate, log_visible);
     }
 }