383 lines
8.1 KiB
C++
383 lines
8.1 KiB
C++
#include "pinball.h"
|
|
|
|
//----- (0100C335) --------------------------------------------------------
|
|
int SpecialAddScore(int a1)
|
|
{
|
|
TPinballTable *v1; // ecx
|
|
int v2; // esi
|
|
int v3; // edi
|
|
int v4; // ebx
|
|
int result; // eax
|
|
TPinballTable *v6; // ecx
|
|
|
|
v1 = dword_1025040;
|
|
v2 = *(DWORD *)((char *)dword_1025040 + 318);
|
|
*(DWORD *)((char *)dword_1025040 + 318) = 0;
|
|
v3 = *(DWORD *)((char *)v1 + 310);
|
|
*(DWORD *)((char *)v1 + 310) = 0;
|
|
v4 = *(DWORD *)((char *)v1 + 294);
|
|
*(DWORD *)((char *)v1 + 294) = 0;
|
|
result = TPinballTable::AddScore(v1, a1);
|
|
v6 = dword_1025040;
|
|
*(DWORD *)((char *)dword_1025040 + 310) = v3;
|
|
*(DWORD *)((char *)v6 + 294) = v4;
|
|
*(DWORD *)((char *)v6 + 318) = v2;
|
|
return result;
|
|
}
|
|
|
|
//----- (0100E50B) --------------------------------------------------------
|
|
int AddRankProgress(int a1)
|
|
{
|
|
signed int v1; // ebx
|
|
int v2; // edi
|
|
void (__thiscall ***v3)(DWORD, signed int, DWORD); // esi
|
|
signed int v4; // edi
|
|
int v5; // eax
|
|
int (__thiscall ***v6)(DWORD, signed int, DWORD); // esi
|
|
int v7; // edi
|
|
CHAR *v8; // ST40_4
|
|
CHAR *v9; // eax
|
|
__int64 v10; // rax
|
|
int v11; // edx
|
|
signed __int64 v12; // rt2
|
|
char Dest; // [esp+50h] [ebp-44h]
|
|
|
|
v1 = 0;
|
|
(**(void (***)(signed int, DWORD))dword_10238F0)(19, 0.0);
|
|
v2 = a1;
|
|
v3 = (void (__thiscall ***)(DWORD, signed int, DWORD))dword_1023CFC;
|
|
if ( a1 > 0 )
|
|
{
|
|
do
|
|
{
|
|
(**v3)(v3, 41, 2.0);
|
|
--v2;
|
|
}
|
|
while ( v2 );
|
|
}
|
|
v4 = ((int (__thiscall *)(DWORD, signed int, DWORD))**v3)(v3, 37, 0.0);
|
|
v5 = ((int (__thiscall *)(DWORD, signed int, DWORD))**v3)(v3, 38, 0.0);
|
|
if ( v4 == v5 )
|
|
{
|
|
v1 = 1;
|
|
(**v3)(v3, 16, 5.0);
|
|
v6 = (int (__thiscall ***)(DWORD, signed int, DWORD))dword_1023CF4;
|
|
(**(void (***)(signed int, DWORD))dword_1023CF4)(34, 0.0);
|
|
v7 = (**v6)(v6, 37, 0.0);
|
|
if ( v7 < 9 )
|
|
{
|
|
(**v6)(v6, 41, 5.0);
|
|
v8 = get_rc_string(word_10246EC[2 * v7], 1);
|
|
v9 = get_rc_string(83, 0);
|
|
_sprintf(&Dest, v9, v8);
|
|
TTextBox::Display(tTextBox, 1, &Dest, 8.0);
|
|
(*(void (**)(void))(*(DWORD *)dword_1023D1C + 20))();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
v10 = 3 * v5;
|
|
v12 = v10 % 4;
|
|
LODWORD(v10) = v10 / 4;
|
|
v11 = v12;
|
|
if ( v4 >= (signed int)v10 )
|
|
(**(void (__fastcall ***)(int, int, signed int, DWORD))dword_1023CF4)(dword_1023CF4, v11, 27, -1.0);
|
|
}
|
|
return v1;
|
|
}
|
|
// 10238F0: using guessed type int dword_10238F0;
|
|
// 1023CF4: using guessed type int dword_1023CF4;
|
|
// 1023CFC: using guessed type int dword_1023CFC;
|
|
// 1023D1C: using guessed type int dword_1023D1C;
|
|
// 10246EC: using guessed type int word_10246EC[];
|
|
|
|
|
|
//----- (01013BB3) --------------------------------------------------------
|
|
DWORD *score_create(LPCSTR lpString, int a2)
|
|
{
|
|
DWORD *v2; // esi
|
|
int *v3; // eax
|
|
int v5; // cx
|
|
signed int *v6; // eax
|
|
int v7; // edx
|
|
int v8; // edx
|
|
int v9; // ebx
|
|
int *v10; // edi
|
|
int v11; // [esp+10h] [ebp+Ch]
|
|
|
|
v2 = (DWORD *)memoryallocate(0x44u);
|
|
if ( !v2 )
|
|
return 0;
|
|
*v2 = -9999;
|
|
v2[2] = a2;
|
|
v3 = (int *)partman_field_labeled(loader_table, lpString, 10);
|
|
if ( !v3 )
|
|
{
|
|
memoryfree((int)v2);
|
|
return 0;
|
|
}
|
|
v5 = *v3;
|
|
v6 = v3 + 1;
|
|
v7 = *v6;
|
|
++v6;
|
|
v2[3] = v7;
|
|
v8 = *v6;
|
|
++v6;
|
|
v2[4] = v8;
|
|
v2[5] = *v6;
|
|
v2[6] = v6[1];
|
|
v9 = v5;
|
|
v10 = v2 + 7;
|
|
v11 = 10;
|
|
do
|
|
{
|
|
*v10 = partman_field(loader_table, v9, 1);
|
|
++v10;
|
|
++v9;
|
|
--v11;
|
|
}
|
|
while ( v11 );
|
|
return v2;
|
|
}
|
|
|
|
//----- (01013C48) --------------------------------------------------------
|
|
void *score_dup(const void *a1, int a2)
|
|
{
|
|
void *result; // eax
|
|
|
|
result = (void *)memoryallocate(0x44u);
|
|
if ( result )
|
|
qmemcpy(result, a1, 0x44u);
|
|
return result;
|
|
}
|
|
|
|
|
|
//----- (01013C89) --------------------------------------------------------
|
|
DWORD *score_set(DWORD *a1, int a2)
|
|
{
|
|
DWORD *result; // eax
|
|
|
|
result = a1;
|
|
if ( a1 )
|
|
{
|
|
*a1 = a2;
|
|
a1[1] = 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//----- (01013CAA) --------------------------------------------------------
|
|
void *score_erase(int a1, DWORD *a2, int a3)
|
|
{
|
|
DWORD *v3; // edx
|
|
void *result; // eax
|
|
|
|
if ( a2 )
|
|
{
|
|
v3 = (DWORD *)a2[2];
|
|
if ( v3 )
|
|
result = gdrv_copy_bitmap(&vscreen, a2[5], a2[6], a2[3], a2[4], v3, a2[3], a2[4]);
|
|
else
|
|
result = (void *)gdrv_fill_bitmap(a1, &vscreen, a2[5], a2[6], a2[3], a2[4], 0);
|
|
if ( a3 )
|
|
result = gdrv_blit((int)&vscreen, a2[3], a2[4], a2[3] + xDest, a2[4] + yDest, a2[5], a2[6]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//----- (01013D2D) --------------------------------------------------------
|
|
HDC score_update(int a1, int *a2)
|
|
{
|
|
HDC result; // eax
|
|
int v3; // ecx
|
|
int v4; // edi
|
|
unsigned int v5; // kr00_4
|
|
int v6; // eax
|
|
char *v7; // eax
|
|
int v8; // [esp-24h] [ebp-40h]
|
|
int v9; // [esp-20h] [ebp-3Ch]
|
|
DWORD *v10; // [esp-14h] [ebp-30h]
|
|
int v11; // [esp+4h] [ebp-18h]
|
|
int v12; // [esp+8h] [ebp-14h]
|
|
char DstBuf[12]; // [esp+Ch] [ebp-10h]
|
|
|
|
result = 0;
|
|
if ( a2 && a2[1] && *a2 <= 1000000000 )
|
|
{
|
|
v3 = a2[4];
|
|
v4 = a2[5] + a2[3];
|
|
a2[1] = 0;
|
|
v11 = v3;
|
|
score_erase(a1, a2, 0);
|
|
if ( *a2 >= 0 )
|
|
{
|
|
__ltoa(*a2, DstBuf, 10);
|
|
v5 = strlen(DstBuf);
|
|
v6 = v5 - 1;
|
|
v12 = v5 - 1;
|
|
if ( (signed int)(v5 - 1) >= 0 )
|
|
{
|
|
while ( 1 )
|
|
{
|
|
v7 = &DstBuf[v6];
|
|
*v7 -= 48;
|
|
v10 = (DWORD *)a2[*v7 + 7];
|
|
v4 -= v10[3];
|
|
v9 = v10[4];
|
|
v8 = v10[3];
|
|
if ( render_background_bitmap )
|
|
gdrv_copy_bitmap_w_transparency(&vscreen, v8, v9, v4, v11, v10, 0, 0);
|
|
else
|
|
gdrv_copy_bitmap(&vscreen, v8, v9, v4, v11, v10, 0, 0);
|
|
if ( --v12 < 0 )
|
|
break;
|
|
v6 = v12;
|
|
}
|
|
}
|
|
}
|
|
result = gdrv_blit((int)&vscreen, a2[3], a2[4], a2[3] + xDest, a2[4] + yDest, a2[5], a2[6]);
|
|
}
|
|
return result;
|
|
}
|
|
// 1013D2D: using guessed type char DstBuf[12];
|
|
|
|
//----- (01013E25) --------------------------------------------------------
|
|
signed int score_init()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
//----- (01013E2E) --------------------------------------------------------
|
|
void score_unload_msg_font()
|
|
{
|
|
signed int v0; // esi
|
|
|
|
if ( score_msg_fontp )
|
|
{
|
|
v0 = 8;
|
|
do
|
|
{
|
|
if ( *(DWORD *)((char *)score_msg_fontp + v0) )
|
|
{
|
|
gdrv_destroy_bitmap(*(DWORD *)((char *)score_msg_fontp + v0));
|
|
memoryfree(*(DWORD *)((char *)score_msg_fontp + v0));
|
|
}
|
|
v0 += 4;
|
|
}
|
|
while ( v0 < 520 );
|
|
score_msg_fontp = 0;
|
|
}
|
|
}
|
|
// 10253C4: using guessed type struct score_msg_font_type *score_msg_fontp;
|
|
|
|
//----- (01013E73) --------------------------------------------------------
|
|
HRSRC score_load_msg_font(LPCSTR lpName)
|
|
{
|
|
HRSRC result; // eax
|
|
HRSRC v2; // esi
|
|
signed int *v3; // ebx
|
|
int v4; // edx
|
|
signed int v5; // esi
|
|
signed int v6; // ecx
|
|
char *v7; // eax
|
|
_BYTE *v8; // esi
|
|
int v9; // eax
|
|
unsigned int v10; // eax
|
|
const void *v11; // esi
|
|
DWORD *v12; // eax
|
|
int v13; // edx
|
|
char *v14; // eax
|
|
int v15; // esi
|
|
HRSRC hResData; // [esp+0h] [ebp-20h]
|
|
unsigned int v17; // [esp+4h] [ebp-1Ch]
|
|
char *i; // [esp+8h] [ebp-18h]
|
|
int v19; // [esp+Ch] [ebp-14h]
|
|
signed int v20; // [esp+10h] [ebp-10h]
|
|
char *v21; // [esp+14h] [ebp-Ch]
|
|
int v22; // [esp+18h] [ebp-8h]
|
|
int v23; // [esp+1Ch] [ebp-4h]
|
|
LPCSTR lpNamea; // [esp+28h] [ebp+8h]
|
|
|
|
result = FindResourceA(hinst, lpName, (LPCSTR)0xA);
|
|
if ( !result )
|
|
return result;
|
|
result = (HRSRC)LoadResource(hinst, result);
|
|
v2 = result;
|
|
hResData = result;
|
|
if ( !result )
|
|
return result;
|
|
v3 = (signed int *)LockResource(result);
|
|
v22 = (int)(v3 + 67);
|
|
v4 = memoryallocate(0x208u);
|
|
score_msg_fontp = (struct score_msg_font_type *)v4;
|
|
if ( !v4 )
|
|
return (HRSRC)FreeResource(v2);
|
|
v5 = 128;
|
|
memset((void *)(v4 + 8), 0, 0x200u);
|
|
v6 = 0;
|
|
v7 = (char *)(v3 + 3);
|
|
do
|
|
{
|
|
if ( *v7 > v6 )
|
|
v6 = *v7;
|
|
++v7;
|
|
--v5;
|
|
}
|
|
while ( v5 );
|
|
v19 = memoryallocate(v6 * v3[2] + 4);
|
|
if ( !v19 )
|
|
{
|
|
memoryfree((int)score_msg_fontp);
|
|
score_msg_fontp = 0;
|
|
return (HRSRC)FreeResource(hResData);
|
|
}
|
|
v23 = 0;
|
|
*(DWORD *)score_msg_fontp = *v3;
|
|
*((DWORD *)score_msg_fontp + 1) = v3[2];
|
|
lpNamea = (LPCSTR)8;
|
|
while ( 1 )
|
|
{
|
|
v8 = (char *)v3 + v23 + 6;
|
|
if ( *v8 )
|
|
break;
|
|
LABEL_16:
|
|
lpNamea += 4;
|
|
++v23;
|
|
if ( (signed int)lpNamea >= 520 )
|
|
goto LABEL_19;
|
|
}
|
|
*(DWORD *)((char *)score_msg_fontp + (DWORD)lpNamea) = memoryallocate(0x25u);
|
|
v9 = *(DWORD *)((char *)score_msg_fontp + (DWORD)lpNamea);
|
|
if ( !v9 )
|
|
goto LABEL_19;
|
|
if ( !gdrv_create_raw_bitmap(v9, (char)*v8, v3[2], 0) )
|
|
{
|
|
v10 = v3[2] * (char)*v8;
|
|
v11 = (const void *)v22;
|
|
v22 += ++v10;
|
|
qmemcpy((void *)(v19 + 3), v11, v10);
|
|
v20 = 0;
|
|
v17 = *((char *)v3 + v23 + 6);
|
|
v21 = (char *)(v19 + 4);
|
|
v12 = *(DWORD **)((char *)score_msg_fontp + (DWORD)lpNamea);
|
|
v13 = -v12[5];
|
|
v14 = (char *)(v12[2] - v13 * (v12[4] - 1));
|
|
for ( i = v14; v20 < v3[2]; i += v13 )
|
|
{
|
|
qmemcpy(v14, v21, v17);
|
|
++v20;
|
|
v21 += v17;
|
|
v14 = &i[v13];
|
|
}
|
|
goto LABEL_16;
|
|
}
|
|
v15 = 4 * v23 + 8;
|
|
memoryfree(*(DWORD *)((char *)score_msg_fontp + v15));
|
|
*(DWORD *)((char *)score_msg_fontp + v15) = 0;
|
|
LABEL_19:
|
|
if ( v23 != 128 )
|
|
score_unload_msg_font();
|
|
return (HRSRC)FreeResource(hResData);
|
|
}
|
|
// 10253C4: using guessed type struct score_msg_font_type *score_msg_fontp;
|