lew/rust-rl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

cleans up linter warns

Browse source
This commit is contained in:
Llywelwyn 2023-09-18 21:54:18 +01:00
parent 6d80b80a82
commit 27c1fe9a48
14 changed files with 71 additions and 64 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/ai/energy_system.rs
View file

@ -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(

2
src/ai/turn_status_system.rs
View file

@ -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")

2
src/damage_system.rs
View file

@ -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.");
}
}

28
src/data/events.rs
View file

@ -2,17 +2,17 @@ use serde::{ Deserialize, Serialize };
#[derive(Serialize, Deserialize, Clone)]
pub enum EVENT {
TURN(i32),
LEVEL(i32),
CHANGED_FLOOR(String),
PLAYER_CONFUSED(i32),
KICKED_SOMETHING(i32),
BROKE_DOOR(i32),
LOOKED_FOR_HELP(i32),
KILLED(String),
PLAYER_DIED(String),
DISCOVERED(String),
IDENTIFIED(String),
Turn(i32),
Level(i32),
ChangedFloor(String),
PlayerConfused(i32),
KickedSomething(i32),
BrokeDoor(i32),
LookedForHelp(i32),
Killed(String),
PlayerDied(String),
Discovered(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_PLAYER_CONFUSED: &str = "player_confused";
pub const COUNT_BROKE_DOOR: &str = "BrokeDoor";
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";
}

16
src/data/messages.rs
View file

@ -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!";
/// Death message specifiers. Appended after PLAYER_DIED.
pub const PLAYER_DIED_SUICIDE: &str = "You killed yourself";
pub const PLAYER_DIED_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: &str = "You died!";
/// Death message specifiers. Appended after PlayerDied.
pub const PlayerDied_SUICIDE: &str = "You killed yourself";
pub const PlayerDied_NAMED_ATTACKER: &str = "You were killed by";
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 PLAYER_DIED_ADDENDUM_MID: &str = ", ";
pub const PLAYER_DIED_ADDENDUM_LAST: &str = ", and ";
pub const PlayerDied_ADDENDUM_FIRST: &str = " ";
pub const PlayerDied_ADDENDUM_MID: &str = ", ";
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."

24
src/effects/damage.rs
View file

@ -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())
);
}
}

11
src/effects/triggers.rs
View file

@ -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()));
}

22
src/gamelog/events.rs
View file

@ -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);
}

13
src/inventory/identification_system.rs
View file

@ -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() {

2
src/main.rs
View file

@ -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)

1
src/map_builders/area_starting_points.rs
View file

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

2
src/map_builders/mod.rs
View file

@ -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 {

4
src/player.rs
View file

@ -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;
}

6
src/states/state.rs
View file

@ -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;
}
_ => {}