fixed first round effect and migrated logging

src/armour/mod.rs

@@ -238,7 +238,7 @@ fn generate_body_parts(
                         // TODO: Going to need this if irradiate is ever added
                         Immunity::Radiation => (),
                         // NOTE: It's an unreleased DOT temp, so the exact effect is currently
-                        // unknwown
+                        // unknown
                         Immunity::NerveGas => (),
                         Immunity::TearGas => {
                             player.insert(TempDebuffImmunity::<TearGas>::default());

src/effect.rs

@@ -68,8 +68,6 @@ pub struct Effects<'w, 's> {
     commands: Commands<'w, 's>,
 }
 
-// TODO: Schedule effects using commands in order to avoid the need for having a separate
-// `Schedule` dedicated to them.
 impl<'w, 's> Effects<'w, 's> {
     pub fn spawn_and_insert<T: Component + 'static>(
         &mut self,
@@ -203,6 +201,8 @@ pub(crate) fn run_effects(world: &mut World) {
         };
 
         for entity in entities {
+            let parent = world.entity(entity).get::<Parent>().unwrap().get();
+            world.entity_mut(parent).remove_child(entity);
             world.despawn(entity);
         }
     }
@@ -233,11 +233,11 @@ fn update_round_limited_effects(
             continue;
         }
 
+        effect.turns -= 1;
         if effect.turns == 0 {
             effects.remove(entity);
             continue;
         }
-        effect.turns -= 1;
     }
 }
 
@@ -291,9 +291,9 @@ pub(crate) fn configure(stages: &mut Stages) {
     stages.world.init_resource::<Clock>();
 
     stages.snapshot.add_systems(mark_permanent_effects);
+    stages.pre_turn.add_systems(advance_clock);
     stages
-        .pre_turn
+        .post_turn
-        .add_systems((advance_clock, update_round_limited_effects));
+        .add_systems((update_time_limited_effects, update_round_limited_effects));
-    stages.post_turn.add_systems(update_time_limited_effects);
     stages.restore.add_systems(remove_transient_effects);
 }

src/lib.rs

