1080 lines
36 KiB
Rust
1080 lines
36 KiB
Rust
use bevy_ecs::{prelude::*, system::SystemParam};
|
|
use proxisim_models::bundle::{
|
|
armour::{ArmourBodyPart, ArmourBodyParts, BodyPartCoverage},
|
|
bonus::{ArmourBypassBonus, DamageMitigationBonus, MiscBonus},
|
|
player::{
|
|
ActionNullification, Attacker, BodyPart, ChooseWeapon, CombatTurns, Current, CurrentTarget,
|
|
Defeated, Defender, FightEndType, Health, HealthChange, PartDamageBonus, PickedAction,
|
|
Player, PlayerStrategy, Weapons,
|
|
},
|
|
stat::{
|
|
AmmoControl, Clips, CritRate, DamageBonus, Defence, Dexterity, EffectiveStat, MaxHealth,
|
|
SimpleStatEffective, Speed, Strength, WeaponAccuracy,
|
|
},
|
|
weapon::{
|
|
Ammo, AmmoType, DamageStat, NeedsReload, NonTargeted, RateOfFire, Usable, Uses, Weapon,
|
|
WeaponSlot,
|
|
},
|
|
};
|
|
use rand::Rng as _;
|
|
|
|
use crate::{
|
|
FightStatus, Rng, Stages,
|
|
effect::Effects,
|
|
log,
|
|
log::Logger,
|
|
metrics::Metrics,
|
|
player::status_effect::{
|
|
Bleed, DamageOverTime, DamageOverTimeType, DeferredDamage, ExtraStatusEffectEffectiveness,
|
|
Hardened,
|
|
},
|
|
weapon::{DamageProcEffect, TurnTriggeredEffect, bonus::MultiTurnBonus},
|
|
};
|
|
|
|
pub mod stats;
|
|
pub mod status_effect;
|
|
|
|
fn select_weapon(
|
|
weapons: &Weapons,
|
|
slot: WeaponSlot,
|
|
reload: bool,
|
|
usable_q: &Query<Has<NeedsReload>, With<Usable>>,
|
|
) -> Option<WeaponSlot> {
|
|
let id = match slot {
|
|
WeaponSlot::Primary => weapons.primary?,
|
|
WeaponSlot::Secondary => weapons.secondary?,
|
|
WeaponSlot::Melee => weapons.melee?,
|
|
WeaponSlot::Temporary => weapons.temporary?,
|
|
WeaponSlot::Fists => weapons.fists,
|
|
WeaponSlot::Kick => weapons.kick,
|
|
};
|
|
|
|
let needs_reload = usable_q.get(id).ok()?;
|
|
|
|
if !reload && needs_reload {
|
|
None
|
|
} else {
|
|
Some(slot)
|
|
}
|
|
}
|
|
|
|
fn designate_first(
|
|
attacker_q: Query<Entity, With<Attacker>>,
|
|
defender_q: Query<Entity, With<Defender>>,
|
|
mut commands: Commands,
|
|
) {
|
|
let attacker = attacker_q.iter().next().unwrap();
|
|
let defender = defender_q.single().unwrap();
|
|
commands.entity(attacker).insert(Current);
|
|
commands.entity(defender).insert(CurrentTarget);
|
|
}
|
|
|
|
fn change_roles(
|
|
current_q: Query<Entity, (With<Current>, With<Player>)>,
|
|
target_q: Query<Entity, With<CurrentTarget>>,
|
|
mut commands: Commands,
|
|
) {
|
|
let current = current_q.single().unwrap();
|
|
let target = target_q.single().unwrap();
|
|
|
|
// TODO: Group fights
|
|
commands
|
|
.entity(current)
|
|
.remove::<Current>()
|
|
.insert(CurrentTarget);
|
|
// TODO: Distraction
|
|
commands
|
|
.entity(target)
|
|
.insert(Current)
|
|
.remove::<CurrentTarget>();
|
|
}
|
|
|
|
fn check_term_condition(
|
|
mut state: ResMut<FightStatus>,
|
|
defender_q: Query<(), (With<Defender>, Without<Defeated>)>,
|
|
attacker_q: Query<(), (With<Attacker>, Without<Defeated>)>,
|
|
) {
|
|
if defender_q.is_empty() || attacker_q.is_empty() {
|
|
*state = FightStatus::Over;
|
|
}
|
|
}
|
|
|
|
pub fn pick_action(
|
|
p_query: Query<(Entity, &Weapons, &PlayerStrategy), (With<Player>, Without<PickedAction>)>,
|
|
usable_q: Query<Has<NeedsReload>, With<Usable>>,
|
|
mut commands: Commands,
|
|
) {
|
|
for (player, weapons, strat) in p_query {
|
|
let slot = match strat {
|
|
PlayerStrategy::AlwaysFists => WeaponSlot::Fists,
|
|
PlayerStrategy::AlwaysKicks => {
|
|
select_weapon(weapons, WeaponSlot::Kick, true, &usable_q)
|
|
.unwrap_or(WeaponSlot::Fists)
|
|
}
|
|
PlayerStrategy::PrimaryMelee { reload } => {
|
|
select_weapon(weapons, WeaponSlot::Primary, *reload, &usable_q)
|
|
.or_else(|| select_weapon(weapons, WeaponSlot::Melee, true, &usable_q))
|
|
.unwrap_or(WeaponSlot::Fists)
|
|
}
|
|
PlayerStrategy::InOrder { order, reload } => order
|
|
.iter()
|
|
.find_map(|slot| select_weapon(weapons, *slot, *reload, &usable_q))
|
|
.unwrap_or(WeaponSlot::Fists),
|
|
};
|
|
|
|
commands.entity(player).insert(PickedAction(slot));
|
|
}
|
|
}
|
|
|
|
pub fn prepare_weapon(
|
|
mut p_query: Query<
|
|
(Entity, &Weapons, &PickedAction, &mut CombatTurns),
|
|
(With<Current>, With<Player>),
|
|
>,
|
|
target_q: Query<Entity, With<CurrentTarget>>,
|
|
child_q: Query<Option<&Children>>,
|
|
weapon_trigger_q: Query<&TurnTriggeredEffect>,
|
|
mut commands: Commands,
|
|
mut effects: Effects,
|
|
metrics: Res<Metrics>,
|
|
) {
|
|
let (current, weapons, picked_action, mut turns) = p_query.single_mut().unwrap();
|
|
let weapon = match picked_action.0 {
|
|
WeaponSlot::Primary => weapons.primary.unwrap_or(weapons.fists),
|
|
WeaponSlot::Secondary => weapons.secondary.unwrap_or(weapons.fists),
|
|
WeaponSlot::Melee => weapons.melee.unwrap_or(weapons.fists),
|
|
WeaponSlot::Temporary => weapons.temporary.unwrap_or(weapons.fists),
|
|
WeaponSlot::Fists => weapons.fists,
|
|
WeaponSlot::Kick => weapons.kick,
|
|
};
|
|
|
|
metrics.increment_counter(Some(current), "turn", 1);
|
|
metrics.increment_counter(Some(weapon), "turn", 1);
|
|
|
|
commands.entity(weapon).insert(Current);
|
|
|
|
let children = child_q.get(weapon).unwrap();
|
|
|
|
let target = target_q.single().unwrap();
|
|
|
|
if let Some(children) = children {
|
|
for effect in weapon_trigger_q.iter_many(children) {
|
|
effect.trigger(&mut effects, current, target);
|
|
}
|
|
}
|
|
|
|
turns.0 += 1;
|
|
}
|
|
|
|
pub struct DamageSpread(rand_distr::Beta<f32>);
|
|
|
|
impl FromWorld for DamageSpread {
|
|
fn from_world(_world: &mut World) -> Self {
|
|
Self(rand_distr::Beta::new(3.0, 3.0).unwrap())
|
|
}
|
|
}
|
|
|
|
#[derive(SystemParam)]
|
|
struct SharedParams<'w, 's> {
|
|
commands: Commands<'w, 's>,
|
|
rng: ResMut<'w, Rng>,
|
|
effects: Effects<'w, 's>,
|
|
logger: Logger<'w>,
|
|
metrics: Res<'w, Metrics>,
|
|
}
|
|
|
|
#[derive(SystemParam)]
|
|
struct BonusMitigationParams<'w, 's> {
|
|
bypass_q: Query<'w, 's, &'static ArmourBypassBonus>,
|
|
mitigation_q: Query<'w, 's, Option<&'static mut DamageMitigationBonus>>,
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
#[inline(always)]
|
|
fn check_bonus_mitigation(
|
|
params: &mut BonusMitigationParams,
|
|
shared: &mut SharedParams,
|
|
w_children: &Children,
|
|
armour_mitigation: &mut f32,
|
|
piece: &mut Option<&BodyPartCoverage>,
|
|
slot: WeaponSlot,
|
|
rounds: &Option<u16>,
|
|
health: &Health,
|
|
max_health: &SimpleStatEffective<MaxHealth>,
|
|
) -> f32 {
|
|
for bypass in params.bypass_q.iter_many(w_children) {
|
|
match bypass {
|
|
ArmourBypassBonus::Penetrate { mitigation } => {
|
|
*armour_mitigation *= 1.0 - mitigation;
|
|
}
|
|
ArmourBypassBonus::Puncture { chance } => {
|
|
if *chance >= 1.0 || shared.rng.random_bool(*chance as f64) {
|
|
*armour_mitigation = 0.0;
|
|
*piece = None;
|
|
return 0.0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(piece) = piece
|
|
&& let Some(mut mitigation) = params.mitigation_q.get_mut(piece.armour).unwrap()
|
|
{
|
|
match mitigation.as_mut() {
|
|
DamageMitigationBonus::Impregnable { mitigation } if slot == WeaponSlot::Melee => {
|
|
*mitigation
|
|
}
|
|
DamageMitigationBonus::Impenetrable { mitigation } if rounds.is_some() => *mitigation,
|
|
DamageMitigationBonus::Insurmountable { mitigation } => {
|
|
if health.0 as f32 / max_health.value as f32 <= 0.25 {
|
|
*mitigation
|
|
} else {
|
|
0.0
|
|
}
|
|
}
|
|
DamageMitigationBonus::Impassable { chance } => {
|
|
if *chance >= 1.0 || shared.rng.random_bool(*chance as f64) {
|
|
1.0
|
|
} else {
|
|
0.0
|
|
}
|
|
}
|
|
DamageMitigationBonus::Kinetokinesis { mitigation } => {
|
|
shared.commands.entity(piece.armour).insert(
|
|
DamageMitigationBonus::ActiveKinetokinesis {
|
|
mitigation: *mitigation,
|
|
remaining_turns: 10,
|
|
},
|
|
);
|
|
0.0
|
|
}
|
|
DamageMitigationBonus::ActiveKinetokinesis {
|
|
mitigation,
|
|
remaining_turns,
|
|
} => {
|
|
*remaining_turns -= 1;
|
|
|
|
if *remaining_turns == 0 {
|
|
shared.commands.entity(piece.armour).insert(
|
|
DamageMitigationBonus::Kinetokinesis {
|
|
mitigation: *mitigation,
|
|
},
|
|
);
|
|
}
|
|
|
|
*mitigation
|
|
}
|
|
_ => 0.0,
|
|
}
|
|
} else {
|
|
0.0
|
|
}
|
|
}
|
|
|
|
#[derive(SystemParam)]
|
|
struct DamageBonusParams<'w, 's> {
|
|
misc_bonus_q: Query<'w, 's, &'static MiscBonus>,
|
|
part_bonus_q: Query<'w, 's, &'static PartDamageBonus>,
|
|
}
|
|
|
|
/// Process miscellaneous bonuses that did not fall in any of the other categories
|
|
#[allow(clippy::too_many_arguments)]
|
|
#[inline(always)]
|
|
fn check_damage_bonuses(
|
|
queries: &DamageBonusParams,
|
|
shared: &mut SharedParams,
|
|
p_children: &Children,
|
|
t_health: &Health,
|
|
p_health: &Health,
|
|
t_max_health: &SimpleStatEffective<MaxHealth>,
|
|
p_max_health: &SimpleStatEffective<MaxHealth>,
|
|
part: BodyPart,
|
|
dmg_bonus: &mut SimpleStatEffective<DamageBonus>,
|
|
double_edged: &mut bool,
|
|
) {
|
|
for bonus in queries.misc_bonus_q.iter_many(p_children) {
|
|
match bonus {
|
|
MiscBonus::Blindside { bonus } if t_health.0 == t_max_health.value => {
|
|
dmg_bonus.value += bonus;
|
|
}
|
|
MiscBonus::Comeback { bonus }
|
|
if p_health.0 as f32 / p_max_health.value as f32 <= 0.25 =>
|
|
{
|
|
dmg_bonus.value += bonus;
|
|
}
|
|
MiscBonus::Deadly { chance } if *chance >= 1.0 || shared.rng.random_bool(*chance) => {
|
|
dmg_bonus.value += 5.0;
|
|
}
|
|
MiscBonus::DoubleEdged { chance }
|
|
if *chance >= 1.0 || shared.rng.random_bool(*chance) =>
|
|
{
|
|
dmg_bonus.value += 1.0;
|
|
*double_edged = true;
|
|
}
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
for bonus in queries.part_bonus_q.iter_many(p_children) {
|
|
if let Some(bonus) = bonus.dmg_bonus(part) {
|
|
dmg_bonus.value += bonus;
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(SystemParam)]
|
|
struct NullificationParams<'w, 's> {
|
|
nullification_q: Query<'w, 's, &'static ActionNullification>,
|
|
}
|
|
|
|
fn check_action_nullification(
|
|
params: &NullificationParams,
|
|
shared: &mut SharedParams,
|
|
target_children: &Children,
|
|
target_action: &PickedAction,
|
|
player_action: &PickedAction,
|
|
) -> Option<&'static str> {
|
|
for bonus in params.nullification_q.iter_many(target_children) {
|
|
match bonus {
|
|
ActionNullification::Parry { chance }
|
|
if player_action.0 == WeaponSlot::Melee
|
|
&& target_action.0 == WeaponSlot::Melee
|
|
&& (*chance >= 1.0 || shared.rng.random_bool(*chance)) =>
|
|
{
|
|
return Some("parry");
|
|
}
|
|
ActionNullification::Homerun { chance }
|
|
if player_action.0 == WeaponSlot::Temporary
|
|
&& target_action.0 == WeaponSlot::Melee
|
|
&& (*chance >= 1.0 || shared.rng.random_bool(*chance)) =>
|
|
{
|
|
return Some("homerun");
|
|
}
|
|
ActionNullification::GentsStripClub
|
|
if player_action.0 == WeaponSlot::Melee && shared.rng.random_bool(0.25) =>
|
|
{
|
|
return Some("dodged");
|
|
}
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
#[derive(SystemParam)]
|
|
struct DeferredDamageParams<'w, 's> {
|
|
damage_q: Query<'w, 's, (Entity, &'static DeferredDamage)>,
|
|
}
|
|
|
|
/// Checks and applied deferred damage.
|
|
/// Returns `true` if the attacking player was defeated
|
|
#[inline(always)]
|
|
fn check_deferred_damage(
|
|
deferred: &DeferredDamageParams,
|
|
shared: &mut SharedParams,
|
|
player: Entity,
|
|
player_children: &Children,
|
|
player_health: &mut Health,
|
|
is_attacker: bool,
|
|
target: Entity,
|
|
) -> bool {
|
|
for (instance, damage) in deferred.damage_q.iter_many(player_children) {
|
|
let health_before = player_health.0;
|
|
player_health.0 = player_health.0.saturating_sub(damage.amount);
|
|
|
|
log!(shared.logger, "deferred_damage", {
|
|
health_before: health_before,
|
|
health_after: player_health.0,
|
|
amount: damage.amount,
|
|
label: damage.label,
|
|
target: player,
|
|
});
|
|
|
|
shared.commands.entity(instance).despawn();
|
|
|
|
if player_health.0 == 0 {
|
|
shared.commands.entity(player).insert(Defeated);
|
|
log!(shared.logger, "fight_end", {
|
|
actor: target,
|
|
recipient: player,
|
|
fight_end_type: %if is_attacker {
|
|
FightEndType::Loss
|
|
} else {
|
|
FightEndType::Victory
|
|
},
|
|
});
|
|
shared.metrics.increment_counter(Some(target), "victory", 1);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
false
|
|
}
|
|
|
|
#[derive(SystemParam)]
|
|
struct EntityParams<'w, 's> {
|
|
/// The weapon and its related stats
|
|
weapon_q: Query<
|
|
'w,
|
|
's,
|
|
(
|
|
Entity,
|
|
&'static DamageStat,
|
|
&'static SimpleStatEffective<WeaponAccuracy>,
|
|
&'static SimpleStatEffective<DamageBonus>,
|
|
&'static SimpleStatEffective<CritRate>,
|
|
&'static Children,
|
|
&'static WeaponSlot,
|
|
Has<NonTargeted>,
|
|
),
|
|
(With<Weapon>, With<Current>, Without<NeedsReload>),
|
|
>,
|
|
|
|
/// The player who's using the weapon and their related stats
|
|
player_q: Query<
|
|
'w,
|
|
's,
|
|
(
|
|
Entity,
|
|
&'static EffectiveStat<Speed>,
|
|
&'static EffectiveStat<Strength>,
|
|
&'static SimpleStatEffective<CritRate>,
|
|
&'static SimpleStatEffective<WeaponAccuracy>,
|
|
&'static SimpleStatEffective<DamageBonus>,
|
|
&'static SimpleStatEffective<MaxHealth>,
|
|
&'static Children,
|
|
&'static PickedAction,
|
|
&'static mut Health,
|
|
Has<Attacker>,
|
|
),
|
|
(With<Player>, With<Current>),
|
|
>,
|
|
|
|
/// The player who is targeted with the weapon
|
|
target_q: Query<
|
|
'w,
|
|
's,
|
|
(
|
|
Entity,
|
|
&'static EffectiveStat<Dexterity>,
|
|
&'static EffectiveStat<Defence>,
|
|
&'static SimpleStatEffective<MaxHealth>,
|
|
&'static ArmourBodyParts,
|
|
&'static Children,
|
|
&'static PickedAction,
|
|
&'static mut Health,
|
|
),
|
|
(With<CurrentTarget>, Without<Current>),
|
|
>,
|
|
}
|
|
|
|
// NOTE: unfortunately this function can't really be split into smaller parts due to the existence
|
|
// of multi turn bonuses
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn use_damaging_weapon(
|
|
(mut shared, mut bonus_mitigation, deferred, misc_bonus, nullification): (
|
|
SharedParams,
|
|
BonusMitigationParams,
|
|
DeferredDamageParams,
|
|
DamageBonusParams,
|
|
NullificationParams,
|
|
),
|
|
mut entities: EntityParams,
|
|
armour_q: Query<&ArmourBodyPart>,
|
|
damage_proc_q: Query<&DamageProcEffect>,
|
|
(mut ammo_q, mut temp_q): (
|
|
Query<(
|
|
&mut Ammo,
|
|
&SimpleStatEffective<Clips>,
|
|
&RateOfFire,
|
|
&SimpleStatEffective<AmmoControl>,
|
|
&AmmoType,
|
|
)>,
|
|
Query<&mut Uses>,
|
|
),
|
|
dmg_spread: Local<DamageSpread>,
|
|
) {
|
|
let Ok((weapon, w_dmg, acc, dmg_bonus, crit, children, slot, non_targeted)) =
|
|
entities.weapon_q.single()
|
|
else {
|
|
return;
|
|
};
|
|
let (
|
|
player,
|
|
player_spd,
|
|
player_str,
|
|
player_crit,
|
|
acc_bonus,
|
|
p_dmg_bonus,
|
|
p_max_health,
|
|
p_children,
|
|
p_action,
|
|
mut p_health,
|
|
attacker,
|
|
) = entities.player_q.single_mut().unwrap();
|
|
let (
|
|
target,
|
|
target_dex,
|
|
target_def,
|
|
target_max_health,
|
|
armour_parts,
|
|
t_children,
|
|
t_action,
|
|
mut health,
|
|
) = entities.target_q.single_mut().unwrap();
|
|
|
|
if check_deferred_damage(
|
|
&deferred,
|
|
&mut shared,
|
|
player,
|
|
p_children,
|
|
&mut p_health,
|
|
attacker,
|
|
target,
|
|
) {
|
|
return;
|
|
}
|
|
|
|
if let Ok(mut uses) = temp_q.get_mut(weapon) {
|
|
uses.0 -= 1;
|
|
if uses.0 == 0 {
|
|
shared.commands.entity(weapon).remove::<Usable>();
|
|
}
|
|
}
|
|
|
|
let spd_dex_ratio = (player_spd.value / target_dex.value).clamp(1.0 / 64.0, 64.0);
|
|
let base_hit_chance = if spd_dex_ratio < 1.0 {
|
|
0.5 * (8.0 * spd_dex_ratio.sqrt() - 1.0) / 7.0
|
|
} else {
|
|
1.0 - 0.5 * (8.0 / spd_dex_ratio.sqrt() - 1.0) / 7.0
|
|
};
|
|
|
|
let mut acc_eff = acc + acc_bonus;
|
|
|
|
let mut ammo = ammo_q
|
|
.get_mut(weapon)
|
|
.ok()
|
|
.map(|(ammo, clips, rof, ammo_ctrl, kind)| {
|
|
let ammo_ctrl = 1.0 - (ammo_ctrl).value;
|
|
let rof_eff = ((rof.0[0] as f32) * ammo_ctrl)..=((rof.0[1] as f32) * ammo_ctrl);
|
|
if *kind == AmmoType::Tracer {
|
|
acc_eff.value += 10.0 / 50.0;
|
|
}
|
|
(ammo, clips, rof_eff, kind)
|
|
});
|
|
|
|
enum MultiAttack {
|
|
Blindfire,
|
|
Rage(u16),
|
|
Fury { first_hit: bool },
|
|
DoubleTap { first_shot: bool },
|
|
}
|
|
|
|
let mut multi_attack_proc = None;
|
|
let mut defeated = false;
|
|
let crit = player_crit + crit;
|
|
|
|
let def_str_ratio = (target_def.value / player_str.value).clamp(1.0 / 32.0, 14.0);
|
|
let def_mitigation = if def_str_ratio < 1.0 {
|
|
0.5 * def_str_ratio.log(32.0) + 0.5
|
|
} else {
|
|
0.5 * def_str_ratio.log(14.0) + 0.5
|
|
};
|
|
|
|
let dmg_intrinsic = 7.0 * (player_str.value / 10.0).log10().powi(2)
|
|
+ 27.0 * (player_str.value / 10.0).log10()
|
|
+ 30.0;
|
|
|
|
loop {
|
|
let rounds = ammo.as_mut().map(|(ammo, clips, rof, _)| {
|
|
let rounds = (shared.rng.random_range(rof.clone()).round() as u16).clamp(1, ammo.0);
|
|
shared
|
|
.metrics
|
|
.increment_counter(Some(player), "rounds_fired", rounds.into());
|
|
shared
|
|
.metrics
|
|
.increment_counter(Some(weapon), "rounds_fired", rounds.into());
|
|
ammo.0 -= rounds;
|
|
if ammo.0 == 0 {
|
|
if clips.value == 0 {
|
|
shared.commands.entity(weapon).remove::<Usable>();
|
|
} else {
|
|
shared.commands.entity(weapon).insert(NeedsReload);
|
|
}
|
|
}
|
|
rounds
|
|
});
|
|
|
|
let hit_chance = if base_hit_chance < 0.5 {
|
|
base_hit_chance + acc_eff.value * base_hit_chance
|
|
} else {
|
|
base_hit_chance + acc_eff.value * (1.0 - base_hit_chance)
|
|
};
|
|
|
|
if hit_chance <= 1.0 && !shared.rng.random_bool(hit_chance as f64) {
|
|
log!(shared.logger, "miss_target", {
|
|
weapon: weapon,
|
|
actor: player,
|
|
recipient: target,
|
|
rounds: rounds,
|
|
hit_chance: hit_chance,
|
|
});
|
|
shared.metrics.increment_counter(Some(player), "miss", 1);
|
|
shared.metrics.increment_counter(Some(weapon), "miss", 1);
|
|
|
|
if multi_attack_proc.is_none() {
|
|
return;
|
|
};
|
|
} else {
|
|
if multi_attack_proc.is_none()
|
|
&& let Some(kind) = check_action_nullification(
|
|
&nullification,
|
|
&mut shared,
|
|
t_children,
|
|
t_action,
|
|
p_action,
|
|
)
|
|
{
|
|
log!(shared.logger, "nullified", {
|
|
actor: player,
|
|
recipient: player,
|
|
weapon: weapon,
|
|
rounds,
|
|
kind,
|
|
});
|
|
|
|
return;
|
|
}
|
|
|
|
let body_part = if !non_targeted {
|
|
shared.rng.sample(crit)
|
|
} else {
|
|
BodyPart::Stomach
|
|
};
|
|
|
|
let mult = match body_part {
|
|
BodyPart::Head | BodyPart::Heart | BodyPart::Throat => {
|
|
shared.metrics.increment_counter(Some(player), "crit", 1);
|
|
shared.metrics.increment_counter(Some(weapon), "crit", 1);
|
|
1.0
|
|
}
|
|
BodyPart::LeftHand
|
|
| BodyPart::RightHand
|
|
| BodyPart::LeftFoot
|
|
| BodyPart::RightFoot => 0.2,
|
|
BodyPart::LeftArm | BodyPart::RightArm | BodyPart::LeftLeg | BodyPart::RightLeg => {
|
|
1.0 / 3.5
|
|
}
|
|
BodyPart::Groin | BodyPart::Stomach | BodyPart::Chest => 1.0 / 1.75,
|
|
};
|
|
|
|
shared.metrics.increment_counter(Some(player), "hit", 1);
|
|
shared.metrics.increment_counter(Some(weapon), "hit", 1);
|
|
|
|
let armour_parts = armour_q.get(armour_parts.0[body_part.into()]).unwrap();
|
|
let mut piece = shared.rng.sample(armour_parts);
|
|
let mut armour_mitigation = piece.map_or(0.0, |p| p.armour_value);
|
|
|
|
// NOTE: Proxima's simulator seems to have the damage spread be between 95% and 105%,
|
|
// but from my brief tests it seems that 100% to 110% lines up better, at least for h2h.
|
|
// It might be better to revivisit this detail later down the line and run more tests.
|
|
let dmg_spread = shared.rng.sample(dmg_spread.0) / 10.0 + 1.0;
|
|
|
|
let mut dmg_bonus = dmg_bonus + p_dmg_bonus;
|
|
|
|
let bonus_mitigation = check_bonus_mitigation(
|
|
&mut bonus_mitigation,
|
|
&mut shared,
|
|
children,
|
|
&mut armour_mitigation,
|
|
&mut piece,
|
|
*slot,
|
|
&rounds,
|
|
&health,
|
|
target_max_health,
|
|
);
|
|
|
|
if let Some((_, _, _, kind)) = ammo {
|
|
match kind {
|
|
AmmoType::HollowPoint if piece.is_none() => armour_mitigation *= 1.5,
|
|
AmmoType::HollowPoint => dmg_bonus.value += 0.50,
|
|
AmmoType::Incindiary => dmg_bonus.value += 0.40,
|
|
AmmoType::Piercer => armour_mitigation *= 0.5,
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
let mut double_edged = false;
|
|
|
|
check_damage_bonuses(
|
|
&misc_bonus,
|
|
&mut shared,
|
|
children,
|
|
&health,
|
|
&p_health,
|
|
target_max_health,
|
|
p_max_health,
|
|
body_part,
|
|
&mut dmg_bonus,
|
|
&mut double_edged,
|
|
);
|
|
|
|
let dmg = dmg_intrinsic
|
|
* w_dmg.0
|
|
* (1.0 + dmg_bonus.value)
|
|
* (1.0 - armour_mitigation)
|
|
* (1.0 - def_mitigation)
|
|
* (1.0 - bonus_mitigation)
|
|
* mult
|
|
* dmg_spread;
|
|
let dmg_i = dmg.round() as u32;
|
|
|
|
if double_edged {
|
|
shared
|
|
.commands
|
|
.write_message(HealthChange::DoubleEdged { dmg: dmg_i });
|
|
}
|
|
|
|
shared.metrics.record_histogram(Some(player), "dmg", dmg_i);
|
|
shared.metrics.record_histogram(Some(weapon), "dmg", dmg_i);
|
|
|
|
if multi_attack_proc.is_none() && dmg_i > 0 {
|
|
for effect in damage_proc_q.iter_many(children) {
|
|
match *effect {
|
|
DamageProcEffect::MultiTurn { value, bonus } => {
|
|
if multi_attack_proc.is_some() {
|
|
continue;
|
|
}
|
|
let chance = (value / 100.0) as f64;
|
|
if chance >= 1.0 || shared.rng.random_bool(chance) {
|
|
match bonus {
|
|
MultiTurnBonus::Blindfire => {
|
|
multi_attack_proc = Some(MultiAttack::Blindfire)
|
|
}
|
|
MultiTurnBonus::Fury => {
|
|
multi_attack_proc =
|
|
Some(MultiAttack::Fury { first_hit: true })
|
|
}
|
|
MultiTurnBonus::Rage => {
|
|
multi_attack_proc =
|
|
Some(MultiAttack::Rage(shared.rng.random_range(2..=8)))
|
|
}
|
|
MultiTurnBonus::DoubleTap => {
|
|
multi_attack_proc =
|
|
Some(MultiAttack::DoubleTap { first_shot: true })
|
|
}
|
|
};
|
|
shared.metrics.increment_counter(
|
|
Some(player),
|
|
bonus.counter_label(),
|
|
1,
|
|
);
|
|
shared.metrics.increment_counter(
|
|
Some(weapon),
|
|
bonus.counter_label(),
|
|
1,
|
|
);
|
|
}
|
|
}
|
|
DamageProcEffect::SelfEffect { value, bonus } => {
|
|
let chance = (value / 100.0) as f64;
|
|
if chance > 1.0 || shared.rng.random_bool(chance) {
|
|
bonus.spawn(player, &mut shared.effects);
|
|
}
|
|
}
|
|
DamageProcEffect::OpponentEffect { value, bonus } => {
|
|
let chance = (value / 100.0) as f64;
|
|
if chance > 1.0 || shared.rng.random_bool(chance) {
|
|
bonus.spawn(target, &mut shared.effects, &mut shared.rng.0);
|
|
}
|
|
}
|
|
DamageProcEffect::DamageOverTime { value, kind } => {
|
|
let chance = (value / 100.0) as f64;
|
|
if chance > 1.0 || shared.rng.random_bool(chance) {
|
|
match kind {
|
|
DamageOverTimeType::Bleed => {
|
|
shared.commands.entity(target).insert(DamageOverTime::<
|
|
Bleed,
|
|
>::new(
|
|
dmg_i
|
|
));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
DamageProcEffect::Execute { cutoff } => {
|
|
if health.0 as f32 / target_max_health.value as f32 <= cutoff {
|
|
shared.commands.entity(target).insert(Defeated);
|
|
let health_before = health.0;
|
|
health.0 = 0;
|
|
log!(shared.logger, "executed", {
|
|
actor: player,
|
|
recipient: target,
|
|
health_before,
|
|
});
|
|
log!(shared.logger, "fight_end", {
|
|
actor: player,
|
|
recipient: target,
|
|
fight_end_type: %if attacker {
|
|
FightEndType::Victory
|
|
} else {
|
|
FightEndType::Loss
|
|
},
|
|
});
|
|
shared.metrics.increment_counter(Some(player), "victory", 1);
|
|
return;
|
|
}
|
|
}
|
|
DamageProcEffect::Bloodlust { ratio } => {
|
|
shared.commands.write_message(HealthChange::Bloodlust {
|
|
dmg: dmg_i,
|
|
value: ratio,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let health_before = health.0;
|
|
|
|
health.0 = health.0.saturating_sub(dmg_i as u16);
|
|
|
|
log!(shared.logger, "hit_target", {
|
|
actor: player,
|
|
acc: acc_eff.value,
|
|
recipient: target,
|
|
weapon,
|
|
part: %body_part,
|
|
part_mult: mult,
|
|
rounds,
|
|
health_before: health_before,
|
|
health_after: health.0,
|
|
dmg: dmg_i,
|
|
dmg_spread,
|
|
dmg_intrinsic,
|
|
dmg_weapon: w_dmg.0,
|
|
armour_mitigation,
|
|
def_mitigation,
|
|
bonus_mitigation,
|
|
bonus_dmg: dmg_bonus.value,
|
|
hit_chance: hit_chance,
|
|
crit_rate: crit.value,
|
|
});
|
|
|
|
if health.0 == 0 && !defeated {
|
|
defeated = true;
|
|
|
|
shared.commands.entity(target).insert(Defeated);
|
|
log!(shared.logger, "fight_end", {
|
|
actor: player,
|
|
recipient: target,
|
|
fight_end_type: %if attacker {
|
|
FightEndType::Victory
|
|
} else {
|
|
FightEndType::Loss
|
|
},
|
|
});
|
|
shared.metrics.increment_counter(Some(player), "victory", 1);
|
|
}
|
|
}
|
|
|
|
// Technically only douple tap and blindfire have this condition, but we can run into
|
|
// panics with invalid bonus/weapon combinations without checking this for all bonuses
|
|
if ammo.as_ref().is_some_and(|(a, _, _, _)| a.0 == 0) {
|
|
break;
|
|
}
|
|
|
|
match multi_attack_proc {
|
|
Some(MultiAttack::Blindfire) => {
|
|
acc_eff.value -= 5.0 / 50.0;
|
|
// Prevent infinite loop if used on a melee
|
|
if ammo.is_none() {
|
|
break;
|
|
}
|
|
}
|
|
Some(MultiAttack::Fury { first_hit: true }) => {
|
|
multi_attack_proc = Some(MultiAttack::Fury { first_hit: false })
|
|
}
|
|
Some(MultiAttack::Rage(turns @ 1..)) => {
|
|
multi_attack_proc = Some(MultiAttack::Rage(turns - 1))
|
|
}
|
|
Some(MultiAttack::DoubleTap { first_shot: true }) => {
|
|
multi_attack_proc = Some(MultiAttack::DoubleTap { first_shot: false })
|
|
}
|
|
_ => break,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn check_stalemate(
|
|
current_q: Query<(Entity, &CombatTurns, Has<Attacker>), (With<Current>, With<Player>)>,
|
|
target_q: Query<Entity, With<CurrentTarget>>,
|
|
other_attackers_q: Query<(), (With<Attacker>, Without<Current>)>,
|
|
mut state: ResMut<FightStatus>,
|
|
mut commands: Commands,
|
|
mut logger: Logger,
|
|
metrics: Res<Metrics>,
|
|
) {
|
|
let (current, current_turns, attacker) = current_q.single().unwrap();
|
|
if *state == FightStatus::Ongoing && current_turns.0 >= 25 && attacker {
|
|
commands.entity(current).insert(Defeated);
|
|
let target = target_q.single();
|
|
|
|
log!(logger, "fight_end", {
|
|
actor: current,
|
|
recipient: target,
|
|
fight_end_type: %FightEndType::Stalemate,
|
|
});
|
|
metrics.increment_counter(Some(current), "stalemate", 1);
|
|
|
|
if other_attackers_q.is_empty() {
|
|
*state = FightStatus::Over
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn restore_initial_state(
|
|
mut state: ResMut<FightStatus>,
|
|
mut player_q: Query<(Entity, &mut CombatTurns, Has<Attacker>)>,
|
|
mut commands: Commands,
|
|
) {
|
|
*state = FightStatus::Ongoing;
|
|
|
|
for (player, mut turns, attacker) in player_q.iter_mut() {
|
|
turns.0 = 0;
|
|
commands.entity(player).remove::<Defeated>();
|
|
if attacker {
|
|
commands
|
|
.entity(player)
|
|
.remove::<CurrentTarget>()
|
|
.insert(Current);
|
|
} else {
|
|
commands
|
|
.entity(player)
|
|
.remove::<Current>()
|
|
.insert(CurrentTarget);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn record_post_fight_stats(player_q: Query<(Entity, &Health)>, metrics: Res<Metrics>) {
|
|
for (player, health) in player_q.iter() {
|
|
metrics.record_histogram(Some(player), "rem_health", health.0 as u32);
|
|
}
|
|
}
|
|
|
|
fn restore_health(
|
|
health_q: Query<(Entity, &SimpleStatEffective<MaxHealth>)>,
|
|
mut commands: Commands,
|
|
mut logger: Logger,
|
|
) {
|
|
for (player, max_health) in health_q {
|
|
log!(logger, "initial_health", {
|
|
target: player,
|
|
max_health: max_health.value,
|
|
});
|
|
commands.entity(player).insert(Health(max_health.value));
|
|
}
|
|
}
|
|
|
|
fn process_health_changes(
|
|
mut messages: MessageReader<HealthChange>,
|
|
mut logger: Logger,
|
|
mut p_query: Query<
|
|
(
|
|
Entity,
|
|
&SimpleStatEffective<MaxHealth>,
|
|
&mut Health,
|
|
Option<&ExtraStatusEffectEffectiveness<1, Hardened>>,
|
|
),
|
|
(With<Player>, With<Current>),
|
|
>,
|
|
) {
|
|
for message in messages.read() {
|
|
let (player, max_health, mut health, extra_effectiveness) = p_query.single_mut().unwrap();
|
|
let (source, delta) = match message {
|
|
HealthChange::Cauterise => {
|
|
let delta = (max_health.value as f32 * 0.2) as i16;
|
|
("Cauterise", delta)
|
|
}
|
|
HealthChange::Serotonin => {
|
|
let delta = (max_health.value as f32
|
|
* 0.25
|
|
* extra_effectiveness.map_or(1.0, |e| e.factor))
|
|
as i16;
|
|
("Serotonin", delta)
|
|
}
|
|
HealthChange::Bloodlust { dmg, value } => {
|
|
let delta = (*dmg as f32 * *value) as i16;
|
|
("Bloodlust", delta)
|
|
}
|
|
HealthChange::DoubleEdged { dmg } => {
|
|
let delta = -(*dmg as f32 * 0.25) as i16;
|
|
("Double-edged", delta)
|
|
}
|
|
};
|
|
|
|
let health_before = health.0;
|
|
health.0 = (health.0 as i16 + delta).clamp(1, max_health.value as i16) as u16;
|
|
|
|
log!(logger, "health_change", {
|
|
recipient: player,
|
|
source,
|
|
delta,
|
|
health_before,
|
|
health_after: health.0
|
|
})
|
|
}
|
|
}
|
|
|
|
fn remove_action_end_of_turn(
|
|
attacker_turn: Query<Has<Attacker>, (With<Current>, With<Player>)>,
|
|
picked_q: Query<Entity, With<PickedAction>>,
|
|
mut commands: Commands,
|
|
) {
|
|
if !attacker_turn.single().unwrap() {
|
|
for player in picked_q {
|
|
commands.entity(player).remove::<PickedAction>();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn remove_picked_actions(picked_q: Query<Entity, With<PickedAction>>, mut commands: Commands) {
|
|
for player in picked_q {
|
|
commands.entity(player).remove::<PickedAction>();
|
|
}
|
|
}
|
|
|
|
pub(crate) fn configure(stages: &mut Stages) {
|
|
stats::configure(stages);
|
|
status_effect::configure(stages);
|
|
|
|
stages.add_event::<ChooseWeapon>();
|
|
stages.add_event::<HealthChange>();
|
|
stages.equip.add_systems(designate_first);
|
|
stages.pre_fight.add_systems((restore_health, pick_action));
|
|
stages.pre_turn.add_systems(prepare_weapon);
|
|
stages
|
|
.turn
|
|
.add_systems((use_damaging_weapon, remove_action_end_of_turn));
|
|
stages
|
|
.post_turn
|
|
.add_systems((
|
|
check_term_condition,
|
|
change_roles,
|
|
process_health_changes,
|
|
pick_action,
|
|
))
|
|
.add_systems(
|
|
check_stalemate
|
|
.after(check_term_condition)
|
|
.before(change_roles),
|
|
);
|
|
stages
|
|
.post_fight
|
|
.add_systems((record_post_fight_stats, remove_picked_actions));
|
|
stages
|
|
.restore
|
|
.add_systems((restore_initial_state, restore_health, pick_action));
|
|
}
|