From 7890afa788ea2a366e2e8fe42bf17b132d2b3dcc Mon Sep 17 00:00:00 2001
From: rewin <rewin1996@gmail.com>
Date: Sat, 9 Dec 2023 00:43:01 +0300
Subject: [PATCH] cargo fmt

---
 Cargo.toml              |   1 -
 src/debug_diagnostic.rs |  12 +++-
 src/finish_screen.rs    |  23 ++++---
 src/level_ui.rs         |   2 +-
 src/lib.rs              |  53 +++++++++-------
 src/menu.rs             |  90 ++++++++++++++--------------
 src/physics.rs          |   7 ++-
 src/player.rs           |   5 +-
 src/safe_area.rs        |   4 +-
 src/sheep.rs            |  22 +++++--
 src/storyteller.rs      |  37 ++++++------
 src/test_level.rs       |  56 ++++++++---------
 src/wolf.rs             | 130 ++++++++++++++++++++++------------------
 13 files changed, 244 insertions(+), 198 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 4900d16..53bd820 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,7 +25,6 @@ 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/src/debug_diagnostic.rs b/src/debug_diagnostic.rs
index e0a0163..5fa889b 100644
--- a/src/debug_diagnostic.rs
+++ b/src/debug_diagnostic.rs
@@ -18,7 +18,10 @@ impl Plugin for DiagnosticPlugin {
             )
                 .chain(),
         )
-        .add_systems(Update, (fps_counting, sheep_counter_text).in_set(GameSet::Playing));
+        .add_systems(
+            Update,
+            (fps_counting, sheep_counter_text).in_set(GameSet::Playing),
+        );
 
         #[cfg(debug_assertions)]
         {
@@ -95,9 +98,12 @@ 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>>,
     sheep_counter: Res<SheepCounter>,
-    start_sheep_count: Res<StartSheepCount>
+    start_sheep_count: Res<StartSheepCount>,
 ) {
     for mut text in &mut query {
-        text.sections[0].value = format!("Sheep in safe area: {}/{}", sheep_counter.count, start_sheep_count.0);
+        text.sections[0].value = format!(
+            "Sheep in safe area: {}/{}",
+            sheep_counter.count, start_sheep_count.0
+        );
     }
 }
diff --git a/src/finish_screen.rs b/src/finish_screen.rs
index 1dc5ebf..f2886e7 100644
--- a/src/finish_screen.rs
+++ b/src/finish_screen.rs
@@ -1,6 +1,9 @@
 use bevy::prelude::*;
 
-use crate::{GameState, storyteller::{Score, FailReason}, GameSet};
+use crate::{
+    storyteller::{FailReason, Score},
+    GameSet, GameState,
+};
 
 pub struct FinishScreenPlugin;
 
