Animation Graphs, Cheatbooks, and Googly Eyes

I'm doing an experiment by building tools to create a Voxel Game, which will be highly customizable and rich in features. I have a whole bunch of ideas, that i haven't seen anywhere yet, and i'm curious if it works out. The goal is to make a game, that is a lot of fun, and gives unique experiences, but at the same time makes it possible to be extended by you. The initial implementation will be called The Artifact Project

The floors start out as 2d polygons, which are then triangulated using earcut and the 3d geometry generated in a compute task. The different floor surface types are determined by schematics/aspects which are defined in JSON. If you look closely you can see that there are black outlines which are rendered by a custom outline shader.

The goal here is to recreate the look and feel of isometric tile games from the early 2000s (think Ultima), except that the "tiles" are actually 3d models and there's actually perspective.

Some great commentary in the Discord thread here. From "why Bevy" to an entire game soundtrack, to a link to the floor mesh generation code.

Uses bevy_editor_pls to add doodad placement for objects like trees.

Snake is a classic game to build to learn a new engine and this is another one!

Some game jam progress from a couple days of work. Not much info so enjoy the visuals.

The game developer for this one has been learning Rust for about a week and built this retro-like game as a result of that work. They're planning to both continue to work on it and open source it some time in the future.

Tiny Death Star is a pixel-art Death Star (the Star Wars kind) simulator/manager.

This is another audio demo, so check out the Discord thread to hear the multiple wonderful demos.

rougepush is a game jam game made for the 7-day roguelike challenge.

• Play it on Itch.io
• Source is available on GitHub.

Well known game asset creator kenney released some googly eyes which immediately got used to create an example desk toy widget. This example got upgraded into an the official desk-toy example in the Bevy repo.

The desk-toy example shows off some interesting usage of window transparency to achieve the effect of a floating Bevy logo with googly eyes on top of other windows. You can drag the logo around and generally play with it.

Armatures (also known as bones) can be used for many different kinds of entities, not just "people shaped". @cake built a new plugin to make dealing with armature setups in Bevy easier to use.

They're looking for feedback, so check this out and let them know how it works for you in the Discord thread

#[derive(Component, Armature, Reflect, InspectorOptions)]
#[reflect(InspectorOptions)]
#[armature_path("Armature")]
pub struct MyTurretArmature {
    #[armature_path("Bone")]
    pub base: Entity,
    #[armature_path("Bone", "Bone.Neck", "Bone.Head")]
    pub head: Entity,
    #[armature_path("Bone.Head.Target.IK")]
    pub target_ik: Entity,
}

Tiny Glade is extremely heavy on procedural generation, which is well-known to be resource intensive. This level of resource-intensive usage at the time of loading can cause stutters as the game loads and generates. This approach uses a second Bevy App to basically make the loading screen a separate process, isolated from the resource-intensive usage, resulting in a smooth loading indicator.

This approach is fairly unique to Tiny Glade, as Tiny Glade has been around since Bevy 0.6 and they have rendering professionals working on it who wanted things done in specific ways.

Tiny Glade uses a custom renderer and asset system. The bevy builtin asset system does have async loading of assets and it's possible to implement a loading screen without using this 2 app technique. With that said, it still has some pitfalls and this solution could still make sense even in a game that uses the bevy asset system

• IceSentry

There's a lot of great discussion about different rendering APIs, how to get started in rendering, as well as discussion of this technique in particular and why it exists like it does.

spawned random sized, random positioned rectangles, then connected them with corridors by minimum spanning tree

Moar Ants! (itch) is a clicker-inspired ant colony simulation.

Source is available on GitHub under the Polyform Strict license,

Click to assemble! Its almost as easy as IKEA!

Deltarune fangame. New work here includes the pause menu and an animation system that can load animations from .ron files.

The animation got moved into a repository on Codeberg called bevy_sprite_anim and it includes an example of loading the .ron files.

Boris gets click+drag voxel building. Source for Boris is available under MIT on GitHub

A Gomoku implementation with capture rules. You can Play Online on Itch against a programmed AI. (I definitely lost my first game).

A baked custom normal map from Blender combined with a small StandardMaterial extension shader results in this painterly tree scene. If you like this result, check out some of the inspiration for your own work as well.

Jarl is a Fantasy Colony Builder with some amazing 2d lighting systems (which are available to use separately!). This demo shows a system which can detect various kinds of indoor spaces such as rooms (yellow) and caves (red).

Check out their YouTube for devlogs and other videos.