touche.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 TOUCHE_TOUCHE_H
#define TOUCHE_TOUCHE_H

#include "common/array.h"
#include "common/endian.h"
#include "common/file.h"
#include "common/random.h"
#include "common/rect.h"
#include "common/util.h"

#include "audio/mixer.h"

#include "engines/engine.h"

#include "touche/console.h"

namespace Touche {

enum TOUCHEAction {
    kToucheActionNone,
    kToucheActionYes,
    kToucheActionSkipOrQuit,
    kToucheActionOpenOptions,
    kToucheActionEnableFastWalk,
    kToucheActionDisableFastWalk,
    kToucheActionToggleFastMode,
    kToucheActionToggleTalkTextMode,
    kToucheActionSkipDialogue
};

struct Area {
    Common::Rect r;
    int16 srcX, srcY;

    Area() {
        srcX = srcY = 0;
    }

    Area(int16 x, int16 y, int16 w, int16 h) {
        r = Common::Rect(x, y, x + w, y + h);
        srcX = srcY = 0;
    }

    bool clip(const Common::Rect &rect) {
        const int dx = r.left - rect.left;
        if (dx < 0) {
            srcX -= dx;
        }
        const int dy = r.top - rect.top;
        if (dy < 0) {
            srcY -= dy;
        }
        if (rect.left > r.left) {
            r.left = rect.left;
        }
        if (rect.top > r.top) {
            r.top = rect.top;
        }
        if (rect.right < r.right) {
            r.right = rect.right;
        }
        if (rect.bottom < r.bottom) {
            r.bottom = rect.bottom;
        }
        return (r.right > r.left && r.bottom > r.top);
    }
};

struct KeyChar {
    uint16 num;
    uint16 flags;
    int16 currentAnimCounter;
    int16 strNum;
    int16 walkDataNum;
    int16 spriteNum;
    Common::Rect prevBoundingRect;
    Common::Rect boundingRect;
    int16 xPos;
    int16 yPos;
    int16 zPos;
    int16 xPosPrev;
    int16 yPosPrev;
    int16 zPosPrev;
    int16 prevWalkDataNum;
    uint16 textColor;
    int16 inventoryItems[4];
    int16 money;
    int16 pointsDataNum;
    int16 currentWalkBox;
    uint16 prevPointsDataNum;
    int16 currentAnim;
    int16 facingDirection;
    int16 currentAnimSpeed;
    int16 framesList[16];
    int16 framesListCount;
    int16 currentFrame;
    int16 anim1Start;
    int16 anim1Count;
    int16 anim2Start;
    int16 anim2Count;
    int16 anim3Start;
    int16 anim3Count;
    int16 followingKeyCharNum;
    int16 followingKeyCharPos;
    uint16 sequenceDataIndex;
    uint16 sequenceDataOffset;
    int16 walkPointsListIndex;
    int16 walkPointsList[40];
    uint16 scriptDataStartOffset;
    uint16 scriptDataOffset;
    int16 *scriptStackPtr;
    int16 delay;
    int16 waitingKeyChar;
    int16 waitingKeyCharPosTable[3];
    int16 scriptStackTable[40];
};

struct Script {
    uint8 opcodeNum;
    uint32 dataOffset;
    int16 keyCharNum;
    uint8 *dataPtr;
    int16 *stackDataPtr;
    int16 *stackDataBasePtr;
    int16 quitFlag;
    int16 stackDataTable[500];

    void init(uint8 *data) {
        dataPtr = data;
        stackDataPtr = stackDataBasePtr = &stackDataTable[499];
        dataOffset = 0;
        quitFlag = 0;
    }

    uint8 readByte(uint32 offs) const {
        return *(dataPtr + offs);
    }

    int16 readWord(uint32 offs) const {
        return READ_LE_UINT16(dataPtr + offs);
    }

    uint8 readNextByte() {
        uint8 val = readByte(dataOffset);
        ++dataOffset;
        return val;
    }

