thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix code formatting (partially) and guard defines in includes.

Browse source 
svn-id: r26631
This commit is contained in:
Eugene Sandulenko 2007-04-27 22:33:45 +00:00
parent 101fbdd64f
commit ffce26ebfe
57 changed files with 9663 additions and 10110 deletions
Download patch file Download diff file Expand all files Collapse all files

1703
engines/cruise/actor.cpp
View file

File diff suppressed because it is too large Load diff

28
engines/cruise/actor.h
View file

@ -22,25 +22,24 @@
*
*/
#ifndef _ACTOR_H_
#define _ACTOR_H_
#ifndef CRUISE_ACTOR_H
#define CRUISE_ACTOR_H
namespace Cruise {
enum animPhase
{
ANIM_PHASE_WAIT = 0,
ANIM_PHASE_STATIC = 1,
ANIM_PHASE_MOVE = 2,
ANIM_PHASE_STATIC_END = 3,
ANIM_PHASE_END = 4
enum animPhase {
ANIM_PHASE_WAIT = 0,
ANIM_PHASE_STATIC = 1,
ANIM_PHASE_MOVE = 2,
ANIM_PHASE_STATIC_END = 3,
ANIM_PHASE_END = 4
};
typedef enum animPhase animPhase;
struct actorStruct {
struct actorStruct* next;
struct actorStruct* prev;
struct actorStruct *next;
struct actorStruct *prev;
int16 idx;
int16 type;
@ -65,10 +64,13 @@ struct actorStruct {
typedef struct actorStruct actorStruct;
int16 mainProc13(int overlayIdx, int param1, actorStruct* pStartEntry, int param2);
actorStruct* findActor(int overlayIdx, int param1, actorStruct* pStartEntry, int param2);
int16 mainProc13(int overlayIdx, int param1, actorStruct * pStartEntry,
int param2);
actorStruct *findActor(int overlayIdx, int param1, actorStruct * pStartEntry,
int param2);
void processAnimation(void);
void getPixel(int x, int y);
} // End of namespace Cruise
#endif

199
engines/cruise/background.cpp
View file

@ -28,193 +28,166 @@ namespace Cruise {
uint8 colorMode = 0;
uint8* backgroundPtrtable[8] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL}; // wasn't initialized in original, but it's probably better
uint8 *backgroundPtrtable[8] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }; // wasn't initialized in original, but it's probably better
backgroundTableStruct backgroundTable[8];
char hwPage[64000];
char* hwMemAddr[] =
{
char *hwMemAddr[] = {
hwPage,
};
short int cvtPalette[0x20];
int loadMEN(uint8** ptr)
{
char* localPtr = (char*)*ptr;
int loadMEN(uint8 **ptr) {
char *localPtr = (char *)*ptr;
if(!strcmp(localPtr,"MEN"))
{
localPtr+=4;
if (!strcmp(localPtr, "MEN")) {
localPtr += 4;
video4 = *(localPtr++);
video3 = *(localPtr++);
video2 = *(localPtr++);
colorOfSelectedSaveDrive = *(localPtr++);
video4 = *(localPtr++);
video3 = *(localPtr++);
video2 = *(localPtr++);
colorOfSelectedSaveDrive = *(localPtr++);
*ptr = (uint8*)localPtr;
*ptr = (uint8 *) localPtr;
return 1;
}
else
{
return 0;
}
return 1;
} else {
return 0;
}
}
int CVTLoaded;
int loadCVT(uint8** ptr)
{
char* localPtr = (char*)*ptr;
int loadCVT(uint8 **ptr) {
char *localPtr = (char *)*ptr;
if(!strcmp(localPtr,"CVT"))
{
int i;
localPtr+=4;
if (!strcmp(localPtr, "CVT")) {
int i;
localPtr += 4;
for(i=0;i<0x20;i++)
{
cvtPalette[i] = *(localPtr++);
}
for (i = 0; i < 0x20; i++) {
cvtPalette[i] = *(localPtr++);
}
*ptr = (uint8*)localPtr;
*ptr = (uint8 *) localPtr;
CVTLoaded = 1;
CVTLoaded = 1;
return 1;
}
else
{
CVTLoaded = 0;
return 0;
}
return 1;
} else {
CVTLoaded = 0;
return 0;
}
}
extern int lastFileSize;
int loadBackground(char* name, int idx)
{
uint8* ptr;
uint8* ptr2;
uint8* ptrToFree;
int loadBackground(char *name, int idx) {
uint8 *ptr;
uint8 *ptr2;
uint8 *ptrToFree;
printf("Loading BG: %s\n",name);
printf("Loading BG: %s\n", name);
if(!backgroundPtrtable[idx])
{
if (!backgroundPtrtable[idx]) {
//if(!gfxModuleData.useEGA && !gfxModuleData.useVGA)
{
backgroundPtrtable[idx] = (uint8*)mallocAndZero(320*200/*64000*/);
backgroundPtrtable[idx] =
(uint8 *) mallocAndZero(320 * 200 /*64000 */ );
}
/* else
{
backgroundPtrtable[idx] = hwMemAddr[idx];
} */
}
}
if(!backgroundPtrtable[idx])
{
backgroundTable[idx].name[0] = 0;
return(-2);
}
if (!backgroundPtrtable[idx]) {
backgroundTable[idx].name[0] = 0;
return (-2);
}
ptrToFree = gfxModuleData.pPage10;
if(loadFileSub1(&ptrToFree,(uint8*)name,NULL)<0)
{
if(ptrToFree != gfxModuleData.pPage10)
free(ptrToFree);
if (loadFileSub1(&ptrToFree, (uint8 *) name, NULL) < 0) {
if (ptrToFree != gfxModuleData.pPage10)
free(ptrToFree);
return(-18);
return (-18);
}
if(lastFileSize == 32078 || lastFileSize == 32080 || lastFileSize == 32034)
{
if (lastFileSize == 32078 || lastFileSize == 32080
|| lastFileSize == 32034) {
colorMode = 0;
}
else
{
} else {
colorMode = 1;
}
ptr = ptrToFree;
ptr2 = ptrToFree;
ptr2 = ptrToFree;
if(!strcmpuint8(name,"LOGO.PI1"))
{
bgVar3=bgVar2;
bgVar1=1;
bgVar2=1;
}
else
{
if(bgVar1)
{
bgVar2=bgVar3;
bgVar1=0;
}
}
if (!strcmpuint8(name, "LOGO.PI1")) {
bgVar3 = bgVar2;
bgVar1 = 1;
bgVar2 = 1;
} else {
if (bgVar1) {
bgVar2 = bgVar3;
bgVar1 = 0;
}
}
if(!strcmpuint8(ptr,"PAL"))
{
printf("Pal loading unsupported !\n");
exit(1);
}
else
{
if(!colorMode || ptr2[1] == 5)
{
ptr2+=2;
if (!strcmpuint8(ptr, "PAL")) {
printf("Pal loading unsupported !\n");
exit(1);
} else {
if (!colorMode || ptr2[1] == 5) {
ptr2 += 2;
memcpy(palette,ptr2,0x20);
ptr2+=0x20;
flipGen(palette,0x20);
memcpy(palette, ptr2, 0x20);
ptr2 += 0x20;
flipGen(palette, 0x20);
ptr2 += 0x7D00;
loadMEN(&ptr2);
loadCVT(&ptr2);
gfxModuleData_gfxClearFrameBuffer(backgroundPtrtable[idx]);
gfxModuleData_field_60((char*)ptrToFree+34, 20, 200, (char*)backgroundPtrtable[idx], 0, 0);
gfxModuleData_gfxClearFrameBuffer(backgroundPtrtable
[idx]);
gfxModuleData_field_60((char *)ptrToFree + 34, 20, 200,
(char *)backgroundPtrtable[idx], 0, 0);
gfxModuleData_setPal((uint8*)(palette + (idx << 6)));
}
else
if(ptr2[1] == 8)
{
gfxModuleData_setPal((uint8 *) (palette + (idx << 6)));
} else if (ptr2[1] == 8) {
int i;
ptr2+=2;
ptr2 += 2;
for(i=0;i<256*3;i++)
{
for (i = 0; i < 256 * 3; i++) {
palette[i] = ptr2[i];
}
//memcpy(palette,ptr2,256*3);
ptr2+=256*3;
ptr2 += 256 * 3;
memcpy(backgroundPtrtable[idx], ptr2, 320*200);
memcpy(backgroundPtrtable[idx], ptr2, 320 * 200);
gfxModuleData_setPal256(palette);
}
}
}
//if(ptrToFree != gfxModuleData.pPage10)
// free(ptrToFree);
//if(ptrToFree != gfxModuleData.pPage10)
// free(ptrToFree);
if(gfxModuleData.useEGA || gfxModuleData.useTandy)
{
if (gfxModuleData.useEGA || gfxModuleData.useTandy) {
ASSERT(0);
}
if(gfxModuleData.useEGA || gfxModuleData.useTandy)
{
if (gfxModuleData.useEGA || gfxModuleData.useTandy) {
ASSERT(0);
}
strcpy(backgroundTable[idx].name, name);
return(0);
return (0);
}
} // End of namespace Cruise

14
engines/cruise/background.h
View file

@ -21,13 +21,13 @@
* $Id$
*
*/
#ifndef _BACKGROUND_H_
#define _BACKGROUND_H_
#ifndef CRUISE_BACKGROUND_H
#define CRUISE_BACKGROUND_H
namespace Cruise {
struct backgroundTableStruct
{
struct backgroundTableStruct {
char name[9];
char extention[6];
};
@ -36,11 +36,11 @@ typedef struct backgroundTableStruct backgroundTableStruct;
extern short int cvtPalette[0x20];
extern int CVTLoaded;
extern uint8* backgroundPtrtable[8];
extern uint8 *backgroundPtrtable[8];
extern backgroundTableStruct backgroundTable[8];
int loadBackground(char* name, int idx);
int loadBackground(char *name, int idx);
} // End of namespace Cruise
#endif

293
engines/cruise/backgroundIncrust.cpp
View file

@ -28,195 +28,192 @@ namespace Cruise {
backgroundIncrustStruct backgroundIncrustHead;
void resetBackgroundIncrustList(backgroundIncrustStruct* pHead)
{
pHead->next = NULL;
pHead->prev = NULL;
void resetBackgroundIncrustList(backgroundIncrustStruct *pHead) {
pHead->next = NULL;
pHead->prev = NULL;
}
// blit background to another one
void addBackgroundIncrustSub1(int fileIdx, int X, int Y, char* ptr2, int16 scale, char* destBuffer, char* dataPtr)
{
if(*dataPtr == 0)
{
ASSERT(0);
}
void addBackgroundIncrustSub1(int fileIdx, int X, int Y, char *ptr2,
int16 scale, char *destBuffer, char *dataPtr) {
if (*dataPtr == 0) {
ASSERT(0);
}
buildPolyModel(X, Y, scale, ptr2, destBuffer, dataPtr);
buildPolyModel(X, Y, scale, ptr2, destBuffer, dataPtr);
}
backgroundIncrustStruct* addBackgroundIncrust(int16 overlayIdx,int16 objectIdx,backgroundIncrustStruct* pHead,int16 scriptNumber,int16 scriptOverlay, int16 backgroundIdx, int16 param4)
{
uint8* backgroundPtr;
uint8* ptr;
objectParamsQuery params;
backgroundIncrustStruct* newElement;
backgroundIncrustStruct* currentHead;
backgroundIncrustStruct* currentHead2;
backgroundIncrustStruct *addBackgroundIncrust(int16 overlayIdx,
int16 objectIdx, backgroundIncrustStruct *pHead, int16 scriptNumber,
int16 scriptOverlay, int16 backgroundIdx, int16 param4) {
uint8 *backgroundPtr;
uint8 *ptr;
objectParamsQuery params;
backgroundIncrustStruct *newElement;
backgroundIncrustStruct *currentHead;
backgroundIncrustStruct *currentHead2;
getMultipleObjectParam(overlayIdx,objectIdx,&params);
getMultipleObjectParam(overlayIdx, objectIdx, &params);
ptr = filesDatabase[params.fileIdx].subData.ptr;
ptr = filesDatabase[params.fileIdx].subData.ptr;
if(!ptr)
{
return NULL;
}
if (!ptr) {
return NULL;
}
if(filesDatabase[params.fileIdx].subData.resourceType != 4 && filesDatabase[params.fileIdx].subData.resourceType != 8)
{
return NULL;
}
if (filesDatabase[params.fileIdx].subData.resourceType != 4
&& filesDatabase[params.fileIdx].subData.resourceType != 8) {
return NULL;
}
backgroundPtr = backgroundPtrtable[backgroundIdx];
backgroundPtr = backgroundPtrtable[backgroundIdx];
if(!backgroundPtr)
{
ASSERT(0);
return NULL;
}
if (!backgroundPtr) {
ASSERT(0);
return NULL;
}
currentHead = pHead;
currentHead2 = currentHead->next;
currentHead = pHead;
currentHead2 = currentHead->next;
while(currentHead2)
{
currentHead = currentHead2;
currentHead2 = currentHead->next;
}
while (currentHead2) {
currentHead = currentHead2;
currentHead2 = currentHead->next;
}
newElement = (backgroundIncrustStruct*)mallocAndZero(sizeof(backgroundIncrustStruct));
newElement =
(backgroundIncrustStruct *)
mallocAndZero(sizeof(backgroundIncrustStruct));
if(!newElement)
return NULL;
if (!newElement)
return NULL;
newElement->next = currentHead->next;
currentHead->next = newElement;
newElement->next = currentHead->next;
currentHead->next = newElement;
if(!currentHead2)
{
currentHead2 = pHead;
}
if (!currentHead2) {
currentHead2 = pHead;
}
newElement->prev = currentHead2->prev;
currentHead2->prev = newElement;
newElement->prev = currentHead2->prev;
currentHead2->prev = newElement;
newElement->objectIdx = objectIdx;
newElement->field_6 = param4;
newElement->backgroundIdx = backgroundIdx;
newElement->overlayIdx = overlayIdx;
newElement->scriptNumber = scriptNumber;
newElement->scriptOverlayIdx = scriptOverlay;
newElement->X = params.X;
newElement->Y = params.Y;
newElement->scale = params.scale;
newElement->field_E = params.fileIdx;
newElement->var34 = filesDatabase[params.fileIdx].subData.index;
newElement->ptr = NULL;
strcpy(newElement->name, filesDatabase[params.fileIdx].subData.name);
newElement->objectIdx = objectIdx;
newElement->field_6 = param4;
newElement->backgroundIdx = backgroundIdx;
newElement->overlayIdx = overlayIdx;
newElement->scriptNumber = scriptNumber;
newElement->scriptOverlayIdx = scriptOverlay;
newElement->X = params.X;
newElement->Y = params.Y;
newElement->scale = params.scale;
newElement->field_E = params.fileIdx;
newElement->var34 = filesDatabase[params.fileIdx].subData.index;
newElement->ptr = NULL;
strcpy(newElement->name, filesDatabase[params.fileIdx].subData.name);
if(filesDatabase[params.fileIdx].subData.resourceType == 4) // sprite
{
int width = filesDatabase[params.fileIdx].width;
int height = filesDatabase[params.fileIdx].height;
if (filesDatabase[params.fileIdx].subData.resourceType == 4) // sprite
{
int width = filesDatabase[params.fileIdx].width;
int height = filesDatabase[params.fileIdx].height;
currentTransparent = filesDatabase[params.fileIdx].subData.transparency;
mainDrawSub4(width, height, NULL, (char*)filesDatabase[params.fileIdx].subData.ptr, newElement->Y, newElement->X, (char*)backgroundPtr, (char*)filesDatabase[params.fileIdx].subData.ptr);
// ASSERT(0);
}
else // poly
{
/* if(param4 == 1)
{
int var_A;
int var_8;
int var_6;
char* var_10;
currentTransparent =
filesDatabase[params.fileIdx].subData.transparency;
mainDrawSub4(width, height, NULL,
(char *)filesDatabase[params.fileIdx].subData.ptr,
newElement->Y, newElement->X, (char *)backgroundPtr,
(char *)filesDatabase[params.fileIdx].subData.ptr);
// ASSERT(0);
} else // poly
{
/* if(param4 == 1)
* {
* int var_A;
* int var_8;
* int var_6;
* char* var_10;
*
* mainDrawSub1Sub1(lvar[3], newElement->X, newElement->Y, &var_A, &var_8, &var_6, &var_10, lvar[4], filesDatabase[lvar[3]].subData.ptr);
* ASSERT(0);
* } */
mainDrawSub1Sub1(lvar[3], newElement->X, newElement->Y, &var_A, &var_8, &var_6, &var_10, lvar[4], filesDatabase[lvar[3]].subData.ptr);
ASSERT(0);
}*/
addBackgroundIncrustSub1(params.fileIdx, newElement->X,
newElement->Y, NULL, params.scale, (char *)backgroundPtr,
(char *)filesDatabase[params.fileIdx].subData.ptr);
}
addBackgroundIncrustSub1(params.fileIdx, newElement->X, newElement->Y, NULL, params.scale, (char*)backgroundPtr, (char*)filesDatabase[params.fileIdx].subData.ptr );
}
return newElement;
return newElement;
}
void loadBackgroundIncrustFromSave(FILE* fileHandle)
{
int16 numEntry;
backgroundIncrustStruct* ptr1;
backgroundIncrustStruct* ptr2;
int32 i;
void loadBackgroundIncrustFromSave(FILE *fileHandle) {
int16 numEntry;
backgroundIncrustStruct *ptr1;
backgroundIncrustStruct *ptr2;
int32 i;
fread(&numEntry,2,1,fileHandle);
fread(&numEntry, 2, 1, fileHandle);
ptr1 = &backgroundIncrustHead;
ptr2 = &backgroundIncrustHead;
ptr1 = &backgroundIncrustHead;
ptr2 = &backgroundIncrustHead;
for(i=0;i<numEntry;i++)
{
backgroundIncrustStruct* current = (backgroundIncrustStruct*)mallocAndZero(sizeof(backgroundIncrustStruct));
fseek(fileHandle, 4, SEEK_CUR);
for (i = 0; i < numEntry; i++) {
backgroundIncrustStruct *current =
(backgroundIncrustStruct *)
mallocAndZero(sizeof(backgroundIncrustStruct));
fread(&current->objectIdx,2,1,fileHandle);
fread(&current->field_6,2,1,fileHandle);
fread(&current->overlayIdx,2,1,fileHandle);
fread(&current->X,2,1,fileHandle);
fread(&current->Y,2,1,fileHandle);
fread(&current->field_E,2,1,fileHandle);
fread(&current->scale,2,1,fileHandle);
fread(&current->backgroundIdx,2,1,fileHandle);
fread(&current->scriptNumber,2,1,fileHandle);
fread(&current->scriptOverlayIdx,2,1,fileHandle);
fread(&current->ptr,4,1,fileHandle);
fread(&current->field_1C,4,1,fileHandle);
fread(&current->size,2,1,fileHandle);
fread(&current->field_22,2,1,fileHandle);
fread(&current->field_24,2,1,fileHandle);
fread(current->name,14,1,fileHandle);
fread(&current->var34,2,1,fileHandle);
fseek(fileHandle, 4, SEEK_CUR);
if(current->size)
{
current->ptr = (uint8*)mallocAndZero(current->size);
fread(current->ptr,current->size,1,fileHandle);
}
fread(&current->objectIdx, 2, 1, fileHandle);
fread(&current->field_6, 2, 1, fileHandle);
fread(&current->overlayIdx, 2, 1, fileHandle);
fread(&current->X, 2, 1, fileHandle);
fread(&current->Y, 2, 1, fileHandle);
fread(&current->field_E, 2, 1, fileHandle);
fread(&current->scale, 2, 1, fileHandle);
fread(&current->backgroundIdx, 2, 1, fileHandle);
fread(&current->scriptNumber, 2, 1, fileHandle);
fread(&current->scriptOverlayIdx, 2, 1, fileHandle);
fread(&current->ptr, 4, 1, fileHandle);
fread(&current->field_1C, 4, 1, fileHandle);
fread(&current->size, 2, 1, fileHandle);
fread(&current->field_22, 2, 1, fileHandle);
fread(&current->field_24, 2, 1, fileHandle);
fread(current->name, 14, 1, fileHandle);
fread(&current->var34, 2, 1, fileHandle);
current->next = NULL;
ptr2 = current;
current->prev = backgroundIncrustHead.prev;
backgroundIncrustHead.prev = current;
ptr2 = current->next;
}
if (current->size) {
current->ptr = (uint8 *) mallocAndZero(current->size);
fread(current->ptr, current->size, 1, fileHandle);
}
current->next = NULL;
ptr2 = current;
current->prev = backgroundIncrustHead.prev;
backgroundIncrustHead.prev = current;
ptr2 = current->next;
}
}
void regenerateBackgroundIncrust(backgroundIncrustStruct* pHead)
{
printf("Need to regenerate backgroundIncrust\n");
void regenerateBackgroundIncrust(backgroundIncrustStruct *pHead) {
printf("Need to regenerate backgroundIncrust\n");
}
void freeBackgroundIncrustList(backgroundIncrustStruct* pHead)
{
backgroundIncrustStruct* pCurrent = pHead->next;
void freeBackgroundIncrustList(backgroundIncrustStruct *pHead) {
backgroundIncrustStruct *pCurrent = pHead->next;
while(pCurrent)
{
backgroundIncrustStruct* pNext = pCurrent->next;
while (pCurrent) {
backgroundIncrustStruct *pNext = pCurrent->next;
if(pCurrent->ptr)
{
free(pCurrent->ptr);
}
if (pCurrent->ptr) {
free(pCurrent->ptr);
}
free(pCurrent);
free(pCurrent);
pCurrent = pNext;
}
pCurrent = pNext;
}
resetBackgroundIncrustList(pHead);
resetBackgroundIncrustList(pHead);
}
} // End of namespace Cruise

23
engines/cruise/backgroundIncrust.h
View file

@ -22,14 +22,14 @@
*
*/
#ifndef _BACKGROUNDINCRUST_H_
#define _BACKGROUNDINCRUST_H_
#ifndef CRUISE_BACKGROUNDINCRUST_H
#define CRUISE_BACKGROUNDINCRUST_H
namespace Cruise {
struct backgroundIncrustStruct {
struct backgroundIncrustStruct* next;
struct backgroundIncrustStruct* prev;
struct backgroundIncrustStruct *next;
struct backgroundIncrustStruct *prev;
uint16 objectIdx;
uint16 field_6;
@ -41,7 +41,7 @@ struct backgroundIncrustStruct {
uint16 backgroundIdx;
uint16 scriptNumber;
uint16 scriptOverlayIdx;
uint8* ptr;
uint8 *ptr;
int32 field_1C;
int16 size;
uint16 field_22;
@ -54,13 +54,14 @@ typedef struct backgroundIncrustStruct backgroundIncrustStruct;
extern backgroundIncrustStruct backgroundIncrustHead;
void resetBackgroundIncrustList(backgroundIncrustStruct* pHead);
backgroundIncrustStruct* addBackgroundIncrust(int16 overlayIdx,int16 param2,backgroundIncrustStruct* pHead,int16 scriptNumber,int16 scriptOverlay, int16 backgroundIdx, int16 param4);
void loadBackgroundIncrustFromSave(FILE* fileHandle);
void regenerateBackgroundIncrust(backgroundIncrustStruct* pHead);
void freeBackgroundIncrustList(backgroundIncrustStruct* pHead);
void resetBackgroundIncrustList(backgroundIncrustStruct * pHead);
backgroundIncrustStruct *addBackgroundIncrust(int16 overlayIdx, int16 param2,
backgroundIncrustStruct * pHead, int16 scriptNumber, int16 scriptOverlay,
int16 backgroundIdx, int16 param4);
void loadBackgroundIncrustFromSave(FILE * fileHandle);
void regenerateBackgroundIncrust(backgroundIncrustStruct * pHead);
void freeBackgroundIncrustList(backgroundIncrustStruct * pHead);
} // End of namespace Cruise
#endif

192
engines/cruise/cell.cpp
View file

@ -27,133 +27,123 @@
namespace Cruise {
void resetPtr(cellStruct* ptr)
{
ptr->next = NULL;
ptr->prev = NULL;
void resetPtr(cellStruct *ptr) {
ptr->next = NULL;
ptr->prev = NULL;
}
void loadSavegameDataSub2(FILE * f)
{
unsigned short int n_chunks;
int i;
cellStruct *p;
cellStruct *t;
void loadSavegameDataSub2(FILE *f) {
unsigned short int n_chunks;
int i;
cellStruct *p;
cellStruct *t;
cellHead.next = NULL; // Not in ASM code, but I guess the variable is defaulted
// to this value in the .exe
cellHead.next = NULL; // Not in ASM code, but I guess the variable is defaulted
// to this value in the .exe
fread(&n_chunks, 2, 1, f);
// BIG ENDIAN MACHINES, PLEASE SWAP IT
fread(&n_chunks, 2, 1, f);
// BIG ENDIAN MACHINES, PLEASE SWAP IT
p = &cellHead;
p = &cellHead;
for (i = 0; i < n_chunks; i++)
{
t = (cellStruct *) mallocAndZero(sizeof(cellStruct));
for (i = 0; i < n_chunks; i++) {
t = (cellStruct *) mallocAndZero(sizeof(cellStruct));
fseek(f, 4, SEEK_CUR);
fread(&t->idx, 1, 0x30, f);
fseek(f, 4, SEEK_CUR);
fread(&t->idx, 1, 0x30, f);
t->next = NULL;
t->next = NULL;
p->next = t;
t->prev = cellHead.prev;
cellHead.prev = t;
p = t;
}
t->prev = cellHead.prev;
cellHead.prev = t;
p = t;
}
}
cellStruct* addCell(int16 overlayIdx,int16 param2,cellStruct* pHead,int16 scriptType,int16 scriptNumber,int16 scriptOverlay, int16 param3, int16 param4)
{
int16 var;
cellStruct *addCell(int16 overlayIdx, int16 param2, cellStruct *pHead,
int16 scriptType, int16 scriptNumber, int16 scriptOverlay, int16 param3,
int16 param4) {
int16 var;
cellStruct* newElement;
cellStruct* currentHead = pHead;
cellStruct* currentHead2;
cellStruct* currentHead3;
cellStruct *newElement;
cellStruct *currentHead = pHead;
cellStruct *currentHead2;
cellStruct *currentHead3;
if(getSingleObjectParam(overlayIdx,param2,2,&var)<0)
{
return 0;
}
if (getSingleObjectParam(overlayIdx, param2, 2, &var) < 0) {
return 0;
}
currentHead3 = currentHead;
currentHead2 = currentHead->next;
currentHead3 = currentHead;
currentHead2 = currentHead->next;
while(currentHead2)
{
if(currentHead2->type == 3)
{
break;
}
while (currentHead2) {
if (currentHead2->type == 3) {
break;
}
if(currentHead2->type != 5)
{
int16 lvar2;
if (currentHead2->type != 5) {
int16 lvar2;
getSingleObjectParam(currentHead2->overlay,currentHead2->idx,2,&lvar2);
getSingleObjectParam(currentHead2->overlay,
currentHead2->idx, 2, &lvar2);
if(lvar2 > var)
break;
}
if (lvar2 > var)
break;
}
currentHead3 = currentHead2;
currentHead2 = currentHead2->next;
}
currentHead3 = currentHead2;
currentHead2 = currentHead2->next;
}
if(currentHead2)
{
if( (currentHead2->overlay == overlayIdx) &&
(currentHead2->backgroundPlane == param3) &&
(currentHead2->idx == param2) &&
(currentHead2->type == param4))
if (currentHead2) {
if ((currentHead2->overlay == overlayIdx) &&
(currentHead2->backgroundPlane == param3) &&
(currentHead2->idx == param2) &&
(currentHead2->type == param4))
return NULL;
}
return NULL;
}
currentHead = currentHead2;
currentHead = currentHead2;
newElement = (cellStruct*)mallocAndZero(sizeof(cellStruct));
newElement = (cellStruct *) mallocAndZero(sizeof(cellStruct));
if(!newElement)
return 0;
if (!newElement)
return 0;
newElement->next = currentHead3->next;
currentHead3->next = newElement;
newElement->next = currentHead3->next;
currentHead3->next = newElement;
newElement->idx = param2;
newElement->type = param4;
newElement->backgroundPlane = param3;
newElement->overlay = overlayIdx;
newElement->freeze = 0;
newElement->field_16 = scriptNumber;
newElement->field_18 = scriptOverlay;
newElement->gfxPtr = NULL;
newElement->followObjectIdx = param2;
newElement->followObjectOverlayIdx = overlayIdx;
newElement->field_1A = scriptType;
newElement->field_20 = 0;
newElement->field_22 = 0;
newElement->nextAnimDelay = 0;
newElement->field_2C = 0;
newElement->currentAnimDelay = 0;
newElement->field_2A = 0;
newElement->animStep = 0;
newElement->field_30 = 0;
newElement->idx = param2;
newElement->type = param4;
newElement->backgroundPlane = param3;
newElement->overlay = overlayIdx;
newElement->freeze = 0;
newElement->field_16 = scriptNumber;
newElement->field_18 = scriptOverlay;
newElement->gfxPtr = NULL;
newElement->followObjectIdx = param2;
newElement->followObjectOverlayIdx = overlayIdx;
newElement->field_1A = scriptType;
newElement->field_20 = 0;
newElement->field_22 = 0;
newElement->nextAnimDelay = 0;
newElement->field_2C = 0;
newElement->currentAnimDelay = 0;
newElement->field_2A = 0;
newElement->animStep = 0;
newElement->field_30 = 0;
if(currentHead)
{
newElement->prev = currentHead->prev;
currentHead->prev = newElement;
}
else
{
newElement->prev = pHead->prev;
pHead->prev = newElement;
}
return newElement;
if (currentHead) {
newElement->prev = currentHead->prev;
currentHead->prev = newElement;
} else {
newElement->prev = pHead->prev;
pHead->prev = newElement;
}
return newElement;
}
}
} // End of namespace Cruise

29
engines/cruise/cell.h
View file

@ -22,8 +22,8 @@
*
*/
#ifndef _CELL_H_
#define _CELL_H_
#ifndef CRUISE_CELL_H
#define CRUISE_CELL_H
#include "common/stdafx.h"
#include "common/scummsys.h"
@ -32,16 +32,15 @@ namespace Cruise {
struct gfxEntryStruct;
struct cellStruct
{
struct cellStruct* next;
struct cellStruct* prev;
struct cellStruct {
struct cellStruct *next;
struct cellStruct *prev;
int16 idx;
int16 type;
int16 overlay ;
int16 field_A ;
int16 field_C ;
int16 spriteIdx ;
int16 overlay;
int16 field_A;
int16 field_C;
int16 spriteIdx;
int16 field_10;
int16 backgroundPlane;
int16 freeze;
@ -59,15 +58,17 @@ struct cellStruct
int16 field_2C;
int16 currentAnimDelay;
int16 field_30;
gfxEntryStruct* gfxPtr;
gfxEntryStruct *gfxPtr;
};
extern cellStruct cellHead;
void resetPtr(cellStruct* ptr);
void resetPtr(cellStruct * ptr);
void loadSavegameDataSub2(FILE * f);
cellStruct* addCell(int16 overlayIdx,int16 param2,cellStruct* pHead,int16 scriptType,int16 scriptNumber,int16 scriptOverlay, int16 param3, int16 param4);
cellStruct *addCell(int16 overlayIdx, int16 param2, cellStruct * pHead,
int16 scriptType, int16 scriptNumber, int16 scriptOverlay, int16 param3,
int16 param4);
}
} // End of namespace Cruise
#endif

25
engines/cruise/cruise.cpp
View file

@ -40,20 +40,23 @@ namespace Cruise {
//SoundDriver *g_soundDriver;
//SfxPlayer *g_sfxPlayer;
Common::SaveFileManager *g_saveFileMan;
Common::SaveFileManager * g_saveFileMan;
CruiseEngine *g_cruise;
CruiseEngine::CruiseEngine(OSystem *syst) : Engine(syst) {
Common::addSpecialDebugLevel(kCruiseDebugScript, "Script", "Script debug level");
CruiseEngine::CruiseEngine(OSystem * syst) : Engine(syst) {
Common::addSpecialDebugLevel(kCruiseDebugScript, "Script",
"Script debug level");
// Setup mixer
if (!_mixer->isReady()) {
warning("Sound initialization failed.");
}
_mixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, ConfMan.getInt("sfx_volume"));
_mixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, ConfMan.getInt("music_volume"));
_mixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType,
ConfMan.getInt("sfx_volume"));
_mixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType,
ConfMan.getInt("music_volume"));
g_cruise = this;
}
@ -64,10 +67,10 @@ CruiseEngine::~CruiseEngine() {
int CruiseEngine::init() {
// Detect game
if (!initGame()) {
GUIErrorMessage("No valid games were found in the specified directory.");
GUIErrorMessage
("No valid games were found in the specified directory.");
return -1;
}
// Initialize backend
_system->beginGFXTransaction();
initCommonGFX(false);
@ -87,16 +90,16 @@ int CruiseEngine::go() {
return 0;
}
void CruiseEngine::initialize() {
fadeVar = 0;
ptr_something = (ctpVar19Struct*)mallocAndZero(sizeof(ctpVar19Struct)*0x200);
ptr_something =
(ctpVar19Struct *) mallocAndZero(sizeof(ctpVar19Struct) * 0x200);
/*volVar1 = 0;
fileData1 = 0;*/
* fileData1 = 0; */
/*PAL_fileHandle = -1;*/
/*PAL_fileHandle = -1; */
// video init stuff

25
engines/cruise/cruise.h
View file

@ -22,8 +22,8 @@
*
*/
#ifndef CRUISE_H
#define CRUISE_H
#ifndef CRUISE_CRUISE_H
#define CRUISE_CRUISE_H
#include "common/stdafx.h"
#include "common/scummsys.h"
@ -41,30 +41,30 @@ enum CruiseGameType {
struct CRUISEGameDescription;
class CruiseEngine : public Engine {
class CruiseEngine:public Engine {
protected:
protected:
int init();
int go();
void shutdown();
bool initGame();
public:
CruiseEngine(OSystem *syst);
virtual ~CruiseEngine();
public:
CruiseEngine(OSystem * syst);
virtual ~ CruiseEngine();
int getGameType() const;
uint32 getFeatures() const;
Common::Language getLanguage() const;
Common::Platform getPlatform() const;
Common::Language getLanguage() const;
Common::Platform getPlatform() const;
bool loadSaveDirectory(void);
void makeSystemMenu(void);
const CRUISEGameDescription *_gameDescription;
private:
private:
void initialize(void);
bool makeLoad(char *saveName);
void mainLoop(int bootScriptIdx);
@ -99,8 +99,7 @@ enum {
kCmpLT = (1 << 2)
};
extern Common::SaveFileManager *g_saveFileMan; // TEMP
extern Common::SaveFileManager * g_saveFileMan; // TEMP
} // End of namespace Cruise

2369
engines/cruise/cruise_main.cpp
View file

File diff suppressed because it is too large Load diff

44
engines/cruise/cruise_main.h
View file

@ -22,8 +22,8 @@
*
*/
#ifndef _CRUISE_H_
#define _CRUISE_H_
#ifndef CRUISE_CRUISE_MAIN_H
#define CRUISE_CRUISE_MAIN_H
#include <string.h>
#include <stdlib.h>
@ -66,35 +66,37 @@ namespace Cruise {
#define ASSERT_PTR assert
#define ASSERT assert
int32 decomp(uint8 * in, uint8 * out, int32 size);
ovlData3Struct* getOvlData3Entry(int32 scriptNumber, int32 param);
ovlData3Struct* scriptFunc1Sub2(int32 scriptNumber, int32 param);
int16 loadShort(void* ptr);
ovlData3Struct *getOvlData3Entry(int32 scriptNumber, int32 param);
ovlData3Struct *scriptFunc1Sub2(int32 scriptNumber, int32 param);
int16 loadShort(void *ptr);
void resetFileEntry(int32 entryNumber);
void saveShort(void* ptr, int16 var);
void* mallocAndZero(int32 size);
uint8* mainProc14(uint16 overlay, uint16 idx);
void printInfoBlackBox(const char* string);
void saveShort(void *ptr, int16 var);
void *mallocAndZero(int32 size);
uint8 *mainProc14(uint16 overlay, uint16 idx);
void printInfoBlackBox(const char *string);
void waitForPlayerInput(void);
int loadCtp(uint8* ctpName);
void loadPakedFileToMem(int fileIdx, uint8* buffer);
int loadCtp(uint8 * ctpName);
void loadPakedFileToMem(int fileIdx, uint8 * buffer);
int loadScriptSub1(int scriptIdx, int param);
void resetFileEntryRange(int param1, int param2);
int getProcParam(int overlayIdx, int param2, uint8* name);
void changeScriptParamInList(int param1, int param2, scriptInstanceStruct* pScriptInstance,int newValue, int param3);
uint8* getDataFromData3(ovlData3Struct* ptr, int param);
int32 prepareWordRender(int32 param, int32 var1,int16* out2, uint8* ptr3,uint8* string);
void removeExtention(const char* name, char* buffer);
void resetRaster(uint8* rasterPtr, int32 rasterSize);
int getProcParam(int overlayIdx, int param2, uint8 * name);
void changeScriptParamInList(int param1, int param2,
scriptInstanceStruct * pScriptInstance, int newValue, int param3);
uint8 *getDataFromData3(ovlData3Struct * ptr, int param);
int32 prepareWordRender(int32 param, int32 var1, int16 * out2, uint8 * ptr3,
uint8 * string);
void removeExtention(const char *name, char *buffer);
void resetRaster(uint8 * rasterPtr, int32 rasterSize);
void changeCursor(uint16 cursorType);
void resetPtr2(scriptInstanceStruct* ptr);
void getFileExtention(const char* name,char* buffer);
void resetPtr2(scriptInstanceStruct * ptr);
void getFileExtention(const char *name, char *buffer);
void *allocAndZero(int size);
void freeStuff2(void);
char* getObjectName(int index, uint8* string);
char *getObjectName(int index, uint8 * string);
void mainLoop(void);
} // End of namespace Cruise
#endif

290
engines/cruise/ctp.cpp
View file

@ -26,14 +26,14 @@
namespace Cruise {
ctpVar19Struct* ptr_something;
ctpVar19Struct* polyStruct;
ctpVar19Struct* ctpVar11;
ctpVar19Struct* ctpVar13;
ctpVar19Struct* ctpVar15;
ctpVar19Struct *ptr_something;
ctpVar19Struct *polyStruct;
ctpVar19Struct *ctpVar11;
ctpVar19Struct *ctpVar13;
ctpVar19Struct *ctpVar15;
uint8* ctpVar17;
ctpVar19Struct* ctpVar19;
uint8 *ctpVar17;
ctpVar19Struct *ctpVar19;
int currentWalkBoxCenterX;
int currentWalkBoxCenterY;
@ -41,43 +41,43 @@ int currentWalkBoxCenterXBis;
int currentWalkBoxCenterYBis;
int ctpVarUnk;
uint8 walkboxTable[0x12];
uint8 walkboxTable[0x12];
int ctpProc2(int varX, int varY, int paramX, int paramY)
{
int diffX = abs(paramX - varX);
int ctpProc2(int varX, int varY, int paramX, int paramY) {
int diffX = abs(paramX - varX);
int diffY = abs(paramY - varY);
if(diffX > diffY)
{
if (diffX > diffY) {
diffY = diffX;
}
ctpVar14 = diffY; // highest difference
return(diffY);
ctpVar14 = diffY; // highest difference
return (diffY);
}
// this function process path finding coordinates
void loadCtpSub2(short int coordCount, short int* ptr) // coordCount = ctp_routeCoordCount, ptr = ctpVar8
{
void loadCtpSub2(short int coordCount, short int *ptr) {
// coordCount = ctp_routeCoordCount, ptr = ctpVar8
int i;
int offset = 0;
short int* cur_ctp_routeCoords = (short int*)ctp_routeCoords; // coordinates table
int8* cur_ctp_routes = (int8*)ctp_routes;
short int *cur_ctp_routeCoords = (short int *)ctp_routeCoords; // coordinates table
int8 *cur_ctp_routes = (int8 *) ctp_routes;
for(i = 0; i < coordCount; i++) // for i < ctp_routeCoordCount
for (i = 0; i < coordCount; i++) // for i < ctp_routeCoordCount
{
int varX = cur_ctp_routeCoords[0]; // x
int varY = cur_ctp_routeCoords[1]; // y
int varX = cur_ctp_routeCoords[0]; // x
int varY = cur_ctp_routeCoords[1]; // y
int di = 0;
int var4Offset = 2;
while(*(int16*) cur_ctp_routes > di) // while (coordCount > counter++)
while (*(int16 *) cur_ctp_routes > di) // while (coordCount > counter++)
{
int idx = *(int16*)(cur_ctp_routes + var4Offset);
ptr[offset + idx] = ctpProc2(varX , varY, ctp_routeCoords[idx][0], ctp_routeCoords[idx * 2][1]);
int idx = *(int16 *) (cur_ctp_routes + var4Offset);
ptr[offset + idx] =
ctpProc2(varX, varY, ctp_routeCoords[idx][0],
ctp_routeCoords[idx * 2][1]);
var4Offset += 2;
di++;
@ -89,38 +89,35 @@ void loadCtpSub2(short int coordCount, short int* ptr) // coordCount = ctp_r
}
}
void getWalkBoxCenter(int boxIdx, uint16* _walkboxTable)
{
void getWalkBoxCenter(int boxIdx, uint16 *_walkboxTable) {
int minX = 1000;
int minY = 1000;
int maxX = -1;
int maxY = -1;
ASSERT(boxIdx <= 15); // max number of walkboxes is 16
ASSERT(boxIdx <= 15); // max number of walkboxes is 16
ASSERT(_walkboxTable[boxIdx * 40]); // we should never have an empty walk box
if(_walkboxTable[boxIdx * 40] > 0)
{
int numPoints = _walkboxTable[boxIdx * 40];
uint16* pCurrentPtr = _walkboxTable + (boxIdx * 40) + 1;
if (_walkboxTable[boxIdx * 40] > 0) {
int numPoints = _walkboxTable[boxIdx * 40];
uint16 *pCurrentPtr = _walkboxTable + (boxIdx * 40) + 1;
int i;
for(i = 0; i < numPoints; i++)
{
for (i = 0; i < numPoints; i++) {
int X = *(pCurrentPtr++);
int Y = *(pCurrentPtr++);;
if(X < minX)
if (X < minX)
minX = X;
if(X > maxX)
if (X > maxX)
maxX = X;
if(Y < minY)
if (Y < minY)
minY = Y;
if(Y > maxY)
if (Y > maxY)
maxY = Y;
}
}
@ -130,13 +127,13 @@ void getWalkBoxCenter(int boxIdx, uint16* _walkboxTable)
}
// ax dx bx
void renderCTPWalkBox(int X1, int Y1, int X2, int scale, int Y2, uint16* walkboxData)
{
void renderCTPWalkBox(int X1, int Y1, int X2, int scale, int Y2,
uint16 *walkboxData) {
int numPoints;
int wbSelf1;
int wbSelf2;
int i;
int16* destination;
int16 *destination;
wbSelf1 = upscaleValue(X1, scale) - X2;
wbSelf2 = upscaleValue(Y1, scale) - Y2;
@ -145,8 +142,7 @@ void renderCTPWalkBox(int X1, int Y1, int X2, int scale, int Y2, uint16* walkbox
destination = polyBuffer2;
for(i = 0; i < numPoints; i++)
{
for (i = 0; i < numPoints; i++) {
int pointX = *(walkboxData++);
int pointY = *(walkboxData++);
@ -160,26 +156,25 @@ void renderCTPWalkBox(int X1, int Y1, int X2, int scale, int Y2, uint16* walkbox
m_color = 0;
ctpVarUnk = 0;
for(i = 0; i < numPoints; i++)
{
for (i = 0; i < numPoints; i++) {
walkboxTable[i] = i;
}
drawPolyMode2((char*)walkboxTable, numPoints);
drawPolyMode2((char *)walkboxTable, numPoints);
}
// this process the walkboxes
void loadCtpSub1(int boxIdx, int scale, uint16* _walkboxTable, ctpVar19Struct* param4)
{
void loadCtpSub1(int boxIdx, int scale, uint16 *_walkboxTable,
ctpVar19Struct *param4) {
int minX = 1000;
int minY = 1000;
int maxX = -1;
int maxY = -1;
ctpVar19Struct* var_1C;
ctpVar19Struct* var_12;
int16* var_18;
int16* si;
ctpVar19Struct *var_1C;
ctpVar19Struct *var_12;
int16 *var_18;
int16 *si;
// int16* di;
// uint8* cx;
// int bx;
@ -188,236 +183,229 @@ void loadCtpSub1(int boxIdx, int scale, uint16* _walkboxTable, ctpVar19Struct* p
int var_E;
//int var_C = 1000;
//int var_A = 0;
ctpVar19SubStruct* subStruct;
ctpVar19SubStruct *subStruct;
ASSERT(boxIdx <= 15);
if(_walkboxTable[boxIdx * 40] > 0) // is walkbox used ?
if (_walkboxTable[boxIdx * 40] > 0) // is walkbox used ?
{
getWalkBoxCenter(boxIdx, _walkboxTable);
currentWalkBoxCenterYBis = currentWalkBoxCenterY;
currentWalkBoxCenterXBis = currentWalkBoxCenterX;
// + 512
renderCTPWalkBox(currentWalkBoxCenterX, currentWalkBoxCenterY, currentWalkBoxCenterX, scale + 0x200, currentWalkBoxCenterY, _walkboxTable + boxIdx * 40);
renderCTPWalkBox(currentWalkBoxCenterX, currentWalkBoxCenterY,
currentWalkBoxCenterX, scale + 0x200,
currentWalkBoxCenterY, _walkboxTable + boxIdx * 40);
var_1C = param4;
var_12 = var_1C + 1; // next
var_12 = var_1C + 1; // next
var_18 = polyBuffer3;
var_E = 0;
var_E = 0;
si = &polyBuffer3[1];
/* if(*si>=0)
{
di = si;
cx = var_12;
do
{
di++;
bx = di[-1];
ax = di[0];
di++;
var_2 = ax;
if(var_C < bx)
{
var_C = bx;
}
if(var_2 < var_A)
{
var_A = var_2;
}
*cx = bx;
cx++;
*cx = var_2;
cx++;
var_E ++;
}while(di);
var_12 = cx;
}*/
* {
* di = si;
* cx = var_12;
*
* do
* {
* di++;
* bx = di[-1];
* ax = di[0];
* di++;
*
* var_2 = ax;
* if(var_C < bx)
* {
* var_C = bx;
* }
*
* if(var_2 < var_A)
* {
* var_A = var_2;
* }
*
* *cx = bx;
* cx++;
* *cx = var_2;
* cx++;
* var_E ++;
* }while(di);
*
* var_12 = cx;
* } */
/*************/
{
int i;
int numPoints;
uint16* pCurrentPtr = _walkboxTable + boxIdx * 40;
uint16 *pCurrentPtr = _walkboxTable + boxIdx * 40;
numPoints = *(pCurrentPtr++);
for(i = 0; i < numPoints; i++)
{
for (i = 0; i < numPoints; i++) {
int X = *(pCurrentPtr++);
int Y = *(pCurrentPtr++);
if(X < minX)
if (X < minX)
minX = X;
if(X > maxX)
if (X > maxX)
maxX = X;
if(Y < minY)
if (Y < minY)
minY = Y;
if(Y > maxY)
if (Y > maxY)
maxY = Y;
}
}
/************/
var_1C->field_0 = var_12;
ctpVar13 = var_12;
var_12->field_0 = (ctpVar19Struct*)(-1);
ctpVar13 = var_12;
var_12->field_0 = (ctpVar19Struct *) (-1);
subStruct = &var_1C->subStruct;
subStruct->boxIdx = boxIdx;
subStruct->type = walkboxType[boxIdx];
subStruct->minX = minX;
subStruct->maxX = maxX;
subStruct->minY = minY;
subStruct->maxY = maxY;
subStruct->type = walkboxType[boxIdx];
subStruct->minX = minX;
subStruct->maxX = maxX;
subStruct->minY = minY;
subStruct->maxY = maxY;
}
}
int loadCtp(uint8* ctpName)
{
int walkboxCounter; // si
uint8* ptr;
uint8* dataPointer; // ptr2
char fileType[5]; // string2
int loadCtp(uint8 *ctpName) {
int walkboxCounter; // si
uint8 *ptr;
uint8 *dataPointer; // ptr2
char fileType[5]; // string2
short int segementSizeTable[7]; // tempTable
char string[32];
if(ctpVar1 == 0)
{
if (ctpVar1 == 0) {
int i;
for(i = 0; i < 10; i++)
{
for (i = 0; i < 10; i++) {
persoTable[i] = NULL;
}
}
if(!loadFileSub1(&ptr,ctpName,0))
{
if (!loadFileSub1(&ptr, ctpName, 0)) {
free(ptr);
return(-18);
return (-18);
}
dataPointer = ptr;
fileType[4] = 0;
memcpy(fileType, dataPointer, 4); // get the file type, first 4 bytes of the CTP file
memcpy(fileType, dataPointer, 4); // get the file type, first 4 bytes of the CTP file
dataPointer += 4;
if(strcmp(fileType, "CTP "))
{
if (strcmp(fileType, "CTP ")) {
free(ptr);
return(0);
return (0);
}
memcpy(&ctp_routeCoordCount , dataPointer, 2); // get the number of path-finding coordinates
memcpy(&ctp_routeCoordCount, dataPointer, 2); // get the number of path-finding coordinates
dataPointer += 2;
flipShort(&ctp_routeCoordCount);
memcpy(segementSizeTable, dataPointer, 0xE);
dataPointer += 0xE; // + 14
dataPointer += 0xE; // + 14
flipGen(segementSizeTable, 0xE);
memcpy(ctp_routeCoords, dataPointer, segementSizeTable[0]); // get the path-finding coordinates
dataPointer += segementSizeTable[0];
flipGen(ctp_routeCoords, segementSizeTable[0]);
memcpy(ctp_routes, dataPointer, segementSizeTable[1]); // get the path-finding line informations (indexing the routeCoords array)
memcpy(ctp_routes, dataPointer, segementSizeTable[1]); // get the path-finding line informations (indexing the routeCoords array)
dataPointer += segementSizeTable[1];
flipGen(ctp_routes, segementSizeTable[1]);
memcpy(ctp_walkboxTable, dataPointer, segementSizeTable[2]);// get the walkbox coordinates and lines
memcpy(ctp_walkboxTable, dataPointer, segementSizeTable[2]); // get the walkbox coordinates and lines
dataPointer += segementSizeTable[2];
flipGen(ctp_walkboxTable, segementSizeTable[2]);
if(ctpVar1)
{
if (ctpVar1) {
dataPointer += segementSizeTable[3];
dataPointer += segementSizeTable[4];
}
else
{
} else {
memcpy(walkboxType, dataPointer, segementSizeTable[3]); // get the walkbox type
dataPointer += segementSizeTable[3];
flipGen(walkboxType, segementSizeTable[3]); // Type: 0x00 - non walkable, 0x01 - walkable, 0x02 - exit zone
flipGen(walkboxType, segementSizeTable[3]); // Type: 0x00 - non walkable, 0x01 - walkable, 0x02 - exit zone
memcpy(walkboxChange, dataPointer, segementSizeTable[4]); // change indicator, walkbox type can change, i.e. blocked by object (values are either 0x00 or 0x01)
dataPointer += segementSizeTable[4];
flipGen(walkboxChange, segementSizeTable[4]);
}
memcpy(ctpVar6, dataPointer, segementSizeTable[5]); // unknown? always 2*16 bytes (used by S24.CTP, S33.CTP, S33_2.CTP, S34.CTP, S35.CTP, S36.CTP; values can be 0x00, 0x01, 0x03, 0x05)
memcpy(ctpVar6, dataPointer, segementSizeTable[5]); // unknown? always 2*16 bytes (used by S24.CTP, S33.CTP, S33_2.CTP, S34.CTP, S35.CTP, S36.CTP; values can be 0x00, 0x01, 0x03, 0x05)
dataPointer += segementSizeTable[5];
flipGen(ctpVar6,segementSizeTable[5]);
flipGen(ctpVar6, segementSizeTable[5]);
memcpy(ctp_scale, dataPointer, segementSizeTable[6]); // scale values for the walkbox coordinates (don't know why there is a need for scaling walkboxes)
memcpy(ctp_scale, dataPointer, segementSizeTable[6]); // scale values for the walkbox coordinates (don't know why there is a need for scaling walkboxes)
dataPointer += segementSizeTable[6];
flipGen(ctp_scale, segementSizeTable[6]); // ok
flipGen(ctp_scale, segementSizeTable[6]); // ok
free(ptr);
strcpyuint8(string, currentCtpName);
numberOfWalkboxes = segementSizeTable[6] / 2; // get the number of walkboxes
numberOfWalkboxes = segementSizeTable[6] / 2; // get the number of walkboxes
loadCtpSub2(ctp_routeCoordCount, ctpVar8); // process path-finding stuff
loadCtpSub2(ctp_routeCoordCount, ctpVar8); // process path-finding stuff
polyStruct = ctpVar11 = ctpVar13 = ptr_something;
ptr = (uint8*) polyStruct;
ptr = (uint8 *) polyStruct;
walkboxCounter = numberOfWalkboxes;
while((--walkboxCounter) >= 0)
{
while ((--walkboxCounter) >= 0) {
loadCtpSub1(walkboxCounter, 0, ctp_walkboxTable, ctpVar13);
}
ctpVar15 = ctpVar13 + 1; // was after the -1 thing
ctpVar15 = ctpVar13 + 1; // was after the -1 thing
walkboxCounter = numberOfWalkboxes;
while(--walkboxCounter)
{
loadCtpSub1(walkboxCounter, ctp_scale[walkboxCounter] * 20, ctp_walkboxTable, ctpVar13);
while (--walkboxCounter) {
loadCtpSub1(walkboxCounter, ctp_scale[walkboxCounter] * 20,
ctp_walkboxTable, ctpVar13);
}
//ctpVar17 = ctpVar13 - ptr + 4;
{
int numOfUsedEntries = ctpVar13 - (ctpVar19Struct*) ptr;
numOfUsedEntries++;// there is a -1 entry at the end... Original was only mallocing numOfUsedEntries*sizeof(ctpVar19Struct)+4, but this is a bit ugly...
ctpVar13 = ctpVar11 = polyStruct = (ctpVar19Struct*)malloc(numOfUsedEntries * sizeof(ctpVar19Struct));
int numOfUsedEntries = ctpVar13 - (ctpVar19Struct *) ptr;
numOfUsedEntries++; // there is a -1 entry at the end... Original was only mallocing numOfUsedEntries*sizeof(ctpVar19Struct)+4, but this is a bit ugly...
ctpVar13 = ctpVar11 = polyStruct =
(ctpVar19Struct *) malloc(numOfUsedEntries *
sizeof(ctpVar19Struct));
}
walkboxCounter = numberOfWalkboxes;
while((--walkboxCounter) >= 0)
{
while ((--walkboxCounter) >= 0) {
loadCtpSub1(walkboxCounter, 0, ctp_walkboxTable, ctpVar13);
}
ctpVar15 = ctpVar13 + 1;
walkboxCounter = numberOfWalkboxes;
while(--walkboxCounter)
{
loadCtpSub1(walkboxCounter, ctp_scale[walkboxCounter] * 20, ctp_walkboxTable, ctpVar13);
while (--walkboxCounter) {
loadCtpSub1(walkboxCounter, ctp_scale[walkboxCounter] * 20,
ctp_walkboxTable, ctpVar13);
}
ctpVar19 = ctpVar11;
return(1);
return (1);
}
} // End of namespace Cruise

42
engines/cruise/ctp.h
View file

@ -22,41 +22,39 @@
*
*/
#ifndef _CTP_H_
#define _CTP_H_
#ifndef CRUISE_CTP_H
#define CRUISE_CTP_H
namespace Cruise {
struct ctpVar19SubStruct
{
uint16 boxIdx; //0
uint16 type; //2
uint16 minX; //4
uint16 maxX; //6
uint16 minY; //8
uint16 maxY; //A
struct ctpVar19SubStruct {
uint16 boxIdx; //0
uint16 type; //2
uint16 minX; //4
uint16 maxX; //6
uint16 minY; //8
uint16 maxY; //A
};
typedef struct ctpVar19SubStruct ctpVar19SubStruct;
struct ctpVar19Struct
{
struct ctpVar19Struct* field_0; //0
ctpVar19SubStruct subStruct;
struct ctpVar19Struct {
struct ctpVar19Struct *field_0; //0
ctpVar19SubStruct subStruct;
};
typedef struct ctpVar19Struct ctpVar19Struct;
extern ctpVar19Struct* ptr_something;
extern ctpVar19Struct* polyStruct;
extern ctpVar19Struct* ctpVar11;
extern ctpVar19Struct* ctpVar13;
extern ctpVar19Struct* ctpVar15;
extern ctpVar19Struct *ptr_something;
extern ctpVar19Struct *polyStruct;
extern ctpVar19Struct *ctpVar11;
extern ctpVar19Struct *ctpVar13;
extern ctpVar19Struct *ctpVar15;
extern uint8* ctpVar17;
extern ctpVar19Struct* ctpVar19;
extern uint8 *ctpVar17;
extern ctpVar19Struct *ctpVar19;
int loadCtp(uint8* ctpName);
int loadCtp(uint8 * ctpName);
int ctpProc2(int varX, int varY, int paramX, int paramY);
} // End of namespace Cruise

870
engines/cruise/dataLoader.cpp
View file

@ -26,15 +26,15 @@
namespace Cruise {
void loadSetEntry(uint8* name, uint8* ptr, int currentEntryIdx, int currentDestEntry);
void loadFNTSub(uint8* ptr, int destIdx);
void loadSetEntry(uint8 * name, uint8 * ptr, int currentEntryIdx,
int currentDestEntry);
void loadFNTSub(uint8 * ptr, int destIdx);
enum fileTypeEnum
{
type_UNK,
type_SPL,
type_SET,
type_FNT
enum fileTypeEnum {
type_UNK,
type_SPL,
type_SET,
type_FNT
};
typedef enum fileTypeEnum fileTypeEnum;
@ -43,384 +43,352 @@ int loadSingleFile;
// TODO: Unify decodeGfxFormat1, decodeGfxFormat4 and decodeGfxFormat5
void decodeGfxFormat1(dataFileEntry* pCurrentFileEntry)
{
uint8* buffer;
uint8* dataPtr = pCurrentFileEntry->subData.ptr;
void decodeGfxFormat1(dataFileEntry *pCurrentFileEntry) {
uint8 *buffer;
uint8 *dataPtr = pCurrentFileEntry->subData.ptr;
int spriteSize = pCurrentFileEntry->height * pCurrentFileEntry->widthInColumn * 8;
int x = 0;
int spriteSize =
pCurrentFileEntry->height * pCurrentFileEntry->widthInColumn * 8;
int x = 0;
buffer = (uint8*)malloc(spriteSize);
buffer = (uint8 *) malloc(spriteSize);
while (x < spriteSize)
{
uint8 c;
uint16 p0;
while (x < spriteSize) {
uint8 c;
uint16 p0;
p0 = (dataPtr[0] << 8) | dataPtr[1];
p0 = (dataPtr[0] << 8) | dataPtr[1];
/* decode planes */
for (c = 0; c < 16; c++)
{
buffer[x+c] = ((p0 >> 15) & 1);
/* decode planes */
for (c = 0; c < 16; c++) {
buffer[x + c] = ((p0 >> 15) & 1);
p0 <<= 1;
}
x+=16;
dataPtr+=2;
}
pCurrentFileEntry->subData.ptr = buffer;
}
void decodeGfxFormat4(dataFileEntry* pCurrentFileEntry)
{
uint8* buffer;
uint8* dataPtr = pCurrentFileEntry->subData.ptr;
int spriteSize = pCurrentFileEntry->height * pCurrentFileEntry->widthInColumn * 2;
int x = 0;
buffer = (uint8*)malloc(spriteSize);
while (x < spriteSize)
{
uint8 c;
uint16 p0;
uint16 p1;
uint16 p2;
uint16 p3;
p0 = (dataPtr[0] << 8) | dataPtr[1];
p1 = (dataPtr[2] << 8) | dataPtr[3];
p2 = (dataPtr[4] << 8) | dataPtr[5];
p3 = (dataPtr[6] << 8) | dataPtr[7];
/* decode planes */
for (c = 0; c < 16; c++)
{
buffer[x+c] = ((p0 >> 15) & 1) | ((p1 >> 14) & 2) | ((p2 >> 13) & 4) | ((p3 >> 12) & 8);
p0 <<= 1;
p1 <<= 1;
p2 <<= 1;
p3 <<= 1;
}
x+=16;
dataPtr+=8;
}
pCurrentFileEntry->subData.ptr = buffer;
}
void decodeGfxFormat5(dataFileEntry* pCurrentFileEntry)
{
uint8* buffer;
uint8* dataPtr = pCurrentFileEntry->subData.ptr;
int spriteSize = pCurrentFileEntry->height * pCurrentFileEntry->widthInColumn;
int x = 0;
int range = pCurrentFileEntry->height * pCurrentFileEntry->width;
buffer = (uint8*)malloc(spriteSize);
while (x < spriteSize)
{
uint8 c;
uint16 p0;
uint16 p1;
uint16 p2;
uint16 p3;
uint16 p4;
p0 = (dataPtr[0 + range * 0] << 8) | dataPtr[1 + range * 0];
p1 = (dataPtr[0 + range * 1] << 8) | dataPtr[1 + range * 1];
p2 = (dataPtr[0 + range * 2] << 8) | dataPtr[1 + range * 2];
p3 = (dataPtr[0 + range * 3] << 8) | dataPtr[1 + range * 3];
p4 = (dataPtr[0 + range * 4] << 8) | dataPtr[1 + range * 4];
/* decode planes */
for (c = 0; c < 16; c++)
{
buffer[x+c] = ((p0 >> 15) & 1) | ((p1 >> 14) & 2) | ((p2 >> 13) & 4) | ((p3 >> 12) & 8) | ((p4 >> 11) & 16);
p0 <<= 1;
p1 <<= 1;
p2 <<= 1;
p3 <<= 1;
p4 <<= 1;
}
x+=16;
dataPtr+=2;
}
pCurrentFileEntry->subData.ptr = buffer;
}
int updateResFileEntry(int height, int width, int entryNumber, int resType)
{
int div = 0;
int size;
resetFileEntry(entryNumber);
filesDatabase[entryNumber].subData.field_1C = 0;
size = height * width; // for sprites: width * height
if(resType == 4)
{
div = size / 4;
}
else if (resType == 5)
{
width = (width * 8) / 5;
}
filesDatabase[entryNumber].subData.ptr = (uint8*)mallocAndZero(size + div);
if(!filesDatabase[entryNumber].subData.ptr)
return(-2);
filesDatabase[entryNumber].widthInColumn = width;
filesDatabase[entryNumber].subData.ptr2 = filesDatabase[entryNumber].subData.ptr+size;
filesDatabase[entryNumber].width = width / 8;
filesDatabase[entryNumber].resType = resType;
filesDatabase[entryNumber].height = height;
filesDatabase[entryNumber].subData.index = -1;
return entryNumber;
}
int createResFileEntry(int width, int height, int resType)
{
int i;
int entryNumber;
int div = 0;
int size;
printf("Executing untested createResFileEntry!\n");
exit(1);
for(i = 0; i < 257; i++)
{
if(!filesDatabase[i].subData.ptr)
break;
}
if(i >= 257)
{
return(-19);
}
entryNumber = i;
filesDatabase[entryNumber].subData.field_1C = 0;
size = width * height; // for sprites: width * height
if(resType == 4)
{
div = size / 4;
}
else if (resType == 5)
{
width = (width * 8) / 5;
}
filesDatabase[entryNumber].subData.ptr = (uint8*)mallocAndZero(size + div);
if(filesDatabase[entryNumber].subData.ptr)
{
return(-2);
}
filesDatabase[entryNumber].widthInColumn = width;
filesDatabase[entryNumber].subData.ptr2 = filesDatabase[entryNumber].subData.ptr + size;
filesDatabase[entryNumber].width = width / 8;
filesDatabase[entryNumber].resType = resType;
filesDatabase[entryNumber].height = height;
filesDatabase[entryNumber].subData.index = -1;
return entryNumber;
}
fileTypeEnum getFileType(uint8* name)
{
char extentionBuffer[16];
fileTypeEnum newFileType = type_UNK;
getFileExtention((char*)name,extentionBuffer);
if(!strcmp(extentionBuffer,".SPL"))
{
newFileType = type_SPL;
}
else
if(!strcmp(extentionBuffer,".SET"))
{
newFileType = type_SET;
}
else
if(!strcmp(extentionBuffer,".FNT"))
{
newFileType = type_FNT;
}
ASSERT(newFileType != type_UNK);
return newFileType;
}
int getNumMaxEntiresInSet(uint8* ptr)
{
uint16 numEntries = *(uint16*)(ptr + 4);
flipShort(&numEntries);
return numEntries;
}
int loadFileMode2(uint8* name, int startIdx, int currentEntryIdx, int numIdx)
{
uint8* ptr = NULL;
fileTypeEnum fileType;
fileType = getFileType(name);
loadFileSub1(&ptr, name, NULL);
switch(fileType)
{
case type_SET:
{
int i;
int numMaxEntriesInSet = getNumMaxEntiresInSet(ptr);
for(i = 0; i < numIdx; i++)
{
if ((currentEntryIdx + i) > numMaxEntriesInSet)
{
return 0; // exit if limit is reached
p0 <<= 1;
}
loadSetEntry(name, ptr, currentEntryIdx + i, startIdx + i);
}
break;
}
case type_FNT:
{
loadFNTSub(ptr, startIdx);
break;
}
case type_UNK:
{
break;
x += 16;
dataPtr += 2;
}
case type_SPL:
{
break;
}
}
return 0;
pCurrentFileEntry->subData.ptr = buffer;
}
int loadFullBundle(uint8* name, int startIdx)
{
uint8* ptr = NULL;
fileTypeEnum fileType;
fileType = getFileType(name);
void decodeGfxFormat4(dataFileEntry *pCurrentFileEntry) {
uint8 *buffer;
uint8 *dataPtr = pCurrentFileEntry->subData.ptr;
loadFileSub1(&ptr,name,NULL);
int spriteSize =
pCurrentFileEntry->height * pCurrentFileEntry->widthInColumn * 2;
int x = 0;
switch(fileType)
{
case type_SET:
{
int i;
int numMaxEntriesInSet;
buffer = (uint8 *) malloc(spriteSize);
numMaxEntriesInSet = getNumMaxEntiresInSet(ptr); // get maximum number of sprites/animations in SET file
for(i = 0; i < numMaxEntriesInSet; i++)
{
loadSetEntry(name, ptr, i, startIdx+i);
}
while (x < spriteSize) {
uint8 c;
uint16 p0;
uint16 p1;
uint16 p2;
uint16 p3;
break;
}
case type_FNT:
{
loadFNTSub(ptr, startIdx);
break;
}
case type_UNK:
{
break;
p0 = (dataPtr[0] << 8) | dataPtr[1];
p1 = (dataPtr[2] << 8) | dataPtr[3];
p2 = (dataPtr[4] << 8) | dataPtr[5];
p3 = (dataPtr[6] << 8) | dataPtr[7];
/* decode planes */
for (c = 0; c < 16; c++) {
buffer[x + c] =
((p0 >> 15) & 1) | ((p1 >> 14) & 2) | ((p2 >> 13) &
4) | ((p3 >> 12) & 8);
p0 <<= 1;
p1 <<= 1;
p2 <<= 1;
p3 <<= 1;
}
x += 16;
dataPtr += 8;
}
case type_SPL:
{
break;
}
}
return 0;
pCurrentFileEntry->subData.ptr = buffer;
}
void loadFNTSub(uint8* ptr, int destIdx)
{
uint8* ptr2 = ptr;
uint8* destPtr;
int fileIndex;
uint32 fontSize;
ptr2 += 4;
memcpy(&loadFileVar1, ptr2, 4);
void decodeGfxFormat5(dataFileEntry *pCurrentFileEntry) {
uint8 *buffer;
uint8 *dataPtr = pCurrentFileEntry->subData.ptr;
flipLong(&loadFileVar1);
int spriteSize =
pCurrentFileEntry->height * pCurrentFileEntry->widthInColumn;
int x = 0;
int range = pCurrentFileEntry->height * pCurrentFileEntry->width;
if(destIdx == -1)
{
fileIndex = createResFileEntry(loadFileVar1, 1 ,1);
}
else
{
fileIndex = updateResFileEntry(loadFileVar1, 1, destIdx, 1);
}
buffer = (uint8 *) malloc(spriteSize);
destPtr = filesDatabase[fileIndex].subData.ptr;
while (x < spriteSize) {
uint8 c;
uint16 p0;
uint16 p1;
uint16 p2;
uint16 p3;
uint16 p4;
memcpy(destPtr, ptr2, loadFileVar1);
p0 = (dataPtr[0 + range * 0] << 8) | dataPtr[1 + range * 0];
p1 = (dataPtr[0 + range * 1] << 8) | dataPtr[1 + range * 1];
p2 = (dataPtr[0 + range * 2] << 8) | dataPtr[1 + range * 2];
p3 = (dataPtr[0 + range * 3] << 8) | dataPtr[1 + range * 3];
p4 = (dataPtr[0 + range * 4] << 8) | dataPtr[1 + range * 4];
memcpy(&fontSize,ptr2,4);
flipLong(&fontSize);
/* decode planes */
for (c = 0; c < 16; c++) {
buffer[x + c] =
((p0 >> 15) & 1) | ((p1 >> 14) & 2) | ((p2 >> 13) &
4) | ((p3 >> 12) & 8) | ((p4 >> 11) & 16);
if(destPtr!=NULL)
{
p0 <<= 1;
p1 <<= 1;
p2 <<= 1;
p3 <<= 1;
p4 <<= 1;
}
x += 16;
dataPtr += 2;
}
pCurrentFileEntry->subData.ptr = buffer;
}
int updateResFileEntry(int height, int width, int entryNumber, int resType) {
int div = 0;
int size;
resetFileEntry(entryNumber);
filesDatabase[entryNumber].subData.field_1C = 0;
size = height * width; // for sprites: width * height
if (resType == 4) {
div = size / 4;
} else if (resType == 5) {
width = (width * 8) / 5;
}
filesDatabase[entryNumber].subData.ptr =
(uint8 *) mallocAndZero(size + div);
if (!filesDatabase[entryNumber].subData.ptr)
return (-2);
filesDatabase[entryNumber].widthInColumn = width;
filesDatabase[entryNumber].subData.ptr2 =
filesDatabase[entryNumber].subData.ptr + size;
filesDatabase[entryNumber].width = width / 8;
filesDatabase[entryNumber].resType = resType;
filesDatabase[entryNumber].height = height;
filesDatabase[entryNumber].subData.index = -1;
return entryNumber;
}
int createResFileEntry(int width, int height, int resType) {
int i;
int entryNumber;
int div = 0;
int size;
printf("Executing untested createResFileEntry!\n");
exit(1);
for (i = 0; i < 257; i++) {
if (!filesDatabase[i].subData.ptr)
break;
}
if (i >= 257) {
return (-19);
}
entryNumber = i;
filesDatabase[entryNumber].subData.field_1C = 0;
size = width * height; // for sprites: width * height
if (resType == 4) {
div = size / 4;
} else if (resType == 5) {
width = (width * 8) / 5;
}
filesDatabase[entryNumber].subData.ptr =
(uint8 *) mallocAndZero(size + div);
if (filesDatabase[entryNumber].subData.ptr) {
return (-2);
}
filesDatabase[entryNumber].widthInColumn = width;
filesDatabase[entryNumber].subData.ptr2 =
filesDatabase[entryNumber].subData.ptr + size;
filesDatabase[entryNumber].width = width / 8;
filesDatabase[entryNumber].resType = resType;
filesDatabase[entryNumber].height = height;
filesDatabase[entryNumber].subData.index = -1;
return entryNumber;
}
fileTypeEnum getFileType(uint8 *name) {
char extentionBuffer[16];
fileTypeEnum newFileType = type_UNK;
getFileExtention((char *)name, extentionBuffer);
if (!strcmp(extentionBuffer, ".SPL")) {
newFileType = type_SPL;
} else if (!strcmp(extentionBuffer, ".SET")) {
newFileType = type_SET;
} else if (!strcmp(extentionBuffer, ".FNT")) {
newFileType = type_FNT;
}
ASSERT(newFileType != type_UNK);
return newFileType;
}
int getNumMaxEntiresInSet(uint8 *ptr) {
uint16 numEntries = *(uint16 *) (ptr + 4);
flipShort(&numEntries);
return numEntries;
}
int loadFileMode2(uint8 *name, int startIdx, int currentEntryIdx, int numIdx) {
uint8 *ptr = NULL;
fileTypeEnum fileType;
fileType = getFileType(name);
loadFileSub1(&ptr, name, NULL);
switch (fileType) {
case type_SET:
{
int i;
int numMaxEntriesInSet = getNumMaxEntiresInSet(ptr);
for (i = 0; i < numIdx; i++) {
if ((currentEntryIdx + i) > numMaxEntriesInSet) {
return 0; // exit if limit is reached
}
loadSetEntry(name, ptr, currentEntryIdx + i,
startIdx + i);
}
break;
}
case type_FNT:
{
loadFNTSub(ptr, startIdx);
break;
}
case type_UNK:
{
break;
}
case type_SPL:
{
break;
}
}
return 0;
}
int loadFullBundle(uint8 *name, int startIdx) {
uint8 *ptr = NULL;
fileTypeEnum fileType;
fileType = getFileType(name);
loadFileSub1(&ptr, name, NULL);
switch (fileType) {
case type_SET:
{
int i;
int numMaxEntriesInSet;
numMaxEntriesInSet = getNumMaxEntiresInSet(ptr); // get maximum number of sprites/animations in SET file
for (i = 0; i < numMaxEntriesInSet; i++) {
loadSetEntry(name, ptr, i, startIdx + i);
}
break;
}
case type_FNT:
{
loadFNTSub(ptr, startIdx);
break;
}
case type_UNK:
{
break;
}
case type_SPL:
{
break;
}
}
return 0;
}
void loadFNTSub(uint8 *ptr, int destIdx) {
uint8 *ptr2 = ptr;
uint8 *destPtr;
int fileIndex;
uint32 fontSize;
ptr2 += 4;
memcpy(&loadFileVar1, ptr2, 4);
flipLong(&loadFileVar1);
if (destIdx == -1) {
fileIndex = createResFileEntry(loadFileVar1, 1, 1);
} else {
fileIndex = updateResFileEntry(loadFileVar1, 1, destIdx, 1);
}
destPtr = filesDatabase[fileIndex].subData.ptr;
memcpy(destPtr, ptr2, loadFileVar1);
memcpy(&fontSize, ptr2, 4);
flipLong(&fontSize);
if (destPtr != NULL) {
int32 i;
uint8* currentPtr;
uint8 *currentPtr;
destPtr = filesDatabase[fileIndex].subData.ptr;
flipLong((int32*) destPtr);
flipLong((int32*) (destPtr + 4));
flipLong((int32 *) destPtr);
flipLong((int32 *) (destPtr + 4));
flipGen(destPtr + 8, 6);
currentPtr = destPtr + 14;
for(i = 0; i < *(int16*) (destPtr + 8); i++)
{
flipLong((int32*) currentPtr);
for (i = 0; i < *(int16 *) (destPtr + 8); i++) {
flipLong((int32 *) currentPtr);
currentPtr += 4;
flipGen(currentPtr, 8);
@ -429,120 +397,124 @@ void loadFNTSub(uint8* ptr, int destIdx)
}
}
void loadSetEntry(uint8* name, uint8* ptr, int currentEntryIdx, int currentDestEntry)
{
uint8* ptr2;
uint8* ptr3;
int offset;
int sec = 0;
uint16 numIdx;
if (!strcmpuint8(ptr,"SEC"))
{
sec = 1;
}
void loadSetEntry(uint8 *name, uint8 *ptr, int currentEntryIdx,
int currentDestEntry) {
uint8 *ptr2;
uint8 *ptr3;
int offset;
int sec = 0;
uint16 numIdx;
ptr2 = ptr + 4;
if (!strcmpuint8(ptr, "SEC")) {
sec = 1;
}
memcpy(&numIdx,ptr2,2);
flipShort(&numIdx);
ptr2 = ptr + 4;
ptr3 = ptr + 6;
memcpy(&numIdx, ptr2, 2);
flipShort(&numIdx);
offset = currentEntryIdx*16;
ptr3 = ptr + 6;
{
uint8* ptr4;
int resourceSize;
int fileIndex;
setHeaderEntry localBuffer;
uint8* ptr5;
offset = currentEntryIdx * 16;
ptr4 = ptr + offset + 6;
{
uint8 *ptr4;
int resourceSize;
int fileIndex;
setHeaderEntry localBuffer;
uint8 *ptr5;
memcpy(&localBuffer, ptr4, sizeof(setHeaderEntry));
ptr4 = ptr + offset + 6;
flipLong((int32*) &localBuffer.field_0);
flipGen(&localBuffer.width, 12);
memcpy(&localBuffer, ptr4, sizeof(setHeaderEntry));
if ((sec == 1) || (localBuffer.type == 5))
{
localBuffer.width = localBuffer.width - (localBuffer.type * 2); // Type 1: Width - (1*2) , Type 5: Width - (5*2)
}
resourceSize = localBuffer.width * localBuffer.height;
flipLong((int32 *) & localBuffer.field_0);
flipGen(&localBuffer.width, 12);
if(currentDestEntry == -1)
{
fileIndex = createResFileEntry(localBuffer.width,localBuffer.height,localBuffer.type);
}
else
{
fileIndex = updateResFileEntry(localBuffer.height, localBuffer.width, currentDestEntry, localBuffer.type);
}
if ((sec == 1) || (localBuffer.type == 5)) {
localBuffer.width = localBuffer.width - (localBuffer.type * 2); // Type 1: Width - (1*2) , Type 5: Width - (5*2)
}
if(fileIndex < 0)
{
return; // TODO: buffer is not freed
}
resourceSize = localBuffer.width * localBuffer.height;
ptr5 = ptr3 + localBuffer.field_0 + numIdx * 16;
if (currentDestEntry == -1) {
fileIndex =
createResFileEntry(localBuffer.width,
localBuffer.height, localBuffer.type);
} else {
fileIndex =
updateResFileEntry(localBuffer.height,
localBuffer.width, currentDestEntry,
localBuffer.type);
}
memcpy(filesDatabase[fileIndex].subData.ptr,ptr5, resourceSize);
ptr5 += resourceSize;
if (fileIndex < 0) {
return; // TODO: buffer is not freed
}
switch(localBuffer.type)
{
case 0:
{
filesDatabase[fileIndex].subData.resourceType = 8;
break;
}
case 1:
{
filesDatabase[fileIndex].subData.resourceType = 2;
decodeGfxFormat1(&filesDatabase[fileIndex]);
break;
}
case 4:
{
filesDatabase[fileIndex].width *= 2;
filesDatabase[fileIndex].subData.resourceType = 4;
decodeGfxFormat4(&filesDatabase[fileIndex]);
break;
}
case 5:
{
if (sec == 0)
{
// TODO sec type 5 needs special conversion. cut out 2 bytes at every width/5 position.
return;
}
filesDatabase[fileIndex].subData.resourceType = 4;
decodeGfxFormat5(&filesDatabase[fileIndex]);
break;
}
case 8:
{
filesDatabase[fileIndex].subData.resourceType = 4; // dummy !
break;
}
default:
{
printf("Unsuported gfx loading type: %d\n", localBuffer.type);
break;
}
}
ptr5 = ptr3 + localBuffer.field_0 + numIdx * 16;
filesDatabase[fileIndex].subData.index = currentDestEntry;
filesDatabase[fileIndex].subData.transparency = localBuffer.transparency; /*% 0x10*/;
memcpy(filesDatabase[fileIndex].subData.ptr, ptr5,
resourceSize);
ptr5 += resourceSize;
strcpyuint8(filesDatabase[fileIndex].subData.name,name);
}
switch (localBuffer.type) {
case 0:
{
filesDatabase[fileIndex].subData.resourceType =
8;
break;
}
case 1:
{
filesDatabase[fileIndex].subData.resourceType =
2;
decodeGfxFormat1(&filesDatabase[fileIndex]);
break;
}
case 4:
{
filesDatabase[fileIndex].width *= 2;
filesDatabase[fileIndex].subData.resourceType =
4;
decodeGfxFormat4(&filesDatabase[fileIndex]);
break;
}
case 5:
{
if (sec == 0) {
// TODO sec type 5 needs special conversion. cut out 2 bytes at every width/5 position.
return;
}
filesDatabase[fileIndex].subData.resourceType =
4;
decodeGfxFormat5(&filesDatabase[fileIndex]);
break;
}
case 8:
{
filesDatabase[fileIndex].subData.resourceType = 4; // dummy !
break;
}
default:
{
printf("Unsuported gfx loading type: %d\n",
localBuffer.type);
break;
}
}
// TODO: free
filesDatabase[fileIndex].subData.index = currentDestEntry;
filesDatabase[fileIndex].subData.transparency =
localBuffer.transparency; /*% 0x10 */ ;
return;
strcpyuint8(filesDatabase[fileIndex].subData.name, name);
}
// TODO: free
return;
}
} // End of namespace Cruise

12
engines/cruise/dataLoader.h
View file

@ -22,16 +22,16 @@
*
*/
#ifndef _DATALOADER_H_
#define _DATALOADER_H_
#ifndef CRUISE_DATALOADER_H
#define CRUISE_DATALOADER_H
namespace Cruise {
int loadData(uint8* name, int startIdx);
int loadFileMode2(uint8* name, int param, int startIdx, int numIdx);
int loadFileSub1(uint8** ptr, uint8* name, uint8* ptr2);
int loadData(uint8 * name, int startIdx);
int loadFileMode2(uint8 * name, int param, int startIdx, int numIdx);
int loadFileSub1(uint8 ** ptr, uint8 * name, uint8 * ptr2);
int loadFullBundle(uint8* name, int startIdx);
int loadFullBundle(uint8 * name, int startIdx);
} // End of namespace Cruise

2433
engines/cruise/decompiler.cpp
View file

File diff suppressed because it is too large Load diff

171
engines/cruise/delphine-unpack.cpp
View file

@ -26,12 +26,11 @@
namespace Cruise {
uint32 crc; // variable at 5C5A
uint32 bitbucket; // dx:bx
uint32 crc; // variable at 5C5A
uint32 bitbucket; // dx:bx
uint16 swap16(uint16 r)
{
return (r >> 8) | (r << 8);
uint16 swap16(uint16 r) {
return (r >> 8) | (r << 8);
}
#define loadd(p, d) {\
@ -64,90 +63,91 @@ uint16 swap16(uint16 r)
} while (nbits);\
}
int32 decomp(uint8 * in, uint8 * out, int32 size) {
uint8 bit = 0; // Carry flag
uint8 nbits = 0; // cl
uint8 byte = 0; // ch
uint16 counter = 0; // bp
uint16 var = 0; // variable at 5C58
uint16 ptr = 0;
uint16 flags = 0;
enum {
DO_COPY,
DO_UNPACK
} action;
loadd(in, crc);
loadd(in, bitbucket);
crc ^= bitbucket;
int32 decomp(uint8 *in, uint8 *out, int32 size) {
uint8 bit = 0; // Carry flag
uint8 nbits = 0; // cl
uint8 byte = 0; // ch
uint16 counter = 0; // bp
uint16 var = 0; // variable at 5C58
uint16 ptr = 0;
uint16 flags = 0;
enum {
DO_COPY,
DO_UNPACK
} action;
do { // 5A4C
getbit(in, bit);
if (!bit) { // 5A94
getbit(in, bit);
if (!bit) { // 5AC8
nbits = 3;
byte = 0;
action = DO_COPY;
} else { // 5ACA
var = 1;
nbits = 8;
action = DO_UNPACK;
}
} else { // 5B4F
nbits = 2;
loadbits(in, flags);
if (flags < 2) {
nbits = flags + 9; // 5BC3
var = flags + 2;
action = DO_UNPACK;
} else if (flags == 3) {
nbits = 8; // 5B4A
byte = 8;
action = DO_COPY;
} else {
nbits = 8;
loadbits(in, var);
nbits = 12;
action = DO_UNPACK;
}
}
loadd(in, crc);
loadd(in, bitbucket);
crc ^= bitbucket;
switch (action) {
case DO_COPY:
// 5AD1
loadbits(in, counter); // 5AFD
counter += byte;
counter++;
size -= counter;
do {
nbits = 8;
loadbits(in, byte); // 5B3F
store(out, byte);
counter--;
} while (counter); // 5B45
break;
case DO_UNPACK:
// 5BD3
loadbits(in, ptr); // 5BFF
counter = var + 1;
size -= counter;
do {
byte = *(out + ptr - 1);
store(out, byte);
counter--;
} while(counter);
do { // 5A4C
getbit(in, bit);
if (!bit) { // 5A94
getbit(in, bit);
if (!bit) { // 5AC8
nbits = 3;
byte = 0;
action = DO_COPY;
} else { // 5ACA
var = 1;
nbits = 8;
action = DO_UNPACK;
}
} else { // 5B4F
nbits = 2;
loadbits(in, flags);
if (flags < 2) {
nbits = flags + 9; // 5BC3
var = flags + 2;
action = DO_UNPACK;
} else if (flags == 3) {
nbits = 8; // 5B4A
byte = 8;
action = DO_COPY;
} else {
nbits = 8;
loadbits(in, var);
nbits = 12;
action = DO_UNPACK;
}
}
switch (action) {
case DO_COPY:
// 5AD1
loadbits(in, counter); // 5AFD
counter += byte;
counter++;
size -= counter;
do {
nbits = 8;
loadbits(in, byte); // 5B3F
store(out, byte);
counter--;
} while (counter); // 5B45
break;
case DO_UNPACK:
// 5BD3
loadbits(in, ptr); // 5BFF
counter = var + 1;
size -= counter;
do {
byte = *(out + ptr - 1);
store(out, byte);
counter--;
} while (counter);
}
} while (size > 0);
// 5C32
// ???
if (crc) {
return -1;
} else {
return 0;
}
} while (size > 0);
// 5C32
// ???
if (crc) {
return -1;
} else {
return 0;
}
}
/*
int main(void) {
FILE * in, * out;
@ -172,5 +172,4 @@ int main(void) {
fclose(in);
}*/
} // End of namespace Cruise

10
engines/cruise/detection.cpp
View file

@ -31,6 +31,7 @@
#include "cruise/cruise.h"
namespace Cruise {
struct CRUISEGameDescription {
Common::ADGameDescription desc;
@ -60,7 +61,7 @@ namespace Cruise {
static const CRUISEGameDescription gameDescriptions[] = {
{
{
{
"cruise",
"",
AD_ENTRY1("D1", "41a7a4d426dbd048eb369cfee4bb2717"),
@ -70,9 +71,9 @@ static const CRUISEGameDescription gameDescriptions[] = {
},
GType_CRUISE,
0,
},
},
{
{
{
"cruise",
"",
AD_ENTRY1("D1", "a90d2b9ead6b4d812cd14268672cf178"),
@ -83,7 +84,7 @@ static const CRUISEGameDescription gameDescriptions[] = {
GType_CRUISE,
0,
},
{ AD_TABLE_END_MARKER, 0, 0 }
{AD_TABLE_END_MARKER, 0, 0}
};
}
@ -117,6 +118,7 @@ namespace Cruise {
bool CruiseEngine::initGame() {
_gameDescription = (const CRUISEGameDescription *)Common::AdvancedDetector::detectBestMatchingGame(detectionParams);
return (_gameDescription != 0);
}

674
engines/cruise/font.cpp
View file

File diff suppressed because it is too large Load diff

29
engines/cruise/font.h
View file

@ -22,27 +22,30 @@
*
*/
#ifndef _FONT_H_
#define _FONT_H_
#ifndef CRUISE_FONT_H
#define CRUISE_FONT_H
namespace Cruise {
void loadFNT(const void* fileName);
void loadFNT(const void *fileName);
void loadSystemFont(void);
//////////////////////////////////////////////////
void flipShort(int16* var);
void flipShort(uint16* var);
void flipLong(int32* var); // TODO: move away
void flipLong(uint32* var); // TODO: move away
void flipGen(void* var, int32 length);
void flipShort(int16 * var);
void flipShort(uint16 * var);
void flipLong(int32 * var); // TODO: move away
void flipLong(uint32 * var); // TODO: move away
void flipGen(void *var, int32 length);
int32 getLineHeight(int16 charCount, uint8* fontPtr, uint8* fontPrt_Desc); // fontProc1
int32 getTextLineCount(int32 rightBorder_X, int32 wordSpacingWidth, uint8* ptr, uint8* textString); // fontProc2
int32 getLineHeight(int16 charCount, uint8 * fontPtr, uint8 * fontPrt_Desc); // fontProc1
int32 getTextLineCount(int32 rightBorder_X, int32 wordSpacingWidth, uint8 * ptr, uint8 * textString); // fontProc2
void renderWord(uint8* fontPtr_Data, uint8* outBufferPtr, int32 drawPosPixel_X, int32 heightOff, int32 height, int32 param4, int32 stringRenderBufferSize, int32 width , int32 charWidth);
gfxEntryStruct* renderText(int inRightBorder_X, uint8* string);
void drawString(int32 x, int32 y, uint8* string, uint8* buffer, uint8 color, int32 inRightBorder_X);
void renderWord(uint8 * fontPtr_Data, uint8 * outBufferPtr,
int32 drawPosPixel_X, int32 heightOff, int32 height, int32 param4,
int32 stringRenderBufferSize, int32 width, int32 charWidth);
gfxEntryStruct *renderText(int inRightBorder_X, uint8 * string);
void drawString(int32 x, int32 y, uint8 * string, uint8 * buffer, uint8 color,
int32 inRightBorder_X);
} // End of namespace Cruise

327
engines/cruise/fontCharacterTable.cpp
View file

@ -26,170 +26,169 @@
namespace Cruise {
int16 fontCharacterTable[256]={
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
86, 87, 88, 89, 90, 91, 92,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
106, 105,
-1,
-1,
-1,
-1,
107, 108,
-1,-1,
109, 110,
-1,
-1,
-1,
-1,
-1,-1,
111, -1,
112,
-1,-1,
113,
114,
-1,
-1,
116, 93,
-1,
118,
-1,
94,
-1,
117,
115,
96,
95,
97,
98,
-1,
-1,
99,
100,
-1,
-1,
-1,
-1,
101,
-1,
102,
-1,
-1,
103,
-1,
104,
-1,
-1,
-1,
-1,
int16 fontCharacterTable[256] = {
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
86, 87, 88, 89, 90, 91, 92,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
106, 105,
-1,
-1,
-1,
-1,
107, 108,
-1, -1,
109, 110,
-1,
-1,
-1,
-1,
-1, -1,
111, -1,
112,
-1, -1,
113,
114,
-1,
-1,
116, 93,
-1,
118,
-1,
94,
-1,
117,
115,
96,
95,
97,
98,
-1,
-1,
99,
100,
-1,
-1,
-1,
-1,
101,
-1,
102,
-1,
-1,
103,
-1,
104,
-1,
-1,
-1,
-1,
};
} // End of namespace Cruise

8
engines/cruise/fontCharacterTable.h
View file

@ -22,14 +22,12 @@
*
*/
#ifndef _FONTCHARACTERTABLE_H_
#define _FONTCHARACTERTABLE_H_
#ifndef CRUISE_FONTCHARACTERTABLE_H
#define CRUISE_FONTCHARACTERTABLE_H
namespace Cruise {
extern short int fontCharacterTable[256];
} // End of namespace Cruise
} // End of namespace Cruise
#endif

2028
engines/cruise/function.cpp
View file

File diff suppressed because it is too large Load diff

5
engines/cruise/function.h
View file

@ -22,8 +22,8 @@
*
*/
#ifndef _FUNCTION_H_
#define _FUNCTION_H_
#ifndef CRUISE_FUNCTION_H
#define CRUISE_FUNCTION_H
namespace Cruise {
@ -36,4 +36,3 @@ int16 subOp23(int param1, int param2);
} // End of namespace Cruise
#endif

968
engines/cruise/gfxModule.cpp
View file

File diff suppressed because it is too large Load diff

32
engines/cruise/gfxModule.h
View file

@ -22,24 +22,22 @@
*
*/
#ifndef _GFXMODULE_H_
#define _GFXMODULE_H_
#ifndef CRUISE_GFXMODULE_H
#define CRUISE_GFXMODULE_H
namespace Cruise {
struct gfxModuleDataStruct
{
struct gfxModuleDataStruct {
int field_1;
int useTandy;
int useEGA;
int useVGA;
uint8* pPage00;
uint8* pPage10;
uint8 *pPage00;
uint8 *pPage10;
};
struct palEntry
{
struct palEntry {
uint8 R;
uint8 G;
uint8 B;
@ -51,22 +49,22 @@ typedef struct palEntry palEntry;
extern gfxModuleDataStruct gfxModuleData;
extern palEntry lpalette[256];
extern short globalAtariScreen[320*200/4];
extern short globalAtariScreen[320 * 200 / 4];
void gfxModuleData_gfxClearFrameBuffer(uint8* ptr);
void gfxModuleData_setPal(uint8* ptr);
void gfxModuleData_gfxClearFrameBuffer(uint8 * ptr);
void gfxModuleData_setPal(uint8 * ptr);
void gfxModuleData_field_90(void);
void gfxModuleData_gfxWaitVSync(void);
void gfxModuleData_flip(void);
void gfxModuleData_field_64(char* sourceBuffer, int width, int height, char* dest, int x, int y, int color);
void gfxModuleData_gfxCopyScreen(char* sourcePtr,char* destPtr);
void gfxModuleData_field_60(char* sourcePtr, int width, int height, char* destPtr, int x, int y);
void gfxModuleData_field_64(char *sourceBuffer, int width, int height,
char *dest, int x, int y, int color);
void gfxModuleData_gfxCopyScreen(char *sourcePtr, char *destPtr);
void gfxModuleData_field_60(char *sourcePtr, int width, int height,
char *destPtr, int x, int y);
void gfxModuleData_flipScreen(void);
void gfxModuleData_setPal256(int16* ptr);
void gfxModuleData_setPal256(int16 * ptr);
void flip(void);
} // End of namespace Cruise
#endif

501
engines/cruise/linker.cpp
View file

@ -26,304 +26,333 @@
namespace Cruise {
exportEntryStruct* parseExport(int* out1, int* pExportedFuncionIdx, char* buffer)
{
char localBuffer[256];
uint8 functionName[256];
uint8 overlayName[256];
char* dotPtr;
char* ptr2;
int idx;
int numExport;
exportEntryStruct* currentExportEntry;
uint8* entity1Name;
int i;
*out1 = 0;
*pExportedFuncionIdx = 0;
exportEntryStruct *parseExport(int *out1, int *pExportedFuncionIdx,
char *buffer) {
char localBuffer[256];
uint8 functionName[256];
uint8 overlayName[256];
char *dotPtr;
char *ptr2;
int idx;
int numExport;
exportEntryStruct *currentExportEntry;
uint8 *entity1Name;
int i;
strcpyuint8(localBuffer, buffer);
dotPtr = strchr(localBuffer,'.');
*out1 = 0;
*pExportedFuncionIdx = 0;
if(dotPtr)
{
strcpyuint8(functionName,dotPtr+1);
*dotPtr = 0;
strcpyuint8(localBuffer, buffer);
dotPtr = strchr(localBuffer, '.');
strcpyuint8(overlayName,localBuffer);
}
else
{
overlayName[0] = 0;
strcpyuint8(functionName,buffer);
}
if (dotPtr) {
strcpyuint8(functionName, dotPtr + 1);
*dotPtr = 0;
ptr2 = strchr((char*)functionName,':');
strcpyuint8(overlayName, localBuffer);
} else {
overlayName[0] = 0;
if(ptr2)
{
*ptr2 = 0;
strcpyuint8(functionName, buffer);
}
*out1 = 1;
}
ptr2 = strchr((char *)functionName, ':');
strToUpper(overlayName);
strToUpper(functionName);
if(strlen((char*)overlayName) == 0)
return NULL;
if (ptr2) {
*ptr2 = 0;
idx = findOverlayByName2(overlayName);
*out1 = 1;
}
if(idx == -4)
return(NULL);
strToUpper(overlayName);
strToUpper(functionName);
if (strlen((char *)overlayName) == 0)
return NULL;
if(overlayTable[idx].alreadyLoaded == 0)
return(NULL);
idx = findOverlayByName2(overlayName);
if(!overlayTable[idx].ovlData)
return(NULL);
if (idx == -4)
return (NULL);
numExport = overlayTable[idx].ovlData->numExport;
currentExportEntry = overlayTable[idx].ovlData->exportDataPtr;
entity1Name = overlayTable[idx].ovlData->exportNamesPtr;
if (overlayTable[idx].alreadyLoaded == 0)
return (NULL);
if(!entity1Name)
return(0);
if (!overlayTable[idx].ovlData)
return (NULL);
for(i=0;i<numExport;i++)
{
uint8 exportedName[256];
uint8* name = entity1Name + currentExportEntry->offsetToName;
numExport = overlayTable[idx].ovlData->numExport;
currentExportEntry = overlayTable[idx].ovlData->exportDataPtr;
entity1Name = overlayTable[idx].ovlData->exportNamesPtr;
strcpyuint8(exportedName,name);
strToUpper(exportedName);
if(!strcmpuint8(functionName,exportedName))
{
*pExportedFuncionIdx = idx;
if (!entity1Name)
return (0);
return(currentExportEntry);
}
for (i = 0; i < numExport; i++) {
uint8 exportedName[256];
uint8 *name = entity1Name + currentExportEntry->offsetToName;
currentExportEntry++;
}
strcpyuint8(exportedName, name);
strToUpper(exportedName);
return(NULL);
if (!strcmpuint8(functionName, exportedName)) {
*pExportedFuncionIdx = idx;
return (currentExportEntry);
}
currentExportEntry++;
}
return (NULL);
}
int updateScriptImport(int ovlIdx)
{
char buffer[256];
ovlDataStruct* ovlData;
int numData3;
int size5;
int numImport;
int param;
int var_32;
ovlData3Struct* pScript;
int updateScriptImport(int ovlIdx) {
char buffer[256];
ovlDataStruct *ovlData;
int numData3;
int size5;
int numImport;
int param;
int var_32;
ovlData3Struct *pScript;
// char* importDataPtr;
// char* namePtr;
// char* linkDataPtr;
if(!overlayTable[ovlIdx].ovlData)
return(-4);
ovlData = overlayTable[ovlIdx].ovlData;
if (!overlayTable[ovlIdx].ovlData)
return (-4);
numData3 = ovlData->numScripts1;
size5 = ovlData->numScripts2;
numImport = ovlData->numImport;
param = 0;
ovlData = overlayTable[ovlIdx].ovlData;
// do it for the 2 first string types
do
{
numData3 = ovlData->numScripts1;
size5 = ovlData->numScripts2;
numImport = ovlData->numImport;
param = 0;
int i = 0;
// do it for the 2 first string types
do {
if(param == 0)
{
var_32 = numData3;
}
else
{
var_32 = size5;
}
int i = 0;
if(var_32)
{
do
{
importScriptStruct* ptrImportData;
uint8* ptrImportName;
uint8* ptrData;
if (param == 0) {
var_32 = numData3;
} else {
var_32 = size5;
}
int var_22 = 0;
if (var_32) {
do {
importScriptStruct *ptrImportData;
uint8 *ptrImportName;
uint8 *ptrData;
if(param == 0)
{
pScript = getOvlData3Entry(ovlIdx, i);
}
else
{
pScript = scriptFunc1Sub2(ovlIdx, i);
}
int var_22 = 0;
ptrImportData = (importScriptStruct*) (pScript->dataPtr + pScript->offsetToImportData); // import data
ptrImportName = pScript->dataPtr + pScript->offsetToImportName; // import name
ptrData = pScript->dataPtr;
if (param == 0) {
pScript = getOvlData3Entry(ovlIdx, i);
} else {
pScript = scriptFunc1Sub2(ovlIdx, i);
}
var_22 = 0;
ptrImportData = (importScriptStruct *) (pScript->dataPtr + pScript->offsetToImportData); // import data
ptrImportName = pScript->dataPtr + pScript->offsetToImportName; // import name
ptrData = pScript->dataPtr;
if(pScript->numImport > 0)
{
int counter = pScript->numImport;
var_22 = 0;
do
{
int param2 = ptrImportData->type;
if (pScript->numImport > 0) {
int counter = pScript->numImport;
if(param2 != 70)
{
exportEntryStruct* ptrDest2;
int out1;
int out2;
do {
int param2 =
ptrImportData->type;
strcpyuint8(buffer,ptrImportName + ptrImportData->offsetToName);
ptrDest2 = parseExport(&out1,&out2,buffer);
if (param2 != 70) {
exportEntryStruct
* ptrDest2;
int out1;
int out2;
if(ptrDest2 && out2)
{
int temp = ptrImportData->offset;
if(out1) //is sub function... (ie 'invent.livre:s')
{
uint8* ptr = ptrData + temp;
strcpyuint8(buffer,
ptrImportName +
ptrImportData->
offsetToName);
ptrDest2 =
parseExport(&out1,
&out2, buffer);
*(ptr+1) = out2;
*(int16*)(ptr+2) = ptrDest2->idx;
if (ptrDest2 && out2) {
int temp =
ptrImportData->
offset;
if (out1) //is sub function... (ie 'invent.livre:s')
{
uint8 *ptr = ptrData + temp;
flipShort((int16*)(ptr+2));
}
else
{
if(param2 == 20 || param2 == 30 || param2 == 40 || param2 == 50 ) // this patch a double push
{
uint8* ptr = ptrData + temp;
*(ptr +
1)
=
out2;
*(int16
*)
(ptr
+
2)
=
ptrDest2->
idx;
*(ptr+1) = 0;
*(ptr+2) = out2; // update the overlay number
flipShort
(
(int16
*)
(ptr + 2));
} else {
if (param2 == 20 || param2 == 30 || param2 == 40 || param2 == 50) // this patch a double push
{
uint8
*
ptr
=
ptrData
+
temp;
*(int16*)(ptr+4) = ptrDest2->idx;
*(ptr + 1) = 0;
*(ptr + 2) = out2; // update the overlay number
flipShort((int16*)(ptr+4));
}
else
{
int var_4 = ptrDest2->var4;
*(int16 *) (ptr + 4) = ptrDest2->idx;
if(var_4&1)
{
param2 = 8;
}
else
{
param2 = 16;
}
flipShort
(
(int16
*)
(ptr + 4));
} else {
int var_4 = ptrDest2->var4;
if(var_4>=0 && var_4<=3)
{
param2 |= 5;
}
else
{
param2 |= 6;
}
if (var_4 & 1) {
param2
=
8;
} else {
param2
=
16;
}
*(ptrData + temp) = param2;
*(ptrData + temp + 1 ) = out2;
if (var_4 >= 0 && var_4 <= 3) {
param2
|=
5;
} else {
param2
|=
6;
}
*(int16*)(ptrData + temp + 2) = ptrDest2->idx;
*(ptrData + temp) = param2;
*(ptrData + temp + 1) = out2;
flipShort((int16*)(ptrData + temp + 2));
}
}
}
}
*(int16 *) (ptrData + temp + 2) = ptrDest2->idx;
ptrImportData++;
}while(--counter);
}
flipShort
(
(int16
*)
(ptrData
+
temp
+
2));
}
}
}
}
}while(++i<var_32);
}
ptrImportData++;
} while (--counter);
}
}while(++param<2);
} while (++i < var_32);
if(ovlData->importDataPtr && ovlData->importNamePtr && numImport)
{
int numImport2 = numImport;
int i;
}
for(i=0;i<numImport2;i++)
{
int out1;
int foundExportIdx;
exportEntryStruct* pFoundExport;
int linkType;
int linkEntryIdx;
} while (++param < 2);
strcpyuint8(buffer,ovlData->importNamePtr + ovlData->importDataPtr[i].nameOffset);
if (ovlData->importDataPtr && ovlData->importNamePtr && numImport) {
int numImport2 = numImport;
int i;
pFoundExport = parseExport(&out1,&foundExportIdx,buffer);
for (i = 0; i < numImport2; i++) {
int out1;
int foundExportIdx;
exportEntryStruct *pFoundExport;
int linkType;
int linkEntryIdx;
linkType = ovlData->importDataPtr[i].linkType;
linkEntryIdx = ovlData->importDataPtr[i].linkIdx;
strcpyuint8(buffer,
ovlData->importNamePtr +
ovlData->importDataPtr[i].nameOffset);
if(pFoundExport && foundExportIdx)
{
switch(linkType)
{
case 0: // var
{
ovlData->linkDataPtr[linkEntryIdx].varIdx = foundExportIdx;
ovlData->linkDataPtr[linkEntryIdx].varNameOffset = pFoundExport->offsetToName;
break;
}
case 1: // string
{
ovlData->linkDataPtr[linkEntryIdx].stringIdx = foundExportIdx;
ovlData->linkDataPtr[linkEntryIdx].stringNameOffset = pFoundExport->offsetToName;
break;
}
case 2: // proc
{
ovlData->linkDataPtr[linkEntryIdx].procIdx = foundExportIdx;
ovlData->linkDataPtr[linkEntryIdx].procNameOffset = pFoundExport->offsetToName;
break;
}
}
}
}
}
pFoundExport =
parseExport(&out1, &foundExportIdx, buffer);
return(0);
linkType = ovlData->importDataPtr[i].linkType;
linkEntryIdx = ovlData->importDataPtr[i].linkIdx;
if (pFoundExport && foundExportIdx) {
switch (linkType) {
case 0: // var
{
ovlData->
linkDataPtr[linkEntryIdx].
varIdx = foundExportIdx;
ovlData->
linkDataPtr[linkEntryIdx].
varNameOffset =
pFoundExport->offsetToName;
break;
}
case 1: // string
{
ovlData->
linkDataPtr[linkEntryIdx].
stringIdx = foundExportIdx;
ovlData->
linkDataPtr[linkEntryIdx].
stringNameOffset =
pFoundExport->offsetToName;
break;
}
case 2: // proc
{
ovlData->
linkDataPtr[linkEntryIdx].
procIdx = foundExportIdx;
ovlData->
linkDataPtr[linkEntryIdx].
procNameOffset =
pFoundExport->offsetToName;
break;
}
}
}
}
}
return (0);
}
// check that the newly loaded isn't used by the already loaded overlays
void updateAllScriptsImports(void)
{
int i;
void updateAllScriptsImports(void) {
int i;
for(i=0;i<90;i++)
{
if(overlayTable[i].ovlData && overlayTable[i].alreadyLoaded)
{
updateScriptImport(i);
}
}
for (i = 0; i < 90; i++) {
if (overlayTable[i].ovlData && overlayTable[i].alreadyLoaded) {
updateScriptImport(i);
}
}
}
} // End of namespace Cruise

7
engines/cruise/linker.h
View file

@ -22,13 +22,12 @@
*
*/
#ifndef _LINKER_H_
#define _LINKER_H_
#ifndef CRUISE_LINKER_H
#define CRUISE_LINKER_H
namespace Cruise {
void updateAllScriptsImports(void);
} // End of namespace Cruise
} // End of namespace Cruise
#endif

960
engines/cruise/mainDraw.cpp
View file

File diff suppressed because it is too large Load diff

16
engines/cruise/mainDraw.h
View file

@ -22,8 +22,8 @@
*
*/
#ifndef _MAINDRAW_H_
#define _MAINDRAW_H_
#ifndef CRUISE_MAINDRAW_H
#define CRUISE_MAINDRAW_H
namespace Cruise {
@ -37,12 +37,14 @@ int upscaleValue(int value, int scale);
void pixel(int x, int y, char color);
void mainDraw(int16 param);
void flipScreen(void);
void buildPolyModel(int X, int Y, int scale, char* ptr2, char* destBuffer, char* dataPtr);
void getPolyData(int fileIndex, int X, int Y, int *newScale, int *newY, int *newX, char **newDataPtr, int scale, char* dataPtr);
void mainDrawSub4(int objX1, int var_6, cellStruct* currentObjPtr, char* data1, int objY2, int objX2, char* output, char* data2);
char* drawPolyMode2(char* si, int cx);
void buildPolyModel(int X, int Y, int scale, char *ptr2, char *destBuffer,
char *dataPtr);
void getPolyData(int fileIndex, int X, int Y, int *newScale, int *newY,
int *newX, char **newDataPtr, int scale, char *dataPtr);
void mainDrawSub4(int objX1, int var_6, cellStruct * currentObjPtr,
char *data1, int objY2, int objX2, char *output, char *data2);
char *drawPolyMode2(char *si, int cx);
} // End of namespace Cruise
#endif

397
engines/cruise/menu.cpp
View file

@ -26,205 +26,199 @@
namespace Cruise {
menuStruct* menuTable[8];
menuStruct *menuTable[8];
menuStruct* createMenu(int X, int Y, const char* menuName)
{
menuStruct* entry;
menuStruct *createMenu(int X, int Y, const char *menuName) {
menuStruct *entry;
entry = (menuStruct*)malloc(sizeof(menuStruct));
ASSERT(entry);
entry = (menuStruct *) malloc(sizeof(menuStruct));
ASSERT(entry);
entry->x = X - 80;
entry->y = Y;
entry->stringPtr = menuName;
entry->numElements = 0;
entry->ptrNextElement = NULL;
entry->gfx = renderText(160, (uint8*)menuName);
entry->x = X - 80;
entry->y = Y;
entry->stringPtr = menuName;
entry->numElements = 0;
entry->ptrNextElement = NULL;
entry->gfx = renderText(160, (uint8 *) menuName);
return entry;
return entry;
}
// TODO: rewrite to remove the goto
void addSelectableMenuEntry(int param0, int param1, menuStruct* pMenu, int param2, int color, const char* menuText)
{
menuElementStruct* di;
menuElementStruct* var_6;
menuElementStruct* pNewElement;
menuElementSubStruct* pSubStruct;
menuElementSubStruct* pSubStructCurrent;
void addSelectableMenuEntry(int param0, int param1, menuStruct *pMenu,
int param2, int color, const char *menuText) {
menuElementStruct *di;
menuElementStruct *var_6;
menuElementStruct *pNewElement;
menuElementSubStruct *pSubStruct;
menuElementSubStruct *pSubStructCurrent;
if(pMenu->numElements <= 48)
{
var_6 = pMenu->ptrNextElement;
if (pMenu->numElements <= 48) {
var_6 = pMenu->ptrNextElement;
if(var_6)
{
do
{
di = var_6;
if(param2)
{
if(!strcmp(var_6->string, menuText))
{
pNewElement = var_6;
pSubStruct = (menuElementSubStruct*)allocAndZero(sizeof(menuElementSubStruct));
ASSERT(pSubStruct);
if (var_6) {
do {
di = var_6;
if (param2) {
if (!strcmp(var_6->string, menuText)) {
pNewElement = var_6;
pSubStruct =
(menuElementSubStruct *)
allocAndZero(sizeof
(menuElementSubStruct));
ASSERT(pSubStruct);
pSubStruct->pNext = NULL;
pSubStruct->var2 = param0;
pSubStruct->var4 = param1;
pSubStruct->pNext = NULL;
pSubStruct->var2 = param0;
pSubStruct->var4 = param1;
pSubStructCurrent = pNewElement->ptrSub;
pSubStructCurrent =
pNewElement->ptrSub;
if(!pSubStructCurrent)
{
pNewElement->ptrSub = pSubStruct;
return;
}
if (!pSubStructCurrent) {
pNewElement->ptrSub =
pSubStruct;
return;
}
if(pSubStructCurrent->pNext)
{
do
{
pSubStructCurrent = pSubStructCurrent->pNext;
}while(pSubStructCurrent->pNext);
}
if (pSubStructCurrent->pNext) {
do {
pSubStructCurrent
=
pSubStructCurrent->
pNext;
} while
(pSubStructCurrent->
pNext);
}
pSubStructCurrent->pNext = pSubStruct;
return;
}
}
var_6 = var_6->next;
}
while(var_6);
pSubStructCurrent->pNext =
pSubStruct;
return;
}
}
var_6 = var_6->next;
}
while (var_6);
var_6 = di;
}
var_6 = di;
}
pNewElement = (menuElementStruct*)allocAndZero(sizeof(menuElementStruct));
ASSERT(pNewElement);
pSubStruct = (menuElementSubStruct*)allocAndZero(sizeof(menuElementSubStruct));
ASSERT(pSubStruct);
pNewElement =
(menuElementStruct *)
allocAndZero(sizeof(menuElementStruct));
ASSERT(pNewElement);
pSubStruct =
(menuElementSubStruct *)
allocAndZero(sizeof(menuElementSubStruct));
ASSERT(pSubStruct);
pNewElement->string = menuText;
pNewElement->next = NULL;
pNewElement->varC = 0;
pNewElement->color = color;
pNewElement->gfx = renderText(160,(uint8*)menuText);
pNewElement->string = menuText;
pNewElement->next = NULL;
pNewElement->varC = 0;
pNewElement->color = color;
pNewElement->gfx = renderText(160, (uint8 *) menuText);
if(var_6 == NULL)
{
pMenu->ptrNextElement = pNewElement;
}
else
{
var_6->next = pNewElement;
}
if (var_6 == NULL) {
pMenu->ptrNextElement = pNewElement;
} else {
var_6->next = pNewElement;
}
pNewElement->ptrSub = pSubStruct;
pNewElement->ptrSub = pSubStruct;
pSubStruct->pNext = NULL;
pSubStruct->var2 = param0;
pSubStruct->var4 = param1;
pSubStruct->pNext = NULL;
pSubStruct->var2 = param0;
pSubStruct->var4 = param1;
pMenu->numElements++;
}
pMenu->numElements++;
}
}
void updateMenuMouse(int mouseX, int mouseY, menuStruct* pMenu)
{
if(pMenu)
{
if(pMenu->gfx)
{
int height = pMenu->gfx->height; // rustine
int var_2 = 0;
menuElementStruct* pCurrentEntry = pMenu->ptrNextElement;
void updateMenuMouse(int mouseX, int mouseY, menuStruct *pMenu) {
if (pMenu) {
if (pMenu->gfx) {
int height = pMenu->gfx->height; // rustine
int var_2 = 0;
menuElementStruct *pCurrentEntry =
pMenu->ptrNextElement;
while(pCurrentEntry)
{
pCurrentEntry->varC = 0;
while (pCurrentEntry) {
pCurrentEntry->varC = 0;
if(var_2 == 0)
{
if((mouseX > pCurrentEntry->x) && ((pCurrentEntry->x + 160) >= mouseX))
{
if((mouseY > pCurrentEntry->y) && ((pCurrentEntry->y + height) >= mouseY))
{
var_2 = 1;
pCurrentEntry->varC = 1;
}
}
}
if (var_2 == 0) {
if ((mouseX > pCurrentEntry->x)
&& ((pCurrentEntry->x + 160) >=
mouseX)) {
if ((mouseY > pCurrentEntry->y)
&& ((pCurrentEntry->y +
height) >=
mouseY)) {
var_2 = 1;
pCurrentEntry->varC =
1;
}
}
}
pCurrentEntry = pCurrentEntry->next;
}
}
}
pCurrentEntry = pCurrentEntry->next;
}
}
}
}
int processMenu(menuStruct* pMenu)
{
int16 mouseX;
int16 mouseY;
int16 mouseButton;
int di;
int si;
currentActiveMenu = 0;
int processMenu(menuStruct *pMenu) {
int16 mouseX;
int16 mouseY;
int16 mouseButton;
int di;
int si;
currentActiveMenu = 0;
mainDraw(1);
flipScreen();
mainDraw(1);
flipScreen();
di = 0;
si = 0;
di = 0;
si = 0;
do
{
getMouseStatus(&main10, &mouseX, &mouseButton, &mouseY);
do {
getMouseStatus(&main10, &mouseX, &mouseButton, &mouseY);
updateMenuMouse(mouseX, mouseY, pMenu);
updateMenuMouse(mouseX, mouseY, pMenu);
if(mouseButton)
{
if(di)
{
si = 1;
}
}
else
{
di = 1;
}
if (mouseButton) {
if (di) {
si = 1;
}
} else {
di = 1;
}
mainDraw(1);
flipScreen();
mainDraw(1);
flipScreen();
// readKeyboard();
}while(!si);
} while (!si);
currentActiveMenu = -1;
currentActiveMenu = -1;
mainDraw(1);
flipScreen();
mainDraw(1);
flipScreen();
return 0;
return 0;
}
int playerMenu(int menuX, int menuY)
{
int retourMenu;
//int restartGame = 0;
int playerMenu(int menuX, int menuY) {
int retourMenu;
//int restartGame = 0;
if(entrerMenuJoueur && affichePasMenuJoueur)
{
if(var0)
{
systemStrings.param = 0;
var24 = 0;
var23 = 0;
freeStuff2();
}
if (entrerMenuJoueur && affichePasMenuJoueur) {
if (var0) {
systemStrings.param = 0;
var24 = 0;
var23 = 0;
freeStuff2();
}
/*
if(currentMenu)
{
@ -251,71 +245,68 @@ int playerMenu(int menuX, int menuY)
/* mouseVar2 = 0;
mouseVar1 = 0; */
freeDisk();
freeDisk();
menuTable[0] = createMenu(menuX, menuY, "Menu Joueur");
ASSERT(menuTable[0]);
menuTable[0] = createMenu(menuX, menuY, "Menu Joueur");
ASSERT(menuTable[0]);
addSelectableMenuEntry(0, 3, menuTable[0], 1, -1, "Lecteur de Sauvegarde");
if(userEnabled)
{
addSelectableMenuEntry(0, 4, menuTable[0], 1, -1, "Sauvegarde");
}
addSelectableMenuEntry(0, 5, menuTable[0], 1, -1, "Chargement");
addSelectableMenuEntry(0, 6, menuTable[0], 1, -1, "Recommencer le jeu");
addSelectableMenuEntry(0, 7, menuTable[0], 1, -1, "Chargement");
addSelectableMenuEntry(0, 3, menuTable[0], 1, -1,
"Lecteur de Sauvegarde");
if (userEnabled) {
addSelectableMenuEntry(0, 4, menuTable[0], 1, -1,
"Sauvegarde");
}
addSelectableMenuEntry(0, 5, menuTable[0], 1, -1,
"Chargement");
addSelectableMenuEntry(0, 6, menuTable[0], 1, -1,
"Recommencer le jeu");
addSelectableMenuEntry(0, 7, menuTable[0], 1, -1,
"Chargement");
retourMenu = processMenu(menuTable[0]);
}
retourMenu = processMenu(menuTable[0]);
}
return 0;
return 0;
}
void freeGfx(gfxEntryStruct* pGfx)
{
if(pGfx->imagePtr)
{
free(pGfx->imagePtr);
}
void freeGfx(gfxEntryStruct *pGfx) {
if (pGfx->imagePtr) {
free(pGfx->imagePtr);
}
free(pGfx);
free(pGfx);
}
void freeMenu(menuStruct* pMenu)
{
menuElementStruct* pElement = pMenu->ptrNextElement;
void freeMenu(menuStruct *pMenu) {
menuElementStruct *pElement = pMenu->ptrNextElement;
while(pElement)
{
menuElementStruct* next;
menuElementSubStruct* pSub = pElement->ptrSub;
while (pElement) {
menuElementStruct *next;
menuElementSubStruct *pSub = pElement->ptrSub;
next = pElement->next;
next = pElement->next;
while(pSub)
{
menuElementSubStruct* nextSub;
while (pSub) {
menuElementSubStruct *nextSub;
nextSub = pSub->pNext;
nextSub = pSub->pNext;
free(pSub);
free(pSub);
pSub=nextSub;
}
pSub = nextSub;
}
if(pElement->gfx)
{
freeGfx(pElement->gfx);
}
if (pElement->gfx) {
freeGfx(pElement->gfx);
}
free(pElement);
free(pElement);
pElement = next;
}
pElement = next;
}
freeGfx(pMenu->gfx);
free(pMenu);
freeGfx(pMenu->gfx);
free(pMenu);
}
} // End of namespace Cruise

34
engines/cruise/menu.h
View file

@ -22,28 +22,32 @@
*
*/
#ifndef CRUISE_MENU_H
#define CRUISE_MENU_H
namespace Cruise {
struct menuStruct
{
const char* stringPtr;
gfxEntryStruct* gfx;
int x;
int y;
int numElements;
menuElementStruct* ptrNextElement;
struct menuStruct {
const char *stringPtr;
gfxEntryStruct *gfx;
int x;
int y;
int numElements;
menuElementStruct *ptrNextElement;
};
typedef struct menuStruct menuStruct;
extern menuStruct* menuTable[8];
extern menuStruct *menuTable[8];
menuStruct* createMenu(int X, int Y, const char* menuName);
void addSelectableMenuEntry(int var0, int var1, menuStruct* pMenu, int var2, int color, const char* menuText);
void updateMenuMouse(int mouseX, int mouseY, menuStruct* pMenu);
int processMenu(menuStruct* pMenu);
void freeMenu(menuStruct* pMenu);
menuStruct *createMenu(int X, int Y, const char *menuName);
void addSelectableMenuEntry(int var0, int var1, menuStruct * pMenu, int var2,
int color, const char *menuText);
void updateMenuMouse(int mouseX, int mouseY, menuStruct * pMenu);
int processMenu(menuStruct * pMenu);
void freeMenu(menuStruct * pMenu);
int playerMenu(int menuX, int menuY);
} // End of namespace Cruise
#endif

14
engines/cruise/mouse.cpp
View file

@ -28,16 +28,16 @@ namespace Cruise {
int16 main10;
void getMouseStatus(int16* pMouseVar, int16* pMouseX, int16* pMouseButton, int16* pMouseY)
{
// mouseStatusStruct localStatus;
void getMouseStatus(int16 *pMouseVar, int16 *pMouseX, int16 *pMouseButton,
int16 *pMouseY) {
// mouseStatusStruct localStatus;
// OSystem_GetMouseStatus(&localStatus);
// OSystem_GetMouseStatus(&localStatus);
*pMouseX = 0;
*pMouseY = 0;
*pMouseX = 0;
*pMouseY = 0;
*pMouseButton = 0;
*pMouseButton = 0;
/*
if(localStatus.left)
*pMouseButton |= 1;

8
engines/cruise/mouse.h
View file

@ -22,16 +22,16 @@
*
*/
#ifndef _MOUSE_H_
#define _MOUSE_H_
#ifndef CRUISE_MOUSE_H
#define CRUISE_MOUSE_H
namespace Cruise {
extern int16 main10;
void getMouseStatus(int16* pMouseVar, int16* pMouseX, int16* pMouseButton, int16* pMouseY);
void getMouseStatus(int16 * pMouseVar, int16 * pMouseX, int16 * pMouseButton,
int16 * pMouseY);
} // End of namespace Cruise
#endif

476
engines/cruise/object.cpp
View file

@ -36,141 +36,133 @@ namespace Cruise {
*/
objDataStruct* getObjectDataFromOverlay(int ovlIdx,int objIdx)
{
objDataStruct* var_6;
objDataStruct *getObjectDataFromOverlay(int ovlIdx, int objIdx) {
objDataStruct *var_6;
if(ovlIdx<1 || objIdx <0)
return NULL;
if (ovlIdx < 1 || objIdx < 0)
return NULL;
if(!overlayTable[ovlIdx].ovlData)
return NULL;
if (!overlayTable[ovlIdx].ovlData)
return NULL;
if(overlayTable[ovlIdx].ovlData->numObjData <= objIdx)
return NULL;
if (overlayTable[ovlIdx].ovlData->numObjData <= objIdx)
return NULL;
var_6 = overlayTable[ovlIdx].ovlData->objDataTable;
var_6 = overlayTable[ovlIdx].ovlData->objDataTable;
if(!var_6)
return NULL;
if (!var_6)
return NULL;
return (&var_6[objIdx]);
return (&var_6[objIdx]);
}
int16 getMultipleObjectParam(int16 overlayIdx,int16 objectIdx,objectParamsQuery* returnParam)
{
int16 size;
int16 var_A;
int16 var_14;
objectParams* ptr2;
objDataStruct* ptr;
ovlDataStruct* ovlData;
int16 getMultipleObjectParam(int16 overlayIdx, int16 objectIdx,
objectParamsQuery *returnParam) {
int16 size;
int16 var_A;
int16 var_14;
objectParams *ptr2;
objDataStruct *ptr;
ovlDataStruct *ovlData;
// int16 type;
ptr = getObjectDataFromOverlay(overlayIdx,objectIdx);
ptr = getObjectDataFromOverlay(overlayIdx, objectIdx);
if(!ptr)
return -11;
if (!ptr)
return -11;
ovlData = overlayTable[overlayIdx].ovlData;
ovlData = overlayTable[overlayIdx].ovlData;
switch(ptr->var1)
{
switch (ptr->var1) {
case 0:
{
ptr2 = &ovlData->objData2SourceTable[ptr->var5];
var_14 = globalVars[*(int16*)(&overlayTable[overlayIdx].field_14 + ptr->var6)];
var_14 = globalVars[*(int16 *) (&overlayTable[overlayIdx].field_14 + ptr->var6)];
var_A = ptr2->var5;
break;
}
case 1:
{
case 1:
{
ptr2 = &ovlData->objData2WorkTable[ptr->var4];
var_A = var_14 = ptr2->var5;
size = var_A + ptr->var5;
var_A = var_14 = ptr2->var5;
size = var_A + ptr->var5;
if(ptr->var5 + var_14<=ovlData->size8)
{
if (ptr->var5 + var_14 <= ovlData->size8) {
var_A = ovlData->objData2SourceTable[ptr->var5 + var_14].var5;
}
break;
}
default:
{
printf("unsupported case %d in getMultipleObjectParam\n", ptr->var1);
exit(1);
}
}
}
break;
}
default:
{
printf("unsupported case %d in getMultipleObjectParam\n", ptr->var1);
exit(1);
}
}
returnParam->X = ptr2->X;
returnParam->Y = ptr2->Y;
returnParam->baseFileIdx = ptr2->baseFileIdx;
returnParam->fileIdx = ptr2->var3;
returnParam->scale = ptr2->scale;
returnParam->var5 = var_14;
returnParam->var6 = var_A;
returnParam->var7 = ptr->var3;
return 0;
returnParam->Y = ptr2->Y;
returnParam->baseFileIdx = ptr2->baseFileIdx;
returnParam->fileIdx = ptr2->var3;
returnParam->scale = ptr2->scale;
returnParam->var5 = var_14;
returnParam->var6 = var_A;
returnParam->var7 = ptr->var3;
return 0;
}
void setObjectPosition(int16 param1,int16 objIdx,int16 param3,int16 param4)
{
objDataStruct* ptr;
objectParams* ptr2;
void setObjectPosition(int16 param1, int16 objIdx, int16 param3, int16 param4) {
objDataStruct *ptr;
objectParams *ptr2;
ptr = getObjectDataFromOverlay(param1, objIdx);
if(!ptr)
{
if (!ptr) {
return;
ASSERT(0);
}
//overlayTable[param1].ovlData
switch(ptr->var1)
{
switch (ptr->var1) {
case 1:
{
ptr2 = &overlayTable[param1].ovlData->objData2WorkTable[ptr->var4];
ptr2 = &overlayTable[param1].ovlData->objData2WorkTable[ptr->var4];
switch(param3)
{
case 0: // x
{
ptr2->X = param4;
break;
}
case 1: // y
{
ptr2->Y = param4;
break;
}
case 2: // base file
{
ptr2->baseFileIdx = param4;
break;
}
case 3:
{
ptr2->var3 = param4;
break;
}
case 4: // scale
switch (param3) {
case 0: // x
{
ptr2->X = param4;
break;
}
case 1: // y
{
ptr2->Y = param4;
break;
}
case 2: // base file
{
ptr2->baseFileIdx = param4;
break;
}
case 3:
{
ptr2->var3 = param4;
break;
}
case 4: // scale
{
ptr2->scale = param4;
break;
}
case 5: // box colision
{
ptr2->var5 = param4;
break;
}
case 5: // box colision
{
ptr2->var5 = param4;
break;
}
default:
{
ASSERT(0);
@ -186,212 +178,195 @@ void setObjectPosition(int16 param1,int16 objIdx,int16 param3,int16 param4)
}
}
void Op_InitializeStateSub1(int16 param1, int16 param2, cellStruct* objPtr)
{
int16 var;
cellStruct* var8_;
cellStruct* var40;
cellStruct* var3E;
cellStruct* currentObjPtrPrevious;
cellStruct* currentObjPtr2;
cellStruct* match;
void Op_InitializeStateSub1(int16 param1, int16 param2, cellStruct *objPtr) {
int16 var;
cellStruct *var8_;
cellStruct *var40;
cellStruct *var3E;
cellStruct *currentObjPtrPrevious;
cellStruct *currentObjPtr2;
cellStruct *match;
getSingleObjectParam(param1,param2,2,&var);
getSingleObjectParam(param1, param2, 2, &var);
currentObjPtrPrevious = objPtr;
currentObjPtr2 = objPtr->next;
currentObjPtrPrevious = objPtr;
currentObjPtr2 = objPtr->next;
match = NULL;
var40 = NULL;
var3E = NULL;
var8_ = objPtr;
match = NULL;
var40 = NULL;
var3E = NULL;
var8_ = objPtr;
while(currentObjPtr2)
{
if((currentObjPtr2->overlay == param1) && (currentObjPtr2->idx == param2)) // found
{
currentObjPtrPrevious->next = currentObjPtr2->next;
while (currentObjPtr2) {
if ((currentObjPtr2->overlay == param1) && (currentObjPtr2->idx == param2)) {// found
currentObjPtrPrevious->next = currentObjPtr2->next;
if(currentObjPtr2->next)
{
currentObjPtr2->next->prev = currentObjPtr2->prev;
}
else
{
objPtr->prev = currentObjPtr2->prev;
}
if (currentObjPtr2->next) {
currentObjPtr2->next->prev =
currentObjPtr2->prev;
} else {
objPtr->prev = currentObjPtr2->prev;
}
if(var40)
{
var40->prev = currentObjPtr2;
}
else
{
var3E = currentObjPtr2;
}
if (var40) {
var40->prev = currentObjPtr2;
} else {
var3E = currentObjPtr2;
}
currentObjPtr2->prev = NULL;
currentObjPtr2->prev = NULL;
currentObjPtr2->next = var40;
currentObjPtr2->next = var40;
var40 = currentObjPtr2;
var40 = currentObjPtr2;
if(match == NULL)
{
match = currentObjPtr2;
}
}
else
{
if(currentObjPtr2->type == 5)
{
var2 = 32000;
}
else
{
int16 varC;
if (match == NULL) {
match = currentObjPtr2;
}
} else {
if (currentObjPtr2->type == 5) {
var2 = 32000;
} else {
int16 varC;
getSingleObjectParam(currentObjPtr2->overlay,currentObjPtr2->idx,2,&varC);
getSingleObjectParam(currentObjPtr2->overlay,
currentObjPtr2->idx, 2, &varC);
var2 = varC;
}
var2 = varC;
}
if(var>var2)
{
var8_ = currentObjPtr2;
}
if (var > var2) {
var8_ = currentObjPtr2;
}
currentObjPtrPrevious=currentObjPtrPrevious->next;
}
currentObjPtrPrevious = currentObjPtrPrevious->next;
}
currentObjPtr2 = currentObjPtr2->next;
}
currentObjPtr2 = currentObjPtr2->next;
}
if(match)
{
cellStruct* temp;
if (match) {
cellStruct *temp;
temp = var8_->next;
temp = var8_->next;
var8_->next = var40;
match->next = temp;
var8_->next = var40;
match->next = temp;
if(objPtr!=var8_)
{
var40->prev = var8_;
}
if (objPtr != var8_) {
var40->prev = var8_;
}
if(!temp)
{
temp = match;
}
if (!temp) {
temp = match;
}
temp->prev = match;
}
temp->prev = match;
}
}
int16 Op_InitializeStateSub(int ovlIdx,int objIdx,int param2)
{
objDataStruct* ptr;
int16 Op_InitializeStateSub(int ovlIdx, int objIdx, int param2) {
objDataStruct *ptr;
// uint16 param;
ovlDataStruct* ovlData;
ptr = getObjectDataFromOverlay(ovlIdx,objIdx);
ovlDataStruct *ovlData;
if(!ptr)
return -11;
ptr = getObjectDataFromOverlay(ovlIdx, objIdx);
ovlData = overlayTable[ovlIdx].ovlData;
if (!ptr)
return -11;
switch(ptr->var1)
{
case 0:
{
globalVars[overlayTable[ovlIdx].field_14 + ptr->var6] = param2;
Op_InitializeStateSub1(ovlIdx,param2,&cellHead);
break;
}
case 1:
{
objectParams* destEntry;
objectParams* sourceEntry;
ovlData = overlayTable[ovlIdx].ovlData;
if(ptr->var5+param2 > ovlData->size8)
{
return 0;
}
switch (ptr->var1) {
case 0:
{
globalVars[overlayTable[ovlIdx].field_14 + ptr->var6] =
param2;
Op_InitializeStateSub1(ovlIdx, param2, &cellHead);
break;
}
case 1:
{
objectParams *destEntry;
objectParams *sourceEntry;
if (ptr->var5 + param2 > ovlData->size8) {
return 0;
}
destEntry = &ovlData->objData2WorkTable[ptr->var4];
sourceEntry = &ovlData->objData2SourceTable[ptr->var5 + param2];
sourceEntry =
&ovlData->objData2SourceTable[ptr->var5 + param2];
memcpy(destEntry,sourceEntry,sizeof(objectParams));
memcpy(destEntry, sourceEntry, sizeof(objectParams));
destEntry->var5 = param2;
destEntry->var5 = param2;
Op_InitializeStateSub1(ovlIdx,param2,&cellHead);
break;
}
default:
{
printf("Unsupported param = %d in Op_InitializeStateSub\n",ptr->var1);
// exit(1);
}
}
Op_InitializeStateSub1(ovlIdx, param2, &cellHead);
break;
}
default:
{
printf
("Unsupported param = %d in Op_InitializeStateSub\n",
ptr->var1);
// exit(1);
}
}
return 0;
return 0;
}
int16 getSingleObjectParam(int16 overlayIdx,int16 param2,int16 param3,int16* returnParam)
{
int16 getSingleObjectParam(int16 overlayIdx, int16 param2, int16 param3,
int16 *returnParam) {
int var_A = 0;
//char* ptr3 = NULL;
objDataStruct* ptr;
ovlDataStruct* ovlData;
objectParams* ptr2;
objDataStruct *ptr;
ovlDataStruct *ovlData;
objectParams *ptr2;
ptr = getObjectDataFromOverlay(overlayIdx,param2);
ptr = getObjectDataFromOverlay(overlayIdx, param2);
if(!ptr)
return -11;
if (!ptr)
return -11;
ovlData = overlayTable[overlayIdx].ovlData;
ovlData = overlayTable[overlayIdx].ovlData;
switch(ptr->var1)
{
switch (ptr->var1) {
case 0:
case 3:
case 3:
{
var_A = globalVars[ptr->var6];
ptr2 = &ovlData->objData2SourceTable[ptr->var5];
break;
break;
}
case 1:
{
case 1:
{
ptr2 = &ovlData->objData2WorkTable[ptr->var4];
var_A = ptr2->var5;
break;
}
default:
{
printf("Unsupported case %d in getSingleObjectParam\n",ptr->var1);
exit(1);
}
}
var_A = ptr2->var5;
break;
}
default:
{
printf("Unsupported case %d in getSingleObjectParam\n",
ptr->var1);
exit(1);
}
}
switch(param3)
{
case 0:
{
*returnParam = ptr2->X;
break;
}
case 1:
{
*returnParam = ptr2->Y;
break;
}
switch (param3) {
case 0:
{
*returnParam = ptr2->X;
break;
}
case 1:
{
*returnParam = ptr2->Y;
break;
}
case 2:
{
*returnParam = ptr2->baseFileIdx;
@ -399,7 +374,7 @@ int16 getSingleObjectParam(int16 overlayIdx,int16 param2,int16 param3,int16* ret
}
case 3:
{
*returnParam = ptr2->var3;
*returnParam = ptr2->var3;
break;
}
case 4:
@ -409,18 +384,19 @@ int16 getSingleObjectParam(int16 overlayIdx,int16 param2,int16 param3,int16* ret
}
case 5:
{
*returnParam = var_A;
*returnParam = var_A;
break;
}
default:
{
printf("Unsupported case %d in getSingleObjectParam case 1\n",param3);
printf
("Unsupported case %d in getSingleObjectParam case 1\n",
param3);
exit(1);
}
}
return 0;
return 0;
}
} // End of namespace Cruise

32
engines/cruise/object.h
View file

@ -22,41 +22,41 @@
*
*/
#ifndef _OBJECT_H_
#define _OBJECT_H_
#ifndef CRUISE_OBJECT_H
#define CRUISE_OBJECT_H
namespace Cruise {
struct gfxEntryStruct
{
uint8* imagePtr;
int imageSize;
int fontIndex;
int height;
int width; // for font: max right border; for sprite: just width
struct gfxEntryStruct {
uint8 *imagePtr;
int imageSize;
int fontIndex;
int height;
int width; // for font: max right border; for sprite: just width
};
typedef struct gfxEntryStruct gfxEntryStruct;
#define OBJ_SPRITE 4
struct objectParamsQuery
{
struct objectParamsQuery {
int16 X;
int16 Y;
int16 baseFileIdx;
int16 fileIdx;
int16 scale;
int16 var5;
int16 var6;
int16 var7;
int16 var6;
int16 var7;
};
typedef struct objectParamsQuery objectParamsQuery;
objDataStruct* getObjectDataFromOverlay(int ovlIdx,int objIdx);
int16 getSingleObjectParam(int16 overlayIdx,int16 param2,int16 param3,int16* returnParam);
int16 getMultipleObjectParam(int16 overlayIdx,int16 objectIdx,objectParamsQuery* returnParam);
objDataStruct *getObjectDataFromOverlay(int ovlIdx, int objIdx);
int16 getSingleObjectParam(int16 overlayIdx, int16 param2, int16 param3,
int16 * returnParam);
int16 getMultipleObjectParam(int16 overlayIdx, int16 objectIdx,
objectParamsQuery * returnParam);
} // End of namespace Cruise

1104
engines/cruise/overlay.cpp
View file

File diff suppressed because it is too large Load diff

149
engines/cruise/overlay.h
View file

@ -22,39 +22,36 @@
*
*/
#ifndef _OVERLAY_H_
#define _OVERLAY_H_
#ifndef CRUISE_OVERLAY_H
#define CRUISE_OVERLAY_H
namespace Cruise {
struct importScriptStruct
{
uint16 var0;
uint16 var1;
uint16 type;
uint16 offset;
uint16 offsetToName;
struct importScriptStruct {
uint16 var0;
uint16 var1;
uint16 type;
uint16 offset;
uint16 offsetToName;
};
typedef struct importScriptStruct importScriptStruct;
struct exportEntryStruct
{
uint16 var0;
uint16 var2;
uint16 var4;
uint16 idx;
uint16 offsetToName;
struct exportEntryStruct {
uint16 var0;
uint16 var2;
uint16 var4;
uint16 idx;
uint16 offsetToName;
};
typedef struct exportEntryStruct exportEntryStruct;
struct ovlData3Struct
{
uint8* dataPtr; //0
short int sizeOfData; //4
short int offsetToSubData3; //6
short int offsetToImportData; //8
struct ovlData3Struct {
uint8 *dataPtr; //0
short int sizeOfData; //4
short int offsetToSubData3; //6
short int offsetToImportData; //8
short int offsetToSubData2;
short int offsetToImportName;
short int offsetToSubData5;
@ -68,52 +65,48 @@ struct ovlData3Struct
typedef struct ovlData3Struct ovlData3Struct;
struct stringEntryStruct
{
char* string;
struct stringEntryStruct {
char *string;
short int length;
short int idx;
};
typedef struct stringEntryStruct stringEntryStruct;
struct linkDataStruct
{
uint16 field_0;
uint16 field_2;
uint16 field_4;
uint16 varIdx;
uint16 varNameOffset;
uint16 stringIdx;
uint16 stringNameOffset;
uint16 procIdx;
uint16 procNameOffset;
struct linkDataStruct {
uint16 field_0;
uint16 field_2;
uint16 field_4;
uint16 varIdx;
uint16 varNameOffset;
uint16 stringIdx;
uint16 stringNameOffset;
uint16 procIdx;
uint16 procNameOffset;
int16 field_12;
int16 field_14;
int16 field_16;
int16 field_18;
int16 field_1A;
int16 field_1C;
int16 field_1E;
int16 field_20;
int16 field_12;
int16 field_14;
int16 field_16;
int16 field_18;
int16 field_1A;
int16 field_1C;
int16 field_1E;
int16 field_20;
};
typedef struct linkDataStruct linkDataStruct;
struct importDataStruct
{
uint16 var0; // 0
uint16 var1; // 2
uint16 linkType; // 4
uint16 linkIdx; // 6
uint16 nameOffset;
struct importDataStruct {
uint16 var0; // 0
uint16 var1; // 2
uint16 linkType; // 4
uint16 linkIdx; // 6
uint16 nameOffset;
};
typedef struct importDataStruct importDataStruct;
struct objDataStruct
{
struct objDataStruct {
int16 var0;
int16 var1;
int16 var2;
@ -125,8 +118,7 @@ struct objDataStruct
typedef struct objDataStruct objDataStruct;
struct objectParams
{
struct objectParams {
int16 X;
int16 Y;
int16 baseFileIdx;
@ -137,23 +129,22 @@ struct objectParams
typedef struct objectParams objectParams;
struct ovlDataStruct
{
ovlData3Struct* data3Table;
uint8* ptr1;
objDataStruct* objDataTable;
objectParams* objData2SourceTable;
objectParams* objData2WorkTable;
stringEntryStruct* stringTable;
exportEntryStruct* exportDataPtr;
importDataStruct* importDataPtr;
linkDataStruct* linkDataPtr;
uint8* specialString1;
uint8* specialString2;
uint8* importNamePtr;
uint8* exportNamesPtr;
uint8* data4Ptr;
uint8* ptr8;
struct ovlDataStruct {
ovlData3Struct *data3Table;
uint8 *ptr1;
objDataStruct *objDataTable;
objectParams *objData2SourceTable;
objectParams *objData2WorkTable;
stringEntryStruct *stringTable;
exportEntryStruct *exportDataPtr;
importDataStruct *importDataPtr;
linkDataStruct *linkDataPtr;
uint8 *specialString1;
uint8 *specialString2;
uint8 *importNamePtr;
uint8 *exportNamesPtr;
uint8 *data4Ptr;
uint8 *ptr8;
unsigned short int numScripts1;
unsigned short int numScripts2;
unsigned short int numExport;
@ -174,10 +165,9 @@ struct ovlDataStruct
typedef struct ovlDataStruct ovlDataStruct;
struct overlayStruct
{
struct overlayStruct {
char overlayName[14];
ovlDataStruct* ovlData;
ovlDataStruct *ovlData;
short int alreadyLoaded;
char field_14;
char field_15;
@ -206,11 +196,10 @@ extern overlayStruct overlayTable[90];
extern int numOfLoadedOverlay;
void initOverlayTable(void);
int loadOverlay(uint8* scriptName);
int32 findOverlayByName2(uint8* name);
int findOverlayByName(const char* overlayName);
int releaseOverlay(const char* name);
int loadOverlay(uint8 * scriptName);
int32 findOverlayByName2(uint8 * name);
int findOverlayByName(const char *overlayName);
int releaseOverlay(const char *name);
} // End of namespace Cruise

309
engines/cruise/perso.cpp
View file

@ -26,235 +26,224 @@
namespace Cruise {
persoStruct* persoTable[10];
persoStruct *persoTable[10];
int16 computedVar14;
void freePerso(int persoIdx)
{
if(persoTable[persoIdx])
{
free(persoTable[persoIdx]);
persoTable[persoIdx] = NULL;
}
void freePerso(int persoIdx) {
if (persoTable[persoIdx]) {
free(persoTable[persoIdx]);
persoTable[persoIdx] = NULL;
}
}
void freeAllPerso(void)
{
int i;
void freeAllPerso(void) {
int i;
for(i=0;i<10;i++)
{
freePerso(i);
}
for (i = 0; i < 10; i++) {
freePerso(i);
}
if(polyStruct)
{
free(polyStruct);
}
if (polyStruct) {
free(polyStruct);
}
ctpVar17 = NULL;
polyStruct = NULL;
ctpVar17 = NULL;
polyStruct = NULL;
strcpy((char*)currentCtpName, "");
strcpy((char *)currentCtpName, "");
}
int pathVar0;
unsigned int inc_droite2,inc_jo;
unsigned int inc_droite2, inc_jo;
int direction( int x1, int y1, int x2, int y2, int inc_jo1, int inc_jo2 )
{
int h, v, h1, v1;
int direction(int x1, int y1, int x2, int y2, int inc_jo1, int inc_jo2) {
int h, v, h1, v1;
h1 = x1-x2; h = abs(h1);
v1 = y1-y2; v = abs(v1);
if ( v > h )
{
if ( h > 30 ) inc_jo = inc_jo1-inc_jo2;
else inc_jo = inc_jo2;
h1 = x1 - x2;
h = abs(h1);
v1 = y1 - y2;
v = abs(v1);
if ( v1 < 0 ) return ( 2 );
else return ( 0 );
}
else
{
if (v > h) {
if (h > 30)
inc_jo = inc_jo1 - inc_jo2;
else
inc_jo = inc_jo2;
if (v1 < 0)
return (2);
else
return (0);
} else {
inc_jo = inc_jo1;
if ( h1 < 0 ) return ( 1 );
else return ( 3 );
if (h1 < 0)
return (1);
else
return (3);
}
}
void cor_droite(int x1,int y1,int x2,int y2, int16 cor_joueur[400][2])
{
int16* di = (int16*)cor_joueur;
int dx;
int dy;
void cor_droite(int x1, int y1, int x2, int y2, int16 cor_joueur[400][2]) {
int16 *di = (int16 *) cor_joueur;
int dx;
int dy;
int mD0;
int mD1;
int mD0;
int mD1;
int mA0;
int mA1;
int mA0;
int mA1;
int bp;
int cx;
int si;
int bp;
int cx;
int si;
int ax;
int bx;
int ax;
int bx;
di[0] = x1;
di[1] = y1;
di+=2;
di[0] = x1;
di[1] = y1;
di += 2;
dx = x2-x1;
dy = y2-y1;
dx = x2 - x1;
dy = y2 - y1;
mD0 = mD1 = 1;
mD0 = mD1 = 1;
if(dx<0)
{
dx = -dx;
mD0 = -1;
}
if (dx < 0) {
dx = -dx;
mD0 = -1;
}
if(dy<0)
{
dy = -dy;
mD1 = -1;
}
if (dy < 0) {
dy = -dy;
mD1 = -1;
}
if(dx<dy)
{
mA0 = 0;
bp = dx;
cx = dy;
if (dx < dy) {
mA0 = 0;
bp = dx;
cx = dy;
mA1 = mD1;
}
else
{
mA1 = 0;
bp = dy;
cx = dx;
mA1 = mD1;
} else {
mA1 = 0;
bp = dy;
cx = dx;
mA0 = mD0;
}
mA0 = mD0;
}
bp=bp*2;
dx=bp-cx;
si=dx-cx;
bp = bp * 2;
dx = bp - cx;
si = dx - cx;
ax = x1;
bx = y1;
ax = x1;
bx = y1;
while(--cx)
{
if(dx>0)
{
ax+=mD0;
bx+=mD1;
dx+=si;
}
else
{
ax+=mA0;
bx+=mA1;
dx+=bp;
}
while (--cx) {
if (dx > 0) {
ax += mD0;
bx += mD1;
dx += si;
} else {
ax += mA0;
bx += mA1;
dx += bp;
}
di[0] = ax;
di[1] = bx;
di+=2;
}
di[0] = ax;
di[1] = bx;
di += 2;
}
flag_obstacle = 0;
inc_droite2 = (di-(int16*)cor_joueur)/2;
flag_obstacle = 0;
inc_droite2 = (di - (int16 *) cor_joueur) / 2;
}
void processActorWalk(int16 resx_y[4], int16* inc_droite, int16* inc_droite0, int16* inc_chemin, int16 cor_joueur[400][2], int16 solution0[NUM_NODES+3][2], int16* inc_jo1, int16* inc_jo2, int16* dir_perso, int16* inc_jo0, int16 num)
{
int x1, x2, y1, y2;
int i, u;
void processActorWalk(int16 resx_y[4], int16 *inc_droite, int16 *inc_droite0,
int16 *inc_chemin, int16 cor_joueur[400][2],
int16 solution0[NUM_NODES + 3][2], int16 *inc_jo1, int16 *inc_jo2,
int16 *dir_perso, int16 *inc_jo0, int16 num) {
int x1, x2, y1, y2;
int i, u;
u = 0;
inc_jo = *inc_jo0;
i = *inc_chemin;
if ( ! *inc_droite )
{
if (!*inc_droite) {
x1 = solution0[i][0];
y1 = solution0[i][1];
i++;
if ( solution0[i][0] != -1 )
{
do
{
if (solution0[i][0]!=-2)
{
if (solution0[i][0] != -1) {
do {
if (solution0[i][0] != -2) {
x2 = solution0[i][0];
y2 = solution0[i][1];
if ( (x1==x2) && (y1==y2))
{
resx_y[0]=-1;
resx_y[1]=-1;
if ((x1 == x2) && (y1 == y2)) {
resx_y[0] = -1;
resx_y[1] = -1;
freePerso(num);
return;
}
cor_droite(x1,y1,x2,y2,cor_joueur);
*inc_droite0=inc_droite2;
*dir_perso=resx_y[2]=direction(x1,y1,x2,y2,*inc_jo1,*inc_jo2);
*inc_jo0=inc_jo;
u=1;
}
else i++;
cor_droite(x1, y1, x2, y2, cor_joueur);
*inc_droite0 = inc_droite2;
*dir_perso = resx_y[2] =
direction(x1, y1, x2, y2, *inc_jo1,
*inc_jo2);
*inc_jo0 = inc_jo;
u = 1;
} else
i++;
} while ( solution0[i][0] !=-1 && !u );
} while (solution0[i][0] != -1 && !u);
}
if ( !u )
{
resx_y[0]=-1;
resx_y[1]=-1;
if (!u) {
resx_y[0] = -1;
resx_y[1] = -1;
freePerso(num);
return;
}
*inc_chemin=i;
}
*inc_chemin = i;
}
resx_y[0]=cor_joueur[*inc_droite][0];
resx_y[1]=cor_joueur[*inc_droite][1];
resx_y[2]=*dir_perso;
resx_y[3]=computeZoom(resx_y[1]);
resx_y[0] = cor_joueur[*inc_droite][0];
resx_y[1] = cor_joueur[*inc_droite][1];
resx_y[2] = *dir_perso;
resx_y[3] = computeZoom(resx_y[1]);
getPixel(resx_y[0],resx_y[1]);
resx_y[4]=computedVar14;
getPixel(resx_y[0], resx_y[1]);
resx_y[4] = computedVar14;
u=subOp23(resx_y[3],inc_jo);
if (!u) u=1;
*inc_droite+=u;
u = subOp23(resx_y[3], inc_jo);
if (!u)
u = 1;
*inc_droite += u;
if ((*inc_droite)>=(*inc_droite0))
{
*inc_droite=0;
resx_y[0]=solution0[*inc_chemin][0];
resx_y[1]=solution0[*inc_chemin][1];
if ((*inc_droite) >= (*inc_droite0)) {
*inc_droite = 0;
resx_y[0] = solution0[*inc_chemin][0];
resx_y[1] = solution0[*inc_chemin][1];
}
}
void affiche_chemin(int16 persoIdx, int16* returnVar)
{
persoStruct* pPerso = persoTable[persoIdx];
void affiche_chemin(int16 persoIdx, int16 *returnVar) {
persoStruct *pPerso = persoTable[persoIdx];
ASSERT(pPerso);
ASSERT(pPerso);
processActorWalk(returnVar, &pPerso->inc_droite, &pPerso->inc_droite0, &pPerso->inc_chemin, pPerso->coordinates, pPerso->solution, &pPerso->inc_jo1, &pPerso->inc_jo2, &pPerso->dir_perso, &pPerso->inc_jo0, persoIdx);
processActorWalk(returnVar, &pPerso->inc_droite, &pPerso->inc_droite0,
&pPerso->inc_chemin, pPerso->coordinates, pPerso->solution,
&pPerso->inc_jo1, &pPerso->inc_jo2, &pPerso->dir_perso,
&pPerso->inc_jo0, persoIdx);
}
} // End of namespace Cruise

29
engines/cruise/perso.h
View file

@ -22,34 +22,33 @@
*
*/
#ifndef _PERSO_H_
#define _PERSO_H_
#ifndef CRUISE_PERSO_H
#define CRUISE_PERSO_H
namespace Cruise {
#define NUM_NODES 20
struct persoStruct
{
int16 inc_droite; // 2
int16 inc_droite0; // 2
int16 inc_chemin; // 2
int16 coordinates[400][2]; // 1600
int16 solution[NUM_NODES+3][2]; //((20+3)*2*2)
int16 inc_jo1; // 2
int16 inc_jo2; // 2
int16 dir_perso; // 2
int16 inc_jo0; // 2
struct persoStruct {
int16 inc_droite; // 2
int16 inc_droite0; // 2
int16 inc_chemin; // 2
int16 coordinates[400][2]; // 1600
int16 solution[NUM_NODES + 3][2]; //((20+3)*2*2)
int16 inc_jo1; // 2
int16 inc_jo2; // 2
int16 dir_perso; // 2
int16 inc_jo0; // 2
};
typedef struct persoStruct persoStruct;
extern persoStruct* persoTable[10];
extern persoStruct *persoTable[10];
extern int16 computedVar14;
void freePerso(int persoIdx);
void freeAllPerso(void);
void affiche_chemin(int16 persoIdx, int16* returnVar);
void affiche_chemin(int16 persoIdx, int16 * returnVar);
} // End of namespace Cruise

63
engines/cruise/polys.cpp
View file

@ -23,6 +23,7 @@
*/
#include "cruise/cruise_main.h"
#include "common/util.h"
namespace Cruise {
@ -34,10 +35,6 @@ typedef char ColorP;
#define SCREENHEIGHT 200
#define MAXPTS 10
#define putdot(x,y) {if ((y >= 0) && (y < SCREENHEIGHT)) dots[y][counters[y]++] = x;}
#define SWAP(x,y) {int temp = x; x = y; y = temp;}
int MAX(int x, int y) {if(x>y){return x;}else{return y;}}
int MIN(int x, int y) {if(x<y){return x;}else{return y;}}
void hline(int x1, int x2, int y, char c) {
for (; x1 <= x2; x1++) {
@ -75,6 +72,7 @@ void bsubline_1(int x1, int y1, int x2, int y2, char c) {
}
}
void bsubline_2(int x1, int y1, int x2, int y2, char c) {
int x, y, ddx, ddy, e;
@ -88,7 +86,6 @@ void bsubline_2(int x1, int y1, int x2, int y2, char c) {
SWAP(y1, y2);
}
for (y = y1, x = x1; y <= y2; y++) {
pixel(x, y, c);
@ -108,7 +105,7 @@ void bsubline_3(int x1, int y1, int x2, int y2, char c) {
ddx = abs(x1 - x2) << 1;
ddy = abs(y2 - y1);
e = ddy - ddx;
e = ddy - ddx;
ddy <<= 1;
if (y1 > y2) {
@ -116,7 +113,6 @@ void bsubline_3(int x1, int y1, int x2, int y2, char c) {
SWAP(y1, y2);
}
for (y = y1, x = x1; y <= y2; y++) {
pixel(x, y, c);
@ -136,7 +132,7 @@ void bsubline_4(int x1, int y1, int x2, int y2, char c) {
ddy = abs(y2 - y1) << 1;
ddx = abs(x1 - x2);
e = ddx - ddy;
e = ddx - ddy;
ddx <<= 1;
if (x1 > x2) {
@ -185,35 +181,32 @@ void line(int x1, int y1, int x2, int y2, char c) {
bsubline_4(x1, y1, x2, y2, c);
} else {
bsubline_3(x1, y1, x2, y2, c);
}
}
}
void fillpoly(short int* datas, int lineCount, ColorP color)
{
void fillpoly(short int *datas, int lineCount, ColorP color) {
static int dots[SCREENHEIGHT][MAXPTS];
static int counters[SCREENHEIGHT];
short int x1, y1, x2, y2;
int i, j, k, dir = -2;
double step, curx;
switch (lineCount)
{
case 0: // do nothing
return;
case 1: // draw pixel
pixel(datas[0], datas[1], color);
return;
case 2: // draw line
line(datas[0], datas[1], datas[2], datas[3], color);
return;
default: // go on and draw polygon
break;
switch (lineCount) {
case 0: // do nothing
return;
case 1: // draw pixel
pixel(datas[0], datas[1], color);
return;
case 2: // draw line
line(datas[0], datas[1], datas[2], datas[3], color);
return;
default: // go on and draw polygon
break;
}
// Reinit array counters
for (i = 0; i < SCREENHEIGHT; i++)
{
for (i = 0; i < SCREENHEIGHT; i++) {
counters[i] = 0;
}
// Drawing lines
@ -230,18 +223,14 @@ void fillpoly(short int* datas, int lineCount, ColorP color)
// line(x1, y1, x2, y2, color);
// continue;
if (y1 == y2)
{
if (y1 == y2) {
// printf("Horizontal line. x1: %i, y1: %i, x2: %i, y2: %i\n", x1, y1, x2, y2);
if (dir)
{
if (dir) {
putdot(x1, y1);
dir = 0;
}
}
else
{
step = (double) (x2 - x1) / (y2 - y1);
} else {
step = (double)(x2 - x1) / (y2 - y1);
// printf("x1: %i, y1 = %i, x2 = %i, y2 = %i, step: %f\n", x1, y1, x2, y2, step);
@ -276,11 +265,11 @@ void fillpoly(short int* datas, int lineCount, ColorP color)
x2 = datas[0];
y2 = datas[1];
if (((y1 < y2) && (dir == -1)) || ((y1 > y2) && (dir == 1)) || ((y1 == y2) && (dir == 0))) {
if (((y1 < y2) && (dir == -1)) || ((y1 > y2) && (dir == 1))
|| ((y1 == y2) && (dir == 0))) {
// printf("Adding final extra (%i, %i)\n", x1, y1);
putdot(x1, y1);
}
// NOTE: all counters should be even now. If not, this is a bad (color) thing :-P
// Sorting datas
@ -289,8 +278,7 @@ void fillpoly(short int* datas, int lineCount, ColorP color)
// Very bad sorting... but arrays are very small (0, 2 or 4), so it's no quite use...
for (j = 0; j < (counters[i] - 1); j++) {
for (k = 0; k < (counters[i] - 1); k++) {
if (dots[i][k] > dots[i][k + 1])
{
if (dots[i][k] > dots[i][k + 1]) {
int temp;
temp = dots[i][k];
dots[i][k] = dots[i][k + 1];
@ -320,4 +308,3 @@ void fillpoly(short int* datas, int lineCount, ColorP color)
}
} // End of namespace Cruise

7
engines/cruise/polys.h
View file

@ -22,11 +22,16 @@
*
*/
#ifndef CRUISE_POLYS_H
#define CRUISE_POLYS_H
namespace Cruise {
typedef char ColorP;
void fillpoly(short int * datas, int n, ColorP c);
void fillpoly(short int *datas, int n, ColorP c);
void line(int x1, int y1, int x2, int y2, ColorP color);
} // End of namespace Cruise
#endif

636
engines/cruise/saveload.cpp
View file

@ -26,418 +26,388 @@
namespace Cruise {
void loadSavegameDataSub1(FILE* fileHandle)
{
int i;
void loadSavegameDataSub1(FILE *fileHandle) {
int i;
for(i=1;i<numOfLoadedOverlay;i++)
{
filesData[i].field_4 = NULL;
filesData[i].field_0 = NULL;
filesData2[i].field_0 = 0;
for (i = 1; i < numOfLoadedOverlay; i++) {
filesData[i].field_4 = NULL;
filesData[i].field_0 = NULL;
filesData2[i].field_0 = 0;
if(overlayTable[i].alreadyLoaded)
{
fread(&filesData2[i].field_0,2,1,fileHandle);
if (overlayTable[i].alreadyLoaded) {
fread(&filesData2[i].field_0, 2, 1, fileHandle);
if(filesData2[i].field_0)
{
filesData[i].field_0 = (uint8*)mallocAndZero(filesData2[i].field_0);
if(filesData[i].field_0)
{
fread(filesData[i].field_0,filesData2[i].field_0,1,fileHandle);
}
}
if (filesData2[i].field_0) {
filesData[i].field_0 =
(uint8 *) mallocAndZero(filesData2[i].
field_0);
if (filesData[i].field_0) {
fread(filesData[i].field_0,
filesData2[i].field_0, 1,
fileHandle);
}
}
fread(&filesData2[i].field_2,2,1,fileHandle);
fread(&filesData2[i].field_2, 2, 1, fileHandle);
if(filesData2[i].field_2)
{
filesData[i].field_4 = (uint8*)mallocAndZero(filesData2[i].field_2*12);
if(filesData[i].field_4)
{
fread(filesData[i].field_4,filesData2[i].field_2*12,1,fileHandle);
}
}
}
}
if (filesData2[i].field_2) {
filesData[i].field_4 =
(uint8 *) mallocAndZero(filesData2[i].
field_2 * 12);
if (filesData[i].field_4) {
fread(filesData[i].field_4,
filesData2[i].field_2 * 12, 1,
fileHandle);
}
}
}
}
}
void loadScriptsFromSave(FILE* fileHandle,scriptInstanceStruct* entry)
{
short int numScripts;
int i;
void loadScriptsFromSave(FILE *fileHandle, scriptInstanceStruct *entry) {
short int numScripts;
int i;
fread(&numScripts,2,1,fileHandle);
fread(&numScripts, 2, 1, fileHandle);
for(i=0;i<numScripts;i++)
{
scriptInstanceStruct* ptr = (scriptInstanceStruct*)mallocAndZero(sizeof(scriptInstanceStruct));
for (i = 0; i < numScripts; i++) {
scriptInstanceStruct *ptr =
(scriptInstanceStruct *)
mallocAndZero(sizeof(scriptInstanceStruct));
fread(ptr,0x1C,1,fileHandle); // use 0x1C as our scriptInstanceStruct is bigger than in original because of cross platform problems
fread(ptr, 0x1C, 1, fileHandle); // use 0x1C as our scriptInstanceStruct is bigger than in original because of cross platform problems
fread(&ptr->varA,2,1,fileHandle);
fread(&ptr->varA, 2, 1, fileHandle);
if(ptr->varA)
{
ptr->var6 = (uint8*)mallocAndZero(ptr->varA);
if (ptr->varA) {
ptr->var6 = (uint8 *) mallocAndZero(ptr->varA);
fread(ptr->var6,ptr->varA,1,fileHandle);
}
fread(ptr->var6, ptr->varA, 1, fileHandle);
}
/////////
ptr->bitMask = *((int16 *) ptr + 1);
/////////
/////////
ptr->bitMask = *((int16*)ptr+1);
/////////
ptr->nextScriptPtr = 0;
ptr->nextScriptPtr = 0;
entry->nextScriptPtr = ptr;
entry = ptr;
}
entry->nextScriptPtr = ptr;
entry = ptr;
}
}
void loadSavegameActor(FILE* fileHandle)
{
short int numEntry;
actorStruct* ptr;
int i;
void loadSavegameActor(FILE *fileHandle) {
short int numEntry;
actorStruct *ptr;
int i;
fread(&numEntry,2,1,fileHandle);
fread(&numEntry, 2, 1, fileHandle);
ptr = &actorHead;
ptr = &actorHead;
for(i=0;i<numEntry;i++)
{
actorStruct* current = (actorStruct*)mallocAndZero(sizeof(actorStruct));
fseek(fileHandle, 4, SEEK_CUR);
fread(current,0x26,1,fileHandle);
for (i = 0; i < numEntry; i++) {
actorStruct *current =
(actorStruct *) mallocAndZero(sizeof(actorStruct));
fseek(fileHandle, 4, SEEK_CUR);
fread(current, 0x26, 1, fileHandle);
current->next = NULL;
ptr->next = current;
current->prev = actorHead.prev;
actorHead.prev = current;
ptr = current->next;
}
current->next = NULL;
ptr->next = current;
current->prev = actorHead.prev;
actorHead.prev = current;
ptr = current->next;
}
}
void loadSavegameDataSub5(FILE* fileHandle)
{
if(var1)
{
fread(&saveVar1,1,1,fileHandle);
void loadSavegameDataSub5(FILE *fileHandle) {
if (var1) {
fread(&saveVar1, 1, 1, fileHandle);
if(saveVar1)
{
fread(saveVar2,saveVar1,1,fileHandle);
}
}
else
{
fread(&saveVar1,1,1,fileHandle);
}
if (saveVar1) {
fread(saveVar2, saveVar1, 1, fileHandle);
}
} else {
fread(&saveVar1, 1, 1, fileHandle);
}
}
void loadSavegameDataSub6(FILE* fileHandle)
{
int32 var;
void loadSavegameDataSub6(FILE *fileHandle) {
int32 var;
fread(&var,4,1,fileHandle);
flipLong(&var);
fread(&var, 4, 1, fileHandle);
flipLong(&var);
if(var)
{
int i;
fread(&numberOfWalkboxes, 2, 1, fileHandle);
if (var) {
int i;
if(numberOfWalkboxes)
{
fread(walkboxType, numberOfWalkboxes * 2, 1, fileHandle);
fread(walkboxType, numberOfWalkboxes * 2, 1, fileHandle);
}
fread(&numberOfWalkboxes, 2, 1, fileHandle);
for(i=0;i<10;i++)
{
fread(&persoTable[i],4,1,fileHandle);
if (numberOfWalkboxes) {
fread(walkboxType, numberOfWalkboxes * 2, 1,
fileHandle);
fread(walkboxType, numberOfWalkboxes * 2, 1,
fileHandle);
}
if(persoTable[i])
{
assert(sizeof(persoStruct) == 0x6AA);
persoTable[i] = (persoStruct*)mallocAndZero(sizeof(persoStruct));
fread(persoTable[i],0x6AA,1,fileHandle);
}
}
}
for (i = 0; i < 10; i++) {
fread(&persoTable[i], 4, 1, fileHandle);
if (persoTable[i]) {
assert(sizeof(persoStruct) == 0x6AA);
persoTable[i] =
(persoStruct *)
mallocAndZero(sizeof(persoStruct));
fread(persoTable[i], 0x6AA, 1, fileHandle);
}
}
}
}
int loadSavegameData(int saveGameIdx) {
char buffer[256];
FILE *fileHandle;
char saveIdentBuffer[6];
int j;
int initVar1Save;
cellStruct *currentcellHead;
int loadSavegameData(int saveGameIdx)
{
char buffer[256];
FILE* fileHandle;
char saveIdentBuffer[6];
int j;
int initVar1Save;
cellStruct* currentcellHead;
sprintf(buffer, "CR.%d", saveGameIdx);
sprintf(buffer,"CR.%d",saveGameIdx);
fileHandle = fopen(buffer, "rb");
fileHandle = fopen(buffer,"rb");
if (!fileHandle) {
printInfoBlackBox("Sauvegarde non trouvée...");
waitForPlayerInput();
return (-1);
}
if(!fileHandle)
{
printInfoBlackBox("Sauvegarde non trouvée...");
waitForPlayerInput();
return(-1);
}
printInfoBlackBox("Chargement en cours...");
printInfoBlackBox("Chargement en cours...");
fread(saveIdentBuffer, 6, 1, fileHandle);
fread(saveIdentBuffer,6,1,fileHandle);
if (strcmp(saveIdentBuffer, "SAVPC")) {
fclose(fileHandle);
return (-1);
}
//initVars();
if(strcmp(saveIdentBuffer,"SAVPC"))
{
fclose(fileHandle);
return(-1);
}
fread(&var1, 2, 1, fileHandle);
fread(&var2, 2, 1, fileHandle);
fread(&var3, 2, 1, fileHandle);
fread(&var4, 2, 1, fileHandle);
fread(&userEnabled, 2, 1, fileHandle);
fread(&var6, 2, 1, fileHandle);
fread(&var7, 2, 1, fileHandle);
fread(&var8, 2, 1, fileHandle);
fread(&userDelay, 2, 1, fileHandle);
fread(&sysKey, 2, 1, fileHandle);
fread(&var11, 2, 1, fileHandle);
fread(&var12, 2, 1, fileHandle);
fread(&var13, 2, 1, fileHandle);
fread(&var14, 2, 1, fileHandle);
fread(&affichePasMenuJoueur, 2, 1, fileHandle);
fread(&var20, 2, 1, fileHandle);
fread(&var22, 2, 1, fileHandle);
fread(&var23, 2, 1, fileHandle);
fread(&var24, 2, 1, fileHandle);
fread(&automaticMode, 2, 1, fileHandle);
//initVars();
// video param (not loaded in EGA mode)
fread(&var1,2,1,fileHandle);
fread(&var2,2,1,fileHandle);
fread(&var3,2,1,fileHandle);
fread(&var4,2,1,fileHandle);
fread(&userEnabled,2,1,fileHandle);
fread(&var6,2,1,fileHandle);
fread(&var7,2,1,fileHandle);
fread(&var8,2,1,fileHandle);
fread(&userDelay,2,1,fileHandle);
fread(&sysKey,2,1,fileHandle);
fread(&var11,2,1,fileHandle);
fread(&var12,2,1,fileHandle);
fread(&var13,2,1,fileHandle);
fread(&var14,2,1,fileHandle);
fread(&affichePasMenuJoueur,2,1,fileHandle);
fread(&var20,2,1,fileHandle);
fread(&var22,2,1,fileHandle);
fread(&var23,2,1,fileHandle);
fread(&var24,2,1,fileHandle);
fread(&automaticMode,2,1,fileHandle);
fread(&video4, 2, 1, fileHandle);
fread(&video2, 2, 1, fileHandle);
fread(&video3, 2, 1, fileHandle);
fread(&colorOfSelectedSaveDrive, 2, 1, fileHandle);
// video param (not loaded in EGA mode)
//
fread(&video4,2,1,fileHandle);
fread(&video2,2,1,fileHandle);
fread(&video3,2,1,fileHandle);
fread(&colorOfSelectedSaveDrive,2,1,fileHandle);
fread(&var30, 2, 1, fileHandle);
fread(&var31, 2, 1, fileHandle);
fread(&var34, 2, 1, fileHandle);
fread(&var35, 2, 1, fileHandle);
int16 bTemp;
fread(&bTemp, 2, 1, fileHandle);
animationStart = bTemp;
fread(&currentActiveBackgroundPlane, 2, 1, fileHandle);
fread(&initVar3, 2, 1, fileHandle);
fread(&initVar2, 2, 1, fileHandle);
fread(&var22, 2, 1, fileHandle);
fread(&main5, 2, 1, fileHandle);
fread(&numOfLoadedOverlay, 2, 1, fileHandle);
fread(&setup1, 2, 1, fileHandle);
fread(&fontFileIndex, 2, 1, fileHandle);
fread(&currentActiveMenu, 2, 1, fileHandle);
fread(&main7, 2, 1, fileHandle); // ok
fread(&main17, 2, 1, fileHandle);
fread(&main14, 2, 1, fileHandle);
fread(&main8, 2, 1, fileHandle);
fread(&var39, 2, 1, fileHandle);
fread(&var42, 2, 1, fileHandle);
fread(&var45, 2, 1, fileHandle);
fread(&var46, 2, 1, fileHandle);
fread(&var47, 2, 1, fileHandle);
fread(&var48, 2, 1, fileHandle);
fread(&flagCt, 2, 1, fileHandle);
fread(&var41, 2, 1, fileHandle);
fread(&entrerMenuJoueur, 2, 1, fileHandle);
//
fread(var50, 64, 1, fileHandle);
fread(var50, 64, 1, fileHandle); // Hu ? why 2 times ?
fread(&systemStrings, sizeof(systemStrings), 1, fileHandle); // ok
fread(currentCtpName, 40, 1, fileHandle);
fread(backgroundTable, 120, 1, fileHandle);
fread(palette, 256, 2, fileHandle); // ok
fread(initVar5, 24, 1, fileHandle);
fread(globalVars, setup1 * 2, 1, fileHandle);
fread(filesDatabase, 9766, 1, fileHandle);
fread(overlayTable, 40 * numOfLoadedOverlay, 1, fileHandle); // ok
fread(mediumVar, 0x880, 1, fileHandle);
fread(&var30,2,1,fileHandle);
fread(&var31,2,1,fileHandle);
fread(&var34,2,1,fileHandle);
fread(&var35,2,1,fileHandle);
int16 bTemp;
fread(&bTemp,2,1,fileHandle);
animationStart = bTemp;
fread(&currentActiveBackgroundPlane,2,1,fileHandle);
fread(&initVar3,2,1,fileHandle);
fread(&initVar2,2,1,fileHandle);
fread(&var22,2,1,fileHandle);
fread(&main5,2,1,fileHandle);
fread(&numOfLoadedOverlay,2,1,fileHandle);
fread(&setup1,2,1,fileHandle);
fread(&fontFileIndex,2,1,fileHandle);
fread(&currentActiveMenu,2,1,fileHandle);
fread(&main7,2,1,fileHandle); // ok
fread(&main17,2,1,fileHandle);
fread(&main14,2,1,fileHandle);
fread(&main8,2,1,fileHandle);
fread(&var39,2,1,fileHandle);
fread(&var42,2,1,fileHandle);
fread(&var45,2,1,fileHandle);
fread(&var46,2,1,fileHandle);
fread(&var47,2,1,fileHandle);
fread(&var48,2,1,fileHandle);
fread(&flagCt,2,1,fileHandle);
fread(&var41,2,1,fileHandle);
fread(&entrerMenuJoueur,2,1,fileHandle);
loadSavegameDataSub1(fileHandle);
loadScriptsFromSave(fileHandle, &scriptHandle2);
loadScriptsFromSave(fileHandle, &scriptHandle1);
fread(var50,64,1,fileHandle);
fread(var50,64,1,fileHandle); // Hu ? why 2 times ?
fread(&systemStrings,sizeof(systemStrings),1,fileHandle); // ok
fread(currentCtpName,40,1,fileHandle);
fread(backgroundTable,120,1,fileHandle);
fread(palette,256,2,fileHandle); // ok
fread(initVar5,24,1,fileHandle);
fread(globalVars,setup1*2,1,fileHandle);
fread(filesDatabase,9766,1,fileHandle);
fread(overlayTable,40*numOfLoadedOverlay,1,fileHandle); // ok
fread(mediumVar,0x880,1,fileHandle);
loadSavegameDataSub2(fileHandle);
loadBackgroundIncrustFromSave(fileHandle);
loadSavegameActor(fileHandle);
loadSavegameDataSub5(fileHandle);
loadSavegameDataSub6(fileHandle);
loadSavegameDataSub1(fileHandle);
loadScriptsFromSave(fileHandle,&scriptHandle2);
loadScriptsFromSave(fileHandle,&scriptHandle1);
fclose(fileHandle); // finished with loading !!!!! Yatta !
loadSavegameDataSub2(fileHandle);
loadBackgroundIncrustFromSave(fileHandle);
loadSavegameActor(fileHandle);
loadSavegameDataSub5(fileHandle);
loadSavegameDataSub6(fileHandle);
for (j = 0; j < 64; j++) {
mediumVar[j].ptr = NULL;
}
fclose(fileHandle); // finished with loading !!!!! Yatta !
for (j = 1; j < numOfLoadedOverlay; j++) {
if (overlayTable[j].alreadyLoaded) {
overlayTable[j].alreadyLoaded = 0;
loadOverlay((uint8 *) overlayTable[j].overlayName);
for(j=0;j<64;j++)
{
mediumVar[j].ptr=NULL;
}
if (overlayTable[j].alreadyLoaded) {
ovlDataStruct *ovlData =
overlayTable[j].ovlData;
for(j=1;j<numOfLoadedOverlay;j++)
{
if(overlayTable[j].alreadyLoaded)
{
overlayTable[j].alreadyLoaded = 0;
loadOverlay((uint8*)overlayTable[j].overlayName);
if (filesData[j].field_0) {
if (ovlData->data4Ptr) {
free(ovlData->data4Ptr);
}
if(overlayTable[j].alreadyLoaded)
{
ovlDataStruct* ovlData = overlayTable[j].ovlData;
ovlData->data4Ptr =
(uint8 *) filesData[j].field_0;
ovlData->sizeOfData4 =
filesData2[j].field_0;
}
if(filesData[j].field_0)
{
if(ovlData->data4Ptr)
{
free(ovlData->data4Ptr);
}
if (filesData[j].field_4) {
if (ovlData->objData2WorkTable) {
free(ovlData->
objData2WorkTable);
}
ovlData->data4Ptr = (uint8*)filesData[j].field_0;
ovlData->sizeOfData4 = filesData2[j].field_0;
}
ovlData->objData2WorkTable = (objectParams *) filesData[j].field_4; // TODO: fix !
ovlData->size9 = filesData2[j].field_2;
}
if(filesData[j].field_4)
{
if(ovlData->objData2WorkTable)
{
free(ovlData->objData2WorkTable);
}
}
}
}
ovlData->objData2WorkTable = (objectParams*)filesData[j].field_4; // TODO: fix !
ovlData->size9 = filesData2[j].field_2;
}
updateAllScriptsImports();
}
}
}
saveVar6[0] = 0;
updateAllScriptsImports();
initVar1Save = initVar1;
saveVar6[0] = 0;
for (j = 0; j < 257; j++) {
if (filesDatabase[j].subData.ptr) {
int i;
int k;
initVar1Save = initVar1;
for (i = j + 1; i < 257; i++) {
if (filesDatabase[i].subData.ptr) {
if (strcmpuint8(filesDatabase[j].
subData.name,
filesDatabase[i].subData.
name)) {
break;
}
} else {
break;
}
}
for(j=0;j<257;j++)
{
if(filesDatabase[j].subData.ptr)
{
int i;
int k;
for (k = j; k < i; k++) {
if (filesDatabase[k].subData.ptr2)
initVar1 = 0;
for(i=j+1;i<257;i++)
{
if(filesDatabase[i].subData.ptr)
{
if(strcmpuint8(filesDatabase[j].subData.name,filesDatabase[i].subData.name))
{
break;
}
}
else
{
break;
}
}
filesDatabase[k].subData.ptr = NULL;
filesDatabase[k].subData.ptr2 = NULL;
}
for(k=j;k<i;k++)
{
if(filesDatabase[k].subData.ptr2)
initVar1 = 0;
if (i < 2) {
printf("Unsupported mono file load!\n");
exit(1);
//loadFileMode1(filesDatabase[j].subData.name,filesDatabase[j].subData.var4);
} else {
loadFileMode2((uint8 *) filesDatabase[j].
subData.name,
filesDatabase[j].subData.index, j, i - j);
j = i - 1;
}
filesDatabase[k].subData.ptr = NULL;
filesDatabase[k].subData.ptr2 = NULL;
}
initVar1 = initVar1Save;
}
}
if(i<2)
{
printf("Unsupported mono file load!\n");
exit(1);
//loadFileMode1(filesDatabase[j].subData.name,filesDatabase[j].subData.var4);
}
else
{
loadFileMode2((uint8*)filesDatabase[j].subData.name,filesDatabase[j].subData.index, j, i-j);
j = i-1;
}
saveVar6[0] = 0;
initVar1 = initVar1Save;
}
}
currentcellHead = cellHead.next;
saveVar6[0] = 0;
while (currentcellHead) {
if (currentcellHead->type == 5) {
uint8 *ptr =
mainProc14(currentcellHead->overlay,
currentcellHead->idx);
currentcellHead = cellHead.next;
ASSERT(0);
while(currentcellHead)
{
if(currentcellHead->type == 5)
{
uint8* ptr = mainProc14(currentcellHead->overlay,currentcellHead->idx);
if (ptr) {
ASSERT(0);
//*(int16*)(currentcellHead->datas+0x2E) = getSprite(ptr,*(int16*)(currentcellHead->datas+0xE));
} else {
//*(int16*)(currentcellHead->datas+0x2E) = 0;
}
}
ASSERT(0);
currentcellHead = currentcellHead->next;
}
if(ptr)
{
ASSERT(0);
//*(int16*)(currentcellHead->datas+0x2E) = getSprite(ptr,*(int16*)(currentcellHead->datas+0xE));
}
else
{
//*(int16*)(currentcellHead->datas+0x2E) = 0;
}
}
//TODO: here, restart music
currentcellHead = currentcellHead->next;
}
if (strlen((char *)currentCtpName)) {
ctpVar1 = 1;
loadCtp(currentCtpName);
ctpVar1 = 0;
}
//prepareFadeOut();
//gfxModuleData.gfxFunction8();
//TODO: here, restart music
if(strlen((char*)currentCtpName))
{
ctpVar1 = 1;
loadCtp(currentCtpName);
ctpVar1 = 0;
}
for (j = 0; j < 8; j++) {
if (strlen((char *)backgroundTable[j].name)) {
loadBackground(backgroundTable[j].name, j);
}
}
//prepareFadeOut();
//gfxModuleData.gfxFunction8();
regenerateBackgroundIncrust(&backgroundIncrustHead);
for(j=0;j<8;j++)
{
if(strlen((char*)backgroundTable[j].name))
{
loadBackground(backgroundTable[j].name,j);
}
}
// to finish
regenerateBackgroundIncrust(&backgroundIncrustHead);
changeCursor(0);
mainDraw(1);
flipScreen();
// to finish
changeCursor(0);
mainDraw(1);
flipScreen();
return(0);
return (0);
}
} // End of namespace Cruise

4
engines/cruise/saveload.h
View file

@ -22,8 +22,8 @@
*
*/
#ifndef _LOADSAVE_H_
#define _LOADSAVE_H_
#ifndef CRUISE_SAVELOAD_H
#define CRUISE_SAVELOAD_H
namespace Cruise {

1263
engines/cruise/script.cpp
View file

File diff suppressed because it is too large Load diff

32
engines/cruise/script.h
View file

@ -22,26 +22,24 @@
*
*/
#ifndef _SCRIPT_H_
#define _SCRIPT_H_
#ifndef CRUISE_SCRIPT_H
#define CRUISE_SCRIPT_H
namespace Cruise {
enum scriptTypeEnum
{
scriptType_Minus20 = -20,
scriptType_Minus30 = -30,
scriptType_20 = 20,
scriptType_30 = 30
enum scriptTypeEnum {
scriptType_Minus20 = -20,
scriptType_Minus30 = -30,
scriptType_20 = 20,
scriptType_30 = 30
};
typedef enum scriptTypeEnum scriptTypeEnum;
struct scriptInstanceStruct
{
struct scriptInstanceStruct* nextScriptPtr;
struct scriptInstanceStruct {
struct scriptInstanceStruct *nextScriptPtr;
int16 var4;
uint8* var6;
uint8 *var6;
int16 varA;
int16 scriptNumber;
int16 overlayNumber;
@ -59,14 +57,16 @@ typedef struct scriptInstanceStruct scriptInstanceStruct;
extern scriptInstanceStruct scriptHandle1;
extern scriptInstanceStruct scriptHandle2;
extern scriptInstanceStruct* currentScriptPtr;
extern scriptInstanceStruct *currentScriptPtr;
void setupFuncArray(void);
uint8 getByteFromScript(void);
int removeScript(int overlay,int idx,scriptInstanceStruct* headPtr);
uint8* attacheNewScriptToTail(int16 overlayNumber,scriptInstanceStruct* scriptHandlePtr,int16 param, int16 arg0, int16 arg1, int16 arg2, scriptTypeEnum scriptType);
void manageScripts(scriptInstanceStruct* scriptHandle);
int removeScript(int overlay, int idx, scriptInstanceStruct * headPtr);
uint8 *attacheNewScriptToTail(int16 overlayNumber,
scriptInstanceStruct * scriptHandlePtr, int16 param, int16 arg0,
int16 arg1, int16 arg2, scriptTypeEnum scriptType);
void manageScripts(scriptInstanceStruct * scriptHandle);
} // End of namespace Cruise

65
engines/cruise/stack.cpp
View file

@ -31,55 +31,46 @@ stackElementStruct scriptStack[SIZE_STACK];
// VAR
void pushVar(int16 var)
{
if(positionInStack<SIZE_STACK)
{
scriptStack[positionInStack].data.shortVar = var;
scriptStack[positionInStack].type = STACK_SHORT;
positionInStack++;
}
void pushVar(int16 var) {
if (positionInStack < SIZE_STACK) {
scriptStack[positionInStack].data.shortVar = var;
scriptStack[positionInStack].type = STACK_SHORT;
positionInStack++;
}
}
int16 popVar(void)
{
if(positionInStack<=0)
{
return(0);
}
int16 popVar(void) {
if (positionInStack <= 0) {
return (0);
}
positionInStack--;
ASSERT(scriptStack[positionInStack].type == STACK_SHORT);
positionInStack--;
return(scriptStack[positionInStack].data.shortVar);
ASSERT(scriptStack[positionInStack].type == STACK_SHORT);
return (scriptStack[positionInStack].data.shortVar);
}
//// PTR
void pushPtr(void* ptr)
{
if(positionInStack<SIZE_STACK)
{
scriptStack[positionInStack].data.ptrVar = ptr;
scriptStack[positionInStack].type = STACK_PTR;
positionInStack++;
}
void pushPtr(void *ptr) {
if (positionInStack < SIZE_STACK) {
scriptStack[positionInStack].data.ptrVar = ptr;
scriptStack[positionInStack].type = STACK_PTR;
positionInStack++;
}
}
void* popPtr()
{
if(positionInStack<=0)
{
return(0);
}
void *popPtr() {
if (positionInStack <= 0) {
return (0);
}
positionInStack--;
ASSERT(scriptStack[positionInStack].type == STACK_PTR);
positionInStack--;
return(scriptStack[positionInStack].data.ptrVar);
ASSERT(scriptStack[positionInStack].type == STACK_PTR);
return (scriptStack[positionInStack].data.ptrVar);
}
} // End of namespace Cruise

31
engines/cruise/stack.h
View file

@ -22,30 +22,27 @@
*
*/
#ifndef _STACK_H_
#define _STACK_H_
#ifndef CRUISE_STACK_H
#define CRUISE_STACK_H
namespace Cruise {
#define SIZE_STACK 0x200
enum stackElementTypeEnum
{
STACK_SHORT,
STACK_PTR
enum stackElementTypeEnum {
STACK_SHORT,
STACK_PTR
};
typedef enum stackElementTypeEnum stackElementTypeEnum;
struct stackElementStruct
{
stackElementTypeEnum type;
union
{
void* ptrVar;
int16 shortVar;
} data;
struct stackElementStruct {
stackElementTypeEnum type;
union {
void *ptrVar;
int16 shortVar;
} data;
};
typedef struct stackElementStruct stackElementStruct;
@ -53,8 +50,8 @@ typedef struct stackElementStruct stackElementStruct;
int16 popVar(void);
void pushVar(int16 var);
void pushPtr(void* ptr);
void* popPtr(void);
void pushPtr(void *ptr);
void *popPtr(void);
} // End of namespace Cruise

20
engines/cruise/stringSupport.cpp
View file

@ -26,24 +26,20 @@
namespace Cruise {
void strcpyuint8(void* dest, const void* source)
{
strcpy((char*)dest,(const char*)source);
void strcpyuint8(void *dest, const void *source) {
strcpy((char *)dest, (const char *)source);
}
void strcatuint8(void* dest, const void* source)
{
strcat((char*)dest,(const char*)source);
void strcatuint8(void *dest, const void *source) {
strcat((char *)dest, (const char *)source);
}
uint8 strcmpuint8(const void* string1, const void* string2)
{
return strcmp((char*)string1,(char*)string2);
uint8 strcmpuint8(const void *string1, const void *string2) {
return strcmp((char *)string1, (char *)string2);
}
FILE* fopenuint8(void* name, const void* param)
{
return fopen((char*)name,(const char*)param);
FILE *fopenuint8(void *name, const void *param) {
return fopen((char *)name, (const char *)param);
}
} // End of namespace Cruise

12
engines/cruise/stringSupport.h
View file

@ -22,15 +22,15 @@
*
*/
#ifndef _STRING_SUPPORT_H_
#define _STRING_SUPPORT_H_
#ifndef CRUISE_STRING_SUPPORT_H
#define CRSUIE_STRING_SUPPORT_H
namespace Cruise {
void strcpyuint8(void* dest, const void* source);
void strcatuint8(void* dest, const void* source);
uint8 strcmpuint8(const void* string1, const void* string2);
FILE* fopenuint8(void* name, const void* param);
void strcpyuint8(void *dest, const void *source);
void strcatuint8(void *dest, const void *source);
uint8 strcmpuint8(const void *string1, const void *string2);
FILE *fopenuint8(void *name, const void *param);
} // End of namespace Cruise

206
engines/cruise/various.cpp
View file

@ -30,158 +30,140 @@ uint16 var0 = 0;
uint16 fadeVar;
uint16 main15;
int16 readB16(void* ptr)
{
int16 readB16(void *ptr) {
int16 temp;
temp = *(int16*)ptr;
temp = *(int16 *) ptr;
flipShort(&temp);
return temp;
}
void freeObject(cellStruct* objPtr)
{
if(objPtr)
{
/* if(objPtr->next)
free(objPtr->next); */
void freeObject(cellStruct *objPtr) {
if (objPtr) {
/* if(objPtr->next)
* free(objPtr->next); */
//free(objPtr);
}
//free(objPtr);
}
}
void removeObjectFromList(int ovlNumber, int objectIdx, cellStruct* objPtr, int backgroundPlane, int arg)
{
cellStruct* currentObj = objPtr->next;
cellStruct* previous;
void removeObjectFromList(int ovlNumber, int objectIdx, cellStruct *objPtr,
int backgroundPlane, int arg) {
cellStruct *currentObj = objPtr->next;
cellStruct *previous;
while(currentObj)
{
cellStruct* si;
while (currentObj) {
cellStruct *si;
si = currentObj;
si = currentObj;
if( (si->overlay == ovlNumber || ovlNumber == -1) &&
(si->idx == objectIdx || objectIdx == -1) &&
(si->type == arg || arg == -1) &&
(si->backgroundPlane == backgroundPlane || backgroundPlane == -1) )
{
si->type = -1;
}
if ((si->overlay == ovlNumber || ovlNumber == -1) &&
(si->idx == objectIdx || objectIdx == -1) &&
(si->type == arg || arg == -1) &&
(si->backgroundPlane == backgroundPlane
|| backgroundPlane == -1)) {
si->type = -1;
}
currentObj = si->next;
}
currentObj = si->next;
}
previous = objPtr;
currentObj = objPtr->next;
previous = objPtr;
currentObj = objPtr->next;
while(currentObj)
{
cellStruct* si;
while (currentObj) {
cellStruct *si;
si = currentObj;
si = currentObj;
if(si->type == -1)
{
cellStruct* dx;
previous->next = si->next;
if (si->type == -1) {
cellStruct *dx;
previous->next = si->next;
dx = si->next;
dx = si->next;
if(!si->next)
{
dx = objPtr;
}
if (!si->next) {
dx = objPtr;
}
dx->prev = si->prev;
dx->prev = si->prev;
freeObject(si);
freeObject(si);
free(si);
free(si);
currentObj = dx;
}
else
{
currentObj = si->next;
previous = si;
}
}
currentObj = dx;
} else {
currentObj = si->next;
previous = si;
}
}
}
char* getText(int textIndex, int overlayIndex)
{
if(!overlayTable[overlayIndex].ovlData)
{
return NULL;
}
char *getText(int textIndex, int overlayIndex) {
if (!overlayTable[overlayIndex].ovlData) {
return NULL;
}
if(!overlayTable[overlayIndex].ovlData->stringTable)
{
return NULL;
}
if (!overlayTable[overlayIndex].ovlData->stringTable) {
return NULL;
}
return overlayTable[overlayIndex].ovlData->stringTable[textIndex].string;
return overlayTable[overlayIndex].ovlData->stringTable[textIndex].
string;
}
void createTextObject(int overlayIdx, int oldVar8, cellStruct *pObject, int scriptNumber, int scriptOverlayNumber, int backgroundPlane, int16 color, int oldVar2, int oldVar4, int oldVar6)
{
char* ax;
cellStruct* savePObject = pObject;
cellStruct* cx;
void createTextObject(int overlayIdx, int oldVar8, cellStruct *pObject,
int scriptNumber, int scriptOverlayNumber, int backgroundPlane,
int16 color, int oldVar2, int oldVar4, int oldVar6) {
char *ax;
cellStruct *savePObject = pObject;
cellStruct *cx;
cellStruct* pNewElement;
cellStruct* si = pObject->next;
cellStruct* var_2;
cellStruct *pNewElement;
cellStruct *si = pObject->next;
cellStruct *var_2;
while(si)
{
pObject = si;
si = si->next;
}
while (si) {
pObject = si;
si = si->next;
}
var_2 = si;
var_2 = si;
pNewElement = (cellStruct*)malloc(sizeof(cellStruct));
pNewElement = (cellStruct *) malloc(sizeof(cellStruct));
pNewElement->next = pObject->next;
pObject->next = pNewElement;
pNewElement->next = pObject->next;
pObject->next = pNewElement;
pNewElement->idx = oldVar8;
pNewElement->type = 5;
pNewElement->backgroundPlane = backgroundPlane;
pNewElement->overlay = overlayIdx;
pNewElement->field_A = oldVar6;
pNewElement->field_C = oldVar4;
pNewElement->spriteIdx = oldVar2;
pNewElement->field_10 = color;
pNewElement->freeze = 0;
pNewElement->field_16 = scriptNumber;
pNewElement->field_18 = scriptOverlayNumber;
pNewElement->gfxPtr = NULL;
pNewElement->idx = oldVar8;
pNewElement->type = 5;
pNewElement->backgroundPlane = backgroundPlane;
pNewElement->overlay = overlayIdx;
pNewElement->field_A = oldVar6;
pNewElement->field_C = oldVar4;
pNewElement->spriteIdx = oldVar2;
pNewElement->field_10 = color;
pNewElement->freeze = 0;
pNewElement->field_16 = scriptNumber;
pNewElement->field_18 = scriptOverlayNumber;
pNewElement->gfxPtr = NULL;
if(var_2)
{
cx = var_2;
}
else
{
cx = savePObject;
}
if (var_2) {
cx = var_2;
} else {
cx = savePObject;
}
pNewElement->prev = cx->prev;
cx->prev = pNewElement;
pNewElement->prev = cx->prev;
cx->prev = pNewElement;
ax = getText(oldVar8, overlayIdx);
ax = getText(oldVar8, overlayIdx);
if(ax)
{
pNewElement->gfxPtr = renderText(oldVar2, (uint8*)ax);
}
if (ax) {
pNewElement->gfxPtr = renderText(oldVar2, (uint8 *) ax);
}
}
} // End of namespace Cruise

15
engines/cruise/various.h
View file

@ -22,8 +22,8 @@
*
*/
#ifndef _VARIOUS_H_
#define _VARIOUS_H_
#ifndef CRUISE_VARIOUS_H
#define CRUISE_VARIOUS_H
#include "cruise/cell.h"
@ -33,11 +33,14 @@ extern uint16 var0;
extern uint16 fadeVar;
extern uint16 main15;
int16 readB16(void* ptr);
int16 readB16(void *ptr);
void createTextObject(int overlayIdx, int oldVar8, cellStruct *pObject, int scriptNumber, int scriptOverlayNumber, int backgroundPlane, int16 color, int oldVar2, int oldVar4, int oldVar6);
void removeObjectFromList(int ovlNumber, int objectIdx, cellStruct* objPtr, int backgroundPlane, int arg);
int16 Op_InitializeStateSub(int ovlIdx,int param1,int param2);
void createTextObject(int overlayIdx, int oldVar8, cellStruct * pObject,
int scriptNumber, int scriptOverlayNumber, int backgroundPlane,
int16 color, int oldVar2, int oldVar4, int oldVar6);
void removeObjectFromList(int ovlNumber, int objectIdx, cellStruct * objPtr,
int backgroundPlane, int arg);
int16 Op_InitializeStateSub(int ovlIdx, int param1, int param2);
} // End of namespace Cruise

32
engines/cruise/vars.cpp
View file

@ -26,7 +26,7 @@
namespace Cruise {
uint8* _systemFNT;
uint8 *_systemFNT;
uint8 video2 = 1;
uint8 video3 = 3;
@ -69,7 +69,7 @@ Common::File currentVolumeFile;
int16 currentCursor;
int16 volumeNumEntry;
fileEntry* volumePtrToFileDescriptor = NULL;
fileEntry *volumePtrToFileDescriptor = NULL;
uint32 volumeFileDescriptorSize;
int16 volumeSizeOfEntry;
@ -89,16 +89,14 @@ cellStruct cellHead;
opcodeTypeFunction opcodeTypeTable[64];
int16 positionInStack;
actorStruct actorHead;
int16 setup1;
uint8* currentData3DataPtr;
uint8* scriptDataPtrTable[7];
uint8 *currentData3DataPtr;
uint8 *scriptDataPtrTable[7];
int16 currentScriptOpcodeType;
@ -142,30 +140,30 @@ int16 var48;
int16 flagCt;
int8 var50[64];
int16 palette[256*3];
int16 palette[256 * 3];
systemStringsStruct systemStrings;
uint8 currentCtpName[40];
int16 saveVar1;
uint8 saveVar2[97]; // recheck size
uint8 saveVar2[97]; // recheck size
int16 numberOfWalkboxes; // saveVar3
int16 numberOfWalkboxes; // saveVar3
int16 walkboxType[15]; // saveVar4
int16 walkboxChange[15]; // saveVar5
int16 walkboxChange[15]; // saveVar5
uint8 saveVar6[16];
int32 loadFileVar1;
int16 ctpVar1 = 0;
int16 ctp_routeCoordCount; // ctpVar2
int16 ctp_routeCoords[20][2]; // ctpVar3
int16 ctp_routes[20][10];
int16 ctp_routeCoordCount; // ctpVar2
int16 ctp_routeCoords[20][2]; // ctpVar3
int16 ctp_routes[20][10];
uint16 ctp_walkboxTable[15 * 40]; // ctpVar5
int8 ctpVar6[32];
int16 ctp_scale[15]; // ctpVar7
int8 ctpVar6[32];
int16 ctp_scale[15]; // ctpVar7
int16 ctpVar8[200];
int16 ctpVar14;
@ -174,8 +172,8 @@ int16 bgVar1;
int16 bgVar2;
int16 bgVar3;
uint8 globalScreen[320*200];
uint8 scaledScreen[640*400];
uint8 globalScreen[320 * 200];
uint8 scaledScreen[640 * 400];
//OSystem *osystem;

135
engines/cruise/vars.h
View file

@ -22,42 +22,39 @@
*
*/
#ifndef _VARS_H_
#define _VARS_H_
#ifndef CRUISE_VARS_H
#define CRUISE_VARS_H
#include "common/file.h"
namespace Cruise {
struct menuElementSubStruct
{
struct menuElementSubStruct* pNext;
int16 var2;
int16 var4;
struct menuElementSubStruct {
struct menuElementSubStruct *pNext;
int16 var2;
int16 var4;
};
typedef struct menuElementSubStruct menuElementSubStruct;
struct menuElementStruct
{
struct menuElementStruct* next;
const char* string;
int x;
int y;
int varA;
int varC;
unsigned char color;
gfxEntryStruct* gfx;
menuElementSubStruct* ptrSub;
struct menuElementStruct {
struct menuElementStruct *next;
const char *string;
int x;
int y;
int varA;
int varC;
unsigned char color;
gfxEntryStruct *gfx;
menuElementSubStruct *ptrSub;
};
typedef struct menuElementStruct menuElementStruct;
typedef int32(*opcodeTypeFunction)(void);
typedef int16(*opcodeFunction)(void);
typedef int32(*opcodeTypeFunction) (void);
typedef int16(*opcodeFunction) (void);
extern uint8* _systemFNT;
extern uint8 *_systemFNT;
extern int16 fontFileIndex;
extern uint8 video2;
@ -74,15 +71,13 @@ extern int16 currentActiveBackgroundPlane;
extern int16 main5;
extern int16 var22;
struct mediumVarStruct
{
struct mediumVarStruct {
uint8 name[16];
int16 field_10;
int16 field_12;
int16 field_14;
int16 field_16;
uint8* ptr;
uint8 *ptr;
int16 field_1C;
int16 field_1E;
int16 field_20;
@ -90,36 +85,32 @@ struct mediumVarStruct
typedef struct mediumVarStruct mediumVarStruct;
struct filesDataStruct
{
uint8* field_0;
uint8* field_4;
struct filesDataStruct {
uint8 *field_0;
uint8 *field_4;
};
typedef struct filesDataStruct filesDataStruct;
struct filesData2Struct
{
struct filesData2Struct {
int16 field_0;
int16 field_2;
};
typedef struct filesData2Struct filesData2Struct;
struct fileName
{
struct fileName {
uint8 name[13];
};
typedef struct fileName fileName;
struct setHeaderEntry
{
int16 field_0; // offset ptr part 1
int16 field_2; // offset ptr part 2
struct setHeaderEntry {
int16 field_0; // offset ptr part 1
int16 field_2; // offset ptr part 2
int16 width;
int16 height;
int16 type; // resource type, ie. sprites 0,1,4,5 and 8
int16 type; // resource type, ie. sprites 0,1,4,5 and 8
int16 transparency;
int16 field_C;
int16 field_E;
@ -127,43 +118,39 @@ struct setHeaderEntry
typedef struct setHeaderEntry setHeaderEntry;
struct volumeDataStruct
{
struct volumeDataStruct {
char ident[10];
fileName* ptr;
fileName *ptr;
int16 diskNumber;
int32 size;
};
typedef struct volumeDataStruct volumeDataStruct;
struct fileEntry
{
struct fileEntry {
uint8 name[14];
int32 offset;
int32 size;
int32 extSize;
int32 unk3; // unused
int32 unk3; // unused
};
typedef struct fileEntry fileEntry;
struct dataFileEntrySub
{
uint8* ptr;
int16 index; // sprite index
char name[14];
int16 transparency; // sprite transparency
uint8* ptr2;
uint8 resourceType; // sprite and image type 2,4,8 , fnt = 7, spl = 6
uint8 field_1B;
struct dataFileEntrySub {
uint8 *ptr;
int16 index; // sprite index
char name[14];
int16 transparency; // sprite transparency
uint8 *ptr2;
uint8 resourceType; // sprite and image type 2,4,8 , fnt = 7, spl = 6
uint8 field_1B;
int16 field_1C;
};
typedef struct dataFileEntrySub dataFileEntrySub;
struct dataFileEntry
{
struct dataFileEntry {
int16 widthInColumn;
int16 width;
int16 resType;
@ -173,8 +160,7 @@ struct dataFileEntry
typedef struct dataFileEntry dataFileEntry;
struct systemStringsStruct
{
struct systemStringsStruct {
int8 param;
uint8 string[12];
uint8 bootScriptName[8];
@ -202,7 +188,6 @@ extern int16 main22;
extern int16 main7;
extern int16 main8;
extern int16 currentDiskNumber;
extern Common::File currentVolumeFile;
@ -210,7 +195,7 @@ extern Common::File currentVolumeFile;
extern int16 currentCursor;
extern int16 volumeNumEntry;
extern fileEntry* volumePtrToFileDescriptor;
extern fileEntry *volumePtrToFileDescriptor;
extern uint32 volumeFileDescriptorSize;
extern int16 volumeSizeOfEntry;
@ -232,8 +217,8 @@ extern actorStruct actorHead;
extern int16 setup1;
extern uint8* currentData3DataPtr;
extern uint8* scriptDataPtrTable[7];
extern uint8 *currentData3DataPtr;
extern uint8 *scriptDataPtrTable[7];
extern int16 currentScriptOpcodeType;
@ -278,26 +263,26 @@ extern int16 var48;
extern int16 flagCt;
extern int8 var50[64];
extern int16 palette[256*3];
extern int16 palette[256 * 3];
extern systemStringsStruct systemStrings;
extern uint8 currentCtpName[40];
extern int16 saveVar1;
extern uint8 saveVar2[97]; // recheck size
extern uint8 saveVar2[97]; // recheck size
extern int16 numberOfWalkboxes; // saveVar3
extern int16 walkboxType[15]; // saveVar4 // Type: 0x00 - non walkable, 0x01 - walkable, 0x02 - exit zone
extern int16 walkboxChange[15]; // saveVar5 // walkbox can change its type: 0x00 - not changeable, 0x01 - changeable
extern int16 numberOfWalkboxes; // saveVar3
extern int16 walkboxType[15]; // saveVar4 // Type: 0x00 - non walkable, 0x01 - walkable, 0x02 - exit zone
extern int16 walkboxChange[15]; // saveVar5 // walkbox can change its type: 0x00 - not changeable, 0x01 - changeable
// Assumption: To change the type: walkboxType[i] -= walkboxChane[i] and vice versa
extern uint8 saveVar6[16];
extern int32 loadFileVar1;
extern int16 ctpVar1;
extern int16 ctp_routeCoordCount; // ctpVar2 // number of path-finding coordinates
extern int16 ctp_routeCoords[20][2]; // ctpVar3 // path-finding coordinates array
extern int16 ctp_routeCoordCount; // ctpVar2 // number of path-finding coordinates
extern int16 ctp_routeCoords[20][2]; // ctpVar3 // path-finding coordinates array
/* ctp_routeCoords:
@ -305,7 +290,7 @@ extern int16 ctp_routeCoords[20][2]; // ctpVar3 // path-finding coordinates ar
coordinate information with x (2 bytes) and y (2 bytes)
*/
extern int16 ctp_routes[20][10]; // path-finding line information
extern int16 ctp_routes[20][10]; // path-finding line information
/* ctp_routes:
@ -317,9 +302,9 @@ extern int16 ctp_routes[20][10]; // path-finding line information
for the 20 * i slice the root x,y is routeCoords[i], routeCoords[i+2]
the unused rest of the slice if filled up with 0xFF
*/
extern uint16 ctp_walkboxTable[15 * 40]; // ctpVar5 // walkboxes coordinates and lines
extern int8 ctpVar6[32];
extern int16 ctp_scale[15]; // ctpVar7 // scaling information for walkboxes
extern uint16 ctp_walkboxTable[15 * 40]; // ctpVar5 // walkboxes coordinates and lines
extern int8 ctpVar6[32];
extern int16 ctp_scale[15]; // ctpVar7 // scaling information for walkboxes
extern int16 ctpVar8[200];
extern int16 ctpVar14;
@ -328,8 +313,8 @@ extern int16 bgVar1;
extern int16 bgVar2;
extern int16 bgVar3;
extern uint8 globalScreen[320*200];
extern uint8 scaledScreen[640*400];
extern uint8 globalScreen[320 * 200];
extern uint8 scaledScreen[640 * 400];
//extern OSystem *osystem;

357
engines/cruise/volume.cpp
View file

@ -26,77 +26,72 @@
namespace Cruise {
FILE* PAL_fileHandle = NULL;
uint8* PAL_ptr = NULL;
FILE *PAL_fileHandle = NULL;
uint8 *PAL_ptr = NULL;
int16 numLoadedPal;
int16 fileData2;
void loadPal(volumeDataStruct* entry)
{
char name[20];
void loadPal(volumeDataStruct *entry) {
char name[20];
return;
if(PAL_fileHandle)
{
fclose(PAL_fileHandle);
}
if (PAL_fileHandle) {
fclose(PAL_fileHandle);
}
removeExtention(entry->ident, name);
strcat(name,".PAL");
PAL_fileHandle = fopen(name,"rb");
removeExtention(entry->ident, name);
strcat(name, ".PAL");
fread(&numLoadedPal, 2, 1, PAL_fileHandle);
fread(&fileData2, 2, 1, PAL_fileHandle);
PAL_fileHandle = fopen(name, "rb");
flipShort(&numLoadedPal);
flipShort(&fileData2);
fread(&numLoadedPal, 2, 1, PAL_fileHandle);
fread(&fileData2, 2, 1, PAL_fileHandle);
PAL_ptr = (uint8*)malloc(numLoadedPal*fileData2);
flipShort(&numLoadedPal);
flipShort(&fileData2);
PAL_ptr = (uint8 *) malloc(numLoadedPal * fileData2);
}
int getVolumeDataEntry(volumeDataStruct* entry)
{
int getVolumeDataEntry(volumeDataStruct *entry) {
char buffer[256];
int i;
volumeNumEntry = 0;
volumeNumberOfEntry = 0;
if(currentVolumeFile.isOpen())
{
if (currentVolumeFile.isOpen()) {
freeDisk();
}
askDisk(-1);
strcpyuint8(buffer,entry->ident);
strcpyuint8(buffer, entry->ident);
currentVolumeFile.open(buffer);
if(!currentVolumeFile.isOpen())
{
return(-14);
if (!currentVolumeFile.isOpen()) {
return (-14);
}
changeCursor(1);
currentVolumeFile.read(&volumeNumberOfEntry,2);
currentVolumeFile.read(&volumeSizeOfEntry,2);
currentVolumeFile.read(&volumeNumberOfEntry, 2);
currentVolumeFile.read(&volumeSizeOfEntry, 2);
flipShort(&volumeNumberOfEntry);
flipShort(&volumeSizeOfEntry);
volumeNumEntry = volumeNumberOfEntry;
assert(volumeSizeOfEntry == 14+4+4+4+4);
assert(volumeSizeOfEntry == 14 + 4 + 4 + 4 + 4);
volumePtrToFileDescriptor = (fileEntry*)mallocAndZero(sizeof(fileEntry) * volumeNumEntry);
volumePtrToFileDescriptor =
(fileEntry *) mallocAndZero(sizeof(fileEntry) * volumeNumEntry);
for(i=0;i<volumeNumEntry;i++)
{
for (i = 0; i < volumeNumEntry; i++) {
volumePtrToFileDescriptor[i].name[0] = 0;
volumePtrToFileDescriptor[i].offset = 0;
volumePtrToFileDescriptor[i].size = 0;
@ -104,177 +99,153 @@ int getVolumeDataEntry(volumeDataStruct* entry)
volumePtrToFileDescriptor[i].unk3 = 0;
}
for(i=0;i<volumeNumEntry;i++)
{
for (i = 0; i < volumeNumEntry; i++) {
currentVolumeFile.read(&volumePtrToFileDescriptor[i].name, 14);
currentVolumeFile.read(&volumePtrToFileDescriptor[i].offset, 4);
currentVolumeFile.read(&volumePtrToFileDescriptor[i].offset,
4);
currentVolumeFile.read(&volumePtrToFileDescriptor[i].size, 4);
currentVolumeFile.read(&volumePtrToFileDescriptor[i].extSize, 4);
currentVolumeFile.read(&volumePtrToFileDescriptor[i].extSize,
4);
currentVolumeFile.read(&volumePtrToFileDescriptor[i].unk3, 4);
}
for(i=0;i<volumeNumEntry;i++)
{
for (i = 0; i < volumeNumEntry; i++) {
flipLong(&volumePtrToFileDescriptor[i].offset);
flipLong(&volumePtrToFileDescriptor[i].size);
flipLong(&volumePtrToFileDescriptor[i].extSize);
}
loadPal(entry);
return 0;
}
int searchFileInVolCnf(uint8* fileName,int32 diskNumber)
{
int searchFileInVolCnf(uint8 *fileName, int32 diskNumber) {
int foundDisk = -1;
int i;
for(i=0;i<numOfDisks;i++)
{
if(volumeData[i].diskNumber == diskNumber)
{
for (i = 0; i < numOfDisks; i++) {
if (volumeData[i].diskNumber == diskNumber) {
int j;
int numOfEntry = volumeData[i].size / 13;
for(j=0;j<numOfEntry;j++)
{
if(!strcmpuint8(volumeData[i].ptr[j].name,fileName))
{
return(i);
for (j = 0; j < numOfEntry; j++) {
if (!strcmpuint8(volumeData[i].ptr[j].name,
fileName)) {
return (i);
}
}
}
}
return(foundDisk);
return (foundDisk);
}
int32 findFileInDisksSub1(uint8* fileName)
{
int32 findFileInDisksSub1(uint8 *fileName) {
int foundDisk = -1;
int i;
for(i=0;i<numOfDisks;i++)
{
for (i = 0; i < numOfDisks; i++) {
int j;
int numOfEntry = volumeData[i].size / 13;
for(j=0;j<numOfEntry;j++)
{
if(!strcmpuint8(volumeData[i].ptr[j].name,fileName))
{
return(i);
for (j = 0; j < numOfEntry; j++) {
if (!strcmpuint8(volumeData[i].ptr[j].name, fileName)) {
return (i);
}
}
}
return(foundDisk);
return (foundDisk);
}
void strToUpper(uint8* fileName)
{
void strToUpper(uint8 *fileName) {
char character;
do
{
do {
character = *fileName;
if(character>='a' && character<='z')
{
character&=0xDF;
if (character >= 'a' && character <= 'z') {
character &= 0xDF;
*fileName = character;
}
fileName++;
}while(character);
} while (character);
}
int16 fileExist(uint8* fileName)
{
FILE* fHandle;
int16 fileExist(uint8 *fileName) {
FILE *fHandle;
fHandle = fopenuint8(fileName,"rb");
fHandle = fopenuint8(fileName, "rb");
if(fHandle)
{
if (fHandle) {
fclose(fHandle);
return(0);
return (0);
}
return(1);
return (1);
}
void freeDisk(void)
{
if(currentVolumeFile.isOpen())
{
void freeDisk(void) {
if (currentVolumeFile.isOpen()) {
currentVolumeFile.close();
free(volumePtrToFileDescriptor);
}
/* TODO
if(PAL_fileHandle)
{
freeAllDataPtr();
}
*/
* if(PAL_fileHandle)
* {
* freeAllDataPtr();
* }
*/
}
int16 findFileInList(uint8* fileName)
{
int16 findFileInList(uint8 *fileName) {
int i;
if(!currentVolumeFile.isOpen())
{
return(-1);
if (!currentVolumeFile.isOpen()) {
return (-1);
}
strToUpper(fileName);
if(volumeNumEntry<=0)
{
return(-1);
if (volumeNumEntry <= 0) {
return (-1);
}
for(i=0;i<volumeNumEntry;i++)
{
if(!strcmpuint8(volumePtrToFileDescriptor[i].name,fileName))
{
return(i);
for (i = 0; i < volumeNumEntry; i++) {
if (!strcmpuint8(volumePtrToFileDescriptor[i].name, fileName)) {
return (i);
}
}
return(-1);
return (-1);
}
void askDisk(int16 discNumber)
{
void askDisk(int16 discNumber) {
char diskNumberString[256];
uint8 fileName[256];
uint8 string[256];
char messageDrawn = 0;
if(discNumber != -1)
{
if (discNumber != -1) {
currentDiskNumber = discNumber;
}
// skip drive selection stuff
strcpyuint8(fileName,"VOL.");
sprintf(diskNumberString,"%d",currentDiskNumber);
strcatuint8(fileName,diskNumberString);
strcpyuint8(fileName, "VOL.");
sprintf(diskNumberString, "%d", currentDiskNumber);
strcatuint8(fileName, diskNumberString);
strcpyuint8(string,"INSERER LE DISQUE ");
strcatuint8(string,diskNumberString);
strcatuint8(string," EN ");
strcpyuint8(string, "INSERER LE DISQUE ");
strcatuint8(string, diskNumberString);
strcatuint8(string, " EN ");
// while(fileExist(fileName))
// while(fileExist(fileName))
{
if(!messageDrawn)
{
if (!messageDrawn) {
drawMsgString(string);
messageDrawn = 1;
}
@ -283,20 +254,15 @@ void askDisk(int16 discNumber)
changeCursor(currentCursor);
}
int16 findFileInDisks(uint8* fileName)
{
int16 findFileInDisks(uint8 *fileName) {
int disk;
int fileIdx;
strToUpper(fileName);
if(!volumeDataLoaded)
{
if (!volumeDataLoaded) {
printf("CNF wasn't loaded, reading now...\n");
if(currentVolumeFile.isOpen())
{
if (currentVolumeFile.isOpen()) {
askDisk(-1);
freeDisk();
}
@ -305,28 +271,24 @@ int16 findFileInDisks(uint8* fileName)
readVolCnf();
}
if(currentVolumeFile.isOpen())
{
if (currentVolumeFile.isOpen()) {
askDisk(-1);
}
fileIdx = findFileInList(fileName);
if(fileIdx>=0)
{
return(fileIdx);
if (fileIdx >= 0) {
return (fileIdx);
}
disk = searchFileInVolCnf(fileName,currentDiskNumber);
disk = searchFileInVolCnf(fileName, currentDiskNumber);
if(disk>=0)
{
if (disk >= 0) {
int temp;
printf("File found on disk %d\n", disk);
if(currentVolumeFile.isOpen())
{
if (currentVolumeFile.isOpen()) {
askDisk(-1);
}
@ -338,69 +300,61 @@ int16 findFileInDisks(uint8* fileName)
temp = findFileInList(fileName);
if(temp>=0)
return(temp);
if (temp >= 0)
return (temp);
return(-1);
return (-1);
}
else
{
} else {
int temp;
temp = findFileInDisksSub1(fileName);
if(temp>=0)
{
if (temp >= 0) {
int temp2;
askDisk(volumeData[temp].diskNumber);
getVolumeDataEntry(&volumeData[temp]);
temp2 = findFileInList(fileName);
if(temp2>=0)
return(temp2);
if (temp2 >= 0)
return (temp2);
}
return(-1);
return (-1);
}
}
int16 readVolCnf(void)
{
int16 readVolCnf(void) {
int i;
Common::File fileHandle;
short int sizeHEntry;
volumeDataLoaded = 0;
for(i=0;i<20;i++)
{
for (i = 0; i < 20; i++) {
volumeData[i].ident[0] = 0;
volumeData[i].ptr = NULL;
volumeData[i].diskNumber = i+1;
volumeData[i].diskNumber = i + 1;
volumeData[i].size = 0;
}
fileHandle.open("VOL.CNF");
if(!fileHandle.isOpen())
{
return(0);
if (!fileHandle.isOpen()) {
return (0);
}
fileHandle.read(&numOfDisks,2);
fileHandle.read(&numOfDisks, 2);
flipShort(&numOfDisks);
fileHandle.read(&sizeHEntry,2);
flipShort(&sizeHEntry); // size of one header entry - 20 bytes
fileHandle.read(&sizeHEntry, 2);
flipShort(&sizeHEntry); // size of one header entry - 20 bytes
for(i=0;i<numOfDisks;i++)
{
// fread(&volumeData[i],20,1,fileHandle);
for (i = 0; i < numOfDisks; i++) {
// fread(&volumeData[i],20,1,fileHandle);
fileHandle.read(&volumeData[i].ident, 10);
fileHandle.read(&volumeData[i].ptr, 4);
fileHandle.read(&volumeData[i].diskNumber, 2);
@ -411,24 +365,22 @@ int16 readVolCnf(void)
flipLong(&volumeData[i].size);
}
for(i=0;i<numOfDisks;i++)
{
fileName* ptr;
fileHandle.read(&volumeData[i].size,4);
for (i = 0; i < numOfDisks; i++) {
fileName *ptr;
fileHandle.read(&volumeData[i].size, 4);
flipLong(&volumeData[i].size);
ptr = (fileName*)mallocAndZero(volumeData[i].size);
ptr = (fileName *) mallocAndZero(volumeData[i].size);
volumeData[i].ptr = ptr;
if(!ptr)
{
if (!ptr) {
fileHandle.close();
return(-2);
return (-2);
}
fileHandle.read(ptr,volumeData[i].size);
fileHandle.read(ptr, volumeData[i].size);
}
fileHandle.close();
@ -438,31 +390,29 @@ int16 readVolCnf(void)
//#define dumpResources
#ifdef dumpResources
for(i=0;i<numOfDisks;i++)
{
for (i = 0; i < numOfDisks; i++) {
int j;
char nameBuffer[256];
fileEntry* buffer;
fileEntry *buffer;
sprintf(nameBuffer,"D%d.",i+1);
sprintf(nameBuffer, "D%d.", i + 1);
fileHandle = fopen(nameBuffer,"rb");
fileHandle = fopen(nameBuffer, "rb");
short int numEntry;
short int sizeEntry;
fread(&numEntry,2,1,fileHandle);
fread(&sizeEntry,2,1,fileHandle);
fread(&numEntry, 2, 1, fileHandle);
fread(&sizeEntry, 2, 1, fileHandle);
flipShort(&numEntry);
flipShort(&sizeEntry);
buffer = (fileEntry*)mallocAndZero(numEntry*sizeEntry);
buffer = (fileEntry *) mallocAndZero(numEntry * sizeEntry);
fread(buffer,numEntry*sizeEntry,1,fileHandle);
fread(buffer, numEntry * sizeEntry, 1, fileHandle);
for(j=0;j<numEntry;j++)
{
for (j = 0; j < numEntry; j++) {
flipLong(&buffer[j].offset);
flipLong(&buffer[j].size);
flipLong(&buffer[j].unk2);
@ -470,29 +420,33 @@ int16 readVolCnf(void)
fseek(fileHandle, buffer[j].offset, SEEK_SET);
char* bufferLocal;
bufferLocal = (char*)mallocAndZero(buffer[j].size);
char *bufferLocal;
bufferLocal = (char *)mallocAndZero(buffer[j].size);
fread(bufferLocal,buffer[j].size,1,fileHandle);
fread(bufferLocal, buffer[j].size, 1, fileHandle);
char nameBuffer[256];
sprintf(nameBuffer,"D%d.dmp/%s",i+1,buffer[j].name);
sprintf(nameBuffer, "D%d.dmp/%s", i + 1,
buffer[j].name);
if(buffer[j].size == buffer[j].unk2)
{
FILE* fOut = fopen(nameBuffer,"wb+");
fwrite(bufferLocal,buffer[j].size,1,fOut);
if (buffer[j].size == buffer[j].unk2) {
FILE *fOut = fopen(nameBuffer, "wb+");
fwrite(bufferLocal, buffer[j].size, 1, fOut);
fclose(fOut);
}
else
{
char* uncompBuffer = (char*)mallocAndZero(buffer[j].unk2+500);
} else {
char *uncompBuffer =
(char *)mallocAndZero(buffer[j].unk2 +
500);
decomp((uint8*)bufferLocal+buffer[j].size-4,(uint8*)uncompBuffer+buffer[j].unk2+500,buffer[j].unk2);
decomp((uint8 *) bufferLocal + buffer[j].size -
4,
(uint8 *) uncompBuffer + buffer[j].unk2 +
500, buffer[j].unk2);
FILE* fOut = fopen(nameBuffer,"wb+");
fwrite(uncompBuffer+500,buffer[j].unk2,1,fOut);
FILE *fOut = fopen(nameBuffer, "wb+");
fwrite(uncompBuffer + 500, buffer[j].unk2, 1,
fOut);
fclose(fOut);
//free(uncompBuffer);
@ -505,13 +459,12 @@ int16 readVolCnf(void)
#endif
return(1);
return (1);
}
///////////////////////////::
void drawMsgString(uint8* string)
{
void drawMsgString(uint8 *string) {
//printf("%s\n",string);
}

16
engines/cruise/volume.h
View file

@ -22,23 +22,23 @@
*
*/
#ifndef _VOLUME_H_
#define _VOLUME_H_
#ifndef CRUISE_VOLUME_H
#define CRUISE_VOLUME_H
namespace Cruise {
int16 readVolCnf(void);
int16 findFileInDisks(uint8* fileName);
int16 fileExist(uint8* fileName);
int16 findFileInDisks(uint8 * fileName);
int16 fileExist(uint8 * fileName);
void freeDisk(void);
int16 findFileInList(uint8* fileName);
int16 findFileInList(uint8 * fileName);
////////////////
void strToUpper(uint8* fileName);
void drawMsgString(uint8* string);
void strToUpper(uint8 * fileName);
void drawMsgString(uint8 * string);
void askDisk(int16 discNumber);
void setObjectPosition(int16 param1,int16 param2,int16 param3,int16 param4);
void setObjectPosition(int16 param1, int16 param2, int16 param3, int16 param4);
} // End of namespace Cruise