database.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/>.
 *
 */
 
#ifndef DATABASE_H_
#define DATABASE_H_
 
#include "engines/myst3/hotspot.h"
#include "engines/myst3/detection.h"
 
#include "common/scummsys.h"
#include "common/str.h"
#include "common/language.h"
#include "common/platform.h"
#include "common/ptr.h"
#include "common/array.h"
#include "common/hashmap.h"
#include "common/stream.h"
 
namespace Myst3 {
 
enum MystLanguage {
    kEnglish = 0,
    kOther   = 1, // Dutch, Japanese or Polish
    kDutch   = 1,
    kFrench  = 2,
    kGerman  = 3,
    kItalian = 4,
    kSpanish = 5
};
 
enum NodeID {
    kNodeSharedInit   = 1,
    kNodeLogoPlay     = 1,
    kNodeMenuNewGame  = 98,
    kNodeMenuMain     = 100,
    kNodeMenuLoadGame = 200,
    kNodeMenuSaveGame = 300
};
 
enum RoomID {
    kRoomShared        = 101,
    kRoomIntro         = 201,
    kRoomTomahnaStart  = 301,
    kRoomTomahnaReturn = 401,
    kJnaninStart       = 501,
    kRoomLeos          = 502,
    kRoomLeet          = 503,
    kRoomLelt          = 504,
    kRoomLemt          = 505,
    kRoomLeof          = 506,
    kRoomEdannaStart   = 601,
    kRoomLisw          = 602,
    kRoomLifo          = 603,
    kRoomLisp          = 604,
    kRoomLine          = 605,
    kRoomVoltaicStart  = 701,
    kRoomEnpp          = 703,
    kRoomEnem          = 704,
    kRoomEnlc          = 705,
    kRoomEndd          = 706,
    kRoomEnch          = 707,
    kRoomEnli          = 708,
    kRoomNarayan       = 801,
    kRoomMenu          = 901,
    kRoomJournals      = 902,
    kRoomDemo          = 903,
    kRoomAtix          = 904,
    kRoomAmateriaStart = 1001,
    kRoomMais          = 1002,
    kRoomMall          = 1003,
    kRoomMass          = 1004,
    kRoomMaww          = 1005,
    kRoomMato          = 1006,
    kLogo              = 1101
};
 
struct NodeData {
    int16 id;
    int16 zipBitIndex;
    Common::Array<CondScript> scripts;
    Common::Array<HotSpot> hotspots;
    Common::Array<CondScript> soundScripts;
    Common::Array<CondScript> backgroundSoundScripts;
};
 
// Nodes are using ref counting pointers since they can be
// deleted by a script they own
typedef Common::SharedPtr<NodeData> NodePtr;
 
struct RoomData {
    uint32 id;
    const char *name;
};
 
struct RoomKey {
    uint16 ageID;
    uint16 roomID;
 
    RoomKey(uint16 room, uint16 age) : roomID(room), ageID(age) {};
 
    bool operator==(const RoomKey &k) const {
        return ageID == k.ageID && roomID == k.roomID;
    }
};
 
struct AgeData {
    uint32 id;
    uint32 disk;
    uint32 roomCount;
    const RoomData *rooms;
    uint32 labelId;
};
 
struct AmbientCue {
    uint16 id;
    uint16 minFrames;
    uint16 maxFrames;
    Common::Array<uint16> tracks;
};
 
enum ScriptType {
    kScriptTypeNode,
    kScriptTypeAmbientSound,
    kScriptTypeBackgroundSound,
    kScriptTypeNodeInit,
    kScriptTypeAmbientCue
};
 
struct RoomScripts {
    Common::String room;
    ScriptType type;
    uint offset;
    uint size;
};
 
class Myst3Engine;
 
class Database {
public:
    Database(const Common::Platform platform, const Common::Language language, const uint32 localizationType);
    ~Database();
 
    void cacheRoom(uint32 roomID, uint32 ageID);
 
    bool isCommonRoom(uint32 roomID, uint32 ageID) const;
 
    NodePtr getNodeData(uint16 nodeID, uint32 roomID, uint32 ageID);
 
    int32 getNodeZipBitIndex(uint16 nodeID, uint32 roomID, uint32 ageID);
 
    const Common::Array<Opcode>& getNodeInitScript() { return _nodeInitScript; }
 
    Common::String getRoomName(uint32 roomID, uint32 ageID) const;
 
    RoomKey getRoomKey(const char *name);
 
    Common::Array<uint16> listRoomNodes(uint32 roomID, uint32 ageID);
 
    uint32 getAgeLabelId(uint32 ageID);
 
    Common::String getSoundName(uint32 id);
 
    uint32 getSoundIdMin() const { return _soundIdMin; }
    uint32 getSoundIdMax() const { return _soundIdMax; }
 
    const AmbientCue &getAmbientCue(uint16 id);
 
    int16 getGameLanguageCode() const;
 
    bool areRoomsScriptsEqual(uint32 roomID1, uint32 ageID1, uint32 roomID2, uint32 ageID2, ScriptType scriptType);
 
private:
    struct RoomKeyHash {
        uint operator()(const RoomKey &v) const {
            return v.ageID + (v.roomID << 16);
        }
    };
 
    typedef Common::HashMap<RoomKey, Common::Array<NodePtr>, RoomKeyHash> NodesCache;
 
    const Common::Platform _platform;
    const Common::Language _language;
    const uint32 _localizationType;
 
    static const AgeData _ages[];
 
    NodesCache _roomNodesCache;
 
    Common::Array<Opcode> _nodeInitScript;
 
    uint32 _soundIdMin;
    uint32 _soundIdMax;
    Common::HashMap<uint32, Common::String> _soundNames;
    Common::HashMap<uint16, AmbientCue> _ambientCues;
    Common::HashMap<uint32, int16> _roomZipBitIndex;
 
    // 'myst3.dat' cached data
    static const uint kDatVersion = 3;
    Common::SeekableReadStream *_datFile;
    Common::Array<RoomScripts> _roomScriptsIndex;
    int32 _roomScriptsStartOffset;
 
    const RoomData *findRoomData(uint32 roomID, uint32 ageID) const;
    Common::Array<NodePtr> getRoomNodes(uint32 roomID, uint32 ageID) const;
 
    Common::Array<NodePtr> readRoomScripts(const RoomData *room) const;
    void preloadCommonRooms();
    void initializeZipBitIndexTable();
    void patchLanguageMenu();
    void patchNodeScripts(const RoomData *room, Common::Array<NodePtr> &nodes) const;
 
    // 'myst3.dat' read methods
    void readScriptIndex(Common::SeekableReadStream *stream, bool load);
    void readSoundNames(Common::SeekableReadStream *stream, bool load);
    void loadAmbientCues(Common::ReadStream *s);
    Common::SeekableReadStream *getRoomScriptStream(const char *room, ScriptType scriptType) const;
};
 
} // End of namespace Myst3
 
#endif // DATABASE_H_