    int16 readNextWord() {
        int16 val = readWord(dataOffset);
        dataOffset += 2;
        return val;
    }
};

struct TalkEntry {
    int16 otherKeyChar;
    int16 talkingKeyChar;
    int16 num;
};

struct ConversationChoice {
    int16 num;
    int16 msg;
};

struct AnimationEntry {
    int16 num;
    int16 x;
    int16 y;
    int16 dx;
    int16 dy;
    int16 posNum;
    int16 delayCounter;
    int16 displayCounter;
    Common::Rect displayRect;

    void clear() {
        num = 0;
        x = 0;
        y = 0;
        dx = 0;
        dy = 0;
        posNum = 0;
        delayCounter = 0;
        displayRect.top = 0;
        displayRect.left = 0;
        displayRect.bottom = 0;
        displayRect.right = 0;
    }
};

struct SequenceEntry {
    int16 sprNum;
    int16 seqNum;
};

struct SpriteData {
    uint32 size;
    uint8 *ptr;
    uint16 bitmapWidth;
    uint16 bitmapHeight;
    uint16 w;
    uint16 h;
};

struct InventoryState {
    int16 displayOffset;
    int16 lastItem;
    int16 itemsPerLine;
    int16 *itemsList;
};

struct ProgramPointData {
    int16 x, y, z;
    int16 order;
};

struct ProgramWalkData {
    int16 point1;
    int16 point2;
    int16 clippingRect;
    int16 area1;
    int16 area2;
};

struct ProgramAreaData {
    Area area;
    int16 id;
    int16 state;
    int16 animCount;
    int16 animNext;
};

struct ProgramBackgroundData {
    Area area;
    int16 type;
    int16 offset;
    int16 scaleMul;
    int16 scaleDiv;
};

struct ProgramHitBoxData {
    int16 item;
    int16 talk;
    uint16 state;
    int16 str;
    int16 defaultStr;
    int16 actions[8];
    Common::Rect hitBoxes[2];
};

struct ProgramActionScriptOffsetData {
    int16 object1;
    int16 action;
    int16 object2;
    uint16 offset;
};

struct ProgramKeyCharScriptOffsetData {
    int16 keyChar;
    uint16 offset;
};

struct ProgramConversationData {
    int16 num;
    uint16 offset;
    int16 msg;
};

enum {
    kDebugEngine   = 1 << 0,
    kDebugGraphics = 1 << 1,
    kDebugResource = 1 << 2,
    kDebugOpcodes  = 1 << 3,
    kDebugMenu     = 1 << 4,
    kDebugCharset  = 1 << 5
};

enum ResourceType {
    kResourceTypeRoomImage = 0,
    kResourceTypeSequence,
    kResourceTypeSpriteImage,
    kResourceTypeIconImage,
    kResourceTypeRoomInfo,
    kResourceTypeProgram,
    kResourceTypeMusic,
    kResourceTypeSound
};

enum TalkMode {
    kTalkModeTextOnly = 0,
    kTalkModeVoiceOnly,
    kTalkModeVoiceAndText,
    kTalkModeCount
};

enum ScriptFlag {
    kScriptStopped = 1 << 0,
    kScriptPaused  = 1 << 1
};

enum SaveLoadMode {
    kSaveGameState = 0,
    kLoadGameState
};

enum InventoryArea {
    kInventoryCharacter = 0,
    kInventoryMoneyDisplay,
    kInventoryGoldCoins,
    kInventorySilverCoins,
    kInventoryMoney,
    kInventoryScroller1,
    kInventoryObject1,
    kInventoryObject2,
    kInventoryObject3,
    kInventoryObject4,
    kInventoryObject5,
    kInventoryObject6,
    kInventoryScroller2
};

enum {
    kScreenWidth = 640,
    kScreenHeight = 400,
    kRoomHeight = 352,
    kStartupEpisode = 90,
    // TODO: If the following truncation is intentional (it probably is) it should be clearly marked as such
    kCycleDelay = 1000 / (1193180 / 32768),
    kIconWidth = 58,
    kIconHeight = 42,
    kCursorWidth = 58,
    kCursorHeight = 42,
    kTextHeight = 16,
    kMaxProgramDataSize = 61440,
    kMaxSaveStates = 100
};

enum StringType {
    kStringTypeDefault,
    kStringTypeConversation
};

enum GameState {
    kGameStateGameLoop,
    kGameStateOptionsDialog,
    kGameStateQuitDialog,
    kGameStateNone
};

enum ActionId {
    kActionNone,

