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

---
 src/lib.rs         |  4 +--
 src/physics.rs     |  3 +-
 src/player.rs      | 13 ++++---
 src/safe_area.rs   | 51 ++++++++++++--------------
 src/shepherd.rs    | 56 ++++++++++++++++-------------
 src/storyteller.rs |  9 +++--
 src/sunday.rs      | 75 +++++++++++++++++++++-----------------
 src/test_level.rs  | 22 ++++++++----
 src/torch.rs       | 90 +++++++++++++++++++++++++---------------------
 9 files changed, 177 insertions(+), 146 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 15f38aa..38f9805 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,13 +9,13 @@ pub mod physics;
 pub mod player;
 pub mod safe_area;
 pub mod sheep;
+pub mod shepherd;
 pub mod sprite_material;
 pub mod storyteller;
+pub mod sunday;
 pub mod test_level;
 pub mod torch;
 pub mod wolf;
-pub mod sunday;
-pub mod shepherd;
 
 use std::f32::consts::PI;
 
diff --git a/src/physics.rs b/src/physics.rs
index 3513719..9f366a7 100644
--- a/src/physics.rs
+++ b/src/physics.rs
@@ -38,7 +38,8 @@ fn walk_system(time: Res<Time>, mut query: Query<(&mut Velocity, &mut WalkContro
         let dspeed = controller.target_velocity - velocity.0;
         let accel = controller.acceleration.min(dspeed.length() * 100.0);
         let cur_vel = velocity.0;
-        velocity.0 += (dspeed.normalize_or_zero() * accel - cur_vel * AIR_RESISTANCE) * time.delta_seconds();
+        velocity.0 +=
+            (dspeed.normalize_or_zero() * accel - cur_vel * AIR_RESISTANCE) * time.delta_seconds();
         velocity.0 = velocity.0.clamp_length_max(controller.max_speed);
     }
 }
diff --git a/src/player.rs b/src/player.rs
index 5c50284..95bff8a 100644
--- a/src/player.rs
+++ b/src/player.rs
@@ -1,4 +1,9 @@
-use bevy::{input::mouse::MouseWheel, prelude::*, window::PrimaryWindow, pbr::{CascadeShadowConfig, CascadeShadowConfigBuilder}};
+use bevy::{
+    input::mouse::MouseWheel,
+    pbr::{CascadeShadowConfig, CascadeShadowConfigBuilder},
+    prelude::*,
+    window::PrimaryWindow,
+};
 
 use crate::{
     get_sprite_rotation,
@@ -224,7 +229,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>
+    mut sun: Query<&mut CascadeShadowConfig>,
 ) {
     let Ok((mut camera, mut distance)) = camera_query.get_single_mut() else {
         return;
@@ -233,7 +238,6 @@ fn camera_movement(
         return;
     };
 
-
     let Ok(mut sun) = sun.get_single_mut() else {
         return;
     };
@@ -247,7 +251,6 @@ fn camera_movement(
         }
 
         distance.0 = distance.0.clamp(10.0, 150.0);
-        
 
         let mut cascade = CascadeShadowConfigBuilder::default();
         cascade.maximum_distance = distance.0 * 2.0;
@@ -267,7 +270,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>
+    mut sun: Query<&mut CascadeShadowConfig>,
 ) {
     let Ok(player) = player_query.get_single() else {
         return;
diff --git a/src/safe_area.rs b/src/safe_area.rs
index 7097c84..b231daa 100644
--- a/src/safe_area.rs
+++ b/src/safe_area.rs
@@ -21,9 +21,9 @@ impl Plugin for SafeAreaPlugin {
 
 #[derive(Component, Clone)]
 pub enum SafeArea {
-    Rect { pos: Vec2, size: Vec2},
-    Ellipse { pos1: Vec2, pos2: Vec2, radius: f32},
-    Circle { pos: Vec2, radius: f32},
+    Rect { pos: Vec2, size: Vec2 },
+    Ellipse { pos1: Vec2, pos2: Vec2, radius: f32 },
+    Circle { pos: Vec2, radius: f32 },
 }
 
 #[derive(Component)]
@@ -49,9 +49,7 @@ impl SafeArea {
                 let r = (*pos1 - sheep_pos).length();
                 r * r <= d * d
             }
-            SafeArea::Circle { pos, radius } => {
-                (*pos - sheep_pos).length() < *radius
-            }
+            SafeArea::Circle { pos, radius } => (*pos - sheep_pos).length() < *radius,
         }
     }
 
@@ -79,32 +77,24 @@ impl SafeArea {
                 pos2,
                 radius: _,
             } => Vec3::new((pos1.x + pos2.x) / 2.0, 0.0, (pos1.y + pos2.y) / 2.0),
-            SafeArea::Circle { pos, radius } => {
-                Vec3::new(pos.x, 0.0, pos.y)
-            }
+            SafeArea::Circle { pos, radius } => Vec3::new(pos.x, 0.0, pos.y),
         }
     }
 
     pub fn get_scaled(&self, scale: f32) -> SafeArea {
         match self {
-            SafeArea::Rect { pos, size } => {
-                SafeArea::Rect {
-                    pos: *pos,
-                    size: *size * scale,
-                }
-            }
-            SafeArea::Ellipse { pos1, pos2, radius } => {
-                SafeArea::Ellipse {
-                    pos1: *pos1,
-                    pos2: *pos2,
-                    radius: *radius * scale,
-                }
+            SafeArea::Rect { pos, size } => SafeArea::Rect {
+                pos: *pos,
+                size: *size * scale,
             },
-            SafeArea::Circle { pos, radius } => {
-                SafeArea::Circle {
-                    pos: *pos,
-                    radius: *radius * scale,
-                }
+            SafeArea::Ellipse { pos1, pos2, radius } => SafeArea::Ellipse {
+                pos1: *pos1,
+                pos2: *pos2,
+                radius: *radius * scale,
+            },
+            SafeArea::Circle { pos, radius } => SafeArea::Circle {
+                pos: *pos,
+                radius: *radius * scale,
             },
         }
     }
@@ -130,7 +120,12 @@ fn draw_safe_area(mut gizmos: Gizmos, query: Query<&SafeArea, Without<HiddenSafe
                 radius: _,
             } => {}
             SafeArea::Circle { pos, radius } => {
-                gizmos.circle(Vec3::new(pos.x, 0.001, pos.y), Vec3::Y, *radius, Color::ORANGE);
+                gizmos.circle(
+                    Vec3::new(pos.x, 0.001, pos.y),
+                    Vec3::Y,
+                    *radius,
+                    Color::ORANGE,
+                );
             }
         }
     }
