Merge multi language games into one entry.

svn-id: r46033

6 files changed, 186 insertions, 157 deletions

diff --git a/tools/create_kyradat/create_kyradat.cpp b/tools/create_kyradat/create_kyradat.cpp
index 3ed69e2218..21d23378e4 100644
--- a/tools/create_kyradat/create_kyradat.cpp
+++ b/tools/create_kyradat/create_kyradat.cpp
@@ -39,6 +39,7 @@
 #include <string>
 #include <map>
 #include <algorithm>
+#include <map>
 
 enum {
 	kKyraDatVersion = 65
@@ -1142,39 +1143,27 @@ const char *getIdString(const int id) {
 	}
 }
 
-struct DataIdEntry {
-	DataIdEntry() : extractInfo(), id(-1) {}
-	DataIdEntry(ExtractEntrySearchData e, int i) : extractInfo(e), id(i) {}
-
-	ExtractEntrySearchData extractInfo;
-	int id;
-};
-
 struct ExtractData {
-	ExtractData() : extractInfo(), result() {}
-	ExtractData(ExtractEntrySearchData e, Search::ResultData r) : extractInfo(e), result(r) {}
+	ExtractData() : desc(), offset() {}
+	ExtractData(ExtractEntrySearchData d, uint32 o) : desc(d), offset(o) {}
 
-	ExtractEntrySearchData extractInfo;
-	Search::ResultData result;
+	ExtractEntrySearchData desc;
+	uint32 offset;
 };
 
-typedef std::list<DataIdEntry> DataIdList;
+typedef std::pair<int, ExtractEntrySearchData> SearchMapEntry;
+typedef std::multimap<int, ExtractEntrySearchData> SearchMap;
 
-typedef std::map<int, Search::ResultData> IdMap;
+typedef std::pair<int, ExtractData> ExtractMapEntry;
+typedef std::multimap<int, ExtractData> ExtractMap;
 
