There's not much to learn about automatons, they're relatively easy to understand (from your code you already know how to use them).
As for efficiency, automatons basically decide which "version" of the function will be called. There's no difference in efficiency between those two:
Code:
public some_function( ) < clients_in_game >
{ // ... }
public some_function( ) < > { }
Code:
public some_function( )
{
if( clients_in_game )
{
// ...
}
}
Because both ways work exactly the same. However, automatons would be probably better if you use more than one state.
As for your example, you're basically saving a native call since you're not unregistering the forward.
However, automatons or not, if you use the standard client_PreThink forward, it will still be called each frame for each client in the server. Therefore, the result will be
exactly the same for these two:
Code:
public client_PreThink( ) < PreThink: enabled >
{ // ... }
public client_PreThink( ) < PreThink: disabled > { }
public client_PreThink( ) < > { }
Code:
public client_PreThink( )
{
if( something )
{
// ...
}
}
So your question is
which PreThink forward is the most efficient, rather than automaton/fakemeta version.