Ticket #8624: dialog_save_memory.patch

engines/scumm/input.cpp

@@ -410 +410 @@
         // Fall back to default behavior
         ScummEngine::processKeyboard(lastKeyHit);
 
+        // On Alt-F5 prepare savegame for the original save/load dialog. 
+        if (lastKeyHit.keycode == Common::KEYCODE_F5 && lastKeyHit.flags == Common::KBD_ALT) {
+                prepareSavegame();
+        }
+
         if (VAR_KEYPRESS != 0xFF && _mouseAndKeyboardStat) {            // Key Input
                 if (315 <= _mouseAndKeyboardStat && _mouseAndKeyboardStat <= 323) {
                         // Convert F-Keys for V1/V2 games (they start at 1)
@@ -424 +429 @@
         // Fall back to default behavior
         ScummEngine::processKeyboard(lastKeyHit);
 
-        // 'i' brings up an IQ dialog in Indy3
-        if (lastKeyHit.ascii == 'i' && _game.id == GID_INDY3) {
+        // On Alt-F5 prepare savegame for the original save/load dialog. 
+        if (lastKeyHit.keycode == Common::KEYCODE_F5 && lastKeyHit.flags == Common::KBD_ALT) {
+                prepareSavegame();
+        }
+
+        // 'i' brings up an IQ dialog in Indy3 (disabled in save/load dialog for input)
+        if (lastKeyHit.ascii == 'i' && _game.id == GID_INDY3 && _currentRoom != 14) {
                 // SCUMM var 244 is the episode score
                 // and var 245 is the series score
                 char text[50];

engines/scumm/saveload.cpp

@@ -28 +28 @@
 #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"
@@ -129 +130 @@
         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__)
+        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;
-        SaveGameHeader hdr;
 
         if (_saveLoadSlot == 255) {
                 // Allow custom filenames for save game system in HE Games
@@ -143 +161 @@
         if (!(out = _saveFileMan->openForSaving(filename.c_str())))
                 return false;
 
-        memcpy(hdr.name, _saveLoadName, sizeof(hdr.name));
-        saveSaveGameHeader(out, hdr);
-#if !defined(__DS__)
-        Graphics::saveThumbnail(*out);
-#endif
-        saveInfos(out);
+        saveFailed = false;
+        if (!saveState(out))
+                saveFailed = true;
 
-        Serializer ser(0, out, CURRENT_VER);
-        saveOrLoad(&ser);
         out->finalize();
-        if (out->err()) {
-                delete out;
+        if (out->err())
+                saveFailed = true;
+        delete out;
+
+        if (saveFailed) {
                 debug(1, "State save as '%s' FAILED", filename.c_str());
                 return false;
         }
-        delete out;
         debug(1, "State saved as '%s'", filename.c_str());
         return true;
 }
 
+
+void ScummEngine::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(), true));
+                }
+        }
+        // free the CompressedWriteStream and MemoryWriteStreamDynamic 
+        // but not the memory stream's internal buffer
+        delete writeStream;
+}
+
+bool ScummEngine::savePreparedSavegame(int slot, char *desc) {
+        bool success;
+        Common::String filename;
+        Common::OutSaveFile *out;
+        SaveGameHeader hdr;
+        uint32 nread, nwritten;
+        byte buffer[1024];
+
+        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.c_str()))) {
+                        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);
+                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();

engines/scumm/script_v5.cpp

@@ -869 +869 @@
         // which matches the original Indy3 save/load code. See also the notes
         // on Feature Request #1666521.
         STRINGID_IQ_EPISODE = 7,
