scummvm/engines/sludge/loadsave.cpp
2017-07-13 18:27:45 +02:00

678 lines
17 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.
*
*/
#include "allfiles.h"
#include "sprites.h"
#include "fonttext.h"
#include "newfatal.h"
#include "variable.h"
#include "CommonCode/version.h"
#include "language.h"
#include "moreio.h"
#include "sludger.h"
#include "people.h"
#include "talk.h"
#include "objtypes.h"
#include "backdrop.h"
#include "region.h"
#include "floor.h"
#include "zbuffer.h"
#include "cursors.h"
#include "statusba.h"
#include "sound.h"
#include "fileset.h"
#include "debug.h"
#include "loadsave.h"
namespace Sludge {
//----------------------------------------------------------------------
// From elsewhere
//----------------------------------------------------------------------
extern loadedFunction *allRunningFunctions; // In sludger.cpp
extern char *typeName[]; // In variable.cpp
extern int numGlobals; // In sludger.cpp
extern variable *globalVars; // In sludger.cpp
extern flor *currentFloor; // In floor.cpp
extern zBufferData zBuffer; // In zbuffer.cpp
extern speechStruct *speech; // In talk.cpp
extern personaAnimation *mouseCursorAnim; // In cursor.cpp
extern int mouseCursorFrameNum; // " " "
extern int loadedFontNum, fontHeight, fontTableSize; // In fonttext.cpp
extern int numFontColours; // " " "
extern char *fontOrderString; // " " "
extern FILETIME fileTime; // In sludger.cpp
extern int speechMode; // " " "
extern int lightMapNumber; // In backdrop.cpp
extern unsigned int sceneWidth, sceneHeight; // " " "
extern int cameraX, cameraY; // " " "
extern float cameraZoom;
extern unsigned char brightnessLevel; // " " "
extern short fontSpace; // in textfont.cpp
extern unsigned char fadeMode; // In transition.cpp
extern bool captureAllKeys;
extern bool allowAnyFilename;
extern unsigned short saveEncoding; // in savedata.cpp
extern unsigned char currentBurnR, currentBurnG, currentBurnB;
extern unsigned int currentBlankColour; // in backdrop.cpp
extern parallaxLayer *parallaxStuff; // "
extern int lightMapMode; // "
extern int languageNum;
//----------------------------------------------------------------------
// Globals (so we know what's saved already and what's a reference
//----------------------------------------------------------------------
struct stackLibrary {
stackHandler *stack;
stackLibrary *next;
};
int stackLibTotal = 0;
stackLibrary *stackLib = NULL;
//----------------------------------------------------------------------
// For saving and loading stacks...
//----------------------------------------------------------------------
void saveStack(variableStack *vs, Common::WriteStream *stream) {
int elements = 0;
int a;
variableStack *search = vs;
while (search) {
elements++;
search = search->next;
}
stackDebug((stackfp, " stack contains %d elements\n", elements));
stream->writeUint16BE(elements);
search = vs;
for (a = 0; a < elements; a++) {
saveVariable(&search->thisVar, stream);
search = search->next;
}
}
variableStack *loadStack(Common::SeekableReadStream *stream, variableStack **last) {
int elements = stream->readUint16BE();
int a;
variableStack *first = NULL;
variableStack * * changeMe = &first;
for (a = 0; a < elements; a++) {
variableStack *nS = new variableStack;
if (!checkNew(nS))
return NULL;
loadVariable(&(nS->thisVar), stream);
if (last && a == elements - 1) {
stackDebug((stackfp, "Setting last to %p\n", nS));
*last = nS;
}
nS->next = NULL;
(*changeMe) = nS;
changeMe = &(nS->next);
}
return first;
}
bool saveStackRef(stackHandler *vs, Common::WriteStream *stream) {
stackLibrary *s = stackLib;
int a = 0;
while (s) {
if (s->stack == vs) {
stream->writeByte(1);
stream->writeUint16BE(stackLibTotal - a);
return true;
}
s = s->next;
a++;
}
stream->writeByte(0);
saveStack(vs->first, stream);
s = new stackLibrary;
stackLibTotal++;
if (!checkNew(s))
return false;
s->next = stackLib;
s->stack = vs;
stackLib = s;
return true;
}
void clearStackLib() {
stackLibrary *k;
while (stackLib) {
k = stackLib;
stackLib = stackLib->next;
delete k;
}
stackLibTotal = 0;
}
stackHandler *getStackFromLibrary(int n) {
n = stackLibTotal - n;
while (n) {
stackLib = stackLib->next;
n--;
}
return stackLib->stack;
}
stackHandler *loadStackRef(Common::SeekableReadStream *stream) {
stackHandler *nsh;
if (stream->readByte()) { // It's one we've loaded already...
stackDebug((stackfp, "loadStackRef (duplicate, get from library)\n"));
nsh = getStackFromLibrary(stream->readUint16BE());
nsh->timesUsed++;
} else {
stackDebug((stackfp, "loadStackRef (new one)\n"));
// Load the new stack
nsh = new stackHandler;
if (!checkNew(nsh))
return NULL;
nsh->last = NULL;
nsh->first = loadStack(stream, &nsh->last);
nsh->timesUsed = 1;
stackDebug((stackfp, " first = %p\n", nsh->first));
if (nsh->first)
stackDebug((stackfp, " first->next = %p\n", nsh->first->next));
stackDebug((stackfp, " last = %p\n", nsh->last));
if (nsh->last)
stackDebug((stackfp, " last->next = %p\n", nsh->last->next));
// Add it to the library of loaded stacks
stackLibrary *s = new stackLibrary;
if (!checkNew(s))
return NULL;
s->stack = nsh;
s->next = stackLib;
stackLib = s;
stackLibTotal++;
}
return nsh;
}
//----------------------------------------------------------------------
// For saving and loading variables...
//----------------------------------------------------------------------
bool saveVariable(variable *from, Common::WriteStream *stream) {
#if DEBUG_STACKINESS
{
char *str = getTextFromAnyVar(*from);
stackDebug((stackfp, "in saveVariable, type %d, %s\n", from->varType, str));
delete str;
}
#endif
stream->writeByte(from->varType);
switch (from->varType) {
case SVT_INT:
case SVT_FUNC:
case SVT_BUILT:
case SVT_FILE:
case SVT_OBJTYPE:
stream->writeUint32LE(from->varData.intValue);
return true;
case SVT_STRING:
writeString(from->varData.theString, stream);
return true;
case SVT_STACK:
return saveStackRef(from->varData.theStack, stream);
case SVT_COSTUME:
saveCostume(from->varData.costumeHandler, stream);
return false;
case SVT_ANIM:
saveAnim(from->varData.animHandler, stream);
return false;
case SVT_NULL:
return false;
default:
fatal("Can't save variables of this type:", (from->varType < SVT_NUM_TYPES) ? typeName[from->varType] : "bad ID");
}
return true;
}
bool loadVariable(variable *to, Common::SeekableReadStream *stream) {
to->varType = (variableType)stream->readByte();
switch (to->varType) {
case SVT_INT:
case SVT_FUNC:
case SVT_BUILT:
case SVT_FILE:
case SVT_OBJTYPE:
to->varData.intValue = stream->readUint32LE();
return true;
case SVT_STRING:
to->varData.theString = readString(stream);
return true;
case SVT_STACK:
to->varData.theStack = loadStackRef(stream);
#if DEBUG_STACKINESS
{
char *str = getTextFromAnyVar(*to);
stackDebug((stackfp, "just loaded %s\n", str));
delete str;
}
#endif
return true;
case SVT_COSTUME:
to->varData.costumeHandler = new persona;
if (!checkNew(to->varData.costumeHandler))
return false;
loadCostume(to->varData.costumeHandler, stream);
return true;
case SVT_ANIM:
to->varData.animHandler = new personaAnimation;
if (!checkNew(to->varData.animHandler))
return false;
loadAnim(to->varData.animHandler, stream);
return true;
default:
break;
}
return true;
}
//----------------------------------------------------------------------
// For saving and loading functions
//----------------------------------------------------------------------
void saveFunction(loadedFunction *fun, Common::WriteStream *stream) {
int a;
stream->writeUint16BE(fun->originalNumber);
if (fun->calledBy) {
stream->writeByte(1);
saveFunction(fun->calledBy, stream);
} else {
stream->writeByte(0);
}
stream->writeUint32LE(fun->timeLeft);
stream->writeUint16BE(fun->runThisLine);
stream->writeByte(fun->cancelMe);
stream->writeByte(fun->returnSomething);
stream->writeByte(fun->isSpeech);
saveVariable(&(fun->reg), stream);
if (fun->freezerLevel) {
fatal(ERROR_GAME_SAVE_FROZEN);
}
saveStack(fun->stack, stream);
for (a = 0; a < fun->numLocals; a++) {
saveVariable(&(fun->localVars[a]), stream);
}
}
loadedFunction *loadFunction(Common::SeekableReadStream *stream) {
int a;
// Reserve memory...
loadedFunction *buildFunc = new loadedFunction;
if (!checkNew(buildFunc))
return NULL;
// See what it was called by and load if we need to...
buildFunc->originalNumber = stream->readUint16BE();
buildFunc->calledBy = NULL;
if (stream->readByte()) {
buildFunc->calledBy = loadFunction(stream);
if (!buildFunc->calledBy)
return NULL;
}
buildFunc->timeLeft = stream->readUint32LE();
buildFunc->runThisLine = stream->readUint16BE();
buildFunc->freezerLevel = 0;
buildFunc->cancelMe = stream->readByte();
buildFunc->returnSomething = stream->readByte();
buildFunc->isSpeech = stream->readByte();
loadVariable(&(buildFunc->reg), stream);
loadFunctionCode(buildFunc);
buildFunc->stack = loadStack(stream, NULL);
for (a = 0; a < buildFunc->numLocals; a++) {
loadVariable(&(buildFunc->localVars[a]), stream);
}
return buildFunc;
}
//----------------------------------------------------------------------
// Save everything
//----------------------------------------------------------------------
bool saveGame(char *fname) {
#if 0
int a;
FILE *fp = fopen(fname, "wb");
if (fp == NULL) return false;
fprintf(fp, "SLUDSA");
fputc(0, fp);
fputc(0, fp);
fputc(MAJOR_VERSION, fp);
fputc(MINOR_VERSION, fp);
if (! saveThumbnail(fp)) return false;
fwrite(&fileTime, sizeof(FILETIME), 1, fp);
// DON'T ADD ANYTHING NEW BEFORE THIS POINT!
fputc(allowAnyFilename, fp);
fputc(captureAllKeys, fp);
fputc(true, fp);// updateDisplay
fputc(fontTableSize > 0, fp);
if (fontTableSize > 0) {
fp->writeUint16BE(loadedFontNum);
fp->writeUint16BE(fontHeight);
writeString(fontOrderString, fp);
}
putSigned(fontSpace, fp);
// Save backdrop
fp->writeUint16BE(cameraX);
fp->writeUint16BE(cameraY);
putFloat(cameraZoom, fp);
fputc(brightnessLevel, fp);
saveHSI(fp);
// Save event handlers
saveHandlers(fp);
// Save regions
saveRegions(fp);
saveAnim(mouseCursorAnim, fp);
fp->writeUint16BE(mouseCursorFrameNum);
// Save functions
loadedFunction *thisFunction = allRunningFunctions;
int countFunctions = 0;
while (thisFunction) {
countFunctions ++;
thisFunction = thisFunction->next;
}
fp->writeUint16BE(countFunctions);
thisFunction = allRunningFunctions;
while (thisFunction) {
saveFunction(thisFunction, fp);
thisFunction = thisFunction->next;
}
for (a = 0; a < numGlobals; a++) {
saveVariable(&globalVars[a], fp);
}
savePeople(fp);
if (currentFloor->numPolygons) {
fputc(1, fp);
fp->writeUint16BE(currentFloor->originalNum);
} else fputc(0, fp);
if (zBuffer.tex) {
fputc(1, fp);
fp->writeUint16BE(zBuffer.originalNum);
} else fputc(0, fp);
if (lightMap.data) {
fputc(1, fp);
fp->writeUint16BE(lightMapNumber);
} else fputc(0, fp);
fputc(lightMapMode, fp);
fputc(speechMode, fp);
fputc(fadeMode, fp);
saveSpeech(speech, fp);
saveStatusBars(fp);
saveSounds(fp);
fp->writeUint16BE(saveEncoding);
blur_saveSettings(fp);
fp->writeUint16BE(currentBlankColour);
fputc(currentBurnR, fp);
fputc(currentBurnG, fp);
fputc(currentBurnB, fp);
saveParallaxRecursive(parallaxStuff, fp);
fputc(0, fp);
fputc(languageNum, fp); // Selected language
saveSnapshot(fp);
fclose(fp);
#endif
clearStackLib();
return true;
}
//----------------------------------------------------------------------
// Load everything
//----------------------------------------------------------------------
int ssgVersion;
bool loadGame(char *fname) {
#if 0
FILE *fp;
FILETIME savedGameTime;
int a;
while (allRunningFunctions) finishFunction(allRunningFunctions);
fp = openAndVerify(fname, 'S', 'A', ERROR_GAME_LOAD_NO, ssgVersion);
if (fp == NULL) return false;
if (ssgVersion >= VERSION(1, 4)) {
if (! skipThumbnail(fp)) return fatal(ERROR_GAME_LOAD_CORRUPT, fname);
}
size_t bytes_read = fread(&savedGameTime, sizeof(FILETIME), 1, fp);
if (bytes_read != sizeof(FILETIME) && ferror(fp)) {
debugOut("Reading error in loadGame.\n");
}
if (savedGameTime.dwLowDateTime != fileTime.dwLowDateTime ||
savedGameTime.dwHighDateTime != fileTime.dwHighDateTime) {
return fatal(ERROR_GAME_LOAD_WRONG, fname);
}
// DON'T ADD ANYTHING NEW BEFORE THIS POINT!
if (ssgVersion >= VERSION(1, 4)) {
allowAnyFilename = fgetc(fp);
}
captureAllKeys = fgetc(fp);
fgetc(fp); // updateDisplay (part of movie playing)
bool fontLoaded = fgetc(fp);
int fontNum;
char *charOrder;
if (fontLoaded) {
fontNum = fp->readUint16BE();
fontHeight = fp->readUint16BE();
if (ssgVersion < VERSION(2, 2)) {
int x;
charOrder = new char[257];
if (! checkNew(charOrder)) return false;
for (int a = 0; a < 256; a++) {
x = fgetc(fp);
charOrder[x] = a;
}
charOrder[256] = 0;
} else {
charOrder = readString(fp);
}
}
loadFont(fontNum, charOrder, fontHeight);
delete [] charOrder;
fontSpace = getSigned(fp);
killAllPeople();
killAllRegions();
int camerX = fp->readUint16BE();
int camerY = fp->readUint16BE();
float camerZ;
if (ssgVersion >= VERSION(2, 0)) {
camerZ = getFloat(fp);
} else {
camerZ = 1.0;
}
brightnessLevel = fgetc(fp);
loadHSI(fp, 0, 0, true);
loadHandlers(fp);
loadRegions(fp);
mouseCursorAnim = new personaAnimation;
if (! checkNew(mouseCursorAnim)) return false;
if (! loadAnim(mouseCursorAnim, fp)) return false;
mouseCursorFrameNum = fp->readUint16BE();
loadedFunction *rFunc;
loadedFunction * * buildList = &allRunningFunctions;
int countFunctions = fp->readUint16BE();
while (countFunctions --) {
rFunc = loadFunction(fp);
rFunc->next = NULL;
(* buildList) = rFunc;
buildList = &(rFunc->next);
}
for (a = 0; a < numGlobals; a++) {
unlinkVar(globalVars[a]);
loadVariable(&globalVars[a], fp);
}
loadPeople(fp);
if (fgetc(fp)) {
if (! setFloor(fp->readUint16BE())) return false;
} else setFloorNull();
if (fgetc(fp)) {
if (! setZBuffer(fp->readUint16BE())) return false;
}
if (fgetc(fp)) {
if (! loadLightMap(fp->readUint16BE())) return false;
}
if (ssgVersion >= VERSION(1, 4)) {
lightMapMode = fgetc(fp) % 3;
}
speechMode = fgetc(fp);
fadeMode = fgetc(fp);
loadSpeech(speech, fp);
loadStatusBars(fp);
loadSounds(fp);
saveEncoding = fp->readUint16BE();
if (ssgVersion >= VERSION(1, 6)) {
if (ssgVersion < VERSION(2, 0)) {
// aaLoad
fgetc(fp);
getFloat(fp);
getFloat(fp);
}
blur_loadSettings(fp);
}
if (ssgVersion >= VERSION(1, 3)) {
currentBlankColour = fp->readUint16BE();
currentBurnR = fgetc(fp);
currentBurnG = fgetc(fp);
currentBurnB = fgetc(fp);
// Read parallax layers
while (fgetc(fp)) {
int im = fp->readUint16BE();
int fx = fp->readUint16BE();
int fy = fp->readUint16BE();
if (! loadParallax(im, fx, fy)) return false;
}
int selectedLanguage = fgetc(fp);
if (selectedLanguage != languageNum) {
// Load the saved language!
languageNum = selectedLanguage;
setFileIndices(NULL, gameSettings.numLanguages, languageNum);
}
}
nosnapshot();
if (ssgVersion >= VERSION(1, 4)) {
if (fgetc(fp)) {
if (! restoreSnapshot(fp)) return false;
}
}
fclose(fp);
cameraX = camerX;
cameraY = camerY;
cameraZoom = camerZ;
#endif
clearStackLib();
return true;
}
} // End of namespace Sludge