diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..897cc1b
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+/target
+**/*.rs.bk
+*.pdb
+*.log
+.DS_Store
+.vscode/
diff --git a/Cargo.lock b/Cargo.lock
index 5398662..3f63213 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "ab_glyph"
@@ -194,6 +194,8 @@ dependencies = [
  "bevy_pancam",
  "kd-tree",
  "rand",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 70bb79d..9ccb67c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,3 +22,5 @@ rand = "0.8.5"
 bevy_pancam = "0.9.0"
 bevy_egui = "0.21.0"
 kd-tree = "0.5.1"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
diff --git a/README.md b/README.md
index f1f2a3c..7a67181 100644
--- a/README.md
+++ b/README.md
@@ -1,31 +1,81 @@
-# Ant Colony Simulation
-This is an ant colony simulation, it internally uses kdtree and query caching, it's able to handle about 5k ants on the cpu.
+# Rust Ant Colony Simulation
 
+A high-performance ant colony simulation written in Rust using the [Bevy](https://bevyengine.org/) engine. This simulation demonstrates emergent behavior where ants find optimal paths between their nest and food sources using pheromone trails.
 
-Built with [Rust](https://www.rust-lang.org/) and [Bevy](https://bevyengine.org/) game engine
+![screenshot](assets/demo.png)
 
-![screenshot](/screenshot.png)
+## Features
 
-# Demo
-Here's the entire timelapse of the AI learning to drive
+- **High Performance**: Capable of simulating thousands of ants efficiently using spatial hashing and KD-Trees.
+- **Emergent Behavior**: Ants follow simple local rules to form complex global pathfinding networks.
+- **Smart Navigation**: Ants utilize a multi-sensor array including a rear sensor to climb pheromone gradients accurately to find the source.
+- **Real-time Tuning**: Adjust simulation parameters on the fly without restarting.
+- **Interactive UI**: Control visuals and simulation settings via a GUI.
 
-[![youtube](https://img.youtube.com/vi/98pUSZAM_7M/0.jpg)](https://youtu.be/98pUSZAM_7M)
+## How to Run (Windows)
 
-# Timelapses with Approach 1
-[![youtube](https://img.youtube.com/vi/5xdfTJBMnwI/0.jpg)](https://youtu.be/5xdfTJBMnwI)
+**Recommended Method:**
+Use the provided PowerShell script to run the project. this avoids common "file in use" / locking errors during compilation on Windows by building in a temporary directory.
 
-
-## Usage
-- Clone the repo
-```bash
-git clone git@github.com:bones-ai/rust-ants-colony-simulation.git
-cd rust-ants-colony-simulation
+```powershell
+.\run_safe.ps1
 ```
-- Run the simulation
+
+**Standard Method:**
 ```bash
 cargo run --release
 ```
+*Note: If you encounter linking errors or "file used by another process" errors, please use the `run_safe.ps1` script.*
+
+## Controls & Shortcuts
+
+### Keyboard Shortcuts
+| Key | Action |
+| --- | --- |
+| **Space** | Pause/Resume Simulation |
+| **TAB** | Toggle Settings Menu (Open/Close UI) |
+| **H** | Toggle Home Pheromone Visibility |
+| **F** | Toggle Food Pheromone Visibility |
+| **P** | Toggle Debug Paths (Sensor lines & Radius) |
+| **A** | Toggle Ant Visibility |
+| **-** | Reduce Speed (Limit FPS: 60 -> 30) |
+| **=** | Increase Speed (Unlimited FPS) |
+| **ESC**| Exit Simulation |
+
+### Mouse Controls
+- **Left Click**: Use selected Editor Tool (Draw Wall, Place Food, etc.)
+- **Right / Middle Click + Drag**: Pan Camera
+
+### UI Parameters (Press TAB)
+You can tweak these values in real-time to see how they affect the colony's behavior:
+
+- **Env Ph Decay**: How fast pheromones on the ground evaporate.
+- **Ant Ph Decay**: How fast the pheromone strength carried by an ant decays.
+- **Sensor Dist**: How far ahead an ant looks for pheromones.
+- **Sensor Angle**: The width of the ant's sensing field.
+- **Randomness**: The amount of random jitter in ant movement.
+- **Update Interval**: How often ants make steering decisions.
+- **Max Pheromone**: Cap for pheromone accumulation. Determines when trails turn "Deep Red/Blue".
+
+### Map Editor (Toolbar at Bottom)
+The simulation includes a built-in map editor to interact with the environment:
+- **Draw Wall**: Paint obstacles that ants must navigate around. Supports continuous drawing.
+- **Eraser**: Remove walls. Supports continuous erasing.
+- **Place Food**: Click to spawn a food source. Each food source contains 1000 units of food.
+- **Remove Food**: Click near a food source to remove it.
+
+**Note:** The simulation starts with **No Food**. You must place food using the editor to start the foraging process.
+
+### Reset
+- **Reset Simulation**: Clears the map, respawns ants, and resets pheromones. Note that placed food and walls persist (or cleared? Check reset logic).
+
+## Configuration
+The initial static configuration constants are located in `src/configs.rs`. However, many of these can now be overridden at runtime via the UI.
+Settings can be saved to `user_config.json` via the "Save Config" button and are automatically loaded on startup.
+
+## Assets
+Original assets located in `assets/`.
+processed sprites sheets are in `assets/processed/`.
 
-## Configurations
-- The project config file is located at `src/configs.rs`
-- If all ants aren't forming a single trail even after a long time, try increasing `ANT_INITIAL_PH_STRENGTH` in the configs to a greater value (exmaple: `40.0`)
+## License
+MIT
diff --git a/assets/ant.png b/assets/ant.png
deleted file mode 100644
index 1673e51..0000000
Binary files a/assets/ant.png and /dev/null differ
diff --git a/assets/ant_with_food.png b/assets/ant_with_food.png
deleted file mode 100644
index d8e9bce..0000000
Binary files a/assets/ant_with_food.png and /dev/null differ
diff --git a/assets/demo.png b/assets/demo.png
new file mode 100644
index 0000000..bc34954
Binary files /dev/null and b/assets/demo.png differ
diff --git a/assets/food.png b/assets/food.png
index 56e3cfd..1ec2867 100644
Binary files a/assets/food.png and b/assets/food.png differ
diff --git a/assets/nest.png b/assets/nest.png
index d5ab8d0..e43c664 100644
Binary files a/assets/nest.png and b/assets/nest.png differ
diff --git a/assets/processed/ant_sheet_centered.png b/assets/processed/ant_sheet_centered.png
new file mode 100644
index 0000000..ca87b5b
Binary files /dev/null and b/assets/processed/ant_sheet_centered.png differ
diff --git a/assets/processed/ant_with_food_sheet_centered.png b/assets/processed/ant_with_food_sheet_centered.png
new file mode 100644
index 0000000..421070c
Binary files /dev/null and b/assets/processed/ant_with_food_sheet_centered.png differ
diff --git a/run_safe.ps1 b/run_safe.ps1
new file mode 100644
index 0000000..2fa657d
--- /dev/null
+++ b/run_safe.ps1
@@ -0,0 +1,3 @@
+$env:CARGO_TARGET_DIR = "$env:TEMP\rust-ants-colony-target"
+Write-Host "Building in temporary directory: $env:CARGO_TARGET_DIR"
+cargo run --release
diff --git a/screenshot.png b/screenshot.png
deleted file mode 100644
index 8c6f2e9..0000000
Binary files a/screenshot.png and /dev/null differ
diff --git a/src/ant.rs b/src/ant.rs
index b2d123c..e5be2bb 100644
--- a/src/ant.rs
+++ b/src/ant.rs
@@ -1,5 +1,5 @@
 use crate::{
-    gui::SimStatistics,
+    gui::{ResetSimEvent, SimConfig, SimStatistics},
     pheromone::Pheromones,
     utils::{calc_rotation_angle, get_rand_unit_vec2},
     *,
@@ -35,6 +35,23 @@ struct AntScanRadius(f32);
 #[derive(Resource)]
 pub struct AntFollowCameraPos(pub Vec2);
 
+#[derive(Component)]
+struct AnimationTimer(Timer);
+
+#[derive(Resource)]
+pub struct AntAnimations {
+    pub walk: Handle<TextureAtlas>,
+    pub walk_food: Handle<TextureAtlas>,
+}
+
+#[derive(Component)]
+pub struct DecisionTimer(pub f32);
+
+#[derive(Component)]
+pub struct Food {
+    pub storage: i32,
+}
+
 impl Plugin for AntPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(Startup, setup)
@@ -42,23 +59,18 @@ impl Plugin for AntPlugin {
             .insert_resource(AntFollowCameraPos(Vec2::ZERO))
             .add_systems(
                 Update,
-                drop_pheromone.run_if(on_timer(Duration::from_secs_f32(ANT_PH_DROP_INTERVAL))),
-            )
-            .add_systems(
-                Update,
-                check_wall_collision.run_if(on_timer(Duration::from_secs_f32(0.1))),
-            )
-            .add_systems(
-                Update,
-                check_home_food_collisions.run_if(on_timer(Duration::from_secs_f32(0.1))),
+                (
+                    drop_pheromone.run_if(on_timer(Duration::from_secs_f32(ANT_PH_DROP_INTERVAL))),
+                    avoid_obstacles,
+                    check_wall_collision.after(avoid_obstacles),
+                    check_home_food_collisions.run_if(on_timer(Duration::from_secs_f32(0.1))),
+                    periodic_direction_update,
+                    decay_ph_strength.run_if(on_timer(Duration::from_secs_f32(ANT_PH_STRENGTH_DECAY_INTERVAL))),
+                    update_position.after(check_wall_collision),
+                    animate_ant,
+                ).run_if(run_if_not_paused)
             )
             .add_systems(Update, update_camera_follow_pos)
-            .add_systems(
-                Update,
-                periodic_direction_update.run_if(on_timer(Duration::from_secs_f32(
-                    ANT_DIRECTION_UPDATE_INTERVAL,
-                ))),
-            )
             .add_systems(
                 Update,
                 update_stats.run_if(on_timer(Duration::from_secs_f32(3.0))),
@@ -67,49 +79,131 @@ impl Plugin for AntPlugin {
                 Update,
                 update_scan_radius.run_if(on_timer(Duration::from_secs_f32(1.0))),
             )
-            .add_systems(
-                Update,
-                decay_ph_strength.run_if(on_timer(Duration::from_secs_f32(
-                    ANT_PH_STRENGTH_DECAY_INTERVAL,
-                ))),
-            )
-            .add_systems(Update, update_position.after(check_wall_collision));
+            .add_systems(Update, debug_sensors)
+            .add_systems(Update, update_ant_count)
+            .add_systems(Update, reset_ants);
     }
 }
 
-fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+fn run_if_not_paused(settings: Res<crate::gui::SimSettings>) -> bool {
+    !settings.is_paused
+}
+
+fn setup(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut texture_atlases: ResMut<Assets<TextureAtlas>>,
+) {
+    let texture_handle = asset_server.load(SPRITE_ANT_SHEET);
+    let texture_atlas = TextureAtlas::from_grid(
+        texture_handle,
+        Vec2::new(512.0, 512.0),
+        ANT_SHEET_COLS,
+        ANT_SHEET_ROWS,
+        None,
+        None,
+    );
+    let walk_handle = texture_atlases.add(texture_atlas);
+
+    let texture_handle_food = asset_server.load(SPRITE_ANT_WITH_FOOD_SHEET);
+    let texture_atlas_food = TextureAtlas::from_grid(
+        texture_handle_food,
+        Vec2::new(512.0, 512.0),
+        ANT_SHEET_COLS,
+        ANT_SHEET_ROWS,
+        None,
+        None,
+    );
+    let walk_food_handle = texture_atlases.add(texture_atlas_food);
+
+    commands.insert_resource(AntAnimations {
+        walk: walk_handle.clone(),
+        walk_food: walk_food_handle,
+    });
+
     for _ in 0..NUM_ANTS {
-        commands.spawn((
-            SpriteBundle {
-                texture: asset_server.load(SPRITE_ANT),
-                sprite: Sprite {
-                    color: Color::rgb(1.1, 1.1, 1.0),
-                    ..default()
-                },
-                transform: Transform::from_xyz(HOME_LOCATION.0, HOME_LOCATION.1, ANT_Z_INDEX)
-                    .with_scale(Vec3::splat(ANT_SPRITE_SCALE)),
-                ..Default::default()
-            },
-            Ant,
-            CurrentTask(AntTask::FindFood),
-            Velocity(get_rand_unit_vec2()),
-            Acceleration(Vec2::ZERO),
-            PhStrength(ANT_INITIAL_PH_STRENGTH),
-        ));
+        spawn_ant(&mut commands, &walk_handle);
+    }
+}
+
+fn spawn_ant(commands: &mut Commands, texture: &Handle<TextureAtlas>) {
+    commands.spawn((
+        SpriteSheetBundle {
+            texture_atlas: texture.clone(),
+            sprite: TextureAtlasSprite::new(0),
+            transform: Transform::from_xyz(HOME_LOCATION.0, HOME_LOCATION.1, ANT_Z_INDEX)
+                .with_scale(Vec3::splat(ANT_SPRITE_SCALE)),
+            ..Default::default()
+        },
+        Ant,
+        CurrentTask(AntTask::FindFood),
+        Velocity(get_rand_unit_vec2()),
+        Acceleration(Vec2::ZERO),
+        PhStrength(ANT_INITIAL_PH_STRENGTH),
+        AnimationTimer(Timer::from_seconds(ANT_ANIMATION_SPEED, TimerMode::Repeating)),
+        DecisionTimer(thread_rng().gen_range(0.0..0.1)),
+    ));
+}
+
+fn reset_ants(
+    mut commands: Commands,
+    mut events: EventReader<ResetSimEvent>,
+    ant_query: Query<Entity, With<Ant>>,
+    ant_animations: Res<AntAnimations>,
+    config: Res<SimConfig>,
+) {
+    for _ in events.iter() {
+        // Despawn all ants
+        for entity in ant_query.iter() {
+            commands.entity(entity).despawn();
+        }
+
+        // Spawn new ants
+        for _ in 0..config.ants_count {
+             spawn_ant(&mut commands, &ant_animations.walk);
+        }
+    }
+}
+
+fn update_ant_count(
+    mut commands: Commands,
+    ant_query: Query<Entity, With<Ant>>,
+    config: Res<SimConfig>,
+    ant_animations: Res<AntAnimations>,
+) {
+    if !config.is_changed() {
+        return;
+    }
+
+    let current_count = ant_query.iter().len();
+    let target_count = config.ants_count;
+
+    if current_count < target_count {
+        let diff = target_count - current_count;
+        for _ in 0..diff {
+            spawn_ant(&mut commands, &ant_animations.walk);
+        }
+    } else if current_count > target_count {
+        let diff = current_count - target_count;
+        let ants_to_despawn = ant_query.iter().take(diff);
+        for entity in ants_to_despawn {
+            commands.entity(entity).despawn();
+        }
     }
 }
 
 fn drop_pheromone(
     mut ant_query: Query<(&Transform, &CurrentTask, &PhStrength), With<Ant>>,
     mut pheromones: ResMut<Pheromones>,
+    config: Res<SimConfig>,
 ) {
     for (transform, ant_task, ph_strength) in ant_query.iter_mut() {
         let x = transform.translation.x as i32;
         let y = transform.translation.y as i32;
 
         match ant_task.0 {
-            AntTask::FindFood => pheromones.to_home.emit_signal(&(x, y), ph_strength.0),
-            AntTask::FindHome => pheromones.to_food.emit_signal(&(x, y), ph_strength.0),
+            AntTask::FindFood => pheromones.to_home.emit_signal(&(x, y), ph_strength.0, config.max_pheromone_strength),
+            AntTask::FindHome => pheromones.to_food.emit_signal(&(x, y), ph_strength.0, config.max_pheromone_strength),
         }
     }
 }
@@ -140,72 +234,122 @@ fn update_stats(
     stats.num_ants = ant_query.iter().len();
 }
 
-fn decay_ph_strength(mut ant_query: Query<&mut PhStrength, With<Ant>>) {
+fn decay_ph_strength(mut ant_query: Query<&mut PhStrength, With<Ant>>, config: Res<SimConfig>) {
     for mut ph_strength in ant_query.iter_mut() {
-        ph_strength.0 = f32::max(ph_strength.0 - ANT_PH_STRENGTH_DECAY_RATE, 0.0);
+        ph_strength.0 = f32::max(ph_strength.0 - config.ant_ph_strength_decay_rate, 0.0);
     }
 }
 
 fn get_steering_force(target: Vec2, current: Vec2, velocity: Vec2) -> Vec2 {
     let desired = target - current;
     let steering = desired - velocity;
-    steering * 0.05
+    steering * 0.2
 }
 
 fn periodic_direction_update(
-    mut ant_query: Query<(&mut Acceleration, &Transform, &CurrentTask, &Velocity), With<Ant>>,
+    mut ant_query: Query<(&mut Acceleration, &Transform, &CurrentTask, &Velocity, &mut DecisionTimer), With<Ant>>,
     mut pheromones: ResMut<Pheromones>,
     mut stats: ResMut<SimStatistics>,
-    scan_radius: Res<AntScanRadius>,
+    _scan_radius: Res<AntScanRadius>,
+    config: Res<SimConfig>,
+    time: Res<Time>,
+    food_query: Query<&Transform, With<Food>>,
+    obstacle_map: Res<crate::map::ObstacleMap>,
+    map_size: Res<crate::map::MapSize>,
 ) {
     (stats.food_cache_size, stats.home_cache_size) = pheromones.clear_cache();
 
-    for (mut acceleration, transform, current_task, velocity) in ant_query.iter_mut() {
+    for (mut acceleration, transform, current_task, velocity, mut timer) in ant_query.iter_mut() {
+        timer.0 -= time.delta_seconds();
+        if timer.0 > 0.0 {
+            continue;
+        }
+        // Reset timer with some randomness to prevent syncing
+        timer.0 = config.ant_update_interval + thread_rng().gen_range(-0.01..0.01);
+
         let current_pos = transform.translation;
         let mut target = None;
 
         // If ant is close to food/home, pull it towards itself
         match current_task.0 {
             AntTask::FindFood => {
-                let dist_to_food = transform.translation.distance_squared(vec3(
-                    FOOD_LOCATION.0,
-                    FOOD_LOCATION.1,
-                    0.0,
-                ));
-                if dist_to_food <= ANT_TARGET_AUTO_PULL_RADIUS * ANT_TARGET_AUTO_PULL_RADIUS {
-                    target = Some(vec2(FOOD_LOCATION.0, FOOD_LOCATION.1));
+                let pull_radius_sq = config.ant_target_auto_pull_radius * config.ant_target_auto_pull_radius;
+                let mut best_dist = pull_radius_sq;
+                // Find closest food
+                for food_transform in food_query.iter() {
+                    let food_pos = food_transform.translation.truncate();
+                    let dist_sq = transform.translation.distance_squared(food_transform.translation);
+                    if dist_sq <= best_dist {
+                         // Check Line of Sight
+                         if obstacle_map.has_line_of_sight(current_pos.truncate(), food_pos, map_size.width, map_size.height) {
+                             best_dist = dist_sq;
+                             target = Some(food_pos);
+                         }
+                    }
                 }
             }
             AntTask::FindHome => {
+                let home_pos = vec2(HOME_LOCATION.0, HOME_LOCATION.1);
                 let dist_to_home = transform.translation.distance_squared(vec3(
                     HOME_LOCATION.0,
                     HOME_LOCATION.1,
                     0.0,
                 ));
-                if dist_to_home <= ANT_TARGET_AUTO_PULL_RADIUS * ANT_TARGET_AUTO_PULL_RADIUS {
-                    target = Some(vec2(HOME_LOCATION.0, HOME_LOCATION.1));
+                if dist_to_home <= config.ant_target_auto_pull_radius * config.ant_target_auto_pull_radius {
+                    // Check LOS
+                     if obstacle_map.has_line_of_sight(current_pos.truncate(), home_pos, map_size.width, map_size.height) {
+                         target = Some(home_pos);
+                     }
                 }
             }
         };
 
         if target.is_none() {
-            match current_task.0 {
-                AntTask::FindFood => {
-                    target = pheromones
-                        .to_food
-                        .get_steer_target(&current_pos, scan_radius.0);
-                }
-                AntTask::FindHome => {
-                    target = pheromones
-                        .to_home
-                        .get_steer_target(&current_pos, scan_radius.0);
-                }
+
+
+            // Sensor Based Steering
+            // 1. Calculate Sensor Positions
+            let (pos_l, pos_r, pos_f) = calculate_sensor_positions(
+                current_pos.truncate(), 
+                velocity.0,
+                config.ant_sensor_dist,
+                config.ant_sensor_angle,
+            );
+            
+            // 2. Sample Strength
+             // Optimization: We know which grid we need.
+            let grid = match current_task.0 {
+                AntTask::FindFood => &pheromones.to_food,
+                AntTask::FindHome => &pheromones.to_home,
+            };
+            
+            // Sample sensors
+            let v_l = grid.sample_sensor_sum(pos_l, ANT_SENSOR_RADIUS);
+            let v_r = grid.sample_sensor_sum(pos_r, ANT_SENSOR_RADIUS);
+            let v_f = grid.sample_sensor_sum(pos_f, ANT_SENSOR_RADIUS);
+            // 3. Normal Steering
+            // Use squared values for sharper gradients
+            let v_l = v_l.powf(2.0);
+            let v_r = v_r.powf(2.0);
+            let v_f = v_f.powf(2.0);
+
+            if v_l + v_r + v_f > 0.0 {
+                 let dir_l = (pos_l - current_pos.truncate()).normalize();
+                 let dir_r = (pos_r - current_pos.truncate()).normalize();
+                 let dir_f = (pos_f - current_pos.truncate()).normalize();
+
+                 // Simple Weighted Sum = Forward Bias (due to geometry)
+                 let steer_dir = (dir_l * v_l + dir_r * v_r + dir_f * v_f).normalize_or_zero();
+                 
+                 if steer_dir != Vec2::ZERO {
+                      target = Some(current_pos.truncate() + steer_dir * config.ant_sensor_dist);
+                 }
             }
         }
-
+ 
         if target.is_none() {
-            // Default direction randomization
-            acceleration.0 += get_rand_unit_vec2() * 0.2;
+            // No signal? Random Search.
+            acceleration.0 += get_rand_unit_vec2() * config.ant_turn_randomness;
             continue;
         }
 
@@ -216,25 +360,98 @@ fn periodic_direction_update(
         );
 
         let mut rng = rand::thread_rng();
-        acceleration.0 += steering_force * rng.gen_range(0.4..=ANT_STEERING_FORCE_FACTOR);
+        acceleration.0 += steering_force * rng.gen_range(0.8..=1.2) * config.ant_steering_force_factor;
+        // Reduced lateral wiggle on established trails for stability
+        acceleration.0 += get_rand_unit_vec2() * (config.ant_turn_randomness * 0.1);
+        acceleration.0 += get_rand_unit_vec2() * (config.ant_turn_randomness * 0.33); 
+    }
+}
+
+fn calculate_sensor_positions(
+    current_pos: Vec2, 
+    velocity: Vec2,
+    sensor_dist: f32,
+    sensor_angle: f32,
+) -> (Vec2, Vec2, Vec2) {
+    let velocity_dir = velocity.normalize_or_zero();
+    let forward = if velocity_dir == Vec2::ZERO {
+            vec2(1.0, 0.0) 
+    } else { 
+            velocity_dir 
+    };
+    
+    let angle_rad = sensor_angle.to_radians();
+    let cos_a = angle_rad.cos();
+    let sin_a = angle_rad.sin();
+    
+    // Left (Rotate +Angle)
+    let left_dir = vec2(
+        forward.x * cos_a - forward.y * sin_a,
+        forward.x * sin_a + forward.y * cos_a
+    );
+    
+    // Right (Rotate -Angle)
+    let right_dir = vec2(
+        forward.x * cos_a - forward.y * (-sin_a),
+        forward.x * (-sin_a) + forward.y * cos_a
+    );
+    
+    let pos_l = current_pos + left_dir * sensor_dist;
+    let pos_r = current_pos + right_dir * sensor_dist;
+    let pos_f = current_pos + forward * sensor_dist;
+
+    (pos_l, pos_r, pos_f)
+}
+
+fn debug_sensors(
+    mut gizmos: Gizmos,
+    ant_query: Query<(&Transform, &Velocity), With<Ant>>,
+    settings: Res<crate::gui::SimSettings>,
+    config: Res<SimConfig>,
+) {
+    if !settings.is_show_ants_path && !settings.is_show_sensor_radius {
+        return;
+    }
+
+    for (transform, velocity) in ant_query.iter() {
+        let pos = transform.translation.truncate();
+        
+        if settings.is_show_ants_path {
+            let (l, r, f) = calculate_sensor_positions(
+                pos, 
+                velocity.0,
+                config.ant_sensor_dist,
+                config.ant_sensor_angle
+            );
+            
+            gizmos.line_2d(pos, l, Color::RED);   // Left
+            gizmos.line_2d(pos, r, Color::BLUE);  // Right
+            gizmos.line_2d(pos, f, Color::GREEN); // Front;
+        }
+
+        if settings.is_show_sensor_radius {
+             gizmos.circle_2d(pos, config.ant_sensor_dist, Color::rgba(0.0, 1.0, 1.0, 0.1));
+        }
     }
 }
 
 fn check_home_food_collisions(
+    mut commands: Commands,
     mut ant_query: Query<
         (
             &Transform,
-            &mut Sprite,
+            &mut TextureAtlasSprite,
             &mut Velocity,
             &mut CurrentTask,
             &mut PhStrength,
-            &mut Handle<Image>,
+            &mut Handle<TextureAtlas>,
         ),
         With<Ant>,
     >,
-    asset_server: Res<AssetServer>,
+    mut food_query: Query<(Entity, &Transform, &mut Food), Without<Ant>>,
+    ant_animations: Res<AntAnimations>,
 ) {
-    for (transform, mut sprite, mut velocity, mut ant_task, mut ph_strength, mut image_handle) in
+    for (transform, mut sprite, mut velocity, mut ant_task, mut ph_strength, mut atlas_handle) in
         ant_query.iter_mut()
     {
         // Home collision
@@ -243,56 +460,138 @@ fn check_home_food_collisions(
                 .translation
                 .distance_squared(vec3(HOME_LOCATION.0, HOME_LOCATION.1, 0.0));
         if dist_to_home < HOME_RADIUS * HOME_RADIUS {
-            // rebound only the ants with food
+            // If we were bringing food home, drop it and turn around
             match ant_task.0 {
-                AntTask::FindFood => {}
+                AntTask::FindFood => {
+                    // Already looking for food (maybe gave up and came home, or just spawned)
+                    // RECHARGE PHEROMONE: Even if empty handed, visiting home refreshes scent supply.
+                    ph_strength.0 = ANT_INITIAL_PH_STRENGTH;
+                }
                 AntTask::FindHome => {
-                    velocity.0 *= -1.0;
+                    // Just arrived home with food.
+                    // 1. Drop Food (Switch Task)
+                    ant_task.0 = AntTask::FindFood;
+                    ph_strength.0 = ANT_INITIAL_PH_STRENGTH;
+                    *atlas_handle = ant_animations.walk.clone();
+                    sprite.color = Color::rgb(1.0, 1.0, 2.5);
+
+                    // 2. Turn Around to go back to where we came from
+                    // Reflect velocity perfectly to head back out the "entrance" we came in
+                    velocity.0 *= -1.0; 
+                    
+                    // Add a tiny bit of noise so they don't walk in a perfect laser line
+                     let mut rng = rand::thread_rng();
+                     let angle = rng.gen_range(-0.5..0.5); // Small jitter
+                     velocity.0 = Vec2::from_angle(angle).rotate(velocity.0);
                 }
             }
-            ant_task.0 = AntTask::FindFood;
-            ph_strength.0 = ANT_INITIAL_PH_STRENGTH;
-            *image_handle = asset_server.load(SPRITE_ANT);
-            sprite.color = Color::rgb(1.0, 1.0, 2.5);
         }
 
         // Food Collision
-        let dist_to_food =
-            transform
-                .translation
-                .distance_squared(vec3(FOOD_LOCATION.0, FOOD_LOCATION.1, 0.0));
-        if dist_to_food < FOOD_PICKUP_RADIUS * FOOD_PICKUP_RADIUS {
-            match ant_task.0 {
-                AntTask::FindFood => {
-                    velocity.0 *= -1.0;
+        if let AntTask::FindFood = ant_task.0 {
+            for (food_entity, food_transform, mut food) in food_query.iter_mut() {
+                let dist_to_food = transform.translation.distance_squared(food_transform.translation);
+                
+                if dist_to_food < FOOD_PICKUP_RADIUS * FOOD_PICKUP_RADIUS {
+                     // Collided with food
+                     velocity.0 *= -1.0;
+                     ant_task.0 = AntTask::FindHome;
+                     ph_strength.0 = ANT_INITIAL_PH_STRENGTH;
+                     
+                     *atlas_handle = ant_animations.walk_food.clone();
+                     sprite.color = Color::rgb(1.0, 2.0, 1.0);
+                     
+                     food.storage -= 1;
+                     if food.storage <= 0 {
+                         commands.entity(food_entity).despawn();
+                     }
+                     
+                     // Stop checking other foods for this ant
+                     break; 
                 }
-                AntTask::FindHome => {}
             }
-            ant_task.0 = AntTask::FindHome;
-            ph_strength.0 = ANT_INITIAL_PH_STRENGTH;
-            *image_handle = asset_server.load(SPRITE_ANT_WITH_FOOD);
-            sprite.color = Color::rgb(1.0, 2.0, 1.0);
+        }
+    }
+}
+
+fn animate_ant(
+    time: Res<Time>,
+    mut query: Query<(&mut AnimationTimer, &mut TextureAtlasSprite), With<Ant>>,
+) {
+    for (mut timer, mut sprite) in &mut query {
+        timer.0.tick(time.delta());
+        if timer.0.just_finished() {
+            sprite.index = (sprite.index + 1) % (ANT_SHEET_COLS * ANT_SHEET_ROWS);
         }
     }
 }
 
 fn check_wall_collision(
-    mut ant_query: Query<(&Transform, &Velocity, &mut Acceleration), With<Ant>>,
+    mut ant_query: Query<(&mut Transform, &mut Velocity, &mut Acceleration), With<Ant>>,
+    obstacle_map: Res<crate::map::ObstacleMap>,
+    map_size: Res<crate::map::MapSize>,
 ) {
-    for (transform, velocity, mut acceleration) in ant_query.iter_mut() {
+    let w = map_size.width;
+    let h = map_size.height;
+
+    for (mut transform, mut velocity, mut acceleration) in ant_query.iter_mut() {
         // wall rebound
         let border = 20.0;
-        let top_left = (-W / 2.0, H / 2.0);
-        let bottom_right = (W / 2.0, -H / 2.0);
-        let x_bound = transform.translation.x < top_left.0 + border
-            || transform.translation.x >= bottom_right.0 - border;
-        let y_bound = transform.translation.y >= top_left.1 - border
-            || transform.translation.y < bottom_right.1 + border;
-        if x_bound || y_bound {
+        let top_left = (-w / 2.0, h / 2.0);
+        let bottom_right = (w / 2.0, -h / 2.0);
+        
+        let pos = transform.translation;
+        
+        let mut hit_wall = false;
+        
+        // Wall Clamping
+        if pos.x < top_left.0 + border {
+            transform.translation.x = top_left.0 + border;
+            hit_wall = true;
+        } else if pos.x >= bottom_right.0 - border {
+            transform.translation.x = bottom_right.0 - border;
+            hit_wall = true;
+        }
+        
+        if pos.y > top_left.1 - border {
+            transform.translation.y = top_left.1 - border;
+            hit_wall = true;
+        } else if pos.y < bottom_right.1 + border {
+            transform.translation.y = bottom_right.1 + border;
+            hit_wall = true;
+        }
+
+        let mut hit_obstacle = false;
+        if !hit_wall {
+             // Check obstacle map with radius
+             // Radius reduced to 10.0 for tighter visual collision
+             if obstacle_map.is_obstacle_in_radius(pos.x, pos.y, 10.0, w, h) {
+                 hit_obstacle = true;
+                 
+                 // Push ant back slightly to unstuck (opposite to current velocity)
+                 let push_dir = -velocity.0.normalize_or_zero();
+                 transform.translation.x += push_dir.x * 2.0;
+                 transform.translation.y += push_dir.y * 2.0;
+             }
+        }
+
+        if hit_wall || hit_obstacle {
+            // "Stop and observe" behavior
+            // Heavily dampen velocity and reverse it slightly to detach from wall
+            velocity.0 = -velocity.0 * 0.2;
+            
+            // Clear acceleration
+            acceleration.0 = Vec2::ZERO;
+
+            // Add a small random rotation to velocity to simulate "looking for new direction"
             let mut rng = thread_rng();
-            let target = vec2(rng.gen_range(-200.0..200.0), rng.gen_range(-200.0..200.0));
-            acceleration.0 +=
-                get_steering_force(target, transform.translation.truncate(), velocity.0);
+            let jitter_angle: f32 = rng.gen_range(-1.0..1.0); 
+            let cos_a = jitter_angle.cos();
+            let sin_a = jitter_angle.sin();
+            velocity.0 = vec2(
+                velocity.0.x * cos_a - velocity.0.y * sin_a,
+                velocity.0.x * sin_a + velocity.0.y * cos_a
+            );
         }
     }
 }
@@ -314,6 +613,78 @@ fn update_position(
 
         acceleration.0 = Vec2::ZERO;
         transform.rotation =
-            Quat::from_rotation_z(calc_rotation_angle(old_pos, transform.translation) + PI / 2.0);
+            Quat::from_rotation_z(calc_rotation_angle(old_pos, transform.translation) + PI);
+    }
+}
+
+fn avoid_obstacles(
+    mut ant_query: Query<(&Transform, &Velocity, &mut Acceleration), With<Ant>>,
+    obstacle_map: Res<crate::map::ObstacleMap>,
+    map_size: Res<crate::map::MapSize>,
+) {
+    let w = map_size.width;
+    let h = map_size.height;
+    // Look ahead distance reduced to 20.0 for closer reaction
+    let look_ahead = 20.0;
+    // Sensor probe offset angle (radians)
+    let probe_angle: f32 = 0.5; // ~30 degrees
+
+    for (transform, velocity, mut acceleration) in ant_query.iter_mut() {
+        if velocity.0.length_squared() < 0.1 { continue; }
+        
+        let forward = velocity.0.normalize();
+        let pos = transform.translation.truncate();
+        
+        // Center probe
+        let center_probe = pos + forward * look_ahead;
+        
+        // Left probe
+        let cos_a = probe_angle.cos();
+        let sin_a = probe_angle.sin();
+        let left_dir = vec2(
+            forward.x * cos_a - forward.y * sin_a,
+            forward.x * sin_a + forward.y * cos_a
+        );
+        let left_probe = pos + left_dir * look_ahead;
+        
+        // Right probe
+        let right_dir = vec2(
+            forward.x * cos_a + forward.y * sin_a,
+            -forward.x * sin_a + forward.y * cos_a
+        );
+        let right_probe = pos + right_dir * look_ahead;
+        
+        let center_hit = obstacle_map.is_obstacle_in_radius(center_probe.x, center_probe.y, 5.0, w, h);
+        let left_hit = obstacle_map.is_obstacle_in_radius(left_probe.x, left_probe.y, 5.0, w, h);
+        let right_hit = obstacle_map.is_obstacle_in_radius(right_probe.x, right_probe.y, 5.0, w, h);
+        
+        if center_hit || left_hit || right_hit {
+            let mut turn_force = Vec2::ZERO;
+            
+            // Steering logic
+            
+            if left_hit && !right_hit {
+                // Obstacle on left, turn right
+                turn_force += vec2(forward.y, -forward.x) * 400.0;
+            } else if right_hit && !left_hit {
+                // Obstacle on right, turn left
+                turn_force += vec2(-forward.y, forward.x) * 400.0;
+            } else {
+                // Both blocked or center blocked, pick random valid side or turn around
+                let mut rng = thread_rng();
+                if rng.gen_bool(0.5) {
+                    turn_force += vec2(forward.y, -forward.x) * 600.0;
+                } else {
+                    turn_force += vec2(-forward.y, forward.x) * 600.0;
+                }
+            }
+            
+            if center_hit {
+                 // Brake hard
+                 acceleration.0 -= velocity.0 * 2.0;
+            }
+
+            acceleration.0 += turn_force;
+        }
     }
 }
diff --git a/src/configs.rs b/src/configs.rs
index 5260fc7..66cb520 100644
--- a/src/configs.rs
+++ b/src/configs.rs
@@ -2,33 +2,37 @@
 pub const W: f32 = 1920.0;
 pub const H: f32 = 1080.0;
 pub const BG_COLOR: (u8, u8, u8) = (0, 0, 0);
+pub const TARGET_FPS: u32 = 60;
 
 // Ants
-pub const NUM_ANTS: u32 = 5000;
+pub const NUM_ANTS: u32 = 500;
 pub const ANT_SPEED: f32 = 1.5;
-pub const ANT_DIRECTION_RANDOMNESS_DEG: f32 = 300.0;
-pub const ANT_DIRECTION_UPDATE_INTERVAL: f32 = 0.5;
-pub const ANT_SPRITE_SCALE: f32 = 0.3;
+pub const ANT_DIRECTION_RANDOMNESS_DEG: f32 = 45.0; // Increased exploration
+pub const ANT_DIRECTION_UPDATE_INTERVAL: f32 = 0.05; 
+pub const ANT_SPRITE_SCALE: f32 = 0.1;
 pub const ANT_Z_INDEX: f32 = 3.0;
-pub const ANT_INITIAL_PH_STRENGTH: f32 = 32.0;
-pub const ANT_PH_STRENGTH_DECAY_RATE: f32 = 0.7;
-pub const ANT_PH_STRENGTH_DECAY_INTERVAL: f32 = 0.5;
-pub const ANT_PH_DROP_INTERVAL: f32 = 0.7;
+pub const ANT_INITIAL_PH_STRENGTH: f32 = 100.0; // Start strong to create gradient
+pub const ANT_PH_STRENGTH_DECAY_RATE: f32 = 2.0;
+pub const ANT_PH_STRENGTH_DECAY_INTERVAL: f32 = 0.5; // (Decay 4.0/sec -> ~25s lifetime)
+pub const ANT_PH_DROP_INTERVAL: f32 = 0.1; 
 pub const INITIAL_ANT_PH_SCAN_RADIUS: f32 = 15.0;
 pub const ANT_PH_SCAN_RADIUS_INCREMENT: f32 = 0.1;
 pub const ANT_PH_SCAN_RADIUS_SCALE: f32 = 1.8;
-pub const ANT_STEERING_FORCE_FACTOR: f32 = 0.7;
+pub const ANT_STEERING_FORCE_FACTOR: f32 = 2.0; 
 pub const ANT_TARGET_AUTO_PULL_RADIUS: f32 = 100.0;
+pub const ANT_SENSOR_ANGLE: f32 = 45.0; 
+pub const ANT_SENSOR_DIST: f32 = 15.0; // Closer sensors for tighter path following
+pub const ANT_SENSOR_RADIUS: usize = 3; 
 
 // Ant Colony
 pub const HOME_LOCATION: (f32, f32) = (759.0, -350.0);
 // pub const HOME_LOCATION: (f32, f32) = (300.0, -250.0);
-pub const HOME_SPRITE_SCALE: f32 = 2.5;
+pub const HOME_SPRITE_SCALE: f32 = 0.4;
 pub const HOME_RADIUS: f32 = 30.0;
 
 // Pheromones
-pub const MAX_PHEROMONE_STRENGTH: f32 = 500.0;
-pub const PH_DECAY_RATE: f32 = 0.08;
+pub const MAX_PHEROMONE_STRENGTH: f32 = 300.0; // Higher cap
+pub const PH_DECAY_RATE: f32 = 0.15; // Moderate decay
 pub const PH_DECAY_INTERVAL: f32 = 0.1;
 pub const PH_IMG_UPDATE_SEC: f32 = 0.1;
 pub const PH_GRID_VIZ_MIN_STRENGTH: u8 = 1;
@@ -51,10 +55,17 @@ pub const VIZ_MAX_COLOR_STRENGTH: f32 = 50.0;
 // pub const FOOD_LOCATION: (f32, f32) = (-400.0, 300.0);
 pub const FOOD_LOCATION: (f32, f32) = (-750.0, 400.0);
 pub const FOOD_PICKUP_RADIUS: f32 = 30.0;
-pub const FOOD_SPRITE_SCALE: f32 = 2.0;
+pub const FOOD_SPRITE_SCALE: f32 = 0.25;
 
+// Sprites
 // Sprites
 pub const SPRITE_ANT: &str = "ant.png";
 pub const SPRITE_ANT_WITH_FOOD: &str = "ant_with_food.png";
+pub const SPRITE_ANT_SHEET: &str = "processed/ant_sheet_centered.png";
+pub const SPRITE_ANT_WITH_FOOD_SHEET: &str = "processed/ant_with_food_sheet_centered.png";
 pub const SPRITE_ANT_COLONY: &str = "nest.png";
 pub const SPRITE_FOOD: &str = "food.png";
+
+pub const ANT_ANIMATION_SPEED: f32 = 0.05;
+pub const ANT_SHEET_COLS: usize = 2;
+pub const ANT_SHEET_ROWS: usize = 2;
diff --git a/src/grid.rs b/src/grid.rs
index f4c20df..bd423ba 100644
--- a/src/grid.rs
+++ b/src/grid.rs
@@ -1,5 +1,5 @@
 use crate::{
-    utils::{calc_weighted_midpoint, window_to_grid},
+    utils::calc_weighted_midpoint,
     *,
 };
 use bevy::prelude::*;
@@ -29,14 +29,14 @@ impl WorldGrid {
         }
     }
 
-    pub fn emit_signal(&mut self, key: &(i32, i32), value: f32) {
+    pub fn emit_signal(&mut self, key: &(i32, i32), value: f32, max_val: f32) {
         let key = self.get_ph_key(key.0, key.1);
         // TODO: this 0 check prevents from having a large pheromone to be formed at the center
         // Still to debug why this happens
         if key.0 == 0 && key.1 == 0 {
             return;
         }
-        self.signals.add_value(&key, value, value * 0.25);
+        self.signals.add_value(&key, value, value * 0.25, max_val);
     }
 
     pub fn update_tree(&mut self) {
@@ -116,8 +116,8 @@ impl WorldGrid {
         None
     }
 
-    pub fn decay_signals(&mut self) {
-        self.signals.decay_values(PH_DECAY_RATE);
+    pub fn decay_signals(&mut self, rate: f32) {
+        self.signals.decay_values(rate);
     }
 
     pub fn drop_zero_signals(&mut self) {
@@ -131,6 +131,21 @@ impl WorldGrid {
     pub fn get_signals_size(&self) -> usize {
         self.signals.values.len()
     }
+
+    pub fn sample_sensor_sum(&self, pos: Vec2, radius: usize) -> f32 {
+        let (grid_x, grid_y) = self.get_ph_key(pos.x as i32, pos.y as i32);
+        let mut sum = 0.0;
+        
+        let radius = radius as i32;
+        for dy in -radius..=radius {
+            for dx in -radius..=radius {
+                if let Some(val) = self.signals.values.get(&(grid_x + dx, grid_y + dy)) {
+                     sum += val;
+                }
+            }
+        }
+        sum
+    }
 }
 
 impl DecayGrid {
@@ -141,17 +156,17 @@ impl DecayGrid {
         }
     }
 
-    pub fn add_value(&mut self, key: &(i32, i32), value: f32, increment_value: f32) {
+    pub fn add_value(&mut self, key: &(i32, i32), value: f32, increment_value: f32, max_val: f32) {
         if value <= 0.0 {
             return;
         }
 
         match self.values.get_mut(key) {
             Some(old_value) => {
-                *old_value = (increment_value + *old_value).min(self.max_allowed_value);
+                *old_value = (increment_value + *old_value).min(max_val);
             }
             None => {
-                self.values.insert(*key, value);
+                self.values.insert(*key, value.min(max_val));
             }
         }
     }
@@ -173,30 +188,52 @@ impl DecayGrid {
 
 pub fn add_map_to_grid_img(
     map: &HashMap<(i32, i32), f32>,
-    color: &(u8, u8, u8),
     img_bytes: &mut Vec<u8>,
     use_grid_pos: bool,
+    map_w_pixels: f32,
+    map_h_pixels: f32,
+    max_val: f32, // From config
+    base_color: (u8, u8, u8),
+    high_color: (u8, u8, u8),
 ) {
-    let w = W as usize / PH_UNIT_GRID_SIZE;
+    let w = map_w_pixels as usize / PH_UNIT_GRID_SIZE;
     for (k, v) in map.iter() {
         let (mut x, mut y) = (k.0, k.1);
 
         if use_grid_pos {
             (x, y) = (x * PH_UNIT_GRID_SIZE as i32, y * PH_UNIT_GRID_SIZE as i32);
-            (x, y) = window_to_grid(x, y);
+            let (tx, ty) = (x + (map_w_pixels as i32 / 2), (map_h_pixels as i32 / 2) - y);
+            // Convert back to grid coords relative to top-left of image
+            let x_grid = tx / PH_UNIT_GRID_SIZE as i32;
+            let y_grid = ty / PH_UNIT_GRID_SIZE as i32;
+            
+            x = x_grid;
+            y = y_grid;
+        }
+        
+        // Explicit boundary check
+        if x < 0 || x >= w as i32 || y < 0 || y >= (map_h_pixels as usize / PH_UNIT_GRID_SIZE) as i32 {
+            continue;
         }
 
         let idx = y * w as i32 + x;
+        // Strength determines opacity mostly
         let strength = cmp::min((*v as u32).saturating_mul(5), u8::MAX.into()) as u8;
 
         let idx = (idx as usize).saturating_mul(4);
         if idx.saturating_add(3) >= img_bytes.len() || strength < PH_GRID_VIZ_MIN_STRENGTH {
             continue;
         }
+        
+        // Interpolate color based on value / max_val
+        let t = (*v / max_val).clamp(0.0, 1.0);
+        let r = (base_color.0 as f32 * (1.0 - t) + high_color.0 as f32 * t) as u8;
+        let g = (base_color.1 as f32 * (1.0 - t) + high_color.1 as f32 * t) as u8;
+        let b = (base_color.2 as f32 * (1.0 - t) + high_color.2 as f32 * t) as u8;
 
         img_bytes[idx + 3] = cmp::min(img_bytes[idx + 3].saturating_add(strength), PH_GRID_OPACITY);
-        img_bytes[idx] = color.0;
-        img_bytes[idx + 1] = color.1;
-        img_bytes[idx + 2] = color.2;
+        img_bytes[idx] = r;
+        img_bytes[idx + 1] = g;
+        img_bytes[idx + 2] = b;
     }
 }
diff --git a/src/gui.rs b/src/gui.rs
index 50de0df..7b2f118 100644
--- a/src/gui.rs
+++ b/src/gui.rs
@@ -1,6 +1,33 @@
-use crate::{ant::Ant, *};
+use crate::{ant::{Ant, Food}, *};
 use bevy::prelude::*;
 use bevy_egui::{egui, EguiContexts, EguiPlugin};
+use bevy_pancam::PanCam;
+use crate::map::{MapSize, ObstacleMap};
+use serde::{Deserialize, Serialize};
+
+#[derive(PartialEq, Clone, Copy, Debug)]
+pub enum EditorTool {
+    None,
+    BrushObstacle,
+    EraserObstacle,
+    PlaceFood,
+    RemoveFood,
+}
+
+#[derive(Resource)]
+pub struct EditorState {
+    pub selected_tool: EditorTool,
+    pub brush_size: f32,
+}
+
+impl Default for EditorState {
+    fn default() -> Self {
+        Self {
+            selected_tool: EditorTool::None,
+            brush_size: 20.0,
+        }
+    }
+}
 
 pub struct GuiPlugin;
 
@@ -12,39 +39,54 @@ pub struct SimSettings {
     pub is_camera_follow: bool,
     pub is_show_menu: bool,
     pub is_show_ants_path: bool,
+    pub is_show_sensor_radius: bool,
+    pub is_paused: bool,
 }
 
-#[derive(Default, Resource)]
-pub struct SimStatistics {
-    pub ph_home_size: u32,
-    pub ph_food_size: u32,
-    pub scan_radius: f32,
-    pub num_ants: usize,
-    pub food_cache_size: u32,
-    pub home_cache_size: u32,
+impl Default for SimSettings {
+    fn default() -> Self {
+        Self {
+            is_show_home_ph: true,
+            is_show_food_ph: true,
+            is_show_ants: true,
+            is_camera_follow: false,
+            is_show_menu: true,
+            is_show_ants_path: false,
+            is_show_sensor_radius: false,
+            is_paused: false,
+        }
+    }
 }
-
 impl Plugin for GuiPlugin {
     fn build(&self, app: &mut bevy::prelude::App) {
         app.insert_resource(SimSettings::default())
             .insert_resource(SimStatistics::default())
+            .insert_resource(SimConfig::default())
+            .insert_resource(EditorState::default())
+            .add_event::<ResetSimEvent>()
             .add_systems(Update, settings_dialog)
             .add_systems(Update, settings_toggle)
+            .add_systems(Update, handle_camera_control)
+            .add_systems(Update, editor_ui)
+            .add_systems(Update, handle_editor_input)
             .add_plugins(EguiPlugin)
-            .add_systems(Startup, setup);
+            .add_systems(Startup, (setup, configure_ui, load_config));
     }
 }
-
-fn setup() {}
+// ...
 
 fn settings_toggle(
     mut settings: ResMut<SimSettings>,
-    ant_query: Query<&mut Visibility, With<Ant>>,
+    mut ant_query: Query<&mut Visibility, With<Ant>>,
     keys: Res<Input<KeyCode>>,
 ) {
     if keys.just_pressed(KeyCode::Tab) {
         settings.is_show_menu = !settings.is_show_menu;
     }
+    if keys.just_pressed(KeyCode::Space) {
+        settings.is_paused = !settings.is_paused;
+        println!("Paused: {}", settings.is_paused);
+    }
     if keys.just_pressed(KeyCode::H) {
         settings.is_show_home_ph = !settings.is_show_home_ph;
     }
@@ -53,6 +95,7 @@ fn settings_toggle(
     }
     if keys.just_pressed(KeyCode::P) {
         settings.is_show_ants_path = !settings.is_show_ants_path;
+        settings.is_show_sensor_radius = !settings.is_show_sensor_radius;
     }
     if keys.just_pressed(KeyCode::A) {
         settings.is_show_ants = !settings.is_show_ants;
@@ -60,11 +103,57 @@ fn settings_toggle(
     }
 }
 
+#[derive(Event)]
+pub struct ResetSimEvent;
+
+#[derive(Resource, Serialize, Deserialize, Clone)]
+pub struct SimConfig {
+    pub ph_decay_rate: f32,
+    pub ant_ph_strength_decay_rate: f32,
+    pub ant_sensor_dist: f32,
+    pub ant_sensor_angle: f32,
+    pub ant_turn_randomness: f32,
+    pub ant_update_interval: f32,
+    pub ants_count: usize,
+    pub ant_target_auto_pull_radius: f32,
+    pub ant_steering_force_factor: f32,
+    pub max_pheromone_strength: f32,
+}
+
+impl Default for SimConfig {
+    fn default() -> Self {
+        Self {
+            ph_decay_rate: PH_DECAY_RATE,
+            ant_ph_strength_decay_rate: ANT_PH_STRENGTH_DECAY_RATE,
+            ant_sensor_dist: ANT_SENSOR_DIST,
+            ant_sensor_angle: ANT_SENSOR_ANGLE,
+            ant_turn_randomness: 0.3,
+            ant_update_interval: 0.1,
+            ants_count: NUM_ANTS as usize,
+            ant_target_auto_pull_radius: ANT_TARGET_AUTO_PULL_RADIUS,
+            ant_steering_force_factor: ANT_STEERING_FORCE_FACTOR,
+            max_pheromone_strength: 5000.0,
+        }
+    }
+}
+
+#[derive(Default, Resource)]
+pub struct SimStatistics {
+    pub ph_home_size: u32,
+    pub ph_food_size: u32,
+    pub scan_radius: f32,
+    pub num_ants: usize,
+    pub food_cache_size: u32,
+    pub home_cache_size: u32,
+}
+
 fn settings_dialog(
     mut contexts: EguiContexts,
     mut settings: ResMut<SimSettings>,
+    mut config: ResMut<SimConfig>,
     stats: Res<SimStatistics>,
     ant_query: Query<&mut Visibility, With<Ant>>,
+    mut reset_sim_event: EventWriter<ResetSimEvent>,
 ) {
     if !settings.is_show_menu {
         return;
@@ -92,11 +181,32 @@ fn settings_dialog(
                     ui.checkbox(&mut settings.is_show_home_ph, "Home ph");
                     ui.checkbox(&mut settings.is_show_food_ph, "Food ph");
                     ui.checkbox(&mut settings.is_show_ants_path, "Paths");
+                    ui.checkbox(&mut settings.is_show_sensor_radius, "Radius");
                     ui.checkbox(&mut settings.is_camera_follow, "Camera follow");
                     if ui.checkbox(&mut settings.is_show_ants, "Ants").clicked() {
                         toggle_ant_visibility(ant_query, settings.is_show_ants);
                     };
                 });
+
+            egui::CollapsingHeader::new("Parameters")
+                .default_open(true)
+                .show(ui, |ui| {
+                    ui.add(egui::Slider::new(&mut config.ph_decay_rate, 0.01..=2.0).text("Env Ph Decay"));
+                    ui.add(egui::Slider::new(&mut config.ant_ph_strength_decay_rate, 0.1..=10.0).text("Ant Ph Decay"));
+                    ui.add(egui::Slider::new(&mut config.ant_sensor_dist, 5.0..=100.0).text("Sensor Dist"));
+                    ui.add(egui::Slider::new(&mut config.ant_sensor_angle, 10.0..=90.0).text("Sensor Angle"));
+                    ui.add(egui::Slider::new(&mut config.ant_turn_randomness, 0.0..=1.0).text("Randomness"));
+                    ui.add(egui::Slider::new(&mut config.ant_update_interval, 0.01..=0.5).text("Update Interval"));
+                    ui.add(egui::Slider::new(&mut config.ants_count, 0..=5000).text("Ant Count"));
+                    ui.add(egui::Slider::new(&mut config.ant_target_auto_pull_radius, 10.0..=500.0).text("Attraction Radius"));
+                    ui.add(egui::Slider::new(&mut config.ant_steering_force_factor, 1.0..=20.0).text("Steering Force"));
+                    ui.add(egui::Slider::new(&mut config.max_pheromone_strength, 100.0..=10000.0).text("Max Pheromone"));
+                });
+            
+            ui.add_space(10.0);
+            if ui.button("Reset Simulation").clicked() {
+                 reset_sim_event.send(ResetSimEvent);
+            }
         });
 }
 
@@ -110,15 +220,203 @@ fn toggle_ant_visibility(mut ant_query: Query<&mut Visibility, With<Ant>>, is_vi
     }
 }
 
-impl Default for SimSettings {
-    fn default() -> Self {
-        Self {
-            is_show_home_ph: true,
-            is_show_food_ph: true,
-            is_show_ants: true,
-            is_camera_follow: false,
-            is_show_menu: false,
-            is_show_ants_path: true,
+
+
+fn configure_ui(mut contexts: EguiContexts) {
+    let ctx = contexts.ctx_mut();
+    use bevy_egui::egui::{FontFamily, FontId, TextStyle};
+
+    let mut style = (*ctx.style()).clone();
+    style.text_styles = [
+        (TextStyle::Heading, FontId::new(24.0, FontFamily::Proportional)),
+        (TextStyle::Body, FontId::new(18.0, FontFamily::Proportional)),
+        (TextStyle::Monospace, FontId::new(18.0, FontFamily::Monospace)),
+        (TextStyle::Button, FontId::new(18.0, FontFamily::Proportional)),
+        (TextStyle::Small, FontId::new(14.0, FontFamily::Proportional)),
+    ].into();
+    ctx.set_style(style);
+}
+
+fn setup() {}
+
+fn handle_camera_control(
+    mut contexts: EguiContexts,
+    mut cam_query: Query<&mut PanCam>,
+) {
+    let ctx = contexts.ctx_mut();
+    let is_interacting = ctx.wants_pointer_input() || ctx.is_pointer_over_area();
+
+    for mut pancam in cam_query.iter_mut() {
+        pancam.enabled = !is_interacting;
+    }
+}
+
+fn editor_ui(
+    mut contexts: EguiContexts,
+    mut editor_state: ResMut<EditorState>,
+    mut map_size: ResMut<MapSize>,
+    settings: Res<SimSettings>,
+    config: Res<SimConfig>,
+) {
+    if !settings.is_show_menu { return; }
+    
+    let ctx = contexts.ctx_mut();
+    
+    egui::Window::new("Editor Toolbar")
+        .anchor(egui::Align2::CENTER_BOTTOM, egui::vec2(0.0, -10.0))
+        .title_bar(false)
+        .collapsible(false)
+        .show(ctx, |ui| {
+             ui.horizontal(|ui| {
+                 ui.selectable_value(&mut editor_state.selected_tool, EditorTool::None, "View/Select");
+                 ui.selectable_value(&mut editor_state.selected_tool, EditorTool::BrushObstacle, "Draw Wall");
+                 ui.selectable_value(&mut editor_state.selected_tool, EditorTool::EraserObstacle, "Eraser");
+                 ui.selectable_value(&mut editor_state.selected_tool, EditorTool::PlaceFood, "Place Food");
+                 ui.selectable_value(&mut editor_state.selected_tool, EditorTool::RemoveFood, "Remove Food");
+                 
+                 if editor_state.selected_tool == EditorTool::BrushObstacle || editor_state.selected_tool == EditorTool::EraserObstacle {
+                      ui.add(egui::Slider::new(&mut editor_state.brush_size, 5.0..=100.0).text("Brush Size"));
+                 }
+                 
+                 ui.separator();
+                 ui.label("Map Size:");
+                 ui.add(egui::Slider::new(&mut map_size.width, 500.0..=5000.0).text("W"));
+                 ui.add(egui::Slider::new(&mut map_size.height, 500.0..=5000.0).text("H"));
+                 
+                 ui.separator();
+                 if ui.button("Save Config").clicked() {
+                     let saved = SavedConfig {
+                         sim_config: (*config).clone(),
+                         map_size: (*map_size).clone(),
+                     };
+                     if let Ok(json) = serde_json::to_string_pretty(&saved) {
+                         // write to current working directory
+                         if let Err(e) = std::fs::write("user_config.json", json) {
+                             eprintln!("Failed to save config: {}", e);
+                         } else {
+                             println!("Saved config to user_config.json");
+                         }
+                     }
+                 }
+             });
+        });
+}
+
+fn handle_editor_input(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut obstacle_map: ResMut<ObstacleMap>,
+    map_size: Res<MapSize>,
+    editor_state: Res<EditorState>,
+    windows: Query<&Window>,
+    camera_q: Query<(&Camera, &GlobalTransform), With<PanCam>>,
+    mouse_btn: Res<Input<MouseButton>>,
+    food_query: Query<(Entity, &Transform), With<Food>>,
+    mut contexts: EguiContexts,
+    mut last_drag_pos: Local<Option<Vec2>>,
+) {
+    if editor_state.selected_tool == EditorTool::None { 
+        *last_drag_pos = None;
+        return; 
+    }
+    
+    // Check if mouse is interacting with UI
+    let ctx = contexts.ctx_mut();
+    if ctx.is_pointer_over_area() || ctx.wants_pointer_input() {
+        *last_drag_pos = None;
+        return;
+    }
+
+    if camera_q.is_empty() { return; }
+    
+    // Reset drag if mouse not pressed
+    if !mouse_btn.pressed(MouseButton::Left) {
+        *last_drag_pos = None;
+    }
+
+    let (camera, camera_transform) = camera_q.single();
+    if let Some(window) = windows.iter().next() {
+        if let Some(cursor_pos) = window.cursor_position() {
+             if let Some(ray) = camera.viewport_to_world(camera_transform, cursor_pos) {
+                 let world_pos = ray.origin.truncate();
+                 
+                  match editor_state.selected_tool {
+                      EditorTool::BrushObstacle | EditorTool::EraserObstacle => {
+                          if mouse_btn.pressed(MouseButton::Left) {
+                              let is_brush = editor_state.selected_tool == EditorTool::BrushObstacle;
+                              
+                              // Interpolation Logic
+                              let start = last_drag_pos.unwrap_or(world_pos);
+                              let dist = start.distance(world_pos);
+                              let step = (editor_state.brush_size * 0.25).max(1.0);
+                              
+                              if dist > step {
+                                  let steps = (dist / step).ceil() as i32;
+                                  for i in 0..=steps {
+                                       let t = i as f32 / steps as f32;
+                                       let p = start.lerp(world_pos, t);
+                                       obstacle_map.set_obstacle(p.x, p.y, map_size.width, map_size.height, is_brush, editor_state.brush_size);
+                                  }
+                              } else {
+                                  obstacle_map.set_obstacle(world_pos.x, world_pos.y, map_size.width, map_size.height, is_brush, editor_state.brush_size);
+                              }
+                              
+                              *last_drag_pos = Some(world_pos);
+                          }
+                      },
+                      EditorTool::PlaceFood => {
+                          if mouse_btn.just_pressed(MouseButton::Left) {
+                              commands.spawn((
+                                  SpriteBundle {
+                                      texture: asset_server.load(SPRITE_FOOD),
+                                      transform: Transform::from_xyz(world_pos.x, world_pos.y, 2.0)
+                                          .with_scale(Vec3::splat(FOOD_SPRITE_SCALE)),
+                                      sprite: Sprite {
+                                          color: Color::rgb(1.5, 1.5, 1.5),
+                                          ..default()
+                                      },
+                                      ..default()
+                                  },
+                                  Food { storage: 1000 },
+                              ));
+                          }
+                      },
+                      EditorTool::RemoveFood => {
+                          if mouse_btn.pressed(MouseButton::Left) {
+                              for (entity, tr) in food_query.iter() {
+                                  if tr.translation.truncate().distance_squared(world_pos) < 30.0 * 30.0 {
+                                      commands.entity(entity).despawn();
+                                  }
+                              }
+                          }
+                      },
+                      _ => {},
+                  }
+             }
         }
     }
 }
+
+#[derive(Serialize, Deserialize)]
+struct SavedConfig {
+    sim_config: SimConfig,
+    map_size: MapSize,
+}
+
+fn load_config(
+    mut sim_config: ResMut<SimConfig>,
+    mut map_size: ResMut<MapSize>,
+) {
+    // Try to load user_config.json
+    if let Ok(content) = std::fs::read_to_string("user_config.json") {
+       if let Ok(saved) = serde_json::from_str::<SavedConfig>(&content) {
+           *sim_config = saved.sim_config;
+           *map_size = saved.map_size;
+           println!("Loaded user config from user_config.json");
+       } else {
+           println!("Failed to parse user_config.json");
+       }
+    } else {
+        println!("No user_config.json found, using defaults.");
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 3803188..5a8870a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,6 +4,7 @@ pub mod grid;
 pub mod gui;
 pub mod pathviz;
 pub mod pheromone;
+pub mod map;
 pub mod utils;
 
 pub use configs::*;
diff --git a/src/main.rs b/src/main.rs
index 50a9067..c38e8a5 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,6 +3,7 @@ use ants::{
     gui::{GuiPlugin, SimSettings},
     pathviz::PathVizPlugin,
     pheromone::PheromonePlugin,
+    map::MapPlugin,
     *,
 };
 use bevy::{
@@ -12,12 +13,28 @@ use bevy::{
     prelude::*,
 };
 use bevy_pancam::{PanCam, PanCamPlugin};
-
+use std::{thread, time::{Duration, Instant}};
 #[derive(Component)]
 struct FollowCamera;
 
+#[derive(Resource)]
+struct FrameLimiter {
+    last_frame: Instant,
+    target_fps: Option<u32>,
+}
+
+impl Default for FrameLimiter {
+    fn default() -> Self {
+        Self {
+            last_frame: Instant::now(),
+            target_fps: Some(60),
+        }
+    }
+}
+
 fn main() {
     App::new()
+        .init_resource::<FrameLimiter>()
         .add_plugins(
             DefaultPlugins
                 .set(ImagePlugin::default_nearest())
@@ -46,10 +63,13 @@ fn main() {
         // Systems
         .add_systems(Startup, setup)
         .add_systems(Update, ant_follow_camera)
+        .add_systems(Update, update_border_size)
+        .add_systems(Last, limit_fps)
         // Internal Plugins
         .add_plugins(AntPlugin)
         .add_plugins(PheromonePlugin)
         .add_plugins(PathVizPlugin)
+        .add_plugins(MapPlugin)
         .add_plugins(GuiPlugin)
         .run();
 }
@@ -64,10 +84,14 @@ fn ant_follow_camera(
     }
 
     let mut transform = camera_query.single_mut();
-    transform.translation = vec3(ant_pos.0.x, ant_pos.0.y, ANT_Z_INDEX);
+    transform.translation = vec3(ant_pos.0.x, ant_pos.0.y, ANT_Z_INDEX + 500.0);
 }
 
-fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+fn setup(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut images: ResMut<Assets<Image>>,
+) {
     commands
         .spawn((
             Camera2dBundle {
@@ -76,12 +100,16 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
                     ..default()
                 },
                 tonemapping: Tonemapping::TonyMcMapface,
+                transform: Transform::from_xyz(0.0, 0.0, 500.0),
                 ..default()
             },
             BloomSettings::default(),
             FollowCamera,
         ))
-        .insert(PanCam::default());
+        .insert(PanCam {
+            grab_buttons: vec![MouseButton::Right, MouseButton::Middle],
+            ..default()
+        });
 
     // Ant colony sprite
     commands.spawn(SpriteBundle {
@@ -95,15 +123,109 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
         ..Default::default()
     });
 
-    // Food sprite
-    commands.spawn(SpriteBundle {
-        texture: asset_server.load(SPRITE_FOOD),
-        sprite: Sprite {
-            color: Color::rgb(1.5, 1.5, 1.5),
-            ..default()
-        },
-        transform: Transform::from_xyz(FOOD_LOCATION.0, FOOD_LOCATION.1, 2.0)
-            .with_scale(Vec3::splat(FOOD_SPRITE_SCALE)),
-        ..Default::default()
-    });
+    // Programmatic Border (Glass Tank Effect)
+    // Create a 1x1 White Pixel Texture
+    let image = Image::new_fill(
+        bevy::render::render_resource::Extent3d { width: 1, height: 1, depth_or_array_layers: 1 },
+        bevy::render::render_resource::TextureDimension::D2,
+        &[255, 255, 255, 255],
+        bevy::render::render_resource::TextureFormat::Rgba8Unorm,
+    );
+    let handle = images.add(image);
+    let color = Color::rgba(0.5, 0.8, 1.0, 0.5); // Cyan Glass
+    
+    // Spawn 4 segments with placeholder transforms (updated by system immediately)
+    let segments = vec![BorderSegment::Top, BorderSegment::Bottom, BorderSegment::Left, BorderSegment::Right];
+    for segment in segments {
+        commands.spawn((
+            SpriteBundle {
+                texture: handle.clone(),
+                sprite: Sprite {
+                    color,
+                    custom_size: Some(Vec2::new(100.0, 100.0)), // Initial
+                    ..default()
+                },
+                transform: Transform::from_xyz(0.0, 0.0, 20.0), 
+                ..default()
+            },
+            MapBorder,
+            segment,
+        ));
+    }
+}
+
+#[derive(Component)]
+struct MapBorder;
+
+#[derive(Component)]
+enum BorderSegment {
+    Top, Bottom, Left, Right
+}
+
+fn update_border_size(
+    map_size: Res<ants::map::MapSize>,
+    mut query: Query<(&mut Sprite, &mut Transform, &BorderSegment), With<MapBorder>>,
+) {
+    if map_size.is_changed() {
+        let w = map_size.width;
+        let h = map_size.height;
+        let t = 20.0; // Thickness
+        
+        for (mut sprite, mut transform, segment) in query.iter_mut() {
+             match segment {
+                 BorderSegment::Top => {
+                     sprite.custom_size = Some(Vec2::new(w + 2.0 * t, t));
+                     transform.translation.y = h / 2.0 + t / 2.0;
+                     transform.translation.x = 0.0;
+                 },
+                 BorderSegment::Bottom => {
+                     sprite.custom_size = Some(Vec2::new(w + 2.0 * t, t));
+                     transform.translation.y = -(h / 2.0 + t / 2.0);
+                     transform.translation.x = 0.0;
+                 },
+                 BorderSegment::Left => {
+                     sprite.custom_size = Some(Vec2::new(t, h));
+                     transform.translation.x = -(w / 2.0 + t / 2.0);
+                     transform.translation.y = 0.0;
+                 },
+                 BorderSegment::Right => {
+                     sprite.custom_size = Some(Vec2::new(t, h));
+                     transform.translation.x = w / 2.0 + t / 2.0;
+                     transform.translation.y = 0.0;
+                 },
+             }
+        }
+    }
+}
+
+fn limit_fps(mut limiter: ResMut<FrameLimiter>, keys: Res<Input<KeyCode>>) {
+    if keys.just_pressed(KeyCode::Minus) {
+        if limiter.target_fps.is_none() {
+            limiter.target_fps = Some(60);
+            println!("Speed: Normal (60 FPS)");
+        } else if limiter.target_fps == Some(60) {
+            limiter.target_fps = Some(30);
+            println!("Speed: Slow (30 FPS)");
+        }
+    }
+    if keys.just_pressed(KeyCode::Equals) {
+        if limiter.target_fps == Some(30) {
+            limiter.target_fps = Some(60);
+            println!("Speed: Normal (60 FPS)");
+        } else if limiter.target_fps == Some(60) {
+            limiter.target_fps = None;
+            println!("Speed: Fast (Unlimited)");
+        }
+    }
+
+    if let Some(target_fps) = limiter.target_fps {
+        if target_fps > 0 {
+            let target_duration = Duration::from_secs_f32(1.0 / target_fps as f32);
+            let elapsed = limiter.last_frame.elapsed();
+            if elapsed < target_duration {
+                thread::sleep(target_duration - elapsed);
+            }
+        }
+    }
+    limiter.last_frame = Instant::now();
 }
diff --git a/src/map.rs b/src/map.rs
new file mode 100644
index 0000000..571ebf5
--- /dev/null
+++ b/src/map.rs
@@ -0,0 +1,266 @@
+use bevy::prelude::*;
+use crate::configs::{W, H, PH_UNIT_GRID_SIZE};
+use serde::{Deserialize, Serialize};
+
+#[derive(Resource, Serialize, Deserialize, Clone, Copy)]
+pub struct MapSize {
+    pub width: f32,
+    pub height: f32,
+}
+
+impl Default for MapSize {
+    fn default() -> Self {
+        Self {
+            width: W,
+            height: H,
+        }
+    }
+}
+
+#[derive(Resource)]
+pub struct ObstacleMap {
+    pub grid: Vec<bool>, // true = obstacle
+    pub width: usize,
+    pub height: usize,
+    pub texture_handle: Handle<Image>,
+}
+
+impl Default for ObstacleMap {
+    fn default() -> Self {
+        Self {
+            grid: vec![], // Initialized in setup
+            width: 0,
+            height: 0,
+            texture_handle: Handle::default(),
+        }
+    }
+}
+
+impl ObstacleMap {
+    pub fn new(w: f32, h: f32) -> Self {
+        let cols = (w as usize / PH_UNIT_GRID_SIZE) + 1;
+        let rows = (h as usize / PH_UNIT_GRID_SIZE) + 1;
+        Self {
+            grid: vec![false; cols * rows],
+            width: cols,
+            height: rows,
+            texture_handle: Handle::default(),
+        }
+    }
+
+    pub fn is_obstacle_in_radius(&self, x: f32, y: f32, radius: f32, map_w: f32, map_h: f32) -> bool {
+        let grid_radius = (radius / PH_UNIT_GRID_SIZE as f32).ceil() as isize;
+        let center_grid_x = ((x + map_w / 2.0) / PH_UNIT_GRID_SIZE as f32) as isize;
+        let center_grid_y = ((y + map_h / 2.0) / PH_UNIT_GRID_SIZE as f32) as isize;
+
+        // Optimization: check center first
+        if self.is_obstacle_at_index(center_grid_x, center_grid_y) { return true; }
+        
+        // Check bounding box in grid
+        for dy in -grid_radius..=grid_radius {
+            for dx in -grid_radius..=grid_radius {
+                if dx == 0 && dy == 0 { continue; }
+                
+                // Simple distance check to preserve circle shape roughly
+                // Or just box check is fine for "at least one touch"
+                if (dx*dx + dy*dy) as f32 > (grid_radius as f32 * grid_radius as f32) + 1.0 { continue; }
+                
+                let gx = center_grid_x + dx;
+                let gy = center_grid_y + dy;
+                
+                if self.is_obstacle_at_index(gx, gy) {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+    
+    fn is_obstacle_at_index(&self, gx: isize, gy: isize) -> bool {
+         if gx < 0 || gx >= self.width as isize || gy < 0 || gy >= self.height as isize {
+             return true; // Treat OOB as obstacle
+         }
+         self.grid[gy as usize * self.width + gx as usize]
+    }
+    
+    pub fn is_obstacle(&self, x: f32, y: f32, map_w: f32, map_h: f32) -> bool {
+         let grid_x = ((x + map_w / 2.0) / PH_UNIT_GRID_SIZE as f32) as isize;
+         let grid_y = ((y + map_h / 2.0) / PH_UNIT_GRID_SIZE as f32) as isize;
+         self.is_obstacle_at_index(grid_x, grid_y)
+    }
+
+    pub fn set_obstacle(&mut self, x: f32, y: f32, map_w: f32, map_h: f32, is_obstacle: bool, brush_size: f32) {
+        let center_grid_x = ((x + map_w / 2.0) / PH_UNIT_GRID_SIZE as f32) as isize;
+        let center_grid_y = ((y + map_h / 2.0) / PH_UNIT_GRID_SIZE as f32) as isize;
+        let radius = (brush_size / PH_UNIT_GRID_SIZE as f32).ceil() as isize;
+
+        for dy in -radius..=radius {
+            for dx in -radius..=radius {
+                if dx*dx + dy*dy > radius*radius { continue; }
+                
+                let gx = center_grid_x + dx;
+                let gy = center_grid_y + dy;
+
+                if gx >= 0 && gx < self.width as isize && gy >= 0 && gy < self.height as isize {
+                    self.grid[gy as usize * self.width + gx as usize] = is_obstacle;
+                }
+            }
+        }
+    }
+    
+    pub fn has_line_of_sight(&self, start: Vec2, end: Vec2, map_w: f32, map_h: f32) -> bool {
+         let grid_x0 = ((start.x + map_w / 2.0) / PH_UNIT_GRID_SIZE as f32) as isize;
+         let grid_y0 = ((start.y + map_h / 2.0) / PH_UNIT_GRID_SIZE as f32) as isize;
+         
+         let grid_x1 = ((end.x + map_w / 2.0) / PH_UNIT_GRID_SIZE as f32) as isize;
+         let grid_y1 = ((end.y + map_h / 2.0) / PH_UNIT_GRID_SIZE as f32) as isize;
+         
+         let dx = (grid_x1 - grid_x0).abs();
+         let dy = -(grid_y1 - grid_y0).abs();
+         let sx = if grid_x0 < grid_x1 { 1 } else { -1 };
+         let sy = if grid_y0 < grid_y1 { 1 } else { -1 };
+         let mut err = dx + dy;
+         
+         let mut x = grid_x0;
+         let mut y = grid_y0;
+         
+         loop {
+             if self.is_obstacle_at_index(x, y) {
+                 return false;
+             }
+             if x == grid_x1 && y == grid_y1 { break; }
+             
+             let e2 = 2 * err;
+             if e2 >= dy {
+                 err += dy;
+                 x += sx;
+             }
+             if e2 <= dx {
+                 err += dx;
+                 y += sy;
+             }
+         }
+         true
+    }
+
+    pub fn clear(&mut self) {
+        self.grid.fill(false);
+    }
+}
+
+pub struct MapPlugin;
+
+impl Plugin for MapPlugin {
+    fn build(&self, app: &mut App) {
+        app.insert_resource(MapSize::default())
+           .insert_resource(ObstacleMap::new(W, H))
+           .add_systems(Startup, setup_obstacle_texture)
+           .add_systems(Update, (resize_obstacle_map, update_obstacle_texture));
+    }
+}
+
+// ... setup_obstacle_texture ...
+
+fn setup_obstacle_texture(
+    mut commands: Commands,
+    mut images: ResMut<Assets<Image>>,
+    mut obstacle_map: ResMut<ObstacleMap>,
+    _map_size: Res<MapSize>,
+) {
+    let w = obstacle_map.width;
+    let h = obstacle_map.height;
+    
+    // Create a transparent image
+    let image = Image::new_fill(
+        bevy::render::render_resource::Extent3d {
+            width: w as u32,
+            height: h as u32,
+            depth_or_array_layers: 1,
+        },
+        bevy::render::render_resource::TextureDimension::D2,
+        &[0, 0, 0, 0],
+        bevy::render::render_resource::TextureFormat::Rgba8Unorm,
+    );
+    
+    let handle = images.add(image);
+    obstacle_map.texture_handle = handle.clone();
+
+    commands.spawn(SpriteBundle {
+        texture: handle,
+        transform: Transform::from_xyz(0.0, 0.0, 1.0) // Z-index 1.0 (below ants, above bg)
+            .with_scale(Vec3::splat(PH_UNIT_GRID_SIZE as f32)),
+        ..default()
+    });
+}
+
+
+fn resize_obstacle_map(
+    mut obstacle_map: ResMut<ObstacleMap>,
+    map_size: Res<MapSize>,
+    mut images: ResMut<Assets<Image>>,
+) {
+    if map_size.is_changed() {
+        let new_w = (map_size.width as usize / PH_UNIT_GRID_SIZE) + 1;
+        let new_h = (map_size.height as usize / PH_UNIT_GRID_SIZE) + 1;
+        
+        if new_w != obstacle_map.width || new_h != obstacle_map.height {
+            // Resize grid, preserving old data if possible? 
+            // For now, simpler to clear or create new. Let's just create new to match the requested size perfectly.
+            // Or better, creating a new struct instance but keeping texture handle?
+            obstacle_map.width = new_w;
+            obstacle_map.height = new_h;
+            obstacle_map.grid = vec![false; new_w * new_h];
+            
+            // Allow OOB logic to work correctly now with new dimensions.
+
+            // Also resize texture
+            if let Some(image) = images.get_mut(&obstacle_map.texture_handle) {
+                 image.resize(bevy::render::render_resource::Extent3d {
+                    width: new_w as u32,
+                    height: new_h as u32,
+                    depth_or_array_layers: 1,
+                });
+                // Initialize with transparent
+                image.data = vec![0; new_w * new_h * 4];
+            }
+        }
+    }
+}
+
+fn update_obstacle_texture(
+    obstacle_map: Res<ObstacleMap>,
+    mut images: ResMut<Assets<Image>>,
+) {
+    if obstacle_map.is_changed() {
+        if let Some(image) = images.get_mut(&obstacle_map.texture_handle) {
+            // Check if sizes match to avoid panic during resize
+            if image.size().x as usize != obstacle_map.width || image.size().y as usize != obstacle_map.height {
+                return;
+            }
+
+            for y in 0..obstacle_map.height {
+                // Flip Y for display because World Y-up corresponds to Image Y-down usually in these mappings
+                // Our grid: 0 is bottom (-H/2). Image: 0 is top.
+                let img_y = obstacle_map.height.saturating_sub(1) - y;
+                
+                for x in 0..obstacle_map.width {
+                    let idx = y * obstacle_map.width + x;
+                    let is_obs = obstacle_map.grid[idx];
+                    
+                    let pixel_idx = (img_y * obstacle_map.width + x) * 4;
+                    
+                    if pixel_idx + 3 < image.data.len() {
+                        if is_obs {
+                            image.data[pixel_idx] = 100;   // R
+                            image.data[pixel_idx + 1] = 100; // G
+                            image.data[pixel_idx + 2] = 100; // B
+                            image.data[pixel_idx + 3] = 255; // Alpha
+                        } else {
+                            image.data[pixel_idx + 3] = 0;   // Transparent
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/pathviz.rs b/src/pathviz.rs
index 7c65dec..1d86b0c 100644
--- a/src/pathviz.rs
+++ b/src/pathviz.rs
@@ -2,7 +2,6 @@ use crate::{
     ant::{Ant, AntTask, CurrentTask},
     grid::{add_map_to_grid_img, DecayGrid},
     gui::SimSettings,
-    utils::window_to_grid,
     *,
 };
 use bevy::{
@@ -65,18 +64,26 @@ fn update_viz_grid_visibility(
 fn update_grid_values(
     ant_query: Query<(&Transform, &CurrentTask), With<Ant>>,
     mut viz_grid: ResMut<PathVizGrid>,
+    map_size: Res<crate::map::MapSize>,
 ) {
+    let w_map = map_size.width;
+    let h_map = map_size.height;
+    
     for (transform, current_task) in ant_query.iter() {
         let x = transform.translation.x as i32;
         let y = transform.translation.y as i32;
-        let key = window_to_grid(x, y);
+        
+        // Inline window_to_grid logic with dynamic size
+        let k_x = (x + (w_map as i32 / 2)) / PH_UNIT_GRID_SIZE as i32;
+        let k_y = ((h_map as i32 / 2) - y) / PH_UNIT_GRID_SIZE as i32;
+        let key = (k_x, k_y);
 
         match current_task.0 {
             AntTask::FindFood => {
-                viz_grid.dg_food.add_value(&key, VIZ_COLOR_STRENGTH, 5.0);
+                viz_grid.dg_food.add_value(&key, VIZ_COLOR_STRENGTH, 5.0, 1000.0);
             }
             AntTask::FindHome => {
-                viz_grid.dg_home.add_value(&key, VIZ_COLOR_STRENGTH, 5.0);
+                viz_grid.dg_home.add_value(&key, VIZ_COLOR_STRENGTH, 5.0, 1000.0);
             }
         }
     }
@@ -91,25 +98,34 @@ fn update_path_viz_image(
     mut textures: ResMut<Assets<Image>>,
     viz_grid: Res<PathVizGrid>,
     mut query: Query<&mut Handle<Image>, With<PathVizImageRender>>,
+    map_size: Res<crate::map::MapSize>,
 ) {
     let mut img_handle = query.single_mut();
     let (w, h) = (
-        W as usize / PH_UNIT_GRID_SIZE,
-        H as usize / PH_UNIT_GRID_SIZE,
+        map_size.width as usize / PH_UNIT_GRID_SIZE,
+        map_size.height as usize / PH_UNIT_GRID_SIZE,
     );
 
     let mut bytes = vec![0; w * h * 4];
     add_map_to_grid_img(
         viz_grid.dg_food.get_values(),
-        &VIZ_COLOR_TO_FOOD,
         &mut bytes,
         false,
+        map_size.width,
+        map_size.height,
+        VIZ_MAX_COLOR_STRENGTH, 
+        VIZ_COLOR_TO_FOOD,
+        VIZ_COLOR_TO_FOOD,
     );
     add_map_to_grid_img(
         viz_grid.dg_home.get_values(),
-        &VIZ_COLOR_TO_HOME,
         &mut bytes,
         false,
+        map_size.width,
+        map_size.height,
+        VIZ_MAX_COLOR_STRENGTH,
+        VIZ_COLOR_TO_HOME,
+        VIZ_COLOR_TO_HOME,
     );
 
     let path_img = Image::new(
@@ -125,6 +141,7 @@ fn update_path_viz_image(
     *img_handle = textures.add(path_img);
 }
 
+
 impl PathVizGrid {
     fn new() -> Self {
         Self {
diff --git a/src/pheromone.rs b/src/pheromone.rs
index 5a224f6..7723bea 100644
--- a/src/pheromone.rs
+++ b/src/pheromone.rs
@@ -1,6 +1,6 @@
 use crate::{
     grid::{add_map_to_grid_img, WorldGrid},
-    gui::{SimSettings, SimStatistics},
+    gui::{ResetSimEvent, SimConfig, SimSettings, SimStatistics},
     *,
 };
 use bevy::{
@@ -27,13 +27,17 @@ impl Plugin for PheromonePlugin {
             .insert_resource(Pheromones::new())
             .add_systems(
                 Update,
-                pheromone_decay.run_if(on_timer(Duration::from_secs_f32(PH_DECAY_INTERVAL))),
+                (
+                    pheromone_decay.run_if(on_timer(Duration::from_secs_f32(PH_DECAY_INTERVAL))),
+                    update_kd_tree.run_if(on_timer(Duration::from_secs_f32(
+                        PH_KD_TREE_UPDATE_INTERVAL,
+                    ))),
+                    clean_zero_signals.run_if(on_timer(Duration::from_secs_f32(2.0))),
+                ).run_if(run_if_not_paused)
             )
             .add_systems(
                 Update,
-                update_kd_tree.run_if(on_timer(Duration::from_secs_f32(
-                    PH_KD_TREE_UPDATE_INTERVAL,
-                ))),
+                pheromone_image_update.run_if(on_timer(Duration::from_secs_f32(PH_IMG_UPDATE_SEC))),
             )
             .add_systems(
                 Update,
@@ -41,20 +45,26 @@ impl Plugin for PheromonePlugin {
                     PH_KD_TREE_UPDATE_INTERVAL,
                 ))),
             )
-            .add_systems(
-                Update,
-                clean_zero_signals.run_if(on_timer(Duration::from_secs_f32(2.0))),
-            )
-            .add_systems(
-                Update,
-                pheromone_image_update.run_if(on_timer(Duration::from_secs_f32(PH_IMG_UPDATE_SEC))),
-            );
+            .add_systems(Update, reset_pheromones);
+    }
+}
+
+fn run_if_not_paused(settings: Res<SimSettings>) -> bool {
+    !settings.is_paused
+}
+
+fn reset_pheromones(
+    mut events: EventReader<ResetSimEvent>,
+    mut pheromones: ResMut<Pheromones>,
+) {
+    for _ in events.iter() {
+        *pheromones = Pheromones::new();
     }
 }
 
-fn pheromone_decay(mut pheromones: ResMut<Pheromones>) {
-    pheromones.to_food.decay_signals();
-    pheromones.to_home.decay_signals();
+fn pheromone_decay(mut pheromones: ResMut<Pheromones>, config: Res<SimConfig>) {
+    pheromones.to_food.decay_signals(config.ph_decay_rate);
+    pheromones.to_home.decay_signals(config.ph_decay_rate);
 }
 
 fn update_sim_stats(pheromones: Res<Pheromones>, mut stats: ResMut<SimStatistics>) {
@@ -76,28 +86,38 @@ fn pheromone_image_update(
     sim_settings: Res<SimSettings>,
     pheromone: Res<Pheromones>,
     mut image_handle_query: Query<&mut Handle<Image>, With<PheromoneImageRender>>,
+    map_size: Res<crate::map::MapSize>,
+    config: Res<SimConfig>,
 ) {
     let mut img_handle = image_handle_query.single_mut();
     let (w, h) = (
-        W as usize / PH_UNIT_GRID_SIZE,
-        H as usize / PH_UNIT_GRID_SIZE,
+        map_size.width as usize / PH_UNIT_GRID_SIZE,
+        map_size.height as usize / PH_UNIT_GRID_SIZE,
     );
     let mut bytes = vec![0; w * h * 4];
 
     if sim_settings.is_show_home_ph {
         add_map_to_grid_img(
             pheromone.to_home.get_signals(),
-            &pheromone.to_home.color,
             &mut bytes,
             true,
+            map_size.width,
+            map_size.height,
+            config.max_pheromone_strength,
+            pheromone.to_home.color,
+            (255, 0, 0), // Deep Red for Home Pheromone Max
         );
     }
     if sim_settings.is_show_food_ph {
         add_map_to_grid_img(
             pheromone.to_food.get_signals(),
-            &pheromone.to_food.color,
             &mut bytes,
             true,
+            map_size.width,
+            map_size.height,
+            config.max_pheromone_strength,
+            pheromone.to_food.color,
+            (0, 0, 255), // Deep Blue for Food Pheromone Max
         );
     }
 
@@ -131,7 +151,7 @@ impl Pheromones {
         let mut to_home_map = HashMap::new();
 
         // Food and Home have high pheromone strength
-        to_food_map.insert((FOOD_LOCATION.0 as i32, FOOD_LOCATION.1 as i32), 100000.0);
+        // to_food_map.insert((FOOD_LOCATION.0 as i32, FOOD_LOCATION.1 as i32), 100000.0);
         to_home_map.insert((HOME_LOCATION.0 as i32, HOME_LOCATION.1 as i32), 100000.0);
 
         Self {
diff --git a/user_config.json b/user_config.json
new file mode 100644
index 0000000..b476e7e
--- /dev/null
+++ b/user_config.json
@@ -0,0 +1,18 @@
+{
+  "sim_config": {
+    "ph_decay_rate": 0.7,
+    "ant_ph_strength_decay_rate": 0.5,
+    "ant_sensor_dist": 100.0,
+    "ant_sensor_angle": 60.0,
+    "ant_turn_randomness": 0.3,
+    "ant_update_interval": 0.1,
+    "ants_count": 1000,
+    "ant_target_auto_pull_radius": 200.0,
+    "ant_steering_force_factor": 20.0,
+    "max_pheromone_strength": 1000.0
+  },
+  "map_size": {
+    "width": 3000.0,
+    "height": 1900.0
+  }
+}
\ No newline at end of file