    // settings menu
    kActionLoadMenu,
    kActionSaveMenu,
    kActionRestartGame,
    kActionPlayGame,
    kActionQuitGame,
    kActionTextOnly,
    kActionVoiceOnly,
    kActionTextAndVoice,
    kActionLowerVolume,
    kActionUpperVolume,

    // saveLoad menu
    kActionGameState1,
    kActionGameState2,
    kActionGameState3,
    kActionGameState4,
    kActionGameState5,
    kActionGameState6,
    kActionGameState7,
    kActionGameState8,
    kActionGameState9,
    kActionGameState10,
    kActionScrollUpSaves,
    kActionScrollDownSaves,
    kActionPerformSaveLoad,
    kActionCancelSaveLoad
};

enum MenuMode {
    kMenuSettingsMode = 0,
    kMenuLoadStateMode,
    kMenuSaveStateMode
};

enum ButtonFlags {
    kButtonBorder = 1 << 0,
    kButtonText   = 1 << 1,
    kButtonArrow  = 1 << 2
};

struct Button {
    int x, y;
    int w, h;
    ActionId action;
    int data;
    uint8 flags;
};

struct MenuData {
    MenuMode mode;
    Button *buttonsTable;
    uint buttonsCount;
    bool quit;
    bool exit;
    char saveLoadDescriptionsTable[kMaxSaveStates][33];

    void removeLastCharFromDescription(int slot) {
        char *description = saveLoadDescriptionsTable[slot];
        int descriptionLen = strlen(description);
        if (descriptionLen > 0) {
            --descriptionLen;
            description[descriptionLen] = 0;
        }
    }

    void addCharToDescription(int slot, char chr) {
        char *description = saveLoadDescriptionsTable[slot];
        int descriptionLen = strlen(description);
        if (descriptionLen < 32 && Common::isPrint(chr)) {
            description[descriptionLen] = chr;
            description[descriptionLen + 1] = 0;
        }
    }

    const Button *findButtonUnderCursor(int cursorX, int cursorY) const {
        for (uint i = 0; i < buttonsCount; ++i) {
            const Button *button = &buttonsTable[i];
            if (cursorX >= button->x && cursorX < button->x + button->w &&
                cursorY >= button->y && cursorY < button->y + button->h) {
                    return button;
            }
        }
        return 0;
    }
};


void readGameStateDescription(Common::ReadStream *f, char *description, int len);
Common::String generateGameStateFileName(const char *target, int slot, bool prefixOnly = false);
int getGameStateFileSlot(const char *filename);

class MidiPlayer;

class ToucheEngine: public Engine {
public:

    enum {
        NUM_FLAGS = 2000,
        NUM_KEYCHARS = 32,
        NUM_SPRITES = 7,
        NUM_SEQUENCES = 7,
        NUM_CONVERSATION_CHOICES = 40,
        NUM_TALK_ENTRIES = 16,
        NUM_ANIMATION_ENTRIES = 4,
        NUM_INVENTORY_ITEMS = 100,
        NUM_DIRTY_RECTS = 30,
        NUM_DIRECTIONS = 135
    };

    typedef void (ToucheEngine::*OpcodeProc)();

    ToucheEngine(OSystem *system, Common::Language language);
    ~ToucheEngine() override;

    // Engine APIs
    Common::Error run() override;
    bool hasFeature(EngineFeature f) const override;
    void syncSoundSettings() override;

protected:

