From 3c226bb064284ae6db15047c9bc5fa46e45695f7 Mon Sep 17 00:00:00 2001
From: rewin <rewin1996@gmail.com>
Date: Thu, 7 Dec 2023 22:26:11 +0300
Subject: [PATCH] cargo fmt

---
 src/level_ui.rs    | 44 +++++++++++------------
 src/lib.rs         |  4 +--
 src/sheep.rs       |  2 +-
 src/storyteller.rs | 90 +++++++++++++++++++++++-----------------------
 src/test_level.rs  |  6 ++--
 5 files changed, 72 insertions(+), 74 deletions(-)

diff --git a/src/level_ui.rs b/src/level_ui.rs
index 3c40e71..074b554 100644
--- a/src/level_ui.rs
+++ b/src/level_ui.rs
@@ -30,30 +30,30 @@ fn create_level_ui_system(
     text_style.font_size = 24.0;
 
     //Spawn top info bar
-    commands.spawn((NodeBundle {
-            style: Style {
-                width: Val::Percent(100.0),
-                height: Val::Px(50.0),
-                flex_direction: FlexDirection::Row,
-                justify_content: JustifyContent::Center,
-                align_items: AlignItems::Center,
-
-                align_self: AlignSelf::Stretch,
+    commands
+        .spawn((
+            NodeBundle {
+                style: Style {
+                    width: Val::Percent(100.0),
+                    height: Val::Px(50.0),
+                    flex_direction: FlexDirection::Row,
+                    justify_content: JustifyContent::Center,
+                    align_items: AlignItems::Center,
+
+                    align_self: AlignSelf::Stretch,
+                    ..default()
+                },
                 ..default()
             },
-            ..default()
-        }, 
-        LevelUi
-    )).with_children(|parent| {
-        parent.spawn((
-            TextBundle::from_section(
-                "",
-                text_style.clone()
-            ),
             LevelUi,
-            LevelTimer
-        ));
-    });
+        ))
+        .with_children(|parent| {
+            parent.spawn((
+                TextBundle::from_section("", text_style.clone()),
+                LevelUi,
+                LevelTimer,
+            ));
+        });
 
     ev_create_level_ui.clear();
-}
\ No newline at end of file
+}
diff --git a/src/lib.rs b/src/lib.rs
index 43e1731..e777c26 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,15 +2,15 @@
 
 pub mod common_storage;
 pub mod debug_diagnostic;
+pub mod level_ui;
 pub mod physics;
 pub mod player;
 pub mod safe_area;
 pub mod sheep;
 pub mod sprite_material;
+pub mod storyteller;
 pub mod test_level;
 pub mod torch;
-pub mod storyteller;
-pub mod level_ui;
 
 use std::f32::consts::PI;
 
