From 827cae1a4b7d5b2bc6f7a2b66335077c7b38e833 Mon Sep 17 00:00:00 2001
From: Nolan Darilek <nolan@thewordnerd.info>
Date: Sun, 6 Oct 2024 17:17:48 -0500
Subject: [PATCH 1/7] Remove `Angle` and standardize direction types.

---
 src/core.rs        | 377 +++++++++++++++++----------------------------
 src/navigation.rs  |  49 +++---
 src/pathfinding.rs |  23 +--
 3 files changed, 176 insertions(+), 273 deletions(-)

diff --git a/src/core.rs b/src/core.rs
index 80ad04d..0f7cd5f 100644
--- a/src/core.rs
+++ b/src/core.rs
@@ -2,11 +2,14 @@ use std::{
     cmp::{max, min},
     f32::consts::PI,
     fmt::Display,
-    ops::Sub,
     sync::RwLock,
 };
 
-use bevy::{app::PluginGroupBuilder, math::FloatOrd, prelude::*};
+use bevy::{
+    app::PluginGroupBuilder,
+    math::{CompassOctant, CompassQuadrant, FloatOrd},
+    prelude::*,
+};
 use bevy_rapier2d::{
     parry::query::{closest_points, distance, ClosestPoints},
     prelude::*,
@@ -16,175 +19,91 @@ use once_cell::sync::Lazy;
 use rand::prelude::*;
 use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Copy, Debug, Reflect)]
-pub enum Angle {
-    Degrees(f32),
-    Radians(f32),
+fn relative_desc(rot: &Rot2) -> String {
+    let mode = RELATIVE_DIRECTION_MODE.read().unwrap();
+    match rot.as_radians() {
+        v if v <= PI / 12. && v > -PI / 12. => "ahead",
+        v if v <= PI / 4. && v > PI / 12. => {
+            if *mode == RelativeDirectionMode::ClockFacing {
+                "11:00"
+            } else {
+                "ahead and left"
+            }
+        }
+        v if v <= 3. * PI / 8. && v > PI / 4. => {
+            if *mode == RelativeDirectionMode::ClockFacing {
+                "10:00"
+            } else {
+                "left and ahead"
+            }
+        }
+        v if v <= 5. * PI / 8. && v > 3. * PI / 8. => "left",
+        v if v <= 3. * PI / 4. && v > 5. * PI / 8. => {
+            if *mode == RelativeDirectionMode::ClockFacing {
+                "8:00"
+            } else {
+                "left and behind"
+            }
+        }
+        v if v <= 11. * PI / 12. && v > 3. * PI / 4. => {
+            if *mode == RelativeDirectionMode::ClockFacing {
+                "7:00"
+            } else {
+                "behind and left"
+            }
+        }
+        v if v <= PI && v > 11. * PI / 12. || v > -PI && v <= -11. * PI / 12. => "behind",
+        v if v <= -3. * PI / 4. && v > -11. * PI / 12. => {
+            if *mode == RelativeDirectionMode::ClockFacing {
+                "5:00"
+            } else {
+                "behind and right"
+            }
+        }
+        v if v <= -5. * PI / 8. && v > -3. * PI / 4. => {
+            if *mode == RelativeDirectionMode::ClockFacing {
+                "4:00"
+            } else {
+                "right and behind"
+            }
+        }
+        v if v <= -3. * PI / 8. && v > -5. * PI / 8. => "right",
+        v if v <= -PI / 4. && v > -3. * PI / 8. => {
+            if *mode == RelativeDirectionMode::ClockFacing {
+                "2:00"
+            } else {
+                "right and ahead"
+            }
+        }
+        v if v <= -PI / 12. && v > -PI / 4. => {
+            if *mode == RelativeDirectionMode::ClockFacing {
+                "1:00"
+            } else {
+                "ahead and right"
+            }
+        }
+        _ => "ahead",
+    }
+    .into()
 }
 
-impl Default for Angle {
-    fn default() -> Self {
-        Self::Radians(0.)
-    }
-}
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Deref, DerefMut, Reflect)]
+pub struct MovementDirection(CompassOctant);
 
