Ticket #8865: rtz_sega_saturn.diff

common/util.cpp

@@ -288 +288 @@
         {"macintosh", "mac", "mac", "Macintosh", kPlatformMacintosh},
         {"pce", "pce", "pce", "PC-Engine", kPlatformPCEngine },
         {"nes", "nes", "nes", "NES", kPlatformNES},
+        {"saturn", "saturn", "saturn", "Sega Saturn", kPlatformSaturn},
         {"segacd", "segacd", "sega", "SegaCD", kPlatformSegaCD},
         {"windows", "win", "win", "Windows", kPlatformWindows},
 

common/util.h

@@ -207 +207 @@
         kPlatformSegaCD,
         kPlatform3DO,
         kPlatformPCEngine,
-
         kPlatformApple2GS,
         kPlatformPC98,
+        kPlatformSaturn,
 
         kPlatformUnknown = -1
 };

engines/made/database.cpp

@@ -195 +195 @@
         */
 }
 
+SegaSaturnObject::~SegaSaturnObject() {
+        if (_freeData && _objData)
+                delete[] _objData;
+}
+
+int SegaSaturnObject::loadVersion3(Common::SeekableReadStream &source) {
+        _freeData = true;
+        source.readUint16BE(); // skip flags
+        uint16 type = source.readUint16BE();
+        if (type == 0x7FFF) {
+                _objSize = source.readUint16BE();
+        } else if (type == 0x7FFE) {
+                _objSize = source.readUint16BE() * 2;
+        } else if (type < 0x7FFE) {
+                byte count1 = source.readByte();
+                byte count2 = source.readByte();
+                _objSize = (count1 + count2) * 2;
+        }
+        source.seek(-6, SEEK_CUR);
+        _objSize += 6;
+        _objData = new byte[_objSize];
+        source.read(_objData, _objSize);
+        return _objSize;
+}
+
+uint16 SegaSaturnObject::getFlags() const {
+        return READ_BE_UINT16(_objData);
+}
+
+uint16 SegaSaturnObject::getClass() const {
+        return READ_BE_UINT16(_objData + 2);
+}
+
+uint16 SegaSaturnObject::getSize() const {
+        return READ_BE_UINT16(_objData + 4);
+}
+
+int16 SegaSaturnObject::getVectorItem(int16 index) {
+        if (getClass() == 0x7FFF) {
+                byte *vector = (byte*)getData();
+                return vector[index];
+        } else if (getClass() == 0x7FFE) {
+                int16 *vector = (int16*)getData();
+                return READ_BE_UINT16(&vector[index]);
+        } else if (getClass() < 0x7FFE) {
+                int16 *vector = (int16*)getData();
+                return READ_BE_UINT16(&vector[index]);
+        } else {
+                // should never reach here
+                error("Unknown object class");
+                return 0;
+        }
+}
+
+void SegaSaturnObject::setVectorItem(int16 index, int16 value) {
+        if (getClass() == 0x7FFF) {
+                byte *vector = (byte*)getData();
+                vector[index] = value;
+        } else if (getClass() <= 0x7FFE) {
+                int16 *vector = (int16*)getData();
+                WRITE_BE_UINT16(&vector[index], value);
+        }
+}
+
 GameDatabase::GameDatabase(MadeEngine *vm) : _vm(vm) {
         _gameText = NULL;
 }
@@ -230 +294 @@
                 debug(2, "loading version 2 dat");
                 loadVersion2(sourceS);
         } else if (_vm->getGameID() == GID_RTZ) {
-                debug(2, "loading version 3 dat");
-                loadVersion3(sourceS);
+                if (_vm->getPlatform() == Common::kPlatformSaturn) {
+                        debug(2, "loading Sega Saturn dat");
+                        loadVersionSegaSaturn(sourceS);
+                } else {
+                        debug(2, "loading version 3 dat");
+                        loadVersion3(sourceS);
+                }
         }
 
 }
