agos.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 AGOS_AGOS_H
#define AGOS_AGOS_H
 
#include "engines/engine.h"
 
#include "common/array.h"
#include "common/error.h"
#include "common/hashmap.h"
#include "common/keyboard.h"
#include "common/random.h"
#include "common/rect.h"
#include "common/stack.h"
#include "common/util.h"
#include "audio/mixer.h"
 
#include "backends/keymapper/action.h"
#include "backends/keymapper/keymapper.h"
 
#include "agos/vga.h"
#include "agos/detection.h"
 
namespace Common {
class File;
class SeekableReadStream;
}
 
namespace Graphics {
struct Surface;
class FontSJIS;
class AmigaFont;
}
 
namespace Audio {
class SeekableAudioStream;
}
 
namespace AGOS {
 
class ElviraAtariSTPlayer;
 
enum {
    kDebugOpcode = 1,
    kDebugVGAOpcode,
    kDebugSubroutine,
    kDebugVGAScript,
    kDebugImageDump,
};
 
enum AGOSAction {
    kActionNone,
    kActionWalkForward,
    kActionTurnBack,
    kActionTurnLeft,
    kActionTurnRight,
    kActionMusicDown,
    kActionMusicUp,
    kActionExitCutscene,
    kActionToggleMusic,
    kActionToggleFastMode,
    kActionToggleSwitchCharacter,
    kActionToggleSubtitle,
    kActionToggleSpeech,
    kActionToggleHitboxName,
    kActionToggleSoundEffects,
    kActionToggleBackgroundSound,
    kActionToggleFightMode,
    kActionShowObjects,
    kActionTextSpeedFast,
    kActionTextSpeedMedium,
    kActionTextSpeedSlow,
    kActionSpeed_GTYPEPP,
    kActionKeyYes,
    kActionKeyNo,
    kActionPause
};
 
uint fileReadItemID(Common::SeekableReadStream *in);
 
#define CHECK_BOUNDS(x, y) assert((uint)(x) < ARRAYSIZE(y))
 
#ifdef ENABLE_AGOS2
class MoviePlayer;
#endif
 
class Sound;
class MidiPlayer;
 
struct Child;
struct SubObject;
struct RoomState;
struct SubRoom;
struct SubSuperRoom;
 
struct Item;
struct WindowBlock;
struct Subroutine;
struct SubroutineLine;
struct TimeEvent;
 
struct TextLocation {
    int16 x, y, width;
    TextLocation() { memset(this, 0, sizeof(*this)); }
};
 
struct HitArea {
    uint16 x, y;
    uint16 width, height;
    uint16 flags;
    uint16 id;
    uint16 data;
    WindowBlock *window;
    Item *itemPtr;
    uint16 verb;
    uint16 priority;
 
    // Personal Nightmare specific
    uint16 msg1, msg2;
    HitArea() { memset(this, 0, sizeof(*this)); }
};
 
struct VgaPointersEntry {
    byte *vgaFile1;
    byte *vgaFile1End;
    byte *vgaFile2;
    byte *vgaFile2End;
    byte *sfxFile;
    byte *sfxFileEnd;
    VgaPointersEntry() { memset(this, 0, sizeof(*this)); }
};
 
struct VgaSprite {
    uint16 id;
    int16 image;
    uint16 palette;
    int16 x, y;
    uint16 flags;
    uint16 priority;
    uint16 windowNum;
    uint16 zoneNum;
    VgaSprite() { reset(); }
 
    void reset() {
        id = 0;
        image = 0;
        palette = 0;
        x = y = 0;
        flags = 0;
        priority = 0;
        windowNum = 0;
        zoneNum = 0;
    }
};
 
struct VgaSleepStruct {
    uint16 ident;
    const byte *codePtr;
    uint16 id;
    uint16 zoneNum;
    VgaSleepStruct() { memset(this, 0, sizeof(*this)); }
};
 
struct VgaTimerEntry {
    int16 delay;
    const byte *codePtr;
    uint16 id;
    uint16 zoneNum;
    uint8 type;
    VgaTimerEntry() { memset(this, 0, sizeof(*this)); }
};
 
struct AnimTable {
    const byte *srcPtr;
    int16 x;
    int16 y;
    uint16 width;
    uint16 height;
    uint16 windowNum;
    uint16 id;
    uint16 zoneNum;
    AnimTable() { memset(this, 0, sizeof(*this)); }
};
 
enum EventType {
    ANIMATE_INT   = 1 << 1,
    ANIMATE_EVENT = 1 << 2,
    SCROLL_EVENT  = 1 << 3,
    PLAYER_DAMAGE_EVENT = 1 << 4,
    MONSTER_DAMAGE_EVENT = 1 << 5,
    PN_FADE_EVENT = 1 << 6
};
 
struct GameSpecificSettings;
 
class Debugger;
 
// This is to help devices with small memory (PDA, smartphones, ...)
// to save a bit of memory used by opcode names in the AGOS engine.
 
#ifndef REDUCE_MEMORY_USAGE
#   define _OPCODE(ver, x)  { &ver::x, #x }
#else
#   define _OPCODE(ver, x)  { &ver::x, "" }
#endif
 
class AGOSEngine : public Engine {
protected:
    // List of Simon 1 DOS floppy SFX which use rhythm notes.
    static const byte SIMON1_RHYTHM_SFX[];
 
    // Music index base for Simon 2 GM data.
    static const uint16 MUSIC_INDEX_BASE_SIMON2_GM = 1128 / 4;
    // Music index base for Simon 2 MT-32 data.
    static const uint16 MUSIC_INDEX_BASE_SIMON2_MT32 = (1128 + 612) / 4;
 
protected:
    friend class Debugger;
 
    // Engine APIs
    virtual Common::Error init();
    virtual Common::Error go();
    Common::Error run() override {
        Common::Error err;
        err = init();
        if (err.getCode() != Common::kNoError)
            return err;
        return go();
    }
 
    bool hasFeature(EngineFeature f) const override;
    void syncSoundSettings() override;
    // Applies AGOS engine internal sound settings to ConfigManager, digital
    // sound channels and MIDI.
    void syncSoundSettingsIntern();
    void pauseEngineIntern(bool pause) override;
 
    virtual void setupOpcodes();
    uint16 _numOpcodes, _opcode;
 
    typedef void (AGOSEngine::*VgaOpcodeProc) ();
 
    void setupVgaOpcodes();
    VgaOpcodeProc _vga_opcode_table[100];
    uint8 _numVideoOpcodes;
 
    virtual void setupVideoOpcodes(VgaOpcodeProc *op);
 
    const AGOSGameDescription * const _gameDescription;
 
public:
    virtual void setupGame();
 
    int getGameId() const;
    int getGameType() const;
    uint32 getFeatures() const;
    const char *getExtra() const;
    bool isSimon2MacAmiga() const;
    Common::Language getLanguage() const;
    Common::Platform getPlatform() const;
    const char *getFileName(int type) const;
 
protected:
    const byte *_vcPtr;                             /* video code ptr */
    uint16 _vcGetOutOfCode;
 
 
    uint32 *_gameOffsetsPtr;
 
    uint8 _numMusic, _numSFX;
    uint16 _numSpeech;
    uint16 _numZone;
 
    uint8 _numBitArray1, _numBitArray2, _numBitArray3, _numItemStore;
    uint16 _numVars;
 
    uint8 _vgaBaseDelay, _vgaPeriod;
 
    uint16 _musicIndexBase;
    uint16 _soundIndexBase;
    uint16 _tableIndexBase;
    uint16 _textIndexBase;
 
    uint32 _itemMemSize;
    uint32 _tableMemSize;
    uint32 _vgaMemSize;
 
    const GameSpecificSettings *gss;
 
    AGOSAction _action;
    Common::JoystickState _joyaction;
    Common::KeyState _keyPressed;
 
    Common::File *_gameFile;
 
    byte *_strippedTxtMem;
    byte *_textMem;
    uint32 _textSize;
    uint32 _stringTabNum, _stringTabPos, _stringTabSize;
    byte **_stringTabPtr;
 
    Item **_itemArrayPtr;
    uint32 _itemArraySize;
    uint32 _itemArrayInited;
 
    Common::Array<byte *> _itemHeap;
 
    byte *_iconFilePtr;
 
    const byte *_codePtr;
 
    byte **_localStringtable;
    uint16 _stringIdLocalMin, _stringIdLocalMax;
 
    RoomState *_roomStates;
    uint16 _numRoomStates;
 
    byte *_menuBase;
    byte *_roomsList;
    byte *_roomsListPtr;
 
    byte *_xtblList;
    byte *_xtablesHeapPtrOrg;
    uint32 _xtablesHeapCurPosOrg;
    Subroutine *_xsubroutineListOrg;
 
    byte *_tblList;
    byte *_tablesHeapPtr, *_tablesHeapPtrOrg, *_tablesheapPtrNew;
    uint32 _tablesHeapSize, _tablesHeapCurPos, _tablesHeapCurPosOrg;
    uint32 _tablesHeapCurPosNew;
    Subroutine *_subroutineListOrg;
 
    Subroutine *_subroutineList;
 
    uint8 _recursionDepth;
 
    uint32 _lastVgaTick;
 
    uint16 _marks;
    bool _scanFlag;
 
    bool _scriptVar2;
    bool _runScriptReturn1;
    bool _runScriptCondition[40];
    int16 _runScriptReturn[40];
    bool _skipVgaWait;
    bool _noParentNotify;
    bool _beardLoaded;
    bool _litBoxFlag;
    bool _mortalFlag;
    uint16 _displayFlag;
    bool _syncFlag2;
    bool _inCallBack;
    bool _cepeFlag;
    bool _fastMode;
    bool _backFlag;
 
