Project Harmonia

Finished adding undo/redo functionality for all game actions. All logic is also networked using bevy_replicon 🙂

Next, I’m planning to work on house-building to create cities. I planning to implement apartment buildings first.

If you know any games where you can build apartments - let me know. Looking at prior art always helps!

When I migrated my game to bevy_enhanced_input, I added gamepad support. I figured it’d be fun to see if the game could run on a device like this.

It's a pocketable handheld with SD865 running Android and only 960p display. But making it work was surprisingly easy - just needed to tweak Cargo.toml and my main function.

However, there's a catch: GilRs, the input library Bevy uses, doesn’t support Android 😢 So, for now, I can only rely on touch controls, which I’ll properly support later.

Just wanted to tinker with it a little bit. Not very useful for the game at this stage, but since it's a hobby project, sometimes I just need to do something fun to stay motivated for bigger tasks.

Working on my game right now and making adjustments to the API along the way. This release allows attaching modifiers and conditions to sets and improves the ergonomics of the Negate modifier.

📜Full changelog 📦bevy_enhanced_input

It’s a crate for server-authoritative networking. We use it for Project Harmonia, but it's general-purpose.

This release, I focused on improving the API for potential rollback crates. We now have full world access in writing functions, a way to reliably check for update messages (optional and needs to be enabled by rollback crates since it costs a little more traffic), and events to react nicely to confirmed ticks.

Currently, there is only one crate in development by another developer that implements a Rocket League rollback style, which is great for physics-based games. But it would be useful to have a "classic" rollback crate, which is better suited for shooters, so maybe we’ll see more rollback crates in the future!

I also improved the serialization. Replication messages are now more compact thanks to variable integer encoding, while still using a single buffer for performance.

Next I planning to focus on the game, just needed to address some feedback for my crates 🙂

📜Full changelog 📦bevy_replicon

It's a crate for dynamic and contextual input mappings for Bevy, inspired by Unreal Engine Enhanced Input.

Some highlights:

• Action events now have statically known types (bool, f32, Vec2 or Vec3), depending on the action configuration.
• Assigning inputs, modifiers, and conditions now works like Bevy systems: you can pass multiple items in tuples.
• Binding presets now structs.
• Many ergonomic improvements for passing input.

I didn’t plan all of these, but a user suggested these ideas and contributed PRs for most of them! I couldn't resist 😅

I’ve drafted two releases:

• 0.3.0 includes all the improvements.
• 0.4.0 updates to Bevy 0.15.0.

This way, you can address the breaking changes in 0.3.0 before updating to Bevy 0.15.0, avoiding the need to handle everything at once.

📜Full changelog 📦bevy_enhanced_input

I've been working on bevy_replicon for the last two weeks. That's the networking library we use for the game.

Originally, I planned to make a small change to include the number of updates in the message (needed for prediction) but ended up completely reworking the serialization 😅 Typical me. This change improves message packaging. For example, in our statistics test, we use only 16 bytes for a test message instead of 33!

Okay, it's finally time to go back to the original change I wanted to make 😄

It's a crate for dynamic and contextual input mappings for Bevy, inspired by Unreal Engine Enhanced Input.

While porting my game, I made many improvements. Actually using the crate gave me a better perspective 😅

Here's a quick showcase from my game. Smooth movement now automatically done by built-in LerpDelta modifier.

Also notice how pressing Esc cancels object spawning first due to the context priority.

Pressed keys displayed via screenkey app.

I also refined controls and added proper gamepad support. But touchscreen is still required due to missing UI navigation in Bevy. And I need to add cursor control with sticks 😅

Now I planning to implement some important features for bevy_replicon.

📜Full changelog 📦bevy_enhanced_input

Migrating my game to bevy_enhanced_input and making some tweaks to the crate. I'll do another release once I finish.

Had to rewrite some game logic to adapt it to the observer pattern. Working with young engines like Bevy means constant rewrites 😭

But I love the power of ECS, everything is so decoupled. Combined with Rust’s strict type system, it makes the rewriting process a lot smoother. I think the engine has great potential!

It's a crate for dynamic and contextual input mappings for Bevy, inspired by Unreal Engine Enhanced Input.

I really like the UE approach and decided to bring it to Bevy.

Despite being the first release, it's packed with features:

• Map inputs from various sources (keyboard, gamepad, etc.) to gameplay actions like Jump, Move, or Attack.
• Assign actions to different contexts like OnFoot or InCar, which are regular components.
• Activate or deactivate contexts by simply adding or removing components.
• Control how actions accumulate input from sources and consume it.
• Layer multiple contexts on a single entity, controlled by priority.
• Apply modifiers to inputs, such as dead zones, inversion, scaling, etc., or create custom modifiers by implementing a trait.
• Assign conditions for how and when an action is triggered, like "hold", "tap", "chord", etc. You can also create custom conditions, such as "on the ground".
• React on actions with observers.

