#59 #115 #57 Chapter 71 spatial fixes.

Author: thebracket

chapter-72-textlayers/src/ai/adjacent_ai_system.rs

@@ -71,12 +71,12 @@ impl<'a> System<'a> for AdjacentAI {
 }
 
 fn evaluate(idx : usize, map : &Map, factions : &ReadStorage<Faction>, my_faction : &str, reactions : &mut Vec<(Entity, Reaction)>) {
-    for other_entity in map.tile_content[idx].iter() {
-        if let Some(faction) = factions.get(*other_entity) {
+    crate::spatial::for_each_tile_content(idx, |other_entity| {
+        if let Some(faction) = factions.get(other_entity) {
             reactions.push((
-                *other_entity,
+                other_entity,
                 crate::raws::faction_reaction(my_faction, &faction.name, &crate::raws::RAWS.lock().unwrap())
             ));
         }
-    }
+    });
 }

chapter-72-textlayers/src/ai/default_move_system.rs

@@ -42,8 +42,8 @@ impl<'a> System<'a> for DefaultMoveAI {
 
                     if x > 0 && x < map.width-1 && y > 0 && y < map.height-1 {
                         let dest_idx = map.xy_idx(x, y);
-                        if !map.blocked[dest_idx] {
-                            apply_move.insert(entity, ApplyMove{ dest_idx : dest_idx })
+                        if !crate::spatial::is_blocked(dest_idx) {
+                            apply_move.insert(entity, ApplyMove{ dest_idx })
                                 .expect("Unable to insert");
                             turn_done.push(entity);
                         }
@@ -54,7 +54,7 @@ impl<'a> System<'a> for DefaultMoveAI {
                     if let Some(path) = path {
                         // We have a target - go there
                         if path.len()>1 {
-                            if !map.blocked[path[1] as usize] {
+                            if !crate::spatial::is_blocked(path[1] as usize) {
                                 apply_move.insert(entity, ApplyMove{ dest_idx : path[1] })
                                     .expect("Unable to insert");
                                 path.remove(0); // Remove the first step in the path

chapter-72-textlayers/src/ai/flee_ai_system.rs

@@ -28,7 +28,7 @@ impl<'a> System<'a> for FleeAI {
                 let flee_map = rltk::DijkstraMap::new(map.width as usize, map.height as usize, &flee.indices, &*map, 100.0);
                 let flee_target = rltk::DijkstraMap::find_highest_exit(&flee_map, my_idx, &*map);
                 if let Some(flee_target) = flee_target {
-                    if !map.blocked[flee_target as usize] {
+                    if !crate::spatial::is_blocked(flee_target as usize) {
                         apply_move.insert(entity, ApplyMove{ dest_idx : flee_target }).expect("Unable to insert");
                         turn_done.push(entity);
                     }

chapter-72-textlayers/src/ai/visible_ai_system.rs

@@ -107,13 +107,13 @@ impl<'a> System<'a> for VisibleAI {
 }
 
 fn evaluate(idx : usize, map : &Map, factions : &ReadStorage<Faction>, my_faction : &str, reactions : &mut Vec<(usize, Reaction, Entity)>) {
-    for other_entity in map.tile_content[idx].iter() {
-        if let Some(faction) = factions.get(*other_entity) {
+    crate::spatial::for_each_tile_content(idx, |other_entity| {
+        if let Some(faction) = factions.get(other_entity) {
             reactions.push((
                 idx,
                 crate::raws::faction_reaction(my_faction, &faction.name, &crate::raws::RAWS.lock().unwrap()),
-                *other_entity
+                other_entity
             ));
         }
-    }
+    });
 }

chapter-72-textlayers/src/effects/damage.rs

@@ -58,9 +58,7 @@ pub fn death(ecs: &mut World, effect: &EffectSpawner, target : Entity) {
     let mut attributes = ecs.write_storage::<Attributes>();
 
     if let Some(pos) = entity_position(ecs, target) {
-        let mut map_mut = ecs.fetch_mut::<Map>();
-        map_mut.blocked[pos as usize] = false;
-        std::mem::drop(map_mut);
+        crate::spatial::remove_entity(target, pos as usize);
     }
 
     if let Some(source) = effect.creator {

chapter-72-textlayers/src/effects/mod.rs

@@ -109,7 +109,7 @@ fn tile_effect_hits_entities(effect: &EffectType) -> bool {
 
 fn affect_tile(ecs: &mut World, effect: &mut EffectSpawner, tile_idx : i32) {
     if tile_effect_hits_entities(&effect.effect_type) {
-        let content = ecs.fetch::<Map>().tile_content[tile_idx as usize].clone();
+        let content = crate::spatial::get_tile_content_clone(tile_idx as usize);
         content.iter().for_each(|entity| affect_entity(ecs, effect, *entity));
     }
 

chapter-72-textlayers/src/gui/tooltips.rs

@@ -66,12 +66,13 @@ pub fn draw_tooltips(ecs: &World, ctx : &mut Rltk) {
     if !map.visible_tiles[mouse_idx] { return; }
 
     let mut tip_boxes : Vec<Tooltip> = Vec::new();
-    for entity in map.tile_content[mouse_idx].iter().filter(|e| hidden.get(**e).is_none()) {
+    crate::spatial::for_each_tile_content(mouse_idx, |entity| {
+        if hidden.get(entity).is_some() { return; }
         let mut tip = Tooltip::new();
-        tip.add(get_item_display_name(ecs, *entity));
+        tip.add(get_item_display_name(ecs, entity));
 
         // Comment on attributes
-        let attr = attributes.get(*entity);
+        let attr = attributes.get(entity);
         if let Some(attr) = attr {
             let mut s = "".to_string();
             if attr.might.bonus < 0 { s += "Weak. " };
@@ -89,7 +90,7 @@ pub fn draw_tooltips(ecs: &World, ctx : &mut Rltk) {
         }
 
         // Comment on pools
-        let stat = pools.get(*entity);
+        let stat = pools.get(entity);
         if let Some(stat) = stat {
             tip.add(format!("Level: {}", stat.level));
         }
@@ -99,13 +100,13 @@ pub fn draw_tooltips(ecs: &World, ctx : &mut Rltk) {
         let durations = ecs.read_storage::<Duration>();
         let names = ecs.read_storage::<Name>();
         for (status, duration, name) in (&statuses, &durations, &names).join() {
-            if status.target == *entity {
+            if status.target == entity {
                 tip.add(format!("{} ({})", name.name, duration.turns));
             }
         }
 
         tip_boxes.push(tip);
-    }
+    });
 
     if tip_boxes.is_empty() { return; }
 

chapter-72-textlayers/src/main.rs

@@ -41,6 +41,7 @@ mod movement_system;
 pub mod effects;
 #[macro_use]
 extern crate lazy_static;
+pub mod spatial;
 
 const SHOW_MAPGEN_VISUALIZER : bool = false;
 

chapter-72-textlayers/src/map/dungeon.rs

@@ -45,7 +45,6 @@ impl MasterDungeonMap {
     pub fn get_map(&self, depth : i32) -> Option<Map> {
         if self.maps.contains_key(&depth) {
             let mut result = self.maps[&depth].clone();
-            result.tile_content = vec![Vec::new(); (result.width * result.height) as usize];
             Some(result)
         } else {
             None

chapter-72-textlayers/src/map/mod.rs

@@ -17,17 +17,12 @@ pub struct Map {
     pub height : i32,
     pub revealed_tiles : Vec<bool>,
     pub visible_tiles : Vec<bool>,
-    pub blocked : Vec<bool>,
     pub depth : i32,
     pub bloodstains : HashSet<usize>,
     pub view_blocked : HashSet<usize>,
     pub name : String,
     pub outdoors : bool,
     pub light : Vec<rltk::RGB>,
-
-    #[serde(skip_serializing)]
-    #[serde(skip_deserializing)]
-    pub tile_content : Vec<Vec<Entity>>
 }
 
 impl Map {
@@ -38,32 +33,30 @@ impl Map {
     fn is_exit_valid(&self, x:i32, y:i32) -> bool {
         if x < 1 || x > self.width-1 || y < 1 || y > self.height-1 { return false; }
         let idx = self.xy_idx(x, y);
-        !self.blocked[idx]
+        !crate::spatial::is_blocked(idx)
     }
 
     pub fn populate_blocked(&mut self) {
-        for (i,tile) in self.tiles.iter_mut().enumerate() {
-            self.blocked[i] = !tile_walkable(*tile);
-        }
+        crate::spatial::populate_blocked_from_map(self);
     }
 
     pub fn populate_blocked_multi(&mut self, width : i32, height : i32) {
         self.populate_blocked();
         for y in 1 .. self.height-1 {
             for x in 1 .. self.width - 1 {
                 let idx = self.xy_idx(x, y);
-                if !self.blocked[idx] {
+                if !crate::spatial::is_blocked(idx) {
                     for cy in 0..height {
                         for cx in 0..width {
                             let tx = x + cx;
                             let ty = y + cy;
                             if tx < self.width-1 && ty < self.height-1 {
                                 let tidx = self.xy_idx(tx, ty);
-                                if self.blocked[tidx] {
-                                    self.blocked[idx] = true;
+                                if crate::spatial::is_blocked(tidx) {
+                                    crate::spatial::set_blocked(idx, true);
                                 }
                             } else {
-                                self.blocked[idx] = true;
+                                crate::spatial::set_blocked(idx, true);
                             }
                         }
                     }
@@ -73,22 +66,19 @@ impl Map {
     }
 
     pub fn clear_content_index(&mut self) {
-        for content in self.tile_content.iter_mut() {
-            content.clear();
-        }
+        crate::spatial::clear();
     }
 
     /// Generates an empty map, consisting entirely of solid walls
     pub fn new<S : ToString>(new_depth : i32, width: i32, height: i32, name: S) -> Map {
         let map_tile_count = (width*height) as usize;
+        crate::spatial::set_size(map_tile_count);
         Map{
             tiles : vec![TileType::Wall; map_tile_count],
             width,
             height,
             revealed_tiles : vec![false; map_tile_count],
             visible_tiles : vec![false; map_tile_count],
-            blocked : vec![false; map_tile_count],
-            tile_content : vec![Vec::new(); map_tile_count],
             depth: new_depth,
             bloodstains: HashSet::new(),
             view_blocked : HashSet::new(),