blindness - misc

src/ai/visible_ai_system.rs

@@ -64,28 +64,40 @@ impl<'a> System<'a> for VisibleAI {
                     // If we didn't already evaluate this idx (if it's not contained in the HashSet),
                     // and it's not the idx we're standing on, then evaluate here w/ minds taken into
                     // account.
-                    if this_idx != idx && idxs.contains(&idx) {
+                    if this_idx != idx && !idxs.contains(&idx) {
                         evaluate(entity, idx, &ancestries, &factions, &mut reactions, Some(&minds));
                     }
                 }
             }
-            let mut done = false;
+            reactions.sort_by(|(a, _, _), (b, _, _)| {
+                let (a_x, a_y) = (a % map.width as usize, a / map.width as usize);
+                let dist_a = DistanceAlg::PythagorasSquared.distance2d(Point::new(a_x, a_y), Point::new(pos.x, pos.y));
+                let dist_a_estimate = dist_a as i32;
+                let (b_x, b_y) = (b % map.width as usize, b / map.width as usize);
+                let dist_b = DistanceAlg::PythagorasSquared.distance2d(Point::new(b_x, b_y), Point::new(pos.x, pos.y));
+                let dist_b_estimate = dist_b as i32;
+                return dist_b_estimate.cmp(&dist_a_estimate);
+            });
+            let mut found_flee = false;
             for reaction in reactions.iter() {
                 match reaction.1 {
                     Reaction::Attack => {
+                        if !found_flee {
                             wants_to_approach
                                 .insert(entity, WantsToApproach { idx: reaction.0 as i32 })
                                 .expect("Error inserting WantsToApproach");
                             chasing.insert(entity, Chasing { target: reaction.2 }).expect("Unable to insert Chasing");
-                        done = true;
+                            continue;
+                        }
                     }
                     Reaction::Flee => {
                         flee.push(reaction.0);
+                        found_flee = true;
                     }
                     _ => {}
                 }
             }
-            if !done && !flee.is_empty() {
+            if !flee.is_empty() {
                 wants_to_flee.insert(entity, WantsToFlee { indices: flee }).expect("Unable to insert");
             }
         }
