README.md

@@ -10,18 +10,19 @@ _Blackout_ uses a few other libraries for its magic:
 
 * [bevy_openal](https://github.com/lightsoutgames/bevy_openal): Audio
 * [bevy_input_actionmap](https://github.com/lightsoutgames/bevy_input_actionmap): Mapping inputs to actions
-* [here_be_dragons](https://docs.rs/here_be_dragons): Map generation
-* [shadowcast](https://docs.rs/shadowcast): Visibility calculations
+* [mapgen](https://docs.rs/mapgen/latest/mapgen/): Map generation
 
 It provides, including but not limited to:
 
 * commands
   * `RunIfExists` extension for only running a given command if its entity exists
 * core
+  * `Coordinates` component for managing 2-D positions
   * `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
   * `Direction` type for working with cardinal/movement directions, converting to/from angles, etc.
   * Configuration for syncing pixel-to-meter ratios between OpenAL and Rapier
+  * Systems that try keeping the mess of Bevy/Blackout/Rapier position types synced
   * `Player` component for use in other modules/plugins
 * log
   * Simple log component, automatically read via text-to-speech when appended to

src/core.rs

@@ -222,19 +222,19 @@ pub trait PointLike {
     fn y(&self) -> f32;
 
     fn x_i32(&self) -> i32 {
-        self.x().trunc() as i32
+        self.x() as i32
     }
 
     fn y_i32(&self) -> i32 {
-        self.y().trunc() as i32
+        self.y() as i32
     }
 
     fn x_usize(&self) -> usize {
-        self.x().trunc() as usize
+        self.x() as usize
     }
 
     fn y_usize(&self) -> usize {
-        self.y().trunc() as usize
+        self.y() as usize
     }
 
     fn f32(&self) -> (f32, f32) {
@@ -248,7 +248,6 @@ pub trait PointLike {
     fn floor(&self) -> (f32, f32) {
         (self.x().floor(), self.y().floor())
     }
-
     fn to_index(&self, width: usize) -> usize {
         ((self.y_i32() * width as i32) + self.x_i32()) as usize
     }

src/exploration.rs

@@ -337,7 +337,7 @@ fn exploration_changed_announcement<D: 'static + Clone + Default + Send + Sync>(
         for (map, revealed_tiles) in map.iter() {
             let point = **exploring;
             let idx = point.to_index(map.width);
-            let shape = Collider::cuboid(0.5 - f32::EPSILON, 0.5 - f32::EPSILON);
+            let shape = Collider::cuboid(0.49, 0.49);
             let known = revealed_tiles[idx];
             let visible = viewshed.is_point_visible(exploring);
             let fog_of_war = known && !visible;

src/sound.rs

@@ -250,7 +250,7 @@ fn sound_icon_exploration_focus_removed(
         if let Ok(children) = children.get(entity) {
             for child in children.iter() {
                 if let Ok(mut icon) = query.get_mut(*child) {
-                    icon.gain /= ICON_GAIN;
+                    icon.gain *= ICON_GAIN;
                 }
             }
         }

src/visibility.rs

@@ -4,7 +4,10 @@ use std::{
     marker::PhantomData,
 };
 
-use bevy::{core::FixedTimestep, prelude::*};
+use bevy::{
+    core::{FixedTimestep, FloatOrd},
+    prelude::*,
+};
 use bevy_rapier2d::na::{self, Point2};
 use coord_2d::{Coord, Size};
 use shadowcast::{vision_distance, Context, InputGrid};
@@ -58,21 +61,23 @@ impl Viewshed {
         map: &Map<D>,
         visible_query: &Query<&Visible>,
         events: &mut EventWriter<VisibilityChanged>,
-        cache: &mut HashMap<Coord, (u8, HashSet<Entity>)>,
+        cache: &mut HashMap<(FloatOrd, FloatOrd), (u8, HashSet<Entity>)>,
     ) {
         let mut context: Context<u8> = Context::default();
         let vision_distance = vision_distance::Circle::new(self.range);
-        let shape = Collider::cuboid(0.5 - f32::EPSILON, 0.5 - f32::EPSILON);
-        let origin = Point2::new(start.x().trunc(), start.y().trunc());
+        let shape = Collider::cuboid(0.5, 0.5);
+        let origin = Point2::new(start.x(), start.y());
+        let coord = Coord::new(start.x_i32(), start.y_i32());
         let mut new_visible_entities = HashSet::new();
         let visibility_grid = VisibilityGrid(
             map,
             RefCell::new(Box::new(|coord: Coord| {
-                let dest = Point2::new(coord.x as f32, coord.y as f32);
-                if na::distance(&origin, &dest) >= self.range as f32 {
+                let dest = Point2::new(coord.x as f32 + 0.5, coord.y as f32 + 0.5);
+                if na::distance(&origin, &dest) > self.range as f32 {
                     return u8::MAX;
                 }
-                if let Some((opacity, entities)) = cache.get(&coord) {
+                if let Some((opacity, entities)) = cache.get(&(FloatOrd(dest.x), FloatOrd(dest.y)))
+                {
                     for e in entities {
                         new_visible_entities.insert(*e);
                     }
@@ -84,12 +89,15 @@ impl Viewshed {
                 }
                 let tile = map.at(coord.x as usize, coord.y as usize);
                 if tile.blocks_visibility() {
-                    cache.insert(coord, (u8::MAX, HashSet::new()));
+                    cache.insert(
+                        (FloatOrd(dest.x), FloatOrd(dest.y)),
+                        (u8::MAX, HashSet::new()),
+                    );
                     return u8::MAX;
                 }
                 let mut opacity = 0;
                 let mut entities = HashSet::new();
-                let shape_pos = Vec2::new(dest.x + 0.5, dest.y + 0.5);
+                let shape_pos = Vec2::new(dest.x, dest.y);
                 rapier_context.intersections_with_shape(
                     shape_pos,
                     0.,
@@ -110,14 +118,14 @@ impl Viewshed {
                 if entities.contains(&viewer_entity) {
                     0
                 } else {
-                    cache.insert(coord, (opacity, entities));
+                    cache.insert((FloatOrd(dest.x), FloatOrd(dest.y)), (opacity, entities));
                     opacity
                 }
             })),
         );
         let mut new_visible = HashSet::new();
         context.for_each_visible(
-            Coord::new(start.x_i32(), start.y_i32()),
+            coord,
             &visibility_grid,
             &visibility_grid,
             vision_distance,
@@ -362,10 +370,10 @@ fn remove_visible<D: 'static + Clone + Default + Send + Sync>(
 
 fn update_revealed_tiles<D: 'static + Clone + Default + Send + Sync>(
     mut map: Query<(&Map<D>, &mut RevealedTiles)>,
-    viewers: Query<&Viewshed, (With<Player>, Changed<Viewshed>)>,
+    viewers: Query<&Viewshed, With<Player>>,
 ) {
-    for viewshed in viewers.iter() {
     for (map, mut revealed_tiles) in map.iter_mut() {
+        for viewshed in viewers.iter() {
             for v in viewshed.visible_points.iter() {
                 let idx = v.to_index(map.width);
                 if idx >= revealed_tiles.len() {