Ticket #8624: dialog_save.patch

../../engines/scumm/input.cpp

@@ -499 +499 @@
 
         // Alt-F5 brings up the original save/load dialog.
 
-        if (lastKeyHit == 440 && _game.version > 2 && _game.version < 8) {
-                lastKeyHit = saveloadkey;
-                saveloadkey = -1;
+        if (lastKeyHit == 440) {
+                if(_game.version <= 3)
+                        prepareSavegame();
+                if(_game.version > 2 && _game.version < 8) {
+                        lastKeyHit = saveloadkey;
+                        saveloadkey = -1;
+                }
         }
 
         if (lastKeyHit == saveloadkey) {

../../engines/scumm/intern.h

@@ -82 +82 @@
         int getWordVararg(int *ptr);
         void saveVars();
         void loadVars();
+        void saveIQPoints();
+        void loadIQPoints();
 
         virtual int getVar();
         virtual int getVarOrDirectByte(byte mask);

../../engines/scumm/saveload.cpp

@@ -84 +84 @@
         _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(int slot, bool compat) {
         char filename[256];
         Common::OutSaveFile *out;
@@ -95 +107 @@
                 return false;
 
         memcpy(hdr.name, _saveLoadName, sizeof(hdr.name));
-
-        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));
+        saveSaveGameHeader(out, hdr);
         saveThumbnail(out);
         saveInfos(out);
 
@@ -429 +433 @@
         return true;
 }
 