    Common::Language _language;
    Common::Language _simon2OverlayLanguage;
    bool _useSimon2LanguageOverlay;
    Common::HashMap<Common::String, Common::String> _simon2LanguageOverlay;
    bool _copyProtection;
    bool _pause;
    bool _speech;
    bool _subtitles;
    bool _vgaVar9;
    int16 _chanceModifier;
    bool _restoreWindow6;
    int16 _scrollX, _scrollXMax;
    int16 _scrollY, _scrollYMax;
    int16 _scrollCount, _scrollFlag;
    uint16 _scrollWidth, _scrollHeight;
    const byte *_scrollImage;
    byte _boxStarHeight;
    bool _forceAscii;
 
    SubroutineLine *_classLine;
    int16 _classMask, _classMode1, _classMode2;
    Item *_findNextPtr;
    Subroutine *_currentTable;
    SubroutineLine *_currentLine;
 
    uint8 _agosMenu;
    byte _textMenu[10];
    uint16 _currentRoom, _superRoomNumber;
    uint8 _wallOn;
 
    uint16 _hyperLink, _newLines;
    uint16 _oracleMaxScrollY, _noOracleScroll;
    uint16 _interactY;
 
    int16 _scriptVerb, _scriptNoun1, _scriptNoun2;
    int16 _scriptAdj1, _scriptAdj2;
 
    uint16 _curWindow;
    WindowBlock *_inputWindow, *_textWindow;
 
    Item *_subjectItem, *_objectItem;
    Item *_currentPlayer;
 
    Item *_hitAreaObjectItem;
    HitArea *_lastHitArea;
    HitArea *_lastNameOn;
    HitArea *_lastHitArea3;
    Item *_hitAreaSubjectItem;
    HitArea *_currentBox, *_currentVerbBox, *_lastVerbOn;
    uint16  _currentBoxNum;
    uint16 _needHitAreaRecalc;
    uint16 _verbHitArea;
    uint16 _defaultVerb;
    bool _iOverflow;
    bool _nameLocked;
 
    bool _dragAccept;
    bool _dragEnd;
    bool _dragFlag;
    bool _dragMode;
    uint8 _dragCount;
    HitArea *_lastClickRem;
 
    uint16 _windowNum;
 
    int16 _printCharCurPos, _printCharMaxPos, _printCharPixelCount;
    uint16 _numLettersToPrint;
 
    uint8 _numTextBoxes;
 
    uint32 getTime() const;
 
    uint32 _lastMinute; // Used in processSpecialKeys()
    uint32 _lastTime;
    uint32 _clockStopped, _gameStoppedClock;
    uint32 _timeStore;
 
    TimeEvent *_firstTimeStruct, *_pendingDeleteTimeEvent;
 
    bool _initMouse;
    Common::Point _mouse;
    Common::Point _mouseOld;
 
    byte *_mouseData;
    bool _animatePointer;
    byte _maxCursorWidth, _maxCursorHeight;
    byte _mouseAnim, _mouseAnimMax, _mouseCursor;
    byte _currentMouseAnim, _currentMouseCursor;
    byte _oldMouseAnimMax, _oldMouseCursor;
    uint16 _mouseHideCount;
    bool _mouseToggle;
 
    bool _leftButtonDown, _rightButtonDown;
    byte _leftButton, _leftButtonCount, _leftButtonOld;
    byte _oneClick;
    bool _clickOnly;
    bool _leftClick, _rightClick;
    bool _noRightClick;
 
    Item *_dummyItem1;
    Item *_dummyItem2;
    Item *_dummyItem3;
 
    volatile uint16 _videoLockOut;
    uint16 _scrollUpHitArea;
    uint16 _scrollDownHitArea;
 
    bool _fastFadeOutFlag;
    byte _paletteFlag;
    bool _bottomPalette;
    uint16 _fastFadeCount;
    volatile uint16 _fastFadeInFlag;
    bool _neverFade;
 
    uint16 _screenWidth, _screenHeight;
    uint16 _internalWidth, _internalHeight;
 
    uint16 _noOverWrite;
    bool _rejectBlock;
 
    bool _exitCutscene, _picture8600;
 
    uint16 _soundFileId;
    int16 _lastMusicPlayed;
    int16 _nextMusicToPlay;
    bool _showPreposition;
    bool _showMessageFlag;
 
    bool _newDirtyClip;
    bool _wiped;
    uint16 _copyScnFlag, _vgaSpriteChanged;
 
    byte *_block, *_blockEnd;
    byte *_vgaMemPtr, *_vgaMemEnd, *_vgaMemBase;
    byte *_vgaFrozenBase, *_vgaRealBase;
    byte *_zoneBuffers;
 
    byte *_curVgaFile1;
    byte *_curVgaFile2;
 
    uint16 _syncCount;
 
    uint16 _frameCount;
 
    uint16 _zoneNumber;
    uint16 _vgaWaitFor, _lastVgaWaitFor;
    uint16 _vgaCurSpriteId, _vgaCurZoneNum;
 
    int16 _baseY;
    float _scale;
    Common::Rect _feebleRect;
    int16 _scaleX, _scaleY, _scaleWidth, _scaleHeight;
 
    VgaTimerEntry *_nextVgaTimerToProcess;
 
    struct PnAmigaTextPlane {
        byte *pixels;
        uint16 width, height;
        PnAmigaTextPlane() : pixels(nullptr), width(0), height(0) {}
    };
 
    enum {
        kPnAmigaTextStartX = 2,
        kPnAmigaLowresWidth = 320,
        kPnAmigaMainTextTop = 136,
        kPnAmigaInputTop = 224,
        kPnAmigaTextPlaneWidth = 552
    };
 
    uint8 _opcode177Var1, _opcode177Var2;
    uint8 _opcode178Var1, _opcode178Var2;
 
    Item *_objectArray[50];
    Item *_itemStore[50];
 
    uint16 _shortText[40];
    uint16 _shortTextX[40];
    uint16 _shortTextY[40];
    uint16 _longText[40];
    uint16 _longSound[40];
 
    uint16 _bitArray[128];
    uint16 _bitArrayTwo[16];
    uint16 _bitArrayThree[16];
    int16 *_variableArray;
    int16 *_variableArray2;
    int16 *_variableArrayPtr;
 
    WindowBlock *_dummyWindow;
    WindowBlock *_windowArray[80];
    Graphics::AmigaFont *_pnAmigaFont;
    bool _pnAmigaUiVisible;
    PnAmigaTextPlane _pnAmigaMainTextPlane;
    PnAmigaTextPlane _pnAmigaInputTextPlane;
 
    byte _fcsData1[8];
    bool _fcsData2[8];
 
    TextLocation _textLocation1, _textLocation2, _textLocation3, _textLocation4;
 
    byte _awaitTwoByteToken;
    byte *_byteTokens;
    byte *_byteTokenStrings;
    byte *_twoByteTokens;
    byte *_twoByteTokenStrings;
    byte *_secondTwoByteTokenStrings;
    byte *_thirdTwoByteTokenStrings;
    byte _textBuffer[180];
    int _textCount;
 
    int _freeStringSlot;
 
    byte _stringReturnBuffer[2][180];
 
    HitArea _hitAreas[250];
    HitArea *_hitAreaList;
 
    AnimTable _screenAnim1[90];
    VgaPointersEntry _vgaBufferPointers[450];
    VgaSprite _vgaSprites[200];
    VgaSleepStruct _onStopTable[60];
    VgaSleepStruct _waitEndTable[60];
    VgaSleepStruct _waitSyncTable[60];
 
    const uint16 *_pathFindArray[100];
 
    uint8 _pathValues[400];
    uint16 _PVCount;
    uint16 _GPVCount;
 
    uint8 _pathValues1[400];
    uint16 _PVCount1;
    uint16 _GPVCount1;
 
    uint8 _currentPalette[768];
    uint8 _displayPalette[768];
    uint8 _simon2LanguageFlagTimer;
    bool _simon2LanguageFlagClearPending;
 
    uint16 _pnPaletteBanks[2][16];
    uint16 _pnFadeCurrent[16];
    uint16 _pnDayNightControllerSelectorMask;
    uint8 _pnDayNightControllerLastStage;
    int16 _pnLastClockMinutes;
    bool _pnHavePaletteBank[2];
    uint16 _pnDayNightControllerTickCounter;
    byte *_planarBuf;
    byte _videoBuf1[32000];
    uint16 _videoWindows[128];
    const byte *_pak98Buf;
    byte _paletteModNext;
 
    uint8 _window3Flag;
    uint8 _window4Flag;
    uint8 _window6Flag;
 
    uint16 _moveXMin, _moveYMin;
    uint16 _moveXMax, _moveYMax;
 
    VgaTimerEntry _vgaTimerList[205];
 
    WindowBlock *_windowList;
 
    byte _lettersToPrintBuf[80];
 
    MidiPlayer *_midi;
    bool _midiEnabled;
 
    int _vgaTickCounter;
 
    Audio::SoundHandle _modHandle;
    Audio::SoundHandle _digitalMusicHandle;
    Audio::SeekableAudioStream *_digitalMusicStream = nullptr;
    ElviraAtariSTPlayer *_elviraAtariSTPlayer = nullptr;
 
    Sound *_sound;
 
    bool _effectsMuted;
    bool _ambientMuted;
    bool _musicMuted;
    // The current music volume, or the last used music volume if music is
    // currently muted.
    uint16 _musicVolume;
    // The current SFX and ambient volume, or the last used volume if SFX
    // and/or ambient sounds are currently muted.
    uint16 _effectsVolume;
    bool _useDigitalSfx;
    bool _pendingWaitCommandDelay;
    bool _pendingPNWaitScreenDelay;
 
