Fog of vision implementation

src/components.rs

@@ -64,3 +64,10 @@ pub enum Team {
     /// The opponent's team.
     Other,
 }
+
+/// Allows a unit to see others.
+#[derive(new)]
+pub struct LineOfSight {
+    /// The limit of the unit vision.
+    pub range: i32,
+}

src/main.rs

@@ -212,6 +212,7 @@ fn main() -> BError {
     let mut dispatcher = DispatcherBuilder::new();
     dispatcher!(
         dispatcher,
+        fog_of_vision_system,
         combine_collision_system,
         input_driver::<InputEvent>,
         update_collision_resource_system,
@@ -293,6 +294,8 @@ fn main() -> BError {
 
     world.initialize::<Components<Barrack>>();
     world.initialize::<Components<Core>>();
+    world.initialize::<Components<LineOfSight>>();
+    world.initialize::<Viewshed>();
     world.initialize::<TeamLeaders>();
 
     *world.get_mut::<Option<CollisionResource>>().unwrap() = Some(CollisionResource::new(
@@ -423,13 +426,15 @@ fn main() -> BError {
             Team::Me,
             Barrack,
             default_stats.clone(),
+            LineOfSight::new(15),
         );
         // Creep spawners
         centity!(
             world,
             Point::new(x, y - 1),
             CreepSpawner(0, CREEP_SPAWN_TICKS),
             Team::Me,
+            LineOfSight::new(15),
         );
     }
 
@@ -470,6 +475,7 @@ fn main() -> BError {
                 SpriteIndex(80),
                 Team::Me,
                 default_stats.clone(),
+                LineOfSight::new(6),
             );
         }
     }

src/states/default.rs

@@ -40,6 +40,7 @@ impl minigene::State for DefaultState {
                     &*world.get().unwrap(),
                     &*world.get().unwrap(),
                     &*world.get().unwrap(),
+                    Some(&*world.get().unwrap()),
                 );
             }
             ctx.set_active_console(0);

src/systems/fog_of_vision.rs

@@ -0,0 +1,23 @@
+use crate::*;
+
+/// Sets which tiles are visible.
+pub fn fog_of_vision_system(
+    collision_res: &Option<CollisionResource>,
+    sights: &Components<LineOfSight>,
+    viewshed: &mut Viewshed,
+    positions: &mut Components<Point>,
+) -> SystemResult {
+    viewshed.visible_tiles.clear();
+    for (sight, pos) in join!(&sights && &positions).map(|(s, p)| (s.unwrap(), p.unwrap())) {
+        if let Some(col_res) = collision_res {
+            let map = &col_res.map;
+            viewshed
+                .visible_tiles
+                .extend(field_of_view(*pos, sight.range, map));
+            viewshed.visible_tiles.retain(|p| {
+                p.x >= 0 && p.x < (map.size().0 as i32) && p.y >= 0 && p.y < (map.size().1 as i32)
+            });
+        }
+    }
+    Ok(())
+}

src/systems/mod.rs

@@ -8,6 +8,7 @@ mod bear_spawner;
 mod creep_spawner;
 mod damage_entity;
 mod dark_presence;
+mod fog_of_vision;
 mod game_stats_updater;
 mod handle_action_points;
 mod kill_entity;
@@ -47,6 +48,7 @@ pub use self::bear_spawner::*;
 pub use self::creep_spawner::*;
 pub use self::damage_entity::*;
 pub use self::dark_presence::*;
+pub use self::fog_of_vision::*;
 pub use self::game_stats_updater::*;
 pub use self::handle_action_points::*;
 pub use self::kill_entity::*;

src/systems/spawn_creep.rs

@@ -13,6 +13,7 @@ pub fn spawn_creep_system(
     teams: &mut Components<Team>,
     sprites: &mut Components<Sprite>,
     sprite_indices: &mut Components<SpriteIndex>,
+    sights: &mut Components<LineOfSight>,
 ) -> SystemResult {
     for ev in game_events.iter() {
         if let GameEvent::SpawnCreep(pos, team) = ev {
@@ -24,6 +25,7 @@ pub fn spawn_creep_system(
             stats.insert(creep, stat_def.to_statset());
             proximity_attacks.insert(creep, ProximityAttack::new(CREEP_ATTACK_RADIUS));
             let bg = if *team == Team::Me {
+                sights.insert(creep, LineOfSight::new(5));
                 RGBA::named(GREEN)
             } else {
                 RGBA::named(RED)