Clean up threading

Source/dthread.cpp

@@ -2,199 +2,182 @@
 
 #include "../types.h"
 
-int dthread_cpp_init_value; // weak
+int dthread_cpp_init_value;        // weak
 static CRITICAL_SECTION sgMemCrit; // idb
-unsigned int glpDThreadId; // idb
-TMegaPkt *sgpInfoHead; /* may not be right struct */
-char byte_52A508; // weak
-HANDLE sghWorkToDoEvent; // idb
+unsigned int glpDThreadId;         // idb
+TMegaPkt *sgpInfoHead;             /* may not be right struct */
+char byte_52A508;                  // weak
+HANDLE sghWorkToDoEvent;           // idb
 
 int dthread_inf = 0x7F800000; // weak
 
 /* rdata */
 static HANDLE sghThread = (HANDLE)0xFFFFFFFF; // idb
 
-struct dthread_cpp_init_1
-{
-	dthread_cpp_init_1()
-	{
-		dthread_cpp_init_value = dthread_inf;
-	}
+struct dthread_cpp_init_1 {
+    dthread_cpp_init_1()
+    {
+        dthread_cpp_init_value = dthread_inf;
+    }
 } _dthread_cpp_init_1;
 // 47A460: using guessed type int dthread_inf;
 // 52A4E0: using guessed type int dthread_cpp_init_value;
 
-struct dthread_cpp_init_2
-{
-	dthread_cpp_init_2()
-	{
-		dthread_init_mutex();
-		dthread_cleanup_mutex_atexit();
-	}
+struct dthread_cpp_init_2 {
+    dthread_cpp_init_2()
+    {
+        dthread_init_mutex();
+        dthread_cleanup_mutex_atexit();
+    }
 } _dthread_cpp_init_2;
 
 void __cdecl dthread_init_mutex()
 {
-	InitializeCriticalSection(&sgMemCrit);
+    InitializeCriticalSection(&sgMemCrit);
 }
 
 void __cdecl dthread_cleanup_mutex_atexit()
 {
-	atexit(dthread_cleanup_mutex);
+    atexit(dthread_cleanup_mutex);
 }
 
 void __cdecl dthread_cleanup_mutex()
 {
-	DeleteCriticalSection(&sgMemCrit);
+    DeleteCriticalSection(&sgMemCrit);
 }
 
 void __fastcall dthread_remove_player(int pnum)
 {
-	int v1; // edi
-	TMegaPkt *i; // eax
-
-	v1 = pnum;
-	EnterCriticalSection(&sgMemCrit);
-	for ( i = sgpInfoHead; i; i = i->pNext )
-	{
-		if ( i->dwSpaceLeft == v1 )
-			i->dwSpaceLeft = 4;
-	}
-	LeaveCriticalSection(&sgMemCrit);
+    int v1;      // edi
+    TMegaPkt *i; // eax
+
+    v1 = pnum;
+    EnterCriticalSection(&sgMemCrit);
+    for (i = sgpInfoHead; i; i = i->pNext) {
+        if (i->dwSpaceLeft == v1)
+            i->dwSpaceLeft = 4;
+    }
+    LeaveCriticalSection(&sgMemCrit);
 }
 
 void __fastcall dthread_send_delta(int pnum, char cmd, void *pbSrc, int dwLen)
 {
-	TMegaPkt *v5; // eax
-	TMegaPkt *v6; // esi
-	TMegaPkt *v7; // eax
-	TMegaPkt **v8; // ecx
-	int v9; // [esp+4h] [ebp-4h]
-
-	v9 = pnum;
-	if ( gbMaxPlayers != 1 )
-	{
-		v5 = (TMegaPkt *)DiabloAllocPtr(dwLen + 20);
-		v6 = v5;
-		v5->pNext = 0;
-		v5->dwSpaceLeft = v9;
-		v5->data[0] = cmd;
-		*(_DWORD *)&v5->data[4] = dwLen;
-		memcpy(&v5->data[8], pbSrc, dwLen);
-		EnterCriticalSection(&sgMemCrit);
-		v7 = sgpInfoHead;
-		v8 = &sgpInfoHead;
-		while ( v7 )
-		{
-			v8 = &v7->pNext;
-			v7 = v7->pNext;
-		}
-		*v8 = v6;
-		SetEvent(sghWorkToDoEvent);
-		LeaveCriticalSection(&sgMemCrit);
-	}
+    TMegaPkt *v5;  // eax
+    TMegaPkt *v6;  // esi
+    TMegaPkt *v7;  // eax
+    TMegaPkt **v8; // ecx
+    int v9;        // [esp+4h] [ebp-4h]
+
+    v9 = pnum;
+    if (gbMaxPlayers != 1) {
+        v5 = (TMegaPkt *)DiabloAllocPtr(dwLen + 20);
+        v6 = v5;
+        v5->pNext = 0;
+        v5->dwSpaceLeft = v9;
+        v5->data[0] = cmd;
+        *(_DWORD *)&v5->data[4] = dwLen;
+        memcpy(&v5->data[8], pbSrc, dwLen);
+        EnterCriticalSection(&sgMemCrit);
+        v7 = sgpInfoHead;
+        v8 = &sgpInfoHead;
+        while (v7) {
+            v8 = &v7->pNext;
+            v7 = v7->pNext;
+        }
+        *v8 = v6;
+        SetEvent(sghWorkToDoEvent);
+        LeaveCriticalSection(&sgMemCrit);
+    }
 }
 // 679660: using guessed type char gbMaxPlayers;
 
 void __cdecl dthread_start()
 {
-	char *v0; // eax
-	char *v1; // eax
-
-	if ( gbMaxPlayers != 1 )
-	{
-		sghWorkToDoEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-		if ( !sghWorkToDoEvent )
-		{
-			v0 = TraceLastError();
-			TermMsg("dthread:1\n%s", v0);
-		}
-		byte_52A508 = 1;
-		sghThread = (HANDLE)_beginthreadex(NULL, 0, dthread_handler, NULL, 0, &glpDThreadId);
-		if ( sghThread == (HANDLE)-1 )
-		{
-			v1 = TraceLastError();
-			TermMsg("dthread2:\n%s", v1);
-		}
-	}
+    char *v0; // eax
+    char *v1; // eax
+
+    if (gbMaxPlayers != 1) {
+        sghWorkToDoEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+        if (!sghWorkToDoEvent) {
+            v0 = TraceLastError();
+            TermMsg("dthread:1\n%s", v0);
+        }
+        byte_52A508 = 1;
+        sghThread = (HANDLE)_beginthreadex(NULL, 0, dthread_handler, NULL, 0, &glpDThreadId);
+        if (sghThread == (HANDLE)-1) {
+            v1 = TraceLastError();
+            TermMsg("dthread2:\n%s", v1);
+        }
+    }
 }
 // 52A508: using guessed type char byte_52A508;
 // 679660: using guessed type char gbMaxPlayers;
 
 unsigned int __stdcall dthread_handler(void *a1)
 {
-	char *v1; // eax
-	TMegaPkt *v2; // esi
-	int v3; // ecx
-	unsigned int v4; // edi
-
-	while ( byte_52A508 )
-	{
-		if ( !sgpInfoHead && WaitForSingleObject(sghWorkToDoEvent, 0xFFFFFFFF) == -1 )
-		{
-			v1 = TraceLastError();
-			TermMsg("dthread4:\n%s", v1);
-		}
-		EnterCriticalSection(&sgMemCrit);
-		v2 = sgpInfoHead;
-		if ( sgpInfoHead )
-			sgpInfoHead = sgpInfoHead->pNext;
-		else
-			ResetEvent(sghWorkToDoEvent);
-		LeaveCriticalSection(&sgMemCrit);
-		if ( v2 )
-		{
-			v3 = v2->dwSpaceLeft;
-			if ( v3 != 4 )
-				multi_send_zero_packet(v3, v2->data[0], &v2->data[8], *(_DWORD *)&v2->data[4]);
-			v4 = 1000 * *(_DWORD *)&v2->data[4] / (unsigned int)gdwDeltaBytesSec;
-			if ( v4 >= 1 )
-				v4 = 1;
-			mem_free_dbg(v2);
-			if ( v4 )
-				Sleep(v4);
-		}
-	}
-	return 0;
+    char *v1;        // eax
+    TMegaPkt *v2;    // esi
+    int v3;          // ecx
+    unsigned int v4; // edi
+
+    while (byte_52A508) {
+        if (!sgpInfoHead && WaitForSingleObject(sghWorkToDoEvent, 0xFFFFFFFF) == -1) {
+            v1 = TraceLastError();
+            TermMsg("dthread4:\n%s", v1);
+        }
+        EnterCriticalSection(&sgMemCrit);
+        v2 = sgpInfoHead;
+        if (sgpInfoHead)
+            sgpInfoHead = sgpInfoHead->pNext;
+        else
+            ResetEvent(sghWorkToDoEvent);
+        LeaveCriticalSection(&sgMemCrit);
+        if (v2) {
+            v3 = v2->dwSpaceLeft;
+            if (v3 != 4)
+                multi_send_zero_packet(v3, v2->data[0], &v2->data[8], *(_DWORD *)&v2->data[4]);
+            v4 = 1000 * *(_DWORD *)&v2->data[4] / (unsigned int)gdwDeltaBytesSec;
+            if (v4 >= 1)
+                v4 = 1;
+            mem_free_dbg(v2);
+            if (v4)
+                Sleep(v4);
+        }
+    }
+    return 0;
 }
 // 52A508: using guessed type char byte_52A508;
 // 679730: using guessed type int gdwDeltaBytesSec;
 
 void __cdecl dthread_cleanup()
 {
-	char *v0; // eax
-	TMegaPkt *v1; // eax
-	TMegaPkt *v2; // esi
-
-	if ( sghWorkToDoEvent )
-	{
-		byte_52A508 = 0;
-		SetEvent(sghWorkToDoEvent);
-		if ( sghThread != (HANDLE)-1 && glpDThreadId != GetCurrentThreadId() )
-		{
-			if ( WaitForSingleObject(sghThread, 0xFFFFFFFF) == -1 )
-			{
-				v0 = TraceLastError();
-				TermMsg("dthread3:\n(%s)", v0);
-			}
-			CloseHandle(sghThread);
-			sghThread = (HANDLE)-1;
-		}
-		CloseHandle(sghWorkToDoEvent);
-		v1 = sgpInfoHead;
-		sghWorkToDoEvent = 0;
-		if ( sgpInfoHead )
-		{
-			do
-			{
-				v2 = v1->pNext;
-				sgpInfoHead = 0;
-				mem_free_dbg(v1);
-				v1 = v2;
-				sgpInfoHead = v2;
-			}
-			while ( v2 );
-		}
-	}
+    char *v0;     // eax
+    TMegaPkt *v1; // eax
+    TMegaPkt *v2; // esi
+
+    if (sghWorkToDoEvent) {
+        byte_52A508 = 0;
+        SetEvent(sghWorkToDoEvent);
+        if (sghThread != (HANDLE)-1 && glpDThreadId != GetCurrentThreadId()) {
+            if (WaitForSingleObject(sghThread, 0xFFFFFFFF) == -1) {
+                v0 = TraceLastError();
+                TermMsg("dthread3:\n(%s)", v0);
+            }
+            CloseHandle(sghThread);
+            sghThread = (HANDLE)-1;
+        }
+        CloseHandle(sghWorkToDoEvent);
+        v1 = sgpInfoHead;
+        sghWorkToDoEvent = 0;
+        if (sgpInfoHead) {
+            do {
+                v2 = v1->pNext;
+                sgpInfoHead = 0;
+                mem_free_dbg(v1);
+                v1 = v2;
+                sgpInfoHead = v2;
+            } while (v2);
+        }
+    }
 }
 // 52A508: using guessed type char byte_52A508;

Source/dthread.h

@@ -3,10 +3,10 @@
 #define __DTHREAD_H__
 
 extern int dthread_cpp_init_value; // weak
-extern unsigned int glpDThreadId; // idb
-extern TMegaPkt *sgpInfoHead; /* may not be right struct */
-extern char byte_52A508; // weak
-extern HANDLE sghWorkToDoEvent; // idb
+extern unsigned int glpDThreadId;  // idb
+extern TMegaPkt *sgpInfoHead;      /* may not be right struct */
+extern char byte_52A508;           // weak
+extern HANDLE sghWorkToDoEvent;    // idb
 
 void __cdecl dthread_cpp_init_1();
 void __cdecl dthread_cpp_init_2();

Source/nthread.cpp

@@ -3,157 +3,144 @@
 #include "../types.h"
 
 int nthread_cpp_init_value; // weak
-char byte_679704; // weak
+char byte_679704;           // weak
 int gdwMsgLenTbl[4];
 static CRITICAL_SECTION sgMemCrit;
-int gdwDeltaBytesSec; // weak
+int gdwDeltaBytesSec;    // weak
 char nthread_should_run; // weak
 DWORD gdwTurnsInTransit; // weak
 int glpMsgTbl[4];
 unsigned int glpNThreadId;
-char sgbSyncCountdown; // weak
-int turn_upper_bit; // weak
-char byte_679758; // weak
+char sgbSyncCountdown;   // weak
+int turn_upper_bit;      // weak
+char byte_679758;        // weak
 char sgbPacketCountdown; // weak
 char sgbThreadIsRunning; // weak
-int gdwLargestMsgSize; // weak
-int gdwNormalMsgSize; // weak
-int last_tick; // weak
+int gdwLargestMsgSize;   // weak
+int gdwNormalMsgSize;    // weak
+int last_tick;           // weak
 
 const int nthread_inf = 0x7F800000; // weak
 
 /* data */
 static HANDLE sghThread = (HANDLE)0xFFFFFFFF; // idb
 
-struct nthread_cpp_init_1
-{
-	nthread_cpp_init_1()
-	{
-		nthread_cpp_init_value = nthread_inf;
-	}
+struct nthread_cpp_init_1 {
+    nthread_cpp_init_1()
+    {
+        nthread_cpp_init_value = nthread_inf;
+    }
 } _nthread_cpp_init_1;
 // 47F164: using guessed type int nthread_inf;
 // 679700: using guessed type int nthread_cpp_init_value;
 
-struct nthread_cpp_init_2
-{
-	nthread_cpp_init_2()
-	{
-		nthread_init_mutex();
-		nthread_cleanup_mutex_atexit();
-	}
+struct nthread_cpp_init_2 {
+    nthread_cpp_init_2()
+    {
+        nthread_init_mutex();
+        nthread_cleanup_mutex_atexit();
+    }
 } _nthread_cpp_init_2;
 
 void __cdecl nthread_init_mutex()
 {
-	InitializeCriticalSection(&sgMemCrit);
+    InitializeCriticalSection(&sgMemCrit);
 }
 
 void __cdecl nthread_cleanup_mutex_atexit()
 {
-	atexit(nthread_cleanup_mutex);
+    atexit(nthread_cleanup_mutex);
 }
 
 void __cdecl nthread_cleanup_mutex()
 {
-	DeleteCriticalSection(&sgMemCrit);
+    DeleteCriticalSection(&sgMemCrit);
 }
 
 void __fastcall nthread_terminate_game(const char *pszFcn)
 {
-	DWORD sErr; // eax
+    DWORD sErr; // eax
 
-	sErr = SErrGetLastError();
-	if ( sErr != STORM_ERROR_INVALID_PLAYER )
-	{
-		if ( sErr == STORM_ERROR_GAME_TERMINATED || sErr == STORM_ERROR_NOT_IN_GAME )
-		{
-			gbGameDestroyed = 1;
-		}
-		else
-		{
-			TermMsg("%s:\n%s", pszFcn, TraceLastError());
-		}
-	}
+    sErr = SErrGetLastError();
+    if (sErr != STORM_ERROR_INVALID_PLAYER) {
+        if (sErr == STORM_ERROR_GAME_TERMINATED || sErr == STORM_ERROR_NOT_IN_GAME) {
+            gbGameDestroyed = 1;
+        } else {
+            TermMsg("%s:\n%s", pszFcn, TraceLastError());
+        }
+    }
 }
 // 67862D: using guessed type char gbGameDestroyed;
 
 int __fastcall nthread_send_and_recv_turn(int cur_turn, int turn_delta)
 {
-	unsigned int new_cur_turn; // edi
-	const char *lastStormFn; // ecx
-	int turn_tmp; // eax
-	int turn; // [esp+Ch] [ebp-8h]
-	int curTurnsInTransit; // [esp+10h] [ebp-4h]
+    unsigned int new_cur_turn; // edi
+    const char *lastStormFn;   // ecx
+    int turn_tmp;              // eax
+    int turn;                  // [esp+Ch] [ebp-8h]
+    int curTurnsInTransit;     // [esp+10h] [ebp-4h]
 
-	new_cur_turn = cur_turn;
-	if ( SNetGetTurnsInTransit(&curTurnsInTransit) )
-	{
-		if ( curTurnsInTransit >= (unsigned int)gdwTurnsInTransit )
-			return new_cur_turn;
-		while ( 1 )
-		{
-			++curTurnsInTransit;
+    new_cur_turn = cur_turn;
+    if (SNetGetTurnsInTransit(&curTurnsInTransit)) {
+        if (curTurnsInTransit >= (unsigned int)gdwTurnsInTransit)
+            return new_cur_turn;
+        while (1) {
+            ++curTurnsInTransit;
 
-			turn_tmp = turn_upper_bit | new_cur_turn & 0x7FFFFFFF;
-			turn_upper_bit = 0;
-			turn = turn_tmp;
+            turn_tmp = turn_upper_bit | new_cur_turn & 0x7FFFFFFF;
+            turn_upper_bit = 0;
+            turn = turn_tmp;
 
-			if ( !SNetSendTurn((char *)&turn, sizeof(turn)) )
-				break;
+            if (!SNetSendTurn((char *)&turn, sizeof(turn)))
+                break;
 
-			new_cur_turn += turn_delta;
-			if ( new_cur_turn >= 0x7FFFFFFF )
-				new_cur_turn = (unsigned short)new_cur_turn;
-			if ( curTurnsInTransit >= (unsigned int)gdwTurnsInTransit )
-				return new_cur_turn;
-		}
-		lastStormFn = "SNetSendTurn";
-	}
-	else
-	{
-		lastStormFn = "SNetGetTurnsInTransit";
-	}
-	nthread_terminate_game(lastStormFn);
-	return 0;
+            new_cur_turn += turn_delta;
+            if (new_cur_turn >= 0x7FFFFFFF)
+                new_cur_turn = (unsigned short)new_cur_turn;
+            if (curTurnsInTransit >= (unsigned int)gdwTurnsInTransit)
+                return new_cur_turn;
+        }
+        lastStormFn = "SNetSendTurn";
+    } else {
+        lastStormFn = "SNetGetTurnsInTransit";
+    }
+    nthread_terminate_game(lastStormFn);
+    return 0;
 }
 // 679738: using guessed type int gdwTurnsInTransit;
 // 679754: using guessed type int turn_upper_bit;
 
 int __fastcall nthread_recv_turns(int *pfSendAsync)
 {
-	bool hasCountedDown; // zf
+    bool hasCountedDown; // zf
 
-	*pfSendAsync = 0;
-	if ( --sgbPacketCountdown )
-	{
-		last_tick += 50;
-		return 1;
-	}
-	hasCountedDown = sgbSyncCountdown-- == 1;
-	sgbPacketCountdown = byte_679704;
-	if ( !hasCountedDown )
-		goto LABEL_11;
-	if ( SNetReceiveTurns(0, 4, (char **)glpMsgTbl, (unsigned int *)gdwMsgLenTbl, (unsigned long *)player_state) )
-	{
-		if ( !byte_679758 )
-		{
-			byte_679758 = 1;
-			last_tick = GetTickCount();
-		}
-		sgbSyncCountdown = 4;
-		multi_msg_countdown();
-LABEL_11:
-		*pfSendAsync = 1;
-		last_tick += 50;
-		return 1;
-	}
-	if ( SErrGetLastError() != STORM_ERROR_NO_MESSAGES_WAITING )
-		nthread_terminate_game("SNetReceiveTurns");
-	byte_679758 = 0;
-	sgbSyncCountdown = 1;
-	sgbPacketCountdown = 1;
-	return 0;
+    *pfSendAsync = 0;
+    if (--sgbPacketCountdown) {
+        last_tick += 50;
+        return 1;
+    }
+    hasCountedDown = sgbSyncCountdown-- == 1;
+    sgbPacketCountdown = byte_679704;
+    if (!hasCountedDown)
+        goto LABEL_11;
+    if (SNetReceiveTurns(0, 4, (char **)glpMsgTbl, (unsigned int *)gdwMsgLenTbl, (unsigned long *)player_state)) {
+        if (!byte_679758) {
+            byte_679758 = 1;
+            last_tick = GetTickCount();
+        }
+        sgbSyncCountdown = 4;
+        multi_msg_countdown();
+    LABEL_11:
+        *pfSendAsync = 1;
+        last_tick += 50;
+        return 1;
+    }
+    if (SErrGetLastError() != STORM_ERROR_NO_MESSAGES_WAITING)
+        nthread_terminate_game("SNetReceiveTurns");
+    byte_679758 = 0;
+    sgbSyncCountdown = 1;
+    sgbPacketCountdown = 1;
+    return 0;
 }
 // 679704: using guessed type char byte_679704;
 // 679750: using guessed type char sgbSyncCountdown;
@@ -163,73 +150,67 @@ LABEL_11:
 
 void __cdecl nthread_set_turn_upper_bit()
 {
-	turn_upper_bit = 0x80000000;
+    turn_upper_bit = 0x80000000;
 }
 // 679754: using guessed type int turn_upper_bit;
 
 void __fastcall nthread_start(bool set_turn_upper_bit)
 {
-	char *err; // eax
-	unsigned int largestMsgSize; // esi
-	unsigned int normalMsgSize; // eax
-	char *err2; // eax
-	_SNETCAPS caps; // [esp+8h] [ebp-24h]
+    char *err;                   // eax
+    unsigned int largestMsgSize; // esi
+    unsigned int normalMsgSize;  // eax
+    char *err2;                  // eax
+    _SNETCAPS caps;              // [esp+8h] [ebp-24h]
 
-	last_tick = GetTickCount();
-	sgbPacketCountdown = 1;
-	sgbSyncCountdown = 1;
-	byte_679758 = 1;
-	if (set_turn_upper_bit)
-		nthread_set_turn_upper_bit();
-	else
-		turn_upper_bit = 0;
-	caps.size = 36;
-	if ( !SNetGetProviderCaps(&caps) )
-	{
-		err = TraceLastError();
-		TermMsg("SNetGetProviderCaps:\n%s", err);
-	}
-	gdwTurnsInTransit = caps.defaultturnsintransit;
-	if ( !caps.defaultturnsintransit )
-		gdwTurnsInTransit = 1;
-	if ( caps.defaultturnssec <= 0x14u && caps.defaultturnssec )
-		byte_679704 = 0x14u / caps.defaultturnssec;
-	else
-		byte_679704 = 1;
-	largestMsgSize = 512;
-	if ( caps.maxmessagesize < 0x200u )
-		largestMsgSize = caps.maxmessagesize;
-	gdwDeltaBytesSec = (unsigned int)caps.bytessec >> 2;
-	gdwLargestMsgSize = largestMsgSize;
-	if ( caps.maxplayers > 4u )
-		caps.maxplayers = 4;
-	normalMsgSize = (3 * (caps.bytessec * (unsigned int)(unsigned char)byte_679704 / 0x14) >> 2) / caps.maxplayers;
-	gdwNormalMsgSize = normalMsgSize;
-	if ( normalMsgSize < 0x80 )
-	{
-		do
-		{
-			byte_679704 *= 2;
-			normalMsgSize *= 2;
-		}
-		while ( normalMsgSize < 0x80 );
-		gdwNormalMsgSize = normalMsgSize;
-	}
-	if ( normalMsgSize > largestMsgSize )
-		gdwNormalMsgSize = largestMsgSize;
-	if ( (unsigned char)gbMaxPlayers > 1u )
-	{
-		sgbThreadIsRunning = 0;
-		EnterCriticalSection(&sgMemCrit);
-		nthread_should_run = 1;
-		sghThread = (HANDLE)_beginthreadex(NULL, 0, nthread_handler, NULL, 0, &glpNThreadId);
-		if ( sghThread == (HANDLE)-1 )
-		{
-			err2 = TraceLastError();
-			TermMsg("nthread2:\n%s", err2);
-		}
-		SetThreadPriority(sghThread, THREAD_PRIORITY_HIGHEST);
-	}
+    last_tick = GetTickCount();
+    sgbPacketCountdown = 1;
+    sgbSyncCountdown = 1;
+    byte_679758 = 1;
+    if (set_turn_upper_bit)
+        nthread_set_turn_upper_bit();
+    else
+        turn_upper_bit = 0;
+    caps.size = 36;
+    if (!SNetGetProviderCaps(&caps)) {
+        err = TraceLastError();
+        TermMsg("SNetGetProviderCaps:\n%s", err);
+    }
+    gdwTurnsInTransit = caps.defaultturnsintransit;
+    if (!caps.defaultturnsintransit)
+        gdwTurnsInTransit = 1;
+    if (caps.defaultturnssec <= 0x14u && caps.defaultturnssec)
+        byte_679704 = 0x14u / caps.defaultturnssec;
+    else
+        byte_679704 = 1;
+    largestMsgSize = 512;
+    if (caps.maxmessagesize < 0x200u)
+        largestMsgSize = caps.maxmessagesize;
+    gdwDeltaBytesSec = (unsigned int)caps.bytessec >> 2;
+    gdwLargestMsgSize = largestMsgSize;
+    if (caps.maxplayers > 4u)
+        caps.maxplayers = 4;
+    normalMsgSize = (3 * (caps.bytessec * (unsigned int)(unsigned char)byte_679704 / 0x14) >> 2) / caps.maxplayers;
+    gdwNormalMsgSize = normalMsgSize;
+    if (normalMsgSize < 0x80) {
+        do {
+            byte_679704 *= 2;
+            normalMsgSize *= 2;
+        } while (normalMsgSize < 0x80);
+        gdwNormalMsgSize = normalMsgSize;
+    }
+    if (normalMsgSize > largestMsgSize)
+        gdwNormalMsgSize = largestMsgSize;
+    if ((unsigned char)gbMaxPlayers > 1u) {
+        sgbThreadIsRunning = 0;
+        EnterCriticalSection(&sgMemCrit);
+        nthread_should_run = 1;
+        sghThread = (HANDLE)_beginthreadex(NULL, 0, nthread_handler, NULL, 0, &glpNThreadId);
+        if (sghThread == (HANDLE)-1) {
+            err2 = TraceLastError();
+            TermMsg("nthread2:\n%s", err2);
+        }
+        SetThreadPriority(sghThread, THREAD_PRIORITY_HIGHEST);
+    }
 }
 // 679660: using guessed type char gbMaxPlayers;
 // 679704: using guessed type char byte_679704;
@@ -247,51 +228,47 @@ void __fastcall nthread_start(bool set_turn_upper_bit)
 
 unsigned int __stdcall nthread_handler(void *a1)
 {
-	signed int delta; // esi
-	int received; // [esp+Ch] [ebp-4h]
+    signed int delta; // esi
+    int received;     // [esp+Ch] [ebp-4h]
 
-	if ( nthread_should_run )
-	{
-		while ( 1 )
-		{
-			EnterCriticalSection(&sgMemCrit);
-			if ( !nthread_should_run )
-				break;
-			nthread_send_and_recv_turn(0, 0);
-			if ( nthread_recv_turns(&received) )
-				delta = last_tick - GetTickCount();
-			else
-				delta = 50;
-			LeaveCriticalSection(&sgMemCrit);
-			if ( delta > 0 )
-				Sleep(delta);
-			if ( !nthread_should_run )
-				return 0;
-		}
-		LeaveCriticalSection(&sgMemCrit);
-	}
-	return 0;
+    if (nthread_should_run) {
+        while (1) {
+            EnterCriticalSection(&sgMemCrit);
+            if (!nthread_should_run)
+                break;
+            nthread_send_and_recv_turn(0, 0);
+            if (nthread_recv_turns(&received))
+                delta = last_tick - GetTickCount();
+            else
+                delta = 50;
+            LeaveCriticalSection(&sgMemCrit);
+            if (delta > 0)
+                Sleep(delta);
+            if (!nthread_should_run)
+                return 0;
+        }
+        LeaveCriticalSection(&sgMemCrit);
+    }
+    return 0;
 }
 // 679734: using guessed type char nthread_should_run;
 // 679764: using guessed type int last_tick;
 
 void __cdecl nthread_cleanup()
 {
-	nthread_should_run = 0;
-	gdwTurnsInTransit = 0;
-	gdwNormalMsgSize = 0;
-	gdwLargestMsgSize = 0;
-	if ( sghThread != (HANDLE)-1 && glpNThreadId != GetCurrentThreadId() )
-	{
-		if ( !sgbThreadIsRunning )
-			LeaveCriticalSection(&sgMemCrit);
-		if ( WaitForSingleObject(sghThread, 0xFFFFFFFF) == -1 )
-		{
-			TermMsg("nthread3:\n(%s)", TraceLastError());
-		}
-		CloseHandle(sghThread);
-		sghThread = (HANDLE)-1;
-	}
+    nthread_should_run = 0;
+    gdwTurnsInTransit = 0;
+    gdwNormalMsgSize = 0;
+    gdwLargestMsgSize = 0;
+    if (sghThread != (HANDLE)-1 && glpNThreadId != GetCurrentThreadId()) {
+        if (!sgbThreadIsRunning)
+            LeaveCriticalSection(&sgMemCrit);
+        if (WaitForSingleObject(sghThread, 0xFFFFFFFF) == -1) {
+            TermMsg("nthread3:\n(%s)", TraceLastError());
+        }
+        CloseHandle(sghThread);
+        sghThread = (HANDLE)-1;
+    }
 }
 // 679734: using guessed type char nthread_should_run;
 // 679738: using guessed type int gdwTurnsInTransit;
@@ -301,30 +278,28 @@ void __cdecl nthread_cleanup()
 
 void __fastcall nthread_ignore_mutex(bool bStart)
 {
-	if ( sghThread != (HANDLE)-1 )
-	{
-		if ( bStart )
-			LeaveCriticalSection(&sgMemCrit);
-		else
-			EnterCriticalSection(&sgMemCrit);
-		sgbThreadIsRunning = bStart;
-	}
+    if (sghThread != (HANDLE)-1) {
+        if (bStart)
+            LeaveCriticalSection(&sgMemCrit);
+        else
+            EnterCriticalSection(&sgMemCrit);
+        sgbThreadIsRunning = bStart;
+    }
 }
 // 67975A: using guessed type char sgbThreadIsRunning;
 
 BOOL __cdecl nthread_has_500ms_passed()
 {
-	DWORD currentTickCount; // eax
-	int ticksElapsed; // ecx
+    DWORD currentTickCount; // eax
+    int ticksElapsed;       // ecx
 
-	currentTickCount = GetTickCount();
-	ticksElapsed = currentTickCount - last_tick;
-	if ( gbMaxPlayers == 1 && ticksElapsed > 500 )
-	{
-		last_tick = currentTickCount;
-		ticksElapsed = 0;
-	}
-	return ticksElapsed >= 0;
+    currentTickCount = GetTickCount();
+    ticksElapsed = currentTickCount - last_tick;
+    if (gbMaxPlayers == 1 && ticksElapsed > 500) {
+        last_tick = currentTickCount;
+        ticksElapsed = 0;
+    }
+    return ticksElapsed >= 0;
 }
 // 679660: using guessed type char gbMaxPlayers;
 // 679764: using guessed type int last_tick;

Source/nthread.h

@@ -3,21 +3,21 @@
 #define __NTHREAD_H__
 
 extern int nthread_cpp_init_value; // weak
-extern char byte_679704; // weak
+extern char byte_679704;           // weak
 extern int gdwMsgLenTbl[4];
-extern int gdwDeltaBytesSec; // weak
+extern int gdwDeltaBytesSec;    // weak
 extern char nthread_should_run; // weak
 extern DWORD gdwTurnsInTransit; // weak
 extern int glpMsgTbl[4];
 extern unsigned int glpNThreadId;
-extern char sgbSyncCountdown; // weak
-extern int turn_upper_bit; // weak
-extern char byte_679758; // weak
+extern char sgbSyncCountdown;   // weak
+extern int turn_upper_bit;      // weak
+extern char byte_679758;        // weak
 extern char sgbPacketCountdown; // weak
 extern char sgbThreadIsRunning; // weak
-extern int gdwLargestMsgSize; // weak
-extern int gdwNormalMsgSize; // weak
-extern int last_tick; // weak
+extern int gdwLargestMsgSize;   // weak
+extern int gdwNormalMsgSize;    // weak
+extern int last_tick;           // weak
 
 void __cdecl nthread_init_mutex();
 void __cdecl nthread_cleanup_mutex_atexit();