Module bevy_ecs::system

Expand description

Tools for controlling behavior in an ECS application.

Systems define how an ECS based application behaves. They have to be registered to a SystemStage to be able to run. A system is usually written as a normal function that will be automatically converted into a system.

System functions can have parameters, through which one can query and mutate Bevy ECS state. Only types that implement SystemParam can be used, automatically fetching data from the World.

System functions often look like this:

fn update_score_system(
    mut query: Query<(&Player, &mut Score)>,
    mut round: ResMut<Round>,
) {
    for (player, mut score) in query.iter_mut() {
        if player.alive {
            score.0 += round.0;
        }
    }
    round.0 += 1;
}

System ordering

While the execution of systems is usually parallel and not deterministic, there are two ways to determine a certain degree of execution order:

System Stages: They determine hard execution synchronization boundaries inside of which systems run in parallel by default.
Labeling: First, systems are labeled upon creation by calling .label(). Then, methods such as .before() and .after() are appended to systems to determine execution order in respect to other systems.

System parameter list

Following is the complete list of accepted types as system parameters:

Query
Res and Option<Res>
ResMut and Option<ResMut>
Commands
Local
EventReader
EventWriter
NonSend and Option<NonSend>
NonSendMut and Option<NonSendMut>
&World
RemovedComponents
SystemChangeTick
Archetypes (Provides Archetype metadata)
Bundles (Provides Bundles metadata)
Components (Provides Components metadata)
Entities (Provides Entities metadata)
All tuples between 1 to 16 elements where each element implements SystemParam
() (unit primitive type)

Re-exports

pub use crate::change_detection::NonSendMut;

pub use crate::change_detection::ResMut;

Modules

lifetimeless

Structs

AlreadyWasSystem

ChainSystem

A System that chains two systems together, creating a new system that routes the output of the first system into the input of the second system, yielding the output of the second system.

CommandQueue

A queue of Commands

Commands

A list of commands that modify a World, running at the end of the stage where they have been invoked.

Despawn

EntityCommands

A list of commands that will be run to modify an entity.

ExclusiveSystemCoerced

ExclusiveSystemFn

FunctionSystem

The System counter part of an ordinary function.

GetOrSpawn