    uint8 _saveGameNameLen;
    uint16 _saveLoadRowCurPos;
    uint16 _numSaveGameRows;
    bool _saveDialogFlag;
    bool _saveOrLoad;
    bool _saveLoadEdit;
 
    byte _saveLoadType, _saveLoadSlot;
    char _saveLoadName[108];
    char _saveBuf[200];
 
    Graphics::Surface *_backGroundBuf;
    Graphics::Surface *_backBuf;
    Graphics::Surface *_scaleBuf;
    Graphics::Surface *_window4BackScn;
    Graphics::Surface *_window6BackScn;
 
    Common::RandomSource _rnd;
 
    const byte *_vc10BasePtrOld;
    byte _hebrewCharWidths[32];
 
public:
    AGOSEngine(OSystem *system, const AGOSGameDescription *gd);
    ~AGOSEngine() override;
 
    byte *_curSfxFile;
    uint32 _curSfxFileSize;
    uint16 _sampleEnd, _sampleWait;
 
protected:
    virtual uint16 to16Wrapper(uint value);
    virtual uint16 readUint16Wrapper(const void *src);
    virtual uint32 readUint32Wrapper(const void *src);
 
#ifdef ENABLE_AGOS2
    void loadArchives();
#endif
 
    int allocGamePcVars(Common::SeekableReadStream *in);
    void createPlayer();
    void allocateStringTable(int num);
    void setupStringTable(byte *mem, int num);
    void setupLocalStringTable(byte *mem, int num);
    void readGamePcText(Common::SeekableReadStream *in);
    virtual void readItemChildren(Common::SeekableReadStream *in, Item *item, uint tmp);
    void readItemFromGamePc(Common::SeekableReadStream *in, Item *item);
    virtual void loadGamePcFile();
    void readGamePcFile(Common::SeekableReadStream *in);
    void decompressData(const char *srcName, byte *dst, uint32 offset, uint32 srcSize, uint32 dstSize);
    void decompressPN(Common::Stack<uint32> &dataList, uint8 *&dataOut, int &dataOutSize);
    void drawPnSqueezedChar(WindowBlock *window, uint x, uint y, byte chr);
    bool isPnAmiga() const;
    bool isPnAmigaMainTextWindow(const WindowBlock *window) const;
    bool isPnAmigaInputWindow(const WindowBlock *window) const;
    bool isPnAmigaTextWindow(const WindowBlock *window) const;
    const Graphics::AmigaFont *getPnAmigaFont() const;
    uint16 getPnAmigaWindowInteriorHeight(const WindowBlock *window) const;
    uint16 getPnAmigaTextPlaneWidth(const WindowBlock *window) const;
    uint16 getPnAmigaTextLineStep() const;
    uint16 getPnAmigaGlyphAdvance(byte chr) const;
    uint16 getPnAmigaGlyphRenderWidth(byte chr) const;
    uint16 getPnAmigaGlyphHeight() const;
    bool usePnAmigaDoubleHeightTopaz() const;
    void ensurePnAmigaTextPlanes();
    PnAmigaTextPlane *getPnAmigaTextPlane(const WindowBlock *window);
    const PnAmigaTextPlane *getPnAmigaTextPlane(const WindowBlock *window) const;
    void clearPnAmigaTextPlane(WindowBlock *window);
    void compositePnAmigaTextPlane(WindowBlock *window);
    void scrollPnAmigaTextPlane(WindowBlock *window);
    void drawPnAmigaTopazChar(WindowBlock *window, byte chr);
    void drawPnAmigaTextWindowBorders();
 
    void loadOffsets(const char *filename, int number, uint32 &file, uint32 &offset, uint32 &compressedSize, uint32 &size);
    void loadSound(uint16 sound, int16 pan, int16 vol, uint16 type);
    void playSfx(uint16 sound, uint16 freq, uint16 flags, bool digitalOnly = false, bool midiOnly = false);
    void loadSound(uint16 sound, uint16 freq, uint16 flags);
    void loadMidiSfx();
    virtual void playMidiSfx(uint16 sound);
    void loadVoice(uint speechId);
    void stopAllSfx();
 
    void loadSoundFile(const char *filename);
 
    int getUserFlag(Item *item, int a);
    int getUserFlag1(Item *item, int a);
    int getUserItem(Item *item, int n);
    void setUserFlag(Item *item, int a, int b);
    void setUserItem(Item *item, int n, int m);
 
    void paletteFadeOut(byte *palPtr, uint num, uint size);
 
    void *allocateItem(uint size);
    void *allocateTable(uint size);
    void alignTableMem();
 
    Child *findChildOfType(Item *i, uint child);
    Child *allocateChildBlock(Item *i, uint type, uint size);
 
    void allocItemHeap();
    void allocTablesHeap();
 
    Subroutine *createSubroutine(uint16 a);
    void readSubroutine(Common::SeekableReadStream *in, Subroutine *sub);
    SubroutineLine *createSubroutineLine(Subroutine *sub, int a);
    void readSubroutineLine(Common::SeekableReadStream *in, SubroutineLine *newTable, Subroutine *sub);
    byte *readSingleOpcode(Common::SeekableReadStream *in, byte *ptr);
    void readSubroutineBlock(Common::SeekableReadStream *in);
 
    Subroutine *getSubroutineByID(uint subroutineId);
 
    /* used in debugger */
    void dumpAllSubroutines();
    void dumpAllVgaImageFiles();
    void dumpAllVgaScriptFiles();
    void dumpSubroutines();
    void dumpSubroutine(Subroutine *sub);
    void dumpSubroutineLine(SubroutineLine *sl, Subroutine *sub);
    const byte *dumpOpcode(const byte *p);
 
    int startSubroutine(Subroutine *sub);
    int startSubroutineEx(Subroutine *sub);
 
    bool checkIfToRunSubroutineLine(SubroutineLine *sl, Subroutine *sub);
 
    int runScript();
    virtual void executeOpcode(int opcode) = 0;
 
    byte getByte();
    int getNextWord();
 
    uint getNextVarContents();
    uint getVarWrapper();
    uint getVarOrWord();
    uint getVarOrByte();
    uint readVariable(uint16 variable);
    void writeNextVarContents(uint16 contents);
    void writeVariable(uint16 variable, uint16 contents);
 
    Item *derefItem(uint item);
    Item *getNextItemPtr();
    uint getNextItemID();
    uint getItem1ID() {return 1;}
    uint itemPtrToID(Item *id);
    Item *me();
    Item *actor();
 
    void uncompressText(byte *ptr);
    byte *uncompressToken(byte a, byte *ptr);
 
    void showMessageFormat(MSVC_PRINTF const char *s, ...) GCC_PRINTF(2, 3);
    const byte *getStringPtrByID(uint16 stringId, bool upperCase = false);
    void loadSimon2LanguageOverlay();
    bool hasSimon2LanguageFiles() const;
    Common::Language getNextSimon2OverlayLanguage() const;
    void cycleSimon2LanguageOverlay();
    Common::String translateLanguageOverlay(const Common::String &english) const;
    const byte *getLocalStringByID(uint16 stringId);
    uint getNextStringID();
 
    void addTimeEvent(int32 timeout, uint16 subroutineId);
    void delTimeEvent(TimeEvent *te);
 
    Item *findInByClass(Item *i, int16 m);
    Item *nextInByClass(Item *i, int16 m);
    Item *findMaster(int16 a, int16 n);
    Item *nextMaster(Item *item, int16 a, int16 n);
    int wordMatch(Item *item, int16 a, int16 n);
 
    bool isRoom(Item *item);
    bool isObject(Item *item);
    bool isPlayer(Item *item);
 
    void itemChildrenChanged(Item *item);
    void unlinkItem(Item *item);
    void linkItem(Item *item, Item *parent);
 
    void setItemParent(Item *item, Item *parent);
    void setItemState(Item *item, int value);
 
    void stopAnimate(uint16 a);
    void stopAnimateSimon2(uint16 a, uint16 b);
 
    void enableBox(uint hitarea);
    void disableBox(uint hitarea);
    void moveBox(uint hitarea, int x, int y);
    bool isBoxDead(uint hitarea);
    void undefineBox(uint hitarea);
    void defineBox(int id, int x, int y, int width, int height, int flags, int verb, Item *itemPtr);
    void defineBox(uint16 id, uint16 x, uint16 y, uint16 width, uint16 height, uint16 msg1, uint16 msg2, uint16 flags);
 
    HitArea *findEmptyHitArea();
 
    virtual void resetVerbs();
    virtual void setVerb(HitArea * ha);
    virtual void hitarea_leave(HitArea * ha, bool state = false);
    void leaveHitAreaById(uint hitarea_id);
 
    void sendSync(uint a);
    void waitForSync(uint a);
 
    uint getOffsetOfChild2Param(SubObject *child, uint prop);
    void scriptMouseOff();
    void freezeBottom();
    void unfreezeBottom();
 
    TextLocation *getTextLocation(uint a);
 
    uint setVerbText(HitArea *ha);
    void waitForInput();
    void setup_cond_c_helper();
 
    uint16 getBackExit(int n);
    uint16 getDoorState(Item *item, uint16 d);
    uint16 getExitOf(Item *item, uint16 d);
    void changeDoorState(SubRoom *r, uint16 d, uint16 n);
    void setDoorState(Item *i, uint16 d, uint16 n);
 
    // Elvira 1 specific
    Item *getDoorOf(Item *item, uint16 d);
    Item *getExitOf_e1(Item *item, uint16 d);
    virtual void moveDirn(Item *i, uint x);
 
