From 358f31e9b0bab69292e191614c3279e2b81b0a95 Mon Sep 17 00:00:00 2001
From: Julia Naomi <jnboeira@outlook.com>
Date: Sun, 10 Dec 2023 00:06:02 -0600
Subject: [PATCH] harden-by-multiple-areas

---
 src/global_task/collect_sheep_in_area.rs |  1 +
 src/global_task/mod.rs                   |  8 +--
 src/global_task/sheep_escape.rs          | 75 ++++++++++++---------
 src/global_task/wolf_attack.rs           |  1 +
 src/level_ui.rs                          | 86 ++++++++++++------------
 src/lib.rs                               |  2 +-
 src/physics.rs                           |  2 +-
 src/player.rs                            |  2 +-
 src/safe_area.rs                         | 78 +++++++++++----------
 src/sheep.rs                             | 19 ++----
 src/shepherd.rs                          |  2 +-
 src/storyteller.rs                       | 52 ++++++--------
 src/sunday.rs                            | 39 +++++++++++
 src/test_level.rs                        |  2 +-
 src/torch.rs                             |  1 -
 src/wolf.rs                              |  2 +-
 16 files changed, 204 insertions(+), 168 deletions(-)

diff --git a/src/global_task/collect_sheep_in_area.rs b/src/global_task/collect_sheep_in_area.rs
index e69de29..8b13789 100644
--- a/src/global_task/collect_sheep_in_area.rs
+++ b/src/global_task/collect_sheep_in_area.rs
@@ -0,0 +1 @@
+
diff --git a/src/global_task/mod.rs b/src/global_task/mod.rs
index 8f15d5b..128efc5 100644
--- a/src/global_task/mod.rs
+++ b/src/global_task/mod.rs
@@ -1,5 +1,5 @@
-pub mod sheep_escape;
 pub mod collect_sheep_in_area;
+pub mod sheep_escape;
 pub mod wolf_attack;
 
 use bevy::prelude::*;
@@ -8,8 +8,6 @@ pub struct GlobalTaskPlugin;
 
 impl Plugin for GlobalTaskPlugin {
     fn build(&self, app: &mut App) {
-        app.add_plugins((
-            sheep_escape::SheepEscapePlugin,
-        ));
+        app.add_plugins((sheep_escape::SheepEscapePlugin,));
     }
-}
\ No newline at end of file
+}
diff --git a/src/global_task/sheep_escape.rs b/src/global_task/sheep_escape.rs
index 4d34d85..99976d8 100644
--- a/src/global_task/sheep_escape.rs
+++ b/src/global_task/sheep_escape.rs
@@ -1,22 +1,28 @@
 use bevy::prelude::*;
 use rand::Rng;
 
-use crate::{storyteller::{Storyteller, GlobalTask, FailReason}, sunday::{DayState, EpisodeTime}, sheep::{Sheep, IsScared, GoTo, IdleFeeding, Decision}, player::Dog, test_level::LevelSize, GameSet, GameState, level_ui::TaskText};
+use crate::{
+    level_ui::TaskText,
+    player::Dog,
+    sheep::{Decision, GoTo, IdleFeeding, IsScared, Sheep},
+    storyteller::{FailReason, GlobalTask, Storyteller},
+    sunday::{DayState, EpisodeTime},
+    test_level::LevelSize,
+    GameSet, GameState,
+};
 
 pub struct SheepEscapePlugin;
 