@@ -16,11 +19,7 @@ impl Plugin for FinishScreenPlugin {
 #[derive(Component)]
 struct FinishScreen;
 
-fn setup_finish_screen(
-    mut commands: Commands,
-    score : Res<Score>,
-    fail : Option<Res<FailReason>>
-) {
+fn setup_finish_screen(mut commands: Commands, score: Res<Score>, fail: Option<Res<FailReason>>) {
     let mut text_style = TextStyle::default();
     text_style.font_size = 24.0;
 
@@ -71,10 +70,7 @@ fn setup_finish_screen(
     });
 }
 
-fn cleanup_finish_screen(
-    mut commands: Commands,
-    query: Query<Entity, With<FinishScreen>>
-) {
+fn cleanup_finish_screen(mut commands: Commands, query: Query<Entity, With<FinishScreen>>) {
     for entity in query.iter() {
         commands.entity(entity).despawn_recursive();
     }
@@ -82,7 +78,10 @@ fn cleanup_finish_screen(
 
 fn finish_screen_system(
     mut next_state: ResMut<NextState<GameState>>,
-    mut interaction_query: Query<(&Interaction, &mut BackgroundColor), (Changed<Interaction>, With<Button>)>,
+    mut interaction_query: Query<
+        (&Interaction, &mut BackgroundColor),
+        (Changed<Interaction>, With<Button>),
+    >,
 ) {
     for (interaction, mut color) in interaction_query.iter_mut() {
         match *interaction {
@@ -97,4 +96,4 @@ fn finish_screen_system(
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/level_ui.rs b/src/level_ui.rs
index 78f62dd..275f2ff 100644
--- a/src/level_ui.rs
+++ b/src/level_ui.rs
@@ -47,7 +47,7 @@ fn create_level_ui_system(
                 ..default()
             },
             LevelUi,
-            GameStuff
+            GameStuff,
         ))
         .with_children(|parent| {
             parent.spawn((
diff --git a/src/lib.rs b/src/lib.rs
index 6752a96..9224d50 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,7 +2,9 @@
 
 pub mod common_storage;
 pub mod debug_diagnostic;
+pub mod finish_screen;
 pub mod level_ui;
+pub mod menu;
 pub mod physics;
 pub mod player;
 pub mod safe_area;
@@ -12,15 +14,13 @@ pub mod storyteller;
 pub mod test_level;
 pub mod torch;
 pub mod wolf;
-pub mod menu;
-pub mod finish_screen;
 
 use std::f32::consts::PI;
 
-use bevy::{app::App, core_pipeline::clear_color::ClearColorConfig};
 #[cfg(debug_assertions)]
 use bevy::diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin};
 use bevy::prelude::*;
+use bevy::{app::App, core_pipeline::clear_color::ClearColorConfig};
 
 // This example game uses States to separate logic
 // See https://bevy-cheatbook.github.io/programming/states.html
@@ -54,15 +54,30 @@ impl Plugin for GamePlugin {
         app.add_state::<GameState>();
 
         //Terrible set configuration
-        app.configure_sets(Update, GameSet::Loading.run_if(in_state(GameState::Loading)));
+        app.configure_sets(
+            Update,
+            GameSet::Loading.run_if(in_state(GameState::Loading)),
+        );
         app.configure_sets(Update, GameSet::Menu.run_if(in_state(GameState::Menu)));
-        app.configure_sets(Update, GameSet::Playing.run_if(in_state(GameState::Playing)));
+        app.configure_sets(
+            Update,
+            GameSet::Playing.run_if(in_state(GameState::Playing)),
+        );
         app.configure_sets(Update, GameSet::Finish.run_if(in_state(GameState::Finish)));
 
-        app.configure_sets(FixedUpdate, GameSet::Loading.run_if(in_state(GameState::Loading)));
+        app.configure_sets(
+            FixedUpdate,
+            GameSet::Loading.run_if(in_state(GameState::Loading)),
+        );
         app.configure_sets(FixedUpdate, GameSet::Menu.run_if(in_state(GameState::Menu)));
-        app.configure_sets(FixedUpdate, GameSet::Playing.run_if(in_state(GameState::Playing)));
-        app.configure_sets(FixedUpdate, GameSet::Finish.run_if(in_state(GameState::Finish)));
+        app.configure_sets(
+            FixedUpdate,
+            GameSet::Playing.run_if(in_state(GameState::Playing)),
+        );
+        app.configure_sets(
+            FixedUpdate,
+            GameSet::Finish.run_if(in_state(GameState::Finish)),
+        );
 
         #[cfg(debug_assertions)]
         {
@@ -83,13 +98,16 @@ impl Plugin for GamePlugin {
             level_ui::LevelUiPlugin,
             wolf::WolfPlugin,
             menu::MenuPlugin,
-            finish_screen::FinishScreenPlugin
+            finish_screen::FinishScreenPlugin,
         ));
 
         //For long term updates
         app.insert_resource(Time::<Fixed>::from_seconds(1.0));
 
-        app.add_systems(OnEnter(GameState::Playing), (test_level::setup, sheep::setup));
+        app.add_systems(
+            OnEnter(GameState::Playing),
+            (test_level::setup, sheep::setup),
+        );
 
         app.add_systems(Startup, (loading, camera_setup));
 
@@ -101,15 +119,11 @@ pub fn get_sprite_rotation() -> Quat {
     Quat::from_euler(EulerRot::XYZ, -PI / 2.0 - PI / 4.0, 0.0, 0.0)
 }
 
-fn loading(
-    mut next_state : ResMut<NextState<GameState>>
-) {
+fn loading(mut next_state: ResMut<NextState<GameState>>) {
     next_state.set(GameState::Menu);
 }
 
-fn camera_setup(
-    mut commands : Commands,
-) {
+fn camera_setup(mut commands: Commands) {
     commands.spawn(Camera3dBundle {
         transform: Transform::from_xyz(0.0, 30.0, 30.0).looking_at(Vec3::ZERO, Vec3::Y),
         camera: Camera {
@@ -127,11 +141,8 @@ fn camera_setup(
 #[derive(Component)]
 pub struct GameStuff;
 
-fn clear_game_stuff(
-    mut commands : Commands,
-    game_stuff : Query<Entity, With<GameStuff>>,
-) {
+fn clear_game_stuff(mut commands: Commands, game_stuff: Query<Entity, With<GameStuff>>) {
     for entity in game_stuff.iter() {
         commands.entity(entity).despawn_recursive();
     }
-}
\ No newline at end of file
+}
diff --git a/src/menu.rs b/src/menu.rs
index 0714820..b00fe76 100644
--- a/src/menu.rs
+++ b/src/menu.rs
@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 
-use crate::{GameState, GameSet};
+use crate::{GameSet, GameState};
 
 pub struct MenuPlugin;
 
@@ -15,59 +15,54 @@ impl Plugin for MenuPlugin {
 #[derive(Component)]
 pub struct MainMenu;
 
-fn setup_main_menu(
-    mut commands: Commands,
-) {
+fn setup_main_menu(mut commands: Commands) {
     let mut text_style = TextStyle::default();
     text_style.font_size = 24.0;
-    commands.spawn((
-        MainMenu,
-        NodeBundle {
-            style: Style {
-                width: Val::Percent(100.),
-                height: Val::Percent(100.),
-                justify_content: JustifyContent::Center,
-                align_items: AlignItems::Center,
-                flex_direction: FlexDirection::Column,
+    commands
+        .spawn((
+            MainMenu,
+            NodeBundle {
+                style: Style {
+                    width: Val::Percent(100.),
+                    height: Val::Percent(100.),
+                    justify_content: JustifyContent::Center,
+                    align_items: AlignItems::Center,
+                    flex_direction: FlexDirection::Column,
+                    ..default()
+                },
                 ..default()
             },
-            ..default()
-        }
-    )).with_children(|parent| {
-
-        parent.spawn(TextBundle::from_section(
-            "You are a shepherd dog servant of a vampire shepherd. \n
+        ))
+        .with_children(|parent| {
+            parent.spawn(TextBundle::from_section(
+                "You are a shepherd dog servant of a vampire shepherd. \n
 Don't let the sheep flock run away and be eaten by wolves, and fulfill the vampire's tasks. \n
 If you fail, you will be replaced. \n
 Good luck!\n",
-            TextStyle::default()
-        ));
-
-        parent.spawn(ButtonBundle {
-            style: Style {
-                width: Val::Px(100.0),
-                height: Val::Px(50.0),
-                border: UiRect::all(Val::Px(5.0)),
-                justify_content: JustifyContent::Center,
-                align_items: AlignItems::Center,
-                ..default()
-            },
-            border_color: BorderColor(Color::WHITE),
-            background_color: BackgroundColor(Color::BLACK),
-            ..default()
-        }).with_children(|parent| {
-            parent.spawn(TextBundle::from_section(
-                "Start", 
-                text_style.clone()
+                TextStyle::default(),
             ));
+
+            parent
+                .spawn(ButtonBundle {
+                    style: Style {
+                        width: Val::Px(100.0),
+                        height: Val::Px(50.0),
+                        border: UiRect::all(Val::Px(5.0)),
+                        justify_content: JustifyContent::Center,
+                        align_items: AlignItems::Center,
+                        ..default()
+                    },
+                    border_color: BorderColor(Color::WHITE),
+                    background_color: BackgroundColor(Color::BLACK),
+                    ..default()
+                })
+                .with_children(|parent| {
+                    parent.spawn(TextBundle::from_section("Start", text_style.clone()));
+                });
         });
-    });
 }
 
-fn clear_menu(
-    mut commands: Commands,
-    query: Query<Entity, With<MainMenu>>,
-) {
+fn clear_menu(mut commands: Commands, query: Query<Entity, With<MainMenu>>) {
     for entity in query.iter() {
         commands.entity(entity).despawn_recursive();
     }
@@ -75,11 +70,14 @@ fn clear_menu(
 
 fn button_system(
     mut next_state: ResMut<NextState<GameState>>,
-    mut interaction_query: Query<(&Interaction, &mut BackgroundColor), (Changed<Interaction>, With<Button>)>,
+    mut interaction_query: Query<
+        (&Interaction, &mut BackgroundColor),
+        (Changed<Interaction>, With<Button>),
+    >,
 ) {
     for (interaction, mut color) in &mut interaction_query {
         match *interaction {
-            Interaction::Pressed  => {
+            Interaction::Pressed => {
                 next_state.set(GameState::Playing);
             }
             Interaction::Hovered => {
@@ -90,4 +88,4 @@ fn button_system(
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/physics.rs b/src/physics.rs
index 2b62bcf..3a55f9a 100644
--- a/src/physics.rs
+++ b/src/physics.rs
@@ -6,7 +6,12 @@ pub struct PhysicsPlugin;
 
 impl Plugin for PhysicsPlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(Update, (walk_system, apply_velocity).chain().in_set(GameSet::Playing));
+        app.add_systems(
+            Update,
+            (walk_system, apply_velocity)
+                .chain()
+                .in_set(GameSet::Playing),
+        );
     }
 }
 
diff --git a/src/player.rs b/src/player.rs
index 7a5ce93..a925293 100644
--- a/src/player.rs
+++ b/src/player.rs
@@ -3,7 +3,8 @@ use bevy::{input::mouse::MouseWheel, prelude::*, window::PrimaryWindow};
 use crate::{
     get_sprite_rotation,
     physics::Velocity,
-    sprite_material::{create_plane_mesh, SpriteExtension, SpriteMaterial}, GameStuff,
+    sprite_material::{create_plane_mesh, SpriteExtension, SpriteMaterial},
+    GameStuff,
 };
 
 const DOG_PATH: &str = "test/dog.png";
@@ -108,7 +109,7 @@ fn spawn_player_by_event(
             Player,
             Dog,
             Velocity::default(),
-            GameStuff
+            GameStuff,
         ));
     }
     event_reader.clear();
diff --git a/src/safe_area.rs b/src/safe_area.rs
index 5ea6d75..f45754a 100644
--- a/src/safe_area.rs
+++ b/src/safe_area.rs
@@ -115,9 +115,7 @@ fn count_sheeps(
                 count += 1;
                 commands.entity(e).remove::<OutOfSafeArea>();
             } else {
-                commands
-                    .entity(e)
-                    .insert(OutOfSafeArea);
+                commands.entity(e).insert(OutOfSafeArea);
             }
         }
     }
diff --git a/src/sheep.rs b/src/sheep.rs
index 808d837..7d5b8a6 100644
--- a/src/sheep.rs
+++ b/src/sheep.rs
@@ -12,7 +12,8 @@ use crate::{
     player::{Bark, Dog, DOG_SPEED},
     safe_area::SafeArea,
     sprite_material::create_plane_mesh,
-    test_level::LevelSize, GameSet, GameStuff,
+    test_level::LevelSize,
+    GameSet, GameStuff,
 };
 
 use bevy_spatial::{
@@ -24,7 +25,7 @@ const SHEEP_PATH: &str = "test/sheep.png";
 pub const SHEEP_SPEED: f32 = DOG_SPEED * 0.5;
 const SHEEP_ACCELERATION: f32 = SHEEP_SPEED * 3.0;
 
-const RANDOM_WALK_RANGE: f32 =  2.0;
+const RANDOM_WALK_RANGE: f32 = 2.0;
 const RANDOM_WALK_ACCEPT_RADIUS: f32 = 0.5;
 pub const RANDOM_WALK_SPEED_MULTIPLIER: f32 = 0.3;
 
@@ -43,7 +44,10 @@ impl Plugin for SheepPlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<StateChance>();
 
-        app.add_systems(Update, (scared_sheeps, update_scared_sheeps).in_set(GameSet::Playing));
+        app.add_systems(
+            Update,
+            (scared_sheeps, update_scared_sheeps).in_set(GameSet::Playing),
+        );
 
         app.add_systems(Update, (sheep_state,).in_set(GameSet::Playing));
 
@@ -385,7 +389,8 @@ pub fn update_scared_sheeps(
                 }
             }
 
-            let speed_amount = (SHEEP_SPEED * (1.0 - dog_distance / SCARE_MAX_DIST) + SHEEP_SPEED * RANDOM_WALK_SPEED_MULTIPLIER)
+            let speed_amount = (SHEEP_SPEED * (1.0 - dog_distance / SCARE_MAX_DIST)
+                + SHEEP_SPEED * RANDOM_WALK_SPEED_MULTIPLIER)
                 .max(SHEEP_SPEED * RANDOM_WALK_SPEED_MULTIPLIER);
 
             if dog_distance < SCARE_MAX_DIST {
@@ -542,8 +547,13 @@ fn collect_field(
                     let dist_force = 10.0 * distance_force;
                     let dz = Vec3::new(0.0, 0.0, sum_dz);
 
-                    let wsum = vel.0.length() + mean_targets.length() + dist_force.length() + dz.length();
-                    let max_length = vel.0.length().max(mean_targets.length()).max(dist_force.length());
+                    let wsum =
+                        vel.0.length() + mean_targets.length() + dist_force.length() + dz.length();
+                    let max_length = vel
+                        .0
+                        .length()
+                        .max(mean_targets.length())
+                        .max(dist_force.length());
                     walk.target_velocity =
                         (vel.0 + dist_force + mean_targets + dz) / (wsum + 0.000001) * max_length;
                 } else {
diff --git a/src/storyteller.rs b/src/storyteller.rs
index 62e1ff0..094de22 100644
--- a/src/storyteller.rs
+++ b/src/storyteller.rs
@@ -12,9 +12,11 @@ use rand::Rng;
 use crate::{
     player::{Dog, DOG_SPEED},
     sheep::{
-        Decision, GoTo, IdleFeeding, IsScared, Sheep, RANDOM_WALK_SPEED_MULTIPLIER, SHEEP_SPEED, StartSheepCount,
+        Decision, GoTo, IdleFeeding, IsScared, Sheep, StartSheepCount,
+        RANDOM_WALK_SPEED_MULTIPLIER, SHEEP_SPEED,
     },
-    test_level::LevelSize, GameState, GameSet,
+    test_level::LevelSize,
+    GameSet, GameState,
 };
 
 pub struct StorytellerPlugin;
@@ -27,9 +29,15 @@ impl Plugin for StorytellerPlugin {
             next_wave: None,
         })
         .init_resource::<Score>()
-        .add_systems(Update, (storyteller_system, level_timer).in_set(GameSet::Playing))
+        .add_systems(
+            Update,
+            (storyteller_system, level_timer).in_set(GameSet::Playing),
+        )
         .add_systems(OnEnter(GameState::Playing), setup_start_time)
-        .add_systems(FixedUpdate, (score_system, fail_system).in_set(GameSet::Playing));
+        .add_systems(
+            FixedUpdate,
+            (score_system, fail_system).in_set(GameSet::Playing),
+        );
     }
 }
 
@@ -50,11 +58,7 @@ pub struct Storyteller {
 #[derive(Resource, Default)]
 pub struct Score(pub f32);
 
-fn setup_start_time(
-    mut commands: Commands,
-    mut teller: ResMut<Storyteller>, 
-    time: Res<Time>) 
-{
+fn setup_start_time(mut commands: Commands, mut teller: ResMut<Storyteller>, time: Res<Time>) {
     commands.remove_resource::<FailReason>();
     teller.level_start_time = time.elapsed_seconds();
 }
@@ -137,8 +141,8 @@ fn level_timer(
     mut timers: Query<&mut Text, With<LevelTimer>>,
     teller: Res<Storyteller>,
     time: Res<Time>,
-    mut next_state : ResMut<NextState<GameState>>,
-    score : Res<Score>
+    mut next_state: ResMut<NextState<GameState>>,
+    score: Res<Score>,
 ) {
     for mut timer in timers.iter_mut() {
         let level_time = time.elapsed_seconds() - teller.level_start_time;
@@ -148,8 +152,7 @@ fn level_timer(
             let time = format!("{:02}:{:02}", dur.as_secs() / 60, dur.as_secs() % 60);
             let score_text = format!("Score: {:.1}", score.0);
 
-            timer.sections[0].value =
-                format!("{}\n{}", time, score_text);
+            timer.sections[0].value = format!("{}\n{}", time, score_text);
         } else {
             timer.sections[0].value = format!("{:02}:{:02}", 0, 0);
             next_state.set(GameState::Finish);
@@ -158,7 +161,7 @@ fn level_timer(
 }
 
 fn score_system(
-    mut score : ResMut<Score>,
+    mut score: ResMut<Score>,
     mut alived_sheep: Query<&Sheep>,
     mut teller: ResMut<Storyteller>,
     time: Res<Time>,
@@ -170,7 +173,7 @@ fn score_system(
 
 fn fail_system(
     mut commands: Commands,
-    mut next_state : ResMut<NextState<GameState>>,
+    mut next_state: ResMut<NextState<GameState>>,
     alived_sheep: Query<&Sheep>,
     start_sheep_count: Res<StartSheepCount>,
 ) {
@@ -183,5 +186,5 @@ fn fail_system(
 #[derive(Resource)]
 pub enum FailReason {
     SheepDied,
-    TaskFailed
-}
\ No newline at end of file
+    TaskFailed,
+}
diff --git a/src/test_level.rs b/src/test_level.rs
index c597b2c..6be10c6 100644
--- a/src/test_level.rs
+++ b/src/test_level.rs
@@ -88,33 +88,33 @@ pub fn setup(
             continue;
         }
 
-        commands.spawn(PbrBundle {
-            mesh: square.clone(),
-            material: tree_material.clone(),
-            transform: Transform::from_xyz(pos.x, pos.y, pos.z)
-                .with_rotation(get_sprite_rotation())
-                .with_scale(Vec3::new(2.5, 2.6, 5.0)),
-            ..default()
-        }).insert(
-            GameStuff
-        );
+        commands
+            .spawn(PbrBundle {
+                mesh: square.clone(),
+                material: tree_material.clone(),
+                transform: Transform::from_xyz(pos.x, pos.y, pos.z)
+                    .with_rotation(get_sprite_rotation())
+                    .with_scale(Vec3::new(2.5, 2.6, 5.0)),
+                ..default()
+            })
+            .insert(GameStuff);
     }
 
     //green plane
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Mesh::from(shape::Plane {
-            size: tree_r * 2.0,
-            ..default()
-        })),
-        material: materials.add(StandardMaterial {
-            base_color: Color::hex("5d9669").unwrap(),
+    commands
+        .spawn(PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::Plane {
+                size: tree_r * 2.0,
+                ..default()
+            })),
+            material: materials.add(StandardMaterial {
+                base_color: Color::hex("5d9669").unwrap(),
+                ..default()
+            }),
+            transform: Transform::from_xyz(0.0, 0.0, 0.0),
             ..default()
-        }),
-        transform: Transform::from_xyz(0.0, 0.0, 0.0),
-        ..default()
-    }).insert(
-        GameStuff
-    );
+        })
+        .insert(GameStuff);
 
     spawn_player_event.send(SpawnPlayer {
         position: Vec3::new(-r - 2.0, 0.0, 0.0),
@@ -128,10 +128,12 @@ pub fn setup(
         spawn_torch.send(SpawnTorch { position: pos });
     }
 
-    commands.spawn(SafeArea::Rect {
-        pos: Vec2::ZERO,
-        size: Vec2::new(r * 1.5, r * 1.5),
-    }).insert(GameStuff);
+    commands
+        .spawn(SafeArea::Rect {
+            pos: Vec2::ZERO,
+            size: Vec2::new(r * 1.5, r * 1.5),
+        })
+        .insert(GameStuff);
 
     create_level_ui.send(CreateLevelUi);
 }
diff --git a/src/wolf.rs b/src/wolf.rs
index aabbdc6..903e924 100644
--- a/src/wolf.rs
+++ b/src/wolf.rs
@@ -1,6 +1,14 @@
 use bevy::prelude::*;
 
-use crate::{safe_area::OutOfSafeArea, player::{DOG_SPEED, Bark}, test_level::LevelSize, common_storage::CommonStorage, get_sprite_rotation, physics::{Velocity, WalkController}, GameStuff};
+use crate::{
+    common_storage::CommonStorage,
+    get_sprite_rotation,
+    physics::{Velocity, WalkController},
+    player::{Bark, DOG_SPEED},
+    safe_area::OutOfSafeArea,
+    test_level::LevelSize,
+    GameStuff,
+};
 
 const WOLF_SPEED: f32 = DOG_SPEED * 1.3;
 const WOLF_ACCEL: f32 = WOLF_SPEED * 2.0;
@@ -9,20 +17,19 @@ pub struct WolfPlugin;
 
 impl Plugin for WolfPlugin {
     fn build(&self, app: &mut App) {
-        app
-            .add_systems(Startup, setup_wolf_material)
-            .add_systems(
-                Update,
-                (
-                    apply_deferred,
-                    wolf_spawner,
-                    catch_system,
-                    eating_system,
-                    go_out_system,
-                    bark,
-                    apply_deferred
-                ).chain()
-            );
+        app.add_systems(Startup, setup_wolf_material).add_systems(
+            Update,
+            (
+                apply_deferred,
+                wolf_spawner,
+                catch_system,
+                eating_system,
+                go_out_system,
+                bark,
+                apply_deferred,
+            )
+                .chain(),
+        );
     }
 }
 
@@ -31,7 +38,7 @@ pub struct Wolf;
 
 #[derive(Component)]
 pub struct TryToCatchSheep {
-    pub target: Entity
+    pub target: Entity,
 }
 
 #[derive(Component)]
@@ -42,55 +49,57 @@ pub struct UnderHunting;
 
 #[derive(Resource)]
 pub struct WolfStorage {
-    pub material : Handle<StandardMaterial>
+    pub material: Handle<StandardMaterial>,
 }
 
 #[derive(Component)]
 pub struct Eating {
-    pub time : f32
+    pub time: f32,
 }
 
 fn setup_wolf_material(
     mut commands: Commands,
     mut materials: ResMut<Assets<StandardMaterial>>,
-    asset_server : Res<AssetServer>,
+    asset_server: Res<AssetServer>,
 ) {
     commands.insert_resource(WolfStorage {
         material: materials.add(StandardMaterial {
             base_color_texture: Some(asset_server.load("test/wolf.png")),
             alpha_mode: AlphaMode::Opaque,
             ..default()
-        })
+        }),
     })
 }
 
 fn wolf_spawner(
     mut commands: Commands,
     sheep: Query<(Entity, &Transform), (With<OutOfSafeArea>, Without<UnderHunting>)>,
-    level_size : Res<LevelSize>,
-    common_storage : Res<CommonStorage>,
-    wolf_storage: Res<WolfStorage>
+    level_size: Res<LevelSize>,
+    common_storage: Res<CommonStorage>,
+    wolf_storage: Res<WolfStorage>,
 ) {
     for (sheep_entity, sheep_transform) in sheep.iter() {
-        commands
-            .spawn((
-                Wolf,
-                PbrBundle {
-                    mesh: common_storage.plane.clone(),
-                    material: wolf_storage.material.clone(),
-                    transform: Transform::from_translation(sheep_transform.translation.normalize() * level_size.0 * 2.0).with_rotation(get_sprite_rotation()),
-                    ..default()
-                },
-                TryToCatchSheep {
-                    target: sheep_entity
-                },
-                Velocity::default(),
-                WalkController {
-                    max_speed: WOLF_SPEED,
-                    acceleration: WOLF_ACCEL,
-                    target_velocity: Vec3::ZERO
-                },
-                GameStuff,
+        commands.spawn((
+            Wolf,
+            PbrBundle {
+                mesh: common_storage.plane.clone(),
+                material: wolf_storage.material.clone(),
+                transform: Transform::from_translation(
+                    sheep_transform.translation.normalize() * level_size.0 * 2.0,
+                )
+                .with_rotation(get_sprite_rotation()),
+                ..default()
+            },
+            TryToCatchSheep {
+                target: sheep_entity,
+            },
+            Velocity::default(),
+            WalkController {
+                max_speed: WOLF_SPEED,
+                acceleration: WOLF_ACCEL,
+                target_velocity: Vec3::ZERO,
+            },
+            GameStuff,
         ));
 
         commands.entity(sheep_entity).insert(UnderHunting);
@@ -99,21 +108,27 @@ fn wolf_spawner(
 
 fn catch_system(
     mut commands: Commands,
-    sheep : Query<&Transform>,
-    mut wolfs : Query<(Entity, &Transform, &mut WalkController, &TryToCatchSheep)>
+    sheep: Query<&Transform>,
+    mut wolfs: Query<(Entity, &Transform, &mut WalkController, &TryToCatchSheep)>,
 ) {
     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 {
-                commands.entity(wolf).insert(Eating {
-                    time: 10.0
-                }).remove::<TryToCatchSheep>();
-
-                commands.entity(try_to_catch_sheep.target).despawn_recursive();
+                commands
+                    .entity(wolf)
+                    .insert(Eating { time: 10.0 })
+                    .remove::<TryToCatchSheep>();
+
+                commands
+                    .entity(try_to_catch_sheep.target)
+                    .despawn_recursive();
             } else {
-                walk_controller.target_velocity = (sheep.translation - wolf_translation).normalize() * WOLF_SPEED;
-                walk_controller.target_velocity = walk_controller.target_velocity.clamp_length_max((sheep.translation - wolf_translation).length() * 2.0);
+                walk_controller.target_velocity =
+                    (sheep.translation - wolf_translation).normalize() * WOLF_SPEED;
+                walk_controller.target_velocity = walk_controller
+                    .target_velocity
+                    .clamp_length_max((sheep.translation - wolf_translation).length() * 2.0);
             }
         }
     }
@@ -122,13 +137,12 @@ fn catch_system(
 fn eating_system(
     mut commands: Commands,
     time: Res<Time>,
-    mut wolfs : Query<(Entity, &mut Eating, &mut WalkController)>
+    mut wolfs: Query<(Entity, &mut Eating, &mut WalkController)>,
 ) {
     for (wolf, mut eating, mut walk_controller) in wolfs.iter_mut() {
         eating.time -= time.delta_seconds();
         if eating.time <= 0.0 {
-            commands.entity(wolf).remove::<Eating>()
-                .insert(GoOut);
+            commands.entity(wolf).remove::<Eating>().insert(GoOut);
         } else {
             walk_controller.target_velocity = Vec3::ZERO;
         }
@@ -137,8 +151,8 @@ fn eating_system(
 
 fn go_out_system(
     mut commands: Commands,
-    mut wolfs : Query<(Entity, &mut Transform, &mut WalkController, &GoOut)>,
-    level_size : Res<LevelSize>
+    mut wolfs: Query<(Entity, &mut Transform, &mut WalkController, &GoOut)>,
+    level_size: Res<LevelSize>,
 ) {
     for (wolf, mut wolf_transform, mut walk_controller, go_out) in wolfs.iter_mut() {
         let dir = wolf_transform.translation.normalize();
@@ -153,7 +167,7 @@ fn go_out_system(
 fn bark(
     mut commands: Commands,
     mut wolfs: Query<(Entity, &Transform), With<Wolf>>,
-    mut barks : EventReader<Bark>,
+    mut barks: EventReader<Bark>,
 ) {
     let Some(bark) = barks.iter().next() else {
         return;
@@ -168,4 +182,4 @@ fn bark(
                 .remove::<TryToCatchSheep>();
         }
     }
-}
\ No newline at end of file
+}