mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-21 09:21:08 +00:00
367 lines
10 KiB
C++
367 lines
10 KiB
C++
/* ScummVM - Scumm Interpreter
|
|
* Copyright (C) 2006 The ScummVM project
|
|
*
|
|
* 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.
|
|
*
|
|
* $URL$
|
|
* $Id$
|
|
*/
|
|
|
|
#include "kyra/kyra.h"
|
|
|
|
#include "common/config-manager.h"
|
|
#include "common/file.h"
|
|
#include "common/fs.h"
|
|
#include "common/system.h"
|
|
#include "common/md5.h"
|
|
|
|
#include "base/plugins.h"
|
|
|
|
using namespace Kyra;
|
|
|
|
enum {
|
|
// We only compute MD5 of the first megabyte of our data files.
|
|
kMD5FileSizeLimit = 1024 * 1024
|
|
};
|
|
|
|
// Kyra MD5 detection brutally ripped from the Gobliins engine.
|
|
struct GameSettings {
|
|
const char *gameid;
|
|
const char *description;
|
|
byte id;
|
|
uint32 features;
|
|
const char *md5sum;
|
|
const char *checkFile;
|
|
};
|
|
|
|
struct Kyra1LanguageTable {
|
|
const char *file;
|
|
uint32 language;
|
|
Common::Language detLanguage;
|
|
};
|
|
|
|
namespace {
|
|
const GameSettings kyra1_games[] = {
|
|
{ "kyra1", "The Legend of Kyrandia", GI_KYRA1, GF_ENGLISH | GF_FLOPPY, // english floppy 1.0 from Malice
|
|
"3c244298395520bb62b5edfe41688879", "GEMCUT.EMC" },
|
|
{ "kyra1", "The Legend of Kyrandia", GI_KYRA1, GF_ENGLISH | GF_FLOPPY,
|
|
"796e44863dd22fa635b042df1bf16673", "GEMCUT.EMC" },
|
|
{ "kyra1", "The Legend of Kyrandia", GI_KYRA1, GF_FRENCH | GF_FLOPPY,
|
|
"abf8eb360e79a6c2a837751fbd4d3d24", "GEMCUT.EMC" },
|
|
{ "kyra1", "The Legend of Kyrandia", GI_KYRA1, GF_GERMAN | GF_FLOPPY,
|
|
"6018e1dfeaca7fe83f8d0b00eb0dd049", "GEMCUT.EMC"},
|
|
{ "kyra1", "The Legend of Kyrandia", GI_KYRA1, GF_GERMAN | GF_FLOPPY, // from Arne.F
|
|
"f0b276781f47c130f423ec9679fe9ed9", "GEMCUT.EMC"},
|
|
{ "kyra1", "The Legend of Kyrandia", GI_KYRA1, GF_SPANISH | GF_FLOPPY, // from VooD
|
|
"8909b41596913b3f5deaf3c9f1017b01", "GEMCUT.EMC"},
|
|
{ "kyra1", "The Legend of Kyrandia", GI_KYRA1, GF_SPANISH | GF_FLOPPY, // floppy 1.8 from clemmy
|
|
"747861d2a9c643c59fdab570df5b9093", "GEMCUT.EMC"},
|
|
{ "kyra1", "The Legend of Kyrandia", GI_KYRA1, GF_ITALIAN | GF_FLOPPY, // from gourry
|
|
"ef08c8c237ee1473fd52578303fc36df", "GEMCUT.EMC" },
|
|
//{ "kyra1", "The Legend of Kyrandia", GI_KYRA1, GF_AMIGA | GF_FLOPPY | GF_ENGLISH,
|
|
// "2bd1da653eaefd691e050e4a9eb68a64", "GEMCUT.PAK" },
|
|
{ "kyra1", "The Legend of Kyrandia", GI_KYRA1, GF_ENGLISH | GF_TALKIE,
|
|
"fac399fe62f98671e56a005c5e94e39f", "GEMCUT.PAK" },
|
|
{ "kyra1", "The Legend of Kyrandia", GI_KYRA1, GF_GERMAN | GF_TALKIE,
|
|
"230f54e6afc007ab4117159181a1c722", "GEMCUT.PAK" },
|
|
{ "kyra1", "The Legend of Kyrandia", GI_KYRA1, GF_FRENCH | GF_TALKIE,
|
|
"b037c41768b652a040360ffa3556fd2a", "GEMCUT.PAK" },
|
|
{ "kyra1", "The Legend of Kyrandia Demo", GI_KYRA1, GF_DEMO | GF_ENGLISH,
|
|
"fb722947d94897512b13b50cc84fd648", "DEMO1.WSA" },
|
|
{ 0, 0, 0, 0, 0, 0 }
|
|
};
|
|
|
|
const GameSettings kyra2_games[] = {
|
|
{ "kyra2", "The Legend of Kyrandia: The Hand of Fate", GI_KYRA2, GF_ENGLISH, // CD version? Floppy version?
|
|
"28cbad1c5bf06b2d3825ae57d760d032", "FATE.PAK" },
|
|
{ 0, 0, 0, 0, 0, 0 }
|
|
};
|
|
|
|
const GameSettings kyra3_games[] = {
|
|
{ "kyra3", "The Legend of Kyrandia: Malcolm's Revenge",
|
|
GI_KYRA3, GF_LNGUNK, "3833ff312757b8e6147f464cca0a6587", "ONETIME.PAK" },
|
|
{ 0, 0, 0, 0, 0, 0 }
|
|
};
|
|
|
|
// Keep list of different supported games
|
|
const PlainGameDescriptor kyra_list[] = {
|
|
{ "kyra1", "The Legend of Kyrandia" },
|
|
{ "kyra2", "The Legend of Kyrandia: The Hand of Fate" },
|
|
{ "kyra3", "The Legend of Kyrandia: Malcolm's Revenge" },
|
|
{ 0, 0 }
|
|
};
|
|
|
|
const Kyra1LanguageTable kyra1_languages[] = {
|
|
{ "MAIN_FRE.CPS", GF_FRENCH, Common::FR_FRA },
|
|
{ "MAIN_GER.CPS", GF_GERMAN, Common::DE_DEU },
|
|
{ "MAIN_SPA.CPS", GF_SPANISH, Common::ES_ESP },
|
|
{ "MAIN_ITA.CPS", GF_ITALIAN, Common::IT_ITA },
|
|
|
|
// default language
|
|
{ "MAIN15.CPS", GF_ENGLISH, Common::EN_ANY },
|
|
{ "MAIN_ENG.CPS", GF_ENGLISH, Common::EN_ANY },
|
|
|
|
{ 0, 0, Common::UNK_LANG }
|
|
};
|
|
|
|
Common::Language convertKyraLang(uint32 features) {
|
|
if (features & GF_ENGLISH) {
|
|
return Common::EN_ANY;
|
|
} else if (features & GF_FRENCH) {
|
|
return Common::FR_FRA;
|
|
} else if (features & GF_GERMAN) {
|
|
return Common::DE_DEU;
|
|
} else if (features & GF_SPANISH) {
|
|
return Common::ES_ESP;
|
|
}
|
|
return Common::UNK_LANG;
|
|
}
|
|
|
|
Common::Platform convertKyraPlatform(uint32 features) {
|
|
if (features & GF_AUDIOCD) {
|
|
return Common::kPlatformFMTowns;
|
|
} else if (features & GF_AMIGA) {
|
|
return Common::kPlatformAmiga;
|
|
}
|
|
|
|
return Common::kPlatformPC;
|
|
}
|
|
|
|
const char *getKyraVersion(uint32 features) {
|
|
if (features & GF_TALKIE) {
|
|
return "CD";
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
} // End of anonymous namespace
|
|
|
|
using namespace Kyra;
|
|
|
|
GameList Engine_KYRA_gameIDList() {
|
|
GameList games;
|
|
const PlainGameDescriptor *g = kyra_list;
|
|
|
|
while (g->gameid) {
|
|
games.push_back(*g);
|
|
g++;
|
|
}
|
|
return games;
|
|
}
|
|
|
|
GameDescriptor Engine_KYRA_findGameID(const char *gameid) {
|
|
const PlainGameDescriptor *g = kyra_list;
|
|
while (g->gameid) {
|
|
if (0 == scumm_stricmp(gameid, g->gameid))
|
|
break;
|
|
g++;
|
|
}
|
|
return *g;
|
|
}
|
|
|
|
DetectedGameList Engine_KYRA_detectGames(const FSList &fslist) {
|
|
DetectedGameList detectedGames;
|
|
const GameSettings *g;
|
|
FSList::const_iterator file;
|
|
|
|
// Iterate over all files in the given directory
|
|
bool isFound = false;
|
|
for (file = fslist.begin(); file != fslist.end(); file++) {
|
|
if (file->isDirectory())
|
|
continue;
|
|
|
|
// TODO: cleanup
|
|
for (g = kyra1_games; g->gameid; g++) {
|
|
if (scumm_stricmp(file->displayName().c_str(), g->checkFile) == 0)
|
|
isFound = true;
|
|
}
|
|
|
|
if (isFound)
|
|
break;
|
|
|
|
for (g = kyra2_games; g->gameid; g++) {
|
|
if (scumm_stricmp(file->displayName().c_str(), g->checkFile) == 0)
|
|
isFound = true;
|
|
}
|
|
|
|
if (isFound)
|
|
break;
|
|
|
|
for (g = kyra3_games; g->gameid; g++) {
|
|
if (scumm_stricmp(file->displayName().c_str(), g->checkFile) == 0)
|
|
isFound = true;
|
|
}
|
|
|
|
if (isFound)
|
|
break;
|
|
}
|
|
|
|
if (file == fslist.end())
|
|
return detectedGames;
|
|
|
|
uint8 md5sum[16];
|
|
char md5str[32 + 1];
|
|
|
|
if (Common::md5_file(file->path().c_str(), md5sum, kMD5FileSizeLimit)) {
|
|
for (int i = 0; i < 16; i++) {
|
|
sprintf(md5str + i * 2, "%02x", (int)md5sum[i]);
|
|
}
|
|
|
|
// TODO: cleanup
|
|
for (g = kyra1_games; g->gameid; g++) {
|
|
if (strcmp(g->md5sum, (char *)md5str) == 0) {
|
|
DetectedGame dg(*g, convertKyraLang(g->features), convertKyraPlatform(g->features));
|
|
dg.updateDesc(getKyraVersion(g->features));
|
|
|
|
detectedGames.push_back(dg);
|
|
}
|
|
}
|
|
|
|
for (g = kyra2_games; g->gameid; g++) {
|
|
if (strcmp(g->md5sum, (char *)md5str) == 0) {
|
|
DetectedGame dg(*g, convertKyraLang(g->features), convertKyraPlatform(g->features));
|
|
dg.updateDesc(getKyraVersion(g->features));
|
|
|
|
detectedGames.push_back(dg);
|
|
}
|
|
}
|
|
|
|
for (g = kyra3_games; g->gameid; g++) {
|
|
if (strcmp(g->md5sum, (char *)md5str) == 0) {
|
|
DetectedGame dg(*g, convertKyraLang(g->features), convertKyraPlatform(g->features));
|
|
dg.updateDesc(getKyraVersion(g->features));
|
|
|
|
detectedGames.push_back(dg);
|
|
}
|
|
}
|
|
|
|
if (detectedGames.empty()) {
|
|
printf("Unknown MD5 (%s)! Please report the details (language, platform, etc.) of this game to the ScummVM team\n", md5str);
|
|
|
|
const PlainGameDescriptor *g1 = kyra_list;
|
|
while (g1->gameid) {
|
|
detectedGames.push_back(*g1);
|
|
g1++;
|
|
}
|
|
}
|
|
}
|
|
return detectedGames;
|
|
}
|
|
|
|
PluginError Engine_KYRA_create(OSystem *syst, Engine **engine) {
|
|
assert(engine);
|
|
const char *gameid = ConfMan.get("gameid").c_str();
|
|
|
|
if (!scumm_stricmp("kyra1", gameid)) {
|
|
*engine = new KyraEngine_v1(syst);
|
|
} else if (!scumm_stricmp("kyra2", gameid)) {
|
|
*engine = new KyraEngine_v2(syst);
|
|
} else if (!scumm_stricmp("kyra3", gameid)) {
|
|
*engine = new KyraEngine_v3(syst);
|
|
} else
|
|
error("Kyra engine created with invalid gameid.");
|
|
|
|
FSList fslist;
|
|
FilesystemNode dir(ConfMan.get("path"));
|
|
if (!dir.listDir(fslist, FilesystemNode::kListFilesOnly)) {
|
|
warning("KyraEngine: invalid game path '%s'", dir.path().c_str());
|
|
return kInvalidPathError;
|
|
}
|
|
|
|
if (*engine) {
|
|
if (((KyraEngine*)(*engine))->setupGameFlags()) {
|
|
warning("KyraEngine: unable to locate game data at path '%s'", dir.path().c_str());
|
|
delete *engine;
|
|
return kNoGameDataFoundError;
|
|
}
|
|
}
|
|
|
|
return kNoError;
|
|
}
|
|
|
|
REGISTER_PLUGIN(KYRA, "Legend of Kyrandia Engine");
|
|
|
|
#pragma mark -
|
|
|
|
int KyraEngine_v1::setupGameFlags() {
|
|
// Detect game features based on MD5. Again brutally ripped from Gobliins.
|
|
uint8 md5sum[16];
|
|
char md5str[32 + 1];
|
|
|
|
const GameSettings *g;
|
|
bool versionFound = false;
|
|
bool fileFound = false;
|
|
|
|
_features = 0;
|
|
memset(md5str, 0, sizeof(md5str));
|
|
for (g = kyra1_games; g->gameid; g++) {
|
|
if (!Common::File::exists(g->checkFile))
|
|
continue;
|
|
|
|
fileFound = true;
|
|
|
|
if (Common::md5_file(g->checkFile, md5sum, kMD5FileSizeLimit)) {
|
|
for (int j = 0; j < 16; j++) {
|
|
sprintf(md5str + j*2, "%02x", (int)md5sum[j]);
|
|
}
|
|
} else
|
|
continue;
|
|
|
|
if (strcmp(g->md5sum, (char *)md5str) == 0) {
|
|
_features = g->features;
|
|
_game = g->id;
|
|
|
|
if (g->description)
|
|
g_system->setWindowCaption(g->description);
|
|
|
|
versionFound = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (fileFound) {
|
|
if (!versionFound) {
|
|
printf("Unknown MD5 (%s)! Please report the details (language, platform, etc.) of this game to the ScummVM team\n", md5str);
|
|
_features = 0;
|
|
_game = GI_KYRA1;
|
|
if (Common::File::exists("INTRO.VRM")) {
|
|
_features |= GF_TALKIE;
|
|
} else {
|
|
_features |= GF_FLOPPY;
|
|
}
|
|
|
|
// try to detect the language
|
|
const Kyra1LanguageTable *lang = kyra1_languages;
|
|
for (; lang->file; ++lang) {
|
|
if (Common::File::exists(lang->file)) {
|
|
_features |= lang->language;
|
|
versionFound = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!versionFound) {
|
|
_features |= GF_LNGUNK;
|
|
}
|
|
}
|
|
} else {
|
|
GUIErrorMessage("No version of Kyrandia found in specified directory.");
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|