CONFTP_P1 = 1,

CONFTP_P2 = 2,

CONFTP_P3 = 3,

CONFTP_IDFLG = 0x80,

CONFTP_RESMASK = 0x7f,

RESTP_GAMECONF = 0xf,

RESTP_GAMECONF2 = 0x10,

RESTP_DATACONF = 0x11,

RESTP_VMSTATE = 0x12,

RESTP_VMDATA = 0x13,

RESTP_BKG = 0x18,

RESTP_INITACT = 0x19,

RESTP_ACT_INFO = 0x20,

RESTP_ACT_ONCREATE = 0x21,

RESTP_ACT_ONDELETE = 0x22,

RESTP_ACT_COUNT = 0x23,

RESTP_ACT_DATA = 0x2a,

RESTP_ACT_COND = 0x2b,

RESTP_ACT_FUNC = 0x2c,

RESTP_UNK_MASKS = 0x38,

RESTP_UNK_OIDS = 0x39,

RESTP_UNK_ACTST = 0x3a,

RESTP_SPR_INFO = 0x40,

RESTP_SPR_SEQLEN = 0x41,

RESTP_SPR_SEQIMGINFO = 0x42,

RESTP_SPR_SEQIMGDATA = 0x43,

RESTP_UNKNOWN_50 = 0x50,

RESTP_SFX_SAMPLE = 0x51,

RESTP_MIDI_TRACK = 0x52,

RESTP_SUB_ACT = 0x60,

RESTP_SUB_PLACE = 0x61,

RESTP_XORSEQ0 = 0x7c,

RESTP_XORSEQ1 = 0x7d,

RESTP_XORSEQ2 = 0x7e,

bool loaded = false;

int32 offset = -1;

int32 size = 0;

int32 cSize = 0;

Graphics::Surface surface;

RawData rawData;

int16 xoffset = 0;

int16 yoffset = 0;

Image *image = nullptr;

uint32 index = 0;

byte field_0;

union {

byte flags;

byte startChar; // if it's font

};

byte lastChar;

byte frameCount;

Common::Array<ImageSeq *> sequences;

Common::Array<byte> masks;

Common::Array<byte> oids;

Common::Array<byte> actsT;

uint8 actid = 0;

uint8 flags = 0;

uint8 t = 0;

ObjState() = default;

ObjState(const ObjState&) = default;

ObjState(ObjState&&) = default;

ObjState& operator=(const ObjState&) = default;

ObjState(uint8 aa, uint8 af, uint8 at): actid(aa), flags(af), t(at) {};

enum {

HAS_CONDITION = 1,

HAS_ACT2 = 2,

HAS_ACT4 = 4,

HAS_FUNCTION = 8,

HAS_ACT10 = 0x10

};

byte flags = 0;

byte num_act_10e = 0;

Common::Array<ActTypeEntry> act_2;

ActEntry act_4;

Common::Array<ActTypeEntry> act_10;

Common::Array<ActEntry> act_10end[3];

int32 conditionAddress = -1;

int32 functionAddress = -1;

void parse(const byte *data, size_t dataSize);

uint8 actType = 0; // input action type?

uint8 mask = 0;

uint8 priority = 0;

uint8 storageSize = 0;

int32 onCreateAddress = -1;

Common::Array< Actions > actions;

int32 onDeleteAddress = -1;

enum {

FLAG_VALID = 1,

/* Action objects */

FLAG_HASACTION = 2,

FLAG_TRANSITION = 4, /* transition between logic cells */

FLAG_STORAGE = 8, /* in original engine used to indicate allocated storage */

/* Graphic objects */

FLAG_GRAPHIC = 0x80,

FLAG_FREECOORDS = 0x40, /* coords not binded to grid */

FLAG_OVERLAY = 0x20, /* gfx object like titles and etc */

FLAG_FLIPV = 0x10,

FLAG_FLIPH = 8,

FLAG_DIRTRECT = 4,

};

int16 index = 0;

uint8 flags = 0;

uint8 priority = 0;

Common::Point cell;

/* gfx */

int32 sprId = -1;

int32 seqId = -1;

int16 frame = -1;

