Struct bevy::ecs::event::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.send(MyEvent);
}

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> EventWriter<'w, E>

where E: Event,

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.

Examples found in repository

examples/ecs/send_and_receive_events.rs (line 63)

fn read_and_write_different_event_types(mut a: EventWriter<A>, mut b: EventReader<B>) {
    for _ in b.read() {}
    a.send(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.send(DebugEvent {
        resend_from_param_set: false,
        resend_from_local_event_reader: false,
        times_sent: 1,
    });
    events.send(DebugEvent {
        resend_from_param_set: true,
        resend_from_local_event_reader: false,
        times_sent: 1,
    });
    events.send(DebugEvent {
        resend_from_param_set: false,
        resend_from_local_event_reader: true,
        times_sent: 1,
    });
    events.send(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().send(event);
    }
}

examples/app/custom_loop.rs (line 33)

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

examples/async_tasks/external_source_external_thread.rs (line 52)

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

examples/ecs/event.rs (lines 45-47)

fn event_trigger(
    time: Res<Time>,
    mut state: ResMut<EventTriggerState>,
    mut my_events: EventWriter<MyEvent>,
    mut play_sound_events: EventWriter<PlaySound>,
) {
    if state.event_timer.tick(time.delta()).finished() {
        my_events.send(MyEvent {
            message: "MyEvent just happened!".to_string(),
        });
        play_sound_events.send_default();
    }
}

examples/ecs/ecs_guide.rs (line 133)

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.send(AppExit::Success);
    } else if game_state.current_round == game_rules.max_rounds {
        println!("Ran out of rounds. Nobody wins!");
        app_exit_events.send(AppExit::Success);
    }
}

examples/audio/pitch.rs (line 53)

fn keyboard_input_system(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut frequency: ResMut<PitchFrequency>,
    mut events: EventWriter<PlayPitch>,
) {
    if keyboard_input.just_pressed(KeyCode::ArrowUp) {
        frequency.0 *= 2.0f32.powf(1.0 / 12.0);
    }
    if keyboard_input.just_pressed(KeyCode::ArrowDown) {
        frequency.0 /= 2.0f32.powf(1.0 / 12.0);
    }
    if keyboard_input.just_pressed(KeyCode::Space) {
        events.send(PlayPitch);
    }
}

Additional examples can be found in:

• examples/games/desk_toy.rs
• examples/games/game_menu.rs
• examples/window/low_power.rs
• examples/input/gamepad_rumble.rs
• examples/ui/size_constraints.rs

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.

Examples found in repository

examples/app/log_layers_ecs.rs (line 41)

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.send_batch(receiver.try_iter());
}

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.

Examples found in repository

examples/ecs/event.rs (line 48)

fn event_trigger(
    time: Res<Time>,
    mut state: ResMut<EventTriggerState>,
    mut my_events: EventWriter<MyEvent>,
    mut play_sound_events: EventWriter<PlaySound>,
) {
    if state.event_timer.tick(time.delta()).finished() {
        my_events.send(MyEvent {
            message: "MyEvent just happened!".to_string(),
        });
        play_sound_events.send_default();
    }
}

examples/games/breakout.rs (line 380)

fn check_for_collisions(
    mut commands: Commands,
    mut score: ResMut<Score>,
    mut ball_query: Query<(&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.single_mut();

    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 {
            // Sends a collision event so that other systems can react to the collision
            collision_events.send_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;
            }
        }
    }
}

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 apply_deferred.

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,