At what point does it get installed in jumpy, for example?

Lua-wasm is becoming an option again as kyren has revived her Lua-in-Rust project:

Cool.

Ah, it gets installed here: https://github.com/fishfolk/jumpy/blob/main/src/audio.rs

But the the sound playback is implemented in

session.rs

. Sounds that are sent from bones are actually played here: https://github.com/fishfolk/jumpy/blob/aad4856c3385f0979fbb4d3159a7c26bff5894ff/src/session.rs#L314

I've got to re-visit sound playback in the context of a clean integration with bones at some point.

The reason it wasn't just implemented in

bones_bevy_renderer

is because rollback network sessions might have different needs for audio handling and, for example, only play audio events if the inputs for that frame have been confirmed, or something like that.

I apparently didn't get to implementing any special audio playback handling, but it seems like it's worked fine so far.

Nice. I also know that someone managed to get some proof of concept of mlua with wasm working

Hiya ! First of all, love your work and everything that you made so far, it's honestly really impressive and inspiring. I'm very curious about

bones

, from what I gathered it's a wrapper around bevy that makes determinism and rollback super easy (which is absolutely awesome !). So if I understand correctly I can use any network type that I want ? I saw that you guys use

ggrs

for

Jumpy

but isn't at all ideal for me, I need something more like

renet

(suitable for 32+ players) And lastly, much less of a dealbreaker but still good to know, would I still be able to use

bevy-ecs-ldtk

easily with

bones

?

I'm also interested in that last point actually since I'm using it for Bomby, which I haven't even ported to bones yet since I've not been able to work on it for a while

I'll probably be looking into it quite soon though as my last exam is tomorrow, so I'll let you know how it goes if you haven't already had a look

Thanks !

Hey there!

Hey! So, since you want 32+ players, I guess you don’t really need rollback either? Do you need determinism?

Regarding networking, you could totally use

renet

or anything else, while bones was heavily motivated by the needs of determinism and snapshotting ( and hopefully modding eventually ), nothing forces you to use it.

And yeah, like Erlend said, I'm not sure if bones is helping you very much if you don't need the determinism or snapshots. ----

Regarding

bevy-ecs-ldtk

you may or may not be able to use it, directly, but I'll explain that more.

The way bones works is by having the deterministic bones world, and then using Bevy plugins to render that bones world.

In order to render a sprite, you create a bones entity with a

Sprite

component in the bones world, for example, and then the

BonesBevyRenderer

plugin for Bevy will find the sprite and render it.

You can make your one bones renderer plugins, though, to do any rendering that Bones doesn't come with, and that could include an LDtk map. So you could create a bones entity with a custom

LDtkMap

component, and then make a

BonesLdtkRenderer

plugin, that uses

bevy-ecs-ldtk

to render it, but you wouldn't get that two-way communication where it will create bones entities corresponding with the LDtk entities, etc. You'd lose a lot of the advantages of

bevy-ecs-ldtk

.

Since we optimize for modding, we defer to our in-built level editor for tiles painting. So while ldtk support is possible, it’s not really the recommended path.

I think I remember jumpy was using bevy\_ecs\_tilemap, which I would think would be incompatible with bones for the same reason. Does jumpy no longer use it?

I'm a few months behind in general

Yeah, we were using that, then we moved to [

bevy-simple-tilemap

](https://github.com/forbjok/bevy_simple_tilemap).

But bones has it's own API that you use in the game.

You pretty much can just create map layer entities, with a specific atlas texture, and then add tiles to that layer, and it will be rendered internally by

bevy-simpl-tilemap

, but that's hidden from the Bones world.

So the rendering is done for you, but you have to choose how to load the map.

We use Bone's YAML/JSON asset derive to define our own map file format that fits the needs of Jumpy.

( And sorry if I'm over-explaining some of this, I might be a little too wordy. )