From 356ab4713a8d4e1dfdb57a1397b0f092f68dab21 Mon Sep 17 00:00:00 2001
From: Wabtey <wabtey@disroot.org>
Date: Sun, 19 Feb 2023 00:52:26 +0100
Subject: [PATCH 1/3] cleanup warning

---
 src/locations/mod.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/locations/mod.rs b/src/locations/mod.rs
index 49f1e9a..2d6a5b6 100644
--- a/src/locations/mod.rs
+++ b/src/locations/mod.rs
@@ -7,9 +7,9 @@ pub mod sensors;
 
 #[derive(Clone, Eq, PartialEq, Debug, Hash)]
 enum Location {
-    /// The transition universe
-    /// Used when reset a Level
-    Void,
+    // /// The transition universe
+    // /// Used when reset a Level
+    // Void,
     // Start cinematic
     // LevelZero,
     LevelOne,

From be90f00d78fd54273da3cb585fa8ed3aaf079223 Mon Sep 17 00:00:00 2001
From: Wabtey <samurai.banzai@laposte.net>
Date: Fri, 24 Feb 2023 18:16:30 +0100
Subject: [PATCH 2/3] optimize the doors spawn

just a clone of the textureAtlax
instead of a full reload of the same spritesheet
---
 src/locations/level_one/mod.rs | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/src/locations/level_one/mod.rs b/src/locations/level_one/mod.rs
index 078ff6c..eeaf2ae 100644
--- a/src/locations/level_one/mod.rs
+++ b/src/locations/level_one/mod.rs
@@ -221,11 +221,12 @@ fn setup_level_one(
         TextureAtlas::from_grid(horizontal_door, Vec2::new(12., 3.), 1, 7, None, None);
 
     let horizontal_door_atlas_handle = texture_atlases.add(horizontal_door_atlas);
-
+    let horizontal_door_texture_atlas_sprite = TextureAtlasSprite::new(0);
     commands
         .spawn((
             SpriteSheetBundle {
-                texture_atlas: horizontal_door_atlas_handle,
+                texture_atlas: horizontal_door_atlas_handle.clone(),
+                sprite: horizontal_door_texture_atlas_sprite.clone(),
                 transform: Transform {
                     translation: IN_DOOR_POSITION.into(),
                     scale: LEVEL_SCALE.into(),
@@ -269,18 +270,11 @@ fn setup_level_one(
             ));
         });
 
-    // XXX: double load on the same sprite_sheet
-
-    let out_horizontal_door = asset_server.load("textures/level_one/horizontal_door_anim.png");
-    let out_horizontal_door_atlas =
-        TextureAtlas::from_grid(out_horizontal_door, Vec2::new(12., 3.), 1, 7, None, None);
-
-    let out_horizontal_door_atlas_handle = texture_atlases.add(out_horizontal_door_atlas);
-
     commands
         .spawn((
             SpriteSheetBundle {
-                texture_atlas: out_horizontal_door_atlas_handle,
+                texture_atlas: horizontal_door_atlas_handle.clone(),
+                sprite: horizontal_door_texture_atlas_sprite.clone(),
                 transform: Transform {
                     translation: OUT_DOOR_POSITION.into(),
                     scale: LEVEL_SCALE.into(),

From 9a017c056b64aba06be8321a9b7a455d8977b166 Mon Sep 17 00:00:00 2001
From: Wabtey <wabtey@disroot.org>
Date: Sun, 11 Jun 2023 12:27:47 +0200
Subject: [PATCH 3/3] Final Cinematic

- add an End
- fix: daze cured after the daze_timer ended
---
 README.md                         |  11 +-
 src/characters/npcs/movement.rs   |  16 +-
 src/constants.rs                  |  16 +-
 src/locations/cinematics/mod.rs   | 193 ++++++++++++
 src/locations/level_one/button.rs |   4 +-
 src/locations/level_one/mod.rs    | 491 ++++++++++++++++--------------
 src/locations/mod.rs              |  53 +++-
 src/locations/sensors.rs          |  25 +-
 src/main.rs                       |  10 +-
 src/spritesheet.rs                |   8 +-
 src/tablet/mind_control/mod.rs    |   7 +-
 11 files changed, 556 insertions(+), 278 deletions(-)
 create mode 100644 src/locations/cinematics/mod.rs

diff --git a/README.md b/README.md
index 19769f6..d567042 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@ or in the correct release note (if from other version):
 
 ## Rules
 
-***But du jeu*** : Arriver à s’enfuir du Labo
+***But du jeu**- : Arriver à s’enfuir du Labo
 
 ### Binding
 
@@ -24,6 +24,15 @@ or in the correct release note (if from other version):
 - `Left Click` on the button *Hack* to hack doors
 - `Z Q S D` or `W A S D` or `Up Left Down Right` to move
 
+### Future... (lmao)
+
+- [ ] TODO: LevelScene, CinematicScene
+  - [ ] TODO: MustHave - Reset the scene when touched (by an enemy)
+- [ ] TODO: Background + MovingBubbles
+- [x] Final Cinematic
+  - [x] Animations
+  - [x] Black Cat, EasterEgg
+
 ### Level Design
 
 #### Tutorial
diff --git a/src/characters/npcs/movement.rs b/src/characters/npcs/movement.rs
index e916700..d28fef6 100644
--- a/src/characters/npcs/movement.rs
+++ b/src/characters/npcs/movement.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 use bevy_rapier2d::prelude::*;
 
 use crate::{
-    characters::movement::{Dazed, Speed},
+    characters::{effects::style::DazeAnimation, movement::{Dazed, Speed}},
     characters::{npcs::NPC, player::Player},
     constants::character::npc::movement::BLACK_CAT_STARTING_POSITION,
     tablet::mind_control::MindControled,
@@ -239,9 +239,10 @@ pub fn daze_wait(
     mut commands: Commands,
 
     time: Res<Time>,
-    mut npc_query: Query<(Entity, &mut Dazed, &mut Velocity, &Name), (With<NPC>, Without<Player>)>,
+    mut npc_query: Query<(Entity, &mut Dazed, &mut Velocity, &Children, &Name), (With<NPC>, Without<Player>)>,
+    daze_effect_query: Query<Entity, With<DazeAnimation>>,
 ) {
-    for (npc, mut daze_timer, mut _rb_vel, name) in npc_query.iter_mut() {
+    for (npc, mut daze_timer, mut _rb_vel, children, name) in npc_query.iter_mut() {
         daze_timer.timer.tick(time.delta());
 
         // not required to control velocity because it is managed elsewhere
@@ -249,7 +250,16 @@ pub fn daze_wait(
         if daze_timer.timer.finished() {
             info!("{:?}, {} can now aggro", npc, name);
 
+            // REFACTOR: Abstract Daze Cure by event (also in daze_cure_by_mind_control())
             commands.entity(npc).remove::<Dazed>();
+            for child in children {
+                match daze_effect_query.get(*child) {
+                    Err(_) => continue,
+                    Ok(daze_effect) => {
+                        commands.entity(daze_effect).despawn();
+                    }
+                }
+            }
         }
     }
 }
diff --git a/src/constants.rs b/src/constants.rs
index 7cd0743..8938732 100644
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -9,6 +9,8 @@ pub const RESOLUTION: f32 = 16. / 9.;
 
 pub const TILE_SIZE: f32 = 1.;
 
+pub const FRAME_TIME: f32 = 0.1;
+
 pub mod character {
 
     use super::TILE_SIZE;
@@ -49,23 +51,29 @@ pub mod locations {
     pub const LEVEL_Z: f32 = 3.;
     pub const LEVEL_POSITION: (f32, f32, f32) = (0., 0., LEVEL_Z);
     pub const LEVEL_SCALE: (f32, f32, f32) = (-1., 1., 1.);
-
+    
     pub const FLOOR_Z: f32 = 1.;
     pub const FLOOR_POSITION: (f32, f32, f32) = (0., 0., FLOOR_Z);
-
+    
     pub mod level_one {
         use super::LEVEL_Z;
-
+        
         pub const IN_DOOR_POSITION: (f32, f32, f32) = (5., -36., LEVEL_Z);
         pub const ALT_DOOR_POSITION: (f32, f32, f32) = (-2.5, 6., LEVEL_Z);
         pub const OUT_DOOR_POSITION: (f32, f32, f32) = (5., 36., LEVEL_Z);
-
+        
         pub const BUTTON_POSITION: (f32, f32, f32) = (-24., 6., LEVEL_Z - 1.);
         pub const BUTTON_HITBOX_X_OFFSET: (f32, f32, f32) = (3., 0., 0.);
         pub const BUTTON_SENSOR_POSITION: (f32, f32, f32) = (-25.5, 6., LEVEL_Z);
     }
 }
 
+pub mod cinematics {
+    pub const CLOUDS_LIMIT: f32 = -333.;
+    pub const CLOUDS_RESET: f32 = 334.;
+    pub const SECOND_CLOUDS_INIT: f32 = 1001.;
+}
+
 pub mod ui {
     pub mod tablet {
         use bevy::prelude::Color;
diff --git a/src/locations/cinematics/mod.rs b/src/locations/cinematics/mod.rs
new file mode 100644
index 0000000..5afddd9
--- /dev/null
+++ b/src/locations/cinematics/mod.rs
@@ -0,0 +1,193 @@
+//! This is a speedrun to have an cinematic in this game-mockup
+//! Do not use it as example (not a good one at least)
+
+use bevy::prelude::*;
+
+use crate::{
+    characters::npcs::NPC,
+    constants::{FRAME_TIME, locations::LEVEL_SCALE, cinematics::*},
+    tablet::mind_control::MindControled,
+    spritesheet::AnimationTimer,
+};
+
+/* -------------------------------------------------------------------------- */
+/*                                    Final                                   */
+/* -------------------------------------------------------------------------- */
+
+/// Marker for the final cat sprite anim
+#[derive(Component)]
+struct FinalFormCat;
+
+/// Marker for the final cat sprite anim
+#[derive(Component)]
+pub struct Clouds;
+
+#[derive(Component)]
+pub struct PlayerHusk;
+
+pub fn cinematic_camera(
+    mut camera_query: Query<&mut Transform, With<Camera>>,
+) {
+    let mut camera_transform = camera_query.single_mut();
+
+    camera_transform.translation.x = 0.;
+    camera_transform.translation.y = 3.;
+
+    camera_transform.scale = Vec3::new(1.4, 1.4, 1.)
+}
+
+pub fn spawn_cinematic_final(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut texture_atlases: ResMut<Assets<TextureAtlas>>,
+    mut clear_color: ResMut<ClearColor>,
+
+    blue_cat_controlled_query: Query<Entity, (Without<NPC>, With<MindControled>)>,
+) {
+    info!("Spawn Cinematic");
+
+    clear_color.0 = Color::rgb(0.753, 0.126, 0.158);
+
+    commands.spawn((
+        SpriteBundle {
+            texture: asset_server.load("textures/cinematics/final/FullClouds.png"),
+            transform: Transform {
+                translation: Vec3::from((CLOUDS_RESET, 0., 1.)),
+                scale: Vec3::from(LEVEL_SCALE),
+                ..default()
+            },
+            ..default()
+        },
+        Name::new("Cinematics - Clouds"),
+        Clouds,
+        // -- Animation --
+        AnimationTimer(Timer::from_seconds(FRAME_TIME, TimerMode::Repeating)),
+    ));
+
+    commands.spawn((
+        SpriteBundle {
+            texture: asset_server.load("textures/cinematics/final/FullClouds.png"),
+            transform: Transform {
+                translation: Vec3::from((SECOND_CLOUDS_INIT, 0., 1.)),
+                scale: Vec3::from(LEVEL_SCALE),
+                ..default()
+            },
+            ..default()
+        },
+        Name::new("Cinematics - Clouds"),
+        Clouds,
+        // -- Animation --
+        AnimationTimer(Timer::from_seconds(FRAME_TIME, TimerMode::Repeating)),
+    ));
+
+    commands.spawn((
+        SpriteBundle {
+            texture: asset_server.load("textures/cinematics/final/evasion-mountain-lab.png"),
+            transform: Transform {
+                translation: Vec3::from((0., 0., 2.)),
+                scale: Vec3::from(LEVEL_SCALE),
+                ..default()
+            },
+            ..default()
+        },
+        Name::new("Cinematics - Mountain Lab"),
+    ));
+
+    let cat_escape_image = if blue_cat_controlled_query.is_empty() {
+        info!("EasterEgg: Black Cat Escaped");
+        asset_server.load("textures/cinematics/final/black-cat-sheet.png")
+    } else {
+        info!("NormalEnd: Blue Cat Escaped");
+        asset_server.load("textures/cinematics/final/blue-cat-sheet.png")
+    };
+
+    let cat_escape_atlas = TextureAtlas::from_grid(
+        cat_escape_image,
+        Vec2::from((19., 17.)),
+        14,
+        1,
+        None,
+        None,
+    );
+    let cat_escape_atlas_handle = texture_atlases.add(cat_escape_atlas);
+
+    commands.spawn((
+        SpriteSheetBundle {
+            texture_atlas: cat_escape_atlas_handle.clone(),
+            transform: Transform {
+                translation: Vec3::from((12., -12., 9.)),
+                scale: Vec3::from(LEVEL_SCALE),
+                ..default()
+            },
+            ..default()
+        },
+        Name::new("Cinematics - Cat"),
+        PlayerHusk,
+        // -- Animation --
+        AnimationTimer(Timer::from_seconds(FRAME_TIME, TimerMode::Repeating)),
+    ));
+
+    info!("Cinematic Spawned");
+}
+
+// TODO: spawn a Quit button after x seconds
+// TODO: adpat the camera to be centered on the endcinematic
+
+// LEVEL_SCALE
+
+/// Infinitly loop the clouds
+pub fn animate_clouds(
+    time: Res<Time>,
+    mut clouds_query: Query<
+        (
+            &mut AnimationTimer,
+            &mut Transform,
+        ),
+        With<Clouds>,
+    >,
+) {
+    for (mut timer, mut transform) in &mut clouds_query {
+        timer.tick(time.delta());
+
+        if timer.just_finished() {
+            transform.translation.x = 
+            if transform.translation.x == CLOUDS_LIMIT {
+                CLOUDS_RESET
+            } else {
+                // IDEA: can be smoother if - 0.1 and faster timer
+                transform.translation.x - 1.
+            };
+        }
+    }
+}
+
+pub fn animate_free_cat(
+    texture_atlases: Res<Assets<TextureAtlas>>,
+
+    time: Res<Time>,
+    mut running_cat: Query<
+        (
+            &mut AnimationTimer,
+            &mut TextureAtlasSprite,
+            &Handle<TextureAtlas>,
+        ),
+        With<PlayerHusk>,
+    >,
+) {
+    for (mut timer, mut sprite, texture_atlas_handle) in &mut running_cat {
+        timer.tick(time.delta());
+
+        if timer.just_finished() {
+            let texture_atlas = texture_atlases.get(texture_atlas_handle).unwrap();
+
+            sprite.index = if sprite.index + 1 < texture_atlas.textures.len() {
+                sprite.index + 1
+            } else if sprite.index == texture_atlas.textures.len() - 1 {
+                texture_atlas.textures.len() - 2
+            } else {
+                warn!("Overflow CatAnim FinalCinematic");
+                texture_atlas.textures.len() - 2
+            };
+        }
+    }
+}
diff --git a/src/locations/level_one/button.rs b/src/locations/level_one/button.rs
index 3b03f41..1830025 100644
--- a/src/locations/level_one/button.rs
+++ b/src/locations/level_one/button.rs
@@ -12,7 +12,7 @@ use crate::constants::locations::{
 /// Link Doors and Button:
 /// Button { pub linked_doors: Vec<Entity> }
 #[derive(Component)]
-pub struct Button;
+pub struct PushButton;
 
 #[derive(Component)]
 pub struct ButtonSensor;
@@ -48,7 +48,7 @@ pub fn set_up_button(
                 ..default()
             },
             Name::new("OneWay Button"),
-            Button,
+            PushButton,
             RigidBody::Dynamic,
             LockedAxes::ROTATION_LOCKED,
         ))
diff --git a/src/locations/level_one/mod.rs b/src/locations/level_one/mod.rs
index eeaf2ae..f99f9e3 100644
--- a/src/locations/level_one/mod.rs
+++ b/src/locations/level_one/mod.rs
@@ -3,9 +3,13 @@ use bevy_inspector_egui::Inspectable;
 use bevy_rapier2d::prelude::*;
 
 use crate::{
+    characters::{npcs::NPC, player::Player},
     constants::locations::{level_one::*, FLOOR_POSITION, LEVEL_POSITION, LEVEL_SCALE},
     locations::{
-        level_one::doors::{animate_door, open_door_event, Door, ExitDoor, OpenDoorEvent},
+        level_one::{
+            button::PushButton,
+            doors::{animate_door, open_door_event, Door, ExitDoor, OpenDoorEvent}
+        },
         sensors::WinSensor,
         Location,
     },
@@ -22,6 +26,8 @@ use super::sensors::LocationSensor;
 pub mod button;
 pub mod doors;
 
+// TODO: level_one to level_one_thousand
+
 pub struct LevelOnePlugin;
 
 impl Plugin for LevelOnePlugin {
@@ -33,20 +39,20 @@ impl Plugin for LevelOnePlugin {
             // .add_system(reset_level_one)
             // .add_system(enter_level_one)
             .add_system_set(
-                SystemSet::on_enter(Location::LevelOne)
+                SystemSet::on_enter(Location::Level1000)
                     .with_system(setup_level_one)
                     .with_system(set_up_button)
             )
             .add_system_set(
-                SystemSet::on_update(Location::LevelOne)
+                SystemSet::on_update(Location::Level1000)
                     // .with_run_criteria(run_if_in_level_one)
                     .with_system(animate_door)
                     .with_system(open_door_event)
             )
-            // .add_system_set(
-            //     SystemSet::on_exit(Location::LevelOne)
-            //         .with_system(despawn_level_one)
-            // )
+            .add_system_set(
+                SystemSet::on_exit(Location::Level1000)
+                    .with_system(despawn_level_one)
+            )
             ;
     }
 }
@@ -73,7 +79,7 @@ pub struct CharacterLocation(pub LevelOneLocation);
 //     mut enter_level_one_event: EventWriter<EnterLevelOneEvent>,
 // ) {
 //     for _ in reset_level_event.iter() {
-//         if location.current() == &Location::LevelOne {
+//         if location.current() == &Location::Level1000 {
 //             location.set(Location::Void).unwrap();
 //             enter_level_one_event.send(EnterLevelOneEvent);
 //         }
@@ -85,18 +91,32 @@ pub struct CharacterLocation(pub LevelOneLocation);
 //     mut location: ResMut<State<Location>>,
 // ) {
 //     for _ in enter_level_event.iter() {
-//         if location.current() != &Location::LevelOne {
-//             location.set(Location::LevelOne).unwrap();
+//         if location.current() != &Location::Level1000 {
+//             location.set(Location::Level1000).unwrap();
 //         }
 //     }
 // }
 
-// /// XXX: the filter on Name OUCH
-// fn despawn_level_one(mut commands: Commands, query: Query<Entity, With<Name>>) {
-//     for entity in query.iter() {
-//         commands.entity(entity).despawn_recursive();
-//     }
-// }
+/// "despawn"
+fn despawn_level_one(
+    // mut commands: Commands,
+    mut query: Query<
+        (Entity, &mut Visibility, &Name), 
+        Or<(
+            With<Player>,
+            With<NPC>,
+            With<Location>,
+            With<Button>,
+            With<PushButton>
+        )>
+    >
+) {
+    for (_entity, mut visibility, name) in query.iter_mut() {
+        // commands.entity(entity).despawn_recursive();
+        info!("{} is invisible", name);
+        *visibility = Visibility::INVISIBLE;
+    }
+}
 
 fn setup_level_one(
     mut commands: Commands,
@@ -109,243 +129,252 @@ fn setup_level_one(
     let floor = asset_server.load("textures/level_one/lab_floor.png");
 
     commands.spawn((
-        SpriteBundle {
-            texture: floor.clone(),
-            transform: Transform {
-                translation: FLOOR_POSITION.into(),
-                scale: LEVEL_SCALE.into(),
-                ..default()
-            },
-            ..SpriteBundle::default()
-        },
-        RigidBody::Fixed,
-        Name::new("floor"),
-    ));
-
-    commands
-        .spawn((
+        TransformBundle::default(),
+        VisibilityBundle::default(),
+        Location::Level1000,
+        Name::new("LevelOne"),
+    )).with_children(|parent| {
+        parent.spawn((
             SpriteBundle {
-                texture: walls.clone(),
+                texture: floor.clone(),
                 transform: Transform {
-                    translation: LEVEL_POSITION.into(),
+                    translation: FLOOR_POSITION.into(),
                     scale: LEVEL_SCALE.into(),
                     ..default()
                 },
                 ..SpriteBundle::default()
             },
             RigidBody::Fixed,
-            Name::new("walls"),
-        ))
-        .with_children(|parent| {
-            // Collider draw by hand...
-            parent.spawn((
-                Collider::cuboid(21., 1.5),
-                Transform::from_xyz(5., -57., 0.),
-                Name::new("Entry Lower Hitbox"),
-            ));
-            parent.spawn((
-                Collider::cuboid(1.5, 12.),
-                Transform::from_xyz(24.5, -46.5, 0.),
-                Name::new("Entry Left Hitbox"),
-            ));
-            parent.spawn((
-                Collider::cuboid(1.5, 12.),
-                Transform::from_xyz(-14.5, -46.5, 0.),
-                Name::new("Entry Right Hitbox"),
-            ));
-            parent.spawn((
-                Collider::cuboid(7.5, 1.5),
-                Transform::from_xyz(18.5, -36., 0.),
-                Name::new("Entry Top Left Hitbox"),
-            ));
-            parent.spawn((
-                Collider::cuboid(7.5, 1.5),
-                Transform::from_xyz(-8.5, -36., 0.),
-                Name::new("Entry Top Right Hitbox"),
-            ));
-            // --- Corridor ---
-            parent.spawn((
-                Collider::cuboid(1.5, 44.5),
-                Transform::from_xyz(12.5, 10., 0.),
-                Name::new("Corridor Left Hitbox"),
-            ));
-            parent.spawn((
-                Collider::cuboid(1.5, 16.5),
-                Transform::from_xyz(-2.5, -18., 0.),
-                Name::new("Corridor Right Bottom Hitbox"),
-            ));
-            parent.spawn((
-                Collider::cuboid(1.5, 20.5),
-                Transform::from_xyz(-2.5, 34., 0.),
-                Name::new("Corridor Right Top Hitbox"),
-            ));
-            // --- Elevator ---
-            // Which is the two Exit and Front Door
-            parent.spawn((
-                Collider::cuboid(6., 1.5),
-                Transform::from_xyz(5., 53., 0.),
-                Name::new("Elevator Top Hitbox"),
-            ));
-            // --- Broom Closet ---
-            parent.spawn((
-                Collider::cuboid(1.5, 7.5),
-                Transform::from_xyz(-29.5, 6., 0.),
-                Name::new("Closet Left Hitbox"),
-            ));
-            parent.spawn((
-                Collider::cuboid(12., 1.5),
-                Transform::from_xyz(-16., 15., 0.),
-                Name::new("Closet Top Hitbox"),
-            ));
-            parent.spawn((
-                Collider::cuboid(12., 1.5),
-                Transform::from_xyz(-16., -3., 0.),
-                Name::new("Closet Bottom Hitbox"),
-            ));
-            // --- Closet Button Sensor ---
-            parent.spawn((
-                Collider::cuboid(2.5, 3.5),
-                Transform::from_translation(BUTTON_SENSOR_POSITION.into()),
-                ActiveEvents::COLLISION_EVENTS,
-                Sensor,
-                ButtonSensor,
-                // DOC: Better Naming
-                Name::new("OneWay Button Sensor"),
-            ));
-        });
+            Name::new("floor"),
+        ));
+    
+        parent
+            .spawn((
+                SpriteBundle {
+                    texture: walls.clone(),
+                    transform: Transform {
+                        translation: LEVEL_POSITION.into(),
+                        scale: LEVEL_SCALE.into(),
+                        ..default()
+                    },
+                    ..SpriteBundle::default()
+                },
+                RigidBody::Fixed,
+                Name::new("walls"),
+            ))
+            .with_children(|parent| {
+                // Collider draw by hand...
+                parent.spawn((
+                    Collider::cuboid(21., 1.5),
+                    Transform::from_xyz(5., -57., 0.),
+                    Name::new("Entry Lower Hitbox"),
+                ));
+                parent.spawn((
+                    Collider::cuboid(1.5, 12.),
+                    Transform::from_xyz(24.5, -46.5, 0.),
+                    Name::new("Entry Left Hitbox"),
+                ));
+                parent.spawn((
+                    Collider::cuboid(1.5, 12.),
+                    Transform::from_xyz(-14.5, -46.5, 0.),
+                    Name::new("Entry Right Hitbox"),
+                ));
+                parent.spawn((
+                    Collider::cuboid(7.5, 1.5),
+                    Transform::from_xyz(18.5, -36., 0.),
+                    Name::new("Entry Top Left Hitbox"),
+                ));
+                parent.spawn((
+                    Collider::cuboid(7.5, 1.5),
+                    Transform::from_xyz(-8.5, -36., 0.),
+                    Name::new("Entry Top Right Hitbox"),
+                ));
+                // --- Corridor ---
+                parent.spawn((
+                    Collider::cuboid(1.5, 44.5),
+                    Transform::from_xyz(12.5, 10., 0.),
+                    Name::new("Corridor Left Hitbox"),
+                ));
+                parent.spawn((
+                    Collider::cuboid(1.5, 16.5),
+                    Transform::from_xyz(-2.5, -18., 0.),
+                    Name::new("Corridor Right Bottom Hitbox"),
+                ));
+                parent.spawn((
+                    Collider::cuboid(1.5, 20.5),
+                    Transform::from_xyz(-2.5, 34., 0.),
+                    Name::new("Corridor Right Top Hitbox"),
+                ));
+                // --- Elevator ---
+                // Which is the two Exit and Front Door
+                parent.spawn((
+                    Collider::cuboid(6., 1.5),
+                    Transform::from_xyz(5., 53., 0.),
+                    Name::new("Elevator Top Hitbox"),
+                ));
+                // --- Broom Closet ---
+                parent.spawn((
+                    Collider::cuboid(1.5, 7.5),
+                    Transform::from_xyz(-29.5, 6., 0.),
+                    Name::new("Closet Left Hitbox"),
+                ));
+                parent.spawn((
+                    Collider::cuboid(12., 1.5),
+                    Transform::from_xyz(-16., 15., 0.),
+                    Name::new("Closet Top Hitbox"),
+                ));
+                parent.spawn((
+                    Collider::cuboid(12., 1.5),
+                    Transform::from_xyz(-16., -3., 0.),
+                    Name::new("Closet Bottom Hitbox"),
+                ));
+                // --- Closet Button Sensor ---
+                parent.spawn((
+                    Collider::cuboid(2.5, 3.5),
+                    Transform::from_translation(BUTTON_SENSOR_POSITION.into()),
+                    ActiveEvents::COLLISION_EVENTS,
+                    Sensor,
+                    ButtonSensor,
+                    // DOC: Better Naming
+                    Name::new("OneWay Button Sensor"),
+                ));
+            });
+  
 
-    // -- Doors --
+        // -- Doors --
 
-    let horizontal_door = asset_server.load("textures/level_one/horizontal_door_anim.png");
-    let horizontal_door_atlas =
-        TextureAtlas::from_grid(horizontal_door, Vec2::new(12., 3.), 1, 7, None, None);
+        let horizontal_door = asset_server.load("textures/level_one/horizontal_door_anim.png");
+        let horizontal_door_atlas =
+            TextureAtlas::from_grid(horizontal_door, Vec2::new(12., 3.), 1, 7, None, None);
 
-    let horizontal_door_atlas_handle = texture_atlases.add(horizontal_door_atlas);
-    let horizontal_door_texture_atlas_sprite = TextureAtlasSprite::new(0);
-    commands
-        .spawn((
-            SpriteSheetBundle {
-                texture_atlas: horizontal_door_atlas_handle.clone(),
-                sprite: horizontal_door_texture_atlas_sprite.clone(),
-                transform: Transform {
-                    translation: IN_DOOR_POSITION.into(),
-                    scale: LEVEL_SCALE.into(),
+        let horizontal_door_atlas_handle = texture_atlases.add(horizontal_door_atlas);
+        let horizontal_door_texture_atlas_sprite = TextureAtlasSprite::new(0);
+        parent
+            .spawn((
+                SpriteSheetBundle {
+                    texture_atlas: horizontal_door_atlas_handle.clone(),
+                    sprite: horizontal_door_texture_atlas_sprite.clone(),
+                    transform: Transform {
+                        translation: IN_DOOR_POSITION.into(),
+                        scale: LEVEL_SCALE.into(),
+                        ..default()
+                    },
                     ..default()
                 },
-                ..default()
-            },
-            Name::new("Front Door"),
-            Door {
-                current_state: doors::DoorState::Closed,
-            },
-        ))
-        .with_children(|parent| {
-            parent.spawn((
-                Collider::cuboid(6., 1.5),
-                Transform::from_xyz(5., -36., 0.),
-                DoorHitbox,
-                Name::new("Front Door Hitbox"),
-            ));
-            // --- Corridor Sensor ---
-            parent.spawn((
-                Collider::cuboid(6., 3.),
-                Transform::from_xyz(5., -31.5, 0.),
-                ActiveEvents::COLLISION_EVENTS,
-                Sensor,
-                LocationSensor {
-                    location: LevelOneLocation::Corridor,
+                Name::new("Front Door"),
+                Door {
+                    current_state: doors::DoorState::Closed,
                 },
-                Name::new("Corridor Sensor From Spawn"),
-            ));
-            // --- SpawnRoom Sensor ---
-            parent.spawn((
-                Collider::cuboid(6., 3.),
-                Transform::from_xyz(5., -40.5, 0.),
-                ActiveEvents::COLLISION_EVENTS,
-                Sensor,
-                LocationSensor {
-                    location: LevelOneLocation::SpawnRoom,
-                },
-                Name::new("SpawnRoom Sensor"),
-            ));
-        });
+            ))
+            .with_children(|parent| {
+                parent.spawn((
+                    Collider::cuboid(6., 1.5),
+                    Transform::default(), // from_xyz(5., -36., 0.),
+                    DoorHitbox,
+                    Name::new("Front Door Hitbox"),
+                ));
+                // --- Corridor Sensor ---
+                parent.spawn((
+                    Collider::cuboid(6., 3.),
+                    Transform::from_xyz(0., -4.5, 0.),
+                    ActiveEvents::COLLISION_EVENTS,
+                    Sensor,
+                    LocationSensor {
+                        location: LevelOneLocation::Corridor,
+                    },
+                    Name::new("Corridor Sensor From Spawn"),
+                ));
+                // --- SpawnRoom Sensor ---
+                parent.spawn((
+                    Collider::cuboid(6., 3.),
+                    Transform::from_xyz(0., 4.5, 0.),
+                    ActiveEvents::COLLISION_EVENTS,
+                    Sensor,
+                    LocationSensor {
+                        location: LevelOneLocation::SpawnRoom,
+                    },
+                    Name::new("SpawnRoom Sensor"),
+                ));
+            });
 
-    commands
-        .spawn((
-            SpriteSheetBundle {
-                texture_atlas: horizontal_door_atlas_handle.clone(),
-                sprite: horizontal_door_texture_atlas_sprite.clone(),
-                transform: Transform {
-                    translation: OUT_DOOR_POSITION.into(),
-                    scale: LEVEL_SCALE.into(),
+        parent
+            .spawn((
+                SpriteSheetBundle {
+                    texture_atlas: horizontal_door_atlas_handle.clone(),
+                    sprite: horizontal_door_texture_atlas_sprite.clone(),
+                    transform: Transform {
+                        translation: OUT_DOOR_POSITION.into(),
+                        scale: LEVEL_SCALE.into(),
+                        ..default()
+                    },
                     ..default()
                 },
-                ..default()
-            },
-            Name::new("Exit Door"),
-            ExitDoor,
-            Door {
-                current_state: doors::DoorState::Closed,
-            },
-        ))
-        .with_children(|parent| {
-            parent.spawn((
-                Collider::cuboid(6., 1.5),
-                Transform::from_xyz(5., 36., 0.),
-                DoorHitbox,
-                Name::new("Exit Door Hitbox"),
-            ));
-            // --- Win Sensor ---
-            parent.spawn((
-                Collider::segment(Vect::new(9., 48.5), Vect::new(1., 40.5)),
-                Transform::default(),
-                ActiveEvents::COLLISION_EVENTS,
-                Sensor,
-                WinSensor,
-                Name::new("Elevator Sensor"),
-            ));
-            // --- Corridor Sensor ---
-            parent.spawn((
-                Collider::cuboid(6., 3.),
-                Transform::from_xyz(5., 31.5, 0.),
-                ActiveEvents::COLLISION_EVENTS,
-                Sensor,
-                LocationSensor {
-                    location: LevelOneLocation::Corridor,
+                Name::new("Exit Door"),
+                ExitDoor,
+                Door {
+                    current_state: doors::DoorState::Closed,
                 },
-                Name::new("Corridor Sensor From Exit"),
-            ));
-        });
+            ))
+            .with_children(|parent| {
+                parent.spawn((
+                    Collider::cuboid(6., 1.5),
+                    Transform::default(), // from_xyz(5., 36., 0.),
+                    DoorHitbox,
+                    Name::new("Exit Door Hitbox"),
+                ));
+                // --- Win Sensor ---
+                parent.spawn((
+                    Collider::cuboid(4., 4.), // segment(Vect::new(9., 48.5), Vect::new(1., 40.5)),
+                    Transform::from_xyz(0., 8.5, 0.), // default(),
+                    ActiveEvents::COLLISION_EVENTS,
+                    Sensor,
+                    WinSensor,
+                    Name::new("Elevator Sensor"),
+                ));
+                // --- Corridor Sensor ---
+                parent.spawn((
+                    Collider::cuboid(6., 3.),
+                    Transform::from_xyz(0., 4.5, 0.),
+                    ActiveEvents::COLLISION_EVENTS,
+                    Sensor,
+                    LocationSensor {
+                        location: LevelOneLocation::Corridor,
+                    },
+                    Name::new("Corridor Sensor From Exit"),
+                ));
+            });
 
-    let vertical_door = asset_server.load("textures/level_one/vertical_door_anim.png");
-    let vertical_door_atlas =
-        TextureAtlas::from_grid(vertical_door, Vec2::new(3., 15.), 9, 1, None, None);
+        let vertical_door = asset_server.load("textures/level_one/vertical_door_anim.png");
+        let vertical_door_atlas =
+            TextureAtlas::from_grid(vertical_door, Vec2::new(3., 15.), 9, 1, None, None);
 
-    let vertical_door_atlas_handle = texture_atlases.add(vertical_door_atlas);
+        let vertical_door_atlas_handle = texture_atlases.add(vertical_door_atlas);
 
-    commands
-        .spawn((
-            SpriteSheetBundle {
-                texture_atlas: vertical_door_atlas_handle,
-                transform: Transform {
-                    translation: ALT_DOOR_POSITION.into(),
-                    scale: LEVEL_SCALE.into(),
+        parent
+            .spawn((
+                SpriteSheetBundle {
+                    texture_atlas: vertical_door_atlas_handle,
+                    transform: Transform {
+                        translation: ALT_DOOR_POSITION.into(),
+                        scale: LEVEL_SCALE.into(),
+                        ..default()
+                    },
                     ..default()
                 },
-                ..default()
-            },
-            Name::new("Closet Door"),
-            Door {
-                current_state: doors::DoorState::Closed,
-            },
-            Hackable,
-        ))
-        .with_children(|parent| {
-            parent.spawn((
-                Collider::cuboid(1.5, 7.5),
-                Transform::from_xyz(-2.5, 6., 0.),
-                DoorHitbox,
-                Name::new("Side Door Hitbox"),
-            ));
+                Name::new("Closet Door"),
+                Door {
+                    current_state: doors::DoorState::Closed,
+                },
+                Hackable,
+            ))
+            .with_children(|parent| {
+                parent.spawn((
+                    Collider::cuboid(1.5, 7.5),
+                    Transform::default(), // from_xyz(-2.5, 6., 0.),
+                    DoorHitbox,
+                    Name::new("Side Door Hitbox"),
+                ));
+            });
+
         });
 }
diff --git a/src/locations/mod.rs b/src/locations/mod.rs
index 2d6a5b6..13be4a8 100644
--- a/src/locations/mod.rs
+++ b/src/locations/mod.rs
@@ -1,27 +1,37 @@
 use bevy::prelude::*;
 
-use self::sensors::{button_event, location_event, win_event, win_trigger, WinTriggerEvent};
+use self::{
+    cinematics::{
+        animate_clouds,
+        animate_free_cat,
+        cinematic_camera,
+        spawn_cinematic_final,
+    },
+    sensors::{
+        button_event,
+        location_event,
+        win_trigger,
+        win_event,
+        WinTriggerEvent
+    },
+};
 
+pub mod cinematics;
 pub mod level_one;
 pub mod sensors;
 
-#[derive(Clone, Eq, PartialEq, Debug, Hash)]
-enum Location {
+#[derive(Component, Clone, Eq, PartialEq, Debug, Hash)]
+pub enum Location {
     // /// The transition universe
     // /// Used when reset a Level
     // Void,
     // Start cinematic
-    // LevelZero,
+    Level1000,
+    LevelTwo,
     LevelOne,
+    // LevelZero,
     // Exit cinematic
-    // Level1000,
-}
-
-// States
-#[derive(Clone, Eq, PartialEq, Debug, Hash)]
-pub enum PlayerLocation {
-    LevelOne,
-    LevelTwo,
+    OutDoor,
 }
 
 pub struct LocationsPlugin;
@@ -30,13 +40,26 @@ impl Plugin for LocationsPlugin {
     #[rustfmt::skip]
     fn build(&self, app: &mut App) {
         app .add_event::<WinTriggerEvent>()
+
             .add_plugin(level_one::LevelOnePlugin)
-            .add_state(Location::LevelOne)
-            .add_state(PlayerLocation::LevelOne)
-            .add_system(win_event)
+
+            .add_state(Location::Level1000)
+
             .add_system(win_trigger)
+            .add_system(win_event)
             .add_system(location_event)
             .add_system(button_event)
+            
+            .add_system_set(
+                SystemSet::on_enter(Location::OutDoor)
+                    .with_system(spawn_cinematic_final)
+                    .with_system(cinematic_camera)
+            )
+            .add_system_set(
+                SystemSet::on_update(Location::OutDoor)
+                    .with_system(animate_clouds)
+                    .with_system(animate_free_cat)
+            )
             ;
     }
 }
diff --git a/src/locations/sensors.rs b/src/locations/sensors.rs
index 7b99ac3..9e57015 100644
--- a/src/locations/sensors.rs
+++ b/src/locations/sensors.rs
@@ -10,7 +10,7 @@ use crate::{
             doors::{Door, OpenDoorEvent},
             CharacterLocation, LevelOneLocation,
         },
-        PlayerLocation,
+        Location,
     },
     tablet::hack::Hackable,
 };
@@ -34,13 +34,13 @@ pub struct LocationSensor {
 }
 
 /// Enter the elevator to trigger the win
-pub fn win_event(
+pub fn win_trigger(
     mut collision_events: EventReader<CollisionEvent>,
 
     win_sensor_query: Query<Entity, With<WinSensor>>,
     character_hitbox_query: Query<(Entity, &Parent), With<CharacterHitbox>>,
 
-    mut win_trigger_event: EventWriter<WinTriggerEvent>,
+    mut win_event: EventWriter<WinTriggerEvent>,
 ) {
     for collision_event in collision_events.iter() {
         match collision_event {
@@ -54,7 +54,7 @@ pub fn win_event(
                         character_hitbox_query.get(*e2),
                     ) {
                         (Err(_), Ok((_, character))) | (Ok((_, character)), Err(_)) => {
-                            win_trigger_event.send(WinTriggerEvent {
+                            win_event.send(WinTriggerEvent {
                                 entity: **character,
                             });
                         }
@@ -67,13 +67,13 @@ pub fn win_event(
     }
 }
 
-pub fn win_trigger(
-    mut win_trigger_event: EventReader<WinTriggerEvent>,
+pub fn win_event(
+    mut win_event: EventReader<WinTriggerEvent>,
 
     character_query: Query<&Name, Or<(With<Player>, With<NPC>)>>,
-    mut player_location: ResMut<State<PlayerLocation>>,
+    mut location: ResMut<State<Location>>,
 ) {
-    for event in win_trigger_event.iter() {
+    for event in win_event.iter() {
         match character_query.get(event.entity) {
             Err(e) => warn!("The Winner is neither a NPC or a Player... {:?}", e),
             Ok(name) => {
@@ -81,9 +81,10 @@ pub fn win_trigger(
                 println!("{}", congrats);
             }
         }
-        // TODO: 'increment" the level
-        if *player_location.current() == PlayerLocation::LevelOne {
-            player_location.set(PlayerLocation::LevelTwo).unwrap();
+        // TODO: "increment" the level
+        if *location.current() == Location::Level1000 {
+            println!("In LevelOne");
+            location.set(Location::OutDoor).unwrap();
         }
     }
 }
@@ -140,7 +141,7 @@ pub fn location_event(
     }
 }
 
-/// Enter the button to trigger the win
+/// Enter the button to trigger the windoor opening
 pub fn button_event(
     mut collision_events: EventReader<CollisionEvent>,
 
diff --git a/src/main.rs b/src/main.rs
index 2f56632..2c661e2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,7 +4,7 @@ use bevy::{prelude::*, render::camera::ScalingMode};
 use bevy_rapier2d::prelude::*;
 
 use characters::CharactersPlugin;
-use constants::{CLEAR, RESOLUTION, TILE_SIZE};
+use constants::{RESOLUTION, TILE_SIZE};
 use debug::DebugPlugin;
 use locations::LocationsPlugin;
 use spritesheet::CatSpritePlugin;
@@ -21,11 +21,12 @@ pub mod tablet;
 
 #[rustfmt::skip]
 fn main() {
-    let height = 720.;
+    let height = 1080.;
 
     let mut app = App::new();
     app
-        .insert_resource(ClearColor(CLEAR))
+        // Color::TEAL / AZURE
+        .insert_resource(ClearColor(Color::TEAL))
         .insert_resource(Msaa { samples: 1 })
         // v-- Hitbox --v
         .insert_resource(RapierConfiguration {
@@ -40,7 +41,7 @@ fn main() {
                         width: height * RESOLUTION,
                         height,
                         title: "CatBeDoingTheLaundry".to_string(),
-                        resizable: false,
+                        resizable: true,
                         ..default()
                     },
                     ..default()
@@ -73,6 +74,7 @@ fn spawn_camera(mut commands: Commands) {
     camera.projection.left = 50. * TILE_SIZE * RESOLUTION;
     camera.projection.right = -50. * TILE_SIZE * RESOLUTION;
 
+    // vv-- Flip the left and right --vv
     camera.projection.scaling_mode = ScalingMode::None;
 
     commands.spawn(camera);
diff --git a/src/spritesheet.rs b/src/spritesheet.rs
index 66f9ea1..f9d1666 100644
--- a/src/spritesheet.rs
+++ b/src/spritesheet.rs
@@ -49,11 +49,11 @@ pub fn animate_sprite(
             // let texture_atlas = texture_atlases.get(texture_atlas_handle).unwrap();
             // disco cats:
             // sprite.index = (sprite.index + 1) % texture_atlas.textures.len();
-            if state.current == state.initial {
-                sprite.index = sprite.index + 1;
+            sprite.index = if state.current == state.initial {
+                sprite.index + 1
             } else {
-                sprite.index = sprite.index - 1;
-            }
+                sprite.index - 1
+            };
             state.current = sprite.index;
         }
     }
diff --git a/src/tablet/mind_control/mod.rs b/src/tablet/mind_control/mod.rs
index fc08c99..b45f7b5 100644
--- a/src/tablet/mind_control/mod.rs
+++ b/src/tablet/mind_control/mod.rs
@@ -8,6 +8,7 @@ use crate::{
     characters::movement::Dazed,
     characters::{effects::style::DazeAnimation, npcs::NPC, player::Player},
     constants::character::effects::DAZE_TIMER,
+    locations::Location,
     tablet::{
         mind_control::movement::mind_control_movement, run_if_tablet_is_free,
         run_if_tablet_is_mind_ctrl,
@@ -33,7 +34,10 @@ impl Plugin for MindControlPlugin {
                 .with_system(exit_mind_control.label("exit_mind_control").after("enter_mind_control"))
             )
             .add_system(mind_control_movement.label("movement").after("enter_mind_control"))
-            .add_system(camera_follow.after("movement"))
+            .add_system_set(
+                SystemSet::on_update(Location::Level1000)
+                .with_system(camera_follow.after("movement"))
+            )
             .add_system_to_stage(
                 CoreStage::PostUpdate,
                 daze_post_mind_control//.after("exit_mind_control")
@@ -137,7 +141,6 @@ fn daze_cure_by_mind_control(
             match daze_effect_query.get(*child) {
                 Err(_) => continue,
                 Ok(daze_effect) => {
-                    // Only works for player
                     // XXX: don't remove the link to their parent
                     commands.entity(daze_effect).despawn();
                 }