state.h

/* 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef SCI_ENGINE_STATE_H
#define SCI_ENGINE_STATE_H
 
#include "common/scummsys.h"
#include "common/array.h"
#include "common/serializer.h"
#include "common/str-array.h"
 
namespace Common {
class SeekableReadStream;
class WriteStream;
}
 
#include "sci/sci.h"
#include "sci/engine/file.h"
#include "sci/engine/seg_manager.h"
 
#include "sci/parser/vocabulary.h"
 
#include "sci/sound/soundcmd.h"
 
namespace Sci {
 
class FileHandle;
class DirSeeker;
class EventManager;
class MessageState;
class SoundCommandParser;
class VirtualIndexFile;
 
enum AbortGameState {
    kAbortNone = 0,
    kAbortLoadGame = 1,
    kAbortRestartGame = 2,
    kAbortQuitGame = 3
};
 
// We assume that scripts give us savegameId 0->99 for creating a new save slot
//  and savegameId 100->199 for existing save slots. Refer to kfile.cpp
enum {
    SAVEGAMEID_OFFICIALRANGE_START = 100,
    SAVEGAMEID_OFFICIALRANGE_END = 199
};
 
enum {
    GAMEISRESTARTING_NONE = 0,
    GAMEISRESTARTING_RESTART = 1,
    GAMEISRESTARTING_RESTORE = 2
};
 
enum VideoFlags {
    kNone            = 0,
    kDoubled         = 1 << 0,
    kDropFrames      = 1 << 1,
    kBlackLines      = 1 << 2,
    kUnkBit3         = 1 << 3,
    kGammaBoost      = 1 << 4,
    kHoldBlackFrame  = 1 << 5,
    kHoldLastFrame   = 1 << 6,
    kUnkBit7         = 1 << 7,
    kStretch         = 1 << 8
};
 
struct SciCallOrigin {
    int scriptNr; //< The source script of the function
    Common::String objectName; //< The name of the object being called
    Common::String methodName; //< The name of the method being called
    int localCallOffset; //< The byte offset of a local script subroutine called by the origin method. -1 if not in a local subroutine.
    int roomNr; //< The room that was loaded at the time of the call
 
    Common::String toString() const {
        return Common::String::format("method %s::%s (room %d, script %d, localCall %x)", objectName.c_str(), methodName.c_str(), roomNr, scriptNr, localCallOffset);
    }
};
 
struct EngineState : public Common::Serializable {
    EngineState(SegManager *segMan);
    ~EngineState() override;
 
    void saveLoadWithSerializer(Common::Serializer &ser) override;
 
    SegManager *_segMan; 
    /* Non-VM information */
 
    uint32 lastWaitTime; 
    uint32 _screenUpdateTime;   
    void speedThrottler(uint32 neededSleep);
    uint16 wait(uint16 ticks);
    void sleep(uint16 ticks);
 
    uint32 _eventCounter; 
    uint32 _paletteSetIntensityCounter; 
    uint32 _throttleLastTime; 
    bool _throttleTrigger;
 
    /* Kernel File IO stuff */
 
    Common::Array<FileHandle> _fileHandles; 
    DirSeeker _dirseeker;
 
    int16 _lastSaveVirtualId; // last virtual id fed to kSaveGame, if no kGetSaveFiles was called inbetween
    int16 _lastSaveNewId;    // last newly created filename-id by kSaveGame
 
    // see detection.cpp / SciEngine::loadGameState()
    int _delayedRestoreGameId; // the saved game id, that it supposed to get restored (triggered by ScummVM menu)
 
    // see kmisc.cpp / kMacPlatform32
    int _kq7MacSaveGameId; // the saved game id to use when saving (might not exist yet)
    Common::String _kq7MacSaveGameDescription; // description to use when saving game
 
    uint _chosenQfGImportItem; // Remembers the item selected in QfG import rooms
 
    bool _cursorWorkaroundActive; // Refer to GfxCursor::setPosition()
    int16 _cursorWorkaroundPosCount; // When the cursor is reported to be at the previously set coordinate, we won't disable the workaround unless it happened for this many times
    Common::Point _cursorWorkaroundPoint;
    Common::Rect _cursorWorkaroundRect;
 
    /* VM Information */
 
    Common::List<ExecStack> _executionStack; 
    int executionStackBase;
    bool _executionStackPosChanged;   
    // Registers
    reg_t r_acc; 
    reg_t r_prev; 
    int16 r_rest; 
    StackPtr stack_base; 
    StackPtr stack_top; 
    // Script state
    ExecStack *xs;
    reg_t *variables[4];        
    reg_t *variablesBase[4];    
    SegmentId variablesSegment[4];  
    int variablesMax[4];        
 
    AbortGameState abortScriptProcessing;
    int16 gameIsRestarting; // is set when restarting (=1) or restoring the game (=2)
 
    int scriptStepCounter; // Counts the number of steps executed
    int scriptGCInterval; // Number of steps in between gcs
 
    uint16 currentRoomNumber() const;
    void setRoomNumber(uint16 roomNumber);
 
    void initGlobals();
 
    void shrinkStackToBase();
 
    int gcCountDown; 
    MessageState *_msgState;
    void initMessageState();
 
    // MemorySegment provides access to a 256-byte block of memory that remains
    // intact across restarts and restores
    enum {
        kMemorySegmentMax = 256
    };
    uint16 _memorySegmentSize;
    byte _memorySegment[kMemorySegmentMax];
 
    void reset(bool isRestoring);
 
    SciCallOrigin getCurrentCallOrigin() const;
 
    bool callInStack(const reg_t object, const Selector selector) const;
 
    Common::String getGameVersionFromGlobal() const;
};
 
} // End of namespace Sci
 
#endif // SCI_ENGINE_STATE_H