Improved visibility

src/map.rs

@@ -1,6 +1,4 @@
-use crate::Viewshed;
+use super::{Rect};
-
-use super::{Rect, Player};
 use rltk::{RandomNumberGenerator, Rltk, RGB, Algorithm2D, Point, BaseMap};
 use std::{cmp::{max, min}};
 use specs::prelude::*;
@@ -15,7 +13,8 @@ pub struct Map {
     pub tiles : Vec::<TileType>,
     pub rooms : Vec::<Rect>,
     pub width : i32,
-    pub height : i32
+    pub height : i32,
+    pub revealed_tiles : Vec<bool>
 }
 
 impl Map {
@@ -55,7 +54,8 @@ impl Map {
             tiles : vec![TileType::Wall; 80*50],
             rooms : Vec::new(),
             width : 80,
-            height : 50
+            height : 50,
+            revealed_tiles : vec![false; 80*50]
         };
     
         const MAX_ROOMS: i32 = 30;
@@ -142,16 +142,12 @@ impl BaseMap for Map {
 
 
 pub fn draw_map(ecs: &World, ctx: &mut Rltk) {
-    let mut viewsheds = ecs.write_storage::<Viewshed>();
-    let mut players = ecs.write_storage::<Player>();
     let map = ecs.fetch::<Map>();
 
-    for (_player, viewshed) in (&mut players, &mut viewsheds).join() {
     let mut y = 0;
     let mut x = 0;
-        for tile in map.tiles.iter() {
+    for (idx, tile) in map.tiles.iter().enumerate() {
-            let pt = Point::new(x,y);
+        if map.revealed_tiles[idx] {
-            if viewshed.visible_tiles.contains(&pt) {
             match tile {
                 TileType::Floor => {
                     ctx.set(
@@ -172,6 +168,9 @@ pub fn draw_map(ecs: &World, ctx: &mut Rltk) {
                     );
                 }
             }
+    
+            
+            
         }
         x += 1;
             if x > 79 {
@@ -179,7 +178,5 @@ pub fn draw_map(ecs: &World, ctx: &mut Rltk) {
                 y += 1;
             }
     }
-    }
-
     
 }

src/visibility_system.rs

@@ -1,20 +1,32 @@
 use specs::prelude::*;
-use super::{Viewshed, Position, Map};
+
+use super::{Viewshed, Position, Map, Player};
 use rltk::{field_of_view, Point};
 
 pub struct VisibilitySystem {}
 
 impl<'a> System<'a> for VisibilitySystem {
-    type SystemData = ( ReadExpect<'a, Map>,
+    type SystemData = ( WriteExpect<'a, Map>,
+                        Entities<'a>,
                         WriteStorage<'a, Viewshed>,
-                        WriteStorage<'a, Position>);
+                        WriteStorage<'a, Position>,
+                        ReadStorage<'a, Player>);
     
     fn run(&mut self, data : Self::SystemData) {
-        let (map, mut viewshed, pos) = data;
+        let (mut map, entities, mut viewshed, pos, player) = data;
-        for (viewshed, pos) in (&mut viewshed, &pos).join() {
+
+        for (ent, viewshed, pos) in (&entities, &mut viewshed, &pos).join() {
             viewshed.visible_tiles.clear();
             viewshed.visible_tiles = field_of_view(Point::new(pos.x, pos.y), viewshed.range, &*map);
             viewshed.visible_tiles.retain(|p| p.x >= 0 && p.x < map.width && p.y >= 0 && p.y < map.height);
+
+            let _p : Option<&Player> = player.get(ent);
+            if let Some(_p) = _p {
+                for vis in viewshed.visible_tiles.iter() {
+                    let idx = map.xy_idx(vis.x, vis.y);
+                    map.revealed_tiles[idx] = true;
+                }
+            }
         }
     }
 }