int16 frameMax = -1;

Common::Point position;

int16 actObjIndex = -1;

/* action */

uint8 actID = 0;

uint8 t = 0;

ObjState state;

uint8 inputFlag = 0;

int16 tgtObjectId = -1;

int16 curObjectId = -1;

ImagePos *pImg = nullptr;

Common::Array<byte> storage;

/*

inline bool isActionObject() const { return (flags & (FLAG_HASACTION | FLAG_VALID)) == (FLAG_HASACTION | FLAG_VALID); };

inline bool isGraphicObject() const { return (flags & (FLAG_GRAPHIC | FLAG_VALID | FLAG_HASACTION)) == (FLAG_GRAPHIC | FLAG_VALID); };

inline bool isOverlayObject() const { return (flags & (FLAG_GRAPHIC | FLAG_OVERLAY | FLAG_FREECOORDS | FLAG_VALID | FLAG_HASACTION)) ==

(FLAG_GRAPHIC | FLAG_OVERLAY | FLAG_FREECOORDS | FLAG_VALID); };

inline bool isStaticObject() const { return (flags & (FLAG_GRAPHIC | FLAG_FREECOORDS | FLAG_VALID)) == (FLAG_GRAPHIC | FLAG_VALID); };

bool loaded = false;

uint32 offset = 0;

Graphics::Surface _bkgImage;

byte *palette = nullptr;

Array2D<ObjState> _savedStates;

Common::Array<Object> _savedObjects;

RawData _bkgImageData;

VmTxtFmtAccess(VM &vm): _vm(vm) {};

VM &_vm;

byte *objMem = nullptr;

inline bool isObjMem() const { return getMemType() == VM::REF_EBX;}

inline Common::String getString(uint maxLen = 256) const {

if (isObjMem()) {

Common::String s = Common::String((const char *)objMem + getOffset());

if (s.size() > maxLen)

s.erase(maxLen);

return s;

}

return _vm.readMemString(getOffset(), maxLen);

}

inline uint8 getU8() const {

if (isObjMem())

return objMem[getOffset()];

return _vm.memory().getU8(getOffset());

}

inline uint32 getU32() const {

if (isObjMem())

return _vm.getU32(objMem + getOffset());

return _vm.memory().getU32(getOffset());

}

inline void write(byte *src, uint len) {

if (isObjMem())

memcpy(objMem + getOffset(), src, len);

else

_vm.writeMemory(getOffset(), src, len);

}

inline void setU8(uint8 v) {

if (isObjMem())

objMem[getOffset()] = v;

else

_vm.memory().setU8(getOffset(), v);

}

inline void setU32(uint32 v) {

if (isObjMem())

_vm.setU32(objMem + getOffset(), v);

else

_vm.memory().setU32(getOffset(), v);

}

friend class MoviePlayer;

const GamosGameDescription *_gameDescription;

bool _errSet = false;

Common::String _errMessage;

Archive _arch;

byte _cmdByte = 0;

bool _isResLoadingProcess = false;

int _currentModuleID = 0;

byte _saveLoadID = 0;

uint32 _magic = 0xBAD00BAD;

uint32 _width = 0; //screen output width

uint32 _height = 0; //screen output height

int32 _gridCellW = 0;

int32 _gridCellH = 0;

uint32 _movieCount = 0;

byte _fps = 1;

byte _drawCursor = 0;

byte _fadeEffectID = 0;

byte _playIntro = 0;

byte _currentFade = 0;

int _isMoviePlay = 0;

bool _onlyScanImage = false;

int32 _resReadOffset = 0;

Common::Point _introPos;

Common::Point _introSize;

Common::String _string1;

Common::String _winCaption;

Common::Array<uint32> _movieOffsets;

Common::Array<Image *> _images;

Common::Array<ImageSeq *> _imgSeq;

Common::Point _bkgSize;

Common::Array<GameScreen> _gameScreens;

Common::Array<Sprite> _sprites;

Common::Array< Common::Array<byte> > _midiTracks;

Common::Array< Common::Array<byte> > _soundSamples;

Common::Array< Actions > _subtitleActions;

Common::Array< Common::Array<SubtitlePoint> > _subtitlePoints;

uint32 _delayTime = 0;

uint32 _lastTimeStamp = 0;

Common::Array<XorArg> _xorSeq[3];

uint32 _seed = 1;

Object _cursorObject;

int32 _cursorFrame = 0;

int32 _mouseCursorImgId = 0;

int32 _currentCursor = -1;

bool _isSaveLoadingProcess = false;

bool _ignoreSoundActions = false;

uint8 _inputMouseActId = 0;

uint8 _inputMouseActType = 0;

bool _midiStarted = false;

uint8 DAT_004173ec = 0;

/* Data2 */

