From e4e734c308b899df36d02071ac13f86abba5f7b5 Mon Sep 17 00:00:00 2001
From: Fabien JUIF <fabien.juif@gmail.com>
Date: Fri, 24 Nov 2023 09:11:14 +0100
Subject: [PATCH 1/5] :sparkles: camera / look at

---
 camera/src/lib.rs | 108 ++++++++++++++++++++++++++++++++++++++++------
 src/main.rs       |   4 +-
 2 files changed, 97 insertions(+), 15 deletions(-)

diff --git a/camera/src/lib.rs b/camera/src/lib.rs
index 4fc909d..ed2997f 100644
--- a/camera/src/lib.rs
+++ b/camera/src/lib.rs
@@ -1,13 +1,22 @@
 use bevy::{
     app::{PostStartup, Update},
-    ecs::system::ResMut,
+    asset::Assets,
+    ecs::{
+        bundle::Bundle,
+        component::Component,
+        system::{Commands, Res, ResMut},
+    },
     gizmos::{gizmos::Gizmos, GizmoConfig},
-    math::Vec2,
+    math::{Vec2, Vec3},
     prelude::{
-        App, Bundle, Camera2dBundle, Component, Entity, Plugin, PostUpdate, Query, Transform, With,
-        Without,
+        default, App, Camera2dBundle, Entity, Plugin, PostUpdate, Query, Transform, With, Without,
+    },
+    render::{
+        color::Color,
+        mesh::{shape, Mesh},
     },
-    render::color::Color,
+    sprite::{ColorMaterial, MaterialMesh2dBundle},
+    time::Time,
 };
 
 #[derive(Component)]
@@ -17,17 +26,28 @@ pub struct Target;
 pub struct Camera {
     target: Entity, // TODO: find a way to have multiple targets per camera, but also being able to have multi cameras (n-n)
     dead_zone: Vec2,
+    target_prev_translation: Vec3,
+    // look at this position, this is the player + velocity + factor
+    // it allow us to place the camera a bit ahead of time
+    look_at: Vec3,
 }
 
 impl Camera {
     pub fn new(target: Entity, dead_zone: Vec2) -> Self {
-        Self { target, dead_zone }
+        Self {
+            target,
+            dead_zone,
+            target_prev_translation: Vec3::ZERO,
+            look_at: Vec3::ZERO,
+        }
     }
 
     pub fn new_default(target: Entity) -> Self {
         Self {
             target,
             dead_zone: Vec2::new(30.0, 15.0),
+            target_prev_translation: Vec3::ZERO,
+            look_at: Vec3::ZERO,
         }
     }
 }
