#59 #115 #57 - Chapter 68 update spatial.

thebracket · thebracket · commit e942769a358d · 2020-04-18T10:31:44.000-05:00
diff --git a/chapter-68-mushrooms/src/ai/adjacent_ai_system.rs b/chapter-68-mushrooms/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())
             ));
         }
-    }
+    });
 }
diff --git a/chapter-68-mushrooms/src/ai/default_move_system.rs b/chapter-68-mushrooms/src/ai/default_move_system.rs
@@ -42,7 +42,7 @@ 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] {
+                        if !crate::spatial::is_blocked(dest_idx) {
                             apply_move.insert(entity, ApplyMove{ dest_idx : 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
diff --git a/chapter-68-mushrooms/src/ai/flee_ai_system.rs b/chapter-68-mushrooms/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);
                     }
diff --git a/chapter-68-mushrooms/src/ai/visible_ai_system.rs b/chapter-68-mushrooms/src/ai/visible_ai_system.rs
@@ -87,13 +87,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
             ));
         }
-    }
+    });
 }
diff --git a/chapter-68-mushrooms/src/effects/damage.rs b/chapter-68-mushrooms/src/effects/damage.rs
@@ -50,9 +50,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 {
diff --git a/chapter-68-mushrooms/src/effects/mod.rs b/chapter-68-mushrooms/src/effects/mod.rs
@@ -107,7 +107,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));
     }
 
diff --git a/chapter-68-mushrooms/src/gui.rs b/chapter-68-mushrooms/src/gui.rs
@@ -300,12 +300,13 @@ 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. " };
@@ -323,7 +324,7 @@ 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));
         }
@@ -333,13 +334,13 @@ 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; }
 
diff --git a/chapter-68-mushrooms/src/main.rs b/chapter-68-mushrooms/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;
 
diff --git a/chapter-68-mushrooms/src/map/dungeon.rs b/chapter-68-mushrooms/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
diff --git a/chapter-68-mushrooms/src/map/mod.rs b/chapter-68-mushrooms/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,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);
                             }
                         }
                     }
@@ -72,22 +65,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(),
diff --git a/chapter-68-mushrooms/src/map_indexing_system.rs b/chapter-68-mushrooms/src/map_indexing_system.rs
@@ -1,48 +1,30 @@
 use specs::prelude::*;
