diff --git a/crates/energy/src/electromagnetism/fields.rs b/crates/energy/src/electromagnetism/fields.rs
index 3d72ceb..241cfc3 100644
--- a/crates/energy/src/electromagnetism/fields.rs
+++ b/crates/energy/src/electromagnetism/fields.rs
@@ -88,7 +88,9 @@ impl MagneticField {
 
         // Biot-Savart law: dB = (μ₀/4π) * (I dl × r̂) / r²
         let field_magnitude = MAGNETIC_CONSTANT_DIV_4PI * current / (distance * distance);
-        let field = Vec2::new(-r_unit.y, r_unit.x) * current_direction.length() * field_magnitude;
+        let field = Vec2::new(-r_unit.y, r_unit.x)
+            * (current_direction.x * r_unit.y - current_direction.y * r_unit.x)
+            * field_magnitude;
 
         Self::new(field, field_position)
     }
diff --git a/crates/systems/ai/src/core/actions.rs b/crates/systems/ai/src/core/actions.rs
index 8a4e08f..96d6e61 100644
--- a/crates/systems/ai/src/core/actions.rs
+++ b/crates/systems/ai/src/core/actions.rs
@@ -8,7 +8,7 @@ use std::sync::Arc;
 /// of the Thinker that spawned it, and the actual Action system executing the
 /// Action itself.
 #[derive(Debug, Clone, Component, Eq, PartialEq, Reflect)]