    void restart();
    void readConfigurationSettings();
    void writeConfigurationSettings();
    void mainLoop();
    void processEvents(bool handleKeyEvents = true);
    void runCycle();
    int16 getRandomNumber(int max);
    void changePaletteRange();
    void playSoundInRange();
    void resetSortedKeyCharsTable();
    void setupEpisode(int num);
    void setupNewEpisode();
    void drawKeyChar(KeyChar *key);
    void sortKeyChars();
    void runKeyCharScript(KeyChar *key);
    void runCurrentKeyCharScript(int mode);
    void executeScriptOpcode(int16 param);
    void initKeyChars(int keyChar);
    void setKeyCharTextColor(int keyChar, uint16 color);
    void waitForKeyCharPosition(int keyChar);
    void setKeyCharBox(int keyChar, int value);
    void setKeyCharFrame(int keyChar, int16 type, int16 value1, int16 value2);
    void setKeyCharFacingDirection(int keyChar, int16 dir);
    void initKeyCharScript(int keyChar, int16 spriteNum, int16 seqDataIndex, int16 seqDataOffs);
    uint16 findProgramKeyCharScriptOffset(int keyChar) const;
    bool scrollRoom(int keyChar);
    void drawIcon(int x, int y, int num);
    void centerScreenToKeyChar(int keyChar);
    void waitForKeyCharsSet();
    void redrawRoom();
    void fadePalette(int firstColor, int colorCount, int scale, int scaleInc, int fadingStepsCount);
    void fadePaletteFromFlags();
    void moveKeyChar(uint8 *dst, int dstPitch, KeyChar *key);
    void changeKeyCharFrame(KeyChar *key, int keyChar);
    void setKeyCharRandomFrame(KeyChar *key);
    void setKeyCharMoney();
    const char *getString(int num) const;
    int getStringWidth(int num) const;
    void drawString(uint16 color, int x, int y, int16 num, StringType strType = kStringTypeDefault);
    void drawGameString(uint16 color, int x1, int y, const char *str);
    int restartKeyCharScriptOnAction(int action, int obj1, int obj2);
    void buildSpriteScalingTable(int z1, int z2);
    void drawSpriteOnBackdrop(int num, int x, int y);
    void updateTalkFrames(int keyChar);
    void setKeyCharTalkingFrame(int keyChar);
    void lockUnlockHitBox(int num, int lock);
    void drawHitBoxes();
    void showCursor(bool show);
    void setCursor(int num);
    void setDefaultCursor(int num);
    void handleLeftMouseButtonClickOnInventory();
    void handleRightMouseButtonClickOnInventory();
    void handleMouseInput(int flag);
    void handleMouseClickOnRoom(int flag);
    void handleMouseClickOnInventory(int flag);
    void scrollScreenToPos(int num);
    void clearRoomArea();
    void startNewMusic();
    void startNewSound();
    void updateSpeech();
    int handleActionMenuUnderCursor(const int16 *actions, int offs, int y, int str);

    void redrawBackground();
    void addRoomArea(int num, int flag);
    void updateRoomAreas(int num, int flags);
    void setRoomAreaState(int num, uint16 state);
    void findAndRedrawRoomRegion(int num);
    void updateRoomRegions();
    void redrawRoomRegion(int num, bool markForRedraw);

    void initInventoryObjectsTable();
    void initInventoryLists();
    void setupInventoryAreas();
    void drawInventory(int index, int flag);
    void drawAmountOfMoneyInInventory();
    void packInventoryItems(int index);
    void appendItemToInventoryList(int index);
    void addItemToInventory(int inventory, int16 item);
    void removeItemFromInventory(int inventory, int16 item);

    void resetTalkingVars();
    int updateKeyCharTalk(int pauseFlag);
    const char *formatTalkText(int *y, int *h, const char *text);
    void addToTalkTable(int talkingKeyChar, int num, int otherKeyChar);
    void removeFromTalkTable(int keyChar);
    void addConversationChoice(int16 num);
    void removeConversationChoice(int16 num);
    void runConversationScript(uint16 offset);
    void findConversationByNum(int16 num);
    void clearConversationChoices();
    void scrollDownConversationChoice();
    void scrollUpConversationChoice();
    void drawCharacterConversation();
    void drawConversationString(int num, uint16 color);
    void clearConversationArea();
    void setupConversationScript(int num);
    void handleConversation();

    void buildWalkPointsList(int keyChar);
    int findWalkDataNum(int pointNum1, int pointNum2);
    void changeWalkPath(int num1, int num2, int16 val);
    void adjustKeyCharPosToWalkBox(KeyChar *key, int moveType);
    void lockWalkPath(int num1, int num2);
    void unlockWalkPath(int num1, int num2);
    void resetPointsData(int num);
    bool sortPointsData(int num1, int num2);
    void updateKeyCharWalkPath(KeyChar *key, int16 dx, int16 dy, int16 dz);
    void markWalkPoints(int keyChar);
    void buildWalkPath(int dstPosX, int dstPosY, int keyChar);

