Cargo.toml

@@ -13,25 +13,27 @@ 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",
 ]
 
 [dependencies]
-bevy_rapier2d = "0.21"
-bevy_synthizer = "0.2"
-bevy_tts = { version = "0.5", default-features = false, features = ["tolk"] }
+backtrace = "0.3"
+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"

README.md

@@ -15,6 +15,8 @@ _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
@@ -47,4 +49,5 @@ 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 piped errors in systems
+  * Logger for logging panic stacktraces
+  * Panic handler for sending stacktraces to [Sentry](https://sentry.io) in release builds

src/commands.rs

@@ -0,0 +1,22 @@
+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,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/error.rs

@@ -1,5 +1,7 @@
 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>>>) {
@@ -7,3 +9,45 @@ 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 &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>,
@@ -383,13 +389,10 @@ 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: States,
+    State: 'static + Clone + Debug + Eq + Hash + Send + Sync,
     MapData: 'static + Clone + Default + Send + Sync,
 {
     fn build(&self, app: &mut App) {
@@ -401,30 +404,37 @@ where
             .register_type::<Mappable>()
             .register_type::<Explorable>()
             .add_plugin(InputManagerPlugin::<ExplorationAction>::default())
-            .add_systems(
-                (
-                    exploration_type_change::<ExplorationType, State>.pipe(error_handler),
+            .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,
                     exploration_type_changed_announcement::<ExplorationType>.pipe(error_handler),
-                )
-                    .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() {
+                );
+        } else {
             let states = config.states;
             for state in states {
-                app.configure_set(Exploration.in_set(OnUpdate(state.clone())))
-                    .add_system(cleanup.in_schedule(OnExit(state)));
+                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));
             }
         }
     }

src/lib.rs

@@ -6,6 +6,7 @@ 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;
@@ -19,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

@@ -6,6 +6,7 @@ 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},
@@ -82,58 +83,6 @@ 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>,
@@ -275,12 +224,63 @@ 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>();
             }
         }
     }
 }
+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 &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,12 +304,14 @@ 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.entity(entity).remove::<CardinalDirection>();
+            commands.run_if_exists(entity, |mut entity| {
+                entity.remove::<CardinalDirection>();
+            });
         }
     }
 }
@@ -317,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>> {
@@ -331,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()
@@ -382,8 +384,7 @@ fn log_area_descriptions<State>(
     }
 }
 
-#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
-pub struct Movement;
+pub const MOVEMENT_CONTROLS: &str = "MOVEMENT_CONTROLS";
 
 #[derive(Resource, Clone, Debug)]
 pub struct NavigationPlugin<State> {
@@ -404,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());
@@ -415,19 +416,22 @@ where
             .register_type::<RotationSpeed>()
             .register_type::<Speed>()
             .add_plugin(InputManagerPlugin::<NavigationAction>::default())
-            .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() {
+            .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.configure_set(Movement.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

@@ -14,6 +14,7 @@ use leafwing_input_manager::{axislike::DualAxisData, plugin::InputManagerSystem,
 use pathfinding::prelude::*;
 
 use crate::{
+    commands::RunIfExistsExt,
     core::{PointLike, TransformExt},
     map::{Map, MapObstruction},
     navigation::{NavigationAction, RotationSpeed},
@@ -234,16 +235,16 @@ fn calculate_path(
                 shape_clone,
             )
         });
-        commands
-            .entity(entity)
-            .insert(Calculating(task))
-            .remove::<Path>()
-            .remove::<NoPath>();
+        commands.run_if_exists(entity, |mut entity| {
+            entity.insert(Calculating(task));
+            entity.remove::<Path>();
+            entity.remove::<NoPath>();
+        });
     }
 }
 
 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:?}");
@@ -260,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>();
         }
@@ -323,7 +324,7 @@ fn negotiate_path(
                 start,
                 transform.yaw().radians(),
                 direction,
-                collider,
+                &*collider,
                 rapier_context.integration_parameters.dt,
                 QueryFilter::new()
                     .exclude_sensors()
@@ -407,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

@@ -4,6 +4,7 @@ use bevy::prelude::*;
 
 use crate::{
     bevy_synthizer::{Listener, Sound},
+    commands::RunIfExistsExt,
     sound::SoundIcon,
 };
 
@@ -21,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;
                 }
@@ -29,15 +30,21 @@ fn tag_behind(
                 let dot = v.dot(listener_forward);
                 let is_behind = dot <= 0.;
                 if is_behind {
-                    commands.entity(entity).insert(Behind);
+                    commands.run_if_exists(entity, |mut entity| {
+                        entity.insert(Behind);
+                    });
                 } else if !is_behind {
-                    commands.entity(entity).remove::<Behind>();
+                    commands.run_if_exists(entity, |mut entity| {
+                        entity.remove::<Behind>();
+                    });
                 }
             }
         }
     } else {
-        for entity in &behind {
-            commands.entity(entity).remove::<Behind>();
+        for entity in behind.iter() {
+            commands.run_if_exists(entity, |mut entity| {
+                entity.remove::<Behind>();
+            });
         }
     }
 }
@@ -54,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);
@@ -69,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);
@@ -90,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 {
@@ -108,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 {
@@ -127,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>();
         }
     }
@@ -154,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

@@ -4,7 +4,7 @@ use bevy::{prelude::*, transform::TransformSystem};
 use bevy_synthizer::{Buffer, Sound};
 use rand::random;
 
-use crate::core::PointLike;
+use crate::{commands::RunIfExistsExt, core::PointLike};
 
 #[derive(Component, Clone, Debug, Reflect)]
 #[reflect(Component)]
@@ -29,12 +29,14 @@ 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.entity(entity).insert(Sound {
-            audio: buffer.into(),
-            paused: true,
-            ..default()
+        commands.run_if_exists(entity, move |mut entity| {
+            entity.insert(Sound {
+                buffer,
+                paused: true,
+                ..default()
+            });
         });
     }
 }
@@ -44,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));
@@ -74,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,11 +1,12 @@
-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;
 
 use crate::{
+    commands::RunIfExistsExt,
     core::Player,
     exploration::ExplorationFocused,
     visibility::{VisibilityChanged, Visible, VisibleEntities},
@@ -38,18 +39,20 @@ 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.entity(entity).insert(Sound {
-            audio: buffer.into(),
-            gain,
-            pitch,
-            looping,
-            paused: true,
-            ..default()
+        commands.run_if_exists(entity, move |mut entity| {
+            entity.insert(Sound {
+                buffer,
+                gain,
+                pitch,
+                looping,
+                paused: true,
+                ..default()
+            });
         });
     }
 }
@@ -67,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() {
@@ -94,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;
@@ -115,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;
         }
@@ -130,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;
         }
@@ -194,21 +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_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(added)
+            .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_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

@@ -2,7 +2,7 @@ use bevy::{prelude::*, transform::TransformSystem};
 use bevy_rapier2d::{parry::query::ClosestPoints, prelude::*};
 use bevy_synthizer::{Listener, Sound};
 
-use crate::core::GlobalTransformExt;
+use crate::{commands::RunIfExistsExt, core::GlobalTransformExt};
 
 #[derive(Component, Default, Reflect, Clone, Copy, Debug)]
 #[reflect(Component)]
@@ -39,15 +39,11 @@ fn update(
     }
 }
 
-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());
-        }
+fn removed(mut commands: Commands, removed: RemovedComponents<Volumetric>) {
+    for entity in removed.iter() {
+        commands.run_if_exists(entity, |mut entity| {
+            entity.insert(TransformBundle::default());
+        });
     }
 }
 
@@ -56,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);
     }
 }