Struct EventWriter

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

Sends events of type T.

Usage

EventWriters are usually declared as a SystemParam.

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

Observers

“Buffered” Events, such as those sent directly in Events or sent using EventWriter, do not automatically trigger any Observers watching for that event, as each Event has different requirements regarding if it will be triggered, and if so, when it will be triggered in the schedule.

Concurrency

EventWriter param has ResMut<Events<T>> inside. So two systems declaring EventWriter<T> params for the same event type won’t be executed concurrently.

Untyped events

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 applied during
    // apply_deferred.
    commands.add(|w: &mut World| {
        w.send_event(MyEvent);
    });
}

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

Implementations

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

pub fn send(&mut self, event: E) -> EventId<E>

Sends an event, which can later be read by EventReaders. This method returns the ID of the sent event.

See Events for details.

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

Sends a list of events all at once, which can later be read by EventReaders. This is more efficient than sending each event individually. This method returns the IDs of the sent events.

See Events for details.

pub fn send_default(&mut self) -> EventId<E>

where E: Default,

Sends the default value of the event. Useful when the event is an empty struct. This method returns the ID of the sent event.

See Events for details.

Trait Implementations

impl<E: Event> SystemParam for EventWriter<'_, E>

type State = FetchState<E>

Used to store data which persists across invocations of a system.

type Item<'w, 's> = EventWriter<'w, E>

The item type returned when constructing this system param. The value of this associated type should be Self, instantiated with new lifetimes.

fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State

Registers any World access used by this SystemParam and creates a new instance of this param’s State.

unsafe fn new_archetype( state: &mut Self::State, archetype: &Archetype, system_meta: &mut SystemMeta, )

For the specified Archetype, registers the components accessed by this SystemParam (if applicable).a

fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)

Applies any deferred mutations stored in this SystemParam’s state. This is used to apply Commands during apply_deferred.

fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

Queues any deferred mutations to be applied at the next apply_deferred.

unsafe fn get_param<'w, 's>( state: &'s mut Self::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, change_tick: Tick, ) -> Self::Item<'w, 's>

Creates a parameter to be passed into a SystemParamFunction.

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

where ResMut<'w, Events<E>>: ReadOnlySystemParam,