mirror
/
devilutionX
mirror of https://github.com/diasurgical/devilutionX.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Clean up threading

pull/25/head
Anders Jenbo 8 years ago
parent
2e9475f381
commit
8317d80d94
4 changed files with 333 additions and 375 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 275
      Source/dthread.cpp
  2. 8
      Source/dthread.h
  3. 409
      Source/nthread.cpp
  4. 16
      Source/nthread.h

275
Source/dthread.cpp
Unescape View File

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

8
Source/dthread.h
Unescape View File

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

409
Source/nthread.cpp
Unescape View File

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

16
Source/nthread.h
Unescape View File

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

Write Preview
Loading…
Cancel
Save