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 2
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#ifndef ENGINES_GAME_H
#define ENGINES_GAME_H

#include "common/array.h"
#include "common/hash-str.h"
#include "common/str.h"
#include "common/ustr.h"
#include "common/str-array.h"
#include "common/language.h"
#include "common/platform.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
    kUnupportedGame  // we don't want to support the game
};


struct FileProperties {
    int32 size;
    Common::String md5;

    FileProperties() : size(-1) {}
};

typedef Common::HashMap<Common::String, FileProperties, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> FilePropertiesMap;

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;

    FilePropertiesMap matchedFiles;

    bool canBeAdded;

    Common::String gameId;
    Common::String preferredTarget;
    Common::String description;
    Common::Language language;
    Common::Platform platform;
    Common::String 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