_gameDescription(gameDesc),

_messageProc(this),

_vm(this, callbackVMCallDispatcher),

for (Image *img : _images)

delete img;

_images.clear();

for (ImageSeq *seq : _imgSeq)

delete seq;

_imgSeq.clear();

// Set the engine's debugger console

setDebugger(new Console());

// If a savegame was selected from the launcher, load it

int saveSlot = ConfMan.getInt("save_slot");

if (saveSlot != -1)

(void)loadGameState(saveSlot);

CursorMan.setDefaultArrowCursor();

CursorMan.showMouse(true);

if (getGameLanguage() == Common::RU_RUS)

setCP1251();

else

setCP1252();

_engineVersion = getEngineVersion() & 0xFF;

_arch.setVersion(_engineVersion);

init(getRunFile());

Common::Event e;

while (!shouldQuit()) {

Common::Point prevMousePos = _messageProc._mouseReportedPos;

while (_system->getEventManager()->pollEvent(e)) {

_messageProc.processMessage(e);

}

uint32 curTime = _system->getMillis();

if (curTime >= _lastTimeStamp + _delayTime) {

_lastTimeStamp = curTime;

if (_messageProc._inputFlags & 2) {

}

uint8 result = 2;

while (result == 2) {

result = update({}, _messageProc._mouseReportedPos, _messageProc._mouseActPos, _messageProc._act2, _messageProc._act1, _messageProc._rawKeyCode, true);

}

if (!result)

break;

_messageProc._act2 = ACT_NONE;

_messageProc._act1 = ACT_NONE;

_messageProc._rawKeyCode = ACT_NONE;

} else {

if (prevMousePos != _messageProc._mouseReportedPos)

_system->updateScreen();

_system->delayMillis(1);

}

//if (_delayTime)

}

stopSounds();

stopMidi();

stopCDAudio();

_enableMovie = true;

_enableMidi = true;

_enableSounds = true;

_enableInput = true;

_isResLoadingProcess = true;

writeStateFile();

return Common::kNoError;

int32 skipsz = _arch.readSint32LE();

_arch.skip(skipsz);

if (_arch.readByte() != 7)

return false;

RawData data;

if (!_arch.readCompressedData(&data))

return false;

int32 p1 = 0;

int32 p2 = 0;

int32 pid = 0;

byte resType = 0;

int32 resSize = 0;

Common::MemoryReadStream dataStream(data.data(), data.size());

while (!dataStream.eos()) {

byte curByte = dataStream.readByte();

if (curByte == 0) {

break;

} else if (curByte == 0x80) {

p1 = 0;

p2 = 0;

pid = dataStream.readSint32LE();

} else if (curByte == 1) {

p1 = dataStream.readSint32LE();

} else if (curByte == 2) {

p2 = dataStream.readSint32LE();

} else if (curByte == 7) {

/*int32 needsz = dataStream.readSint32LE(); // check free mem ? */

dataStream.skip(4);

} else if (curByte == 0x40) {

resSize = 4;

resType = 0x40;

if (!loadResHandler(resType, pid, p1, p2, 0, data.data() + dataStream.pos(), resSize))

return false;

dataStream.skip(resSize);

} else if (curByte == 0x41 || curByte == 0x42) {

resSize = dataStream.readSint32LE();

resType = curByte;

if (!loadResHandler(resType, pid, p1, p2, 0, data.data() + dataStream.pos(), resSize))

return false;

_loadedDataSize += (resSize + 3) & (~3);

dataStream.skip(resSize);

} else if (curByte == 0x43) {

resSize = 0x10;

resType = 0x43;

if (!loadResHandler(resType, pid, p1, p2, 0, data.data() + dataStream.pos(), resSize))

return false;

_loadedDataSize += (resSize + 3) & (~3);

dataStream.skip(resSize);

} else if (curByte == 0xff) {

//warning("0xFF %d %d %d", pid, p1, p2);

if (!reuseLastResource(resType, pid, p1, p2, 0))

return false;

} else {

warning("loader2 want %x", curByte);

return false;

}

}

return true;

_keySeq.clear();

if ((!_isResLoadingProcess && !writeStateFile()) ||

!_arch.seekDir(1))

return false;

_currentModuleID = id;

const byte targetDir = 2 + id;

//DAT_004126e4 = 1;

_currentGameScreen = -1;

_readingBkgMainId = -1;

_countReadedBkg = 0;

