Alex/REDRIVER2
1
0
Fork 0
mirror of https://github.com/OpenDriver2/REDRIVER2.git synced 2024-11-23 19:02:35 +01:00
Code Issues Projects Releases Wiki Activity
3e875daf3c
REDRIVER2/src_rebuild/GAME/C/SPOOL.C
Ilya Shurumov c98c754fc8 - attempts to fix GetPVSRegionCell2
2020-06-02 02:16:53 +06:00

4364 lines
85 KiB
C
Raw Blame History

#include "THISDUST.H"
#ifndef PSX
#include <SDL.h>
#endif // !PSX
#include <STRINGS.H>
#include "LIBETC.H"
#include "PAD.H"
#include "SPOOL.H"
#include "MAP.H"
#include "SYSTEM.H"
#include "MAIN.H"
#include "XAPLAY.H"
#include "DIRECTOR.H"
#include "SOUND.H"
#include "TEXTURE.H"
#include "MODELS.H"
#include "OBJANIM.H"
#include "GLAUNCH.H"
#include "CARS.H"
#include "COSMETIC.H"
#include "DENTING.H"
#include "HANDLING.H"
#include "MISSION.H"
#include "CIV_AI.H"
#include "CAMERA.H"
#include "DR2ROADS.H"
int date_date = 0xA11;
int date_time = 0x27220B;
int SpecialByRegion[4][20] = {
{5, 1, 3, 3, 2, 2, 2, 3, 3, 3, 3, 1, 1, 1, 2, 3, 2, 2, 3, 0},
{2, 4, 1, 1, 4, 4, 3, 3, 3, 3, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{2, 4, 1, 1, 1, 1, 1, 1, 4, 2, 3, 3, 5, 0, 0, 0, 0, 0, 0, 0},
{2, 5, 4, 1, 2, 1, 4, 3, 2, 2, 2, 2, 3, 3, 3, 0, 0, 0, 0, 0},
};
char* model_spool_buffer = NULL;
int cell_objects_add[5];
int cell_slots_add[5];
SXYPAIR* Music_And_AmbientOffsets;
AreaDataStr* AreaData;
unsigned char* AreaTPages; // 16 per area
int NumAreas;
char* RegionSpoolInfo;
unsigned short *spoolinfo_offsets;
char* specmallocptr;
char *specLoadBuffer;
int doSpooling = 1;
short loading_region[4];
int regions_unpacked[4];
int spool_regioncounter;
int spoolerror; // UNUSED
int spool_regionpos;
volatile int spoolactive; // volatile is required at least for PC
volatile int quickSpool;
int models_ready;
short specspooldata[3] = { 20, 10, 4 };
int tsetcounter;
int tsetpos;
int spoolcounter;
int spoolseek; // Probably UNUSED
int loadbank_read;
int loadbank_write;
int spoolpos;
int spoolpos_reading;
int spoolpos_writing;
int allowSpecSpooling;
int startSpecSpool;
int unpack_roadmap_flag;
int unpack_cellptr_flag;
char *packed_cell_pointers;
SPL_REGIONINFO spool_regioninfo[8];
static int sectors_this_chunk;
static volatile int sectors_to_read;
static char *target_address;
static int nTPchunks;
static int nTPchunks_reading;
static int nTPchunks_writing;
static int ntpages;
static int current_sector;
static int switch_spooltype;
static int endchunk;
int send_bank;
int sample_chunk;
int chunk_complete;
int new_area_location;
int LoadingArea = 0;
unsigned short *newmodels;
struct SPOOLQ spooldata[48];
#if !defined(PSX) && !defined(SIMPLE_SPOOL)
#include <assert.h>
typedef void(*data_callbackFn)(void);
typedef void(*ready_callbackFn)(unsigned char intr, unsigned char *result);
data_callbackFn g_dataCallbackPC = NULL;
ready_callbackFn g_readyCallbackPC = NULL;
char g_sectorData[2048] = { 0 };
bool g_isSectorDataRead = false;
bool g_spoolDoneFlag = false;
extern char g_CurrentLevelFileName[64];
SDL_Thread* levelSpoolerPCThread = NULL;
SDL_mutex* levelSpoolerPCMutex = NULL;
volatile int levelSpoolerSeekCmd = 0;
//-----------------------------------------------------
// copies read sector data to addr
//-----------------------------------------------------
void getLevSectorPC(char* dest, int count)
{
count *= 4;
#ifdef _DEBUG
SPOOLQ* which = &spooldata[spoolpos_reading];
sectors_this_chunk;
current_sector;
sectors_to_read;
#endif // _DEBUG
assert(count <= 2048);
assert(dest);
assert(sectors_to_read > 0);
//SDL_LockMutex(levelSpoolerPCMutex);
memcpy(dest, g_sectorData, count);
g_isSectorDataRead = true;
//SDL_UnlockMutex(levelSpoolerPCMutex);
}
void levelSpoolerPCDataCallback(data_callbackFn cb)
{
SDL_LockMutex(levelSpoolerPCMutex);
g_dataCallbackPC = cb;
SDL_UnlockMutex(levelSpoolerPCMutex);
}
void levelSpoolerPCReadyCallback(ready_callbackFn cb)
{
SDL_LockMutex(levelSpoolerPCMutex);
g_readyCallbackPC = cb;
SDL_UnlockMutex(levelSpoolerPCMutex);
}
// Main spooler thread function
int levelSpoolerPCFunc(void* data)
{
//Print incoming data
printWarning("Running SPOOL thread...\n");
g_spoolDoneFlag = false;
g_isSectorDataRead = false;
ready_callbackFn readyCb = g_readyCallbackPC;
data_callbackFn dataCb = g_dataCallbackPC;
FILE* fp = fopen(g_CurrentLevelFileName, "rb");
if (!fp)
{
char errPrint[1024];
sprintf(errPrint, "Cannot open '%s'\n", g_CurrentLevelFileName);
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "ERROR", errPrint, NULL);
if (readyCb)
readyCb(0, { 0x0 });
return -1;
}
do
{
SDL_LockMutex(levelSpoolerPCMutex);
if (levelSpoolerSeekCmd != 0)
{
int sector = levelSpoolerSeekCmd;
if (sector == -1)
{
printInfo("SPOOL thread recieved 'CdlPause'\n", sector);
levelSpoolerSeekCmd = 0;
g_spoolDoneFlag = true;
}
else
{
printInfo("SPOOL thread recieved 'CdlReadS' at %d\n", sector);
// seek
fseek(fp, sector * 2048, SEEK_SET);
levelSpoolerSeekCmd = 0;
}
}
dataCb = g_dataCallbackPC;
readyCb = g_readyCallbackPC;
SDL_UnlockMutex(levelSpoolerPCMutex);
// clear sector before proceed
ClearMem(g_sectorData, sizeof(g_sectorData));
fread(g_sectorData, 1, 2048, fp);
g_isSectorDataRead = false;
if (readyCb)
{
readyCb(1, { 0x0 });
if (g_isSectorDataRead && dataCb)
dataCb();
}
else
break;
} while (!g_spoolDoneFlag);
printInfo("SPOOLER thread work done.\n");
fclose(fp);
return 0;
}
//-----------------------------------------------------
// reads sector from LEV file
//-----------------------------------------------------
void startReadLevSectorsPC(int sector)
{
if (!levelSpoolerPCMutex)
levelSpoolerPCMutex = SDL_CreateMutex();
SDL_LockMutex(levelSpoolerPCMutex);
levelSpoolerSeekCmd = sector;
SDL_UnlockMutex(levelSpoolerPCMutex);
if (levelSpoolerPCThread && g_spoolDoneFlag)
{
int returnValue;
SDL_WaitThread(levelSpoolerPCThread, &returnValue);
levelSpoolerPCThread = NULL;
}
if (!levelSpoolerPCThread)
{
levelSpoolerPCThread = SDL_CreateThread(levelSpoolerPCFunc, "Spooler", NULL);
if (NULL == levelSpoolerPCThread)
{
printError("SDL_CreateThread failed: %s\n", SDL_GetError());
}
}
}
#endif // !PSX
// decompiled code
// original method signature:
// void /*$ra*/ test_changemode()
// line 532, offset 0x0007b228
/* begin block 1 */
// Start line: 534
// Start offset: 0x0007B228
// Variables:
// struct SPOOLQ *current; // $a3
/* end block 1 */
// End offset: 0x0007B3B4
// End Line: 588
/* begin block 2 */
// Start line: 1064
/* end block 2 */
// End Line: 1065
/* begin block 3 */
// Start line: 1065
/* end block 3 */
// End Line: 1066
/* begin block 4 */
// Start line: 1067
/* end block 4 */
// End Line: 1068
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void test_changemode(void)
{
#ifndef SIMPLE_SPOOL
char bVar1;
SPOOLQ *current = &spooldata[spoolpos_reading];
if (spoolpos_reading == spoolcounter)
{
switch_spooltype = 0;
#ifdef PSX
CdReadyCallback(0);
CdControlF(CdlPause, 0);
#else
levelSpoolerPCReadyCallback(NULL);
levelSpoolerSeekCmd = -1;
#endif // PSX
}
else if (current_sector == current->sector)
{
target_address = current->addr;
bVar1 = current->type;
switch_spooltype = 1;
if (bVar1 == 0)
{
sectors_to_read = spool_regioninfo[spool_regionpos + 1].nsectors;
sectors_this_chunk = (current->nsectors);
#ifdef PSX
CdReadyCallback(ready_cb_regions);
#else
levelSpoolerPCReadyCallback(ready_cb_regions);
#endif // PSX
}
else if (bVar1 == 1)
{
sectors_to_read = 17;
target_address += 0x4000;
nTPchunks_reading = 0;
nTPchunks_writing = 0;
ntpages = tsetcounter;
sectors_this_chunk = (uint)bVar1;
#ifdef PSX
CdReadyCallback(ready_cb_textures);
#else
levelSpoolerPCReadyCallback(ready_cb_textures);
#endif // PSX
}
else if (bVar1 == 2)
{
sectors_to_read = (current->nsectors);
send_bank = (current->data);
sample_chunk = 0;
nTPchunks_reading = 0;
nTPchunks_writing = 0;
target_address = target_address + (loadbank_read & 1U) * 0x1000;
sectors_this_chunk = (uint)bVar1;
#ifdef PSX
CdReadyCallback(ready_cb_soundbank);
#else
levelSpoolerPCReadyCallback(ready_cb_soundbank);
#endif // PSX
}
else if (bVar1 == 3)
{
sectors_to_read = (current->nsectors);
#ifdef PSX
CdReadyCallback(ready_cb_misc);
#else
levelSpoolerPCReadyCallback(ready_cb_misc);
#endif // PSX
}
}
else
{
switch_spooltype = 0;
#ifdef PSX
CdReadyCallback(0);
#else
levelSpoolerPCReadyCallback(NULL);
#endif // PSX
}
#endif // SIMPLE_SPOOL
}
// decompiled code
// original method signature:
// void /*$ra*/ changemode(struct SPOOLQ *current /*$a0*/)
// line 591, offset 0x0007e1a8
/* begin block 1 */
// Start line: 1182
/* end block 1 */
// End Line: 1183
/* begin block 2 */
// Start line: 5397
/* end block 2 */
// End Line: 5398
// [D]
void changemode(SPOOLQ *current)
{
#ifndef SIMPLE_SPOOL
switch_spooltype = 0;
endchunk = 0;
switch (current->type)
{
case 0:
{
#ifdef PSX
CdDataCallback(data_cb_regions);
#else
levelSpoolerPCDataCallback(data_cb_regions);
#endif // PSX
break;
}
case 1:
{
#ifdef PSX
CdDataCallback(data_cb_textures);
#else
levelSpoolerPCDataCallback(data_cb_textures);
#endif // PSX
break;
}
case 2:
{
#ifdef PSX
CdDataCallback(data_cb_soundbank);
#else
levelSpoolerPCDataCallback(data_cb_soundbank);
#endif // PSX
break;
}
case 3:
{
#ifdef PSX
CdDataCallback(data_cb_misc);
#else
levelSpoolerPCDataCallback(data_cb_misc);
#endif // PSX
break;
}
}
#endif // SIMPLE_SPOOL
}
// decompiled code
// original method signature:
// int /*$ra*/ check_regions_present()
// line 625, offset 0x0007b3c4
/* begin block 1 */
// Start line: 627
// Start offset: 0x0007B3C4
// Variables:
// struct AREA_LOAD_INFO regions_to_unpack[3]; // stack offset -160
// int leftright_unpack; // $a2
// int topbottom_unpack; // $a3
// int num_regions_to_unpack; // $a1
// int x; // $v1
// int z; // $v0
// int loop; // $t1
// int retval; // $a3
// int region_to_unpack; // $a0
// int barrel_region; // $v1
// char textbuf[128]; // stack offset -136
/* end block 1 */
// End offset: 0x0007B6C4
// End Line: 771
/* begin block 2 */
// Start line: 1267
/* end block 2 */
// End Line: 1268
/* begin block 3 */
// Start line: 1268
/* end block 3 */
// End Line: 1269
/* begin block 4 */
// Start line: 1269
/* end block 4 */
// End Line: 1270
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
int check_regions_present(void)
{
AREA_LOAD_INFO *pAVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
AREA_LOAD_INFO *pAVar6;
AREA_LOAD_INFO region_to_unpack[3];
char textbuf[128];
pAVar6 = region_to_unpack;
iVar4 = 0;
iVar5 = 0;
iVar3 = 0;
if (current_barrel_region_xcell < 9) {
region_to_unpack[0].xoffset = -1;
if (region_x != 0) {
iVar4 = 1;
LAB_0007b44c:
iVar3 = 1;
region_to_unpack[0].zoffset = 0;
}
}
else {
if (0x17 < current_barrel_region_xcell) {
iVar2 = cells_across;
if (cells_across < 0) {
iVar2 = cells_across + 0x1f;
}
region_to_unpack[0].xoffset = 1;
if (region_x < iVar2 >> 5) {
iVar4 = 2;
goto LAB_0007b44c;
}
}
}
if (current_barrel_region_zcell < 9) {
if (region_z == 0) goto LAB_0007b4e0;
iVar5 = 1;
region_to_unpack[iVar3].xoffset = 0;
iVar2 = -1;
}
else {
if ((current_barrel_region_zcell < 0x18) || (region_z == 0)) goto LAB_0007b4e0;
iVar5 = 2;
region_to_unpack[iVar3].xoffset = 0;
iVar2 = 1;
}
pAVar1 = region_to_unpack + iVar3;
iVar3 = iVar3 + 1;
pAVar1->zoffset = iVar2;
LAB_0007b4e0:
if (iVar3 == 2) {
if (iVar5 == 1) {
iVar3 = 3;
if (iVar4 == 1) {
region_to_unpack[2].xoffset = -1;
region_to_unpack[2].zoffset = -1;
}
else {
region_to_unpack[2].xoffset = 1;
region_to_unpack[2].zoffset = -1;
}
}
else {
iVar3 = 3;
if (iVar4 == 1) {
region_to_unpack[2].xoffset = -1;
}
else {
region_to_unpack[2].xoffset = 1;
}
region_to_unpack[2].zoffset = 1;
}
}
iVar4 = 0;
while (iVar3 != 0) {
iVar5 = cells_across;
if (cells_across < 0) {
iVar5 = cells_across + 0x1f;
}
iVar5 = current_region + *(int *)pAVar6 + ((int *)pAVar6)[1] * (iVar5 >> 5);
if ((((int)loading_region[(region_x + *(int *)pAVar6 & 1U) + (region_z + ((int *)pAVar6)[1] & 1U) * 2] !=
-1) && (spoolinfo_offsets[iVar5] != 0xffff)) &&
((int)loading_region
[(region_x + *(int *)pAVar6 & 1U) + (region_z + ((int *)pAVar6)[1] & 1U) * 2] ==
iVar5)) {
iVar4 = iVar4 + 1;
}
iVar3 = iVar3 + -1;
pAVar6 = (AREA_LOAD_INFO *)((int *)pAVar6 + 2);
}
if (LoadingArea != 0) {
if (new_area_location == 1) {
if (0x1a < current_barrel_region_xcell) {
iVar4 = iVar4 + 1;
}
}
else {
if (new_area_location < 2) {
if ((new_area_location == 0) && (0x1a < current_barrel_region_zcell)) {
iVar4 = iVar4 + 1;
}
}
else {
iVar3 = current_barrel_region_zcell;
if (((new_area_location == 2) ||
(iVar3 = current_barrel_region_xcell, new_area_location == 3)) && (iVar3 < 6)) {
iVar4 = iVar4 + 1;
}
}
}
}
return iVar4;
}
// decompiled code
// original method signature:
// void /*$ra*/ stopgame()
// line 818, offset 0x0007e958
/* begin block 1 */
// Start line: 822
// Start offset: 0x0007E958
/* end block 1 */
// End offset: 0x0007E9A0
// End Line: 827
/* begin block 2 */
// Start line: 1636
/* end block 2 */
// End Line: 1637
/* begin block 3 */
// Start line: 8809
/* end block 3 */
// End Line: 8810
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void stopgame(void)
{
StopPadVibration(0);
StopPadVibration(1);
PauseSFX();
DrawSync(0);
PutDrawEnv(&last->draw);
}
// decompiled code
// original method signature:
// void /*$ra*/ startgame()
// line 829, offset 0x0007e9a0
/* begin block 1 */
// Start line: 831
// Start offset: 0x0007E9A0
/* end block 1 */
// End offset: 0x0007E9D0
// End Line: 833
/* begin block 2 */
// Start line: 8825
/* end block 2 */
// End Line: 8826
/* begin block 3 */
// Start line: 8828
/* end block 3 */
// End Line: 8829
/* begin block 4 */
// Start line: 8829
/* end block 4 */
// End Line: 8830
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void startgame(void)
{
PutDrawEnv(&current->draw);
UnPauseSFX();
}
// decompiled code
// original method signature:
// void /*$ra*/ DrawCDicon()
// line 836, offset 0x0007e24c
/* begin block 1 */
// Start line: 838
// Start offset: 0x0007E24C
// Variables:
// unsigned short *palette; // $a1
// int temp; // $a2
// int i; // $a0
// struct RECT dest; // stack offset -16
/* end block 1 */
// End offset: 0x0007E2CC
// End Line: 856
/* begin block 2 */
// Start line: 5885
/* end block 2 */
// End Line: 5886
/* begin block 3 */
// Start line: 5886
/* end block 3 */
// End Line: 5887
/* WARNING: Unknown calling convention yet parameter storage is locked */
extern POLY_FT4 cd_sprite;
extern unsigned short cd_icon[288];
// [D]
void DrawCDicon(void)
{
ushort *puVar1;
int iVar2;
RECT16 local_10;
cd_icon[23] = cd_icon[11];
iVar2 = 0xb;
puVar1 = cd_icon + 10;
do {
iVar2 = iVar2 + -1;
puVar1[1] = puVar1[2];
puVar1 = puVar1 + 1;
} while (-1 < iVar2);
local_10.x = 960;
local_10.y = 433;
local_10.w = 16;
local_10.h = 1;
LoadImage(&local_10, (u_long *)(cd_icon + 10));
DrawPrim(&cd_sprite);
DrawSync(0);
}
// decompiled code
// original method signature:
// void /*$ra*/ CheckValidSpoolData()
// line 859, offset 0x0007e2cc
/* begin block 1 */
// Start line: 861
// Start offset: 0x0007E2CC
// Variables:
// struct RECT dest; // stack offset -16
/* end block 1 */
// End offset: 0x0007E35C
// End Line: 918
/* begin block 2 */
// Start line: 5946
/* end block 2 */
// End Line: 5947
/* begin block 3 */
// Start line: 5950
/* end block 3 */
// End Line: 5951
/* begin block 4 */
// Start line: 5951
/* end block 4 */
// End Line: 5952
/* begin block 5 */
// Start line: 5962
/* end block 5 */
// End Line: 5963
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void CheckValidSpoolData(void)
{
if (models_ready != 0)
init_spooled_models();
if (spoolactive != 0)
{
if (check_regions_present() != 0)
{
stopgame();
while (spoolactive != 0)
{
DrawCDicon();
VSync(0);
}
startgame();
PutDrawEnv(&current->draw);
UnPauseSFX();
}
}
}
// decompiled code
// original method signature:
// void /*$ra*/ UpdateSpool()
// line 925, offset 0x0007b6c4
/* begin block 1 */
// Start line: 927
// Start offset: 0x0007B6C4
// Variables:
// struct SPOOLQ *current; // $s0
// struct CdlLOC pos; // stack offset -16
/* end block 1 */
// End offset: 0x0007B87C
// End Line: 977
/* begin block 2 */
// Start line: 1793
/* end block 2 */
// End Line: 1794
/* begin block 3 */
// Start line: 1903
/* end block 3 */
// End Line: 1904
/* begin block 4 */
// Start line: 1904
/* end block 4 */
// End Line: 1905
/* begin block 5 */
// Start line: 1908
/* end block 5 */
// End Line: 1909
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void UpdateSpool(void)
{
#ifdef SIMPLE_SPOOL
extern char g_CurrentLevelFileName[64];
FILE* fp = fopen(g_CurrentLevelFileName, "rb");
if (!fp)
{
char errPrint[1024];
sprintf(errPrint, "Cannot open '%s'\n", g_CurrentLevelFileName);
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "ERROR", errPrint, NULL);
return;
}
for (; spoolpos_reading < spoolcounter; spoolpos_reading++)
{
SPOOLQ *current = &spooldata[spoolpos_reading];
#ifdef _DEBUG
char* nameType;
switch (current->type)
{
case 0: // regions
nameType = "REGION";
break;
case 1: // textures
nameType = "TPAGE";
break;
case 2: // sbk
nameType = "SBK";
break;
case 3: // misc
nameType = "MISC";
break;
}
printWarning("spool type=%s cb=%d sec=%d cnt=%d id=%d\n", nameType, current->func ? 1 : 0, current->sector, current->nsectors, spoolpos_reading);
#endif // _DEBUG
// seek to required sector
fseek(fp, current->sector * 2048, SEEK_SET);
switch (current->type)
{
case 0: // regions
fread(current->addr, 2048, current->nsectors, fp);
if (current->func)
current->func();
break;
case 1: // textures
// read cluts
nTPchunks = 0;
fread(current->addr + 0x4000, 2048, 1, fp);
SendTPage();
nTPchunks++;
// read tpage (4 sectors 4 times = 16)
for (int i = 0; i < 4; i++)
{
fread(current->addr + (loadbank_write & 1U) * TPAGE_WIDTH * 32, 2048, 4, fp);
SendTPage();
nTPchunks++;
}
break;
case 2: // sbk
// nothing to do with this
break;
case 3: // misc
fread(current->addr, 2048, current->nsectors, fp);
if (current->func)
current->func();
break;
}
}
spoolcounter = 0;
spoolpos_reading = 0;
spoolactive = 0;
fclose(fp);
#else
char bVar1;
int iVar3;
CdlLOC pos;
iVar3 = XAPrepared();
SPOOLQ *current = &spooldata[spoolpos_reading];
if (iVar3 != 1)
{
target_address = current->addr;
bVar1 = current->type;
if (bVar1 == 0) // SPOOLTYPE_REGIONS
{
sectors_this_chunk = (current->nsectors);
sectors_to_read = spool_regioninfo[spool_regionpos].nsectors;
spoolseek = 5;
#ifdef PSX
CdDataCallback(data_cb_regions);
CdReadyCallback(ready_cb_regions);
#else
levelSpoolerPCDataCallback(data_cb_regions);
levelSpoolerPCReadyCallback(ready_cb_regions);
#endif // PSX
}
else if (bVar1 == 1) // SPOOLTYPE_TEXTURES
{
spoolseek = 5;
nTPchunks_reading = 0;
nTPchunks_writing = 0;
sectors_to_read = 17;
ntpages = tsetcounter;
sectors_this_chunk = (uint)bVar1;
#ifdef PSX
CdDataCallback(data_cb_textures);
CdReadyCallback(ready_cb_textures);
#else
levelSpoolerPCDataCallback(data_cb_textures);
levelSpoolerPCReadyCallback(ready_cb_textures);
#endif // PSX
target_address = target_address + 0x4000;
}
else if (bVar1 == 2) // SPOOLTYPE_SOUNDBANK
{
sectors_to_read = (current->nsectors);
send_bank = (current->data);
spoolseek = 5;
sample_chunk = 0;
nTPchunks_reading = 0;
nTPchunks_writing = 0;
sectors_this_chunk = (uint)bVar1;
#ifdef PSX
CdDataCallback(data_cb_soundbank);
CdReadyCallback(ready_cb_soundbank);
#else
levelSpoolerPCDataCallback(data_cb_soundbank);
levelSpoolerPCReadyCallback(ready_cb_soundbank);
#endif // PSX
target_address = target_address + (loadbank_read & 1U) * 0x1000;
}
else if (bVar1 == 3) // SPOOLTYPE_MISC
{
sectors_to_read = (current->nsectors);
spoolseek = 5;
#ifdef PSX
CdDataCallback(data_cb_misc);
CdReadyCallback(ready_cb_misc);
#else
levelSpoolerPCDataCallback(data_cb_misc);
levelSpoolerPCReadyCallback(ready_cb_misc);
#endif // PSX
}
current_sector = current->sector;
endchunk = 0;
switch_spooltype = 0;
// run sector reading
#ifdef PSX
CdIntToPos(current_sector, &pos);
CdControlF(CdlReadS, (u_char*)&pos);
#else
startReadLevSectorsPC(current_sector);
#endif // PSX
}
#endif
}
// decompiled code
// original method signature:
// void /*$ra*/ RequestSpool(int type /*$a0*/, int data /*$a1*/, int offset /*$a2*/, int loadsize /*$a3*/, char *address /*stack 16*/, TDRFuncPtr_RequestSpool5func func /*stack 20*/)
// line 1104, offset 0x0007e36c
/* begin block 1 */
// Start line: 1105
// Start offset: 0x0007E36C
// Variables:
// struct SPOOLQ *next; // $t0
// int sector; // $v0
/* end block 1 */
// End offset: 0x0007E3E4
// End Line: 1126
/* begin block 2 */
// Start line: 6440
/* end block 2 */
// End Line: 6441
/* begin block 3 */
// Start line: 6447
/* end block 3 */
// End Line: 6448
// [D]
#ifdef _DEBUG
void _RequestSpool(int type, int data, int offset, int loadsize, char *address, spooledFuncPtr func, const char* requestby, int line)
#define RequestSpool(type, data, offset, loadsize, loadaddr, func) _RequestSpool(type, data, offset, loadsize, loadaddr, func, __FUNCTION__, __LINE__)
#else
void RequestSpool(int type, int data, int offset, int loadsize, char *address, spooledFuncPtr func)
#endif _DEBUG
{
if (!(spoolcounter < 48))
trap(0x400);
SPOOLQ *next;
next = &spooldata[spoolcounter];
next->type = type;
next->data = data;
next->sector = (citylumps[GameLevel][CITYLUMP_SPOOL].x / 2048) + offset;
next->nsectors = loadsize;
next->addr = address;
next->func = func;
#ifdef _DEBUG
next->requestby = requestby;
next->requestbyline = line;
#endif // _DEBUG
spoolcounter++;
}
// decompiled code
// original method signature:
// void /*$ra*/ InitSpooling()
// line 1129, offset 0x0007e494
/* begin block 1 */
// Start line: 1131
// Start offset: 0x0007E494
// Variables:
// int i; // $s0
// char namebuffer[128]; // stack offset -152
// struct CdlLOC pos; // stack offset -24
/* end block 1 */
// End offset: 0x0007E528
// End Line: 1158
/* begin block 2 */
// Start line: 7099
/* end block 2 */
// End Line: 7100
/* begin block 3 */
// Start line: 2258
/* end block 3 */
// End Line: 2259
/* begin block 4 */
// Start line: 7100
/* end block 4 */
// End Line: 7101
/* begin block 5 */
// Start line: 7105
/* end block 5 */
// End Line: 7106
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void InitSpooling(void)
{
int target_region;
target_region = 0;
do {
loading_region[target_region] = -1;
ClearRegion(target_region);
target_region++;
} while (target_region < 4);
newmodels = NULL;
spool_regioncounter = 0;
spoolerror = 0;
spool_regionpos = 0;
spoolactive = 0;
tsetcounter = 0;
models_ready = 0;
tsetpos = 0;
spoolcounter = 0;
loadbank_read = 0;
spoolpos = 0;
unpack_roadmap_flag = 0;
loadbank_write = 0;
spoolseek = 0;
unpack_cellptr_flag = 0;
}
// decompiled code
// original method signature:
// void /*$ra*/ SendTPage()
// line 1161, offset 0x0007b88c
/* begin block 1 */
// Start line: 1163
// Start offset: 0x0007B88C
// Variables:
// int tpage2send; // $s2
// int slot; // $s0
// int old; // $v1
// char *tpageaddress; // $t0
/* begin block 1.1 */
// Start line: 1176
// Start offset: 0x0007B900
// Variables:
// struct RECT cluts; // stack offset -32
// int npalettes; // $s1
// int i; // $a3
// unsigned long *clutptr; // $a1
/* end block 1.1 */
// End offset: 0x0007BA24
// End Line: 1208
/* end block 1 */
// End offset: 0x0007BB14
// End Line: 1235
/* begin block 2 */
// Start line: 2385
/* end block 2 */
// End Line: 2386
/* begin block 3 */
// Start line: 2386
/* end block 3 */
// End Line: 2387
/* begin block 4 */
// Start line: 2390
/* end block 4 */
// End Line: 2391
/* WARNING: Unknown calling convention yet parameter storage is locked */
int tsetinfo[32];
// [D]
void SendTPage(void)
{
unsigned char bVar1;
ulong *clutptr;
int iVar5;
int npalettes;
int iVar7;
RECT16 cluts;
iVar7 = tsetinfo[tsetpos * 2];
iVar5 = tsetinfo[tsetpos * 2 + 1];
if (iVar7 == 0xFF || iVar5 == 0xFF) // [A] bug fix
return;
if (nTPchunks == 0)
{
if (iVar5 != tpageloaded[iVar7]-1)
{
npalettes = *(int *)(model_spool_buffer + 0xE000);
tpage.w = 64;
tpage.h = 64;
cluts.w = 64;
tpage.x = slot_tpagepos[iVar5].vx;
tpage.y = slot_tpagepos[iVar5].vy;
cluts.y = slot_clutpos[iVar5].vy;
cluts.x = slot_clutpos[iVar5].vx;
cluts.h = npalettes / 4 + 1;
LoadImage(&cluts, (u_long *)(model_spool_buffer + 0xE000 + 4));
clutptr = (ulong *)(texture_cluts[iVar7]);
iVar5 = 0;
if (0 < npalettes)
{
do {
//int test1 = (uVar3 | iVar2 + 0x10 >> 4 & 0x3fU) << 0x10 | uVar3 | (int)((uint)cluts.x << 0x10) >> 0x14 & 0x3fU;
//int test2 = (uVar3 | iVar2 + 0x30 >> 4 & 0x3fU) << 0x10 | uVar3 | iVar2 + 0x20 >> 4 & 0x3fU;
clutptr[0] = getClut(cluts.x + 16, cluts.y) << 0x10 | getClut(cluts.x, cluts.y);
clutptr[1] = getClut(cluts.x + 48, cluts.y) << 0x10 | getClut(cluts.x + 32, cluts.y);
clutptr+=2;
cluts.y++;
iVar5 += 4;;
} while (iVar5 < npalettes);
}
texture_pages[iVar7] = getTPage(0, 0, tpage.x, tpage.y);
// OLD VALUE: (short)(tpage.y & 0x100U) >> 4 | (ushort)(((uint)(ushort)tpage.x & 0x3ff) >> 6) | (ushort)(((uint)(ushort)tpage.y & 0x200) << 2);
// please check me if above is correct
}
}
else
{
if (iVar5 != tpageloaded[iVar7] - 1)
{
LoadImage(&tpage, (u_long *)(model_spool_buffer + 0xA000 + (loadbank_write % 2) * TPAGE_WIDTH * 32));
tpage.y = tpage.y + tpage.h;
}
if (nTPchunks == 4)
{
bVar1 = tpageslots[iVar5];
tpageslots[iVar5] = iVar7;
if(bVar1 != 0xFF) // [A] bug fix
tpageloaded[bVar1] = 0;
tpageloaded[iVar7] = iVar5 + 1;
tsetpos++;
if (tsetpos == tsetcounter)
{
tsetcounter = 0;
tsetpos = 0;
}
}
}
}
// decompiled code
// original method signature:
// void /*$ra*/ SpoolSYNC()
// line 1239, offset 0x0007e528
/* begin block 1 */
// Start line: 7247
/* end block 1 */
// End Line: 7248
/* begin block 2 */
// Start line: 7329
/* end block 2 */
// End Line: 7330
/* begin block 3 */
// Start line: 7345
/* end block 3 */
// End Line: 7346
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void SpoolSYNC(void)
{
do {
} while (spoolactive != 0);
}
// decompiled code
// original method signature:
// void /*$ra*/ LoadInAreaTSets(int area /*$t4*/)
// line 1262, offset 0x0007bb14
/* begin block 1 */
// Start line: 1263
// Start offset: 0x0007BB14
// Variables:
// unsigned char *tpages; // $s1
// int ntpages_to_load; // $s3
// int i; // $s0
// int slot; // $a0
// int j; // $a1
// int offset; // $s4
// int availableslots[16]; // stack offset -104
// int navailable; // $s2
// char *loadaddr; // $fp
/* end block 1 */
// End offset: 0x0007BD84
// End Line: 1333
/* begin block 2 */
// Start line: 2620
/* end block 2 */
// End Line: 2621
/* begin block 3 */
// Start line: 2648
/* end block 3 */
// End Line: 2649
/* begin block 4 */
// Start line: 2660
/* end block 4 */
// End Line: 2661
// [D]
void LoadInAreaTSets(int area)
{
bool bVar1;
uint uVar3;
int iVar4;
int offset;
int *piVar5;
int i;
int slot;
unsigned char *tpages;
int ntpages_to_load;
int navailable;
char *loadaddr;
int availableslots[16];
tpages = AreaTPages + area * 16;
ntpages_to_load = AreaData[area].num_tpages;
loadaddr = model_spool_buffer + 0xA000;
navailable = 0;
if (slotsused < 19)
{
piVar5 = availableslots;
slot = slotsused;
do {
offset = 0;
if (tpageslots[slot] == 0xff) // [A]
{
*piVar5++ = slot;
navailable++;
}
else
{
if (ntpages_to_load != 0 && tpageslots[slot] != *tpages) // [A]
{
uVar3 = 1;
do {
offset = uVar3;
if (ntpages_to_load <= offset)
break;
uVar3 = offset + 1;
} while (tpageslots[slot] != tpages[offset]); // [A]
}
if (offset == ntpages_to_load)
{
*piVar5++ = slot;
navailable++;
}
}
slot++;
} while (slot < 19);
}
offset = AreaData[area].gfx_offset;
i = 0;
if (ntpages_to_load != 0)
{
uVar3 = *tpages;
if (tpageloaded[uVar3] != 0) // weird goto lol
{
goto LAB_0007bc94;
}
bVar1 = 0 < navailable;
navailable--;
if (bVar1)
{
iVar4 = availableslots[navailable];
while (true)
{
tsetinfo[tsetcounter*2 + 1] = iVar4;
while (true)
{
RequestSpool(1, 0, offset, 17, loadaddr, SendTPage);
offset += 17;
i++;
tsetinfo[tsetcounter * 2] = *tpages;
tsetcounter++;
tpages++;
if (ntpages_to_load <= i)
return;
uVar3 = *tpages;
if (tpageloaded[uVar3] == 0)
break;
LAB_0007bc94:
tsetinfo[tsetcounter * 2 + 1] = tpageloaded[uVar3] - 1;
}
if (navailable < 1)
break;
navailable--;
iVar4 = availableslots[navailable];
}
}
}
}
// decompiled code
// original method signature:
// void /*$ra*/ SendSBK()
// line 1337, offset 0x0007bd84
/* begin block 1 */
// Start line: 1339
// Start offset: 0x0007BD84
// Variables:
// char *address; // $s0
// int slength; // $s1
// int i; // $a1
// unsigned long *source; // $v0
// unsigned long *dest; // $a0
/* end block 1 */
// End offset: 0x0007BEBC
// End Line: 1380
/* begin block 2 */
// Start line: 2921
/* end block 2 */
// End Line: 2922
/* begin block 3 */
// Start line: 2926
/* end block 3 */
// End Line: 2927
/* begin block 4 */
// Start line: 2927
/* end block 4 */
// End Line: 2928
/* WARNING: Unknown calling convention yet parameter storage is locked */
void SendSBK(void)
{
UNIMPLEMENTED();
/*
ulong uVar1;
uint uVar2;
SAMPLE_DATA *pSVar3;
ulong *puVar4;
uint uVar5;
int *piVar6;
int iVar7;
piVar6 = (int *)(model_spool_buffer + (loadbank_write & 1U) * 0x1000 + 0x8000);
if (sample_chunk == 0) {
if (Song_ID != -1) {
StopXM();
FreeXM();
}
uVar5 = 0;
pSVar3 = samples;
num_samples = piVar6[1];
uVar2 = num_samples << 2;
puVar4 = (ulong *)(piVar6 + 2);
if (uVar2 != 0) {
do {
uVar1 = *puVar4;
puVar4 = puVar4 + 1;
uVar5 = uVar5 + 1;
pSVar3->address = uVar1;
pSVar3 = (SAMPLE_DATA *)&pSVar3->length;
} while (uVar5 < uVar2);
}
piVar6 = piVar6 + 1 + num_samples * 4 + 1;
spuaddress = (&bankaddr)[send_bank];
iVar7 = num_samples * -0x10 + 0xff8;
}
else {
iVar7 = 0x1000;
}
SpuSetTransferMode(0);
SpuSetTransferStartAddr(spuaddress);
SpuWrite(piVar6, iVar7 + 0x3fU & 0xffffffc0);
spuaddress = spuaddress + iVar7;
sample_chunk = sample_chunk + 1;
return;
*/
}
// decompiled code
// original method signature:
// void /*$ra*/ init_spooled_models()
// line 1484, offset 0x0007bebc
/* begin block 1 */
// Start line: 1486
// Start offset: 0x0007BEBC
// Variables:
// int i; // $s1
// int nmodels; // $s4
// int size; // $s2
// int model_number; // $a1
// char *addr; // $s0
// struct MODEL *parentmodel; // $a1
/* begin block 1.1 */
// Start line: 1519
// Start offset: 0x0007BFBC
/* end block 1.1 */
// End offset: 0x0007BFD0
// End Line: 1521
/* begin block 1.2 */
// Start line: 1528
// Start offset: 0x0007C004
/* end block 1.2 */
// End offset: 0x0007C048
// End Line: 1536
/* end block 1 */
// End offset: 0x0007C08C
// End Line: 1543
/* begin block 2 */
// Start line: 3131
/* end block 2 */
// End Line: 3132
/* begin block 3 */
// Start line: 3236
/* end block 3 */
// End Line: 3237
/* begin block 4 */
// Start line: 3237
/* end block 4 */
// End Line: 3238
/* begin block 5 */
// Start line: 3246
/* end block 5 */
// End Line: 3247
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void init_spooled_models(void)
{
int nmodels;
ushort lod;
int model_number;
MODEL *parentmodel;
char *addr;
MODEL *model;
int i;
int size;
addr = model_spool_buffer;
models_ready = 0;
nmodels = *newmodels;
printInfo("loading %d model slots\n", nmodels);
//for (i = 0; i < 1536; i++)
//{
// if (addr <= (char*)&modelpointers[i])
// modelpointers[i] = &dummyModel;
//}
unsigned short* new_model_numbers = newmodels + 1;
for (i = 0; i < nmodels; i++)
{
model_number = new_model_numbers[i];
size = *(int *)addr;
model = (MODEL *)(addr + 4);
modelpointers[model_number] = model;
pLodModels[model_number] = model;
lod = Low2LowerDetailTable[model_number];
if (lod != 0xffff && lod != model_number)
pLodModels[model_number] = modelpointers[lod];
if (model->instance_number == -1)
{
if (model->collision_block != 0)
model->collision_block += (int)model;
model->vertices += (int)model;
model->normals += (int)model;
model->point_normals += (int)model;
InitSpooledAnimObj(model_number);
}
else
{
parentmodel = modelpointers[model->instance_number];
if (parentmodel->collision_block != 0)
model->collision_block = parentmodel->collision_block;
model->vertices = parentmodel->vertices;
model->normals = parentmodel->normals;
model->point_normals = parentmodel->point_normals;
InitSpooledAnimObj(parentmodel->instance_number);
}
model->poly_block += (int)model;
addr += size + 4;
}
LoadingArea = 0;
}
// decompiled code
// original method signature:
// void /*$ra*/ SetupModels()
// line 1545, offset 0x0007e540
/* begin block 1 */
// Start line: 7941
/* end block 1 */
// End Line: 7942
/* begin block 2 */
// Start line: 7945
/* end block 2 */
// End Line: 7946
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void SetupModels(void)
{
if (old_region == -1)
init_spooled_models();
else
models_ready = 1;
}
// decompiled code
// original method signature:
// void /*$ra*/ LoadInAreaModels(int area /*$a0*/)
// line 1559, offset 0x0007e580
/* begin block 1 */
// Start line: 1561
// Start offset: 0x0007E580
// Variables:
// int offset; // $a2
// int length; // $a3
/* end block 1 */
// End offset: 0x0007E5DC
// End Line: 1571
/* begin block 2 */
// Start line: 7969
/* end block 2 */
// End Line: 7970
/* begin block 3 */
// Start line: 7970
/* end block 3 */
// End Line: 7971
/* begin block 4 */
// Start line: 7974
/* end block 4 */
// End Line: 7975
// [D]
void LoadInAreaModels(int area)
{
if (newmodels)
{
// clear old model ids
int nmodels = *newmodels;
unsigned short* new_model_numbers = newmodels + 1;
// set old model ids to dummy
for (int i = 0; i < nmodels; i++)
{
int model_number = new_model_numbers[i];
modelpointers[model_number] = &dummyModel;
}
printInfo("freed %d model slots\n", nmodels);
}
int length = AreaData[area].model_size;
newmodels = (ushort *)(model_spool_buffer + (length-1) * 2048);
RequestSpool(3, 0, AreaData[area].model_offset, length, model_spool_buffer, SetupModels);
}
// decompiled code
// original method signature:
// void /*$ra*/ CheckLoadAreaData(int cellx /*$t9*/, int cellz /*$a1*/)
// line 1574, offset 0x0007c08c
/* begin block 1 */
// Start line: 1575
// Start offset: 0x0007C08C
// Variables:
// int i; // $a2
// int nAreas; // $t0
// struct Spool *spoolptr; // $t1
// int load; // $a3
// int force_load_boundary; // $a0
/* end block 1 */
// End offset: 0x0007C27C
// End Line: 1666
/* begin block 2 */
// Start line: 3485
/* end block 2 */
// End Line: 3486
/* begin block 3 */
// Start line: 3517
/* end block 3 */
// End Line: 3518
/* begin block 4 */
// Start line: 3522
/* end block 4 */
// End Line: 3523
// [D]
void CheckLoadAreaData(int cellx, int cellz)
{
int nAreas;
int load;
int force_load_boundary;
int i;
Spool *spoolptr;
if (spoolinfo_offsets[current_region] == 0xffff)
return;
spoolptr = (Spool *)(RegionSpoolInfo + spoolinfo_offsets[current_region]);
#ifndef PSX
if (LoadedArea != spoolptr->super_region && spoolptr->super_region != 0xFF && old_region != -1)
{
LoadedArea = spoolptr->super_region;
}
else
#endif
if (old_region == -1 && spoolptr->super_region != 0xFF)
{
// just load the area if no
LoadedArea = spoolptr->super_region;
}
else
{
nAreas = spoolptr->num_connected_areas;
if (old_region == -1)
{
LoadedArea = -1;
}
else
{
//if (spoolptr->super_region == 0xFF) // [A] if this is on, it stops spool. You still may want to load connected areas
// return;
if (nAreas == 0)
return;
}
force_load_boundary = (lead_car == 0) ? 15 : 13;
// check area bounds
for (i = 0; i < nAreas; i++)
{
load = spoolptr->connected_areas[i] >> 6;
if (LoadedArea != (spoolptr->connected_areas[i] & 0x3f))
{
new_area_location = load;
// [A] bounds?
if (load == 0 && (32-force_load_boundary < cellz))
{
break;
}
else if (load == 1 && (32-force_load_boundary < cellx))
{
break;
}
else if (load == 2 && (cellz < force_load_boundary))
{
break;
}
else if (load == 3 && (cellx < force_load_boundary))
{
break;
}
}
}
if (nAreas == i)
{
if (LoadedArea != -1)
return;
LoadedArea = initarea;
if (initarea == -1)
return;
}
else
{
LoadedArea = spoolptr->connected_areas[i] & 0x3f;
}
}
LoadingArea = 1;
LoadInAreaTSets(LoadedArea);
LoadInAreaModels(LoadedArea);
}
// decompiled code
// original method signature:
// void /*$ra*/ ClearRegion(int target_region /*$a0*/)
// line 1670, offset 0x0007e3e4
/* begin block 1 */
// Start line: 1671
// Start offset: 0x0007E3E4
// Variables:
// int loop; // $a1
// unsigned short *cell_ptrs_s; // $v1
// unsigned long *pvsptr; // $v0
/* end block 1 */
// End offset: 0x0007E494
// End Line: 1711
/* begin block 2 */
// Start line: 7049
/* end block 2 */
// End Line: 7050
/* begin block 3 */
// Start line: 7594
/* end block 3 */
// End Line: 7595
/* begin block 4 */
// Start line: 7604
/* end block 4 */
// End Line: 7605
// [D]
void ClearRegion(int target_region)
{
long *pvsptr;
ushort *cell_ptrs_s;
int loop;
loop = 1024;
cell_ptrs_s = cell_ptrs + target_region * 1024;
pvsptr = (long *)PVS_Buffers[target_region];
do {
*cell_ptrs_s++ = 0xffff;
*pvsptr++ = 0;
} while (--loop != 0);
ClearMem(PVS_Buffers[target_region]-4, pvsSize[target_region]);
RoadMapDataRegions[target_region] = (short*)PVS_Buffers[0];
}
// decompiled code
// original method signature:
// int /*$ra*/ LoadRegionData(int region /*$s4*/, int target_region /*$s5*/)
// line 1713, offset 0x0007c28c
/* begin block 1 */
// Start line: 1714
// Start offset: 0x0007C28C
// Variables:
// int offset; // $s0
// char *target_unpacked_data; // $t1
// struct Spool *spoolptr; // $s1
// char *roadmap_buffer; // $s6
// char *cell_buffer; // $s3
/* end block 1 */
// End offset: 0x0007C464
// End Line: 1776
/* begin block 2 */
// Start line: 3836
/* end block 2 */
// End Line: 3837
// [D]
int LoadRegionData(int region, int target_region)
{
char *cell_buffer;
ushort *spofs;
int offset;
Spool *spoolptr;
char *roadmap_buffer; // D1 leftover?
roadmap_buffer = NULL; // [A]
spofs = (spoolinfo_offsets + region);
if (*spofs == 0xFFFF) // has region offset?
return 0;
loading_region[target_region] = region;
cell_buffer = packed_cell_pointers;
spoolptr = (Spool *)(RegionSpoolInfo + *spofs);
offset = spoolptr->offset;
//#define HAVANA_AUGUST_DEMO // uncomment to load August Demo HAVANA.LEV
#ifdef HAVANA_AUGUST_DEMO
RequestSpool(0, 0, offset, spoolptr->roadm_size, PVS_Buffers[target_region], NULL);
offset += spoolptr->roadm_size;
RequestSpool(0, 0, offset, spoolptr->cell_data_size[1], packed_cell_pointers, NULL);
offset += spoolptr->cell_data_size[1];
RequestSpool(0, 0, offset, spoolptr->cell_data_size[0], (char *)(cells + cell_slots_add[target_region]), NULL);
offset += spoolptr->cell_data_size[0];
RequestSpool(0, 0, offset, spoolptr->cell_data_size[2], (char *)(cell_objects + num_straddlers + cell_objects_add[target_region]), GotRegion);
offset += spoolptr->cell_data_size[2];
//offset -= spoolptr->roadm_size; // [A] if PVS_Buffers loading temporarily disabled this should be uncommented
spool_regioninfo[spool_regioncounter].nsectors = offset - spoolptr->offset;
#else
extern bool gDriver1Level;
if (gDriver1Level)
{
}
else
{
RequestSpool(0, 0, offset, spoolptr->cell_data_size[1], packed_cell_pointers, NULL);
offset += spoolptr->cell_data_size[1];
RequestSpool(0, 0, offset, spoolptr->cell_data_size[0], (char *)(cells + cell_slots_add[target_region]), NULL);
offset += spoolptr->cell_data_size[0];
RequestSpool(0, 0, offset, spoolptr->cell_data_size[2], (char *)(cell_objects + num_straddlers + cell_objects_add[target_region]), NULL);
offset += spoolptr->cell_data_size[2];
RequestSpool(0, 0, offset, spoolptr->roadm_size, PVS_Buffers[target_region] - 4, GotRegion);
offset += spoolptr->roadm_size;
}
spool_regioninfo[spool_regioncounter].nsectors = offset - spoolptr->offset;
#endif
spool_regioninfo[spool_regioncounter].region_to_unpack = region;
spool_regioninfo[spool_regioncounter].target_barrel_region = target_region;
spool_regioninfo[spool_regioncounter].cell_addr = cell_buffer;
spool_regioninfo[spool_regioncounter].roadm_addr = roadmap_buffer;
return 1;
}
// decompiled code
// original method signature:
// void /*$ra*/ UnpackRegion(int region_to_unpack /*$s1*/, int target_barrel_region /*$s0*/)
// line 1779, offset 0x0007e5dc
/* begin block 1 */
// Start line: 1780
// Start offset: 0x0007E5DC
/* end block 1 */
// End offset: 0x0007E658
// End Line: 1812
/* begin block 2 */
// Start line: 8208
/* end block 2 */
// End Line: 8209
/* begin block 3 */
// Start line: 8417
/* end block 3 */
// End Line: 8418
int RoadMapRegions[4];
// [D]
void UnpackRegion(int region_to_unpack, int target_barrel_region)
{
if (loading_region[target_barrel_region] == -1)
{
if (LoadRegionData(region_to_unpack, target_barrel_region))
spool_regioncounter++;
regions_unpacked[target_barrel_region] = region_to_unpack;
RoadMapRegions[target_barrel_region] = region_to_unpack;
}
}
// decompiled code
// original method signature:
// void /*$ra*/ ProcessSpoolInfoLump(char *lump_ptr /*$a2*/, int lump_size /*$a1*/)
// line 1815, offset 0x0007c464
/* begin block 1 */
// Start line: 1816
// Start offset: 0x0007C464
// Variables:
// int i; // $t2
// int size; // $v1
// int slots_count; // $t0
// int objects_count; // $t1
// int num_of_regions; // $v0
// char *alloclist; // $a3
/* end block 1 */
// End offset: 0x0007C5C0
// End Line: 1918
/* begin block 2 */
// Start line: 4141
/* end block 2 */
// End Line: 4142
/* begin block 3 */
// Start line: 4181
/* end block 3 */
// End Line: 4182
inline int _getIntAdv(char** ptr)
{
int value = *(int*)*ptr;
*ptr += 4;
return value;
}
#define getIntAdv(ptr) _getIntAdv(&ptr)
// [D]
void ProcessSpoolInfoLump(char *lump_ptr, int lump_size)
{
int i;
int size;
char *alloclist;
pvsSize[0] = 0;
pvsSize[1] = 0;
pvsSize[2] = 0;
pvsSize[3] = 0;
char* ptr = lump_ptr;
size = getIntAdv(ptr) * 2048;
if (size < 0x10000)
size = 0x10000; // smaller still should be fixed to 64k
MALLOC_BEGIN();
model_spool_buffer = D_MALLOC(size);
MALLOC_END();
cell_slots_add[4] = 0;
cell_objects_add[4] = 0;
int music_and_ambients_size = getIntAdv(ptr);
Music_And_AmbientOffsets = (SXYPAIR *)ptr; // [A] seems to be UNUSED
ptr += music_and_ambients_size;
NumAreas = getIntAdv(ptr);
AreaData = (AreaDataStr *)ptr;
ptr += sizeof(AreaDataStr) * NumAreas;
AreaTPages = (unsigned char *)ptr;
ptr += NumAreas * 16;
// get the pointers
int* slots_add = (int *)ptr;
ptr += sizeof(int) * 4;
int* objects_add = (int *)ptr;
ptr += sizeof(int) * 4;
int* pvsSizes = (int *)ptr;
ptr += sizeof(int) * 4;
for (i = 0; i < 4; i++)
{
int slots_count = slots_add[i];
int objects_count = objects_add[i];
// set last totals
cell_objects_add[i] = cell_objects_add[4];
cell_slots_add[i] = cell_slots_add[4];
// increment totals
cell_slots_add[4] += slots_count;
cell_objects_add[4] += objects_count;
// by the fact it's a roadmap size + pvs size
pvsSize[i] = pvsSizes[i] + 0x7ffU & 0xfffff800;
MALLOC_BEGIN();
alloclist = D_MALLOC(pvsSize[i]);
MALLOC_END();
PVS_Buffers[i] = alloclist + 4; // +4 for -1 cases
}
int num_of_regions = getIntAdv(ptr);
spoolinfo_offsets = (ushort*)ptr;
ptr += sizeof(ushort) * num_of_regions;
int spoolinfo_size = getIntAdv(ptr);
RegionSpoolInfo = ptr;
}
// decompiled code
// original method signature:
// void /*$ra*/ WaitCloseLid()
// line 1928, offset 0x0007e66c
/* begin block 1 */
// Start line: 1930
// Start offset: 0x0007E66C
// Variables:
// void (*old)(); // $s1
/* end block 1 */
// End offset: 0x0007E6D8
// End Line: 1942
/* begin block 2 */
// Start line: 8731
/* end block 2 */
// End Line: 8732
/* begin block 3 */
// Start line: 8732
/* end block 3 */
// End Line: 8733
/* begin block 4 */
// Start line: 8733
/* end block 4 */
// End Line: 8734
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void WaitCloseLid(void)
{
#ifdef PSX
void (*old)();
int loop;
old = (void(*)())CdReadyCallback(0);
stopgame();
while (loop = CdDiskReady(1), loop != 2)
{
DrawCDicon();
VSync(0);
}
startgame();
CdReadyCallback((CdlCB)old);
#endif // PSX
}
// decompiled code
// original method signature:
// void /*$ra*/ FoundError(char *name /*$a0*/, unsigned char intr /*$a1*/, unsigned char *result /*$a2*/)
// line 1945, offset 0x0007e6d8
/* begin block 1 */
// Start line: 1947
// Start offset: 0x0007E6D8
// Variables:
// struct CdlLOC p; // stack offset -16
/* end block 1 */
// End offset: 0x0007E724
// End Line: 1963
/* begin block 2 */
// Start line: 8761
/* end block 2 */
// End Line: 8762
/* begin block 3 */
// Start line: 8765
/* end block 3 */
// End Line: 8766
/* begin block 4 */
// Start line: 8766
/* end block 4 */
// End Line: 8767
/* begin block 5 */
// Start line: 8768
/* end block 5 */
// End Line: 8769
// [D]
void FoundError(char *name, unsigned char intr, unsigned char *result)
{
#ifndef SIMPLE_SPOOL
CdlLOC p;
if ((*result & 0x10) != 0)
{
WaitCloseLid();
}
#ifdef _DEBUG
printError("FoundError: %s, intr: %d\n", name, intr);
#endif // _DEBUG
spoolerror = 0x3c;
#ifdef PSX
CdIntToPos(current_sector, &p);
CdControlF(CdlReadS, (u_char*)&p);
#else
UNIMPLEMENTED();
#endif
#endif // SIMPLE_SPOOL
}
// decompiled code
// original method signature:
// void /*$ra*/ GotRegion()
// line 1970, offset 0x0007d9cc
/* begin block 1 */
// Start line: 1972
// Start offset: 0x0007D9CC
// Variables:
// int cbr; // $a1
/* end block 1 */
// End offset: 0x0007DA60
// End Line: 1990
/* begin block 2 */
// Start line: 6109
/* end block 2 */
// End Line: 6110
/* begin block 3 */
// Start line: 3940
/* end block 3 */
// End Line: 3941
/* begin block 4 */
// Start line: 6110
/* end block 4 */
// End Line: 6111
/* begin block 5 */
// Start line: 6113
/* end block 5 */
// End Line: 6114
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void GotRegion(void)
{
uint target_barrel_reg;
Unpack_CellPtrs();
target_barrel_reg = spool_regioninfo[spool_regionpos].target_barrel_region;
spool_regionpos++;
char* pvs = PVS_Buffers[target_barrel_reg];
loading_region[target_barrel_reg] = -1;
int cbr = *(int *)(pvs - 4);
RoadMapDataRegions[target_barrel_reg] = (short*)(pvs + cbr);
if (spool_regionpos == spool_regioncounter)
{
spool_regioncounter = 0;
spool_regionpos = 0;
}
}
// decompiled code
// original method signature:
// void /*$ra*/ data_cb_textures()
// line 1993, offset 0x0007df64
/* begin block 1 */
// Start line: 1995
// Start offset: 0x0007DF64
/* begin block 1.1 */
// Start line: 1997
// Start offset: 0x0007DF78
/* end block 1.1 */
// End offset: 0x0007E068
// End Line: 2033
/* end block 1 */
// End offset: 0x0007E078
// End Line: 2034
/* begin block 2 */
// Start line: 6680
/* end block 2 */
// End Line: 6681
/* begin block 3 */
// Start line: 3986
/* end block 3 */
// End Line: 3987
/* begin block 4 */
// Start line: 6681
/* end block 4 */
// End Line: 6682
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void data_cb_textures(void)
{
#ifndef SIMPLE_SPOOL
//printf("data_cb_textures remaining: %d\n", sectors_to_read);
if (chunk_complete != 0)
{
chunk_complete = 0;
nTPchunks = nTPchunks_writing;
SendTPage();
if (nTPchunks != 0)
loadbank_write++;
nTPchunks_writing++;
if (nTPchunks_writing == 5)
{
nTPchunks_writing = 0;
spoolpos_writing++;
if (ntpages == 0)
{
if (switch_spooltype == 0)
{
#ifdef PSX
CdDataCallback(0);
#else
levelSpoolerPCDataCallback(NULL);
#endif // PSX
if (spoolpos_writing == spoolcounter)
{
printWarning("All SPOOL requests (%d) completed successfully on TEXTURES\n", spoolcounter); // [A]
spoolcounter = 0;
spoolpos_writing = 0;
spoolpos_reading = 0;
spoolactive = 0;
}
else
{
UpdateSpool();
}
}
else
{
changemode(spooldata + spoolpos_writing);
}
}
}
}
#endif // SIMPLE_SPOOL
}
// decompiled code
// original method signature:
// void /*$ra*/ ready_cb_textures(unsigned char intr /*$s0*/, unsigned char *result /*$a2*/)
// line 2036, offset 0x0007e078
/* begin block 1 */
// Start line: 2037
// Start offset: 0x0007E078
/* begin block 1.1 */
// Start line: 2050
// Start offset: 0x0007E0D8
// Variables:
// struct SPOOLQ *current; // $a2
/* end block 1.1 */
// End offset: 0x0007E188
// End Line: 2080
/* end block 1 */
// End offset: 0x0007E198
// End Line: 2086
/* begin block 2 */
// Start line: 6770
/* end block 2 */
// End Line: 6771
/* begin block 3 */
// Start line: 6773
/* end block 3 */
// End Line: 6774
// [D]
void ready_cb_textures(unsigned char intr, unsigned char *result)
{
#ifndef SIMPLE_SPOOL
if (intr == 1)
{
#ifdef PSX
CdGetSector(target_address, 0x200);
#else
getLevSectorPC(target_address, 0x200);
#endif // PSX
target_address = target_address + 0x800;
sectors_this_chunk--;
current_sector++;
sectors_to_read--;
if (sectors_this_chunk == 0)
{
if (nTPchunks_reading != 0)
loadbank_read++;
nTPchunks_reading++;
chunk_complete = intr;
if (sectors_to_read == 0)
{
ntpages--;
if (ntpages == 0)
{
spoolpos_reading++;
test_changemode();
}
else
{
nTPchunks_reading = 0;
sectors_to_read = 17;
target_address = spooldata[spoolpos_reading].addr + 0x4000;
spoolpos_reading++;
sectors_this_chunk = intr;
}
}
else
{
sectors_this_chunk = 4;
target_address = spooldata[spoolpos_reading].addr + (loadbank_read & 1U) * 0x2000;
}
}
}
else
FoundError("ready_cb_textures", intr, result);
#endif // SIMPLE_SPOOL
}
// decompiled code
// original method signature:
// void /*$ra*/ ready_cb_regions(unsigned char intr /*$s0*/, unsigned char *result /*$a2*/)
// line 2090, offset 0x0007de90
/* begin block 1 */
// Start line: 2091
// Start offset: 0x0007DE90
/* begin block 1.1 */
// Start line: 2110
// Start offset: 0x0007DF08
// Variables:
// struct SPOOLQ *current; // $v1
/* end block 1.1 */
// End offset: 0x0007DF08
// End Line: 2110
/* end block 1 */
// End offset: 0x0007DF64
// End Line: 2129
/* begin block 2 */
// Start line: 6728
/* end block 2 */
// End Line: 6729
/* begin block 3 */
// Start line: 4180
/* end block 3 */
// End Line: 4181
void ready_cb_regions(unsigned char intr, unsigned char *result)
{
#ifndef SIMPLE_SPOOL
if (intr == 1)
{
#ifdef PSX
CdGetSector(target_address, 0x200);
#else
getLevSectorPC(target_address, 0x200);
#endif // PSX
target_address = target_address + 0x800;
sectors_this_chunk--;
current_sector++;
sectors_to_read--;
if (sectors_this_chunk == 0)
{
spoolpos_reading++;
chunk_complete = intr;
if (sectors_to_read == 0)
{
endchunk = intr;
test_changemode();
}
else
{
target_address = spooldata[spoolpos_reading].addr;
sectors_this_chunk = (spooldata[spoolpos_reading].nsectors);
}
}
}
else
FoundError("ready_cb_regions", intr, result);
#endif // SIMPLE_SPOOL
}
// decompiled code
// original method signature:
// void /*$ra*/ data_cb_regions()
// line 2132, offset 0x0007dda8
/* begin block 1 */
// Start line: 2134
// Start offset: 0x0007DDA8
/* begin block 1.1 */
// Start line: 2136
// Start offset: 0x0007DDBC
// Variables:
// struct SPOOLQ *current; // $v0
/* end block 1.1 */
// End offset: 0x0007DE80
// End Line: 2167
/* end block 1 */
// End offset: 0x0007DE90
// End Line: 2168
/* begin block 2 */
// Start line: 4264
/* end block 2 */
// End Line: 4265
/* begin block 3 */
// Start line: 6733
/* end block 3 */
// End Line: 6734
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void data_cb_regions(void)
{
#ifndef SIMPLE_SPOOL
//printf("data_cb_regions remaining: %d\n", sectors_to_read);
SPOOLQ* current = &spooldata[spoolpos_writing];
if (chunk_complete != 0)
{
chunk_complete = 0;
if (current->func != NULL)
(current->func)();
spoolpos_writing++;
if (endchunk != 0)
{
if (switch_spooltype == 0)
{
#ifdef PSX
CdDataCallback(0);
#else
levelSpoolerPCDataCallback(NULL);
#endif // PSX
if (spoolpos_writing == spoolcounter)
{
printWarning("All SPOOL requests (%d) completed successfully on REGIONS\n", spoolcounter); // [A]
spoolcounter = 0;
spoolpos_writing = 0;
spoolpos_reading = 0;
spoolactive = 0;
}
else
{
UpdateSpool();
}
}
else
{
changemode(&spooldata[spoolpos_writing]);
}
}
}
#endif // SIMPLE_SPOOL
}
// decompiled code
// original method signature:
// void /*$ra*/ data_cb_soundbank()
// line 2171, offset 0x0007dbcc
/* begin block 1 */
// Start line: 2173
// Start offset: 0x0007DBCC
/* begin block 1.1 */
// Start line: 2175
// Start offset: 0x0007DBE0
/* end block 1.1 */
// End offset: 0x0007DC94
// End Line: 2200
/* end block 1 */
// End offset: 0x0007DCA4
// End Line: 2201
/* begin block 2 */
// Start line: 4342
/* end block 2 */
// End Line: 4343
/* begin block 3 */
// Start line: 6666
/* end block 3 */
// End Line: 6667
/* WARNING: Unknown calling convention yet parameter storage is locked */
void data_cb_soundbank(void)
{
UNIMPLEMENTED();
/*
if (chunk_complete != 0) {
chunk_complete = 0;
SendSBK();
loadbank_write = loadbank_write + 1;
if (endchunk != 0) {
spoolpos_writing = spoolpos_writing + 1;
if (switch_spooltype == 0) {
#ifdef PSX
CdDataCallback(0);
#else
UNIMPLEMENTED();
#endif // PSX
if (spoolpos_writing == spoolcounter) {
spoolcounter = 0;
spoolpos_writing = 0;
spoolpos_reading = 0;
spoolactive = 0;
}
else {
UpdateSpool();
}
}
else {
changemode(spooldata + spoolpos_writing);
}
}
}
return;*/
}
// decompiled code
// original method signature:
// void /*$ra*/ ready_cb_soundbank(unsigned char intr /*$s0*/, unsigned char *result /*$a2*/)
// line 2203, offset 0x0007dca4
/* begin block 1 */
// Start line: 2204
// Start offset: 0x0007DCA4
/* begin block 1.1 */
// Start line: 2217
// Start offset: 0x0007DD04
// Variables:
// struct SPOOLQ *current; // $a0
/* end block 1.1 */
// End offset: 0x0007DD70
// End Line: 2237
/* end block 1 */
// End offset: 0x0007DD98
// End Line: 2244
/* begin block 2 */
// Start line: 6729
/* end block 2 */
// End Line: 6730
/* begin block 3 */
// Start line: 6732
/* end block 3 */
// End Line: 6733
void ready_cb_soundbank(unsigned char intr, unsigned char *result)
{
UNIMPLEMENTED();
/*
uint uVar1;
uVar1 = (uint)intr;
if (intr == '\x01') {
#ifdef PSX
CdGetSector(target_address, 0x200);
#else
getLevSectorPC(target_address, 0x200);
#endif // PSX
target_address = target_address + 0x800;
sectors_this_chunk--;
current_sector++;
sectors_to_read--;
if (sectors_this_chunk == 0) {
loadbank_read = loadbank_read + 1;
nTPchunks_reading = nTPchunks_reading + 1;
chunk_complete = uVar1;
if (sectors_to_read == 0) {
spoolpos_reading = spoolpos_reading + 1;
endchunk = uVar1;
test_changemode();
}
else {
sectors_this_chunk = 2;
if (sectors_to_read < 2) {
sectors_this_chunk = sectors_to_read;
}
target_address = spooldata[spoolpos_reading].addr + (loadbank_read & 1U) * 0x1000;
}
}
}
else {
FoundError(s_ready_cb_soundbank_00011d5c, intr, result);
}
return;*/
}
// decompiled code
// original method signature:
// void /*$ra*/ data_cb_misc()
// line 2246, offset 0x0007da60
/* begin block 1 */
// Start line: 2248
// Start offset: 0x0007DA60
/* begin block 1.1 */
// Start line: 2250
// Start offset: 0x0007DA74
// Variables:
// struct SPOOLQ *current; // $v0
/* end block 1.1 */
// End offset: 0x0007DB28
// End Line: 2275
/* end block 1 */
// End offset: 0x0007DB38
// End Line: 2276
/* begin block 2 */
// Start line: 6421
/* end block 2 */
// End Line: 6422
/* begin block 3 */
// Start line: 6678
/* end block 3 */
// End Line: 6679
/* begin block 4 */
// Start line: 6679
/* end block 4 */
// End Line: 6680
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void data_cb_misc(void)
{
#ifndef SIMPLE_SPOOL
//printf("data_cb_misc remaining: %d\n", sectors_to_read);
SPOOLQ *current = &spooldata[spoolpos_writing];
if (chunk_complete != 0)
{
chunk_complete = 0;
if (current->func != NULL)
{
(*current->func)();
}
spoolpos_writing++;
if (switch_spooltype == 0)
{
#ifdef PSX
CdDataCallback(0);
#else
levelSpoolerPCDataCallback(NULL);
#endif // PSX
if (spoolpos_writing == spoolcounter)
{
printWarning("All SPOOL requests (%d) completed successfully on MISC\n", spoolcounter); // [A]
spoolcounter = 0;
spoolpos_writing = 0;
spoolpos_reading = 0;
spoolactive = 0;
}
else
{
UpdateSpool();
}
}
else
{
changemode(spooldata + spoolpos_writing);
}
}
#endif // SIMPLE_SPOOL
}
// decompiled code
// original method signature:
// void /*$ra*/ ready_cb_misc(unsigned char intr /*$s0*/, unsigned char *result /*$a2*/)
// line 2278, offset 0x0007db38
/* begin block 1 */
// Start line: 6744
/* end block 1 */
// End Line: 6745
/* begin block 2 */
// Start line: 6747
/* end block 2 */
// End Line: 6748
// [D]
void ready_cb_misc(unsigned char intr, unsigned char *result)
{
#ifndef SIMPLE_SPOOL
if (intr == 1)
{
#ifdef PSX
CdGetSector(target_address, 0x200);
#else
getLevSectorPC(target_address, 0x200);
#endif // PSX
target_address = target_address + 0x800;
sectors_to_read--;
current_sector++;
if (sectors_to_read == 0)
{
spoolpos_reading++;
chunk_complete = intr;
test_changemode();
}
}
else
{
FoundError("ready_cb_misc", intr, result);
}
#endif // SIMPLE_SPOOL
}
// decompiled code
// original method signature:
// void /*$ra*/ StartSpooling()
// line 2302, offset 0x0007e724
/* begin block 1 */
// Start line: 2304
// Start offset: 0x0007E724
/* end block 1 */
// End offset: 0x0007E7B0
// End Line: 2321
/* begin block 2 */
// Start line: 9140
/* end block 2 */
// End Line: 9141
/* begin block 3 */
// Start line: 9480
/* end block 3 */
// End Line: 9481
/* begin block 4 */
// Start line: 9481
/* end block 4 */
// End Line: 9482
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void StartSpooling(void)
{
static unsigned char param[8];
static unsigned char result[8];
int iVar1;
if ((spoolcounter != 0) && (spoolactive == 0))
{
iVar1 = XAPrepared();
if (iVar1 == 0)
{
#ifdef PSX
param[0] = -0x80;
CdControlB(0xe, param, result);
if ((result[0] & 0x15) != 0)
{
WaitCloseLid();
}
#endif // PSX
spoolactive = 1;
UpdateSpool();
if (FastForward != 0)
{
SpoolSYNC();
}
}
}
}
// decompiled code
// original method signature:
// void /*$ra*/ unpack_cellpointers()
// line 2351, offset 0x0007c5c0
/* begin block 1 */
// Start line: 2353
// Start offset: 0x0007C5C0
// Variables:
// int target_barrel_region; // $t0
// char *source_packed_data; // $v0
// int bitpos; // $a3
// int loop; // $a2
// int packtype; // $a0
// unsigned short cell; // $a0
// unsigned short *short_ptr; // $a1
// unsigned short pcode; // $t1
/* end block 1 */
// End offset: 0x0007C74C
// End Line: 2437
/* begin block 2 */
// Start line: 4939
/* end block 2 */
// End Line: 4940
/* begin block 3 */
// Start line: 5373
/* end block 3 */
// End Line: 5374
/* begin block 4 */
// Start line: 5374
/* end block 4 */
// End Line: 5375
/* begin block 5 */
// Start line: 5383
/* end block 5 */
// End Line: 5384
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D] [A] - altered declaration
void unpack_cellpointers(int region_to_unpack, int target_barrel_region, char* cell_addr)
{
ushort *puVar1;
ushort *puVar2;
ushort uVar3;
int loop;
uint uVar6;
uint uVar7;
int packtype;
unpack_cellptr_flag = 0;
packtype = *(int *)(cell_addr + 4);
puVar1 = (ushort *)(cell_addr + 8);
if (packtype == 0)
{
puVar1 = cell_ptrs + target_barrel_region * 1024;
for (loop = 0; loop < 1024; loop++)
*puVar1++ = 0xffff;
}
else if (packtype == 1)
{
puVar2 = cell_ptrs + target_barrel_region * 1024;
for (loop = 0; loop < 1024; loop++)
{
uVar3 = *puVar1++;
if (uVar3 != 0xffff)
uVar3 += cell_slots_add[target_barrel_region];
*puVar2++ = uVar3;
}
}
else if (packtype == 2)
{
uVar6 = 0x8000;
uVar7 = (uint)*puVar1;
puVar2 = (ushort *)(cell_addr + 10);
puVar1 = cell_ptrs + target_barrel_region * 1024;
for (loop = 0; loop < 1024; loop++)
{
if (uVar7 & uVar6)
{
uVar3 = *puVar2++;
uVar3 += cell_slots_add[target_barrel_region];
}
else
uVar3 = 0xffff;
uVar6 >>= 1;
*puVar1++ = uVar3;
if (uVar6 == 0)
{
uVar6 = 0x8000;
uVar7 = *puVar2++;
}
}
}
else
{
if (FrameCnt != 0x78654321)
{
do {
trap(0x400);
} while (FrameCnt != 0x78654321);
unpack_cellptr_flag = 0;
}
}
}
// decompiled code
// original method signature:
// void /*$ra*/ Unpack_CellPtrs()
// line 2442, offset 0x0007d978
/* begin block 1 */
// Start line: 2444
// Start offset: 0x0007D978
// Variables:
// int region_to_unpack; // $a1
// int target_barrel_region; // $a1
// char *source_packed_data; // $v1
/* end block 1 */
// End offset: 0x0007D9CC
// End Line: 2469
/* begin block 2 */
// Start line: 4884
/* end block 2 */
// End Line: 4885
/* begin block 3 */
// Start line: 6539
/* end block 3 */
// End Line: 6540
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D] [A] altered unpack_cellpointers
void Unpack_CellPtrs(void)
{
SPL_REGIONINFO* spool = &spool_regioninfo[spool_regionpos];
unpack_cellpointers(spool->region_to_unpack, spool->target_barrel_region, spool->cell_addr);
}
// decompiled code
// original method signature:
// void /*$ra*/ SpecClutsSpooled()
// line 2509, offset 0x0007c74c
/* begin block 1 */
// Start line: 2511
// Start offset: 0x0007C74C
// Variables:
// char *loadaddr; // $s4
// int i; // $s1
// int j; // $s2
// int tpage; // $s0
// struct RECT specCluts; // stack offset -48
/* begin block 1.1 */
// Start line: 2522
// Start offset: 0x0007C7F4
// Variables:
// int index; // $a3
/* begin block 1.1.1 */
// Start line: 2537
// Start offset: 0x0007C91C
/* end block 1.1.1 */
// End offset: 0x0007C91C
// End Line: 2537
/* end block 1.1 */
// End offset: 0x0007C95C
// End Line: 2542
/* end block 1 */
// End offset: 0x0007C9B8
// End Line: 2546
/* begin block 2 */
// Start line: 5647
/* end block 2 */
// End Line: 5648
/* begin block 3 */
// Start line: 5720
/* end block 3 */
// End Line: 5721
/* begin block 4 */
// Start line: 5721
/* end block 4 */
// End Line: 5722
/* begin block 5 */
// Start line: 5730
/* end block 5 */
// End Line: 5731
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void SpecClutsSpooled(void)
{
unsigned char bVar1;
short sVar2;
short sVar3;
u_short uVar4;
int iVar5;
int iVar6;
uint uVar7;
ushort *puVar8;
int iVar9;
int iVar10;
char *pcVar11;
RECT16 specCluts;
iVar9 = 0;
specCluts.x = slot_clutpos[specialSlot].vx;
specCluts.y = slot_clutpos[specialSlot].vy;
specCluts.w = 16;
specCluts.h = 1;
pcVar11 = specLoadBuffer;
do {
iVar5 = 7;
if (iVar9 == 0)
iVar5 = 6;
iVar10 = 0;
iVar6 = specialSlot + iVar9;
int tpage = specTpages[GameLevel][(specspooldata[2]-1) * 2 + iVar9];
carTpages[GameLevel][iVar5] = tpageslots[iVar6] = tpage;
tpageloaded[tpage] = specialSlot + iVar9 + 1;
slot_tpagepos[iVar6].vx = tpagepos[iVar6].x;
slot_tpagepos[iVar6].vy = tpagepos[iVar6].y;
texture_pages[tpage] = GetTPage(0, 0, slot_tpagepos[iVar6].vx, slot_tpagepos[iVar6].vy);
if (0 < tpage_texamts[tpage])
{
puVar8 = texture_cluts[tpage];
do {
LoadImage2(&specCluts, (u_long*)pcVar11);
pcVar11 += 32;
*puVar8++ = GetClut(specCluts.x, specCluts.y);
IncrementClutNum(&specCluts);
iVar10++;
} while (iVar10 < tpage_texamts[tpage]);
}
iVar9++;
} while (iVar9 < 2);
if (quickSpool != 1)
{
DrawSyncCallback(SpecialStartNextBlock);
}
}
// decompiled code
// original method signature:
// void /*$ra*/ CleanModelSpooled()
// line 2549, offset 0x0007c9b8
/* begin block 1 */
// Start line: 2552
// Start offset: 0x0007C9B8
// Variables:
// int *loadaddr; // $a1
// int *mem; // $a3
/* begin block 1.1 */
// Start line: 2576
// Start offset: 0x0007CA80
/* end block 1.1 */
// End offset: 0x0007CAD0
// End Line: 2587
/* end block 1 */
// End offset: 0x0007CAFC
// End Line: 2591
/* begin block 2 */
// Start line: 5870
/* end block 2 */
// End Line: 5871
/* begin block 3 */
// Start line: 5874
/* end block 3 */
// End Line: 5875
/* begin block 4 */
// Start line: 5876
/* end block 4 */
// End Line: 5877
/* begin block 5 */
// Start line: 5880
/* end block 5 */
// End Line: 5881
/* WARNING: Unknown calling convention yet parameter storage is locked */
int *modelMemory;
int lengthLowBlock;
int lastCleanBlock;
int lengthDamBlock;
int firstLowBlock;
int firstDamBlock;
int specBlocksToLoad = 0;
int specialState = 0;
char specModelValid = 1;
int specSpoolComplete;
// [D]
void CleanModelSpooled(void)
{
int *piVar1;
ushort *puVar2;
int iVar4;
int *piVar5;
int *in_a3;
piVar5 = (int *)specLoadBuffer;
if (specBlocksToLoad == lastCleanBlock-1)
{
piVar5 = (int *)(specLoadBuffer + 12);
modelMemory = (int *)specmallocptr;
gCarCleanModelPtr[4] = (MODEL *)specmallocptr;
}
// memcpy
while (piVar5 < (int*)(specLoadBuffer + 0x800))
*modelMemory++ = *piVar5++;
in_a3 = (int*)((int)gCarCleanModelPtr[4] + gCarCleanModelPtr[4]->poly_block); // [A] pls check, might be invalid
if (specBlocksToLoad == 0 || in_a3 < modelMemory)
{
specBlocksToLoad = 0;
modelMemory = in_a3;
gCarCleanModelPtr[4]->vertices += (int)gCarCleanModelPtr[4];
gCarCleanModelPtr[4]->normals += (int)gCarCleanModelPtr[4];
gCarCleanModelPtr[4]->point_normals += (int)gCarCleanModelPtr[4];
gCarCleanModelPtr[4]->poly_block += (int)gCarCleanModelPtr[4];
NewCarModel[4].nlist = (SVECTOR *)gCarCleanModelPtr[4]->point_normals;
NewCarModel[4].vlist = (SVECTOR *)gCarCleanModelPtr[4]->vertices;
}
if (quickSpool != 1)
DrawSyncCallback(SpecialStartNextBlock);
}
// decompiled code
// original method signature:
// void /*$ra*/ DamagedModelSpooled()
// line 2594, offset 0x0007cafc
/* begin block 1 */
// Start line: 2596
// Start offset: 0x0007CAFC
// Variables:
// int *loadaddr; // $a1
// int *mem; // $a3
/* begin block 1.1 */
// Start line: 2620
// Start offset: 0x0007CBC0
/* end block 1.1 */
// End offset: 0x0007CBF8
// End Line: 2629
/* end block 1 */
// End offset: 0x0007CC24
// End Line: 2633
/* begin block 2 */
// Start line: 5981
/* end block 2 */
// End Line: 5982
/* begin block 3 */
// Start line: 5985
/* end block 3 */
// End Line: 5986
/* begin block 4 */
// Start line: 5986
/* end block 4 */
// End Line: 5987
/* begin block 5 */
// Start line: 5990
/* end block 5 */
// End Line: 5991
/* WARNING: Unknown calling convention yet parameter storage is locked */
int damOffset;
// [D]
void DamagedModelSpooled(void)
{
MODEL *pMVar1;
int iVar2;
int *piVar3;
int *in_a3;
piVar3 = (int *)specLoadBuffer;
if (specBlocksToLoad == lengthDamBlock + -1)
{
piVar3 = (int *)(specLoadBuffer + damOffset);
gCarDamModelPtr[4] = (MODEL *)modelMemory;
}
// memcpy
while (piVar3 < (int*)(specLoadBuffer + 0x800))
*modelMemory++ = *piVar3++;
in_a3 = (int*)((int)gCarDamModelPtr[4] + gCarDamModelPtr[4]->poly_block); // [A] pls check, might be invalid
if (specBlocksToLoad == 0 || in_a3 < modelMemory)
{
piVar3 = &gCarDamModelPtr[4]->normals;
specBlocksToLoad = 0;
modelMemory = in_a3;
gCarDamModelPtr[4]->vertices += (int)gCarDamModelPtr[4];
gCarDamModelPtr[4]->normals += (int)gCarDamModelPtr[4];
gCarDamModelPtr[4]->poly_block += (int)gCarDamModelPtr[4];
gCarDamModelPtr[4]->point_normals += (int)gCarDamModelPtr[4];
}
if (quickSpool != 1)
DrawSyncCallback(SpecialStartNextBlock);
}
// decompiled code
// original method signature:
// void /*$ra*/ LowModelSpooled()
// line 2635, offset 0x0007cc24
/* begin block 1 */
// Start line: 2637
// Start offset: 0x0007CC24
// Variables:
// int *loadaddr; // $a1
// int *mem; // $a3
/* begin block 1.1 */
// Start line: 2661
// Start offset: 0x0007CCE8
/* end block 1.1 */
// End offset: 0x0007CD38
// End Line: 2672
/* end block 1 */
// End offset: 0x0007CD64
// End Line: 2676
/* begin block 2 */
// Start line: 6081
/* end block 2 */
// End Line: 6082
/* begin block 3 */
// Start line: 6084
/* end block 3 */
// End Line: 6085
/* begin block 4 */
// Start line: 6085
/* end block 4 */
// End Line: 6086
/* begin block 5 */
// Start line: 6089
/* end block 5 */
// End Line: 6090
/* WARNING: Unknown calling convention yet parameter storage is locked */
int lowOffset;
// [D]
void LowModelSpooled(void)
{
int *piVar1;
ushort *puVar2;
int iVar4;
int *piVar5;
int *in_a3;
piVar5 = (int *)specLoadBuffer;
if (specBlocksToLoad == lengthLowBlock + -1)
{
piVar5 = (int *)(specLoadBuffer + lowOffset);
gCarLowModelPtr[4] = (MODEL *)modelMemory;
}
// memcpy
while (piVar5 < (int*)(specLoadBuffer + 0x800))
*modelMemory++ = *piVar5++;
in_a3 = (int*)((int)gCarLowModelPtr[4] + gCarLowModelPtr[4]->poly_block); // [A] pls check, might be invalid
if ((specBlocksToLoad == 0) || (in_a3 < modelMemory))
{
specBlocksToLoad = 0;
modelMemory = in_a3;
gCarLowModelPtr[4]->vertices += (int)gCarLowModelPtr[4];
gCarLowModelPtr[4]->normals += (int)gCarLowModelPtr[4];
gCarLowModelPtr[4]->poly_block += (int)gCarLowModelPtr[4];
gCarLowModelPtr[4]->point_normals += (int)gCarLowModelPtr[4];
NewLowCarModel[4].nlist = (SVECTOR *)gCarLowModelPtr[4]->point_normals;
NewLowCarModel[4].vlist = (SVECTOR *)gCarLowModelPtr[4]->vertices;
}
if (quickSpool != 1) {
DrawSyncCallback(SpecialStartNextBlock);
}
}
// decompiled code
// original method signature:
// void /*$ra*/ CleanSpooled()
// line 2680, offset 0x0007cd64
/* begin block 1 */
// Start line: 2683
// Start offset: 0x0007CD64
// Variables:
// char *loadaddr; // $a1
/* begin block 1.1 */
// Start line: 2702
// Start offset: 0x0007CE8C
// Variables:
// struct MODEL *tempModel; // $a1
/* end block 1.1 */
// End offset: 0x0007CEE0
// End Line: 2713
/* end block 1 */
// End offset: 0x0007CF0C
// End Line: 2717
/* begin block 2 */
// Start line: 6189
/* end block 2 */
// End Line: 6190
/* begin block 3 */
// Start line: 6194
/* end block 3 */
// End Line: 6195
/* begin block 4 */
// Start line: 6196
/* end block 4 */
// End Line: 6197
/* begin block 5 */
// Start line: 6198
/* end block 5 */
// End Line: 6199
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void CleanSpooled(void)
{
int *piVar1;
char *pcVar2;
int iVar3;
int iVar4;
MODEL *model;
if (specBlocksToLoad == 6)
{
lastCleanBlock = *(int *)specmallocptr + 0x80b;
lastCleanBlock = lastCleanBlock >> 0xb;
firstLowBlock = *(int *)specmallocptr + *(int *)(specmallocptr + 4) + 0xc;
firstLowBlock = firstLowBlock >> 0xb;
iVar4 = *(int *)specmallocptr + *(int *)(specmallocptr + 4) + *(int *)(specmallocptr + 8);
iVar3 = iVar4 + 0x80b;
lengthLowBlock = (iVar3 >> 0xb) - firstLowBlock;
lowOffset = (*(int *)specmallocptr + *(int *)(specmallocptr + 4)) - (firstLowBlock * 0x800 + -12);
firstDamBlock = *(int *)specmallocptr + 12;
firstDamBlock = firstDamBlock >> 0xb;
iVar3 = *(int *)specmallocptr + *(int *)(specmallocptr + 4) + 0x80b;
lengthDamBlock = (iVar3 >> 0xb) - firstDamBlock;
damOffset = *(int *)specmallocptr - (firstDamBlock * 0x800 + -12);
}
model = (MODEL *)(specmallocptr + 12);
if (specBlocksToLoad == 7-lastCleanBlock)
{
model->vertices += (int)model;
model->poly_block += (int)model;
model->normals += (int)model;
model->point_normals += (int)model;
whichCP = baseSpecCP;
buildNewCarFromModel(&NewCarModel[4], model, 0);
specBlocksToLoad = 0;
}
if (quickSpool != 1)
DrawSyncCallback(SpecialStartNextBlock);
}
// decompiled code
// original method signature:
// void /*$ra*/ LowSpooled()
// line 2720, offset 0x0007e7c0
/* begin block 1 */
// Start line: 2723
// Start offset: 0x0007E7C0
// Variables:
// char *loadaddr; // $v1
/* begin block 1.1 */
// Start line: 2728
// Start offset: 0x0007E7D8
// Variables:
// struct MODEL *tempModel; // $a1
/* end block 1.1 */
// End offset: 0x0007E820
// End Line: 2737
/* end block 1 */
// End offset: 0x0007E84C
// End Line: 2741
/* begin block 2 */
// Start line: 10317
/* end block 2 */
// End Line: 10318
/* begin block 3 */
// Start line: 10319
/* end block 3 */
// End Line: 10320
/* begin block 4 */
// Start line: 10321
/* end block 4 */
// End Line: 10322
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void LowSpooled(void)
{
MODEL *model;
if (specBlocksToLoad == 0)
{
model = (MODEL *)(specmallocptr + lowOffset);
model->vertices += (int)model;
model->normals += (int)model;
model->poly_block += (int)model;
model->point_normals += (int)model;
buildNewCarFromModel(&NewLowCarModel[4], model, 0);
}
if (quickSpool != 1)
DrawSyncCallback(SpecialStartNextBlock);
}
// decompiled code
// original method signature:
// void /*$ra*/ Tada()
// line 2744, offset 0x0007cf0c
/* begin block 1 */
// Start line: 2746
// Start offset: 0x0007CF0C
// Variables:
// char *loadaddr; // $s1
/* begin block 1.1 */
// Start line: 2751
// Start offset: 0x0007CF60
// Variables:
// struct RECT tpage; // stack offset -32
// int spec_tpage; // $a0
/* end block 1.1 */
// End offset: 0x0007D018
// End Line: 2764
/* begin block 1.2 */
// Start line: 2767
// Start offset: 0x0007D018
// Variables:
// struct RECT tpage; // stack offset -24
// int spec_tpage; // $a0
/* end block 1.2 */
// End offset: 0x0007D0EC
// End Line: 2780
/* begin block 1.3 */
// Start line: 2783
// Start offset: 0x0007D0EC
/* end block 1.3 */
// End offset: 0x0007D130
// End Line: 2789
/* end block 1 */
// End offset: 0x0007D144
// End Line: 2793
/* begin block 2 */
// Start line: 6312
/* end block 2 */
// End Line: 6313
/* begin block 3 */
// Start line: 6340
/* end block 3 */
// End Line: 6341
/* begin block 4 */
// Start line: 6341
/* end block 4 */
// End Line: 6342
/* begin block 5 */
// Start line: 6342
/* end block 5 */
// End Line: 6343
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void Tada(void)
{
int spec_tpage;
RECT16 tpagerect;
if (specialState == 2)
{
tpagerect.w = 64;
tpagerect.h = 16;
spec_tpage = specialSlot + 1;
tpagerect.x = tpagepos[spec_tpage].x;
tpagerect.y = tpagepos[spec_tpage].y + (15 - specBlocksToLoad) * 16;
if (specBlocksToLoad == 15)
update_slotinfo(specTpages[GameLevel][specspooldata[2]-1], specialSlot, &tpagerect);
LoadImage(&tpagerect, (u_long *)specLoadBuffer);
}
else
{
if (2 < specialState)
{
if (specialState != 4)
return;
SetupSpecCosmetics(specLoadBuffer);
FixCarCos(&car_cosmetics[4], MissionHeader->residentModels[4]);
SetupSpecDenting(specLoadBuffer + sizeof(CAR_COSMETICS));
if (quickSpool == 1)
return;
DrawSyncCallback(SpecialStartNextBlock);
return;
}
if (specialState != 1)
return;
spec_tpage = specialSlot;
tpagerect.w = 64;
tpagerect.h = 16;
tpagerect.x = tpagepos[spec_tpage].x;
tpagerect.y = tpagepos[spec_tpage].y + (15 - specBlocksToLoad) * 16;
if (specBlocksToLoad == 15)
update_slotinfo(specTpages[GameLevel][specspooldata[2]-1], spec_tpage, &tpagerect);
LoadImage(&tpagerect, (u_long *)specLoadBuffer);
}
if (quickSpool != 1)
DrawSyncCallback(SpecialStartNextBlock);
}
// decompiled code
// original method signature:
// void /*$ra*/ SpecialStartNextBlock()
// line 2799, offset 0x0007d144
/* begin block 1 */
// Start line: 2801
// Start offset: 0x0007D144
// Variables:
// char *loadaddr; // $s0
// int fileSector; // $t0
/* end block 1 */
// End offset: 0x0007D4D0
// End Line: 2925
/* begin block 2 */
// Start line: 6482
/* end block 2 */
// End Line: 6483
/* begin block 3 */
// Start line: 6489
/* end block 3 */
// End Line: 6490
/* begin block 4 */
// Start line: 6490
/* end block 4 */
// End Line: 6491
/* begin block 5 */
// Start line: 6493
/* end block 5 */
// End Line: 6494
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void SpecialStartNextBlock(void)
{
char *loadaddr;
int fileSector;
spooledFuncPtr spoolFunc;
loadaddr = specLoadBuffer;
DrawSyncCallback(0);
// if previous state blocks are fully loaded, start next state
if (specBlocksToLoad == 0)
{
switch (specialState)
{
case 0:
case 1:
specBlocksToLoad = 16;
break;
case 2:
case 3:
specBlocksToLoad = 1;
break;
case 4:
specBlocksToLoad = 7;
break;
case 5:
case 8:
specBlocksToLoad = lengthLowBlock;
break;
case 6:
specBlocksToLoad = lastCleanBlock;
break;
case 7:
specBlocksToLoad = lengthDamBlock;
break;
default:
specBlocksToLoad = 0;
}
specialState++;
}
fileSector = 0x1400 + (citystart[GameLevel] - citylumps[GameLevel][CITYLUMP_SPOOL].x / 2048) + (specspooldata[2]-1) * 42;
switch (specialState)
{
case 1:
spoolFunc = Tada;
fileSector += (17 - specBlocksToLoad);
break;
case 2:
spoolFunc = Tada;
fileSector += (33 - specBlocksToLoad);
break;
case 3:
spoolFunc = SpecClutsSpooled;
break;
case 4:
fileSector += 33;
spoolFunc = Tada;
break;
case 5:
spoolFunc = CleanSpooled;
fileSector += (41 - specBlocksToLoad);
loadaddr = specmallocptr + (7 - specBlocksToLoad) * 2048;
break;
case 6:
spoolFunc = LowSpooled;
fileSector += ((firstLowBlock + lengthLowBlock) - specBlocksToLoad) + 34;
loadaddr = specmallocptr + (lengthLowBlock - specBlocksToLoad) * 2048;
break;
case 7:
spoolFunc = CleanModelSpooled;
fileSector += (lastCleanBlock - specBlocksToLoad) + 34;
break;
case 8:
spoolFunc = DamagedModelSpooled;
fileSector += ((firstDamBlock + lengthDamBlock) - specBlocksToLoad) + 34;
break;
case 9:
spoolFunc = LowModelSpooled;
fileSector += ((firstLowBlock + lengthLowBlock) - specBlocksToLoad) + 34;
break;
default:
if (quickSpool == 1)
{
specModelValid = 1;
specialState = 0;
quickSpool = 0;
specSpoolComplete = 0;
return;
}
specSpoolComplete = 1;
return;
}
RequestSpool(3, 0, fileSector, 1, loadaddr, spoolFunc);
specBlocksToLoad--;
}
// decompiled code
// original method signature:
// void /*$ra*/ CheckSpecialSpool()
// line 2956, offset 0x0007d4e0
/* begin block 1 */
// Start line: 2958
// Start offset: 0x0007D4E0
// Variables:
// struct _CAR_DATA *lcp; // $a0
// int ret; // $a3
/* begin block 1.1 */
// Start line: 2965
// Start offset: 0x0007D51C
/* end block 1.1 */
// End offset: 0x0007D53C
// End Line: 2969
/* end block 1 */
// End offset: 0x0007D6C8
// End Line: 3022
/* begin block 2 */
// Start line: 6827
/* end block 2 */
// End Line: 6828
/* begin block 3 */
// Start line: 6828
/* end block 3 */
// End Line: 6829
/* begin block 4 */
// Start line: 6831
/* end block 4 */
// End Line: 6832
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void CheckSpecialSpool(void)
{
int ret;
int iVar2;
_CAR_DATA *lcp;
if (startSpecSpool != -1 && startSpecSpool+400 < CameraCnt)
{
while (specSpoolComplete == 0)
{
SpoolSYNC();
if (DrawSync(1) == 0)
SpecialStartNextBlock();
StartSpooling();
}
specModelValid = 1;
specialState = 0;
specBlocksToLoad = 0;
specSpoolComplete = 0;
startSpecSpool = -1;
}
if (allowSpecSpooling &&
specSpoolComplete != 1 &&
GameType != GAME_PURSUIT &&
LoadedArea != -1 &&
SpecialByRegion[GameLevel][LoadedArea] != MissionHeader->residentModels[4]-7)
{
lcp = car_data;
// if there are cars that still using special models, deny spooling
do // [A]
{
if (MissionHeader->residentModels[lcp->ap.model] > 4)
return;
lcp++;
} while (lcp <= &car_data[20]);
specModelValid = 0;
startSpecSpool = CameraCnt;
gCarDamModelPtr[4] = NULL;
gCarCleanModelPtr[4] = NULL;
gCarLowModelPtr[4] = NULL;
specspooldata[2] = SpecialByRegion[GameLevel][LoadedArea];
MissionHeader->residentModels[4] = SpecialByRegion[GameLevel][LoadedArea] + 7;
if (specialState == 0)
SpecialStartNextBlock();
}
}
// decompiled code
// original method signature:
// void /*$ra*/ QuickSpoolSpecial()
// line 3025, offset 0x0007e84c
/* begin block 1 */
// Start line: 10949
/* end block 1 */
// End Line: 10950
/* begin block 2 */
// Start line: 10950
/* end block 2 */
// End Line: 10951
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void QuickSpoolSpecial(void)
{
quickSpool = 1;
specialState = 0;
specBlocksToLoad = 0;
gCarCleanModelPtr[4] = NULL;
gCarDamModelPtr[4] = NULL;
gCarLowModelPtr[4] = NULL;
specspooldata[2] = MissionHeader->residentModels[4]-7;
do {
SpoolSYNC();
DrawSync(0);
SpecialStartNextBlock();
StartSpooling();
} while (quickSpool == 1);
}
// decompiled code
// original method signature:
// void /*$ra*/ PrepareSecretCar()
// line 3046, offset 0x0007e8dc
/* begin block 1 */
// Start line: 11011
/* end block 1 */
// End Line: 11012
/* begin block 2 */
// Start line: 11012
/* end block 2 */
// End Line: 11013
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void PrepareSecretCar(void)
{
allowSpecSpooling = 0;
PingOutAllSpecialCivCars();
gCarDamModelPtr[4] = NULL;
gCarCleanModelPtr[4] = NULL;
gCarLowModelPtr[4] = NULL;
specspooldata[2] = 5;
specModelValid = 0;
startSpecSpool = CameraCnt;
MissionHeader->residentModels[4] = 12;
specialState = 0;
specBlocksToLoad = 0;
SpecialStartNextBlock();
}
// decompiled code
// original method signature:
// void /*$ra*/ InitSpecSpool()
// line 3063, offset 0x0007d6d8
/* begin block 1 */
// Start line: 7058
/* end block 1 */
// End Line: 7059
/* begin block 2 */
// Start line: 7059
/* end block 2 */
// End Line: 7060
/* begin block 3 */
// Start line: 7064
/* end block 3 */
// End Line: 7065
/* WARNING: Unknown calling convention yet parameter storage is locked */
// [D]
void InitSpecSpool(void)
{
switch (gCurrentMissionNumber)
{
case 2:
case 4:
case 6:
case 7:
case 10:
case 11:
case 12:
case 13:
case 16:
case 18:
case 19:
case 20:
case 24:
case 26:
case 27:
case 29:
case 30:
case 31:
case 33:
case 35:
case 38:
case 39:
case 40:
case 58:
case 59:
case 60:
case 61:
case 62:
case 63:
case 64:
case 65:
case 70:
case 78:
case 86:
case 94:
case 228:
case 229:
case 236:
case 237:
case 244:
case 245:
case 252:
case 253:
case 352:
case 353:
case 360:
case 169:
case 368:
case 369:
case 376:
case 377:
case 420:
case 421:
case 428:
case 429:
case 436:
case 437:
case 444:
case 445:
case 480:
case 481:
case 482:
case 483:
case 484:
case 485:
case 486:
case 487:
case 498:
case 499:
case 500:
case 501:
case 502:
case 503:
case 504:
case 505:
allowSpecSpooling = 0;
break;
default:
allowSpecSpooling = 1;
}
specModelValid = 1;
specialState = 0;
specBlocksToLoad = 0;
quickSpool = 0;
specSpoolComplete = 0;
startSpecSpool = -1;
}
Reference in New Issue View Git Blame Copy Permalink