diff --git a/assets/textures/ground/flowers1.png b/assets/textures/ground/flowers1.png
deleted file mode 100644
index 143f175..0000000
Binary files a/assets/textures/ground/flowers1.png and /dev/null differ
diff --git a/assets/textures/ground/flowers2.png b/assets/textures/ground/flowers2.png
deleted file mode 100644
index 4f1f847..0000000
Binary files a/assets/textures/ground/flowers2.png and /dev/null differ
diff --git a/assets/textures/ground/grass1.png b/assets/textures/ground/grass1.png
index 7c8db0f..3a7d161 100644
Binary files a/assets/textures/ground/grass1.png and b/assets/textures/ground/grass1.png differ
diff --git a/assets/textures/ground/grass2.png b/assets/textures/ground/grass2.png
index b3fdcce..dd5bf5f 100644
Binary files a/assets/textures/ground/grass2.png and b/assets/textures/ground/grass2.png differ
diff --git a/assets/textures/ground/ground.png b/assets/textures/ground/ground.png
index 7f21173..84083bb 100644
Binary files a/assets/textures/ground/ground.png and b/assets/textures/ground/ground.png differ
diff --git a/src/bees.rs b/src/bees.rs
index f69d52e..efc4625 100644
--- a/src/bees.rs
+++ b/src/bees.rs
@@ -16,6 +16,7 @@ use crate::{
 
 use crate::interactions::{MousePosition, Highlightable};
 use bevy::prelude::*;
+use crate::tilemap::FogTile;
 // use bevy::window::PrimaryWindow;
 
 pub struct BeesPlugin;
@@ -27,6 +28,7 @@ impl Plugin for BeesPlugin {
             .add_systems(Update, create_boid_group.run_if(in_state(GameState::Playing)))
             .add_systems(Update, place_bee.run_if(in_state(GameState::Playing)))
             .add_systems(Update, animate_wings.run_if(in_state(GameState::Playing)))
+            // .add_systems(Update, clear_fog.run_if(in_state(GameState::Playing)))
             .add_systems(
                 Update,
                 (build_or_update_quadtree, update_boids, move_system).run_if(
@@ -78,10 +80,10 @@ pub struct Bee;
 
 #[derive(Component)]
 pub enum BeeBehavior {
-    Traveling(Vec2), // Destination coordinates
-    Wondering(Vec2), // Point of origin coordinates
-    Exploring(Vec2), // Point of origin coordinates
-    Interacting(Vec2), // Coordinates of interactable object
+    // Traveling(Vec2), // Destination coordinates
+    Destination(Vec2), // Point of origin coordinates
+    // Exploring(Vec2), // Point of origin coordinates
+    // Interacting(Vec2), // Coordinates of interactable object
 }
 
 // Separate out these types of data???
@@ -125,11 +127,11 @@ impl BoidGroup {
             graph: QuadTree::new(region::Region::new(min, max)),
             id: team.0,
             count: 0,
-            separation: 0.3,
-            alignment: 0.4,
-            cohesion: 0.8,
-            speed: 40.0,
-            vision: 50.0,
+            separation: 0.5,
+            alignment: 0.3,
+            cohesion: 0.3,
+            speed: 240.0,
+            vision: 600.0,
         }
     }
 }
@@ -156,12 +158,12 @@ fn setup(mut _commands: Commands) {
 }
 
 #[derive(Component)]
-struct AnimationIndices {
-    first: usize,
-    last: usize,
+pub struct AnimationIndices {
+    pub first: usize,
+    pub last: usize,
 }
 #[derive(Component, Deref, DerefMut)]
-struct AnimationTimer(Timer);
+pub struct AnimationTimer(pub Timer);
 
 fn animate_wings(
     time: Res<Time>,
@@ -189,10 +191,16 @@ fn place_bee(
     textures: Res<TextureAssets>,
     mouse_input: Res<Input<MouseButton>>,
 ) {
+    let mut rng = rand::thread_rng();
+    let bee_body= if rng.gen::<bool>() {
+        textures.beebody1.clone()
+    } else {
+        textures.beebody2.clone()
+    };
     if mouse_input.just_pressed(MouseButton::Right) {
         let bee_entity = commands.spawn((
             SpriteBundle {
-                texture: textures.beebody1.clone(),
+                texture: bee_body,
                 transform: Transform::from_xyz(
                     mouse_position.0.x,
                     mouse_position.0.y,
@@ -201,20 +209,22 @@ fn place_bee(
                 ..default()
             },
             Bee,
-            BeeBehavior::Wondering(Vec2::new(mouse_position.0.x, mouse_position.0.y)),
+            BeeBehavior::Destination(Vec2::new(mouse_position.0.x, mouse_position.0.y)),
             Boid,
             Highlightable,
             Collider::new(5.0),
             Velocity::default(),
         )).id();
 
-        // Create the wings
-        let texture_atlas_handle = textures.bee1wingmap.clone();
-
         // Spawn the wings as a child of the bee body
+        let bee_wings= if rng.gen::<bool>() {
+            textures.bee1wingmap.clone()
+        } else {
+            textures.bee2wingmap.clone()
+        };
         commands.entity(bee_entity).with_children(|parent| {
             parent.spawn(SpriteSheetBundle {
-                texture_atlas: textures.bee1wingmap.clone(),
+                texture_atlas: bee_wings,
                 sprite: TextureAtlasSprite::new(0), // Set the initial sprite index
                 transform: Transform::from_xyz(0.0, 0.0, 1.0), // Adjust the position of the wings relative to the bee body
                 ..Default::default()
@@ -226,3 +236,26 @@ fn place_bee(
         info!("Bee spawned");
     }
 }
+
+fn _clear_fog(
+    mut commands: Commands,
+    bee_query: Query<&Transform, With<Bee>>,
+    mut fog_tile_query: Query<(Entity, &Transform), With<FogTile>>,
+) {
+    for bee_transform in bee_query.iter() {
+        // info!("Bee transform {:?}", bee_transform);
+        for (fog_tile_entity, fog_transform) in fog_tile_query.iter_mut() {
+            // info!("Fogtile transform {:?}", fog_transform);
+            let distance = bee_transform.translation.distance(fog_transform.translation);
+            info!("Distance {:?}", distance);
+            // Define a range where the fog tile should despawn (adjust this range as needed)
+            let despawn_range = 30000.0; // Modify this value to suit your needs
+
+            if distance < despawn_range {
+                // Despawn fog tile if it's within the despawn range of the bee
+                info!("Collision detected: Distance between bee and fog tile: {}", distance);
+                commands.entity(fog_tile_entity).despawn_recursive();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/boids.rs b/src/boids.rs
index 52fedb2..caa7cb0 100644
--- a/src/boids.rs
+++ b/src/boids.rs
@@ -23,6 +23,7 @@ pub fn create_boid_group(
     }
     let height = level_data.level_height;
     let width = level_data.level_width;
+    info!("Maximum width {}, height {}", width, height);
     comms.spawn(BoidGroup::new(
         Vec2::new(0., 0.),
         Vec2::new(width, height),
diff --git a/src/camera.rs b/src/camera.rs
index 3bcc330..269270e 100644
--- a/src/camera.rs
+++ b/src/camera.rs
@@ -20,7 +20,7 @@ fn setup_camera_controls(
     mut q_camera: Query<&mut OrthographicProjection, With<Camera2d>>,
 ) {
     let mut projection = q_camera.single_mut();
-    projection.scale = 0.6;
+    projection.scale = 4.0;
 }
 
 fn panning_controls
@@ -30,13 +30,13 @@ fn panning_controls
     level_data: Res<LevelData>
 )
 {
-    let pan_speed = 2.0;
+    let pan_speed = 10.0;
     let mut cam_transform = q_cam.single_mut();
     // info!("Cam Translation {:?}", cam_transform.translation);
     if keys.pressed(KeyCode::W) || keys.pressed(KeyCode::Up) {
         cam_transform.translation.y += pan_speed;
-        if cam_transform.translation.y > level_data.level_height as f32 {
-            cam_transform.translation.y = level_data.level_height as f32;
+        if cam_transform.translation.y > level_data.level_height {
+            cam_transform.translation.y = level_data.level_height;
         }
     }
     if keys.pressed(KeyCode::A) || keys.pressed(KeyCode::Left) {
@@ -53,8 +53,8 @@ fn panning_controls
     }
     if keys.pressed(KeyCode::D) || keys.pressed(KeyCode::Right) {
         cam_transform.translation.x += pan_speed;
-        if cam_transform.translation.x > level_data.level_width as f32 {
-            cam_transform.translation.x = level_data.level_width as f32;
+        if cam_transform.translation.x > level_data.level_width {
+            cam_transform.translation.x = level_data.level_width;
         }
     }
 }
@@ -67,8 +67,8 @@ fn zooming_controls
 
 ) {
     let zoom_speed = 0.2;
-    let max_scale = 5.0;
-    let min_scale = 0.2;
+    let max_scale = 10.0;
+    let min_scale = 1.0;
     for ev in scroll_evr.read() {
         use bevy::input::mouse::MouseScrollUnit;
         let mut projection = q_camera.single_mut();
diff --git a/src/debug/debug.rs b/src/debug/debug.rs
index 08237c6..50fdbdf 100644
--- a/src/debug/debug.rs
+++ b/src/debug/debug.rs
@@ -1,13 +1,14 @@
 use bevy::prelude::*;
-use rand::Rng;
+// use rand::Rng;
 
 use crate::{
-    bees::{Bee, BoidGroup, Collider, Velocity, BeeBehavior},
+    // bees::{Bee, BoidGroup, Collider, Velocity, BeeBehavior},
+    bees::BoidGroup,
     boids::Boid,
-    loading::TextureAssets,
+    // loading::TextureAssets,
     GameState,
 };
-use crate::interactions::Highlightable;
+// use crate::interactions::Highlightable;
 
 pub struct DebugPlugin;
 
@@ -22,7 +23,7 @@ impl Plugin for DebugPlugin {
                 (
                     visualize_quadtree,
                     visualize_boid_radius,
-                    spawn_random_boids,
+                    // spawn_random_boids,
                 )
                     .run_if(in_state(GameState::Playing)),
             );
@@ -37,7 +38,11 @@ pub struct Visualizer {
     pub boid_cone: bool,
 }
 
-pub fn visualize_quadtree(mut gizmos: Gizmos, vis: Res<Visualizer>, groups: Query<&BoidGroup>) {
+pub fn visualize_quadtree(mut gizmos: Gizmos, mut vis: ResMut<Visualizer>, groups: Query<&BoidGroup>, input: Res<Input<KeyCode>>) {
+    if input.just_pressed(KeyCode::Space) {
+        vis.quadtree = !vis.quadtree;
+        info!("Toggling quadtree to {:?}", vis.quadtree);
+    }
     if !vis.quadtree {
         return;
     }
@@ -80,38 +85,38 @@ pub fn visualize_boid_radius(
     }
 }
 
-fn spawn_random_boids(
-    mut commands: Commands,
-    input: Res<Input<KeyCode>>,
-    textures: Res<TextureAssets>,
-) {
-    // spawn in 1000 boids randomly in the field on press of some key
-    if input.just_pressed(KeyCode::Space) {
-        (0..1000).for_each(|_| {
-            let mut rng = rand::thread_rng();
-            let spawn_x = rng.gen_range(20.0..3820.0);
-            let spawn_y = rng.gen_range(20.0..2140.0);
-            commands.spawn((
-                SpriteSheetBundle {
-                    texture_atlas: textures.planes.clone(),
-                    sprite: TextureAtlasSprite::new(11),
-                    transform: Transform::from_xyz(
-                        spawn_x,
-                        spawn_y,
-                        5.0,
-                    ),
-                    ..default()
-                },
-                Bee,
-                Boid,
-                BeeBehavior::Wondering(Vec2::new(spawn_x, spawn_y)),
-                Highlightable,
-                Collider::new(5.0),
-                Velocity::default(),
-            ));
-        });
-    }
-}
+// fn spawn_random_boids(
+//     mut commands: Commands,
+//     input: Res<Input<KeyCode>>,
+//     textures: Res<TextureAssets>,
+// ) {
+//     // spawn in 1000 boids randomly in the field on press of some key
+//     if input.just_pressed(KeyCode::Space) {
+//         (0..1000).for_each(|_| {
+//             let mut rng = rand::thread_rng();
+//             let spawn_x = rng.gen_range(20.0..3820.0);
+//             let spawn_y = rng.gen_range(20.0..2140.0);
+//             commands.spawn((
+//                 SpriteSheetBundle {
+//                     texture_atlas: textures.planes.clone(),
+//                     sprite: TextureAtlasSprite::new(11),
+//                     transform: Transform::from_xyz(
+//                         spawn_x,
+//                         spawn_y,
+//                         5.0,
+//                     ),
+//                     ..default()
+//                 },
+//                 Bee,
+//                 Boid,
+//                 BeeBehavior::Wondering(Vec2::new(spawn_x, spawn_y)),
+//                 Highlightable,
+//                 Collider::new(5.0),
+//                 Velocity::default(),
+//             ));
+//         });
+//     }
+// }
 
 // this should create a window with a dropdown of all boidgroups and allow editing of all the values within
 // fn edit_boid_groups(groups: Query<&BoidGroup>) {
diff --git a/src/interactions.rs b/src/interactions.rs
index 7027e81..a8503e0 100644
--- a/src/interactions.rs
+++ b/src/interactions.rs
@@ -82,11 +82,11 @@ fn mouse_state_manager(
     mut q_entities: Query<(Entity, &Transform, Option<&Highlighted>), With<Highlightable>>,
 ) {
     for button in buttons.get_just_pressed() {
-        info!("{:?} is currently held down", button);
+        // info!("{:?} is currently held down", button);
         // mouse_state.0 = MouseStates::MouseDown;
         match button {
             MouseButton::Left => {
-                mouse_state.0 = { MouseStates::LeftDragging(mouse_position.0) };
+                mouse_state.0 = MouseStates::LeftDragging(mouse_position.0);
                 // TODO: Do something with the highlighted entities with an event at this point
                 highlighted_entities.0.clear();
             },
@@ -96,39 +96,33 @@ fn mouse_state_manager(
         }
     }
     for button in buttons.get_just_released() {
-        info!("{:?} has been released", button);
-        match button {
-            // On mouse left just released
-            MouseButton::Left => {
-                // If it was previously in the dragging state
-                if let MouseStates::LeftDragging(start_pos) = mouse_state.0 {
-                    // Grab the mouse dragged square region
-                    let min_x = start_pos.x.min(mouse_position.0.x);
-                    let max_x = start_pos.x.max(mouse_position.0.x);
-                    let min_y = start_pos.y.min(mouse_position.0.y);
-                    let max_y = start_pos.y.max(mouse_position.0.y);
-                    // For all entities with
-                    for (entity, transform, highlighted) in q_entities.iter_mut() {
-                        let entity_pos = transform.translation;
-                        // Check if their transform is in the square region
-                        if entity_pos.x >= min_x && entity_pos.x <= max_x &&
-                            entity_pos.y >= min_y && entity_pos.y <= max_y {
-                            // info!("Entity {:?} is inside the mouse square region.", entity);
-                            // Add them to the highlighted entities hashmap
-                            highlighted_entities.0.insert(entity);
-
-                            if let None = highlighted {
-                                commands.entity(entity).insert(Highlighted);
-                            }
-                        } else {
-                            if let Some(_) = highlighted {
-                                commands.entity(entity).remove::<Highlighted>();
-                            }
+        // info!("{:?} has been released", button);
+        if button == &MouseButton::Left {
+            // If it was previously in the dragging state
+            if let MouseStates::LeftDragging(start_pos) = mouse_state.0 {
+                // Grab the mouse dragged square region
+                let min_x = start_pos.x.min(mouse_position.0.x);
+                let max_x = start_pos.x.max(mouse_position.0.x);
+                let min_y = start_pos.y.min(mouse_position.0.y);
+                let max_y = start_pos.y.max(mouse_position.0.y);
+                // For all entities with
+                for (entity, transform, highlighted) in q_entities.iter_mut() {
+                    let entity_pos = transform.translation;
+                    // Check if their transform is in the square region
+                    if entity_pos.x >= min_x && entity_pos.x <= max_x &&
+                        entity_pos.y >= min_y && entity_pos.y <= max_y {
+                        info!("Entity {:?} is inside the mouse square region.", entity);
+                        // Add them to the highlighted entities hashmap
+                        highlighted_entities.0.insert(entity);
+
+                        if highlighted.is_none() {
+                            commands.entity(entity).insert(Highlighted);
                         }
+                    } else if highlighted.is_some() {
+                        commands.entity(entity).remove::<Highlighted>();
                     }
                 }
             }
-            _ => {}
         }
         mouse_state.0 = MouseStates::Default;
     }
@@ -140,42 +134,39 @@ fn draw_mouse_region
     mouse_position: Res<MousePosition>,
     mut gizmos: Gizmos
 ) {
-    match mouse_state.0 {
-        MouseStates::LeftDragging(pos) => {
-            // Diagonal debug line
-            // gizmos.line_2d(pos, mouse_position.0, Color::RED);
-            // Draw horizontal line
-            gizmos.line_2d(pos, Vec2::new(mouse_position.0.x, pos.y), Color::BLUE);
-            // Draw vertical line
-            gizmos.line_2d(pos, Vec2::new(pos.x, mouse_position.0.y), Color::BLUE);
-            // Draw connecting horizontal line
-            gizmos.line_2d(mouse_position.0, Vec2::new(pos.x, mouse_position.0.y), Color::BLUE);
-            // Draw connecting vertical line
-            gizmos.line_2d(mouse_position.0, Vec2::new(mouse_position.0.x, pos.y), Color::BLUE);
-        }
-        _ => {}
+    if let MouseStates::LeftDragging(pos) = mouse_state.0 {
+        // Diagonal debug line
+        // gizmos.line_2d(pos, mouse_position.0, Color::RED);
+        // Draw horizontal line
+        gizmos.line_2d(pos, Vec2::new(mouse_position.0.x, pos.y), Color::BLUE);
+        // Draw vertical line
+        gizmos.line_2d(pos, Vec2::new(pos.x, mouse_position.0.y), Color::BLUE);
+        // Draw connecting horizontal line
+        gizmos.line_2d(mouse_position.0, Vec2::new(pos.x, mouse_position.0.y), Color::BLUE);
+        // Draw connecting vertical line
+        gizmos.line_2d(mouse_position.0, Vec2::new(mouse_position.0.x, pos.y), Color::BLUE);
     }
 }
 
 fn bloom_highlighted_entities
 (
-    mut q_highlighted: Query<&mut TextureAtlasSprite, Added<Highlighted>>,
+    mut q_highlighted: Query<&mut Sprite, Added<Highlighted>>,
 ) {
     for mut texture in q_highlighted.iter_mut() {
         let col = texture.color.as_hsla();
-        texture.color = Color::hsla(col.h(), col.s(), col.l() * 1.5, col.a());
+        texture.color = Color::hsla(col.h(), col.s(), col.l() * 3.5, col.a());
     }
 }
 
 fn remove_bloom
 (
     mut removals: RemovedComponents<Highlighted>,
-    mut q_highlighted: Query<(Entity, &mut TextureAtlasSprite)>
+    mut q_highlighted: Query<(Entity, &mut Sprite)>
 ) {
     for removed_entity in removals.read() {
         if let Ok((_, mut texture)) = q_highlighted.get_mut(removed_entity) {
             let col = texture.color.as_hsla();
-            texture.color = Color::hsla(col.h(), col.s(), col.l() / 1.5, col.a());
+            texture.color = Color::hsla(col.h(), col.s(), col.l() / 3.5, col.a());
         }
     }
 }
\ No newline at end of file
diff --git a/src/lib.rs b/src/lib.rs
index 0cd8640..7ac49d7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -24,14 +24,14 @@ mod interactions;
 mod tilemap;
 
 use crate::actions::ActionsPlugin;
-use crate::audio::InternalAudioPlugin;
+// use crate::audio::InternalAudioPlugin;
 use crate::debug::debug::DebugPlugin;
 use crate::loading::LoadingPlugin;
 use crate::menu::MenuPlugin;
-use crate::player::PlayerPlugin;
+// use crate::player::PlayerPlugin;
 
 use crate::bees::BeesPlugin;
-use crate::world::WorldPlugin;
+// use crate::world::WorldPlugin;
 use crate::camera::CameraPlugin;
 use crate::tilemap::MapPlugin;
 
@@ -55,8 +55,6 @@ enum GameState {
     Playing,
     // Here the menu is drawn and waiting for player interaction
     Menu,
-    // Additional state for pausing the game
-    Paused,
 }
 
 pub struct GamePlugin;
@@ -80,7 +78,7 @@ impl Plugin for GamePlugin {
         {
             app.add_plugins((
                 DebugPlugin,
-                // FrameTimeDiagnosticsPlugin,
+                FrameTimeDiagnosticsPlugin,
                 LogDiagnosticsPlugin::default(),
                 WorldInspectorPlugin::new(),
             ))
diff --git a/src/loading.rs b/src/loading.rs
index 8c83b79..1e289fc 100644
--- a/src/loading.rs
+++ b/src/loading.rs
@@ -36,40 +36,71 @@ pub struct TextureAssets {
     #[asset(path = "textures/github.png")]
     pub github: Handle<Image>,
 
-    #[asset(texture_atlas(
-        tile_size_x = 16.,
-        tile_size_y = 16.,
-        columns = 12,
-        rows = 10,
-        padding_x = 0.,
-        padding_y = 0.,
-        offset_x = 0.,
-        offset_y = 0.
-    ))]
-    #[asset(path = "textures/shmup.png")]
-    pub shmup: Handle<TextureAtlas>,
-
-    #[asset(texture_atlas(
-        tile_size_x = 32.,
-        tile_size_y = 32.,
-        columns = 4,
-        rows = 6,
-        padding_x = 0.,
-        padding_y = 0.,
-        offset_x = 0.,
-        offset_y = 0.
-    ))]
-    #[asset(path = "textures/airplanes.png")]
-    pub planes: Handle<TextureAtlas>,
+    // #[asset(texture_atlas(
+    //     tile_size_x = 16.,
+    //     tile_size_y = 16.,
+    //     columns = 12,
+    //     rows = 10,
+    //     padding_x = 0.,
+    //     padding_y = 0.,
+    //     offset_x = 0.,
+    //     offset_y = 0.
+    // ))]
+    // #[asset(path = "textures/shmup.png")]
+    // pub shmup: Handle<TextureAtlas>,
+    //
+    // #[asset(texture_atlas(
+    //     tile_size_x = 32.,
+    //     tile_size_y = 32.,
+    //     columns = 4,
+    //     rows = 6,
+    //     padding_x = 0.,
+    //     padding_y = 0.,
+    //     offset_x = 0.,
+    //     offset_y = 0.
+    // ))]
+    // #[asset(path = "textures/airplanes.png")]
+    // pub planes: Handle<TextureAtlas>,
+
+    #[asset(path = "textures/menubackground.png")]
+    pub background: Handle<Image>,
 
     // #[asset(texture_atlas(tile_size_x = 720., tile_size_y = 720., columns = 4, rows = 1, padding_x = 0., padding_y = 0., offset_x = 0., offset_y = 0.))]
     #[asset(path = "textures/ground/ground.png")]
     pub ground: Handle<Image>,
 
     #[asset(texture_atlas(tile_size_x = 720., tile_size_y = 720., columns = 3, rows = 1, padding_x = 0., padding_y = 0., offset_x = 0., offset_y = 0.))]
-    #[asset(path = "textures/bee1/wingmap.png")]
+    #[asset(path = "textures/bee1/wingmap1.png")]
     pub bee1wingmap: Handle<TextureAtlas>,
 
+    #[asset(texture_atlas(tile_size_x = 720., tile_size_y = 720., columns = 3, rows = 1, padding_x = 0., padding_y = 0., offset_x = 0., offset_y = 0.))]
+    #[asset(path = "textures/bee2/wingmap2.png")]
+    pub bee2wingmap: Handle<TextureAtlas>,
+
     #[asset(path = "textures/bee1/beebody.png")]
     pub beebody1: Handle<Image>,
+
+    #[asset(path = "textures/bee2/beebody.png")]
+    pub beebody2: Handle<Image>,
+
+    #[asset(path = "textures/queen.png")]
+    pub queen: Handle<Image>,
+
+    #[asset(path = "textures/hive.png")]
+    pub hive: Handle<Image>,
+
+    #[asset(path = "textures/fog.png")]
+    pub fog: Handle<Image>,
+
+    #[asset(path = "textures/flowers/flower1.png")]
+    pub flower1: Handle<Image>,
+
+    #[asset(path = "textures/flowers/flower2.png")]
+    pub flower2: Handle<Image>,
+
+    #[asset(path = "textures/flowers/flower3.png")]
+    pub flower3: Handle<Image>,
+
+    #[asset(path = "textures/flowers/flower4.png")]
+    pub flower4: Handle<Image>,
 }
diff --git a/src/menu.rs b/src/menu.rs
index 82a0963..3933a42 100644
--- a/src/menu.rs
+++ b/src/menu.rs
@@ -48,51 +48,41 @@ fn setup_menu(mut commands: Commands, textures: Res<TextureAssets>) {
         BloomSettings::default(),
     ));
 
-    // commands
-    //     .spawn((
-    //         NodeBundle {
-    //             style: Style {
-    //                 width: Val::Percent(100.0),
-    //                 height: Val::Percent(100.0),
-    //                 flex_direction: FlexDirection::Row,
-    //                 align_items: AlignItems::Center,
-    //                 justify_content: JustifyContent::SpaceBetween,
-    //                 ..default()
-    //             },
-    //             ..default()
-    //         },
-    //         Menu,
-    //     ))
-    //     .with_children(|children| {
-    //         let button_colors = ButtonColors::default();
-    //         children
-    //             .spawn((
-    //                 ButtonBundle {
-    //                     style: Style {
-    //                         width: Val::Px(140.0),
-    //                         height: Val::Px(50.0),
-    //                         justify_content: JustifyContent::Center,
-    //                         align_items: AlignItems::Center,
-    //                         ..Default::default()
-    //                     },
-    //                     background_color: button_colors.normal.into(),
-    //                     ..Default::default()
-    //                 },
-    //                 button_colors,
-    //                 ChangeState(GameState::Playing),
-    //                 StartLevel("world.ldtk"),
-    //             ))
-    //             .with_children(|parent| {
-    //                 parent.spawn(TextBundle::from_section(
-    //                     "Play default world",
-    //                     TextStyle {
-    //                         font_size: 40.0,
-    //                         color: Color::rgb(0.9, 0.9, 0.9),
-    //                         ..default()
-    //                     },
-    //                 ));
-    //             });
-    //     });
+    // commands.spawn(
+    //     SpriteBundle {
+    //         texture: textures.background.clone(),
+    //         ..default()
+    //     }
+    // );
+
+    commands
+        .spawn((NodeBundle {
+            style: Style {
+                width: Val::Percent(100.0),
+                height: Val::Percent(100.0),
+                flex_direction: FlexDirection::Column,
+                align_items: AlignItems::Center,
+                justify_content: JustifyContent::Center,
+                ..default()
+            },
+            ..default()
+        },
+        Menu,
+        ))
+        .with_children(|children| {
+            children.spawn(
+                ImageBundle {
+                    style: Style {
+                        width: Val::Percent(100.0),
+                        height: Val::Percent(100.0),
+                        ..Default::default()
+                    },
+                    image: textures.background.clone().into(),
+                    ..Default::default()
+                }
+            );
+        });
+
     commands
         .spawn((
             NodeBundle {
diff --git a/src/tilemap.rs b/src/tilemap.rs
index 076655a..a37259a 100644
--- a/src/tilemap.rs
+++ b/src/tilemap.rs
@@ -3,7 +3,10 @@ use bevy::prelude::*;
 use bevy_ecs_tilemap::prelude::*;
 use crate::loading::TextureAssets;
 
-use rand::Rng;  
+use rand::Rng;
+use crate::bees::{Bee, BeeBehavior, Collider, Velocity};
+use crate::boids::Boid;
+use crate::interactions::Highlightable;
 
 pub struct MapPlugin;
 impl Plugin for MapPlugin {
@@ -25,12 +28,14 @@ fn setup_level(
     mut commands: Commands,
     // asset_server: Res<AssetServer>,
     textures: Res<TextureAssets>,
+    mut q_camera: Query<&mut Transform, With<Camera2d>>,
+
     #[cfg(all(not(feature = "atlas"), feature = "render"))]
     array_texture_loader: Res<ArrayTextureLoader>,
 ) {
     let texture_handle: Handle<Image> = textures.ground.clone();
 
-    let map_size = TilemapSize { x: 16, y: 16 };
+    let map_size = TilemapSize { x: 32, y: 32 };
 
     let tilemap_entity = commands.spawn_empty().id();
 
@@ -39,12 +44,12 @@ fn setup_level(
 
     for x in 0..map_size.x {
         for y in 0..map_size.y {
-            let tile_pos = TilePos{ x , y };
+            let tile_pos = TilePos { x, y };
             let tile_entity = commands
                 .spawn(TileBundle {
                     position: tile_pos,
                     tilemap_id: TilemapId(tilemap_entity),
-                    texture_index: TileTextureIndex(rng.gen_range(0..3)),
+                    texture_index: TileTextureIndex(rng.gen_range(0..7)),
                     ..Default::default()
                 })
                 .id();
@@ -52,9 +57,9 @@ fn setup_level(
         }
     }
 
-    let tile_size = TilemapTileSize{ x: 720.0, y: 720.0 };
+    let tile_size = TilemapTileSize { x: 720.0, y: 720.0 };
     let grid_size: TilemapGridSize = tile_size.into();
-    commands.insert_resource(LevelData {level_height: grid_size.y, level_width: grid_size.x});
+    commands.insert_resource(LevelData { level_height: grid_size.y * map_size.y as f32, level_width: grid_size.x * map_size.x as f32 });
     let map_type = TilemapType::default();
 
     commands.entity(tilemap_entity).insert(TilemapBundle {
@@ -64,7 +69,8 @@ fn setup_level(
         storage: tile_storage,
         texture: TilemapTexture::Single(texture_handle),
         tile_size,
-        transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
+        // transform: get_tilemap_center_transform(&map_size, &grid_size, &map_type, 0.0),
+        transform: Transform::from_xyz(360., 360., 0.),
         ..Default::default()
     });
 
@@ -78,5 +84,206 @@ fn setup_level(
             ..Default::default()
         });
     }
+    // Spawn fog
+    // Create a separate tilemap for fog
+    let fog_tilemap_entity = commands.spawn_empty().id();
+    let mut fog_tile_storage = TileStorage::empty(map_size);
+
+    // Populate the fog tile storage with fog tiles covering the entire map
+    for x in 0..map_size.x {
+        for y in 0..map_size.y {
+            let fog_tile_pos = TilePos { x, y };
+            let fog_tile_entity = commands
+                .spawn(TileBundle {
+                    position: fog_tile_pos,
+                    tilemap_id: TilemapId(fog_tilemap_entity),
+                    texture_index: TileTextureIndex(0), // Set fog texture index
+                    ..Default::default()
+                })
+                .id();
+            fog_tile_storage.set(&fog_tile_pos, fog_tile_entity);
+        }
+    }
+
+    // Insert fog tilemap bundle
+    commands.entity(fog_tilemap_entity).insert((
+        TilemapBundle {
+            grid_size,
+            map_type,
+            size: map_size,
+            storage: fog_tile_storage.clone(),
+            texture: TilemapTexture::Single(textures.fog.clone()), // Use fog texture handle
+            tile_size,
+            transform: Transform::from_translation(Vec3::new(360.0, 360.0, 1.0)), // Render fog on top by adjusting z-axis
+            ..Default::default()
+
+        },
+        FogTile
+    ));
+
+
+    // Spawn the hive
+    let max_x = (map_size.x * tile_size.x as u32) - 720;
+    let max_y = (map_size.y * tile_size.y as u32) - 720;
+
+    let beehive_position = Vec3::new(
+        ((rand::random::<u32>() % max_x) as f32 / tile_size.x * tile_size.x + 360.) as f32,
+        ((rand::random::<u32>() % max_y) as f32 / tile_size.y * tile_size.y + 360.) as f32,
+        2.0,
+    );
+
+    commands.spawn(SpriteBundle {
+        texture: textures.hive.clone(),
+        transform: Transform {
+            translation: beehive_position,
+            ..Default::default()
+        },
+        ..Default::default()
+    });
+    info!("Spawned beehive at {:?}", beehive_position);
+    let mut camera_transform = q_camera.single_mut();
+    camera_transform.translation = beehive_position;
+
+    // Despawn fog around hive
+    // Calculate fog removal area around the beehive
+    let fog_removal_radius = 3; // Adjust the radius as needed
+    // Ensure fog removal area stays within the bounds of the tile storage
+    let fog_tile_storage_size = fog_tile_storage.size; // Assuming fog_tile_storage has a size() method
+    let beehive_tile_pos = TilePos {
+        x: (beehive_position.x / tile_size.x) as u32,
+        y: (beehive_position.y / tile_size.y) as u32,
+    };
+    let mut fog_removal_area = Vec::new();
+    for x in (beehive_tile_pos.x as i32 - fog_removal_radius as i32)..=(beehive_tile_pos.x as i32 + fog_removal_radius as i32) {
+        for y in (beehive_tile_pos.y as i32 - fog_removal_radius as i32)..=(beehive_tile_pos.y as i32 + fog_removal_radius as i32) {
+            if x >= 0 && y >= 0 && x < fog_tile_storage_size.x as i32 && y < fog_tile_storage_size.y as i32 {
+                fog_removal_area.push((x as u32, y as u32));
+            }
+        }
+    }
+    // Access the fog tile storage and remove fog tiles in the calculated area
+    for (x, y) in fog_removal_area {
+        if let Some(fog_tile_entity) = fog_tile_storage.get(&TilePos { x, y }) {
+            commands.entity(fog_tile_entity).despawn_recursive();
+        }
+    }
+
+    // Spawn the Queen bee
+    // Calculate the maximum position bounds
+    let max_x = (map_size.x * tile_size.x as u32) - 720;
+    let max_y = (map_size.y * tile_size.y as u32) - 720;
+
+    // Spawn the bee queen away from the hive
+    let bee_queen_position = get_random_position_away_from_hive(beehive_position, max_x, max_y, grid_size, 720);
+    commands.spawn(SpriteBundle {
+        texture: textures.queen.clone(),
+        transform: Transform {
+            translation: bee_queen_position,
+            ..Default::default()
+        },
+        ..Default::default()
+    });
+    info!("Spawned bee queen at {:?}", bee_queen_position);
+
+    // Spawn flowers randomly within the map bounds
+    const NUM_FLOWERS: usize = 20;
+    for _ in 0..NUM_FLOWERS {
+        let flower_type = rand::random::<u8>() % 4; // Assuming you have 4 flower types
+        let flower_texture = match flower_type {
+            0 => textures.flower1.clone(),
+            1 => textures.flower2.clone(),
+            2 => textures.flower3.clone(),
+            3 => textures.flower4.clone(),
+            _ => textures.flower1.clone(), // Default to a texture if needed
+        };
+
+        let flower_position = get_random_position(max_x, max_y, grid_size);
+
+        commands.spawn((
+            SpriteBundle {
+                texture: flower_texture,
+                transform: Transform {
+                    translation: flower_position,
+                    ..Default::default()
+                },
+                ..Default::default()
+            },
+            Flower
+        ));
+    }
+
+    // Spawn the initial 5 bees
+    for _ in 0..5 {
+        let bee_body = if rng.gen::<bool>() {
+            textures.beebody1.clone()
+        } else {
+            textures.beebody2.clone()
+        };
+        let bee_offset_x = rng.gen_range(-500.0..=500.0); // Adjust the offset range as needed
+        let bee_offset_y = rng.gen_range(-500.0..=500.0);
+        let bee_entity = commands.spawn((
+            SpriteBundle {
+                texture: bee_body,
+                transform:  Transform::from_translation(Vec3::new(
+                    beehive_position.x + bee_offset_x,
+                    beehive_position.y + bee_offset_y,
+                    beehive_position.z,
+                )),
+                ..default()
+            },
+            Bee,
+            BeeBehavior::Destination(Vec2::new(beehive_position.x, beehive_position.y)),
+            Boid,
+            Highlightable,
+            Collider::new(25.0),
+            Velocity::default(),
+        )).id();
+
+        // Spawn the wings as a child of the bee body
+        let bee_wings= if rng.gen::<bool>() {
+            textures.bee1wingmap.clone()
+        } else {
+            textures.bee2wingmap.clone()
+        };
+        commands.entity(bee_entity).with_children(|parent| {
+            parent.spawn(SpriteSheetBundle {
+                texture_atlas: bee_wings,
+                sprite: TextureAtlasSprite::new(0), // Set the initial sprite index
+                transform: Transform::from_xyz(0.0, 0.0, 1.0), // Adjust the position of the wings relative to the bee body
+                ..Default::default()
+            })
+                .insert(crate::bees::AnimationIndices { first: 0, last: 3 - 1 })
+                .insert(crate::bees::AnimationTimer(Timer::from_seconds(0.3, TimerMode::Repeating)));
+        });
+
+        // info!("Bee spawned at hive position");
+    }
+
+}
+
+// Define a function to get a random position away from the hive
+fn get_random_position_away_from_hive(hive_position: Vec3, max_x: u32, max_y: u32, tile_size: TilemapGridSize, radius: u32) -> Vec3 {
+    loop {
+        let x = (rand::random::<u32>() % max_x) as f32 / tile_size.x * tile_size.x + 360.;
+        let y = (rand::random::<u32>() % max_y) as f32 / tile_size.y * tile_size.y + 360.;
+        let candidate_position = Vec3::new(x, y, 1.0);
+
+        // Check if the candidate position is away from the hive by the given radius
+        if (candidate_position - hive_position).length() > radius as f32 {
+            return candidate_position;
+        }
+    }
+}
+
+// Define a function to get a random position within the map bounds
+fn get_random_position(max_x: u32, max_y: u32, tile_size: TilemapGridSize) -> Vec3 {
+    let x = (rand::random::<u32>() % max_x) as f32 / tile_size.x * tile_size.x + 360.;
+    let y = (rand::random::<u32>() % max_y) as f32 / tile_size.y * tile_size.y + 360.;
+    Vec3::new(x, y, 1.0)
+}
+
+#[derive(Component)]
+pub struct Flower;
 
-}
\ No newline at end of file
+#[derive(Component)]
+pub struct FogTile;