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

sorry - swapping from rustfmt to prettier-rust

Browse source
This commit is contained in:
Llywelwyn 2023-08-23 01:22:09 +01:00
parent 281396f9ce
commit c2c7e0bd52
93 changed files with 2797 additions and 2021 deletions
Download patch file Download diff file Expand all files Collapse all files

42
src/effects/damage.rs
View file

@ -1,8 +1,15 @@
use super::{add_effect, 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},
Attributes, Confusion, Destructible, GrantsXP, Map, Player, Pools, DEFAULT_PARTICLE_LIFETIME,
gamesystem::{ hp_per_level, mana_per_level },
Attributes,
Confusion,
Destructible,
GrantsXP,
Map,
Player,
Pools,
DEFAULT_PARTICLE_LIFETIME,
LONG_PARTICLE_LIFETIME,
};
use rltk::prelude::*;
@ -24,7 +31,7 @@ pub fn inflict_damage(ecs: &mut World, damage: &EffectSpawner, target: Entity) {
lifespan: DEFAULT_PARTICLE_LIFETIME,
delay: 0.0,
},
Targets::Entity { target },
Targets::Entity { target }
);
if target_pool.hit_points.current < 1 {
super::DEAD_ENTITIES.lock().unwrap().push_back(target);
@ -57,7 +64,7 @@ pub fn heal_damage(ecs: &mut World, heal: &EffectSpawner, target: Entity) {
lifespan: DEFAULT_PARTICLE_LIFETIME,
delay: 0.0,
},
Targets::Entity { target },
Targets::Entity { target }
);
}
}
@ -98,7 +105,7 @@ pub fn bloodstain(ecs: &mut World, target: usize) {
// - If we're in bounds and the tile is unbloodied, bloody it and return.
// - If we ever leave bounds, return.
// - Roll a dice on each failed attempt, with an increasing change to return (soft-capping max spread)
if spread > 0 && spread < (map.height * map.width) {
if spread > 0 && spread < map.height * map.width {
if !map.bloodstains.contains(&(spread as usize)) {
map.bloodstains.insert(spread as usize);
return;
@ -117,9 +124,9 @@ fn get_next_level_requirement(level: i32) -> i32 {
if level == 0 {
return 5;
} else if level < 10 {
return 20 * 2_i32.pow(level as u32 - 1);
return 20 * (2_i32).pow((level as u32) - 1);
} else if level < 20 {
return 10000 * 2_i32.pow(level as u32 - 10);
return 10000 * (2_i32).pow((level as u32) - 10);
} else if level < 30 {
return 10000000 * (level - 19);
}
@ -155,7 +162,8 @@ pub fn entity_death(ecs: &mut World, effect: &EffectSpawner, target: Entity) {
// If it was the PLAYER that levelled up:
if ecs.read_storage::<Player>().get(source).is_some() {
gamelog::record_event("player_level", 1);
gamelog::Logger::new()
gamelog::Logger
::new()
.append("Welcome to experience level")
.append(source_pools.level)
.append(".")
@ -171,9 +179,9 @@ pub fn entity_death(ecs: &mut World, effect: &EffectSpawner, target: Entity) {
fg: RGB::named(GOLD),
bg: RGB::named(BLACK),
lifespan: LONG_PARTICLE_LIFETIME,
delay: i as f32 * 100.0,
delay: (i as f32) * 100.0,
},
Targets::Tile { target: map.xy_idx(player_pos.x, player_pos.y - i) },
Targets::Tile { target: map.xy_idx(player_pos.x, player_pos.y - i) }
);
if i > 2 {
add_effect(
@ -183,9 +191,9 @@ pub fn entity_death(ecs: &mut World, effect: &EffectSpawner, target: Entity) {
fg: RGB::named(GOLD),
bg: RGB::named(BLACK),
lifespan: LONG_PARTICLE_LIFETIME,
delay: i as f32 * 100.0,
delay: (i as f32) * 100.0,
},
Targets::Tile { target: map.xy_idx(player_pos.x + (i - 2), player_pos.y - i) },
Targets::Tile { target: map.xy_idx(player_pos.x + (i - 2), player_pos.y - i) }
);
add_effect(
None,
@ -194,9 +202,9 @@ pub fn entity_death(ecs: &mut World, effect: &EffectSpawner, target: Entity) {
fg: RGB::named(GOLD),
bg: RGB::named(BLACK),
lifespan: LONG_PARTICLE_LIFETIME,
delay: i as f32 * 100.0,
delay: (i as f32) * 100.0,
},
Targets::Tile { target: map.xy_idx(player_pos.x - (i - 2), player_pos.y - i) },
Targets::Tile { target: map.xy_idx(player_pos.x - (i - 2), player_pos.y - i) }
);
}
}
@ -208,11 +216,11 @@ pub fn entity_death(ecs: &mut World, effect: &EffectSpawner, target: Entity) {
let mut rng = ecs.write_resource::<RandomNumberGenerator>();
let hp_gained = hp_per_level(
&mut rng,
source_attributes.constitution.base + source_attributes.constitution.modifiers,
source_attributes.constitution.base + source_attributes.constitution.modifiers
);
let mana_gained = mana_per_level(
&mut rng,
source_attributes.intelligence.base + source_attributes.intelligence.modifiers,
source_attributes.intelligence.base + source_attributes.intelligence.modifiers
);
source_pools.hit_points.max += hp_gained;
source_pools.hit_points.current += hp_gained;

2
src/effects/hunger.rs
View file

@ -1,4 +1,4 @@
use super::{EffectSpawner, EffectType};
use super::{ EffectSpawner, EffectType };
use crate::HungerClock;
use specs::prelude::*;

59
src/effects/mod.rs
View file

@ -23,24 +23,51 @@ lazy_static! {
}
pub enum EffectType {
Damage { amount: i32 },
Healing { amount: i32, increment_max: bool },
Confusion { turns: i32 },
Damage {
amount: i32,
},
Healing {
amount: i32,
increment_max: bool,
},
Confusion {
turns: i32,
},
Bloodstain,
Particle { glyph: FontCharType, fg: RGB, bg: RGB, lifespan: f32, delay: f32 },
Particle {
glyph: FontCharType,
fg: RGB,
bg: RGB,
lifespan: f32,
delay: f32,
},
EntityDeath,
ItemUse { item: Entity },
ModifyNutrition { amount: i32 },
TriggerFire { trigger: Entity },
ItemUse {
item: Entity,
},
ModifyNutrition {
amount: i32,
},
TriggerFire {
trigger: Entity,
},
}
#[derive(Clone)]
#[allow(dead_code)]
pub enum Targets {
Entity { target: Entity },
EntityList { targets: Vec<Entity> },
Tile { target: usize },
TileList { targets: Vec<usize> },
Entity {
target: Entity,
},
EntityList {
targets: Vec<Entity>,
},
Tile {
target: usize,
},
TileList {
targets: Vec<usize>,
},
}
pub struct EffectSpawner {
@ -61,7 +88,9 @@ pub fn run_effects_queue(ecs: &mut World) {
loop {
let dead_entity: Option<Entity> = DEAD_ENTITIES.lock().unwrap().pop_front();
if let Some(dead_entity) = dead_entity {
EFFECT_QUEUE.lock().unwrap().retain(|x| x.source != Some(dead_entity));
EFFECT_QUEUE.lock()
.unwrap()
.retain(|x| x.source != Some(dead_entity));
} else {
break;
}
@ -147,9 +176,5 @@ fn affect_entity(ecs: &mut World, effect: &EffectSpawner, target: Entity) {
}
pub fn get_noncursed(buc: &BUC) -> bool {
if buc == &BUC::Cursed {
false
} else {
true
}
if buc == &BUC::Cursed { false } else { true }
}

55
src/effects/particles.rs
View file

@ -1,5 +1,5 @@
use super::{add_effect, targeting, EffectSpawner, EffectType, Targets};
use crate::{Map, ParticleBuilder, SpawnParticleBurst, SpawnParticleLine, SpawnParticleSimple};
use super::{ add_effect, targeting, EffectSpawner, EffectType, Targets };
use crate::{ Map, ParticleBuilder, SpawnParticleBurst, SpawnParticleLine, SpawnParticleSimple };
use rltk::prelude::*;
use specs::prelude::*;
@ -26,7 +26,7 @@ pub fn handle_simple_particles(ecs: &World, entity: Entity, target: &Targets) {
lifespan: part.lifetime_ms,
delay: 0.0,
},
target.clone(),
target.clone()
);
}
}
@ -39,33 +39,33 @@ pub fn handle_burst_particles(ecs: &World, entity: Entity, target: &Targets) {
ecs,
start_pos,
end_pos,
&SpawnParticleLine {
&(SpawnParticleLine {
glyph: part.head_glyph,
tail_glyph: part.tail_glyph,
colour: part.colour,
trail_colour: part.trail_colour,
lifetime_ms: part.trail_lifetime_ms, // 75.0 is good here.
trail_lifetime_ms: part.trail_lifetime_ms,
},
})
);
let map = ecs.fetch::<Map>();
let line = line2d(
LineAlg::Bresenham,
Point::new(start_pos % map.width, start_pos / map.width),
Point::new(end_pos % map.width, end_pos / map.width),
Point::new(end_pos % map.width, end_pos / map.width)
);
let burst_delay = line.len() as f32 * part.trail_lifetime_ms;
let burst_delay = (line.len() as f32) * part.trail_lifetime_ms;
for i in 0..10 {
add_effect(
None,
EffectType::Particle {
glyph: part.glyph,
fg: part.colour.lerp(part.lerp, i as f32 * 0.1),
fg: part.colour.lerp(part.lerp, (i as f32) * 0.1),
bg: RGB::named(BLACK),
lifespan: part.lifetime_ms / 10.0, // ~50-80 is good here.
delay: burst_delay + (i as f32 * part.lifetime_ms / 10.0), // above + burst_delay
delay: burst_delay + ((i as f32) * part.lifetime_ms) / 10.0, // above + burst_delay
},
target.clone(),
target.clone()
);
}
}
@ -74,27 +74,31 @@ pub fn handle_burst_particles(ecs: &World, entity: Entity, target: &Targets) {
fn get_centre(ecs: &World, target: &Targets) -> i32 {
match target {
Targets::Tile { target } => return *target as i32,
Targets::Tile { target } => {
return *target as i32;
}
Targets::TileList { targets } => {
let map = ecs.fetch::<Map>();
let (mut count, mut sum_x, mut sum_y) = (0, 0, 0);
for target in targets {
sum_x += *target as i32 % map.width;
sum_y += *target as i32 / map.width;
sum_x += (*target as i32) % map.width;
sum_y += (*target as i32) / map.width;
count += 1;
}
let (mean_x, mean_y) = (sum_x / count, sum_y / count);
let centre = map.xy_idx(mean_x, mean_y);
return centre as i32;
}
Targets::Entity { target } => return targeting::entity_position(ecs, *target).unwrap() as i32,
Targets::Entity { target } => {
return targeting::entity_position(ecs, *target).unwrap() as i32;
}
Targets::EntityList { targets } => {
let map = ecs.fetch::<Map>();
let (mut count, mut sum_x, mut sum_y) = (0, 0, 0);
for target in targets {
if let Some(pos) = targeting::entity_position(ecs, *target) {
sum_x += pos as i32 % map.width;
sum_y += pos as i32 / map.width;
sum_x += (pos as i32) % map.width;
sum_y += (pos as i32) / map.width;
count += 1;
}
}
@ -118,11 +122,12 @@ pub fn handle_line_particles(ecs: &World, entity: Entity, target: &Targets) {
spawn_line_particles(ecs, start_pos, end_pos as i32, part);
}
}
Targets::EntityList { targets } => targets.iter().for_each(|target| {
if let Some(end_pos) = targeting::entity_position(ecs, *target) {
spawn_line_particles(ecs, start_pos, end_pos as i32, part);
}
}),
Targets::EntityList { targets } =>
targets.iter().for_each(|target| {
if let Some(end_pos) = targeting::entity_position(ecs, *target) {
spawn_line_particles(ecs, start_pos, end_pos as i32, part);
}
}),
}
}
}
@ -141,9 +146,9 @@ fn spawn_line_particles(ecs: &World, start: i32, end: i32, part: &SpawnParticleL
fg: part.colour,
bg: RGB::named(BLACK),
lifespan: part.lifetime_ms,
delay: i as f32 * part.lifetime_ms,
delay: (i as f32) * part.lifetime_ms,
},
Targets::Tile { target: map.xy_idx(pt.x, pt.y) },
Targets::Tile { target: map.xy_idx(pt.x, pt.y) }
);
if i > 0 {
add_effect(
@ -153,9 +158,9 @@ fn spawn_line_particles(ecs: &World, start: i32, end: i32, part: &SpawnParticleL
fg: part.trail_colour,
bg: RGB::named(BLACK),
lifespan: part.trail_lifetime_ms,
delay: i as f32 * part.lifetime_ms,
delay: (i as f32) * part.lifetime_ms,
},
Targets::Tile { target: map.xy_idx(line[i - 1].x, line[i - 1].y) },
Targets::Tile { target: map.xy_idx(line[i - 1].x, line[i - 1].y) }
);
}
}

2
src/effects/targeting.rs
View file

@ -1,4 +1,4 @@
use crate::{Equipped, InBackpack, Map, Position};
use crate::{ Equipped, InBackpack, Map, Position };
use rltk::prelude::*;
use specs::prelude::*;

61
src/effects/triggers.rs
View file

@ -1,9 +1,34 @@
use super::{add_effect, get_noncursed, messages::*, particles, spatial, EffectType, Entity, Targets, World};
use super::{ add_effect, get_noncursed, messages::*, particles, spatial, EffectType, Entity, Targets, World };
use crate::{
gamelog, gui::item_colour_ecs, gui::obfuscate_name_ecs, gui::renderable_colour, Beatitude, Charges, Confusion,
Consumable, Destructible, Equipped, Hidden, InBackpack, InflictsDamage, Item, MagicMapper, MasterDungeonMap, Name,
ObfuscatedName, Player, Prop, ProvidesHealing, ProvidesIdentify, ProvidesNutrition, ProvidesRemoveCurse,
RandomNumberGenerator, Renderable, RunState, SingleActivation, BUC,
gamelog,
gui::item_colour_ecs,
gui::obfuscate_name_ecs,
gui::renderable_colour,
Beatitude,
Charges,
Confusion,
Consumable,
Destructible,
Equipped,
Hidden,
InBackpack,
InflictsDamage,
Item,
MagicMapper,
MasterDungeonMap,
Name,
ObfuscatedName,
Player,
Prop,
ProvidesHealing,
ProvidesIdentify,
ProvidesNutrition,
ProvidesRemoveCurse,
RandomNumberGenerator,
Renderable,
RunState,
SingleActivation,
BUC,
};
use rltk::prelude::*;
use specs::prelude::*;
@ -85,7 +110,7 @@ fn event_trigger(source: Option<Entity>, entity: Entity, target: &Targets, ecs:
fn handle_restore_nutrition(
ecs: &mut World,
event: &mut EventInfo,
mut logger: gamelog::Logger,
mut logger: gamelog::Logger
) -> (gamelog::Logger, bool) {
if ecs.read_storage::<ProvidesNutrition>().get(event.entity).is_some() {
let amount = match event.buc {
@ -131,7 +156,7 @@ fn handle_healing(ecs: &mut World, event: &mut EventInfo, mut logger: gamelog::L
add_effect(
event.source,
EffectType::Healing { amount: roll, increment_max: get_noncursed(&event.buc) },
event.target.clone(),
event.target.clone()
);
for target in get_entity_targets(&event.target) {
if ecs.read_storage::<Prop>().get(target).is_some() || ecs.read_storage::<Item>().get(target).is_some() {
@ -238,11 +263,13 @@ fn handle_identify(ecs: &mut World, event: &mut EventInfo, mut logger: gamelog::
)
.join()
.filter(|(_e, _i, bp, _o, name)| {
bp.owner == event.source.unwrap()
&& (!dm.identified_items.contains(&name.name.clone())
|| !beatitudes.get(event.source.unwrap()).map(|beatitude| beatitude.known).unwrap_or(true))
})
{
bp.owner == event.source.unwrap() &&
(!dm.identified_items.contains(&name.name.clone()) ||
!beatitudes
.get(event.source.unwrap())
.map(|beatitude| beatitude.known)
.unwrap_or(true))
}) {
to_identify.push((e, name.name.clone()));
}
for item in to_identify {
@ -276,8 +303,7 @@ fn handle_remove_curse(ecs: &mut World, event: &mut EventInfo, mut logger: gamel
&ecs.read_storage::<Beatitude>(),
)
.join()
.filter(|(_e, _i, bp, b)| bp.owner == event.source.unwrap() && b.buc == BUC::Cursed)
{
.filter(|(_e, _i, bp, b)| bp.owner == event.source.unwrap() && b.buc == BUC::Cursed) {
to_decurse.push(entity);
}
}
@ -291,14 +317,15 @@ fn handle_remove_curse(ecs: &mut World, event: &mut EventInfo, mut logger: gamel
&ecs.read_storage::<Beatitude>(),
)
.join()
.filter(|(_e, _i, e, b)| e.owner == event.source.unwrap() && b.buc == BUC::Cursed)
{
.filter(|(_e, _i, e, b)| e.owner == event.source.unwrap() && b.buc == BUC::Cursed) {
to_decurse.push(entity);
}
if to_decurse.len() == 0 {
match event.buc {
BUC::Uncursed => select_single(ecs, RunState::ShowRemoveCurse),
BUC::Blessed => logger = logger.append(REMOVECURSE_BLESSED_FAILED),
BUC::Blessed => {
logger = logger.append(REMOVECURSE_BLESSED_FAILED);
}
_ => {}
}
return (logger, true);