Emit signals async

[ValorZard]

Signals in Godot-rust are like 90% perfect to being perfect.
There’s already been lots of prior work done on async signals, but they are all around connecting them and receiving them.
There doesn’t seem to be much work done on EMITTING signals async.

The biggest problem I can think of is that usually &self is not send/sync, since Gd isn’t suited for multi threading. As such, there’s basically no way to spawn an async task within a function that emits a signal.

For example, this does not work (assume I am using https://github.com/2-3-5-41/godot_tokio )

impl Monster {
    // Can be invoked by other game systems.
    pub fn deal_damage(&mut self, amount: i32) {
        self.hitpoints -= amount;
        AsyncRuntime::spawn( async {
self.signals().damage_taken().emit(amount);
});
    }
}

I’ll be honest - not totally sure how to fix this. Maybe allow to clone a signal?

For the record: the current way to do this is to run your async tasks in the background, and poll on process() using channels. Once you receive something in the channel, you can emit a signal to let the other nodes that something happened. This is FINE, but it’s unwieldy and doesn’t feel very Godot.

[ColinWttt]

I haven’t used godot_tokio, but it’s possible to do this with godot.

        let mut self_gd = self.to_gd();

        let _task_handle = godot::task::spawn(async move {
             self_gd.signals().damage_taken().emit(amount);
        });

[Houtamelo]

If you're just looking for a solution:

https://github.com/Houtamelo/gdext_coroutines

node.start_async_task(
		async {
			smol::Timer::after(Duration::from_secs(10)).await;
			some_node.signals().damage_taken().emit(amount);
		});

[TitanNano]

@ValorZard to clarify, you want to spawn an async task and then emit a signal inside that task?

If yes, then the solution @ColinWttt wrote should work. (Note: godot::task is currently on master but unreleased)

[ValorZard]

The main problem is that these solutions only work with godot tasks. I'm doing stuff with tokio, and i can't do that inside of tokio::spawn()

[TitanNano]

I see. This stems from the fact that godot_tokio::AsyncRuntime::spawn requires a Send future and Gd<T> is not Send. So what you want is Gd<T> to be Send. This won't be possible anytime soon. Maybe #18 will help at some point.

godot::task was among other things designed to solve issues like this by allowing non Send futures. What does godot_tokio provide that you can't do with godot::task? Or is it just a matter of migrating from one to the other?

[Bromeon]

You might be interested in tokio::task::spawn_local().

Not sure if godot_tokio supports it, but given that most classes in Godot are not thread-safe, it might be a good idea.

[ValorZard]

(For context this is what I've been up to: https://github.com/ValorZard/godot-iroh-gossip-example )
The library I'm trying to integrate with godot is pretty heavily tokio based. I'm not TOTALLY sure if all of that will work with godot task? I guess I can try...

Basically, I've been trying to integrate this into godot: https://www.iroh.computer/docs/examples/gossip-chat

[TitanNano]

I don't think there is anything actionable in this issue.

[ValorZard]

yeah seems pretty clear signals can never be send sync cuz the gd smart pointer cant be (for now anyways)
closing issue