-bool getExtractionData(const Game *g, Search &search, IdMap &map);
+bool getExtractionData(const Game *g, Search &search, ExtractMap &map);
 
 bool process(PAKFile &out, const Game *g, const byte *data, const uint32 size) {
 	char filename[128];
 
-	ExtractInformation extractInfo;
-	extractInfo.game = g->game;
-	extractInfo.lang = g->lang;
-	extractInfo.platform = g->platform;
-	extractInfo.special = g->special;
-
 	Search search(data, size);
-	IdMap ids;
+	ExtractMap ids;
 
 	if (!getExtractionData(g, search, ids))
 		return false;
@@ -1185,47 +1174,32 @@ bool process(PAKFile &out, const Game *g, const byte *data, const uint32 size) {
 		return false;
 	}
 
-	bool breakProcess = false;
+	ExtractInformation extractInfo;
+	extractInfo.game = g->game;
+	extractInfo.platform = g->platform;
+	extractInfo.special = g->special;
 
-	// Compare against need list
-	for (const int *entry = needList; *entry != -1; ++entry) {
-		if (ids.find(*entry) != ids.end())
-			continue;
+	for (ExtractMap::const_iterator i = ids.begin(); i != ids.end(); ++i) {
+		const int id = i->first;
 
-		// Try whether the data is present in the kyra.dat file already
-		filename[0] = 0;
-		if (!getFilename(filename, &extractInfo, *entry))
-			error("couldn't find filename for id %d", *entry);
+		const ExtractFilename *fDesc = getFilenameDesc(id);
 
-		PAKFile::cFileList *list = out.getFileList();
-		// If the data wasn't found already, we need to break the extraction here
-		if (!list || !list->findEntry(filename)) {
-			fprintf(stderr, "Couldn't find id %d/%s in executable file\n", *entry, getIdString(*entry));
-			breakProcess = true;
-		} else {
-			warning("Id %d/%s is present in kyra.dat but could not be found in the executable", *entry, getIdString(*entry));
+		if (!fDesc) {
+			fprintf(stderr, "ERROR: couldn't find file description for id %d\n", id);
+			return false;
 		}
-	}
 
-	if (breakProcess)
-		return false;
+		if (isLangSpecific(fDesc->type))
+			extractInfo.lang = i->second.desc.lang;
+		else
+			extractInfo.lang = UNK_LANG;
 
-	for (IdMap::const_iterator i = ids.begin(); i != ids.end(); ++i) {
-		const int id = i->first;
-	
 		filename[0] = 0;
 		if (!getFilename(filename, &extractInfo, id)) {
 			fprintf(stderr, "ERROR: couldn't get filename for id %d\n", id);
 			return false;
 		}
 
-		const ExtractFilename *fDesc = getFilenameDesc(id);
-
-		if (!fDesc) {
-			fprintf(stderr, "ERROR: couldn't find file description for id %d\n", id);
-			return false;
-		}
-
 		const ExtractType *tDesc = findExtractType(fDesc->type);
 
 		if (!tDesc) {
@@ -1237,21 +1211,27 @@ bool process(PAKFile &out, const Game *g, const byte *data, const uint32 size) {
 		if (list && list->findEntry(filename) != 0)
 			continue;
 
-		if (!tDesc->extract(out, &extractInfo, data + i->second.offset, i->second.data.size, filename, id)) {
+		if (!tDesc->extract(out, &extractInfo, data + i->second.offset, i->second.desc.hint.size, filename, id)) {
 			fprintf(stderr, "ERROR: couldn't extract id %d\n", id);
 			return false;
 		}
 	}
 
-	if (!updateIndex(out, &extractInfo)) {
-		error("couldn't update INDEX file, stop processing of all files");
-		return false;
+	for (int i = 0; i < 3; ++i) {
+		if (g->lang[i] == -1)
+			continue;
+
+		extractInfo.lang = g->lang[i];
+		if (!updateIndex(out, &extractInfo)) {
+			error("couldn't update INDEX file, stop processing of all files");
+			return false;
+		}
 	}
 
 	return true;
 }
 
-bool setupSearch(const int *needList, Search &search, DataIdList &dataIdList) {
+bool setupSearch(const Game *g, const int *needList, Search &search, SearchMap &searchData) {
 	for (const int *entry = needList; *entry != -1; ++entry) {
 		ExtractEntryList providers = getProvidersForId(*entry);
 
@@ -1260,9 +1240,9 @@ bool setupSearch(const int *needList, Search &search, DataIdList &dataIdList) {
 			return false;
 		} else {
 			for (ExtractEntryList::const_iterator i = providers.begin(); i != providers.end(); ++i) {
-				// We will add *all* providers here, regardless of the language and platform!
+				// We'll add all providers here...
 				search.addData(i->hint);
-				dataIdList.push_back(DataIdEntry(*i, *entry));
+				searchData.insert(SearchMapEntry(*entry, *i));
 			}
 		}
 	}
@@ -1270,8 +1250,69 @@ bool setupSearch(const int *needList, Search &search, DataIdList &dataIdList) {
 	return true;
 }
 
-bool getExtractionData(const Game *g, Search &search, IdMap &ids) {
-	DataIdList dataIdList;
+typedef std::list<ExtractMap::const_iterator> MatchList;
+MatchList filterPlatformMatches(const Game *g, std::pair<ExtractMap::const_iterator, ExtractMap::const_iterator> range) {
+	bool hasPlatformMatch = false;
+	for (ExtractMap::const_iterator i = range.first; i != range.second; ++i) {
+		if (i->second.desc.platform == g->platform) {
+			hasPlatformMatch = true;
+			break;
+		}
+	}
+
+	MatchList result;
+	if (hasPlatformMatch) {
+		for (ExtractMap::const_iterator i = range.first; i != range.second; ++i) {
+			if (i->second.desc.platform == g->platform)
+				result.push_back(i);
+		}
+	} else {
+		for (ExtractMap::const_iterator i = range.first; i != range.second; ++i)
+			result.push_back(i);
+	}
+
+	return result;
+}
+
+MatchList filterLanguageMatches(const int lang, const MatchList &input) {
+	std::list<ExtractMap::const_iterator> result;
+
+	for (MatchList::const_iterator i = input.begin(); i != input.end(); ++i) {
+		if ((*i)->second.desc.lang == lang)
+			result.push_back(*i);
+	}
+
+	return result;
+}
+
+MatchList::const_iterator filterOutBestMatch(const MatchList &input) {
+	MatchList::const_iterator result = input.begin();
+
+	if (input.size() > 1)
+		warning("Multiple entries found for id %d/%s", (*result)->first, getIdString((*result)->first));
+
+	for (MatchList::const_iterator i = input.begin(); i != input.end(); ++i) {
+		// Reduce all entries to one single entry.
+		//
+		// We use the following rules for this (in this order):
+		// - Prefer the entry with the higest size
+		// - Prefer the entry, which starts at the smallest offest
+		//
+		// TODO: These rules might not be safe for all games, but hopefully
+		// they will work fine. If there are any problems it should be rather
+		// easy to identify them, since we print out a warning for multiple
+		// entries found.
+		if ((*result)->second.desc.hint.size <= (*i)->second.desc.hint.size) {
+			if ((*result)->second.offset >= (*i)->second.offset)
+				result = i;
+		}
+	}
+
+	return result;
+}
+
+bool getExtractionData(const Game *g, Search &search, ExtractMap &map) {
+	SearchMap searchMap;
 
 	const int *needList = getNeedList(g);
 	if (!needList) {
@@ -1279,7 +1320,7 @@ bool getExtractionData(const Game *g, Search &search, IdMap &ids) {
 		return false;
 	}
 
-	if (!setupSearch(needList, search, dataIdList))
+	if (!setupSearch(g, needList, search, searchMap))
 		return false;
 
 	// Process the data search
@@ -1291,78 +1332,61 @@ bool getExtractionData(const Game *g, Search &search, IdMap &ids) {
 		return false;
 	}
 
+	ExtractMap temporaryExtractMap;
 	for (const int *entry = needList; *entry != -1; ++entry) {
-		typedef std::list<ExtractData> ExtractList;
-		ExtractList idResults;
+		typedef std::pair<SearchMap::const_iterator, SearchMap::const_iterator> KeyRange;
+		KeyRange idRange = searchMap.equal_range(*entry);
 
-		// Fill in all id entries found
 		for (Search::ResultList::const_iterator i = results.begin(); i != results.end(); ++i) {
-			for (DataIdList::const_iterator j = dataIdList.begin(); j != dataIdList.end(); ++j) {
-				if (j->id == *entry && i->data == j->extractInfo.hint)
-					idResults.push_back(ExtractData(j->extractInfo, *i));
+			for (SearchMap::const_iterator j = idRange.first; j != idRange.second; ++j) {
+				if (j->second.hint == i->data)
+					temporaryExtractMap.insert(ExtractMapEntry(*entry, ExtractData(j->second, i->offset)));
 			}
 		}
+	}
 
-		// Sort out entries with mistmatching language settings
-		for (ExtractList::iterator i = idResults.begin(); i != idResults.end();) {
-			if (i->extractInfo.lang != UNK_LANG && i->extractInfo.lang != g->lang) {
-				i = idResults.erase(i);
-				continue;
-			}
-
-			++i;
-		}
-
-		// Determin whether we have a 100% platform match
-		bool hasPlatformMatch = false;
-		for (ExtractList::const_iterator i = idResults.begin(); i != idResults.end(); ++i) {
-			if (i->extractInfo.platform == g->platform)
-				hasPlatformMatch = true;
-		}
+	// Free up some memory
+	results.clear();
+	searchMap.clear();
 
-		for (ExtractList::iterator i = idResults.begin(); i != idResults.end();) {
-			// Sort out entries with mistmatching platform settings, when we have a platform match
-			if (hasPlatformMatch && i->extractInfo.platform != g->platform) {
-				i = idResults.erase(i);
-				continue;
-			}
+	for (const int *entry = needList; *entry != -1; ++entry) {
+		MatchList possibleMatches = filterPlatformMatches(g, temporaryExtractMap.equal_range(*entry));
 
-			++i;
-		}
+		// This means, no matching entries were found, this is in general not a good sign, we might
+		// think of nicer handling of this in the future. TODO: Error out?
+		if (possibleMatches.empty())
+			continue;
 
-		if (idResults.empty())
+		const ExtractFilename *fDesc = getFilenameDesc(*entry);
+		if (!fDesc)
 			continue;
 
-		if (idResults.size() > 1)
-			warning("Multiple entries found for id %d/%s", *entry, getIdString(*entry));
+		if (isLangSpecific(fDesc->type)) {
+			for (int i = 0; i < 3; ++i) {
+				if (g->lang[i] == -1)
+					continue;
 
-		Search::ResultData result;
-		result.data.size = 0;
-		result.offset = 0xFFFFFFFF;
+				MatchList langMatches = filterLanguageMatches(g->lang[i], possibleMatches);
+				if (langMatches.empty())
+					printf("foo %s %d\n", getIdString(*entry), g->lang[i]);
+				MatchList::const_iterator bestMatch = filterOutBestMatch(langMatches);
 
-		// Reduce all entries to one single entry.
-		//
-		// We use the following rules for this (in this order):
-		// - Prefer the entry with the higest size
-		// - Prefer the entry, which starts at the smallest offest
-		//
-		// TODO: These rules might not be safe for all games, but hopefully
-		// they will work fine. If there are any problems it should be rather
-		// easy to identify them, since we print out a warning for multiple
-		// entries found.
-		for (ExtractList::iterator i = idResults.begin(); i != idResults.end(); ++i) {
-			if (result.data.size <= i->result.data.size) {
-				if (result.offset >= i->result.offset)
-					result = i->result;
+				// TODO: Error out. This case means an entry was not found for a required language.
+				if (bestMatch == langMatches.end())
+					continue;
+
+				map.insert(**bestMatch);
 			}
-		}
+		} else {
+			MatchList::const_iterator bestMatch = filterOutBestMatch(possibleMatches);
 
-		ids[*entry] = result;
-	}
+			// TODO: Error out. This case means an entry was not found.
+			if (bestMatch == possibleMatches.end())
+				continue;
 
-	// Free up some memory
-	results.clear();
-	dataIdList.clear();
+			map.insert(**bestMatch);
+		}
+	}
 
 	return true;
 }
diff --git a/tools/create_kyradat/create_kyradat.h b/tools/create_kyradat/create_kyradat.h
index c95b1e1aeb..259bf86ade 100644
--- a/tools/create_kyradat/create_kyradat.h
+++ b/tools/create_kyradat/create_kyradat.h
@@ -306,14 +306,14 @@ enum kGame {
 
 struct Game {
 	int game;
-	int lang;
+	int lang[3];
 	int platform;
 	int special;
 
 	const char *md5[2];
 };
 
-#define GAME_DUMMY_ENTRY { -1, -1, -1, -1, { 0, 0 } }
+#define GAME_DUMMY_ENTRY { -1, { -1, -1, -1 }, -1, -1, { 0, 0 } }
 
 extern const Game * const gameDescs[];
 
diff --git a/tools/create_kyradat/extract.cpp b/tools/create_kyradat/extract.cpp
index 55928c3d41..1e3af95036 100644
--- a/tools/create_kyradat/extract.cpp
+++ b/tools/create_kyradat/extract.cpp
@@ -149,6 +149,15 @@ const ExtractType *findExtractType(const int type) {
 	return 0;
 }
 
+// TODO: Get rid of this....
+bool isLangSpecific(const int type) {
+	const ExtractType *ext = findExtractType(type);
+	if (!ext)
+		return false;
+
+	return (ext->createFilename == createLangFilename);
+}
+
 // Extractor implementation
 
 namespace {
diff --git a/tools/create_kyradat/extract.h b/tools/create_kyradat/extract.h
index 1884587988..fdfaa61835 100644
--- a/tools/create_kyradat/extract.h
+++ b/tools/create_kyradat/extract.h
@@ -66,6 +66,7 @@ struct ExtractType {
 };
 
 const ExtractType *findExtractType(const int type);
+bool isLangSpecific(const int type);
 
 // TODO: Do not export this in the future
 void createFilename(char *dstFilename, const ExtractInformation *info, const char *filename);
diff --git a/tools/create_kyradat/games.cpp b/tools/create_kyradat/games.cpp
index 64010431c4..4b24428c6d 100644
--- a/tools/create_kyradat/games.cpp
+++ b/tools/create_kyradat/games.cpp
@@ -28,82 +28,78 @@ namespace {
 
 const Game kyra1Games[] = {
 	// Demos
-	{ kKyra1, EN_ANY, kPlatformPC, kDemoVersion, { "7b7504c8560ffc914d34c44c71b3094c", 0 } },
-	{ kKyra1, EN_ANY, kPlatformPC, kTalkieDemoVersion, { "226fdba99cb11ef1047131d9a50e6292", 0 } },
+	{ kKyra1, { EN_ANY, -1, -1 }, kPlatformPC, kDemoVersion, { "7b7504c8560ffc914d34c44c71b3094c", 0 } },
+	{ kKyra1, { EN_ANY, -1, -1 }, kPlatformPC, kTalkieDemoVersion, { "226fdba99cb11ef1047131d9a50e6292", 0 } },
 
 	// Amiga
-	{ kKyra1, EN_ANY, kPlatformAmiga, kNoSpecial, { "b620564b6b7e0787b053ca9e35bd9f52", 0 } },
-	{ kKyra1, DE_DEU, kPlatformAmiga, kNoSpecial, { "ceddb4bd4df51698e3851e75106d117a", 0 } },
+	{ kKyra1, { EN_ANY, -1, -1 }, kPlatformAmiga, kNoSpecial, { "b620564b6b7e0787b053ca9e35bd9f52", 0 } },
+	{ kKyra1, { DE_DEU, -1, -1 }, kPlatformAmiga, kNoSpecial, { "ceddb4bd4df51698e3851e75106d117a", 0 } },
 
 	// Floppy
-	{ kKyra1, EN_ANY, kPlatformPC, kNoSpecial, { "76a4fc84e173cadb6369785787e1546e", 0 } },
-	{ kKyra1, DE_DEU, kPlatformPC, kNoSpecial, { "9442d6f7db6a41f3dd4aa4de5d36e107", 0 } },
-	{ kKyra1, FR_FRA, kPlatformPC, kNoSpecial, { "aa9d6d78d8b199deaf48efeca6d19af2", 0 } },
-	{ kKyra1, IT_ITA, kPlatformPC, kNoSpecial, { "5d7550306b369a3492f9f3402702477c", 0 } },
-	{ kKyra1, ES_ESP, kPlatformPC, kNoSpecial, { "9ff130d2558bcd674d4074849d93c362", 0 } },
+	{ kKyra1, { EN_ANY, -1, -1 }, kPlatformPC, kNoSpecial, { "76a4fc84e173cadb6369785787e1546e", 0 } },
+	{ kKyra1, { DE_DEU, -1, -1 }, kPlatformPC, kNoSpecial, { "9442d6f7db6a41f3dd4aa4de5d36e107", 0 } },
+	{ kKyra1, { FR_FRA, -1, -1 }, kPlatformPC, kNoSpecial, { "aa9d6d78d8b199deaf48efeca6d19af2", 0 } },
+	{ kKyra1, { IT_ITA, -1, -1 }, kPlatformPC, kNoSpecial, { "5d7550306b369a3492f9f3402702477c", 0 } },
+	{ kKyra1, { ES_ESP, -1, -1 }, kPlatformPC, kNoSpecial, { "9ff130d2558bcd674d4074849d93c362", 0 } },
 
 	// Talkie
-	{ kKyra1, EN_ANY, kPlatformPC, kTalkieVersion, { "1ebc18f3e7fbb72474a55cb0fa089ed4", 0 } },
-	{ kKyra1, DE_DEU, kPlatformPC, kTalkieVersion, { "c65d381184f98ac26d9efd2d45baef51", 0 } },
-	{ kKyra1, FR_FRA, kPlatformPC, kTalkieVersion, { "307c5d4a554d9068ac3d326e350ae4a6", 0 } },
-	{ kKyra1, IT_ITA, kPlatformPC, kTalkieVersion, { "d0f1752098236083d81b9497bd2b6989", 0 } }, // Italian fan translation
+	{ kKyra1, { EN_ANY, -1, -1 }, kPlatformPC, kTalkieVersion, { "1ebc18f3e7fbb72474a55cb0fa089ed4", 0 } },
+	{ kKyra1, { DE_DEU, -1, -1 }, kPlatformPC, kTalkieVersion, { "c65d381184f98ac26d9efd2d45baef51", 0 } },
+	{ kKyra1, { FR_FRA, -1, -1 }, kPlatformPC, kTalkieVersion, { "307c5d4a554d9068ac3d326e350ae4a6", 0 } },
+	{ kKyra1, { IT_ITA, -1, -1 }, kPlatformPC, kTalkieVersion, { "d0f1752098236083d81b9497bd2b6989", 0 } }, // Italian fan translation
 
 	// FM-TOWNS
-	{ kKyra1, EN_ANY, kPlatformFMTowns, kNoSpecial, { "5a3ad60ccd0f2e29463e0368cd14a60d", 0 } },
-	{ kKyra1, JA_JPN, kPlatformFMTowns, kNoSpecial, { "5a3ad60ccd0f2e29463e0368cd14a60d", 0 } },
+	{ kKyra1, { EN_ANY, JA_JPN, -1 }, kPlatformFMTowns, kNoSpecial, { "5a3ad60ccd0f2e29463e0368cd14a60d", 0 } },
 
 	// PC-98
-	{ kKyra1, JA_JPN, kPlatformPC98, kNoSpecial, { "b9c06ac5177f5bf1f1acc0eea3937f6d", 0 } },
+	{ kKyra1, { JA_JPN, -1, -1 }, kPlatformPC98, kNoSpecial, { "b9c06ac5177f5bf1f1acc0eea3937f6d", 0 } },
 
 	GAME_DUMMY_ENTRY
 };
 
 const Game kyra2Games[] = {
 	// demos
-	{ kKyra2, EN_ANY, kPlatformPC, kDemoVersion, { "a620a37579dd44ab0403482285e3897f", 0 } },
+	{ kKyra2, { EN_ANY, -1, -1 }, kPlatformPC, kDemoVersion, { "a620a37579dd44ab0403482285e3897f", 0 } },
 
-	{ kKyra2, EN_ANY, kPlatformPC, kTalkieDemoVersion, { "85bbc1cc6c4cef6ad31fc6ee79518efb", "fa54d8abfe05f9186c05f7de7eaf1480" } },
-	{ kKyra2, FR_FRA, kPlatformPC, kTalkieDemoVersion, { "85bbc1cc6c4cef6ad31fc6ee79518efb", "fa54d8abfe05f9186c05f7de7eaf1480" } },
-	{ kKyra2, DE_DEU, kPlatformPC, kTalkieDemoVersion, { "85bbc1cc6c4cef6ad31fc6ee79518efb", "fa54d8abfe05f9186c05f7de7eaf1480" } },
+	{ kKyra2, { EN_ANY, FR_FRA, DE_DEU }, kPlatformPC, kTalkieDemoVersion, { "85bbc1cc6c4cef6ad31fc6ee79518efb", "fa54d8abfe05f9186c05f7de7eaf1480" } },
 
 	// floppy games
-	{ kKyra2, EN_ANY, kPlatformPC, kNoSpecial, { "9b0f5e57b5a2ed88b5b989cbb402b6c7", "7c3eadbe5122722cf2e5e1611e19dfb9" } },
-	{ kKyra2, FR_FRA, kPlatformPC, kNoSpecial, { "df31cc9e37e1cf68df2fdc75ddf2d87b", "fc2c6782778e6c6d5a553d1cb73c98ad" } },
-	{ kKyra2, DE_DEU, kPlatformPC, kNoSpecial, { "0ca4f9a1438264a4c63c3218e064ed3b", "0d9b0eb7b0ad889ec942d74d80dde1bf" } },
-	{ kKyra2, IT_ITA, kPlatformPC, kNoSpecial, { "178d3ab913f61bfba21d2fb196405e8c", "3a61ed6b7c00ddae383a0361799e2ba6" } },
+	{ kKyra2, { EN_ANY, -1, -1 }, kPlatformPC, kNoSpecial, { "9b0f5e57b5a2ed88b5b989cbb402b6c7", "7c3eadbe5122722cf2e5e1611e19dfb9" } },
+	{ kKyra2, { FR_FRA, -1, -1 }, kPlatformPC, kNoSpecial, { "df31cc9e37e1cf68df2fdc75ddf2d87b", "fc2c6782778e6c6d5a553d1cb73c98ad" } },
+	{ kKyra2, { DE_DEU, -1, -1 }, kPlatformPC, kNoSpecial, { "0ca4f9a1438264a4c63c3218e064ed3b", "0d9b0eb7b0ad889ec942d74d80dde1bf" } },
+	{ kKyra2, { IT_ITA, -1, -1 }, kPlatformPC, kNoSpecial, { "178d3ab913f61bfba21d2fb196405e8c", "3a61ed6b7c00ddae383a0361799e2ba6" } },
 
 	// talkie games
-	{ kKyra2, EN_ANY, kPlatformPC, kTalkieVersion, { "85bbc1cc6c4cef6ad31fc6ee79518efb", "e20d0d2e500f01e399ec588247a7e213" } },
-	{ kKyra2, FR_FRA, kPlatformPC, kTalkieVersion, { "85bbc1cc6c4cef6ad31fc6ee79518efb", "e20d0d2e500f01e399ec588247a7e213" } },
-	{ kKyra2, DE_DEU, kPlatformPC, kTalkieVersion, { "85bbc1cc6c4cef6ad31fc6ee79518efb", "e20d0d2e500f01e399ec588247a7e213" } },
-	{ kKyra2, IT_ITA, kPlatformPC, kTalkieVersion, { "130795aa8f2333250c895dae9028b9bb", "e20d0d2e500f01e399ec588247a7e213" } }, // Italian Fan Translation (using same offsets as English)
+	{ kKyra2, { EN_ANY, FR_FRA, DE_DEU }, kPlatformPC, kTalkieVersion, { "85bbc1cc6c4cef6ad31fc6ee79518efb", "e20d0d2e500f01e399ec588247a7e213" } },
+	{ kKyra2, { IT_ITA, FR_FRA, DE_DEU }, kPlatformPC, kTalkieVersion, { "130795aa8f2333250c895dae9028b9bb", "e20d0d2e500f01e399ec588247a7e213" } }, // Italian Fan Translation
 
 	// FM-TOWNS games
-	{ kKyra2, EN_ANY, kPlatformFMTowns, kNoSpecial, { "74f50d79c919cc8e7196c24942ce43d7", "a9a7fd4f05d00090e9e8bda073e6d431" } },
-	{ kKyra2, JA_JPN, kPlatformFMTowns, kNoSpecial, { "74f50d79c919cc8e7196c24942ce43d7", "a9a7fd4f05d00090e9e8bda073e6d431" } },
+	{ kKyra2, { EN_ANY, JA_JPN, -1 }, kPlatformFMTowns, kNoSpecial, { "74f50d79c919cc8e7196c24942ce43d7", "a9a7fd4f05d00090e9e8bda073e6d431" } },
 
 	GAME_DUMMY_ENTRY
 };
 
 const Game kyra3Games[] = {
 	// DOS CD (multi language version, with no language specific strings)
-	{ kKyra3, UNK_LANG, kPlatformPC, kTalkieVersion, { "bf68701eb591d0b72219f314c0d32688", 0 } },
+	{ kKyra3, { EN_ANY, FR_FRA, DE_DEU }, kPlatformPC, kTalkieVersion, { "bf68701eb591d0b72219f314c0d32688", 0 } },
+	{ kKyra3, { EN_ANY, IT_ITA, DE_DEU }, kPlatformPC, kTalkieVersion, { "bf68701eb591d0b72219f314c0d32688", 0 } }, // Fan translation // TODO: Verify md5sum
+	{ kKyra3, { ES_ESP, FR_FRA, DE_DEU }, kPlatformPC, kTalkieVersion, { "bf68701eb591d0b72219f314c0d32688", 0 } }, // Fan translation // TODO: Verify md5sum
 
 	GAME_DUMMY_ENTRY
 };
 
 const Game lolGames[] = {
 	// DOS demo
-	{ kLol, EN_ANY, kPlatformPC, kDemoVersion, { "30bb5af87d38adb47d3e6ce06b1cb042", 0 } },
+	{ kLol, { EN_ANY, -1, -1 }, kPlatformPC, kDemoVersion, { "30bb5af87d38adb47d3e6ce06b1cb042", 0 } },
 
 	// DOS floppy (no language specifc strings)
-	{ kLol, DE_DEU, kPlatformPC, kNoSpecial, { "6b843869772c1b779e1386be868c15dd", 0 } },
+	{ kLol, { DE_DEU, -1, -1 }, kPlatformPC, kNoSpecial, { "6b843869772c1b779e1386be868c15dd", 0 } },
 
 	// PC98 (no language specifc strings)
-	{ kLol, JA_JPN, kPlatformPC98, kNoSpecial, { "6d5bd4a2f5ce433365734ca6b7a8d984", "1b0a457c48ae6908da301b656fe0aab4" } },
+	{ kLol, { JA_JPN, -1, -1 }, kPlatformPC98, kNoSpecial, { "6d5bd4a2f5ce433365734ca6b7a8d984", "1b0a457c48ae6908da301b656fe0aab4" } },
 
 	// DOS CD (multi language version, with no language specific strings)
-	{ kLol, UNK_LANG, kPlatformPC, kTalkieVersion, { "9d1778314de80598c0b0d032e2a1a1cf", "263998ec600afca1cc7b935c473df670" } },
+	{ kLol, { EN_ANY, FR_FRA, DE_DEU }, kPlatformPC, kTalkieVersion, { "9d1778314de80598c0b0d032e2a1a1cf", "263998ec600afca1cc7b935c473df670" } },
 
 	GAME_DUMMY_ENTRY
 };
diff --git a/tools/create_kyradat/tables.cpp b/tools/create_kyradat/tables.cpp
index 461cdaf65e..1a0dc0cd3b 100644
--- a/tools/create_kyradat/tables.cpp
+++ b/tools/create_kyradat/tables.cpp
@@ -211,7 +211,8 @@ const ExtractEntrySearchData kOutroHomeStringProvider[] = {
 
 	{ DE_DEU, kPlatformUnknown, { 0x0000000E, 0x00000473, { { 0xB6, 0xEB, 0xE8, 0x22, 0x67, 0x24, 0xA9, 0xA3, 0x94, 0x55, 0xC6, 0x57, 0x17, 0x15, 0x5B, 0x04 } } } },
 
-	{ UNK_LANG, kPlatformPC, { 0x00000005, 0x00000178, { { 0x2E, 0x9C, 0x94, 0x0F, 0x29, 0x77, 0x27, 0x1D, 0x77, 0x1E, 0x5A, 0xF8, 0x0E, 0x8D, 0x09, 0x6B } } } }, // floppy italian + spanish
+	{ ES_ESP, kPlatformPC, { 0x00000005, 0x00000178, { { 0x2E, 0x9C, 0x94, 0x0F, 0x29, 0x77, 0x27, 0x1D, 0x77, 0x1E, 0x5A, 0xF8, 0x0E, 0x8D, 0x09, 0x6B } } } },
+	{ IT_ITA, kPlatformPC, { 0x00000005, 0x00000178, { { 0x2E, 0x9C, 0x94, 0x0F, 0x29, 0x77, 0x27, 0x1D, 0x77, 0x1E, 0x5A, 0xF8, 0x0E, 0x8D, 0x09, 0x6B } } } },
 
 	{ IT_ITA, kPlatformPC, { 0x00000007, 0x000001B8, { { 0x17, 0x95, 0x5B, 0x4F, 0xE2, 0x07, 0x5A, 0x49, 0xFA, 0xCE, 0x53, 0x8B, 0xE7, 0x46, 0x69, 0xC7 } } } }, // (fan) CD
 
@@ -624,8 +625,6 @@ const ExtractEntrySearchData kNewGameStringProvider[] = {
 
 	{ ES_ESP, kPlatformPC, { 0x0000001B, 0x00000701, { { 0x2B, 0x87, 0xC3, 0x82, 0x68, 0xA5, 0xFC, 0xC5, 0x64, 0x9E, 0xAB, 0xD2, 0x8A, 0x07, 0x9C, 0x1E } } } },
 
-	{ EN_ANY, kPlatformFMTowns, { 0x00000015, 0x0000052B, { { 0xAB, 0xD2, 0x16, 0x26, 0xC2, 0x86, 0xFA, 0xC8, 0x42, 0xCD, 0x16, 0xCD, 0x25, 0xB7, 0x44, 0xDC } } } },
-
 	EXTRACT_END_ENTRY
 };