Ludum Dare, Nannou, and esp32s

A gizmo for directional lights with mouse drag control support.

This week we get a Steam release for GLOW, a physics-based arcade game where you have to avoid colliders.

In Path of Summoner, you take the role of a summoner tasked with saving the world from dangerous monsters. Within your dungeon, you possess a summoning circle, where you can combine ingredients to summon minions. These summoned creatures will aid you in combat. However, if they all die, monsters will get you.

Playable on Itch.io

This YouTube video show off running Bevy on an ESP32 microcontroller. Specifically the ESP32-S3-WROOM-1-N16R8 in coordination with a behavioral crate called beet.

Source is available on GitHub

Continuous Collision Detection is a problem domain that addresses potential tunneling in physics simulations. Tunneling is loosely speaking when an object is moving so fast that its discrete steps miss collisions on its path that would've otherwise occurred.

This implementation is similar to Jolt's CCD, performing time-of-impact queries from the previous position to determine whether collisions were missed, and if so, moving the bodies back to the time of impact.

Nannou, the Rust creative coding framework, is replacing their backend with Bevy and making great progress. These demos show off some of what is and what will be possible.

For me, the biggest takeaway from this showcase is that Nannou and Bevy are coexisting well and the future seems very bright.

The discord thread contains a lot more information and some extra screenshots that show off what code could look like, including defining noise and post-processing shaders inline.

This web-based particle editor is great for playing with values that can feed back into bevy_enoki. You can export and import your ron settings, upload textures and write a fragment shader live.

An experiment to build animations through using composable combinators. Code is posted in the Discord thread

3k entities, playing skinned animations, all doing astar pathfinding, and plenty of FPS headroom left over

A 2d prototype for a future 3d implementation of wave function collapse as part of a smooth voxel game.

Combine bevy_minibuffer and bevy_defer to start, stop, and set the speed for a cube using commands.

/// Stop the cube spinning. No input.
fn stop(mut query: Query<&mut Rotatable>) {
    let mut r = query.single_mut();
    r.speed = 0.0;
}

/// Set the speed of the spinning cube with input.
fn speed(
    mut minibuffer: Minibuffer,
    query: Query<Entity, With<Rotatable>>,
) -> impl Future<Output = Result<(), Error>> {
    let id = query.single();
    async move {
        let speed = minibuffer
            .prompt(Number::new("speed:"))
            .await?;
        let world = world();
        world
            .entity(id)
            .component::<Rotatable>()
            .set(move |r| r.speed = speed)
            .await?;
        Ok(())
    }
}

The people behind the Compass Map Editor are working on a game using their editor and have taken advantage of the pathfinding crate in this demo.

This demo is an "infinite" version of pong that plays itself. It explores the ability of bevy_ecs_tilemap to individually address tile entities, and takes advantage of bevy_xpbd_2d for colliders, collision layers, and ball movement.

Source is available on GitHub and a video diving into the code is available on YouTube.

The beginnings of a 2d fighting game with a 3d representation. The demo is a tool to edit the timeline of the animation playback position and location information assuming 60fps. The animations are currently from mixamo for prototyping purposes and will be changed out in future versions.

bevy_quinnet powers this multiplayer demo. It uses an authoritative server with client-side prediction to power wizards throwing fireballs and shooting bows back and forth.

This demo showcases in-progress work integrating sickle_ui and bevy_cobweb.

Eternal Battle in the Hells, or something is a ludum dare entry about drawing shapes.

You can view some of the gameplay on YouTube or play it for yourself on ldjam.com.

Summoner Chess is an auto-battler where you choose your pieces and then see how they perform.

Available to play on ldjam.com.

Another Ludum Dare entry. This one requires you to extend your pieces until they "match three" with the red souls on the board. When matching, you get additional souls to use which allows you to match further away on the board.

The author notes it may be better to play on itch.io rather than on ldjam.com.

These skyboxes are the result of an automatic direct hdr to skybox, specular, and diffuse map pipeline. This results in being able to grab any HDRi for Blender and use it in Bevy immediately.

It looks like the author is working on making it "bevy compatible" in the way it would need to be to be merged into Bevy itself, so we'll see where that goes in the future.

This top down shooter added persistent bullet casings as well as some audio to go along with it.

Simulate logic gates with bevy_logic.