-
 impl Plugin for SheepEscapePlugin {
     fn build(&self, app: &mut App) {
-        app
-            .add_systems(OnEnter(GlobalTask::SheepEscape), generate_new_wave)
-            .add_systems(Update, 
-                (
-                    apply_deferred,
-                    check_wave_finish,
-                    wave_executor,
-            ).chain().run_if(in_state(GlobalTask::SheepEscape)).in_set(GameSet::Playing))
-            
+        app.add_systems(OnEnter(GlobalTask::SheepEscape), generate_new_wave)
+            .add_systems(
+                Update,
+                (apply_deferred, check_wave_finish, wave_executor)
+                    .chain()
+                    .run_if(in_state(GlobalTask::SheepEscape))
+                    .in_set(GameSet::Playing),
+            )
             .init_resource::<NextWave>()
             .init_resource::<SheepWaveStatus>();
     }
@@ -37,23 +43,22 @@ pub struct SheepWave {
 
 #[derive(Resource, Default)]
 pub struct SheepWaveStatus {
-    pub start_count : usize,
-    pub sheep : Vec<Entity>
+    pub start_count: usize,
+    pub sheep: Vec<Entity>,
 }
 
 fn check_wave_finish(
     mut commands: Commands,
-    escapers : Query<Entity, (With<ShawshankRedemption>, With<Sheep>)>,
-    sheep : Query<&Sheep>,
-    mut global_task : ResMut<NextState<GlobalTask>>,
-    mut sheep_wave_status : ResMut<SheepWaveStatus>,
-    mut game_state : ResMut<NextState<GameState>>,
-    next_wave : Res<NextWave>,
-    mut info_texts : Query<&mut Text, With<TaskText>>,
+    escapers: Query<Entity, (With<ShawshankRedemption>, With<Sheep>)>,
+    sheep: Query<&Sheep>,
+    mut global_task: ResMut<NextState<GlobalTask>>,
+    mut sheep_wave_status: ResMut<SheepWaveStatus>,
+    mut game_state: ResMut<NextState<GameState>>,
+    next_wave: Res<NextWave>,
+    mut info_texts: Query<&mut Text, With<TaskText>>,
 ) {
     let loose_limit = (sheep_wave_status.start_count / 2).max(10);
     if escapers.is_empty() && next_wave.0.is_none() && sheep_wave_status.start_count != 0 {
-
         let mut alived_sheep = 0;
         for e in &sheep_wave_status.sheep {
             if sheep.get(*e).is_ok() {
@@ -63,7 +68,9 @@ fn check_wave_finish(
         info!("WAVE FINISHED");
 
         if sheep_wave_status.start_count - alived_sheep > loose_limit {
-            commands.insert_resource(FailReason::TaskFailed("Half of the runaway sheep were eaten :(".to_string()));
+            commands.insert_resource(FailReason::TaskFailed(
+                "Half of the runaway sheep were eaten :(".to_string(),
+            ));
             game_state.set(GameState::Finish);
             global_task.set(GlobalTask::None);
         } else {
@@ -82,22 +89,24 @@ fn check_wave_finish(
         }
     } else if sheep_wave_status.start_count != 0 {
         for mut t in info_texts.iter_mut() {
-            t.sections[0].value = format!("{} sheep are trying to escape! Stop them! Dont lose more than {}", escapers.iter().count(), loose_limit);
+            t.sections[0].value = format!(
+                "{} sheep are trying to escape! Stop them! Dont lose more than {}",
+                escapers.iter().count(),
+                loose_limit
+            );
         }
     }
 }
 
 fn generate_new_wave(
-    mut commands: Commands,
     time: Res<Time>,
     mut next_wave: ResMut<NextWave>,
-    teller : ResMut<Storyteller>,
-    day_state : Res<State<DayState>>,
-    episode_time : Res<EpisodeTime>,
+    teller: ResMut<Storyteller>,
+    day_state: Res<State<DayState>>,
+    episode_time: Res<EpisodeTime>,
     sheep: Query<(Entity, &Transform), (With<Sheep>, Without<IsScared>, Without<GoTo>)>,
 ) {
     let level_time = time.elapsed_seconds() - teller.level_start_time;
-    let unfiorm_time = level_time / teller.level_duration;
 
     let episode_time = episode_time.0;
 
@@ -134,17 +143,17 @@ fn generate_new_wave(
 
 fn wave_executor(
     mut commands: Commands,
-    mut next_wave : ResMut<NextWave>,
-    time : Res<Time>,
+    mut next_wave: ResMut<NextWave>,
+    time: Res<Time>,
     sheep: Query<(Entity, &Transform), (With<Sheep>, Without<IsScared>, Without<GoTo>)>,
     dog: Query<&Transform, With<Dog>>,
     level_size: Res<LevelSize>,
-    mut sheep_wave_status : ResMut<SheepWaveStatus>,
+    mut sheep_wave_status: ResMut<SheepWaveStatus>,
 ) {
     let Ok(dog_transform) = dog.get_single() else {
         return;
     };
-    
+
     if next_wave.0.is_some() {
         let wave = next_wave.0.as_ref().unwrap().clone();
         let cur_time = time.elapsed_seconds();
@@ -192,4 +201,4 @@ fn wave_executor(
             sheep_wave_status.start_count = sheep_wave_status.sheep.len();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/global_task/wolf_attack.rs b/src/global_task/wolf_attack.rs
index e69de29..8b13789 100644
--- a/src/global_task/wolf_attack.rs
+++ b/src/global_task/wolf_attack.rs
@@ -0,0 +1 @@
+
diff --git a/src/level_ui.rs b/src/level_ui.rs
index e7c23bc..f72b232 100644
--- a/src/level_ui.rs
+++ b/src/level_ui.rs
@@ -17,7 +17,6 @@ pub struct CreateLevelUi;
 #[derive(Component)]
 pub struct LevelUi;
 
-
 #[derive(Component)]
 pub struct TaskText;
 
@@ -35,54 +34,53 @@ fn create_level_ui_system(
 
     //Spawn top info bar
     commands
-    .spawn(NodeBundle {
-        style: Style {
-            width: Val::Percent(100.0),
-            height: Val::Px(100.0),
-            justify_content: JustifyContent::Center,
-            align_items: AlignItems::Center,
-            align_self: AlignSelf::Stretch,
-            top: Val::Px(0.0),
-            left: Val::Px(0.0),
-            ..default()
-        },
-        ..default()
-    }).with_children(|parent| {
-        parent.spawn((
-            NodeBundle {
-                style: Style {
-                    width: Val::Percent(50.0),
-                    height: Val::Px(100.0),
-                    flex_direction: FlexDirection::Column,
-                    justify_content: JustifyContent::Center,
-                    align_items: AlignItems::Center,
-
-                    align_self: AlignSelf::Stretch,
-                    ..default()
-                },
-                background_color: BackgroundColor(Color::rgba(0.0, 0.0, 0.0, 0.5)),
+        .spawn(NodeBundle {
+            style: Style {
+                width: Val::Percent(100.0),
+                height: Val::Px(100.0),
+                justify_content: JustifyContent::Center,
+                align_items: AlignItems::Center,
+                align_self: AlignSelf::Stretch,
+                top: Val::Px(0.0),
+                left: Val::Px(0.0),
                 ..default()
             },
-            LevelUi,
-            GameStuff,
-        ))
+            ..default()
+        })
         .with_children(|parent| {
-            parent.spawn((
-                TextBundle::from_section("", text_style.clone()),
-                LevelUi,
-                LevelTimer,
-            ));
+            parent
+                .spawn((
+                    NodeBundle {
+                        style: Style {
+                            width: Val::Percent(50.0),
+                            height: Val::Px(100.0),
+                            flex_direction: FlexDirection::Column,
+                            justify_content: JustifyContent::Center,
+                            align_items: AlignItems::Center,
+
+                            align_self: AlignSelf::Stretch,
+                            ..default()
+                        },
+                        background_color: BackgroundColor(Color::rgba(0.0, 0.0, 0.0, 0.5)),
+                        ..default()
+                    },
+                    LevelUi,
+                    GameStuff,
+                ))
+                .with_children(|parent| {
+                    parent.spawn((
+                        TextBundle::from_section("", text_style.clone()),
+                        LevelUi,
+                        LevelTimer,
+                    ));
 
-            parent.spawn((
-                TextBundle::from_section(
-                    "",
-                    text_style.clone()
-                ),
-                LevelUi,
-                TaskText
-            ));
+                    parent.spawn((
+                        TextBundle::from_section("", text_style.clone()),
+                        LevelUi,
+                        TaskText,
+                    ));
+                });
         });
-    });
 
     ev_create_level_ui.clear();
 }
diff --git a/src/lib.rs b/src/lib.rs
index 63286b6..f10f8e0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,6 +3,7 @@
 pub mod common_storage;
 pub mod debug_diagnostic;
 pub mod finish_screen;
+pub mod global_task;
 pub mod level_ui;
 pub mod menu;
 pub mod physics;
@@ -16,7 +17,6 @@ pub mod sunday;
 pub mod test_level;
 pub mod torch;
 pub mod wolf;
-pub mod global_task;
 
 use std::f32::consts::PI;
 
diff --git a/src/physics.rs b/src/physics.rs
index 9f366a7..a74871f 100644
--- a/src/physics.rs
+++ b/src/physics.rs
@@ -34,7 +34,7 @@ pub struct WalkController {
 }
 
 fn walk_system(time: Res<Time>, mut query: Query<(&mut Velocity, &mut WalkController)>) {
-    for (mut velocity, mut controller) in query.iter_mut() {
+    for (mut velocity, controller) in query.iter_mut() {
         let dspeed = controller.target_velocity - velocity.0;
         let accel = controller.acceleration.min(dspeed.length() * 100.0);
         let cur_vel = velocity.0;
diff --git a/src/player.rs b/src/player.rs
index 95bff8a..095c493 100644
--- a/src/player.rs
+++ b/src/player.rs
@@ -270,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>,
+    _: Query<&CascadeShadowConfig>,
 ) {
     let Ok(player) = player_query.get_single() else {
         return;
diff --git a/src/safe_area.rs b/src/safe_area.rs
index b231daa..6640edc 100644
--- a/src/safe_area.rs
+++ b/src/safe_area.rs
@@ -2,10 +2,10 @@
 
 use std::f32::consts::PI;
 
-use bevy::{prelude::*, transform::commands};
+use bevy::prelude::*;
 use rand::Rng;
 
-use crate::{sheep::Sheep, storyteller::Storyteller};
+use crate::sheep::Sheep;
 
 pub struct SafeAreaPlugin;
 
@@ -22,11 +22,10 @@ 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 },
 }
 
-#[derive(Component)]
+#[derive(Component, Clone)]
 pub struct LandSafeArea {
     pub start_area: SafeArea,
 } //Mark for day safe area
@@ -40,19 +39,32 @@ impl SafeArea {
 
                 dx.abs() < size.x / 2.0 && dy.abs() < size.y / 2.0
             }
-            SafeArea::Ellipse {
-                pos1,
-                pos2,
-                radius: _,
-            } => {
-                let d = (*pos1 - *pos2).length();
-                let r = (*pos1 - sheep_pos).length();
-                r * r <= d * d
-            }
             SafeArea::Circle { pos, radius } => (*pos - sheep_pos).length() < *radius,
         }
     }
 
+    pub fn set_pos(&mut self, mew_pos: Vec2) {
+        match self {
+            SafeArea::Rect { pos, size: _ } => {
+                *pos = mew_pos;
+            }
+            SafeArea::Circle { pos, radius: _ } => {
+                *pos = mew_pos;
+            }
+        }
+    }
+
+    pub fn downscale(&mut self, scale: f32) {
+        match self {
+            SafeArea::Rect { pos: _, size } => {
+                *size = *size / Vec2::new(scale, scale);
+            }
+            SafeArea::Circle { pos: _, radius } => {
+                *radius = *radius / scale;
+            }
+        }
+    }
+
     pub fn get_random_point_inside(&self, level_size: f32) -> Vec3 {
         let mut rng = rand::thread_rng();
         let v2 = (0..)
@@ -72,12 +84,21 @@ impl SafeArea {
     pub fn get_center(&self) -> Vec3 {
         match self {
             SafeArea::Rect { pos, size: _ } => Vec3::new(pos.x, 0.0, pos.y),
-            SafeArea::Ellipse {
-                pos1,
-                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_center_2d(&self) -> Vec2 {
+        match self {
+            SafeArea::Rect { pos, size: _ } => Vec2::new(pos.x, pos.y),
+            SafeArea::Circle { pos, radius: _ } => Vec2::new(pos.x, pos.y),
+        }
+    }
+
+    pub fn get_width(&self) -> f32 {
+        match self {
+            SafeArea::Rect { pos: _, size } => size.x,
+            SafeArea::Circle { pos: _, radius } => *radius,
         }
     }
 
@@ -87,11 +108,6 @@ impl SafeArea {
                 pos: *pos,
                 size: *size * 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,
@@ -111,21 +127,11 @@ fn draw_safe_area(mut gizmos: Gizmos, query: Query<&SafeArea, Without<HiddenSafe
                     Vec3::new(pos.x, 0.001, pos.y),
                     Quat::from_euler(EulerRot::XYZ, PI / 2.0, 0.0, 0.0),
                     *size,
-                    Color::ORANGE,
+                    Color::RED,
                 );
             }
-            SafeArea::Ellipse {
-                pos1: _,
-                pos2: _,
-                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::RED);
             }
         }
     }
diff --git a/src/sheep.rs b/src/sheep.rs
index e1a66b5..8c437fb 100644
--- a/src/sheep.rs
+++ b/src/sheep.rs
@@ -1,19 +1,17 @@
-use std::{
-    f32::consts::{E, PI},
-    time::Duration,
-};
+use std::{f32::consts::PI, time::Duration};
 
 use bevy::prelude::*;
 use rand::{rngs::ThreadRng, Rng};
 
 use crate::{
     get_sprite_rotation,
+    global_task::sheep_escape::ShawshankRedemption,
     physics::{Velocity, WalkController},
     player::{Bark, Dog, DOG_SPEED},
     safe_area::SafeArea,
     sprite_material::create_plane_mesh,
     test_level::LevelSize,
-    GameSet, GameStuff, global_task::sheep_escape::ShawshankRedemption,
+    GameSet, GameStuff,
 };
 
 use bevy_spatial::{
@@ -505,7 +503,7 @@ fn collect_field(
         ),
         With<Sheep>,
     >,
-    mut field: ResMut<NNTree>,
+    field: ResMut<NNTree>,
 ) {
     unsafe {
         for (t, vel, mut walk, _, dec) in sheep.iter_unsafe() {
@@ -547,17 +545,14 @@ 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()
-                        + dist_force.length()
-                        + dz.length();
+                    let wsum = vel.0.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 + dz)
-                        / (wsum + 0.000001)
-                        * max_length;
+                    walk.target_velocity =
+                        (vel.0 + dist_force + dz) / (wsum + 0.000001) * max_length;
                 } else {
                     walk.target_velocity = vel.0;
                 }
diff --git a/src/shepherd.rs b/src/shepherd.rs
index 063d798..7a21266 100644
--- a/src/shepherd.rs
+++ b/src/shepherd.rs
@@ -1,4 +1,4 @@
-use bevy::{prelude::*, reflect::EnumInfo};
+use bevy::prelude::*;
 
 use crate::{
     common_storage::CommonStorage,
diff --git a/src/storyteller.rs b/src/storyteller.rs
index f1cac63..22a024d 100644
--- a/src/storyteller.rs
+++ b/src/storyteller.rs
@@ -1,22 +1,14 @@
 //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::{E, PI},
-    time::Duration,
-};
+use std::time::Duration;
 
 use bevy::prelude::*;
-use rand::Rng;
 
 use crate::{
-    player::{Dog, DOG_SPEED},
-    sheep::{
-        Decision, GoTo, IdleFeeding, IsScared, Sheep, StartSheepCount,
-        RANDOM_WALK_SPEED_MULTIPLIER, SHEEP_SPEED,
-    },
-    sunday::{DayState, EpisodeTime},
-    test_level::LevelSize,
+    player::Dog,
+    sheep::{Sheep, StartSheepCount},
+    sunday::DayState,
     GameSet, GameState,
 };
 
@@ -27,6 +19,7 @@ impl Plugin for StorytellerPlugin {
         app.insert_resource(Storyteller {
             level_start_time: 0.0,
             level_duration: 4.0 * 60.0,
+            safearea_count: 1,
         })
         .init_resource::<Score>()
         .add_systems(
@@ -42,11 +35,11 @@ impl Plugin for StorytellerPlugin {
     }
 }
 
-
 #[derive(Resource)]
 pub struct Storyteller {
     pub level_start_time: f32,
     pub level_duration: f32,
+    pub safearea_count: u8,
 }
 
 impl Storyteller {
@@ -68,43 +61,41 @@ fn setup_start_time(mut commands: Commands, mut teller: ResMut<Storyteller>, tim
 }
 
 fn storyteller_system(
-    mut commands: Commands,
-    sheep: Query<(Entity, &Transform), (With<Sheep>, Without<IsScared>, Without<GoTo>)>,
-    mut teller: ResMut<Storyteller>,
-    time: Res<Time>,
-    level_size: Res<LevelSize>,
+    // mut commands: Commands,
+    // sheep: Query<(Entity, &Transform), (With<Sheep>, Without<IsScared>, Without<GoTo>)>,
+    // mut teller: ResMut<Storyteller>,
+    // time: Res<Time>,
+    // level_size: Res<LevelSize>,
     dog: Query<&Transform, With<Dog>>,
 
     current_task: Res<State<GlobalTask>>,
     mut next_task: ResMut<NextState<GlobalTask>>,
     day_state: Res<State<DayState>>,
-    episode_time: Res<EpisodeTime>,
+    // episode_time: Res<EpisodeTime>,
 ) {
     if *current_task != GlobalTask::None {
         return;
     }
 
-    let Ok(dog_transform) = dog.get_single() else {
+    let Ok(_dog_transform) = dog.get_single() else {
         return;
     };
     if *current_task == GlobalTask::None {
-        let level_time = time.elapsed_seconds() - teller.level_start_time;
-        let unfiorm_time = level_time / teller.level_duration;
+        // let level_time = time.elapsed_seconds() - teller.level_start_time;
+        // let unfiorm_time = level_time / teller.level_duration;
 
-        let episode_time = episode_time.0;
+        // let episode_time = episode_time.0;
 
         match &day_state.get() {
             DayState::Day => {
                 next_task.set(GlobalTask::SheepEscape);
-            },
-            DayState::Evening => {
-
-            },
+            }
+            DayState::Evening => {}
             DayState::Night => {
                 next_task.set(GlobalTask::SheepEscape);
-            },
+            }
         }
-    } 
+    }
 }
 
 #[derive(Component)]
@@ -135,8 +126,7 @@ fn level_timer(
 
 fn score_system(
     mut score: ResMut<Score>,
-    mut alived_sheep: Query<&Sheep>,
-    mut teller: ResMut<Storyteller>,
+    alived_sheep: Query<&Sheep>,
     time: Res<Time>,
     start_sheep_count: Res<StartSheepCount>,
 ) {
diff --git a/src/sunday.rs b/src/sunday.rs
index 60f9626..6fd0084 100644
--- a/src/sunday.rs
+++ b/src/sunday.rs
@@ -1,6 +1,7 @@
 use std::f32::consts::PI;
 
 use bevy::prelude::*;
+use rand::Rng;
 
 use crate::{
     safe_area::{LandSafeArea, SafeArea},
@@ -32,6 +33,8 @@ const DAY_TIME: f32 = 0.3;
 const EVENING_TIME: f32 = 0.6;
 const NIGHT_TIME: f32 = 0.7;
 
+const DAY_TIME_DOWNSCALE: f32 = 2.0;
+
 impl Plugin for SundayPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(Update, sunday_system.in_set(GameSet::Playing));
@@ -47,6 +50,12 @@ impl Plugin for SundayPlugin {
                 .in_set(GameSet::Playing)
                 .run_if(in_state(DayState::Evening)),
         );
+        app.add_systems(
+            Update,
+            safe_area_dayshift
+                .in_set(GameSet::Playing)
+                .run_if(in_state(DayState::Day)),
+        );
         app.add_systems(OnEnter(DayState::Night), delete_land_area_at_night);
 
         app.init_resource::<EpisodeTime>();
@@ -179,6 +188,36 @@ fn safe_area_evening_decrease(
     }
 }
 
+fn safe_area_dayshift(
+    mut commands: Commands,
+    mut areas: Query<(&mut SafeArea, &LandSafeArea)>,
+    mut teller: ResMut<Storyteller>,
+    time: Res<Time>,
+) {
+    let uniform_time = teller.get_level_time(&time);
+    let area_count = teller.safearea_count;
+    if uniform_time > 25. && area_count <= 1 {
+        let mut rng = rand::thread_rng();
+        let pos = rng.gen_range(8..=20) as f32;
+        for (mut area, _) in areas.iter_mut() {
+            let center = area.get_center_2d();
+            let new_safearea = SafeArea::Circle {
+                pos: center + Vec2 { x: -pos, y: -pos },
+                radius: area.get_width() / (2. * DAY_TIME_DOWNSCALE),
+            };
+            commands.spawn((
+                new_safearea.clone(),
+                LandSafeArea {
+                    start_area: new_safearea,
+                },
+            ));
+            area.set_pos(center + Vec2 { x: pos, y: pos });
+            area.downscale(DAY_TIME_DOWNSCALE);
+            teller.safearea_count += 1;
+        }
+    }
+}
+
 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();
diff --git a/src/test_level.rs b/src/test_level.rs
index c2851d8..ba297c8 100644
--- a/src/test_level.rs
+++ b/src/test_level.rs
@@ -141,7 +141,7 @@ pub fn setup(
     commands
         .spawn(safe_area.clone())
         .insert(LandSafeArea {
-            start_area: safe_area.clone(),
+            start_area: safe_area,
         })
         .insert(GameStuff);
 
diff --git a/src/torch.rs b/src/torch.rs
index fe1ed65..cf7aa12 100644
--- a/src/torch.rs
+++ b/src/torch.rs
@@ -65,7 +65,6 @@ fn spawn_torch(
 ) {
     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();
diff --git a/src/wolf.rs b/src/wolf.rs
index eadc16f..d591007 100644
--- a/src/wolf.rs
+++ b/src/wolf.rs
@@ -140,7 +140,7 @@ fn eating_system(
     time: Res<Time>,
     mut wolfs: Query<(Entity, &Transform, &mut Eating, &mut WalkController)>,
 ) {
-    for (wolf, wolf_transform, 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 {
             commands.entity(wolf).remove::<Eating>().insert(GoOut);