-        STRINGID_IQ_SERIES = 9
+        STRINGID_IQ_SERIES = 9,
+        // The string IDs of the first savegame name, used as an offset to determine
+        // the IDs of all savenames. 
+        // Loom is the only game whose savenames start with a different ID.
+        STRINGID_SAVENAME1 = 10,
+        STRINGID_SAVENAME1_LOOM = 9
 };
 
 void ScummEngine_v5::o5_saveLoadVars() {
@@ -1235 +1240 @@
                 result = 100;
                 break;
         case 0x20: // drive
-                if (_game.id == GID_INDY3) {
-                        // 0 = hard drive
-                        // 1 = disk drive
-                        result = 0;
+                if (_game.version <= 3) {
+                        // 0 = ???
+                        // [1,2] = disk drive [A:,B:]
+                        // 3 = hard drive
+                        result = 3;
                 } else {
                         // set current drive
                         result = 1;
                 }
                 break;
         case 0x40: // load
-                if (loadState(slot, _saveTemporaryState))
+                if (loadState(slot, false))
                         result = 3; // sucess
                 else
                         result = 5; // failed to load
                 break;
         case 0x80: // save
-                //if (saveState(slot, _saveTemporaryState))
-                //      result = 0; // sucess
-                //else
+                if (_game.version <= 3) {
+                        char name[32];
+                        if (_game.version <= 2) {
+                                // use generic name
+                                sprintf(name, "Game %c", 'A'+slot-1);
+                        } else {
+                                // use name entered by the user
+                                char* ptr;
+                                int firstSlot = (_game.id == GID_LOOM) ? STRINGID_SAVENAME1_LOOM : STRINGID_SAVENAME1;
+                                ptr = (char*)getStringAddress(slot + firstSlot - 1);
+                                strncpy(name, ptr, sizeof(name));
+                        }
+
+                        if(savePreparedSavegame(slot, name))
+                                result = 0;
+                        else
+                                result = 2;
+                } else {
                         result = 2; // failed to save
+                }
                 break;
         case 0xC0: // test if save exists
                 {

engines/scumm/scumm.cpp

@@ -198 +198 @@
         _saveLoadSlot = 0;
         _lastSaveTime = 0;
         _saveTemporaryState = false;
+        _savePreparedSavegame = NULL;
         memset(_saveLoadFileName, 0, sizeof(_saveLoadFileName));
         memset(_saveLoadName, 0, sizeof(_saveLoadName));
         memset(_localScriptOffsets, 0, sizeof(_localScriptOffsets));
@@ -569 +570 @@
         delete _costumeLoader;
         delete _costumeRenderer;
 
+        delete _savePreparedSavegame;
+
         _textSurface.free();
 
         free(_shadowPalette);
@@ -1416 +1419 @@
                 _keyDownMap[i] = false;
 
         _lastSaveTime = _system->getMillis();
+
+        delete _savePreparedSavegame;
+        _savePreparedSavegame = NULL;
 }
 
 void ScummEngine_v0::resetScumm() {

engines/scumm/scumm.h

@@ -29 +29 @@
 #include "engines/engine.h"
 #include "common/endian.h"
 #include "common/file.h"
+#include "common/savefile.h"
 #include "common/keyboard.h"
 #include "common/rect.h"
 #include "common/str.h"
@@ -626 +627 @@
         char _saveLoadFileName[32];
         char _saveLoadName[32];
 
+        // Prepared savegame used by the orginal save/load dialog.
+        // Must be valid as long as the savescreen is active. As we are not
+        // notified when the savescreen is closed, memory is only freed on a game 
+        // reset, at the destruction of the engine or when the original save/load dialog 
+        // is entered the next time.
+        Common::SeekableReadStream* _savePreparedSavegame;
+
+        bool saveState(Common::OutSaveFile *out, bool writeHeader = true);
         bool saveState(int slot, bool compat);
         bool loadState(int slot, bool compat);
         virtual void saveOrLoad(Serializer *s);
@@ -633 +642 @@
         void saveResource(Serializer *ser, int type, int index);
         void loadResource(Serializer *ser, int type, int index);
 
+        void prepareSavegame();
+        bool savePreparedSavegame(int slot, char *desc);
+
         Common::String makeSavegameName(int slot, bool temporary) const {
                 return makeSavegameName(_targetName, slot, temporary);
         }