game.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 ENGINES_GAME_H
#define ENGINES_GAME_H
 
#include "common/array.h"
#include "common/hash-str.h"
#include "common/language.h"
#include "common/path.h"
#include "common/platform.h"
#include "common/str.h"
#include "common/str-array.h"
#include "common/ustr.h"
 
struct PlainGameDescriptor {
    const char *gameId;
    const char *description;
 
    static PlainGameDescriptor empty();
    static PlainGameDescriptor of(const char *gameId, const char *description);
};
 
const PlainGameDescriptor *findPlainGameDescriptor(const char *gameid, const PlainGameDescriptor *list);
 
class PlainGameList : public Common::Array<PlainGameDescriptor> {
public:
    PlainGameList() {}
    PlainGameList(const PlainGameList &list) : Common::Array<PlainGameDescriptor>(list) {}
    PlainGameList(const PlainGameDescriptor *g) {
        while (g->gameId) {
            push_back(*g);
            g++;
        }
    }
};
 
struct QualifiedGameDescriptor {
    Common::String engineId;
    Common::String gameId;
    Common::String description;
 
    QualifiedGameDescriptor() {}
    QualifiedGameDescriptor(const char *engine, const PlainGameDescriptor &pgd);
};
 
typedef Common::Array<QualifiedGameDescriptor> QualifiedGameList;
 
enum GameSupportLevel {
    kStableGame = 0,  // the game is fully supported
    kTestingGame,     // the game is not supposed to end up in releases yet but is ready for public testing
    kUnstableGame,    // the game is not even ready for public testing yet
    kUnsupportedGame, // we don't want to support the game
    kWarningGame      // we want to ask user to proceed and provide them with an explanation
};
 
enum MD5Properties {
    kMD5Head                 = 0 << 1,  // the MD5 is calculated from the head, default
    kMD5Tail                 = 1 << 1,  // the MD5 is calculated from the tail
    kMD5MacResFork           = 1 << 2,  // the MD5 is calculated from the Mac Resource fork (no fall back) (head or tail)
    kMD5MacDataFork          = 1 << 3,  // the MD5 is calculated from the Mac Data fork (head or tail)
    kMD5MacMask              = kMD5MacResFork | kMD5MacDataFork,    // Mask for mac type
    kMD5Archive              = 1 << 4,  // the desired file is inside an archive
};
 
Common::String md5PropToCachePrefix(MD5Properties val);
 
struct FileProperties {
    int64 size;
    Common::String md5;
    MD5Properties md5prop;
 
    FileProperties() : size(-1), md5prop(kMD5Head) {}
};
 
typedef Common::HashMap<Common::Path, FileProperties, Common::Path::IgnoreCase_Hash, Common::Path::IgnoreCase_EqualTo> FilePropertiesMap;
 
typedef Common::HashMap<Common::String, FileProperties, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> CachedPropertiesMap;
 
struct DetectedGame {
    DetectedGame();
    DetectedGame(const Common::String &engine, const PlainGameDescriptor &pgd);
    DetectedGame(const Common::String &engine, const Common::String &id,
                   const Common::String &description,
                   Common::Language language = Common::UNK_LANG,
                   Common::Platform platform = Common::kPlatformUnknown,
                   const Common::String &extra = Common::String(),
                   bool unsupported = false);
 
    void setGUIOptions(const Common::String &options);
    void appendGUIOptions(const Common::String &str);
    const Common::String &getGUIOptions() const { return _guiOptions; }
 
    Common::String engineId;
 
    bool hasUnknownFiles;
 
    bool isSelected = false;
 
    FilePropertiesMap matchedFiles;
 
    bool canBeAdded;
 
    bool isAddOn = false;
 
    Common::String gameId;
    Common::String preferredTarget;
    Common::String description;
    Common::Language language;
    Common::Platform platform;
    Common::Path path;
    Common::String shortPath;
    Common::String extra;
 
    GameSupportLevel gameSupportLevel;
 
    Common::StringMap _extraConfigEntries;
 
    void addExtraEntry(const Common::String &key, const Common::String &value) {
        _extraConfigEntries[key] = value;
    }
private:
    Common::String updateDesc(bool skipExtraField) const;
 
    Common::String _guiOptions;
};
 
typedef Common::Array<DetectedGame> DetectedGames;
 
class DetectionResults {
public:
    explicit DetectionResults(const DetectedGames &detectedGames);
 
    DetectedGames listRecognizedGames() const;
 
    DetectedGames listDetectedGames() const;
 
    bool foundUnknownGames() const;
 
    Common::U32String generateUnknownGameReport(bool translate, uint32 wordwrapAt = 0) const;
 
private:
    DetectedGames _detectedGames;
};
 
Common::U32String generateUnknownGameReport(const DetectedGames &detectedGames, bool translate, bool fullPath, uint32 wordwrapAt = 0);
Common::U32String generateUnknownGameReport(const DetectedGame &detectedGame, bool translate, bool fullPath, uint32 wordwrapAt = 0);
#endif