reg_t kCheckSaveGame(EngineState *s, int argc, reg_t *argv) {
Common::String game_id = s->_segMan->getString(argv[0]);
uint16 virtualId = argv[1].toUint16();
debug(3, "kCheckSaveGame(%s, %d)", game_id.c_str(), virtualId);
Common::Array<SavegameDesc> saves;
listSavegames(saves);
// we allow 0 (happens in QfG2 when trying to restore from an empty saved game list) and return false in that case
if (virtualId == 0)
return NULL_REG;
// Find saved-game
if ((virtualId < SAVEGAMEID_OFFICIALRANGE_START) || (virtualId > SAVEGAMEID_OFFICIALRANGE_END))
error("kCheckSaveGame: called with invalid savegameId");
uint savegameId = virtualId - SAVEGAMEID_OFFICIALRANGE_START;
int savegameNr = findSavegame(saves, savegameId);
if (savegameNr == -1)
return NULL_REG;
// Check for compatible savegame version
int ver = saves[savegameNr].version;
if (ver < MINIMUM_SAVEGAME_VERSION || ver > CURRENT_SAVEGAME_VERSION)
return NULL_REG;
// Otherwise we assume the savegame is OK
return TRUE_REG;
}
reg_t kCheckSaveGame(EngineState *s, int funct_nr, int argc, reg_t *argv) {
char *game_id = kernel_dereference_char_pointer(s, argv[0], 0);
int savedir_nr = argv[1].toUint16();
debug(3, "kCheckSaveGame(%s, %d)", game_id, savedir_nr);
Common::Array<SavegameDesc> saves;
listSavegames(saves);
savedir_nr = saves[savedir_nr].id;
if (savedir_nr > MAX_SAVEGAME_NR - 1) {
return NULL_REG;
}
Common::SaveFileManager *saveFileMan = g_engine->getSaveFileManager();
Common::String filename = ((Sci::SciEngine*)g_engine)->getSavegameName(savedir_nr);
Common::SeekableReadStream *in;
if ((in = saveFileMan->openForLoading(filename))) {
// found a savegame file
SavegameMetadata meta;
if (!get_savegame_metadata(in, &meta)) {
// invalid
s->r_acc = make_reg(0, 0);
} else {
s->r_acc = make_reg(0, 1);
}
delete in;
} else {
s->r_acc = make_reg(0, 1);
}
return s->r_acc;
}
reg_t kGetSaveFiles(EngineState *s, int funct_nr, int argc, reg_t *argv) {
char *game_id = kernel_dereference_char_pointer(s, argv[0], 0);
char *nametarget = kernel_dereference_char_pointer(s, argv[1], 0);
reg_t nametarget_base = argv[1];
reg_t *nameoffsets = kernel_dereference_reg_pointer(s, argv[2], 0);
debug(3, "kGetSaveFiles(%s,%s)", game_id, nametarget);
Common::Array<SavegameDesc> saves;
listSavegames(saves);
s->r_acc = NULL_REG;
Common::SaveFileManager *saveFileMan = g_engine->getSaveFileManager();
for (uint i = 0; i < saves.size(); i++) {
Common::String filename = ((Sci::SciEngine*)g_engine)->getSavegameName(saves[i].id);
Common::SeekableReadStream *in;
if ((in = saveFileMan->openForLoading(filename))) {
// found a savegame file
SavegameMetadata meta;
if (!get_savegame_metadata(in, &meta)) {
// invalid
delete in;
continue;
}
if (!meta.savegame_name.empty()) {
if (meta.savegame_name.lastChar() == '\n')
meta.savegame_name.deleteLastChar();
*nameoffsets = s->r_acc; // Store savegame ID
++s->r_acc.offset; // Increase number of files found
nameoffsets++; // Make sure the next ID string address is written to the next pointer
strncpy(nametarget, meta.savegame_name.c_str(), SCI_MAX_SAVENAME_LENGTH); // Copy identifier string
*(nametarget + SCI_MAX_SAVENAME_LENGTH - 1) = 0; // Make sure it's terminated
nametarget += SCI_MAX_SAVENAME_LENGTH; // Increase name offset pointer accordingly
nametarget_base.offset += SCI_MAX_SAVENAME_LENGTH;
}
delete in;
}
}
//free(gfname);
*nametarget = 0; // Terminate list
return s->r_acc;
}
reg_t kFileIOUnlink(EngineState *s, int argc, reg_t *argv) {
Common::String name = s->_segMan->getString(argv[0]);
Common::SaveFileManager *saveFileMan = g_sci->getSaveFileManager();
bool result;
// SQ4 floppy prepends /\ to the filenames
if (name.hasPrefix("/\\")) {
name.deleteChar(0);
name.deleteChar(0);
}
// Special case for SQ4 floppy: This game has hardcoded names for all of
// its savegames, and they are all named "sq4sg.xxx", where xxx is the
// slot. We just take the slot number here, and delete the appropriate
// save game.
if (name.hasPrefix("sq4sg.")) {
// Special handling for SQ4... get the slot number and construct the
// save game name.
int slotNum = atoi(name.c_str() + name.size() - 3);
Common::Array<SavegameDesc> saves;
listSavegames(saves);
int savedir_nr = saves[slotNum].id;
name = g_sci->getSavegameName(savedir_nr);
result = saveFileMan->removeSavefile(name);
} else if (getSciVersion() >= SCI_VERSION_2) {
// The file name may be already wrapped, so check both cases
result = saveFileMan->removeSavefile(name);
if (!result) {
const Common::String wrappedName = g_sci->wrapFilename(name);
result = saveFileMan->removeSavefile(wrappedName);
}
#ifdef ENABLE_SCI32
if (name == PHANTASMAGORIA_SAVEGAME_INDEX) {
delete s->_virtualIndexFile;
s->_virtualIndexFile = 0;
}
#endif
} else {
const Common::String wrappedName = g_sci->wrapFilename(name);
result = saveFileMan->removeSavefile(wrappedName);
}
debugC(kDebugLevelFile, "kFileIO(unlink): %s", name.c_str());
if (result)
return NULL_REG;
return make_reg(0, 2); // DOS - file not found error code
}
reg_t kMakeSaveFileName(EngineState *s, int argc, reg_t *argv) {
// Creates a savegame name from a slot number. Used when deleting saved games.
// Param 0: the output buffer (same as in kMakeSaveCatName)
// Param 1: a string with game parameters, ignored
// Param 2: the selected slot
SciString *resultString = s->_segMan->lookupString(argv[0]);
uint16 virtualId = argv[2].toUint16();
if ((virtualId < SAVEGAMEID_OFFICIALRANGE_START) || (virtualId > SAVEGAMEID_OFFICIALRANGE_END))
error("kMakeSaveFileName: invalid savegame ID specified");
uint saveSlot = virtualId - SAVEGAMEID_OFFICIALRANGE_START;
Common::Array<SavegameDesc> saves;
listSavegames(saves);
Common::String filename = g_sci->getSavegameName(saveSlot);
resultString->fromString(filename);
return argv[0];
}
reg_t kRestoreGame(EngineState *s, int funct_nr, int argc, reg_t *argv) {
char *game_id = kernel_dereference_char_pointer(s, argv[0], 0);
int savedir_nr = argv[1].toUint16();
debug(3, "kRestoreGame(%s,%d)", game_id, savedir_nr);
Common::Array<SavegameDesc> saves;
listSavegames(saves);
savedir_nr = saves[savedir_nr].id;
if (savedir_nr > -1) {
Common::SaveFileManager *saveFileMan = g_engine->getSaveFileManager();
Common::String filename = ((Sci::SciEngine*)g_engine)->getSavegameName(savedir_nr);
Common::SeekableReadStream *in;
if ((in = saveFileMan->openForLoading(filename))) {
// found a savegame file
EngineState *newstate = gamestate_restore(s, in);
delete in;
if (newstate) {
s->successor = newstate;
script_abort_flag = 2; // Abort current game with replay
shrink_execution_stack(s, s->execution_stack_base + 1);
} else {
s->r_acc = make_reg(0, 1);
warning("Restoring failed (game_id = '%s')", game_id);
}
return s->r_acc;
}
}
s->r_acc = make_reg(0, 1);
warning("Savegame #%d not found", savedir_nr);
return s->r_acc;
}
reg_t kGetSaveFiles(EngineState *s, int argc, reg_t *argv) {
Common::String game_id = s->_segMan->getString(argv[0]);
debug(3, "kGetSaveFiles(%s)", game_id.c_str());
// Scripts ask for current save files, we can assume that if afterwards they ask us to create a new slot they really
// mean new slot instead of overwriting the old one
s->_lastSaveVirtualId = SAVEGAMEID_OFFICIALRANGE_START;
Common::Array<SavegameDesc> saves;
listSavegames(saves);
uint totalSaves = MIN<uint>(saves.size(), MAX_SAVEGAME_NR);
reg_t *slot = s->_segMan->derefRegPtr(argv[2], totalSaves);
if (!slot) {
warning("kGetSaveFiles: %04X:%04X invalid or too small to hold slot data", PRINT_REG(argv[2]));
totalSaves = 0;
}
const uint bufSize = (totalSaves * SCI_MAX_SAVENAME_LENGTH) + 1;
char *saveNames = new char[bufSize];
char *saveNamePtr = saveNames;
for (uint i = 0; i < totalSaves; i++) {
*slot++ = make_reg(0, saves[i].id + SAVEGAMEID_OFFICIALRANGE_START); // Store the virtual savegame ID ffs. see above
strcpy(saveNamePtr, saves[i].name);
saveNamePtr += SCI_MAX_SAVENAME_LENGTH;
}
*saveNamePtr = 0; // Terminate list
s->_segMan->memcpy(argv[1], (byte *)saveNames, bufSize);
delete[] saveNames;
return make_reg(0, totalSaves);
}
reg_t kRestoreGame(EngineState *s, int argc, reg_t *argv) {
Common::String game_id = !argv[0].isNull() ? s->_segMan->getString(argv[0]) : "";
int16 savegameId = argv[1].toSint16();
bool pausedMusic = false;
debug(3, "kRestoreGame(%s,%d)", game_id.c_str(), savegameId);
if (argv[0].isNull()) {
// Direct call, either from launcher or from a patched Game::restore
if (savegameId == -1) {
// we are supposed to show a dialog for the user and let him choose a saved game
g_sci->_soundCmd->pauseAll(true); // pause music
GUI::SaveLoadChooser *dialog = new GUI::SaveLoadChooser(_("Restore game:"), _("Restore"), false);
savegameId = dialog->runModalWithCurrentTarget();
delete dialog;
if (savegameId < 0) {
g_sci->_soundCmd->pauseAll(false); // unpause music
return s->r_acc;
}
pausedMusic = true;
}
// don't adjust ID of the saved game, it's already correct
} else {
if (argv[2].isNull())
error("kRestoreGame: called with parameter 2 being NULL");
// Real call from script, we need to adjust ID
if ((savegameId < SAVEGAMEID_OFFICIALRANGE_START) || (savegameId > SAVEGAMEID_OFFICIALRANGE_END)) {
warning("Savegame ID %d is not allowed", savegameId);
return TRUE_REG;
}
savegameId -= SAVEGAMEID_OFFICIALRANGE_START;
}
s->r_acc = NULL_REG; // signals success
Common::Array<SavegameDesc> saves;
listSavegames(saves);
if (findSavegame(saves, savegameId) == -1) {
s->r_acc = TRUE_REG;
warning("Savegame ID %d not found", savegameId);
} else {
Common::SaveFileManager *saveFileMan = g_sci->getSaveFileManager();
Common::String filename = g_sci->getSavegameName(savegameId);
Common::SeekableReadStream *in;
in = saveFileMan->openForLoading(filename);
if (in) {
// found a savegame file
gamestate_restore(s, in);
delete in;
if (g_sci->getGameId() == GID_MOTHERGOOSE256) {
// WORKAROUND: Mother Goose SCI1/SCI1.1 does some weird things for
// saving a previously restored game.
// We set the current savedgame-id directly and remove the script
// code concerning this via script patch.
s->variables[VAR_GLOBAL][0xB3].setOffset(SAVEGAMEID_OFFICIALRANGE_START + savegameId);
}
} else {
s->r_acc = TRUE_REG;
warning("Savegame #%d not found", savegameId);
}
}
if (!s->r_acc.isNull()) {
// no success?
if (pausedMusic)
g_sci->_soundCmd->pauseAll(false); // unpause music
}
return s->r_acc;
}
reg_t kDeviceInfo(EngineState *s, int argc, reg_t *argv) {
if (g_sci->getGameId() == GID_FANMADE && argc == 1) {
// WORKAROUND: The fan game script library calls kDeviceInfo with one parameter.
// According to the scripts, it wants to call CurDevice. However, it fails to
// provide the subop to the function.
s->_segMan->strcpy(argv[0], "/");
return s->r_acc;
}
int mode = argv[0].toUint16();
switch (mode) {
case K_DEVICE_INFO_GET_DEVICE: {
Common::String input_str = s->_segMan->getString(argv[1]);
s->_segMan->strcpy(argv[2], "/");
debug(3, "K_DEVICE_INFO_GET_DEVICE(%s) -> %s", input_str.c_str(), "/");
break;
}
case K_DEVICE_INFO_GET_CURRENT_DEVICE:
s->_segMan->strcpy(argv[1], "/");
debug(3, "K_DEVICE_INFO_GET_CURRENT_DEVICE() -> %s", "/");
break;
case K_DEVICE_INFO_PATHS_EQUAL: {
Common::String path1_s = s->_segMan->getString(argv[1]);
Common::String path2_s = s->_segMan->getString(argv[2]);
debug(3, "K_DEVICE_INFO_PATHS_EQUAL(%s,%s)", path1_s.c_str(), path2_s.c_str());
return make_reg(0, Common::matchString(path2_s.c_str(), path1_s.c_str(), false, true));
}
break;
case K_DEVICE_INFO_IS_FLOPPY: {
Common::String input_str = s->_segMan->getString(argv[1]);
debug(3, "K_DEVICE_INFO_IS_FLOPPY(%s)", input_str.c_str());
return NULL_REG; /* Never */
}
case K_DEVICE_INFO_GET_CONFIG_PATH: {
// Early versions return drive letter, later versions a path string
// FIXME: Implement if needed, for now return NULL_REG
return NULL_REG;
}
/* SCI uses these in a less-than-portable way to delete savegames.
** Read http://www-plan.cs.colorado.edu/creichen/freesci-logs/2005.10/log20051019.html
** for more information on our workaround for this.
*/
case K_DEVICE_INFO_GET_SAVECAT_NAME: {
Common::String game_prefix = s->_segMan->getString(argv[2]);
s->_segMan->strcpy(argv[1], "__throwaway");
debug(3, "K_DEVICE_INFO_GET_SAVECAT_NAME(%s) -> %s", game_prefix.c_str(), "__throwaway");
}
break;
case K_DEVICE_INFO_GET_SAVEFILE_NAME: {
Common::String game_prefix = s->_segMan->getString(argv[2]);
uint virtualId = argv[3].toUint16();
s->_segMan->strcpy(argv[1], "__throwaway");
debug(3, "K_DEVICE_INFO_GET_SAVEFILE_NAME(%s,%d) -> %s", game_prefix.c_str(), virtualId, "__throwaway");
if ((virtualId < SAVEGAMEID_OFFICIALRANGE_START) || (virtualId > SAVEGAMEID_OFFICIALRANGE_END))
error("kDeviceInfo(deleteSave): invalid savegame ID specified");
uint savegameId = virtualId - SAVEGAMEID_OFFICIALRANGE_START;
Common::Array<SavegameDesc> saves;
listSavegames(saves);
if (findSavegame(saves, savegameId) != -1) {
// Confirmed that this id still lives...
Common::String filename = g_sci->getSavegameName(savegameId);
Common::SaveFileManager *saveFileMan = g_sci->getSaveFileManager();
saveFileMan->removeSavefile(filename);
}
break;
}
default:
error("Unknown DeviceInfo() sub-command: %d", mode);
break;
}
return s->r_acc;
}
reg_t kSaveGame(EngineState *s, int argc, reg_t *argv) {
Common::String game_id;
int16 virtualId = argv[1].toSint16();
int16 savegameId = -1;
Common::String game_description;
Common::String version;
if (argc > 3)
version = s->_segMan->getString(argv[3]);
// We check here, we don't want to delete a users save in case we are within a kernel function
if (s->executionStackBase) {
warning("kSaveGame - won't save from within kernel function");
return NULL_REG;
}
if (argv[0].isNull()) {
// Direct call, from a patched Game::save
if ((argv[1] != SIGNAL_REG) || (!argv[2].isNull()))
error("kSaveGame: assumed patched call isn't accurate");
// we are supposed to show a dialog for the user and let him choose where to save
g_sci->_soundCmd->pauseAll(true); // pause music
GUI::SaveLoadChooser *dialog = new GUI::SaveLoadChooser(_("Save game:"), _("Save"), true);
savegameId = dialog->runModalWithCurrentTarget();
game_description = dialog->getResultString();
if (game_description.empty()) {
// create our own description for the saved game, the user didnt enter it
game_description = dialog->createDefaultSaveDescription(savegameId);
}
delete dialog;
g_sci->_soundCmd->pauseAll(false); // unpause music ( we can't have it paused during save)
if (savegameId < 0)
return NULL_REG;
} else {
// Real call from script
game_id = s->_segMan->getString(argv[0]);
if (argv[2].isNull())
error("kSaveGame: called with description being NULL");
game_description = s->_segMan->getString(argv[2]);
debug(3, "kSaveGame(%s,%d,%s,%s)", game_id.c_str(), virtualId, game_description.c_str(), version.c_str());
Common::Array<SavegameDesc> saves;
listSavegames(saves);
if ((virtualId >= SAVEGAMEID_OFFICIALRANGE_START) && (virtualId <= SAVEGAMEID_OFFICIALRANGE_END)) {
// savegameId is an actual Id, so search for it just to make sure
savegameId = virtualId - SAVEGAMEID_OFFICIALRANGE_START;
if (findSavegame(saves, savegameId) == -1)
return NULL_REG;
} else if (virtualId < SAVEGAMEID_OFFICIALRANGE_START) {
// virtualId is low, we assume that scripts expect us to create new slot
if (virtualId == s->_lastSaveVirtualId) {
// if last virtual id is the same as this one, we assume that caller wants to overwrite last save
savegameId = s->_lastSaveNewId;
} else {
uint savegameNr;
// savegameId is in lower range, scripts expect us to create a new slot
for (savegameId = 0; savegameId < SAVEGAMEID_OFFICIALRANGE_START; savegameId++) {
for (savegameNr = 0; savegameNr < saves.size(); savegameNr++) {
if (savegameId == saves[savegameNr].id)
break;
}
if (savegameNr == saves.size())
break;
}
if (savegameId == SAVEGAMEID_OFFICIALRANGE_START)
error("kSavegame: no more savegame slots available");
}
} else {
error("kSaveGame: invalid savegameId used");
}
// Save in case caller wants to overwrite last newly created save
s->_lastSaveVirtualId = virtualId;
s->_lastSaveNewId = savegameId;
}
s->r_acc = NULL_REG;
Common::String filename = g_sci->getSavegameName(savegameId);
Common::SaveFileManager *saveFileMan = g_sci->getSaveFileManager();
Common::OutSaveFile *out;
out = saveFileMan->openForSaving(filename);
if (!out) {
warning("Error opening savegame \"%s\" for writing", filename.c_str());
} else {
if (!gamestate_save(s, out, game_description, version)) {
warning("Saving the game failed");
} else {
s->r_acc = TRUE_REG; // save successful
}
out->finalize();
if (out->err()) {
warning("Writing the savegame failed");
s->r_acc = NULL_REG; // write failure
}
delete out;
}
return s->r_acc;
}
reg_t kFileIOOpen(EngineState *s, int argc, reg_t *argv) {
Common::String name = s->_segMan->getString(argv[0]);
// SCI32 can call K_FILEIO_OPEN with only one argument. It seems to
// just be checking if it exists.
int mode = (argc < 2) ? (int)_K_FILE_MODE_OPEN_OR_FAIL : argv[1].toUint16();
bool unwrapFilename = true;
// SQ4 floppy prepends /\ to the filenames
if (name.hasPrefix("/\\")) {
name.deleteChar(0);
name.deleteChar(0);
}
// SQ4 floppy attempts to update the savegame index file sq4sg.dir when
// deleting saved games. We don't use an index file for saving or loading,
// so just stop the game from modifying the file here in order to avoid
// having it saved in the ScummVM save directory.
if (name == "sq4sg.dir") {
debugC(kDebugLevelFile, "Not opening unused file sq4sg.dir");
return SIGNAL_REG;
}
if (name.empty()) {
// Happens many times during KQ1 (e.g. when typing something)
debugC(kDebugLevelFile, "Attempted to open a file with an empty filename");
return SIGNAL_REG;
}
debugC(kDebugLevelFile, "kFileIO(open): %s, 0x%x", name.c_str(), mode);
#ifdef ENABLE_SCI32
if (name == PHANTASMAGORIA_SAVEGAME_INDEX) {
if (s->_virtualIndexFile) {
return make_reg(0, VIRTUALFILE_HANDLE);
} else {
Common::String englishName = g_sci->getSciLanguageString(name, K_LANG_ENGLISH);
Common::String wrappedName = g_sci->wrapFilename(englishName);
if (!g_sci->getSaveFileManager()->listSavefiles(wrappedName).empty()) {
s->_virtualIndexFile = new VirtualIndexFile(wrappedName);
return make_reg(0, VIRTUALFILE_HANDLE);
}
}
}
// Shivers is trying to store savegame descriptions and current spots in
// separate .SG files, which are hardcoded in the scripts.
// Essentially, there is a normal save file, created by the executable
// and an extra hardcoded save file, created by the game scripts, probably
// because they didn't want to modify the save/load code to add the extra
// information.
// Each slot in the book then has two strings, the save description and a
// description of the current spot that the player is at. Currently, the
// spot strings are always empty (probably related to the unimplemented
// kString subop 14, which gets called right before this call).
// For now, we don't allow the creation of these files, which means that
// all the spot descriptions next to each slot description will be empty
// (they are empty anyway). Until a viable solution is found to handle these
// extra files and until the spot description strings are initialized
// correctly, we resort to virtual files in order to make the load screen
// useable. Without this code it is unusable, as the extra information is
// always saved to 0.SG for some reason, but on restore the correct file is
// used. Perhaps the virtual ID is not taken into account when saving.
//
// Future TODO: maintain spot descriptions and show them too, ideally without
// having to return to this logic of extra hardcoded files.
if (g_sci->getGameId() == GID_SHIVERS && name.hasSuffix(".SG")) {
if (mode == _K_FILE_MODE_OPEN_OR_CREATE || mode == _K_FILE_MODE_CREATE) {
// Game scripts are trying to create a file with the save
// description, stop them here
debugC(kDebugLevelFile, "Not creating unused file %s", name.c_str());
return SIGNAL_REG;
} else if (mode == _K_FILE_MODE_OPEN_OR_FAIL) {
// Create a virtual file containing the save game description
// and slot number, as the game scripts expect.
int slotNumber;
sscanf(name.c_str(), "%d.SG", &slotNumber);
Common::Array<SavegameDesc> saves;
listSavegames(saves);
int savegameNr = findSavegame(saves, slotNumber - SAVEGAMEID_OFFICIALRANGE_START);
if (!s->_virtualIndexFile) {
// Make the virtual file buffer big enough to avoid having it grow dynamically.
// 50 bytes should be more than enough.
s->_virtualIndexFile = new VirtualIndexFile(50);
}
s->_virtualIndexFile->seek(0, SEEK_SET);
s->_virtualIndexFile->write(saves[savegameNr].name, strlen(saves[savegameNr].name));
s->_virtualIndexFile->write("\0", 1);
s->_virtualIndexFile->write("\0", 1); // Spot description (empty)
s->_virtualIndexFile->seek(0, SEEK_SET);
return make_reg(0, VIRTUALFILE_HANDLE);
}
}
#endif
// QFG import rooms get a virtual filelisting instead of an actual one
if (g_sci->inQfGImportRoom()) {
// We need to find out what the user actually selected, "savedHeroes" is
// already destroyed when we get here. That's why we need to remember
// selection via kDrawControl.
name = s->_dirseeker.getVirtualFilename(s->_chosenQfGImportItem);
unwrapFilename = false;
}
return file_open(s, name, mode, unwrapFilename);
}
reg_t kSaveGame(EngineState *s, int funct_nr, int argc, reg_t *argv) {
char *game_id = kernel_dereference_char_pointer(s, argv[0], 0);
int savedir_nr = argv[1].toUint16();
int savedir_id; // Savegame ID, derived from savedir_nr and the savegame ID list
char *game_description = kernel_dereference_char_pointer(s, argv[2], 0);
char *version = argc > 3 ? strdup(kernel_dereference_char_pointer(s, argv[3], 0)) : NULL;
debug(3, "kSaveGame(%s,%d,%s,%s)", game_id, savedir_nr, game_description, version);
s->game_version = version;
Common::Array<SavegameDesc> saves;
listSavegames(saves);
fprintf(stderr, "savedir_nr = %d\n", savedir_nr);
if (savedir_nr >= 0 && (uint)savedir_nr < saves.size()) {
// Overwrite
savedir_id = saves[savedir_nr].id;
} else if (savedir_nr >= 0 && savedir_nr < MAX_SAVEGAME_NR) {
uint i = 0;
fprintf(stderr, "searching for hole\n");
savedir_id = 0;
// First, look for holes
while (i < saves.size()) {
if (saves[i].id == savedir_id) {
++savedir_id;
i = 0;
} else
++i;
}
if (savedir_id >= MAX_SAVEGAME_NR) {
warning("Internal error: Free savegame ID is %d, shouldn't happen", savedir_id);
return NULL_REG;
}
// This loop terminates when savedir_id is not in [x | ex. n. saves [n].id = x]
} else {
warning("Savegame ID %d is not allowed", savedir_nr);
return NULL_REG;
}
Common::String filename = ((Sci::SciEngine*)g_engine)->getSavegameName(savedir_id);
Common::SaveFileManager *saveFileMan = g_engine->getSaveFileManager();
Common::OutSaveFile *out;
if (!(out = saveFileMan->openForSaving(filename))) {
warning("Error opening savegame \"%s\" for writing", filename.c_str());
s->r_acc = NULL_REG;
return NULL_REG;
}
if (gamestate_save(s, out, game_description)) {
warning("Saving the game failed.");
s->r_acc = NULL_REG;
} else {
out->finalize();
if (out->err()) {
delete out;
warning("Writing the savegame failed.");
s->r_acc = NULL_REG;
} else {
delete out;
s->r_acc = make_reg(0, 1);
}
}
free(s->game_version);
s->game_version = NULL;
return s->r_acc;
}