    virtual int canPlace(Item *x, Item *y);
    int contains(Item *a, Item *b);
    int sizeContents(Item *x);
    virtual int sizeOfRec(Item *o, int d);
    int sizeRec(Item *x, int d);
    int weighUp(Item *x);
    int weightRec(Item *x, int d);
    virtual int weightOf(Item *x);
    void xPlace(Item *x, Item *y);
 
    void restoreMenu();
    void drawMenuStrip(uint windowNum, uint menuNum);
    void lightMenuStrip(int a);
    void unlightMenuStrip();
    void lightMenuBox(uint hitarea);
 
    uint menuFor_e2(Item *item);
    uint menuFor_ww(Item *item, uint id);
    void clearMenuStrip();
    void doMenuStrip(uint menuNum);
 
    void mouseOff();
    void mouseOn();
 
    bool loadRoomItems(uint16 item);
 
    virtual bool loadTablesIntoMem(uint16 subrId);
    bool loadXTablesIntoMem(uint16 subrId);
    void loadTextIntoMem(uint16 stringId);
 
    uint loadTextFile(const char *filename, byte *dst);
    Common::SeekableReadStream *openTablesFile(const char *filename);
    void closeTablesFile(Common::SeekableReadStream *in);
 
    uint loadTextFile_simon1(const char *filename, byte *dst);
    Common::SeekableReadStream *openTablesFile_simon1(const char *filename);
    Common::SeekableReadStream *openTablesFile_pak98(const char *filename);
    Common::SeekableReadStream *createPak98FileStream(const char *filename);
    void convertPC98Image(VC10_state &state);
 
    uint loadTextFile_gme(const char *filename, byte *dst);
    Common::SeekableReadStream *openTablesFile_gme(const char *filename);
 
    void invokeTimeEvent(TimeEvent *te);
    bool kickoffTimeEvents();
    void killAllTimers();
 
    void endCutscene();
    virtual void runSubroutine101();
    bool isSimon2LanguageToggleKeyPressed() const;
    void refreshSimon2LanguageText();
    uint8 mapRGBToPaletteIndex(uint8 r, uint8 g, uint8 b) const;
    void fillSimon2LanguageFlagRect(int x1, int y1, int x2, int y2, uint8 color);
    void restoreSimon2LanguageFlagArea();
    void drawSimon2LanguageFlag();
 
    virtual void inventoryUp(WindowBlock *window);
    virtual void inventoryDown(WindowBlock *window);
 
    WindowBlock *openWindow(uint x, uint y, uint w, uint h, uint flags, uint fillColor, uint textColor);
    uint getWindowNum(WindowBlock *window);
    void clearWindow(WindowBlock *window);
    void changeWindow(uint a);
    void closeWindow(uint a);
    void setTextColor(uint color);
    virtual void windowPutChar(WindowBlock *window, byte c, byte b = 0);
    void waitWindow(WindowBlock *window);
 
    HitArea *findBox(uint hitarea_id);
    virtual void boxController(uint x, uint y, uint mode);
    void handleVerbClicked(uint verb);
    virtual void clearName();
    void displayName(HitArea * ha);
    void resetNameWindow();
    void displayBoxStars();
    void invertBox(HitArea * ha, byte a, byte b, byte c, byte d);
 
    virtual void handleMouseWheelUp();
    virtual void handleMouseWheelDown();
 
    virtual void initMouse();
    virtual void handleMouseMoved();
    virtual void drawMousePointer();
 
    void drawArrow(uint16 x, uint16 y, int8 dir);
    virtual void addArrows(WindowBlock *window, uint8 num);
    virtual void removeArrows(WindowBlock *window, uint num);
 
    virtual void drawIcon(WindowBlock *window, uint icon, uint x, uint y);
    virtual bool hasIcon(Item *item);
    virtual uint itemGetIconNumber(Item *item);
    virtual uint setupIconHitArea(WindowBlock *window, uint num, uint x, uint y, Item *itemPtr);
 
    virtual void drawIconArray(uint i, Item *itemPtr, int line, int classMask);
    void removeIconArray(uint num);
 
    void loadIconData();
    void loadIconFile();
    void loadMenuFile();
 
    virtual bool processSpecialKeys();
    void hitarea_stuff_helper();
 
    void permitInput();
 
    uint getFeebleFontSize(byte chr);
    void justifyStart();
    void justifyOutPut(byte chr);
 
    void loadZone(uint16 zoneNum, bool useError = true);
 
    void animate(uint16 windowNum, uint16 zoneNum, uint16 vgaSpriteId, int16 x, int16 y, uint16 palette, bool vgaScript = false);
    void setImage(uint16 vgaSpriteId, bool vgaScript = false);
    void setWindowImage(uint16 mode, uint16 vgaSpriteId, bool specialCase = false);
    virtual void setWindowImageEx(uint16 mode, uint16 vgaSpriteId);
    void drawEdging();
 
    void skipSpeech();
 
    const char *getPixelLength(const char *string, uint16 maxWidth, uint16 &pixels);
    bool printNameOf(Item *item, uint x, uint y);
    bool printTextOf(uint a, uint x, uint y);
    void printVerbOf(uint hitarea_id);
    void showActionString(const byte *string);
 
    virtual void printScreenText(uint vgaSpriteId, uint color, const char *stringPtr, int16 x, int16 y, int16 width);
 
    void renderStringAmiga(uint vgaSpriteId, uint color, uint width, uint height, const char *txt);
    void renderString(uint vgaSpriteId, uint color, uint width, uint height, const char *txt);
 
    void writeChar(WindowBlock *window, int x, int y, int offs, int val);
 
    byte *allocBlock(uint32 size);
    void checkNoOverWrite();
    void checkRunningAnims();
    void checkAnims(uint a);
    void checkZonePtrs();
    void setZoneBuffers();
 
    void runVgaScript();
 
public:
    bool getBitFlag(uint bit);
    void setBitFlag(uint bit, bool value);
 
    // Video Script Opcodes, Common
    void vc1_fadeOut();
    void vc2_call();
    virtual void vc3_loadSprite();
    void vc4_fadeIn();
    void vc5_ifEqual();
    void vc6_ifObjectHere();
    void vc7_ifObjectNotHere();
    void vc8_ifObjectIsAt();
    void vc9_ifObjectStateIs();
    void vc10_draw();
    void vc12_delay();
    void vc13_addToSpriteX();
    void vc14_addToSpriteY();
    void vc15_sync();
    void vc16_waitSync();
    void vc18_jump();
    void vc19_loop();
    void vc20_setRepeat();
    void vc21_endRepeat();
    virtual void vc22_setPalette();
    void vc23_setPriority();
    void vc24_setSpriteXY();
    void vc25_halt_sprite();
    void vc26_setSubWindow();
    void vc27_resetSprite();
    void vc28_playSFX();
    void vc29_stopAllSounds();
    void vc30_setFrameRate();
    void vc31_setWindow();
    void vc33_setMouseOn();
    void vc34_setMouseOff();
    void vc35_clearWindow();
    virtual void vc36_setWindowImage();
    void vc38_ifVarNotZero();
    void vc39_setVar();
    void vc40_scrollRight();
    void vc41_scrollLeft();
    void vc42_delayIfNotEQ();
 
    // Video Script Opcodes, Personal Nightmare
    void vc11_onStop();
    void vc36_pause();
    void vc39_volume();
    void vc44_enableBox();
    void vc45_disableBox();
    void vc46_maxBox();
    void vc48_specialEffect();
    void vc50_setBox();
    void vc55_scanFlag();
 
    // Video Script Opcodes, Elvira 1
    void vc17_waitEnd();
    void vc32_saveScreen();
    void vc37_pokePalette();
 
    // Video Script Opcodes, Elvira 2
    void vc43_ifBitSet();
    void vc44_ifBitClear();
    void vc45_setWindowPalette();
    void vc46_setPaletteSlot1();
    void vc47_setPaletteSlot2();
    void vc48_setPaletteSlot3();
    void vc49_setBit();
    void vc50_clearBit();
    void vc51_enableBox();
    void vc52_playSound();
    void vc53_dissolveIn();
    void vc54_dissolveOut();
    void vc55_moveBox();
    void vc56_fullScreen();
    void vc57_blackPalette();
    void vc58_checkCodeWheel();
    void vc58_changePriority();
    void vc59_ifEGA();
 
    // Video Script Opcodes, Waxworks
    void vc60_stopAnimation();
    void vc61();
    void vc62_fastFadeOut();
    virtual void vc63_fastFadeIn();
 
    // Video Script Opcodes, Simon 1
    void vc11_clearPathFinder();
    void vc17_setPathfinderItem();
    void vc32_copyVar();
    void vc37_addToSpriteY();
    void vc45_setSpriteX();
    void vc46_setSpriteY();
    void vc47_addToVar();
    virtual void vc48_setPathFinder();
    void vc59_ifSpeech();
    void vc61_setMaskImage();
 
    // Video Script Opcodes, Simon 2
    void vc56_delayLong();
    void vc59_stopAnimations();
    void vc64_ifSpeech();
    void vc65_slowFadeIn();
    void vc66_ifEqual();
    void vc67_ifLE();
    void vc68_ifGE();
    void vc69_playSeq();
    void vc70_joinSeq();
    void vc71_ifSeqWaiting();
    void vc72_segue();
    void vc73_setMark();
    void vc74_clearMark();
 
