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

deletes deprecated damage system

Browse source
This commit is contained in:
Llywelwyn 2023-08-17 05:42:19 +01:00
parent ff1afed92c
commit 945242bc42
5 changed files with 20 additions and 116 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/ai/turn_status_system.rs
View file

@ -35,7 +35,6 @@ impl<'a> System<'a> for TurnStatusSystem {
let mut not_my_turn: Vec<Entity> = Vec::new();
let mut not_confused: Vec<Entity> = Vec::new();
for (entity, _turn, confused, name) in (&entities, &mut turns, &mut confusion, &names).join() {
log = true;
confused.turns -= 1;
if confused.turns < 1 {
not_confused.push(entity);
@ -45,6 +44,7 @@ impl<'a> System<'a> for TurnStatusSystem {
.append(&name.name)
.colour(WHITE)
.append("snap out of it.");
log = true;
} else {
logger = logger
.append("The")
@ -52,6 +52,7 @@ impl<'a> System<'a> for TurnStatusSystem {
.append(&name.name)
.colour(WHITE)
.append("snaps out of it.");
log = true;
}
add_effect(
None,
@ -72,6 +73,8 @@ impl<'a> System<'a> for TurnStatusSystem {
.append(&name.name)
.colour(WHITE)
.append("are confused!");
log = true;
gamelog::record_event("player_confused", 1);
} else {
logger = logger
.append("The")
@ -79,6 +82,7 @@ impl<'a> System<'a> for TurnStatusSystem {
.append(&name.name)
.colour(WHITE)
.append("is confused!");
log = true;
}
add_effect(
None,

112
src/damage_system.rs
View file

@ -6,118 +6,6 @@ use crate::gamesystem::{hp_per_level, mana_per_level};
use rltk::prelude::*;
use specs::prelude::*;
pub struct DamageSystem {}
impl<'a> System<'a> for DamageSystem {
#[allow(clippy::type_complexity)]
type SystemData = (
WriteStorage<'a, Pools>,
WriteStorage<'a, SufferDamage>,
ReadStorage<'a, Position>,
WriteExpect<'a, Map>,
Entities<'a>,
ReadExpect<'a, Entity>,
ReadStorage<'a, Attributes>,
WriteExpect<'a, rltk::RandomNumberGenerator>,
ReadStorage<'a, GrantsXP>,
WriteExpect<'a, ParticleBuilder>,
ReadExpect<'a, rltk::Point>,
);
fn run(&mut self, data: Self::SystemData) {
let (
mut stats,
mut damage,
positions,
mut map,
entities,
player,
attributes,
mut rng,
xp_granters,
mut particle_builder,
player_pos,
) = data;
let mut xp_gain = 0;
for (entity, mut stats, damage) in (&entities, &mut stats, &damage).join() {
for dmg in damage.amount.iter() {
if !stats.god {
stats.hit_points.current -= dmg.0;
}
let pos = positions.get(entity);
if let Some(pos) = pos {
let idx = map.xy_idx(pos.x, pos.y);
map.bloodstains.insert(idx);
}
if stats.hit_points.current < 1 && dmg.1 {
let gives_xp = xp_granters.get(entity);
if let Some(xp_value) = gives_xp {
xp_gain += xp_value.amount;
}
if let Some(pos) = pos {
let idx = map.xy_idx(pos.x, pos.y);
crate::spatial::remove_entity(entity, idx);
}
}
}
}
if xp_gain != 0 {
let mut player_stats = stats.get_mut(*player).unwrap();
let player_attributes = attributes.get(*player).unwrap();
player_stats.xp += xp_gain;
let mut next_level_requirement = -1;
if player_stats.level < 10 {
next_level_requirement = 20 * 2_i32.pow(player_stats.level as u32 - 1);
} else if player_stats.level < 20 {
next_level_requirement = 10000 * 2_i32.pow(player_stats.level as u32 - 10);
} else if player_stats.level < 30 {
next_level_requirement = 10000000 * (player_stats.level - 19);
}
if next_level_requirement != -1 && player_stats.xp >= next_level_requirement {
// We've gone up a level!
player_stats.level += 1;
gamelog::record_event("player_level", 1);
gamelog::Logger::new()
.append("Welcome to experience level")
.append(player_stats.level)
.append(".")
.log();
for i in 0..5 {
if player_pos.y - i > 1 {
particle_builder.request(
player_pos.x,
player_pos.y - i,
rltk::RGB::named(rltk::GOLD),
rltk::RGB::named(rltk::BLACK),
rltk::to_cp437('*'),
200.0,
);
}
}
// Roll for HP gain this level
let hp_gained = hp_per_level(
&mut rng,
player_attributes.constitution.base + player_attributes.constitution.modifiers,
);
player_stats.hit_points.max += hp_gained;
player_stats.hit_points.current += hp_gained;
// Roll for MANA gain this level
let mana_gained = mana_per_level(
&mut rng,
player_attributes.intelligence.base + player_attributes.intelligence.modifiers,
);
player_stats.mana.max += mana_gained;
player_stats.mana.current += mana_gained;
}
}
// Clear the queue
damage.clear();
}
}
pub fn delete_the_dead(ecs: &mut World) {
let mut dead: Vec<Entity> = Vec::new();
// Using scope to make borrow checker happy

9
src/gamelog/logstore.rs
View file

@ -33,7 +33,11 @@ pub fn print_log(console: &mut Box<dyn Console>, pos: Point, _descending: bool,
log.iter().for_each(|frag| {
entry_len += frag.text.len() as i32;
});
let lines = entry_len / maximum_len;
// I don't know why the +1 is required, or why there were issues on what seemed to be
// specified a value of 68. I'm pretty sure it's a ""rounding error"" between this method
// of determining max lines and how the iterator actually counts the characters. Regardless,
// this seems to work. -- NOTE IN CASE THIS ISSUE COMES BACK? HARD TO REPRODUCE!
let lines = entry_len / (maximum_len + 1);
// If the fragment is more than one line long, move our y-value up
// by this much.
y -= lines;
@ -47,6 +51,9 @@ pub fn print_log(console: &mut Box<dyn Console>, pos: Point, _descending: bool,
// and reset our length counter to 0.
for part in parts {
if len_so_far + part.len() as i32 > maximum_len {
if y > pos.y - len as i32 {
console.print(x, y, "-");
}
y += 1;
x = pos.x;
len_so_far = 0;

2
src/main.rs
View file

@ -92,7 +92,6 @@ impl State {
let mut vis = VisibilitySystem {};
let mut trigger_system = trigger_system::TriggerSystem {};
let mut melee_system = MeleeCombatSystem {};
let mut damage_system = DamageSystem {};
let mut inventory_system = inventory::ItemCollectionSystem {};
let mut item_equip_system = inventory::ItemEquipSystem {};
let mut item_use_system = inventory::ItemUseSystem {};
@ -113,7 +112,6 @@ impl State {
item_remove_system.run_now(&self.ecs);
item_id_system.run_now(&self.ecs);
melee_system.run_now(&self.ecs);
damage_system.run_now(&self.ecs);
effects::run_effects_queue(&mut self.ecs);
hunger_clock.run_now(&self.ecs);
particle_system.run_now(&self.ecs);

7
src/spawner.rs
View file

@ -91,6 +91,13 @@ pub fn player(ecs: &mut World, player_x: i32, player_y: i32) -> Entity {
raws::SpawnType::Carried { by: player },
0,
);
raws::spawn_named_entity(
&raws::RAWS.lock().unwrap(),
ecs,
"scroll_mass_confusion",
raws::SpawnType::Carried { by: player },
0,
);
return player;
}