diff --git a/Cargo.toml b/Cargo.toml
index 53bd820..4900d16 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,6 +25,7 @@ dev = [
     "bevy/dynamic_linking",
     "dep:bevy-inspector-egui"
 ]
+default = ["dev"]
 
 # All of Bevy's default features exept for the audio related ones (bevy_audio, vorbis), since they clash with bevy_kira_audio
 #   and android_shared_stdcxx, since that is covered in `mobile`
diff --git a/examples/simple_3d_test.rs b/examples/simple_3d_test.rs
index 584951e..d1e4745 100644
--- a/examples/simple_3d_test.rs
+++ b/examples/simple_3d_test.rs
@@ -79,7 +79,7 @@ fn setup(
         ..default()
     });
 
-    //spawn ships
+    //spawn sheeps
     let r = 50.0;
     let mut rng = rand::thread_rng();
     let sheep_count = 2000;
diff --git a/src/debug_diagnostic.rs b/src/debug_diagnostic.rs
index 5fa889b..4d4b9d0 100644
--- a/src/debug_diagnostic.rs
+++ b/src/debug_diagnostic.rs
@@ -1,6 +1,10 @@
 use bevy::prelude::*;
 
-use crate::{safe_area::SheepCounter, sheep::StartSheepCount, GameSet, GameState, GameStuff};
+use crate::{
+    safe_area::SheepCounter,
+    sheep::{Sheep, StartSheepCount},
+    GameSet, GameState, GameStuff,
+};
 
 const FONT_SIZE: f32 = 24.0;
 
@@ -15,15 +19,16 @@ impl Plugin for DiagnosticPlugin {
                 apply_deferred,
                 setup_counter,
                 setup_sheep_counter,
+                setup_alive_sheep_counter,
             )
                 .chain(),
         )
         .add_systems(
             Update,
-            (fps_counting, sheep_counter_text).in_set(GameSet::Playing),
+            (fps_counting, sheep_counter_text, alive_sheep_counter).in_set(GameSet::Playing),
         );
 
-        #[cfg(debug_assertions)]
+        #[cfg(feature = "dev")]
         {
             app.add_plugins(bevy_inspector_egui::quick::WorldInspectorPlugin::default());
         }
@@ -80,14 +85,14 @@ fn fps_counting(mut query: Query<&mut Text, With<FrameCounter>>, time: Res<Time>
 }
 
 #[derive(Component)]