Common::String _stateExt;

int32 _svModuleId = 0;

int32 _svGameScreen = 0;

uint32 _d2_fld10 = 0;

bool _enableSounds = false;

bool _enableInput = false;

bool _enableMovie = false;

bool _enableCDAudio = false;

int8 _cdAudioTrack = -1;

int32 _scrollX = 0;

int32 _scrollY = 0;

int32 _scrollTrackObj = 0;

int16 _scrollSpeed = 0;

int16 _scrollCutoff = 0;

int16 _scrollSpeedReduce = 0;

uint8 _scrollBorderL = 0;

uint8 _scrollBorderR = 0;

uint8 _scrollBorderU = 0;

uint8 _scrollBorderB = 0;

uint8 _sndChannels = 0;

uint8 _sndVolume = 0;

uint8 _midiVolume = 0;

uint8 _svFps = 0;

uint32 _svFrame = 0;

uint8 _sndVolumeTarget = 0;

uint8 _midiVolumeTarget = 0;

uint8 _savedSndVolume = 0;

uint8 _savedMidiVolume = 0;

bool _enableMidi = false;

int32 _midiTrack = 0;

uint32 _readingBkgOffset = 0;

int32 _readingBkgMainId = -1;

int32 _countReadedBkg = 0;

int32 _currentGameScreen = -1;

int32 _loadedDataSize = -1;

uint32 _addrBlk12 = 0;

uint32 _addrFPS = 1;

uint32 _addrKeyDown = 2;

uint32 _addrKeyCode = 3;

uint32 _addrCurrentFrame = 4;

MidiMusic _musicPlayer;

SystemProc _messageProc;

MoviePlayer _moviePlayer;

uint32 _statesWidth = 0;

uint32 _statesHeight = 0;

uint32 _statesShift = 0;

Array2D<ObjState> _states;

uint8 _preprocDataId = 0;

Common::Array<Unknown1> _thing2;

Common::Array<ObjectAction> _objectActions;

Pool<Object> _objects;

bool _curObjectActProcessed = false;

Object *_firstUpdateObject = nullptr;

ObjectAction *_curAction = nullptr;

Object *_curObject = nullptr;

Object *_inputActObj = nullptr;

uint8 _curObjectT = 0;

bool _gfxObjectCreated = false;

bool _restartUpdateObject = false;

byte *_curObjStorage = nullptr;

Common::Point _curObjectCurrentCell;

Common::Point _curObjectStartCell;

byte *PTR_00417388 = nullptr;

int32 _curObjIndex = 0;

Common::Point _inputActCell;

Common::Point _inputMouseActCell;

uint8 _inputActId = 0;

bool _pathInMove = false;

uint8 _pressedKeyCode = 0;

Common::String _keySeq;

int32 _txtInputVmOffset = -1;

int32 _txtInputSpriteID = 0;

int32 _txtInputX = 0;

int32 _txtInputY = 0;

uint8 _txtInputBuffer[256];

Object *_txtInputObjects[256];

int32 _txtInputLength = 0;

int32 _txtInputMaxLength = 0;

VmTxtFmtAccess _txtInputVMAccess;

uint8 _txtInputFlags = 0;

bool _txtInputTyped = false;

bool _txtInputIsNumber = false;

Object *_txtInputObject = nullptr;

ObjectAction *_txtInputAction = nullptr;

int32 _txtInputObjectIndex = -1;

bool _txtInputActive = false;

/* path find ? */

Common::Point _pathStartCell;