-impl Angle {
-    pub fn degrees(&self) -> f32 {
-        use Angle::*;
-        let mut degrees: f32 = match self {
-            Degrees(v) => *v,
-            Radians(v) => v.to_degrees(),
-        };
-        while degrees < 0. {
-            degrees += 360.;
-        }
-        while degrees >= 360. {
-            degrees %= 360.;
-        }
-        degrees
-    }
-
-    pub fn degrees_u32(&self) -> u32 {
-        self.degrees() as u32
-    }
-
-    pub fn radians(&self) -> f32 {
-        use Angle::*;
-        match self {
-            Degrees(v) => v.to_radians(),
-            Radians(v) => *v,
-        }
-    }
-
-    fn relative_desc(&self) -> String {
-        let mode = RELATIVE_DIRECTION_MODE.read().unwrap();
-        match self.degrees() {
-            v if v <= 15. => "ahead",
-            v if v <= 45. => {
-                if *mode == RelativeDirectionMode::ClockFacing {
-                    "11:00"
-                } else {
-                    "ahead and left"
-                }
-            }
-            v if v <= 75. => {
-                if *mode == RelativeDirectionMode::ClockFacing {
-                    "10:00"
-                } else {
-                    "left and ahead"
-                }
-            }
-            v if v <= 105. => "left",
-            v if v <= 135. => {
-                if *mode == RelativeDirectionMode::ClockFacing {
-                    "8:00"
-                } else {
-                    "left and behind"
-                }
-            }
-            v if v <= 165. => {
-                if *mode == RelativeDirectionMode::ClockFacing {
-                    "7:00"
-                } else {
-                    "behind and left"
-                }
-            }
-            v if v <= 195. => "behind",
-            v if v <= 225. => {
-                if *mode == RelativeDirectionMode::ClockFacing {
-                    "5:00"
-                } else {
-                    "behind and right"
-                }
-            }
-            v if v <= 255. => {
-                if *mode == RelativeDirectionMode::ClockFacing {
-                    "4:00"
-                } else {
-                    "right and behind"
-                }
-            }
-            v if v <= 285. => "right",
-            v if v <= 315. => {
-                if *mode == RelativeDirectionMode::ClockFacing {
-                    "2:00"
-                } else {
-                    "right and ahead"
-                }
-            }
-            v if v <= 345. => {
-                if *mode == RelativeDirectionMode::ClockFacing {
-                    "1:00"
-                } else {
-                    "ahead and right"
-                }
-            }
-            _ => "ahead",
-        }
-        .into()
-    }
-}
-
-impl Sub for Angle {
-    type Output = Self;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        match self {
-            Angle::Degrees(v1) => match rhs {
-                Angle::Degrees(v2) => Angle::Degrees(v1 - v2),
-                Angle::Radians(v2) => Angle::Degrees(v1 - v2.to_degrees()),
-            },
-            Angle::Radians(v1) => match rhs {
-                Angle::Degrees(v2) => Angle::Radians(v1 - v2.to_radians()),
-                Angle::Radians(v2) => Angle::Radians(v1 - v2),
-            },
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Reflect)]
-pub enum MovementDirection {
-    North,
-    NorthNortheast,
-    Northeast,
-    EastNortheast,
-    East,
-    EastSoutheast,
-    Southeast,
-    SouthSoutheast,
-    South,
-    SouthSouthwest,
-    Southwest,
-    WestSouthwest,
-    West,
-    WestNorthwest,
-    Northwest,
-    NorthNorthwest,
-}
-
-impl From<Angle> for MovementDirection {
-    fn from(angle: Angle) -> Self {
-        let heading = angle.degrees();
-        use MovementDirection::*;
-        match heading {
-            h if h < 11.5 => East,
-            h if h < 34.0 => EastNortheast,
-            h if h < 56.5 => Northeast,
-            h if h < 79.0 => NorthNortheast,
-            h if h < 101.5 => North,
-            h if h < 124.0 => NorthNorthwest,
-            h if h < 146.5 => Northwest,
-            h if h < 169.0 => WestNorthwest,
-            h if h < 191.5 => West,
-            h if h < 214.0 => WestSouthwest,
-            h if h < 236.5 => Southwest,
-            h if h < 259.0 => SouthSouthwest,
-            h if h < 281.5 => South,
-            h if h < 304.0 => SouthSoutheast,
-            h if h < 326.5 => Southeast,
-            h if h <= 349.0 => EastSoutheast,
-            _ => East,
-        }
+impl From<Rot2> for MovementDirection {
+    fn from(rot: Rot2) -> Self {
+        use CompassOctant::*;
+        MovementDirection(match rot.as_radians() {
+            h if h > -PI / 8. && h <= PI / 8. => East,
+            h if h > PI / 8. && h <= 3. * PI / 8. => NorthEast,
+            h if h > 3. * PI / 8. && h <= 5. * PI / 8. => North,
+            h if h > 5. * PI / 8. && h <= 7. * PI / 8. => NorthWest,
+            h if h > 7. * PI / 8. || h <= -7. * PI / 8. => East,
+            h if h > -7. * PI / 8. && h <= -5. * PI / 8. => SouthEast,
+            h if h > -5. * PI / 8. && h <= -3. * PI / 8. => South,
+            h if h > -3. * PI / 8. && h <= -PI / 8. => SouthWest,
+            _ => West,
+        })
     }
 }
 
@@ -192,25 +111,18 @@ impl From<Angle> for MovementDirection {
 #[allow(clippy::from_over_into)]
 impl Into<String> for MovementDirection {
     fn into(self) -> String {
-        use MovementDirection::*;
-        match self {
-            North => "north".to_string(),
-            NorthNortheast => "north northeast".to_string(),
-            Northeast => "northeast".to_string(),
-            EastNortheast => "east northeast".to_string(),
-            East => "east".to_string(),
-            EastSoutheast => "east southeast".to_string(),
-            Southeast => "southeast".to_string(),
-            SouthSoutheast => "south southeast".to_string(),
-            South => "south".to_string(),
-            SouthSouthwest => "south southwest".to_string(),
-            Southwest => "southwest".to_string(),
-            WestSouthwest => "west southwest".to_string(),
-            West => "west".to_string(),
-            WestNorthwest => "west northwest".to_string(),
-            Northwest => "northwest".to_string(),
-            NorthNorthwest => "north northwest".to_string(),
+        use CompassOctant::*;
+        match self.0 {
+            North => "north",
+            NorthEast => "northeast",
+            East => "east",
+            SouthEast => "southeast",
+            South => "south",
+            SouthWest => "southwest",
+            West => "west",
+            NorthWest => "northwest",
         }
+        .into()
     }
 }
 
@@ -221,38 +133,36 @@ impl Display for MovementDirection {
     }
 }
 
-#[derive(Component, Clone, Copy, Default, Debug, Eq, PartialEq, Reflect)]
+#[derive(Component, Clone, Copy, Debug, Eq, PartialEq, Deref, DerefMut, Reflect)]
 #[reflect(Component)]
-pub enum CardinalDirection {
-    #[default]
-    North,
-    East,
-    South,
-    West,
-}
+pub struct CardinalDirection(pub CompassQuadrant);
 
-impl From<Angle> for CardinalDirection {
-    fn from(angle: Angle) -> Self {
-        let heading = angle.degrees();
-        use CardinalDirection::*;
-        match heading {
-            h if h <= 45. => East,
-            h if h <= 135. => North,
-            h if h <= 225. => West,
-            h if h <= 315. => South,
-            _ => East,
-        }
+impl Default for CardinalDirection {
+    fn default() -> Self {
+        Self(CompassQuadrant::East)
     }
 }
 
-impl From<&CardinalDirection> for Angle {
+impl From<Rot2> for CardinalDirection {
+    fn from(rot: Rot2) -> Self {
+        use CompassQuadrant::*;
+        CardinalDirection(match rot.as_radians() {
+            h if h > -PI / 4. && h <= PI / 4. => East,
+            h if h > PI / 4. && h <= 3. * PI / 4. => North,
+            h if h > 3. * PI / 4. || h <= -3. * PI / 4. => West,
+            _ => South,
+        })
+    }
+}
+
+impl From<&CardinalDirection> for Rot2 {
     fn from(direction: &CardinalDirection) -> Self {
-        use CardinalDirection::*;
-        match direction {
-            North => Angle::Radians(PI / 2.),
-            East => Angle::Radians(0.),
-            South => Angle::Radians(PI * 1.5),
-            West => Angle::Radians(PI),
+        use CompassQuadrant::*;
+        match direction.0 {
+            North => Rot2::radians(PI / 2.),
+            East => Rot2::radians(0.),
+            South => Rot2::radians(-PI / 2.),
+            West => Rot2::radians(PI),
         }
     }
 }
@@ -261,8 +171,8 @@ impl From<&CardinalDirection> for Angle {
 #[allow(clippy::from_over_into)]
 impl Into<String> for CardinalDirection {
     fn into(self) -> String {
-        use CardinalDirection::*;
-        match self {
+        use CompassQuadrant::*;
+        match self.0 {
             North => "north".to_string(),
             East => "east".to_string(),
             South => "south".to_string(),
@@ -342,24 +252,26 @@ pub trait PointLike {
         self.distance_squared(other).sqrt()
     }
 
-    fn bearing(&self, other: &dyn PointLike) -> Angle {
+    fn bearing(&self, other: &dyn PointLike) -> Rot2 {
         let y = other.y() - self.y();
         let x = other.x() - self.x();
-        Angle::Radians(y.atan2(x))
+        Rot2::radians(y.atan2(x))
     }
 
     fn direction(&self, other: &dyn PointLike) -> MovementDirection {
         self.bearing(other).into()
     }
 
-    fn direction_and_distance(&self, other: &dyn PointLike, yaw: Option<Angle>) -> String {
+    fn direction_and_distance(&self, other: &dyn PointLike, yaw: Option<Rot2>) -> String {
         let mut tokens: Vec<String> = vec![];
         let distance = self.distance(other).round() as i32;
         if distance > 0 {
             let tile_or_tiles = if distance == 1 { "tile" } else { "tiles" };
             let direction: String = if let Some(yaw) = yaw {
-                let bearing = self.bearing(other);
-                (bearing - yaw).relative_desc()
+                let yaw = yaw.as_radians();
+                let bearing = self.bearing(other).as_radians();
+                let rot = Rot2::radians(bearing - yaw);
+                relative_desc(&rot)
             } else {
                 self.direction(other).into()
             };
@@ -481,18 +393,18 @@ impl From<&dyn PointLike> for (i32, i32) {
 }
 
 pub trait TransformExt {
-    fn yaw(&self) -> Angle;
+    fn yaw(&self) -> Rot2;
 }
 
 impl TransformExt for Transform {
-    fn yaw(&self) -> Angle {
+    fn yaw(&self) -> Rot2 {
         let forward = self.right();
-        Angle::Radians(forward.y.atan2(forward.x))
+        Rot2::radians(forward.y.atan2(forward.x))
     }
 }
 
 pub trait GlobalTransformExt {
-    fn yaw(&self) -> Angle;
+    fn yaw(&self) -> Rot2;
 
     fn closest_points(
         &self,
@@ -510,9 +422,9 @@ pub trait GlobalTransformExt {
 }
 
 impl GlobalTransformExt for GlobalTransform {
-    fn yaw(&self) -> Angle {
+    fn yaw(&self) -> Rot2 {
         let forward = self.right();
-        Angle::Radians(forward.y.atan2(forward.x))
+        Rot2::radians(forward.y.atan2(forward.x))
     }
 
     fn closest_points(
@@ -524,11 +436,11 @@ impl GlobalTransformExt for GlobalTransform {
         let scale = PHYSICS_SCALE.read().unwrap();
         let pos1 = Isometry::new(
             (self.translation() / *scale).xy().into(),
-            self.yaw().radians(),
+            self.yaw().as_radians(),
         );
         let pos2 = Isometry::new(
             (other.translation() / *scale).xy().into(),
-            other.yaw().radians(),
+            other.yaw().as_radians(),
         );
         closest_points(&pos1, &*collider.raw, &pos2, &*other_collider.raw, f32::MAX).unwrap()
     }
@@ -542,11 +454,11 @@ impl GlobalTransformExt for GlobalTransform {
         let scale = PHYSICS_SCALE.read().unwrap();
         let pos1 = Isometry::new(
             (self.translation() / *scale).xy().into(),
-            self.yaw().radians(),
+            self.yaw().as_radians(),
         );
         let pos2 = Isometry::new(
             (other.translation() / *scale).xy().into(),
-            other.yaw().radians(),
+            other.yaw().as_radians(),
         );
         let closest = self.closest_points(collider, other, other_collider);
         let distance = distance(&pos1, &*collider.raw, &pos2, &*other_collider.raw).unwrap() as u32;
@@ -555,9 +467,10 @@ impl GlobalTransformExt for GlobalTransform {
             if let ClosestPoints::WithinMargin(p1, p2) = closest {
                 let p1 = (p1.x, p1.y);
                 let p2 = (p2.x, p2.y);
-                let bearing = p1.bearing(&p2);
-                let yaw = self.yaw();
-                let direction = (bearing - yaw).relative_desc();
+                let bearing = p1.bearing(&p2).as_radians();
+                let yaw = self.yaw().as_radians();
+                let rot = Rot2::radians(bearing - yaw);
+                let direction = relative_desc(&rot);
                 format!("{direction} {distance} {tile_or_tiles}")
             } else {
                 format!("{} {}", distance, tile_or_tiles)
diff --git a/src/navigation.rs b/src/navigation.rs
index 7f3c451..8f6d084 100644
--- a/src/navigation.rs
+++ b/src/navigation.rs
@@ -1,12 +1,12 @@
 use std::{collections::HashMap, error::Error, f32::consts::PI, fmt::Debug, hash::Hash};
 
-use bevy::prelude::*;
+use bevy::{math::CompassQuadrant, prelude::*};
 use bevy_rapier2d::prelude::*;
 use bevy_tts::Tts;
 use leafwing_input_manager::prelude::*;
 
 use crate::{
-    core::{Angle, Area, CardinalDirection, GlobalTransformExt, Player, TransformExt},
+    core::{Area, CardinalDirection, GlobalTransformExt, Player, TransformExt},
     error::error_handler,
     log::Log,
     utils::target_and_other,
@@ -74,7 +74,7 @@ impl Default for StrafeMovementFactor {
 
 #[derive(Component, Clone, Copy, Default, Debug, Deref, DerefMut, Reflect)]
 #[reflect(Component)]
-pub struct RotationSpeed(pub Angle);
+pub struct RotationSpeed(pub Rot2);
 
 #[derive(Deref, DerefMut)]
 struct SnapTimer(Timer);
@@ -116,26 +116,28 @@ fn snap(
             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.,
+            transform.rotation = Quat::from_rotation_z(match direction.0 {
+                CompassQuadrant::North => PI,
+                CompassQuadrant::East => PI / 2.,
+                CompassQuadrant::South => 0.,
+                CompassQuadrant::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.,
+            transform.rotation = Quat::from_rotation_z(match direction.0 {
+                CompassQuadrant::North => 0.,
+                CompassQuadrant::East => -PI / 2.,
+                CompassQuadrant::South => PI,
+                CompassQuadrant::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();
+            println!("Direction: {direction:?}");
+            let yaw: Rot2 = direction.into();
+            let yaw = yaw.as_radians();
+            println!("Yaw: {yaw}");
             transform.rotation = Quat::from_rotation_z(yaw);
             tts.speak(direction.to_string(), true)?;
         }
@@ -220,7 +222,7 @@ fn controls(
             if rapier_context
                 .cast_shape(
                     transform.translation.truncate(),
-                    transform.yaw().radians(),
+                    transform.yaw().as_radians(),
                     pair,
                     collider,
                     ShapeCastOptions {
@@ -240,7 +242,7 @@ fn controls(
         if !snap_timers.contains_key(&entity) {
             if let Some(rotation_speed) = rotation_speed {
                 let delta =
-                    -rotation_speed.radians() * actions.clamped_value(&NavigationAction::Rotate);
+                    rotation_speed.as_radians() * actions.clamped_value(&NavigationAction::Rotate);
                 actions.set_value(&NavigationAction::SetAngularVelocity, delta);
             }
         }
@@ -288,16 +290,11 @@ fn remove_direction(
 
 fn speak_direction(
     mut tts: ResMut<Tts>,
-    player: Query<
-        (&CardinalDirection, Ref<CardinalDirection>),
-        (With<Player>, Changed<CardinalDirection>),
-    >,
+    player: Query<&CardinalDirection, (With<Player>, Changed<CardinalDirection>)>,
 ) -> Result<(), Box<dyn Error>> {
-    if let Ok((direction, change)) = player.get_single() {
-        if !change.is_added() {
-            let direction: String = (*direction).into();
-            tts.speak(direction, true)?;
-        }
+    if let Ok(direction) = player.get_single() {
+        let direction: String = (*direction).into();
+        tts.speak(direction, true)?;
     }
     Ok(())
 }
diff --git a/src/pathfinding.rs b/src/pathfinding.rs
index dabd6d6..6ea1304 100644
--- a/src/pathfinding.rs
+++ b/src/pathfinding.rs
@@ -175,11 +175,9 @@ fn calculate_path(
     >,
 ) {
     for (entity, handle, destination, coordinates, shape, cost_map) in &query {
-        trace
-!("{entity}: destination: {destination:?}");
+        trace!("{entity}: destination: {destination:?}");
         if coordinates.i32() == **destination {
-            trace
-!("{entity}: remove1");
+            trace!("{entity}: remove1");
             commands
                 .entity(entity)
                 .remove::<Path>()
@@ -229,8 +227,7 @@ fn calculate_path(
                 shape_clone,
             )
         });
-        trace
-!("{entity}: remove2");
+        trace!("{entity}: remove2");
         commands
             .entity(entity)
             .insert(Calculating(task))
@@ -255,8 +252,7 @@ fn poll_tasks(
                 trace!("{entity:?}: Path: {path:?}");
                 commands.entity(entity).insert(path);
             } else {
-                trace
-!(
+                trace!(
                     "{entity:?}: path: no path from {:?} to {:?}",
                     transform.translation.truncate().i32(),
                     **destination
@@ -349,7 +345,7 @@ fn negotiate_path(
             if rapier_context
                 .cast_shape(
                     start,
-                    transform.yaw().radians(),
+                    transform.yaw().as_radians(),
                     direction,
                     collider,
                     ShapeCastOptions {
@@ -362,8 +358,7 @@ fn negotiate_path(
                 )
                 .is_some()
             {
-                trace
-!("{entity:?} is stuck");
+                trace!("{entity:?} is stuck");
                 // TODO: Remove when we have an actual character controller.
                 next.x = next.x.trunc();
                 next.y = next.y.trunc();
@@ -376,8 +371,7 @@ fn negotiate_path(
                 transform.rotation = Quat::from_rotation_z(angle);
             }
         } else {
-            trace
-!("{entity:?}: empty path, cleaning");
+            trace!("{entity:?}: empty path, cleaning");
             if let Some(mut actions) = actions {
                 trace!("{entity:?}: Disabling pathfind because at destination");
                 actions.reset_all();
@@ -421,8 +415,7 @@ fn actions(
                     *current_dest = dest;
                 }
             } else {
-                trace
-!("{entity:?}: Adding destination, zeroing velocity");
+                trace!("{entity:?}: Adding destination, zeroing velocity");
                 navigation_action.set_axis_pair(&NavigationAction::SetLinearVelocity, Vec2::ZERO);
                 commands.entity(entity).insert(dest);
             }

From 44c40f64732581086fd7f3369182a0da91450a02 Mon Sep 17 00:00:00 2001
From: Nolan Darilek <nolan@thewordnerd.info>
Date: Sun, 1 Dec 2024 14:12:32 -0600
Subject: [PATCH 2/7] Remove unnecessary sets/speech from navigation controls.

---
 src/navigation.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/navigation.rs b/src/navigation.rs
index 8f6d084..c4167bb 100644
--- a/src/navigation.rs
+++ b/src/navigation.rs
@@ -99,7 +99,6 @@ impl Default for Speed {
 }
 
 fn snap(
-    mut tts: ResMut<Tts>,
     mut snap_timers: ResMut<SnapTimers>,
     mut query: Query<
         (
@@ -110,7 +109,7 @@ fn snap(
         ),
         With<Player>,
     >,
-) -> Result<(), Box<dyn Error>> {
+) {
     for (entity, actions, mut transform, direction) in &mut query {
         if snap_timers.contains_key(&entity) {
             continue;
@@ -138,11 +137,12 @@ fn snap(
             let yaw: Rot2 = direction.into();
             let yaw = yaw.as_radians();
             println!("Yaw: {yaw}");
-            transform.rotation = Quat::from_rotation_z(yaw);
-            tts.speak(direction.to_string(), true)?;
+            let rotation = Quat::from_rotation_z(yaw);
+            if transform.rotation != rotation {
+                transform.rotation = rotation;
+            }
         }
     }
-    Ok(())
 }
 
 fn tick_snap_timers(time: Res<Time>, mut snap_timers: ResMut<SnapTimers>) {
@@ -380,7 +380,7 @@ impl Plugin for NavigationPlugin {
             .add_systems(PreUpdate, (update_direction, add_speed))
             .add_systems(
                 Update,
-                (snap.pipe(error_handler), controls)
+                (snap, controls)
                     .chain()
                     .in_set(Movement),
             )

From 1cfbf7f65b64c987ec99080ff8e25ccd7ccc88f5 Mon Sep 17 00:00:00 2001
From: Nolan Darilek <nolan@thewordnerd.info>
Date: Sun, 1 Dec 2024 15:30:08 -0600
Subject: [PATCH 3/7] Fix wrong directions.

---
 src/core.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/core.rs b/src/core.rs
index 0f7cd5f..360bb02 100644
--- a/src/core.rs
+++ b/src/core.rs
@@ -98,10 +98,10 @@ impl From<Rot2> for MovementDirection {
             h if h > PI / 8. && h <= 3. * PI / 8. => NorthEast,
             h if h > 3. * PI / 8. && h <= 5. * PI / 8. => North,
             h if h > 5. * PI / 8. && h <= 7. * PI / 8. => NorthWest,
-            h if h > 7. * PI / 8. || h <= -7. * PI / 8. => East,
-            h if h > -7. * PI / 8. && h <= -5. * PI / 8. => SouthEast,
+            h if h > 7. * PI / 8. || h <= -7. * PI / 8. => West,
+            h if h > -7. * PI / 8. && h <= -5. * PI / 8. => SouthWest,
             h if h > -5. * PI / 8. && h <= -3. * PI / 8. => South,
-            h if h > -3. * PI / 8. && h <= -PI / 8. => SouthWest,
+            h if h > -3. * PI / 8. && h <= -PI / 8. => SouthEast,
             _ => West,
         })
     }

From f903801ba8d746518b413ad60234377a61953232 Mon Sep 17 00:00:00 2001
From: Nolan Darilek <nolan@thewordnerd.info>
Date: Sun, 1 Dec 2024 16:02:14 -0600
Subject: [PATCH 4/7] Simplify exploration code.

---
 src/exploration.rs | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/src/exploration.rs b/src/exploration.rs
index 1c41297..93ce86e 100644
--- a/src/exploration.rs
+++ b/src/exploration.rs
@@ -1,4 +1,9 @@
-use std::{error::Error, fmt::Debug, hash::Hash, marker::PhantomData};
+use std::{
+    error::Error,
+    fmt::{Debug, Display},
+    hash::Hash,
+    marker::PhantomData,
+};
 
 use bevy::prelude::*;
 use bevy_rapier2d::prelude::*;
@@ -182,7 +187,7 @@ fn exploration_type_changed_announcement<ExplorationType>(
     >,
 ) -> Result<(), Box<dyn Error>>
 where
-    ExplorationType: Component + Default + Copy + Into<String>,
+    ExplorationType: Component + Default + Copy + Display,
 {
     for (focused, changed) in &focused {
         if changed.is_added() {
@@ -190,8 +195,7 @@ where
         }
         match &focused.0 {
             Some(v) => {
-                let v: String = (*v).into();
-                tts.speak(v, true)?;
+                tts.speak(format!("{v}"), true)?;
             }
             None => {
                 tts.speak("Everything", true)?;
@@ -284,7 +288,7 @@ fn exploration_changed_announcement<ExplorationType, MapData>(
     rapier_context: Res<RapierContext>,
 ) -> Result<(), Box<dyn Error>>
 where
-    ExplorationType: Component + Copy + Into<String>,
+    ExplorationType: Component + Copy + Display,
     MapData: 'static + Clone + Default + Send + Sync,
 {
     if let Ok((coordinates, exploring, viewshed)) = explorer.get_single() {
@@ -318,7 +322,7 @@ where
                         }
                         if tokens.is_empty() {
                             if let Ok(t) = types.get(entity) {
-                                tokens.push((*t).into());
+                                tokens.push(format!("{t}"));
                             }
                         }
                     }
@@ -385,7 +389,7 @@ pub struct Exploration;
 
 impl<ExplorationType, MapData> Plugin for ExplorationPlugin<ExplorationType, MapData>
 where
-    ExplorationType: 'static + Component + Default + Copy + Ord + PartialEq + Into<String>,
+    ExplorationType: 'static + Component + Default + Copy + Ord + PartialEq + Display,
     MapData: 'static + Clone + Default + Send + Sync,
 {
     fn build(&self, app: &mut App) {

From 1601354f409a85cb105d945c1a2feac62c1db5c6 Mon Sep 17 00:00:00 2001
From: Nolan Darilek <nolan@thewordnerd.info>
Date: Sun, 1 Dec 2024 16:04:12 -0600
Subject: [PATCH 5/7] Newer, faster visibility.

---
 src/visibility.rs | 276 ++++++++++++++++++++++++++--------------------
 1 file changed, 157 insertions(+), 119 deletions(-)

diff --git a/src/visibility.rs b/src/visibility.rs
index 46b75d8..122d4c2 100644
--- a/src/visibility.rs
+++ b/src/visibility.rs
@@ -1,12 +1,11 @@
 use std::{
-    cell::RefCell,
     collections::{HashMap, HashSet},
     marker::PhantomData,
 };
 
 use bevy::prelude::*;
 
-use bevy_rapier2d::{na::Isometry2, parry::bounding_volume::BoundingVolume};
+use bevy_rapier2d::na::Isometry2;
 use coord_2d::{Coord, Size};
 use shadowcast::{vision_distance, Context, InputGrid};
 
@@ -51,100 +50,17 @@ impl Viewshed {
         viewer_entity: &Entity,
         visible_entities: &mut VisibleEntities,
         start: &Vec2,
+        opacity_map: &OpacityMap,
+        sensors: &Query<&Sensor>,
         rapier_context: &RapierContext,
-        visible_query: &Query<(&Visible, &Collider, &GlobalTransform)>,
-        cache: &mut RefCell<HashMap<(i32, i32), (u8, HashSet<Entity>)>>,
     ) {
-        // println!("Start");
-        let mut boxes = vec![];
-        let shape = Collider::cuboid(self.range as f32, self.range as f32);
-        rapier_context.intersections_with_shape(*start, 0., &shape, default(), |entity| {
-            if let Ok((_, collider, transform)) = visible_query.get(entity) {
-                let position =
-                    Isometry2::translation(transform.translation().x, transform.translation().y);
-                // println!(
-                // "Hit {:?}, pushing {:?}",
-                // entity,
-                // collider.raw.compute_aabb(&position)
-                // );
-                boxes.push(collider.raw.compute_aabb(&position));
-            }
-            true
-        });
         let mut context: Context<u8> = Context::default();
         let vision_distance = vision_distance::Circle::new(self.range);
-        let shape = Collider::cuboid(0.49, 0.49);
         let size = (
             (start.x.abs() + self.range as f32 * 2.) as u32,
             (start.y.abs() + self.range as f32 * 2.) as u32,
         );
-        let visibility_grid = VisibilityGrid(
-            size,
-            RefCell::new(Box::new(|coord: Coord| {
-                let shape_pos = Vec2::new(coord.x as f32 + 0.5, coord.y as f32 + 0.5);
-                // println!("Checking {coord:?}: {shape_pos:?}");
-                if start.distance(&shape_pos) > self.range as f32 {
-                    // println!("Out of range");
-                    return u8::MAX;
-                }
-                let mut coord_entities = HashSet::new();
-                let mut to_insert = None;
-                let opacity = if let Some((opacity, entities)) =
-                    cache.borrow().get(&(coord.x, coord.y))
-                {
-                    // println!("Cache hit: {opacity:?}: {entities:?}");
-                    coord_entities = entities.clone();
-                    *opacity
-                } else {
-                    let position = Isometry2::translation(shape_pos.x, shape_pos.y);
-                    let aabb = shape.raw.compute_aabb(&position);
-                    if boxes.iter().any(|b| b.intersects(&aabb)) {
-                        // println!("Hit");
-                        let mut opacity = 0;
-                        rapier_context.intersections_with_shape(
-                            shape_pos,
-                            0.,
-                            &shape,
-                            default(),
-                            |entity| {
-                                if let Ok((visible, _, _)) = visible_query.get(entity) {
-                                    // println!(
-                                    // "{entity:?}: {visible:?}: {:?}",
-                                    // transform.translation().truncate()
-                                    // );
-                                    coord_entities.insert(entity);
-                                    opacity = opacity.max(**visible);
-                                }
-                                true
-                            },
-                        );
-                        to_insert = Some(((coord.x, coord.y), (opacity, coord_entities.clone())));
-                        // println!("New opacity: {opacity}");
-                        opacity
-                    } else {
-                        // println!("No hits, 0");
-                        to_insert = Some(((coord.x, coord.y), default()));
-                        0
-                    }
-                };
-                if let Some((k, v)) = to_insert {
-                    cache.borrow_mut().insert(k, v);
-                }
-                if coord_entities.contains(&viewer_entity) {
-                    let mut coord_entities = coord_entities.clone();
-                    coord_entities.retain(|e| e != viewer_entity);
-                    let opacity = coord_entities
-                        .iter()
-                        .map(|v| visible_query.get(*v).unwrap().0 .0)
-                        .max()
-                        .unwrap_or(0);
-                    // println!("Viewer hit, removing viewer opacity: {opacity}");
-                    opacity
-                } else {
-                    opacity
-                }
-            })),
-        );
+        let visibility_grid = VisibilityGrid(size, *viewer_entity, opacity_map.clone());
         let mut new_visible = HashSet::new();
         let mut new_visible_entities = HashSet::new();
         // println!("Start: {viewer_entity}");
@@ -156,9 +72,36 @@ impl Viewshed {
             u8::MAX,
             |coord, _directions, _visibility| {
                 new_visible.insert((coord.x, coord.y));
-                if let Some((_, entities)) = cache.borrow().get(&(coord.x, coord.y)) {
+                let coord = IVec2::new(coord.x, coord.y);
+                // println!("Checking {coord:?}");
+                if let Some((_, entities)) = opacity_map.get(&coord) {
                     for e in entities {
-                        new_visible_entities.insert(*e);
+                        if entities.len() == 1 || sensors.contains(*e) {
+                            new_visible_entities.insert(*e);
+                        } else {
+                            let mut should_push = true;
+                            let coord = Vec2::new(coord.x as f32 + 0.5, coord.y as f32 + 0.5);
+                            let dir = (coord - *start).normalize();
+                            // println!("Casting from {coord}");
+                            rapier_context.intersections_with_ray(
+                                *start,
+                                dir,
+                                dir.distance(*start),
+                                true,
+                                default(),
+                                |entity, _hit| {
+                                    if *e != entity && entities.contains(&e) {
+                                        // println!("{entities:?} contains {e} and hits at {:?}", hit.point);
+                                        // commands.entity(*e).log_components();
+                                        should_push = false;
+                                    }
+                                    true
+                                },
+                            );
+                            if should_push {
+                                new_visible_entities.insert(*e);
+                            }
+                        }
                     }
                 }
             },
@@ -171,8 +114,6 @@ impl Viewshed {
                 commands.trigger_targets(VisibilityChanged::Lost(*lost), *viewer_entity);
             }
             for gained in new_visible_entities.difference(visible_entities) {
-                // println!("transition: {:?} gains {:?}", viewer_entity,
-                // gained);
                 commands.trigger_targets(VisibilityChanged::Gained(*gained), *viewer_entity);
             }
             **visible_entities = new_visible_entities;
@@ -200,6 +141,80 @@ impl Visible {
     }
 }
 
+#[derive(Resource, Clone, Deref, DerefMut, Default)]
+pub struct OpacityMap(HashMap<IVec2, (u8, HashSet<Entity>)>);
+
+impl OpacityMap {
+    fn update(
+        &mut self,
+        rapier_context: &RapierContext,
+        coordinates: HashSet<IVec2>,
+        visible: &Query<(Entity, &GlobalTransform, &Collider, &Visible)>,
+    ) {
+        self.retain(|k, _| !coordinates.contains(k));
+        let shape = Collider::cuboid(0.49, 0.49);
+        for coords in &coordinates {
+            let shape_pos = Vec2::new(coords.x as f32 + 0.5, coords.y as f32 + 0.5);
+            let mut opacity = 0;
+            let mut coord_entities = HashSet::new();
+            rapier_context.intersections_with_shape(shape_pos, 0., &shape, default(), |entity| {
+                if let Ok((_, _, _, visible)) = visible.get(entity) {
+                    coord_entities.insert(entity);
+                    opacity = opacity.max(**visible);
+                }
+                true
+            });
+            self.insert(*coords, (opacity, coord_entities));
+        }
+    }
+}
+
+fn update_opacity_map(
+    mut opacity_map: ResMut<OpacityMap>,
+    rapier_context: Res<RapierContext>,
+    query: Query<
+        (Entity, &GlobalTransform, &Collider, &Visible),
+        Or<(Changed<GlobalTransform>, Changed<Visible>)>,
+    >,
+    visible: Query<(Entity, &GlobalTransform, &Collider, &Visible)>,
+) {
+    let mut to_update = HashSet::new();
+    for (entity, transform, collider, _) in &query {
+        // println!(
+        //     "Updating {entity} at {:?}",
+        //     transform.translation().truncate().as_ivec2()
+        // );
+        let mut prev = HashSet::new();
+        for (k, v) in opacity_map.iter() {
+            if v.1.contains(&entity) {
+                // println!("Also updating {k} because it contained entity");
+                prev.insert(*k);
+            }
+        }
+        let mut current = HashSet::new();
+        current.insert(transform.translation().truncate().as_ivec2());
+        let position = Isometry2::new(
+            transform.translation().truncate().into(),
+            transform.yaw().as_radians(),
+        );
+        let aabb = collider.raw.compute_aabb(&position);
+        for x in aabb.mins.x as i32..aabb.maxs.x as i32 {
+            for y in aabb.mins.y as i32..aabb.maxs.y as i32 {
+                // println!(
+                //     "Also updating coordinates at {:?}",
+                //     IVec2::new(x as i32, y as i32)
+                // );
+                current.insert(IVec2::new(x as i32, y as i32));
+            }
+        }
+        if prev != current {
+            to_update.extend(prev);
+            to_update.extend(current);
+        }
+    }
+    opacity_map.update(&rapier_context, to_update, &visible);
+}
+
 #[derive(Component, Clone, Debug, Default, Deref, DerefMut)]
 pub struct VisibleEntities(HashSet<Entity>);
 
@@ -261,12 +276,9 @@ fn viewshed_removed(
     }
 }
 
-pub struct VisibilityGrid<F>(pub (u32, u32), pub RefCell<Box<F>>);
+pub struct VisibilityGrid(pub (u32, u32), pub Entity, pub OpacityMap);
 
-impl<F> InputGrid for VisibilityGrid<F>
-where
-    F: FnMut(Coord) -> u8,
-{
+impl InputGrid for VisibilityGrid {
     type Grid = (u32, u32);
 
     type Opacity = u8;
@@ -276,35 +288,47 @@ where
     }
 
     fn get_opacity(&self, _grid: &Self::Grid, coord: Coord) -> Self::Opacity {
-        (self.1.borrow_mut())(coord)
+        // println!("Checking {coord:?}");
+        if let Some((opacity, entities)) = self.2.get(&IVec2::new(coord.x, coord.y)) {
+            if entities.len() == 1 && entities.contains(&self.1) {
+                // println!("Hit viewer, 0");
+                0
+            } else {
+                // println!("{opacity:?}");
+                *opacity
+            }
+        } else {
+            // println!("Miss, 0");
+            0
+        }
     }
 }
 
 fn update_viewshed(
     mut commands: Commands,
     config: Res<RapierConfiguration>,
-    visible: Query<(&Visible, &Collider, &GlobalTransform)>,
     mut viewers: Query<(
         Entity,
         &mut Viewshed,
         &mut VisibleEntities,
         &GlobalTransform,
     )>,
+    opacity_map: Res<OpacityMap>,
+    sensors: Query<&Sensor>,
     rapier_context: Res<RapierContext>,
 ) {
     if !config.query_pipeline_active {
         return;
     }
-    let mut cache = default();
     for (viewer_entity, mut viewshed, mut visible_entities, viewer_transform) in &mut viewers {
         viewshed.update(
             &mut commands,
             &viewer_entity,
             &mut visible_entities,
             &viewer_transform.translation().truncate(),
-            &rapier_context,
-            &visible,
-            &mut cache,
+            &opacity_map,
+            &sensors,
+            &*rapier_context,
         );
     }
 }
@@ -318,11 +342,21 @@ fn remove_visible(
         &mut VisibleEntities,
         &GlobalTransform,
     )>,
+    sensors: Query<&Sensor>,
     rapier_context: Res<RapierContext>,
-    visible: Query<(&Visible, &Collider, &GlobalTransform)>,
+    mut opacity_map: ResMut<OpacityMap>,
+    visible: Query<(Entity, &GlobalTransform, &Collider, &Visible)>,
 ) {
     if !removed.is_empty() {
-        let mut cache = default();
+        let mut to_update = HashSet::new();
+        for e in removed.read() {
+            for (k, v) in opacity_map.iter() {
+                if v.1.contains(&e) {
+                    to_update.insert(*k);
+                }
+            }
+        }
+        opacity_map.update(&rapier_context, to_update, &visible);
         for removed in removed.read() {
             for (viewer_entity, mut viewshed, mut visible_entities, start) in &mut viewers {
                 if !visible_entities.contains(&removed) {
@@ -333,9 +367,9 @@ fn remove_visible(
                     &viewer_entity,
                     &mut visible_entities,
                     &start.translation().truncate(),
-                    &rapier_context,
-                    &visible,
-                    &mut cache,
+                    &opacity_map,
+                    &sensors,
+                    &*rapier_context,
                 );
             }
         }
@@ -371,7 +405,6 @@ fn log_visible(
         }
         if let Ok((viewer_transform, viewer_collider)) = viewers.get(trigger.entity()) {
             if let Ok((name, viewed_transform, viewed_collider)) = visible.get(*entity) {
-                // println!("Gain {name}: {entity}");
                 let location = if let (Some(viewer_collider), Some(viewed_collider)) =
                     (viewer_collider, viewed_collider)
                 {
@@ -402,15 +435,20 @@ 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_systems(
-            FixedPreUpdate,
-            (
-                add_visibility_indices::<MapData>,
-                update_viewshed,
-                update_revealed_tiles::<MapData>,
-            ),
-        )
-        .add_systems(FixedPostUpdate, (viewshed_removed, remove_visible))
-        .observe(log_visible);
+        app.init_resource::<OpacityMap>()
+            .add_systems(
+                FixedPreUpdate,
+                update_opacity_map.before(update_viewshed),
+            )
+            .add_systems(
+                FixedPreUpdate,
+                (
+                    add_visibility_indices::<MapData>,
+                    update_viewshed,
+                    update_revealed_tiles::<MapData>,
+                ),
+            )
+            .add_systems(FixedPostUpdate, (viewshed_removed, remove_visible))
+            .observe(log_visible);
     }
 }

From 8c930c321d735ed5f4f5859a5a402e32b418f0af Mon Sep 17 00:00:00 2001
From: Nolan Darilek <nolan@thewordnerd.info>
Date: Sun, 1 Dec 2024 17:54:55 -0600
Subject: [PATCH 6/7] Remove unused features.

---
 Cargo.toml | 37 +++++++++++++++++++++++++++++++++++--
 1 file changed, 35 insertions(+), 2 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 3b0cbf3..980a1df 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,8 +13,41 @@ speech_dispatcher_0_9 = ["bevy_tts/speech_dispatcher_0_9"]
 speech_dispatcher_0_10 = ["bevy_tts/speech_dispatcher_0_10"]
 speech_dispatcher_0_11 = ["bevy_tts/speech_dispatcher_0_11"]
 
+[dependencies.bevy]
+version = "0.14"
+default-features = false
+features = [
+    "android_shared_stdcxx",
+    "animation",
+    "bevy_animation",
+    "bevy_asset",
+    "bevy_color",
+    "bevy_core_pipeline",
+    "bevy_gilrs",
+    "bevy_gizmos",
+    "bevy_gltf",
+    "bevy_pbr",
+    "bevy_render",
+    "bevy_scene",
+    "bevy_sprite",
+    "bevy_state",
+    "bevy_text",
+    "bevy_ui",
+    "bevy_winit",
+    "default_font",
+    "hdr",
+    "ktx2",
+    "multi_threaded",
+    "png",
+    "smaa_luts",
+    "sysinfo_plugin",
+    "tonemapping_luts",
+    "webgl2",
+    "x11",
+    "zstd",
+]
+
 [dependencies]
-bevy = "0.14"
 bevy_rapier2d = "0.27"
 bevy_synthizer = "0.7"
 bevy_tts = { version = "0.9", default-features = false, features = ["tolk"] }
@@ -26,4 +59,4 @@ once_cell = "1"
 pathfinding = "4"
 rand = "0.8"
 serde = "1"
-shadowcast = "0.8"
\ No newline at end of file
+shadowcast = "0.8"

From d268ed2b0cf82d771c00f524d5f852279e3b73ae Mon Sep 17 00:00:00 2001
From: Nolan Darilek <nolan@thewordnerd.info>
Date: Mon, 2 Dec 2024 13:30:37 -0600
Subject: [PATCH 7/7] Fix volumetric sound and adapt sound icon code to new
 bevy_synthizer.

---
 Cargo.toml              |  2 +-
 src/sound/icon.rs       | 67 +++++++++++++++++++++--------------------
 src/sound/volumetric.rs | 45 ++++++++++++++++++---------
 3 files changed, 65 insertions(+), 49 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 980a1df..ce3a570 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -49,7 +49,7 @@ features = [
 
 [dependencies]
 bevy_rapier2d = "0.27"
-bevy_synthizer = "0.7"
+bevy_synthizer = "0.8"
 bevy_tts = { version = "0.9", default-features = false, features = ["tolk"] }
 coord_2d = "0.3"
 here_be_dragons = { version = "0.3", features = ["serde"] }
diff --git a/src/sound/icon.rs b/src/sound/icon.rs
index 9c83e42..4c42e4b 100644
--- a/src/sound/icon.rs
+++ b/src/sound/icon.rs
@@ -75,42 +75,43 @@ fn update<S>(
             } else {
                 None
             };
-            if let Some(entity) = entity {
-                if visible.contains(&entity) {
-                    if let Some(interval) = icon.interval.as_mut() {
-                        if interval.finished() {
-                            interval.reset();
-                            continue;
-                        } else if interval.fraction() == 0. {
-                            sound.generator = None;
-                        }
-                        interval.tick(time.delta());
-                    }
-                    if sound.audio != icon.audio {
-                        sound.audio = icon.audio.clone();
-                    }
-                    if sound.gain != icon.gain {
-                        sound.gain = icon.gain;
-                    }
-                    if sound.pitch != icon.pitch {
-                        sound.pitch = icon.pitch;
-                    }
-                    let looping = icon.interval.is_none();
-                    if sound.looping != looping {
-                        sound.looping = looping;
-                    }
-                    if sound.paused {
-                        sound.paused = false;
+            let Some(entity) = entity else {
+                continue;
+            };
+            if visible.contains(&entity) {
+                if let Some(interval) = icon.interval.as_mut() {
+                    if interval.finished() {
+                        interval.reset();
+                        continue;
+                    } else if interval.fraction() == 0. {
+                        sound.playback_position = 0.;
                         sound.generator = None;
                     }
-                } else if !sound.paused {
-                    sound.paused = true;
-                    if let Some(interval) = icon.interval.as_mut() {
-                        interval.reset();
-                    }
+                    interval.tick(time.delta());
+                }
+                if sound.audio != icon.audio {
+                    sound.audio = icon.audio.clone();
+                }
+                if sound.gain != icon.gain {
+                    sound.gain = icon.gain;
+                }
+                if sound.pitch != icon.pitch {
+                    sound.pitch = icon.pitch;
+                }
+                let looping = icon.interval.is_none();
+                if sound.looping != looping {
+                    sound.looping = looping;
+                }
+                if sound.paused {
+                    sound.paused = false;
+                    sound.playback_position = 0.;
+                    sound.generator = None;
+                }
+            } else if !sound.paused {
+                sound.paused = true;
+                if let Some(interval) = icon.interval.as_mut() {
+                    interval.reset();
                 }
-            } else {
-                panic!("Should not happen");
             }
         }
     }
diff --git a/src/sound/volumetric.rs b/src/sound/volumetric.rs
index f8c574f..7d51627 100644
--- a/src/sound/volumetric.rs
+++ b/src/sound/volumetric.rs
@@ -9,31 +9,46 @@ use crate::core::GlobalTransformExt;
 pub struct Volumetric;
 
 fn update(
+    mut commands: Commands,
     listener: Query<(&Collider, &GlobalTransform), With<Listener>>,
-    mut sounds: Query<(&Sound, &Parent, &mut Transform), With<Volumetric>>,
+    mut sounds: Query<(Entity, &Sound, &Parent, Option<&mut Transform>), With<Volumetric>>,
     colliders: Query<(&Collider, &GlobalTransform)>,
 ) {
     if let Ok((listener_collider, listener_global_transform)) = listener.get_single() {
-        for (sound, parent, mut sound_transform) in &mut sounds {
+        for (sound_entity, sound, parent, sound_transform) in &mut sounds {
             if sound.paused {
                 continue;
             }
-            if let Ok((sound_collider, sound_global_transform)) = colliders.get(**parent) {
-                let closest = listener_global_transform.closest_points(
-                    listener_collider,
-                    sound_global_transform,
-                    sound_collider,
-                );
-                if let ClosestPoints::WithinMargin(_p1, p2) = closest {
-                    let p2 = Vec3::new(p2.x, p2.y, 0.);
+            let Ok((sound_collider, sound_global_transform)) = colliders.get(**parent) else {
+                continue;
+            };
+            let closest = listener_global_transform.closest_points(
+                listener_collider,
+                sound_global_transform,
+                sound_collider,
+            );
+            if let ClosestPoints::WithinMargin(_p1, p2) = closest {
+                if let Some(mut sound_transform) = sound_transform {
                     sound_transform.translation.x = p2.x - sound_global_transform.translation().x;
                     sound_transform.translation.y = p2.y - sound_global_transform.translation().y;
-                } else if closest == ClosestPoints::Intersecting {
-                    sound_transform.translation.x = listener_global_transform.translation().x
-                        - sound_global_transform.translation().x;
-                    sound_transform.translation.y = listener_global_transform.translation().y
-                        - sound_global_transform.translation().y;
+                } else {
+                    let sound_translation = Vec3::new(
+                        p2.x - sound_global_transform.translation().x,
+                        p2.y - sound_global_transform.translation().y,
+                        0.,
+                    );
+                    commands
+                        .entity(sound_entity)
+                        .insert(TransformBundle::from_transform(
+                            Transform::from_translation(sound_translation),
+                        ));
                 }
+            } else if closest == ClosestPoints::Intersecting && sound_transform.is_some() {
+                println!("Clearing volumetric");
+                commands
+                    .entity(sound_entity)
+                    .remove::<Transform>()
+                    .remove::<GlobalTransform>();
             }
         }
     }