    void addToAnimationTable(int num, int posNum, int keyChar, int delayCounter);
    void copyAnimationImage(int dstX, int dstY, int w, int h, const uint8 *src, int srcX, int srcY, int fillColor);
    void drawAnimationImage(AnimationEntry *anim);
    void processAnimationTable();
    void clearAnimationTable();

    void addToDirtyRect(const Common::Rect &r);
    void clearDirtyRects();
    void setPalette(int firstColor, int colorCount, int redScale, int greenScale, int blueScale);
    void updateScreenArea(int x, int y, int w, int h);
    void updateEntireScreen();
    void updateDirtyScreenAreas();
    void updatePalette();

    void saveGameStateData(Common::WriteStream *stream);
    void loadGameStateData(Common::ReadStream *stream);
    Common::Error saveGameState(int num, const Common::String &description, bool isAutosave = false) override;
    Common::Error loadGameState(int num) override;
    bool canLoadGameStateCurrently(Common::U32String *msg = nullptr) override;
    bool canSaveGameStateCurrently(Common::U32String *msg = nullptr) override;
    Common::String getSaveStateName(int slot) const override {
        return Common::String::format("%s.%d", _targetName.c_str(), slot);
    }

    void setupOpcodes();
    void op_nop();
    void op_jnz();
    void op_jz();
    void op_jmp();
    void op_true();
    void op_false();
    void op_push();
    void op_not();
    void op_add();
    void op_sub();
    void op_mul();
    void op_div();
    void op_mod();
    void op_and();
    void op_or();
    void op_neg();
    void op_testGreater();
    void op_testEquals();
    void op_testLower();
    void op_fetchScriptWord();
    void op_testGreaterOrEquals();
    void op_testLowerOrEquals();
    void op_testNotEquals();
    void op_endConversation();
    void op_stopScript();
    void op_getFlag();
    void op_setFlag();
    void op_fetchScriptByte();
    void op_getKeyCharWalkBox();
    void op_startSound();
    void op_moveKeyCharToPos();
    void op_loadRoom();
    void op_updateRoom();
    void op_startTalk();
    void op_loadSprite();
    void op_loadSequence();
    void op_setKeyCharBox();
    void op_initKeyCharScript();
    void op_setKeyCharFrame();
    void op_setKeyCharDirection();
    void op_clearConversationChoices();
    void op_addConversationChoice();
    void op_removeConversationChoice();
    void op_getInventoryItem();
    void op_setInventoryItem();
    void op_startEpisode();
    void op_setConversationNum();
    void op_enableInput();
    void op_disableInput();
    void op_faceKeyChar();
    void op_getKeyCharCurrentAnim();
    void op_getCurrentKeyChar();
    void op_isKeyCharActive();
    void op_setPalette();
    void op_changeWalkPath();
    void op_lockWalkPath();
    void op_initializeKeyChar();
    void op_setupWaitingKeyChars();
    void op_updateRoomAreas();
    void op_unlockWalkPath();
    void op_addItemToInventoryAndRedraw();
    void op_giveItemTo();
    void op_setHitBoxText();
    void op_fadePalette();
    void op_getInventoryItemFlags();
    void op_drawInventory();
    void op_stopKeyCharScript();
    void op_restartKeyCharScript();
    void op_getKeyCharCurrentWalkBox();
    void op_getKeyCharPointsDataNum();
    void op_setupFollowingKeyChar();
    void op_startAnimation();
    void op_setKeyCharTextColor();
    void op_startMusic();
    void op_sleep();
    void op_setKeyCharDelay();
    void op_lockHitBox();
    void op_removeItemFromInventory();
    void op_unlockHitBox();
    void op_addRoomArea();
    void op_setKeyCharFlags();
    void op_unsetKeyCharFlags();
    void op_loadSpeechSegment();
    void op_drawSpriteOnBackdrop();
    void op_startPaletteFadeIn();
    void op_startPaletteFadeOut();
    void op_setRoomAreaState();

