Struct MessageMutator 

pub struct MessageMutator<'w, 's, M>
where
    M: Message,
{ /* private fields */ }

Reads and writes Messages of type T, keeping track of which messages have already been read.

This can be used if a system needs to both read and write messages of the same type.

Since it has exclusive access to the underlying messages, it also permits messages to be modified as they are read. This is ideal for chains of systems that all want to modify the same messages.

Usage

MessageMutators are usually declared as a SystemParam.

#[derive(Message, Debug)]
pub struct MyMessage(pub u32); // Custom message type.
fn my_system(mut mutator: MessageMutator<MyMessage>) {
    // This message will be read immediately by this system,
    // and will then be visible to other systems.
    mutator.write(MyMessage(0));
    for message in mutator.read() {
        message.0 += 1;
        println!("received message: {:?}", message);
    }
    // This message will be read on the next run of this system,
    // but will be visible immediately to other systems.
    mutator.write(MyMessage(0));
}

Concurrency

Multiple systems with MessageMutator<T> of the same message type can not run concurrently. They also can not be executed in parallel with MessageReader or MessageWriter.

Clearing, Reading, and Peeking

Messages are stored in a double buffered queue that switches each frame. This switch also clears the previous frame’s messages. Messages should be read each frame otherwise they may be lost. For manual control over this behavior, see Messages.

Most of the time systems will want to use MessageMutator::read(). This function creates an iterator over all messages that haven’t been read yet by this system, marking the message as read in the process.

Implementations

impl<'w, 's, M> MessageMutator<'w, 's, M>

where M: Message,

pub fn read(&mut self) -> MessageMutIterator<'_, M>

Iterates over the messages this MessageMutator has not seen yet. This updates the MessageMutator’s message counter, which means subsequent message reads will not include messages that happened before now.

Examples found in repository

examples/ecs/message.rs (line 58)

fn apply_extra_damage(mut dmg_messages: MessageMutator<DealDamage>) {
    let mut extra = Vec::new();
    for message in dmg_messages.read() {
        if message.amount >= 10 {
            extra.push(DealDamage {
                amount: message.amount / 10,
            });
        }
    }
    // Note that this system will read messages it wrote itself!
    // These are written after the `read()`, so they will be read the next time it runs.
    for message in extra {
        dmg_messages.write(message);
    }
}

// This system mutates the 'DealDamage' messages to apply some armor value
// It also sends an 'ArmorBlockedDamage' message if the value of 'DealDamage' is zero
//
// Messages are mutated using an 'MessageMutator<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
// 'MessageReader', 'MessageWriter', and 'MessageMutator' in a given system, as long as the types (T) are different.
fn apply_armor_to_damage(
    mut dmg_messages: MessageMutator<DealDamage>,
    mut armor_messages: MessageWriter<ArmorBlockedDamage>,
) {
    for message in dmg_messages.read() {
        message.amount -= 1;
        if message.amount <= 0 {
            // Zero-sized messages can also be sent with 'send'
            armor_messages.write(ArmorBlockedDamage);
        }
    }
}

pub fn read_with_id(&mut self) -> MessageMutIteratorWithId<'_, M>

Like read, except also returning the MessageId of the messages.

pub fn par_read(&mut self) -> MessageMutParIter<'_, M>

Available on crate feature multi_threaded only.

Returns a parallel iterator over the messages this MessageMutator has not seen yet. See also for_each.

Example

#[derive(Message)]
struct MyMessage {
    value: usize,
}

#[derive(Resource, Default)]
struct Counter(AtomicUsize);

// setup
let mut world = World::new();
world.init_resource::<Messages<MyMessage>>();
world.insert_resource(Counter::default());

let mut schedule = Schedule::default();
schedule.add_systems(|mut messages: MessageMutator<MyMessage>, counter: Res<Counter>| {
    messages.par_read().for_each(|MyMessage { value }| {
        counter.0.fetch_add(*value, Ordering::Relaxed);
    });
});
for value in 0..100 {
    world.write_message(MyMessage { value });
}
schedule.run(&mut world);
let Counter(counter) = world.remove_resource::<Counter>().unwrap();
// all messages were processed
assert_eq!(counter.into_inner(), 4950);

pub fn len(&self) -> usize

Determines the number of messages available to be read from this MessageMutator without consuming any.

pub fn is_empty(&self) -> bool

Returns true if there are no messages available to read.

Example

The following example shows a useful pattern where some behavior is triggered if new messages are available. MessageMutator::clear() is used so the same messages don’t re-trigger the behavior the next time the system runs.

#[derive(Message)]
struct Collision;

fn play_collision_sound(mut messages: MessageMutator<Collision>) {
    if !messages.is_empty() {
        messages.clear();
        // Play a sound
    }
}

pub fn clear(&mut self)

Consumes all available messages.

This means these messages will not appear in calls to MessageMutator::read() or MessageMutator::read_with_id() and MessageMutator::is_empty() will return true.

For usage, see MessageMutator::is_empty().

pub fn write(&mut self, message: M) -> MessageId<M>

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

See Messages for details.

Examples found in repository

examples/ecs/message.rs (line 68)

fn apply_extra_damage(mut dmg_messages: MessageMutator<DealDamage>) {
    let mut extra = Vec::new();
    for message in dmg_messages.read() {
        if message.amount >= 10 {
            extra.push(DealDamage {
                amount: message.amount / 10,
            });
        }
    }
    // Note that this system will read messages it wrote itself!
    // These are written after the `read()`, so they will be read the next time it runs.
    for message in extra {
        dmg_messages.write(message);
    }
}

pub fn write_batch( &mut self, messages: impl IntoIterator<Item = M>, ) -> WriteBatchIds<M>

Writes a list of messages all at once, which can later be read by MessageReaders. This is more efficient than writing each message individually. This method returns the IDs of the written messages.

See Messages for details.

pub fn write_default(&mut self) -> MessageId<M>

where M: Default,

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

See Messages for details.

Trait Implementations

impl<'w, 's, M> Debug for MessageMutator<'w, 's, M>

where M: Debug + Message,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'w, 's, M> ReadOnlySystemParam for MessageMutator<'w, 's, M>

where M: Message, Local<'s, MessageCursor<M>>: ReadOnlySystemParam, ResMut<'w, Messages<M>>: ReadOnlySystemParam,

impl<M> SystemParam for MessageMutator<'_, '_, M>

where M: Message,

type State = FetchState<M>

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

type Item<'w, 's> = MessageMutator<'w, 's, M>

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, ) -> <MessageMutator<'_, '_, M> as SystemParam>::State

Creates a new instance of this param’s State.

fn init_access( state: &<MessageMutator<'_, '_, M> as SystemParam>::State, system_meta: &mut SystemMeta, system_access: &mut SystemAccess, world: &mut World, )

Registers any World access used by this SystemParam.

fn apply( state: &mut <MessageMutator<'_, '_, M> 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 <MessageMutator<'_, '_, M> as SystemParam>::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

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

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

Creates a parameter to be passed into a SystemParamFunction.