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();
}
Common::Error GlkEngine::saveGame() {
frefid_t ref = _streams->createByPrompt(fileusage_BinaryMode | fileusage_SavedGame,
filemode_Write, 0);
if (ref == nullptr)
return Common::kWritingFailed;
int slot = ref->_slotNumber;
Common::String desc = ref->_description;
_streams->deleteRef(ref);
return saveGameState(slot, desc);
}
int AdlEngine_v2::o2_save(ScriptEnv &e) {
OP_DEBUG_0("\tSAVE_GAME()");
int slot = askForSlot(_strings_v2.saveInsert);
if (slot < 0)
return -1;
saveGameState(slot, "");
_display->printString(_strings_v2.saveReplace);
inputString();
return 0;
}
Common::Error BuriedEngine::runSaveDialog() {
GUI::SaveLoadChooser slc(_("Save game:"), _("Save"), true);
int slot = slc.runModalWithCurrentTarget();
Common::Error result;
if (slot >= 0) {
if (saveGameState(slot, slc.getResultString()).getCode() == Common::kNoError)
result = Common::kNoError;
else
result = Common::kUnknownError;
} else {
result = Common::kUserCanceled;
}
return result;
}
bool SavesManager::saveGame() {
Map &map = *g_vm->_map;
if (map.mazeData()._mazeFlags & RESTRICTION_SAVE) {
ErrorScroll::show(g_vm, Res.SAVE_OFF_LIMITS, WT_NONFREEZED_WAIT);
return false;
} else if (!g_vm->canSaveGameStateCurrently()) {
return false;
} else {
GUI::SaveLoadChooser *dialog = new GUI::SaveLoadChooser(_("Save game:"), _("Save"), true);
int slotNum = dialog->runModalWithCurrentTarget();
Common::String saveName = dialog->getResultString();
delete dialog;
if (slotNum != -1)
saveGameState(slotNum, saveName);
return slotNum != -1;
}
}
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;
}
}
////
// 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);
}
}
}
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;
}
}
int KyraEngine_MR::o3_makeSecondChanceSave(EMCState *script) {
debugC(3, kDebugLevelScriptFuncs, "KyraEngine_MR::o3_makeSecondChanceSave(%p) ()", (const void *)script);
saveGameState(999, "Autosave", 0);
return 0;
}
void BbvsEngine::writeContinueSavegame() {
if (_hasSnapshot) {
saveGameState(0, "Continue");
}
}
Common::Error ComposerEngine::run() {
Common::Event event;
_vars.resize(1000);
for (uint i = 0; i < _vars.size(); i++)
_vars[i] = 0;
_queuedScripts.resize(10);
for (uint i = 0; i < _queuedScripts.size(); i++) {
_queuedScripts[i]._count = 0;
_queuedScripts[i]._scriptId = 0;
}
if (!_bookIni.loadFromFile("book.ini")) {
_directoriesToStrip = 0;
if (!_bookIni.loadFromFile("programs/book.ini")) {
// mac version?
if (!_bookIni.loadFromFile("Darby the Dragon.ini"))
if (!_bookIni.loadFromFile("Gregory.ini"))
error("failed to find book.ini");
}
}
uint width = 640;
if (_bookIni.hasKey("Width", "Common"))
width = atoi(getStringFromConfig("Common", "Width").c_str());
uint height = 480;
if (_bookIni.hasKey("Height", "Common"))
height = atoi(getStringFromConfig("Common", "Height").c_str());
initGraphics(width, height);
_screen.create(width, height, Graphics::PixelFormat::createFormatCLUT8());
Graphics::Cursor *cursor = Graphics::makeDefaultWinCursor();
CursorMan.replaceCursor(cursor->getSurface(), cursor->getWidth(), cursor->getHeight(), cursor->getHotspotX(),
cursor->getHotspotY(), cursor->getKeyColor());
CursorMan.replaceCursorPalette(cursor->getPalette(), cursor->getPaletteStartIndex(), cursor->getPaletteCount());
delete cursor;
_console = new Console(this);
loadLibrary(0);
uint fps = atoi(getStringFromConfig("Common", "FPS").c_str());
uint frameTime = 125; // Default to 125ms (1000/8)
if (fps != 0)
frameTime = 1000 / fps;
else
warning("FPS in book.ini is zero. Defaulting to 8...");
uint32 lastDrawTime = 0;
_lastSaveTime = _system->getMillis();
bool loadFromLauncher = ConfMan.hasKey("save_slot");
while (!shouldQuit()) {
for (uint i = 0; i < _pendingPageChanges.size(); i++) {
if (_pendingPageChanges[i]._remove)
unloadLibrary(_pendingPageChanges[i]._pageId);
else
loadLibrary(_pendingPageChanges[i]._pageId);
lastDrawTime = 0;
}
_pendingPageChanges.clear();
uint32 thisTime = _system->getMillis();
// maintain our own internal timing, since otherwise we get
// confused when starved of CPU (for example when the user
// is dragging the scummvm window around)
if (thisTime > _lastTime + frameTime)
_currentTime += frameTime;
else
_currentTime += thisTime - _lastTime;
_lastTime = thisTime;
for (uint i = 0; i < _queuedScripts.size(); i++) {
QueuedScript &script = _queuedScripts[i];
if (!script._count)
continue;
if (script._baseTime + script._duration > _currentTime)
continue;
if (script._count != 0xffffffff)
script._count--;
script._baseTime = _currentTime;
runScript(script._scriptId, i, 0, 0);
}
if (lastDrawTime + frameTime <= thisTime) {
// catch up if we're more than 2 frames behind
if (lastDrawTime + (frameTime * 2) <= thisTime)
lastDrawTime = thisTime;
else
lastDrawTime += frameTime;
tickOldScripts();
redraw();
processAnimFrame();
} else if (_needsUpdate) {
redraw();
}
if (loadFromLauncher) {
loadGameState(ConfMan.getInt("save_slot"));
loadFromLauncher = false;
}
if (shouldPerformAutoSave(_lastSaveTime))
saveGameState(0, "Autosave");
while (_eventMan->pollEvent(event)) {
switch (event.type) {
case Common::EVENT_LBUTTONDOWN:
onMouseDown(event.mouse);
break;
case Common::EVENT_LBUTTONUP:
break;
case Common::EVENT_RBUTTONDOWN:
break;
case Common::EVENT_MOUSEMOVE:
onMouseMove(event.mouse);
break;
case Common::EVENT_KEYDOWN:
switch (event.kbd.keycode) {
case Common::KEYCODE_d:
if (event.kbd.hasFlags(Common::KBD_CTRL)) {
// Start the debugger
getDebugger()->attach();
getDebugger()->onFrame();
}
break;
case Common::KEYCODE_q:
if (event.kbd.hasFlags(Common::KBD_CTRL))
quitGame();
break;
default:
break;
}
onKeyDown(event.kbd.keycode);
break;
default:
break;
}
}
_system->delayMillis(20);
}
_screen.free();
return Common::kNoError;
}
