bevy_sequential_actions is a library for the Bevy game engine that aims to execute a list of actions in a sequential manner.

hikikones

Last update: Dec 22, 2022

Related tags

Overview

Bevy Sequential Actions

bevy_sequential_actions is a library for the Bevy game engine that aims to execute a list of actions in a sequential manner. This generally means that one action runs at a time, and when it is done, the next action will start, and so on until the list is empty.

Getting Started

An action is anything that implements the Action trait, and can be added to any Entity that contains the ActionsBundle. Each action must signal when they are finished, which is done by calling next_action on either Commands or ActionCommands.

use bevy::prelude::*;

use bevy_sequential_actions::*;

fn main() {
    App::new()
        .add_plugins(MinimalPlugins)
        .add_startup_system(setup)
        .add_system(wait)
        .run();
}

fn setup(mut commands: Commands) {
    // Create entity with ActionsBundle
    let id = commands.spawn_bundle(ActionsBundle::default()).id();

    // Add a single action with default config
    commands.add_action(id, WaitAction(1.0), AddConfig::default());

    // Add multiple actions with custom config
    commands
        .action_builder(
            id,
            AddConfig {
                // Add each action to the back of the queue
                order: AddOrder::Back,
                // Start action if nothing is currently running
                start: false,
                // Repeat the action         
                repeat: false,
            },
        )
        .push(WaitAction(2.0))
        .push(WaitAction(3.0))
        .submit();
}

struct WaitAction(f32);

impl Action for WaitAction {
    fn add(&mut self, actor: Entity, world: &mut World, _commands: &mut ActionCommands) {
        world.entity_mut(actor).insert(Wait(self.0));
    }

    fn remove(&mut self, actor: Entity, world: &mut World) {
        world.entity_mut(actor).remove::();
    }

    fn stop(&mut self, actor: Entity, world: &mut World) {
        self.remove(actor, world);
    }
}

#[derive(Component)]
struct Wait(f32);

fn wait(mut wait_q: Query<(Entity, &mut Wait)>, time: Res, mut commands: Commands) {
    for (actor, mut wait) in wait_q.iter_mut() {
        wait.0 -= time.delta_seconds();
        if wait.0 <= 0.0 {
            // Action is finished, issue next.
            commands.next_action(actor);
        }
    }
}

Examples

See the examples for more usage. Each example can be run with cargo run --example .

Example	Description
`basic`	Shows the basic usage of the library by adding a bunch of actions.
`stop`	Shows how to stop a running action, and then add a new action to the front of the queue.
`repeat`	Shows how to add actions that basically loop forever in the added order.
`demo`	A more comprehensive and practical example showcasing how this library can be used in a turn-based board game. Includes lots of custom actions that can be reused throughout the game.

Compatibility

bevy	bevy_sequential_actions
0.7	0.1

You might also like...

Proof-of-concept of getting OpenXR rendering support for Bevy game engine using gfx-rs abstractions

