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