-use super::{Map, Position, BlocksTile, TileSize};
+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, TileSize>,
+                        ReadStorage<'a, Pools>,
                         Entities<'a>,);
 
     fn run(&mut self, data : Self::SystemData) {
-        let (mut map, position, blockers, sizes, 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 let Some(size) = sizes.get(entity) {
-                // Multi-tile
-                for y in position.y .. position.y + size.y {
-                    for x in position.x .. position.x + size.x {
-                        if x > 0 && x < map.width-1 && y > 0 && y < map.height-1 {
-                            let idx = map.xy_idx(x, y);
-                            if blockers.get(entity).is_some() {
-                                map.blocked[idx] = true;
-                            }
-
-                            // 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);
-                        }
-                    }
-                }
-            } else {
-                // Single Tile
-                if blockers.get(entity).is_some() {
-                    map.blocked[idx] = true;
+            let mut alive = true;
+            if let Some(pools) = pools.get(entity) {
+                if pools.hit_points.current < 1 {
+                    alive = false;
                 }
-
-                // 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);
+            }
+            if alive {
+                let idx = map.xy_idx(position.x, position.y);
+                spatial::index_entity(entity, idx, blockers.get(entity).is_some());
             }
         }
     }
diff --git a/chapter-68-mushrooms/src/movement_system.rs b/chapter-68-mushrooms/src/movement_system.rs
@@ -32,9 +32,8 @@ impl<'a> System<'a> for MovementSystem {
                 *runstate = RunState::TeleportingToOtherLevel{ x: teleport.dest_x, y: teleport.dest_y, depth: teleport.dest_depth };
             } else if let Some(pos) = position.get(entity) {
                 let idx = map.xy_idx(pos.x, pos.y);
-                if blockers.get(entity).is_some() {
-                    map.blocked[idx] = false;
-                }
+                let dest_idx = map.xy_idx(teleport.dest_x, teleport.dest_y);
+                crate::spatial::move_entity(entity, idx, dest_idx);
                 other_level.insert(entity, OtherLevelPosition{
                     x: teleport.dest_x,
                     y: teleport.dest_y,
@@ -49,11 +48,7 @@ impl<'a> System<'a> for MovementSystem {
         for (entity, movement, mut pos) in (&entities, &apply_move, &mut position).join() {
             let start_idx = map.xy_idx(pos.x, pos.y);
             let dest_idx = movement.dest_idx as usize;
-            let is_blocking = blockers.get(entity);
-            if is_blocking.is_some() {
-                map.blocked[start_idx] = false;
-                map.blocked[dest_idx] = true;
-            }
+            crate::spatial::move_entity(entity, start_idx, dest_idx);
             pos.x = movement.dest_idx as i32 % map.width;
             pos.y = movement.dest_idx as i32 / map.width;
             if let Some(vs) = viewsheds.get_mut(entity) {
diff --git a/chapter-68-mushrooms/src/player.rs b/chapter-68-mushrooms/src/player.rs
@@ -29,14 +29,14 @@ pub fn try_move_player(delta_x: i32, delta_y: i32, ecs: &mut World) -> RunState
         if pos.x + delta_x < 1 || pos.x + delta_x > map.width-1 || pos.y + delta_y < 1 || pos.y + delta_y > map.height-1 { return RunState::AwaitingInput; }
         let destination_idx = map.xy_idx(pos.x + delta_x, pos.y + delta_y);
 
-        for potential_target in map.tile_content[destination_idx].iter() {
-            if let Some(_vendor) = vendors.get(*potential_target) {
-                return RunState::ShowVendor{ vendor: *potential_target, mode : VendorMode::Sell }
+        crate::spatial::for_each_tile_content(destination_idx, |potential_target| {
+            if let Some(_vendor) = vendors.get(potential_target) {
+                result = RunState::ShowVendor{ vendor: potential_target, mode : VendorMode::Sell }
             }
 
             let mut hostile = true;
-            if combat_stats.get(*potential_target).is_some() {
-                if let Some(faction) = factions.get(*potential_target) {
+            if combat_stats.get(potential_target).is_some() {
+                if let Some(faction) = factions.get(potential_target) {
                     let reaction = crate::raws::faction_reaction(
                         &faction.name,
                         "Player",
@@ -47,7 +47,7 @@ pub fn try_move_player(delta_x: i32, delta_y: i32, ecs: &mut World) -> RunState
             }
             if !hostile {
                 // Note that we want to move the bystander
-                swap_entities.push((*potential_target, pos.x, pos.y));
+                swap_entities.push((potential_target, pos.x, pos.y));
 
                 // Move the player
                 pos.x = min(map.width-1 , max(0, pos.x + delta_x));
@@ -58,26 +58,27 @@ pub fn try_move_player(delta_x: i32, delta_y: i32, ecs: &mut World) -> RunState
                 let mut ppos = ecs.write_resource::<Point>();
                 ppos.x = pos.x;
                 ppos.y = pos.y;
+                result = RunState::Ticking;
             } else {
-                let target = combat_stats.get(*potential_target);
+                let target = combat_stats.get(potential_target);
                 if let Some(_target) = target {
-                    wants_to_melee.insert(entity, WantsToMelee{ target: *potential_target }).expect("Add target failed");
-                    return RunState::Ticking;
+                    wants_to_melee.insert(entity, WantsToMelee{ target: potential_target }).expect("Add target failed");
+                    result = RunState::Ticking;
                 }
             }
-            let door = doors.get_mut(*potential_target);
+            let door = doors.get_mut(potential_target);
             if let Some(door) = door {
                 door.open = true;
-                blocks_visibility.remove(*potential_target);
-                blocks_movement.remove(*potential_target);
-                let glyph = renderables.get_mut(*potential_target).unwrap();
+                blocks_visibility.remove(potential_target);
+                blocks_movement.remove(potential_target);
+                let glyph = renderables.get_mut(potential_target).unwrap();
                 glyph.glyph = rltk::to_cp437('/');
                 viewshed.dirty = true;
                 result = RunState::Ticking;
             }
-        }
+        });
 
-        if !map.blocked[destination_idx] {
+        if !crate::spatial::is_blocked(destination_idx) {
             pos.x = min(map.width-1 , max(0, pos.x + delta_x));
             pos.y = min(map.height-1, max(0, pos.y + delta_y));
             entity_moved.insert(entity, EntityMoved{}).expect("Unable to insert marker");
@@ -167,8 +168,8 @@ fn skip_turn(ecs: &mut World) -> RunState {
     let viewshed = viewshed_components.get(*player_entity).unwrap();
     for tile in viewshed.visible_tiles.iter() {
         let idx = worldmap_resource.xy_idx(tile.x, tile.y);
-        for entity_id in worldmap_resource.tile_content[idx].iter() {
-            let faction = factions.get(*entity_id);
+        crate::spatial::for_each_tile_content(idx, |entity_id| {
+            let faction = factions.get(entity_id);
             match faction {
                 None => {}
                 Some(faction) => {
@@ -182,7 +183,7 @@ fn skip_turn(ecs: &mut World) -> RunState {
                     }
                 }
             }
-        }
+        });
     }
 
     let hunger_clocks = ecs.read_storage::<HungerClock>();
diff --git a/chapter-68-mushrooms/src/saveload_system.rs b/chapter-68-mushrooms/src/saveload_system.rs
diff --git a/chapter-68-mushrooms/src/spatial/mod.rs b/chapter-68-mushrooms/src/spatial/mod.rs
diff --git a/chapter-68-mushrooms/src/trigger_system.rs b/chapter-68-mushrooms/src/trigger_system.rs
diff --git a/chapter-68-mushrooms/src/visibility_system.rs b/chapter-68-mushrooms/src/visibility_system.rs

Original file line number	Diff line number	Diff line change
`@@ -71,12 +71,12 @@ impl<'a> System<'a> for AdjacentAI {`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`fn evaluate(idx : usize, map : &Map, factions : &ReadStorage<Faction>, my_faction : &str, reactions : &mut Vec<(Entity, Reaction)>) {`
`74`		`- for other_entity in map.tile_content[idx].iter() {`
`75`		`- if let Some(faction) = factions.get(*other_entity) {`
	`74`	`+ crate::spatial::for_each_tile_content(idx, \|other_entity\| {`
	`75`	`+ if let Some(faction) = factions.get(other_entity) {`
`76`	`76`	`reactions.push((`
`77`		`- *other_entity,`
	`77`	`+ other_entity,`
`78`	`78`	`crate::raws::faction_reaction(my_faction, &faction.name, &crate::raws::RAWS.lock().unwrap())`
`79`	`79`	`));`
`80`	`80`	`}`
`81`		`- }`
	`81`	`+ });`
`82`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ impl<'a> System<'a> for FleeAI {`
`28`	`28`	`let flee_map = rltk::DijkstraMap::new(map.width as usize, map.height as usize, &flee.indices, &*map, 100.0);`
`29`	`29`	`let flee_target = rltk::DijkstraMap::find_highest_exit(&flee_map, my_idx, &*map);`
`30`	`30`	`if let Some(flee_target) = flee_target {`
`31`		`- if !map.blocked[flee_target as usize] {`
	`31`	`+ if !crate::spatial::is_blocked(flee_target as usize) {`
`32`	`32`	`apply_move.insert(entity, ApplyMove{ dest_idx : flee_target }).expect("Unable to insert");`
`33`	`33`	`turn_done.push(entity);`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -87,13 +87,13 @@ impl<'a> System<'a> for VisibleAI {`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`fn evaluate(idx : usize, map : &Map, factions : &ReadStorage<Faction>, my_faction : &str, reactions : &mut Vec<(usize, Reaction, Entity)>) {`
`90`		`- for other_entity in map.tile_content[idx].iter() {`
`91`		`- if let Some(faction) = factions.get(*other_entity) {`
	`90`	`+ crate::spatial::for_each_tile_content(idx, \|other_entity\| {`
	`91`	`+ if let Some(faction) = factions.get(other_entity) {`
`92`	`92`	`reactions.push((`
`93`	`93`	`idx,`
`94`	`94`	`crate::raws::faction_reaction(my_faction, &faction.name, &crate::raws::RAWS.lock().unwrap()),`
`95`		`- *other_entity`
	`95`	`+ other_entity`
`96`	`96`	`));`
`97`	`97`	`}`
`98`		`- }`
	`98`	`+ });`
`99`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,9 +50,7 @@ pub fn death(ecs: &mut World, effect: &EffectSpawner, target : Entity) {`
`50`	`50`	`let mut attributes = ecs.write_storage::<Attributes>();`
`51`	`51`
`52`	`52`	`if let Some(pos) = entity_position(ecs, target) {`
`53`		`- let mut map_mut = ecs.fetch_mut::<Map>();`
`54`		`- map_mut.blocked[pos as usize] = false;`
`55`		`- std::mem::drop(map_mut);`
	`53`	`+ crate::spatial::remove_entity(target, pos as usize);`
`56`	`54`	`}`
`57`	`55`
`58`	`56`	`if let Some(source) = effect.creator {`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ fn tile_effect_hits_entities(effect: &EffectType) -> bool {`
`107`	`107`
`108`	`108`	`fn affect_tile(ecs: &mut World, effect: &mut EffectSpawner, tile_idx : i32) {`
`109`	`109`	`if tile_effect_hits_entities(&effect.effect_type) {`
`110`		`- let content = ecs.fetch::<Map>().tile_content[tile_idx as usize].clone();`
	`110`	`+ let content = crate::spatial::get_tile_content_clone(tile_idx as usize);`
`111`	`111`	`content.iter().for_each(\|entity\| affect_entity(ecs, effect, *entity));`
`112`	`112`	`}`
`113`	`113`