@@ -103,7 +115,9 @@ fn evaluate(
     crate::spatial::for_each_tile_content(idx, |other_entity| {
         let mut check = true;
         if minds.is_some() {
+            console::log("Minds got passed! Evaluating!");
             if minds.unwrap().get(other_entity).is_none() {
+                console::log("No brain here. Skipping!");
                 check = false;
             }
         }

src/effects/damage.rs

@@ -1,4 +1,4 @@
-use super::{add_effect, get_noncursed, targeting, EffectSpawner, EffectType, Entity, Targets, World};
+use super::{add_effect, targeting, EffectSpawner, EffectType, Entity, Targets, World};
 use crate::{
     gamelog,
     gamesystem::{hp_per_level, mana_per_level},

src/effects/hunger.rs

@@ -1,5 +1,5 @@
 use super::{EffectSpawner, EffectType};
-use crate::{HungerClock, BUC};
+use crate::HungerClock;
 use specs::prelude::*;
 
 pub fn modify_nutrition(ecs: &mut World, effect: &EffectSpawner, target: Entity) {

src/effects/mod.rs

@@ -35,6 +35,7 @@ pub enum EffectType {
 }
 
 #[derive(Clone)]
+#[allow(dead_code)]
 pub enum Targets {
     Entity { target: Entity },
     EntityList { targets: Vec<Entity> },

src/gamelog/builder.rs

@@ -57,6 +57,7 @@ impl Logger {
     }
 
     /// Appends text in YELLOW to the current message logger.
+    #[allow(unused)]
     pub fn npc_name<T: ToString>(mut self, text: T) -> Self {
         let mut text_with_space = text.to_string();
         text_with_space.push_str(" ");

src/gui/mod.rs

@@ -1,8 +1,8 @@
 use super::{
     ai::CARRY_CAPACITY_PER_STRENGTH, camera, gamelog, gamesystem, hunger_system::get_hunger_colour,
     rex_assets::RexAssets, ArmourClassBonus, Attributes, Beatitude, Burden, Charges, Equipped, Hidden, HungerClock,
-    HungerState, InBackpack, MagicItem, MagicItemClass, Map, MasterDungeonMap, Name, ObfuscatedName, Player, Point,
+    HungerState, InBackpack, MagicItem, Map, MasterDungeonMap, Name, ObfuscatedName, Player, Point, Pools, Position,
-    Pools, Position, Prop, Renderable, RunState, Skill, Skills, State, Viewshed, BUC,
+    Prop, Renderable, RunState, Skill, Skills, State, Viewshed, BUC,
 };
 use rltk::prelude::*;
 use specs::prelude::*;
@@ -527,7 +527,7 @@ pub fn item_colour_ecs(ecs: &World, item: Entity) -> (u8, u8, u8) {
     return WHITE;
 }
 
-pub fn item_colour(item: Entity, beatitudes: &ReadStorage<Beatitude>, dm: &MasterDungeonMap) -> (u8, u8, u8) {
+pub fn item_colour(item: Entity, beatitudes: &ReadStorage<Beatitude>) -> (u8, u8, u8) {
     if let Some(beatitude) = beatitudes.get(item) {
         if beatitude.known {
             match beatitude.buc {

src/inventory/equip_system.rs

@@ -61,7 +61,7 @@ impl<'a> System<'a> for ItemEquipSystem {
                                 can_equip = false;
                                 logger = logger
                                     .append("You can't remove the")
-                                    .colour(item_colour(item_entity, &beatitudes, &dm))
+                                    .colour(item_colour(item_entity, &beatitudes))
                                     .append_n(
                                         obfuscate_name(
                                             item_entity,
@@ -94,7 +94,7 @@ impl<'a> System<'a> for ItemEquipSystem {
                     if target == *player_entity {
                         logger = logger
                             .append("You remove your")
-                            .colour(item_colour(*item, &beatitudes, &dm))
+                            .colour(item_colour(*item, &beatitudes))
                             .append_n(
                                 obfuscate_name(*item, &names, &magic_items, &obfuscated_names, &beatitudes, &dm, None)
                                     .0,
@@ -112,7 +112,7 @@ impl<'a> System<'a> for ItemEquipSystem {
                 if target == *player_entity {
                     logger = logger
                         .append("You equip the")
-                        .colour(item_colour(wants_to_use_item.item, &beatitudes, &dm))
+                        .colour(item_colour(wants_to_use_item.item, &beatitudes))
                         .append_n(
                             obfuscate_name(
                                 wants_to_use_item.item,

src/inventory/remove_system.rs

@@ -45,7 +45,7 @@ impl<'a> System<'a> for ItemRemoveSystem {
                     can_remove = false;
                     gamelog::Logger::new()
                         .append("You can't remove the")
-                        .colour(item_colour(to_remove.item, &beatitudes, &dm))
+                        .colour(item_colour(to_remove.item, &beatitudes))
                         .append_n(
                             obfuscate_name(
                                 to_remove.item,
@@ -72,7 +72,7 @@ impl<'a> System<'a> for ItemRemoveSystem {
                 if entity == *player_entity {
                     gamelog::Logger::new()
                         .append("You unequip the")
-                        .colour(item_colour(to_remove.item, &beatitudes, &dm))
+                        .colour(item_colour(to_remove.item, &beatitudes))
                         .append_n(
                             obfuscate_name(
                                 to_remove.item,

src/raws/mob_structs.rs

@@ -15,6 +15,7 @@ pub struct Mob {
     pub attributes: Option<MobAttributes>,
     pub skills: Option<HashMap<String, i32>>,
     pub vision_range: i32,
+    pub telepathy_range: Option<i32>,
     pub equipped: Option<Vec<String>>,
     pub loot: Option<LootTableInfo>,
     pub quips: Option<Vec<String>>,

src/raws/rawmaster.rs

@@ -93,6 +93,7 @@ macro_rules! apply_flags {
                 "SMALL_GROUP" => {} // These flags are for region spawning,
                 "LARGE_GROUP" => {} // and don't need to apply a component.
                 "MULTIATTACK" => $eb = $eb.with(MultiAttack {}),
+                "BLIND" => $eb = $eb.with(Blind {}),
                 _ => rltk::console::log(format!("Unrecognised flag: {}", flag.as_str())),
             }
         }
@@ -379,6 +380,9 @@ pub fn spawn_named_mob(
         eb = spawn_position(pos, eb, key, raws);
         eb = eb.with(Name { name: mob_template.name.clone(), plural: mob_template.name.clone() });
         eb = eb.with(Viewshed { visible_tiles: Vec::new(), range: mob_template.vision_range, dirty: true });
+        if let Some(telepath) = &mob_template.telepathy_range {
+            eb = eb.with(Telepath { telepath_tiles: Vec::new(), range: *telepath, dirty: true });
+        }
         if let Some(renderable) = &mob_template.renderable {
             eb = eb.with(get_renderable_component(renderable));
         }

src/saveload_system.rs

@@ -53,9 +53,10 @@ pub fn save_game(ecs: &mut World) {
             AOE,
             ArmourClassBonus,
             Attributes,
+            Beatitude,
+            Blind,
             BlocksTile,
             BlocksVisibility,
-            Beatitude,
             Burden,
             Chasing,
             Clock,
@@ -178,9 +179,10 @@ pub fn load_game(ecs: &mut World) {
             AOE,
             ArmourClassBonus,
             Attributes,
+            Beatitude,
+            Blind,
             BlocksTile,
             BlocksVisibility,
-            Beatitude,
             Burden,
             Chasing,
             Clock,

src/spawner.rs

@@ -1,6 +1,6 @@
 use super::{
     ai::NORMAL_SPEED, random_table::RandomTable, raws, Clock, Energy, EquipmentChanged, Faction, HungerClock,
-    HungerState, Map, Name, Player, Position, Rect, Renderable, SerializeMe, Skill, Skills, TileType, Viewshed,
+    HungerState, Map, Mind, Name, Player, Position, Rect, Renderable, SerializeMe, Skill, Skills, TileType, Viewshed,
 };
 use rltk::{RandomNumberGenerator, RGB};
 use specs::prelude::*;
@@ -26,6 +26,7 @@ pub fn player(ecs: &mut World, player_x: i32, player_y: i32) -> Entity {
             render_order: 0,
         })
         .with(Player {})
+        .with(Mind {})
         .with(Faction { name: "player".to_string() })
         .with(Viewshed { visible_tiles: Vec::new(), range: 12, dirty: true })
         .with(Name { name: "you".to_string(), plural: "you".to_string() })

src/visibility_system.rs

@@ -45,7 +45,7 @@ impl<'a> System<'a> for VisibilitySystem {
         for (ent, viewshed, pos) in (&entities, &mut viewshed, &pos).join() {
             if viewshed.dirty {
                 viewshed.dirty = false;
-                let mut range = if let Some(is_blind) = blind_entities.get(ent) { 1 } else { viewshed.range };
+                let range = if let Some(_is_blind) = blind_entities.get(ent) { 1 } else { viewshed.range };
                 let origin = Point::new(pos.x, pos.y);
                 viewshed.visible_tiles = SymmetricShadowcasting.field_of_view(origin, range, &*map);
                 viewshed.visible_tiles.retain(|p| {
@@ -94,7 +94,7 @@ impl<'a> System<'a> for VisibilitySystem {
             if telepath.dirty {
                 telepath.dirty = false;
                 let mut range = telepath.range;
-                if let Some(is_blind) = blind_entities.get(ent) {
+                if let Some(_is_blind) = blind_entities.get(ent) {
                     range *= BLIND_TELEPATHY_RANGE_MULTIPLIER;
                 }
                 telepath.telepath_tiles = fast_fov(pos.x, pos.y, range);