scummvm/engines/sherlock/saveload.cpp
Orgad Shaneh fe104cc337 ENGINES: Use MetaEngine consistently for getting autosave slot
The autosave refactoring that was done in
7adad5aaf5 used g_engine for identifying the
autosave slot. This worked for in-game save/load, but doesn't fit when
called from the launcher.

Fix by passing MetaEngine to SaveStateDescriptor ctor and using it for this
query.

Amends 7adad5aaf5.
2021-10-24 16:46:06 +02:00

273 lines
7.8 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 "sherlock/saveload.h"
#include "sherlock/surface.h"
#include "sherlock/sherlock.h"
#include "sherlock/scalpel/scalpel_saveload.h"
#include "sherlock/tattoo/widget_files.h"
#include "common/system.h"
#include "graphics/scaler.h"
#include "graphics/thumbnail.h"
namespace Sherlock {
const char *const EMPTY_SAVEGAME_SLOT = "-EMPTY-";
static const char *const SAVEGAME_STR = "SHLK";
#define SAVEGAME_STR_SIZE 4
/*----------------------------------------------------------------*/
SaveManager *SaveManager::init(SherlockEngine *vm, const Common::String &target) {
if (vm->getGameID() == GType_SerratedScalpel)
return new Scalpel::ScalpelSaveManager(vm, target);
else
return new Tattoo::WidgetFiles(vm, target);
}
SaveManager::SaveManager(SherlockEngine *vm, const Common::String &target) :
_vm(vm), _target(target) {
_saveThumb = nullptr;
_justLoaded = false;
_savegameIndex = 0;
}
SaveManager::~SaveManager() {
if (_saveThumb) {
_saveThumb->free();
delete _saveThumb;
}
}
void SaveManager::createSavegameList() {
Screen &screen = *_vm->_screen;
_savegames.clear();
for (int idx = 0; idx < MAX_SAVEGAME_SLOTS; ++idx)
_savegames.push_back(EMPTY_SAVEGAME_SLOT);
SaveStateList saveList = getSavegameList(_vm->getMetaEngine(), _target);
for (uint idx = 0; idx < saveList.size(); ++idx) {
int slot = saveList[idx].getSaveSlot();
if (slot >= 0 && slot < MAX_SAVEGAME_SLOTS)
_savegames[slot] = saveList[idx].getDescription();
}
// Ensure the names will fit on the screen
for (uint idx = 0; idx < _savegames.size(); ++idx) {
int width = screen.stringWidth(_savegames[idx]) + 24;
if (width > 308) {
// It won't fit in, so remove characters until it does
do {
width -= screen.charWidth(_savegames[idx].lastChar());
_savegames[idx].deleteLastChar();
} while (width > 300);
}
}
}
SaveStateList SaveManager::getSavegameList(const MetaEngine *metaEngine, const Common::String &target) {
Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
Common::StringArray filenames;
Common::String saveDesc;
Common::String pattern = Common::String::format("%s.0##", target.c_str());
SherlockSavegameHeader header;
filenames = saveFileMan->listSavefiles(pattern);
SaveStateList saveList;
for (Common::StringArray::const_iterator file = filenames.begin(); file != filenames.end(); ++file) {
const char *ext = strrchr(file->c_str(), '.');
int slot = ext ? atoi(ext + 1) : -1;
if (slot >= 0 && slot < MAX_SAVEGAME_SLOTS) {
Common::InSaveFile *in = g_system->getSavefileManager()->openForLoading(*file);
if (in) {
if (readSavegameHeader(in, header))
saveList.push_back(SaveStateDescriptor(metaEngine, slot, header._saveName));
delete in;
}
}
}
Common::sort(saveList.begin(), saveList.end(), SaveStateDescriptorSlotComparator());
return saveList;
}
WARN_UNUSED_RESULT bool SaveManager::readSavegameHeader(Common::InSaveFile *in, SherlockSavegameHeader &header, bool skipThumbnail) {
char saveIdentBuffer[SAVEGAME_STR_SIZE + 1];
// Validate the header Id
in->read(saveIdentBuffer, SAVEGAME_STR_SIZE + 1);
if (strncmp(saveIdentBuffer, SAVEGAME_STR, SAVEGAME_STR_SIZE))
return false;
header._version = in->readByte();
if (header._version < MINIMUM_SAVEGAME_VERSION || header._version > CURRENT_SAVEGAME_VERSION)
return false;
// Read in the string
header._saveName.clear();
char ch;
while ((ch = (char)in->readByte()) != '\0') header._saveName += ch;
// Get the thumbnail
if (!Graphics::loadThumbnail(*in, header._thumbnail, skipThumbnail)) {
return false;
}
// Read in save date/time
header._year = in->readSint16LE();
header._month = in->readSint16LE();
header._day = in->readSint16LE();
header._hour = in->readSint16LE();
header._minute = in->readSint16LE();
header._totalFrames = in->readUint32LE();
return true;
}
void SaveManager::writeSavegameHeader(Common::OutSaveFile *out, SherlockSavegameHeader &header) {
// Write out a savegame header
out->write(SAVEGAME_STR, SAVEGAME_STR_SIZE + 1);
out->writeByte(CURRENT_SAVEGAME_VERSION);
// Write savegame name
out->write(header._saveName.c_str(), header._saveName.size());
out->writeByte('\0');
// Handle the thumbnail. If there's already one set by the game, create one
if (!_saveThumb)
createThumbnail();
Graphics::saveThumbnail(*out, *_saveThumb);
_saveThumb->free();
delete _saveThumb;
_saveThumb = nullptr;
// Write out the save date/time
TimeDate td;
g_system->getTimeAndDate(td);
out->writeSint16LE(td.tm_year + 1900);
out->writeSint16LE(td.tm_mon + 1);
out->writeSint16LE(td.tm_mday);
out->writeSint16LE(td.tm_hour);
out->writeSint16LE(td.tm_min);
out->writeUint32LE(_vm->_events->getFrameCounter());
}
void SaveManager::createThumbnail() {
if (_saveThumb) {
_saveThumb->free();
delete _saveThumb;
}
_saveThumb = new Graphics::Surface();
if (!IS_3DO) {
uint8 thumbPalette[PALETTE_SIZE];
_vm->_screen->getPalette(thumbPalette);
::createThumbnail(_saveThumb, (const byte *)_vm->_screen->getPixels(), SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT, thumbPalette);
} else {
::createThumbnailFromScreen(_saveThumb);
}
}
void SaveManager::loadGame(int slot) {
Events &events = *_vm->_events;
Common::InSaveFile *saveFile = g_system->getSavefileManager()->openForLoading(
generateSaveName(slot));
if (!saveFile)
return;
// Load the savaegame header
SherlockSavegameHeader header;
if (!readSavegameHeader(saveFile, header))
error("Invalid savegame");
// Synchronize the savegame data
Serializer s(saveFile, nullptr);
s.setVersion(header._version);
synchronize(s);
delete saveFile;
events.clearEvents();
}
void SaveManager::saveGame(int slot, const Common::String &name) {
Events &events = *_vm->_events;
Common::OutSaveFile *out = g_system->getSavefileManager()->openForSaving(
generateSaveName(slot));
SherlockSavegameHeader header;
header._saveName = name;
writeSavegameHeader(out, header);
// Synchronize the savegame data
Serializer s(nullptr, out);
s.setVersion(CURRENT_SAVEGAME_VERSION);
synchronize(s);
out->finalize();
delete out;
events.clearEvents();
}
Common::String SaveManager::generateSaveName(int slot) {
return Common::String::format("%s.%03d", _target.c_str(), slot);
}
void SaveManager::synchronize(Serializer &s) {
Inventory &inv = *_vm->_inventory;
Journal &journal = *_vm->_journal;
Map &map = *_vm->_map;
People &people = *_vm->_people;
Scene &scene = *_vm->_scene;
Screen &screen = *_vm->_screen;
Talk &talk = *_vm->_talk;
int oldFont = screen.fontNumber();
inv.synchronize(s);
journal.synchronize(s);
people.synchronize(s);
map.synchronize(s);
scene.synchronize(s);
screen.synchronize(s);
talk.synchronize(s);
_vm->synchronize(s);
if (screen.fontNumber() != oldFont)
journal.resetPosition();
_justLoaded = s.isLoading();
}
bool SaveManager::isSlotEmpty(int slot) const {
return _savegames[slot].equalsIgnoreCase(EMPTY_SAVEGAME_SLOT);
}
} // End of namespace Sherlock