@@ -64,10 +84,10 @@ impl Plugin for CameraPlugin {
 }
 
 fn center(
-    mut query_camera: Query<(&mut Transform, &Camera), Without<Target>>,
+    mut query_camera: Query<(&mut Transform, &mut Camera), Without<Target>>,
     query_targets: Query<(&Transform, Entity), With<Target>>,
 ) {
-    for (mut camera_transform, camera) in &mut query_camera {
+    for (mut camera_transform, mut camera) in &mut query_camera {
         for (target_transform, target_entity) in &query_targets {
             if camera.target != target_entity {
                 continue;
@@ -77,6 +97,8 @@ fn center(
             if camera.target == target_entity {
                 camera_transform.translation.x = target_transform.translation.x;
                 camera_transform.translation.y = target_transform.translation.y;
+                camera.target_prev_translation = target_transform.translation;
+                camera.look_at = target_transform.translation;
                 break;
             }
         }
@@ -84,15 +106,23 @@ fn center(
 }
 
 fn cameraman(
-    mut query_camera: Query<(&mut Transform, &Camera), Without<Target>>,
+    mut query_camera: Query<(&mut Transform, &mut Camera), Without<Target>>,
     query_targets: Query<(&Transform, Entity), With<Target>>,
+    time: Res<Time>,
 ) {
-    for (mut camera_transform, camera) in &mut query_camera {
+    for (mut camera_transform, mut camera) in &mut query_camera {
         for (target_transform, target_entity) in &query_targets {
             if camera.target != target_entity {
                 continue;
             }
 
+            // process velocity
+            let target_velocity = (target_transform.translation - camera.target_prev_translation)
+                / time.delta().as_secs_f32();
+            camera.look_at = target_transform.translation + target_velocity;
+            camera.target_prev_translation = target_transform.translation;
+            // TODO: DO SOMETHING ABOUT IT
+
             // TODO: for now we follow the first target but we could think of doing an average positions of all the targets
             if camera.target == target_entity {
                 let diff = camera_transform.translation - target_transform.translation;
@@ -125,23 +155,75 @@ pub struct CameraDebugPlugin;
 
 impl Plugin for CameraDebugPlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(Update, debug);
+        app.add_systems(PostStartup, setup_debug)
+            .add_systems(Update, debug);
+    }
+}
+
+#[derive(Component)]
+pub struct CameraDebug(Entity);
+
+fn setup_debug(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+    query_cameras: Query<(&Transform, &Camera, Entity)>,
+) {
+    for (camera_transform, _camera, entity) in &query_cameras {
+        commands.spawn((
+            MaterialMesh2dBundle {
+                mesh: meshes.add(shape::Circle::new(2.).into()).into(),
+                material: materials.add(ColorMaterial::from(Color::GREEN)),
+                transform: Transform::from_translation(Vec3::new(
+                    camera_transform.translation.x,
+                    camera_transform.translation.y,
+                    100.0,
+                )),
+                ..default()
+            },
+            CameraDebug(entity),
+        ));
     }
 }
 
+#[allow(clippy::type_complexity)] // Because of query_targets
 fn debug(
     mut gizmos: Gizmos,
     mut config: ResMut<GizmoConfig>,
-    query_cameras: Query<(&Transform, &Camera)>,
+    query_cameras: Query<(&Transform, &Camera, Entity)>,
+    query_targets: Query<(&Transform, Entity), (With<Target>, Without<CameraDebug>)>,
+    mut query_camera_debug: Query<(&mut Transform, &CameraDebug), Without<Camera>>,
 ) {
     config.line_width = 1.0;
 
-    for (camera_transform, camera) in &query_cameras {
+    // TODO: Unspawn camera debug object if camera do not exist anymore
+
+    for (camera_transform, camera, entity) in &query_cameras {
         gizmos.rect_2d(
             camera_transform.translation.truncate(),
             0.,
             camera.dead_zone * 2.0,
             Color::RED,
         );
+
+        for (target_transform, target_entity) in &query_targets {
+            if camera.target != target_entity {
+                continue;
+            }
+
+            gizmos.line_2d(
+                target_transform.translation.truncate(),
+                camera.look_at.truncate(),
+                Color::GREEN,
+            );
+        }
+
+        for (mut transform, camera_debug) in &mut query_camera_debug {
+            if camera_debug.0 != entity {
+                continue;
+            }
+            transform.translation.x = camera.look_at.x;
+            transform.translation.y = camera.look_at.y;
+        }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 9964c81..5bb466e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,7 +12,7 @@ use bevy::{
     prelude::*,
     DefaultPlugins,
 };
-use bevy_camera::CameraPlugin;
+use bevy_camera::{CameraDebugPlugin, CameraPlugin};
 use bevy_rapier2d::prelude::*;
 use castles::CastlesPlugin;
 use health::HealthPlugin;
@@ -42,7 +42,7 @@ fn main() {
     // --- camera ---
     .add_plugins((
         CameraPlugin,
-        // CameraDebugPlugin,
+        CameraDebugPlugin,
     ))
     // --- physics ---
     .add_plugins((

From 083f0be5d2dcf21c1b5003c060939a23971e58bb Mon Sep 17 00:00:00 2001
From: Fabien JUIF <fabien.juif@gmail.com>
Date: Fri, 24 Nov 2023 09:41:26 +0100
Subject: [PATCH 2/5] wip

---
 camera/src/lib.rs | 67 +++++++++++++++++++++++++----------------------
 src/player.rs     |  5 +++-
 2 files changed, 40 insertions(+), 32 deletions(-)

diff --git a/camera/src/lib.rs b/camera/src/lib.rs
index ed2997f..71730f9 100644
--- a/camera/src/lib.rs
+++ b/camera/src/lib.rs
@@ -30,15 +30,17 @@ pub struct Camera {
     // look at this position, this is the player + velocity + factor
     // it allow us to place the camera a bit ahead of time
     look_at: Vec3,
+    ahead_factor: Vec3,
 }
 
 impl Camera {
-    pub fn new(target: Entity, dead_zone: Vec2) -> Self {
+    pub fn new(target: Entity, dead_zone: Vec2, ahead_factor: Vec3) -> Self {
         Self {
             target,
             dead_zone,
             target_prev_translation: Vec3::ZERO,
             look_at: Vec3::ZERO,
+            ahead_factor,
         }
     }
 
@@ -48,6 +50,7 @@ impl Camera {
             dead_zone: Vec2::new(30.0, 15.0),
             target_prev_translation: Vec3::ZERO,
             look_at: Vec3::ZERO,
+            ahead_factor: Vec3::ONE,
         }
     }
 }
@@ -59,11 +62,8 @@ pub struct CameraBundle {
 }
 
 impl CameraBundle {
-    pub fn new(target: Entity, bundle: Camera2dBundle) -> Self {
-        Self {
-            camera: Camera::new_default(target),
-            bundle,
-        }
+    pub fn new(camera: Camera, bundle: Camera2dBundle) -> Self {
+        Self { camera, bundle }
     }
 
     pub fn new_with_default_bundle(target: Entity) -> Self {
@@ -119,34 +119,39 @@ fn cameraman(
             // process velocity
             let target_velocity = (target_transform.translation - camera.target_prev_translation)
                 / time.delta().as_secs_f32();
-            camera.look_at = target_transform.translation + target_velocity;
+            camera.look_at = target_transform.translation + (target_velocity * camera.ahead_factor);
+            // FIXME: SHOULD NOT BE HERE THIS IS FOR TESTING PURPOSE
+            if (target_transform.translation - camera.target_prev_translation) != Vec3::ZERO {
+                camera_transform.translation.x = camera.look_at.x;
+                camera_transform.translation.y = camera.look_at.y;
+            }
             camera.target_prev_translation = target_transform.translation;
-            // TODO: DO SOMETHING ABOUT IT
 
             // TODO: for now we follow the first target but we could think of doing an average positions of all the targets
-            if camera.target == target_entity {
-                let diff = camera_transform.translation - target_transform.translation;
-                let diff_abs = diff.abs();
-
-                if diff_abs.x > camera.dead_zone.x {
-                    camera_transform.translation.x = target_transform.translation.x
-                        - if diff.x > 0. {
-                            -camera.dead_zone.x
-                        } else {
-                            camera.dead_zone.x
-                        };
-                }
-                if diff_abs.y > camera.dead_zone.y {
-                    camera_transform.translation.y = target_transform.translation.y
-                        - if diff.y > 0. {
-                            -camera.dead_zone.y
-                        } else {
-                            camera.dead_zone.y
-                        };
-                }
-
-                break;
-            }
+            // FIXME: put back dead zone
+            // if camera.target == target_entity {
+            //     let diff = camera_transform.translation - target_transform.translation;
+            //     let diff_abs = diff.abs();
+
+            //     if diff_abs.x > camera.dead_zone.x {
+            //         camera_transform.translation.x = target_transform.translation.x
+            //             - if diff.x > 0. {
+            //                 -camera.dead_zone.x
+            //             } else {
+            //                 camera.dead_zone.x
+            //             };
+            //     }
+            //     if diff_abs.y > camera.dead_zone.y {
+            //         camera_transform.translation.y = target_transform.translation.y
+            //             - if diff.y > 0. {
+            //                 -camera.dead_zone.y
+            //             } else {
+            //                 camera.dead_zone.y
+            //             };
+            //     }
+
+            //     break;
+            // }
         }
     }
 }
diff --git a/src/player.rs b/src/player.rs
index dd38985..de834b9 100644
--- a/src/player.rs
+++ b/src/player.rs
@@ -159,7 +159,10 @@ fn setup(
         })
         .id();
 
-    commands.spawn(CameraBundle::new_with_default_bundle(entity));
+    commands.spawn(CameraBundle::new(
+        Camera::new(entity, Vec2::new(50.0, 20.0), Vec3::ONE * 0.66),
+        Camera2dBundle::default(),
+    ));
 }
 
 fn setup_ui(mut commands: Commands, asset_server: Res<AssetServer>) {

From 246ee5891340c4b061dd58529dc0c7ba057694aa Mon Sep 17 00:00:00 2001
From: Fabien JUIF <fabien.juif@gmail.com>
Date: Fri, 24 Nov 2023 14:09:13 +0100
Subject: [PATCH 3/5] wip

---
 camera/src/lib.rs | 54 +++++++++++++++++++----------------------------
 src/player.rs     |  2 +-
 2 files changed, 23 insertions(+), 33 deletions(-)

diff --git a/camera/src/lib.rs b/camera/src/lib.rs
index 71730f9..45771ff 100644
--- a/camera/src/lib.rs
+++ b/camera/src/lib.rs
@@ -31,6 +31,7 @@ pub struct Camera {
     // it allow us to place the camera a bit ahead of time
     look_at: Vec3,
     ahead_factor: Vec3,
+    moving: bool,
 }
 
 impl Camera {
@@ -41,6 +42,7 @@ impl Camera {
             target_prev_translation: Vec3::ZERO,
             look_at: Vec3::ZERO,
             ahead_factor,
+            moving: false,
         }
     }
 
@@ -51,6 +53,7 @@ impl Camera {
             target_prev_translation: Vec3::ZERO,
             look_at: Vec3::ZERO,
             ahead_factor: Vec3::ONE,
+            moving: false,
         }
     }
 }
@@ -117,41 +120,28 @@ fn cameraman(
             }
 
             // process velocity
-            let target_velocity = (target_transform.translation - camera.target_prev_translation)
-                / time.delta().as_secs_f32();
-            camera.look_at = target_transform.translation + (target_velocity * camera.ahead_factor);
-            // FIXME: SHOULD NOT BE HERE THIS IS FOR TESTING PURPOSE
-            if (target_transform.translation - camera.target_prev_translation) != Vec3::ZERO {
-                camera_transform.translation.x = camera.look_at.x;
-                camera_transform.translation.y = camera.look_at.y;
+            let mut target_velocity = target_transform.translation - camera.target_prev_translation;
+            if target_velocity != Vec3::ZERO {
+                target_velocity /= time.delta_seconds()
             }
+            camera.look_at = target_transform.translation + (target_velocity * camera.ahead_factor);
             camera.target_prev_translation = target_transform.translation;
 
-            // TODO: for now we follow the first target but we could think of doing an average positions of all the targets
-            // FIXME: put back dead zone
-            // if camera.target == target_entity {
-            //     let diff = camera_transform.translation - target_transform.translation;
-            //     let diff_abs = diff.abs();
-
-            //     if diff_abs.x > camera.dead_zone.x {
-            //         camera_transform.translation.x = target_transform.translation.x
-            //             - if diff.x > 0. {
-            //                 -camera.dead_zone.x
-            //             } else {
-            //                 camera.dead_zone.x
-            //             };
-            //     }
-            //     if diff_abs.y > camera.dead_zone.y {
-            //         camera_transform.translation.y = target_transform.translation.y
-            //             - if diff.y > 0. {
-            //                 -camera.dead_zone.y
-            //             } else {
-            //                 camera.dead_zone.y
-            //             };
-            //     }
-
-            //     break;
-            // }
+            // if the target is in the dead zone, do nothing on camera
+            let diff = camera_transform.translation - target_transform.translation;
+            let diff_abs = diff.abs();
+            if !camera.moving
+                && diff_abs.x <= camera.dead_zone.x
+                && diff_abs.y <= camera.dead_zone.y
+            {
+                break;
+            }
+
+            // moving camera
+            camera.moving = target_velocity != Vec3::ZERO;
+            let next_pos = (camera.look_at - camera_transform.translation) * 0.02;
+            camera_transform.translation.x += next_pos.x;
+            camera_transform.translation.y += next_pos.y;
         }
     }
 }
diff --git a/src/player.rs b/src/player.rs
index bf5bcb4..d15cb0e 100644
--- a/src/player.rs
+++ b/src/player.rs
@@ -160,7 +160,7 @@ fn setup(
         .id();
 
     commands.spawn(CameraBundle::new(
-        Camera::new(entity, Vec2::new(50.0, 20.0), Vec3::ONE * 0.66),
+        Camera::new(entity, Vec2::new(50.0, 20.0), Vec3::ONE * 0.8),
         Camera2dBundle::default(),
     ));
 }

From f4543d1c6bcef2426974bae090a7ca8ce17324c8 Mon Sep 17 00:00:00 2001
From: Fabien JUIF <fabien.juif@gmail.com>
Date: Fri, 24 Nov 2023 15:14:00 +0100
Subject: [PATCH 4/5] working cam / physics need to be debugged

---
 camera/src/lib.rs |  67 ++++++++++++++++++----------
 src/main.rs       |   2 +-
 src/physics.rs    | 108 +++++++++++++++++++++++-----------------------
 3 files changed, 100 insertions(+), 77 deletions(-)

diff --git a/camera/src/lib.rs b/camera/src/lib.rs
index 45771ff..94b2544 100644
--- a/camera/src/lib.rs
+++ b/camera/src/lib.rs
@@ -7,16 +7,17 @@ use bevy::{
         system::{Commands, Res, ResMut},
     },
     gizmos::{gizmos::Gizmos, GizmoConfig},
-    math::{Vec2, Vec3},
+    log::{debug, warn},
+    math::{self, Vec2, Vec3},
     prelude::{
-        default, App, Camera2dBundle, Entity, Plugin, PostUpdate, Query, Transform, With, Without,
+        default, App, Camera2dBundle, Entity, Plugin, PostUpdate, Query, Time, Timer, TimerMode,
+        Transform, With, Without,
     },
     render::{
         color::Color,
         mesh::{shape, Mesh},
     },
     sprite::{ColorMaterial, MaterialMesh2dBundle},
-    time::Time,
 };
 
 #[derive(Component)]
@@ -31,7 +32,8 @@ pub struct Camera {
     // it allow us to place the camera a bit ahead of time
     look_at: Vec3,
     ahead_factor: Vec3,
-    moving: bool,
+    traveling: bool,
+    center_after: Timer,
 }
 
 impl Camera {
@@ -42,7 +44,8 @@ impl Camera {
             target_prev_translation: Vec3::ZERO,
             look_at: Vec3::ZERO,
             ahead_factor,
-            moving: false,
+            traveling: false,
+            center_after: Timer::from_seconds(0.4, TimerMode::Once),
         }
     }
 
@@ -53,7 +56,8 @@ impl Camera {
             target_prev_translation: Vec3::ZERO,
             look_at: Vec3::ZERO,
             ahead_factor: Vec3::ONE,
-            moving: false,
+            traveling: false,
+            center_after: Timer::from_seconds(0.4, TimerMode::Once),
         }
     }
 }
@@ -119,29 +123,48 @@ fn cameraman(
                 continue;
             }
 
-            // process velocity
+            // process target velocity
             let mut target_velocity = target_transform.translation - camera.target_prev_translation;
-            if target_velocity != Vec3::ZERO {
-                target_velocity /= time.delta_seconds()
+            let target_moving = target_velocity != Vec3::ZERO;
+            if target_moving {
+                target_velocity /= time.delta_seconds();
             }
             camera.look_at = target_transform.translation + (target_velocity * camera.ahead_factor);
             camera.target_prev_translation = target_transform.translation;
 
-            // if the target is in the dead zone, do nothing on camera
-            let diff = camera_transform.translation - target_transform.translation;
-            let diff_abs = diff.abs();
-            if !camera.moving
-                && diff_abs.x <= camera.dead_zone.x
-                && diff_abs.y <= camera.dead_zone.y
-            {
-                break;
+            // process dead zone
+            let diff_pos_abs = (target_transform.translation - camera_transform.translation)
+                .truncate()
+                .abs();
+            let dead_zone =
+                diff_pos_abs.x <= camera.dead_zone.x && diff_pos_abs.y <= camera.dead_zone.y;
+            let centered = diff_pos_abs.x < 3.0 && diff_pos_abs.y < 3.0;
+
+            // center after some time in the dead zone
+            if dead_zone && !centered && !target_moving && !camera.traveling {
+                camera.center_after.tick(time.delta());
+            } else {
+                camera.center_after.reset();
+            }
+
+            // triggers travelling if we are out of dead zone
+            if !dead_zone {
+                camera.traveling = true;
             }
 
-            // moving camera
-            camera.moving = target_velocity != Vec3::ZERO;
-            let next_pos = (camera.look_at - camera_transform.translation) * 0.02;
-            camera_transform.translation.x += next_pos.x;
-            camera_transform.translation.y += next_pos.y;
+            // once the camera is moving we keep moving until we reach the center
+            if camera.traveling || camera.center_after.finished() {
+                let next_pos = camera.look_at - camera_transform.translation;
+                camera_transform.translation.x += next_pos.x * 0.02;
+                camera_transform.translation.y += next_pos.y * 0.02;
+
+                // we arrived
+                if centered && !target_moving {
+                    camera.traveling = false;
+                }
+            }
+
+            // if the target is in the dead zone, do nothing on camera
         }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 5bb466e..63c7756 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -42,7 +42,7 @@ fn main() {
     // --- camera ---
     .add_plugins((
         CameraPlugin,
-        CameraDebugPlugin,
+        // CameraDebugPlugin,
     ))
     // --- physics ---
     .add_plugins((
diff --git a/src/physics.rs b/src/physics.rs
index 43c499c..d5b06b0 100644
--- a/src/physics.rs
+++ b/src/physics.rs
@@ -87,58 +87,58 @@ fn check_collisions(
     mut event_writer: EventWriter<CollisionEvent>,
     query: Query<Entity>,
 ) {
-    let mut before = collisions.clone();
-    let mut events = Vec::<CollisionEvent>::new();
-
-    // first pass detects intersections
-    for (e1, e2, _) in rapier_context.intersection_pairs() {
-        if !query.contains(e1) || !query.contains(e2) {
-            // entity are removed from ECS
-            // so we are not spawning events for them
-            // they will be removed in last loop
-            continue;
-        }
-
-        let pair = EntityPair::new(e1, e2);
-        before.remove(&pair);
-        if collisions.contains(&pair) {
-            // we already have a started event for this intersection
-            continue;
-        }
-
-        collisions.add(pair);
-        events.push(CollisionEvent::Started(pair.entity1, pair.entity2));
-    }
-
-    // second pass detects contacts
-    for c in rapier_context.contact_pairs() {
-        let e1 = c.collider1();
-        let e2 = c.collider2();
-
-        if !query.contains(e1) || !query.contains(e2) {
-            // entity are removed from ECS
-            // so we are not spawning events for them
-            // they will be removed in last loop
-            continue;
-        }
-
-        let pair = EntityPair::new(e1, e2);
-        before.remove(&pair);
-        if collisions.contains(&pair) {
-            // we already have a started event for this intersection
-            continue;
-        }
-
-        collisions.add(pair);
-        events.push(CollisionEvent::Started(e1, e2));
-    }
-
-    // emit ended collisions
-    // TODO: implement iter() that return an iterator on the collisions struct
-    for (pair, _) in before.pairs {
-        collisions.remove(&pair);
-        events.push(CollisionEvent::Stopped(pair.entity1, pair.entity2));
-    }
-
-    event_writer.send_batch(events);
+    // let mut before = collisions.clone();
+    // let mut events = Vec::<CollisionEvent>::new();
+
+    // // first pass detects intersections
+    // for (e1, e2, _) in rapier_context.intersection_pairs() {
+    //     if !query.contains(e1) || !query.contains(e2) {
+    //         // entity are removed from ECS
+    //         // so we are not spawning events for them
+    //         // they will be removed in last loop
+    //         continue;
+    //     }
+
+    //     let pair = EntityPair::new(e1, e2);
+    //     before.remove(&pair);
+    //     if collisions.contains(&pair) {
+    //         // we already have a started event for this intersection
+    //         continue;
+    //     }
+
+    //     collisions.add(pair);
+    //     events.push(CollisionEvent::Started(pair.entity1, pair.entity2));
+    // }
+
+    // // second pass detects contacts
+    // for c in rapier_context.contact_pairs() {
+    //     let e1 = c.collider1();
+    //     let e2 = c.collider2();
+
+    //     if !query.contains(e1) || !query.contains(e2) {
+    //         // entity are removed from ECS
+    //         // so we are not spawning events for them
+    //         // they will be removed in last loop
+    //         continue;
+    //     }
+
+    //     let pair = EntityPair::new(e1, e2);
+    //     before.remove(&pair);
+    //     if collisions.contains(&pair) {
+    //         // we already have a started event for this intersection
+    //         continue;
+    //     }
+
+    //     collisions.add(pair);
+    //     events.push(CollisionEvent::Started(e1, e2));
+    // }
+
+    // // emit ended collisions
+    // // TODO: implement iter() that return an iterator on the collisions struct
+    // for (pair, _) in before.pairs {
+    //     collisions.remove(&pair);
+    //     events.push(CollisionEvent::Stopped(pair.entity1, pair.entity2));
+    // }
+
+    // event_writer.send_batch(events);
 }

From 9b55fafa02a176eed45eae91189027a7ac9b4278 Mon Sep 17 00:00:00 2001
From: Fabien JUIF <fabien.juif@gmail.com>
Date: Fri, 24 Nov 2023 17:54:51 +0100
Subject: [PATCH 5/5] put back physics & clippy

---
 camera/src/lib.rs |   3 +-
 src/main.rs       |   2 +-
 src/physics.rs    | 108 +++++++++++++++++++++++-----------------------
 3 files changed, 56 insertions(+), 57 deletions(-)

diff --git a/camera/src/lib.rs b/camera/src/lib.rs
index 94b2544..97f1198 100644
--- a/camera/src/lib.rs
+++ b/camera/src/lib.rs
@@ -7,8 +7,7 @@ use bevy::{
         system::{Commands, Res, ResMut},
     },
     gizmos::{gizmos::Gizmos, GizmoConfig},
-    log::{debug, warn},
-    math::{self, Vec2, Vec3},
+    math::{Vec2, Vec3},
     prelude::{
         default, App, Camera2dBundle, Entity, Plugin, PostUpdate, Query, Time, Timer, TimerMode,
         Transform, With, Without,
diff --git a/src/main.rs b/src/main.rs
index 63c7756..9964c81 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,7 +12,7 @@ use bevy::{
     prelude::*,
     DefaultPlugins,
 };
-use bevy_camera::{CameraDebugPlugin, CameraPlugin};
+use bevy_camera::CameraPlugin;
 use bevy_rapier2d::prelude::*;
 use castles::CastlesPlugin;
 use health::HealthPlugin;
diff --git a/src/physics.rs b/src/physics.rs
index d5b06b0..43c499c 100644
--- a/src/physics.rs
+++ b/src/physics.rs
@@ -87,58 +87,58 @@ fn check_collisions(
     mut event_writer: EventWriter<CollisionEvent>,
     query: Query<Entity>,
 ) {
-    // let mut before = collisions.clone();
-    // let mut events = Vec::<CollisionEvent>::new();
-
-    // // first pass detects intersections
-    // for (e1, e2, _) in rapier_context.intersection_pairs() {
-    //     if !query.contains(e1) || !query.contains(e2) {
-    //         // entity are removed from ECS
-    //         // so we are not spawning events for them
-    //         // they will be removed in last loop
-    //         continue;
-    //     }
-
-    //     let pair = EntityPair::new(e1, e2);
-    //     before.remove(&pair);
-    //     if collisions.contains(&pair) {
-    //         // we already have a started event for this intersection
-    //         continue;
-    //     }
-
-    //     collisions.add(pair);
-    //     events.push(CollisionEvent::Started(pair.entity1, pair.entity2));
-    // }
-
-    // // second pass detects contacts
-    // for c in rapier_context.contact_pairs() {
-    //     let e1 = c.collider1();
-    //     let e2 = c.collider2();
-
-    //     if !query.contains(e1) || !query.contains(e2) {
-    //         // entity are removed from ECS
-    //         // so we are not spawning events for them
-    //         // they will be removed in last loop
-    //         continue;
-    //     }
-
-    //     let pair = EntityPair::new(e1, e2);
-    //     before.remove(&pair);
-    //     if collisions.contains(&pair) {
-    //         // we already have a started event for this intersection
-    //         continue;
-    //     }
-
-    //     collisions.add(pair);
-    //     events.push(CollisionEvent::Started(e1, e2));
-    // }
-
-    // // emit ended collisions
-    // // TODO: implement iter() that return an iterator on the collisions struct
-    // for (pair, _) in before.pairs {
-    //     collisions.remove(&pair);
-    //     events.push(CollisionEvent::Stopped(pair.entity1, pair.entity2));
-    // }
-
-    // event_writer.send_batch(events);
+    let mut before = collisions.clone();
+    let mut events = Vec::<CollisionEvent>::new();
+
+    // first pass detects intersections
+    for (e1, e2, _) in rapier_context.intersection_pairs() {
+        if !query.contains(e1) || !query.contains(e2) {
+            // entity are removed from ECS
+            // so we are not spawning events for them
+            // they will be removed in last loop
+            continue;
+        }
+
+        let pair = EntityPair::new(e1, e2);
+        before.remove(&pair);
+        if collisions.contains(&pair) {
+            // we already have a started event for this intersection
+            continue;
+        }
+
+        collisions.add(pair);
+        events.push(CollisionEvent::Started(pair.entity1, pair.entity2));
+    }
+
+    // second pass detects contacts
+    for c in rapier_context.contact_pairs() {
+        let e1 = c.collider1();
+        let e2 = c.collider2();
+
+        if !query.contains(e1) || !query.contains(e2) {
+            // entity are removed from ECS
+            // so we are not spawning events for them
+            // they will be removed in last loop
+            continue;
+        }
+
+        let pair = EntityPair::new(e1, e2);
+        before.remove(&pair);
+        if collisions.contains(&pair) {
+            // we already have a started event for this intersection
+            continue;
+        }
+
+        collisions.add(pair);
+        events.push(CollisionEvent::Started(e1, e2));
+    }
+
+    // emit ended collisions
+    // TODO: implement iter() that return an iterator on the collisions struct
+    for (pair, _) in before.pairs {
+        collisions.remove(&pair);
+        events.push(CollisionEvent::Stopped(pair.entity1, pair.entity2));
+    }
+
+    event_writer.send_batch(events);
 }