thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Patch #1395615 "GobEngine code wrapped in classes". With some cosmetic changes.

Browse source 
svn-id: r19899
This commit is contained in:
Eugene Sandulenko 2006-01-03 23:14:39 +00:00
parent f046a14bb2
commit fd8ac69fc4
42 changed files with 6551 additions and 6164 deletions
Download patch file Download diff file Expand all files Collapse all files

12
gob/anim.cpp
View file

@ -25,10 +25,12 @@
namespace Gob { namespace Gob {
int16 anim_animAreaLeft; Anim::Anim() {
int16 anim_animAreaTop; _areaLeft = 0;
int16 anim_animAreaWidth; _areaTop = 0;
int16 anim_animAreaHeight; _areaWidth = 0;
SurfaceDesc *anim_underAnimSurf = 0; _areaHeight = 0;
_animSurf = 0;
}
} // End of namespace Gob } // End of namespace Gob

15
gob/anim.h
View file

@ -24,11 +24,16 @@
namespace Gob { namespace Gob {
extern int16 anim_animAreaLeft; class Anim {
extern int16 anim_animAreaTop; public:
extern int16 anim_animAreaWidth; int16 _areaLeft;
extern int16 anim_animAreaHeight; int16 _areaTop;
extern SurfaceDesc *anim_underAnimSurf; int16 _areaWidth;
int16 _areaHeight;
Video::SurfaceDesc *_animSurf;
Anim();
};
} // End of namespace Gob } // End of namespace Gob

117
gob/cdrom.cpp
View file

@ -28,73 +28,76 @@
namespace Gob { namespace Gob {
byte *cd_LICbuffer; CDROM::CDROM(GobEngine *vm) : _vm(vm) {
char cd_curTrack[16]; _cdPlaying = false;
uint16 cd_numTracks; _LICbuffer = 0;
bool cd_globFlag; for (int i = 0; i < 16; i++)
uint32 cd_trackStop; _curTrack[i] = 0;
uint32 cd_startTime; _numTracks = 0;
_trackStop = 0;
_startTime = 0;
}
void cd_readLIC(const char *fname) { void CDROM::readLIC(const char *fname) {
char tmp[80]; char tmp[80];
int handle; int handle;
uint16 version, startChunk, pos; uint16 version, startChunk, pos;
cd_freeLICbuffer(); freeLICbuffer();
*cd_curTrack = 0; *_curTrack = 0;
strcpy(tmp, fname); strcpy(tmp, fname);
handle = data_openData(tmp); handle = _vm->_dataio->openData(tmp);
if (handle == -1) if (handle == -1)
return; 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); version = READ_LE_UINT16(&version);
data_readData(handle, (char *)&startChunk, 2); _vm->_dataio->readData(handle, (char *)&startChunk, 2);
startChunk = READ_LE_UINT16(&startChunk); startChunk = READ_LE_UINT16(&startChunk);
data_readData(handle, (char *)&cd_numTracks, 2); _vm->_dataio->readData(handle, (char *)&_numTracks, 2);
cd_numTracks = READ_LE_UINT16(&cd_numTracks); _numTracks = READ_LE_UINT16(&_numTracks);
if (version != 3) { if (version != 3) {
error("Wrong file %s (%d)", fname, version); error("Wrong file %s (%d)", fname, version);
return; return;
} }
data_seekData(handle, 50, SEEK_SET); _vm->_dataio->seekData(handle, 50, SEEK_SET);
for (int i = 0; i < startChunk; i++) { 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); pos = READ_LE_UINT16(&pos);
if (!pos) if (!pos)
break; break;
data_seekData(handle, pos, SEEK_CUR); _vm->_dataio->seekData(handle, pos, SEEK_CUR);
} }
cd_LICbuffer = (byte *)malloc(cd_numTracks * 22); _LICbuffer = (byte *)malloc(_numTracks * 22);
data_readData(handle, (char *)cd_LICbuffer, cd_numTracks * 22); _vm->_dataio->readData(handle, (char *)_LICbuffer, _numTracks * 22);
data_closeData(handle); _vm->_dataio->closeData(handle);
} }
void cd_freeLICbuffer(void) { void CDROM::freeLICbuffer(void) {
free(cd_LICbuffer); free(_LICbuffer);
cd_LICbuffer = 0; _LICbuffer = 0;
} }
void cd_playBgMusic() { void CDROM::playBgMusic() {
static const char *tracks[][2] = { static const char *tracks[][2] = {
{"avt00.tot", "mine"}, {"avt00.tot", "mine"},
{"avt001.tot", "nuit"}, {"avt001.tot", "nuit"},
@ -121,13 +124,13 @@ void cd_playBgMusic() {
}; };
for (int i = 0; i < ARRAYSIZE(tracks); i++) for (int i = 0; i < ARRAYSIZE(tracks); i++)
if (!scumm_stricmp(game_curTotFile, tracks[i][0])) { if (!scumm_stricmp(_vm->_game->curTotFile, tracks[i][0])) {
cd_startTrack(tracks[i][1]); startTrack(tracks[i][1]);
break; break;
} }
} }
void cd_playMultMusic() { void CDROM::playMultMusic() {
static const char *tracks[][6] = { static const char *tracks[][6] = {
{"avt005.tot", "fra1", "all1", "ang1", "esp1", "ita1"}, {"avt005.tot", "fra1", "all1", "ang1", "esp1", "ita1"},
{"avt006.tot", "fra2", "all2", "ang2", "esp2", "ita2"}, {"avt006.tot", "fra2", "all2", "ang2", "esp2", "ita2"},
@ -138,25 +141,25 @@ void cd_playMultMusic() {
}; };
for (int i = 0; i < ARRAYSIZE(tracks); i++) for (int i = 0; i < ARRAYSIZE(tracks); i++)
if (!scumm_stricmp(game_curTotFile, tracks[i][0])) { if (!scumm_stricmp(_vm->_game->curTotFile, tracks[i][0])) {
cd_globFlag = true; _cdPlaying = true;
cd_startTrack(tracks[i][language + 1]); startTrack(tracks[i][_vm->_global->language + 1]);
break; break;
} }
} }
void cd_startTrack(const char *trackname) { void CDROM::startTrack(const char *trackname) {
byte *curPtr, *matchPtr; byte *curPtr, *matchPtr;
if (!cd_LICbuffer) if (!_LICbuffer)
return; return;
debug(3, "cd_startTrack(%s)", trackname); debug(3, "startTrack(%s)", trackname);
matchPtr = 0; 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)) { if (!scumm_stricmp((char *)curPtr, trackname)) {
matchPtr = curPtr; matchPtr = curPtr;
break; break;
@ -169,64 +172,64 @@ void cd_startTrack(const char *trackname) {
return; return;
} }
strcpy(cd_curTrack, trackname); strcpy(_curTrack, trackname);
cd_stopPlaying(); stopPlaying();
while (cd_getTrackPos() != -1); while (getTrackPos() != -1);
uint32 start, end; uint32 start, end;
start = READ_LE_UINT32(matchPtr + 12); start = READ_LE_UINT32(matchPtr + 12);
end = READ_LE_UINT32(matchPtr + 16); end = READ_LE_UINT32(matchPtr + 16);
cd_play(start, end); play(start, end);
cd_startTime = util_getTimeKey(); _startTime = _vm->_util->getTimeKey();
cd_trackStop = cd_startTime + (end - start + 1 + 150) * 40 / 3; _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] // play from sector [from] to sector [to]
// //
// format is HSG: // format is HSG:
// HSG encodes frame information into a double word: // HSG encodes frame information into a double word:
// minute multiplied by 4500, plus second multiplied by 75, // minute multiplied by 4500, plus second multiplied by 75,
// plus frame, minus 150 // 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); AudioCD.play(1, 0, from, to - from + 1);
} }
int32 cd_getTrackPos(void) { int32 CDROM::getTrackPos(void) {
uint32 curPos = util_getTimeKey() - cd_startTime; uint32 curPos = _vm->_util->getTimeKey() - _startTime;
if (AudioCD.isPlaying() && (util_getTimeKey() < cd_trackStop)) if (AudioCD.isPlaying() && (_vm->_util->getTimeKey() < _trackStop))
return curPos * 3 / 40; return curPos * 3 / 40;
else else
return -1; return -1;
} }
void cd_stopPlaying(void) { void CDROM::stopPlaying(void) {
cd_stop(); stop();
while (cd_getTrackPos() != -1); while (getTrackPos() != -1);
} }
void cd_stop(void) { void CDROM::stop(void) {
debug(3, "cd_stop()"); debug(3, "stop()");
AudioCD.stop(); AudioCD.stop();
} }
void cd_testCD(int trySubst, const char *label) { void CDROM::testCD(int trySubst, const char *label) {
if (!trySubst) { if (!trySubst) {
error("CDROM track substitution is not supported"); error("CDROM track substitution is not supported");
return; return;
} }
cd_LICbuffer = 0; _LICbuffer = 0;
cd_globFlag = false; _cdPlaying = false;
// Original checked CD label here // Original checked CD label here
// but will skip it as it will require OSystem extensions of direct // but will skip it as it will require OSystem extensions of direct

35
gob/cdrom.h
View file

@ -22,18 +22,31 @@
namespace Gob { namespace Gob {
extern bool cd_globFlag; class CDROM {
public:
bool _cdPlaying;
void cd_readLIC(const char *fname); void readLIC(const char *fname);
void cd_freeLICbuffer(void); void freeLICbuffer(void);
void cd_startTrack(const char *s); void startTrack(const char *s);
void cd_playBgMusic(); void playBgMusic();
void cd_playMultMusic(); void playMultMusic();
void cd_play(uint32 from, uint32 to); void play(uint32 from, uint32 to);
int32 cd_getTrackPos(void); int32 getTrackPos(void);
void cd_stopPlaying(void); void stopPlaying(void);
void cd_stop(void); void stop(void);
void cd_testCD(int trySubst, const char *label); 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 } // End of namespace Gob

187
gob/dataio.cpp
View file

@ -26,11 +26,14 @@
namespace Gob { namespace Gob {
Common::File *file_getHandle(int16 handle) { DataIO::DataIO(GobEngine *vm) : _vm(vm) {
return &filesHandles[handle];
} }
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; int16 i;
for (i = 0; i < MAX_FILES; i++) { for (i = 0; i < MAX_FILES; i++) {
@ -48,51 +51,51 @@ int16 file_open(const char *path, Common::File::AccessMode mode) {
return -1; return -1;
} }
int16 data_getChunk(const char *chunkName) { int16 DataIO::getChunk(const char *chunkName) {
int16 file; int16 file;
int16 slot; int16 slot;
int16 chunk; int16 chunk;
struct ChunkDesc *dataDesc; struct ChunkDesc *dataDesc;
for (file = 0; file < MAX_DATA_FILES; file++) { for (file = 0; file < MAX_DATA_FILES; file++) {
if (dataFiles[file] == 0) if (_vm->_global->dataFiles[file] == 0)
return -1; return -1;
for (slot = 0; slot < MAX_SLOT_COUNT; slot++) 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; break;
if (slot == MAX_SLOT_COUNT) if (slot == MAX_SLOT_COUNT)
return -1; return -1;
dataDesc = dataFiles[file]; dataDesc = _vm->_global->dataFiles[file];
for (chunk = 0; chunk < numDataChunks[file]; for (chunk = 0; chunk < _vm->_global->numDataChunks[file];
chunk++, dataDesc++) { chunk++, dataDesc++) {
if (scumm_stricmp(chunkName, dataDesc->chunkName) != 0) if (scumm_stricmp(chunkName, dataDesc->chunkName) != 0)
continue; continue;
isCurrentSlot[file * MAX_SLOT_COUNT + slot] = 0; _vm->_global->isCurrentSlot[file * MAX_SLOT_COUNT + slot] = 0;
chunkSize[file * MAX_SLOT_COUNT + slot] = _vm->_global->chunkSize[file * MAX_SLOT_COUNT + slot] =
dataDesc->size; dataDesc->size;
chunkOffset[file * MAX_SLOT_COUNT + slot] = _vm->_global->chunkOffset[file * MAX_SLOT_COUNT + slot] =
dataDesc->offset; dataDesc->offset;
chunkPos[file * MAX_SLOT_COUNT + slot] = 0; _vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot] = 0;
return file * 10 + slot + 50; return file * 10 + slot + 50;
} }
} }
return -1; return -1;
} }
char data_freeChunk(int16 handle) { char DataIO::freeChunk(int16 handle) {
if (handle >= 50 && handle < 100) { if (handle >= 50 && handle < 100) {
handle -= 50; 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 0;
} }
return 1; return 1;
} }
int32 data_readChunk(int16 handle, char *buf, int16 size) { int32 DataIO::readChunk(int16 handle, char *buf, int16 size) {
int16 file; int16 file;
int16 slot; int16 slot;
int16 i; int16 i;
@ -103,30 +106,30 @@ int32 data_readChunk(int16 handle, char *buf, int16 size) {
file = (handle - 50) / 10; file = (handle - 50) / 10;
slot = (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++) 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 = offset =
chunkOffset[file * MAX_SLOT_COUNT + slot] + _vm->_global->chunkOffset[file * MAX_SLOT_COUNT + slot] +
chunkPos[file * MAX_SLOT_COUNT + slot]; _vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot];
debug(7, "seek: %ld, %ld", chunkOffset[file * MAX_SLOT_COUNT + slot], 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(dataFileHandles[file])->seek(offset, SEEK_SET); file_getHandle(_vm->_global->dataFileHandles[file])->seek(offset, SEEK_SET);
} }
isCurrentSlot[file * MAX_SLOT_COUNT + slot] = 1; _vm->_global->isCurrentSlot[file * MAX_SLOT_COUNT + slot] = 1;
if (chunkPos[file * MAX_SLOT_COUNT + slot] + size > if (_vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot] + size >
chunkSize[file * MAX_SLOT_COUNT + slot]) _vm->_global->chunkSize[file * MAX_SLOT_COUNT + slot])
size = size =
chunkSize[file * MAX_SLOT_COUNT + slot] - _vm->_global->chunkSize[file * MAX_SLOT_COUNT + slot] -
chunkPos[file * MAX_SLOT_COUNT + slot]; _vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot];
file_getHandle(dataFileHandles[file])->read(buf, size); file_getHandle(_vm->_global->dataFileHandles[file])->read(buf, size);
chunkPos[file * MAX_SLOT_COUNT + slot] += size; _vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot] += size;
return size; return size;
} }
int16 data_seekChunk(int16 handle, int32 pos, int16 from) { int16 DataIO::seekChunk(int16 handle, int32 pos, int16 from) {
int16 file; int16 file;
int16 slot; int16 slot;
@ -135,16 +138,16 @@ int16 data_seekChunk(int16 handle, int32 pos, int16 from) {
file = (handle - 50) / 10; file = (handle - 50) / 10;
slot = (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) if (from == SEEK_SET)
chunkPos[file * MAX_SLOT_COUNT + slot] = pos; _vm->_global->chunkPos[file * MAX_SLOT_COUNT + slot] = pos;
else 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 file;
int16 chunk; int16 chunk;
struct ChunkDesc *dataDesc; struct ChunkDesc *dataDesc;
@ -152,33 +155,33 @@ int32 data_getChunkSize(const char *chunkName) {
int32 realSize; int32 realSize;
for (file = 0; file < MAX_DATA_FILES; file++) { for (file = 0; file < MAX_DATA_FILES; file++) {
if (dataFiles[file] == 0) if (_vm->_global->dataFiles[file] == 0)
return -1; return -1;
dataDesc = dataFiles[file]; dataDesc = _vm->_global->dataFiles[file];
for (chunk = 0; chunk < numDataChunks[file]; for (chunk = 0; chunk < _vm->_global->numDataChunks[file];
chunk++, dataDesc++) { chunk++, dataDesc++) {
if (scumm_stricmp(chunkName, dataDesc->chunkName) != 0) if (scumm_stricmp(chunkName, dataDesc->chunkName) != 0)
continue; continue;
if (dataDesc->packed == 0) { if (dataDesc->packed == 0) {
packedSize = -1; _vm->_global->packedSize = -1;
return dataDesc->size; return dataDesc->size;
} }
for (slot = 0; slot < MAX_SLOT_COUNT; slot++) 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); file_getHandle(_vm->_global->dataFileHandles[file])->seek(dataDesc->offset, SEEK_SET);
realSize = file_getHandle(dataFileHandles[file])->readUint32LE(); realSize = file_getHandle(_vm->_global->dataFileHandles[file])->readUint32LE();
packedSize = dataDesc->size; _vm->_global->packedSize = dataDesc->size;
return realSize; return realSize;
} }
} }
return -1; return -1;
} }
void data_openDataFile(const char *src) { void DataIO::openDataFile(const char *src) {
char path[128]; char path[128];
int16 i; int16 i;
int16 file; int16 file;
@ -190,52 +193,52 @@ void data_openDataFile(const char *src) {
strcat(path, ".stk"); strcat(path, ".stk");
for (file = 0; file < MAX_DATA_FILES; file++) for (file = 0; file < MAX_DATA_FILES; file++)
if (dataFiles[file] == 0) if (_vm->_global->dataFiles[file] == 0)
break; break;
if (file == MAX_DATA_FILES) if (file == MAX_DATA_FILES)
error("data_dataFileOpen: Data file slots are full\n"); error("dataFileOpen: Data file slots are full\n");
dataFileHandles[file] = file_open(path); _vm->_global->dataFileHandles[file] = file_open(path);
if (dataFileHandles[file] == -1) if (_vm->_global->dataFileHandles[file] == -1)
error("data_dataFileOpen: Can't open %s data file\n", path); 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) * (struct ChunkDesc *)malloc(sizeof(struct ChunkDesc) *
numDataChunks[file]); _vm->_global->numDataChunks[file]);
for (i = 0; i < numDataChunks[file]; i++) { for (i = 0; i < _vm->_global->numDataChunks[file]; i++) {
file_getHandle(dataFileHandles[file])->read(dataDesc[i].chunkName, 13); file_getHandle(_vm->_global->dataFileHandles[file])->read(dataDesc[i].chunkName, 13);
dataDesc[i].size = file_getHandle(dataFileHandles[file])->readUint32LE(); dataDesc[i].size = file_getHandle(_vm->_global->dataFileHandles[file])->readUint32LE();
dataDesc[i].offset = file_getHandle(dataFileHandles[file])->readUint32LE(); dataDesc[i].offset = file_getHandle(_vm->_global->dataFileHandles[file])->readUint32LE();
dataDesc[i].packed = file_getHandle(dataFileHandles[file])->readByte(); 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); debug(7, "%d: %s %d", i, dataDesc[i].chunkName, dataDesc[i].size);
for (i = 0; i < MAX_SLOT_COUNT; i++) 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; int16 file;
for (file = MAX_DATA_FILES - 1; file >= 0; file--) { for (file = MAX_DATA_FILES - 1; file >= 0; file--) {
if (dataFiles[file] != 0) { if (_vm->_global->dataFiles[file] != 0) {
free(dataFiles[file]); free(_vm->_global->dataFiles[file]);
dataFiles[file] = 0; _vm->_global->dataFiles[file] = 0;
file_getHandle(dataFileHandles[file])->close(); file_getHandle(_vm->_global->dataFileHandles[file])->close();
return; return;
} }
} }
} }
char *data_getUnpackedData(const char *name) { char *DataIO::getUnpackedData(const char *name) {
int32 realSize; int32 realSize;
int16 chunk; int16 chunk;
char *unpackBuf; char *unpackBuf;
@ -243,11 +246,11 @@ char *data_getUnpackedData(const char *name) {
char *ptr; char *ptr;
int32 sizeLeft; int32 sizeLeft;
realSize = data_getChunkSize(name); realSize = getChunkSize(name);
if (packedSize == -1 || realSize == -1) if (_vm->_global->packedSize == -1 || realSize == -1)
return 0; return 0;
chunk = data_getChunk(name); chunk = getChunk(name);
if (chunk == -1) if (chunk == -1)
return 0; return 0;
@ -255,76 +258,76 @@ char *data_getUnpackedData(const char *name) {
if (unpackBuf == 0) if (unpackBuf == 0)
return 0; return 0;
packBuf = (char *)malloc(packedSize); packBuf = (char *)malloc(_vm->_global->packedSize);
if (packBuf == 0) { if (packBuf == 0) {
free(unpackBuf); free(unpackBuf);
return 0; return 0;
} }
sizeLeft = packedSize; sizeLeft = _vm->_global->packedSize;
ptr = packBuf; ptr = packBuf;
while (sizeLeft > 0x4000) { while (sizeLeft > 0x4000) {
data_readChunk(chunk, ptr, 0x4000); readChunk(chunk, ptr, 0x4000);
sizeLeft -= 0x4000; sizeLeft -= 0x4000;
ptr += 0x4000; ptr += 0x4000;
} }
data_readChunk(chunk, ptr, sizeLeft); readChunk(chunk, ptr, sizeLeft);
data_freeChunk(chunk); freeChunk(chunk);
unpackData(packBuf, unpackBuf); _vm->_pack->unpackData(packBuf, unpackBuf);
free(packBuf); free(packBuf);
return unpackBuf; return unpackBuf;
} }
void data_closeData(int16 handle) { void DataIO::closeData(int16 handle) {
if (data_freeChunk(handle) != 0) if (freeChunk(handle) != 0)
file_getHandle(handle)->close(); 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; int16 handle;
if (mode != Common::File::kFileReadMode) if (mode != Common::File::kFileReadMode)
return file_open(path, mode); return file_open(path, mode);
handle = data_getChunk(path); handle = getChunk(path);
if (handle >= 0) if (handle >= 0)
return handle; return handle;
return file_open(path, mode); 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; int32 res;
res = data_readChunk(handle, buf, size); res = readChunk(handle, buf, size);
if (res >= 0) if (res >= 0)
return res; return res;
return file_getHandle(handle)->read(buf, size); 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; int32 resPos;
resPos = data_seekChunk(handle, pos, from); resPos = seekChunk(handle, pos, from);
if (resPos != -1) if (resPos != -1)
return; return;
file_getHandle(handle)->seek(pos, from); file_getHandle(handle)->seek(pos, from);
} }
int32 data_getDataSize(const char *name) { int32 DataIO::getDataSize(const char *name) {
char buf[128]; char buf[128];
int32 chunkSz; int32 chunkSz;
Common::File file; Common::File file;
strcpy(buf, name); strcpy(buf, name);
chunkSz = data_getChunkSize(buf); chunkSz = getChunkSize(buf);
if (chunkSz >= 0) if (chunkSz >= 0)
return chunkSz; return chunkSz;
if (!file.open(buf)) if (!file.open(buf))
error("data_getDataSize: Can't find data(%s)", name); error("getDataSize: Can't find data(%s)", name);
chunkSz = file.size(); chunkSz = file.size();
file.close(); file.close();
@ -332,31 +335,31 @@ int32 data_getDataSize(const char *name) {
return chunkSz; return chunkSz;
} }
char *data_getData(const char *path) { char *DataIO::getData(const char *path) {
char *data; char *data;
char *ptr; char *ptr;
int32 size; int32 size;
int16 handle; int16 handle;
data = data_getUnpackedData(path); data = getUnpackedData(path);
if (data != 0) if (data != 0)
return data; return data;
size = data_getDataSize(path); size = getDataSize(path);
data = (char *)malloc(size); data = (char *)malloc(size);
if (data == 0) if (data == 0)
return 0; return 0;
handle = data_openData(path); handle = openData(path);
ptr = data; ptr = data;
while (size > 0x4000) { while (size > 0x4000) {
data_readData(handle, ptr, 0x4000); readData(handle, ptr, 0x4000);
size -= 0x4000; size -= 0x4000;
ptr += 0x4000; ptr += 0x4000;
} }
data_readData(handle, ptr, size); readData(handle, ptr, size);
data_closeData(handle); closeData(handle);
return data; return data;
} }

40
gob/dataio.h
View file

@ -23,36 +23,46 @@
#define GOB_DATAIO_H #define GOB_DATAIO_H
#include "common/file.h" #include "common/file.h"
#include "gob/gob.h"
namespace Gob { namespace Gob {
#define MAX_DATA_FILES 3 #define MAX_DATA_FILES 3
#define MAX_SLOT_COUNT 4 #define MAX_SLOT_COUNT 4
class DataIO {
public:
struct ChunkDesc { struct ChunkDesc {
char chunkName[13]; char chunkName[13];
uint32 size; uint32 size;
uint32 offset; uint32 offset;
byte packed; 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); int16 file_open(const char *path, Common::File::AccessMode mode = Common::File::kFileReadMode);
Common::File *file_getHandle(int16 handle); Common::File *file_getHandle(int16 handle);
int16 data_getChunk(const char *chunkName); int16 getChunk(const char *chunkName);
char data_freeChunk(int16 handle); char freeChunk(int16 handle);
int32 data_readChunk(int16 handle, char *buf, int16 size); int32 readChunk(int16 handle, char *buf, int16 size);
int16 data_seekChunk(int16 handle, int32 pos, int16 from); int16 seekChunk(int16 handle, int32 pos, int16 from);
int32 data_getChunkSize(const char *chunkName); int32 getChunkSize(const char *chunkName);
void data_openDataFile(const char *src); void openDataFile(const char *src);
void data_closeDataFile(void); void closeDataFile(void);
char *data_getUnpackedData(const char *name); char *getUnpackedData(const char *name);
void data_closeData(int16 handle); void closeData(int16 handle);
int16 data_openData(const char *path, Common::File::AccessMode mode = Common::File::kFileReadMode); int16 openData(const char *path, Common::File::AccessMode mode = Common::File::kFileReadMode);
int32 data_readData(int16 handle, char *buf, int16 size); int32 readData(int16 handle, char *buf, int16 size);
void data_seekData(int16 handle, int32 pos, int16 from); void seekData(int16 handle, int32 pos, int16 from);
int32 data_getDataSize(const char *name); int32 getDataSize(const char *name);
char *data_getData(const char *path); char *getData(const char *path);
char *data_getSmallData(const char *path); char *getSmallData(const char *path);
DataIO(class GobEngine *vm);
protected:
class GobEngine *_vm;
};
} // End of namespace Gob } // End of namespace Gob

943
gob/draw.cpp
View file

File diff suppressed because it is too large Load diff

134
gob/draw.h
View file

@ -31,81 +31,95 @@ namespace Gob {
#define RENDERFLAG_CAPTUREPOP 8 #define RENDERFLAG_CAPTUREPOP 8
#define RENDERFLAG_USEDELTAS 0x10 #define RENDERFLAG_USEDELTAS 0x10
typedef struct Draw_FontToSprite { class Draw {
public:
typedef struct FontToSprite {
int8 sprite; int8 sprite;
int8 base; int8 base;
int8 width; int8 width;
int8 height; int8 height;
} Draw_FontToSprite; FontToSprite() : sprite(0), base(0), width(0), height() {}
} FontToSprite;
extern int16 draw_fontIndex; int16 fontIndex;
extern int16 draw_spriteLeft; int16 spriteLeft;
extern int16 draw_spriteTop; int16 spriteTop;
extern int16 draw_spriteRight; int16 spriteRight;
extern int16 draw_spriteBottom; int16 spriteBottom;
extern int16 draw_destSpriteX; int16 destSpriteX;
extern int16 draw_destSpriteY; int16 destSpriteY;
extern int16 draw_backColor; int16 backColor;
extern int16 draw_frontColor; int16 frontColor;
extern char draw_letterToPrint; char letterToPrint;
extern Draw_FontToSprite draw_fontToSprite[4]; FontToSprite fontToSprite[4];
extern int16 draw_destSurface; int16 destSurface;
extern int16 draw_sourceSurface; int16 sourceSurface;
extern int16 draw_renderFlags; int16 renderFlags;
extern int16 draw_backDeltaX; int16 backDeltaX;
extern int16 draw_backDeltaY; int16 backDeltaY;
extern FontDesc *draw_fonts[4]; Video::FontDesc *fonts[4];
extern char *draw_textToPrint; char *textToPrint;
extern int16 draw_transparency; int16 transparency;
extern SurfaceDesc *draw_spritesArray[50]; Video::SurfaceDesc *spritesArray[50];
extern int16 draw_invalidatedCount; int16 invalidatedCount;
extern int16 draw_invalidatedTops[30]; int16 invalidatedTops[30];
extern int16 draw_invalidatedLefts[30]; int16 invalidatedLefts[30];
extern int16 draw_invalidatedRights[30]; int16 invalidatedRights[30];
extern int16 draw_invalidatedBottoms[30]; int16 invalidatedBottoms[30];
extern int8 draw_noInvalidated; int8 noInvalidated;
extern int8 draw_doFullFlip; // int8 doFullFlip; // Never used?!?
extern int8 draw_paletteCleared; int8 paletteCleared;
extern int16 draw_cursorIndex; int16 gcursorIndex;
extern int16 draw_transparentCursor; int16 transparentCursor;
uint32 cursorTimeKey;
extern SurfaceDesc *draw_backSurface; Video::SurfaceDesc *backSurface;
extern SurfaceDesc *draw_frontSurface; Video::SurfaceDesc *frontSurface;
extern int16 draw_unusedPalette1[18]; int16 unusedPalette1[18];
extern int16 draw_unusedPalette2[16]; int16 unusedPalette2[16];
extern Color draw_vgaPalette[256]; Video::Color vgaPalette[256];
extern Color draw_vgaSmallPalette[16]; Video::Color vgaSmallPalette[16];
extern int16 draw_cursorX; int16 cursorX;
extern int16 draw_cursorY; int16 cursorY;
extern int16 draw_cursorWidth; int16 cursorWidth;
extern int16 draw_cursorHeight; int16 cursorHeight;
extern int16 draw_cursorXDeltaVar; int16 cursorXDeltaVar;
extern int16 draw_cursorYDeltaVar; int16 cursorYDeltaVar;
extern SurfaceDesc *draw_cursorSprites; Video::SurfaceDesc *cursorSprites;
extern SurfaceDesc *draw_cursorBack; Video::SurfaceDesc *cursorBack;
extern int16 draw_cursorAnim; int16 cursorAnim;
extern int8 draw_cursorAnimLow[40]; int8 cursorAnimLow[40];
extern int8 draw_cursorAnimHigh[40]; int8 cursorAnimHigh[40];
extern int8 draw_cursorAnimDelays[40]; int8 cursorAnimDelays[40];
extern int8 draw_applyPal; int8 applyPal;
void draw_invalidateRect(int16 left, int16 top, int16 right, int16 bottom); int16 palLoadData1[4];
void draw_blitInvalidated(void); int16 palLoadData2[4];
void draw_setPalette(void);
void draw_clearPalette(void); void invalidateRect(int16 left, int16 top, int16 right, int16 bottom);
void draw_blitCursor(void); 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;
};
void draw_spriteOperation(int16 operation);
void draw_animateCursor(int16 cursor);
void draw_interPalLoad(void);
void draw_printText(void);
// Draw operations // Draw operations
#define DRAW_BLITSURF 0 #define DRAW_BLITSURF 0

14
gob/driver_vga.cpp
View file

@ -30,7 +30,7 @@
namespace Gob { 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) { if (x >= 0 && x < dest->width && y >= 0 && y < dest->height) {
int16 width = (right - left) + 1; int16 width = (right - left) + 1;
int16 height = (bottom - top) + 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) { if (left < dest->width && right < dest->width && top < dest->height && bottom < dest->height) {
byte *pos = dest->vidPtr + (top * dest->width) + left; byte *pos = dest->vidPtr + (top * dest->width) + left;
int16 width = (right - left) + 1; 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) if (x >= 0 && x < dest->width && y >= 0 && y < dest->height)
dest->vidPtr[(y * dest->width) + x] = color; 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; byte *src, *dst;
uint16 data; uint16 data;
int i, j; 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) { 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) if (x >= 0 && x < dest->width && y >= 0 && y < dest->height)
dest->vidPtr[(y * dest->width) + x] = color; 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); 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 destRight = x + width;
int destBottom = y + height; int destBottom = y + height;

12
gob/driver_vga.h
View file

@ -30,12 +30,12 @@ class VGAVideoDriver : public VideoDriver {
public: public:
VGAVideoDriver() {} VGAVideoDriver() {}
virtual ~VGAVideoDriver() {} virtual ~VGAVideoDriver() {}
void drawSprite(SurfaceDesc *source, SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, int16 x, int16 y, int16 transp); void drawSprite(Video::SurfaceDesc *source, Video::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 fillRect(Video::SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 bottom, byte color);
void putPixel(int16 x, int16 y, byte color, SurfaceDesc *dest); void putPixel(int16 x, int16 y, byte color, Video::SurfaceDesc *dest);
void drawLetter(unsigned char item, int16 x, int16 y, FontDesc *fontDesc, byte color1, byte color2, byte transp, 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(SurfaceDesc *dest, int16 x0, int16 y0, int16 x1, int16 y1, byte color); 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, SurfaceDesc *dest); void drawPackedSprite(byte *sprBuf, int16 width, int16 height, int16 x, int16 y, byte transp, Video::SurfaceDesc *dest);
}; };
} }

1477
gob/game.cpp
View file

File diff suppressed because it is too large Load diff

225
gob/game.h
View file

@ -26,51 +26,12 @@
namespace Gob { namespace Gob {
class Game {
public:
#pragma START_PACK_STRUCTS #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;
#define szGame_TotResItem (4 + 2 + 2 + 2) #define szGame_TotResItem (4 + 2 + 2 + 2)
typedef struct Game_TotResItem { typedef struct Collision {
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;
#define szGame_TotResTable (2 + 1)
typedef struct Game_TotResTable {
int16 itemsCount;
byte unknown;
Game_TotResItem items[1];
} GCC_PACK Game_TotResTable;
#define szGame_TotTextItem (2 + 2)
typedef struct Game_TotTextItem {
int16 offset;
int16 size;
} GCC_PACK Game_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 id;
int16 left; int16 left;
int16 top; int16 top;
@ -80,85 +41,147 @@ typedef struct Game_Collision {
int16 key; int16 key;
int16 funcEnter; int16 funcEnter;
int16 funcLeave; int16 funcLeave;
} GCC_PACK Game_Collision; } GCC_PACK Collision;
typedef struct Game_InputDesc { 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 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 TotTextItem {
int16 offset;
int16 size;
} GCC_PACK TotTextItem;
#define szGame_TotTextTable (2)
typedef struct TotTextTable {
int16 itemsCount;
TotTextItem items[1];
} GCC_PACK TotTextTable;
typedef struct InputDesc {
int16 fontIndex; int16 fontIndex;
int16 backColor; int16 backColor;
int16 frontColor; int16 frontColor;
char *ptr; char *ptr;
} GCC_PACK Game_InputDesc; } GCC_PACK InputDesc;
#pragma END_PACK_STRUCTS #pragma END_PACK_STRUCTS
extern Game_Collision *game_collisionAreas; TotResTable *totResourceTable;
Collision *collisionAreas;
Collision *collStack[3];
extern int16 game_lastCollKey; TotTextTable *totTextData;
extern int16 game_lastCollAreaIndex;
extern int16 game_lastCollId;
extern int16 game_activeCollResId; char curTotFile[14];
extern int16 game_activeCollIndex; char curExtFile[14];
extern char game_handleMouse;
extern char game_forceHandleMouse;
extern char game_tempStr[256]; char *imFileData;
char *totFileData;
extern Game_ExtTable *game_extTable; int16 extHandle;
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; Snd::SoundDesc *soundSamples[20];
extern Game_Collision *game_collStack[3];
extern int16 game_collStackElemSizes[3];
extern int16 game_mouseButtons; char totToLoad[20];
extern Snd_SoundDesc *game_soundSamples[20]; int32 startTimeKey;
int16 mouseButtons;
extern char game_soundFromExt[20]; Game(GobEngine *vm);
extern char game_totToLoad[20];
extern int32 game_startTimeKey; char *loadExtData(int16 dataId, int16 *pResWidth, int16 *pResHeight);
extern char game_shouldPushColls; char *loadTotResource(int16 id);
// Functions void capturePush(int16 left, int16 top, int16 width, int16 height);
char *game_loadExtData(int16 dataId, int16 *pResWidth, int16 *pResHeight); void capturePop(char doDraw);
void game_clearCollisions(void); void interLoadSound(int16 slot);
void game_addNewCollision(int16 val_0, int16 left, int16 top, int16 right, int16 bottom, void freeSoundSlot(int16 slot);
int16 flags, int16 key, int16 val_E, int16 val_10); int16 checkKeys(int16 *pMousex, int16 *pMouseY, int16 *pButtons,
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); char handleMouse);
int16 game_checkCollisions(char handleMouse, int16 deltaTime, int16 *pResId, int16 checkCollisions(char handleMouse, int16 deltaTime, int16 *pResId,
int16 *pResIndex); int16 *pResIndex);
int16 game_inputArea(int16 xPos, int16 yPos, int16 width, int16 height, int16 backColor, 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 frontColor, char *str, int16 fontIndex, char inpType, int16 *pTotTime);
int16 game_multiEdit(int16 time, int16 index, int16 *pCurPos, int16 multiEdit(int16 time, int16 index, int16 *pCurPos,
Game_InputDesc * inpDesc); InputDesc * inpDesc);
int16 game_adjustKey(int16 key); int16 adjustKey(int16 key);
void game_collisionsBlock(void); void collisionsBlock(void);
void game_prepareStart(void); void prepareStart(void);
void game_loadTotFile(char *path); void loadTotFile(char *path);
void game_loadExtTable(void); void loadExtTable(void);
void game_loadImFile(void); void loadImFile(void);
void game_playTot(int16 skipPlay); void playTot(int16 skipPlay);
void game_start(void); 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 } // End of namespace Gob

185
gob/global.cpp
View file

@ -24,135 +24,130 @@
namespace Gob { namespace Gob {
char pressedKeys[128]; Global::Global(GobEngine *vm) : _vm(vm) {
useMouse = UNDEF;
mousePresent = UNDEF;
char useMouse = UNDEF; presentCGA = UNDEF;
int16 mousePresent = UNDEF; presentEGA = UNDEF;
presentVGA = UNDEF;
presentHER = UNDEF;
int16 presentCGA = UNDEF; videoMode = 0;
int16 presentEGA = UNDEF;
int16 presentVGA = UNDEF;
int16 presentHER = UNDEF;
int16 videoMode = 0;
int16 disableVideoCfg;
/* Sound */ /* Sound */
uint16 presentSound = 0x8000; /* undefined values */ presentSound = 0x8000; /* undefined values */
uint16 soundFlags = 0x8000; soundFlags = 0x8000;
int16 blasterPort = 0; blasterPort = 0;
int16 disableSoundCfg = 0; disableSoundCfg = 0;
//char playingSound = 0; //char playingSound = 0;
/* Mouse */ /* Mouse */
int16 disableMouseCfg = 0; disableMouseCfg = 0;
int16 mouseXShift = 3; mouseXShift = 3;
int16 mouseYShift = 3; mouseYShift = 3;
int16 mouseMaxCol = 320; mouseMaxCol = 320;
int16 mouseMaxRow = 200; mouseMaxRow = 200;
/* Language */ /* Language */
uint16 disableLangCfg = 0x8000; disableLangCfg = 0x8000;
uint16 language = 0x8000; language = 0x8000;
/* Timer variables */ /* Timer variables */
int32 startTime = 0; startTime = 0;
int16 timer_delta = 1000; timer_delta = 1000;
int16 frameWaitTime = 0; frameWaitTime = 0;
int32 startFrameTime = 0; startFrameTime = 0;
/* Timer and delays */ /* Timer and delays */
int16 delayTime = 0; delayTime = 0;
/* Joystick */ /* Joystick */
char useJoystick = 1; useJoystick = 1;
/* Files */
Common::File filesHandles[MAX_FILES];
/* Data files */ /* Data files */
struct ChunkDesc *dataFiles[MAX_DATA_FILES]; packedSize = 0;
int16 numDataChunks[MAX_DATA_FILES]; for (int i = 0; i < MAX_DATA_FILES; i++) {
int16 dataFileHandles[MAX_DATA_FILES]; dataFiles[i] = 0;
int32 chunkPos[MAX_SLOT_COUNT * MAX_DATA_FILES]; numDataChunks[i] = 0;
int32 chunkOffset[MAX_SLOT_COUNT * MAX_DATA_FILES]; dataFileHandles[i] = -1;
int32 chunkSize[MAX_SLOT_COUNT * MAX_DATA_FILES]; }
char isCurrentSlot[MAX_SLOT_COUNT * MAX_DATA_FILES];
int32 packedSize = 0;
int16 sprAllocated = 0; primaryWidth = 0;
primaryHeight = 0;
SurfaceDesc primarySurfDesc; sprAllocated = 0;
SurfaceDesc *pPrimarySurfDesc;
int16 primaryWidth; doRangeClamp = 0;
int16 primaryHeight;
int16 doRangeClamp = 0; setAllPalette = 0;
char redPalette[256]; oldMode = 3;
char greenPalette[256]; dontSetPalette = 0;
char bluePalette[256]; curPrimaryDesc = 0;
allocatedPrimary = 0;
pPrimarySurfDesc = 0;
int16 setAllPalette = 0; pPaletteDesc = 0;
int16 oldMode = 3; unusedPalette1[0] = (int16)0;
char dontSetPalette = 0; unusedPalette1[1] = (int16)0x0b;
SurfaceDesc *curPrimaryDesc = 0; unusedPalette1[2] = (int16)0;
SurfaceDesc *allocatedPrimary = 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;
PalDesc *pPaletteDesc = 0; for (int i = 0; i < 16 ;i++)
unusedPalette2[i] = i;
int16 unusedPalette1[18] = { vgaPalette[0].red = 0x00; vgaPalette[0].green = 0x00; vgaPalette[0].blue = 0x00;
0, 0x0b, 0, (int16)0x5555, (int16)0xAAAA, (int16)0xFFFF, 0, (int16)0x5555, vgaPalette[1].red = 0x00; vgaPalette[1].green = 0x00; vgaPalette[1].blue = 0x2a;
(int16)0xAAAA, (int16)0xFFFF, 0, (int16)0x5555, vgaPalette[2].red = 0x00; vgaPalette[2].green = 0x2a; vgaPalette[2].blue = 0x00;
(int16)0xAAAA, (int16)0xFFFF, 0, (int16)0x5555, (int16)0xAAAA, (int16)0xFFFF 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;
int16 unusedPalette2[] = { debugFlag = 0;
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 inVM = 0;
}; colorCount = 16;
Color vgaPalette[16] = { inter_resStr[0] = 0;
{0x00, 0x00, 0x00}, inter_resVal = 0;
{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; inter_variables = 0;
inter_execPtr = 0;
inter_animDataSize = 10;
int16 debugFlag = 0; inter_mouseX = 0;
int16 inVM = 0; inter_mouseY = 0;
int16 colorCount = 16;
char inter_resStr[200]; tmpPalBuffer = 0;
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;
} // End of namespace Gob } // End of namespace Gob

179
gob/global.h
View file

@ -29,29 +29,11 @@
namespace Gob { 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_CGA 0x05
#define VIDMODE_EGA 0x0d #define VIDMODE_EGA 0x0d
#define VIDMODE_VGA 0x13 #define VIDMODE_VGA 0x13
#define VIDMODE_HER 7 #define VIDMODE_HER 7
extern uint16 presentSound;
extern uint16 soundFlags;
extern int16 disableSoundCfg;
#define PROAUDIO_FLAG 0x10 #define PROAUDIO_FLAG 0x10
#define ADLIB_FLAG 0x08 #define ADLIB_FLAG 0x08
#define BLASTER_FLAG 0x04 #define BLASTER_FLAG 0x04
@ -59,9 +41,6 @@ extern int16 disableSoundCfg;
#define SPEAKER_FLAG 0x01 #define SPEAKER_FLAG 0x01
#define MIDI_FLAG 0x4000 #define MIDI_FLAG 0x4000
extern uint16 disableLangCfg;
extern uint16 language;
#define NO 0 #define NO 0
#define YES 1 #define YES 1
#define UNDEF 2 #define UNDEF 2
@ -75,42 +54,8 @@ extern uint16 language;
#define ESCAPE 0x001b #define ESCAPE 0x001b
#define ENTER 0x000d #define ENTER 0x000d
/* Timer variables */
extern int32 startTime;
extern int16 timer_delta;
extern int16 frameWaitTime;
extern int32 startFrameTime;
/* Mouse */
extern int16 disableMouseCfg;
extern int16 mouseXShift;
extern int16 mouseYShift;
extern int16 mouseMaxCol;
extern int16 mouseMaxRow;
/* Timer and delays */
extern int16 delayTime;
/* Joystick */
extern char useJoystick;
/* Files */
#define MAX_FILES 30 #define MAX_FILES 30
extern Common::File filesHandles[MAX_FILES];
/* 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;
/* Video drivers */ /* Video drivers */
#define UNK_DRIVER 0 #define UNK_DRIVER 0
#define VGA_DRIVER 1 #define VGA_DRIVER 1
@ -118,49 +63,113 @@ extern int32 packedSize;
#define CGA_DRIVER 3 #define CGA_DRIVER 3
#define HER_DRIVER 4 #define HER_DRIVER 4
extern SurfaceDesc primarySurfDesc; class Global {
extern SurfaceDesc *pPrimarySurfDesc; public:
extern int16 sprAllocated; char pressedKeys[128];
extern int16 primaryWidth; char useMouse;
extern int16 primaryHeight; int16 mousePresent;
extern int16 doRangeClamp; int16 presentCGA;
int16 presentEGA;
int16 presentVGA;
int16 presentHER;
extern char redPalette[256]; int16 videoMode;
extern char greenPalette[256];
extern char bluePalette[256];
extern int16 setAllPalette; int16 disableVideoCfg;
extern SurfaceDesc *curPrimaryDesc; uint16 presentSound;
extern SurfaceDesc *allocatedPrimary; uint16 soundFlags;
int16 disableSoundCfg;
int16 blasterPort;
extern int16 oldMode; uint16 disableLangCfg;
extern char dontSetPalette; uint16 language;
extern PalDesc *pPaletteDesc; // Timer variables
int32 startTime;
int16 timer_delta;
extern int16 unusedPalette1[18]; int16 frameWaitTime;
extern int16 unusedPalette2[16]; int32 startFrameTime;
extern Color vgaPalette[16];
extern PalDesc paletteStruct;
extern int16 debugFlag; // Mouse
extern int16 inVM; int16 disableMouseCfg;
extern int16 colorCount;
extern char inter_resStr[200]; int16 mouseXShift;
extern int32 inter_resVal; int16 mouseYShift;
int16 mouseMaxCol;
int16 mouseMaxRow;
extern char *inter_variables; // Timer and delays
extern char *inter_execPtr; int16 delayTime;
extern int16 inter_animDataSize;
extern int16 inter_mouseX; // Joystick
extern int16 inter_mouseY; char useJoystick;
extern char *tmpPalBuffer; // 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;
int16 doRangeClamp;
char redPalette[256];
char greenPalette[256];
char bluePalette[256];
int16 setAllPalette;
Video::SurfaceDesc *curPrimaryDesc;
Video::SurfaceDesc *allocatedPrimary;
Video::SurfaceDesc_t primarySurfDesc;
Video::SurfaceDesc *pPrimarySurfDesc;
int16 oldMode;
char dontSetPalette;
Video::PalDesc *pPaletteDesc;
int16 unusedPalette1[18];
int16 unusedPalette2[16];
Video::Color vgaPalette[16];
Video::PalDesc paletteStruct;
int16 debugFlag;
int16 inVM;
int16 colorCount;
char inter_resStr[200];
int32 inter_resVal;
char *inter_variables;
char *inter_execPtr;
int16 inter_animDataSize;
int16 inter_mouseX;
int16 inter_mouseY;
char *tmpPalBuffer;
Global(GobEngine *vm);
protected:
GobEngine *_vm;
};
} // End of namespace Gob } // End of namespace Gob

137
gob/gob.cpp
View file

@ -31,6 +31,19 @@
#include "gob/game.h" #include "gob/game.h"
#include "gob/sound.h" #include "gob/sound.h"
#include "gob/init.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 { enum {
// We only compute MD5 of the first megabyte of our data files. // We only compute MD5 of the first megabyte of our data files.
@ -50,53 +63,53 @@ struct GobGameSettings {
static const GobGameSettings gob_games[] = { static const GobGameSettings gob_games[] = {
// Supplied by Florian Zeitz on scummvm-devel // Supplied by Florian Zeitz on scummvm-devel
{"gob1", "Gobliiins (DOS EGA)", GF_GOB1, "82aea70ef26f41fa963dfae270993e49"}, {"gob1", "Gobliiins (DOS EGA)", Gob::GF_GOB1, "82aea70ef26f41fa963dfae270993e49"},
{"gob1", "Gobliiins (DOS EGA)", GF_GOB1, "1f499458837008058b8ba6ae07057214"}, {"gob1", "Gobliiins (DOS EGA)", Gob::GF_GOB1, "1f499458837008058b8ba6ae07057214"},
{"gob1", "Gobliiins (Windows)", GF_GOB1, "8a5e850c49d7cacdba5f5eb1fcc77b89"}, {"gob1", "Gobliiins (Windows)", Gob::GF_GOB1, "8a5e850c49d7cacdba5f5eb1fcc77b89"},
// Supplied by Theruler76 in bug report #1201233 // 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 // 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 // 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)", Gob::GF_GOB1, "d9f8736b7dc0ea891cd06592a72e8a72"},
{"gob1", "Gobliiins (Amiga)", GF_GOB1, "69f9ae85252271e7dfa62883e581e5e9"}, {"gob1", "Gobliiins (Amiga)", Gob::GF_GOB1, "69f9ae85252271e7dfa62883e581e5e9"},
{"gob1", "Gobliiins (Amiga)", GF_GOB1, "26de406cb09228d902274446a6a2eceb"}, {"gob1", "Gobliiins (Amiga)", Gob::GF_GOB1, "26de406cb09228d902274446a6a2eceb"},
{"gob1", "Gobliiins (Amiga)", GF_GOB1, "baf88a95928edb3f51067983f2dffa93"}, {"gob1", "Gobliiins (Amiga)", Gob::GF_GOB1, "baf88a95928edb3f51067983f2dffa93"},
{"gob1", "Gobliiins (Interactive Demo)", GF_GOB1, "4f5bf4b9e4c39ebb93579747fc678e97"}, {"gob1", "Gobliiins (Interactive Demo)", Gob::GF_GOB1, "4f5bf4b9e4c39ebb93579747fc678e97"},
#if 0 #if 0
{"gob2", "Gobliins 2 (DOS)", GF_GOB2, "abb5f762f9979d4253002de20f6e7b56"}, {"gob2", "Gobliins 2 (DOS)", Gob::GF_GOB2, "abb5f762f9979d4253002de20f6e7b56"},
{"gob2", "Gobliins 2 (DOS)", GF_GOB2, "9b6de65d811c08eebf50391b84fcba92"}, {"gob2", "Gobliins 2 (DOS)", Gob::GF_GOB2, "9b6de65d811c08eebf50391b84fcba92"},
{"gob2", "Gobliins 2 (DOS)", GF_GOB2, "54d59c200e3823ad0af11a605a6fd06a"}, {"gob2", "Gobliins 2 (DOS)", Gob::GF_GOB2, "54d59c200e3823ad0af11a605a6fd06a"},
{"gob2", "Gobliins 2 (DOS Ru)", GF_GOB2, "b6d47494bf88398ae59c1b5656cafce4"}, {"gob2", "Gobliins 2 (DOS Ru)", Gob::GF_GOB2, "b6d47494bf88398ae59c1b5656cafce4"},
// CD 1.000. // CD 1.000.
{"gob2", "Gobliins 2 (CD)", GF_GOB2, "02bf538fd8003b8da23a3546299c3df4"}, {"gob2", "Gobliins 2 (CD)", Gob::GF_GOB2, "02bf538fd8003b8da23a3546299c3df4"},
// CD 1.01 // CD 1.01
{"gob2", "Gobliins 2 (CD)", GF_GOB2, "410e632682ab11969bc3b3b588066d95"}, {"gob2", "Gobliins 2 (CD)", Gob::GF_GOB2, "410e632682ab11969bc3b3b588066d95"},
{"gob2", "Gobliins 2 (Demo)", GF_GOB2, "be8b111191f965ac9b28fe530580d14e"}, {"gob2", "Gobliins 2 (Demo)", Gob::GF_GOB2, "be8b111191f965ac9b28fe530580d14e"},
{"gob3", "Goblins Quest 3", GF_GOB3, "36d9b4032b39a794c8640e500e98893a"}, {"gob3", "Goblins Quest 3", Gob::GF_GOB3, "36d9b4032b39a794c8640e500e98893a"},
{"gob3", "Goblins Quest 3", GF_GOB3, "d129f639f6ca8d6b5f0f4e15edb91058"}, {"gob3", "Goblins Quest 3", Gob::GF_GOB3, "d129f639f6ca8d6b5f0f4e15edb91058"},
{"gob3", "Goblins Quest 3", GF_GOB3, "8d17b0abc514b1512fdedc6072acd48b"}, {"gob3", "Goblins Quest 3", Gob::GF_GOB3, "8d17b0abc514b1512fdedc6072acd48b"},
// CD 1.000 // 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 // 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 (Interactive Demo)", Gob::GF_GOB3, "4986b44cec309589508d7904f924c217"},
{"gob3", "Goblins Quest 3 (Demo)", GF_GOB3, "5024e7de8d6377fbbeabbaa92e0452bc"}, {"gob3", "Goblins Quest 3 (Demo)", Gob::GF_GOB3, "5024e7de8d6377fbbeabbaa92e0452bc"},
{"gob3", "Goblins Quest 3 (Interactive Demo)", GF_GOB3, "59ab69dab5fddbbf698c77a84297a5a2"}, {"gob3", "Goblins Quest 3 (Interactive Demo)", Gob::GF_GOB3, "59ab69dab5fddbbf698c77a84297a5a2"},
// CD 1.0 // 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?) // 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 #endif
{0, 0, 0, 0} {0, 0, 0, 0}
}; };
@ -111,8 +124,8 @@ static const struct GobGameList {
return dummy; return dummy;
} }
} gob_list[] = { } gob_list[] = {
{"gob1", "Gobliiins", GF_GOB1}, {"gob1", "Gobliiins", Gob::GF_GOB1},
{"gob2", "Gobliins 2", GF_GOB2}, {"gob2", "Gobliins 2", Gob::GF_GOB2},
{0, 0, 0} {0, 0, 0}
}; };
@ -183,7 +196,6 @@ namespace Gob {
GobEngine *_vm = NULL; GobEngine *_vm = NULL;
GobEngine::GobEngine(GameDetector *detector, OSystem * syst) : Engine(syst) { GobEngine::GobEngine(GameDetector *detector, OSystem * syst) : Engine(syst) {
// Setup mixer // Setup mixer
if (!_mixer->isReady()) { if (!_mixer->isReady()) {
warning("Sound initialization failed."); warning("Sound initialization failed.");
@ -232,6 +244,25 @@ GobEngine::GobEngine(GameDetector *detector, OSystem * syst) : Engine(syst) {
} }
GobEngine::~GobEngine() { 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) { 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) { 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(); _system->beginGFXTransaction();
initCommonGFX(detector); initCommonGFX(detector);
_system->initSize(320, 200); _system->initSize(320, 200);
@ -252,30 +303,30 @@ int GobEngine::init(GameDetector &detector) {
if (cd_num >= 0) if (cd_num >= 0)
_system->openCD(cd_num); _system->openCD(cd_num);
debugFlag = 1; _global->debugFlag = 1;
doRangeClamp = 1; _global->doRangeClamp = 1;
videoMode = 0x13; _global->videoMode = 0x13;
snd_soundPort = 1; _snd->soundPort = 1;
useMouse = 1; _global->useMouse = 1;
soundFlags = 0; _global->soundFlags = 0;
switch (Common::parseLanguage(ConfMan.get("language"))) { switch (Common::parseLanguage(ConfMan.get("language"))) {
case Common::FR_FRA: case Common::FR_FRA:
language = 0; _global->language = 0;
break; break;
case Common::DE_DEU: case Common::DE_DEU:
language = 1; _global->language = 1;
break; break;
case Common::ES_ESP: case Common::ES_ESP:
language = 3; _global->language = 3;
break; break;
case Common::IT_ITA: case Common::IT_ITA:
language = 4; _global->language = 4;
break; break;
default: default:
// Default to English // Default to English
language = 2; _global->language = 2;
break; break;
} }
@ -289,7 +340,7 @@ int GobEngine::init(GameDetector &detector) {
} }
int GobEngine::go() { int GobEngine::go() {
init_initGame(0); _init->initGame(0);
return 0; return 0;
} }

51
gob/gob.h
View file

@ -29,15 +29,39 @@
#include "base/engine.h" #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(var) VAR_OFFSET((var) << 2)
#define VAR_ADDRESS(var) (&VAR(var)) #define VAR_ADDRESS(var) (&VAR(var))
#define WRITE_VAR_OFFSET(offs, val) (VAR_OFFSET(offs) = (val)) #define WRITE_VAR_OFFSET(offs, val) (VAR_OFFSET(offs) = (val))
#define WRITE_VAR(var, val) WRITE_VAR_OFFSET((var) << 2, (val)) #define WRITE_VAR(var, val) WRITE_VAR_OFFSET((var) << 2, (val))
// TODO: Should be in the Gob namespace, I guess
enum { enum {
GF_GOB1 = 1 << 0, GF_GOB1 = 1 << 0,
GF_GOB2 = 1 << 1, GF_GOB2 = 1 << 1,
@ -46,8 +70,6 @@ enum {
GF_CD = 1 << 4 GF_CD = 1 << 4
}; };
namespace Gob {
class GobEngine : public Engine { class GobEngine : public Engine {
void errorString(const char *buf_input, char *buf_output); void errorString(const char *buf_input, char *buf_output);
@ -64,6 +86,25 @@ public:
Common::RandomSource _rnd; Common::RandomSource _rnd;
int32 _features; 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; extern GobEngine *_vm;

2638
gob/goblin.cpp
View file

File diff suppressed because it is too large Load diff

232
gob/goblin.h
View file

@ -31,6 +31,8 @@ namespace Gob {
#define TYPE_AMORPHOUS 1 #define TYPE_AMORPHOUS 1
#define TYPE_MOBILE 3 #define TYPE_MOBILE 3
class Goblin {
public:
#pragma START_PACK_STRUCTS #pragma START_PACK_STRUCTS
typedef struct Gob_State { typedef struct Gob_State {
int16 animation;// +0h int16 animation;// +0h
@ -43,7 +45,7 @@ typedef struct Gob_State {
int16 sndFrame; // +Eh int16 sndFrame; // +Eh
} GCC_PACK Gob_State; } GCC_PACK Gob_State;
typedef struct Gob_State *Gob_PState; typedef Gob_State *Gob_PState;
#define szGob_StateLine 24 #define szGob_StateLine 24
typedef Gob_PState Gob_StateLine[6]; typedef Gob_PState Gob_StateLine[6];
@ -89,117 +91,141 @@ typedef struct Gob_Pos {
} GCC_PACK Gob_Pos; } GCC_PACK Gob_Pos;
#pragma END_PACK_STRUCTS #pragma END_PACK_STRUCTS
extern Util_List *gob_objList; Util::List *objList;
extern Gob_Object *gob_goblins[4]; Gob_Object *goblins[4];
extern int16 gob_currentGoblin; int16 currentGoblin;
extern Snd_SoundDesc *gob_soundData[16]; Snd::SoundDesc *soundData[16];
extern int16 gob_gobStateLayer; int16 gobStateLayer;
extern char gob_goesAtTarget; char goesAtTarget;
extern char gob_readyToAct; char readyToAct;
extern int16 gob_gobAction; // 0 - move, 3 - do action, 4 - pick int16 gobAction; // 0 - move, 3 - do action, 4 - pick
// goblins 0 - picker, 1 - fighter, 2 - mage // goblins 0 - picker, 1 - fighter, 2 - mage
extern Gob_Pos gob_gobPositions[3]; Gob_Pos gobPositions[3];
extern int16 gob_gobDestX; int16 gobDestX;
extern int16 gob_gobDestY; int16 gobDestY;
extern int16 gob_pressedMapX; int16 pressedMapX;
extern int16 gob_pressedMapY; int16 pressedMapY;
extern char gob_pathExistence; char pathExistence;
// Pointers to interpreter variables // Pointers to interpreter variables
extern int32 *gob_some0ValPtr; int32 *some0ValPtr;
extern int32 *gob_gobRetVarPtr; int32 *gobRetVarPtr;
extern int32 *gob_curGobVarPtr; int32 *curGobVarPtr;
extern int32 *gob_curGobXPosVarPtr; int32 *curGobXPosVarPtr;
extern int32 *gob_curGobYPosVarPtr; int32 *curGobYPosVarPtr;
extern int32 *gob_itemInPocketVarPtr; int32 *itemInPocketVarPtr;
extern int32 *gob_curGobStateVarPtr; int32 *curGobStateVarPtr;
extern int32 *gob_curGobFrameVarPtr; int32 *curGobFrameVarPtr;
extern int32 *gob_curGobMultStateVarPtr; int32 *curGobMultStateVarPtr;
extern int32 *gob_curGobNextStateVarPtr; int32 *curGobNextStateVarPtr;
extern int32 *gob_curGobScrXVarPtr; int32 *curGobScrXVarPtr;
extern int32 *gob_curGobScrYVarPtr; int32 *curGobScrYVarPtr;
extern int32 *gob_curGobLeftVarPtr; int32 *curGobLeftVarPtr;
extern int32 *gob_curGobTopVarPtr; int32 *curGobTopVarPtr;
extern int32 *gob_curGobRightVarPtr; int32 *curGobRightVarPtr;
extern int32 *gob_curGobBottomVarPtr; int32 *curGobBottomVarPtr;
extern int32 *gob_curGobDoAnimVarPtr; int32 *curGobDoAnimVarPtr;
extern int32 *gob_curGobOrderVarPtr; int32 *curGobOrderVarPtr;
extern int32 *gob_curGobNoTickVarPtr; int32 *curGobNoTickVarPtr;
extern int32 *gob_curGobTypeVarPtr; int32 *curGobTypeVarPtr;
extern int32 *gob_curGobMaxTickVarPtr; int32 *curGobMaxTickVarPtr;
extern int32 *gob_curGobTickVarPtr; int32 *curGobTickVarPtr;
extern int32 *gob_curGobActStartStateVarPtr; int32 *curGobActStartStateVarPtr;
extern int32 *gob_curGobLookDirVarPtr; int32 *curGobLookDirVarPtr;
extern int32 *gob_curGobPickableVarPtr; int32 *curGobPickableVarPtr;
extern int32 *gob_curGobRelaxVarPtr; int32 *curGobRelaxVarPtr;
extern int32 *gob_curGobMaxFrameVarPtr; int32 *curGobMaxFrameVarPtr;
extern int32 *gob_destItemStateVarPtr; int32 *destItemStateVarPtr;
extern int32 *gob_destItemFrameVarPtr; int32 *destItemFrameVarPtr;
extern int32 *gob_destItemMultStateVarPtr; int32 *destItemMultStateVarPtr;
extern int32 *gob_destItemNextStateVarPtr; int32 *destItemNextStateVarPtr;
extern int32 *gob_destItemScrXVarPtr; int32 *destItemScrXVarPtr;
extern int32 *gob_destItemScrYVarPtr; int32 *destItemScrYVarPtr;
extern int32 *gob_destItemLeftVarPtr; int32 *destItemLeftVarPtr;
extern int32 *gob_destItemTopVarPtr; int32 *destItemTopVarPtr;
extern int32 *gob_destItemRightVarPtr; int32 *destItemRightVarPtr;
extern int32 *gob_destItemBottomVarPtr; int32 *destItemBottomVarPtr;
extern int32 *gob_destItemDoAnimVarPtr; int32 *destItemDoAnimVarPtr;
extern int32 *gob_destItemOrderVarPtr; int32 *destItemOrderVarPtr;
extern int32 *gob_destItemNoTickVarPtr; int32 *destItemNoTickVarPtr;
extern int32 *gob_destItemTypeVarPtr; int32 *destItemTypeVarPtr;
extern int32 *gob_destItemMaxTickVarPtr; int32 *destItemMaxTickVarPtr;
extern int32 *gob_destItemTickVarPtr; int32 *destItemTickVarPtr;
extern int32 *gob_destItemActStartStVarPtr; int32 *destItemActStartStVarPtr;
extern int32 *gob_destItemLookDirVarPtr; int32 *destItemLookDirVarPtr;
extern int32 *gob_destItemPickableVarPtr; int32 *destItemPickableVarPtr;
extern int32 *gob_destItemRelaxVarPtr; int32 *destItemRelaxVarPtr;
extern int32 *gob_destItemMaxFrameVarPtr; int32 *destItemMaxFrameVarPtr;
extern int16 gob_destItemType; int16 destItemType;
extern int16 gob_destItemState; int16 destItemState;
extern int16 gob_itemToObject[20]; int16 itemToObject[20];
extern Gob_Object *gob_objects[20]; Gob_Object *objects[20];
extern int16 gob_objCount; int16 objCount;
extern int16 gob_gobsCount; int16 gobsCount;
extern int16 gob_itemIndInPocket; int16 itemIndInPocket;
extern int16 gob_itemIdInPocket; int16 itemIdInPocket;
extern char gob_itemByteFlag; char itemByteFlag;
extern int16 gob_destItemId; int16 destItemId;
extern int16 gob_destActionItem; int16 destActionItem;
extern Gob_Object *gob_actDestItemDesc; Gob_Object *actDestItemDesc;
extern int16 gob_forceNextState[10]; int16 forceNextState[10];
extern char gob_boreCounter; char boreCounter;
extern int16 gob_positionedGob; int16 positionedGob;
extern char gob_noPick; char noPick;
// Functions // Functions
char gob_rotateState(int16 from, int16 to); char rotateState(int16 from, int16 to);
void gob_playSound(Snd_SoundDesc * snd, int16 repCount, int16 freq); void playSound(Snd::SoundDesc * snd, int16 repCount, int16 freq);
void gob_drawObjects(void); void drawObjects(void);
void gob_animateObjects(void); void animateObjects(void);
void gob_placeObject(Gob_Object * objDesc, char animated); void placeObject(Gob_Object * objDesc, char animated);
int16 gob_getObjMaxFrame(Gob_Object * obj); int16 getObjMaxFrame(Gob_Object * obj);
int16 gob_objIntersected(Gob_Object * obj1, Gob_Object * obj2); int16 objIntersected(Gob_Object * obj1, Gob_Object * obj2);
void gob_setMultStates(Gob_Object * gobDesc); void setMultStates(Gob_Object * gobDesc);
int16 gob_nextLayer(Gob_Object * gobDesc); int16 nextLayer(Gob_Object * gobDesc);
void gob_showBoredom(int16 gobIndex); void showBoredom(int16 gobIndex);
void gob_switchGoblin(int16 index); void switchGoblin(int16 index);
void gob_freeObjects(void); void freeObjects(void);
void gob_zeroObjects(void); void zeroObjects(void);
void gob_freeAllObjects(void); void freeAllObjects(void);
void gob_loadObjects(char *source); void loadObjects(char *source);
void gob_initVarPointers(void); void initVarPointers(void);
void gob_saveGobDataToVars(int16 xPos, int16 yPos, int16 someVal); void saveGobDataToVars(int16 xPos, int16 yPos, int16 someVal);
void gob_loadGobDataFromVars(void); void loadGobDataFromVars(void);
void gob_pickItem(int16 indexToPocket, int16 idToPocket); void pickItem(int16 indexToPocket, int16 idToPocket);
void gob_placeItem(int16 indexInPocket, int16 idInPocket); void placeItem(int16 indexInPocket, int16 idInPocket);
void gob_swapItems(int16 indexToPick, int16 idToPick); void swapItems(int16 indexToPick, int16 idToPick);
void gob_treatItemPick(int16 itemId); void treatItemPick(int16 itemId);
int16 gob_treatItem(int16 action); int16 treatItem(int16 action);
void gob_interFunc(void); 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 } // End of namespace Gob

247
gob/init.cpp
View file

@ -36,102 +36,99 @@ namespace Gob {
void game_start(void); void game_start(void);
extern int16 debugFlag; const char *Init::fontNames[] = { "jeulet1.let", "jeulet2.let", "jeucar1.let", "jeumath.let" };
extern int16 inVM;
extern int16 colorCount;
PalDesc *init_palDesc; Init::Init(GobEngine *vm) : _vm(vm) {
palDesc = 0;
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;
else
soundFlags = 0;
} }
void init_soundVideo(int32 smallHeap, int16 flag) { void Init::findBestCfg(void) {
if (videoMode != 0x13 && videoMode != 0) _vm->_global->videoMode = VIDMODE_VGA;
error("init_soundVideo: Video mode 0x%x is not supported!", _vm->_global->useMouse = _vm->_global->mousePresent;
videoMode); 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
_vm->_global->soundFlags = 0;
}
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) //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; _vm->_global->sprAllocated = 0;
timer_enableTimer(); _vm->_gtimer->enableTimer();
// snd_setResetTimerFlag(debugFlag); // TODO // _vm->_snd->setResetTimerFlag(debugFlag); // TODO
if (videoMode == 0x13) if (_vm->_global->videoMode == 0x13)
colorCount = 256; _vm->_global->colorCount = 256;
pPaletteDesc = &paletteStruct; _vm->_global->pPaletteDesc = &_vm->_global->paletteStruct;
pPaletteDesc->vgaPal = vgaPalette; _vm->_global->pPaletteDesc->vgaPal = _vm->_global->vgaPalette;
pPaletteDesc->unused1 = unusedPalette1; _vm->_global->pPaletteDesc->unused1 = _vm->_global->unusedPalette1;
pPaletteDesc->unused2 = unusedPalette2; _vm->_global->pPaletteDesc->unused2 = _vm->_global->unusedPalette2;
pPrimarySurfDesc = &primarySurfDesc; _vm->_global->pPrimarySurfDesc = &_vm->_global->primarySurfDesc;
if (videoMode != 0) if (_vm->_global->videoMode != 0)
vid_initSurfDesc(videoMode, 320, 200, PRIMARY_SURFACE); _vm->_video->initSurfDesc(_vm->_global->videoMode, 320, 200, PRIMARY_SURFACE);
if (soundFlags & MIDI_FLAG) { if (_vm->_global->soundFlags & MIDI_FLAG) {
soundFlags &= presentSound; _vm->_global->soundFlags &= _vm->_global->presentSound;
if (presentSound & ADLIB_FLAG) if (_vm->_global->presentSound & ADLIB_FLAG)
soundFlags |= MIDI_FLAG; _vm->_global->soundFlags |= MIDI_FLAG;
} else { } else {
soundFlags &= presentSound; _vm->_global->soundFlags &= _vm->_global->presentSound;
} }
} }
void init_cleanup(void) { void Init::cleanup(void) {
if (debugFlag == 0) if (_vm->_global->debugFlag == 0)
timer_disableTimer(); _vm->_gtimer->disableTimer();
vid_freeDriver(); _vm->_video->freeDriver();
if (curPrimaryDesc != 0) { if (_vm->_global->curPrimaryDesc != 0) {
vid_freeSurfDesc(curPrimaryDesc); _vm->_video->freeSurfDesc(_vm->_global->curPrimaryDesc);
vid_freeSurfDesc(allocatedPrimary); _vm->_video->freeSurfDesc(_vm->_global->allocatedPrimary);
allocatedPrimary = 0; _vm->_global->allocatedPrimary = 0;
curPrimaryDesc = 0; _vm->_global->curPrimaryDesc = 0;
} }
pPrimarySurfDesc = 0; _vm->_global->pPrimarySurfDesc = 0;
if (snd_cleanupFunc != 0 && snd_playingSound != 0) { if (_vm->_snd->cleanupFunc != 0 && _vm->_snd->playingSound != 0) {
(*snd_cleanupFunc) (0); (*_vm->_snd->cleanupFunc) (0);
snd_cleanupFunc = 0; _vm->_snd->cleanupFunc = 0;
} }
snd_speakerOff(); _vm->_snd->speakerOff();
data_closeDataFile(); _vm->_dataio->closeDataFile();
if (sprAllocated != 0) if (_vm->_global->sprAllocated != 0)
error("init_cleanup: Error! Allocated sprites left: %d", error("cleanup: Error! Allocated sprites left: %d",
sprAllocated); _vm->_global->sprAllocated);
snd_stopSound(0); _vm->_snd->stopSound(0);
keyboard_release(); _vm->_util->keyboard_release();
g_system->quit(); g_system->quit();
} }
void init_initGame(char *totName) { void Init::initGame(char *totName) {
int16 handle2; int16 handle2;
int16 i; int16 i;
int16 handle; int16 handle;
@ -154,58 +151,58 @@ numFromTot = word ptr -0Ah
memAvail = dword ptr -6 memAvail = dword ptr -6
memBlocks = word ptr -2*/ memBlocks = word ptr -2*/
disableVideoCfg = 0x11; _vm->_global->disableVideoCfg = 0x11;
disableMouseCfg = 0x15; _vm->_global->disableMouseCfg = 0x15;
init_soundVideo(1000, 1); soundVideo(1000, 1);
handle2 = data_openData("intro.stk"); handle2 = _vm->_dataio->openData("intro.stk");
if (handle2 >= 0) { if (handle2 >= 0) {
data_closeData(handle2); _vm->_dataio->closeData(handle2);
data_openDataFile("intro.stk"); _vm->_dataio->openDataFile("intro.stk");
} }
util_initInput(); _vm->_util->initInput();
vid_setHandlers(); _vm->_video->setHandlers();
vid_initPrimary(videoMode); _vm->_video->initPrimary(_vm->_global->videoMode);
mouseXShift = 1; _vm->_global->mouseXShift = 1;
mouseYShift = 1; _vm->_global->mouseYShift = 1;
game_totTextData = 0; _vm->_game->totTextData = 0;
game_totFileData = 0; _vm->_game->totFileData = 0;
game_totResourceTable = 0; _vm->_game->totResourceTable = 0;
inter_variables = 0; _vm->_global->inter_variables = 0;
init_palDesc = (PalDesc *)malloc(12); palDesc = (Video::PalDesc *)malloc(12);
if (videoMode != 0x13) if (_vm->_global->videoMode != 0x13)
error("init_initGame: Only 0x13 video mode is supported!"); error("initGame: Only 0x13 video mode is supported!");
init_palDesc->vgaPal = draw_vgaPalette; palDesc->vgaPal = _vm->_draw->vgaPalette;
init_palDesc->unused1 = draw_unusedPalette1; palDesc->unused1 = _vm->_draw->unusedPalette1;
init_palDesc->unused2 = draw_unusedPalette2; palDesc->unused2 = _vm->_draw->unusedPalette2;
vid_setFullPalette(init_palDesc); _vm->_video->setFullPalette(palDesc);
for (i = 0; i < 4; i++) 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) { if (handle < 0) {
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
handle2 = data_openData(init_fontNames[i]); handle2 = _vm->_dataio->openData(fontNames[i]);
if (handle2 >= 0) { if (handle2 >= 0) {
data_closeData(handle2); _vm->_dataio->closeData(handle2);
draw_fonts[i] = _vm->_draw->fonts[i] =
util_loadFont(init_fontNames[i]); _vm->_util->loadFont(fontNames[i]);
} }
} }
} else { } else {
data_closeData(handle); _vm->_dataio->closeData(handle);
infPtr = data_getData("intro.inf"); infPtr = _vm->_dataio->getData("intro.inf");
infBuf = infPtr; infBuf = infPtr;
infEnd = infBuf + data_getDataSize("intro.inf"); infEnd = infBuf + _vm->_dataio->getDataSize("intro.inf");
for (i = 0; i < 4; i++, infPtr++) { for (i = 0; i < 4; i++, infPtr++) {
for (j = 0; *infPtr >= ' ' && infPtr != infEnd; for (j = 0; *infPtr >= ' ' && infPtr != infEnd;
@ -214,10 +211,10 @@ memBlocks = word ptr -2*/
buffer[j] = 0; buffer[j] = 0;
strcat(buffer, ".let"); strcat(buffer, ".let");
handle2 = data_openData(buffer); handle2 = _vm->_dataio->openData(buffer);
if (handle2 >= 0) { if (handle2 >= 0) {
data_closeData(handle2); _vm->_dataio->closeData(handle2);
draw_fonts[i] = util_loadFont(buffer); _vm->_draw->fonts[i] = _vm->_util->loadFont(buffer);
} }
if (infPtr == infEnd) if (infPtr == infEnd)
@ -238,42 +235,42 @@ memBlocks = word ptr -2*/
strcpy(buffer, "intro.tot"); strcpy(buffer, "intro.tot");
} }
handle = data_openData(buffer); handle = _vm->_dataio->openData(buffer);
if (handle >= 0) { if (handle >= 0) {
// Get variables count // Get variables count
data_seekData(handle, 0x2c, SEEK_SET); _vm->_dataio->seekData(handle, 0x2c, SEEK_SET);
data_readData(handle, (char *)&varsCount, 4); _vm->_dataio->readData(handle, (char *)&varsCount, 4);
varsCount = FROM_LE_32(varsCount); varsCount = FROM_LE_32(varsCount);
data_closeData(handle); _vm->_dataio->closeData(handle);
inter_variables = (char *)malloc(varsCount * 4); _vm->_global->inter_variables = (char *)malloc(varsCount * 4);
memset(inter_variables, 0, varsCount * 4); memset(_vm->_global->inter_variables, 0, varsCount * 4);
strcpy(game_curTotFile, buffer); strcpy(_vm->_game->curTotFile, buffer);
cd_testCD(1, "GOB"); _vm->_cdrom->testCD(1, "GOB");
cd_readLIC("gob.lic"); _vm->_cdrom->readLIC("gob.lic");
game_start(); _vm->_game->start();
cd_stopPlaying(); _vm->_cdrom->stopPlaying();
cd_freeLICbuffer(); _vm->_cdrom->freeLICbuffer();
free(inter_variables); free(_vm->_global->inter_variables);
free(game_totFileData); free(_vm->_game->totFileData);
free(game_totTextData); free(_vm->_game->totTextData);
free(game_totResourceTable); free(_vm->_game->totResourceTable);
} }
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
if (draw_fonts[i] != 0) if (_vm->_draw->fonts[i] != 0)
util_freeFont(draw_fonts[i]); _vm->_util->freeFont(_vm->_draw->fonts[i]);
} }
free(init_palDesc); free(palDesc);
data_closeDataFile(); _vm->_dataio->closeDataFile();
vid_initPrimary(-1); _vm->_video->initPrimary(-1);
init_cleanup(); cleanup();
} }
} // End of namespace Gob } // End of namespace Gob

18
gob/init.h
View file

@ -24,10 +24,22 @@
namespace Gob { namespace Gob {
void init_findBestCfg(void); class Init {
void init_soundVideo(int32 smallHeapSize, int16 flag); 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 } // End of namespace Gob

1160
gob/inter.cpp
View file

File diff suppressed because it is too large Load diff

142
gob/inter.h
View file

@ -24,75 +24,83 @@
namespace Gob { namespace Gob {
extern int16 inter_animPalLowIndex; class Inter {
extern int16 inter_animPalHighIndex; public:
extern int16 inter_animPalDir; int16 animPalLowIndex;
extern uint32 inter_soundEndTimeKey; int16 animPalHighIndex;
extern int16 inter_soundStopVal; int16 animPalDir;
extern char inter_terminate; uint32 soundEndTimeKey;
extern char inter_breakFlag; int16 soundStopVal;
extern int16 *inter_breakFromLevel; char terminate;
extern int16 *inter_nestLevel; char breakFlag;
int16 *breakFromLevel;
int16 *nestLevel;
int16 inter_load16(void); int16 load16(void);
int16 inter_peek16(char *ptr); int16 peek16(char *ptr);
int32 inter_peek32(char *ptr); int32 peek32(char *ptr);
void inter_setMousePos(void); void setMousePos(void);
char inter_evalExpr(int16 *pRes); char evalExpr(int16 *pRes);
char inter_evalBoolResult(void); char evalBoolResult(void);
void inter_storeResult(void); void storeResult(void);
void inter_printText(void); void printText(void);
void inter_animPalette(void); void animPalette(void);
void inter_animPalInit(void); void animPalInit(void);
void inter_loadMult(void); void loadMult(void);
void inter_playMult(void); void playMult(void);
void inter_freeMult(void); void freeMult(void);
void inter_initCursor(void); void initCursor(void);
void inter_initCursorAnim(void); void initCursorAnim(void);
void inter_clearCursorAnim(void); void clearCursorAnim(void);
void inter_drawOperations(void); void drawOperations(void);
void inter_getFreeMem(void); void getFreeMem(void);
void inter_manageDataFile(void); void manageDataFile(void);
void inter_getFreeMem(void); void writeData(void);
void inter_manageDataFile(void); void checkData(void);
void inter_writeData(void); void readData(void);
void inter_checkData(void); void loadFont(void);
void inter_readData(void); void freeFont(void);
void inter_loadFont(void); void prepareStr(void);
void inter_freeFont(void); void insertStr(void);
void inter_prepareStr(void); void cutStr(void);
void inter_insertStr(void); void strstr(void);
void inter_cutStr(void); void setFrameRate(void);
void inter_strstr(void); void istrlen(void);
void inter_setFrameRate(void); void strToLong(void);
void inter_strlen(void); void invalidate(void);
void inter_strToLong(void); void loadSpriteContent(void);
void inter_invalidate(void); void copySprite(void);
void inter_loadSpriteContent(void); void putPixel(void);
void inter_copySprite(void); void fillRect(void);
void inter_putPixel(void); void drawLine(void);
void inter_fillRect(void); void createSprite(void);
void inter_drawLine(void); void freeSprite(void);
void inter_createSprite(void); void renewTimeInVars(void);
void inter_freeSprite(void); void playComposition(void);
void inter_renewTimeInVars(void); void stopSound(void);
void inter_playComposition(void); void playSound(void);
void inter_stopSound(void); void loadCursor(void);
void inter_playSound(void); void loadSpriteToPos(void);
void inter_loadCursor(void); void funcBlock(int16 retFlag);
void inter_loadSpriteToPos(void); void loadTot(void);
void inter_funcBlock(int16 retFlag); void storeKey(int16 key);
void inter_loadTot(void); void keyFunc(void);
void inter_storeKey(int16 key); void checkSwitchTable(char **ppExec);
void inter_keyFunc(void); void repeatUntil(void);
void inter_checkSwitchTable(char **ppExec); void whileDo(void);
void inter_repeatUntil(void); void callSub(int16 retFlag);
void inter_whileDo(void); void initControlVars(void);
void inter_funcBlock(int16 retFlag);
void inter_callSub(int16 retFlag); Inter(GobEngine *vm);
void inter_initControlVars(void);
void inter_callSub(int16 retFlag); protected:
GobEngine *_vm;
void evaluateStore(void);
void capturePush(void);
void capturePop(void);
};
} // End of namespace Gob } // End of namespace Gob

518
gob/map.cpp
View file

@ -31,28 +31,38 @@
namespace Gob { namespace Gob {
int8 map_passMap[kMapHeight][kMapWidth]; // [y][x] Map::Map(GobEngine *vm) : _vm(vm) {
int16 map_itemsMap[kMapHeight][kMapWidth]; // [y][x] 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;
}
Map_Point map_wayPoints[40]; nearestWayPoint = 0;
int16 map_nearestWayPoint = 0; nearestDest = 0;
int16 map_nearestDest = 0; curGoblinX = 0;
curGoblinY = 0;
destX = 0;
destY = 0;
loadFromAvo = 0;
sourceFile[0] = 0;
avoDataPtr = 0;
}
int16 map_curGoblinX; void Map::placeItem(int16 x, int16 y, int16 id) {
int16 map_curGoblinY; if ((itemsMap[y][x] & 0xff00) != 0)
int16 map_destX; itemsMap[y][x] = (itemsMap[y][x] & 0xff00) | id;
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;
else else
map_itemsMap[y][x] = (map_itemsMap[y][x] & 0x00ff) | (id << 8); itemsMap[y][x] = (itemsMap[y][x] & 0x00ff) | (id << 8);
} }
enum { enum {
@ -62,7 +72,7 @@ enum {
kDown = (1 << 3) 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; int16 dir = 0;
if (x0 == x1 && y0 == y1) if (x0 == x1 && y0 == y1)
@ -81,63 +91,63 @@ int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1) {
else if (x1 < x0) else if (x1 < x0)
dir |= kLeft; dir |= kLeft;
if (map_passMap[y0][x0] == 3 && (dir & kUp)) { if (passMap[y0][x0] == 3 && (dir & kUp)) {
if (map_passMap[y0 - 1][x0] != 0) if (passMap[y0 - 1][x0] != 0)
return kDirN; return kDirN;
} }
if (map_passMap[y0][x0] == 3 && (dir & kDown)) { if (passMap[y0][x0] == 3 && (dir & kDown)) {
if (map_passMap[y0 + 1][x0] != 0) if (passMap[y0 + 1][x0] != 0)
return kDirS; return kDirS;
} }
if (map_passMap[y0][x0] == 6 && (dir & kUp)) { if (passMap[y0][x0] == 6 && (dir & kUp)) {
if (map_passMap[y0 - 1][x0] != 0) if (passMap[y0 - 1][x0] != 0)
return kDirN; return kDirN;
} }
if (map_passMap[y0][x0] == 6 && (dir & kDown)) { if (passMap[y0][x0] == 6 && (dir & kDown)) {
if (map_passMap[y0 + 1][x0] != 0) if (passMap[y0 + 1][x0] != 0)
return kDirS; return kDirS;
} }
if (dir == kLeft) { 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 kDirW;
return 0; return 0;
} }
if (dir == kRight) { 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 kDirE;
return 0; return 0;
} }
if (dir == kUp) { if (dir == kUp) {
if (y0 - 1 >= 0 && map_passMap[y0 - 1][x0] != 0) if (y0 - 1 >= 0 && passMap[y0 - 1][x0] != 0)
return kDirN; return kDirN;
if (y0 - 1 >= 0 && x0 - 1 >= 0 if (y0 - 1 >= 0 && x0 - 1 >= 0
&& map_passMap[y0 - 1][x0 - 1] != 0) && passMap[y0 - 1][x0 - 1] != 0)
return kDirNW; return kDirNW;
if (y0 - 1 >= 0 && x0 + 1 < kMapWidth if (y0 - 1 >= 0 && x0 + 1 < kMapWidth
&& map_passMap[y0 - 1][x0 + 1] != 0) && passMap[y0 - 1][x0 + 1] != 0)
return kDirNE; return kDirNE;
return 0; return 0;
} }
if (dir == kDown) { if (dir == kDown) {
if (y0 + 1 < kMapHeight && map_passMap[y0 + 1][x0] != 0) if (y0 + 1 < kMapHeight && passMap[y0 + 1][x0] != 0)
return kDirS; return kDirS;
if (y0 + 1 < kMapHeight && x0 - 1 >= 0 if (y0 + 1 < kMapHeight && x0 - 1 >= 0
&& map_passMap[y0 + 1][x0 - 1] != 0) && passMap[y0 + 1][x0 - 1] != 0)
return kDirSW; return kDirSW;
if (y0 + 1 < kMapHeight && x0 + 1 < kMapWidth if (y0 + 1 < kMapHeight && x0 + 1 < kMapWidth
&& map_passMap[y0 + 1][x0 + 1] != 0) && passMap[y0 + 1][x0 + 1] != 0)
return kDirSE; return kDirSE;
return 0; return 0;
@ -145,13 +155,13 @@ int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1) {
if (dir == (kRight | kUp)) { if (dir == (kRight | kUp)) {
if (y0 - 1 >= 0 && x0 + 1 < kMapWidth if (y0 - 1 >= 0 && x0 + 1 < kMapWidth
&& map_passMap[y0 - 1][x0 + 1] != 0) && passMap[y0 - 1][x0 + 1] != 0)
return kDirNE; return kDirNE;
if (y0 - 1 >= 0 && map_passMap[y0 - 1][x0] != 0) if (y0 - 1 >= 0 && passMap[y0 - 1][x0] != 0)
return kDirN; return kDirN;
if (x0 + 1 < kMapWidth && map_passMap[y0][x0 + 1] != 0) if (x0 + 1 < kMapWidth && passMap[y0][x0 + 1] != 0)
return kDirE; return kDirE;
return 0; return 0;
@ -159,13 +169,13 @@ int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1) {
if (dir == (kRight | kDown)) { if (dir == (kRight | kDown)) {
if (x0 + 1 < kMapWidth && y0 + 1 < kMapHeight if (x0 + 1 < kMapWidth && y0 + 1 < kMapHeight
&& map_passMap[y0 + 1][x0 + 1] != 0) && passMap[y0 + 1][x0 + 1] != 0)
return kDirSE; return kDirSE;
if (y0 + 1 < kMapHeight && map_passMap[y0 + 1][x0] != 0) if (y0 + 1 < kMapHeight && passMap[y0 + 1][x0] != 0)
return kDirS; return kDirS;
if (x0 + 1 < kMapWidth && map_passMap[y0][x0 + 1] != 0) if (x0 + 1 < kMapWidth && passMap[y0][x0 + 1] != 0)
return kDirE; return kDirE;
return 0; return 0;
@ -173,13 +183,13 @@ int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1) {
if (dir == (kLeft | kUp)) { if (dir == (kLeft | kUp)) {
if (x0 - 1 >= 0 && y0 - 1 >= 0 if (x0 - 1 >= 0 && y0 - 1 >= 0
&& map_passMap[y0 - 1][x0 - 1] != 0) && passMap[y0 - 1][x0 - 1] != 0)
return kDirNW; return kDirNW;
if (y0 - 1 >= 0 && map_passMap[y0 - 1][x0] != 0) if (y0 - 1 >= 0 && passMap[y0 - 1][x0] != 0)
return kDirN; return kDirN;
if (x0 - 1 >= 0 && map_passMap[y0][x0 - 1] != 0) if (x0 - 1 >= 0 && passMap[y0][x0 - 1] != 0)
return kDirW; return kDirW;
return 0; return 0;
@ -187,13 +197,13 @@ int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1) {
if (dir == (kLeft | kDown)) { if (dir == (kLeft | kDown)) {
if (x0 - 1 >= 0 && y0 + 1 < kMapHeight if (x0 - 1 >= 0 && y0 + 1 < kMapHeight
&& map_passMap[y0 + 1][x0 - 1] != 0) && passMap[y0 + 1][x0 - 1] != 0)
return kDirSW; return kDirSW;
if (y0 + 1 < kMapHeight && map_passMap[y0 + 1][x0] != 0) if (y0 + 1 < kMapHeight && passMap[y0 + 1][x0] != 0)
return kDirS; return kDirS;
if (x0 - 1 >= 0 && map_passMap[y0][x0 - 1] != 0) if (x0 - 1 >= 0 && passMap[y0][x0 - 1] != 0)
return kDirW; return kDirW;
return 0; return 0;
@ -201,8 +211,8 @@ int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1) {
return -1; return -1;
} }
int16 map_findNearestWayPoint(int16 x, int16 y) { int16 Map::findNearestWayPoint(int16 x, int16 y) {
int16 nearestWayPoint = -1; int16 lnearestWayPoint = -1;
int16 length; int16 length;
int16 i; int16 i;
int16 tmp; int16 tmp;
@ -210,41 +220,41 @@ int16 map_findNearestWayPoint(int16 x, int16 y) {
length = 30000; length = 30000;
for (i = 0; i < 40; i++) { for (i = 0; i < 40; i++) {
if (map_wayPoints[i].x < 0 || if (wayPoints[i].x < 0 ||
map_wayPoints[i].x >= kMapWidth || wayPoints[i].x >= kMapWidth ||
map_wayPoints[i].y < 0 || map_wayPoints[i].y >= kMapHeight) wayPoints[i].y < 0 || wayPoints[i].y >= kMapHeight)
return -1; 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) { if (tmp <= length) {
nearestWayPoint = i; lnearestWayPoint = i;
length = tmp; length = tmp;
} }
} }
return nearestWayPoint; return lnearestWayPoint;
} }
void map_findNearestToGob(void) { void Map::findNearestToGob(void) {
int16 wayPoint = map_findNearestWayPoint(map_curGoblinX, map_curGoblinY); int16 wayPoint = findNearestWayPoint(curGoblinX, curGoblinY);
if (wayPoint != -1) if (wayPoint != -1)
map_nearestWayPoint = wayPoint; nearestWayPoint = wayPoint;
} }
void map_findNearestToDest(void) { void Map::findNearestToDest(void) {
int16 wayPoint = map_findNearestWayPoint(map_destX, map_destY); int16 wayPoint = findNearestWayPoint(destX, destY);
if (wayPoint != -1) 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; uint16 dir;
while (1) { while (1) {
dir = map_getDirection(x0, y0, x1, y1); dir = getDirection(x0, y0, x1, y1);
if (x0 == x1 && y0 == y1) if (x0 == x1 && y0 == y1)
return 1; 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; uint16 dir;
int16 curX; int16 curX;
int16 curY; int16 curY;
@ -309,30 +319,30 @@ int16 map_checkLongPath(int16 x0, int16 y0, int16 x1, int16 y1, int16 i0, int16
nextLink = 1; nextLink = 1;
if (nextLink != 0) { if (nextLink != 0) {
if (map_checkDirectPath(x0, y0, x1, y1) == 1) if (checkDirectPath(x0, y0, x1, y1) == 1)
return 1; return 1;
nextLink = 0; nextLink = 0;
if (i0 > i1) { if (i0 > i1) {
curX = map_wayPoints[i0].x; curX = wayPoints[i0].x;
curY = map_wayPoints[i0].y; curY = wayPoints[i0].y;
i0--; i0--;
} else if (i0 < i1) { } else if (i0 < i1) {
curX = map_wayPoints[i0].x; curX = wayPoints[i0].x;
curY = map_wayPoints[i0].y; curY = wayPoints[i0].y;
i0++; i0++;
} else if (i0 == i1) { } else if (i0 == i1) {
curX = map_wayPoints[i0].x; curX = wayPoints[i0].x;
curY = map_wayPoints[i0].y; curY = wayPoints[i0].y;
} }
} }
if (i0 == i1 && map_wayPoints[i0].x == x0 if (i0 == i1 && wayPoints[i0].x == x0
&& map_wayPoints[i0].y == y0) { && wayPoints[i0].y == y0) {
if (map_checkDirectPath(x0, y0, x1, y1) == 1) if (checkDirectPath(x0, y0, x1, y1) == 1)
return 1; return 1;
return 0; return 0;
} }
dir = map_getDirection(x0, y0, curX, curY); dir = getDirection(x0, y0, curX, curY);
switch (dir) { switch (dir) {
case 0: case 0:
return 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; int16 i;
if (map_nearestWayPoint < map_nearestDest) { if (nearestWayPoint < nearestDest) {
for (i = map_nearestWayPoint; i <= map_nearestDest; i++) { for (i = nearestWayPoint; i <= nearestDest; i++) {
if (map_checkDirectPath(map_curGoblinX, map_curGoblinY, if (checkDirectPath(curGoblinX, curGoblinY,
map_wayPoints[i].x, map_wayPoints[i].y) == 1) wayPoints[i].x, wayPoints[i].y) == 1)
map_nearestWayPoint = i; nearestWayPoint = i;
} }
} else if (map_nearestWayPoint > map_nearestDest) { } else if (nearestWayPoint > nearestDest) {
for (i = map_nearestWayPoint; i >= map_nearestDest; i--) { for (i = nearestWayPoint; i >= nearestDest; i--) {
if (map_checkDirectPath(map_curGoblinX, map_curGoblinY, if (checkDirectPath(curGoblinX, curGoblinY,
map_wayPoints[i].x, map_wayPoints[i].y) == 1) wayPoints[i].x, wayPoints[i].y) == 1)
map_nearestWayPoint = i; nearestWayPoint = i;
} }
} }
} }
void map_loadDataFromAvo(char *dest, int16 size) { void Map::loadDataFromAvo(char *dest, int16 size) {
memcpy(dest, map_avoDataPtr, size); memcpy(dest, avoDataPtr, size);
map_avoDataPtr += size; avoDataPtr += size;
} }
uint16 map_loadFromAvo_LE_UINT16() { uint16 Map::loadFromAvo_LE_UINT16() {
uint16 tmp = READ_LE_UINT16(map_avoDataPtr); uint16 tmp = READ_LE_UINT16(avoDataPtr);
map_avoDataPtr += 2; avoDataPtr += 2;
return tmp; return tmp;
} }
void map_loadItemToObject(void) { void Map::loadItemToObject(void) {
int16 flag; int16 flag;
int16 count; int16 count;
int16 i; int16 i;
flag = map_loadFromAvo_LE_UINT16(); flag = loadFromAvo_LE_UINT16();
if (flag == 0) if (flag == 0)
return; return;
map_avoDataPtr += 1456; avoDataPtr += 1456;
count = map_loadFromAvo_LE_UINT16(); count = loadFromAvo_LE_UINT16();
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
map_avoDataPtr += 20; avoDataPtr += 20;
gob_itemToObject[i] = map_loadFromAvo_LE_UINT16(); _vm->_goblin->itemToObject[i] = loadFromAvo_LE_UINT16();
map_avoDataPtr += 5; avoDataPtr += 5;
} }
} }
void map_loadMapObjects(char *avjFile) { void Map::loadMapObjects(char *avjFile) {
int16 i; int16 i;
char avoName[128]; char avoName[128];
int16 handle; int16 handle;
@ -436,7 +446,7 @@ void map_loadMapObjects(char *avjFile) {
int16 state; int16 state;
int16 col; int16 col;
int32 flag; int32 flag;
Gob_State *pState; Goblin::Gob_State *pState;
char buf[128]; char buf[128];
char sndNames[20][14]; char sndNames[20][14];
char *dataBuf; char *dataBuf;
@ -445,154 +455,154 @@ void map_loadMapObjects(char *avjFile) {
int16 count2; int16 count2;
int16 count3; int16 count3;
strcpy(avoName, map_sourceFile); strcpy(avoName, sourceFile);
strcat(avoName, ".avo"); strcat(avoName, ".avo");
handle = data_openData(avoName); handle = _vm->_dataio->openData(avoName);
if (handle >= 0) { if (handle >= 0) {
map_loadFromAvo = 1; loadFromAvo = 1;
data_closeData(handle); _vm->_dataio->closeData(handle);
map_avoDataPtr = data_getData(avoName); avoDataPtr = _vm->_dataio->getData(avoName);
dataBuf = map_avoDataPtr; dataBuf = avoDataPtr;
map_loadDataFromAvo((char *)map_passMap, kMapHeight * kMapWidth); loadDataFromAvo((char *)passMap, kMapHeight * kMapWidth);
for (y = 0; y < kMapHeight; y++) { for (y = 0; y < kMapHeight; y++) {
for (x = 0; x < kMapWidth; x++) { for (x = 0; x < kMapWidth; x++) {
map_loadDataFromAvo(&item, 1); loadDataFromAvo(&item, 1);
map_itemsMap[y][x] = item; itemsMap[y][x] = item;
} }
} }
for (i = 0; i < 40; i++) { for (i = 0; i < 40; i++) {
map_wayPoints[i].x = map_loadFromAvo_LE_UINT16(); wayPoints[i].x = loadFromAvo_LE_UINT16();
map_wayPoints[i].y = map_loadFromAvo_LE_UINT16(); wayPoints[i].y = loadFromAvo_LE_UINT16();
} }
map_loadDataFromAvo((char *)map_itemPoses, szMap_ItemPos * 20); loadDataFromAvo((char *)itemPoses, szMap_ItemPos * 20);
} else { } else {
map_loadFromAvo = 0; loadFromAvo = 0;
map_avoDataPtr = data_getData(avjFile); avoDataPtr = _vm->_dataio->getData(avjFile);
dataBuf = map_avoDataPtr; dataBuf = avoDataPtr;
} }
map_avoDataPtr += 32; avoDataPtr += 32;
map_avoDataPtr += 76; avoDataPtr += 76;
map_avoDataPtr += 4; avoDataPtr += 4;
map_avoDataPtr += 20; avoDataPtr += 20;
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
tmp = map_loadFromAvo_LE_UINT16(); tmp = loadFromAvo_LE_UINT16();
map_avoDataPtr += tmp * 14; avoDataPtr += tmp * 14;
} }
soundCount = map_loadFromAvo_LE_UINT16(); soundCount = loadFromAvo_LE_UINT16();
savedPtr = map_avoDataPtr; savedPtr = avoDataPtr;
map_avoDataPtr += 14 * soundCount; avoDataPtr += 14 * soundCount;
map_avoDataPtr += 4; avoDataPtr += 4;
map_avoDataPtr += 24; avoDataPtr += 24;
count2 = map_loadFromAvo_LE_UINT16(); count2 = loadFromAvo_LE_UINT16();
count3 = map_loadFromAvo_LE_UINT16(); count3 = loadFromAvo_LE_UINT16();
savedPtr2 = map_avoDataPtr; savedPtr2 = avoDataPtr;
map_avoDataPtr += count2 * 8; avoDataPtr += count2 * 8;
savedPtr3 = map_avoDataPtr; savedPtr3 = avoDataPtr;
map_avoDataPtr += count3 * 8; avoDataPtr += count3 * 8;
gob_gobsCount = map_loadFromAvo_LE_UINT16(); _vm->_goblin->gobsCount = loadFromAvo_LE_UINT16();
for (i = 0; i < gob_gobsCount; i++) { for (i = 0; i < _vm->_goblin->gobsCount; i++) {
gob_goblins[i] = (Gob_Object *)malloc(sizeof(Gob_Object)); _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; savedPtr2 += 2;
gob_goblins[i]->yPos = READ_LE_UINT16(savedPtr2); _vm->_goblin->goblins[i]->yPos = READ_LE_UINT16(savedPtr2);
savedPtr2 += 2; savedPtr2 += 2;
gob_goblins[i]->order = READ_LE_UINT16(savedPtr2); _vm->_goblin->goblins[i]->order = READ_LE_UINT16(savedPtr2);
savedPtr2 += 2; savedPtr2 += 2;
gob_goblins[i]->state = READ_LE_UINT16(savedPtr2); _vm->_goblin->goblins[i]->state = READ_LE_UINT16(savedPtr2);
savedPtr2 += 2; savedPtr2 += 2;
if (i == 3) 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 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() // FIXME: All is wrong further. We should unwind calls to loadDataFromAvo()
map_loadDataFromAvo((char *)gob_goblins[i]->stateMach, 40 * szGob_StateLine); loadDataFromAvo((char *)_vm->_goblin->goblins[i]->stateMach, 40 * szGob_StateLine);
map_avoDataPtr += 160; avoDataPtr += 160;
gob_goblins[i]->multObjIndex = *map_avoDataPtr; _vm->_goblin->goblins[i]->multObjIndex = *avoDataPtr;
map_avoDataPtr += 2; 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 (state = 0; state < 40; state++) {
for (col = 0; col < 6; col++) { for (col = 0; col < 6; col++) {
if (gob_goblins[i]->stateMach[state][col] == 0) if (_vm->_goblin->goblins[i]->stateMach[state][col] == 0)
continue; continue;
Gob_State *tmpState = (Gob_State *)malloc(sizeof(Gob_State)); Goblin::Gob_State *tmpState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State));
gob_goblins[i]->stateMach[state][col] = tmpState; _vm->_goblin->goblins[i]->stateMach[state][col] = tmpState;
tmpState->animation = map_loadFromAvo_LE_UINT16(); tmpState->animation = loadFromAvo_LE_UINT16();
tmpState->layer = map_loadFromAvo_LE_UINT16(); tmpState->layer = loadFromAvo_LE_UINT16();
map_avoDataPtr += 8; avoDataPtr += 8;
tmpState->unk0 = map_loadFromAvo_LE_UINT16(); tmpState->unk0 = loadFromAvo_LE_UINT16();
tmpState->unk1 = map_loadFromAvo_LE_UINT16(); tmpState->unk1 = loadFromAvo_LE_UINT16();
map_avoDataPtr += 2; avoDataPtr += 2;
if (READ_LE_UINT32(map_avoDataPtr) != 0) { if (READ_LE_UINT32(avoDataPtr) != 0) {
map_avoDataPtr += 4; avoDataPtr += 4;
tmpState->sndItem = map_loadFromAvo_LE_UINT16(); tmpState->sndItem = loadFromAvo_LE_UINT16();
} else { } else {
map_avoDataPtr += 6; avoDataPtr += 6;
tmpState->sndItem = -1; tmpState->sndItem = -1;
} }
tmpState->freq = map_loadFromAvo_LE_UINT16(); tmpState->freq = loadFromAvo_LE_UINT16();
tmpState->repCount = map_loadFromAvo_LE_UINT16(); tmpState->repCount = loadFromAvo_LE_UINT16();
tmpState->sndFrame = map_loadFromAvo_LE_UINT16(); tmpState->sndFrame = loadFromAvo_LE_UINT16();
} }
} }
} }
pState = (Gob_State *)malloc(sizeof(Gob_State)); pState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State));
gob_goblins[0]->stateMach[39][0] = pState; _vm->_goblin->goblins[0]->stateMach[39][0] = pState;
pState->animation = 0; pState->animation = 0;
pState->layer = 98; pState->layer = 98;
pState->unk0 = 0; pState->unk0 = 0;
pState->unk1 = 0; pState->unk1 = 0;
pState->sndItem = -1; pState->sndItem = -1;
pState = (Gob_State *) malloc(sizeof(Gob_State)); pState = (Goblin::Gob_State *) malloc(sizeof(Goblin::Gob_State));
gob_goblins[1]->stateMach[39][0] = pState; _vm->_goblin->goblins[1]->stateMach[39][0] = pState;
pState->animation = 0; pState->animation = 0;
pState->layer = 99; pState->layer = 99;
pState->unk0 = 0; pState->unk0 = 0;
pState->unk1 = 0; pState->unk1 = 0;
pState->sndItem = -1; pState->sndItem = -1;
pState = (Gob_State *) malloc(sizeof(Gob_State)); pState = (Goblin::Gob_State *) malloc(sizeof(Goblin::Gob_State));
gob_goblins[2]->stateMach[39][0] = pState; _vm->_goblin->goblins[2]->stateMach[39][0] = pState;
pState->animation = 0; pState->animation = 0;
pState->layer = 100; pState->layer = 100;
pState->unk0 = 0; pState->unk0 = 0;
pState->unk1 = 0; pState->unk1 = 0;
pState->sndItem = -1; pState->sndItem = -1;
gob_goblins[2]->stateMach[10][0]->sndFrame = 13; _vm->_goblin->goblins[2]->stateMach[10][0]->sndFrame = 13;
gob_goblins[2]->stateMach[11][0]->sndFrame = 13; _vm->_goblin->goblins[2]->stateMach[11][0]->sndFrame = 13;
gob_goblins[2]->stateMach[28][0]->sndFrame = 13; _vm->_goblin->goblins[2]->stateMach[28][0]->sndFrame = 13;
gob_goblins[2]->stateMach[29][0]->sndFrame = 13; _vm->_goblin->goblins[2]->stateMach[29][0]->sndFrame = 13;
gob_goblins[1]->stateMach[10][0]->sndFrame = 13; _vm->_goblin->goblins[1]->stateMach[10][0]->sndFrame = 13;
gob_goblins[1]->stateMach[11][0]->sndFrame = 13; _vm->_goblin->goblins[1]->stateMach[11][0]->sndFrame = 13;
for (state = 40; state < 70; state++) { for (state = 40; state < 70; state++) {
pState = (Gob_State *)malloc(sizeof(Gob_State)); pState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State));
gob_goblins[3]->stateMach[state][0] = pState; _vm->_goblin->goblins[3]->stateMach[state][0] = pState;
gob_goblins[3]->stateMach[state][1] = 0; _vm->_goblin->goblins[3]->stateMach[state][1] = 0;
pState->animation = 9; pState->animation = 9;
pState->layer = state - 40; pState->layer = state - 40;
@ -600,70 +610,70 @@ void map_loadMapObjects(char *avjFile) {
pState->sndFrame = 0; pState->sndFrame = 0;
} }
gob_objCount = map_loadFromAvo_LE_UINT16(); _vm->_goblin->objCount = loadFromAvo_LE_UINT16();
for (i = 0; i < gob_objCount; i++) { for (i = 0; i < _vm->_goblin->objCount; i++) {
gob_objects[i] = _vm->_goblin->objects[i] =
(Gob_Object *) malloc(sizeof(Gob_Object)); (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; savedPtr3 += 2;
gob_objects[i]->yPos = READ_LE_UINT16(savedPtr3); _vm->_goblin->objects[i]->yPos = READ_LE_UINT16(savedPtr3);
savedPtr3 += 2; savedPtr3 += 2;
gob_objects[i]->order = READ_LE_UINT16(savedPtr3); _vm->_goblin->objects[i]->order = READ_LE_UINT16(savedPtr3);
savedPtr3 += 2; savedPtr3 += 2;
gob_objects[i]->state = READ_LE_UINT16(savedPtr3); _vm->_goblin->objects[i]->state = READ_LE_UINT16(savedPtr3);
savedPtr3 += 2; 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); loadDataFromAvo((char *)_vm->_goblin->objects[i]->stateMach, 40 * szGob_StateLine);
map_avoDataPtr += 160; avoDataPtr += 160;
gob_objects[i]->multObjIndex = *map_avoDataPtr; _vm->_goblin->objects[i]->multObjIndex = *avoDataPtr;
map_avoDataPtr += 2; 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 (state = 0; state < 40; state++) {
for (col = 0; col < 6; col++) { for (col = 0; col < 6; col++) {
if (gob_objects[i]->stateMach[state][col] == 0) if (_vm->_goblin->objects[i]->stateMach[state][col] == 0)
continue; continue;
Gob_State *tmpState = (Gob_State *)malloc(sizeof(Gob_State)); Goblin::Gob_State *tmpState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State));
gob_objects[i]->stateMach[state][col] = tmpState; _vm->_goblin->objects[i]->stateMach[state][col] = tmpState;
tmpState->animation = map_loadFromAvo_LE_UINT16(); tmpState->animation = loadFromAvo_LE_UINT16();
tmpState->layer = map_loadFromAvo_LE_UINT16(); tmpState->layer = loadFromAvo_LE_UINT16();
map_avoDataPtr += 8; avoDataPtr += 8;
tmpState->unk0 = map_loadFromAvo_LE_UINT16(); tmpState->unk0 = loadFromAvo_LE_UINT16();
tmpState->unk1 = map_loadFromAvo_LE_UINT16(); tmpState->unk1 = loadFromAvo_LE_UINT16();
map_avoDataPtr += 2; avoDataPtr += 2;
if (READ_LE_UINT32(map_avoDataPtr) != 0) { if (READ_LE_UINT32(avoDataPtr) != 0) {
map_avoDataPtr += 4; avoDataPtr += 4;
tmpState->sndItem = map_loadFromAvo_LE_UINT16(); tmpState->sndItem = loadFromAvo_LE_UINT16();
} else { } else {
map_avoDataPtr += 6; avoDataPtr += 6;
tmpState->sndItem = -1; tmpState->sndItem = -1;
} }
tmpState->freq = map_loadFromAvo_LE_UINT16(); tmpState->freq = loadFromAvo_LE_UINT16();
tmpState->repCount = map_loadFromAvo_LE_UINT16(); tmpState->repCount = loadFromAvo_LE_UINT16();
tmpState->sndFrame = map_loadFromAvo_LE_UINT16(); tmpState->sndFrame = loadFromAvo_LE_UINT16();
} }
} }
} }
gob_objects[10] = (Gob_Object *)malloc(sizeof(Gob_Object)); _vm->_goblin->objects[10] = (Goblin::Gob_Object *)malloc(sizeof(Goblin::Gob_Object));
memset(gob_objects[10], 0, sizeof(Gob_Object)); memset(_vm->_goblin->objects[10], 0, sizeof(Goblin::Gob_Object));
gob_objects[10]->stateMach = (Gob_StateLine *)malloc(szGob_StateLine * 40); _vm->_goblin->objects[10]->stateMach = (Goblin::Gob_StateLine *)malloc(szGob_StateLine * 40);
memset(gob_objects[10]->stateMach, 0, szGob_StateLine * 40); memset(_vm->_goblin->objects[10]->stateMach, 0, szGob_StateLine * 40);
pState = (Gob_State *)malloc(sizeof(Gob_State)); pState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State));
gob_objects[10]->stateMach[0][0] = pState; _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->animation = 9;
pState->layer = 27; pState->layer = 27;
pState->unk0 = 0; pState->unk0 = 0;
@ -671,84 +681,84 @@ void map_loadMapObjects(char *avjFile) {
pState->sndItem = -1; pState->sndItem = -1;
pState->sndFrame = 0; 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; _vm->_goblin->objects[10]->realStateMach = _vm->_goblin->objects[10]->stateMach;
gob_objects[10]->type = 1; _vm->_goblin->objects[10]->type = 1;
gob_objects[10]->unk14 = 1; _vm->_goblin->objects[10]->unk14 = 1;
state = map_loadFromAvo_LE_UINT16(); state = loadFromAvo_LE_UINT16();
for (i = 0; i < state; i++) { for (i = 0; i < state; i++) {
map_avoDataPtr += 30; avoDataPtr += 30;
map_loadDataFromAvo((char *)&flag, 4); loadDataFromAvo((char *)&flag, 4);
map_avoDataPtr += 56; avoDataPtr += 56;
if (flag != 0) if (flag != 0)
map_avoDataPtr += 30; avoDataPtr += 30;
} }
map_loadDataFromAvo((char *)&tmp, 2); loadDataFromAvo((char *)&tmp, 2);
map_avoDataPtr += 48; avoDataPtr += 48;
map_loadItemToObject(); loadItemToObject();
map_avoDataPtr = savedPtr; avoDataPtr = savedPtr;
for (i = 0; i < soundCount; i++) { for (i = 0; i < soundCount; i++) {
map_loadDataFromAvo(buf, 14); loadDataFromAvo(buf, 14);
strcat(buf, ".SND"); strcat(buf, ".SND");
strcpy(sndNames[i], buf); strcpy(sndNames[i], buf);
} }
free(dataBuf); free(dataBuf);
gob_soundData[14] = snd_loadSoundData("diamant1.snd"); _vm->_goblin->soundData[14] = _vm->_snd->loadSoundData("diamant1.snd");
for (i = 0; i < soundCount; i++) { for (i = 0; i < soundCount; i++) {
handle = data_openData(sndNames[i]); handle = _vm->_dataio->openData(sndNames[i]);
if (handle < 0) if (handle < 0)
continue; continue;
data_closeData(handle); _vm->_dataio->closeData(handle);
gob_soundData[i] = snd_loadSoundData(sndNames[i]); _vm->_goblin->soundData[i] = _vm->_snd->loadSoundData(sndNames[i]);
} }
} }
void map_loadMapsInitGobs(void) { void Map::loadMapsInitGobs(void) {
int16 layer; int16 layer;
int16 i; int16 i;
if (map_loadFromAvo == 0) if (loadFromAvo == 0)
error("map_load: Loading .pas/.pos files is not supported!"); error("load: Loading .pas/.pos files is not supported!");
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
gob_nextLayer(gob_goblins[i]); _vm->_goblin->nextLayer(_vm->_goblin->goblins[i]);
} }
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
layer = 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, _vm->_scenery->updateAnim(layer, 0, _vm->_goblin->goblins[i]->animation, 0,
gob_goblins[i]->xPos, gob_goblins[i]->yPos, 0); _vm->_goblin->goblins[i]->xPos, _vm->_goblin->goblins[i]->yPos, 0);
gob_goblins[i]->yPos = (gob_gobPositions[i].y + 1) * 6 - _vm->_goblin->goblins[i]->yPos = (_vm->_goblin->gobPositions[i].y + 1) * 6 -
(scen_toRedrawBottom - scen_animTop); (_vm->_scenery->toRedrawBottom - _vm->_scenery->animTop);
gob_goblins[i]->xPos = gob_gobPositions[i].x * 12 - _vm->_goblin->goblins[i]->xPos = _vm->_goblin->gobPositions[i].x * 12 -
(scen_toRedrawLeft - scen_animLeft); (_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; _vm->_goblin->currentGoblin = 0;
gob_pressedMapX = gob_gobPositions[0].x; _vm->_goblin->pressedMapX = _vm->_goblin->gobPositions[0].x;
gob_pressedMapY = gob_gobPositions[0].y; _vm->_goblin->pressedMapY = _vm->_goblin->gobPositions[0].y;
gob_pathExistence = 0; _vm->_goblin->pathExistence = 0;
gob_goblins[0]->doAnim = 0; _vm->_goblin->goblins[0]->doAnim = 0;
gob_goblins[1]->doAnim = 1; _vm->_goblin->goblins[1]->doAnim = 1;
gob_goblins[2]->doAnim = 1; _vm->_goblin->goblins[2]->doAnim = 1;
} }
} // End of namespace Gob } // End of namespace Gob

93
gob/map.h
View file

@ -26,6 +26,8 @@ namespace Gob {
// The same numeric values are also used for the arrow keys. // The same numeric values are also used for the arrow keys.
class Map {
public:
enum { enum {
kDirNW = 0x4700, kDirNW = 0x4700,
kDirN = 0x4800, kDirN = 0x4800,
@ -36,56 +38,65 @@ enum {
kDirS = 0x5000, kDirS = 0x5000,
kDirSE = 0x5100 kDirSE = 0x5100
}; };
#pragma START_PACK_STRUCTS
typedef struct Map_Point {
int16 x;
int16 y;
} GCC_PACK Map_Point;
#define szMap_ItemPos 3
typedef struct Map_ItemPos {
int8 x;
int8 y;
int8 orient; // ??
} GCC_PACK Map_ItemPos;
#pragma END_PACK_STRUCTS
enum { enum {
kMapWidth = 26, kMapWidth = 26,
kMapHeight = 28 kMapHeight = 28
}; };
extern int8 map_passMap[kMapHeight][kMapWidth]; // [y][x] #pragma START_PACK_STRUCTS
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; typedef struct Point {
extern int16 map_curGoblinY; int16 x;
extern int16 map_destX; int16 y;
extern int16 map_destY; } GCC_PACK Point;
extern int8 map_loadFromAvo;
extern Map_ItemPos map_itemPoses[40]; #define szMap_ItemPos 3
extern char map_sourceFile[15];
void map_placeItem(int16 x, int16 y, int16 id); typedef struct ItemPos {
int8 x;
int8 y;
int8 orient; // ??
} GCC_PACK ItemPos;
int16 map_getDirection(int16 x0, int16 y0, int16 x1, int16 y1); #pragma END_PACK_STRUCTS
void map_findNearestToGob(void);
void map_findNearestToDest(void); int8 passMap[kMapHeight][kMapWidth]; // [y][x]
int16 map_checkDirectPath(int16 x0, int16 y0, int16 x1, int16 y1); int16 itemsMap[kMapHeight][kMapWidth]; // [y][x]
int16 map_checkLongPath(int16 x0, int16 y0, int16 x1, int16 y1, int16 i0, int16 i1); Point wayPoints[40];
void map_optimizePoints(void); int16 nearestWayPoint;
void map_loadItemToObject(void); int16 nearestDest;
void map_loadMapObjects(char *avjFile);
void map_loadDataFromAvo(int8 *dest, int16 size); int16 curGoblinX;
void map_loadMapsInitGobs(void); 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();
};
} // End of namespace Gob } // End of namespace Gob

1144
gob/mult.cpp
View file

File diff suppressed because it is too large Load diff

139
gob/mult.h
View file

@ -26,6 +26,8 @@
namespace Gob { namespace Gob {
class Mult {
public:
#pragma START_PACK_STRUCTS #pragma START_PACK_STRUCTS
typedef struct Mult_AnimData { typedef struct Mult_AnimData {
int8 animation; int8 animation;
@ -105,92 +107,101 @@ typedef struct Mult_SndKey {
// Globals // Globals
extern Mult_Object *mult_objects; Mult_Object *objects;
extern int16 *mult_renderData; int16 *renderData;
extern int16 mult_objCount; int16 objCount;
extern SurfaceDesc *mult_underAnimSurf; Video::SurfaceDesc *underAnimSurf;
extern char *mult_multData; char *multData;
extern int16 mult_frame; int16 frame;
extern char mult_doPalSubst; char doPalSubst;
extern int16 mult_counter; int16 counter;
extern int16 mult_frameRate; int16 frameRate;
extern int32 *mult_animArrayX; int32 *animArrayX;
extern int32 *mult_animArrayY; int32 *animArrayY;
extern Mult_AnimData *mult_animArrayData; Mult_AnimData *animArrayData;
extern int16 mult_index; int16 index;
// Static keys // Static keys
extern int16 mult_staticKeysCount; int16 staticKeysCount;
extern Mult_StaticKey *mult_staticKeys; Mult_StaticKey *staticKeys;
extern int16 mult_staticIndices[10]; int16 staticIndices[10];
// Anim keys // Anim keys
extern Mult_AnimKey *mult_animKeys[4]; Mult_AnimKey *animKeys[4];
extern int16 mult_animKeysCount[4]; int16 animKeysCount[4];
extern int16 mult_animLayer; int16 animLayer;
extern int16 mult_animIndices[10]; int16 animIndices[10];
// Text keys // Text keys
extern int16 mult_textKeysCount; int16 textKeysCount;
extern Mult_TextKey *mult_textKeys; Mult_TextKey *textKeys;
extern int16 mult_frameStart; int16 frameStart;
// Palette keys // Palette keys
extern int16 mult_palKeyIndex; int16 palKeyIndex;
extern int16 mult_palKeysCount; int16 palKeysCount;
extern Mult_PalKey *mult_palKeys; Mult_PalKey *palKeys;
extern Color *mult_oldPalette; Video::Color *oldPalette;
extern Color mult_palAnimPalette[256]; Video::Color palAnimPalette[256];
extern int16 mult_palAnimKey; int16 palAnimKey;
extern int16 mult_palAnimIndices[4]; int16 palAnimIndices[4];
extern int16 mult_palAnimRed[4]; int16 palAnimRed[4];
extern int16 mult_palAnimGreen[4]; int16 palAnimGreen[4];
extern int16 mult_palAnimBlue[4]; int16 palAnimBlue[4];
// Palette fading // Palette fading
extern Mult_PalFadeKey *mult_palFadeKeys; Mult_PalFadeKey *palFadeKeys;
extern int16 mult_palFadeKeysCount; int16 palFadeKeysCount;
extern char mult_palFadingRed; char palFadingRed;
extern char mult_palFadingGreen; char palFadingGreen;
extern char mult_palFadingBlue; char palFadingBlue;
extern char mult_animDataAllocated; char animDataAllocated;
extern char *mult_dataPtr; char *dataPtr;
extern int16 mult_staticLoaded[10]; int16 staticLoaded[10];
extern int16 mult_animLoaded[10]; int16 animLoaded[10];
extern int16 mult_sndSlotsCount; int16 sndSlotsCount;
// Sound keys // Sound keys
extern int16 mult_sndKeysCount; int16 sndKeysCount;
extern Mult_SndKey *mult_sndKeys; Mult_SndKey *sndKeys;
void mult_zeroMultData(void); void zeroMultData(void);
void mult_loadMult(int16 resId); void loadMult(int16 resId);
void mult_freeMultKeys(void); void freeMultKeys(void);
void mult_checkFreeMult(void); void checkFreeMult(void);
void mult_playMult(int16 startFrame, int16 endFrame, char checkEscape, void playMult(int16 startFrame, int16 endFrame, char checkEscape,
char handleMouse); char handleMouse);
void mult_animate(void); void animate(void);
void mult_interGetObjAnimSize(void); void interGetObjAnimSize(void);
void mult_interInitMult(void); void interInitMult(void);
void mult_freeMult(void); void freeMult(void);
void mult_interLoadMult(void); void interLoadMult(void);
void mult_freeAll(void); void freeAll(void);
void mult_initAll(void); void initAll(void);
void mult_playSound(Snd_SoundDesc * soundDesc, int16 repCount, int16 freq, void playSound(Snd::SoundDesc * soundDesc, int16 repCount, int16 freq,
int16 channel); int16 channel);
void mult_playMult(int16 startFrame, int16 endFrame, char checkEscape,
char handleMouse); Mult(GobEngine *vm);
void mult_zeroMultData(void);
void mult_loadMult(int16 resId); protected:
void mult_freeMultKeys(void); Video::Color fadePal[5][16];
void mult_checkFreeMult(void); 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 } // End of namespace Gob

2
gob/pack.cpp
View file

@ -24,7 +24,7 @@
namespace Gob { namespace Gob {
int32 unpackData(char *sourceBuf, char *destBuf) { int32 Pack::unpackData(char *sourceBuf, char *destBuf) {
uint32 realSize; uint32 realSize;
uint32 counter; uint32 counter;
uint16 cmd; uint16 cmd;

3
gob/pack.h
View file

@ -24,8 +24,11 @@
namespace Gob { namespace Gob {
class Pack {
public:
int32 asm_unpackData(char *source, char *dest, char *temp); int32 asm_unpackData(char *source, char *dest, char *temp);
int32 unpackData(char *source, char *dest); int32 unpackData(char *source, char *dest);
};
} // End of namespace Gob } // End of namespace Gob

187
gob/palanim.cpp
View file

@ -27,74 +27,77 @@
namespace Gob { namespace Gob {
int16 pal_fadeValue = 1; PalAnim::PalAnim(GobEngine *vm) : _vm(vm) {
fadeValue = 1;
for (int i = 0; i < 256; i++) {
toFadeRed[i] = 0;
toFadeGreen[i] = 0;
toFadeBlue[i] = 0;
}
}
byte pal_toFadeRed[256]; char PalAnim::fadeColor(char from, char to) {
byte pal_toFadeGreen[256]; if ((int16)from - fadeValue > (int16)to)
byte pal_toFadeBlue[256]; return from - fadeValue;
else if ((int16)from + fadeValue < (int16)to)
char pal_fadeColor(char from, char to) { return from + fadeValue;
if ((int16)from - pal_fadeValue > (int16)to)
return from - pal_fadeValue;
else if ((int16)from + pal_fadeValue < (int16)to)
return from + pal_fadeValue;
else else
return to; return to;
} }
char pal_fadeStep(int16 oper) { char PalAnim::fadeStep(int16 oper) {
byte newRed; byte newRed;
byte newGreen; byte newGreen;
byte newBlue; byte newBlue;
char stop; char stop;
int16 i; int16 i;
if (colorCount != 256) if (_vm->_global->colorCount != 256)
error("pal_fadeStep: Only 256 color mode is supported!"); error("fadeStep: Only 256 color mode is supported!");
if (oper == 0) { if (oper == 0) {
stop = 1; stop = 1;
if (setAllPalette) { if (_vm->_global->setAllPalette) {
if (inVM != 0) if (_vm->_global->inVM != 0)
error("pal_fade: inVM != 0 not supported."); error("fade: _vm->_global->inVM != 0 not supported.");
for (i = 0; i < 256; i++) { for (i = 0; i < 256; i++) {
newRed = newRed =
pal_fadeColor(redPalette[i], fadeColor(_vm->_global->redPalette[i],
pal_toFadeRed[i]); toFadeRed[i]);
newGreen = newGreen =
pal_fadeColor(greenPalette[i], fadeColor(_vm->_global->greenPalette[i],
pal_toFadeGreen[i]); toFadeGreen[i]);
newBlue = newBlue =
pal_fadeColor(bluePalette[i], fadeColor(_vm->_global->bluePalette[i],
pal_toFadeBlue[i]); toFadeBlue[i]);
if (redPalette[i] != newRed if (_vm->_global->redPalette[i] != newRed
|| greenPalette[i] != newGreen || _vm->_global->greenPalette[i] != newGreen
|| bluePalette[i] != newBlue) { || _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; _vm->_global->redPalette[i] = newRed;
greenPalette[i] = newGreen; _vm->_global->greenPalette[i] = newGreen;
bluePalette[i] = newBlue; _vm->_global->bluePalette[i] = newBlue;
stop = 0; stop = 0;
} }
} }
} else { } else {
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
vid_setPalElem(i, _vm->_video->setPalElem(i,
pal_fadeColor(redPalette[i], fadeColor(_vm->_global->redPalette[i],
pal_toFadeRed[i]), toFadeRed[i]),
pal_fadeColor(greenPalette[i], fadeColor(_vm->_global->greenPalette[i],
pal_toFadeGreen[i]), toFadeGreen[i]),
pal_fadeColor(bluePalette[i], fadeColor(_vm->_global->bluePalette[i],
pal_toFadeBlue[i]), -1, videoMode); toFadeBlue[i]), -1, _vm->_global->videoMode);
if (redPalette[i] != pal_toFadeRed[i] || if (_vm->_global->redPalette[i] != toFadeRed[i] ||
greenPalette[i] != pal_toFadeGreen[i] || _vm->_global->greenPalette[i] != toFadeGreen[i] ||
bluePalette[i] != pal_toFadeBlue[i]) _vm->_global->bluePalette[i] != toFadeBlue[i])
stop = 0; stop = 0;
} }
} }
@ -102,36 +105,36 @@ char pal_fadeStep(int16 oper) {
} else if (oper == 1) { } else if (oper == 1) {
stop = 1; stop = 1;
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
vid_setPalElem(i, _vm->_video->setPalElem(i,
pal_fadeColor(redPalette[i], pal_toFadeRed[i]), fadeColor(_vm->_global->redPalette[i], toFadeRed[i]),
greenPalette[i], bluePalette[i], -1, videoMode); _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; stop = 0;
} }
return stop; return stop;
} else if (oper == 2) { } else if (oper == 2) {
stop = 1; stop = 1;
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
vid_setPalElem(i, _vm->_video->setPalElem(i,
redPalette[i], _vm->_global->redPalette[i],
pal_fadeColor(greenPalette[i], pal_toFadeGreen[i]), fadeColor(_vm->_global->greenPalette[i], toFadeGreen[i]),
bluePalette[i], -1, videoMode); _vm->_global->bluePalette[i], -1, _vm->_global->videoMode);
if (greenPalette[i] != pal_toFadeGreen[i]) if (_vm->_global->greenPalette[i] != toFadeGreen[i])
stop = 0; stop = 0;
} }
return stop; return stop;
} else if (oper == 3) { } else if (oper == 3) {
stop = 1; stop = 1;
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
vid_setPalElem(i, _vm->_video->setPalElem(i,
redPalette[i], _vm->_global->redPalette[i],
greenPalette[i], _vm->_global->greenPalette[i],
pal_fadeColor(bluePalette[i], pal_toFadeBlue[i]), fadeColor(_vm->_global->bluePalette[i], toFadeBlue[i]),
-1, videoMode); -1, _vm->_global->videoMode);
if (bluePalette[i] != pal_toFadeBlue[i]) if (_vm->_global->bluePalette[i] != toFadeBlue[i])
stop = 0; stop = 0;
} }
return stop; return stop;
@ -139,95 +142,95 @@ char pal_fadeStep(int16 oper) {
return 1; return 1;
} }
void pal_fade(PalDesc *palDesc, int16 fade, int16 allColors) { void PalAnim::fade(Video::PalDesc *palDesc, int16 fadeV, int16 allColors) {
char stop; char stop;
int16 i; int16 i;
if (fade < 0) if (fadeV < 0)
pal_fadeValue = -fade; fadeValue = -fadeV;
else else
pal_fadeValue = 2; fadeValue = 2;
if (colorCount < 256) { if (_vm->_global->colorCount < 256) {
if (palDesc != 0) if (palDesc != 0)
vid_setFullPalette(palDesc); _vm->_video->setFullPalette(palDesc);
return; return;
} }
if (setAllPalette == 0) { if (_vm->_global->setAllPalette == 0) {
if (palDesc == 0) { if (palDesc == 0) {
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
pal_toFadeRed[i] = 0; toFadeRed[i] = 0;
pal_toFadeGreen[i] = 0; toFadeGreen[i] = 0;
pal_toFadeBlue[i] = 0; toFadeBlue[i] = 0;
} }
} else { } else {
for (i = 0; i < 16; i++) { for (i = 0; i < 16; i++) {
pal_toFadeRed[i] = palDesc->vgaPal[i].red; toFadeRed[i] = palDesc->vgaPal[i].red;
pal_toFadeGreen[i] = palDesc->vgaPal[i].green; toFadeGreen[i] = palDesc->vgaPal[i].green;
pal_toFadeBlue[i] = palDesc->vgaPal[i].blue; toFadeBlue[i] = palDesc->vgaPal[i].blue;
} }
} }
} else { } else {
if (inVM != 0) if (_vm->_global->inVM != 0)
error("pal_fade: inVM != 0 is not supported"); error("fade: _vm->_global->inVM != 0 is not supported");
if (palDesc == 0) { if (palDesc == 0) {
for (i = 0; i < 256; i++) { for (i = 0; i < 256; i++) {
pal_toFadeRed[i] = 0; toFadeRed[i] = 0;
pal_toFadeGreen[i] = 0; toFadeGreen[i] = 0;
pal_toFadeBlue[i] = 0; toFadeBlue[i] = 0;
} }
} else { } else {
for (i = 0; i < 256; i++) { for (i = 0; i < 256; i++) {
pal_toFadeRed[i] = palDesc->vgaPal[i].red; toFadeRed[i] = palDesc->vgaPal[i].red;
pal_toFadeGreen[i] = palDesc->vgaPal[i].green; toFadeGreen[i] = palDesc->vgaPal[i].green;
pal_toFadeBlue[i] = palDesc->vgaPal[i].blue; toFadeBlue[i] = palDesc->vgaPal[i].blue;
} }
} }
} }
if (allColors == 0) { if (allColors == 0) {
do { do {
if (tmpPalBuffer == 0) if (_vm->_global->tmpPalBuffer == 0)
vid_waitRetrace(videoMode); _vm->_video->waitRetrace(_vm->_global->videoMode);
stop = pal_fadeStep(0); stop = fadeStep(0);
if (fade > 0) if (fadeV > 0)
util_delay(fade); _vm->_util->delay(fadeV);
} while (stop == 0); } while (stop == 0);
if (palDesc != 0) if (palDesc != 0)
vid_setFullPalette(palDesc); _vm->_video->setFullPalette(palDesc);
else else
util_clearPalette(); _vm->_util->clearPalette();
} }
if (allColors == 1) { if (allColors == 1) {
do { do {
vid_waitRetrace(videoMode); _vm->_video->waitRetrace(_vm->_global->videoMode);
stop = pal_fadeStep(1); stop = fadeStep(1);
} while (stop == 0); } while (stop == 0);
do { do {
vid_waitRetrace(videoMode); _vm->_video->waitRetrace(_vm->_global->videoMode);
stop = pal_fadeStep(2); stop = fadeStep(2);
} while (stop == 0); } while (stop == 0);
do { do {
vid_waitRetrace(videoMode); _vm->_video->waitRetrace(_vm->_global->videoMode);
stop = pal_fadeStep(3); stop = fadeStep(3);
} while (stop == 0); } while (stop == 0);
if (palDesc != 0) if (palDesc != 0)
vid_setFullPalette(palDesc); _vm->_video->setFullPalette(palDesc);
else else
util_clearPalette(); _vm->_util->clearPalette();
} }
free(tmpPalBuffer); free(_vm->_global->tmpPalBuffer);
tmpPalBuffer = 0; _vm->_global->tmpPalBuffer = 0;
} }
} // End of namespace Gob } // End of namespace Gob

19
gob/palanim.h
View file

@ -24,11 +24,22 @@
namespace Gob { namespace Gob {
extern int16 pal_fadeValue; class PalAnim {
public:
int16 fadeValue;
char pal_fadeColor(char from, char to); char fadeColor(char from, char to);
char pal_fadeStep(int16 oper); // oper == 0 - fade all colors, 1, 2, 3 - red,green, blue char fadeStep(int16 oper); // oper == 0 - fade all colors, 1, 2, 3 - red,green, blue
void pal_fade(PalDesc * palDesc, int16 fade, int16 all); 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 } // End of namespace Gob

373
gob/parse.cpp
View file

@ -28,24 +28,21 @@
namespace Gob { namespace Gob {
enum PointerType { Parse::Parse(GobEngine *vm) : _vm(vm) {
kExecPtr = 0, }
kInterVar = 1,
kResStr = 2
};
int32 encodePtr(char *ptr, int type) { int32 Parse::encodePtr(char *ptr, int type) {
int32 offset; int32 offset;
switch (type) { switch (type) {
case kExecPtr: case kExecPtr:
offset = ptr - game_totFileData; offset = ptr - _vm->_game->totFileData;
break; break;
case kInterVar: case kInterVar:
offset = ptr - inter_variables; offset = ptr - _vm->_global->inter_variables;
break; break;
case kResStr: case kResStr:
offset = ptr - inter_resStr; offset = ptr - _vm->_global->inter_resStr;
break; break;
default: default:
error("encodePtr: Unknown pointer type"); error("encodePtr: Unknown pointer type");
@ -54,18 +51,18 @@ int32 encodePtr(char *ptr, int type) {
return (type << 28) | offset; return (type << 28) | offset;
} }
char *decodePtr(int32 n) { char *Parse::decodePtr(int32 n) {
char *ptr; char *ptr;
switch (n >> 28) { switch (n >> 28) {
case kExecPtr: case kExecPtr:
ptr = game_totFileData; ptr = _vm->_game->totFileData;
break; break;
case kInterVar: case kInterVar:
ptr = inter_variables; ptr = _vm->_global->inter_variables;
break; break;
case kResStr: case kResStr:
ptr = inter_resStr; ptr = _vm->_global->inter_resStr;
break; break;
default: default:
error("decodePtr: Unknown pointer type"); error("decodePtr: Unknown pointer type");
@ -73,7 +70,7 @@ char *decodePtr(int32 n) {
return ptr + (n & 0x0FFFFFFF); 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]; int32 values[20];
byte operStack[20]; byte operStack[20];
int32 prevPrevVal; int32 prevPrevVal;
@ -101,54 +98,54 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
stkPos++; stkPos++;
operPtr++; operPtr++;
valPtr++; valPtr++;
operation = *inter_execPtr++; operation = *_vm->_global->inter_execPtr++;
if (operation >= 19 && operation <= 29) { if (operation >= 19 && operation <= 29) {
switch (operation) { switch (operation) {
case 19: case 19:
*operPtr = 20; *operPtr = 20;
*valPtr = READ_LE_UINT32(inter_execPtr); *valPtr = READ_LE_UINT32(_vm->_global->inter_execPtr);
inter_execPtr += 4; _vm->_global->inter_execPtr += 4;
break; break;
case 20: case 20:
*operPtr = 20; *operPtr = 20;
*valPtr = inter_load16(); *valPtr = _vm->_inter->load16();
break; break;
case 22: case 22:
*operPtr = 22; *operPtr = 22;
*valPtr = encodePtr(inter_execPtr, kExecPtr); *valPtr = encodePtr(_vm->_global->inter_execPtr, kExecPtr);
inter_execPtr += strlen(inter_execPtr) + 1; _vm->_global->inter_execPtr += strlen(_vm->_global->inter_execPtr) + 1;
break; break;
case 23: case 23:
*operPtr = 20; *operPtr = 20;
*valPtr = VAR(inter_load16()); *valPtr = VAR(_vm->_inter->load16());
break; break;
case 25: case 25:
*operPtr = 22; *operPtr = 22;
temp = inter_load16() * 4; temp = _vm->_inter->load16() * 4;
*valPtr = encodePtr(inter_variables + temp, kInterVar); *valPtr = encodePtr(_vm->_global->inter_variables + temp, kInterVar);
if (*inter_execPtr == 13) { if (*_vm->_global->inter_execPtr == 13) {
inter_execPtr++; _vm->_global->inter_execPtr++;
temp += parse_parseValExpr(); temp += parseValExpr();
*operPtr = 20; *operPtr = 20;
*valPtr = (uint8)*(inter_variables + temp); *valPtr = (uint8)*(_vm->_global->inter_variables + temp);
} }
break; break;
case 26: case 26:
case 28: case 28:
*operPtr = operation - 6; *operPtr = operation - 6;
temp = inter_load16(); temp = _vm->_inter->load16();
dimCount = *inter_execPtr++; dimCount = *_vm->_global->inter_execPtr++;
arrDescPtr = (byte *)inter_execPtr; arrDescPtr = (byte *)_vm->_global->inter_execPtr;
inter_execPtr += dimCount; _vm->_global->inter_execPtr += dimCount;
offset = 0; offset = 0;
dim = 0; dim = 0;
for (dim = 0; dim < dimCount; dim++) { for (dim = 0; dim < dimCount; dim++) {
temp2 = parse_parseValExpr(); temp2 = parseValExpr();
offset = offset * arrDescPtr[dim] + temp2; offset = offset * arrDescPtr[dim] + temp2;
} }
@ -156,22 +153,22 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
*valPtr = VAR(temp + offset); *valPtr = VAR(temp + offset);
break; break;
} }
*valPtr = encodePtr(inter_variables + temp * 4 + offset * inter_animDataSize * 4, kInterVar); *valPtr = encodePtr(_vm->_global->inter_variables + temp * 4 + offset * _vm->_global->inter_animDataSize * 4, kInterVar);
if (*inter_execPtr == 13) { if (*_vm->_global->inter_execPtr == 13) {
inter_execPtr++; _vm->_global->inter_execPtr++;
temp2 = parse_parseValExpr(); temp2 = parseValExpr();
*operPtr = 20; *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; break;
case 29: case 29:
operation = *inter_execPtr++; operation = *_vm->_global->inter_execPtr++;
parse_parseExpr(10, 0); parseExpr(10, 0);
switch (operation) { switch (operation) {
case 5: case 5:
inter_resVal = inter_resVal * inter_resVal; _vm->_global->inter_resVal = _vm->_global->inter_resVal * _vm->_global->inter_resVal;
break; break;
case 0: case 0:
@ -183,22 +180,22 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
do { do {
prevPrevVal = prevVal; prevPrevVal = prevVal;
prevVal = curVal; prevVal = curVal;
curVal = (curVal + inter_resVal / curVal) / 2; curVal = (curVal + _vm->_global->inter_resVal / curVal) / 2;
} while (curVal != prevVal && curVal != prevPrevVal); } while (curVal != prevVal && curVal != prevPrevVal);
inter_resVal = curVal; _vm->_global->inter_resVal = curVal;
break; break;
case 10: case 10:
inter_resVal = util_getRandom(inter_resVal); _vm->_global->inter_resVal = _vm->_util->getRandom(_vm->_global->inter_resVal);
break; break;
case 7: case 7:
if (inter_resVal < 0) if (_vm->_global->inter_resVal < 0)
inter_resVal = -inter_resVal; _vm->_global->inter_resVal = -_vm->_global->inter_resVal;
break; break;
} }
*operPtr = 20; *operPtr = 20;
*valPtr = inter_resVal; *valPtr = _vm->_global->inter_resVal;
} }
if (stkPos > 0 && (operPtr[-1] == 1 || operPtr[-1] == 11)) { 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]) { switch (operPtr[-1]) {
case 2: case 2:
if (operPtr[-2] == 22) { if (operPtr[-2] == 22) {
if (decodePtr(valPtr[-2]) != inter_resStr) { if (decodePtr(valPtr[-2]) != _vm->_global->inter_resStr) {
strcpy(inter_resStr, decodePtr(valPtr[-2])); strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-2]));
valPtr[-2] = encodePtr(inter_resStr, kResStr); valPtr[-2] = encodePtr(_vm->_global->inter_resStr, kResStr);
} }
strcat(inter_resStr, decodePtr(valPtr[0])); strcat(_vm->_global->inter_resStr, decodePtr(valPtr[0]));
stkPos -= 2; stkPos -= 2;
operPtr -= 2; operPtr -= 2;
valPtr -= 2; valPtr -= 2;
@ -343,11 +340,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
if (operStack[brackStart] == 20) { if (operStack[brackStart] == 20) {
values[brackStart] += valPtr[-1]; values[brackStart] += valPtr[-1];
} else if (operStack[brackStart] == 22) { } else if (operStack[brackStart] == 22) {
if (decodePtr(values[brackStart]) != inter_resStr) { if (decodePtr(values[brackStart]) != _vm->_global->inter_resStr) {
strcpy(inter_resStr, decodePtr(values[brackStart])); strcpy(_vm->_global->inter_resStr, decodePtr(values[brackStart]));
values[brackStart] = encodePtr(inter_resStr, kResStr); values[brackStart] = encodePtr(_vm->_global->inter_resStr, kResStr);
} }
strcat(inter_resStr, decodePtr(valPtr[-1])); strcat(_vm->_global->inter_resStr, decodePtr(valPtr[-1]));
} }
stkPos -= 2; stkPos -= 2;
operPtr -= 2; operPtr -= 2;
@ -419,11 +416,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
if (valPtr[-3] < valPtr[-1]) if (valPtr[-3] < valPtr[-1])
operPtr[-3] = 24; operPtr[-3] = 24;
} else if (var_C == 22) { } else if (var_C == 22) {
if (decodePtr(valPtr[-3]) != inter_resStr) { if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) {
strcpy(inter_resStr, decodePtr(valPtr[-3])); strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3]));
valPtr[-3] = encodePtr(inter_resStr, kResStr); 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; operPtr[-3] = 24;
} }
stkPos -= 2; stkPos -= 2;
@ -438,11 +435,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
if (valPtr[-3] <= valPtr[-1]) if (valPtr[-3] <= valPtr[-1])
operPtr[-3] = 24; operPtr[-3] = 24;
} else if (var_C == 22) { } else if (var_C == 22) {
if (decodePtr(valPtr[-3]) != inter_resStr) { if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) {
strcpy(inter_resStr, decodePtr(valPtr[-3])); strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3]));
valPtr[-3] = encodePtr(inter_resStr, kResStr); 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; operPtr[-3] = 24;
} }
stkPos -= 2; stkPos -= 2;
@ -457,11 +454,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
if (valPtr[-3] > valPtr[-1]) if (valPtr[-3] > valPtr[-1])
operPtr[-3] = 24; operPtr[-3] = 24;
} else if (var_C == 22) { } else if (var_C == 22) {
if (decodePtr(valPtr[-3]) != inter_resStr) { if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) {
strcpy(inter_resStr, decodePtr(valPtr[-3])); strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3]));
valPtr[-3] = encodePtr(inter_resStr, kResStr); 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; operPtr[-3] = 24;
} }
stkPos -= 2; stkPos -= 2;
@ -476,11 +473,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
if (valPtr[-3] >= valPtr[-1]) if (valPtr[-3] >= valPtr[-1])
operPtr[-3] = 24; operPtr[-3] = 24;
} else if (var_C == 22) { } else if (var_C == 22) {
if (decodePtr(valPtr[-3]) != inter_resStr) { if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) {
strcpy(inter_resStr, decodePtr(valPtr[-3])); strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3]));
valPtr[-3] = encodePtr(inter_resStr, kResStr); 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; operPtr[-3] = 24;
} }
stkPos -= 2; stkPos -= 2;
@ -495,11 +492,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
if (valPtr[-3] == valPtr[-1]) if (valPtr[-3] == valPtr[-1])
operPtr[-3] = 24; operPtr[-3] = 24;
} else if (var_C == 22) { } else if (var_C == 22) {
if (decodePtr(valPtr[-3]) != inter_resStr) { if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) {
strcpy(inter_resStr, decodePtr(valPtr[-3])); strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3]));
valPtr[-3] = encodePtr(inter_resStr, kResStr); 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; operPtr[-3] = 24;
} }
stkPos -= 2; stkPos -= 2;
@ -514,11 +511,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
if (valPtr[-3] != valPtr[-1]) if (valPtr[-3] != valPtr[-1])
operPtr[-3] = 24; operPtr[-3] = 24;
} else if (var_C == 22) { } else if (var_C == 22) {
if (decodePtr(valPtr[-3]) != inter_resStr) { if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) {
strcpy(inter_resStr, decodePtr(valPtr[-3])); strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3]));
valPtr[-3] = encodePtr(inter_resStr, kResStr); 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; operPtr[-3] = 24;
} }
stkPos -= 2; stkPos -= 2;
@ -546,15 +543,15 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
if ((operation == 30 && operPtr[-1] == 24) || if ((operation == 30 && operPtr[-1] == 24) ||
(operation == 31 && operPtr[-1] == 23)) { (operation == 31 && operPtr[-1] == 23)) {
if (stkPos > 1 && operPtr[-2] == 9) { if (stkPos > 1 && operPtr[-2] == 9) {
parse_skipExpr(10); skipExpr(10);
operPtr[-2] = operPtr[-1]; operPtr[-2] = operPtr[-1];
stkPos -= 2; stkPos -= 2;
operPtr -= 2; operPtr -= 2;
valPtr -= 2; valPtr -= 2;
} else { } 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 (stkPos > 0 && operPtr[-1] == 11) {
if (operPtr[0] == 23) if (operPtr[0] == 23)
operPtr[-1] = 24; operPtr[-1] = 24;
@ -581,12 +578,12 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
switch (operStack[0]) { switch (operStack[0]) {
case 20: case 20:
inter_resVal = values[0]; _vm->_global->inter_resVal = values[0];
break; break;
case 22: case 22:
if (decodePtr(values[0]) != inter_resStr) if (decodePtr(values[0]) != _vm->_global->inter_resStr)
strcpy(inter_resStr, decodePtr(values[0])); strcpy(_vm->_global->inter_resStr, decodePtr(values[0]));
break; break;
case 11: case 11:
@ -599,7 +596,7 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
break; break;
default: default:
inter_resVal = 0; _vm->_global->inter_resVal = 0;
if (arg_2 != 0) if (arg_2 != 0)
*arg_2 = 20; *arg_2 = 20;
break; break;
@ -616,11 +613,11 @@ int16 parse_parseExpr(char arg_0, byte *arg_2) {
if (operPtr[-3] == 20) { if (operPtr[-3] == 20) {
valPtr[-3] += valPtr[-1]; valPtr[-3] += valPtr[-1];
} else if (operPtr[-3] == 22) { } else if (operPtr[-3] == 22) {
if (decodePtr(valPtr[-3]) != inter_resStr) { if (decodePtr(valPtr[-3]) != _vm->_global->inter_resStr) {
strcpy(inter_resStr, decodePtr(valPtr[-3])); strcpy(_vm->_global->inter_resStr, decodePtr(valPtr[-3]));
valPtr[-3] = encodePtr(inter_resStr, kResStr); valPtr[-3] = encodePtr(_vm->_global->inter_resStr, kResStr);
} }
strcat(inter_resStr, decodePtr(valPtr[-1])); strcat(_vm->_global->inter_resStr, decodePtr(valPtr[-1]));
} }
stkPos -= 2; stkPos -= 2;
operPtr -= 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; int16 dimCount;
char operation; char operation;
int16 num; int16 num;
@ -651,47 +648,47 @@ void parse_skipExpr(char arg_0) {
num = 0; num = 0;
while (1) { while (1) {
operation = *inter_execPtr++; operation = *_vm->_global->inter_execPtr++;
if (operation >= 19 && operation <= 29) { if (operation >= 19 && operation <= 29) {
switch (operation) { switch (operation) {
case 20: case 20:
case 23: case 23:
inter_execPtr += 2; _vm->_global->inter_execPtr += 2;
break; break;
case 19: case 19:
inter_execPtr += 4; _vm->_global->inter_execPtr += 4;
break; break;
case 22: case 22:
inter_execPtr += strlen(inter_execPtr) + 1; _vm->_global->inter_execPtr += strlen(_vm->_global->inter_execPtr) + 1;
break; break;
case 25: case 25:
inter_execPtr += 2; _vm->_global->inter_execPtr += 2;
if (*inter_execPtr == 13) { if (*_vm->_global->inter_execPtr == 13) {
inter_execPtr++; _vm->_global->inter_execPtr++;
parse_skipExpr(12); skipExpr(12);
} }
break; break;
case 26: case 26:
case 28: case 28:
dimCount = inter_execPtr[2]; dimCount = _vm->_global->inter_execPtr[2];
inter_execPtr += 3 + dimCount; // ??? _vm->_global->inter_execPtr += 3 + dimCount; // ???
for (dim = 0; dim < dimCount; dim++) for (dim = 0; dim < dimCount; dim++)
parse_skipExpr(12); skipExpr(12);
if (operation == 28 && *inter_execPtr == 13) { if (operation == 28 && *_vm->_global->inter_execPtr == 13) {
inter_execPtr++; _vm->_global->inter_execPtr++;
parse_skipExpr(12); skipExpr(12);
} }
break; break;
case 29: case 29:
inter_execPtr++; _vm->_global->inter_execPtr++;
parse_skipExpr(10); skipExpr(10);
} }
continue; continue;
} // if (operation >= 19 && operation <= 29) } // if (operation >= 19 && operation <= 29)
@ -718,7 +715,7 @@ void parse_skipExpr(char arg_0) {
} }
} }
int16 parse_parseValExpr() { int16 Parse::parseValExpr() {
int16 values[20]; int16 values[20];
byte operStack[20]; byte operStack[20];
int16 *valPtr; int16 *valPtr;
@ -738,7 +735,7 @@ int16 parse_parseValExpr() {
oldflag = flag; oldflag = flag;
if (flag == 0) { if (flag == 0) {
flag = 1; flag = 1;
parse_printExpr(99); printExpr(99);
} }
stkPos = -1; stkPos = -1;
@ -750,63 +747,63 @@ int16 parse_parseValExpr() {
operPtr++; operPtr++;
valPtr++; valPtr++;
operation = *inter_execPtr++; operation = *_vm->_global->inter_execPtr++;
if (operation >= 19 && operation <= 29) { if (operation >= 19 && operation <= 29) {
*operPtr = 20; *operPtr = 20;
switch (operation) { switch (operation) {
case 19: case 19:
*valPtr = READ_LE_UINT32(inter_execPtr); *valPtr = READ_LE_UINT32(_vm->_global->inter_execPtr);
inter_execPtr += 4; _vm->_global->inter_execPtr += 4;
break; break;
case 20: case 20:
*valPtr = inter_load16(); *valPtr = _vm->_inter->load16();
break; break;
case 23: case 23:
*valPtr = (uint16)VAR(inter_load16()); *valPtr = (uint16)VAR(_vm->_inter->load16());
break; break;
case 25: case 25:
temp = inter_load16() * 4; temp = _vm->_inter->load16() * 4;
inter_execPtr++; _vm->_global->inter_execPtr++;
temp += parse_parseValExpr(); temp += parseValExpr();
*valPtr = (uint8)*(inter_variables + temp); *valPtr = (uint8)*(_vm->_global->inter_variables + temp);
break; break;
case 26: case 26:
case 28: case 28:
temp = inter_load16(); temp = _vm->_inter->load16();
dimCount = *inter_execPtr++; dimCount = *_vm->_global->inter_execPtr++;
arrDesc = (byte*)inter_execPtr; arrDesc = (byte*)_vm->_global->inter_execPtr;
inter_execPtr += dimCount; _vm->_global->inter_execPtr += dimCount;
offset = 0; offset = 0;
for (dim = 0; dim < dimCount; dim++) { for (dim = 0; dim < dimCount; dim++) {
temp2 = parse_parseValExpr(); temp2 = parseValExpr();
offset = arrDesc[dim] * offset + temp2; offset = arrDesc[dim] * offset + temp2;
} }
if (operation == 26) { if (operation == 26) {
*valPtr = (uint16)VAR(temp + offset); *valPtr = (uint16)VAR(temp + offset);
} else { } else {
inter_execPtr++; _vm->_global->inter_execPtr++;
temp2 = parse_parseValExpr(); temp2 = parseValExpr();
*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; break;
case 29: case 29:
operation = *inter_execPtr++; operation = *_vm->_global->inter_execPtr++;
parse_parseExpr(10, 0); parseExpr(10, 0);
if (operation == 5) { 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) { } else if (operation == 7) {
if (inter_resVal < 0) if (_vm->_global->inter_resVal < 0)
inter_resVal = -inter_resVal; _vm->_global->inter_resVal = -_vm->_global->inter_resVal;
} else if (operation == 10) { } 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; break;
} // switch } // switch
@ -943,7 +940,7 @@ int16 parse_parseValExpr() {
} }
} }
int16 parse_parseVarIndex() { int16 Parse::parseVarIndex() {
int16 temp2; int16 temp2;
char *arrDesc; char *arrDesc;
int16 dim; int16 dim;
@ -953,16 +950,16 @@ int16 parse_parseVarIndex() {
int16 offset; int16 offset;
int16 val; int16 val;
operation = *inter_execPtr++; operation = *_vm->_global->inter_execPtr++;
debug(5, "var parse = %d", operation); debug(5, "var parse = %d", operation);
switch (operation) { switch (operation) {
case 23: case 23:
case 25: case 25:
temp = inter_load16() * 4; temp = _vm->_inter->load16() * 4;
debug(5, "oper = %d", (int16)*inter_execPtr); debug(5, "oper = %d", (int16)*_vm->_global->inter_execPtr);
if (operation == 25 && *inter_execPtr == 13) { if (operation == 25 && *_vm->_global->inter_execPtr == 13) {
inter_execPtr++; _vm->_global->inter_execPtr++;
val = parse_parseValExpr(); val = parseValExpr();
temp += val; temp += val;
debug(5, "parse subscript = %d", val); debug(5, "parse subscript = %d", val);
} }
@ -970,31 +967,31 @@ int16 parse_parseVarIndex() {
case 26: case 26:
case 28: case 28:
temp = inter_load16() * 4; temp = _vm->_inter->load16() * 4;
dimCount = *inter_execPtr++; dimCount = *_vm->_global->inter_execPtr++;
arrDesc = inter_execPtr; arrDesc = _vm->_global->inter_execPtr;
inter_execPtr += dimCount; _vm->_global->inter_execPtr += dimCount;
offset = 0; offset = 0;
for (dim = 0; dim < dimCount; dim++) { for (dim = 0; dim < dimCount; dim++) {
temp2 = parse_parseValExpr(); temp2 = parseValExpr();
offset = arrDesc[dim] * offset + temp2; offset = arrDesc[dim] * offset + temp2;
} }
offset *= 4; offset *= 4;
if (operation != 28) if (operation != 28)
return temp + offset; return temp + offset;
if (*inter_execPtr == 13) { if (*_vm->_global->inter_execPtr == 13) {
inter_execPtr++; _vm->_global->inter_execPtr++;
temp += parse_parseValExpr(); temp += parseValExpr();
} }
return offset * inter_animDataSize + temp; return offset * _vm->_global->inter_animDataSize + temp;
default: default:
return 0; return 0;
} }
} }
void parse_printExpr(char arg_0) { void Parse::printExpr(char arg_0) {
int16 dimCount; int16 dimCount;
char operation; char operation;
int16 num; int16 num;
@ -1009,40 +1006,40 @@ void parse_printExpr(char arg_0) {
return; return;
if (savedPos == 0) { if (savedPos == 0) {
savedPos = inter_execPtr; savedPos = _vm->_global->inter_execPtr;
saved = 1; saved = 1;
} }
num = 0; num = 0;
while (1) { while (1) {
operation = *inter_execPtr++; operation = *_vm->_global->inter_execPtr++;
if (operation >= 19 && operation <= 29) { if (operation >= 19 && operation <= 29) {
switch (operation) { switch (operation) {
case 19: case 19:
debug(5, "%l", READ_LE_UINT32(inter_execPtr)); debug(5, "%l", READ_LE_UINT32(_vm->_global->inter_execPtr));
inter_execPtr += 4; _vm->_global->inter_execPtr += 4;
break; break;
case 20: case 20:
debug(5, "%d", inter_load16()); debug(5, "%d", _vm->_inter->load16());
break; break;
case 22: case 22:
debug(5, "\42%s\42", inter_execPtr); debug(5, "\42%s\42", _vm->_global->inter_execPtr);
inter_execPtr += strlen(inter_execPtr) + 1; _vm->_global->inter_execPtr += strlen(_vm->_global->inter_execPtr) + 1;
break; break;
case 23: case 23:
debug(5, "var_%d", inter_load16()); debug(5, "var_%d", _vm->_inter->load16());
break; break;
case 25: case 25:
debug(5, "(&var_%d)", inter_load16()); debug(5, "(&var_%d)", _vm->_inter->load16());
if (*inter_execPtr == 13) { if (*_vm->_global->inter_execPtr == 13) {
inter_execPtr++; _vm->_global->inter_execPtr++;
debug(5, "{"); debug(5, "{");
parse_printExpr(12); printExpr(12);
// debug(5, "}"); // debug(5, "}");
} }
break; break;
@ -1052,12 +1049,12 @@ void parse_printExpr(char arg_0) {
if (operation == 28) if (operation == 28)
debug(5, "(&"); debug(5, "(&");
debug(5, "var_%d[", inter_load16()); debug(5, "var_%d[", _vm->_inter->load16());
dimCount = *inter_execPtr++; dimCount = *_vm->_global->inter_execPtr++;
arrDesc = inter_execPtr; arrDesc = _vm->_global->inter_execPtr;
inter_execPtr += dimCount; _vm->_global->inter_execPtr += dimCount;
for (dim = 0; dim < dimCount; dim++) { for (dim = 0; dim < dimCount; dim++) {
parse_printExpr(12); printExpr(12);
debug(5, " of %d", (int16)arrDesc[dim]); debug(5, " of %d", (int16)arrDesc[dim]);
if (dim != dimCount - 1) if (dim != dimCount - 1)
debug(5, ","); debug(5, ",");
@ -1066,16 +1063,16 @@ void parse_printExpr(char arg_0) {
if (operation == 28) if (operation == 28)
debug(5, ")"); debug(5, ")");
if (operation == 28 && *inter_execPtr == 13) { if (operation == 28 && *_vm->_global->inter_execPtr == 13) {
inter_execPtr++; _vm->_global->inter_execPtr++;
debug(5, "{"); debug(5, "{");
parse_printExpr(12); printExpr(12);
// debug(5, "}"); // debug(5, "}");
} }
break; break;
case 29: case 29:
func = *inter_execPtr++; func = *_vm->_global->inter_execPtr++;
if (func == 5) if (func == 5)
debug(5, "sqr("); debug(5, "sqr(");
else if (func == 10) else if (func == 10)
@ -1086,7 +1083,7 @@ void parse_printExpr(char arg_0) {
debug(5, "sqrt("); debug(5, "sqrt(");
else else
debug(5, "id("); debug(5, "id(");
parse_printExpr(10); printExpr(10);
break; break;
case 12: case 12:
@ -1207,7 +1204,7 @@ void parse_printExpr(char arg_0) {
if (arg_0 != 10 || num < 0) { if (arg_0 != 10 || num < 0) {
if (saved != 0) { if (saved != 0) {
inter_execPtr = savedPos; _vm->_global->inter_execPtr = savedPos;
savedPos = 0; savedPos = 0;
} }
return; return;
@ -1216,46 +1213,46 @@ void parse_printExpr(char arg_0) {
} }
} }
void parse_printVarIndex() { void Parse::printVarIndex() {
char *arrDesc; char *arrDesc;
int16 dim; int16 dim;
int16 dimCount; int16 dimCount;
int16 operation; int16 operation;
int16 temp; int16 temp;
char *pos = inter_execPtr; char *pos = _vm->_global->inter_execPtr;
operation = *inter_execPtr++; operation = *_vm->_global->inter_execPtr++;
switch (operation) { switch (operation) {
case 23: case 23:
case 25: case 25:
temp = inter_load16() * 4; temp = _vm->_inter->load16() * 4;
debug(5, "&var_%d", temp); debug(5, "&var_%d", temp);
if (operation == 25 && *inter_execPtr == 13) { if (operation == 25 && *_vm->_global->inter_execPtr == 13) {
inter_execPtr++; _vm->_global->inter_execPtr++;
debug(5, "+"); debug(5, "+");
parse_printExpr(99); printExpr(99);
} }
break; break;
case 26: case 26:
case 28: case 28:
debug(5, "&var_%d[", inter_load16()); debug(5, "&var_%d[", _vm->_inter->load16());
dimCount = *inter_execPtr++; dimCount = *_vm->_global->inter_execPtr++;
arrDesc = inter_execPtr; arrDesc = _vm->_global->inter_execPtr;
inter_execPtr += dimCount; _vm->_global->inter_execPtr += dimCount;
for (dim = 0; dim < dimCount; dim++) { for (dim = 0; dim < dimCount; dim++) {
parse_printExpr(12); printExpr(12);
debug(5, " of %d", (int16)arrDesc[dim]); debug(5, " of %d", (int16)arrDesc[dim]);
if (dim != dimCount - 1) if (dim != dimCount - 1)
debug(5, ","); debug(5, ",");
} }
debug(5, "]"); debug(5, "]");
if (operation == 28 && *inter_execPtr == 13) { if (operation == 28 && *_vm->_global->inter_execPtr == 13) {
inter_execPtr++; _vm->_global->inter_execPtr++;
debug(5, "+"); debug(5, "+");
parse_printExpr(99); printExpr(99);
} }
break; break;
@ -1264,7 +1261,7 @@ void parse_printVarIndex() {
break; break;
} }
debug(5, "\n"); debug(5, "\n");
inter_execPtr = pos; _vm->_global->inter_execPtr = pos;
return; return;
} }

29
gob/parse.h
View file

@ -24,12 +24,29 @@
namespace Gob { namespace Gob {
int16 parse_parseExpr(char stopToken, byte *resultPtr); class Parse {
void parse_skipExpr(char stopToken); public:
int16 parse_parseValExpr(void); int16 parseExpr(char stopToken, byte *resultPtr);
int16 parse_parseVarIndex(void); void skipExpr(char stopToken);
void parse_printExpr(char stopToken); int16 parseValExpr(void);
void parse_printVarIndex(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 } // End of namespace Gob

614
gob/scenery.cpp
View file

@ -33,35 +33,39 @@
namespace Gob { namespace Gob {
int16 scen_spriteResId[20]; Scenery::Scenery(GobEngine *vm) : _vm(vm) {
char scen_spriteRefs[20]; 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;
}
Scen_Static scen_statics[10]; curStatic = 0;
int16 scen_staticPictCount[10]; curStaticLayer = 0;
char scen_staticFromExt[10];
int16 scen_staticResId[10];
char scen_staticPictToSprite[70];
Scen_Animation scen_animations[10]; toRedrawLeft = 0;
int16 scen_animPictCount[10]; toRedrawRight = 0;
char scen_animFromExt[10]; toRedrawTop = 0;
int16 scen_animResId[10]; toRedrawBottom = 0;
char scen_animPictToSprite[70];
int16 scen_curStatic; animTop = 0;
int16 scen_curStaticLayer; animLeft = 0;
int16 scen_toRedrawLeft; pCaptureCounter = 0;
int16 scen_toRedrawRight; }
int16 scen_toRedrawTop;
int16 scen_toRedrawBottom;
int16 scen_animTop; int16 Scenery::loadStatic(char search) {
int16 scen_animLeft;
int16 *scen_pCaptureCounter;
int16 scen_loadStatic(char search) {
int16 tmp; int16 tmp;
int16 *backsPtr; int16 *backsPtr;
int16 picsCount; int16 picsCount;
@ -69,7 +73,7 @@ int16 scen_loadStatic(char search) {
int16 i; int16 i;
int16 sceneryIndex; int16 sceneryIndex;
char *dataPtr; char *dataPtr;
Scen_Static *ptr; Static *ptr;
int16 offset; int16 offset;
int16 pictDescId; int16 pictDescId;
int16 width; int16 width;
@ -77,48 +81,48 @@ int16 scen_loadStatic(char search) {
int16 sprResId; int16 sprResId;
int16 sprIndex; int16 sprIndex;
inter_evalExpr(&sceneryIndex); _vm->_inter->evalExpr(&sceneryIndex);
tmp = inter_load16(); tmp = _vm->_inter->load16();
backsPtr = (int16 *)inter_execPtr; backsPtr = (int16 *)_vm->_global->inter_execPtr;
inter_execPtr += tmp * 2; _vm->_global->inter_execPtr += tmp * 2;
picsCount = inter_load16(); picsCount = _vm->_inter->load16();
resId = inter_load16(); resId = _vm->_inter->load16();
if (search) { if (search) {
for (i = 0; i < 10; i++) { for (i = 0; i < 10; i++) {
if (scen_staticPictCount[i] != -1 && scen_staticResId[i] == resId) { if (staticPictCount[i] != -1 && staticResId[i] == resId) {
inter_execPtr += 8 * scen_staticPictCount[i]; _vm->_global->inter_execPtr += 8 * staticPictCount[i];
return i; return i;
} }
if (scen_staticPictCount[i] == -1 && i < sceneryIndex) if (staticPictCount[i] == -1 && i < sceneryIndex)
sceneryIndex = i; sceneryIndex = i;
} }
} }
scen_staticPictCount[sceneryIndex] = picsCount; staticPictCount[sceneryIndex] = picsCount;
scen_staticResId[sceneryIndex] = resId; staticResId[sceneryIndex] = resId;
if (resId >= 30000) { if (resId >= 30000) {
scen_staticFromExt[sceneryIndex] = 1; staticFromExt[sceneryIndex] = 1;
dataPtr = game_loadExtData(resId, 0, 0); dataPtr = _vm->_game->loadExtData(resId, 0, 0);
} else { } else {
scen_staticFromExt[sceneryIndex] = 0; staticFromExt[sceneryIndex] = 0;
dataPtr = game_loadTotResource(resId); dataPtr = _vm->_game->loadTotResource(resId);
} }
ptr = &scen_statics[sceneryIndex]; ptr = &statics[sceneryIndex];
ptr->dataPtr = dataPtr; ptr->dataPtr = dataPtr;
ptr->layersCount = (int16)READ_LE_UINT16(dataPtr); ptr->layersCount = (int16)READ_LE_UINT16(dataPtr);
dataPtr += 2; dataPtr += 2;
ptr->layers = (Scen_StaticLayer **)malloc(sizeof(Scen_StaticLayer *) * ptr->layersCount); ptr->layers = (StaticLayer **)malloc(sizeof(StaticLayer *) * ptr->layersCount);
ptr->pieces = (Scen_PieceDesc **)malloc(sizeof(Scen_PieceDesc *) * picsCount); ptr->pieces = (PieceDesc **)malloc(sizeof(PieceDesc *) * picsCount);
ptr->piecesFromExt = (int8 *)malloc(picsCount); ptr->piecesFromExt = (int8 *)malloc(picsCount);
for (i = 0; i < ptr->layersCount; i++) { for (i = 0; i < ptr->layersCount; i++) {
offset = (int16)READ_LE_UINT16(&((int16 *)dataPtr)[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); 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++) { for (i = 0; i < picsCount; i++) {
pictDescId = inter_load16(); pictDescId = _vm->_inter->load16();
if (pictDescId >= 30000) { if (pictDescId >= 30000) {
ptr->pieces[i] = ptr->pieces[i] =
(Scen_PieceDesc *) game_loadExtData(pictDescId, 0, (PieceDesc *) _vm->_game->loadExtData(pictDescId, 0,
0); 0);
ptr->piecesFromExt[i] = 1; ptr->piecesFromExt[i] = 1;
} else { } else {
ptr->pieces[i] = ptr->pieces[i] =
(Scen_PieceDesc *) (PieceDesc *)
game_loadTotResource(pictDescId); _vm->_game->loadTotResource(pictDescId);
ptr->piecesFromExt[i] = 0; ptr->piecesFromExt[i] = 0;
} }
width = inter_load16(); width = _vm->_inter->load16();
height = inter_load16(); height = _vm->_inter->load16();
sprResId = inter_load16(); sprResId = _vm->_inter->load16();
for (sprIndex = 0; sprIndex < 20; sprIndex++) { for (sprIndex = 0; sprIndex < 20; sprIndex++) {
if (scen_spriteResId[sprIndex] == sprResId) if (spriteResId[sprIndex] == sprResId)
break; break;
} }
if (sprIndex < 20) { if (sprIndex < 20) {
scen_staticPictToSprite[7 * sceneryIndex + i] = staticPictToSprite[7 * sceneryIndex + i] =
sprIndex; sprIndex;
scen_spriteRefs[sprIndex]++; spriteRefs[sprIndex]++;
} else { } else {
for (sprIndex = 19; draw_spritesArray[sprIndex] != 0; for (sprIndex = 19; _vm->_draw->spritesArray[sprIndex] != 0;
sprIndex--); sprIndex--);
scen_staticPictToSprite[7 * sceneryIndex + i] = staticPictToSprite[7 * sceneryIndex + i] =
sprIndex; sprIndex;
scen_spriteRefs[sprIndex] = 1; spriteRefs[sprIndex] = 1;
scen_spriteResId[sprIndex] = sprResId; spriteResId[sprIndex] = sprResId;
draw_spritesArray[sprIndex] = _vm->_draw->spritesArray[sprIndex] =
vid_initSurfDesc(videoMode, width, height, 2); _vm->_video->initSurfDesc(_vm->_global->videoMode, width, height, 2);
vid_clearSurf(draw_spritesArray[sprIndex]); _vm->_video->clearSurf(_vm->_draw->spritesArray[sprIndex]);
draw_destSurface = sprIndex; _vm->_draw->destSurface = sprIndex;
draw_spriteLeft = sprResId; _vm->_draw->spriteLeft = sprResId;
draw_transparency = 0; _vm->_draw->transparency = 0;
draw_destSpriteX = 0; _vm->_draw->destSpriteX = 0;
draw_destSpriteY = 0; _vm->_draw->destSpriteY = 0;
draw_spriteOperation(DRAW_LOADSPRITE); _vm->_draw->spriteOperation(DRAW_LOADSPRITE);
} }
} }
return sceneryIndex + 100; return sceneryIndex + 100;
} }
void scen_freeStatic(int16 index) { void Scenery::freeStatic(int16 index) {
int16 i; int16 i;
int16 spr; int16 spr;
if (index == -1) if (index == -1)
inter_evalExpr(&index); _vm->_inter->evalExpr(&index);
if (scen_staticPictCount[index] == -1) if (staticPictCount[index] == -1)
return; return;
for (i = 0; i < scen_staticPictCount[index]; i++) { for (i = 0; i < staticPictCount[index]; i++) {
if (scen_statics[index].piecesFromExt[i] == 1) if (statics[index].piecesFromExt[i] == 1)
free(scen_statics[index].pieces[i]); free(statics[index].pieces[i]);
spr = scen_staticPictToSprite[index * 7 + i]; spr = staticPictToSprite[index * 7 + i];
scen_spriteRefs[spr]--; spriteRefs[spr]--;
if (scen_spriteRefs[spr] == 0) { if (spriteRefs[spr] == 0) {
vid_freeSurfDesc(draw_spritesArray[spr]); _vm->_video->freeSurfDesc(_vm->_draw->spritesArray[spr]);
draw_spritesArray[spr] = 0; _vm->_draw->spritesArray[spr] = 0;
scen_spriteResId[spr] = -1; spriteResId[spr] = -1;
} }
} }
free(scen_statics[index].layers); free(statics[index].layers);
free(scen_statics[index].pieces); free(statics[index].pieces);
free(scen_statics[index].piecesFromExt); free(statics[index].piecesFromExt);
if (scen_staticFromExt[index] == 1) if (staticFromExt[index] == 1)
free(scen_statics[index].dataPtr); free(statics[index].dataPtr);
scen_staticFromExt[index] = 0; staticFromExt[index] = 0;
scen_staticPictCount[index] = -1; staticPictCount[index] = -1;
} }
void scen_renderStatic(int16 scenery, int16 layer) { void Scenery::renderStatic(int16 scenery, int16 layer) {
Scen_Static *ptr; Static *ptr;
Scen_StaticLayer *layerPtr; StaticLayer *layerPtr;
Scen_StaticPlane *planePtr; StaticPlane *planePtr;
int16 planeCount; int16 planeCount;
int16 order; int16 order;
int16 plane; int16 plane;
@ -229,19 +233,19 @@ void scen_renderStatic(int16 scenery, int16 layer) {
int16 top; int16 top;
int16 bottom; int16 bottom;
ptr = &scen_statics[scenery]; ptr = &statics[scenery];
if (layer >= ptr->layersCount) if (layer >= ptr->layersCount)
return; return;
layerPtr = ptr->layers[layer]; layerPtr = ptr->layers[layer];
draw_spriteLeft = layerPtr->backResId; _vm->_draw->spriteLeft = layerPtr->backResId;
if (draw_spriteLeft != -1) { if (_vm->_draw->spriteLeft != -1) {
draw_destSpriteX = 0; _vm->_draw->destSpriteX = 0;
draw_destSpriteY = 0; _vm->_draw->destSpriteY = 0;
draw_destSurface = 21; _vm->_draw->destSurface = 21;
draw_transparency = 0; _vm->_draw->transparency = 0;
draw_spriteOperation(DRAW_LOADSPRITE); _vm->_draw->spriteOperation(DRAW_LOADSPRITE);
} }
planeCount = layerPtr->planeCount; planeCount = layerPtr->planeCount;
@ -254,44 +258,44 @@ void scen_renderStatic(int16 scenery, int16 layer) {
pieceIndex = planePtr->pieceIndex; pieceIndex = planePtr->pieceIndex;
pictIndex = planePtr->pictIndex - 1; pictIndex = planePtr->pictIndex - 1;
draw_destSpriteX = planePtr->destX; _vm->_draw->destSpriteX = planePtr->destX;
draw_destSpriteY = planePtr->destY; _vm->_draw->destSpriteY = planePtr->destY;
left = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].left); left = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].left);
right = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].right); right = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].right);
top = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].top); top = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].top);
bottom = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].bottom); bottom = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].bottom);
draw_sourceSurface = _vm->_draw->sourceSurface =
scen_staticPictToSprite[scenery * 7 + pictIndex]; staticPictToSprite[scenery * 7 + pictIndex];
draw_destSurface = 21; _vm->_draw->destSurface = 21;
draw_spriteLeft = left; _vm->_draw->spriteLeft = left;
draw_spriteTop = top; _vm->_draw->spriteTop = top;
draw_spriteRight = right - left + 1; _vm->_draw->spriteRight = right - left + 1;
draw_spriteBottom = bottom - top + 1; _vm->_draw->spriteBottom = bottom - top + 1;
draw_transparency = planePtr->transp ? 3 : 0; _vm->_draw->transparency = planePtr->transp ? 3 : 0;
draw_spriteOperation(DRAW_BLITSURF); _vm->_draw->spriteOperation(DRAW_BLITSURF);
} }
} }
} }
void scen_interRenderStatic(void) { void Scenery::interRenderStatic(void) {
int16 layer; int16 layer;
int16 index; int16 index;
inter_evalExpr(&index); _vm->_inter->evalExpr(&index);
inter_evalExpr(&layer); _vm->_inter->evalExpr(&layer);
scen_renderStatic(index, layer); renderStatic(index, layer);
} }
void scen_interLoadCurLayer(void) { void Scenery::interLoadCurLayer(void) {
inter_evalExpr(&scen_curStatic); _vm->_inter->evalExpr(&curStatic);
inter_evalExpr(&scen_curStaticLayer); _vm->_inter->evalExpr(&curStaticLayer);
} }
void scen_updateStatic(int16 orderFrom) { void Scenery::updateStatic(int16 orderFrom) {
Scen_StaticLayer *layerPtr; StaticLayer *layerPtr;
Scen_PieceDesc **pictPtr; PieceDesc **pictPtr;
Scen_StaticPlane *planePtr; StaticPlane *planePtr;
int16 planeCount; int16 planeCount;
int16 order; int16 order;
int16 plane; int16 plane;
@ -303,14 +307,14 @@ void scen_updateStatic(int16 orderFrom) {
int16 top; int16 top;
int16 bottom; int16 bottom;
if (scen_curStatic == -1) if (curStatic == -1)
return; return;
if (scen_curStaticLayer >= scen_statics[scen_curStatic].layersCount) if (curStaticLayer >= statics[curStatic].layersCount)
return; return;
layerPtr = scen_statics[scen_curStatic].layers[scen_curStaticLayer]; layerPtr = statics[curStatic].layers[curStaticLayer];
pictPtr = scen_statics[scen_curStatic].pieces; pictPtr = statics[curStatic].pieces;
planeCount = layerPtr->planeCount; planeCount = layerPtr->planeCount;
@ -322,65 +326,65 @@ void scen_updateStatic(int16 orderFrom) {
pieceIndex = planePtr->pieceIndex; pieceIndex = planePtr->pieceIndex;
pictIndex = planePtr->pictIndex - 1; pictIndex = planePtr->pictIndex - 1;
draw_destSpriteX = planePtr->destX; _vm->_draw->destSpriteX = planePtr->destX;
draw_destSpriteY = planePtr->destY; _vm->_draw->destSpriteY = planePtr->destY;
left = FROM_LE_16(pictPtr[pictIndex][pieceIndex].left); left = FROM_LE_16(pictPtr[pictIndex][pieceIndex].left);
right = FROM_LE_16(pictPtr[pictIndex][pieceIndex].right); right = FROM_LE_16(pictPtr[pictIndex][pieceIndex].right);
top = FROM_LE_16(pictPtr[pictIndex][pieceIndex].top); top = FROM_LE_16(pictPtr[pictIndex][pieceIndex].top);
bottom = FROM_LE_16(pictPtr[pictIndex][pieceIndex].bottom); bottom = FROM_LE_16(pictPtr[pictIndex][pieceIndex].bottom);
if (draw_destSpriteX > scen_toRedrawRight) if (_vm->_draw->destSpriteX > toRedrawRight)
continue; continue;
if (draw_destSpriteY > scen_toRedrawBottom) if (_vm->_draw->destSpriteY > toRedrawBottom)
continue; continue;
if (draw_destSpriteX < scen_toRedrawLeft) { if (_vm->_draw->destSpriteX < toRedrawLeft) {
left += scen_toRedrawLeft - draw_destSpriteX; left += toRedrawLeft - _vm->_draw->destSpriteX;
draw_destSpriteX = scen_toRedrawLeft; _vm->_draw->destSpriteX = toRedrawLeft;
} }
if (draw_destSpriteY < scen_toRedrawTop) { if (_vm->_draw->destSpriteY < toRedrawTop) {
top += scen_toRedrawTop - draw_destSpriteY; top += toRedrawTop - _vm->_draw->destSpriteY;
draw_destSpriteY = scen_toRedrawTop; _vm->_draw->destSpriteY = toRedrawTop;
} }
draw_spriteLeft = left; _vm->_draw->spriteLeft = left;
draw_spriteTop = top; _vm->_draw->spriteTop = top;
draw_spriteRight = right - left + 1; _vm->_draw->spriteRight = right - left + 1;
draw_spriteBottom = bottom - top + 1; _vm->_draw->spriteBottom = bottom - top + 1;
if (draw_spriteRight <= 0 || draw_spriteBottom <= 0) if (_vm->_draw->spriteRight <= 0 || _vm->_draw->spriteBottom <= 0)
continue; continue;
if (draw_destSpriteX + draw_spriteRight - 1 > if (_vm->_draw->destSpriteX + _vm->_draw->spriteRight - 1 >
scen_toRedrawRight) toRedrawRight)
draw_spriteRight = _vm->_draw->spriteRight =
scen_toRedrawRight - draw_destSpriteX + 1; toRedrawRight - _vm->_draw->destSpriteX + 1;
if (draw_destSpriteY + draw_spriteBottom - 1 > if (_vm->_draw->destSpriteY + _vm->_draw->spriteBottom - 1 >
scen_toRedrawBottom) toRedrawBottom)
draw_spriteBottom = _vm->_draw->spriteBottom =
scen_toRedrawBottom - draw_destSpriteY + 1; toRedrawBottom - _vm->_draw->destSpriteY + 1;
draw_sourceSurface = _vm->_draw->sourceSurface =
scen_staticPictToSprite[scen_curStatic * 7 + staticPictToSprite[curStatic * 7 +
pictIndex]; pictIndex];
draw_destSurface = 21; _vm->_draw->destSurface = 21;
draw_transparency = planePtr->transp ? 3 : 0; _vm->_draw->transparency = planePtr->transp ? 3 : 0;
draw_spriteOperation(DRAW_BLITSURF); _vm->_draw->spriteOperation(DRAW_BLITSURF);
} }
} }
} }
int16 scen_loadAnim(char search) { int16 Scenery::loadAnim(char search) {
int16 picsCount; int16 picsCount;
int16 resId; int16 resId;
int16 i; int16 i;
int16 sceneryIndex; int16 sceneryIndex;
char *dataPtr; char *dataPtr;
Scen_Animation *ptr; Animation *ptr;
int16 offset; int16 offset;
int16 pictDescId; int16 pictDescId;
int16 width; int16 width;
@ -388,58 +392,58 @@ int16 scen_loadAnim(char search) {
int16 sprResId; int16 sprResId;
int16 sprIndex; int16 sprIndex;
if (cd_globFlag) { if (_vm->_cdrom->_cdPlaying) {
while (cd_getTrackPos() != -1) while (_vm->_cdrom->getTrackPos() != -1)
util_longDelay(50); _vm->_util->longDelay(50);
cd_globFlag = false; _vm->_cdrom->_cdPlaying = false;
} }
inter_evalExpr(&sceneryIndex); _vm->_inter->evalExpr(&sceneryIndex);
picsCount = inter_load16(); picsCount = _vm->_inter->load16();
resId = inter_load16(); resId = _vm->_inter->load16();
if (search) { if (search) {
for (i = 0; i < 10; i++) { for (i = 0; i < 10; i++) {
if (scen_animPictCount[i] != 0 if (animPictCount[i] != 0
&& scen_animResId[i] == resId) { && animResId[i] == resId) {
inter_execPtr += 8 * scen_animPictCount[i]; _vm->_global->inter_execPtr += 8 * animPictCount[i];
return i; return i;
} }
if (scen_animPictCount[i] == 0 && i < sceneryIndex) if (animPictCount[i] == 0 && i < sceneryIndex)
sceneryIndex = i; sceneryIndex = i;
} }
} }
scen_animPictCount[sceneryIndex] = picsCount; animPictCount[sceneryIndex] = picsCount;
scen_animResId[sceneryIndex] = resId; animResId[sceneryIndex] = resId;
if (resId >= 30000) { if (resId >= 30000) {
scen_animFromExt[sceneryIndex] = 1; animFromExt[sceneryIndex] = 1;
dataPtr = game_loadExtData(resId, 0, 0); dataPtr = _vm->_game->loadExtData(resId, 0, 0);
} else { } else {
scen_animFromExt[sceneryIndex] = 0; animFromExt[sceneryIndex] = 0;
dataPtr = game_loadTotResource(resId); dataPtr = _vm->_game->loadTotResource(resId);
} }
ptr = &scen_animations[sceneryIndex]; ptr = &animations[sceneryIndex];
ptr->dataPtr = dataPtr; ptr->dataPtr = dataPtr;
ptr->layersCount = READ_LE_UINT16(dataPtr); ptr->layersCount = READ_LE_UINT16(dataPtr);
dataPtr += 2; dataPtr += 2;
ptr->layers = ptr->layers =
(Scen_AnimLayer **) malloc(sizeof(Scen_AnimLayer *) * (AnimLayer **) malloc(sizeof(AnimLayer *) *
ptr->layersCount); ptr->layersCount);
ptr->pieces = ptr->pieces =
(Scen_PieceDesc **) malloc(sizeof(Scen_PieceDesc *) * (PieceDesc **) malloc(sizeof(PieceDesc *) *
picsCount); picsCount);
ptr->piecesFromExt = (int8 *) malloc(picsCount); ptr->piecesFromExt = (int8 *) malloc(picsCount);
for (i = 0; i < ptr->layersCount; i++) { for (i = 0; i < ptr->layersCount; i++) {
offset = (int16)READ_LE_UINT16(&((int16 *)dataPtr)[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]->unknown0 = (int16)READ_LE_UINT16(&ptr->layers[i]->unknown0);
ptr->layers[i]->posX = (int16)READ_LE_UINT16(&ptr->layers[i]->posX); 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++) { for (i = 0; i < picsCount; i++) {
pictDescId = inter_load16(); pictDescId = _vm->_inter->load16();
if (pictDescId >= 30000) { if (pictDescId >= 30000) {
ptr->pieces[i] = ptr->pieces[i] =
(Scen_PieceDesc *) game_loadExtData(pictDescId, 0, (PieceDesc *) _vm->_game->loadExtData(pictDescId, 0,
0); 0);
ptr->piecesFromExt[i] = 1; ptr->piecesFromExt[i] = 1;
} else { } else {
ptr->pieces[i] = ptr->pieces[i] =
(Scen_PieceDesc *) (PieceDesc *)
game_loadTotResource(pictDescId); _vm->_game->loadTotResource(pictDescId);
ptr->piecesFromExt[i] = 0; ptr->piecesFromExt[i] = 0;
} }
width = inter_load16(); width = _vm->_inter->load16();
height = inter_load16(); height = _vm->_inter->load16();
sprResId = inter_load16(); sprResId = _vm->_inter->load16();
for (sprIndex = 0; sprIndex < 20; sprIndex++) { for (sprIndex = 0; sprIndex < 20; sprIndex++) {
if (scen_spriteResId[sprIndex] == sprResId) if (spriteResId[sprIndex] == sprResId)
break; break;
} }
if (sprIndex < 20) { if (sprIndex < 20) {
scen_animPictToSprite[7 * sceneryIndex + i] = sprIndex; animPictToSprite[7 * sceneryIndex + i] = sprIndex;
scen_spriteRefs[sprIndex]++; spriteRefs[sprIndex]++;
} else { } else {
for (sprIndex = 19; draw_spritesArray[sprIndex] != 0; for (sprIndex = 19; _vm->_draw->spritesArray[sprIndex] != 0;
sprIndex--); sprIndex--);
scen_animPictToSprite[7 * sceneryIndex + i] = sprIndex; animPictToSprite[7 * sceneryIndex + i] = sprIndex;
scen_spriteRefs[sprIndex] = 1; spriteRefs[sprIndex] = 1;
scen_spriteResId[sprIndex] = sprResId; spriteResId[sprIndex] = sprResId;
draw_spritesArray[sprIndex] = _vm->_draw->spritesArray[sprIndex] =
vid_initSurfDesc(videoMode, width, height, 2); _vm->_video->initSurfDesc(_vm->_global->videoMode, width, height, 2);
vid_clearSurf(draw_spritesArray[sprIndex]); _vm->_video->clearSurf(_vm->_draw->spritesArray[sprIndex]);
draw_destSurface = sprIndex; _vm->_draw->destSurface = sprIndex;
draw_spriteLeft = sprResId; _vm->_draw->spriteLeft = sprResId;
draw_transparency = 0; _vm->_draw->transparency = 0;
draw_destSpriteX = 0; _vm->_draw->destSpriteX = 0;
draw_destSpriteY = 0; _vm->_draw->destSpriteY = 0;
draw_spriteOperation(DRAW_LOADSPRITE); _vm->_draw->spriteOperation(DRAW_LOADSPRITE);
} }
} }
return sceneryIndex + 100; return sceneryIndex + 100;
@ -500,11 +504,11 @@ int16 scen_loadAnim(char search) {
// flags & 4 == 0 - calculate animation final size // flags & 4 == 0 - calculate animation final size
// flags & 2 != 0 - don't check with "toRedraw"'s // flags & 2 != 0 - don't check with "toRedraw"'s
// flags & 4 != 0 - checkk view toRedraw // 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) { int16 drawDeltaX, int16 drawDeltaY, char doDraw) {
Scen_AnimLayer *layerPtr; AnimLayer *layerPtr;
Scen_PieceDesc **pictPtr; PieceDesc **pictPtr;
Scen_AnimFramePiece *framePtr; AnimFramePiece *framePtr;
uint16 pieceIndex; uint16 pieceIndex;
uint16 pictIndex; uint16 pictIndex;
@ -523,29 +527,29 @@ void scen_updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
int16 destX; int16 destX;
int16 destY; int16 destY;
if (layer >= scen_animations[animation].layersCount) if (layer >= animations[animation].layersCount)
return; return;
layerPtr = scen_animations[animation].layers[layer]; layerPtr = animations[animation].layers[layer];
if (frame >= layerPtr->framesCount) if (frame >= layerPtr->framesCount)
return; return;
if (flags & 1) // Do capture if (flags & 1) // Do capture
{ {
scen_updateAnim(layer, frame, animation, 0, drawDeltaX, updateAnim(layer, frame, animation, 0, drawDeltaX,
drawDeltaY, 0); drawDeltaY, 0);
if (scen_toRedrawLeft == -12345) // Some magic number? if (toRedrawLeft == -12345) // Some magic number?
return; return;
game_capturePush(scen_toRedrawLeft, scen_toRedrawTop, _vm->_game->capturePush(toRedrawLeft, toRedrawTop,
scen_toRedrawRight - scen_toRedrawLeft + 1, toRedrawRight - toRedrawLeft + 1,
scen_toRedrawBottom - scen_toRedrawTop + 1); toRedrawBottom - toRedrawTop + 1);
*scen_pCaptureCounter = *scen_pCaptureCounter + 1; *pCaptureCounter = *pCaptureCounter + 1;
} }
pictPtr = scen_animations[animation].pieces; pictPtr = animations[animation].pieces;
framePtr = layerPtr->frames; framePtr = layerPtr->frames;
for (i = 0; i < frame; i++, framePtr++) { 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) { if ((flags & 4) == 0) {
scen_toRedrawLeft = -12345; toRedrawLeft = -12345;
} else { } else {
scen_toRedrawLeft = toRedrawLeft =
MAX(scen_toRedrawLeft, anim_animAreaLeft); MAX(toRedrawLeft, _vm->_anim->_areaLeft);
scen_toRedrawTop = toRedrawTop =
MAX(scen_toRedrawTop, anim_animAreaTop); MAX(toRedrawTop, _vm->_anim->_areaTop);
scen_toRedrawRight = toRedrawRight =
MIN(scen_toRedrawRight, MIN(toRedrawRight,
(int16)(anim_animAreaLeft + anim_animAreaWidth - 1)); (int16)(_vm->_anim->_areaLeft + _vm->_anim->_areaWidth - 1));
scen_toRedrawBottom = toRedrawBottom =
MIN(scen_toRedrawBottom, MIN(toRedrawBottom,
(int16)(anim_animAreaTop + anim_animAreaHeight - 1)); (int16)(_vm->_anim->_areaTop + _vm->_anim->_areaHeight - 1));
} }
transp = layerPtr->transp ? 3 : 0; 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); bottom = FROM_LE_16(pictPtr[pictIndex][pieceIndex].bottom);
if (flags & 2) { if (flags & 2) {
if (destX < anim_animAreaLeft) { if (destX < _vm->_anim->_areaLeft) {
left += anim_animAreaLeft - destX; left += _vm->_anim->_areaLeft - destX;
destX = anim_animAreaLeft; destX = _vm->_anim->_areaLeft;
} }
if (left <= right if (left <= right
&& destX + right - left >= && destX + right - left >=
anim_animAreaLeft + anim_animAreaWidth) _vm->_anim->_areaLeft + _vm->_anim->_areaWidth)
right -= right -=
(destX + right - left) - (destX + right - left) -
(anim_animAreaLeft + anim_animAreaWidth) + (_vm->_anim->_areaLeft + _vm->_anim->_areaWidth) +
1; 1;
if (destY < anim_animAreaTop) { if (destY < _vm->_anim->_areaTop) {
top += anim_animAreaTop - destY; top += _vm->_anim->_areaTop - destY;
destY = anim_animAreaTop; destY = _vm->_anim->_areaTop;
} }
if (top <= bottom if (top <= bottom
&& destY + bottom - top >= && destY + bottom - top >=
anim_animAreaTop + anim_animAreaHeight) _vm->_anim->_areaTop + _vm->_anim->_areaHeight)
bottom -= bottom -=
(destY + bottom - top) - (destY + bottom - top) -
(anim_animAreaTop + anim_animAreaHeight) + (_vm->_anim->_areaTop + _vm->_anim->_areaHeight) +
1; 1;
} else if (flags & 4) { } else if (flags & 4) {
if (destX < scen_toRedrawLeft) { if (destX < toRedrawLeft) {
left += scen_toRedrawLeft - destX; left += toRedrawLeft - destX;
destX = scen_toRedrawLeft; destX = toRedrawLeft;
} }
if (left <= right if (left <= right
&& destX + right - left > scen_toRedrawRight) && destX + right - left > toRedrawRight)
right -= right -=
destX + right - left - scen_toRedrawRight; destX + right - left - toRedrawRight;
if (destY < scen_toRedrawTop) { if (destY < toRedrawTop) {
top += scen_toRedrawTop - destY; top += toRedrawTop - destY;
destY = scen_toRedrawTop; destY = toRedrawTop;
} }
if (top <= bottom if (top <= bottom
&& destY + bottom - top > scen_toRedrawBottom) && destY + bottom - top > toRedrawBottom)
bottom -= bottom -=
destY + bottom - top - scen_toRedrawBottom; destY + bottom - top - toRedrawBottom;
} }
if (left > right || top > bottom) if (left > right || top > bottom)
continue; continue;
if (doDraw) { if (doDraw) {
draw_sourceSurface = _vm->_draw->sourceSurface =
scen_animPictToSprite[animation * 7 + pictIndex]; animPictToSprite[animation * 7 + pictIndex];
draw_destSurface = 21; _vm->_draw->destSurface = 21;
draw_spriteLeft = left; _vm->_draw->spriteLeft = left;
draw_spriteTop = top; _vm->_draw->spriteTop = top;
draw_spriteRight = right - left + 1; _vm->_draw->spriteRight = right - left + 1;
draw_spriteBottom = bottom - top + 1; _vm->_draw->spriteBottom = bottom - top + 1;
draw_destSpriteX = destX; _vm->_draw->destSpriteX = destX;
draw_destSpriteY = destY; _vm->_draw->destSpriteY = destY;
draw_transparency = transp; _vm->_draw->transparency = transp;
draw_spriteOperation(DRAW_BLITSURF); _vm->_draw->spriteOperation(DRAW_BLITSURF);
} }
if ((flags & 4) == 0) { if ((flags & 4) == 0) {
if (scen_toRedrawLeft == -12345) { if (toRedrawLeft == -12345) {
scen_toRedrawLeft = destX; toRedrawLeft = destX;
scen_animLeft = destX; animLeft = destX;
scen_toRedrawTop = destY; toRedrawTop = destY;
scen_animTop = destY; animTop = destY;
scen_toRedrawRight = destX + right - left; toRedrawRight = destX + right - left;
scen_toRedrawBottom = destY + bottom - top; toRedrawBottom = destY + bottom - top;
} else { } else {
scen_toRedrawLeft = toRedrawLeft =
MIN(scen_toRedrawLeft, destX); MIN(toRedrawLeft, destX);
scen_toRedrawTop = toRedrawTop =
MIN(scen_toRedrawTop, destY); MIN(toRedrawTop, destY);
scen_toRedrawRight = toRedrawRight =
MAX(scen_toRedrawRight, MAX(toRedrawRight,
(int16)(destX + right - left)); (int16)(destX + right - left));
scen_toRedrawBottom = toRedrawBottom =
MAX(scen_toRedrawBottom, MAX(toRedrawBottom,
(int16)(destY + bottom - top)); (int16)(destY + bottom - top));
} }
} }
} while (framePtr->notFinal == 1); } while (framePtr->notFinal == 1);
} }
void scen_freeAnim(int16 animation) { void Scenery::freeAnim(int16 animation) {
int16 i; int16 i;
int16 spr; int16 spr;
if (animation == -1) if (animation == -1)
inter_evalExpr(&animation); _vm->_inter->evalExpr(&animation);
if (scen_animPictCount[animation] == 0) if (animPictCount[animation] == 0)
return; return;
for (i = 0; i < scen_animPictCount[animation]; i++) { for (i = 0; i < animPictCount[animation]; i++) {
if (scen_animations[animation].piecesFromExt[i] == 1) if (animations[animation].piecesFromExt[i] == 1)
free(scen_animations[animation].pieces[i]); free(animations[animation].pieces[i]);
spr = scen_animPictToSprite[animation * 7 + i]; spr = animPictToSprite[animation * 7 + i];
scen_spriteRefs[spr]--; spriteRefs[spr]--;
if (scen_spriteRefs[spr] == 0) { if (spriteRefs[spr] == 0) {
vid_freeSurfDesc(draw_spritesArray[spr]); _vm->_video->freeSurfDesc(_vm->_draw->spritesArray[spr]);
draw_spritesArray[spr] = 0; _vm->_draw->spritesArray[spr] = 0;
scen_spriteResId[spr] = -1; spriteResId[spr] = -1;
} }
} }
free(scen_animations[animation].layers); free(animations[animation].layers);
free(scen_animations[animation].pieces); free(animations[animation].pieces);
free(scen_animations[animation].piecesFromExt); free(animations[animation].piecesFromExt);
if (scen_animFromExt[animation] == 1) if (animFromExt[animation] == 1)
free(scen_animations[animation].dataPtr); free(animations[animation].dataPtr);
scen_animFromExt[animation] = 0; animFromExt[animation] = 0;
scen_animPictCount[animation] = 0; animPictCount[animation] = 0;
} }
void scen_interUpdateAnim(void) { void Scenery::interUpdateAnim(void) {
int16 deltaX; int16 deltaX;
int16 deltaY; int16 deltaY;
int16 flags; int16 flags;
@ -744,37 +748,37 @@ void scen_interUpdateAnim(void) {
int16 layer; int16 layer;
int16 animation; int16 animation;
inter_evalExpr(&deltaX); _vm->_inter->evalExpr(&deltaX);
inter_evalExpr(&deltaY); _vm->_inter->evalExpr(&deltaY);
inter_evalExpr(&animation); _vm->_inter->evalExpr(&animation);
inter_evalExpr(&layer); _vm->_inter->evalExpr(&layer);
inter_evalExpr(&frame); _vm->_inter->evalExpr(&frame);
flags = inter_load16(); flags = _vm->_inter->load16();
scen_updateAnim(layer, frame, animation, flags, deltaX, deltaY, 1); updateAnim(layer, frame, animation, flags, deltaX, deltaY, 1);
} }
void scen_interStoreParams(void) { void Scenery::interStoreParams(void) {
Scen_AnimLayer *layerPtr; AnimLayer *layerPtr;
int16 animation; int16 animation;
int16 layer; int16 layer;
int16 var; int16 var;
warning("scen_interStoreParams: Storing..."); warning("interStoreParams: Storing...");
inter_evalExpr(&animation); _vm->_inter->evalExpr(&animation);
inter_evalExpr(&layer); _vm->_inter->evalExpr(&layer);
layerPtr = scen_animations[animation].layers[layer]; layerPtr = animations[animation].layers[layer];
var = parse_parseVarIndex(); var = _vm->_parse->parseVarIndex();
WRITE_VAR_OFFSET(var, layerPtr->animDeltaX); WRITE_VAR_OFFSET(var, layerPtr->animDeltaX);
var = parse_parseVarIndex(); var = _vm->_parse->parseVarIndex();
WRITE_VAR_OFFSET(var, layerPtr->animDeltaY); WRITE_VAR_OFFSET(var, layerPtr->animDeltaY);
var = parse_parseVarIndex(); var = _vm->_parse->parseVarIndex();
WRITE_VAR_OFFSET(var, layerPtr->unknown0); WRITE_VAR_OFFSET(var, layerPtr->unknown0);
var = parse_parseVarIndex(); var = _vm->_parse->parseVarIndex();
WRITE_VAR_OFFSET(var, layerPtr->framesCount); WRITE_VAR_OFFSET(var, layerPtr->framesCount);
} }

114
gob/scenery.h
View file

@ -24,40 +24,42 @@
namespace Gob { namespace Gob {
class Scenery {
public:
#pragma START_PACK_STRUCTS #pragma START_PACK_STRUCTS
typedef struct Scen_PieceDesc { typedef struct PieceDesc {
int16 left; //NOTE: int16 left; //NOTE:
int16 right; //These are stored in Little Endian format int16 right; //These are stored in Little Endian format
int16 top; //And should be converted by client code when accessed int16 top; //And should be converted by client code when accessed
int16 bottom; //i.e. use FROM_LE_16() int16 bottom; //i.e. use FROM_LE_16()
} GCC_PACK Scen_PieceDesc; } GCC_PACK PieceDesc;
typedef struct Scen_StaticPlane { typedef struct StaticPlane {
int8 pictIndex; int8 pictIndex;
int8 pieceIndex; int8 pieceIndex;
int8 drawOrder; int8 drawOrder;
int16 destX; int16 destX;
int16 destY; int16 destY;
int8 transp; int8 transp;
} GCC_PACK Scen_StaticPlane; } GCC_PACK StaticPlane;
typedef struct Scen_StaticLayer { typedef struct StaticLayer {
int16 backResId; int16 backResId;
int16 planeCount; int16 planeCount;
Scen_StaticPlane planes[1]; StaticPlane planes[1];
} GCC_PACK Scen_StaticLayer; } GCC_PACK StaticLayer;
// Animations // Animations
typedef struct Scen_AnimFramePiece { typedef struct AnimFramePiece {
byte pictIndex; byte pictIndex;
byte pieceIndex; byte pieceIndex;
int8 destX; int8 destX;
int8 destY; int8 destY;
int8 notFinal; int8 notFinal;
} GCC_PACK Scen_AnimFramePiece; } GCC_PACK AnimFramePiece;
typedef struct Scen_AnimLayer { typedef struct AnimLayer {
int16 unknown0; int16 unknown0;
int16 posX; int16 posX;
int16 posY; int16 posY;
@ -65,70 +67,80 @@ typedef struct Scen_AnimLayer {
int16 animDeltaY; int16 animDeltaY;
int8 transp; int8 transp;
int16 framesCount; int16 framesCount;
Scen_AnimFramePiece frames[1]; AnimFramePiece frames[1];
} GCC_PACK Scen_AnimLayer; } GCC_PACK AnimLayer;
#pragma END_PACK_STRUCTS #pragma END_PACK_STRUCTS
typedef struct Scen_Static { typedef struct Static {
int16 layersCount; int16 layersCount;
Scen_StaticLayer **layers; StaticLayer **layers;
Scen_PieceDesc **pieces; PieceDesc **pieces;
int8 *piecesFromExt; int8 *piecesFromExt;
char *dataPtr; char *dataPtr;
} Scen_Static; Static() : layersCount(0), layers(0), pieces(0),
piecesFromExt(0), dataPtr(0) {}
} Static;
struct Scen_Animation { struct Animation {
int16 layersCount; int16 layersCount;
Scen_AnimLayer **layers; AnimLayer **layers;
Scen_PieceDesc **pieces; PieceDesc **pieces;
int8 *piecesFromExt; int8 *piecesFromExt;
char *dataPtr; char *dataPtr;
Animation() : layersCount(0), layers(0), pieces(0),
piecesFromExt(0), dataPtr(0) {}
}; };
// Global variables // Global variables
extern char scen_spriteRefs[20]; char spriteRefs[20];
extern int16 scen_spriteResId[20]; int16 spriteResId[20];
extern char scen_staticPictToSprite[70]; char staticPictToSprite[70];
extern int16 scen_staticPictCount[10]; int16 staticPictCount[10];
extern Scen_Static scen_statics[10]; Static statics[10];
extern char scen_staticFromExt[10]; char staticFromExt[10];
extern int16 scen_staticResId[10]; int16 staticResId[10];
extern char scen_animPictToSprite[70]; char animPictToSprite[70];
extern int16 scen_animPictCount[10]; int16 animPictCount[10];
extern char scen_animFromExt[10]; char animFromExt[10];
extern Scen_Animation scen_animations[10]; Animation animations[10];
extern int16 scen_animResId[10]; int16 animResId[10];
extern int16 scen_curStatic; int16 curStatic;
extern int16 scen_curStaticLayer; int16 curStaticLayer;
extern int16 scen_toRedrawLeft; int16 toRedrawLeft;
extern int16 scen_toRedrawRight; int16 toRedrawRight;
extern int16 scen_toRedrawTop; int16 toRedrawTop;
extern int16 scen_toRedrawBottom; int16 toRedrawBottom;
extern int16 scen_animTop; int16 animTop;
extern int16 scen_animLeft; int16 animLeft;
extern int16 *scen_pCaptureCounter; int16 *pCaptureCounter;
// Functions // Functions
int16 scen_loadStatic(char search); int16 loadStatic(char search);
void scen_freeStatic(int16 index); void freeStatic(int16 index);
void scen_renderStatic(int16 scenery, int16 layer); void renderStatic(int16 scenery, int16 layer);
void scen_interRenderStatic(void); void interRenderStatic(void);
void scen_interLoadCurLayer(void); void interLoadCurLayer(void);
void scen_updateStatic(int16 orderFrom); void updateStatic(int16 orderFrom);
int16 scen_loadAnim(char search); int16 loadAnim(char search);
void scen_updateAnim(int16 layer, int16 frame, int16 animation, int16 flags, void updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
int16 drawDeltaX, int16 drawDeltaY, char doDraw); int16 drawDeltaX, int16 drawDeltaY, char doDraw);
void scen_freeAnim(int16 animation); void freeAnim(int16 animation);
void scen_interUpdateAnim(void); void interUpdateAnim(void);
void scen_interStoreParams(void); void interStoreParams(void);
Scenery(GobEngine *vm);
protected:
GobEngine *_vm;
};
} // End of namespace Gob } // End of namespace Gob

107
gob/sound.cpp
View file

@ -20,41 +20,14 @@
* *
*/ */
#include "sound/audiostream.h"
#include "gob/gob.h" #include "gob/gob.h"
#include "gob/global.h" #include "gob/global.h"
#include "gob/sound.h" #include "gob/sound.h"
namespace Gob { namespace Gob {
// TODO: This is a very primitive square wave generator. The only thing is void Snd::SquareWaveStream::playNote(int freq, int32 ms, uint rate) {
// has in common with the PC speaker is that it sounds terrible. _rate = rate;
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();
_periodLength = _rate / (2 * freq); _periodLength = _rate / (2 * freq);
_periodSamples = 0; _periodSamples = 0;
_sampleValue = 6000; _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; int samples = 0;
while (samples < numSamples && _remainingSamples > 0) { while (samples < numSamples && _remainingSamples > 0) {
@ -84,48 +57,42 @@ int SquareWaveStream::readBuffer(int16 *buffer, const int numSamples) {
return samples; return samples;
} }
SquareWaveStream speakerStream; Snd::Snd(GobEngine *vm) : _vm(vm) {
Audio::SoundHandle speakerHandle; //CleanupFuncPtr cleanupFunc;// = &snd_cleanupFuncCallback();
Snd_SoundDesc *snd_loopingSounds[5]; // Should be enough cleanupFunc = 0;
for (int i = 0; i < ARRAYSIZE(loopingSounds); i++)
void snd_initSound(void) { loopingSounds[i] = NULL;
for (int i = 0; i < ARRAYSIZE(snd_loopingSounds); i++) soundPort = 0;
snd_loopingSounds[i] = NULL; playingSound = 0;
} }
void snd_loopSounds(void) { void Snd::loopSounds(void) {
for (int i = 0; i < ARRAYSIZE(snd_loopingSounds); i++) { for (int i = 0; i < ARRAYSIZE(loopingSounds); i++) {
Snd_SoundDesc *snd = snd_loopingSounds[i]; SoundDesc *snd = loopingSounds[i];
if (snd && !_vm->_mixer->isSoundHandleActive(snd->handle)) { if (snd && !_vm->_mixer->isSoundHandleActive(snd->handle)) {
if (snd->repCount-- > 0) { if (snd->repCount-- > 0) {
_vm->_mixer->playRaw(&snd->handle, snd->data, snd->size, snd->frequency, 0); _vm->_mixer->playRaw(&snd->handle, snd->data, snd->size, snd->frequency, 0);
} else { } else {
snd_loopingSounds[i] = NULL; loopingSounds[i] = NULL;
} }
} }
} }
} }
int16 snd_checkProAudio(void) {return 0;} void Snd::setBlasterPort(int16 port) {return;}
int16 snd_checkAdlib(void) {return 0;}
int16 snd_checkBlaster(void) {return 0;}
void snd_setBlasterPort(int16 port) {return;}
void snd_speakerOn(int16 frequency, int32 length) { void Snd::speakerOn(int16 frequency, int32 length) {
speakerStream.playNote(frequency, length); speakerStream.playNote(frequency, length, _vm->_mixer->getOutputRate());
if (!_vm->_mixer->isSoundHandleActive(speakerHandle)) { if (!_vm->_mixer->isSoundHandleActive(speakerHandle)) {
_vm->_mixer->playInputStream(Audio::Mixer::kSFXSoundType, &speakerHandle, &speakerStream, -1, 255, 0, false); _vm->_mixer->playInputStream(Audio::Mixer::kSFXSoundType, &speakerHandle, &speakerStream, -1, 255, 0, false);
} }
} }
void snd_speakerOff(void) { void Snd::speakerOff(void) {
_vm->_mixer->stopHandle(speakerHandle); _vm->_mixer->stopHandle(speakerHandle);
} }
void snd_stopSound(int16 arg){return;} void Snd::playSample(Snd::SoundDesc *sndDesc, int16 repCount, int16 frequency) {
void snd_setResetTimerFlag(char flag){return;}
void snd_playSample(Snd_SoundDesc *sndDesc, int16 repCount, int16 frequency) {
assert(frequency > 0); assert(frequency > 0);
if (!_vm->_mixer->isSoundHandleActive(sndDesc->handle)) { if (!_vm->_mixer->isSoundHandleActive(sndDesc->handle)) {
@ -136,9 +103,9 @@ void snd_playSample(Snd_SoundDesc *sndDesc, int16 repCount, int16 frequency) {
sndDesc->frequency = frequency; sndDesc->frequency = frequency;
if (repCount > 1) { if (repCount > 1) {
for (int i = 0; i < ARRAYSIZE(snd_loopingSounds); i++) { for (int i = 0; i < ARRAYSIZE(loopingSounds); i++) {
if (!snd_loopingSounds[i]) { if (!loopingSounds[i]) {
snd_loopingSounds[i] = sndDesc; loopingSounds[i] = sndDesc;
return; return;
} }
} }
@ -146,44 +113,34 @@ void snd_playSample(Snd_SoundDesc *sndDesc, int16 repCount, int16 frequency) {
} }
} }
void snd_cleanupFuncCallback() {;} void Snd::writeAdlib(int16 port, int16 data) {
CleanupFuncPtr (snd_cleanupFunc);
//CleanupFuncPtr snd_cleanupFunc;// = &snd_cleanupFuncCallback();
int16 snd_soundPort;
char snd_playingSound;
void snd_writeAdlib(int16 port, int16 data) {
return; return;
} }
Snd_SoundDesc *snd_loadSoundData(const char *path) { Snd::SoundDesc *Snd::loadSoundData(const char *path) {
Snd_SoundDesc *sndDesc; Snd::SoundDesc *sndDesc;
int32 size; int32 size;
size = data_getDataSize(path); size = _vm->_dataio->getDataSize(path);
sndDesc = (Snd_SoundDesc *)malloc(size); sndDesc = (Snd::SoundDesc *)malloc(size);
sndDesc->size = size; sndDesc->size = size;
sndDesc->data = data_getData(path); sndDesc->data = _vm->_dataio->getData(path);
return sndDesc; return sndDesc;
} }
void snd_freeSoundData(Snd_SoundDesc *sndDesc) { void Snd::freeSoundData(Snd::SoundDesc *sndDesc) {
_vm->_mixer->stopHandle(sndDesc->handle); _vm->_mixer->stopHandle(sndDesc->handle);
for (int i = 0; i < ARRAYSIZE(snd_loopingSounds); i++) { for (int i = 0; i < ARRAYSIZE(loopingSounds); i++) {
if (snd_loopingSounds[i] == sndDesc) if (loopingSounds[i] == sndDesc)
snd_loopingSounds[i] = NULL; loopingSounds[i] = NULL;
} }
free(sndDesc->data); free(sndDesc->data);
free(sndDesc); free(sndDesc);
} }
void snd_playComposition(Snd_SoundDesc ** samples, int16 *composit, int16 freqVal) {;}
void snd_waitEndPlay(void) {;}
} // End of namespace Gob } // End of namespace Gob

91
gob/sound.h
View file

@ -22,28 +22,13 @@
#ifndef GOB_SOUND_H #ifndef GOB_SOUND_H
#define GOB_SOUND_H #define GOB_SOUND_H
#include "sound/audiostream.h"
namespace Gob { namespace Gob {
void snd_initSound(void); class Snd {
void snd_loopSounds(void); public:
int16 snd_checkProAudio(void); typedef struct SoundDesc {
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; Audio::SoundHandle handle;
char *data; char *data;
int32 size; int32 size;
@ -52,13 +37,67 @@ typedef struct Snd_SoundDesc {
int16 inClocks; int16 inClocks;
int16 frequency; int16 frequency;
int16 flag; int16 flag;
} Snd_SoundDesc; SoundDesc() : data(0), size(0), repCount(0), timerTicks(0),
inClocks(0), frequency(0), flag(0) {}
} SoundDesc;
void snd_playSample(Snd_SoundDesc *sndDesc, int16 repCount, int16 frequency); typedef void (*CleanupFuncPtr) (int16);
Snd_SoundDesc *snd_loadSoundData(const char *path);
void snd_freeSoundData(Snd_SoundDesc *sndDesc); SoundDesc *loopingSounds[5]; // Should be enough
void snd_playComposition(Snd_SoundDesc **samples, int16 *composit, int16 freqVal); int16 soundPort;
void snd_waitEndPlay(void); 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 } // End of namespace Gob

10
gob/timer.cpp
View file

@ -22,13 +22,15 @@
#include "gob/gob.h" #include "gob/gob.h"
#include "gob/global.h" #include "gob/global.h"
#include "gob/sound.h" #include "gob/sound.h"
#include "gob/timer.h"
namespace Gob { namespace Gob {
void timer_enableTimer() { void GTimer::enableTimer() {
debug(4, "STUB: timer_enableTimer()"); debug(4, "STUB: GTimer::enableTimer()");
} }
void timer_disableTimer() { void GTimer::disableTimer() {
debug(4, "STUB: timer_disableTimer()"); debug(4, "STUB: GTimer::disableTimer()");
} }
} }

17
gob/timer.h
View file

@ -24,15 +24,18 @@
namespace Gob { namespace Gob {
class GTimer {
public:
typedef void (* TickHandler) (void); typedef void (* TickHandler) (void);
void timer_enableTimer(void); void enableTimer(void);
void timer_disableTimer(void); void disableTimer(void);
void timer_setHandler(void); void setHandler(void);
void timer_restoreHandler(void); void restoreHandler(void);
void timer_addTicks(int16 ticks); void addTicks(int16 ticks);
void timer_setTickHandler(TickHandler handler); void setTickHandler(TickHandler handler);
int32 timer_getTicks(void); int32 getTicks(void);
};
} // End of namespace Gob } // End of namespace Gob

198
gob/util.cpp
View file

@ -28,47 +28,52 @@
namespace Gob { namespace Gob {
static const int kKeyBufSize = 16; 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;
}
static int16 _mouseX, _mouseY, _mouseButtons; void Util::addKeyToBuffer(int16 key) {
static int16 _keyBuffer[kKeyBufSize], _keyBufferHead, _keyBufferTail; if ((_keyBufferHead + 1) % KEYBUFSIZE == _keyBufferTail) {
static void addKeyToBuffer(int16 key) {
if ((_keyBufferHead + 1) % kKeyBufSize == _keyBufferTail) {
warning("key buffer overflow!"); warning("key buffer overflow!");
return; return;
} }
_keyBuffer[_keyBufferHead] = key; _keyBuffer[_keyBufferHead] = key;
_keyBufferHead = (_keyBufferHead + 1) % kKeyBufSize; _keyBufferHead = (_keyBufferHead + 1) % KEYBUFSIZE;
} }
static bool keyBufferEmpty() { bool Util::keyBufferEmpty() {
return (_keyBufferHead == _keyBufferTail); return (_keyBufferHead == _keyBufferTail);
} }
static bool getKeyFromBuffer(int16& key) { bool Util::getKeyFromBuffer(int16& key) {
if (_keyBufferHead == _keyBufferTail) return false; if (_keyBufferHead == _keyBufferTail) return false;
key = _keyBuffer[_keyBufferTail]; key = _keyBuffer[_keyBufferTail];
_keyBufferTail = (_keyBufferTail + 1) % kKeyBufSize; _keyBufferTail = (_keyBufferTail + 1) % KEYBUFSIZE;
return true; return true;
} }
void util_initInput(void) { void Util::initInput(void) {
_mouseX = _mouseY = _mouseButtons = 0; _mouseX = _mouseY = _mouseButtons = 0;
_keyBufferHead = _keyBufferTail = 0; _keyBufferHead = _keyBufferTail = 0;
} }
void util_waitKey(void) { void Util::waitKey(void) {
// FIXME: wrong function name? This functions clears the keyboard buffer. // FIXME: wrong function name? This functions clears the keyboard buffer.
util_processInput(); processInput();
_keyBufferHead = _keyBufferTail = 0; _keyBufferHead = _keyBufferTail = 0;
} }
int16 util_translateKey(int16 key) { int16 Util::translateKey(int16 key) {
struct keyS { struct keyS {
int16 from; int16 from;
int16 to; int16 to;
@ -104,32 +109,32 @@ int16 util_translateKey(int16 key) {
return key; return key;
} }
int16 util_getKey(void) { int16 Util::getKey(void) {
int16 key; int16 key;
while (!getKeyFromBuffer(key)) { while (!getKeyFromBuffer(key)) {
util_processInput(); processInput();
if (keyBufferEmpty()) if (keyBufferEmpty())
g_system->delayMillis(10); g_system->delayMillis(10);
} }
return util_translateKey(key); return translateKey(key);
} }
int16 util_checkKey(void) { int16 Util::checkKey(void) {
int16 key; int16 key;
if (!getKeyFromBuffer(key)) if (!getKeyFromBuffer(key))
key = 0; 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); return _vm->_rnd.getRandomNumber(max - 1);
} }
void util_processInput() { void Util::processInput() {
OSystem::Event event; OSystem::Event event;
while (g_system->pollEvent(event)) { while (g_system->pollEvent(event)) {
switch (event.type) { 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; *pX = _mouseX;
*pY = _mouseY; *pY = _mouseY;
@ -171,91 +176,90 @@ void util_getMouseState(int16 *pX, int16 *pY, int16 *pButtons) {
*pButtons = _mouseButtons; *pButtons = _mouseButtons;
} }
void util_setMousePos(int16 x, int16 y) { void Util::setMousePos(int16 x, int16 y) {
g_system->warpMouse(x, y); g_system->warpMouse(x, y);
} }
void util_longDelay(uint16 msecs) void Util::longDelay(uint16 msecs) {
{
uint32 time = g_system->getMillis() + msecs; uint32 time = g_system->getMillis() + msecs;
do { do {
vid_waitRetrace(videoMode); _vm->_video->waitRetrace(_vm->_global->videoMode);
util_processInput(); processInput();
util_delay(25); delay(25);
} while (g_system->getMillis() < time); } while (g_system->getMillis() < time);
} }
void util_delay(uint16 msecs) { void Util::delay(uint16 msecs) {
g_system->delayMillis(msecs); g_system->delayMillis(msecs);
} }
void util_beep(int16 freq) { void Util::beep(int16 freq) {
if (soundFlags == 0) if (_vm->_global->soundFlags == 0)
return; return;
snd_speakerOn(freq, 50); _vm->_snd->speakerOn(freq, 50);
} }
uint32 util_getTimeKey(void) { uint32 Util::getTimeKey(void) {
return g_system->getMillis(); return g_system->getMillis();
} }
void util_waitMouseUp(void) { void Util::waitMouseUp(void) {
int16 x; int16 x;
int16 y; int16 y;
int16 buttons; int16 buttons;
do { do {
util_processInput(); processInput();
util_getMouseState(&x, &y, &buttons); getMouseState(&x, &y, &buttons);
if (buttons != 0) util_delay(10); if (buttons != 0) delay(10);
} while (buttons != 0); } while (buttons != 0);
} }
void util_waitMouseDown(void) { void Util::waitMouseDown(void) {
int16 x; int16 x;
int16 y; int16 y;
int16 buttons; int16 buttons;
do { do {
util_processInput(); processInput();
util_getMouseState(&x, &y, &buttons); getMouseState(&x, &y, &buttons);
if (buttons == 0) util_delay(10); if (buttons == 0) delay(10);
} while (buttons == 0); } while (buttons == 0);
} }
/* NOT IMPLEMENTED */ /* NOT IMPLEMENTED */
int16 util_calcDelayTime() { int16 Util::calcDelayTime() {
return 0; return 0;
} }
/* NOT IMPLEMENTED */ /* NOT IMPLEMENTED */
void util_checkJoystick() { void Util::checkJoystick() {
useJoystick = 0; _vm->_global->useJoystick = 0;
} }
void util_setFrameRate(int16 rate) { void Util::setFrameRate(int16 rate) {
if (rate == 0) if (rate == 0)
rate = 1; rate = 1;
frameWaitTime = 1000 / rate; _vm->_global->frameWaitTime = 1000 / rate;
startFrameTime = util_getTimeKey(); _vm->_global->startFrameTime = getTimeKey();
} }
void util_waitEndFrame() { void Util::waitEndFrame() {
int32 time; 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) { if (time > 1000 || time < 0) {
startFrameTime = util_getTimeKey(); _vm->_global->startFrameTime = getTimeKey();
return; return;
} }
if (frameWaitTime - time > 0) { if (_vm->_global->frameWaitTime - time > 0) {
util_delay(frameWaitTime - time); delay(_vm->_global->frameWaitTime - time);
} }
startFrameTime = util_getTimeKey(); _vm->_global->startFrameTime = getTimeKey();
} }
int16 joy_getState() { int16 joy_getState() {
@ -266,14 +270,14 @@ int16 joy_calibrate() {
return 0; return 0;
} }
FontDesc *util_loadFont(const char *path) { Video::FontDesc *Util::loadFont(const char *path) {
FontDesc *fontDesc = (FontDesc *) malloc(sizeof(FontDesc)); Video::FontDesc *fontDesc = (Video::FontDesc *) malloc(sizeof(Video::FontDesc));
char *data; char *data;
if (fontDesc == 0) if (fontDesc == 0)
return 0; return 0;
data = data_getData(path); data = _vm->_dataio->getData(path);
if (data == 0) { if (data == 0) {
free(fontDesc); free(fontDesc);
return 0; return 0;
@ -298,20 +302,20 @@ FontDesc *util_loadFont(const char *path) {
return fontDesc; return fontDesc;
} }
void util_freeFont(FontDesc * fontDesc) { void Util::freeFont(Video::FontDesc * fontDesc) {
free(fontDesc->dataPtr - 4); free(fontDesc->dataPtr - 4);
free(fontDesc); free(fontDesc);
} }
void util_clearPalette(void) { void Util::clearPalette(void) {
int16 i; int16 i;
byte colors[768]; byte colors[768];
if (videoMode != 0x13) if (_vm->_global->videoMode != 0x13)
error("util_clearPalette: Video mode 0x%x is not supported!", error("clearPalette: Video mode 0x%x is not supported!",
videoMode); _vm->_global->videoMode);
if (setAllPalette) { if (_vm->_global->setAllPalette) {
for (i = 0; i < 768; i++) for (i = 0; i < 768; i++)
colors[i] = 0; colors[i] = 0;
g_system->setPalette(colors, 0, 256); g_system->setPalette(colors, 0, 256);
@ -320,10 +324,10 @@ void util_clearPalette(void) {
} }
for (i = 0; i < 16; i++) 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 len1;
int16 i; int16 i;
int16 from; int16 from;
@ -342,11 +346,11 @@ void util_insertStr(const char *str1, char *str2, int16 pos) {
str2[i + from] = str1[i]; 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 len;
int16 i; int16 i;
//log_write("util_cutFromStr: str = %s, ", str); //log_write("cutFromStr: str = %s, ", str);
len = strlen(str); len = strlen(str);
if (from >= len) if (from >= len)
return; return;
@ -364,12 +368,12 @@ void util_cutFromStr(char *str, int16 from, int16 cutlen) {
//log_write("res = %s\n", str); //log_write("res = %s\n", str);
} }
int16 util_strstr(const char *str1, char *str2) { int16 Util::strstr(const char *str1, char *str2) {
char c; char c;
uint16 len1; uint16 len1;
uint16 i; 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++) { for (i = 0, len1 = strlen(str1); strlen(str2 + i) >= len1; i++) {
c = str2[i + len1]; c = str2[i + len1];
@ -383,10 +387,10 @@ int16 util_strstr(const char *str1, char *str2) {
return 0; return 0;
} }
void util_listInsertFront(Util_List * list, void *data) { void Util::listInsertFront(List * list, void *data) {
Util_ListNode *node; ListNode *node;
node = (Util_ListNode *) malloc(sizeof(Util_ListNode)); node = (ListNode *) malloc(sizeof(ListNode));
if (list->pHead != 0) { if (list->pHead != 0) {
node->pData = data; node->pData = data;
node->pNext = list->pHead; node->pNext = list->pHead;
@ -402,28 +406,28 @@ void util_listInsertFront(Util_List * list, void *data) {
} }
} }
void util_listInsertBack(Util_List * list, void *data) { void Util::listInsertBack(List * list, void *data) {
Util_ListNode *node; ListNode *node;
if (list->pHead != 0) { if (list->pHead != 0) {
if (list->pTail == 0) { if (list->pTail == 0) {
list->pTail = list->pHead; list->pTail = list->pHead;
warning("util_listInsertBack: Broken list!"); warning("listInsertBack: Broken list!");
} }
node = node =
(Util_ListNode *) malloc(sizeof(Util_ListNode)); (ListNode *) malloc(sizeof(ListNode));
node->pData = data; node->pData = data;
node->pPrev = list->pTail; node->pPrev = list->pTail;
node->pNext = 0; node->pNext = 0;
list->pTail->pNext = node; list->pTail->pNext = node;
list->pTail = node; list->pTail = node;
} else { } else {
util_listInsertFront(list, data); listInsertFront(list, data);
} }
} }
void util_listDropFront(Util_List * list) { void Util::listDropFront(List * list) {
if (list->pHead->pNext == 0) { if (list->pHead->pNext == 0) {
free((list->pHead)); free((list->pHead));
list->pHead = 0; 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) { while (list->pHead != 0) {
util_listDropFront(list); listDropFront(list);
} }
free(list); free(list);
} }
char util_str1[] = const char Util::trStr1[] =
" ' + - :0123456789: <=> abcdefghijklmnopqrstuvwxyz abcdefghijklmnopqrstuvwxyz "; " ' + - :0123456789: <=> abcdefghijklmnopqrstuvwxyz abcdefghijklmnopqrstuvwxyz ";
char util_str2[] = const char Util::trStr2[] =
" ueaaaaceeeiii ooouu aioun "; " ueaaaaceeeiii ooouu aioun ";
char util_str3[] = " "; const char Util::trStr3[] = " ";
void util_prepareStr(char *str) { void Util::prepareStr(char *str) {
uint16 i; uint16 i;
int16 j; int16 j;
char buf[300]; char buf[300];
strcpy(buf, util_str1); strcpy(buf, trStr1);
strcat(buf, util_str2); strcat(buf, trStr2);
strcat(buf, util_str3); strcat(buf, trStr3);
for (i = 0; i < strlen(str); i++) for (i = 0; i < strlen(str); i++)
str[i] = buf[str[i] - 32]; str[i] = buf[str[i] - 32];
while (str[0] == ' ') while (str[0] == ' ')
util_cutFromStr(str, 0, 1); cutFromStr(str, 0, 1);
while (strlen(str) > 0 && str[strlen(str) - 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) { while (1) {
if (i == 0) if (i == 0)
return; return;
if (str[i] == ' ') { if (str[i] == ' ') {
util_cutFromStr(str, i - 1, 1); cutFromStr(str, i - 1, 1);
continue; continue;
} }
j = util_strstr(" ", str + i); j = strstr(" ", str + i);
if (j != 0) if (j != 0)
i += j; i += j;
else else
@ -486,18 +490,18 @@ void util_prepareStr(char *str) {
} }
} }
void util_waitMouseRelease(char drawMouse) { void Util::waitMouseRelease(char drawMouse) {
int16 buttons; int16 buttons;
int16 mouseX; int16 mouseX;
int16 mouseY; int16 mouseY;
do { do {
game_checkKeys(&mouseX, &mouseY, &buttons, drawMouse); _vm->_game->checkKeys(&mouseX, &mouseY, &buttons, drawMouse);
if (drawMouse != 0) if (drawMouse != 0)
draw_animateCursor(2); _vm->_draw->animateCursor(2);
util_delay(10); delay(10);
} while (buttons != 0); } while (buttons != 0);
} }
void keyboard_release(void) {;} void Util::keyboard_release(void) {;}
} // End of namespace Gob } // End of namespace Gob

99
gob/util.h
View file

@ -26,57 +26,80 @@
namespace Gob { namespace Gob {
struct Util_ListNode; #define KEYBUFSIZE 16
typedef struct Util_ListNode {
class Util {
public:
struct ListNode;
typedef struct ListNode {
void *pData; void *pData;
struct Util_ListNode *pNext; struct ListNode *pNext;
struct Util_ListNode *pPrev; struct ListNode *pPrev;
} Util_ListNode; ListNode() : pData(0), pNext(0), pPrev(0) {}
} ListNode;
typedef struct Util_List { typedef struct List {
Util_ListNode *pHead; ListNode *pHead;
Util_ListNode *pTail; ListNode *pTail;
} Util_List; List() : pHead(0), pTail(0) {}
} List;
void util_initInput(void); void initInput(void);
void util_processInput(void); void processInput(void);
void util_waitKey(void); void waitKey(void);
int16 util_getKey(void); int16 getKey(void);
int16 util_checkKey(void); int16 checkKey(void);
int16 util_getRandom(int16 max); int16 getRandom(int16 max);
void util_getMouseState(int16 *pX, int16 *pY, int16 *pButtons); void getMouseState(int16 *pX, int16 *pY, int16 *pButtons);
void util_setMousePos(int16 x, int16 y); void setMousePos(int16 x, int16 y);
void util_longDelay(uint16 msecs); void longDelay(uint16 msecs);
void util_delay(uint16 msecs); void delay(uint16 msecs);
void util_beep(int16 freq); void beep(int16 freq);
uint32 util_getTimeKey(void); uint32 getTimeKey(void);
void util_waitMouseUp(void); void waitMouseUp(void);
void util_waitMouseDown(void); void waitMouseDown(void);
void keyboard_init(void); void keyboard_init(void);
void keyboard_release(void); void keyboard_release(void);
void util_clearPalette(void); void clearPalette(void);
void asm_setPaletteBlock(char *tmpPalBuffer, int16 start, int16 end); void asm_setPaletteBlock(char *tmpPalBuffer, int16 start, int16 end);
void vid_waitRetrace(int16 mode); void vid_waitRetrace(int16 mode);
FontDesc *util_loadFont(const char *path); Video::FontDesc *loadFont(const char *path);
void util_freeFont(FontDesc * fontDesc); void freeFont(Video::FontDesc * fontDesc);
void util_clearPalette(void); void insertStr(const char *str1, char *str2, int16 pos);
void util_insertStr(const char *str1, char *str2, int16 pos); void cutFromStr(char *str, int16 from, int16 cutlen);
void util_cutFromStr(char *str, int16 from, int16 cutlen); int16 strstr(const char *str1, char *str2);
int16 util_strstr(const char *str1, char *str2); void waitEndFrame();
void util_waitEndFrame(); void setFrameRate(int16 rate);
void util_setFrameRate(int16 rate);
void util_listInsertBack(Util_List * list, void *data); void listInsertBack(List * list, void *data);
void util_listInsertFront(Util_List * list, void *data); void listInsertFront(List * list, void *data);
void util_listDropFront(Util_List * list); void listDropFront(List * list);
void util_deleteList(Util_List * list); void deleteList(List * list);
void util_prepareStr(char *str); void prepareStr(char *str);
void util_waitMouseRelease(char drawMouse); 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 } // End of namespace Gob

162
gob/video.cpp
View file

@ -28,22 +28,22 @@
namespace Gob { namespace Gob {
VideoDriver *_videoDriver;
/* NOT IMPLEMENTED */ /* NOT IMPLEMENTED */
Video::Video(GobEngine *vm) : _vm(vm) {
}
//XXX: Use this function to update the screen for now. //XXX: Use this function to update the screen for now.
// This should be moved to a better location later on. // This should be moved to a better location later on.
void vid_waitRetrace(int16) { void Video::waitRetrace(int16) {
if (pPrimarySurfDesc) { if (_vm->_global->pPrimarySurfDesc) {
g_system->copyRectToScreen(pPrimarySurfDesc->vidPtr, 320, 0, 0, 320, 200); g_system->copyRectToScreen(_vm->_global->pPrimarySurfDesc->vidPtr, 320, 0, 0, 320, 200);
g_system->updateScreen(); g_system->updateScreen();
} }
} }
char vid_initDriver(int16 vidMode) { char Video::initDriver(int16 vidMode) {
warning("STUB: vid_initDriver"); warning("STUB: Video::initDriver");
// FIXME: Finish all this stuff :) // FIXME: Finish all this stuff :)
_videoDriver = new VGAVideoDriver(); _videoDriver = new VGAVideoDriver();
@ -51,17 +51,17 @@ char vid_initDriver(int16 vidMode) {
return 1; return 1;
} }
void vid_freeDriver() { void Video::freeDriver() {
delete _videoDriver; 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; int32 size;
if ((mode & 0x7f) != 0x13) if ((mode & 0x7f) != 0x13)
warning warning
("vid_getRectSize: Video mode %d is not fully supported!", ("Video::getRectSize: Video mode %d is not fully supported!",
mode & 0x7f); mode & 0x7f);
switch (mode & 0x7f) { switch (mode & 0x7f) {
case 5: case 5:
@ -83,7 +83,7 @@ int32 vid_getRectSize(int16 width, int16 height, int16 flag, int16 mode) {
return size; 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; int8 flagsAnd2;
byte *vidMem; byte *vidMem;
int32 sprSize; int32 sprSize;
@ -91,13 +91,13 @@ SurfaceDesc *vid_initSurfDesc(int16 vidMode, int16 width, int16 height, int16 fl
SurfaceDesc *descPtr; SurfaceDesc *descPtr;
if (flags != PRIMARY_SURFACE) if (flags != PRIMARY_SURFACE)
sprAllocated++; _vm->_global->sprAllocated++;
if (flags & RETURN_PRIMARY) if (flags & RETURN_PRIMARY)
return pPrimarySurfDesc; return _vm->_global->pPrimarySurfDesc;
if (vidMode != 0x13) 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) if ((flags & PRIMARY_SURFACE) == 0)
vidMode += 0x80; vidMode += 0x80;
@ -109,20 +109,20 @@ SurfaceDesc *vid_initSurfDesc(int16 vidMode, int16 width, int16 height, int16 fl
if (flags & PRIMARY_SURFACE) { if (flags & PRIMARY_SURFACE) {
vidMem = 0; vidMem = 0;
primaryWidth = width; _vm->_global->primaryWidth = width;
mouseMaxCol = width; _vm->_global->mouseMaxCol = width;
primaryHeight = height; _vm->_global->primaryHeight = height;
mouseMaxRow = height; _vm->_global->mouseMaxRow = height;
sprSize = 0; sprSize = 0;
} else { } else {
vidMem = 0; vidMem = 0;
sprSize = vid_getRectSize(width, height, flagsAnd2, vidMode); sprSize = Video::getRectSize(width, height, flagsAnd2, vidMode);
if (flagsAnd2) if (flagsAnd2)
someFlags += 0x80; someFlags += 0x80;
} }
if (flags & PRIMARY_SURFACE) { if (flags & PRIMARY_SURFACE) {
descPtr = pPrimarySurfDesc; descPtr = _vm->_global->pPrimarySurfDesc;
vidMem = (byte *)malloc(320 * 200); vidMem = (byte *)malloc(320 * 200);
} else { } else {
if (flags & DISABLE_SPR_ALLOC) if (flags & DISABLE_SPR_ALLOC)
@ -146,15 +146,15 @@ SurfaceDesc *vid_initSurfDesc(int16 vidMode, int16 width, int16 height, int16 fl
return descPtr; return descPtr;
} }
void vid_freeSurfDesc(SurfaceDesc * surfDesc) { void Video::freeSurfDesc(SurfaceDesc * surfDesc) {
sprAllocated--; _vm->_global->sprAllocated--;
if (surfDesc != pPrimarySurfDesc) if (surfDesc != _vm->_global->pPrimarySurfDesc)
free(surfDesc); free(surfDesc);
else else
free(surfDesc->vidPtr); free(surfDesc->vidPtr);
} }
int16 vid_clampValue(int16 val, int16 max) { int16 Video::clampValue(int16 val, int16 max) {
if (val >= max) if (val >= max)
val = max - 1; val = max - 1;
@ -164,13 +164,13 @@ int16 vid_clampValue(int16 val, int16 max) {
return val; 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 left, int16 top, int16 right, int16 bottom, int16 x, int16 y, int16 transp) {
int16 temp; int16 temp;
int16 destRight; int16 destRight;
int16 destBottom; int16 destBottom;
if (doRangeClamp) { if (_vm->_global->doRangeClamp) {
if (left > right) { if (left > right) {
temp = left; temp = left;
left = right; left = right;
@ -198,8 +198,8 @@ void vid_drawSprite(SurfaceDesc *source, SurfaceDesc *dest,
y -= top; y -= top;
top = 0; top = 0;
} }
right = vid_clampValue(right, source->width); right = Video::clampValue(right, source->width);
bottom = vid_clampValue(bottom, source->height); bottom = Video::clampValue(bottom, source->height);
if (right - left >= source->width) if (right - left >= source->width)
right = left + source->width - 1; right = left + source->width - 1;
if (bottom - top >= source->height) 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); _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 color) {
int16 temp; int16 temp;
if (doRangeClamp) { if (_vm->_global->doRangeClamp) {
if (left > right) { if (left > right) {
temp = left; temp = left;
left = right; left = right;
@ -260,64 +260,64 @@ void vid_fillRect(SurfaceDesc *dest, int16 left, int16 top, int16 right, int16 b
if (top >= dest->height) if (top >= dest->height)
return; return;
left = vid_clampValue(left, dest->width); left = Video::clampValue(left, dest->width);
top = vid_clampValue(top, dest->height); top = Video::clampValue(top, dest->height);
right = vid_clampValue(right, dest->width); right = Video::clampValue(right, dest->width);
bottom = vid_clampValue(bottom, dest->height); bottom = Video::clampValue(bottom, dest->height);
} }
_videoDriver->fillRect(dest, left, top, right, bottom, color); _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) { if (x0 == x1 || y0 == y1) {
vid_fillRect(dest, x0, y0, x1, y1, color); Video::fillRect(dest, x0, y0, x1, y1, color);
return; return;
} }
_videoDriver->drawLine(dest, x0, y0, x1, y1, color); _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) if (x < 0 || y < 0 || x >= dest->width || y >= dest->height)
return; return;
_videoDriver->putPixel(x, y, color, dest); _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) { int16 color2, int16 transp, SurfaceDesc *dest) {
_videoDriver->drawLetter(item, x, y, fontDesc, color1, color2, transp, dest); _videoDriver->drawLetter(item, x, y, fontDesc, color1, color2, transp, dest);
} }
void vid_clearSurf(SurfaceDesc *dest) { void Video::clearSurf(SurfaceDesc *dest) {
vid_fillRect(dest, 0, 0, dest->width - 1, dest->height - 1, 0); 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) { 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; return;
if ((dest->vidMode & 0x7f) != 0x13) 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); dest->vidMode & 0x7f);
_videoDriver->drawPackedSprite(sprBuf, width, height, x, y, transp, dest); _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) { int16 vidMode) {
byte pal[4]; byte pal[4];
redPalette[index] = red; _vm->_global->redPalette[index] = red;
greenPalette[index] = green; _vm->_global->greenPalette[index] = green;
bluePalette[index] = blue; _vm->_global->bluePalette[index] = blue;
if (vidMode != 0x13) if (vidMode != 0x13)
error("vid_setPalElem: Video mode 0x%x is not supported!", error("Video::setPalElem: Video mode 0x%x is not supported!",
vidMode); vidMode);
pal[0] = (red << 2) | (red >> 4); 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); g_system->setPalette(pal, index, 1);
} }
void vid_setPalette(PalDesc *palDesc) { void Video::setPalette(PalDesc *palDesc) {
int16 i; int16 i;
byte pal[1024]; byte pal[1024];
int16 numcolors; int16 numcolors;
if (videoMode != 0x13) if (_vm->_global->videoMode != 0x13)
error("vid_setPalette: Video mode 0x%x is not supported!", error("Video::setPalette: Video mode 0x%x is not supported!",
videoMode); _vm->_global->videoMode);
if (setAllPalette) if (_vm->_global->setAllPalette)
numcolors = 256; numcolors = 256;
else else
numcolors = 16; numcolors = 16;
@ -351,17 +351,17 @@ void vid_setPalette(PalDesc *palDesc) {
g_system->setPalette(pal, 0, numcolors); g_system->setPalette(pal, 0, numcolors);
} }
void vid_setFullPalette(PalDesc *palDesc) { void Video::setFullPalette(PalDesc *palDesc) {
Color *colors; Color *colors;
int16 i; int16 i;
byte pal[1024]; byte pal[1024];
if (setAllPalette) { if (_vm->_global->setAllPalette) {
colors = palDesc->vgaPal; colors = palDesc->vgaPal;
for (i = 0; i < 256; i++) { for (i = 0; i < 256; i++) {
redPalette[i] = colors[i].red; _vm->_global->redPalette[i] = colors[i].red;
greenPalette[i] = colors[i].green; _vm->_global->greenPalette[i] = colors[i].green;
bluePalette[i] = colors[i].blue; _vm->_global->bluePalette[i] = colors[i].blue;
} }
for (i = 0; i < 256; i++) { for (i = 0; i < 256; i++) {
@ -372,46 +372,46 @@ void vid_setFullPalette(PalDesc *palDesc) {
} }
g_system->setPalette(pal, 0, 256); g_system->setPalette(pal, 0, 256);
} else { } else {
vid_setPalette(palDesc); Video::setPalette(palDesc);
} }
} }
void vid_initPrimary(int16 mode) { void Video::initPrimary(int16 mode) {
int16 old; int16 old;
if (curPrimaryDesc) { if (_vm->_global->curPrimaryDesc) {
vid_freeSurfDesc(curPrimaryDesc); Video::freeSurfDesc(_vm->_global->curPrimaryDesc);
vid_freeSurfDesc(allocatedPrimary); Video::freeSurfDesc(_vm->_global->allocatedPrimary);
curPrimaryDesc = 0; _vm->_global->curPrimaryDesc = 0;
allocatedPrimary = 0; _vm->_global->allocatedPrimary = 0;
} }
if (mode != 0x13 && mode != 3 && mode != -1) 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); mode);
if (videoMode != 0x13) if (_vm->_global->videoMode != 0x13)
error("vid_initPrimary: Video mode 0x%x is not supported!", error("Video::initPrimary: Video mode 0x%x is not supported!",
mode); mode);
old = oldMode; old = _vm->_global->oldMode;
if (mode == -1) if (mode == -1)
mode = 3; mode = 3;
oldMode = mode; _vm->_global->oldMode = mode;
if (mode != 3) if (mode != 3)
vid_initDriver(mode); Video::initDriver(mode);
if (mode != 3) { if (mode != 3) {
vid_initSurfDesc(mode, 320, 200, PRIMARY_SURFACE); Video::initSurfDesc(mode, 320, 200, PRIMARY_SURFACE);
if (dontSetPalette) if (_vm->_global->dontSetPalette)
return; 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) { int16 x, int16 y, int16 transp, SurfaceDesc *destDesc) {
SurfaceDesc sourceDesc; SurfaceDesc sourceDesc;
byte *memBuffer; byte *memBuffer;
@ -432,7 +432,7 @@ char vid_spriteUncompressor(byte *sprBuf, int16 srcWidth, int16 srcHeight,
return 1; return 1;
if ((destDesc->vidMode & 0x7f) != 0x13) 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); destDesc->vidMode & 0x7f);
if (sprBuf[0] != 1) if (sprBuf[0] != 1)
@ -446,7 +446,7 @@ char vid_spriteUncompressor(byte *sprBuf, int16 srcWidth, int16 srcHeight,
sourceDesc.height = srcHeight; sourceDesc.height = srcHeight;
sourceDesc.vidMode = 0x93; sourceDesc.vidMode = 0x93;
sourceDesc.vidPtr = sprBuf + 3; 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); srcHeight - 1, x, y, transp);
return 1; return 1;
} else { } else {
@ -540,8 +540,6 @@ char vid_spriteUncompressor(byte *sprBuf, int16 srcWidth, int16 srcHeight,
return 1; return 1;
} }
void vid_setHandlers() { void Video::setHandlers() { _vm->_global->setAllPalette = 1; }
setAllPalette = 1;
}
} // End of namespace Gob } // End of namespace Gob

84
gob/video.h
View file

@ -24,6 +24,7 @@
#include "common/stdafx.h" #include "common/stdafx.h"
#include "common/util.h" #include "common/util.h"
#include "gob/gob.h"
namespace Gob { namespace Gob {
@ -35,7 +36,10 @@ namespace Gob {
#define TEXT_COL_COUNT 80 #define TEXT_COL_COUNT 80
#define TEXT_ROW_COUNT 25 #define TEXT_ROW_COUNT 25
extern int16 setAllPalette;
class Video {
public:
typedef struct SurfaceDesc_t { typedef struct SurfaceDesc_t {
int16 width; int16 width;
int16 height; int16 height;
@ -44,6 +48,8 @@ typedef struct SurfaceDesc_t {
int16 vidMode; int16 vidMode;
byte *vidPtr; byte *vidPtr;
int16 reserved2; int16 reserved2;
SurfaceDesc_t() : width(0), height(0), reserved1(0), flag(0),
vidMode(0), vidPtr(0), reserved2(0) {}
} SurfaceDesc; } SurfaceDesc;
typedef struct FontDesc_t { typedef struct FontDesc_t {
@ -55,30 +61,17 @@ typedef struct FontDesc_t {
int8 itemSize; int8 itemSize;
int8 bitWidth; int8 bitWidth;
void *extraData; void *extraData;
FontDesc_t() : dataPtr(0), itemWidth(0), itemHeight(0), startItem(0),
endItem(0), itemSize(0), bitWidth(0) {}
} FontDesc; } FontDesc;
class VideoDriver {
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;
};
#define GDR_VERSION 4 #define GDR_VERSION 4
#define PRIMARY_SURFACE 0x80 #define PRIMARY_SURFACE 0x80
#define RETURN_PRIMARY 0x01 #define RETURN_PRIMARY 0x01
#define DISABLE_SPR_ALLOC 0x20 #define DISABLE_SPR_ALLOC 0x20
#if !defined(__GNUC__)
#pragma START_PACK_STRUCTS #pragma START_PACK_STRUCTS
#endif
typedef struct Color { typedef struct Color {
byte red; byte red;
@ -86,42 +79,61 @@ typedef struct Color {
byte blue; byte blue;
} GCC_PACK Color; } GCC_PACK Color;
#if !defined(__GNUC__)
#pragma END_PACK_STRUCTS #pragma END_PACK_STRUCTS
#endif
typedef struct PalDesc { typedef struct PalDesc {
Color *vgaPal; Color *vgaPal;
int16 *unused1; int16 *unused1;
int16 *unused2; int16 *unused2;
PalDesc() : vgaPal(0), unused1(0), unused2(0) {}
} PalDesc; } PalDesc;
char vid_initDriver(int16 vidMode); Video(class GobEngine *vm);
void vid_freeDriver(void); int32 getRectSize(int16 width, int16 height, int16 flag, int16 mode);
int32 vid_getRectSize(int16 width, int16 height, int16 flag, int16 mode); SurfaceDesc *initSurfDesc(int16 vidMode, int16 width, int16 height, int16 flags);
SurfaceDesc *vid_initSurfDesc(int16 vidMode, int16 width, int16 height, int16 flags); void freeSurfDesc(SurfaceDesc * surfDesc);
void vid_freeSurfDesc(SurfaceDesc * surfDesc); int16 clampValue(int16 val, int16 max);
int16 vid_clampValue(int16 val, int16 max); void drawSprite(SurfaceDesc * source, SurfaceDesc * dest, int16 left,
void vid_drawSprite(SurfaceDesc * source, SurfaceDesc * dest, int16 left,
int16 top, int16 right, int16 bottom, int16 x, int16 y, int16 transp); 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, void fillRect(SurfaceDesc * dest, int16 left, int16 top, int16 right, int16 bottom,
int16 color); int16 color);
void vid_drawLine(SurfaceDesc * dest, int16 x0, int16 y0, int16 x1, int16 y1, void drawLine(SurfaceDesc * dest, int16 x0, int16 y0, int16 x1, int16 y1,
int16 color); int16 color);
void vid_putPixel(int16 x, int16 y, int16 color, SurfaceDesc * dest); void putPixel(int16 x, int16 y, int16 color, SurfaceDesc * dest);
void vid_drawLetter(unsigned char item, int16 x, int16 y, FontDesc * fontDesc, int16 color1, void drawLetter(unsigned char item, int16 x, int16 y, FontDesc * fontDesc, int16 color1,
int16 color2, int16 transp, SurfaceDesc * dest); int16 color2, int16 transp, SurfaceDesc * dest);
void vid_clearSurf(SurfaceDesc * dest); void clearSurf(SurfaceDesc * dest);
void vid_drawPackedSprite(byte *sprBuf, int16 width, int16 height, int16 x, int16 y, void drawPackedSprite(byte *sprBuf, int16 width, int16 height, int16 x, int16 y,
int16 transp, SurfaceDesc * dest); int16 transp, SurfaceDesc * dest);
void vid_setPalElem(int16 index, char red, char green, char blue, int16 unused, void setPalElem(int16 index, char red, char green, char blue, int16 unused,
int16 vidMode); int16 vidMode);
void vid_setPalette(PalDesc * palDesc); void setPalette(PalDesc * palDesc);
void vid_setFullPalette(PalDesc * palDesc); void setFullPalette(PalDesc * palDesc);
void vid_initPrimary(int16 mode); void initPrimary(int16 mode);
char vid_spriteUncompressor(byte *sprBuf, int16 srcWidth, int16 srcHeight, int16 x, char spriteUncompressor(byte *sprBuf, int16 srcWidth, int16 srcHeight, int16 x,
int16 y, int16 transp, SurfaceDesc * destDesc); int16 y, int16 transp, SurfaceDesc * destDesc);
void vid_setHandlers(void); void waitRetrace(int16);
void freeDriver(void);
void setHandlers();
protected:
class VideoDriver *_videoDriver;
GobEngine *_vm;
char initDriver(int16 vidMode);
};
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 } // End of namespace Gob