Introduction Proof-of-concept of getting OpenXR rendering support for Bevy game engine using gfx-rs abstractions. (hand interaction with boxes missing

52 Nov 14, 2022

A physics lib for the bevy game engine based on physme

physimple Physimple aims to be the simplest(and capable) physics engine(currently for bevy) WARNING Beware for breaking changes with each update for n

24 Oct 28, 2022

An immediate mode 2D drawing API for Bevy game engine

Bevy Canvas API prototype An unofficial immediate mode 2D drawing API for Bevy game engine. Check the documentation or the examples to know how to use

20 Apr 21, 2022

Simple RUST game with the Bevy Engine

Simple RUST Game using the Bevy Engine YouTube videos for this code base: Episode 1 - Rust Game Development tutorial from Scratch with Bevy Engine Epi

150 Jan 7, 2023

A vdom-free reactive UI lib for the bevy game engine

ui4 ui4 is my fourth major attempt at making a UI dataflow library for the Bevy game engine. More specifically, it's a vdom-less UI library which uses

48 Nov 28, 2022

Hanabi — a particle system plugin for the Bevy game engine.

Hanabi — a particle system plugin for the Bevy game engine

256 Dec 30, 2022

Brine is my attempt at writing a Minecraft client in Rust using the Bevy game engine.

Brine Brine is my attempt at writing a Minecraft client in Rust using the Bevy game engine. It's EXTREMELY work-in-progress. The thing that makes Brin

34 Dec 26, 2022

Bevy is a refreshingly simple data-driven game engine built in Rust

What is Bevy? Bevy is a refreshingly simple data-driven game engine built in Rust. It is free and open-source forever! WARNING Bevy is still in the ve

3 Jun 3, 2022

Utilities for creating strictly ordered execution graphs of systems for the Bevy game engine

bevy_system_graph This crate provides the utilities for creating strictly ordered execution graphs of systems for the Bevy game engine. Bevy Version S

19 Dec 2, 2022

Comments

Add parallel actions
This PR adds the ability to add a collection of actions that is treated as "one". This means that they all start and stop at the same time, and the actions queue will only advance when all actions are finished within the same frame.

commands .actions(agent) .add_many( ExecutionMode::Parallel, [ action_d.into_boxed(), action_e.into_boxed(), action_f.into_boxed(), ].into_iter() );

For this to work, this library now requires that you add the SequentialActionsPlugin to your app, as a system at the end of the frame now needs to check for all finished actions.

This PR also includes some internal rework and other stuff. The finish method has been removed in favor of using the new ActionFinished component on an agent. This approach composes well with other actions running in parallel. For short one-at-a-time actions the next method can still be used. The README file has been updated with examples.
opened by hikikones 0
Replace repeat bool with a `Repeat` enum
You can now specify how many times an action should repeat.

pub enum Repeat { Amount(u32), Forever, }

A value of Repeat::Amount(0) means it will repeat zero times, i.e. only run once as before when the repeat bool was set to false.
opened by hikikones 0

Add an anonymous action using a closure

commands
        .actions(actor)
        // Single closure for only the on_start method
        .add(
            |entity, _world: &mut World, commands: &mut ActionCommands| {
                // on_start
                commands.actions(entity).finish();
            },
        )
        // Tuple closure for both the on_start and on_stop methods
        .add((
            |entity, _world: &mut World, commands: &mut ActionCommands| {
                // on_start
                commands.actions(entity).finish();
            },
            |_entity, _world: &mut World, _reason| {
                // on_stop
            },
        ));

opened by hikikones 0

Releases(v0.6.0)

v0.6.0(Nov 15, 2022)
Changes:

Update to Bevy 0.9. (#55)

Add a collection of actions that run in parallel with the add_many method. The collection is treated as "one action", meaning that they all start and stop at the same time, and the action queue will only advance when all actions are finished within the same frame. For this to work, this library now requires that you add the SequentialActionsPlugin to your app, as a set of systems at the end of the frame now needs to check for all finished actions. The finish method has been removed, as declaring an action as finished is now done with the ActionFinished component on an agent. The explicit stop(reason) method has also been removed. (#45)

Add SequentialActionsPlugin::get_systems if you want to schedule the systems yourself. (#53)

Add actions! helper macro for creating a collection of boxed actions. (#47)

Add Repeat::None variant. (#50)

Add ActionsBundle::new method. (#52)

Rename ActionCommands::custom method to add. (#48)

Remove ActionMarker component. (#49)

Source code(tar.gz)
Source code(zip)
v0.5.0(Sep 8, 2022)
Changes:

Replace builder constructs for adding a list of actions with a simple add_many method that takes an iterator of boxed actions. Reversing the list before adding to the front is no longer needed. (#40)

Replace the repeat bool in AddConfig with a Repeat enum. You can now specify how many times an action should be repeated before it is permanently removed from the queue. A value of zero means that it will only run once. (#41)

Source code(tar.gz)
Source code(zip)
v0.4.0(Aug 19, 2022)
Changes:

Building a list of actions is now done through the builder method when modifying actions. (#28)

Add skip method for skipping the next action. (#30)

Add ActionMarker component to ActionsBundle. (#31)

Add an anonymous action using a closure. (#34)

Add custom method to ActionCommands for deferred World mutation after Action::on_start has been called. Used for modifying actions using World inside the Action trait. (#36)

Source code(tar.gz)
Source code(zip)
v0.3.0(Jul 30, 2022)
Changes:

Update to Bevy 0.8.

Remove the Action::remove trait method.

Rename Action::start method to Action::on_start.

Rename Action::stop method to Action::on_stop.

Add StopReason enum and use it as parameter in Action::on_stop method.

Rename action(entity) method to actions(entity) for modifying actions.

Source code(tar.gz)
Source code(zip)
v0.2.0(May 12, 2022)
Changes:

New simplified API for modifying actions.

Allow despawning an entity as its last action.

Rename Action::add to Action::start.

Source code(tar.gz)
Source code(zip)
v0.1.0(Apr 28, 2022)

First release! 🎉
Source code(tar.gz)
Source code(zip)