    void res_openDataFile();
    void res_closeDataFile();
    void res_allocateTables();
    void res_deallocateTables();
    uint32 res_getDataOffset(ResourceType type, int num, uint32 *size = NULL);
    void res_loadSpriteImage(int num, uint8 *dst);
    void res_loadProgram(int num);
    void res_decodeProgramData();
    void res_loadRoom(int num);
    void res_loadSprite(int num, int index);
    void res_loadSequence(int num, int index);
    void res_decodeScanLineImageRLE(uint8 *dst, int lineWidth);
    void res_loadBackdrop();
    void res_loadImage(int num, uint8 *dst);
    void res_loadImageHelper(uint8 *imgData, int imgWidth, int imgHeight);
    void res_loadSound(int flag, int num);
    void res_stopSound();
    void res_loadMusic(int num);
    void res_loadSpeech(int num);
    void res_loadSpeechSegment(int num);
    void res_stopSpeech();

    void drawButton(Button *button);
    void redrawMenu(MenuData *menu);
    void handleMenuAction(MenuData *menu, int actionId);
    void handleOptions(int forceDisplay);
    void drawActionsPanel(int dstX, int dstY, int deltaX, int deltaY);
    void drawConversationPanelBorder(int dstY, int srcX, int srcY);
    void drawConversationPanel();
    void printStatusString(const char *str);
    void clearStatusString();
    int displayQuitDialog();
    void displayTextMode(int str);

    Common::Point getMousePos() const;

    MidiPlayer *_midiPlayer;

    int _musicVolume;
    Audio::SoundHandle _musicHandle;

    void initMusic();
public: // To allow access from console
    void startMusic(int num);
    void stopMusic();
protected:
    int getMusicVolume();
    void setMusicVolume(int volume);
    void adjustMusicVolume(int diff);

    Common::Language _language;
    Common::RandomSource _rnd;

    bool _inp_leftMouseButtonPressed;
    bool _inp_rightMouseButtonPressed;
    int _disabledInputCounter;
    bool _hideInventoryTexts;
    GameState _gameState;
    bool _displayQuitDialog;
    int _saveLoadCurrentPage;
    int _saveLoadCurrentSlot;

    int _newMusicNum;
    int _currentMusicNum;
    int _newSoundNum;
    int _newSoundDelay;
    int _newSoundPriority;
    int _playSoundCounter;
    bool _speechPlaying;
    Audio::SoundHandle _sfxHandle;
    Audio::SoundHandle _speechHandle;

    int16 _inventoryList1[101];
    int16 _inventoryList2[101];
    int16 _inventoryList3[7];
    InventoryState _inventoryStateTable[3];
    int16 _inventoryItemsInfoTable[NUM_INVENTORY_ITEMS];
    int16 *_inventoryVar1;
    int16 *_inventoryVar2;
    int _currentCursorObject;
    Common::Rect _inventoryAreasTable[13];

    int _talkTextMode;
    int _talkListEnd;
    int _talkListCurrent;
    bool _talkTextRectDefined;
    bool _talkTextDisplayed;
    bool _talkTextInitialized;
    bool _skipTalkText;
    int _talkTextSpeed;
    int _keyCharTalkCounter;
    int _talkTableLastTalkingKeyChar;
    int _talkTableLastOtherKeyChar;
    int _talkTableLastStringNum;
    int _objectDescriptionNum;
    TalkEntry _talkTable[NUM_TALK_ENTRIES];

    bool _conversationChoicesUpdated;
    int _conversationReplyNum;
    bool _conversationEnded;
    int _conversationNum;
    int _scrollConversationChoiceOffset;
    int _currentConversation;
    bool _disableConversationScript;
    bool _conversationAreaCleared;
    ConversationChoice _conversationChoicesTable[NUM_CONVERSATION_CHOICES];

    int16 _flagsTable[NUM_FLAGS];
    KeyChar _keyCharsTable[NUM_KEYCHARS];
    KeyChar *_sortedKeyCharsTable[NUM_KEYCHARS];
    int _currentKeyCharNum;

