Connect to a world

-- rt = client.realtime. Callbacks via rt:on(mapped_name, fn); the wire world.tick maps to "world_tick".
rt:on("world_tick", function(frame)
	print("snapshot/delta, tick=" .. tostring(frame.tick))
end)

rt:on("world_joined", function(info)
	print("joined world " .. tostring(info.world_id))
end)

rt:join_world(world_id, function(ok, err)
	if not ok then print("join failed: " .. tostring(err)) end
end)

# Asobi.realtime autoload. Signals use underscores; connect them before world_join.
Asobi.realtime.world_tick.connect(_on_world_tick)
Asobi.realtime.world_joined.connect(_on_world_joined)
Asobi.realtime.world_join(world_id)

func _on_world_tick(payload: Dictionary) -> void:
	print("tick ", payload.get("tick"))

func _on_world_joined(payload: Dictionary) -> void:
	print("joined ", payload.get("world_id"))

// Events on client.Realtime; handlers get the raw JSON envelope string, which you parse. WorldJoinAsync returns a Task<string> ack.
client.Realtime.OnWorldTick += rawJson => Debug.Log($"tick: {rawJson}");
client.Realtime.OnWorldJoined += rawJson => Debug.Log($"joined: {rawJson}");

string ack = await client.Realtime.WorldJoinAsync(worldId);

// Dynamic multicast delegates on UAsobiWebSocket. Handlers must be UFUNCTIONs. OnWorldTick delivers the tick number and the updates as a JSON string; OnWorldJoined delivers a typed FAsobiWorldInfo.
WebSocket->OnWorldTick.AddDynamic(this, &UMyClass::HandleWorldTick);
WebSocket->OnWorldJoined.AddDynamic(this, &UMyClass::HandleWorldJoined);
WebSocket->WorldJoin(WorldId);

// UFUNCTION() void HandleWorldTick(int64 Tick, const FString& UpdatesJson);
// UFUNCTION() void HandleWorldJoined(const FAsobiWorldInfo& Info);

// Broadcast streams on client.realtime. onWorldTick yields a typed WorldTick; onWorldJoined yields a Map. joinWorld returns a Future<Map>.
client.realtime.onWorldTick.stream.listen((WorldTick tick) {
  print('tick ${tick.tick}');
});

client.realtime.onWorldJoined.stream.listen((Map<String, dynamic> info) {
  print('joined ${info['world_id']}');
});

await client.realtime.joinWorld(worldId);

// asobi.websocket(...) uses raw wire event names (dots). Join is an awaited RPC via send.
ws.on("world.tick", (payload) => console.log("tick", payload.tick));
ws.on("world.joined", (payload) => console.log("joined", payload.world_id));

const reply = await ws.send("world.join", { world_id });

-- client.realtime with mapped callback names, one callback per event. LOVE needs a manual pump: call client.realtime:update() every frame from love.update, or no callbacks fire.
client.realtime:on("world_tick", function(frame)
	print("tick " .. tostring(frame.tick))
end)

client.realtime:on("world_joined", function(info)
	print("joined " .. tostring(info.world_id))
end)

client.realtime:join_world(world_id)

-- in love.update(dt):
--   client.realtime:update()