-#[component(storage = "SparseSet")]
+#[component(storage = "Table")]
 pub enum ActionState {
     /// Initial state. No action should be performed.
     Init,
diff --git a/crates/systems/ai/src/drives/mod.rs b/crates/systems/ai/src/drives/mod.rs
index 1f2f38b..9acf492 100644
--- a/crates/systems/ai/src/drives/mod.rs
+++ b/crates/systems/ai/src/drives/mod.rs
@@ -7,7 +7,9 @@ use bevy::prelude::*;
 pub struct DrivesPlugin;
 
 impl Plugin for DrivesPlugin {
-    fn build(&self, _app: &mut App) {
+    fn build(&self, app: &mut App) {
+        app.register_type::<needs::Need>()
+            .register_type::<needs::NeedType>();
         // Simple plugin - just makes drives available
         // Systems will be added later when we have proper integration
     }
diff --git a/crates/systems/ai/src/drives/needs.rs b/crates/systems/ai/src/drives/needs.rs
index 40a7c55..7947171 100644
--- a/crates/systems/ai/src/drives/needs.rs
+++ b/crates/systems/ai/src/drives/needs.rs
@@ -2,7 +2,7 @@ use crate::prelude::*;
 use bevy::prelude::*;
 
 /// Core need types representing basic drives
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Reflect)]
 pub enum NeedType {
     Hunger, // Need for nourishment
     Safety, // Need to avoid danger
@@ -11,7 +11,7 @@ pub enum NeedType {
 }
 
 /// Component representing a single need
-#[derive(Component, Debug, Clone)]
+#[derive(Component, Debug, Clone, Reflect)]
 pub struct Need {
     /// Type of need
     pub need_type: NeedType,
diff --git a/crates/systems/save_system/src/lib.rs b/crates/systems/save_system/src/lib.rs
index 9898993..9c55579 100644
--- a/crates/systems/save_system/src/lib.rs
+++ b/crates/systems/save_system/src/lib.rs
@@ -3,20 +3,29 @@ use bevy::prelude::*;
 pub mod save_system;
 pub mod versioning;
 
-/// Plugin for save/load functionality with versioning support
-#[derive(Default)]
 pub struct SaveSystemPlugin;
 
 impl Plugin for SaveSystemPlugin {
-    fn build(&self, _app: &mut App) {
-        // TODO: Will add save/load systems when needed
-        // For now, just register the plugin
+    fn build(&self, app: &mut App) {
+        app.init_resource::<save_system::GameTracker>()
+            .register_type::<save_system::Saveable>()
+            .register_type::<save_system::GameState>()
+            .register_type::<save_system::GameEvent>()
+            .register_type::<save_system::SaveMetadata>();
+    }
+}
+
+impl Default for SaveSystemPlugin {
+    fn default() -> Self {
+        Self
     }
 }
 
-/// Prelude for easy importing
 pub mod prelude {
     pub use super::SaveSystemPlugin;
-    pub use crate::save_system::{load, save};
+    pub use crate::save_system::{
+        get_save_directory, get_save_path, load, load_game_data, save, save_game_data, GameEvent,
+        GameSaveData, GameSnapshot, GameState, GameTracker, SaveMetadata, Saveable, WorldSaveExt,
+    };
     pub use crate::versioning::{is_save_up_to_date, upgrade_save, SAVE_VERSION};
 }
diff --git a/crates/systems/save_system/src/save_system.rs b/crates/systems/save_system/src/save_system.rs
index f26b520..a14c762 100644
--- a/crates/systems/save_system/src/save_system.rs
+++ b/crates/systems/save_system/src/save_system.rs
@@ -1,22 +1,79 @@
 use crate::versioning::{is_save_up_to_date, upgrade_save};
+use bevy::prelude::ReflectComponent;
+use bevy::prelude::*;
+use bevy::reflect::{Reflect, ReflectSerialize};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use std::collections::HashMap;
 use std::fs;
+use std::path::PathBuf;
+
+/// Get the default save directory for the platform
+pub fn get_save_directory() -> PathBuf {
+    #[cfg(target_os = "windows")]
+    {
+        std::env::var("APPDATA")
+            .map(PathBuf::from)
+            .unwrap_or_else(|_| PathBuf::from("."))
+            .join("LP")
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        std::env::var("HOME")
+            .map(PathBuf::from)
+            .unwrap_or_else(|_| PathBuf::from("."))
+            .join("Library")
+            .join("Application Support")
+            .join("LP")
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        std::env::var("XDG_DATA_HOME")
+            .map(PathBuf::from)
+            .or_else(|_| {
+                std::env::var("HOME").map(|home| PathBuf::from(home).join(".local").join("share"))
+            })
+            .unwrap_or_else(|_| PathBuf::from("."))
+            .join("LP")
+    }
+
+    #[cfg(not(any(target_os = "windows", target_os = "macos", target_os = "linux")))]
+    {
+        PathBuf::from(".")
+    }
+}
+
+/// Get the full path for a save file
+pub fn get_save_path(filename: &str) -> PathBuf {
+    let save_dir = get_save_directory();
+
+    // Ensure save directory exists
+    if let Err(e) = fs::create_dir_all(&save_dir) {
+        eprintln!(
+            "Warning: Could not create save directory {:?}: {}",
+            save_dir, e
+        );
+        return PathBuf::from(filename); // Fallback to current directory
+    }
+
+    save_dir.join(filename)
+}
 
-/// Saves data to a file
 pub fn save<T: Serialize>(data: &T, path: &str) -> Result<(), String> {
+    let full_path = get_save_path(path);
     let json =
         serde_json::to_string_pretty(data).map_err(|e| format!("Serialization failed: {}", e))?;
-    fs::write(path, json).map_err(|e| format!("File write failed: {}", e))?;
+    fs::write(&full_path, json).map_err(|e| format!("File write failed: {}", e))?;
     Ok(())
 }
 
-/// Loads data from a file, or returns a properly initialized default save if missing
 pub fn load<T: for<'de> Deserialize<'de> + Default + Serialize>(path: &str) -> Result<T, String> {
-    let json = match fs::read_to_string(path) {
+    let full_path = get_save_path(path);
+    let json = match fs::read_to_string(&full_path) {
         Ok(content) => content,
         Err(_) => {
-            eprintln!("[Warning] Save file not found. Creating a new one.");
             let default_data = T::default();
 
             if let Err(e) = save(&default_data, path) {
@@ -38,3 +95,308 @@ pub fn load<T: for<'de> Deserialize<'de> + Default + Serialize>(path: &str) -> R
 
     serde_json::from_value(data).map_err(|e| format!("Final deserialization failed: {}", e))
 }
+
+#[derive(Serialize, Deserialize, Debug, Default)]
+pub struct GameSaveData {
+    pub version: String,
+    pub timestamp: f64,
+    pub game_time: f64,
+    pub metadata: SaveMetadata,
+
+    pub events: Vec<GameEvent>,
+    pub entities: HashMap<String, HashMap<String, Value>>,
+    pub game_state: GameState,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Reflect)]
+pub struct SaveMetadata {
+    pub created_at: String,
+    pub game_version: String,
+    pub save_system_version: String,
+    pub platform: String,
+    pub description: Option<String>,
+    pub playtime_seconds: f64,
+}
+
+impl Default for SaveMetadata {
+    fn default() -> Self {
+        let timestamp = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs();
+
+        Self {
+            created_at: format!("Unix timestamp: {}", timestamp),
+            game_version: env!("CARGO_PKG_VERSION").to_string(),
+            save_system_version: crate::versioning::SAVE_VERSION.to_string(),
+            platform: std::env::consts::OS.to_string(),
+            description: None,
+            playtime_seconds: 0.0,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Default, Clone, Reflect)]
+pub struct GameState {
+    pub total_energy: f32,
+    pub entity_count: u32,
+    pub environment: HashMap<String, f32>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Reflect)]
+pub struct GameEvent {
+    pub event_type: String,
+    pub game_time: f64,
+    pub entity_id: Option<String>,
+    pub data: String,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, Default, Reflect)]
+pub struct EntityData {
+    pub position: Option<Vec3>,
+    pub energy: Option<f32>,
+    pub custom: HashMap<String, String>,
+}
+
+#[derive(Component, Reflect)]
+pub struct Saveable;
+
+#[derive(Resource, Clone)]
+pub struct GameTracker {
+    pub state: GameState,
+    pub events: Vec<GameEvent>,
+    pub auto_save_timer: Timer,
+    pub snapshots: Vec<GameSnapshot>,
+    pub max_snapshots: usize,
+}
+
+impl Default for GameTracker {
+    fn default() -> Self {
+        Self::new(60.0) // Auto-save every 60 seconds by default
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct GameSnapshot {
+    pub state: GameState,
+    pub events: Vec<GameEvent>,
+    pub timestamp: f64,
+    pub name: String,
+}
+
+impl GameTracker {
+    /// Create a new GameTracker with auto-save enabled
+    pub fn new(auto_save_interval_secs: f32) -> Self {
+        Self {
+            state: GameState::default(),
+            events: Vec::new(),
+            auto_save_timer: Timer::from_seconds(auto_save_interval_secs, TimerMode::Repeating),
+            snapshots: Vec::new(),
+            max_snapshots: 10,
+        }
+    }
+
+    /// Create a snapshot of the current game state
+    pub fn snapshot(&mut self, name: String, timestamp: f64) {
+        let snapshot = GameSnapshot {
+            state: self.state.clone(),
+            events: self.events.clone(),
+            timestamp,
+            name,
+        };
+
+        self.snapshots.push(snapshot);
+
+        // Keep only the latest snapshots
+        if self.snapshots.len() > self.max_snapshots {
+            self.snapshots.remove(0);
+        }
+    }
+
+    /// Rollback to the most recent snapshot
+    pub fn rollback(&mut self) -> Result<String, String> {
+        if let Some(snapshot) = self.snapshots.last() {
+            self.state = snapshot.state.clone();
+            self.events = snapshot.events.clone();
+            Ok(format!("Rolled back to snapshot: {}", snapshot.name))
+        } else {
+            Err("No snapshots available for rollback".to_string())
+        }
+    }
+
+    /// Rollback to a specific named snapshot
+    pub fn rollback_to(&mut self, name: &str) -> Result<String, String> {
+        if let Some(snapshot) = self.snapshots.iter().rev().find(|s| s.name == name) {
+            self.state = snapshot.state.clone();
+            self.events = snapshot.events.clone();
+            Ok(format!("Rolled back to snapshot: {}", name))
+        } else {
+            Err(format!("Snapshot '{}' not found", name))
+        }
+    }
+
+    /// Convenience method for auto-saving
+    pub fn auto_save(&self, world: &mut World, game_time: f64) -> Result<(), String> {
+        save_game_data(
+            world,
+            self,
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap_or_default()
+                .as_secs_f64(),
+            game_time,
+        )
+    }
+
+    /// Update the auto-save timer and return true if it's time to save
+    pub fn should_auto_save(&mut self, delta_time: f32) -> bool {
+        self.auto_save_timer
+            .tick(std::time::Duration::from_secs_f32(delta_time));
+        self.auto_save_timer.just_finished()
+    }
+
+    pub fn set_environment(&mut self, name: String, value: f32) {
+        self.state.environment.insert(name, value);
+    }
+
+    pub fn set_total_energy(&mut self, energy: f32) {
+        self.state.total_energy = energy;
+    }
+
+    pub fn set_entity_count(&mut self, count: u32) {
+        self.state.entity_count = count;
+    }
+
+    pub fn log_event(
+        &mut self,
+        event_type: String,
+        entity_id: Option<String>,
+        data: String,
+        game_time: f64,
+    ) {
+        self.events.push(GameEvent {
+            event_type,
+            game_time,
+            entity_id,
+            data,
+        });
+
+        if self.events.len() > 100 {
+            self.events.remove(0);
+        }
+    }
+}
+
+pub fn save_game_data(
+    world: &mut World,
+    tracker: &GameTracker,
+    time: f64,
+    game_time: f64,
+) -> Result<(), String> {
+    let mut entities = HashMap::new();
+
+    let mut query = world.query_filtered::<Entity, With<Saveable>>();
+    let saveable_entities: Vec<Entity> = query.iter(world).collect();
+
+    let type_registry = world.resource::<AppTypeRegistry>();
+    let type_registry = type_registry.read();
+
+    for entity in saveable_entities {
+        let entity_id = format!("{:?}", entity);
+        let mut entity_data = HashMap::new();
+
+        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);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        entities.insert(entity_id, entity_data);
+    }
+
+    let mut metadata = SaveMetadata::default();
+    metadata.playtime_seconds = game_time;
+
+    let save_data = GameSaveData {
+        version: crate::versioning::SAVE_VERSION.to_string(),
+        timestamp: time,
+        game_time,
+        metadata,
+        game_state: tracker.state.clone(),
+        events: tracker.events.clone(),
+        entities,
+    };
+
+    save(&save_data, "game_save.json")
+}
+
+pub fn load_game_data() -> Result<GameSaveData, String> {
+    load::<GameSaveData>("game_save.json")
+}
+
+/// Extension trait for World to add bevy_save-style convenience methods
+pub trait WorldSaveExt {
+    fn save_game(&mut self, path: &str) -> Result<(), String>;
+    fn load_game(&mut self, path: &str) -> Result<(), String>;
+}
+
+impl WorldSaveExt for World {
+    fn save_game(&mut self, _path: &str) -> Result<(), String> {
+        let timestamp = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs_f64();
+
+        let game_time = self
+            .get_resource::<Time>()
+            .map(|time| time.elapsed_secs_f64())
+            .unwrap_or(0.0);
+
+        // Clone tracker to avoid borrow conflicts
+        if let Some(tracker) = self.get_resource::<GameTracker>().cloned() {
+            save_game_data(self, &tracker, timestamp, game_time)?;
+            Ok(())
+        } else {
+            Err("GameTracker resource not found".to_string())
+        }
+    }
+
+    fn load_game(&mut self, path: &str) -> Result<(), String> {
+        let save_data = load::<GameSaveData>(path)?;
+
+        // Update GameTracker if it exists
+        if let Some(mut tracker) = self.get_resource_mut::<GameTracker>() {
+            tracker.state = save_data.game_state;
+            tracker.events = save_data.events;
+        }
+
+        Ok(())
+    }
+}
diff --git a/crates/systems/save_system/src/versioning.rs b/crates/systems/save_system/src/versioning.rs
index b8356f7..aa9cc05 100644
--- a/crates/systems/save_system/src/versioning.rs
+++ b/crates/systems/save_system/src/versioning.rs
@@ -1,8 +1,7 @@
 use serde_json::Value;
 
-pub const SAVE_VERSION: &str = "0.1.0"; // Fix to match Cargo.toml
+pub const SAVE_VERSION: &str = "0.1.0";
 
-/// Checks if a save file is up to date
 pub fn is_save_up_to_date(data: &Value) -> bool {
     let version = data
         .get("version")
@@ -13,57 +12,40 @@ pub fn is_save_up_to_date(data: &Value) -> bool {
         return true;
     }
 
-    eprintln!(
-        "[Warning] Save file is outdated! Detected version: {}. Expected: {}.",
-        version, SAVE_VERSION
-    );
     false
 }
 
-/// Upgrades old save data to match the latest format dynamically
 pub fn upgrade_save(mut data: Value) -> Value {
     let version = data
         .get("version")
         .and_then(|v| v.as_str())
-        .unwrap_or("0.0.0")
-        .to_string();
-
-    // Always upgrade to the latest version
-    eprintln!(
-        "[Info] Upgrading save from {} to {}...",
-        version, SAVE_VERSION
-    );
-
-    // Ensure missing fields are initialized dynamically
-    for (key, default_value) in get_default_fields() {
-        if data.get(key).is_none() {
-            eprintln!("[Info] Adding missing field: {}", key);
-            data[key] = default_value.clone(); // Ensure the value is actually added
+        .unwrap_or("0.0.0");
+
+    match version {
+        "0.0.0" => {
+            for (key, default_value) in get_default_fields() {
+                if data.get(key).is_none() {
+                    data[key] = default_value.clone();
+                }
+            }
+        }
+        "0.1.0" => {}
+        _ => {
+            for (key, default_value) in get_default_fields() {
+                if data.get(key).is_none() {
+                    data[key] = default_value.clone();
+                }
+            }
         }
     }
 
-    // Rename any fields if needed
-    rename_property(&mut data, "player_info", "player_data");
-
-    // Set version to latest
     data["version"] = SAVE_VERSION.into();
-
     data
 }
 
-/// Returns a map of all expected fields with their default values
 fn get_default_fields() -> Vec<(&'static str, Value)> {
     vec![
-        ("score", Value::from(42)),                  // Default score
-        ("new_field", Value::from("default_value")), // Ensure this field is correctly added
+        ("score", Value::from(42)),
+        ("new_field", Value::from("default_value")),
     ]
 }
-
-/// Renames a property in the JSON data
-fn rename_property(data: &mut Value, old_key: &str, new_key: &str) {
-    if let Some(value) = data.get(old_key).cloned() {
-        data[new_key] = value;
-        data.as_object_mut().unwrap().remove(old_key);
-        eprintln!("[Info] Renamed property: {} → {}", old_key, new_key);
-    }
-}
diff --git a/examples/basic_save.rs b/examples/basic_save.rs
index 5d26f7e..f0db785 100644
--- a/examples/basic_save.rs
+++ b/examples/basic_save.rs
@@ -1,6 +1,5 @@
 use serde::{Deserialize, Serialize};
-use systems::save_system::save_system::{load, save};
-use systems::save_system::versioning::SAVE_VERSION;
+use systems::save_system::prelude::*;
 
 #[derive(Serialize, Deserialize, Debug)]
 struct GameData {
@@ -21,24 +20,58 @@ impl Default for GameData {
 
 fn main() {
     let path = "save.json";
-
     let mut data = match load::<GameData>(path) {
-        Ok(loaded_data) => {
-            println!("Loaded existing data: {:?}", loaded_data);
-            loaded_data
-        }
-        Err(e) => {
-            eprintln!("Failed to load existing save: {}. Creating a new one.", e);
-            GameData::default()
-        }
+        Ok(data) => data,
+        Err(_) => GameData::default(),
     };
 
-    // Modify the score every run to show persistence
     data.score += 1;
+    println!("Score: {}", data.score);
+
+    if save(&data, path).is_err() {
+        eprintln!("Save failed");
+    }
+
+    let mut tracker = GameTracker::default();
+    tracker.set_total_energy(1500.0);
+    tracker.set_entity_count(25);
+    tracker.set_environment("temperature".to_string(), 22.5);
+    tracker.log_event(
+        "spawn".to_string(),
+        Some("creature_01".to_string()),
+        "spawned".to_string(),
+        120.5,
+    );
+    tracker.log_event(
+        "energy_transfer".to_string(),
+        Some("creature_01".to_string()),
+        "consumed 50 energy".to_string(),
+        125.0,
+    );
 
-    if let Err(e) = save(&data, path) {
-        eprintln!("Save failed: {}", e);
-    } else {
-        println!("Data saved successfully!");
+    let game_save = GameSaveData {
+        version: data.version.clone(),
+        timestamp: 1000.0,
+        game_time: 130.0,
+        metadata: Default::default(),
+        game_state: tracker.state.clone(),
+        events: tracker.events.clone(),
+        entities: std::collections::HashMap::new(),
+    };
+
+    match save(&game_save, path) {
+        Ok(_) => {
+            println!("Energy: {}", game_save.game_state.total_energy);
+            println!("Entities: {}", game_save.game_state.entity_count);
+            println!("Events: {}", game_save.events.len());
+        }
+        Err(e) => eprintln!("Save failed: {}", e),
+    }
+
+    if let Ok(loaded) = load::<GameSaveData>(path) {
+        println!("Game time: {}", loaded.game_time);
+        for event in &loaded.events {
+            println!("{}: {}", event.event_type, event.data);
+        }
     }
 }