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)
    kMD5MacResOrDataFork     = kMD5MacResFork | kMD5MacDataFork,    // the MD5 is calculated from the Mac Resource fork falling back to data fork (head or tail). Deprecated.
    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;

    FilePropertiesMap matchedFiles;

    bool canBeAdded;

    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