Broadcast queue

Note: When I originally wrote this module, I didn't know about BroadcastEventResultCode, which is really useful for just automatically retrying a broadcast when it gets throttled. All you have to do is this:

while Events.BroadcastToServer(...) == BroadcastEventResultCode.EXCEEDED_RATE_LIMIT do
	Task.Wait()
end

and it will automatically retry each frame until it doesn't encounter the rate limit exceeded result. If it works on the first try then it won't wait at all. I think this pattern should be used pretty much anywhere you ever use a broadcast, just so you know none are ever dropped.


Networked broadcasts currently have a limit of 10 per second. The client has a budget of 10 broadcasts per second to the server using BroadcastToServer, and the server has a budget of 10 broadcasts to use between BroadcastToPlayer and BroadcastToAllPlayers.

If you send too many broadcasts too fast, though, they are not queued, they just disappear. In order to make the most of the broadcast budget, I've made this module to queue broadcasts and send them as soon as possible.

local isServerContext = pcall(Game.IncreaseTeamScore, 0, 0)

local broadcastThreshold = 10

local function fastSpawn(f)
	local connection
	connection = Events.Connect("fastSpawn", function()
		connection:Disconnect()
		f()
	end)
	Events.Broadcast("fastSpawn")
end

local broadcastQueue = {}
local timeline = {}
local queueing = false

local function queueBroadcast(...)
	broadcastQueue[#broadcastQueue+1] = {...}
	if not queueing then
		queueing = true
		fastSpawn(function()
			while #broadcastQueue > 0 do
				while timeline[1] and os.clock() - timeline[1] >= 1 do
					table.remove(timeline, 1)
				end
				if #timeline == broadcastThreshold then
					repeat
						Task.Wait()
					until os.clock() - timeline[1] >= 1
				end
				local data = table.remove(broadcastQueue, 1)
				local method = Events.BroadcastToServer
				if isServerContext then
					if type(data[1]) == "string" then
						method = Events.BroadcastToAllPlayers
					else -- the first argument is a Player object
						method = Events.BroadcastToPlayer
					end
				end
				while method(table.unpack(data)) == BroadcastEventResultCode.EXCEEDED_RATE_LIMIT do
					Task.Wait() -- automatically retry each frame if the budget is unexpectedly low
				end
				timeline[#timeline+1] = os.clock()
			end
			queueing = false
		end)
	end
end

return queueBroadcast, broadcastQueue

edit: fixed a mistake where method was determined in the wrong place
edit 2: modified the context detection to work properly for networked scripts and single-player preview mode
edit 3: now checking the return value of the broadcast function and automatically retrying if it exceeds the threshold

This module can be used on the client and the server. It determines which context it is running in in order to determine whether to use BroadcastToServer. If the first argument is a Player object rather than a string, it automatically uses BroadcastToPlayer instead of BroadcastToAllPlayers.

2 things are returned, the first is the function queueBroadcast and the second is a table that contains the arguments of all of the broadcasts that are still in the queue in case you want to modify/cancel them before they're sent.

The first argument to queueBroadcast is the name of the event, unless you want to invoke BroadcastToPlayer, in which case the Player is the first argument and the event name is the second argument. The remaining arguments are sent through the broadcast and follow the same restrictions as the functions in the docs.

The way this works is, a table of timestamps of each broadcast is kept. Times that are 1 second or older are removed. If the number of timestamps in the table is equal to the threshold then Task.Wait() is called repeatedly until the oldest timestamp was 1 second ago, and then the next broadcast is sent. The loop only runs while there are broadcasts queued.

It's important that this module is the only thing in the game that uses broadcasts, otherwise it can't know the remaining broadcast budget and can exceed the limit if there is something else doing broadcasts while many are being queued. edit: Checking the return value allows for automatically retrying, so this will no longer fail when other things use the broadcast budget.

4 Likes