1use crate as bevy_ecs;
4#[cfg(feature = "multi_threaded")]
5use crate::batching::BatchingStrategy;
6use crate::change_detection::MutUntyped;
7use crate::{
8 change_detection::{DetectChangesMut, Mut},
9 component::{Component, ComponentId, Tick},
10 system::{Local, Res, ResMut, Resource, SystemParam},
11 world::World,
12};
13pub use bevy_ecs_macros::Event;
14use bevy_ecs_macros::SystemSet;
15#[cfg(feature = "bevy_reflect")]
16use bevy_reflect::Reflect;
17use bevy_utils::detailed_trace;
18use std::ops::{Deref, DerefMut};
19use std::{
20 cmp::Ordering,
21 fmt,
22 hash::{Hash, Hasher},
23 iter::Chain,
24 marker::PhantomData,
25 slice::Iter,
26};
27
28#[diagnostic::on_unimplemented(
47 message = "`{Self}` is not an `Event`",
48 label = "invalid `Event`",
49 note = "consider annotating `{Self}` with `#[derive(Event)]`"
50)]
51pub trait Event: Component {}
52
53#[cfg_attr(feature = "bevy_reflect", derive(Reflect))]
60pub struct EventId<E: Event> {
61 pub id: usize,
64 #[cfg_attr(feature = "bevy_reflect", reflect(ignore))]
65 _marker: PhantomData<E>,
66}
67
68impl<E: Event> Copy for EventId<E> {}
69
70impl<E: Event> Clone for EventId<E> {
71 fn clone(&self) -> Self {
72 *self
73 }
74}
75
76impl<E: Event> fmt::Display for EventId<E> {
77 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
78 <Self as fmt::Debug>::fmt(self, f)
79 }
80}
81
82impl<E: Event> fmt::Debug for EventId<E> {
83 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
84 write!(
85 f,
86 "event<{}>#{}",
87 std::any::type_name::<E>().split("::").last().unwrap(),
88 self.id,
89 )
90 }
91}
92
93impl<E: Event> PartialEq for EventId<E> {
94 fn eq(&self, other: &Self) -> bool {
95 self.id == other.id
96 }
97}
98
99impl<E: Event> Eq for EventId<E> {}
100
101impl<E: Event> PartialOrd for EventId<E> {
102 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
103 Some(self.cmp(other))
104 }
105}
106
107impl<E: Event> Ord for EventId<E> {
108 fn cmp(&self, other: &Self) -> Ordering {
109 self.id.cmp(&other.id)
110 }
111}
112
113impl<E: Event> Hash for EventId<E> {
114 fn hash<H: Hasher>(&self, state: &mut H) {
115 Hash::hash(&self.id, state);
116 }
117}
118
119#[derive(Debug)]
120#[cfg_attr(feature = "bevy_reflect", derive(Reflect))]
121struct EventInstance<E: Event> {
122 pub event_id: EventId<E>,
123 pub event: E,
124}
125
126#[derive(Debug, Resource)]
199#[cfg_attr(feature = "bevy_reflect", derive(Reflect))]
200pub struct Events<E: Event> {
201 events_a: EventSequence<E>,
204 events_b: EventSequence<E>,
206 event_count: usize,
207}
208
209impl<E: Event> Default for Events<E> {
211 fn default() -> Self {
212 Self {
213 events_a: Default::default(),
214 events_b: Default::default(),
215 event_count: Default::default(),
216 }
217 }
218}
219
220impl<E: Event> Events<E> {
221 pub fn oldest_event_count(&self) -> usize {
223 self.events_a
224 .start_event_count
225 .min(self.events_b.start_event_count)
226 }
227
228 pub fn send(&mut self, event: E) -> EventId<E> {
232 let event_id = EventId {
233 id: self.event_count,
234 _marker: PhantomData,
235 };
236 detailed_trace!("Events::send() -> id: {}", event_id);
237
238 let event_instance = EventInstance { event_id, event };
239
240 self.events_b.push(event_instance);
241 self.event_count += 1;
242
243 event_id
244 }
245
246 pub fn send_batch(&mut self, events: impl IntoIterator<Item = E>) -> SendBatchIds<E> {
250 let last_count = self.event_count;
251
252 self.extend(events);
253
254 SendBatchIds {
255 last_count,
256 event_count: self.event_count,
257 _marker: PhantomData,
258 }
259 }
260
261 pub fn send_default(&mut self) -> EventId<E>
264 where
265 E: Default,
266 {
267 self.send(Default::default())
268 }
269
270 pub fn get_reader(&self) -> ManualEventReader<E> {
272 ManualEventReader::default()
273 }
274
275 pub fn get_reader_current(&self) -> ManualEventReader<E> {
278 ManualEventReader {
279 last_event_count: self.event_count,
280 ..Default::default()
281 }
282 }
283
284 pub fn update(&mut self) {
289 std::mem::swap(&mut self.events_a, &mut self.events_b);
290 self.events_b.clear();
291 self.events_b.start_event_count = self.event_count;
292 debug_assert_eq!(
293 self.events_a.start_event_count + self.events_a.len(),
294 self.events_b.start_event_count
295 );
296 }
297
298 #[must_use = "If you do not need the returned events, call .update() instead."]
303 pub fn update_drain(&mut self) -> impl Iterator<Item = E> + '_ {
304 std::mem::swap(&mut self.events_a, &mut self.events_b);
305 let iter = self.events_b.events.drain(..);
306 self.events_b.start_event_count = self.event_count;
307 debug_assert_eq!(
308 self.events_a.start_event_count + self.events_a.len(),
309 self.events_b.start_event_count
310 );
311
312 iter.map(|e| e.event)
313 }
314
315 #[inline]
316 fn reset_start_event_count(&mut self) {
317 self.events_a.start_event_count = self.event_count;
318 self.events_b.start_event_count = self.event_count;
319 }
320
321 #[inline]
323 pub fn clear(&mut self) {
324 self.reset_start_event_count();
325 self.events_a.clear();
326 self.events_b.clear();
327 }
328
329 #[inline]
331 pub fn len(&self) -> usize {
332 self.events_a.len() + self.events_b.len()
333 }
334
335 #[inline]
337 pub fn is_empty(&self) -> bool {
338 self.len() == 0
339 }
340
341 pub fn drain(&mut self) -> impl Iterator<Item = E> + '_ {
343 self.reset_start_event_count();
344
345 self.events_a
347 .drain(..)
348 .chain(self.events_b.drain(..))
349 .map(|i| i.event)
350 }
351
352 pub fn iter_current_update_events(&self) -> impl ExactSizeIterator<Item = &E> {
359 self.events_b.iter().map(|i| &i.event)
360 }
361
362 pub fn get_event(&self, id: usize) -> Option<(&E, EventId<E>)> {
364 if id < self.oldest_id() {
365 return None;
366 }
367
368 let sequence = self.sequence(id);
369 let index = id.saturating_sub(sequence.start_event_count);
370
371 sequence
372 .get(index)
373 .map(|instance| (&instance.event, instance.event_id))
374 }
375
376 pub fn oldest_id(&self) -> usize {
378 self.events_a.start_event_count
379 }
380
381 fn sequence(&self, id: usize) -> &EventSequence<E> {
383 if id < self.events_b.start_event_count {
384 &self.events_a
385 } else {
386 &self.events_b
387 }
388 }
389}
390
391impl<E: Event> Extend<E> for Events<E> {
392 fn extend<I>(&mut self, iter: I)
393 where
394 I: IntoIterator<Item = E>,
395 {
396 let old_count = self.event_count;
397 let mut event_count = self.event_count;
398 let events = iter.into_iter().map(|event| {
399 let event_id = EventId {
400 id: event_count,
401 _marker: PhantomData,
402 };
403 event_count += 1;
404 EventInstance { event_id, event }
405 });
406
407 self.events_b.extend(events);
408
409 if old_count != event_count {
410 detailed_trace!(
411 "Events::extend() -> ids: ({}..{})",
412 self.event_count,
413 event_count
414 );
415 }
416
417 self.event_count = event_count;
418 }
419}
420
421#[derive(Debug)]
422#[cfg_attr(feature = "bevy_reflect", derive(Reflect))]
423struct EventSequence<E: Event> {
424 events: Vec<EventInstance<E>>,
425 start_event_count: usize,
426}
427
428impl<E: Event> Default for EventSequence<E> {
430 fn default() -> Self {
431 Self {
432 events: Default::default(),
433 start_event_count: Default::default(),
434 }
435 }
436}
437
438impl<E: Event> Deref for EventSequence<E> {
439 type Target = Vec<EventInstance<E>>;
440
441 fn deref(&self) -> &Self::Target {
442 &self.events
443 }
444}
445
446impl<E: Event> DerefMut for EventSequence<E> {
447 fn deref_mut(&mut self) -> &mut Self::Target {
448 &mut self.events
449 }
450}
451
452#[derive(SystemParam, Debug)]
459pub struct EventReader<'w, 's, E: Event> {
460 reader: Local<'s, ManualEventReader<E>>,
461 events: Res<'w, Events<E>>,
462}
463
464impl<'w, 's, E: Event> EventReader<'w, 's, E> {
465 pub fn read(&mut self) -> EventIterator<'_, E> {
469 self.reader.read(&self.events)
470 }
471
472 pub fn read_with_id(&mut self) -> EventIteratorWithId<'_, E> {
474 self.reader.read_with_id(&self.events)
475 }
476
477 #[cfg(feature = "multi_threaded")]
514 pub fn par_read(&mut self) -> EventParIter<'_, E> {
515 self.reader.par_read(&self.events)
516 }
517
518 pub fn len(&self) -> usize {
520 self.reader.len(&self.events)
521 }
522
523 pub fn is_empty(&self) -> bool {
545 self.reader.is_empty(&self.events)
546 }
547
548 pub fn clear(&mut self) {
555 self.reader.clear(&self.events);
556 }
557}
558
559#[derive(SystemParam)]
615pub struct EventWriter<'w, E: Event> {
616 events: ResMut<'w, Events<E>>,
617}
618
619impl<'w, E: Event> EventWriter<'w, E> {
620 pub fn send(&mut self, event: E) -> EventId<E> {
625 self.events.send(event)
626 }
627
628 pub fn send_batch(&mut self, events: impl IntoIterator<Item = E>) -> SendBatchIds<E> {
634 self.events.send_batch(events)
635 }
636
637 pub fn send_default(&mut self) -> EventId<E>
642 where
643 E: Default,
644 {
645 self.events.send_default()
646 }
647}
648
649#[derive(Debug)]
691pub struct ManualEventReader<E: Event> {
692 last_event_count: usize,
693 _marker: PhantomData<E>,
694}
695
696impl<E: Event> Default for ManualEventReader<E> {
697 fn default() -> Self {
698 ManualEventReader {
699 last_event_count: 0,
700 _marker: Default::default(),
701 }
702 }
703}
704
705impl<E: Event> Clone for ManualEventReader<E> {
706 fn clone(&self) -> Self {
707 ManualEventReader {
708 last_event_count: self.last_event_count,
709 _marker: PhantomData,
710 }
711 }
712}
713
714#[allow(clippy::len_without_is_empty)] impl<E: Event> ManualEventReader<E> {
716 pub fn read<'a>(&'a mut self, events: &'a Events<E>) -> EventIterator<'a, E> {
718 self.read_with_id(events).without_id()
719 }
720
721 pub fn read_with_id<'a>(&'a mut self, events: &'a Events<E>) -> EventIteratorWithId<'a, E> {
723 EventIteratorWithId::new(self, events)
724 }
725
726 #[cfg(feature = "multi_threaded")]
728 pub fn par_read<'a>(&'a mut self, events: &'a Events<E>) -> EventParIter<'a, E> {
729 EventParIter::new(self, events)
730 }
731
732 pub fn len(&self, events: &Events<E>) -> usize {
734 events
739 .event_count
740 .saturating_sub(self.last_event_count)
741 .min(events.len())
742 }
743
744 pub fn missed_events(&self, events: &Events<E>) -> usize {
746 events
747 .oldest_event_count()
748 .saturating_sub(self.last_event_count)
749 }
750
751 pub fn is_empty(&self, events: &Events<E>) -> bool {
753 self.len(events) == 0
754 }
755
756 pub fn clear(&mut self, events: &Events<E>) {
758 self.last_event_count = events.event_count;
759 }
760}
761
762#[derive(Debug)]
764pub struct EventIterator<'a, E: Event> {
765 iter: EventIteratorWithId<'a, E>,
766}
767
768impl<'a, E: Event> Iterator for EventIterator<'a, E> {
769 type Item = &'a E;
770 fn next(&mut self) -> Option<Self::Item> {
771 self.iter.next().map(|(event, _)| event)
772 }
773
774 fn size_hint(&self) -> (usize, Option<usize>) {
775 self.iter.size_hint()
776 }
777
778 fn count(self) -> usize {
779 self.iter.count()
780 }
781
782 fn last(self) -> Option<Self::Item>
783 where
784 Self: Sized,
785 {
786 self.iter.last().map(|(event, _)| event)
787 }
788
789 fn nth(&mut self, n: usize) -> Option<Self::Item> {
790 self.iter.nth(n).map(|(event, _)| event)
791 }
792}
793
794impl<'a, E: Event> ExactSizeIterator for EventIterator<'a, E> {
795 fn len(&self) -> usize {
796 self.iter.len()
797 }
798}
799
800#[derive(Debug)]
802pub struct EventIteratorWithId<'a, E: Event> {
803 reader: &'a mut ManualEventReader<E>,
804 chain: Chain<Iter<'a, EventInstance<E>>, Iter<'a, EventInstance<E>>>,
805 unread: usize,
806}
807
808impl<'a, E: Event> EventIteratorWithId<'a, E> {
809 pub fn new(reader: &'a mut ManualEventReader<E>, events: &'a Events<E>) -> Self {
811 let a_index = reader
812 .last_event_count
813 .saturating_sub(events.events_a.start_event_count);
814 let b_index = reader
815 .last_event_count
816 .saturating_sub(events.events_b.start_event_count);
817 let a = events.events_a.get(a_index..).unwrap_or_default();
818 let b = events.events_b.get(b_index..).unwrap_or_default();
819
820 let unread_count = a.len() + b.len();
821 debug_assert_eq!(unread_count, reader.len(events));
823 reader.last_event_count = events.event_count - unread_count;
824 let chain = a.iter().chain(b.iter());
826
827 Self {
828 reader,
829 chain,
830 unread: unread_count,
831 }
832 }
833
834 pub fn without_id(self) -> EventIterator<'a, E> {
836 EventIterator { iter: self }
837 }
838}
839
840impl<'a, E: Event> Iterator for EventIteratorWithId<'a, E> {
841 type Item = (&'a E, EventId<E>);
842 fn next(&mut self) -> Option<Self::Item> {
843 match self
844 .chain
845 .next()
846 .map(|instance| (&instance.event, instance.event_id))
847 {
848 Some(item) => {
849 detailed_trace!("EventReader::iter() -> {}", item.1);
850 self.reader.last_event_count += 1;
851 self.unread -= 1;
852 Some(item)
853 }
854 None => None,
855 }
856 }
857
858 fn size_hint(&self) -> (usize, Option<usize>) {
859 self.chain.size_hint()
860 }
861
862 fn count(self) -> usize {
863 self.reader.last_event_count += self.unread;
864 self.unread
865 }
866
867 fn last(self) -> Option<Self::Item>
868 where
869 Self: Sized,
870 {
871 let EventInstance { event_id, event } = self.chain.last()?;
872 self.reader.last_event_count += self.unread;
873 Some((event, *event_id))
874 }
875
876 fn nth(&mut self, n: usize) -> Option<Self::Item> {
877 if let Some(EventInstance { event_id, event }) = self.chain.nth(n) {
878 self.reader.last_event_count += n + 1;
879 self.unread -= n + 1;
880 Some((event, *event_id))
881 } else {
882 self.reader.last_event_count += self.unread;
883 self.unread = 0;
884 None
885 }
886 }
887}
888
889impl<'a, E: Event> ExactSizeIterator for EventIteratorWithId<'a, E> {
890 fn len(&self) -> usize {
891 self.unread
892 }
893}
894
895#[cfg(feature = "multi_threaded")]
897#[derive(Debug)]
898pub struct EventParIter<'a, E: Event> {
899 reader: &'a mut ManualEventReader<E>,
900 slices: [&'a [EventInstance<E>]; 2],
901 batching_strategy: BatchingStrategy,
902 unread: usize,
903}
904
905#[cfg(feature = "multi_threaded")]
906impl<'a, E: Event> EventParIter<'a, E> {
907 pub fn new(reader: &'a mut ManualEventReader<E>, events: &'a Events<E>) -> Self {
909 let a_index = reader
910 .last_event_count
911 .saturating_sub(events.events_a.start_event_count);
912 let b_index = reader
913 .last_event_count
914 .saturating_sub(events.events_b.start_event_count);
915 let a = events.events_a.get(a_index..).unwrap_or_default();
916 let b = events.events_b.get(b_index..).unwrap_or_default();
917
918 let unread_count = a.len() + b.len();
919 debug_assert_eq!(unread_count, reader.len(events));
921 reader.last_event_count = events.event_count - unread_count;
922
923 Self {
924 reader,
925 slices: [a, b],
926 batching_strategy: BatchingStrategy::default(),
927 unread: unread_count,
928 }
929 }
930
931 pub fn batching_strategy(mut self, strategy: BatchingStrategy) -> Self {
936 self.batching_strategy = strategy;
937 self
938 }
939
940 pub fn for_each<FN: Fn(&'a E) + Send + Sync + Clone>(self, func: FN) {
950 self.for_each_with_id(move |e, _| func(e));
951 }
952
953 pub fn for_each_with_id<FN: Fn(&'a E, EventId<E>) + Send + Sync + Clone>(mut self, func: FN) {
964 #[cfg(any(target_arch = "wasm32", not(feature = "multi_threaded")))]
965 {
966 self.into_iter().for_each(|(e, i)| func(e, i));
967 }
968
969 #[cfg(all(not(target_arch = "wasm32"), feature = "multi_threaded"))]
970 {
971 let pool = bevy_tasks::ComputeTaskPool::get();
972 let thread_count = pool.thread_num();
973 if thread_count <= 1 {
974 return self.into_iter().for_each(|(e, i)| func(e, i));
975 }
976
977 let batch_size = self
978 .batching_strategy
979 .calc_batch_size(|| self.len(), thread_count);
980 let chunks = self.slices.map(|s| s.chunks_exact(batch_size));
981 let remainders = chunks.each_ref().map(|c| c.remainder());
982
983 pool.scope(|scope| {
984 for batch in chunks.into_iter().flatten().chain(remainders) {
985 let func = func.clone();
986 scope.spawn(async move {
987 for event in batch {
988 func(&event.event, event.event_id);
989 }
990 });
991 }
992 });
993
994 self.reader.last_event_count += self.unread;
996 self.unread = 0;
997 }
998 }
999
1000 pub fn len(&self) -> usize {
1002 self.slices.iter().map(|s| s.len()).sum()
1003 }
1004
1005 pub fn is_empty(&self) -> bool {
1007 self.slices.iter().all(|x| x.is_empty())
1008 }
1009}
1010
1011#[cfg(feature = "multi_threaded")]
1012impl<'a, E: Event> IntoIterator for EventParIter<'a, E> {
1013 type IntoIter = EventIteratorWithId<'a, E>;
1014 type Item = <Self::IntoIter as Iterator>::Item;
1015
1016 fn into_iter(self) -> Self::IntoIter {
1017 let EventParIter {
1018 reader,
1019 slices: [a, b],
1020 ..
1021 } = self;
1022 let unread = a.len() + b.len();
1023 let chain = a.iter().chain(b);
1024 EventIteratorWithId {
1025 reader,
1026 chain,
1027 unread,
1028 }
1029 }
1030}
1031
1032#[doc(hidden)]
1033struct RegisteredEvent {
1034 component_id: ComponentId,
1035 previously_updated: bool,
1037 update: unsafe fn(MutUntyped),
1040}
1041
1042#[derive(Resource, Default)]
1045pub struct EventRegistry {
1046 pub should_update: ShouldUpdateEvents,
1050 event_updates: Vec<RegisteredEvent>,
1051}
1052
1053#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
1055pub enum ShouldUpdateEvents {
1056 #[default]
1058 Always,
1059 Waiting,
1061 Ready,
1063}
1064
1065impl EventRegistry {
1066 pub fn register_event<T: Event>(world: &mut World) {
1071 let component_id = world.init_resource::<Events<T>>();
1074 let mut registry = world.get_resource_or_insert_with(Self::default);
1075 registry.event_updates.push(RegisteredEvent {
1076 component_id,
1077 previously_updated: false,
1078 update: |ptr| {
1079 unsafe { ptr.with_type::<Events<T>>() }
1081 .bypass_change_detection()
1082 .update();
1083 },
1084 });
1085 }
1086
1087 pub fn deregister_events<T: Event>(world: &mut World) {
1089 let component_id = world.init_resource::<Events<T>>();
1090 let mut registry = world.get_resource_or_insert_with(Self::default);
1091 registry
1092 .event_updates
1093 .retain(|e| e.component_id != component_id);
1094 world.remove_resource::<Events<T>>();
1095 }
1096
1097 pub fn run_updates(&mut self, world: &mut World, last_change_tick: Tick) {
1099 for registered_event in &mut self.event_updates {
1100 if let Some(events) = world.get_resource_mut_by_id(registered_event.component_id) {
1102 let has_changed = events.has_changed_since(last_change_tick);
1103 if registered_event.previously_updated || has_changed {
1104 unsafe { (registered_event.update)(events) };
1107 registered_event.previously_updated =
1110 has_changed || !registered_event.previously_updated;
1111 }
1112 }
1113 }
1114 }
1115}
1116
1117#[doc(hidden)]
1118#[derive(SystemSet, Clone, Debug, PartialEq, Eq, Hash)]
1119pub struct EventUpdates;
1120
1121pub fn signal_event_update_system(signal: Option<ResMut<EventRegistry>>) {
1126 if let Some(mut registry) = signal {
1127 registry.should_update = ShouldUpdateEvents::Ready;
1128 }
1129}
1130
1131pub fn event_update_system(world: &mut World, mut last_change_tick: Local<Tick>) {
1133 if world.contains_resource::<EventRegistry>() {
1134 world.resource_scope(|world, mut registry: Mut<EventRegistry>| {
1135 registry.run_updates(world, *last_change_tick);
1136
1137 registry.should_update = match registry.should_update {
1138 ShouldUpdateEvents::Always => ShouldUpdateEvents::Always,
1140 ShouldUpdateEvents::Waiting | ShouldUpdateEvents::Ready => {
1142 ShouldUpdateEvents::Waiting
1143 }
1144 };
1145 });
1146 }
1147 *last_change_tick = world.change_tick();
1148}
1149
1150pub fn event_update_condition(maybe_signal: Option<Res<EventRegistry>>) -> bool {
1157 match maybe_signal {
1158 Some(signal) => match signal.should_update {
1159 ShouldUpdateEvents::Always | ShouldUpdateEvents::Ready => true,
1160 ShouldUpdateEvents::Waiting => false,
1161 },
1162 None => true,
1163 }
1164}
1165
1166pub struct SendBatchIds<E> {
1168 last_count: usize,
1169 event_count: usize,
1170 _marker: PhantomData<E>,
1171}
1172
1173impl<E: Event> Iterator for SendBatchIds<E> {
1174 type Item = EventId<E>;
1175
1176 fn next(&mut self) -> Option<Self::Item> {
1177 if self.last_count >= self.event_count {
1178 return None;
1179 }
1180
1181 let result = Some(EventId {
1182 id: self.last_count,
1183 _marker: PhantomData,
1184 });
1185
1186 self.last_count += 1;
1187
1188 result
1189 }
1190}
1191
1192impl<E: Event> ExactSizeIterator for SendBatchIds<E> {
1193 fn len(&self) -> usize {
1194 self.event_count.saturating_sub(self.last_count)
1195 }
1196}
1197
1198#[cfg(test)]
1199mod tests {
1200 use crate::system::assert_is_read_only_system;
1201
1202 use super::*;
1203
1204 #[derive(Event, Copy, Clone, PartialEq, Eq, Debug)]
1205 struct TestEvent {
1206 i: usize,
1207 }
1208
1209 #[test]
1210 fn test_events() {
1211 let mut events = Events::<TestEvent>::default();
1212 let event_0 = TestEvent { i: 0 };
1213 let event_1 = TestEvent { i: 1 };
1214 let event_2 = TestEvent { i: 2 };
1215
1216 let mut reader_missed = events.get_reader();
1219
1220 let mut reader_a = events.get_reader();
1221
1222 events.send(event_0);
1223
1224 assert_eq!(
1225 get_events(&events, &mut reader_a),
1226 vec![event_0],
1227 "reader_a created before event receives event"
1228 );
1229 assert_eq!(
1230 get_events(&events, &mut reader_a),
1231 vec![],
1232 "second iteration of reader_a created before event results in zero events"
1233 );
1234
1235 let mut reader_b = events.get_reader();
1236
1237 assert_eq!(
1238 get_events(&events, &mut reader_b),
1239 vec![event_0],
1240 "reader_b created after event receives event"
1241 );
1242 assert_eq!(
1243 get_events(&events, &mut reader_b),
1244 vec![],
1245 "second iteration of reader_b created after event results in zero events"
1246 );
1247
1248 events.send(event_1);
1249
1250 let mut reader_c = events.get_reader();
1251
1252 assert_eq!(
1253 get_events(&events, &mut reader_c),
1254 vec![event_0, event_1],
1255 "reader_c created after two events receives both events"
1256 );
1257 assert_eq!(
1258 get_events(&events, &mut reader_c),
1259 vec![],
1260 "second iteration of reader_c created after two event results in zero events"
1261 );
1262
1263 assert_eq!(
1264 get_events(&events, &mut reader_a),
1265 vec![event_1],
1266 "reader_a receives next unread event"
1267 );
1268
1269 events.update();
1270
1271 let mut reader_d = events.get_reader();
1272
1273 events.send(event_2);
1274
1275 assert_eq!(
1276 get_events(&events, &mut reader_a),
1277 vec![event_2],
1278 "reader_a receives event created after update"
1279 );
1280 assert_eq!(
1281 get_events(&events, &mut reader_b),
1282 vec![event_1, event_2],
1283 "reader_b receives events created before and after update"
1284 );
1285 assert_eq!(
1286 get_events(&events, &mut reader_d),
1287 vec![event_0, event_1, event_2],
1288 "reader_d receives all events created before and after update"
1289 );
1290
1291 events.update();
1292
1293 assert_eq!(
1294 get_events(&events, &mut reader_missed),
1295 vec![event_2],
1296 "reader_missed missed events unread after two update() calls"
1297 );
1298 }
1299
1300 fn get_events<E: Event + Clone>(
1301 events: &Events<E>,
1302 reader: &mut ManualEventReader<E>,
1303 ) -> Vec<E> {
1304 reader.read(events).cloned().collect::<Vec<E>>()
1305 }
1306
1307 #[derive(Event, PartialEq, Eq, Debug)]
1308 struct E(usize);
1309
1310 fn events_clear_and_read_impl(clear_func: impl FnOnce(&mut Events<E>)) {
1311 let mut events = Events::<E>::default();
1312 let mut reader = events.get_reader();
1313
1314 assert!(reader.read(&events).next().is_none());
1315
1316 events.send(E(0));
1317 assert_eq!(*reader.read(&events).next().unwrap(), E(0));
1318 assert_eq!(reader.read(&events).next(), None);
1319
1320 events.send(E(1));
1321 clear_func(&mut events);
1322 assert!(reader.read(&events).next().is_none());
1323
1324 events.send(E(2));
1325 events.update();
1326 events.send(E(3));
1327
1328 assert!(reader.read(&events).eq([E(2), E(3)].iter()));
1329 }
1330
1331 #[test]
1332 fn test_events_clear_and_read() {
1333 events_clear_and_read_impl(|events| events.clear());
1334 }
1335
1336 #[test]
1337 fn test_events_drain_and_read() {
1338 events_clear_and_read_impl(|events| {
1339 assert!(events.drain().eq(vec![E(0), E(1)].into_iter()));
1340 });
1341 }
1342
1343 #[test]
1344 fn test_events_extend_impl() {
1345 let mut events = Events::<TestEvent>::default();
1346 let mut reader = events.get_reader();
1347
1348 events.extend(vec![TestEvent { i: 0 }, TestEvent { i: 1 }]);
1349 assert!(reader
1350 .read(&events)
1351 .eq([TestEvent { i: 0 }, TestEvent { i: 1 }].iter()));
1352 }
1353
1354 #[test]
1355 fn test_events_empty() {
1356 let mut events = Events::<TestEvent>::default();
1357 assert!(events.is_empty());
1358
1359 events.send(TestEvent { i: 0 });
1360 assert!(!events.is_empty());
1361
1362 events.update();
1363 assert!(!events.is_empty());
1364
1365 events.update();
1368 assert!(events.is_empty());
1369 }
1370
1371 #[test]
1372 fn test_event_reader_len_empty() {
1373 let events = Events::<TestEvent>::default();
1374 assert_eq!(events.get_reader().len(&events), 0);
1375 assert!(events.get_reader().is_empty(&events));
1376 }
1377
1378 #[test]
1379 fn test_event_reader_len_filled() {
1380 let mut events = Events::<TestEvent>::default();
1381 events.send(TestEvent { i: 0 });
1382 assert_eq!(events.get_reader().len(&events), 1);
1383 assert!(!events.get_reader().is_empty(&events));
1384 }
1385
1386 #[test]
1387 fn test_event_iter_len_updated() {
1388 let mut events = Events::<TestEvent>::default();
1389 events.send(TestEvent { i: 0 });
1390 events.send(TestEvent { i: 1 });
1391 events.send(TestEvent { i: 2 });
1392 let mut reader = events.get_reader();
1393 let mut iter = reader.read(&events);
1394 assert_eq!(iter.len(), 3);
1395 iter.next();
1396 assert_eq!(iter.len(), 2);
1397 iter.next();
1398 assert_eq!(iter.len(), 1);
1399 iter.next();
1400 assert_eq!(iter.len(), 0);
1401 }
1402
1403 #[test]
1404 fn test_event_reader_len_current() {
1405 let mut events = Events::<TestEvent>::default();
1406 events.send(TestEvent { i: 0 });
1407 let reader = events.get_reader_current();
1408 dbg!(&reader);
1409 dbg!(&events);
1410 assert!(reader.is_empty(&events));
1411 events.send(TestEvent { i: 0 });
1412 assert_eq!(reader.len(&events), 1);
1413 assert!(!reader.is_empty(&events));
1414 }
1415
1416 #[test]
1417 fn test_event_reader_len_update() {
1418 let mut events = Events::<TestEvent>::default();
1419 events.send(TestEvent { i: 0 });
1420 events.send(TestEvent { i: 0 });
1421 let reader = events.get_reader();
1422 assert_eq!(reader.len(&events), 2);
1423 events.update();
1424 events.send(TestEvent { i: 0 });
1425 assert_eq!(reader.len(&events), 3);
1426 events.update();
1427 assert_eq!(reader.len(&events), 1);
1428 events.update();
1429 assert!(reader.is_empty(&events));
1430 }
1431
1432 #[test]
1433 fn test_event_reader_clear() {
1434 use bevy_ecs::prelude::*;
1435
1436 let mut world = World::new();
1437 let mut events = Events::<TestEvent>::default();
1438 events.send(TestEvent { i: 0 });
1439 world.insert_resource(events);
1440
1441 let mut reader = IntoSystem::into_system(|mut events: EventReader<TestEvent>| -> bool {
1442 if !events.is_empty() {
1443 events.clear();
1444 false
1445 } else {
1446 true
1447 }
1448 });
1449 reader.initialize(&mut world);
1450
1451 let is_empty = reader.run((), &mut world);
1452 assert!(!is_empty, "EventReader should not be empty");
1453 let is_empty = reader.run((), &mut world);
1454 assert!(is_empty, "EventReader should be empty");
1455 }
1456
1457 #[test]
1458 fn test_update_drain() {
1459 let mut events = Events::<TestEvent>::default();
1460 let mut reader = events.get_reader();
1461
1462 events.send(TestEvent { i: 0 });
1463 events.send(TestEvent { i: 1 });
1464 assert_eq!(reader.read(&events).count(), 2);
1465
1466 let mut old_events = Vec::from_iter(events.update_drain());
1467 assert!(old_events.is_empty());
1468
1469 events.send(TestEvent { i: 2 });
1470 assert_eq!(reader.read(&events).count(), 1);
1471
1472 old_events.extend(events.update_drain());
1473 assert_eq!(old_events.len(), 2);
1474
1475 old_events.extend(events.update_drain());
1476 assert_eq!(
1477 old_events,
1478 &[TestEvent { i: 0 }, TestEvent { i: 1 }, TestEvent { i: 2 }]
1479 );
1480 }
1481
1482 #[allow(clippy::iter_nth_zero)]
1483 #[test]
1484 fn test_event_iter_nth() {
1485 use bevy_ecs::prelude::*;
1486
1487 let mut world = World::new();
1488 world.init_resource::<Events<TestEvent>>();
1489
1490 world.send_event(TestEvent { i: 0 });
1491 world.send_event(TestEvent { i: 1 });
1492 world.send_event(TestEvent { i: 2 });
1493 world.send_event(TestEvent { i: 3 });
1494 world.send_event(TestEvent { i: 4 });
1495
1496 let mut schedule = Schedule::default();
1497 schedule.add_systems(|mut events: EventReader<TestEvent>| {
1498 let mut iter = events.read();
1499
1500 assert_eq!(iter.next(), Some(&TestEvent { i: 0 }));
1501 assert_eq!(iter.nth(2), Some(&TestEvent { i: 3 }));
1502 assert_eq!(iter.nth(1), None);
1503
1504 assert!(events.is_empty());
1505 });
1506 schedule.run(&mut world);
1507 }
1508
1509 #[test]
1510 fn test_event_iter_last() {
1511 use bevy_ecs::prelude::*;
1512
1513 let mut world = World::new();
1514 world.init_resource::<Events<TestEvent>>();
1515
1516 let mut reader =
1517 IntoSystem::into_system(|mut events: EventReader<TestEvent>| -> Option<TestEvent> {
1518 events.read().last().copied()
1519 });
1520 reader.initialize(&mut world);
1521
1522 let last = reader.run((), &mut world);
1523 assert!(last.is_none(), "EventReader should be empty");
1524
1525 world.send_event(TestEvent { i: 0 });
1526 let last = reader.run((), &mut world);
1527 assert_eq!(last, Some(TestEvent { i: 0 }));
1528
1529 world.send_event(TestEvent { i: 1 });
1530 world.send_event(TestEvent { i: 2 });
1531 world.send_event(TestEvent { i: 3 });
1532 let last = reader.run((), &mut world);
1533 assert_eq!(last, Some(TestEvent { i: 3 }));
1534
1535 let last = reader.run((), &mut world);
1536 assert!(last.is_none(), "EventReader should be empty");
1537 }
1538
1539 #[derive(Event, Clone, PartialEq, Debug, Default)]
1540 struct EmptyTestEvent;
1541
1542 #[test]
1543 fn test_firing_empty_event() {
1544 let mut events = Events::<EmptyTestEvent>::default();
1545 events.send_default();
1546
1547 let mut reader = events.get_reader();
1548 assert_eq!(get_events(&events, &mut reader), vec![EmptyTestEvent]);
1549 }
1550
1551 #[test]
1552 fn ensure_reader_readonly() {
1553 fn reader_system(_: EventReader<EmptyTestEvent>) {}
1554
1555 assert_is_read_only_system(reader_system);
1556 }
1557
1558 #[test]
1559 fn test_send_events_ids() {
1560 let mut events = Events::<TestEvent>::default();
1561 let event_0 = TestEvent { i: 0 };
1562 let event_1 = TestEvent { i: 1 };
1563 let event_2 = TestEvent { i: 2 };
1564
1565 let event_0_id = events.send(event_0);
1566
1567 assert_eq!(
1568 events.get_event(event_0_id.id),
1569 Some((&event_0, event_0_id)),
1570 "Getting a sent event by ID should return the original event"
1571 );
1572
1573 let mut event_ids = events.send_batch([event_1, event_2]);
1574
1575 let event_id = event_ids.next().expect("Event 1 must have been sent");
1576
1577 assert_eq!(
1578 events.get_event(event_id.id),
1579 Some((&event_1, event_id)),
1580 "Getting a sent event by ID should return the original event"
1581 );
1582
1583 let event_id = event_ids.next().expect("Event 2 must have been sent");
1584
1585 assert_eq!(
1586 events.get_event(event_id.id),
1587 Some((&event_2, event_id)),
1588 "Getting a sent event by ID should return the original event"
1589 );
1590
1591 assert!(
1592 event_ids.next().is_none(),
1593 "Only sent two events; got more than two IDs"
1594 );
1595 }
1596
1597 #[cfg(feature = "multi_threaded")]
1598 #[test]
1599 fn test_events_par_iter() {
1600 use crate::prelude::*;
1601 use std::sync::atomic::{AtomicUsize, Ordering};
1602
1603 #[derive(Resource)]
1604 struct Counter(AtomicUsize);
1605
1606 let mut world = World::new();
1607 world.init_resource::<Events<TestEvent>>();
1608 for _ in 0..100 {
1609 world.send_event(TestEvent { i: 1 });
1610 }
1611 let mut schedule = Schedule::default();
1612 schedule.add_systems(
1613 |mut events: EventReader<TestEvent>, counter: ResMut<Counter>| {
1614 events.par_read().for_each(|event| {
1615 counter.0.fetch_add(event.i, Ordering::Relaxed);
1616 });
1617 },
1618 );
1619 world.insert_resource(Counter(AtomicUsize::new(0)));
1620 schedule.run(&mut world);
1621 let counter = world.remove_resource::<Counter>().unwrap();
1622 assert_eq!(counter.0.into_inner(), 100);
1623
1624 world.insert_resource(Counter(AtomicUsize::new(0)));
1625 schedule.run(&mut world);
1626 let counter = world.remove_resource::<Counter>().unwrap();
1627 assert_eq!(counter.0.into_inner(), 0);
1628 }
1629
1630 #[test]
1631 fn iter_current_update_events_iterates_over_current_events() {
1632 #[derive(Event, Clone)]
1633 struct TestEvent;
1634
1635 let mut test_events = Events::<TestEvent>::default();
1636
1637 assert_eq!(test_events.len(), 0);
1639 assert_eq!(test_events.iter_current_update_events().count(), 0);
1640 test_events.update();
1641
1642 test_events.send(TestEvent);
1644
1645 assert_eq!(test_events.len(), 1);
1646 assert_eq!(test_events.iter_current_update_events().count(), 1);
1647 test_events.update();
1648
1649 test_events.send(TestEvent);
1651 test_events.send(TestEvent);
1652
1653 assert_eq!(test_events.len(), 3); assert_eq!(test_events.iter_current_update_events().count(), 2);
1655 test_events.update();
1656
1657 assert_eq!(test_events.len(), 2); assert_eq!(test_events.iter_current_update_events().count(), 0);
1660 }
1661
1662 #[test]
1663 fn test_event_registry_can_add_and_remove_events_to_world() {
1664 use bevy_ecs::prelude::*;
1665
1666 let mut world = World::new();
1667 EventRegistry::register_event::<TestEvent>(&mut world);
1668
1669 let has_events = world.get_resource::<Events<TestEvent>>().is_some();
1670
1671 assert!(has_events, "Should have the events resource");
1672
1673 EventRegistry::deregister_events::<TestEvent>(&mut world);
1674
1675 let has_events = world.get_resource::<Events<TestEvent>>().is_some();
1676
1677 assert!(!has_events, "Should not have the events resource");
1678 }
1679}