1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
|
/* 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.
*
* $URL$
* $Id$
*
*/
#include "engines/advancedDetector.h"
#include "base/plugins.h"
#include "sci/sci.h"
#include "sci/engine/kernel.h"
#include "sci/engine/seg_manager.h"
#include "sci/engine/vm.h" // for convertSierraGameId
namespace Sci {
#define GF_FOR_SCI0_BEFORE_629 GF_SCI0_OLDGETTIME
// Titles of the games
static const PlainGameDescriptor SciGameTitles[] = {
{"sci", "Sierra SCI Game"},
{"sci-fanmade", "Fanmade SCI Game"},
{"astrochicken", "Astro Chicken"},
{"christmas1988", "Christmas Card 1988"},
{"christmas1990", "Christmas Card 1990: The Seasoned Professional"},
{"christmas1992", "Christmas Card 1992"},
{"castlebrain", "Castle of Dr. Brain"},
{"iceman", "Codename: Iceman"},
{"camelot", "Conquests of Camelot: King Arthur, Quest for the Grail"},
{"longbow", "Conquests of the Longbow: The Adventures of Robin Hood"},
{"ecoquest", "EcoQuest: The Search for Cetus"},
{"ecoquest2", "EcoQuest II: Lost Secret of the Rainforest"},
{"freddypharkas", "Freddy Pharkas: Frontier Pharmacist"},
{"funseeker", "Fun Seeker's Guide"},
{"hoyle1", "Hoyle Official Book of Games: Volume 1"},
{"hoyle2", "Hoyle Official Book of Games: Volume 2"},
{"hoyle3", "Hoyle Official Book of Games: Volume 3"},
{"hoyle4", "Hoyle Classic Card Games"},
{"jones", "Jones in the Fast Lane"},
{"kq1sci", "King's Quest I: Quest for the Crown"},
{"kq4sci", "King's Quest IV: The Perils of Rosella"},
{"kq5", "King's Quest V: Absence Makes the Heart Go Yonder"},
{"kq6", "King's Quest VI: Heir Today, Gone Tomorrow"},
{"laurabow", "Laura Bow: The Colonel's Bequest"},
{"laurabow2", "Laura Bow 2: The Dagger of Amon Ra"},
{"lsl1sci", "Leisure Suit Larry in the Land of the Lounge Lizards"},
{"lsl2", "Leisure Suit Larry 2: Goes Looking for Love (in Several Wrong Places)"},
{"lsl3", "Leisure Suit Larry 3: Passionate Patti in Pursuit of the Pulsating Pectorals"},
{"lsl5", "Leisure Suit Larry 5: Passionate Patti Does a Little Undercover Work"},
{"lsl6", "Leisure Suit Larry 6: Shape Up or Slip Out!"},
{"lslcasino", "Crazy Nick's Software Picks: Leisure Suit Larry's Casino"},
{"fairytales", "Mixed-up Fairy Tales"},
{"mothergoose", "Mixed-Up Mother Goose"},
{"msastrochicken", "Ms. Astro Chicken"},
{"pepper", "Pepper's Adventure in Time"},
{"pq1sci", "Police Quest: In Pursuit of the Death Angel"},
{"pq2", "Police Quest II: The Vengeance"},
{"pq3", "Police Quest III: The Kindred"},
{"qfg1", "Quest for Glory I: So You Want to Be a Hero"},
{"qfg2", "Quest for Glory II: Trial by Fire"},
{"qfg3", "Quest for Glory III: Wages of War"},
{"slater", "Slater & Charlie Go Camping"},
{"sq1sci", "Space Quest I: The Sarien Encounter"},
{"sq3", "Space Quest III: The Pirates of Pestulon"},
{"sq4", "Space Quest IV: Roger Wilco and the Time Rippers"},
{"sq5", "Space Quest V: The Next Mutation"},
{"islandbrain", "The Island of Dr. Brain"},
// SCI32 games
{"gk1", "Gabriel Knight: Sins of the Fathers"}, // demo is SCI11, full version SCI32
{"gk2", "The Beast Within: A Gabriel Knight Mystery"},
{"kq7", "King's Quest VII: The Princeless Bride"},
{"lsl7", "Leisure Suit Larry 7: Love for Sail!"},
{"lighthouse", "Lighthouse: The Dark Being"},
{"phantasmagoria", "Phantasmagoria"},
{"phantasmagoria2", "Phantasmagoria II: A Puzzle of Flesh"},
{"pq4", "Police Quest IV: Open Season"},
{"pqswat", "Police Quest: SWAT"},
{"qfg4", "Quest for Glory IV: Shadows of Darkness"},
{"rama", "RAMA"},
{"shivers", "Shivers"},
{"shivers2", "Shivers II: Harvest of Souls"},
{"sq6", "Space Quest 6: The Spinal Frontier"},
{"torin", "Torin's Passage"},
{0, 0}
};
#include "sci/detection_tables.h"
/**
* The fallback game descriptor used by the SCI engine's fallbackDetector.
* Contents of this struct are to be overwritten by the fallbackDetector.
*/
static SciGameDescription s_fallbackDesc = {
{
"",
"",
AD_ENTRY1(0, 0), // This should always be AD_ENTRY1(0, 0) in the fallback descriptor
Common::UNK_LANG,
Common::kPlatformPC,
ADGF_NO_FLAGS,
Common::GUIO_NONE
},
0
};
static const ADParams detectionParams = {
// Pointer to ADGameDescription or its superset structure
(const byte *)Sci::SciGameDescriptions,
// Size of that superset structure
sizeof(SciGameDescription),
// Number of bytes to compute MD5 sum for
5000,
// List of all engine targets
SciGameTitles,
// Structure for autoupgrading obsolete targets
0,
// Name of single gameid (optional)
"sci",
// List of files for file-based fallback detection (optional)
0,
// Flags
0,
// Additional GUI options (for every game}
Common::GUIO_NONE
};
class SciMetaEngine : public AdvancedMetaEngine {
public:
SciMetaEngine() : AdvancedMetaEngine(detectionParams) {}
virtual const char *getName() const {
return "SCI Engine [SCI0, SCI01, SCI10, SCI11"
#ifdef ENABLE_SCI32
", SCI32"
#endif
"]";
}
virtual const char *getOriginalCopyright() const {
return "Sierra's Creative Interpreter (C) Sierra Online";
}
virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *gd) const;
const ADGameDescription *fallbackDetect(const Common::FSList &fslist) const;
};
Common::Language charToScummVMLanguage(const char c) {
switch (c) {
case 'F':
return Common::FR_FRA;
case 'S':
return Common::ES_ESP;
case 'I':
return Common::IT_ITA;
case 'G':
return Common::DE_DEU;
case 'J':
case 'j':
return Common::JA_JPN;
case 'P':
return Common::PT_BRA;
default:
return Common::UNK_LANG;
}
}
const ADGameDescription *SciMetaEngine::fallbackDetect(const Common::FSList &fslist) const {
bool foundResMap = false;
bool foundRes000 = false;
// This flag is used to determine if the size of resource.000 is less than 1MB, to distinguish
// between full and demo versions
bool smallResource000Size = false;
// Set some defaults
s_fallbackDesc.desc.extra = "";
s_fallbackDesc.desc.language = Common::EN_ANY;
s_fallbackDesc.desc.flags = ADGF_NO_FLAGS;
s_fallbackDesc.desc.platform = Common::kPlatformPC; // default to PC platform
s_fallbackDesc.desc.gameid = "sci";
// First grab all filenames
for (Common::FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
if (file->isDirectory())
continue;
Common::String filename = file->getName();
filename.toLowercase();
if (filename.contains("resource.map") || filename.contains("resmap.000")) {
// HACK: resource.map is located in the same directory as the other resource files,
// therefore add the directory here, so that the game files can be opened later on
// We now add the parent directory temporary to our SearchMan so the engine code
// used in the detection can access all files via Common::File without any problems.
// In all branches returning from this function, we need to have a call to
// SearchMan.remove to remove it from the default directory pool again.
//
// A proper solution to remove this hack would be to have the code, which is needed
// for detection, to operate on Stream objects, so they can be easily called from
// the detection code. This might be easily to achieve through refactoring the
// code needed for detection.
assert(!SearchMan.hasArchive("SCI_detection"));
SearchMan.addDirectory("SCI_detection", file->getParent());
foundResMap = true;
}
// Determine if we got a CD version and set the CD flag accordingly, by checking for
// resource.aud for SCI1.1 CD games, or audio001.002 for SCI1 CD games. We assume that
// the file should be over 10MB, as it contains all the game speech and is usually
// around 450MB+. The size check is for some floppy game versions like KQ6 floppy, which
// also have a small resource.aud file
if (filename.contains("resource.aud") || filename.contains("audio001.002")) {
Common::SeekableReadStream *tmpStream = file->createReadStream();
if (tmpStream->size() > 10 * 1024 * 1024) {
// We got a CD version, so set the CD flag accordingly
s_fallbackDesc.desc.flags |= ADGF_CD;
s_fallbackDesc.desc.extra = "CD";
}
delete tmpStream;
}
if (filename.contains("resource.000")) {
Common::SeekableReadStream *tmpStream = file->createReadStream();
if (tmpStream->size() < 1 * 1024 * 1024)
smallResource000Size = true;
delete tmpStream;
}
if (filename.contains("resource.000") || filename.contains("resource.001")
|| filename.contains("ressci.000") || filename.contains("ressci.001"))
foundRes000 = true;
// Determine the game platform
// The existence of any of these files indicates an Amiga game
if (filename.contains("9.pat") || filename.contains("spal") ||
filename.contains("patch.005") || filename.contains("bank.001"))
s_fallbackDesc.desc.platform = Common::kPlatformAmiga;
// The existence of 7.pat indicates a Mac game
if (filename.contains("7.pat"))
s_fallbackDesc.desc.platform = Common::kPlatformMacintosh;
// The data files for Atari ST versions are the same as their DOS counterparts
}
// If these files aren't found, it can't be SCI
if (!foundResMap && !foundRes000) {
SearchMan.remove("SCI_detection");
return 0;
}
ResourceManager *resourceManager = new ResourceManager(fslist);
ViewType gameViews = resourceManager->getViewType();
// Have we identified the game views? If not, stop here
if (gameViews == kViewUnknown) {
SearchMan.remove("SCI_detection");
delete resourceManager;
return (const ADGameDescription *)&s_fallbackDesc;
}
#ifndef ENABLE_SCI32
// Is SCI32 compiled in? If not, and this is a SCI32 game,
// stop here
if (resourceManager->sciVersion() >= SCI_VERSION_2) {
SearchMan.remove("SCI_detection");
delete resourceManager;
return (const ADGameDescription *)&s_fallbackDesc;
}
#endif
// EGA views
if (gameViews == kViewEga && s_fallbackDesc.desc.platform != Common::kPlatformAmiga)
s_fallbackDesc.desc.extra = "EGA";
// Set the platform to Amiga if the game is using Amiga views
if (gameViews == kViewAmiga)
s_fallbackDesc.desc.platform = Common::kPlatformAmiga;
// Determine the game id
SegManager *segManager = new SegManager(resourceManager);
if (!script_instantiate(resourceManager, segManager, 0)) {
warning("fallbackDetect(): Could not instantiate script 0");
SearchMan.remove("SCI_detection");
delete segManager;
delete resourceManager;
return 0;
}
reg_t game_obj = script_lookup_export(segManager, 0, 0);
const char *gameName = obj_get_name(segManager, game_obj);
debug(2, "Detected ID: \"%s\" at %04x:%04x", gameName, PRINT_REG(game_obj));
s_fallbackDesc.desc.gameid = convertSierraGameId(gameName, &s_fallbackDesc.desc.flags);
delete segManager;
// Try to determine the game language
// Load up text 0 and start looking for "#" characters
// Non-English versions contain strings like XXXX#YZZZZ
// Where XXXX is the English string, #Y a separator indicating the language
// (e.g. #G for German) and ZZZZ is the translated text
// NOTE: This doesn't work for games which use message instead of text resources
// (like, for example, Eco Quest 1 and all SCI1.1 games and newer, e.g. Freddy Pharkas).
// As far as we know, these games store the messages of each language in separate
// resources, and it's not possible to detect that easily
Resource *text = resourceManager->findResource(ResourceId(kResourceTypeText, 0), 0);
uint seeker = 0;
if (text) {
while (seeker < text->size) {
if (text->data[seeker] == '#') {
s_fallbackDesc.desc.language = charToScummVMLanguage(text->data[seeker + 1]);
break;
}
seeker++;
}
}
delete resourceManager;
// Distinguish demos from full versions
if (!strcmp(s_fallbackDesc.desc.gameid, "castlebrain") && !Common::File::exists("resource.002")) {
// The Spanish full version doesn't have resource.002, but we can distinguish it from the
// demo from the size of resource.000
if (smallResource000Size)
s_fallbackDesc.desc.flags |= ADGF_DEMO;
}
if (!strcmp(s_fallbackDesc.desc.gameid, "islandbrain") && smallResource000Size)
s_fallbackDesc.desc.flags |= ADGF_DEMO;
if (!strcmp(s_fallbackDesc.desc.gameid, "kq6") && smallResource000Size)
s_fallbackDesc.desc.flags |= ADGF_DEMO;
SearchMan.remove("SCI_detection");
return (const ADGameDescription *)&s_fallbackDesc;
}
bool SciMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *gd) const {
const SciGameDescription *desc = (const SciGameDescription *)gd;
*engine = new SciEngine(syst, desc);
return true;
}
} // End of namespace Sci
#if PLUGIN_ENABLED_DYNAMIC(SCI)
REGISTER_PLUGIN_DYNAMIC(SCI, PLUGIN_TYPE_ENGINE, Sci::SciMetaEngine);
#else
REGISTER_PLUGIN_STATIC(SCI, PLUGIN_TYPE_ENGINE, Sci::SciMetaEngine);
#endif
|