IntervalSpawningSystem{} fix, and mobs randomly move

src/bystander_ai_system.rs

@@ -22,6 +22,19 @@ impl<'a> System<'a> for BystanderAI {
         for (entity, mut viewshed, _bystander, mut pos, _turn) in
             (&entities, &mut viewshed, &bystander, &mut position, &turns).join()
         {
+            if try_move_randomly(&mut pos, &mut rng, &mut map, &mut viewshed) {
+                entity_moved.insert(entity, EntityMoved {}).expect("Unable to insert marker");
+            }
+        }
+    }
+}
+
+pub fn try_move_randomly(
+    pos: &mut Position,
+    rng: &mut rltk::RandomNumberGenerator,
+    map: &mut Map,
+    viewshed: &mut Viewshed,
+) -> bool {
     // Try to move randomly
     let mut x = pos.x;
     let mut y = pos.y;
@@ -41,11 +54,10 @@ impl<'a> System<'a> for BystanderAI {
             map.blocked[idx] = false;
             pos.x = x;
             pos.y = y;
-                    entity_moved.insert(entity, EntityMoved {}).expect("Unable to insert marker");
             map.blocked[dest_idx] = true;
             viewshed.dirty = true;
+            return true;
         }
     }
-        }
+    return false;
-    }
 }

src/main.rs

@@ -176,6 +176,7 @@ impl State {
     fn entities_to_remove_on_level_change(&mut self) -> Vec<Entity> {
         let entities = self.ecs.entities();
         let player = self.ecs.read_storage::<Player>();
+        let clock = self.ecs.read_storage::<Clock>();
         let backpack = self.ecs.read_storage::<InBackpack>();
         let player_entity = self.ecs.fetch::<Entity>();
         let equipped = self.ecs.read_storage::<Equipped>();
@@ -184,6 +185,12 @@ impl State {
         for entity in entities.join() {
             let mut should_delete = true;
 
+            // Don't delete the turn clock
+            let c = clock.get(entity);
+            if let Some(_c) = c {
+                should_delete = false;
+            }
+
             // Don't delete player
             let p = player.get(entity);
             if let Some(_p) = p {

src/map/interval_spawning_system.rs

@@ -1,4 +1,4 @@
-use crate::{gamelog, raws, spawner, Clock, Map, RandomNumberGenerator, TakingTurn};
+use crate::{gamelog, raws, spawner, Clock, Map, RandomNumberGenerator, TakingTurn, LOG_SPAWNING};
 use specs::prelude::*;
 
 const TRY_SPAWN_CHANCE: i32 = 70;
@@ -17,12 +17,14 @@ pub fn try_spawn_interval(ecs: &mut World) {
         let mut rng = ecs.write_resource::<rltk::RandomNumberGenerator>();
         for (_c, _t) in (&clock, &turns).join() {
             if rng.roll_dice(1, TRY_SPAWN_CHANCE) == 1 {
-                rltk::console::log("Trying spawn.");
                 try_spawn = true;
             }
         }
     }
     if try_spawn {
+        if LOG_SPAWNING {
+            rltk::console::log("SPAWNINFO: Trying spawn.");
+        }
         spawn_random_mob_in_free_nonvisible_tile(ecs);
     }
 }
@@ -32,6 +34,9 @@ fn spawn_random_mob_in_free_nonvisible_tile(ecs: &mut World) {
     let available_tiles = populate_unblocked_nonvisible_tiles(&map);
     let difficulty = (map.difficulty + gamelog::get_event_count("player_level")) / 2;
     if available_tiles.len() == 0 {
+        if LOG_SPAWNING {
+            rltk::console::log("SPAWNINFO: No free tiles; not spawning anything..");
+        }
         return;
     }
     let mut rng = ecs.write_resource::<RandomNumberGenerator>();
@@ -41,6 +46,9 @@ fn spawn_random_mob_in_free_nonvisible_tile(ecs: &mut World) {
     let y = idx as i32 / map.width;
     std::mem::drop(map);
     std::mem::drop(rng);
+    if LOG_SPAWNING {
+        rltk::console::log(format!("SPAWNINFO: Spawning {} at {}, {}.", key, x, y));
+    }
     raws::spawn_named_entity(&raws::RAWS.lock().unwrap(), ecs, &key, raws::SpawnType::AtPosition { x, y }, difficulty);
 }
 
@@ -56,5 +64,5 @@ fn populate_unblocked_nonvisible_tiles(map: &Map) -> Vec<usize> {
 
 fn get_random_idx_from_possible_tiles(rng: &mut rltk::RandomNumberGenerator, area: Vec<usize>) -> usize {
     let idx = if area.len() == 1 { 0usize } else { (rng.roll_dice(1, area.len() as i32) - 1) as usize };
-    return idx;
+    return area[idx];
 }

src/map_builders/mod.rs

@@ -361,6 +361,6 @@ pub fn level_builder(
     match new_id {
         1 => town_builder(new_id, rng, width, height, 0, initial_player_level),
         2 => forest_builder(new_id, rng, width, height, 1, initial_player_level),
-        _ => random_builder(new_id, rng, width, height, difficulty, initial_player_level),
+        _ => random_builder(new_id, rng, 64, 64, difficulty, initial_player_level),
     }
 }

src/monster_ai_system.rs

@@ -1,4 +1,4 @@
-use super::{EntityMoved, Map, Monster, Position, TakingTurn, Viewshed, WantsToMelee};
+use super::{bystander_ai_system, EntityMoved, Map, Monster, Position, TakingTurn, Viewshed, WantsToMelee};
 use rltk::Point;
 use specs::prelude::*;
 
@@ -8,6 +8,7 @@ impl<'a> System<'a> for MonsterAI {
     #[allow(clippy::type_complexity)]
     type SystemData = (
         WriteExpect<'a, Map>,
+        WriteExpect<'a, rltk::RandomNumberGenerator>,
         ReadExpect<'a, Point>,
         ReadExpect<'a, Entity>,
         Entities<'a>,
@@ -22,6 +23,7 @@ impl<'a> System<'a> for MonsterAI {
     fn run(&mut self, data: Self::SystemData) {
         let (
             mut map,
+            mut rng,
             player_pos,
             player_entity,
             entities,
@@ -57,6 +59,10 @@ impl<'a> System<'a> for MonsterAI {
                     viewshed.dirty = true;
                     entity_moved.insert(entity, EntityMoved {}).expect("Unable to insert marker");
                 }
+            } else {
+                if bystander_ai_system::try_move_randomly(&mut pos, &mut rng, &mut map, &mut viewshed) {
+                    entity_moved.insert(entity, EntityMoved {}).expect("Unable to insert marker");
+                }
             }
         }
     }