Defining OnClientInvoke does not resume waiting calls to InvokeClient

[Anaminus]

On RemoteFunctions, if InvokeClient is called on the server, but OnClientInvoke was not defined on the target client, then the call to InvokeClient will never finish. The expected behavior is that, if InvokeClient is called, but OnClientInvoke is not yet defined, then the RemoteFunction will wait, and call it immediately after it has been defined.

It may be worth noting that the correct behavior occurs in the studio's Play Solo mode, which acts as both the server and a client.

[Anaminus]

It is also worth noting that the correct behavior occurs with InvokeServer and OnServerInvoke.

[Anaminus]

If you rely on this working correctly, then you can work around the bug by adapting the following example, which ensures that OnClientInvoke is defined before InvokeClient is called, by using a RemoteEvent.

-- the server
RemoteEvent.OnServerEvent:connect(function(player,message)
    if message == 'ClientReady' then
        -- The client is ready, so start doing stuff as usual.
        RemoteFunction:InvokeClient(player)
    end
end)

-- the client
function RemoteFunction.OnClientInvoke()
    -- Do normal stuff here
end

-- Everything is set up here, so tell the server that we're ready.
RemoteEvent:FireServer('ClientReady')

Compare this to how it would be done were this issue fixed:

-- the server
RemoteFunction:InvokeClient(player)

-- the client
function RemoteFunction.OnClientInvoke()
    -- Do normal stuff here
end

[zeux]

This is puzzling. We have a test that tests exactly this behavior - it issues a server -> client call from a game script, and then after some time forces the client to implement the OnClientInvoke - after this the first call succeeds.

Here's a snippet from the test:

Server-side code:

-- Now let's verify that latched function calls work
-- We need to first issue a function call (it will wait), then issue a call that prompts the client to subscribe (wow!)
local delayedDone = false

Spawn(function ()
    RBX_CHECK_EQUAL(workspace.FunctionDelayed:InvokeClient(player1), 42)
    delayedDone = true
end)

RBX_CHECK_EQUAL(delayedDone, false)

-- Ask the player 2 to subscribe - this should not trigger the response since we issued the call to player1
workspace.FunctionDelayedSubscribe:InvokeClient(player2)
wait(1)
RBX_CHECK_EQUAL(delayedDone, false)

-- Ask the player 1 to subscribe - that should do it; note that the response is immediate due to order of processing, so no need to wait
workspace.FunctionDelayedSubscribe:InvokeClient(player1)
RBX_CHECK_EQUAL(delayedDone, true)

Client-side code:

workspace:WaitForChild("FunctionDelayedSubscribe").OnClientInvoke = function ()
    function workspace.FunctionDelayed.OnClientInvoke()
        return 42
    end
end

Can you describe your test case in more detail?

[Anaminus]

Here's an example that reproduces the behavior. Tested with a Script in the ServerScriptService, and a LocalScript in the StarterGui. Used the studio's Start Server, followed by Start Player.

Server:

remote = Instance.new('RemoteFunction',Workspace)

Game.Players.PlayerAdded:connect(function(player)
    print("Calling InvokeClient")
    local result = remote:InvokeClient(player,'Hello')
    print("Result:",result)
end)

Client:

remote = Workspace:WaitForChild('RemoteFunction')

wait(5)

print("Defining OnClientInvoke")
function remote.OnClientInvoke(v)
    print("Received value:",v)
    return 'Hi there'
end
print("Defined OnClientInvoke")

[zeux]

The latching mechanism is working as expected; you're seeing a race that's related to PlayerAdded. Basically the PlayerAdded callback fires before player is configured for remote function processing; if you add wait(1) before InvokeClient, even with a very large wait in the client script the call succeeds.

I'll try to figure out if we can fix it.

[zeux]

This is fixed in our internal build; the fix will ship on 4/23 night.

[Anaminus]

Thank you for the fix!