roguelike-game/src/melee_combat_system.rs

212 lines
8.2 KiB
Rust
Raw Normal View History

use ::rltk::{RandomNumberGenerator, RGB};
2021-12-24 10:38:44 -05:00
use ::specs::prelude::*;
2021-12-10 20:16:48 -05:00
use crate::components::{
2022-01-04 11:11:38 -05:00
Attributes, Equipped, HungerClock, HungerState, MeleeWeapon, Name, Pools, Skill, Skills,
SufferDamage, WantsToMelee, Wearable,
};
2021-12-10 20:16:48 -05:00
use crate::game_log::GameLog;
use crate::gamesystem::skill_bonus;
2021-12-10 20:16:48 -05:00
use crate::particle_system::ParticleBuilder;
use crate::{EquipmentSlot, NaturalAttackDefense, Position, WeaponAttribute};
2021-10-29 15:15:22 -04:00
pub struct MeleeCombatSystem {}
impl<'a> System<'a> for MeleeCombatSystem {
#[allow(clippy::type_complexity)]
2021-10-29 15:15:22 -04:00
type SystemData = (
Entities<'a>,
WriteExpect<'a, GameLog>,
2021-10-29 15:15:22 -04:00
WriteStorage<'a, WantsToMelee>,
ReadStorage<'a, Name>,
ReadStorage<'a, Attributes>,
ReadStorage<'a, Skills>,
2021-10-29 15:15:22 -04:00
WriteStorage<'a, SufferDamage>,
2021-11-16 11:33:58 -05:00
WriteExpect<'a, ParticleBuilder>,
ReadStorage<'a, Position>,
2021-11-19 11:31:27 -05:00
ReadStorage<'a, HungerClock>,
ReadStorage<'a, Pools>,
WriteExpect<'a, RandomNumberGenerator>,
2022-01-04 11:11:38 -05:00
ReadStorage<'a, Equipped>,
ReadStorage<'a, MeleeWeapon>,
ReadStorage<'a, Wearable>,
ReadStorage<'a, NaturalAttackDefense>,
2021-10-29 15:15:22 -04:00
);
fn run(&mut self, data: Self::SystemData) {
let (
entities,
mut log,
mut wants_melee,
names,
attributes,
skills,
mut inflict_damage,
2021-11-16 11:33:58 -05:00
mut particle_builder,
positions,
2021-11-19 11:31:27 -05:00
hunger_clock,
pools,
mut rng,
2022-01-04 11:11:38 -05:00
equipped_items,
meleeweapons,
wearables,
natural,
) = data;
2021-10-29 15:15:22 -04:00
for (entity, wants_melee, name, attacker_attributes, attacker_skills, attacker_pools) in (
&entities,
&wants_melee,
&names,
&attributes,
&skills,
&pools,
)
.join()
2021-10-29 15:15:22 -04:00
{
// Are the attacker and defender alive? Only attack if they are
let target_pools = pools.get(wants_melee.target).unwrap();
let target_attributes = attributes.get(wants_melee.target).unwrap();
let target_skills = skills.get(wants_melee.target).unwrap();
if attacker_pools.hit_points.current > 0 && target_pools.hit_points.current > 0 {
let target_name = names.get(wants_melee.target).unwrap();
2022-01-04 11:11:38 -05:00
let mut weapon_info = MeleeWeapon {
attribute: WeaponAttribute::Might,
hit_bonus: 0,
damage_n_dice: 1,
damage_die_type: 4,
damage_bonus: 0,
};
if let Some(nat) = natural.get(entity) {
if !nat.attacks.is_empty() {
let attack_index = if nat.attacks.len() == 1 {
0
} else {
rng.roll_dice(1, nat.attacks.len() as i32) as usize - 1
};
let attk = &nat.attacks[attack_index];
weapon_info.hit_bonus = attk.hit_bonus;
weapon_info.damage_n_dice = attk.damage_n_dice;
weapon_info.damage_die_type = attk.damage_die_type;
weapon_info.damage_bonus = attk.damage_bonus;
}
}
2022-01-04 11:11:38 -05:00
for (wielded, melee) in (&equipped_items, &meleeweapons).join() {
if wielded.owner == entity && wielded.slot == EquipmentSlot::Melee {
weapon_info = melee.clone();
}
}
let natural_roll = rng.roll_dice(1, 20);
2022-01-04 11:11:38 -05:00
let attribute_hit_bonus = if weapon_info.attribute == WeaponAttribute::Might {
attacker_attributes.might.bonus
} else {
attacker_attributes.quickness.bonus
};
let skill_hit_bonus = skill_bonus(Skill::Melee, &*attacker_skills);
2022-01-04 11:11:38 -05:00
let weapon_hit_bonus = weapon_info.hit_bonus;
let mut status_hit_bonus = 0;
2021-11-19 11:31:27 -05:00
if let Some(hc) = hunger_clock.get(entity) {
// Well-Fed grants +1
2021-11-19 11:31:27 -05:00
if hc.state == HungerState::WellFed {
status_hit_bonus += 1;
2021-11-19 11:31:27 -05:00
}
}
let modified_hit_roll = natural_roll
+ attribute_hit_bonus
+ skill_hit_bonus
+ weapon_hit_bonus
+ status_hit_bonus;
2021-11-19 11:31:27 -05:00
2022-01-04 11:11:38 -05:00
let mut armor_item_bonus_f = 0.0;
for (wielded, armor) in (&equipped_items, &wearables).join() {
if wielded.owner == wants_melee.target {
armor_item_bonus_f += armor.armor_class;
}
}
let base_armor_class = match natural.get(wants_melee.target) {
None => 10,
Some(nat) => nat.armor_class.unwrap_or(10),
};
let armor_quickness_bonus = target_attributes.quickness.bonus;
let armor_skill_bonus = skill_bonus(Skill::Defense, &*target_skills);
2022-01-04 11:11:38 -05:00
let armor_item_bonus = armor_item_bonus_f as i32;
let armor_class =
base_armor_class + armor_quickness_bonus + armor_skill_bonus + armor_item_bonus;
if natural_roll != 1 && (natural_roll == 20 || modified_hit_roll > armor_class) {
// Target hit! Until we support weapons, we're going with 1d4
let base_damage = rng.roll_dice(1, 4);
let attr_damage_bonus = attacker_attributes.might.bonus;
let skill_damage_bonus = skill_bonus(Skill::Melee, &*attacker_skills);
2022-01-04 11:11:38 -05:00
let weapon_damage_bonus = weapon_info.damage_bonus;
let damage = i32::max(
0,
base_damage
+ attr_damage_bonus
+ skill_hit_bonus
+ skill_damage_bonus
+ weapon_damage_bonus,
);
SufferDamage::new_damage(&mut inflict_damage, wants_melee.target, damage);
log.append(format!(
"{} hits {} for {} hp.",
&name.name, &target_name.name, damage
));
2021-11-16 11:33:58 -05:00
if let Some(pos) = positions.get(wants_melee.target) {
particle_builder.request(
pos.x,
pos.y,
RGB::named(rltk::ORANGE),
RGB::named(rltk::BLACK),
rltk::to_cp437('‼'),
200.0,
);
}
} else if natural_roll == 1 {
// Natural 1 miss
log.append(format!(
"{} considers attacking {}, but misjudges the timing.",
name.name, target_name.name
));
if let Some(pos) = positions.get(wants_melee.target) {
particle_builder.request(
pos.x,
pos.y,
RGB::named(rltk::BLUE),
RGB::named(rltk::BLACK),
rltk::to_cp437('‼'),
200.0,
);
}
} else {
// Miss
log.append(format!(
"{} attacks {}, but can't connect",
name.name, target_name.name
));
if let Some(pos) = positions.get(wants_melee.target) {
particle_builder.request(
pos.x,
pos.y,
RGB::named(rltk::CYAN),
RGB::named(rltk::BLACK),
rltk::to_cp437('‼'),
200.0,
);
2021-10-29 15:15:22 -04:00
}
}
}
}
wants_melee.clear();
}
}