Struct bevy::ecs::prelude::Schedules

pub struct Schedules {
    pub ignored_scheduling_ambiguities: BTreeSet<ComponentId>,
    /* private fields */
}

Resource that stores Schedules mapped to ScheduleLabels excluding the current running Schedule.

Fields

ignored_scheduling_ambiguities: BTreeSet<ComponentId>

List of ComponentIds to ignore when reporting system order ambiguity conflicts

Implementations

impl Schedules

pub fn new() -> Schedules

Constructs an empty Schedules with zero initial capacity.

pub fn insert(&mut self, schedule: Schedule) -> Option<Schedule>

Inserts a labeled schedule into the map.

If the map already had an entry for label, schedule is inserted, and the old schedule is returned. Otherwise, None is returned.

pub fn remove(&mut self, label: impl ScheduleLabel) -> Option<Schedule>

Removes the schedule corresponding to the label from the map, returning it if it existed.

pub fn remove_entry( &mut self, label: impl ScheduleLabel ) -> Option<(Interned<dyn ScheduleLabel>, Schedule)>

Removes the (schedule, label) pair corresponding to the label from the map, returning it if it existed.

pub fn contains(&self, label: impl ScheduleLabel) -> bool

Does a schedule with the provided label already exist?

pub fn get(&self, label: impl ScheduleLabel) -> Option<&Schedule>

Returns a reference to the schedule associated with label, if it exists.

Examples found in repository

examples/games/stepping.rs (line 118)

fn build_ui(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
    schedules: Res<Schedules>,
    mut stepping: ResMut<Stepping>,
    mut state: ResMut<State>,
) {
    let mut text_sections = Vec::new();
    let mut always_run = Vec::new();

    let Ok(schedule_order) = stepping.schedules() else {
        return;
    };

    // go through the stepping schedules and construct a list of systems for
    // each label
    for label in schedule_order {
        let schedule = schedules.get(*label).unwrap();
        text_sections.push(TextSection::new(
            format!("{:?}\n", label),
            TextStyle {
                font: asset_server.load(FONT_BOLD),
                font_size: FONT_SIZE,
                color: FONT_COLOR,
            },
        ));

        // grab the list of systems in the schedule, in the order the
        // single-threaded executor would run them.
        let Ok(systems) = schedule.systems() else {
            return;
        };

        for (node_id, system) in systems {
            // skip bevy default systems; we don't want to step those
            if system.name().starts_with("bevy") {
                always_run.push((*label, node_id));
                continue;
            }

            // Add an entry to our systems list so we can find where to draw
            // the cursor when the stepping cursor is at this system
            state.systems.push((*label, node_id, text_sections.len()));

            // Add a text section for displaying the cursor for this system
            text_sections.push(TextSection::new(
                "   ",
                TextStyle {
                    font: asset_server.load(FONT_MEDIUM),
                    font_size: FONT_SIZE,
                    color: FONT_COLOR,
                },
            ));

            // add the name of the system to the ui
            text_sections.push(TextSection::new(
                format!("{}\n", system.name()),
                TextStyle {
                    font: asset_server.load(FONT_MEDIUM),
                    font_size: FONT_SIZE,
                    color: FONT_COLOR,
                },
            ));
        }
    }

    for (label, node) in always_run.drain(..) {
        stepping.always_run_node(label, node);
    }

    commands.spawn((
        SteppingUi,
        TextBundle {
            text: Text::from_sections(text_sections),
            style: Style {
                position_type: PositionType::Absolute,
                top: state.ui_top,
                left: state.ui_left,
                padding: UiRect::all(Val::Px(10.0)),
                ..default()
            },
            background_color: BackgroundColor(Color::srgba(1.0, 1.0, 1.0, 0.33)),
            visibility: Visibility::Hidden,
            ..default()
        },
    ));
}

pub fn get_mut(&mut self, label: impl ScheduleLabel) -> Option<&mut Schedule>

Returns a mutable reference to the schedule associated with label, if it exists.

pub fn entry(&mut self, label: impl ScheduleLabel) -> &mut Schedule

Returns a mutable reference to the schedules associated with label, creating one if it doesn’t already exist.

pub fn iter( &self ) -> impl Iterator<Item = (&(dyn ScheduleLabel + 'static), &Schedule)>

Returns an iterator over all schedules. Iteration order is undefined.

pub fn iter_mut( &mut self ) -> impl Iterator<Item = (&(dyn ScheduleLabel + 'static), &mut Schedule)>

Returns an iterator over mutable references to all schedules. Iteration order is undefined.

pub fn configure_schedules( &mut self, schedule_build_settings: ScheduleBuildSettings )

Applies the provided ScheduleBuildSettings to all schedules.

pub fn allow_ambiguous_component<T>(&mut self, world: &mut World)

where T: Component,

Ignore system order ambiguities caused by conflicts on Components of type T.

pub fn allow_ambiguous_resource<T>(&mut self, world: &mut World)

where T: Resource,

Ignore system order ambiguities caused by conflicts on Resources of type T.

pub fn iter_ignored_ambiguities(&self) -> impl Iterator<Item = &ComponentId>

Iterate through the ComponentId’s that will be ignored.

pub fn print_ignored_ambiguities(&self, components: &Components)

Prints the names of the components and resources with info

May panic or retrieve incorrect names if Components is not from the same world

pub fn add_systems<M>( &mut self, schedule: impl ScheduleLabel, systems: impl IntoSystemConfigs<M> ) -> &mut Schedules

Adds one or more systems to the Schedule matching the provided ScheduleLabel.

pub fn configure_sets( &mut self, schedule: impl ScheduleLabel, sets: impl IntoSystemSetConfigs ) -> &mut Schedules

Configures a collection of system sets in the provided schedule, adding any sets that do not exist.

pub fn ignore_ambiguity<M1, M2, S1, S2>( &mut self, schedule: impl ScheduleLabel, a: S1, b: S2 ) -> &mut Schedules

where S1: IntoSystemSet<M1>, S2: IntoSystemSet<M2>,

Suppress warnings and errors that would result from systems in these sets having ambiguities (conflicting access but indeterminate order) with systems in set.

When possible, do this directly in the .add_systems(Update, a.ambiguous_with(b)) call. However, sometimes two independent plugins A and B are reported as ambiguous, which you can only suppress as the consumer of both.

Trait Implementations

impl Default for Schedules

fn default() -> Schedules

Returns the “default value” for a type.

impl Resource for Schedules

where Schedules: Send + Sync + 'static,