madcow/scummvm-cursorfix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
Files
5b116987315fa80e8d88f1eedb4927173ffb1461
scummvm-cursorfix/engines/gob/inter_v7.cpp
Leon Krieg 5b11698731 Initial commit
2026-02-02 04:50:13 +01:00

2362 lines
74 KiB
C++
Raw Blame History

/* 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/>.
*
*
* This file is dual-licensed.
* In addition to the GPLv3 license mentioned above, this code is also
* licensed under LGPL 2.1. See LICENSES/COPYING.LGPL file for the
* full text of the license.
*
*/
#include "common/config-manager.h"
#include "common/endian.h"
#include "common/archive.h"
#include "common/translation.h"
#include "common/formats/winexe_pe.h"
#include "common/formats/winexe_ne.h"
#include "graphics/cursorman.h"
#include "graphics/wincursor.h"
#include "gui/message.h"
#include "image/iff.h"
#include "gob/dbase.h"
#include "gob/gob.h"
#include "gob/global.h"
#include "gob/dataio.h"
#include "gob/inter.h"
#include "gob/game.h"
#include "gob/script.h"
#include "gob/expression.h"
#include "gob/videoplayer.h"
#include "gob/resources.h"
#include "gob/sound/sound.h"
#include "gob/save/saveload.h"
namespace Gob {
#define OPCODEVER Inter_v7
#define OPCODEDRAW(i, x) _opcodesDraw[i]._OPCODEDRAW(OPCODEVER, x)
#define OPCODEFUNC(i, x) _opcodesFunc[i]._OPCODEFUNC(OPCODEVER, x)
#define OPCODEGOB(i, x) _opcodesGob[i]._OPCODEGOB(OPCODEVER, x)
Inter_v7::Inter_v7(GobEngine *vm) : Inter_Playtoons(vm), _inis(vm), _currentHtmlContext(nullptr) {
}
void Inter_v7::setupOpcodesDraw() {
Inter_Playtoons::setupOpcodesDraw();
OPCODEDRAW(0x0C, o7_draw0x0C);
OPCODEDRAW(0x0D, o7_setCursorToLoadFromExec);
OPCODEDRAW(0x15, o7_freeMult);
OPCODEDRAW(0x17, o7_loadMultObject);
OPCODEDRAW(0x44, o7_displayWarning);
OPCODEDRAW(0x45, o7_logString);
OPCODEDRAW(0x52, o7_moveGoblin);
OPCODEDRAW(0x55, o7_setGoblinState);
OPCODEDRAW(0x57, o7_intToString);
OPCODEDRAW(0x59, o7_callFunction);
OPCODEDRAW(0x5A, o7_loadFunctions);
OPCODEDRAW(0x60, o7_copyFile);
OPCODEDRAW(0x61, o7_deleteFile);
OPCODEDRAW(0x62, o7_moveFile);
OPCODEDRAW(0x80, o7_initScreen);
OPCODEDRAW(0x83, o7_playVmdOrMusic);
OPCODEDRAW(0x85, o7_openItk);
OPCODEDRAW(0x89, o7_setActiveCD);
OPCODEDRAW(0x8A, o7_findFile);
OPCODEDRAW(0x8B, o7_findNextFile);
OPCODEDRAW(0x8C, o7_getSystemProperty);
OPCODEDRAW(0x8E, o7_getFileInfo);
OPCODEDRAW(0x90, o7_loadImage);
OPCODEDRAW(0x91, o7_copyDataToClipboard);
OPCODEDRAW(0x93, o7_setVolume);
OPCODEDRAW(0x95, o7_zeroVar);
OPCODEDRAW(0xA0, o7_draw0xA0);
OPCODEDRAW(0xA1, o7_getINIValue);
OPCODEDRAW(0xA2, o7_setINIValue);
OPCODEDRAW(0xA4, o7_loadIFFPalette);
OPCODEDRAW(0xAA, o7_openDatabase);
OPCODEDRAW(0xAC, o7_openDatabaseTable);
OPCODEDRAW(0xAD, o7_closeDatabaseTable);
OPCODEDRAW(0xAE, o7_draw0xAE);
OPCODEDRAW(0xAF, o7_openDatabaseIndex);
OPCODEDRAW(0xB0, o7_findDatabaseRecord);
OPCODEDRAW(0xB1, o7_findNextDatabaseRecord);
OPCODEDRAW(0xB4, o7_getDatabaseRecordValue);
OPCODEDRAW(0xB6, o7_checkAnyDatabaseRecordFound);
OPCODEDRAW(0xBE, o7_openHtmlFile);
OPCODEDRAW(0xBF, o7_closeHtmlFile);
OPCODEDRAW(0xC0, o7_seekHtmlFile);
OPCODEDRAW(0xC1, o7_nextKeywordHtmlFile);
OPCODEDRAW(0xC3, o7_draw0xC3);
OPCODEDRAW(0xC4, o7_openTranslationDB);
OPCODEDRAW(0xC5, o7_closeTranslationDB);
OPCODEDRAW(0xC6, o7_getDBString);
OPCODEDRAW(0xCC, o7_draw0xCC);
OPCODEDRAW(0xCD, o7_draw0xCD);
OPCODEDRAW(0xCE, o7_draw0xCE);
OPCODEDRAW(0xDC, o7_draw0xDC);
OPCODEDRAW(0xDD, o7_draw0xDD);
OPCODEDRAW(0xDE, o7_draw0xDE);
OPCODEDRAW(0xDF, o7_draw0xDF);
OPCODEDRAW(0xE0, o7_draw0xE0);
OPCODEDRAW(0xE1, o7_draw0xE1);
OPCODEDRAW(0xE2, o7_draw0xE2);
OPCODEDRAW(0xE3, o7_draw0xE3);
OPCODEDRAW(0xE4, o7_draw0xE4);
OPCODEDRAW(0xE6, o7_draw0xE6);
OPCODEDRAW(0xE7, o7_draw0xE7);
OPCODEDRAW(0xE8, o7_draw0xE8);
OPCODEDRAW(0xE8, o7_draw0xE9);
OPCODEDRAW(0xF0, o7_draw0xF0);
OPCODEDRAW(0xF2, o7_executeModAddEvent);
OPCODEDRAW(0xF4, o7_executeModSetLength);
OPCODEDRAW(0xF5, o7_executeModStart);
OPCODEDRAW(0xF7, o7_executeModGetPosition);
OPCODEDRAW(0xFA, o7_vmdGetSoundBuffer);
OPCODEDRAW(0xFB, o7_vmdReleaseSoundBuffer);
}
void Inter_v7::setupOpcodesFunc() {
Inter_Playtoons::setupOpcodesFunc();
OPCODEFUNC(0x03, o7_loadCursor);
OPCODEFUNC(0x11, o7_printText);
OPCODEFUNC(0x33, o7_fillRect);
OPCODEFUNC(0x34, o7_drawLine);
OPCODEFUNC(0x36, o7_invalidate);
OPCODEFUNC(0x3E, o7_getFreeMem);
OPCODEFUNC(0x3F, o7_checkData);
OPCODEFUNC(0x4D, o7_readData);
OPCODEFUNC(0x4E, o7_writeData);
OPCODEFUNC(0x4F, o7_manageDataFile);
}
void Inter_v7::setupOpcodesGob() {
OPCODEGOB(0, o7_saveAdi4ExerciseAttemptsCount);
OPCODEGOB(1, o7_saveAdi4ExerciseResults);
OPCODEGOB(55, o7_writeUnknownChildDataToGameVariables);
OPCODEGOB(64, o7_writeUnknownAppChildDataToGameVariables);
OPCODEGOB(74, o7_writeChildScoreToGameVariables);
OPCODEGOB(406, o7_startAdi4Application);
OPCODEGOB(407, o7_xorDeobfuscate);
OPCODEGOB(408, o7_xorObfuscate);
OPCODEGOB(410, o7_resolvePath);
OPCODEGOB(420, o7_ansiToOEM);
OPCODEGOB(421, o7_oemToANSI);
OPCODEGOB(512, o7_setDBStringEncoding);
OPCODEGOB(513, o7_gob0x201);
OPCODEGOB(600, o7_getFreeDiskSpace);
OPCODEGOB(782, o7_dummy);
}
void Inter_v7::o7_draw0x0C() {
WRITE_VAR(11, 0);
}
void Inter_v7::o7_loadCursor(OpFuncParams &params) {
int16 id = _vm->_game->_script->readInt16();
if ((id == -1) || (id == -2)) {
char file[10];
if (id == -1) {
for (int i = 0; i < 9; i++)
file[i] = _vm->_game->_script->readChar();
} else
strncpy(file, GET_VAR_STR(_vm->_game->_script->readInt16()), 10);
file[9] = '\0';
uint16 start = _vm->_game->_script->readUint16();
int8 index = _vm->_game->_script->readInt8();
VideoPlayer::Properties props;
props.sprite = -1;
int vmdSlot = _vm->_vidPlayer->openVideo(false, file, props);
if (vmdSlot == -1) {
warning("Can't open video \"%s\" as cursor", file);
return;
}
int16 framesCount = _vm->_vidPlayer->getFrameCount(vmdSlot);
for (int i = 0; i < framesCount; i++) {
props.startFrame = i;
props.lastFrame = i;
props.waitEndFrame = false;
_vm->_vidPlayer->play(vmdSlot, props);
_vm->_vidPlayer->copyFrame(vmdSlot, *_vm->_draw->_cursorSprites,
0, 0, _vm->_draw->_cursorWidth, _vm->_draw->_cursorWidth,
(start + i) * _vm->_draw->_cursorWidth, 0);
}
_vm->_vidPlayer->closeVideo(vmdSlot);
_vm->_draw->_cursorAnimLow[index] = start;
_vm->_draw->_cursorAnimHigh[index] = framesCount + start - 1;
_vm->_draw->_cursorAnimDelays[index] = 10;
return;
}
int8 index = _vm->_game->_script->readInt8();
Resource *resource = _vm->_game->_resources->getResource((uint16) id);
if (!resource)
return;
int16 cursorWidth = MAX(_vm->_draw->_cursorWidth, resource->getWidth());
int16 cursorHeight = MAX(_vm->_draw->_cursorHeight, resource->getHeight());
_vm->_draw->resizeCursors(cursorWidth, cursorHeight, index + 1, true);
if ((index * _vm->_draw->_cursorWidth) >= _vm->_draw->_cursorSprites->getWidth())
return;
_vm->_draw->_cursorSprites->fillRect(index * _vm->_draw->_cursorWidth, 0,
index * _vm->_draw->_cursorWidth + _vm->_draw->_cursorWidth - 1,
_vm->_draw->_cursorHeight - 1, 0);
_vm->_video->drawPackedSprite(resource->getData(),
resource->getWidth(), resource->getHeight(),
index * _vm->_draw->_cursorWidth, 0, 0, *_vm->_draw->_cursorSprites);
_vm->_draw->_cursorAnimLow[index] = 0;
delete resource;
}
void Inter_v7::o7_setCursorToLoadFromExec() {
int16 cursorIndex = _vm->_game->_script->readValExpr();
Common::String cursorName = _vm->_game->_script->evalString();
debugC(1, kDebugGraphics, "o7_setCursorToLoadFromExec : index=%d, cursorName=%s", cursorIndex, cursorName.c_str());
_vm->_draw->_cursorNames[cursorIndex] = cursorName;
}
void Inter_v7::o7_freeMult() {
_vm->_mult->freeMult(true);
}
void Inter_v7::o7_loadMultObject() {
assert(_vm->_mult->_objects);
uint16 objIndex = _vm->_game->_script->readValExpr();
Mult::Mult_Object &obj = _vm->_mult->_objects[objIndex];
Mult::Mult_AnimData &objAnim = *(obj.pAnimData);
auto x = _vm->_game->_script->readValExpr();
auto y = _vm->_game->_script->readValExpr();
debugC(4, kDebugGameFlow, "Loading mult object %d -> x = %d, y = %d", objIndex, x ,y);
*obj.pPosX = x;
*obj.pPosY = y;
byte *multData = (byte *) &objAnim;
for (int i = 0; i < 11; i++) {
if (_vm->_game->_script->peekByte() != 99)
multData[i] = _vm->_game->_script->readValExpr();
else
_vm->_game->_script->skip(1);
}
if (((int32)*obj.pPosX == -1234) && ((int32)*obj.pPosY == -4321)) {
if (obj.videoSlot > 0) {
_vm->_mult->closeObjVideo(obj);
} else
_vm->_draw->freeSprite(50 + objIndex);
objAnim.isStatic = 1;
obj.animVariables = nullptr;
obj.lastLeft = -1;
obj.lastTop = -1;
obj.lastBottom = -1;
obj.lastRight = -1;
}
}
void Inter_v7::o7_displayWarning() {
Common::String caption = _vm->_game->_script->evalString();
Common::String text = _vm->_game->_script->evalString();
Common::String source = _vm->_game->_script->evalString();
Common::String msg = _vm->_game->_script->evalString();
Common::String param = _vm->_game->_script->evalString();
warning("%s: %s (%s)", source.c_str(), msg.c_str(), param.c_str());
}
void Inter_v7::o7_logString() {
Common::String str0 = _vm->_game->_script->evalString();
Common::String str1 = _vm->_game->_script->evalString();
TimeDate t;
_vm->_system->getTimeAndDate(t);
debug(1, "%-9s%04d-%02d-%02dT%02d:%02d:%02d --> %s", str0.c_str(),
t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,
t.tm_hour, t.tm_min, t.tm_sec, str1.c_str());
}
void Inter_v7::o7_moveGoblin() {
int16 destX, destY;
int16 index;
destX = _vm->_game->_script->readValExpr();
destY = _vm->_game->_script->readValExpr();
index = _vm->_game->_script->readValExpr();
Mult::Mult_Object &obj = _vm->_mult->_objects[index];
Mult::Mult_AnimData &animData = *(obj.pAnimData);
if (animData.animType < 10 || animData.animType > 12)
return;
animData.pathExistence = 0;
animData.animTypeBak = 0;
animData.framesLeft = 0;
animData.isBusy = 0;
obj.gobDestX = destX;
animData.gobDestX_maybe = destX;
obj.gobDestY = destY;
animData.gobDestY_maybe = destY;
animData.newState = 0;
obj.goblinX = animData.destX;
obj.goblinY = animData.destY;
if (animData.animType == 10 && animData.curLookDir <= 10)
return;
animData.destXBak = animData.destX;
animData.destYBak = animData.destY;
animData.animType = 10;
debugC(1, kDebugVideo, "o7_moveGoblin Obj %s destX = %d, destY = %d (gobX = %d, gobY = %d) ", obj.animName, destX, destY, obj.goblinX, obj.goblinY);
_vm->_goblin->initiateMove(&obj);
}
void Inter_v7::o7_setGoblinState() {
int16 index = _vm->_game->_script->readValExpr();
int16 state = _vm->_game->_script->readValExpr();
int16 type = _vm->_game->_script->readValExpr();
Mult::Mult_Object &obj = _vm->_mult->_objects[index];
Mult::Mult_AnimData &animData = *(obj.pAnimData);
if (animData.animType < 10 || animData.animType > 12)
return;
animData.pathExistence = 1;
animData.animType = 10;
obj.destX = obj.goblinX;
obj.destY = obj.goblinY;
debugC(1, kDebugVideo, "o7_setGoblinState Obj %s state = %d, type = %d = %d ", obj.animName, state, type, state + type*100);
_vm->_goblin->setGoblinState(&obj, state + type * 100);
if (type != 0) {
animData.pathExistence = 3;
animData.animType = 12;
animData.frame = 0;
}
}
void Inter_v7::o7_intToString() {
uint16 valueIndex = _vm->_game->_script->readVarIndex();
uint16 destIndex = _vm->_game->_script->readVarIndex();
uint32 maxLength = _vm->_global->_inter_animDataSize * 4 - 1;
Common::sprintf_s(GET_VARO_STR(destIndex), maxLength, "%d", (int32)READ_VARO_UINT32(valueIndex));
}
void Inter_v7::o7_callFunction() {
Common::String tot = _vm->_game->_script->evalString();
Common::String function = _vm->_game->_script->evalString();
int16 param = _vm->_game->_script->readValExpr();
if (!tot.contains('.'))
tot += ".TOT";
_vm->_game->callFunction(tot, function, param);
}
void Inter_v7::o7_loadFunctions() {
Common::String tot = _vm->_game->_script->evalString();
int16 flags = _vm->_game->_script->readValExpr();
if (!tot.contains('.'))
tot += ".TOT";
_vm->_game->loadFunctions(tot, flags);
}
void Inter_v7::copyFile(const Common::String &sourceFile, bool sourceIsCd, const Common::String &destFile) {
SaveLoad::SaveMode mode1 = _vm->_saveLoad->getSaveMode(sourceFile.c_str());
SaveLoad::SaveMode mode2 = _vm->_saveLoad->getSaveMode(destFile.c_str());
if (mode2 == SaveLoad::kSaveModeIgnore || mode2 == SaveLoad::kSaveModeExists)
return;
else if (mode2 == SaveLoad::kSaveModeSave) {
if (mode1 == SaveLoad::kSaveModeNone || sourceIsCd) {
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(sourceFile);
if (!stream)
return;
int32 size = stream->size();
// TODO: avoid this allocation by implementing a Stream version of saveFromRaw (e.g. "saveFromStream")
byte *data = new byte[size];
stream->read(data, size);
_vm->_saveLoad->saveFromRaw(destFile.c_str(), data, size, 0);
delete[] data;
delete stream;
} else if (mode1 == SaveLoad::kSaveModeSave) {
_vm->_saveLoad->copySaveGame(sourceFile.c_str(), destFile.c_str());
} else
warning("o7_copyFile(): unsupported mode %d for source \"%s\" while copying to \"%s\" ",
mode1,
sourceFile.c_str(),
destFile.c_str());
} else
warning("Attempted to write to file \"%s\" while copying from \"%s\"",
destFile.c_str(),
sourceFile.c_str());
}
void Inter_v7::o7_copyFile() {
Common::String path1 = _vm->_game->_script->evalString();
Common::String path2 = _vm->_game->_script->evalString();
debugC(2, kDebugFileIO, "Copy file \"%s\" to \"%s", path1.c_str(), path2.c_str());
bool sourceIsCd = false;
Common::String file1 = getFile(path1.c_str(), true, &sourceIsCd);
Common::String file2 = getFile(path2.c_str());
if (!sourceIsCd && file1.equalsIgnoreCase(file2)) {
warning("o7_copyFile(): \"%s\" == \"%s\"", path1.c_str(), path2.c_str());
return;
}
copyFile(file1, sourceIsCd, file2);
}
void Inter_v7::o7_deleteFile() {
Common::Path file(_vm->_game->_script->evalString(), '\\');
debugC(2, kDebugFileIO, "Delete file \"%s\"", file.toString().c_str());
bool isPattern = file.toString().contains('*') || file.toString().contains('?');
Common::List<Common::Path> files;
if (isPattern) {
files = _vm->_saveLoad->getFilesMatchingPattern(file);
debugC(2, kDebugFileIO, "Delete file matching pattern \"%s\" (%d matching file(s))", file.toString().c_str(), files.size());
for (const Common::Path &matchingFile : files)
debugC(5, kDebugFileIO, "Matching file: %s", matchingFile.toString().c_str());
} else {
files.push_back(file);
debugC(2, kDebugFileIO, "Delete file \"%s\"", file.toString().c_str());
}
if (_vm->getGameType() == kGameTypeAdibou2
&& isPattern
&& file.toString().hasPrefix("DATA/??????")) {
// WORKAROUND a bug in original game: files APPLI_<N>.INF and CRITE_<N>.INF should not be deleted when removing character <N>
// Those files contain *application <N>* data, not "character <N>" data
for (Common::List<Common::Path>::iterator it = files.begin(); it != files.end(); ++it) {
if (it->toString().matchString("DATA/appli_??.inf", true) || it->toString().matchString("DATA/crite_??.inf", true)) {
debugC(2, kDebugFileIO, "o7_deleteFile: ignoring deletion of file \"%s\" when processing pattern %s (delete character bug workaround)",
it->toString().c_str(),
file.toString().c_str());
it = files.reverse_erase(it);
}
}
}
for (const Common::Path &fileToDelete : files) {
SaveLoad::SaveMode mode = _vm->_saveLoad->getSaveMode(fileToDelete.toString().c_str());
if (mode == SaveLoad::kSaveModeSave) {
if (!_vm->_saveLoad->deleteFile(fileToDelete.toString().c_str())) {
warning("Cannot delete file \"%s\"", fileToDelete.toString().c_str());
}
} else if (mode == SaveLoad::kSaveModeNone)
warning("Attempted to delete file \"%s\"", fileToDelete.toString().c_str());
}
}
void Inter_v7::o7_moveFile() {
Common::String path1 = _vm->_game->_script->evalString();
Common::String path2 = _vm->_game->_script->evalString();
bool sourceIsCd = false;
Common::String file1 = getFile(path1.c_str(), true, &sourceIsCd);
Common::String file2 = getFile(path2.c_str());
if (!sourceIsCd && file1.equalsIgnoreCase(file2)) {
warning("o7_moveFile(): \"%s\" == \"%s\"", path1.c_str(), path2.c_str());
return;
}
copyFile(file1, sourceIsCd, file2);
SaveLoad::SaveMode mode = _vm->_saveLoad->getSaveMode(file1.c_str());
if (mode == SaveLoad::kSaveModeSave) {
_vm->_saveLoad->deleteFile(file1.c_str());
} else if (mode == SaveLoad::kSaveModeNone)
warning("Attempted to delete file \"%s\" while moving it to \"%s\"", file1.c_str(), file2.c_str());
}
void Inter_v7::o7_initScreen() {
int16 videoMode;
int16 width, height;
videoMode = _vm->_game->_script->readInt16();
if (videoMode == 32000 || videoMode == 256) {
bool trueColor = videoMode == 32000;
// Comment the next line and uncomment the following ones to use the original pixel format (RGB555) for debugging purposes
_vm->setTrueColor(trueColor, false, nullptr);
// Graphics::PixelFormat format = Graphics::createPixelFormat<555>();
// _vm->setTrueColor(trueColor, false, &format);
}
videoMode &= 0xFF;
int16 offY = 0;
width = _vm->_game->_script->readValExpr();
height = _vm->_game->_script->readValExpr();
if (videoMode == 0)
videoMode = 0x14;
if (videoMode != 0x18)
_vm->_video->clearScreen();
if (videoMode == 0x13) {
if (width == -1)
width = 320;
if (height == -1)
height = 200;
_vm->_width = 320;
_vm->_height = 200;
_vm->_video->setSize();
} else if (_vm->_global->_videoMode == 0x13) {
width = _vm->_width = 640;
height = _vm->_height = 480;
_vm->_video->setSize();
}
_vm->_global->_fakeVideoMode = videoMode;
// Some versions require this
if (videoMode == 0x18)
_vm->_global->_fakeVideoMode = 0x37;
if ((videoMode == _vm->_global->_videoMode) && (width == -1))
return;
if (width > 0)
_vm->_video->_surfWidth = width;
if (height > 0)
_vm->_video->_surfHeight = height;
_vm->_video->_screenDeltaX = 0;
if (_vm->_video->_surfWidth < _vm->_width)
_vm->_video->_screenDeltaX = (_vm->_width - _vm->_video->_surfWidth) / 2;
_vm->_global->_mouseMinX = _vm->_video->_screenDeltaX;
_vm->_global->_mouseMaxX = _vm->_video->_screenDeltaX + _vm->_video->_surfWidth - 1;
_vm->_video->_splitStart = _vm->_video->_surfHeight - offY;
_vm->_video->_splitHeight1 = MIN<int16>(_vm->_height, _vm->_video->_surfHeight);
_vm->_video->_splitHeight2 = offY;
if ((_vm->_video->_surfHeight + offY) < _vm->_height)
_vm->_video->_screenDeltaY = (_vm->_height - (_vm->_video->_surfHeight + offY)) / 2;
else
_vm->_video->_screenDeltaY = 0;
_vm->_global->_mouseMaxY = (_vm->_video->_surfHeight + _vm->_video->_screenDeltaY) - offY - 1;
_vm->_global->_mouseMinY = _vm->_video->_screenDeltaY;
if (videoMode != 0x18) {
_vm->_draw->closeScreen();
_vm->_util->clearPalette();
memset(_vm->_global->_redPalette, 0, 256);
memset(_vm->_global->_greenPalette, 0, 256);
memset(_vm->_global->_bluePalette, 0, 256);
_vm->_video->_splitSurf.reset();
_vm->_draw->_spritesArray[24].reset();
_vm->_draw->_spritesArray[25].reset();
}
_vm->_global->_videoMode = videoMode;
if (videoMode != 0x18)
_vm->_video->initPrimary(videoMode);
WRITE_VAR(15, _vm->_global->_fakeVideoMode);
_vm->_global->_setAllPalette = true;
_vm->_util->setMousePos(_vm->_global->_inter_mouseX,
_vm->_global->_inter_mouseY);
if (videoMode != 0x18)
_vm->_util->clearPalette();
_vm->_draw->initScreen();
_vm->_util->setScrollOffset();
}
void Inter_v7::o7_playVmdOrMusic() {
Common::String file = _vm->_game->_script->evalString();
VideoPlayer::Properties props;
props.x = _vm->_game->_script->readValExpr();
props.y = _vm->_game->_script->readValExpr();
props.startFrame = _vm->_game->_script->readValExpr();
props.lastFrame = _vm->_game->_script->readValExpr();
props.breakKey = _vm->_game->_script->readValExpr();
props.flags = _vm->_game->_script->readValExpr();
props.palStart = _vm->_game->_script->readValExpr();
props.palEnd = _vm->_game->_script->readValExpr();
props.palCmd = 1 << (props.flags & 0x3F);
props.forceSeek = true;
int startFrameCopy = props.startFrame;
if (props.startFrame == -20 || props.startFrame == -200) {
props.startFrame = -2;
}
debugC(1, kDebugVideo, "Playing video \"%s\" @ %d+%d, frames %d - %d, "
"paletteCmd %d (%d - %d), flags %X", file.c_str(),
props.x, props.y, props.startFrame, props.lastFrame,
props.palCmd, props.palStart, props.palEnd, props.flags);
bool close = false;
if (props.lastFrame == -1) {
close = true;
} else if (props.lastFrame == -2) {
// TODO: when props.lastFrame == -2, the VMD seems to be loaded/played in two steps.
// First o7_playVmdOrMusic is called with props.firstFrame == -2, then later with
// props.firstFrame == -1.
// We simply ignore the first step for now, and play the whole video in the second step.
if (props.startFrame == -2)
return;
props.startFrame = 0;
props.lastFrame = -1;
} else if (props.lastFrame == -3 && _vm->_mult->_objects != nullptr) {
if (file.empty()) {
if (props.flags & 0x400) {
if (!_vm->_mult->_objects[props.startFrame].pAnimData->isStatic) {
if (_vm->_mult->_objects[props.startFrame].videoSlot > 0) {
// TODO: something more is needed here, but unclear what
//_vm->_vidPlayer->pauseVideo(_vm->_mult->_objects[props.startFrame].videoSlot - 1, true);
}
}
}
return;
}
props.flags = VideoPlayer::kFlagOtherSurface;
_vm->_mult->_objects[props.startFrame].pAnimData->animation = -props.startFrame - 1;
props.sprite = 50 - _vm->_mult->_objects[props.startFrame].pAnimData->animation - 1;
if (_vm->_mult->_objects[props.startFrame].videoSlot > 0)
_vm->_mult->closeObjVideo(_vm->_mult->_objects[props.startFrame]);
uint32 x = props.x;
uint32 y = props.y;
int slot = _vm->_mult->openObjVideo(file, props, -props.startFrame - 1);
if (x == 0xFFFFFFFF) {
*_vm->_mult->_objects[props.startFrame].pPosX = _vm->_vidPlayer->getDefaultX(slot);
*_vm->_mult->_objects[props.startFrame].pPosY = _vm->_vidPlayer->getDefaultY(slot);
} else {
*_vm->_mult->_objects[props.startFrame].pPosX = x;
*_vm->_mult->_objects[props.startFrame].pPosY = y;
}
return;
} else if (props.lastFrame == -4) {
warning("Woodruff Stub: Video/Music command -4: Play background video %s", file.c_str());
return;
} else if (props.lastFrame == -5) {
// warning("Urban/Playtoons Stub: Stop without delay");
_vm->_sound->bgStop();
return;
} else if (props.lastFrame == -6) {
// warning("Urban/Playtoons Stub: Video/Music command -6 (cache video)");
return;
} else if (props.lastFrame == -7) {
// warning("Urban/Playtoons Stub: Video/Music command -7 (flush cache)");
return;
} else if ((props.lastFrame == -8) || (props.lastFrame == -9)) {
if (!file.contains('.'))
file += ".WA8";
probe16bitMusic(file);
if (props.lastFrame == -9)
debugC(0, kDebugVideo, "Urban/Playtoons Stub: Delayed music stop?");
_vm->_sound->bgStop();
_vm->_sound->bgPlay(file.c_str(), SOUND_WAV);
return;
} else if (props.lastFrame <= -10) {
if (props.lastFrame <= -100) {
// The original does an early return here if the video is not in the cache
// if (video not in cache)
// return;
props.noWaitSound = true;
props.lastFrame += 100;
}
if (props.lastFrame <= -20)
props.noBlock = true;
props.slot = (-props.lastFrame) % 10;
}
if (props.startFrame == -1)
close = true;
if (props.startFrame == -2)
props.noBlock = true;
if ((props.slot == 1 && !(props.flags & VideoPlayer::kFlagNoVideo)) ||
startFrameCopy == -20) {
props.loop = true;
// TODO: one more mode is missing if start frame == -200
// In that case, the video is not closed at the end, but does not loop either
}
_vm->_vidPlayer->evaluateFlags(props);
bool primary = true;
if (props.noBlock && (props.flags & VideoPlayer::kFlagNoVideo))
primary = false;
props.reuseSlotWitSameFilename = true;
int slot = _vm->_vidPlayer->openVideo(primary, file, props);
if (slot < 0) {
WRITE_VAR(11, (uint32) -1);
return;
}
if (_vm->_vidPlayer->getVideoBufferSize(slot) == 0 || !_vm->_vidPlayer->hasVideo(slot)) {
props.noBlock = true;
}
if (_vm->_vidPlayer->getSoundFlags() & 0x100) {
props.noWaitSound = true;
}
if (props.startFrame == -2 || props.startFrame == -3) {
props.startFrame = 0;
props.lastFrame = 0;
close = false;
}
if (props.startFrame >= 0)
_vm->_vidPlayer->play(slot, props);
if (close) {
if (!props.canceled)
_vm->_vidPlayer->waitSoundEnd(slot);
_vm->_vidPlayer->closeVideo(slot);
}
}
void Inter_v7::o7_setActiveCD() {
Common::String str0 = _vm->_game->_script->evalString();
Common::String str1 = _vm->_game->_script->evalString();
Common::ArchiveMemberDetailsList files;
SearchMan.listMatchingMembers(files, Common::Path(str0, '\\'));
Common::Path savedCDpath = _currentCDPath;
for (Common::ArchiveMemberDetails file : files) {
if (setCurrentCDPath(file.arcName)) {
debugC(5, kDebugFileIO, "o7_setActiveCD: %s -> %s", savedCDpath.toString().c_str(), _currentCDPath.toString().c_str());
storeValue(1);
return;
}
}
storeValue(0);
}
void Inter_v7::o7_openItk() {
Common::String file = getFile(_vm->_game->_script->evalString());
if (!file.contains('.'))
file += ".ITK";
bool openSuccess = _vm->_dataIO->openArchive(file, false);
WRITE_VAR_OFFSET(108, openSuccess);
}
void Inter_v7::o7_findFile() {
const char *filePatternStr = _vm->_game->_script->evalString();
bool isPattern = Common::String(filePatternStr).contains('*') || Common::String(filePatternStr).contains('?');
Common::Path filePattern(getFile(filePatternStr, !isPattern), '\\');
Common::ArchiveMemberList files;
SearchMan.listMatchingMembers(files, filePattern);
Common::List<Common::Path> filePaths;
for (Common::ArchiveMemberPtr file : files) {
filePaths.push_back(file->getPathInArchive());
}
Common::List<Common::Path> matchingSaveFiles = _vm->_saveLoad->getFilesMatchingPattern(filePattern.toString().c_str());
for (Common::Path &filename : matchingSaveFiles) {
if (_vm->_saveLoad->getSize(filename.toString().c_str()) >= 0) {
filePaths.push_back(filename);
}
}
Common::List<Common::Path> filenamesWithoutDuplicates;
for (Common::Path &filename : filePaths) {
bool found = false;
for (Common::Path &filename2 : filenamesWithoutDuplicates) {
if (filename == filename2) {
found = true;
break;
}
}
if (!found)
filenamesWithoutDuplicates.push_back(filename);
}
debugC(5, kDebugFileIO, "o7_findFile(%s): %d matches after discarding duplicates",
filePattern.toString().c_str(),
filenamesWithoutDuplicates.size());
if (filenamesWithoutDuplicates.empty()) {
storeString("");
storeValue(0);
} else {
Common::Path file = filenamesWithoutDuplicates.front();
filenamesWithoutDuplicates.pop_front();
debugC(5, kDebugFileIO, "o7_findFile(%s): first match = %s",
filePattern.toString().c_str(),
file.toString().c_str());
storeString(file.getLastComponent().toString().c_str());
storeValue(1);
}
_findFileMatches = filenamesWithoutDuplicates;
}
void Inter_v7::o7_findNextFile() {
uint16 type;
uint16 varIndex = _vm->_game->_script->readVarIndex(0, &type);
Common::Path file;
if (!_findFileMatches.empty()) {
file = _findFileMatches.front();
_findFileMatches.pop_front();
}
debugC(5, kDebugFileIO, "o7_findNextFile: new match = %s",
file.toString().c_str());
storeString(varIndex, type, file.getLastComponent().toString().c_str());
storeValue(file.empty() ? 0 : 1);
}
void Inter_v7::o7_getSystemProperty() {
const char *property = _vm->_game->_script->evalString();
if (!scumm_stricmp(property, "TotalPhys")) {
// HACK
// NOTE: Any value lower than 8 MB will disable the icon bar animations in Adibou2/Sciences
storeValue(16000000);
return;
}
if (!scumm_stricmp(property, "AvailPhys")) {
// HACK
storeValue(16000000);
return;
}
if (!scumm_stricmp(property, "TimeGMT")) {
renewTimeInVars();
storeValue(0);
return;
}
warning("Inter_v7::o7_getSystemProperty(): Unknown property \"%s\"", property);
storeValue(0);
}
void Inter_v7::o7_getFileInfo() {
Common::String file = getFile(_vm->_game->_script->evalString());
Common::String property = _vm->_game->_script->evalString();
uint16 resultVarType = 0;
uint16 resultVar = _vm->_game->_script->readVarIndex(nullptr, &resultVarType);
_vm->_game->_script->readVarIndex(); // Unknown, some status variable?
if (property.hasPrefix("IMAGE")) {
if (!file.contains('.'))
file += ".TGA";
Common::SeekableReadStream *imageFile = _vm->_dataIO->getFile(file);
if (!imageFile) {
warning("o7_getFileInfo(): No such file \"%s\"", file.c_str());
return;
}
uint32 width = (uint32)-1;
uint32 height = (uint32)-1;
uint32 bpp = (uint32)-1;
Surface::getImageInfo(*imageFile, width, height, bpp);
if (property == "IMAGELARGEUR")
storeValue(resultVar, resultVarType, width);
else if (property == "IMAGEHAUTEUR")
storeValue(resultVar, resultVarType, height);
else if (property == "IMAGECOULEUR")
storeValue(resultVar, resultVarType, bpp);
else
warning("o7_getFileInfo(): Unknown image property \"%s\"", property.c_str());
} else {
if (property == "NOMBRELIGNE") {
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(file);
if (!stream) {
warning("o7_getFileInfo(): No such file \"%s\"", file.c_str());
return;
}
int nbrLines = 0;
while (!stream->eos()) {
stream->readLine(true);
++nbrLines;
}
storeValue(resultVar, resultVarType, nbrLines);
} else {
warning("o7_getFileInfo(): Unknown property \"%s\"", property.c_str());
}
}
}
void Inter_v7::o7_loadImage() {
Common::String file = getFile(_vm->_game->_script->evalString());
if (!file.contains('.'))
file += ".TGA";
int16 spriteIndex = _vm->_game->_script->readValExpr();
int16 left = _vm->_game->_script->readValExpr();
int16 top = _vm->_game->_script->readValExpr();
int16 width = _vm->_game->_script->readValExpr();
int16 height = _vm->_game->_script->readValExpr();
int16 x = _vm->_game->_script->readValExpr();
int16 y = _vm->_game->_script->readValExpr();
int16 transp = _vm->_game->_script->readValExpr();
if (spriteIndex > 100)
spriteIndex -= 80;
if ((spriteIndex < 0) || (spriteIndex >= Draw::kSpriteCount)) {
warning("o7_loadImage(): Sprite %d out of range", spriteIndex);
return;
}
SurfacePtr destSprite = _vm->_draw->_spritesArray[spriteIndex];
if (!destSprite) {
warning("o7_loadImage(): Sprite %d does not exist", spriteIndex);
return;
}
Common::SeekableReadStream *imageFile = _vm->_dataIO->getFile(file);
if (!imageFile) {
warning("o7_loadImage(): No such file \"%s\"", file.c_str());
return;
}
int16 right = left + width - 1;
int16 bottom = top + height - 1;
if (!destSprite->loadImage(*imageFile, left, top, right, bottom, x, y, transp, _vm->getPixelFormat())) {
warning("o7_loadImage(): Failed to load image \"%s\"", file.c_str());
return;
}
}
void Inter_v7::o7_copyDataToClipboard() {
Common::String data = _vm->_game->_script->evalString();
warning("STUB: Adi4: Copy data '%s' to clipboard", data.c_str());
}
void Inter_v7::o7_setVolume() {
uint32 volume = _vm->_game->_script->readValExpr();
warning("Addy Stub: Set volume %d (0 - 100)", volume);
}
void Inter_v7::o7_zeroVar() {
uint16 index = _vm->_game->_script->readVarIndex();
WRITE_VARO_UINT32(index, 0);
}
void Inter_v7::o7_draw0xA0() {
_vm->_game->_script->readValExpr();
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readValExpr();
}
void Inter_v7::o7_getINIValue() {
bool isCd = false;
Common::String file = getFile(_vm->_game->_script->evalString(), true, &isCd);
Common::String section = _vm->_game->_script->evalString();
Common::String key = _vm->_game->_script->evalString();
Common::String def = _vm->_game->_script->evalString();
section = oemToANSI(section);
key.trim();
key = oemToANSI(key);
Common::String value;
_inis.getValue(value, file, isCd, section, key, def);
value = ansiToOEM(value);
storeString(value.c_str());
debugC(5, kDebugGameFlow, "o7_getINIValue: %s: [%s] %s = %s", file.c_str(), section.c_str(), key.c_str(), value.c_str());
}
void Inter_v7::o7_setINIValue() {
bool isCd = false;
Common::String file = getFile(_vm->_game->_script->evalString(), true, &isCd);
Common::String section = _vm->_game->_script->evalString();
Common::String key = _vm->_game->_script->evalString();
Common::String value = _vm->_game->_script->evalString();
section = oemToANSI(section);
key.trim();
key = oemToANSI(key);
value = oemToANSI(value);
bool success = _inis.setValue(file, isCd, section, key, value);
WRITE_VAR(27, success ? 1 : 0);
debugC(5, kDebugGameFlow, "o7_setINIValue: %s: [%s] %s := %s", file.c_str(), section.c_str(), key.c_str(), value.c_str());
}
void Inter_v7::o7_loadIFFPalette() {
Common::String file = _vm->_game->_script->evalString();
if (!file.contains('.'))
file += ".LBM";
int16 startIndex = CLIP<int16>(_vm->_game->_script->readValExpr(), 0, 255);
int16 stopIndex = CLIP<int16>(_vm->_game->_script->readValExpr(), 0, 255);
if (startIndex > stopIndex)
SWAP(startIndex, stopIndex);
Common::SeekableReadStream *iffFile = _vm->_dataIO->getFile(file);
if (!iffFile) {
warning("o7_loadIFFPalette(): No such file \"%s\"", file.c_str());
return;
}
ImageType type = Surface::identifyImage(*iffFile);
if (type != kImageTypeIFF) {
warning("o7_loadIFFPalette(): \"%s\" is no IFF", file.c_str());
return;
}
Image::IFFDecoder decoder;
decoder.loadStream(*iffFile);
if (decoder.getPalette().size() != 256) {
warning("o7_loadIFFPalette(): Failed reading palette from IFF \"%s\"", file.c_str());
return;
}
const byte *palette = decoder.getPalette().data();
startIndex *= 3;
stopIndex *= 3;
byte *dst = (byte *)_vm->_draw->_vgaPalette + startIndex;
const byte *src = palette + startIndex;
for (int i = startIndex; i <= stopIndex + 2; ++i) {
*dst++ = *src++ >> 2;
}
if (startIndex == 0) {
dst = (byte *)_vm->_draw->_vgaPalette;
dst[0] = dst[1] = dst[2] = 0x00 >> 2;
}
if (stopIndex == 765) {
dst = (byte *)_vm->_draw->_vgaPalette + 765;
dst[0] = dst[1] = dst[2] = 0xFF >> 2;
}
_vm->_video->setFullPalette(_vm->_global->_pPaletteDesc);
}
void Inter_v7::o7_openDatabase() {
Common::String databaseName = _vm->_game->_script->evalString();
_vm->_game->_script->readValExpr(); // unknown, some kind of "open mode"
_databases.setVal(databaseName, Database());
}
void Inter_v7::o7_openDatabaseTable() {
Common::String databaseName = _vm->_game->_script->evalString();
Common::String tableName = _vm->_game->_script->evalString();
Common::String dbFile = getFile(_vm->_game->_script->evalString());
dbFile += ".DBF";
if (!_databases.contains(databaseName)) {
warning("o7_openDatabaseTable(): No such database \"%s\"", databaseName.c_str());
return;
}
Database &database = _databases.getVal(databaseName);
database.openTable(tableName, Common::Path(dbFile));
}
void Inter_v7::o7_closeDatabaseTable() {
Common::String databaseName = _vm->_game->_script->evalString();
Common::String tableName = _vm->_game->_script->evalString();
if (!_databases.contains(databaseName)) {
warning("o7_closeDatabaseTable(): No such database \"%s\"", databaseName.c_str());
return;
}
Database &database = _databases.getVal(databaseName);
database.closeTable(tableName);
}
void Inter_v7::o7_draw0xAE() {
_vm->_game->_script->readValExpr();
_vm->_game->_script->readValExpr();
warning("STUB: o7_draw0xAE (Adibou/Musique)");
}
void Inter_v7::o7_openDatabaseIndex() {
Common::String databaseName = _vm->_game->_script->evalString();
Common::String tableName = _vm->_game->_script->evalString();
Common::String indexName = _vm->_game->_script->evalString();
if (!_databases.contains(databaseName)) {
warning("o7_openDatabaseIndex(): No such database \"%s\"", databaseName.c_str());
return;
}
Database &database = _databases.getVal(databaseName);
dBase *db = database.getTable(tableName);
db->setCurrentIndex(indexName);
}
void Inter_v7::o7_findDatabaseRecord() {
Common::String databaseName = _vm->_game->_script->evalString();
Common::String tableName = _vm->_game->_script->evalString();
Common::String query = _vm->_game->_script->evalString();
debugC(5, kDebugGameFlow, "o7_findDatabaseRecord: %s.%s: query=%s", databaseName.c_str(), tableName.c_str(), query.c_str());
if (!_databases.contains(databaseName)) {
warning("o7_findDatabaseRecord(): No such database \"%s\"", databaseName.c_str());
return;
}
Database &database = _databases.getVal(databaseName);
dBase *db = database.getTable(tableName);
if (!db) {
warning("o7_findDatabaseRecord(): No such table \"%s\"", tableName.c_str());
return;
}
db->setQuery(query);
db->findFirstMatchingRecord();
}
void Inter_v7::o7_findNextDatabaseRecord() {
Common::String databaseName = _vm->_game->_script->evalString();
Common::String tableName = _vm->_game->_script->evalString();
Database &database = _databases.getVal(databaseName);
debugC(5, kDebugGameFlow, "o7_findNextDatabaseRecord: %s.%s", databaseName.c_str(), tableName.c_str());
if (!_databases.contains(databaseName)) {
warning("o7_findDatabaseRecord(): No such database \"%s\"", databaseName.c_str());
return;
}
dBase *db = database.getTable(tableName);
if (!db) {
warning("o7_findDatabaseRecord(): No such table \"%s\"", tableName.c_str());
return;
}
db->findNextMatchingRecord();
}
void Inter_v7::o7_getDatabaseRecordValue() {
Common::String databaseSetName = _vm->_game->_script->evalString();
Common::String tableName = _vm->_game->_script->evalString();
Common::String fieldName = _vm->_game->_script->evalString();
uint16 type;
uint16 varIndex = _vm->_game->_script->readVarIndex(nullptr, &type);
if (!_databases.contains(databaseSetName)) {
warning("o7_findDatabaseRecord(): No such database set \"%s\"", databaseSetName.c_str());
return;
}
Database &database = _databases.getVal(databaseSetName);
dBase *db = database.getTable(tableName);
if (!db) {
warning("o7_findDatabaseRecord(): No such database table \"%s\"", tableName.c_str());
return;
}
Common::String string = db->getFieldOfMatchingRecord(fieldName);
debugC(5, kDebugGameFlow, "o7_getDatabaseRecordValue: %s.%s.%s = %s", databaseSetName.c_str(), tableName.c_str(), fieldName.c_str(), string.c_str());
storeString(varIndex, type, string.c_str());
}
void Inter_v7::o7_checkAnyDatabaseRecordFound() {
Common::String databaseName = _vm->_game->_script->evalString();
Common::String tableName = _vm->_game->_script->evalString();
uint16 varIndex = _vm->_game->_script->readVarIndex();
if (!_databases.contains(databaseName)) {
warning("o7_findDatabaseRecord(): No such database set \"%s\"", databaseName.c_str());
return;
}
Database &database = _databases.getVal(databaseName);
dBase *db = database.getTable(tableName);
if (!db) {
warning("o7_findDatabaseRecord(): No such database table \"%s\"", tableName.c_str());
return;
}
debugC(5, kDebugGameFlow, "o7_checkAnyDatabaseRecordFound: %s.%s = %s", databaseName.c_str(), tableName.c_str(), db->hasMatchingRecord() ? "true" : "false");
WRITE_VAR_OFFSET(varIndex, db->hasMatchingRecord() ? 0 : 1);
}
void Inter_v7::o7_openHtmlFile() {
Common::String file = getFile(_vm->_game->_script->evalString());
Common::SeekableReadStream *htmlFile = _vm->_dataIO->getFile(file);
if (!htmlFile) {
warning("o7_openHtmlFile(): No such file \"%s\"", file.c_str());
return;
}
_currentHtmlFile = file;
_currentHtmlContext = new HtmlContext(htmlFile, _vm);
}
void Inter_v7::o7_closeHtmlFile() {
Common::String file = getFile(_vm->_game->_script->evalString());
if (file != _currentHtmlFile) {
warning("o7_closeHtmlFile(): open/close file mismatch \"%s\" != \"%s\"", file.c_str(), _currentHtmlFile.c_str());
}
_currentHtmlFile.clear();
delete _currentHtmlContext;
_currentHtmlContext = nullptr;
}
void Inter_v7::o7_seekHtmlFile() {
Common::String file = getFile(_vm->_game->_script->evalString());
Common::String commandArg = _vm->_game->_script->evalString();
Common::String command = _vm->_game->_script->evalString();
uint16 destVar = _vm->_game->_script->readVarIndex();
if (_currentHtmlContext == nullptr) {
warning("o7_seekHtmlFile(): No open file");
return;
}
if (file != _currentHtmlFile) {
warning("o7_seekHtmlFile(): filename mismatch \"%s\" != \"%s\"", file.c_str(), _currentHtmlFile.c_str());
}
_currentHtmlContext->seekCommand(command, commandArg, destVar);
}
void Inter_v7::o7_nextKeywordHtmlFile() {
Common::String file = getFile(_vm->_game->_script->evalString());
uint16 destVarTagType = _vm->_game->_script->readVarIndex();
uint16 destVar = _vm->_game->_script->readVarIndex();
if (_currentHtmlContext == nullptr) {
warning("o7_seekHtmlFile(): No open file");
return;
}
if (file != _currentHtmlFile) {
warning("o7_nextKeywordHtmlFile(): filename mismatch \"%s\" != \"%s\"", file.c_str(), _currentHtmlFile.c_str());
}
_currentHtmlContext->nextKeyword(destVar, destVarTagType);
}
void Inter_v7::o7_draw0xC3() {
_vm->_game->_script->readValExpr();
_vm->_game->_script->readValExpr();
_vm->_game->_script->readValExpr();
_vm->_game->_script->readValExpr();
_vm->_game->_script->readValExpr();
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
warning("STUB: o7_draw0xC3 (Adibou/Musique)");
}
void Inter_v7::o7_openTranslationDB() {
Common::String dbFile = getFile(_vm->_game->_script->evalString());
Common::String id = _vm->_game->_script->evalString();
dbFile += ".DBF";
_translationDatabases.setLanguage(_vm->_language);
if (!_translationDatabases.open(id, Common::Path(dbFile))) {
WRITE_VAR(27, 0); // Failure
return;
}
WRITE_VAR(27, 1); // Success
}
void Inter_v7::o7_closeTranslationDB() {
Common::String id = _vm->_game->_script->evalString();
if (_translationDatabases.close(id))
WRITE_VAR(27, 1); // Success
else
WRITE_VAR(27, 0); // Failure
}
void Inter_v7::o7_getDBString() {
Common::String id = _vm->_game->_script->evalString();
Common::String group = _vm->_game->_script->evalString();
Common::String section = _vm->_game->_script->evalString();
Common::String keyword = _vm->_game->_script->evalString();
Common::String result;
if (!_translationDatabases.getString(id, group, section, keyword, result)) {
WRITE_VAR(27, 0); // Failure
storeString("");
return;
}
if (_translationDatabases.encodingIsOEM())
result = oemToANSI(result);
storeString(result.c_str());
WRITE_VAR(27, 1); // Success
}
void Inter_v7::o7_draw0xCC() {
_vm->_game->_script->readVarIndex();
warning("STUB: o7_draw0xCC (Adibou/Anglais)");
}
void Inter_v7::o7_draw0xCD() {
_vm->_game->_script->readValExpr();
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
warning("STUB: o7_draw0xCD (Adibou/Anglais)");
}
void Inter_v7::o7_draw0xCE() {
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
warning("STUB: o7_draw0xCE (Adibou/Anglais)");
}
void Inter_v7::o7_draw0xDC() {
_vm->_game->_script->readValExpr();
_vm->_game->_script->readVarIndex();
warning("STUB: o7_draw0xDC (Adibou/Anglais)");
}
void Inter_v7::o7_draw0xDD() {
_vm->_game->_script->readValExpr();
warning("STUB: o7_draw0xDD (Adibou/Anglais)");
}
void Inter_v7::o7_draw0xDE() {
_vm->_game->_script->readValExpr();
_vm->_game->_script->readValExpr();
warning("STUB: o7_draw0xDE (Adibou/Anglais)");
}
void Inter_v7::o7_draw0xDF() {
_vm->_game->_script->readValExpr();
warning("STUB: o7_draw0xDF (Adibou/Anglais)");
}
void Inter_v7::o7_draw0xE0() {
warning("STUB: o7_draw0xE0 (Adibou/Anglais)");
}
void Inter_v7::o7_draw0xE1() {
warning("STUB: o7_draw0xE1 (Adibou/Anglais)");
}
void Inter_v7::o7_draw0xE2() {
warning("STUB: o7_draw0xE2 (Adibou/Anglais)");
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
}
void Inter_v7::o7_draw0xE3() {
warning("STUB: o7_draw0xE3 (Adibou/Anglais)");
}
void Inter_v7::o7_draw0xE4() {
warning("STUB: o7_draw0xE4 (Adibou/Anglais)");
}
void Inter_v7::o7_draw0xE6() {
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
warning("STUB: o7_draw0xE6 (Adibou/Musique)");
}
void Inter_v7::o7_draw0xE7() {
_vm->_game->_script->readVarIndex();
warning("STUB: o7_draw0xE7 (Adibou/Musique)");
}
void Inter_v7::o7_draw0xE8() {
_vm->_game->_script->readVarIndex();
warning("STUB: o7_draw0xE8 (Adibou/Musique)");
}
void Inter_v7::o7_draw0xE9() {
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
warning("STUB: o7_draw0xE8 (Adibou/Musique)");
}
void Inter_v7::o7_draw0xF0() {
_vm->_game->_script->readVarIndex();
warning("STUB: o7_draw0xF0 (Adibou/Musique)");
}
void Inter_v7::o7_executeModAddEvent() {
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
_vm->_game->_script->readVarIndex();
warning("STUB: o7_executeModAddEvent (Adibou/Musique)");
}
void Inter_v7::o7_executeModSetLength() {
_vm->_game->_script->readVarIndex();
warning("STUB: o7_executeModSetLength (Adibou/Musique)");
}
void Inter_v7::o7_executeModStart() {
_vm->_game->_script->readVarIndex();
warning("STUB: o7_executeModSetLength (Adibou/Musique)");
}
void Inter_v7::o7_executeModGetPosition() {
_vm->_game->_script->readVarIndex();
warning("STUB: o7_executeModSetLength (Adibou/Musique)");
}
void Inter_v7::o7_vmdGetSoundBuffer() {
_vm->_game->_script->readValExpr();
_vm->_game->_script->readVarIndex();
warning("STUB: o7_vmdGetSoundBuffer (Adibou/Musique)");
}
void Inter_v7::o7_vmdReleaseSoundBuffer() {
_vm->_game->_script->readVarIndex();
warning("STUB: o7_vmdReleaseSoundBuffer (Adibou/Musique)");
}
void Inter_v7::o7_printText(OpFuncParams &params) {
char buf[152];
_vm->_draw->_destSpriteX = _vm->_game->_script->readValExpr();
_vm->_draw->_destSpriteY = _vm->_game->_script->readValExpr();
_vm->_draw->_backColor = _vm->_game->_script->readValExpr();
_vm->_draw->_frontColor = _vm->_game->_script->readValExpr();
_vm->_draw->_fontIndex = _vm->_game->_script->readValExpr();
_vm->_draw->_destSurface = Draw::kBackSurface;
_vm->_draw->_textToPrint = buf;
_vm->_draw->_transparency = 0;
if (_vm->_draw->_backColor & 0xFF00) {
_vm->_draw->_destSurface = _vm->_draw->_backColor >> 8;
_vm->_draw->_backColor &= 0xFF;
}
if (_vm->_draw->_backColor == 16) {
_vm->_draw->_backColor = 0;
_vm->_draw->_transparency = 1;
}
// colMod is read from conf file (_off_=xxx).
// in Playtoons, it's not present in the conf file, thus always equal to the default value (0).
// Maybe used in ADIs...
// if (!_vm->_draw->_transparency)
// _vm->_draw->_backColor += colMod;
// _vm->_draw->_frontColor += colMod;
int16 oldTransparency = _vm->_draw->_transparency;
int i = 0;
do {
for (; (_vm->_game->_script->peekChar() != '.') &&
(_vm->_game->_script->peekByte() != 200); i++) {
buf[i] = _vm->_game->_script->readChar();
}
if (_vm->_game->_script->peekByte() != 200) {
_vm->_game->_script->skip(1);
switch (_vm->_game->_script->peekByte()) {
case TYPE_VAR_INT8:
case TYPE_ARRAY_INT8:
Common::sprintf_s(buf + i, sizeof(buf) - i, "%d",
(int8) READ_VARO_UINT8(_vm->_game->_script->readVarIndex()));
break;
case TYPE_VAR_INT16:
case TYPE_VAR_INT32_AS_INT16:
case TYPE_ARRAY_INT16:
Common::sprintf_s(buf + i, sizeof(buf) - i, "%d",
(int16) READ_VARO_UINT16(_vm->_game->_script->readVarIndex()));
break;
case TYPE_VAR_INT32:
case TYPE_ARRAY_INT32:
Common::sprintf_s(buf + i, sizeof(buf) - i, "%d",
(int32)VAR_OFFSET(_vm->_game->_script->readVarIndex()));
break;
case TYPE_VAR_STR:
case TYPE_ARRAY_STR:
Common::sprintf_s(buf + i, sizeof(buf) - i, "%s",
GET_VARO_STR(_vm->_game->_script->readVarIndex()));
break;
default:
break;
}
_vm->_game->_script->skip(1);
} else
buf[i] = 0;
if (_vm->_game->_script->peekByte() == 200) {
_vm->_draw->_spriteBottom = _vm->_draw->_fonts[_vm->_draw->_fontIndex]->getCharHeight();
_vm->_draw->_spriteRight = _vm->_draw->stringLength(_vm->_draw->_textToPrint, _vm->_draw->_fontIndex);
_vm->_draw->adjustCoords(1, &_vm->_draw->_spriteBottom, &_vm->_draw->_spriteRight);
if (_vm->_draw->_transparency == 0) {
_vm->_draw->spriteOperation(DRAW_FILLRECT);
_vm->_draw->_transparency = 1;
}
_vm->_draw->spriteOperation(DRAW_PRINTTEXT);
_vm->_draw->_transparency = oldTransparency;
i = 0;
} else
i = strlen(buf);
} while (_vm->_game->_script->peekByte() != 200);
_vm->_game->_script->skip(1);
}
void Inter_v7::o7_fillRect(OpFuncParams &params) {
_vm->_draw->_destSurface = _vm->_game->_script->readInt16();
_vm->_draw->_destSpriteX = _vm->_game->_script->readValExpr();
_vm->_draw->_destSpriteY = _vm->_game->_script->readValExpr();
_vm->_draw->_spriteRight = _vm->_game->_script->readValExpr();
_vm->_draw->_spriteBottom = _vm->_game->_script->readValExpr();
uint32 patternColor = _vm->_game->_script->evalInt();
int16 savedPattern = _vm->_draw->_pattern;
_vm->_draw->_backColor = patternColor & 0xFFFF;
_vm->_draw->_pattern = patternColor >> 16;
if (_vm->_draw->_spriteRight < 0) {
_vm->_draw->_destSpriteX += _vm->_draw->_spriteRight - 1;
_vm->_draw->_spriteRight = -_vm->_draw->_spriteRight + 2;
}
if (_vm->_draw->_spriteBottom < 0) {
_vm->_draw->_destSpriteY += _vm->_draw->_spriteBottom - 1;
_vm->_draw->_spriteBottom = -_vm->_draw->_spriteBottom + 2;
}
if (_vm->_draw->_destSurface & 0x80) {
_vm->_draw->_destSurface &= 0x7F;
if (_vm->_draw->_destSurface > 100)
_vm->_draw->_destSurface -= 80;
if (_vm->_draw->_pattern & 0x8000)
warning("o7_fillRect: pattern %d & 0x8000 != 0 stub", _vm->_draw->_pattern);
else {
// Replace a specific color in the rectangle
uint8 colorIndexToReplace = (_vm->_draw->_backColor >> 8) & 0xFF;
uint32 colorToReplace = _vm->_draw->_spritesArray[_vm->_draw->_destSurface]->getColorFromIndex(colorIndexToReplace);
_vm->_draw->_pattern = 4;
_vm->_draw->_backColor = _vm->_draw->_backColor & 0xFF;
uint32 newColor = _vm->_draw->_spritesArray[_vm->_draw->_destSurface]->getColorFromIndex(_vm->_draw->_backColor);
// Additional condition on surface.field_10 in executables (video mode ?), seems to be always true for Adibou2
// if (_vm->_draw->_spritesArray[_vm->_draw->_destSurface].field_10 & 0x80)) {
SurfacePtr newSurface = _vm->_video->initSurfDesc(_vm->_draw->_spriteRight,
_vm->_draw->_spriteBottom,
8,
_vm->_draw->_spritesArray[_vm->_draw->_destSurface]->getBPP());
newSurface->blit(*_vm->_draw->_spritesArray[_vm->_draw->_destSurface],
_vm->_draw->_destSpriteX,
_vm->_draw->_destSpriteY,
_vm->_draw->_destSpriteX + _vm->_draw->_spriteRight - 1,
_vm->_draw->_destSpriteY + _vm->_draw->_spriteBottom - 1,
0,
0,
-1);
for (int y = 0; y < _vm->_draw->_spriteBottom; y++) {
for (int x = 0; x < _vm->_draw->_spriteRight; x++) {
if (colorToReplace == newSurface->get(x, y).get())
newSurface->putPixelRaw(x, y, newColor);
}
}
_vm->_draw->_spritesArray[_vm->_draw->_destSurface]->blit(*newSurface,
0,
0,
_vm->_draw->_spriteRight - 1,
_vm->_draw->_spriteBottom - 1,
_vm->_draw->_destSpriteX,
_vm->_draw->_destSpriteY,
-1);
_vm->_draw->dirtiedRect(_vm->_draw->_destSurface,
_vm->_draw->_destSpriteX,
_vm->_draw->_destSpriteY,
_vm->_draw->_destSpriteX + _vm->_draw->_spriteRight - 1,
_vm->_draw->_destSpriteY + _vm->_draw->_spriteBottom - 1);
}
} else
_vm->_draw->spriteOperation(DRAW_FILLRECT);
_vm->_draw->_pattern = savedPattern;
}
bool Inter_v7::setCurrentCDPath(const Common::String &newDirName) {
if (newDirName.equalsIgnoreCase("applis") || newDirName.equalsIgnoreCase("envir"))
return false;
if (!_currentCDPath.empty())
SearchMan.setPriority(_currentCDPath.toString(), 0);
_currentCDPath = newDirName;
if (!_currentCDPath.empty())
SearchMan.setPriority(newDirName, 1);
return true;
}
Common::Array<uint32> Inter_v7::getAdibou2InstalledApplications() {
byte buffer[4];
Common::Array<uint32> applicationNumbers;
if (_vm->_saveLoad->loadToRaw("applis.inf", buffer, 4, 0)) {
int numApplications = READ_LE_UINT32(buffer);
for (int i = 0; i < numApplications; i++) {
if (_vm->_saveLoad->loadToRaw("applis.inf", buffer, 4, 4 + i * 4)) {
uint32 applicationNumber = READ_LE_UINT32(buffer);
applicationNumbers.push_back(applicationNumber);
}
}
}
return applicationNumbers;
}
void Inter_v7::o7_drawLine(OpFuncParams &params) {
_vm->_draw->_destSurface = _vm->_game->_script->readInt16();
_vm->_draw->_destSpriteX = _vm->_game->_script->readValExpr();
_vm->_draw->_destSpriteY = _vm->_game->_script->readValExpr();
_vm->_draw->_spriteRight = _vm->_game->_script->readValExpr();
_vm->_draw->_spriteBottom = _vm->_game->_script->readValExpr();
_vm->_game->_script->readExpr(99, 0);
//unk_var is always set to 0
_vm->_draw->_frontColor = _vm->_game->_script->getResultInt() & 0xFFFF; // + unk_var;
_vm->_draw->_pattern = _vm->_game->_script->getResultInt()>>16;
_vm->_draw->spriteOperation(DRAW_DRAWLINE);
}
void Inter_v7::o7_invalidate(OpFuncParams &params) {
_vm->_draw->_destSurface = _vm->_game->_script->readInt16();
_vm->_draw->_destSpriteX = _vm->_game->_script->readValExpr();
_vm->_draw->_destSpriteY = _vm->_game->_script->readValExpr();
_vm->_draw->_spriteRight = _vm->_game->_script->readValExpr();
_vm->_game->_script->readExpr(99, 0);
//unk_var is always set to 0
_vm->_draw->_frontColor = _vm->_game->_script->getResultInt() & 0xFFFF; // + unk_var;
_vm->_draw->_pattern = _vm->_game->_script->getResultInt()>>16;
_vm->_draw->spriteOperation(DRAW_INVALIDATE);
}
void Inter_v7::o7_getFreeMem(OpFuncParams &params) {
uint16 freeVar = _vm->_game->_script->readVarIndex();
uint16 maxFreeVar = _vm->_game->_script->readVarIndex();
// HACK, with a higher value than o2_getFreeMem (16M vs 1M)
// This unlocks a nicer intro music in Adibou2/Adi4
WRITE_VAR_OFFSET(freeVar , 16000000);
WRITE_VAR_OFFSET(maxFreeVar, 16000000);
WRITE_VAR(16, _vm->_game->_script->getVariablesCount() * 4);
}
void Inter_v7::o7_checkData(OpFuncParams &params) {
Common::String file = getFile(_vm->_game->_script->evalString());
if (_vm->getGameType() == kGameTypeAdibou2 && file == "CD.INF") {
// WORKAROUND: some versions of Adibou2 are only able to handle one CD at a time.
// In such versions, scripts always begin to look for CD.INF file in the CD, and check
// if its contents matches the selected application. We insert a hack here, to set
// the directory of the wanted application as "current CD" directory.
// This way, applications can be made available by copying them as a subdirectory of the
// game directory, just like in multi-cd-aware versions.
Common::Array<uint32> installedApplications = getAdibou2InstalledApplications();
int32 indexAppli = VAR_OFFSET(20196);
if (indexAppli <= 0) {
// New appli, find the first directory containing an application still not installed, and set it as "current CD" path.
Common::ArchiveMemberDetailsList files;
SearchMan.listMatchingMembers(files, Common::Path(file)); // Search for CD.INF files
for (Common::ArchiveMemberDetails &cdInfFile : files) {
Common::SeekableReadStream *stream = cdInfFile.arcMember->createReadStream();
while (stream->pos() + 4 <= stream->size()) {
// CD.INF contains a list of applications, as uint32 LE values
uint32 applicationNumber = stream->readUint32LE();
if (Common::find(installedApplications.begin(), installedApplications.end(), applicationNumber) == installedApplications.end()) {
// Application not installed yet, set it as current CD path
setCurrentCDPath(cdInfFile.arcName);
break;
}
}
}
} else if (indexAppli >= 0 && (size_t) indexAppli <= installedApplications.size()) {
// Already installed appli, find its directory and set it as "current CD" path
int32 applicationNumber = installedApplications[indexAppli - 1];
Common::Path appliVmdName(Common::String::format("appli_%02d.vmd", applicationNumber));
Common::ArchiveMemberDetailsList matchingFiles;
SearchMan.listMatchingMembers(matchingFiles, appliVmdName);
for (Common::ArchiveMemberDetails &matchingFile : matchingFiles) {
if (setCurrentCDPath(matchingFile.arcName))
break;
}
}
}
uint16 varOff = _vm->_game->_script->readVarIndex();
int32 size = -1;
int16 handle = 1;
SaveLoad::SaveMode mode = _vm->_saveLoad->getSaveMode(file.c_str());
if (_vm->getGameType() == kGameTypeAdibou2 && file.compareToIgnoreCase("CARON.BOU") == 0) {
// WORKAROUND to disable the 3D driving activity in Adibou2/Sciences (not supported in ScummVM)
size = -1;
} else if (mode == SaveLoad::kSaveModeNone) {
size = _vm->_dataIO->fileSize(file);
if (size == -1)
warning("File \"%s\" not found", file.c_str());
} else if (mode == SaveLoad::kSaveModeSave)
size = _vm->_saveLoad->getSize(file.c_str());
else if (mode == SaveLoad::kSaveModeExists)
size = 23;
if (size == -1)
handle = -1;
debugC(2, kDebugFileIO, "Requested size of file \"%s\": %d",
file.c_str(), size);
WRITE_VAR_OFFSET(varOff, handle);
if (_vm->getGameType() == kGameTypeAdibou2 && _vm->isCurrentTot("BE_CD.TOT")) {
// WORKAROUND: in script BE_CD.TOT of Adibou 2, o7_checkData() can be called in the "leave" callback of a hotspot.
// This corrupts the "current hotspot" variable, which is also VAR(16) (!), and lead to an infinite loop.
// We skip writing the file size into VAR(16) here as a workarond (the value is not used anyway).
} else
WRITE_VAR(16, (uint32) size);
}
void Inter_v7::o7_readData(OpFuncParams &params) {
Common::String file = getFile(_vm->_game->_script->evalString(), false);
uint16 dataVar = _vm->_game->_script->readVarIndex();
int32 size = _vm->_game->_script->readValExpr();
int32 offset = _vm->_game->_script->evalInt();
int32 retSize = 0;
if (size == 0) {
dataVar = 0;
size = _vm->_game->_script->getVariablesCount() * 4;
}
debugC(2, kDebugFileIO, "Read from file \"%s\" (%d, %d bytes at %d)",
file.c_str(), dataVar, size, offset);
SaveLoad::SaveMode mode = _vm->_saveLoad->getSaveMode(file.c_str());
if (mode == SaveLoad::kSaveModeSave) {
WRITE_VAR(1, 1);
if (!_vm->_saveLoad->load(file.c_str(), dataVar, size, offset)) {
// Too noisy, the scripts often try to load "save" file not existing (yet)
// GUI::MessageDialog dialog(_("Failed to load saved game from file."));
// dialog.runModal();
} else
WRITE_VAR(1, 0);
return;
} else if (mode == SaveLoad::kSaveModeIgnore)
return;
if (size < 0) {
if (readSprite(file, dataVar, size, offset))
WRITE_VAR(1, 0);
return;
} else if (size == 0) {
dataVar = 0;
size = _vm->_game->_script->getVariablesCount() * 4;
}
byte *buf = _variables->getAddressOff8(dataVar);
if (file.empty()) {
WRITE_VAR(1, size);
return;
}
WRITE_VAR(1, 1);
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(file);
if (!stream)
return;
_vm->_draw->animateCursor(4);
if (offset > stream->size()) {
warning("oPlaytoons_readData: File \"%s\", Offset (%d) > file size (%d)",
file.c_str(), offset, (int)stream->size());
delete stream;
return;
}
if (offset < 0)
stream->seek(offset + 1, SEEK_END);
else
stream->seek(offset);
if (((dataVar >> 2) == 59) && (size == 4)) {
WRITE_VAR(59, stream->readUint32LE());
// The scripts in some versions divide through 256^3 then,
// effectively doing a LE->BE conversion
if ((_vm->getPlatform() != Common::kPlatformDOS) && (VAR(59) < 256))
WRITE_VAR(59, SWAP_BYTES_32(VAR(59)));
} else
retSize = stream->read(buf, size);
if (retSize == size)
WRITE_VAR(1, 0);
delete stream;
}
void Inter_v7::o7_writeData(OpFuncParams &params) {
Common::String file = getFile(_vm->_game->_script->evalString(), false);
uint16 dataVar = _vm->_game->_script->readVarIndex();
int32 size = _vm->_game->_script->readValExpr();
int32 offset = _vm->_game->_script->evalInt();
debugC(2, kDebugFileIO, "Write to file \"%s\" (%d, %d bytes at %d)",
file.c_str(), dataVar, size, offset);
WRITE_VAR(1, 1);
if (size == 0) {
dataVar = 0;
size = _vm->_game->_script->getVariablesCount() * 4;
}
SaveLoad::SaveMode mode = _vm->_saveLoad ? _vm->_saveLoad->getSaveMode(file.c_str()) : SaveLoad::kSaveModeNone;
if (mode == SaveLoad::kSaveModeSave) {
if (!_vm->_saveLoad->save(file.c_str(), dataVar, size, offset)) {
GUI::MessageDialog dialog(_("Failed to save game to file."));
dialog.runModal();
} else
WRITE_VAR(1, 0);
} else if (mode == SaveLoad::kSaveModeIgnore)
return;
else if (mode == SaveLoad::kSaveModeNone)
warning("Attempted to write to file \"%s\"", file.c_str());
}
void Inter_v7::o7_manageDataFile(OpFuncParams &params) {
Common::String file = _vm->_game->_script->evalString();
if (!file.empty()) {
bool result = _vm->_dataIO->openArchive(Common::Path(file, '\\').toString('/'), true);
WRITE_VAR(27, result);
} else {
_vm->_dataIO->closeArchive(true);
// NOTE: Lost in Time might close a data file without explicitely closing a video in it.
// So we make sure that all open videos are still available.
_vm->_vidPlayer->reopenAll();
}
}
Common::String Inter_v7::ansiToOEM(Common::String string) {
Common::U32String u32String = string.decode(Common::kWindows1252);
// Replace characters that do not exist in the target codepage with the closest match
for (int i = 0; i < (int) u32String.size(); ++i) {
// Replace curly double quotes with straight double quotes
if (u32String[i] == 0x201C || u32String[i] == 0x201D || u32String[i] == 0x201E) {
u32String.setChar(0x22, i);
}
// Replace curly single quotes with straight single quotes
if (u32String[i] == 0x2018 || u32String[i] == 0x2019) {
u32String.setChar(0x27, i);
}
}
return u32String.encode(Common::kDos850);
}
Common::String Inter_v7::oemToANSI(Common::String string) {
return string.decode(Common::kDos850).encode(Common::kWindows1252);
}
void Inter_v7::xorObfuscate(byte *str, int len) {
if (len <= 1)
return;
for (int i = len - 1; i >= 1; --i)
str[i] = str[i] ^ str[i - 1];
}
void Inter_v7::xorDeobfuscate(byte *str, int len) {
if (len <= 1)
return;
for (int i = 1; i < len; ++i)
str[i] = str[i] ^ str[i - 1];
}
bool Inter_v7::readAdi4InfDataForChild(Common::Array<byte> &dest, uint32 childNumber, uint32 offset, uint32 size) {
uint32 totalOffset = childNumber * kAdi4InfChildDataSize + offset;
assert(size <= dest.size());
if (!_vm->_saveLoad->loadToRaw("ADI.INF", dest.data(), size, totalOffset))
return false;
xorDeobfuscate(dest.data(), size);
return true;
}
bool Inter_v7::readAdi4InstalledAppsData(Common::Array<byte> &generalChildData,
Common::Array<byte> &appChildData,
uint32 childNbr,
uint32 appliNbr) {
if (!readAdi4InfDataForChild(generalChildData, childNbr, 0, kAdi4InfGeneralChildDataSize)) {
warning("readAdi4InstalledAppsData: Failed to read general data for child %d in ADI.INF", childNbr);
return false;
}
Common::Array<byte> appChildDataPacked(kAdi4InfAppChildDataSize);
if (!readAdi4InfDataForChild(appChildDataPacked,
childNbr,
kAdi4InfGeneralChildDataSize + appliNbr * kAdi4InfAppChildDataSize,
kAdi4InfAppChildDataSize)) {
warning("readAdi4InstalledAppsData: Failed to read app-specific data for child %d in ADI.INF", childNbr);
return false;
}
for (uint32 i = 0; i < kAdi4InfAppChildDataSize; ++i) {
appChildData[i] = appChildDataPacked[i] & 3;
appChildData[i + kAdi4InfAppChildDataSize] = (appChildDataPacked[i] >> 2) & 3;
appChildData[i + 2 * kAdi4InfAppChildDataSize] = (appChildDataPacked[i] >> 4) & 3;
}
return true;
}
bool Inter_v7::writeAdi4InfDataForChild(const Common::Array<byte> &src, uint32 childNumber, uint32 offset, uint32 size) {
int adiInfSize = _vm->_saveLoad->getSize("ADI.INF");
if (adiInfSize < 0) {
warning("writeAdi4InfDataForChild: ADI.INF file not found");
return false;
}
Common::Array<byte> bytesToWrite(size);
memcpy(bytesToWrite.data(), src.data(), size);
xorObfuscate(bytesToWrite.data(), bytesToWrite.size());
uint32 totalOffset = childNumber * kAdi4InfChildDataSize + offset;
if (totalOffset > (uint32) adiInfSize) {
// Offset is past the current size, fill the gap with spaces
Common::Array<byte> emptySpace(totalOffset - adiInfSize, ' ');
if (!_vm->_saveLoad->saveFromRaw("ADI.INF", emptySpace.data(), emptySpace.size(), adiInfSize))
return false;
}
if (!_vm->_saveLoad->saveFromRaw("ADI.INF", bytesToWrite.data(), bytesToWrite.size(), totalOffset))
return false;
return true;
}
bool Inter_v7::writeAdi4InstalledAppsData(const Common::Array<byte> &generalChildData,
const Common::Array<byte> &appChildData,
uint32 childNbr,
uint32 appliNbr) {
if (generalChildData.empty())
return false;
if (!writeAdi4InfDataForChild(generalChildData, childNbr, 0, kAdi4InfGeneralChildDataSize)) {
warning("writeAdi4InstalledAppsData: Failed to write general data for child %d in ADI.INF", childNbr);
return false;
}
Common::Array<byte> appChildDataPacked(kAdi4InfAppChildDataSize);
for (uint32 i = 0; i < kAdi4InfAppChildDataSize; ++i) {
appChildDataPacked[i] = (appChildData[i] & 3) |
((appChildData[i + kAdi4InfAppChildDataSize] & 3) << 2) |
((appChildData[i + 2 * kAdi4InfAppChildDataSize] & 3) << 4);
}
if (!writeAdi4InfDataForChild(appChildDataPacked,
childNbr,
kAdi4InfGeneralChildDataSize + appliNbr * kAdi4InfAppChildDataSize,
kAdi4InfAppChildDataSize)) {
warning("readAdi4InstalledAppsData: Failed to write app-specific data for child %d in ADI.INF", childNbr);
return false;
}
return true;
}
void Inter_v7::o7_saveAdi4ExerciseAttemptsCount(OpGobParams &params) {
_vm->_game->_script->skip(2);
uint16 sectionNumberVar = _vm->_game->_script->readUint16();
_vm->_game->_script->skip(2);
if (_adi4GeneralChildData.empty())
return;
uint16 sectionNumber = READ_VAR_UINT16(sectionNumberVar);
if (sectionNumber & 0x80) {
_adi4CurrentSectionInGeneralChildData = 0;
_adi4CurrentSectionInAppChildData = sectionNumber;
return;
}
if (sectionNumber & 0x100) {
_adi4CurrentSectionInGeneralChildData = 0;
_adi4CurrentSectionInAppChildData = 0;
return;
}
_adi4CurrentSectionInGeneralChildData = sectionNumber - 1;
if (_adi4CurrentSectionInAppChildData != 0)
_adi4CurrentSectionInGeneralChildData = _adi4CurrentSectionInAppChildData & 3;
uint16 unknownOffset = READ_LE_UINT16(&_adi4GeneralChildData[3]);
byte &totalAttemptsCount = _adi4GeneralChildData[2515 + _adi4CurrentAppNbr * 36 + unknownOffset * 3 + _adi4CurrentSectionInGeneralChildData];
if (totalAttemptsCount != 0xFF)
++totalAttemptsCount;
}
void Inter_v7::o7_saveAdi4ExerciseResults(OpGobParams &params) {
uint16 varIndexExerciseNumber = _vm->_game->_script->readUint16();
uint16 varIndexExerciseOutcome = _vm->_game->_script->readUint16();
if (_adi4GeneralChildData.empty())
return;
uint32 exerciseOutcome = VAR(varIndexExerciseOutcome);
if (exerciseOutcome < 10)
return; // Not completed
uint16 exerciseNumber = READ_VAR_UINT16(varIndexExerciseNumber);
byte &exerciseCompletionFlag = _adi4CurrentAppChildData[(_adi4CurrentSectionInAppChildData & 3) * 200 + exerciseNumber];
if (exerciseOutcome == 12) {
// Failed
if (exerciseCompletionFlag == 0)
exerciseCompletionFlag = 1; // Mark as attempted but not suceeded
} else {
// Succeeded
uint16 unknownOffset = READ_LE_UINT16(&_adi4GeneralChildData[3]);
if (exerciseCompletionFlag < 2) {
byte *currentScorePtr = &_adi4GeneralChildData[3241];
uint16 currentScore = READ_LE_UINT16(currentScorePtr);
if ((_adi4CurrentSectionInAppChildData & 80) == 0) {
WRITE_UINT16(currentScorePtr, currentScore + 2);
} else {
WRITE_UINT16(currentScorePtr, currentScore + 1);
}
byte &firstTimeSuccessCount = _adi4GeneralChildData[1075 + _adi4CurrentAppNbr * 36 + unknownOffset * 3 + _adi4CurrentSectionInGeneralChildData];
if (firstTimeSuccessCount != 0xFF)
++firstTimeSuccessCount;
} else {
byte &repeatSuccessCount = _adi4GeneralChildData[1795 + _adi4CurrentAppNbr * 36 + unknownOffset * 3 + _adi4CurrentSectionInGeneralChildData];
if (repeatSuccessCount != 0xFF)
++repeatSuccessCount;
}
exerciseCompletionFlag = 2;
}
writeAdi4InstalledAppsData(_adi4GeneralChildData,
_adi4CurrentAppChildData,
_adi4CurrentChildNbr,
_adi4CurrentAppNbr);
}
void Inter_v7::o7_writeUnknownChildDataToGameVariables(OpGobParams &params) {
uint16 destVarIndex = _vm->_game->_script->readUint16();
_vm->_game->_script->skip(14);
if (_adi4GeneralChildData.empty())
return;
_vm->_inter->_variables->copyFrom(destVarIndex * 4, &_adi4GeneralChildData[3344], 40);
WRITE_VARO_UINT16(destVarIndex * 4 + 39, _adi4CurrentChildNbr);
}
void Inter_v7::o7_writeUnknownAppChildDataToGameVariables(OpGobParams &params) {
uint16 destVarIndex = _vm->_game->_script->readUint16();
if (_adi4GeneralChildData.empty())
return;
for (uint32 i = 0; i < kAdi4InfAppChildDataSize; ++i) {
WRITE_VARO_UINT8(destVarIndex * 4 + i,
_adi4CurrentAppChildData[i + (_adi4CurrentSectionInAppChildData & 3) * kAdi4InfAppChildDataSize] & 3);
}
}
void Inter_v7::o7_writeChildScoreToGameVariables(OpGobParams &params) {
uint16 varIndex = _vm->_game->_script->readUint16();
if (_adi4GeneralChildData.empty())
return;
WRITE_VAR(varIndex, READ_LE_UINT16(&_adi4GeneralChildData[3241]));
}
void Inter_v7::o7_startAdi4Application(OpGobParams &params) {
uint16 varIndexAppNbr = _vm->_game->_script->readUint16();
uint16 varIndexChildNbr = _vm->_game->_script->readUint16();
_adi4CurrentAppNbr = VAR(varIndexAppNbr);
_adi4CurrentChildNbr = VAR(varIndexChildNbr);
_adi4GeneralChildData.resize(kAdi4InfGeneralChildDataSize);
_adi4CurrentAppChildData.resize(3 * kAdi4InfAppChildDataSize, ' ');
readAdi4InstalledAppsData(_adi4GeneralChildData,
_adi4CurrentAppChildData,
_adi4CurrentChildNbr,
_adi4CurrentAppNbr);
char appliAbbreviationBuf[4];
appliAbbreviationBuf[0] = static_cast<char>(_adi4GeneralChildData[_adi4CurrentAppNbr * 4 + 55]);
appliAbbreviationBuf[1] = static_cast<char>(_adi4GeneralChildData[_adi4CurrentAppNbr * 4 + 56]);
appliAbbreviationBuf[2] = static_cast<char>(_adi4GeneralChildData[_adi4CurrentAppNbr * 4 + 57]);
appliAbbreviationBuf[3] = '\0';
Common::String appliAbbreviation(appliAbbreviationBuf);
byte c = _adi4GeneralChildData[_adi4CurrentAppNbr * 4 + 58];
Common::String appliDescFilename = "<CD>DESC" + appliAbbreviation;
if (c != 0) {
appliDescFilename.push_back(static_cast<char>(c));
}
appliDescFilename += ".ADI";
Common::String appliDescFile = getFile(appliDescFilename.c_str());
// Ensure the desc file is found
if (!_vm->_dataIO->hasFile(appliDescFile)) {
warning("o7_startAdi4Application: desc file '%s' not found (application %d, child %d)",
appliDescFile.c_str(),
_adi4CurrentAppNbr,
_adi4CurrentChildNbr);
return;
}
if (c == 0) {
// Ensure the ADIVMD.TIK file is found
if (!_vm->_dataIO->hasFile(getFile("<CD>ADIVMD.TIK"))) {
warning("o7_startAdi4Application: desc file '%s' not found (application %d, child %d)",
appliDescFile.c_str(),
_adi4CurrentAppNbr,
_adi4CurrentChildNbr);
return;
}
warning("o7_startAdi4Application: c = 0 case stub");
} else {
Common::String appliStkFile = "ADI" + appliAbbreviation + ".STK";
_vm->_dataIO->openArchive(appliStkFile, false);
Common::String appliIntroTotFile = appliAbbreviation + "INTRO";
_vm->_draw->_colorOffset = 10;
_vm->_game->totSub(1, appliIntroTotFile);
_vm->_draw->_colorOffset = 0;
_vm->_dataIO->closeArchive(false);
}
_adi4CurrentSectionInAppChildData = 0;
_adi4GeneralChildData.clear();
_adi4CurrentAppChildData.clear();
}
void Inter_v7::o7_xorDeobfuscate(OpGobParams &params) {
uint16 varIndex = _vm->_game->_script->readUint16();
uint16 size = _vm->_game->_script->readUint16();
byte *data = _vm->_inter->_variables->getAddressVar8(varIndex);
xorDeobfuscate(data, size);
}
void Inter_v7::o7_xorObfuscate(OpGobParams &params) {
uint16 varIndex = _vm->_game->_script->readUint16();
byte *data = _vm->_inter->_variables->getAddressVar8(varIndex);
uint16 size = _vm->_game->_script->readUint16();
xorObfuscate(data, size);
}
void Inter_v7::o7_resolvePath(OpGobParams &params) {
uint16 srcVarIndex = _vm->_game->_script->readUint16();
uint16 destVarIndex = _vm->_game->_script->readUint16();
char *str = GET_VAR_STR(srcVarIndex);
Common::String resolvedPath = getFile(str);
if ((int)resolvedPath.size() > 4 * _vm->_global->_inter_animDataSize) {
warning("o7_resolvePath: resolved path too long (%d > max length = %d), truncating",
(int)resolvedPath.size(),
4 * _vm->_global->_inter_animDataSize);
resolvedPath = resolvedPath.substr(0, 4 * _vm->_global->_inter_animDataSize);
}
WRITE_VAR_STR(destVarIndex, resolvedPath.c_str());
}
void Inter_v7::o7_ansiToOEM(OpGobParams &params) {
uint16 varIndex = _vm->_game->_script->readUint16();
char *str = GET_VAR_STR(varIndex);
Common::String oemString = ansiToOEM(Common::String(str));
WRITE_VAR_STR(varIndex, oemString.c_str());
}
void Inter_v7::o7_oemToANSI(OpGobParams &params) {
uint16 varIndex = _vm->_game->_script->readUint16();
char *str = GET_VAR_STR(varIndex);
Common::String ansiString = oemToANSI(Common::String(str));
WRITE_VAR_STR(varIndex, ansiString.c_str());
}
void Inter_v7::o7_setDBStringEncoding(OpGobParams &params) {
uint16 varIndex = _vm->_game->_script->readUint16();
int mode = READ_VAR_UINT32(varIndex);
switch (mode) {
case 0:
case 1:
_translationDatabases.setEncodingIsOEM(mode);
break;
default:
warning("o7_setDBStringEncoding: invalid mode %d", mode);
break;
}
}
void Inter_v7::o7_gob0x201(OpGobParams &params) {
uint16 varIndex = _vm->_game->_script->readUint16();
WRITE_VAR(varIndex, 1);
}
void Inter_v7::o7_getFreeDiskSpace(OpGobParams &params) {
// This opcode is called by the game scripts to check if there is enough free space on the hard disk, before
// copying some data from the CD (e.g. when starting Adibou2/Sciences for the first time).
// Those copies are a no-op in ScummVM, so we just return a value high enough to make the game scripts happy.
uint16 varIndex = _vm->_game->_script->readUint16();
WRITE_VAR(varIndex, 1000000000); // HACK
}
void Inter_v7::o7_dummy(OpGobParams &params) {
_vm->_game->_script->skip(4);
}
} // End of namespace Gob
Reference in New Issue View Git Blame Copy Permalink