//DAT_004126ec = 0;

//INT_004126e8 = 0;

_xorSeq[0].clear();

_xorSeq[1].clear();

_xorSeq[2].clear();

stopMidi();

stopCDAudio();

stopSounds();

/* Complete me */

bool prefixLoaded = false;

byte prevByte = 0;

bool doLoad = true;

int32 p1 = 0;

int32 p2 = 0;

int32 p3 = 0;

int32 pid = 0;

while (doLoad) {

byte curByte = _arch.readByte();

switch (curByte) {

case 0:

if (prefixLoaded) {

doLoad = false;

break;

}

prefixLoaded = true;

if (!_arch.seekDir(targetDir))

return false;

break;

case CONFTP_P1:

p1 = _arch.readPackedInt();

break;

case CONFTP_P2:

p2 = _arch.readPackedInt();

break;

case CONFTP_P3:

p3 = _arch.readPackedInt();

break;

case 4: {

_resReadOffset = _arch.pos();

bool isResource = true;

if (prevByte == RESTP_GAMECONF) {

RawData data;

if (!_arch.readCompressedData(&data))

return false;

if (_isResLoadingProcess && !_isSaveLoadingProcess)

readData2(data);

if (!_isSaveLoadingProcess) {

_scrollY = 0;

_scrollX = 0;

_scrollTrackObj = -1;

_scrollSpeed = 16;

_scrollCutoff = 80;

_scrollSpeedReduce = -1;

_scrollBorderB = 0;

_scrollBorderU = 0;

_scrollBorderR = 0;

_scrollBorderL = 0;

}

isResource = false; /* do not loadResHandler */

} else if (prevByte == RESTP_GAMECONF2) {

if (!initMainDatas())

return false;

isResource = false; /* do not loadResHandler */

} else if (prevByte == RESTP_DATACONF) {

RawData data;

if (!_arch.readCompressedData(&data))

return false;

if (pid == id)

readElementsConfig(data);

isResource = false; /* do not loadResHandler */

} else if (prevByte == RESTP_BKG) {

/* free elements ? */

_readingBkgOffset = _arch.pos();

_countReadedBkg++;

}

RawData data;

if (isResource) {

if (!_arch.readCompressedData(&data))

return false;

if (!loadResHandler(prevByte, pid, p1, p2, p3, data))

return false;

}

uint32 datasz = (data.size() + 3) & (~3);

switch (prevByte) {

case RESTP_DATACONF:

case RESTP_BKG:

case RESTP_INITACT:

case RESTP_ACT_INFO:

case RESTP_SPR_INFO:

case RESTP_UNKNOWN_50:

break;

case RESTP_SPR_SEQIMGDATA:

//warning("t %x sz %x sum %x", prevByte, data.size(), _loadedDataSize);

if (_onlyScanImage)

_loadedDataSize += 0x10;

else

_loadedDataSize += datasz;

break;

default:

//warning("t %x sz %x sum %x", prevByte, data.size(), _loadedDataSize);

_loadedDataSize += datasz;

break;

}

break;

}

case 5: {

byte t = _arch.readByte();

if (t == 0 || (t & 0xec) != 0xec)

return false;

byte sz = (t & 3) + 1;

int32 movieSize = 0;

for (uint i = 0; i < sz; ++i)

movieSize |= _arch.readByte() << (i * 8);

if (prevByte == 0x14)

_movieOffsets[pid] = _arch.pos();

_arch.skip(movieSize);

break;

}

case 6:

if (!loader2())

return false;

break;

case 0xFF:

if (!reuseLastResource(prevByte, pid, p1, p2, 0))

return false;

break;

default:

p1 = 0;

p2 = 0;

p3 = 0;

pid = 0;

prevByte = curByte & CONFTP_RESMASK;

if ((curByte & CONFTP_IDFLG) == 0)

pid = _arch.readPackedInt();

break;

}

}

//FUN_00404a28();

if (_isSaveLoadingProcess)

return true;

// Reverse Here

setCursor(0, false);

if (!loadStateFile())

return false;

int bkg = _readingBkgMainId;

if (bkg == -1)

bkg = 0;

if (!switchToGameScreen(bkg, false))

return false;

return true;

