From e5ffc7586bf0879bbecbccd0d117600f5658d72b Mon Sep 17 00:00:00 2001
From: M1thieu <mathieupierreadrien@gmail.com>
Date: Sun, 21 Sep 2025 13:13:37 +0200
Subject: [PATCH 1/8] Restore Scorers clamping behavior

Reverts panic-on-invalid-input back to automatic clamping for production safety.
Prevents crashes from floating-point drift, config errors, and FixedScore edge cases.

I did try a little and faced an issue whereas I did not with this one my bad here
---
 crates/systems/ai/src/core/scorers.rs | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/crates/systems/ai/src/core/scorers.rs b/crates/systems/ai/src/core/scorers.rs
index 3a41fc3..8f39696 100644
--- a/crates/systems/ai/src/core/scorers.rs
+++ b/crates/systems/ai/src/core/scorers.rs
@@ -24,14 +24,9 @@ impl Score {
 
     /// Set the `Score`'s value.
     ///
-    /// ### Panics
-    ///
-    /// Panics if `value` isn't within `0.0..=1.0`.
+    /// Values outside `0.0..=1.0` will be automatically clamped to the valid range.
     pub fn set(&mut self, value: f32) {
-        if !(0.0..=1.0).contains(&value) {
-            panic!("Score value must be between 0.0 and 1.0");
-        }
-        self.0 = value;
+        self.0 = value.clamp(0.0, 1.0);
     }
 
     /// Set the `Score`'s value. Allows values outside the range `0.0..=1.0`

From e538bd396011a0234b37e05d5358a7ef0d5c4a4e Mon Sep 17 00:00:00 2001
From: M1thieu <mathieupierreadrien@gmail.com>
Date: Fri, 26 Sep 2025 04:57:17 +0200
Subject: [PATCH 2/8] Refactor Stabilise Systemic Physics Math

- Guard wave helpers against zero vectors and apply displacement from rest pose

- Fix wave solver chunking, force accumulation, and basic ai if-let

- Harden ai need decay, weighted product, and save reflection
---
 crates/energy/src/waves/oscillation.rs        | 13 ++++-
 crates/energy/src/waves/propagation.rs        | 27 +++++++--
 crates/energy/src/waves/superposition.rs      | 25 ++++++--
 crates/energy/src/waves/wave_equation.rs      | 58 +++++++++++--------
 crates/forces/src/core/newton_laws.rs         |  8 +++
 crates/systems/ai/src/core/measures.rs        |  6 +-
 crates/systems/ai/src/drives/needs.rs         | 18 ++++--
 crates/systems/save_system/src/save_system.rs | 56 +++++++++---------
 examples/basic_ai.rs                          |  3 +-
 9 files changed, 140 insertions(+), 74 deletions(-)

diff --git a/crates/energy/src/waves/oscillation.rs b/crates/energy/src/waves/oscillation.rs
index a23414e..e026932 100644
--- a/crates/energy/src/waves/oscillation.rs
+++ b/crates/energy/src/waves/oscillation.rs
@@ -1,5 +1,14 @@
 use bevy::prelude::*;
 
+#[inline]
+fn normalize_or(vec: Vec2, fallback: Vec2) -> Vec2 {
+    if vec.length_squared() > f32::EPSILON {
+        vec.normalize()
+    } else {
+        fallback
+    }
+}
+
 /// Wave parameters for configuring wave behavior
 #[derive(Component, Debug, Clone, Copy, Reflect)]
 pub struct WaveParameters {
@@ -68,13 +77,13 @@ impl WaveParameters {
 
     /// Fluent interface for setting direction
     pub fn with_direction(mut self, direction: Vec2) -> Self {
-        self.direction = direction.normalize();
+        self.direction = normalize_or(direction, self.direction);
         self
     }
 
     /// Fluent interface for setting displacement axis
     pub fn with_displacement_axis(mut self, displacement_axis: Vec2) -> Self {
-        self.displacement_axis = displacement_axis.normalize();
+        self.displacement_axis = normalize_or(displacement_axis, self.displacement_axis);
         self
     }
 
diff --git a/crates/energy/src/waves/propagation.rs b/crates/energy/src/waves/propagation.rs
index cd9415d..079c614 100644
--- a/crates/energy/src/waves/propagation.rs
+++ b/crates/energy/src/waves/propagation.rs
@@ -1,6 +1,15 @@
 use super::oscillation::{WaveParameters, angular_frequency, wave_number};
 use bevy::prelude::*;
 
+#[inline]
+fn normalize_or(vec: Vec2, fallback: Vec2) -> Vec2 {
+    if vec.length_squared() > f32::EPSILON {
+        vec.normalize()
+    } else {
+        fallback
+    }
+}
+
 // Calculate modified angular frequency with dispersion
 #[inline]
 pub fn dispersive_angular_frequency(params: &WaveParameters, k: f32) -> f32 {
@@ -52,7 +61,8 @@ pub fn solve_wave(params: &WaveParameters, position: Vec2, time: f32) -> f32 {
     let k = wave_number(params.wavelength);
     let omega = dispersive_angular_frequency(params, k);
 
-    let k_vec = params.direction.normalize() * k;
+    let direction = normalize_or(params.direction, Vec2::X);
+    let k_vec = direction * k;
     let dot_product = k_vec.dot(position);
 
     // Calculate the phase argument for the wave function
@@ -106,6 +116,8 @@ pub fn update_wave_displacements(
     let t = time.elapsed_secs();
 
     for (mut transform, params, position, wave_type) in query.iter_mut() {
+        let base_translation = Vec3::new(position.0.x, position.0.y, transform.translation.z);
+
         let displacement = match wave_type {
             Some(WaveType::Radial) => {
                 // Find the nearest wave center
@@ -128,9 +140,10 @@ pub fn update_wave_displacements(
             _ => solve_wave(params, position.0, t),
         };
 
-        let displacement_vec = params.displacement_axis.normalize() * displacement;
-        transform.translation.x += displacement_vec.x;
-        transform.translation.y += displacement_vec.y;
+        let displacement_axis = normalize_or(params.displacement_axis, Vec2::Y);
+        let displacement_vec = displacement_axis * displacement;
+        transform.translation =
+            base_translation + Vec3::new(displacement_vec.x, displacement_vec.y, 0.0);
     }
 }
 
@@ -145,13 +158,15 @@ pub fn create_linear_wave(
     damping: f32,
     dispersion_factor: f32,
 ) -> WaveParameters {
+    let current = WaveParameters::default();
+
     WaveParameters {
         amplitude,
         wavelength,
         speed,
         phase,
-        direction: direction.normalize(),
-        displacement_axis: displacement_axis.normalize(),
+        direction: normalize_or(direction, current.direction),
+        displacement_axis: normalize_or(displacement_axis, current.displacement_axis),
         damping,
         dispersion_factor,
     }
diff --git a/crates/energy/src/waves/superposition.rs b/crates/energy/src/waves/superposition.rs
index 6757faa..80c2958 100644
--- a/crates/energy/src/waves/superposition.rs
+++ b/crates/energy/src/waves/superposition.rs
@@ -2,6 +2,15 @@ use super::oscillation::{WaveParameters, angular_frequency, wave_number};
 use super::propagation::WavePosition;
 use bevy::prelude::*;
 
+#[inline]
+fn normalize_or(vec: Vec2, fallback: Vec2) -> Vec2 {
+    if vec.length_squared() > f32::EPSILON {
+        vec.normalize()
+    } else {
+        fallback
+    }
+}
+
 #[inline]
 pub fn solve_standing_wave(
     params: &WaveParameters,
@@ -12,7 +21,7 @@ pub fn solve_standing_wave(
     let k = wave_number(params.wavelength);
     let omega = angular_frequency(params.speed, k);
 
-    let direction = params.direction.normalize();
+    let direction = normalize_or(params.direction, Vec2::X);
     let spatial_term = (k * direction.dot(position) + params.phase).sin();
     let temporal_term = (omega * time).cos();
 
@@ -37,10 +46,12 @@ pub fn update_standing_waves(
     let t = time.elapsed_secs();
 
     for (mut transform, params, position) in query.iter_mut() {
+        let base_translation = Vec3::new(position.0.x, position.0.y, transform.translation.z);
         let displacement = solve_standing_wave(params, position.0, t, None::<fn(f32) -> f32>);
-        let displacement_vec = params.displacement_axis.normalize() * displacement;
-        transform.translation.x += displacement_vec.x;
-        transform.translation.y += displacement_vec.y;
+        let displacement_axis = normalize_or(params.displacement_axis, Vec2::Y);
+        let displacement_vec = displacement_axis * displacement;
+        transform.translation =
+            base_translation + Vec3::new(displacement_vec.x, displacement_vec.y, 0.0);
     }
 }
 
@@ -72,13 +83,15 @@ pub fn create_standing_wave_parameters(
     damping: f32,
     dispersion_factor: f32,
 ) -> WaveParameters {
+    let defaults = WaveParameters::default();
+
     WaveParameters {
         amplitude,
         wavelength,
         speed: frequency * wavelength,
         phase,
-        direction: direction.normalize(),
-        displacement_axis: displacement_axis.normalize(),
+        direction: normalize_or(direction, defaults.direction),
+        displacement_axis: normalize_or(displacement_axis, defaults.displacement_axis),
         damping,
         dispersion_factor,
     }
diff --git a/crates/energy/src/waves/wave_equation.rs b/crates/energy/src/waves/wave_equation.rs
index d5c2a97..2e1412c 100644
--- a/crates/energy/src/waves/wave_equation.rs
+++ b/crates/energy/src/waves/wave_equation.rs
@@ -89,31 +89,39 @@ impl WaveEquation2D {
         const CHUNK_SIZE: usize = 32;
 
         // Optimize memory access patterns by processing in blocks
-        for j_chunk in 1..((self.ny - 1).div_ceil(CHUNK_SIZE)) {
-            let j_start = (j_chunk - 1) * CHUNK_SIZE + 1;
-            let j_end = (j_start + CHUNK_SIZE - 1).min(self.ny - 2);
-
-            for i_chunk in 1..((self.nx - 1).div_ceil(CHUNK_SIZE)) {
-                let i_start = (i_chunk - 1) * CHUNK_SIZE + 1;
-                let i_end = (i_start + CHUNK_SIZE - 1).min(self.nx - 2);
-
-                for j in j_start..=j_end {
-                    for i in i_start..=i_end {
-                        // Finite difference formula for 2D wave equation
-                        let laplacian_x = self.get(&self.u_current, i + 1, j)
-                            - 2.0 * self.get(&self.u_current, i, j)
-                            + self.get(&self.u_current, i - 1, j);
-
-                        let laplacian_y = self.get(&self.u_current, i, j + 1)
-                            - 2.0 * self.get(&self.u_current, i, j)
-                            + self.get(&self.u_current, i, j - 1);
-
-                        let next_value = 2.0 * self.get(&self.u_current, i, j)
-                            - self.get(&self.u_previous, i, j)
-                            + cx * laplacian_x
-                            + cy * laplacian_y;
-
-                        self.set(&mut u_next, i, j, next_value);
+        let inner_height = self.ny.saturating_sub(2);
+        let inner_width = self.nx.saturating_sub(2);
+
+        if inner_height > 0 && inner_width > 0 {
+            let j_chunks = (inner_height + CHUNK_SIZE - 1) / CHUNK_SIZE;
+            let i_chunks = (inner_width + CHUNK_SIZE - 1) / CHUNK_SIZE;
+
+            for j_chunk in 0..j_chunks {
+                let j_start = 1 + j_chunk * CHUNK_SIZE;
+                let j_end = (j_start + CHUNK_SIZE - 1).min(self.ny - 2);
+
+                for i_chunk in 0..i_chunks {
+                    let i_start = 1 + i_chunk * CHUNK_SIZE;
+                    let i_end = (i_start + CHUNK_SIZE - 1).min(self.nx - 2);
+
+                    for j in j_start..=j_end {
+                        for i in i_start..=i_end {
+                            // Finite difference formula for 2D wave equation
+                            let laplacian_x = self.get(&self.u_current, i + 1, j)
+                                - 2.0 * self.get(&self.u_current, i, j)
+                                + self.get(&self.u_current, i - 1, j);
+
+                            let laplacian_y = self.get(&self.u_current, i, j + 1)
+                                - 2.0 * self.get(&self.u_current, i, j)
+                                + self.get(&self.u_current, i, j - 1);
+
+                            let next_value = 2.0 * self.get(&self.u_current, i, j)
+                                - self.get(&self.u_previous, i, j)
+                                + cx * laplacian_x
+                                + cy * laplacian_y;
+
+                            self.set(&mut u_next, i, j, next_value);
+                        }
                     }
                 }
             }
diff --git a/crates/forces/src/core/newton_laws.rs b/crates/forces/src/core/newton_laws.rs
index 4b9b5b7..26a0f5e 100644
--- a/crates/forces/src/core/newton_laws.rs
+++ b/crates/forces/src/core/newton_laws.rs
@@ -159,6 +159,11 @@ pub fn apply_forces(time: Res<Time>, mut query: Query<(&Mass, &mut Velocity, &mu
             continue;
         }
 
+        if force.is_expired() {
+            force.force = Vec3::ZERO;
+            continue;
+        }
+
         let acceleration = force.force * mass.inverse();
 
         // Cap extremely high accelerations to prevent instability
@@ -171,6 +176,9 @@ pub fn apply_forces(time: Res<Time>, mut query: Query<(&Mass, &mut Velocity, &mu
 
         velocity.linvel += acceleration * dt;
         force.elapsed += dt;
+
+        // Clear accumulated force so subsequent systems can rebuild it per-frame
+        force.force = Vec3::ZERO;
     }
 }
 
diff --git a/crates/systems/ai/src/core/measures.rs b/crates/systems/ai/src/core/measures.rs
index d0edb2e..009366f 100644
--- a/crates/systems/ai/src/core/measures.rs
+++ b/crates/systems/ai/src/core/measures.rs
@@ -32,9 +32,13 @@ pub struct WeightedProduct;
 
 impl Measure for WeightedProduct {
     fn calculate(&self, scores: Vec<(&Score, f32)>) -> f32 {
+        if scores.is_empty() {
+            return 0.0;
+        }
+
         scores
             .iter()
-            .fold(0f32, |acc, (score, weight)| acc * score.0 * weight)
+            .fold(1.0f32, |acc, (score, weight)| acc * score.0 * weight)
     }
 }
 
diff --git a/crates/systems/ai/src/drives/needs.rs b/crates/systems/ai/src/drives/needs.rs
index 9849b46..8083f48 100644
--- a/crates/systems/ai/src/drives/needs.rs
+++ b/crates/systems/ai/src/drives/needs.rs
@@ -34,6 +34,15 @@ impl Need {
         }
     }
 
+    /// Apply depletion based on elapsed time
+    pub fn decay(&mut self, delta_secs: f32) {
+        if delta_secs <= 0.0 || self.depletion_rate <= 0.0 {
+            return;
+        }
+
+        self.satisfaction = (self.satisfaction - self.depletion_rate * delta_secs).max(0.0);
+    }
+
     /// Calculate need urgency as utility score
     pub fn urgency(&self) -> UtilityScore {
         UtilityScore::new((1.0 - self.satisfaction) * self.priority)
@@ -48,7 +57,7 @@ impl Need {
 /// System for updating needs over time
 pub fn update_needs(time: Res<Time>, mut needs: Query<&mut Need>) {
     for mut need in &mut needs {
-        need.satisfaction = (need.satisfaction - need.depletion_rate * time.delta_secs()).max(0.0);
+        need.decay(time.delta_secs());
     }
 }
 
@@ -73,9 +82,8 @@ pub fn get_most_urgent_need(
 
 impl AIModule for Need {
     fn update(&mut self) {
-        // Naturally decrease satisfaction over time
-        // (Note: Full implementation would use time delta)
-        self.satisfaction = (self.satisfaction - self.depletion_rate * 0.01).max(0.0);
+        // Clamp to valid range; depletion is handled by systems with proper delta time
+        self.satisfaction = self.satisfaction.clamp(0.0, 1.0);
     }
 
     fn utility(&self) -> UtilityScore {
@@ -83,5 +91,3 @@ impl AIModule for Need {
         self.urgency()
     }
 }
-
-//TODO: Adding a NeedTracker to monitor and manage needs over time, would be in systems/ai/src/trackers/needs_tracker.rs
diff --git a/crates/systems/save_system/src/save_system.rs b/crates/systems/save_system/src/save_system.rs
index cf75d74..c871b06 100644
--- a/crates/systems/save_system/src/save_system.rs
+++ b/crates/systems/save_system/src/save_system.rs
@@ -307,32 +307,36 @@ pub fn save_game_data(
 
         if let Ok(entity_ref) = world.get_entity(entity) {
             for component_id in entity_ref.archetype().components() {
-                if let Some(component_info) = world.components().get_info(component_id) {
-                    if let Some(type_registration) =
-                        type_registry.get(component_info.type_id().unwrap())
-                    {
-                        if let Some(reflect_serialize) =
-                            type_registration.data::<ReflectSerialize>()
-                        {
-                            let component_name =
-                                type_registration.type_info().type_path().to_string();
-
-                            if component_name.contains("Saveable") {
-                                continue;
-                            }
-
-                            if let Some(reflect_component) =
-                                type_registration.data::<ReflectComponent>()
-                            {
-                                if let Some(reflected) = reflect_component.reflect(entity_ref) {
-                                    let serializable =
-                                        reflect_serialize.get_serializable(reflected);
-                                    if let Ok(value) = serde_json::to_value(&*serializable) {
-                                        entity_data.insert(component_name, value);
-                                    }
-                                }
-                            }
-                        }
+                let Some(component_info) = world.components().get_info(component_id) else {
+                    continue;
+                };
+
+                let Some(type_id) = component_info.type_id() else {
+                    continue;
+                };
+
+                let Some(type_registration) = type_registry.get(type_id) else {
+                    continue;
+                };
+
+                let Some(reflect_serialize) = type_registration.data::<ReflectSerialize>() else {
+                    continue;
+                };
+
+                let component_name = type_registration.type_info().type_path().to_string();
+
+                if component_name.contains("Saveable") {
+                    continue;
+                }
+
+                let Some(reflect_component) = type_registration.data::<ReflectComponent>() else {
+                    continue;
+                };
+
+                if let Some(reflected) = reflect_component.reflect(entity_ref) {
+                    let serializable = reflect_serialize.get_serializable(reflected);
+                    if let Ok(value) = serde_json::to_value(&*serializable) {
+                        entity_data.insert(component_name, value);
                     }
                 }
             }
diff --git a/examples/basic_ai.rs b/examples/basic_ai.rs
index 3381fa5..9791b88 100644
--- a/examples/basic_ai.rs
+++ b/examples/basic_ai.rs
@@ -283,8 +283,7 @@ fn update_creatures_and_perception(
                     }
 
                     // Use direct distance approach (Relations queries will be added in future systems)
-                    if direct_target.is_some() {
-                        let food_pos = direct_target.unwrap();
+                    if let Some(food_pos) = direct_target {
                         let direction = (food_pos - position).normalize_or_zero();
 
                         // Movement speed influenced by evolved personality traits

From 8a6ab896123ac3a0b195d6e2867c8bc9b6091d21 Mon Sep 17 00:00:00 2001
From: M1thieu <mathieupierreadrien@gmail.com>
Date: Fri, 26 Sep 2025 05:07:59 +0200
Subject: [PATCH 3/8] Streamline Workflow Setup

---
 .github/contributing.md   |  6 ++++--
 .github/workflows/ci.yaml | 19 +++++++++----------
 2 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/.github/contributing.md b/.github/contributing.md
index 483535f..985a0a1 100644
--- a/.github/contributing.md
+++ b/.github/contributing.md
@@ -39,9 +39,11 @@ Before submitting a pull request:
 
 2. **Follow Code Standards:** Ensure your code adheres to LP's coding standards.
 
-3. **Provide Unit Tests:** Include relevant unit tests for new features or changes.
+3. **Run Local Checks:** Before opening a pull request, run `cargo fmt`, `cargo clippy --workspace`, and `cargo test --workspace` so CI time stays focused on regressions instead of formatting or lint fixes.
 
-4. **Document Changes:** Update documentation to reflect any modifications made.
+4. **Provide Unit Tests:** Include relevant unit tests for new features or changes.
+
+5. **Document Changes:** Update documentation to reflect any modifications made.
 
 ## Communicating with Developers
 
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index f243f63..91f983c 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -6,12 +6,16 @@ on:
   pull_request:
     branches: [main]
 
+permissions:
+  contents: read
+
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 env:
   CARGO_TERM_COLOR: always
+  DEBIAN_FRONTEND: noninteractive
 
 jobs:
   test:
@@ -28,13 +32,13 @@ jobs:
       - name: Cache dependencies
         uses: Swatinem/rust-cache@v2
         with:
-          shared-key: test-suite
+          shared-key: workspace
       
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
       
       - name: Install system dependencies
-        run: sudo apt-get update && sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev clang lld
+        run: sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev clang lld
       
       - name: Quick check
         run: cargo check --workspace
@@ -62,7 +66,7 @@ jobs:
       - name: Cache dependencies
         uses: Swatinem/rust-cache@v2
         with:
-          shared-key: clippy-lint
+          shared-key: workspace
       
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
@@ -70,7 +74,7 @@ jobs:
           components: clippy
       
       - name: Install system dependencies
-        run: sudo apt-get update && sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev clang lld
+        run: sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev clang lld
       
       - name: Run clippy
         run: cargo clippy --workspace -- -A clippy::upper-case-acronyms -A clippy::manual-flatten -A clippy::excessive-precision -A clippy::too-many-arguments
@@ -83,15 +87,10 @@ jobs:
       - name: Checkout sources
         uses: actions/checkout@v4
       
-      - name: Cache dependencies
-        uses: Swatinem/rust-cache@v2
-        with:
-          shared-key: format-check
-      
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
         with:
           components: rustfmt
       
       - name: Check formatting
-        run: cargo fmt --all -- --check
\ No newline at end of file
+        run: cargo fmt --all -- --check

From e0977aa1d594f2c63a7068b0b425d4d9200b6426 Mon Sep 17 00:00:00 2001
From: M1thieu <mathieupierreadrien@gmail.com>
Date: Sat, 4 Oct 2025 20:05:58 +0200
Subject: [PATCH 4/8] Upgrade to Bevy 0.17

- Update all crates from bevy 0.16 to 0.17
- Migrate Event to Message for internal communication
- Add #[reflect(Component)] annotations
- Update reflection serialization API
- Fix component iterator dereferencing

Closes #135
---
 Cargo.toml                                      |  4 ++--
 crates/energy/Cargo.toml                        |  2 +-
 crates/energy/src/conservation.rs               |  6 ++++--
 crates/energy/src/electromagnetism/fields.rs    |  8 +++++---
 crates/energy/src/electromagnetism/mod.rs       |  2 +-
 crates/energy/src/thermodynamics/entropy.rs     |  2 ++
 crates/energy/src/thermodynamics/equilibrium.rs |  2 ++
 crates/energy/src/thermodynamics/mod.rs         |  2 +-
 crates/energy/src/thermodynamics/thermal.rs     | 10 +++++++---
 crates/energy/src/waves/mod.rs                  |  2 +-
 crates/energy/src/waves/oscillation.rs          |  5 +++--
 crates/energy/src/waves/propagation.rs          |  3 +++
 crates/energy/src/waves/superposition.rs        |  7 ++++---
 crates/energy/src/waves/wave_equation.rs        |  1 +
 crates/forces/Cargo.toml                        |  2 +-
 crates/forces/src/core/gravity.rs               |  4 ++++
 crates/forces/src/core/newton_laws.rs           |  9 ++++++---
 crates/information/Cargo.toml                   |  4 ++--
 crates/information/src/fractals/renderer.rs     |  2 +-
 crates/matter/Cargo.toml                        |  2 +-
 crates/systems/Cargo.toml                       |  4 ++--
 crates/systems/acoustics/Cargo.toml             |  2 +-
 crates/systems/ai/Cargo.toml                    |  4 ++--
 crates/systems/pbmpm/Cargo.toml                 |  2 +-
 crates/systems/save_system/Cargo.toml           |  2 +-
 crates/systems/save_system/src/save_system.rs   | 13 +++++--------
 examples/basic_ai.rs                            |  4 ++--
 examples/basic_forces.rs                        |  2 +-
 28 files changed, 67 insertions(+), 45 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 5c3899b..d60e5a9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,7 @@ forces = { path = "crates/forces" }
 information = { path = "crates/information" }
 matter = { path = "crates/matter" }
 
-bevy = { version = "0.16", features = ["dynamic_linking"] }
+bevy = { version = "0.17", features = ["dynamic_linking"] }
 
 glam = "0.29.2"
 
@@ -41,4 +41,4 @@ serde = "1.0"
 serde_json = "1.0"
 
 # rand for picking random values
-rand = "0.9"
\ No newline at end of file
+rand = "0.9"
diff --git a/crates/energy/Cargo.toml b/crates/energy/Cargo.toml
index 30f4947..00a97f2 100644
--- a/crates/energy/Cargo.toml
+++ b/crates/energy/Cargo.toml
@@ -5,4 +5,4 @@ edition = "2024"
 description = "Core systems governing how energy manifests, transforms and flows."
 
 [dependencies]
-bevy = "0.16"
\ No newline at end of file
+bevy = "0.17"
diff --git a/crates/energy/src/conservation.rs b/crates/energy/src/conservation.rs
index 5c76e42..2545916 100644
--- a/crates/energy/src/conservation.rs
+++ b/crates/energy/src/conservation.rs
@@ -14,6 +14,7 @@ pub enum EnergyType {
 
 /// Component tracking energy in a system
 #[derive(Component, Debug, Clone, Copy, Reflect)]
+#[reflect(Component)]
 pub struct EnergyQuantity {
     /// Energy amount in joules
     pub value: f32,
@@ -70,7 +71,7 @@ pub enum TransactionType {
 }
 
 /// Event for energy transfers between entities
-#[derive(Event, Debug)]
+#[derive(Message, Debug)]
 pub struct EnergyTransferEvent {
     /// Source entity losing energy
     pub source: Entity,
@@ -84,6 +85,7 @@ pub struct EnergyTransferEvent {
 
 /// Component for precise energy accounting
 #[derive(Component, Debug, Reflect)]
+#[reflect(Component)]
 pub struct EnergyAccountingLedger {
     /// History of all transactions, newest first
     pub transactions: Vec<EnergyTransaction>,
@@ -244,6 +246,6 @@ impl Plugin for EnergyConservationPlugin {
             // Add resources
             .init_resource::<EnergyConservationTracker>()
             // Add event channel
-            .add_event::<EnergyTransferEvent>();
+            .add_message::<EnergyTransferEvent>();
     }
 }
diff --git a/crates/energy/src/electromagnetism/fields.rs b/crates/energy/src/electromagnetism/fields.rs
index 241cfc3..46e1281 100644
--- a/crates/energy/src/electromagnetism/fields.rs
+++ b/crates/energy/src/electromagnetism/fields.rs
@@ -6,6 +6,7 @@ pub const MAGNETIC_CONSTANT_DIV_4PI: f32 = 1e-7;
 
 /// Represents an electric field component
 #[derive(Component, Debug, Clone, Copy, Reflect, Default)]
+#[reflect(Component)]
 pub struct ElectricField {
     /// Magnitude and direction of the electric field
     pub field: Vec2,
@@ -52,6 +53,7 @@ impl ElectricField {
 
 /// Represents a magnetic field component
 #[derive(Component, Debug, Clone, Copy, Reflect, Default)]
+#[reflect(Component)]
 pub struct MagneticField {
     /// Magnitude and direction of the magnetic field
     pub field: Vec2,
@@ -107,7 +109,7 @@ impl MagneticField {
 }
 
 /// Event for field interactions
-#[derive(Event, Debug)]
+#[derive(Message, Debug)]
 pub struct ElectromagneticFieldInteractionEvent {
     /// Source entity generating the field
     pub source: Entity,
@@ -119,7 +121,7 @@ pub struct ElectromagneticFieldInteractionEvent {
 
 /// System for calculating field interactions
 pub fn calculate_field_interactions(
-    mut field_interaction_events: EventWriter<ElectromagneticFieldInteractionEvent>,
+    mut field_interaction_events: MessageWriter<ElectromagneticFieldInteractionEvent>,
     electric_fields: Query<(Entity, &ElectricField)>,
     magnetic_fields: Query<(Entity, &MagneticField)>,
 ) {
@@ -172,7 +174,7 @@ impl Plugin for ElectromagneticFieldPlugin {
             .register_type::<ElectricField>()
             .register_type::<MagneticField>()
             // Add electromagnetic field interaction event
-            .add_event::<ElectromagneticFieldInteractionEvent>()
+            .add_message::<ElectromagneticFieldInteractionEvent>()
             // Add system for field interactions
             .add_systems(Update, calculate_field_interactions);
     }
diff --git a/crates/energy/src/electromagnetism/mod.rs b/crates/energy/src/electromagnetism/mod.rs
index c9f04da..97c307a 100644
--- a/crates/energy/src/electromagnetism/mod.rs
+++ b/crates/energy/src/electromagnetism/mod.rs
@@ -11,7 +11,7 @@ impl Plugin for ElectromagnetismPlugin {
             .register_type::<fields::MagneticField>()
             .register_type::<interactions::ElectromagneticWave>()
             .register_type::<interactions::MaterialProperties>()
-            .add_event::<fields::ElectromagneticFieldInteractionEvent>()
+            .add_message::<fields::ElectromagneticFieldInteractionEvent>()
             .add_systems(Update, fields::calculate_field_interactions);
     }
 }
diff --git a/crates/energy/src/thermodynamics/entropy.rs b/crates/energy/src/thermodynamics/entropy.rs
index 4d7c9eb..0dca535 100644
--- a/crates/energy/src/thermodynamics/entropy.rs
+++ b/crates/energy/src/thermodynamics/entropy.rs
@@ -2,6 +2,7 @@ use bevy::prelude::*;
 
 /// Entropy component for thermodynamic systems
 #[derive(Component, Debug, Clone, Copy, Reflect)]
+#[reflect(Component)]
 pub struct Entropy {
     /// Entropy in J/K
     pub value: f32,
@@ -17,6 +18,7 @@ impl Entropy {
 
 /// Process reversibility characteristic
 #[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Reflect)]
+#[reflect(Component)]
 pub enum Reversibility {
     Reversible,
     Irreversible,
diff --git a/crates/energy/src/thermodynamics/equilibrium.rs b/crates/energy/src/thermodynamics/equilibrium.rs
index c469a86..acc4619 100644
--- a/crates/energy/src/thermodynamics/equilibrium.rs
+++ b/crates/energy/src/thermodynamics/equilibrium.rs
@@ -2,6 +2,7 @@ use bevy::prelude::*;
 
 /// Component marking systems in thermal equilibrium
 #[derive(Component, Debug, Reflect)]
+#[reflect(Component)]
 pub struct ThermalEquilibrium {
     pub connected_entities: Vec<Entity>,
     /// Equilibrium group ID for transitivity tracking
@@ -12,6 +13,7 @@ pub struct ThermalEquilibrium {
 /// and the matter crate is implemented
 /// This is a placeholder for the actual phase state representation
 #[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Reflect)]
+#[reflect(Component)]
 pub enum PhaseState {
     Solid,
     Liquid,
diff --git a/crates/energy/src/thermodynamics/mod.rs b/crates/energy/src/thermodynamics/mod.rs
index f6215e9..a7e4f59 100644
--- a/crates/energy/src/thermodynamics/mod.rs
+++ b/crates/energy/src/thermodynamics/mod.rs
@@ -23,7 +23,7 @@ impl Plugin for ThermodynamicsPlugin {
             .register_type::<entropy::Reversibility>()
             .register_type::<equilibrium::ThermalEquilibrium>()
             .register_type::<equilibrium::PhaseState>()
-            .add_event::<thermal::ThermalTransferEvent>()
+            .add_message::<thermal::ThermalTransferEvent>()
             .configure_sets(
                 Update,
                 (
diff --git a/crates/energy/src/thermodynamics/thermal.rs b/crates/energy/src/thermodynamics/thermal.rs
index 46aa6aa..1cafd29 100644
--- a/crates/energy/src/thermodynamics/thermal.rs
+++ b/crates/energy/src/thermodynamics/thermal.rs
@@ -5,6 +5,7 @@ pub const STEFAN_BOLTZMANN: f32 = 5.67e-8; // W/(m²·K⁴)
 
 /// Temperature component for thermal systems
 #[derive(Component, Debug, Clone, Copy, Reflect, Default)]
+#[reflect(Component)]
 pub struct Temperature {
     /// Temperature in Kelvin
     pub value: f32,
@@ -36,6 +37,7 @@ impl Temperature {
 
 /// Thermal conductivity property
 #[derive(Component, Debug, Clone, Copy, Reflect, Default)]
+#[reflect(Component)]
 pub struct ThermalConductivity {
     /// W/(m·K)
     pub value: f32,
@@ -43,6 +45,7 @@ pub struct ThermalConductivity {
 
 /// Thermal diffusivity property
 #[derive(Component, Debug, Clone, Copy, Reflect, Default)]
+#[reflect(Component)]
 pub struct ThermalDiffusivity {
     /// m²/s
     pub value: f32,
@@ -63,6 +66,7 @@ impl ThermalDiffusivity {
 
 /// Emissivity property for radiation calculations
 #[derive(Component, Debug, Clone, Copy, Reflect, Default)]
+#[reflect(Component)]
 pub struct Emissivity {
     /// Dimensionless value between 0.0 and 1.0
     /// 0.0 = perfect reflector, 1.0 = perfect emitter (black body)
@@ -78,7 +82,7 @@ impl Emissivity {
 }
 
 /// Event for thermal energy transfer between entities
-#[derive(Event, Debug)]
+#[derive(Message, Debug)]
 pub struct ThermalTransferEvent {
     /// Source entity losing thermal energy
     pub source: Entity,
@@ -90,7 +94,7 @@ pub struct ThermalTransferEvent {
 
 /// System for calculating heat conduction between entities
 pub fn calculate_thermal_transfer(
-    mut thermal_transfer_events: EventWriter<ThermalTransferEvent>,
+    mut thermal_transfer_events: MessageWriter<ThermalTransferEvent>,
     query: Query<(Entity, &Temperature, &ThermalConductivity)>,
 ) {
     // Use query.iter_combinations() to efficiently compare all entities
@@ -157,7 +161,7 @@ impl Plugin for ThermalSystemPlugin {
             .register_type::<ThermalDiffusivity>()
             .register_type::<Emissivity>()
             // Add thermal transfer event channel
-            .add_event::<ThermalTransferEvent>()
+            .add_message::<ThermalTransferEvent>()
             // Add system for thermal calculations
             .add_systems(Update, calculate_thermal_transfer);
     }
diff --git a/crates/energy/src/waves/mod.rs b/crates/energy/src/waves/mod.rs
index d535ec8..8b1e76c 100644
--- a/crates/energy/src/waves/mod.rs
+++ b/crates/energy/src/waves/mod.rs
@@ -16,7 +16,7 @@ impl Plugin for WavesPlugin {
             .register_type::<propagation::WaveCenterMarker>()
             .register_type::<superposition::StandingWaveMarker>()
             .register_type::<wave_equation::WaveEquationComponent>()
-            .add_event::<oscillation::WaveGenerationEvent>()
+            .add_message::<oscillation::WaveGenerationEvent>()
             .add_systems(
                 Update,
                 (
diff --git a/crates/energy/src/waves/oscillation.rs b/crates/energy/src/waves/oscillation.rs
index e026932..89f63bf 100644
--- a/crates/energy/src/waves/oscillation.rs
+++ b/crates/energy/src/waves/oscillation.rs
@@ -11,6 +11,7 @@ fn normalize_or(vec: Vec2, fallback: Vec2) -> Vec2 {
 
 /// Wave parameters for configuring wave behavior
 #[derive(Component, Debug, Clone, Copy, Reflect)]
+#[reflect(Component)]
 pub struct WaveParameters {
     /// Wave propagation speed (units/second)
     pub speed: f32,
@@ -122,7 +123,7 @@ pub fn damping_from_half_life(half_life: f32) -> f32 {
 }
 
 /// Event for wave generation or modification
-#[derive(Event, Debug)]
+#[derive(Message, Debug)]
 pub struct WaveGenerationEvent {
     /// Parameters of the generated wave
     pub parameters: WaveParameters,
@@ -131,7 +132,7 @@ pub struct WaveGenerationEvent {
 }
 
 /// System for wave parameter validation
-pub fn validate_wave_parameters(mut wave_generation_events: EventReader<WaveGenerationEvent>) {
+pub fn validate_wave_parameters(mut wave_generation_events: MessageReader<WaveGenerationEvent>) {
     for event in wave_generation_events.read() {
         // Validate wave parameters
         assert!(
diff --git a/crates/energy/src/waves/propagation.rs b/crates/energy/src/waves/propagation.rs
index 079c614..7dee9ec 100644
--- a/crates/energy/src/waves/propagation.rs
+++ b/crates/energy/src/waves/propagation.rs
@@ -28,6 +28,7 @@ pub fn dispersive_angular_frequency(params: &WaveParameters, k: f32) -> f32 {
 
 /// Component to store position for wave calculations
 #[derive(Component, Debug, Clone, Reflect)]
+#[reflect(Component)]
 pub struct WavePosition(pub Vec2);
 
 impl WavePosition {
@@ -46,6 +47,7 @@ impl WavePosition {
 
 /// Wave type marker component
 #[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Reflect)]
+#[reflect(Component)]
 pub enum WaveType {
     Traveling,
     Radial,
@@ -54,6 +56,7 @@ pub enum WaveType {
 
 // Marker component for wave centers (for radial waves)
 #[derive(Component, Reflect)]
+#[reflect(Component)]
 pub struct WaveCenterMarker;
 
 #[inline]
diff --git a/crates/energy/src/waves/superposition.rs b/crates/energy/src/waves/superposition.rs
index 80c2958..6f9cb4c 100644
--- a/crates/energy/src/waves/superposition.rs
+++ b/crates/energy/src/waves/superposition.rs
@@ -36,6 +36,7 @@ pub fn solve_standing_wave(
 
 /// Marker component for standing waves
 #[derive(Component, Reflect, Default)]
+#[reflect(Component)]
 pub struct StandingWaveMarker;
 
 /// System for updating standing waves specifically
@@ -56,7 +57,7 @@ pub fn update_standing_waves(
 }
 
 /// Event for standing wave modifications
-#[derive(Event)]
+#[derive(Message)]
 pub struct StandingWaveModificationEvent {
     pub entity: Entity,
     pub new_parameters: WaveParameters,
@@ -65,7 +66,7 @@ pub struct StandingWaveModificationEvent {
 /// System to handle wave parameter modifications
 pub fn handle_wave_modifications(
     mut commands: Commands,
-    mut wave_mod_events: EventReader<StandingWaveModificationEvent>,
+    mut wave_mod_events: MessageReader<StandingWaveModificationEvent>,
 ) {
     for event in wave_mod_events.read() {
         commands.entity(event.entity).insert(event.new_parameters);
@@ -103,7 +104,7 @@ pub struct StandingWavePlugin;
 impl Plugin for StandingWavePlugin {
     fn build(&self, app: &mut App) {
         app.register_type::<StandingWaveMarker>()
-            .add_event::<StandingWaveModificationEvent>()
+            .add_message::<StandingWaveModificationEvent>()
             .add_systems(Update, (update_standing_waves, handle_wave_modifications));
     }
 }
diff --git a/crates/energy/src/waves/wave_equation.rs b/crates/energy/src/waves/wave_equation.rs
index 2e1412c..9ae3f1a 100644
--- a/crates/energy/src/waves/wave_equation.rs
+++ b/crates/energy/src/waves/wave_equation.rs
@@ -146,6 +146,7 @@ impl WaveEquation2D {
 
 /// Component wrapper for the wave equation
 #[derive(Component, Reflect)]
+#[reflect(Component)]
 pub struct WaveEquationComponent {
     pub solver: WaveEquation2D,
 }
diff --git a/crates/forces/Cargo.toml b/crates/forces/Cargo.toml
index 67c46b2..6d569bb 100644
--- a/crates/forces/Cargo.toml
+++ b/crates/forces/Cargo.toml
@@ -5,4 +5,4 @@ edition = "2024"
 description = "Fundamental interaction mechanisms that create relationships between entities and drive dynamic behaviors across scales."
 
 [dependencies]
-bevy = "0.16"
\ No newline at end of file
+bevy = "0.17"
diff --git a/crates/forces/src/core/gravity.rs b/crates/forces/src/core/gravity.rs
index 282cb94..378b9ac 100644
--- a/crates/forces/src/core/gravity.rs
+++ b/crates/forces/src/core/gravity.rs
@@ -33,18 +33,22 @@ impl Default for UniformGravity {
 
 /// Component for entities affected by gravity
 #[derive(Component, Debug, Clone, Copy, Reflect)]
+#[reflect(Component)]
 pub struct GravityAffected;
 
 /// Marker component for gravity field measurement points
 #[derive(Component, Debug, Clone, Copy, Reflect)]
+#[reflect(Component)]
 pub struct GravityFieldMarker;
 
 /// Component for objects that generate gravitational attraction
 #[derive(Component, Debug, Clone, Copy, Reflect)]
+#[reflect(Component)]
 pub struct GravitySource;
 
 /// Marker for bodies with significant mass
 #[derive(Component, Debug, Clone, Copy, Reflect)]
+#[reflect(Component)]
 pub struct MassiveBody;
 
 // Barnes-Hut spatial partitioning
diff --git a/crates/forces/src/core/newton_laws.rs b/crates/forces/src/core/newton_laws.rs
index 26a0f5e..a7189fd 100644
--- a/crates/forces/src/core/newton_laws.rs
+++ b/crates/forces/src/core/newton_laws.rs
@@ -37,6 +37,7 @@ impl Distance for Vec2 {}
 
 /// Component for mass properties of an entity
 #[derive(Component, Debug, Clone, Copy, Reflect)]
+#[reflect(Component)]
 pub struct Mass {
     /// Mass in kilograms
     pub value: f32,
@@ -95,6 +96,7 @@ impl Mass {
 
 /// Component representing a force applied to an entity
 #[derive(Component, Debug, Clone, Reflect)]
+#[reflect(Component)]
 pub struct AppliedForce {
     /// Force vector in Newtons
     pub force: Vec3,
@@ -143,6 +145,7 @@ impl AppliedForce {
 
 /// Component for velocity (both linear and angular)
 #[derive(Component, Debug, Clone, Copy, Reflect, Default)]
+#[reflect(Component)]
 pub struct Velocity {
     /// Linear velocity in meters per second
     pub linvel: Vec3,
@@ -222,7 +225,7 @@ pub trait PairedForce {
 pub struct PairedForceInteraction;
 
 /// Event for immediate impulse application that respects Newton's Third Law
-#[derive(Event)]
+#[derive(Message)]
 pub struct ForceImpulse {
     pub entity1: Entity,
     pub impulse1: Vec3,
@@ -248,7 +251,7 @@ pub struct NewtonLawsPlugin;
 
 impl Plugin for NewtonLawsPlugin {
     fn build(&self, app: &mut App) {
-        app.add_event::<ForceImpulse>().add_systems(
+        app.add_message::<ForceImpulse>().add_systems(
             Update,
             (apply_forces, apply_impulses, integrate_positions).chain(),
         );
@@ -283,7 +286,7 @@ pub fn compute_paired_forces<T: PairedForce + Resource>(
 
 /// System to apply impulses directly to velocities
 pub fn apply_impulses(
-    mut impulses: EventReader<ForceImpulse>,
+    mut impulses: MessageReader<ForceImpulse>,
     mut velocities: Query<(&Mass, &mut Velocity)>,
 ) {
     for impulse in impulses.read() {
diff --git a/crates/information/Cargo.toml b/crates/information/Cargo.toml
index 417a54f..819b295 100644
--- a/crates/information/Cargo.toml
+++ b/crates/information/Cargo.toml
@@ -6,7 +6,7 @@ description = "Systems handling pattern emergence, complexity formation, and the
 
 [dependencies]
 
-bevy = "0.16"
+bevy = "0.17"
 
 
 
@@ -14,4 +14,4 @@ bevy = "0.16"
 serde = "1.0"
 
 # Serde JSON for JSON serialization and deserialization
-serde_json = "1.0"
\ No newline at end of file
+serde_json = "1.0"
diff --git a/crates/information/src/fractals/renderer.rs b/crates/information/src/fractals/renderer.rs
index a0fb52c..5d13346 100644
--- a/crates/information/src/fractals/renderer.rs
+++ b/crates/information/src/fractals/renderer.rs
@@ -191,7 +191,7 @@ pub fn run_renderer(
         .add_plugins(DefaultPlugins.set(WindowPlugin {
             primary_window: Some(Window {
                 title: "L-System Renderer".to_string(),
-                resolution: (800.0, 600.0).into(),
+                resolution: (800, 600).into(),
                 ..default()
             }),
             ..default()
diff --git a/crates/matter/Cargo.toml b/crates/matter/Cargo.toml
index 889fd53..6f6b7f1 100644
--- a/crates/matter/Cargo.toml
+++ b/crates/matter/Cargo.toml
@@ -5,4 +5,4 @@ edition = "2024"
 description = "Physical substance modeling from fundamental particles to complex materials, defining how tangible elements behave and interact."
 
 [dependencies]
-bevy = "0.16"
\ No newline at end of file
+bevy = "0.17"
diff --git a/crates/systems/Cargo.toml b/crates/systems/Cargo.toml
index 8067981..a335f94 100644
--- a/crates/systems/Cargo.toml
+++ b/crates/systems/Cargo.toml
@@ -5,8 +5,8 @@ edition = "2024"
 description = "Core simulation infrastructure components that manage and support the virtual universe rather than represent parts of it."
 
 [dependencies]
-bevy = "0.16"
+bevy = "0.17"
 save_system = { path = "./save_system" }
 pbmpm = { path = "./pbmpm" }
 acoustics = { path = "./acoustics" }
-ai = { path = "./ai" }
\ No newline at end of file
+ai = { path = "./ai" }
diff --git a/crates/systems/acoustics/Cargo.toml b/crates/systems/acoustics/Cargo.toml
index c28c8c5..5e1e209 100644
--- a/crates/systems/acoustics/Cargo.toml
+++ b/crates/systems/acoustics/Cargo.toml
@@ -5,4 +5,4 @@ edition = "2024"
 description = "Sound generation, playback, and spatial processing system for ambient and interactive audio experiences."
 
 [dependencies]
-bevy = "0.16"
\ No newline at end of file
+bevy = "0.17"
diff --git a/crates/systems/ai/Cargo.toml b/crates/systems/ai/Cargo.toml
index a3085a5..9c5a150 100644
--- a/crates/systems/ai/Cargo.toml
+++ b/crates/systems/ai/Cargo.toml
@@ -8,10 +8,10 @@ description = "Utility-based AI framework for life form simulation with modular
 doctest = false
 
 [dependencies]
-bevy = "0.16"
+bevy = "0.17"
 rand = "0.9"
 energy = { path = "../../energy" }
 
 
 [features]
-trace = []
\ No newline at end of file
+trace = []
diff --git a/crates/systems/pbmpm/Cargo.toml b/crates/systems/pbmpm/Cargo.toml
index 7955a3e..989ab5e 100644
--- a/crates/systems/pbmpm/Cargo.toml
+++ b/crates/systems/pbmpm/Cargo.toml
@@ -5,4 +5,4 @@ edition = "2024"
 description = "Material Point Method implementation for simulating continuous materials"
 
 [dependencies]
-bevy = "0.16"
\ No newline at end of file
+bevy = "0.17"
diff --git a/crates/systems/save_system/Cargo.toml b/crates/systems/save_system/Cargo.toml
index 5fcfb1e..283b6f2 100644
--- a/crates/systems/save_system/Cargo.toml
+++ b/crates/systems/save_system/Cargo.toml
@@ -7,4 +7,4 @@ description = "Framework for preserving and restoring simulation states across s
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-bevy = "0.16"
+bevy = "0.17"
diff --git a/crates/systems/save_system/src/save_system.rs b/crates/systems/save_system/src/save_system.rs
index c871b06..96252b4 100644
--- a/crates/systems/save_system/src/save_system.rs
+++ b/crates/systems/save_system/src/save_system.rs
@@ -1,7 +1,8 @@
 use crate::versioning::{is_save_up_to_date, upgrade_save};
 use bevy::prelude::ReflectComponent;
 use bevy::prelude::*;
-use bevy::reflect::{Reflect, ReflectSerialize};
+use bevy::reflect::Reflect;
+use bevy::reflect::serde::ReflectSerializer;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::collections::HashMap;
@@ -307,7 +308,7 @@ pub fn save_game_data(
 
         if let Ok(entity_ref) = world.get_entity(entity) {
             for component_id in entity_ref.archetype().components() {
-                let Some(component_info) = world.components().get_info(component_id) else {
+                let Some(component_info) = world.components().get_info(*component_id) else {
                     continue;
                 };
 
@@ -319,10 +320,6 @@ pub fn save_game_data(
                     continue;
                 };
 
-                let Some(reflect_serialize) = type_registration.data::<ReflectSerialize>() else {
-                    continue;
-                };
-
                 let component_name = type_registration.type_info().type_path().to_string();
 
                 if component_name.contains("Saveable") {
@@ -334,8 +331,8 @@ pub fn save_game_data(
                 };
 
                 if let Some(reflected) = reflect_component.reflect(entity_ref) {
-                    let serializable = reflect_serialize.get_serializable(reflected);
-                    if let Ok(value) = serde_json::to_value(&*serializable) {
+                    let serializer = ReflectSerializer::new(reflected, &type_registry);
+                    if let Ok(value) = serde_json::to_value(&serializer) {
                         entity_data.insert(component_name, value);
                     }
                 }
diff --git a/examples/basic_ai.rs b/examples/basic_ai.rs
index 9791b88..bd65b63 100644
--- a/examples/basic_ai.rs
+++ b/examples/basic_ai.rs
@@ -87,7 +87,7 @@ fn setup(mut commands: Commands) {
         // Add dynamic state label text
         commands.spawn((
             Text2d::new("Neutral"),
-            TextLayout::new_with_justify(JustifyText::Center),
+            TextLayout::new_with_justify(Justify::Center),
             Transform::from_translation(Vec3::new(x, y + 25.0, 1.0)).with_scale(Vec3::splat(0.5)), // Half the size
             CreatureLabel { creature: entity },
         ));
@@ -401,7 +401,7 @@ fn respawn_food(mut food_query: Query<(&mut Food, &mut Visibility)>, time: Res<T
         if !food.active {
             food.respawn_timer.tick(time.delta());
 
-            if food.respawn_timer.finished() {
+            if food.respawn_timer.is_finished() {
                 food.active = true;
                 *visibility = Visibility::Inherited;
             }
diff --git a/examples/basic_forces.rs b/examples/basic_forces.rs
index 8d4fe48..70fc2f2 100644
--- a/examples/basic_forces.rs
+++ b/examples/basic_forces.rs
@@ -5,7 +5,7 @@ fn main() {
         .add_plugins(DefaultPlugins.set(WindowPlugin {
             primary_window: Some(Window {
                 title: "N-Body Gravitational Simulation".to_string(),
-                resolution: (800.0, 600.0).into(),
+                resolution: (800, 600).into(),
                 ..default()
             }),
             ..default()

From ab164819aaa38cb4857f5a1f84e8deb50480b3e5 Mon Sep 17 00:00:00 2001
From: M1thieu <mathieupierreadrien@gmail.com>
Date: Sun, 5 Oct 2025 03:53:49 +0200
Subject: [PATCH 5/8] Increase CI timeout to 30 minutes

Bevy 0.17 fresh builds take longer than 25 minutes.
Prevents timeout during cache warming on first run after dependency changes.
---
 .github/workflows/ci.yaml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 91f983c..dc11d60 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -21,7 +21,7 @@ jobs:
   test:
     name: Test Suite
     runs-on: ubuntu-latest
-    timeout-minutes: 25
+    timeout-minutes: 30
     steps:
       - name: Free disk space
         run: sudo rm -rf /usr/share/dotnet /opt/ghc /usr/local/lib/android /usr/local/share/boost
@@ -55,7 +55,7 @@ jobs:
   clippy:
     name: Clippy
     runs-on: ubuntu-latest
-    timeout-minutes: 25
+    timeout-minutes: 30
     steps:
       - name: Free disk space
         run: sudo rm -rf /usr/share/dotnet /opt/ghc /usr/local/lib/android /usr/local/share/boost

From f82d245ebe65f92e1b54faaea7889050edcb6652 Mon Sep 17 00:00:00 2001
From: M1thieu <18742831+M1thieu@users.noreply.github.com>
Date: Thu, 16 Oct 2025 12:43:30 +0200
Subject: [PATCH 6/8] Generalize NeedType enum to support universal organisms
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace animal-centric need types with universal biological drives that apply to all life forms (animals, plants, fungi, microbes):

- Hunger → Energy (food/sunlight/decomposition)
- Add Resources (water, minerals, nutrients)
- Expand Safety (predators, herbivores, environmental hazards)
- Add Homeostasis (temperature, pH, osmotic regulation)
- Add Reproduction (universal biological drive)

This enables the AI system to work seamlessly with any organism type through component-based satisfaction mechanisms rather than hardcoded organism-specific logic.
---
 crates/systems/ai/src/drives/needs.rs | 34 +++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 5 deletions(-)

diff --git a/crates/systems/ai/src/drives/needs.rs b/crates/systems/ai/src/drives/needs.rs
index 8083f48..8ff9316 100644
--- a/crates/systems/ai/src/drives/needs.rs
+++ b/crates/systems/ai/src/drives/needs.rs
@@ -2,13 +2,37 @@ use crate::core::utility::UtilityScore;
 use crate::prelude::*;
 use bevy::prelude::*;
 
-/// Core need types representing basic drives
+/// Universal need types that apply to all life forms
+/// These represent fundamental biological drives that emerge from physics and chemistry
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Reflect)]
 pub enum NeedType {
-    Hunger, // Need for nourishment
-    Safety, // Need to avoid danger
-    Rest,   // Need for recuperation
-    Social, // Need for group interaction
+    /// Need for energy to sustain life
+    /// - Animals: food consumption
+    /// - Plants: sunlight absorption
+    /// - Fungi: nutrient decomposition
+    /// - Microbes: chemical energy sources
+    Energy,
+
+    /// Need for essential resources (water, minerals, nutrients)
+    /// Universal across all life forms
+    Resources,
+
+    /// Need to avoid threats and maintain safety
+    /// - Animals: predators, environmental hazards
+    /// - Plants: herbivores, drought, fire
+    /// - All: temperature extremes, toxins
+    Safety,
+
+    /// Need to maintain stable internal state (homeostasis)
+    /// - Temperature regulation
+    /// - pH balance
+    /// - Osmotic pressure
+    /// Universal physiological stability
+    Homeostasis,
+
+    /// Biological drive to reproduce and pass on genetic information
+    /// Universal across all life forms
+    Reproduction,
 }
 
 /// Component representing a single need

From 418b8b18ef04f816d47565d3841f8bfbd4c6c854 Mon Sep 17 00:00:00 2001
From: M1thieu <18742831+M1thieu@users.noreply.github.com>
Date: Sat, 18 Oct 2025 16:26:00 +0200
Subject: [PATCH 7/8] Remove unused utility caching infrastructure

- Delete utility.rs with unused caching system
- Consolidate Score type in scorers.rs
- Fix DRY violation in core/
---
 crates/systems/ai/src/core/mod.rs             |   3 -
 crates/systems/ai/src/core/scorers.rs         |  95 ++++-
 crates/systems/ai/src/core/utility.rs         | 335 ------------------
 crates/systems/ai/src/drives/needs.rs         |  16 +-
 crates/systems/ai/src/lib.rs                  |   4 +-
 crates/systems/ai/src/memory/types.rs         |   7 +-
 crates/systems/ai/src/personality/traits.rs   |  66 ++--
 crates/systems/ai/src/relationships/social.rs |  18 +-
 .../systems/ai/src/trackers/base_tracker.rs   |   5 +-
 .../systems/ai/src/trackers/needs_tracker.rs  |  11 +-
 .../ai/src/trackers/perception_tracker.rs     |   7 +-
 11 files changed, 163 insertions(+), 404 deletions(-)
 delete mode 100644 crates/systems/ai/src/core/utility.rs

diff --git a/crates/systems/ai/src/core/mod.rs b/crates/systems/ai/src/core/mod.rs
index ab9bbc8..488d7e8 100644
--- a/crates/systems/ai/src/core/mod.rs
+++ b/crates/systems/ai/src/core/mod.rs
@@ -10,7 +10,6 @@ pub mod measures;
 pub mod pickers;
 pub mod scorers;
 pub mod thinkers;
-pub mod utility;
 
 /// Prelude for the core AI module.
 ///
@@ -46,8 +45,6 @@ pub mod prelude {
 
     // Choices
     pub use crate::core::choices::{Choice, ChoiceBuilder};
-
-    pub use crate::core::utility::*;
 }
 
 use bevy::{
diff --git a/crates/systems/ai/src/core/scorers.rs b/crates/systems/ai/src/core/scorers.rs
index 8f39696..f055cd8 100644
--- a/crates/systems/ai/src/core/scorers.rs
+++ b/crates/systems/ai/src/core/scorers.rs
@@ -13,15 +13,33 @@ use crate::core::{
 };
 
 /// Score value between `0.0..=1.0` associated with a Scorer.
-#[derive(Clone, Component, Debug, Default, Reflect)]
+///
+/// This type represents normalized utility scores used throughout the AI system.
+/// It provides math operations for combining and transforming scores.
+#[derive(Clone, Copy, Component, Debug, Default, Reflect, PartialEq, PartialOrd)]
 pub struct Score(pub(crate) f32);
 
 impl Score {
+    /// Common score constants
+    pub const ZERO: Self = Self(0.0);
+    pub const HALF: Self = Self(0.5);
+    pub const MAX: Self = Self(1.0);
+
+    /// Create a new score, clamping to valid range `0.0..=1.0`
+    pub fn new(value: f32) -> Self {
+        Self(value.clamp(0.0, 1.0))
+    }
+
     /// Returns the `Score`'s current value.
     pub fn get(&self) -> f32 {
         self.0
     }
 
+    /// Get the raw score value (alias for `get()`)
+    pub fn value(&self) -> f32 {
+        self.0
+    }
+
     /// Set the `Score`'s value.
     ///
     /// Values outside `0.0..=1.0` will be automatically clamped to the valid range.
@@ -36,6 +54,81 @@ impl Score {
     pub fn set_unchecked(&mut self, value: f32) {
         self.0 = value;
     }
+
+    /// Helper function for clamping trait values to valid range
+    pub fn clamp_trait_value(value: f32) -> f32 {
+        value.clamp(0.0, 1.0)
+    }
+
+    /// Normalize a collection of scores to sum to 1.0
+    pub fn normalize_scores(scores: &mut [Score]) {
+        let total: f32 = scores.iter().map(|score| score.value()).sum();
+        if total > 0.0 {
+            for score in scores.iter_mut() {
+                *score = Score::new(score.value() / total);
+            }
+        } else {
+            // If all scores are 0, distribute evenly
+            let equal_value = if scores.is_empty() {
+                0.0
+            } else {
+                1.0 / scores.len() as f32
+            };
+            for score in scores.iter_mut() {
+                *score = Score::new(equal_value);
+            }
+        }
+    }
+
+    /// Multiply the score by a factor (adjusts importance)
+    pub fn multiply_by_factor(&self, factor: f32) -> Self {
+        Self::new(self.0 * factor)
+    }
+
+    /// Combine two scores with AND logic (both must be true)
+    /// Returns lower values as both scores must be high
+    pub fn and_with(&self, other: &Self) -> Self {
+        Self::new(self.0 * other.0)
+    }
+
+    /// Blend two scores with custom importance weights
+    /// weight_a and weight_b should ideally sum to 1.0
+    pub fn blend_weighted(&self, other: &Self, weight_a: f32, weight_b: f32) -> Self {
+        Self::new(self.0 * weight_a + other.0 * weight_b)
+    }
+
+    /// Combine scores with OR logic (either can be true)
+    /// P(A or B) = P(A) + P(B) - P(A and B)
+    pub fn or_with(&self, other: &Self) -> Self {
+        Self::new(self.0 + other.0 - (self.0 * other.0))
+    }
+
+    /// Get the opposite score (1 - score)
+    /// Useful for negating or inverting priorities
+    pub fn opposite(&self) -> Self {
+        Self::new(1.0 - self.0)
+    }
+
+    /// Perform weighted random selection between multiple options
+    pub fn weighted_select<T: Clone, R: rand::Rng>(
+        options: &[(T, Score)],
+        rng: &mut R,
+    ) -> Option<T> {
+        let total_weight: f32 = options.iter().map(|(_, score)| score.value()).sum();
+        if total_weight <= 0.0 || options.is_empty() {
+            return None;
+        }
+        let random_point = rng.random_range(0.0..total_weight);
+        let mut cumulative_weight = 0.0;
+        for (option, score) in options {
+            cumulative_weight += score.value();
+            if random_point <= cumulative_weight {
+                return Some(option.clone());
+            }
+        }
+        // Fallback to last option (shouldn't happen with proper weights)
+        options.last().map(|(opt, _)| opt.clone())
+    }
 }
 
 /// Trait for building scorer components. Must implement `build()`.
diff --git a/crates/systems/ai/src/core/utility.rs b/crates/systems/ai/src/core/utility.rs
deleted file mode 100644
index 0a22b8e..0000000
--- a/crates/systems/ai/src/core/utility.rs
+++ /dev/null
@@ -1,335 +0,0 @@
-use crate::prelude::*;
-use bevy::prelude::*;
-use rand::prelude::*; //still plan to use bevy_rand instead
-use std::collections::HashMap;
-
-/// Represents a utility score for decision-making
-/// Normalized between 0.0 and 1.0
-#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Component, Reflect)]
-pub struct UtilityScore(f32);
-
-impl UtilityScore {
-    /// Common utility score constants
-    pub const ZERO: Self = Self(0.0);
-    pub const HALF: Self = Self(0.5);
-    pub const MAX: Self = Self(1.0);
-
-    /// Create a new utility score, clamping to valid range
-    pub fn new(value: f32) -> Self {
-        Self(value.clamp(0.0, 1.0))
-    }
-
-    /// Get the raw score value
-    pub fn value(&self) -> f32 {
-        self.0
-    }
-
-    /// Helper function for clamping trait values to valid range
-    pub fn clamp_trait_value(value: f32) -> f32 {
-        value.clamp(0.0, 1.0)
-    }
-
-    /// Normalize a collection of scores to sum to 1.0
-    pub fn normalize_scores(scores: &mut [UtilityScore]) {
-        let total: f32 = scores.iter().map(|score| score.value()).sum();
-        if total > 0.0 {
-            for score in scores.iter_mut() {
-                *score = UtilityScore::new(score.value() / total);
-            }
-        } else {
-            // If all scores are 0, distribute evenly
-            let equal_value = if scores.is_empty() {
-                0.0
-            } else {
-                1.0 / scores.len() as f32
-            };
-            for score in scores.iter_mut() {
-                *score = UtilityScore::new(equal_value);
-            }
-        }
-    }
-
-    /// Multiply the score by a factor (adjusts importance)
-    pub fn multiply_by_factor(&self, factor: f32) -> Self {
-        Self::new(self.0 * factor)
-    }
-
-    /// Combine two scores with AND logic (both must be true)
-    /// Returns lower values as both scores must be high
-    pub fn and_with(&self, other: &Self) -> Self {
-        Self::new(self.0 * other.0)
-    }
-
-    /// Blend two scores with custom importance weights
-    /// weight_a and weight_b should ideally sum to 1.0
-    pub fn blend_weighted(&self, other: &Self, weight_a: f32, weight_b: f32) -> Self {
-        Self::new(self.0 * weight_a + other.0 * weight_b)
-    }
-
-    /// Combine scores with OR logic (either can be true)
-    /// P(A or B) = P(A) + P(B) - P(A and B)
-    pub fn or_with(&self, other: &Self) -> Self {
-        Self::new(self.0 + other.0 - (self.0 * other.0))
-    }
-
-    /// Get the opposite score (1 - score)
-    /// Useful for negating or inverting priorities
-    pub fn opposite(&self) -> Self {
-        Self::new(1.0 - self.0)
-    }
-
-    /// Perform weighted random selection between multiple options
-    pub fn weighted_select<T: Clone, R: Rng>(
-        options: &[(T, UtilityScore)],
-        rng: &mut R,
-    ) -> Option<T> {
-        let total_weight: f32 = options.iter().map(|(_, score)| score.value()).sum();
-        if total_weight <= 0.0 || options.is_empty() {
-            return None;
-        }
-        let random_point = rng.random_range(0.0..total_weight);
-        let mut cumulative_weight = 0.0;
-        for (option, score) in options {
-            cumulative_weight += score.value();
-            if random_point <= cumulative_weight {
-                return Some(option.clone());
-            }
-        }
-        // Fallback to last option (shouldn't happen with proper weights)
-        options.last().map(|(opt, _)| opt.clone())
-    }
-}
-
-/// Possible AI behaviors that can be selected based on utility scores
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Component)]
-pub enum Behavior {
-    Idle,      // Default state, minimal activity
-    Hunt,      // Pursuing prey or resource
-    Flee,      // Escaping from threat
-    Explore,   // Discovering new areas
-    Fight,     // Engaging in combat
-    Rest,      // Recovering energy
-    Socialize, // Interacting with others
-}
-
-/// Selects the most appropriate behavior based on module utility scores
-pub fn determine_behavior(
-    modules: &[(&dyn AIModule, UtilityScore, Behavior)],
-) -> (Behavior, UtilityScore) {
-    if modules.is_empty() {
-        return (Behavior::Idle, UtilityScore::ZERO);
-    }
-
-    // Create normalized version of the scores for better decision making
-    let mut normalized_scores: Vec<UtilityScore> =
-        modules.iter().map(|(_, score, _)| *score).collect();
-    UtilityScore::normalize_scores(&mut normalized_scores);
-
-    // Find behavior with highest normalized score
-    let mut best_index = 0;
-    let mut best_score = normalized_scores[0];
-
-    for (i, score) in normalized_scores.iter().enumerate().skip(1) {
-        if score > &best_score {
-            best_score = *score;
-            best_index = i;
-        }
-    }
-
-    // Return the original behavior and original score (not normalized)
-    // This preserves the absolute utility value while making selection based on normalized scores
-    let (_, original_score, behavior) = modules[best_index];
-    (behavior, original_score)
-}
-
-/// A cached result with timestamp for expiration
-#[derive(Clone, Debug)]
-struct CachedValue {
-    value: UtilityScore,
-    timestamp: f32,
-}
-
-/// Global utility cache resource
-#[derive(Resource)]
-pub struct UtilityCache {
-    cache: HashMap<String, CachedValue>,
-    ttl: f32,
-}
-
-impl Default for UtilityCache {
-    fn default() -> Self {
-        Self {
-            cache: HashMap::new(),
-            ttl: 0.5, // Default 0.5 seconds TTL
-        }
-    }
-}
-
-impl UtilityCache {
-    pub fn new(ttl: f32) -> Self {
-        Self {
-            cache: HashMap::new(),
-            ttl,
-        }
-    }
-
-    /// Get cached value if not expired
-    pub fn get(&self, key: &str, current_time: f32) -> Option<UtilityScore> {
-        self.cache.get(key).and_then(|cached| {
-            if current_time - cached.timestamp < self.ttl {
-                Some(cached.value)
-            } else {
-                None
-            }
-        })
-    }
-
-    /// Store value with timestamp
-    pub fn insert(&mut self, key: String, value: UtilityScore, current_time: f32) {
-        self.cache.insert(
-            key,
-            CachedValue {
-                value,
-                timestamp: current_time,
-            },
-        );
-    }
-
-    /// Get value if cached, otherwise calculate and store
-    pub fn get_or_insert_with<F>(
-        &mut self,
-        key: String,
-        calculator: F,
-        current_time: f32,
-    ) -> UtilityScore
-    where
-        F: FnOnce() -> UtilityScore,
-    {
-        if let Some(value) = self.get(&key, current_time) {
-            return value;
-        }
-
-        let value = calculator();
-        self.insert(key, value, current_time);
-        value
-    }
-
-    /// Clean up expired entries
-    pub fn cleanup(&mut self, current_time: f32) {
-        self.cache
-            .retain(|_, cached| current_time - cached.timestamp < self.ttl);
-    }
-}
-
-/// Entity-specific cache component for better scaling
-#[derive(Component, Default)]
-pub struct EntityUtilityCache {
-    cache: HashMap<String, CachedValue>,
-}
-
-impl EntityUtilityCache {
-    /// Get cached value if not expired
-    pub fn get(&self, key: &str, current_time: f32, ttl: f32) -> Option<UtilityScore> {
-        self.cache.get(key).and_then(|cached| {
-            if current_time - cached.timestamp < ttl {
-                Some(cached.value)
-            } else {
-                None
-            }
-        })
-    }
-
-    /// Store value with timestamp
-    pub fn insert(&mut self, key: String, value: UtilityScore, current_time: f32) {
-        self.cache.insert(
-            key,
-            CachedValue {
-                value,
-                timestamp: current_time,
-            },
-        );
-    }
-
-    /// Clean up expired entries
-    pub fn cleanup(&mut self, current_time: f32, ttl: f32) {
-        self.cache
-            .retain(|_, cached| current_time - cached.timestamp < ttl);
-    }
-}
-
-/// Trait for AIModules that support caching
-pub trait CacheableModule: AIModule {
-    /// Generate a cache key for this module
-    fn cache_key(&self) -> Option<String> {
-        None // Default implementation returns None (no caching)
-    }
-
-    /// Get utility with caching if available
-    fn cached_utility(
-        &self,
-        entity_cache: Option<&mut EntityUtilityCache>,
-        global_cache: Option<&mut UtilityCache>,
-        current_time: f32,
-    ) -> UtilityScore {
-        // Try to get a cache key
-        let Some(key) = self.cache_key() else {
-            return self.utility(); // No key means no caching
-        };
-
-        // Try entity cache first (better locality and parallelism)
-        if let Some(entity_cache) = entity_cache {
-            let ttl = global_cache.as_ref().map(|c| c.ttl).unwrap_or(0.5);
-
-            if let Some(value) = entity_cache.get(&key, current_time, ttl) {
-                return value;
-            }
-
-            // Not in entity cache, calculate and store
-            let value = self.utility();
-            entity_cache.insert(key.clone(), value, current_time);
-
-            // Also update global cache if available
-            if let Some(global_cache) = global_cache {
-                global_cache.insert(key, value, current_time);
-            }
-
-            return value;
-        }
-
-        // No entity cache, try global cache
-        if let Some(global_cache) = global_cache {
-            return global_cache.get_or_insert_with(key, || self.utility(), current_time);
-        }
-
-        // No caching available, calculate directly
-        self.utility()
-    }
-}
-
-/// System that periodically cleans up the utility cache
-pub fn cleanup_utility_cache_system(
-    time: Res<Time>,
-    mut global_cache: ResMut<UtilityCache>,
-    mut entity_caches: Query<&mut EntityUtilityCache>,
-) {
-    let current_time = time.elapsed_secs_f64() as f32;
-
-    // Clean up global cache
-    global_cache.cleanup(current_time);
-
-    // Clean up entity caches
-    for mut entity_cache in &mut entity_caches {
-        entity_cache.cleanup(current_time, global_cache.ttl);
-    }
-}
-
-/// Helper function to get current time as f32
-pub fn get_current_time(time: &Time) -> f32 {
-    time.elapsed_secs_f64() as f32
-}
-
-/// Simple function to initialize the caching system
-pub fn setup_utility_caching(app: &mut App, ttl: f32) {
-    app.insert_resource(UtilityCache::new(ttl))
-        .add_systems(Last, cleanup_utility_cache_system);
-}
diff --git a/crates/systems/ai/src/drives/needs.rs b/crates/systems/ai/src/drives/needs.rs
index 8ff9316..574bde2 100644
--- a/crates/systems/ai/src/drives/needs.rs
+++ b/crates/systems/ai/src/drives/needs.rs
@@ -1,4 +1,4 @@
-use crate::core::utility::UtilityScore;
+use crate::core::scorers::Score;
 use crate::prelude::*;
 use bevy::prelude::*;
 
@@ -52,9 +52,9 @@ impl Need {
     pub fn new(need_type: NeedType, satisfaction: f32, depletion_rate: f32, priority: f32) -> Self {
         Self {
             need_type,
-            satisfaction: UtilityScore::clamp_trait_value(satisfaction),
+            satisfaction: Score::clamp_trait_value(satisfaction),
             depletion_rate: depletion_rate.max(0.0),
-            priority: UtilityScore::clamp_trait_value(priority),
+            priority: Score::clamp_trait_value(priority),
         }
     }
 
@@ -68,8 +68,8 @@ impl Need {
     }
 
     /// Calculate need urgency as utility score
-    pub fn urgency(&self) -> UtilityScore {
-        UtilityScore::new((1.0 - self.satisfaction) * self.priority)
+    pub fn urgency(&self) -> Score {
+        Score::new((1.0 - self.satisfaction) * self.priority)
     }
 
     /// Satisfy this need by the given amount
@@ -89,9 +89,9 @@ pub fn update_needs(time: Res<Time>, mut needs: Query<&mut Need>) {
 pub fn get_most_urgent_need(
     entity: Entity,
     needs: Query<&Need>,
-) -> Option<(NeedType, UtilityScore)> {
+) -> Option<(NeedType, Score)> {
     let mut most_urgent = None;
-    let mut highest_urgency = UtilityScore::ZERO;
+    let mut highest_urgency = Score::ZERO;
 
     for need in needs.iter_many(std::iter::once(entity)) {
         let urgency = need.urgency();
@@ -110,7 +110,7 @@ impl AIModule for Need {
         self.satisfaction = self.satisfaction.clamp(0.0, 1.0);
     }
 
-    fn utility(&self) -> UtilityScore {
+    fn utility(&self) -> Score {
         // Return urgency as utility
         self.urgency()
     }
diff --git a/crates/systems/ai/src/lib.rs b/crates/systems/ai/src/lib.rs
index b83859f..6252717 100644
--- a/crates/systems/ai/src/lib.rs
+++ b/crates/systems/ai/src/lib.rs
@@ -34,7 +34,7 @@ pub mod prelude {
     };
 }
 
-use crate::core::utility::UtilityScore;
+use crate::core::scorers::Score;
 use bevy::prelude::*;
 
 /// Base trait for all AI modules
@@ -43,7 +43,7 @@ pub trait AIModule: Send + Sync {
     fn update(&mut self);
 
     /// Calculate the utility value of this module
-    fn utility(&self) -> UtilityScore;
+    fn utility(&self) -> Score;
 }
 
 /// Trait for executing actions based on behavior decisions
diff --git a/crates/systems/ai/src/memory/types.rs b/crates/systems/ai/src/memory/types.rs
index 56d1464..3f7c0e2 100644
--- a/crates/systems/ai/src/memory/types.rs
+++ b/crates/systems/ai/src/memory/types.rs
@@ -1,3 +1,4 @@
+use crate::core::scorers::Score;
 use crate::prelude::*;
 use bevy::prelude::*;
 
@@ -17,7 +18,7 @@ pub enum MemoryEventType {
 #[derive(Debug, Clone, Component)]
 pub struct MemoryEvent {
     pub timestamp: MemoryTimestamp,
-    pub importance: UtilityScore, // Use UtilityScore instead of raw f32
+    pub importance: Score, // Importance as Score (0.0-1.0)
     // pub location: Option<Vec2>, // Commented out until terrain is implemented
     pub related_entities: Vec<Entity>,
     pub event_type: MemoryEventType,
@@ -28,7 +29,7 @@ impl MemoryEvent {
         Self {
             event_type,
             timestamp,
-            importance: UtilityScore::new(importance), // Convert to UtilityScore
+            importance: Score::new(importance), // Convert to Score
             // location: None,
             related_entities: Vec::new(),
         }
@@ -46,7 +47,7 @@ impl AIModule for MemoryEvent {
         // Could implement decay of importance over time if needed
     }
 
-    fn utility(&self) -> UtilityScore {
+    fn utility(&self) -> Score {
         // Return importance as utility
         self.importance
     }
diff --git a/crates/systems/ai/src/personality/traits.rs b/crates/systems/ai/src/personality/traits.rs
index da85610..5f53961 100644
--- a/crates/systems/ai/src/personality/traits.rs
+++ b/crates/systems/ai/src/personality/traits.rs
@@ -1,4 +1,4 @@
-use crate::core::utility::UtilityScore;
+use crate::core::scorers::Score;
 use crate::prelude::*;
 use bevy::prelude::*;
 // Removed direct energy dependency - use trait-based interface instead
@@ -38,9 +38,9 @@ impl Personality {
         competitive_strength: f32,
     ) -> Self {
         Self {
-            resource_assertiveness: UtilityScore::clamp_trait_value(resource_assertiveness),
-            stress_tolerance: UtilityScore::clamp_trait_value(stress_tolerance),
-            competitive_strength: UtilityScore::clamp_trait_value(competitive_strength),
+            resource_assertiveness: Score::clamp_trait_value(resource_assertiveness),
+            stress_tolerance: Score::clamp_trait_value(stress_tolerance),
+            competitive_strength: Score::clamp_trait_value(competitive_strength),
         }
     }
 
@@ -57,18 +57,18 @@ impl Personality {
     }
 
     /// Get base resource competition behavior utility score
-    pub fn base_resource_competition_utility(&self) -> UtilityScore {
-        UtilityScore::new(self.resource_competition_likelihood())
+    pub fn base_resource_competition_utility(&self) -> Score {
+        Score::new(self.resource_competition_likelihood())
     }
 
     /// Get base stress retreat behavior utility score
-    pub fn base_stress_retreat_utility(&self) -> UtilityScore {
-        UtilityScore::new(self.stress_retreat_likelihood())
+    pub fn base_stress_retreat_utility(&self) -> Score {
+        Score::new(self.stress_retreat_likelihood())
     }
 
     /// Get base competitive behavior utility score
-    pub fn base_competitive_utility(&self) -> UtilityScore {
-        UtilityScore::new(self.competitive_strength)
+    pub fn base_competitive_utility(&self) -> Score {
+        Score::new(self.competitive_strength)
     }
 
     /// Get social behavior utility score
@@ -84,9 +84,9 @@ impl AIModule for Personality {
         // but could evolve slowly based on experiences
     }
 
-    fn utility(&self) -> UtilityScore {
+    fn utility(&self) -> Score {
         // Return a base utility score for personality-driven behaviors
-        UtilityScore::HALF
+        Score::HALF
     }
 }
 
@@ -123,11 +123,11 @@ impl Altruistic {
     }
 
     /// Get altruistic behavior utility score
-    pub fn altruistic_utility(&self, hunger_level: f32) -> UtilityScore {
+    pub fn altruistic_utility(&self, hunger_level: f32) -> Score {
         if self.should_be_altruistic(hunger_level) {
-            UtilityScore::new(self.strength)
+            Score::new(self.strength)
         } else {
-            UtilityScore::ZERO
+            Score::ZERO
         }
     }
 }
@@ -135,22 +135,22 @@ impl Altruistic {
 /// Component storing context-aware utility scores (updated by systems)
 #[derive(Component, Debug, Clone, Reflect)]
 pub struct ContextAwareUtilities {
-    pub resource_competition: UtilityScore,
-    pub stress_retreat: UtilityScore,
-    pub competitive_behavior: UtilityScore,
-    pub cooperation: UtilityScore,
+    pub resource_competition: Score,
+    pub stress_retreat: Score,
+    pub competitive_behavior: Score,
+    pub cooperation: Score,
     /// Collective intelligence modifier from nearby entities (swarm effects)
-    pub collective_influence: UtilityScore,
+    pub collective_influence: Score,
 }
 
 impl Default for ContextAwareUtilities {
     fn default() -> Self {
         Self {
-            resource_competition: UtilityScore::HALF,
-            stress_retreat: UtilityScore::HALF,
-            competitive_behavior: UtilityScore::HALF,
-            cooperation: UtilityScore::HALF,
-            collective_influence: UtilityScore::ZERO,
+            resource_competition: Score::HALF,
+            stress_retreat: Score::HALF,
+            competitive_behavior: Score::HALF,
+            cooperation: Score::HALF,
+            collective_influence: Score::ZERO,
         }
     }
 }
@@ -180,7 +180,7 @@ pub fn update_context_aware_utilities(
         utilities.stress_retreat =
             calculate_contextual_stress_retreat(personality, energy_level, environmental_stress);
 
-        utilities.cooperation = UtilityScore::new(personality.social_utility());
+        utilities.cooperation = Score::new(personality.social_utility());
 
         // collective_influence is calculated by separate proximity-based systems
         // when entities are near each other - starts at 0.0 for isolated entities
@@ -218,7 +218,7 @@ pub fn update_collective_influence(
         }
 
         // Update collective influence (clamped to reasonable range)
-        utilities.collective_influence = UtilityScore::new(total_collective_influence.min(1.0));
+        utilities.collective_influence = Score::new(total_collective_influence.min(1.0));
     }
 }
 
@@ -226,7 +226,7 @@ fn calculate_contextual_resource_competition(
     personality: &Personality,
     energy_level: f32,
     recent_success: f32,
-) -> UtilityScore {
+) -> Score {
     let energy_multiplier = 1.0 + (1.0 - energy_level) * 0.5;
     let confidence_modifier = 1.0 + recent_success.clamp(-0.3, 0.3);
 
@@ -238,14 +238,14 @@ fn calculate_contextual_resource_competition(
     let result =
         base * energy_multiplier * confidence_modifier * stress_influence * competitive_influence;
 
-    UtilityScore::new(result)
+    Score::new(result)
 }
 
 fn calculate_contextual_competitive_strength(
     personality: &Personality,
     energy_level: f32,
     recent_success: f32,
-) -> UtilityScore {
+) -> Score {
     let energy_threshold = if energy_level > 0.3 {
         energy_level
     } else {
@@ -253,17 +253,17 @@ fn calculate_contextual_competitive_strength(
     };
     let success_boost = 1.0 + recent_success.clamp(0.0, 0.4);
 
-    UtilityScore::new(personality.competitive_strength * energy_threshold * success_boost)
+    Score::new(personality.competitive_strength * energy_threshold * success_boost)
 }
 
 fn calculate_contextual_stress_retreat(
     personality: &Personality,
     energy_level: f32,
     environmental_stress: f32,
-) -> UtilityScore {
+) -> Score {
     let energy_modifier = 1.0 + (1.0 - energy_level) * 0.4;
     let stress_modifier = 1.0 + environmental_stress * 0.6;
 
     let base = personality.stress_retreat_likelihood();
-    UtilityScore::new(base * energy_modifier * stress_modifier)
+    Score::new(base * energy_modifier * stress_modifier)
 }
diff --git a/crates/systems/ai/src/relationships/social.rs b/crates/systems/ai/src/relationships/social.rs
index 475563b..69ea3f6 100644
--- a/crates/systems/ai/src/relationships/social.rs
+++ b/crates/systems/ai/src/relationships/social.rs
@@ -1,4 +1,4 @@
-use crate::core::utility::UtilityScore;
+use crate::core::scorers::Score;
 use crate::prelude::*;
 use bevy::prelude::*;
 use std::collections::HashMap;
@@ -12,7 +12,7 @@ pub struct RelationshipStrength(f32);
 
 impl RelationshipStrength {
     pub fn new(value: f32) -> Self {
-        Self(UtilityScore::clamp_trait_value(value))
+        Self(Score::clamp_trait_value(value))
     }
 
     pub fn value(&self) -> f32 {
@@ -20,13 +20,13 @@ impl RelationshipStrength {
     }
 
     /// Convert relationship to utility score for decision-making
-    pub fn to_utility(&self) -> UtilityScore {
-        UtilityScore::new(self.0)
+    pub fn to_utility(&self) -> Score {
+        Score::new(self.0)
     }
 
     /// Modify relationship by amount (can be positive or negative)
     pub fn adjust(&mut self, amount: f32) {
-        self.0 = UtilityScore::clamp_trait_value(self.0 + amount);
+        self.0 = Score::clamp_trait_value(self.0 + amount);
     }
 }
 
@@ -166,7 +166,7 @@ impl SocialNetwork {
 }
 
 /// Get social behavior utility score
-pub fn social_behavior_utility(relationships: &SocialNetwork) -> UtilityScore {
+pub fn social_behavior_utility(relationships: &SocialNetwork) -> Score {
     let mut total_utility = 0.0;
     let mut count = 0;
 
@@ -178,9 +178,9 @@ pub fn social_behavior_utility(relationships: &SocialNetwork) -> UtilityScore {
     }
 
     if count > 0 {
-        UtilityScore::new(total_utility / count as f32)
+        Score::new(total_utility / count as f32)
     } else {
-        UtilityScore::ZERO
+        Score::ZERO
     }
 }
 
@@ -203,7 +203,7 @@ impl AIModule for SocialNetwork {
         // or update based on recent interactions
     }
 
-    fn utility(&self) -> UtilityScore {
+    fn utility(&self) -> Score {
         // Calculate overall social interaction utility
         social_behavior_utility(self)
     }
diff --git a/crates/systems/ai/src/trackers/base_tracker.rs b/crates/systems/ai/src/trackers/base_tracker.rs
index 8ecc040..d345563 100644
--- a/crates/systems/ai/src/trackers/base_tracker.rs
+++ b/crates/systems/ai/src/trackers/base_tracker.rs
@@ -1,3 +1,4 @@
+use crate::core::scorers::Score;
 use crate::prelude::*;
 use bevy::prelude::*;
 use std::collections::HashMap;
@@ -56,8 +57,8 @@ impl AIModule for EntityTracker {
         }
     }
 
-    fn utility(&self) -> UtilityScore {
-        UtilityScore::new(self.priority)
+    fn utility(&self) -> Score {
+        Score::new(self.priority)
     }
 }
 
diff --git a/crates/systems/ai/src/trackers/needs_tracker.rs b/crates/systems/ai/src/trackers/needs_tracker.rs
index c6d8900..aac3508 100644
--- a/crates/systems/ai/src/trackers/needs_tracker.rs
+++ b/crates/systems/ai/src/trackers/needs_tracker.rs
@@ -1,3 +1,4 @@
+use crate::core::scorers::Score;
 use crate::prelude::*;
 use bevy::prelude::*;
 
@@ -5,7 +6,7 @@ use bevy::prelude::*;
 #[derive(Component, Default)]
 pub struct NeedsTracker {
     needs: Vec<Need>,
-    most_urgent_need: Option<(NeedType, UtilityScore)>,
+    most_urgent_need: Option<(NeedType, Score)>,
 }
 
 impl NeedsTracker {
@@ -27,7 +28,7 @@ impl NeedsTracker {
             .find(|need| need.need_type == need_type)
     }
 
-    pub fn get_most_urgent_need(&self) -> Option<(NeedType, UtilityScore)> {
+    pub fn get_most_urgent_need(&self) -> Option<(NeedType, Score)> {
         self.most_urgent_need
     }
 }
@@ -41,7 +42,7 @@ impl AIModule for NeedsTracker {
 
         // Find most urgent need
         let mut most_urgent = None;
-        let mut highest_urgency = UtilityScore::ZERO;
+        let mut highest_urgency = Score::ZERO;
 
         for need in &self.needs {
             let urgency = need.urgency();
@@ -54,10 +55,10 @@ impl AIModule for NeedsTracker {
         self.most_urgent_need = most_urgent.map(|need_type| (need_type, highest_urgency));
     }
 
-    fn utility(&self) -> UtilityScore {
+    fn utility(&self) -> Score {
         // Return the urgency of the most urgent need, or zero if no needs
         self.most_urgent_need
             .map(|(_, urgency)| urgency)
-            .unwrap_or(UtilityScore::ZERO)
+            .unwrap_or(Score::ZERO)
     }
 }
diff --git a/crates/systems/ai/src/trackers/perception_tracker.rs b/crates/systems/ai/src/trackers/perception_tracker.rs
index bc9b498..bc0b376 100644
--- a/crates/systems/ai/src/trackers/perception_tracker.rs
+++ b/crates/systems/ai/src/trackers/perception_tracker.rs
@@ -1,3 +1,4 @@
+use crate::core::scorers::Score;
 use crate::prelude::*;
 use bevy::prelude::*;
 
@@ -49,15 +50,15 @@ impl Perception {
 
 impl AIModule for Perception {
     fn update(&mut self) {
-        // This would be called from controller - actual update happens in update() method
+        // This would be called from controller - actual update() method
         // with position and entities data
 
         // Decay threat level over time when not explicitly updated
         self.highest_threat_level *= 0.95;
     }
 
-    fn utility(&self) -> UtilityScore {
+    fn utility(&self) -> Score {
         // Return threat level as utility - higher threat means more important
-        UtilityScore::new(self.highest_threat_level)
+        Score::new(self.highest_threat_level)
     }
 }

From 0e3e074ddccb625a1dd43e086d7ba1ae0e1cbb43 Mon Sep 17 00:00:00 2001
From: M1thieu <18742831+M1thieu@users.noreply.github.com>
Date: Sat, 18 Oct 2025 18:36:22 +0200
Subject: [PATCH 8/8] Tighten electromagnetics edge cases

---
 crates/energy/src/electromagnetism/fields.rs  | 60 +++++++++----------
 .../src/electromagnetism/interactions.rs      |  5 ++
 crates/systems/ai/src/drives/needs.rs         |  5 +-
 3 files changed, 36 insertions(+), 34 deletions(-)

diff --git a/crates/energy/src/electromagnetism/fields.rs b/crates/energy/src/electromagnetism/fields.rs
index 46e1281..ed9102b 100644
--- a/crates/energy/src/electromagnetism/fields.rs
+++ b/crates/energy/src/electromagnetism/fields.rs
@@ -126,40 +126,40 @@ pub fn calculate_field_interactions(
     magnetic_fields: Query<(Entity, &MagneticField)>,
 ) {
     // Electric field interactions
-    for (source_entity, source_field) in electric_fields.iter() {
-        for (target_entity, target_field) in electric_fields.iter() {
-            if source_entity == target_entity {
-                continue;
-            }
-
-            let interaction_strength = source_field.strength() * target_field.strength();
-
-            if interaction_strength > f32::EPSILON {
-                field_interaction_events.write(ElectromagneticFieldInteractionEvent {
-                    source: source_entity,
-                    target: target_entity,
-                    interaction_strength,
-                });
-            }
+    let mut electric_pairs = electric_fields.iter_combinations();
+    while let Some([(entity_a, field_a), (entity_b, field_b)]) = electric_pairs.fetch_next() {
+        let interaction_strength = field_a.strength() * field_b.strength();
+
+        if interaction_strength > f32::EPSILON {
+            field_interaction_events.write(ElectromagneticFieldInteractionEvent {
+                source: entity_a,
+                target: entity_b,
+                interaction_strength,
+            });
+            field_interaction_events.write(ElectromagneticFieldInteractionEvent {
+                source: entity_b,
+                target: entity_a,
+                interaction_strength,
+            });
         }
     }
 
     // Magnetic field interactions (similar logic)
-    for (source_entity, source_field) in magnetic_fields.iter() {
-        for (target_entity, target_field) in magnetic_fields.iter() {
-            if source_entity == target_entity {
-                continue;
-            }
-
-            let interaction_strength = source_field.strength() * target_field.strength();
-
-            if interaction_strength > f32::EPSILON {
-                field_interaction_events.write(ElectromagneticFieldInteractionEvent {
-                    source: source_entity,
-                    target: target_entity,
-                    interaction_strength,
-                });
-            }
+    let mut magnetic_pairs = magnetic_fields.iter_combinations();
+    while let Some([(entity_a, field_a), (entity_b, field_b)]) = magnetic_pairs.fetch_next() {
+        let interaction_strength = field_a.strength() * field_b.strength();
+
+        if interaction_strength > f32::EPSILON {
+            field_interaction_events.write(ElectromagneticFieldInteractionEvent {
+                source: entity_a,
+                target: entity_b,
+                interaction_strength,
+            });
+            field_interaction_events.write(ElectromagneticFieldInteractionEvent {
+                source: entity_b,
+                target: entity_a,
+                interaction_strength,
+            });
         }
     }
 }
diff --git a/crates/energy/src/electromagnetism/interactions.rs b/crates/energy/src/electromagnetism/interactions.rs
index f73a23a..82bd4be 100644
--- a/crates/energy/src/electromagnetism/interactions.rs
+++ b/crates/energy/src/electromagnetism/interactions.rs
@@ -24,6 +24,11 @@ pub struct ElectromagneticWave {
 
 impl ElectromagneticWave {
     pub fn new(frequency: f32, direction: Vec2, electric_amplitude: f32, phase: f32) -> Self {
+        assert!(
+            frequency > 0.0,
+            "Electromagnetic wave frequency must be strictly positive"
+        );
+
         // Calculate wavelength and wave number
         let wavelength = C / frequency;
         let wave_number = 2.0 * std::f32::consts::PI / wavelength;
diff --git a/crates/systems/ai/src/drives/needs.rs b/crates/systems/ai/src/drives/needs.rs
index 574bde2..d3ba9a1 100644
--- a/crates/systems/ai/src/drives/needs.rs
+++ b/crates/systems/ai/src/drives/needs.rs
@@ -86,10 +86,7 @@ pub fn update_needs(time: Res<Time>, mut needs: Query<&mut Need>) {
 }
 
 /// System for selecting most urgent need
-pub fn get_most_urgent_need(
-    entity: Entity,
-    needs: Query<&Need>,
-) -> Option<(NeedType, Score)> {
+pub fn get_most_urgent_need(entity: Entity, needs: Query<&Need>) -> Option<(NeedType, Score)> {
     let mut most_urgent = None;
     let mut highest_urgency = Score::ZERO;