Do long-distance relays delay traces more than short-distance relays?

If you bounce your connection between nodes that are geographically far apart instead of nodes that are close together, does that slow down active traces between them?

If they do, then I should use long-distance relays always. If they don’t, then I should use short-distance relays so the map is covered with fewer messy lines.

I know that you should always use the maximum number of relays. I am asking how to order those relays – whether each node should connect to a node that is far away from it on the map, or whether that doesn’t affect the time in which you are active traced.

Solution 1:

My data says no. I ran experiments, timing how long it took me to be active traced when I was connected to the server through different paths. I didn’t run statistical tests, but it looks like distance between nodes is not a factor in active trace time. (However, one long-distance path was traced significantly faster than other paths, indicating that there are other factors controlling active trace time). Here is the data from my experiments:

Uplink experiments to find best active-trace-resistant path:    

time to get kicked off connection to Uplink Test Machine by active trace after starting to log in with known account admin/rosebud:    

when routing thru one other server, changing the server:
31, 35, 36, 37, 33; 31 secs thru UPAS (straight path)
25, 27, 24; 26 secs thru UIB (out of the way)
34, 32, 31, 34 secs thru INIC (a little less out of the way)
33, 31, 34 secs thru INIC after get admin access    

when routing thru three other servers, changing the order:
81, 75, 81, 80, 73 secs thru UPAS, UISS, UIB (straight path)
73, 80, 80, 77, 82 secs thru UIB, UISS, UPAS (path doubles back)    

for these experiments, I did not control for:
time spent on any screens before triggering active trace – connection screen, intro screen, admin login screen before and after filling in password    

server locations were all the same in each experiment, but I know they change between games, so only my descriptions of their locations remain

I also tried to look for the source code that determines your time to be active traced. The progress of a trace is measured with the traceprogress of a Connection in trunk/uplink/src/world/connection.cpp. The code that updates the trace progress is in Player in trunk/uplink/src/world/player.cpp – the methods TimeRemaining, TimeToTrace, and Update. I think that this code in TimeToTrace, which measures the time to trace each individual step in the chain, indicates that distance between nodes is not a factor:

int Player::TimeToTrace ( char *tracerIP, char *routerIP )
{

    VLocation *tracer = game->GetWorld ()->GetVLocation (tracerIP);
    UplinkAssert (tracer);
    Computer *comp = tracer->GetComputer ();
    UplinkAssert (comp);

    int timetonexttrace = comp->tracespeed;

    //
    // Modifiers to the time to next trace

    int playeraccesslevel = game->GetWorld ()->GetPlayer ()->HasAccount ( routerIP );

    if ( playeraccesslevel == -1 && tracer->GetComputer ()->traceaction > COMPUTER_TRACEACTION_FINE ) {
        timetonexttrace = (int) ( timetonexttrace * TRACESPEED_MODIFIER_NOACCOUNT );
    }
    else if ( playeraccesslevel == 1 ) {
        timetonexttrace = (int) ( timetonexttrace * TRACESPEED_MODIFIER_ADMINACCESS );
    }
    else if ( playeraccesslevel != -1 ) {
        timetonexttrace = (int) ( timetonexttrace * TRACESPEED_MODIFIER_HASACCOUNT );
    }

    if ( playeraccesslevel != -1 && tracer->GetComputer ()->TYPE == COMPUTER_TYPE_CENTRALMAINFRAME ) {
        timetonexttrace = (int) ( timetonexttrace * COMPUTER_TYPE_CENTRALMAINFRAME );
    }

    if ( playeraccesslevel == 1 && tracer->GetComputer ()->TYPE == COMPUTER_TYPE_PUBLICBANKSERVER ) {
        timetonexttrace = (int) ( timetonexttrace * TRACESPEED_MODIFIER_PUBLICBANKSERVERADMIN );
    }

    if ( timetonexttrace < 2 ) timetonexttrace = 2;

    return timetonexttrace;

}