Struct bevy::ecs::event::EventWriter

pub struct EventWriter<'w, 's, E>where
    E: Event,{ /* private fields */ }

Sends events of type T.

Usage

EventWriters are usually declared as a SystemParam.

pub struct MyEvent; // Custom event type.
fn my_system(mut writer: EventWriter<MyEvent>) {
    writer.send(MyEvent);
}

Limitations

EventWriter can only send events of one specific type, which must be known at compile-time. This is not a problem most of the time, but you may find a situation where you cannot know ahead of time every kind of event you’ll need to send. In this case, you can use the “type-erased event” pattern.

fn send_untyped(mut commands: Commands) {
    // Send an event of a specific type without having to declare that
    // type as a SystemParam.
    //
    // Effectively, we're just moving the type parameter from the /type/ to the /method/,
    // which allows one to do all kinds of clever things with type erasure, such as sending
    // custom events to unknown 3rd party plugins (modding API).
    //
    // NOTE: the event won't actually be sent until commands get flushed
    // at the end of the current stage.
    commands.add(|w: &mut World| {
        let mut events_resource = w.resource_mut::<Events<_>>();
        events_resource.send(MyEvent);
    });
}

Note that this is considered non-idiomatic, and should only be used when EventWriter will not work.

Implementations

impl<'w, 's, E> EventWriter<'w, 's, E>where
    E: Event,

pub fn send(&mut self, event: E)

Sends an event. EventReaders can then read the event. See Events for details.

pub fn send_batch(&mut self, events: impl IntoIterator<Item = E>)

pub fn send_default(&mut self)where
    E: Default,

Sends the default value of the event. Useful when the event is an empty struct.

Trait Implementations

impl<'w, 's, E> SystemParam for EventWriter<'w, 's, E>where
    E: Event,

type Fetch = FetchState<(<ResMut<'w, Events<E>> as SystemParam>::Fetch,), E>