Custom Cursors, Picking, and Space games

bevy disjoint query filters (djqf) crate provides macros and a trait to generate disjoint query filters for Bevy queries. In a somewhat extreme example the following:

fn complex_system(
    a_query: Query<&mut Transform, (With<A>, Without<B>, Without<C>, Without<D>, Without<E>, Without<F>, Without<G>, ..., Without<Z>)>,
    b_query: Query<&mut Transform, (Without<A>, With<B>, Without<C>, Without<D>, Without<E>, Without<F>, Without<G>, ..., Without<Z>)>,
    ...,
    z_query: Query<&mut Transform, (Without<A>, Without<B>, Without<C>, Without<D>, Without<E>, Without<F>, Without<G>, ..., With<Z>)>,
) {
    // ...
}

can be reduced to

fn complex_system(
    a_query: Query<&mut Transform, <A as Disjoint>::Only>,
    b_query: Query<&mut Transform, <B as Disjoint>::Only>,
    ...,
    z_query: Query<&mut Transform, <Z as Disjoint>::Only>,
) {
    // ...
}

bevy_bsml is a markup language & implementation inspired by svelte and tailwindcss.

Create your own reusable components, and handle reactivity using BsmlClasses component in systems to add/remove classes. It's built on top of bevy_ui, so you can still use bevy_ui to manually interact with the ui node or styles.

(node) {
    (text) { "hello world" }
}

A library that allows the editing of non-reflect components via wrapper components, and serialization of these components via moonshine-save

A straightforward but robust input-action manager for Bevy. You can read the full release notes, but the highlights are:

• clear separation of buttonlike, axislike and dual-axislike inputs and actions. No more wondering what it means for an analog stick to be pressed!
• fully extensible trait-based definition of user input kinds. Ever wanted to add VR support? Touch? Electric guitar? Now you can!
• powerful axis / dual axis processors: invert controls, scale axes, create deadzones and more!
• fixed time step support: safely and reliably check the action values in FixedUpdate.
• better action disabling: bug-free* support for 4 disabling actions at 4 different levels of granularity.

Rotate entities even through hierarchies:

bevy_htnp provides Hierarchical Task Network Planning.

Hierarchical Task Networks are characterized by having a concrete set of specific primitive tasks that can be compounded into a sequence that affects the world around them. Because of bevy using ECS, individual task primitives can be modeled with a simple, and standard, bevy system. This plugin handles the heavy lifting of organizing those task primitives, loading and unloading specific components associated with those primitives, and cleaning up if something goes wrong.

bevy_gizmo_log lets you render gizmos through logging:

debug!(gizmo = arrow(Vec3::ZERO, Vec3::ONE, RED));

bevy_simple_text_input gains a few features in 0.9 including integration with Observers, new navigation shortcuts, and improvements to multiple active input support.

"Bailing" is defined by this tiny_bail as an error-handling pattern that takes the middle path between unwrap and ?:

• Compared to unwrap: Bail will return, continue, or break instead of panicking.
• Compared to ?: Bail will log or ignore the error instead of propagating it.

tiny_bail tries to optimize the act of writing let-else conditions like this:

let Ok(x) = query.get_single() else {
    warn!("query requires exactly one result");
    return;
}

using macros

*or_return!(list.last_mut()) += 1;

tiny_bail 0.2 adds support for break variation macros.

bevy_mod_reqwest helps when trying to use reqwest with bevy, without having to deal with async stuff, and it works on both web and and native.

It now allows reacting to errors of the http requests using observer-style callback patterns

    client
        // Sends the created http request
        .send(reqwest_request)
        // The response from the http request can be reached using an observersystem
        .on_response(|trigger: Trigger<ReqwestResponseEvent>| {
            let response = trigger.event();
            let data = response.as_str();
            let status = response.status();
            // let headers = req.response_headers();
            bevy::log::info!("code: {status}, data: {data:?}");
        })
        // In case of request error, it can be reached using an observersystem
        .on_error(|trigger: Trigger<ReqwestErrorEvent>| {
            let e = &trigger.event().0;
            bevy::log::info!("error: {e:?}");
        });