Large update of 57A onwards to properly handle player.rs try_move function.

Author: thebracket

book/src/chapter_57a.md

@@ -494,7 +494,26 @@ crate::spatial::for_each_tile_content(idx, |mob| targets.push(mob));
 
 ### Fixing player.rs
 
-The function `try_move_player` does a really big query of the spatial indexing system. Replacing it with the new API is mostly a matter of using the new functions, and performing the index check inside the closure. Here's the new function:
+The function `try_move_player` does a really big query of the spatial indexing system. It also sometimes returns mid-calculation, which our API doesn't currently support. We'll add a new function to our `spatial/mod.rs` file to enable this:
+
+```rust
+pub fn for_each_tile_content_with_gamemode<F>(idx: usize, mut f: F) -> RunState
+where F : FnMut(Entity)->Option<RunState>
+{
+    let lock = SPATIAL_MAP.lock().unwrap();
+    for entity in lock.tile_content[idx].iter() {
+        if let Some(rs) = f(entity.0) {
+            return rs;
+        }
+    }
+
+    RunState::AwaitingInput
+}
+```
+
+This function runs like the other one, but accepts an optional game mode from the closure. If the game mode is `Some(x)`, then it returns `x`. If it hasn't received any modes by the end, it returns `AwaitingInput`.
+
+ Replacing it with the new API is mostly a matter of using the new functions, and performing the index check inside the closure. Here's the new function:
 
 ```rust
 pub fn try_move_player(delta_x: i32, delta_y: i32, ecs: &mut World) -> RunState {
@@ -519,7 +538,7 @@ 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);
 
-        crate::spatial::for_each_tile_content(destination_idx, |potential_target| {
+        result = crate::spatial::for_each_tile_content_with_gamemode(destination_idx, |potential_target| {
             let mut hostile = true;
             if combat_stats.get(potential_target).is_some() {
                 if let Some(faction) = factions.get(potential_target) {
@@ -544,11 +563,12 @@ 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;
+                return Some(RunState::Ticking);
             } else {
                 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");
-                    result = RunState::Ticking;
+                    return Some(RunState::Ticking);
                 }
             }
             let door = doors.get_mut(potential_target);
@@ -559,8 +579,9 @@ pub fn try_move_player(delta_x: i32, delta_y: i32, ecs: &mut World) -> RunState
                 let glyph = renderables.get_mut(potential_target).unwrap();
                 glyph.glyph = rltk::to_cp437('/');
                 viewshed.dirty = true;
-                result = RunState::Ticking;
+                return Some(RunState::Ticking);
             }
+            None
         });
 
         if !crate::spatial::is_blocked(destination_idx) {
@@ -587,9 +608,12 @@ pub fn try_move_player(delta_x: i32, delta_y: i32, ecs: &mut World) -> RunState
     for m in swap_entities.iter() {
         let their_pos = positions.get_mut(m.0);
         if let Some(their_pos) = their_pos {
-            // TODO: Swapping
+            let old_idx = map.xy_idx(their_pos.x, their_pos.y);
             their_pos.x = m.1;
             their_pos.y = m.2;
+            let new_idx = map.xy_idx(their_pos.x, their_pos.y);
+            crate::spatial::move_entity(m.0, old_idx, new_idx);
+            result = RunState::Ticking;
         }
     }
 

book/src/chapter_58.md

@@ -689,12 +689,12 @@ let mut swap_entities : Vec<(Entity, i32, i32)> = Vec::new();
 
 for (entity, _player, pos, viewshed) in (&entities, &players, &mut positions, &mut viewsheds).join() {
     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);
+        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 }
-        }
+        result = crate::spatial::for_each_tile_content_with_gamemode(destination_idx, |potential_target| {
+            if let Some(_vendor) = vendors.get(potential_target) {
+                return Some(RunState::ShowVendor{ vendor: potential_target, mode : VendorMode::Sell });
+            }
 ...
 ```
 

book/src/chapter_70.md

@@ -257,11 +257,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));
                             }
-                        }
+                        });
                     }
                 }
             }

chapter-57a-spatial/src/player.rs

@@ -28,7 +28,7 @@ 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);
 