if (tp == RESTP_VMSTATE) {

Common::MemoryReadStream dataStream(data, dataSize, DisposeAfterUse::NO);

_addrBlk12 = _loadedDataSize;

_addrFPS = _loadedDataSize + 1;

_addrKeyDown = _loadedDataSize + 2;

_addrKeyCode = _loadedDataSize + 3;

_addrCurrentFrame = _loadedDataSize + 4;

_vm.memory().setU8(_addrBlk12, dataStream.readByte());

dataStream.skip(1);

_vm.memory().setU8(_addrFPS, _fps);

_vm.memory().setU8(_addrKeyDown, dataStream.readByte());

_vm.memory().setU8(_addrKeyCode, dataStream.readByte());

_vm.memory().setU32(_addrCurrentFrame, dataStream.readUint32LE());

setFPS(_fps);

} else if (tp == RESTP_VMDATA) {

_vm.writeMemory(_loadedDataSize, data, dataSize);

} else if (tp == RESTP_BKG) {

loadBackground(pid, data, dataSize);

} else if (tp == RESTP_INITACT) {

if (!_isSaveLoadingProcess) {

for (int i = 0; i < _states.size(); i++)

_states.at(i) = ObjState(0xfe, 0, 0xf);

_ignoreSoundActions = true;

Actions acts;

acts.parse(data, dataSize);

doActions(acts, true);

if (_needReload)

warning("needs reload from loadResHandler, CANT HAPPEN!");

_ignoreSoundActions = false;

storeToGameScreen(pid);

}

} else if (tp == RESTP_ACT_INFO) {

if (dataSize != 4)

return false;

_objectActions[pid].actType = data[0];

_objectActions[pid].mask = data[1];

_objectActions[pid].priority = data[2];

_objectActions[pid].storageSize = data[3] + 1;

} else if (tp == RESTP_ACT_ONCREATE) {

_vm.writeMemory(_loadedDataSize, data, dataSize);

_objectActions[pid].onCreateAddress = _loadedDataSize + p3;

//warning("RESTP_ACT_ONCREATE %x pid %d sz %x", _loadedDataSize, pid, dataSize);

} else if (tp == RESTP_ACT_ONDELETE) {

_vm.writeMemory(_loadedDataSize, data, dataSize);

_objectActions[pid].onDeleteAddress = _loadedDataSize + p3;

//warning("RESTP_ACT_ONDELETE %x pid %d sz %x", _loadedDataSize, pid, dataSize);

} else if (tp == RESTP_ACT_COUNT) {

if (dataSize % 4 != 0 || dataSize < 4)

return false;

_objectActions[pid].actions.resize(dataSize / 4);

} else if (tp == RESTP_ACT_DATA) {

Actions &scr = _objectActions[pid].actions[p1];

scr.parse(data, dataSize);

} else if (tp == RESTP_ACT_COND) {

_vm.writeMemory(_loadedDataSize, data, dataSize);

_objectActions[pid].actions[p1].conditionAddress = _loadedDataSize + p3;

//warning("RESTP_ACT_COND %x pid %d p1 %d sz %x", _loadedDataSize, pid, p1, dataSize);

} else if (tp == RESTP_ACT_FUNC) {

_vm.writeMemory(_loadedDataSize, data, dataSize);

_objectActions[pid].actions[p1].functionAddress = _loadedDataSize + p3;

//warning("RESTP_ACT_FUNC %x pid %d p1 %d sz %x", _loadedDataSize, pid, p1, dataSize);

} else if (tp == RESTP_UNK_MASKS) {

//warning("Data 38 size %zu", dataSize);

_thing2[pid].masks.assign(data, data + dataSize);

} else if (tp == RESTP_UNK_OIDS) {

if (data[0] == 0)

_thing2[pid].oids.clear();

else

_thing2[pid].oids.assign(data + 1, data + 1 + data[0]);

} else if (tp == RESTP_UNK_ACTST) {

_thing2[pid].actsT.assign(data, data + dataSize);

} else if (tp == RESTP_SPR_INFO) {

return loadSpriteInfo(pid, data, dataSize);

} else if (tp == RESTP_SPR_SEQLEN) {

return loadSpriteSeqLength(pid, data, dataSize);

} else if (tp == RESTP_SPR_SEQIMGINFO) {

return loadSpriteSeqImageInfo(pid, p1, data, dataSize);

} else if (tp == RESTP_SPR_SEQIMGDATA) {

return loadSpriteSeqImageData(pid, p1, p2, data, dataSize);

} else if (tp == RESTP_UNKNOWN_50) {

/* just ignore it? */

} else if (tp == RESTP_SFX_SAMPLE) {

uint32 datSz = getU32(data) & (~3);

_soundSamples[pid].assign(data + 4, data + 4 + datSz);

//warning("sound size %d", dataSize);

} else if (tp == RESTP_MIDI_TRACK) {

return loadMidiTrack(pid, data, dataSize);

//warning("midi size %d", dataSize);

} else if (tp == RESTP_SUB_ACT) {

_subtitleActions[pid].parse(data, dataSize);

} else if (tp == RESTP_SUB_PLACE) {

Common::MemoryReadStream dataStream(data, dataSize, DisposeAfterUse::NO);

const int count = dataSize / 8;

_subtitlePoints[pid].resize(count);

for (int i = 0; i < count; i++) {

SubtitlePoint &d = _subtitlePoints[pid][i];

d.x = dataStream.readSint16LE();

d.y = dataStream.readSint16LE();

d.sprId = dataStream.readUint16LE();

dataStream.skip(2);

}

} else if (tp == RESTP_XORSEQ0) {

loadXorSeq(data, dataSize, 0);

} else if (tp == RESTP_XORSEQ1) {

loadXorSeq(data, dataSize, 1);

} else if (tp == RESTP_XORSEQ2) {

loadXorSeq(data, dataSize, 2);

} else {

warning("Unk Res %x at %x sz %zx", tp, _loadedDataSize, dataSize);

}

