Ticket #8690: fallback-alternate.patch

common/advancedDetector.h

@@ -64 +64 @@
 };
 
 /**
+ * Encapsulates ADGameDescription and makes gameid and extra strings dynamic.
+ * Used in fallback detection when dynamically creating string content.
+ */
+struct EncapsulatedADGameDesc : ADGameDescription {
+        Common::String gameid;
+        Common::String extra;
+
+        EncapsulatedADGameDesc() {
+        }
+        EncapsulatedADGameDesc(const ADGameDescription &realDesc,
+                Common::String paramGameID = Common::String(""),
+                Common::String paramExtra = Common::String(""))
+                : ADGameDescription(realDesc), gameid(paramGameID), extra(paramExtra) {
+        }
+
+        // Functions for getting the correct gameid and extra values from the struct
+        const char *getGameID() const { return gameid.empty() ? ((ADGameDescription *)this)->gameid : gameid.c_str(); }
+        const char *getExtra() const { return extra.empty() ? ((ADGameDescription *)this)->extra : extra.c_str(); }
+};
+
+/**
  * A list of pointers to ADGameDescription structs (or subclasses thereof).
  */
 typedef Array<const ADGameDescription*> ADGameDescList;
@@ -175 +196 @@
          * @note The fslist parameter may be 0 -- in that case, it is assumed
          *       that the callback searchs the current directory.
          *
+         * @note You need to handle deleting the returned pointer if it's not NULL.
+         *       You don't need to delete the memory pointed to by the realDesc
+         *       pointer inside the struct though because it should be statically
+         *       allocated.
+         *
+         * @return A pointer to a single EncapsulatedADGameDesc if there was a
+         *         match, otherwise NULL.
+         *
          * @todo
          */
-        ADGameDescList (*fallbackDetectFunc)(const FSList *fslist);
+        EncapsulatedADGameDesc (*fallbackDetectFunc)(const FSList *fslist);
 
         /**
          * A bitmask of flags which can be used to configure the behavior
@@ -206 +235 @@
 // FIXME/TODO: Rename this function to something more sensible.
 GameList detectAllGames(const FSList &fslist, const Common::ADParams &params);
 
-// FIXME/TODO: Rename this function to something more sensible.
-const ADGameDescription *detectBestMatchingGame(const Common::ADParams &params);
+/**
+ * Detect the best matching game.
+ *
+ * FIXME/TODO: Rename this function to something more sensible.
+ *
+ * @note You need to handle deleting the returned pointer if it's not NULL.
+ *       You don't need to delete the memory pointed to by the realDesc
+ *       pointer inside the struct though because it should be statically
+ *       allocated.
+ */
+EncapsulatedADGameDesc detectBestMatchingGame(const Common::ADParams &params);
 
 // FIXME/TODO: Rename this function to something more sensible.
 // Only used by ADVANCED_DETECTOR_DEFINE_PLUGIN_WITH_FUNC

common/advancedDetector.cpp

@@ -110 +110 @@
         return gd;
 }
 
