cleans up linter warns

src/ai/energy_system.rs

@@ -68,7 +68,7 @@ impl<'a> System<'a> for EnergySystem {
                     .insert(entity, TakingTurn {})
                     .expect("Unable to insert turn for turn counter.");
                 energy.current -= TURN_COST;
-                crate::gamelog::record_event(EVENT::TURN(1));
+                crate::gamelog::record_event(EVENT::Turn(1));
                 // Handle spawning mobs each turn
                 if CONFIG.logging.log_ticks {
                     console::log(

src/ai/turn_status_system.rs

@@ -99,7 +99,7 @@ impl<'a> System<'a> for TurnStatusSystem {
                         .colour(WHITE)
                         .append("are confused!");
                     log = true;
-                    gamelog::record_event(EVENT::PLAYER_CONFUSED(1));
+                    gamelog::record_event(EVENT::PlayerConfused(1));
                 } else {
                     logger = logger
                         .append("The")

src/damage_system.rs

@@ -81,7 +81,7 @@ pub fn delete_the_dead(ecs: &mut World) {
     }
     // For everything that died, increment the event log, and delete.
     for victim in dead {
-        gamelog::record_event(events::EVENT::TURN(1));
+        gamelog::record_event(events::EVENT::Turn(1));
         ecs.delete_entity(victim).expect("Unable to delete.");
     }
 }

src/data/events.rs

@@ -2,17 +2,17 @@ use serde::{ Deserialize, Serialize };
 
 #[derive(Serialize, Deserialize, Clone)]
 pub enum EVENT {
-    TURN(i32),
+    Turn(i32),
-    LEVEL(i32),
+    Level(i32),
-    CHANGED_FLOOR(String),
+    ChangedFloor(String),
-    PLAYER_CONFUSED(i32),
+    PlayerConfused(i32),
-    KICKED_SOMETHING(i32),
+    KickedSomething(i32),
-    BROKE_DOOR(i32),
+    BrokeDoor(i32),
-    LOOKED_FOR_HELP(i32),
+    LookedForHelp(i32),
-    KILLED(String),
+    Killed(String),
-    PLAYER_DIED(String),
+    PlayerDied(String),
-    DISCOVERED(String),
+    Discovered(String),
-    IDENTIFIED(String),
+    Identified(String),
 }
 
 impl EVENT {
@@ -20,8 +20,8 @@ impl EVENT {
     pub const COUNT_KILLED: &str = "killed";
     pub const COUNT_LEVEL: &str = "level";
     pub const COUNT_CHANGED_FLOOR: &str = "changed_floor";
-    pub const COUNT_BROKE_DOOR: &str = "broke_door";
+    pub const COUNT_BROKE_DOOR: &str = "BrokeDoor";
-    pub const COUNT_PLAYER_CONFUSED: &str = "player_confused";
+    pub const COUNT_PLAYER_CONFUSED: &str = "PlayerConfused";
     pub const COUNT_KICK: &str = "kick";
-    pub const COUNT_LOOKED_FOR_HELP: &str = "looked_for_help";
+    pub const COUNT_LOOKED_FOR_HELP: &str = "LookedForHelp";
 }

src/data/messages.rs

@@ -31,15 +31,15 @@ pub const YOU_REMOVE_ITEM: &str = "You unequip your";
 pub const YOU_REMOVE_ITEM_CURSED: &str = "You can't remove the";
 
 /// Prefixes death message.
-pub const PLAYER_DIED: &str = "You died!";
+pub const PlayerDied: &str = "You died!";
-/// Death message specifiers. Appended after PLAYER_DIED.
+/// Death message specifiers. Appended after PlayerDied.
-pub const PLAYER_DIED_SUICIDE: &str = "You killed yourself";
+pub const PlayerDied_SUICIDE: &str = "You killed yourself";
-pub const PLAYER_DIED_NAMED_ATTACKER: &str = "You were killed by";
+pub const PlayerDied_NAMED_ATTACKER: &str = "You were killed by";
-pub const PLAYER_DIED_UNKNOWN: &str = "You were killed"; // Ultimately, this should never be used. Slowly include specific messages for any death.
+pub const PlayerDied_UNKNOWN: &str = "You were killed"; // Ultimately, this should never be used. Slowly include specific messages for any death.
 /// Death message addendums. Appended at end of death message.
-pub const PLAYER_DIED_ADDENDUM_FIRST: &str = " ";
+pub const PlayerDied_ADDENDUM_FIRST: &str = " ";
-pub const PLAYER_DIED_ADDENDUM_MID: &str = ", ";
+pub const PlayerDied_ADDENDUM_MID: &str = ", ";
-pub const PLAYER_DIED_ADDENDUM_LAST: &str = ", and ";
+pub const PlayerDied_ADDENDUM_LAST: &str = ", and ";
 pub const STATUS_CONFUSED_STRING: &str = "confused";
 pub const STATUS_BLIND_STRING: &str = "blinded";
 // Results in something like: "You died! You were killed by a kobold captain, whilst confused."

src/effects/damage.rs

@@ -170,16 +170,16 @@ fn get_next_level_requirement(level: i32) -> i32 {
 
 fn get_death_message(ecs: &World, source: Entity) -> String {
     let player = ecs.fetch::<Entity>();
-    let mut result: String = format!("{} ", PLAYER_DIED);
+    let mut result: String = format!("{} ", PlayerDied);
     // If we killed ourselves,
     if source == *player {
-        result.push_str(format!("{}", PLAYER_DIED_SUICIDE).as_str());
+        result.push_str(format!("{}", PlayerDied_SUICIDE).as_str());
     } else if let Some(name) = ecs.read_storage::<Name>().get(source) {
         result.push_str(
-            format!("{} {}", PLAYER_DIED_NAMED_ATTACKER, with_article(name.name.clone())).as_str()
+            format!("{} {}", PlayerDied_NAMED_ATTACKER, with_article(name.name.clone())).as_str()
         );
     } else {
-        result.push_str(format!("{}", PLAYER_DIED_UNKNOWN).as_str());
+        result.push_str(format!("{}", PlayerDied_UNKNOWN).as_str());
     }
     // Status effects
     {
@@ -194,11 +194,11 @@ fn get_death_message(ecs: &World, source: Entity) -> String {
             result.push_str(" whilst");
             for (i, addendum) in addendums.iter().enumerate() {
                 if i == 0 {
-                    result.push_str(format!("{}{}", PLAYER_DIED_ADDENDUM_FIRST, addendum).as_str());
+                    result.push_str(format!("{}{}", PlayerDied_ADDENDUM_FIRST, addendum).as_str());
                 } else if i == addendums.len() {
-                    result.push_str(format!("{}{}", PLAYER_DIED_ADDENDUM_LAST, addendum).as_str());
+                    result.push_str(format!("{}{}", PlayerDied_ADDENDUM_LAST, addendum).as_str());
                 } else {
-                    result.push_str(format!("{}{}", PLAYER_DIED_ADDENDUM_MID, addendum).as_str());
+                    result.push_str(format!("{}{}", PlayerDied_ADDENDUM_MID, addendum).as_str());
                 }
             }
         }
@@ -221,12 +221,12 @@ pub fn entity_death(ecs: &mut World, effect: &EffectSpawner, target: Entity) {
     if let Some(source) = effect.source {
         // If the target was the player, game over, and record source of death.
         if target == *player {
-            gamelog::record_event(EVENT::PLAYER_DIED(get_death_message(ecs, source)));
+            gamelog::record_event(EVENT::PlayerDied(get_death_message(ecs, source)));
             return;
         } else {
             // If the player was the source, record the kill.
             if let Some(tar_name) = names.get(target) {
-                gamelog::record_event(EVENT::KILLED(tar_name.name.clone()));
+                gamelog::record_event(EVENT::Killed(tar_name.name.clone()));
             }
         }
         // Calc XP value of target.
@@ -246,7 +246,7 @@ pub fn entity_death(ecs: &mut World, effect: &EffectSpawner, target: Entity) {
                 source_pools.level += 1;
                 // If it was the PLAYER that levelled up:
                 if ecs.read_storage::<Player>().get(source).is_some() {
-                    gamelog::record_event(EVENT::LEVEL(1));
+                    gamelog::record_event(EVENT::Level(1));
                     gamelog::Logger
                         ::new()
                         .append(LEVELUP_PLAYER)
@@ -328,11 +328,11 @@ pub fn entity_death(ecs: &mut World, effect: &EffectSpawner, target: Entity) {
         if target == *player {
             if let Some(hc) = ecs.read_storage::<HungerClock>().get(target) {
                 if hc.state == HungerState::Starving {
-                    gamelog::record_event(EVENT::PLAYER_DIED("You starved to death!".to_string()));
+                    gamelog::record_event(EVENT::PlayerDied("You starved to death!".to_string()));
                 }
             } else {
                 gamelog::record_event(
-                    EVENT::PLAYER_DIED("You died from unknown causes!".to_string())
+                    EVENT::PlayerDied("You died from unknown causes!".to_string())
                 );
             }
         }

src/effects/triggers.rs

@@ -30,7 +30,6 @@ use crate::{
     SingleActivation,
     BUC,
     GrantsSpell,
-    KnownSpell,
     KnownSpells,
     Position,
     Viewshed,
@@ -175,9 +174,9 @@ fn handle_grant_spell(
     event: &mut EventInfo,
     mut logger: gamelog::Logger
 ) -> (gamelog::Logger, bool) {
-    if let Some(granted_spell) = ecs.read_storage::<GrantsSpell>().get(event.entity) {
+    if let Some(_granted_spell) = ecs.read_storage::<GrantsSpell>().get(event.entity) {
         if
-            let Some(known_spells) = ecs
+            let Some(_known_spells) = ecs
                 .write_storage::<KnownSpells>()
                 .get_mut(event.source.unwrap())
         {
@@ -349,10 +348,10 @@ fn handle_identify(
                     .get(event.source.unwrap())
                     .map(|b| b.known)
                     .unwrap_or(true);
-                return (
+                let result =
                     in_this_backpack &&
-                    (has_obfuscated_name || !already_identified || !known_beatitude)
+                    (has_obfuscated_name || !already_identified || !known_beatitude);
-                );
+                return result;
             }) {
             to_identify.push((e, name.name.clone()));
         }

src/gamelog/events.rs

@@ -73,12 +73,12 @@ pub fn record_event(event: EVENT) {
     let mut new_event: String = "unknown event".to_string();
     let mut significant_event = true;
     match event {
-        EVENT::TURN(n) => {
+        EVENT::Turn(n) => {
             modify_event_count(EVENT::COUNT_TURN, n);
             significant_event = false;
         }
         // If de-levelling is ever implemented, this needs refactoring (along with a lot of stuff).
-        EVENT::LEVEL(n) => {
+        EVENT::Level(n) => {
             modify_event_count(EVENT::COUNT_LEVEL, n);
             let new_lvl = get_event_count(EVENT::COUNT_LEVEL);
             if new_lvl == 1 {
@@ -87,7 +87,7 @@ pub fn record_event(event: EVENT) {
                 new_event = format!("Advanced to level {}", new_lvl);
             }
         }
-        EVENT::CHANGED_FLOOR(n) => {
+        EVENT::ChangedFloor(n) => {
             modify_event_count(EVENT::COUNT_CHANGED_FLOOR, 1);
             if VISITED.lock().unwrap().contains(&n) {
                 significant_event = false;
@@ -96,23 +96,23 @@ pub fn record_event(event: EVENT) {
                 new_event = format!("Visited {} for the first time", n);
             }
         }
-        EVENT::KICKED_SOMETHING(n) => {
+        EVENT::KickedSomething(n) => {
             modify_event_count(EVENT::COUNT_KICK, n);
             significant_event = false;
         }
-        EVENT::BROKE_DOOR(n) => {
+        EVENT::BrokeDoor(n) => {
             modify_event_count(EVENT::COUNT_BROKE_DOOR, n);
             significant_event = false;
         }
-        EVENT::PLAYER_CONFUSED(n) => {
+        EVENT::PlayerConfused(n) => {
             modify_event_count(EVENT::COUNT_PLAYER_CONFUSED, n);
             significant_event = false;
         }
-        EVENT::LOOKED_FOR_HELP(n) => {
+        EVENT::LookedForHelp(n) => {
             modify_event_count(EVENT::COUNT_LOOKED_FOR_HELP, n);
             significant_event = false;
         }
-        EVENT::KILLED(name) => {
+        EVENT::Killed(name) => {
             modify_event_count(EVENT::COUNT_KILLED, 1);
             if KILLED.lock().unwrap().contains(&name) {
                 significant_event = false;
@@ -121,13 +121,13 @@ pub fn record_event(event: EVENT) {
                 new_event = format!("Killed your first {}", name);
             }
         }
-        EVENT::DISCOVERED(name) => {
+        EVENT::Discovered(name) => {
             new_event = format!("Discovered {}", name);
         }
-        EVENT::IDENTIFIED(name) => {
+        EVENT::Identified(name) => {
             new_event = format!("Identified {}", name);
         }
-        EVENT::PLAYER_DIED(str) => {
+        EVENT::PlayerDied(str) => {
             // Generating the String is handled in the death effect, to avoid passing the ecs here.
             new_event = format!("{}", str);
         }

src/inventory/identification_system.rs

@@ -1,4 +1,13 @@
-use crate::{ Beatitude, IdentifiedBeatitude, IdentifiedItem, Item, MasterDungeonMap, Name, ObfuscatedName, Player };
+use crate::{
+    Beatitude,
+    IdentifiedBeatitude,
+    IdentifiedItem,
+    Item,
+    MasterDungeonMap,
+    Name,
+    ObfuscatedName,
+    Player,
+};
 use specs::prelude::*;
 use crate::data::events::*;
 use crate::gamelog;
@@ -35,7 +44,7 @@ impl<'a> System<'a> for ItemIdentificationSystem {
             let tag = crate::raws::get_id_from_name(id.name.clone());
             if !dm.identified_items.contains(&id.name) && crate::raws::is_tag_magic(&tag) {
                 if gamelog::get_event_count(EVENT::COUNT_TURN) != 1 {
-                    gamelog::record_event(EVENT::IDENTIFIED(id.name.clone()));
+                    gamelog::record_event(EVENT::Identified(id.name.clone()));
                 }
                 dm.identified_items.insert(id.name.clone());
                 for (entity, _item, name) in (&entities, &items, &names).join() {

src/main.rs

@@ -129,7 +129,7 @@ fn main() -> BError {
     gs.ecs.insert(rex_assets::RexAssets::new());
 
     gamelog::setup_log();
-    gamelog::record_event(data::events::EVENT::LEVEL(1));
+    gamelog::record_event(data::events::EVENT::Level(1));
     gs.generate_world_map(1, TileType::Floor);
 
     main_loop(context, gs)

src/map_builders/area_starting_points.rs

@@ -1,6 +1,5 @@
 use super::{ BuilderMap, MetaMapBuilder, Position };
 use bracket_lib::prelude::*;
-use bracket_lib::prelude::*;
 
 #[allow(dead_code)]
 pub enum XStart {

src/map_builders/mod.rs

@@ -70,7 +70,7 @@ use forest::forest_builder;
 mod foliage;
 use foliage::Foliage;
 mod room_themer;
-use room_themer::{ Theme, ThemeRooms };
+use room_themer::ThemeRooms;
 
 // Shared data to be passed around build chain
 pub struct BuilderMap {

src/player.rs

@@ -350,7 +350,7 @@ pub fn kick(i: i32, j: i32, ecs: &mut World) -> RunState {
                                         destroyed_pos = Some(
                                             Point::new(pos.x + delta_x, pos.y + delta_y)
                                         );
-                                        gamelog::record_event(EVENT::BROKE_DOOR(1));
+                                        gamelog::record_event(EVENT::BrokeDoor(1));
                                         return false;
                                         // 66% chance of just kicking it.
                                     } else {
@@ -414,7 +414,7 @@ pub fn kick(i: i32, j: i32, ecs: &mut World) -> RunState {
         ecs.delete_entity(destroyed_thing).expect("Unable to delete.");
     }
 
-    gamelog::record_event(EVENT::KICKED_SOMETHING(1));
+    gamelog::record_event(EVENT::KickedSomething(1));
     return RunState::Ticking;
 }
 

src/states/state.rs

@@ -128,7 +128,7 @@ impl State {
             .colour(WHITE)
             .period()
             .log();
-        gamelog::record_event(EVENT::CHANGED_FLOOR(mapname));
+        gamelog::record_event(EVENT::ChangedFloor(mapname));
     }
 
     fn game_over_cleanup(&mut self) {
@@ -152,7 +152,7 @@ impl State {
         self.generate_world_map(1, TileType::Floor);
 
         gamelog::setup_log();
-        gamelog::record_event(EVENT::LEVEL(1));
+        gamelog::record_event(EVENT::Level(1));
     }
 }
 
@@ -513,7 +513,7 @@ impl GameState for State {
                 let result = gui::show_help(ctx);
                 match result {
                     gui::YesNoResult::Yes => {
-                        gamelog::record_event(EVENT::LOOKED_FOR_HELP(1));
+                        gamelog::record_event(EVENT::LookedForHelp(1));
                         new_runstate = RunState::AwaitingInput;
                     }
                     _ => {}