-pub struct ShipDebugCounter;
+pub struct SheepDebugCounter;
 
 pub fn setup_sheep_counter(mut commands: Commands, panels: Query<Entity, With<DiagnosticPanel>>) {
     let mut text_style = TextStyle::default();
     text_style.font_size = FONT_SIZE;
     let sheep_counter = commands
         .spawn(TextBundle::from_section("Sheep in safe area: ", text_style))
-        .insert(ShipDebugCounter)
+        .insert(SheepDebugCounter)
         .id();
 
     if let Ok(panel) = panels.get_single() {
@@ -96,7 +101,7 @@ pub fn setup_sheep_counter(mut commands: Commands, panels: Query<Entity, With<Di
 }
 
 pub fn sheep_counter_text(
-    mut query: Query<&mut Text, With<ShipDebugCounter>>,
+    mut query: Query<&mut Text, With<SheepDebugCounter>>,
     sheep_counter: Res<SheepCounter>,
     start_sheep_count: Res<StartSheepCount>,
 ) {
@@ -107,3 +112,36 @@ pub fn sheep_counter_text(
         );
     }
 }
+
+#[derive(Component)]
+pub struct SheepAliveDebugCounter;
+
+pub fn setup_alive_sheep_counter(
+    mut commands: Commands,
+    panels: Query<Entity, With<DiagnosticPanel>>,
+) {
+    let mut text_style = TextStyle::default();
+    text_style.font_size = FONT_SIZE;
+    let sheep_counter = commands
+        .spawn(TextBundle::from_section("Alive sheeps: ", text_style))
+        .insert(SheepAliveDebugCounter)
+        .id();
+
+    if let Ok(panel) = panels.get_single() {
+        commands.entity(panel).add_child(sheep_counter);
+    }
+}
+
+pub fn alive_sheep_counter(
+    mut query: Query<&mut Text, With<SheepAliveDebugCounter>>,
+    sheeps: Query<&Sheep>,
+    start_sheep_count: Res<StartSheepCount>,
+) {
+    let alive_sheep_count = sheeps.iter().count();
+    for mut text in &mut query {
+        text.sections[0].value = format!(
+            "Alive sheeps: {}/{}",
+            alive_sheep_count, start_sheep_count.0
+        );
+    }
+}
diff --git a/src/level_ui.rs b/src/level_ui.rs
index 275f2ff..96907f0 100644
--- a/src/level_ui.rs
+++ b/src/level_ui.rs
@@ -19,7 +19,7 @@ pub struct LevelUi;
 
 fn create_level_ui_system(
     mut commands: Commands,
-    asset_server: Res<AssetServer>,
+    _asset_server: Res<AssetServer>,
     mut ev_create_level_ui: EventReader<CreateLevelUi>,
 ) {
     if ev_create_level_ui.is_empty() {
diff --git a/src/lib.rs b/src/lib.rs
index 9224d50..3b0e98f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -17,7 +17,7 @@ pub mod wolf;
 
 use std::f32::consts::PI;
 
-#[cfg(debug_assertions)]
+#[cfg(feature = "dev")]
 use bevy::diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin};
 use bevy::prelude::*;
 use bevy::{app::App, core_pipeline::clear_color::ClearColorConfig};
@@ -79,7 +79,7 @@ impl Plugin for GamePlugin {
             GameSet::Finish.run_if(in_state(GameState::Finish)),
         );
 
-        #[cfg(debug_assertions)]
+        #[cfg(feature = "dev")]
         {
             app.add_plugins((FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin::default()));
         }
diff --git a/src/player.rs b/src/player.rs
index a925293..bc3088a 100644
--- a/src/player.rs
+++ b/src/player.rs
@@ -168,7 +168,7 @@ pub fn bark(
         return;
     };
 
-    if input.pressed(KeyCode::Space) {
+    if input.just_pressed(KeyCode::Space) {
         event_writer.send(Bark {
             radius: 10.,
             position: bark.translation,
diff --git a/src/sheep.rs b/src/sheep.rs
index 7d5b8a6..3459b12 100644
--- a/src/sheep.rs
+++ b/src/sheep.rs
@@ -3,7 +3,7 @@ use std::{
     time::Duration,
 };
 
-use bevy::{prelude::*, utils::HashMap};
+use bevy::prelude::*;
 use rand::{rngs::ThreadRng, Rng};
 
 use crate::{
@@ -268,14 +268,13 @@ fn init_safeareawalk_walk(
 pub fn sheep_state(
     mut commands: Commands,
     state_matrix: Res<StateChance>,
-    time: Res<Time>,
-    mut sheeps: Query<(Entity, &mut Decision, &mut Sheep), Without<IsScared>>,
+    mut sheeps: Query<(Entity, &mut Decision, &Sheep), Without<IsScared>>,
     mut init_random_walk: EventWriter<InitRandomWalk>,
     mut init_safe_walk: EventWriter<SafeAreaWalk>,
     mut init_escape_walk: EventWriter<EscapeWalk>,
 ) {
     let mut rand = rand::thread_rng();
-    for (e, mut dec, mut sheep) in &mut sheeps.iter_mut() {
+    for (e, mut dec, _sheep) in &mut sheeps.iter_mut() {
         if *dec == Decision::Idle {
             let next_dec = state_matrix.select_next(&mut rand);
 
diff --git a/src/storyteller.rs b/src/storyteller.rs
index 094de22..2e61186 100644
--- a/src/storyteller.rs
+++ b/src/storyteller.rs
@@ -146,7 +146,7 @@ fn level_timer(
 ) {
     for mut timer in timers.iter_mut() {
         let level_time = time.elapsed_seconds() - teller.level_start_time;
-        if (teller.level_duration - level_time > 0.0) {
+        if teller.level_duration - level_time > 0.0 {
             let dur = Duration::from_secs_f32(teller.level_duration - level_time);
 
             let time = format!("{:02}:{:02}", dur.as_secs() / 60, dur.as_secs() % 60);
diff --git a/src/test_level.rs b/src/test_level.rs
index 6be10c6..59dd6ca 100644
--- a/src/test_level.rs
+++ b/src/test_level.rs
@@ -1,6 +1,4 @@
-use bevy::{
-    core_pipeline::clear_color::ClearColorConfig, pbr::CascadeShadowConfigBuilder, prelude::*,
-};
+use bevy::{pbr::CascadeShadowConfigBuilder, prelude::*};
 use rand::prelude::*;
 use std::f32::consts::PI;
 
diff --git a/src/wolf.rs b/src/wolf.rs
index 903e924..42bfa19 100644
--- a/src/wolf.rs
+++ b/src/wolf.rs
@@ -5,7 +5,7 @@ use crate::{
     get_sprite_rotation,
     physics::{Velocity, WalkController},
     player::{Bark, DOG_SPEED},
-    safe_area::OutOfSafeArea,
+    safe_area::{OutOfSafeArea, SafeArea},
     test_level::LevelSize,
     GameStuff,
 };
@@ -110,11 +110,19 @@ fn catch_system(
     mut commands: Commands,
     sheep: Query<&Transform>,
     mut wolfs: Query<(Entity, &Transform, &mut WalkController, &TryToCatchSheep)>,
+    safearea: Query<&SafeArea>,
 ) {
     for (wolf, wolf_transform, mut walk_controller, try_to_catch_sheep) in wolfs.iter_mut() {
         let wolf_translation = wolf_transform.translation;
         if let Ok(sheep) = sheep.get(try_to_catch_sheep.target) {
-            if wolf_translation.distance(sheep.translation) < 1.0 {
+            if wolf_translation.distance(sheep.translation) < 1.0
+                || !safearea.iter().any(|area| {
+                    area.in_area(Vec2 {
+                        x: sheep.translation.x,
+                        y: sheep.translation.z,
+                    })
+                })
+            {
                 commands
                     .entity(wolf)
                     .insert(Eating { time: 10.0 })
@@ -137,11 +145,13 @@ fn catch_system(
 fn eating_system(
     mut commands: Commands,
     time: Res<Time>,
-    mut wolfs: Query<(Entity, &mut Eating, &mut WalkController)>,
+    mut wolfs: Query<(Entity, &Transform, &mut Eating, &mut WalkController)>,
+    safearea: Query<&SafeArea>,
 ) {
-    for (wolf, mut eating, mut walk_controller) in wolfs.iter_mut() {
+    for (wolf, wolf_transform, mut eating, mut walk_controller) in wolfs.iter_mut() {
         eating.time -= time.delta_seconds();
-        if eating.time <= 0.0 {
+        if eating.time <= 0.0
+        {
             commands.entity(wolf).remove::<Eating>().insert(GoOut);
         } else {
             walk_controller.target_velocity = Vec3::ZERO;
@@ -151,16 +161,25 @@ fn eating_system(
 
 fn go_out_system(
     mut commands: Commands,
-    mut wolfs: Query<(Entity, &mut Transform, &mut WalkController, &GoOut)>,
+    mut wolfs: Query<(Entity, &Transform, &mut WalkController, &GoOut)>,
+    safearea: Query<&SafeArea>,
     level_size: Res<LevelSize>,
 ) {
-    for (wolf, mut wolf_transform, mut walk_controller, go_out) in wolfs.iter_mut() {
+    for (wolf, wolf_transform, mut walk_controller, _go_out) in wolfs.iter_mut() {
         let dir = wolf_transform.translation.normalize();
         walk_controller.target_velocity = dir * WOLF_SPEED;
 
         if wolf_transform.translation.distance(Vec3::ZERO) > level_size.0 * 3.0 {
             commands.entity(wolf).despawn_recursive();
         }
+        if safearea.iter().any(|area| {
+            area.in_area(Vec2 {
+                x: wolf_transform.translation.x,
+                y: wolf_transform.translation.z,
+            })
+        }) {
+            commands.entity(wolf).insert(GoOut);
+        }
     }
 }
 
@@ -169,7 +188,7 @@ fn bark(
     mut wolfs: Query<(Entity, &Transform), With<Wolf>>,
     mut barks: EventReader<Bark>,
 ) {
-    let Some(bark) = barks.iter().next() else {
+    let Some(bark) = barks.read().next() else {
         return;
     };