-        crate::spatial::for_each_tile_content(destination_idx, |potential_target| {
+        result = crate::spatial::for_each_tile_content_with_gamemode(destination_idx, |potential_target| {
             let mut hostile = true;
             if combat_stats.get(potential_target).is_some() {
                 if let Some(faction) = factions.get(potential_target) {
@@ -53,11 +53,12 @@ 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;
+                return Some(RunState::Ticking);
             } else {
                 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");
-                    result = RunState::Ticking;
+                    return Some(RunState::Ticking);
                 }
             }
             let door = doors.get_mut(potential_target);
@@ -68,8 +69,9 @@ pub fn try_move_player(delta_x: i32, delta_y: i32, ecs: &mut World) -> RunState
                 let glyph = renderables.get_mut(potential_target).unwrap();
                 glyph.glyph = rltk::to_cp437('/');
                 viewshed.dirty = true;
-                result = RunState::Ticking;
+                return Some(RunState::Ticking);
             }
+            None
         });
 
         if !crate::spatial::is_blocked(destination_idx) {

chapter-57a-spatial/src/spatial/mod.rs

@@ -1,6 +1,6 @@
 use std::sync::Mutex;
 use specs::prelude::*;
-use crate::{ Map, tile_walkable };
+use crate::{ Map, tile_walkable, RunState };
 
 struct SpatialMap {
     blocked : Vec<(bool, bool)>,
@@ -63,6 +63,19 @@ where F : FnMut(Entity)
     }
 }
 
+pub fn for_each_tile_content_with_gamemode<F>(idx: usize, mut f: F) -> RunState
+where F : FnMut(Entity)->Option<RunState>
+{
+    let lock = SPATIAL_MAP.lock().unwrap();
+    for entity in lock.tile_content[idx].iter() {
+        if let Some(rs) = f(entity.0) {
+            return rs;
+        }
+    }
+
+    RunState::AwaitingInput
+}
+
 pub fn move_entity(entity: Entity, moving_from: usize, moving_to: usize) {
     let mut lock = SPATIAL_MAP.lock().unwrap();
     let mut entity_blocks = false;

chapter-58-itemstats/src/player.rs

@@ -6,108 +6,114 @@ use super::{Position, Player, Viewshed, State, Map, RunState, Attributes, WantsT
     EntityMoved, Door, BlocksTile, BlocksVisibility, Renderable, Pools, Faction,
     raws::Reaction, Vendor, VendorMode};
 
-    pub fn try_move_player(delta_x: i32, delta_y: i32, ecs: &mut World) -> RunState {
-        let mut positions = ecs.write_storage::<Position>();
-        let players = ecs.read_storage::<Player>();
-        let mut viewsheds = ecs.write_storage::<Viewshed>();
-        let entities = ecs.entities();
-        let combat_stats = ecs.read_storage::<Attributes>();
-        let map = ecs.fetch::<Map>();
-        let mut wants_to_melee = ecs.write_storage::<WantsToMelee>();
-        let mut entity_moved = ecs.write_storage::<EntityMoved>();
-        let mut doors = ecs.write_storage::<Door>();
-        let mut blocks_visibility = ecs.write_storage::<BlocksVisibility>();
-        let mut blocks_movement = ecs.write_storage::<BlocksTile>();
-        let mut renderables = ecs.write_storage::<Renderable>();
-        let factions = ecs.read_storage::<Faction>();
-        let mut result = RunState::AwaitingInput;
-    
-        let mut swap_entities : Vec<(Entity, i32, i32)> = Vec::new();
-    
-        for (entity, _player, pos, viewshed) in (&entities, &players, &mut positions, &mut viewsheds).join() {
-            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);
-    
-            crate::spatial::for_each_tile_content(destination_idx, |potential_target| {
-                let mut hostile = true;
-                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",
-                            &crate::raws::RAWS.lock().unwrap()
-                        );
-                        if reaction != Reaction::Attack { hostile = false; }
-                    }
-                }
-                if !hostile {
-                    // Note that we want to move the bystander
-                    swap_entities.push((potential_target, pos.x, pos.y));
-    
-                    // Move the player
-                    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");
-    
-                    viewshed.dirty = true;
-                    let mut ppos = ecs.write_resource::<Point>();
-                    ppos.x = pos.x;
-                    ppos.y = pos.y;
-                } else {
-                    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");
-                        result = RunState::Ticking;
-                    }
-                }
-                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();
-                    glyph.glyph = rltk::to_cp437('/');
-                    viewshed.dirty = true;
-                    result = RunState::Ticking;
+pub fn try_move_player(delta_x: i32, delta_y: i32, ecs: &mut World) -> RunState {
+    let mut positions = ecs.write_storage::<Position>();
+    let players = ecs.read_storage::<Player>();
+    let mut viewsheds = ecs.write_storage::<Viewshed>();
+    let entities = ecs.entities();
+    let combat_stats = ecs.read_storage::<Attributes>();
+    let map = ecs.fetch::<Map>();
+    let mut wants_to_melee = ecs.write_storage::<WantsToMelee>();
+    let mut entity_moved = ecs.write_storage::<EntityMoved>();
+    let mut doors = ecs.write_storage::<Door>();
+    let mut blocks_visibility = ecs.write_storage::<BlocksVisibility>();
+    let mut blocks_movement = ecs.write_storage::<BlocksTile>();
+    let mut renderables = ecs.write_storage::<Renderable>();
+    let factions = ecs.read_storage::<Faction>();
+    let mut result = RunState::AwaitingInput;
+    let vendors = ecs.read_storage::<Vendor>();
+
+    let mut swap_entities : Vec<(Entity, i32, i32)> = Vec::new();
+
+    for (entity, _player, pos, viewshed) in (&entities, &players, &mut positions, &mut viewsheds).join() {
+        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);
+
+        result = crate::spatial::for_each_tile_content_with_gamemode(destination_idx, |potential_target| {
+            if let Some(_vendor) = vendors.get(potential_target) {
+                return Some(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) {
+                    let reaction = crate::raws::faction_reaction(
+                        &faction.name,
+                        "Player",
+                        &crate::raws::RAWS.lock().unwrap()
+                    );
+                    if reaction != Reaction::Attack { hostile = false; }
                 }
-            });
-    
-            if !crate::spatial::is_blocked(destination_idx) {
-                let old_idx = map.xy_idx(pos.x, pos.y);
+            }
+            if !hostile {
+                // Note that we want to move the bystander
+                swap_entities.push((potential_target, pos.x, pos.y));
+
+                // Move the player
                 pos.x = min(map.width-1 , max(0, pos.x + delta_x));
                 pos.y = min(map.height-1, max(0, pos.y + delta_y));
-                let new_idx = map.xy_idx(pos.x, pos.y);
                 entity_moved.insert(entity, EntityMoved{}).expect("Unable to insert marker");
-                crate::spatial::move_entity(entity, old_idx, new_idx);
-    
+
                 viewshed.dirty = true;
                 let mut ppos = ecs.write_resource::<Point>();
                 ppos.x = pos.x;
                 ppos.y = pos.y;
-                result = RunState::Ticking;
-                match map.tiles[destination_idx] {
-                    TileType::DownStairs => result = RunState::NextLevel,
-                    TileType::UpStairs => result = RunState::PreviousLevel,
-                    _ => {}
+                return Some(RunState::Ticking);
+            } else {
+                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 Some(RunState::Ticking);
                 }
             }
-        }
-    
-        for m in swap_entities.iter() {
-            let their_pos = positions.get_mut(m.0);
-            if let Some(their_pos) = their_pos {
-                let old_idx = map.xy_idx(their_pos.x, their_pos.y);
-                their_pos.x = m.1;
-                their_pos.y = m.2;
-                let new_idx = map.xy_idx(their_pos.x, their_pos.y);
-                crate::spatial::move_entity(m.0, old_idx, new_idx);
-                result = RunState::Ticking;
+            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();
+                glyph.glyph = rltk::to_cp437('/');
+                viewshed.dirty = true;
+                return Some(RunState::Ticking);
+            }
+            None
+        });
+
+        if !crate::spatial::is_blocked(destination_idx) {
+            let old_idx = map.xy_idx(pos.x, pos.y);
+            pos.x = min(map.width-1 , max(0, pos.x + delta_x));
+            pos.y = min(map.height-1, max(0, pos.y + delta_y));
+            let new_idx = map.xy_idx(pos.x, pos.y);
+            entity_moved.insert(entity, EntityMoved{}).expect("Unable to insert marker");
+            crate::spatial::move_entity(entity, old_idx, new_idx);
+
+            viewshed.dirty = true;
+            let mut ppos = ecs.write_resource::<Point>();
+            ppos.x = pos.x;
+            ppos.y = pos.y;
+            result = RunState::Ticking;
+            match map.tiles[destination_idx] {
+                TileType::DownStairs => result = RunState::NextLevel,
+                TileType::UpStairs => result = RunState::PreviousLevel,
+                _ => {}
             }
         }
-    
-        result
     }
 
+    for m in swap_entities.iter() {
+        let their_pos = positions.get_mut(m.0);
+        if let Some(their_pos) = their_pos {
+            let old_idx = map.xy_idx(their_pos.x, their_pos.y);
+            their_pos.x = m.1;
+            their_pos.y = m.2;
+            let new_idx = map.xy_idx(their_pos.x, their_pos.y);
+            crate::spatial::move_entity(m.0, old_idx, new_idx);
+            result = RunState::Ticking;
+        }
+    }
+
+    result
+}
+
 pub fn try_next_level(ecs: &mut World) -> bool {
     let player_pos = ecs.fetch::<Point>();
     let map = ecs.fetch::<Map>();