    // Video Script Opcodes, Feeble Files
    void vc75_setScale();
    void vc76_setScaleXOffs();
    void vc77_setScaleYOffs();
    void vc78_computeXY();
    void vc79_computePosNum();
    void vc80_setOverlayImage();
    void vc81_setRandom();
    void vc82_getPathValue();
    void vc83_playSoundLoop();
    void vc84_stopSoundLoop();
 
    void setScriptCondition(bool cond);
    bool getScriptCondition();
    void setScriptReturn(int ret);
    int getScriptReturn();
 
    // Opcodes, common
    void o_invalid();
    void o_at();
    void o_notAt();
    void o_carried();
    void o_notCarried();
    void o_isAt();
    void o_zero();
    void o_notZero();
    void o_eq();
    void o_notEq();
    void o_gt();
    void o_lt();
    void o_eqf();
    void o_notEqf();
    void o_ltf();
    void o_gtf();
    void o_chance();
    void o_isRoom();
    void o_isObject();
    void o_state();
    void o_oflag();
    void o_destroy();
    void o_place();
    void o_copyff();
    void o_clear();
    void o_let();
    void o_add();
    void o_sub();
    void o_addf();
    void o_subf();
    void o_mul();
    void o_div();
    void o_mulf();
    void o_divf();
    void o_mod();
    void o_modf();
    void o_random();
    void o_goto();
    void o_oset();
    void o_oclear();
    void o_putBy();
    void o_inc();
    void o_dec();
    void o_setState();
    void o_print();
    void o_message();
    void o_msg();
    void o_end();
    void o_done();
    void o_process();
    void o_when();
    void o_if1();
    void o_if2();
    void o_isCalled();
    void o_is();
    void o_debug();
    void o_comment();
    void o_haltAnimation();
    void o_restartAnimation();
    void o_getParent();
    void o_getNext();
    void o_getChildren();
    void o_picture();
    void o_loadZone();
    void o_killAnimate();
    void o_defWindow();
    void o_window();
    void o_cls();
    void o_closeWindow();
    void o_addBox();
    void o_delBox();
    void o_enableBox();
    void o_disableBox();
    void o_moveBox();
    void o_doIcons();
    void o_isClass();
    void o_setClass();
    void o_unsetClass();
    void o_waitSync();
    void o_sync();
    void o_defObj();
    void o_here();
    void o_doClassIcons();
    void o_playTune();
    void o_setAdjNoun();
    void o_saveUserGame();
    void o_loadUserGame();
    void o_copysf();
    void o_restoreIcons();
    void o_freezeZones();
    void o_placeNoIcons();
    void o_clearTimers();
    void o_setDollar();
    void o_isBox();
 
    int16 moreText(Item *i);
    void lobjFunc(Item *i, const char *f);
    uint confirmYesOrNo(uint16 x, uint16 y);
    uint continueOrQuit();
    void printScroll();
    virtual void printStats();
    void synchChain(Item *i);
 
protected:
    bool drawImage_clip(VC10_state *state);
 
    void drawImage_init(int16 image, uint16 palette, int16 x, int16 y, uint16 flags);
 
    virtual void drawImage(VC10_state *state);
    void drawBackGroundImage(VC10_state *state);
    void drawVertImage(VC10_state *state);
    void drawVertImageCompressed(VC10_state *state);
    void drawVertImageUncompressed(VC10_state *state);
    void remapElvira2AtariSTUIRegions(Graphics::Surface *screen);
    void setMoveRect(uint16 x, uint16 y, uint16 width, uint16 height);
 
    void horizontalScroll(VC10_state *state);
    void verticalScroll(VC10_state *state);
 
    Graphics::Surface *getBackendSurface() const;
    void updateBackendSurface(Common::Rect *area = 0) const;
    virtual void clearHiResTextLayer() {}
 
    int vcReadVarOrWord();
    uint vcReadNextWord(bool forceLERead = false);
    uint vcReadNextByte();
    uint vcReadVar(uint var);
    void vcWriteVar(uint var, int16 value);
    void vcSkipNextInstruction();
 
    int getScale(int16 y, int16 x);
    void checkScrollX(int16 x, int16 xpos);
    void checkScrollY(int16 y, int16 ypos);
    void centerScroll();
 
    virtual void clearVideoWindow(uint16 windowNum, uint16 color);
    void clearVideoBackGround(uint16 windowNum, uint16 color);
 
    void setPaletteSlot(uint16 srcOffs, uint8 dstOffs);
    bool isPNDayNightPaletteMode() const;
    uint8 getPNDesiredPaletteBank() const;
    void notePNClockValueChange();
    void resetPNRoomPaletteState();
    void buildPNPaletteTarget(uint16 selectorMask, uint16 *target) const;
    uint16 blendPNPaletteColor(uint16 source, uint16 target, uint8 steps) const;
    uint8 getPNDayNightControllerStage() const;
    void startPNDayNightController(uint16 selectorMask);
    void updatePNDayNightController(uint16 selectorMask);
    void applyPNDayNightPalette(const uint16 *palette);
    void checkOnStopTable();
    void checkWaitEndTable();
 
    virtual bool ifObjectHere(uint16 val);
    virtual bool ifObjectAt(uint16 a, uint16 b);
    virtual bool ifObjectState(uint16 a, int16 b);
 
    bool isVgaQueueEmpty();
    void haltAnimation();
    void restartAnimation();
    void addVgaEvent(uint16 num, uint8 type, const byte *codePtr, uint16 curSprite, uint16 curZoneNum);
    void deleteVgaEvent(VgaTimerEntry * vte);
    void processVgaEvents();
    void schedulePNFadeEvent();
    void removePNFadeEvent();
    void animateEvent(const byte *codePtr, uint16 curZoneNum, uint16 curSprite);
    void scrollEvent();
    void drawStuff(const byte *src, uint offs);
    void playerDamageEvent(VgaTimerEntry * vte, uint dx);
    void monsterDamageEvent(VgaTimerEntry * vte, uint dx);
 
    VgaSprite *findCurSprite();
 
    bool isSpriteLoaded(uint16 id, uint16 zoneNum);
 
    void resetWindow(WindowBlock *window);
    void freeBox(uint index);
 
    void sendWindow(uint a);
 
    virtual void colorWindow(WindowBlock *window);
    void colorBlock(WindowBlock *window, uint16 x, uint16 y, uint16 w, uint16 h);
 
    void restoreWindow(WindowBlock *window);
    void restoreBlock(uint16 left, uint16 top, uint16 right, uint16 bottom);
 
    byte *getBackBuf();
    byte *getBackGround();
    byte *getScaleBuf();
 
    byte *convertAmigaImage(VC10_state *state, bool compressed);
 
    bool decrunchFile(byte *src, byte *dst, uint32 size);
    void loadVGABeardFile(uint16 id);
    void loadVGAVideoFile(uint16 id, uint8 type, bool useError = true);
    bool loadVGASoundFile(uint16 id, uint8 type);
 
    void openGameFile();
    void readGameFile(void *dst, uint32 offs, uint32 size);
 
    virtual void timerProc();
 
    virtual void animateSprites();
 
    void dirtyClips();
    void dirtyClipCheck(int16 x, int16 y, int16 w, int16 h);
    void dirtyBackGround();
    void restoreBackGround();
    void saveBackGround(VgaSprite *vsp);
 
    void clearSurfaces();
    void displayScreen();
 
    void dumpVideoScript(const byte *src, bool singeOpcode);
    virtual void dumpVgaFile(const byte *vga);
    void dumpVgaScript(const byte *ptr, uint16 res, uint16 id);
    void dumpVgaScriptAlways(const byte *ptr, uint16 res, uint16 id);
 
    void dumpVgaBitmaps(uint16 zoneNum);
 
    void dumpSingleBitmap(int file, int image, const byte *offs, int w, int h, byte base);
    void dumpBitmap(const char *filename, const byte *offs, uint16 w, uint16 h, int flags, const byte *palette, byte base);
    void palLoad(byte *pal, const byte *vga1, int a, int b);
 
    void fillBackFromBackGround(uint16 height, uint16 width);
    void fillBackFromFront();
    void fillBackGroundFromBack();
    void fillBackGroundFromFront();
 
    virtual void doOutput(const byte *src, uint len);
    void clsCheck(WindowBlock *window);
 
    virtual void quickLoadOrSave();
 
    byte *vc10_uncompressFlip(const byte *src, uint16 w, uint16 h);
    byte *vc10_flip(const byte *src, uint16 w, uint16 h);
 
    Item *getNextItemPtrStrange();
 
    virtual bool loadGame(const Common::String &filename, bool restartMode = false);
    virtual bool saveGame(uint slot, const char *caption);
 
    void openTextWindow();
    void tidyIconArray(uint i);
 
    virtual void windowNewLine(WindowBlock *window);
    void windowScroll(WindowBlock *window);
    virtual void windowDrawChar(WindowBlock *window, uint x, uint y, byte chr);
 
    // Loads the MIDI data for the specified track. The forceSimon2GmData
    // parameter forces loading the MIDI data from the GM data set.
    // The useSimon2Remapping parameter activates GM to MT-32 instrument
    // remapping. These parameters are useful only for a specific
    // workaround (see AGOSEngine_Simon2::playMusic for more details).
    void loadMusic(uint16 track, bool forceSimon2GmData = false, bool useSimon2Remapping = false);
    void playModule(uint16 music);
    virtual void playMusic(uint16 music, uint16 track);
    void stopMusic();
 
    void delay(uint delay);
    void pause();
 
    void waitForMark(uint i);
    void scrollScreen();
 
    void decodeColumn(byte *dst, const byte *src, uint16 height, uint16 pitch);
    void decodeRow(byte *dst, const byte *src, uint16 width, uint16 pitch);
    void hitarea_stuff_helper_2();
    void fastFadeIn();
    void slowFadeIn();
    void fullFade();
 
