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

199
engines/cruise/background.cpp
View file

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

14
engines/cruise/background.h
View file

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

293
engines/cruise/backgroundIncrust.cpp
View file

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

23
engines/cruise/backgroundIncrust.h
View file

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

192
engines/cruise/cell.cpp
View file

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

29
engines/cruise/cell.h
View file

@ -22,8 +22,8 @@
* *
*/ */
#ifndef _CELL_H_ #ifndef CRUISE_CELL_H
#define _CELL_H_ #define CRUISE_CELL_H
#include "common/stdafx.h" #include "common/stdafx.h"
#include "common/scummsys.h" #include "common/scummsys.h"
@ -32,16 +32,15 @@ namespace Cruise {
struct gfxEntryStruct; struct gfxEntryStruct;
struct cellStruct struct cellStruct {
{ struct cellStruct *next;
struct cellStruct* next; struct cellStruct *prev;
struct cellStruct* prev;
int16 idx; int16 idx;
int16 type; int16 type;
int16 overlay ; int16 overlay;
int16 field_A ; int16 field_A;
int16 field_C ; int16 field_C;
int16 spriteIdx ; int16 spriteIdx;
int16 field_10; int16 field_10;
int16 backgroundPlane; int16 backgroundPlane;
int16 freeze; int16 freeze;
@ -59,15 +58,17 @@ struct cellStruct
int16 field_2C; int16 field_2C;
int16 currentAnimDelay; int16 currentAnimDelay;
int16 field_30; int16 field_30;
gfxEntryStruct* gfxPtr; gfxEntryStruct *gfxPtr;
}; };
extern cellStruct cellHead; extern cellStruct cellHead;
void resetPtr(cellStruct* ptr); void resetPtr(cellStruct * ptr);
void loadSavegameDataSub2(FILE * f); 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 #endif

25
engines/cruise/cruise.cpp
View file

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

25
engines/cruise/cruise.h
View file

@ -22,8 +22,8 @@
* *
*/ */
#ifndef CRUISE_H #ifndef CRUISE_CRUISE_H
#define CRUISE_H #define CRUISE_CRUISE_H
#include "common/stdafx.h" #include "common/stdafx.h"
#include "common/scummsys.h" #include "common/scummsys.h"
@ -41,30 +41,30 @@ enum CruiseGameType {
struct CRUISEGameDescription; struct CRUISEGameDescription;
class CruiseEngine : public Engine { class CruiseEngine:public Engine {
protected: protected:
int init(); int init();
int go(); int go();
void shutdown(); void shutdown();
bool initGame(); bool initGame();
public: public:
CruiseEngine(OSystem *syst); CruiseEngine(OSystem * syst);
virtual ~CruiseEngine(); virtual ~ CruiseEngine();
int getGameType() const; int getGameType() const;
uint32 getFeatures() const; uint32 getFeatures() const;
Common::Language getLanguage() const; Common::Language getLanguage() const;
Common::Platform getPlatform() const; Common::Platform getPlatform() const;
bool loadSaveDirectory(void); bool loadSaveDirectory(void);
void makeSystemMenu(void); void makeSystemMenu(void);
const CRUISEGameDescription *_gameDescription; const CRUISEGameDescription *_gameDescription;
private: private:
void initialize(void); void initialize(void);
bool makeLoad(char *saveName); bool makeLoad(char *saveName);
void mainLoop(int bootScriptIdx); void mainLoop(int bootScriptIdx);
@ -99,8 +99,7 @@ enum {
kCmpLT = (1 << 2) kCmpLT = (1 << 2)
}; };
extern Common::SaveFileManager * g_saveFileMan; // TEMP
extern Common::SaveFileManager *g_saveFileMan; // TEMP
} // End of namespace Cruise } // 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_ #ifndef CRUISE_CRUISE_MAIN_H
#define _CRUISE_H_ #define CRUISE_CRUISE_MAIN_H
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
@ -66,35 +66,37 @@ namespace Cruise {
#define ASSERT_PTR assert #define ASSERT_PTR assert
#define ASSERT assert #define ASSERT assert
int32 decomp(uint8 * in, uint8 * out, int32 size); int32 decomp(uint8 * in, uint8 * out, int32 size);
ovlData3Struct* getOvlData3Entry(int32 scriptNumber, int32 param); ovlData3Struct *getOvlData3Entry(int32 scriptNumber, int32 param);
ovlData3Struct* scriptFunc1Sub2(int32 scriptNumber, int32 param); ovlData3Struct *scriptFunc1Sub2(int32 scriptNumber, int32 param);
int16 loadShort(void* ptr); int16 loadShort(void *ptr);
void resetFileEntry(int32 entryNumber); void resetFileEntry(int32 entryNumber);
void saveShort(void* ptr, int16 var); void saveShort(void *ptr, int16 var);
void* mallocAndZero(int32 size); void *mallocAndZero(int32 size);
uint8* mainProc14(uint16 overlay, uint16 idx); uint8 *mainProc14(uint16 overlay, uint16 idx);
void printInfoBlackBox(const char* string); void printInfoBlackBox(const char *string);
void waitForPlayerInput(void); void waitForPlayerInput(void);
int loadCtp(uint8* ctpName); int loadCtp(uint8 * ctpName);
void loadPakedFileToMem(int fileIdx, uint8* buffer); void loadPakedFileToMem(int fileIdx, uint8 * buffer);
int loadScriptSub1(int scriptIdx, int param); int loadScriptSub1(int scriptIdx, int param);
void resetFileEntryRange(int param1, int param2); void resetFileEntryRange(int param1, int param2);
int getProcParam(int overlayIdx, int param2, uint8* name); int getProcParam(int overlayIdx, int param2, uint8 * name);
void changeScriptParamInList(int param1, int param2, scriptInstanceStruct* pScriptInstance,int newValue, int param3); void changeScriptParamInList(int param1, int param2,
uint8* getDataFromData3(ovlData3Struct* ptr, int param); scriptInstanceStruct * pScriptInstance, int newValue, int param3);
int32 prepareWordRender(int32 param, int32 var1,int16* out2, uint8* ptr3,uint8* string); uint8 *getDataFromData3(ovlData3Struct * ptr, int param);
void removeExtention(const char* name, char* buffer); int32 prepareWordRender(int32 param, int32 var1, int16 * out2, uint8 * ptr3,
void resetRaster(uint8* rasterPtr, int32 rasterSize); uint8 * string);
void removeExtention(const char *name, char *buffer);
void resetRaster(uint8 * rasterPtr, int32 rasterSize);
void changeCursor(uint16 cursorType); void changeCursor(uint16 cursorType);
void resetPtr2(scriptInstanceStruct* ptr); void resetPtr2(scriptInstanceStruct * ptr);
void getFileExtention(const char* name,char* buffer); void getFileExtention(const char *name, char *buffer);
void *allocAndZero(int size); void *allocAndZero(int size);
void freeStuff2(void); void freeStuff2(void);
char* getObjectName(int index, uint8* string); char *getObjectName(int index, uint8 * string);
void mainLoop(void); void mainLoop(void);
} // End of namespace Cruise } // End of namespace Cruise
#endif #endif

290
engines/cruise/ctp.cpp
View file

@ -26,14 +26,14 @@
namespace Cruise { namespace Cruise {
ctpVar19Struct* ptr_something; ctpVar19Struct *ptr_something;
ctpVar19Struct* polyStruct; ctpVar19Struct *polyStruct;
ctpVar19Struct* ctpVar11; ctpVar19Struct *ctpVar11;
ctpVar19Struct* ctpVar13; ctpVar19Struct *ctpVar13;
ctpVar19Struct* ctpVar15; ctpVar19Struct *ctpVar15;
uint8* ctpVar17; uint8 *ctpVar17;
ctpVar19Struct* ctpVar19; ctpVar19Struct *ctpVar19;
int currentWalkBoxCenterX; int currentWalkBoxCenterX;
int currentWalkBoxCenterY; int currentWalkBoxCenterY;
@ -41,43 +41,43 @@ int currentWalkBoxCenterXBis;
int currentWalkBoxCenterYBis; int currentWalkBoxCenterYBis;
int ctpVarUnk; int ctpVarUnk;
uint8 walkboxTable[0x12]; uint8 walkboxTable[0x12];
int ctpProc2(int varX, int varY, int paramX, int paramY) int ctpProc2(int varX, int varY, int paramX, int paramY) {
{ int diffX = abs(paramX - varX);
int diffX = abs(paramX - varX);
int diffY = abs(paramY - varY); int diffY = abs(paramY - varY);
if(diffX > diffY) if (diffX > diffY) {
{
diffY = diffX; diffY = diffX;
} }
ctpVar14 = diffY; // highest difference ctpVar14 = diffY; // highest difference
return(diffY); return (diffY);
} }
// this function process path finding coordinates // 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 i;
int offset = 0; int offset = 0;
short int* cur_ctp_routeCoords = (short int*)ctp_routeCoords; // coordinates table short int *cur_ctp_routeCoords = (short int *)ctp_routeCoords; // coordinates table
int8* cur_ctp_routes = (int8*)ctp_routes; 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 varX = cur_ctp_routeCoords[0]; // x
int varY = cur_ctp_routeCoords[1]; // y int varY = cur_ctp_routeCoords[1]; // y
int di = 0; int di = 0;
int var4Offset = 2; 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); int idx = *(int16 *) (cur_ctp_routes + var4Offset);
ptr[offset + idx] = ctpProc2(varX , varY, ctp_routeCoords[idx][0], ctp_routeCoords[idx * 2][1]); ptr[offset + idx] =
ctpProc2(varX, varY, ctp_routeCoords[idx][0],
ctp_routeCoords[idx * 2][1]);
var4Offset += 2; var4Offset += 2;
di++; 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 minX = 1000;
int minY = 1000; int minY = 1000;
int maxX = -1; int maxX = -1;
int maxY = -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 ASSERT(_walkboxTable[boxIdx * 40]); // we should never have an empty walk box
if(_walkboxTable[boxIdx * 40] > 0) if (_walkboxTable[boxIdx * 40] > 0) {
{ int numPoints = _walkboxTable[boxIdx * 40];
int numPoints = _walkboxTable[boxIdx * 40]; uint16 *pCurrentPtr = _walkboxTable + (boxIdx * 40) + 1;
uint16* pCurrentPtr = _walkboxTable + (boxIdx * 40) + 1;
int i; int i;
for(i = 0; i < numPoints; i++) for (i = 0; i < numPoints; i++) {
{
int X = *(pCurrentPtr++); int X = *(pCurrentPtr++);
int Y = *(pCurrentPtr++);; int Y = *(pCurrentPtr++);;
if(X < minX) if (X < minX)
minX = X; minX = X;
if(X > maxX) if (X > maxX)
maxX = X; maxX = X;
if(Y < minY) if (Y < minY)
minY = Y; minY = Y;
if(Y > maxY) if (Y > maxY)
maxY = Y; maxY = Y;
} }
} }
@ -130,13 +127,13 @@ void getWalkBoxCenter(int boxIdx, uint16* _walkboxTable)
} }
// ax dx bx // 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 numPoints;
int wbSelf1; int wbSelf1;
int wbSelf2; int wbSelf2;
int i; int i;
int16* destination; int16 *destination;
wbSelf1 = upscaleValue(X1, scale) - X2; wbSelf1 = upscaleValue(X1, scale) - X2;
wbSelf2 = upscaleValue(Y1, scale) - Y2; 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; destination = polyBuffer2;
for(i = 0; i < numPoints; i++) for (i = 0; i < numPoints; i++) {
{
int pointX = *(walkboxData++); int pointX = *(walkboxData++);
int pointY = *(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; m_color = 0;
ctpVarUnk = 0; ctpVarUnk = 0;
for(i = 0; i < numPoints; i++) for (i = 0; i < numPoints; i++) {
{
walkboxTable[i] = i; walkboxTable[i] = i;
} }
drawPolyMode2((char*)walkboxTable, numPoints); drawPolyMode2((char *)walkboxTable, numPoints);
} }
// this process the walkboxes // 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 minX = 1000;
int minY = 1000; int minY = 1000;
int maxX = -1; int maxX = -1;
int maxY = -1; int maxY = -1;
ctpVar19Struct* var_1C; ctpVar19Struct *var_1C;
ctpVar19Struct* var_12; ctpVar19Struct *var_12;
int16* var_18; int16 *var_18;
int16* si; int16 *si;
// int16* di; // int16* di;
// uint8* cx; // uint8* cx;
// int bx; // int bx;
@ -188,236 +183,229 @@ void loadCtpSub1(int boxIdx, int scale, uint16* _walkboxTable, ctpVar19Struct* p
int var_E; int var_E;
//int var_C = 1000; //int var_C = 1000;
//int var_A = 0; //int var_A = 0;
ctpVar19SubStruct* subStruct; ctpVar19SubStruct *subStruct;
ASSERT(boxIdx <= 15); ASSERT(boxIdx <= 15);
if(_walkboxTable[boxIdx * 40] > 0) // is walkbox used ? if (_walkboxTable[boxIdx * 40] > 0) // is walkbox used ?
{ {
getWalkBoxCenter(boxIdx, _walkboxTable); getWalkBoxCenter(boxIdx, _walkboxTable);
currentWalkBoxCenterYBis = currentWalkBoxCenterY; currentWalkBoxCenterYBis = currentWalkBoxCenterY;
currentWalkBoxCenterXBis = currentWalkBoxCenterX; currentWalkBoxCenterXBis = currentWalkBoxCenterX;
// + 512 // + 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_1C = param4;
var_12 = var_1C + 1; // next var_12 = var_1C + 1; // next
var_18 = polyBuffer3; var_18 = polyBuffer3;
var_E = 0; var_E = 0;
si = &polyBuffer3[1]; si = &polyBuffer3[1];
/* if(*si>=0) /* if(*si>=0)
{ * {
di = si; * di = si;
cx = var_12; * cx = var_12;
*
do * do
{ * {
di++; * di++;
bx = di[-1]; * bx = di[-1];
ax = di[0]; * ax = di[0];
di++; * di++;
*
var_2 = ax; * var_2 = ax;
if(var_C < bx) * if(var_C < bx)
{ * {
var_C = bx; * var_C = bx;
} * }
*
if(var_2 < var_A) * if(var_2 < var_A)
{ * {
var_A = var_2; * var_A = var_2;
} * }
*
*cx = bx; * *cx = bx;
cx++; * cx++;
*cx = var_2; * *cx = var_2;
cx++; * cx++;
var_E ++; * var_E ++;
}while(di); * }while(di);
*
var_12 = cx; * var_12 = cx;
}*/ * } */
/*************/ /*************/
{ {
int i; int i;
int numPoints; int numPoints;
uint16* pCurrentPtr = _walkboxTable + boxIdx * 40; uint16 *pCurrentPtr = _walkboxTable + boxIdx * 40;
numPoints = *(pCurrentPtr++); numPoints = *(pCurrentPtr++);
for(i = 0; i < numPoints; i++) for (i = 0; i < numPoints; i++) {
{
int X = *(pCurrentPtr++); int X = *(pCurrentPtr++);
int Y = *(pCurrentPtr++); int Y = *(pCurrentPtr++);
if(X < minX) if (X < minX)
minX = X; minX = X;
if(X > maxX) if (X > maxX)
maxX = X; maxX = X;
if(Y < minY) if (Y < minY)
minY = Y; minY = Y;
if(Y > maxY) if (Y > maxY)
maxY = Y; maxY = Y;
} }
} }
/************/ /************/
var_1C->field_0 = var_12; var_1C->field_0 = var_12;
ctpVar13 = var_12; ctpVar13 = var_12;
var_12->field_0 = (ctpVar19Struct*)(-1); var_12->field_0 = (ctpVar19Struct *) (-1);
subStruct = &var_1C->subStruct; subStruct = &var_1C->subStruct;
subStruct->boxIdx = boxIdx; subStruct->boxIdx = boxIdx;
subStruct->type = walkboxType[boxIdx]; subStruct->type = walkboxType[boxIdx];
subStruct->minX = minX; subStruct->minX = minX;
subStruct->maxX = maxX; subStruct->maxX = maxX;
subStruct->minY = minY; subStruct->minY = minY;
subStruct->maxY = maxY; subStruct->maxY = maxY;
} }
} }
int loadCtp(uint8* ctpName) int loadCtp(uint8 *ctpName) {
{ int walkboxCounter; // si
int walkboxCounter; // si uint8 *ptr;
uint8* ptr; uint8 *dataPointer; // ptr2
uint8* dataPointer; // ptr2 char fileType[5]; // string2
char fileType[5]; // string2
short int segementSizeTable[7]; // tempTable short int segementSizeTable[7]; // tempTable
char string[32]; char string[32];
if(ctpVar1 == 0) if (ctpVar1 == 0) {
{
int i; int i;
for(i = 0; i < 10; i++) for (i = 0; i < 10; i++) {
{
persoTable[i] = NULL; persoTable[i] = NULL;
} }
} }
if(!loadFileSub1(&ptr,ctpName,0)) if (!loadFileSub1(&ptr, ctpName, 0)) {
{
free(ptr); free(ptr);
return(-18); return (-18);
} }
dataPointer = ptr; dataPointer = ptr;
fileType[4] = 0; 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; dataPointer += 4;
if(strcmp(fileType, "CTP ")) if (strcmp(fileType, "CTP ")) {
{
free(ptr); 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; dataPointer += 2;
flipShort(&ctp_routeCoordCount); flipShort(&ctp_routeCoordCount);
memcpy(segementSizeTable, dataPointer, 0xE); memcpy(segementSizeTable, dataPointer, 0xE);
dataPointer += 0xE; // + 14 dataPointer += 0xE; // + 14
flipGen(segementSizeTable, 0xE); flipGen(segementSizeTable, 0xE);
memcpy(ctp_routeCoords, dataPointer, segementSizeTable[0]); // get the path-finding coordinates memcpy(ctp_routeCoords, dataPointer, segementSizeTable[0]); // get the path-finding coordinates
dataPointer += segementSizeTable[0]; dataPointer += segementSizeTable[0];
flipGen(ctp_routeCoords, 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]; dataPointer += segementSizeTable[1];
flipGen(ctp_routes, 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]; dataPointer += segementSizeTable[2];
flipGen(ctp_walkboxTable, segementSizeTable[2]); flipGen(ctp_walkboxTable, segementSizeTable[2]);
if(ctpVar1) if (ctpVar1) {
{
dataPointer += segementSizeTable[3]; dataPointer += segementSizeTable[3];
dataPointer += segementSizeTable[4]; dataPointer += segementSizeTable[4];
} } else {
else
{
memcpy(walkboxType, dataPointer, segementSizeTable[3]); // get the walkbox type memcpy(walkboxType, dataPointer, segementSizeTable[3]); // get the walkbox type
dataPointer += segementSizeTable[3]; 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) 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]; dataPointer += segementSizeTable[4];
flipGen(walkboxChange, 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]; 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]; dataPointer += segementSizeTable[6];
flipGen(ctp_scale, segementSizeTable[6]); // ok flipGen(ctp_scale, segementSizeTable[6]); // ok
free(ptr); free(ptr);
strcpyuint8(string, currentCtpName); 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; polyStruct = ctpVar11 = ctpVar13 = ptr_something;
ptr = (uint8*) polyStruct; ptr = (uint8 *) polyStruct;
walkboxCounter = numberOfWalkboxes; walkboxCounter = numberOfWalkboxes;
while((--walkboxCounter) >= 0) while ((--walkboxCounter) >= 0) {
{
loadCtpSub1(walkboxCounter, 0, ctp_walkboxTable, ctpVar13); loadCtpSub1(walkboxCounter, 0, ctp_walkboxTable, ctpVar13);
} }
ctpVar15 = ctpVar13 + 1; // was after the -1 thing ctpVar15 = ctpVar13 + 1; // was after the -1 thing
walkboxCounter = numberOfWalkboxes; walkboxCounter = numberOfWalkboxes;
while(--walkboxCounter) while (--walkboxCounter) {
{ loadCtpSub1(walkboxCounter, ctp_scale[walkboxCounter] * 20,
loadCtpSub1(walkboxCounter, ctp_scale[walkboxCounter] * 20, ctp_walkboxTable, ctpVar13); ctp_walkboxTable, ctpVar13);
} }
//ctpVar17 = ctpVar13 - ptr + 4; //ctpVar17 = ctpVar13 - ptr + 4;
{ {
int numOfUsedEntries = ctpVar13 - (ctpVar19Struct*) ptr; 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... 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)); ctpVar13 = ctpVar11 = polyStruct =
(ctpVar19Struct *) malloc(numOfUsedEntries *
sizeof(ctpVar19Struct));
} }
walkboxCounter = numberOfWalkboxes; walkboxCounter = numberOfWalkboxes;
while((--walkboxCounter) >= 0) while ((--walkboxCounter) >= 0) {
{
loadCtpSub1(walkboxCounter, 0, ctp_walkboxTable, ctpVar13); loadCtpSub1(walkboxCounter, 0, ctp_walkboxTable, ctpVar13);
} }
ctpVar15 = ctpVar13 + 1; ctpVar15 = ctpVar13 + 1;
walkboxCounter = numberOfWalkboxes; walkboxCounter = numberOfWalkboxes;
while(--walkboxCounter) while (--walkboxCounter) {
{ loadCtpSub1(walkboxCounter, ctp_scale[walkboxCounter] * 20,
loadCtpSub1(walkboxCounter, ctp_scale[walkboxCounter] * 20, ctp_walkboxTable, ctpVar13); ctp_walkboxTable, ctpVar13);
} }
ctpVar19 = ctpVar11; ctpVar19 = ctpVar11;
return(1); return (1);
} }
} // End of namespace Cruise } // End of namespace Cruise

