mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-23 10:19:27 +00:00
457 lines
8.9 KiB
C++
457 lines
8.9 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;
|
|
|
|
void loadPal(volumeDataStruct *entry) {
|
|
char name[20];
|
|
|
|
return;
|
|
|
|
if (PAL_fileHandle) {
|
|
fclose(PAL_fileHandle);
|
|
}
|
|
|
|
removeExtention(entry->ident, name);
|
|
strcat(name, ".PAL");
|
|
|
|
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);
|
|
}
|
|
|
|
int getVolumeDataEntry(volumeDataStruct *entry) {
|
|
char buffer[256];
|
|
int i;
|
|
|
|
volumeNumEntry = 0;
|
|
volumeNumberOfEntry = 0;
|
|
|
|
if (currentVolumeFile.isOpen()) {
|
|
freeDisk();
|
|
}
|
|
|
|
askDisk(-1);
|
|
|
|
strcpyuint8(buffer, entry->ident);
|
|
|
|
currentVolumeFile.open(buffer);
|
|
|
|
if (!currentVolumeFile.isOpen()) {
|
|
return (-14);
|
|
}
|
|
|
|
changeCursor(1);
|
|
|
|
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);
|
|
}
|
|
|
|
loadPal(entry);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int searchFileInVolCnf(uint8 *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 (!strcmpuint8(volumeData[i].ptr[j].name,
|
|
fileName)) {
|
|
return (i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (foundDisk);
|
|
}
|
|
|
|
int32 findFileInDisksSub1(uint8 *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 (!strcmpuint8(volumeData[i].ptr[j].name, fileName)) {
|
|
return (i);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (foundDisk);
|
|
}
|
|
|
|
void strToUpper(uint8 *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(uint8 *fileName) {
|
|
int i;
|
|
|
|
if (!currentVolumeFile.isOpen()) {
|
|
return (-1);
|
|
}
|
|
|
|
strToUpper(fileName);
|
|
|
|
if (volumeNumEntry <= 0) {
|
|
return (-1);
|
|
}
|
|
|
|
for (i = 0; i < volumeNumEntry; i++) {
|
|
if (!strcmpuint8(volumePtrToFileDescriptor[i].name, fileName)) {
|
|
return (i);
|
|
}
|
|
}
|
|
|
|
return (-1);
|
|
}
|
|
|
|
void askDisk(int16 discNumber) {
|
|
char diskNumberString[256];
|
|
uint8 fileName[256];
|
|
uint8 string[256];
|
|
char messageDrawn = 0;
|
|
|
|
if (discNumber != -1) {
|
|
currentDiskNumber = discNumber;
|
|
}
|
|
// skip drive selection stuff
|
|
|
|
strcpyuint8(fileName, "VOL.");
|
|
sprintf(diskNumberString, "%d", currentDiskNumber);
|
|
strcatuint8(fileName, diskNumberString);
|
|
|
|
strcpyuint8(string, "INSERER LE DISQUE ");
|
|
strcatuint8(string, diskNumberString);
|
|
strcatuint8(string, " EN ");
|
|
|
|
//while (Common::File::exists((const char*)fileName))
|
|
{
|
|
if (!messageDrawn) {
|
|
drawMsgString(string);
|
|
messageDrawn = 1;
|
|
}
|
|
}
|
|
|
|
changeCursor(currentCursor);
|
|
}
|
|
|
|
int16 findFileInDisks(uint8 *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);
|
|
}
|
|
}
|
|
|
|
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++) {
|
|
fileName *ptr;
|
|
|
|
fileHandle.read(&volumeData[i].size, 4);
|
|
flipLong(&volumeData[i].size);
|
|
|
|
ptr = (fileName *) 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 = fopen(nameBuffer, "rb");
|
|
|
|
short int numEntry;
|
|
short int sizeEntry;
|
|
|
|
fread(&numEntry, 2, 1, fileHandle);
|
|
fread(&sizeEntry, 2, 1, fileHandle);
|
|
|
|
flipShort(&numEntry);
|
|
flipShort(&sizeEntry);
|
|
|
|
buffer = (fileEntry *) mallocAndZero(numEntry * sizeEntry);
|
|
|
|
fread(buffer, numEntry * sizeEntry, 1, fileHandle);
|
|
|
|
for (j = 0; j < numEntry; j++) {
|
|
flipLong(&buffer[j].offset);
|
|
flipLong(&buffer[j].size);
|
|
flipLong(&buffer[j].unk2);
|
|
flipLong(&buffer[j].unk3);
|
|
|
|
fseek(fileHandle, buffer[j].offset, SEEK_SET);
|
|
|
|
char *bufferLocal;
|
|
bufferLocal = (char *)mallocAndZero(buffer[j].size);
|
|
|
|
fread(bufferLocal, buffer[j].size, 1, fileHandle);
|
|
|
|
char nameBuffer[256];
|
|
|
|
sprintf(nameBuffer, "D%d.dmp/%s", i + 1,
|
|
buffer[j].name);
|
|
|
|
if (buffer[j].size == buffer[j].unk2) {
|
|
FILE *fOut = fopen(nameBuffer, "wb+");
|
|
fwrite(bufferLocal, buffer[j].size, 1, fOut);
|
|
fclose(fOut);
|
|
} else {
|
|
char *uncompBuffer =
|
|
(char *)mallocAndZero(buffer[j].unk2 +
|
|
500);
|
|
|
|
delphineUnpack((uint8 *) uncompBuffer, (const uint8 *) bufferLocal, buffer[j].size);
|
|
|
|
FILE *fOut = fopen(nameBuffer, "wb+");
|
|
fwrite(uncompBuffer, buffer[j].unk2, 1,
|
|
fOut);
|
|
fclose(fOut);
|
|
|
|
//free(uncompBuffer);
|
|
|
|
}
|
|
|
|
free(bufferLocal);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
return (1);
|
|
}
|
|
|
|
///////////////////////////::
|
|
|
|
void drawMsgString(uint8 *string) {
|
|
//printf("%s\n",string);
|
|
}
|
|
|
|
} // End of namespace Cruise
|