    virtual void vcStopAnimation(uint16 zone, uint16 sprite);
 
    virtual bool confirmOverWrite(WindowBlock *window);
    int16 matchSaveGame(const char *name, uint16 max);
    void disableFileBoxes();
    virtual void userGame(bool load);
    void userGameBackSpace(WindowBlock *window, int x, byte b = 0);
    void fileError(WindowBlock *window, bool saveError);
 
    int countSaveGames();
 
    virtual Common::String genSaveName(int slot) const;
    void enterSaveLoadScreen(bool entering);
};
 
class AGOSEngine_PN : public AGOSEngine {
 
    Common::Error go() override;
    void demoSeq();
    void introSeq();
    void setupBoxes();
    int readfromline();
public:
    AGOSEngine_PN(OSystem *system, const AGOSGameDescription *gd);
    ~AGOSEngine_PN() override;
 
    void setupGame() override;
    void setupOpcodes() override;
    void setupVideoOpcodes(VgaOpcodeProc *op) override;
    void windowDrawChar(WindowBlock *window, uint x, uint y, byte chr) override;
    void saveInventoryPalette();
    void applyInventoryPalette();
    void restoreInventoryPalette();
    
    void executeOpcode(int opcode) override;
 
    int actCallD(int n);
 
    void opn_opcode00();
    void opn_add();
    void opn_sub();
    void opn_mul();
    void opn_div();
    void opn_opcode05();
    void opn_opcode06();
    void opn_opcode07();
    void opn_opcode08();
    void opn_opcode09();
    void opn_opcode10();
    void opn_opcode11();
    void opn_opcode12();
    void opn_opcode13();
    void opn_opcode14();
    void opn_opcode15();
    void opn_opcode16();
    void opn_lt();
    void opn_gt();
    void opn_eq();
    void opn_neq();
    void opn_opcode21();
    void opn_opcode22();
    void opn_opcode23();
    void opn_opcode24();
    void opn_opcode25();
    void opn_opcode26();
    void opn_opcode27();
    void opn_opcode28();
    void opn_opcode29();
    void opn_opcode30();
    void opn_opcode31();
    void opn_opcode32();
    void opn_opcode33();
    void opn_opcode34();
    void opn_opcode35();
    void opn_opcode36();
    void opn_opcode37();
    void opn_opcode38();
    void opn_opcode39();
    void opn_opcode40();
    void opn_opcode41();
    void opn_opcode42();
    void opn_opcode43();
    void opn_opcode44();
    void opn_opcode45();
    void opn_opcode46();
    void opn_opcode47();
    void opn_opcode48();
    void opn_opcode49();
    void opn_opcode50();
    void opn_opcode51();
    void opn_opcode52();
    void opn_opcode53();
    void opn_opcode54();
    void opn_opcode55();
    void opn_opcode56();
    void opn_opcode57();
    void opn_opcode62();
    void opn_opcode63();
 
protected:
    struct StackFrame {
        StackFrame *nextframe;
        int16 flag[6];
        int16 param[8];
        int16 classnum;
        uint8 *linpos;
        uint8 *lbase;
        int16 ll;
        int16 linenum;
        int16 process;
        int tagOfParentDoline;  
        StackFrame() { memset(this, 0, sizeof(*this)); }
    };
 
 
    StackFrame *_stackbase;
 
    int _tagOfActiveDoline; 
    int _dolineReturnVal;
 
    byte *_dataBase, *_textBase;
    uint32 _dataBaseSize, _textBaseSize;
 
    HitArea _invHitAreas[45];
 
    char _buffer[80];
    char _inputline[61];
    char _saveFile[20];
    char _sb[80];
    uint8 _wordcp[7];
 
    const char *_mouseString, *_mouseString1;
    char _objectName1[15], _objectName2[15];
    char _inMessage[20];
    char _placeMessage[15];
    bool _inputReady;
    bool _inputting;
    uint16 _intputCounter, _inputMax;
    uint16 _mousePrintFG;
    HitArea *_dragStore;
    uint8 _hitCalled;
 
    uint32 _quickptr[16];
    uint16 _quickshort[12];
 
    bool _noScanFlag;
    char _keyboardBuffer[61];
 
    uint16 _objects;
    int16 _objectCountS;
 
    int16 _bp;
    int16 _xofs;
    int16 _havinit;
    uint16 _seed;
 
    char *_curwrdptr;
    char *_inpp;
    int _fnst;
    int _procnum;
    int _linct;
    int _linembr;
    uint8 *_linebase;
    uint8 *_workptr;
 
    bool _keymapEnabled;
 
    uint16 getptr(uint32 pos);
    uint32 getlong(uint32 pos);
 
    void loadGamePcFile() override;
 
    int bitextract(uint32 ptr, int offs);
    int doaction();
    int doline(int needsave);
    int setposition(int process, int line);
    int varval();
 
    char *getMessage(char *msg, uint16 num);
    void getResponse(uint16 charNum, uint16 objNum, uint16 &msgNum1, uint16 &msgNum2);
    void getObjectName(char *v, uint16 x);
 
    void processor();
    void setbitf(uint32 ptr, int offs, int val);
    void setqptrs();
    void writeval(uint8 *ptr, int val);
 
    void addstack(int type);
    void dumpstack();
    void popstack(int type);
    void funccpy(int *store);
    void funcentry(int *storestore, int procn);
 
    int findentry();
    int findset();
    int gvwrd(uint8 *wptr, int mask);
    int wrdmatch(uint8 *word1, int mask1, uint8 *word2, int mask2);
 
    bool testContainer(uint16 a);
    bool testObvious(uint16 a);
    bool testSeen(uint16 a);
 
    bool ifObjectInInv(uint16 a);
    int inventoryOn(int val);
    int inventoryOff();
    void mouseHit();
    void execMouseHit(HitArea *ha);
    void hitBox1(HitArea *ha);
    void hitBox2(HitArea *ha);
    void hitBox3(HitArea *ha);
    void hitBox4(HitArea *ha);
    void hitBox5(HitArea *ha);
    void hitBox6(HitArea *ha);
    void hitBox7(HitArea *ha);
    void hitBox8(HitArea *ha);
    void hitBox9(HitArea *ha);
    void hitBox11(HitArea *ha);
 
    void drawIconHitBar();
    void iconPage();
    void printIcon(HitArea *ha, uint8 i, uint8 r);
    void windowPutChar(WindowBlock *window, byte c, byte b = 0) override;
 
    bool badload(int8 errorNum);
    int loadFile(const Common::String &name);
    int saveFile(const Common::String &name);
    void getFilename();
    void sysftodb();
    void dbtosysf();
 
    uint32 ftext(uint32 base, int n);
    char *unctok(char *c, int n);
    void uncomstr(char *c, uint32 x);
    void patok(int n);
    void pcf(uint8 ch);
    void pcl(const char *s);
    void pmesd(int n);
    void plocd(int n, int m);
    void pobjd(int n, int m);
    void ptext(uint32 tptr);
 
    void clearVideoWindow(uint16 windowNum, uint16 color) override;
    void setWindowImageEx(uint16 mode, uint16 vga_res) override;
 
    bool ifObjectHere(uint16 val) override;
    bool ifObjectAt(uint16 a, uint16 b) override;
    bool ifObjectState(uint16 a, int16 b) override;
 
    void boxController(uint x, uint y, uint mode) override;
    void timerProc() override;
 
    void addChar(uint8 chr);
    void clearCursor(WindowBlock *window);
    void clearInputLine();
    bool tryHandleDebugTimeCommand();
    bool tryParseDebugTimeCommand(const char *typed, uint16 &hour, uint16 &minute) const;
    void setDebugTime(uint16 hour, uint16 minute);
    void handleKeyboard();
    void handleMouseMoved() override;
    void interact(char *buffer, uint8 size);
 
    bool processSpecialKeys() override;
protected:
    typedef void (AGOSEngine_PN::*OpcodeProcPN) ();
    struct OpcodeEntryPN {
        OpcodeProcPN proc;
        const char *desc;
    };
 
    const OpcodeEntryPN *_opcodesPN;
};
 
class AGOSEngine_Elvira1 : public AGOSEngine {
public:
    AGOSEngine_Elvira1(OSystem *system, const AGOSGameDescription *gd);
    ~AGOSEngine_Elvira1() override;
    Common::Error init() override;
 
    void setupGame() override;
    void setupOpcodes() override;
    void setupVideoOpcodes(VgaOpcodeProc *op) override;
 
    void executeOpcode(int opcode) override;
 
    void oe1_present();
    void oe1_notPresent();
    void oe1_worn();
    void oe1_notWorn();
    void oe1_notCarried();
    void oe1_isNotAt();
    void oe1_sibling();
    void oe1_notSibling();
    void oe1_isIn();
    void oe1_isNotIn();
    void oe1_isPlayer();
    void oe1_canPut();
    void oe1_create();
    void oe1_copyof();
    void oe1_copyfo();
    void oe1_whatO();
    void oe1_weigh();
    void oe1_setFF();
    void oe1_moveDirn();
    void oe1_score();
    void oe1_look();
    void oe1_doClass();
    void oe1_pObj();
    void oe1_pName();
    void oe1_pcName();
    void oe1_isCalled();
    void oe1_cFlag();
    void oe1_rescan();
    void oe1_setUserItem();
    void oe1_getUserItem();
    void oe1_whereTo();
    void oe1_doorExit();
    void oe1_loadGame();
    void oe1_clearUserItem();
    void oe1_findMaster();
    void oe1_nextMaster();
    void oe1_animate();
    void oe1_stopAnimate();
    void oe1_menu();
    void oe1_addBox();
    void oe1_enableInput();
    void oe1_setTime();
    void oe1_ifTime();
    void oe1_playTune();
    void oe1_bitClear();
    void oe1_bitSet();
    void oe1_bitTest();
    void oe1_zoneDisk();
    void oe1_printStats();
    void oe1_stopTune();
    void oe1_printPlayerDamage();
    void oe1_printMonsterDamage();
    void oe1_pauseGame();
    void oe1_printPlayerHit();
    void oe1_printMonsterHit();
 
protected:
    typedef void (AGOSEngine_Elvira1::*OpcodeProcElvira1) ();
    struct OpcodeEntryElvira1 {
        OpcodeProcElvira1 proc;
        const char *desc;
    };
 
