diff --git a/assets/credits.txt b/assets/credits.txt
new file mode 100644
index 0000000..83d9812
--- /dev/null
+++ b/assets/credits.txt
@@ -0,0 +1 @@
+Knight - https://aamatniekss.itch.io/fantasy-knight-free-pixelart-animated-character
diff --git a/assets/test/Knight.png b/assets/test/Knight.png
new file mode 100644
index 0000000..9e9861e
Binary files /dev/null and b/assets/test/Knight.png differ
diff --git a/src/debug_diagnostic.rs b/src/debug_diagnostic.rs
index 4d4b9d0..ae15656 100644
--- a/src/debug_diagnostic.rs
+++ b/src/debug_diagnostic.rs
@@ -27,11 +27,6 @@ impl Plugin for DiagnosticPlugin {
             Update,
             (fps_counting, sheep_counter_text, alive_sheep_counter).in_set(GameSet::Playing),
         );
-
-        #[cfg(feature = "dev")]
-        {
-            app.add_plugins(bevy_inspector_egui::quick::WorldInspectorPlugin::default());
-        }
     }
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index 3b0e98f..15f38aa 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -14,6 +14,8 @@ pub mod storyteller;
 pub mod test_level;
 pub mod torch;
 pub mod wolf;
+pub mod sunday;
+pub mod shepherd;
 
 use std::f32::consts::PI;
 
@@ -99,6 +101,8 @@ impl Plugin for GamePlugin {
             wolf::WolfPlugin,
             menu::MenuPlugin,
             finish_screen::FinishScreenPlugin,
+            sunday::SundayPlugin,
+            shepherd::ShepherdPlugin,
         ));
 
         //For long term updates