diff --git a/src/sheep.rs b/src/sheep.rs
index 11aa070..f84b39e 100644
--- a/src/sheep.rs
+++ b/src/sheep.rs
@@ -49,7 +49,7 @@ impl Plugin for SheepPlugin {
 
         //random walk
         app.add_event::<InitRandomWalk>()
-            .add_systems(Update, (init_random_walk, ));
+            .add_systems(Update, (init_random_walk,));
 
         app.add_systems(Update, (goto_system,));
 
diff --git a/src/storyteller.rs b/src/storyteller.rs
index 3ee62f2..2602b79 100644
--- a/src/storyteller.rs
+++ b/src/storyteller.rs
@@ -1,74 +1,73 @@
 //This global AI is responsible for creating problems for player
 //This module will be determine where and how sheep will be try to escape from safe zone
 
-use std::{f32::consts::{PI, E}, time::Duration};
+use std::{
+    f32::consts::{E, PI},
+    time::Duration,
+};
 
 use bevy::prelude::*;
 use rand::Rng;
 
-use crate::{sheep::{Sheep, SHEEP_SPEED, RANDOM_WALK_SPEED_MULTIPLIER, GoTo}, test_level::LevelSize, player::DOG_SPEED};
+use crate::{
+    player::DOG_SPEED,
+    sheep::{GoTo, Sheep, RANDOM_WALK_SPEED_MULTIPLIER, SHEEP_SPEED},
+    test_level::LevelSize,
+};
 
 pub struct StorytellerPlugin;
 
 impl Plugin for StorytellerPlugin {
     fn build(&self, app: &mut App) {
-        app
-            .insert_resource(Storyteller {
-                level_start_time : 0.0,
-                level_duration : 4.0 * 60.0,
-                next_wave : None
-            })
-            .add_systems(Update, (
-                storyteller_system,
-                level_timer
-            ))
-            .add_systems(PostStartup, setup_start_time);
+        app.insert_resource(Storyteller {
+            level_start_time: 0.0,
+            level_duration: 4.0 * 60.0,
+            next_wave: None,
+        })
+        .add_systems(Update, (storyteller_system, level_timer))
+        .add_systems(PostStartup, setup_start_time);
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct SheepWave {
-    pub count : usize,
-    pub beams : usize,
-    pub time : f32
+    pub count: usize,
+    pub beams: usize,
+    pub time: f32,
 }
 
 #[derive(Resource)]
 pub struct Storyteller {
-    pub level_start_time : f32,
-    pub level_duration : f32,
-    pub next_wave : Option<SheepWave>
+    pub level_start_time: f32,
+    pub level_duration: f32,
+    pub next_wave: Option<SheepWave>,
 }
 
-fn setup_start_time(
-    mut teller : ResMut<Storyteller>,
-    time : Res<Time>
-) {
+fn setup_start_time(mut teller: ResMut<Storyteller>, time: Res<Time>) {
     teller.level_start_time = time.elapsed_seconds();
 }
 
 fn storyteller_system(
     mut commands: Commands,
-    sheep : Query<(Entity, &Transform), With<Sheep>>,
-    mut teller : ResMut<Storyteller>,
-    time : Res<Time>,
-    level_size : Res<LevelSize>
+    sheep: Query<(Entity, &Transform), With<Sheep>>,
+    mut teller: ResMut<Storyteller>,
+    time: Res<Time>,
+    level_size: Res<LevelSize>,
 ) {
     if teller.next_wave.is_none() {
         let level_time = time.elapsed_seconds() - teller.level_start_time;
         let unfiorm_time = level_time / teller.level_duration;
 
-
         let sheep_count = sheep.iter().count() as f32;
 
         let c = sheep_count * unfiorm_time * 0.2 + 1.0;
         let dt = 15.0 - 10.0 * unfiorm_time;
         let n = 1.0 + 2.0 * unfiorm_time;
-        
+
         teller.next_wave = Some(SheepWave {
-            count : c as usize,
-            beams : n as usize,
-            time : time.elapsed_seconds() + dt
+            count: c as usize,
+            beams: n as usize,
+            time: time.elapsed_seconds() + dt,
         });
 
         info!("Next wave: {:?}", teller.next_wave);
@@ -82,14 +81,16 @@ fn storyteller_system(
 
             let split_c = (wave.count / wave.beams).max(1);
             for _ in 0..wave.beams {
-                let random_dir = Vec3::new(rand.gen_range(-1.0..1.0), 0.0, rand.gen_range(-1.0..1.0)).normalize();
+                let random_dir =
+                    Vec3::new(rand.gen_range(-1.0..1.0), 0.0, rand.gen_range(-1.0..1.0))
+                        .normalize();
                 //create a sorted list of sheep which far in direction
                 let mut sorted_sheep = sheep
                     .iter()
                     .map(|(e, t)| {
                         let dir = t.translation;
                         let proj_dir = dir.dot(random_dir);
-                        (e, dir, proj_dir)   
+                        (e, dir, proj_dir)
                     })
                     .collect::<Vec<_>>();
                 sorted_sheep.sort_by(|a, b| b.2.partial_cmp(&a.2).unwrap());
@@ -98,36 +99,33 @@ fn storyteller_system(
                 for i in 0..split_c {
                     if let Some((e, pos, dist)) = sorted_sheep.get(i) {
                         info!("Sending {:?} with {:?}", e, dist);
-                        commands.entity(*e).insert(
-                            GoTo {
-                                target: *pos + level_size.0 * random_dir,
-                            }
-                        );
+                        commands.entity(*e).insert(GoTo {
+                            target: *pos + level_size.0 * random_dir,
+                        });
                     }
                 }
             }
         }
     }
-
-
 }
 
 #[derive(Component)]
 pub struct LevelTimer;
 
 fn level_timer(
-    mut timers : Query<&mut Text, With<LevelTimer>>,
-    teller : Res<Storyteller>,
-    time : Res<Time>
+    mut timers: Query<&mut Text, With<LevelTimer>>,
+    teller: Res<Storyteller>,
+    time: Res<Time>,
 ) {
     for mut timer in timers.iter_mut() {
         let level_time = time.elapsed_seconds() - teller.level_start_time;
         if (level_time > 0.0) {
             let dur = Duration::from_secs_f32(teller.level_duration - level_time);
 
-            timer.sections[0].value = format!("{:02}:{:02}", dur.as_secs() / 60, dur.as_secs() % 60);
+            timer.sections[0].value =
+                format!("{:02}:{:02}", dur.as_secs() / 60, dur.as_secs() % 60);
         } else {
             timer.sections[0].value = format!("{:02}:{:02}", 0, 0);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/test_level.rs b/src/test_level.rs
index a116769..f207a89 100644
--- a/src/test_level.rs
+++ b/src/test_level.rs
@@ -5,8 +5,8 @@ use rand::prelude::*;
 use std::f32::consts::PI;
 
 use crate::{
-    get_sprite_rotation, player::SpawnPlayer, safe_area::SafeArea,
-    sprite_material::create_plane_mesh, torch::SpawnTorch, level_ui::CreateLevelUi,
+    get_sprite_rotation, level_ui::CreateLevelUi, player::SpawnPlayer, safe_area::SafeArea,
+    sprite_material::create_plane_mesh, torch::SpawnTorch,
 };
 
 const TREE_PATH: &str = "test/pine.png";
@@ -33,7 +33,7 @@ pub fn setup(
     mut spawn_player_event: EventWriter<SpawnPlayer>,
     mut spawn_torch: EventWriter<SpawnTorch>,
     level_size: Res<LevelSize>,
-    mut create_level_ui : EventWriter<CreateLevelUi>,
+    mut create_level_ui: EventWriter<CreateLevelUi>,
 ) {
     commands.spawn(Camera3dBundle {
         transform: Transform::from_xyz(0.0, 30.0, 30.0).looking_at(Vec3::ZERO, Vec3::Y),