    const OpcodeEntryElvira1 *_opcodesElvira1;
 
    void drawIcon(WindowBlock *window, uint icon, uint x, uint y) override;
    void windowDrawChar(WindowBlock *window, uint x, uint y, byte chr) override;
    void addHiResTextDirtyRect(Common::Rect rect);
    void clearHiResTextLayer() override;
 
    Common::String genSaveName(int slot) const override;
 
    Graphics::FontSJIS *_sjisFont;
    Common::Array<Common::Rect> _sjisTextFields;
    uint16 _sjisCurChar;
};
 
class AGOSEngine_Elvira2 : public AGOSEngine_Elvira1 {
public:
    AGOSEngine_Elvira2(OSystem *system, const AGOSGameDescription *gd);
    //~AGOSEngine_Elvira2();
 
    void setupGame() override;
    void setupOpcodes() override;
    void setupVideoOpcodes(VgaOpcodeProc *op) override;
 
    void executeOpcode(int opcode) override;
 
    void oe2_moveDirn();
    void oe2_doClass();
    void oe2_pObj();
    void oe2_isCalled();
    void oe2_menu();
    void oe2_drawItem();
    void oe2_doTable();
    void oe2_pauseGame();
    void oe2_setDoorOpen();
    void oe2_setDoorClosed();
    void oe2_setDoorLocked();
    void oe2_ifDoorOpen();
    void oe2_ifDoorClosed();
    void oe2_ifDoorLocked();
    void oe2_storeItem();
    void oe2_getItem();
    void oe2_bSet();
    void oe2_bClear();
    void oe2_bZero();
    void oe2_bNotZero();
    void oe2_getOValue();
    void oe2_setOValue();
    void oe2_ink();
    void oe2_printStats();
    void oe2_setSuperRoom();
    void oe2_getSuperRoom();
    void oe2_setExitOpen();
    void oe2_setExitClosed();
    void oe2_setExitLocked();
    void oe2_ifExitOpen();
    void oe2_ifExitClosed();
    void oe2_ifExitLocked();
    void oe2_playEffect();
    void oe2_getDollar2();
    void oe2_setSRExit();
    void oe2_printPlayerDamage();
    void oe2_printMonsterDamage();
    void oe2_isAdjNoun();
    void oe2_b2Set();
    void oe2_b2Clear();
    void oe2_b2Zero();
    void oe2_b2NotZero();
 
    void printStats() override;
protected:
    typedef void (AGOSEngine_Elvira2::*OpcodeProcElvira2) ();
    struct OpcodeEntryElvira2 {
        OpcodeProcElvira2 proc;
        const char *desc;
    };
 
    const OpcodeEntryElvira2 *_opcodesElvira2;
 
    void readItemChildren(Common::SeekableReadStream *in, Item *item, uint tmp) override;
 
    bool loadGame(const Common::String &filename, bool restartMode = false) override;
    bool saveGame(uint slot, const char *caption) override;
 
    void addArrows(WindowBlock *window, uint8 num) override;
    void removeArrows(WindowBlock *window, uint num) override;
 
    void drawIcon(WindowBlock *window, uint icon, uint x, uint y) override;
    bool hasIcon(Item *item) override;
    uint itemGetIconNumber(Item *item) override;
    uint setupIconHitArea(WindowBlock *window, uint num, uint x, uint y, Item *itemPtr) override;
 
    void moveDirn(Item *i, uint x) override;
    int canPlace(Item *x, Item *y) override;
    int sizeOfRec(Item *o, int d) override;
    int weightOf(Item *x) override;
 
    int changeExitStates(SubSuperRoom *sr, int n, int d, uint16 s);
    uint16 getExitState(Item *item, uint16 x, uint16 d);
    void setExitState(Item *i, uint16 n, uint16 d, uint16 s);
    void setSRExit(Item *i, int n, int d, uint16 s);
 
    void handleMouseWheelUp() override;
    void handleMouseWheelDown() override;
 
    virtual void listSaveGames();
    bool confirmOverWrite(WindowBlock *window) override;
    void userGame(bool load) override;
    virtual int userGameGetKey(bool *b, uint maxChar);
 
    Common::String genSaveName(int slot) const override;
};
 
class AGOSEngine_Waxworks : public AGOSEngine_Elvira2 {
public:
    AGOSEngine_Waxworks(OSystem *system, const AGOSGameDescription *gd);
    //~AGOSEngine_Waxworks();
 
    void setupGame() override;
    void setupOpcodes() override;
    void setupVideoOpcodes(VgaOpcodeProc *op) override;
 
    void executeOpcode(int opcode) override;
 
    void boxTextMessage(const char *x);
    void boxTextMsg(const char *x);
    void printBox();
    uint16 getBoxSize();
    uint16 checkFit(char *Ptr, int width, int lines);
 
    void oww_goto();
    void oww_addTextBox();
    void oww_setShortText();
    void oww_setLongText();
    void oww_printLongText();
    void oww_whereTo();
    void oww_textMenu();
    void oww_pauseGame();
    void oww_boxMessage();
    void oww_boxMsg();
    void oww_boxLongText();
    void oww_printBox();
    void oww_boxPObj();
    void oww_lockZones();
    void oww_unlockZones();
 
protected:
    typedef void (AGOSEngine_Waxworks::*OpcodeProcWaxworks) ();
    struct OpcodeEntryWaxworks {
        OpcodeProcWaxworks proc;
        const char *desc;
    };
 
    const OpcodeEntryWaxworks *_opcodesWaxworks;
 
    bool _boxCR;
    char _boxBuffer[310];
    char *_boxBufferPtr;
    int _boxLineCount;
    int _lineCounts[6];
    char *_linePtrs[6];
 
    void drawIcon(WindowBlock *window, uint icon, uint x, uint y) override;
 
    void boxController(uint x, uint y, uint mode) override;
 
    void addArrows(WindowBlock *window, uint8 num) override;
    void removeArrows(WindowBlock *window, uint num) override;
 
    uint setupIconHitArea(WindowBlock *window, uint num, uint x, uint y, Item *itemPtr) override;
 
    bool loadTablesIntoMem(uint16 subrId) override;
 
    void moveDirn(Item *i, uint x) override;
 
    bool confirmOverWrite(WindowBlock *window) override;
 
    Common::String genSaveName(int slot) const override;
};
 
class AGOSEngine_Simon1 : public AGOSEngine_Waxworks {
private:
    // Simon 1 DOS CD and Acorn CD GMF data sizes.
    static const int SIMON1_GMF_SIZE[];
 
public:
    AGOSEngine_Simon1(OSystem *system, const AGOSGameDescription *gd);
    //~AGOSEngine_Simon1();
 
    void setupGame() override;
    void setupOpcodes() override;
    void setupVideoOpcodes(VgaOpcodeProc *op) override;
 
    void executeOpcode(int opcode) override;
 
    void vc22_setPalette() override;
 
    // Opcodes, Simon 1
    void os1_animate();
    void os1_pauseGame();
    void os1_screenTextBox();
    void os1_screenTextMsg();
    void os1_playEffect();
    void os1_screenTextPObj();
    void os1_getPathPosn();
    void os1_scnTxtLongText();
    void os1_mouseOn();
    void os1_mouseOff();
    void os1_loadBeard();
    void os1_unloadBeard();
    void os1_unloadZone();
    void os1_loadStrings();
    void os1_unfreezeZones();
    void os1_specialFade();
 
protected:
    typedef void (AGOSEngine_Simon1::*OpcodeProcSimon1) ();
    struct OpcodeEntrySimon1 {
        OpcodeProcSimon1 proc;
        const char *desc;
    };
 
    const OpcodeEntrySimon1 *_opcodesSimon1;
 
    void drawImage(VC10_state *state) override;
    void drawMaskedImage(VC10_state *state);
    void draw32ColorImage(VC10_state *state);
 
    void dumpVgaFile(const byte *vga) override;
 
    bool loadSimonAcornFloppyDemoPalette(Common::Array<byte> &outPalette);
    bool _simonAcornFloppyDemoPaletteLoaded = false;
    void patchSimonAcornFloppyDemoPalettes();
    
    void clearName() override;
 
    void handleMouseWheelUp() override;
    void handleMouseWheelDown() override;
 
    void drawIcon(WindowBlock *window, uint icon, uint x, uint y) override;
 
    void initMouse() override;
    void handleMouseMoved() override;
 
    void addArrows(WindowBlock *window, uint8 num) override;
    void removeArrows(WindowBlock *window, uint num) override;
 
    uint setupIconHitArea(WindowBlock *window, uint num, uint x, uint y, Item *itemPtr) override;
 
    virtual void playSpeech(uint16 speechId, uint16 vgaSpriteId);
 
    void listSaveGames() override;
    void userGame(bool load) override;
    int userGameGetKey(bool *b, uint maxChar) override;
 
    void playMusic(uint16 music, uint16 track) override;
    void playMidiSfx(uint16 sound) override;
 
