#59 #115 #57 Chapter 64 fixes.

Author: thebracket

chapter-64-curses/src/ai/adjacent_ai_system.rs

@@ -55,12 +55,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-64-curses/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-64-curses/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-64-curses/src/ai/visible_ai_system.rs

@@ -59,13 +59,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-64-curses/src/effects/damage.rs

@@ -12,13 +12,13 @@ pub fn inflict_damage(ecs: &mut World, damage: &EffectSpawner, target: Entity) {
             if let EffectType::Damage{amount} = damage.effect_type {
                 pool.hit_points.current -= amount;
                 add_effect(None, EffectType::Bloodstain, Targets::Single{target});
-                add_effect(None, 
-                    EffectType::Particle{ 
+                add_effect(None,
+                    EffectType::Particle{
                         glyph: rltk::to_cp437('‼'),
                         fg : rltk::RGB::named(rltk::ORANGE),
                         bg : rltk::RGB::named(rltk::BLACK),
                         lifespan: 200.0
-                    }, 
+                    },
                     Targets::Single{target}
                 );
 
@@ -43,9 +43,7 @@ pub fn death(ecs: &mut World, effect: &EffectSpawner, target : Entity) {
     let attributes = ecs.read_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-64-curses/src/effects/mod.rs

@@ -93,10 +93,10 @@ fn tile_effect_hits_entities(effect: &EffectType) -> bool {
 
 fn affect_tile(ecs: &mut World, effect: &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));
     }
-    
+
     match &effect.effect_type {
         EffectType::Bloodstain => damage::bloodstain(ecs, tile_idx),
         EffectType::Particle{..} => particles::particle_to_tile(ecs, tile_idx, &effect),

chapter-64-curses/src/main.rs

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

chapter-64-curses/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-64-curses/src/map/mod.rs

@@ -16,17 +16,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 {
@@ -37,32 +32,27 @@ 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 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(),

chapter-64-curses/src/map_indexing_system.rs

@@ -1,31 +1,31 @@
 use specs::prelude::*;
-use super::{Map, Position, BlocksTile};
+use super::{Map, Position, BlocksTile, Pools, spatial};
 
 pub struct MapIndexingSystem {}
 
 impl<'a> System<'a> for MapIndexingSystem {
-    type SystemData = ( WriteExpect<'a, Map>,
+    type SystemData = ( ReadExpect<'a, Map>,
                         ReadStorage<'a, Position>,
                         ReadStorage<'a, BlocksTile>,
+                        ReadStorage<'a, Pools>,
                         Entities<'a>,);
 
     fn run(&mut self, data : Self::SystemData) {
-        let (mut map, position, blockers, entities) = data;
+        let (map, position, blockers, pools, entities) = data;
 
-        map.populate_blocked();
-        map.clear_content_index();
+        spatial::clear();
+        spatial::populate_blocked_from_map(&*map);
         for (entity, position) in (&entities, &position).join() {
-            let idx = map.xy_idx(position.x, position.y);
-
-            // If they block, update the blocking list
-            let _p : Option<&BlocksTile> = blockers.get(entity);
-            if let Some(_p) = _p {
-                map.blocked[idx] = true;
+            let mut alive = true;
+            if let Some(pools) = pools.get(entity) {
+                if pools.hit_points.current < 1 {
+                    alive = false;
+                }
+            }
+            if alive {
+                let idx = map.xy_idx(position.x, position.y);
+                spatial::index_entity(entity, idx, blockers.get(entity).is_some());
             }
-
-            // Push the entity to the appropriate index slot. It's a Copy
-            // type, so we don't need to clone it (we want to avoid moving it out of the ECS!)
-            map.tile_content[idx].push(entity);
         }
     }
 }