savefile.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *
 * This file is dual-licensed.
 * In addition to the GPLv3 license mentioned above, this code is also
 * licensed under LGPL 2.1. See LICENSES/COPYING.LGPL file for the
 * full text of the license.
 *
 */
 
#ifndef GOB_SAVE_SAVEFILE_H
#define GOB_SAVE_SAVEFILE_H
 
#include "common/endian.h"
#include "common/array.h"
#include "common/savefile.h"
 
namespace Gob {
 
class GobEngine;
class Surface;
 
class SaveHeader {
public:
    static const int kSize = 20;
    static const uint32 kID1 = MKTAG(0,'S','C','V');
    static const uint32 kID2 = MKTAG('M','G','O','B');
 
    SaveHeader(uint32 type = 0, uint32 version = 0, uint32 size = 0);
 
    bool operator==(const SaveHeader &header) const;
    bool operator!=(const SaveHeader &header) const;
 
    bool read(Common::ReadStream &stream);
    bool verify(Common::ReadStream &stream) const;
    bool verifyReadSize(Common::ReadStream &stream);
    bool write(Common::WriteStream &stream) const;
 
    uint32 getType() const;
    uint32 getVersion() const;
    uint32 getSize() const;
 
    void setType(uint32 type);
    void setVersion(uint32 version);
    void setSize(uint32 size);
 
private:
    uint32 _type;
    uint32 _version;
    uint32 _size;
};
 
class SavePart {
public:
    SavePart();
    virtual ~SavePart();
 
    virtual uint32 getSize() const;
 
    virtual bool read(Common::ReadStream &stream) = 0;
    virtual bool write(Common::WriteStream &stream) const = 0;
 
protected:
    SaveHeader _header;
};
 
class SavePartMem : public SavePart {
public:
    static const uint32 kVersion = 1;
    static const uint32 kID = MKTAG('P','M','E','M');
 
    SavePartMem(uint32 size);
    ~SavePartMem() override;
 
    bool read(Common::ReadStream &stream) override;
    bool write(Common::WriteStream &stream) const override;
 
    bool readFrom(const byte *data, uint32 offset, uint32 size);
    bool writeInto(byte *data, uint32 offset, uint32 size) const;
 
private:
    uint32 _size;
    byte *_data;
};
 
class SavePartVars : public SavePart {
public:
    static const uint32 kVersion = 1;
    static const uint32 kID = MKTAG('V','A','R','S');
 
    SavePartVars(GobEngine *vm, uint32 size);
    ~SavePartVars() override;
 
    bool read(Common::ReadStream &stream) override;
    bool write(Common::WriteStream &stream) const override;
 
    bool readFrom(uint32 var, uint32 offset, uint32 size);
    bool writeInto(uint32 var, uint32 offset, uint32 size) const;
 
    bool readFromRaw(const byte *data, uint32 offset, uint32 size);
 
    bool writeIntoRaw(byte *data, uint32 offset, uint32 size) const;
 
    const byte* data() const { return _data; }
 
private:
    GobEngine *_vm;
 
    uint32 _size;
    byte *_data;
};
 
class SavePartSprite : public SavePart {
public:
    static const uint32 kVersion = 2;
    static const uint32 kID = MKTAG('S','P','R','T');
 
    SavePartSprite(uint32 width, uint32 height, bool trueColor = false);
    ~SavePartSprite() override;
 
    bool read(Common::ReadStream &stream) override;
    bool write(Common::WriteStream &stream) const override;
 
    bool readPalette(const byte *palette);
    bool readSprite(const Surface &sprite);
 
    bool readSpriteRaw(const byte *data, uint32 size);
 
    bool writePalette(byte *palette) const;
    bool writeSprite(Surface &sprite) const;
 
private:
    uint32 _width;
    uint32 _height;
 
    uint32 _spriteSize;
 
    bool _oldFormat;
    bool _trueColor;
 
