From 2917a7baa7f7febe23777d0f734de6f3a48ea6d9 Mon Sep 17 00:00:00 2001
From: Benjamyn Love <benjamyn.love@gmail.com>
Date: Mon, 31 Oct 2022 09:16:55 +1100
Subject: [PATCH] Improved visibility

---
 src/map.rs               | 69 +++++++++++++++++++---------------------
 src/visibility_system.rs | 22 ++++++++++---
 2 files changed, 50 insertions(+), 41 deletions(-)

diff --git a/src/map.rs b/src/map.rs
index 103fccf..e1ab578 100644
--- a/src/map.rs
+++ b/src/map.rs
@@ -1,6 +1,4 @@
-use crate::Viewshed;
-
-use super::{Rect, Player};
+use super::{Rect};
 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,44 +142,41 @@ 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() {
-            let pt = Point::new(x,y);
-            if viewshed.visible_tiles.contains(&pt) {
-                match tile {
-                    TileType::Floor => {
-                        ctx.set(
-                            x,
-                            y,
-                            RGB::from_f32(0.5, 0.5, 0.5),
-                            RGB::from_f32(0., 0., 0.),
-                            rltk::to_cp437('.'),
-                        );
-                    }
-                    TileType::Wall => {
-                        ctx.set(
-                            x,
-                            y,
-                            RGB::from_f32(0.0, 1.0, 0.0),
-                            RGB::from_f32(0., 0., 0.),
-                            rltk::to_cp437('#'),
-                        );
-                    }
+    let mut y = 0;
+    let mut x = 0;
+    for (idx, tile) in map.tiles.iter().enumerate() {
+        if map.revealed_tiles[idx] {
+            match tile {
+                TileType::Floor => {
+                    ctx.set(
+                        x,
+                        y,
+                        RGB::from_f32(0.5, 0.5, 0.5),
+                        RGB::from_f32(0., 0., 0.),
+                        rltk::to_cp437('.'),
+                    );
+                }
+                TileType::Wall => {
+                    ctx.set(
+                        x,
+                        y,
+                        RGB::from_f32(0.0, 1.0, 0.0),
+                        RGB::from_f32(0., 0., 0.),
+                        rltk::to_cp437('#'),
+                    );
                 }
             }
-            x += 1;
+    
+            
+            
+        }
+        x += 1;
             if x > 79 {
                 x = 0;
                 y += 1;
             }
-        }
     }
-
-
+    
 }
diff --git a/src/visibility_system.rs b/src/visibility_system.rs
index 52869bf..7a8e408 100644
--- a/src/visibility_system.rs
+++ b/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;
-        for (viewshed, pos) in (&mut viewshed, &pos).join() {
+        let (mut map, entities, mut viewshed, pos, player) = data;
+
+        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;
+                }
+            }
         }
     }
 }
\ No newline at end of file