From fd8ac69fc45fb346a931f61701e8aec04278159b Mon Sep 17 00:00:00 2001 From: Eugene Sandulenko Date: Tue, 3 Jan 2006 23:14:39 +0000 Subject: Patch #1395615 "GobEngine code wrapped in classes". With some cosmetic changes. svn-id: r19899 --- gob/anim.cpp | 12 +- gob/anim.h | 15 +- gob/cdrom.cpp | 119 +-- gob/cdrom.h | 39 +- gob/dataio.cpp | 187 ++-- gob/dataio.h | 56 +- gob/draw.cpp | 981 +++++++++---------- gob/draw.h | 164 ++-- gob/driver_vga.cpp | 14 +- gob/driver_vga.h | 14 +- gob/game.cpp | 1491 ++++++++++++++--------------- gob/game.h | 269 +++--- gob/global.cpp | 255 +++-- gob/global.h | 177 ++-- gob/gob.cpp | 137 ++- gob/gob.h | 51 +- gob/goblin.cpp | 2696 ++++++++++++++++++++++++++-------------------------- gob/goblin.h | 354 +++---- gob/init.cpp | 247 +++-- gob/init.h | 18 +- gob/inter.cpp | 1162 +++++++++++----------- gob/inter.h | 142 +-- gob/map.cpp | 522 +++++----- gob/map.h | 111 ++- gob/mult.cpp | 1188 +++++++++++------------ gob/mult.h | 327 ++++--- gob/pack.cpp | 2 +- gob/pack.h | 7 +- gob/palanim.cpp | 189 ++-- gob/palanim.h | 19 +- gob/parse.cpp | 373 ++++---- gob/parse.h | 29 +- gob/scenery.cpp | 620 ++++++------ gob/scenery.h | 214 +++-- gob/sound.cpp | 107 +-- gob/sound.h | 109 ++- gob/timer.cpp | 10 +- gob/timer.h | 19 +- gob/util.cpp | 200 ++-- gob/util.h | 125 ++- gob/video.cpp | 162 ++-- gob/video.h | 166 ++-- 42 files changed, 6743 insertions(+), 6356 deletions(-) diff --git a/gob/anim.cpp b/gob/anim.cpp index 7524ca91f8..3d3fd4ab74 100644 --- a/gob/anim.cpp +++ b/gob/anim.cpp @@ -25,10 +25,12 @@ namespace Gob { -int16 anim_animAreaLeft; -int16 anim_animAreaTop; -int16 anim_animAreaWidth; -int16 anim_animAreaHeight; -SurfaceDesc *anim_underAnimSurf = 0; +Anim::Anim() { + _areaLeft = 0; + _areaTop = 0; + _areaWidth = 0; + _areaHeight = 0; + _animSurf = 0; +} } // End of namespace Gob diff --git a/gob/anim.h b/gob/anim.h index 2557e7d0ba..741816a710 100644 --- a/gob/anim.h +++ b/gob/anim.h @@ -24,11 +24,16 @@ namespace Gob { -extern int16 anim_animAreaLeft; -extern int16 anim_animAreaTop; -extern int16 anim_animAreaWidth; -extern int16 anim_animAreaHeight; -extern SurfaceDesc *anim_underAnimSurf; +class Anim { +public: + int16 _areaLeft; + int16 _areaTop; + int16 _areaWidth; + int16 _areaHeight; + Video::SurfaceDesc *_animSurf; + + Anim(); +}; } // End of namespace Gob diff --git a/gob/cdrom.cpp b/gob/cdrom.cpp index 6a8ae1a4b7..ed05812c87 100644 --- a/gob/cdrom.cpp +++ b/gob/cdrom.cpp @@ -28,73 +28,76 @@ namespace Gob { -byte *cd_LICbuffer; -char cd_curTrack[16]; -uint16 cd_numTracks; -bool cd_globFlag; -uint32 cd_trackStop; -uint32 cd_startTime; - -void cd_readLIC(const char *fname) { +CDROM::CDROM(GobEngine *vm) : _vm(vm) { + _cdPlaying = false; + _LICbuffer = 0; + for (int i = 0; i < 16; i++) + _curTrack[i] = 0; + _numTracks = 0; + _trackStop = 0; + _startTime = 0; +} + +void CDROM::readLIC(const char *fname) { char tmp[80]; int handle; uint16 version, startChunk, pos; - cd_freeLICbuffer(); + freeLICbuffer(); - *cd_curTrack = 0; + *_curTrack = 0; strcpy(tmp, fname); - handle = data_openData(tmp); + handle = _vm->_dataio->openData(tmp); if (handle == -1) return; - data_closeData(handle); + _vm->_dataio->closeData(handle); - data_getUnpackedData(tmp); + _vm->_dataio->getUnpackedData(tmp); - handle = data_openData(tmp); + handle = _vm->_dataio->openData(tmp); - data_readData(handle, (char *)&version, 2); + _vm->_dataio->readData(handle, (char *)&version, 2); version = READ_LE_UINT16(&version); - data_readData(handle, (char *)&startChunk, 2); + _vm->_dataio->readData(handle, (char *)&startChunk, 2); startChunk = READ_LE_UINT16(&startChunk); - data_readData(handle, (char *)&cd_numTracks, 2); - cd_numTracks = READ_LE_UINT16(&cd_numTracks); + _vm->_dataio->readData(handle, (char *)&_numTracks, 2); + _numTracks = READ_LE_UINT16(&_numTracks); if (version != 3) { error("Wrong file %s (%d)", fname, version); return; } - data_seekData(handle, 50, SEEK_SET); + _vm->_dataio->seekData(handle, 50, SEEK_SET); for (int i = 0; i < startChunk; i++) { - data_readData(handle, (char *)&pos, 2); + _vm->_dataio->readData(handle, (char *)&pos, 2); pos = READ_LE_UINT16(&pos); if (!pos) break; - data_seekData(handle, pos, SEEK_CUR); + _vm->_dataio->seekData(handle, pos, SEEK_CUR); } - cd_LICbuffer = (byte *)malloc(cd_numTracks * 22); - data_readData(handle, (char *)cd_LICbuffer, cd_numTracks * 22); + _LICbuffer = (byte *)malloc(_numTracks * 22); + _vm->_dataio->readData(handle, (char *)_LICbuffer, _numTracks * 22); - data_closeData(handle); + _vm->_dataio->closeData(handle); } -void cd_freeLICbuffer(void) { - free(cd_LICbuffer); - cd_LICbuffer = 0; +void CDROM::freeLICbuffer(void) { + free(_LICbuffer); + _LICbuffer = 0; } -void cd_playBgMusic() { +void CDROM::playBgMusic() { static const char *tracks[][2] = { {"avt00.tot", "mine"}, {"avt001.tot", "nuit"}, @@ -121,13 +124,13 @@ void cd_playBgMusic() { }; for (int i = 0; i < ARRAYSIZE(tracks); i++) - if (!scumm_stricmp(game_curTotFile, tracks[i][0])) { - cd_startTrack(tracks[i][1]); + if (!scumm_stricmp(_vm->_game->curTotFile, tracks[i][0])) { + startTrack(tracks[i][1]); break; } } -void cd_playMultMusic() { +void CDROM::playMultMusic() { static const char *tracks[][6] = { {"avt005.tot", "fra1", "all1", "ang1", "esp1", "ita1"}, {"avt006.tot", "fra2", "all2", "ang2", "esp2", "ita2"}, @@ -138,25 +141,25 @@ void cd_playMultMusic() { }; for (int i = 0; i < ARRAYSIZE(tracks); i++) - if (!scumm_stricmp(game_curTotFile, tracks[i][0])) { - cd_globFlag = true; - cd_startTrack(tracks[i][language + 1]); + if (!scumm_stricmp(_vm->_game->curTotFile, tracks[i][0])) { + _cdPlaying = true; + startTrack(tracks[i][_vm->_global->language + 1]); break; } } -void cd_startTrack(const char *trackname) { +void CDROM::startTrack(const char *trackname) { byte *curPtr, *matchPtr; - if (!cd_LICbuffer) + if (!_LICbuffer) return; - debug(3, "cd_startTrack(%s)", trackname); + debug(3, "startTrack(%s)", trackname); matchPtr = 0; - curPtr = cd_LICbuffer; + curPtr = _LICbuffer; - for (int i = 0; i < cd_numTracks; i++) { + for (int i = 0; i < _numTracks; i++) { if (!scumm_stricmp((char *)curPtr, trackname)) { matchPtr = curPtr; break; @@ -169,64 +172,64 @@ void cd_startTrack(const char *trackname) { return; } - strcpy(cd_curTrack, trackname); + strcpy(_curTrack, trackname); - cd_stopPlaying(); + stopPlaying(); - while (cd_getTrackPos() != -1); + while (getTrackPos() != -1); uint32 start, end; start = READ_LE_UINT32(matchPtr + 12); end = READ_LE_UINT32(matchPtr + 16); - cd_play(start, end); + play(start, end); - cd_startTime = util_getTimeKey(); - cd_trackStop = cd_startTime + (end - start + 1 + 150) * 40 / 3; + _startTime = _vm->_util->getTimeKey(); + _trackStop = _startTime + (end - start + 1 + 150) * 40 / 3; } -void cd_play(uint32 from, uint32 to) { +void CDROM::play(uint32 from, uint32 to) { // play from sector [from] to sector [to] // // format is HSG: // HSG encodes frame information into a double word: // minute multiplied by 4500, plus second multiplied by 75, // plus frame, minus 150 - debug(3, "cd_play(%d, %d)", from, to); + debug(3, "play(%d, %d)", from, to); AudioCD.play(1, 0, from, to - from + 1); } -int32 cd_getTrackPos(void) { - uint32 curPos = util_getTimeKey() - cd_startTime; +int32 CDROM::getTrackPos(void) { + uint32 curPos = _vm->_util->getTimeKey() - _startTime; - if (AudioCD.isPlaying() && (util_getTimeKey() < cd_trackStop)) + if (AudioCD.isPlaying() && (_vm->_util->getTimeKey() < _trackStop)) return curPos * 3 / 40; else return -1; } -void cd_stopPlaying(void) { - cd_stop(); +void CDROM::stopPlaying(void) { + stop(); - while (cd_getTrackPos() != -1); + while (getTrackPos() != -1); } -void cd_stop(void) { - debug(3, "cd_stop()"); +void CDROM::stop(void) { + debug(3, "stop()"); AudioCD.stop(); } -void cd_testCD(int trySubst, const char *label) { +void CDROM::testCD(int trySubst, const char *label) { if (!trySubst) { error("CDROM track substitution is not supported"); return; } - cd_LICbuffer = 0; - cd_globFlag = false; + _LICbuffer = 0; + _cdPlaying = false; // Original checked CD label here // but will skip it as it will require OSystem extensions of direct diff --git a/gob/cdrom.h b/gob/cdrom.h index 48a693e135..110e053bd7 100644 --- a/gob/cdrom.h +++ b/gob/cdrom.h @@ -22,18 +22,31 @@ namespace Gob { -extern bool cd_globFlag; - -void cd_readLIC(const char *fname); -void cd_freeLICbuffer(void); - -void cd_startTrack(const char *s); -void cd_playBgMusic(); -void cd_playMultMusic(); -void cd_play(uint32 from, uint32 to); -int32 cd_getTrackPos(void); -void cd_stopPlaying(void); -void cd_stop(void); -void cd_testCD(int trySubst, const char *label); +class CDROM { +public: + bool _cdPlaying; + + void readLIC(const char *fname); + void freeLICbuffer(void); + + void startTrack(const char *s); + void playBgMusic(); + void playMultMusic(); + void play(uint32 from, uint32 to); + int32 getTrackPos(void); + void stopPlaying(void); + void stop(void); + void testCD(int trySubst, const char *label); + + CDROM(GobEngine *vm); + +protected: + byte *_LICbuffer; + char _curTrack[16]; + uint16 _numTracks; + uint32 _trackStop; + uint32 _startTime; + GobEngine *_vm; +}; } // End of namespace Gob diff --git a/gob/dataio.cpp b/gob/dataio.cpp index 809bce42e7..e0743566d4 100644 --- a/gob/dataio.cpp +++ b/gob/dataio.cpp @@ -26,11 +26,14 @@ namespace Gob { -Common::File *file_getHandle(int16 handle) { - return &filesHandles[handle]; +DataIO::DataIO(GobEngine *vm) : _vm(vm) { } -int16 file_open(const char *path, Common::File::AccessMode mode) { +Common::File *DataIO::file_getHandle(int16 handle) { + return &_vm->_global->filesHandles[handle]; +} + +int16 DataIO::file_open(const char *path, Common::File::AccessMode mode) { int16 i; for (i = 0; i < MAX_FILES; i++) { @@ -48,51 +51,51 @@ int16 file_open(const char *path, Common::File::AccessMode mode) { return -1; } -int16 data_getChunk(const char *chunkName) { +int16 DataIO::getChunk(const char *chunkName) { int16 file; int16 slot; int16 chunk; struct ChunkDesc *dataDesc; for (file = 0; file < MAX_DATA_FILES; file++) { - if (dataFiles[file] == 0) + if (_vm->_global->dataFiles[file] == 0) return -1; for (slot = 0; slot < MAX_SLOT_COUNT; slot++) - if (chunkPos[file * MAX_SLOT_COUNT + slot] == -1) + if (_vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot] == -1) break; if (slot == MAX_SLOT_COUNT) return -1; - dataDesc = dataFiles[file]; - for (chunk = 0; chunk < numDataChunks[file]; + dataDesc = _vm->_global->dataFiles[file]; + for (chunk = 0; chunk < _vm->_global->numDataChunks[file]; chunk++, dataDesc++) { if (scumm_stricmp(chunkName, dataDesc->chunkName) != 0) continue; - isCurrentSlot[file * MAX_SLOT_COUNT + slot] = 0; - chunkSize[file * MAX_SLOT_COUNT + slot] = + _vm->_global->isCurrentSlot[file * MAX_SLOT_COUNT + slot] = 0; + _vm->_global->chunkSize[file * MAX_SLOT_COUNT + slot] = dataDesc->size; - chunkOffset[file * MAX_SLOT_COUNT + slot] = + _vm->_global->chunkOffset[file * MAX_SLOT_COUNT + slot] = dataDesc->offset; - chunkPos[file * MAX_SLOT_COUNT + slot] = 0; + _vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot] = 0; return file * 10 + slot + 50; } } return -1; } -char data_freeChunk(int16 handle) { +char DataIO::freeChunk(int16 handle) { if (handle >= 50 && handle < 100) { handle -= 50; - chunkPos[(handle / 10) * MAX_SLOT_COUNT + (handle % 10)] = -1; + _vm->_global->chunkPos[(handle / 10) * MAX_SLOT_COUNT + (handle % 10)] = -1; return 0; } return 1; } -int32 data_readChunk(int16 handle, char *buf, int16 size) { +int32 DataIO::readChunk(int16 handle, char *buf, int16 size) { int16 file; int16 slot; int16 i; @@ -103,30 +106,30 @@ int32 data_readChunk(int16 handle, char *buf, int16 size) { file = (handle - 50) / 10; slot = (handle - 50) % 10; - if (isCurrentSlot[file * MAX_SLOT_COUNT + slot] == 0) { + if (_vm->_global->isCurrentSlot[file * MAX_SLOT_COUNT + slot] == 0) { for (i = 0; i < MAX_SLOT_COUNT; i++) - isCurrentSlot[file * MAX_SLOT_COUNT + i] = 0; + _vm->_global->isCurrentSlot[file * MAX_SLOT_COUNT + i] = 0; offset = - chunkOffset[file * MAX_SLOT_COUNT + slot] + - chunkPos[file * MAX_SLOT_COUNT + slot]; - debug(7, "seek: %ld, %ld", chunkOffset[file * MAX_SLOT_COUNT + slot], chunkPos[file * MAX_SLOT_COUNT + slot]); - file_getHandle(dataFileHandles[file])->seek(offset, SEEK_SET); + _vm->_global->chunkOffset[file * MAX_SLOT_COUNT + slot] + + _vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot]; + debug(7, "seek: %ld, %ld", _vm->_global->chunkOffset[file * MAX_SLOT_COUNT + slot], _vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot]); + file_getHandle(_vm->_global->dataFileHandles[file])->seek(offset, SEEK_SET); } - isCurrentSlot[file * MAX_SLOT_COUNT + slot] = 1; - if (chunkPos[file * MAX_SLOT_COUNT + slot] + size > - chunkSize[file * MAX_SLOT_COUNT + slot]) + _vm->_global->isCurrentSlot[file * MAX_SLOT_COUNT + slot] = 1; + if (_vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot] + size > + _vm->_global->chunkSize[file * MAX_SLOT_COUNT + slot]) size = - chunkSize[file * MAX_SLOT_COUNT + slot] - - chunkPos[file * MAX_SLOT_COUNT + slot]; + _vm->_global->chunkSize[file * MAX_SLOT_COUNT + slot] - + _vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot]; - file_getHandle(dataFileHandles[file])->read(buf, size); - chunkPos[file * MAX_SLOT_COUNT + slot] += size; + file_getHandle(_vm->_global->dataFileHandles[file])->read(buf, size); + _vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot] += size; return size; } -int16 data_seekChunk(int16 handle, int32 pos, int16 from) { +int16 DataIO::seekChunk(int16 handle, int32 pos, int16 from) { int16 file; int16 slot; @@ -135,16 +138,16 @@ int16 data_seekChunk(int16 handle, int32 pos, int16 from) { file = (handle - 50) / 10; slot = (handle - 50) % 10; - isCurrentSlot[file * MAX_SLOT_COUNT + slot] = 0; + _vm->_global->isCurrentSlot[file * MAX_SLOT_COUNT + slot] = 0; if (from == SEEK_SET) - chunkPos[file * MAX_SLOT_COUNT + slot] = pos; + _vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot] = pos; else - chunkPos[file * MAX_SLOT_COUNT + slot] += pos; + _vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot] += pos; - return chunkPos[file * MAX_SLOT_COUNT + slot]; + return _vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot]; } -int32 data_getChunkSize(const char *chunkName) { +int32 DataIO::getChunkSize(const char *chunkName) { int16 file; int16 chunk; struct ChunkDesc *dataDesc; @@ -152,33 +155,33 @@ int32 data_getChunkSize(const char *chunkName) { int32 realSize; for (file = 0; file < MAX_DATA_FILES; file++) { - if (dataFiles[file] == 0) + if (_vm->_global->dataFiles[file] == 0) return -1; - dataDesc = dataFiles[file]; - for (chunk = 0; chunk < numDataChunks[file]; + dataDesc = _vm->_global->dataFiles[file]; + for (chunk = 0; chunk < _vm->_global->numDataChunks[file]; chunk++, dataDesc++) { if (scumm_stricmp(chunkName, dataDesc->chunkName) != 0) continue; if (dataDesc->packed == 0) { - packedSize = -1; + _vm->_global->packedSize = -1; return dataDesc->size; } for (slot = 0; slot < MAX_SLOT_COUNT; slot++) - isCurrentSlot[slot] = 0; + _vm->_global->isCurrentSlot[slot] = 0; - file_getHandle(dataFileHandles[file])->seek(dataDesc->offset, SEEK_SET); - realSize = file_getHandle(dataFileHandles[file])->readUint32LE(); - packedSize = dataDesc->size; + file_getHandle(_vm->_global->dataFileHandles[file])->seek(dataDesc->offset, SEEK_SET); + realSize = file_getHandle(_vm->_global->dataFileHandles[file])->readUint32LE(); + _vm->_global->packedSize = dataDesc->size; return realSize; } } return -1; } -void data_openDataFile(const char *src) { +void DataIO::openDataFile(const char *src) { char path[128]; int16 i; int16 file; @@ -190,52 +193,52 @@ void data_openDataFile(const char *src) { strcat(path, ".stk"); for (file = 0; file < MAX_DATA_FILES; file++) - if (dataFiles[file] == 0) + if (_vm->_global->dataFiles[file] == 0) break; if (file == MAX_DATA_FILES) - error("data_dataFileOpen: Data file slots are full\n"); - dataFileHandles[file] = file_open(path); + error("dataFileOpen: Data file slots are full\n"); + _vm->_global->dataFileHandles[file] = file_open(path); - if (dataFileHandles[file] == -1) - error("data_dataFileOpen: Can't open %s data file\n", path); + if (_vm->_global->dataFileHandles[file] == -1) + error("dataFileOpen: Can't open %s data file\n", path); - numDataChunks[file] = file_getHandle(dataFileHandles[file])->readUint16LE(); + _vm->_global->numDataChunks[file] = file_getHandle(_vm->_global->dataFileHandles[file])->readUint16LE(); - debug(7, "DataChunks: %d [for %s]", numDataChunks[file], path); + debug(7, "DataChunks: %d [for %s]", _vm->_global->numDataChunks[file], path); - dataFiles[file] = dataDesc = + _vm->_global->dataFiles[file] = dataDesc = (struct ChunkDesc *)malloc(sizeof(struct ChunkDesc) * - numDataChunks[file]); + _vm->_global->numDataChunks[file]); - for (i = 0; i < numDataChunks[file]; i++) { - file_getHandle(dataFileHandles[file])->read(dataDesc[i].chunkName, 13); - dataDesc[i].size = file_getHandle(dataFileHandles[file])->readUint32LE(); - dataDesc[i].offset = file_getHandle(dataFileHandles[file])->readUint32LE(); - dataDesc[i].packed = file_getHandle(dataFileHandles[file])->readByte(); + for (i = 0; i < _vm->_global->numDataChunks[file]; i++) { + file_getHandle(_vm->_global->dataFileHandles[file])->read(dataDesc[i].chunkName, 13); + dataDesc[i].size = file_getHandle(_vm->_global->dataFileHandles[file])->readUint32LE(); + dataDesc[i].offset = file_getHandle(_vm->_global->dataFileHandles[file])->readUint32LE(); + dataDesc[i].packed = file_getHandle(_vm->_global->dataFileHandles[file])->readByte(); } - for (i = 0; i < numDataChunks[file]; i++) + for (i = 0; i < _vm->_global->numDataChunks[file]; i++) debug(7, "%d: %s %d", i, dataDesc[i].chunkName, dataDesc[i].size); for (i = 0; i < MAX_SLOT_COUNT; i++) - chunkPos[file * MAX_SLOT_COUNT + i] = -1; + _vm->_global->chunkPos[file * MAX_SLOT_COUNT + i] = -1; } -void data_closeDataFile() { +void DataIO::closeDataFile() { int16 file; for (file = MAX_DATA_FILES - 1; file >= 0; file--) { - if (dataFiles[file] != 0) { - free(dataFiles[file]); - dataFiles[file] = 0; - file_getHandle(dataFileHandles[file])->close(); + if (_vm->_global->dataFiles[file] != 0) { + free(_vm->_global->dataFiles[file]); + _vm->_global->dataFiles[file] = 0; + file_getHandle(_vm->_global->dataFileHandles[file])->close(); return; } } } -char *data_getUnpackedData(const char *name) { +char *DataIO::getUnpackedData(const char *name) { int32 realSize; int16 chunk; char *unpackBuf; @@ -243,11 +246,11 @@ char *data_getUnpackedData(const char *name) { char *ptr; int32 sizeLeft; - realSize = data_getChunkSize(name); - if (packedSize == -1 || realSize == -1) + realSize = getChunkSize(name); + if (_vm->_global->packedSize == -1 || realSize == -1) return 0; - chunk = data_getChunk(name); + chunk = getChunk(name); if (chunk == -1) return 0; @@ -255,76 +258,76 @@ char *data_getUnpackedData(const char *name) { if (unpackBuf == 0) return 0; - packBuf = (char *)malloc(packedSize); + packBuf = (char *)malloc(_vm->_global->packedSize); if (packBuf == 0) { free(unpackBuf); return 0; } - sizeLeft = packedSize; + sizeLeft = _vm->_global->packedSize; ptr = packBuf; while (sizeLeft > 0x4000) { - data_readChunk(chunk, ptr, 0x4000); + readChunk(chunk, ptr, 0x4000); sizeLeft -= 0x4000; ptr += 0x4000; } - data_readChunk(chunk, ptr, sizeLeft); - data_freeChunk(chunk); - unpackData(packBuf, unpackBuf); + readChunk(chunk, ptr, sizeLeft); + freeChunk(chunk); + _vm->_pack->unpackData(packBuf, unpackBuf); free(packBuf); return unpackBuf; } -void data_closeData(int16 handle) { - if (data_freeChunk(handle) != 0) +void DataIO::closeData(int16 handle) { + if (freeChunk(handle) != 0) file_getHandle(handle)->close(); } -int16 data_openData(const char *path, Common::File::AccessMode mode) { +int16 DataIO::openData(const char *path, Common::File::AccessMode mode) { int16 handle; if (mode != Common::File::kFileReadMode) return file_open(path, mode); - handle = data_getChunk(path); + handle = getChunk(path); if (handle >= 0) return handle; return file_open(path, mode); } -int32 data_readData(int16 handle, char *buf, int16 size) { +int32 DataIO::readData(int16 handle, char *buf, int16 size) { int32 res; - res = data_readChunk(handle, buf, size); + res = readChunk(handle, buf, size); if (res >= 0) return res; return file_getHandle(handle)->read(buf, size); } -void data_seekData(int16 handle, int32 pos, int16 from) { +void DataIO::seekData(int16 handle, int32 pos, int16 from) { int32 resPos; - resPos = data_seekChunk(handle, pos, from); + resPos = seekChunk(handle, pos, from); if (resPos != -1) return; file_getHandle(handle)->seek(pos, from); } -int32 data_getDataSize(const char *name) { +int32 DataIO::getDataSize(const char *name) { char buf[128]; int32 chunkSz; Common::File file; strcpy(buf, name); - chunkSz = data_getChunkSize(buf); + chunkSz = getChunkSize(buf); if (chunkSz >= 0) return chunkSz; if (!file.open(buf)) - error("data_getDataSize: Can't find data(%s)", name); + error("getDataSize: Can't find data(%s)", name); chunkSz = file.size(); file.close(); @@ -332,31 +335,31 @@ int32 data_getDataSize(const char *name) { return chunkSz; } -char *data_getData(const char *path) { +char *DataIO::getData(const char *path) { char *data; char *ptr; int32 size; int16 handle; - data = data_getUnpackedData(path); + data = getUnpackedData(path); if (data != 0) return data; - size = data_getDataSize(path); + size = getDataSize(path); data = (char *)malloc(size); if (data == 0) return 0; - handle = data_openData(path); + handle = openData(path); ptr = data; while (size > 0x4000) { - data_readData(handle, ptr, 0x4000); + readData(handle, ptr, 0x4000); size -= 0x4000; ptr += 0x4000; } - data_readData(handle, ptr, size); - data_closeData(handle); + readData(handle, ptr, size); + closeData(handle); return data; } diff --git a/gob/dataio.h b/gob/dataio.h index 15b33d55b8..48ac485c01 100644 --- a/gob/dataio.h +++ b/gob/dataio.h @@ -23,36 +23,46 @@ #define GOB_DATAIO_H #include "common/file.h" +#include "gob/gob.h" namespace Gob { #define MAX_DATA_FILES 3 #define MAX_SLOT_COUNT 4 -struct ChunkDesc { - char chunkName[13]; - uint32 size; - uint32 offset; - byte packed; -}; +class DataIO { +public: + struct ChunkDesc { + char chunkName[13]; + uint32 size; + uint32 offset; + byte packed; + ChunkDesc() : size(0), offset(0), packed(0) { chunkName[0] = 0; } + }; + + int16 file_open(const char *path, Common::File::AccessMode mode = Common::File::kFileReadMode); + Common::File *file_getHandle(int16 handle); + int16 getChunk(const char *chunkName); + char freeChunk(int16 handle); + int32 readChunk(int16 handle, char *buf, int16 size); + int16 seekChunk(int16 handle, int32 pos, int16 from); + int32 getChunkSize(const char *chunkName); + void openDataFile(const char *src); + void closeDataFile(void); + char *getUnpackedData(const char *name); + void closeData(int16 handle); + int16 openData(const char *path, Common::File::AccessMode mode = Common::File::kFileReadMode); + int32 readData(int16 handle, char *buf, int16 size); + void seekData(int16 handle, int32 pos, int16 from); + int32 getDataSize(const char *name); + char *getData(const char *path); + char *getSmallData(const char *path); -int16 file_open(const char *path, Common::File::AccessMode mode = Common::File::kFileReadMode); -Common::File *file_getHandle(int16 handle); -int16 data_getChunk(const char *chunkName); -char data_freeChunk(int16 handle); -int32 data_readChunk(int16 handle, char *buf, int16 size); -int16 data_seekChunk(int16 handle, int32 pos, int16 from); -int32 data_getChunkSize(const char *chunkName); -void data_openDataFile(const char *src); -void data_closeDataFile(void); -char *data_getUnpackedData(const char *name); -void data_closeData(int16 handle); -int16 data_openData(const char *path, Common::File::AccessMode mode = Common::File::kFileReadMode); -int32 data_readData(int16 handle, char *buf, int16 size); -void data_seekData(int16 handle, int32 pos, int16 from); -int32 data_getDataSize(const char *name); -char *data_getData(const char *path); -char *data_getSmallData(const char *path); + DataIO(class GobEngine *vm); + +protected: + class GobEngine *_vm; +}; } // End of namespace Gob diff --git a/gob/draw.cpp b/gob/draw.cpp index 4c7b592710..a894f8e1a7 100644 --- a/gob/draw.cpp +++ b/gob/draw.cpp @@ -33,72 +33,101 @@ namespace Gob { -int16 draw_fontIndex = 0; -int16 draw_spriteLeft = 0; -int16 draw_spriteTop = 0; -int16 draw_spriteRight = 0; -int16 draw_spriteBottom = 0; -int16 draw_destSpriteX = 0; -int16 draw_destSpriteY = 0; -int16 draw_backColor = 0; -int16 draw_frontColor = 0; -char draw_letterToPrint = 0; -Draw_FontToSprite draw_fontToSprite[4]; -int16 draw_destSurface = 0; -int16 draw_sourceSurface = 0; -int16 draw_renderFlags = 0; -int16 draw_backDeltaX = 0; -int16 draw_backDeltaY = 0; -FontDesc *draw_fonts[4]; -char *draw_textToPrint = 0; -int16 draw_transparency = 0; -SurfaceDesc *draw_spritesArray[50]; - -int16 draw_invalidatedCount; -int16 draw_invalidatedTops[30]; -int16 draw_invalidatedLefts[30]; -int16 draw_invalidatedRights[30]; -int16 draw_invalidatedBottoms[30]; - -int8 draw_noInvalidated = 0; -int8 draw_applyPal = 0; -int8 draw_paletteCleared = 0; - -SurfaceDesc *draw_backSurface = 0; -SurfaceDesc *draw_frontSurface = 0; - -int16 draw_unusedPalette1[18]; -int16 draw_unusedPalette2[16]; -Color draw_vgaPalette[256]; -Color draw_vgaSmallPalette[16]; - -int16 draw_cursorX = 0; -int16 draw_cursorY = 0; -int16 draw_cursorWidth = 0; -int16 draw_cursorHeight = 0; - -int16 draw_cursorXDeltaVar = -1; -int16 draw_cursorYDeltaVar = -1; - -int16 draw_cursorIndex = 0; -int16 draw_transparentCursor = 0; -SurfaceDesc *draw_cursorSprites = 0; -SurfaceDesc *draw_cursorBack = 0; -int16 draw_cursorAnim = 0; -int8 draw_cursorAnimLow[40]; -int8 draw_cursorAnimHigh[40]; -int8 draw_cursorAnimDelays[40]; -static uint32 draw_cursorTimeKey = 0; - -int16 draw_palLoadData1[] = { 0, 17, 34, 51 }; -int16 draw_palLoadData2[] = { 0, 68, 136, 204 }; - -void draw_invalidateRect(int16 left, int16 top, int16 right, int16 bottom) { +Draw::Draw(GobEngine *vm) : _vm(vm) { + fontIndex = 0; + spriteLeft = 0; + spriteTop = 0; + spriteRight = 0; + spriteBottom = 0; + destSpriteX = 0; + destSpriteY = 0; + backColor = 0; + frontColor = 0; + letterToPrint = 0; + + destSurface = 0; + sourceSurface = 0; + renderFlags = 0; + backDeltaX = 0; + backDeltaY = 0; + + for (int i = 0; i < 4; i++) + fonts[i] = 0; + + textToPrint = 0; + transparency = 0; + + for (int i = 0; i < 50; i++) + spritesArray[i] = 0; + + invalidatedCount = 0; + for (int i = 0; i < 30; i++) { + invalidatedTops[i] = 0; + invalidatedLefts[i] = 0; + invalidatedRights[i] = 0; + invalidatedBottoms[i] = 0; + } + + noInvalidated = 0; + applyPal = 0; + paletteCleared = 0; + + backSurface = 0; + frontSurface = 0; + + for (int i = 0; i < 18; i++) + unusedPalette1[i] = 0; + for (int i = 0; i < 16; i++) + unusedPalette2[i] = 0; + for (int i = 0; i < 256; i++) { + vgaPalette[i].red = 0; + vgaPalette[i].blue = 0; + vgaPalette[i].green = 0; + } + for (int i = 0; i < 16; i++) { + vgaSmallPalette[i].red = 0; + vgaSmallPalette[i].blue = 0; + vgaSmallPalette[i].green = 0; + } + + cursorX = 0; + cursorY = 0; + cursorWidth = 0; + cursorHeight = 0; + + cursorXDeltaVar = -1; + cursorYDeltaVar = -1; + + for (int i = 0; i < 40; i++) { + cursorAnimLow[i] = 0; + cursorAnimHigh[i] = 0; + cursorAnimDelays[i] = 0; + } + + gcursorIndex = 0; + transparentCursor = 0; + cursorSprites = 0; + cursorBack = 0; + cursorAnim = 0; + + palLoadData1[0] = 0; + palLoadData1[1] = 17; + palLoadData1[2] = 34; + palLoadData1[3] = 51; + palLoadData2[0] = 0; + palLoadData2[1] = 68; + palLoadData2[2] = 136; + palLoadData2[3] = 204; + + cursorTimeKey = 0; +} + +void Draw::invalidateRect(int16 left, int16 top, int16 right, int16 bottom) { int16 temp; int16 rect; int16 i; - if (draw_renderFlags & RENDERFLAG_NOINVALIDATE) + if (renderFlags & RENDERFLAG_NOINVALIDATE) return; if (left > right) { @@ -115,14 +144,14 @@ void draw_invalidateRect(int16 left, int16 top, int16 right, int16 bottom) { if (left > 319 || right < 0 || top > 199 || bottom < 0) return; - draw_noInvalidated = 0; + noInvalidated = 0; - if (draw_invalidatedCount >= 30) { - draw_invalidatedLefts[0] = 0; - draw_invalidatedTops[0] = 0; - draw_invalidatedRights[0] = 319; - draw_invalidatedBottoms[0] = 199; - draw_invalidatedCount = 1; + if (invalidatedCount >= 30) { + invalidatedLefts[0] = 0; + invalidatedTops[0] = 0; + invalidatedRights[0] = 319; + invalidatedBottoms[0] = 199; + invalidatedCount = 1; return; } @@ -141,154 +170,154 @@ void draw_invalidateRect(int16 left, int16 top, int16 right, int16 bottom) { left &= 0xfff0; right |= 0x000f; - for (rect = 0; rect < draw_invalidatedCount; rect++) { - - if (draw_invalidatedTops[rect] > top) { - if (draw_invalidatedTops[rect] > bottom) { - for (i = draw_invalidatedCount; i > rect; i--) { - draw_invalidatedLefts[i] = - draw_invalidatedLefts[i - 1]; - draw_invalidatedTops[i] = - draw_invalidatedTops[i - 1]; - draw_invalidatedRights[i] = - draw_invalidatedRights[i - 1]; - draw_invalidatedBottoms[i] = - draw_invalidatedBottoms[i - 1]; + for (rect = 0; rect < invalidatedCount; rect++) { + + if (invalidatedTops[rect] > top) { + if (invalidatedTops[rect] > bottom) { + for (i = invalidatedCount; i > rect; i--) { + invalidatedLefts[i] = + invalidatedLefts[i - 1]; + invalidatedTops[i] = + invalidatedTops[i - 1]; + invalidatedRights[i] = + invalidatedRights[i - 1]; + invalidatedBottoms[i] = + invalidatedBottoms[i - 1]; } - draw_invalidatedLefts[rect] = left; - draw_invalidatedTops[rect] = top; - draw_invalidatedRights[rect] = right; - draw_invalidatedBottoms[rect] = bottom; - draw_invalidatedCount++; + invalidatedLefts[rect] = left; + invalidatedTops[rect] = top; + invalidatedRights[rect] = right; + invalidatedBottoms[rect] = bottom; + invalidatedCount++; return; } - if (draw_invalidatedBottoms[rect] < bottom) - draw_invalidatedBottoms[rect] = bottom; + if (invalidatedBottoms[rect] < bottom) + invalidatedBottoms[rect] = bottom; - if (draw_invalidatedLefts[rect] > left) - draw_invalidatedLefts[rect] = left; + if (invalidatedLefts[rect] > left) + invalidatedLefts[rect] = left; - if (draw_invalidatedRights[rect] < right) - draw_invalidatedRights[rect] = right; + if (invalidatedRights[rect] < right) + invalidatedRights[rect] = right; - draw_invalidatedTops[rect] = top; + invalidatedTops[rect] = top; return; } - if (draw_invalidatedBottoms[rect] < top) + if (invalidatedBottoms[rect] < top) continue; - if (draw_invalidatedBottoms[rect] < bottom) - draw_invalidatedBottoms[rect] = bottom; + if (invalidatedBottoms[rect] < bottom) + invalidatedBottoms[rect] = bottom; - if (draw_invalidatedLefts[rect] > left) - draw_invalidatedLefts[rect] = left; + if (invalidatedLefts[rect] > left) + invalidatedLefts[rect] = left; - if (draw_invalidatedRights[rect] < right) - draw_invalidatedRights[rect] = right; + if (invalidatedRights[rect] < right) + invalidatedRights[rect] = right; return; } - draw_invalidatedLefts[draw_invalidatedCount] = left; - draw_invalidatedTops[draw_invalidatedCount] = top; - draw_invalidatedRights[draw_invalidatedCount] = right; - draw_invalidatedBottoms[draw_invalidatedCount] = bottom; - draw_invalidatedCount++; + invalidatedLefts[invalidatedCount] = left; + invalidatedTops[invalidatedCount] = top; + invalidatedRights[invalidatedCount] = right; + invalidatedBottoms[invalidatedCount] = bottom; + invalidatedCount++; return; } -void draw_blitInvalidated(void) { +void Draw::blitInvalidated(void) { int16 i; - if (draw_cursorIndex == 4) - draw_blitCursor(); + if (gcursorIndex == 4) + blitCursor(); - if (inter_terminate) + if (_vm->_inter->terminate) return; - if (draw_noInvalidated && draw_applyPal == 0) + if (noInvalidated && applyPal == 0) return; - if (draw_noInvalidated) { - draw_setPalette(); - draw_applyPal = 0; + if (noInvalidated) { + setPalette(); + applyPal = 0; return; } - if (draw_applyPal) { - draw_clearPalette(); + if (applyPal) { + clearPalette(); - vid_drawSprite(draw_backSurface, draw_frontSurface, 0, 0, 319, + _vm->_video->drawSprite(backSurface, frontSurface, 0, 0, 319, 199, 0, 0, 0); - draw_setPalette(); - draw_invalidatedCount = 0; - draw_noInvalidated = 1; - draw_applyPal = 0; + setPalette(); + invalidatedCount = 0; + noInvalidated = 1; + applyPal = 0; return; } - doRangeClamp = 0; - for (i = 0; i < draw_invalidatedCount; i++) { - vid_drawSprite(draw_backSurface, draw_frontSurface, - draw_invalidatedLefts[i], draw_invalidatedTops[i], - draw_invalidatedRights[i], draw_invalidatedBottoms[i], - draw_invalidatedLefts[i], draw_invalidatedTops[i], 0); + _vm->_global->doRangeClamp = 0; + for (i = 0; i < invalidatedCount; i++) { + _vm->_video->drawSprite(backSurface, frontSurface, + invalidatedLefts[i], invalidatedTops[i], + invalidatedRights[i], invalidatedBottoms[i], + invalidatedLefts[i], invalidatedTops[i], 0); } - doRangeClamp = 1; + _vm->_global->doRangeClamp = 1; - draw_invalidatedCount = 0; - draw_noInvalidated = 1; - draw_applyPal = 0; + invalidatedCount = 0; + noInvalidated = 1; + applyPal = 0; } -void draw_setPalette(void) { - if (videoMode != 0x13) - error("draw_setPalette: Video mode 0x%x is not supported!\n", - videoMode); +void Draw::setPalette(void) { + if (_vm->_global->videoMode != 0x13) + error("setPalette: Video mode 0x%x is not supported!\n", + _vm->_global->videoMode); - pPaletteDesc->unused1 = draw_unusedPalette1; - pPaletteDesc->unused2 = draw_unusedPalette2; - pPaletteDesc->vgaPal = draw_vgaPalette; - vid_setFullPalette(pPaletteDesc); - draw_paletteCleared = 0; + _vm->_global->pPaletteDesc->unused1 = unusedPalette1; + _vm->_global->pPaletteDesc->unused2 = unusedPalette2; + _vm->_global->pPaletteDesc->vgaPal = vgaPalette; + _vm->_video->setFullPalette(_vm->_global->pPaletteDesc); + paletteCleared = 0; } -void draw_clearPalette(void) { - if (draw_paletteCleared == 0) { - draw_paletteCleared = 1; - util_clearPalette(); +void Draw::clearPalette(void) { + if (paletteCleared == 0) { + paletteCleared = 1; + _vm->_util->clearPalette(); } } -void draw_blitCursor(void) { - if (draw_cursorIndex == -1) +void Draw::blitCursor(void) { + if (gcursorIndex == -1) return; - draw_cursorIndex = -1; - if (draw_cursorX + draw_cursorWidth > 320) - draw_cursorWidth = 320 - draw_cursorX; + gcursorIndex = -1; + if (cursorX + cursorWidth > 320) + cursorWidth = 320 - cursorX; - if (draw_cursorY + draw_cursorHeight > 200) - draw_cursorHeight = 200 - draw_cursorY; + if (cursorY + cursorHeight > 200) + cursorHeight = 200 - cursorY; - if (draw_noInvalidated) { - vid_drawSprite(draw_backSurface, draw_frontSurface, - draw_cursorX, draw_cursorY, - draw_cursorX + draw_cursorWidth - 1, - draw_cursorY + draw_cursorHeight - 1, draw_cursorX, - draw_cursorY, 0); + if (noInvalidated) { + _vm->_video->drawSprite(backSurface, frontSurface, + cursorX, cursorY, + cursorX + cursorWidth - 1, + cursorY + cursorHeight - 1, cursorX, + cursorY, 0); } else { - draw_invalidateRect(draw_cursorX, draw_cursorY, - draw_cursorX + draw_cursorWidth - 1, - draw_cursorY + draw_cursorHeight - 1); + invalidateRect(cursorX, cursorY, + cursorX + cursorWidth - 1, + cursorY + cursorHeight - 1); } } -void draw_spriteOperation(int16 operation) { +void Draw::spriteOperation(int16 operation) { uint16 id; char *dataBuf; - Game_TotResItem *itemPtr; + Game::TotResItem *itemPtr; int32 offset; int16 len; int16 i; @@ -296,270 +325,270 @@ void draw_spriteOperation(int16 operation) { int16 y; int16 perLine; - if (draw_sourceSurface >= 100) - draw_sourceSurface -= 80; + if (sourceSurface >= 100) + sourceSurface -= 80; - if (draw_destSurface >= 100) - draw_destSurface -= 80; + if (destSurface >= 100) + destSurface -= 80; - if (draw_renderFlags & RENDERFLAG_USEDELTAS) { - if (draw_sourceSurface == 21) { - draw_spriteLeft += draw_backDeltaX; - draw_spriteTop += draw_backDeltaY; + if (renderFlags & RENDERFLAG_USEDELTAS) { + if (sourceSurface == 21) { + spriteLeft += backDeltaX; + spriteTop += backDeltaY; } - if (draw_destSurface == 21) { - draw_destSpriteX += draw_backDeltaX; - draw_destSpriteY += draw_backDeltaY; + if (destSurface == 21) { + destSpriteX += backDeltaX; + destSpriteY += backDeltaY; if (operation == DRAW_DRAWLINE || (operation >= DRAW_DRAWBAR && operation <= DRAW_FILLRECTABS)) { - draw_spriteRight += draw_backDeltaX; - draw_spriteBottom += draw_backDeltaY; + spriteRight += backDeltaX; + spriteBottom += backDeltaY; } } } switch (operation) { case DRAW_BLITSURF: - vid_drawSprite(draw_spritesArray[draw_sourceSurface], - draw_spritesArray[draw_destSurface], - draw_spriteLeft, draw_spriteTop, - draw_spriteLeft + draw_spriteRight - 1, - draw_spriteTop + draw_spriteBottom - 1, - draw_destSpriteX, draw_destSpriteY, draw_transparency); - - if (draw_destSurface == 21) { - draw_invalidateRect(draw_destSpriteX, draw_destSpriteY, - draw_destSpriteX + draw_spriteRight - 1, - draw_destSpriteY + draw_spriteBottom - 1); + _vm->_video->drawSprite(spritesArray[sourceSurface], + spritesArray[destSurface], + spriteLeft, spriteTop, + spriteLeft + spriteRight - 1, + spriteTop + spriteBottom - 1, + destSpriteX, destSpriteY, transparency); + + if (destSurface == 21) { + invalidateRect(destSpriteX, destSpriteY, + destSpriteX + spriteRight - 1, + destSpriteY + spriteBottom - 1); } break; case DRAW_PUTPIXEL: - vid_putPixel(draw_destSpriteX, draw_destSpriteY, - draw_frontColor, draw_spritesArray[draw_destSurface]); - if (draw_destSurface == 21) { - draw_invalidateRect(draw_destSpriteX, draw_destSpriteY, - draw_destSpriteX, draw_destSpriteY); + _vm->_video->putPixel(destSpriteX, destSpriteY, + frontColor, spritesArray[destSurface]); + if (destSurface == 21) { + invalidateRect(destSpriteX, destSpriteY, + destSpriteX, destSpriteY); } break; case DRAW_FILLRECT: - vid_fillRect(draw_spritesArray[draw_destSurface], - draw_destSpriteX, draw_destSpriteY, - draw_destSpriteX + draw_spriteRight - 1, - draw_destSpriteY + draw_spriteBottom - 1, draw_backColor); - - if (draw_destSurface == 21) { - draw_invalidateRect(draw_destSpriteX, draw_destSpriteY, - draw_destSpriteX + draw_spriteRight - 1, - draw_destSpriteY + draw_spriteBottom - 1); + _vm->_video->fillRect(spritesArray[destSurface], + destSpriteX, destSpriteY, + destSpriteX + spriteRight - 1, + destSpriteY + spriteBottom - 1, backColor); + + if (destSurface == 21) { + invalidateRect(destSpriteX, destSpriteY, + destSpriteX + spriteRight - 1, + destSpriteY + spriteBottom - 1); } break; case DRAW_DRAWLINE: - vid_drawLine(draw_spritesArray[draw_destSurface], - draw_destSpriteX, draw_destSpriteY, - draw_spriteRight, draw_spriteBottom, draw_frontColor); + _vm->_video->drawLine(spritesArray[destSurface], + destSpriteX, destSpriteY, + spriteRight, spriteBottom, frontColor); - if (draw_destSurface == 21) { - draw_invalidateRect(draw_destSpriteX, draw_destSpriteY, - draw_spriteRight, draw_spriteBottom); + if (destSurface == 21) { + invalidateRect(destSpriteX, destSpriteY, + spriteRight, spriteBottom); } break; case DRAW_INVALIDATE: - if (draw_destSurface == 21) { - draw_invalidateRect(draw_destSpriteX - draw_spriteRight, draw_destSpriteY - draw_spriteBottom, // !! - draw_destSpriteX + draw_spriteRight, - draw_destSpriteY + draw_spriteBottom); + if (destSurface == 21) { + invalidateRect(destSpriteX - spriteRight, destSpriteY - spriteBottom, // !! + destSpriteX + spriteRight, + destSpriteY + spriteBottom); } break; case DRAW_LOADSPRITE: - id = draw_spriteLeft; + id = spriteLeft; if (id >= 30000) { dataBuf = - game_loadExtData(id, &draw_spriteRight, - &draw_spriteBottom); - vid_drawPackedSprite((byte *)dataBuf, draw_spriteRight, - draw_spriteBottom, draw_destSpriteX, - draw_destSpriteY, draw_transparency, - draw_spritesArray[draw_destSurface]); - if (draw_destSurface == 21) { - draw_invalidateRect(draw_destSpriteX, - draw_destSpriteY, - draw_destSpriteX + draw_spriteRight - 1, - draw_destSpriteY + draw_spriteBottom - 1); + _vm->_game->loadExtData(id, &spriteRight, + &spriteBottom); + _vm->_video->drawPackedSprite((byte *)dataBuf, spriteRight, + spriteBottom, destSpriteX, + destSpriteY, transparency, + spritesArray[destSurface]); + if (destSurface == 21) { + invalidateRect(destSpriteX, + destSpriteY, + destSpriteX + spriteRight - 1, + destSpriteY + spriteBottom - 1); } free(dataBuf); break; } // Load from .TOT resources - itemPtr = &game_totResourceTable->items[id]; + itemPtr = &_vm->_game->totResourceTable->items[id]; offset = itemPtr->offset; if (offset >= 0) { dataBuf = - ((char *)game_totResourceTable) + + ((char *)_vm->_game->totResourceTable) + szGame_TotResTable + szGame_TotResItem * - game_totResourceTable->itemsCount + offset; + _vm->_game->totResourceTable->itemsCount + offset; } else { dataBuf = - game_imFileData + - (int32)READ_LE_UINT32(&((int32 *)game_imFileData)[-offset - 1]); + _vm->_game->imFileData + + (int32)READ_LE_UINT32(&((int32 *)_vm->_game->imFileData)[-offset - 1]); } - draw_spriteRight = itemPtr->width; - draw_spriteBottom = itemPtr->height; - vid_drawPackedSprite((byte *)dataBuf, - draw_spriteRight, draw_spriteBottom, - draw_destSpriteX, draw_destSpriteY, - draw_transparency, draw_spritesArray[draw_destSurface]); - - if (draw_destSurface == 21) { - draw_invalidateRect(draw_destSpriteX, draw_destSpriteY, - draw_destSpriteX + draw_spriteRight - 1, - draw_destSpriteY + draw_spriteBottom - 1); + spriteRight = itemPtr->width; + spriteBottom = itemPtr->height; + _vm->_video->drawPackedSprite((byte *)dataBuf, + spriteRight, spriteBottom, + destSpriteX, destSpriteY, + transparency, spritesArray[destSurface]); + + if (destSurface == 21) { + invalidateRect(destSpriteX, destSpriteY, + destSpriteX + spriteRight - 1, + destSpriteY + spriteBottom - 1); } break; case DRAW_PRINTTEXT: - len = strlen(draw_textToPrint); - if (draw_destSurface == 21) { - draw_invalidateRect(draw_destSpriteX, draw_destSpriteY, - draw_destSpriteX + - len * draw_fonts[draw_fontIndex]->itemWidth - 1, - draw_destSpriteY + - draw_fonts[draw_fontIndex]->itemHeight - 1); + len = strlen(textToPrint); + if (destSurface == 21) { + invalidateRect(destSpriteX, destSpriteY, + destSpriteX + + len * fonts[fontIndex]->itemWidth - 1, + destSpriteY + + fonts[fontIndex]->itemHeight - 1); } for (i = 0; i < len; i++) { - vid_drawLetter(draw_textToPrint[i], - draw_destSpriteX, draw_destSpriteY, - draw_fonts[draw_fontIndex], - draw_transparency, - draw_frontColor, draw_backColor, - draw_spritesArray[draw_destSurface]); - - draw_destSpriteX += draw_fonts[draw_fontIndex]->itemWidth; + _vm->_video->drawLetter(textToPrint[i], + destSpriteX, destSpriteY, + fonts[fontIndex], + transparency, + frontColor, backColor, + spritesArray[destSurface]); + + destSpriteX += fonts[fontIndex]->itemWidth; } break; case DRAW_DRAWBAR: - vid_drawLine(draw_spritesArray[draw_destSurface], - draw_destSpriteX, draw_spriteBottom, - draw_spriteRight, draw_spriteBottom, draw_frontColor); + _vm->_video->drawLine(spritesArray[destSurface], + destSpriteX, spriteBottom, + spriteRight, spriteBottom, frontColor); - vid_drawLine(draw_spritesArray[draw_destSurface], - draw_destSpriteX, draw_destSpriteY, - draw_destSpriteX, draw_spriteBottom, draw_frontColor); + _vm->_video->drawLine(spritesArray[destSurface], + destSpriteX, destSpriteY, + destSpriteX, spriteBottom, frontColor); - vid_drawLine(draw_spritesArray[draw_destSurface], - draw_spriteRight, draw_destSpriteY, - draw_spriteRight, draw_spriteBottom, draw_frontColor); + _vm->_video->drawLine(spritesArray[destSurface], + spriteRight, destSpriteY, + spriteRight, spriteBottom, frontColor); - vid_drawLine(draw_spritesArray[draw_destSurface], - draw_destSpriteX, draw_destSpriteY, - draw_spriteRight, draw_destSpriteY, draw_frontColor); + _vm->_video->drawLine(spritesArray[destSurface], + destSpriteX, destSpriteY, + spriteRight, destSpriteY, frontColor); - if (draw_destSurface == 21) { - draw_invalidateRect(draw_destSpriteX, draw_destSpriteY, - draw_spriteRight, draw_spriteBottom); + if (destSurface == 21) { + invalidateRect(destSpriteX, destSpriteY, + spriteRight, spriteBottom); } break; case DRAW_CLEARRECT: - if (draw_backColor < 16) { - vid_fillRect(draw_spritesArray[draw_destSurface], - draw_destSpriteX, draw_destSpriteY, - draw_spriteRight, draw_spriteBottom, - draw_backColor); + if (backColor < 16) { + _vm->_video->fillRect(spritesArray[destSurface], + destSpriteX, destSpriteY, + spriteRight, spriteBottom, + backColor); } - if (draw_destSurface == 21) { - draw_invalidateRect(draw_destSpriteX, draw_destSpriteY, - draw_spriteRight, draw_spriteBottom); + if (destSurface == 21) { + invalidateRect(destSpriteX, destSpriteY, + spriteRight, spriteBottom); } break; case DRAW_FILLRECTABS: - vid_fillRect(draw_spritesArray[draw_destSurface], - draw_destSpriteX, draw_destSpriteY, - draw_spriteRight, draw_spriteBottom, draw_backColor); + _vm->_video->fillRect(spritesArray[destSurface], + destSpriteX, destSpriteY, + spriteRight, spriteBottom, backColor); - if (draw_destSurface == 21) { - draw_invalidateRect(draw_destSpriteX, draw_destSpriteY, - draw_spriteRight, draw_spriteBottom); + if (destSurface == 21) { + invalidateRect(destSpriteX, destSpriteY, + spriteRight, spriteBottom); } break; case DRAW_DRAWLETTER: - if (draw_fontToSprite[draw_fontIndex].sprite == -1) { - if (draw_destSurface == 21) { - draw_invalidateRect(draw_destSpriteX, - draw_destSpriteY, - draw_destSpriteX + - draw_fonts[draw_fontIndex]->itemWidth - 1, - draw_destSpriteY + - draw_fonts[draw_fontIndex]->itemHeight - + if (fontToSprite[fontIndex].sprite == -1) { + if (destSurface == 21) { + invalidateRect(destSpriteX, + destSpriteY, + destSpriteX + + fonts[fontIndex]->itemWidth - 1, + destSpriteY + + fonts[fontIndex]->itemHeight - 1); } - vid_drawLetter(draw_letterToPrint, - draw_destSpriteX, draw_destSpriteY, - draw_fonts[draw_fontIndex], - draw_transparency, - draw_frontColor, draw_backColor, - draw_spritesArray[draw_destSurface]); + _vm->_video->drawLetter(letterToPrint, + destSpriteX, destSpriteY, + fonts[fontIndex], + transparency, + frontColor, backColor, + spritesArray[destSurface]); break; } perLine = - draw_spritesArray[(int16)draw_fontToSprite[draw_fontIndex]. - sprite]->width / draw_fontToSprite[draw_fontIndex].width; - - y = (draw_letterToPrint - - draw_fontToSprite[draw_fontIndex].base) / perLine * - draw_fontToSprite[draw_fontIndex].height; - - x = (draw_letterToPrint - - draw_fontToSprite[draw_fontIndex].base) % perLine * - draw_fontToSprite[draw_fontIndex].width; - - if (draw_destSurface == 21) { - draw_invalidateRect(draw_destSpriteX, draw_destSpriteY, - draw_destSpriteX + - draw_fontToSprite[draw_fontIndex].width, - draw_destSpriteY + - draw_fontToSprite[draw_fontIndex].height); + spritesArray[(int16)fontToSprite[fontIndex]. + sprite]->width / fontToSprite[fontIndex].width; + + y = (letterToPrint - + fontToSprite[fontIndex].base) / perLine * + fontToSprite[fontIndex].height; + + x = (letterToPrint - + fontToSprite[fontIndex].base) % perLine * + fontToSprite[fontIndex].width; + + if (destSurface == 21) { + invalidateRect(destSpriteX, destSpriteY, + destSpriteX + + fontToSprite[fontIndex].width, + destSpriteY + + fontToSprite[fontIndex].height); } - vid_drawSprite(draw_spritesArray[(int16)draw_fontToSprite - [draw_fontIndex].sprite], - draw_spritesArray[draw_destSurface], x, y, - x + draw_fontToSprite[draw_fontIndex].width, - y + draw_fontToSprite[draw_fontIndex].height, - draw_destSpriteX, draw_destSpriteY, draw_transparency); + _vm->_video->drawSprite(spritesArray[(int16)fontToSprite + [fontIndex].sprite], + spritesArray[destSurface], x, y, + x + fontToSprite[fontIndex].width, + y + fontToSprite[fontIndex].height, + destSpriteX, destSpriteY, transparency); break; } - if (draw_renderFlags & RENDERFLAG_USEDELTAS) { - if (draw_sourceSurface == 21) { - draw_spriteLeft -= draw_backDeltaX; - draw_spriteTop -= draw_backDeltaY; + if (renderFlags & RENDERFLAG_USEDELTAS) { + if (sourceSurface == 21) { + spriteLeft -= backDeltaX; + spriteTop -= backDeltaY; } - if (draw_destSurface == 21) { - draw_destSpriteX -= draw_backDeltaX; - draw_destSpriteY -= draw_backDeltaY; + if (destSurface == 21) { + destSpriteX -= backDeltaX; + destSpriteY -= backDeltaY; } } } -void draw_animateCursor(int16 cursor) { +void Draw::animateCursor(int16 cursor) { int16 newX = 0; int16 newY = 0; - Game_Collision *ptr; + Game::Collision *ptr; int16 minX; int16 minY; int16 maxX; @@ -570,20 +599,20 @@ void draw_animateCursor(int16 cursor) { if (cursorIndex == -1) { cursorIndex = 0; - for (ptr = game_collisionAreas; ptr->left != -1; ptr++) { + for (ptr = _vm->_game->collisionAreas; ptr->left != -1; ptr++) { if (ptr->flags & 0xfff0) continue; - if (ptr->left > inter_mouseX) + if (ptr->left > _vm->_global->inter_mouseX) continue; - if (ptr->right < inter_mouseX) + if (ptr->right < _vm->_global->inter_mouseX) continue; - if (ptr->top > inter_mouseY) + if (ptr->top > _vm->_global->inter_mouseY) continue; - if (ptr->bottom < inter_mouseY) + if (ptr->bottom < _vm->_global->inter_mouseY) continue; if ((ptr->flags & 0xf) < 3) @@ -592,161 +621,161 @@ void draw_animateCursor(int16 cursor) { cursorIndex = 3; break; } - if (draw_cursorAnimLow[cursorIndex] == -1) + if (cursorAnimLow[cursorIndex] == -1) cursorIndex = 1; } - if (draw_cursorAnimLow[cursorIndex] != -1) { - if (cursorIndex == draw_cursorIndex) { - if (draw_cursorAnimDelays[draw_cursorIndex] != 0 && - draw_cursorAnimDelays[draw_cursorIndex] * 10 + - draw_cursorTimeKey <= util_getTimeKey()) { - draw_cursorAnim++; - draw_cursorTimeKey = util_getTimeKey(); + if (cursorAnimLow[cursorIndex] != -1) { + if (cursorIndex == gcursorIndex) { + if (cursorAnimDelays[gcursorIndex] != 0 && + cursorAnimDelays[gcursorIndex] * 10 + + cursorTimeKey <= _vm->_util->getTimeKey()) { + cursorAnim++; + cursorTimeKey = _vm->_util->getTimeKey(); } else { -/* if (draw_noInvalidated && - inter_mouseX == draw_cursorX && inter_mouseY == draw_cursorY) +/* if (noInvalidated && + inter_mouseX == cursorX && inter_mouseY == cursorY) return;*/ } } else { - draw_cursorIndex = cursorIndex; - if (draw_cursorAnimDelays[draw_cursorIndex] != 0) { - draw_cursorAnim = - draw_cursorAnimLow[draw_cursorIndex]; - draw_cursorTimeKey = util_getTimeKey(); + gcursorIndex = cursorIndex; + if (cursorAnimDelays[gcursorIndex] != 0) { + cursorAnim = + cursorAnimLow[gcursorIndex]; + cursorTimeKey = _vm->_util->getTimeKey(); } else { - draw_cursorAnim = draw_cursorIndex; + cursorAnim = gcursorIndex; } } - if (draw_cursorAnimDelays[draw_cursorIndex] != 0 && - (draw_cursorAnimHigh[draw_cursorIndex] < draw_cursorAnim || - draw_cursorAnimLow[draw_cursorIndex] > - draw_cursorAnim)) { - draw_cursorAnim = draw_cursorAnimLow[draw_cursorIndex]; + if (cursorAnimDelays[gcursorIndex] != 0 && + (cursorAnimHigh[gcursorIndex] < cursorAnim || + cursorAnimLow[gcursorIndex] > + cursorAnim)) { + cursorAnim = cursorAnimLow[gcursorIndex]; } - newX = inter_mouseX; - newY = inter_mouseY; - if (draw_cursorXDeltaVar != -1) { - newX -= (uint16)VAR_OFFSET(draw_cursorIndex * 4 + (draw_cursorXDeltaVar / 4) * 4); - newY -= (uint16)VAR_OFFSET(draw_cursorIndex * 4 + (draw_cursorYDeltaVar / 4) * 4); + newX = _vm->_global->inter_mouseX; + newY = _vm->_global->inter_mouseY; + if (cursorXDeltaVar != -1) { + newX -= (uint16)VAR_OFFSET(gcursorIndex * 4 + (cursorXDeltaVar / 4) * 4); + newY -= (uint16)VAR_OFFSET(gcursorIndex * 4 + (cursorYDeltaVar / 4) * 4); } - minX = MIN(newX, draw_cursorX); - minY = MIN(newY, draw_cursorY); - maxX = MAX(draw_cursorX, newX) + draw_cursorWidth - 1; - maxY = MAX(draw_cursorY, newY) + draw_cursorHeight - 1; - vid_drawSprite(draw_backSurface, draw_cursorBack, - newX, newY, newX + draw_cursorWidth - 1, - newY + draw_cursorHeight - 1, 0, 0, 0); - - vid_drawSprite(draw_cursorSprites, draw_backSurface, - draw_cursorWidth * draw_cursorAnim, 0, - draw_cursorWidth * (draw_cursorAnim + 1) - 1, - draw_cursorHeight - 1, newX, newY, draw_transparentCursor); - - if (draw_noInvalidated == 0) { - cursorIndex = draw_cursorIndex; - draw_cursorIndex = -1; - draw_blitInvalidated(); - draw_cursorIndex = cursorIndex; + minX = MIN(newX, cursorX); + minY = MIN(newY, cursorY); + maxX = MAX(cursorX, newX) + cursorWidth - 1; + maxY = MAX(cursorY, newY) + cursorHeight - 1; + _vm->_video->drawSprite(backSurface, cursorBack, + newX, newY, newX + cursorWidth - 1, + newY + cursorHeight - 1, 0, 0, 0); + + _vm->_video->drawSprite(cursorSprites, backSurface, + cursorWidth * cursorAnim, 0, + cursorWidth * (cursorAnim + 1) - 1, + cursorHeight - 1, newX, newY, transparentCursor); + + if (noInvalidated == 0) { + cursorIndex = gcursorIndex; + gcursorIndex = -1; + blitInvalidated(); + gcursorIndex = cursorIndex; } else { - vid_waitRetrace(videoMode); + _vm->_video->waitRetrace(_vm->_global->videoMode); } - vid_drawSprite(draw_backSurface, draw_frontSurface, + _vm->_video->drawSprite(backSurface, frontSurface, minX, minY, maxX, maxY, minX, minY, 0); - vid_drawSprite(draw_cursorBack, draw_backSurface, - 0, 0, draw_cursorWidth - 1, draw_cursorHeight - 1, + _vm->_video->drawSprite(cursorBack, backSurface, + 0, 0, cursorWidth - 1, cursorHeight - 1, newX, newY, 0); } else { - draw_blitCursor(); + blitCursor(); } - draw_cursorX = newX; - draw_cursorY = newY; + cursorX = newX; + cursorY = newY; } -void draw_interPalLoad(void) { +void Draw::interPalLoad(void) { int16 i; int16 ind1; int16 ind2; byte cmd; char *palPtr; - cmd = *inter_execPtr++; - draw_applyPal = 0; + cmd = *_vm->_global->inter_execPtr++; + applyPal = 0; if (cmd & 0x80) cmd &= 0x7f; else - draw_applyPal = 1; + applyPal = 1; if (cmd == 49) { warning("inter_palLoad: cmd == 49 is not supported"); //var_B = 1; - for (i = 0; i < 18; i++, inter_execPtr++) { + for (i = 0; i < 18; i++, _vm->_global->inter_execPtr++) { if (i < 2) { - if (draw_applyPal == 0) + if (applyPal == 0) continue; - draw_unusedPalette1[i] = *inter_execPtr; + unusedPalette1[i] = *_vm->_global->inter_execPtr; continue; } //if (*inter_execPtr != 0) // var_B = 0; - ind1 = *inter_execPtr >> 4; - ind2 = (*inter_execPtr & 0xf); + ind1 = *_vm->_global->inter_execPtr >> 4; + ind2 = (*_vm->_global->inter_execPtr & 0xf); - draw_unusedPalette1[i] = - ((draw_palLoadData1[ind1] + draw_palLoadData2[ind2]) << 8) + - (draw_palLoadData2[ind1] + draw_palLoadData1[ind2]); + unusedPalette1[i] = + ((palLoadData1[ind1] + palLoadData2[ind2]) << 8) + + (palLoadData2[ind1] + palLoadData1[ind2]); } - pPaletteDesc->unused1 = draw_unusedPalette1; + _vm->_global->pPaletteDesc->unused1 = unusedPalette1; } switch (cmd) { case 52: - for (i = 0; i < 16; i++, inter_execPtr += 3) { - draw_vgaSmallPalette[i].red = inter_execPtr[0]; - draw_vgaSmallPalette[i].green = inter_execPtr[1]; - draw_vgaSmallPalette[i].blue = inter_execPtr[2]; + for (i = 0; i < 16; i++, _vm->_global->inter_execPtr += 3) { + vgaSmallPalette[i].red = _vm->_global->inter_execPtr[0]; + vgaSmallPalette[i].green = _vm->_global->inter_execPtr[1]; + vgaSmallPalette[i].blue = _vm->_global->inter_execPtr[2]; } break; case 50: - for (i = 0; i < 16; i++, inter_execPtr++) - draw_unusedPalette2[i] = *inter_execPtr; + for (i = 0; i < 16; i++, _vm->_global->inter_execPtr++) + unusedPalette2[i] = *_vm->_global->inter_execPtr; break; case 53: - palPtr = game_loadTotResource(inter_load16()); - memcpy((char *)draw_vgaPalette, palPtr, 768); + palPtr = _vm->_game->loadTotResource(_vm->_inter->load16()); + memcpy((char *)vgaPalette, palPtr, 768); break; case 54: - memset((char *)draw_vgaPalette, 0, 768); + memset((char *)vgaPalette, 0, 768); break; } - if (!draw_applyPal) { - pPaletteDesc->unused2 = draw_unusedPalette2; - pPaletteDesc->unused1 = draw_unusedPalette1; + if (!applyPal) { + _vm->_global->pPaletteDesc->unused2 = unusedPalette2; + _vm->_global->pPaletteDesc->unused1 = unusedPalette1; - if (videoMode != 0x13) - pPaletteDesc->vgaPal = (Color *)draw_vgaSmallPalette; + if (_vm->_global->videoMode != 0x13) + _vm->_global->pPaletteDesc->vgaPal = (Video::Color *)vgaSmallPalette; else - pPaletteDesc->vgaPal = (Color *)draw_vgaPalette; + _vm->_global->pPaletteDesc->vgaPal = (Video::Color *)vgaPalette; - pal_fade((PalDesc *) pPaletteDesc, 0, 0); + _vm->_palanim->fade((Video::PalDesc *) _vm->_global->pPaletteDesc, 0, 0); } } -void draw_printText(void) { +void Draw::printText(void) { int16 savedFlags; - int16 destSpriteX; + int16 ldestSpriteX; char *dataPtr; char *ptr; char *ptr2; @@ -757,59 +786,59 @@ void draw_printText(void) { int16 val; char buf[20]; - index = inter_load16(); + index = _vm->_inter->load16(); - cd_playMultMusic(); + _vm->_cdrom->playMultMusic(); - dataPtr = (char *)game_totTextData + game_totTextData->items[index].offset; + dataPtr = (char *)_vm->_game->totTextData + _vm->_game->totTextData->items[index].offset; ptr = dataPtr; - if (draw_renderFlags & RENDERFLAG_CAPTUREPUSH) { - draw_destSpriteX = READ_LE_UINT16(ptr); - draw_destSpriteY = READ_LE_UINT16(ptr + 2); - draw_spriteRight = READ_LE_UINT16(ptr + 4) - draw_destSpriteX + 1; - draw_spriteBottom = READ_LE_UINT16(ptr + 6) - draw_destSpriteY + 1; - game_capturePush(draw_destSpriteX, draw_destSpriteY, - draw_spriteRight, draw_spriteBottom); - (*scen_pCaptureCounter)++; + if (renderFlags & RENDERFLAG_CAPTUREPUSH) { + destSpriteX = READ_LE_UINT16(ptr); + destSpriteY = READ_LE_UINT16(ptr + 2); + spriteRight = READ_LE_UINT16(ptr + 4) - destSpriteX + 1; + spriteBottom = READ_LE_UINT16(ptr + 6) - destSpriteY + 1; + _vm->_game->capturePush(destSpriteX, destSpriteY, + spriteRight, spriteBottom); + (*_vm->_scenery->pCaptureCounter)++; } - draw_destSpriteX = READ_LE_UINT16(ptr); - destX = draw_destSpriteX; + destSpriteX = READ_LE_UINT16(ptr); + destX = destSpriteX; - draw_destSpriteY = READ_LE_UINT16(ptr + 2); - destY = draw_destSpriteY; + destSpriteY = READ_LE_UINT16(ptr + 2); + destY = destSpriteY; - draw_spriteRight = READ_LE_UINT16(ptr + 4); - draw_spriteBottom = READ_LE_UINT16(ptr + 6); - draw_destSurface = 21; + spriteRight = READ_LE_UINT16(ptr + 4); + spriteBottom = READ_LE_UINT16(ptr + 6); + destSurface = 21; ptr += 8; - draw_backColor = *ptr++; - draw_transparency = 1; - draw_spriteOperation(DRAW_CLEARRECT); + backColor = *ptr++; + transparency = 1; + spriteOperation(DRAW_CLEARRECT); - draw_backColor = 0; - savedFlags = draw_renderFlags; + backColor = 0; + savedFlags = renderFlags; - draw_renderFlags &= ~RENDERFLAG_NOINVALIDATE; - for (; (draw_destSpriteX = READ_LE_UINT16(ptr)) != -1; ptr++) { - draw_destSpriteX += destX; - draw_destSpriteY = READ_LE_UINT16(ptr + 2) + destY; - draw_spriteRight = READ_LE_UINT16(ptr + 4) + destX; - draw_spriteBottom = READ_LE_UINT16(ptr + 6) + destY; + renderFlags &= ~RENDERFLAG_NOINVALIDATE; + for (; (destSpriteX = READ_LE_UINT16(ptr)) != -1; ptr++) { + destSpriteX += destX; + destSpriteY = READ_LE_UINT16(ptr + 2) + destY; + spriteRight = READ_LE_UINT16(ptr + 4) + destX; + spriteBottom = READ_LE_UINT16(ptr + 6) + destY; ptr += 8; cmd = (*ptr & 0xf0) >> 4; if (cmd == 0) { - draw_frontColor = *ptr & 0xf; - draw_spriteOperation(DRAW_DRAWLINE); + frontColor = *ptr & 0xf; + spriteOperation(DRAW_DRAWLINE); } else if (cmd == 1) { - draw_frontColor = *ptr & 0xf; - draw_spriteOperation(DRAW_DRAWBAR); + frontColor = *ptr & 0xf; + spriteOperation(DRAW_DRAWBAR); } else if (cmd == 2) { - draw_backColor = *ptr & 0xf; - draw_spriteOperation(DRAW_FILLRECTABS); + backColor = *ptr & 0xf; + spriteOperation(DRAW_FILLRECTABS); } } ptr += 2; @@ -828,23 +857,23 @@ void draw_printText(void) { cmd = *ptr; if (cmd == 3) { ptr++; - draw_fontIndex = (*ptr & 0xf0) >> 4; - draw_frontColor = *ptr & 0xf; + fontIndex = (*ptr & 0xf0) >> 4; + frontColor = *ptr & 0xf; ptr++; continue; } else if (cmd == 2) { ptr++; - draw_destSpriteX = destX + READ_LE_UINT16(ptr); - draw_destSpriteY = destY + READ_LE_UINT16(ptr + 2); + destSpriteX = destX + READ_LE_UINT16(ptr); + destSpriteY = destY + READ_LE_UINT16(ptr + 2); ptr += 4; continue; } if ((byte)*ptr != 0xba) { - draw_letterToPrint = *ptr; - draw_spriteOperation(DRAW_DRAWLETTER); - draw_destSpriteX += - draw_fonts[draw_fontIndex]->itemWidth; + letterToPrint = *ptr; + spriteOperation(DRAW_DRAWLETTER); + destSpriteX += + fonts[fontIndex]->itemWidth; ptr++; } else { cmd = ptr2[17] & 0x7f; @@ -854,51 +883,51 @@ void draw_printText(void) { } else if (cmd == 1) { val = READ_LE_UINT16(ptr2 + 18) * 4; - strcpy(buf, inter_variables + val); + strcpy(buf, _vm->_global->inter_variables + val); } else { val = READ_LE_UINT16(ptr2 + 18) * 4; sprintf(buf, "%d", VAR_OFFSET(val)); if (buf[0] == '-') { while (strlen(buf) - 1 < (uint32)ptr2[17]) { - util_insertStr("0", buf, 1); + _vm->_util->insertStr("0", buf, 1); } } else { while (strlen(buf) - 1 < (uint32)ptr2[17]) { - util_insertStr("0", buf, 0); + _vm->_util->insertStr("0", buf, 0); } } - util_insertStr(",", buf, strlen(buf) + 1 - ptr2[17]); + _vm->_util->insertStr(",", buf, strlen(buf) + 1 - ptr2[17]); } - draw_textToPrint = buf; - destSpriteX = draw_destSpriteX; - draw_spriteOperation(DRAW_PRINTTEXT); + textToPrint = buf; + ldestSpriteX = destSpriteX; + spriteOperation(DRAW_PRINTTEXT); if (ptr2[17] & 0x80) { if (ptr[1] == ' ') { - draw_destSpriteX += draw_fonts[draw_fontIndex]->itemWidth; + destSpriteX += fonts[fontIndex]->itemWidth; while (ptr[1] == ' ') ptr++; if (ptr[1] == 2) { - if (READ_LE_UINT16(ptr + 4) == draw_destSpriteY) + if (READ_LE_UINT16(ptr + 4) == destSpriteY) ptr += 5; } - } else if (ptr[1] == 2 && READ_LE_UINT16(ptr + 4) == draw_destSpriteY) { + } else if (ptr[1] == 2 && READ_LE_UINT16(ptr + 4) == destSpriteY) { ptr += 5; - draw_destSpriteX += draw_fonts[draw_fontIndex]->itemWidth; + destSpriteX += fonts[fontIndex]->itemWidth; } } else { - draw_destSpriteX = destSpriteX + draw_fonts[draw_fontIndex]->itemWidth; + destSpriteX = ldestSpriteX + fonts[fontIndex]->itemWidth; } ptr2 += 23; ptr++; } } - draw_renderFlags = savedFlags; - if (draw_renderFlags & 4) { - warning("draw_printText: Input not supported!"); + renderFlags = savedFlags; + if (renderFlags & 4) { + warning("printText: Input not supported!"); // xor ax, ax // loc_436_1391: // xor dx, dx @@ -913,9 +942,9 @@ void draw_printText(void) { // add sp, 0Ch } - if ((draw_renderFlags & RENDERFLAG_CAPTUREPOP) && *scen_pCaptureCounter != 0) { - (*scen_pCaptureCounter)--; - game_capturePop(1); + if ((renderFlags & RENDERFLAG_CAPTUREPOP) && *_vm->_scenery->pCaptureCounter != 0) { + (*_vm->_scenery->pCaptureCounter)--; + _vm->_game->capturePop(1); } } diff --git a/gob/draw.h b/gob/draw.h index 6880881c51..2084aa1bf5 100644 --- a/gob/draw.h +++ b/gob/draw.h @@ -31,81 +31,95 @@ namespace Gob { #define RENDERFLAG_CAPTUREPOP 8 #define RENDERFLAG_USEDELTAS 0x10 -typedef struct Draw_FontToSprite { - int8 sprite; - int8 base; - int8 width; - int8 height; -} Draw_FontToSprite; - -extern int16 draw_fontIndex; -extern int16 draw_spriteLeft; -extern int16 draw_spriteTop; -extern int16 draw_spriteRight; -extern int16 draw_spriteBottom; -extern int16 draw_destSpriteX; -extern int16 draw_destSpriteY; -extern int16 draw_backColor; -extern int16 draw_frontColor; -extern char draw_letterToPrint; -extern Draw_FontToSprite draw_fontToSprite[4]; -extern int16 draw_destSurface; -extern int16 draw_sourceSurface; -extern int16 draw_renderFlags; -extern int16 draw_backDeltaX; -extern int16 draw_backDeltaY; -extern FontDesc *draw_fonts[4]; -extern char *draw_textToPrint; -extern int16 draw_transparency; -extern SurfaceDesc *draw_spritesArray[50]; - -extern int16 draw_invalidatedCount; -extern int16 draw_invalidatedTops[30]; -extern int16 draw_invalidatedLefts[30]; -extern int16 draw_invalidatedRights[30]; -extern int16 draw_invalidatedBottoms[30]; - -extern int8 draw_noInvalidated; -extern int8 draw_doFullFlip; -extern int8 draw_paletteCleared; - -extern int16 draw_cursorIndex; -extern int16 draw_transparentCursor; - -extern SurfaceDesc *draw_backSurface; -extern SurfaceDesc *draw_frontSurface; - -extern int16 draw_unusedPalette1[18]; -extern int16 draw_unusedPalette2[16]; -extern Color draw_vgaPalette[256]; -extern Color draw_vgaSmallPalette[16]; - -extern int16 draw_cursorX; -extern int16 draw_cursorY; -extern int16 draw_cursorWidth; -extern int16 draw_cursorHeight; - -extern int16 draw_cursorXDeltaVar; -extern int16 draw_cursorYDeltaVar; - -extern SurfaceDesc *draw_cursorSprites; -extern SurfaceDesc *draw_cursorBack; -extern int16 draw_cursorAnim; -extern int8 draw_cursorAnimLow[40]; -extern int8 draw_cursorAnimHigh[40]; -extern int8 draw_cursorAnimDelays[40]; -extern int8 draw_applyPal; - -void draw_invalidateRect(int16 left, int16 top, int16 right, int16 bottom); -void draw_blitInvalidated(void); -void draw_setPalette(void); -void draw_clearPalette(void); -void draw_blitCursor(void); - -void draw_spriteOperation(int16 operation); -void draw_animateCursor(int16 cursor); -void draw_interPalLoad(void); -void draw_printText(void); +class Draw { + public: + typedef struct FontToSprite { + int8 sprite; + int8 base; + int8 width; + int8 height; + FontToSprite() : sprite(0), base(0), width(0), height() {} + } FontToSprite; + + int16 fontIndex; + int16 spriteLeft; + int16 spriteTop; + int16 spriteRight; + int16 spriteBottom; + int16 destSpriteX; + int16 destSpriteY; + int16 backColor; + int16 frontColor; + char letterToPrint; + FontToSprite fontToSprite[4]; + int16 destSurface; + int16 sourceSurface; + int16 renderFlags; + int16 backDeltaX; + int16 backDeltaY; + Video::FontDesc *fonts[4]; + char *textToPrint; + int16 transparency; + Video::SurfaceDesc *spritesArray[50]; + + int16 invalidatedCount; + int16 invalidatedTops[30]; + int16 invalidatedLefts[30]; + int16 invalidatedRights[30]; + int16 invalidatedBottoms[30]; + + int8 noInvalidated; +// int8 doFullFlip; // Never used?!? + int8 paletteCleared; + + int16 gcursorIndex; + int16 transparentCursor; + uint32 cursorTimeKey; + + Video::SurfaceDesc *backSurface; + Video::SurfaceDesc *frontSurface; + + int16 unusedPalette1[18]; + int16 unusedPalette2[16]; + Video::Color vgaPalette[256]; + Video::Color vgaSmallPalette[16]; + + int16 cursorX; + int16 cursorY; + int16 cursorWidth; + int16 cursorHeight; + + int16 cursorXDeltaVar; + int16 cursorYDeltaVar; + + Video::SurfaceDesc *cursorSprites; + Video::SurfaceDesc *cursorBack; + int16 cursorAnim; + int8 cursorAnimLow[40]; + int8 cursorAnimHigh[40]; + int8 cursorAnimDelays[40]; + int8 applyPal; + + int16 palLoadData1[4]; + int16 palLoadData2[4]; + + void invalidateRect(int16 left, int16 top, int16 right, int16 bottom); + void blitInvalidated(void); + void setPalette(void); + void clearPalette(void); + void blitCursor(void); + + void spriteOperation(int16 operation); + void animateCursor(int16 cursor); + void interPalLoad(void); + void printText(void); + + Draw(GobEngine *vm); + + protected: + GobEngine *_vm; +}; + // Draw operations #define DRAW_BLITSURF 0 diff --git a/gob/driver_vga.cpp b/gob/driver_vga.cpp index eeaa9a10a6..15444f4bd9 100644 --- a/gob/driver_vga.cpp +++ b/gob/driver_vga.cpp @@ -30,7 +30,7 @@ namespace Gob { -void VGAVideoDriver::drawSprite(SurfaceDesc *source, SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, int16 x, int16 y, int16 transp) { +void VGAVideoDriver::drawSprite(Video::SurfaceDesc *source, Video::SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, int16 x, int16 y, int16 transp) { if (x >= 0 && x < dest->width && y >= 0 && y < dest->height) { int16 width = (right - left) + 1; int16 height = (bottom - top) + 1; @@ -54,7 +54,7 @@ void VGAVideoDriver::drawSprite(SurfaceDesc *source, SurfaceDesc *dest, int16 le } } -void VGAVideoDriver::fillRect(SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, byte color) { +void VGAVideoDriver::fillRect(Video::SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, byte color) { if (left < dest->width && right < dest->width && top < dest->height && bottom < dest->height) { byte *pos = dest->vidPtr + (top * dest->width) + left; int16 width = (right - left) + 1; @@ -69,12 +69,12 @@ void VGAVideoDriver::fillRect(SurfaceDesc *dest, int16 left, int16 top, int16 ri } } -void VGAVideoDriver::putPixel(int16 x, int16 y, byte color, SurfaceDesc *dest) { +void VGAVideoDriver::putPixel(int16 x, int16 y, byte color, Video::SurfaceDesc *dest) { if (x >= 0 && x < dest->width && y >= 0 && y < dest->height) dest->vidPtr[(y * dest->width) + x] = color; } -void VGAVideoDriver::drawLetter(unsigned char item, int16 x, int16 y, FontDesc *fontDesc, byte color1, byte color2, byte transp, SurfaceDesc *dest) { +void VGAVideoDriver::drawLetter(unsigned char item, int16 x, int16 y, Video::FontDesc *fontDesc, byte color1, byte color2, byte transp, Video::SurfaceDesc *dest) { byte *src, *dst; uint16 data; int i, j; @@ -103,16 +103,16 @@ void VGAVideoDriver::drawLetter(unsigned char item, int16 x, int16 y, FontDesc * } static void plotPixel(int x, int y, int color, void *data) { - SurfaceDesc *dest = (SurfaceDesc *)data; + Video::SurfaceDesc *dest = (Video::SurfaceDesc *)data; if (x >= 0 && x < dest->width && y >= 0 && y < dest->height) dest->vidPtr[(y * dest->width) + x] = color; } -void VGAVideoDriver::drawLine(SurfaceDesc *dest, int16 x0, int16 y0, int16 x1, int16 y1, byte color) { +void VGAVideoDriver::drawLine(Video::SurfaceDesc *dest, int16 x0, int16 y0, int16 x1, int16 y1, byte color) { Graphics::drawLine(x0, y0, x1, y1, color, &plotPixel, dest); } -void VGAVideoDriver::drawPackedSprite(byte *sprBuf, int16 width, int16 height, int16 x, int16 y, byte transp, SurfaceDesc *dest) { +void VGAVideoDriver::drawPackedSprite(byte *sprBuf, int16 width, int16 height, int16 x, int16 y, byte transp, Video::SurfaceDesc *dest) { int destRight = x + width; int destBottom = y + height; diff --git a/gob/driver_vga.h b/gob/driver_vga.h index 1aab68e4f6..d146c70224 100644 --- a/gob/driver_vga.h +++ b/gob/driver_vga.h @@ -29,13 +29,13 @@ namespace Gob { class VGAVideoDriver : public VideoDriver { public: VGAVideoDriver() {} - virtual ~VGAVideoDriver() {} - void drawSprite(SurfaceDesc *source, SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, int16 x, int16 y, int16 transp); - void fillRect(SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, byte color); - void putPixel(int16 x, int16 y, byte color, SurfaceDesc *dest); - void drawLetter(unsigned char item, int16 x, int16 y, FontDesc *fontDesc, byte color1, byte color2, byte transp, SurfaceDesc *dest); - void drawLine(SurfaceDesc *dest, int16 x0, int16 y0, int16 x1, int16 y1, byte color); - void drawPackedSprite(byte *sprBuf, int16 width, int16 height, int16 x, int16 y, byte transp, SurfaceDesc *dest); + virtual ~VGAVideoDriver() {} + void drawSprite(Video::SurfaceDesc *source, Video::SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, int16 x, int16 y, int16 transp); + void fillRect(Video::SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, byte color); + void putPixel(int16 x, int16 y, byte color, Video::SurfaceDesc *dest); + void drawLetter(unsigned char item, int16 x, int16 y, Video::FontDesc *fontDesc, byte color1, byte color2, byte transp, Video::SurfaceDesc *dest); + void drawLine(Video::SurfaceDesc *dest, int16 x0, int16 y0, int16 x1, int16 y1, byte color); + void drawPackedSprite(byte *sprBuf, int16 width, int16 height, int16 x, int16 y, byte transp, Video::SurfaceDesc *dest); }; } diff --git a/gob/game.cpp b/gob/game.cpp index 5187cfd6ff..b664a69d92 100644 --- a/gob/game.cpp +++ b/gob/game.cpp @@ -36,57 +36,60 @@ namespace Gob { -Game_ExtTable *game_extTable = 0; - -char *game_totFileData = 0; -Game_TotTextTable *game_totTextData; -Game_TotResTable *game_totResourceTable = 0; -char *game_imFileData = 0; -int16 game_extHandle = 0; -char game_curExtFile[14]; -char game_curTotFile[14]; -char game_curImaFile[18]; - -Game_Collision *game_collisionAreas = 0; -char game_shouldPushColls = 0; -char game_collStr[256]; - -int16 game_lastCollKey; -int16 game_lastCollAreaIndex; -int16 game_lastCollId; - -char game_handleMouse; -char game_forceHandleMouse; +int16 Game::captureCount = 0; +Common::Rect Game::captureStack[20]; + +Game::Game(GobEngine *vm) : _vm(vm) { + extTable = 0; + totFileData = 0; + totResourceTable = 0; + imFileData = 0; + extHandle = 0; + collisionAreas = 0; + shouldPushColls = 0; + totTextData = 0; + + // Collisions stack + collStackSize = 0; + for (int i = 0; i < 3; i++) { + collStack[i] = 0; + collStackElemSizes[i] = 0; + } -char game_tempStr[256]; + for (int i = 0; i < 20; i++) + soundSamples[i] = 0; -int16 game_activeCollResId; -int16 game_activeCollIndex; + curTotFile[0] = 0; + curExtFile[0] = 0; + totToLoad[0] = 0; -// Collisions stack -int16 game_collStackSize = 0; -Game_Collision *game_collStack[3]; -int16 game_collStackElemSizes[3]; + startTimeKey = 0; + mouseButtons = 0; -int16 game_mouseButtons = 0; + lastCollKey = 0; + lastCollAreaIndex = 0; + lastCollId = 0; -// Capture -static Common::Rect game_captureStack[20]; -static int16 game_captureCount = 0; + activeCollResId = 0; + activeCollIndex = 0; + ghandleMouse = 0; + forceHandleMouse = 0; -Snd_SoundDesc *game_soundSamples[20]; + tempStr[0] = 0; + curImaFile[0] = 0; + soundFromExt[0] = 0; + collStr[0] = 0; -char game_soundFromExt[20]; -char game_totToLoad[20]; -int32 game_startTimeKey; + // Capture +} -char *game_loadExtData(int16 itemId, int16 *pResWidth, int16 *pResHeight) { +char *Game::loadExtData(int16 itemId, int16 *pResWidth, int16 *pResHeight) { int16 commonHandle; int16 itemsCount; int32 offset; uint32 size; - Game_ExtItem *item; + ExtItem *item; char isPacked; int16 handle; int32 tableSize; @@ -96,12 +99,12 @@ char *game_loadExtData(int16 itemId, int16 *pResWidth, int16 *pResHeight) { char *dataPtr; itemId -= 30000; - if (game_extTable == 0) + if (extTable == 0) return 0; commonHandle = -1; - itemsCount = game_extTable->itemsCount; - item = &game_extTable->items[itemId]; + itemsCount = extTable->itemsCount; + item = &extTable->items[itemId]; tableSize = szGame_ExtTable + szGame_ExtItem * itemsCount; offset = item->offset; @@ -114,29 +117,29 @@ char *game_loadExtData(int16 itemId, int16 *pResWidth, int16 *pResHeight) { if (pResWidth != 0) { *pResWidth = item->width & 0x7fff; *pResHeight = item->height; - debug(7, "game_loadExtData(%d, %d, %d)", itemId, *pResWidth, *pResHeight); + debug(7, "loadExtData(%d, %d, %d)", itemId, *pResWidth, *pResHeight); } - debug(7, "game_loadExtData(%d, 0, 0)", itemId); + debug(7, "loadExtData(%d, 0, 0)", itemId); if (item->height == 0) size += (item->width & 0x7fff) << 16; debug(7, "size: %d off: %d", size, offset); if (offset >= 0) { - handle = game_extHandle; + handle = extHandle; } else { offset = -(offset + 1); tableSize = 0; - data_closeData(game_extHandle); + _vm->_dataio->closeData(extHandle); strcpy(path, "commun.ex1"); - path[strlen(path) - 1] = *(game_totFileData + 0x3c) + '0'; - commonHandle = data_openData(path); + path[strlen(path) - 1] = *(totFileData + 0x3c) + '0'; + commonHandle = _vm->_dataio->openData(path); handle = commonHandle; } debug(7, "off: %ld size: %ld", offset, tableSize); - data_seekData(handle, offset + tableSize, SEEK_SET); + _vm->_dataio->seekData(handle, offset + tableSize, SEEK_SET); if (isPacked) dataBuf = (char *)malloc(size); else @@ -145,20 +148,20 @@ char *game_loadExtData(int16 itemId, int16 *pResWidth, int16 *pResHeight) { dataPtr = dataBuf; while (size > 32000) { // BUG: huge->far conversion. Need normalization? - data_readData(handle, (char *)dataPtr, 32000); + _vm->_dataio->readData(handle, (char *)dataPtr, 32000); size -= 32000; dataPtr += 32000; } - data_readData(handle, (char *)dataPtr, size); + _vm->_dataio->readData(handle, (char *)dataPtr, size); if (commonHandle != -1) { - data_closeData(commonHandle); - game_extHandle = data_openData(game_curExtFile); + _vm->_dataio->closeData(commonHandle); + extHandle = _vm->_dataio->openData(curExtFile); } if (isPacked != 0) { packedBuf = dataBuf; dataBuf = (char *)malloc(READ_LE_UINT32(packedBuf)); - unpackData(packedBuf, dataBuf); + _vm->_pack->unpackData(packedBuf, dataBuf); free(packedBuf); } @@ -166,30 +169,30 @@ char *game_loadExtData(int16 itemId, int16 *pResWidth, int16 *pResHeight) { } -void game_clearCollisions() { +void Game::clearCollisions() { int16 i; for (i = 0; i < 250; i++) { - game_collisionAreas[i].id = 0; - game_collisionAreas[i].left = -1; + collisionAreas[i].id = 0; + collisionAreas[i].left = -1; } } -void game_addNewCollision(int16 id, int16 left, int16 top, int16 right, int16 bottom, +void Game::addNewCollision(int16 id, int16 left, int16 top, int16 right, int16 bottom, int16 flags, int16 key, int16 funcEnter, int16 funcLeave) { int16 i; - Game_Collision *ptr; + Collision *ptr; - debug(5, "game_addNewCollision"); + debug(5, "addNewCollision"); debug(5, "id = %x", id); debug(5, "left = %d, top = %d, right = %d, bottom = %d", left, top, right, bottom); debug(5, "flags = %x, key = %x", flags, key); debug(5, "funcEnter = %d, funcLeave = %d", funcEnter, funcLeave); for (i = 0; i < 250; i++) { - if (game_collisionAreas[i].left != -1) + if (collisionAreas[i].left != -1) continue; - ptr = &game_collisionAreas[i]; + ptr = &collisionAreas[i]; ptr->id = id; ptr->left = left; ptr->top = top; @@ -201,63 +204,63 @@ void game_addNewCollision(int16 id, int16 left, int16 top, int16 right, int16 bo ptr->funcLeave = funcLeave; return; } - error("game_addNewCollision: Collision array full!\n"); + error("addNewCollision: Collision array full!\n"); } -void game_freeCollision(int16 id) { +void Game::freeCollision(int16 id) { int16 i; for (i = 0; i < 250; i++) { - if (game_collisionAreas[i].id == id) - game_collisionAreas[i].left = -1; + if (collisionAreas[i].id == id) + collisionAreas[i].left = -1; } } -void game_pushCollisions(char all) { - Game_Collision *srcPtr; - Game_Collision *destPtr; +void Game::pushCollisions(char all) { + Collision *srcPtr; + Collision *destPtr; int16 size; - debug(4, "game_pushCollisions"); - for (size = 0, srcPtr = game_collisionAreas; srcPtr->left != -1; + debug(4, "pushCollisions"); + for (size = 0, srcPtr = collisionAreas; srcPtr->left != -1; srcPtr++) { if (all || (srcPtr->id & 0x8000)) size++; } - destPtr = (Game_Collision *)malloc(size * sizeof(Game_Collision)); - game_collStack[game_collStackSize] = destPtr; - game_collStackElemSizes[game_collStackSize] = size; - game_collStackSize++; + destPtr = (Collision *)malloc(size * sizeof(Collision)); + collStack[collStackSize] = destPtr; + collStackElemSizes[collStackSize] = size; + collStackSize++; - for (srcPtr = game_collisionAreas; srcPtr->left != -1; srcPtr++) { + for (srcPtr = collisionAreas; srcPtr->left != -1; srcPtr++) { if (all || (srcPtr->id & 0x8000)) { - memcpy(destPtr, srcPtr, sizeof(Game_Collision)); + memcpy(destPtr, srcPtr, sizeof(Collision)); srcPtr->left = -1; destPtr++; } } } -void game_popCollisions(void) { - Game_Collision *destPtr; - Game_Collision *srcPtr; +void Game::popCollisions(void) { + Collision *destPtr; + Collision *srcPtr; - debug(4, "game_popCollision"); + debug(4, "popCollision"); - game_collStackSize--; - for (destPtr = game_collisionAreas; destPtr->left != -1; destPtr++); + collStackSize--; + for (destPtr = collisionAreas; destPtr->left != -1; destPtr++); - srcPtr = game_collStack[game_collStackSize]; + srcPtr = collStack[collStackSize]; memcpy(destPtr, srcPtr, - game_collStackElemSizes[game_collStackSize] * - sizeof(Game_Collision)); + collStackElemSizes[collStackSize] * + sizeof(Collision)); - free(game_collStack[game_collStackSize]); + free(collStack[collStackSize]); } -int16 game_checkMousePoint(int16 all, int16 *resId, int16 *resIndex) { - Game_Collision *ptr; +int16 Game::checkMousePoint(int16 all, int16 *resId, int16 *resIndex) { + Collision *ptr; int16 i; if (resId != 0) @@ -265,7 +268,7 @@ int16 game_checkMousePoint(int16 all, int16 *resId, int16 *resIndex) { *resIndex = 0; - ptr = game_collisionAreas; + ptr = collisionAreas; for (i = 0; ptr->left != -1; ptr++, i++) { if (all) { if ((ptr->flags & 0xf) > 1) @@ -274,10 +277,10 @@ int16 game_checkMousePoint(int16 all, int16 *resId, int16 *resIndex) { if ((ptr->flags & 0xff00) != 0) continue; - if (inter_mouseX < ptr->left - || inter_mouseX > ptr->right - || inter_mouseY < ptr->top - || inter_mouseY > ptr->bottom) + if (_vm->_global->inter_mouseX < ptr->left + || _vm->_global->inter_mouseX > ptr->right + || _vm->_global->inter_mouseY < ptr->top + || _vm->_global->inter_mouseY > ptr->bottom) continue; if (resId != 0) @@ -292,14 +295,14 @@ int16 game_checkMousePoint(int16 all, int16 *resId, int16 *resIndex) { if ((ptr->flags & 0xf) != 1 && (ptr->flags & 0xf) != 2) continue; - if ((ptr->flags & 0xf0) >> 4 != game_mouseButtons - 1 + if ((ptr->flags & 0xf0) >> 4 != mouseButtons - 1 && (ptr->flags & 0xf0) >> 4 != 2) continue; - if (inter_mouseX < ptr->left - || inter_mouseX > ptr->right - || inter_mouseY < ptr->top - || inter_mouseY > ptr->bottom) + if (_vm->_global->inter_mouseX < ptr->left + || _vm->_global->inter_mouseX > ptr->right + || _vm->_global->inter_mouseY < ptr->top + || _vm->_global->inter_mouseY > ptr->bottom) continue; if (resId != 0) @@ -309,88 +312,88 @@ int16 game_checkMousePoint(int16 all, int16 *resId, int16 *resIndex) { } } - if (game_mouseButtons != 1 && all == 0) + if (mouseButtons != 1 && all == 0) return 0x11b; return 0; } -void game_capturePush(int16 left, int16 top, int16 width, int16 height) { +void Game::capturePush(int16 left, int16 top, int16 width, int16 height) { int16 right; - if (game_captureCount == 20) - error("game_capturePush: Capture stack overflow!"); + if (captureCount == 20) + error("capturePush: Capture stack overflow!"); - game_captureStack[game_captureCount].left = left; - game_captureStack[game_captureCount].top = top; - game_captureStack[game_captureCount].right = left + width; - game_captureStack[game_captureCount].bottom = top + height; + captureStack[captureCount].left = left; + captureStack[captureCount].top = top; + captureStack[captureCount].right = left + width; + captureStack[captureCount].bottom = top + height; - draw_spriteTop = top; - draw_spriteBottom = height; + _vm->_draw->spriteTop = top; + _vm->_draw->spriteBottom = height; right = left + width - 1; left &= 0xfff0; right |= 0xf; - draw_spritesArray[30 + game_captureCount] = - vid_initSurfDesc(videoMode, right - left + 1, height, 0); + _vm->_draw->spritesArray[30 + captureCount] = + _vm->_video->initSurfDesc(_vm->_global->videoMode, right - left + 1, height, 0); - draw_sourceSurface = 21; - draw_destSurface = 30 + game_captureCount; + _vm->_draw->sourceSurface = 21; + _vm->_draw->destSurface = 30 + captureCount; - draw_spriteLeft = left; - draw_spriteRight = right - left + 1; - draw_destSpriteX = 0; - draw_destSpriteY = 0; - draw_transparency = 0; - draw_spriteOperation(0); - game_captureCount++; + _vm->_draw->spriteLeft = left; + _vm->_draw->spriteRight = right - left + 1; + _vm->_draw->destSpriteX = 0; + _vm->_draw->destSpriteY = 0; + _vm->_draw->transparency = 0; + _vm->_draw->spriteOperation(0); + captureCount++; } -void game_capturePop(char doDraw) { - if (game_captureCount <= 0) +void Game::capturePop(char doDraw) { + if (captureCount <= 0) return; - game_captureCount--; + captureCount--; if (doDraw) { - draw_destSpriteX = game_captureStack[game_captureCount].left; - draw_destSpriteY = game_captureStack[game_captureCount].top; - draw_spriteRight = - game_captureStack[game_captureCount].width(); - draw_spriteBottom = - game_captureStack[game_captureCount].height(); - - draw_transparency = 0; - draw_sourceSurface = 30 + game_captureCount; - draw_destSurface = 21; - draw_spriteLeft = draw_destSpriteX & 0xf; - draw_spriteTop = 0; - draw_spriteOperation(0); + _vm->_draw->destSpriteX = captureStack[captureCount].left; + _vm->_draw->destSpriteY = captureStack[captureCount].top; + _vm->_draw->spriteRight = + captureStack[captureCount].width(); + _vm->_draw->spriteBottom = + captureStack[captureCount].height(); + + _vm->_draw->transparency = 0; + _vm->_draw->sourceSurface = 30 + captureCount; + _vm->_draw->destSurface = 21; + _vm->_draw->spriteLeft = _vm->_draw->destSpriteX & 0xf; + _vm->_draw->spriteTop = 0; + _vm->_draw->spriteOperation(0); } - vid_freeSurfDesc(draw_spritesArray[30 + game_captureCount]); + _vm->_video->freeSurfDesc(_vm->_draw->spritesArray[30 + captureCount]); } -char *game_loadTotResource(int16 id) { - Game_TotResItem *itemPtr; +char *Game::loadTotResource(int16 id) { + TotResItem *itemPtr; int32 offset; - itemPtr = &game_totResourceTable->items[id]; + itemPtr = &totResourceTable->items[id]; offset = itemPtr->offset; if (offset >= 0) { - return ((char *)game_totResourceTable) + szGame_TotResTable + - szGame_TotResItem * game_totResourceTable->itemsCount + offset; + return ((char *)totResourceTable) + szGame_TotResTable + + szGame_TotResItem * totResourceTable->itemsCount + offset; } else { - return (char *)(game_imFileData + (int32)READ_LE_UINT32(&((int32 *)game_imFileData)[-offset - 1])); + return (char *)(imFileData + (int32)READ_LE_UINT32(&((int32 *)imFileData)[-offset - 1])); } } -void game_loadSound(int16 slot, char *dataPtr) { - Snd_SoundDesc *soundDesc; +void Game::loadSound(int16 slot, char *dataPtr) { + Snd::SoundDesc *soundDesc; - soundDesc = (Snd_SoundDesc *)malloc(sizeof(Snd_SoundDesc)); + soundDesc = (Snd::SoundDesc *)malloc(sizeof(Snd::SoundDesc)); - game_soundSamples[slot] = soundDesc; + soundSamples[slot] = soundDesc; soundDesc->frequency = (dataPtr[4] << 8) + dataPtr[5]; soundDesc->size = (dataPtr[1] << 16) + (dataPtr[2] << 8) + dataPtr[3]; @@ -401,77 +404,77 @@ void game_loadSound(int16 slot, char *dataPtr) { soundDesc->flag = 0; } -void game_interLoadSound(int16 slot) { +void Game::interLoadSound(int16 slot) { char *dataPtr; int16 id; if (slot == -1) - slot = parse_parseValExpr(); + slot = _vm->_parse->parseValExpr(); - id = inter_load16(); + id = _vm->_inter->load16(); if (id == -1) { - inter_execPtr += 9; + _vm->_global->inter_execPtr += 9; return; } if (id >= 30000) { - dataPtr = game_loadExtData(id, 0, 0); - game_soundFromExt[slot] = 1; + dataPtr = loadExtData(id, 0, 0); + soundFromExt[slot] = 1; } else { - dataPtr = game_loadTotResource(id); - game_soundFromExt[slot] = 0; + dataPtr = loadTotResource(id); + soundFromExt[slot] = 0; } - game_loadSound(slot, dataPtr); + loadSound(slot, dataPtr); } -void game_freeSoundSlot(int16 slot) { +void Game::freeSoundSlot(int16 slot) { if (slot == -1) - slot = parse_parseValExpr(); + slot = _vm->_parse->parseValExpr(); - if (game_soundSamples[slot] == 0) + if (soundSamples[slot] == 0) return; - if (game_soundFromExt[slot] == 1) { - free(game_soundSamples[slot]->data - 6); - game_soundFromExt[slot] = 0; + if (soundFromExt[slot] == 1) { + free(soundSamples[slot]->data - 6); + soundFromExt[slot] = 0; } - free(game_soundSamples[slot]); - game_soundSamples[slot] = 0; + free(soundSamples[slot]); + soundSamples[slot] = 0; } -int16 game_checkKeys(int16 *pMouseX, int16 *pMouseY, int16 *pButtons, char handleMouse) { - util_processInput(); +int16 Game::checkKeys(int16 *pMouseX, int16 *pMouseY, int16 *pButtons, char handleMouse) { + _vm->_util->processInput(); if (VAR(58) != 0) { - if (mult_frameStart != (int)VAR(58) - 1) - mult_frameStart++; + if (_vm->_mult->frameStart != (int)VAR(58) - 1) + _vm->_mult->frameStart++; else - mult_frameStart = 0; + _vm->_mult->frameStart = 0; - mult_playMult(mult_frameStart + VAR(57), mult_frameStart + VAR(57), 1, + _vm->_mult->playMult(_vm->_mult->frameStart + VAR(57), _vm->_mult->frameStart + VAR(57), 1, handleMouse); } - if (inter_soundEndTimeKey != 0 - && util_getTimeKey() >= inter_soundEndTimeKey) { - snd_stopSound(inter_soundStopVal); - inter_soundEndTimeKey = 0; + if (_vm->_inter->soundEndTimeKey != 0 + && _vm->_util->getTimeKey() >= _vm->_inter->soundEndTimeKey) { + _vm->_snd->stopSound(_vm->_inter->soundStopVal); + _vm->_inter->soundEndTimeKey = 0; } - if (useMouse == 0) - error("game_checkKeys: Can't work without mouse!"); + if (_vm->_global->useMouse == 0) + error("checkKeys: Can't work without mouse!"); - util_getMouseState(pMouseX, pMouseY, pButtons); + _vm->_util->getMouseState(pMouseX, pMouseY, pButtons); if (*pButtons == 3) *pButtons = 0; - return util_checkKey(); + return _vm->_util->checkKey(); } -int16 game_checkCollisions(char handleMouse, int16 deltaTime, int16 *pResId, +int16 Game::checkCollisions(char handleMouse, int16 deltaTime, int16 *pResId, int16 *pResIndex) { char *savedIP; int16 resIndex; @@ -481,9 +484,9 @@ int16 game_checkCollisions(char handleMouse, int16 deltaTime, int16 *pResId, uint32 timeKey; if (deltaTime >= -1) { - game_lastCollKey = 0; - game_lastCollAreaIndex = 0; - game_lastCollId = 0; + lastCollKey = 0; + lastCollAreaIndex = 0; + lastCollId = 0; } if (pResId != 0) @@ -491,48 +494,48 @@ int16 game_checkCollisions(char handleMouse, int16 deltaTime, int16 *pResId, resIndex = 0; - if (draw_cursorIndex == -1 && handleMouse != 0 - && game_lastCollKey == 0) { - game_lastCollKey = - game_checkMousePoint(1, &game_lastCollId, - &game_lastCollAreaIndex); + if (_vm->_draw->gcursorIndex == -1 && handleMouse != 0 + && lastCollKey == 0) { + lastCollKey = + checkMousePoint(1, &lastCollId, + &lastCollAreaIndex); - if (game_lastCollKey != 0 && (game_lastCollId & 0x8000) != 0) { - savedIP = inter_execPtr; - inter_execPtr = (char *)game_totFileData + - game_collisionAreas[game_lastCollAreaIndex].funcEnter; + if (lastCollKey != 0 && (lastCollId & 0x8000) != 0) { + savedIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr = (char *)totFileData + + collisionAreas[lastCollAreaIndex].funcEnter; - inter_funcBlock(0); - inter_execPtr = savedIP; + _vm->_inter->funcBlock(0); + _vm->_global->inter_execPtr = savedIP; } } if (handleMouse != 0) - draw_animateCursor(-1); + _vm->_draw->animateCursor(-1); - timeKey = util_getTimeKey(); + timeKey = _vm->_util->getTimeKey(); while (1) { - if (inter_terminate != 0) { + if (_vm->_inter->terminate != 0) { if (handleMouse) - draw_blitCursor(); + _vm->_draw->blitCursor(); return 0; } - if (draw_noInvalidated == 0) { + if (_vm->_draw->noInvalidated == 0) { if (handleMouse) - draw_animateCursor(-1); + _vm->_draw->animateCursor(-1); else - draw_blitInvalidated(); + _vm->_draw->blitInvalidated(); } - // NOTE: the original asm does the below game_checkKeys call + // NOTE: the original asm does the below checkKeys call // _before_ this check. However, that can cause keypresses to get lost // since there's a return statement in this check. // Additionally, I added a 'deltaTime == -1' check there, since - // when this function is called with deltaTime == -1 in game_inputArea, + // when this function is called with deltaTime == -1 in inputArea, // and the return value is then discarded. if (deltaTime < 0) { - uint32 curtime = util_getTimeKey(); + uint32 curtime = _vm->_util->getTimeKey(); if (deltaTime == -1 || curtime + deltaTime > timeKey) { if (pResId != 0) *pResId = 0; @@ -544,18 +547,18 @@ int16 game_checkCollisions(char handleMouse, int16 deltaTime, int16 *pResId, } } - key = game_checkKeys(&inter_mouseX, &inter_mouseY, - &game_mouseButtons, handleMouse); + key = checkKeys(&_vm->_global->inter_mouseX, &_vm->_global->inter_mouseY, + &mouseButtons, handleMouse); - if (handleMouse == 0 && game_mouseButtons != 0) { - util_waitMouseRelease(0); + if (handleMouse == 0 && mouseButtons != 0) { + _vm->_util->waitMouseRelease(0); key = 3; } if (key != 0) { if (handleMouse == 1) - draw_blitCursor(); + _vm->_draw->blitCursor(); if (pResId != 0) *pResId = 0; @@ -563,118 +566,118 @@ int16 game_checkCollisions(char handleMouse, int16 deltaTime, int16 *pResId, if (pResIndex != 0) *pResIndex = 0; - if (game_lastCollKey != 0 && - game_collisionAreas[game_lastCollAreaIndex].funcLeave != 0) { - savedIP = inter_execPtr; - inter_execPtr = (char *)game_totFileData + - game_collisionAreas[game_lastCollAreaIndex].funcLeave; + if (lastCollKey != 0 && + collisionAreas[lastCollAreaIndex].funcLeave != 0) { + savedIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr = (char *)totFileData + + collisionAreas[lastCollAreaIndex].funcLeave; - inter_funcBlock(0); - inter_execPtr = savedIP; + _vm->_inter->funcBlock(0); + _vm->_global->inter_execPtr = savedIP; } - game_lastCollKey = 0; + lastCollKey = 0; if (key != 0) return key; } if (handleMouse != 0) { - if (game_mouseButtons != 0) { + if (mouseButtons != 0) { oldIndex = 0; - draw_animateCursor(2); + _vm->_draw->animateCursor(2); if (deltaTime <= 0) { if (handleMouse == 1) - util_waitMouseRelease(1); + _vm->_util->waitMouseRelease(1); } else if (deltaTime > 0) { - util_delay(deltaTime); + _vm->_util->delay(deltaTime); } - draw_animateCursor(-1); + _vm->_draw->animateCursor(-1); if (pResId != 0) *pResId = 0; - key = game_checkMousePoint(0, pResId, &resIndex); + key = checkMousePoint(0, pResId, &resIndex); if (pResIndex != 0) *pResIndex = resIndex; if (key != 0 || (pResId != 0 && *pResId != 0)) { if (handleMouse == 1 && (deltaTime <= 0 - || game_mouseButtons == 0)) - draw_blitCursor(); - - if (game_lastCollKey != 0 && - game_collisionAreas[game_lastCollAreaIndex].funcLeave != 0) { - savedIP = inter_execPtr; - inter_execPtr = - (char *)game_totFileData + - game_collisionAreas[game_lastCollAreaIndex].funcLeave; - - inter_funcBlock(0); - inter_execPtr = savedIP; + || mouseButtons == 0)) + _vm->_draw->blitCursor(); + + if (lastCollKey != 0 && + collisionAreas[lastCollAreaIndex].funcLeave != 0) { + savedIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr = + (char *)totFileData + + collisionAreas[lastCollAreaIndex].funcLeave; + + _vm->_inter->funcBlock(0); + _vm->_global->inter_execPtr = savedIP; } - game_lastCollKey = 0; + lastCollKey = 0; return key; } - if (game_lastCollKey != 0 && - game_collisionAreas[game_lastCollAreaIndex].funcLeave != 0) { - savedIP = inter_execPtr; - inter_execPtr = - (char *)game_totFileData + - game_collisionAreas[game_lastCollAreaIndex].funcLeave; + if (lastCollKey != 0 && + collisionAreas[lastCollAreaIndex].funcLeave != 0) { + savedIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr = + (char *)totFileData + + collisionAreas[lastCollAreaIndex].funcLeave; - inter_funcBlock(0); - inter_execPtr = savedIP; + _vm->_inter->funcBlock(0); + _vm->_global->inter_execPtr = savedIP; } - game_lastCollKey = - game_checkMousePoint(1, &game_lastCollId, - &game_lastCollAreaIndex); + lastCollKey = + checkMousePoint(1, &lastCollId, + &lastCollAreaIndex); - if (game_lastCollKey != 0 - && (game_lastCollId & 0x8000) != 0) { - savedIP = inter_execPtr; - inter_execPtr = - (char *)game_totFileData + - game_collisionAreas[game_lastCollAreaIndex].funcEnter; + if (lastCollKey != 0 + && (lastCollId & 0x8000) != 0) { + savedIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr = + (char *)totFileData + + collisionAreas[lastCollAreaIndex].funcEnter; - inter_funcBlock(0); - inter_execPtr = savedIP; + _vm->_inter->funcBlock(0); + _vm->_global->inter_execPtr = savedIP; } } else { if (handleMouse != 0 && - (inter_mouseX != draw_cursorX - || inter_mouseY != draw_cursorY)) { - oldIndex = game_lastCollAreaIndex; - oldId = game_lastCollId; + (_vm->_global->inter_mouseX != _vm->_draw->cursorX + || _vm->_global->inter_mouseY != _vm->_draw->cursorY)) { + oldIndex = lastCollAreaIndex; + oldId = lastCollId; key = - game_checkMousePoint(1, - &game_lastCollId, - &game_lastCollAreaIndex); + checkMousePoint(1, + &lastCollId, + &lastCollAreaIndex); - if (key != game_lastCollKey) { - if (game_lastCollKey != 0 + if (key != lastCollKey) { + if (lastCollKey != 0 && (oldId & 0x8000) != 0) { - savedIP = inter_execPtr; - inter_execPtr = (char *)game_totFileData + - game_collisionAreas[oldIndex].funcLeave; + savedIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr = (char *)totFileData + + collisionAreas[oldIndex].funcLeave; - inter_funcBlock(0); - inter_execPtr = savedIP; + _vm->_inter->funcBlock(0); + _vm->_global->inter_execPtr = savedIP; } - game_lastCollKey = key; - if (game_lastCollKey != 0 && (game_lastCollId & 0x8000) != 0) { - savedIP = inter_execPtr; - inter_execPtr = (char *)game_totFileData + - game_collisionAreas[game_lastCollAreaIndex].funcEnter; + lastCollKey = key; + if (lastCollKey != 0 && (lastCollId & 0x8000) != 0) { + savedIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr = (char *)totFileData + + collisionAreas[lastCollAreaIndex].funcEnter; - inter_funcBlock(0); - inter_execPtr = savedIP; + _vm->_inter->funcBlock(0); + _vm->_global->inter_execPtr = savedIP; } } } @@ -682,19 +685,19 @@ int16 game_checkCollisions(char handleMouse, int16 deltaTime, int16 *pResId, } if (handleMouse != 0) - draw_animateCursor(-1); + _vm->_draw->animateCursor(-1); - util_delay(10); + _vm->_util->delay(10); - snd_loopSounds(); + _vm->_snd->loopSounds(); } } -int16 game_inputArea(int16 xPos, int16 yPos, int16 width, int16 height, int16 backColor, +int16 Game::inputArea(int16 xPos, int16 yPos, int16 width, int16 height, int16 backColor, int16 frontColor, char *str, int16 fontIndex, char inpType, int16 *pTotTime) { int16 handleMouse; uint32 editSize; - FontDesc *pFont; + Video::FontDesc *pFont; char curSym; int16 key; const char *str1; @@ -704,116 +707,116 @@ int16 game_inputArea(int16 xPos, int16 yPos, int16 width, int16 height, int16 ba int16 flag; int16 savedKey; - if (game_handleMouse != 0 && - (useMouse != 0 || game_forceHandleMouse != 0)) + if (ghandleMouse != 0 && + (_vm->_global->useMouse != 0 || forceHandleMouse != 0)) handleMouse = 1; else handleMouse = 0; pos = strlen(str); - pFont = draw_fonts[fontIndex]; + pFont = _vm->_draw->fonts[fontIndex]; editSize = width / pFont->itemWidth; while (1) { - strcpy(game_tempStr, str); - strcat(game_tempStr, " "); - if (strlen(game_tempStr) > editSize) - strcpy(game_tempStr, str); - - draw_destSpriteX = xPos; - draw_destSpriteY = yPos; - draw_spriteRight = editSize * pFont->itemWidth; - draw_spriteBottom = height; - - draw_destSurface = 21; - draw_backColor = backColor; - draw_frontColor = frontColor; - draw_textToPrint = game_tempStr; - draw_transparency = 1; - draw_fontIndex = fontIndex; - draw_spriteOperation(DRAW_FILLRECT); - - draw_destSpriteY = yPos + (height - 8) / 2; - - draw_spriteOperation(DRAW_PRINTTEXT); + strcpy(tempStr, str); + strcat(tempStr, " "); + if (strlen(tempStr) > editSize) + strcpy(tempStr, str); + + _vm->_draw->destSpriteX = xPos; + _vm->_draw->destSpriteY = yPos; + _vm->_draw->spriteRight = editSize * pFont->itemWidth; + _vm->_draw->spriteBottom = height; + + _vm->_draw->destSurface = 21; + _vm->_draw->backColor = backColor; + _vm->_draw->frontColor = frontColor; + _vm->_draw->textToPrint = tempStr; + _vm->_draw->transparency = 1; + _vm->_draw->fontIndex = fontIndex; + _vm->_draw->spriteOperation(DRAW_FILLRECT); + + _vm->_draw->destSpriteY = yPos + (height - 8) / 2; + + _vm->_draw->spriteOperation(DRAW_PRINTTEXT); if (pos == editSize) pos--; - curSym = game_tempStr[pos]; + curSym = tempStr[pos]; flag = 1; while (1) { - game_tempStr[0] = curSym; - game_tempStr[1] = 0; + tempStr[0] = curSym; + tempStr[1] = 0; - draw_destSpriteX = xPos + pFont->itemWidth * pos; - draw_destSpriteY = yPos + height - 1; - draw_spriteRight = pFont->itemWidth; - draw_spriteBottom = 1; - draw_destSurface = 21; - draw_backColor = frontColor; - draw_spriteOperation(DRAW_FILLRECT); + _vm->_draw->destSpriteX = xPos + pFont->itemWidth * pos; + _vm->_draw->destSpriteY = yPos + height - 1; + _vm->_draw->spriteRight = pFont->itemWidth; + _vm->_draw->spriteBottom = 1; + _vm->_draw->destSurface = 21; + _vm->_draw->backColor = frontColor; + _vm->_draw->spriteOperation(DRAW_FILLRECT); if (flag != 0) { - key = game_checkCollisions(handleMouse, -1, - &game_activeCollResId, - &game_activeCollIndex); + key = checkCollisions(handleMouse, -1, + &activeCollResId, + &activeCollIndex); } flag = 0; - key = game_checkCollisions(handleMouse, -300, - &game_activeCollResId, &game_activeCollIndex); + key = checkCollisions(handleMouse, -300, + &activeCollResId, &activeCollIndex); if (*pTotTime > 0) { *pTotTime -= 300; if (*pTotTime <= 1) { key = 0; - game_activeCollResId = 0; + activeCollResId = 0; break; } } - game_tempStr[0] = curSym; - game_tempStr[1] = 0; - draw_destSpriteX = xPos + pFont->itemWidth * pos; - draw_destSpriteY = yPos + height - 1; - draw_spriteRight = pFont->itemWidth; - draw_spriteBottom = 1; - draw_destSurface = 21; - draw_backColor = backColor; - draw_frontColor = frontColor; - draw_textToPrint = game_tempStr; - draw_transparency = 1; - draw_spriteOperation(DRAW_FILLRECT); - - draw_destSpriteY = yPos + (height - 8) / 2; - draw_spriteOperation(DRAW_PRINTTEXT); - - if (key != 0 || game_activeCollResId != 0) + tempStr[0] = curSym; + tempStr[1] = 0; + _vm->_draw->destSpriteX = xPos + pFont->itemWidth * pos; + _vm->_draw->destSpriteY = yPos + height - 1; + _vm->_draw->spriteRight = pFont->itemWidth; + _vm->_draw->spriteBottom = 1; + _vm->_draw->destSurface = 21; + _vm->_draw->backColor = backColor; + _vm->_draw->frontColor = frontColor; + _vm->_draw->textToPrint = tempStr; + _vm->_draw->transparency = 1; + _vm->_draw->spriteOperation(DRAW_FILLRECT); + + _vm->_draw->destSpriteY = yPos + (height - 8) / 2; + _vm->_draw->spriteOperation(DRAW_PRINTTEXT); + + if (key != 0 || activeCollResId != 0) break; - key = game_checkCollisions(handleMouse, -300, - &game_activeCollResId, &game_activeCollIndex); + key = checkCollisions(handleMouse, -300, + &activeCollResId, &activeCollIndex); if (*pTotTime > 0) { *pTotTime -= 300; if (*pTotTime <= 1) { key = 0; - game_activeCollResId = 0; + activeCollResId = 0; break; } } - if (key != 0 || game_activeCollResId != 0) + if (key != 0 || activeCollResId != 0) break; - if (inter_terminate != 0) + if (_vm->_inter->terminate != 0) return 0; } - if (key == 0 || game_activeCollResId != 0 - || inter_terminate != 0) + if (key == 0 || activeCollResId != 0 + || _vm->_inter->terminate != 0) return 0; switch (key) { @@ -833,7 +836,7 @@ int16 game_inputArea(int16 xPos, int16 yPos, int16 width, int16 height, int16 ba case 0xe08: // Backspace if (pos > 0) { - util_cutFromStr(str, pos - 1, 1); + _vm->_util->cutFromStr(str, pos - 1, 1); pos--; continue; } @@ -843,7 +846,7 @@ int16 game_inputArea(int16 xPos, int16 yPos, int16 width, int16 height, int16 ba if (pos >= strlen(str)) continue; - util_cutFromStr(str, pos, 1); + _vm->_util->cutFromStr(str, pos, 1); continue; case 0x1c0d: // Enter @@ -862,21 +865,21 @@ int16 game_inputArea(int16 xPos, int16 yPos, int16 width, int16 height, int16 ba return key; case 0x11b: // Escape - if (useMouse != 0) + if (_vm->_global->useMouse != 0) continue; - game_forceHandleMouse = !game_forceHandleMouse; + forceHandleMouse = !forceHandleMouse; - if (game_handleMouse != 0 && - (useMouse != 0 || game_forceHandleMouse != 0)) + if (ghandleMouse != 0 && + (_vm->_global->useMouse != 0 || forceHandleMouse != 0)) handleMouse = 1; else handleMouse = 0; - if (pressedKeys[1] == 0) + if (_vm->_global->pressedKeys[1] == 0) continue; - while (pressedKeys[1] != 0); + while (_vm->_global->pressedKeys[1] != 0); continue; default: @@ -906,17 +909,17 @@ int16 game_inputArea(int16 xPos, int16 yPos, int16 width, int16 height, int16 ba if (key >= ' ' && key <= 0xff) { if (editSize == strlen(str)) - util_cutFromStr(str, strlen(str) - 1, + _vm->_util->cutFromStr(str, strlen(str) - 1, 1); if (key >= 'a' && key <= 'z') key += ('A' - 'a'); pos++; - game_tempStr[0] = key; - game_tempStr[1] = 0; + tempStr[0] = key; + tempStr[1] = 0; - util_insertStr(game_tempStr, str, pos - 1); + _vm->_util->insertStr(tempStr, str, pos - 1); //strupr(str); } @@ -924,8 +927,8 @@ int16 game_inputArea(int16 xPos, int16 yPos, int16 width, int16 height, int16 ba } } -int16 game_multiEdit(int16 time, int16 index, int16 *pCurPos, Game_InputDesc * inpDesc) { - Game_Collision *collArea; +int16 Game::multiEdit(int16 time, int16 index, int16 *pCurPos, InputDesc * inpDesc) { + Collision *collArea; int16 descInd; int16 key; int16 found = -1; @@ -933,7 +936,7 @@ int16 game_multiEdit(int16 time, int16 index, int16 *pCurPos, Game_InputDesc * i descInd = 0; for (i = 0; i < 250; i++) { - collArea = &game_collisionAreas[i]; + collArea = &collisionAreas[i]; if (collArea->left == -1) continue; @@ -947,25 +950,25 @@ int16 game_multiEdit(int16 time, int16 index, int16 *pCurPos, Game_InputDesc * i if ((collArea->flags & 0x0f) > 10) continue; - strcpy(game_tempStr, inter_variables + collArea->key); + strcpy(tempStr, _vm->_global->inter_variables + collArea->key); - draw_destSpriteX = collArea->left; - draw_destSpriteY = collArea->top; - draw_spriteRight = collArea->right - collArea->left + 1; - draw_spriteBottom = collArea->bottom - collArea->top + 1; + _vm->_draw->destSpriteX = collArea->left; + _vm->_draw->destSpriteY = collArea->top; + _vm->_draw->spriteRight = collArea->right - collArea->left + 1; + _vm->_draw->spriteBottom = collArea->bottom - collArea->top + 1; - draw_destSurface = 21; + _vm->_draw->destSurface = 21; - draw_backColor = inpDesc[descInd].backColor; - draw_frontColor = inpDesc[descInd].frontColor; - draw_textToPrint = game_tempStr; - draw_transparency = 1; - draw_fontIndex = inpDesc[descInd].fontIndex; - draw_spriteOperation(DRAW_FILLRECT); - draw_destSpriteY += + _vm->_draw->backColor = inpDesc[descInd].backColor; + _vm->_draw->frontColor = inpDesc[descInd].frontColor; + _vm->_draw->textToPrint = tempStr; + _vm->_draw->transparency = 1; + _vm->_draw->fontIndex = inpDesc[descInd].fontIndex; + _vm->_draw->spriteOperation(DRAW_FILLRECT); + _vm->_draw->destSpriteY += ((collArea->bottom - collArea->top + 1) - 8) / 2; - draw_spriteOperation(DRAW_PRINTTEXT); + _vm->_draw->spriteOperation(DRAW_PRINTTEXT); descInd++; } @@ -977,7 +980,7 @@ int16 game_multiEdit(int16 time, int16 index, int16 *pCurPos, Game_InputDesc * i descInd = 0; for (i = 0; i < 250; i++) { - collArea = &game_collisionAreas[i]; + collArea = &collisionAreas[i]; if (collArea->left == -1) continue; @@ -1001,34 +1004,34 @@ int16 game_multiEdit(int16 time, int16 index, int16 *pCurPos, Game_InputDesc * i assert(found != -1); - collArea = &game_collisionAreas[found]; + collArea = &collisionAreas[found]; - key = game_inputArea(collArea->left, collArea->top, + key = inputArea(collArea->left, collArea->top, collArea->right - collArea->left + 1, collArea->bottom - collArea->top + 1, inpDesc[*pCurPos].backColor, inpDesc[*pCurPos].frontColor, - inter_variables + collArea->key, + _vm->_global->inter_variables + collArea->key, inpDesc[*pCurPos].fontIndex, collArea->flags, &time); - if (inter_terminate != 0) + if (_vm->_inter->terminate != 0) return 0; switch (key) { case 0: - if (game_activeCollResId == 0) + if (activeCollResId == 0) return 0; - if ((game_collisionAreas[game_activeCollIndex]. + if ((collisionAreas[activeCollIndex]. flags & 0x0f) < 3) return 0; - if ((game_collisionAreas[game_activeCollIndex]. + if ((collisionAreas[activeCollIndex]. flags & 0x0f) > 10) return 0; *pCurPos = 0; for (i = 0; i < 250; i++) { - collArea = &game_collisionAreas[i]; + collArea = &collisionAreas[i]; if (collArea->left == -1) continue; @@ -1042,7 +1045,7 @@ int16 game_multiEdit(int16 time, int16 index, int16 *pCurPos, Game_InputDesc * i if ((collArea->flags & 0x0f) > 10) continue; - if (i == game_activeCollIndex) + if (i == activeCollIndex) break; pCurPos[0]++; @@ -1087,15 +1090,15 @@ int16 game_multiEdit(int16 time, int16 index, int16 *pCurPos, Game_InputDesc * i } } -int16 game_adjustKey(int16 key) { +int16 Game::adjustKey(int16 key) { if (key <= 0x60 || key >= 0x7b) return key; return key - 0x20; } -void game_collisionsBlock(void) { - Game_InputDesc descArray[20]; +void Game::collisionsBlock(void) { + InputDesc descArray[20]; int16 array[250]; char count; int16 collResId; @@ -1125,29 +1128,29 @@ void game_collisionsBlock(void) { int16 var_24; int16 var_26; int16 collStackPos; - Game_Collision *collPtr; + Collision *collPtr; int16 timeKey; char *savedIP; - if (game_shouldPushColls) - game_pushCollisions(1); + if (shouldPushColls) + pushCollisions(1); collResId = -1; - inter_execPtr++; - count = *inter_execPtr++; - game_handleMouse = inter_execPtr[0]; - deltaTime = 1000 * (byte)inter_execPtr[1]; - descIndex2 = (byte)inter_execPtr[2]; - stackPos2 = (byte)inter_execPtr[3]; - descIndex = (byte)inter_execPtr[4]; + _vm->_global->inter_execPtr++; + count = *_vm->_global->inter_execPtr++; + ghandleMouse = _vm->_global->inter_execPtr[0]; + deltaTime = 1000 * (byte)_vm->_global->inter_execPtr[1]; + descIndex2 = (byte)_vm->_global->inter_execPtr[2]; + stackPos2 = (byte)_vm->_global->inter_execPtr[3]; + descIndex = (byte)_vm->_global->inter_execPtr[4]; if (stackPos2 != 0 || descIndex != 0) deltaTime /= 100; timeVal = deltaTime; - inter_execPtr += 6; + _vm->_global->inter_execPtr += 6; - startIP = inter_execPtr; + startIP = _vm->_global->inter_execPtr; WRITE_VAR(16, 0); var_22 = 0; index = 0; @@ -1155,31 +1158,31 @@ void game_collisionsBlock(void) { for (curCmd = 0; curCmd < count; curCmd++) { array[curCmd] = 0; - cmd = *inter_execPtr++; + cmd = *_vm->_global->inter_execPtr++; if ((cmd & 0x40) != 0) { cmd -= 0x40; - cmdHigh = (byte)*inter_execPtr; - inter_execPtr++; + cmdHigh = (byte)*_vm->_global->inter_execPtr; + _vm->_global->inter_execPtr++; cmdHigh <<= 8; } else { cmdHigh = 0; } if ((cmd & 0x80) != 0) { - left = parse_parseValExpr(); - top = parse_parseValExpr(); - width = parse_parseValExpr(); - height = parse_parseValExpr(); + left = _vm->_parse->parseValExpr(); + top = _vm->_parse->parseValExpr(); + width = _vm->_parse->parseValExpr(); + height = _vm->_parse->parseValExpr(); } else { - left = inter_load16(); - top = inter_load16(); - width = inter_load16(); - height = inter_load16(); + left = _vm->_inter->load16(); + top = _vm->_inter->load16(); + width = _vm->_inter->load16(); + height = _vm->_inter->load16(); } cmd &= 0x7f; - debug(4, "game_collisionsBlock(%d)", cmd); + debug(4, "collisionsBlock(%d)", cmd); switch (cmd) { case 3: @@ -1191,41 +1194,41 @@ void game_collisionsBlock(void) { case 9: case 10: - util_waitKey(); + _vm->_util->waitKey(); var_22 = 1; - key = parse_parseVarIndex(); - descArray[index].fontIndex = inter_load16(); - descArray[index].backColor = *inter_execPtr++; - descArray[index].frontColor = *inter_execPtr++; + key = _vm->_parse->parseVarIndex(); + descArray[index].fontIndex = _vm->_inter->load16(); + descArray[index].backColor = *_vm->_global->inter_execPtr++; + descArray[index].frontColor = *_vm->_global->inter_execPtr++; if (cmd < 5 || cmd > 8) { descArray[index].ptr = 0; } else { - descArray[index].ptr = inter_execPtr + 2; - inter_execPtr += inter_load16(); + descArray[index].ptr = _vm->_global->inter_execPtr + 2; + _vm->_global->inter_execPtr += _vm->_inter->load16(); } if (left == -1) break; if ((cmd & 1) == 0) { - game_addNewCollision(curCmd + 0x8000, left, + addNewCollision(curCmd + 0x8000, left, top, left + width * - draw_fonts[descArray[index].fontIndex]-> + _vm->_draw->fonts[descArray[index].fontIndex]-> itemWidth - 1, top + height - 1, cmd, key, 0, - inter_execPtr - (char *)game_totFileData); + _vm->_global->inter_execPtr - (char *)totFileData); - inter_execPtr += 2; - inter_execPtr += READ_LE_UINT16(inter_execPtr); + _vm->_global->inter_execPtr += 2; + _vm->_global->inter_execPtr += READ_LE_UINT16(_vm->_global->inter_execPtr); } else { - game_addNewCollision(curCmd + 0x8000, left, + addNewCollision(curCmd + 0x8000, left, top, left + width * - draw_fonts[descArray[index].fontIndex]-> + _vm->_draw->fonts[descArray[index].fontIndex]-> itemWidth - 1, top + height - 1, cmd, key, 0, 0); } @@ -1233,18 +1236,18 @@ void game_collisionsBlock(void) { break; case 21: - key = inter_load16(); - array[curCmd] = inter_load16(); - flags = inter_load16() & 3; + key = _vm->_inter->load16(); + array[curCmd] = _vm->_inter->load16(); + flags = _vm->_inter->load16() & 3; - game_addNewCollision(curCmd + 0x8000, left, top, + addNewCollision(curCmd + 0x8000, left, top, left + width - 1, top + height - 1, (flags << 4) + cmdHigh + 2, key, - inter_execPtr - (char *)game_totFileData, 0); + _vm->_global->inter_execPtr - (char *)totFileData, 0); - inter_execPtr += 2; - inter_execPtr += READ_LE_UINT16(inter_execPtr); + _vm->_global->inter_execPtr += 2; + _vm->_global->inter_execPtr += READ_LE_UINT16(_vm->_global->inter_execPtr); break; case 20: @@ -1252,97 +1255,97 @@ void game_collisionsBlock(void) { // Fall through to case 2 case 2: - key = inter_load16(); - array[curCmd] = inter_load16(); - flags = inter_load16() & 3; + key = _vm->_inter->load16(); + array[curCmd] = _vm->_inter->load16(); + flags = _vm->_inter->load16() & 3; - game_addNewCollision(curCmd + 0x8000, left, top, + addNewCollision(curCmd + 0x8000, left, top, left + width - 1, top + height - 1, (flags << 4) + cmdHigh + 2, key, 0, - inter_execPtr - (char *)game_totFileData); + _vm->_global->inter_execPtr - (char *)totFileData); - inter_execPtr += 2; - inter_execPtr += READ_LE_UINT16(inter_execPtr); + _vm->_global->inter_execPtr += 2; + _vm->_global->inter_execPtr += READ_LE_UINT16(_vm->_global->inter_execPtr); break; case 0: - inter_execPtr += 6; - startIP = inter_execPtr; - inter_execPtr += 2; - inter_execPtr += READ_LE_UINT16(inter_execPtr); + _vm->_global->inter_execPtr += 6; + startIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr += 2; + _vm->_global->inter_execPtr += READ_LE_UINT16(_vm->_global->inter_execPtr); key = curCmd + 0xA000; - game_addNewCollision(curCmd + 0x8000, left, top, + addNewCollision(curCmd + 0x8000, left, top, left + width - 1, top + height - 1, cmd + cmdHigh, key, - startIP - (char *)game_totFileData, - inter_execPtr - (char *)game_totFileData); + startIP - (char *)totFileData, + _vm->_global->inter_execPtr - (char *)totFileData); - inter_execPtr += 2; - inter_execPtr += READ_LE_UINT16(inter_execPtr); + _vm->_global->inter_execPtr += 2; + _vm->_global->inter_execPtr += READ_LE_UINT16(_vm->_global->inter_execPtr); break; case 1: - key = inter_load16(); - array[curCmd] = inter_load16(); - flags = inter_load16() & 3; + key = _vm->_inter->load16(); + array[curCmd] = _vm->_inter->load16(); + flags = _vm->_inter->load16() & 3; - startIP = inter_execPtr; - inter_execPtr += 2; - inter_execPtr += READ_LE_UINT16(inter_execPtr); + startIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr += 2; + _vm->_global->inter_execPtr += READ_LE_UINT16(_vm->_global->inter_execPtr); if (key == 0) key = curCmd + 0xa000; - game_addNewCollision(curCmd + 0x8000, left, top, + addNewCollision(curCmd + 0x8000, left, top, left + width - 1, top + height - 1, (flags << 4) + cmd + cmdHigh, key, - startIP - (char *)game_totFileData, - inter_execPtr - (char *)game_totFileData); + startIP - (char *)totFileData, + _vm->_global->inter_execPtr - (char *)totFileData); - inter_execPtr += 2; - inter_execPtr += READ_LE_UINT16(inter_execPtr); + _vm->_global->inter_execPtr += 2; + _vm->_global->inter_execPtr += READ_LE_UINT16(_vm->_global->inter_execPtr); break; } } - game_forceHandleMouse = 0; - util_waitKey(); + forceHandleMouse = 0; + _vm->_util->waitKey(); do { if (var_22 != 0) { key = - game_multiEdit(deltaTime, index, &curEditIndex, + multiEdit(deltaTime, index, &curEditIndex, descArray); if (key == 0x1c0d) { for (i = 0; i < 250; i++) { - if (game_collisionAreas[i].left == -1) + if (collisionAreas[i].left == -1) continue; - if ((game_collisionAreas[i].id & 0x8000) == 0) + if ((collisionAreas[i].id & 0x8000) == 0) continue; - if ((game_collisionAreas[i].flags & 1) != 0) + if ((collisionAreas[i].flags & 1) != 0) continue; - if ((game_collisionAreas[i].flags & 0x0f) <= 2) + if ((collisionAreas[i].flags & 0x0f) <= 2) continue; - collResId = game_collisionAreas[i].id; - game_activeCollResId = collResId; + collResId = collisionAreas[i].id; + activeCollResId = collResId; collResId &= 0x7fff; - game_activeCollIndex = i; + activeCollIndex = i; break; } break; } } else { key = - game_checkCollisions(game_handleMouse, -deltaTime, - &game_activeCollResId, &game_activeCollIndex); + checkCollisions(ghandleMouse, -deltaTime, + &activeCollResId, &activeCollIndex); } if ((key & 0xff) >= ' ' && (key & 0xff) <= 0xff && @@ -1350,44 +1353,44 @@ void game_collisionsBlock(void) { key = '0' + (((key >> 8) - 1) % 10) + (key & 0xff00); } - if (game_activeCollResId == 0) { + if (activeCollResId == 0) { if (key != 0) { for (i = 0; i < 250; i++) { - if (game_collisionAreas[i].left == -1) + if (collisionAreas[i].left == -1) continue; - if ((game_collisionAreas[i]. + if ((collisionAreas[i]. id & 0x8000) == 0) continue; - if (game_collisionAreas[i].key == key - || game_collisionAreas[i].key == + if (collisionAreas[i].key == key + || collisionAreas[i].key == 0x7fff) { - game_activeCollResId = - game_collisionAreas[i].id; - game_activeCollIndex = i; + activeCollResId = + collisionAreas[i].id; + activeCollIndex = i; break; } } - if (game_activeCollResId == 0) { + if (activeCollResId == 0) { for (i = 0; i < 250; i++) { - if (game_collisionAreas[i].left == -1) + if (collisionAreas[i].left == -1) continue; - if ((game_collisionAreas[i].id & 0x8000) == 0) + if ((collisionAreas[i].id & 0x8000) == 0) continue; - if ((game_collisionAreas[i].key & 0xff00) != 0) + if ((collisionAreas[i].key & 0xff00) != 0) continue; - if (game_collisionAreas[i].key == 0) + if (collisionAreas[i].key == 0) continue; - if (game_adjustKey(key & 0xff) == game_adjustKey(game_collisionAreas[i].key) || game_collisionAreas[i].key == 0x7fff) { - game_activeCollResId = game_collisionAreas[i].id; - game_activeCollIndex = i; + if (adjustKey(key & 0xff) == adjustKey(collisionAreas[i].key) || collisionAreas[i].key == 0x7fff) { + activeCollResId = collisionAreas[i].id; + activeCollIndex = i; break; } } @@ -1397,9 +1400,9 @@ void game_collisionsBlock(void) { if (deltaTime != 0 && VAR(16) == 0) { if (stackPos2 != 0) { collStackPos = 0; - collPtr = game_collisionAreas; + collPtr = collisionAreas; - for (i = 0, collPtr = game_collisionAreas; collPtr->left != -1; i++, collPtr++) { + for (i = 0, collPtr = collisionAreas; collPtr->left != -1; i++, collPtr++) { if ((collPtr->id & 0x8000) == 0) continue; @@ -1407,64 +1410,64 @@ void game_collisionsBlock(void) { if (collStackPos != stackPos2) continue; - game_activeCollResId = collPtr->id; - game_activeCollIndex = i; - WRITE_VAR(2, inter_mouseX); - WRITE_VAR(3, inter_mouseY); - WRITE_VAR(4, game_mouseButtons); - WRITE_VAR(16, array[(uint16)game_activeCollResId & ~0x8000]); + activeCollResId = collPtr->id; + activeCollIndex = i; + WRITE_VAR(2, _vm->_global->inter_mouseX); + WRITE_VAR(3, _vm->_global->inter_mouseY); + WRITE_VAR(4, mouseButtons); + WRITE_VAR(16, array[(uint16)activeCollResId & ~0x8000]); if (collPtr->funcLeave != 0) { - timeKey = util_getTimeKey(); - savedIP = inter_execPtr; - inter_execPtr = (char *)game_totFileData + collPtr->funcLeave; - game_shouldPushColls = 1; - savedCollStackSize = game_collStackSize; - inter_funcBlock(0); + timeKey = _vm->_util->getTimeKey(); + savedIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr = (char *)totFileData + collPtr->funcLeave; + shouldPushColls = 1; + savedCollStackSize = collStackSize; + _vm->_inter->funcBlock(0); - if (savedCollStackSize != game_collStackSize) - game_popCollisions(); + if (savedCollStackSize != collStackSize) + popCollisions(); - game_shouldPushColls = 0; - inter_execPtr = savedIP; - deltaTime = timeVal - (util_getTimeKey() - timeKey); + shouldPushColls = 0; + _vm->_global->inter_execPtr = savedIP; + deltaTime = timeVal - (_vm->_util->getTimeKey() - timeKey); if (deltaTime < 2) deltaTime = 2; } if (VAR(16) == 0) - game_activeCollResId = 0; + activeCollResId = 0; break; } } else { if (descIndex != 0) { counter = 0; for (i = 0; i < 250; i++) { - if (game_collisionAreas[i].left == -1) + if (collisionAreas[i].left == -1) continue; - if ((game_collisionAreas[i].id & 0x8000) == 0) + if ((collisionAreas[i].id & 0x8000) == 0) continue; counter++; if (counter != descIndex) continue; - game_activeCollResId = game_collisionAreas[i].id; - game_activeCollIndex = i; + activeCollResId = collisionAreas[i].id; + activeCollIndex = i; break; } } else { for (i = 0; i < 250; i++) { - if (game_collisionAreas[i].left == -1) + if (collisionAreas[i].left == -1) continue; - if ((game_collisionAreas[i].id & 0x8000) == 0) + if ((collisionAreas[i].id & 0x8000) == 0) continue; - game_activeCollResId = game_collisionAreas[i].id; - game_activeCollIndex = i; + activeCollResId = collisionAreas[i].id; + activeCollIndex = i; break; } } @@ -1473,18 +1476,18 @@ void game_collisionsBlock(void) { if (descIndex2 != 0) { counter = 0; for (i = 0; i < 250; i++) { - if (game_collisionAreas[i].left == -1) + if (collisionAreas[i].left == -1) continue; - if ((game_collisionAreas[i].id & 0x8000) == 0) + if ((collisionAreas[i].id & 0x8000) == 0) continue; counter++; if (counter != descIndex2) continue; - game_activeCollResId = game_collisionAreas[i].id; - game_activeCollIndex = i; + activeCollResId = collisionAreas[i].id; + activeCollIndex = i; break; } } @@ -1492,86 +1495,86 @@ void game_collisionsBlock(void) { } } - if (game_activeCollResId == 0) + if (activeCollResId == 0) continue; - if (game_collisionAreas[game_activeCollIndex].funcLeave != 0) + if (collisionAreas[activeCollIndex].funcLeave != 0) continue; - WRITE_VAR(2, inter_mouseX); - WRITE_VAR(3, inter_mouseY); - WRITE_VAR(4, game_mouseButtons); - WRITE_VAR(16, array[(uint16)game_activeCollResId & ~0x8000]); + WRITE_VAR(2, _vm->_global->inter_mouseX); + WRITE_VAR(3, _vm->_global->inter_mouseY); + WRITE_VAR(4, mouseButtons); + WRITE_VAR(16, array[(uint16)activeCollResId & ~0x8000]); - if (game_collisionAreas[game_activeCollIndex].funcEnter != 0) { - savedIP = inter_execPtr; - inter_execPtr = (char *)game_totFileData + - game_collisionAreas[game_activeCollIndex]. + if (collisionAreas[activeCollIndex].funcEnter != 0) { + savedIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr = (char *)totFileData + + collisionAreas[activeCollIndex]. funcEnter; - game_shouldPushColls = 1; + shouldPushColls = 1; - collStackPos = game_collStackSize; - inter_funcBlock(0); - if (collStackPos != game_collStackSize) - game_popCollisions(); - game_shouldPushColls = 0; - inter_execPtr = savedIP; + collStackPos = collStackSize; + _vm->_inter->funcBlock(0); + if (collStackPos != collStackSize) + popCollisions(); + shouldPushColls = 0; + _vm->_global->inter_execPtr = savedIP; } WRITE_VAR(16, 0); - game_activeCollResId = 0; + activeCollResId = 0; } - while (game_activeCollResId == 0 && inter_terminate == 0); + while (activeCollResId == 0 && _vm->_inter->terminate == 0); - if (((uint16)game_activeCollResId & ~0x8000) == collResId) { + if (((uint16)activeCollResId & ~0x8000) == collResId) { collStackPos = 0; var_24 = 0; var_26 = 1; for (i = 0; i < 250; i++) { - if (game_collisionAreas[i].left == -1) + if (collisionAreas[i].left == -1) continue; - if ((game_collisionAreas[i].id & 0x8000) == 0) + if ((collisionAreas[i].id & 0x8000) == 0) continue; - if ((game_collisionAreas[i].flags & 0x0f) < 3) + if ((collisionAreas[i].flags & 0x0f) < 3) continue; - if ((game_collisionAreas[i].flags & 0x0f) > 10) + if ((collisionAreas[i].flags & 0x0f) > 10) continue; - if ((game_collisionAreas[i].flags & 0x0f) > 8) { - strcpy(game_tempStr, - inter_variables + game_collisionAreas[i].key); + if ((collisionAreas[i].flags & 0x0f) > 8) { + strcpy(tempStr, + _vm->_global->inter_variables + collisionAreas[i].key); while ((pos = - util_strstr(" ", game_tempStr)) != 0) { - util_cutFromStr(game_tempStr, pos - 1, 1); - pos = util_strstr(" ", game_tempStr); + _vm->_util->strstr(" ", tempStr)) != 0) { + _vm->_util->cutFromStr(tempStr, pos - 1, 1); + pos = _vm->_util->strstr(" ", tempStr); } - strcpy(inter_variables + game_collisionAreas[i].key, game_tempStr); + strcpy(_vm->_global->inter_variables + collisionAreas[i].key, tempStr); } - if ((game_collisionAreas[i].flags & 0x0f) >= 5 && - (game_collisionAreas[i].flags & 0x0f) <= 8) { + if ((collisionAreas[i].flags & 0x0f) >= 5 && + (collisionAreas[i].flags & 0x0f) <= 8) { str = descArray[var_24].ptr; - strcpy(game_tempStr, inter_variables + game_collisionAreas[i].key); + strcpy(tempStr, _vm->_global->inter_variables + collisionAreas[i].key); - if ((game_collisionAreas[i].flags & 0x0f) < 7) - util_prepareStr(game_tempStr); + if ((collisionAreas[i].flags & 0x0f) < 7) + _vm->_util->prepareStr(tempStr); pos = 0; do { - strcpy(game_collStr, str); + strcpy(collStr, str); pos += strlen(str) + 1; str += strlen(str) + 1; - if ((game_collisionAreas[i].flags & 0x0f) < 7) - util_prepareStr(game_collStr); + if ((collisionAreas[i].flags & 0x0f) < 7) + _vm->_util->prepareStr(collStr); - if (strcmp(game_tempStr, game_collStr) == 0) { + if (strcmp(tempStr, collStr) == 0) { VAR(17)++; WRITE_VAR(17 + var_26, 1); break; @@ -1592,137 +1595,137 @@ void game_collisionsBlock(void) { } savedIP = 0; - if (inter_terminate == 0) { - savedIP = (char *)game_totFileData + - game_collisionAreas[game_activeCollIndex].funcLeave; + if (_vm->_inter->terminate == 0) { + savedIP = (char *)totFileData + + collisionAreas[activeCollIndex].funcLeave; - WRITE_VAR(2, inter_mouseX); - WRITE_VAR(3, inter_mouseY); - WRITE_VAR(4, game_mouseButtons); + WRITE_VAR(2, _vm->_global->inter_mouseX); + WRITE_VAR(3, _vm->_global->inter_mouseY); + WRITE_VAR(4, mouseButtons); if (VAR(16) == 0) { - WRITE_VAR(16, array[(uint16)game_activeCollResId & ~0x8000]); + WRITE_VAR(16, array[(uint16)activeCollResId & ~0x8000]); } } for (curCmd = 0; curCmd < count; curCmd++) { - game_freeCollision(curCmd + 0x8000); + freeCollision(curCmd + 0x8000); } - inter_execPtr = savedIP; + _vm->_global->inter_execPtr = savedIP; } -void game_prepareStart(void) { +void Game::prepareStart(void) { int16 i; - game_clearCollisions(); + clearCollisions(); - pPaletteDesc->unused2 = draw_unusedPalette2; - pPaletteDesc->unused1 = draw_unusedPalette1; - pPaletteDesc->vgaPal = draw_vgaPalette; + _vm->_global->pPaletteDesc->unused2 = _vm->_draw->unusedPalette2; + _vm->_global->pPaletteDesc->unused1 = _vm->_draw->unusedPalette1; + _vm->_global->pPaletteDesc->vgaPal = _vm->_draw->vgaPalette; - vid_setFullPalette(pPaletteDesc); + _vm->_video->setFullPalette(_vm->_global->pPaletteDesc); - draw_backSurface = vid_initSurfDesc(videoMode, 320, 200, 0); + _vm->_draw->backSurface = _vm->_video->initSurfDesc(_vm->_global->videoMode, 320, 200, 0); - vid_fillRect(draw_backSurface, 0, 0, 319, 199, 1); - draw_frontSurface = pPrimarySurfDesc; - vid_fillRect(draw_frontSurface, 0, 0, 319, 199, 1); + _vm->_video->fillRect(_vm->_draw->backSurface, 0, 0, 319, 199, 1); + _vm->_draw->frontSurface = _vm->_global->pPrimarySurfDesc; + _vm->_video->fillRect(_vm->_draw->frontSurface, 0, 0, 319, 199, 1); - util_setMousePos(152, 92); + _vm->_util->setMousePos(152, 92); - draw_cursorX = 152; - inter_mouseX = 152; + _vm->_draw->cursorX = 152; + _vm->_global->inter_mouseX = 152; - draw_cursorY = 92; - inter_mouseY = 92; - draw_invalidatedCount = 0; - draw_noInvalidated = 1; - draw_applyPal = 0; - draw_paletteCleared = 0; - draw_cursorWidth = 16; - draw_cursorHeight = 16; - draw_transparentCursor = 1; + _vm->_draw->cursorY = 92; + _vm->_global->inter_mouseY = 92; + _vm->_draw->invalidatedCount = 0; + _vm->_draw->noInvalidated = 1; + _vm->_draw->applyPal = 0; + _vm->_draw->paletteCleared = 0; + _vm->_draw->cursorWidth = 16; + _vm->_draw->cursorHeight = 16; + _vm->_draw->transparentCursor = 1; for (i = 0; i < 40; i++) { - draw_cursorAnimLow[i] = -1; - draw_cursorAnimDelays[i] = 0; - draw_cursorAnimHigh[i] = 0; + _vm->_draw->cursorAnimLow[i] = -1; + _vm->_draw->cursorAnimDelays[i] = 0; + _vm->_draw->cursorAnimHigh[i] = 0; } - draw_cursorAnimLow[1] = 0; - draw_cursorSprites = vid_initSurfDesc(videoMode, 32, 16, 2); - draw_cursorBack = vid_initSurfDesc(videoMode, 16, 16, 0); - draw_renderFlags = 0; - draw_backDeltaX = 0; - draw_backDeltaY = 0; + _vm->_draw->cursorAnimLow[1] = 0; + _vm->_draw->cursorSprites = _vm->_video->initSurfDesc(_vm->_global->videoMode, 32, 16, 2); + _vm->_draw->cursorBack = _vm->_video->initSurfDesc(_vm->_global->videoMode, 16, 16, 0); + _vm->_draw->renderFlags = 0; + _vm->_draw->backDeltaX = 0; + _vm->_draw->backDeltaY = 0; - game_startTimeKey = util_getTimeKey(); + startTimeKey = _vm->_util->getTimeKey(); } -void game_loadTotFile(char *path) { +void Game::loadTotFile(char *path) { int16 handle; - handle = data_openData(path); + handle = _vm->_dataio->openData(path); if (handle >= 0) { - data_closeData(handle); - game_totFileData = data_getData(path); + _vm->_dataio->closeData(handle); + totFileData = _vm->_dataio->getData(path); } else { - game_totFileData = 0; + totFileData = 0; } } -void game_loadExtTable(void) { +void Game::loadExtTable(void) { int16 count, i; // Function is correct. [sev] - game_extHandle = data_openData(game_curExtFile); - if (game_extHandle < 0) + extHandle = _vm->_dataio->openData(curExtFile); + if (extHandle < 0) return; - data_readData(game_extHandle, (char *)&count, 2); + _vm->_dataio->readData(extHandle, (char *)&count, 2); count = FROM_LE_16(count); - data_seekData(game_extHandle, 0, 0); - game_extTable = (Game_ExtTable *)malloc(sizeof(Game_ExtTable) - + sizeof(Game_ExtItem) * count); + _vm->_dataio->seekData(extHandle, 0, 0); + extTable = (ExtTable *)malloc(sizeof(ExtTable) + + sizeof(ExtItem) * count); - data_readData(game_extHandle, (char *)&game_extTable->itemsCount, 2); - game_extTable->itemsCount = FROM_LE_16(game_extTable->itemsCount); - data_readData(game_extHandle, (char *)&game_extTable->unknown, 1); + _vm->_dataio->readData(extHandle, (char *)&extTable->itemsCount, 2); + extTable->itemsCount = FROM_LE_16(extTable->itemsCount); + _vm->_dataio->readData(extHandle, (char *)&extTable->unknown, 1); for (i = 0; i < count; i++) { - data_readData(game_extHandle, (char *)&game_extTable->items[i].offset, 4); - game_extTable->items[i].offset = FROM_LE_32(game_extTable->items[i].offset); - data_readData(game_extHandle, (char *)&game_extTable->items[i].size, 2); - game_extTable->items[i].size = FROM_LE_16(game_extTable->items[i].size); - data_readData(game_extHandle, (char *)&game_extTable->items[i].width, 2); - game_extTable->items[i].width = FROM_LE_16(game_extTable->items[i].width); - data_readData(game_extHandle, (char *)&game_extTable->items[i].height, 2); - game_extTable->items[i].height = FROM_LE_16(game_extTable->items[i].height); + _vm->_dataio->readData(extHandle, (char *)&extTable->items[i].offset, 4); + extTable->items[i].offset = FROM_LE_32(extTable->items[i].offset); + _vm->_dataio->readData(extHandle, (char *)&extTable->items[i].size, 2); + extTable->items[i].size = FROM_LE_16(extTable->items[i].size); + _vm->_dataio->readData(extHandle, (char *)&extTable->items[i].width, 2); + extTable->items[i].width = FROM_LE_16(extTable->items[i].width); + _vm->_dataio->readData(extHandle, (char *)&extTable->items[i].height, 2); + extTable->items[i].height = FROM_LE_16(extTable->items[i].height); } } -void game_loadImFile(void) { +void Game::loadImFile(void) { char path[20]; int16 handle; - if (game_totFileData[0x3d] != 0 && game_totFileData[0x3b] == 0) + if (totFileData[0x3d] != 0 && totFileData[0x3b] == 0) return; strcpy(path, "commun.im1"); - if (game_totFileData[0x3b] != 0) - path[strlen(path) - 1] = '0' + game_totFileData[0x3b]; + if (totFileData[0x3b] != 0) + path[strlen(path) - 1] = '0' + totFileData[0x3b]; - handle = data_openData(path); + handle = _vm->_dataio->openData(path); if (handle < 0) return; - data_closeData(handle); - game_imFileData = data_getData(path); + _vm->_dataio->closeData(handle); + imFileData = _vm->_dataio->getData(path); } -void game_playTot(int16 skipPlay) { +void Game::playTot(int16 skipPlay) { char savedTotName[20]; int16 *oldCaptureCounter; int16 *oldBreakFrom; @@ -1738,202 +1741,202 @@ void game_playTot(int16 skipPlay) { char *savedIP; int16 i; - oldNestLevel = inter_nestLevel; - oldBreakFrom = inter_breakFromLevel; - oldCaptureCounter = scen_pCaptureCounter; - savedIP = inter_execPtr; + oldNestLevel = _vm->_inter->nestLevel; + oldBreakFrom = _vm->_inter->breakFromLevel; + oldCaptureCounter = _vm->_scenery->pCaptureCounter; + savedIP = _vm->_global->inter_execPtr; - inter_nestLevel = &nestLevel; - inter_breakFromLevel = &breakFrom; - scen_pCaptureCounter = &captureCounter; - strcpy(savedTotName, game_curTotFile); + _vm->_inter->nestLevel = &nestLevel; + _vm->_inter->breakFromLevel = &breakFrom; + _vm->_scenery->pCaptureCounter = &captureCounter; + strcpy(savedTotName, curTotFile); if (skipPlay == 0) { while (1) { for (i = 0; i < 4; i++) { - draw_fontToSprite[i].sprite = -1; - draw_fontToSprite[i].base = -1; - draw_fontToSprite[i].width = -1; - draw_fontToSprite[i].height = -1; + _vm->_draw->fontToSprite[i].sprite = -1; + _vm->_draw->fontToSprite[i].base = -1; + _vm->_draw->fontToSprite[i].width = -1; + _vm->_draw->fontToSprite[i].height = -1; } - cd_stopPlaying(); - draw_animateCursor(4); - inter_initControlVars(); - mult_initAll(); - mult_zeroMultData(); + _vm->_cdrom->stopPlaying(); + _vm->_draw->animateCursor(4); + _vm->_inter->initControlVars(); + _vm->_mult->initAll(); + _vm->_mult->zeroMultData(); for (i = 0; i < 20; i++) - draw_spritesArray[i] = 0; + _vm->_draw->spritesArray[i] = 0; - draw_spritesArray[20] = draw_frontSurface; - draw_spritesArray[21] = draw_backSurface; - draw_spritesArray[23] = draw_cursorSprites; + _vm->_draw->spritesArray[20] = _vm->_draw->frontSurface; + _vm->_draw->spritesArray[21] = _vm->_draw->backSurface; + _vm->_draw->spritesArray[23] = _vm->_draw->cursorSprites; for (i = 0; i < 20; i++) - game_soundSamples[i] = 0; + soundSamples[i] = 0; - game_totTextData = 0; - game_totResourceTable = 0; - game_imFileData = 0; - game_extTable = 0; - game_extHandle = -1; + totTextData = 0; + totResourceTable = 0; + imFileData = 0; + extTable = 0; + extHandle = -1; needFreeResTable = 1; needTextFree = 1; - game_totToLoad[0] = 0; + totToLoad[0] = 0; - if (game_curTotFile[0] == 0 && game_totFileData == 0) + if (curTotFile[0] == 0 && totFileData == 0) break; - game_loadTotFile(game_curTotFile); - if (game_totFileData == 0) { - draw_blitCursor(); + loadTotFile(curTotFile); + if (totFileData == 0) { + _vm->_draw->blitCursor(); break; } - strcpy(game_curImaFile, game_curTotFile); - strcpy(game_curExtFile, game_curTotFile); + strcpy(curImaFile, curTotFile); + strcpy(curExtFile, curTotFile); - game_curImaFile[strlen(game_curImaFile) - 4] = 0; - strcat(game_curImaFile, ".ima"); + curImaFile[strlen(curImaFile) - 4] = 0; + strcat(curImaFile, ".ima"); - game_curExtFile[strlen(game_curExtFile) - 4] = 0; - strcat(game_curExtFile, ".ext"); + curExtFile[strlen(curExtFile) - 4] = 0; + strcat(curExtFile, ".ext"); - debug(4, "IMA: %s", game_curImaFile); - debug(4, "EXT: %s", game_curExtFile); + debug(4, "IMA: %s", curImaFile); + debug(4, "EXT: %s", curExtFile); - filePtr = (char *)game_totFileData + 0x30; + filePtr = (char *)totFileData + 0x30; if (READ_LE_UINT32(filePtr) != (uint32)-1) { - curPtr = game_totFileData; - game_totTextData = - (Game_TotTextTable *) (curPtr + - READ_LE_UINT32((char *)game_totFileData + 0x30)); + curPtr = totFileData; + totTextData = + (TotTextTable *) (curPtr + + READ_LE_UINT32((char *)totFileData + 0x30)); - game_totTextData->itemsCount = (int16)READ_LE_UINT16(&game_totTextData->itemsCount); + totTextData->itemsCount = (int16)READ_LE_UINT16(&totTextData->itemsCount); - for (i = 0; i < game_totTextData->itemsCount; ++i) { - game_totTextData->items[i].offset = (int16)READ_LE_UINT16(&game_totTextData->items[i].offset); - game_totTextData->items[i].size = (int16)READ_LE_UINT16(&game_totTextData->items[i].size); + for (i = 0; i < totTextData->itemsCount; ++i) { + totTextData->items[i].offset = (int16)READ_LE_UINT16(&totTextData->items[i].offset); + totTextData->items[i].size = (int16)READ_LE_UINT16(&totTextData->items[i].size); } needTextFree = 0; } - filePtr = (char *)game_totFileData + 0x34; + filePtr = (char *)totFileData + 0x34; if (READ_LE_UINT32(filePtr) != (uint32)-1) { - curPtr = game_totFileData; + curPtr = totFileData; - game_totResourceTable = - (Game_TotResTable *)(curPtr + - READ_LE_UINT32((char *)game_totFileData + 0x34)); + totResourceTable = + (TotResTable *)(curPtr + + READ_LE_UINT32((char *)totFileData + 0x34)); - game_totResourceTable->itemsCount = (int16)READ_LE_UINT16(&game_totResourceTable->itemsCount); + totResourceTable->itemsCount = (int16)READ_LE_UINT16(&totResourceTable->itemsCount); - for (i = 0; i < game_totResourceTable->itemsCount; ++i) { - game_totResourceTable->items[i].offset = (int32)READ_LE_UINT32(&game_totResourceTable->items[i].offset); - game_totResourceTable->items[i].size = (int16)READ_LE_UINT16(&game_totResourceTable->items[i].size); - game_totResourceTable->items[i].width = (int16)READ_LE_UINT16(&game_totResourceTable->items[i].width); - game_totResourceTable->items[i].height = (int16)READ_LE_UINT16(&game_totResourceTable->items[i].height); + for (i = 0; i < totResourceTable->itemsCount; ++i) { + totResourceTable->items[i].offset = (int32)READ_LE_UINT32(&totResourceTable->items[i].offset); + totResourceTable->items[i].size = (int16)READ_LE_UINT16(&totResourceTable->items[i].size); + totResourceTable->items[i].width = (int16)READ_LE_UINT16(&totResourceTable->items[i].width); + totResourceTable->items[i].height = (int16)READ_LE_UINT16(&totResourceTable->items[i].height); } needFreeResTable = 0; } - game_loadImFile(); - game_loadExtTable(); + loadImFile(); + loadExtTable(); - inter_animDataSize = READ_LE_UINT16((char *)game_totFileData + 0x38); - if (inter_variables == 0) { - variablesCount = READ_LE_UINT32((char *)game_totFileData + 0x2c); - inter_variables = (char *)malloc(variablesCount * 4); + _vm->_global->inter_animDataSize = READ_LE_UINT16((char *)totFileData + 0x38); + if (_vm->_global->inter_variables == 0) { + variablesCount = READ_LE_UINT32((char *)totFileData + 0x2c); + _vm->_global->inter_variables = (char *)malloc(variablesCount * 4); for (i = 0; i < variablesCount; i++) WRITE_VAR(i, 0); } - inter_execPtr = (char *)game_totFileData; - inter_execPtr += READ_LE_UINT32((char *)game_totFileData + 0x64); + _vm->_global->inter_execPtr = (char *)totFileData; + _vm->_global->inter_execPtr += READ_LE_UINT32((char *)totFileData + 0x64); - inter_renewTimeInVars(); + _vm->_inter->renewTimeInVars(); - WRITE_VAR(13, useMouse); - WRITE_VAR(14, soundFlags); - WRITE_VAR(15, videoMode); - WRITE_VAR(16, language); + WRITE_VAR(13, _vm->_global->useMouse); + WRITE_VAR(14, _vm->_global->soundFlags); + WRITE_VAR(15, _vm->_global->videoMode); + WRITE_VAR(16, _vm->_global->language); - inter_callSub(2); + _vm->_inter->callSub(2); - if (game_totToLoad[0] != 0) - inter_terminate = 0; + if (totToLoad[0] != 0) + _vm->_inter->terminate = 0; - variablesCount = READ_LE_UINT32((char *)game_totFileData + 0x2c); - draw_blitInvalidated(); - free(game_totFileData); - game_totFileData = 0; + variablesCount = READ_LE_UINT32((char *)totFileData + 0x2c); + _vm->_draw->blitInvalidated(); + free(totFileData); + totFileData = 0; if (needTextFree) - free(game_totTextData); - game_totTextData = 0; + free(totTextData); + totTextData = 0; if (needFreeResTable) - free(game_totResourceTable); - game_totResourceTable = 0; + free(totResourceTable); + totResourceTable = 0; - free(game_imFileData); - game_imFileData = 0; + free(imFileData); + imFileData = 0; - free(game_extTable); - game_extTable = 0; + free(extTable); + extTable = 0; - if (game_extHandle >= 0) - data_closeData(game_extHandle); + if (extHandle >= 0) + _vm->_dataio->closeData(extHandle); - game_extHandle = -1; + extHandle = -1; - for (i = 0; i < *scen_pCaptureCounter; i++) - game_capturePop(0); + for (i = 0; i < *_vm->_scenery->pCaptureCounter; i++) + capturePop(0); - mult_checkFreeMult(); - mult_freeAll(); + _vm->_mult->checkFreeMult(); + _vm->_mult->freeAll(); for (i = 0; i < 20; i++) { - if (draw_spritesArray[i] != 0) - vid_freeSurfDesc(draw_spritesArray[i]); - draw_spritesArray[i] = 0; + if (_vm->_draw->spritesArray[i] != 0) + _vm->_video->freeSurfDesc(_vm->_draw->spritesArray[i]); + _vm->_draw->spritesArray[i] = 0; } - snd_stopSound(0); + _vm->_snd->stopSound(0); for (i = 0; i < 20; i++) - game_freeSoundSlot(i); + freeSoundSlot(i); - if (game_totToLoad[0] == 0) + if (totToLoad[0] == 0) break; - strcpy(game_curTotFile, game_totToLoad); + strcpy(curTotFile, totToLoad); } } - strcpy(game_curTotFile, savedTotName); + strcpy(curTotFile, savedTotName); - inter_nestLevel = oldNestLevel; - inter_breakFromLevel = oldBreakFrom; - scen_pCaptureCounter = oldCaptureCounter; - inter_execPtr = savedIP; + _vm->_inter->nestLevel = oldNestLevel; + _vm->_inter->breakFromLevel = oldBreakFrom; + _vm->_scenery->pCaptureCounter = oldCaptureCounter; + _vm->_global->inter_execPtr = savedIP; } -void game_start(void) { - game_collisionAreas = (Game_Collision *)malloc(250 * sizeof(Game_Collision)); - game_prepareStart(); - game_playTot(0); +void Game::start(void) { + collisionAreas = (Collision *)malloc(250 * sizeof(Collision)); + prepareStart(); + playTot(0); - free(game_collisionAreas); + free(collisionAreas); - vid_freeSurfDesc(draw_cursorSprites); - vid_freeSurfDesc(draw_cursorBack); - vid_freeSurfDesc(draw_backSurface); + _vm->_video->freeSurfDesc(_vm->_draw->cursorSprites); + _vm->_video->freeSurfDesc(_vm->_draw->cursorBack); + _vm->_video->freeSurfDesc(_vm->_draw->backSurface); } } // End of namespace Gob diff --git a/gob/game.h b/gob/game.h index 6f98b23da6..bc126463a1 100644 --- a/gob/game.h +++ b/gob/game.h @@ -26,139 +26,162 @@ namespace Gob { -#pragma START_PACK_STRUCTS -#define szGame_ExtItem (4 + 2 + 2 + 2) -typedef struct Game_ExtItem { - int32 offset; // offset from the table end - uint16 size; - int16 width; // width&0x7fff - width, width&0x8000 - pack flag - int16 height; // not zero -} GCC_PACK Game_ExtItem; - -#define szGame_ExtTable (2 + 1) -typedef struct Game_ExtTable { - int16 itemsCount; - byte unknown; - Game_ExtItem items[1]; -} GCC_PACK Game_ExtTable; +class Game { +public: +#pragma START_PACK_STRUCTS #define szGame_TotResItem (4 + 2 + 2 + 2) -typedef struct Game_TotResItem { - int32 offset; // if > 0, then offset from end of resource table. - // If < 0, then -offset-1 is index in .IM file table - int16 size; - int16 width; - int16 height; -} GCC_PACK Game_TotResItem; + typedef struct Collision { + int16 id; + int16 left; + int16 top; + int16 right; + int16 bottom; + int16 flags; + int16 key; + int16 funcEnter; + int16 funcLeave; + } GCC_PACK Collision; + + typedef struct TotResItem { + int32 offset; // if > 0, then offset from end of resource table. + // If < 0, then -offset-1 is index in .IM file table + int16 size; + int16 width; + int16 height; + } GCC_PACK TotResItem; #define szGame_TotResTable (2 + 1) -typedef struct Game_TotResTable { - int16 itemsCount; - byte unknown; - Game_TotResItem items[1]; -} GCC_PACK Game_TotResTable; + typedef struct TotResTable { + int16 itemsCount; + byte unknown; + TotResItem items[1]; + } GCC_PACK TotResTable; + +#define szGame_ExtItem (4 + 2 + 2 + 2) + typedef struct ExtItem { + int32 offset; // offset from the table end + uint16 size; + int16 width; // width&0x7fff - width, width&0x8000 - pack flag + int16 height; // not zero + } GCC_PACK ExtItem; + +#define szGame_ExtTable (2 + 1) + typedef struct ExtTable { + int16 itemsCount; + byte unknown; + ExtItem items[1]; + } GCC_PACK ExtTable; #define szGame_TotTextItem (2 + 2) -typedef struct Game_TotTextItem { - int16 offset; - int16 size; -} GCC_PACK Game_TotTextItem; + typedef struct TotTextItem { + int16 offset; + int16 size; + } GCC_PACK TotTextItem; #define szGame_TotTextTable (2) -typedef struct Game_TotTextTable { - int16 itemsCount; - Game_TotTextItem items[1]; -} GCC_PACK Game_TotTextTable; - -typedef struct Game_Collision { - int16 id; - int16 left; - int16 top; - int16 right; - int16 bottom; - int16 flags; - int16 key; - int16 funcEnter; - int16 funcLeave; -} GCC_PACK Game_Collision; - -typedef struct Game_InputDesc { - int16 fontIndex; - int16 backColor; - int16 frontColor; - char *ptr; -} GCC_PACK Game_InputDesc; + typedef struct TotTextTable { + int16 itemsCount; + TotTextItem items[1]; + } GCC_PACK TotTextTable; + + typedef struct InputDesc { + int16 fontIndex; + int16 backColor; + int16 frontColor; + char *ptr; + } GCC_PACK InputDesc; #pragma END_PACK_STRUCTS -extern Game_Collision *game_collisionAreas; - -extern int16 game_lastCollKey; -extern int16 game_lastCollAreaIndex; -extern int16 game_lastCollId; - -extern int16 game_activeCollResId; -extern int16 game_activeCollIndex; -extern char game_handleMouse; -extern char game_forceHandleMouse; - -extern char game_tempStr[256]; - -extern Game_ExtTable *game_extTable; -extern char *game_totFileData; -extern Game_TotTextTable *game_totTextData; -extern Game_TotResTable *game_totResourceTable; -extern char *game_imFileData; -extern int16 game_extHandle; -extern char game_curExtFile[14]; -extern char game_curTotFile[14]; -extern char game_curImaFile[18]; - -extern int16 game_collStackSize; -extern Game_Collision *game_collStack[3]; -extern int16 game_collStackElemSizes[3]; - -extern int16 game_mouseButtons; - -extern Snd_SoundDesc *game_soundSamples[20]; - -extern char game_soundFromExt[20]; -extern char game_totToLoad[20]; - -extern int32 game_startTimeKey; -extern char game_shouldPushColls; - -// Functions - -char *game_loadExtData(int16 dataId, int16 *pResWidth, int16 *pResHeight); -void game_clearCollisions(void); -void game_addNewCollision(int16 val_0, int16 left, int16 top, int16 right, int16 bottom, - int16 flags, int16 key, int16 val_E, int16 val_10); -void game_freeCollision(int16 id); -char *game_loadTotResource(int16 id); -void game_capturePush(int16 left, int16 top, int16 width, int16 height); - -void game_capturePush(int16 left, int16 top, int16 width, int16 height); -void game_capturePop(char doDraw); - -void game_loadSound(int16 slot, char *dataPtr); -void game_interLoadSound(int16 slot); -void game_freeSoundSlot(int16 slot); -int16 game_checkKeys(int16 *pMousex, int16 *pMouseY, int16 *pButtons, - char handleMouse); -int16 game_checkCollisions(char handleMouse, int16 deltaTime, int16 *pResId, - int16 *pResIndex); -int16 game_inputArea(int16 xPos, int16 yPos, int16 width, int16 height, int16 backColor, - int16 frontColor, char *str, int16 fontIndex, char inpType, int16 *pTotTime); -int16 game_multiEdit(int16 time, int16 index, int16 *pCurPos, - Game_InputDesc * inpDesc); -int16 game_adjustKey(int16 key); -void game_collisionsBlock(void); -void game_prepareStart(void); -void game_loadTotFile(char *path); -void game_loadExtTable(void); -void game_loadImFile(void); -void game_playTot(int16 skipPlay); -void game_start(void); + TotResTable *totResourceTable; + Collision *collisionAreas; + Collision *collStack[3]; + + TotTextTable *totTextData; + + char curTotFile[14]; + char curExtFile[14]; + + char *imFileData; + char *totFileData; + + int16 extHandle; + + Snd::SoundDesc *soundSamples[20]; + + char totToLoad[20]; + + int32 startTimeKey; + int16 mouseButtons; + + Game(GobEngine *vm); + + char *loadExtData(int16 dataId, int16 *pResWidth, int16 *pResHeight); + char *loadTotResource(int16 id); + + void capturePush(int16 left, int16 top, int16 width, int16 height); + + void capturePop(char doDraw); + void interLoadSound(int16 slot); + void freeSoundSlot(int16 slot); + int16 checkKeys(int16 *pMousex, int16 *pMouseY, int16 *pButtons, + char handleMouse); + int16 checkCollisions(char handleMouse, int16 deltaTime, int16 *pResId, + int16 *pResIndex); + void clearCollisions(void); + void addNewCollision(int16 val_0, int16 left, int16 top, int16 right, int16 bottom, + int16 flags, int16 key, int16 val_E, int16 val_10); + void freeCollision(int16 id); + + void loadSound(int16 slot, char *dataPtr); + int16 inputArea(int16 xPos, int16 yPos, int16 width, int16 height, int16 backColor, + int16 frontColor, char *str, int16 fontIndex, char inpType, int16 *pTotTime); + int16 multiEdit(int16 time, int16 index, int16 *pCurPos, + InputDesc * inpDesc); + int16 adjustKey(int16 key); + void collisionsBlock(void); + void prepareStart(void); + void loadTotFile(char *path); + void loadExtTable(void); + void loadImFile(void); + void playTot(int16 skipPlay); + void start(void); + +protected: + + int16 lastCollKey; + int16 lastCollAreaIndex; + int16 lastCollId; + + int16 activeCollResId; + int16 activeCollIndex; + char ghandleMouse; + char forceHandleMouse; + + char tempStr[256]; + + ExtTable *extTable; + char curImaFile[18]; + + int16 collStackSize; + int16 collStackElemSizes[3]; + + char soundFromExt[20]; + + char shouldPushColls; + + // Capture + static Common::Rect captureStack[20]; + static int16 captureCount; + + char collStr[256]; + + GobEngine *_vm; + + void pushCollisions(char all); + void popCollisions(void); + int16 checkMousePoint(int16 all, int16 *resId, int16 *resIndex); +}; } // End of namespace Gob diff --git a/gob/global.cpp b/gob/global.cpp index aab918e17a..13bfa2fe92 100644 --- a/gob/global.cpp +++ b/gob/global.cpp @@ -24,135 +24,130 @@ namespace Gob { -char pressedKeys[128]; - -char useMouse = UNDEF; -int16 mousePresent = UNDEF; - -int16 presentCGA = UNDEF; -int16 presentEGA = UNDEF; -int16 presentVGA = UNDEF; -int16 presentHER = UNDEF; - -int16 videoMode = 0; - -int16 disableVideoCfg; - -/* Sound */ -uint16 presentSound = 0x8000; /* undefined values */ -uint16 soundFlags = 0x8000; -int16 blasterPort = 0; -int16 disableSoundCfg = 0; - -//char playingSound = 0; - -/* Mouse */ -int16 disableMouseCfg = 0; - -int16 mouseXShift = 3; -int16 mouseYShift = 3; - -int16 mouseMaxCol = 320; -int16 mouseMaxRow = 200; - -/* Language */ -uint16 disableLangCfg = 0x8000; -uint16 language = 0x8000; - -/* Timer variables */ -int32 startTime = 0; -int16 timer_delta = 1000; - -int16 frameWaitTime = 0; -int32 startFrameTime = 0; - -/* Timer and delays */ -int16 delayTime = 0; - -/* Joystick */ -char useJoystick = 1; - -/* Files */ -Common::File filesHandles[MAX_FILES]; - -/* Data files */ -struct ChunkDesc *dataFiles[MAX_DATA_FILES]; -int16 numDataChunks[MAX_DATA_FILES]; -int16 dataFileHandles[MAX_DATA_FILES]; -int32 chunkPos[MAX_SLOT_COUNT * MAX_DATA_FILES]; -int32 chunkOffset[MAX_SLOT_COUNT * MAX_DATA_FILES]; -int32 chunkSize[MAX_SLOT_COUNT * MAX_DATA_FILES]; -char isCurrentSlot[MAX_SLOT_COUNT * MAX_DATA_FILES]; -int32 packedSize = 0; - -int16 sprAllocated = 0; - -SurfaceDesc primarySurfDesc; -SurfaceDesc *pPrimarySurfDesc; - -int16 primaryWidth; -int16 primaryHeight; - -int16 doRangeClamp = 0; - -char redPalette[256]; -char greenPalette[256]; -char bluePalette[256]; - -int16 setAllPalette = 0; - -int16 oldMode = 3; -char dontSetPalette = 0; -SurfaceDesc *curPrimaryDesc = 0; -SurfaceDesc *allocatedPrimary = 0; - -PalDesc *pPaletteDesc = 0; - -int16 unusedPalette1[18] = { - 0, 0x0b, 0, (int16)0x5555, (int16)0xAAAA, (int16)0xFFFF, 0, (int16)0x5555, - (int16)0xAAAA, (int16)0xFFFF, 0, (int16)0x5555, - (int16)0xAAAA, (int16)0xFFFF, 0, (int16)0x5555, (int16)0xAAAA, (int16)0xFFFF -}; - -int16 unusedPalette2[] = { - 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 -}; - -Color vgaPalette[16] = { - {0x00, 0x00, 0x00}, - {0x00, 0x00, 0x2a}, - {0x00, 0x2a, 0x00}, - {0x00, 0x2a, 0x2a}, - {0x2a, 0x00, 0x00}, - {0x2a, 0x00, 0x2a}, - {0x2a, 0x15, 0x00}, - {0x2a, 0x2a, 0x2a}, - {0x15, 0x15, 0x15}, - {0x15, 0x15, 0x3f}, - {0x15, 0x3f, 0x15}, - {0x15, 0x3f, 0x3f}, - {0x3f, 0x15, 0x15}, - {0x3f, 0x15, 0x3f}, - {0x3f, 0x3f, 0x15}, - {0x3f, 0x3f, 0x3f} -}; - -PalDesc paletteStruct; - -int16 debugFlag = 0; -int16 inVM = 0; -int16 colorCount = 16; - -char inter_resStr[200]; -int32 inter_resVal = 0; - -char *inter_variables = 0; -char *inter_execPtr = 0; -int16 inter_animDataSize = 10; - -int16 inter_mouseX = 0; -int16 inter_mouseY = 0; - -char *tmpPalBuffer = 0; +Global::Global(GobEngine *vm) : _vm(vm) { + useMouse = UNDEF; + mousePresent = UNDEF; + + presentCGA = UNDEF; + presentEGA = UNDEF; + presentVGA = UNDEF; + presentHER = UNDEF; + + videoMode = 0; + + /* Sound */ + presentSound = 0x8000; /* undefined values */ + soundFlags = 0x8000; + blasterPort = 0; + disableSoundCfg = 0; + + //char playingSound = 0; + + /* Mouse */ + disableMouseCfg = 0; + + mouseXShift = 3; + mouseYShift = 3; + + mouseMaxCol = 320; + mouseMaxRow = 200; + + /* Language */ + disableLangCfg = 0x8000; + language = 0x8000; + + /* Timer variables */ + startTime = 0; + timer_delta = 1000; + + frameWaitTime = 0; + startFrameTime = 0; + + /* Timer and delays */ + delayTime = 0; + + /* Joystick */ + useJoystick = 1; + + /* Data files */ + packedSize = 0; + for (int i = 0; i < MAX_DATA_FILES; i++) { + dataFiles[i] = 0; + numDataChunks[i] = 0; + dataFileHandles[i] = -1; + } + + primaryWidth = 0; + primaryHeight = 0; + + sprAllocated = 0; + + doRangeClamp = 0; + + setAllPalette = 0; + + oldMode = 3; + dontSetPalette = 0; + curPrimaryDesc = 0; + allocatedPrimary = 0; + pPrimarySurfDesc = 0; + + pPaletteDesc = 0; + + unusedPalette1[0] = (int16)0; + unusedPalette1[1] = (int16)0x0b; + unusedPalette1[2] = (int16)0; + unusedPalette1[3] = (int16)0x5555; + unusedPalette1[4] = (int16)0xAAAA; + unusedPalette1[5] = (int16)0xFFFF; + unusedPalette1[6] = (int16)0; + unusedPalette1[7] = (int16)0x5555; + unusedPalette1[8] = (int16)0xAAAA; + unusedPalette1[9] = (int16)0xFFFF; + unusedPalette1[10] = (int16)0; + unusedPalette1[11] = (int16)0x5555; + unusedPalette1[12] = (int16)0xAAAA; + unusedPalette1[13] = (int16)0xFFFF; + unusedPalette1[14] = (int16)0; + unusedPalette1[15] = (int16)0x5555; + unusedPalette1[16] = (int16)0xAAAA; + unusedPalette1[17] = (int16)0xFFFF; + + for (int i = 0; i < 16 ;i++) + unusedPalette2[i] = i; + + vgaPalette[0].red = 0x00; vgaPalette[0].green = 0x00; vgaPalette[0].blue = 0x00; + vgaPalette[1].red = 0x00; vgaPalette[1].green = 0x00; vgaPalette[1].blue = 0x2a; + vgaPalette[2].red = 0x00; vgaPalette[2].green = 0x2a; vgaPalette[2].blue = 0x00; + vgaPalette[3].red = 0x00; vgaPalette[3].green = 0x2a; vgaPalette[3].blue = 0x2a; + vgaPalette[4].red = 0x2a; vgaPalette[4].green = 0x00; vgaPalette[4].blue = 0x00; + vgaPalette[5].red = 0x2a; vgaPalette[5].green = 0x00; vgaPalette[5].blue = 0x2a; + vgaPalette[6].red = 0x2a; vgaPalette[6].green = 0x15; vgaPalette[6].blue = 0x00; + vgaPalette[7].red = 0x2a; vgaPalette[7].green = 0x2a; vgaPalette[7].blue = 0x2a; + vgaPalette[8].red = 0x15; vgaPalette[8].green = 0x15; vgaPalette[8].blue = 0x15; + vgaPalette[9].red = 0x15; vgaPalette[9].green = 0x15; vgaPalette[9].blue = 0x3f; + vgaPalette[10].red = 0x15; vgaPalette[10].green = 0x3f; vgaPalette[10].blue = 0x15; + vgaPalette[11].red = 0x15; vgaPalette[11].green = 0x3f; vgaPalette[11].blue = 0x3f; + vgaPalette[12].red = 0x3f; vgaPalette[12].green = 0x15; vgaPalette[12].blue = 0x15; + vgaPalette[13].red = 0x3f; vgaPalette[13].green = 0x15; vgaPalette[13].blue = 0x3f; + vgaPalette[14].red = 0x3f; vgaPalette[14].green = 0x3f; vgaPalette[14].blue = 0x15; + vgaPalette[15].red = 0x3f; vgaPalette[15].green = 0x3f; vgaPalette[15].blue = 0x3f; + + debugFlag = 0; + inVM = 0; + colorCount = 16; + + inter_resStr[0] = 0; + inter_resVal = 0; + + inter_variables = 0; + inter_execPtr = 0; + inter_animDataSize = 10; + + inter_mouseX = 0; + inter_mouseY = 0; + + tmpPalBuffer = 0; +} } // End of namespace Gob diff --git a/gob/global.h b/gob/global.h index a8a3d45fb8..d6b9fd8d4c 100644 --- a/gob/global.h +++ b/gob/global.h @@ -29,29 +29,11 @@ namespace Gob { -extern char pressedKeys[128]; - -extern char useMouse; -extern int16 mousePresent; - -extern int16 presentCGA; -extern int16 presentEGA; -extern int16 presentVGA; -extern int16 presentHER; - -extern int16 videoMode; - -extern int16 disableVideoCfg; - #define VIDMODE_CGA 0x05 #define VIDMODE_EGA 0x0d #define VIDMODE_VGA 0x13 #define VIDMODE_HER 7 -extern uint16 presentSound; -extern uint16 soundFlags; -extern int16 disableSoundCfg; - #define PROAUDIO_FLAG 0x10 #define ADLIB_FLAG 0x08 #define BLASTER_FLAG 0x04 @@ -59,9 +41,6 @@ extern int16 disableSoundCfg; #define SPEAKER_FLAG 0x01 #define MIDI_FLAG 0x4000 -extern uint16 disableLangCfg; -extern uint16 language; - #define NO 0 #define YES 1 #define UNDEF 2 @@ -75,92 +54,122 @@ extern uint16 language; #define ESCAPE 0x001b #define ENTER 0x000d -/* Timer variables */ -extern int32 startTime; -extern int16 timer_delta; +#define MAX_FILES 30 -extern int16 frameWaitTime; -extern int32 startFrameTime; +/* Video drivers */ +#define UNK_DRIVER 0 +#define VGA_DRIVER 1 +#define EGA_DRIVER 2 +#define CGA_DRIVER 3 +#define HER_DRIVER 4 -/* Mouse */ -extern int16 disableMouseCfg; +class Global { +public: + char pressedKeys[128]; -extern int16 mouseXShift; -extern int16 mouseYShift; -extern int16 mouseMaxCol; -extern int16 mouseMaxRow; + char useMouse; + int16 mousePresent; -/* Timer and delays */ -extern int16 delayTime; + int16 presentCGA; + int16 presentEGA; + int16 presentVGA; + int16 presentHER; -/* Joystick */ -extern char useJoystick; + int16 videoMode; -/* Files */ -#define MAX_FILES 30 + int16 disableVideoCfg; -extern Common::File filesHandles[MAX_FILES]; + uint16 presentSound; + uint16 soundFlags; + int16 disableSoundCfg; + int16 blasterPort; -/* Data files */ -extern struct ChunkDesc *dataFiles[MAX_DATA_FILES]; -extern int16 numDataChunks[MAX_DATA_FILES]; -extern int16 dataFileHandles[MAX_DATA_FILES]; -extern int32 chunkPos[MAX_SLOT_COUNT * MAX_DATA_FILES]; -extern int32 chunkOffset[MAX_SLOT_COUNT * MAX_DATA_FILES]; -extern int32 chunkSize[MAX_SLOT_COUNT * MAX_DATA_FILES]; -extern char isCurrentSlot[MAX_SLOT_COUNT * MAX_DATA_FILES]; -extern int32 packedSize; + uint16 disableLangCfg; + uint16 language; -/* Video drivers */ -#define UNK_DRIVER 0 -#define VGA_DRIVER 1 -#define EGA_DRIVER 2 -#define CGA_DRIVER 3 -#define HER_DRIVER 4 + // Timer variables + int32 startTime; + int16 timer_delta; + + int16 frameWaitTime; + int32 startFrameTime; + + // Mouse + int16 disableMouseCfg; + + int16 mouseXShift; + int16 mouseYShift; + int16 mouseMaxCol; + int16 mouseMaxRow; + + // Timer and delays + int16 delayTime; + + // Joystick + char useJoystick; + + // Files + Common::File filesHandles[MAX_FILES]; + + // Data files + struct DataIO::ChunkDesc *dataFiles[MAX_DATA_FILES]; + int16 numDataChunks[MAX_DATA_FILES]; + int16 dataFileHandles[MAX_DATA_FILES]; + int32 chunkPos[MAX_SLOT_COUNT * MAX_DATA_FILES]; + int32 chunkOffset[MAX_SLOT_COUNT * MAX_DATA_FILES]; + int32 chunkSize[MAX_SLOT_COUNT * MAX_DATA_FILES]; + char isCurrentSlot[MAX_SLOT_COUNT * MAX_DATA_FILES]; + int32 packedSize; + + int16 sprAllocated; + + int16 primaryWidth; + int16 primaryHeight; -extern SurfaceDesc primarySurfDesc; -extern SurfaceDesc *pPrimarySurfDesc; -extern int16 sprAllocated; + int16 doRangeClamp; -extern int16 primaryWidth; -extern int16 primaryHeight; + char redPalette[256]; + char greenPalette[256]; + char bluePalette[256]; -extern int16 doRangeClamp; + int16 setAllPalette; -extern char redPalette[256]; -extern char greenPalette[256]; -extern char bluePalette[256]; + Video::SurfaceDesc *curPrimaryDesc; + Video::SurfaceDesc *allocatedPrimary; + Video::SurfaceDesc_t primarySurfDesc; + Video::SurfaceDesc *pPrimarySurfDesc; -extern int16 setAllPalette; + int16 oldMode; + char dontSetPalette; -extern SurfaceDesc *curPrimaryDesc; -extern SurfaceDesc *allocatedPrimary; + Video::PalDesc *pPaletteDesc; -extern int16 oldMode; -extern char dontSetPalette; + int16 unusedPalette1[18]; + int16 unusedPalette2[16]; + Video::Color vgaPalette[16]; + Video::PalDesc paletteStruct; -extern PalDesc *pPaletteDesc; + int16 debugFlag; + int16 inVM; + int16 colorCount; -extern int16 unusedPalette1[18]; -extern int16 unusedPalette2[16]; -extern Color vgaPalette[16]; -extern PalDesc paletteStruct; + char inter_resStr[200]; + int32 inter_resVal; -extern int16 debugFlag; -extern int16 inVM; -extern int16 colorCount; + char *inter_variables; + char *inter_execPtr; + int16 inter_animDataSize; -extern char inter_resStr[200]; -extern int32 inter_resVal; + int16 inter_mouseX; + int16 inter_mouseY; -extern char *inter_variables; -extern char *inter_execPtr; -extern int16 inter_animDataSize; + char *tmpPalBuffer; -extern int16 inter_mouseX; -extern int16 inter_mouseY; + Global(GobEngine *vm); -extern char *tmpPalBuffer; +protected: + GobEngine *_vm; +}; } // End of namespace Gob diff --git a/gob/gob.cpp b/gob/gob.cpp index e304563c3d..a4815eda27 100644 --- a/gob/gob.cpp +++ b/gob/gob.cpp @@ -31,6 +31,19 @@ #include "gob/game.h" #include "gob/sound.h" #include "gob/init.h" +#include "gob/inter.h" +#include "gob/draw.h" +#include "gob/anim.h" +#include "gob/cdrom.h" +#include "gob/goblin.h" +#include "gob/map.h" +#include "gob/mult.h" +#include "gob/pack.h" +#include "gob/palanim.h" +#include "gob/parse.h" +#include "gob/scenery.h" +#include "gob/timer.h" +#include "gob/util.h" enum { // We only compute MD5 of the first megabyte of our data files. @@ -50,53 +63,53 @@ struct GobGameSettings { static const GobGameSettings gob_games[] = { // Supplied by Florian Zeitz on scummvm-devel - {"gob1", "Gobliiins (DOS EGA)", GF_GOB1, "82aea70ef26f41fa963dfae270993e49"}, - {"gob1", "Gobliiins (DOS EGA)", GF_GOB1, "1f499458837008058b8ba6ae07057214"}, - {"gob1", "Gobliiins (Windows)", GF_GOB1, "8a5e850c49d7cacdba5f5eb1fcc77b89"}, + {"gob1", "Gobliiins (DOS EGA)", Gob::GF_GOB1, "82aea70ef26f41fa963dfae270993e49"}, + {"gob1", "Gobliiins (DOS EGA)", Gob::GF_GOB1, "1f499458837008058b8ba6ae07057214"}, + {"gob1", "Gobliiins (Windows)", Gob::GF_GOB1, "8a5e850c49d7cacdba5f5eb1fcc77b89"}, // Supplied by Theruler76 in bug report #1201233 - {"gob1", "Gobliiins (DOS VGA)", GF_GOB1, "a5e232fcd02733c7dffff107d22d36eb"}, + {"gob1", "Gobliiins (DOS VGA)", Gob::GF_GOB1, "a5e232fcd02733c7dffff107d22d36eb"}, // CD 1.000 version. Multilingual - {"gob1", "Gobliiins (CD)", GF_GOB1 | GF_CD, "037db48ebce94bdfe42e2c9510da9211"}, + {"gob1", "Gobliiins (CD)", Gob::GF_GOB1 | Gob::GF_CD, "037db48ebce94bdfe42e2c9510da9211"}, // CD 1.02 version. Multilingual - {"gob1", "Gobliiins (CD)", GF_GOB1 | GF_CD, "45f9c1162dd7040fd05fd013ccc176e2"}, + {"gob1", "Gobliiins (CD)", Gob::GF_GOB1 | Gob::GF_CD, "45f9c1162dd7040fd05fd013ccc176e2"}, - {"gob1", "Gobliiins (Amiga)", GF_GOB1, "d9f8736b7dc0ea891cd06592a72e8a72"}, - {"gob1", "Gobliiins (Amiga)", GF_GOB1, "69f9ae85252271e7dfa62883e581e5e9"}, - {"gob1", "Gobliiins (Amiga)", GF_GOB1, "26de406cb09228d902274446a6a2eceb"}, - {"gob1", "Gobliiins (Amiga)", GF_GOB1, "baf88a95928edb3f51067983f2dffa93"}, + {"gob1", "Gobliiins (Amiga)", Gob::GF_GOB1, "d9f8736b7dc0ea891cd06592a72e8a72"}, + {"gob1", "Gobliiins (Amiga)", Gob::GF_GOB1, "69f9ae85252271e7dfa62883e581e5e9"}, + {"gob1", "Gobliiins (Amiga)", Gob::GF_GOB1, "26de406cb09228d902274446a6a2eceb"}, + {"gob1", "Gobliiins (Amiga)", Gob::GF_GOB1, "baf88a95928edb3f51067983f2dffa93"}, - {"gob1", "Gobliiins (Interactive Demo)", GF_GOB1, "4f5bf4b9e4c39ebb93579747fc678e97"}, + {"gob1", "Gobliiins (Interactive Demo)", Gob::GF_GOB1, "4f5bf4b9e4c39ebb93579747fc678e97"}, #if 0 - {"gob2", "Gobliins 2 (DOS)", GF_GOB2, "abb5f762f9979d4253002de20f6e7b56"}, - {"gob2", "Gobliins 2 (DOS)", GF_GOB2, "9b6de65d811c08eebf50391b84fcba92"}, - {"gob2", "Gobliins 2 (DOS)", GF_GOB2, "54d59c200e3823ad0af11a605a6fd06a"}, - {"gob2", "Gobliins 2 (DOS Ru)", GF_GOB2, "b6d47494bf88398ae59c1b5656cafce4"}, + {"gob2", "Gobliins 2 (DOS)", Gob::GF_GOB2, "abb5f762f9979d4253002de20f6e7b56"}, + {"gob2", "Gobliins 2 (DOS)", Gob::GF_GOB2, "9b6de65d811c08eebf50391b84fcba92"}, + {"gob2", "Gobliins 2 (DOS)", Gob::GF_GOB2, "54d59c200e3823ad0af11a605a6fd06a"}, + {"gob2", "Gobliins 2 (DOS Ru)", Gob::GF_GOB2, "b6d47494bf88398ae59c1b5656cafce4"}, // CD 1.000. - {"gob2", "Gobliins 2 (CD)", GF_GOB2, "02bf538fd8003b8da23a3546299c3df4"}, + {"gob2", "Gobliins 2 (CD)", Gob::GF_GOB2, "02bf538fd8003b8da23a3546299c3df4"}, // CD 1.01 - {"gob2", "Gobliins 2 (CD)", GF_GOB2, "410e632682ab11969bc3b3b588066d95"}, - {"gob2", "Gobliins 2 (Demo)", GF_GOB2, "be8b111191f965ac9b28fe530580d14e"}, + {"gob2", "Gobliins 2 (CD)", Gob::GF_GOB2, "410e632682ab11969bc3b3b588066d95"}, + {"gob2", "Gobliins 2 (Demo)", Gob::GF_GOB2, "be8b111191f965ac9b28fe530580d14e"}, - {"gob3", "Goblins Quest 3", GF_GOB3, "36d9b4032b39a794c8640e500e98893a"}, - {"gob3", "Goblins Quest 3", GF_GOB3, "d129f639f6ca8d6b5f0f4e15edb91058"}, - {"gob3", "Goblins Quest 3", GF_GOB3, "8d17b0abc514b1512fdedc6072acd48b"}, + {"gob3", "Goblins Quest 3", Gob::GF_GOB3, "36d9b4032b39a794c8640e500e98893a"}, + {"gob3", "Goblins Quest 3", Gob::GF_GOB3, "d129f639f6ca8d6b5f0f4e15edb91058"}, + {"gob3", "Goblins Quest 3", Gob::GF_GOB3, "8d17b0abc514b1512fdedc6072acd48b"}, // CD 1.000 - {"gob3", "Goblins Quest 3 (CD)", GF_GOB3, "8d17b0abc514b1512fdedc6072acd48b"}, + {"gob3", "Goblins Quest 3 (CD)", Gob::GF_GOB3, "8d17b0abc514b1512fdedc6072acd48b"}, // CD 1.02. Spanish "Computer Gaming World"* distribution in Spain - {"gob3", "Goblins Quest 3 (CD)", GF_GOB3, "7d7ab9a987be7208b9b685846fbd3e82"}, + {"gob3", "Goblins Quest 3 (CD)", Gob::GF_GOB3, "7d7ab9a987be7208b9b685846fbd3e82"}, - {"gob3", "Goblins Quest 3 (Interactive Demo)", GF_GOB3, "4986b44cec309589508d7904f924c217"}, - {"gob3", "Goblins Quest 3 (Demo)", GF_GOB3, "5024e7de8d6377fbbeabbaa92e0452bc"}, - {"gob3", "Goblins Quest 3 (Interactive Demo)", GF_GOB3, "59ab69dab5fddbbf698c77a84297a5a2"}, + {"gob3", "Goblins Quest 3 (Interactive Demo)", Gob::GF_GOB3, "4986b44cec309589508d7904f924c217"}, + {"gob3", "Goblins Quest 3 (Demo)", Gob::GF_GOB3, "5024e7de8d6377fbbeabbaa92e0452bc"}, + {"gob3", "Goblins Quest 3 (Interactive Demo)", Gob::GF_GOB3, "59ab69dab5fddbbf698c77a84297a5a2"}, // CD 1.0 - {"woodruff", "The Bizarre Adventures of Woodruff and the Schnibble", GF_WOODRUFF, "c27402cee260d2ff1c4cecb2006a630a"}, + {"woodruff", "The Bizarre Adventures of Woodruff and the Schnibble", Gob::GF_WOODRUFF, "c27402cee260d2ff1c4cecb2006a630a"}, // CD 1.00, German release (INTRO.STRK seems to be multilingual, though?) - {"woodruff", "The Bizarre Adventures of Woodruff and the Schnibble", GF_WOODRUFF, "751ba028d215e0db1e0254853de6a7e4"}, + {"woodruff", "The Bizarre Adventures of Woodruff and the Schnibble", Gob::GF_WOODRUFF, "751ba028d215e0db1e0254853de6a7e4"}, #endif {0, 0, 0, 0} }; @@ -111,8 +124,8 @@ static const struct GobGameList { return dummy; } } gob_list[] = { - {"gob1", "Gobliiins", GF_GOB1}, - {"gob2", "Gobliins 2", GF_GOB2}, + {"gob1", "Gobliiins", Gob::GF_GOB1}, + {"gob2", "Gobliins 2", Gob::GF_GOB2}, {0, 0, 0} }; @@ -183,7 +196,6 @@ namespace Gob { GobEngine *_vm = NULL; GobEngine::GobEngine(GameDetector *detector, OSystem * syst) : Engine(syst) { - // Setup mixer if (!_mixer->isReady()) { warning("Sound initialization failed."); @@ -232,6 +244,25 @@ GobEngine::GobEngine(GameDetector *detector, OSystem * syst) : Engine(syst) { } GobEngine::~GobEngine() { + delete _game; + delete _snd; + delete _video; + delete _global; + delete _draw; + delete _anim; + delete _cdrom; + delete _dataio; + delete _goblin; + delete _init; + delete _inter; + delete _map; + delete _mult; + delete _pack; + delete _palanim; + delete _parse; + delete _scenery; + delete _gtimer; + delete _util; } void GobEngine::errorString(const char *buf1, char *buf2) { @@ -239,6 +270,26 @@ void GobEngine::errorString(const char *buf1, char *buf2) { } int GobEngine::init(GameDetector &detector) { + _game = new Game(this); + _snd = new Snd(this); + _video = new Video(this); + _global = new Global(this); + _draw = new Draw(this); + _anim = new Anim(); + _cdrom = new CDROM(this); + _dataio = new DataIO(this); + _goblin = new Goblin(this); + _init = new Init(this); + _inter = new Inter(this); + _map = new Map(this); + _mult = new Mult(this); + _pack = new Pack(); + _palanim = new PalAnim(this); + _parse = new Parse(this); + _scenery = new Scenery(this); + _gtimer = new GTimer(); + _util = new Util(this); + _system->beginGFXTransaction(); initCommonGFX(detector); _system->initSize(320, 200); @@ -252,30 +303,30 @@ int GobEngine::init(GameDetector &detector) { if (cd_num >= 0) _system->openCD(cd_num); - debugFlag = 1; - doRangeClamp = 1; + _global->debugFlag = 1; + _global->doRangeClamp = 1; - videoMode = 0x13; - snd_soundPort = 1; - useMouse = 1; - soundFlags = 0; + _global->videoMode = 0x13; + _snd->soundPort = 1; + _global->useMouse = 1; + _global->soundFlags = 0; switch (Common::parseLanguage(ConfMan.get("language"))) { case Common::FR_FRA: - language = 0; + _global->language = 0; break; case Common::DE_DEU: - language = 1; + _global->language = 1; break; case Common::ES_ESP: - language = 3; + _global->language = 3; break; case Common::IT_ITA: - language = 4; + _global->language = 4; break; default: // Default to English - language = 2; + _global->language = 2; break; } @@ -289,7 +340,7 @@ int GobEngine::init(GameDetector &detector) { } int GobEngine::go() { - init_initGame(0); + _init->initGame(0); return 0; } diff --git a/gob/gob.h b/gob/gob.h index 3e22d4a436..fde3bec197 100644 --- a/gob/gob.h +++ b/gob/gob.h @@ -29,15 +29,39 @@ #include "base/engine.h" -#define VAR_OFFSET(offs) (*(uint32 *)(inter_variables + (offs))) +#include "gob/dataio.h" +#include "gob/video.h" +#include "common/file.h" + +namespace Gob { + +class Game; +class Snd; +class Video; +class Global; +class Draw; +class Anim; +class CDROM; +class DataIO; +class Goblin; +class Init; +class Inter; +class Map; +class Mult; +class Pack; +class PalAnim; +class Parse; +class Scenery; +class GTimer; +class Util; + +#define VAR_OFFSET(offs) (*(uint32 *)(_vm->_global->inter_variables + (offs))) #define VAR(var) VAR_OFFSET((var) << 2) #define VAR_ADDRESS(var) (&VAR(var)) #define WRITE_VAR_OFFSET(offs, val) (VAR_OFFSET(offs) = (val)) #define WRITE_VAR(var, val) WRITE_VAR_OFFSET((var) << 2, (val)) -// TODO: Should be in the Gob namespace, I guess - enum { GF_GOB1 = 1 << 0, GF_GOB2 = 1 << 1, @@ -46,8 +70,6 @@ enum { GF_CD = 1 << 4 }; -namespace Gob { - class GobEngine : public Engine { void errorString(const char *buf_input, char *buf_output); @@ -64,6 +86,25 @@ public: Common::RandomSource _rnd; int32 _features; + Game *_game; + Snd *_snd; + Video *_video; + Global *_global; + Draw *_draw; + Anim *_anim; + CDROM *_cdrom; + DataIO *_dataio; + Goblin *_goblin; + Init *_init; + Inter *_inter; + Map *_map; + Mult *_mult; + Pack *_pack; + PalAnim *_palanim; + Parse *_parse; + Scenery *_scenery; + GTimer *_gtimer; + Util *_util; }; extern GobEngine *_vm; diff --git a/gob/goblin.cpp b/gob/goblin.cpp index f88514ab83..3da9c50764 100644 --- a/gob/goblin.cpp +++ b/gob/goblin.cpp @@ -35,125 +35,137 @@ namespace Gob { -Util_List *gob_objList; -Gob_Object *gob_goblins[4]; -int16 gob_currentGoblin; -Snd_SoundDesc *gob_soundData[16]; -int16 gob_gobStateLayer; -char gob_goesAtTarget = 0; -char gob_readyToAct = 0; -int16 gob_gobAction = 0; -Gob_Pos gob_gobPositions[3]; -int16 gob_gobDestX; -int16 gob_gobDestY; -int16 gob_pressedMapX; -int16 gob_pressedMapY; -char gob_pathExistence; - -int16 gob_itemIndInPocket = 5; -int16 gob_itemIdInPocket = 2; -char gob_itemByteFlag = 0; -int16 gob_destItemId = -1; -int16 gob_destActionItem = 0; -Gob_Object *gob_actDestItemDesc = 0; -int16 gob_forceNextState[10] = { - -1, -1, -1, -1, -1, -1, -1, 0, 0, 0 -}; - -char gob_rotStates[4][4] = { - {0, 22, 23, 24}, - {13, 2, 12, 14}, - {16, 15, 4, 17}, - {27, 25, 26, 6} -}; - -int16 gob_destItemType; -int16 gob_destItemState; -// Pointers to interpreter variables -int32 *gob_some0ValPtr; - -int32 *gob_gobRetVarPtr; -int32 *gob_curGobVarPtr; -int32 *gob_curGobXPosVarPtr; -int32 *gob_curGobYPosVarPtr; -int32 *gob_itemInPocketVarPtr; -int32 *gob_curGobStateVarPtr; -int32 *gob_curGobFrameVarPtr; -int32 *gob_curGobMultStateVarPtr; -int32 *gob_curGobNextStateVarPtr; -int32 *gob_curGobScrXVarPtr; -int32 *gob_curGobScrYVarPtr; -int32 *gob_curGobLeftVarPtr; -int32 *gob_curGobTopVarPtr; -int32 *gob_curGobRightVarPtr; -int32 *gob_curGobBottomVarPtr; -int32 *gob_curGobDoAnimVarPtr; -int32 *gob_curGobOrderVarPtr; -int32 *gob_curGobNoTickVarPtr; -int32 *gob_curGobTypeVarPtr; -int32 *gob_curGobMaxTickVarPtr; -int32 *gob_curGobTickVarPtr; -int32 *gob_curGobActStartStateVarPtr; -int32 *gob_curGobLookDirVarPtr; -int32 *gob_curGobPickableVarPtr; -int32 *gob_curGobRelaxVarPtr; -int32 *gob_curGobMaxFrameVarPtr; - -int32 *gob_destItemStateVarPtr; -int32 *gob_destItemFrameVarPtr; -int32 *gob_destItemMultStateVarPtr; -int32 *gob_destItemNextStateVarPtr; -int32 *gob_destItemScrXVarPtr; -int32 *gob_destItemScrYVarPtr; -int32 *gob_destItemLeftVarPtr; -int32 *gob_destItemTopVarPtr; -int32 *gob_destItemRightVarPtr; -int32 *gob_destItemBottomVarPtr; -int32 *gob_destItemDoAnimVarPtr; -int32 *gob_destItemOrderVarPtr; -int32 *gob_destItemNoTickVarPtr; -int32 *gob_destItemTypeVarPtr; -int32 *gob_destItemMaxTickVarPtr; -int32 *gob_destItemTickVarPtr; -int32 *gob_destItemActStartStVarPtr; -int32 *gob_destItemLookDirVarPtr; -int32 *gob_destItemPickableVarPtr; -int32 *gob_destItemRelaxVarPtr; -int32 *gob_destItemMaxFrameVarPtr; - -// -int16 gob_itemToObject[20]; -Gob_Object *gob_objects[20]; -int16 gob_objCount; -int16 gob_gobsCount; -char gob_boreCounter = 0; -int16 gob_positionedGob = 5; - -char gob_noPick = 0; - -char gob_rotateState(int16 from, int16 to) { - return gob_rotStates[from / 2][to / 2]; +Goblin::Goblin(GobEngine *vm) : _vm(vm) { + goesAtTarget = 0; + readyToAct = 0; + gobAction = 0; + itemIndInPocket = 5; + itemIdInPocket = 2; + itemByteFlag = 0; + destItemId = -1; + destActionItem = 0; + actDestItemDesc = 0; + forceNextState[0] = -1; + forceNextState[1] = -1; + forceNextState[2] = -1; + forceNextState[3] = -1; + forceNextState[4] = -1; + forceNextState[5] = -1; + forceNextState[6] = -1; + forceNextState[7] = 0; + forceNextState[8] = 0; + forceNextState[9] = 0; + + rotStates[0][0] = 0; rotStates[0][1] = 22; rotStates[0][2] = 23; rotStates[0][3] = 24; + rotStates[1][0] = 13; rotStates[1][1] = 2; rotStates[1][2] = 12; rotStates[1][3] = 14; + rotStates[2][0] = 16; rotStates[2][1] = 15; rotStates[2][2] = 4; rotStates[2][3] = 17; + rotStates[3][0] = 27; rotStates[3][1] = 25; rotStates[3][2] = 26; rotStates[3][3] = 6; + + boreCounter = 0; + positionedGob = 5; + + noPick = 0; + objList = 0; + for (int i = 0; i < 4; i++) + goblins[i] = 0; + currentGoblin = 0; + for (int i = 0; i < 16; i++) + soundData[i] = 0; + for (int i = 0; i < 3; i++) { + gobPositions[i].x = 0; + gobPositions[i].y = 0; + } + gobDestX = 0; + gobDestY = 0; + pressedMapX = 0; + pressedMapY = 0; + pathExistence = 0; + + some0ValPtr = 0; + + gobRetVarPtr = 0; + curGobVarPtr = 0; + curGobXPosVarPtr = 0; + curGobYPosVarPtr = 0; + itemInPocketVarPtr = 0; + + curGobStateVarPtr = 0; + curGobFrameVarPtr = 0; + curGobMultStateVarPtr = 0; + curGobNextStateVarPtr = 0; + curGobScrXVarPtr = 0; + curGobScrYVarPtr = 0; + curGobLeftVarPtr = 0; + curGobTopVarPtr = 0; + curGobRightVarPtr = 0; + curGobBottomVarPtr = 0; + curGobDoAnimVarPtr = 0; + curGobOrderVarPtr = 0; + curGobNoTickVarPtr = 0; + curGobTypeVarPtr = 0; + curGobMaxTickVarPtr = 0; + curGobTickVarPtr = 0; + curGobActStartStateVarPtr = 0; + curGobLookDirVarPtr = 0; + curGobPickableVarPtr = 0; + curGobRelaxVarPtr = 0; + curGobMaxFrameVarPtr = 0; + + destItemStateVarPtr = 0; + destItemFrameVarPtr = 0; + destItemMultStateVarPtr = 0; + destItemNextStateVarPtr = 0; + destItemScrXVarPtr = 0; + destItemScrYVarPtr = 0; + destItemLeftVarPtr = 0; + destItemTopVarPtr = 0; + destItemRightVarPtr = 0; + destItemBottomVarPtr = 0; + destItemDoAnimVarPtr = 0; + destItemOrderVarPtr = 0; + destItemNoTickVarPtr = 0; + destItemTypeVarPtr = 0; + destItemMaxTickVarPtr = 0; + destItemTickVarPtr = 0; + destItemActStartStVarPtr = 0; + destItemLookDirVarPtr = 0; + destItemPickableVarPtr = 0; + destItemRelaxVarPtr = 0; + destItemMaxFrameVarPtr = 0; + + destItemType = 0; + destItemState = 0; + for (int i = 0; i < 20; i++) { + itemToObject[i] = 0; + objects[i] = 0; + } + objCount = 0; + gobsCount = 0; +} + +char Goblin::rotateState(int16 from, int16 to) { + return rotStates[from / 2][to / 2]; } -int16 gob_peekGoblin(Gob_Object *curGob) { - Util_ListNode *ptr; +int16 Goblin::peekGoblin(Gob_Object *curGob) { + Util::ListNode *ptr; Gob_Object *desc; int16 index; int16 i; - ptr = gob_objList->pHead; + ptr = objList->pHead; index = 0; while (ptr != 0) { desc = (Gob_Object *) ptr->pData; if (desc != curGob) { for (i = 0; i < 3; i++) { - if (desc != gob_goblins[i]) + if (desc != goblins[i]) continue; - if (inter_mouseX < desc->right && - inter_mouseX > desc->left && - inter_mouseY < desc->bottom && - inter_mouseY > desc->top) { + if (_vm->_global->inter_mouseX < desc->right && + _vm->_global->inter_mouseX > desc->left && + _vm->_global->inter_mouseY < desc->bottom && + _vm->_global->inter_mouseY > desc->top) { index = i + 1; } } @@ -163,15 +175,15 @@ int16 gob_peekGoblin(Gob_Object *curGob) { return index; } -void gob_initList(void) { - gob_objList = (Util_List *) malloc(sizeof(Util_List)); - gob_objList->pHead = 0; - gob_objList->pTail = 0; +void Goblin::initList(void) { + objList = (Util::List *) malloc(sizeof(Util::List)); + objList->pHead = 0; + objList->pTail = 0; } -void gob_sortByOrder(Util_List *list) { - Util_ListNode *ptr; - Util_ListNode *ptr2; +void Goblin::sortByOrder(Util::List *list) { + Util::ListNode *ptr; + Util::ListNode *ptr2; ptr = list->pHead; while (ptr->pNext != 0) { @@ -187,7 +199,7 @@ void gob_sortByOrder(Util_List *list) { if (objDesc->bottom != objDesc2->bottom) continue; - if (objDesc != gob_goblins[gob_currentGoblin]) + if (objDesc != goblins[currentGoblin]) continue; } } @@ -198,23 +210,23 @@ void gob_sortByOrder(Util_List *list) { } } -void gob_playSound(Snd_SoundDesc *snd, int16 repCount, int16 freq) { +void Goblin::playSound(Snd::SoundDesc *snd, int16 repCount, int16 freq) { if (snd != 0) { - snd_stopSound(0); - snd_playSample(snd, repCount, freq); + _vm->_snd->stopSound(0); + _vm->_snd->playSample(snd, repCount, freq); } } -void gob_drawObjects(void) { - Util_ListNode *ptr; - Util_ListNode *ptr2; +void Goblin::drawObjects(void) { + Util::ListNode *ptr; + Util::ListNode *ptr2; Gob_Object *objDesc; Gob_Object *gobDesc2; int16 layer; - ptr = gob_objList->pHead; - for (ptr = gob_objList->pHead; ptr != 0; ptr = ptr->pNext) { + ptr = objList->pHead; + for (ptr = objList->pHead; ptr != 0; ptr = ptr->pNext) { objDesc = (Gob_Object *) ptr->pData; if (objDesc->type == 3) @@ -223,16 +235,16 @@ void gob_drawObjects(void) { objDesc->toRedraw = 0; } - for (ptr = gob_objList->pHead; ptr != 0; ptr = ptr->pNext) { + for (ptr = objList->pHead; ptr != 0; ptr = ptr->pNext) { objDesc = (Gob_Object *) ptr->pData; if (objDesc->toRedraw == 0) continue; - vid_drawSprite(anim_underAnimSurf, draw_backSurface, + _vm->_video->drawSprite(_vm->_anim->_animSurf, _vm->_draw->backSurface, objDesc->left, objDesc->top, objDesc->right, objDesc->bottom, objDesc->left, objDesc->top, 0); - draw_invalidateRect(objDesc->left, objDesc->top, + _vm->_draw->invalidateRect(objDesc->left, objDesc->top, objDesc->right, objDesc->bottom); if (objDesc->type != 0) @@ -241,23 +253,23 @@ void gob_drawObjects(void) { layer = objDesc->stateMach[objDesc->state][objDesc->stateColumn]-> layer; - scen_updateAnim(layer, objDesc->curFrame, objDesc->animation, + _vm->_scenery->updateAnim(layer, objDesc->curFrame, objDesc->animation, 0, objDesc->xPos, objDesc->yPos, 0); - if (scen_toRedrawLeft == -12345) { + if (_vm->_scenery->toRedrawLeft == -12345) { objDesc->dirtyLeft = objDesc->left; objDesc->dirtyRight = objDesc->right; objDesc->dirtyTop = objDesc->top; objDesc->dirtyBottom = objDesc->bottom; } else { objDesc->dirtyLeft = - MIN(objDesc->left, scen_toRedrawLeft); + MIN(objDesc->left, _vm->_scenery->toRedrawLeft); objDesc->dirtyRight = - MAX(objDesc->right, scen_toRedrawRight); + MAX(objDesc->right, _vm->_scenery->toRedrawRight); objDesc->dirtyTop = - MIN(objDesc->top, scen_toRedrawTop); + MIN(objDesc->top, _vm->_scenery->toRedrawTop); objDesc->dirtyBottom = - MAX(objDesc->bottom, scen_toRedrawBottom); + MAX(objDesc->bottom, _vm->_scenery->toRedrawBottom); } objDesc->dirtyLeft = 0; @@ -266,8 +278,8 @@ void gob_drawObjects(void) { objDesc->dirtyBottom = 199; } - gob_sortByOrder(gob_objList); - for (ptr = gob_objList->pHead; ptr != 0; ptr = ptr->pNext) { + sortByOrder(objList); + for (ptr = objList->pHead; ptr != 0; ptr = ptr->pNext) { objDesc = (Gob_Object *) ptr->pData; if (objDesc->toRedraw) { layer = @@ -276,33 +288,33 @@ void gob_drawObjects(void) { if (objDesc->type == 0) { if (objDesc->visible == 0) { - scen_updateAnim(layer, + _vm->_scenery->updateAnim(layer, objDesc->curFrame, objDesc->animation, 0, objDesc->xPos, objDesc->yPos, 0); } else { - scen_updateAnim(layer, + _vm->_scenery->updateAnim(layer, objDesc->curFrame, objDesc->animation, 2, objDesc->xPos, objDesc->yPos, 1); } - if (scen_toRedrawLeft == -12345) { + if (_vm->_scenery->toRedrawLeft == -12345) { objDesc->left = 0; objDesc->top = 0; objDesc->right = 0; objDesc->bottom = 0; } else { - draw_invalidateRect(scen_toRedrawLeft, - scen_toRedrawTop, - scen_toRedrawRight, - scen_toRedrawBottom); - - objDesc->left = scen_toRedrawLeft; - objDesc->top = scen_toRedrawTop; - objDesc->right = scen_toRedrawRight; - objDesc->bottom = scen_toRedrawBottom; - scen_updateStatic(objDesc->order); + _vm->_draw->invalidateRect(_vm->_scenery->toRedrawLeft, + _vm->_scenery->toRedrawTop, + _vm->_scenery->toRedrawRight, + _vm->_scenery->toRedrawBottom); + + objDesc->left = _vm->_scenery->toRedrawLeft; + objDesc->top = _vm->_scenery->toRedrawTop; + objDesc->right = _vm->_scenery->toRedrawRight; + objDesc->bottom = _vm->_scenery->toRedrawBottom; + _vm->_scenery->updateStatic(objDesc->order); } } else { objDesc->left = 0; @@ -315,7 +327,7 @@ void gob_drawObjects(void) { } if (objDesc->type == 0 && objDesc->visible != 0) { - for (ptr2 = gob_objList->pHead; ptr2 != 0; + for (ptr2 = objList->pHead; ptr2 != 0; ptr2 = ptr2->pNext) { gobDesc2 = (Gob_Object *) ptr2->pData; @@ -334,25 +346,25 @@ void gob_drawObjects(void) { if (gobDesc2->dirtyBottom < objDesc->top) continue; - scen_toRedrawLeft = gobDesc2->dirtyLeft; - scen_toRedrawRight = gobDesc2->dirtyRight; - scen_toRedrawTop = gobDesc2->dirtyTop; - scen_toRedrawBottom = gobDesc2->dirtyBottom; + _vm->_scenery->toRedrawLeft = gobDesc2->dirtyLeft; + _vm->_scenery->toRedrawRight = gobDesc2->dirtyRight; + _vm->_scenery->toRedrawTop = gobDesc2->dirtyTop; + _vm->_scenery->toRedrawBottom = gobDesc2->dirtyBottom; layer = objDesc->stateMach[objDesc-> state][objDesc->stateColumn]->layer; - scen_updateAnim(layer, objDesc->curFrame, + _vm->_scenery->updateAnim(layer, objDesc->curFrame, objDesc->animation, 4, objDesc->xPos, objDesc->yPos, 1); - scen_updateStatic(objDesc->order); + _vm->_scenery->updateStatic(objDesc->order); } } } - for (ptr = gob_objList->pHead; ptr != 0; ptr = ptr->pNext) { + for (ptr = objList->pHead; ptr != 0; ptr = ptr->pNext) { objDesc = (Gob_Object *) ptr->pData; if (objDesc->toRedraw == 0 || objDesc->type == 1) continue; @@ -376,7 +388,7 @@ void gob_drawObjects(void) { if (objDesc->curFrame == sndFrame) { if (sndItem != 0xff) { - gob_playSound(gob_soundData[sndItem], + playSound(soundData[sndItem], repCount, freq); } } @@ -388,7 +400,7 @@ void gob_drawObjects(void) { if (objDesc->curFrame == sndFrame) { if (sndItem != 0xff) { - gob_playSound(gob_soundData[sndItem], + playSound(soundData[sndItem], repCount, freq); } } @@ -401,23 +413,23 @@ void gob_drawObjects(void) { if (objDesc->curFrame == sndFrame) { if (sndItem != -1) { - gob_playSound(gob_soundData[sndItem], + playSound(soundData[sndItem], repCount, freq); } } } } -// scen_updateAnim(27, 0, 9, 2, 10, 10, 1); +// _vm->_scenery->updateAnim(27, 0, 9, 2, 10, 10, 1); } -void gob_animateObjects(void) { - Util_ListNode *node; +void Goblin::animateObjects(void) { + Util::ListNode *node; Gob_Object *objDesc; - Scen_AnimLayer *pLayer; + Scenery::AnimLayer *pLayer; int16 layer; - for (node = gob_objList->pHead; node != 0; node = node->pNext) { + for (node = objList->pHead; node != 0; node = node->pNext) { objDesc = (Gob_Object *) node->pData; if (objDesc->doAnim != 1 || objDesc->type != 0) continue; @@ -434,7 +446,7 @@ void gob_animateObjects(void) { layer = objDesc->stateMach[objDesc->state][0]->layer; pLayer = - scen_animations[objDesc->animation].layers[layer]; + _vm->_scenery->animations[objDesc->animation].layers[layer]; if (objDesc->curFrame < pLayer->framesCount) continue; @@ -453,7 +465,7 @@ void gob_animateObjects(void) { if (objDesc->multState != -1) { if (objDesc->multState > 39) { - objDesc->stateMach = gob_goblins[(int)(objDesc->multObjIndex)]->stateMach; + objDesc->stateMach = goblins[(int)(objDesc->multObjIndex)]->stateMach; objDesc->state = objDesc->multState - 40; } else { objDesc->stateMach = objDesc->realStateMach; @@ -479,7 +491,7 @@ void gob_animateObjects(void) { } } -void gob_placeObject(Gob_Object *objDesc, char animated) { +void Goblin::placeObject(Gob_Object *objDesc, char animated) { int16 layer; if (objDesc->stateMach[objDesc->state][0] != 0) { @@ -503,13 +515,13 @@ void gob_placeObject(Gob_Object *objDesc, char animated) { objDesc->pickable = 0; objDesc->unk14 = 0; - objDesc->relaxTime = util_getRandom(30); + objDesc->relaxTime = _vm->_util->getRandom(30); layer = objDesc->stateMach[objDesc->state][0]->layer; - scen_updateAnim(layer, 0, objDesc->animation, 0, + _vm->_scenery->updateAnim(layer, 0, objDesc->animation, 0, objDesc->xPos, objDesc->yPos, 0); - objDesc->order = scen_toRedrawBottom / 24 + 3; + objDesc->order = _vm->_scenery->toRedrawBottom / 24 + 3; objDesc->left = objDesc->xPos; objDesc->right = objDesc->xPos; @@ -521,19 +533,19 @@ void gob_placeObject(Gob_Object *objDesc, char animated) { objDesc->dirtyTop = objDesc->yPos; objDesc->dirtyBottom = objDesc->yPos; - util_listInsertBack(gob_objList, objDesc); + _vm->_util->listInsertBack(objList, objDesc); } } -int16 gob_getObjMaxFrame(Gob_Object * objDesc) { +int16 Goblin::getObjMaxFrame(Gob_Object * objDesc) { int16 layer; layer = objDesc->stateMach[objDesc->state][0]->layer; - return scen_animations[objDesc->animation].layers[layer]->framesCount - + return _vm->_scenery->animations[objDesc->animation].layers[layer]->framesCount - 1; } -int16 gob_objIntersected(Gob_Object *obj1, Gob_Object *obj2) { +int16 Goblin::objIntersected(Gob_Object *obj1, Gob_Object *obj2) { if (obj1->type == 1 || obj2->type == 1) return 0; @@ -552,11 +564,11 @@ int16 gob_objIntersected(Gob_Object *obj1, Gob_Object *obj2) { return 1; } -void gob_setMultStates(Gob_Object * gobDesc) { - gobDesc->stateMach = gob_goblins[(int)gobDesc->multObjIndex]->stateMach; +void Goblin::setMultStates(Gob_Object * gobDesc) { + gobDesc->stateMach = goblins[(int)gobDesc->multObjIndex]->stateMach; } -int16 gob_nextLayer(Gob_Object *gobDesc) { +int16 Goblin::nextLayer(Gob_Object *gobDesc) { if (gobDesc->nextState == 10) gobDesc->curLookDir = 0; @@ -564,7 +576,7 @@ int16 gob_nextLayer(Gob_Object *gobDesc) { gobDesc->curLookDir = 4; if (gobDesc->nextState > 39) { - gob_setMultStates(gobDesc); + setMultStates(gobDesc); } else { gobDesc->stateMach = gobDesc->realStateMach; } @@ -579,7 +591,7 @@ int16 gob_nextLayer(Gob_Object *gobDesc) { return gobDesc->stateMach[gobDesc->state][0]->layer; } -void gob_showBoredom(int16 gobIndex) { +void Goblin::showBoredom(int16 gobIndex) { Gob_Object *gobDesc; int16 frame; int16 frameCount; @@ -587,20 +599,20 @@ void gob_showBoredom(int16 gobIndex) { int16 state; int16 boreFlag; - gobDesc = gob_goblins[gobIndex]; + gobDesc = goblins[gobIndex]; layer = gobDesc->stateMach[gobDesc->state][0]->layer; frameCount = - scen_animations[gobDesc->animation].layers[layer]->framesCount; + _vm->_scenery->animations[gobDesc->animation].layers[layer]->framesCount; state = gobDesc->state; frame = gobDesc->curFrame; gobDesc->noTick = 0; gobDesc->toRedraw = 1; - boreFlag = 1 << util_getRandom(7); + boreFlag = 1 << _vm->_util->getRandom(7); - if (gobIndex != gob_currentGoblin && util_getRandom(3) != 0) { + if (gobIndex != currentGoblin && _vm->_util->getRandom(3) != 0) { if (state == 21) { if ((boreFlag & 16) || (boreFlag & 32)) { gobDesc->multState = 92 + gobIndex; @@ -628,103 +640,103 @@ void gob_showBoredom(int16 gobIndex) { // index - goblin to select+1 // index==0 - switch to next -void gob_switchGoblin(int16 index) { +void Goblin::switchGoblin(int16 index) { int16 next; int16 tmp; - debug(4, "gob_switchGoblin"); + debug(4, "switchGoblin"); if (VAR(59) != 0) return; - if (gob_goblins[gob_currentGoblin]->state <= 39 && - gob_goblins[gob_currentGoblin]->curFrame != 0) + if (goblins[currentGoblin]->state <= 39 && + goblins[currentGoblin]->curFrame != 0) return; - if (index != 0 && gob_goblins[index - 1]->type != 0) + if (index != 0 && goblins[index - 1]->type != 0) return; if (index == 0) - next = (gob_currentGoblin + 1) % 3; + next = (currentGoblin + 1) % 3; else next = index - 1; - if (map_passMap[map_curGoblinY][map_curGoblinX] == 3 || - map_passMap[map_curGoblinY][map_curGoblinX] == 6) + if (_vm->_map->passMap[_vm->_map->curGoblinY][_vm->_map->curGoblinX] == 3 || + _vm->_map->passMap[_vm->_map->curGoblinY][_vm->_map->curGoblinX] == 6) return; - if (gob_goblins[(gob_currentGoblin + 1) % 3]->type != 0 && - gob_goblins[(gob_currentGoblin + 2) % 3]->type != 0) + if (goblins[(currentGoblin + 1) % 3]->type != 0 && + goblins[(currentGoblin + 2) % 3]->type != 0) return; - gob_gobPositions[gob_currentGoblin].x = map_curGoblinX; - gob_gobPositions[gob_currentGoblin].y = map_curGoblinY; + gobPositions[currentGoblin].x = _vm->_map->curGoblinX; + gobPositions[currentGoblin].y = _vm->_map->curGoblinY; - gob_goblins[gob_currentGoblin]->doAnim = 1; - gob_goblins[gob_currentGoblin]->nextState = 21; + goblins[currentGoblin]->doAnim = 1; + goblins[currentGoblin]->nextState = 21; - gob_nextLayer(gob_goblins[gob_currentGoblin]); + nextLayer(goblins[currentGoblin]); - gob_currentGoblin = next; - if (gob_goblins[gob_currentGoblin]->type != 0) - gob_currentGoblin = (gob_currentGoblin + 1) % 3; + currentGoblin = next; + if (goblins[currentGoblin]->type != 0) + currentGoblin = (currentGoblin + 1) % 3; - gob_goblins[gob_currentGoblin]->doAnim = 0; - if (gob_goblins[gob_currentGoblin]->curLookDir == 4) - gob_goblins[gob_currentGoblin]->nextState = 18; + goblins[currentGoblin]->doAnim = 0; + if (goblins[currentGoblin]->curLookDir == 4) + goblins[currentGoblin]->nextState = 18; else - gob_goblins[gob_currentGoblin]->nextState = 19; - - gob_goblins[gob_currentGoblin]->toRedraw = 1; - gob_nextLayer(gob_goblins[gob_currentGoblin]); - - tmp = gob_gobPositions[gob_currentGoblin].x; - gob_pressedMapX = tmp; - map_destX = tmp; - gob_gobDestX = tmp; - map_curGoblinX = tmp; - - tmp = gob_gobPositions[gob_currentGoblin].y; - gob_pressedMapY = tmp; - map_destY = tmp; - gob_gobDestY = tmp; - map_curGoblinY = tmp; - - *gob_curGobVarPtr = gob_currentGoblin; - gob_pathExistence = 0; - gob_readyToAct = 0; + goblins[currentGoblin]->nextState = 19; + + goblins[currentGoblin]->toRedraw = 1; + nextLayer(goblins[currentGoblin]); + + tmp = gobPositions[currentGoblin].x; + pressedMapX = tmp; + _vm->_map->destX = tmp; + gobDestX = tmp; + _vm->_map->curGoblinX = tmp; + + tmp = gobPositions[currentGoblin].y; + pressedMapY = tmp; + _vm->_map->destY = tmp; + gobDestY = tmp; + _vm->_map->curGoblinY = tmp; + + *curGobVarPtr = currentGoblin; + pathExistence = 0; + readyToAct = 0; } -void gob_adjustDest(int16 posX, int16 posY) { +void Goblin::adjustDest(int16 posX, int16 posY) { int16 resDelta; int16 resDeltaDir; int16 resDeltaPix; int16 deltaPix; int16 i; - if (map_passMap[gob_pressedMapY][gob_pressedMapX] == 0 && - (gob_gobAction == 0 - || map_itemsMap[gob_pressedMapY][gob_pressedMapX] == 0)) { + if (_vm->_map->passMap[pressedMapY][pressedMapX] == 0 && + (gobAction == 0 + || _vm->_map->itemsMap[pressedMapY][pressedMapX] == 0)) { resDelta = -1; resDeltaDir = 0; resDeltaPix = 0; for (i = 1; - i <= gob_pressedMapX - && map_passMap[gob_pressedMapY][gob_pressedMapX - i] == 0; + i <= pressedMapX + && _vm->_map->passMap[pressedMapY][pressedMapX - i] == 0; i++); - if (i <= gob_pressedMapX) { + if (i <= pressedMapX) { resDeltaPix = (i - 1) * 12 + (posX % 12) + 1; resDelta = i; } for (i = 1; - (i + gob_pressedMapX) < kMapWidth - && map_passMap[gob_pressedMapY][gob_pressedMapX + i] == 0; + (i + pressedMapX) < Map::kMapWidth + && _vm->_map->passMap[pressedMapY][pressedMapX + i] == 0; i++); - if (gob_pressedMapX + i < kMapWidth) { + if (pressedMapX + i < Map::kMapWidth) { deltaPix = (i * 12) - (posX % 12); if (resDelta == -1 || deltaPix < resDeltaPix) { resDeltaPix = deltaPix; @@ -734,11 +746,11 @@ void gob_adjustDest(int16 posX, int16 posY) { } for (i = 1; - (i + gob_pressedMapY) < kMapHeight - && map_passMap[gob_pressedMapY + i][gob_pressedMapX] == 0; + (i + pressedMapY) < Map::kMapHeight + && _vm->_map->passMap[pressedMapY + i][pressedMapX] == 0; i++); - if (gob_pressedMapY + i < kMapHeight) { + if (pressedMapY + i < Map::kMapHeight) { deltaPix = (i * 6) - (posY % 6); if (resDelta == -1 || deltaPix < resDeltaPix) { resDeltaPix = deltaPix; @@ -748,11 +760,11 @@ void gob_adjustDest(int16 posX, int16 posY) { } for (i = 1; - i <= gob_pressedMapY - && map_passMap[gob_pressedMapY - i][gob_pressedMapX] == 0; + i <= pressedMapY + && _vm->_map->passMap[pressedMapY - i][pressedMapX] == 0; i++); - if (i <= gob_pressedMapY) { + if (i <= pressedMapY) { deltaPix = (i * 6) + (posY % 6); if (resDelta == -1 || deltaPix < resDeltaPix) { resDeltaPix = deltaPix; @@ -763,62 +775,62 @@ void gob_adjustDest(int16 posX, int16 posY) { switch (resDeltaDir) { case 0: - gob_pressedMapX -= resDelta; + pressedMapX -= resDelta; break; case 1: - gob_pressedMapX += resDelta; + pressedMapX += resDelta; break; case 2: - gob_pressedMapY += resDelta; + pressedMapY += resDelta; break; case 3: - gob_pressedMapY -= resDelta; + pressedMapY -= resDelta; break; } } } -void gob_adjustTarget(void) { - if (gob_gobAction == 4 - && map_itemsMap[gob_pressedMapY][gob_pressedMapX] == 0) { +void Goblin::adjustTarget(void) { + if (gobAction == 4 + && _vm->_map->itemsMap[pressedMapY][pressedMapX] == 0) { - if (gob_pressedMapY > 0 - && map_itemsMap[gob_pressedMapY - 1][gob_pressedMapX] != + if (pressedMapY > 0 + && _vm->_map->itemsMap[pressedMapY - 1][pressedMapX] != 0) { - gob_pressedMapY--; - } else if (gob_pressedMapX < kMapWidth - 1 - && map_itemsMap[gob_pressedMapY][gob_pressedMapX + 1] != + pressedMapY--; + } else if (pressedMapX < Map::kMapWidth - 1 + && _vm->_map->itemsMap[pressedMapY][pressedMapX + 1] != 0) { - gob_pressedMapX++; - } else if (gob_pressedMapX < kMapWidth - 1 && gob_pressedMapY > 0 - && map_itemsMap[gob_pressedMapY - 1][gob_pressedMapX + + pressedMapX++; + } else if (pressedMapX < Map::kMapWidth - 1 && pressedMapY > 0 + && _vm->_map->itemsMap[pressedMapY - 1][pressedMapX + 1] != 0) { - gob_pressedMapY--; - gob_pressedMapX++; + pressedMapY--; + pressedMapX++; } } } -void gob_targetDummyItem(Gob_Object *gobDesc) { - if (map_itemsMap[gob_pressedMapY][gob_pressedMapX] == 0 && - map_passMap[gob_pressedMapY][gob_pressedMapX] == 1) { +void Goblin::targetDummyItem(Gob_Object *gobDesc) { + if (_vm->_map->itemsMap[pressedMapY][pressedMapX] == 0 && + _vm->_map->passMap[pressedMapY][pressedMapX] == 1) { if (gobDesc->curLookDir == 0) { - map_itemPoses[0].x = gob_pressedMapX; - map_itemPoses[0].y = gob_pressedMapY; - map_itemPoses[0].orient = -4; + _vm->_map->itemPoses[0].x = pressedMapX; + _vm->_map->itemPoses[0].y = pressedMapY; + _vm->_map->itemPoses[0].orient = -4; } else { - map_itemPoses[0].x = gob_pressedMapX; - map_itemPoses[0].y = gob_pressedMapY; - map_itemPoses[0].orient = -1; + _vm->_map->itemPoses[0].x = pressedMapX; + _vm->_map->itemPoses[0].y = pressedMapY; + _vm->_map->itemPoses[0].orient = -1; } } } -void gob_targetItem(void) { +void Goblin::targetItem(void) { int16 tmpX; int16 tmpY; int16 items; @@ -827,106 +839,106 @@ void gob_targetItem(void) { int16 tmpPosY; Gob_Object *itemDesc; - if (gob_gobAction == 3 || gob_gobAction == 4) { - items = map_itemsMap[gob_pressedMapY][gob_pressedMapX]; - if (gob_gobAction == 4 && (items & 0xff00) != 0 && - gob_objects[gob_itemToObject[(items & 0xff00) >> 8]]-> + if (gobAction == 3 || gobAction == 4) { + items = _vm->_map->itemsMap[pressedMapY][pressedMapX]; + if (gobAction == 4 && (items & 0xff00) != 0 && + objects[itemToObject[(items & 0xff00) >> 8]]-> pickable == 1) { - gob_destItemId = (items & 0xff00) >> 8; - gob_destActionItem = (items & 0xff00) >> 8; - gob_itemByteFlag = 1; + destItemId = (items & 0xff00) >> 8; + destActionItem = (items & 0xff00) >> 8; + itemByteFlag = 1; } else if ((items & 0xff) == 0) { - gob_destItemId = (items & 0xff00) >> 8; - gob_destActionItem = (items & 0xff00) >> 8; - gob_itemByteFlag = 1; - } else if (gob_gobAction == 3 && gob_currentGoblin == 2 && + destItemId = (items & 0xff00) >> 8; + destActionItem = (items & 0xff00) >> 8; + itemByteFlag = 1; + } else if (gobAction == 3 && currentGoblin == 2 && (items & 0xff00) != 0) { - gob_destItemId = (items & 0xff00) >> 8; - gob_destActionItem = (items & 0xff00) >> 8; - gob_itemByteFlag = 1; + destItemId = (items & 0xff00) >> 8; + destActionItem = (items & 0xff00) >> 8; + itemByteFlag = 1; } else { - gob_destItemId = items & 0xff; - gob_destActionItem = items & 0xff; - gob_itemByteFlag = 0; + destItemId = items & 0xff; + destActionItem = items & 0xff; + itemByteFlag = 0; } - gob_pressedMapY = map_itemPoses[gob_destItemId].y; - map_destY = map_itemPoses[gob_destItemId].y; - gob_gobDestY = map_itemPoses[gob_destItemId].y; + pressedMapY = _vm->_map->itemPoses[destItemId].y; + _vm->_map->destY = _vm->_map->itemPoses[destItemId].y; + gobDestY = _vm->_map->itemPoses[destItemId].y; - if (gob_gobAction == 3 || gob_destActionItem == 0) { - gob_pressedMapX = map_itemPoses[gob_destItemId].x; - map_destX = map_itemPoses[gob_destItemId].x; - gob_gobDestX = map_itemPoses[gob_destItemId].x; + if (gobAction == 3 || destActionItem == 0) { + pressedMapX = _vm->_map->itemPoses[destItemId].x; + _vm->_map->destX = _vm->_map->itemPoses[destItemId].x; + gobDestX = _vm->_map->itemPoses[destItemId].x; } else if ((items & 0xff00) != 0) { - if (map_itemPoses[gob_destItemId].orient == 4) { - if ((map_itemsMap[gob_pressedMapY] - [gob_pressedMapX - 1] & 0xff00) == - (map_itemsMap[gob_pressedMapY] - [gob_pressedMapX] & 0xff00)) { - gob_pressedMapX--; - map_destX = gob_pressedMapX; - gob_gobDestX = gob_pressedMapX; + if (_vm->_map->itemPoses[destItemId].orient == 4) { + if ((_vm->_map->itemsMap[pressedMapY] + [pressedMapX - 1] & 0xff00) == + (_vm->_map->itemsMap[pressedMapY] + [pressedMapX] & 0xff00)) { + pressedMapX--; + _vm->_map->destX = pressedMapX; + gobDestX = pressedMapX; } - } else if (map_itemPoses[gob_destItemId].orient == 0) { - - if ((map_itemsMap[gob_pressedMapY] - [gob_pressedMapX + 1] & 0xff00) == - (map_itemsMap[gob_pressedMapY] - [gob_pressedMapX] & 0xff00)) { - gob_pressedMapX++; - map_destX = gob_pressedMapX; - gob_gobDestX = gob_pressedMapX; + } else if (_vm->_map->itemPoses[destItemId].orient == 0) { + + if ((_vm->_map->itemsMap[pressedMapY] + [pressedMapX + 1] & 0xff00) == + (_vm->_map->itemsMap[pressedMapY] + [pressedMapX] & 0xff00)) { + pressedMapX++; + _vm->_map->destX = pressedMapX; + gobDestX = pressedMapX; } } - if ((map_itemsMap[gob_pressedMapY + - 1][gob_pressedMapX] & 0xff00) == - (map_itemsMap[gob_pressedMapY][gob_pressedMapX] & + if ((_vm->_map->itemsMap[pressedMapY + + 1][pressedMapX] & 0xff00) == + (_vm->_map->itemsMap[pressedMapY][pressedMapX] & 0xff00)) { - gob_pressedMapY++; - map_destY = gob_pressedMapY; - gob_gobDestY = gob_pressedMapY; + pressedMapY++; + _vm->_map->destY = pressedMapY; + gobDestY = pressedMapY; } } else { - if (map_itemPoses[gob_destItemId].orient == 4) { - if ((map_itemsMap[gob_pressedMapY] - [gob_pressedMapX - 1]) == - (map_itemsMap[gob_pressedMapY] - [gob_pressedMapX])) { - gob_pressedMapX--; - map_destX = gob_pressedMapX; - gob_gobDestX = gob_pressedMapX; + if (_vm->_map->itemPoses[destItemId].orient == 4) { + if ((_vm->_map->itemsMap[pressedMapY] + [pressedMapX - 1]) == + (_vm->_map->itemsMap[pressedMapY] + [pressedMapX])) { + pressedMapX--; + _vm->_map->destX = pressedMapX; + gobDestX = pressedMapX; } - } else if (map_itemPoses[gob_destItemId].orient == 0) { - - if ((map_itemsMap[gob_pressedMapY] - [gob_pressedMapX + 1]) == - (map_itemsMap[gob_pressedMapY] - [gob_pressedMapX])) { - gob_pressedMapX++; - map_destX = gob_pressedMapX; - gob_gobDestX = gob_pressedMapX; + } else if (_vm->_map->itemPoses[destItemId].orient == 0) { + + if ((_vm->_map->itemsMap[pressedMapY] + [pressedMapX + 1]) == + (_vm->_map->itemsMap[pressedMapY] + [pressedMapX])) { + pressedMapX++; + _vm->_map->destX = pressedMapX; + gobDestX = pressedMapX; } } - if ((map_itemsMap[gob_pressedMapY + - 1][gob_pressedMapX]) == - (map_itemsMap[gob_pressedMapY][gob_pressedMapX])) { - gob_pressedMapY++; - map_destY = gob_pressedMapY; - gob_gobDestY = gob_pressedMapY; + if ((_vm->_map->itemsMap[pressedMapY + + 1][pressedMapX]) == + (_vm->_map->itemsMap[pressedMapY][pressedMapX])) { + pressedMapY++; + _vm->_map->destY = pressedMapY; + gobDestY = pressedMapY; } } - if (gob_gobAction == 4 && gob_destActionItem != 0 && - gob_itemToObject[gob_destActionItem] != -1 && - gob_objects[gob_itemToObject[gob_destActionItem]]-> + if (gobAction == 4 && destActionItem != 0 && + itemToObject[destActionItem] != -1 && + objects[itemToObject[destActionItem]]-> pickable == 1) { itemDesc = - gob_objects[gob_itemToObject[gob_destActionItem]]; + objects[itemToObject[destActionItem]]; itemDesc->animation = itemDesc->stateMach[itemDesc->state][0]->animation; @@ -934,11 +946,11 @@ void gob_targetItem(void) { itemDesc->stateMach[itemDesc->state][itemDesc-> stateColumn]->layer; - scen_updateAnim(layer, 0, itemDesc->animation, 0, + _vm->_scenery->updateAnim(layer, 0, itemDesc->animation, 0, itemDesc->xPos, itemDesc->yPos, 0); - tmpX = (scen_toRedrawRight + scen_toRedrawLeft) / 2; - tmpY = scen_toRedrawBottom; + tmpX = (_vm->_scenery->toRedrawRight + _vm->_scenery->toRedrawLeft) / 2; + tmpY = _vm->_scenery->toRedrawBottom; tmpPosY = tmpY / 6; if ((tmpY % 3) < 3 && tmpPosY > 0) @@ -948,358 +960,358 @@ void gob_targetItem(void) { if ((tmpX % 12) < 6 && tmpPosX > 0) tmpPosX--; - if (map_itemPoses[gob_destActionItem].orient == 0 || - map_itemPoses[gob_destActionItem].orient == -1) { + if (_vm->_map->itemPoses[destActionItem].orient == 0 || + _vm->_map->itemPoses[destActionItem].orient == -1) { tmpPosX++; } - if (map_passMap[tmpPosY][tmpPosX] == 1) { - gob_pressedMapX = tmpPosX; - map_destX = tmpPosX; - gob_gobDestX = tmpPosX; + if (_vm->_map->passMap[tmpPosY][tmpPosX] == 1) { + pressedMapX = tmpPosX; + _vm->_map->destX = tmpPosX; + gobDestX = tmpPosX; - gob_pressedMapY = tmpPosY; - map_destY = tmpPosY; - gob_gobDestY = tmpPosY; + pressedMapY = tmpPosY; + _vm->_map->destY = tmpPosY; + gobDestY = tmpPosY; } } } } -void gob_initiateMove(void) { - map_findNearestToDest(); - map_findNearestToGob(); - map_optimizePoints(); +void Goblin::initiateMove(void) { + _vm->_map->findNearestToDest(); + _vm->_map->findNearestToGob(); + _vm->_map->optimizePoints(); - gob_pathExistence = map_checkDirectPath(map_curGoblinX, map_curGoblinY, - gob_pressedMapX, gob_pressedMapY); + pathExistence = _vm->_map->checkDirectPath(_vm->_map->curGoblinX, _vm->_map->curGoblinY, + pressedMapX, pressedMapY); - if (gob_pathExistence == 3) { - if (map_checkLongPath(map_curGoblinX, map_curGoblinY, - gob_pressedMapX, gob_pressedMapY, - map_nearestWayPoint, map_nearestDest) == 0) { - gob_pathExistence = 0; + if (pathExistence == 3) { + if (_vm->_map->checkLongPath(_vm->_map->curGoblinX, _vm->_map->curGoblinY, + pressedMapX, pressedMapY, + _vm->_map->nearestWayPoint, _vm->_map->nearestDest) == 0) { + pathExistence = 0; } else { - map_destX = map_wayPoints[map_nearestWayPoint].x; - map_destY = map_wayPoints[map_nearestWayPoint].y; + _vm->_map->destX = _vm->_map->wayPoints[_vm->_map->nearestWayPoint].x; + _vm->_map->destY = _vm->_map->wayPoints[_vm->_map->nearestWayPoint].y; } } } -void gob_moveFindItem(int16 posX, int16 posY) { +void Goblin::moveFindItem(int16 posX, int16 posY) { int16 i; - if (gob_gobAction == 3 || gob_gobAction == 4) { + if (gobAction == 3 || gobAction == 4) { for (i = 0; i < 20; i++) { - if (gob_objects[i] == 0) + if (objects[i] == 0) continue; - if (gob_objects[i]->type != 0) + if (objects[i]->type != 0) continue; - if (gob_objects[i]->left > posX) + if (objects[i]->left > posX) continue; - if (gob_objects[i]->right < posX) + if (objects[i]->right < posX) continue; - if (gob_objects[i]->top > posY) + if (objects[i]->top > posY) continue; - if (gob_objects[i]->bottom < posY) + if (objects[i]->bottom < posY) continue; - if (gob_objects[i]->right - gob_objects[i]->left < 40) + if (objects[i]->right - objects[i]->left < 40) posX = - (gob_objects[i]->left + - gob_objects[i]->right) / 2; + (objects[i]->left + + objects[i]->right) / 2; - if (gob_objects[i]->bottom - gob_objects[i]->top < 40) + if (objects[i]->bottom - objects[i]->top < 40) posY = - (gob_objects[i]->top + - gob_objects[i]->bottom) / 2; + (objects[i]->top + + objects[i]->bottom) / 2; break; } - gob_pressedMapX = posX / 12; - gob_pressedMapY = posY / 6; + pressedMapX = posX / 12; + pressedMapY = posY / 6; - if (map_itemsMap[gob_pressedMapY][gob_pressedMapX] == 0 + if (_vm->_map->itemsMap[pressedMapY][pressedMapX] == 0 && i < 20) { - if (map_itemsMap[gob_pressedMapY + - 1][gob_pressedMapX] != 0) { - gob_pressedMapY++; - } else if (map_itemsMap[gob_pressedMapY + - 1][gob_pressedMapX + 1] != 0) { - gob_pressedMapX++; - gob_pressedMapY++; + if (_vm->_map->itemsMap[pressedMapY + + 1][pressedMapX] != 0) { + pressedMapY++; + } else if (_vm->_map->itemsMap[pressedMapY + + 1][pressedMapX + 1] != 0) { + pressedMapX++; + pressedMapY++; } else - if (map_itemsMap[gob_pressedMapY][gob_pressedMapX + + if (_vm->_map->itemsMap[pressedMapY][pressedMapX + 1] != 0) { - gob_pressedMapX++; - } else if (map_itemsMap[gob_pressedMapY - - 1][gob_pressedMapX + 1] != 0) { - gob_pressedMapX++; - gob_pressedMapY--; - } else if (map_itemsMap[gob_pressedMapY - - 1][gob_pressedMapX] != 0) { - gob_pressedMapY--; - } else if (map_itemsMap[gob_pressedMapY - - 1][gob_pressedMapX - 1] != 0) { - gob_pressedMapY--; - gob_pressedMapX--; + pressedMapX++; + } else if (_vm->_map->itemsMap[pressedMapY - + 1][pressedMapX + 1] != 0) { + pressedMapX++; + pressedMapY--; + } else if (_vm->_map->itemsMap[pressedMapY - + 1][pressedMapX] != 0) { + pressedMapY--; + } else if (_vm->_map->itemsMap[pressedMapY - + 1][pressedMapX - 1] != 0) { + pressedMapY--; + pressedMapX--; } else - if (map_itemsMap[gob_pressedMapY][gob_pressedMapX - + if (_vm->_map->itemsMap[pressedMapY][pressedMapX - 1] != 0) { - gob_pressedMapX--; - } else if (map_itemsMap[gob_pressedMapY + - 1][gob_pressedMapX - 1] != 0) { - gob_pressedMapX--; - gob_pressedMapY++; + pressedMapX--; + } else if (_vm->_map->itemsMap[pressedMapY + + 1][pressedMapX - 1] != 0) { + pressedMapX--; + pressedMapY++; } } } else { - gob_pressedMapX = posX / 12; - gob_pressedMapY = posY / 6; + pressedMapX = posX / 12; + pressedMapY = posY / 6; } } -void gob_moveCheckSelect(int16 framesCount, Gob_Object * gobDesc, int16 *pGobIndex, +void Goblin::moveCheckSelect(int16 framesCount, Gob_Object * gobDesc, int16 *pGobIndex, int16 *nextAct) { - if (gobDesc->right > inter_mouseX && - gobDesc->left < inter_mouseX && - gobDesc->bottom > inter_mouseY && - gobDesc->bottom - 10 < inter_mouseY && gob_gobAction == 0) { + if (gobDesc->right > _vm->_global->inter_mouseX && + gobDesc->left < _vm->_global->inter_mouseX && + gobDesc->bottom > _vm->_global->inter_mouseY && + gobDesc->bottom - 10 < _vm->_global->inter_mouseY && gobAction == 0) { if (gobDesc->curLookDir & 4) *nextAct = 16; else *nextAct = 23; gobDesc->curFrame = framesCount - 1; - gob_pathExistence = 0; + pathExistence = 0; } else { - *pGobIndex = gob_peekGoblin(gobDesc); + *pGobIndex = peekGoblin(gobDesc); if (*pGobIndex != 0) { - gob_pathExistence = 0; - } else if (map_curGoblinX == gob_pressedMapX && - map_curGoblinY == gob_pressedMapY) { + pathExistence = 0; + } else if (_vm->_map->curGoblinX == pressedMapX && + _vm->_map->curGoblinY == pressedMapY) { - if (gob_gobAction != 0) - gob_readyToAct = 1; + if (gobAction != 0) + readyToAct = 1; - gob_pathExistence = 0; + pathExistence = 0; } } } -void gob_moveInitStep(int16 framesCount, int16 action, int16 cont, +void Goblin::moveInitStep(int16 framesCount, int16 action, int16 cont, Gob_Object *gobDesc, int16 *pGobIndex, int16 *pNextAct) { int16 posX; int16 posY; - if (cont != 0 && gob_goesAtTarget == 0 && - gob_readyToAct == 0 && VAR(59) == 0 && + if (cont != 0 && goesAtTarget == 0 && + readyToAct == 0 && VAR(59) == 0 && gobDesc->type != 1 && gobDesc->state != 10 && gobDesc->state != 11) { if (gobDesc->state >= 40) { gobDesc->curFrame = framesCount - 1; } - gob_gobAction = action; - gob_forceNextState[0] = -1; - gob_forceNextState[1] = -1; - gob_forceNextState[2] = -1; + gobAction = action; + forceNextState[0] = -1; + forceNextState[1] = -1; + forceNextState[2] = -1; if (action == 3) { - posX = inter_mouseX + 6; - posY = inter_mouseY + 7; + posX = _vm->_global->inter_mouseX + 6; + posY = _vm->_global->inter_mouseY + 7; } else if (action == 4) { - posX = inter_mouseX + 7; - posY = inter_mouseY + 12; + posX = _vm->_global->inter_mouseX + 7; + posY = _vm->_global->inter_mouseY + 12; } else { - posX = inter_mouseX; - posY = inter_mouseY; + posX = _vm->_global->inter_mouseX; + posY = _vm->_global->inter_mouseY; } - gob_moveFindItem(posX, posY); - gob_adjustDest(posX, posY); - gob_adjustTarget(); + moveFindItem(posX, posY); + adjustDest(posX, posY); + adjustTarget(); - map_destX = gob_pressedMapX; - gob_gobDestX = gob_pressedMapX; + _vm->_map->destX = pressedMapX; + gobDestX = pressedMapX; - map_destY = gob_pressedMapY; - gob_gobDestY = gob_pressedMapY; + _vm->_map->destY = pressedMapY; + gobDestY = pressedMapY; - gob_targetDummyItem(gobDesc); + targetDummyItem(gobDesc); - gob_targetItem(); - gob_initiateMove(); + targetItem(); + initiateMove(); - gob_moveCheckSelect(framesCount, gobDesc, pGobIndex, pNextAct); + moveCheckSelect(framesCount, gobDesc, pGobIndex, pNextAct); } else { - if (gob_readyToAct != 0 && - (map_curGoblinX != gob_pressedMapX || - map_curGoblinY != gob_pressedMapY)) - gob_readyToAct = 0; + if (readyToAct != 0 && + (_vm->_map->curGoblinX != pressedMapX || + _vm->_map->curGoblinY != pressedMapY)) + readyToAct = 0; if (gobDesc->type == 1) { - *pGobIndex = gob_peekGoblin(gobDesc); + *pGobIndex = peekGoblin(gobDesc); } } } -void gob_moveTreatRopeStairs(Gob_Object *gobDesc) { - if (gob_currentGoblin != 1) +void Goblin::moveTreatRopeStairs(Gob_Object *gobDesc) { + if (currentGoblin != 1) return; if (gobDesc->nextState == 28 - && map_passMap[map_curGoblinY - 1][map_curGoblinX] == 6) { - gob_forceNextState[0] = 28; - gob_forceNextState[1] = -1; + && _vm->_map->passMap[_vm->_map->curGoblinY - 1][_vm->_map->curGoblinX] == 6) { + forceNextState[0] = 28; + forceNextState[1] = -1; } if (gobDesc->nextState == 29 - && map_passMap[map_curGoblinY + 1][map_curGoblinX] == 6) { - gob_forceNextState[0] = 29; - gob_forceNextState[1] = -1; + && _vm->_map->passMap[_vm->_map->curGoblinY + 1][_vm->_map->curGoblinX] == 6) { + forceNextState[0] = 29; + forceNextState[1] = -1; } if ((gobDesc->nextState == 28 || gobDesc->nextState == 29 || gobDesc->nextState == 20) - && map_passMap[map_curGoblinY][map_curGoblinX] == 6) { + && _vm->_map->passMap[_vm->_map->curGoblinY][_vm->_map->curGoblinX] == 6) { if ((gobDesc->curLookDir == 0 || gobDesc->curLookDir == 4 || gobDesc->curLookDir == 2) - && map_passMap[map_curGoblinY - 1][map_curGoblinX] == 6) { - gob_forceNextState[0] = 28; - gob_forceNextState[1] = -1; + && _vm->_map->passMap[_vm->_map->curGoblinY - 1][_vm->_map->curGoblinX] == 6) { + forceNextState[0] = 28; + forceNextState[1] = -1; } else if ((gobDesc->curLookDir == 0 || gobDesc->curLookDir == 4 || gobDesc->curLookDir == 6) - && map_passMap[map_curGoblinY + 1][map_curGoblinX] == 6) { - gob_forceNextState[0] = 29; - gob_forceNextState[1] = -1; + && _vm->_map->passMap[_vm->_map->curGoblinY + 1][_vm->_map->curGoblinX] == 6) { + forceNextState[0] = 29; + forceNextState[1] = -1; } } if (gobDesc->nextState == 8 - && map_passMap[map_curGoblinY - 1][map_curGoblinX] == 3) { - gob_forceNextState[0] = 8; - gob_forceNextState[1] = -1; + && _vm->_map->passMap[_vm->_map->curGoblinY - 1][_vm->_map->curGoblinX] == 3) { + forceNextState[0] = 8; + forceNextState[1] = -1; } if (gobDesc->nextState == 9 - && map_passMap[map_curGoblinY + 1][map_curGoblinX] == 3) { - gob_forceNextState[0] = 9; - gob_forceNextState[1] = -1; + && _vm->_map->passMap[_vm->_map->curGoblinY + 1][_vm->_map->curGoblinX] == 3) { + forceNextState[0] = 9; + forceNextState[1] = -1; } if (gobDesc->nextState == 20 - && map_passMap[map_curGoblinY][map_curGoblinX] == 3) { + && _vm->_map->passMap[_vm->_map->curGoblinY][_vm->_map->curGoblinX] == 3) { if ((gobDesc->curLookDir == 0 || gobDesc->curLookDir == 4 || gobDesc->curLookDir == 2) - && map_passMap[map_curGoblinY - 1][map_curGoblinX] == 3) { - gob_forceNextState[0] = 8; - gob_forceNextState[1] = -1; + && _vm->_map->passMap[_vm->_map->curGoblinY - 1][_vm->_map->curGoblinX] == 3) { + forceNextState[0] = 8; + forceNextState[1] = -1; } else if ((gobDesc->curLookDir == 0 || gobDesc->curLookDir == 4 || gobDesc->curLookDir == 6) - && map_passMap[map_curGoblinY + 1][map_curGoblinX] == 3) { - gob_forceNextState[0] = 9; - gob_forceNextState[1] = -1; + && _vm->_map->passMap[_vm->_map->curGoblinY + 1][_vm->_map->curGoblinX] == 3) { + forceNextState[0] = 9; + forceNextState[1] = -1; } } } -void gob_movePathFind(Gob_Object *gobDesc, int16 nextAct) { - if (gob_pathExistence == 1) { - map_curGoblinX = gob_gobPositions[gob_currentGoblin].x; - map_curGoblinY = gob_gobPositions[gob_currentGoblin].y; +void Goblin::movePathFind(Gob_Object *gobDesc, int16 nextAct) { + if (pathExistence == 1) { + _vm->_map->curGoblinX = gobPositions[currentGoblin].x; + _vm->_map->curGoblinY = gobPositions[currentGoblin].y; - if (map_curGoblinX == gob_pressedMapX && - map_curGoblinY == gob_pressedMapY && gob_gobAction != 0) { - gob_readyToAct = 1; - gob_pathExistence = 0; + if (_vm->_map->curGoblinX == pressedMapX && + _vm->_map->curGoblinY == pressedMapY && gobAction != 0) { + readyToAct = 1; + pathExistence = 0; } - nextAct = map_getDirection(map_curGoblinX, map_curGoblinY, - map_destX, map_destY); + nextAct = _vm->_map->getDirection(_vm->_map->curGoblinX, _vm->_map->curGoblinY, + _vm->_map->destX, _vm->_map->destY); if (nextAct == 0) - gob_pathExistence = 0; - } else if (gob_pathExistence == 3) { - map_curGoblinX = gob_gobPositions[gob_currentGoblin].x; - map_curGoblinY = gob_gobPositions[gob_currentGoblin].y; - - if (map_curGoblinX == gob_gobDestX && map_curGoblinY == gob_gobDestY) { - gob_pathExistence = 1; - map_destX = gob_pressedMapX; - map_destY = gob_pressedMapY; + pathExistence = 0; + } else if (pathExistence == 3) { + _vm->_map->curGoblinX = gobPositions[currentGoblin].x; + _vm->_map->curGoblinY = gobPositions[currentGoblin].y; + + if (_vm->_map->curGoblinX == gobDestX && _vm->_map->curGoblinY == gobDestY) { + pathExistence = 1; + _vm->_map->destX = pressedMapX; + _vm->_map->destY = pressedMapY; } else { - if (map_checkDirectPath(map_curGoblinX, map_curGoblinY, - gob_gobDestX, gob_gobDestY) == 1) { - map_destX = gob_gobDestX; - map_destY = gob_gobDestY; - } else if (map_curGoblinX == map_destX && map_curGoblinY == map_destY) { + if (_vm->_map->checkDirectPath(_vm->_map->curGoblinX, _vm->_map->curGoblinY, + gobDestX, gobDestY) == 1) { + _vm->_map->destX = gobDestX; + _vm->_map->destY = gobDestY; + } else if (_vm->_map->curGoblinX == _vm->_map->destX && _vm->_map->curGoblinY == _vm->_map->destY) { - if (map_nearestWayPoint > map_nearestDest) { - map_optimizePoints(); + if (_vm->_map->nearestWayPoint > _vm->_map->nearestDest) { + _vm->_map->optimizePoints(); - map_destX = - map_wayPoints[map_nearestWayPoint]. + _vm->_map->destX = + _vm->_map->wayPoints[_vm->_map->nearestWayPoint]. x; - map_destY = - map_wayPoints[map_nearestWayPoint]. + _vm->_map->destY = + _vm->_map->wayPoints[_vm->_map->nearestWayPoint]. y; - if (map_nearestWayPoint > map_nearestDest) - map_nearestWayPoint--; - } else if (map_nearestWayPoint < map_nearestDest) { - map_optimizePoints(); + if (_vm->_map->nearestWayPoint > _vm->_map->nearestDest) + _vm->_map->nearestWayPoint--; + } else if (_vm->_map->nearestWayPoint < _vm->_map->nearestDest) { + _vm->_map->optimizePoints(); - map_destX = - map_wayPoints[map_nearestWayPoint]. + _vm->_map->destX = + _vm->_map->wayPoints[_vm->_map->nearestWayPoint]. x; - map_destY = - map_wayPoints[map_nearestWayPoint]. + _vm->_map->destY = + _vm->_map->wayPoints[_vm->_map->nearestWayPoint]. y; - if (map_nearestWayPoint < map_nearestDest) - map_nearestWayPoint++; + if (_vm->_map->nearestWayPoint < _vm->_map->nearestDest) + _vm->_map->nearestWayPoint++; } else { - if (map_checkDirectPath(map_curGoblinX, - map_curGoblinY, gob_gobDestX, - gob_gobDestY) == 3 && map_passMap[gob_pressedMapY][gob_pressedMapX] != 0) { - map_destX = map_wayPoints[map_nearestWayPoint].x; - map_destY = map_wayPoints[map_nearestWayPoint].y; + if (_vm->_map->checkDirectPath(_vm->_map->curGoblinX, + _vm->_map->curGoblinY, gobDestX, + gobDestY) == 3 && _vm->_map->passMap[pressedMapY][pressedMapX] != 0) { + _vm->_map->destX = _vm->_map->wayPoints[_vm->_map->nearestWayPoint].x; + _vm->_map->destY = _vm->_map->wayPoints[_vm->_map->nearestWayPoint].y; } else { - gob_pathExistence = 1; - map_destX = gob_pressedMapX; - map_destY = gob_pressedMapY; + pathExistence = 1; + _vm->_map->destX = pressedMapX; + _vm->_map->destY = pressedMapY; } } } nextAct = - map_getDirection(map_curGoblinX, map_curGoblinY, - map_destX, map_destY); + _vm->_map->getDirection(_vm->_map->curGoblinX, _vm->_map->curGoblinY, + _vm->_map->destX, _vm->_map->destY); } } - if (gob_readyToAct != 0 && (gob_gobAction == 3 || gob_gobAction == 4)) + if (readyToAct != 0 && (gobAction == 3 || gobAction == 4)) nextAct = 0x4dc8; switch (nextAct) { - case kDirW: - gobDesc->nextState = gob_rotateState(gobDesc->curLookDir, 0); + case Map::kDirW: + gobDesc->nextState = rotateState(gobDesc->curLookDir, 0); break; - case kDirE: - gobDesc->nextState = gob_rotateState(gobDesc->curLookDir, 4); + case Map::kDirE: + gobDesc->nextState = rotateState(gobDesc->curLookDir, 4); break; case 16: @@ -1310,52 +1322,52 @@ void gob_movePathFind(Gob_Object *gobDesc, int16 nextAct) { gobDesc->nextState = 23; break; - case kDirN: - if (map_passMap[map_curGoblinY - 1][map_curGoblinX] == 6 && - gob_currentGoblin != 1) { - gob_pathExistence = 0; + case Map::kDirN: + if (_vm->_map->passMap[_vm->_map->curGoblinY - 1][_vm->_map->curGoblinX] == 6 && + currentGoblin != 1) { + pathExistence = 0; break; } - if (map_passMap[map_curGoblinY][map_curGoblinX] == 3) { + if (_vm->_map->passMap[_vm->_map->curGoblinY][_vm->_map->curGoblinX] == 3) { gobDesc->nextState = 8; break; } - if (map_passMap[map_curGoblinY][map_curGoblinX] == 6 && - gob_currentGoblin == 1) { + if (_vm->_map->passMap[_vm->_map->curGoblinY][_vm->_map->curGoblinX] == 6 && + currentGoblin == 1) { gobDesc->nextState = 28; break; } - gobDesc->nextState = gob_rotateState(gobDesc->curLookDir, 2); + gobDesc->nextState = rotateState(gobDesc->curLookDir, 2); break; - case kDirS: - if (map_passMap[map_curGoblinY + 1][map_curGoblinX] == 6 && - gob_currentGoblin != 1) { - gob_pathExistence = 0; + case Map::kDirS: + if (_vm->_map->passMap[_vm->_map->curGoblinY + 1][_vm->_map->curGoblinX] == 6 && + currentGoblin != 1) { + pathExistence = 0; break; } - if (map_passMap[map_curGoblinY][map_curGoblinX] == 3) { + if (_vm->_map->passMap[_vm->_map->curGoblinY][_vm->_map->curGoblinX] == 3) { gobDesc->nextState = 9; break; } - if (map_passMap[map_curGoblinY][map_curGoblinX] == 6 && - gob_currentGoblin == 1) { + if (_vm->_map->passMap[_vm->_map->curGoblinY][_vm->_map->curGoblinX] == 6 && + currentGoblin == 1) { gobDesc->nextState = 29; break; } - gobDesc->nextState = gob_rotateState(gobDesc->curLookDir, 6); + gobDesc->nextState = rotateState(gobDesc->curLookDir, 6); break; - case kDirSE: - if (map_passMap[map_curGoblinY + 1][map_curGoblinX + 1] == 6 && - gob_currentGoblin != 1) { - gob_pathExistence = 0; + case Map::kDirSE: + if (_vm->_map->passMap[_vm->_map->curGoblinY + 1][_vm->_map->curGoblinX + 1] == 6 && + currentGoblin != 1) { + pathExistence = 0; break; } @@ -1363,13 +1375,13 @@ void gob_movePathFind(Gob_Object *gobDesc, int16 nextAct) { if (gobDesc->curLookDir == 4) break; - gobDesc->nextState = gob_rotateState(gobDesc->curLookDir, 4); + gobDesc->nextState = rotateState(gobDesc->curLookDir, 4); break; - case kDirSW: - if (map_passMap[map_curGoblinY + 1][map_curGoblinX - 1] == 6 && - gob_currentGoblin != 1) { - gob_pathExistence = 0; + case Map::kDirSW: + if (_vm->_map->passMap[_vm->_map->curGoblinY + 1][_vm->_map->curGoblinX - 1] == 6 && + currentGoblin != 1) { + pathExistence = 0; break; } @@ -1377,13 +1389,13 @@ void gob_movePathFind(Gob_Object *gobDesc, int16 nextAct) { if (gobDesc->curLookDir == 0) break; - gobDesc->nextState = gob_rotateState(gobDesc->curLookDir, 0); + gobDesc->nextState = rotateState(gobDesc->curLookDir, 0); break; - case kDirNW: - if (map_passMap[map_curGoblinY - 1][map_curGoblinX - 1] == 6 && - gob_currentGoblin != 1) { - gob_pathExistence = 0; + case Map::kDirNW: + if (_vm->_map->passMap[_vm->_map->curGoblinY - 1][_vm->_map->curGoblinX - 1] == 6 && + currentGoblin != 1) { + pathExistence = 0; break; } @@ -1391,13 +1403,13 @@ void gob_movePathFind(Gob_Object *gobDesc, int16 nextAct) { if (gobDesc->curLookDir == 0) break; - gobDesc->nextState = gob_rotateState(gobDesc->curLookDir, 0); + gobDesc->nextState = rotateState(gobDesc->curLookDir, 0); break; - case kDirNE: - if (map_passMap[map_curGoblinY - 1][map_curGoblinX + 1] == 6 && - gob_currentGoblin != 1) { - gob_pathExistence = 0; + case Map::kDirNE: + if (_vm->_map->passMap[_vm->_map->curGoblinY - 1][_vm->_map->curGoblinX + 1] == 6 && + currentGoblin != 1) { + pathExistence = 0; break; } @@ -1405,58 +1417,58 @@ void gob_movePathFind(Gob_Object *gobDesc, int16 nextAct) { if (gobDesc->curLookDir == 4) break; - gobDesc->nextState = gob_rotateState(gobDesc->curLookDir, 4); + gobDesc->nextState = rotateState(gobDesc->curLookDir, 4); break; case 0x4dc8: - if (gob_currentGoblin == 0 && gob_gobAction == 3 - && gob_itemIndInPocket == -1) { - gob_destItemId = -1; - gob_readyToAct = 0; + if (currentGoblin == 0 && gobAction == 3 + && itemIndInPocket == -1) { + destItemId = -1; + readyToAct = 0; break; } - if (gob_currentGoblin == 0 && gob_gobAction == 4 && - gob_itemIndInPocket == -1 && gob_destActionItem == 0) { + if (currentGoblin == 0 && gobAction == 4 && + itemIndInPocket == -1 && destActionItem == 0) { gobDesc->multState = 104; - gob_destItemId = -1; - gob_readyToAct = 0; + destItemId = -1; + readyToAct = 0; break; } - if (gob_currentGoblin == 0 && gob_gobAction == 4 && - gob_itemIndInPocket == -1 && gob_destActionItem != 0 && - gob_itemToObject[gob_destActionItem] != -1 && - gob_objects[gob_itemToObject[gob_destActionItem]]-> + if (currentGoblin == 0 && gobAction == 4 && + itemIndInPocket == -1 && destActionItem != 0 && + itemToObject[destActionItem] != -1 && + objects[itemToObject[destActionItem]]-> pickable == 0) { gobDesc->multState = 104; - gob_destItemId = -1; - gob_readyToAct = 0; + destItemId = -1; + readyToAct = 0; break; } - switch (map_itemPoses[gob_destActionItem].orient) { + switch (_vm->_map->itemPoses[destActionItem].orient) { case 0: case -4: gobDesc->nextState = 10; gobDesc->curLookDir = 0; - gob_destItemId = -1; + destItemId = -1; break; case -1: case 4: gobDesc->nextState = 11; gobDesc->curLookDir = 4; - gob_destItemId = -1; + destItemId = -1; break; } break; default: - if (map_passMap[map_curGoblinY][map_curGoblinX] == 3 || - (map_passMap[map_curGoblinY][map_curGoblinX] == 6 - && gob_currentGoblin == 1)) { + if (_vm->_map->passMap[_vm->_map->curGoblinY][_vm->_map->curGoblinX] == 3 || + (_vm->_map->passMap[_vm->_map->curGoblinY][_vm->_map->curGoblinX] == 6 + && currentGoblin == 1)) { gobDesc->nextState = 20; break; } @@ -1477,19 +1489,19 @@ void gob_movePathFind(Gob_Object *gobDesc, int16 nextAct) { return; } -void gob_moveAdvance(Gob_Object *gobDesc, int16 nextAct, int16 framesCount) { +void Goblin::moveAdvance(Gob_Object *gobDesc, int16 nextAct, int16 framesCount) { int16 i; int16 newX; int16 newY; int16 flag; - gob_movePathFind(gobDesc, nextAct); + movePathFind(gobDesc, nextAct); gobDesc->curFrame++; if (gobDesc->curFrame == 1) gobDesc->actionStartState = gobDesc->state; - if (gob_goesAtTarget == 0 + if (goesAtTarget == 0 && gobDesc->stateMach == gobDesc->realStateMach) { switch (gobDesc->state) { case 0: @@ -1511,7 +1523,7 @@ void gob_moveAdvance(Gob_Object *gobDesc, int16 nextAct, int16 framesCount) { break; case 28: - if (gob_currentGoblin != 1) + if (currentGoblin != 1) break; gobDesc->curLookDir = 2; break; @@ -1525,7 +1537,7 @@ void gob_moveAdvance(Gob_Object *gobDesc, int16 nextAct, int16 framesCount) { break; case 29: - if (gob_currentGoblin != 1) + if (currentGoblin != 1) break; gobDesc->curLookDir = 6; @@ -1544,27 +1556,27 @@ void gob_moveAdvance(Gob_Object *gobDesc, int16 nextAct, int16 framesCount) { if (gobDesc->state >= 0 && gobDesc->state < 10 && gobDesc->stateMach == gobDesc->realStateMach && (gobDesc->curFrame == 3 || gobDesc->curFrame == 6)) { - snd_speakerOn(10 * util_getRandom(3) + 50, 5); + _vm->_snd->speakerOn(10 * _vm->_util->getRandom(3) + 50, 5); } - if (gob_currentGoblin == 0 + if (currentGoblin == 0 && gobDesc->stateMach == gobDesc->realStateMach && (gobDesc->state == 10 || gobDesc->state == 11) && gobDesc->curFrame == 9) { - snd_stopSound(0); - if (gob_itemIndInPocket != -1) { - snd_playSample(gob_soundData[14], 1, 9000); + _vm->_snd->stopSound(0); + if (itemIndInPocket != -1) { + _vm->_snd->playSample(soundData[14], 1, 9000); } - if (gob_itemIndInPocket == -1) { - snd_playSample(gob_soundData[14], 1, 5000); + if (itemIndInPocket == -1) { + _vm->_snd->playSample(soundData[14], 1, 5000); } } - if (gob_boreCounter++ == 120) { - gob_boreCounter = 0; + if (boreCounter++ == 120) { + boreCounter = 0; for (i = 0; i < 3; i++) - gob_showBoredom(i); + showBoredom(i); } if (gobDesc->multState != -1 && gobDesc->curFrame == framesCount && @@ -1573,14 +1585,14 @@ void gob_moveAdvance(Gob_Object *gobDesc, int16 nextAct, int16 framesCount) { gobDesc->multState = -1; newX = - scen_animations[gobDesc->animation]. - layers[gob_gobStateLayer]->animDeltaX + gobDesc->xPos; + _vm->_scenery->animations[gobDesc->animation]. + layers[gobStateLayer]->animDeltaX + gobDesc->xPos; newY = - scen_animations[gobDesc->animation]. - layers[gob_gobStateLayer]->animDeltaY + gobDesc->yPos; + _vm->_scenery->animations[gobDesc->animation]. + layers[gobStateLayer]->animDeltaY + gobDesc->yPos; - gob_gobStateLayer = gob_nextLayer(gobDesc); + gobStateLayer = nextLayer(gobDesc); gobDesc->xPos = newX; gobDesc->yPos = newY; @@ -1588,180 +1600,180 @@ void gob_moveAdvance(Gob_Object *gobDesc, int16 nextAct, int16 framesCount) { if (gobDesc->curFrame == 3 && gobDesc->stateMach == gobDesc->realStateMach && (gobDesc->state < 10 || - (gob_currentGoblin == 1 && (gobDesc->state == 28 + (currentGoblin == 1 && (gobDesc->state == 28 || gobDesc->state == 29)) )) { flag = 0; - if (gob_forceNextState[0] != -1) { - gobDesc->nextState = gob_forceNextState[0]; + if (forceNextState[0] != -1) { + gobDesc->nextState = forceNextState[0]; for (i = 0; i < 9; i++) - gob_forceNextState[i] = - gob_forceNextState[i + 1]; + forceNextState[i] = + forceNextState[i + 1]; } - map_curGoblinX = gob_gobPositions[gob_currentGoblin].x; - map_curGoblinY = gob_gobPositions[gob_currentGoblin].y; + _vm->_map->curGoblinX = gobPositions[currentGoblin].x; + _vm->_map->curGoblinY = gobPositions[currentGoblin].y; if (gobDesc->nextState != gobDesc->state) { - gob_gobStateLayer = gob_nextLayer(gobDesc); + gobStateLayer = nextLayer(gobDesc); flag = 1; } switch (gobDesc->state) { case 0: - gob_gobPositions[gob_currentGoblin].x--; + gobPositions[currentGoblin].x--; break; case 2: case 8: - gob_gobPositions[gob_currentGoblin].y--; + gobPositions[currentGoblin].y--; break; case 4: - gob_gobPositions[gob_currentGoblin].x++; + gobPositions[currentGoblin].x++; break; case 6: case 9: - gob_gobPositions[gob_currentGoblin].y++; + gobPositions[currentGoblin].y++; break; case 1: - gob_gobPositions[gob_currentGoblin].x--; - gob_gobPositions[gob_currentGoblin].y--; + gobPositions[currentGoblin].x--; + gobPositions[currentGoblin].y--; break; case 3: - gob_gobPositions[gob_currentGoblin].x++; - gob_gobPositions[gob_currentGoblin].y--; + gobPositions[currentGoblin].x++; + gobPositions[currentGoblin].y--; break; case 5: - gob_gobPositions[gob_currentGoblin].x++; - gob_gobPositions[gob_currentGoblin].y++; + gobPositions[currentGoblin].x++; + gobPositions[currentGoblin].y++; break; case 7: - gob_gobPositions[gob_currentGoblin].x--; - gob_gobPositions[gob_currentGoblin].y++; + gobPositions[currentGoblin].x--; + gobPositions[currentGoblin].y++; break; case 38: - gob_gobPositions[gob_currentGoblin].y++; + gobPositions[currentGoblin].y++; break; } - if (gob_currentGoblin == 1) { + if (currentGoblin == 1) { if (gobDesc->state == 28) - gob_gobPositions[1].y--; + gobPositions[1].y--; if (gobDesc->state == 29) - gob_gobPositions[1].y++; + gobPositions[1].y++; } if (flag != 0) { - scen_updateAnim(gob_gobStateLayer, 0, + _vm->_scenery->updateAnim(gobStateLayer, 0, gobDesc->animation, 0, gobDesc->xPos, gobDesc->yPos, 0); gobDesc->yPos = - (map_curGoblinY + 1) * 6 - - (scen_toRedrawBottom - scen_animTop); + (_vm->_map->curGoblinY + 1) * 6 - + (_vm->_scenery->toRedrawBottom - _vm->_scenery->animTop); gobDesc->xPos = - map_curGoblinX * 12 - (scen_toRedrawLeft - - scen_animLeft); + _vm->_map->curGoblinX * 12 - (_vm->_scenery->toRedrawLeft - + _vm->_scenery->animLeft); } if ((gobDesc->state == 10 || gobDesc->state == 11) - && gob_currentGoblin != 0) - gob_goesAtTarget = 1; + && currentGoblin != 0) + goesAtTarget = 1; } if (gobDesc->curFrame != framesCount) return; - if (gob_forceNextState[0] != -1) { - gobDesc->nextState = gob_forceNextState[0]; + if (forceNextState[0] != -1) { + gobDesc->nextState = forceNextState[0]; for (i = 0; i < 10; i++) - gob_forceNextState[i] = - gob_forceNextState[i + 1]; + forceNextState[i] = + forceNextState[i + 1]; } - map_curGoblinX = gob_gobPositions[gob_currentGoblin].x; - map_curGoblinY = gob_gobPositions[gob_currentGoblin].y; + _vm->_map->curGoblinX = gobPositions[currentGoblin].x; + _vm->_map->curGoblinY = gobPositions[currentGoblin].y; - gob_gobStateLayer = gob_nextLayer(gobDesc); + gobStateLayer = nextLayer(gobDesc); if (gobDesc->stateMach == gobDesc->realStateMach) { switch (gobDesc->nextState) { case 0: - gob_gobPositions[gob_currentGoblin].x--; + gobPositions[currentGoblin].x--; break; case 2: case 8: - gob_gobPositions[gob_currentGoblin].y--; + gobPositions[currentGoblin].y--; break; case 4: - gob_gobPositions[gob_currentGoblin].x++; + gobPositions[currentGoblin].x++; break; case 6: case 9: - gob_gobPositions[gob_currentGoblin].y++; + gobPositions[currentGoblin].y++; break; case 1: - gob_gobPositions[gob_currentGoblin].x--; - gob_gobPositions[gob_currentGoblin].y--; + gobPositions[currentGoblin].x--; + gobPositions[currentGoblin].y--; break; case 3: - gob_gobPositions[gob_currentGoblin].x++; - gob_gobPositions[gob_currentGoblin].y--; + gobPositions[currentGoblin].x++; + gobPositions[currentGoblin].y--; break; case 5: - gob_gobPositions[gob_currentGoblin].x++; - gob_gobPositions[gob_currentGoblin].y++; + gobPositions[currentGoblin].x++; + gobPositions[currentGoblin].y++; break; case 7: - gob_gobPositions[gob_currentGoblin].x--; - gob_gobPositions[gob_currentGoblin].y++; + gobPositions[currentGoblin].x--; + gobPositions[currentGoblin].y++; break; case 38: - gob_gobPositions[gob_currentGoblin].y++; + gobPositions[currentGoblin].y++; break; } - if (gob_currentGoblin == 1) { + if (currentGoblin == 1) { if (gobDesc->nextState == 28) - gob_gobPositions[1].y--; + gobPositions[1].y--; if (gobDesc->nextState == 29) - gob_gobPositions[1].y++; + gobPositions[1].y++; } } - scen_updateAnim(gob_gobStateLayer, 0, gobDesc->animation, 0, + _vm->_scenery->updateAnim(gobStateLayer, 0, gobDesc->animation, 0, gobDesc->xPos, gobDesc->yPos, 0); gobDesc->yPos = - (map_curGoblinY + 1) * 6 - (scen_toRedrawBottom - - scen_animTop); + (_vm->_map->curGoblinY + 1) * 6 - (_vm->_scenery->toRedrawBottom - + _vm->_scenery->animTop); gobDesc->xPos = - map_curGoblinX * 12 - (scen_toRedrawLeft - scen_animLeft); + _vm->_map->curGoblinX * 12 - (_vm->_scenery->toRedrawLeft - _vm->_scenery->animLeft); if ((gobDesc->state == 10 || gobDesc->state == 11) - && gob_currentGoblin != 0) - gob_goesAtTarget = 1; + && currentGoblin != 0) + goesAtTarget = 1; } return; } -int16 gob_doMove(Gob_Object *gobDesc, int16 cont, int16 action) { +int16 Goblin::doMove(Gob_Object *gobDesc, int16 cont, int16 action) { int16 framesCount; int16 nextAct; int16 gobIndex; @@ -1772,423 +1784,423 @@ int16 gob_doMove(Gob_Object *gobDesc, int16 cont, int16 action) { layer = gobDesc->stateMach[gobDesc->state][0]->layer; framesCount = - scen_animations[gobDesc->animation].layers[layer]->framesCount; + _vm->_scenery->animations[gobDesc->animation].layers[layer]->framesCount; if (VAR(59) == 0 && gobDesc->state != 30 && gobDesc->state != 31) { gobDesc->order = (gobDesc->bottom) / 24 + 3; } - if (gob_positionedGob != gob_currentGoblin) { - map_curGoblinX = gob_gobPositions[gob_currentGoblin].x; - map_curGoblinY = gob_gobPositions[gob_currentGoblin].y; + if (positionedGob != currentGoblin) { + _vm->_map->curGoblinX = gobPositions[currentGoblin].x; + _vm->_map->curGoblinY = gobPositions[currentGoblin].y; } - gob_positionedGob = gob_currentGoblin; + positionedGob = currentGoblin; gobDesc->animation = gobDesc->stateMach[gobDesc->state][gobDesc->stateColumn]-> animation; - gob_gobStateLayer = + gobStateLayer = gobDesc->stateMach[gobDesc->state][gobDesc->stateColumn]->layer; - gob_moveInitStep(framesCount, action, cont, gobDesc, &gobIndex, + moveInitStep(framesCount, action, cont, gobDesc, &gobIndex, &nextAct); - gob_moveTreatRopeStairs(gobDesc); - gob_moveAdvance(gobDesc, nextAct, framesCount); + moveTreatRopeStairs(gobDesc); + moveAdvance(gobDesc, nextAct, framesCount); return gobIndex; } -void gob_freeObjects(void) { +void Goblin::freeObjects(void) { int16 i; int16 state; int16 col; for (i = 0; i < 16; i++) { - if (gob_soundData[i] == 0) + if (soundData[i] == 0) continue; - snd_freeSoundData(gob_soundData[i]); - gob_soundData[i] = 0; + _vm->_snd->freeSoundData(soundData[i]); + soundData[i] = 0; } for (i = 0; i < 4; i++) { - if (gob_goblins[i] == 0) + if (goblins[i] == 0) continue; - gob_goblins[i]->stateMach = gob_goblins[i]->realStateMach; + goblins[i]->stateMach = goblins[i]->realStateMach; for (state = 0; state < 40; state++) { for (col = 0; col < 6; col++) { - free(gob_goblins[i]->stateMach[state][col]); - gob_goblins[i]->stateMach[state][col] = 0; + free(goblins[i]->stateMach[state][col]); + goblins[i]->stateMach[state][col] = 0; } } if (i == 3) { for (state = 40; state < 70; state++) { - free(gob_goblins[3]->stateMach[state][0]); - gob_goblins[3]->stateMach[state][0] = 0; + free(goblins[3]->stateMach[state][0]); + goblins[3]->stateMach[state][0] = 0; } } - free(gob_goblins[i]->stateMach); - free(gob_goblins[i]); - gob_goblins[i] = 0; + free(goblins[i]->stateMach); + free(goblins[i]); + goblins[i] = 0; } for (i = 0; i < 20; i++) { - if (gob_objects[i] == 0) + if (objects[i] == 0) continue; - gob_objects[i]->stateMach = gob_objects[i]->realStateMach; + objects[i]->stateMach = objects[i]->realStateMach; for (state = 0; state < 40; state++) { for (col = 0; col < 6; col++) { - free(gob_objects[i]->stateMach[state][col]); - gob_objects[i]->stateMach[state][col] = 0; + free(objects[i]->stateMach[state][col]); + objects[i]->stateMach[state][col] = 0; } } - free(gob_objects[i]->stateMach); - free(gob_objects[i]); - gob_objects[i] = 0; + free(objects[i]->stateMach); + free(objects[i]); + objects[i] = 0; } } -void gob_zeroObjects(void) { +void Goblin::zeroObjects(void) { int16 i; for (i = 0; i < 4; i++) - gob_goblins[i] = 0; + goblins[i] = 0; for (i = 0; i < 20; i++) - gob_objects[i] = 0; + objects[i] = 0; for (i = 0; i < 16; i++) - gob_soundData[i] = 0; + soundData[i] = 0; } -void gob_freeAllObjects(void) { - util_deleteList(gob_objList); - gob_freeObjects(); +void Goblin::freeAllObjects(void) { + _vm->_util->deleteList(objList); + freeObjects(); } -void gob_loadObjects(char *source) { +void Goblin::loadObjects(char *source) { int16 i; - gob_zeroObjects(); + zeroObjects(); for (i = 0; i < 20; i++) - gob_itemToObject[i] = 100; + itemToObject[i] = 100; - gob_freeObjects(); - gob_initList(); - strcpy(map_sourceFile, source); + freeObjects(); + initList(); + strcpy(_vm->_map->sourceFile, source); - map_sourceFile[strlen(map_sourceFile) - 4] = 0; - map_loadMapObjects(source); + _vm->_map->sourceFile[strlen(_vm->_map->sourceFile) - 4] = 0; + _vm->_map->loadMapObjects(source); - for (i = 0; i < gob_gobsCount; i++) - gob_placeObject(gob_goblins[i], 0); + for (i = 0; i < gobsCount; i++) + placeObject(goblins[i], 0); - for (i = 0; i < gob_objCount; i++) { - gob_placeObject(gob_objects[i], 1); + for (i = 0; i < objCount; i++) { + placeObject(objects[i], 1); } - gob_initVarPointers(); - gob_actDestItemDesc = 0; + initVarPointers(); + actDestItemDesc = 0; } -void gob_saveGobDataToVars(int16 xPos, int16 yPos, int16 someVal) { +void Goblin::saveGobDataToVars(int16 xPos, int16 yPos, int16 someVal) { Gob_Object *obj; - *gob_some0ValPtr = someVal; - *gob_curGobXPosVarPtr = xPos; - *gob_curGobYPosVarPtr = yPos; - *gob_itemInPocketVarPtr = gob_itemIndInPocket; - - obj = gob_goblins[gob_currentGoblin]; - - *gob_curGobStateVarPtr = obj->state; - *gob_curGobFrameVarPtr = obj->curFrame; - *gob_curGobMultStateVarPtr = obj->multState; - *gob_curGobNextStateVarPtr = obj->nextState; - *gob_curGobScrXVarPtr = obj->xPos; - *gob_curGobScrYVarPtr = obj->yPos; - *gob_curGobLeftVarPtr = obj->left; - *gob_curGobTopVarPtr = obj->top; - *gob_curGobRightVarPtr = obj->right; - *gob_curGobBottomVarPtr = obj->bottom; - *gob_curGobDoAnimVarPtr = obj->doAnim; - *gob_curGobOrderVarPtr = obj->order; - *gob_curGobNoTickVarPtr = obj->noTick; - *gob_curGobTypeVarPtr = obj->type; - *gob_curGobMaxTickVarPtr = obj->maxTick; - *gob_curGobTickVarPtr = obj->tick; - *gob_curGobActStartStateVarPtr = obj->actionStartState; - *gob_curGobLookDirVarPtr = obj->curLookDir; - *gob_curGobPickableVarPtr = obj->pickable; - *gob_curGobRelaxVarPtr = obj->relaxTime; - *gob_curGobMaxFrameVarPtr = gob_getObjMaxFrame(obj); - - if (gob_actDestItemDesc == 0) + *some0ValPtr = someVal; + *curGobXPosVarPtr = xPos; + *curGobYPosVarPtr = yPos; + *itemInPocketVarPtr = itemIndInPocket; + + obj = goblins[currentGoblin]; + + *curGobStateVarPtr = obj->state; + *curGobFrameVarPtr = obj->curFrame; + *curGobMultStateVarPtr = obj->multState; + *curGobNextStateVarPtr = obj->nextState; + *curGobScrXVarPtr = obj->xPos; + *curGobScrYVarPtr = obj->yPos; + *curGobLeftVarPtr = obj->left; + *curGobTopVarPtr = obj->top; + *curGobRightVarPtr = obj->right; + *curGobBottomVarPtr = obj->bottom; + *curGobDoAnimVarPtr = obj->doAnim; + *curGobOrderVarPtr = obj->order; + *curGobNoTickVarPtr = obj->noTick; + *curGobTypeVarPtr = obj->type; + *curGobMaxTickVarPtr = obj->maxTick; + *curGobTickVarPtr = obj->tick; + *curGobActStartStateVarPtr = obj->actionStartState; + *curGobLookDirVarPtr = obj->curLookDir; + *curGobPickableVarPtr = obj->pickable; + *curGobRelaxVarPtr = obj->relaxTime; + *curGobMaxFrameVarPtr = getObjMaxFrame(obj); + + if (actDestItemDesc == 0) return; - obj = gob_actDestItemDesc; - *gob_destItemStateVarPtr = obj->state; - *gob_destItemFrameVarPtr = obj->curFrame; - *gob_destItemMultStateVarPtr = obj->multState; - *gob_destItemNextStateVarPtr = obj->nextState; - *gob_destItemScrXVarPtr = obj->xPos; - *gob_destItemScrYVarPtr = obj->yPos; - *gob_destItemLeftVarPtr = obj->left; - *gob_destItemTopVarPtr = obj->top; - *gob_destItemRightVarPtr = obj->right; - *gob_destItemBottomVarPtr = obj->bottom; - *gob_destItemDoAnimVarPtr = obj->doAnim; - *gob_destItemOrderVarPtr = obj->order; - *gob_destItemNoTickVarPtr = obj->noTick; - *gob_destItemTypeVarPtr = obj->type; - *gob_destItemMaxTickVarPtr = obj->maxTick; - *gob_destItemTickVarPtr = obj->tick; - *gob_destItemActStartStVarPtr = obj->actionStartState; - *gob_destItemLookDirVarPtr = obj->curLookDir; - *gob_destItemPickableVarPtr = obj->pickable; - *gob_destItemRelaxVarPtr = obj->relaxTime; - *gob_destItemMaxFrameVarPtr = gob_getObjMaxFrame(obj); - - gob_destItemState = obj->state; - gob_destItemType = obj->type; + obj = actDestItemDesc; + *destItemStateVarPtr = obj->state; + *destItemFrameVarPtr = obj->curFrame; + *destItemMultStateVarPtr = obj->multState; + *destItemNextStateVarPtr = obj->nextState; + *destItemScrXVarPtr = obj->xPos; + *destItemScrYVarPtr = obj->yPos; + *destItemLeftVarPtr = obj->left; + *destItemTopVarPtr = obj->top; + *destItemRightVarPtr = obj->right; + *destItemBottomVarPtr = obj->bottom; + *destItemDoAnimVarPtr = obj->doAnim; + *destItemOrderVarPtr = obj->order; + *destItemNoTickVarPtr = obj->noTick; + *destItemTypeVarPtr = obj->type; + *destItemMaxTickVarPtr = obj->maxTick; + *destItemTickVarPtr = obj->tick; + *destItemActStartStVarPtr = obj->actionStartState; + *destItemLookDirVarPtr = obj->curLookDir; + *destItemPickableVarPtr = obj->pickable; + *destItemRelaxVarPtr = obj->relaxTime; + *destItemMaxFrameVarPtr = getObjMaxFrame(obj); + + destItemState = obj->state; + destItemType = obj->type; } -void gob_initVarPointers(void) { - gob_gobRetVarPtr = (int32 *)VAR_ADDRESS(59); - gob_curGobStateVarPtr = (int32 *)VAR_ADDRESS(60); - gob_curGobFrameVarPtr = (int32 *)VAR_ADDRESS(61); - gob_curGobMultStateVarPtr = (int32 *)VAR_ADDRESS(62); - gob_curGobNextStateVarPtr = (int32 *)VAR_ADDRESS(63); - gob_curGobScrXVarPtr = (int32 *)VAR_ADDRESS(64); - gob_curGobScrYVarPtr = (int32 *)VAR_ADDRESS(65); - gob_curGobLeftVarPtr = (int32 *)VAR_ADDRESS(66); - gob_curGobTopVarPtr = (int32 *)VAR_ADDRESS(67); - gob_curGobRightVarPtr = (int32 *)VAR_ADDRESS(68); - gob_curGobBottomVarPtr = (int32 *)VAR_ADDRESS(69); - gob_curGobDoAnimVarPtr = (int32 *)VAR_ADDRESS(70); - gob_curGobOrderVarPtr = (int32 *)VAR_ADDRESS(71); - gob_curGobNoTickVarPtr = (int32 *)VAR_ADDRESS(72); - gob_curGobTypeVarPtr = (int32 *)VAR_ADDRESS(73); - gob_curGobMaxTickVarPtr = (int32 *)VAR_ADDRESS(74); - gob_curGobTickVarPtr = (int32 *)VAR_ADDRESS(75); - gob_curGobActStartStateVarPtr = (int32 *)VAR_ADDRESS(76); - gob_curGobLookDirVarPtr = (int32 *)VAR_ADDRESS(77); - gob_curGobPickableVarPtr = (int32 *)VAR_ADDRESS(80); - gob_curGobRelaxVarPtr = (int32 *)VAR_ADDRESS(81); - gob_destItemStateVarPtr = (int32 *)VAR_ADDRESS(82); - gob_destItemFrameVarPtr = (int32 *)VAR_ADDRESS(83); - gob_destItemMultStateVarPtr = (int32 *)VAR_ADDRESS(84); - gob_destItemNextStateVarPtr = (int32 *)VAR_ADDRESS(85); - gob_destItemScrXVarPtr = (int32 *)VAR_ADDRESS(86); - gob_destItemScrYVarPtr = (int32 *)VAR_ADDRESS(87); - gob_destItemLeftVarPtr = (int32 *)VAR_ADDRESS(88); - gob_destItemTopVarPtr = (int32 *)VAR_ADDRESS(89); - gob_destItemRightVarPtr = (int32 *)VAR_ADDRESS(90); - gob_destItemBottomVarPtr = (int32 *)VAR_ADDRESS(91); - gob_destItemDoAnimVarPtr = (int32 *)VAR_ADDRESS(92); - gob_destItemOrderVarPtr = (int32 *)VAR_ADDRESS(93); - gob_destItemNoTickVarPtr = (int32 *)VAR_ADDRESS(94); - gob_destItemTypeVarPtr = (int32 *)VAR_ADDRESS(95); - gob_destItemMaxTickVarPtr = (int32 *)VAR_ADDRESS(96); - gob_destItemTickVarPtr = (int32 *)VAR_ADDRESS(97); - gob_destItemActStartStVarPtr = (int32 *)VAR_ADDRESS(98); - gob_destItemLookDirVarPtr = (int32 *)VAR_ADDRESS(99); - gob_destItemPickableVarPtr = (int32 *)VAR_ADDRESS(102); - gob_destItemRelaxVarPtr = (int32 *)VAR_ADDRESS(103); - gob_destItemMaxFrameVarPtr = (int32 *)VAR_ADDRESS(105); - gob_curGobVarPtr = (int32 *)VAR_ADDRESS(106); - gob_some0ValPtr = (int32 *)VAR_ADDRESS(107); - gob_curGobXPosVarPtr = (int32 *)VAR_ADDRESS(108); - gob_curGobYPosVarPtr = (int32 *)VAR_ADDRESS(109); - gob_curGobMaxFrameVarPtr = (int32 *)VAR_ADDRESS(110); - - gob_itemInPocketVarPtr = (int32 *)VAR_ADDRESS(114); - - *gob_itemInPocketVarPtr = -2; +void Goblin::initVarPointers(void) { + gobRetVarPtr = (int32 *)VAR_ADDRESS(59); + curGobStateVarPtr = (int32 *)VAR_ADDRESS(60); + curGobFrameVarPtr = (int32 *)VAR_ADDRESS(61); + curGobMultStateVarPtr = (int32 *)VAR_ADDRESS(62); + curGobNextStateVarPtr = (int32 *)VAR_ADDRESS(63); + curGobScrXVarPtr = (int32 *)VAR_ADDRESS(64); + curGobScrYVarPtr = (int32 *)VAR_ADDRESS(65); + curGobLeftVarPtr = (int32 *)VAR_ADDRESS(66); + curGobTopVarPtr = (int32 *)VAR_ADDRESS(67); + curGobRightVarPtr = (int32 *)VAR_ADDRESS(68); + curGobBottomVarPtr = (int32 *)VAR_ADDRESS(69); + curGobDoAnimVarPtr = (int32 *)VAR_ADDRESS(70); + curGobOrderVarPtr = (int32 *)VAR_ADDRESS(71); + curGobNoTickVarPtr = (int32 *)VAR_ADDRESS(72); + curGobTypeVarPtr = (int32 *)VAR_ADDRESS(73); + curGobMaxTickVarPtr = (int32 *)VAR_ADDRESS(74); + curGobTickVarPtr = (int32 *)VAR_ADDRESS(75); + curGobActStartStateVarPtr = (int32 *)VAR_ADDRESS(76); + curGobLookDirVarPtr = (int32 *)VAR_ADDRESS(77); + curGobPickableVarPtr = (int32 *)VAR_ADDRESS(80); + curGobRelaxVarPtr = (int32 *)VAR_ADDRESS(81); + destItemStateVarPtr = (int32 *)VAR_ADDRESS(82); + destItemFrameVarPtr = (int32 *)VAR_ADDRESS(83); + destItemMultStateVarPtr = (int32 *)VAR_ADDRESS(84); + destItemNextStateVarPtr = (int32 *)VAR_ADDRESS(85); + destItemScrXVarPtr = (int32 *)VAR_ADDRESS(86); + destItemScrYVarPtr = (int32 *)VAR_ADDRESS(87); + destItemLeftVarPtr = (int32 *)VAR_ADDRESS(88); + destItemTopVarPtr = (int32 *)VAR_ADDRESS(89); + destItemRightVarPtr = (int32 *)VAR_ADDRESS(90); + destItemBottomVarPtr = (int32 *)VAR_ADDRESS(91); + destItemDoAnimVarPtr = (int32 *)VAR_ADDRESS(92); + destItemOrderVarPtr = (int32 *)VAR_ADDRESS(93); + destItemNoTickVarPtr = (int32 *)VAR_ADDRESS(94); + destItemTypeVarPtr = (int32 *)VAR_ADDRESS(95); + destItemMaxTickVarPtr = (int32 *)VAR_ADDRESS(96); + destItemTickVarPtr = (int32 *)VAR_ADDRESS(97); + destItemActStartStVarPtr = (int32 *)VAR_ADDRESS(98); + destItemLookDirVarPtr = (int32 *)VAR_ADDRESS(99); + destItemPickableVarPtr = (int32 *)VAR_ADDRESS(102); + destItemRelaxVarPtr = (int32 *)VAR_ADDRESS(103); + destItemMaxFrameVarPtr = (int32 *)VAR_ADDRESS(105); + curGobVarPtr = (int32 *)VAR_ADDRESS(106); + some0ValPtr = (int32 *)VAR_ADDRESS(107); + curGobXPosVarPtr = (int32 *)VAR_ADDRESS(108); + curGobYPosVarPtr = (int32 *)VAR_ADDRESS(109); + curGobMaxFrameVarPtr = (int32 *)VAR_ADDRESS(110); + + itemInPocketVarPtr = (int32 *)VAR_ADDRESS(114); + + *itemInPocketVarPtr = -2; } -void gob_loadGobDataFromVars(void) { +void Goblin::loadGobDataFromVars(void) { Gob_Object *obj; - gob_itemIndInPocket = *gob_itemInPocketVarPtr; - - obj = gob_goblins[gob_currentGoblin]; - - obj->state = *gob_curGobStateVarPtr; - obj->curFrame = *gob_curGobFrameVarPtr; - obj->multState = *gob_curGobMultStateVarPtr; - obj->nextState = *gob_curGobNextStateVarPtr; - obj->xPos = *gob_curGobScrXVarPtr; - obj->yPos = *gob_curGobScrYVarPtr; - obj->left = *gob_curGobLeftVarPtr; - obj->top = *gob_curGobTopVarPtr; - obj->right = *gob_curGobRightVarPtr; - obj->bottom = *gob_curGobBottomVarPtr; - obj->doAnim = *gob_curGobDoAnimVarPtr; - obj->order = *gob_curGobOrderVarPtr; - obj->noTick = *gob_curGobNoTickVarPtr; - obj->type = *gob_curGobTypeVarPtr; - obj->maxTick = *gob_curGobMaxTickVarPtr; - obj->tick = *gob_curGobTickVarPtr; - obj->actionStartState = *gob_curGobActStartStateVarPtr; - obj->curLookDir = *gob_curGobLookDirVarPtr; - obj->pickable = *gob_curGobPickableVarPtr; - obj->relaxTime = *gob_curGobRelaxVarPtr; - - if (gob_actDestItemDesc == 0) + itemIndInPocket = *itemInPocketVarPtr; + + obj = goblins[currentGoblin]; + + obj->state = *curGobStateVarPtr; + obj->curFrame = *curGobFrameVarPtr; + obj->multState = *curGobMultStateVarPtr; + obj->nextState = *curGobNextStateVarPtr; + obj->xPos = *curGobScrXVarPtr; + obj->yPos = *curGobScrYVarPtr; + obj->left = *curGobLeftVarPtr; + obj->top = *curGobTopVarPtr; + obj->right = *curGobRightVarPtr; + obj->bottom = *curGobBottomVarPtr; + obj->doAnim = *curGobDoAnimVarPtr; + obj->order = *curGobOrderVarPtr; + obj->noTick = *curGobNoTickVarPtr; + obj->type = *curGobTypeVarPtr; + obj->maxTick = *curGobMaxTickVarPtr; + obj->tick = *curGobTickVarPtr; + obj->actionStartState = *curGobActStartStateVarPtr; + obj->curLookDir = *curGobLookDirVarPtr; + obj->pickable = *curGobPickableVarPtr; + obj->relaxTime = *curGobRelaxVarPtr; + + if (actDestItemDesc == 0) return; - obj = gob_actDestItemDesc; - - obj->state = *gob_destItemStateVarPtr; - obj->curFrame = *gob_destItemFrameVarPtr; - obj->multState = *gob_destItemMultStateVarPtr; - obj->nextState = *gob_destItemNextStateVarPtr; - obj->xPos = *gob_destItemScrXVarPtr; - obj->yPos = *gob_destItemScrYVarPtr; - obj->left = *gob_destItemLeftVarPtr; - obj->top = *gob_destItemTopVarPtr; - obj->right = *gob_destItemRightVarPtr; - obj->bottom = *gob_destItemBottomVarPtr; - obj->doAnim = *gob_destItemDoAnimVarPtr; - obj->order = *gob_destItemOrderVarPtr; - obj->noTick = *gob_destItemNoTickVarPtr; - obj->type = *gob_destItemTypeVarPtr; - obj->maxTick = *gob_destItemMaxTickVarPtr; - obj->tick = *gob_destItemTickVarPtr; - obj->actionStartState = *gob_destItemActStartStVarPtr; - obj->curLookDir = *gob_destItemLookDirVarPtr; - obj->pickable = *gob_destItemPickableVarPtr; - obj->relaxTime = *gob_destItemRelaxVarPtr; - - if (obj->type != gob_destItemType) + obj = actDestItemDesc; + + obj->state = *destItemStateVarPtr; + obj->curFrame = *destItemFrameVarPtr; + obj->multState = *destItemMultStateVarPtr; + obj->nextState = *destItemNextStateVarPtr; + obj->xPos = *destItemScrXVarPtr; + obj->yPos = *destItemScrYVarPtr; + obj->left = *destItemLeftVarPtr; + obj->top = *destItemTopVarPtr; + obj->right = *destItemRightVarPtr; + obj->bottom = *destItemBottomVarPtr; + obj->doAnim = *destItemDoAnimVarPtr; + obj->order = *destItemOrderVarPtr; + obj->noTick = *destItemNoTickVarPtr; + obj->type = *destItemTypeVarPtr; + obj->maxTick = *destItemMaxTickVarPtr; + obj->tick = *destItemTickVarPtr; + obj->actionStartState = *destItemActStartStVarPtr; + obj->curLookDir = *destItemLookDirVarPtr; + obj->pickable = *destItemPickableVarPtr; + obj->relaxTime = *destItemRelaxVarPtr; + + if (obj->type != destItemType) obj->toRedraw = 1; - if (obj->state != gob_destItemState && obj->type == 0) + if (obj->state != destItemState && obj->type == 0) obj->toRedraw = 1; } -void gob_pickItem(int16 indexToPocket, int16 idToPocket) { +void Goblin::pickItem(int16 indexToPocket, int16 idToPocket) { int16 x; int16 y; - if (gob_objects[indexToPocket]->pickable != 1) + if (objects[indexToPocket]->pickable != 1) return; - gob_objects[indexToPocket]->type = 3; + objects[indexToPocket]->type = 3; - gob_itemIndInPocket = indexToPocket; - gob_itemIdInPocket = idToPocket; + itemIndInPocket = indexToPocket; + itemIdInPocket = idToPocket; - for (y = 0; y < kMapHeight; y++) { - for (x = 0; x < kMapWidth; x++) { - if (gob_itemByteFlag == 1) { - if (((map_itemsMap[y][x] & 0xff00) >> 8) == + for (y = 0; y < Map::kMapHeight; y++) { + for (x = 0; x < Map::kMapWidth; x++) { + if (itemByteFlag == 1) { + if (((_vm->_map->itemsMap[y][x] & 0xff00) >> 8) == idToPocket) - map_itemsMap[y][x] &= 0xff; + _vm->_map->itemsMap[y][x] &= 0xff; } else { - if ((map_itemsMap[y][x] & 0xff) == idToPocket) - map_itemsMap[y][x] &= 0xff00; + if ((_vm->_map->itemsMap[y][x] & 0xff) == idToPocket) + _vm->_map->itemsMap[y][x] &= 0xff00; } } } if (idToPocket >= 0 && idToPocket < 20) { - map_itemPoses[gob_itemIdInPocket].x = 0; - map_itemPoses[gob_itemIdInPocket].y = 0; - map_itemPoses[gob_itemIdInPocket].orient = 0; + _vm->_map->itemPoses[itemIdInPocket].x = 0; + _vm->_map->itemPoses[itemIdInPocket].y = 0; + _vm->_map->itemPoses[itemIdInPocket].orient = 0; } } -void gob_placeItem(int16 indexInPocket, int16 idInPocket) { +void Goblin::placeItem(int16 indexInPocket, int16 idInPocket) { Gob_Object *itemDesc; int16 lookDir; int16 xPos; int16 yPos; int16 layer; - itemDesc = gob_objects[indexInPocket]; - lookDir = gob_goblins[0]->curLookDir & 4; + itemDesc = objects[indexInPocket]; + lookDir = goblins[0]->curLookDir & 4; - xPos = gob_gobPositions[0].x; - yPos = gob_gobPositions[0].y; + xPos = gobPositions[0].x; + yPos = gobPositions[0].y; - gob_itemIndInPocket = -1; - gob_itemIdInPocket = 0; + itemIndInPocket = -1; + itemIdInPocket = 0; itemDesc->pickable = 1; itemDesc->type = 0; itemDesc->toRedraw = 1; itemDesc->curFrame = 0; - itemDesc->order = gob_goblins[0]->order; + itemDesc->order = goblins[0]->order; itemDesc->animation = itemDesc->stateMach[itemDesc->state][0]->animation; layer = itemDesc->stateMach[itemDesc->state][itemDesc->stateColumn]->layer; - scen_updateAnim(layer, 0, itemDesc->animation, 0, + _vm->_scenery->updateAnim(layer, 0, itemDesc->animation, 0, itemDesc->xPos, itemDesc->yPos, 0); itemDesc->yPos += - (gob_gobPositions[0].y * 6) + 5 - scen_toRedrawBottom; + (gobPositions[0].y * 6) + 5 - _vm->_scenery->toRedrawBottom; if (lookDir == 4) { - itemDesc->xPos += (gob_gobPositions[0].x * 12 + 14) - - (scen_toRedrawLeft + scen_toRedrawRight) / 2; + itemDesc->xPos += (gobPositions[0].x * 12 + 14) + - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2; } else { - itemDesc->xPos += (gob_gobPositions[0].x * 12) - - (scen_toRedrawLeft + scen_toRedrawRight) / 2; + itemDesc->xPos += (gobPositions[0].x * 12) + - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2; } - map_placeItem(xPos, yPos, idInPocket); + _vm->_map->placeItem(xPos, yPos, idInPocket); if (yPos > 0) { - map_placeItem(xPos, yPos - 1, idInPocket); + _vm->_map->placeItem(xPos, yPos - 1, idInPocket); } if (lookDir == 4) { - if (xPos < kMapWidth - 1) { - map_placeItem(xPos + 1, yPos, idInPocket); + if (xPos < Map::kMapWidth - 1) { + _vm->_map->placeItem(xPos + 1, yPos, idInPocket); if (yPos > 0) { - map_placeItem(xPos + 1, yPos - 1, idInPocket); + _vm->_map->placeItem(xPos + 1, yPos - 1, idInPocket); } } } else { if (xPos > 0) { - map_placeItem(xPos - 1, yPos, idInPocket); + _vm->_map->placeItem(xPos - 1, yPos, idInPocket); if (yPos > 0) { - map_placeItem(xPos - 1, yPos - 1, idInPocket); + _vm->_map->placeItem(xPos - 1, yPos - 1, idInPocket); } } } if (idInPocket >= 0 && idInPocket < 20) { - map_itemPoses[idInPocket].x = gob_gobPositions[0].x; - map_itemPoses[idInPocket].y = gob_gobPositions[0].y; - map_itemPoses[idInPocket].orient = lookDir; - if (map_itemPoses[idInPocket].orient == 0) { -// map_itemPoses[idInPocket].x++; - if (map_passMap[(int)map_itemPoses[idInPocket].y][map_itemPoses[idInPocket].x + 1] == 1) - map_itemPoses[idInPocket].x++; + _vm->_map->itemPoses[idInPocket].x = gobPositions[0].x; + _vm->_map->itemPoses[idInPocket].y = gobPositions[0].y; + _vm->_map->itemPoses[idInPocket].orient = lookDir; + if (_vm->_map->itemPoses[idInPocket].orient == 0) { +// _vm->_map->itemPoses[idInPocket].x++; + if (_vm->_map->passMap[(int)_vm->_map->itemPoses[idInPocket].y][_vm->_map->itemPoses[idInPocket].x + 1] == 1) + _vm->_map->itemPoses[idInPocket].x++; } else { - if (map_passMap[(int)map_itemPoses[idInPocket].y][map_itemPoses[idInPocket].x - 1] == 1) - map_itemPoses[idInPocket].x--; + if (_vm->_map->passMap[(int)_vm->_map->itemPoses[idInPocket].y][_vm->_map->itemPoses[idInPocket].x - 1] == 1) + _vm->_map->itemPoses[idInPocket].x--; } } } -void gob_swapItems(int16 indexToPick, int16 idToPick) { +void Goblin::swapItems(int16 indexToPick, int16 idToPick) { int16 layer; Gob_Object *pickObj; Gob_Object *placeObj; @@ -2196,51 +2208,51 @@ void gob_swapItems(int16 indexToPick, int16 idToPick) { int16 x; int16 y; - pickObj = gob_objects[indexToPick]; - placeObj = gob_objects[gob_itemIndInPocket]; + pickObj = objects[indexToPick]; + placeObj = objects[itemIndInPocket]; - idToPlace = gob_itemIdInPocket; + idToPlace = itemIdInPocket; pickObj->type = 3; - gob_itemIndInPocket = indexToPick; - gob_itemIdInPocket = idToPick; - - if (gob_itemByteFlag == 0) { - for (y = 0; y < kMapHeight; y++) { - for (x = 0; x < kMapWidth; x++) { - if ((map_itemsMap[y][x] & 0xff) == idToPick) - map_itemsMap[y][x] = - (map_itemsMap[y][x] & 0xff00) + + itemIndInPocket = indexToPick; + itemIdInPocket = idToPick; + + if (itemByteFlag == 0) { + for (y = 0; y < Map::kMapHeight; y++) { + for (x = 0; x < Map::kMapWidth; x++) { + if ((_vm->_map->itemsMap[y][x] & 0xff) == idToPick) + _vm->_map->itemsMap[y][x] = + (_vm->_map->itemsMap[y][x] & 0xff00) + idToPlace; } } } else { - for (y = 0; y < kMapHeight; y++) { - for (x = 0; x < kMapWidth; x++) { - if (((map_itemsMap[y][x] & 0xff00) >> 8) == + for (y = 0; y < Map::kMapHeight; y++) { + for (x = 0; x < Map::kMapWidth; x++) { + if (((_vm->_map->itemsMap[y][x] & 0xff00) >> 8) == idToPick) - map_itemsMap[y][x] = - (map_itemsMap[y][x] & 0xff) + + _vm->_map->itemsMap[y][x] = + (_vm->_map->itemsMap[y][x] & 0xff) + (idToPlace << 8); } } } if (idToPick >= 0 && idToPick < 20) { - map_itemPoses[idToPlace].x = - map_itemPoses[gob_itemIdInPocket].x; - map_itemPoses[idToPlace].y = - map_itemPoses[gob_itemIdInPocket].y; - map_itemPoses[idToPlace].orient = - map_itemPoses[gob_itemIdInPocket].orient; - - map_itemPoses[gob_itemIdInPocket].x = 0; - map_itemPoses[gob_itemIdInPocket].y = 0; - map_itemPoses[gob_itemIdInPocket].orient = 0; + _vm->_map->itemPoses[idToPlace].x = + _vm->_map->itemPoses[itemIdInPocket].x; + _vm->_map->itemPoses[idToPlace].y = + _vm->_map->itemPoses[itemIdInPocket].y; + _vm->_map->itemPoses[idToPlace].orient = + _vm->_map->itemPoses[itemIdInPocket].orient; + + _vm->_map->itemPoses[itemIdInPocket].x = 0; + _vm->_map->itemPoses[itemIdInPocket].y = 0; + _vm->_map->itemPoses[itemIdInPocket].orient = 0; } - gob_itemIndInPocket = -1; - gob_itemIdInPocket = 0; + itemIndInPocket = -1; + itemIdInPocket = 0; placeObj->type = 0; placeObj->nextState = -1; @@ -2248,33 +2260,33 @@ void gob_swapItems(int16 indexToPick, int16 idToPick) { placeObj->unk14 = 0; placeObj->toRedraw = 1; placeObj->curFrame = 0; - placeObj->order = gob_goblins[0]->order; + placeObj->order = goblins[0]->order; placeObj->animation = placeObj->stateMach[placeObj->state][0]->animation; layer = placeObj->stateMach[placeObj->state][placeObj->stateColumn]->layer; - scen_updateAnim(layer, 0, placeObj->animation, 0, placeObj->xPos, + _vm->_scenery->updateAnim(layer, 0, placeObj->animation, 0, placeObj->xPos, placeObj->yPos, 0); placeObj->yPos += - (gob_gobPositions[0].y * 6) + 5 - scen_toRedrawBottom; + (gobPositions[0].y * 6) + 5 - _vm->_scenery->toRedrawBottom; - if (map_itemPoses[idToPlace].orient == 4) { - placeObj->xPos += (gob_gobPositions[0].x * 12 + 14) - - (scen_toRedrawLeft + scen_toRedrawRight) / 2; + if (_vm->_map->itemPoses[idToPlace].orient == 4) { + placeObj->xPos += (gobPositions[0].x * 12 + 14) + - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2; } else { - placeObj->xPos += (gob_gobPositions[0].x * 12) - - (scen_toRedrawLeft + scen_toRedrawRight) / 2; + placeObj->xPos += (gobPositions[0].x * 12) + - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2; } } -void gob_treatItemPick(int16 itemId) { +void Goblin::treatItemPick(int16 itemId) { int16 itemIndex; Gob_Object *gobDesc; - gobDesc = gob_goblins[gob_currentGoblin]; + gobDesc = goblins[currentGoblin]; if (gobDesc->curFrame != 9) return; @@ -2282,88 +2294,88 @@ void gob_treatItemPick(int16 itemId) { if (gobDesc->stateMach != gobDesc->realStateMach) return; - gob_readyToAct = 0; - gob_goesAtTarget = 0; + readyToAct = 0; + goesAtTarget = 0; - itemIndex = gob_itemToObject[itemId]; + itemIndex = itemToObject[itemId]; if (itemId != 0 && itemIndex != -1 - && gob_objects[itemIndex]->pickable != 1) + && objects[itemIndex]->pickable != 1) itemIndex = -1; - if (gob_itemIndInPocket != -1 && gob_itemIndInPocket == itemIndex) + if (itemIndInPocket != -1 && itemIndInPocket == itemIndex) itemIndex = -1; - if (gob_itemIndInPocket != -1 && itemIndex != -1 - && gob_objects[itemIndex]->pickable == 1) { - gob_swapItems(itemIndex, itemId); - gob_itemIndInPocket = itemIndex; - gob_itemIdInPocket = itemId; + if (itemIndInPocket != -1 && itemIndex != -1 + && objects[itemIndex]->pickable == 1) { + swapItems(itemIndex, itemId); + itemIndInPocket = itemIndex; + itemIdInPocket = itemId; return; } - if (gob_itemIndInPocket != -1 && itemIndex == -1) { - gob_placeItem(gob_itemIndInPocket, gob_itemIdInPocket); + if (itemIndInPocket != -1 && itemIndex == -1) { + placeItem(itemIndInPocket, itemIdInPocket); return; } - if (gob_itemIndInPocket == -1 && itemIndex != -1) { - gob_pickItem(itemIndex, itemId); + if (itemIndInPocket == -1 && itemIndex != -1) { + pickItem(itemIndex, itemId); return; } } -int16 gob_treatItem(int16 action) { +int16 Goblin::treatItem(int16 action) { int16 state; - state = gob_goblins[gob_currentGoblin]->state; + state = goblins[currentGoblin]->state; if ((state == 10 || state == 11) && - gob_goblins[gob_currentGoblin]->curFrame == 0) { - gob_readyToAct = 0; + goblins[currentGoblin]->curFrame == 0) { + readyToAct = 0; } - if (action == 3 && gob_currentGoblin == 0 && - (state == 10 || state == 11) && gob_goblins[0]->curFrame == 0) { - gob_saveGobDataToVars(gob_gobPositions[gob_currentGoblin].x, - gob_gobPositions[gob_currentGoblin].y, 0); - gob_goesAtTarget = 1; + if (action == 3 && currentGoblin == 0 && + (state == 10 || state == 11) && goblins[0]->curFrame == 0) { + saveGobDataToVars(gobPositions[currentGoblin].x, + gobPositions[currentGoblin].y, 0); + goesAtTarget = 1; return -1; } - if (gob_noPick == 0 && gob_currentGoblin == 0 && + if (noPick == 0 && currentGoblin == 0 && (state == 10 || state == 11)) { - gob_treatItemPick(gob_destActionItem); + treatItemPick(destActionItem); - gob_saveGobDataToVars(gob_gobPositions[gob_currentGoblin].x, - gob_gobPositions[gob_currentGoblin].y, 0); + saveGobDataToVars(gobPositions[currentGoblin].x, + gobPositions[currentGoblin].y, 0); return 0; } - if (gob_goesAtTarget == 0) { - gob_saveGobDataToVars(gob_gobPositions[gob_currentGoblin].x, - gob_gobPositions[gob_currentGoblin].y, 0); + if (goesAtTarget == 0) { + saveGobDataToVars(gobPositions[currentGoblin].x, + gobPositions[currentGoblin].y, 0); return 0; } else { - if (gob_itemToObject[gob_destActionItem] != 100 && - gob_destActionItem != 0) { + if (itemToObject[destActionItem] != 100 && + destActionItem != 0) { - if (gob_itemToObject[gob_destActionItem] == -1) { - gob_actDestItemDesc = 0; + if (itemToObject[destActionItem] == -1) { + actDestItemDesc = 0; } else { - gob_actDestItemDesc = - gob_objects[gob_itemToObject - [gob_destActionItem]]; + actDestItemDesc = + objects[itemToObject + [destActionItem]]; } } - gob_goesAtTarget = 0; - gob_saveGobDataToVars(gob_gobPositions[gob_currentGoblin].x, - gob_gobPositions[gob_currentGoblin].y, 0); - return gob_destActionItem; + goesAtTarget = 0; + saveGobDataToVars(gobPositions[currentGoblin].x, + gobPositions[currentGoblin].y, 0); + return destActionItem; } } -void gob_interFunc(void) { +void Goblin::interFunc(void) { int16 cmd; int16 extraData = 0; Gob_Object *objDesc = NULL; @@ -2381,31 +2393,31 @@ void gob_interFunc(void) { retVarPtr = (int32 *)VAR_ADDRESS(59); - cmd = inter_load16(); - inter_execPtr += 2; + cmd = _vm->_inter->load16(); + _vm->_global->inter_execPtr += 2; if (cmd > 0 && cmd < 17) { - extraData = inter_load16(); - objDesc = gob_objects[extraData]; + extraData = _vm->_inter->load16(); + objDesc = objects[extraData]; objDescSet = true; - extraData = inter_load16(); + extraData = _vm->_inter->load16(); } if (cmd > 90 && cmd < 107) { - extraData = inter_load16(); - objDesc = gob_goblins[extraData]; + extraData = _vm->_inter->load16(); + objDesc = goblins[extraData]; objDescSet = true; - extraData = inter_load16(); + extraData = _vm->_inter->load16(); cmd -= 90; } if (cmd > 110 && cmd < 128) { - extraData = inter_load16(); - objDesc = gob_goblins[extraData]; + extraData = _vm->_inter->load16(); + objDesc = goblins[extraData]; objDescSet = true; cmd -= 90; } else if (cmd > 20 && cmd < 38) { - extraData = inter_load16(); - objDesc = gob_objects[extraData]; + extraData = _vm->_inter->load16(); + objDesc = objects[extraData]; objDescSet = true; } @@ -2414,7 +2426,7 @@ void gob_interFunc(void) { variable, so we manually check if objDesc is properly set before checking if it is zero. If it was not set, we do not return. This fixes a crash in the EGA version if the life bar is depleted, because - gob_interFunc is called multiple times with cmd == 39. + interFunc is called multiple times with cmd == 39. Bug #1324814 */ @@ -2427,50 +2439,50 @@ void gob_interFunc(void) { case 1: objDesc->state = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemStateVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemStateVarPtr = extraData; break; case 2: objDesc->curFrame = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemFrameVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemFrameVarPtr = extraData; break; case 3: objDesc->nextState = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemNextStateVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemNextStateVarPtr = extraData; break; case 4: objDesc->multState = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemMultStateVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemMultStateVarPtr = extraData; break; case 5: objDesc->order = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemOrderVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemOrderVarPtr = extraData; break; case 6: objDesc->actionStartState = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemActStartStVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemActStartStVarPtr = extraData; break; case 7: objDesc->curLookDir = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemLookDirVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemLookDirVarPtr = extraData; break; case 8: objDesc->type = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemTypeVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemTypeVarPtr = extraData; if (extraData == 0) objDesc->toRedraw = 1; @@ -2478,44 +2490,44 @@ void gob_interFunc(void) { case 9: objDesc->noTick = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemNoTickVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemNoTickVarPtr = extraData; break; case 10: objDesc->pickable = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemPickableVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemPickableVarPtr = extraData; break; case 12: objDesc->xPos = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemScrXVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemScrXVarPtr = extraData; break; case 13: objDesc->yPos = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemScrYVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemScrYVarPtr = extraData; break; case 14: objDesc->doAnim = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemDoAnimVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemDoAnimVarPtr = extraData; break; case 15: objDesc->relaxTime = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemRelaxVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemRelaxVarPtr = extraData; break; case 16: objDesc->maxTick = extraData; - if (objDesc == gob_actDestItemDesc) - *gob_destItemMaxTickVarPtr = extraData; + if (objDesc == actDestItemDesc) + *destItemMaxTickVarPtr = extraData; break; case 21: @@ -2559,7 +2571,7 @@ void gob_interFunc(void) { break; case 32: - *retVarPtr = gob_getObjMaxFrame(objDesc); + *retVarPtr = getObjMaxFrame(objDesc); break; case 33: @@ -2584,9 +2596,9 @@ void gob_interFunc(void) { case 40: case 42: - xPos = inter_load16(); - yPos = inter_load16(); - item = inter_load16(); + xPos = _vm->_inter->load16(); + yPos = _vm->_inter->load16(); + item = _vm->_inter->load16(); if (cmd == 42) { xPos = VAR(xPos); @@ -2594,109 +2606,109 @@ void gob_interFunc(void) { item = VAR(item); } - for (y = 0; y < kMapHeight; y++) { - for (x = 0; x < kMapWidth; x++) { - if ((map_itemsMap[y][x] & 0xff) == item) { - map_itemsMap[y][x] &= 0xff00; - } else if (((map_itemsMap[y][x] & 0xff00) >> 8) + for (y = 0; y < Map::kMapHeight; y++) { + for (x = 0; x < Map::kMapWidth; x++) { + if ((_vm->_map->itemsMap[y][x] & 0xff) == item) { + _vm->_map->itemsMap[y][x] &= 0xff00; + } else if (((_vm->_map->itemsMap[y][x] & 0xff00) >> 8) == item) { - map_itemsMap[y][x] &= 0xff; + _vm->_map->itemsMap[y][x] &= 0xff; } } } - if (xPos < kMapWidth - 1) { + if (xPos < Map::kMapWidth - 1) { if (yPos > 0) { - if ((map_itemsMap[yPos][xPos] & 0xff00) != 0 || - (map_itemsMap[yPos - 1][xPos] & 0xff00) != + if ((_vm->_map->itemsMap[yPos][xPos] & 0xff00) != 0 || + (_vm->_map->itemsMap[yPos - 1][xPos] & 0xff00) != 0 - || (map_itemsMap[yPos][xPos + + || (_vm->_map->itemsMap[yPos][xPos + 1] & 0xff00) != 0 - || (map_itemsMap[yPos - 1][xPos + + || (_vm->_map->itemsMap[yPos - 1][xPos + 1] & 0xff00) != 0) { - map_itemsMap[yPos][xPos] = - (map_itemsMap[yPos][xPos] & 0xff00) + _vm->_map->itemsMap[yPos][xPos] = + (_vm->_map->itemsMap[yPos][xPos] & 0xff00) + item; - map_itemsMap[yPos - 1][xPos] = - (map_itemsMap[yPos - + _vm->_map->itemsMap[yPos - 1][xPos] = + (_vm->_map->itemsMap[yPos - 1][xPos] & 0xff00) + item; - map_itemsMap[yPos][xPos + 1] = - (map_itemsMap[yPos][xPos + + _vm->_map->itemsMap[yPos][xPos + 1] = + (_vm->_map->itemsMap[yPos][xPos + 1] & 0xff00) + item; - map_itemsMap[yPos - 1][xPos + 1] = - (map_itemsMap[yPos - 1][xPos + + _vm->_map->itemsMap[yPos - 1][xPos + 1] = + (_vm->_map->itemsMap[yPos - 1][xPos + 1] & 0xff00) + item; } else { - map_itemsMap[yPos][xPos] = - (map_itemsMap[yPos][xPos] & 0xff) + + _vm->_map->itemsMap[yPos][xPos] = + (_vm->_map->itemsMap[yPos][xPos] & 0xff) + (item << 8); - map_itemsMap[yPos - 1][xPos] = - (map_itemsMap[yPos - + _vm->_map->itemsMap[yPos - 1][xPos] = + (_vm->_map->itemsMap[yPos - 1][xPos] & 0xff) + (item << 8); - map_itemsMap[yPos][xPos + 1] = - (map_itemsMap[yPos][xPos + + _vm->_map->itemsMap[yPos][xPos + 1] = + (_vm->_map->itemsMap[yPos][xPos + 1] & 0xff) + (item << 8); - map_itemsMap[yPos - 1][xPos + 1] = - (map_itemsMap[yPos - 1][xPos + + _vm->_map->itemsMap[yPos - 1][xPos + 1] = + (_vm->_map->itemsMap[yPos - 1][xPos + 1] & 0xff) + (item << 8); } } else { - if ((map_itemsMap[yPos][xPos] & 0xff00) != 0 || - (map_itemsMap[yPos][xPos + 1] & 0xff00) != + if ((_vm->_map->itemsMap[yPos][xPos] & 0xff00) != 0 || + (_vm->_map->itemsMap[yPos][xPos + 1] & 0xff00) != 0) { - map_itemsMap[yPos][xPos] = - (map_itemsMap[yPos][xPos] & 0xff00) + _vm->_map->itemsMap[yPos][xPos] = + (_vm->_map->itemsMap[yPos][xPos] & 0xff00) + item; - map_itemsMap[yPos][xPos + 1] = - (map_itemsMap[yPos][xPos + + _vm->_map->itemsMap[yPos][xPos + 1] = + (_vm->_map->itemsMap[yPos][xPos + 1] & 0xff00) + item; } else { - map_itemsMap[yPos][xPos] = - (map_itemsMap[yPos][xPos] & 0xff) + + _vm->_map->itemsMap[yPos][xPos] = + (_vm->_map->itemsMap[yPos][xPos] & 0xff) + (item << 8); - map_itemsMap[yPos][xPos + 1] = - (map_itemsMap[yPos][xPos + + _vm->_map->itemsMap[yPos][xPos + 1] = + (_vm->_map->itemsMap[yPos][xPos + 1] & 0xff) + (item << 8); } } } else { if (yPos > 0) { - if ((map_itemsMap[yPos][xPos] & 0xff00) != 0 || - (map_itemsMap[yPos - 1][xPos] & 0xff00) != + if ((_vm->_map->itemsMap[yPos][xPos] & 0xff00) != 0 || + (_vm->_map->itemsMap[yPos - 1][xPos] & 0xff00) != 0) { - map_itemsMap[yPos][xPos] = - (map_itemsMap[yPos][xPos] & 0xff00) + _vm->_map->itemsMap[yPos][xPos] = + (_vm->_map->itemsMap[yPos][xPos] & 0xff00) + item; - map_itemsMap[yPos - 1][xPos] = - (map_itemsMap[yPos - + _vm->_map->itemsMap[yPos - 1][xPos] = + (_vm->_map->itemsMap[yPos - 1][xPos] & 0xff00) + item; } else { - map_itemsMap[yPos][xPos] = - (map_itemsMap[yPos][xPos] & 0xff) + + _vm->_map->itemsMap[yPos][xPos] = + (_vm->_map->itemsMap[yPos][xPos] & 0xff) + (item << 8); - map_itemsMap[yPos - 1][xPos] = - (map_itemsMap[yPos - + _vm->_map->itemsMap[yPos - 1][xPos] = + (_vm->_map->itemsMap[yPos - 1][xPos] & 0xff) + (item << 8); } } else { - if ((map_itemsMap[yPos][xPos] & 0xff00) != 0) { - map_itemsMap[yPos][xPos] = - (map_itemsMap[yPos][xPos] & 0xff00) + if ((_vm->_map->itemsMap[yPos][xPos] & 0xff00) != 0) { + _vm->_map->itemsMap[yPos][xPos] = + (_vm->_map->itemsMap[yPos][xPos] & 0xff00) + item; } else { - map_itemsMap[yPos][xPos] = - (map_itemsMap[yPos][xPos] & 0xff) + + _vm->_map->itemsMap[yPos][xPos] = + (_vm->_map->itemsMap[yPos][xPos] & 0xff) + (item << 8); } } @@ -2705,505 +2717,505 @@ void gob_interFunc(void) { if (item < 0 || item >= 20) break; - if (xPos > 1 && map_passMap[yPos][xPos - 2] == 1) { - map_itemPoses[item].x = xPos - 2; - map_itemPoses[item].y = yPos; - map_itemPoses[item].orient = 4; + if (xPos > 1 && _vm->_map->passMap[yPos][xPos - 2] == 1) { + _vm->_map->itemPoses[item].x = xPos - 2; + _vm->_map->itemPoses[item].y = yPos; + _vm->_map->itemPoses[item].orient = 4; break; } - if (xPos < kMapWidth - 2 && map_passMap[yPos][xPos + 2] == 1) { - map_itemPoses[item].x = xPos + 2; - map_itemPoses[item].y = yPos; - map_itemPoses[item].orient = 0; + if (xPos < Map::kMapWidth - 2 && _vm->_map->passMap[yPos][xPos + 2] == 1) { + _vm->_map->itemPoses[item].x = xPos + 2; + _vm->_map->itemPoses[item].y = yPos; + _vm->_map->itemPoses[item].orient = 0; break; } - if (xPos < kMapWidth - 1 && map_passMap[yPos][xPos + 1] == 1) { - map_itemPoses[item].x = xPos + 1; - map_itemPoses[item].y = yPos; - map_itemPoses[item].orient = 0; + if (xPos < Map::kMapWidth - 1 && _vm->_map->passMap[yPos][xPos + 1] == 1) { + _vm->_map->itemPoses[item].x = xPos + 1; + _vm->_map->itemPoses[item].y = yPos; + _vm->_map->itemPoses[item].orient = 0; break; } - if (xPos > 0 && map_passMap[yPos][xPos - 1] == 1) { - map_itemPoses[item].x = xPos - 1; - map_itemPoses[item].y = yPos; - map_itemPoses[item].orient = 4; + if (xPos > 0 && _vm->_map->passMap[yPos][xPos - 1] == 1) { + _vm->_map->itemPoses[item].x = xPos - 1; + _vm->_map->itemPoses[item].y = yPos; + _vm->_map->itemPoses[item].orient = 4; break; } break; case 41: case 43: - xPos = inter_load16(); - yPos = inter_load16(); + xPos = _vm->_inter->load16(); + yPos = _vm->_inter->load16(); if (cmd == 43) { xPos = VAR(xPos); yPos = VAR(yPos); } - if ((map_itemsMap[yPos][xPos] & 0xff00) != 0) { - *retVarPtr = (map_itemsMap[yPos][xPos] & 0xff00) >> 8; + if ((_vm->_map->itemsMap[yPos][xPos] & 0xff00) != 0) { + *retVarPtr = (_vm->_map->itemsMap[yPos][xPos] & 0xff00) >> 8; } else { - *retVarPtr = map_itemsMap[yPos][xPos]; + *retVarPtr = _vm->_map->itemsMap[yPos][xPos]; } break; case 44: - xPos = inter_load16(); - yPos = inter_load16(); - val = inter_load16(); - map_passMap[yPos][xPos] = val; + xPos = _vm->_inter->load16(); + yPos = _vm->_inter->load16(); + val = _vm->_inter->load16(); + _vm->_map->passMap[yPos][xPos] = val; break; case 50: - item = inter_load16(); - xPos = inter_load16(); - yPos = inter_load16(); + item = _vm->_inter->load16(); + xPos = _vm->_inter->load16(); + yPos = _vm->_inter->load16(); - gob_gobPositions[item].x = xPos * 2; - gob_gobPositions[item].y = yPos * 2; + gobPositions[item].x = xPos * 2; + gobPositions[item].y = yPos * 2; - objDesc = gob_goblins[item]; + objDesc = goblins[item]; objDesc->nextState = 21; - gob_nextLayer(objDesc); + nextLayer(objDesc); layer = objDesc->stateMach[objDesc->state][0]->layer; - scen_updateAnim(layer, 0, objDesc->animation, 0, + _vm->_scenery->updateAnim(layer, 0, objDesc->animation, 0, objDesc->xPos, objDesc->yPos, 0); objDesc->yPos = - (gob_gobPositions[item].y * 6 + 6) - (scen_toRedrawBottom - - scen_animTop); + (gobPositions[item].y * 6 + 6) - (_vm->_scenery->toRedrawBottom - + _vm->_scenery->animTop); objDesc->xPos = - gob_gobPositions[item].x * 12 - (scen_toRedrawLeft - - scen_animLeft); + gobPositions[item].x * 12 - (_vm->_scenery->toRedrawLeft - + _vm->_scenery->animLeft); objDesc->curFrame = 0; objDesc->state = 21; - if (gob_currentGoblin == item) { - *gob_curGobScrXVarPtr = objDesc->xPos; - *gob_curGobScrYVarPtr = objDesc->yPos; + if (currentGoblin == item) { + *curGobScrXVarPtr = objDesc->xPos; + *curGobScrYVarPtr = objDesc->yPos; - *gob_curGobFrameVarPtr = 0; - *gob_curGobStateVarPtr = 18; - gob_pressedMapX = gob_gobPositions[item].x; - gob_pressedMapY = gob_gobPositions[item].y; + *curGobFrameVarPtr = 0; + *curGobStateVarPtr = 18; + pressedMapX = gobPositions[item].x; + pressedMapY = gobPositions[item].y; } break; case 52: - item = inter_load16(); - *retVarPtr = gob_gobPositions[item].x >> 1; + item = _vm->_inter->load16(); + *retVarPtr = gobPositions[item].x >> 1; break; case 53: - item = inter_load16(); - *retVarPtr = gob_gobPositions[item].y >> 1; + item = _vm->_inter->load16(); + *retVarPtr = gobPositions[item].y >> 1; break; case 150: - item = inter_load16(); - xPos = inter_load16(); - yPos = inter_load16(); + item = _vm->_inter->load16(); + xPos = _vm->_inter->load16(); + yPos = _vm->_inter->load16(); - objDesc = gob_goblins[item]; + objDesc = goblins[item]; if (yPos == 0) { objDesc->multState = xPos; objDesc->nextState = xPos; - gob_nextLayer(objDesc); + nextLayer(objDesc); layer = objDesc->stateMach[objDesc->state][0]->layer; objDesc->xPos = - scen_animations[objDesc->animation].layers[layer]-> + _vm->_scenery->animations[objDesc->animation].layers[layer]-> posX; objDesc->yPos = - scen_animations[objDesc->animation].layers[layer]-> + _vm->_scenery->animations[objDesc->animation].layers[layer]-> posY; - *gob_curGobScrXVarPtr = objDesc->xPos; - *gob_curGobScrYVarPtr = objDesc->yPos; - *gob_curGobFrameVarPtr = 0; - *gob_curGobStateVarPtr = objDesc->state; - *gob_curGobNextStateVarPtr = objDesc->nextState; - *gob_curGobMultStateVarPtr = objDesc->multState; - *gob_curGobMaxFrameVarPtr = - gob_getObjMaxFrame(objDesc); - gob_noPick = 1; + *curGobScrXVarPtr = objDesc->xPos; + *curGobScrYVarPtr = objDesc->yPos; + *curGobFrameVarPtr = 0; + *curGobStateVarPtr = objDesc->state; + *curGobNextStateVarPtr = objDesc->nextState; + *curGobMultStateVarPtr = objDesc->multState; + *curGobMaxFrameVarPtr = + getObjMaxFrame(objDesc); + noPick = 1; break; } objDesc->multState = 21; objDesc->nextState = 21; objDesc->state = 21; - gob_nextLayer(objDesc); + nextLayer(objDesc); layer = objDesc->stateMach[objDesc->state][0]->layer; - scen_updateAnim(layer, 0, objDesc->animation, 0, + _vm->_scenery->updateAnim(layer, 0, objDesc->animation, 0, objDesc->xPos, objDesc->yPos, 0); objDesc->yPos = - (yPos * 6 + 6) - (scen_toRedrawBottom - scen_animTop); + (yPos * 6 + 6) - (_vm->_scenery->toRedrawBottom - _vm->_scenery->animTop); objDesc->xPos = - xPos * 12 - (scen_toRedrawLeft - scen_animLeft); + xPos * 12 - (_vm->_scenery->toRedrawLeft - _vm->_scenery->animLeft); - gob_gobPositions[item].x = xPos; - gob_pressedMapX = xPos; - map_curGoblinX = xPos; + gobPositions[item].x = xPos; + pressedMapX = xPos; + _vm->_map->curGoblinX = xPos; - gob_gobPositions[item].y = yPos; - gob_pressedMapY = yPos; - map_curGoblinY = yPos; + gobPositions[item].y = yPos; + pressedMapY = yPos; + _vm->_map->curGoblinY = yPos; - *gob_curGobScrXVarPtr = objDesc->xPos; - *gob_curGobScrYVarPtr = objDesc->yPos; - *gob_curGobFrameVarPtr = 0; - *gob_curGobStateVarPtr = 21; - *gob_curGobNextStateVarPtr = 21; - *gob_curGobMultStateVarPtr = -1; - gob_noPick = 0; + *curGobScrXVarPtr = objDesc->xPos; + *curGobScrYVarPtr = objDesc->yPos; + *curGobFrameVarPtr = 0; + *curGobStateVarPtr = 21; + *curGobNextStateVarPtr = 21; + *curGobMultStateVarPtr = -1; + noPick = 0; break; case 250: - item = inter_load16(); - xPos = inter_load16(); - yPos = inter_load16(); + item = _vm->_inter->load16(); + xPos = _vm->_inter->load16(); + yPos = _vm->_inter->load16(); - gob_gobPositions[item].x = xPos; - gob_gobPositions[item].y = yPos; + gobPositions[item].x = xPos; + gobPositions[item].y = yPos; - objDesc = gob_goblins[item]; + objDesc = goblins[item]; objDesc->nextState = 21; - gob_nextLayer(objDesc); + nextLayer(objDesc); layer = objDesc->stateMach[objDesc->state][0]->layer; - scen_updateAnim(layer, 0, objDesc->animation, 0, + _vm->_scenery->updateAnim(layer, 0, objDesc->animation, 0, objDesc->xPos, objDesc->yPos, 0); objDesc->yPos = - (yPos * 6 + 6) - (scen_toRedrawBottom - scen_animTop); + (yPos * 6 + 6) - (_vm->_scenery->toRedrawBottom - _vm->_scenery->animTop); objDesc->xPos = - xPos * 12 - (scen_toRedrawLeft - scen_animLeft); + xPos * 12 - (_vm->_scenery->toRedrawLeft - _vm->_scenery->animLeft); objDesc->curFrame = 0; objDesc->state = 21; - if (gob_currentGoblin == item) { - *gob_curGobScrXVarPtr = objDesc->xPos; - *gob_curGobScrYVarPtr = objDesc->yPos; - *gob_curGobFrameVarPtr = 0; - *gob_curGobStateVarPtr = 18; + if (currentGoblin == item) { + *curGobScrXVarPtr = objDesc->xPos; + *curGobScrYVarPtr = objDesc->yPos; + *curGobFrameVarPtr = 0; + *curGobStateVarPtr = 18; - gob_pressedMapX = gob_gobPositions[item].x; - gob_pressedMapY = gob_gobPositions[item].y; + pressedMapX = gobPositions[item].x; + pressedMapY = gobPositions[item].y; } break; case 251: - item = inter_load16(); - state = inter_load16(); + item = _vm->_inter->load16(); + state = _vm->_inter->load16(); - objDesc = gob_goblins[item]; + objDesc = goblins[item]; objDesc->nextState = state; - gob_nextLayer(objDesc); + nextLayer(objDesc); layer = objDesc->stateMach[objDesc->state][0]->layer; objDesc->xPos = - scen_animations[objDesc->animation].layers[layer]->posX; + _vm->_scenery->animations[objDesc->animation].layers[layer]->posX; objDesc->yPos = - scen_animations[objDesc->animation].layers[layer]->posY; + _vm->_scenery->animations[objDesc->animation].layers[layer]->posY; - if (item == gob_currentGoblin) { - *gob_curGobScrXVarPtr = objDesc->xPos; - *gob_curGobScrYVarPtr = objDesc->yPos; - *gob_curGobFrameVarPtr = 0; - *gob_curGobStateVarPtr = objDesc->state; - *gob_curGobMultStateVarPtr = objDesc->multState; + if (item == currentGoblin) { + *curGobScrXVarPtr = objDesc->xPos; + *curGobScrYVarPtr = objDesc->yPos; + *curGobFrameVarPtr = 0; + *curGobStateVarPtr = objDesc->state; + *curGobMultStateVarPtr = objDesc->multState; } break; case 252: - item = inter_load16(); - state = inter_load16(); - objDesc = gob_objects[item]; + item = _vm->_inter->load16(); + state = _vm->_inter->load16(); + objDesc = objects[item]; objDesc->nextState = state; - gob_nextLayer(objDesc); + nextLayer(objDesc); layer = objDesc->stateMach[objDesc->state][0]->layer; objDesc->xPos = - scen_animations[objDesc->animation].layers[layer]->posX; + _vm->_scenery->animations[objDesc->animation].layers[layer]->posX; objDesc->yPos = - scen_animations[objDesc->animation].layers[layer]->posY; + _vm->_scenery->animations[objDesc->animation].layers[layer]->posY; objDesc->toRedraw = 1; objDesc->type = 0; - if (objDesc == gob_actDestItemDesc) { - *gob_destItemScrXVarPtr = objDesc->xPos; - *gob_destItemScrYVarPtr = objDesc->yPos; + if (objDesc == actDestItemDesc) { + *destItemScrXVarPtr = objDesc->xPos; + *destItemScrYVarPtr = objDesc->yPos; - *gob_destItemStateVarPtr = objDesc->state; - *gob_destItemNextStateVarPtr = -1; - *gob_destItemMultStateVarPtr = -1; - *gob_destItemFrameVarPtr = 0; + *destItemStateVarPtr = objDesc->state; + *destItemNextStateVarPtr = -1; + *destItemMultStateVarPtr = -1; + *destItemFrameVarPtr = 0; } break; case 152: - item = inter_load16(); - val = inter_load16(); - objDesc = gob_objects[item]; + item = _vm->_inter->load16(); + val = _vm->_inter->load16(); + objDesc = objects[item]; objDesc->unk14 = val; break; case 200: - gob_itemIdInPocket = inter_load16(); + itemIdInPocket = _vm->_inter->load16(); break; case 201: - gob_itemIndInPocket = inter_load16(); + itemIndInPocket = _vm->_inter->load16(); break; case 202: - *retVarPtr = gob_itemIdInPocket; + *retVarPtr = itemIdInPocket; break; case 203: - *retVarPtr = gob_itemIndInPocket; + *retVarPtr = itemIndInPocket; break; case 204: - item = inter_load16(); - xPos = inter_load16(); - yPos = inter_load16(); - val = inter_load16(); + item = _vm->_inter->load16(); + xPos = _vm->_inter->load16(); + yPos = _vm->_inter->load16(); + val = _vm->_inter->load16(); - map_itemPoses[item].x = xPos; - map_itemPoses[item].y = yPos; - map_itemPoses[item].orient = val; + _vm->_map->itemPoses[item].x = xPos; + _vm->_map->itemPoses[item].y = yPos; + _vm->_map->itemPoses[item].orient = val; break; case 500: - extraData = inter_load16(); - objDesc = gob_objects[extraData]; + extraData = _vm->_inter->load16(); + objDesc = objects[extraData]; objDesc->relaxTime--; if (objDesc->relaxTime < 0 && - gob_getObjMaxFrame(objDesc) == objDesc->curFrame) { - objDesc->relaxTime = util_getRandom(100) + 50; + getObjMaxFrame(objDesc) == objDesc->curFrame) { + objDesc->relaxTime = _vm->_util->getRandom(100) + 50; objDesc->curFrame = 0; objDesc->toRedraw = 1; } break; case 502: - item = inter_load16(); - *retVarPtr = gob_gobPositions[item].x; + item = _vm->_inter->load16(); + *retVarPtr = gobPositions[item].x; break; case 503: - item = inter_load16(); - *retVarPtr = gob_gobPositions[item].y; + item = _vm->_inter->load16(); + *retVarPtr = gobPositions[item].y; break; case 600: - gob_pathExistence = 0; + pathExistence = 0; break; case 601: - extraData = inter_load16(); - gob_goblins[extraData]->visible = 1; + extraData = _vm->_inter->load16(); + goblins[extraData]->visible = 1; break; case 602: - extraData = inter_load16(); - gob_goblins[extraData]->visible = 0; + extraData = _vm->_inter->load16(); + goblins[extraData]->visible = 0; break; case 603: - extraData = inter_load16(); - item = inter_load16(); + extraData = _vm->_inter->load16(); + item = _vm->_inter->load16(); - objDesc = gob_objects[extraData]; - if (gob_objIntersected(objDesc, gob_goblins[item]) != 0) + objDesc = objects[extraData]; + if (objIntersected(objDesc, goblins[item]) != 0) *retVarPtr = 1; else *retVarPtr = 0; break; case 604: - extraData = inter_load16(); - item = inter_load16(); + extraData = _vm->_inter->load16(); + item = _vm->_inter->load16(); - objDesc = gob_goblins[extraData]; - if (gob_objIntersected(objDesc, gob_goblins[item]) != 0) + objDesc = goblins[extraData]; + if (objIntersected(objDesc, goblins[item]) != 0) *retVarPtr = 1; else *retVarPtr = 0; break; case 605: - item = inter_load16(); - xPos = inter_load16(); - yPos = inter_load16(); - val = inter_load16(); + item = _vm->_inter->load16(); + xPos = _vm->_inter->load16(); + yPos = _vm->_inter->load16(); + val = _vm->_inter->load16(); - map_itemPoses[item].x = xPos; - map_itemPoses[item].y = yPos; - map_itemPoses[item].orient = val; + _vm->_map->itemPoses[item].x = xPos; + _vm->_map->itemPoses[item].y = yPos; + _vm->_map->itemPoses[item].orient = val; break; case 1000: - extraData = inter_load16(); - if (game_extHandle >= 0) - data_closeData(game_extHandle); + extraData = _vm->_inter->load16(); + if (_vm->_game->extHandle >= 0) + _vm->_dataio->closeData(_vm->_game->extHandle); - gob_loadObjects((char *)VAR_ADDRESS(extraData)); - game_extHandle = data_openData(game_curExtFile); + loadObjects((char *)VAR_ADDRESS(extraData)); + _vm->_game->extHandle = _vm->_dataio->openData(_vm->_game->curExtFile); break; case 1001: - gob_freeAllObjects(); + freeAllObjects(); break; case 1002: - gob_animateObjects(); + animateObjects(); break; case 1003: - gob_drawObjects(); + drawObjects(); - if (cd_getTrackPos() == -1) - cd_playBgMusic(); + if (_vm->_cdrom->getTrackPos() == -1) + _vm->_cdrom->playBgMusic(); break; case 1004: - map_loadMapsInitGobs(); + _vm->_map->loadMapsInitGobs(); break; case 1005: - extraData = inter_load16(); - xPos = inter_load16(); + extraData = _vm->_inter->load16(); + xPos = _vm->_inter->load16(); if ((uint16)VAR(xPos) == 0) { item = - gob_doMove(gob_goblins[gob_currentGoblin], 1, + doMove(goblins[currentGoblin], 1, (uint16)VAR(extraData)); } else { item = - gob_doMove(gob_goblins[gob_currentGoblin], 1, 3); + doMove(goblins[currentGoblin], 1, 3); } if (item != 0) - gob_switchGoblin(item); + switchGoblin(item); break; case 1006: - gob_switchGoblin(0); + switchGoblin(0); break; case 1008: - gob_loadGobDataFromVars(); + loadGobDataFromVars(); break; case 1009: - extraData = inter_load16(); - cmd = inter_load16(); - xPos = inter_load16(); + extraData = _vm->_inter->load16(); + cmd = _vm->_inter->load16(); + xPos = _vm->_inter->load16(); if ((uint16)VAR(xPos) == 0) { - WRITE_VAR(cmd, gob_treatItem((uint16)VAR(extraData))); + WRITE_VAR(cmd, treatItem((uint16)VAR(extraData))); break; } - WRITE_VAR(cmd, gob_treatItem(3)); + WRITE_VAR(cmd, treatItem(3)); break; case 1010: - gob_doMove(gob_goblins[gob_currentGoblin], 0, 0); + doMove(goblins[currentGoblin], 0, 0); break; case 1011: - extraData = inter_load16(); + extraData = _vm->_inter->load16(); if (VAR(extraData) != 0) - gob_goesAtTarget = 1; + goesAtTarget = 1; else - gob_goesAtTarget = 0; + goesAtTarget = 0; break; case 1015: - extraData = inter_load16(); + extraData = _vm->_inter->load16(); extraData = VAR(extraData); - gob_objects[10]->xPos = extraData; + objects[10]->xPos = extraData; - extraData = inter_load16(); + extraData = _vm->_inter->load16(); extraData = VAR(extraData); - gob_objects[10]->yPos = extraData; + objects[10]->yPos = extraData; break; case 2005: - gobDesc = gob_goblins[0]; - if (gob_currentGoblin != 0) { - gob_goblins[gob_currentGoblin]->doAnim = 1; - gob_goblins[gob_currentGoblin]->nextState = 21; + gobDesc = goblins[0]; + if (currentGoblin != 0) { + goblins[currentGoblin]->doAnim = 1; + goblins[currentGoblin]->nextState = 21; - gob_nextLayer(gob_goblins[gob_currentGoblin]); - gob_currentGoblin = 0; + nextLayer(goblins[currentGoblin]); + currentGoblin = 0; gobDesc->doAnim = 0; gobDesc->type = 0; gobDesc->toRedraw = 1; - gob_pressedMapX = gob_gobPositions[0].x; - map_destX = gob_gobPositions[0].x; - gob_gobDestX = gob_gobPositions[0].x; + pressedMapX = gobPositions[0].x; + _vm->_map->destX = gobPositions[0].x; + gobDestX = gobPositions[0].x; - gob_pressedMapY = gob_gobPositions[0].y; - map_destY = gob_gobPositions[0].y; - gob_gobDestY = gob_gobPositions[0].y; + pressedMapY = gobPositions[0].y; + _vm->_map->destY = gobPositions[0].y; + gobDestY = gobPositions[0].y; - *gob_curGobVarPtr = 0; - gob_pathExistence = 0; - gob_readyToAct = 0; + *curGobVarPtr = 0; + pathExistence = 0; + readyToAct = 0; } - if (gobDesc->state != 10 && gob_itemIndInPocket != -1 && - gob_getObjMaxFrame(gobDesc) == gobDesc->curFrame) { + if (gobDesc->state != 10 && itemIndInPocket != -1 && + getObjMaxFrame(gobDesc) == gobDesc->curFrame) { gobDesc->stateMach = gobDesc->realStateMach; - xPos = gob_gobPositions[0].x; - yPos = gob_gobPositions[0].y; + xPos = gobPositions[0].x; + yPos = gobPositions[0].y; gobDesc->nextState = 10; - layer = gob_nextLayer(gobDesc); + layer = nextLayer(gobDesc); - scen_updateAnim(layer, 0, gobDesc->animation, 0, + _vm->_scenery->updateAnim(layer, 0, gobDesc->animation, 0, gobDesc->xPos, gobDesc->yPos, 0); gobDesc->yPos = - (yPos * 6 + 6) - (scen_toRedrawBottom - - scen_animTop); + (yPos * 6 + 6) - (_vm->_scenery->toRedrawBottom - + _vm->_scenery->animTop); gobDesc->xPos = - xPos * 12 - (scen_toRedrawLeft - scen_animLeft); + xPos * 12 - (_vm->_scenery->toRedrawLeft - _vm->_scenery->animLeft); } if (gobDesc->state != 10) break; - if (gob_itemIndInPocket == -1) + if (itemIndInPocket == -1) break; if (gobDesc->curFrame != 10) break; - objDesc = gob_objects[gob_itemIndInPocket]; + objDesc = objects[itemIndInPocket]; objDesc->type = 0; objDesc->toRedraw = 1; objDesc->curFrame = 0; @@ -3214,30 +3226,30 @@ void gob_interFunc(void) { layer = objDesc->stateMach[objDesc->state][0]->layer; - scen_updateAnim(layer, 0, objDesc->animation, 0, + _vm->_scenery->updateAnim(layer, 0, objDesc->animation, 0, objDesc->xPos, objDesc->yPos, 0); objDesc->yPos += - (gob_gobPositions[0].y * 6 + 5) - scen_toRedrawBottom; + (gobPositions[0].y * 6 + 5) - _vm->_scenery->toRedrawBottom; if (gobDesc->curLookDir == 4) { - objDesc->xPos += gob_gobPositions[0].x * 12 + 14 - - (scen_toRedrawLeft + scen_toRedrawRight) / 2; + objDesc->xPos += gobPositions[0].x * 12 + 14 + - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2; } else { - objDesc->xPos += gob_gobPositions[0].x * 12 - - (scen_toRedrawLeft + scen_toRedrawRight) / 2; + objDesc->xPos += gobPositions[0].x * 12 + - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2; } - gob_itemIndInPocket = -1; - gob_itemIdInPocket = -1; - util_beep(50); + itemIndInPocket = -1; + itemIdInPocket = -1; + _vm->_util->beep(50); break; default: - warning("gob_interFunc: Unknown command %d!", cmd); - inter_execPtr -= 2; - cmd = inter_load16(); - inter_execPtr += cmd * 2; + warning("interFunc: Unknown command %d!", cmd); + _vm->_global->inter_execPtr -= 2; + cmd = _vm->_inter->load16(); + _vm->_global->inter_execPtr += cmd * 2; break; } return; diff --git a/gob/goblin.h b/gob/goblin.h index 2903b00f0b..36c76b14f0 100644 --- a/gob/goblin.h +++ b/gob/goblin.h @@ -31,175 +31,201 @@ namespace Gob { #define TYPE_AMORPHOUS 1 #define TYPE_MOBILE 3 +class Goblin { +public: #pragma START_PACK_STRUCTS -typedef struct Gob_State { - int16 animation;// +0h - int16 layer; // +2h - int16 unk0; // +4h - int16 unk1; // +6h - int16 sndItem; // +8h, high/low byte - sound sample index - int16 freq; // +Ah, high/low byte * 100 - frequency - int16 repCount; // +Ch high/low byte - repeat count - int16 sndFrame; // +Eh -} GCC_PACK Gob_State; - -typedef struct Gob_State *Gob_PState; + typedef struct Gob_State { + int16 animation;// +0h + int16 layer; // +2h + int16 unk0; // +4h + int16 unk1; // +6h + int16 sndItem; // +8h, high/low byte - sound sample index + int16 freq; // +Ah, high/low byte * 100 - frequency + int16 repCount; // +Ch high/low byte - repeat count + int16 sndFrame; // +Eh + } GCC_PACK Gob_State; + + typedef Gob_State *Gob_PState; #define szGob_StateLine 24 -typedef Gob_PState Gob_StateLine[6]; - -typedef struct Gob_Object { - int16 animation; // +0h - int16 state; // +2h - int16 stateColumn; // +4h - int16 curFrame; // +6h - int16 xPos; // +8h - int16 yPos; // +Ah - int16 dirtyLeft; // +Ch - int16 dirtyTop; // +Eh - int16 dirtyRight; // +10h - int16 dirtyBottom; // +12h - int16 left; // +14h - int16 top; // +16h - int16 right; // +18h - int16 bottom; // +1ah - int16 nextState; // +1ch - int16 multState; // +1eh - int16 actionStartState; // +20h - int16 curLookDir; // +22h - int16 pickable; // +24h - int16 relaxTime; // +26h - Gob_StateLine *stateMach; // +28h - Gob_StateLine *realStateMach; // +2ch - char doAnim; // +30h - char order; // +31h - char noTick; // +32h - char toRedraw; // +33h - char type; // +34h - char maxTick; // +35h - char tick; // +36h - char multObjIndex; // +37h, from which play mult animations - char unk14; // +38h - char visible; // +39h -} GCC_PACK Gob_Object; - -typedef struct Gob_Pos { - char x; - char y; -} GCC_PACK Gob_Pos; + typedef Gob_PState Gob_StateLine[6]; + + typedef struct Gob_Object { + int16 animation; // +0h + int16 state; // +2h + int16 stateColumn; // +4h + int16 curFrame; // +6h + int16 xPos; // +8h + int16 yPos; // +Ah + int16 dirtyLeft; // +Ch + int16 dirtyTop; // +Eh + int16 dirtyRight; // +10h + int16 dirtyBottom; // +12h + int16 left; // +14h + int16 top; // +16h + int16 right; // +18h + int16 bottom; // +1ah + int16 nextState; // +1ch + int16 multState; // +1eh + int16 actionStartState; // +20h + int16 curLookDir; // +22h + int16 pickable; // +24h + int16 relaxTime; // +26h + Gob_StateLine *stateMach; // +28h + Gob_StateLine *realStateMach; // +2ch + char doAnim; // +30h + char order; // +31h + char noTick; // +32h + char toRedraw; // +33h + char type; // +34h + char maxTick; // +35h + char tick; // +36h + char multObjIndex; // +37h, from which play mult animations + char unk14; // +38h + char visible; // +39h + } GCC_PACK Gob_Object; + + typedef struct Gob_Pos { + char x; + char y; + } GCC_PACK Gob_Pos; #pragma END_PACK_STRUCTS -extern Util_List *gob_objList; -extern Gob_Object *gob_goblins[4]; -extern int16 gob_currentGoblin; -extern Snd_SoundDesc *gob_soundData[16]; -extern int16 gob_gobStateLayer; -extern char gob_goesAtTarget; -extern char gob_readyToAct; -extern int16 gob_gobAction; // 0 - move, 3 - do action, 4 - pick - // goblins 0 - picker, 1 - fighter, 2 - mage -extern Gob_Pos gob_gobPositions[3]; -extern int16 gob_gobDestX; -extern int16 gob_gobDestY; -extern int16 gob_pressedMapX; -extern int16 gob_pressedMapY; -extern char gob_pathExistence; - -// Pointers to interpreter variables -extern int32 *gob_some0ValPtr; - -extern int32 *gob_gobRetVarPtr; -extern int32 *gob_curGobVarPtr; -extern int32 *gob_curGobXPosVarPtr; -extern int32 *gob_curGobYPosVarPtr; -extern int32 *gob_itemInPocketVarPtr; - -extern int32 *gob_curGobStateVarPtr; -extern int32 *gob_curGobFrameVarPtr; -extern int32 *gob_curGobMultStateVarPtr; -extern int32 *gob_curGobNextStateVarPtr; -extern int32 *gob_curGobScrXVarPtr; -extern int32 *gob_curGobScrYVarPtr; -extern int32 *gob_curGobLeftVarPtr; -extern int32 *gob_curGobTopVarPtr; -extern int32 *gob_curGobRightVarPtr; -extern int32 *gob_curGobBottomVarPtr; -extern int32 *gob_curGobDoAnimVarPtr; -extern int32 *gob_curGobOrderVarPtr; -extern int32 *gob_curGobNoTickVarPtr; -extern int32 *gob_curGobTypeVarPtr; -extern int32 *gob_curGobMaxTickVarPtr; -extern int32 *gob_curGobTickVarPtr; -extern int32 *gob_curGobActStartStateVarPtr; -extern int32 *gob_curGobLookDirVarPtr; -extern int32 *gob_curGobPickableVarPtr; -extern int32 *gob_curGobRelaxVarPtr; -extern int32 *gob_curGobMaxFrameVarPtr; - -extern int32 *gob_destItemStateVarPtr; -extern int32 *gob_destItemFrameVarPtr; -extern int32 *gob_destItemMultStateVarPtr; -extern int32 *gob_destItemNextStateVarPtr; -extern int32 *gob_destItemScrXVarPtr; -extern int32 *gob_destItemScrYVarPtr; -extern int32 *gob_destItemLeftVarPtr; -extern int32 *gob_destItemTopVarPtr; -extern int32 *gob_destItemRightVarPtr; -extern int32 *gob_destItemBottomVarPtr; -extern int32 *gob_destItemDoAnimVarPtr; -extern int32 *gob_destItemOrderVarPtr; -extern int32 *gob_destItemNoTickVarPtr; -extern int32 *gob_destItemTypeVarPtr; -extern int32 *gob_destItemMaxTickVarPtr; -extern int32 *gob_destItemTickVarPtr; -extern int32 *gob_destItemActStartStVarPtr; -extern int32 *gob_destItemLookDirVarPtr; -extern int32 *gob_destItemPickableVarPtr; -extern int32 *gob_destItemRelaxVarPtr; -extern int32 *gob_destItemMaxFrameVarPtr; - -extern int16 gob_destItemType; -extern int16 gob_destItemState; -extern int16 gob_itemToObject[20]; -extern Gob_Object *gob_objects[20]; -extern int16 gob_objCount; -extern int16 gob_gobsCount; -extern int16 gob_itemIndInPocket; -extern int16 gob_itemIdInPocket; -extern char gob_itemByteFlag; -extern int16 gob_destItemId; -extern int16 gob_destActionItem; -extern Gob_Object *gob_actDestItemDesc; -extern int16 gob_forceNextState[10]; -extern char gob_boreCounter; -extern int16 gob_positionedGob; -extern char gob_noPick; - -// Functions -char gob_rotateState(int16 from, int16 to); -void gob_playSound(Snd_SoundDesc * snd, int16 repCount, int16 freq); -void gob_drawObjects(void); -void gob_animateObjects(void); -void gob_placeObject(Gob_Object * objDesc, char animated); -int16 gob_getObjMaxFrame(Gob_Object * obj); -int16 gob_objIntersected(Gob_Object * obj1, Gob_Object * obj2); -void gob_setMultStates(Gob_Object * gobDesc); -int16 gob_nextLayer(Gob_Object * gobDesc); -void gob_showBoredom(int16 gobIndex); -void gob_switchGoblin(int16 index); -void gob_freeObjects(void); -void gob_zeroObjects(void); -void gob_freeAllObjects(void); -void gob_loadObjects(char *source); -void gob_initVarPointers(void); -void gob_saveGobDataToVars(int16 xPos, int16 yPos, int16 someVal); -void gob_loadGobDataFromVars(void); -void gob_pickItem(int16 indexToPocket, int16 idToPocket); -void gob_placeItem(int16 indexInPocket, int16 idInPocket); -void gob_swapItems(int16 indexToPick, int16 idToPick); -void gob_treatItemPick(int16 itemId); -int16 gob_treatItem(int16 action); -void gob_interFunc(void); + Util::List *objList; + Gob_Object *goblins[4]; + int16 currentGoblin; + Snd::SoundDesc *soundData[16]; + int16 gobStateLayer; + char goesAtTarget; + char readyToAct; + int16 gobAction; // 0 - move, 3 - do action, 4 - pick + // goblins 0 - picker, 1 - fighter, 2 - mage + Gob_Pos gobPositions[3]; + int16 gobDestX; + int16 gobDestY; + int16 pressedMapX; + int16 pressedMapY; + char pathExistence; + + // Pointers to interpreter variables + int32 *some0ValPtr; + + int32 *gobRetVarPtr; + int32 *curGobVarPtr; + int32 *curGobXPosVarPtr; + int32 *curGobYPosVarPtr; + int32 *itemInPocketVarPtr; + + int32 *curGobStateVarPtr; + int32 *curGobFrameVarPtr; + int32 *curGobMultStateVarPtr; + int32 *curGobNextStateVarPtr; + int32 *curGobScrXVarPtr; + int32 *curGobScrYVarPtr; + int32 *curGobLeftVarPtr; + int32 *curGobTopVarPtr; + int32 *curGobRightVarPtr; + int32 *curGobBottomVarPtr; + int32 *curGobDoAnimVarPtr; + int32 *curGobOrderVarPtr; + int32 *curGobNoTickVarPtr; + int32 *curGobTypeVarPtr; + int32 *curGobMaxTickVarPtr; + int32 *curGobTickVarPtr; + int32 *curGobActStartStateVarPtr; + int32 *curGobLookDirVarPtr; + int32 *curGobPickableVarPtr; + int32 *curGobRelaxVarPtr; + int32 *curGobMaxFrameVarPtr; + + int32 *destItemStateVarPtr; + int32 *destItemFrameVarPtr; + int32 *destItemMultStateVarPtr; + int32 *destItemNextStateVarPtr; + int32 *destItemScrXVarPtr; + int32 *destItemScrYVarPtr; + int32 *destItemLeftVarPtr; + int32 *destItemTopVarPtr; + int32 *destItemRightVarPtr; + int32 *destItemBottomVarPtr; + int32 *destItemDoAnimVarPtr; + int32 *destItemOrderVarPtr; + int32 *destItemNoTickVarPtr; + int32 *destItemTypeVarPtr; + int32 *destItemMaxTickVarPtr; + int32 *destItemTickVarPtr; + int32 *destItemActStartStVarPtr; + int32 *destItemLookDirVarPtr; + int32 *destItemPickableVarPtr; + int32 *destItemRelaxVarPtr; + int32 *destItemMaxFrameVarPtr; + + int16 destItemType; + int16 destItemState; + int16 itemToObject[20]; + Gob_Object *objects[20]; + int16 objCount; + int16 gobsCount; + int16 itemIndInPocket; + int16 itemIdInPocket; + char itemByteFlag; + int16 destItemId; + int16 destActionItem; + Gob_Object *actDestItemDesc; + int16 forceNextState[10]; + char boreCounter; + int16 positionedGob; + char noPick; + + // Functions + char rotateState(int16 from, int16 to); + void playSound(Snd::SoundDesc * snd, int16 repCount, int16 freq); + void drawObjects(void); + void animateObjects(void); + void placeObject(Gob_Object * objDesc, char animated); + int16 getObjMaxFrame(Gob_Object * obj); + int16 objIntersected(Gob_Object * obj1, Gob_Object * obj2); + void setMultStates(Gob_Object * gobDesc); + int16 nextLayer(Gob_Object * gobDesc); + void showBoredom(int16 gobIndex); + void switchGoblin(int16 index); + void freeObjects(void); + void zeroObjects(void); + void freeAllObjects(void); + void loadObjects(char *source); + void initVarPointers(void); + void saveGobDataToVars(int16 xPos, int16 yPos, int16 someVal); + void loadGobDataFromVars(void); + void pickItem(int16 indexToPocket, int16 idToPocket); + void placeItem(int16 indexInPocket, int16 idInPocket); + void swapItems(int16 indexToPick, int16 idToPick); + void treatItemPick(int16 itemId); + int16 treatItem(int16 action); + void interFunc(void); + + Goblin(GobEngine *vm); + +protected: + int16 rotStates[4][4]; + GobEngine *_vm; + + int16 peekGoblin(Gob_Object *curGob); + void initList(void); + void sortByOrder(Util::List *list); + void adjustDest(int16 posX, int16 posY); + void adjustTarget(void); + void targetDummyItem(Gob_Object *gobDesc); + void targetItem(void); + void initiateMove(void); + void moveFindItem(int16 posX, int16 posY); + void moveCheckSelect(int16 framesCount, Gob_Object * gobDesc, int16 *pGobIndex, int16 *nextAct); + void moveInitStep(int16 framesCount, int16 action, int16 cont, + Gob_Object *gobDesc, int16 *pGobIndex, int16 *pNextAct); + void moveTreatRopeStairs(Gob_Object *gobDesc); + void movePathFind(Gob_Object *gobDesc, int16 nextAct); + void moveAdvance(Gob_Object *gobDesc, int16 nextAct, int16 framesCount); + int16 doMove(Gob_Object *gobDesc, int16 cont, int16 action); +}; } // End of namespace Gob diff --git a/gob/init.cpp b/gob/init.cpp index 4e3367c393..f038b7ca51 100644 --- a/gob/init.cpp +++ b/gob/init.cpp @@ -36,102 +36,99 @@ namespace Gob { void game_start(void); -extern int16 debugFlag; -extern int16 inVM; -extern int16 colorCount; - -PalDesc *init_palDesc; - -static const char *init_fontNames[] = - { "jeulet1.let", "jeulet2.let", "jeucar1.let", "jeumath.let" }; - -void init_findBestCfg(void) { - videoMode = VIDMODE_VGA; - useMouse = mousePresent; - if (presentSound & BLASTER_FLAG) - soundFlags = BLASTER_FLAG | SPEAKER_FLAG | MIDI_FLAG; - else if (presentSound & PROAUDIO_FLAG) - soundFlags = PROAUDIO_FLAG | SPEAKER_FLAG | MIDI_FLAG; - else if (presentSound & ADLIB_FLAG) - soundFlags = ADLIB_FLAG | SPEAKER_FLAG | MIDI_FLAG; - else if (presentSound & INTERSOUND_FLAG) - soundFlags = INTERSOUND_FLAG | SPEAKER_FLAG; - else if (presentSound & SPEAKER_FLAG) - soundFlags = SPEAKER_FLAG; +const char *Init::fontNames[] = { "jeulet1.let", "jeulet2.let", "jeucar1.let", "jeumath.let" }; + +Init::Init(GobEngine *vm) : _vm(vm) { + palDesc = 0; +} + +void Init::findBestCfg(void) { + _vm->_global->videoMode = VIDMODE_VGA; + _vm->_global->useMouse = _vm->_global->mousePresent; + if (_vm->_global->presentSound & BLASTER_FLAG) + _vm->_global->soundFlags = BLASTER_FLAG | SPEAKER_FLAG | MIDI_FLAG; + else if (_vm->_global->presentSound & PROAUDIO_FLAG) + _vm->_global->soundFlags = PROAUDIO_FLAG | SPEAKER_FLAG | MIDI_FLAG; + else if (_vm->_global->presentSound & ADLIB_FLAG) + _vm->_global->soundFlags = ADLIB_FLAG | SPEAKER_FLAG | MIDI_FLAG; + else if (_vm->_global->presentSound & INTERSOUND_FLAG) + _vm->_global->soundFlags = INTERSOUND_FLAG | SPEAKER_FLAG; + else if (_vm->_global->presentSound & SPEAKER_FLAG) + _vm->_global->soundFlags = SPEAKER_FLAG; else - soundFlags = 0; + _vm->_global->soundFlags = 0; } -void init_soundVideo(int32 smallHeap, int16 flag) { - if (videoMode != 0x13 && videoMode != 0) - error("init_soundVideo: Video mode 0x%x is not supported!", - videoMode); +void Init::soundVideo(int32 smallHeap, int16 flag) { + if (_vm->_global->videoMode != 0x13 && _vm->_global->videoMode != 0) + error("soundVideo: Video mode 0x%x is not supported!", + _vm->_global->videoMode); //if ((flag & 4) == 0) - // vid_findVideo(); + // _vm->_video->findVideo(); - mousePresent = 1; + _vm->_global->mousePresent = 1; - inVM = 0; + _vm->_global->inVM = 0; - presentSound = 0; // FIXME: sound is not supported yet + _vm->_global->presentSound = 0; // FIXME: sound is not supported yet - sprAllocated = 0; - timer_enableTimer(); + _vm->_global->sprAllocated = 0; + _vm->_gtimer->enableTimer(); - // snd_setResetTimerFlag(debugFlag); // TODO + // _vm->_snd->setResetTimerFlag(debugFlag); // TODO - if (videoMode == 0x13) - colorCount = 256; + if (_vm->_global->videoMode == 0x13) + _vm->_global->colorCount = 256; - pPaletteDesc = &paletteStruct; - pPaletteDesc->vgaPal = vgaPalette; - pPaletteDesc->unused1 = unusedPalette1; - pPaletteDesc->unused2 = unusedPalette2; - pPrimarySurfDesc = &primarySurfDesc; + _vm->_global->pPaletteDesc = &_vm->_global->paletteStruct; + _vm->_global->pPaletteDesc->vgaPal = _vm->_global->vgaPalette; + _vm->_global->pPaletteDesc->unused1 = _vm->_global->unusedPalette1; + _vm->_global->pPaletteDesc->unused2 = _vm->_global->unusedPalette2; + _vm->_global->pPrimarySurfDesc = &_vm->_global->primarySurfDesc; - if (videoMode != 0) - vid_initSurfDesc(videoMode, 320, 200, PRIMARY_SURFACE); + if (_vm->_global->videoMode != 0) + _vm->_video->initSurfDesc(_vm->_global->videoMode, 320, 200, PRIMARY_SURFACE); - if (soundFlags & MIDI_FLAG) { - soundFlags &= presentSound; - if (presentSound & ADLIB_FLAG) - soundFlags |= MIDI_FLAG; + if (_vm->_global->soundFlags & MIDI_FLAG) { + _vm->_global->soundFlags &= _vm->_global->presentSound; + if (_vm->_global->presentSound & ADLIB_FLAG) + _vm->_global->soundFlags |= MIDI_FLAG; } else { - soundFlags &= presentSound; + _vm->_global->soundFlags &= _vm->_global->presentSound; } } -void init_cleanup(void) { - if (debugFlag == 0) - timer_disableTimer(); +void Init::cleanup(void) { + if (_vm->_global->debugFlag == 0) + _vm->_gtimer->disableTimer(); - vid_freeDriver(); - if (curPrimaryDesc != 0) { - vid_freeSurfDesc(curPrimaryDesc); - vid_freeSurfDesc(allocatedPrimary); - allocatedPrimary = 0; - curPrimaryDesc = 0; + _vm->_video->freeDriver(); + if (_vm->_global->curPrimaryDesc != 0) { + _vm->_video->freeSurfDesc(_vm->_global->curPrimaryDesc); + _vm->_video->freeSurfDesc(_vm->_global->allocatedPrimary); + _vm->_global->allocatedPrimary = 0; + _vm->_global->curPrimaryDesc = 0; } - pPrimarySurfDesc = 0; - if (snd_cleanupFunc != 0 && snd_playingSound != 0) { - (*snd_cleanupFunc) (0); - snd_cleanupFunc = 0; + _vm->_global->pPrimarySurfDesc = 0; + if (_vm->_snd->cleanupFunc != 0 && _vm->_snd->playingSound != 0) { + (*_vm->_snd->cleanupFunc) (0); + _vm->_snd->cleanupFunc = 0; } - snd_speakerOff(); + _vm->_snd->speakerOff(); - data_closeDataFile(); + _vm->_dataio->closeDataFile(); - if (sprAllocated != 0) - error("init_cleanup: Error! Allocated sprites left: %d", - sprAllocated); + if (_vm->_global->sprAllocated != 0) + error("cleanup: Error! Allocated sprites left: %d", + _vm->_global->sprAllocated); - snd_stopSound(0); - keyboard_release(); + _vm->_snd->stopSound(0); + _vm->_util->keyboard_release(); g_system->quit(); } -void init_initGame(char *totName) { +void Init::initGame(char *totName) { int16 handle2; int16 i; int16 handle; @@ -154,58 +151,58 @@ numFromTot = word ptr -0Ah memAvail = dword ptr -6 memBlocks = word ptr -2*/ - disableVideoCfg = 0x11; - disableMouseCfg = 0x15; - init_soundVideo(1000, 1); + _vm->_global->disableVideoCfg = 0x11; + _vm->_global->disableMouseCfg = 0x15; + soundVideo(1000, 1); - handle2 = data_openData("intro.stk"); + handle2 = _vm->_dataio->openData("intro.stk"); if (handle2 >= 0) { - data_closeData(handle2); - data_openDataFile("intro.stk"); + _vm->_dataio->closeData(handle2); + _vm->_dataio->openDataFile("intro.stk"); } - util_initInput(); + _vm->_util->initInput(); - vid_setHandlers(); - vid_initPrimary(videoMode); - mouseXShift = 1; - mouseYShift = 1; + _vm->_video->setHandlers(); + _vm->_video->initPrimary(_vm->_global->videoMode); + _vm->_global->mouseXShift = 1; + _vm->_global->mouseYShift = 1; - game_totTextData = 0; - game_totFileData = 0; - game_totResourceTable = 0; - inter_variables = 0; - init_palDesc = (PalDesc *)malloc(12); + _vm->_game->totTextData = 0; + _vm->_game->totFileData = 0; + _vm->_game->totResourceTable = 0; + _vm->_global->inter_variables = 0; + palDesc = (Video::PalDesc *)malloc(12); - if (videoMode != 0x13) - error("init_initGame: Only 0x13 video mode is supported!"); + if (_vm->_global->videoMode != 0x13) + error("initGame: Only 0x13 video mode is supported!"); - init_palDesc->vgaPal = draw_vgaPalette; - init_palDesc->unused1 = draw_unusedPalette1; - init_palDesc->unused2 = draw_unusedPalette2; - vid_setFullPalette(init_palDesc); + palDesc->vgaPal = _vm->_draw->vgaPalette; + palDesc->unused1 = _vm->_draw->unusedPalette1; + palDesc->unused2 = _vm->_draw->unusedPalette2; + _vm->_video->setFullPalette(palDesc); for (i = 0; i < 4; i++) - draw_fonts[i] = 0; + _vm->_draw->fonts[i] = 0; - handle = data_openData("intro.inf"); + handle = _vm->_dataio->openData("intro.inf"); if (handle < 0) { for (i = 0; i < 4; i++) { - handle2 = data_openData(init_fontNames[i]); + handle2 = _vm->_dataio->openData(fontNames[i]); if (handle2 >= 0) { - data_closeData(handle2); - draw_fonts[i] = - util_loadFont(init_fontNames[i]); + _vm->_dataio->closeData(handle2); + _vm->_draw->fonts[i] = + _vm->_util->loadFont(fontNames[i]); } } } else { - data_closeData(handle); + _vm->_dataio->closeData(handle); - infPtr = data_getData("intro.inf"); + infPtr = _vm->_dataio->getData("intro.inf"); infBuf = infPtr; - infEnd = infBuf + data_getDataSize("intro.inf"); + infEnd = infBuf + _vm->_dataio->getDataSize("intro.inf"); for (i = 0; i < 4; i++, infPtr++) { for (j = 0; *infPtr >= ' ' && infPtr != infEnd; @@ -214,10 +211,10 @@ memBlocks = word ptr -2*/ buffer[j] = 0; strcat(buffer, ".let"); - handle2 = data_openData(buffer); + handle2 = _vm->_dataio->openData(buffer); if (handle2 >= 0) { - data_closeData(handle2); - draw_fonts[i] = util_loadFont(buffer); + _vm->_dataio->closeData(handle2); + _vm->_draw->fonts[i] = _vm->_util->loadFont(buffer); } if (infPtr == infEnd) @@ -238,42 +235,42 @@ memBlocks = word ptr -2*/ strcpy(buffer, "intro.tot"); } - handle = data_openData(buffer); + handle = _vm->_dataio->openData(buffer); if (handle >= 0) { // Get variables count - data_seekData(handle, 0x2c, SEEK_SET); - data_readData(handle, (char *)&varsCount, 4); + _vm->_dataio->seekData(handle, 0x2c, SEEK_SET); + _vm->_dataio->readData(handle, (char *)&varsCount, 4); varsCount = FROM_LE_32(varsCount); - data_closeData(handle); + _vm->_dataio->closeData(handle); - inter_variables = (char *)malloc(varsCount * 4); - memset(inter_variables, 0, varsCount * 4); + _vm->_global->inter_variables = (char *)malloc(varsCount * 4); + memset(_vm->_global->inter_variables, 0, varsCount * 4); - strcpy(game_curTotFile, buffer); + strcpy(_vm->_game->curTotFile, buffer); - cd_testCD(1, "GOB"); - cd_readLIC("gob.lic"); - game_start(); + _vm->_cdrom->testCD(1, "GOB"); + _vm->_cdrom->readLIC("gob.lic"); + _vm->_game->start(); - cd_stopPlaying(); - cd_freeLICbuffer(); + _vm->_cdrom->stopPlaying(); + _vm->_cdrom->freeLICbuffer(); - free(inter_variables); - free(game_totFileData); - free(game_totTextData); - free(game_totResourceTable); + free(_vm->_global->inter_variables); + free(_vm->_game->totFileData); + free(_vm->_game->totTextData); + free(_vm->_game->totResourceTable); } for (i = 0; i < 4; i++) { - if (draw_fonts[i] != 0) - util_freeFont(draw_fonts[i]); + if (_vm->_draw->fonts[i] != 0) + _vm->_util->freeFont(_vm->_draw->fonts[i]); } - free(init_palDesc); - data_closeDataFile(); - vid_initPrimary(-1); - init_cleanup(); + free(palDesc); + _vm->_dataio->closeDataFile(); + _vm->_video->initPrimary(-1); + cleanup(); } } // End of namespace Gob diff --git a/gob/init.h b/gob/init.h index a54c5d064f..964ea0f582 100644 --- a/gob/init.h +++ b/gob/init.h @@ -24,10 +24,22 @@ namespace Gob { -void init_findBestCfg(void); -void init_soundVideo(int32 smallHeapSize, int16 flag); +class Init { +public: + void findBestCfg(void); + void soundVideo(int32 smallHeapSize, int16 flag); -void init_initGame(char *totFile); + void initGame(char *totFile); + + Init(GobEngine *vm); + +protected: + Video::PalDesc *palDesc; + static const char *fontNames[4]; + GobEngine *_vm; + + void cleanup(void); +}; } // End of namespace Gob diff --git a/gob/inter.cpp b/gob/inter.cpp index d4022542bb..50c063cff2 100644 --- a/gob/inter.cpp +++ b/gob/inter.cpp @@ -33,42 +33,44 @@ namespace Gob { -int16 inter_animPalLowIndex; -int16 inter_animPalHighIndex; -int16 inter_animPalDir; -uint32 inter_soundEndTimeKey; -int16 inter_soundStopVal; -char inter_terminate = 0; -char inter_breakFlag = 0; -int16 *inter_breakFromLevel; -int16 *inter_nestLevel; - -int16 inter_load16(void) { - int16 tmp = (int16)READ_LE_UINT16(inter_execPtr); - inter_execPtr += 2; +Inter::Inter(GobEngine *vm) : _vm(vm) { + terminate = 0; + breakFlag = 0; + animPalLowIndex = 0; + animPalHighIndex = 0; + animPalDir = 0; + soundEndTimeKey = 0; + soundStopVal = 0; + breakFromLevel = 0; + nestLevel = 0; +} + +int16 Inter::load16(void) { + int16 tmp = (int16)READ_LE_UINT16(_vm->_global->inter_execPtr); + _vm->_global->inter_execPtr += 2; return tmp; } -void inter_setMousePos(void) { - inter_mouseX = parse_parseValExpr(); - inter_mouseY = parse_parseValExpr(); - if (useMouse != 0) - util_setMousePos(inter_mouseX, inter_mouseY); +void Inter::setMousePos(void) { + _vm->_global->inter_mouseX = _vm->_parse->parseValExpr(); + _vm->_global->inter_mouseY = _vm->_parse->parseValExpr(); + if (_vm->_global->useMouse != 0) + _vm->_util->setMousePos(_vm->_global->inter_mouseX, _vm->_global->inter_mouseY); } -char inter_evalExpr(int16 *pRes) { +char Inter::evalExpr(int16 *pRes) { byte token; // - parse_printExpr(99); + _vm->_parse->printExpr(99); - parse_parseExpr(99, &token); + _vm->_parse->parseExpr(99, &token); if (pRes == 0) return token; switch (token) { case 20: - *pRes = inter_resVal; + *pRes = _vm->_global->inter_resVal; break; case 22: @@ -83,291 +85,291 @@ char inter_evalExpr(int16 *pRes) { return token; } -char inter_evalBoolResult() { +char Inter::evalBoolResult() { byte token; - parse_printExpr(99); + _vm->_parse->printExpr(99); - parse_parseExpr(99, &token); - if (token == 24 || (token == 20 && inter_resVal != 0)) + _vm->_parse->parseExpr(99, &token); + if (token == 24 || (token == 20 && _vm->_global->inter_resVal != 0)) return 1; else return 0; } -void inter_evaluateStore(void) { +void Inter::evaluateStore(void) { char *savedPos; int16 token; int16 result; int16 varOff; - savedPos = inter_execPtr; - varOff = parse_parseVarIndex(); - token = inter_evalExpr(&result); + savedPos = _vm->_global->inter_execPtr; + varOff = _vm->_parse->parseVarIndex(); + token = evalExpr(&result); switch (savedPos[0]) { case 23: case 26: - WRITE_VAR_OFFSET(varOff, inter_resVal); + WRITE_VAR_OFFSET(varOff, _vm->_global->inter_resVal); break; case 25: case 28: if (token == 20) - *(inter_variables + varOff) = result; + *(_vm->_global->inter_variables + varOff) = result; else - strcpy(inter_variables + varOff, inter_resStr); + strcpy(_vm->_global->inter_variables + varOff, _vm->_global->inter_resStr); break; } return; } -void inter_capturePush(void) { +void Inter::capturePush(void) { int16 left; int16 top; int16 width; int16 height; - left = parse_parseValExpr(); - top = parse_parseValExpr(); - width = parse_parseValExpr(); - height = parse_parseValExpr(); - game_capturePush(left, top, width, height); - (*scen_pCaptureCounter)++; + left = _vm->_parse->parseValExpr(); + top = _vm->_parse->parseValExpr(); + width = _vm->_parse->parseValExpr(); + height = _vm->_parse->parseValExpr(); + _vm->_game->capturePush(left, top, width, height); + (*_vm->_scenery->pCaptureCounter)++; } -void inter_capturePop(void) { - if (*scen_pCaptureCounter != 0) { - (*scen_pCaptureCounter)--; - game_capturePop(1); +void Inter::capturePop(void) { + if (*_vm->_scenery->pCaptureCounter != 0) { + (*_vm->_scenery->pCaptureCounter)--; + _vm->_game->capturePop(1); } } -void inter_printText(void) { +void Inter::printText(void) { char buf[60]; int16 i; - debug(3, "inter_printText"); - draw_destSpriteX = parse_parseValExpr(); - draw_destSpriteY = parse_parseValExpr(); + debug(3, "printText"); + _vm->_draw->destSpriteX = _vm->_parse->parseValExpr(); + _vm->_draw->destSpriteY = _vm->_parse->parseValExpr(); - draw_backColor = parse_parseValExpr(); - draw_frontColor = parse_parseValExpr(); - draw_fontIndex = parse_parseValExpr(); - draw_destSurface = 21; - draw_textToPrint = buf; - draw_transparency = 0; + _vm->_draw->backColor = _vm->_parse->parseValExpr(); + _vm->_draw->frontColor = _vm->_parse->parseValExpr(); + _vm->_draw->fontIndex = _vm->_parse->parseValExpr(); + _vm->_draw->destSurface = 21; + _vm->_draw->textToPrint = buf; + _vm->_draw->transparency = 0; - if (draw_backColor >= 16) { - draw_backColor = 0; - draw_transparency = 1; + if (_vm->_draw->backColor >= 16) { + _vm->_draw->backColor = 0; + _vm->_draw->transparency = 1; } do { - for (i = 0; *inter_execPtr != '.' && (byte)*inter_execPtr != 200; - i++, inter_execPtr++) { - buf[i] = *inter_execPtr; + for (i = 0; *_vm->_global->inter_execPtr != '.' && (byte)*_vm->_global->inter_execPtr != 200; + i++, _vm->_global->inter_execPtr++) { + buf[i] = *_vm->_global->inter_execPtr; } - if ((byte)*inter_execPtr != 200) { - inter_execPtr++; - switch (*inter_execPtr) { + if ((byte)*_vm->_global->inter_execPtr != 200) { + _vm->_global->inter_execPtr++; + switch (*_vm->_global->inter_execPtr) { case 23: case 26: - sprintf(buf + i, "%d", VAR_OFFSET(parse_parseVarIndex())); + sprintf(buf + i, "%d", VAR_OFFSET(_vm->_parse->parseVarIndex())); break; case 25: case 28: - sprintf(buf + i, "%s", inter_variables + parse_parseVarIndex()); + sprintf(buf + i, "%s", _vm->_global->inter_variables + _vm->_parse->parseVarIndex()); break; } - inter_execPtr++; + _vm->_global->inter_execPtr++; } else { buf[i] = 0; } - draw_spriteOperation(DRAW_PRINTTEXT); - } while ((byte)*inter_execPtr != 200); - inter_execPtr++; + _vm->_draw->spriteOperation(DRAW_PRINTTEXT); + } while ((byte)*_vm->_global->inter_execPtr != 200); + _vm->_global->inter_execPtr++; } -void inter_animPalette(void) { +void Inter::animPalette(void) { int16 i; - Color col; + Video::Color col; - if (inter_animPalDir == 0) + if (animPalDir == 0) return; - vid_waitRetrace(videoMode); + _vm->_video->waitRetrace(_vm->_global->videoMode); - if (inter_animPalDir == -1) { - col = draw_vgaSmallPalette[inter_animPalLowIndex]; + if (animPalDir == -1) { + col = _vm->_draw->vgaSmallPalette[animPalLowIndex]; - for (i = inter_animPalLowIndex; i < inter_animPalHighIndex; i++) - draw_vgaSmallPalette[i] = draw_vgaSmallPalette[i + 1]; + for (i = animPalLowIndex; i < animPalHighIndex; i++) + _vm->_draw->vgaSmallPalette[i] = _vm->_draw->vgaSmallPalette[i + 1]; - draw_vgaSmallPalette[inter_animPalHighIndex] = col; + _vm->_draw->vgaSmallPalette[animPalHighIndex] = col; } else { - col = draw_vgaSmallPalette[inter_animPalHighIndex]; - for (i = inter_animPalHighIndex; i > inter_animPalLowIndex; i--) - draw_vgaSmallPalette[i] = draw_vgaSmallPalette[i - 1]; + col = _vm->_draw->vgaSmallPalette[animPalHighIndex]; + for (i = animPalHighIndex; i > animPalLowIndex; i--) + _vm->_draw->vgaSmallPalette[i] = _vm->_draw->vgaSmallPalette[i - 1]; - draw_vgaSmallPalette[inter_animPalLowIndex] = col; + _vm->_draw->vgaSmallPalette[animPalLowIndex] = col; } - pPaletteDesc->vgaPal = draw_vgaSmallPalette; - vid_setFullPalette(pPaletteDesc); + _vm->_global->pPaletteDesc->vgaPal = _vm->_draw->vgaSmallPalette; + _vm->_video->setFullPalette(_vm->_global->pPaletteDesc); } -void inter_animPalInit(void) { - inter_animPalDir = inter_load16(); - inter_animPalLowIndex = parse_parseValExpr(); - inter_animPalHighIndex = parse_parseValExpr(); +void Inter::animPalInit(void) { + animPalDir = load16(); + animPalLowIndex = _vm->_parse->parseValExpr(); + animPalHighIndex = _vm->_parse->parseValExpr(); } -void inter_loadMult(void) { +void Inter::loadMult(void) { int16 resId; - resId = inter_load16(); - mult_loadMult(resId); + resId = load16(); + _vm->_mult->loadMult(resId); } -void inter_playMult(void) { +void Inter::playMult(void) { int16 checkEscape; - checkEscape = inter_load16(); - mult_playMult(VAR(57), -1, checkEscape, 0); + checkEscape = load16(); + _vm->_mult->playMult(VAR(57), -1, checkEscape, 0); } -void inter_freeMult(void) { - inter_load16(); // unused - mult_freeMultKeys(); +void Inter::freeMult(void) { + load16(); // unused + _vm->_mult->freeMultKeys(); } -void inter_initCursor(void) { +void Inter::initCursor(void) { int16 width; int16 height; int16 count; int16 i; - draw_cursorXDeltaVar = parse_parseVarIndex(); - draw_cursorYDeltaVar = parse_parseVarIndex(); + _vm->_draw->cursorXDeltaVar = _vm->_parse->parseVarIndex(); + _vm->_draw->cursorYDeltaVar = _vm->_parse->parseVarIndex(); - width = inter_load16(); + width = load16(); if (width < 16) width = 16; - height = inter_load16(); + height = load16(); if (height < 16) height = 16; - count = inter_load16(); + count = load16(); if (count < 2) count = 2; - if (width != draw_cursorWidth || height != draw_cursorHeight || - draw_cursorSprites->width != width * count) { + if (width != _vm->_draw->cursorWidth || height != _vm->_draw->cursorHeight || + _vm->_draw->cursorSprites->width != width * count) { - vid_freeSurfDesc(draw_cursorSprites); - vid_freeSurfDesc(draw_cursorBack); + _vm->_video->freeSurfDesc(_vm->_draw->cursorSprites); + _vm->_video->freeSurfDesc(_vm->_draw->cursorBack); - draw_cursorWidth = width; - draw_cursorHeight = height; + _vm->_draw->cursorWidth = width; + _vm->_draw->cursorHeight = height; if (count < 0x80) - draw_transparentCursor = 1; + _vm->_draw->transparentCursor = 1; else - draw_transparentCursor = 0; + _vm->_draw->transparentCursor = 0; if (count > 0x80) count -= 0x80; - draw_cursorSprites = - vid_initSurfDesc(videoMode, draw_cursorWidth * count, - draw_cursorHeight, 2); - draw_spritesArray[23] = draw_cursorSprites; + _vm->_draw->cursorSprites = + _vm->_video->initSurfDesc(_vm->_global->videoMode, _vm->_draw->cursorWidth * count, + _vm->_draw->cursorHeight, 2); + _vm->_draw->spritesArray[23] = _vm->_draw->cursorSprites; - draw_cursorBack = - vid_initSurfDesc(videoMode, draw_cursorWidth, - draw_cursorHeight, 0); + _vm->_draw->cursorBack = + _vm->_video->initSurfDesc(_vm->_global->videoMode, _vm->_draw->cursorWidth, + _vm->_draw->cursorHeight, 0); for (i = 0; i < 40; i++) { - draw_cursorAnimLow[i] = -1; - draw_cursorAnimDelays[i] = 0; - draw_cursorAnimHigh[i] = 0; + _vm->_draw->cursorAnimLow[i] = -1; + _vm->_draw->cursorAnimDelays[i] = 0; + _vm->_draw->cursorAnimHigh[i] = 0; } - draw_cursorAnimLow[1] = 0; + _vm->_draw->cursorAnimLow[1] = 0; } } -void inter_initCursorAnim(void) { +void Inter::initCursorAnim(void) { int16 ind; - ind = parse_parseValExpr(); - draw_cursorAnimLow[ind] = inter_load16(); - draw_cursorAnimHigh[ind] = inter_load16(); - draw_cursorAnimDelays[ind] = inter_load16(); + ind = _vm->_parse->parseValExpr(); + _vm->_draw->cursorAnimLow[ind] = load16(); + _vm->_draw->cursorAnimHigh[ind] = load16(); + _vm->_draw->cursorAnimDelays[ind] = load16(); } -void inter_clearCursorAnim(void) { +void Inter::clearCursorAnim(void) { int16 ind; - ind = parse_parseValExpr(); - draw_cursorAnimLow[ind] = -1; - draw_cursorAnimHigh[ind] = 0; - draw_cursorAnimDelays[ind] = 0; + ind = _vm->_parse->parseValExpr(); + _vm->_draw->cursorAnimLow[ind] = -1; + _vm->_draw->cursorAnimHigh[ind] = 0; + _vm->_draw->cursorAnimDelays[ind] = 0; } -void inter_drawOperations(void) { +void Inter::drawOperations(void) { byte cmd; int16 i; - cmd = *inter_execPtr++; + cmd = *_vm->_global->inter_execPtr++; - debug(4, "inter_drawOperations(%d)", cmd); + debug(4, "drawOperations(%d)", cmd); switch (cmd) { case 0: - inter_loadMult(); + loadMult(); break; case 1: - inter_playMult(); + playMult(); break; case 2: - inter_freeMult(); + freeMult(); break; case 7: - inter_initCursor(); + initCursor(); break; case 8: - inter_initCursorAnim(); + initCursorAnim(); break; case 9: - inter_clearCursorAnim(); + clearCursorAnim(); break; case 10: - draw_renderFlags = parse_parseValExpr(); + _vm->_draw->renderFlags = _vm->_parse->parseValExpr(); break; case 11: - //word_23EC_DE = parse_parseValExpr(); + //word_23EC_DE = _vm->_parse->parseValExpr(); break; case 16: - scen_loadAnim(0); + _vm->_scenery->loadAnim(0); break; case 17: - scen_freeAnim(-1); + _vm->_scenery->freeAnim(-1); break; case 18: - scen_interUpdateAnim(); + _vm->_scenery->interUpdateAnim(); break; case 19: @@ -375,50 +377,50 @@ void inter_drawOperations(void) { break; case 20: - mult_interInitMult(); + _vm->_mult->interInitMult(); break; case 21: - mult_freeMult(); + _vm->_mult->freeMult(); break; case 22: - mult_animate(); + _vm->_mult->animate(); break; case 23: - mult_interLoadMult(); + _vm->_mult->interLoadMult(); break; case 24: - scen_interStoreParams(); + _vm->_scenery->interStoreParams(); break; case 25: - mult_interGetObjAnimSize(); + _vm->_mult->interGetObjAnimSize(); break; case 26: - scen_loadStatic(0); + _vm->_scenery->loadStatic(0); break; case 27: - scen_freeStatic(-1); + _vm->_scenery->freeStatic(-1); break; case 28: - scen_interRenderStatic(); + _vm->_scenery->interRenderStatic(); break; case 29: - scen_interLoadCurLayer(); + _vm->_scenery->interLoadCurLayer(); break; case 32: if (_vm->_features & GF_GOB1) { // Used in gob1 CD - inter_evalExpr(0); - cd_startTrack(inter_resStr); + evalExpr(0); + _vm->_cdrom->startTrack(_vm->_global->inter_resStr); } else { } break; @@ -431,9 +433,9 @@ void inter_drawOperations(void) { // This is a very nasty thing to do, so let's add a // short delay here. It's probably a safe thing to do. - util_longDelay(1); + _vm->_util->longDelay(1); - int pos = cd_getTrackPos(); + int pos = _vm->_cdrom->getTrackPos(); if (pos == -1) pos = 32767; WRITE_VAR(5, pos); @@ -444,7 +446,7 @@ void inter_drawOperations(void) { case 34: if (_vm->_features & GF_GOB1) { // Used in gob1 CD - cd_stopPlaying(); + _vm->_cdrom->stopPlaying(); } else { } break; @@ -465,19 +467,19 @@ void inter_drawOperations(void) { break; case 48: - i = inter_load16(); - draw_fontToSprite[i].sprite = inter_load16(); - draw_fontToSprite[i].base = inter_load16(); - draw_fontToSprite[i].width = inter_load16(); - draw_fontToSprite[i].height = inter_load16(); + i = load16(); + _vm->_draw->fontToSprite[i].sprite = load16(); + _vm->_draw->fontToSprite[i].base = load16(); + _vm->_draw->fontToSprite[i].width = load16(); + _vm->_draw->fontToSprite[i].height = load16(); break; case 49: - i = inter_load16(); - draw_fontToSprite[i].sprite = -1; - draw_fontToSprite[i].base = -1; - draw_fontToSprite[i].width = -1; - draw_fontToSprite[i].height = -1; + i = load16(); + _vm->_draw->fontToSprite[i].sprite = -1; + _vm->_draw->fontToSprite[i].base = -1; + _vm->_draw->fontToSprite[i].width = -1; + _vm->_draw->fontToSprite[i].height = -1; break; case 64: @@ -585,309 +587,309 @@ void inter_drawOperations(void) { } } -void inter_getFreeMem(void) { +void Inter::getFreeMem(void) { int16 freeVar; int16 maxFreeVar; - freeVar = parse_parseVarIndex(); - maxFreeVar = parse_parseVarIndex(); + freeVar = _vm->_parse->parseVarIndex(); + maxFreeVar = _vm->_parse->parseVarIndex(); // HACK WRITE_VAR_OFFSET(freeVar, 1000000); WRITE_VAR_OFFSET(maxFreeVar, 1000000); } -void inter_manageDataFile(void) { - inter_evalExpr(0); +void Inter::manageDataFile(void) { + evalExpr(0); - if (inter_resStr[0] != 0) - data_openDataFile(inter_resStr); + if (_vm->_global->inter_resStr[0] != 0) + _vm->_dataio->openDataFile(_vm->_global->inter_resStr); else - data_closeDataFile(); + _vm->_dataio->closeDataFile(); } -void inter_writeData(void) { +void Inter::writeData(void) { int16 offset; int16 handle; int16 size; int16 dataVar; int16 retSize; - debug(4, "inter_writeData"); - inter_evalExpr(0); - dataVar = parse_parseVarIndex(); - size = parse_parseValExpr(); - offset = parse_parseValExpr(); + debug(4, "writeData"); + evalExpr(0); + dataVar = _vm->_parse->parseVarIndex(); + size = _vm->_parse->parseValExpr(); + offset = _vm->_parse->parseValExpr(); WRITE_VAR(1, 1); - handle = data_openData(inter_resStr, Common::File::kFileWriteMode); + handle = _vm->_dataio->openData(_vm->_global->inter_resStr, Common::File::kFileWriteMode); if (handle < 0) return; if (offset < 0) { - data_seekData(handle, -offset - 1, 2); + _vm->_dataio->seekData(handle, -offset - 1, 2); } else { - data_seekData(handle, offset, 0); + _vm->_dataio->seekData(handle, offset, 0); } - retSize = file_getHandle(handle)->write(inter_variables + dataVar, size); + retSize = _vm->_dataio->file_getHandle(handle)->write(_vm->_global->inter_variables + dataVar, size); if (retSize == size) WRITE_VAR(1, 0); - data_closeData(handle); + _vm->_dataio->closeData(handle); } -void inter_checkData(void) { +void Inter::checkData(void) { int16 handle; int16 varOff; - debug(4, "data_cheackData"); - inter_evalExpr(0); - varOff = parse_parseVarIndex(); - handle = data_openData(inter_resStr); + debug(4, "_vm->_dataio->cheackData"); + evalExpr(0); + varOff = _vm->_parse->parseVarIndex(); + handle = _vm->_dataio->openData(_vm->_global->inter_resStr); WRITE_VAR_OFFSET(varOff, handle); if (handle >= 0) - data_closeData(handle); + _vm->_dataio->closeData(handle); } -void inter_readData(void) { +void Inter::readData(void) { int16 retSize; int16 size; int16 dataVar; int16 offset; int16 handle; - debug(4, "inter_readData"); - inter_evalExpr(0); - dataVar = parse_parseVarIndex(); - size = parse_parseValExpr(); - offset = parse_parseValExpr(); + debug(4, "readData"); + evalExpr(0); + dataVar = _vm->_parse->parseVarIndex(); + size = _vm->_parse->parseValExpr(); + offset = _vm->_parse->parseValExpr(); - if (game_extHandle >= 0) - data_closeData(game_extHandle); + if (_vm->_game->extHandle >= 0) + _vm->_dataio->closeData(_vm->_game->extHandle); WRITE_VAR(1, 1); - handle = data_openData(inter_resStr); + handle = _vm->_dataio->openData(_vm->_global->inter_resStr); if (handle >= 0) { - draw_animateCursor(4); + _vm->_draw->animateCursor(4); if (offset < 0) - data_seekData(handle, -offset - 1, 2); + _vm->_dataio->seekData(handle, -offset - 1, 2); else - data_seekData(handle, offset, 0); + _vm->_dataio->seekData(handle, offset, 0); - retSize = data_readData(handle, inter_variables + dataVar, size); - data_closeData(handle); + retSize = _vm->_dataio->readData(handle, _vm->_global->inter_variables + dataVar, size); + _vm->_dataio->closeData(handle); if (retSize == size) WRITE_VAR(1, 0); } - if (game_extHandle >= 0) - game_extHandle = data_openData(game_curExtFile); + if (_vm->_game->extHandle >= 0) + _vm->_game->extHandle = _vm->_dataio->openData(_vm->_game->curExtFile); } -void inter_loadFont(void) { +void Inter::loadFont(void) { int16 index; - debug(4, "inter_loadFont"); - inter_evalExpr(0); - index = inter_load16(); + debug(4, "loadFont"); + evalExpr(0); + index = load16(); - if (draw_fonts[index] != 0) - util_freeFont(draw_fonts[index]); + if (_vm->_draw->fonts[index] != 0) + _vm->_util->freeFont(_vm->_draw->fonts[index]); - draw_animateCursor(4); - if (game_extHandle >= 0) - data_closeData(game_extHandle); + _vm->_draw->animateCursor(4); + if (_vm->_game->extHandle >= 0) + _vm->_dataio->closeData(_vm->_game->extHandle); - draw_fonts[index] = util_loadFont(inter_resStr); + _vm->_draw->fonts[index] = _vm->_util->loadFont(_vm->_global->inter_resStr); - if (game_extHandle >= 0) - game_extHandle = data_openData(game_curExtFile); + if (_vm->_game->extHandle >= 0) + _vm->_game->extHandle = _vm->_dataio->openData(_vm->_game->curExtFile); } -void inter_freeFont(void) { +void Inter::freeFont(void) { int16 index; - index = inter_load16(); - if (draw_fonts[index] != 0) - util_freeFont(draw_fonts[index]); + index = load16(); + if (_vm->_draw->fonts[index] != 0) + _vm->_util->freeFont(_vm->_draw->fonts[index]); - draw_fonts[index] = 0; + _vm->_draw->fonts[index] = 0; } -void inter_prepareStr(void) { +void Inter::prepareStr(void) { int16 var; - var = parse_parseVarIndex(); - util_prepareStr(inter_variables + var); + var = _vm->_parse->parseVarIndex(); + _vm->_util->prepareStr(_vm->_global->inter_variables + var); } -void inter_insertStr(void) { +void Inter::insertStr(void) { int16 pos; int16 strVar; - strVar = parse_parseVarIndex(); - inter_evalExpr(0); - pos = parse_parseValExpr(); - util_insertStr(inter_resStr, inter_variables + strVar, pos); + strVar = _vm->_parse->parseVarIndex(); + evalExpr(0); + pos = _vm->_parse->parseValExpr(); + _vm->_util->insertStr(_vm->_global->inter_resStr, _vm->_global->inter_variables + strVar, pos); } -void inter_cutStr(void) { +void Inter::cutStr(void) { int16 var; int16 pos; int16 size; - var = parse_parseVarIndex(); - pos = parse_parseValExpr(); - size = parse_parseValExpr(); - util_cutFromStr(inter_variables + var, pos, size); + var = _vm->_parse->parseVarIndex(); + pos = _vm->_parse->parseValExpr(); + size = _vm->_parse->parseValExpr(); + _vm->_util->cutFromStr(_vm->_global->inter_variables + var, pos, size); } -void inter_strstr(void) { +void Inter::strstr(void) { int16 strVar; int16 resVar; int16 pos; - strVar = parse_parseVarIndex(); - inter_evalExpr(0); - resVar = parse_parseVarIndex(); + strVar = _vm->_parse->parseVarIndex(); + evalExpr(0); + resVar = _vm->_parse->parseVarIndex(); - pos = util_strstr(inter_resStr, inter_variables + strVar); + pos = _vm->_util->strstr(_vm->_global->inter_resStr, _vm->_global->inter_variables + strVar); WRITE_VAR_OFFSET(resVar, pos - 1); } -void inter_setFrameRate(void) { - util_setFrameRate(parse_parseValExpr()); +void Inter::setFrameRate(void) { + _vm->_util->setFrameRate(_vm->_parse->parseValExpr()); } -void inter_strlen(void) { +void Inter::istrlen(void) { int16 len; int16 var; - var = parse_parseVarIndex(); - len = strlen(inter_variables + var); - var = parse_parseVarIndex(); + var = _vm->_parse->parseVarIndex(); + len = strlen(_vm->_global->inter_variables + var); + var = _vm->_parse->parseVarIndex(); WRITE_VAR_OFFSET(var, len); } -void inter_strToLong(void) { +void Inter::strToLong(void) { char str[20]; int16 strVar; int16 destVar; int32 res; - strVar = parse_parseVarIndex(); - strcpy(str, inter_variables + strVar); + strVar = _vm->_parse->parseVarIndex(); + strcpy(str, _vm->_global->inter_variables + strVar); res = atol(str); - destVar = parse_parseVarIndex(); + destVar = _vm->_parse->parseVarIndex(); WRITE_VAR_OFFSET(destVar, res); } -void inter_invalidate(void) { - warning("inter_invalidate: 'bugged' function!"); - draw_destSurface = inter_load16(); - draw_destSpriteX = parse_parseValExpr(); - draw_destSpriteY = parse_parseValExpr(); - draw_spriteRight = parse_parseValExpr(); - draw_frontColor = parse_parseValExpr(); - draw_spriteOperation(DRAW_INVALIDATE); +void Inter::invalidate(void) { + warning("invalidate: 'bugged' function!"); + _vm->_draw->destSurface = load16(); + _vm->_draw->destSpriteX = _vm->_parse->parseValExpr(); + _vm->_draw->destSpriteY = _vm->_parse->parseValExpr(); + _vm->_draw->spriteRight = _vm->_parse->parseValExpr(); + _vm->_draw->frontColor = _vm->_parse->parseValExpr(); + _vm->_draw->spriteOperation(DRAW_INVALIDATE); } -void inter_loadSpriteContent(void) { - draw_spriteLeft = inter_load16(); - draw_destSurface = inter_load16(); - draw_transparency = inter_load16(); - draw_destSpriteX = 0; - draw_destSpriteY = 0; - draw_spriteOperation(DRAW_LOADSPRITE); +void Inter::loadSpriteContent(void) { + _vm->_draw->spriteLeft = load16(); + _vm->_draw->destSurface = load16(); + _vm->_draw->transparency = load16(); + _vm->_draw->destSpriteX = 0; + _vm->_draw->destSpriteY = 0; + _vm->_draw->spriteOperation(DRAW_LOADSPRITE); } -void inter_copySprite(void) { - draw_sourceSurface = inter_load16(); - draw_destSurface = inter_load16(); +void Inter::copySprite(void) { + _vm->_draw->sourceSurface = load16(); + _vm->_draw->destSurface = load16(); - draw_spriteLeft = parse_parseValExpr(); - draw_spriteTop = parse_parseValExpr(); - draw_spriteRight = parse_parseValExpr(); - draw_spriteBottom = parse_parseValExpr(); + _vm->_draw->spriteLeft = _vm->_parse->parseValExpr(); + _vm->_draw->spriteTop = _vm->_parse->parseValExpr(); + _vm->_draw->spriteRight = _vm->_parse->parseValExpr(); + _vm->_draw->spriteBottom = _vm->_parse->parseValExpr(); - draw_destSpriteX = parse_parseValExpr(); - draw_destSpriteY = parse_parseValExpr(); + _vm->_draw->destSpriteX = _vm->_parse->parseValExpr(); + _vm->_draw->destSpriteY = _vm->_parse->parseValExpr(); - draw_transparency = inter_load16(); - draw_spriteOperation(DRAW_BLITSURF); + _vm->_draw->transparency = load16(); + _vm->_draw->spriteOperation(DRAW_BLITSURF); } -void inter_putPixel(void) { - draw_destSurface = inter_load16(); +void Inter::putPixel(void) { + _vm->_draw->destSurface = load16(); - draw_destSpriteX = parse_parseValExpr(); - draw_destSpriteY = parse_parseValExpr(); - draw_frontColor = parse_parseValExpr(); - draw_spriteOperation(DRAW_PUTPIXEL); + _vm->_draw->destSpriteX = _vm->_parse->parseValExpr(); + _vm->_draw->destSpriteY = _vm->_parse->parseValExpr(); + _vm->_draw->frontColor = _vm->_parse->parseValExpr(); + _vm->_draw->spriteOperation(DRAW_PUTPIXEL); } -void inter_fillRect(void) { - draw_destSurface = inter_load16(); +void Inter::fillRect(void) { + _vm->_draw->destSurface = load16(); - draw_destSpriteX = parse_parseValExpr(); - draw_destSpriteY = parse_parseValExpr(); - draw_spriteRight = parse_parseValExpr(); - draw_spriteBottom = parse_parseValExpr(); + _vm->_draw->destSpriteX = _vm->_parse->parseValExpr(); + _vm->_draw->destSpriteY = _vm->_parse->parseValExpr(); + _vm->_draw->spriteRight = _vm->_parse->parseValExpr(); + _vm->_draw->spriteBottom = _vm->_parse->parseValExpr(); - draw_backColor = parse_parseValExpr(); - draw_spriteOperation(DRAW_FILLRECT); + _vm->_draw->backColor = _vm->_parse->parseValExpr(); + _vm->_draw->spriteOperation(DRAW_FILLRECT); } -void inter_drawLine(void) { - draw_destSurface = inter_load16(); +void Inter::drawLine(void) { + _vm->_draw->destSurface = load16(); - draw_destSpriteX = parse_parseValExpr(); - draw_destSpriteY = parse_parseValExpr(); - draw_spriteRight = parse_parseValExpr(); - draw_spriteBottom = parse_parseValExpr(); + _vm->_draw->destSpriteX = _vm->_parse->parseValExpr(); + _vm->_draw->destSpriteY = _vm->_parse->parseValExpr(); + _vm->_draw->spriteRight = _vm->_parse->parseValExpr(); + _vm->_draw->spriteBottom = _vm->_parse->parseValExpr(); - draw_frontColor = parse_parseValExpr(); - draw_spriteOperation(DRAW_DRAWLINE); + _vm->_draw->frontColor = _vm->_parse->parseValExpr(); + _vm->_draw->spriteOperation(DRAW_DRAWLINE); } -void inter_createSprite(void) { +void Inter::createSprite(void) { int16 index; int16 height; int16 width; int16 flag; - index = inter_load16(); - width = inter_load16(); - height = inter_load16(); + index = load16(); + width = load16(); + height = load16(); - flag = inter_load16(); + flag = load16(); if (flag == 1) - draw_spritesArray[index] = vid_initSurfDesc(videoMode, width, height, 2); + _vm->_draw->spritesArray[index] = _vm->_video->initSurfDesc(_vm->_global->videoMode, width, height, 2); else - draw_spritesArray[index] = vid_initSurfDesc(videoMode, width, height, 0); + _vm->_draw->spritesArray[index] = _vm->_video->initSurfDesc(_vm->_global->videoMode, width, height, 0); - vid_clearSurf(draw_spritesArray[index]); + _vm->_video->clearSurf(_vm->_draw->spritesArray[index]); } -void inter_freeSprite(void) { +void Inter::freeSprite(void) { int16 index; - index = inter_load16(); - if (draw_spritesArray[index] == 0) + index = load16(); + if (_vm->_draw->spritesArray[index] == 0) return; - vid_freeSurfDesc(draw_spritesArray[index]); - draw_spritesArray[index] = 0; + _vm->_video->freeSurfDesc(_vm->_draw->spritesArray[index]); + _vm->_draw->spritesArray[index] = 0; } -void inter_renewTimeInVars(void) { +void Inter::renewTimeInVars(void) { struct tm *t; time_t now = time(NULL); @@ -902,63 +904,63 @@ void inter_renewTimeInVars(void) { WRITE_VAR(11, t->tm_sec); } -void inter_playComposition(void) { - static int16 inter_composition[50]; +void Inter::playComposition(void) { + static int16 composition[50]; int16 i; int16 dataVar; int16 freqVal; - dataVar = parse_parseVarIndex(); - freqVal = parse_parseValExpr(); + dataVar = _vm->_parse->parseVarIndex(); + freqVal = _vm->_parse->parseValExpr(); for (i = 0; i < 50; i++) - inter_composition[i] = (int16)VAR_OFFSET(dataVar + i * 4); + composition[i] = (int16)VAR_OFFSET(dataVar + i * 4); - snd_playComposition(game_soundSamples, inter_composition, freqVal); + _vm->_snd->playComposition(_vm->_game->soundSamples, composition, freqVal); } -void inter_stopSound(void) { - snd_stopSound(parse_parseValExpr()); - inter_soundEndTimeKey = 0; +void Inter::stopSound(void) { + _vm->_snd->stopSound(_vm->_parse->parseValExpr()); + soundEndTimeKey = 0; } -void inter_playSound(void) { +void Inter::playSound(void) { int16 frequency; int16 freq2; int16 repCount; int16 index; - index = parse_parseValExpr(); - repCount = parse_parseValExpr(); - frequency = parse_parseValExpr(); + index = _vm->_parse->parseValExpr(); + repCount = _vm->_parse->parseValExpr(); + frequency = _vm->_parse->parseValExpr(); - snd_stopSound(0); - inter_soundEndTimeKey = 0; - if (game_soundSamples[index] == 0) + _vm->_snd->stopSound(0); + soundEndTimeKey = 0; + if (_vm->_game->soundSamples[index] == 0) return; if (repCount < 0) { - if (soundFlags < 2) + if (_vm->_global->soundFlags < 2) return; repCount = -repCount; - inter_soundEndTimeKey = util_getTimeKey(); + soundEndTimeKey = _vm->_util->getTimeKey(); if (frequency == 0) { - freq2 = game_soundSamples[index]->frequency; + freq2 = _vm->_game->soundSamples[index]->frequency; } else { freq2 = frequency; } - inter_soundStopVal = - (10 * (game_soundSamples[index]->size / 2)) / freq2; - inter_soundEndTimeKey += - ((game_soundSamples[index]->size * repCount - - game_soundSamples[index]->size / 2) * 1000) / freq2; + soundStopVal = + (10 * (_vm->_game->soundSamples[index]->size / 2)) / freq2; + soundEndTimeKey += + ((_vm->_game->soundSamples[index]->size * repCount - + _vm->_game->soundSamples[index]->size / 2) * 1000) / freq2; } - snd_playSample(game_soundSamples[index], repCount, frequency); + _vm->_snd->playSample(_vm->_game->soundSamples[index], repCount, frequency); } -void inter_loadCursor(void) { - Game_TotResItem *itemPtr; +void Inter::loadCursor(void) { + Game::TotResItem *itemPtr; int16 width; int16 height; int32 offset; @@ -966,78 +968,78 @@ void inter_loadCursor(void) { int16 id; int8 index; - id = inter_load16(); - index = *inter_execPtr++; - itemPtr = &game_totResourceTable->items[id]; + id = load16(); + index = *_vm->_global->inter_execPtr++; + itemPtr = &_vm->_game->totResourceTable->items[id]; offset = itemPtr->offset; if (offset >= 0) { dataBuf = - ((char *)game_totResourceTable) + szGame_TotResTable + - szGame_TotResItem * game_totResourceTable->itemsCount + offset; + ((char *)_vm->_game->totResourceTable) + szGame_TotResTable + + szGame_TotResItem * _vm->_game->totResourceTable->itemsCount + offset; } else { - dataBuf = game_imFileData + (int32)READ_LE_UINT32(&((int32 *)game_imFileData)[-offset - 1]); + dataBuf = _vm->_game->imFileData + (int32)READ_LE_UINT32(&((int32 *)_vm->_game->imFileData)[-offset - 1]); } width = itemPtr->width; height = itemPtr->height; - vid_fillRect(draw_cursorSprites, index * draw_cursorWidth, 0, - index * draw_cursorWidth + draw_cursorWidth - 1, - draw_cursorHeight - 1, 0); + _vm->_video->fillRect(_vm->_draw->cursorSprites, index * _vm->_draw->cursorWidth, 0, + index * _vm->_draw->cursorWidth + _vm->_draw->cursorWidth - 1, + _vm->_draw->cursorHeight - 1, 0); - vid_drawPackedSprite((byte*)dataBuf, width, height, - index * draw_cursorWidth, 0, 0, draw_cursorSprites); - draw_cursorAnimLow[index] = 0; + _vm->_video->drawPackedSprite((byte*)dataBuf, width, height, + index * _vm->_draw->cursorWidth, 0, 0, _vm->_draw->cursorSprites); + _vm->_draw->cursorAnimLow[index] = 0; } -void inter_loadSpriteToPos(void) { - debug(4, "inter_loadSpriteToPos"); - draw_spriteLeft = inter_load16(); +void Inter::loadSpriteToPos(void) { + debug(4, "loadSpriteToPos"); + _vm->_draw->spriteLeft = load16(); - draw_destSpriteX = parse_parseValExpr(); - draw_destSpriteY = parse_parseValExpr(); + _vm->_draw->destSpriteX = _vm->_parse->parseValExpr(); + _vm->_draw->destSpriteY = _vm->_parse->parseValExpr(); - draw_transparency = inter_execPtr[0]; - draw_destSurface = (inter_execPtr[0] / 2) - 1; + _vm->_draw->transparency = _vm->_global->inter_execPtr[0]; + _vm->_draw->destSurface = (_vm->_global->inter_execPtr[0] / 2) - 1; - if (draw_destSurface < 0) - draw_destSurface = 101; - draw_transparency &= 1; - inter_execPtr += 2; - draw_spriteOperation(DRAW_LOADSPRITE); + if (_vm->_draw->destSurface < 0) + _vm->_draw->destSurface = 101; + _vm->_draw->transparency &= 1; + _vm->_global->inter_execPtr += 2; + _vm->_draw->spriteOperation(DRAW_LOADSPRITE); } -void inter_loadTot(void) { +void Inter::loadTot(void) { char buf[20]; int8 size; int16 i; - debug(4, "inter_loadTot"); - if ((*inter_execPtr & 0x80) != 0) { - inter_execPtr++; - inter_evalExpr(0); - strcpy(buf, inter_resStr); + debug(4, "loadTot"); + if ((*_vm->_global->inter_execPtr & 0x80) != 0) { + _vm->_global->inter_execPtr++; + evalExpr(0); + strcpy(buf, _vm->_global->inter_resStr); } else { - size = *inter_execPtr++; + size = *_vm->_global->inter_execPtr++; for (i = 0; i < size; i++) - buf[i] = *inter_execPtr++; + buf[i] = *_vm->_global->inter_execPtr++; buf[size] = 0; } strcat(buf, ".tot"); - inter_terminate = 1; - strcpy(game_totToLoad, buf); + terminate = 1; + strcpy(_vm->_game->totToLoad, buf); } -void inter_storeKey(int16 key) { - WRITE_VAR(12, util_getTimeKey() - game_startTimeKey); +void Inter::storeKey(int16 key) { + WRITE_VAR(12, _vm->_util->getTimeKey() - _vm->_game->startTimeKey); - WRITE_VAR(2, inter_mouseX); - WRITE_VAR(3, inter_mouseY); - WRITE_VAR(4, game_mouseButtons); - WRITE_VAR(1, snd_playingSound); + WRITE_VAR(2, _vm->_global->inter_mouseX); + WRITE_VAR(3, _vm->_global->inter_mouseY); + WRITE_VAR(4, _vm->_game->mouseButtons); + WRITE_VAR(1, _vm->_snd->playingSound); if (key == 0x4800) key = 0x0b; @@ -1055,93 +1057,93 @@ void inter_storeKey(int16 key) { WRITE_VAR(0, key); if (key != 0) - util_waitKey(); + _vm->_util->waitKey(); } -void inter_keyFunc(void) { +void Inter::keyFunc(void) { int16 flag; int16 key; - debug(4, "inter_keyFunc"); - flag = inter_load16(); - inter_animPalette(); - draw_blitInvalidated(); + debug(4, "keyFunc"); + flag = load16(); + animPalette(); + _vm->_draw->blitInvalidated(); if (flag != 0) { if (flag != 1) { if (flag != 2) { - util_longDelay(flag); + _vm->_util->longDelay(flag); return; } key = 0; - if (pressedKeys[0x48]) + if (_vm->_global->pressedKeys[0x48]) key |= 1; - if (pressedKeys[0x50]) + if (_vm->_global->pressedKeys[0x50]) key |= 2; - if (pressedKeys[0x4d]) + if (_vm->_global->pressedKeys[0x4d]) key |= 4; - if (pressedKeys[0x4b]) + if (_vm->_global->pressedKeys[0x4b]) key |= 8; - if (pressedKeys[0x1c]) + if (_vm->_global->pressedKeys[0x1c]) key |= 0x10; - if (pressedKeys[0x39]) + if (_vm->_global->pressedKeys[0x39]) key |= 0x20; - if (pressedKeys[1]) + if (_vm->_global->pressedKeys[1]) key |= 0x40; - if (pressedKeys[0x1d]) + if (_vm->_global->pressedKeys[0x1d]) key |= 0x80; - if (pressedKeys[0x2a]) + if (_vm->_global->pressedKeys[0x2a]) key |= 0x100; - if (pressedKeys[0x36]) + if (_vm->_global->pressedKeys[0x36]) key |= 0x200; - if (pressedKeys[0x38]) + if (_vm->_global->pressedKeys[0x38]) key |= 0x400; - if (pressedKeys[0x3b]) + if (_vm->_global->pressedKeys[0x3b]) key |= 0x800; - if (pressedKeys[0x3c]) + if (_vm->_global->pressedKeys[0x3c]) key |= 0x1000; - if (pressedKeys[0x3d]) + if (_vm->_global->pressedKeys[0x3d]) key |= 0x2000; - if (pressedKeys[0x3e]) + if (_vm->_global->pressedKeys[0x3e]) key |= 0x4000; WRITE_VAR(0, key); - util_waitKey(); + _vm->_util->waitKey(); return; } - key = game_checkKeys(&inter_mouseX, &inter_mouseY, &game_mouseButtons, 0); + key = _vm->_game->checkKeys(&_vm->_global->inter_mouseX, &_vm->_global->inter_mouseY, &_vm->_game->mouseButtons, 0); - inter_storeKey(key); + storeKey(key); return; } else { - key = game_checkCollisions(0, 0, 0, 0); - inter_storeKey(key); + key = _vm->_game->checkCollisions(0, 0, 0, 0); + storeKey(key); if (flag == 1) return; - util_waitKey(); + _vm->_util->waitKey(); } } -void inter_checkSwitchTable(char **ppExec) { +void Inter::checkSwitchTable(char **ppExec) { int16 i; int16 len; char found; @@ -1152,116 +1154,116 @@ void inter_checkSwitchTable(char **ppExec) { found = 0; notFound = 1; *ppExec = 0; - value = parse_parseVarIndex(); + value = _vm->_parse->parseVarIndex(); value = VAR_OFFSET(value); do { - len = *(int8*)inter_execPtr++; // must be a signed char typ and char is not default signed on all platforms. + len = *(int8*)_vm->_global->inter_execPtr++; // must be a signed char typ and char is not default signed on all platforms. if (len == -5) break; for (i = 0; i < len; i++) { - inter_evalExpr(0); + evalExpr(0); - if (inter_terminate != 0) + if (terminate != 0) return; - if (inter_resVal == value) { + if (_vm->_global->inter_resVal == value) { found = 1; notFound = 0; } } if (found != 0) - *ppExec = inter_execPtr; + *ppExec = _vm->_global->inter_execPtr; - inter_execPtr += READ_LE_UINT16(inter_execPtr + 2) + 2; + _vm->_global->inter_execPtr += READ_LE_UINT16(_vm->_global->inter_execPtr + 2) + 2; found = 0; } while (len != -5); if (len != -5) - inter_execPtr++; + _vm->_global->inter_execPtr++; - defFlag = *inter_execPtr; + defFlag = *_vm->_global->inter_execPtr; defFlag >>= 4; if (defFlag != 4) return; - inter_execPtr++; + _vm->_global->inter_execPtr++; if (notFound) - *ppExec = inter_execPtr; + *ppExec = _vm->_global->inter_execPtr; - inter_execPtr += READ_LE_UINT16(inter_execPtr + 2) + 2; + _vm->_global->inter_execPtr += READ_LE_UINT16(_vm->_global->inter_execPtr + 2) + 2; } -void inter_repeatUntil(void) { +void Inter::repeatUntil(void) { char *blockPtr; int16 size; char flag; - debug(4, "inter_repeatUntil"); - inter_nestLevel[0]++; - blockPtr = inter_execPtr; + debug(4, "repeatUntil"); + nestLevel[0]++; + blockPtr = _vm->_global->inter_execPtr; do { - inter_execPtr = blockPtr; - size = READ_LE_UINT16(inter_execPtr + 2) + 2; + _vm->_global->inter_execPtr = blockPtr; + size = READ_LE_UINT16(_vm->_global->inter_execPtr + 2) + 2; - inter_funcBlock(1); - inter_execPtr = blockPtr + size + 1; - flag = inter_evalBoolResult(); - } while (flag == 0 && inter_breakFlag == 0 && inter_terminate == 0); + funcBlock(1); + _vm->_global->inter_execPtr = blockPtr + size + 1; + flag = evalBoolResult(); + } while (flag == 0 && breakFlag == 0 && terminate == 0); - inter_nestLevel[0]--; + nestLevel[0]--; - if (*inter_breakFromLevel > -1) { - inter_breakFlag = 0; - *inter_breakFromLevel = -1; + if (*breakFromLevel > -1) { + breakFlag = 0; + *breakFromLevel = -1; } } -void inter_whileDo(void) { +void Inter::whileDo(void) { char *blockPtr; char *savedIP; char flag; int16 size; - debug(4, "inter_whileDo"); - inter_nestLevel[0]++; + debug(4, "whileDo"); + nestLevel[0]++; do { - savedIP = inter_execPtr; - flag = inter_evalBoolResult(); + savedIP = _vm->_global->inter_execPtr; + flag = evalBoolResult(); - if (inter_terminate != 0) + if (terminate != 0) return; - blockPtr = inter_execPtr; + blockPtr = _vm->_global->inter_execPtr; - size = READ_LE_UINT16(inter_execPtr + 2) + 2; + size = READ_LE_UINT16(_vm->_global->inter_execPtr + 2) + 2; if (flag != 0) { - inter_funcBlock(1); - inter_execPtr = savedIP; + funcBlock(1); + _vm->_global->inter_execPtr = savedIP; } else { - inter_execPtr += size; + _vm->_global->inter_execPtr += size; } - if (inter_breakFlag != 0 || inter_terminate != 0) { - inter_execPtr = blockPtr; - inter_execPtr += size; + if (breakFlag != 0 || terminate != 0) { + _vm->_global->inter_execPtr = blockPtr; + _vm->_global->inter_execPtr += size; break; } } while (flag != 0); - inter_nestLevel[0]--; - if (*inter_breakFromLevel > -1) { - inter_breakFlag = 0; - *inter_breakFromLevel = -1; + nestLevel[0]--; + if (*breakFromLevel > -1) { + breakFlag = 0; + *breakFromLevel = -1; } } -void inter_funcBlock(int16 retFlag) { +void Inter::funcBlock(int16 retFlag) { char cmdCount; int16 counter; byte cmd; @@ -1270,124 +1272,124 @@ void inter_funcBlock(int16 retFlag) { char *callAddr; char boolRes; - if (inter_execPtr == 0) + if (_vm->_global->inter_execPtr == 0) return; - inter_breakFlag = 0; - inter_execPtr++; - cmdCount = *inter_execPtr++; - inter_execPtr += 2; + breakFlag = 0; + _vm->_global->inter_execPtr++; + cmdCount = *_vm->_global->inter_execPtr++; + _vm->_global->inter_execPtr += 2; if (cmdCount == 0) { - inter_execPtr = 0; + _vm->_global->inter_execPtr = 0; return; } counter = 0; do { - if (inter_terminate != 0) + if (terminate != 0) break; - cmd = (byte)*inter_execPtr; + cmd = (byte)*_vm->_global->inter_execPtr; if ((cmd >> 4) >= 12) { cmd2 = 16 - (cmd >> 4); cmd &= 0xf; } else cmd2 = 0; - inter_execPtr++; + _vm->_global->inter_execPtr++; counter++; - debug(4, "inter_funcBlock(%d, %d)", cmd2, cmd); + debug(4, "funcBlock(%d, %d)", cmd2, cmd); switch (cmd2) { case 0: switch (cmd >> 4) { case 0: case 1: - storedIP = inter_execPtr; - inter_execPtr = (char *)game_totFileData + READ_LE_UINT16(inter_execPtr); + storedIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr = (char *)_vm->_game->totFileData + READ_LE_UINT16(_vm->_global->inter_execPtr); if (counter == cmdCount && retFlag == 2) return; - inter_callSub(2); - inter_execPtr = storedIP + 2; + callSub(2); + _vm->_global->inter_execPtr = storedIP + 2; break; case 2: - draw_printText(); + _vm->_draw->printText(); break; case 3: - inter_loadCursor(); + loadCursor(); break; case 5: - inter_checkSwitchTable(&callAddr); - storedIP = inter_execPtr; - inter_execPtr = callAddr; + checkSwitchTable(&callAddr); + storedIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr = callAddr; if (counter == cmdCount && retFlag == 2) return; - inter_funcBlock(0); - inter_execPtr = storedIP; + funcBlock(0); + _vm->_global->inter_execPtr = storedIP; break; case 6: - inter_repeatUntil(); + repeatUntil(); break; case 7: - inter_whileDo(); + whileDo(); break; case 8: - boolRes = inter_evalBoolResult(); + boolRes = evalBoolResult(); if (boolRes != 0) { if (counter == cmdCount && retFlag == 2) return; - storedIP = inter_execPtr; - inter_funcBlock(0); - inter_execPtr = storedIP; + storedIP = _vm->_global->inter_execPtr; + funcBlock(0); + _vm->_global->inter_execPtr = storedIP; - inter_execPtr += READ_LE_UINT16(inter_execPtr + 2) + 2; + _vm->_global->inter_execPtr += READ_LE_UINT16(_vm->_global->inter_execPtr + 2) + 2; - debug(5, "cmd = %d", (int16)*inter_execPtr); - cmd = (byte)(*inter_execPtr) >> 4; - inter_execPtr++; + debug(5, "cmd = %d", (int16)*_vm->_global->inter_execPtr); + cmd = (byte)(*_vm->_global->inter_execPtr) >> 4; + _vm->_global->inter_execPtr++; if (cmd != 12) break; - inter_execPtr += READ_LE_UINT16(inter_execPtr + 2) + 2; + _vm->_global->inter_execPtr += READ_LE_UINT16(_vm->_global->inter_execPtr + 2) + 2; } else { - inter_execPtr += READ_LE_UINT16(inter_execPtr + 2) + 2; + _vm->_global->inter_execPtr += READ_LE_UINT16(_vm->_global->inter_execPtr + 2) + 2; - debug(5, "cmd = %d", (int16)*inter_execPtr); - cmd = (byte)(*inter_execPtr) >> 4; - inter_execPtr++; + debug(5, "cmd = %d", (int16)*_vm->_global->inter_execPtr); + cmd = (byte)(*_vm->_global->inter_execPtr) >> 4; + _vm->_global->inter_execPtr++; if (cmd != 12) break; if (counter == cmdCount && retFlag == 2) return; - storedIP = inter_execPtr; - inter_funcBlock(0); - inter_execPtr = storedIP; - inter_execPtr += READ_LE_UINT16(inter_execPtr + 2) + 2; + storedIP = _vm->_global->inter_execPtr; + funcBlock(0); + _vm->_global->inter_execPtr = storedIP; + _vm->_global->inter_execPtr += READ_LE_UINT16(_vm->_global->inter_execPtr + 2) + 2; } break; case 9: - inter_evaluateStore(); + evaluateStore(); break; case 10: - inter_loadSpriteToPos(); + loadSpriteToPos(); break; } break; @@ -1395,39 +1397,39 @@ void inter_funcBlock(int16 retFlag) { case 1: switch (cmd) { case 1: - inter_printText(); + printText(); break; case 2: - inter_loadTot(); + loadTot(); break; case 3: - draw_interPalLoad(); + _vm->_draw->interPalLoad(); break; case 4: - inter_keyFunc(); + keyFunc(); break; case 5: - inter_capturePush(); + capturePush(); break; case 6: - inter_capturePop(); + capturePop(); break; case 7: - inter_animPalInit(); + animPalInit(); break; case 14: - inter_drawOperations(); + drawOperations(); break; case 15: - cmdCount = *inter_execPtr++; + cmdCount = *_vm->_global->inter_execPtr++; counter = 0; break; } @@ -1438,37 +1440,37 @@ void inter_funcBlock(int16 retFlag) { switch (cmd) { case 0: if (retFlag != 2) - inter_breakFlag = 1; + breakFlag = 1; - inter_execPtr = 0; + _vm->_global->inter_execPtr = 0; return; case 1: - inter_renewTimeInVars(); + renewTimeInVars(); break; case 2: - snd_speakerOn(parse_parseValExpr(), -1); + _vm->_snd->speakerOn(_vm->_parse->parseValExpr(), -1); break; case 3: - snd_speakerOff(); + _vm->_snd->speakerOff(); break; case 4: - inter_putPixel(); + putPixel(); break; case 5: - gob_interFunc(); + _vm->_goblin->interFunc(); break; case 6: - inter_createSprite(); + createSprite(); break; case 7: - inter_freeSprite(); + freeSprite(); break; } break; @@ -1477,78 +1479,78 @@ void inter_funcBlock(int16 retFlag) { switch (cmd) { case 0: if (retFlag == 1) { - inter_breakFlag = 1; - inter_execPtr = 0; + breakFlag = 1; + _vm->_global->inter_execPtr = 0; return; } - if (*inter_nestLevel == 0) + if (*nestLevel == 0) break; - *inter_breakFromLevel = *inter_nestLevel; - inter_breakFlag = 1; - inter_execPtr = 0; + *breakFromLevel = *nestLevel; + breakFlag = 1; + _vm->_global->inter_execPtr = 0; return; case 1: - inter_loadSpriteContent(); + loadSpriteContent(); break; case 2: - inter_copySprite(); + copySprite(); break; case 3: - inter_fillRect(); + fillRect(); break; case 4: - inter_drawLine(); + drawLine(); break; case 5: - inter_strToLong(); + strToLong(); break; case 6: - inter_invalidate(); + invalidate(); break; case 7: - draw_backDeltaX = parse_parseValExpr(); - draw_backDeltaY = parse_parseValExpr(); + _vm->_draw->backDeltaX = _vm->_parse->parseValExpr(); + _vm->_draw->backDeltaY = _vm->_parse->parseValExpr(); break; case 8: - inter_playSound(); + playSound(); break; case 9: - inter_stopSound(); + stopSound(); break; case 10: - game_interLoadSound(-1); + _vm->_game->interLoadSound(-1); break; case 11: - game_freeSoundSlot(-1); + _vm->_game->freeSoundSlot(-1); break; case 12: - snd_waitEndPlay(); + _vm->_snd->waitEndPlay(); break; case 13: - inter_playComposition(); + playComposition(); break; case 14: - inter_getFreeMem(); + getFreeMem(); break; case 15: - inter_checkData(); + checkData(); break; } break; @@ -1557,112 +1559,112 @@ void inter_funcBlock(int16 retFlag) { switch (cmd) { case 1: - inter_prepareStr(); + prepareStr(); break; case 2: - inter_insertStr(); + insertStr(); break; case 3: - inter_cutStr(); + cutStr(); break; case 4: - inter_strstr(); + strstr(); break; case 5: - inter_strlen(); + istrlen(); break; case 6: - inter_setMousePos(); + setMousePos(); break; case 7: - inter_setFrameRate(); + setFrameRate(); break; case 8: - draw_blitInvalidated(); - util_waitEndFrame(); - inter_animPalette(); - inter_storeKey(game_checkKeys(&inter_mouseX, - &inter_mouseY, &game_mouseButtons, 0)); + _vm->_draw->blitInvalidated(); + _vm->_util->waitEndFrame(); + animPalette(); + storeKey(_vm->_game->checkKeys(&_vm->_global->inter_mouseX, + &_vm->_global->inter_mouseY, &_vm->_game->mouseButtons, 0)); break; case 9: - draw_animateCursor(1); + _vm->_draw->animateCursor(1); break; case 10: - draw_blitCursor(); + _vm->_draw->blitCursor(); break; case 11: - inter_loadFont(); + loadFont(); break; case 12: - inter_freeFont(); + freeFont(); break; case 13: - inter_readData(); + readData(); break; case 14: - inter_writeData(); + writeData(); break; case 15: - inter_manageDataFile(); + manageDataFile(); break; } break; } - if (inter_breakFlag != 0) { + if (breakFlag != 0) { if (retFlag != 2) break; - if (*inter_breakFromLevel == -1) - inter_breakFlag = 0; + if (*breakFromLevel == -1) + breakFlag = 0; break; } } while (counter != cmdCount); - inter_execPtr = 0; + _vm->_global->inter_execPtr = 0; return; } -void inter_initControlVars(void) { - *inter_nestLevel = 0; - *inter_breakFromLevel = -1; +void Inter::initControlVars(void) { + *nestLevel = 0; + *breakFromLevel = -1; - *scen_pCaptureCounter = 0; + *_vm->_scenery->pCaptureCounter = 0; - inter_breakFlag = 0; - inter_terminate = 0; - inter_animPalDir = 0; - inter_soundEndTimeKey = 0; + breakFlag = 0; + terminate = 0; + animPalDir = 0; + soundEndTimeKey = 0; } -void inter_callSub(int16 retFlag) { +void Inter::callSub(int16 retFlag) { int16 block; - while (inter_execPtr != 0 && (char *)inter_execPtr != game_totFileData) { - block = *inter_execPtr; + while (_vm->_global->inter_execPtr != 0 && (char *)_vm->_global->inter_execPtr != _vm->_game->totFileData) { + block = *_vm->_global->inter_execPtr; if (block == 1) { - inter_funcBlock(retFlag); + funcBlock(retFlag); } else if (block == 2) { - game_collisionsBlock(); + _vm->_game->collisionsBlock(); } } - if ((char *)inter_execPtr == game_totFileData) - inter_terminate = 1; + if ((char *)_vm->_global->inter_execPtr == _vm->_game->totFileData) + terminate = 1; } } // End of namespace Gob diff --git a/gob/inter.h b/gob/inter.h index 3464072d07..f74c6a81f6 100644 --- a/gob/inter.h +++ b/gob/inter.h @@ -24,75 +24,83 @@ namespace Gob { -extern int16 inter_animPalLowIndex; -extern int16 inter_animPalHighIndex; -extern int16 inter_animPalDir; -extern uint32 inter_soundEndTimeKey; -extern int16 inter_soundStopVal; -extern char inter_terminate; -extern char inter_breakFlag; -extern int16 *inter_breakFromLevel; -extern int16 *inter_nestLevel; +class Inter { +public: + int16 animPalLowIndex; + int16 animPalHighIndex; + int16 animPalDir; + uint32 soundEndTimeKey; + int16 soundStopVal; + char terminate; + char breakFlag; + int16 *breakFromLevel; + int16 *nestLevel; -int16 inter_load16(void); -int16 inter_peek16(char *ptr); -int32 inter_peek32(char *ptr); + int16 load16(void); + int16 peek16(char *ptr); + int32 peek32(char *ptr); -void inter_setMousePos(void); -char inter_evalExpr(int16 *pRes); -char inter_evalBoolResult(void); -void inter_storeResult(void); -void inter_printText(void); -void inter_animPalette(void); -void inter_animPalInit(void); -void inter_loadMult(void); -void inter_playMult(void); -void inter_freeMult(void); -void inter_initCursor(void); -void inter_initCursorAnim(void); -void inter_clearCursorAnim(void); -void inter_drawOperations(void); -void inter_getFreeMem(void); -void inter_manageDataFile(void); -void inter_getFreeMem(void); -void inter_manageDataFile(void); -void inter_writeData(void); -void inter_checkData(void); -void inter_readData(void); -void inter_loadFont(void); -void inter_freeFont(void); -void inter_prepareStr(void); -void inter_insertStr(void); -void inter_cutStr(void); -void inter_strstr(void); -void inter_setFrameRate(void); -void inter_strlen(void); -void inter_strToLong(void); -void inter_invalidate(void); -void inter_loadSpriteContent(void); -void inter_copySprite(void); -void inter_putPixel(void); -void inter_fillRect(void); -void inter_drawLine(void); -void inter_createSprite(void); -void inter_freeSprite(void); -void inter_renewTimeInVars(void); -void inter_playComposition(void); -void inter_stopSound(void); -void inter_playSound(void); -void inter_loadCursor(void); -void inter_loadSpriteToPos(void); -void inter_funcBlock(int16 retFlag); -void inter_loadTot(void); -void inter_storeKey(int16 key); -void inter_keyFunc(void); -void inter_checkSwitchTable(char **ppExec); -void inter_repeatUntil(void); -void inter_whileDo(void); -void inter_funcBlock(int16 retFlag); -void inter_callSub(int16 retFlag); -void inter_initControlVars(void); -void inter_callSub(int16 retFlag); + void setMousePos(void); + char evalExpr(int16 *pRes); + char evalBoolResult(void); + void storeResult(void); + void printText(void); + void animPalette(void); + void animPalInit(void); + void loadMult(void); + void playMult(void); + void freeMult(void); + void initCursor(void); + void initCursorAnim(void); + void clearCursorAnim(void); + void drawOperations(void); + void getFreeMem(void); + void manageDataFile(void); + void writeData(void); + void checkData(void); + void readData(void); + void loadFont(void); + void freeFont(void); + void prepareStr(void); + void insertStr(void); + void cutStr(void); + void strstr(void); + void setFrameRate(void); + void istrlen(void); + void strToLong(void); + void invalidate(void); + void loadSpriteContent(void); + void copySprite(void); + void putPixel(void); + void fillRect(void); + void drawLine(void); + void createSprite(void); + void freeSprite(void); + void renewTimeInVars(void); + void playComposition(void); + void stopSound(void); + void playSound(void); + void loadCursor(void); + void loadSpriteToPos(void); + void funcBlock(int16 retFlag); + void loadTot(void); + void storeKey(int16 key); + void keyFunc(void); + void checkSwitchTable(char **ppExec); + void repeatUntil(void); + void whileDo(void); + void callSub(int16 retFlag); + void initControlVars(void); + + Inter(GobEngine *vm); + +protected: + GobEngine *_vm; + + void evaluateStore(void); + void capturePush(void); + void capturePop(void); +}; } // End of namespace Gob diff --git a/gob/map.cpp b/gob/map.cpp index 955742503a..85983a72de 100644 --- a/gob/map.cpp +++ b/gob/map.cpp @@ -31,28 +31,38 @@ namespace Gob { -int8 map_passMap[kMapHeight][kMapWidth]; // [y][x] -int16 map_itemsMap[kMapHeight][kMapWidth]; // [y][x] - -Map_Point map_wayPoints[40]; -int16 map_nearestWayPoint = 0; -int16 map_nearestDest = 0; - -int16 map_curGoblinX; -int16 map_curGoblinY; -int16 map_destX; -int16 map_destY; - -Map_ItemPos map_itemPoses[40]; -int8 map_loadFromAvo; -char map_sourceFile[15]; -static char *map_avoDataPtr; - -void map_placeItem(int16 x, int16 y, int16 id) { - if ((map_itemsMap[y][x] & 0xff00) != 0) - map_itemsMap[y][x] = (map_itemsMap[y][x] & 0xff00) | id; +Map::Map(GobEngine *vm) : _vm(vm) { + for (int i = 0; i < kMapHeight; i++) + for (int j = 0; j < kMapWidth; j++) { + passMap[i][j] = 0; + itemsMap[i][j] = 0; + } + for (int i = 0; i < 40; i++) { + wayPoints[i].x = 0; + wayPoints[i].y = 0; + } + for (int i = 0; i < 40; i++) { + itemPoses[i].x = 0; + itemPoses[i].y = 0; + itemPoses[i].orient = 0; + } + + nearestWayPoint = 0; + nearestDest = 0; + curGoblinX = 0; + curGoblinY = 0; + destX = 0; + destY = 0; + loadFromAvo = 0; + sourceFile[0] = 0; + avoDataPtr = 0; +} + +void Map::placeItem(int16 x, int16 y, int16 id) { + if ((itemsMap[y][x] & 0xff00) != 0) + itemsMap[y][x] = (itemsMap[y][x] & 0xff00) | id; else - map_itemsMap[y][x] = (map_itemsMap[y][x] & 0x00ff) | (id << 8); + itemsMap[y][x] = (itemsMap[y][x] & 0x00ff) | (id << 8); } enum { @@ -62,7 +72,7 @@ enum { kDown = (1 << 3) }; -int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1) { +int16 Map::getDirection(int16 x0, int16 y0, int16 x1, int16 y1) { int16 dir = 0; if (x0 == x1 && y0 == y1) @@ -81,63 +91,63 @@ int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1) { else if (x1 < x0) dir |= kLeft; - if (map_passMap[y0][x0] == 3 && (dir & kUp)) { - if (map_passMap[y0 - 1][x0] != 0) + if (passMap[y0][x0] == 3 && (dir & kUp)) { + if (passMap[y0 - 1][x0] != 0) return kDirN; } - if (map_passMap[y0][x0] == 3 && (dir & kDown)) { - if (map_passMap[y0 + 1][x0] != 0) + if (passMap[y0][x0] == 3 && (dir & kDown)) { + if (passMap[y0 + 1][x0] != 0) return kDirS; } - if (map_passMap[y0][x0] == 6 && (dir & kUp)) { - if (map_passMap[y0 - 1][x0] != 0) + if (passMap[y0][x0] == 6 && (dir & kUp)) { + if (passMap[y0 - 1][x0] != 0) return kDirN; } - if (map_passMap[y0][x0] == 6 && (dir & kDown)) { - if (map_passMap[y0 + 1][x0] != 0) + if (passMap[y0][x0] == 6 && (dir & kDown)) { + if (passMap[y0 + 1][x0] != 0) return kDirS; } if (dir == kLeft) { - if (x0 - 1 >= 0 && map_passMap[y0][x0 - 1] != 0) + if (x0 - 1 >= 0 && passMap[y0][x0 - 1] != 0) return kDirW; return 0; } if (dir == kRight) { - if (x0 + 1 < kMapWidth && map_passMap[y0][x0 + 1] != 0) + if (x0 + 1 < kMapWidth && passMap[y0][x0 + 1] != 0) return kDirE; return 0; } if (dir == kUp) { - if (y0 - 1 >= 0 && map_passMap[y0 - 1][x0] != 0) + if (y0 - 1 >= 0 && passMap[y0 - 1][x0] != 0) return kDirN; if (y0 - 1 >= 0 && x0 - 1 >= 0 - && map_passMap[y0 - 1][x0 - 1] != 0) + && passMap[y0 - 1][x0 - 1] != 0) return kDirNW; if (y0 - 1 >= 0 && x0 + 1 < kMapWidth - && map_passMap[y0 - 1][x0 + 1] != 0) + && passMap[y0 - 1][x0 + 1] != 0) return kDirNE; return 0; } if (dir == kDown) { - if (y0 + 1 < kMapHeight && map_passMap[y0 + 1][x0] != 0) + if (y0 + 1 < kMapHeight && passMap[y0 + 1][x0] != 0) return kDirS; if (y0 + 1 < kMapHeight && x0 - 1 >= 0 - && map_passMap[y0 + 1][x0 - 1] != 0) + && passMap[y0 + 1][x0 - 1] != 0) return kDirSW; if (y0 + 1 < kMapHeight && x0 + 1 < kMapWidth - && map_passMap[y0 + 1][x0 + 1] != 0) + && passMap[y0 + 1][x0 + 1] != 0) return kDirSE; return 0; @@ -145,13 +155,13 @@ int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1) { if (dir == (kRight | kUp)) { if (y0 - 1 >= 0 && x0 + 1 < kMapWidth - && map_passMap[y0 - 1][x0 + 1] != 0) + && passMap[y0 - 1][x0 + 1] != 0) return kDirNE; - if (y0 - 1 >= 0 && map_passMap[y0 - 1][x0] != 0) + if (y0 - 1 >= 0 && passMap[y0 - 1][x0] != 0) return kDirN; - if (x0 + 1 < kMapWidth && map_passMap[y0][x0 + 1] != 0) + if (x0 + 1 < kMapWidth && passMap[y0][x0 + 1] != 0) return kDirE; return 0; @@ -159,13 +169,13 @@ int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1) { if (dir == (kRight | kDown)) { if (x0 + 1 < kMapWidth && y0 + 1 < kMapHeight - && map_passMap[y0 + 1][x0 + 1] != 0) + && passMap[y0 + 1][x0 + 1] != 0) return kDirSE; - if (y0 + 1 < kMapHeight && map_passMap[y0 + 1][x0] != 0) + if (y0 + 1 < kMapHeight && passMap[y0 + 1][x0] != 0) return kDirS; - if (x0 + 1 < kMapWidth && map_passMap[y0][x0 + 1] != 0) + if (x0 + 1 < kMapWidth && passMap[y0][x0 + 1] != 0) return kDirE; return 0; @@ -173,13 +183,13 @@ int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1) { if (dir == (kLeft | kUp)) { if (x0 - 1 >= 0 && y0 - 1 >= 0 - && map_passMap[y0 - 1][x0 - 1] != 0) + && passMap[y0 - 1][x0 - 1] != 0) return kDirNW; - if (y0 - 1 >= 0 && map_passMap[y0 - 1][x0] != 0) + if (y0 - 1 >= 0 && passMap[y0 - 1][x0] != 0) return kDirN; - if (x0 - 1 >= 0 && map_passMap[y0][x0 - 1] != 0) + if (x0 - 1 >= 0 && passMap[y0][x0 - 1] != 0) return kDirW; return 0; @@ -187,13 +197,13 @@ int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1) { if (dir == (kLeft | kDown)) { if (x0 - 1 >= 0 && y0 + 1 < kMapHeight - && map_passMap[y0 + 1][x0 - 1] != 0) + && passMap[y0 + 1][x0 - 1] != 0) return kDirSW; - if (y0 + 1 < kMapHeight && map_passMap[y0 + 1][x0] != 0) + if (y0 + 1 < kMapHeight && passMap[y0 + 1][x0] != 0) return kDirS; - if (x0 - 1 >= 0 && map_passMap[y0][x0 - 1] != 0) + if (x0 - 1 >= 0 && passMap[y0][x0 - 1] != 0) return kDirW; return 0; @@ -201,8 +211,8 @@ int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1) { return -1; } -int16 map_findNearestWayPoint(int16 x, int16 y) { - int16 nearestWayPoint = -1; +int16 Map::findNearestWayPoint(int16 x, int16 y) { + int16 lnearestWayPoint = -1; int16 length; int16 i; int16 tmp; @@ -210,41 +220,41 @@ int16 map_findNearestWayPoint(int16 x, int16 y) { length = 30000; for (i = 0; i < 40; i++) { - if (map_wayPoints[i].x < 0 || - map_wayPoints[i].x >= kMapWidth || - map_wayPoints[i].y < 0 || map_wayPoints[i].y >= kMapHeight) + if (wayPoints[i].x < 0 || + wayPoints[i].x >= kMapWidth || + wayPoints[i].y < 0 || wayPoints[i].y >= kMapHeight) return -1; - tmp = ABS(x - map_wayPoints[i].x) + ABS(y - map_wayPoints[i].y); + tmp = ABS(x - wayPoints[i].x) + ABS(y - wayPoints[i].y); if (tmp <= length) { - nearestWayPoint = i; + lnearestWayPoint = i; length = tmp; } } - return nearestWayPoint; + return lnearestWayPoint; } -void map_findNearestToGob(void) { - int16 wayPoint = map_findNearestWayPoint(map_curGoblinX, map_curGoblinY); +void Map::findNearestToGob(void) { + int16 wayPoint = findNearestWayPoint(curGoblinX, curGoblinY); if (wayPoint != -1) - map_nearestWayPoint = wayPoint; + nearestWayPoint = wayPoint; } -void map_findNearestToDest(void) { - int16 wayPoint = map_findNearestWayPoint(map_destX, map_destY); +void Map::findNearestToDest(void) { + int16 wayPoint = findNearestWayPoint(destX, destY); if (wayPoint != -1) - map_nearestDest = wayPoint; + nearestDest = wayPoint; } -int16 map_checkDirectPath(int16 x0, int16 y0, int16 x1, int16 y1) { +int16 Map::checkDirectPath(int16 x0, int16 y0, int16 x1, int16 y1) { uint16 dir; while (1) { - dir = map_getDirection(x0, y0, x1, y1); + dir = getDirection(x0, y0, x1, y1); if (x0 == x1 && y0 == y1) return 1; @@ -292,7 +302,7 @@ int16 map_checkDirectPath(int16 x0, int16 y0, int16 x1, int16 y1) { } } -int16 map_checkLongPath(int16 x0, int16 y0, int16 x1, int16 y1, int16 i0, int16 i1) { +int16 Map::checkLongPath(int16 x0, int16 y0, int16 x1, int16 y1, int16 i0, int16 i1) { uint16 dir; int16 curX; int16 curY; @@ -309,30 +319,30 @@ int16 map_checkLongPath(int16 x0, int16 y0, int16 x1, int16 y1, int16 i0, int16 nextLink = 1; if (nextLink != 0) { - if (map_checkDirectPath(x0, y0, x1, y1) == 1) + if (checkDirectPath(x0, y0, x1, y1) == 1) return 1; nextLink = 0; if (i0 > i1) { - curX = map_wayPoints[i0].x; - curY = map_wayPoints[i0].y; + curX = wayPoints[i0].x; + curY = wayPoints[i0].y; i0--; } else if (i0 < i1) { - curX = map_wayPoints[i0].x; - curY = map_wayPoints[i0].y; + curX = wayPoints[i0].x; + curY = wayPoints[i0].y; i0++; } else if (i0 == i1) { - curX = map_wayPoints[i0].x; - curY = map_wayPoints[i0].y; + curX = wayPoints[i0].x; + curY = wayPoints[i0].y; } } - if (i0 == i1 && map_wayPoints[i0].x == x0 - && map_wayPoints[i0].y == y0) { - if (map_checkDirectPath(x0, y0, x1, y1) == 1) + if (i0 == i1 && wayPoints[i0].x == x0 + && wayPoints[i0].y == y0) { + if (checkDirectPath(x0, y0, x1, y1) == 1) return 1; return 0; } - dir = map_getDirection(x0, y0, curX, curY); + dir = getDirection(x0, y0, curX, curY); switch (dir) { case 0: return 0; @@ -376,54 +386,54 @@ int16 map_checkLongPath(int16 x0, int16 y0, int16 x1, int16 y1, int16 i0, int16 } } -void map_optimizePoints(void) { +void Map::optimizePoints(void) { int16 i; - if (map_nearestWayPoint < map_nearestDest) { - for (i = map_nearestWayPoint; i <= map_nearestDest; i++) { - if (map_checkDirectPath(map_curGoblinX, map_curGoblinY, - map_wayPoints[i].x, map_wayPoints[i].y) == 1) - map_nearestWayPoint = i; + if (nearestWayPoint < nearestDest) { + for (i = nearestWayPoint; i <= nearestDest; i++) { + if (checkDirectPath(curGoblinX, curGoblinY, + wayPoints[i].x, wayPoints[i].y) == 1) + nearestWayPoint = i; } - } else if (map_nearestWayPoint > map_nearestDest) { - for (i = map_nearestWayPoint; i >= map_nearestDest; i--) { - if (map_checkDirectPath(map_curGoblinX, map_curGoblinY, - map_wayPoints[i].x, map_wayPoints[i].y) == 1) - map_nearestWayPoint = i; + } else if (nearestWayPoint > nearestDest) { + for (i = nearestWayPoint; i >= nearestDest; i--) { + if (checkDirectPath(curGoblinX, curGoblinY, + wayPoints[i].x, wayPoints[i].y) == 1) + nearestWayPoint = i; } } } -void map_loadDataFromAvo(char *dest, int16 size) { - memcpy(dest, map_avoDataPtr, size); - map_avoDataPtr += size; +void Map::loadDataFromAvo(char *dest, int16 size) { + memcpy(dest, avoDataPtr, size); + avoDataPtr += size; } -uint16 map_loadFromAvo_LE_UINT16() { - uint16 tmp = READ_LE_UINT16(map_avoDataPtr); - map_avoDataPtr += 2; +uint16 Map::loadFromAvo_LE_UINT16() { + uint16 tmp = READ_LE_UINT16(avoDataPtr); + avoDataPtr += 2; return tmp; } -void map_loadItemToObject(void) { +void Map::loadItemToObject(void) { int16 flag; int16 count; int16 i; - flag = map_loadFromAvo_LE_UINT16(); + flag = loadFromAvo_LE_UINT16(); if (flag == 0) return; - map_avoDataPtr += 1456; - count = map_loadFromAvo_LE_UINT16(); + avoDataPtr += 1456; + count = loadFromAvo_LE_UINT16(); for (i = 0; i < count; i++) { - map_avoDataPtr += 20; - gob_itemToObject[i] = map_loadFromAvo_LE_UINT16(); - map_avoDataPtr += 5; + avoDataPtr += 20; + _vm->_goblin->itemToObject[i] = loadFromAvo_LE_UINT16(); + avoDataPtr += 5; } } -void map_loadMapObjects(char *avjFile) { +void Map::loadMapObjects(char *avjFile) { int16 i; char avoName[128]; int16 handle; @@ -436,7 +446,7 @@ void map_loadMapObjects(char *avjFile) { int16 state; int16 col; int32 flag; - Gob_State *pState; + Goblin::Gob_State *pState; char buf[128]; char sndNames[20][14]; char *dataBuf; @@ -445,154 +455,154 @@ void map_loadMapObjects(char *avjFile) { int16 count2; int16 count3; - strcpy(avoName, map_sourceFile); + strcpy(avoName, sourceFile); strcat(avoName, ".avo"); - handle = data_openData(avoName); + handle = _vm->_dataio->openData(avoName); if (handle >= 0) { - map_loadFromAvo = 1; - data_closeData(handle); - map_avoDataPtr = data_getData(avoName); - dataBuf = map_avoDataPtr; - map_loadDataFromAvo((char *)map_passMap, kMapHeight * kMapWidth); + loadFromAvo = 1; + _vm->_dataio->closeData(handle); + avoDataPtr = _vm->_dataio->getData(avoName); + dataBuf = avoDataPtr; + loadDataFromAvo((char *)passMap, kMapHeight * kMapWidth); for (y = 0; y < kMapHeight; y++) { for (x = 0; x < kMapWidth; x++) { - map_loadDataFromAvo(&item, 1); - map_itemsMap[y][x] = item; + loadDataFromAvo(&item, 1); + itemsMap[y][x] = item; } } for (i = 0; i < 40; i++) { - map_wayPoints[i].x = map_loadFromAvo_LE_UINT16(); - map_wayPoints[i].y = map_loadFromAvo_LE_UINT16(); + wayPoints[i].x = loadFromAvo_LE_UINT16(); + wayPoints[i].y = loadFromAvo_LE_UINT16(); } - map_loadDataFromAvo((char *)map_itemPoses, szMap_ItemPos * 20); + loadDataFromAvo((char *)itemPoses, szMap_ItemPos * 20); } else { - map_loadFromAvo = 0; - map_avoDataPtr = data_getData(avjFile); - dataBuf = map_avoDataPtr; + loadFromAvo = 0; + avoDataPtr = _vm->_dataio->getData(avjFile); + dataBuf = avoDataPtr; } - map_avoDataPtr += 32; - map_avoDataPtr += 76; - map_avoDataPtr += 4; - map_avoDataPtr += 20; + avoDataPtr += 32; + avoDataPtr += 76; + avoDataPtr += 4; + avoDataPtr += 20; for (i = 0; i < 3; i++) { - tmp = map_loadFromAvo_LE_UINT16(); - map_avoDataPtr += tmp * 14; + tmp = loadFromAvo_LE_UINT16(); + avoDataPtr += tmp * 14; } - soundCount = map_loadFromAvo_LE_UINT16(); - savedPtr = map_avoDataPtr; + soundCount = loadFromAvo_LE_UINT16(); + savedPtr = avoDataPtr; - map_avoDataPtr += 14 * soundCount; - map_avoDataPtr += 4; - map_avoDataPtr += 24; + avoDataPtr += 14 * soundCount; + avoDataPtr += 4; + avoDataPtr += 24; - count2 = map_loadFromAvo_LE_UINT16(); - count3 = map_loadFromAvo_LE_UINT16(); + count2 = loadFromAvo_LE_UINT16(); + count3 = loadFromAvo_LE_UINT16(); - savedPtr2 = map_avoDataPtr; - map_avoDataPtr += count2 * 8; + savedPtr2 = avoDataPtr; + avoDataPtr += count2 * 8; - savedPtr3 = map_avoDataPtr; - map_avoDataPtr += count3 * 8; + savedPtr3 = avoDataPtr; + avoDataPtr += count3 * 8; - gob_gobsCount = map_loadFromAvo_LE_UINT16(); - for (i = 0; i < gob_gobsCount; i++) { - gob_goblins[i] = (Gob_Object *)malloc(sizeof(Gob_Object)); + _vm->_goblin->gobsCount = loadFromAvo_LE_UINT16(); + for (i = 0; i < _vm->_goblin->gobsCount; i++) { + _vm->_goblin->goblins[i] = (Goblin::Gob_Object *)malloc(sizeof(Goblin::Gob_Object)); - gob_goblins[i]->xPos = READ_LE_UINT16(savedPtr2); + _vm->_goblin->goblins[i]->xPos = READ_LE_UINT16(savedPtr2); savedPtr2 += 2; - gob_goblins[i]->yPos = READ_LE_UINT16(savedPtr2); + _vm->_goblin->goblins[i]->yPos = READ_LE_UINT16(savedPtr2); savedPtr2 += 2; - gob_goblins[i]->order = READ_LE_UINT16(savedPtr2); + _vm->_goblin->goblins[i]->order = READ_LE_UINT16(savedPtr2); savedPtr2 += 2; - gob_goblins[i]->state = READ_LE_UINT16(savedPtr2); + _vm->_goblin->goblins[i]->state = READ_LE_UINT16(savedPtr2); savedPtr2 += 2; if (i == 3) - gob_goblins[i]->stateMach = (Gob_StateLine *)malloc(szGob_StateLine * 70); + _vm->_goblin->goblins[i]->stateMach = (Goblin::Gob_StateLine *)malloc(szGob_StateLine * 70); else - gob_goblins[i]->stateMach = (Gob_StateLine *)malloc(szGob_StateLine * 40); + _vm->_goblin->goblins[i]->stateMach = (Goblin::Gob_StateLine *)malloc(szGob_StateLine * 40); - // FIXME: All is wrong further. We should unwind calls to map_loadDataFromAvo() - map_loadDataFromAvo((char *)gob_goblins[i]->stateMach, 40 * szGob_StateLine); - map_avoDataPtr += 160; - gob_goblins[i]->multObjIndex = *map_avoDataPtr; - map_avoDataPtr += 2; + // FIXME: All is wrong further. We should unwind calls to loadDataFromAvo() + loadDataFromAvo((char *)_vm->_goblin->goblins[i]->stateMach, 40 * szGob_StateLine); + avoDataPtr += 160; + _vm->_goblin->goblins[i]->multObjIndex = *avoDataPtr; + avoDataPtr += 2; - gob_goblins[i]->realStateMach = gob_goblins[i]->stateMach; + _vm->_goblin->goblins[i]->realStateMach = _vm->_goblin->goblins[i]->stateMach; for (state = 0; state < 40; state++) { for (col = 0; col < 6; col++) { - if (gob_goblins[i]->stateMach[state][col] == 0) + if (_vm->_goblin->goblins[i]->stateMach[state][col] == 0) continue; - Gob_State *tmpState = (Gob_State *)malloc(sizeof(Gob_State)); - gob_goblins[i]->stateMach[state][col] = tmpState; + Goblin::Gob_State *tmpState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State)); + _vm->_goblin->goblins[i]->stateMach[state][col] = tmpState; - tmpState->animation = map_loadFromAvo_LE_UINT16(); - tmpState->layer = map_loadFromAvo_LE_UINT16(); - map_avoDataPtr += 8; - tmpState->unk0 = map_loadFromAvo_LE_UINT16(); - tmpState->unk1 = map_loadFromAvo_LE_UINT16(); + tmpState->animation = loadFromAvo_LE_UINT16(); + tmpState->layer = loadFromAvo_LE_UINT16(); + avoDataPtr += 8; + tmpState->unk0 = loadFromAvo_LE_UINT16(); + tmpState->unk1 = loadFromAvo_LE_UINT16(); - map_avoDataPtr += 2; - if (READ_LE_UINT32(map_avoDataPtr) != 0) { - map_avoDataPtr += 4; - tmpState->sndItem = map_loadFromAvo_LE_UINT16(); + avoDataPtr += 2; + if (READ_LE_UINT32(avoDataPtr) != 0) { + avoDataPtr += 4; + tmpState->sndItem = loadFromAvo_LE_UINT16(); } else { - map_avoDataPtr += 6; + avoDataPtr += 6; tmpState->sndItem = -1; } - tmpState->freq = map_loadFromAvo_LE_UINT16(); - tmpState->repCount = map_loadFromAvo_LE_UINT16(); - tmpState->sndFrame = map_loadFromAvo_LE_UINT16(); + tmpState->freq = loadFromAvo_LE_UINT16(); + tmpState->repCount = loadFromAvo_LE_UINT16(); + tmpState->sndFrame = loadFromAvo_LE_UINT16(); } } } - pState = (Gob_State *)malloc(sizeof(Gob_State)); - gob_goblins[0]->stateMach[39][0] = pState; + pState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State)); + _vm->_goblin->goblins[0]->stateMach[39][0] = pState; pState->animation = 0; pState->layer = 98; pState->unk0 = 0; pState->unk1 = 0; pState->sndItem = -1; - pState = (Gob_State *) malloc(sizeof(Gob_State)); - gob_goblins[1]->stateMach[39][0] = pState; + pState = (Goblin::Gob_State *) malloc(sizeof(Goblin::Gob_State)); + _vm->_goblin->goblins[1]->stateMach[39][0] = pState; pState->animation = 0; pState->layer = 99; pState->unk0 = 0; pState->unk1 = 0; pState->sndItem = -1; - pState = (Gob_State *) malloc(sizeof(Gob_State)); - gob_goblins[2]->stateMach[39][0] = pState; + pState = (Goblin::Gob_State *) malloc(sizeof(Goblin::Gob_State)); + _vm->_goblin->goblins[2]->stateMach[39][0] = pState; pState->animation = 0; pState->layer = 100; pState->unk0 = 0; pState->unk1 = 0; pState->sndItem = -1; - gob_goblins[2]->stateMach[10][0]->sndFrame = 13; - gob_goblins[2]->stateMach[11][0]->sndFrame = 13; - gob_goblins[2]->stateMach[28][0]->sndFrame = 13; - gob_goblins[2]->stateMach[29][0]->sndFrame = 13; + _vm->_goblin->goblins[2]->stateMach[10][0]->sndFrame = 13; + _vm->_goblin->goblins[2]->stateMach[11][0]->sndFrame = 13; + _vm->_goblin->goblins[2]->stateMach[28][0]->sndFrame = 13; + _vm->_goblin->goblins[2]->stateMach[29][0]->sndFrame = 13; - gob_goblins[1]->stateMach[10][0]->sndFrame = 13; - gob_goblins[1]->stateMach[11][0]->sndFrame = 13; + _vm->_goblin->goblins[1]->stateMach[10][0]->sndFrame = 13; + _vm->_goblin->goblins[1]->stateMach[11][0]->sndFrame = 13; for (state = 40; state < 70; state++) { - pState = (Gob_State *)malloc(sizeof(Gob_State)); - gob_goblins[3]->stateMach[state][0] = pState; - gob_goblins[3]->stateMach[state][1] = 0; + pState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State)); + _vm->_goblin->goblins[3]->stateMach[state][0] = pState; + _vm->_goblin->goblins[3]->stateMach[state][1] = 0; pState->animation = 9; pState->layer = state - 40; @@ -600,70 +610,70 @@ void map_loadMapObjects(char *avjFile) { pState->sndFrame = 0; } - gob_objCount = map_loadFromAvo_LE_UINT16(); - for (i = 0; i < gob_objCount; i++) { - gob_objects[i] = - (Gob_Object *) malloc(sizeof(Gob_Object)); + _vm->_goblin->objCount = loadFromAvo_LE_UINT16(); + for (i = 0; i < _vm->_goblin->objCount; i++) { + _vm->_goblin->objects[i] = + (Goblin::Gob_Object *) malloc(sizeof(Goblin::Gob_Object)); - gob_objects[i]->xPos = READ_LE_UINT16(savedPtr3); + _vm->_goblin->objects[i]->xPos = READ_LE_UINT16(savedPtr3); savedPtr3 += 2; - gob_objects[i]->yPos = READ_LE_UINT16(savedPtr3); + _vm->_goblin->objects[i]->yPos = READ_LE_UINT16(savedPtr3); savedPtr3 += 2; - gob_objects[i]->order = READ_LE_UINT16(savedPtr3); + _vm->_goblin->objects[i]->order = READ_LE_UINT16(savedPtr3); savedPtr3 += 2; - gob_objects[i]->state = READ_LE_UINT16(savedPtr3); + _vm->_goblin->objects[i]->state = READ_LE_UINT16(savedPtr3); savedPtr3 += 2; - gob_objects[i]->stateMach = (Gob_StateLine *)malloc(szGob_StateLine * 40); + _vm->_goblin->objects[i]->stateMach = (Goblin::Gob_StateLine *)malloc(szGob_StateLine * 40); - map_loadDataFromAvo((char *)gob_objects[i]->stateMach, 40 * szGob_StateLine); - map_avoDataPtr += 160; - gob_objects[i]->multObjIndex = *map_avoDataPtr; - map_avoDataPtr += 2; + loadDataFromAvo((char *)_vm->_goblin->objects[i]->stateMach, 40 * szGob_StateLine); + avoDataPtr += 160; + _vm->_goblin->objects[i]->multObjIndex = *avoDataPtr; + avoDataPtr += 2; - gob_objects[i]->realStateMach = gob_objects[i]->stateMach; + _vm->_goblin->objects[i]->realStateMach = _vm->_goblin->objects[i]->stateMach; for (state = 0; state < 40; state++) { for (col = 0; col < 6; col++) { - if (gob_objects[i]->stateMach[state][col] == 0) + if (_vm->_goblin->objects[i]->stateMach[state][col] == 0) continue; - Gob_State *tmpState = (Gob_State *)malloc(sizeof(Gob_State)); - gob_objects[i]->stateMach[state][col] = tmpState; + Goblin::Gob_State *tmpState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State)); + _vm->_goblin->objects[i]->stateMach[state][col] = tmpState; - tmpState->animation = map_loadFromAvo_LE_UINT16(); - tmpState->layer = map_loadFromAvo_LE_UINT16(); - map_avoDataPtr += 8; - tmpState->unk0 = map_loadFromAvo_LE_UINT16(); - tmpState->unk1 = map_loadFromAvo_LE_UINT16(); + tmpState->animation = loadFromAvo_LE_UINT16(); + tmpState->layer = loadFromAvo_LE_UINT16(); + avoDataPtr += 8; + tmpState->unk0 = loadFromAvo_LE_UINT16(); + tmpState->unk1 = loadFromAvo_LE_UINT16(); - map_avoDataPtr += 2; - if (READ_LE_UINT32(map_avoDataPtr) != 0) { - map_avoDataPtr += 4; - tmpState->sndItem = map_loadFromAvo_LE_UINT16(); + avoDataPtr += 2; + if (READ_LE_UINT32(avoDataPtr) != 0) { + avoDataPtr += 4; + tmpState->sndItem = loadFromAvo_LE_UINT16(); } else { - map_avoDataPtr += 6; + avoDataPtr += 6; tmpState->sndItem = -1; } - tmpState->freq = map_loadFromAvo_LE_UINT16(); - tmpState->repCount = map_loadFromAvo_LE_UINT16(); - tmpState->sndFrame = map_loadFromAvo_LE_UINT16(); + tmpState->freq = loadFromAvo_LE_UINT16(); + tmpState->repCount = loadFromAvo_LE_UINT16(); + tmpState->sndFrame = loadFromAvo_LE_UINT16(); } } } - gob_objects[10] = (Gob_Object *)malloc(sizeof(Gob_Object)); - memset(gob_objects[10], 0, sizeof(Gob_Object)); + _vm->_goblin->objects[10] = (Goblin::Gob_Object *)malloc(sizeof(Goblin::Gob_Object)); + memset(_vm->_goblin->objects[10], 0, sizeof(Goblin::Gob_Object)); - gob_objects[10]->stateMach = (Gob_StateLine *)malloc(szGob_StateLine * 40); - memset(gob_objects[10]->stateMach, 0, szGob_StateLine * 40); + _vm->_goblin->objects[10]->stateMach = (Goblin::Gob_StateLine *)malloc(szGob_StateLine * 40); + memset(_vm->_goblin->objects[10]->stateMach, 0, szGob_StateLine * 40); - pState = (Gob_State *)malloc(sizeof(Gob_State)); - gob_objects[10]->stateMach[0][0] = pState; + pState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State)); + _vm->_goblin->objects[10]->stateMach[0][0] = pState; - memset(pState, 0, sizeof(Gob_State)); + memset(pState, 0, sizeof(Goblin::Gob_State)); pState->animation = 9; pState->layer = 27; pState->unk0 = 0; @@ -671,84 +681,84 @@ void map_loadMapObjects(char *avjFile) { pState->sndItem = -1; pState->sndFrame = 0; - gob_placeObject(gob_objects[10], 1); + _vm->_goblin->placeObject(_vm->_goblin->objects[10], 1); - gob_objects[10]->realStateMach = gob_objects[10]->stateMach; - gob_objects[10]->type = 1; - gob_objects[10]->unk14 = 1; + _vm->_goblin->objects[10]->realStateMach = _vm->_goblin->objects[10]->stateMach; + _vm->_goblin->objects[10]->type = 1; + _vm->_goblin->objects[10]->unk14 = 1; - state = map_loadFromAvo_LE_UINT16(); + state = loadFromAvo_LE_UINT16(); for (i = 0; i < state; i++) { - map_avoDataPtr += 30; + avoDataPtr += 30; - map_loadDataFromAvo((char *)&flag, 4); - map_avoDataPtr += 56; + loadDataFromAvo((char *)&flag, 4); + avoDataPtr += 56; if (flag != 0) - map_avoDataPtr += 30; + avoDataPtr += 30; } - map_loadDataFromAvo((char *)&tmp, 2); - map_avoDataPtr += 48; - map_loadItemToObject(); - map_avoDataPtr = savedPtr; + loadDataFromAvo((char *)&tmp, 2); + avoDataPtr += 48; + loadItemToObject(); + avoDataPtr = savedPtr; for (i = 0; i < soundCount; i++) { - map_loadDataFromAvo(buf, 14); + loadDataFromAvo(buf, 14); strcat(buf, ".SND"); strcpy(sndNames[i], buf); } free(dataBuf); - gob_soundData[14] = snd_loadSoundData("diamant1.snd"); + _vm->_goblin->soundData[14] = _vm->_snd->loadSoundData("diamant1.snd"); for (i = 0; i < soundCount; i++) { - handle = data_openData(sndNames[i]); + handle = _vm->_dataio->openData(sndNames[i]); if (handle < 0) continue; - data_closeData(handle); - gob_soundData[i] = snd_loadSoundData(sndNames[i]); + _vm->_dataio->closeData(handle); + _vm->_goblin->soundData[i] = _vm->_snd->loadSoundData(sndNames[i]); } } -void map_loadMapsInitGobs(void) { +void Map::loadMapsInitGobs(void) { int16 layer; int16 i; - if (map_loadFromAvo == 0) - error("map_load: Loading .pas/.pos files is not supported!"); + if (loadFromAvo == 0) + error("load: Loading .pas/.pos files is not supported!"); for (i = 0; i < 3; i++) { - gob_nextLayer(gob_goblins[i]); + _vm->_goblin->nextLayer(_vm->_goblin->goblins[i]); } for (i = 0; i < 3; i++) { layer = - gob_goblins[i]->stateMach[gob_goblins[i]->state][0]->layer; + _vm->_goblin->goblins[i]->stateMach[_vm->_goblin->goblins[i]->state][0]->layer; - scen_updateAnim(layer, 0, gob_goblins[i]->animation, 0, - gob_goblins[i]->xPos, gob_goblins[i]->yPos, 0); + _vm->_scenery->updateAnim(layer, 0, _vm->_goblin->goblins[i]->animation, 0, + _vm->_goblin->goblins[i]->xPos, _vm->_goblin->goblins[i]->yPos, 0); - gob_goblins[i]->yPos = (gob_gobPositions[i].y + 1) * 6 - - (scen_toRedrawBottom - scen_animTop); + _vm->_goblin->goblins[i]->yPos = (_vm->_goblin->gobPositions[i].y + 1) * 6 - + (_vm->_scenery->toRedrawBottom - _vm->_scenery->animTop); - gob_goblins[i]->xPos = gob_gobPositions[i].x * 12 - - (scen_toRedrawLeft - scen_animLeft); + _vm->_goblin->goblins[i]->xPos = _vm->_goblin->gobPositions[i].x * 12 - + (_vm->_scenery->toRedrawLeft - _vm->_scenery->animLeft); - gob_goblins[i]->order = scen_toRedrawBottom / 24 + 3; + _vm->_goblin->goblins[i]->order = _vm->_scenery->toRedrawBottom / 24 + 3; } - gob_currentGoblin = 0; - gob_pressedMapX = gob_gobPositions[0].x; - gob_pressedMapY = gob_gobPositions[0].y; - gob_pathExistence = 0; + _vm->_goblin->currentGoblin = 0; + _vm->_goblin->pressedMapX = _vm->_goblin->gobPositions[0].x; + _vm->_goblin->pressedMapY = _vm->_goblin->gobPositions[0].y; + _vm->_goblin->pathExistence = 0; - gob_goblins[0]->doAnim = 0; - gob_goblins[1]->doAnim = 1; - gob_goblins[2]->doAnim = 1; + _vm->_goblin->goblins[0]->doAnim = 0; + _vm->_goblin->goblins[1]->doAnim = 1; + _vm->_goblin->goblins[2]->doAnim = 1; } } // End of namespace Gob diff --git a/gob/map.h b/gob/map.h index 9804b1559a..754dbe69a7 100644 --- a/gob/map.h +++ b/gob/map.h @@ -26,67 +26,78 @@ namespace Gob { // The same numeric values are also used for the arrow keys. -enum { - kDirNW = 0x4700, - kDirN = 0x4800, - kDirNE = 0x4900, - kDirW = 0x4b00, - kDirE = 0x4d00, - kDirSW = 0x4f00, - kDirS = 0x5000, - kDirSE = 0x5100 -}; +class Map { +public: + enum { + kDirNW = 0x4700, + kDirN = 0x4800, + kDirNE = 0x4900, + kDirW = 0x4b00, + kDirE = 0x4d00, + kDirSW = 0x4f00, + kDirS = 0x5000, + kDirSE = 0x5100 + }; + enum { + kMapWidth = 26, + kMapHeight = 28 + }; #pragma START_PACK_STRUCTS -typedef struct Map_Point { - int16 x; - int16 y; -} GCC_PACK Map_Point; + typedef struct Point { + int16 x; + int16 y; + } GCC_PACK Point; #define szMap_ItemPos 3 - typedef struct Map_ItemPos { - int8 x; - int8 y; - int8 orient; // ?? -} GCC_PACK Map_ItemPos; + typedef struct ItemPos { + int8 x; + int8 y; + int8 orient; // ?? + } GCC_PACK ItemPos; #pragma END_PACK_STRUCTS -enum { - kMapWidth = 26, - kMapHeight = 28 + int8 passMap[kMapHeight][kMapWidth]; // [y][x] + int16 itemsMap[kMapHeight][kMapWidth]; // [y][x] + Point wayPoints[40]; + int16 nearestWayPoint; + int16 nearestDest; + + int16 curGoblinX; + int16 curGoblinY; + int16 destX; + int16 destY; + int8 loadFromAvo; + + ItemPos itemPoses[40]; + char sourceFile[15]; + + void placeItem(int16 x, int16 y, int16 id); + + int16 getDirection(int16 x0, int16 y0, int16 x1, int16 y1); + void findNearestToGob(void); + void findNearestToDest(void); + int16 checkDirectPath(int16 x0, int16 y0, int16 x1, int16 y1); + int16 checkLongPath(int16 x0, int16 y0, int16 x1, int16 y1, int16 i0, int16 i1); + void optimizePoints(void); + void loadItemToObject(void); + void loadMapObjects(char *avjFile); + void loadDataFromAvo(char *dest, int16 size); + void loadMapsInitGobs(void); + + Map(GobEngine *vm); + +protected: + char *avoDataPtr; + GobEngine *_vm; + + int16 findNearestWayPoint(int16 x, int16 y); + uint16 loadFromAvo_LE_UINT16(); }; -extern int8 map_passMap[kMapHeight][kMapWidth]; // [y][x] -extern int16 map_itemsMap[kMapHeight][kMapWidth]; // [y][x] -extern Map_Point map_wayPoints[40]; -extern int16 map_nearestWayPoint; -extern int16 map_nearestDest; - -extern int16 map_curGoblinX; -extern int16 map_curGoblinY; -extern int16 map_destX; -extern int16 map_destY; -extern int8 map_loadFromAvo; - -extern Map_ItemPos map_itemPoses[40]; -extern char map_sourceFile[15]; - -void map_placeItem(int16 x, int16 y, int16 id); - -int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1); -void map_findNearestToGob(void); -void map_findNearestToDest(void); -int16 map_checkDirectPath(int16 x0, int16 y0, int16 x1, int16 y1); -int16 map_checkLongPath(int16 x0, int16 y0, int16 x1, int16 y1, int16 i0, int16 i1); -void map_optimizePoints(void); -void map_loadItemToObject(void); -void map_loadMapObjects(char *avjFile); -void map_loadDataFromAvo(int8 *dest, int16 size); -void map_loadMapsInitGobs(void); - } // End of namespace Gob #endif /* __MAP_H */ diff --git a/gob/mult.cpp b/gob/mult.cpp index c0d7a2264a..e9ff27a20d 100644 --- a/gob/mult.cpp +++ b/gob/mult.cpp @@ -35,73 +35,85 @@ namespace Gob { -Mult_Object *mult_objects; -int16 *mult_renderData; -int16 mult_objCount; -int16 mult_frame; - -char *mult_multData; -char mult_doPalSubst; -int16 mult_counter; -int16 mult_frameRate; - -int32 *mult_animArrayX; -int32 *mult_animArrayY; - -Mult_AnimData *mult_animArrayData; - -int16 mult_index; - -// Static keys -int16 mult_staticKeysCount; -Mult_StaticKey *mult_staticKeys; -int16 mult_staticIndices[10]; - -// Anim keys -Mult_AnimKey *mult_animKeys[4]; -int16 mult_animKeysCount[4]; -int16 mult_animLayer; -int16 mult_animIndices[10]; - -// Text keys -int16 mult_textKeysCount; -Mult_TextKey *mult_textKeys; - -int16 mult_frameStart; - -// Palette keys -int16 mult_palKeyIndex; -int16 mult_palKeysCount; -Mult_PalKey *mult_palKeys; -Color *mult_oldPalette; -Color mult_palAnimPalette[256]; -int16 mult_palAnimKey; -int16 mult_palAnimIndices[4]; -int16 mult_palAnimRed[4]; -int16 mult_palAnimGreen[4]; -int16 mult_palAnimBlue[4]; - -// Palette fading -Mult_PalFadeKey *mult_palFadeKeys; -int16 mult_palFadeKeysCount; -char mult_palFadingRed; -char mult_palFadingGreen; -char mult_palFadingBlue; - -Color mult_fadePal[5][16]; - -// Sounds -int16 mult_sndKeysCount; -Mult_SndKey *mult_sndKeys; - -char mult_animDataAllocated; - -char *mult_dataPtr; -int16 mult_staticLoaded[10]; -int16 mult_animLoaded[10]; -int16 mult_sndSlotsCount; - -void mult_animate(void) { +Mult::Mult(GobEngine *vm) : _vm(vm) { + objects = 0; + renderData = 0; + objCount = 0; + underAnimSurf = 0; + multData = 0; + frame = 0; + doPalSubst = 0; + counter = 0; + frameRate = 0; + + animArrayX = 0; + animArrayY = 0; + animArrayData = 0; + + index = 0; + + staticKeysCount = 0; + staticKeys = 0; + for (int i = 0; i < 10; i++) + staticIndices[i] = 0; + + for (int i = 0; i < 4; i++) { + animKeys[i] = 0; + animKeysCount[i] = 0; + } + animLayer = 0; + for (int i = 0; i < 10; i++) + animIndices[i] = 0; + + textKeysCount = 0; + textKeys = 0; + + frameStart = 0; + + palKeyIndex = 0; + palKeysCount = 0; + palKeys = 0; + oldPalette = 0; + palAnimKey = 0; + for (int i = 0; i < 256; i++) { + palAnimPalette[i].red = 0; + palAnimPalette[i].green = 0; + palAnimPalette[i].blue = 0; + } + for (int i = 0; i < 4; i++) { + palAnimIndices[i] = 0; + palAnimRed[i] = 0; + palAnimGreen[i] = 0; + palAnimBlue[i] = 0; + } + + palFadeKeys = 0; + palFadeKeysCount = 0; + palFadingRed = 0; + palFadingGreen = 0; + palFadingBlue = 0; + + animDataAllocated = 0; + + dataPtr = 0; + for (int i = 0; i < 10; i++) { + staticLoaded[i] = 0; + animLoaded[i] = 0; + } + sndSlotsCount = 0; + + sndKeysCount = 0; + sndKeys = 0; + + for (int i = 0; i < 5; i++) + for (int j = 0; j < 16; j++) { + fadePal[i][j].red = 0; + fadePal[i][j].green = 0; + fadePal[i][j].blue = 0; + } +} + +void Mult::animate(void) { int16 minOrder; int16 maxOrder; int16 *pCurLefts; @@ -117,32 +129,32 @@ void mult_animate(void) { int16 i, j; int16 order; - if (mult_renderData == 0) + if (renderData == 0) return; - pDirtyLefts = mult_renderData; - pDirtyRights = pDirtyLefts + mult_objCount; - pDirtyTops = pDirtyRights + mult_objCount; - pDirtyBottoms = pDirtyTops + mult_objCount; - pNeedRedraw = pDirtyBottoms + mult_objCount; - pCurLefts = pNeedRedraw + mult_objCount; - pCurRights = pCurLefts + mult_objCount; - pCurTops = pCurRights + mult_objCount; - pCurBottoms = pCurTops + mult_objCount; + pDirtyLefts = renderData; + pDirtyRights = pDirtyLefts + objCount; + pDirtyTops = pDirtyRights + objCount; + pDirtyBottoms = pDirtyTops + objCount; + pNeedRedraw = pDirtyBottoms + objCount; + pCurLefts = pNeedRedraw + objCount; + pCurRights = pCurLefts + objCount; + pCurTops = pCurRights + objCount; + pCurBottoms = pCurTops + objCount; minOrder = 100; maxOrder = 0; //Find dirty areas - for (i = 0; i < mult_objCount; i++) { + for (i = 0; i < objCount; i++) { pNeedRedraw[i] = 0; pDirtyTops[i] = 1000; pDirtyLefts[i] = 1000; pDirtyBottoms[i] = 1000; pDirtyRights[i] = 1000; - pAnimData = mult_objects[i].pAnimData; + pAnimData = objects[i].pAnimData; if (pAnimData->isStatic == 0 && pAnimData->isPaused == 0 && - mult_objects[i].tick == pAnimData->maxTick) { + objects[i].tick == pAnimData->maxTick) { if (pAnimData->order < minOrder) minOrder = pAnimData->order; @@ -150,36 +162,36 @@ void mult_animate(void) { maxOrder = pAnimData->order; pNeedRedraw[i] = 1; - scen_updateAnim(pAnimData->layer, pAnimData->frame, + _vm->_scenery->updateAnim(pAnimData->layer, pAnimData->frame, pAnimData->animation, 0, - *(mult_objects[i].pPosX), *(mult_objects[i].pPosY), + *(objects[i].pPosX), *(objects[i].pPosY), 0); - if (mult_objects[i].lastLeft != -1) { + if (objects[i].lastLeft != -1) { pDirtyLefts[i] = - MIN(mult_objects[i].lastLeft, - scen_toRedrawLeft); + MIN(objects[i].lastLeft, + _vm->_scenery->toRedrawLeft); pDirtyTops[i] = - MIN(mult_objects[i].lastTop, - scen_toRedrawTop); + MIN(objects[i].lastTop, + _vm->_scenery->toRedrawTop); pDirtyRights[i] = - MAX(mult_objects[i].lastRight, - scen_toRedrawRight); + MAX(objects[i].lastRight, + _vm->_scenery->toRedrawRight); pDirtyBottoms[i] = - MAX(mult_objects[i].lastBottom, - scen_toRedrawBottom); + MAX(objects[i].lastBottom, + _vm->_scenery->toRedrawBottom); } else { - pDirtyLefts[i] = scen_toRedrawLeft; - pDirtyTops[i] = scen_toRedrawTop; - pDirtyRights[i] = scen_toRedrawRight; - pDirtyBottoms[i] = scen_toRedrawBottom; + pDirtyLefts[i] = _vm->_scenery->toRedrawLeft; + pDirtyTops[i] = _vm->_scenery->toRedrawTop; + pDirtyRights[i] = _vm->_scenery->toRedrawRight; + pDirtyBottoms[i] = _vm->_scenery->toRedrawBottom; } - pCurLefts[i] = scen_toRedrawLeft; - pCurRights[i] = scen_toRedrawRight; - pCurTops[i] = scen_toRedrawTop; - pCurBottoms[i] = scen_toRedrawBottom; + pCurLefts[i] = _vm->_scenery->toRedrawLeft; + pCurRights[i] = _vm->_scenery->toRedrawRight; + pCurTops[i] = _vm->_scenery->toRedrawTop; + pCurBottoms[i] = _vm->_scenery->toRedrawBottom; } else { - if (mult_objects[i].lastLeft != -1) { + if (objects[i].lastLeft != -1) { if (pAnimData->order < minOrder) minOrder = pAnimData->order; @@ -189,34 +201,34 @@ void mult_animate(void) { if (pAnimData->isStatic) *pNeedRedraw = 1; - pCurLefts[i] = mult_objects[i].lastLeft; - pDirtyLefts[i] = mult_objects[i].lastLeft; + pCurLefts[i] = objects[i].lastLeft; + pDirtyLefts[i] = objects[i].lastLeft; - pCurTops[i] = mult_objects[i].lastTop; - pDirtyTops[i] = mult_objects[i].lastTop; + pCurTops[i] = objects[i].lastTop; + pDirtyTops[i] = objects[i].lastTop; - pCurRights[i] = mult_objects[i].lastRight; - pDirtyRights[i] = mult_objects[i].lastRight; + pCurRights[i] = objects[i].lastRight; + pDirtyRights[i] = objects[i].lastRight; - pCurBottoms[i] = mult_objects[i].lastBottom; - pDirtyBottoms[i] = mult_objects[i].lastBottom; + pCurBottoms[i] = objects[i].lastBottom; + pDirtyBottoms[i] = objects[i].lastBottom; } } } // Find intersections - for (i = 0; i < mult_objCount; i++) { - pAnimData = mult_objects[i].pAnimData; + for (i = 0; i < objCount; i++) { + pAnimData = objects[i].pAnimData; pAnimData->intersected = 200; if (pAnimData->isStatic) continue; - for (j = 0; j < mult_objCount; j++) { + for (j = 0; j < objCount; j++) { if (i == j) continue; - if (mult_objects[j].pAnimData->isStatic) + if (objects[j].pAnimData->isStatic) continue; if (pCurRights[i] < pCurLefts[j]) @@ -237,56 +249,56 @@ void mult_animate(void) { } // Restore dirty areas - for (i = 0; i < mult_objCount; i++) { + for (i = 0; i < objCount; i++) { - if (pNeedRedraw[i] == 0 || mult_objects[i].lastLeft == -1) + if (pNeedRedraw[i] == 0 || objects[i].lastLeft == -1) continue; - draw_sourceSurface = 22; - draw_destSurface = 21; - draw_spriteLeft = pDirtyLefts[i] - anim_animAreaLeft; - draw_spriteTop = pDirtyTops[i] - anim_animAreaTop; - draw_spriteRight = pDirtyRights[i] - pDirtyLefts[i] + 1; - draw_spriteBottom = pDirtyBottoms[i] - pDirtyTops[i] + 1; - draw_destSpriteX = pDirtyLefts[i]; - draw_destSpriteY = pDirtyTops[i]; - draw_transparency = 0; - draw_spriteOperation(DRAW_BLITSURF); - mult_objects[i].lastLeft = -1; + _vm->_draw->sourceSurface = 22; + _vm->_draw->destSurface = 21; + _vm->_draw->spriteLeft = pDirtyLefts[i] - _vm->_anim->_areaLeft; + _vm->_draw->spriteTop = pDirtyTops[i] - _vm->_anim->_areaTop; + _vm->_draw->spriteRight = pDirtyRights[i] - pDirtyLefts[i] + 1; + _vm->_draw->spriteBottom = pDirtyBottoms[i] - pDirtyTops[i] + 1; + _vm->_draw->destSpriteX = pDirtyLefts[i]; + _vm->_draw->destSpriteY = pDirtyTops[i]; + _vm->_draw->transparency = 0; + _vm->_draw->spriteOperation(DRAW_BLITSURF); + objects[i].lastLeft = -1; } // Update view for (order = minOrder; order <= maxOrder; order++) { - for (i = 0; i < mult_objCount; i++) { - pAnimData = mult_objects[i].pAnimData; + for (i = 0; i < objCount; i++) { + pAnimData = objects[i].pAnimData; if (pAnimData->order != order) continue; if (pNeedRedraw[i]) { if (pAnimData->isStatic == 0) { - scen_updateAnim(pAnimData->layer, + _vm->_scenery->updateAnim(pAnimData->layer, pAnimData->frame, pAnimData->animation, 2, - *(mult_objects[i].pPosX), - *(mult_objects[i].pPosY), 1); - - if (scen_toRedrawLeft != -12345) { - mult_objects[i].lastLeft = - scen_toRedrawLeft; - mult_objects[i].lastTop = - scen_toRedrawTop; - mult_objects[i].lastRight = - scen_toRedrawRight; - mult_objects[i].lastBottom = - scen_toRedrawBottom; + *(objects[i].pPosX), + *(objects[i].pPosY), 1); + + if (_vm->_scenery->toRedrawLeft != -12345) { + objects[i].lastLeft = + _vm->_scenery->toRedrawLeft; + objects[i].lastTop = + _vm->_scenery->toRedrawTop; + objects[i].lastRight = + _vm->_scenery->toRedrawRight; + objects[i].lastBottom = + _vm->_scenery->toRedrawBottom; } else { - mult_objects[i].lastLeft = -1; + objects[i].lastLeft = -1; } } - scen_updateStatic(order + 1); + _vm->_scenery->updateStatic(order + 1); } else if (pAnimData->isStatic == 0) { - for (j = 0; j < mult_objCount; j++) { + for (j = 0; j < objCount; j++) { if (pNeedRedraw[j] == 0) continue; @@ -302,38 +314,38 @@ void mult_animate(void) { if (pDirtyBottoms[j] < pDirtyTops[i]) continue; - scen_toRedrawLeft = pDirtyLefts[j]; - scen_toRedrawRight = pDirtyRights[j]; - scen_toRedrawTop = pDirtyTops[j]; - scen_toRedrawBottom = pDirtyBottoms[j]; + _vm->_scenery->toRedrawLeft = pDirtyLefts[j]; + _vm->_scenery->toRedrawRight = pDirtyRights[j]; + _vm->_scenery->toRedrawTop = pDirtyTops[j]; + _vm->_scenery->toRedrawBottom = pDirtyBottoms[j]; - scen_updateAnim(pAnimData->layer, + _vm->_scenery->updateAnim(pAnimData->layer, pAnimData->frame, pAnimData->animation, 4, - *(mult_objects[i].pPosX), - *(mult_objects[i].pPosY), 1); + *(objects[i].pPosX), + *(objects[i].pPosY), 1); - scen_updateStatic(order + 1); + _vm->_scenery->updateStatic(order + 1); } } } } // Advance animations - for (i = 0; i < mult_objCount; i++) { - pAnimData = mult_objects[i].pAnimData; + for (i = 0; i < objCount; i++) { + pAnimData = objects[i].pAnimData; if (pAnimData->isStatic || pAnimData->isPaused) continue; - if (mult_objects[i].tick == pAnimData->maxTick) { - mult_objects[i].tick = 0; + if (objects[i].tick == pAnimData->maxTick) { + objects[i].tick = 0; if (pAnimData->animType == 4) { pAnimData->isPaused = 1; pAnimData->frame = 0; } else { pAnimData->frame++; if (pAnimData->frame >= - scen_animations[(int)pAnimData->animation].layers[pAnimData->layer]->framesCount) { + _vm->_scenery->animations[(int)pAnimData->animation].layers[pAnimData->layer]->framesCount) { switch (pAnimData->animType) { case 0: pAnimData->frame = 0; @@ -342,13 +354,13 @@ void mult_animate(void) { case 1: pAnimData->frame = 0; - *(mult_objects[i].pPosX) = - *(mult_objects[i].pPosX) + - scen_animations[(int)pAnimData->animation].layers[pAnimData->layer]->animDeltaX; + *(objects[i].pPosX) = + *(objects[i].pPosX) + + _vm->_scenery->animations[(int)pAnimData->animation].layers[pAnimData->layer]->animDeltaX; - *(mult_objects[i].pPosY) = - *(mult_objects[i].pPosY) + - scen_animations[(int)pAnimData->animation].layers[pAnimData->layer]->animDeltaY; + *(objects[i].pPosY) = + *(objects[i].pPosY) + + _vm->_scenery->animations[(int)pAnimData->animation].layers[pAnimData->layer]->animDeltaY; break; case 2: @@ -380,29 +392,29 @@ void mult_animate(void) { } } } else { - mult_objects[i].tick++; + objects[i].tick++; } } } -void mult_interGetObjAnimSize(void) { +void Mult::interGetObjAnimSize(void) { Mult_AnimData *pAnimData; int16 objIndex; - inter_evalExpr(&objIndex); - pAnimData = mult_objects[objIndex].pAnimData; + _vm->_inter->evalExpr(&objIndex); + pAnimData = objects[objIndex].pAnimData; if (pAnimData->isStatic == 0) { - scen_updateAnim(pAnimData->layer, pAnimData->frame, - pAnimData->animation, 0, *(mult_objects[objIndex].pPosX), - *(mult_objects[objIndex].pPosY), 0); + _vm->_scenery->updateAnim(pAnimData->layer, pAnimData->frame, + pAnimData->animation, 0, *(objects[objIndex].pPosX), + *(objects[objIndex].pPosY), 0); } - WRITE_VAR_OFFSET(parse_parseVarIndex(), scen_toRedrawLeft); - WRITE_VAR_OFFSET(parse_parseVarIndex(), scen_toRedrawTop); - WRITE_VAR_OFFSET(parse_parseVarIndex(), scen_toRedrawRight); - WRITE_VAR_OFFSET(parse_parseVarIndex(), scen_toRedrawBottom); + WRITE_VAR_OFFSET(_vm->_parse->parseVarIndex(), _vm->_scenery->toRedrawLeft); + WRITE_VAR_OFFSET(_vm->_parse->parseVarIndex(), _vm->_scenery->toRedrawTop); + WRITE_VAR_OFFSET(_vm->_parse->parseVarIndex(), _vm->_scenery->toRedrawRight); + WRITE_VAR_OFFSET(_vm->_parse->parseVarIndex(), _vm->_scenery->toRedrawBottom); } -void mult_interInitMult(void) { +void Mult::interInitMult(void) { int16 oldAnimHeight; int16 oldAnimWidth; int16 oldObjCount; @@ -411,177 +423,177 @@ void mult_interInitMult(void) { int16 posYVar; int16 animDataVar; - oldAnimWidth = anim_animAreaWidth; - oldAnimHeight = anim_animAreaHeight; - oldObjCount = mult_objCount; - - anim_animAreaLeft = inter_load16(); - anim_animAreaTop = inter_load16(); - anim_animAreaWidth = inter_load16(); - anim_animAreaHeight = inter_load16(); - mult_objCount = inter_load16(); - posXVar = parse_parseVarIndex(); - posYVar = parse_parseVarIndex(); - animDataVar = parse_parseVarIndex(); - - if (mult_objects == 0) { - mult_renderData = (int16 *)malloc(sizeof(int16) * mult_objCount * 9); - mult_objects = (Mult_Object *)malloc(sizeof(Mult_Object) * mult_objCount); - - for (i = 0; i < mult_objCount; i++) { - mult_objects[i].pPosX = (int32 *)(inter_variables + i * 4 + (posXVar / 4) * 4); - mult_objects[i].pPosY = (int32 *)(inter_variables + i * 4 + (posYVar / 4) * 4); - mult_objects[i].pAnimData = - (Mult_AnimData *) (inter_variables + animDataVar + - i * 4 * inter_animDataSize); - - mult_objects[i].pAnimData->isStatic = 1; - mult_objects[i].tick = 0; - mult_objects[i].lastLeft = -1; - mult_objects[i].lastRight = -1; - mult_objects[i].lastTop = -1; - mult_objects[i].lastBottom = -1; + oldAnimWidth = _vm->_anim->_areaWidth; + oldAnimHeight = _vm->_anim->_areaHeight; + oldObjCount = objCount; + + _vm->_anim->_areaLeft = _vm->_inter->load16(); + _vm->_anim->_areaTop = _vm->_inter->load16(); + _vm->_anim->_areaWidth = _vm->_inter->load16(); + _vm->_anim->_areaHeight = _vm->_inter->load16(); + objCount = _vm->_inter->load16(); + posXVar = _vm->_parse->parseVarIndex(); + posYVar = _vm->_parse->parseVarIndex(); + animDataVar = _vm->_parse->parseVarIndex(); + + if (objects == 0) { + renderData = (int16 *)malloc(sizeof(int16) * objCount * 9); + objects = (Mult_Object *)malloc(sizeof(Mult_Object) * objCount); + + for (i = 0; i < objCount; i++) { + objects[i].pPosX = (int32 *)(_vm->_global->inter_variables + i * 4 + (posXVar / 4) * 4); + objects[i].pPosY = (int32 *)(_vm->_global->inter_variables + i * 4 + (posYVar / 4) * 4); + objects[i].pAnimData = + (Mult_AnimData *) (_vm->_global->inter_variables + animDataVar + + i * 4 * _vm->_global->inter_animDataSize); + + objects[i].pAnimData->isStatic = 1; + objects[i].tick = 0; + objects[i].lastLeft = -1; + objects[i].lastRight = -1; + objects[i].lastTop = -1; + objects[i].lastBottom = -1; } - } else if (oldObjCount != mult_objCount) { - error("mult_interInitMult: Object count changed, but storage didn't (old count = %d, new count = %d)", - oldObjCount, mult_objCount); + } else if (oldObjCount != objCount) { + error("interInitMult: Object count changed, but storage didn't (old count = %d, new count = %d)", + oldObjCount, objCount); } - if (anim_underAnimSurf != 0 && - (oldAnimWidth != anim_animAreaWidth - || oldAnimHeight != anim_animAreaHeight)) { - vid_freeSurfDesc(anim_underAnimSurf); - anim_underAnimSurf = 0; + if (_vm->_anim->_animSurf != 0 && + (oldAnimWidth != _vm->_anim->_areaWidth + || oldAnimHeight != _vm->_anim->_areaHeight)) { + _vm->_video->freeSurfDesc(_vm->_anim->_animSurf); + _vm->_anim->_animSurf = 0; } - if (anim_underAnimSurf == 0) { - anim_underAnimSurf = vid_initSurfDesc(videoMode, - anim_animAreaWidth, anim_animAreaHeight, 0); + if (_vm->_anim->_animSurf == 0) { + _vm->_anim->_animSurf = _vm->_video->initSurfDesc(_vm->_global->videoMode, + _vm->_anim->_areaWidth, _vm->_anim->_areaHeight, 0); - draw_spritesArray[22] = anim_underAnimSurf; + _vm->_draw->spritesArray[22] = _vm->_anim->_animSurf; } - vid_drawSprite(draw_backSurface, anim_underAnimSurf, - anim_animAreaLeft, anim_animAreaTop, - anim_animAreaLeft + anim_animAreaWidth - 1, - anim_animAreaTop + anim_animAreaHeight - 1, 0, 0, 0); + _vm->_video->drawSprite(_vm->_draw->backSurface, _vm->_anim->_animSurf, + _vm->_anim->_areaLeft, _vm->_anim->_areaTop, + _vm->_anim->_areaLeft + _vm->_anim->_areaWidth - 1, + _vm->_anim->_areaTop + _vm->_anim->_areaHeight - 1, 0, 0, 0); - debug(4, "mult_interInitMult: x = %d, y = %d, w = %d, h = %d", - anim_animAreaLeft, anim_animAreaTop, anim_animAreaWidth, anim_animAreaHeight); - debug(4, " objCount = %d, animation data size = %d", mult_objCount, inter_animDataSize); + debug(4, "interInitMult: x = %d, y = %d, w = %d, h = %d", + _vm->_anim->_areaLeft, _vm->_anim->_areaTop, _vm->_anim->_areaWidth, _vm->_anim->_areaHeight); + debug(4, " objCount = %d, animation data size = %d", objCount, _vm->_global->inter_animDataSize); } -void mult_freeMult(void) { - if (anim_underAnimSurf != 0) - vid_freeSurfDesc(anim_underAnimSurf); +void Mult::freeMult(void) { + if (_vm->_anim->_animSurf != 0) + _vm->_video->freeSurfDesc(_vm->_anim->_animSurf); - free(mult_objects); - free(mult_renderData); + free(objects); + free(renderData); - mult_objects = 0; - mult_renderData = 0; - anim_underAnimSurf = 0; + objects = 0; + renderData = 0; + _vm->_anim->_animSurf = 0; } -void mult_interLoadMult(void) { +void Mult::interLoadMult(void) { int16 val; int16 objIndex; int16 i; - char *multData; + char *lmultData; - debug(4, "mult_interLoadMult: Loading..."); + debug(4, "interLoadMult: Loading..."); - inter_evalExpr(&objIndex); - inter_evalExpr(&val); - *mult_objects[objIndex].pPosX = val; - inter_evalExpr(&val); - *mult_objects[objIndex].pPosY = val; + _vm->_inter->evalExpr(&objIndex); + _vm->_inter->evalExpr(&val); + *objects[objIndex].pPosX = val; + _vm->_inter->evalExpr(&val); + *objects[objIndex].pPosY = val; - multData = (char *)mult_objects[objIndex].pAnimData; + lmultData = (char *)objects[objIndex].pAnimData; for (i = 0; i < 11; i++) { - if ((char)READ_LE_UINT16(inter_execPtr) == (char)99) { - inter_evalExpr(&val); - multData[i] = val; + if ((char)READ_LE_UINT16(_vm->_global->inter_execPtr) == (char)99) { + _vm->_inter->evalExpr(&val); + lmultData[i] = val; } else { - inter_execPtr++; + _vm->_global->inter_execPtr++; } } } -void mult_freeAll(void) { +void Mult::freeAll(void) { int16 i; - mult_freeMult(); + freeMult(); for (i = 0; i < 10; i++) - scen_freeAnim(i); + _vm->_scenery->freeAnim(i); for (i = 0; i < 10; i++) - scen_freeStatic(i); + _vm->_scenery->freeStatic(i); } -void mult_initAll(void) { +void Mult::initAll(void) { int16 i; - mult_objects = 0; - anim_underAnimSurf = 0; - mult_renderData = 0; + objects = 0; + _vm->_anim->_animSurf = 0; + renderData = 0; for (i = 0; i < 10; i++) - scen_animPictCount[i] = 0; + _vm->_scenery->animPictCount[i] = 0; for (i = 0; i < 20; i++) { - scen_spriteRefs[i] = 0; - scen_spriteResId[i] = -1; + _vm->_scenery->spriteRefs[i] = 0; + _vm->_scenery->spriteResId[i] = -1; } for (i = 0; i < 10; i++) - scen_staticPictCount[i] = -1; + _vm->_scenery->staticPictCount[i] = -1; - scen_curStaticLayer = -1; - scen_curStatic = -1; + _vm->_scenery->curStaticLayer = -1; + _vm->_scenery->curStatic = -1; } -void mult_playSound(Snd_SoundDesc * soundDesc, int16 repCount, int16 freq, +void Mult::playSound(Snd::SoundDesc * soundDesc, int16 repCount, int16 freq, int16 channel) { - snd_playSample(soundDesc, repCount, freq); + _vm->_snd->playSample(soundDesc, repCount, freq); } -char mult_drawStatics(char stop) { - if (mult_staticKeys[mult_staticKeysCount - 1].frame > mult_frame) +char Mult::drawStatics(char stop) { + if (staticKeys[staticKeysCount - 1].frame > frame) stop = 0; - for (mult_counter = 0; mult_counter < mult_staticKeysCount; - mult_counter++) { - if (mult_staticKeys[mult_counter].frame != mult_frame - || mult_staticKeys[mult_counter].layer == -1) + for (counter = 0; counter < staticKeysCount; + counter++) { + if (staticKeys[counter].frame != frame + || staticKeys[counter].layer == -1) continue; - for (scen_curStatic = 0, scen_curStaticLayer = mult_staticKeys[mult_counter].layer; - scen_curStaticLayer >= scen_statics[mult_staticIndices[scen_curStatic]].layersCount; - scen_curStatic++) { - scen_curStaticLayer -= - scen_statics[mult_staticIndices[scen_curStatic]].layersCount; + for (_vm->_scenery->curStatic = 0, _vm->_scenery->curStaticLayer = staticKeys[counter].layer; + _vm->_scenery->curStaticLayer >= _vm->_scenery->statics[staticIndices[_vm->_scenery->curStatic]].layersCount; + _vm->_scenery->curStatic++) { + _vm->_scenery->curStaticLayer -= + _vm->_scenery->statics[staticIndices[_vm->_scenery->curStatic]].layersCount; } - scen_curStatic = mult_staticIndices[scen_curStatic]; - scen_renderStatic(scen_curStatic, scen_curStaticLayer); - vid_drawSprite(draw_backSurface, anim_underAnimSurf, + _vm->_scenery->curStatic = staticIndices[_vm->_scenery->curStatic]; + _vm->_scenery->renderStatic(_vm->_scenery->curStatic, _vm->_scenery->curStaticLayer); + _vm->_video->drawSprite(_vm->_draw->backSurface, _vm->_anim->_animSurf, 0, 0, 319, 199, 0, 0, 0); } return stop; } -void mult_drawAnims(void) { +void Mult::drawAnims(void) { Mult_AnimKey *key; Mult_Object *animObj; int16 i; int16 count; - for (mult_index = 0; mult_index < 4; mult_index++) { - for (mult_counter = 0; mult_counter < mult_animKeysCount[mult_index]; mult_counter++) { - key = &mult_animKeys[mult_index][mult_counter]; - animObj = &mult_objects[mult_index]; - if (key->frame != mult_frame) + for (index = 0; index < 4; index++) { + for (counter = 0; counter < animKeysCount[index]; counter++) { + key = &animKeys[index][counter]; + animObj = &objects[index]; + if (key->frame != frame) continue; if (key->layer != -1) { @@ -598,15 +610,15 @@ void mult_drawAnims(void) { animObj->tick = 0; animObj->pAnimData->layer = key->layer; - count = scen_animations[mult_animIndices[0]].layersCount; + count = _vm->_scenery->animations[animIndices[0]].layersCount; i = 0; while (animObj->pAnimData->layer >= count) { animObj->pAnimData->layer -= count; i++; - count = scen_animations[mult_animIndices[i]].layersCount; + count = _vm->_scenery->animations[animIndices[i]].layersCount; } - animObj->pAnimData->animation = mult_animIndices[i]; + animObj->pAnimData->animation = animIndices[i]; } else { animObj->pAnimData->isStatic = 1; } @@ -614,255 +626,255 @@ void mult_drawAnims(void) { } } -void mult_drawText(char *pStop, char *pStopNoClear) { +void Mult::drawText(char *pStop, char *pStopNoClear) { char *savedIP; int16 cmd; - for (mult_index = 0; mult_index < mult_textKeysCount; mult_index++) { - if (mult_textKeys[mult_index].frame != mult_frame) + for (index = 0; index < textKeysCount; index++) { + if (textKeys[index].frame != frame) continue; - cmd = mult_textKeys[mult_index].cmd; + cmd = textKeys[index].cmd; if (cmd == 0) { *pStop = 0; } else if (cmd == 1) { *pStopNoClear = 1; - mult_frameStart = 0; + frameStart = 0; } else if (cmd == 3) { *pStop = 0; - savedIP = inter_execPtr; - inter_execPtr = (char *)(&mult_textKeys[mult_index].index); - inter_execPtr = savedIP; + savedIP = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr = (char *)(&textKeys[index].index); + _vm->_global->inter_execPtr = savedIP; } } } -char mult_prepPalAnim(char stop) { - mult_palKeyIndex = -1; +char Mult::prepPalAnim(char stop) { + palKeyIndex = -1; do { - mult_palKeyIndex++; - if (mult_palKeyIndex >= mult_palKeysCount) + palKeyIndex++; + if (palKeyIndex >= palKeysCount) return stop; - } while (mult_palKeys[mult_palKeyIndex].frame != mult_frame); + } while (palKeys[palKeyIndex].frame != frame); - if (mult_palKeys[mult_palKeyIndex].cmd == -1) { + if (palKeys[palKeyIndex].cmd == -1) { stop = 0; - mult_doPalSubst = 0; - pPaletteDesc->vgaPal = mult_oldPalette; + doPalSubst = 0; + _vm->_global->pPaletteDesc->vgaPal = oldPalette; - memcpy((char *)mult_palAnimPalette, (char *)pPaletteDesc->vgaPal, 768); + memcpy((char *)palAnimPalette, (char *)_vm->_global->pPaletteDesc->vgaPal, 768); - vid_setFullPalette(pPaletteDesc); + _vm->_video->setFullPalette(_vm->_global->pPaletteDesc); } else { stop = 0; - mult_doPalSubst = 1; - mult_palAnimKey = mult_palKeyIndex; + doPalSubst = 1; + palAnimKey = palKeyIndex; - mult_palAnimIndices[0] = 0; - mult_palAnimIndices[1] = 0; - mult_palAnimIndices[2] = 0; - mult_palAnimIndices[3] = 0; + palAnimIndices[0] = 0; + palAnimIndices[1] = 0; + palAnimIndices[2] = 0; + palAnimIndices[3] = 0; - pPaletteDesc->vgaPal = mult_palAnimPalette; + _vm->_global->pPaletteDesc->vgaPal = palAnimPalette; } return stop; } -void mult_doPalAnim(void) { +void Mult::doPalAnim(void) { int16 off; int16 off2; - Color *palPtr; + Video::Color *palPtr; Mult_PalKey *palKey; - if (mult_doPalSubst == 0) + if (doPalSubst == 0) return; - for (mult_index = 0; mult_index < 4; mult_index++) { - palKey = &mult_palKeys[mult_palAnimKey]; + for (index = 0; index < 4; index++) { + palKey = &palKeys[palAnimKey]; - if ((mult_frame % palKey->rates[mult_index]) != 0) + if ((frame % palKey->rates[index]) != 0) continue; - mult_palAnimRed[mult_index] = - pPaletteDesc->vgaPal[palKey->subst[0][mult_index] - 1].red; - mult_palAnimGreen[mult_index] = - pPaletteDesc->vgaPal[palKey->subst[0][mult_index] - 1].green; - mult_palAnimBlue[mult_index] = - pPaletteDesc->vgaPal[palKey->subst[0][mult_index] - 1].blue; + palAnimRed[index] = + _vm->_global->pPaletteDesc->vgaPal[palKey->subst[0][index] - 1].red; + palAnimGreen[index] = + _vm->_global->pPaletteDesc->vgaPal[palKey->subst[0][index] - 1].green; + palAnimBlue[index] = + _vm->_global->pPaletteDesc->vgaPal[palKey->subst[0][index] - 1].blue; while (1) { - off = palKey->subst[(mult_palAnimIndices[mult_index] + 1) % 16][mult_index]; + off = palKey->subst[(palAnimIndices[index] + 1) % 16][index]; if (off == 0) { - off = palKey->subst[mult_palAnimIndices[mult_index]][mult_index] - 1; + off = palKey->subst[palAnimIndices[index]][index] - 1; - pPaletteDesc->vgaPal[off].red = mult_palAnimRed[mult_index]; - pPaletteDesc->vgaPal[off].green = mult_palAnimGreen[mult_index]; - pPaletteDesc->vgaPal[off].blue = mult_palAnimBlue[mult_index]; + _vm->_global->pPaletteDesc->vgaPal[off].red = palAnimRed[index]; + _vm->_global->pPaletteDesc->vgaPal[off].green = palAnimGreen[index]; + _vm->_global->pPaletteDesc->vgaPal[off].blue = palAnimBlue[index]; } else { - off = palKey->subst[(mult_palAnimIndices[mult_index] + 1) % 16][mult_index] - 1; - off2 = palKey->subst[mult_palAnimIndices[mult_index]][mult_index] - 1; + off = palKey->subst[(palAnimIndices[index] + 1) % 16][index] - 1; + off2 = palKey->subst[palAnimIndices[index]][index] - 1; - pPaletteDesc->vgaPal[off2].red = pPaletteDesc->vgaPal[off].red; - pPaletteDesc->vgaPal[off2].green = pPaletteDesc->vgaPal[off].green; - pPaletteDesc->vgaPal[off2].blue = pPaletteDesc->vgaPal[off].blue; + _vm->_global->pPaletteDesc->vgaPal[off2].red = _vm->_global->pPaletteDesc->vgaPal[off].red; + _vm->_global->pPaletteDesc->vgaPal[off2].green = _vm->_global->pPaletteDesc->vgaPal[off].green; + _vm->_global->pPaletteDesc->vgaPal[off2].blue = _vm->_global->pPaletteDesc->vgaPal[off].blue; } - mult_palAnimIndices[mult_index] = (mult_palAnimIndices[mult_index] + 1) % 16; + palAnimIndices[index] = (palAnimIndices[index] + 1) % 16; - off = palKey->subst[mult_palAnimIndices[mult_index]][mult_index]; + off = palKey->subst[palAnimIndices[index]][index]; if (off == 0) { - mult_palAnimIndices[mult_index] = 0; - off = palKey->subst[0][mult_index] - 1; + palAnimIndices[index] = 0; + off = palKey->subst[0][index] - 1; - mult_palAnimRed[mult_index] = pPaletteDesc->vgaPal[off].red; - mult_palAnimGreen[mult_index] = pPaletteDesc->vgaPal[off].green; - mult_palAnimBlue[mult_index] = pPaletteDesc->vgaPal[off].blue; + palAnimRed[index] = _vm->_global->pPaletteDesc->vgaPal[off].red; + palAnimGreen[index] = _vm->_global->pPaletteDesc->vgaPal[off].green; + palAnimBlue[index] = _vm->_global->pPaletteDesc->vgaPal[off].blue; } - if (mult_palAnimIndices[mult_index] == 0) + if (palAnimIndices[index] == 0) break; } } - if (colorCount == 256) { - vid_waitRetrace(videoMode); + if (_vm->_global->colorCount == 256) { + _vm->_video->waitRetrace(_vm->_global->videoMode); - palPtr = pPaletteDesc->vgaPal; - for (mult_counter = 0; mult_counter < 16; mult_counter++) { - vid_setPalElem(mult_counter, palPtr->red, palPtr->green, palPtr->blue, 0, 0x13); + palPtr = _vm->_global->pPaletteDesc->vgaPal; + for (counter = 0; counter < 16; counter++) { + _vm->_video->setPalElem(counter, palPtr->red, palPtr->green, palPtr->blue, 0, 0x13); palPtr++; } - palPtr = pPaletteDesc->vgaPal; - for (mult_counter = 0; mult_counter < 16; mult_counter++) { - redPalette[mult_counter] = palPtr->red; - greenPalette[mult_counter] = palPtr->green; - bluePalette[mult_counter] = palPtr->blue; + palPtr = _vm->_global->pPaletteDesc->vgaPal; + for (counter = 0; counter < 16; counter++) { + _vm->_global->redPalette[counter] = palPtr->red; + _vm->_global->greenPalette[counter] = palPtr->green; + _vm->_global->bluePalette[counter] = palPtr->blue; palPtr++; } } else { - vid_setFullPalette(pPaletteDesc); + _vm->_video->setFullPalette(_vm->_global->pPaletteDesc); } } -char mult_doFadeAnim(char stop) { +char Mult::doFadeAnim(char stop) { Mult_PalFadeKey *fadeKey; - for (mult_index = 0; mult_index < mult_palFadeKeysCount; mult_index++) { - fadeKey = &mult_palFadeKeys[mult_index]; + for (index = 0; index < palFadeKeysCount; index++) { + fadeKey = &palFadeKeys[index]; - if (fadeKey->frame != mult_frame) + if (fadeKey->frame != frame) continue; stop = 0; if ((fadeKey->flag & 1) == 0) { if (fadeKey->fade == 0) { - pPaletteDesc->vgaPal = mult_fadePal[fadeKey->palIndex]; - vid_setFullPalette(pPaletteDesc); + _vm->_global->pPaletteDesc->vgaPal = fadePal[fadeKey->palIndex]; + _vm->_video->setFullPalette(_vm->_global->pPaletteDesc); } else { - pPaletteDesc->vgaPal = mult_fadePal[fadeKey->palIndex]; - pal_fade(pPaletteDesc, fadeKey->fade, 0); + _vm->_global->pPaletteDesc->vgaPal = fadePal[fadeKey->palIndex]; + _vm->_palanim->fade(_vm->_global->pPaletteDesc, fadeKey->fade, 0); } } else { - pPaletteDesc->vgaPal = mult_fadePal[fadeKey->palIndex]; - pal_fade(pPaletteDesc, fadeKey->fade, -1); + _vm->_global->pPaletteDesc->vgaPal = fadePal[fadeKey->palIndex]; + _vm->_palanim->fade(_vm->_global->pPaletteDesc, fadeKey->fade, -1); - mult_palFadingRed = (fadeKey->flag >> 1) & 1; - mult_palFadingGreen = (fadeKey->flag >> 2) & 1; - mult_palFadingBlue = (fadeKey->flag >> 3) & 1; + palFadingRed = (fadeKey->flag >> 1) & 1; + palFadingGreen = (fadeKey->flag >> 2) & 1; + palFadingBlue = (fadeKey->flag >> 3) & 1; } } - if (mult_palFadingRed) { - mult_palFadingRed = !pal_fadeStep(1); + if (palFadingRed) { + palFadingRed = !_vm->_palanim->fadeStep(1); stop = 0; } - if (mult_palFadingGreen) { - mult_palFadingGreen = !pal_fadeStep(2); + if (palFadingGreen) { + palFadingGreen = !_vm->_palanim->fadeStep(2); stop = 0; } - if (mult_palFadingBlue) { - mult_palFadingBlue = !pal_fadeStep(3); + if (palFadingBlue) { + palFadingBlue = !_vm->_palanim->fadeStep(3); stop = 0; } return stop; } -char mult_doSoundAnim(char stop) { +char Mult::doSoundAnim(char stop) { Mult_SndKey *sndKey; - for (mult_index = 0; mult_index < mult_sndKeysCount; mult_index++) { - sndKey = &mult_sndKeys[mult_index]; - if (sndKey->frame != mult_frame) + for (index = 0; index < sndKeysCount; index++) { + sndKey = &sndKeys[index]; + if (sndKey->frame != frame) continue; if (sndKey->cmd != -1) { if (sndKey->cmd == 1) { - snd_stopSound(0); + _vm->_snd->stopSound(0); stop = 0; - mult_playSound(game_soundSamples[sndKey->soundIndex], sndKey->repCount, + playSound(_vm->_game->soundSamples[sndKey->soundIndex], sndKey->repCount, sndKey->freq, sndKey->channel); } else if (sndKey->cmd == 4) { - snd_stopSound(0); + _vm->_snd->stopSound(0); stop = 0; - mult_playSound(game_soundSamples[sndKey->soundIndex], sndKey->repCount, + playSound(_vm->_game->soundSamples[sndKey->soundIndex], sndKey->repCount, sndKey->freq, sndKey->channel); } } else { - if (snd_playingSound) - snd_stopSound(sndKey->channel); + if (_vm->_snd->playingSound) + _vm->_snd->stopSound(sndKey->channel); } } return stop; } -void mult_playMult(int16 startFrame, int16 endFrame, char checkEscape, +void Mult::playMult(int16 startFrame, int16 endFrame, char checkEscape, char handleMouse) { char stopNoClear; char stop; Mult_Object *multObj; Mult_AnimData *animData; - if (mult_multData == 0) + if (multData == 0) return; stopNoClear = 0; - mult_frame = startFrame; + frame = startFrame; if (endFrame == -1) endFrame = 32767; - if (mult_frame == -1) { - mult_doPalSubst = 0; - mult_palFadingRed = 0; - mult_palFadingGreen = 0; - mult_palFadingBlue = 0; + if (frame == -1) { + doPalSubst = 0; + palFadingRed = 0; + palFadingGreen = 0; + palFadingBlue = 0; - mult_oldPalette = pPaletteDesc->vgaPal; - memcpy((char *)mult_palAnimPalette, (char *)pPaletteDesc->vgaPal, 768); + oldPalette = _vm->_global->pPaletteDesc->vgaPal; + memcpy((char *)palAnimPalette, (char *)_vm->_global->pPaletteDesc->vgaPal, 768); - if (anim_underAnimSurf == 0) { - util_setFrameRate(mult_frameRate); - anim_animAreaTop = 0; - anim_animAreaLeft = 0; - anim_animAreaWidth = 320; - anim_animAreaHeight = 200; - mult_objCount = 4; + if (_vm->_anim->_animSurf == 0) { + _vm->_util->setFrameRate(frameRate); + _vm->_anim->_areaTop = 0; + _vm->_anim->_areaLeft = 0; + _vm->_anim->_areaWidth = 320; + _vm->_anim->_areaHeight = 200; + objCount = 4; - mult_objects = (Mult_Object *)malloc(sizeof(Mult_Object) * mult_objCount); - mult_renderData = (int16 *)malloc(sizeof(int16) * 9 * mult_objCount); + objects = (Mult_Object *)malloc(sizeof(Mult_Object) * objCount); + renderData = (int16 *)malloc(sizeof(int16) * 9 * objCount); - mult_animArrayX = (int32 *)malloc(sizeof(int32) * mult_objCount); - mult_animArrayY = (int32 *)malloc(sizeof(int32) * mult_objCount); + animArrayX = (int32 *)malloc(sizeof(int32) * objCount); + animArrayY = (int32 *)malloc(sizeof(int32) * objCount); - mult_animArrayData = (Mult_AnimData *)malloc(sizeof(Mult_AnimData) * mult_objCount); + animArrayData = (Mult_AnimData *)malloc(sizeof(Mult_AnimData) * objCount); - for (mult_counter = 0; mult_counter < mult_objCount; mult_counter++) { - multObj = &mult_objects[mult_counter]; + for (counter = 0; counter < objCount; counter++) { + multObj = &objects[counter]; - multObj->pPosX = (int32 *)&mult_animArrayX[mult_counter]; - multObj->pPosY = (int32 *)&mult_animArrayY[mult_counter]; + multObj->pPosX = (int32 *)&animArrayX[counter]; + multObj->pPosY = (int32 *)&animArrayY[counter]; - multObj->pAnimData = &mult_animArrayData[mult_counter]; + multObj->pAnimData = &animArrayData[counter]; animData = multObj->pAnimData; animData->isStatic = 1; @@ -874,328 +886,328 @@ void mult_playMult(int16 startFrame, int16 endFrame, char checkEscape, multObj->lastBottom = -1; } - anim_underAnimSurf = - vid_initSurfDesc(videoMode, 320, 200, 0); - draw_spritesArray[22] = anim_underAnimSurf; + _vm->_anim->_animSurf = + _vm->_video->initSurfDesc(_vm->_global->videoMode, 320, 200, 0); + _vm->_draw->spritesArray[22] = _vm->_anim->_animSurf; - vid_drawSprite(draw_backSurface, anim_underAnimSurf, + _vm->_video->drawSprite(_vm->_draw->backSurface, _vm->_anim->_animSurf, 0, 0, 319, 199, 0, 0, 0); - mult_animDataAllocated = 1; + animDataAllocated = 1; } else - mult_animDataAllocated = 0; - mult_frame = 0; + animDataAllocated = 0; + frame = 0; } do { stop = 1; if (VAR(58) == 0) { - stop = mult_drawStatics(stop); - mult_drawAnims(); + stop = drawStatics(stop); + drawAnims(); } - mult_animate(); + animate(); if (handleMouse) { - draw_animateCursor(-1); + _vm->_draw->animateCursor(-1); } else { - draw_blitInvalidated(); + _vm->_draw->blitInvalidated(); } if (VAR(58) == 0) { - mult_drawText(&stop, &stopNoClear); + drawText(&stop, &stopNoClear); } - stop = mult_prepPalAnim(stop); - mult_doPalAnim(); + stop = prepPalAnim(stop); + doPalAnim(); - stop = mult_doFadeAnim(stop); - stop = mult_doSoundAnim(stop); + stop = doFadeAnim(stop); + stop = doSoundAnim(stop); - if (mult_frame >= endFrame) + if (frame >= endFrame) stopNoClear = 1; - if (snd_playingSound) + if (_vm->_snd->playingSound) stop = 0; - util_processInput(); - if (checkEscape && util_checkKey() == 0x11b) // Esc + _vm->_util->processInput(); + if (checkEscape && _vm->_util->checkKey() == 0x11b) // Esc stop = 1; - mult_frame++; - util_waitEndFrame(); + frame++; + _vm->_util->waitEndFrame(); } while (stop == 0 && stopNoClear == 0); if (stopNoClear == 0) { - if (mult_animDataAllocated) { - free(mult_objects); - mult_objects = 0; + if (animDataAllocated) { + free(objects); + objects = 0; - free(mult_renderData); - mult_renderData = 0; + free(renderData); + renderData = 0; - free(mult_animArrayX); - mult_animArrayX = 0; + free(animArrayX); + animArrayX = 0; - free(mult_animArrayY); - mult_animArrayY = 0; + free(animArrayY); + animArrayY = 0; - free(mult_animArrayData); - mult_animArrayData = 0; + free(animArrayData); + animArrayData = 0; - if (anim_underAnimSurf) - vid_freeSurfDesc(anim_underAnimSurf); - anim_underAnimSurf = 0; + if (_vm->_anim->_animSurf) + _vm->_video->freeSurfDesc(_vm->_anim->_animSurf); + _vm->_anim->_animSurf = 0; - mult_animDataAllocated = 0; + animDataAllocated = 0; } - if (snd_playingSound != 0) - snd_stopSound(10); + if (_vm->_snd->playingSound != 0) + _vm->_snd->stopSound(10); WRITE_VAR(57, (uint32)-1); } else { - WRITE_VAR(57, mult_frame - 1 - mult_frameStart); + WRITE_VAR(57, frame - 1 - frameStart); } } -void mult_zeroMultData(void) { - mult_multData = 0; +void Mult::zeroMultData(void) { + multData = 0; } -void mult_loadMult(int16 resId) { +void Mult::loadMult(int16 resId) { char animCount; char staticCount; int16 palIndex; int16 i, j; - mult_sndSlotsCount = 0; - mult_frameStart = 0; - mult_multData = game_loadExtData(resId, 0, 0); - mult_dataPtr = mult_multData; + sndSlotsCount = 0; + frameStart = 0; + multData = _vm->_game->loadExtData(resId, 0, 0); + dataPtr = multData; - staticCount = mult_dataPtr[0]; - animCount = mult_dataPtr[1]; - mult_dataPtr += 2; + staticCount = dataPtr[0]; + animCount = dataPtr[1]; + dataPtr += 2; staticCount++; animCount++; - for (i = 0; i < staticCount; i++, mult_dataPtr += 14) { - mult_staticIndices[i] = scen_loadStatic(1); + for (i = 0; i < staticCount; i++, dataPtr += 14) { + staticIndices[i] = _vm->_scenery->loadStatic(1); - if (mult_staticIndices[i] >= 100) { - mult_staticIndices[i] -= 100; - mult_staticLoaded[i] = 1; + if (staticIndices[i] >= 100) { + staticIndices[i] -= 100; + staticLoaded[i] = 1; } else { - mult_staticLoaded[i] = 0; + staticLoaded[i] = 0; } } - for (i = 0; i < animCount; i++, mult_dataPtr += 14) { - mult_animIndices[i] = scen_loadAnim(1); + for (i = 0; i < animCount; i++, dataPtr += 14) { + animIndices[i] = _vm->_scenery->loadAnim(1); - if (mult_animIndices[i] >= 100) { - mult_animIndices[i] -= 100; - mult_animLoaded[i] = 1; + if (animIndices[i] >= 100) { + animIndices[i] -= 100; + animLoaded[i] = 1; } else { - mult_animLoaded[i] = 0; + animLoaded[i] = 0; } } - mult_frameRate = READ_LE_UINT16(mult_dataPtr); - mult_dataPtr += 2; + frameRate = READ_LE_UINT16(dataPtr); + dataPtr += 2; - mult_staticKeysCount = READ_LE_UINT16(mult_dataPtr); - mult_dataPtr += 2; + staticKeysCount = READ_LE_UINT16(dataPtr); + dataPtr += 2; - mult_staticKeys = (Mult_StaticKey *)malloc(sizeof(Mult_StaticKey) * - mult_staticKeysCount); - for (i = 0; i < mult_staticKeysCount; i++, mult_dataPtr += 4) { - mult_staticKeys[i].frame = (int16)READ_LE_UINT16(mult_dataPtr); - mult_staticKeys[i].layer = (int16)READ_LE_UINT16(mult_dataPtr + 2); + staticKeys = (Mult_StaticKey *)malloc(sizeof(Mult_StaticKey) * + staticKeysCount); + for (i = 0; i < staticKeysCount; i++, dataPtr += 4) { + staticKeys[i].frame = (int16)READ_LE_UINT16(dataPtr); + staticKeys[i].layer = (int16)READ_LE_UINT16(dataPtr + 2); } for (j = 0; j < 4; j++) { - mult_animKeysCount[j] = READ_LE_UINT16(mult_dataPtr); - mult_dataPtr += 2; - - mult_animKeys[j] = (Mult_AnimKey *) malloc(sizeof(Mult_AnimKey) * mult_animKeysCount[j]); - for (i = 0; i < mult_animKeysCount[j]; i++, mult_dataPtr += 10) { - mult_animKeys[j][i].frame = (int16)READ_LE_UINT16(mult_dataPtr); - mult_animKeys[j][i].layer = (int16)READ_LE_UINT16(mult_dataPtr + 2); - mult_animKeys[j][i].posX = (int16)READ_LE_UINT16(mult_dataPtr + 4); - mult_animKeys[j][i].posY = (int16)READ_LE_UINT16(mult_dataPtr + 6); - mult_animKeys[j][i].order = (int16)READ_LE_UINT16(mult_dataPtr + 8); + animKeysCount[j] = READ_LE_UINT16(dataPtr); + dataPtr += 2; + + animKeys[j] = (Mult_AnimKey *) malloc(sizeof(Mult_AnimKey) * animKeysCount[j]); + for (i = 0; i < animKeysCount[j]; i++, dataPtr += 10) { + animKeys[j][i].frame = (int16)READ_LE_UINT16(dataPtr); + animKeys[j][i].layer = (int16)READ_LE_UINT16(dataPtr + 2); + animKeys[j][i].posX = (int16)READ_LE_UINT16(dataPtr + 4); + animKeys[j][i].posY = (int16)READ_LE_UINT16(dataPtr + 6); + animKeys[j][i].order = (int16)READ_LE_UINT16(dataPtr + 8); } } for (palIndex = 0; palIndex < 5; palIndex++) { for (i = 0; i < 16; i++) { - mult_fadePal[palIndex][i].red = mult_dataPtr[0]; - mult_fadePal[palIndex][i].green = mult_dataPtr[1]; - mult_fadePal[palIndex][i].blue = mult_dataPtr[2]; - mult_dataPtr += 3; + fadePal[palIndex][i].red = dataPtr[0]; + fadePal[palIndex][i].green = dataPtr[1]; + fadePal[palIndex][i].blue = dataPtr[2]; + dataPtr += 3; } } - mult_palFadeKeysCount = READ_LE_UINT16(mult_dataPtr); - mult_dataPtr += 2; - mult_palFadeKeys = (Mult_PalFadeKey *)malloc(sizeof(Mult_PalFadeKey) * mult_palFadeKeysCount); + palFadeKeysCount = READ_LE_UINT16(dataPtr); + dataPtr += 2; + palFadeKeys = (Mult_PalFadeKey *)malloc(sizeof(Mult_PalFadeKey) * palFadeKeysCount); - for (i = 0; i < mult_palFadeKeysCount; i++, mult_dataPtr += 7) { - mult_palFadeKeys[i].frame = (int16)READ_LE_UINT16(mult_dataPtr); - mult_palFadeKeys[i].fade = (int16)READ_LE_UINT16(mult_dataPtr + 2); - mult_palFadeKeys[i].palIndex = (int16)READ_LE_UINT16(mult_dataPtr + 4); - mult_palFadeKeys[i].flag = *(mult_dataPtr + 6); + for (i = 0; i < palFadeKeysCount; i++, dataPtr += 7) { + palFadeKeys[i].frame = (int16)READ_LE_UINT16(dataPtr); + palFadeKeys[i].fade = (int16)READ_LE_UINT16(dataPtr + 2); + palFadeKeys[i].palIndex = (int16)READ_LE_UINT16(dataPtr + 4); + palFadeKeys[i].flag = *(dataPtr + 6); } - mult_palKeysCount = READ_LE_UINT16(mult_dataPtr); - mult_dataPtr += 2; - - mult_palKeys = (Mult_PalKey *)malloc(sizeof(Mult_PalKey) * mult_palKeysCount); - for (i = 0; i < mult_palKeysCount; i++, mult_dataPtr += 80) { - mult_palKeys[i].frame = (int16)READ_LE_UINT16(mult_dataPtr); - mult_palKeys[i].cmd = (int16)READ_LE_UINT16(mult_dataPtr + 2); - mult_palKeys[i].rates[0] = (int16)READ_LE_UINT16(mult_dataPtr + 4); - mult_palKeys[i].rates[1] = (int16)READ_LE_UINT16(mult_dataPtr + 6); - mult_palKeys[i].rates[2] = (int16)READ_LE_UINT16(mult_dataPtr + 8); - mult_palKeys[i].rates[3] = (int16)READ_LE_UINT16(mult_dataPtr + 10); - mult_palKeys[i].unknown0 = (int16)READ_LE_UINT16(mult_dataPtr + 12); - mult_palKeys[i].unknown1 = (int16)READ_LE_UINT16(mult_dataPtr + 14); - memcpy(mult_palKeys[i].subst, mult_dataPtr + 16, 64); + palKeysCount = READ_LE_UINT16(dataPtr); + dataPtr += 2; + + palKeys = (Mult_PalKey *)malloc(sizeof(Mult_PalKey) * palKeysCount); + for (i = 0; i < palKeysCount; i++, dataPtr += 80) { + palKeys[i].frame = (int16)READ_LE_UINT16(dataPtr); + palKeys[i].cmd = (int16)READ_LE_UINT16(dataPtr + 2); + palKeys[i].rates[0] = (int16)READ_LE_UINT16(dataPtr + 4); + palKeys[i].rates[1] = (int16)READ_LE_UINT16(dataPtr + 6); + palKeys[i].rates[2] = (int16)READ_LE_UINT16(dataPtr + 8); + palKeys[i].rates[3] = (int16)READ_LE_UINT16(dataPtr + 10); + palKeys[i].unknown0 = (int16)READ_LE_UINT16(dataPtr + 12); + palKeys[i].unknown1 = (int16)READ_LE_UINT16(dataPtr + 14); + memcpy(palKeys[i].subst, dataPtr + 16, 64); } - mult_textKeysCount = READ_LE_UINT16(mult_dataPtr); - mult_dataPtr += 2; - mult_textKeys = (Mult_TextKey *) malloc(sizeof(Mult_TextKey) * mult_textKeysCount); + textKeysCount = READ_LE_UINT16(dataPtr); + dataPtr += 2; + textKeys = (Mult_TextKey *) malloc(sizeof(Mult_TextKey) * textKeysCount); - for (i = 0; i < mult_textKeysCount; i++, mult_dataPtr += 28) { - mult_textKeys[i].frame = (int16)READ_LE_UINT16(mult_dataPtr); - mult_textKeys[i].cmd = (int16)READ_LE_UINT16(mult_dataPtr + 2); + for (i = 0; i < textKeysCount; i++, dataPtr += 28) { + textKeys[i].frame = (int16)READ_LE_UINT16(dataPtr); + textKeys[i].cmd = (int16)READ_LE_UINT16(dataPtr + 2); for (int k = 0; k < 9; ++k) - mult_textKeys[i].unknown0[k] = (int16)READ_LE_UINT16(mult_dataPtr + 4 + (k * 2)); - mult_textKeys[i].index = (int16)READ_LE_UINT16(mult_dataPtr + 22); - mult_textKeys[i].unknown1[0] = (int16)READ_LE_UINT16(mult_dataPtr + 24); - mult_textKeys[i].unknown1[1] = (int16)READ_LE_UINT16(mult_dataPtr + 26); + textKeys[i].unknown0[k] = (int16)READ_LE_UINT16(dataPtr + 4 + (k * 2)); + textKeys[i].index = (int16)READ_LE_UINT16(dataPtr + 22); + textKeys[i].unknown1[0] = (int16)READ_LE_UINT16(dataPtr + 24); + textKeys[i].unknown1[1] = (int16)READ_LE_UINT16(dataPtr + 26); } - mult_sndKeysCount = READ_LE_UINT16(mult_dataPtr); - mult_dataPtr += 2; - - mult_sndKeys = (Mult_SndKey *)malloc(sizeof(Mult_SndKey) * mult_sndKeysCount); - for (i = 0; i < mult_sndKeysCount; i++) { - mult_sndKeys[i].frame = (int16)READ_LE_UINT16(mult_dataPtr); - mult_sndKeys[i].cmd = (int16)READ_LE_UINT16(mult_dataPtr + 2); - mult_sndKeys[i].freq = (int16)READ_LE_UINT16(mult_dataPtr + 4); - mult_sndKeys[i].channel = (int16)READ_LE_UINT16(mult_dataPtr + 6); - mult_sndKeys[i].repCount = (int16)READ_LE_UINT16(mult_dataPtr + 8); - mult_sndKeys[i].resId = (int16)READ_LE_UINT16(mult_dataPtr + 10); - mult_sndKeys[i].soundIndex = (int16)READ_LE_UINT16(mult_dataPtr + 12); - - mult_sndKeys[i].soundIndex = -1; - mult_sndKeys[i].resId = -1; - mult_dataPtr += 36; - switch (mult_sndKeys[i].cmd) { + sndKeysCount = READ_LE_UINT16(dataPtr); + dataPtr += 2; + + sndKeys = (Mult_SndKey *)malloc(sizeof(Mult_SndKey) * sndKeysCount); + for (i = 0; i < sndKeysCount; i++) { + sndKeys[i].frame = (int16)READ_LE_UINT16(dataPtr); + sndKeys[i].cmd = (int16)READ_LE_UINT16(dataPtr + 2); + sndKeys[i].freq = (int16)READ_LE_UINT16(dataPtr + 4); + sndKeys[i].channel = (int16)READ_LE_UINT16(dataPtr + 6); + sndKeys[i].repCount = (int16)READ_LE_UINT16(dataPtr + 8); + sndKeys[i].resId = (int16)READ_LE_UINT16(dataPtr + 10); + sndKeys[i].soundIndex = (int16)READ_LE_UINT16(dataPtr + 12); + + sndKeys[i].soundIndex = -1; + sndKeys[i].resId = -1; + dataPtr += 36; + switch (sndKeys[i].cmd) { case 1: case 4: - mult_sndKeys[i].resId = READ_LE_UINT16(inter_execPtr); + sndKeys[i].resId = READ_LE_UINT16(_vm->_global->inter_execPtr); for (j = 0; j < i; j++) { - if (mult_sndKeys[i].resId == - mult_sndKeys[j].resId) { - mult_sndKeys[i].soundIndex = - mult_sndKeys[j].soundIndex; - inter_execPtr += 2; + if (sndKeys[i].resId == + sndKeys[j].resId) { + sndKeys[i].soundIndex = + sndKeys[j].soundIndex; + _vm->_global->inter_execPtr += 2; break; } } if (i == j) { - game_interLoadSound(19 - mult_sndSlotsCount); - mult_sndKeys[i].soundIndex = - 19 - mult_sndSlotsCount; - mult_sndSlotsCount++; + _vm->_game->interLoadSound(19 - sndSlotsCount); + sndKeys[i].soundIndex = + 19 - sndSlotsCount; + sndSlotsCount++; } break; case 3: - inter_execPtr += 6; + _vm->_global->inter_execPtr += 6; break; case 5: - inter_execPtr += mult_sndKeys[i].freq * 2; + _vm->_global->inter_execPtr += sndKeys[i].freq * 2; break; } } } -void mult_freeMultKeys(void) { +void Mult::freeMultKeys(void) { int i; char animCount; char staticCount; - mult_dataPtr = mult_multData; - staticCount = mult_dataPtr[0]; - animCount = mult_dataPtr[1]; + dataPtr = multData; + staticCount = dataPtr[0]; + animCount = dataPtr[1]; - free(mult_dataPtr); + free(dataPtr); staticCount++; animCount++; for (i = 0; i < staticCount; i++) { - if (mult_staticLoaded[i] != 0) - scen_freeStatic(mult_staticIndices[i]); + if (staticLoaded[i] != 0) + _vm->_scenery->freeStatic(staticIndices[i]); } for (i = 0; i < animCount; i++) { - if (mult_animLoaded[i] != 0) - scen_freeAnim(mult_animIndices[i]); + if (animLoaded[i] != 0) + _vm->_scenery->freeAnim(animIndices[i]); } - free(mult_staticKeys); + free(staticKeys); for (i = 0; i < 4; i++) - free(mult_animKeys[i]); + free(animKeys[i]); - free(mult_palFadeKeys); - free(mult_palKeys); - free(mult_textKeys); + free(palFadeKeys); + free(palKeys); + free(textKeys); - for (i = 0; i < mult_sndSlotsCount; i++) { - game_freeSoundSlot(19 - i); + for (i = 0; i < sndSlotsCount; i++) { + _vm->_game->freeSoundSlot(19 - i); } - free(mult_sndKeys); + free(sndKeys); - mult_multData = 0; + multData = 0; - if (mult_animDataAllocated != 0) { - free(mult_objects); - mult_objects = 0; + if (animDataAllocated != 0) { + free(objects); + objects = 0; - free(mult_renderData); - mult_renderData = 0; + free(renderData); + renderData = 0; - free(mult_animArrayX); - mult_animArrayX = 0; + free(animArrayX); + animArrayX = 0; - free(mult_animArrayY); - mult_animArrayY = 0; + free(animArrayY); + animArrayY = 0; - free(mult_animArrayData); - mult_animArrayData = 0; + free(animArrayData); + animArrayData = 0; - if (anim_underAnimSurf) - vid_freeSurfDesc(anim_underAnimSurf); - anim_underAnimSurf = 0; + if (_vm->_anim->_animSurf) + _vm->_video->freeSurfDesc(_vm->_anim->_animSurf); + _vm->_anim->_animSurf = 0; - mult_animDataAllocated = 0; + animDataAllocated = 0; } } -void mult_checkFreeMult(void) { - if (mult_multData != 0) - mult_freeMultKeys(); +void Mult::checkFreeMult(void) { + if (multData != 0) + freeMultKeys(); } } // End of namespace Gob diff --git a/gob/mult.h b/gob/mult.h index 5c584514ac..df66011edc 100644 --- a/gob/mult.h +++ b/gob/mult.h @@ -26,171 +26,182 @@ namespace Gob { +class Mult { +public: #pragma START_PACK_STRUCTS -typedef struct Mult_AnimData { - int8 animation; - int8 layer; - int8 frame; - int8 animType; - int8 order; - int8 isPaused; - int8 isStatic; - int8 maxTick; - int8 unknown; - int8 newLayer; - int8 newAnimation; - byte intersected; - int8 newCycle; -} GCC_PACK Mult_AnimData; - -typedef struct Mult_Object { - int32 *pPosX; - int32 *pPosY; - Mult_AnimData *pAnimData; - int16 tick; - int16 lastLeft; - int16 lastRight; - int16 lastTop; - int16 lastBottom; -} Mult_Object; - -// Mult -typedef struct Mult_StaticKey { - int16 frame; - int16 layer; -} GCC_PACK Mult_StaticKey; + typedef struct Mult_AnimData { + int8 animation; + int8 layer; + int8 frame; + int8 animType; + int8 order; + int8 isPaused; + int8 isStatic; + int8 maxTick; + int8 unknown; + int8 newLayer; + int8 newAnimation; + byte intersected; + int8 newCycle; + } GCC_PACK Mult_AnimData; + + typedef struct Mult_Object { + int32 *pPosX; + int32 *pPosY; + Mult_AnimData *pAnimData; + int16 tick; + int16 lastLeft; + int16 lastRight; + int16 lastTop; + int16 lastBottom; + } Mult_Object; + + // Mult + typedef struct Mult_StaticKey { + int16 frame; + int16 layer; + } GCC_PACK Mult_StaticKey; + + typedef struct Mult_AnimKey { + int16 frame; + int16 layer; + int16 posX; + int16 posY; + int16 order; + } GCC_PACK Mult_AnimKey; + + typedef struct Mult_TextKey { + int16 frame; + int16 cmd; + int16 unknown0[9]; + int16 index; + int16 unknown1[2]; + } GCC_PACK Mult_TextKey; + + typedef struct Mult_PalKey { + int16 frame; + int16 cmd; + int16 rates[4]; + int16 unknown0; + int16 unknown1; + int8 subst[16][4]; + } GCC_PACK Mult_PalKey; + + typedef struct Mult_PalFadeKey { + int16 frame; + int16 fade; + int16 palIndex; + int8 flag; + } GCC_PACK Mult_PalFadeKey; + + typedef struct Mult_SndKey { + int16 frame; + int16 cmd; + int16 freq; + int16 channel; + int16 repCount; + int16 resId; + int16 soundIndex; + } GCC_PACK Mult_SndKey; +#pragma END_PACK_STRUCTS -typedef struct Mult_AnimKey { - int16 frame; - int16 layer; - int16 posX; - int16 posY; - int16 order; -} GCC_PACK Mult_AnimKey; + // Globals -typedef struct Mult_TextKey { - int16 frame; - int16 cmd; - int16 unknown0[9]; - int16 index; - int16 unknown1[2]; -} GCC_PACK Mult_TextKey; + Mult_Object *objects; + int16 *renderData; + int16 objCount; + Video::SurfaceDesc *underAnimSurf; -typedef struct Mult_PalKey { - int16 frame; - int16 cmd; - int16 rates[4]; - int16 unknown0; - int16 unknown1; - int8 subst[16][4]; -} GCC_PACK Mult_PalKey; - -typedef struct Mult_PalFadeKey { + char *multData; int16 frame; - int16 fade; - int16 palIndex; - int8 flag; -} GCC_PACK Mult_PalFadeKey; + char doPalSubst; + int16 counter; + int16 frameRate; -typedef struct Mult_SndKey { - int16 frame; - int16 cmd; - int16 freq; - int16 channel; - int16 repCount; - int16 resId; - int16 soundIndex; -} GCC_PACK Mult_SndKey; -#pragma END_PACK_STRUCTS + int32 *animArrayX; + int32 *animArrayY; + + Mult_AnimData *animArrayData; + + int16 index; -// Globals - -extern Mult_Object *mult_objects; -extern int16 *mult_renderData; -extern int16 mult_objCount; -extern SurfaceDesc *mult_underAnimSurf; - -extern char *mult_multData; -extern int16 mult_frame; -extern char mult_doPalSubst; -extern int16 mult_counter; -extern int16 mult_frameRate; - -extern int32 *mult_animArrayX; -extern int32 *mult_animArrayY; - -extern Mult_AnimData *mult_animArrayData; - -extern int16 mult_index; - -// Static keys -extern int16 mult_staticKeysCount; -extern Mult_StaticKey *mult_staticKeys; -extern int16 mult_staticIndices[10]; - -// Anim keys -extern Mult_AnimKey *mult_animKeys[4]; -extern int16 mult_animKeysCount[4]; -extern int16 mult_animLayer; -extern int16 mult_animIndices[10]; - -// Text keys -extern int16 mult_textKeysCount; -extern Mult_TextKey *mult_textKeys; - -extern int16 mult_frameStart; - -// Palette keys -extern int16 mult_palKeyIndex; -extern int16 mult_palKeysCount; -extern Mult_PalKey *mult_palKeys; -extern Color *mult_oldPalette; -extern Color mult_palAnimPalette[256]; -extern int16 mult_palAnimKey; -extern int16 mult_palAnimIndices[4]; -extern int16 mult_palAnimRed[4]; -extern int16 mult_palAnimGreen[4]; -extern int16 mult_palAnimBlue[4]; - -// Palette fading -extern Mult_PalFadeKey *mult_palFadeKeys; -extern int16 mult_palFadeKeysCount; -extern char mult_palFadingRed; -extern char mult_palFadingGreen; -extern char mult_palFadingBlue; - -extern char mult_animDataAllocated; - -extern char *mult_dataPtr; -extern int16 mult_staticLoaded[10]; -extern int16 mult_animLoaded[10]; -extern int16 mult_sndSlotsCount; - -// Sound keys -extern int16 mult_sndKeysCount; -extern Mult_SndKey *mult_sndKeys; - -void mult_zeroMultData(void); -void mult_loadMult(int16 resId); -void mult_freeMultKeys(void); -void mult_checkFreeMult(void); -void mult_playMult(int16 startFrame, int16 endFrame, char checkEscape, - char handleMouse); -void mult_animate(void); -void mult_interGetObjAnimSize(void); -void mult_interInitMult(void); -void mult_freeMult(void); -void mult_interLoadMult(void); -void mult_freeAll(void); -void mult_initAll(void); -void mult_playSound(Snd_SoundDesc * soundDesc, int16 repCount, int16 freq, - int16 channel); -void mult_playMult(int16 startFrame, int16 endFrame, char checkEscape, - char handleMouse); -void mult_zeroMultData(void); -void mult_loadMult(int16 resId); -void mult_freeMultKeys(void); -void mult_checkFreeMult(void); + // Static keys + int16 staticKeysCount; + Mult_StaticKey *staticKeys; + int16 staticIndices[10]; + + // Anim keys + Mult_AnimKey *animKeys[4]; + int16 animKeysCount[4]; + int16 animLayer; + int16 animIndices[10]; + + // Text keys + int16 textKeysCount; + Mult_TextKey *textKeys; + + int16 frameStart; + + // Palette keys + int16 palKeyIndex; + int16 palKeysCount; + Mult_PalKey *palKeys; + Video::Color *oldPalette; + Video::Color palAnimPalette[256]; + int16 palAnimKey; + int16 palAnimIndices[4]; + int16 palAnimRed[4]; + int16 palAnimGreen[4]; + int16 palAnimBlue[4]; + + // Palette fading + Mult_PalFadeKey *palFadeKeys; + int16 palFadeKeysCount; + char palFadingRed; + char palFadingGreen; + char palFadingBlue; + + char animDataAllocated; + + char *dataPtr; + int16 staticLoaded[10]; + int16 animLoaded[10]; + int16 sndSlotsCount; + + // Sound keys + int16 sndKeysCount; + Mult_SndKey *sndKeys; + + void zeroMultData(void); + void loadMult(int16 resId); + void freeMultKeys(void); + void checkFreeMult(void); + void playMult(int16 startFrame, int16 endFrame, char checkEscape, + char handleMouse); + void animate(void); + void interGetObjAnimSize(void); + void interInitMult(void); + void freeMult(void); + void interLoadMult(void); + void freeAll(void); + void initAll(void); + void playSound(Snd::SoundDesc * soundDesc, int16 repCount, int16 freq, + int16 channel); + + Mult(GobEngine *vm); + +protected: + Video::Color fadePal[5][16]; + GobEngine *_vm; + + char drawStatics(char stop); + void drawAnims(void); + void drawText(char *pStop, char *pStopNoClear); + char prepPalAnim(char stop); + void doPalAnim(void); + char doFadeAnim(char stop); + char doSoundAnim(char stop); +}; } // End of namespace Gob diff --git a/gob/pack.cpp b/gob/pack.cpp index 92563b204b..e2091fa2b3 100644 --- a/gob/pack.cpp +++ b/gob/pack.cpp @@ -24,7 +24,7 @@ namespace Gob { -int32 unpackData(char *sourceBuf, char *destBuf) { +int32 Pack::unpackData(char *sourceBuf, char *destBuf) { uint32 realSize; uint32 counter; uint16 cmd; diff --git a/gob/pack.h b/gob/pack.h index 9cbba5b90b..69c53c9a83 100644 --- a/gob/pack.h +++ b/gob/pack.h @@ -24,8 +24,11 @@ namespace Gob { -int32 asm_unpackData(char *source, char *dest, char *temp); -int32 unpackData(char *source, char *dest); +class Pack { +public: + int32 asm_unpackData(char *source, char *dest, char *temp); + int32 unpackData(char *source, char *dest); +}; } // End of namespace Gob diff --git a/gob/palanim.cpp b/gob/palanim.cpp index ed5a37f274..62b4897c2c 100644 --- a/gob/palanim.cpp +++ b/gob/palanim.cpp @@ -27,74 +27,77 @@ namespace Gob { -int16 pal_fadeValue = 1; - -byte pal_toFadeRed[256]; -byte pal_toFadeGreen[256]; -byte pal_toFadeBlue[256]; +PalAnim::PalAnim(GobEngine *vm) : _vm(vm) { + fadeValue = 1; + for (int i = 0; i < 256; i++) { + toFadeRed[i] = 0; + toFadeGreen[i] = 0; + toFadeBlue[i] = 0; + } +} -char pal_fadeColor(char from, char to) { - if ((int16)from - pal_fadeValue > (int16)to) - return from - pal_fadeValue; - else if ((int16)from + pal_fadeValue < (int16)to) - return from + pal_fadeValue; +char PalAnim::fadeColor(char from, char to) { + if ((int16)from - fadeValue > (int16)to) + return from - fadeValue; + else if ((int16)from + fadeValue < (int16)to) + return from + fadeValue; else return to; } -char pal_fadeStep(int16 oper) { +char PalAnim::fadeStep(int16 oper) { byte newRed; byte newGreen; byte newBlue; char stop; int16 i; - if (colorCount != 256) - error("pal_fadeStep: Only 256 color mode is supported!"); + if (_vm->_global->colorCount != 256) + error("fadeStep: Only 256 color mode is supported!"); if (oper == 0) { stop = 1; - if (setAllPalette) { - if (inVM != 0) - error("pal_fade: inVM != 0 not supported."); + if (_vm->_global->setAllPalette) { + if (_vm->_global->inVM != 0) + error("fade: _vm->_global->inVM != 0 not supported."); for (i = 0; i < 256; i++) { newRed = - pal_fadeColor(redPalette[i], - pal_toFadeRed[i]); + fadeColor(_vm->_global->redPalette[i], + toFadeRed[i]); newGreen = - pal_fadeColor(greenPalette[i], - pal_toFadeGreen[i]); + fadeColor(_vm->_global->greenPalette[i], + toFadeGreen[i]); newBlue = - pal_fadeColor(bluePalette[i], - pal_toFadeBlue[i]); + fadeColor(_vm->_global->bluePalette[i], + toFadeBlue[i]); - if (redPalette[i] != newRed - || greenPalette[i] != newGreen - || bluePalette[i] != newBlue) { + if (_vm->_global->redPalette[i] != newRed + || _vm->_global->greenPalette[i] != newGreen + || _vm->_global->bluePalette[i] != newBlue) { - vid_setPalElem(i, newRed, newGreen, newBlue, 0, 0x13); + _vm->_video->setPalElem(i, newRed, newGreen, newBlue, 0, 0x13); - redPalette[i] = newRed; - greenPalette[i] = newGreen; - bluePalette[i] = newBlue; + _vm->_global->redPalette[i] = newRed; + _vm->_global->greenPalette[i] = newGreen; + _vm->_global->bluePalette[i] = newBlue; stop = 0; } } } else { for (i = 0; i < 16; i++) { - vid_setPalElem(i, - pal_fadeColor(redPalette[i], - pal_toFadeRed[i]), - pal_fadeColor(greenPalette[i], - pal_toFadeGreen[i]), - pal_fadeColor(bluePalette[i], - pal_toFadeBlue[i]), -1, videoMode); - - if (redPalette[i] != pal_toFadeRed[i] || - greenPalette[i] != pal_toFadeGreen[i] || - bluePalette[i] != pal_toFadeBlue[i]) + _vm->_video->setPalElem(i, + fadeColor(_vm->_global->redPalette[i], + toFadeRed[i]), + fadeColor(_vm->_global->greenPalette[i], + toFadeGreen[i]), + fadeColor(_vm->_global->bluePalette[i], + toFadeBlue[i]), -1, _vm->_global->videoMode); + + if (_vm->_global->redPalette[i] != toFadeRed[i] || + _vm->_global->greenPalette[i] != toFadeGreen[i] || + _vm->_global->bluePalette[i] != toFadeBlue[i]) stop = 0; } } @@ -102,36 +105,36 @@ char pal_fadeStep(int16 oper) { } else if (oper == 1) { stop = 1; for (i = 0; i < 16; i++) { - vid_setPalElem(i, - pal_fadeColor(redPalette[i], pal_toFadeRed[i]), - greenPalette[i], bluePalette[i], -1, videoMode); + _vm->_video->setPalElem(i, + fadeColor(_vm->_global->redPalette[i], toFadeRed[i]), + _vm->_global->greenPalette[i], _vm->_global->bluePalette[i], -1, _vm->_global->videoMode); - if (redPalette[i] != pal_toFadeRed[i]) + if (_vm->_global->redPalette[i] != toFadeRed[i]) stop = 0; } return stop; } else if (oper == 2) { stop = 1; for (i = 0; i < 16; i++) { - vid_setPalElem(i, - redPalette[i], - pal_fadeColor(greenPalette[i], pal_toFadeGreen[i]), - bluePalette[i], -1, videoMode); + _vm->_video->setPalElem(i, + _vm->_global->redPalette[i], + fadeColor(_vm->_global->greenPalette[i], toFadeGreen[i]), + _vm->_global->bluePalette[i], -1, _vm->_global->videoMode); - if (greenPalette[i] != pal_toFadeGreen[i]) + if (_vm->_global->greenPalette[i] != toFadeGreen[i]) stop = 0; } return stop; } else if (oper == 3) { stop = 1; for (i = 0; i < 16; i++) { - vid_setPalElem(i, - redPalette[i], - greenPalette[i], - pal_fadeColor(bluePalette[i], pal_toFadeBlue[i]), - -1, videoMode); + _vm->_video->setPalElem(i, + _vm->_global->redPalette[i], + _vm->_global->greenPalette[i], + fadeColor(_vm->_global->bluePalette[i], toFadeBlue[i]), + -1, _vm->_global->videoMode); - if (bluePalette[i] != pal_toFadeBlue[i]) + if (_vm->_global->bluePalette[i] != toFadeBlue[i]) stop = 0; } return stop; @@ -139,95 +142,95 @@ char pal_fadeStep(int16 oper) { return 1; } -void pal_fade(PalDesc *palDesc, int16 fade, int16 allColors) { +void PalAnim::fade(Video::PalDesc *palDesc, int16 fadeV, int16 allColors) { char stop; int16 i; - if (fade < 0) - pal_fadeValue = -fade; + if (fadeV < 0) + fadeValue = -fadeV; else - pal_fadeValue = 2; + fadeValue = 2; - if (colorCount < 256) { + if (_vm->_global->colorCount < 256) { if (palDesc != 0) - vid_setFullPalette(palDesc); + _vm->_video->setFullPalette(palDesc); return; } - if (setAllPalette == 0) { + if (_vm->_global->setAllPalette == 0) { if (palDesc == 0) { for (i = 0; i < 16; i++) { - pal_toFadeRed[i] = 0; - pal_toFadeGreen[i] = 0; - pal_toFadeBlue[i] = 0; + toFadeRed[i] = 0; + toFadeGreen[i] = 0; + toFadeBlue[i] = 0; } } else { for (i = 0; i < 16; i++) { - pal_toFadeRed[i] = palDesc->vgaPal[i].red; - pal_toFadeGreen[i] = palDesc->vgaPal[i].green; - pal_toFadeBlue[i] = palDesc->vgaPal[i].blue; + toFadeRed[i] = palDesc->vgaPal[i].red; + toFadeGreen[i] = palDesc->vgaPal[i].green; + toFadeBlue[i] = palDesc->vgaPal[i].blue; } } } else { - if (inVM != 0) - error("pal_fade: inVM != 0 is not supported"); + if (_vm->_global->inVM != 0) + error("fade: _vm->_global->inVM != 0 is not supported"); if (palDesc == 0) { for (i = 0; i < 256; i++) { - pal_toFadeRed[i] = 0; - pal_toFadeGreen[i] = 0; - pal_toFadeBlue[i] = 0; + toFadeRed[i] = 0; + toFadeGreen[i] = 0; + toFadeBlue[i] = 0; } } else { for (i = 0; i < 256; i++) { - pal_toFadeRed[i] = palDesc->vgaPal[i].red; - pal_toFadeGreen[i] = palDesc->vgaPal[i].green; - pal_toFadeBlue[i] = palDesc->vgaPal[i].blue; + toFadeRed[i] = palDesc->vgaPal[i].red; + toFadeGreen[i] = palDesc->vgaPal[i].green; + toFadeBlue[i] = palDesc->vgaPal[i].blue; } } } if (allColors == 0) { do { - if (tmpPalBuffer == 0) - vid_waitRetrace(videoMode); + if (_vm->_global->tmpPalBuffer == 0) + _vm->_video->waitRetrace(_vm->_global->videoMode); - stop = pal_fadeStep(0); + stop = fadeStep(0); - if (fade > 0) - util_delay(fade); + if (fadeV > 0) + _vm->_util->delay(fadeV); } while (stop == 0); if (palDesc != 0) - vid_setFullPalette(palDesc); + _vm->_video->setFullPalette(palDesc); else - util_clearPalette(); + _vm->_util->clearPalette(); } if (allColors == 1) { do { - vid_waitRetrace(videoMode); - stop = pal_fadeStep(1); + _vm->_video->waitRetrace(_vm->_global->videoMode); + stop = fadeStep(1); } while (stop == 0); do { - vid_waitRetrace(videoMode); - stop = pal_fadeStep(2); + _vm->_video->waitRetrace(_vm->_global->videoMode); + stop = fadeStep(2); } while (stop == 0); do { - vid_waitRetrace(videoMode); - stop = pal_fadeStep(3); + _vm->_video->waitRetrace(_vm->_global->videoMode); + stop = fadeStep(3); } while (stop == 0); if (palDesc != 0) - vid_setFullPalette(palDesc); + _vm->_video->setFullPalette(palDesc); else - util_clearPalette(); + _vm->_util->clearPalette(); } - free(tmpPalBuffer); - tmpPalBuffer = 0; + free(_vm->_global->tmpPalBuffer); + _vm->_global->tmpPalBuffer = 0; } } // End of namespace Gob diff --git a/gob/palanim.h b/gob/palanim.h index 9bc4ff6641..0f2cfcc3c4 100644 --- a/gob/palanim.h +++ b/gob/palanim.h @@ -24,11 +24,22 @@ namespace Gob { -extern int16 pal_fadeValue; +class PalAnim { +public: + int16 fadeValue; -char pal_fadeColor(char from, char to); -char pal_fadeStep(int16 oper); // oper == 0 - fade all colors, 1, 2, 3 - red,green, blue -void pal_fade(PalDesc * palDesc, int16 fade, int16 all); + char fadeColor(char from, char to); + char fadeStep(int16 oper); // oper == 0 - fade all colors, 1, 2, 3 - red,green, blue + void fade(Video::PalDesc * palDesc, int16 fade, int16 all); + + PalAnim(GobEngine *vm); + +protected: + byte toFadeRed[256]; + byte toFadeGreen[256]; + byte toFadeBlue[256]; + GobEngine *_vm; +}; } // End of namespace Gob diff --git a/gob/parse.cpp b/gob/parse.cpp index a05783ab14..9d7134a4a1 100644 --- a/gob/parse.cpp +++ b/gob/parse.cpp @@ -28,24 +28,21 @@ namespace Gob { -enum PointerType { - kExecPtr = 0, - kInterVar = 1, - kResStr = 2 -}; +Parse::Parse(GobEngine *vm) : _vm(vm) { +} -int32 encodePtr(char *ptr, int type) { +int32 Parse::encodePtr(char *ptr, int type) { int32 offset; switch (type) { case kExecPtr: - offset = ptr - game_totFileData; + offset = ptr - _vm->_game->totFileData; break; case kInterVar: - offset = ptr - inter_variables; + offset = ptr - _vm->_global->inter_variables; break; case kResStr: - offset = ptr - inter_resStr; + offset = ptr - _vm->_global->inter_resStr; break; default: error("encodePtr: Unknown pointer type"); @@ -54,18 +51,18 @@ int32 encodePtr(char *ptr, int type) { return (type << 28) | offset; } -char *decodePtr(int32 n) { +char *Parse::decodePtr(int32 n) { char *ptr; switch (n >> 28) { case kExecPtr: - ptr = game_totFileData; + ptr = _vm->_game->totFileData; break; case kInterVar: - ptr = inter_variables; + ptr = _vm->_global->inter_variables; break; case kResStr: - ptr = inter_resStr; + ptr = _vm->_global->inter_resStr; break; default: error("decodePtr: Unknown pointer type"); @@ -73,7 +70,7 @@ char *decodePtr(int32 n) { return ptr + (n & 0x0FFFFFFF); } -int16 parse_parseExpr(char arg_0, byte *arg_2) { +int16 Parse::parseExpr(char arg_0, byte *arg_2) { int32 values[20]; byte operStack[20]; int32 prevPrevVal; @@ -101,54 +98,54 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { stkPos++; operPtr++; valPtr++; - operation = *inter_execPtr++; + operation = *_vm->_global->inter_execPtr++; if (operation >= 19 && operation <= 29) { switch (operation) { case 19: *operPtr = 20; - *valPtr = READ_LE_UINT32(inter_execPtr); - inter_execPtr += 4; + *valPtr = READ_LE_UINT32(_vm->_global->inter_execPtr); + _vm->_global->inter_execPtr += 4; break; case 20: *operPtr = 20; - *valPtr = inter_load16(); + *valPtr = _vm->_inter->load16(); break; case 22: *operPtr = 22; - *valPtr = encodePtr(inter_execPtr, kExecPtr); - inter_execPtr += strlen(inter_execPtr) + 1; + *valPtr = encodePtr(_vm->_global->inter_execPtr, kExecPtr); + _vm->_global->inter_execPtr += strlen(_vm->_global->inter_execPtr) + 1; break; case 23: *operPtr = 20; - *valPtr = VAR(inter_load16()); + *valPtr = VAR(_vm->_inter->load16()); break; case 25: *operPtr = 22; - temp = inter_load16() * 4; - *valPtr = encodePtr(inter_variables + temp, kInterVar); - if (*inter_execPtr == 13) { - inter_execPtr++; - temp += parse_parseValExpr(); + temp = _vm->_inter->load16() * 4; + *valPtr = encodePtr(_vm->_global->inter_variables + temp, kInterVar); + if (*_vm->_global->inter_execPtr == 13) { + _vm->_global->inter_execPtr++; + temp += parseValExpr(); *operPtr = 20; - *valPtr = (uint8)*(inter_variables + temp); + *valPtr = (uint8)*(_vm->_global->inter_variables + temp); } break; case 26: case 28: *operPtr = operation - 6; - temp = inter_load16(); - dimCount = *inter_execPtr++; - arrDescPtr = (byte *)inter_execPtr; - inter_execPtr += dimCount; + temp = _vm->_inter->load16(); + dimCount = *_vm->_global->inter_execPtr++; + arrDescPtr = (byte *)_vm->_global->inter_execPtr; + _vm->_global->inter_execPtr += dimCount; offset = 0; dim = 0; for (dim = 0; dim < dimCount; dim++) { - temp2 = parse_parseValExpr(); + temp2 = parseValExpr(); offset = offset * arrDescPtr[dim] + temp2; } @@ -156,22 +153,22 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { *valPtr = VAR(temp + offset); break; } - *valPtr = encodePtr(inter_variables + temp * 4 + offset * inter_animDataSize * 4, kInterVar); - if (*inter_execPtr == 13) { - inter_execPtr++; - temp2 = parse_parseValExpr(); + *valPtr = encodePtr(_vm->_global->inter_variables + temp * 4 + offset * _vm->_global->inter_animDataSize * 4, kInterVar); + if (*_vm->_global->inter_execPtr == 13) { + _vm->_global->inter_execPtr++; + temp2 = parseValExpr(); *operPtr = 20; - *valPtr = (uint8)*(inter_variables + temp * 4 + offset * 4 * inter_animDataSize + temp2); + *valPtr = (uint8)*(_vm->_global->inter_variables + temp * 4 + offset * 4 * _vm->_global->inter_animDataSize + temp2); } break; case 29: - operation = *inter_execPtr++; - parse_parseExpr(10, 0); + operation = *_vm->_global->inter_execPtr++; + parseExpr(10, 0); switch (operation) { case 5: - inter_resVal = inter_resVal * inter_resVal; + _vm->_global->inter_resVal = _vm->_global->inter_resVal * _vm->_global->inter_resVal; break; case 0: @@ -183,22 +180,22 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { do { prevPrevVal = prevVal; prevVal = curVal; - curVal = (curVal + inter_resVal / curVal) / 2; + curVal = (curVal + _vm->_global->inter_resVal / curVal) / 2; } while (curVal != prevVal && curVal != prevPrevVal); - inter_resVal = curVal; + _vm->_global->inter_resVal = curVal; break; case 10: - inter_resVal = util_getRandom(inter_resVal); + _vm->_global->inter_resVal = _vm->_util->getRandom(_vm->_global->inter_resVal); break; case 7: - if (inter_resVal < 0) - inter_resVal = -inter_resVal; + if (_vm->_global->inter_resVal < 0) + _vm->_global->inter_resVal = -_vm->_global->inter_resVal; break; } *operPtr = 20; - *valPtr = inter_resVal; + *valPtr = _vm->_global->inter_resVal; } if (stkPos > 0 && (operPtr[-1] == 1 || operPtr[-1] == 11)) { @@ -223,11 +220,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { switch (operPtr[-1]) { case 2: if (operPtr[-2] == 22) { - if (decodePtr(valPtr[-2]) != inter_resStr) { - strcpy(inter_resStr, decodePtr(valPtr[-2])); - valPtr[-2] = encodePtr(inter_resStr, kResStr); + if (decodePtr(valPtr[-2]) != _vm->_global->inter_resStr) { + strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-2])); + valPtr[-2] = encodePtr(_vm->_global->inter_resStr, kResStr); } - strcat(inter_resStr, decodePtr(valPtr[0])); + strcat(_vm->_global->inter_resStr, decodePtr(valPtr[0])); stkPos -= 2; operPtr -= 2; valPtr -= 2; @@ -343,11 +340,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { if (operStack[brackStart] == 20) { values[brackStart] += valPtr[-1]; } else if (operStack[brackStart] == 22) { - if (decodePtr(values[brackStart]) != inter_resStr) { - strcpy(inter_resStr, decodePtr(values[brackStart])); - values[brackStart] = encodePtr(inter_resStr, kResStr); + if (decodePtr(values[brackStart]) != _vm->_global->inter_resStr) { + strcpy(_vm->_global->inter_resStr, decodePtr(values[brackStart])); + values[brackStart] = encodePtr(_vm->_global->inter_resStr, kResStr); } - strcat(inter_resStr, decodePtr(valPtr[-1])); + strcat(_vm->_global->inter_resStr, decodePtr(valPtr[-1])); } stkPos -= 2; operPtr -= 2; @@ -419,11 +416,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { if (valPtr[-3] < valPtr[-1]) operPtr[-3] = 24; } else if (var_C == 22) { - if (decodePtr(valPtr[-3]) != inter_resStr) { - strcpy(inter_resStr, decodePtr(valPtr[-3])); - valPtr[-3] = encodePtr(inter_resStr, kResStr); + if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) { + strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3])); + valPtr[-3] = encodePtr(_vm->_global->inter_resStr, kResStr); } - if (strcmp(inter_resStr, decodePtr(valPtr[-1])) < 0) + if (strcmp(_vm->_global->inter_resStr, decodePtr(valPtr[-1])) < 0) operPtr[-3] = 24; } stkPos -= 2; @@ -438,11 +435,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { if (valPtr[-3] <= valPtr[-1]) operPtr[-3] = 24; } else if (var_C == 22) { - if (decodePtr(valPtr[-3]) != inter_resStr) { - strcpy(inter_resStr, decodePtr(valPtr[-3])); - valPtr[-3] = encodePtr(inter_resStr, kResStr); + if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) { + strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3])); + valPtr[-3] = encodePtr(_vm->_global->inter_resStr, kResStr); } - if (strcmp(inter_resStr, decodePtr(valPtr[-1])) <= 0) + if (strcmp(_vm->_global->inter_resStr, decodePtr(valPtr[-1])) <= 0) operPtr[-3] = 24; } stkPos -= 2; @@ -457,11 +454,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { if (valPtr[-3] > valPtr[-1]) operPtr[-3] = 24; } else if (var_C == 22) { - if (decodePtr(valPtr[-3]) != inter_resStr) { - strcpy(inter_resStr, decodePtr(valPtr[-3])); - valPtr[-3] = encodePtr(inter_resStr, kResStr); + if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) { + strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3])); + valPtr[-3] = encodePtr(_vm->_global->inter_resStr, kResStr); } - if (strcmp(inter_resStr, decodePtr(valPtr[-1])) > 0) + if (strcmp(_vm->_global->inter_resStr, decodePtr(valPtr[-1])) > 0) operPtr[-3] = 24; } stkPos -= 2; @@ -476,11 +473,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { if (valPtr[-3] >= valPtr[-1]) operPtr[-3] = 24; } else if (var_C == 22) { - if (decodePtr(valPtr[-3]) != inter_resStr) { - strcpy(inter_resStr, decodePtr(valPtr[-3])); - valPtr[-3] = encodePtr(inter_resStr, kResStr); + if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) { + strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3])); + valPtr[-3] = encodePtr(_vm->_global->inter_resStr, kResStr); } - if (strcmp(inter_resStr, decodePtr(valPtr[-1])) >= 0) + if (strcmp(_vm->_global->inter_resStr, decodePtr(valPtr[-1])) >= 0) operPtr[-3] = 24; } stkPos -= 2; @@ -495,11 +492,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { if (valPtr[-3] == valPtr[-1]) operPtr[-3] = 24; } else if (var_C == 22) { - if (decodePtr(valPtr[-3]) != inter_resStr) { - strcpy(inter_resStr, decodePtr(valPtr[-3])); - valPtr[-3] = encodePtr(inter_resStr, kResStr); + if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) { + strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3])); + valPtr[-3] = encodePtr(_vm->_global->inter_resStr, kResStr); } - if (strcmp(inter_resStr, decodePtr(valPtr[-1])) == 0) + if (strcmp(_vm->_global->inter_resStr, decodePtr(valPtr[-1])) == 0) operPtr[-3] = 24; } stkPos -= 2; @@ -514,11 +511,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { if (valPtr[-3] != valPtr[-1]) operPtr[-3] = 24; } else if (var_C == 22) { - if (decodePtr(valPtr[-3]) != inter_resStr) { - strcpy(inter_resStr, decodePtr(valPtr[-3])); - valPtr[-3] = encodePtr(inter_resStr, kResStr); + if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) { + strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3])); + valPtr[-3] = encodePtr(_vm->_global->inter_resStr, kResStr); } - if (strcmp(inter_resStr, decodePtr(valPtr[-1])) != 0) + if (strcmp(_vm->_global->inter_resStr, decodePtr(valPtr[-1])) != 0) operPtr[-3] = 24; } stkPos -= 2; @@ -546,15 +543,15 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { if ((operation == 30 && operPtr[-1] == 24) || (operation == 31 && operPtr[-1] == 23)) { if (stkPos > 1 && operPtr[-2] == 9) { - parse_skipExpr(10); + skipExpr(10); operPtr[-2] = operPtr[-1]; stkPos -= 2; operPtr -= 2; valPtr -= 2; } else { - parse_skipExpr(arg_0); + skipExpr(arg_0); } - operation = inter_execPtr[-1]; + operation = _vm->_global->inter_execPtr[-1]; if (stkPos > 0 && operPtr[-1] == 11) { if (operPtr[0] == 23) operPtr[-1] = 24; @@ -581,12 +578,12 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { switch (operStack[0]) { case 20: - inter_resVal = values[0]; + _vm->_global->inter_resVal = values[0]; break; case 22: - if (decodePtr(values[0]) != inter_resStr) - strcpy(inter_resStr, decodePtr(values[0])); + if (decodePtr(values[0]) != _vm->_global->inter_resStr) + strcpy(_vm->_global->inter_resStr, decodePtr(values[0])); break; case 11: @@ -599,7 +596,7 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { break; default: - inter_resVal = 0; + _vm->_global->inter_resVal = 0; if (arg_2 != 0) *arg_2 = 20; break; @@ -616,11 +613,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { if (operPtr[-3] == 20) { valPtr[-3] += valPtr[-1]; } else if (operPtr[-3] == 22) { - if (decodePtr(valPtr[-3]) != inter_resStr) { - strcpy(inter_resStr, decodePtr(valPtr[-3])); - valPtr[-3] = encodePtr(inter_resStr, kResStr); + if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) { + strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3])); + valPtr[-3] = encodePtr(_vm->_global->inter_resStr, kResStr); } - strcat(inter_resStr, decodePtr(valPtr[-1])); + strcat(_vm->_global->inter_resStr, decodePtr(valPtr[-1])); } stkPos -= 2; operPtr -= 2; @@ -643,7 +640,7 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) { } } -void parse_skipExpr(char arg_0) { +void Parse::skipExpr(char arg_0) { int16 dimCount; char operation; int16 num; @@ -651,47 +648,47 @@ void parse_skipExpr(char arg_0) { num = 0; while (1) { - operation = *inter_execPtr++; + operation = *_vm->_global->inter_execPtr++; if (operation >= 19 && operation <= 29) { switch (operation) { case 20: case 23: - inter_execPtr += 2; + _vm->_global->inter_execPtr += 2; break; case 19: - inter_execPtr += 4; + _vm->_global->inter_execPtr += 4; break; case 22: - inter_execPtr += strlen(inter_execPtr) + 1; + _vm->_global->inter_execPtr += strlen(_vm->_global->inter_execPtr) + 1; break; case 25: - inter_execPtr += 2; - if (*inter_execPtr == 13) { - inter_execPtr++; - parse_skipExpr(12); + _vm->_global->inter_execPtr += 2; + if (*_vm->_global->inter_execPtr == 13) { + _vm->_global->inter_execPtr++; + skipExpr(12); } break; case 26: case 28: - dimCount = inter_execPtr[2]; - inter_execPtr += 3 + dimCount; // ??? + dimCount = _vm->_global->inter_execPtr[2]; + _vm->_global->inter_execPtr += 3 + dimCount; // ??? for (dim = 0; dim < dimCount; dim++) - parse_skipExpr(12); + skipExpr(12); - if (operation == 28 && *inter_execPtr == 13) { - inter_execPtr++; - parse_skipExpr(12); + if (operation == 28 && *_vm->_global->inter_execPtr == 13) { + _vm->_global->inter_execPtr++; + skipExpr(12); } break; case 29: - inter_execPtr++; - parse_skipExpr(10); + _vm->_global->inter_execPtr++; + skipExpr(10); } continue; } // if (operation >= 19 && operation <= 29) @@ -718,7 +715,7 @@ void parse_skipExpr(char arg_0) { } } -int16 parse_parseValExpr() { +int16 Parse::parseValExpr() { int16 values[20]; byte operStack[20]; int16 *valPtr; @@ -738,7 +735,7 @@ int16 parse_parseValExpr() { oldflag = flag; if (flag == 0) { flag = 1; - parse_printExpr(99); + printExpr(99); } stkPos = -1; @@ -750,63 +747,63 @@ int16 parse_parseValExpr() { operPtr++; valPtr++; - operation = *inter_execPtr++; + operation = *_vm->_global->inter_execPtr++; if (operation >= 19 && operation <= 29) { *operPtr = 20; switch (operation) { case 19: - *valPtr = READ_LE_UINT32(inter_execPtr); - inter_execPtr += 4; + *valPtr = READ_LE_UINT32(_vm->_global->inter_execPtr); + _vm->_global->inter_execPtr += 4; break; case 20: - *valPtr = inter_load16(); + *valPtr = _vm->_inter->load16(); break; case 23: - *valPtr = (uint16)VAR(inter_load16()); + *valPtr = (uint16)VAR(_vm->_inter->load16()); break; case 25: - temp = inter_load16() * 4; - inter_execPtr++; - temp += parse_parseValExpr(); - *valPtr = (uint8)*(inter_variables + temp); + temp = _vm->_inter->load16() * 4; + _vm->_global->inter_execPtr++; + temp += parseValExpr(); + *valPtr = (uint8)*(_vm->_global->inter_variables + temp); break; case 26: case 28: - temp = inter_load16(); - dimCount = *inter_execPtr++; - arrDesc = (byte*)inter_execPtr; - inter_execPtr += dimCount; + temp = _vm->_inter->load16(); + dimCount = *_vm->_global->inter_execPtr++; + arrDesc = (byte*)_vm->_global->inter_execPtr; + _vm->_global->inter_execPtr += dimCount; offset = 0; for (dim = 0; dim < dimCount; dim++) { - temp2 = parse_parseValExpr(); + temp2 = parseValExpr(); offset = arrDesc[dim] * offset + temp2; } if (operation == 26) { *valPtr = (uint16)VAR(temp + offset); } else { - inter_execPtr++; - temp2 = parse_parseValExpr(); - *valPtr = (uint8)*(inter_variables + temp * 4 + offset * 4 * inter_animDataSize + temp2); + _vm->_global->inter_execPtr++; + temp2 = parseValExpr(); + *valPtr = (uint8)*(_vm->_global->inter_variables + temp * 4 + offset * 4 * _vm->_global->inter_animDataSize + temp2); } break; case 29: - operation = *inter_execPtr++; - parse_parseExpr(10, 0); + operation = *_vm->_global->inter_execPtr++; + parseExpr(10, 0); if (operation == 5) { - inter_resVal = inter_resVal * inter_resVal; + _vm->_global->inter_resVal = _vm->_global->inter_resVal * _vm->_global->inter_resVal; } else if (operation == 7) { - if (inter_resVal < 0) - inter_resVal = -inter_resVal; + if (_vm->_global->inter_resVal < 0) + _vm->_global->inter_resVal = -_vm->_global->inter_resVal; } else if (operation == 10) { - inter_resVal = util_getRandom(inter_resVal); + _vm->_global->inter_resVal = _vm->_util->getRandom(_vm->_global->inter_resVal); } - *valPtr = inter_resVal; + *valPtr = _vm->_global->inter_resVal; break; } // switch @@ -943,7 +940,7 @@ int16 parse_parseValExpr() { } } -int16 parse_parseVarIndex() { +int16 Parse::parseVarIndex() { int16 temp2; char *arrDesc; int16 dim; @@ -953,16 +950,16 @@ int16 parse_parseVarIndex() { int16 offset; int16 val; - operation = *inter_execPtr++; + operation = *_vm->_global->inter_execPtr++; debug(5, "var parse = %d", operation); switch (operation) { case 23: case 25: - temp = inter_load16() * 4; - debug(5, "oper = %d", (int16)*inter_execPtr); - if (operation == 25 && *inter_execPtr == 13) { - inter_execPtr++; - val = parse_parseValExpr(); + temp = _vm->_inter->load16() * 4; + debug(5, "oper = %d", (int16)*_vm->_global->inter_execPtr); + if (operation == 25 && *_vm->_global->inter_execPtr == 13) { + _vm->_global->inter_execPtr++; + val = parseValExpr(); temp += val; debug(5, "parse subscript = %d", val); } @@ -970,31 +967,31 @@ int16 parse_parseVarIndex() { case 26: case 28: - temp = inter_load16() * 4; - dimCount = *inter_execPtr++; - arrDesc = inter_execPtr; - inter_execPtr += dimCount; + temp = _vm->_inter->load16() * 4; + dimCount = *_vm->_global->inter_execPtr++; + arrDesc = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr += dimCount; offset = 0; for (dim = 0; dim < dimCount; dim++) { - temp2 = parse_parseValExpr(); + temp2 = parseValExpr(); offset = arrDesc[dim] * offset + temp2; } offset *= 4; if (operation != 28) return temp + offset; - if (*inter_execPtr == 13) { - inter_execPtr++; - temp += parse_parseValExpr(); + if (*_vm->_global->inter_execPtr == 13) { + _vm->_global->inter_execPtr++; + temp += parseValExpr(); } - return offset * inter_animDataSize + temp; + return offset * _vm->_global->inter_animDataSize + temp; default: return 0; } } -void parse_printExpr(char arg_0) { +void Parse::printExpr(char arg_0) { int16 dimCount; char operation; int16 num; @@ -1009,40 +1006,40 @@ void parse_printExpr(char arg_0) { return; if (savedPos == 0) { - savedPos = inter_execPtr; + savedPos = _vm->_global->inter_execPtr; saved = 1; } num = 0; while (1) { - operation = *inter_execPtr++; + operation = *_vm->_global->inter_execPtr++; if (operation >= 19 && operation <= 29) { switch (operation) { case 19: - debug(5, "%l", READ_LE_UINT32(inter_execPtr)); - inter_execPtr += 4; + debug(5, "%l", READ_LE_UINT32(_vm->_global->inter_execPtr)); + _vm->_global->inter_execPtr += 4; break; case 20: - debug(5, "%d", inter_load16()); + debug(5, "%d", _vm->_inter->load16()); break; case 22: - debug(5, "\42%s\42", inter_execPtr); - inter_execPtr += strlen(inter_execPtr) + 1; + debug(5, "\42%s\42", _vm->_global->inter_execPtr); + _vm->_global->inter_execPtr += strlen(_vm->_global->inter_execPtr) + 1; break; case 23: - debug(5, "var_%d", inter_load16()); + debug(5, "var_%d", _vm->_inter->load16()); break; case 25: - debug(5, "(&var_%d)", inter_load16()); - if (*inter_execPtr == 13) { - inter_execPtr++; + debug(5, "(&var_%d)", _vm->_inter->load16()); + if (*_vm->_global->inter_execPtr == 13) { + _vm->_global->inter_execPtr++; debug(5, "{"); - parse_printExpr(12); + printExpr(12); // debug(5, "}"); } break; @@ -1052,12 +1049,12 @@ void parse_printExpr(char arg_0) { if (operation == 28) debug(5, "(&"); - debug(5, "var_%d[", inter_load16()); - dimCount = *inter_execPtr++; - arrDesc = inter_execPtr; - inter_execPtr += dimCount; + debug(5, "var_%d[", _vm->_inter->load16()); + dimCount = *_vm->_global->inter_execPtr++; + arrDesc = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr += dimCount; for (dim = 0; dim < dimCount; dim++) { - parse_printExpr(12); + printExpr(12); debug(5, " of %d", (int16)arrDesc[dim]); if (dim != dimCount - 1) debug(5, ","); @@ -1066,16 +1063,16 @@ void parse_printExpr(char arg_0) { if (operation == 28) debug(5, ")"); - if (operation == 28 && *inter_execPtr == 13) { - inter_execPtr++; + if (operation == 28 && *_vm->_global->inter_execPtr == 13) { + _vm->_global->inter_execPtr++; debug(5, "{"); - parse_printExpr(12); + printExpr(12); // debug(5, "}"); } break; case 29: - func = *inter_execPtr++; + func = *_vm->_global->inter_execPtr++; if (func == 5) debug(5, "sqr("); else if (func == 10) @@ -1086,7 +1083,7 @@ void parse_printExpr(char arg_0) { debug(5, "sqrt("); else debug(5, "id("); - parse_printExpr(10); + printExpr(10); break; case 12: @@ -1207,7 +1204,7 @@ void parse_printExpr(char arg_0) { if (arg_0 != 10 || num < 0) { if (saved != 0) { - inter_execPtr = savedPos; + _vm->_global->inter_execPtr = savedPos; savedPos = 0; } return; @@ -1216,46 +1213,46 @@ void parse_printExpr(char arg_0) { } } -void parse_printVarIndex() { +void Parse::printVarIndex() { char *arrDesc; int16 dim; int16 dimCount; int16 operation; int16 temp; - char *pos = inter_execPtr; + char *pos = _vm->_global->inter_execPtr; - operation = *inter_execPtr++; + operation = *_vm->_global->inter_execPtr++; switch (operation) { case 23: case 25: - temp = inter_load16() * 4; + temp = _vm->_inter->load16() * 4; debug(5, "&var_%d", temp); - if (operation == 25 && *inter_execPtr == 13) { - inter_execPtr++; + if (operation == 25 && *_vm->_global->inter_execPtr == 13) { + _vm->_global->inter_execPtr++; debug(5, "+"); - parse_printExpr(99); + printExpr(99); } break; case 26: case 28: - debug(5, "&var_%d[", inter_load16()); - dimCount = *inter_execPtr++; - arrDesc = inter_execPtr; - inter_execPtr += dimCount; + debug(5, "&var_%d[", _vm->_inter->load16()); + dimCount = *_vm->_global->inter_execPtr++; + arrDesc = _vm->_global->inter_execPtr; + _vm->_global->inter_execPtr += dimCount; for (dim = 0; dim < dimCount; dim++) { - parse_printExpr(12); + printExpr(12); debug(5, " of %d", (int16)arrDesc[dim]); if (dim != dimCount - 1) debug(5, ","); } debug(5, "]"); - if (operation == 28 && *inter_execPtr == 13) { - inter_execPtr++; + if (operation == 28 && *_vm->_global->inter_execPtr == 13) { + _vm->_global->inter_execPtr++; debug(5, "+"); - parse_printExpr(99); + printExpr(99); } break; @@ -1264,7 +1261,7 @@ void parse_printVarIndex() { break; } debug(5, "\n"); - inter_execPtr = pos; + _vm->_global->inter_execPtr = pos; return; } diff --git a/gob/parse.h b/gob/parse.h index d86a99ce3f..fae387df88 100644 --- a/gob/parse.h +++ b/gob/parse.h @@ -24,12 +24,29 @@ namespace Gob { -int16 parse_parseExpr(char stopToken, byte *resultPtr); -void parse_skipExpr(char stopToken); -int16 parse_parseValExpr(void); -int16 parse_parseVarIndex(void); -void parse_printExpr(char stopToken); -void parse_printVarIndex(void); +class Parse { +public: + int16 parseExpr(char stopToken, byte *resultPtr); + void skipExpr(char stopToken); + int16 parseValExpr(void); + int16 parseVarIndex(void); + void printExpr(char stopToken); + void printVarIndex(void); + + Parse(GobEngine *vm); + +protected: + enum PointerType { + kExecPtr = 0, + kInterVar = 1, + kResStr = 2 + }; + + GobEngine *_vm; + + int32 encodePtr(char *ptr, int type); + char *decodePtr(int32 n); +}; } // End of namespace Gob diff --git a/gob/scenery.cpp b/gob/scenery.cpp index b373e2178c..0cd6971c25 100644 --- a/gob/scenery.cpp +++ b/gob/scenery.cpp @@ -33,35 +33,39 @@ namespace Gob { -int16 scen_spriteResId[20]; -char scen_spriteRefs[20]; - -Scen_Static scen_statics[10]; -int16 scen_staticPictCount[10]; -char scen_staticFromExt[10]; -int16 scen_staticResId[10]; -char scen_staticPictToSprite[70]; - -Scen_Animation scen_animations[10]; -int16 scen_animPictCount[10]; -char scen_animFromExt[10]; -int16 scen_animResId[10]; -char scen_animPictToSprite[70]; +Scenery::Scenery(GobEngine *vm) : _vm(vm) { + for (int i = 0; i < 20; i++) { + spriteRefs[i] = 0; + spriteResId[i] = 0; + } + for (int i = 0; i < 70; i++ ) { + staticPictToSprite[i] = 0; + animPictToSprite[i] = 0; + } + for (int i = 0; i < 10; i++) { + staticPictCount[i] = 0; + staticFromExt[i] = 0; + staticResId[i] = 0; + animPictCount[i] = 0; + animFromExt[i] = 0; + animResId[i] = 0; + } -int16 scen_curStatic; -int16 scen_curStaticLayer; + curStatic = 0; + curStaticLayer = 0; -int16 scen_toRedrawLeft; -int16 scen_toRedrawRight; -int16 scen_toRedrawTop; -int16 scen_toRedrawBottom; + toRedrawLeft = 0; + toRedrawRight = 0; + toRedrawTop = 0; + toRedrawBottom = 0; -int16 scen_animTop; -int16 scen_animLeft; + animTop = 0; + animLeft = 0; -int16 *scen_pCaptureCounter; + pCaptureCounter = 0; +} -int16 scen_loadStatic(char search) { +int16 Scenery::loadStatic(char search) { int16 tmp; int16 *backsPtr; int16 picsCount; @@ -69,7 +73,7 @@ int16 scen_loadStatic(char search) { int16 i; int16 sceneryIndex; char *dataPtr; - Scen_Static *ptr; + Static *ptr; int16 offset; int16 pictDescId; int16 width; @@ -77,48 +81,48 @@ int16 scen_loadStatic(char search) { int16 sprResId; int16 sprIndex; - inter_evalExpr(&sceneryIndex); - tmp = inter_load16(); - backsPtr = (int16 *)inter_execPtr; - inter_execPtr += tmp * 2; - picsCount = inter_load16(); - resId = inter_load16(); + _vm->_inter->evalExpr(&sceneryIndex); + tmp = _vm->_inter->load16(); + backsPtr = (int16 *)_vm->_global->inter_execPtr; + _vm->_global->inter_execPtr += tmp * 2; + picsCount = _vm->_inter->load16(); + resId = _vm->_inter->load16(); if (search) { for (i = 0; i < 10; i++) { - if (scen_staticPictCount[i] != -1 && scen_staticResId[i] == resId) { - inter_execPtr += 8 * scen_staticPictCount[i]; + if (staticPictCount[i] != -1 && staticResId[i] == resId) { + _vm->_global->inter_execPtr += 8 * staticPictCount[i]; return i; } - if (scen_staticPictCount[i] == -1 && i < sceneryIndex) + if (staticPictCount[i] == -1 && i < sceneryIndex) sceneryIndex = i; } } - scen_staticPictCount[sceneryIndex] = picsCount; - scen_staticResId[sceneryIndex] = resId; + staticPictCount[sceneryIndex] = picsCount; + staticResId[sceneryIndex] = resId; if (resId >= 30000) { - scen_staticFromExt[sceneryIndex] = 1; - dataPtr = game_loadExtData(resId, 0, 0); + staticFromExt[sceneryIndex] = 1; + dataPtr = _vm->_game->loadExtData(resId, 0, 0); } else { - scen_staticFromExt[sceneryIndex] = 0; - dataPtr = game_loadTotResource(resId); + staticFromExt[sceneryIndex] = 0; + dataPtr = _vm->_game->loadTotResource(resId); } - ptr = &scen_statics[sceneryIndex]; + ptr = &statics[sceneryIndex]; ptr->dataPtr = dataPtr; ptr->layersCount = (int16)READ_LE_UINT16(dataPtr); dataPtr += 2; - ptr->layers = (Scen_StaticLayer **)malloc(sizeof(Scen_StaticLayer *) * ptr->layersCount); - ptr->pieces = (Scen_PieceDesc **)malloc(sizeof(Scen_PieceDesc *) * picsCount); + ptr->layers = (StaticLayer **)malloc(sizeof(StaticLayer *) * ptr->layersCount); + ptr->pieces = (PieceDesc **)malloc(sizeof(PieceDesc *) * picsCount); ptr->piecesFromExt = (int8 *)malloc(picsCount); for (i = 0; i < ptr->layersCount; i++) { offset = (int16)READ_LE_UINT16(&((int16 *)dataPtr)[i]); - ptr->layers[i] = (Scen_StaticLayer *)(dataPtr + offset - 2); + ptr->layers[i] = (StaticLayer *)(dataPtr + offset - 2); ptr->layers[i]->planeCount = (int16)READ_LE_UINT16(&ptr->layers[i]->planeCount); @@ -132,91 +136,91 @@ int16 scen_loadStatic(char search) { } for (i = 0; i < picsCount; i++) { - pictDescId = inter_load16(); + pictDescId = _vm->_inter->load16(); if (pictDescId >= 30000) { ptr->pieces[i] = - (Scen_PieceDesc *) game_loadExtData(pictDescId, 0, + (PieceDesc *) _vm->_game->loadExtData(pictDescId, 0, 0); ptr->piecesFromExt[i] = 1; } else { ptr->pieces[i] = - (Scen_PieceDesc *) - game_loadTotResource(pictDescId); + (PieceDesc *) + _vm->_game->loadTotResource(pictDescId); ptr->piecesFromExt[i] = 0; } - width = inter_load16(); - height = inter_load16(); - sprResId = inter_load16(); + width = _vm->_inter->load16(); + height = _vm->_inter->load16(); + sprResId = _vm->_inter->load16(); for (sprIndex = 0; sprIndex < 20; sprIndex++) { - if (scen_spriteResId[sprIndex] == sprResId) + if (spriteResId[sprIndex] == sprResId) break; } if (sprIndex < 20) { - scen_staticPictToSprite[7 * sceneryIndex + i] = + staticPictToSprite[7 * sceneryIndex + i] = sprIndex; - scen_spriteRefs[sprIndex]++; + spriteRefs[sprIndex]++; } else { - for (sprIndex = 19; draw_spritesArray[sprIndex] != 0; + for (sprIndex = 19; _vm->_draw->spritesArray[sprIndex] != 0; sprIndex--); - scen_staticPictToSprite[7 * sceneryIndex + i] = + staticPictToSprite[7 * sceneryIndex + i] = sprIndex; - scen_spriteRefs[sprIndex] = 1; - scen_spriteResId[sprIndex] = sprResId; - draw_spritesArray[sprIndex] = - vid_initSurfDesc(videoMode, width, height, 2); - - vid_clearSurf(draw_spritesArray[sprIndex]); - draw_destSurface = sprIndex; - draw_spriteLeft = sprResId; - draw_transparency = 0; - draw_destSpriteX = 0; - draw_destSpriteY = 0; - draw_spriteOperation(DRAW_LOADSPRITE); + spriteRefs[sprIndex] = 1; + spriteResId[sprIndex] = sprResId; + _vm->_draw->spritesArray[sprIndex] = + _vm->_video->initSurfDesc(_vm->_global->videoMode, width, height, 2); + + _vm->_video->clearSurf(_vm->_draw->spritesArray[sprIndex]); + _vm->_draw->destSurface = sprIndex; + _vm->_draw->spriteLeft = sprResId; + _vm->_draw->transparency = 0; + _vm->_draw->destSpriteX = 0; + _vm->_draw->destSpriteY = 0; + _vm->_draw->spriteOperation(DRAW_LOADSPRITE); } } return sceneryIndex + 100; } -void scen_freeStatic(int16 index) { +void Scenery::freeStatic(int16 index) { int16 i; int16 spr; if (index == -1) - inter_evalExpr(&index); + _vm->_inter->evalExpr(&index); - if (scen_staticPictCount[index] == -1) + if (staticPictCount[index] == -1) return; - for (i = 0; i < scen_staticPictCount[index]; i++) { - if (scen_statics[index].piecesFromExt[i] == 1) - free(scen_statics[index].pieces[i]); + for (i = 0; i < staticPictCount[index]; i++) { + if (statics[index].piecesFromExt[i] == 1) + free(statics[index].pieces[i]); - spr = scen_staticPictToSprite[index * 7 + i]; - scen_spriteRefs[spr]--; - if (scen_spriteRefs[spr] == 0) { - vid_freeSurfDesc(draw_spritesArray[spr]); - draw_spritesArray[spr] = 0; - scen_spriteResId[spr] = -1; + spr = staticPictToSprite[index * 7 + i]; + spriteRefs[spr]--; + if (spriteRefs[spr] == 0) { + _vm->_video->freeSurfDesc(_vm->_draw->spritesArray[spr]); + _vm->_draw->spritesArray[spr] = 0; + spriteResId[spr] = -1; } } - free(scen_statics[index].layers); - free(scen_statics[index].pieces); - free(scen_statics[index].piecesFromExt); - if (scen_staticFromExt[index] == 1) - free(scen_statics[index].dataPtr); + free(statics[index].layers); + free(statics[index].pieces); + free(statics[index].piecesFromExt); + if (staticFromExt[index] == 1) + free(statics[index].dataPtr); - scen_staticFromExt[index] = 0; - scen_staticPictCount[index] = -1; + staticFromExt[index] = 0; + staticPictCount[index] = -1; } -void scen_renderStatic(int16 scenery, int16 layer) { - Scen_Static *ptr; - Scen_StaticLayer *layerPtr; - Scen_StaticPlane *planePtr; +void Scenery::renderStatic(int16 scenery, int16 layer) { + Static *ptr; + StaticLayer *layerPtr; + StaticPlane *planePtr; int16 planeCount; int16 order; int16 plane; @@ -229,19 +233,19 @@ void scen_renderStatic(int16 scenery, int16 layer) { int16 top; int16 bottom; - ptr = &scen_statics[scenery]; + ptr = &statics[scenery]; if (layer >= ptr->layersCount) return; layerPtr = ptr->layers[layer]; - draw_spriteLeft = layerPtr->backResId; - if (draw_spriteLeft != -1) { - draw_destSpriteX = 0; - draw_destSpriteY = 0; - draw_destSurface = 21; - draw_transparency = 0; - draw_spriteOperation(DRAW_LOADSPRITE); + _vm->_draw->spriteLeft = layerPtr->backResId; + if (_vm->_draw->spriteLeft != -1) { + _vm->_draw->destSpriteX = 0; + _vm->_draw->destSpriteY = 0; + _vm->_draw->destSurface = 21; + _vm->_draw->transparency = 0; + _vm->_draw->spriteOperation(DRAW_LOADSPRITE); } planeCount = layerPtr->planeCount; @@ -254,44 +258,44 @@ void scen_renderStatic(int16 scenery, int16 layer) { pieceIndex = planePtr->pieceIndex; pictIndex = planePtr->pictIndex - 1; - draw_destSpriteX = planePtr->destX; - draw_destSpriteY = planePtr->destY; + _vm->_draw->destSpriteX = planePtr->destX; + _vm->_draw->destSpriteY = planePtr->destY; left = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].left); right = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].right); top = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].top); bottom = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].bottom); - draw_sourceSurface = - scen_staticPictToSprite[scenery * 7 + pictIndex]; - draw_destSurface = 21; - draw_spriteLeft = left; - draw_spriteTop = top; - draw_spriteRight = right - left + 1; - draw_spriteBottom = bottom - top + 1; - draw_transparency = planePtr->transp ? 3 : 0; - draw_spriteOperation(DRAW_BLITSURF); + _vm->_draw->sourceSurface = + staticPictToSprite[scenery * 7 + pictIndex]; + _vm->_draw->destSurface = 21; + _vm->_draw->spriteLeft = left; + _vm->_draw->spriteTop = top; + _vm->_draw->spriteRight = right - left + 1; + _vm->_draw->spriteBottom = bottom - top + 1; + _vm->_draw->transparency = planePtr->transp ? 3 : 0; + _vm->_draw->spriteOperation(DRAW_BLITSURF); } } } -void scen_interRenderStatic(void) { +void Scenery::interRenderStatic(void) { int16 layer; int16 index; - inter_evalExpr(&index); - inter_evalExpr(&layer); - scen_renderStatic(index, layer); + _vm->_inter->evalExpr(&index); + _vm->_inter->evalExpr(&layer); + renderStatic(index, layer); } -void scen_interLoadCurLayer(void) { - inter_evalExpr(&scen_curStatic); - inter_evalExpr(&scen_curStaticLayer); +void Scenery::interLoadCurLayer(void) { + _vm->_inter->evalExpr(&curStatic); + _vm->_inter->evalExpr(&curStaticLayer); } -void scen_updateStatic(int16 orderFrom) { - Scen_StaticLayer *layerPtr; - Scen_PieceDesc **pictPtr; - Scen_StaticPlane *planePtr; +void Scenery::updateStatic(int16 orderFrom) { + StaticLayer *layerPtr; + PieceDesc **pictPtr; + StaticPlane *planePtr; int16 planeCount; int16 order; int16 plane; @@ -303,14 +307,14 @@ void scen_updateStatic(int16 orderFrom) { int16 top; int16 bottom; - if (scen_curStatic == -1) + if (curStatic == -1) return; - if (scen_curStaticLayer >= scen_statics[scen_curStatic].layersCount) + if (curStaticLayer >= statics[curStatic].layersCount) return; - layerPtr = scen_statics[scen_curStatic].layers[scen_curStaticLayer]; - pictPtr = scen_statics[scen_curStatic].pieces; + layerPtr = statics[curStatic].layers[curStaticLayer]; + pictPtr = statics[curStatic].pieces; planeCount = layerPtr->planeCount; @@ -322,65 +326,65 @@ void scen_updateStatic(int16 orderFrom) { pieceIndex = planePtr->pieceIndex; pictIndex = planePtr->pictIndex - 1; - draw_destSpriteX = planePtr->destX; - draw_destSpriteY = planePtr->destY; + _vm->_draw->destSpriteX = planePtr->destX; + _vm->_draw->destSpriteY = planePtr->destY; left = FROM_LE_16(pictPtr[pictIndex][pieceIndex].left); right = FROM_LE_16(pictPtr[pictIndex][pieceIndex].right); top = FROM_LE_16(pictPtr[pictIndex][pieceIndex].top); bottom = FROM_LE_16(pictPtr[pictIndex][pieceIndex].bottom); - if (draw_destSpriteX > scen_toRedrawRight) + if (_vm->_draw->destSpriteX > toRedrawRight) continue; - if (draw_destSpriteY > scen_toRedrawBottom) + if (_vm->_draw->destSpriteY > toRedrawBottom) continue; - if (draw_destSpriteX < scen_toRedrawLeft) { - left += scen_toRedrawLeft - draw_destSpriteX; - draw_destSpriteX = scen_toRedrawLeft; + if (_vm->_draw->destSpriteX < toRedrawLeft) { + left += toRedrawLeft - _vm->_draw->destSpriteX; + _vm->_draw->destSpriteX = toRedrawLeft; } - if (draw_destSpriteY < scen_toRedrawTop) { - top += scen_toRedrawTop - draw_destSpriteY; - draw_destSpriteY = scen_toRedrawTop; + if (_vm->_draw->destSpriteY < toRedrawTop) { + top += toRedrawTop - _vm->_draw->destSpriteY; + _vm->_draw->destSpriteY = toRedrawTop; } - draw_spriteLeft = left; - draw_spriteTop = top; - draw_spriteRight = right - left + 1; - draw_spriteBottom = bottom - top + 1; + _vm->_draw->spriteLeft = left; + _vm->_draw->spriteTop = top; + _vm->_draw->spriteRight = right - left + 1; + _vm->_draw->spriteBottom = bottom - top + 1; - if (draw_spriteRight <= 0 || draw_spriteBottom <= 0) + if (_vm->_draw->spriteRight <= 0 || _vm->_draw->spriteBottom <= 0) continue; - if (draw_destSpriteX + draw_spriteRight - 1 > - scen_toRedrawRight) - draw_spriteRight = - scen_toRedrawRight - draw_destSpriteX + 1; + if (_vm->_draw->destSpriteX + _vm->_draw->spriteRight - 1 > + toRedrawRight) + _vm->_draw->spriteRight = + toRedrawRight - _vm->_draw->destSpriteX + 1; - if (draw_destSpriteY + draw_spriteBottom - 1 > - scen_toRedrawBottom) - draw_spriteBottom = - scen_toRedrawBottom - draw_destSpriteY + 1; + if (_vm->_draw->destSpriteY + _vm->_draw->spriteBottom - 1 > + toRedrawBottom) + _vm->_draw->spriteBottom = + toRedrawBottom - _vm->_draw->destSpriteY + 1; - draw_sourceSurface = - scen_staticPictToSprite[scen_curStatic * 7 + + _vm->_draw->sourceSurface = + staticPictToSprite[curStatic * 7 + pictIndex]; - draw_destSurface = 21; - draw_transparency = planePtr->transp ? 3 : 0; - draw_spriteOperation(DRAW_BLITSURF); + _vm->_draw->destSurface = 21; + _vm->_draw->transparency = planePtr->transp ? 3 : 0; + _vm->_draw->spriteOperation(DRAW_BLITSURF); } } } -int16 scen_loadAnim(char search) { +int16 Scenery::loadAnim(char search) { int16 picsCount; int16 resId; int16 i; int16 sceneryIndex; char *dataPtr; - Scen_Animation *ptr; + Animation *ptr; int16 offset; int16 pictDescId; int16 width; @@ -388,58 +392,58 @@ int16 scen_loadAnim(char search) { int16 sprResId; int16 sprIndex; - if (cd_globFlag) { - while (cd_getTrackPos() != -1) - util_longDelay(50); + if (_vm->_cdrom->_cdPlaying) { + while (_vm->_cdrom->getTrackPos() != -1) + _vm->_util->longDelay(50); - cd_globFlag = false; + _vm->_cdrom->_cdPlaying = false; } - inter_evalExpr(&sceneryIndex); - picsCount = inter_load16(); - resId = inter_load16(); + _vm->_inter->evalExpr(&sceneryIndex); + picsCount = _vm->_inter->load16(); + resId = _vm->_inter->load16(); if (search) { for (i = 0; i < 10; i++) { - if (scen_animPictCount[i] != 0 - && scen_animResId[i] == resId) { - inter_execPtr += 8 * scen_animPictCount[i]; + if (animPictCount[i] != 0 + && animResId[i] == resId) { + _vm->_global->inter_execPtr += 8 * animPictCount[i]; return i; } - if (scen_animPictCount[i] == 0 && i < sceneryIndex) + if (animPictCount[i] == 0 && i < sceneryIndex) sceneryIndex = i; } } - scen_animPictCount[sceneryIndex] = picsCount; - scen_animResId[sceneryIndex] = resId; + animPictCount[sceneryIndex] = picsCount; + animResId[sceneryIndex] = resId; if (resId >= 30000) { - scen_animFromExt[sceneryIndex] = 1; - dataPtr = game_loadExtData(resId, 0, 0); + animFromExt[sceneryIndex] = 1; + dataPtr = _vm->_game->loadExtData(resId, 0, 0); } else { - scen_animFromExt[sceneryIndex] = 0; - dataPtr = game_loadTotResource(resId); + animFromExt[sceneryIndex] = 0; + dataPtr = _vm->_game->loadTotResource(resId); } - ptr = &scen_animations[sceneryIndex]; + ptr = &animations[sceneryIndex]; ptr->dataPtr = dataPtr; ptr->layersCount = READ_LE_UINT16(dataPtr); dataPtr += 2; ptr->layers = - (Scen_AnimLayer **) malloc(sizeof(Scen_AnimLayer *) * + (AnimLayer **) malloc(sizeof(AnimLayer *) * ptr->layersCount); ptr->pieces = - (Scen_PieceDesc **) malloc(sizeof(Scen_PieceDesc *) * + (PieceDesc **) malloc(sizeof(PieceDesc *) * picsCount); ptr->piecesFromExt = (int8 *) malloc(picsCount); for (i = 0; i < ptr->layersCount; i++) { offset = (int16)READ_LE_UINT16(&((int16 *)dataPtr)[i]); - ptr->layers[i] = (Scen_AnimLayer *) (dataPtr + offset - 2); + ptr->layers[i] = (AnimLayer *) (dataPtr + offset - 2); ptr->layers[i]->unknown0 = (int16)READ_LE_UINT16(&ptr->layers[i]->unknown0); ptr->layers[i]->posX = (int16)READ_LE_UINT16(&ptr->layers[i]->posX); @@ -450,47 +454,47 @@ int16 scen_loadAnim(char search) { } for (i = 0; i < picsCount; i++) { - pictDescId = inter_load16(); + pictDescId = _vm->_inter->load16(); if (pictDescId >= 30000) { ptr->pieces[i] = - (Scen_PieceDesc *) game_loadExtData(pictDescId, 0, + (PieceDesc *) _vm->_game->loadExtData(pictDescId, 0, 0); ptr->piecesFromExt[i] = 1; } else { ptr->pieces[i] = - (Scen_PieceDesc *) - game_loadTotResource(pictDescId); + (PieceDesc *) + _vm->_game->loadTotResource(pictDescId); ptr->piecesFromExt[i] = 0; } - width = inter_load16(); - height = inter_load16(); - sprResId = inter_load16(); + width = _vm->_inter->load16(); + height = _vm->_inter->load16(); + sprResId = _vm->_inter->load16(); for (sprIndex = 0; sprIndex < 20; sprIndex++) { - if (scen_spriteResId[sprIndex] == sprResId) + if (spriteResId[sprIndex] == sprResId) break; } if (sprIndex < 20) { - scen_animPictToSprite[7 * sceneryIndex + i] = sprIndex; - scen_spriteRefs[sprIndex]++; + animPictToSprite[7 * sceneryIndex + i] = sprIndex; + spriteRefs[sprIndex]++; } else { - for (sprIndex = 19; draw_spritesArray[sprIndex] != 0; + for (sprIndex = 19; _vm->_draw->spritesArray[sprIndex] != 0; sprIndex--); - scen_animPictToSprite[7 * sceneryIndex + i] = sprIndex; - scen_spriteRefs[sprIndex] = 1; - scen_spriteResId[sprIndex] = sprResId; - draw_spritesArray[sprIndex] = - vid_initSurfDesc(videoMode, width, height, 2); - - vid_clearSurf(draw_spritesArray[sprIndex]); - draw_destSurface = sprIndex; - draw_spriteLeft = sprResId; - draw_transparency = 0; - draw_destSpriteX = 0; - draw_destSpriteY = 0; - draw_spriteOperation(DRAW_LOADSPRITE); + animPictToSprite[7 * sceneryIndex + i] = sprIndex; + spriteRefs[sprIndex] = 1; + spriteResId[sprIndex] = sprResId; + _vm->_draw->spritesArray[sprIndex] = + _vm->_video->initSurfDesc(_vm->_global->videoMode, width, height, 2); + + _vm->_video->clearSurf(_vm->_draw->spritesArray[sprIndex]); + _vm->_draw->destSurface = sprIndex; + _vm->_draw->spriteLeft = sprResId; + _vm->_draw->transparency = 0; + _vm->_draw->destSpriteX = 0; + _vm->_draw->destSpriteY = 0; + _vm->_draw->spriteOperation(DRAW_LOADSPRITE); } } return sceneryIndex + 100; @@ -500,11 +504,11 @@ int16 scen_loadAnim(char search) { // flags & 4 == 0 - calculate animation final size // flags & 2 != 0 - don't check with "toRedraw"'s // flags & 4 != 0 - checkk view toRedraw -void scen_updateAnim(int16 layer, int16 frame, int16 animation, int16 flags, +void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags, int16 drawDeltaX, int16 drawDeltaY, char doDraw) { - Scen_AnimLayer *layerPtr; - Scen_PieceDesc **pictPtr; - Scen_AnimFramePiece *framePtr; + AnimLayer *layerPtr; + PieceDesc **pictPtr; + AnimFramePiece *framePtr; uint16 pieceIndex; uint16 pictIndex; @@ -523,29 +527,29 @@ void scen_updateAnim(int16 layer, int16 frame, int16 animation, int16 flags, int16 destX; int16 destY; - if (layer >= scen_animations[animation].layersCount) + if (layer >= animations[animation].layersCount) return; - layerPtr = scen_animations[animation].layers[layer]; + layerPtr = animations[animation].layers[layer]; if (frame >= layerPtr->framesCount) return; if (flags & 1) // Do capture { - scen_updateAnim(layer, frame, animation, 0, drawDeltaX, + updateAnim(layer, frame, animation, 0, drawDeltaX, drawDeltaY, 0); - if (scen_toRedrawLeft == -12345) // Some magic number? + if (toRedrawLeft == -12345) // Some magic number? return; - game_capturePush(scen_toRedrawLeft, scen_toRedrawTop, - scen_toRedrawRight - scen_toRedrawLeft + 1, - scen_toRedrawBottom - scen_toRedrawTop + 1); + _vm->_game->capturePush(toRedrawLeft, toRedrawTop, + toRedrawRight - toRedrawLeft + 1, + toRedrawBottom - toRedrawTop + 1); - *scen_pCaptureCounter = *scen_pCaptureCounter + 1; + *pCaptureCounter = *pCaptureCounter + 1; } - pictPtr = scen_animations[animation].pieces; + pictPtr = animations[animation].pieces; framePtr = layerPtr->frames; for (i = 0; i < frame; i++, framePtr++) { @@ -554,18 +558,18 @@ void scen_updateAnim(int16 layer, int16 frame, int16 animation, int16 flags, } if ((flags & 4) == 0) { - scen_toRedrawLeft = -12345; + toRedrawLeft = -12345; } else { - scen_toRedrawLeft = - MAX(scen_toRedrawLeft, anim_animAreaLeft); - scen_toRedrawTop = - MAX(scen_toRedrawTop, anim_animAreaTop); - scen_toRedrawRight = - MIN(scen_toRedrawRight, - (int16)(anim_animAreaLeft + anim_animAreaWidth - 1)); - scen_toRedrawBottom = - MIN(scen_toRedrawBottom, - (int16)(anim_animAreaTop + anim_animAreaHeight - 1)); + toRedrawLeft = + MAX(toRedrawLeft, _vm->_anim->_areaLeft); + toRedrawTop = + MAX(toRedrawTop, _vm->_anim->_areaTop); + toRedrawRight = + MIN(toRedrawRight, + (int16)(_vm->_anim->_areaLeft + _vm->_anim->_areaWidth - 1)); + toRedrawBottom = + MIN(toRedrawBottom, + (int16)(_vm->_anim->_areaTop + _vm->_anim->_areaHeight - 1)); } transp = layerPtr->transp ? 3 : 0; @@ -612,131 +616,131 @@ void scen_updateAnim(int16 layer, int16 frame, int16 animation, int16 flags, bottom = FROM_LE_16(pictPtr[pictIndex][pieceIndex].bottom); if (flags & 2) { - if (destX < anim_animAreaLeft) { - left += anim_animAreaLeft - destX; - destX = anim_animAreaLeft; + if (destX < _vm->_anim->_areaLeft) { + left += _vm->_anim->_areaLeft - destX; + destX = _vm->_anim->_areaLeft; } if (left <= right && destX + right - left >= - anim_animAreaLeft + anim_animAreaWidth) + _vm->_anim->_areaLeft + _vm->_anim->_areaWidth) right -= (destX + right - left) - - (anim_animAreaLeft + anim_animAreaWidth) + + (_vm->_anim->_areaLeft + _vm->_anim->_areaWidth) + 1; - if (destY < anim_animAreaTop) { - top += anim_animAreaTop - destY; - destY = anim_animAreaTop; + if (destY < _vm->_anim->_areaTop) { + top += _vm->_anim->_areaTop - destY; + destY = _vm->_anim->_areaTop; } if (top <= bottom && destY + bottom - top >= - anim_animAreaTop + anim_animAreaHeight) + _vm->_anim->_areaTop + _vm->_anim->_areaHeight) bottom -= (destY + bottom - top) - - (anim_animAreaTop + anim_animAreaHeight) + + (_vm->_anim->_areaTop + _vm->_anim->_areaHeight) + 1; } else if (flags & 4) { - if (destX < scen_toRedrawLeft) { - left += scen_toRedrawLeft - destX; - destX = scen_toRedrawLeft; + if (destX < toRedrawLeft) { + left += toRedrawLeft - destX; + destX = toRedrawLeft; } if (left <= right - && destX + right - left > scen_toRedrawRight) + && destX + right - left > toRedrawRight) right -= - destX + right - left - scen_toRedrawRight; + destX + right - left - toRedrawRight; - if (destY < scen_toRedrawTop) { - top += scen_toRedrawTop - destY; - destY = scen_toRedrawTop; + if (destY < toRedrawTop) { + top += toRedrawTop - destY; + destY = toRedrawTop; } if (top <= bottom - && destY + bottom - top > scen_toRedrawBottom) + && destY + bottom - top > toRedrawBottom) bottom -= - destY + bottom - top - scen_toRedrawBottom; + destY + bottom - top - toRedrawBottom; } if (left > right || top > bottom) continue; if (doDraw) { - draw_sourceSurface = - scen_animPictToSprite[animation * 7 + pictIndex]; - draw_destSurface = 21; - - draw_spriteLeft = left; - draw_spriteTop = top; - draw_spriteRight = right - left + 1; - draw_spriteBottom = bottom - top + 1; - draw_destSpriteX = destX; - draw_destSpriteY = destY; - draw_transparency = transp; - draw_spriteOperation(DRAW_BLITSURF); + _vm->_draw->sourceSurface = + animPictToSprite[animation * 7 + pictIndex]; + _vm->_draw->destSurface = 21; + + _vm->_draw->spriteLeft = left; + _vm->_draw->spriteTop = top; + _vm->_draw->spriteRight = right - left + 1; + _vm->_draw->spriteBottom = bottom - top + 1; + _vm->_draw->destSpriteX = destX; + _vm->_draw->destSpriteY = destY; + _vm->_draw->transparency = transp; + _vm->_draw->spriteOperation(DRAW_BLITSURF); } if ((flags & 4) == 0) { - if (scen_toRedrawLeft == -12345) { - scen_toRedrawLeft = destX; - scen_animLeft = destX; - scen_toRedrawTop = destY; - scen_animTop = destY; - scen_toRedrawRight = destX + right - left; - scen_toRedrawBottom = destY + bottom - top; + if (toRedrawLeft == -12345) { + toRedrawLeft = destX; + animLeft = destX; + toRedrawTop = destY; + animTop = destY; + toRedrawRight = destX + right - left; + toRedrawBottom = destY + bottom - top; } else { - scen_toRedrawLeft = - MIN(scen_toRedrawLeft, destX); - scen_toRedrawTop = - MIN(scen_toRedrawTop, destY); - scen_toRedrawRight = - MAX(scen_toRedrawRight, + toRedrawLeft = + MIN(toRedrawLeft, destX); + toRedrawTop = + MIN(toRedrawTop, destY); + toRedrawRight = + MAX(toRedrawRight, (int16)(destX + right - left)); - scen_toRedrawBottom = - MAX(scen_toRedrawBottom, + toRedrawBottom = + MAX(toRedrawBottom, (int16)(destY + bottom - top)); } } } while (framePtr->notFinal == 1); } -void scen_freeAnim(int16 animation) { +void Scenery::freeAnim(int16 animation) { int16 i; int16 spr; if (animation == -1) - inter_evalExpr(&animation); + _vm->_inter->evalExpr(&animation); - if (scen_animPictCount[animation] == 0) + if (animPictCount[animation] == 0) return; - for (i = 0; i < scen_animPictCount[animation]; i++) { - if (scen_animations[animation].piecesFromExt[i] == 1) - free(scen_animations[animation].pieces[i]); + for (i = 0; i < animPictCount[animation]; i++) { + if (animations[animation].piecesFromExt[i] == 1) + free(animations[animation].pieces[i]); - spr = scen_animPictToSprite[animation * 7 + i]; - scen_spriteRefs[spr]--; - if (scen_spriteRefs[spr] == 0) { - vid_freeSurfDesc(draw_spritesArray[spr]); + spr = animPictToSprite[animation * 7 + i]; + spriteRefs[spr]--; + if (spriteRefs[spr] == 0) { + _vm->_video->freeSurfDesc(_vm->_draw->spritesArray[spr]); - draw_spritesArray[spr] = 0; - scen_spriteResId[spr] = -1; + _vm->_draw->spritesArray[spr] = 0; + spriteResId[spr] = -1; } } - free(scen_animations[animation].layers); - free(scen_animations[animation].pieces); - free(scen_animations[animation].piecesFromExt); - if (scen_animFromExt[animation] == 1) - free(scen_animations[animation].dataPtr); + free(animations[animation].layers); + free(animations[animation].pieces); + free(animations[animation].piecesFromExt); + if (animFromExt[animation] == 1) + free(animations[animation].dataPtr); - scen_animFromExt[animation] = 0; - scen_animPictCount[animation] = 0; + animFromExt[animation] = 0; + animPictCount[animation] = 0; } -void scen_interUpdateAnim(void) { +void Scenery::interUpdateAnim(void) { int16 deltaX; int16 deltaY; int16 flags; @@ -744,37 +748,37 @@ void scen_interUpdateAnim(void) { int16 layer; int16 animation; - inter_evalExpr(&deltaX); - inter_evalExpr(&deltaY); - inter_evalExpr(&animation); - inter_evalExpr(&layer); - inter_evalExpr(&frame); - flags = inter_load16(); - scen_updateAnim(layer, frame, animation, flags, deltaX, deltaY, 1); + _vm->_inter->evalExpr(&deltaX); + _vm->_inter->evalExpr(&deltaY); + _vm->_inter->evalExpr(&animation); + _vm->_inter->evalExpr(&layer); + _vm->_inter->evalExpr(&frame); + flags = _vm->_inter->load16(); + updateAnim(layer, frame, animation, flags, deltaX, deltaY, 1); } -void scen_interStoreParams(void) { - Scen_AnimLayer *layerPtr; +void Scenery::interStoreParams(void) { + AnimLayer *layerPtr; int16 animation; int16 layer; int16 var; - warning("scen_interStoreParams: Storing..."); + warning("interStoreParams: Storing..."); - inter_evalExpr(&animation); - inter_evalExpr(&layer); - layerPtr = scen_animations[animation].layers[layer]; + _vm->_inter->evalExpr(&animation); + _vm->_inter->evalExpr(&layer); + layerPtr = animations[animation].layers[layer]; - var = parse_parseVarIndex(); + var = _vm->_parse->parseVarIndex(); WRITE_VAR_OFFSET(var, layerPtr->animDeltaX); - var = parse_parseVarIndex(); + var = _vm->_parse->parseVarIndex(); WRITE_VAR_OFFSET(var, layerPtr->animDeltaY); - var = parse_parseVarIndex(); + var = _vm->_parse->parseVarIndex(); WRITE_VAR_OFFSET(var, layerPtr->unknown0); - var = parse_parseVarIndex(); + var = _vm->_parse->parseVarIndex(); WRITE_VAR_OFFSET(var, layerPtr->framesCount); } diff --git a/gob/scenery.h b/gob/scenery.h index 8b9b50d7ba..b80ed118cb 100644 --- a/gob/scenery.h +++ b/gob/scenery.h @@ -24,112 +24,124 @@ namespace Gob { +class Scenery { +public: #pragma START_PACK_STRUCTS -typedef struct Scen_PieceDesc { - int16 left; //NOTE: - int16 right; //These are stored in Little Endian format - int16 top; //And should be converted by client code when accessed - int16 bottom; //i.e. use FROM_LE_16() -} GCC_PACK Scen_PieceDesc; - -typedef struct Scen_StaticPlane { - int8 pictIndex; - int8 pieceIndex; - int8 drawOrder; - int16 destX; - int16 destY; - int8 transp; -} GCC_PACK Scen_StaticPlane; - -typedef struct Scen_StaticLayer { - int16 backResId; - int16 planeCount; - Scen_StaticPlane planes[1]; -} GCC_PACK Scen_StaticLayer; - -// Animations - -typedef struct Scen_AnimFramePiece { - byte pictIndex; - byte pieceIndex; - int8 destX; - int8 destY; - int8 notFinal; -} GCC_PACK Scen_AnimFramePiece; - -typedef struct Scen_AnimLayer { - int16 unknown0; - int16 posX; - int16 posY; - int16 animDeltaX; - int16 animDeltaY; - int8 transp; - int16 framesCount; - Scen_AnimFramePiece frames[1]; -} GCC_PACK Scen_AnimLayer; + typedef struct PieceDesc { + int16 left; //NOTE: + int16 right; //These are stored in Little Endian format + int16 top; //And should be converted by client code when accessed + int16 bottom; //i.e. use FROM_LE_16() + } GCC_PACK PieceDesc; + + typedef struct StaticPlane { + int8 pictIndex; + int8 pieceIndex; + int8 drawOrder; + int16 destX; + int16 destY; + int8 transp; + } GCC_PACK StaticPlane; + + typedef struct StaticLayer { + int16 backResId; + int16 planeCount; + StaticPlane planes[1]; + } GCC_PACK StaticLayer; + + // Animations + + typedef struct AnimFramePiece { + byte pictIndex; + byte pieceIndex; + int8 destX; + int8 destY; + int8 notFinal; + } GCC_PACK AnimFramePiece; + + typedef struct AnimLayer { + int16 unknown0; + int16 posX; + int16 posY; + int16 animDeltaX; + int16 animDeltaY; + int8 transp; + int16 framesCount; + AnimFramePiece frames[1]; + } GCC_PACK AnimLayer; #pragma END_PACK_STRUCTS -typedef struct Scen_Static { - int16 layersCount; - Scen_StaticLayer **layers; - Scen_PieceDesc **pieces; - int8 *piecesFromExt; - char *dataPtr; -} Scen_Static; - -struct Scen_Animation { - int16 layersCount; - Scen_AnimLayer **layers; - Scen_PieceDesc **pieces; - int8 *piecesFromExt; - char *dataPtr; + typedef struct Static { + int16 layersCount; + StaticLayer **layers; + PieceDesc **pieces; + int8 *piecesFromExt; + char *dataPtr; + Static() : layersCount(0), layers(0), pieces(0), + piecesFromExt(0), dataPtr(0) {} + } Static; + + struct Animation { + int16 layersCount; + AnimLayer **layers; + PieceDesc **pieces; + int8 *piecesFromExt; + char *dataPtr; + Animation() : layersCount(0), layers(0), pieces(0), + piecesFromExt(0), dataPtr(0) {} + }; + + // Global variables + + char spriteRefs[20]; + int16 spriteResId[20]; + + char staticPictToSprite[70]; + int16 staticPictCount[10]; + Static statics[10]; + char staticFromExt[10]; + int16 staticResId[10]; + + char animPictToSprite[70]; + int16 animPictCount[10]; + char animFromExt[10]; + Animation animations[10]; + int16 animResId[10]; + + int16 curStatic; + int16 curStaticLayer; + + int16 toRedrawLeft; + int16 toRedrawRight; + int16 toRedrawTop; + int16 toRedrawBottom; + + int16 animTop; + int16 animLeft; + + int16 *pCaptureCounter; + + // Functions + + int16 loadStatic(char search); + void freeStatic(int16 index); + void renderStatic(int16 scenery, int16 layer); + void interRenderStatic(void); + void interLoadCurLayer(void); + void updateStatic(int16 orderFrom); + int16 loadAnim(char search); + void updateAnim(int16 layer, int16 frame, int16 animation, int16 flags, + int16 drawDeltaX, int16 drawDeltaY, char doDraw); + void freeAnim(int16 animation); + void interUpdateAnim(void); + void interStoreParams(void); + + Scenery(GobEngine *vm); + +protected: + GobEngine *_vm; }; -// Global variables - -extern char scen_spriteRefs[20]; -extern int16 scen_spriteResId[20]; - -extern char scen_staticPictToSprite[70]; -extern int16 scen_staticPictCount[10]; -extern Scen_Static scen_statics[10]; -extern char scen_staticFromExt[10]; -extern int16 scen_staticResId[10]; - -extern char scen_animPictToSprite[70]; -extern int16 scen_animPictCount[10]; -extern char scen_animFromExt[10]; -extern Scen_Animation scen_animations[10]; -extern int16 scen_animResId[10]; - -extern int16 scen_curStatic; -extern int16 scen_curStaticLayer; - -extern int16 scen_toRedrawLeft; -extern int16 scen_toRedrawRight; -extern int16 scen_toRedrawTop; -extern int16 scen_toRedrawBottom; - -extern int16 scen_animTop; -extern int16 scen_animLeft; - -extern int16 *scen_pCaptureCounter; - -// Functions - -int16 scen_loadStatic(char search); -void scen_freeStatic(int16 index); -void scen_renderStatic(int16 scenery, int16 layer); -void scen_interRenderStatic(void); -void scen_interLoadCurLayer(void); -void scen_updateStatic(int16 orderFrom); -int16 scen_loadAnim(char search); -void scen_updateAnim(int16 layer, int16 frame, int16 animation, int16 flags, - int16 drawDeltaX, int16 drawDeltaY, char doDraw); -void scen_freeAnim(int16 animation); -void scen_interUpdateAnim(void); -void scen_interStoreParams(void); - } // End of namespace Gob #endif /* __SCENERY_H */ diff --git a/gob/sound.cpp b/gob/sound.cpp index bd6e3ca42f..3b287badf8 100644 --- a/gob/sound.cpp +++ b/gob/sound.cpp @@ -20,41 +20,14 @@ * */ -#include "sound/audiostream.h" - #include "gob/gob.h" #include "gob/global.h" #include "gob/sound.h" namespace Gob { -// TODO: This is a very primitive square wave generator. The only thing is -// has in common with the PC speaker is that it sounds terrible. - -class SquareWaveStream : public AudioStream { -private: - uint _rate; - bool _beepForever; - uint32 _periodLength; - uint32 _periodSamples; - uint32 _remainingSamples; - int16 _sampleValue; - -public: - SquareWaveStream() {} - ~SquareWaveStream() {} - - void playNote(int freq, int32 ms); - - int readBuffer(int16 *buffer, const int numSamples); - - bool endOfData() const { return _remainingSamples == 0; } - bool isStereo() const { return false; } - int getRate() const { return _rate; } -}; - -void SquareWaveStream::playNote(int freq, int32 ms) { - _rate = _vm->_mixer->getOutputRate(); +void Snd::SquareWaveStream::playNote(int freq, int32 ms, uint rate) { + _rate = rate; _periodLength = _rate / (2 * freq); _periodSamples = 0; _sampleValue = 6000; @@ -67,7 +40,7 @@ void SquareWaveStream::playNote(int freq, int32 ms) { } } -int SquareWaveStream::readBuffer(int16 *buffer, const int numSamples) { +int Snd::SquareWaveStream::readBuffer(int16 *buffer, const int numSamples) { int samples = 0; while (samples < numSamples && _remainingSamples > 0) { @@ -84,48 +57,42 @@ int SquareWaveStream::readBuffer(int16 *buffer, const int numSamples) { return samples; } -SquareWaveStream speakerStream; -Audio::SoundHandle speakerHandle; -Snd_SoundDesc *snd_loopingSounds[5]; // Should be enough - -void snd_initSound(void) { - for (int i = 0; i < ARRAYSIZE(snd_loopingSounds); i++) - snd_loopingSounds[i] = NULL; +Snd::Snd(GobEngine *vm) : _vm(vm) { + //CleanupFuncPtr cleanupFunc;// = &snd_cleanupFuncCallback(); + cleanupFunc = 0; + for (int i = 0; i < ARRAYSIZE(loopingSounds); i++) + loopingSounds[i] = NULL; + soundPort = 0; + playingSound = 0; } -void snd_loopSounds(void) { - for (int i = 0; i < ARRAYSIZE(snd_loopingSounds); i++) { - Snd_SoundDesc *snd = snd_loopingSounds[i]; +void Snd::loopSounds(void) { + for (int i = 0; i < ARRAYSIZE(loopingSounds); i++) { + SoundDesc *snd = loopingSounds[i]; if (snd && !_vm->_mixer->isSoundHandleActive(snd->handle)) { if (snd->repCount-- > 0) { _vm->_mixer->playRaw(&snd->handle, snd->data, snd->size, snd->frequency, 0); } else { - snd_loopingSounds[i] = NULL; + loopingSounds[i] = NULL; } } } } -int16 snd_checkProAudio(void) {return 0;} -int16 snd_checkAdlib(void) {return 0;} -int16 snd_checkBlaster(void) {return 0;} -void snd_setBlasterPort(int16 port) {return;} +void Snd::setBlasterPort(int16 port) {return;} -void snd_speakerOn(int16 frequency, int32 length) { - speakerStream.playNote(frequency, length); +void Snd::speakerOn(int16 frequency, int32 length) { + speakerStream.playNote(frequency, length, _vm->_mixer->getOutputRate()); if (!_vm->_mixer->isSoundHandleActive(speakerHandle)) { _vm->_mixer->playInputStream(Audio::Mixer::kSFXSoundType, &speakerHandle, &speakerStream, -1, 255, 0, false); } } -void snd_speakerOff(void) { +void Snd::speakerOff(void) { _vm->_mixer->stopHandle(speakerHandle); } -void snd_stopSound(int16 arg){return;} -void snd_setResetTimerFlag(char flag){return;} - -void snd_playSample(Snd_SoundDesc *sndDesc, int16 repCount, int16 frequency) { +void Snd::playSample(Snd::SoundDesc *sndDesc, int16 repCount, int16 frequency) { assert(frequency > 0); if (!_vm->_mixer->isSoundHandleActive(sndDesc->handle)) { @@ -136,9 +103,9 @@ void snd_playSample(Snd_SoundDesc *sndDesc, int16 repCount, int16 frequency) { sndDesc->frequency = frequency; if (repCount > 1) { - for (int i = 0; i < ARRAYSIZE(snd_loopingSounds); i++) { - if (!snd_loopingSounds[i]) { - snd_loopingSounds[i] = sndDesc; + for (int i = 0; i < ARRAYSIZE(loopingSounds); i++) { + if (!loopingSounds[i]) { + loopingSounds[i] = sndDesc; return; } } @@ -146,44 +113,34 @@ void snd_playSample(Snd_SoundDesc *sndDesc, int16 repCount, int16 frequency) { } } -void snd_cleanupFuncCallback() {;} -CleanupFuncPtr (snd_cleanupFunc); -//CleanupFuncPtr snd_cleanupFunc;// = &snd_cleanupFuncCallback(); - -int16 snd_soundPort; -char snd_playingSound; - -void snd_writeAdlib(int16 port, int16 data) { +void Snd::writeAdlib(int16 port, int16 data) { return; } -Snd_SoundDesc *snd_loadSoundData(const char *path) { - Snd_SoundDesc *sndDesc; +Snd::SoundDesc *Snd::loadSoundData(const char *path) { + Snd::SoundDesc *sndDesc; int32 size; - size = data_getDataSize(path); - sndDesc = (Snd_SoundDesc *)malloc(size); + size = _vm->_dataio->getDataSize(path); + sndDesc = (Snd::SoundDesc *)malloc(size); sndDesc->size = size; - sndDesc->data = data_getData(path); + sndDesc->data = _vm->_dataio->getData(path); return sndDesc; } -void snd_freeSoundData(Snd_SoundDesc *sndDesc) { +void Snd::freeSoundData(Snd::SoundDesc *sndDesc) { _vm->_mixer->stopHandle(sndDesc->handle); - for (int i = 0; i < ARRAYSIZE(snd_loopingSounds); i++) { - if (snd_loopingSounds[i] == sndDesc) - snd_loopingSounds[i] = NULL; + for (int i = 0; i < ARRAYSIZE(loopingSounds); i++) { + if (loopingSounds[i] == sndDesc) + loopingSounds[i] = NULL; } free(sndDesc->data); free(sndDesc); } -void snd_playComposition(Snd_SoundDesc ** samples, int16 *composit, int16 freqVal) {;} -void snd_waitEndPlay(void) {;} - } // End of namespace Gob diff --git a/gob/sound.h b/gob/sound.h index 4b947c5317..60750874f4 100644 --- a/gob/sound.h +++ b/gob/sound.h @@ -22,43 +22,82 @@ #ifndef GOB_SOUND_H #define GOB_SOUND_H +#include "sound/audiostream.h" + namespace Gob { -void snd_initSound(void); -void snd_loopSounds(void); -int16 snd_checkProAudio(void); -int16 snd_checkAdlib(void); -int16 snd_checkBlaster(void); -void snd_setBlasterPort(int16 port); -void snd_speakerOn(int16 frequency, int32 length); -void snd_speakerOff(void); -void snd_stopSound(int16 arg); -void snd_setResetTimerFlag(char flag); - -extern int16 snd_soundPort; -extern char snd_playingSound; - -typedef void (*CleanupFuncPtr) (int16); -extern CleanupFuncPtr snd_cleanupFunc; - -void snd_writeAdlib(int16 port, int16 data); - -typedef struct Snd_SoundDesc { - Audio::SoundHandle handle; - char *data; - int32 size; - int16 repCount; - int16 timerTicks; - int16 inClocks; - int16 frequency; - int16 flag; -} Snd_SoundDesc; - -void snd_playSample(Snd_SoundDesc *sndDesc, int16 repCount, int16 frequency); -Snd_SoundDesc *snd_loadSoundData(const char *path); -void snd_freeSoundData(Snd_SoundDesc *sndDesc); -void snd_playComposition(Snd_SoundDesc **samples, int16 *composit, int16 freqVal); -void snd_waitEndPlay(void); +class Snd { +public: + typedef struct SoundDesc { + Audio::SoundHandle handle; + char *data; + int32 size; + int16 repCount; + int16 timerTicks; + int16 inClocks; + int16 frequency; + int16 flag; + SoundDesc() : data(0), size(0), repCount(0), timerTicks(0), + inClocks(0), frequency(0), flag(0) {} + } SoundDesc; + + typedef void (*CleanupFuncPtr) (int16); + + SoundDesc *loopingSounds[5]; // Should be enough + int16 soundPort; + char playingSound; + CleanupFuncPtr cleanupFunc; + + Snd(GobEngine *vm); + void speakerOn(int16 frequency, int32 length); + void speakerOff(void); + SoundDesc *loadSoundData(const char *path); + void stopSound(int16 arg){return;} + void loopSounds(void); + void playSample(SoundDesc *sndDesc, int16 repCount, int16 frequency); + void playComposition(Snd::SoundDesc ** samples, int16 *composit, int16 freqVal) {;} + void waitEndPlay(void) {;} + void freeSoundData(SoundDesc *sndDesc); + +protected: + // TODO: This is a very primitive square wave generator. The only thing is + // has in common with the PC speaker is that it sounds terrible. + class SquareWaveStream : public AudioStream { + private: + uint _rate; + bool _beepForever; + uint32 _periodLength; + uint32 _periodSamples; + uint32 _remainingSamples; + int16 _sampleValue; + + public: + SquareWaveStream() {} + ~SquareWaveStream() {} + + void playNote(int freq, int32 ms, uint rate); + + int readBuffer(int16 *buffer, const int numSamples); + + bool endOfData() const { return _remainingSamples == 0; } + bool isStereo() const { return false; } + int getRate() const { return _rate; } + }; + + SquareWaveStream speakerStream; + Audio::SoundHandle speakerHandle; + + GobEngine *_vm; + + void cleanupFuncCallback() {;} + int16 checkProAudio(void) {return 0;} + int16 checkAdlib(void) {return 0;} + int16 checkBlaster(void) {return 0;} + + void writeAdlib(int16 port, int16 data); + void setBlasterPort(int16 port); + void setResetTimerFlag(char flag){return;} +}; } // End of namespace Gob diff --git a/gob/timer.cpp b/gob/timer.cpp index 1c5987d2e9..c7487f1156 100644 --- a/gob/timer.cpp +++ b/gob/timer.cpp @@ -22,13 +22,15 @@ #include "gob/gob.h" #include "gob/global.h" #include "gob/sound.h" +#include "gob/timer.h" + namespace Gob { -void timer_enableTimer() { - debug(4, "STUB: timer_enableTimer()"); +void GTimer::enableTimer() { + debug(4, "STUB: GTimer::enableTimer()"); } -void timer_disableTimer() { - debug(4, "STUB: timer_disableTimer()"); +void GTimer::disableTimer() { + debug(4, "STUB: GTimer::disableTimer()"); } } diff --git a/gob/timer.h b/gob/timer.h index ca0a8b49b3..5b7e77c2b4 100644 --- a/gob/timer.h +++ b/gob/timer.h @@ -24,15 +24,18 @@ namespace Gob { -typedef void (* TickHandler) (void); +class GTimer { +public: + typedef void (* TickHandler) (void); -void timer_enableTimer(void); -void timer_disableTimer(void); -void timer_setHandler(void); -void timer_restoreHandler(void); -void timer_addTicks(int16 ticks); -void timer_setTickHandler(TickHandler handler); -int32 timer_getTicks(void); + void enableTimer(void); + void disableTimer(void); + void setHandler(void); + void restoreHandler(void); + void addTicks(int16 ticks); + void setTickHandler(TickHandler handler); + int32 getTicks(void); +}; } // End of namespace Gob diff --git a/gob/util.cpp b/gob/util.cpp index ace32c8fac..7d5b574b97 100644 --- a/gob/util.cpp +++ b/gob/util.cpp @@ -28,47 +28,52 @@ namespace Gob { -static const int kKeyBufSize = 16; - -static int16 _mouseX, _mouseY, _mouseButtons; -static int16 _keyBuffer[kKeyBufSize], _keyBufferHead, _keyBufferTail; - -static void addKeyToBuffer(int16 key) { - if ((_keyBufferHead + 1) % kKeyBufSize == _keyBufferTail) { +Util::Util(GobEngine *vm) : _vm(vm) { + _mouseX = 0; + _mouseY = 0; + _mouseButtons = 0; + for (int i = 0; i < KEYBUFSIZE; i++) + _keyBuffer[i] = 0; + _keyBufferHead = 0; + _keyBufferTail = 0; +} + +void Util::addKeyToBuffer(int16 key) { + if ((_keyBufferHead + 1) % KEYBUFSIZE == _keyBufferTail) { warning("key buffer overflow!"); return; } _keyBuffer[_keyBufferHead] = key; - _keyBufferHead = (_keyBufferHead + 1) % kKeyBufSize; + _keyBufferHead = (_keyBufferHead + 1) % KEYBUFSIZE; } -static bool keyBufferEmpty() { +bool Util::keyBufferEmpty() { return (_keyBufferHead == _keyBufferTail); } -static bool getKeyFromBuffer(int16& key) { +bool Util::getKeyFromBuffer(int16& key) { if (_keyBufferHead == _keyBufferTail) return false; key = _keyBuffer[_keyBufferTail]; - _keyBufferTail = (_keyBufferTail + 1) % kKeyBufSize; + _keyBufferTail = (_keyBufferTail + 1) % KEYBUFSIZE; return true; } -void util_initInput(void) { +void Util::initInput(void) { _mouseX = _mouseY = _mouseButtons = 0; _keyBufferHead = _keyBufferTail = 0; } -void util_waitKey(void) { +void Util::waitKey(void) { // FIXME: wrong function name? This functions clears the keyboard buffer. - util_processInput(); + processInput(); _keyBufferHead = _keyBufferTail = 0; } -int16 util_translateKey(int16 key) { +int16 Util::translateKey(int16 key) { struct keyS { int16 from; int16 to; @@ -104,32 +109,32 @@ int16 util_translateKey(int16 key) { return key; } -int16 util_getKey(void) { +int16 Util::getKey(void) { int16 key; while (!getKeyFromBuffer(key)) { - util_processInput(); + processInput(); if (keyBufferEmpty()) g_system->delayMillis(10); } - return util_translateKey(key); + return translateKey(key); } -int16 util_checkKey(void) { +int16 Util::checkKey(void) { int16 key; if (!getKeyFromBuffer(key)) key = 0; - return util_translateKey(key); + return translateKey(key); } -int16 util_getRandom(int16 max) { +int16 Util::getRandom(int16 max) { return _vm->_rnd.getRandomNumber(max - 1); } -void util_processInput() { +void Util::processInput() { OSystem::Event event; while (g_system->pollEvent(event)) { switch (event.type) { @@ -163,7 +168,7 @@ void util_processInput() { } } -void util_getMouseState(int16 *pX, int16 *pY, int16 *pButtons) { +void Util::getMouseState(int16 *pX, int16 *pY, int16 *pButtons) { *pX = _mouseX; *pY = _mouseY; @@ -171,91 +176,90 @@ void util_getMouseState(int16 *pX, int16 *pY, int16 *pButtons) { *pButtons = _mouseButtons; } -void util_setMousePos(int16 x, int16 y) { +void Util::setMousePos(int16 x, int16 y) { g_system->warpMouse(x, y); } -void util_longDelay(uint16 msecs) -{ +void Util::longDelay(uint16 msecs) { uint32 time = g_system->getMillis() + msecs; do { - vid_waitRetrace(videoMode); - util_processInput(); - util_delay(25); + _vm->_video->waitRetrace(_vm->_global->videoMode); + processInput(); + delay(25); } while (g_system->getMillis() < time); } -void util_delay(uint16 msecs) { +void Util::delay(uint16 msecs) { g_system->delayMillis(msecs); } -void util_beep(int16 freq) { - if (soundFlags == 0) +void Util::beep(int16 freq) { + if (_vm->_global->soundFlags == 0) return; - snd_speakerOn(freq, 50); + _vm->_snd->speakerOn(freq, 50); } -uint32 util_getTimeKey(void) { +uint32 Util::getTimeKey(void) { return g_system->getMillis(); } -void util_waitMouseUp(void) { +void Util::waitMouseUp(void) { int16 x; int16 y; int16 buttons; do { - util_processInput(); - util_getMouseState(&x, &y, &buttons); - if (buttons != 0) util_delay(10); + processInput(); + getMouseState(&x, &y, &buttons); + if (buttons != 0) delay(10); } while (buttons != 0); } -void util_waitMouseDown(void) { +void Util::waitMouseDown(void) { int16 x; int16 y; int16 buttons; do { - util_processInput(); - util_getMouseState(&x, &y, &buttons); - if (buttons == 0) util_delay(10); + processInput(); + getMouseState(&x, &y, &buttons); + if (buttons == 0) delay(10); } while (buttons == 0); } /* NOT IMPLEMENTED */ -int16 util_calcDelayTime() { +int16 Util::calcDelayTime() { return 0; } /* NOT IMPLEMENTED */ -void util_checkJoystick() { - useJoystick = 0; +void Util::checkJoystick() { + _vm->_global->useJoystick = 0; } -void util_setFrameRate(int16 rate) { +void Util::setFrameRate(int16 rate) { if (rate == 0) rate = 1; - frameWaitTime = 1000 / rate; - startFrameTime = util_getTimeKey(); + _vm->_global->frameWaitTime = 1000 / rate; + _vm->_global->startFrameTime = getTimeKey(); } -void util_waitEndFrame() { +void Util::waitEndFrame() { int32 time; - vid_waitRetrace(videoMode); + _vm->_video->waitRetrace(_vm->_global->videoMode); - time = util_getTimeKey() - startFrameTime; + time = getTimeKey() - _vm->_global->startFrameTime; if (time > 1000 || time < 0) { - startFrameTime = util_getTimeKey(); + _vm->_global->startFrameTime = getTimeKey(); return; } - if (frameWaitTime - time > 0) { - util_delay(frameWaitTime - time); + if (_vm->_global->frameWaitTime - time > 0) { + delay(_vm->_global->frameWaitTime - time); } - startFrameTime = util_getTimeKey(); + _vm->_global->startFrameTime = getTimeKey(); } int16 joy_getState() { @@ -266,14 +270,14 @@ int16 joy_calibrate() { return 0; } -FontDesc *util_loadFont(const char *path) { - FontDesc *fontDesc = (FontDesc *) malloc(sizeof(FontDesc)); +Video::FontDesc *Util::loadFont(const char *path) { + Video::FontDesc *fontDesc = (Video::FontDesc *) malloc(sizeof(Video::FontDesc)); char *data; if (fontDesc == 0) return 0; - data = data_getData(path); + data = _vm->_dataio->getData(path); if (data == 0) { free(fontDesc); return 0; @@ -298,20 +302,20 @@ FontDesc *util_loadFont(const char *path) { return fontDesc; } -void util_freeFont(FontDesc * fontDesc) { +void Util::freeFont(Video::FontDesc * fontDesc) { free(fontDesc->dataPtr - 4); free(fontDesc); } -void util_clearPalette(void) { +void Util::clearPalette(void) { int16 i; byte colors[768]; - if (videoMode != 0x13) - error("util_clearPalette: Video mode 0x%x is not supported!", - videoMode); + if (_vm->_global->videoMode != 0x13) + error("clearPalette: Video mode 0x%x is not supported!", + _vm->_global->videoMode); - if (setAllPalette) { + if (_vm->_global->setAllPalette) { for (i = 0; i < 768; i++) colors[i] = 0; g_system->setPalette(colors, 0, 256); @@ -320,10 +324,10 @@ void util_clearPalette(void) { } for (i = 0; i < 16; i++) - vid_setPalElem(i, 0, 0, 0, 0, videoMode); + _vm->_video->setPalElem(i, 0, 0, 0, 0, _vm->_global->videoMode); } -void util_insertStr(const char *str1, char *str2, int16 pos) { +void Util::insertStr(const char *str1, char *str2, int16 pos) { int16 len1; int16 i; int16 from; @@ -342,11 +346,11 @@ void util_insertStr(const char *str1, char *str2, int16 pos) { str2[i + from] = str1[i]; } -void util_cutFromStr(char *str, int16 from, int16 cutlen) { +void Util::cutFromStr(char *str, int16 from, int16 cutlen) { int16 len; int16 i; - //log_write("util_cutFromStr: str = %s, ", str); + //log_write("cutFromStr: str = %s, ", str); len = strlen(str); if (from >= len) return; @@ -364,12 +368,12 @@ void util_cutFromStr(char *str, int16 from, int16 cutlen) { //log_write("res = %s\n", str); } -int16 util_strstr(const char *str1, char *str2) { +int16 Util::strstr(const char *str1, char *str2) { char c; uint16 len1; uint16 i; - //log_write("util_strstr: str1 = %s, str2 = %s\n", str1, str2); + //log_write("strstr: str1 = %s, str2 = %s\n", str1, str2); for (i = 0, len1 = strlen(str1); strlen(str2 + i) >= len1; i++) { c = str2[i + len1]; @@ -383,10 +387,10 @@ int16 util_strstr(const char *str1, char *str2) { return 0; } -void util_listInsertFront(Util_List * list, void *data) { - Util_ListNode *node; +void Util::listInsertFront(List * list, void *data) { + ListNode *node; - node = (Util_ListNode *) malloc(sizeof(Util_ListNode)); + node = (ListNode *) malloc(sizeof(ListNode)); if (list->pHead != 0) { node->pData = data; node->pNext = list->pHead; @@ -402,28 +406,28 @@ void util_listInsertFront(Util_List * list, void *data) { } } -void util_listInsertBack(Util_List * list, void *data) { - Util_ListNode *node; +void Util::listInsertBack(List * list, void *data) { + ListNode *node; if (list->pHead != 0) { if (list->pTail == 0) { list->pTail = list->pHead; - warning("util_listInsertBack: Broken list!"); + warning("listInsertBack: Broken list!"); } node = - (Util_ListNode *) malloc(sizeof(Util_ListNode)); + (ListNode *) malloc(sizeof(ListNode)); node->pData = data; node->pPrev = list->pTail; node->pNext = 0; list->pTail->pNext = node; list->pTail = node; } else { - util_listInsertFront(list, data); + listInsertFront(list, data); } } -void util_listDropFront(Util_List * list) { +void Util::listDropFront(List * list) { if (list->pHead->pNext == 0) { free((list->pHead)); list->pHead = 0; @@ -435,50 +439,50 @@ void util_listDropFront(Util_List * list) { } } -void util_deleteList(Util_List * list) { +void Util::deleteList(List * list) { while (list->pHead != 0) { - util_listDropFront(list); + listDropFront(list); } free(list); } -char util_str1[] = +const char Util::trStr1[] = " ' + - :0123456789: <=> abcdefghijklmnopqrstuvwxyz abcdefghijklmnopqrstuvwxyz "; -char util_str2[] = +const char Util::trStr2[] = " ueaaaaceeeiii ooouu aioun "; -char util_str3[] = " "; +const char Util::trStr3[] = " "; -void util_prepareStr(char *str) { +void Util::prepareStr(char *str) { uint16 i; int16 j; char buf[300]; - strcpy(buf, util_str1); - strcat(buf, util_str2); - strcat(buf, util_str3); + strcpy(buf, trStr1); + strcat(buf, trStr2); + strcat(buf, trStr3); for (i = 0; i < strlen(str); i++) str[i] = buf[str[i] - 32]; while (str[0] == ' ') - util_cutFromStr(str, 0, 1); + cutFromStr(str, 0, 1); while (strlen(str) > 0 && str[strlen(str) - 1] == ' ') - util_cutFromStr(str, strlen(str) - 1, 1); + cutFromStr(str, strlen(str) - 1, 1); - i = util_strstr(" ", str); + i = strstr(" ", str); while (1) { if (i == 0) return; if (str[i] == ' ') { - util_cutFromStr(str, i - 1, 1); + cutFromStr(str, i - 1, 1); continue; } - j = util_strstr(" ", str + i); + j = strstr(" ", str + i); if (j != 0) i += j; else @@ -486,18 +490,18 @@ void util_prepareStr(char *str) { } } -void util_waitMouseRelease(char drawMouse) { +void Util::waitMouseRelease(char drawMouse) { int16 buttons; int16 mouseX; int16 mouseY; do { - game_checkKeys(&mouseX, &mouseY, &buttons, drawMouse); + _vm->_game->checkKeys(&mouseX, &mouseY, &buttons, drawMouse); if (drawMouse != 0) - draw_animateCursor(2); - util_delay(10); + _vm->_draw->animateCursor(2); + delay(10); } while (buttons != 0); } -void keyboard_release(void) {;} +void Util::keyboard_release(void) {;} } // End of namespace Gob diff --git a/gob/util.h b/gob/util.h index 2b63ff0f03..d3d76c47f8 100644 --- a/gob/util.h +++ b/gob/util.h @@ -26,57 +26,80 @@ namespace Gob { -struct Util_ListNode; -typedef struct Util_ListNode { - void *pData; - struct Util_ListNode *pNext; - struct Util_ListNode *pPrev; -} Util_ListNode; - -typedef struct Util_List { - Util_ListNode *pHead; - Util_ListNode *pTail; -} Util_List; - -void util_initInput(void); -void util_processInput(void); -void util_waitKey(void); -int16 util_getKey(void); -int16 util_checkKey(void); -int16 util_getRandom(int16 max); -void util_getMouseState(int16 *pX, int16 *pY, int16 *pButtons); -void util_setMousePos(int16 x, int16 y); -void util_longDelay(uint16 msecs); -void util_delay(uint16 msecs); -void util_beep(int16 freq); -uint32 util_getTimeKey(void); -void util_waitMouseUp(void); -void util_waitMouseDown(void); - -void keyboard_init(void); -void keyboard_release(void); - -void util_clearPalette(void); - -void asm_setPaletteBlock(char *tmpPalBuffer, int16 start, int16 end); - -void vid_waitRetrace(int16 mode); - -FontDesc *util_loadFont(const char *path); -void util_freeFont(FontDesc * fontDesc); -void util_clearPalette(void); -void util_insertStr(const char *str1, char *str2, int16 pos); -void util_cutFromStr(char *str, int16 from, int16 cutlen); -int16 util_strstr(const char *str1, char *str2); -void util_waitEndFrame(); -void util_setFrameRate(int16 rate); - -void util_listInsertBack(Util_List * list, void *data); -void util_listInsertFront(Util_List * list, void *data); -void util_listDropFront(Util_List * list); -void util_deleteList(Util_List * list); -void util_prepareStr(char *str); -void util_waitMouseRelease(char drawMouse); +#define KEYBUFSIZE 16 + +class Util { +public: + struct ListNode; + typedef struct ListNode { + void *pData; + struct ListNode *pNext; + struct ListNode *pPrev; + ListNode() : pData(0), pNext(0), pPrev(0) {} + } ListNode; + + typedef struct List { + ListNode *pHead; + ListNode *pTail; + List() : pHead(0), pTail(0) {} + } List; + + void initInput(void); + void processInput(void); + void waitKey(void); + int16 getKey(void); + int16 checkKey(void); + int16 getRandom(int16 max); + void getMouseState(int16 *pX, int16 *pY, int16 *pButtons); + void setMousePos(int16 x, int16 y); + void longDelay(uint16 msecs); + void delay(uint16 msecs); + void beep(int16 freq); + uint32 getTimeKey(void); + void waitMouseUp(void); + void waitMouseDown(void); + + void keyboard_init(void); + void keyboard_release(void); + + void clearPalette(void); + + void asm_setPaletteBlock(char *tmpPalBuffer, int16 start, int16 end); + + void vid_waitRetrace(int16 mode); + + Video::FontDesc *loadFont(const char *path); + void freeFont(Video::FontDesc * fontDesc); + void insertStr(const char *str1, char *str2, int16 pos); + void cutFromStr(char *str, int16 from, int16 cutlen); + int16 strstr(const char *str1, char *str2); + void waitEndFrame(); + void setFrameRate(int16 rate); + + void listInsertBack(List * list, void *data); + void listInsertFront(List * list, void *data); + void listDropFront(List * list); + void deleteList(List * list); + void prepareStr(char *str); + void waitMouseRelease(char drawMouse); + + static const char trStr1[]; + static const char trStr2[]; + static const char trStr3[]; + Util(GobEngine *vm); + +protected: + int16 _mouseX, _mouseY, _mouseButtons; + int16 _keyBuffer[KEYBUFSIZE], _keyBufferHead, _keyBufferTail; + GobEngine *_vm; + + void addKeyToBuffer(int16 key); + bool keyBufferEmpty(); + bool getKeyFromBuffer(int16& key); + int16 translateKey(int16 key); + int16 calcDelayTime(); + void checkJoystick(); +}; } // End of namespace Gob diff --git a/gob/video.cpp b/gob/video.cpp index 3ecf2962b5..934ef29bbf 100644 --- a/gob/video.cpp +++ b/gob/video.cpp @@ -28,22 +28,22 @@ namespace Gob { -VideoDriver *_videoDriver; - - /* NOT IMPLEMENTED */ +Video::Video(GobEngine *vm) : _vm(vm) { +} + //XXX: Use this function to update the screen for now. // This should be moved to a better location later on. -void vid_waitRetrace(int16) { - if (pPrimarySurfDesc) { - g_system->copyRectToScreen(pPrimarySurfDesc->vidPtr, 320, 0, 0, 320, 200); +void Video::waitRetrace(int16) { + if (_vm->_global->pPrimarySurfDesc) { + g_system->copyRectToScreen(_vm->_global->pPrimarySurfDesc->vidPtr, 320, 0, 0, 320, 200); g_system->updateScreen(); } } -char vid_initDriver(int16 vidMode) { - warning("STUB: vid_initDriver"); +char Video::initDriver(int16 vidMode) { + warning("STUB: Video::initDriver"); // FIXME: Finish all this stuff :) _videoDriver = new VGAVideoDriver(); @@ -51,17 +51,17 @@ char vid_initDriver(int16 vidMode) { return 1; } -void vid_freeDriver() { +void Video::freeDriver() { delete _videoDriver; - warning("STUB: vid_freeDriver"); + warning("STUB: Video::freeDriver"); } -int32 vid_getRectSize(int16 width, int16 height, int16 flag, int16 mode) { +int32 Video::getRectSize(int16 width, int16 height, int16 flag, int16 mode) { int32 size; if ((mode & 0x7f) != 0x13) warning - ("vid_getRectSize: Video mode %d is not fully supported!", + ("Video::getRectSize: Video mode %d is not fully supported!", mode & 0x7f); switch (mode & 0x7f) { case 5: @@ -83,7 +83,7 @@ int32 vid_getRectSize(int16 width, int16 height, int16 flag, int16 mode) { return size; } -SurfaceDesc *vid_initSurfDesc(int16 vidMode, int16 width, int16 height, int16 flags) { +Video::SurfaceDesc *Video::initSurfDesc(int16 vidMode, int16 width, int16 height, int16 flags) { int8 flagsAnd2; byte *vidMem; int32 sprSize; @@ -91,13 +91,13 @@ SurfaceDesc *vid_initSurfDesc(int16 vidMode, int16 width, int16 height, int16 fl SurfaceDesc *descPtr; if (flags != PRIMARY_SURFACE) - sprAllocated++; + _vm->_global->sprAllocated++; if (flags & RETURN_PRIMARY) - return pPrimarySurfDesc; + return _vm->_global->pPrimarySurfDesc; if (vidMode != 0x13) - error("vid_initSurfDesc: Only VGA 0x13 mode is supported!"); + error("Video::initSurfDesc: Only VGA 0x13 mode is supported!"); if ((flags & PRIMARY_SURFACE) == 0) vidMode += 0x80; @@ -109,20 +109,20 @@ SurfaceDesc *vid_initSurfDesc(int16 vidMode, int16 width, int16 height, int16 fl if (flags & PRIMARY_SURFACE) { vidMem = 0; - primaryWidth = width; - mouseMaxCol = width; - primaryHeight = height; - mouseMaxRow = height; + _vm->_global->primaryWidth = width; + _vm->_global->mouseMaxCol = width; + _vm->_global->primaryHeight = height; + _vm->_global->mouseMaxRow = height; sprSize = 0; } else { vidMem = 0; - sprSize = vid_getRectSize(width, height, flagsAnd2, vidMode); + sprSize = Video::getRectSize(width, height, flagsAnd2, vidMode); if (flagsAnd2) someFlags += 0x80; } if (flags & PRIMARY_SURFACE) { - descPtr = pPrimarySurfDesc; + descPtr = _vm->_global->pPrimarySurfDesc; vidMem = (byte *)malloc(320 * 200); } else { if (flags & DISABLE_SPR_ALLOC) @@ -146,15 +146,15 @@ SurfaceDesc *vid_initSurfDesc(int16 vidMode, int16 width, int16 height, int16 fl return descPtr; } -void vid_freeSurfDesc(SurfaceDesc * surfDesc) { - sprAllocated--; - if (surfDesc != pPrimarySurfDesc) +void Video::freeSurfDesc(SurfaceDesc * surfDesc) { + _vm->_global->sprAllocated--; + if (surfDesc != _vm->_global->pPrimarySurfDesc) free(surfDesc); else free(surfDesc->vidPtr); } -int16 vid_clampValue(int16 val, int16 max) { +int16 Video::clampValue(int16 val, int16 max) { if (val >= max) val = max - 1; @@ -164,13 +164,13 @@ int16 vid_clampValue(int16 val, int16 max) { return val; } -void vid_drawSprite(SurfaceDesc *source, SurfaceDesc *dest, +void Video::drawSprite(SurfaceDesc *source, SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, int16 x, int16 y, int16 transp) { int16 temp; int16 destRight; int16 destBottom; - if (doRangeClamp) { + if (_vm->_global->doRangeClamp) { if (left > right) { temp = left; left = right; @@ -198,8 +198,8 @@ void vid_drawSprite(SurfaceDesc *source, SurfaceDesc *dest, y -= top; top = 0; } - right = vid_clampValue(right, source->width); - bottom = vid_clampValue(bottom, source->height); + right = Video::clampValue(right, source->width); + bottom = Video::clampValue(bottom, source->height); if (right - left >= source->width) right = left + source->width - 1; if (bottom - top >= source->height) @@ -236,11 +236,11 @@ void vid_drawSprite(SurfaceDesc *source, SurfaceDesc *dest, _videoDriver->drawSprite(source, dest, left, top, right, bottom, x, y, transp); } -void vid_fillRect(SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, +void Video::fillRect(SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, int16 color) { int16 temp; - if (doRangeClamp) { + if (_vm->_global->doRangeClamp) { if (left > right) { temp = left; left = right; @@ -260,64 +260,64 @@ void vid_fillRect(SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 b if (top >= dest->height) return; - left = vid_clampValue(left, dest->width); - top = vid_clampValue(top, dest->height); - right = vid_clampValue(right, dest->width); - bottom = vid_clampValue(bottom, dest->height); + left = Video::clampValue(left, dest->width); + top = Video::clampValue(top, dest->height); + right = Video::clampValue(right, dest->width); + bottom = Video::clampValue(bottom, dest->height); } _videoDriver->fillRect(dest, left, top, right, bottom, color); } -void vid_drawLine(SurfaceDesc *dest, int16 x0, int16 y0, int16 x1, int16 y1, int16 color) { +void Video::drawLine(SurfaceDesc *dest, int16 x0, int16 y0, int16 x1, int16 y1, int16 color) { if (x0 == x1 || y0 == y1) { - vid_fillRect(dest, x0, y0, x1, y1, color); + Video::fillRect(dest, x0, y0, x1, y1, color); return; } _videoDriver->drawLine(dest, x0, y0, x1, y1, color); } -void vid_putPixel(int16 x, int16 y, int16 color, SurfaceDesc *dest) { +void Video::putPixel(int16 x, int16 y, int16 color, SurfaceDesc *dest) { if (x < 0 || y < 0 || x >= dest->width || y >= dest->height) return; _videoDriver->putPixel(x, y, color, dest); } -void vid_drawLetter(unsigned char item, int16 x, int16 y, FontDesc *fontDesc, int16 color1, +void Video::drawLetter(unsigned char item, int16 x, int16 y, FontDesc *fontDesc, int16 color1, int16 color2, int16 transp, SurfaceDesc *dest) { _videoDriver->drawLetter(item, x, y, fontDesc, color1, color2, transp, dest); } -void vid_clearSurf(SurfaceDesc *dest) { - vid_fillRect(dest, 0, 0, dest->width - 1, dest->height - 1, 0); +void Video::clearSurf(SurfaceDesc *dest) { + Video::fillRect(dest, 0, 0, dest->width - 1, dest->height - 1, 0); } -void vid_drawPackedSprite(byte *sprBuf, int16 width, int16 height, int16 x, int16 y, +void Video::drawPackedSprite(byte *sprBuf, int16 width, int16 height, int16 x, int16 y, int16 transp, SurfaceDesc *dest) { - if (vid_spriteUncompressor(sprBuf, width, height, x, y, transp, dest)) + if (Video::spriteUncompressor(sprBuf, width, height, x, y, transp, dest)) return; if ((dest->vidMode & 0x7f) != 0x13) - error("vid_drawPackedSprite: Vide mode 0x%x is not fully supported!", + error("Video::drawPackedSprite: Vide mode 0x%x is not fully supported!", dest->vidMode & 0x7f); _videoDriver->drawPackedSprite(sprBuf, width, height, x, y, transp, dest); } -void vid_setPalElem(int16 index, char red, char green, char blue, int16 unused, +void Video::setPalElem(int16 index, char red, char green, char blue, int16 unused, int16 vidMode) { byte pal[4]; - redPalette[index] = red; - greenPalette[index] = green; - bluePalette[index] = blue; + _vm->_global->redPalette[index] = red; + _vm->_global->greenPalette[index] = green; + _vm->_global->bluePalette[index] = blue; if (vidMode != 0x13) - error("vid_setPalElem: Video mode 0x%x is not supported!", + error("Video::setPalElem: Video mode 0x%x is not supported!", vidMode); pal[0] = (red << 2) | (red >> 4); @@ -327,16 +327,16 @@ void vid_setPalElem(int16 index, char red, char green, char blue, int16 unused, g_system->setPalette(pal, index, 1); } -void vid_setPalette(PalDesc *palDesc) { +void Video::setPalette(PalDesc *palDesc) { int16 i; byte pal[1024]; int16 numcolors; - if (videoMode != 0x13) - error("vid_setPalette: Video mode 0x%x is not supported!", - videoMode); + if (_vm->_global->videoMode != 0x13) + error("Video::setPalette: Video mode 0x%x is not supported!", + _vm->_global->videoMode); - if (setAllPalette) + if (_vm->_global->setAllPalette) numcolors = 256; else numcolors = 16; @@ -351,17 +351,17 @@ void vid_setPalette(PalDesc *palDesc) { g_system->setPalette(pal, 0, numcolors); } -void vid_setFullPalette(PalDesc *palDesc) { +void Video::setFullPalette(PalDesc *palDesc) { Color *colors; int16 i; byte pal[1024]; - if (setAllPalette) { + if (_vm->_global->setAllPalette) { colors = palDesc->vgaPal; for (i = 0; i < 256; i++) { - redPalette[i] = colors[i].red; - greenPalette[i] = colors[i].green; - bluePalette[i] = colors[i].blue; + _vm->_global->redPalette[i] = colors[i].red; + _vm->_global->greenPalette[i] = colors[i].green; + _vm->_global->bluePalette[i] = colors[i].blue; } for (i = 0; i < 256; i++) { @@ -372,46 +372,46 @@ void vid_setFullPalette(PalDesc *palDesc) { } g_system->setPalette(pal, 0, 256); } else { - vid_setPalette(palDesc); + Video::setPalette(palDesc); } } -void vid_initPrimary(int16 mode) { +void Video::initPrimary(int16 mode) { int16 old; - if (curPrimaryDesc) { - vid_freeSurfDesc(curPrimaryDesc); - vid_freeSurfDesc(allocatedPrimary); + if (_vm->_global->curPrimaryDesc) { + Video::freeSurfDesc(_vm->_global->curPrimaryDesc); + Video::freeSurfDesc(_vm->_global->allocatedPrimary); - curPrimaryDesc = 0; - allocatedPrimary = 0; + _vm->_global->curPrimaryDesc = 0; + _vm->_global->allocatedPrimary = 0; } if (mode != 0x13 && mode != 3 && mode != -1) - error("vid_initPrimary: Video mode 0x%x is not supported!", + error("Video::initPrimary: Video mode 0x%x is not supported!", mode); - if (videoMode != 0x13) - error("vid_initPrimary: Video mode 0x%x is not supported!", + if (_vm->_global->videoMode != 0x13) + error("Video::initPrimary: Video mode 0x%x is not supported!", mode); - old = oldMode; + old = _vm->_global->oldMode; if (mode == -1) mode = 3; - oldMode = mode; + _vm->_global->oldMode = mode; if (mode != 3) - vid_initDriver(mode); + Video::initDriver(mode); if (mode != 3) { - vid_initSurfDesc(mode, 320, 200, PRIMARY_SURFACE); + Video::initSurfDesc(mode, 320, 200, PRIMARY_SURFACE); - if (dontSetPalette) + if (_vm->_global->dontSetPalette) return; - vid_setFullPalette(pPaletteDesc); + Video::setFullPalette(_vm->_global->pPaletteDesc); } } -char vid_spriteUncompressor(byte *sprBuf, int16 srcWidth, int16 srcHeight, +char Video::spriteUncompressor(byte *sprBuf, int16 srcWidth, int16 srcHeight, int16 x, int16 y, int16 transp, SurfaceDesc *destDesc) { SurfaceDesc sourceDesc; byte *memBuffer; @@ -432,7 +432,7 @@ char vid_spriteUncompressor(byte *sprBuf, int16 srcWidth, int16 srcHeight, return 1; if ((destDesc->vidMode & 0x7f) != 0x13) - error("vid_spriteUncompressor: Video mode 0x%x is not supported!", + error("Video::spriteUncompressor: Video mode 0x%x is not supported!", destDesc->vidMode & 0x7f); if (sprBuf[0] != 1) @@ -446,7 +446,7 @@ char vid_spriteUncompressor(byte *sprBuf, int16 srcWidth, int16 srcHeight, sourceDesc.height = srcHeight; sourceDesc.vidMode = 0x93; sourceDesc.vidPtr = sprBuf + 3; - vid_drawSprite(&sourceDesc, destDesc, 0, 0, srcWidth - 1, + Video::drawSprite(&sourceDesc, destDesc, 0, 0, srcWidth - 1, srcHeight - 1, x, y, transp); return 1; } else { @@ -540,8 +540,6 @@ char vid_spriteUncompressor(byte *sprBuf, int16 srcWidth, int16 srcHeight, return 1; } -void vid_setHandlers() { - setAllPalette = 1; -} +void Video::setHandlers() { _vm->_global->setAllPalette = 1; } } // End of namespace Gob diff --git a/gob/video.h b/gob/video.h index 3f64b43231..194f552da3 100644 --- a/gob/video.h +++ b/gob/video.h @@ -24,6 +24,7 @@ #include "common/stdafx.h" #include "common/util.h" +#include "gob/gob.h" namespace Gob { @@ -35,40 +36,34 @@ namespace Gob { #define TEXT_COL_COUNT 80 #define TEXT_ROW_COUNT 25 +extern int16 setAllPalette; -typedef struct SurfaceDesc_t { - int16 width; - int16 height; - int8 reserved1; - int8 flag; - int16 vidMode; - byte *vidPtr; - int16 reserved2; -} SurfaceDesc; - -typedef struct FontDesc_t { - char *dataPtr; - int8 itemWidth; - int8 itemHeight; - int8 startItem; - int8 endItem; - int8 itemSize; - int8 bitWidth; - void *extraData; -} FontDesc; - - -class VideoDriver { +class Video { public: - VideoDriver() {} - virtual ~VideoDriver() {} - virtual void drawSprite(SurfaceDesc *source, SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, int16 x, int16 y, int16 transp) = 0; - virtual void fillRect(SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, byte color) = 0; - virtual void putPixel(int16 x, int16 y, byte color, SurfaceDesc *dest) = 0; - virtual void drawLetter(unsigned char item, int16 x, int16 y, FontDesc *fontDesc, byte color1, byte color2, byte transp, SurfaceDesc *dest) = 0; - virtual void drawLine(SurfaceDesc *dest, int16 x0, int16 y0, int16 x1, int16 y1, byte color) = 0; - virtual void drawPackedSprite(byte *sprBuf, int16 width, int16 height, int16 x, int16 y, byte transp, SurfaceDesc *dest) = 0; -}; + typedef struct SurfaceDesc_t { + int16 width; + int16 height; + int8 reserved1; + int8 flag; + int16 vidMode; + byte *vidPtr; + int16 reserved2; + SurfaceDesc_t() : width(0), height(0), reserved1(0), flag(0), + vidMode(0), vidPtr(0), reserved2(0) {} + } SurfaceDesc; + + typedef struct FontDesc_t { + char *dataPtr; + int8 itemWidth; + int8 itemHeight; + int8 startItem; + int8 endItem; + int8 itemSize; + int8 bitWidth; + void *extraData; + FontDesc_t() : dataPtr(0), itemWidth(0), itemHeight(0), startItem(0), + endItem(0), itemSize(0), bitWidth(0) {} + } FontDesc; #define GDR_VERSION 4 @@ -76,52 +71,69 @@ public: #define RETURN_PRIMARY 0x01 #define DISABLE_SPR_ALLOC 0x20 -#if !defined(__GNUC__) - #pragma START_PACK_STRUCTS -#endif - -typedef struct Color { - byte red; - byte green; - byte blue; -} GCC_PACK Color; - -#if !defined(__GNUC__) - #pragma END_PACK_STRUCTS -#endif +#pragma START_PACK_STRUCTS + + typedef struct Color { + byte red; + byte green; + byte blue; + } GCC_PACK Color; + +#pragma END_PACK_STRUCTS + + typedef struct PalDesc { + Color *vgaPal; + int16 *unused1; + int16 *unused2; + PalDesc() : vgaPal(0), unused1(0), unused2(0) {} + } PalDesc; + + Video(class GobEngine *vm); + int32 getRectSize(int16 width, int16 height, int16 flag, int16 mode); + SurfaceDesc *initSurfDesc(int16 vidMode, int16 width, int16 height, int16 flags); + void freeSurfDesc(SurfaceDesc * surfDesc); + int16 clampValue(int16 val, int16 max); + void drawSprite(SurfaceDesc * source, SurfaceDesc * dest, int16 left, + int16 top, int16 right, int16 bottom, int16 x, int16 y, int16 transp); + void fillRect(SurfaceDesc * dest, int16 left, int16 top, int16 right, int16 bottom, + int16 color); + void drawLine(SurfaceDesc * dest, int16 x0, int16 y0, int16 x1, int16 y1, + int16 color); + void putPixel(int16 x, int16 y, int16 color, SurfaceDesc * dest); + void drawLetter(unsigned char item, int16 x, int16 y, FontDesc * fontDesc, int16 color1, + int16 color2, int16 transp, SurfaceDesc * dest); + void clearSurf(SurfaceDesc * dest); + void drawPackedSprite(byte *sprBuf, int16 width, int16 height, int16 x, int16 y, + int16 transp, SurfaceDesc * dest); + void setPalElem(int16 index, char red, char green, char blue, int16 unused, + int16 vidMode); + void setPalette(PalDesc * palDesc); + void setFullPalette(PalDesc * palDesc); + void initPrimary(int16 mode); + char spriteUncompressor(byte *sprBuf, int16 srcWidth, int16 srcHeight, int16 x, + int16 y, int16 transp, SurfaceDesc * destDesc); + void waitRetrace(int16); + void freeDriver(void); + void setHandlers(); + +protected: + class VideoDriver *_videoDriver; + GobEngine *_vm; + + char initDriver(int16 vidMode); +}; -typedef struct PalDesc { - Color *vgaPal; - int16 *unused1; - int16 *unused2; -} PalDesc; - -char vid_initDriver(int16 vidMode); -void vid_freeDriver(void); -int32 vid_getRectSize(int16 width, int16 height, int16 flag, int16 mode); -SurfaceDesc *vid_initSurfDesc(int16 vidMode, int16 width, int16 height, int16 flags); -void vid_freeSurfDesc(SurfaceDesc * surfDesc); -int16 vid_clampValue(int16 val, int16 max); -void vid_drawSprite(SurfaceDesc * source, SurfaceDesc * dest, int16 left, - int16 top, int16 right, int16 bottom, int16 x, int16 y, int16 transp); -void vid_fillRect(SurfaceDesc * dest, int16 left, int16 top, int16 right, int16 bottom, - int16 color); -void vid_drawLine(SurfaceDesc * dest, int16 x0, int16 y0, int16 x1, int16 y1, - int16 color); -void vid_putPixel(int16 x, int16 y, int16 color, SurfaceDesc * dest); -void vid_drawLetter(unsigned char item, int16 x, int16 y, FontDesc * fontDesc, int16 color1, - int16 color2, int16 transp, SurfaceDesc * dest); -void vid_clearSurf(SurfaceDesc * dest); -void vid_drawPackedSprite(byte *sprBuf, int16 width, int16 height, int16 x, int16 y, - int16 transp, SurfaceDesc * dest); -void vid_setPalElem(int16 index, char red, char green, char blue, int16 unused, - int16 vidMode); -void vid_setPalette(PalDesc * palDesc); -void vid_setFullPalette(PalDesc * palDesc); -void vid_initPrimary(int16 mode); -char vid_spriteUncompressor(byte *sprBuf, int16 srcWidth, int16 srcHeight, int16 x, - int16 y, int16 transp, SurfaceDesc * destDesc); -void vid_setHandlers(void); +class VideoDriver { +public: + VideoDriver() {} + virtual ~VideoDriver() {} + virtual void drawSprite(Video::SurfaceDesc *source, Video::SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, int16 x, int16 y, int16 transp) = 0; + virtual void fillRect(Video::SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, byte color) = 0; + virtual void putPixel(int16 x, int16 y, byte color, Video::SurfaceDesc *dest) = 0; + virtual void drawLetter(unsigned char item, int16 x, int16 y, Video::FontDesc *fontDesc, byte color1, byte color2, byte transp, Video::SurfaceDesc *dest) = 0; + virtual void drawLine(Video::SurfaceDesc *dest, int16 x0, int16 y0, int16 x1, int16 y1, byte color) = 0; + virtual void drawPackedSprite(byte *sprBuf, int16 width, int16 height, int16 x, int16 y, byte transp, Video::SurfaceDesc *dest) = 0; +}; } // End of namespace Gob -- cgit v1.2.3