use bevy::prelude::*;
use crate::player::PlayerHealth;
#[derive(Debug, Clone, Copy)]
pub struct EffectModifiers {
pub speed_mult: f32,
pub jump_mult: f32,
pub gravity_mult: f32,
pub mining_speed_mult: f32,
pub damage_resistance: f32,
pub regen_per_sec: f32,
pub damage_per_sec: f32,
}
impl Default for EffectModifiers {
fn default() -> Self {
Self {
speed_mult: 1.0,
jump_mult: 1.0,
gravity_mult: 1.0,
mining_speed_mult: 1.0,
damage_resistance: 0.0,
regen_per_sec: 0.0,
damage_per_sec: 0.0,
}
}
}
pub trait StatusEffect: Send + Sync + Clone + PartialEq + 'static {
fn name(&self) -> &'static str;
fn modifiers(&self, amplifier: u8) -> EffectModifiers;
fn color(&self) -> [f32; 4] {
[1.0, 1.0, 1.0, 1.0]
}
fn is_beneficial(&self) -> bool {
true
}
}
#[derive(Debug, Clone)]
pub struct ActiveEffect<E: StatusEffect> {
pub effect: E,
pub amplifier: u8,
pub remaining_secs: f32,
}
#[derive(Resource)]
pub struct ActiveEffects<E: StatusEffect> {
pub effects: Vec<ActiveEffect<E>>,
}
impl<E: StatusEffect> Default for ActiveEffects<E> {
fn default() -> Self {
Self {
effects: Vec::new(),
}
}
}
impl<E: StatusEffect> ActiveEffects<E> {
pub fn apply(&mut self, effect: E, amplifier: u8, duration_secs: f32) {
if let Some(existing) = self.effects.iter_mut().find(|a| a.effect == effect) {
existing.amplifier = existing.amplifier.max(amplifier);
existing.remaining_secs = existing.remaining_secs.max(duration_secs);
} else {
self.effects.push(ActiveEffect {
effect,
amplifier,
remaining_secs: duration_secs,
});
}
}
pub fn remove(&mut self, effect: &E) {
self.effects.retain(|a| &a.effect != effect);
}
pub fn combined_modifiers(&self) -> EffectModifiers {
let mut out = EffectModifiers::default();
for a in &self.effects {
let m = a.effect.modifiers(a.amplifier);
out.speed_mult *= m.speed_mult;
out.jump_mult *= m.jump_mult;
out.gravity_mult *= m.gravity_mult;
out.mining_speed_mult *= m.mining_speed_mult;
out.damage_resistance = (out.damage_resistance + m.damage_resistance).min(1.0);
out.regen_per_sec += m.regen_per_sec;
out.damage_per_sec += m.damage_per_sec;
}
out
}
}
#[derive(Resource, Default)]
pub struct AppliedEffectModifiers(pub EffectModifiers);
pub fn tick_effects<E: StatusEffect>(mut effects: ResMut<ActiveEffects<E>>, time: Res<Time>) {
let dt = time.delta_secs();
effects.effects.retain_mut(|a| {
a.remaining_secs -= dt;
a.remaining_secs > 0.0
});
}
pub fn update_applied_modifiers<E: StatusEffect>(
effects: Res<ActiveEffects<E>>,
mut applied: ResMut<AppliedEffectModifiers>,
) {
applied.0 = effects.combined_modifiers();
}
pub fn apply_health_effects<E: StatusEffect>(
effects: Res<ActiveEffects<E>>,
mut health: ResMut<PlayerHealth>,
time: Res<Time>,
) {
let m = effects.combined_modifiers();
let dt = time.delta_secs();
if m.regen_per_sec > 0.0 {
health.health = (health.health + m.regen_per_sec * dt).min(health.max_health);
}
if m.damage_per_sec > 0.0 {
health.health = (health.health - m.damage_per_sec * dt).max(1.0_f32);
}
}
pub struct StatusEffectsPlugin<E: StatusEffect> {
_marker: std::marker::PhantomData<E>,
}
impl<E: StatusEffect> StatusEffectsPlugin<E> {
pub fn new() -> Self {
Self {
_marker: std::marker::PhantomData,
}
}
}
impl<E: StatusEffect> Default for StatusEffectsPlugin<E> {
fn default() -> Self {
Self::new()
}
}
impl<E: StatusEffect> Plugin for StatusEffectsPlugin<E> {
fn build(&self, app: &mut App) {
app.init_resource::<ActiveEffects<E>>();
app.init_resource::<AppliedEffectModifiers>();
app.add_systems(
Update,
(
update_applied_modifiers::<E>,
tick_effects::<E>,
apply_health_effects::<E>,
),
);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[derive(Clone, PartialEq, Debug)]
enum TestEffect {
Speed,
Poison,
Resistance,
}
impl StatusEffect for TestEffect {
fn name(&self) -> &'static str {
match self {
Self::Speed => "Speed",
Self::Poison => "Poison",
Self::Resistance => "Resistance",
}
}
fn modifiers(&self, amplifier: u8) -> EffectModifiers {
let lvl = (amplifier + 1) as f32;
match self {
Self::Speed => EffectModifiers {
speed_mult: 1.0 + 0.2 * lvl,
..Default::default()
},
Self::Poison => EffectModifiers {
damage_per_sec: 1.0 * lvl,
..Default::default()
},
Self::Resistance => EffectModifiers {
damage_resistance: 0.2 * lvl,
..Default::default()
},
}
}
fn is_beneficial(&self) -> bool {
!matches!(self, Self::Poison)
}
}
#[test]
fn effect_modifiers_default_identity() {
let m = EffectModifiers::default();
assert_eq!(m.speed_mult, 1.0);
assert_eq!(m.jump_mult, 1.0);
assert_eq!(m.gravity_mult, 1.0);
assert_eq!(m.mining_speed_mult, 1.0);
assert_eq!(m.damage_resistance, 0.0);
assert_eq!(m.regen_per_sec, 0.0);
assert_eq!(m.damage_per_sec, 0.0);
}
#[test]
fn apply_adds_new_effect() {
let mut ae: ActiveEffects<TestEffect> = ActiveEffects::default();
ae.apply(TestEffect::Speed, 0, 10.0);
assert_eq!(ae.effects.len(), 1);
assert_eq!(ae.effects[0].amplifier, 0);
assert!((ae.effects[0].remaining_secs - 10.0).abs() < f32::EPSILON);
}
#[test]
fn apply_refreshes_existing_keeps_higher_amplifier_and_longer_duration() {
let mut ae: ActiveEffects<TestEffect> = ActiveEffects::default();
ae.apply(TestEffect::Speed, 1, 10.0);
ae.apply(TestEffect::Speed, 0, 20.0); assert_eq!(ae.effects.len(), 1);
assert_eq!(ae.effects[0].amplifier, 1); assert!((ae.effects[0].remaining_secs - 20.0).abs() < f32::EPSILON); }
#[test]
fn apply_two_different_effects() {
let mut ae: ActiveEffects<TestEffect> = ActiveEffects::default();
ae.apply(TestEffect::Speed, 0, 5.0);
ae.apply(TestEffect::Poison, 0, 5.0);
assert_eq!(ae.effects.len(), 2);
}
#[test]
fn remove_clears_matching_effect() {
let mut ae: ActiveEffects<TestEffect> = ActiveEffects::default();
ae.apply(TestEffect::Speed, 0, 10.0);
ae.apply(TestEffect::Poison, 0, 10.0);
ae.remove(&TestEffect::Speed);
assert_eq!(ae.effects.len(), 1);
assert_eq!(ae.effects[0].effect, TestEffect::Poison);
}
#[test]
fn remove_nonexistent_is_noop() {
let mut ae: ActiveEffects<TestEffect> = ActiveEffects::default();
ae.apply(TestEffect::Poison, 0, 5.0);
ae.remove(&TestEffect::Speed);
assert_eq!(ae.effects.len(), 1);
}
#[test]
fn combined_modifiers_empty_is_identity() {
let ae: ActiveEffects<TestEffect> = ActiveEffects::default();
let m = ae.combined_modifiers();
assert_eq!(m.speed_mult, 1.0);
assert_eq!(m.damage_per_sec, 0.0);
}
#[test]
fn combined_modifiers_speed_multiplied() {
let mut ae: ActiveEffects<TestEffect> = ActiveEffects::default();
ae.apply(TestEffect::Speed, 0, 10.0); ae.apply(TestEffect::Speed, 0, 10.0); let m = ae.combined_modifiers();
assert!((m.speed_mult - 1.2).abs() < 1e-5);
}
#[test]
fn combined_modifiers_damage_resistance_clamped_at_one() {
let mut ae: ActiveEffects<TestEffect> = ActiveEffects::default();
ae.apply(TestEffect::Resistance, 4, 10.0); ae.apply(TestEffect::Resistance, 4, 10.0); let m = ae.combined_modifiers();
assert!(m.damage_resistance <= 1.0);
}
#[test]
fn combined_modifiers_poison_additive() {
let mut ae: ActiveEffects<TestEffect> = ActiveEffects::default();
ae.apply(TestEffect::Poison, 0, 10.0); ae.apply(TestEffect::Speed, 0, 10.0); let m = ae.combined_modifiers();
assert!((m.damage_per_sec - 1.0).abs() < 1e-5);
assert!((m.speed_mult - 1.2).abs() < 1e-5);
}
#[test]
fn status_effect_color_default() {
assert_eq!(TestEffect::Speed.color(), [1.0, 1.0, 1.0, 1.0]);
}
#[test]
fn status_effect_is_beneficial_poison_is_harmful() {
assert!(!TestEffect::Poison.is_beneficial());
assert!(TestEffect::Speed.is_beneficial());
}
}