#59 #115 #57 - Spatial ported to chapter 73. Now to go back and bugfix.

Author: thebracket

chapter-73-systems/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-73-systems/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-73-systems/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-73-systems/src/main.rs

@@ -27,6 +27,7 @@ pub mod effects;
 extern crate lazy_static;
 mod systems;
 pub mod rng;
+pub mod spatial;
 
 const SHOW_MAPGEN_VISUALIZER : bool = false;
 const SHOW_FPS : bool = true;

chapter-73-systems/src/map/dungeon.rs

@@ -44,7 +44,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-73-systems/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(),

chapter-73-systems/src/player.rs

@@ -26,11 +26,11 @@ fn get_player_target_list(ecs : &mut World) -> Vec<(f32,Entity)> {
                     let tile_idx = map.xy_idx(tile_point.x, tile_point.y);
                     let distance_to_target = rltk::DistanceAlg::Pythagoras.distance2d(*tile_point, rltk::Point::new(player_pos.x, player_pos.y));
                     if distance_to_target < range as f32 {
-                        for possible_target in map.tile_content[tile_idx].iter() {
-                            if *possible_target != *player_entity && factions.get(*possible_target).is_some() {
-                                possible_targets.push((distance_to_target, *possible_target));
+                        crate::spatial::for_each_tile_content(tile_idx, |possible_target| {
+                            if possible_target != *player_entity && factions.get(possible_target).is_some() {
+                                possible_targets.push((distance_to_target, possible_target));
                             }
-                        }
+                        });
                     }
                 }
             }
@@ -133,14 +133,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",
@@ -151,7 +151,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));
@@ -162,26 +162,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");
@@ -268,8 +269,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) => {
@@ -283,7 +284,7 @@ fn skip_turn(ecs: &mut World) -> RunState {
                     }
                 }
             }
-        }
+        });
     }
 
     let hunger_clocks = ecs.read_storage::<HungerClock>();

chapter-73-systems/src/saveload_system.rs

@@ -137,7 +137,7 @@ pub fn load_game(ecs: &mut World) {
         for (e,h) in (&entities, &helper).join() {
             let mut worldmap = ecs.write_resource::<super::map::Map>();
             *worldmap = h.map.clone();
-            worldmap.tile_content = vec![Vec::new(); (worldmap.height * worldmap.width) as usize];
+            crate::spatial::set_size((worldmap.height * worldmap.width) as usize);
             deleteme = Some(e);
         }
         for (e,h) in (&entities, &helper2).join() {

chapter-73-systems/src/systems/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-73-systems/src/systems/ai/default_move_system.rs

@@ -41,8 +41,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);
                         }
@@ -53,7 +53,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