    int _newEpisodeNum;
    int _currentEpisodeNum;

    int _currentAmountOfMoney;
    int _giveItemToKeyCharNum;
    int _giveItemToObjectNum;
    int _giveItemToCounter;
    int _currentRoomNum;
    int _waitingSetKeyCharNum1;
    int _waitingSetKeyCharNum2;
    int _waitingSetKeyCharNum3;
    uint8 _updatedRoomAreasTable[200];
    Common::Rect _moveKeyCharRect;
    Common::Point _screenOffset;
    int _currentObjectNum;
    int _processRandomPaletteCounter;
    int16 _spriteScalingIndex[1000];
    int16 _spriteScalingTable[1000];

    bool _fastWalkMode;
    bool _fastMode;

    AnimationEntry _animationTable[NUM_ANIMATION_ENTRIES];

    Script _script;
    const OpcodeProc *_opcodesTable;
    int _numOpcodes;

    Common::File _fData;
    Common::File _fSpeech[2];
    int _compressedSpeechData;

    uint8 *_textData;
    uint8 *_backdropBuffer;
    uint8 *_menuKitData;
    uint8 *_convKitData;
    uint8 *_sequenceDataTable[NUM_SEQUENCES];
    uint8 *_programData;
    uint32 _programDataSize;
    uint8 *_mouseData;
    uint8 *_iconData;

    SpriteData _spritesTable[NUM_SPRITES];
    SequenceEntry _sequenceEntryTable[NUM_SEQUENCES];
    int _currentBitmapWidth;
    int _currentBitmapHeight;
    int _currentImageWidth;
    int _currentImageHeight;
    int _roomWidth;

    uint8 *_programTextDataPtr;
    Common::Array<Common::Rect> _programRectsTable;
    Common::Array<ProgramPointData> _programPointsTable;
    Common::Array<ProgramWalkData> _programWalkTable;
    Common::Array<ProgramAreaData> _programAreaTable;
    Common::Array<ProgramBackgroundData> _programBackgroundTable;
    Common::Array<ProgramHitBoxData> _programHitBoxTable;
    Common::Array<ProgramActionScriptOffsetData> _programActionScriptOffsetTable;
    Common::Array<ProgramKeyCharScriptOffsetData> _programKeyCharScriptOffsetTable;
    Common::Array<ProgramConversationData> _programConversationTable;
    Common::Rect _cursorObjectRect;
    Common::Rect _talkTextRect, _talkTextRect2;
    Common::Rect _screenRect;
    Common::Rect _roomAreaRect;

    bool _roomNeedRedraw;
    int _fullRedrawCounter;
    int _menuRedrawCounter;
    uint8 *_offscreenBuffer;
    uint8 _paletteBuffer[256 * 3];
    Common::Rect _dirtyRectsTable[NUM_DIRTY_RECTS];
    int _dirtyRectsTableCount;

    static const uint8 _directionsTable[NUM_DIRECTIONS];
};

/*
    FLAGS LIST

    115 : don't set backdrop palette on room loading
    118 : current amount of money
    119 : current cursor object
    176 : keychar max direction
    266 : keychar direction override
    267 : don't decode picture/sprite images (in load_image_helper)
    268 : don't decode picture/sprite images
    269 : disable room background animations
    270 : play random sound
    290 : process random palette
    295 : game cycle counter (incremented)
    296 : game cycle counter (incremented)
    297 : game cycle counter (incremented)
    298 : game cycle counter (decremented)
    299 : game cycle counter (decremented)
    600 : last ascii key press
    603 : fade palette "scale" increment (in vbl handler)
    605 : fade palette "scale"
    606 : inventory redraw disabled
    607 : first palette color to fade
    608 : last palette color to fade
    609 : max fade palette "scale"
    610 : min fade palette "scale"
    611 : quit game
    612 : random number modulo
    613 : last generated random number
    614 : room scroll x offset
    615 : room scroll y offset
    616 : disable room scrolling
    617 : current speech file number
    618 : hide mouse cursor
    621 : enable french version "features"
    902 : debug/draw walk boxes
    911 : load scripts/programs from external files
*/

} // namespace Touche

#endif