Clean up state/scheduling setup.

Cargo.toml

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

README.md

@@ -15,8 +15,6 @@ _Blackout_ uses a few other libraries for its magic:
 
 It provides, including but not limited to:
 
-* commands
-  * `RunIfExists` extension for only running a given command if its entity exists
 * core
   * `PointLike` trait for distance and other calculations between `Coordinates` and `Coordinates`-like things (I.e. `(f32, f32)`, `(i32, i32)`, ...)
   * `Angle` type for handling angles in degrees/radians
@@ -49,5 +47,4 @@ It provides, including but not limited to:
 * utils
   * Poorly-named `target_and_other` function for taking 2 entities, a predecate, and returning `Some((match, other))` if one matches or `None` if neither do. Good for, say, taking in a collision pair and returning a bullet entity first
 * error
-  * Logger for logging panic stacktraces
-  * Panic handler for sending stacktraces to [Sentry](https://sentry.io) in release builds
+  * Logger for logging piped errors in systems

src/commands.rs

@@ -1,22 +0,0 @@
-use bevy::{
-    ecs::{system::Command, world::EntityMut},
-    prelude::*,
-};
-
-struct RunIfExistsCommand<F>(Entity, F);
-
-impl<F: FnOnce(EntityMut) + Send + Sync + 'static> Command for RunIfExistsCommand<F> {
-    fn write(self, world: &mut World) {
-        world.get_entity_mut(self.0).map(self.1);
-    }
-}
-
-pub trait RunIfExistsExt {
-    fn run_if_exists(&mut self, entity: Entity, f: impl FnOnce(EntityMut) + Send + Sync + 'static);
-}
-
-impl RunIfExistsExt for Commands<'_, '_> {
-    fn run_if_exists(&mut self, entity: Entity, f: impl FnOnce(EntityMut) + Send + Sync + 'static) {
-        self.add(RunIfExistsCommand(entity, f));
-    }
-}

src/core.rs

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

src/error.rs

@@ -1,7 +1,5 @@
 use std::error::Error;
-use std::{panic, thread};
 
-use backtrace::Backtrace;
 use bevy::prelude::*;
 
 pub fn error_handler(In(result): In<Result<(), Box<dyn Error>>>) {
@@ -9,45 +7,3 @@ pub fn error_handler(In(result): In<Result<(), Box<dyn Error>>>) {
         error!("{}", e);
     }
 }
-
-fn init_panic_handler() {
-    panic::set_hook(Box::new(|info| {
-        let backtrace = Backtrace::default();
-        let thread = thread::current();
-        let thread = thread.name().unwrap_or("<unnamed>");
-        let msg = match info.payload().downcast_ref::<&'static str>() {
-            Some(s) => *s,
-            None => match info.payload().downcast_ref::<String>() {
-                Some(s) => &**s,
-                None => "Box<Any>",
-            },
-        };
-        match info.location() {
-            Some(location) => {
-                error!(
-                    target: "panic", "thread '{}' panicked at '{}': {}:{}{:?}",
-                    thread,
-                    msg,
-                    location.file(),
-                    location.line(),
-                    backtrace
-                );
-            }
-            None => error!(
-                target: "panic",
-                "thread '{}' panicked at '{}'{:?}",
-                thread,
-                msg,
-                backtrace
-            ),
-        }
-    }));
-}
-
-pub struct ErrorPlugin;
-
-impl Plugin for ErrorPlugin {
-    fn build(&self, _app: &mut App) {
-        init_panic_handler();
-    }
-}

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 explorers.iter_mut() {
+    for (actions, visible, mut focused) in &mut explorers {
         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.iter() {
+    for (entity, actions, visible_entities, focused_type, exploring) in &explorers {
         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>,
-            ChangeTrackers<FocusedExplorationType<ExplorationType>>,
+            Ref<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.iter() {
+    for (focused, changed) in &focused {
         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.iter() {
+    for (entity, actions, transform, exploring) in &explorers {
         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.iter() {
-        for (map, revealed_tiles) in map.iter() {
+    for (entity, actions, exploring) in &explorers {
+        for (map, revealed_tiles) in &map {
             let point = **exploring;
             let idx = point.to_index(map.width);
             let known = revealed_tiles[idx];
@@ -363,25 +363,19 @@ fn cleanup(
     explorers: Query<Entity, With<Exploring>>,
     focus: Query<Entity, With<ExplorationFocused>>,
 ) {
-    for entity in explorers.iter() {
+    for entity in &explorers {
         commands.entity(entity).remove::<Exploring>();
     }
-    for entity in focus.iter() {
+    for entity in &focus {
         commands.entity(entity).remove::<ExplorationFocused>();
     }
 }
 
-#[derive(Resource, Clone, Debug)]
+#[derive(Resource, Clone, Debug, Default)]
 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>,
@@ -389,10 +383,13 @@ pub struct ExplorationPlugin<ExplorationType, State, MapData> {
     pub map_data: PhantomData<MapData>,
 }
 
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
+pub struct Exploration;
+
 impl<ExplorationType, State, MapData> Plugin for ExplorationPlugin<ExplorationType, State, MapData>
 where
     ExplorationType: 'static + Component + Default + Copy + Ord + PartialEq + Into<String>,
-    State: 'static + Clone + Debug + Eq + Hash + Send + Sync,
+    State: States,
     MapData: 'static + Clone + Default + Send + Sync,
 {
     fn build(&self, app: &mut App) {
@@ -404,37 +401,30 @@ where
             .register_type::<Mappable>()
             .register_type::<Explorable>()
             .add_plugin(InputManagerPlugin::<ExplorationAction>::default())
-            .add_system(
-                exploration_changed_announcement::<ExplorationType, MapData>.pipe(error_handler),
-            );
-        if config.states.is_empty() {
-            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,
+            .add_systems(
+                (
+                    exploration_type_change::<ExplorationType, State>.pipe(error_handler),
                     exploration_type_changed_announcement::<ExplorationType>.pipe(error_handler),
-                );
-        } else {
+                )
+                    .chain()
+                    .in_set(Exploration),
+            )
+            .add_systems(
+                (
+                    exploration_focus::<State, MapData>,
+                    exploration_type_focus::<ExplorationType, State>.pipe(error_handler),
+                    exploration_changed_announcement::<ExplorationType, MapData>
+                        .pipe(error_handler),
+                )
+                    .chain()
+                    .in_set(Exploration),
+            )
+            .add_system(navigate_to_explored::<State, MapData>.in_set(Exploration));
+        if !config.states.is_empty() {
             let states = config.states;
             for state in states {
-                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_set(SystemSet::on_exit(state).with_system(cleanup));
+                app.configure_set(Exploration.in_set(OnUpdate(state.clone())))
+                    .add_system(cleanup.in_schedule(OnExit(state)));
             }
         }
     }

src/lib.rs

@@ -6,7 +6,6 @@ pub use bevy;
 pub use bevy_rapier2d;
 pub use bevy_synthizer;
 pub use bevy_tts;
-pub mod commands;
 pub use coord_2d;
 #[macro_use]
 pub mod core;
@@ -20,7 +19,6 @@ 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.iter() {
+    for log in &log {
         if *position >= log.len() {
             *position = 0;
         }
@@ -61,6 +61,10 @@ impl Plugin for LogPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<LogEntry>()
             .add_startup_system(setup)
-            .add_system_to_stage(CoreStage::PostUpdate, read_log.pipe(error_handler));
+            .add_system(
+                read_log
+                    .pipe(error_handler)
+                    .in_base_set(CoreSet::PostUpdate),
+            );
     }
 }

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.iter() {
+    for (map_entity, map, spawn_colliders) in &maps {
         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.iter() {
+    for (map_entity, map, spawn_portals) in &map {
         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.iter() {
+    for (entity, spawn_colliders) in &map {
         if **spawn_colliders {
-            for portal_entity in portals.iter() {
+            for portal_entity in &portals {
                 commands
                     .entity(portal_entity)
                     .insert((Collider::cuboid(0.5, 0.5), Sensor));
@@ -328,8 +328,13 @@ 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_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>);
+            .add_systems(
+                (
+                    spawn_colliders::<MapData>,
+                    spawn_portals::<MapData>,
+                    spawn_portal_colliders::<MapData>,
+                )
+                    .in_base_set(CoreSet::PreUpdate),
+            );
     }
 }

src/navigation.rs

@@ -6,7 +6,6 @@ use bevy_tts::Tts;
 use leafwing_input_manager::{axislike::DualAxisData, prelude::*};
 
 use crate::{
-    commands::RunIfExistsExt,
     core::{Angle, Area, CardinalDirection, GlobalTransformExt, Player},
     error::error_handler,
     exploration::{ExplorationFocused, Exploring},
@@ -83,6 +82,58 @@ impl Default for Speed {
     }
 }
 
+fn snap(
+    mut tts: ResMut<Tts>,
+    mut snap_timers: ResMut<SnapTimers>,
+    mut query: Query<
+        (
+            Entity,
+            &ActionState<NavigationAction>,
+            &mut Transform,
+            &CardinalDirection,
+        ),
+        With<Player>,
+    >,
+) -> Result<(), Box<dyn Error>> {
+    for (entity, actions, mut transform, direction) in &mut query {
+        if snap_timers.contains_key(&entity) {
+            continue;
+        } else if actions.just_pressed(NavigationAction::SnapLeft) {
+            snap_timers.insert(entity, SnapTimer::default());
+            transform.rotation = Quat::from_rotation_z(match direction {
+                CardinalDirection::North => PI,
+                CardinalDirection::East => PI / 2.,
+                CardinalDirection::South => 0.,
+                CardinalDirection::West => -PI / 2.,
+            });
+        } else if actions.just_pressed(NavigationAction::SnapRight) {
+            snap_timers.insert(entity, SnapTimer::default());
+            transform.rotation = Quat::from_rotation_z(match direction {
+                CardinalDirection::North => 0.,
+                CardinalDirection::East => -PI / 2.,
+                CardinalDirection::South => PI,
+                CardinalDirection::West => PI / 2.,
+            });
+        } else if actions.just_pressed(NavigationAction::SnapReverse) {
+            snap_timers.insert(entity, SnapTimer::default());
+            transform.rotate(Quat::from_rotation_z(PI));
+        } else if actions.just_pressed(NavigationAction::SnapCardinal) {
+            let yaw: Angle = direction.into();
+            let yaw = yaw.radians();
+            transform.rotation = Quat::from_rotation_z(yaw);
+            tts.speak(direction.to_string(), true)?;
+        }
+    }
+    Ok(())
+}
+
+fn tick_snap_timers(time: Res<Time>, mut snap_timers: ResMut<SnapTimers>) {
+    for timer in snap_timers.values_mut() {
+        timer.tick(time.delta());
+    }
+    snap_timers.retain(|_, v| !v.finished());
+}
+
 fn controls(
     mut commands: Commands,
     time: Res<Time>,
@@ -224,63 +275,12 @@ fn controls(
         }
         if cleanup {
             commands.entity(entity).remove::<Exploring>();
-            for entity in exploration_focused.iter() {
+            for entity in &exploration_focused {
                 commands.entity(entity).remove::<ExplorationFocused>();
             }
         }
     }
 }
-fn snap(
-    mut tts: ResMut<Tts>,
-    mut snap_timers: ResMut<SnapTimers>,
-    mut query: Query<
-        (
-            Entity,
-            &ActionState<NavigationAction>,
-            &mut Transform,
-            &CardinalDirection,
-        ),
-        With<Player>,
-    >,
-) -> Result<(), Box<dyn Error>> {
-    for (entity, actions, mut transform, direction) in &mut query {
-        if snap_timers.contains_key(&entity) {
-            continue;
-        } else if actions.just_pressed(NavigationAction::SnapLeft) {
-            snap_timers.insert(entity, SnapTimer::default());
-            transform.rotation = Quat::from_rotation_z(match direction {
-                CardinalDirection::North => PI,
-                CardinalDirection::East => PI / 2.,
-                CardinalDirection::South => 0.,
-                CardinalDirection::West => -PI / 2.,
-            });
-        } else if actions.just_pressed(NavigationAction::SnapRight) {
-            snap_timers.insert(entity, SnapTimer::default());
-            transform.rotation = Quat::from_rotation_z(match direction {
-                CardinalDirection::North => 0.,
-                CardinalDirection::East => -PI / 2.,
-                CardinalDirection::South => PI,
-                CardinalDirection::West => PI / 2.,
-            });
-        } else if actions.just_pressed(NavigationAction::SnapReverse) {
-            snap_timers.insert(entity, SnapTimer::default());
-            transform.rotate(Quat::from_rotation_z(PI));
-        } else if actions.just_pressed(NavigationAction::SnapCardinal) {
-            let yaw: Angle = direction.into();
-            let yaw = yaw.radians();
-            transform.rotation = Quat::from_rotation_z(yaw);
-            tts.speak(direction.to_string(), true)?;
-        }
-    }
-    Ok(())
-}
-
-fn tick_snap_timers(time: Res<Time>, mut snap_timers: ResMut<SnapTimers>) {
-    for timer in snap_timers.values_mut() {
-        timer.tick(time.delta());
-    }
-    snap_timers.retain(|_, v| !v.finished());
-}
 
 fn update_direction(
     mut commands: Commands,
@@ -289,7 +289,7 @@ fn update_direction(
         (With<Player>, Changed<Transform>),
     >,
 ) {
-    for (entity, transform, direction) in query.iter_mut() {
+    for (entity, transform, direction) in &mut query {
         let yaw = transform.yaw();
         let new_direction: CardinalDirection = yaw.into();
         if let Some(mut direction) = direction {
@@ -304,14 +304,12 @@ fn update_direction(
 
 fn remove_direction(
     mut commands: Commands,
-    removed: RemovedComponents<Transform>,
+    mut removed: RemovedComponents<Transform>,
     directions: Query<&CardinalDirection>,
 ) {
-    for entity in removed.iter() {
+    for entity in &mut removed {
         if directions.contains(entity) {
-            commands.run_if_exists(entity, |mut entity| {
-                entity.remove::<CardinalDirection>();
-            });
+            commands.entity(entity).remove::<CardinalDirection>();
         }
     }
 }
@@ -319,7 +317,7 @@ fn remove_direction(
 fn speak_direction(
     mut tts: ResMut<Tts>,
     player: Query<
-        (&CardinalDirection, ChangeTrackers<CardinalDirection>),
+        (&CardinalDirection, Ref<CardinalDirection>),
         (With<Player>, Changed<CardinalDirection>),
     >,
 ) -> Result<(), Box<dyn Error>> {
@@ -333,7 +331,7 @@ fn speak_direction(
 }
 
 fn add_speed(mut commands: Commands, query: Query<Entity, (Added<Speed>, Without<Velocity>)>) {
-    for entity in query.iter() {
+    for entity in &query {
         commands.entity(entity).insert(Velocity {
             linvel: Vec2::ZERO,
             ..default()
@@ -384,7 +382,8 @@ fn log_area_descriptions<State>(
     }
 }
 
-pub const MOVEMENT_CONTROLS: &str = "MOVEMENT_CONTROLS";
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
+pub struct Movement;
 
 #[derive(Resource, Clone, Debug)]
 pub struct NavigationPlugin<State> {
@@ -405,7 +404,7 @@ impl<State> Default for NavigationPlugin<State> {
 
 impl<State> Plugin for NavigationPlugin<State>
 where
-    State: 'static + Clone + Copy + Debug + Eq + Hash + Send + Sync,
+    State: States,
 {
     fn build(&self, app: &mut App) {
         app.insert_resource(self.clone());
@@ -416,22 +415,19 @@ where
             .register_type::<RotationSpeed>()
             .register_type::<Speed>()
             .add_plugin(InputManagerPlugin::<NavigationAction>::default())
-            .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_system(controls.label(MOVEMENT_CONTROLS))
-                .add_system(snap.pipe(error_handler).before(MOVEMENT_CONTROLS));
-        } else {
-            for state in &self.states {
-                app.add_system_set(
-                    SystemSet::on_update(*state)
-                        .with_system(controls.label(MOVEMENT_CONTROLS))
-                        .with_system(snap.pipe(error_handler).before(MOVEMENT_CONTROLS)),
+            .add_systems((update_direction, add_speed).in_base_set(CoreSet::PreUpdate))
+            .add_systems(
+                (snap.pipe(error_handler), controls)
+                    .chain()
+                    .in_set(Movement),
+            )
+            .add_systems((tick_snap_timers, speak_direction.pipe(error_handler)))
+            .add_systems(
+                (remove_direction, log_area_descriptions::<State>).in_base_set(CoreSet::PostUpdate),
             );
+        if !self.states.is_empty() {
+            for state in &self.states {
+                app.configure_set(Movement.in_set(OnUpdate(state.clone())));
             }
         }
     }

src/pathfinding.rs

@@ -14,7 +14,6 @@ use leafwing_input_manager::{axislike::DualAxisData, plugin::InputManagerSystem,
 use pathfinding::prelude::*;
 
 use crate::{
-    commands::RunIfExistsExt,
     core::{PointLike, TransformExt},
     map::{Map, MapObstruction},
     navigation::{NavigationAction, RotationSpeed},
@@ -235,16 +234,16 @@ fn calculate_path(
                 shape_clone,
             )
         });
-        commands.run_if_exists(entity, |mut entity| {
-            entity.insert(Calculating(task));
-            entity.remove::<Path>();
-            entity.remove::<NoPath>();
-        });
+        commands
+            .entity(entity)
+            .insert(Calculating(task))
+            .remove::<Path>()
+            .remove::<NoPath>();
     }
 }
 
 fn poll_tasks(mut commands: Commands, mut query: Query<(Entity, &mut Calculating)>) {
-    for (entity, mut calculating) in query.iter_mut() {
+    for (entity, mut calculating) in &mut query {
         if let Some(result) = future::block_on(future::poll_once(&mut **calculating)) {
             if let Some(path) = result {
                 trace!("{entity:?}: Path: {path:?}");
@@ -261,9 +260,9 @@ fn poll_tasks(mut commands: Commands, mut query: Query<(Entity, &mut Calculating
 fn remove_destination(
     mut commands: Commands,
     entities: &Entities,
-    removed: RemovedComponents<Destination>,
+    mut removed: RemovedComponents<Destination>,
 ) {
-    for entity in removed.iter() {
+    for entity in &mut removed {
         if entities.contains(entity) {
             commands.entity(entity).remove::<Calculating>();
         }
@@ -324,7 +323,7 @@ fn negotiate_path(
                 start,
                 transform.yaw().radians(),
                 direction,
-                &*collider,
+                collider,
                 rapier_context.integration_parameters.dt,
                 QueryFilter::new()
                     .exclude_sensors()
@@ -408,18 +407,13 @@ impl Plugin for PathfindingPlugin {
             .register_type::<NoPath>()
             .register_type::<Path>()
             .register_type::<CostMap>()
-            .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_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,
-                actions
-                    .after(InputManagerSystem::Update)
-                    .before(calculate_path),
-            );
+            .add_system(remove_destination.in_base_set(CoreSet::PostUpdate));
     }
 }

src/sound/footstep.rs

@@ -4,7 +4,7 @@ use bevy::{prelude::*, transform::TransformSystem};
 use bevy_synthizer::{Buffer, Sound};
 use rand::random;
 
-use crate::{commands::RunIfExistsExt, core::PointLike};
+use crate::core::PointLike;
 
 #[derive(Component, Clone, Debug, Reflect)]
 #[reflect(Component)]
@@ -29,15 +29,13 @@ impl Default for Footstep {
 }
 
 fn added(mut commands: Commands, footsteps: Query<(Entity, &Footstep), Added<Footstep>>) {
-    for (entity, footstep) in footsteps.iter() {
+    for (entity, footstep) in &footsteps {
         let buffer = footstep.buffer.clone();
-        commands.run_if_exists(entity, move |mut entity| {
-            entity.insert(Sound {
-                buffer,
+        commands.entity(entity).insert(Sound {
+            audio: buffer.into(),
             paused: true,
             ..default()
         });
-        });
     }
 }
 
@@ -46,7 +44,7 @@ fn update(
     mut footsteps: Query<(Entity, &Footstep, &Parent, &mut Sound)>,
     transforms_storage: Query<&GlobalTransform>,
 ) {
-    for (entity, footstep, parent, mut sound) in footsteps.iter_mut() {
+    for (entity, footstep, parent, mut sound) in &mut footsteps {
         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,10 +74,11 @@ pub struct FootstepPlugin;
 impl Plugin for FootstepPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<Footstep>()
-            .add_system_to_stage(CoreStage::PreUpdate, added)
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
-                update.after(TransformSystem::TransformPropagate),
+            .add_system(added.in_base_set(CoreSet::PreUpdate))
+            .add_system(
+                update
+                    .after(TransformSystem::TransformPropagate)
+                    .in_base_set(CoreSet::PostUpdate),
             );
     }
 }

src/sound/icon.rs

@@ -1,12 +1,11 @@
-use std::{fmt::Debug, hash::Hash, time::Duration};
+use std::{fmt::Debug, time::Duration};
 
 use bevy::prelude::*;
-use bevy_synthizer::{Buffer, Sound};
+use bevy_synthizer::{Audio, Buffer, Sound};
 
 use rand::random;
 
 use crate::{
-    commands::RunIfExistsExt,
     core::Player,
     exploration::ExplorationFocused,
     visibility::{VisibilityChanged, Visible, VisibleEntities},
@@ -39,21 +38,19 @@ impl Default for SoundIcon {
 }
 
 fn added(mut commands: Commands, icons: Query<(Entity, &SoundIcon), Added<SoundIcon>>) {
-    for (entity, icon) in icons.iter() {
+    for (entity, icon) in &icons {
         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 {
-                buffer,
+        commands.entity(entity).insert(Sound {
+            audio: buffer.into(),
             gain,
             pitch,
             looping,
             paused: true,
             ..default()
         });
-        });
     }
 }
 
@@ -70,13 +67,13 @@ fn update<S>(
         &mut Sound,
     )>,
 ) where
-    S: 'static + Clone + Debug + Eq + Hash + Send + Sync,
+    S: States,
 {
-    if !config.states.is_empty() && !config.states.contains(state.current()) {
+    if !config.states.is_empty() && !config.states.contains(&state.0) {
         return;
     }
-    for visible in viewers.iter() {
-        for (icon_entity, mut icon, visibility, parent, mut sound) in icons.iter_mut() {
+    for visible in &viewers {
+        for (icon_entity, mut icon, visibility, parent, mut sound) in &mut icons {
             let entity = if visibility.is_some() {
                 Some(icon_entity)
             } else if parent.is_some() {
@@ -97,8 +94,9 @@ fn update<S>(
                         }
                     }
                     let buffer = icon.buffer.clone();
-                    if sound.buffer != buffer {
-                        sound.buffer = buffer;
+                    let audio: Audio = buffer.into();
+                    if sound.audio != audio {
+                        sound.audio = audio;
                     }
                     sound.gain = icon.gain;
                     sound.pitch = icon.pitch;
@@ -117,7 +115,7 @@ fn exploration_focus_changed(
     mut icons: Query<&mut SoundIcon>,
 ) {
     const ICON_GAIN: f64 = 3.;
-    for (entity, children) in focused.iter_mut() {
+    for (entity, children) in &mut focused {
         if let Ok(mut icon) = icons.get_mut(entity) {
             icon.gain *= ICON_GAIN;
         }
@@ -132,12 +130,12 @@ fn exploration_focus_changed(
 }
 
 fn exploration_focus_removed(
-    removed: RemovedComponents<ExplorationFocused>,
+    mut removed: RemovedComponents<ExplorationFocused>,
     mut query: Query<&mut SoundIcon>,
     children: Query<&Children>,
 ) {
     const ICON_GAIN: f64 = 3.;
-    for entity in removed.iter() {
+    for entity in &mut removed {
         if let Ok(mut icon) = query.get_mut(entity) {
             icon.gain /= ICON_GAIN;
         }
@@ -196,21 +194,21 @@ impl<S> Default for SoundIconPlugin<S> {
 
 impl<S> Plugin for SoundIconPlugin<S>
 where
-    S: 'static + Clone + Debug + Eq + Hash + Send + Sync,
+    S: States,
 {
     fn build(&self, app: &mut App) {
         app.insert_resource(self.clone())
             .register_type::<SoundIcon>()
-            .add_system(added)
-            .add_system_to_stage(CoreStage::PostUpdate, update::<S>)
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
-                exploration_focus_changed.after(update::<S>),
+            .add_systems((added, reset_timer_on_visibility_gain).in_base_set(CoreSet::PreUpdate))
+            .add_systems(
+                (exploration_focus_changed, update::<S>)
+                    .chain()
+                    .in_base_set(CoreSet::PreUpdate),
             )
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
-                exploration_focus_removed.after(exploration_focus_changed),
-            )
-            .add_system_to_stage(CoreStage::PostUpdate, reset_timer_on_visibility_gain);
+            .add_system(
+                exploration_focus_removed
+                    .in_base_set(CoreSet::PostUpdate)
+                    .after(exploration_focus_changed),
+            );
     }
 }

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 sounds.iter_mut() {
+    for mut sound in &mut sounds {
         sound.reference_distance *= pixels_per_unit;
         if sound.max_distance != f32::MAX {
             sound.max_distance *= pixels_per_unit;
@@ -30,12 +30,13 @@ impl<'a, S> Default for SoundPlugins<'a, S> {
 
 impl<S> PluginGroup for SoundPlugins<'static, S>
 where
-    S: 'static + Clone + Debug + Eq + Hash + Send + Sync,
+    S: States,
 {
     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/pitch_shift.rs

@@ -4,7 +4,6 @@ use bevy::prelude::*;
 
 use crate::{
     bevy_synthizer::{Listener, Sound},
-    commands::RunIfExistsExt,
     sound::SoundIcon,
 };
 
@@ -22,7 +21,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.iter() {
+            for (entity, transform, sound, icon) in &sounds {
                 if icon.is_none() && sound.is_none() {
                     continue;
                 }
@@ -30,21 +29,15 @@ fn tag_behind(
                 let dot = v.dot(listener_forward);
                 let is_behind = dot <= 0.;
                 if is_behind {
-                    commands.run_if_exists(entity, |mut entity| {
-                        entity.insert(Behind);
-                    });
+                    commands.entity(entity).insert(Behind);
                 } else if !is_behind {
-                    commands.run_if_exists(entity, |mut entity| {
-                        entity.remove::<Behind>();
-                    });
+                    commands.entity(entity).remove::<Behind>();
                 }
             }
         }
     } else {
-        for entity in behind.iter() {
-            commands.run_if_exists(entity, |mut entity| {
-                entity.remove::<Behind>();
-            });
+        for entity in &behind {
+            commands.entity(entity).remove::<Behind>();
         }
     }
 }
@@ -61,7 +54,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 query.iter_mut() {
+    for (entity, icon, sound) in &mut query {
         if let Some(mut icon) = icon {
             icon.pitch *= config.downshift;
             last_icon_pitch.insert(entity, icon.pitch);
@@ -76,12 +69,12 @@ fn behind_removed(
     config: Res<PitchShiftPlugin>,
     mut last_icon_pitch: ResMut<LastIconPitch>,
     mut last_sound_pitch: ResMut<LastSoundPitch>,
-    removed: RemovedComponents<Behind>,
+    mut removed: RemovedComponents<Behind>,
     mut icons: Query<&mut SoundIcon>,
     mut sounds: Query<&mut Sound>,
 ) {
     let downshift = 1. / config.downshift;
-    for entity in removed.iter() {
+    for entity in &mut removed {
         if let Ok(mut icon) = icons.get_mut(entity) {
             icon.pitch *= downshift;
             last_icon_pitch.remove(&entity);
@@ -97,7 +90,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 icons.iter_mut() {
+    for (entity, mut icon) in &mut icons {
         let should_change = if let Some(pitch) = last_icon_pitch.get(&entity) {
             *pitch != icon.pitch
         } else {
@@ -115,7 +108,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 sounds.iter_mut() {
+    for (entity, mut sound) in &mut sounds {
         let should_change = if let Some(pitch) = last_sound_pitch.get(&entity) {
             *pitch != sound.pitch
         } else {
@@ -134,7 +127,7 @@ fn sync_config(
     behind: Query<Entity, With<Behind>>,
 ) {
     if config.is_changed() {
-        for entity in behind.iter() {
+        for entity in &behind {
             commands.entity(entity).remove::<Behind>();
         }
     }
@@ -161,11 +154,8 @@ impl Plugin for PitchShiftPlugin {
             .register_type::<Behind>()
             .init_resource::<LastIconPitch>()
             .init_resource::<LastSoundPitch>()
-            .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);
+            .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));
     }
 }

src/sound/volumetric.rs

@@ -2,7 +2,7 @@ use bevy::{prelude::*, transform::TransformSystem};
 use bevy_rapier2d::{parry::query::ClosestPoints, prelude::*};
 use bevy_synthizer::{Listener, Sound};
 
-use crate::{commands::RunIfExistsExt, core::GlobalTransformExt};
+use crate::core::GlobalTransformExt;
 
 #[derive(Component, Default, Reflect, Clone, Copy, Debug)]
 #[reflect(Component)]
@@ -39,11 +39,15 @@ fn update(
     }
 }
 
-fn removed(mut commands: Commands, removed: RemovedComponents<Volumetric>) {
-    for entity in removed.iter() {
-        commands.run_if_exists(entity, |mut entity| {
-            entity.insert(TransformBundle::default());
-        });
+fn removed(
+    mut commands: Commands,
+    mut removed: RemovedComponents<Volumetric>,
+    transforms: Query<Entity, (With<Transform>, With<GlobalTransform>)>,
+) {
+    for entity in &mut removed {
+        if transforms.get(entity).is_ok() {
+            commands.entity(entity).insert(TransformBundle::default());
+        }
     }
 }
 
@@ -52,10 +56,11 @@ pub struct VolumetricPlugin;
 impl Plugin for VolumetricPlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<Volumetric>()
-            .add_system_to_stage(
-                CoreStage::PostUpdate,
-                update.before(TransformSystem::TransformPropagate),
+            .add_system(
+                update
+                    .in_base_set(CoreSet::PostUpdate)
+                    .before(TransformSystem::TransformPropagate),
             )
-            .add_system_to_stage(CoreStage::PostUpdate, removed);
+            .add_system(removed.in_base_set(CoreSet::PostUpdate));
     }
 }

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.iter() {
+    for (entity, map) in &query {
         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(
-    query: RemovedComponents<Viewshed>,
+    mut query: RemovedComponents<Viewshed>,
     visible_entities: Query<&VisibleEntities>,
     mut events: EventWriter<VisibilityChanged>,
 ) {
-    for entity in query.iter() {
+    for entity in &mut query {
         if let Ok(visible) = visible_entities.get(entity) {
             for e in visible.iter() {
                 events.send(VisibilityChanged::Lost {
@@ -314,8 +314,7 @@ fn update_viewshed(
         return;
     }
     let mut cache = HashMap::new();
-    for (viewer_entity, mut viewshed, mut visible_entities, viewer_transform) in viewers.iter_mut()
-    {
+    for (viewer_entity, mut viewshed, mut visible_entities, viewer_transform) in &mut viewers {
         viewshed.update(
             &viewer_entity,
             &mut visible_entities,
@@ -330,7 +329,7 @@ fn update_viewshed(
 }
 
 fn remove_visible(
-    removed: RemovedComponents<Visible>,
+    mut removed: RemovedComponents<Visible>,
     mut viewers: Query<(
         Entity,
         &mut Viewshed,
@@ -342,10 +341,10 @@ fn remove_visible(
     obstructions: Query<&MapObstruction>,
     mut changed: EventWriter<VisibilityChanged>,
 ) {
-    if removed.iter().len() != 0 {
+    if !removed.is_empty() {
         let mut cache = HashMap::new();
-        for removed in removed.iter() {
-            for (viewer_entity, mut viewshed, mut visible_entities, start) in viewers.iter_mut() {
+        for removed in &mut removed {
+            for (viewer_entity, mut viewshed, mut visible_entities, start) in &mut viewers {
                 if !visible_entities.contains(&removed) {
                     continue;
                 }
@@ -369,8 +368,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.iter() {
-        for (map, mut revealed_tiles) in map.iter_mut() {
+    for viewshed in &viewers {
+        for (map, mut revealed_tiles) in &mut map {
             for v in viewshed.visible_points.iter() {
                 let idx = v.to_index(map.width);
                 if idx >= revealed_tiles.len() {
@@ -441,11 +440,15 @@ 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_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);
+            .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));
     }
 }