42
engines/cruise/ctp.h
View file

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

870
engines/cruise/dataLoader.cpp
View file

@ -26,15 +26,15 @@
namespace Cruise { namespace Cruise {
void loadSetEntry(uint8* name, uint8* ptr, int currentEntryIdx, int currentDestEntry); void loadSetEntry(uint8 * name, uint8 * ptr, int currentEntryIdx,
void loadFNTSub(uint8* ptr, int destIdx); int currentDestEntry);
void loadFNTSub(uint8 * ptr, int destIdx);
enum fileTypeEnum enum fileTypeEnum {
{ type_UNK,
type_UNK, type_SPL,
type_SPL, type_SET,
type_SET, type_FNT
type_FNT
}; };
typedef enum fileTypeEnum fileTypeEnum; typedef enum fileTypeEnum fileTypeEnum;
@ -43,384 +43,352 @@ int loadSingleFile;
// TODO: Unify decodeGfxFormat1, decodeGfxFormat4 and decodeGfxFormat5 // TODO: Unify decodeGfxFormat1, decodeGfxFormat4 and decodeGfxFormat5
void decodeGfxFormat1(dataFileEntry* pCurrentFileEntry) void decodeGfxFormat1(dataFileEntry *pCurrentFileEntry) {
{ uint8 *buffer;
uint8* buffer; uint8 *dataPtr = pCurrentFileEntry->subData.ptr;
uint8* dataPtr = pCurrentFileEntry->subData.ptr;
int spriteSize = pCurrentFileEntry->height * pCurrentFileEntry->widthInColumn * 8; int spriteSize =
int x = 0; pCurrentFileEntry->height * pCurrentFileEntry->widthInColumn * 8;
int x = 0;
buffer = (uint8*)malloc(spriteSize); buffer = (uint8 *) malloc(spriteSize);
while (x < spriteSize) while (x < spriteSize) {
{ uint8 c;
uint8 c; uint16 p0;
uint16 p0;
p0 = (dataPtr[0] << 8) | dataPtr[1]; p0 = (dataPtr[0] << 8) | dataPtr[1];
/* decode planes */ /* decode planes */
for (c = 0; c < 16; c++) for (c = 0; c < 16; c++) {
{ buffer[x + c] = ((p0 >> 15) & 1);
buffer[x+c] = ((p0 >> 15) & 1);
p0 <<= 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
} }
loadSetEntry(name, ptr, currentEntryIdx + i, startIdx + i);
}
break; x += 16;
}
case type_FNT: dataPtr += 2;
{
loadFNTSub(ptr, startIdx);
break;
}
case type_UNK:
{
break;
} }
case type_SPL:
{ pCurrentFileEntry->subData.ptr = buffer;
break;
}
}
return 0;
} }
int loadFullBundle(uint8* name, int startIdx) void decodeGfxFormat4(dataFileEntry *pCurrentFileEntry) {
{ uint8 *buffer;
uint8* ptr = NULL; uint8 *dataPtr = pCurrentFileEntry->subData.ptr;
fileTypeEnum fileType;
fileType = getFileType(name);
loadFileSub1(&ptr,name,NULL); int spriteSize =
pCurrentFileEntry->height * pCurrentFileEntry->widthInColumn * 2;
int x = 0;
switch(fileType) buffer = (uint8 *) malloc(spriteSize);
{
case type_SET:
{
int i;
int numMaxEntriesInSet;
numMaxEntriesInSet = getNumMaxEntiresInSet(ptr); // get maximum number of sprites/animations in SET file while (x < spriteSize) {
uint8 c;
for(i = 0; i < numMaxEntriesInSet; i++) uint16 p0;
{ uint16 p1;
loadSetEntry(name, ptr, i, startIdx+i); uint16 p2;
} uint16 p3;
break; p0 = (dataPtr[0] << 8) | dataPtr[1];
} p1 = (dataPtr[2] << 8) | dataPtr[3];
case type_FNT: p2 = (dataPtr[4] << 8) | dataPtr[5];
{ p3 = (dataPtr[6] << 8) | dataPtr[7];
loadFNTSub(ptr, startIdx);
break; /* decode planes */
} for (c = 0; c < 16; c++) {
case type_UNK: buffer[x + c] =
{ ((p0 >> 15) & 1) | ((p1 >> 14) & 2) | ((p2 >> 13) &
break; 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) void decodeGfxFormat5(dataFileEntry *pCurrentFileEntry) {
{ uint8 *buffer;
uint8* ptr2 = ptr; uint8 *dataPtr = pCurrentFileEntry->subData.ptr;
uint8* destPtr;
int fileIndex;
uint32 fontSize;
ptr2 += 4;
memcpy(&loadFileVar1, ptr2, 4);
flipLong(&loadFileVar1); int spriteSize =
pCurrentFileEntry->height * pCurrentFileEntry->widthInColumn;
int x = 0;
int range = pCurrentFileEntry->height * pCurrentFileEntry->width;
if(destIdx == -1) buffer = (uint8 *) malloc(spriteSize);
{
fileIndex = createResFileEntry(loadFileVar1, 1 ,1);
}
else
{
fileIndex = updateResFileEntry(loadFileVar1, 1, destIdx, 1);
}
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); /* decode planes */
flipLong(&fontSize); 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; int32 i;
uint8* currentPtr; uint8 *currentPtr;
destPtr = filesDatabase[fileIndex].subData.ptr; destPtr = filesDatabase[fileIndex].subData.ptr;
flipLong((int32*) destPtr); flipLong((int32 *) destPtr);
flipLong((int32*) (destPtr + 4)); flipLong((int32 *) (destPtr + 4));
flipGen(destPtr + 8, 6); flipGen(destPtr + 8, 6);
currentPtr = destPtr + 14; currentPtr = destPtr + 14;
for(i = 0; i < *(int16*) (destPtr + 8); i++) for (i = 0; i < *(int16 *) (destPtr + 8); i++) {
{ flipLong((int32 *) currentPtr);
flipLong((int32*) currentPtr);
currentPtr += 4; currentPtr += 4;
flipGen(currentPtr, 8); flipGen(currentPtr, 8);
@ -429,120 +397,124 @@ void loadFNTSub(uint8* ptr, int destIdx)
} }
} }
void loadSetEntry(uint8* name, uint8* ptr, int currentEntryIdx, int currentDestEntry) void loadSetEntry(uint8 *name, uint8 *ptr, int currentEntryIdx,
{ int currentDestEntry) {
uint8* ptr2; uint8 *ptr2;
uint8* ptr3; uint8 *ptr3;
int offset; int offset;
int sec = 0; int sec = 0;
uint16 numIdx; uint16 numIdx;
if (!strcmpuint8(ptr,"SEC"))
{
sec = 1;
}
ptr2 = ptr + 4; if (!strcmpuint8(ptr, "SEC")) {
sec = 1;
}
memcpy(&numIdx,ptr2,2); ptr2 = ptr + 4;
flipShort(&numIdx);
ptr3 = ptr + 6; memcpy(&numIdx, ptr2, 2);
flipShort(&numIdx);
offset = currentEntryIdx*16; ptr3 = ptr + 6;
{ offset = currentEntryIdx * 16;
uint8* ptr4;
int resourceSize;
int fileIndex;
setHeaderEntry localBuffer;
uint8* ptr5;
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); memcpy(&localBuffer, ptr4, sizeof(setHeaderEntry));
flipGen(&localBuffer.width, 12);
if ((sec == 1) || (localBuffer.type == 5)) flipLong((int32 *) & localBuffer.field_0);
{ flipGen(&localBuffer.width, 12);
localBuffer.width = localBuffer.width - (localBuffer.type * 2); // Type 1: Width - (1*2) , Type 5: Width - (5*2)
}
resourceSize = localBuffer.width * localBuffer.height;
if(currentDestEntry == -1) if ((sec == 1) || (localBuffer.type == 5)) {
{ localBuffer.width = localBuffer.width - (localBuffer.type * 2); // Type 1: Width - (1*2) , Type 5: Width - (5*2)
fileIndex = createResFileEntry(localBuffer.width,localBuffer.height,localBuffer.type); }
}
else
{
fileIndex = updateResFileEntry(localBuffer.height, localBuffer.width, currentDestEntry, localBuffer.type);
}
if(fileIndex < 0) resourceSize = localBuffer.width * localBuffer.height;
{
return; // TODO: buffer is not freed
}
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); if (fileIndex < 0) {
ptr5 += resourceSize; return; // TODO: buffer is not freed
}
switch(localBuffer.type) ptr5 = ptr3 + localBuffer.field_0 + numIdx * 16;
{
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;
}
}
filesDatabase[fileIndex].subData.index = currentDestEntry; memcpy(filesDatabase[fileIndex].subData.ptr, ptr5,
filesDatabase[fileIndex].subData.transparency = localBuffer.transparency; /*% 0x10*/; 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 } // End of namespace Cruise

12
engines/cruise/dataLoader.h
View file

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

10
engines/cruise/detection.cpp
View file

@ -31,6 +31,7 @@
#include "cruise/cruise.h" #include "cruise/cruise.h"
namespace Cruise { namespace Cruise {
struct CRUISEGameDescription { struct CRUISEGameDescription {
Common::ADGameDescription desc; Common::ADGameDescription desc;
@ -60,7 +61,7 @@ namespace Cruise {
static const CRUISEGameDescription gameDescriptions[] = { static const CRUISEGameDescription gameDescriptions[] = {
{ {
{ {
"cruise", "cruise",
"", "",
AD_ENTRY1("D1", "41a7a4d426dbd048eb369cfee4bb2717"), AD_ENTRY1("D1", "41a7a4d426dbd048eb369cfee4bb2717"),
@ -70,9 +71,9 @@ static const CRUISEGameDescription gameDescriptions[] = {
}, },
GType_CRUISE, GType_CRUISE,
0, 0,
}, },
{ {
{ {
"cruise", "cruise",
"", "",
AD_ENTRY1("D1", "a90d2b9ead6b4d812cd14268672cf178"), AD_ENTRY1("D1", "a90d2b9ead6b4d812cd14268672cf178"),
@ -83,7 +84,7 @@ static const CRUISEGameDescription gameDescriptions[] = {
GType_CRUISE, GType_CRUISE,
0, 0,
}, },
{ AD_TABLE_END_MARKER, 0, 0 } {AD_TABLE_END_MARKER, 0, 0}
}; };
} }
@ -117,6 +118,7 @@ namespace Cruise {
bool CruiseEngine::initGame() { bool CruiseEngine::initGame() {
_gameDescription = (const CRUISEGameDescription *)Common::AdvancedDetector::detectBestMatchingGame(detectionParams); _gameDescription = (const CRUISEGameDescription *)Common::AdvancedDetector::detectBestMatchingGame(detectionParams);
return (_gameDescription != 0); 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_ #ifndef CRUISE_FONT_H
#define _FONT_H_ #define CRUISE_FONT_H
namespace Cruise { namespace Cruise {
void loadFNT(const void* fileName); void loadFNT(const void *fileName);
void loadSystemFont(void); void loadSystemFont(void);
////////////////////////////////////////////////// //////////////////////////////////////////////////
void flipShort(int16* var); void flipShort(int16 * var);
void flipShort(uint16* var); void flipShort(uint16 * var);
void flipLong(int32* var); // TODO: move away void flipLong(int32 * var); // TODO: move away
void flipLong(uint32* var); // TODO: move away void flipLong(uint32 * var); // TODO: move away
void flipGen(void* var, int32 length); void flipGen(void *var, int32 length);
int32 getLineHeight(int16 charCount, uint8* fontPtr, uint8* fontPrt_Desc); // fontProc1 int32 getLineHeight(int16 charCount, uint8 * fontPtr, uint8 * fontPrt_Desc); // fontProc1
int32 getTextLineCount(int32 rightBorder_X, int32 wordSpacingWidth, uint8* ptr, uint8* textString); // fontProc2 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); void renderWord(uint8 * fontPtr_Data, uint8 * outBufferPtr,
gfxEntryStruct* renderText(int inRightBorder_X, uint8* string); int32 drawPosPixel_X, int32 heightOff, int32 height, int32 param4,
void drawString(int32 x, int32 y, uint8* string, uint8* buffer, uint8 color, int32 inRightBorder_X); 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 } // End of namespace Cruise

327
engines/cruise/fontCharacterTable.cpp
View file

@ -26,170 +26,169 @@
namespace Cruise { namespace Cruise {
int16 fontCharacterTable[256]={ 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, -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, 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, 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, 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, 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, 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, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
86, 87, 88, 89, 90, 91, 92, 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,
-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, 106, 105,
-1, -1,
-1, -1,
-1, -1,
-1, -1,
107, 108, 107, 108,
-1,-1, -1, -1,
109, 110, 109, 110,
-1, -1,
-1, -1,
-1, -1,
-1, -1,
-1,-1, -1, -1,
111, -1, 111, -1,
112, 112,
-1,-1, -1, -1,
113, 113,
114, 114,
-1, -1,
-1, -1,
116, 93, 116, 93,
-1, -1,
118, 118,
-1, -1,
94, 94,
-1, -1,
117, 117,
115, 115,
96, 96,
95, 95,
97, 97,
98, 98,
-1, -1,
-1, -1,
99, 99,
100, 100,
-1, -1,
-1, -1,
-1, -1,
-1, -1,
101, 101,
-1, -1,
102, 102,
-1, -1,
-1, -1,
103, 103,
-1, -1,
104, 104,
-1, -1,
-1, -1,
-1, -1,
-1, -1,
}; };
} // End of namespace Cruise } // End of namespace Cruise

8
engines/cruise/fontCharacterTable.h
View file

@ -22,14 +22,12 @@
* *
*/ */
#ifndef _FONTCHARACTERTABLE_H_ #ifndef CRUISE_FONTCHARACTERTABLE_H
#define _FONTCHARACTERTABLE_H_ #define CRUISE_FONTCHARACTERTABLE_H
namespace Cruise { namespace Cruise {
extern short int fontCharacterTable[256]; extern short int fontCharacterTable[256];
} // End of namespace Cruise } // End of namespace Cruise
#endif #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_ #ifndef CRUISE_FUNCTION_H
#define _FUNCTION_H_ #define CRUISE_FUNCTION_H
namespace Cruise { namespace Cruise {
@ -36,4 +36,3 @@ int16 subOp23(int param1, int param2);
} // End of namespace Cruise } // End of namespace Cruise
#endif #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_ #ifndef CRUISE_GFXMODULE_H
#define _GFXMODULE_H_ #define CRUISE_GFXMODULE_H
namespace Cruise { namespace Cruise {
struct gfxModuleDataStruct struct gfxModuleDataStruct {
{
int field_1; int field_1;
int useTandy; int useTandy;
int useEGA; int useEGA;
int useVGA; int useVGA;
uint8* pPage00; uint8 *pPage00;
uint8* pPage10; uint8 *pPage10;
}; };
struct palEntry struct palEntry {
{
uint8 R; uint8 R;
uint8 G; uint8 G;
uint8 B; uint8 B;
@ -51,22 +49,22 @@ typedef struct palEntry palEntry;
extern gfxModuleDataStruct gfxModuleData; extern gfxModuleDataStruct gfxModuleData;
extern palEntry lpalette[256]; extern palEntry lpalette[256];
extern short globalAtariScreen[320*200/4]; extern short globalAtariScreen[320 * 200 / 4];
void gfxModuleData_gfxClearFrameBuffer(uint8* ptr); void gfxModuleData_gfxClearFrameBuffer(uint8 * ptr);
void gfxModuleData_setPal(uint8* ptr); void gfxModuleData_setPal(uint8 * ptr);
void gfxModuleData_field_90(void); void gfxModuleData_field_90(void);
void gfxModuleData_gfxWaitVSync(void); void gfxModuleData_gfxWaitVSync(void);
void gfxModuleData_flip(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_field_64(char *sourceBuffer, int width, int height,
void gfxModuleData_gfxCopyScreen(char* sourcePtr,char* destPtr); char *dest, int x, int y, int color);
void gfxModuleData_field_60(char* sourcePtr, int width, int height, char* destPtr, int x, int y); 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_flipScreen(void);
void gfxModuleData_setPal256(int16* ptr); void gfxModuleData_setPal256(int16 * ptr);
void flip(void); void flip(void);
} // End of namespace Cruise } // End of namespace Cruise
#endif #endif

501
engines/cruise/linker.cpp
View file

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

7
engines/cruise/linker.h
View file

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

397
engines/cruise/menu.cpp
View file

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

14
engines/cruise/mouse.cpp
View file

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

8
engines/cruise/mouse.h
View file

@ -22,16 +22,16 @@
* *
*/ */
#ifndef _MOUSE_H_ #ifndef CRUISE_MOUSE_H
#define _MOUSE_H_ #define CRUISE_MOUSE_H
namespace Cruise { namespace Cruise {
extern int16 main10; 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 } // End of namespace Cruise
#endif #endif

476
engines/cruise/object.cpp
View file

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

32
engines/cruise/object.h
View file

@ -22,41 +22,41 @@
* *
*/ */
#ifndef _OBJECT_H_ #ifndef CRUISE_OBJECT_H
#define _OBJECT_H_ #define CRUISE_OBJECT_H
namespace Cruise { namespace Cruise {
struct gfxEntryStruct struct gfxEntryStruct {
{ uint8 *imagePtr;
uint8* imagePtr; int imageSize;
int imageSize; int fontIndex;
int fontIndex; int height;
int height; int width; // for font: max right border; for sprite: just width
int width; // for font: max right border; for sprite: just width
}; };
typedef struct gfxEntryStruct gfxEntryStruct; typedef struct gfxEntryStruct gfxEntryStruct;
#define OBJ_SPRITE 4 #define OBJ_SPRITE 4
struct objectParamsQuery struct objectParamsQuery {
{
int16 X; int16 X;
int16 Y; int16 Y;
int16 baseFileIdx; int16 baseFileIdx;
int16 fileIdx; int16 fileIdx;
int16 scale; int16 scale;
int16 var5; int16 var5;
int16 var6; int16 var6;
int16 var7; int16 var7;
}; };
typedef struct objectParamsQuery objectParamsQuery; typedef struct objectParamsQuery objectParamsQuery;
objDataStruct* getObjectDataFromOverlay(int ovlIdx,int objIdx); objDataStruct *getObjectDataFromOverlay(int ovlIdx, int objIdx);
int16 getSingleObjectParam(int16 overlayIdx,int16 param2,int16 param3,int16* returnParam); int16 getSingleObjectParam(int16 overlayIdx, int16 param2, int16 param3,
int16 getMultipleObjectParam(int16 overlayIdx,int16 objectIdx,objectParamsQuery* returnParam); int16 * returnParam);
int16 getMultipleObjectParam(int16 overlayIdx, int16 objectIdx,
objectParamsQuery * returnParam);
} // End of namespace Cruise } // 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_ #ifndef CRUISE_OVERLAY_H
#define _OVERLAY_H_ #define CRUISE_OVERLAY_H
namespace Cruise { namespace Cruise {
struct importScriptStruct struct importScriptStruct {
{ uint16 var0;
uint16 var0; uint16 var1;
uint16 var1; uint16 type;
uint16 type; uint16 offset;
uint16 offset; uint16 offsetToName;
uint16 offsetToName;
}; };
typedef struct importScriptStruct importScriptStruct; typedef struct importScriptStruct importScriptStruct;
struct exportEntryStruct struct exportEntryStruct {
{ uint16 var0;
uint16 var0; uint16 var2;
uint16 var2; uint16 var4;
uint16 var4; uint16 idx;
uint16 idx; uint16 offsetToName;
uint16 offsetToName;
}; };
typedef struct exportEntryStruct exportEntryStruct; typedef struct exportEntryStruct exportEntryStruct;
struct ovlData3Struct struct ovlData3Struct {
{ uint8 *dataPtr; //0
uint8* dataPtr; //0 short int sizeOfData; //4
short int sizeOfData; //4 short int offsetToSubData3; //6
short int offsetToSubData3; //6 short int offsetToImportData; //8
short int offsetToImportData; //8
short int offsetToSubData2; short int offsetToSubData2;
short int offsetToImportName; short int offsetToImportName;
short int offsetToSubData5; short int offsetToSubData5;
@ -68,52 +65,48 @@ struct ovlData3Struct
typedef struct ovlData3Struct ovlData3Struct; typedef struct ovlData3Struct ovlData3Struct;
struct stringEntryStruct struct stringEntryStruct {
{ char *string;
char* string;
short int length; short int length;
short int idx; short int idx;
}; };
typedef struct stringEntryStruct stringEntryStruct; typedef struct stringEntryStruct stringEntryStruct;
struct linkDataStruct struct linkDataStruct {
{ uint16 field_0;
uint16 field_0; uint16 field_2;
uint16 field_2; uint16 field_4;
uint16 field_4; uint16 varIdx;
uint16 varIdx; uint16 varNameOffset;
uint16 varNameOffset; uint16 stringIdx;
uint16 stringIdx; uint16 stringNameOffset;
uint16 stringNameOffset; uint16 procIdx;
uint16 procIdx; uint16 procNameOffset;
uint16 procNameOffset;
int16 field_12; int16 field_12;
int16 field_14; int16 field_14;
int16 field_16; int16 field_16;
int16 field_18; int16 field_18;
int16 field_1A; int16 field_1A;
int16 field_1C; int16 field_1C;
int16 field_1E; int16 field_1E;
int16 field_20; int16 field_20;
}; };
typedef struct linkDataStruct linkDataStruct; typedef struct linkDataStruct linkDataStruct;
struct importDataStruct struct importDataStruct {
{ uint16 var0; // 0
uint16 var0; // 0 uint16 var1; // 2
uint16 var1; // 2 uint16 linkType; // 4
uint16 linkType; // 4 uint16 linkIdx; // 6
uint16 linkIdx; // 6 uint16 nameOffset;
uint16 nameOffset;
}; };
typedef struct importDataStruct importDataStruct; typedef struct importDataStruct importDataStruct;
struct objDataStruct struct objDataStruct {
{
int16 var0; int16 var0;
int16 var1; int16 var1;
int16 var2; int16 var2;
@ -125,8 +118,7 @@ struct objDataStruct
typedef struct objDataStruct objDataStruct; typedef struct objDataStruct objDataStruct;
struct objectParams struct objectParams {
{
int16 X; int16 X;
int16 Y; int16 Y;
int16 baseFileIdx; int16 baseFileIdx;
@ -137,23 +129,22 @@ struct objectParams
typedef struct objectParams objectParams; typedef struct objectParams objectParams;
struct ovlDataStruct struct ovlDataStruct {
{ ovlData3Struct *data3Table;
ovlData3Struct* data3Table; uint8 *ptr1;
uint8* ptr1; objDataStruct *objDataTable;
objDataStruct* objDataTable; objectParams *objData2SourceTable;
objectParams* objData2SourceTable; objectParams *objData2WorkTable;
objectParams* objData2WorkTable; stringEntryStruct *stringTable;
stringEntryStruct* stringTable; exportEntryStruct *exportDataPtr;
exportEntryStruct* exportDataPtr; importDataStruct *importDataPtr;
importDataStruct* importDataPtr; linkDataStruct *linkDataPtr;
linkDataStruct* linkDataPtr; uint8 *specialString1;
uint8* specialString1; uint8 *specialString2;
uint8* specialString2; uint8 *importNamePtr;
uint8* importNamePtr; uint8 *exportNamesPtr;
uint8* exportNamesPtr; uint8 *data4Ptr;
uint8* data4Ptr; uint8 *ptr8;
uint8* ptr8;
unsigned short int numScripts1; unsigned short int numScripts1;
unsigned short int numScripts2; unsigned short int numScripts2;
unsigned short int numExport; unsigned short int numExport;
@ -174,10 +165,9 @@ struct ovlDataStruct
typedef struct ovlDataStruct ovlDataStruct; typedef struct ovlDataStruct ovlDataStruct;
struct overlayStruct struct overlayStruct {
{
char overlayName[14]; char overlayName[14];
ovlDataStruct* ovlData; ovlDataStruct *ovlData;
short int alreadyLoaded; short int alreadyLoaded;
char field_14; char field_14;
char field_15; char field_15;
@ -206,11 +196,10 @@ extern overlayStruct overlayTable[90];
extern int numOfLoadedOverlay; extern int numOfLoadedOverlay;
void initOverlayTable(void); void initOverlayTable(void);
int loadOverlay(uint8* scriptName); int loadOverlay(uint8 * scriptName);
int32 findOverlayByName2(uint8* name); int32 findOverlayByName2(uint8 * name);
int findOverlayByName(const char* overlayName); int findOverlayByName(const char *overlayName);
int releaseOverlay(const char* name); int releaseOverlay(const char *name);
} // End of namespace Cruise } // End of namespace Cruise

309
engines/cruise/perso.cpp
View file

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

29
engines/cruise/perso.h
View file

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

63
engines/cruise/polys.cpp
View file

@ -23,6 +23,7 @@
*/ */
#include "cruise/cruise_main.h" #include "cruise/cruise_main.h"
#include "common/util.h"
namespace Cruise { namespace Cruise {
@ -34,10 +35,6 @@ typedef char ColorP;
#define SCREENHEIGHT 200 #define SCREENHEIGHT 200
#define MAXPTS 10 #define MAXPTS 10
#define putdot(x,y) {if ((y >= 0) && (y < SCREENHEIGHT)) dots[y][counters[y]++] = x;} #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) { void hline(int x1, int x2, int y, char c) {
for (; x1 <= x2; x1++) { 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) { void bsubline_2(int x1, int y1, int x2, int y2, char c) {
int x, y, ddx, ddy, e; 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); SWAP(y1, y2);
} }
for (y = y1, x = x1; y <= y2; y++) { for (y = y1, x = x1; y <= y2; y++) {
pixel(x, y, c); 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; ddx = abs(x1 - x2) << 1;
ddy = abs(y2 - y1); ddy = abs(y2 - y1);
e = ddy - ddx; e = ddy - ddx;
ddy <<= 1; ddy <<= 1;
if (y1 > y2) { if (y1 > y2) {
@ -116,7 +113,6 @@ void bsubline_3(int x1, int y1, int x2, int y2, char c) {
SWAP(y1, y2); SWAP(y1, y2);
} }
for (y = y1, x = x1; y <= y2; y++) { for (y = y1, x = x1; y <= y2; y++) {
pixel(x, y, c); 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; ddy = abs(y2 - y1) << 1;
ddx = abs(x1 - x2); ddx = abs(x1 - x2);
e = ddx - ddy; e = ddx - ddy;
ddx <<= 1; ddx <<= 1;
if (x1 > x2) { 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); bsubline_4(x1, y1, x2, y2, c);
} else { } else {
bsubline_3(x1, y1, x2, y2, c); 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 dots[SCREENHEIGHT][MAXPTS];
static int counters[SCREENHEIGHT]; static int counters[SCREENHEIGHT];
short int x1, y1, x2, y2; short int x1, y1, x2, y2;
int i, j, k, dir = -2; int i, j, k, dir = -2;
double step, curx; double step, curx;
switch (lineCount) switch (lineCount) {
{ case 0: // do nothing
case 0: // do nothing return;
return; case 1: // draw pixel
case 1: // draw pixel pixel(datas[0], datas[1], color);
pixel(datas[0], datas[1], color); return;
return; case 2: // draw line
case 2: // draw line line(datas[0], datas[1], datas[2], datas[3], color);
line(datas[0], datas[1], datas[2], datas[3], color); return;
return; default: // go on and draw polygon
default: // go on and draw polygon break;
break;
} }
// Reinit array counters // Reinit array counters
for (i = 0; i < SCREENHEIGHT; i++) for (i = 0; i < SCREENHEIGHT; i++) {
{
counters[i] = 0; counters[i] = 0;
} }
// Drawing lines // Drawing lines
@ -230,18 +223,14 @@ void fillpoly(short int* datas, int lineCount, ColorP color)
// line(x1, y1, x2, y2, color); // line(x1, y1, x2, y2, color);
// continue; // continue;
if (y1 == y2) if (y1 == y2) {
{
// printf("Horizontal line. x1: %i, y1: %i, x2: %i, y2: %i\n", x1, y1, x2, y2); // printf("Horizontal line. x1: %i, y1: %i, x2: %i, y2: %i\n", x1, y1, x2, y2);
if (dir) if (dir) {
{
putdot(x1, y1); putdot(x1, y1);
dir = 0; dir = 0;
} }
} } else {
else step = (double)(x2 - x1) / (y2 - y1);
{
step = (double) (x2 - x1) / (y2 - y1);
// printf("x1: %i, y1 = %i, x2 = %i, y2 = %i, step: %f\n", x1, y1, x2, y2, step); // 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]; x2 = datas[0];
y2 = datas[1]; 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); // printf("Adding final extra (%i, %i)\n", x1, y1);
putdot(x1, y1); putdot(x1, y1);
} }
// NOTE: all counters should be even now. If not, this is a bad (color) thing :-P // NOTE: all counters should be even now. If not, this is a bad (color) thing :-P
// Sorting datas // 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... // 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 (j = 0; j < (counters[i] - 1); j++) {
for (k = 0; k < (counters[i] - 1); k++) { 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; int temp;
temp = dots[i][k]; temp = dots[i][k];
dots[i][k] = dots[i][k + 1]; dots[i][k] = dots[i][k + 1];
@ -320,4 +308,3 @@ void fillpoly(short int* datas, int lineCount, ColorP color)
} }
} // End of namespace Cruise } // 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 { namespace Cruise {
typedef char ColorP; 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); void line(int x1, int y1, int x2, int y2, ColorP color);
} // End of namespace Cruise } // End of namespace Cruise
#endif

636
engines/cruise/saveload.cpp
View file

@ -26,418 +26,388 @@
namespace Cruise { namespace Cruise {
void loadSavegameDataSub1(FILE* fileHandle) void loadSavegameDataSub1(FILE *fileHandle) {
{ int i;
int i;
for(i=1;i<numOfLoadedOverlay;i++) for (i = 1; i < numOfLoadedOverlay; i++) {
{ filesData[i].field_4 = NULL;
filesData[i].field_4 = NULL; filesData[i].field_0 = NULL;
filesData[i].field_0 = NULL; filesData2[i].field_0 = 0;
filesData2[i].field_0 = 0;
if(overlayTable[i].alreadyLoaded) if (overlayTable[i].alreadyLoaded) {
{ fread(&filesData2[i].field_0, 2, 1, fileHandle);
fread(&filesData2[i].field_0,2,1,fileHandle);
if(filesData2[i].field_0) if (filesData2[i].field_0) {
{ filesData[i].field_0 =
filesData[i].field_0 = (uint8*)mallocAndZero(filesData2[i].field_0); (uint8 *) mallocAndZero(filesData2[i].
if(filesData[i].field_0) field_0);
{ if (filesData[i].field_0) {
fread(filesData[i].field_0,filesData2[i].field_0,1,fileHandle); 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) if (filesData2[i].field_2) {
{ filesData[i].field_4 =
filesData[i].field_4 = (uint8*)mallocAndZero(filesData2[i].field_2*12); (uint8 *) mallocAndZero(filesData2[i].
if(filesData[i].field_4) field_2 * 12);
{ if (filesData[i].field_4) {
fread(filesData[i].field_4,filesData2[i].field_2*12,1,fileHandle); fread(filesData[i].field_4,
} filesData2[i].field_2 * 12, 1,
} fileHandle);
} }
} }
}
}
} }
void loadScriptsFromSave(FILE* fileHandle,scriptInstanceStruct* entry) void loadScriptsFromSave(FILE *fileHandle, scriptInstanceStruct *entry) {
{ short int numScripts;
short int numScripts; int i;
int i;
fread(&numScripts,2,1,fileHandle); fread(&numScripts, 2, 1, fileHandle);
for(i=0;i<numScripts;i++) for (i = 0; i < numScripts; i++) {
{ scriptInstanceStruct *ptr =
scriptInstanceStruct* ptr = (scriptInstanceStruct*)mallocAndZero(sizeof(scriptInstanceStruct)); (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) if (ptr->varA) {
{ ptr->var6 = (uint8 *) mallocAndZero(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->nextScriptPtr = 0;
ptr->bitMask = *((int16*)ptr+1);
/////////
ptr->nextScriptPtr = 0; entry->nextScriptPtr = ptr;
entry = ptr;
entry->nextScriptPtr = ptr; }
entry = ptr;
}
} }
void loadSavegameActor(FILE* fileHandle) void loadSavegameActor(FILE *fileHandle) {
{ short int numEntry;
short int numEntry; actorStruct *ptr;
actorStruct* ptr; int i;
int i;
fread(&numEntry,2,1,fileHandle); fread(&numEntry, 2, 1, fileHandle);
ptr = &actorHead; ptr = &actorHead;
for(i=0;i<numEntry;i++) for (i = 0; i < numEntry; i++) {
{ actorStruct *current =
actorStruct* current = (actorStruct*)mallocAndZero(sizeof(actorStruct)); (actorStruct *) mallocAndZero(sizeof(actorStruct));
fseek(fileHandle, 4, SEEK_CUR); fseek(fileHandle, 4, SEEK_CUR);
fread(current,0x26,1,fileHandle); fread(current, 0x26, 1, fileHandle);
current->next = NULL; current->next = NULL;
ptr->next = current; ptr->next = current;
current->prev = actorHead.prev; current->prev = actorHead.prev;
actorHead.prev = current; actorHead.prev = current;
ptr = current->next; ptr = current->next;
} }
} }
void loadSavegameDataSub5(FILE* fileHandle) void loadSavegameDataSub5(FILE *fileHandle) {
{ if (var1) {
if(var1) fread(&saveVar1, 1, 1, fileHandle);
{
fread(&saveVar1,1,1,fileHandle);
if(saveVar1) if (saveVar1) {
{ fread(saveVar2, saveVar1, 1, fileHandle);
fread(saveVar2,saveVar1,1,fileHandle); }
} } else {
} fread(&saveVar1, 1, 1, fileHandle);
else }
{
fread(&saveVar1,1,1,fileHandle);
}
} }
void loadSavegameDataSub6(FILE* fileHandle) void loadSavegameDataSub6(FILE *fileHandle) {
{ int32 var;
int32 var;
fread(&var,4,1,fileHandle); fread(&var, 4, 1, fileHandle);
flipLong(&var); flipLong(&var);
if(var) if (var) {
{ int i;
int i;
fread(&numberOfWalkboxes, 2, 1, fileHandle);
if(numberOfWalkboxes) fread(&numberOfWalkboxes, 2, 1, fileHandle);
{
fread(walkboxType, numberOfWalkboxes * 2, 1, fileHandle);
fread(walkboxType, numberOfWalkboxes * 2, 1, fileHandle);
}
for(i=0;i<10;i++) if (numberOfWalkboxes) {
{ fread(walkboxType, numberOfWalkboxes * 2, 1,
fread(&persoTable[i],4,1,fileHandle); fileHandle);
fread(walkboxType, numberOfWalkboxes * 2, 1,
fileHandle);
}
if(persoTable[i]) for (i = 0; i < 10; i++) {
{ fread(&persoTable[i], 4, 1, fileHandle);
assert(sizeof(persoStruct) == 0x6AA);
persoTable[i] = (persoStruct*)mallocAndZero(sizeof(persoStruct)); if (persoTable[i]) {
fread(persoTable[i],0x6AA,1,fileHandle); 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) sprintf(buffer, "CR.%d", saveGameIdx);
{
char buffer[256];
FILE* fileHandle;
char saveIdentBuffer[6];
int j;
int initVar1Save;
cellStruct* currentcellHead;
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("Chargement en cours...");
{
printInfoBlackBox("Sauvegarde non trouvée...");
waitForPlayerInput();
return(-1);
}
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")) fread(&var1, 2, 1, fileHandle);
{ fread(&var2, 2, 1, fileHandle);
fclose(fileHandle); fread(&var3, 2, 1, fileHandle);
return(-1); 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(&video4, 2, 1, fileHandle);
fread(&var2,2,1,fileHandle); fread(&video2, 2, 1, fileHandle);
fread(&var3,2,1,fileHandle); fread(&video3, 2, 1, fileHandle);
fread(&var4,2,1,fileHandle); fread(&colorOfSelectedSaveDrive, 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);
// video param (not loaded in EGA mode) //
fread(&video4,2,1,fileHandle); fread(&var30, 2, 1, fileHandle);
fread(&video2,2,1,fileHandle); fread(&var31, 2, 1, fileHandle);
fread(&video3,2,1,fileHandle); fread(&var34, 2, 1, fileHandle);
fread(&colorOfSelectedSaveDrive,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); loadSavegameDataSub1(fileHandle);
fread(&var31,2,1,fileHandle); loadScriptsFromSave(fileHandle, &scriptHandle2);
fread(&var34,2,1,fileHandle); loadScriptsFromSave(fileHandle, &scriptHandle1);
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); loadSavegameDataSub2(fileHandle);
fread(var50,64,1,fileHandle); // Hu ? why 2 times ? loadBackgroundIncrustFromSave(fileHandle);
fread(&systemStrings,sizeof(systemStrings),1,fileHandle); // ok loadSavegameActor(fileHandle);
fread(currentCtpName,40,1,fileHandle); loadSavegameDataSub5(fileHandle);
fread(backgroundTable,120,1,fileHandle); loadSavegameDataSub6(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);
loadSavegameDataSub1(fileHandle); fclose(fileHandle); // finished with loading !!!!! Yatta !
loadScriptsFromSave(fileHandle,&scriptHandle2);
loadScriptsFromSave(fileHandle,&scriptHandle1);
loadSavegameDataSub2(fileHandle); for (j = 0; j < 64; j++) {
loadBackgroundIncrustFromSave(fileHandle); mediumVar[j].ptr = NULL;
loadSavegameActor(fileHandle); }
loadSavegameDataSub5(fileHandle);
loadSavegameDataSub6(fileHandle);
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++) if (overlayTable[j].alreadyLoaded) {
{ ovlDataStruct *ovlData =
mediumVar[j].ptr=NULL; overlayTable[j].ovlData;
}
for(j=1;j<numOfLoadedOverlay;j++) if (filesData[j].field_0) {
{ if (ovlData->data4Ptr) {
if(overlayTable[j].alreadyLoaded) free(ovlData->data4Ptr);
{ }
overlayTable[j].alreadyLoaded = 0;
loadOverlay((uint8*)overlayTable[j].overlayName);
if(overlayTable[j].alreadyLoaded) ovlData->data4Ptr =
{ (uint8 *) filesData[j].field_0;
ovlDataStruct* ovlData = overlayTable[j].ovlData; ovlData->sizeOfData4 =
filesData2[j].field_0;
}
if(filesData[j].field_0) if (filesData[j].field_4) {
{ if (ovlData->objData2WorkTable) {
if(ovlData->data4Ptr) free(ovlData->
{ objData2WorkTable);
free(ovlData->data4Ptr); }
}
ovlData->data4Ptr = (uint8*)filesData[j].field_0; ovlData->objData2WorkTable = (objectParams *) filesData[j].field_4; // TODO: fix !
ovlData->sizeOfData4 = filesData2[j].field_0; 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 ! updateAllScriptsImports();
ovlData->size9 = filesData2[j].field_2;
}
} 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++) for (k = j; k < i; k++) {
{ if (filesDatabase[k].subData.ptr2)
if(filesDatabase[j].subData.ptr) initVar1 = 0;
{
int i;
int k;
for(i=j+1;i<257;i++) filesDatabase[k].subData.ptr = NULL;
{ filesDatabase[k].subData.ptr2 = NULL;
if(filesDatabase[i].subData.ptr) }
{
if(strcmpuint8(filesDatabase[j].subData.name,filesDatabase[i].subData.name))
{
break;
}
}
else
{
break;
}
}
for(k=j;k<i;k++) if (i < 2) {
{ printf("Unsupported mono file load!\n");
if(filesDatabase[k].subData.ptr2) exit(1);
initVar1 = 0; //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; initVar1 = initVar1Save;
filesDatabase[k].subData.ptr2 = NULL; }
} }
if(i<2) saveVar6[0] = 0;
{
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;
}
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 (ptr) {
{ ASSERT(0);
if(currentcellHead->type == 5) //*(int16*)(currentcellHead->datas+0x2E) = getSprite(ptr,*(int16*)(currentcellHead->datas+0xE));
{ } else {
uint8* ptr = mainProc14(currentcellHead->overlay,currentcellHead->idx); //*(int16*)(currentcellHead->datas+0x2E) = 0;
}
}
ASSERT(0); currentcellHead = currentcellHead->next;
}
if(ptr) //TODO: here, restart music
{
ASSERT(0);
//*(int16*)(currentcellHead->datas+0x2E) = getSprite(ptr,*(int16*)(currentcellHead->datas+0xE));
}
else
{
//*(int16*)(currentcellHead->datas+0x2E) = 0;
}
}
currentcellHead = currentcellHead->next; if (strlen((char *)currentCtpName)) {
} ctpVar1 = 1;
loadCtp(currentCtpName);
ctpVar1 = 0;
}
//prepareFadeOut();
//gfxModuleData.gfxFunction8();
//TODO: here, restart music for (j = 0; j < 8; j++) {
if (strlen((char *)backgroundTable[j].name)) {
if(strlen((char*)currentCtpName)) loadBackground(backgroundTable[j].name, j);
{ }
ctpVar1 = 1; }
loadCtp(currentCtpName);
ctpVar1 = 0;
}
//prepareFadeOut(); regenerateBackgroundIncrust(&backgroundIncrustHead);
//gfxModuleData.gfxFunction8();
for(j=0;j<8;j++) // to finish
{
if(strlen((char*)backgroundTable[j].name))
{
loadBackground(backgroundTable[j].name,j);
}
}
regenerateBackgroundIncrust(&backgroundIncrustHead); changeCursor(0);
mainDraw(1);
flipScreen();
// to finish return (0);
changeCursor(0);
mainDraw(1);
flipScreen();
return(0);
} }
} // End of namespace Cruise } // End of namespace Cruise

4
engines/cruise/saveload.h
View file

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

65
engines/cruise/stack.cpp
View file

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

31
engines/cruise/stack.h
View file

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

20
engines/cruise/stringSupport.cpp
View file

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

12
engines/cruise/stringSupport.h
View file

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

206
engines/cruise/various.cpp
View file

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

15
engines/cruise/various.h
View file

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

32
engines/cruise/vars.cpp
View file

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

135
engines/cruise/vars.h
View file

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

357
engines/cruise/volume.cpp
View file

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

16
engines/cruise/volume.h
View file

@ -22,23 +22,23 @@
* *
*/ */
#ifndef _VOLUME_H_ #ifndef CRUISE_VOLUME_H
#define _VOLUME_H_ #define CRUISE_VOLUME_H
namespace Cruise { namespace Cruise {
int16 readVolCnf(void); int16 readVolCnf(void);
int16 findFileInDisks(uint8* fileName); int16 findFileInDisks(uint8 * fileName);
int16 fileExist(uint8* fileName); int16 fileExist(uint8 * fileName);
void freeDisk(void); void freeDisk(void);
int16 findFileInList(uint8* fileName); int16 findFileInList(uint8 * fileName);
//////////////// ////////////////
void strToUpper(uint8* fileName); void strToUpper(uint8 * fileName);
void drawMsgString(uint8* string); void drawMsgString(uint8 * string);
void askDisk(int16 discNumber); 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 } // End of namespace Cruise