@@ -166,4 +161,4 @@ fn count_sheeps(
         }
     }
     counter.count = count;
-}
\ No newline at end of file
+}
diff --git a/src/shepherd.rs b/src/shepherd.rs
index 3f1aa3e..063d798 100644
--- a/src/shepherd.rs
+++ b/src/shepherd.rs
@@ -1,6 +1,14 @@
 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};
+use crate::{
+    common_storage::CommonStorage,
+    get_sprite_rotation,
+    physics::{Velocity, WalkController},
+    player::{DOG_ACCELERATION, DOG_SPEED},
+    sunday::DayState,
+    torch::{IgniteTorch, TorchBase},
+    GameSet,
+};
 
 const SHEPHERD_PATH: &str = "test/Knight.png";
 
@@ -13,12 +21,10 @@ 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)
+        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);
     }
@@ -35,10 +41,7 @@ pub struct Shepherd;
 #[derive(Component)]
 pub struct IgniteAllTorhes;
 
-fn start_ignite_torches(
-    mut commands: Commands,
-    query : Query<Entity, With<Shepherd>>
-) {
+fn start_ignite_torches(mut commands: Commands, query: Query<Entity, With<Shepherd>>) {
     if let Ok(entity) = query.get_single() {
         commands.entity(entity).insert(IgniteAllTorhes);
     }
@@ -46,17 +49,17 @@ fn start_ignite_torches(
 
 fn ignite_all_torhes(
     mut commands: Commands,
-    mut query : Query<(Entity, &mut WalkController, &Transform), With<IgniteAllTorhes>>,
-    torches : Query<(&Transform, &TorchBase)>,
-    mut ignite : EventWriter<IgniteTorch>
+    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 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();
@@ -69,12 +72,13 @@ fn ignite_all_torhes(
 
     if let Some(nearest_torch) = nearest_torch {
         if dist < IGNITE_RADIUS {
-            ignite.send(IgniteTorch { 
+            ignite.send(IgniteTorch {
                 position: transform.translation,
-                radius: IGNITE_RADIUS
-            }); 
+                radius: IGNITE_RADIUS,
+            });
         } else {
-            walk_controller.target_velocity = (nearest_torch - transform.translation).normalize() * SHEPHERD_SPEED;
+            walk_controller.target_velocity =
+                (nearest_torch - transform.translation).normalize() * SHEPHERD_SPEED;
         }
     } else {
         commands.entity(herd_entity).remove::<IgniteAllTorhes>();
@@ -86,14 +90,16 @@ fn spawn_shepherd_system(
     mut commands: Commands,
     mut events: EventReader<SpawnShepherd>,
     asset_server: Res<AssetServer>,
-    common_storage : Res<CommonStorage>,
-    mut materials : ResMut<Assets<StandardMaterial>>,
+    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)),
+                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()
@@ -106,8 +112,8 @@ fn spawn_shepherd_system(
                 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 142fcb2..e6c4f61 100644
--- a/src/storyteller.rs
+++ b/src/storyteller.rs
@@ -57,11 +57,11 @@ pub struct Storyteller {
 }
 
 impl Storyteller {
-    pub fn get_level_time(&self, time : &Time) -> f32 {
+    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 {
+    pub fn get_level_unfirom_time(&self, time: &Time) -> f32 {
         self.get_level_time(time) / self.level_duration
     }
 }
@@ -200,11 +200,10 @@ pub enum FailReason {
     TaskFailed,
 }
 
-
 pub enum TaskStatus {
     Active,
     Done,
-    Failed
+    Failed,
 }
 
 #[derive(States, Debug, Clone, Eq, PartialEq, Hash, Default)]
@@ -214,4 +213,4 @@ pub enum GlobalTask {
     SheepEscape,
     WolfAttack,
     CollectSheepInArea,
-}
\ No newline at end of file
+}
diff --git a/src/sunday.rs b/src/sunday.rs
index a2b98f2..f9e851a 100644
--- a/src/sunday.rs
+++ b/src/sunday.rs
@@ -2,7 +2,11 @@ use std::f32::consts::PI;
 
 use bevy::prelude::*;
 
-use crate::{storyteller::Storyteller, GameSet, safe_area::{SafeArea, LandSafeArea}};
+use crate::{
+    safe_area::{LandSafeArea, SafeArea},
+    storyteller::Storyteller,
+    GameSet,
+};
 
 pub struct SundayPlugin;
 
@@ -34,7 +38,12 @@ impl Plugin for SundayPlugin {
         app.add_systems(Update, set_day_state.in_set(GameSet::Playing));
         app.add_state::<DayState>();
 
-        app.add_systems(Update, safe_area_evening_decrease.in_set(GameSet::Playing).run_if(in_state(DayState::Evening)));
+        app.add_systems(
+            Update,
+            safe_area_evening_decrease
+                .in_set(GameSet::Playing)
+                .run_if(in_state(DayState::Evening)),
+        );
         app.add_systems(OnEnter(DayState::Night), delete_land_area_at_night);
     }
 }
@@ -48,10 +57,10 @@ pub enum DayState {
 }
 
 fn set_day_state(
-    mut state : ResMut<NextState<DayState>>,
-    current_state : Res<State<DayState>>,
-    teller : Res<Storyteller>,
-    time : Res<Time>
+    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 {
@@ -71,9 +80,9 @@ fn set_day_state(
 
 fn sunday_system(
     time: Res<Time>,
-    teller : Res<Storyteller>,
-    mut sun : Query<(&mut Transform, &mut DirectionalLight)>,
-    mut ambient_light: ResMut<AmbientLight>
+    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");
@@ -87,18 +96,23 @@ fn sunday_system(
         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);
-
+        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 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 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);
+        transform.look_at(
+            pos + Vec3::new(-(PI / 4.0).cos(), -sun_angle.sin(), -sun_angle.cos()),
+            Vec3::Y,
+        );
         light.color = color;
         light.illuminance = illuminance;
 
@@ -109,24 +123,25 @@ fn sunday_system(
         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);
+        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;
+        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 {
-        
     }
 }
 
-
-
 fn safe_area_evening_decrease(
-    mut areas : Query<(&mut SafeArea, &LandSafeArea)>,
-    time : Res<Time>,
-    teller : Res<Storyteller>
+    mut areas: Query<(&mut SafeArea, &LandSafeArea)>,
+    time: Res<Time>,
+    teller: Res<Storyteller>,
 ) {
     let uniform_time = teller.get_level_unfirom_time(&time);
     let evening_time = (uniform_time - DAY_TIME) / (EVENING_TIME - DAY_TIME);
@@ -136,12 +151,8 @@ fn safe_area_evening_decrease(
     }
 }
 
-
-fn delete_land_area_at_night(
-    mut commands: Commands,
-    mut areas : Query<Entity, With<LandSafeArea>>,
-) {
+fn delete_land_area_at_night(mut commands: Commands, mut areas: Query<Entity, With<LandSafeArea>>) {
     for entity in areas.iter_mut() {
         commands.entity(entity).despawn_recursive();
     }
-}
\ No newline at end of file
+}
diff --git a/src/test_level.rs b/src/test_level.rs
index 68e6f90..c2851d8 100644
--- a/src/test_level.rs
+++ b/src/test_level.rs
@@ -3,8 +3,15 @@ use rand::prelude::*;
 use std::f32::consts::PI;
 
 use crate::{
-    get_sprite_rotation, level_ui::CreateLevelUi, player::SpawnPlayer, safe_area::{SafeArea, LandSafeArea},
-    sprite_material::create_plane_mesh, torch::SpawnTorch, GameStuff, sunday::{DAY_SUN_COLOR, SUN_BASE_ILLUMINANCE, AMBIENT_BASE_ILLUMINANCE}, shepherd::SpawnShepherd,
+    get_sprite_rotation,
+    level_ui::CreateLevelUi,
+    player::SpawnPlayer,
+    safe_area::{LandSafeArea, SafeArea},
+    shepherd::SpawnShepherd,
+    sprite_material::create_plane_mesh,
+    sunday::{AMBIENT_BASE_ILLUMINANCE, DAY_SUN_COLOR, SUN_BASE_ILLUMINANCE},
+    torch::SpawnTorch,
+    GameStuff,
 };
 
 const TREE_PATH: &str = "test/pine.png";
@@ -18,8 +25,6 @@ impl Default for LevelSize {
     }
 }
 
-
-
 pub fn setup(
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
@@ -120,7 +125,11 @@ pub fn setup(
     let num_of_torchs = 20;
     let torch_r = r / 2.0;
     for _ in 0..num_of_torchs {
-        let pos = Vec3::new(rng.gen_range(-torch_r..torch_r), 0.0, rng.gen_range(-torch_r..torch_r));
+        let pos = Vec3::new(
+            rng.gen_range(-torch_r..torch_r),
+            0.0,
+            rng.gen_range(-torch_r..torch_r),
+        );
 
         spawn_torch.send(SpawnTorch { position: pos });
     }
@@ -132,7 +141,7 @@ pub fn setup(
     commands
         .spawn(safe_area.clone())
         .insert(LandSafeArea {
-            start_area : safe_area.clone()
+            start_area: safe_area.clone(),
         })
         .insert(GameStuff);
 
@@ -140,6 +149,5 @@ pub fn setup(
         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 f4b0c85..fe1ed65 100644
--- a/src/torch.rs
+++ b/src/torch.rs
@@ -1,12 +1,16 @@
 use bevy::prelude::*;
 
-use crate::{common_storage::CommonStorage, get_sprite_rotation, GameStuff, GameSet, safe_area::{SafeArea, HiddenSafeArea}};
+use crate::{
+    common_storage::CommonStorage,
+    get_sprite_rotation,
+    safe_area::{HiddenSafeArea, SafeArea},
+    GameSet, GameStuff,
+};
 
 const TORCH_PATH: &str = "test/torch.png";
 
 const TORCH_ILLUMINATION: f32 = 10000.0;
 
-
 pub struct TorchPlugin;
 
 impl Plugin for TorchPlugin {
@@ -14,7 +18,6 @@ impl Plugin for TorchPlugin {
         app.add_event::<SpawnTorch>()
             .add_systems(Startup, setup_material)
             .add_systems(Update, spawn_torch)
-            
             .add_event::<IgniteTorch>()
             .add_systems(Update, ignite_torch.in_set(GameSet::Playing));
     }
@@ -25,7 +28,7 @@ pub struct TorchLight;
 
 #[derive(Component)]
 pub struct TorchBase {
-    pub light : Entity,
+    pub light: Entity,
     pub lit: bool,
     pub fuel: f32,
     pub color: Color,
@@ -61,29 +64,32 @@ fn spawn_torch(
     torch_material: Res<TorchMaterial>,
 ) {
     for event in events.read() {
-
         let torch_radius = 10.0;
         let smooth_radius = torch_radius + 0.01;
         let light_height = torch_radius * 0.5;
 
         let outer_spot_angle = ((torch_radius / light_height) as f32).atan();
-        let inner_spot_angle =  outer_spot_angle * 0.95;
-
-        let light_id = commands.spawn(SpotLightBundle {
-            spot_light: SpotLight {
-                color: Color::ORANGE,
-                intensity: 0.0,
-                radius: 0.0,
-                range: torch_radius * 10.0,
-                shadows_enabled: false,
-                inner_angle: inner_spot_angle,
-                outer_angle: outer_spot_angle,
+        let inner_spot_angle = outer_spot_angle * 0.95;
+
+        let light_id = commands
+            .spawn(SpotLightBundle {
+                spot_light: SpotLight {
+                    color: Color::ORANGE,
+                    intensity: 0.0,
+                    radius: 0.0,
+                    range: torch_radius * 10.0,
+                    shadows_enabled: false,
+                    inner_angle: inner_spot_angle,
+                    outer_angle: outer_spot_angle,
+                    ..default()
+                },
+                transform: Transform::from_translation(event.position + Vec3::Y * light_height)
+                    .looking_at(event.position, Vec3::Z),
                 ..default()
-            },
-            transform: Transform::from_translation(event.position + Vec3::Y * light_height).looking_at(event.position, Vec3::Z),
-            ..default()
-        }).insert(TorchLight)
-        .insert(GameStuff).id();
+            })
+            .insert(TorchLight)
+            .insert(GameStuff)
+            .id();
 
         let torch = TorchBase {
             lit: false,
@@ -94,19 +100,18 @@ fn spawn_torch(
             light: light_id,
         };
 
-        commands
-            .spawn((
-                torch,
-                PbrBundle {
-                    transform: Transform::from_translation(event.position)
-                        .with_rotation(get_sprite_rotation())
-                        .with_scale(Vec3::new(2.0 / 7.0, 2.0 / 7.0, 2.0)),
-                    material: torch_material.0.clone(),
-                    mesh: common_storage.plane.clone(),
-                    ..default()
-                },
-                GameStuff,
-            ));
+        commands.spawn((
+            torch,
+            PbrBundle {
+                transform: Transform::from_translation(event.position)
+                    .with_rotation(get_sprite_rotation())
+                    .with_scale(Vec3::new(2.0 / 7.0, 2.0 / 7.0, 2.0)),
+                material: torch_material.0.clone(),
+                mesh: common_storage.plane.clone(),
+                ..default()
+            },
+            GameStuff,
+        ));
     }
     events.clear();
 }
@@ -118,10 +123,10 @@ pub struct IgniteTorch {
 }
 
 fn ignite_torch(
-    mut commands : Commands,
+    mut commands: Commands,
     mut events: EventReader<IgniteTorch>,
     mut query: Query<(Entity, &mut TorchBase, &Transform)>,
-    mut lights : Query<&mut SpotLight, With<TorchLight>>
+    mut lights: Query<&mut SpotLight, With<TorchLight>>,
 ) {
     for event in events.read() {
         for (torch_e, mut torch, transform) in &mut query {
@@ -130,13 +135,16 @@ fn ignite_torch(
                 torch.fuel = torch.max_fuel;
                 if let Ok(mut light) = lights.get_mut(torch.light) {
                     light.intensity = TORCH_ILLUMINATION;
-                    commands.entity(torch_e).insert(SafeArea::Circle { 
-                        pos: Vec2::new(transform.translation.x, transform.translation.z), 
-                        radius: torch.radius 
-                    }).insert(HiddenSafeArea);
+                    commands
+                        .entity(torch_e)
+                        .insert(SafeArea::Circle {
+                            pos: Vec2::new(transform.translation.x, transform.translation.z),
+                            radius: torch.radius,
+                        })
+                        .insert(HiddenSafeArea);
                 };
             }
         }
     }
     events.clear();
-}
\ No newline at end of file
+}