I've implemented everything from UE and even added some extras. The crate also has ~90% test coverage.

Finally released! Next up, I'll be migrating the game to use it. After it I will need to implement some requested features for bevy_replicon.

📦bevy_enhanced_input

Over the past two weeks, I have been working on an input management plugin.

LWIM crate is good, but I wanted to try a different approach inspired by the Unreal Engine Enhanced Input.

If you have never used it, I explained the approach in the README, where you can also find a link to UE's documentation.

I finished the implementation and added examples, but I still need to write tests and improve the documentation. Planning to release it soon and continue focusing on the game :)

https://github.com/projectharmonia/bevy_enhanced_input

It uses the novel Polyanya algorithm instead of the classical A*.

I faced a few issues during the migration, but the author helped me resolve them all. He even dumped the navmesh of the house I built in the game and created a test named after the project 😅

I also implemented skipping points that the agent has projected past to prevent jitter when multiple points are close to each other.

This week, I was fixing bugs (there were a lot!) and refactoring.

I finally migrated the game's physics from XPBD to Avian. The migration was seamless since we're only using it for picking, collision checking, and navigation for now 😅

It's worth noting that I also switched from Avian's global Position component to Bevy's relative Transform, as the global Position breaks when there are multiple cities.

I’ve finally added the ability to edit and remove previously spawned walls, along with an undo/redo system.

Implementing the undo/redo was a bit challenging. If a command spawns or despawns an entity, it needs to be tracked to update the history with the correct ID. Additionally, since the game is networked, I had to introduce the concept of pending history commands. These commands are only added to the history after server confirmation.

It’s a crate for server-authoritative networking. We use it for Project Harmonia, but it's general-purpose.

Some highlights:

• Added the ability to defer replication, which is useful for exchanging messages or downloading assets required by the server before replication starts.
• If there is any spawning, despawning, removal, or insertion, client events wait for replication. However, with this release, it can be disabled per event.
• Fixed entity mapping when a client event is buffering.

📜Full changelog 📦bevy_replicon

Got sick last week, finally back to the game. Working on undo/redo system. Continue replacing the old models. The old bench is on the left, and the new one is on the right.

Added initial support for roads, reusing some logic from the walls implementation.

Currently, I'm using segments for road creation, but I plan to add Bezier curves to allow for curved walls and roads. Maybe I should use Bezier curves even for straight lines 🤔

I also need to use a texture without road markings for connection islands and implement rounding for turns.

But wanted to share the current progress :)

Our game stylistic changed during the development and @YaraGardaria@toot.garden has decided to redo some old models :)

Old is on the left, new is on the right.

My wife just finished playground asset pack for the game :)

Here are the renders in Blender:

I found that Tonemapping::AcesFitted better fits the game aesthetic. With a little bit of bloom and an environment map, it looks much nicer.

My wife also made more placeable objects, and I finished refactoring into new features from Bevy 0.14. Substates are so convenient!

Added placeable carousel made by my wife.

I like how easy it is to integrate new objects when the logic for them is already written. All I need to do is add a metadata file in RON format and the object will be available in the game.

While I am refactoring the code to new features from Bevy 0.14, my wife continues making models.

I think Bevy can look attractive. However, I am still not fully satisfied with my lighting configuration and will come back to it later.

I took a small break to relax and publish my translation application under the KDE umbrella. I am waiting for the review process to finish, but the webpage is already available at https://apps.kde.org/crowtranslate.

Just added a children's ladder made by my wife and updated the game to Bevy 0.14. But I need some time to utilize the added features. Additionally, I added a lot of logging, it's so convenient in development!

It’s a crate for server-authoritative networking. We use it for Project Harmonia, but it's general-purpose.

This release adds support for Bevy 0.14.0 and includes features from the previous RC. I like Bevy's new release candidate process a lot!

But it will take some time for the messaging backends to update. The bevy_replicion_renet that I maintain needs the renet crate to be updated to Bevy 0.14 first.

📜Full changelog 📦bevy_replicon

I took a small break from developing Project Harmonia. But I planning to get back soon!

I last month I was asked to move my translation app under KDE umbrella. Since I'm a KDE fan, I couldn't refuse 😅

The migration is almost done, will draft a new release soon.

After that, I plan to return to the game development.

I didn't stop working on bevy_replicon, though :)

It’s a crate for server-authoritative networking.

We usually don't make breaking changes when a Bevy release is around the corner, but decided to make a small exception for this one :)

This release adds support for Bevy 0.14.0-rc.4 and splits the crate functionality by features. For example, for headless server you can disable client feature. By default all features, except diagnostics are enabled, so you have the same set of plugins as before. But most plugin authors will need to add default-features = false.

📜Full changelog 📦bevy_replicon