@@ -149,7 +149,7 @@ impl Simulation {
 
     pub fn truncate_log(&mut self) {
         let mut log = self.0.world.resource_mut::<Log>();
-        log.entries.clear();
+        log.clear();
     }
 
     pub fn set_metrics(&mut self, recording: bool) {
@@ -158,6 +158,16 @@ impl Simulation {
     }
 
     pub fn consume_metrics(&mut self) -> (Vec<dto::Counter>, Vec<dto::Histogram>) {
+        let entities = self.0.world.entities().len();
+        let components = self.0.world.components().len();
+        self.0
+            .world
+            .resource::<metrics::Metrics>()
+            .increment_counter(Entity::from_raw(0), "entities", entities.into());
+        self.0
+            .world
+            .resource::<metrics::Metrics>()
+            .increment_counter(Entity::from_raw(0), "components", components as u64);
         metrics::consume_metrics(&self.0.world)
     }
 
@@ -352,7 +362,7 @@ mod tests {
                         clip_size: 25,
                         rate_of_fire: [3, 5],
                     },
-                    mods: Vec::default(),
+                    mods: vec![WeaponMod::HairTrigger],
                     bonuses: vec![WeaponBonusInfo {
                         bonus: WeaponBonus::Expose,
                         value: 9.0,
@@ -431,17 +441,15 @@ mod tests {
 
     #[test]
     fn init_simulator() {
-        let mut sim = Simulation::new(attacker(), defender());
+        Simulation::new(attacker(), defender());
-        sim.run_once();
     }
 
     #[test]
     fn metrics() {
         let mut sim = Simulation::new(attacker(), defender());
         sim.set_metrics(true);
-        for _ in 0..20 {
         sim.run_once();
-        }
         sim.consume_metrics();
+        panic!();
     }
 }

src/log.rs

@@ -1,7 +1,6 @@
 use std::sync::Mutex;
 
 use bevy_ecs::{prelude::*, system::SystemParam};
-use macros::LogMessage;
 
 use crate::{
     entity_registry::EntityRegistry,
@@ -9,7 +8,7 @@ use crate::{
     player::stats::{
         AdditiveBonus, BaselineStat, CritRate, DamageBonus, Defence, Dexterity, EffectiveStat,
         MultiplicativeBonus, SimpleStatBaseline, SimpleStatBonus, SimpleStatEffective,
-        SimpleStatMarker, Speed, StatMarker, StatType, Strength, WeaponAccuracy,
+        SimpleStatMarker, Speed, StatMarker, Strength, WeaponAccuracy,
     },
     weapon::WeaponVerb,
     Stages,
@@ -19,14 +18,11 @@ use crate::{
 pub struct Logging(pub bool);
 
 #[derive(Event)]
-struct LogEvent(Mutex<Option<Box<dyn LogMessage>>>);
+struct LogEvent(Mutex<Option<DynamicLogMessage>>);
 
-impl<T> From<T> for LogEvent
+impl From<DynamicLogMessage> for LogEvent {
-where
+    fn from(value: DynamicLogMessage) -> Self {
-    T: LogMessage,
+        LogEvent(Mutex::new(Some(value)))
-{
-    fn from(value: T) -> Self {
-        Self(Mutex::new(Some(Box::new(value))))
     }
 }
 
@@ -53,6 +49,8 @@ pub enum LogValue<'a> {
     Debug(&'a (dyn std::fmt::Debug + Send + Sync)),
     Player(Entity),
     Weapon(Entity),
+    Array(Vec<LogValue<'a>>),
+    Map(Vec<(&'static str, LogValue<'a>)>),
 }
 
 impl<'a> From<String> for LogValue<'a> {
@@ -61,6 +59,12 @@ impl<'a> From<String> for LogValue<'a> {
     }
 }
 
+impl<'a> From<&'a str> for LogValue<'static> {
+    fn from(value: &'a str) -> Self {
+        Self::String(value.to_owned())
+    }
+}
+
 impl<'a> From<f32> for LogValue<'a> {
     fn from(value: f32) -> Self {
         Self::Float(value)
@@ -103,6 +107,24 @@ where
     }
 }
 
+impl<'a, V> From<Vec<V>> for LogValue<'a>
+where
+    V: Into<LogValue<'a>>,
+{
+    fn from(value: Vec<V>) -> Self {
+        LogValue::Array(value.into_iter().map(Into::into).collect())
+    }
+}
+
+impl<'a, V> From<Vec<(&'static str, V)>> for LogValue<'a>
+where
+    V: Into<LogValue<'a>>,
+{
+    fn from(value: Vec<(&'static str, V)>) -> Self {
+        LogValue::Map(value.into_iter().map(|(k, v)| (k, v.into())).collect())
+    }
+}
+
 #[cfg(feature = "json")]
 impl<'a> LogValue<'a> {
     fn to_value(&self, entity_registry: &EntityRegistry) -> serde_json::Value {
@@ -125,11 +147,19 @@ impl<'a> LogValue<'a> {
             LogValue::Entity(id) => {
                 serde_json::to_value(entity_registry.0.get(id).unwrap()).unwrap()
             }
+            LogValue::Array(items) => serde_json::Value::Array(
+                items.iter().map(|v| v.to_value(entity_registry)).collect(),
+            ),
+            LogValue::Map(map) => serde_json::Value::Object(
+                map.iter()
+                    .map(|(k, v)| ((*k).to_owned(), v.to_value(entity_registry)))
+                    .collect(),
+            ),
         }
     }
 }
 
-pub trait LogMessage: Send + Sync + 'static {
+trait LogMessage: Send + Sync + 'static {
     fn tag(&self) -> &'static str;
 
     fn entries(&self) -> Vec<(&'static str, LogValue<'_>)>;
@@ -137,7 +167,7 @@ pub trait LogMessage: Send + Sync + 'static {
 
 #[derive(Resource, Default)]
 pub struct Log {
-    pub entries: Vec<Box<dyn LogMessage>>,
+    entries: Vec<DynamicLogMessage>,
 
     pub expanded: bool,
 }
@@ -158,6 +188,10 @@ impl Log {
             ).collect::<Vec<_>>()
         })
     }
+
+    pub fn clear(&mut self) {
+        self.entries.clear();
+    }
 }
 
 impl std::fmt::Display for Log {
@@ -184,6 +218,7 @@ impl std::fmt::Display for Log {
                     LogValue::Player(id) | LogValue::Weapon(id) | LogValue::Entity(id) => {
                         write!(f, "{:?}", id)?
                     }
+                    LogValue::Array(_) | LogValue::Map(_) => (),
                 };
 
                 if fields.peek().is_some() {
@@ -391,10 +426,9 @@ pub struct Logger<'w> {
 }
 
 impl<'w> Logger<'w> {
-    pub fn log<B, M>(&mut self, body: B)
+    pub fn log<B>(&mut self, body: B)
     where
-        B: FnOnce() -> M,
+        B: FnOnce() -> DynamicLogMessage,
-        M: LogMessage,
     {
         if self.logging.0 {
             self.event_writer.send(body().into());
@@ -408,100 +442,10 @@ fn logging_enabled(logging: Res<Logging>) -> bool {
 
 fn append_log_messages(mut events: EventReader<LogEvent>, mut log: ResMut<Log>) {
     for event in events.read() {
-        log.entries.push(event.0.lock().unwrap().take().unwrap());
+        if let Some(entry) = event.0.lock().unwrap().take() {
+            log.entries.push(entry);
         }
     }
-
-#[derive(macros::LogMessage)]
-struct StatChange {
-    #[log(player)]
-    target: Entity,
-    #[log(debug)]
-    stat: StatType,
-
-    #[log(debug)]
-    effects_add: Vec<(&'static str, f32)>,
-
-    #[log(debug)]
-    effects_mult: Vec<(&'static str, f32)>,
-
-    baseline: f32,
-
-    effective: f32,
-}
-
-fn log_stat_changes<Stat: StatMarker>(
-    stat_q: Query<
-        (Entity, &BaselineStat<Stat>, &EffectiveStat<Stat>, &Children),
-        Changed<EffectiveStat<Stat>>,
-    >,
-    add_q: Query<&AdditiveBonus<Stat>>,
-    mult_q: Query<&MultiplicativeBonus<Stat>>,
-    mut logger: Logger,
-) {
-    for (player, baseline, effective, children) in stat_q.iter() {
-        let effects_add = add_q
-            .iter_many(children.get())
-            .map(|eff| (eff.label, eff.value))
-            .collect();
-        let effects_mult = mult_q
-            .iter_many(children.get())
-            .map(|eff| (eff.label, eff.value))
-            .collect();
-
-        logger.log(|| StatChange {
-            target: player,
-            stat: Stat::stat_type(),
-            effects_add,
-            effects_mult,
-            baseline: baseline.value,
-            effective: effective.value,
-        })
-    }
-}
-
-fn log_simple_stat_changes<Stat: SimpleStatMarker>(
-    stat_q: Query<
-        (
-            Entity,
-            &SimpleStatBaseline<Stat>,
-            &SimpleStatEffective<Stat>,
-            &Children,
-        ),
-        Changed<SimpleStatEffective<Stat>>,
-    >,
-    bonus_q: Query<&SimpleStatBonus<Stat>>,
-    mut logger: Logger,
-) where
-    Stat::ValueType: Into<LogValue<'static>>,
-    Stat::BonusType: std::fmt::Debug,
-{
-    #[derive(LogMessage)]
-    struct AppliedBonus {
-        #[log(debug)]
-        target: Entity,
-        #[log(display)]
-        stat: &'static str,
-        baseline: LogValue<'static>,
-        effective: LogValue<'static>,
-        #[log(debug)]
-        bonuses: Vec<(&'static str, String)>,
-    }
-
-    for (target, baseline, effective, children) in stat_q.iter() {
-        let bonuses = bonus_q
-            .iter_many(children.get())
-            .map(|eff| (eff.label, format!("{:?}", eff.value)))
-            .collect();
-
-        logger.log(|| AppliedBonus {
-            target,
-            stat: std::any::type_name::<Stat>(),
-            baseline: baseline.value.into(),
-            effective: effective.value.into(),
-            bonuses,
-        });
-    }
 }
 
 pub struct DynamicLogMessage {
@@ -547,18 +491,94 @@ macro_rules! log_values {
     (@ { $(,)* $($out:expr),* } $label:ident: %$val:expr, $($rest:tt)*) => {
         $crate::log_values!(@ { $($out),*, (stringify!($label),$crate::log::LogValue::String(format!("{}",$val))) } $($rest)*)
     };
+    (@ { $(,)* $($out:expr),* } $value:ident, $($rest:tt)*) => {
+        $crate::log_values!(@ { $($out),*, (stringify!($value),$value.into()) } $($rest)*)
+    };
+    (@ { $(,)* $($out:expr),* } ?$value:ident, $($rest:tt)*) => {
+        $crate::log_values!(@ { $($out),*, (stringify!($value),$crate::log::LogValue::String(format!("{:?}",$val))) } $($rest)*)
+    };
+    (@ { $(,)* $($out:expr),* } %$value:ident, $($rest:tt)*) => {
+        $crate::log_values!(@ { $($out),*, (stringify!($value),$crate::log::LogValue::String(format!("{}",$val))) } $($rest)*)
+    };
 
     ($($args:tt)* ) => {
         $crate::log_values!(@ { } $($args)*,)
     };
 }
 
+fn log_stat_changes<Stat: StatMarker>(
+    stat_q: Query<
+        (Entity, &BaselineStat<Stat>, &EffectiveStat<Stat>, &Children),
+        Changed<EffectiveStat<Stat>>,
+    >,
+    add_q: Query<&AdditiveBonus<Stat>>,
+    mult_q: Query<&MultiplicativeBonus<Stat>>,
+    mut logger: Logger,
+) {
+    for (player, baseline, effective, children) in stat_q.iter() {
+        let effects_add: Vec<_> = add_q
+            .iter_many(children.get())
+            .map(|bonus| (bonus.label, 100.0 * bonus.value))
+            .collect();
+        let effects_mult: Vec<_> = mult_q
+            .iter_many(children.get())
+            .map(|bonus| (bonus.label, 100.0 * bonus.value))
+            .collect();
+
+        log!(logger, "stat_change", {
+            target: player,
+            stat: ?Stat::stat_type(),
+            effects_add,
+            effects_mult,
+            baseline: baseline.value,
+            effective: effective.value,
+        });
+    }
+}
+
+fn log_simple_stat_changes<Stat: SimpleStatMarker>(
+    stat_q: Query<
+        (
+            Entity,
+            &SimpleStatBaseline<Stat>,
+            &SimpleStatEffective<Stat>,
+            &Children,
+        ),
+        Changed<SimpleStatEffective<Stat>>,
+    >,
+    bonus_q: Query<&SimpleStatBonus<Stat>>,
+    mut logger: Logger,
+) where
+    Stat::ValueType: Into<LogValue<'static>>,
+    Stat::BonusType: Into<LogValue<'static>>,
+{
+    for (target, baseline, effective, children) in stat_q.iter() {
+        let bonuses: Vec<_> = bonus_q
+            .iter_many(children.get())
+            .map(|bonus| (bonus.label, Stat::denormalise_bonus(bonus.value)))
+            .collect();
+
+        log!(logger, "applied_bonus", {
+            target,
+            stat: std::any::type_name::<Stat>(),
+            baseline: Stat::denormalise_value(baseline.value),
+            effective: Stat::denormalise_value(effective.value),
+            bonuses
+        });
+    }
+}
+
 pub(crate) fn configure(stages: &mut Stages) {
     stages.world.insert_resource(Log::default());
     stages.world.insert_resource(Logging(false));
     stages.add_event::<LogEvent>();
 
-    stages.post_turn.add_systems(append_log_messages);
+    stages
+        .post_turn
+        .add_systems(append_log_messages.run_if(logging_enabled));
+    stages
+        .post_fight
+        .add_systems(append_log_messages.run_if(logging_enabled));
     stages.turn.add_systems(
         (
             log_stat_changes::<Strength>,

src/passives.rs

@@ -2,8 +2,9 @@ use bevy_ecs::prelude::*;
 
 use crate::{
     effect::Effects,
-    player::stats::{
+    player::{
-        AdditiveBonus, CritRate, Defence, Dexterity, SimpleStatBonus, Speed, Strength,
+        stats::{AdditiveBonus, CritRate, Defence, Dexterity, SimpleStatBonus, Speed, Strength},
+        BodyPart,
     },
     Stages,
 };
@@ -191,6 +192,20 @@ pub enum DrugCooldown {
     Vicodin,
 }
 
+#[derive(Clone, Copy)]
+pub enum EducationPartDamageBonus {
+    Bio2380,
+}
+
+impl EducationPartDamageBonus {
+    pub fn dmg_bonus(self, part: BodyPart) -> Option<f32> {
+        match part {
+            BodyPart::Throat => Some(0.10),
+            _ => None,
+        }
+    }
+}
+
 #[derive(Bundle, Default)]
 pub(crate) struct PassiveBundle {
     pub merits: Merits,

src/player/mod.rs

@@ -9,9 +9,9 @@ use crate::{
     log,
     log::Logger,
     metrics::Metrics,
-    passives::{Education, FactionUpgrades, Merits},
+    passives::{EducationPartDamageBonus, FactionUpgrades, Merits},
     weapon::{
-        bonus::MultiTurnBonus,
+        bonus::{BonusPartDamageBonus, MultiTurnBonus},
         temp::{NonTargeted, Uses},
         Ammo, DamageProcEffect, DamageStat, NeedsReload, RateOfFire, TurnTriggeredEffect, Usable,
         Weapon, WeaponSlot,
@@ -172,6 +172,24 @@ pub enum FightEndType {
     Loss,
 }
 
+#[derive(Component)]
+pub enum PartDamageBonus {
+    Education(EducationPartDamageBonus),
+    WeaponBonus {
+        value: f32,
+        bonus: BonusPartDamageBonus,
+    },
+}
+
+impl PartDamageBonus {
+    pub fn dmg_bonus(&self, part: BodyPart) -> Option<f32> {
+        match self {
+            Self::Education(edu) => edu.dmg_bonus(part),
+            Self::WeaponBonus { value, bonus } => bonus.dmg_bonus(part, *value),
+        }
+    }
+}
+
 #[derive(Bundle)]
 pub struct PlayerBundle {
     pub name: Name,
@@ -341,7 +359,6 @@ pub fn use_damaging_weapon(
             &SimpleStatEffective<CritRate>,
             &SimpleStatEffective<WeaponAccuracy>,
             &SimpleStatEffective<DamageBonus>,
-            &Education,
             Has<Attacker>,
         ),
         (With<Player>, With<Current>),
@@ -357,7 +374,7 @@ pub fn use_damaging_weapon(
         With<CurrentTarget>,
     >,
     armour_q: Query<&armour::ArmourBodyPart>,
-    damage_proc_q: Query<&DamageProcEffect>,
+    (damage_proc_q, part_bonus_q): (Query<&DamageProcEffect>, Query<&PartDamageBonus>),
     (mut ammo_q, mut temp_q): (
         Query<(
             &mut Ammo,
@@ -367,18 +384,19 @@ pub fn use_damaging_weapon(
         )>,
         Query<&mut Uses>,
     ),
-    (mut logger, mut commands, dmg_spread, metrics): (
+    (mut logger, mut commands, dmg_spread, metrics, mut effects): (
         Logger,
         Commands,
         Local<DamageSpread>,
         Res<Metrics>,
+        Effects,
     ),
 ) {
     let Ok((weapon, w_dmg, acc, dmg_bonus, crit, children, non_targeted)) = weapon_q.get_single()
     else {
         return;
     };
-    let (player, player_spd, player_str, player_crit, acc_bonus, p_dmg_bonus, edu, attacker) =
+    let (player, player_spd, player_str, player_crit, acc_bonus, p_dmg_bonus, attacker) =
         player_q.single();
     let (target, target_dex, target_def, armour_parts, mut health) = target_q.single_mut();
 
@@ -457,6 +475,7 @@ pub fn use_damaging_weapon(
                 actor: player,
                 recipient: target,
                 rounds: rounds,
+                hit_chance: hit_chance,
             });
             metrics.increment_counter(player, "miss", 1);
             metrics.increment_counter(weapon, "miss", 1);
@@ -494,13 +513,17 @@ pub fn use_damaging_weapon(
             let piece = rng.sample(armour_parts);
             let armour_mitigation = piece.map_or(0.0, |p| p.armour_value);
 
-            // NOTE: The beta distribution is defined on [0,1], so we rescale here
+            // 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 = rng.sample(dmg_spread.0) / 10.0 + 1.0;
 
             let mut dmg_bonus = dmg_bonus + p_dmg_bonus;
 
-            if edu.bio2380 && body_part == BodyPart::Throat {
+            for part_bonus in part_bonus_q.iter_many(children.get()) {
-                dmg_bonus.value += 0.10;
+                if let Some(bonus) = part_bonus.dmg_bonus(body_part) {
+                    dmg_bonus.value += bonus;
+                }
             }
 
             // TODO: special ammo
@@ -519,11 +542,13 @@ pub fn use_damaging_weapon(
 
             if dmg > 0 {
                 for effect in damage_proc_q.iter_many(children.get()) {
-                    match effect {
+                    match *effect {
-                        DamageProcEffect::MultiTurn { value, bonus }
+                        DamageProcEffect::MultiTurn { value, bonus } => {
-                            if multi_attack_proc.is_none() =>
+                            if multi_attack_proc.is_some() {
-                        {
+                                continue;
-                            if rng.gen_bool((*value / 100.0) as f64) {
+                            }
+                            let chance = (value / 100.0) as f64;
+                            if chance > 1.0 || rng.gen_bool(chance) {
                                 match bonus {
                                     MultiTurnBonus::Blindfire => {
                                         multi_attack_proc = Some(MultiAttack::Blindfire)
@@ -545,7 +570,18 @@ pub fn use_damaging_weapon(
                                 metrics.increment_counter(weapon, bonus.counter_label(), 1);
                             }
                         }
-                        _ => (),
+                        DamageProcEffect::SelfEffect { value, bonus } => {
+                            let chance = (value / 100.0) as f64;
+                            if chance > 1.0 || rng.gen_bool(chance) {
+                                bonus.spawn(player, &mut effects);
+                            }
+                        }
+                        DamageProcEffect::OpponentEffect { value, bonus } => {
+                            let chance = (value / 100.0) as f64;
+                            if chance > 1.0 || rng.gen_bool(chance) {
+                                bonus.spawn(target, &mut effects, &mut rng.0);
+                            }
+                        }
                     }
                 }
             }
@@ -561,6 +597,7 @@ pub fn use_damaging_weapon(
                 part: %body_part,
                 part_mult: mult,
                 dmg: dmg,
+                rounds: rounds,
                 health_before: health_before,
                 health_after: health.value,
                 dmg_spread: dmg_spread,
@@ -584,7 +621,7 @@ pub fn use_damaging_weapon(
                         FightEndType::Victory
                     } else {
                         FightEndType::Loss
-                    }
+                    },
                 });
                 metrics.increment_counter(player, "victory", 1);
             }
@@ -613,7 +650,7 @@ pub fn use_damaging_weapon(
 }
 
 pub fn check_stalemate(
-    current_q: Query<(Entity, &CombatTurns, Option<&Attacker>), (With<Current>, With<Player>)>,
+    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>,
@@ -622,14 +659,14 @@ pub fn check_stalemate(
     metrics: Res<Metrics>,
 ) {
     let (current, current_turns, attacker) = current_q.single();
-    if *state == FightStatus::Ongoing && current_turns.0 >= 25 && attacker.is_some() {
+    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
+            fight_end_type: %FightEndType::Stalemate,
         });
         metrics.increment_counter(current, "stalemate", 1);
 

src/player/stats.rs

@@ -10,6 +10,12 @@ pub trait SimpleStatMarker: Send + Sync + 'static {
 
     fn apply_bonus(value: Self::ValueType, bonus: Self::BonusType) -> Self::ValueType;
     fn revert_bonus(value: Self::ValueType, bonus: Self::BonusType) -> Self::ValueType;
+    fn denormalise_value(value: Self::ValueType) -> Self::ValueType {
+        value
+    }
+    fn denormalise_bonus(value: Self::BonusType) -> Self::BonusType {
+        value
+    }
 }
 
 #[derive(Component)]
@@ -143,6 +149,12 @@ impl SimpleStatMarker for AmmoControl {
     fn revert_bonus(value: Self::ValueType, bonus: Self::BonusType) -> Self::ValueType {
         value - bonus
     }
+    fn denormalise_value(value: Self::ValueType) -> Self::ValueType {
+        value * 100.0
+    }
+    fn denormalise_bonus(value: Self::BonusType) -> Self::BonusType {
+        value * 100.0
+    }
 }
 
 #[derive(Default)]
@@ -157,6 +169,12 @@ impl SimpleStatMarker for DamageBonus {
     fn revert_bonus(value: Self::ValueType, bonus: Self::BonusType) -> Self::ValueType {
         value - bonus
     }
+    fn denormalise_value(value: Self::ValueType) -> Self::ValueType {
+        value * 100.0
+    }
+    fn denormalise_bonus(value: Self::BonusType) -> Self::BonusType {
+        value * 100.0
+    }
 }
 
 #[derive(Default)]
@@ -171,6 +189,12 @@ impl SimpleStatMarker for WeaponAccuracy {
     fn revert_bonus(value: Self::ValueType, bonus: Self::BonusType) -> Self::ValueType {
         value - bonus
     }
+    fn denormalise_value(value: Self::ValueType) -> Self::ValueType {
+        value * 50.0 + 50.0
+    }
+    fn denormalise_bonus(value: Self::BonusType) -> Self::BonusType {
+        value * 50.0
+    }
 }
 
 #[derive(Default)]
@@ -490,7 +514,7 @@ fn apply_simple_stat_bonus<Stat: SimpleStatMarker>(
     effect_q: Query<(&SimpleStatBonus<Stat>, &Parent)>,
     mut stat_q: Query<&mut SimpleStatEffective<Stat>>,
 ) {
-    for (bonus, target) in effect_q.iter_many(entities) {
+    for (bonus, target) in effect_q.iter_many(&entities) {
         let mut effective = stat_q.get_mut(target.get()).unwrap();
         effective.value = Stat::apply_bonus(effective.value, bonus.value);
     }
@@ -568,5 +592,6 @@ pub(crate) fn configure(stages: &mut Stages) {
     register_simple_stat_effects::<DamageBonus>(stages);
     register_simple_stat_effects::<WeaponAccuracy>(stages);
     register_simple_stat_effects::<ClipSize>(stages);
+    register_simple_stat_effects::<Clips>(stages);
     register_simple_stat_effects::<Health>(stages);
 }

src/player/status_effect.rs

@@ -1,12 +1,12 @@
 use std::{collections::VecDeque, marker::PhantomData};
 
 use bevy_ecs::prelude::*;
-use macros::LogMessage;
 use rand::Rng as _;
 
 use crate::{
     effect::{Effects, TimeLimitedEffect},
     hierarchy::{HierarchyBuilder, Parent},
+    log,
     log::Logger,
     weapon::temp::AssociatedWeapon,
     Rng, Stages,
@@ -117,7 +117,7 @@ impl DebuffingTempMarker for Sand {
 #[derive(Component)]
 struct LinkedComponents<const N: usize>([Entity; N]);
 
-trait Stats<const N: usize> {
+pub trait Stats<const N: usize> {
     fn spawn_additive_effects(
         effects: &mut Effects,
         target: Entity,
@@ -160,15 +160,18 @@ impl_n_stats!(2, A, B);
 impl_n_stats!(3, A, B, C);
 impl_n_stats!(4, A, B, C, D);
 
-trait AdditiveStatusEffectMarker<const N: usize>: Send + Sync + 'static {
+// TODO: the const generic arguably isn't worth the trouble and it might be better to remove it
+pub trait AdditiveStatusEffectMarker<const N: usize>: Send + Sync + 'static {
     type AffectedStats: Stats<N>;
     fn max_stack() -> usize;
     fn factor() -> f32;
     fn duration() -> f32;
 }
 
+// TODO: instead of tracking it in the status effect itself, add generic
+// `StatusEffectEffectiveness` and `StatusEffectExtraDuration` components
 #[derive(Component)]
-struct AdditiveStatusEffect<const N: usize, M>
+pub struct AdditiveStatusEffect<const N: usize, M>
 where
     M: AdditiveStatusEffectMarker<N>,
 {
@@ -187,16 +190,6 @@ impl<const N: usize, M: AdditiveStatusEffectMarker<N>> Default for AdditiveStatu
     }
 }
 
-impl<const N: usize, M: AdditiveStatusEffectMarker<N>> AdditiveStatusEffect<N, M> {
-    pub fn new(extra_effectiveness: f32, extra_duration: f32) -> Self {
-        Self {
-            marker: PhantomData,
-            extra_effectiveness,
-            extra_duration,
-        }
-    }
-}
-
 pub struct Withered;
 
 impl AdditiveStatusEffectMarker<1> for Withered {
@@ -368,8 +361,14 @@ fn apply_additive_status_effect<const N: usize, M: AdditiveStatusEffectMarker<N>
     mut parent_q: Query<Option<&mut StatusEffectStack<M>>>,
     mut commands: Commands,
     mut effects: Effects,
+    mut logger: Logger,
 ) {
     for (entity, player, effect) in effect_q.iter_many(entities) {
+        log!(logger, "apply_status_effect", {
+            recipient: player.get(),
+            effect: std::any::type_name::<M>(),
+        });
+
         let stack = parent_q.get_mut(player.get()).unwrap();
 
         let new_effects = <M::AffectedStats as Stats<N>>::spawn_additive_effects(
@@ -434,24 +433,13 @@ fn apply_temp_debuff_effect<Temp: DebuffingTempMarker>(
     (mut commands, mut effects): (Commands, Effects),
     mut logger: Logger,
 ) {
-    #[derive(LogMessage)]
-    pub struct UsedDebuffTemp {
-        #[log(player)]
-        pub actor: Entity,
-        #[log(player)]
-        pub recipient: Entity,
-        #[log(weapon)]
-        pub weapon: Entity,
-        pub immune: bool,
-    }
-
     for (effect, player, weapon) in temp_q.iter_many(entities) {
         let (stack, immunity) = parent_q.get_mut(player.get()).unwrap();
         let user = weapon_q.get(weapon.0).unwrap();
         if immunity {
             commands.entity(effect).despawn();
             commands.entity(player.get()).remove_child(effect);
-            logger.log(|| UsedDebuffTemp {
+            log!(logger, "used_debuff_temp", {
                 actor: user.get(),
                 recipient: player.get(),
                 weapon: weapon.0,
@@ -488,7 +476,7 @@ fn apply_temp_debuff_effect<Temp: DebuffingTempMarker>(
                 });
         }
 
-        logger.log(|| UsedDebuffTemp {
+        log!(logger, "used_debuff_temp", {
             actor: user.get(),
             recipient: player.get(),
             weapon: weapon.0,
@@ -505,14 +493,6 @@ fn remove_temp_debuff_effect<Temp: DebuffingTempMarker>(
     _logger: Logger,
     mut effects: Effects,
 ) {
-    #[derive(LogMessage)]
-    struct RemovedDebuffTemp {
-        #[log(player)]
-        recipient: Entity,
-        factor: f32,
-        factor_remaining: f32,
-    }
-
     for player in temp_q.iter_many(entities) {
         let (mut stack, immunity) = parent_q.get_mut(player.get()).unwrap();
         if immunity {

src/weapon/bonus.rs

@@ -3,10 +3,16 @@ use bevy_ecs::prelude::*;
 use crate::{
     effect::{Effects, TurnLimitedEffect},
     hierarchy::{HierarchyBuilder, Parent},
-    player::stats::{
+    player::{
+        stats::{
             AdditiveBonus, AmmoControl, Clips, CritRate, DamageBonus, SimpleStatBonus,
             SimpleStatEffective, Speed, Strength, WeaponAccuracy,
         },
+        status_effect::{
+            AdditiveStatusEffect, Crippled, Demoralise, Frozen, Motivate, Slow, Weakened, Withered,
+        },
+        BodyPart, PartDamageBonus,
+    },
     Stages,
 };
 
@@ -155,6 +161,117 @@ impl MultiTurnBonus {
     }
 }
 
+#[derive(Clone, Copy)]
+pub enum OpponentStatusEffect {
+    Cripple,
+    // TODO: implement for group fights
+    Demoralise,
+    Freeze,
+    Slow,
+    Toxin,
+    Weaken,
+    Wither,
+}
+
+impl OpponentStatusEffect {
+    pub fn spawn(self, target: Entity, effects: &mut Effects, rng: &mut impl rand::Rng) {
+        match self {
+            Self::Cripple => {
+                effects.spawn(AdditiveStatusEffect::<1, Crippled>::default(), target);
+            }
+            Self::Demoralise => {
+                effects.spawn(AdditiveStatusEffect::<4, Demoralise>::default(), target);
+            }
+            Self::Freeze => {
+                effects.spawn(AdditiveStatusEffect::<2, Frozen>::default(), target);
+            }
+            Self::Slow => {
+                effects.spawn(AdditiveStatusEffect::<1, Slow>::default(), target);
+            }
+            Self::Toxin => match rng.gen_range(0..4) {
+                0 => OpponentStatusEffect::Cripple.spawn(target, effects, rng),
+                1 => OpponentStatusEffect::Slow.spawn(target, effects, rng),
+                2 => OpponentStatusEffect::Weaken.spawn(target, effects, rng),
+                _ => OpponentStatusEffect::Wither.spawn(target, effects, rng),
+            },
+            Self::Weaken => {
+                effects.spawn(AdditiveStatusEffect::<1, Weakened>::default(), target);
+            }
+            Self::Wither => {
+                effects.spawn(AdditiveStatusEffect::<1, Withered>::default(), target);
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum SelfStatusEffect {
+    Motivate,
+}
+
+impl SelfStatusEffect {
+    pub fn spawn(self, current: Entity, effects: &mut Effects) {
+        match self {
+            Self::Motivate => {
+                effects.spawn(AdditiveStatusEffect::<4, Motivate>::default(), current);
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum BonusPartDamageBonus {
+    Achilles,
+    Crusher,
+    Cupid,
+    Deadeye,
+    Roshambo,
+    Throttle,
+}
+
+impl BonusPartDamageBonus {
+    pub fn dmg_bonus(self, part: BodyPart, value: f32) -> Option<f32> {
+        match self {
+            Self::Achilles => match part {
+                BodyPart::LeftFoot | BodyPart::RightFoot => Some(value),
+                _ => None,
+            },
+            Self::Crusher => {
+                if part == BodyPart::Head {
+                    Some(value)
+                } else {
+                    None
+                }
+            }
+            Self::Cupid => {
+                if part == BodyPart::Heart {
+                    Some(value)
+                } else {
+                    None
+                }
+            }
+            Self::Deadeye => match part {
+                BodyPart::Head | BodyPart::Heart | BodyPart::Throat => Some(value),
+                _ => None,
+            },
+            Self::Roshambo => {
+                if part == BodyPart::Groin {
+                    Some(value)
+                } else {
+                    None
+                }
+            }
+            Self::Throttle => {
+                if part == BodyPart::Throat {
+                    Some(value)
+                } else {
+                    None
+                }
+            }
+        }
+    }
+}
+
 pub(crate) fn prepare_bonuses(
     bonus_q: Query<(
         &Parent,
@@ -278,6 +395,121 @@ pub(crate) fn prepare_bonuses(
                     .set_parent(weapon.get());
             }
 
+            WeaponBonus::Achilles => {
+                commands
+                    .spawn(PartDamageBonus::WeaponBonus {
+                        value: value.0 / 100.0,
+                        bonus: BonusPartDamageBonus::Achilles,
+                    })
+                    .set_parent(weapon.get());
+            }
+            WeaponBonus::Cupid => {
+                commands
+                    .spawn(PartDamageBonus::WeaponBonus {
+                        value: value.0 / 100.0,
+                        bonus: BonusPartDamageBonus::Cupid,
+                    })
+                    .set_parent(weapon.get());
+            }
+            WeaponBonus::Crusher => {
+                commands
+                    .spawn(PartDamageBonus::WeaponBonus {
+                        value: value.0 / 100.0,
+                        bonus: BonusPartDamageBonus::Crusher,
+                    })
+                    .set_parent(weapon.get());
+            }
+            WeaponBonus::Deadeye => {
+                commands
+                    .spawn(PartDamageBonus::WeaponBonus {
+                        value: value.0 / 100.0,
+                        bonus: BonusPartDamageBonus::Deadeye,
+                    })
+                    .set_parent(weapon.get());
+            }
+            WeaponBonus::Throttle => {
+                commands
+                    .spawn(PartDamageBonus::WeaponBonus {
+                        value: value.0 / 100.0,
+                        bonus: BonusPartDamageBonus::Throttle,
+                    })
+                    .set_parent(weapon.get());
+            }
+            WeaponBonus::Roshambo => {
+                commands
+                    .spawn(PartDamageBonus::WeaponBonus {
+                        value: value.0 / 100.0,
+                        bonus: BonusPartDamageBonus::Roshambo,
+                    })
+                    .set_parent(weapon.get());
+            }
+
+            WeaponBonus::Cripple => {
+                commands
+                    .spawn(DamageProcEffect::OpponentEffect {
+                        value: value.0,
+                        bonus: OpponentStatusEffect::Cripple,
+                    })
+                    .set_parent(weapon.get());
+            }
+            WeaponBonus::Demoralise => {
+                commands
+                    .spawn(DamageProcEffect::OpponentEffect {
+                        value: value.0,
+                        bonus: OpponentStatusEffect::Demoralise,
+                    })
+                    .set_parent(weapon.get());
+            }
+            WeaponBonus::Freeze => {
+                commands
+                    .spawn(DamageProcEffect::OpponentEffect {
+                        value: value.0,
+                        bonus: OpponentStatusEffect::Freeze,
+                    })
+                    .set_parent(weapon.get());
+            }
+            WeaponBonus::Slow => {
+                commands
+                    .spawn(DamageProcEffect::OpponentEffect {
+                        value: value.0,
+                        bonus: OpponentStatusEffect::Slow,
+                    })
+                    .set_parent(weapon.get());
+            }
+            WeaponBonus::Toxin => {
+                commands
+                    .spawn(DamageProcEffect::OpponentEffect {
+                        value: value.0,
+                        bonus: OpponentStatusEffect::Toxin,
+                    })
+                    .set_parent(weapon.get());
+            }
+            WeaponBonus::Weaken => {
+                commands
+                    .spawn(DamageProcEffect::OpponentEffect {
+                        value: value.0,
+                        bonus: OpponentStatusEffect::Weaken,
+                    })
+                    .set_parent(weapon.get());
+            }
+            WeaponBonus::Wither => {
+                commands
+                    .spawn(DamageProcEffect::OpponentEffect {
+                        value: value.0,
+                        bonus: OpponentStatusEffect::Wither,
+                    })
+                    .set_parent(weapon.get());
+            }
+
+            WeaponBonus::Motivate => {
+                commands
+                    .spawn(DamageProcEffect::SelfEffect {
+                        value: value.0,
+                        bonus: SelfStatusEffect::Motivate,
+                    })
+                    .set_parent(weapon.get());
+            }
+
             val => unimplemented!("{val:?}"),
         }
     }

src/weapon/mod.rs

@@ -1,22 +1,24 @@
 use bevy_ecs::prelude::*;
-use macros::LogMessage;
 
 use crate::{
     effect::{Effects, TurnLimitedEffect},
     hierarchy::{HierarchyBuilder, Parent},
+    log,
     log::Logger,
-    passives::{Education, FactionUpgrades, Merits},
+    passives::{Education, EducationPartDamageBonus, FactionUpgrades, Merits},
     player::{
         stats::{
             AdditiveBonus, AmmoControl, ClipSize, Clips, CritRate, DamageBonus, Dexterity,
             SimpleStatBonus, SimpleStatBundle, SimpleStatEffective, WeaponAccuracy,
         },
-        Current, Weapons,
+        Current, PartDamageBonus, Weapons,
     },
     Id, Name, Stages,
 };
 
-use self::bonus::{FirstTurnBonus, MultiTurnBonus, TurnTriggeredBonus};
+use self::bonus::{
+    FirstTurnBonus, MultiTurnBonus, OpponentStatusEffect, SelfStatusEffect, TurnTriggeredBonus,
+};
 
 pub mod bonus;
 pub mod temp;
@@ -58,7 +60,7 @@ pub enum WeaponCategory {
     Smg,
     Shotgun,
     Pistol,
-    Club,
+    Clubbing,
     Piercing,
     Slashing,
     Mechanical,
@@ -110,7 +112,7 @@ pub enum WeaponMod {
     FullChoke,
     RecoilPad,
     StandardBrake,
-    HeavyDutyBreak,
+    HeavyDutyBrake,
     TacticalBrake,
     SmallLight,
     PrecisionLight,
@@ -220,11 +222,6 @@ pub enum FirstTurnEffect {
     Bonus { value: f32, bonus: FirstTurnBonus },
 }
 
-#[derive(Component)]
-pub enum DamageProcEffect {
-    MultiTurn { value: f32, bonus: MultiTurnBonus },
-}
-
 impl FirstTurnEffect {
     fn spawn(&self, effects: &mut Effects, weapon: Entity, owner: Entity) {
         match self {
@@ -234,31 +231,28 @@ impl FirstTurnEffect {
     }
 }
 
+#[derive(Component)]
+pub enum DamageProcEffect {
+    MultiTurn {
+        value: f32,
+        bonus: MultiTurnBonus,
+    },
+    OpponentEffect {
+        value: f32,
+        bonus: OpponentStatusEffect,
+    },
+    SelfEffect {
+        value: f32,
+        bonus: SelfStatusEffect,
+    },
+}
+
 #[derive(Component)]
 pub struct EquippedMods(pub Vec<WeaponMod>);
 
 #[derive(Component)]
 pub struct Experience(pub f32);
 
-#[derive(LogMessage)]
-pub struct ReloadWeapon {
-    #[log(player)]
-    pub actor: Entity,
-    #[log(weapon)]
-    pub weapon: Entity,
-}
-
-#[derive(LogMessage)]
-pub struct MissTarget {
-    #[log(player)]
-    pub actor: Entity,
-    #[log(player)]
-    pub recipient: Entity,
-    #[log(weapon)]
-    pub weapon: Entity,
-    pub rounds: Option<u16>,
-}
-
 #[derive(Bundle)]
 pub struct WeaponBundle {
     pub usable: Usable,
@@ -514,7 +508,7 @@ fn apply_passives(
                         weapon,
                     );
                 }
-                WeaponMod::HeavyDutyBreak => {
+                WeaponMod::HeavyDutyBrake => {
                     effects.spawn(
                         SimpleStatBonus::<WeaponAccuracy>::new("heavy duty brake", 1.25 / 50.0),
                         weapon,
@@ -595,7 +589,7 @@ fn apply_passives(
                 merits.pistol_mastery,
                 education.cbt2840.then_some("CBT2840"),
             ),
-            WeaponCategory::Club => (merits.club_mastery, None),
+            WeaponCategory::Clubbing => (merits.club_mastery, None),
             WeaponCategory::Piercing => (merits.piercing_mastery, None),
             WeaponCategory::Slashing => (merits.slashing_mastery, None),
             WeaponCategory::Mechanical => (merits.mechanical_mastery, None),
@@ -644,6 +638,14 @@ fn apply_passives(
             effects.spawn(SimpleStatBonus::<DamageBonus>::new("HIS2160", 0.10), weapon);
         }
 
+        if education.bio2380 {
+            commands
+                .spawn(PartDamageBonus::Education(
+                    EducationPartDamageBonus::Bio2380,
+                ))
+                .set_parent(weapon);
+        }
+
         if mastery > 0 {
             effects.spawn(
                 SimpleStatBonus::<WeaponAccuracy>::new("mastery", (mastery as f32) * 0.2 / 50.0),
@@ -697,9 +699,9 @@ fn reload_weapon(
         ammo.0 = clip_size.value;
         clips.value -= 1;
 
-        logger.log(|| ReloadWeapon {
+        log!(logger, "reload_weapon", {
             actor: player.get(),
-            weapon,
+            weapon
         });
 
         commands.entity(weapon).remove::<NeedsReload>();
@@ -735,12 +737,10 @@ fn apply_first_turn_effects(
 
 pub(crate) fn configure(stages: &mut Stages) {
     stages.equip.add_systems(set_owner);
-    stages.pre_fight.add_systems((
+    // running this in the snapshot layer ensures that the stat increases aren't restored at the
-        apply_passives,
+    // end of the run
-        apply_first_turn_effects
+    stages.snapshot.add_systems(apply_first_turn_effects);
-            .after(apply_passives)
+    stages.pre_fight.add_systems(apply_passives);
-            .after(bonus::prepare_bonuses),
-    ));
     stages.turn.add_systems(reload_weapon);
     stages.post_turn.add_systems(unset_current);
     stages