//bevy system signatures often violate these rules #![allow(clippy::type_complexity)] #![allow(clippy::too_many_arguments)] use std::time::Duration; use bevy::prelude::*; use state::GameSystemSet; pub struct CombatPlugin; impl Plugin for CombatPlugin { fn build(&self, app: &mut App) { app.add_observer(on_attack) .add_observer(on_die) .add_systems( FixedUpdate, tick_invulnerability.in_set(GameSystemSet::StatusEffects), ); } } #[derive(Component, Clone, Debug, PartialEq, Eq)] pub enum Team { Core, Immune, } #[derive(Event, Debug, Default)] pub struct Attacked { pub attacker: Option, pub amount: f32, pub skip_invulnerability: bool, } #[derive(Event, Debug)] pub struct Died { pub slayer: Option, } #[derive(Component, Clone, Debug)] #[require(InvulnerabilityTime)] pub struct Health { pub max: f32, pub current: f32, } impl Health { pub fn new(health: f32) -> Self { Self { max: health, current: health, } } } impl Default for Health { fn default() -> Self { Self { max: 1.0, current: 1.0, } } } #[derive(Component, Clone, Debug)] pub struct InvulnerabilityTime { pub duration: Duration, } impl Default for InvulnerabilityTime { fn default() -> Self { Self { duration: Duration::from_secs_f32(0.25), } } } #[derive(Component, Clone, Debug)] pub struct Invulnerable { pub time_remaining: Option, } impl From<&InvulnerabilityTime> for Invulnerable { fn from(value: &InvulnerabilityTime) -> Self { Self { time_remaining: Some(Timer::new(value.duration, TimerMode::Once)), } } } #[derive(Component, Clone, Debug, Default)] #[require(Health)] pub struct Defense { pub amount: f32, } impl Defense { pub fn calc_damage(&self, incoming_damage: f32) -> f32 { let min_damage = 0.1; if incoming_damage < min_damage { return 0.; } (incoming_damage - self.amount * 0.5).max(min_damage) } pub fn new(amount: f32) -> Self { Self { amount } } } fn on_attack( trigger: Trigger, mut commands: Commands, attacker_query: Query<&Team>, mut attacked_query: Query< ( &mut Health, &InvulnerabilityTime, Option<&Defense>, Option<&Team>, ), Without, >, names: Query<&Name>, ) { let Ok((mut health, invulnerability, opt_defense, opt_team)) = attacked_query.get_mut(trigger.target()) else { return; }; if let Some(Ok(attacker_team)) = trigger.event().attacker.map(|a| attacker_query.get(a)) && let Some(team) = opt_team && team == attacker_team { info!("avoiding friendly fire!"); return; } let defense = opt_defense.cloned().unwrap_or_default(); let damage_taken = defense.calc_damage(trigger.event().amount); health.current = (health.current - damage_taken).max(0.0); info!( "{:?} attacked {:?} for {} damage. New health = {}", trigger .event() .attacker .map(|e| names.get(e).ok()) .flatten(), names.get(trigger.target()), damage_taken, health.current ); if let Ok(mut ec) = commands.get_entity(trigger.target()) { if health.current <= 0. { ec.trigger(Died { slayer: trigger.event().attacker, }); } else if !trigger.event().skip_invulnerability { ec.insert(Invulnerable::from(invulnerability)); } } } fn on_die(trigger: Trigger, names: Query<&Name>, mut commands: Commands) { if let Ok(mut ec) = commands.get_entity(trigger.target()) { info!( "{:?} killed {:?}!", trigger.event().slayer.map(|e| names.get(e).ok()).flatten(), names.get(trigger.target()) ); ec.despawn(); } } fn tick_invulnerability( mut commands: Commands, mut query: Query<(Entity, &mut Invulnerable)>, time: Res