return true;

if (tp == RESTP_SPR_SEQIMGDATA) {

_sprites[pid].sequences[p1]->operator[](p2).image = _images.back();

} else if (tp == RESTP_SPR_SEQIMGINFO) {

_sprites[pid].sequences[p1] = _imgSeq.back();

} else {

error("Reuse of resource not implemented: resource type %x, id %d %d %d %d", tp, pid, p1, p2, p3);

}

return true;

RawData rawdata;

if (!_arch.readCompressedData(&rawdata))

return false;

Common::MemoryReadStream dataStream(rawdata.data(), rawdata.size(), DisposeAfterUse::NO);

_magic = dataStream.readUint32LE();

if (_magic != getEngineVersion()) {

error("InitMainData: Invalid engine version! get %x expecting %x", _magic, getEngineVersion());

return false;

}

/* skip count of pages 1kb size */

dataStream.skip(4); // 4

if (_engineVersion >= 0x12) {

/* skip read buffer size */

dataStream.skip(4); // 8

}

_width = dataStream.readUint32LE(); // c

_height = dataStream.readUint32LE(); // 10

_gridCellW = dataStream.readSint32LE(); // 14

_gridCellH = dataStream.readSint32LE(); // 18

_movieCount = dataStream.readUint32LE(); // 1c

dataStream.skip(3); // skip unknown unused 20

_fps = dataStream.readByte(); // 23

dataStream.skip(1); // skip unknown unused 24

_drawCursor = dataStream.readByte(); // 25

if (_engineVersion >= 0x12) {

_fadeEffectID = dataStream.readByte(); // 26

_playIntro = dataStream.readByte(); // 27

} else {

_playIntro = dataStream.readByte();

_fadeEffectID = dataStream.readByte();

}

if (_engineVersion >= 0x12) {

_introPos.x = dataStream.readSint32LE(); // 28

_introPos.y = dataStream.readSint32LE(); // 2c

_introSize.x = dataStream.readSint32LE(); // 30

_introSize.y = dataStream.readSint32LE(); // 34

int64 pos = dataStream.pos();

_string1 = dataStream.readString(0, 64); // 38

dataStream.seek(pos + 64);

} else {

_string1 = "";

}

_winCaption = dataStream.readString(0, 32); // 78

if (!_screen) {

initGraphics(_width, _height);

_screen = new Graphics::Screen();

}

_movieOffsets.clear();

_movieOffsets.resize(_movieCount, 0);

_objects.clear();

return true;

_isSaveLoadingProcess = false;

if (!_arch.open(Common::Path(moduleName)))

return false;

if (!loadInitModule())

return false;

_savedSndVolume = !ConfMan.hasKey("sfx_volume") ? 255 : ConfMan.getInt("sfx_volume");

_savedMidiVolume = !ConfMan.hasKey("music_volume") ? 255 : ConfMan.getInt("music_volume");

_sndVolumeTarget = _savedSndVolume;

_midiVolumeTarget = _savedMidiVolume;

