scummvm/engines/cruise/volume.cpp
2008-09-08 14:00:26 +00:00

494 lines
9.5 KiB
C++

/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
#include "cruise/cruise_main.h"
namespace Cruise {
FILE *PAL_fileHandle = NULL;
uint8 *PAL_ptr = NULL;
int16 numLoadedPal;
int16 fileData2;
char currentBaseName[15] = "";
void loadPal(volumeDataStruct *entry) {
char name[20];
return;
if (PAL_fileHandle) {
fclose(PAL_fileHandle);
}
removeExtention(entry->ident, name);
strcat(name, ".PAL");
// FIXME: using fopen/fread is not portable. Use Common::File instead
PAL_fileHandle = fopen(name, "rb");
fread(&numLoadedPal, 2, 1, PAL_fileHandle);
fread(&fileData2, 2, 1, PAL_fileHandle);
flipShort(&numLoadedPal);
flipShort(&fileData2);
PAL_ptr = (uint8 *) malloc(numLoadedPal * fileData2);
}
void closePal(void)
{
if(PAL_fileHandle)
{
fclose(PAL_fileHandle);
free(PAL_ptr);
PAL_ptr = NULL;
numLoadedPal = 0;
fileData2 = 0;
}
}
int closeBase(void)
{
if(currentVolumeFile.isOpen())
{
currentVolumeFile.close();
free(volumePtrToFileDescriptor);
strcpy(currentBaseName, "");
}
if(PAL_fileHandle) {
closePal();
}
return 0;
}
int getVolumeDataEntry(volumeDataStruct *entry) {
char buffer[256];
int i;
volumeNumEntry = 0;
volumeNumberOfEntry = 0;
if (currentVolumeFile.isOpen()) {
freeDisk();
}
askDisk(-1);
strcpy(buffer, entry->ident);
currentVolumeFile.open(buffer);
if (!currentVolumeFile.isOpen()) {
return (-14);
}
changeCursor(CURSOR_DISK);
currentVolumeFile.read(&volumeNumberOfEntry, 2);
currentVolumeFile.read(&volumeSizeOfEntry, 2);
flipShort(&volumeNumberOfEntry);
flipShort(&volumeSizeOfEntry);
volumeNumEntry = volumeNumberOfEntry;
assert(volumeSizeOfEntry == 14 + 4 + 4 + 4 + 4);
volumePtrToFileDescriptor = (fileEntry *) mallocAndZero(sizeof(fileEntry) * volumeNumEntry);
for (i = 0; i < volumeNumEntry; i++) {
volumePtrToFileDescriptor[i].name[0] = 0;
volumePtrToFileDescriptor[i].offset = 0;
volumePtrToFileDescriptor[i].size = 0;
volumePtrToFileDescriptor[i].extSize = 0;
volumePtrToFileDescriptor[i].unk3 = 0;
}
for (i = 0; i < volumeNumEntry; i++) {
currentVolumeFile.read(&volumePtrToFileDescriptor[i].name, 14);
currentVolumeFile.read(&volumePtrToFileDescriptor[i].offset, 4);
currentVolumeFile.read(&volumePtrToFileDescriptor[i].size, 4);
currentVolumeFile.read(&volumePtrToFileDescriptor[i].extSize, 4);
currentVolumeFile.read(&volumePtrToFileDescriptor[i].unk3, 4);
}
for (i = 0; i < volumeNumEntry; i++) {
flipLong(&volumePtrToFileDescriptor[i].offset);
flipLong(&volumePtrToFileDescriptor[i].size);
flipLong(&volumePtrToFileDescriptor[i].extSize);
}
strcpy(currentBaseName, entry->ident);
loadPal(entry);
return 0;
}
int searchFileInVolCnf(const char *fileName, int32 diskNumber) {
int foundDisk = -1;
int i;
for (i = 0; i < numOfDisks; i++) {
if (volumeData[i].diskNumber == diskNumber) {
int j;
int numOfEntry = volumeData[i].size / 13;
for (j = 0; j < numOfEntry; j++) {
if (!strcmp(volumeData[i].ptr[j].name, fileName)) {
return (i);
}
}
}
}
return (foundDisk);
}
int32 findFileInDisksSub1(const char *fileName) {
int foundDisk = -1;
int i;
for (i = 0; i < numOfDisks; i++) {
int j;
int numOfEntry = volumeData[i].size / 13;
for (j = 0; j < numOfEntry; j++) {
if (!strcmp(volumeData[i].ptr[j].name, fileName)) {
return (i);
}
}
}
return (foundDisk);
}
void strToUpper(char *fileName) {
char character;
do {
character = *fileName;
if (character >= 'a' && character <= 'z') {
character &= 0xDF;
*fileName = character;
}
fileName++;
} while (character);
}
void freeDisk(void) {
if (currentVolumeFile.isOpen()) {
currentVolumeFile.close();
free(volumePtrToFileDescriptor);
}
/* TODO
* if (PAL_fileHandle)
* {
* freeAllDataPtr();
* }
*/
}
int16 findFileInList(char *fileName) {
int i;
if (!currentVolumeFile.isOpen()) {
return (-1);
}
strToUpper(fileName);
if (volumeNumEntry <= 0) {
return (-1);
}
for (i = 0; i < volumeNumEntry; i++) {
if (!strcmp(volumePtrToFileDescriptor[i].name, fileName)) {
return (i);
}
}
return (-1);
}
void askDisk(int16 discNumber) {
char fileName[256];
char string[256];
char messageDrawn = 0;
if (discNumber != -1) {
currentDiskNumber = discNumber;
}
// skip drive selection stuff
sprintf(fileName, "VOL.%d", currentDiskNumber);
sprintf(string, "INSERER LE DISQUE %d EN ", currentDiskNumber);
//while (Common::File::exists((const char*)fileName))
{
if (!messageDrawn) {
drawMsgString(string);
messageDrawn = 1;
}
}
changeCursor(currentCursor);
}
int16 findFileInDisks(char *fileName) {
int disk;
int fileIdx;
strToUpper(fileName);
if (!volumeDataLoaded) {
printf("CNF wasn't loaded, reading now...\n");
if (currentVolumeFile.isOpen()) {
askDisk(-1);
freeDisk();
}
askDisk(1);
readVolCnf();
}
if (currentVolumeFile.isOpen()) {
askDisk(-1);
}
fileIdx = findFileInList(fileName);
if (fileIdx >= 0) {
return (fileIdx);
}
disk = searchFileInVolCnf(fileName, currentDiskNumber);
if (disk >= 0) {
int temp;
printf("File found on disk %d\n", disk);
if (currentVolumeFile.isOpen()) {
askDisk(-1);
}
freeDisk();
askDisk(volumeData[disk].diskNumber);
getVolumeDataEntry(&volumeData[disk]);
temp = findFileInList(fileName);
if (temp >= 0)
return (temp);
return (-1);
} else {
int temp;
temp = findFileInDisksSub1(fileName);
if (temp >= 0) {
int temp2;
askDisk(volumeData[temp].diskNumber);
getVolumeDataEntry(&volumeData[temp]);
temp2 = findFileInList(fileName);
if (temp2 >= 0)
return (temp2);
}
return (-1);
}
}
int closeCnf(void) {
for(long int i=0; i<numOfDisks; i++) {
if(volumeData[i].ptr) {
free(volumeData[i].ptr);
volumeData[i].ptr = NULL;
}
}
volumeDataLoaded = 0;
return 0;
}
int16 readVolCnf(void) {
int i;
Common::File fileHandle;
short int sizeHEntry;
volumeDataLoaded = 0;
for (i = 0; i < 20; i++) {
volumeData[i].ident[0] = 0;
volumeData[i].ptr = NULL;
volumeData[i].diskNumber = i + 1;
volumeData[i].size = 0;
}
fileHandle.open("VOL.CNF");
if (!fileHandle.isOpen()) {
return (0);
}
fileHandle.read(&numOfDisks, 2);
flipShort(&numOfDisks);
fileHandle.read(&sizeHEntry, 2);
flipShort(&sizeHEntry); // size of one header entry - 20 bytes
for (i = 0; i < numOfDisks; i++) {
// fread(&volumeData[i],20,1,fileHandle);
fileHandle.read(&volumeData[i].ident, 10);
fileHandle.read(&volumeData[i].ptr, 4);
fileHandle.read(&volumeData[i].diskNumber, 2);
fileHandle.read(&volumeData[i].size, 4);
flipShort(&volumeData[i].diskNumber);
printf("Disk number: %d\n", volumeData[i].diskNumber);
flipLong(&volumeData[i].size);
}
for (i = 0; i < numOfDisks; i++) {
dataFileName *ptr;
fileHandle.read(&volumeData[i].size, 4);
flipLong(&volumeData[i].size);
ptr = (dataFileName *) mallocAndZero(volumeData[i].size);
volumeData[i].ptr = ptr;
if (!ptr) {
fileHandle.close();
return (-2);
}
fileHandle.read(ptr, volumeData[i].size);
}
fileHandle.close();
volumeDataLoaded = 1;
//#define dumpResources
#ifdef dumpResources
for (i = 0; i < numOfDisks; i++) {
int j;
char nameBuffer[256];
fileEntry *buffer;
sprintf(nameBuffer, "D%d.", i + 1);
fileHandle.open(nameBuffer);
short int numEntry;
short int sizeEntry;
numEntry = fileHandle.readSint16BE();
sizeEntry = fileHandle.readSint16BE();
buffer = (fileEntry *) mallocAndZero(numEntry * sizeEntry);
for (j = 0; j < numEntry; j++) {
fileHandle.seek(4+j*0x1E);
fileHandle.read(buffer[j].name, 14);
buffer[j].offset = fileHandle.readSint32BE();
buffer[j].size = fileHandle.readSint32BE();
buffer[j].extSize = fileHandle.readSint32BE();
buffer[j].unk3 = fileHandle.readSint32BE();
fileHandle.seek(buffer[j].offset);
char *bufferLocal;
bufferLocal = (char *)mallocAndZero(buffer[j].size);
fileHandle.read(bufferLocal, buffer[j].size);
char nameBuffer[256];
sprintf(nameBuffer, "%s", buffer[j].name);
if (buffer[j].size == buffer[j].extSize) {
Common::DumpFile fout;
fout.open(nameBuffer);
if(fout.isOpen())
fout.write(bufferLocal, buffer[j].size);
} else {
char *uncompBuffer = (char *)mallocAndZero(buffer[j].extSize + 500);
delphineUnpack((uint8 *) uncompBuffer, (const uint8 *) bufferLocal, buffer[j].size);
Common::File fout;
fout.open(nameBuffer, Common::File::kFileWriteMode);
if(fout.isOpen())
fout.write(uncompBuffer, buffer[j].extSize);
//free(uncompBuffer);
}
free(bufferLocal);
}
fileHandle.close();
}
#endif
return (1);
}
///////////////////////////::
void drawMsgString(const char *string) {
//printf("%s\n",string);
}
} // End of namespace Cruise