    void vcStopAnimation(uint16 zone, uint16 sprite) override;
 
    Common::String genSaveName(int slot) const override;
};
 
class AGOSEngine_Simon2 : public AGOSEngine_Simon1 {
public:
    AGOSEngine_Simon2(OSystem *system, const AGOSGameDescription *gd);
    //~AGOSEngine_Simon2();
 
    void setupGame() override;
    void setupOpcodes() override;
    void setupVideoOpcodes(VgaOpcodeProc *op) override;
 
    void executeOpcode(int opcode) override;
 
    void os2_printLongText();
    void os2_rescan();
    void os2_animate();
    void os2_stopAnimate();
    void os2_playTune();
    void os2_screenTextPObj();
    void os2_mouseOn();
    void os2_mouseOff();
    void os2_isShortText();
    void os2_clearMarks();
    void os2_waitMark();
 
protected:
    typedef void (AGOSEngine_Simon2::*OpcodeProcSimon2) ();
    struct OpcodeEntrySimon2 {
        OpcodeProcSimon2 proc;
        const char *desc;
    };
 
    const OpcodeEntrySimon2 *_opcodesSimon2;
 
    void clearName() override;
 
    void drawIcon(WindowBlock *window, uint icon, uint x, uint y) override;
 
    void addArrows(WindowBlock *window, uint8 num) override;
    uint setupIconHitArea(WindowBlock *window, uint num, uint x, uint y, Item *itemPtr) override;
 
    void clearVideoWindow(uint16 windowNum, uint16 color) override;
 
    void playSpeech(uint16 speechId, uint16 vgaSpriteId) override;
    // This overload plays the music track specified in the second parameter.
    // The first parameter is ignored; music data must be loaded using the
    // loadMusic method before calling this method.
    void playMusic(uint16 music, uint16 track) override;
 
    Common::String genSaveName(int slot) const override;
};
 
#ifdef ENABLE_AGOS2
class AGOSEngine_Feeble : public AGOSEngine_Simon2 {
public:
    AGOSEngine_Feeble(OSystem *system, const AGOSGameDescription *gd);
    ~AGOSEngine_Feeble() override;
 
    void setupGame() override;
    void setupOpcodes() override;
    void setupVideoOpcodes(VgaOpcodeProc *op) override;
 
    void executeOpcode(int opcode) override;
 
    void vc36_setWindowImage() override;
    void vc48_setPathFinder() override;
 
    void off_chance();
    void off_jumpOut();
    void off_addTextBox();
    void off_printLongText();
    void off_addBox();
    void off_oracleTextDown();
    void off_oracleTextUp();
    void off_ifTime();
    void off_setTime();
    void off_saveUserGame();
    void off_loadUserGame();
    void off_listSaveGames();
    void off_checkCD();
    void off_screenTextBox();
    void off_b2Set();
    void off_isAdjNoun();
    void off_hyperLinkOn();
    void off_hyperLinkOff();
    void off_checkPaths();
    void off_screenTextPObj();
    void off_mouseOn();
    void off_mouseOff();
    void off_loadVideo();
    void off_playVideo();
    void off_centerScroll();
    void off_resetPVCount();
    void off_setPathValues();
    void off_stopClock();
    void off_restartClock();
    void off_setColor();
    void off_b3Set();
    void off_b3Clear();
    void off_b3Zero();
    void off_b3NotZero();
 
protected:
    friend class MoviePlayer;
    friend class MoviePlayerDXA;
    friend class MoviePlayerSMK;
 
    typedef void (AGOSEngine_Feeble::*OpcodeProcFeeble) ();
    struct OpcodeEntryFeeble {
        OpcodeProcFeeble proc;
        const char *desc;
    };
 
    const OpcodeEntryFeeble *_opcodesFeeble;
 
    MoviePlayer *_moviePlayer;
 
    uint8 _interactiveVideo;
    uint16 _vgaCurSpritePriority;
 
    uint16 to16Wrapper(uint value) override;
    uint16 readUint16Wrapper(const void *src) override;
    uint32 readUint32Wrapper(const void *src) override;
 
    void setLoyaltyRating(byte rating);
 
    void playVideo(const char *filename, bool lastSceneUsed = false);
    void stopInteractiveVideo();
 
    void drawImage(VC10_state *state) override;
    void scaleClip(int16 h, int16 w, int16 y, int16 x, int16 scrollY);
 
    void handleMouseWheelUp() override;
    void handleMouseWheelDown() override;
 
    void drawMousePart(int image, byte x, byte y);
    void initMouse() override;
    void drawMousePointer() override;
 
    void animateSprites() override;
    void animateSpritesByY();
 
    void oracleLogo();
    void swapCharacterLogo();
    void timerProc() override;
 
    void addArrows(WindowBlock *window, uint8 num) override;
    uint setupIconHitArea(WindowBlock *window, uint num, uint x, uint y, Item *itemPtr) override;
 
    void resetVerbs() override;
    void setVerb(HitArea * ha) override;
    void hitarea_leave(HitArea * ha, bool state = false) override;
    void invertBox(HitArea *ha, bool state);
 
    void windowNewLine(WindowBlock *window) override;
    void windowDrawChar(WindowBlock *window, uint x, uint y, byte chr) override;
 
    void clearName() override;
 
    void drawIconArray(uint i, Item *itemPtr, int line, int classMask) override;
 
    void colorWindow(WindowBlock *window) override;
 
    void dumpVgaFile(const byte *vga) override;
 
    void doOutput(const byte *src, uint len) override;
 
    void printScreenText(uint vgaSpriteId, uint color, const char *stringPtr, int16 x, int16 y, int16 width) override;
 
    void printInteractText(uint16 num, const char *string);
    void sendInteractText(uint16 num, MSVC_PRINTF const char *fmt, ...) GCC_PRINTF(3, 4);
 
    void checkLinkBox();
    void hyperLinkOn(uint16 x);
    void hyperLinkOff();
    void linksUp();
    void linksDown();
 
    void runSubroutine101() override;
 
    void checkUp(WindowBlock *window);
    void checkDown(WindowBlock *window);
    void inventoryUp(WindowBlock *window) override;
    void inventoryDown(WindowBlock *window) override;
 
    void oracleTextUp();
    void oracleTextDown();
    void scrollOracle();
    void scrollOracleUp();
    void scrollOracleDown();
 
    void listSaveGamesFeeble();
    void saveUserGame(int slot);
    void windowBackSpace(WindowBlock *window);
 
    Common::String genSaveName(int slot) const override;
    void quickLoadOrSave() override;
};
 
class AGOSEngine_FeebleDemo : public AGOSEngine_Feeble {
public:
    AGOSEngine_FeebleDemo(OSystem *system, const AGOSGameDescription *gd);
 
protected:
    bool _filmMenuUsed;
 
    Common::Error go() override;
 
    void initMouse() override;
    void drawMousePointer() override;
 
    void exitMenu();
    void filmMenu();
    void handleText();
    void handleWobble();
    void mainMenu();
    void startInteractiveVideo(const char *filename);
    void waitForSpace();
};
 
class AGOSEngine_PuzzlePack : public AGOSEngine_Feeble {
public:
    AGOSEngine_PuzzlePack(OSystem *system, const AGOSGameDescription *gd);
    //~AGOSEngine_PuzzlePack();
 
    void setupGame() override;
    void setupOpcodes() override;
 
    void executeOpcode(int opcode) override;
 
    void vc3_loadSprite() override;
    void vc63_fastFadeIn() override;
 
    void opp_iconifyWindow();
    void opp_restoreOopsPosition();
    void opp_loadMouseImage();
    void opp_message();
    void opp_setShortText();
    void opp_loadHiScores();
    void opp_checkHiScores();
    void opp_sync();
    void opp_saveUserGame();
    void opp_loadUserGame();
    void opp_playTune();
    void opp_saveOopsPosition();
    void opp_resetGameTime();
    void opp_resetPVCount();
    void opp_setPathValues();
    void opp_pauseClock();
 
protected:
    typedef void (AGOSEngine_PuzzlePack::*OpcodeProcPuzzlePack) ();
    struct OpcodeEntryPuzzlePack {
        OpcodeProcPuzzlePack proc;
        const char *desc;
    };
 
    const OpcodeEntryPuzzlePack *_opcodesPuzzlePack;
 
    bool _oopsValid;
    uint32 _gameTime;
 
    void initMouse() override;
    void handleMouseMoved() override;
    void drawMousePointer() override;
 
    void resetVerbs() override;
 
    void loadMouseImage();
 
    void startOverlayAnims();
    void startAnOverlayAnim();
 
    void printInfoText(const char *itemText);
 
    Common::String genSaveName(int slot) const override;
};
 
 
class AGOSEngine_DIMP : public AGOSEngine_PuzzlePack {
public:
    AGOSEngine_DIMP(OSystem *system, const AGOSGameDescription *gd);
    //~AGOSEngine_DIMP();
 
    void setupOpcodes() override;
 
    void executeOpcode(int opcode) override;
 
protected:
    typedef void (AGOSEngine_DIMP::*OpcodeProcDIMP) ();
    struct OpcodeEntryDIMP {
        OpcodeProcDIMP proc;
        const char *desc;
    };
 
    const OpcodeEntryDIMP *_opcodesDIMP;
 
    int16 _iconToggleCount, _voiceCount;
    uint32 _lastTickCount;
    uint32 _startSecondCount, _tSecondCount;
 
    void odp_saveUserGame();
    void odp_loadUserGame();
 
    void dimpIdle();
    void timerProc() override;
 
};
#endif
 
} // End of namespace AGOS
 
#endif