void MohawkEngine_Riven::runLoadDialog() {
GUI::SaveLoadChooser slc(_("Load game:"), _("Load"), false);
int slot = slc.runModalWithCurrentTarget();
if (slot >= 0)
loadGameState(slot);
}
void Engine::openMainMenuDialog() {
if (!_mainMenuDialog)
_mainMenuDialog = new MainMenuDialog(this);
setGameToLoadSlot(-1);
runDialog(*_mainMenuDialog);
// Load savegame after main menu execution
// (not from inside the menu loop to avoid
// mouse cursor glitches and simliar bugs,
// e.g. #2822778).
if (_saveSlotToLoad >= 0) {
Common::Error status = loadGameState(_saveSlotToLoad);
if (status.getCode() != Common::kNoError) {
Common::String failMessage = Common::String::format(_("Failed to load saved game (%s)! "
"Please consult the README for basic information, and for "
"instructions on how to obtain further assistance."), status.getDesc().c_str());
GUI::MessageDialog dialog(failMessage);
dialog.runModal();
}
}
syncSoundSettings();
}
Common::Error QueenEngine::run() {
initGraphics(GAME_SCREEN_WIDTH, GAME_SCREEN_HEIGHT, false);
_resource = new Resource();
_bam = new BamScene(this);
_bankMan = new BankManager(_resource);
_command = new Command(this);
_debugger = new Debugger(this);
_display = new Display(this, _system);
_graphics = new Graphics(this);
_grid = new Grid(this);
_input = new Input(_resource->getLanguage(), _system, this);
if (_resource->isDemo()) {
_logic = new LogicDemo(this);
} else if (_resource->isInterview()) {
_logic = new LogicInterview(this);
} else {
_logic = new LogicGame(this);
}
_sound = Sound::makeSoundInstance(_mixer, this, _resource->getCompression());
_walk = new Walk(this);
//_talkspeedScale = (MAX_TEXT_SPEED - MIN_TEXT_SPEED) / 255.0;
registerDefaultSettings();
// Setup mixer
syncSoundSettings();
_logic->start();
if (ConfMan.hasKey("save_slot") && canLoadOrSave()) {
loadGameState(ConfMan.getInt("save_slot"));
}
_lastSaveTime = _lastUpdateTime = _system->getMillis();
while (!shouldQuit()) {
if (_logic->newRoom() > 0) {
_logic->update();
_logic->oldRoom(_logic->currentRoom());
_logic->currentRoom(_logic->newRoom());
_logic->changeRoom();
_display->fullscreen(false);
if (_logic->currentRoom() == _logic->newRoom()) {
_logic->newRoom(0);
}
} else if (_logic->joeWalk() == JWM_EXECUTE) {
_logic->joeWalk(JWM_NORMAL);
_command->executeCurrentAction();
} else {
_logic->joeWalk(JWM_NORMAL);
update(true);
}
}
return Common::kNoError;
}
void CPlayGame::loadGame()
{
// This is for the new xml based savegame format since version 1.6.0
if(loadXMLGameState())
return;
// This is for legacy savegame state formats
loadGameState();
}
void MohawkEngine_Riven::loadGameStateAndDisplayError(int slot) {
assert(slot >= 0);
Common::Error loadError = loadGameState(slot);
if (loadError.getCode() != Common::kNoError) {
GUI::MessageDialog dialog(loadError.getDesc());
dialog.runModal();
}
}
Common::Error GlkEngine::loadGame() {
frefid_t ref = _streams->createByPrompt(fileusage_BinaryMode | fileusage_SavedGame,
filemode_Read, 0);
if (ref == nullptr)
return Common::kReadingFailed;
int slotNumber = ref->_slotNumber;
_streams->deleteRef(ref);
return loadGameState(slotNumber);
}
void KyraEngine_v1::loadGameStateCheck(int slot) {
if (loadGameState(slot) != Common::kNoError) {
const char *filename = getSavegameFilename(slot);
Common::String errorMessage = "Could not load savegame: '";
errorMessage += filename;
errorMessage += "'";
GUIErrorMessage(errorMessage);
error("%s", errorMessage.c_str());
}
}
bool SavesManager::loadGame() {
GUI::SaveLoadChooser *dialog = new GUI::SaveLoadChooser(_("Load game:"), _("Load"), false);
int slotNum = dialog->runModalWithCurrentTarget();
delete dialog;
if (slotNum != -1) {
loadGameState(slotNum);
g_vm->_interface->drawParty(true);
}
return slotNum != -1;
}
void KyraEngine_v1::loadGameStateCheck(int slot) {
// FIXME: Instead of throwing away the error returned by
// loadGameState, we should use it / augment it.
if (loadGameState(slot).getCode() != Common::kNoError) {
const char *filename = getSavegameFilename(slot);
Common::String errorMessage = "Could not load savegame: '";
errorMessage += filename;
errorMessage += "'";
GUIErrorMessage(errorMessage);
error("%s", errorMessage.c_str());
}
}
Common::Error DraciEngine::run() {
init();
setTotalPlayTime(0);
_game->init();
// Load game from specified slot, if any
if (ConfMan.hasKey("save_slot")) {
loadGameState(ConfMan.getInt("save_slot"));
}
_game->start();
return Common::kNoError;
}
void MohawkEngine_Riven::runLoadDialog() {
GUI::SaveLoadChooser slc(_("Load game:"), _("Load"));
slc.setSaveMode(false);
Common::String gameId = ConfMan.get("gameid");
const EnginePlugin *plugin = 0;
EngineMan.findGame(gameId, &plugin);
int slot = slc.runModal(plugin, ConfMan.getActiveDomainName());
if (slot >= 0)
loadGameState(slot);
slc.close();
}
void QueenEngine::update(bool checkPlayerInput) {
_debugger->onFrame();
_graphics->update(_logic->currentRoom());
_logic->update();
int frameDelay = (_lastUpdateTime + Input::DELAY_NORMAL - _system->getMillis());
if (frameDelay <= 0) {
frameDelay = 1;
}
_input->delay(frameDelay);
_lastUpdateTime = _system->getMillis();
if (!_resource->isInterview()) {
_display->palCustomScroll(_logic->currentRoom());
}
BobSlot *joe = _graphics->bob(0);
_display->update(joe->active, joe->x, joe->y);
_input->checkKeys();
if (_input->debugger()) {
_input->debuggerReset();
_debugger->attach();
}
if (canLoadOrSave()) {
if (_input->quickSave()) {
_input->quickSaveReset();
saveGameState(SLOT_QUICKSAVE, "Quicksave");
}
if (_input->quickLoad()) {
_input->quickLoadReset();
loadGameState(SLOT_QUICKSAVE);
}
if (shouldPerformAutoSave(_lastSaveTime)) {
saveGameState(SLOT_AUTOSAVE, "Autosave");
_lastSaveTime = _system->getMillis();
}
}
if (!_input->cutawayRunning()) {
if (checkPlayerInput) {
_command->updatePlayer();
}
if (_input->idleTime() >= Input::DELAY_SCREEN_BLANKER) {
_display->blankScreen();
}
}
_sound->updateMusic();
}
int AdlEngine_v2::o2_restore(ScriptEnv &e) {
OP_DEBUG_0("\tRESTORE_GAME()");
int slot = askForSlot(_strings_v2.restoreInsert);
if (slot < 0)
return -1;
loadGameState(slot);
_isRestoring = false;
_display->printString(_strings_v2.restoreReplace);
inputString();
_picOnScreen = 0;
_roomOnScreen = 0;
return 0;
}
Common::Error PinkEngine::init() {
debugC(10, kPinkDebugGeneral, "PinkEngine init");
initGraphics(640, 480);
Common::PEResources exeResources;
Common::String fileName = isPeril() ? "pptp.exe" : "hpp.exe";
if (!exeResources.loadFromEXE(fileName)) {
return Common::kNoGameDataFoundError;
}
_console = new Console(this);
_director = new Director();
initMenu(exeResources);
Common::String orbName;
Common::String broName;
if (isPeril()) {
orbName = "PPTP.ORB";
broName = "PPTP.BRO";
_bro = new BroFile;
} else {
orbName = "HPP.ORB";
}
if (!_orb.open(orbName) || (_bro && !_bro->open(broName) && _orb.getTimestamp() == _bro->getTimestamp()))
return Common::kNoGameDataFoundError;
if (!loadCursors(exeResources))
return Common::kNoGameDataFoundError;
setCursor(kLoadingCursor);
_orb.loadGame(this);
debugC(6, kPinkDebugGeneral, "Modules are loaded");
syncSoundSettings();
if (ConfMan.hasKey("save_slot"))
loadGameState(ConfMan.getInt("save_slot"));
else
initModule(_modules[0]->getName(), "", nullptr);
return Common::kNoError;
}
Common::Error BuriedEngine::runLoadDialog() {
GUI::SaveLoadChooser slc(_("Load game:"), _("Load"), false);
int slot = slc.runModalWithCurrentTarget();
Common::Error result;
if (slot >= 0) {
if (loadGameState(slot).getCode() == Common::kNoError)
result = Common::kNoError;
else
result = Common::kUnknownError;
} else {
result = Common::kUserCanceled;
}
return result;
}
Common::Error DMEngine::run() {
initConstants();
// scummvm/engine specific
initGraphics(320, 200, false);
_console = new Console(this);
_displayMan = new DisplayMan(this);
_dungeonMan = new DungeonMan(this);
_eventMan = new EventManager(this);
_menuMan = new MenuMan(this);
_championMan = new ChampionMan(this);
_objectMan = new ObjectMan(this);
_inventoryMan = new InventoryMan(this);
_textMan = new TextMan(this);
_moveSens = new MovesensMan(this);
_groupMan = new GroupMan(this);
_timeline = new Timeline(this);
_projexpl = new ProjExpl(this);
_dialog = new DialogMan(this);
_sound = SoundMan::getSoundMan(this, _gameVersion);
_displayMan->setUpScreens(320, 200);
initializeGame();
while (true) {
gameloop();
if (_engineShouldQuit)
return Common::kNoError;
if (_loadSaveSlotAtRuntime == -1)
endGame(_championMan->_partyDead);
else {
loadGameState(_loadSaveSlotAtRuntime);
_menuMan->drawEnabledMenus();
_displayMan->updateScreen();
_loadSaveSlotAtRuntime = -1;
}
}
return Common::kNoError;
}
void Engine::openMainMenuDialog() {
if (!_mainMenuDialog)
_mainMenuDialog = new MainMenuDialog(this);
setGameToLoadSlot(-1);
runDialog(*_mainMenuDialog);
// Load savegame after main menu execution
// (not from inside the menu loop to avoid
// mouse cursor glitches and simliar bugs,
// e.g. #2822778).
// FIXME: For now we just ignore the return
// value, which is quite bad since it could
// be a fatal loading error, which renders
// the engine unusable.
if (_saveSlotToLoad >= 0)
loadGameState(_saveSlotToLoad);
syncSoundSettings();
}
void MartianEngine::playGame() {
// Initialize Martian Memorandum game-specific objects
initObjects();
// Setup the game
setupGame();
configSelect();
if (_loadSaveSlot == -1) {
// Do introduction
doCredits();
if (shouldQuit())
return;
// Display Notes screen
doSpecial5(4);
if (shouldQuit())
return;
_screen->forceFadeOut();
}
do {
_restartFl = false;
_screen->clearScreen();
_screen->setPanel(0);
_screen->forceFadeOut();
_events->showCursor();
initVariables();
// If there's a pending savegame to load, load it
if (_loadSaveSlot != -1) {
loadGameState(_loadSaveSlot);
_loadSaveSlot = -1;
}
// Execute the room
_room->doRoom();
} while (_restartFl);
}
void Engine::processInput() {
if (sys->input.load) {
loadGameState(_stateSlot);
sys->input.load = false;
}
if (sys->input.save) {
saveGameState(_stateSlot, "quicksave");
sys->input.save = false;
}
if (sys->input.fastMode) {
vm._fastMode = !vm._fastMode;
sys->input.fastMode = false;
}
if (sys->input.stateSlot != 0) {
int8_t slot = _stateSlot + sys->input.stateSlot;
if (slot >= 0 && slot < MAX_SAVE_SLOTS) {
_stateSlot = slot;
debug(DBG_INFO, "Current game state slot is %d", _stateSlot);
}
sys->input.stateSlot = 0;
}
}
void CruiseEngine::mainLoop() {
//int32 t_start,t_left;
//uint32 t_end;
//int32 q=0; /* Dummy */
int16 mouseX, mouseY;
int16 mouseButton;
int enableUser = 0;
strcpy(nextOverlay, "");
strcpy(lastOverlay, "");
strcpy(cmdLine, "");
currentActiveMenu = -1;
autoMsg = -1;
linkedRelation = 0;
main21 = 0;
main22 = 0;
userWait = 0;
autoTrack = false;
initAllData();
playerDontAskQuit = 0;
int quitValue2 = 1;
int quitValue = 0;
if (ConfMan.hasKey("save_slot"))
loadGameState(ConfMan.getInt("save_slot"));
do {
// Handle frame delay
uint32 currentTick = g_system->getMillis();
if (!bFastMode) {
// Delay for the specified amount of time, but still respond to events
bool skipEvents = false;
do {
g_system->delayMillis(10);
currentTick = g_system->getMillis();
if (!skipEvents)
skipEvents = manageEvents();
if (playerDontAskQuit)
break;
_vm->getDebugger()->onFrame();
} while (currentTick < lastTick + _gameSpeed);
} else {
manageEvents();
if (currentTick >= (lastTickDebug + 10)) {
lastTickDebug = currentTick;
_vm->getDebugger()->onFrame();
}
}
if (playerDontAskQuit)
break;
lastTick = g_system->getMillis();
// Handle switchover in game speed after intro
if (!_speedFlag && canLoadGameStateCurrently()) {
_speedFlag = true;
_gameSpeed = GAME_FRAME_DELAY_2;
}
// Handle the next frame
// frames++;
// t_start=Osystem_GetTicks();
// readKeyboard();
bool isUserWait = userWait != 0;
playerDontAskQuit = processInput();
if (playerDontAskQuit)
break;
if (enableUser) {
userEnabled = 1;
enableUser = 0;
}
if (userDelay && !userWait) {
userDelay--;
continue;
}
if (isUserWait & !userWait) {
// User waiting has ended
changeScriptParamInList(-1, -1, &procHead, 9999, 0);
changeScriptParamInList(-1, -1, &relHead, 9999, 0);
// Disable any mouse click used to end the user wait
currentMouseButton = 0;
}
// FIXME: I suspect that the original game does multiple script executions between game frames; the bug with
// Raoul appearing when looking at the book is being there are 3 script iterations separation between the
// scene being changed to the book, and the Raoul actor being frozen/disabled. This loop is a hack to ensure
// that when a background changes, a few extra script executions are done
bool bgChanged;
int numIterations = 1;
while (numIterations-- > 0) {
bgChanged = backgroundChanged[masterScreen];
manageScripts(&relHead);
manageScripts(&procHead);
removeFinishedScripts(&relHead);
removeFinishedScripts(&procHead);
if (!bgChanged && backgroundChanged[masterScreen]) {
bgChanged = true;
numIterations += 2;
}
}
processAnimation();
if (remdo) {
// ASSERT(0);
/* main3 = 0;
* var24 = 0;
* var23 = 0;
*
* freeStuff2(); */
}
if (cmdLine[0]) {
ASSERT(0);
/* redrawStrings(0,&cmdLine,8);
waitForPlayerInput();
cmdLine = 0; */
}
if (displayOn) {
if (doFade)
PCFadeFlag = 0;
/*if (!PCFadeFlag)*/
mainDraw(userWait);
flipScreen();
if (userEnabled && !userWait && !autoTrack) {
if (currentActiveMenu == -1) {
static int16 oldMouseX = -1;
static int16 oldMouseY = -1;
getMouseStatus(&main10, &mouseX, &mouseButton, &mouseY);
if (mouseX != oldMouseX || mouseY != oldMouseY) {
int objectType;
int newCursor1;
int newCursor2;
oldMouseX = mouseX;
oldMouseY = mouseY;
objectType = findObject(mouseX, mouseY, &newCursor1, &newCursor2);
if (objectType == 9) {
changeCursor(CURSOR_EXIT);
} else if (objectType != -1) {
changeCursor(CURSOR_MAGNIFYING_GLASS);
} else {
changeCursor(CURSOR_WALK);
}
}
} else {
changeCursor(CURSOR_NORMAL);
}
} else {
changeCursor(CURSOR_NORMAL);
}
if (userWait == 1) {
// Waiting for press - original wait loop has been integrated into the
// main event loop
continue;
}
// wait for character to finish auto track
if (autoTrack) {
if (isAnimFinished(narratorOvl, narratorIdx, &actorHead, ATP_MOUSE)) {
if (autoMsg != -1) {
freezeCell(&cellHead, autoOvl, autoMsg, 5, -1, 9998, 0);
char* pText = getText(autoMsg, autoOvl);
if (strlen(pText))
userWait = 1;
}
changeScriptParamInList(-1, -1, &relHead, 9998, 0);
autoTrack = false;
enableUser = 1;
} else {
userEnabled = false;
}
} else if (autoMsg != -1) {
removeCell(&cellHead, autoOvl, autoMsg, 5, masterScreen);
autoMsg = -1;
}
} else {
// Keep ScummVM being responsive even when displayOn is false
g_system->updateScreen();
}
} while (!playerDontAskQuit && quitValue2 && quitValue != 7);
// Free data
removeAllScripts(&relHead);
removeAllScripts(&procHead);
resetActorPtr(&actorHead);
freeOverlayTable();
closeCnf();
closeBase();
resetFileEntryRange(0, NUM_FILE_ENTRIES);
freeObjectList(&cellHead);
freeBackgroundIncrustList(&backgroundIncrustHead);
}
void HeriswapGame::init(const uint8_t* in, int size) {
LOGI("HeriswapGame initialisation begins...");
CAMERA(camera)->clearColor = Color(0.49,0.59,0,1);
TRANSFORM(camera)->z = 0;
ScoreStorageProxy ssp;
//init database
LOGI("\t- Init database...");
gameThreadContext->storageAPI->init(gameThreadContext->assetAPI, "Heriswap");
gameThreadContext->storageAPI->setOption("sound", std::string(), "on");
gameThreadContext->storageAPI->setOption("gameCount", std::string(), "0");
gameThreadContext->storageAPI->createTable(&ssp);
SuccessManager *sm = new SuccessManager(gameThreadContext->gameCenterAPI);
datas = new PrivateData(this, gameThreadContext, sm);
datas->Setup();
theSoundSystem.mute = !datas->storageAPI->isOption("sound", "on");
theMusicSystem.toggleMute(theSoundSystem.mute);
datas->sky = theEntityManager.CreateEntityFromTemplate("general/sky");
SCROLLING(datas->sky)->images.push_back(HASH("ciel0", 0x89b9427));
SCROLLING(datas->sky)->images.push_back(HASH("ciel1", 0xd296102e));
SCROLLING(datas->sky)->images.push_back(HASH("ciel2", 0x22648ee8));
SCROLLING(datas->sky)->images.push_back(HASH("ciel3", 0x7f710b96));
SCROLLING(datas->sky)->displaySize = glm::vec2(TRANSFORM(datas->sky)->size.x * 1.01,
TRANSFORM(datas->sky)->size.y);
datas->faderHelper.init(camera);
sceneStateMachine.setup(gameThreadContext->assetAPI);
if (in && size) {
loadGameState(in, size);
SCROLLING(datas->sky)->show = true;
theBackgroundSystem.showAll();
} else {
sceneStateMachine.start(Scene::Logo);
}
if (gameThreadContext->gameCenterAPI) {
datas->gamecenterAPIHelper.init(gameThreadContext->gameCenterAPI, true, true, true, [this] {
if (sceneStateMachine.getCurrentState() == Scene::ModeMenu) {
int id = datas->mode * difficulty;
gameThreadContext->gameCenterAPI->openSpecificLeaderboard(id);
} else {
gameThreadContext->gameCenterAPI->openDashboard();
}
});
}
#if SAC_INGAME_EDITORS && SAC_DEBUG
HeriswapDebugConsole::init(this);
#endif
modeMenuIsInNameInput = false;
LOGI("HeriswapGame initialisation done.");
}
Common::Error TeenAgentEngine::run() {
Resources *res = Resources::instance();
if (!res->loadArchives(_gameDescription))
return Common::kUnknownError;
Common::EventManager *_event = _system->getEventManager();
initGraphics(320, 200, false);
scene = new Scene;
inventory = new Inventory;
console = new Console(this);
scene->init(this, _system);
inventory->init(this);
init();
CursorMan.pushCursor(res->dseg.ptr(0x00da), 8, 12, 0, 0, 1);
syncSoundSettings();
_mixer->playStream(Audio::Mixer::kMusicSoundType, &_musicHandle, music, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, false);
setMusic(1);
music->start();
int load_slot = Common::ConfigManager::instance().getInt("save_slot");
if (load_slot >= 0) {
loadGameState(load_slot);
} else {
if (!showCDLogo())
return Common::kNoError;
if (!showLogo())
return Common::kNoError;
if (!showMetropolis())
return Common::kNoError;
scene->intro = true;
scene_busy = true;
processCallback(0x24c);
}
CursorMan.showMouse(true);
uint32 game_timer = 0;
uint32 mark_timer = 0;
Common::Event event;
Common::Point mouse;
uint32 timer = _system->getMillis();
do {
Object *current_object = scene->findObject(mouse);
while (_event->pollEvent(event)) {
if (event.type == Common::EVENT_RTL) {
deinit();
return Common::kNoError;
}
if ((!scene_busy && inventory->processEvent(event)) || scene->processEvent(event))
continue;
//debug(0, "event");
switch (event.type) {
case Common::EVENT_KEYDOWN:
if ((event.kbd.hasFlags(Common::KBD_CTRL) && event.kbd.keycode == Common::KEYCODE_d) ||
event.kbd.ascii == '~' || event.kbd.ascii == '#') {
console->attach();
} else if (event.kbd.hasFlags(0) && event.kbd.keycode == Common::KEYCODE_F5) {
openMainMenuDialog();
} if (event.kbd.hasFlags(Common::KBD_CTRL) && event.kbd.keycode == Common::KEYCODE_f) {
_mark_delay = _mark_delay == 80? 40: 80;
debug(0, "mark_delay = %u", _mark_delay);
}
break;
case Common::EVENT_LBUTTONDOWN:
if (scene->getId() < 0)
break;
examine(event.mouse, current_object);
break;
case Common::EVENT_RBUTTONDOWN:
//if (current_object)
// debug(0, "%d, %s", current_object->id, current_object->name.c_str());
if (scene->getId() < 0)
break;
if (current_object == NULL)
break;
if (res->dseg.get_byte(0) == 3 && current_object->id == 1) {
processCallback(0x5189); //boo!
break;
}
if (res->dseg.get_byte(0) == 4 && current_object->id == 5) {
processCallback(0x99e0); //getting an anchor
break;
}
use(current_object);
break;
case Common::EVENT_MOUSEMOVE:
mouse = event.mouse;
break;
default:
;
}
}
//game delays: slow 16, normal 11, fast 5, crazy 1
//mark delays: 4 * (3 - hero_speed), normal == 1
//game delays in 1/100th of seconds
uint32 new_timer = _system->getMillis();
uint32 delta = new_timer - timer;
timer = new_timer;
bool tick_game = game_timer <= delta;
if (tick_game)
game_timer = _game_delay - ((delta - game_timer) % _game_delay);
else
game_timer -= delta;
bool tick_mark = mark_timer <= delta;
if (tick_mark)
mark_timer = _mark_delay - ((delta - mark_timer) % _mark_delay);
else
mark_timer -= delta;
if (tick_game || tick_mark) {
bool b = scene->render(tick_game, tick_mark, delta);
if (!inventory->active() && !b && action != kActionNone) {
processObject();
action = kActionNone;
dst_object = NULL;
}
scene_busy = b;
}
_system->showMouse(scene->getMessage().empty() && !scene_busy);
bool busy = inventory->active() || scene_busy;
Graphics::Surface *surface = _system->lockScreen();
if (!busy) {
InventoryObject *selected_object = inventory->selectedObject();
if (current_object || selected_object) {
Common::String name;
if (selected_object) {
name += selected_object->name;
name += " & ";
}
if (current_object)
name += current_object->name;
uint w = res->font7.render(NULL, 0, 0, name, 0xd1);
res->font7.render(surface, (320 - w) / 2, 180, name, 0xd1, true);
#if 0
if (current_object) {
current_object->rect.render(surface, 0x80);
current_object->actor_rect.render(surface, 0x81);
}
#endif
}
}
inventory->render(surface, tick_game? 1: 0);
_system->unlockScreen();
_system->updateScreen();
console->onFrame();
uint32 next_tick = MIN(game_timer, mark_timer);
if (next_tick > 0) {
_system->delayMillis(next_tick > 40? 40: next_tick);
}
} while (!shouldQuit());
deinit();
return Common::kNoError;
}
Common::Error FullpipeEngine::run() {
const Graphics::PixelFormat format(4, 8, 8, 8, 8, 24, 16, 8, 0);
// Initialize backend
initGraphics(800, 600, true, &format);
_backgroundSurface.create(800, 600, format);
_origFormat = new Graphics::PixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0);
_console = new Console(this);
initialize();
_isSaveAllowed = false;
int scene = 0;
if (ConfMan.hasKey("boot_param"))
scene = convertScene(ConfMan.getInt("boot_param"));
if (ConfMan.hasKey("save_slot"))
scene = -1;
if (!loadGam("fullpipe.gam", scene))
return Common::kNoGameDataFoundError;
if (ConfMan.hasKey("save_slot")) {
loadGameState(ConfMan.getInt("save_slot"));
}
#if 0
loadAllScenes();
#endif
_gameContinue = true;
int time1 = g_fp->_system->getMillis();
// Center mouse
_system->warpMouse(400, 300);
while (_gameContinue) {
updateEvents();
int time2 = g_fp->_system->getMillis();
// 30fps
if (time2 - time1 >= 33 || !_normalSpeed) {
time1 = time2;
updateScreen();
}
if (_needRestart) {
if (_modalObject) {
delete _modalObject;
_modalObject = 0;
}
freeGameLoader();
_currentScene = 0;
_updateTicks = 0;
loadGam("fullpipe.gam");
_needRestart = false;
}
_system->delayMillis(5);
_system->updateScreen();
}
freeGameLoader();
cleanup();
return Common::kNoError;
}
Common::Error StarkEngine::run() {
_console = new Console();
_gfx = Gfx::Driver::create();
// Get the screen prepared
_gfx->init();
_frameLimiter = new Gfx::FrameLimiter(_system, ConfMan.getInt("engine_speed"));
_archiveLoader = new ArchiveLoader();
_stateProvider = new StateProvider();
_global = new Global();
_resourceProvider = new ResourceProvider(_archiveLoader, _stateProvider, _global);
_staticProvider = new StaticProvider(_archiveLoader);
_randomSource = new Common::RandomSource("stark");
_fontProvider = new FontProvider();
_scene = new Scene(_gfx);
_dialogPlayer = new DialogPlayer();
_diary = new Diary();
_gameInterface = new GameInterface();
_userInterface = new UserInterface(_gfx);
_settings = new Settings(_mixer, _gameDescription);
_gameChapter = new GameChapter();
_gameMessage = new GameMessage();
// Setup the public services
StarkServices &services = StarkServices::instance();
services.archiveLoader = _archiveLoader;
services.dialogPlayer = _dialogPlayer;
services.diary = _diary;
services.gfx = _gfx;
services.global = _global;
services.resourceProvider = _resourceProvider;
services.randomSource = _randomSource;
services.scene = _scene;
services.staticProvider = _staticProvider;
services.gameInterface = _gameInterface;
services.userInterface = _userInterface;
services.fontProvider = _fontProvider;
services.settings = _settings;
services.gameChapter = _gameChapter;
services.gameMessage = _gameMessage;
// Load global resources
_staticProvider->init();
_fontProvider->initFonts();
// Initialize the UI
_userInterface->init();
// Load through ResidualVM launcher
if (ConfMan.hasKey("save_slot")) {
loadGameState(ConfMan.getInt("save_slot"));
}
// Start running
mainLoop();
_staticProvider->shutdown();
_resourceProvider->shutdown();
return Common::kNoError;
}
Common::Error GrimEngine::run() {
// Try to see if we have the EMI Mac installer present
// Currently, this requires the data fork to be standalone
if (getGameType() == GType_MONKEY4) {
if (SearchMan.hasFile("Monkey Island 4 Installer")) {
StuffItArchive *archive = new StuffItArchive();
if (archive->open("Monkey Island 4 Installer"))
SearchMan.add("Monkey Island 4 Installer", archive, 0, true);
else
delete archive;
}
if (SearchMan.hasFile("EFMI Installer")) {
StuffItArchive *archive = new StuffItArchive();
if (archive->open("EFMI Installer"))
SearchMan.add("EFMI Installer", archive, 0, true);
else
delete archive;
}
}
ConfMan.registerDefault("check_gamedata", true);
if (ConfMan.getBool("check_gamedata")) {
MD5CheckDialog d;
if (!d.runModal()) {
Common::String confirmString = Common::String::format(_(
"ResidualVM found some problems with your game data files.\n"
"Running ResidualVM nevertheless may cause game bugs or even crashes.\n"
"Do you still want to run %s?"),
GType_MONKEY4 == getGameType() ? _("Escape From Monkey Island") : _("Grim Fandango")
);
GUI::MessageDialog msg(confirmString, _("Yes"), _("No"));
if (!msg.runModal()) {
return Common::kUserCanceled;
}
}
ConfMan.setBool("check_gamedata", false);
ConfMan.flushToDisk();
}
g_resourceloader = new ResourceLoader();
bool demo = getGameFlags() & ADGF_DEMO;
if (getGameType() == GType_GRIM)
g_movie = CreateSmushPlayer(demo);
else if (getGameType() == GType_MONKEY4) {
if (_gamePlatform == Common::kPlatformPS2)
g_movie = CreateMpegPlayer();
else
g_movie = CreateBinkPlayer(demo);
}
if (getGameType() == GType_GRIM) {
g_imuse = new Imuse(20, demo);
g_emiSound = nullptr;
} else if (getGameType() == GType_MONKEY4) {
g_emiSound = new EMISound(20);
g_imuse = nullptr;
}
g_sound = new SoundPlayer();
bool fullscreen = ConfMan.getBool("fullscreen");
g_driver = createRenderer(640, 480, fullscreen);
if (getGameType() == GType_MONKEY4 && SearchMan.hasFile("AMWI.m4b")) {
// Play EMI Mac Aspyr logo
playAspyrLogo();
}
Bitmap *splash_bm = nullptr;
if (!(_gameFlags & ADGF_DEMO) && getGameType() == GType_GRIM)
splash_bm = Bitmap::create("splash.bm");
else if ((_gameFlags & ADGF_DEMO) && getGameType() == GType_MONKEY4)
splash_bm = Bitmap::create("splash.til");
else if (getGamePlatform() == Common::kPlatformPS2 && getGameType() == GType_MONKEY4)
splash_bm = Bitmap::create("load.tga");
g_driver->clearScreen();
if (splash_bm != nullptr)
splash_bm->draw();
// This flipBuffer() may make the OpenGL renderer show garbage instead of the splash,
// while the TinyGL renderer needs it.
if (_softRenderer)
g_driver->flipBuffer();
LuaBase *lua = createLua();
lua->registerOpcodes();
lua->registerLua();
// One version of the demo doesn't set the demo flag in scripts.
if (getGameType() == GType_GRIM && _gameFlags & ADGF_DEMO) {
lua->forceDemo();
}
//Initialize Localizer first. In system-script are already localizeable Strings
g_localizer = new Localizer();
lua->loadSystemScript();
lua->boot();
_savegameLoadRequest = false;
_savegameSaveRequest = false;
// Load game from specified slot, if any
if (ConfMan.hasKey("save_slot")) {
loadGameState(ConfMan.getInt("save_slot"));
}
g_grim->setMode(NormalMode);
delete splash_bm;
g_grim->mainLoop();
return Common::kNoError;
}
void ToucheEngine::handleMenuAction(void *menu, int actionId) {
MenuData *menuData = (MenuData *)menu;
switch (actionId) {
case kActionLoadMenu:
menuData->mode = kMenuLoadStateMode;
break;
case kActionSaveMenu:
_system->setFeatureState(OSystem::kFeatureVirtualKeyboard, true);
menuData->mode = kMenuSaveStateMode;
break;
case kActionRestartGame:
restart();
menuData->quit = true;
break;
case kActionPlayGame:
menuData->quit = true;
break;
case kActionQuitGame:
quitGame();
menuData->quit = true;
break;
case kActionTextOnly:
_talkTextMode = kTalkModeTextOnly;
break;
case kActionVoiceOnly:
_talkTextMode = kTalkModeVoiceOnly;
break;
case kActionTextAndVoice:
_talkTextMode = kTalkModeVoiceAndText;
break;
case kActionLowerVolume:
adjustMusicVolume(-16);
break;
case kActionUpperVolume:
adjustMusicVolume(+16);
break;
case kActionScrollUpSaves:
--_saveLoadCurrentPage;
if (_saveLoadCurrentPage < 0) {
_saveLoadCurrentPage = 9;
}
_saveLoadCurrentSlot = _saveLoadCurrentPage * 10 + (_saveLoadCurrentSlot % 10);
break;
case kActionScrollDownSaves:
++_saveLoadCurrentPage;
if (_saveLoadCurrentPage > 9) {
_saveLoadCurrentPage = 0;
}
_saveLoadCurrentSlot = _saveLoadCurrentPage * 10 + (_saveLoadCurrentSlot % 10);
break;
case kActionPerformSaveLoad:
if (menuData->mode == kMenuLoadStateMode) {
if (loadGameState(_saveLoadCurrentSlot).getCode() == Common::kNoError) {
menuData->quit = true;
}
} else if (menuData->mode == kMenuSaveStateMode) {
_system->setFeatureState(OSystem::kFeatureVirtualKeyboard, false);
const char *description = menuData->saveLoadDescriptionsTable[_saveLoadCurrentSlot];
if (strlen(description) > 0) {
if (saveGameState(_saveLoadCurrentSlot, description).getCode() == Common::kNoError) {
menuData->quit = true;
}
}
}
break;
case kActionCancelSaveLoad:
_system->setFeatureState(OSystem::kFeatureVirtualKeyboard, false);
menuData->mode = kMenuSettingsMode;
break;
default:
if (actionId >= kActionGameState1 && actionId <= kActionGameState10) {
_saveLoadCurrentSlot = _saveLoadCurrentPage * 10 + (actionId - kActionGameState1);
}
break;
}
}
Common::Error TinselEngine::run() {
// Initialize backend
if (getGameID() == GID_DW2) {
#ifndef DW2_EXACT_SIZE
initGraphics(640, 480, true);
#else
initGraphics(640, 432, true);
#endif
_screenSurface.create(640, 432, 1);
} else {
initGraphics(320, 200, false);
_screenSurface.create(320, 200, 1);
}
g_system->getEventManager()->registerRandomSource(_random, "tinsel");
_console = new Console();
_scheduler = new Scheduler();
InitSysVars();
// init memory manager
MemoryInit();
// load user configuration
ReadConfig();
#if 1
// FIXME: The following is taken from RestartGame().
// It may have to be adjusted a bit
CountOut = 1;
RebootCursor();
RebootDeadTags();
RebootMovers();
resetUserEventTime();
RebootTimers();
RebootScalingReels();
DelayedScene.scene = HookScene.scene = 0;
#endif
// Load in text strings
ChangeLanguage(g_language);
// Init palette and object managers, scheduler, keyboard and mouse
RestartDrivers();
// load in graphics info
SetupHandleTable();
// Actors, globals and inventory icons
LoadBasicChunks();
// Continuous game processes
CreateConstProcesses();
// allow game to run in the background
//RestartBackgroundProcess(); // FIXME: is this still needed?
//dumpMusic(); // dumps all of the game's music in external XMIDI files
// Load game from specified slot, if any
//
// TODO: We might want to think about properly taking care of possible
// errors when loading the save state.
if (ConfMan.hasKey("save_slot")) {
if (loadGameState(ConfMan.getInt("save_slot")) == Common::kNoError)
loadingFromGMM = true;
}
// Foreground loop
uint32 timerVal = 0;
while (!shouldQuit()) {
assert(_console);
if (_console->isAttached())
_console->onFrame();
// Check for time to do next game cycle
if ((g_system->getMillis() > timerVal + GAME_FRAME_DELAY)) {
timerVal = g_system->getMillis();
AudioCD.updateCD();
NextGameCycle();
}
if (bRestart) {
RestartGame();
bRestart = false;
bHasRestarted = true; // Set restarted flag
}
// Save/Restore scene file transfers
ProcessSRQueue();
// Handle any playing movie
FettleBMV();
#ifdef DEBUG
if (bFast)
continue; // run flat-out
#endif
// Loop processing events while there are any pending
while (pollEvent())
;
DoCdChange();
if (MoviePlaying() && NextMovieTime())
g_system->delayMillis(MAX<int>(NextMovieTime() - g_system->getMillis() + MovieAudioLag(), 0));
else
g_system->delayMillis(10);
}
// Write configuration
WriteConfig();
return Common::kNoError;
}
Common::Error ToltecsEngine::run() {
initGraphics(640, 400, true);
_isSaveAllowed = true;
_counter01 = 0;
_counter02 = 0;
_movieSceneFlag = false;
_flag01 = 0;
_saveLoadRequested = 0;
_cameraX = 0;
_cameraY = 0;
_newCameraX = 0;
_newCameraY = 0;
_cameraHeight = 0;
_guiHeight = 26;
_sceneWidth = 0;
_sceneHeight = 0;
_doSpeech = true;
_doText = true;
_walkSpeedY = 5;
_walkSpeedX = 1;
_mouseX = 0;
_mouseY = 0;
_mouseDblClickTicks = 60;
_mouseWaitForRelease = false;
_mouseButton = 0;
_mouseDisabled = 0;
_leftButtonDown = false;
_rightButtonDown = false;
_arc = new ArchiveReader();
_arc->openArchive("WESTERN");
_res = new ResourceCache(this);
_screen = new Screen(this);
_script = new ScriptInterpreter(this);
_anim = new AnimationPlayer(this);
_palette = new Palette(this);
_segmap = new SegmentMap(this);
_moviePlayer = new MoviePlayer(this);
_music = new Music(_arc);
_menuSystem = new MenuSystem(this);
_sound = new Sound(this);
_console = new Console(this);
_cfgText = ConfMan.getBool("subtitles");
_cfgVoices = !ConfMan.getBool("speech_mute");
bool mute = false;
if (ConfMan.hasKey("mute"))
mute = ConfMan.getBool("mute");
_mixer->setVolumeForSoundType(Audio::Mixer::kSpeechSoundType, mute ? 0 : ConfMan.getInt("speech_volume"));
_mixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, mute ? 0 : ConfMan.getInt("music_volume"));
_mixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, mute ? 0 : ConfMan.getInt("sfx_volume"));
syncSoundSettings();
CursorMan.showMouse(true);
setupSysStrings();
#if 0
// Menu test
_screen->registerFont(0, 0x0D);
_screen->registerFont(1, 0x0E);
_screen->loadMouseCursor(12);
_palette->loadAddPalette(9, 224);
_palette->setDeltaPalette(_palette->getMainPalette(), 7, 0, 31, 224);
_screen->finishTalkTextItems();
_menuSystem->run();
/*
while (1) {
//updateInput();
_menuSystem->update();
updateScreen();
}
*/
return Common::kNoError;
#endif
// Start main game loop
setTotalPlayTime(0);
_script->loadScript(0, 0);
_script->setMainScript(0);
if (ConfMan.hasKey("save_slot")) {
int saveSlot = ConfMan.getInt("save_slot");
if (saveSlot >= 0 && saveSlot <= 99) {
_screen->loadMouseCursor(12);
loadGameState(saveSlot);
}
}
_script->runScript();
_music->stopSequence();
_sound->stopAll();
delete _console;
delete _arc;
delete _res;
delete _screen;
delete _script;
delete _anim;
delete _palette;
delete _segmap;
delete _music;
delete _moviePlayer;
delete _menuSystem;
delete _sound;
return Common::kNoError;
}
Common::Error NeverhoodEngine::run() {
initGraphics(640, 480, true);
const Common::FSNode gameDataDir(ConfMan.get("path"));
SearchMan.addSubDirectoryMatching(gameDataDir, "data");
_isSaveAllowed = false;
_mouseX = 0;
_mouseY = 0;
_gameState.sceneNum = 0;
_gameState.which = 0;
_staticData = new StaticData();
_staticData->load("neverhood.dat");
_gameVars = new GameVars();
_screen = new Screen(this);
_res = new ResourceMan();
_console = new Console(this);
if (isDemo()) {
_res->addArchive("a.blb");
_res->addArchive("nevdemo.blb");
} else {
_res->addArchive("a.blb");
_res->addArchive("c.blb");
_res->addArchive("hd.blb");
_res->addArchive("i.blb");
_res->addArchive("m.blb");
_res->addArchive("s.blb");
_res->addArchive("t.blb");
}
CursorMan.showMouse(false);
_soundMan = new SoundMan(this);
_audioResourceMan = new AudioResourceMan(this);
_gameModule = new GameModule(this);
_isSaveAllowed = true;
_updateSound = true;
_enableMusic = !_mixer->isSoundTypeMuted(Audio::Mixer::kMusicSoundType);
if (isDemo()) {
// Adjust this navigation list for the demo version
NavigationList *navigationList = _staticData->getNavigationList(0x004B67E8);
(*navigationList)[0].middleSmackerFileHash = 0;
(*navigationList)[0].middleFlag = 1;
(*navigationList)[2].middleSmackerFileHash = 0;
(*navigationList)[2].middleFlag = 1;
(*navigationList)[4].middleSmackerFileHash = 0;
(*navigationList)[4].middleFlag = 1;
(*navigationList)[5].middleSmackerFileHash = 0;
(*navigationList)[5].middleFlag = 1;
}
if (ConfMan.hasKey("save_slot")) {
if (loadGameState(ConfMan.getInt("save_slot")).getCode() != Common::kNoError)
_gameModule->startup();
} else
_gameModule->startup();
mainLoop();
delete _gameModule;
delete _soundMan;
delete _audioResourceMan;
delete _console;
delete _res;
delete _screen;
delete _gameVars;
delete _staticData;
return Common::kNoError;
}
////
// Process Routine
////
void CPlayGameVorticon::process()
{
// Check for fading processes if necessary
if(g_pGfxEngine->Palette.in_progress())
g_pGfxEngine->Palette.applyFade();
if(mp_HighScores) // Are we requesting Highscores
{
mp_HighScores->process();
// Blit the background
g_pVideoDriver->blitScrollSurface();
if(mp_HighScores->destroyed())
{
SAFE_DELETE(mp_HighScores);
m_endgame = true;
}
}
else // No, we are in the middle of the game
{
if(!m_paused && m_MessageBoxes.empty() && !mp_Menu) // Game is not paused, no messages have to be shown and no menu is open
{
if (!mp_Finale) // Hasn't the game yet been finished?
{
// Perform AIs
mp_ObjectAI->process();
/// The following functions must be worldmap dependent
if( m_Level == WORLD_MAP_LEVEL_VORTICON )
processOnWorldMap();
else
processInLevel();
// Does one of the players need to pause the game?
for( int i=0 ; i<m_NumPlayers ; i++ )
{
// Did he open the status screen?
if(m_Player[i].m_showStatusScreen)
m_paused = true; // this is processed in processPauseDialogs!
if(!m_Player[0].pdie)
m_Player[0].processCamera();
}
}
else // In this case the Game has been finished, goto to the cutscenes
{
mp_Finale->process();
if(mp_Finale->getHasFinished())
{
SAFE_DELETE(mp_Finale);
if(!m_gameover)
{
mp_HighScores = new CHighScores(m_Episode, m_Gamepath, true);
collectHighScoreInfo();
}
}
m_Player[0].processEvents();
}
}
// Draw all the Stuff here!
drawAllElements();
if( m_Level == WORLD_MAP_LEVEL_VORTICON && m_showKeensLeft )
showKeensLeft();
// Check if we are in gameover mode. If yes, than show the bitmaps and block the FKeys().
// Only confirmation button is allowes
if(m_gameover && !mp_Finale) // game over mode
{
if(mp_gameoverbmp != NULL)
{
mp_gameoverbmp->process();
if( g_pInput->getPressedAnyCommand() )
{
mp_HighScores = new CHighScores(m_Episode, m_Gamepath, true);
collectHighScoreInfo();
}
}
else // Bitmap must first be created
{
CBitmap *pBitmap = g_pGfxEngine->getBitmap("GAMEOVER");
g_pSound->playSound(SOUND_GAME_OVER, PLAY_NOW);
mp_gameoverbmp = new CEGABitmap(&m_Map , g_pVideoDriver->getBlitSurface(), pBitmap);
mp_gameoverbmp->setScrPos( 160-(pBitmap->getWidth()/2), 100-(pBitmap->getHeight()/2) );
}
}
else // No game over
{
// Handle special functional keys for paused game, F1 Help, god mode, all items, etc.
if(!mp_Menu)
handleFKeys();
}
//////////////////////////////////////////
//// Menu Code... processed if opened
//////////////////////////////////////////
// If the menu is open process it!
if(mp_Menu)
{
if( mp_Menu->mustClose() || mp_Menu->getExitEvent() ||
mp_Menu->mustEndGame() || mp_Menu->mustStartGame() )
{
if( mp_Menu->getExitEvent() )
m_exitgame = true;
else if( mp_Menu->mustEndGame() )
m_endgame = true;
else if( mp_Menu->mustStartGame() )
{
m_NumPlayers = mp_Menu->getNumPlayers();
m_Difficulty = mp_Menu->getDifficulty();
m_startgame = true;
}
mp_Menu->cleanup();
SAFE_DELETE(mp_Menu);
m_hideobjects = false;
}
else
{
mp_Menu->processSpecific();
if(m_restartVideo) // Happens when in Game resolution was changed!
{
mp_Menu->cleanup();
SAFE_DELETE(mp_Menu);
SDL_Rect gamerect = g_pVideoDriver->getGameResolution();
m_Map.m_maxscrollx = (m_Map.m_width<<4) - gamerect.w - 36;
m_Map.m_maxscrolly = (m_Map.m_height<<4) - gamerect.h - 36;
m_Map.drawAll();
m_restartVideo = false;
}
// Does the player want to load/save a game?
if(m_SavedGame.getCommand() == CSavedGame::SAVE)
saveGameState();
else if(m_SavedGame.getCommand() == CSavedGame::LOAD)
loadGameState();
}
}
// Open the Main Menu if ESC Key pressed and mp_Menu not opened. Prevent the menu if the player is not solid.
else if( !mp_Finale && g_pInput->getPressedCommand(IC_QUIT) && ( m_Player[0].solid || m_Player[0].godmode ) )
{ // Open the menu
mp_Menu = new CMenuVorticon( ACTIVE, m_Map, m_SavedGame, m_restartVideo, m_hideobjects );
}
if (g_pVideoDriver->getVidConfig().showfps)
{
SDL_Surface *sfc = g_pVideoDriver->mp_VideoEngine->getBlitSurface();
std::string tempbuf;
#ifdef DEBUG
tempbuf = "FPS: " + itoa(g_pTimer->getFramesPerSec()) +
"; x = " + itoa(m_Player[0].getXPosition()) + " ; y = " + itoa(m_Player[0].getYPosition());
#else
tempbuf = "FPS: " + itoa(g_pTimer->getFramesPerSec());
#endif
g_pGfxEngine->getFont(0).drawFont(sfc,tempbuf,320-(tempbuf.size()<<3)-1, true);
}
}
}