Since we move more and more GUI into script, and also triggered by #723, I spent some thoughts on asynchronous scripts. The idea behind this is to run some scripts only at one host in the network and not for others (for example to create menus, HUD elements, etc.) but to still make it impossible for script to spoil the synchronization in network games. The basic idea is as follows:

We introduce an "Async" flag to C4Value. Engine functions specify for their parameter types whether they are allowed to be asynchronous and then on function call a corresponding typecheck is performed. If an engine function which requires a synchronous parameter is called with an async C4Value a runtime error occurs. However, in the other direction, async parameters are allowed to be called with synchronous C4Values. For example, RemoveObject() requires a synchronous this pointer, but GetName() only an asynchronous one. If GetName() is called with a synchronous C4Object though then it returns a synchronous string, otherwise an asynchronous one.

Next, objects (and, in the function pointer branch, also proplists I suppose) can be asynchronous. There should be an "Async" flag in C4Object. The this pointer returns a synchronous C4Value for both synchronous objects and asynchronous objects. There will be a new function CreateAsyncObject to create asynchronous objects. The FindObject* family of functions will either have a new Find_Async flag which allows them to return asynchronous objects, or there will be a new FindAsyncObject* family of functions.

array/proplist access with [] or . return an asynchrous object if the array or proplist is asynchronous itself. array/proplist setters are only allowed to set asynchronous values if the array/proplist is asynchronous itself. This means synchronous objects are not allowed to have local asynchronous variables!

Whenever a conditional jump (if/while/for) is performed on an asynchronous C4Value, then every C4Value used in that block becomes automatically asynchronous -- even if that block is not even executed! This might actually be the most tricky part to implement, but the "Async" flag as such must stay synchronous!

Here is an example:

var i = 5, j = 7; // here, i is synchronous
var x = [1,2,3] // x is synchronous and so are x[0], x[1], x[2].
var y = x;
if(FindObjectAsync(Find_ID(Clonk))) // this is a condition on an async value!
{
  i = 6;
  FindObject(Find_ID(Clonk))->RemoveObject(); // fails because FindObject() returns an async object within the if() block
  CreateObject(Clonk); // fails because the this pointer is async within the if() block.
  x[3] = 5; // fails, because x is asynchronous but points to a synchronous array. For the synchronous array, it is not allowed to set an asynchronous value (even "5" in an if(<async condition>) block is asynchronous).
}
bla(x, y, i, j); // here, i and x are asynchronous. j and y are not, and neither is the array pointed to by x and y.
bla2(x[2], i); // even though x[2] is synchronous, the array getter returns an asynchronous value because x became asynchronous
bla3(y[2], i); // works because y is synchronous.
x[3] = 2; // works, but x stays asynchronous
FindObject(Find_ID(Clonk))->RemoveObject(); // works

In addition, there can be asynchronous engine callbacks. Such callbacks will always be called in an asynchronous context, i.e. as if they were within a if(<async condition>) block. Examples for such callbacks include mouse
hovering or drag+drop feedback. There should also be a callback similar to InitializePlayer for every player at the local client.

For records, I suggest to record every asynchronous callback that was performed, plus its parameters. This allows in records to view local players including their HUD and so on, but not the HUD, menus etc. of remote players (simply because that information is no longer available at all).

Feedback by both scripters and engine developers is highly welcome. Would such an interface be suitable for creating even more awesome GUIs in script? Do you see any way how obtaining different non-Async C4Values on different machines if this feature were implemented this way?

Edit: Changed the semantics of the example.

Just on a side-note: We already have asynchronous stuff... String tables. I already tripped into that one.