Struct EventWriter

pub struct EventWriter<'w, E>
where
    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.write(MyEvent);
}

Observers

“Buffered” Events, such as those sent directly in Events or written 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 write 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.queue(|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> EventWriter<'w, E>

where E: Event,

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

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

See Events for details.

Examples found in repository

examples/ecs/send_and_receive_events.rs (line 61)

fn read_and_write_different_event_types(mut a: EventWriter<A>, mut b: EventReader<B>) {
    for _ in b.read() {}
    a.write(A);
}

/// A dummy event type.
#[derive(Debug, Clone, Event)]
struct DebugEvent {
    resend_from_param_set: bool,
    resend_from_local_event_reader: bool,
    times_sent: u8,
}

/// A system that sends all combinations of events.
fn send_events(mut events: EventWriter<DebugEvent>, frame_count: Res<FrameCount>) {
    println!("Sending events for frame {}", frame_count.0);

    events.write(DebugEvent {
        resend_from_param_set: false,
        resend_from_local_event_reader: false,
        times_sent: 1,
    });
    events.write(DebugEvent {
        resend_from_param_set: true,
        resend_from_local_event_reader: false,
        times_sent: 1,
    });
    events.write(DebugEvent {
        resend_from_param_set: false,
        resend_from_local_event_reader: true,
        times_sent: 1,
    });
    events.write(DebugEvent {
        resend_from_param_set: true,
        resend_from_local_event_reader: true,
        times_sent: 1,
    });
}

/// A system that prints all events sent since the last time this system ran.
///
/// Note that some events will be printed twice, because they were sent twice.
fn debug_events(mut events: EventReader<DebugEvent>) {
    for event in events.read() {
        println!("{event:?}");
    }
}

/// A system that both sends and receives events using [`ParamSet`].
fn send_and_receive_param_set(
    mut param_set: ParamSet<(EventReader<DebugEvent>, EventWriter<DebugEvent>)>,
    frame_count: Res<FrameCount>,
) {
    println!(
        "Sending and receiving events for frame {} with a `ParamSet`",
        frame_count.0
    );

    // We must collect the events to resend, because we can't access the writer while we're iterating over the reader.
    let mut events_to_resend = Vec::new();

    // This is p0, as the first parameter in the `ParamSet` is the reader.
    for event in param_set.p0().read() {
        if event.resend_from_param_set {
            events_to_resend.push(event.clone());
        }
    }

    // This is p1, as the second parameter in the `ParamSet` is the writer.
    for mut event in events_to_resend {
        event.times_sent += 1;
        param_set.p1().write(event);
    }
}

examples/app/custom_loop.rs (line 38)

fn exit_system(input: Res<Input>, mut exit_event: EventWriter<AppExit>) {
    if input.0 == "exit" {
        exit_event.write(AppExit::Success);
    }
}

examples/async_tasks/external_source_external_thread.rs (line 49)

fn read_stream(receiver: Res<StreamReceiver>, mut events: EventWriter<StreamEvent>) {
    for from_stream in receiver.try_iter() {
        events.write(StreamEvent(from_stream));
    }
}

examples/ecs/event.rs (line 47)

fn deal_damage_over_time(
    time: Res<Time>,
    mut state: ResMut<DamageTimer>,
    mut events: EventWriter<DealDamage>,
) {
    if state.tick(time.delta()).finished() {
        // Events can be sent with 'write' and constructed just like any other object.
        events.write(DealDamage { amount: 10 });
    }
}

// This system mutates the 'DealDamage' events to apply some armor value
// It also sends an 'ArmorBlockedDamage' event if the value of 'DealDamage' is zero
//
// Events are mutated using an 'EventMutator<T>' by calling 'read'. This returns an iterator
// over all the &mut T that this system has not read yet. Note, you can have multiple
// 'EventReader', 'EventWriter', and 'EventMutator' in a given system, as long as the types (T) are different.
fn apply_armor_to_damage(
    mut dmg_events: EventMutator<DealDamage>,
    mut armor_events: EventWriter<ArmorBlockedDamage>,
) {
    for event in dmg_events.read() {
        event.amount -= 1;
        if event.amount <= 0 {
            // Zero-sized events can also be sent with 'send'
            armor_events.write(ArmorBlockedDamage);
        }
    }
}

examples/ecs/ecs_guide.rs (line 171)

fn game_over_system(
    game_rules: Res<GameRules>,
    game_state: Res<GameState>,
    mut app_exit_events: EventWriter<AppExit>,
) {
    if let Some(ref player) = game_state.winning_player {
        println!("{player} won the game!");
        app_exit_events.write(AppExit::Success);
    } else if game_state.current_round == game_rules.max_rounds {
        println!("Ran out of rounds. Nobody wins!");
        app_exit_events.write(AppExit::Success);
    }
}

examples/3d/../helpers/widgets.rs (line 176)

pub fn handle_ui_interactions<T>(
    mut interactions: Query<
        (&Interaction, &WidgetClickSender<T>),
        (With<Button>, With<RadioButton>),
    >,
    mut widget_click_events: EventWriter<WidgetClickEvent<T>>,
) where
    T: Clone + Send + Sync + 'static,
{
    for (interaction, click_event) in interactions.iter_mut() {
        if *interaction == Interaction::Pressed {
            widget_click_events.write(WidgetClickEvent((**click_event).clone()));
        }
    }
}

Additional examples can be found in:

• examples/audio/pitch.rs
• examples/ecs/observer_propagation.rs
• examples/games/desk_toy.rs
• examples/3d/mixed_lighting.rs
• examples/games/game_menu.rs
• examples/input/gamepad_rumble.rs
• examples/ui/size_constraints.rs
• examples/window/low_power.rs
• examples/app/headless_renderer.rs

pub fn write_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 written events.

See Events for details.

Examples found in repository

examples/app/log_layers_ecs.rs (line 57)

fn transfer_log_events(
    receiver: NonSend<CapturedLogEvents>,
    mut log_events: EventWriter<LogEvent>,
) {
    // Make sure to use `try_iter()` and not `iter()` to prevent blocking.
    log_events.write_batch(receiver.try_iter());
}

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

where E: Default,

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

See Events for details.

Examples found in repository

examples/ecs/event.rs (line 84)

fn apply_damage_to_health(
    mut dmg_events: EventReader<DealDamage>,
    mut rcvd_events: EventWriter<DamageReceived>,
) {
    for event in dmg_events.read() {
        info!("Applying {} damage", event.amount);
        if event.amount > 0 {
            // Events with a 'Default' implementation can be written with 'write_default'
            rcvd_events.write_default();
        }
    }
}

examples/games/breakout.rs (line 360)

fn check_for_collisions(
    mut commands: Commands,
    mut score: ResMut<Score>,
    ball_query: Single<(&mut Velocity, &Transform), With<Ball>>,
    collider_query: Query<(Entity, &Transform, Option<&Brick>), With<Collider>>,
    mut collision_events: EventWriter<CollisionEvent>,
) {
    let (mut ball_velocity, ball_transform) = ball_query.into_inner();

    for (collider_entity, collider_transform, maybe_brick) in &collider_query {
        let collision = ball_collision(
            BoundingCircle::new(ball_transform.translation.truncate(), BALL_DIAMETER / 2.),
            Aabb2d::new(
                collider_transform.translation.truncate(),
                collider_transform.scale.truncate() / 2.,
            ),
        );

        if let Some(collision) = collision {
            // Writes a collision event so that other systems can react to the collision
            collision_events.write_default();

            // Bricks should be despawned and increment the scoreboard on collision
            if maybe_brick.is_some() {
                commands.entity(collider_entity).despawn();
                **score += 1;
            }

            // Reflect the ball's velocity when it collides
            let mut reflect_x = false;
            let mut reflect_y = false;

            // Reflect only if the velocity is in the opposite direction of the collision
            // This prevents the ball from getting stuck inside the bar
            match collision {
                Collision::Left => reflect_x = ball_velocity.x > 0.0,
                Collision::Right => reflect_x = ball_velocity.x < 0.0,
                Collision::Top => reflect_y = ball_velocity.y < 0.0,
                Collision::Bottom => reflect_y = ball_velocity.y > 0.0,
            }

            // Reflect velocity on the x-axis if we hit something on the x-axis
            if reflect_x {
                ball_velocity.x = -ball_velocity.x;
            }

            // Reflect velocity on the y-axis if we hit something on the y-axis
            if reflect_y {
                ball_velocity.y = -ball_velocity.y;
            }
        }
    }
}

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

👎Deprecated since 0.16.0: Use EventWriter::write instead.

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>

👎Deprecated since 0.16.0: Use EventWriter::write_batch instead.

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,

👎Deprecated since 0.16.0: Use EventWriter::write_default instead.

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> SystemParam for EventWriter<'_, E>

where E: Event,

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, ) -> <EventWriter<'_, E> as SystemParam>::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 <EventWriter<'_, E> as SystemParam>::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 <EventWriter<'_, E> as SystemParam>::State, system_meta: &SystemMeta, world: &mut World, )

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

fn queue( state: &mut <EventWriter<'_, E> as SystemParam>::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

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

unsafe fn validate_param<'w, 's>( state: &'s <EventWriter<'_, E> as SystemParam>::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'w>, ) -> Result<(), SystemParamValidationError>

Validates that the param can be acquired by the get_param.

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

Creates a parameter to be passed into a SystemParamFunction.

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

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