scummvm/engines/cruise/volume.cpp

/* 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 */

#include "cruise/cruise.h"
#include "cruise/cruise_main.h"

namespace Cruise {

uint8 *PAL_ptr = nullptr;

int16 numLoadedPal;
int16 fileData2;

char currentBaseName[15] = "";

void loadPal(volumeDataStruct *entry) {
	// This code isn't currently being used
#if 0
	char name[20];

	if (_vm->_PAL_file.isOpen())
		_vm->_PAL_file.close();

	removeExtension(entry->ident, name);
	strcat(name, ".PAL");

	if (!_vm->_PAL_file.open(name))
		return;

	numLoadedPal = _vm->_PAL_file.readSint16BE();
	fileData2 = _vm->_PAL_file.readSint16BE();

	PAL_ptr = (uint8 *)MemAlloc(numLoadedPal * fileData2);
#endif
}

void closePal() {
	if (_vm->_PAL_file.isOpen()) {
		_vm->_PAL_file.close();

		MemFree(PAL_ptr);
		PAL_ptr = nullptr;

		numLoadedPal = 0;
		fileData2 = 0;
	}
}

int closeBase() {
	if (_vm->_currentVolumeFile.isOpen()) {
		_vm->_currentVolumeFile.close();

		MemFree(volumePtrToFileDescriptor);

		currentBaseName[0] = '\0';
	}

	if (_vm->_PAL_file.isOpen()) {
		closePal();
	}

	return 0;
}

int getVolumeDataEntry(volumeDataStruct *entry) {
	char buffer[256];

	volumeNumEntry = 0;
	volumeNumberOfEntry = 0;

	if (_vm->_currentVolumeFile.isOpen())
		freeDisk();

	askDisk(-1);

	Common::strcpy_s(buffer, entry->ident);

	_vm->_currentVolumeFile.open(buffer);

	if (!_vm->_currentVolumeFile.isOpen())
		return (-14);

	changeCursor(CURSOR_DISK);

	volumeNumberOfEntry = _vm->_currentVolumeFile.readSint16BE();
	volumeSizeOfEntry = _vm->_currentVolumeFile.readSint16BE();

	volumeNumEntry = volumeNumberOfEntry;

	assert(volumeSizeOfEntry == 14 + 4 + 4 + 4 + 4);

	volumePtrToFileDescriptor = (fileEntry *) mallocAndZero(sizeof(fileEntry) * volumeNumEntry);

	for (int 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 (int i = 0; i < volumeNumEntry; i++) {
		_vm->_currentVolumeFile.read(&volumePtrToFileDescriptor[i].name, 14);
		volumePtrToFileDescriptor[i].offset = _vm->_currentVolumeFile.readSint32BE();
		volumePtrToFileDescriptor[i].size = _vm->_currentVolumeFile.readSint32BE();
		volumePtrToFileDescriptor[i].extSize = _vm->_currentVolumeFile.readSint32BE();
		volumePtrToFileDescriptor[i].unk3 = _vm->_currentVolumeFile.readSint32BE();
	}

	Common::strcpy_s(currentBaseName, entry->ident);

	loadPal(entry);

	return 0;
}

int searchFileInVolCnf(const char *fileName, int32 diskNumber) {
	int foundDisk = -1;

	for (int i = 0; i < numOfDisks; i++) {
		if (volumeData[i].diskNumber == diskNumber) {
			int numOfEntry = volumeData[i].size / 13;

			for (int 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;

	for (int i = 0; i < numOfDisks; i++) {
		int numOfEntry = volumeData[i].size / 13;

		for (int j = 0; j < numOfEntry; j++) {
			if (!strcmp(volumeData[i].ptr[j].name, fileName)) {
				return (i);
			}
		}
	}

	return (foundDisk);
}

void freeDisk() {
	if (_vm->_currentVolumeFile.isOpen()) {
		_vm->_currentVolumeFile.close();
		MemFree(volumePtrToFileDescriptor);
	}

	/* TODO
	 * if (PAL_fileHandle)
	 * {
	 * freeAllDataPtr();
	 * }
	 */
}

int16 findFileInList(char *fileName) {
	if (!_vm->_currentVolumeFile.isOpen())
		return (-1);

	strToUpper(fileName);

	if (volumeNumEntry <= 0)
		return (-1);

	for (int 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];

	if (discNumber != -1) {
		currentDiskNumber = discNumber;
	}

	Common::sprintf_s(fileName, "VOL.%d", currentDiskNumber);
	Common::sprintf_s(string, "INSERER LE DISQUE %d EN ", currentDiskNumber);

#if 0 // skip drive selection stuff
	bool messageDrawn = false;
	while (Common::File::exists((const char*)fileName)) {
		if (!messageDrawn) {
			drawMsgString(string);
			messageDrawn = true;
		}
	}
#else
	drawMsgString(string);
#endif

	changeCursor(currentCursor);
}

int16 findFileInDisks(const char *name) {
	char fileName[50];
	int disk;
	int fileIdx;

	Common::strlcpy(fileName, name, sizeof(fileName));
	strToUpper(fileName);

	if (!volumeDataLoaded) {
		debug(1, "CNF wasn't loaded, reading now...");
		if (_vm->_currentVolumeFile.isOpen()) {
			askDisk(-1);
			freeDisk();
		}

		askDisk(1);
		readVolCnf();
	}

	if (_vm->_currentVolumeFile.isOpen()) {
		askDisk(-1);
	}

	fileIdx = findFileInList(fileName);

	if (fileIdx >= 0) {
		return (fileIdx);
	}

	disk = searchFileInVolCnf(fileName, currentDiskNumber);

	if (disk >= 0) {
		int temp;

		debug(1, "File found on disk %d", disk);

		if (_vm->_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() {
	for (long int i = 0; i < numOfDisks; i++) {
		if (volumeData[i].ptr) {
			MemFree(volumeData[i].ptr);
			volumeData[i].ptr = nullptr;
		}
	}

	volumeDataLoaded = 0;

	return 0;
}

int16 readVolCnf() {
	Common::File fileHandle;
	//short int sizeHEntry;

	volumeDataLoaded = 0;

	for (int i = 0; i < 20; i++) {
		volumeData[i].ident[0] = 0;
		volumeData[i].ptr = nullptr;
		volumeData[i].diskNumber = i + 1;
		volumeData[i].size = 0;
	}

	fileHandle.open("VOL.CNF");

	if (!fileHandle.isOpen())
		return (0);

	numOfDisks = fileHandle.readSint16BE();
	/*sizeHEntry =*/ fileHandle.readSint16BE();		// size of one header entry - 20 bytes

	for (int i = 0; i < numOfDisks; i++) {
		//      fread(&volumeData[i],20,1,fileHandle);
		fileHandle.read(&volumeData[i].ident, 10);
		fileHandle.read(&volumeData[i].ptr, 4);
		volumeData[i].diskNumber = fileHandle.readSint16BE();
		volumeData[i].size = fileHandle.readSint32BE();

		debug(1, "Disk number: %d", volumeData[i].diskNumber);
	}

	for (int i = 0; i < numOfDisks; i++) {
		dataFileName *ptr;

		volumeData[i].size = fileHandle.readSint32BE();

		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++) {
		char nameBuffer[256];
		fileEntry *buffer;

		Common::sprintf_s(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 (int 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];

			Common::sprintf_s(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);

				//MemFree(uncompBuffer);

			}

			MemFree(bufferLocal);
		}
		fileHandle.close();
	}

#endif

	return (1);
}

///////////////////////////::

// This code used to rely on "strupr", which is non existent on my system,
// thus I just implemented this function instead. - LordHoto
//
// TODO: This might be code duplication, please check this out.
void strToUpper(char *string) {
	while (*string) {
		*string = toupper(*string);
		++string;
	}
}

void drawMsgString(const char *string) {
	//printf("%s\n",string);
}

} // End of namespace Cruise