+void ScummEngine::prepareSavegame() {
+        saveState(0, true);
+}
+
+bool ScummEngine::savePreparedSavegame(int slot, char *desc) {
+        return copyRenameSavegame(0, true, slot, false, desc);
+}
+
+bool ScummEngine::copyRenameSavegame(int oldSlot, bool oldTemporary, int newSlot, bool newTemporary, char *desc) {
+        bool result;
+        uint32 nread;
+        byte buffer[1024];
+        char oldFilename[256];
+        char newFilename[256];
+        Common::InSaveFile *in;
+        Common::OutSaveFile *out;
+        SaveGameHeader hdr;
+
+        makeSavegameName(oldFilename, oldSlot, oldTemporary);
+        if (!(in = _saveFileMan->openForLoading(oldFilename)))
+                return false;
+
+        if (!loadSaveGameHeader(in, hdr)) {
+                warning("Invalid savegame '%s'", oldFilename);
+                delete in;
+                return false;
+        }
+
+        if (hdr.ver != CURRENT_VER) {
+                warning("Incompatible savegame '%s'", oldFilename);
+                delete in;
+                return false;
+        }
+
+        makeSavegameName(newFilename, newSlot, newTemporary);
+        if (!(out = _saveFileMan->openForSaving(newFilename))) {
+                delete in;
+                return false;
+        }
+
+        memset(hdr.name, 0, sizeof(hdr.name));
+        strncpy(hdr.name, desc, sizeof(hdr.name)-1);
+        saveSaveGameHeader(out, hdr);
+        
+        // copy bytes
+        result = true;
+        while (nread = in->read(buffer, sizeof(buffer))) {
+                uint32 nwritten = out->write(buffer, nread);
+                if (nwritten < nread) {
+                        result = false;
+                        break;
+                }
+        }
+
+        out->finalize();
+        if (out->ioFailed()) {
+                result = false;
+        }
+        delete in;
+        delete out;
+
+        return result;
+}
+
 Graphics::Surface *ScummEngine::loadThumbnailFromSlot(int slot) {
         char filename[256];
         Common::InSaveFile *in;

../../engines/scumm/script_v5.cpp

@@ -870 +870 @@
 
 void ScummEngine_v5::saveVars() {
         int a, b;
+        static char filename[256];
 
-        // FIXME: This opcode is currently a stub. It is needed for at least two things:
-        // * storing save game names in Indy 3 (and maybe others)
-        // * storing the global IQ (Indy Quotient) in Indy 3
-        // The former is not so important as we have our own save system, but the
-        // latter one of course is a desirable feature.
-        // So implementing this would be nice indeed. Not sure what the filename
-        // should be -- either base it on the target name, or base it on the gameid.
-        // Both approaches have their merits, though.
-
         while ((_opcode = fetchScriptByte()) != 0) {
                 switch (_opcode & 0x1F) {
                 case 0x01: // write a range of variables
@@ -892 +884 @@
                 case 0x02: // write a range of string variables
                         a = getVarOrDirectByte(PARAM_1);
                         b = getVarOrDirectByte(PARAM_2);
-                        debug(0, "stub saveVars: strings %d -> %d", a, b);
+
+                        if (_game.version == 3 && (_game.id == GID_INDY3 || _game.id == GID_ZAK || _game.id == GID_LOOM)) {
+                                if (a == RESID_IQ_EPISODE && b == RESID_IQ_EPISODE) {
+                                        if (_game.id == GID_INDY3) {
+                                                saveIQPoints();
+                                        }
+                                        break;
+                                }
+                                // FIXME: changing savegame-names not supported
+                        } else {
+                                debug(0, "stub saveVars: strings %d -> %d", a, b);
+                        }
                         break;
                 case 0x03: // open file
                         a = resStrLen(_scriptPointer);
-                        debug(0, "stub saveVars to %s", _scriptPointer);
+                        strncpy(filename, (char*)_scriptPointer, a);
+                        filename[a] = '\0';
                         _scriptPointer += a + 1;
                         break;
                 case 0x04:
                         return;
                 case 0x1F: // close file
-                        debug(0, "stub saveVars close file");
+                        filename[0] = '\0';
                         return;
                 }
         }
@@ -910 +914 @@
 
 void ScummEngine_v5::loadVars() {
         int a, b;
+        static char filename[256];
 
-        // FIXME: See ScummEngine_v5::saveVars
-
-//      Common::hexdump(_scriptPointer, 64);
         while ((_opcode = fetchScriptByte()) != 0) {
                 switch (_opcode & 0x1F) {
                 case 0x01: // read a range of variables
@@ -926 +928 @@
                 case 0x02: // read a range of string variables
                         a = getVarOrDirectByte(PARAM_1);
                         b = getVarOrDirectByte(PARAM_2);
-                        debug(0, "stub loadVars: strings %d -> %d", a, b);
+
+                        if (_game.version == 3 && (_game.id == GID_INDY3 || _game.id == GID_ZAK || _game.id == GID_LOOM)) {
+                                int slot;
+                                int slotSize;
+                                byte* slotContent;
+                                int savegameId;
+                                char name[32];
+                                bool avail_saves[100];
+
+                                if (a == RESID_IQ_SERIES && b == RESID_IQ_SERIES) {
+                                        // Zak256 loads the IQ script-slot but does not use it -> ignore it
+                                        if(_game.id == GID_INDY3) {
+                                                loadIQPoints();
+                                        }
+                                        break;
+                                } 
+                                
+                                listSavegames(avail_saves, ARRAYSIZE(avail_saves));                                                     
+                                for (slot = a; slot <= b; ++slot) {
+                                        slotSize = getResourceSize(rtString, slot);
+                                        slotContent = getResourceAddress(rtString, slot);
+
+                                        // load savegame names
+                                        savegameId = slot - a + 1;
+                                        if (avail_saves[savegameId] && getSavegameName(savegameId, name)) {
+                                                int pos;
+                                                char *ptr = name;
+                                                // slotContent ends with {'\0','@'} -> max. length = slotSize-2
+                                                for (pos = 0; pos < slotSize - 2; ++pos) {
+                                                        if (!ptr[pos]) 
+                                                                break;
+                                                        // replace special characters
+                                                        if(ptr[pos] >= 32 && ptr[pos] <= 122 && ptr[pos] != 64)
+                                                                slotContent[pos] = ptr[pos];
+                                                        else
+                                                                slotContent[pos] = '_';
+                                                }
+                                                slotContent[pos] = '\0';                                                
+                                        } else {
+                                                slotContent[0] = '\0';
+                                        }
+                                }
+                        } else {
+                                debug(0, "stub loadVars: strings %d -> %d", a, b);
+                        }
                         break;
                 case 0x03: // open file
                         a = resStrLen(_scriptPointer);
-                        debug(0, "stub loadVars from %s", _scriptPointer);
+                        strncpy(filename, (char*)_scriptPointer, a);
+                        filename[a] = '\0';
                         _scriptPointer += a + 1;
                         break;
                 case 0x04:
                         return;
                 case 0x1F: // close file
-                        debug(0, "stub loadVars close file");
+                        filename[0] = '\0';
                         return;
                 }
         }
 }
 
+void ScummEngine_v5::saveIQPoints() {
+        // save series IQ-points
+        Common::OutSaveFile *file;
+        char filename[256];
+
+        sprintf(filename, "%s.iq", _targetName.c_str());
+        file = _saveFileMan->openForSaving(filename);
+        if (file != NULL) {
+                int size = getResourceSize(rtString, RESID_IQ_EPISODE);
+                byte *ptr = getResourceAddress(rtString, RESID_IQ_EPISODE);
+                file->write(ptr, size);
+                delete file;
+        }
+}
+
+void ScummEngine_v5::loadIQPoints() {
+        // load series IQ-points
+        Common::InSaveFile *file;
+        char filename[256];
+
+        sprintf(filename, "%s.iq", _targetName.c_str());
+        file = _saveFileMan->openForLoading(filename);
+        if (file != NULL) {
+                int size = getResourceSize(rtString, RESID_IQ_SERIES);
+                byte *ptr = getResourceAddress(rtString, RESID_IQ_SERIES);
+                byte *tmp = (byte*)malloc(size);
+                int nread = file->read(tmp, size);
+                if (nread == size) {
+                        memcpy(ptr, tmp, size); 
+                }
+                free(tmp);
+                delete file;
+        }
+}
+
 void ScummEngine_v5::o5_expression() {
         int dst, i;
 
@@ -1124 +1206 @@
 void ScummEngine_v5::o5_saveLoadGame() {
         getResultPos();
         byte a = getVarOrDirectByte(PARAM_1);
-        byte slot = (a & 0x1F) + 1;
+        byte slot = a & 0x1F;
         byte result = 0;
 
+        if (_game.version <= 2) {
+                // Slot numbers in older games start with 0, in newer games with 1
+                slot++;
+        }
+
         if ((_game.id == GID_MANIAC) && (_game.version <= 1)) {
                 // Convert older load/save screen
                 // 1 Load
@@ -1145 +1232 @@
                 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) ? RESID_SAVENAME1_LOOM : RESID_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
                 Common::InSaveFile *file;

../../engines/scumm/scumm.h

@@ -328 +328 @@
         rtNumTypes = 22
 };
 
+enum ResIds {
+        RESID_IQ_EPISODE = 7,
+        RESID_IQ_SERIES = 9,
+        RESID_SAVENAME1 = 10,
+        RESID_SAVENAME1_LOOM = 9,
+};
 
 
+
 /**
  * The 'resource manager' class. Currently doesn't really deserve to be called
  * a 'class', at least until somebody gets around to OOfying this more.
@@ -620 +627 @@
         void requestSave(int slot, const char *name, bool temporary = false);
         void requestLoad(int slot);
 
+        void prepareSavegame();
+        bool savePreparedSavegame(int slot, char *desc);
+        bool copyRenameSavegame(int oldSlot, bool oldTemporary, int newSlot, bool newTemporary, char *desc);
+
 // thumbnail + info stuff
 public:
         Graphics::Surface *loadThumbnailFromSlot(int slot);