    byte *_dataSprite;
    byte *_dataPalette;
};
 
class SavePartInfo : public SavePart {
public:
    static const uint32 kVersion = 1;
    static const uint32 kID = MKTAG('I','N','F','O');
 
    SavePartInfo(uint32 descMaxLength, uint32 gameID,
            uint32 gameVersion, byte endian, uint32 varCount);
    ~SavePartInfo() override;
 
    const char *getDesc() const;
    uint32 getDescMaxLength() const;
 
    void setVarCount(uint32 varCount);
    void setDesc(const char *desc = 0);
    void setDesc(const byte *desc, uint32 size);
 
    bool read(Common::ReadStream &stream) override;
    bool write(Common::WriteStream &stream) const override;
 
private:
    char *_desc;
    uint32 _descMaxLength;
    uint32 _gameID;
    uint32 _gameVersion;
    uint32 _varCount;
    byte _endian;
};
 
class SaveContainer {
public:
    static const uint32 kVersion = 1;
    static const uint32 kID = MKTAG('C','O','N','T');
 
    SaveContainer(uint32 partCount, uint32 slot);
    ~SaveContainer();
 
    uint32 getSlot() const;
    uint32 getSize() const;
 
    bool hasAllParts() const;
 
    void clear();
 
    bool writePart(uint32 partN, const SavePart *part);
    bool readPart(uint32 partN, SavePart *part) const;
    bool readPartHeader(uint32 partN, SaveHeader *header) const;
 
    static bool isSave(Common::SeekableReadStream &stream);
 
protected:
    struct Part {
        uint32 size;
        byte *data;
 
        Part(uint32 s);
        ~Part();
 
        Common::WriteStream *createWriteStream();
        Common::ReadStream *createReadStream() const;
    };
 
    struct PartInfo {
        uint32 id;
        uint32 offset;
        uint32 size;
    };
 
    typedef Common::Array<Part *>::iterator PartIterator;
    typedef Common::Array<Part *>::const_iterator PartConstIterator;
 
    uint32 _partCount;
    uint32 _slot;
 
    SaveHeader _header;
    Common::Array<Part *> _parts;
 
    uint32 calcSize() const;
 
    bool read(Common::ReadStream &stream);
    bool write(Common::WriteStream &stream) const;
 
    static Common::Array<PartInfo> *getPartsInfo(Common::SeekableReadStream &stream);
};
 
class SaveReader : public SaveContainer {
public:
    SaveReader(uint32 partCount, uint32 slot, const Common::String &fileName);
    SaveReader(uint32 partCount, uint32 slot, Common::SeekableReadStream &stream);
    ~SaveReader();
 
    bool load();
 
    bool readPart(uint32 partN, SavePart *part) const;
    bool readPartHeader(uint32 partN, SaveHeader *header) const;
 
    static bool getInfo(Common::SeekableReadStream &stream, SavePartInfo &info);
    static bool getInfo(const Common::String &fileName, SavePartInfo &info);
 
protected:
    Common::String _fileName;
    Common::SeekableReadStream *_stream;
 
    bool _loaded;
 
    static Common::InSaveFile *openSave(const Common::String &fileName);
    Common::InSaveFile *openSave();
};
 
class SaveWriter: public SaveContainer {
public:
    SaveWriter(uint32 partCount, uint32 slot);
    SaveWriter(uint32 partCount, uint32 slot, const Common::String &fileName);
    ~SaveWriter();
 
    bool writePart(uint32 partN, const SavePart *part);
 
    bool save(Common::WriteStream &stream);
    bool deleteFile();
 
protected:
    bool save();
 
    Common::String _fileName;
 
    bool canSave() const;
 
    static Common::OutSaveFile *openSave(const Common::String &fileName);
    Common::OutSaveFile *openSave();
};
 
} // End of namespace Gob
 
#endif // GOB_SAVE_SAVEFILE_H