Fix Events::<drain/clear> bug

Co-authored-by: Alice Cecile <[email protected]>

Author: NathanSWard

crates/bevy_ecs/src/event.rs

@@ -150,14 +150,14 @@ fn map_instance_event<T>(event_instance: &EventInstance<T>) -> &T {
 }
 
 /// Reads events of type `T` in order and tracks which events have already been read.
-#[derive(SystemParam)]
+#[derive(SystemParam, Debug)]
 pub struct EventReader<'a, T: Component> {
     last_event_count: Local<'a, (usize, PhantomData<T>)>,
     events: Res<'a, Events<T>>,
 }
 
 /// Sends events of type `T`.
-#[derive(SystemParam)]
+#[derive(SystemParam, Debug)]
 pub struct EventWriter<'a, T: Component> {
     events: ResMut<'a, Events<T>>,
 }
@@ -172,6 +172,7 @@ impl<'a, T: Component> EventWriter<'a, T> {
     }
 }
 
+#[derive(Debug)]
 pub struct ManualEventReader<T> {
     last_event_count: usize,
     _marker: PhantomData<T>,
@@ -328,14 +329,25 @@ impl<T: Component> Events<T> {
         events.update();
     }
 
+    #[inline]
+    fn increment_start_event_count(&mut self) {
+        let count = self.event_count + 1;
+        self.a_start_event_count = count;
+        self.b_start_event_count = count;
+    }
+
     /// Removes all events.
+    #[inline]
     pub fn clear(&mut self) {
+        self.increment_start_event_count();
         self.events_a.clear();
         self.events_b.clear();
     }
 
     /// Creates a draining iterator that removes all events.
     pub fn drain(&mut self) -> impl Iterator<Item = T> + '_ {
+        self.increment_start_event_count();
+
         let map = |i: EventInstance<T>| i.event;
         match self.state {
             State::A => self
@@ -376,6 +388,8 @@ impl<T: Component> Events<T> {
 
 #[cfg(test)]
 mod tests {
+    use bevy_utils::tracing::event;
+
     use super::*;
 
     #[derive(Copy, Clone, PartialEq, Eq, Debug)]
@@ -480,4 +494,40 @@ mod tests {
     ) -> Vec<TestEvent> {
         reader.iter(events).cloned().collect::<Vec<TestEvent>>()
     }
+
+    #[derive(PartialEq, Eq, Debug)]
+    struct E(usize);
+
+    fn events_clear_and_read_impl(clear_func: impl FnOnce(&mut Events<E>)) {
+        let mut events = Events::<E>::default();
+        let mut reader = events.get_reader();
+
+        assert!(reader.iter(&events).next().is_none());
+
+        events.send(E(0));
+        assert_eq!(*reader.iter(&events).next().unwrap(), E(0));
+        assert_eq!(reader.iter(&events).next(), None);
+
+        events.send(E(1));
+        clear_func(&mut events);
+        assert!(reader.iter(&events).next().is_none());
+
+        events.send(E(2));
+        events.update();
+        events.send(E(3));
+
+        assert!(reader.iter(&events).eq([E(2), E(3)].iter()));
+    }
+
+    #[test]
+    fn test_events_clear_and_read() {
+        events_clear_and_read_impl(|events| events.clear());
+    }
+
+    #[test]
+    fn test_events_drain_and_read() {
+        events_clear_and_read_impl(|events| {
+            assert!(events.drain().eq(vec![E(0), E(1)].into_iter()));
+        });
+    }
 }