void SaveLoad_ns::setPartComplete(const char *part) {
Common::String s;
bool alreadyPresent = false;
Common::InSaveFile *inFile = getInSaveFile(SPECIAL_SAVESLOT);
if (inFile) {
s = inFile->readLine();
delete inFile;
if (s.contains(part)) {
alreadyPresent = true;
}
}
if (!alreadyPresent) {
Common::OutSaveFile *outFile = getOutSaveFile(SPECIAL_SAVESLOT);
outFile->writeString(s);
outFile->writeString(part);
outFile->finalize();
delete outFile;
}
}
Common::Error Saver::save(int slot, const Common::String &saveName) {
assert(!getMacroRestoreFlag());
Common::StackLock slock1(g_globals->_soundManager._serverDisabledMutex);
// Signal any objects registered for notification
_saveNotifiers.notify(false);
// Set fields
_macroSaveFlag = true;
_saveSlot = slot;
// Try and create the save file
Common::OutSaveFile *saveFile = g_system->getSavefileManager()->openForSaving(g_vm->generateSaveName(slot));
if (!saveFile)
return Common::kCreatingFileFailed;
// Set up the serializer
Serializer serializer(NULL, saveFile);
serializer.setSaveVersion(TSAGE_SAVEGAME_VERSION);
// Write out the savegame header
tSageSavegameHeader header;
header.saveName = saveName;
header.version = TSAGE_SAVEGAME_VERSION;
writeSavegameHeader(saveFile, header);
// Save out objects that need to come at the start of the savegame
for (SynchronizedList<SaveListener *>::iterator i = _listeners.begin(); i != _listeners.end(); ++i) {
(*i)->listenerSynchronize(serializer);
}
// Save each registered SaveObject descendant object into the savegame file
for (SynchronizedList<SavedObject *>::iterator i = _objList.begin(); i != _objList.end(); ++i) {
SavedObject *so = *i;
serializer.validate(so->getClassName());
so->synchronize(serializer);
}
// Save file complete
saveFile->writeString("END");
saveFile->finalize();
delete saveFile;
// Final post-save notification
_macroSaveFlag = false;
_saveNotifiers.notify(true);
return Common::kNoError;
}
/**
* This test creates a savefile for the given testbed-state and could be reloaded using the saveFile API.
* It is intended to test saving and loading from savefiles.
*/
bool SaveGametests::writeDataToFile(const char *fileName, const char *msg) {
Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
Common::OutSaveFile *saveFile = saveFileMan->openForSaving(fileName);
if (!saveFile) {
Testsuite::logDetailedPrintf("Can't open saveFile %s\n", fileName);
return false;
}
saveFile->writeString(msg);
saveFile->finalize();
delete saveFile;
return true;
}
void SaveLoad_ns::doSaveGame(uint16 slot, const char* name) {
Common::OutSaveFile *f = getOutSaveFile(slot);
if (f == 0) {
char buf[32];
sprintf(buf, "Can't save game in slot %i\n\n", slot);
GUI::MessageDialog dialog(buf);
dialog.runModal();
return;
}
char s[200];
memset(s, 0, sizeof(s));
if (!name || name[0] == '\0') {
sprintf(s, "default_%i", slot);
} else {
strncpy(s, name, 199);
}
f->writeString(s);
f->writeString("\n");
sprintf(s, "%s\n", _vm->_char.getFullName());
f->writeString(s);
sprintf(s, "%s\n", _saveData1);
f->writeString(s);
sprintf(s, "%d\n", _vm->_char._ani->getX());
f->writeString(s);
sprintf(s, "%d\n", _vm->_char._ani->getY());
f->writeString(s);
sprintf(s, "%d\n", _vm->_score);
f->writeString(s);
sprintf(s, "%u\n", _globalFlags);
f->writeString(s);
sprintf(s, "%d\n", _vm->_numLocations);
f->writeString(s);
for (uint16 _si = 0; _si < _vm->_numLocations; _si++) {
sprintf(s, "%s\n%u\n", _vm->_locationNames[_si], _vm->_localFlags[_si]);
f->writeString(s);
}
const InventoryItem *item;
for (uint16 _si = 0; _si < 30; _si++) {
item = _vm->getInventoryItem(_si);
sprintf(s, "%u\n%d\n", item->_id, item->_index);
f->writeString(s);
}
delete f;
}
bool PersistenceService::saveGame(uint slotID, const Common::String &screenshotFilename) {
// FIXME: This code is a hack which bypasses the savefile API,
// and should eventually be removed.
// Überprüfen, ob die Slot-ID zulässig ist.
if (slotID >= SLOT_COUNT) {
error("Tried to save to an invalid slot (%d). Only slot ids form 0 to %d are allowed.", slotID, SLOT_COUNT - 1);
return false;
}
// Dateinamen erzeugen.
Common::String filename = generateSavegameFilename(slotID);
// Spielstanddatei öffnen und die Headerdaten schreiben.
Common::SaveFileManager *sfm = g_system->getSavefileManager();
Common::OutSaveFile *file = sfm->openForSaving(filename);
file->writeString(FILE_MARKER);
file->writeByte(0);
file->writeString(VERSIONID);
file->writeByte(0);
char buf[20];
snprintf(buf, 20, "%d", VERSIONNUM);
file->writeString(buf);
file->writeByte(0);
TimeDate dt;
g_system->getTimeAndDate(dt);
file->writeString(formatTimestamp(dt));
file->writeByte(0);
if (file->err()) {
error("Unable to write header data to savegame file \"%s\".", filename.c_str());
}
// Alle notwendigen Module persistieren.
OutputPersistenceBlock writer;
bool success = true;
success &= Kernel::getInstance()->getScript()->persist(writer);
success &= RegionRegistry::instance().persist(writer);
success &= Kernel::getInstance()->getGfx()->persist(writer);
success &= Kernel::getInstance()->getSfx()->persist(writer);
success &= Kernel::getInstance()->getInput()->persist(writer);
if (!success) {
error("Unable to persist modules for savegame file \"%s\".", filename.c_str());
}
// Write the save game data uncompressed, since the final saved game will be
// compressed anyway.
char sBuffer[10];
snprintf(sBuffer, 10, "%u", writer.getDataSize());
file->writeString(sBuffer);
file->writeByte(0);
snprintf(sBuffer, 10, "%u", writer.getDataSize());
file->writeString(sBuffer);
file->writeByte(0);
file->write(writer.getData(), writer.getDataSize());
// Get the screenshot
Common::SeekableReadStream *thumbnail = Kernel::getInstance()->getGfx()->getThumbnail();
if (thumbnail) {
byte *buffer = new byte[FILE_COPY_BUFFER_SIZE];
thumbnail->seek(0, SEEK_SET);
while (!thumbnail->eos()) {
int bytesRead = thumbnail->read(&buffer[0], FILE_COPY_BUFFER_SIZE);
file->write(&buffer[0], bytesRead);
}
delete[] buffer;
} else {
warning("The screenshot file \"%s\" does not exist. Savegame is written without a screenshot.", filename.c_str());
}
file->finalize();
delete file;
// Savegameinformationen für diesen Slot aktualisieren.
_impl->readSlotSavegameInformation(slotID);
// Empty the cache, to remove old thumbnails
Kernel::getInstance()->getResourceManager()->emptyThumbnailCache();
// Erfolg signalisieren.
return true;
}
bool DrasculaEngine::saveLoadScreen() {
char names[10][23];
char file[50];
char fileEpa[50];
int n, n2, num_sav = 0, y = 27;
Common::InSaveFile *sav;
clearRoom();
snprintf(fileEpa, 50, "%s.epa", _targetName.c_str());
if (!(sav = _saveFileMan->openForLoading(fileEpa))) {
Common::OutSaveFile *epa;
if (!(epa = _saveFileMan->openForSaving(fileEpa)))
error("Can't open %s file", fileEpa);
for (n = 0; n < NUM_SAVES; n++)
epa->writeString("*\n");
epa->finalize();
delete epa;
if (!(sav = _saveFileMan->openForLoading(fileEpa))) {
error("Can't open %s file", fileEpa);
}
}
for (n = 0; n < NUM_SAVES; n++) {
strncpy(names[n], sav->readLine().c_str(), 23);
names[n][22] = '\0'; // make sure the savegame name is 0-terminated
}
delete sav;
loadPic("savescr.alg", bgSurface, HALF_PAL);
color_abc(kColorLightGreen);
select[0] = 0;
_system->setFeatureState(OSystem::kFeatureVirtualKeyboard, true);
setCursor(kCursorCrosshair);
while (!shouldQuit()) {
y = 27;
copyBackground();
for (n = 0; n < NUM_SAVES; n++) {
print_abc(names[n], 116, y);
y = y + 9;
}
print_abc(select, 117, 15);
updateScreen();
y = 27;
updateEvents();
if (leftMouseButton == 1) {
delay(50);
for (n = 0; n < NUM_SAVES; n++) {
if (mouseX > 115 && mouseY > y + (9 * n) && mouseX < 115 + 175 && mouseY < y + 10 + (9 * n)) {
strcpy(select, names[n]);
if (strcmp(select, "*"))
selectionMade = 1;
else {
enterName();
strcpy(names[n], select);
if (selectionMade == 1) {
snprintf(file, 50, "%s%02d", _targetName.c_str(), n + 1);
saveGame(file);
Common::OutSaveFile *tsav;
if (!(tsav = _saveFileMan->openForSaving(fileEpa))) {
error("Can't open %s file", fileEpa);
}
for (n = 0; n < NUM_SAVES; n++) {
tsav->writeString(names[n]);
tsav->writeString("\n");
}
tsav->finalize();
delete tsav;
}
}
print_abc(select, 117, 15);
y = 27;
for (n2 = 0; n2 < NUM_SAVES; n2++) {
print_abc(names[n2], 116, y);
y = y + 9;
}
if (selectionMade == 1) {
snprintf(file, 50, "%s%02d", _targetName.c_str(), n + 1);
}
num_sav = n;
}
}
if (mouseX > 117 && mouseY > 15 && mouseX < 295 && mouseY < 24 && selectionMade == 1) {
enterName();
strcpy(names[num_sav], select);
print_abc(select, 117, 15);
y = 27;
for (n2 = 0; n2 < NUM_SAVES; n2++) {
print_abc(names[n2], 116, y);
y = y + 9;
}
if (selectionMade == 1) {
snprintf(file, 50, "%s%02d", _targetName.c_str(), n + 1);
saveGame(file);
Common::OutSaveFile *tsav;
if (!(tsav = _saveFileMan->openForSaving(fileEpa))) {
error("Can't open %s file", fileEpa);
}
for (n = 0; n < NUM_SAVES; n++) {
tsav->writeString(names[n]);
tsav->writeString("\n");
}
tsav->finalize();
delete tsav;
}
}
if (mouseX > 125 && mouseY > 123 && mouseX < 199 && mouseY < 149 && selectionMade == 1) {
if (!loadGame(file)) {
_system->setFeatureState(OSystem::kFeatureVirtualKeyboard, false);
return false;
}
break;
} else if (mouseX > 208 && mouseY > 123 && mouseX < 282 && mouseY < 149 && selectionMade == 1) {
saveGame(file);
Common::OutSaveFile *tsav;
if (!(tsav = _saveFileMan->openForSaving(fileEpa))) {
error("Can't open %s file", fileEpa);
}
for (n = 0; n < NUM_SAVES; n++) {
tsav->writeString(names[n]);
tsav->writeString("\n");
}
tsav->finalize();
delete tsav;
} else if (mouseX > 168 && mouseY > 154 && mouseX < 242 && mouseY < 180)
break;
else if (selectionMade == 0) {
print_abc("Please select a slot", 117, 15);
}
updateScreen();
delay(200);
}
y = 26;
delay(5);
}
selectVerb(kVerbNone);
clearRoom();
loadPic(roomNumber, bgSurface, HALF_PAL);
selectionMade = 0;
_system->setFeatureState(OSystem::kFeatureVirtualKeyboard, false);
return true;
}
bool saveGame(const Common::String &fname) {
Common::OutSaveFile *fp = g_system->getSavefileManager()->openForSaving(fname);
if (fp == NULL)
return false;
fp->writeString("SLUDSA");
fp->writeByte(0);
fp->writeByte(0);
fp->writeByte(MAJOR_VERSION);
fp->writeByte(MINOR_VERSION);
if (!g_sludge->_gfxMan->saveThumbnail(fp))
return false;
fp->write(&fileTime, sizeof(FILETIME));
// DON'T ADD ANYTHING NEW BEFORE THIS POINT!
fp->writeByte(allowAnyFilename);
fp->writeByte(captureAllKeys);
fp->writeByte(true);
g_sludge->_txtMan->saveFont(fp);
// Save backdrop
fp->writeUint16BE(g_sludge->_gfxMan->getCamX());
fp->writeUint16BE(g_sludge->_gfxMan->getCamY());
fp->writeFloatLE(g_sludge->_gfxMan->getCamZoom());
fp->writeByte(brightnessLevel);
g_sludge->_gfxMan->saveHSI(fp);
// Save event handlers
g_sludge->_evtMan->saveHandlers(fp);
// Save regions
saveRegions(fp);
g_sludge->_cursorMan->saveCursor(fp);
// 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 (int a = 0; a < numGlobals; a++) {
saveVariable(&globalVars[a], fp);
}
savePeople(fp);
if (currentFloor->numPolygons) {
fp->writeByte(1);
fp->writeUint16BE(currentFloor->originalNum);
} else {
fp->writeByte(0);
}
g_sludge->_gfxMan->saveZBuffer(fp);
g_sludge->_gfxMan->saveLightMap(fp);
fp->writeByte(fadeMode);
g_sludge->_speechMan->save(fp);
saveStatusBars(fp);
g_sludge->_soundMan->saveSounds(fp);
fp->writeUint16BE(saveEncoding);
blur_saveSettings(fp);
g_sludge->_gfxMan->saveColors(fp);
g_sludge->_gfxMan->saveParallax(fp);
fp->writeByte(0);
g_sludge->_languageMan->saveLanguageSetting(fp);
g_sludge->_gfxMan->saveSnapshot(fp);
fp->flush();
fp->finalize();
delete fp;
clearStackLib();
return true;
}