@@ -327 +396 @@
 
 }
 
+void GameDatabase::loadVersionSegaSaturn(Common::SeekableReadStream &sourceS) {
+
+        // TODO: Read/verifiy header
+
+        sourceS.seek(0x1E);
+
+        uint32 objectIndexOffs = sourceS.readUint32BE();
+        uint16 objectCount = sourceS.readUint16BE();
+        uint32 gameStateOffs = sourceS.readUint32BE();
+        _gameStateSize = sourceS.readUint32BE();
+        uint32 objectsOffs = sourceS.readUint32BE();
+        uint32 objectsSize = sourceS.readUint32BE();
+        _mainCodeObjectIndex = sourceS.readUint16BE();
+
+        debug(2, "objectIndexOffs = %08X; objectCount = %d; gameStateOffs = %08X; gameStateSize = %d; objectsOffs = %08X; objectsSize = %d\n", objectIndexOffs, objectCount, gameStateOffs, _gameStateSize, objectsOffs, objectsSize);
+
+        _gameState = new byte[_gameStateSize];
+        sourceS.seek(gameStateOffs);
+        sourceS.read(_gameState, _gameStateSize);
+
+        Common::Array<uint32> objectOffsets;
+        sourceS.seek(objectIndexOffs);
+        for (uint32 i = 0; i < objectCount; i++)
+                objectOffsets.push_back(sourceS.readUint32BE());
+
+        for (uint32 i = 0; i < objectCount; i++) {
+                Object *obj = new SegaSaturnObject();
+
+                // The LSB indicates if it's a constant or variable object.
+                // Constant objects are loaded from disk, while variable objects exist
+                // in the _gameState buffer.
+
+                debug(3, "obj(%04X) ofs = %08X\n", i, objectOffsets[i]);
+
+                if (objectOffsets[i] & 1) {
+                        debug(3, "-> const %08X\n", objectsOffs + objectOffsets[i] - 1);
+                        sourceS.seek(objectsOffs + objectOffsets[i] - 1);
+                        obj->loadVersion3(sourceS);
+                } else {
+                        debug(3, "-> var\n");
+                        obj->loadVersion3(_gameState + objectOffsets[i]);
+                }
+                _objects.push_back(obj);
+        }
+
+}
+
 bool GameDatabase::getSavegameDescription(const char *filename, Common::String &description) {
 
         Common::InSaveFile *in;

engines/made/database.h

@@ -72 +72 @@
         byte *_objData;
 };
 
+class SegaSaturnObject : public Object {
+public:
+        SegaSaturnObject() {}
+        ~SegaSaturnObject();
+        int loadVersion3(Common::SeekableReadStream &source);
+
+        uint16 getFlags() const;
+        uint16 getClass() const;
+        uint16 getSize() const;
+        
+        int16 getVectorItem(int16 index);
+        void setVectorItem(int16 index, int16 value);
+};
+
 class GameDatabase {
 public:
 
@@ -118 +132 @@
         void load(Common::SeekableReadStream &sourceS);
         void loadVersion2(Common::SeekableReadStream &sourceS);
         void loadVersion3(Common::SeekableReadStream &sourceS);
+        void loadVersionSegaSaturn(Common::SeekableReadStream &sourceS);
 };
 
 } // End of namespace Made

engines/made/detection.cpp

@@ -173 +173 @@
                 GF_FLOPPY,
                 0,
         },
+        
+        {
+                // Return to Zork - Japanese Sega Saturn version
+                {
+                        "rtz",
+                        "",
+                        AD_ENTRY1("rtz.dat", "023e46f6b43913792bd535558cce7bf7"),
+                        Common::JA_JPN,
+                        Common::kPlatformSaturn,
+                        Common::ADGF_NO_FLAGS
+                },
+                GID_RTZ,
+                0,
+                GF_FLOPPY,
+                0,
+        },
 
         {
                 // Return to Zork - Demo