playVideo("intro", _introPos, _introSize);

if (!playIntro())

return false;

return true;

rndSeed(_system->getMillis());

_curObjIndex = -1;

_curObject = nullptr;

_curAction = nullptr;

_xorSeq[2].clear();

_xorSeq[1].clear();

_xorSeq[0].clear();

_isMoviePlay = 0;

_txtInputActive = false;

//_updateMouse = false;

_isResLoadingProcess = true;

_savedSndVolume = 0;

_savedMidiVolume = 0;

_sndVolumeTarget = 0;

_midiVolumeTarget = 0;

//_mouseInWindow = false;

return loadModule(0);

_delayTime = 0;

if (fps)

_delayTime = 1000 / fps;

Common::MemoryReadStream dataStream(data.data(), data.size(), DisposeAfterUse::NO);

freeImages();

freeSequences();

uint32 bkgnum1 = dataStream.readUint32LE(); // 0

uint32 bkgnum2 = dataStream.readUint32LE(); // 4

_statesWidth = dataStream.readUint32LE(); // 8

_statesHeight = dataStream.readUint32LE(); // c

_bkgSize.x = dataStream.readUint32LE(); // 10

_bkgSize.y = dataStream.readUint32LE(); // 14

/* bkgbufferSize */ dataStream.readUint32LE(); // 18

uint32 actsCount = dataStream.readUint32LE(); // 1c

uint32 unk1Count = dataStream.readUint32LE(); // 20

uint32 imageCount = dataStream.readUint32LE(); // 24

uint32 soundCount = dataStream.readUint32LE(); // 28

uint32 midiCount = dataStream.readUint32LE(); // 2c

uint32 dat6xCount = dataStream.readUint32LE(); // 30

_statesShift = 2;

for (int i = 2; i < 9; i++) {

if (_statesWidth <= (1 << i)) {

_statesShift = i;

break;

}

}

_states.clear();

_states.resize(_statesWidth, _statesHeight);

_statesCount = _statesHeight * _statesWidth;

_pathRight = _statesWidth - 1;

_pathBottom = _statesHeight - 1;

_pathMap.clear();

_pathMap.resize(_statesWidth, _statesHeight);

_gameScreens.clear();

_gameScreens.resize(bkgnum1 * bkgnum2);

_sprites.clear();

_sprites.resize(imageCount);

for (uint i = 0; i < imageCount; i++)

_sprites[i].index = i;

_midiTracks.clear();

_midiTracks.resize(midiCount);

_soundSamples.clear();

_soundSamples.resize(soundCount);

_thing2.clear();

_thing2.resize(unk1Count);

_objectActions.clear();

_objectActions.resize(actsCount);

_subtitleActions.clear();

_subtitlePoints.clear();

_subtitleActions.resize(dat6xCount);

_subtitlePoints.resize(dat6xCount);

_loadedDataSize = 0;

_vm.clearMemory();

Common::MemoryReadStream dataStream(data, dataSize);

Common::Array<XorArg> &seq = _xorSeq[id];

uint32 num = dataStream.readUint32LE();

seq.resize(num);

for (uint i = 0; i < num; ++i) {

seq[i].pos = dataStream.readUint32LE();

seq[i].len = dataStream.readUint32LE();

}

if (dataSize < 4)

return false;

if (dataSize % 4)

warning("dataSize > 4");

_sprites[id].field_0 = data[0];

_sprites[id].flags = data[1];

_sprites[id].lastChar = data[2];

_sprites[id].frameCount = data[3];

_onlyScanImage = data[1] & 0x80;

return true;

if (*(const uint32 *)data != 0)

error("41 not null!!!");

if (dataSize % 4)

warning("loadRes41 datasize > 4");

_sprites[id].sequences.resize(dataSize / 4);

return true;

//warning("loadRes42 pid %d p %d sz %x",id, p1, dataSize);

if (_sprites[id].sequences.size() == 0)

_sprites[id].sequences.resize(1);

int32 count = dataSize / 8;

_imgSeq.push_back(new ImageSeq(count));

_sprites[id].sequences[p1] = _imgSeq.back();

Common::MemoryReadStream strm(data, dataSize);

for (int i = 0; i < count; ++i) {

int32 dataz = strm.readSint32LE();

if (dataz != 0) {

error("42 nut null");

}

ImagePos &imgpos = _sprites[id].sequences[p1]->operator[](i);

imgpos.xoffset = strm.readSint16LE();

imgpos.yoffset = strm.readSint16LE();

}