Common::Point _pathTargetCell;

int8 _pathDir8 = 0;

int8 _pathDir4 = 0;

Array2D<uint8> _pathMap;

uint32 _statesCount = 0;

int32 _pathRight = 0;

int32 _pathBottom = 0;

Common::Array<Common::Rect> _dirtyRects;

VM _vm;

bool _needReload = false;

uint32 _engineVersion = 0x18;

// Engine APIs

Common::Error run() override;

void readCMDByte() {

_cmdByte = _arch.readByte();

}

bool loadModule(uint id);

bool loader2();

bool loadResHandler(uint tp, uint pid, uint p1, uint p2, uint p3, const byte *data, size_t dataSize);

bool loadResHandler(uint tp, uint pid, uint p1, uint p2, uint p3, const RawData &data);

bool reuseLastResource(uint tp, uint pid, uint p1, uint p2, uint p3);

bool initMainDatas();

bool init(const Common::String &moduleName);

bool loadInitModule();

void readElementsConfig(const RawData &data);

void setFPS(uint fps);

void loadXorSeq(const byte *data, size_t dataSize, int id);

bool loadSpriteInfo(int32 id, const byte *data, size_t dataSize);

bool loadSpriteSeqLength(int32 id, const byte *data, size_t dataSize);

bool loadSpriteSeqImageInfo(int32 id, int32 p1, const byte *data, size_t dataSize);

bool loadSpriteSeqImageData(int32 id, int32 p1, int32 p2, const byte *data, size_t dataSize);

bool loadMidiTrack(int32 id, const byte *data, size_t dataSize);

bool loadBackground(int32 id, const byte *data, size_t dataSize);

void freeImages();

void freeSequences();

bool playMidi(Common::Array<byte> *buffer);

bool playSound(uint id);

int stepVolume(int volume, int target);

void changeVolume();

void stopMidi();

void stopCDAudio();

void stopSounds();

bool playIntro();

bool playMovie(uint32 id);

uint32 playMidiTrack(uint32 id);

void setErrMessage(const Common::String &msg);

void updateScreen(bool checkers, const Common::Rect &rect);

void readData2(const RawData &data);

uint8 update(Common::Point screenSize, Common::Point mouseMove, Common::Point actPos, uint8 act2, uint8 act1, uint16 keyCode, bool mouseInWindow);

int32 doActions(const Actions &a, bool absolute);

uint32 savedDoActions(const Actions &a);

static uint32 getU32(const void *ptr);

void preprocessData(int id, ActEntry *e);

void preprocessDataB1(int id, ActEntry *e);

int processData(ActEntry e, bool absolute);

void executeScript(int32 scriptAddr, ObjectAction *act, Object *pobj, int32 index, byte *storage, Common::Point cell, uint8 t);

void processActionCurObject(ActEntry e);

void createActiveObject(ActEntry e, Common::Point cell);

void removeObjectAtCoords(Common::Point cell, bool deleteGfxObj);

Object *getFreeObject();

void removeObject(Object *obj);

void removeObjectMarkDirty(Object *obj);

void removeObjectByIDMarkDirty(int32 id);

void removeSubtitles(Object *obj);

void cycleNextInputObj(Object *obj);

bool updateObjects();

bool updateMouseCursor(Common::Point mouseMove);

bool scrollAndDraw();

bool updateVMInputFrameStates();

bool updateGfxFrames(Object *obj, bool p2, bool p1);

void updateGfxObjectPosition(Object *obj);

void addDirtRectOnObject(Object *obj);

void addDirtyRect(const Common::Rect &rect);

void doDraw();

void flushDirtyRects(bool apply);

bool usePalette(const byte *pal, int num, int fade, bool winColors);

bool setPaletteCurrentGS();

bool loadImage(Image *img);

uint32 doScript(uint32 scriptAddress);

bool createGfxObject(uint32 id, Common::Point position, bool p);

void gfxObjectCalculateFlip(int32 sprId, Object *obj, bool p);

void updateLinkedGfxObject(Object *obj);

bool moviePlayerPlay(int id);

void setCursor(int id, bool dirtRect);

