mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-22 18:02:05 +00:00
2bbf708dea
svn-id: r45233
1898 lines
57 KiB
C++
1898 lines
57 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 "common/config-manager.h"
|
|
#include "common/savefile.h"
|
|
#include "common/system.h"
|
|
#include "common/zlib.h"
|
|
|
|
#include "scumm/actor.h"
|
|
#include "scumm/charset.h"
|
|
#include "scumm/imuse_digi/dimuse.h"
|
|
#include "scumm/imuse/imuse.h"
|
|
#include "scumm/he/intern_he.h"
|
|
#include "scumm/object.h"
|
|
#include "scumm/resource.h"
|
|
#include "scumm/saveload.h"
|
|
#include "scumm/scumm_v0.h"
|
|
#include "scumm/scumm_v7.h"
|
|
#include "scumm/sound.h"
|
|
#include "scumm/he/sprite_he.h"
|
|
#include "scumm/verbs.h"
|
|
|
|
#include "sound/audiocd.h"
|
|
#include "sound/mixer.h"
|
|
|
|
#include "graphics/thumbnail.h"
|
|
|
|
namespace Scumm {
|
|
|
|
struct SaveGameHeader {
|
|
uint32 type;
|
|
uint32 size;
|
|
uint32 ver;
|
|
char name[32];
|
|
};
|
|
|
|
struct SaveInfoSection {
|
|
uint32 type;
|
|
uint32 version;
|
|
uint32 size;
|
|
|
|
uint32 timeTValue; // Obsolete since version 2, but kept for compatibility
|
|
uint32 playtime;
|
|
|
|
uint32 date;
|
|
uint16 time;
|
|
};
|
|
|
|
#define SaveInfoSectionSize (4+4+4 + 4+4 + 4+2)
|
|
|
|
#define INFOSECTION_VERSION 2
|
|
|
|
#pragma mark -
|
|
|
|
Common::Error ScummEngine::loadGameState(int slot) {
|
|
requestLoad(slot);
|
|
return Common::kNoError;
|
|
}
|
|
|
|
bool ScummEngine::canLoadGameStateCurrently() {
|
|
// FIXME: For now always allow loading in V0-V3 games
|
|
// FIXME: Actually, we might wish to support loading in more places.
|
|
// As long as we are sure it won't cause any problems... Are we
|
|
// aware of *any* spots where loading is not supported?
|
|
|
|
// HE games are limited to original load and save interface only,
|
|
// due to numerous glitches (see bug #1726909) that can occur.
|
|
if (_game.heversion >= 60)
|
|
return false;
|
|
|
|
// COMI always disables saving/loading (to tell the truth:
|
|
// the main menu) via its scripts, thus we need to make an
|
|
// exception here. This the same forced overwriting of the
|
|
// script decisions as in ScummEngine::processKeyboard.
|
|
if (_game.id == GID_CMI)
|
|
return true;
|
|
|
|
return (VAR_MAINMENU_KEY == 0xFF || VAR(VAR_MAINMENU_KEY) != 0);
|
|
}
|
|
|
|
Common::Error ScummEngine::saveGameState(int slot, const char *desc) {
|
|
requestSave(slot, desc);
|
|
return Common::kNoError;
|
|
}
|
|
|
|
bool ScummEngine::canSaveGameStateCurrently() {
|
|
// FIXME: For now always allow loading in V0-V3 games
|
|
// TODO: Should we disallow saving in some more places,
|
|
// e.g. when a SAN movie is playing? Not sure whether the
|
|
// original EXE allowed this.
|
|
|
|
// HE games are limited to original load and save interface only,
|
|
// due to numerous glitches (see bug #1726909) that can occur.
|
|
if (_game.heversion >= 60)
|
|
return false;
|
|
|
|
// COMI always disables saving/loading (to tell the truth:
|
|
// the main menu) via its scripts, thus we need to make an
|
|
// exception here. This the same forced overwriting of the
|
|
// script decisions as in ScummEngine::processKeyboard.
|
|
if (_game.id == GID_CMI)
|
|
return true;
|
|
|
|
// SCUMM v4+ doesn't allow saving in room 0 or if
|
|
// VAR(VAR_MAINMENU_KEY) to set to zero.
|
|
return (VAR_MAINMENU_KEY == 0xFF || (VAR(VAR_MAINMENU_KEY) != 0 && _currentRoom != 0));
|
|
}
|
|
|
|
|
|
void ScummEngine::requestSave(int slot, const char *name) {
|
|
_saveLoadSlot = slot;
|
|
_saveTemporaryState = false;
|
|
_saveLoadFlag = 1; // 1 for save
|
|
assert(name);
|
|
strncpy(_saveLoadName, name, sizeof(_saveLoadName));
|
|
_saveLoadName[sizeof(_saveLoadName) - 1] = 0;
|
|
}
|
|
|
|
void ScummEngine::requestLoad(int slot) {
|
|
_saveLoadSlot = slot;
|
|
_saveTemporaryState = false;
|
|
_saveLoadFlag = 2; // 2 for load
|
|
}
|
|
|
|
static bool saveSaveGameHeader(Common::OutSaveFile *out, SaveGameHeader &hdr) {
|
|
hdr.type = MKID_BE('SCVM');
|
|
hdr.size = 0;
|
|
hdr.ver = CURRENT_VER;
|
|
|
|
out->writeUint32BE(hdr.type);
|
|
out->writeUint32LE(hdr.size);
|
|
out->writeUint32LE(hdr.ver);
|
|
out->write(hdr.name, sizeof(hdr.name));
|
|
return true;
|
|
}
|
|
|
|
bool ScummEngine::saveState(Common::OutSaveFile *out, bool writeHeader) {
|
|
SaveGameHeader hdr;
|
|
|
|
if (writeHeader) {
|
|
memcpy(hdr.name, _saveLoadName, sizeof(hdr.name));
|
|
saveSaveGameHeader(out, hdr);
|
|
}
|
|
#if !defined(__DS__) /* && !defined(__PLAYSTATION2__) */
|
|
Graphics::saveThumbnail(*out);
|
|
#endif
|
|
saveInfos(out);
|
|
|
|
Serializer ser(0, out, CURRENT_VER);
|
|
saveOrLoad(&ser);
|
|
return true;
|
|
}
|
|
|
|
bool ScummEngine::saveState(int slot, bool compat) {
|
|
bool saveFailed;
|
|
Common::String filename;
|
|
Common::OutSaveFile *out;
|
|
|
|
if (_saveLoadSlot == 255) {
|
|
// Allow custom filenames for save game system in HE Games
|
|
filename = _saveLoadFileName;
|
|
} else {
|
|
filename = makeSavegameName(slot, compat);
|
|
}
|
|
if (!(out = _saveFileMan->openForSaving(filename)))
|
|
return false;
|
|
|
|
saveFailed = false;
|
|
if (!saveState(out))
|
|
saveFailed = true;
|
|
|
|
out->finalize();
|
|
if (out->err())
|
|
saveFailed = true;
|
|
delete out;
|
|
|
|
if (saveFailed) {
|
|
debug(1, "State save as '%s' FAILED", filename.c_str());
|
|
return false;
|
|
}
|
|
debug(1, "State saved as '%s'", filename.c_str());
|
|
return true;
|
|
}
|
|
|
|
|
|
void ScummEngine_v4::prepareSavegame() {
|
|
Common::MemoryWriteStreamDynamic *memStream;
|
|
Common::WriteStream *writeStream;
|
|
|
|
// free memory of the last prepared savegame
|
|
delete _savePreparedSavegame;
|
|
_savePreparedSavegame = NULL;
|
|
|
|
// store headerless savegame in a compressed memory stream
|
|
memStream = new Common::MemoryWriteStreamDynamic();
|
|
writeStream = Common::wrapCompressedWriteStream(memStream);
|
|
if (saveState(writeStream, false)) {
|
|
// we have to finalize the compression-stream first, otherwise the internal
|
|
// memory-stream pointer will be zero (Important: flush() does not work here!).
|
|
writeStream->finalize();
|
|
if (!writeStream->err()) {
|
|
// wrap uncompressing MemoryReadStream around the savegame data
|
|
_savePreparedSavegame = Common::wrapCompressedReadStream(
|
|
new Common::MemoryReadStream(memStream->getData(), memStream->size(), Common::DisposeAfterUse::YES));
|
|
}
|
|
}
|
|
// free the CompressedWriteStream and MemoryWriteStreamDynamic
|
|
// but not the memory stream's internal buffer
|
|
delete writeStream;
|
|
}
|
|
|
|
bool ScummEngine_v4::savePreparedSavegame(int slot, char *desc) {
|
|
bool success;
|
|
Common::String filename;
|
|
Common::OutSaveFile *out;
|
|
SaveGameHeader hdr;
|
|
uint32 nread, nwritten;
|
|
|
|
out = 0;
|
|
success = true;
|
|
|
|
// check if savegame was successfully stored in memory
|
|
if (!_savePreparedSavegame)
|
|
success = false;
|
|
|
|
// open savegame file
|
|
if (success) {
|
|
filename = makeSavegameName(slot, false);
|
|
if (!(out = _saveFileMan->openForSaving(filename))) {
|
|
success = false;
|
|
}
|
|
}
|
|
|
|
// write header to file
|
|
if (success) {
|
|
memset(hdr.name, 0, sizeof(hdr.name));
|
|
strncpy(hdr.name, desc, sizeof(hdr.name)-1);
|
|
success = saveSaveGameHeader(out, hdr);
|
|
}
|
|
|
|
// copy savegame from memory-stream to file
|
|
if (success) {
|
|
_savePreparedSavegame->seek(0, SEEK_SET);
|
|
byte buffer[1024];
|
|
while ((nread = _savePreparedSavegame->read(buffer, sizeof(buffer)))) {
|
|
nwritten = out->write(buffer, nread);
|
|
if (nwritten < nread) {
|
|
success = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (out) {
|
|
out->finalize();
|
|
if (out->err())
|
|
success = false;
|
|
delete out;
|
|
}
|
|
|
|
if (!success) {
|
|
debug(1, "State save as '%s' FAILED", filename.c_str());
|
|
return false;
|
|
} else {
|
|
debug(1, "State saved as '%s'", filename.c_str());
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static bool loadSaveGameHeader(Common::SeekableReadStream *in, SaveGameHeader &hdr) {
|
|
hdr.type = in->readUint32BE();
|
|
hdr.size = in->readUint32LE();
|
|
hdr.ver = in->readUint32LE();
|
|
in->read(hdr.name, sizeof(hdr.name));
|
|
return !in->err() && hdr.type == MKID_BE('SCVM');
|
|
}
|
|
|
|
bool ScummEngine::loadState(int slot, bool compat) {
|
|
Common::String filename;
|
|
Common::SeekableReadStream *in;
|
|
int i, j;
|
|
SaveGameHeader hdr;
|
|
int sb, sh;
|
|
|
|
if (_saveLoadSlot == 255) {
|
|
// Allow custom filenames for save game system in HE Games
|
|
filename = _saveLoadFileName;
|
|
} else {
|
|
filename = makeSavegameName(slot, compat);
|
|
}
|
|
if (!(in = _saveFileMan->openForLoading(filename)))
|
|
return false;
|
|
|
|
if (!loadSaveGameHeader(in, hdr)) {
|
|
warning("Invalid savegame '%s'", filename.c_str());
|
|
delete in;
|
|
return false;
|
|
}
|
|
|
|
// In older versions of ScummVM, the header version was not endian safe.
|
|
// We account for that by retrying once with swapped byte order in case
|
|
// we see a version that is higher than anything we'd expect...
|
|
if (hdr.ver > 0xFFFFFF)
|
|
hdr.ver = SWAP_BYTES_32(hdr.ver);
|
|
|
|
// Reject save games which are too old or too new. Note that
|
|
// We do not really support V7 games, but still accept them here
|
|
// to work around a bug from the stone age (see below for more
|
|
// information).
|
|
if (hdr.ver < VER(7) || hdr.ver > CURRENT_VER) {
|
|
warning("Invalid version of '%s'", filename.c_str());
|
|
delete in;
|
|
return false;
|
|
}
|
|
|
|
// We (deliberately) broke HE savegame compatibility at some point.
|
|
if (hdr.ver < VER(50) && _game.heversion >= 71) {
|
|
warning("Unsupported version of '%s'", filename.c_str());
|
|
delete in;
|
|
return false;
|
|
}
|
|
|
|
// Since version 52 a thumbnail is saved directly after the header.
|
|
if (hdr.ver >= VER(52)) {
|
|
// Prior to version 75 we always required an thumbnail to be present
|
|
if (hdr.ver <= VER(74)) {
|
|
if (!Graphics::checkThumbnailHeader(*in)) {
|
|
warning("Can not load thumbnail");
|
|
delete in;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
Graphics::skipThumbnailHeader(*in);
|
|
}
|
|
|
|
// Since version 56 we save additional information about the creation of
|
|
// the save game and the save time.
|
|
if (hdr.ver >= VER(56)) {
|
|
InfoStuff infos;
|
|
if (!loadInfos(in, &infos)) {
|
|
warning("Info section could not be found");
|
|
delete in;
|
|
return false;
|
|
}
|
|
|
|
_engineStartTime = _system->getMillis() / 1000 - infos.playtime;
|
|
} else {
|
|
// start time counting
|
|
_engineStartTime = _system->getMillis() / 1000;
|
|
}
|
|
|
|
// Due to a bug in scummvm up to and including 0.3.0, save games could be saved
|
|
// in the V8/V9 format but were tagged with a V7 mark. Ouch. So we just pretend V7 == V8 here
|
|
if (hdr.ver == VER(7))
|
|
hdr.ver = VER(8);
|
|
|
|
memcpy(_saveLoadName, hdr.name, sizeof(hdr.name));
|
|
|
|
// Unless specifically requested with _saveSound, we do not save the iMUSE
|
|
// state for temporary state saves - such as certain cutscenes in DOTT,
|
|
// FOA, Sam and Max, etc.
|
|
//
|
|
// Thus, we should probably not stop music when restoring from one of
|
|
// these saves. This change stops the Mole Man theme from going quiet in
|
|
// Sam & Max when Doug tells you about the Ball of Twine, as mentioned in
|
|
// patch #886058.
|
|
//
|
|
// If we don't have iMUSE at all we may as well stop the sounds. The previous
|
|
// default behavior here was to stopAllSounds on all state restores.
|
|
|
|
if (!_imuse || _saveSound || !_saveTemporaryState)
|
|
_sound->stopAllSounds();
|
|
|
|
#ifdef ENABLE_SCUMM_7_8
|
|
if (_imuseDigital) {
|
|
_imuseDigital->stopAllSounds();
|
|
_imuseDigital->resetState();
|
|
}
|
|
#endif
|
|
|
|
_sound->stopCD();
|
|
|
|
_sound->pauseSounds(true);
|
|
|
|
closeRoom();
|
|
|
|
memset(_inventory, 0, sizeof(_inventory[0]) * _numInventory);
|
|
memset(_newNames, 0, sizeof(_newNames[0]) * _numNewNames);
|
|
|
|
// Because old savegames won't fill the entire gfxUsageBits[] array,
|
|
// clear it here just to be sure it won't hold any unforseen garbage.
|
|
memset(gfxUsageBits, 0, sizeof(gfxUsageBits));
|
|
|
|
// Nuke all resources
|
|
for (i = rtFirst; i <= rtLast; i++)
|
|
if (i != rtTemp && i != rtBuffer && (i != rtSound || _saveSound || !compat))
|
|
for (j = 0; j < _res->num[i]; j++) {
|
|
_res->nukeResource(i, j);
|
|
}
|
|
|
|
resetScummVars();
|
|
|
|
if (_game.features & GF_OLD_BUNDLE)
|
|
loadCharset(0); // FIXME - HACK ?
|
|
|
|
//
|
|
// Now do the actual loading
|
|
//
|
|
Serializer ser(in, 0, hdr.ver);
|
|
saveOrLoad(&ser);
|
|
delete in;
|
|
|
|
// Update volume settings
|
|
syncSoundSettings();
|
|
|
|
// Init NES costume data
|
|
if (_game.platform == Common::kPlatformNES) {
|
|
if (hdr.ver < VER(47))
|
|
_NESCostumeSet = 0;
|
|
NES_loadCostumeSet(_NESCostumeSet);
|
|
}
|
|
|
|
// Normally, _vm->_screenTop should always be >= 0, but for some old save games
|
|
// it is not, hence we check & correct it here.
|
|
if (_screenTop < 0)
|
|
_screenTop = 0;
|
|
|
|
// WORKAROUND bug #795214: For unknown reasons, object 819 sometimes is in
|
|
// state 1 in old save games, implying it should be drawn. This in turn
|
|
// results in a crash when entering the church, as object 819 is part of the
|
|
// exitof the church and there are no graphics assigned to it.
|
|
if (_game.id == GID_MONKEY_VGA) {
|
|
putState(819, 0);
|
|
}
|
|
|
|
if (hdr.ver < VER(33) && _game.version >= 7) {
|
|
// For a long time, we didn't set these vars to default values.
|
|
VAR(VAR_DEFAULT_TALK_DELAY) = 60;
|
|
if (_game.version == 7)
|
|
VAR(VAR_NUM_GLOBAL_OBJS) = _numGlobalObjects - 1;
|
|
}
|
|
|
|
if (hdr.ver < VER(30)) {
|
|
// For a long time, we used incorrect location, causing it to default to zero.
|
|
if (_game.version == 8)
|
|
_scummVars[VAR_CHARINC] = (_game.features & GF_DEMO) ? 3 : 1;
|
|
// Needed due to subtitle speed changes
|
|
_defaultTalkDelay /= 20;
|
|
}
|
|
|
|
// For a long time, we used incorrect locations for some camera related
|
|
// scumm vars. We now know the proper locations. To be able to properly use
|
|
// old save games, we update the old (bad) variables to the new (correct)
|
|
// ones.
|
|
if (hdr.ver < VER(28) && _game.version == 8) {
|
|
_scummVars[VAR_CAMERA_MIN_X] = _scummVars[101];
|
|
_scummVars[VAR_CAMERA_MAX_X] = _scummVars[102];
|
|
_scummVars[VAR_CAMERA_MIN_Y] = _scummVars[103];
|
|
_scummVars[VAR_CAMERA_MAX_Y] = _scummVars[104];
|
|
_scummVars[VAR_CAMERA_THRESHOLD_X] = _scummVars[105];
|
|
_scummVars[VAR_CAMERA_THRESHOLD_Y] = _scummVars[106];
|
|
_scummVars[VAR_CAMERA_SPEED_X] = _scummVars[107];
|
|
_scummVars[VAR_CAMERA_SPEED_Y] = _scummVars[108];
|
|
_scummVars[VAR_CAMERA_ACCEL_X] = _scummVars[109];
|
|
_scummVars[VAR_CAMERA_ACCEL_Y] = _scummVars[110];
|
|
}
|
|
|
|
// For a long time, we used incorrect values for some camera related
|
|
// scumm vars. We now know the proper values. To be able to properly use
|
|
// old save games, we update the old (bad) values to the new (correct)
|
|
// ones.
|
|
if (hdr.ver < VER(77) && _game.version >= 7) {
|
|
_scummVars[VAR_CAMERA_THRESHOLD_X] = 100;
|
|
_scummVars[VAR_CAMERA_THRESHOLD_Y] = 70;
|
|
_scummVars[VAR_CAMERA_ACCEL_X] = 100;
|
|
_scummVars[VAR_CAMERA_ACCEL_Y] = 100;
|
|
}
|
|
|
|
// With version 22, we replaced the scale items with scale slots. So when
|
|
// loading such an old save game, try to upgrade the old to new format.
|
|
if (hdr.ver < VER(22)) {
|
|
// Convert all rtScaleTable resources to matching scale items
|
|
for (i = 1; i < _res->num[rtScaleTable]; i++) {
|
|
convertScaleTableToScaleSlot(i);
|
|
}
|
|
}
|
|
|
|
// Reset the palette.
|
|
resetPalette();
|
|
|
|
if (hdr.ver < VER(35) && _game.id == GID_MANIAC && _game.version <= 1)
|
|
resetV1ActorTalkColor();
|
|
|
|
// Load the static room data
|
|
setupRoomSubBlocks();
|
|
|
|
if (_game.version < 7) {
|
|
camera._last.x = camera._cur.x;
|
|
}
|
|
|
|
sb = _screenB;
|
|
sh = _screenH;
|
|
|
|
// Restore the virtual screens and force a fade to black.
|
|
initScreens(0, _screenHeight);
|
|
|
|
VirtScreen *vs = &_virtscr[kMainVirtScreen];
|
|
memset(vs->getPixels(0, 0), 0, vs->pitch * vs->h);
|
|
vs->setDirtyRange(0, vs->h);
|
|
updateDirtyScreen(kMainVirtScreen);
|
|
updatePalette();
|
|
initScreens(sb, sh);
|
|
|
|
_completeScreenRedraw = true;
|
|
|
|
// Reset charset mask
|
|
_charset->_hasMask = false;
|
|
clearTextSurface();
|
|
|
|
_lastCodePtr = NULL;
|
|
_drawObjectQueNr = 0;
|
|
_verbMouseOver = 0;
|
|
|
|
cameraMoved();
|
|
|
|
initBGBuffers(_roomHeight);
|
|
|
|
if (VAR_ROOM_FLAG != 0xFF)
|
|
VAR(VAR_ROOM_FLAG) = 1;
|
|
|
|
// Sync with current config setting
|
|
if (VAR_VOICE_MODE != 0xFF)
|
|
VAR(VAR_VOICE_MODE) = ConfMan.getBool("subtitles");
|
|
|
|
debug(1, "State loaded from '%s'", filename.c_str());
|
|
|
|
_sound->pauseSounds(false);
|
|
|
|
// WORKAROUND: Original save/load script ran this script
|
|
// after game load, and o2_loadRoomWithEgo() does as well
|
|
// this script starts character-dependent music
|
|
//
|
|
// Fixes bug #1766072: MANIACNES: Music Doesn't Start On Load Game
|
|
if (_game.platform == Common::kPlatformNES) {
|
|
runScript(5, 0, 0, 0);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
Common::String ScummEngine::makeSavegameName(const Common::String &target, int slot, bool temporary) {
|
|
char extension[6];
|
|
snprintf(extension, sizeof(extension), ".%c%02d", temporary ? 'c' : 's', slot);
|
|
return (target + extension);
|
|
}
|
|
|
|
void ScummEngine::listSavegames(bool *marks, int num) {
|
|
assert(marks);
|
|
|
|
char slot[3];
|
|
int slotNum;
|
|
Common::StringList files;
|
|
|
|
Common::String prefix = makeSavegameName(99, false);
|
|
prefix.setChar('*', prefix.size()-2);
|
|
prefix.setChar(0, prefix.size()-1);
|
|
memset(marks, false, num * sizeof(bool)); //assume no savegames for this title
|
|
files = _saveFileMan->listSavefiles(prefix);
|
|
|
|
for (Common::StringList::const_iterator file = files.begin(); file != files.end(); ++file) {
|
|
//Obtain the last 2 digits of the filename, since they correspond to the save slot
|
|
slot[0] = file->c_str()[file->size()-2];
|
|
slot[1] = file->c_str()[file->size()-1];
|
|
slot[2] = 0;
|
|
|
|
slotNum = atoi(slot);
|
|
if (slotNum >= 0 && slotNum < num)
|
|
marks[slotNum] = true; //mark this slot as valid
|
|
}
|
|
}
|
|
|
|
bool getSavegameName(Common::InSaveFile *in, Common::String &desc, int heversion);
|
|
|
|
bool ScummEngine::getSavegameName(int slot, Common::String &desc) {
|
|
Common::InSaveFile *in = 0;
|
|
bool result = false;
|
|
|
|
desc.clear();
|
|
Common::String filename = makeSavegameName(slot, false);
|
|
in = _saveFileMan->openForLoading(filename);
|
|
if (in) {
|
|
result = Scumm::getSavegameName(in, desc, _game.heversion);
|
|
delete in;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool getSavegameName(Common::InSaveFile *in, Common::String &desc, int heversion) {
|
|
SaveGameHeader hdr;
|
|
|
|
if (!loadSaveGameHeader(in, hdr)) {
|
|
desc = "Invalid savegame";
|
|
return false;
|
|
}
|
|
|
|
if (hdr.ver > CURRENT_VER)
|
|
hdr.ver = TO_LE_32(hdr.ver);
|
|
if (hdr.ver < VER(7) || hdr.ver > CURRENT_VER) {
|
|
desc = "Invalid version";
|
|
return false;
|
|
}
|
|
|
|
// We (deliberately) broke HE savegame compatibility at some point.
|
|
if (hdr.ver < VER(57) && heversion >= 60) {
|
|
desc = "Unsupported version";
|
|
return false;
|
|
}
|
|
|
|
hdr.name[sizeof(hdr.name) - 1] = 0;
|
|
desc = hdr.name;
|
|
return true;
|
|
}
|
|
|
|
Graphics::Surface *ScummEngine::loadThumbnailFromSlot(const char *target, int slot) {
|
|
Common::SeekableReadStream *in;
|
|
SaveGameHeader hdr;
|
|
|
|
if (slot < 0)
|
|
return 0;
|
|
|
|
Common::String filename = ScummEngine::makeSavegameName(target, slot, false);
|
|
if (!(in = g_system->getSavefileManager()->openForLoading(filename))) {
|
|
return 0;
|
|
}
|
|
|
|
if (!loadSaveGameHeader(in, hdr)) {
|
|
delete in;
|
|
return 0;
|
|
}
|
|
|
|
if (hdr.ver > CURRENT_VER)
|
|
hdr.ver = TO_LE_32(hdr.ver);
|
|
if (hdr.ver < VER(52)) {
|
|
delete in;
|
|
return 0;
|
|
}
|
|
|
|
Graphics::Surface *thumb = 0;
|
|
if (Graphics::checkThumbnailHeader(*in)) {
|
|
thumb = new Graphics::Surface();
|
|
assert(thumb);
|
|
if (!Graphics::loadThumbnail(*in, *thumb)) {
|
|
delete thumb;
|
|
thumb = 0;
|
|
}
|
|
}
|
|
|
|
delete in;
|
|
return thumb;
|
|
}
|
|
|
|
bool ScummEngine::loadInfosFromSlot(const char *target, int slot, InfoStuff *stuff) {
|
|
Common::SeekableReadStream *in;
|
|
SaveGameHeader hdr;
|
|
|
|
if (slot < 0)
|
|
return 0;
|
|
|
|
Common::String filename = makeSavegameName(target, slot, false);
|
|
if (!(in = g_system->getSavefileManager()->openForLoading(filename))) {
|
|
return false;
|
|
}
|
|
|
|
if (!loadSaveGameHeader(in, hdr)) {
|
|
delete in;
|
|
return false;
|
|
}
|
|
|
|
if (hdr.ver > CURRENT_VER)
|
|
hdr.ver = TO_LE_32(hdr.ver);
|
|
if (hdr.ver < VER(56)) {
|
|
delete in;
|
|
return false;
|
|
}
|
|
|
|
if (!Graphics::skipThumbnailHeader(*in)) {
|
|
delete in;
|
|
return false;
|
|
}
|
|
|
|
if (!loadInfos(in, stuff)) {
|
|
delete in;
|
|
return false;
|
|
}
|
|
|
|
delete in;
|
|
return true;
|
|
}
|
|
|
|
bool ScummEngine::loadInfos(Common::SeekableReadStream *file, InfoStuff *stuff) {
|
|
memset(stuff, 0, sizeof(InfoStuff));
|
|
|
|
SaveInfoSection section;
|
|
section.type = file->readUint32BE();
|
|
if (section.type != MKID_BE('INFO')) {
|
|
return false;
|
|
}
|
|
|
|
section.version = file->readUint32BE();
|
|
section.size = file->readUint32BE();
|
|
|
|
// If we ever extend this we should add a table containing the sizes corresponding to each
|
|
// version, so that we are able to properly verify their correctness.
|
|
if (section.version == INFOSECTION_VERSION && section.size != SaveInfoSectionSize) {
|
|
warning("Info section is corrupt");
|
|
file->skip(section.size);
|
|
return false;
|
|
}
|
|
|
|
section.timeTValue = file->readUint32BE();
|
|
section.playtime = file->readUint32BE();
|
|
|
|
// For header version 1, we load the data in with our old method
|
|
if (section.version == 1) {
|
|
//time_t tmp = section.timeTValue;
|
|
//tm *curTime = localtime(&tmp);
|
|
//stuff->date = (curTime->tm_mday & 0xFF) << 24 | ((curTime->tm_mon + 1) & 0xFF) << 16 | (curTime->tm_year + 1900) & 0xFFFF;
|
|
//stuff->time = (curTime->tm_hour & 0xFF) << 8 | (curTime->tm_min) & 0xFF;
|
|
stuff->date = 0;
|
|
stuff->time = 0;
|
|
}
|
|
|
|
if (section.version >= 2) {
|
|
section.date = file->readUint32BE();
|
|
section.time = file->readUint16BE();
|
|
|
|
stuff->date = section.date;
|
|
stuff->time = section.time;
|
|
}
|
|
|
|
stuff->playtime = section.playtime;
|
|
|
|
// Skip over the remaining (unsupported) data
|
|
if (section.size > SaveInfoSectionSize)
|
|
file->skip(section.size - SaveInfoSectionSize);
|
|
|
|
return true;
|
|
}
|
|
|
|
void ScummEngine::saveInfos(Common::WriteStream* file) {
|
|
SaveInfoSection section;
|
|
section.type = MKID_BE('INFO');
|
|
section.version = INFOSECTION_VERSION;
|
|
section.size = SaveInfoSectionSize;
|
|
|
|
// still save old format for older versions
|
|
section.timeTValue = 0;
|
|
section.playtime = _system->getMillis() / 1000 - _engineStartTime;
|
|
|
|
TimeDate curTime;
|
|
_system->getTimeAndDate(curTime);
|
|
|
|
section.date = ((curTime.tm_mday & 0xFF) << 24) | (((curTime.tm_mon + 1) & 0xFF) << 16) | ((curTime.tm_year + 1900) & 0xFFFF);
|
|
section.time = ((curTime.tm_hour & 0xFF) << 8) | ((curTime.tm_min) & 0xFF);
|
|
|
|
file->writeUint32BE(section.type);
|
|
file->writeUint32BE(section.version);
|
|
file->writeUint32BE(section.size);
|
|
file->writeUint32BE(section.timeTValue);
|
|
file->writeUint32BE(section.playtime);
|
|
file->writeUint32BE(section.date);
|
|
file->writeUint16BE(section.time);
|
|
}
|
|
|
|
void ScummEngine::saveOrLoad(Serializer *s) {
|
|
const SaveLoadEntry objectEntries[] = {
|
|
MKLINE(ObjectData, OBIMoffset, sleUint32, VER(8)),
|
|
MKLINE(ObjectData, OBCDoffset, sleUint32, VER(8)),
|
|
MKLINE(ObjectData, walk_x, sleUint16, VER(8)),
|
|
MKLINE(ObjectData, walk_y, sleUint16, VER(8)),
|
|
MKLINE(ObjectData, obj_nr, sleUint16, VER(8)),
|
|
MKLINE(ObjectData, x_pos, sleInt16, VER(8)),
|
|
MKLINE(ObjectData, y_pos, sleInt16, VER(8)),
|
|
MKLINE(ObjectData, width, sleUint16, VER(8)),
|
|
MKLINE(ObjectData, height, sleUint16, VER(8)),
|
|
MKLINE(ObjectData, actordir, sleByte, VER(8)),
|
|
MKLINE(ObjectData, parentstate, sleByte, VER(8)),
|
|
MKLINE(ObjectData, parent, sleByte, VER(8)),
|
|
MKLINE(ObjectData, state, sleByte, VER(8)),
|
|
MKLINE(ObjectData, fl_object_index, sleByte, VER(8)),
|
|
MKLINE(ObjectData, flags, sleByte, VER(46)),
|
|
MKEND()
|
|
};
|
|
|
|
const SaveLoadEntry verbEntries[] = {
|
|
MKLINE(VerbSlot, curRect.left, sleInt16, VER(8)),
|
|
MKLINE(VerbSlot, curRect.top, sleInt16, VER(8)),
|
|
MKLINE(VerbSlot, curRect.right, sleInt16, VER(8)),
|
|
MKLINE(VerbSlot, curRect.bottom, sleInt16, VER(8)),
|
|
MKLINE(VerbSlot, oldRect.left, sleInt16, VER(8)),
|
|
MKLINE(VerbSlot, oldRect.top, sleInt16, VER(8)),
|
|
MKLINE(VerbSlot, oldRect.right, sleInt16, VER(8)),
|
|
MKLINE(VerbSlot, oldRect.bottom, sleInt16, VER(8)),
|
|
|
|
MKLINE_OLD(VerbSlot, verbid, sleByte, VER(8), VER(11)),
|
|
MKLINE(VerbSlot, verbid, sleInt16, VER(12)),
|
|
|
|
MKLINE(VerbSlot, color, sleByte, VER(8)),
|
|
MKLINE(VerbSlot, hicolor, sleByte, VER(8)),
|
|
MKLINE(VerbSlot, dimcolor, sleByte, VER(8)),
|
|
MKLINE(VerbSlot, bkcolor, sleByte, VER(8)),
|
|
MKLINE(VerbSlot, type, sleByte, VER(8)),
|
|
MKLINE(VerbSlot, charset_nr, sleByte, VER(8)),
|
|
MKLINE(VerbSlot, curmode, sleByte, VER(8)),
|
|
MKLINE(VerbSlot, saveid, sleByte, VER(8)),
|
|
MKLINE(VerbSlot, key, sleByte, VER(8)),
|
|
MKLINE(VerbSlot, center, sleByte, VER(8)),
|
|
MKLINE(VerbSlot, prep, sleByte, VER(8)),
|
|
MKLINE(VerbSlot, imgindex, sleUint16, VER(8)),
|
|
MKEND()
|
|
};
|
|
|
|
const SaveLoadEntry mainEntries[] = {
|
|
MKARRAY(ScummEngine, _gameMD5[0], sleUint8, 16, VER(39)),
|
|
MK_OBSOLETE(ScummEngine, _roomWidth, sleUint16, VER(8), VER(50)),
|
|
MK_OBSOLETE(ScummEngine, _roomHeight, sleUint16, VER(8), VER(50)),
|
|
MK_OBSOLETE(ScummEngine, _ENCD_offs, sleUint32, VER(8), VER(50)),
|
|
MK_OBSOLETE(ScummEngine, _EXCD_offs, sleUint32, VER(8), VER(50)),
|
|
MK_OBSOLETE(ScummEngine, _IM00_offs, sleUint32, VER(8), VER(50)),
|
|
MK_OBSOLETE(ScummEngine, _CLUT_offs, sleUint32, VER(8), VER(50)),
|
|
MK_OBSOLETE(ScummEngine, _EPAL_offs, sleUint32, VER(8), VER(9)),
|
|
MK_OBSOLETE(ScummEngine, _PALS_offs, sleUint32, VER(8), VER(50)),
|
|
MKLINE(ScummEngine, _curPalIndex, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, _currentRoom, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, _roomResource, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, _numObjectsInRoom, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, _currentScript, sleByte, VER(8)),
|
|
MK_OBSOLETE_ARRAY(ScummEngine, _localScriptOffsets[0], sleUint32, _numLocalScripts, VER(8), VER(50)),
|
|
|
|
|
|
// vm.localvar grew from 25 to 40 script entries and then from
|
|
// 16 to 32 bit variables (but that wasn't reflect here)... and
|
|
// THEN from 16 to 25 variables.
|
|
MKARRAY2_OLD(ScummEngine, vm.localvar[0][0], sleUint16, 17, 25, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(8), VER(8)),
|
|
MKARRAY2_OLD(ScummEngine, vm.localvar[0][0], sleUint16, 17, 40, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(9), VER(14)),
|
|
|
|
// We used to save 25 * 40 = 1000 blocks; but actually, each 'row consisted of 26 entry,
|
|
// i.e. 26 * 40 = 1040. Thus the last 40 blocks of localvar where not saved at all. To be
|
|
// able to load this screwed format, we use a trick: We load 26 * 38 = 988 blocks.
|
|
// Then, we mark the followin 12 blocks (24 bytes) as obsolete.
|
|
MKARRAY2_OLD(ScummEngine, vm.localvar[0][0], sleUint16, 26, 38, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(15), VER(17)),
|
|
MK_OBSOLETE_ARRAY(ScummEngine, vm.localvar[39][0], sleUint16, 12, VER(15), VER(17)),
|
|
|
|
// This was the first proper multi dimensional version of the localvars, with 32 bit values
|
|
MKARRAY2_OLD(ScummEngine, vm.localvar[0][0], sleUint32, 26, 40, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(18), VER(19)),
|
|
|
|
// Then we doubled the script slots again, from 40 to 80
|
|
MKARRAY2(ScummEngine, vm.localvar[0][0], sleUint32, 26, NUM_SCRIPT_SLOT, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(20)),
|
|
|
|
|
|
MKARRAY(ScummEngine, _resourceMapper[0], sleByte, 128, VER(8)),
|
|
MKARRAY(ScummEngine, _charsetColorMap[0], sleByte, 16, VER(8)),
|
|
|
|
// _charsetData grew from 10*16, to 15*16, to 23*16 bytes
|
|
MKARRAY_OLD(ScummEngine, _charsetData[0][0], sleByte, 10 * 16, VER(8), VER(9)),
|
|
MKARRAY_OLD(ScummEngine, _charsetData[0][0], sleByte, 15 * 16, VER(10), VER(66)),
|
|
MKARRAY(ScummEngine, _charsetData[0][0], sleByte, 23 * 16, VER(67)),
|
|
|
|
MK_OBSOLETE(ScummEngine, _curExecScript, sleUint16, VER(8), VER(62)),
|
|
|
|
MKLINE(ScummEngine, camera._dest.x, sleInt16, VER(8)),
|
|
MKLINE(ScummEngine, camera._dest.y, sleInt16, VER(8)),
|
|
MKLINE(ScummEngine, camera._cur.x, sleInt16, VER(8)),
|
|
MKLINE(ScummEngine, camera._cur.y, sleInt16, VER(8)),
|
|
MKLINE(ScummEngine, camera._last.x, sleInt16, VER(8)),
|
|
MKLINE(ScummEngine, camera._last.y, sleInt16, VER(8)),
|
|
MKLINE(ScummEngine, camera._accel.x, sleInt16, VER(8)),
|
|
MKLINE(ScummEngine, camera._accel.y, sleInt16, VER(8)),
|
|
MKLINE(ScummEngine, _screenStartStrip, sleInt16, VER(8)),
|
|
MKLINE(ScummEngine, _screenEndStrip, sleInt16, VER(8)),
|
|
MKLINE(ScummEngine, camera._mode, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, camera._follows, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, camera._leftTrigger, sleInt16, VER(8)),
|
|
MKLINE(ScummEngine, camera._rightTrigger, sleInt16, VER(8)),
|
|
MKLINE(ScummEngine, camera._movingToActor, sleUint16, VER(8)),
|
|
|
|
MKLINE(ScummEngine, _actorToPrintStrFor, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, _charsetColor, sleByte, VER(8)),
|
|
|
|
// _charsetBufPos was changed from byte to int
|
|
MKLINE_OLD(ScummEngine, _charsetBufPos, sleByte, VER(8), VER(9)),
|
|
MKLINE(ScummEngine, _charsetBufPos, sleInt16, VER(10)),
|
|
|
|
MKLINE(ScummEngine, _haveMsg, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, _haveActorSpeechMsg, sleByte, VER(61)),
|
|
MKLINE(ScummEngine, _useTalkAnims, sleByte, VER(8)),
|
|
|
|
MKLINE(ScummEngine, _talkDelay, sleInt16, VER(8)),
|
|
MKLINE(ScummEngine, _defaultTalkDelay, sleInt16, VER(8)),
|
|
MK_OBSOLETE(ScummEngine, _numInMsgStack, sleInt16, VER(8), VER(27)),
|
|
MKLINE(ScummEngine, _sentenceNum, sleByte, VER(8)),
|
|
|
|
MKLINE(ScummEngine, vm.cutSceneStackPointer, sleByte, VER(8)),
|
|
MKARRAY(ScummEngine, vm.cutScenePtr[0], sleUint32, 5, VER(8)),
|
|
MKARRAY(ScummEngine, vm.cutSceneScript[0], sleByte, 5, VER(8)),
|
|
MKARRAY(ScummEngine, vm.cutSceneData[0], sleInt16, 5, VER(8)),
|
|
MKLINE(ScummEngine, vm.cutSceneScriptIndex, sleInt16, VER(8)),
|
|
|
|
MKLINE(ScummEngine, vm.numNestedScripts, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, _userPut, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, _userState, sleUint16, VER(17)),
|
|
MKLINE(ScummEngine, _cursor.state, sleByte, VER(8)),
|
|
MK_OBSOLETE(ScummEngine, _gdi->_cursorActive, sleByte, VER(8), VER(20)),
|
|
MKLINE(ScummEngine, _currentCursor, sleByte, VER(8)),
|
|
MKARRAY(ScummEngine, _grabbedCursor[0], sleByte, 8192, VER(20)),
|
|
MKLINE(ScummEngine, _cursor.width, sleInt16, VER(20)),
|
|
MKLINE(ScummEngine, _cursor.height, sleInt16, VER(20)),
|
|
MKLINE(ScummEngine, _cursor.hotspotX, sleInt16, VER(20)),
|
|
MKLINE(ScummEngine, _cursor.hotspotY, sleInt16, VER(20)),
|
|
MKLINE(ScummEngine, _cursor.animate, sleByte, VER(20)),
|
|
MKLINE(ScummEngine, _cursor.animateIndex, sleByte, VER(20)),
|
|
MKLINE(ScummEngine, _mouse.x, sleInt16, VER(20)),
|
|
MKLINE(ScummEngine, _mouse.y, sleInt16, VER(20)),
|
|
|
|
MKARRAY(ScummEngine, _colorUsedByCycle[0], sleByte, 256, VER(60)),
|
|
MKLINE(ScummEngine, _doEffect, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, _switchRoomEffect, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, _newEffect, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, _switchRoomEffect2, sleByte, VER(8)),
|
|
MKLINE(ScummEngine, _bgNeedsRedraw, sleByte, VER(8)),
|
|
|
|
// The state of palManipulate is stored only since V10
|
|
MKLINE(ScummEngine, _palManipStart, sleByte, VER(10)),
|
|
MKLINE(ScummEngine, _palManipEnd, sleByte, VER(10)),
|
|
MKLINE(ScummEngine, _palManipCounter, sleUint16, VER(10)),
|
|
|
|
// gfxUsageBits grew from 200 to 410 entries. Then 3 * 410 entries:
|
|
MKARRAY_OLD(ScummEngine, gfxUsageBits[0], sleUint32, 200, VER(8), VER(9)),
|
|
MKARRAY_OLD(ScummEngine, gfxUsageBits[0], sleUint32, 410, VER(10), VER(13)),
|
|
MKARRAY(ScummEngine, gfxUsageBits[0], sleUint32, 3 * 410, VER(14)),
|
|
|
|
MK_OBSOLETE(ScummEngine, _gdi->_transparentColor, sleByte, VER(8), VER(50)),
|
|
MKARRAY(ScummEngine, _currentPalette[0], sleByte, 768, VER(8)),
|
|
MKARRAY(ScummEngine, _darkenPalette[0], sleByte, 768, VER(53)),
|
|
|
|
// Sam & Max specific palette replaced by _shadowPalette now.
|
|
MK_OBSOLETE_ARRAY(ScummEngine, _proc_special_palette[0], sleByte, 256, VER(8), VER(33)),
|
|
|
|
MKARRAY(ScummEngine, _charsetBuffer[0], sleByte, 256, VER(8)),
|
|
|
|
MKLINE(ScummEngine, _egoPositioned, sleByte, VER(8)),
|
|
|
|
// _gdi->_imgBufOffs grew from 4 to 5 entries. Then one day we realized
|
|
// that we don't have to store it since initBGBuffers() recomputes it.
|
|
MK_OBSOLETE_ARRAY(ScummEngine, _gdi->_imgBufOffs[0], sleUint16, 4, VER(8), VER(9)),
|
|
MK_OBSOLETE_ARRAY(ScummEngine, _gdi->_imgBufOffs[0], sleUint16, 5, VER(10), VER(26)),
|
|
|
|
// See _imgBufOffs: _numZBuffer is recomputed by initBGBuffers().
|
|
MK_OBSOLETE(ScummEngine, _gdi->_numZBuffer, sleByte, VER(8), VER(26)),
|
|
|
|
MKLINE(ScummEngine, _screenEffectFlag, sleByte, VER(8)),
|
|
|
|
MK_OBSOLETE(ScummEngine, _randSeed1, sleUint32, VER(8), VER(9)),
|
|
MK_OBSOLETE(ScummEngine, _randSeed2, sleUint32, VER(8), VER(9)),
|
|
|
|
// Converted _shakeEnabled to boolean and added a _shakeFrame field.
|
|
MKLINE_OLD(ScummEngine, _shakeEnabled, sleInt16, VER(8), VER(9)),
|
|
MKLINE(ScummEngine, _shakeEnabled, sleByte, VER(10)),
|
|
MKLINE(ScummEngine, _shakeFrame, sleUint32, VER(10)),
|
|
|
|
MKLINE(ScummEngine, _keepText, sleByte, VER(8)),
|
|
|
|
MKLINE(ScummEngine, _screenB, sleUint16, VER(8)),
|
|
MKLINE(ScummEngine, _screenH, sleUint16, VER(8)),
|
|
|
|
MKLINE(ScummEngine, _NESCostumeSet, sleUint16, VER(47)),
|
|
|
|
MK_OBSOLETE(ScummEngine, _cd_track, sleInt16, VER(9), VER(9)),
|
|
MK_OBSOLETE(ScummEngine, _cd_loops, sleInt16, VER(9), VER(9)),
|
|
MK_OBSOLETE(ScummEngine, _cd_frame, sleInt16, VER(9), VER(9)),
|
|
MK_OBSOLETE(ScummEngine, _cd_end, sleInt16, VER(9), VER(9)),
|
|
|
|
MKEND()
|
|
};
|
|
|
|
const SaveLoadEntry scriptSlotEntries[] = {
|
|
MKLINE(ScriptSlot, offs, sleUint32, VER(8)),
|
|
MKLINE(ScriptSlot, delay, sleInt32, VER(8)),
|
|
MKLINE(ScriptSlot, number, sleUint16, VER(8)),
|
|
MKLINE(ScriptSlot, delayFrameCount, sleUint16, VER(8)),
|
|
MKLINE(ScriptSlot, status, sleByte, VER(8)),
|
|
MKLINE(ScriptSlot, where, sleByte, VER(8)),
|
|
MKLINE(ScriptSlot, freezeResistant, sleByte, VER(8)),
|
|
MKLINE(ScriptSlot, recursive, sleByte, VER(8)),
|
|
MKLINE(ScriptSlot, freezeCount, sleByte, VER(8)),
|
|
MKLINE(ScriptSlot, didexec, sleByte, VER(8)),
|
|
MKLINE(ScriptSlot, cutsceneOverride, sleByte, VER(8)),
|
|
MKLINE(ScriptSlot, cycle, sleByte, VER(46)),
|
|
MK_OBSOLETE(ScriptSlot, unk5, sleByte, VER(8), VER(10)),
|
|
MKEND()
|
|
};
|
|
|
|
const SaveLoadEntry nestedScriptEntries[] = {
|
|
MKLINE(NestedScript, number, sleUint16, VER(8)),
|
|
MKLINE(NestedScript, where, sleByte, VER(8)),
|
|
MKLINE(NestedScript, slot, sleByte, VER(8)),
|
|
MKEND()
|
|
};
|
|
|
|
const SaveLoadEntry sentenceTabEntries[] = {
|
|
MKLINE(SentenceTab, verb, sleUint8, VER(8)),
|
|
MKLINE(SentenceTab, preposition, sleUint8, VER(8)),
|
|
MKLINE(SentenceTab, objectA, sleUint16, VER(8)),
|
|
MKLINE(SentenceTab, objectB, sleUint16, VER(8)),
|
|
MKLINE(SentenceTab, freezeCount, sleUint8, VER(8)),
|
|
MKEND()
|
|
};
|
|
|
|
const SaveLoadEntry stringTabEntries[] = {
|
|
// Then _default/restore of a StringTab entry becomes a one liner.
|
|
MKLINE(StringTab, xpos, sleInt16, VER(8)),
|
|
MKLINE(StringTab, _default.xpos, sleInt16, VER(8)),
|
|
MKLINE(StringTab, ypos, sleInt16, VER(8)),
|
|
MKLINE(StringTab, _default.ypos, sleInt16, VER(8)),
|
|
MKLINE(StringTab, right, sleInt16, VER(8)),
|
|
MKLINE(StringTab, _default.right, sleInt16, VER(8)),
|
|
MKLINE(StringTab, color, sleInt8, VER(8)),
|
|
MKLINE(StringTab, _default.color, sleInt8, VER(8)),
|
|
MKLINE(StringTab, charset, sleInt8, VER(8)),
|
|
MKLINE(StringTab, _default.charset, sleInt8, VER(8)),
|
|
MKLINE(StringTab, center, sleByte, VER(8)),
|
|
MKLINE(StringTab, _default.center, sleByte, VER(8)),
|
|
MKLINE(StringTab, overhead, sleByte, VER(8)),
|
|
MKLINE(StringTab, _default.overhead, sleByte, VER(8)),
|
|
MKLINE(StringTab, no_talk_anim, sleByte, VER(8)),
|
|
MKLINE(StringTab, _default.no_talk_anim, sleByte, VER(8)),
|
|
MKLINE(StringTab, wrapping, sleByte, VER(71)),
|
|
MKLINE(StringTab, _default.wrapping, sleByte, VER(71)),
|
|
MKEND()
|
|
};
|
|
|
|
const SaveLoadEntry colorCycleEntries[] = {
|
|
MKLINE(ColorCycle, delay, sleUint16, VER(8)),
|
|
MKLINE(ColorCycle, counter, sleUint16, VER(8)),
|
|
MKLINE(ColorCycle, flags, sleUint16, VER(8)),
|
|
MKLINE(ColorCycle, start, sleByte, VER(8)),
|
|
MKLINE(ColorCycle, end, sleByte, VER(8)),
|
|
MKEND()
|
|
};
|
|
|
|
const SaveLoadEntry scaleSlotsEntries[] = {
|
|
MKLINE(ScaleSlot, x1, sleUint16, VER(13)),
|
|
MKLINE(ScaleSlot, y1, sleUint16, VER(13)),
|
|
MKLINE(ScaleSlot, scale1, sleUint16, VER(13)),
|
|
MKLINE(ScaleSlot, x2, sleUint16, VER(13)),
|
|
MKLINE(ScaleSlot, y2, sleUint16, VER(13)),
|
|
MKLINE(ScaleSlot, scale2, sleUint16, VER(13)),
|
|
MKEND()
|
|
};
|
|
|
|
// MSVC6 FIX (Jamieson630):
|
|
// MSVC6 has a problem with any notation that involves
|
|
// more than one set of double colons ::
|
|
// The following MKLINE macros expand to such things
|
|
// as AudioCDManager::Status::playing, and MSVC6 has
|
|
// a fit with that. This typedef simplifies the notation
|
|
// to something MSVC6 can grasp.
|
|
typedef Audio::AudioCDManager::Status AudioCDManager_Status;
|
|
const SaveLoadEntry audioCDEntries[] = {
|
|
MKLINE(AudioCDManager_Status, playing, sleUint32, VER(24)),
|
|
MKLINE(AudioCDManager_Status, track, sleInt32, VER(24)),
|
|
MKLINE(AudioCDManager_Status, start, sleUint32, VER(24)),
|
|
MKLINE(AudioCDManager_Status, duration, sleUint32, VER(24)),
|
|
MKLINE(AudioCDManager_Status, numLoops, sleInt32, VER(24)),
|
|
MKEND()
|
|
};
|
|
|
|
int i, j;
|
|
int var120Backup;
|
|
int var98Backup;
|
|
uint8 md5Backup[16];
|
|
|
|
// MD5 Operations: Backup on load, compare, and reset.
|
|
if (s->isLoading())
|
|
memcpy(md5Backup, _gameMD5, 16);
|
|
|
|
|
|
//
|
|
// Save/load main state (many members of class ScummEngine get saved here)
|
|
//
|
|
s->saveLoadEntries(this, mainEntries);
|
|
|
|
// MD5 Operations: Backup on load, compare, and reset.
|
|
if (s->isLoading()) {
|
|
char md5str1[32+1], md5str2[32+1];
|
|
for (j = 0; j < 16; j++) {
|
|
sprintf(md5str1 + j*2, "%02x", (int)_gameMD5[j]);
|
|
sprintf(md5str2 + j*2, "%02x", (int)md5Backup[j]);
|
|
}
|
|
|
|
debug(2, "Save version: %d", s->getVersion());
|
|
debug(2, "Saved game MD5: %s", (s->getVersion() >= 39) ? md5str1 : "unknown");
|
|
|
|
if (memcmp(md5Backup, _gameMD5, 16) != 0) {
|
|
warning("Game was saved with different gamedata - you may encounter problems");
|
|
debug(1, "You have %s and save is %s.", md5str2, md5str1);
|
|
memcpy(_gameMD5, md5Backup, 16);
|
|
}
|
|
}
|
|
|
|
|
|
// Starting V14, we extended the usage bits, to be able to cope with games
|
|
// that have more than 30 actors (up to 94 are supported now, in theory).
|
|
// Since the format of the usage bits was changed by this, we have to
|
|
// convert them when loading an older savegame.
|
|
if (s->isLoading() && s->getVersion() < VER(14))
|
|
upgradeGfxUsageBits();
|
|
|
|
// When loading, move the mouse to the saved mouse position.
|
|
if (s->isLoading() && s->getVersion() >= VER(20)) {
|
|
updateCursor();
|
|
_system->warpMouse(_mouse.x, _mouse.y);
|
|
}
|
|
|
|
// Before V61, we re-used the _haveMsg flag to handle "alternative" speech
|
|
// sound files (see charset code 10).
|
|
if (s->isLoading() && s->getVersion() < VER(61)) {
|
|
if (_haveMsg == 0xFE) {
|
|
_haveActorSpeechMsg = false;
|
|
_haveMsg = 0xFF;
|
|
} else {
|
|
_haveActorSpeechMsg = true;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Save/load actors
|
|
//
|
|
for (i = 0; i < _numActors; i++)
|
|
_actors[i]->saveLoadWithSerializer(s);
|
|
|
|
|
|
//
|
|
// Save/load sound data
|
|
//
|
|
_sound->saveLoadWithSerializer(s);
|
|
|
|
|
|
//
|
|
// Save/load script data
|
|
//
|
|
if (s->getVersion() < VER(9))
|
|
s->saveLoadArrayOf(vm.slot, 25, sizeof(vm.slot[0]), scriptSlotEntries);
|
|
else if (s->getVersion() < VER(20))
|
|
s->saveLoadArrayOf(vm.slot, 40, sizeof(vm.slot[0]), scriptSlotEntries);
|
|
else
|
|
s->saveLoadArrayOf(vm.slot, NUM_SCRIPT_SLOT, sizeof(vm.slot[0]), scriptSlotEntries);
|
|
|
|
if (s->getVersion() < VER(46)) {
|
|
// When loading an old savegame, make sure that the 'cycle'
|
|
// field is set to something sensible, otherwise the scripts
|
|
// that were running probably won't be.
|
|
|
|
for (i = 0; i < NUM_SCRIPT_SLOT; i++) {
|
|
vm.slot[i].cycle = 1;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Save/load local objects
|
|
//
|
|
s->saveLoadArrayOf(_objs, _numLocalObjects, sizeof(_objs[0]), objectEntries);
|
|
if (s->isLoading() && s->getVersion() < VER(13)) {
|
|
// Since roughly v13 of the save games, the objs storage has changed a bit
|
|
for (i = _numObjectsInRoom; i < _numLocalObjects; i++) {
|
|
_objs[i].obj_nr = 0;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// Save/load misc stuff
|
|
//
|
|
s->saveLoadArrayOf(_verbs, _numVerbs, sizeof(_verbs[0]), verbEntries);
|
|
s->saveLoadArrayOf(vm.nest, 16, sizeof(vm.nest[0]), nestedScriptEntries);
|
|
s->saveLoadArrayOf(_sentence, 6, sizeof(_sentence[0]), sentenceTabEntries);
|
|
s->saveLoadArrayOf(_string, 6, sizeof(_string[0]), stringTabEntries);
|
|
s->saveLoadArrayOf(_colorCycle, 16, sizeof(_colorCycle[0]), colorCycleEntries);
|
|
if (s->getVersion() >= VER(13))
|
|
s->saveLoadArrayOf(_scaleSlots, 20, sizeof(_scaleSlots[0]), scaleSlotsEntries);
|
|
|
|
|
|
//
|
|
// Save/load resources
|
|
//
|
|
int type, idx;
|
|
if (s->getVersion() >= VER(26)) {
|
|
// New, more robust resource save/load system. This stores the type
|
|
// and index of each resource. Thus if we increase e.g. the maximum
|
|
// number of script resources, savegames won't break.
|
|
if (s->isSaving()) {
|
|
for (type = rtFirst; type <= rtLast; type++) {
|
|
if (_res->mode[type] != 1 && type != rtTemp && type != rtBuffer) {
|
|
s->saveUint16(type); // Save the res type...
|
|
for (idx = 0; idx < _res->num[type]; idx++) {
|
|
// Only save resources which actually exist...
|
|
if (_res->address[type][idx]) {
|
|
s->saveUint16(idx); // Save the index of the resource
|
|
saveResource(s, type, idx);
|
|
}
|
|
}
|
|
s->saveUint16(0xFFFF); // End marker
|
|
}
|
|
}
|
|
s->saveUint16(0xFFFF); // End marker
|
|
} else {
|
|
while ((type = s->loadUint16()) != 0xFFFF) {
|
|
while ((idx = s->loadUint16()) != 0xFFFF) {
|
|
assert(0 <= idx && idx < _res->num[type]);
|
|
loadResource(s, type, idx);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Old, fragile resource save/load system. Doesn't save resources
|
|
// with index 0, and breaks whenever we change the limit on a given
|
|
// resource type.
|
|
for (type = rtFirst; type <= rtLast; type++)
|
|
if (_res->mode[type] != 1 && type != rtTemp && type != rtBuffer) {
|
|
// For V1-V5 games, there used to be no object name resources.
|
|
// At some point this changed. But since old savegames rely on
|
|
// unchanged resource counts, we have to hard code the following check
|
|
if (_game.version < 6 && type == rtObjectName)
|
|
continue;
|
|
for (idx = 1; idx < _res->num[type]; idx++)
|
|
saveLoadResource(s, type, idx);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Save/load global object state
|
|
//
|
|
s->saveLoadArrayOf(_objectOwnerTable, _numGlobalObjects, sizeof(_objectOwnerTable[0]), sleByte);
|
|
s->saveLoadArrayOf(_objectStateTable, _numGlobalObjects, sizeof(_objectStateTable[0]), sleByte);
|
|
if (_objectRoomTable)
|
|
s->saveLoadArrayOf(_objectRoomTable, _numGlobalObjects, sizeof(_objectRoomTable[0]), sleByte);
|
|
|
|
|
|
//
|
|
// Save/load palette data
|
|
//
|
|
if (_shadowPaletteSize) {
|
|
s->saveLoadArrayOf(_shadowPalette, _shadowPaletteSize, 1, sleByte);
|
|
// _roomPalette didn't show up until V21 save games
|
|
if (s->getVersion() >= VER(21) && _game.version < 5)
|
|
s->saveLoadArrayOf(_roomPalette, sizeof(_roomPalette), 1, sleByte);
|
|
}
|
|
|
|
// PalManip data was not saved before V10 save games
|
|
if (s->getVersion() < VER(10))
|
|
_palManipCounter = 0;
|
|
if (_palManipCounter) {
|
|
if (!_palManipPalette)
|
|
_palManipPalette = (byte *)calloc(0x300, 1);
|
|
if (!_palManipIntermediatePal)
|
|
_palManipIntermediatePal = (byte *)calloc(0x600, 1);
|
|
s->saveLoadArrayOf(_palManipPalette, 0x300, 1, sleByte);
|
|
s->saveLoadArrayOf(_palManipIntermediatePal, 0x600, 1, sleByte);
|
|
}
|
|
|
|
// darkenPalette was not saved before V53
|
|
if (s->isLoading() && s->getVersion() < VER(53)) {
|
|
memcpy(_darkenPalette, _currentPalette, 768);
|
|
}
|
|
|
|
// _colorUsedByCycle was not saved before V60
|
|
if (s->isLoading() && s->getVersion() < VER(60)) {
|
|
memset(_colorUsedByCycle, 0, sizeof(_colorUsedByCycle));
|
|
}
|
|
|
|
//
|
|
// Save/load more global object state
|
|
//
|
|
s->saveLoadArrayOf(_classData, _numGlobalObjects, sizeof(_classData[0]), sleUint32);
|
|
|
|
|
|
//
|
|
// Save/load script variables
|
|
//
|
|
var120Backup = _scummVars[120];
|
|
var98Backup = _scummVars[98];
|
|
|
|
if (s->getVersion() > VER(37))
|
|
s->saveLoadArrayOf(_roomVars, _numRoomVariables, sizeof(_roomVars[0]), sleInt32);
|
|
|
|
// The variables grew from 16 to 32 bit.
|
|
if (s->getVersion() < VER(15))
|
|
s->saveLoadArrayOf(_scummVars, _numVariables, sizeof(_scummVars[0]), sleInt16);
|
|
else
|
|
s->saveLoadArrayOf(_scummVars, _numVariables, sizeof(_scummVars[0]), sleInt32);
|
|
|
|
if (_game.id == GID_TENTACLE) // Maybe misplaced, but that's the main idea
|
|
_scummVars[120] = var120Backup;
|
|
if (_game.id == GID_INDY4)
|
|
_scummVars[98] = var98Backup;
|
|
|
|
s->saveLoadArrayOf(_bitVars, _numBitVariables >> 3, 1, sleByte);
|
|
|
|
|
|
//
|
|
// Save/load a list of the locked objects
|
|
//
|
|
if (s->isSaving()) {
|
|
for (i = rtFirst; i <= rtLast; i++)
|
|
for (j = 1; j < _res->num[i]; j++) {
|
|
if (_res->isLocked(i, j)) {
|
|
s->saveByte(i);
|
|
s->saveUint16(j);
|
|
}
|
|
}
|
|
s->saveByte(0xFF);
|
|
} else {
|
|
while ((i = s->loadByte()) != 0xFF) {
|
|
j = s->loadUint16();
|
|
_res->lock(i, j);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Save/load the Audio CD status
|
|
//
|
|
if (s->getVersion() >= VER(24)) {
|
|
Audio::AudioCDManager::Status info;
|
|
if (s->isSaving())
|
|
info = AudioCD.getStatus();
|
|
s->saveLoadArrayOf(&info, 1, sizeof(info), audioCDEntries);
|
|
// If we are loading, and the music being loaded was supposed to loop
|
|
// forever, then resume playing it. This helps a lot when the audio CD
|
|
// is used to provide ambient music (see bug #788195).
|
|
if (s->isLoading() && info.playing && info.numLoops < 0)
|
|
AudioCD.play(info.track, info.numLoops, info.start, info.duration);
|
|
}
|
|
|
|
|
|
//
|
|
// Save/load the iMuse status
|
|
//
|
|
if (_imuse && (_saveSound || !_saveTemporaryState)) {
|
|
_imuse->save_or_load(s, this);
|
|
}
|
|
|
|
//
|
|
// Save/load the charset renderer state
|
|
//
|
|
if (s->getVersion() >= VER(73)) {
|
|
_charset->saveLoadWithSerializer(s);
|
|
} else if (s->isLoading()) {
|
|
if (s->getVersion() == VER(72)) {
|
|
_charset->setCurID(s->loadByte());
|
|
} else {
|
|
// Before V72, the charset id wasn't saved. This used to cause issues such
|
|
// as the one described in the bug report #1722153. For these savegames,
|
|
// we reinitialize the id using a, hopefully, sane value.
|
|
_charset->setCurID(_string[0]._default.charset);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ScummEngine_v0::saveOrLoad(Serializer *s) {
|
|
ScummEngine_v2::saveOrLoad(s);
|
|
|
|
const SaveLoadEntry v0Entrys[] = {
|
|
MKLINE(ScummEngine_v0, _currentMode, sleByte, VER(78)),
|
|
MKLINE(ScummEngine_v0, _currentLights, sleByte, VER(78)),
|
|
MKEND()
|
|
};
|
|
s->saveLoadEntries(this, v0Entrys);
|
|
}
|
|
|
|
|
|
void ScummEngine_v2::saveOrLoad(Serializer *s) {
|
|
ScummEngine::saveOrLoad(s);
|
|
|
|
const SaveLoadEntry v2Entrys[] = {
|
|
MKLINE(ScummEngine_v2, _inventoryOffset, sleUint16, VER(79)),
|
|
MKEND()
|
|
};
|
|
s->saveLoadEntries(this, v2Entrys);
|
|
|
|
// In old saves we didn't store _inventoryOffset -> reset it to
|
|
// a sane default when loading one of those.
|
|
if (s->getVersion() < 79 && s->isLoading()) {
|
|
_inventoryOffset = 0;
|
|
}
|
|
}
|
|
|
|
void ScummEngine_v5::saveOrLoad(Serializer *s) {
|
|
ScummEngine::saveOrLoad(s);
|
|
|
|
const SaveLoadEntry cursorEntries[] = {
|
|
MKARRAY2(ScummEngine_v5, _cursorImages[0][0], sleUint16, 16, 4, (byte*)_cursorImages[1] - (byte*)_cursorImages[0], VER(44)),
|
|
MKARRAY(ScummEngine_v5, _cursorHotspots[0], sleByte, 8, VER(44)),
|
|
MKEND()
|
|
};
|
|
|
|
// This is probably only needed for Loom.
|
|
s->saveLoadEntries(this, cursorEntries);
|
|
}
|
|
|
|
#ifdef ENABLE_SCUMM_7_8
|
|
void ScummEngine_v7::saveOrLoad(Serializer *s) {
|
|
ScummEngine::saveOrLoad(s);
|
|
|
|
const SaveLoadEntry subtitleQueueEntries[] = {
|
|
MKARRAY(SubtitleText, text[0], sleByte, 256, VER(61)),
|
|
MKLINE(SubtitleText, charset, sleByte, VER(61)),
|
|
MKLINE(SubtitleText, color, sleByte, VER(61)),
|
|
MKLINE(SubtitleText, xpos, sleInt16, VER(61)),
|
|
MKLINE(SubtitleText, ypos, sleInt16, VER(61)),
|
|
MKLINE(SubtitleText, actorSpeechMsg, sleByte, VER(61)),
|
|
MKEND()
|
|
};
|
|
|
|
const SaveLoadEntry V7Entries[] = {
|
|
MKLINE(ScummEngine_v7, _subtitleQueuePos, sleInt32, VER(61)),
|
|
MK_OBSOLETE(ScummEngine_v7, _verbCharset, sleInt32, VER(68), VER(68)),
|
|
MKLINE(ScummEngine_v7, _verbLineSpacing, sleInt32, VER(68)),
|
|
MKEND()
|
|
};
|
|
|
|
_imuseDigital->saveOrLoad(s);
|
|
|
|
s->saveLoadArrayOf(_subtitleQueue, ARRAYSIZE(_subtitleQueue), sizeof(_subtitleQueue[0]), subtitleQueueEntries);
|
|
s->saveLoadEntries(this, V7Entries);
|
|
|
|
if (s->getVersion() <= VER(68) && s->isLoading()) {
|
|
// WORKAROUND bug #1846049: Reset the default charset color to a sane value.
|
|
_string[0]._default.charset = 1;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void ScummEngine_v60he::saveOrLoad(Serializer *s) {
|
|
ScummEngine::saveOrLoad(s);
|
|
|
|
s->saveLoadArrayOf(_arraySlot, _numArray, sizeof(_arraySlot[0]), sleByte);
|
|
}
|
|
|
|
void ScummEngine_v70he::saveOrLoad(Serializer *s) {
|
|
ScummEngine_v60he::saveOrLoad(s);
|
|
|
|
const SaveLoadEntry HE70Entries[] = {
|
|
MKLINE(ScummEngine_v70he, _heSndSoundId, sleInt32, VER(51)),
|
|
MKLINE(ScummEngine_v70he, _heSndOffset, sleInt32, VER(51)),
|
|
MKLINE(ScummEngine_v70he, _heSndChannel, sleInt32, VER(51)),
|
|
MKLINE(ScummEngine_v70he, _heSndFlags, sleInt32, VER(51)),
|
|
MKEND()
|
|
};
|
|
|
|
s->saveLoadEntries(this, HE70Entries);
|
|
}
|
|
|
|
#ifdef ENABLE_HE
|
|
void ScummEngine_v71he::saveOrLoad(Serializer *s) {
|
|
ScummEngine_v70he::saveOrLoad(s);
|
|
|
|
const SaveLoadEntry polygonEntries[] = {
|
|
MKLINE(WizPolygon, vert[0].x, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, vert[0].y, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, vert[1].x, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, vert[1].y, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, vert[2].x, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, vert[2].y, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, vert[3].x, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, vert[3].y, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, vert[4].x, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, vert[4].y, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, bound.left, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, bound.top, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, bound.right, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, bound.bottom, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, id, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, numVerts, sleInt16, VER(40)),
|
|
MKLINE(WizPolygon, flag, sleByte, VER(40)),
|
|
MKEND()
|
|
};
|
|
|
|
s->saveLoadArrayOf(_wiz->_polygons, ARRAYSIZE(_wiz->_polygons), sizeof(_wiz->_polygons[0]), polygonEntries);
|
|
}
|
|
|
|
void ScummEngine_v90he::saveOrLoad(Serializer *s) {
|
|
ScummEngine_v71he::saveOrLoad(s);
|
|
|
|
const SaveLoadEntry floodFillEntries[] = {
|
|
MKLINE(FloodFillParameters, box.left, sleInt32, VER(51)),
|
|
MKLINE(FloodFillParameters, box.top, sleInt32, VER(51)),
|
|
MKLINE(FloodFillParameters, box.right, sleInt32, VER(51)),
|
|
MKLINE(FloodFillParameters, box.bottom, sleInt32, VER(51)),
|
|
MKLINE(FloodFillParameters, x, sleInt32, VER(51)),
|
|
MKLINE(FloodFillParameters, y, sleInt32, VER(51)),
|
|
MKLINE(FloodFillParameters, flags, sleInt32, VER(51)),
|
|
MK_OBSOLETE(FloodFillParameters, unk1C, sleInt32, VER(51), VER(62)),
|
|
MKEND()
|
|
};
|
|
|
|
const SaveLoadEntry HE90Entries[] = {
|
|
MKLINE(ScummEngine_v90he, _curMaxSpriteId, sleInt32, VER(51)),
|
|
MKLINE(ScummEngine_v90he, _curSpriteId, sleInt32, VER(51)),
|
|
MKLINE(ScummEngine_v90he, _curSpriteGroupId, sleInt32, VER(51)),
|
|
MK_OBSOLETE(ScummEngine_v90he, _numSpritesToProcess, sleInt32, VER(51), VER(63)),
|
|
MKLINE(ScummEngine_v90he, _heObject, sleInt32, VER(51)),
|
|
MKLINE(ScummEngine_v90he, _heObjectNum, sleInt32, VER(51)),
|
|
MKLINE(ScummEngine_v90he, _hePaletteNum, sleInt32, VER(51)),
|
|
MKEND()
|
|
};
|
|
|
|
_sprite->saveOrLoadSpriteData(s);
|
|
|
|
s->saveLoadArrayOf(&_floodFillParams, 1, sizeof(_floodFillParams), floodFillEntries);
|
|
|
|
s->saveLoadEntries(this, HE90Entries);
|
|
}
|
|
|
|
void ScummEngine_v99he::saveOrLoad(Serializer *s) {
|
|
ScummEngine_v90he::saveOrLoad(s);
|
|
|
|
s->saveLoadArrayOf(_hePalettes, (_numPalettes + 1) * _hePaletteSlot, sizeof(_hePalettes[0]), sleUint8);
|
|
}
|
|
|
|
void ScummEngine_v100he::saveOrLoad(Serializer *s) {
|
|
ScummEngine_v99he::saveOrLoad(s);
|
|
|
|
const SaveLoadEntry HE100Entries[] = {
|
|
MKLINE(ScummEngine_v100he, _heResId, sleInt32, VER(51)),
|
|
MKLINE(ScummEngine_v100he, _heResType, sleInt32, VER(51)),
|
|
MKEND()
|
|
};
|
|
|
|
s->saveLoadEntries(this, HE100Entries);
|
|
}
|
|
#endif
|
|
|
|
void ScummEngine::saveLoadResource(Serializer *ser, int type, int idx) {
|
|
byte *ptr;
|
|
uint32 size;
|
|
|
|
if (!_res->mode[type]) {
|
|
if (ser->isSaving()) {
|
|
ptr = _res->address[type][idx];
|
|
if (ptr == NULL) {
|
|
ser->saveUint32(0);
|
|
return;
|
|
}
|
|
|
|
size = ((MemBlkHeader *)ptr)->size;
|
|
|
|
ser->saveUint32(size);
|
|
ser->saveBytes(ptr + sizeof(MemBlkHeader), size);
|
|
|
|
if (type == rtInventory) {
|
|
ser->saveUint16(_inventory[idx]);
|
|
}
|
|
if (type == rtObjectName && ser->getVersion() >= VER(25)) {
|
|
ser->saveUint16(_newNames[idx]);
|
|
}
|
|
} else {
|
|
size = ser->loadUint32();
|
|
if (size) {
|
|
_res->createResource(type, idx, size);
|
|
ser->loadBytes(getResourceAddress(type, idx), size);
|
|
if (type == rtInventory) {
|
|
_inventory[idx] = ser->loadUint16();
|
|
}
|
|
if (type == rtObjectName && ser->getVersion() >= VER(25)) {
|
|
// Paranoia: We increased the possible number of new names
|
|
// to fix bugs #933610 and #936323. The savegame format
|
|
// didn't change, but at least during the transition
|
|
// period there is a slight chance that we try to load
|
|
// more names than we have allocated space for. If so,
|
|
// discard them.
|
|
if (idx < _numNewNames)
|
|
_newNames[idx] = ser->loadUint16();
|
|
}
|
|
}
|
|
}
|
|
} else if (_res->mode[type] == 2 && ser->getVersion() >= VER(23)) {
|
|
// Save/load only a list of resource numbers that need to be reloaded.
|
|
if (ser->isSaving()) {
|
|
ser->saveUint16(_res->address[type][idx] ? 1 : 0);
|
|
} else {
|
|
if (ser->loadUint16())
|
|
ensureResourceLoaded(type, idx);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ScummEngine::saveResource(Serializer *ser, int type, int idx) {
|
|
assert(_res->address[type][idx]);
|
|
|
|
if (_res->mode[type] == 0) {
|
|
byte *ptr = _res->address[type][idx];
|
|
uint32 size = ((MemBlkHeader *)ptr)->size;
|
|
|
|
ser->saveUint32(size);
|
|
ser->saveBytes(ptr + sizeof(MemBlkHeader), size);
|
|
|
|
if (type == rtInventory) {
|
|
ser->saveUint16(_inventory[idx]);
|
|
}
|
|
if (type == rtObjectName) {
|
|
ser->saveUint16(_newNames[idx]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ScummEngine::loadResource(Serializer *ser, int type, int idx) {
|
|
if (_game.heversion >= 60 && ser->getVersion() <= VER(65) &&
|
|
((type == rtSound && idx == 1) || (type == rtSpoolBuffer))) {
|
|
uint32 size = ser->loadUint32();
|
|
assert(size);
|
|
_res->createResource(type, idx, size);
|
|
ser->loadBytes(getResourceAddress(type, idx), size);
|
|
} else if (_res->mode[type] == 0) {
|
|
uint32 size = ser->loadUint32();
|
|
assert(size);
|
|
_res->createResource(type, idx, size);
|
|
ser->loadBytes(getResourceAddress(type, idx), size);
|
|
|
|
if (type == rtInventory) {
|
|
_inventory[idx] = ser->loadUint16();
|
|
}
|
|
if (type == rtObjectName) {
|
|
_newNames[idx] = ser->loadUint16();
|
|
}
|
|
} else if (_res->mode[type] == 2) {
|
|
// HE Games use sound resource 1 for speech
|
|
if (_game.heversion >= 60 && idx == 1)
|
|
return;
|
|
|
|
ensureResourceLoaded(type, idx);
|
|
}
|
|
}
|
|
|
|
void Serializer::saveBytes(void *b, int len) {
|
|
_saveStream->write(b, len);
|
|
}
|
|
|
|
void Serializer::loadBytes(void *b, int len) {
|
|
_loadStream->read(b, len);
|
|
}
|
|
|
|
void Serializer::saveUint32(uint32 d) {
|
|
_saveStream->writeUint32LE(d);
|
|
}
|
|
|
|
void Serializer::saveUint16(uint16 d) {
|
|
_saveStream->writeUint16LE(d);
|
|
}
|
|
|
|
void Serializer::saveByte(byte b) {
|
|
_saveStream->writeByte(b);
|
|
}
|
|
|
|
uint32 Serializer::loadUint32() {
|
|
return _loadStream->readUint32LE();
|
|
}
|
|
|
|
uint16 Serializer::loadUint16() {
|
|
return _loadStream->readUint16LE();
|
|
}
|
|
|
|
byte Serializer::loadByte() {
|
|
return _loadStream->readByte();
|
|
}
|
|
|
|
void Serializer::saveArrayOf(void *b, int len, int datasize, byte filetype) {
|
|
byte *at = (byte *)b;
|
|
uint32 data;
|
|
|
|
// speed up byte arrays
|
|
if (datasize == 1 && filetype == sleByte) {
|
|
if (len > 0) {
|
|
saveBytes(b, len);
|
|
}
|
|
return;
|
|
}
|
|
|
|
while (--len >= 0) {
|
|
if (datasize == 0) {
|
|
// Do nothing for obsolete data
|
|
data = 0;
|
|
} else if (datasize == 1) {
|
|
data = *(byte *)at;
|
|
at += 1;
|
|
} else if (datasize == 2) {
|
|
data = *(uint16 *)at;
|
|
at += 2;
|
|
} else if (datasize == 4) {
|
|
data = *(uint32 *)at;
|
|
at += 4;
|
|
} else {
|
|
error("saveArrayOf: invalid size %d", datasize);
|
|
}
|
|
switch (filetype) {
|
|
case sleByte:
|
|
saveByte((byte)data);
|
|
break;
|
|
case sleUint16:
|
|
case sleInt16:
|
|
saveUint16((int16)data);
|
|
break;
|
|
case sleInt32:
|
|
case sleUint32:
|
|
saveUint32(data);
|
|
break;
|
|
default:
|
|
error("saveArrayOf: invalid filetype %d", filetype);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Serializer::loadArrayOf(void *b, int len, int datasize, byte filetype) {
|
|
byte *at = (byte *)b;
|
|
uint32 data;
|
|
|
|
// speed up byte arrays
|
|
if (datasize == 1 && filetype == sleByte) {
|
|
loadBytes(b, len);
|
|
return;
|
|
}
|
|
|
|
while (--len >= 0) {
|
|
switch (filetype) {
|
|
case sleByte:
|
|
data = loadByte();
|
|
break;
|
|
case sleUint16:
|
|
data = loadUint16();
|
|
break;
|
|
case sleInt16:
|
|
data = (int16)loadUint16();
|
|
break;
|
|
case sleUint32:
|
|
data = loadUint32();
|
|
break;
|
|
case sleInt32:
|
|
data = (int32)loadUint32();
|
|
break;
|
|
default:
|
|
error("loadArrayOf: invalid filetype %d", filetype);
|
|
}
|
|
if (datasize == 0) {
|
|
// Do nothing for obsolete data
|
|
} else if (datasize == 1) {
|
|
*(byte *)at = (byte)data;
|
|
at += 1;
|
|
} else if (datasize == 2) {
|
|
*(uint16 *)at = (uint16)data;
|
|
at += 2;
|
|
} else if (datasize == 4) {
|
|
*(uint32 *)at = data;
|
|
at += 4;
|
|
} else {
|
|
error("loadArrayOf: invalid size %d", datasize);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Serializer::saveLoadArrayOf(void *b, int num, int datasize, const SaveLoadEntry *sle) {
|
|
byte *data = (byte *)b;
|
|
|
|
if (isSaving()) {
|
|
while (--num >= 0) {
|
|
saveEntries(data, sle);
|
|
data += datasize;
|
|
}
|
|
} else {
|
|
while (--num >= 0) {
|
|
loadEntries(data, sle);
|
|
data += datasize;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Serializer::saveLoadArrayOf(void *b, int len, int datasize, byte filetype) {
|
|
if (isSaving())
|
|
saveArrayOf(b, len, datasize, filetype);
|
|
else
|
|
loadArrayOf(b, len, datasize, filetype);
|
|
}
|
|
|
|
void Serializer::saveLoadEntries(void *d, const SaveLoadEntry *sle) {
|
|
if (isSaving())
|
|
saveEntries(d, sle);
|
|
else
|
|
loadEntries(d, sle);
|
|
}
|
|
|
|
void Serializer::saveEntries(void *d, const SaveLoadEntry *sle) {
|
|
byte type;
|
|
byte *at;
|
|
int size;
|
|
|
|
while (sle->offs != 0xFFFF) {
|
|
at = (byte *)d + sle->offs;
|
|
size = sle->size;
|
|
type = (byte) sle->type;
|
|
|
|
if (sle->maxVersion != CURRENT_VER) {
|
|
// Skip obsolete entries
|
|
if (type & 128)
|
|
sle++;
|
|
} else {
|
|
// save entry
|
|
int columns = 1;
|
|
int rows = 1;
|
|
int rowlen = 0;
|
|
if (type & 128) {
|
|
sle++;
|
|
columns = sle->offs;
|
|
rows = sle->type;
|
|
rowlen = sle->size;
|
|
type &= ~128;
|
|
}
|
|
while (rows--) {
|
|
saveArrayOf(at, columns, size, type);
|
|
at += rowlen;
|
|
}
|
|
}
|
|
sle++;
|
|
}
|
|
}
|
|
|
|
void Serializer::loadEntries(void *d, const SaveLoadEntry *sle) {
|
|
byte type;
|
|
byte *at;
|
|
int size;
|
|
|
|
while (sle->offs != 0xFFFF) {
|
|
at = (byte *)d + sle->offs;
|
|
size = sle->size;
|
|
type = (byte) sle->type;
|
|
|
|
if (_savegameVersion < sle->minVersion || _savegameVersion > sle->maxVersion) {
|
|
// Skip entries which are not present in this save game version
|
|
if (type & 128)
|
|
sle++;
|
|
} else {
|
|
// load entry
|
|
int columns = 1;
|
|
int rows = 1;
|
|
int rowlen = 0;
|
|
|
|
if (type & 128) {
|
|
sle++;
|
|
columns = sle->offs;
|
|
rows = sle->type;
|
|
rowlen = sle->size;
|
|
type &= ~128;
|
|
}
|
|
while (rows--) {
|
|
loadArrayOf(at, columns, size, type);
|
|
at += rowlen;
|
|
}
|
|
}
|
|
sle++;
|
|
}
|
|
}
|
|
|
|
} // End of namespace Scumm
|