+// Almost identical to the toGameDescriptor function that takes a ADGameDescription and PlainGameDescriptor.
+// Just a little fine tuning about accessing variables.
+// Used because of fallback detection and the dynamic string content it needs.
+static GameDescriptor toGameDescriptor(const EncapsulatedADGameDesc &g, const PlainGameDescriptor *sg) {
+        const char *title = 0;
+
+        while (sg->gameid) {
+                if (!scumm_stricmp(g.getGameID(), sg->gameid))
+                        title = sg->description;
+                sg++;
+        }
+
+        GameDescriptor gd(g.getGameID(), title, g.language, g.platform);
+        gd.updateDesc(g.getExtra());
+        return gd;
+}
+
 /**
  * Generate a preferred target value as
  *   GAMEID-PLAFORM-LANG
@@ -139 +156 @@
         const Common::ADParams &params
         ) {
         ADGameDescList matches = detectGame(&fslist, params, Common::UNK_LANG, Common::kPlatformUnknown);
-
         GameList detectedGames;
-        for (uint i = 0; i < matches.size(); i++) {
-                GameDescriptor desc(toGameDescriptor(*matches[i], params.list));
+        EncapsulatedADGameDesc fallbackDesc;
 
+        // Use fallback detector if there were no matches by other means
+        if (matches.empty() && params.fallbackDetectFunc != NULL) {
+                fallbackDesc = (*params.fallbackDetectFunc)(&fslist);
+                if (!fallbackDesc.gameid.empty()) detectedGames.push_back(toGameDescriptor(fallbackDesc, params.list));
+        } else for (uint i = 0; i < matches.size(); i++) // Otherwise use the found matches
+                detectedGames.push_back(toGameDescriptor(*matches[i], params.list));
+
+        for (uint i = 0; i < detectedGames.size(); i++) {
                 if (params.singleid != NULL) {
-                        desc["preferredtarget"] = desc["gameid"];
-                        desc["gameid"] = params.singleid;
+                        detectedGames[i]["preferredtarget"] = detectedGames[i]["gameid"];
+                        detectedGames[i]["gameid"] = params.singleid;
                 }
 
                 if (params.flags & kADFlagAugmentPreferredTarget) {
-                        if (!desc.contains("preferredtarget"))
-                                desc["preferredtarget"] = desc["gameid"];
+                        if (!detectedGames[i].contains("preferredtarget"))
+                                detectedGames[i]["preferredtarget"] = detectedGames[i]["gameid"];
 
-                        desc["preferredtarget"] = generatePreferredTarget(desc["preferredtarget"], matches[i]);
+                        if (!matches.empty()) { // If found a match or matches without fallback detection
+                                detectedGames[i]["preferredtarget"] = generatePreferredTarget(detectedGames[i]["preferredtarget"], matches[i]);
+                        } else if (!fallbackDesc.gameid.empty()) { // If found match with the fallback detection
+                                // This assumes that generatePreferredTarget doesn't need gameid or extra fields from the fallbackDesc,
+                                // so we can just give it the ADGameDescription from inside the *fallbackDesc.
+                                detectedGames[i]["preferredtarget"] = generatePreferredTarget(detectedGames[i]["preferredtarget"], &fallbackDesc);
+                        }
                 }
-
-                detectedGames.push_back(desc);
         }
 
         return detectedGames;
 }
 
-const ADGameDescription *detectBestMatchingGame(
+EncapsulatedADGameDesc detectBestMatchingGame(
         const Common::ADParams &params
         ) {
-        const ADGameDescription *agdDesc = 0;
+        const ADGameDescription *agdDesc = NULL;
+        EncapsulatedADGameDesc result;
         Common::Language language = Common::UNK_LANG;
         Common::Platform platform = Common::kPlatformUnknown;
 
@@ -176 +204 @@
 
         Common::String gameid = ConfMan.get("gameid");
 
-        ADGameDescList matches = detectGame(0, params, language, platform);
+        ADGameDescList matches = detectGame(NULL, params, language, platform);
 
         if (params.singleid == NULL) {
                 for (uint i = 0; i < matches.size(); i++) {
@@ -189 +217 @@
                 agdDesc = matches[0];
         }
 
-        if (agdDesc != 0) {
-                debug(2, "Running %s", toGameDescriptor(*agdDesc, params.list).description().c_str());
+        // Use fallback detector if there were no matches by other means
+        if (matches.empty() && params.fallbackDetectFunc != NULL) {
+                EncapsulatedADGameDesc fallbackDesc = (*params.fallbackDetectFunc)(NULL);
+                if (!fallbackDesc.gameid.empty() && (params.singleid != NULL || fallbackDesc.getGameID() == gameid)) {
+                        result = fallbackDesc; // Found a fallback match
+                }
         }
 
-        return agdDesc;
+        // If we found a match without fallback detection
+        // then let's convert it to this function's return format
+        if (agdDesc != NULL) {
+                result = EncapsulatedADGameDesc(*agdDesc);
+        }
+
+        if (!result.gameid.empty()) {
+                debug(2, "Running %s", toGameDescriptor(result, params.list).description().c_str());
+        }
+
+        return result;
 }
 
 PluginError detectGameForEngineCreation(
@@ -236 +278 @@
                 }
         }
 
+        // Use fallback detector if there were no matches by other means
+        if (matches.empty() && params.fallbackDetectFunc != NULL) {
+                EncapsulatedADGameDesc fallbackDesc = (*params.fallbackDetectFunc)(&fslist);
+                if (!fallbackDesc.gameid.empty()) {
+                        bool foundFallbackMatch = (params.singleid != NULL || fallbackDesc.getGameID() == gameid);
+                        if (foundFallbackMatch) return kNoError;
+                }
+        }
+
         return kNoGameDataFoundError;
 }
 
@@ -486 +537 @@
                 }
         }
 
-        // If we still haven't got a match, try to use the fallback callback :-)
-        if (matched.empty() && params.fallbackDetectFunc != 0) {
-                matched = (*params.fallbackDetectFunc)(fslist);
-        }
-
         return matched;
 }