1 files changed, 133 insertions, 43 deletions
diff --git a/engines/game.h b/engines/game.h
index e01e5c6885..14f9962ce6 100644
--- a/engines/game.h
+++ b/engines/game.h
@@ -38,6 +38,9 @@
 struct PlainGameDescriptor {
 	const char *gameId;
 	const char *description;
+
+	static PlainGameDescriptor empty();
+	static PlainGameDescriptor of(const char *gameId, const char *description);
 };
 
 /**
@@ -47,6 +50,18 @@ struct PlainGameDescriptor {
  */
 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++;
+		}
+	}
+};
+
 /**
  * Ths is an enum to describe how done a game is. This also indicates what level of support is expected.
  */
@@ -56,63 +71,138 @@ enum GameSupportLevel {
 	kUnstableGame // the game is not even ready for public testing yet
 };
 
+
 /**
- * A hashmap describing details about a given game. In a sense this is a refined
- * version of PlainGameDescriptor, as it also contains a gameid and a description string.
- * But in addition, platform and language settings, as well as arbitrary other settings,
- * can be contained in a GameDescriptor.
- * This is an essential part of the glue between the game engines and the launcher code.
+ * A record describing the properties of a file. Used on the existing
+ * files while detecting a game.
  */
-class GameDescriptor : public Common::StringMap {
-public:
-	GameDescriptor();
-	GameDescriptor(const PlainGameDescriptor &pgd, Common::String guioptions = Common::String());
-	GameDescriptor(const Common::String &gameid,
-	              const Common::String &description,
-	              Common::Language language = Common::UNK_LANG,
-				  Common::Platform platform = Common::kPlatformUnknown,
-				  Common::String guioptions = Common::String(),
-				  GameSupportLevel gsl = kStableGame);
+struct FileProperties {
+	int32 size;
+	Common::String md5;
+
+	FileProperties() : size(-1) {}
+};
+
+/**
+ * A map of all relevant existing files while detecting.
+ */
+typedef Common::HashMap<Common::String, FileProperties, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> FilePropertiesMap;
+
+/**
+ * Details about a given game.
+ *
+ * While PlainGameDescriptor refers to a game supported by an engine, this refers to a game copy
+ * that has been detected by an engine's detector.
+ * It contains all the necessary data to add the game to the configuration manager and / or to launch it.
+ */
+struct DetectedGame {
+	DetectedGame();
+	explicit DetectedGame(const PlainGameDescriptor &pgd);
+	DetectedGame(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());
+
+	void setGUIOptions(const Common::String &options);
+	void appendGUIOptions(const Common::String &str);
+	Common::String getGUIOptions() const { return _guiOptions; }
 
 	/**
-	 * Update the description string by appending (EXTRA/PLATFORM/LANG) to it.
-	 * Values that are missing are omitted, so e.g. (EXTRA/LANG) would be
-	 * added if no platform has been specified but a language and an extra string.
+	 * The name of the engine supporting the detected game
 	 */
-	void updateDesc(const char *extra = 0);
+	const char *engineName;
 
-	void setGUIOptions(Common::String options);
-	void appendGUIOptions(const Common::String &str);
+	/**
+	 * A game was detected, but some files were not recognized
+	 *
+	 * This can happen when the md5 or size of the detected files did not match the engine's detection tables.
+	 * When this is true, the list of matched files below contains detail about the unknown files.
+	 *
+	 * @see matchedFiles
+	 */
+	bool hasUnknownFiles;
+
+	/**
+	 * An optional list of the files that were used to match the game with the engine's detection tables
+	 */
+	FilePropertiesMap matchedFiles;
+
+	/**
+	 * This detection entry contains enough data to add the game to the configuration manager and launch it
+	 *
+	 * @see matchedGame
+	 */
+	bool canBeAdded;
+
+	Common::String gameId;
+	Common::String preferredTarget;
+	Common::String description;
+	Common::Language language;
+	Common::Platform platform;
+	Common::String path;
+	Common::String extra;
 
 	/**
 	 * What level of support is expected of this game
 	 */
-	GameSupportLevel getSupportLevel();
-	void setSupportLevel(GameSupportLevel gsl);
-
-	Common::String &gameid() { return getVal("gameid"); }
-	Common::String &description() { return getVal("description"); }
-	const Common::String &gameid() const { return getVal("gameid"); }
-	const Common::String &description() const { return getVal("description"); }
-	Common::Language language() const { return contains("language") ? Common::parseLanguage(getVal("language")) : Common::UNK_LANG; }
-	Common::Platform platform() const { return contains("platform") ? Common::parsePlatform(getVal("platform")) : Common::kPlatformUnknown; }
-
-	const Common::String &preferredtarget() const {
-		return contains("preferredtarget") ? getVal("preferredtarget") : getVal("gameid");
-	}
+	GameSupportLevel gameSupportLevel;
+
+private:
+	/**
+	 * Update the description string by appending (EXTRA/PLATFORM/LANG) to it.
+	 * Values that are missing are omitted, so e.g. (EXTRA/LANG) would be
+	 * added if no platform has been specified but a language and an extra string.
+	 */
+	Common::String updateDesc() const;
+
+	Common::String _guiOptions;
 };
 
 /** List of games. */
-class GameList : public Common::Array<GameDescriptor> {
+typedef Common::Array<DetectedGame> DetectedGames;
+
+/**
+ * Contains a list of games found by the engines' detectors.
+ *
+ * Each detected game can either:
+ * - be fully recognized (e.g. an exact match was found in the detection tables of an engine)
+ * - be an unknown variant (e.g. a game using files with the same name was found in the detection tables)
+ * - be recognized with unknown files (e.g. the game was exactly not found in the detection tables,
+ *              but the detector was able to gather enough data to allow launching the game)
+ *
+ * Practically, this means a detected game can be in both the recognized game list and in the unknown game
+ * report handled by this class.
+ */
+class DetectionResults {
 public:
-	GameList() {}
-	GameList(const GameList &list) : Common::Array<GameDescriptor>(list) {}
-	GameList(const PlainGameDescriptor *g) {
-		while (g->gameId) {
-			push_back(GameDescriptor(*g));
-			g++;
-		}
-	}
+	explicit DetectionResults(const DetectedGames &detectedGames);
+
+	/**
+	 * List all the games that were recognized by the engines
+	 *
+	 * Recognized games can be added to the configuration manager and then launched.
+	 */
+	DetectedGames listRecognizedGames();
+
+	/**
+	 * Were unknown game variants found by the engines?
+	 *
+	 * When unknown game variants are found, an unknown game report can be generated.
+	 */
+	bool foundUnknownGames() const;
+
+	/**
+	 * Generate a report that we found an unknown game variant, together with the file
+	 * names, sizes and MD5 sums.
+	 *
+	 * @param translate translate the report to the currently active GUI language
+	 * @param wordwrapAt word wrap the text part of the report after a number of characters
+	 */
+	Common::String generateUnknownGameReport(bool translate, uint32 wordwrapAt = 0) const;
+
+private:
+	DetectedGames _detectedGames;
 };
 
 #endif