return true;

_images.push_back(new Image());

_sprites[id].sequences[p1]->operator[](p2).image = _images.back();

Image *img = _sprites[id].sequences[p1]->operator[](p2).image;

Common::MemoryReadStream s(data, dataSize);

img->surface.pitch = img->surface.w = s.readSint16LE();

img->surface.h = s.readSint16LE();

img->loaded = false;

img->offset = -1;

uint32 token = s.readUint32LE();

/* token 'Disk' */

if (token == 0x4469736b) {

img->offset = s.readSint32LE();

img->cSize = s.readSint32LE();

} else {

if (_sprites[id].flags & 0x80) {

if (_arch._lastReadDecompressedSize) {

img->offset = _arch._lastReadDataOffset;

img->cSize = _arch._lastReadSize;

} else {

img->offset = _arch._lastReadDataOffset;

img->cSize = 0;

}

} else {

img->loaded = true;

img->rawData.assign(data + 4, data + dataSize);

img->surface.setPixels(img->rawData.data());

img->surface.format = Graphics::PixelFormat::createFormatCLUT8();

}

}

return true;

GameScreen &bimg = _gameScreens[id];

bimg.loaded = true;

bimg.offset = _readingBkgOffset;

bimg._savedStates.clear();

bimg._savedObjects.clear();

bimg.palette = nullptr;

bimg._bkgImageData.assign(data, data + dataSize);

Common::MemoryReadStream strm(data, dataSize);

if (_readingBkgMainId == -1 && (strm.readUint32LE() & 0x80000000))

_readingBkgMainId = id;

//warning("res 18 id %d 4: %x", id, strm.readUint32LE());

strm.seek(8);

bimg._bkgImage.pitch = bimg._bkgImage.w = strm.readUint32LE();

bimg._bkgImage.h = strm.readUint32LE();

uint32 imgsize = strm.readUint32LE();

//warning("res 18 id %d 14: %x", id, strm.readUint32LE());

bimg._bkgImage.setPixels(bimg._bkgImageData.data() + 0x18);

bimg._bkgImage.format = Graphics::PixelFormat::createFormatCLUT8();

bimg.palette = bimg._bkgImageData.data() + 0x18 + imgsize;

return true;

if (_movieCount != 0 && _playIntro == 1)

return playMovie(0);

return true;

if (_enableMovie) {

_isMoviePlay++;

bool res = moviePlayerPlay(id);

_isMoviePlay--;

return res;

}

return true;

if (_errSet)

return;

_errMessage = msg;

_errSet = true;

if (_width == 0 || _height == 0)

return;

if (!checkers || shouldQuit()) {

_screen->addDirtyRect(rect);

return;

}

/* checkers update */

static const Common::Point checkerCoords[16] = {

{0, 0}, {16, 32}, {48, 16}, {16, 48},

{0, 32}, {32, 48}, {16, 16}, {48, 0},

{32, 32}, {0, 48}, {32, 16}, {16, 0},

{48, 32}, {32, 0}, {0, 16}, {48, 48}

};

/* 0.4sec */

const int16 maxDelay = (400 / 16) - 1;

_screen->clearDirtyRects();

for (int16 p = 0; p < 16; p++) {

uint32 val = _system->getMillis();

const Common::Point point = checkerCoords[p];

for (uint32 x = point.x; x < _width; x += 64) {

for (uint32 y = point.y; y < _height; y += 64) {

_screen->addDirtyRect(Common::Rect(x, y, x + 16, y + 16));

}

}

_screen->update();

while (_system->getMillis() - val < maxDelay) {

_system->delayMillis(1);

if (eventsSkip()) {

_screen->addDirtyRect(rect);

_screen->update();

return;

} else {

_system->updateScreen();

}

}

}

if (apply) {

for (const Common::Rect &r : _dirtyRects) {

updateScreen(false, r);

}

}

_dirtyRects.clear();

_screen->update();

_inputMouseActId = 0xff;

_inputMouseActType = ACT_NONE;

PTR_00417388 = nullptr;

rndSeed(_system->getMillis());

_inputActObj = nullptr;

cycleNextInputObj(nullptr);

static const byte winColorMap[20][3] = {

/* r g b */

{ 0x00, 0x00, 0x00 },

{ 0x80, 0x00, 0x00 },

{ 0x00, 0x80, 0x00 },