diff --git a/src/player.rs b/src/player.rs
index bc3088a..5c50284 100644
--- a/src/player.rs
+++ b/src/player.rs
@@ -1,4 +1,4 @@
-use bevy::{input::mouse::MouseWheel, prelude::*, window::PrimaryWindow};
+use bevy::{input::mouse::MouseWheel, prelude::*, window::PrimaryWindow, pbr::{CascadeShadowConfig, CascadeShadowConfigBuilder}};
 
 use crate::{
     get_sprite_rotation,
@@ -168,7 +168,7 @@ pub fn bark(
         return;
     };
 
-    if input.just_pressed(KeyCode::Space) {
+    if input.pressed(KeyCode::Space) {
         event_writer.send(Bark {
             radius: 10.,
             position: bark.translation,
@@ -224,6 +224,7 @@ fn camera_movement(
     player_query: Query<&Transform, (With<Player>, Without<Camera>)>,
     time: Res<Time>,
     mut scroll_evr: EventReader<MouseWheel>,
+    mut sun : Query<&mut CascadeShadowConfig>
 ) {
     let Ok((mut camera, mut distance)) = camera_query.get_single_mut() else {
         return;
@@ -232,6 +233,11 @@ fn camera_movement(
         return;
     };
 
+
+    let Ok(mut sun) = sun.get_single_mut() else {
+        return;
+    };
+
     for ev in scroll_evr.read() {
         let delta = ev.y;
         if delta < 0.0 {
@@ -241,6 +247,11 @@ fn camera_movement(
         }
 
         distance.0 = distance.0.clamp(10.0, 150.0);
+        
+
+        let mut cascade = CascadeShadowConfigBuilder::default();
+        cascade.maximum_distance = distance.0 * 2.0;
+        *sun = cascade.build();
     }
 
     let cam_frw = camera.forward();
@@ -256,6 +267,7 @@ fn set_cam_distance(
     mut commands: Commands,
     camera_without_dist: Query<(Entity, &Transform), (With<Camera>, Without<CameraDistance>)>,
     player_query: Query<&Transform, With<Player>>,
+    mut sun : Query<&mut CascadeShadowConfig>
 ) {
     let Ok(player) = player_query.get_single() else {
         return;
diff --git a/src/shepherd.rs b/src/shepherd.rs
new file mode 100644
index 0000000..2ed41fb
--- /dev/null
+++ b/src/shepherd.rs
@@ -0,0 +1,113 @@
+use bevy::{prelude::*, reflect::EnumInfo};
+
+use crate::{player::{DOG_SPEED, DOG_ACCELERATION}, common_storage::CommonStorage, get_sprite_rotation, physics::{Velocity, WalkController}, GameSet, torch::{TorchBase, IgniteTorch}, sunday::DayState};
+
+const SHEPHERD_PATH: &str = "test/Knight.png";
+
+const SHEPHERD_SPEED: f32 = DOG_SPEED;
+const SHEPHERD_ACCEL: f32 = DOG_ACCELERATION;
+
+const IGNITE_RADIUS: f32 = 5.0;
+
+pub struct ShepherdPlugin;
+
+impl Plugin for ShepherdPlugin {
+    fn build(&self, app: &mut App) {
+        app
+            .add_event::<SpawnShepherd>()
+            .add_systems(Update, (
+                    spawn_shepherd_system,
+                    ignite_all_torhes,
+                ).in_set(GameSet::Playing)
+            )
+            .add_systems(OnEnter(DayState::Evening), start_ignite_torches);
+    }
+}
+
+#[derive(Event)]
+pub struct SpawnShepherd {
+    pub pos: Vec3,
+}
+
+#[derive(Component, Default)]
+pub struct Shepherd;
+
+#[derive(Component)]
+pub struct IgniteAllTorhes;
+
+fn start_ignite_torches(
+    mut commands: Commands,
+    query : Query<Entity, With<Shepherd>>
+) {
+    if let Ok(entity) = query.get_single() {
+        commands.entity(entity).insert(IgniteAllTorhes);
+    }
+}
+
+fn ignite_all_torhes(
+    mut commands: Commands,
+    mut query : Query<(Entity, &mut WalkController, &Transform), With<IgniteAllTorhes>>,
+    torches : Query<(&Transform, &TorchBase)>,
+    mut ignite : EventWriter<IgniteTorch>
+) {
+    let Ok((herd_entity, mut walk_controller, transform)) = query.get_single_mut() else {
+        return;
+    };
+
+    //find nearest torch
+    let mut nearest_torch : Option<Vec3> = None;
+    let mut nearest_torch_data : Option<&TorchBase> = None;
+    let mut dist = f32::MAX;
+    for (torch_transform, torch) in torches.iter() {
+        let dist_to_torch = (torch_transform.translation - transform.translation).length();
+        if dist_to_torch < dist && !torch.lit {
+            nearest_torch = Some(torch_transform.translation);
+            nearest_torch_data = Some(torch);
+            dist = dist_to_torch;
+        }
+    }
+
+    if let Some(nearest_torch) = nearest_torch {
+        if dist < IGNITE_RADIUS {
+            ignite.send(IgniteTorch { 
+                position: transform.translation,
+                radius: IGNITE_RADIUS
+            }); 
+        } else {
+            walk_controller.target_velocity = (nearest_torch - transform.translation).normalize() * SHEPHERD_SPEED;
+        }
+    } else {
+        commands.entity(herd_entity).remove::<IgniteAllTorhes>();
+        walk_controller.target_velocity = Vec3::ZERO;
+    }
+}
+
+fn spawn_shepherd_system(
+    mut commands: Commands,
+    mut events: EventReader<SpawnShepherd>,
+    asset_server: Res<AssetServer>,
+    common_storage : Res<CommonStorage>,
+    mut materials : ResMut<Assets<StandardMaterial>>,
+) {
+    for event in events.read() {
+        commands.spawn((
+            Shepherd::default(),
+            PbrBundle {
+                transform: Transform::from_translation(event.pos).with_rotation(get_sprite_rotation()).with_scale(Vec3::new(1.0, 1.0, 2.0)),
+                material: materials.add(StandardMaterial {
+                    base_color_texture: Some(asset_server.load(SHEPHERD_PATH)),
+                    ..default()
+                }),
+                mesh: common_storage.plane.clone(),
+                ..default()
+            },
+            Velocity::default(),
+            WalkController {
+                max_speed: SHEPHERD_SPEED,
+                acceleration: SHEPHERD_ACCEL,
+                target_velocity: Vec3::ZERO,
+            }
+        ));
+    }
+    events.clear();
+}
\ No newline at end of file
diff --git a/src/storyteller.rs b/src/storyteller.rs
index afd4125..142fcb2 100644
--- a/src/storyteller.rs
+++ b/src/storyteller.rs
@@ -56,6 +56,16 @@ pub struct Storyteller {
     pub next_wave: Option<SheepWave>,
 }
 
+impl Storyteller {
+    pub fn get_level_time(&self, time : &Time) -> f32 {
+        time.elapsed_seconds() - self.level_start_time
+    }
+
+    pub fn get_level_unfirom_time(&self, time : &Time) -> f32 {
+        self.get_level_time(time) / self.level_duration
+    }
+}
+
 #[derive(Resource, Default)]
 pub struct Score(pub f32);
 
diff --git a/src/sunday.rs b/src/sunday.rs
new file mode 100644
index 0000000..5954742
--- /dev/null
+++ b/src/sunday.rs
@@ -0,0 +1,119 @@
+use std::f32::consts::PI;
+
+use bevy::prelude::*;
+
+use crate::{storyteller::Storyteller, GameSet};
+
+pub struct SundayPlugin;
+
+pub const DAY_SUN_COLOR: &str = "f2ecbe";
+pub const EVENING_SUN_COLOR: &str = "cfaf56";
+pub const DUSK_SUN_COLOR: &str = "f2ecbe";
+pub const NIGHT_SUN_COLOR: &str = "506886";
+
+pub const SUN_BASE_ILLUMINANCE: f32 = 50000.0;
+pub const AMBIENT_BASE_ILLUMINANCE: f32 = 1.0;
+
+pub const SUN_EVENING_ILLUMINANCE: f32 = 10000.0;
+pub const SUN_DUSK_ILLUMINANCE: f32 = 10000.0;
+pub const SUN_NIGHT_ILLUMINANCE: f32 = 10000.0;
+
+pub const AMBIENT_DAY_COLOR: &str = "2ba4a9";
+pub const AMBIENT_NIGHT_COLOR: &str = "643a69";
+
+pub const AMBIENT_DAY_ILLUMINANCE: f32 = 1.0;
+pub const AMBIENT_NIGHT_ILLUMINANCE: f32 = 0.1;
+
+const DAY_TIME: f32 = 0.3;
+const EVENING_TIME: f32 = 0.6;
+const NIGHT_TIME: f32 = 0.7;
+
+impl Plugin for SundayPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(Update, sunday_system.in_set(GameSet::Playing));
+        app.add_systems(Update, set_day_state.in_set(GameSet::Playing));
+        app.add_state::<DayState>();
+    }
+}
+
+#[derive(States, Debug, Clone, Copy, Eq, PartialEq, Hash, Default)]
+pub enum DayState {
+    #[default]
+    Day,
+    Evening,
+    Night,
+}
+
+fn set_day_state(
+    mut state : ResMut<NextState<DayState>>,
+    current_state : Res<State<DayState>>,
+    teller : Res<Storyteller>,
+    time : Res<Time>
+) {
+    let uniform_time = teller.get_level_unfirom_time(&time);
+    if uniform_time < DAY_TIME {
+        if *current_state != DayState::Day {
+            state.set(DayState::Day);
+        }
+    } else if uniform_time < EVENING_TIME {
+        if *current_state != DayState::Evening {
+            state.set(DayState::Evening);
+        }
+    } else if uniform_time < NIGHT_TIME {
+        if *current_state != DayState::Night {
+            state.set(DayState::Night);
+        }
+    }
+}
+
+fn sunday_system(
+    time: Res<Time>,
+    teller : Res<Storyteller>,
+    mut sun : Query<(&mut Transform, &mut DirectionalLight)>,
+    mut ambient_light: ResMut<AmbientLight>
+) {
+    let Ok((mut transform, mut light)) = sun.get_single_mut() else {
+        warn!("Could not get directional light");
+        return;
+    };
+
+    let uniform_time = teller.get_level_unfirom_time(&time);
+
+    if uniform_time < DAY_TIME {
+        let sun_falloff = 1.0;
+        ambient_light.color = Color::hex(AMBIENT_DAY_COLOR).unwrap();
+        let sun_angle = sun_falloff * std::f32::consts::PI / 4.0;
+        let pos = transform.translation.clone();
+        transform.look_at(pos + Vec3::new(-(PI / 4.0).cos(), -sun_angle.sin(), -sun_angle.cos()), Vec3::Y);
+
+    } else if uniform_time < EVENING_TIME {
+        let sun_falloff = 1.0 - (uniform_time - DAY_TIME) / (EVENING_TIME - DAY_TIME);
+        let color = 
+            Color::hex(DAY_SUN_COLOR).unwrap() * sun_falloff 
+                + Color::hex(EVENING_SUN_COLOR).unwrap() * (1.0 - sun_falloff);
+        let sun_angle = sun_falloff * std::f32::consts::PI / 4.0;
+        let illuminance = SUN_BASE_ILLUMINANCE * sun_falloff + SUN_EVENING_ILLUMINANCE * (1.0 - sun_falloff);
+
+        let pos = transform.translation.clone();
+        transform.look_at(pos + Vec3::new(-(PI / 4.0).cos(), -sun_angle.sin(), -sun_angle.cos()), Vec3::Y);
+        light.color = color;
+        light.illuminance = illuminance;
+
+        ambient_light.color = Color::hex(AMBIENT_DAY_COLOR).unwrap();
+    } else if uniform_time < NIGHT_TIME {
+        let sun_falloff = 1.0 - (uniform_time - EVENING_TIME) / (NIGHT_TIME - EVENING_TIME);
+        let color = Color::hex(NIGHT_SUN_COLOR).unwrap();
+        let sun_angle = (1.0 - sun_falloff) * std::f32::consts::PI / 4.0;
+        let illuminance = SUN_NIGHT_ILLUMINANCE;
+        let pos = transform.translation.clone();
+        transform.look_at(pos + Vec3::new(-(PI / 4.0).cos(), -sun_angle.sin(), -sun_angle.cos()), Vec3::Y);
+        light.color = color;
+        light.illuminance = illuminance;
+
+        ambient_light.color = 
+            Color::hex(AMBIENT_NIGHT_COLOR).unwrap() * (1.0 - sun_falloff) + Color::hex(AMBIENT_DAY_COLOR).unwrap() * sun_falloff;
+        ambient_light.brightness = AMBIENT_NIGHT_ILLUMINANCE * (1.0 - sun_falloff) + sun_falloff * AMBIENT_DAY_ILLUMINANCE;
+    } else {
+        
+    }
+}
\ No newline at end of file
diff --git a/src/test_level.rs b/src/test_level.rs
index 59dd6ca..e452d02 100644
--- a/src/test_level.rs
+++ b/src/test_level.rs
@@ -4,7 +4,7 @@ use std::f32::consts::PI;
 
 use crate::{
     get_sprite_rotation, level_ui::CreateLevelUi, player::SpawnPlayer, safe_area::SafeArea,
-    sprite_material::create_plane_mesh, torch::SpawnTorch, GameStuff,
+    sprite_material::create_plane_mesh, torch::SpawnTorch, GameStuff, sunday::{DAY_SUN_COLOR, SUN_BASE_ILLUMINANCE, AMBIENT_BASE_ILLUMINANCE}, shepherd::SpawnShepherd,
 };
 
 const TREE_PATH: &str = "test/pine.png";
@@ -14,14 +14,11 @@ pub struct LevelSize(pub f32);
 
 impl Default for LevelSize {
     fn default() -> Self {
-        Self(40.)
+        Self(50.)
     }
 }
 
-pub const DAY_SUN_COLOR: &str = "f2ecbe";
-pub const EVENING_SUN_COLOR: &str = "cfaf56";
-pub const DUSK_SUN_COLOR: &str = "f2ecbe";
-pub const NIGHT_SUN_COLOR: &str = "f2ecbe";
+
 
 pub fn setup(
     mut commands: Commands,
@@ -32,6 +29,7 @@ pub fn setup(
     mut spawn_torch: EventWriter<SpawnTorch>,
     level_size: Res<LevelSize>,
     mut create_level_ui: EventWriter<CreateLevelUi>,
+    mut spawn_shepherd: EventWriter<SpawnShepherd>,
 ) {
     //spawn sun
     let mut cascades = CascadeShadowConfigBuilder::default();
@@ -41,7 +39,7 @@ pub fn setup(
         directional_light: DirectionalLight {
             shadows_enabled: true,
             color: Color::hex(DAY_SUN_COLOR).unwrap(),
-            illuminance: 50000.0,
+            illuminance: SUN_BASE_ILLUMINANCE,
             ..default()
         },
 
@@ -52,7 +50,7 @@ pub fn setup(
     //ambient ligjt
     commands.insert_resource(AmbientLight {
         color: Color::WHITE,
-        brightness: 1.0,
+        brightness: AMBIENT_BASE_ILLUMINANCE,
     });
 
     let square = meshes.add(create_plane_mesh());
@@ -73,7 +71,7 @@ pub fn setup(
     let cut_r = r + 5.0;
 
     let tree_area_size = PI * tree_r * tree_r - PI * cut_r * cut_r;
-    let tree_per_meter = 1.0;
+    let tree_per_meter = 0.5;
     let tree_count = (tree_area_size * tree_per_meter) as usize;
 
     for _ in 0..tree_count {
@@ -107,6 +105,7 @@ pub fn setup(
             })),
             material: materials.add(StandardMaterial {
                 base_color: Color::hex("5d9669").unwrap(),
+                reflectance: 0.05,
                 ..default()
             }),
             transform: Transform::from_xyz(0.0, 0.0, 0.0),
@@ -133,5 +132,10 @@ pub fn setup(
         })
         .insert(GameStuff);
 
+    spawn_shepherd.send(SpawnShepherd {
+        pos: Vec3::new(0.0, 0.0, -level_size.0),
+    });
+
+
     create_level_ui.send(CreateLevelUi);
 }
diff --git a/src/torch.rs b/src/torch.rs
index e4bcf8b..d7e9af8 100644
--- a/src/torch.rs
+++ b/src/torch.rs
@@ -1,21 +1,31 @@
 use bevy::prelude::*;
 
-use crate::{common_storage::CommonStorage, get_sprite_rotation, GameStuff};
+use crate::{common_storage::CommonStorage, get_sprite_rotation, GameStuff, GameSet};
 
 const TORCH_PATH: &str = "test/torch.png";
 
+const TORCH_ILLUMINATION: f32 = 1000.0;
+
+
 pub struct TorchPlugin;
 
 impl Plugin for TorchPlugin {
     fn build(&self, app: &mut App) {
         app.add_event::<SpawnTorch>()
             .add_systems(Startup, setup_material)
-            .add_systems(Update, spawn_torch);
+            .add_systems(Update, spawn_torch)
+            
+            .add_event::<IgniteTorch>()
+            .add_systems(Update, ignite_torch.in_set(GameSet::Playing));
     }
 }
 
 #[derive(Component)]
-pub struct Torch {
+pub struct TorchLight;
+
+#[derive(Component)]
+pub struct TorchBase {
+    pub light : Entity,
     pub lit: bool,
     pub fuel: f32,
     pub color: Color,
@@ -51,12 +61,27 @@ fn spawn_torch(
     torch_material: Res<TorchMaterial>,
 ) {
     for event in events.read() {
-        let torch = Torch {
+
+        let light_id = commands.spawn(PointLightBundle {
+            point_light: PointLight {
+                color: Color::ORANGE,
+                intensity: 0.0,
+                range: 20.0,
+                radius: 0.3,
+                shadows_enabled: false,
+                ..default()
+            },
+            transform: Transform::from_translation(Vec3::new(0.0, 0.0, 1.0)),
+            ..default()
+        }).insert(TorchLight).id();
+
+        let torch = TorchBase {
             lit: false,
             fuel: 0.0,
             color: Color::ORANGE,
             max_fuel: 1.0,
-            radius: 50.0,
+            radius: 20.0,
+            light: light_id,
         };
 
         commands
@@ -71,21 +96,32 @@ fn spawn_torch(
                     ..default()
                 },
                 GameStuff,
-            ))
-            .with_children(|parent| {
-                parent.spawn(PointLightBundle {
-                    point_light: PointLight {
-                        color: Color::ORANGE,
-                        intensity: 100.0,
-                        range: 5.0,
-                        radius: 0.3,
-                        shadows_enabled: false,
-                        ..default()
-                    },
-                    transform: Transform::from_translation(Vec3::new(0.0, 0.0, 1.0)),
-                    ..default()
-                });
-            });
+            )).add_child(light_id);
     }
     events.clear();
 }
+
+#[derive(Event)]
+pub struct IgniteTorch {
+    pub position: Vec3,
+    pub radius: f32,
+}
+
+fn ignite_torch(
+    mut events: EventReader<IgniteTorch>,
+    mut query: Query<(&mut TorchBase, &Transform)>,
+    mut lights : Query<&mut PointLight, With<TorchLight>>
+) {
+    for event in events.read() {
+        for (mut torch, transform) in &mut query {
+            if (transform.translation - event.position).length() < event.radius {
+                torch.lit = true;
+                torch.fuel = torch.max_fuel;
+                if let Ok(mut light) = lights.get_mut(torch.light) {
+                    light.intensity = TORCH_ILLUMINATION;
+                };
+            }
+        }
+    }
+    events.clear();
+}
\ No newline at end of file