Common::Error CineEngine::run() {
// Initialize backend
initGraphics(320, 200, false);
if (g_cine->getGameType() == GType_FW && (g_cine->getFeatures() & GF_CD))
checkCD();
if (getPlatform() == Common::kPlatformDOS) {
g_sound = new PCSound(_mixer, this);
} else {
// Paula chipset for Amiga and Atari versions
g_sound = new PaulaSound(_mixer, this);
}
_restartRequested = false;
do {
initialize();
_restartRequested = false;
CursorMan.showMouse(true);
mainLoop(1);
delete renderer;
delete[] collisionPage;
} while (_restartRequested);
delete g_sound;
return Common::kNoError;
}
Common::Error MadeEngine::run() {
_music = new MusicPlayer(getGameID() == GID_RTZ);
syncSoundSettings();
// Initialize backend
initGraphics(320, 200, false);
resetAllTimers();
if (getGameID() == GID_RTZ) {
if (getFeatures() & GF_DEMO) {
_dat->open("demo.dat");
_res->open("demo.prj");
} else if (getFeatures() & GF_CD) {
_dat->open("rtzcd.dat");
_res->open("rtzcd.prj");
} else if (getFeatures() & GF_CD_COMPRESSED) {
_dat->openFromRed("rtzcd.red", "rtzcd.dat");
_res->open("rtzcd.prj");
} else if (getFeatures() & GF_FLOPPY) {
_dat->open("rtz.dat");
_res->open("rtz.prj");
} else {
error("Unknown RTZ game features");
}
} else if (getGameID() == GID_MANHOLE) {
_dat->open("manhole.dat");
if (getVersion() == 2) {
_res->open("manhole.prj");
} else {
_res->openResourceBlocks();
}
} else if (getGameID() == GID_LGOP2) {
_dat->open("lgop2.dat");
_res->open("lgop2.prj");
} else if (getGameID() == GID_RODNEY) {
_dat->open("rodneys.dat");
_res->open("rodneys.prj");
} else {
error ("Unknown MADE game");
}
if ((getFeatures() & GF_CD) || (getFeatures() & GF_CD_COMPRESSED))
checkCD();
_autoStopSound = false;
_eventNum = _eventKey = _eventMouseX = _eventMouseY = 0;
#ifdef DUMP_SCRIPTS
_script->dumpAllScripts();
#else
_screen->setDefaultMouseCursor();
_script->runScript(_dat->getMainCodeObjectIndex());
#endif
return Common::kNoError;
}
//-----------------------------------------------------------------------
Bool CSkillUseManager::checkCD( IdType skillId, AddAndCheckSkillCDType addSkillCDType )
{
SkillInfo* skillInfo = (SkillInfo*)SkillInfoList::getInstance().getSkillInfo(skillId);
if(!skillInfo)
{
return true;
}
return checkCD(skillInfo, addSkillCDType);
}
Common::Error GobEngine::run() {
Common::Error err;
err = initGameParts();
if (err.getCode() != Common::kNoError)
return err;
err = initGraphics();
if (err.getCode() != Common::kNoError)
return err;
// On some systems it's not safe to run CD audio games from the CD.
if (isCD())
checkCD();
_system->getAudioCDManager()->open();
_global->_debugFlag = 1;
_video->_doRangeClamp = true;
// WORKAROUND: Some versions check the video mode to detect the system
if (_platform == Common::kPlatformAmiga)
_global->_fakeVideoMode = 0x11;
else if (_platform == Common::kPlatformAtariST)
_global->_fakeVideoMode = 0x10;
else
_global->_fakeVideoMode = 0x13;
_global->_videoMode = 0x13;
_global->_useMouse = 1;
_global->_soundFlags = MIDI_FLAG | SPEAKER_FLAG | BLASTER_FLAG | ADLIB_FLAG;
if (ConfMan.hasKey("language"))
_language = Common::parseLanguage(ConfMan.get("language"));
switch (_language) {
case Common::FR_FRA:
case Common::RU_RUS:
_global->_language = kLanguageFrench;
break;
case Common::DE_DEU:
_global->_language = kLanguageGerman;
break;
case Common::EN_ANY:
case Common::EN_GRB:
case Common::HU_HUN:
_global->_language = kLanguageBritish;
break;
case Common::ES_ESP:
_global->_language = kLanguageSpanish;
break;
case Common::IT_ITA:
_global->_language = kLanguageItalian;
break;
case Common::EN_USA:
_global->_language = kLanguageAmerican;
break;
case Common::NL_NLD:
_global->_language = kLanguageDutch;
break;
case Common::KO_KOR:
_global->_language = kLanguageKorean;
break;
case Common::HE_ISR:
_global->_language = kLanguageHebrew;
break;
case Common::PT_BRA:
_global->_language = kLanguagePortuguese;
break;
case Common::JA_JPN:
_global->_language = kLanguageJapanese;
break;
default:
_global->_language = kLanguageBritish;
break;
}
_global->_languageWanted = _global->_language;
_init->initGame();
return Common::kNoError;
}
Common::Error GroovieEngine::run() {
_script = new Script(this, _gameDescription->version);
// Initialize the graphics
switch (_gameDescription->version) {
case kGroovieV2:
// Request the mode with the highest precision available
initGraphics(640, 480, true, NULL);
// Save the enabled mode as it can be both an RGB mode or CLUT8
_pixelFormat = _system->getScreenFormat();
_mode8bit = (_pixelFormat == Graphics::PixelFormat::createFormatCLUT8());
break;
case kGroovieT7G:
initGraphics(640, 480, true);
_pixelFormat = Graphics::PixelFormat::createFormatCLUT8();
break;
}
// Create debugger. It requires GFX to be initialized
_debugger = new Debugger(this);
_script->setDebugger(_debugger);
// Create the graphics manager
_graphicsMan = new GraphicsMan(this);
// Create the resource and cursor managers and the video player
// Prepare the font too
switch (_gameDescription->version) {
case kGroovieT7G:
if (getPlatform() == Common::kPlatformMacintosh) {
_macResFork = new Common::MacResManager();
if (!_macResFork->open(_gameDescription->desc.filesDescriptions[0].fileName))
error("Could not open %s as a resource fork", _gameDescription->desc.filesDescriptions[0].fileName);
// The Macintosh release used system fonts. We use GUI fonts.
_font = FontMan.getFontByUsage(Graphics::FontManager::kBigGUIFont);
} else {
Common::File fontfile;
if (!fontfile.open("sphinx.fnt")) {
error("Couldn't open sphinx.fnt");
return Common::kNoGameDataFoundError;
} else if (!_sphinxFont.load(fontfile)) {
error("Error loading sphinx.fnt");
return Common::kUnknownError;
}
fontfile.close();
_font = &_sphinxFont;
}
_resMan = new ResMan_t7g(_macResFork);
_grvCursorMan = new GrvCursorMan_t7g(_system, _macResFork);
_videoPlayer = new VDXPlayer(this);
break;
case kGroovieV2:
_resMan = new ResMan_v2();
_grvCursorMan = new GrvCursorMan_v2(_system);
_videoPlayer = new ROQPlayer(this);
break;
}
// Create the music player
if (getPlatform() == Common::kPlatformMacintosh)
_musicPlayer = new MusicPlayerMac(this);
else
_musicPlayer = new MusicPlayerXMI(this, _gameDescription->version == kGroovieT7G ? "fat" : "sample");
// Load volume levels
syncSoundSettings();
// Get the name of the main script
Common::String filename = _gameDescription->desc.filesDescriptions[0].fileName;
if (_gameDescription->version == kGroovieT7G) {
// Run The 7th Guest's demo if requested
if (ConfMan.hasKey("demo_mode") && ConfMan.getBool("demo_mode"))
filename = "demo.grv";
else if (getPlatform() == Common::kPlatformMacintosh)
filename = "script.grv"; // Stored inside the executable's resource fork
} else if (_gameDescription->version == kGroovieV2) {
// Open the disk index
Common::File disk;
if (!disk.open(filename)) {
error("Couldn't open %s", filename.c_str());
return Common::kNoGameDataFoundError;
}
// Search the entry
bool found = false;
int index = 0;
while (!found && !disk.eos()) {
Common::String line = disk.readLine();
if (line.hasPrefix("title: ")) {
// A new entry
index++;
} else if (line.hasPrefix("boot: ") && index == _gameDescription->indexEntry) {
// It's the boot of the entry we're looking for,
// get the script filename
filename = line.c_str() + 6;
found = true;
}
}
// Couldn't find the entry
if (!found) {
error("Couldn't find entry %d in %s", _gameDescription->indexEntry, filename.c_str());
return Common::kUnknownError;
}
}
// Check the script file extension
if (!filename.hasSuffix(".grv")) {
error("%s isn't a valid script filename", filename.c_str());
return Common::kUnknownError;
}
// Load the script
if (!_script->loadScript(filename)) {
error("Couldn't load the script file %s", filename.c_str());
return Common::kUnknownError;
}
// Should I load a saved game?
if (ConfMan.hasKey("save_slot")) {
// Get the requested slot
int slot = ConfMan.getInt("save_slot");
_script->directGameLoad(slot);
}
// Check that the game files and the audio tracks aren't together run from
// the same cd
checkCD();
// Game timer counter
uint16 tmr = 0;
// Initialize the CD
int cd_num = ConfMan.getInt("cdrom");
if (cd_num >= 0)
_system->getAudioCDManager()->openCD(cd_num);
while (!shouldQuit()) {
// Give the debugger a chance to act
_debugger->onFrame();
// Handle input
Common::Event ev;
while (_eventMan->pollEvent(ev)) {
switch (ev.type) {
case Common::EVENT_KEYDOWN:
// CTRL-D: Attach the debugger
if ((ev.kbd.flags & Common::KBD_CTRL) && ev.kbd.keycode == Common::KEYCODE_d)
_debugger->attach();
// Send the event to the scripts
_script->setKbdChar(ev.kbd.ascii);
// Continue the script execution to handle the key
_waitingForInput = false;
break;
case Common::EVENT_MAINMENU:
// Closing the GMM
case Common::EVENT_MOUSEMOVE:
// Continue the script execution, the mouse pointer
// may fall inside a different hotspot now
_waitingForInput = false;
break;
case Common::EVENT_LBUTTONDOWN:
// Send the event to the scripts
_script->setMouseClick(1);
// Continue the script execution to handle
// the click
_waitingForInput = false;
break;
case Common::EVENT_RBUTTONDOWN:
// Send the event to the scripts (to skip the video)
_script->setMouseClick(2);
break;
case Common::EVENT_QUIT:
quitGame();
break;
default:
break;
}
}
// The event loop may have triggered the quit status. In this case,
// stop the execution.
if (shouldQuit()) {
continue;
}
if (_waitingForInput) {
// Still waiting for input, just update the mouse, game timer and then wait a bit more
_grvCursorMan->animate();
_system->updateScreen();
tmr++;
// Wait a little bit between increments. While mouse is moving, this triggers
// only negligably slower.
if (tmr > 4) {
_script->timerTick();
tmr = 0;
}
_system->delayMillis(50);
} else if (_graphicsMan->isFading()) {
// We're waiting for a fading to end, let the CPU rest
// for a while and continue
_system->delayMillis(30);
} else {
// Everything's fine, execute another script step
_script->step();
}
// Update the screen if required
_graphicsMan->update();
}
return Common::kNoError;
}
int GobEngine::init() {
_snd = new Snd(this);
_global = new Global(this);
_anim = new Anim();
_cdrom = new CDROM(this);
_dataio = new DataIO(this);
_pack = new Pack();
_palanim = new PalAnim(this);
_gtimer = new GTimer();
_util = new Util(this);
if (_features & Gob::GF_GOB1) {
_inter = new Inter_v1(this);
_parse = new Parse_v1(this);
_mult = new Mult_v1(this);
_draw = new Draw_v1(this);
_game = new Game_v1(this);
_video = new Video_v1(this);
_init = new Init_v1(this);
_map = new Map_v1(this);
_goblin = new Goblin_v1(this);
_scenery = new Scenery_v1(this);
}
else if (_features & Gob::GF_GOB2) {
_inter = new Inter_v2(this);
_parse = new Parse_v2(this);
_mult = new Mult_v2(this);
_draw = new Draw_v2(this);
_game = new Game_v2(this);
_video = new Video_v2(this);
_init = new Init_v2(this);
_map = new Map_v2(this);
_goblin = new Goblin_v2(this);
_scenery = new Scenery_v2(this);
}
else
error("GobEngine::init(): Unknown version of game engine");
if ((_features & Gob::GF_MAC) || (_features & Gob::GF_GOB1) || (_features & Gob::GF_GOB2)) {
if (ConfMan.get("music_driver") == "null")
_music = new Music_Dummy(this);
else
_music = new Music(this);
}
_system->beginGFXTransaction();
initCommonGFX(false);
_system->initSize(320, 200);
_system->endGFXTransaction();
// On some systems it's not safe to run CD audio games from the CD.
if (_features & GF_CD)
checkCD();
int cd_num = ConfMan.getInt("cdrom");
if (cd_num >= 0)
_system->openCD(cd_num);
_global->_debugFlag = 1;
_global->_doRangeClamp = 1;
_global->_videoMode = 0x13;
_global->_useMouse = 1;
_global->_soundFlags = 0;
if (ConfMan.hasKey("language"))
_language = Common::parseLanguage(ConfMan.get("language"));
switch (_language) {
case Common::FR_FRA:
case Common::RU_RUS:
_global->_language = 0;
break;
case Common::DE_DEU:
_global->_language = 1;
break;
case Common::EN_GRB:
_global->_language = 2;
break;
case Common::ES_ESP:
_global->_language = 3;
break;
case Common::IT_ITA:
_global->_language = 4;
break;
case Common::EN_USA:
_global->_language = 5;
break;
case Common::NL_NLD:
_global->_language = 6;
break;
case Common::KO_KOR:
_global->_language = 7;
break;
case Common::HB_ISR:
_global->_language = 8;
break;
default:
// Default to English
_global->_language = 2;
break;
}
// FIXME: This is the ugly way of reducing redraw overhead. It works
// well for 320x200 but it's unclear how well it will work for
// 640x480.
g_system->setFeatureState(OSystem::kFeatureAutoComputeDirtyRects, true);
return 0;
}