void processInput(Common::Point move, Common::Point actPos, uint8 act2, uint8 act1);

bool checkPointOnLinkedGfx(Object *obj, Common::Point pos);

void setNeedReload() {

_needReload = true;

_vm._interrupt = true;

};

Object *addSubtitleImage(uint32 frame, int32 spr, int32 *pX, int32 y);

void addSubtitles(VM::Context *ctx, byte memtype, int32 offset, int32 sprId, int32 x, int32 y);

/* Path find methods */

void FUN_00407db8(uint8 p);

byte FUN_00408648(uint8 p1, uint8 p2, uint8 p3);

byte FUN_004084bc(uint8 p);

byte FUN_00408510(uint8 p);

byte FUN_0040856c();

byte FUN_004085d8(uint8 p);

byte pathFindCalcMove(bool faceTarget);

byte pathFindMoveToTarget();

byte pathFindTraceMove(uint8 p);

byte pathFindSetNeighbor(uint8 checkVal, uint8 setVal);

byte FUN_004088cc(uint8 p1, uint8 p2, uint8 p3);

byte FUN_004086e4(const Common::Array<byte> &arr);

byte FUN_00408778(const Common::Array<byte> &arr);

byte FUN_0040881c(const Common::Array<byte> &arr);

bool FUN_0040705c(int a, int b);

void runRenewStaticGfxCurObj(uint8 val, bool rnd);

void removeStaticGfxCurObj();

int txtInputBegin(VM::Context *ctx, byte memtype, int32 offset, int sprId, int32 x, int32 y);

void txtInputProcess(uint8 c);

void txtInputEraseBack(int n);

bool onTxtInputUpdate(uint8 c);

/* save-load */

void storeToGameScreen(int id);

bool switchToGameScreen(int id, bool doNotStore);

Common::String makeSaveName(const Common::String &main, int id, const Common::String &ext) const;

void writeVMData(Common::SeekableWriteStream *stream, const Common::Array<XorArg> &seq);

void readVMData(Common::SeekableReadStream *stream, const Common::Array<XorArg> &seq);

bool writeStateFile();

void writeStateData(Common::SeekableWriteStream *stream);

void zeroVMData(const Common::Array<XorArg> &seq);

bool loadStateFile();

void loadStateData(Common::SeekableReadStream *stream);

bool writeSaveFile(int id);

bool loadSaveFile(int id);

bool deleteSaveFile(int id);

void writeObjectData(Common::SeekableWriteStream *stream, const Object *obj);

void loadObjectData(Common::SeekableReadStream *stream, Object *obj);

void vmCallDispatcher(VM::Context *ctx, uint32 funcID);

void dumpActions();

static void callbackVMCallDispatcher(void *engine, VM::Context *ctx, uint32 funcID);

static Common::String gamos_itoa(int value, uint radix);

/* video */

void playVideo(const Common::String &video, const Common::Point &pos, const Common::Point &size);

void surfacePaletteRemap(Graphics::Surface *dst, const byte *tgtPalette, const Graphics::Surface *src, const byte *srcPalette, int srcCount);

/* skip events */

bool eventsSkip(bool breakOnInput = false);

inline void rndSeed(uint32 seed) {

_seed = seed * 0x41c64e6d + 0x3039;

}

inline uint32 rnd() {

uint32 val = _seed;

_seed = _seed * 0x41c64e6d + 0x3039;

return val;

}

inline uint16 rndRange16(uint32 range) {

uint16 percent = _seed >> 16;

_seed = _seed * 0x41c64e6d + 0x3039;

return (percent * range) >> 16;

}

Graphics::Screen *_screen = nullptr;

GamosEngine(OSystem *syst, const GamosGameDescription *gameDesc);

~GamosEngine() override;

uint32 getFeatures() const {

return _gameDescription->desc.flags;

}

Common::String getGameId() const {

return _gameDescription->desc.gameId;

}

Common::Language getGameLanguage() {

return _gameDescription->desc.language;

}

Common::String getRunFile() const {

return _gameDescription->runFile;

}

uint32 getEngineVersion() const {

return _gameDescription->engineVersion;

}