aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--engines/voyeur/animation.cpp485
-rw-r--r--engines/voyeur/animation.h196
-rw-r--r--engines/voyeur/configure.engine4
-rw-r--r--engines/voyeur/data.cpp359
-rw-r--r--engines/voyeur/data.h231
-rw-r--r--engines/voyeur/debugger.cpp148
-rw-r--r--engines/voyeur/debugger.h72
-rw-r--r--engines/voyeur/detection.cpp182
-rw-r--r--engines/voyeur/detection_tables.h42
-rw-r--r--engines/voyeur/events.cpp624
-rw-r--r--engines/voyeur/events.h153
-rw-r--r--engines/voyeur/files.cpp1659
-rw-r--r--engines/voyeur/files.h650
-rw-r--r--engines/voyeur/files_threads.cpp1738
-rw-r--r--engines/voyeur/graphics.cpp1065
-rw-r--r--engines/voyeur/graphics.h134
-rw-r--r--engines/voyeur/module.mk23
-rw-r--r--engines/voyeur/sound.cpp85
-rw-r--r--engines/voyeur/sound.h60
-rw-r--r--engines/voyeur/staticres.cpp142
-rw-r--r--engines/voyeur/staticres.h63
-rw-r--r--engines/voyeur/voyeur.cpp919
-rw-r--r--engines/voyeur/voyeur.h321
-rw-r--r--engines/voyeur/voyeur_game.cpp1423
24 files changed, 10778 insertions, 0 deletions
diff --git a/engines/voyeur/animation.cpp b/engines/voyeur/animation.cpp
new file mode 100644
index 0000000000..f81573f733
--- /dev/null
+++ b/engines/voyeur/animation.cpp
@@ -0,0 +1,485 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "voyeur/animation.h"
+#include "voyeur/staticres.h"
+#include "voyeur/voyeur.h"
+#include "common/endian.h"
+#include "common/memstream.h"
+#include "common/system.h"
+#include "audio/decoders/raw.h"
+#include "graphics/surface.h"
+
+namespace Voyeur {
+
+// Number of audio frames to keep audio track topped up when playing back video
+#define SOUND_FRAMES_READAHEAD 3
+
+RL2Decoder::RL2Decoder(Audio::Mixer::SoundType soundType) : _soundType(soundType) {
+ _paletteStart = 0;
+ _fileStream = nullptr;
+ _soundFrameNumber = -1;
+}
+
+RL2Decoder::~RL2Decoder() {
+ close();
+}
+
+bool RL2Decoder::loadVideo(int videoId) {
+ Common::String filename = Common::String::format("%s.rl2",
+ ::Voyeur::SZ_FILENAMES[videoId * 2]);
+ return loadFile(filename);
+}
+
+bool RL2Decoder::loadFile(const Common::String &file, bool palFlag) {
+ bool result = VideoDecoder::loadFile(file);
+ _paletteStart = palFlag ? 0 : 128;
+ return result;
+}
+
+bool RL2Decoder::loadStream(Common::SeekableReadStream *stream) {
+ close();
+
+ // Load basic file information
+ _fileStream = stream;
+ _header.load(stream);
+ _paletteStart = 0;
+
+ // Check RL2 magic number
+ if (!_header.isValid()) {
+ warning("RL2Decoder::loadStream(): attempted to load non-RL2 data (0x%08X)", _header._signature);
+ return false;
+ }
+
+ // Add an audio track if sound is present
+ _audioTrack = nullptr;
+ if (_header._soundRate) {
+ _audioTrack = new RL2AudioTrack(_header, stream, _soundType);
+ addTrack(_audioTrack);
+ }
+
+ // Create a video track
+ _videoTrack = new RL2VideoTrack(_header, _audioTrack, stream);
+ addTrack(_videoTrack);
+
+ // Load the offset/sizes of the video's audio data
+ _soundFrames.reserve(_header._numFrames);
+ for (int frameNumber = 0; frameNumber < _header._numFrames; ++frameNumber) {
+ int offset = _header._frameOffsets[frameNumber];
+ int size = _header._frameSoundSizes[frameNumber];
+
+ _soundFrames.push_back(SoundFrame(offset, size));
+ }
+
+ return true;
+}
+
+const Common::List<Common::Rect> *RL2Decoder::getDirtyRects() const {
+ if (_videoTrack)
+ return _videoTrack->getDirtyRects();
+
+ return 0;
+}
+
+void RL2Decoder::clearDirtyRects() {
+ if (_videoTrack)
+ _videoTrack->clearDirtyRects();
+}
+
+void RL2Decoder::copyDirtyRectsToBuffer(uint8 *dst, uint pitch) {
+ if (_videoTrack)
+ _videoTrack->copyDirtyRectsToBuffer(dst, pitch);
+}
+
+void RL2Decoder::readNextPacket() {
+ int frameNumber = getCurFrame();
+ RL2AudioTrack *audioTrack = getAudioTrack();
+
+ // Handle queueing sound data
+ if (_soundFrameNumber == -1)
+ _soundFrameNumber = (frameNumber == -1) ? 0 : frameNumber;
+
+ while (audioTrack->numQueuedStreams() < SOUND_FRAMES_READAHEAD &&
+ (_soundFrameNumber < (int)_soundFrames.size())) {
+ _fileStream->seek(_soundFrames[_soundFrameNumber]._offset);
+ audioTrack->queueSound(_fileStream, _soundFrames[_soundFrameNumber]._size);
+ ++_soundFrameNumber;
+ }
+}
+
+bool RL2Decoder::seekIntern(const Audio::Timestamp &where) {
+ _soundFrameNumber = -1;
+ return VideoDecoder::seekIntern(where);
+}
+
+void RL2Decoder::close() {
+ VideoDecoder::close();
+ delete _fileStream;
+ _fileStream = nullptr;
+ _soundFrameNumber = -1;
+}
+
+/*------------------------------------------------------------------------*/
+
+RL2Decoder::SoundFrame::SoundFrame(int offset, int size) {
+ _offset = offset;
+ _size = size;
+}
+
+/*------------------------------------------------------------------------*/
+
+RL2Decoder::RL2FileHeader::RL2FileHeader() {
+ _frameOffsets = nullptr;
+ _frameSoundSizes = nullptr;
+}
+
+RL2Decoder::RL2FileHeader::~RL2FileHeader() {
+ delete[] _frameOffsets;
+ delete[] _frameSoundSizes;
+}
+
+void RL2Decoder::RL2FileHeader::load(Common::SeekableReadStream *stream) {
+ stream->seek(0);
+
+ _form = stream->readUint32LE();
+ _backSize = stream->readUint32LE();
+ _signature = stream->readUint32BE();
+
+ if (!isValid())
+ return;
+
+ _dataSize = stream->readUint32LE();
+ _numFrames = stream->readUint32LE();
+ _method = stream->readUint16LE();
+ _soundRate = stream->readUint16LE();
+ _rate = stream->readUint16LE();
+ _channels = stream->readUint16LE();
+ _defSoundSize = stream->readUint16LE();
+ _videoBase = stream->readUint16LE();
+ _colorCount = stream->readUint32LE();
+ assert(_colorCount <= 256);
+
+ stream->read(_palette, 768);
+
+ // Skip over background frame, if any, and the list of overall frame sizes (which we don't use)
+ stream->skip(_backSize + 4 * _numFrames);
+
+ // Load frame offsets
+ delete[] _frameOffsets;
+ _frameOffsets = new uint32[_numFrames];
+ for (int i = 0; i < _numFrames; ++i)
+ _frameOffsets[i] = stream->readUint32LE();
+
+ // Load the size of the sound portion of each frame
+ delete[] _frameSoundSizes;
+ _frameSoundSizes = new int[_numFrames];
+ for (int i = 0; i < _numFrames; ++i)
+ _frameSoundSizes[i] = stream->readUint32LE() & 0xffff;
+}
+
+bool RL2Decoder::RL2FileHeader::isValid() const {
+ return _signature == MKTAG('R','L','V','2') || _signature == MKTAG('R','L','V','3');
+}
+
+Common::Rational RL2Decoder::RL2FileHeader::getFrameRate() const {
+ return (_soundRate > 0) ? Common::Rational(_rate, _defSoundSize) :
+ Common::Rational(11025, 1103);
+}
+
+/*------------------------------------------------------------------------*/
+
+RL2Decoder::RL2VideoTrack::RL2VideoTrack(const RL2FileHeader &header, RL2AudioTrack *audioTrack,
+ Common::SeekableReadStream *stream):
+ _header(header), _audioTrack(audioTrack), _fileStream(stream) {
+
+ // Set up surfaces
+ _surface = new Graphics::Surface();
+ _surface->create(320, 200, Graphics::PixelFormat::createFormatCLUT8());
+
+ _hasBackFrame = header._backSize != 0;
+
+ _backSurface = NULL;
+ if (_hasBackFrame)
+ initBackSurface();
+
+ _videoBase = header._videoBase;
+ _dirtyPalette = header._colorCount > 0;
+
+ _curFrame = -1;
+ _initialFrame = true;
+}
+
+RL2Decoder::RL2VideoTrack::~RL2VideoTrack() {
+ // Free surfaces
+ _surface->free();
+ delete _surface;
+ if (_backSurface) {
+ _backSurface->free();
+ delete _backSurface;
+ }
+}
+
+void RL2Decoder::RL2VideoTrack::initBackSurface() {
+ _backSurface = new Graphics::Surface();
+ _backSurface->create(320, 200, Graphics::PixelFormat::createFormatCLUT8());
+}
+
+bool RL2Decoder::RL2VideoTrack::seek(const Audio::Timestamp &time) {
+ int frame = getFrameAtTime(time);
+
+ if (frame < 0 || frame >= _header._numFrames)
+ return false;
+
+ _curFrame = frame;
+ return true;
+}
+
+uint16 RL2Decoder::RL2VideoTrack::getWidth() const {
+ return _surface->w;
+}
+
+uint16 RL2Decoder::RL2VideoTrack::getHeight() const {
+ return _surface->h;
+}
+
+Graphics::PixelFormat RL2Decoder::RL2VideoTrack::getPixelFormat() const {
+ return _surface->format;
+}
+
+const Graphics::Surface *RL2Decoder::RL2VideoTrack::decodeNextFrame() {
+ if (_initialFrame && _hasBackFrame) {
+ // Read in the initial background frame
+ _fileStream->seek(0x324);
+ rl2DecodeFrameWithoutTransparency(0);
+
+ Common::copy((byte *)_surface->getPixels(), (byte *)_surface->getPixels() + (320 * 200),
+ (byte *)_backSurface->getPixels());
+ _dirtyRects.push_back(Common::Rect(0, 0, _surface->w, _surface->h));
+ _initialFrame = false;
+ }
+
+ // Move to the next frame data
+ _fileStream->seek(_header._frameOffsets[++_curFrame]);
+
+ // If there's any sound data, pass it to the audio track
+ _fileStream->seek(_header._frameSoundSizes[_curFrame], SEEK_CUR);
+
+ // Decode the graphic data using the appropriate method depending on whether the animation
+ // has a background or just raw frames without any background transparency
+ if (_backSurface) {
+ rl2DecodeFrameWithTransparency(_videoBase);
+ } else {
+ rl2DecodeFrameWithoutTransparency(_videoBase);
+ }
+
+ return _surface;
+}
+
+void RL2Decoder::RL2VideoTrack::copyDirtyRectsToBuffer(uint8 *dst, uint pitch) {
+ for (Common::List<Common::Rect>::const_iterator it = _dirtyRects.begin(); it != _dirtyRects.end(); ++it) {
+ for (int y = (*it).top; y < (*it).bottom; ++y) {
+ const int x = (*it).left;
+ memcpy(dst + y * pitch + x, (byte *)_surface->getPixels() + y * getWidth() + x, (*it).right - x);
+ }
+ }
+
+ clearDirtyRects();
+}
+
+void RL2Decoder::RL2VideoTrack::copyFrame(uint8 *data) {
+ memcpy((byte *)_surface->getPixels(), data, getWidth() * getHeight());
+
+ // Redraw
+ _dirtyRects.clear();
+ _dirtyRects.push_back(Common::Rect(0, 0, getWidth(), getHeight()));
+}
+
+void RL2Decoder::RL2VideoTrack::rl2DecodeFrameWithoutTransparency(int screenOffset) {
+ if (screenOffset == -1)
+ screenOffset = _videoBase;
+ int frameSize = _surface->w * _surface->h - screenOffset;
+ byte *destP = (byte *)_surface->getPixels();
+
+ // Main frame decode loop
+ byte nextByte;
+ for (;;) {
+ nextByte = _fileStream->readByte();
+
+ if (nextByte < 0x80) {
+ // Simple byte to copy to output
+ assert(frameSize > 0);
+ *destP++ = nextByte;
+ --frameSize;
+ } else if (nextByte > 0x80) {
+ // Lower 7 bits a run length for the following byte
+ int runLength = _fileStream->readByte();
+ runLength = MIN(runLength, frameSize);
+
+ Common::fill(destP, destP + runLength, nextByte & 0x7f);
+ destP += runLength;
+ frameSize -= runLength;
+ } else {
+ // Follow byte run length for zeroes. If zero, indicates end of image
+ int runLength = _fileStream->readByte();
+ if (runLength == 0)
+ break;
+
+ runLength = MIN(runLength, frameSize);
+ Common::fill(destP, destP + runLength, 0);
+ destP += runLength;
+ frameSize -= runLength;
+ }
+ }
+
+ // If there's any remaining screen area, zero it out
+ byte *endP = (byte *)_surface->getPixels() + _surface->w * _surface->h;
+ if (destP != endP)
+ Common::fill(destP, endP, 0);
+}
+
+void RL2Decoder::RL2VideoTrack::rl2DecodeFrameWithTransparency(int screenOffset) {
+ int frameSize = _surface->w * _surface->h - screenOffset;
+ byte *refP = (byte *)_backSurface->getPixels();
+ byte *destP = (byte *)_surface->getPixels();
+
+ // If there's a screen offset, copy unchanged initial pixels from reference surface
+ if (screenOffset > 0)
+ Common::copy(refP, refP + screenOffset, destP);
+
+ // Main decode loop
+ while (frameSize > 0) {
+ byte nextByte = _fileStream->readByte();
+
+ if (nextByte == 0) {
+ // Move one single byte from reference surface
+ assert(frameSize > 0);
+ destP[screenOffset] = refP[screenOffset];
+ ++screenOffset;
+ --frameSize;
+ } else if (nextByte < 0x80) {
+ // Single 7-bit pixel to output (128-255)
+ assert(frameSize > 0);
+ destP[screenOffset] = nextByte | 0x80;
+ ++screenOffset;
+ --frameSize;
+ } else if (nextByte == 0x80) {
+ int runLength = _fileStream->readByte();
+ if (runLength == 0)
+ return;
+
+ // Run length of transparency (i.e. pixels to copy from reference frame)
+ runLength = MIN(runLength, frameSize);
+
+ Common::copy(refP + screenOffset, refP + screenOffset + runLength, destP + screenOffset);
+ screenOffset += runLength;
+ frameSize -= runLength;
+ } else {
+ // Run length of a single pixel value
+ int runLength = _fileStream->readByte();
+ runLength = MIN(runLength, frameSize);
+
+ Common::fill(destP + screenOffset, destP + screenOffset + runLength, nextByte);
+ screenOffset += runLength;
+ frameSize -= runLength;
+ }
+ }
+
+ // If there's a remaining section of the screen not covered, copy it from reference surface
+ if (screenOffset < (_surface->w * _surface->h))
+ Common::copy(refP + screenOffset, refP + (_surface->w * _surface->h), destP + screenOffset);
+}
+
+Graphics::Surface *RL2Decoder::RL2VideoTrack::getBackSurface() {
+ if (!_backSurface)
+ initBackSurface();
+
+ return _backSurface;
+}
+
+/*------------------------------------------------------------------------*/
+
+RL2Decoder::RL2AudioTrack::RL2AudioTrack(const RL2FileHeader &header, Common::SeekableReadStream *stream, Audio::Mixer::SoundType soundType):
+ _header(header), _soundType(soundType) {
+ // Create audio straem for the audio track
+ _audStream = Audio::makeQueuingAudioStream(_header._rate, _header._channels == 2);
+}
+
+RL2Decoder::RL2AudioTrack::~RL2AudioTrack() {
+ delete _audStream;
+}
+
+void RL2Decoder::RL2AudioTrack::queueSound(Common::SeekableReadStream *stream, int size) {
+ // Queue the sound data
+ byte *data = (byte *)malloc(size);
+ stream->read(data, size);
+ Common::MemoryReadStream *memoryStream = new Common::MemoryReadStream(data, size,
+ DisposeAfterUse::YES);
+
+ _audStream->queueAudioStream(Audio::makeRawStream(memoryStream, _header._rate,
+ Audio::FLAG_UNSIGNED, DisposeAfterUse::YES), DisposeAfterUse::YES);
+}
+
+Audio::AudioStream *RL2Decoder::RL2AudioTrack::getAudioStream() const {
+ return _audStream;
+}
+
+void RL2Decoder::play(VoyeurEngine *vm, int resourceOffset,
+ byte *frames, byte *imgPos) {
+ vm->flipPageAndWait();
+ int paletteStart = getPaletteStart();
+ int paletteCount = getPaletteCount();
+
+ PictureResource videoFrame(getVideoTrack()->getBackSurface());
+ int picCtr = 0;
+ while (!vm->shouldQuit() && !endOfVideo() && !vm->_eventsManager._mouseClicked) {
+ if (hasDirtyPalette()) {
+ const byte *palette = getPalette();
+
+ vm->_graphicsManager.setPalette128(palette, paletteStart, paletteCount);
+ }
+
+ if (needsUpdate()) {
+ if (frames) {
+ // If reached a point where a new background is needed, load it
+ // and copy over to the video decoder
+ if (getCurFrame() >= READ_LE_UINT16(frames + picCtr * 4)) {
+ PictureResource *newPic = vm->_bVoy->boltEntry(0x302 + picCtr)._picResource;
+ Common::Point pt(READ_LE_UINT16(imgPos + 4 * picCtr) - 32,
+ READ_LE_UINT16(imgPos + 4 * picCtr + 2) - 20);
+
+ vm->_graphicsManager.sDrawPic(newPic, &videoFrame, pt);
+ ++picCtr;
+ }
+ }
+
+ // Decode the next frame and display
+ const Graphics::Surface *frame = decodeNextFrame();
+ Common::copy((const byte *)frame->getPixels(), (const byte *)frame->getPixels() + 320 * 200,
+ (byte *)vm->_graphicsManager._screenSurface.getPixels());
+ }
+
+ vm->_eventsManager.getMouseInfo();
+ g_system->delayMillis(10);
+ }
+}
+
+} // End of namespace Voyeur
diff --git a/engines/voyeur/animation.h b/engines/voyeur/animation.h
new file mode 100644
index 0000000000..35199f6b93
--- /dev/null
+++ b/engines/voyeur/animation.h
@@ -0,0 +1,196 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef VOYEUR_ANIMATION_H
+#define VOYEUR_ANIMATION_H
+
+#include "video/video_decoder.h"
+#include "audio/audiostream.h"
+#include "audio/mixer.h"
+#include "audio/timestamp.h"
+#include "common/array.h"
+#include "common/list.h"
+#include "common/rect.h"
+#include "common/stream.h"
+#include "voyeur/files.h"
+
+namespace Voyeur {
+
+class VoyeurEngine;
+
+/**
+ * Decoder for RL2 videos.
+ *
+ * Video decoder used in engines:
+ * - voyeur
+ */
+class RL2Decoder : public Video::VideoDecoder {
+private:
+ class RL2FileHeader {
+ public:
+ RL2FileHeader();
+ ~RL2FileHeader();
+
+ int _channels;
+ int _colorCount;
+ int _numFrames;
+ int _rate;
+ int _soundRate;
+ int _videoBase;
+ int *_frameSoundSizes;
+
+ uint32 _backSize;
+ uint32 _signature;
+ uint32 *_frameOffsets;
+
+ byte _palette[768];
+
+ void load(Common::SeekableReadStream *stream);
+ Common::Rational getFrameRate() const;
+ bool isValid() const;
+
+ private:
+ uint32 _form;
+ uint32 _dataSize;
+ int _method;
+ int _defSoundSize;
+ };
+
+ class SoundFrame {
+ public:
+ int _offset;
+ int _size;
+
+ SoundFrame(int offset, int size);
+ };
+
+ class RL2AudioTrack : public AudioTrack {
+ private:
+ Audio::Mixer::SoundType _soundType;
+ const RL2FileHeader &_header;
+ Audio::QueuingAudioStream *_audStream;
+ protected:
+ Audio::AudioStream *getAudioStream() const;
+ public:
+ RL2AudioTrack(const RL2FileHeader &header, Common::SeekableReadStream *stream,
+ Audio::Mixer::SoundType soundType);
+ ~RL2AudioTrack();
+
+ Audio::Mixer::SoundType getSoundType() const { return _soundType; }
+ int numQueuedStreams() const { return _audStream->numQueuedStreams(); }
+ virtual bool isSeekable() const { return true; }
+ virtual bool seek(const Audio::Timestamp &time) { return true; }
+
+ void queueSound(Common::SeekableReadStream *stream, int size);
+ };
+
+ class RL2VideoTrack : public FixedRateVideoTrack {
+ public:
+ RL2VideoTrack(const RL2FileHeader &header, RL2AudioTrack *audioTrack,
+ Common::SeekableReadStream *stream);
+ ~RL2VideoTrack();
+
+ uint16 getWidth() const;
+ uint16 getHeight() const;
+ Graphics::Surface *getSurface() { return _surface; }
+ Graphics::Surface *getBackSurface();
+ Graphics::PixelFormat getPixelFormat() const;
+ int getCurFrame() const { return _curFrame; }
+ int getFrameCount() const { return _header._numFrames; }
+ const Graphics::Surface *decodeNextFrame();
+ const byte *getPalette() const { _dirtyPalette = false; return _header._palette; }
+ int getPaletteCount() const { return _header._colorCount; }
+ bool hasDirtyPalette() const { return _dirtyPalette; }
+ const Common::List<Common::Rect> *getDirtyRects() const { return &_dirtyRects; }
+ void clearDirtyRects() { _dirtyRects.clear(); }
+ void copyDirtyRectsToBuffer(uint8 *dst, uint pitch);
+
+ virtual Common::Rational getFrameRate() const { return _header.getFrameRate(); }
+ virtual bool isSeekable() const { return true; }
+ virtual bool seek(const Audio::Timestamp &time);
+ private:
+ Common::SeekableReadStream *_fileStream;
+ const RL2FileHeader &_header;
+ RL2AudioTrack *_audioTrack;
+ Graphics::Surface *_surface;
+ Graphics::Surface *_backSurface;
+ bool _hasBackFrame;
+
+ mutable bool _dirtyPalette;
+
+ bool _initialFrame;
+ int _curFrame;
+ uint32 _videoBase;
+ uint32 *_frameOffsets;
+
+ Common::List<Common::Rect> _dirtyRects;
+
+ void copyFrame(uint8 *data);
+ void rl2DecodeFrameWithTransparency(int screenOffset);
+ void rl2DecodeFrameWithoutTransparency(int screenOffset = -1);
+ void initBackSurface();
+ };
+
+private:
+ RL2AudioTrack *_audioTrack;
+ RL2VideoTrack *_videoTrack;
+ Common::SeekableReadStream *_fileStream;
+ Audio::Mixer::SoundType _soundType;
+ RL2FileHeader _header;
+ int _paletteStart;
+ Common::Array<SoundFrame> _soundFrames;
+ int _soundFrameNumber;
+ const Common::List<Common::Rect> *getDirtyRects() const;
+
+ void clearDirtyRects();
+ void copyDirtyRectsToBuffer(uint8 *dst, uint pitch);
+ int getPaletteStart() const { return _paletteStart; }
+ const RL2FileHeader &getHeader() { return _header; }
+ virtual void readNextPacket();
+ virtual bool seekIntern(const Audio::Timestamp &time);
+
+public:
+ RL2Decoder(Audio::Mixer::SoundType soundType = Audio::Mixer::kPlainSoundType);
+ virtual ~RL2Decoder();
+
+ virtual void close();
+
+ bool loadStream(Common::SeekableReadStream *stream);
+ bool loadFile(const Common::String &file, bool palFlag = false);
+ bool loadVideo(int videoId);
+ int getPaletteCount() const { return _header._colorCount; }
+
+ /**
+ * Play back a given Voyeur RL2 video
+ * @param vm Engine reference
+ * @param resourceOffset Starting resource to use for frame pictures
+ * @param frames Optional frame numbers resource for when to apply image data
+ * @param imgPos Position to draw image data
+ */
+ void play(VoyeurEngine *vm, int resourceOffset = 0, byte *frames = NULL, byte *imgPos = NULL);
+ RL2VideoTrack *getVideoTrack() { return _videoTrack; }
+ RL2AudioTrack *getAudioTrack() { return _audioTrack; }
+};
+
+} // End of namespace Voyeur
+
+#endif /* VOYEUR_ANIMATION_H */
diff --git a/engines/voyeur/configure.engine b/engines/voyeur/configure.engine
new file mode 100644
index 0000000000..23891fccb7
--- /dev/null
+++ b/engines/voyeur/configure.engine
@@ -0,0 +1,4 @@
+
+# This file is included from the main "configure" script
+# add_engine [name] [desc] [build-by-default] [subengines] [base games] [deps]
+add_engine voyeur "Voyeur" no
diff --git a/engines/voyeur/data.cpp b/engines/voyeur/data.cpp
new file mode 100644
index 0000000000..3a7c75fc2e
--- /dev/null
+++ b/engines/voyeur/data.cpp
@@ -0,0 +1,359 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "voyeur/data.h"
+#include "voyeur/voyeur.h"
+
+namespace Voyeur {
+
+void VoyeurEvent::synchronize(Common::Serializer &s) {
+ s.syncAsByte(_hour);
+ s.syncAsByte(_minute);
+ s.syncAsByte(_isAM);
+ s.syncAsByte(_type);
+ s.syncAsSint16LE(_audioVideoId);
+ s.syncAsSint16LE(_computerOn);
+ s.syncAsSint16LE(_computerOff);
+ s.syncAsSint16LE(_dead);
+}
+
+/*------------------------------------------------------------------------*/
+
+SVoy::SVoy() {
+ // Initialize all the data fields
+ _abortInterface = false;
+ _fadeICF0 = false;
+ _isAM = false;
+ Common::fill(&_phoneCallsReceived[0], &_phoneCallsReceived[5], false);
+ Common::fill(&_roomHotspotsEnabled[0], &_roomHotspotsEnabled[20], false);
+ _victimMurdered = false;
+
+ _audioVisualStartTime = 0;
+ _audioVisualDuration = 0;
+ _boltGroupId2 = 0;
+ _computerTextId = 0;
+ _computerTimeMin = _computerTimeMax = 0;
+ _curICF0 = 0;
+ _eventCount = 0;
+ _fadingStep1 = 0;
+ _fadingStep2 = 0;
+ _fadingType = 0;
+ _incriminatedVictimNumber = 0;
+ _musicStartTime = 0;
+ _playStampMode = 0;
+ _switchBGNum = 0;
+ _transitionId = 0;
+ _victimNumber = 0;
+ _videoEventId = 0;
+ _vocSecondsOffset = 0;
+ _RTANum = 0;
+ _RTVLimit = 0;
+ _RTVNum = 0;
+ _viewBounds = nullptr;
+ Common::fill(&_evPicPtrs[0], &_evPicPtrs[6], (PictureResource *)nullptr);
+ Common::fill(&_evCmPtrs[0], &_evCmPtrs[6], (CMapResource *)nullptr);
+ _curICF1 = 0;
+ _policeEvent = 0;
+
+ _eventFlags = EVTFLAG_TIME_DISABLED;
+ _fadingAmount1 = _fadingAmount2 = 127;
+ _murderThreshold = 9999;
+ _aptLoadMode = -1;
+ _eventFlags |= EVTFLAG_100;
+ _totalPhoneCalls = 0;
+}
+
+void SVoy::setVm(VoyeurEngine *vm) {
+ _vm = vm;
+}
+
+void SVoy::addEvent(int hour, int minute, VoyeurEventType type, int audioVideoId,
+ int on, int off, int dead) {
+ VoyeurEvent &e = _events[_eventCount++];
+
+ e._type = type;
+ e._hour = hour;
+ e._minute = minute;
+ e._isAM = hour < 12;
+ e._audioVideoId = audioVideoId;
+ e._computerOn = on;
+ e._computerOff = off;
+ e._dead = dead;
+}
+
+void SVoy::synchronize(Common::Serializer &s) {
+ s.syncAsByte(_isAM);
+ s.syncAsSint16LE(_RTANum);
+ s.syncAsSint16LE(_RTVNum);
+ s.syncAsSint16LE(_switchBGNum);
+
+ _videoHotspotTimes.synchronize(s);
+ _audioHotspotTimes.synchronize(s);
+ _evidenceHotspotTimes.synchronize(s);
+
+ for (int idx = 0; idx < 20; ++idx) {
+ s.syncAsByte(_roomHotspotsEnabled[idx]);
+ }
+
+ s.syncAsSint16LE(_audioVisualStartTime);
+ s.syncAsSint16LE(_audioVisualDuration);
+ s.syncAsSint16LE(_vocSecondsOffset);
+ s.syncAsSint16LE(_abortInterface);
+ s.syncAsSint16LE(_playStampMode);
+ s.syncAsSint16LE(_aptLoadMode);
+ s.syncAsSint16LE(_transitionId);
+ s.syncAsSint16LE(_RTVLimit);
+ s.syncAsSint16LE(_eventFlags);
+ s.syncAsSint16LE(_boltGroupId2);
+
+ s.syncAsSint16LE(_musicStartTime);
+ s.syncAsSint16LE(_totalPhoneCalls);
+ s.syncAsSint16LE(_computerTextId);
+ s.syncAsSint16LE(_computerTimeMin);
+ s.syncAsSint16LE(_computerTimeMax);
+ s.syncAsSint16LE(_victimMurdered);
+ s.syncAsSint16LE(_murderThreshold);
+
+ // Events
+ s.syncAsUint16LE(_eventCount);
+ for (int idx = 0; idx < _eventCount; ++idx)
+ _events[idx].synchronize(s);
+
+ s.syncAsSint16LE(_fadingAmount1);
+ s.syncAsSint16LE(_fadingAmount2);
+ s.syncAsSint16LE(_fadingStep1);
+ s.syncAsSint16LE(_fadingStep2);
+ s.syncAsSint16LE(_fadingType);
+ s.syncAsSint16LE(_victimNumber);
+ s.syncAsSint16LE(_incriminatedVictimNumber);
+ s.syncAsSint16LE(_videoEventId);
+
+ if (s.isLoading()) {
+ // Reset apartment loading mode to initial game value
+ _aptLoadMode = 140;
+ _viewBounds = nullptr;
+ }
+}
+
+void SVoy::addVideoEventStart() {
+ VoyeurEvent &e = _events[_eventCount];
+ e._hour = _vm->_gameHour;
+ e._minute = _vm->_gameMinute;
+ e._isAM = _isAM;
+ e._type = EVTYPE_VIDEO;
+ e._audioVideoId = _vm->_audioVideoId;
+ e._computerOn = _vocSecondsOffset;
+ e._dead = _vm->_eventsManager._videoDead;
+}
+
+void SVoy::addVideoEventEnd() {
+ VoyeurEvent &e = _events[_eventCount];
+ e._computerOff = _RTVNum - _audioVisualStartTime - _vocSecondsOffset;
+ if (_eventCount < (TOTAL_EVENTS - 1))
+ ++_eventCount;
+}
+
+void SVoy::addAudioEventStart() {
+ VoyeurEvent &e = _events[_eventCount];
+ e._hour = _vm->_gameHour;
+ e._minute = _vm->_gameMinute;
+ e._isAM = _isAM;
+ e._type = EVTYPE_AUDIO;
+ e._audioVideoId = _vm->_audioVideoId;
+ e._computerOn = _vocSecondsOffset;
+ e._dead = _vm->_eventsManager._videoDead;
+}
+
+void SVoy::addAudioEventEnd() {
+ VoyeurEvent &e = _events[_eventCount];
+ e._computerOff = _RTVNum - _audioVisualStartTime - _vocSecondsOffset;
+ if (_eventCount < (TOTAL_EVENTS - 1))
+ ++_eventCount;
+}
+
+void SVoy::addEvidEventStart(int v) {
+ VoyeurEvent &e = _events[_eventCount];
+ e._hour = _vm->_gameHour;
+ e._minute = _vm->_gameMinute;
+ e._isAM = _isAM;
+ e._type = EVTYPE_EVID;
+ e._audioVideoId = _vm->_playStampGroupId;
+ e._computerOn = _boltGroupId2;
+ e._computerOff = v;
+}
+
+void SVoy::addEvidEventEnd(int totalPages) {
+ VoyeurEvent &e = _events[_eventCount];
+ e._dead = totalPages;
+ if (_eventCount < (TOTAL_EVENTS - 1))
+ ++_eventCount;
+}
+
+void SVoy::addComputerEventStart() {
+ VoyeurEvent &e = _events[_eventCount];
+ e._hour = _vm->_gameHour;
+ e._minute = _vm->_gameMinute;
+ e._isAM = _isAM;
+ e._type = EVTYPE_COMPUTER;
+ e._audioVideoId = _vm->_playStampGroupId;
+ e._computerOn = _computerTextId;
+}
+
+void SVoy::addComputerEventEnd(int v) {
+ VoyeurEvent &e = _events[_eventCount];
+ e._computerOff = v;
+ if (_eventCount < (TOTAL_EVENTS - 1))
+ ++_eventCount;
+}
+
+void SVoy::reviewAnEvidEvent(int eventIndex) {
+ VoyeurEvent &e = _events[eventIndex];
+ _vm->_playStampGroupId = e._audioVideoId;
+ _boltGroupId2 = e._computerOn;
+ int frameOff = e._computerOff;
+
+ if (_vm->_bVoy->getBoltGroup(_vm->_playStampGroupId)) {
+ _vm->_graphicsManager._backColors = _vm->_bVoy->boltEntry(_vm->_playStampGroupId + 1)._cMapResource;
+ _vm->_graphicsManager._backgroundPage = _vm->_bVoy->boltEntry(_vm->_playStampGroupId)._picResource;
+ (*_vm->_graphicsManager._vPort)->setupViewPort(_vm->_graphicsManager._backgroundPage);
+ _vm->_graphicsManager._backColors->startFade();
+
+ _vm->doEvidDisplay(frameOff, e._dead);
+ _vm->_bVoy->freeBoltGroup(_vm->_playStampGroupId);
+ _vm->_playStampGroupId = -1;
+
+ if (_boltGroupId2 != -1) {
+ _vm->_bVoy->freeBoltGroup(_boltGroupId2);
+ _boltGroupId2 = -1;
+ }
+ }
+}
+
+void SVoy::reviewComputerEvent(int eventIndex) {
+ VoyeurEvent &e = _events[eventIndex];
+ _vm->_playStampGroupId = e._audioVideoId;
+ _computerTextId = e._computerOn;
+
+ if (_vm->_bVoy->getBoltGroup(_vm->_playStampGroupId)) {
+ _vm->_graphicsManager._backColors = _vm->_bVoy->boltEntry(_vm->_playStampGroupId + 1)._cMapResource;
+ _vm->_graphicsManager._backgroundPage = _vm->_bVoy->boltEntry(_vm->_playStampGroupId)._picResource;
+ (*_vm->_graphicsManager._vPort)->setupViewPort(_vm->_graphicsManager._backgroundPage);
+ _vm->_graphicsManager._backColors->startFade();
+ _vm->flipPageAndWaitForFade();
+
+ _vm->getComputerBrush();
+ _vm->flipPageAndWait();
+ _vm->doComputerText(e._computerOff);
+
+ _vm->_bVoy->freeBoltGroup(0x4900);
+ _vm->_bVoy->freeBoltGroup(_vm->_playStampGroupId);
+ _vm->_playStampGroupId = -1;
+ }
+}
+
+bool SVoy::checkForKey() {
+ _vm->_controlPtr->_state->_victimEvidenceIndex = 0;
+ if (_vm->_voy._victimMurdered)
+ return false;
+
+ for (int eventIdx = 0; eventIdx < _eventCount; ++eventIdx) {
+ VoyeurEvent &e = _events[eventIdx];
+
+ switch (e._type) {
+ case EVTYPE_VIDEO:
+ switch (_vm->_controlPtr->_state->_victimIndex) {
+ case 1:
+ if (e._audioVideoId == 33 && e._computerOn < 2 && e._computerOff >= 38)
+ _vm->_controlPtr->_state->_victimEvidenceIndex = 1;
+ break;
+
+ case 2:
+ if (e._audioVideoId == 47 && e._computerOn < 2 && e._computerOff >= 9)
+ _vm->_controlPtr->_state->_victimEvidenceIndex = 2;
+ break;
+
+ case 3:
+ if (e._audioVideoId == 46 && e._computerOn < 2 && e._computerOff > 2)
+ _vm->_controlPtr->_state->_victimEvidenceIndex = 3;
+ break;
+
+ case 4:
+ if (e._audioVideoId == 40 && e._computerOn < 2 && e._computerOff > 6)
+ _vm->_controlPtr->_state->_victimEvidenceIndex = 4;
+ break;
+
+ default:
+ break;
+ }
+ break;
+
+ case EVTYPE_AUDIO:
+ switch (_vm->_controlPtr->_state->_victimIndex) {
+ case 1:
+ if (e._audioVideoId == 8 && e._computerOn < 2 && e._computerOff > 26)
+ _vm->_controlPtr->_state->_victimEvidenceIndex = 1;
+ break;
+
+ case 3:
+ if (e._audioVideoId == 20 && e._computerOn < 2 && e._computerOff > 28)
+ _vm->_controlPtr->_state->_victimEvidenceIndex = 3;
+ if (e._audioVideoId == 35 && e._computerOn < 2 && e._computerOff > 18)
+ _vm->_controlPtr->_state->_victimEvidenceIndex = 3;
+ break;
+
+ default:
+ break;
+ }
+ break;
+
+ case EVTYPE_EVID:
+ switch (_vm->_controlPtr->_state->_victimIndex) {
+ case 4:
+ if (e._audioVideoId == 0x2400 && e._computerOn == 0x4f00 && e._computerOff == 17)
+ _vm->_controlPtr->_state->_victimEvidenceIndex = 4;
+
+ default:
+ break;
+ }
+ break;
+
+ case EVTYPE_COMPUTER:
+ switch (_vm->_controlPtr->_state->_victimIndex) {
+ case 2:
+ if (e._computerOn == 13 && e._computerOff > 76)
+ _vm->_controlPtr->_state->_victimEvidenceIndex = 2;
+ break;
+
+ default:
+ break;
+ }
+ break;
+ }
+
+ if (_vm->_controlPtr->_state->_victimEvidenceIndex == _vm->_controlPtr->_state->_victimIndex)
+ return true;
+ }
+
+ return false;
+}
+
+} // End of namespace Voyeur
diff --git a/engines/voyeur/data.h b/engines/voyeur/data.h
new file mode 100644
index 0000000000..8eb11ff390
--- /dev/null
+++ b/engines/voyeur/data.h
@@ -0,0 +1,231 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef VOYEUR_DATA_H
+#define VOYEUR_DATA_H
+
+#include "common/scummsys.h"
+#include "common/serializer.h"
+#include "voyeur/files.h"
+
+namespace Voyeur {
+
+#define TOTAL_EVENTS 1000
+
+enum VoyeurEventType { EVTYPE_VIDEO = 1, EVTYPE_AUDIO = 2, EVTYPE_EVID = 3,
+ EVTYPE_COMPUTER = 4 };
+
+enum EventFlag { EVTFLAG_TIME_DISABLED = 1, EVTFLAG_2 = 2, EVTFLAG_8 = 8, EVTFLAG_RECORDING = 0x10,
+ EVTFLAG_40 = 0x40, EVTFLAG_VICTIM_PRESET = 0x80, EVTFLAG_100 = 0x100 };
+
+struct VoyeurEvent {
+ int _hour;
+ int _minute;
+ bool _isAM;
+ VoyeurEventType _type;
+ int _audioVideoId;
+ int _computerOn;
+ int _computerOff;
+ int _dead;
+
+ void synchronize(Common::Serializer &s);
+};
+
+class VoyeurEngne;
+
+/**
+ * Encapsulates a list of the time expired ranges that hotspots in the mansion
+ * view are enabled for in a given time period.
+ */
+template<int SLOTS>
+class HotspotTimes {
+public:
+ int _min[SLOTS][20]; // Min time expired
+ int _max[SLOTS][20]; // Max time expired
+
+ HotspotTimes() {
+ reset();
+ }
+
+ /**
+ * Resets the data to an initial state
+ */
+ void reset() {
+ for (int hotspotIdx = 0; hotspotIdx < 20; ++hotspotIdx) {
+ for (int slotIdx = 0; slotIdx < SLOTS; ++slotIdx) {
+ _min[slotIdx][hotspotIdx] = 9999;
+ _max[slotIdx][hotspotIdx] = 0;
+ }
+ }
+ }
+
+ /**
+ * Synchronise the data
+ */
+ void synchronize(Common::Serializer &s) {
+ for (int slotIndex = 0; slotIndex < SLOTS; ++slotIndex) {
+ for (int hotspotIndex = 0; hotspotIndex < 20; ++hotspotIndex) {
+ s.syncAsSint16LE(_min[slotIndex][hotspotIndex]);
+ s.syncAsSint16LE(_max[slotIndex][hotspotIndex]);
+ }
+ }
+ }
+
+ /**
+ * Returns true if the given value is in the range specified by the
+ * min and max at the given hotspot and slot indexes
+ */
+ bool isInRange(int slotIndex, int hotspotIndex, int v) const {
+ return _min[slotIndex][hotspotIndex] <= v &&
+ v < _max[slotIndex][hotspotIndex];
+ }
+};
+
+class SVoy {
+private:
+ VoyeurEngine *_vm;
+
+public:
+ bool _abortInterface;
+ bool _fadeICF0; // Useless variable? (always the same value)
+ bool _isAM;
+ bool _phoneCallsReceived[5];
+ bool _roomHotspotsEnabled[20];
+ bool _victimMurdered;
+
+ int _aptLoadMode;
+ int _audioVisualStartTime;
+ int _audioVisualDuration;
+ int _boltGroupId2;
+ int _computerTextId;
+ int _computerTimeMin;
+ int _computerTimeMax;
+ int _curICF0; // Useless variable
+ int _eventCount;
+ int _eventFlags;
+ int _fadingAmount1;
+ int _fadingAmount2;
+ int _fadingStep1;
+ int _fadingStep2;
+ int _fadingType;
+ int _incriminatedVictimNumber;
+ int _murderThreshold;
+ int _musicStartTime;
+ int _playStampMode;
+ int _switchBGNum;
+ int _totalPhoneCalls;
+ int _transitionId;
+ int _victimNumber;
+ int _videoEventId;
+ int _vocSecondsOffset;
+ int _RTANum;
+ int _RTVLimit;
+ int _RTVNum;
+
+ HotspotTimes<3> _audioHotspotTimes;
+ HotspotTimes<3> _evidenceHotspotTimes;
+ HotspotTimes<8> _videoHotspotTimes;
+
+ Common::Rect _rect4E4;
+ RectResource *_viewBounds;
+ PictureResource *_evPicPtrs[6];
+ CMapResource *_evCmPtrs[6];
+ VoyeurEvent _events[TOTAL_EVENTS];
+
+ SVoy();
+ void setVm(VoyeurEngine *vm);
+
+ /**
+ * Synchronise the data
+ */
+ void synchronize(Common::Serializer &s);
+
+ /**
+ * Add an event to the list of game events that have occurred
+ */
+ void addEvent(int hour, int minute, VoyeurEventType type, int audioVideoId,
+ int on, int off, int dead);
+
+ /**
+ * Adds the start of a video event happening
+ */
+ void addVideoEventStart();
+
+ /**
+ * Adds the finish of a video event happening
+ */
+ void addVideoEventEnd();
+
+ /**
+ * Adds the start of an audio event happening
+ */
+ void addAudioEventStart();
+
+ /**
+ * Adsd the finish of an audio event happening
+ */
+ void addAudioEventEnd();
+
+ /**
+ * Adds the start of an evidence event happening
+ */
+ void addEvidEventStart(int v);
+
+ /**
+ * Adds the finish of an evidence event happening
+ */
+ void addEvidEventEnd(int totalPages);
+
+ /**
+ * Adds the start of a computer event happening
+ */
+ void addComputerEventStart();
+
+ /**
+ * Adds the finish of a computer event happening
+ */
+ void addComputerEventEnd(int v);
+
+ /**
+ * Review a previously recorded evidence event
+ */
+ void reviewAnEvidEvent(int eventIndex);
+
+ /**
+ * Review a previously recorded computer event
+ */
+ void reviewComputerEvent(int eventIndex);
+
+ /**
+ * Checks for key information in determining what kind of murder
+ * should take place
+ */
+ bool checkForKey();
+
+private:
+ int _curICF1; // Useless variable
+ int _policeEvent;
+};
+
+} // End of namespace Voyeur
+
+#endif /* VOYEUR_DATA_H */
diff --git a/engines/voyeur/debugger.cpp b/engines/voyeur/debugger.cpp
new file mode 100644
index 0000000000..b1bc2633ee
--- /dev/null
+++ b/engines/voyeur/debugger.cpp
@@ -0,0 +1,148 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "voyeur/debugger.h"
+#include "voyeur/graphics.h"
+#include "voyeur/voyeur.h"
+#include "voyeur/staticres.h"
+
+namespace Voyeur {
+
+Debugger::Debugger() : GUI::Debugger() {
+ // Register methods
+ DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit));
+ DCmd_Register("exit", WRAP_METHOD(Debugger, Cmd_Exit));
+ DCmd_Register("time", WRAP_METHOD(Debugger, Cmd_Time));
+ DCmd_Register("hotspots", WRAP_METHOD(Debugger, Cmd_Hotspots));
+ DCmd_Register("mouse", WRAP_METHOD(Debugger, Cmd_Mouse));
+
+ // Set fields
+ _isTimeActive = true;
+ _showMousePosition = false;
+}
+
+static const int TIME_STATES[] = {
+ 0, 31, 0, 43, 59, 0, 67, 75, 85, 93, 0, 0, 111, 121, 0, 0
+};
+
+bool Debugger::Cmd_Time(int argc, const char **argv) {
+ if (argc < 2) {
+ // Get the current day and time of day
+ Common::String dtString = _vm->getDayName();
+ Common::String timeString = _vm->getTimeOfDay();
+ if (!timeString.empty())
+ dtString += " " + timeString;
+
+ DebugPrintf("Time period = %d, date/time is: %s, time is %s\n",
+ _vm->_voy._transitionId, dtString.c_str(), _isTimeActive ? "on" : "off");
+ DebugPrintf("Format: %s [on | off | 1..17 | val <amount>]\n\n", argv[0]);
+ } else {
+ if (!strcmp(argv[1], "on")) {
+ _isTimeActive = true;
+ DebugPrintf("Time is now on\n\n");
+ } else if (!strcmp(argv[1], "off")) {
+ _isTimeActive = false;
+ DebugPrintf("Time is now off\n\n");
+ } else if (!strcmp(argv[1], "val")) {
+ if (argc < 3) {
+ DebugPrintf("Time expired is currently %d.\n", _vm->_voy._RTVNum);
+ } else {
+ _vm->_voy._RTVNum = atoi(argv[2]);
+ DebugPrintf("Time expired is now %d.\n", _vm->_voy._RTVNum);
+ }
+ } else {
+ int timeId = atoi(argv[1]);
+ if (timeId >= 1 && timeId <= 17) {
+ int stateId = TIME_STATES[timeId - 1];
+ if (!stateId) {
+ DebugPrintf("Given time period is not used in-game\n");
+ } else {
+ DebugPrintf("Changing to time period: %d\n", timeId);
+ if (_vm->_mainThread->goToState(-1, stateId))
+ _vm->_mainThread->parsePlayCommands();
+
+ return false;
+ }
+ } else {
+ DebugPrintf("Unknown parameter\n\n");
+ }
+ }
+ }
+
+ return true;
+}
+
+bool Debugger::Cmd_Hotspots(int argc, const char **argv) {
+ BoltEntry &boltEntry = _vm->_bVoy->boltEntry(_vm->_playStampGroupId + 1);
+ if (!boltEntry._rectResource) {
+ DebugPrintf("No hotspots available\n");
+ } else {
+ Common::Array<RectEntry> &hotspots = boltEntry._rectResource->_entries;
+
+ for (uint hotspotIdx = 0; hotspotIdx < hotspots.size(); ++hotspotIdx) {
+ Common::String pos = Common::String::format("(%d,%d->%d,%d)",
+ hotspots[hotspotIdx].left, hotspots[hotspotIdx].top,
+ hotspots[hotspotIdx].right, hotspots[hotspotIdx].bottom);
+
+ for (int arrIndex = 0; arrIndex < 3; ++arrIndex) {
+ if (_vm->_voy._audioHotspotTimes._min[arrIndex][hotspotIdx] != 9999) {
+ DebugPrintf("Hotspot %d %s Audio slot %d, time: %d to %d\n",
+ hotspotIdx, pos.c_str(), arrIndex,
+ _vm->_voy._audioHotspotTimes._min[arrIndex][hotspotIdx],
+ _vm->_voy._audioHotspotTimes._max[arrIndex][hotspotIdx]);
+ }
+
+ if (_vm->_voy._evidenceHotspotTimes._min[arrIndex][hotspotIdx] != 9999) {
+ DebugPrintf("Hotspot %d %s Evidence slot %d, time: %d to %d\n",
+ hotspotIdx, pos.c_str(), arrIndex,
+ _vm->_voy._evidenceHotspotTimes._min[arrIndex][hotspotIdx],
+ _vm->_voy._evidenceHotspotTimes._max[arrIndex][hotspotIdx]);
+ }
+ }
+
+ for (int arrIndex = 0; arrIndex < 8; ++arrIndex) {
+ if (_vm->_voy._videoHotspotTimes._min[arrIndex][hotspotIdx] != 9999) {
+ DebugPrintf("Hotspot %d %s Video slot %d, time: %d to %d\n",
+ hotspotIdx, pos.c_str(), arrIndex,
+ _vm->_voy._videoHotspotTimes._min[arrIndex][hotspotIdx],
+ _vm->_voy._videoHotspotTimes._max[arrIndex][hotspotIdx]);
+ }
+ }
+ }
+ }
+
+ DebugPrintf("\n");
+ return true;
+}
+
+bool Debugger::Cmd_Mouse(int argc, const char **argv) {
+ if (argc < 2) {
+ DebugPrintf("mouse [ on | off ]\n");
+ } else {
+ _showMousePosition = !strcmp(argv[1], "on");
+ DebugPrintf("Mouse position is now %s\n", _showMousePosition ? "on" : "off");
+ }
+
+ return true;
+}
+
+} // End of namespace Voyeur
diff --git a/engines/voyeur/debugger.h b/engines/voyeur/debugger.h
new file mode 100644
index 0000000000..43eaa5f474
--- /dev/null
+++ b/engines/voyeur/debugger.h
@@ -0,0 +1,72 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef VOYEUR_DEBUGGER_H
+#define VOYEUR_DEBUGGER_H
+
+#include "common/scummsys.h"
+#include "gui/debugger.h"
+
+namespace Voyeur {
+
+class VoyeurEngine;
+
+class Debugger : public GUI::Debugger {
+private:
+ VoyeurEngine *_vm;
+public:
+ /**
+ * Specifies whether time should pass, and the video camera's batteries go down
+ * @default true
+ */
+ bool _isTimeActive;
+
+ /*
+ * Specifies whether to show the current mouse position on the screen
+ */
+ bool _showMousePosition;
+protected:
+ /**
+ * Turn time on or off, set the current time period, or the camera delay
+ * within the current time period.
+ */
+ bool Cmd_Time(int argc, const char **argv);
+
+ /**
+ * List the active hotspots during the current time period
+ */
+ bool Cmd_Hotspots(int argc, const char **argv);
+
+ /**
+ * Toggle showing the mouse on the screen
+ */
+ bool Cmd_Mouse(int argc, const char **argv);
+public:
+ Debugger();
+ virtual ~Debugger() {}
+ void setVm(VoyeurEngine *vm) { _vm = vm; }
+
+};
+
+} // End of namespace Voyeur
+
+#endif
diff --git a/engines/voyeur/detection.cpp b/engines/voyeur/detection.cpp
new file mode 100644
index 0000000000..ab3932bea1
--- /dev/null
+++ b/engines/voyeur/detection.cpp
@@ -0,0 +1,182 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ *
+ */
+
+#include "voyeur/voyeur.h"
+
+#include "base/plugins.h"
+#include "common/savefile.h"
+#include "common/str-array.h"
+#include "common/memstream.h"
+#include "engines/advancedDetector.h"
+#include "common/system.h"
+#include "graphics/colormasks.h"
+#include "graphics/surface.h"
+
+#define MAX_SAVES 99
+
+namespace Voyeur {
+
+struct VoyeurGameDescription {
+ ADGameDescription desc;
+};
+
+uint32 VoyeurEngine::getFeatures() const {
+ return _gameDescription->desc.flags;
+}
+
+Common::Language VoyeurEngine::getLanguage() const {
+ return _gameDescription->desc.language;
+}
+
+Common::Platform VoyeurEngine::getPlatform() const {
+ return _gameDescription->desc.platform;
+}
+
+bool VoyeurEngine::getIsDemo() const {
+ return _gameDescription->desc.flags & ADGF_DEMO;
+}
+
+} // End of namespace Voyeur
+
+static const PlainGameDescriptor voyeurGames[] = {
+ {"voyeur", "Voyeur"},
+ {0, 0}
+};
+
+#include "voyeur/detection_tables.h"
+
+class VoyeurMetaEngine : public AdvancedMetaEngine {
+public:
+ VoyeurMetaEngine() : AdvancedMetaEngine(Voyeur::gameDescriptions, sizeof(Voyeur::VoyeurGameDescription), voyeurGames) {
+ _maxScanDepth = 3;
+ }
+
+ virtual const char *getName() const {
+ return "Voyeur Engine";
+ }
+
+ virtual const char *getOriginalCopyright() const {
+ return "Voyeur (c) Philips P.O.V. Entertainment Group";
+ }
+
+ virtual bool hasFeature(MetaEngineFeature f) const;
+ virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const;
+ virtual SaveStateList listSaves(const char *target) const;
+ virtual int getMaximumSaveSlot() const;
+ virtual void removeSaveState(const char *target, int slot) const;
+ SaveStateDescriptor querySaveMetaInfos(const char *target, int slot) const;
+};
+
+bool VoyeurMetaEngine::hasFeature(MetaEngineFeature f) const {
+ return
+ (f == kSupportsListSaves) ||
+ (f == kSupportsLoadingDuringStartup) ||
+ (f == kSupportsDeleteSave) ||
+ (f == kSavesSupportMetaInfo) ||
+ (f == kSavesSupportThumbnail);
+}
+
+bool Voyeur::VoyeurEngine::hasFeature(EngineFeature f) const {
+ return
+ (f == kSupportsRTL) ||
+ (f == kSupportsLoadingDuringRuntime) ||
+ (f == kSupportsSavingDuringRuntime);
+}
+
+bool VoyeurMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const {
+ const Voyeur::VoyeurGameDescription *gd = (const Voyeur::VoyeurGameDescription *)desc;
+ if (gd) {
+ *engine = new Voyeur::VoyeurEngine(syst, gd);
+ }
+ return gd != 0;
+}
+
+SaveStateList VoyeurMetaEngine::listSaves(const char *target) const {
+ Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
+ Common::StringArray filenames;
+ Common::String saveDesc;
+ Common::String pattern = Common::String::format("%s.0??", target);
+
+ filenames = saveFileMan->listSavefiles(pattern);
+ sort(filenames.begin(), filenames.end()); // Sort to get the files in numerical order
+
+ SaveStateList saveList;
+ Voyeur::VoyeurSavegameHeader header;
+
+ for (Common::StringArray::const_iterator file = filenames.begin(); file != filenames.end(); ++file) {
+ const char *ext = strrchr(file->c_str(), '.');
+ int slot = ext ? atoi(ext + 1) : -1;
+
+ if (slot >= 0 && slot <= MAX_SAVES) {
+ Common::InSaveFile *in = g_system->getSavefileManager()->openForLoading(*file);
+
+ if (in) {
+ if (header.read(in)) {
+ saveList.push_back(SaveStateDescriptor(slot, header._saveName));
+ header._thumbnail->free();
+ }
+ delete in;
+ }
+ }
+ }
+
+ return saveList;
+}
+
+int VoyeurMetaEngine::getMaximumSaveSlot() const {
+ return MAX_SAVES;
+}
+
+void VoyeurMetaEngine::removeSaveState(const char *target, int slot) const {
+ Common::String filename = Common::String::format("%s.%03d", target, slot);
+ g_system->getSavefileManager()->removeSavefile(filename);
+}
+
+SaveStateDescriptor VoyeurMetaEngine::querySaveMetaInfos(const char *target, int slot) const {
+ Common::String filename = Common::String::format("%s.%03d", target, slot);
+ Common::InSaveFile *f = g_system->getSavefileManager()->openForLoading(filename);
+
+ if (f) {
+ Voyeur::VoyeurSavegameHeader header;
+ header.read(f);
+ delete f;
+
+ // Create the return descriptor
+ SaveStateDescriptor desc(slot, header._saveName);
+ desc.setThumbnail(header._thumbnail);
+ desc.setSaveDate(header._saveYear, header._saveMonth, header._saveDay);
+ desc.setSaveTime(header._saveHour, header._saveMinutes);
+ desc.setPlayTime(header._totalFrames * GAME_FRAME_TIME);
+
+ return desc;
+ }
+
+ return SaveStateDescriptor();
+}
+
+
+#if PLUGIN_ENABLED_DYNAMIC(VOYEUR)
+ REGISTER_PLUGIN_DYNAMIC(VOYEUR, PLUGIN_TYPE_ENGINE, VoyeurMetaEngine);
+#else
+ REGISTER_PLUGIN_STATIC(VOYEUR, PLUGIN_TYPE_ENGINE, VoyeurMetaEngine);
+#endif
diff --git a/engines/voyeur/detection_tables.h b/engines/voyeur/detection_tables.h
new file mode 100644
index 0000000000..af0faf6acb
--- /dev/null
+++ b/engines/voyeur/detection_tables.h
@@ -0,0 +1,42 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+namespace Voyeur {
+
+static const VoyeurGameDescription gameDescriptions[] = {
+ {
+ // Voyeur DOS English
+ {
+ "voyeur",
+ 0,
+ AD_ENTRY1s("a1100100.rl2", "b44630677618d034970ca0a13c1c1237", 336361),
+ Common::EN_ANY,
+ Common::kPlatformDOS,
+ ADGF_NO_FLAGS,
+ GUIO1(GUIO_NONE)
+ },
+ },
+
+ { AD_TABLE_END_MARKER }
+};
+
+} // End of namespace Voyeur
diff --git a/engines/voyeur/events.cpp b/engines/voyeur/events.cpp
new file mode 100644
index 0000000000..3b2369c1e1
--- /dev/null
+++ b/engines/voyeur/events.cpp
@@ -0,0 +1,624 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "voyeur/events.h"
+#include "voyeur/voyeur.h"
+#include "voyeur/staticres.h"
+#include "common/events.h"
+#include "graphics/cursorman.h"
+#include "graphics/font.h"
+#include "graphics/fontman.h"
+#include "graphics/palette.h"
+
+namespace Voyeur {
+
+IntNode::IntNode() {
+ _intFunc = NULL;
+ _curTime = 0;
+ _timeReset = 0;
+ _flags = 0;
+}
+
+IntNode::IntNode(uint16 curTime, uint16 timeReset, uint16 flags) {
+ _intFunc = NULL;
+ _curTime = curTime;
+ _timeReset = timeReset;
+ _flags = flags;
+}
+
+/*------------------------------------------------------------------------*/
+
+IntData::IntData() {
+ _flipWait = false;
+ _hasPalette = false;
+ _flashTimer = 0;
+ _flashStep = 0;
+ field26 = 0;
+ _skipFading = false;
+ _palStartIndex = 0;
+ _palEndIndex = 0;
+ _palette = NULL;
+}
+
+/*------------------------------------------------------------------------*/
+
+EventsManager::EventsManager(): _intPtr(_gameData),
+ _fadeIntNode(0, 0, 3), _cycleIntNode(0, 0, 3) {
+ _cycleStatus = 0;
+ _mouseButton = 0;
+ _fadeStatus = 0;
+ _priorFrameTime = g_system->getMillis();
+ _gameCounter = 0;
+ _counterFlag = false;
+ _recordBlinkCounter = 0;
+ _cursorBlinked = false;
+
+ Common::fill(&_cycleTime[0], &_cycleTime[4], 0);
+ Common::fill(&_cycleNext[0], &_cycleNext[4], (byte *)nullptr);
+ _cyclePtr = NULL;
+
+ _leftClick = _rightClick = false;
+ _mouseClicked = _mouseUnk = false;
+ _newLeftClick = _newRightClick = false;;
+ _newMouseClicked = _newMouseUnk = false;
+
+ _videoDead = 0;
+}
+
+void EventsManager::resetMouse() {
+ // No implementation
+}
+
+void EventsManager::startMainClockInt() {
+ _mainIntNode._intFunc = &EventsManager::mainVoyeurIntFunc;
+ _mainIntNode._flags = 0;
+ _mainIntNode._curTime = 0;
+ _mainIntNode._timeReset = _vm->_graphicsManager._palFlag ? 50 : 60;
+}
+
+void EventsManager::mainVoyeurIntFunc() {
+ if (!(_vm->_voy._eventFlags & EVTFLAG_TIME_DISABLED)) {
+ ++_vm->_voy._switchBGNum;
+
+ if (_vm->_debugger._isTimeActive) {
+ // Increase camera discharge
+ ++_vm->_voy._RTVNum;
+
+ // If the murder threshold has been set, and is passed, then flag the victim
+ // as murdered, which prevents sending the tape from succeeding
+ if (_vm->_voy._RTVNum >= _vm->_voy._murderThreshold)
+ _vm->_voy._victimMurdered = true;
+ }
+ }
+}
+
+void EventsManager::sWaitFlip() {
+ Common::Array<ViewPortResource *> &viewPorts = _vm->_graphicsManager._viewPortListPtr->_entries;
+ for (uint idx = 0; idx < viewPorts.size(); ++idx) {
+ ViewPortResource &viewPort = *viewPorts[idx];
+
+ if (_vm->_graphicsManager._saveBack && (viewPort._flags & DISPFLAG_40)) {
+ Common::Rect *clipPtr = _vm->_graphicsManager._clipPtr;
+ _vm->_graphicsManager._clipPtr = &viewPort._clipRect;
+
+ if (viewPort._restoreFn)
+ (_vm->_graphicsManager.*viewPort._restoreFn)(&viewPort);
+
+ _vm->_graphicsManager._clipPtr = clipPtr;
+ viewPort._rectListCount[viewPort._pageIndex] = 0;
+ viewPort._rectListPtr[viewPort._pageIndex]->clear();
+ viewPort._flags &= ~DISPFLAG_40;
+ }
+ }
+
+ while (_gameData._flipWait && !_vm->shouldQuit()) {
+ pollEvents();
+ g_system->delayMillis(10);
+ }
+}
+
+void EventsManager::checkForNextFrameCounter() {
+ // Check for next game frame
+ uint32 milli = g_system->getMillis();
+ if ((milli - _priorFrameTime) >= GAME_FRAME_TIME) {
+ _counterFlag = !_counterFlag;
+ if (_counterFlag)
+ ++_gameCounter;
+ _priorFrameTime = milli;
+
+ // Run the timer-based updates
+ voyeurTimer();
+
+ if ((_gameCounter % GAME_FRAME_RATE) == 0)
+ mainVoyeurIntFunc();
+
+ // Give time to the debugger
+ _vm->_debugger.onFrame();
+
+ // If mouse position display is on, display the position
+ if (_vm->_debugger._showMousePosition)
+ showMousePosition();
+
+ // Display the frame
+ g_system->copyRectToScreen((byte *)_vm->_graphicsManager._screenSurface.getPixels(),
+ SCREEN_WIDTH, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
+ g_system->updateScreen();
+
+ // Signal the ScummVM debugger
+ _vm->_debugger.onFrame();
+ }
+}
+
+void EventsManager::showMousePosition() {
+ const Graphics::Font &font(*FontMan.getFontByUsage(Graphics::FontManager::kConsoleFont));
+ Common::String mousePos = Common::String::format("(%d,%d)", _mousePos.x, _mousePos.y);
+ if (_vm->_voyeurArea == AREA_INTERFACE) {
+ Common::Point pt = _mousePos + _vm->_mansionViewPos - Common::Point(40, 27);
+ if (pt.x < 0) pt.x = 0;
+ if (pt.y < 0) pt.y = 0;
+
+ mousePos += Common::String::format(" - (%d,%d)", pt.x, pt.y);
+ }
+
+ _vm->_graphicsManager._screenSurface.fillRect(
+ Common::Rect(0, 0, 110, font.getFontHeight()), 0);
+ font.drawString(&_vm->_graphicsManager._screenSurface, mousePos,
+ 0, 0, 110, 63);
+}
+
+void EventsManager::voyeurTimer() {
+ _gameData._flashTimer += _gameData._flashStep;
+
+ if (--_gameData.field26 <= 0) {
+ if (_gameData._flipWait) {
+ _gameData._flipWait = false;
+ _gameData._skipFading = false;
+ }
+
+ _gameData.field26 >>= 8;
+ }
+
+ videoTimer();
+
+ // Iterate through the list of registered nodes
+ Common::List<IntNode *>::iterator i;
+ for (i = _intNodes.begin(); i != _intNodes.end(); ++i) {
+ IntNode &node = **i;
+
+ if (node._flags & 1)
+ continue;
+ if (!(node._flags & 2)) {
+ if (--node._curTime != 0)
+ continue;
+
+ node._curTime = node._timeReset;
+ }
+
+ (this->*node._intFunc)();
+ }
+
+}
+
+void EventsManager::videoTimer() {
+ if (_gameData._hasPalette) {
+ _gameData._hasPalette = false;
+
+ g_system->getPaletteManager()->setPalette(_gameData._palette +
+ _gameData._palStartIndex * 3, _gameData._palStartIndex,
+ _gameData._palEndIndex - _gameData._palStartIndex + 1);
+ }
+}
+
+void EventsManager::delay(int cycles) {
+ uint32 totalMilli = cycles * 1000 / GAME_FRAME_RATE;
+ uint32 delayEnd = g_system->getMillis() + totalMilli;
+
+ while (!_vm->shouldQuit() && g_system->getMillis() < delayEnd) {
+ g_system->delayMillis(10);
+
+ pollEvents();
+ }
+}
+
+void EventsManager::delayClick(int cycles) {
+ uint32 totalMilli = cycles * 1000 / GAME_FRAME_RATE;
+ uint32 delayEnd = g_system->getMillis() + totalMilli;
+
+ do {
+ g_system->delayMillis(10);
+ getMouseInfo();
+ } while (!_vm->shouldQuit() && g_system->getMillis() < delayEnd
+ && !_vm->_eventsManager._mouseClicked);
+}
+
+void EventsManager::pollEvents() {
+ checkForNextFrameCounter();
+
+ Common::Event event;
+ while (g_system->getEventManager()->pollEvent(event)) {
+ // Handle keypress
+ switch (event.type) {
+ case Common::EVENT_QUIT:
+ case Common::EVENT_RTL:
+ case Common::EVENT_KEYUP:
+ return;
+
+ case Common::EVENT_KEYDOWN:
+ // Check for debugger
+ if (event.kbd.keycode == Common::KEYCODE_d && (event.kbd.flags & Common::KBD_CTRL)) {
+ // Attach to the debugger
+ _vm->_debugger.attach();
+ _vm->_debugger.onFrame();
+ }
+ return;
+ case Common::EVENT_LBUTTONDOWN:
+ _mouseButton = 1;
+ _vm->_eventsManager._newLeftClick = true;
+ _vm->_eventsManager._newMouseClicked = true;
+ return;
+ case Common::EVENT_RBUTTONDOWN:
+ _mouseButton = 2;
+ _vm->_eventsManager._newRightClick = true;
+ _vm->_eventsManager._newMouseClicked = true;
+ return;
+ case Common::EVENT_LBUTTONUP:
+ case Common::EVENT_RBUTTONUP:
+ _vm->_eventsManager._newMouseClicked = false;
+ _vm->_eventsManager._newLeftClick = false;
+ _vm->_eventsManager._newRightClick = false;
+ _mouseButton = 0;
+ return;
+ case Common::EVENT_MOUSEMOVE:
+ _mousePos = event.mouse;
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+void EventsManager::startFade(CMapResource *cMap) {
+ _fadeIntNode._flags |= 1;
+ if (_cycleStatus & 1)
+ _cycleIntNode._flags |= 1;
+
+ _fadeFirstCol = cMap->_start;
+ _fadeLastCol = cMap->_end;
+ _fadeCount = cMap->_steps + 1;
+
+ if (cMap->_steps > 0) {
+ _fadeStatus = cMap->_fadeStatus | 1;
+ byte *vgaP = &_vm->_graphicsManager._VGAColors[_fadeFirstCol * 3];
+ int mapIndex = 0;
+
+ for (int idx = _fadeFirstCol; idx <= _fadeLastCol; ++idx, vgaP += 3) {
+ ViewPortPalEntry &palEntry = _vm->_graphicsManager._viewPortListPtr->_palette[idx];
+ palEntry._rEntry = vgaP[0] << 8;
+ int rDiff = (cMap->_entries[mapIndex * 3] << 8) - palEntry._rEntry;
+ palEntry._rChange = rDiff / cMap->_steps;
+
+ palEntry._gEntry = vgaP[1] << 8;
+ int gDiff = (cMap->_entries[mapIndex * 3 + 1] << 8) - palEntry._gEntry;
+ palEntry._gChange = gDiff / cMap->_steps;
+
+ palEntry._bEntry = vgaP[2] << 8;
+ int bDiff = (cMap->_entries[mapIndex * 3 + 2] << 8) - palEntry._bEntry;
+ palEntry._bChange = bDiff / cMap->_steps;
+
+ palEntry._palIndex = idx;
+ if (!(cMap->_fadeStatus & 1))
+ ++mapIndex;
+ }
+
+ if (cMap->_fadeStatus & 2)
+ _intPtr._skipFading = true;
+ _fadeIntNode._flags &= ~1;
+ } else {
+ byte *vgaP = &_vm->_graphicsManager._VGAColors[_fadeFirstCol * 3];
+ int mapIndex = 0;
+
+ for (int idx = _fadeFirstCol; idx <= _fadeLastCol; ++idx, vgaP += 3) {
+ Common::copy(&cMap->_entries[mapIndex], &cMap->_entries[mapIndex + 3], vgaP);
+
+ if (!(cMap->_fadeStatus & 1))
+ mapIndex += 3;
+ }
+
+ if (_intPtr._palStartIndex > _fadeFirstCol)
+ _intPtr._palStartIndex = _fadeFirstCol;
+ if (_intPtr._palEndIndex < _fadeLastCol)
+ _intPtr._palEndIndex = _fadeLastCol;
+
+ _intPtr._hasPalette = true;
+ }
+
+ if (_cycleStatus & 1)
+ _cycleIntNode._flags &= ~1;
+}
+
+void EventsManager::addIntNode(IntNode *node) {
+ _intNodes.push_back(node);
+}
+
+void EventsManager::addFadeInt() {
+ IntNode &node = _fade2IntNode;
+ node._intFunc = &EventsManager::fadeIntFunc;
+ node._flags = 0;
+ node._curTime = 0;
+ node._timeReset = 1;
+
+ addIntNode(&node);
+}
+
+void EventsManager::vDoFadeInt() {
+ if (_intPtr._skipFading)
+ return;
+ if (--_fadeCount == 0) {
+ _fadeIntNode._flags |= 1;
+ _fadeStatus &= ~1;
+ return;
+ }
+
+
+ for (int i = _fadeFirstCol; i <= _fadeLastCol; ++i) {
+ ViewPortPalEntry &palEntry = _vm->_graphicsManager._viewPortListPtr->_palette[i];
+ byte *vgaP = &_vm->_graphicsManager._VGAColors[palEntry._palIndex * 3];
+
+ palEntry._rEntry += palEntry._rChange;
+ palEntry._gEntry += palEntry._gChange;
+ palEntry._bEntry += palEntry._bChange;
+
+ vgaP[0] = palEntry._rEntry >> 8;
+ vgaP[1] = palEntry._gEntry >> 8;
+ vgaP[2] = palEntry._bEntry >> 8;
+ }
+
+ if (_intPtr._palStartIndex > _fadeFirstCol)
+ _intPtr._palStartIndex = _fadeFirstCol;
+ if (_intPtr._palEndIndex < _fadeLastCol)
+ _intPtr._palEndIndex = _fadeLastCol;
+
+ _intPtr._hasPalette = true;
+}
+
+void EventsManager::vDoCycleInt() {
+ for (int idx = 3; idx >= 0; --idx) {
+ if (_cyclePtr->_type[idx] && --_cycleTime[idx] <= 0) {
+ byte *pSrc = _cycleNext[idx];
+ byte *pPal = _vm->_graphicsManager._VGAColors;
+
+ if (_cyclePtr->_type[idx] != 1) {
+ // New palette data being specified - loop to set entries
+ do {
+ int palIndex = READ_LE_UINT16(pSrc);
+ pPal[palIndex * 3] = pSrc[3];
+ pPal[palIndex * 3 + 1] = pSrc[4];
+ pPal[palIndex * 3 + 1] = pSrc[5];
+ pSrc += 6;
+
+ if ((int16)READ_LE_UINT16(pSrc) >= 0) {
+ // Resetting back to start of cycle data
+ pSrc = _cycleNext[idx];
+ break;
+ }
+ } while (*(pSrc + 2) == 0);
+
+ _cycleNext[idx] = pSrc;
+ _cycleTime[idx] = pSrc[2];
+ } else {
+ // Palette rotation to be done
+ _cycleTime[idx] = pSrc[4];
+
+ if (pSrc[5] == 1) {
+ // Move palette entry to end of range
+ int start = READ_LE_UINT16(pSrc);
+ int end = READ_LE_UINT16(&pSrc[2]);
+ assert(start < 0x100 && end < 0x100);
+
+ // Store the RGB of the first entry to be moved
+ byte r = pPal[start * 3];
+ byte g = pPal[start * 3 + 1];
+ byte b = pPal[start * 3 + 2];
+
+ Common::copy(&pPal[start * 3 + 3], &pPal[end * 3 + 3], &pPal[start * 3]);
+
+ // Place the original saved entry at the end of the range
+ pPal[end * 3] = r;
+ pPal[end * 3 + 1] = g;
+ pPal[end * 3 + 2] = b;
+
+ if (_fadeStatus & 1) {
+ //dx = start, di = end
+ warning("TODO: Adjustment of ViewPortListResource");
+ }
+ } else {
+ // Move palette entry to start of range
+ int start = READ_LE_UINT16(pSrc);
+ int end = READ_LE_UINT16(&pSrc[2]);
+ assert(start < 0x100 && end < 0x100);
+
+ // Store the RGB of the entry to be moved
+ byte r = pPal[end * 3];
+ byte g = pPal[end * 3 + 1];
+ byte b = pPal[end * 3 + 2];
+
+ // Move the remainder of the range forwards one entry
+ Common::copy_backward(&pPal[start * 3], &pPal[end * 3], &pPal[end * 3 + 3]);
+
+ // Place the original saved entry at the end of the range
+ pPal[start * 3] = r;
+ pPal[start * 3 + 1] = g;
+ pPal[start * 3 + 2] = b;
+
+ if (_fadeStatus & 1) {
+ //dx = start, di = end
+ warning("TODO: Adjustment of ViewPortListResource");
+ }
+ }
+ }
+
+ _intPtr._hasPalette = true;
+ }
+ }
+}
+
+
+void EventsManager::fadeIntFunc() {
+ switch (_vm->_voy._fadingType) {
+ case 1:
+ if (_vm->_voy._fadingAmount1 < 63)
+ _vm->_voy._fadingAmount1 += _vm->_voy._fadingStep1;
+ if (_vm->_voy._fadingAmount2 < 63)
+ _vm->_voy._fadingAmount2 += _vm->_voy._fadingStep2;
+ if (_vm->_voy._fadingAmount1 > 63)
+ _vm->_voy._fadingAmount1 = 63;
+ if (_vm->_voy._fadingAmount2 > 63)
+ _vm->_voy._fadingAmount2 = 63;
+ if ((_vm->_voy._fadingAmount1 == 63) && (_vm->_voy._fadingAmount2 == 63))
+ _vm->_voy._fadingType = 0;
+ break;
+ case 2:
+ if (_vm->_voy._fadingAmount1 > 0)
+ _vm->_voy._fadingAmount1 -= _vm->_voy._fadingStep1;
+ if (_vm->_voy._fadingAmount2 > 0)
+ _vm->_voy._fadingAmount2 -= _vm->_voy._fadingStep2;
+ if (_vm->_voy._fadingAmount1 < 0)
+ _vm->_voy._fadingAmount1 = 0;
+ if (_vm->_voy._fadingAmount2 < 0)
+ _vm->_voy._fadingAmount2 = 0;
+ if ((_vm->_voy._fadingAmount1 == 0) && (_vm->_voy._fadingAmount2 == 0))
+ _vm->_voy._fadingType = 0;
+ break;
+ default:
+ break;
+ }
+}
+
+void EventsManager::deleteIntNode(IntNode *node) {
+ _intNodes.remove(node);
+}
+
+void EventsManager::vInitColor() {
+ _fadeIntNode._intFunc = &EventsManager::vDoFadeInt;
+ _cycleIntNode._intFunc = &EventsManager::vDoCycleInt;
+
+ addIntNode(&_fadeIntNode);
+ addIntNode(&_cycleIntNode);
+}
+
+void EventsManager::setCursor(PictureResource *pic) {
+ PictureResource cursor;
+ cursor._bounds = pic->_bounds;
+ cursor._flags = DISPFLAG_CURSOR;
+
+ _vm->_graphicsManager.sDrawPic(pic, &cursor, Common::Point());
+}
+
+void EventsManager::setCursor(byte *cursorData, int width, int height) {
+ CursorMan.replaceCursor(cursorData, width, height, width / 2, height / 2, 0);
+}
+
+void EventsManager::setCursorColor(int idx, int mode) {
+ switch (mode) {
+ case 0:
+ _vm->_graphicsManager.setColor(idx, 90, 90, 232);
+ break;
+ case 1:
+ _vm->_graphicsManager.setColor(idx, 232, 90, 90);
+ break;
+ case 2:
+ _vm->_graphicsManager.setColor(idx, 90, 232, 90);
+ break;
+ case 3:
+ _vm->_graphicsManager.setColor(idx, 90, 232, 232);
+ break;
+ default:
+ break;
+ }
+}
+
+void EventsManager::showCursor() {
+ CursorMan.showMouse(true);
+}
+
+void EventsManager::hideCursor() {
+ CursorMan.showMouse(false);
+}
+
+void EventsManager::getMouseInfo() {
+ pollEvents();
+
+ if (_vm->_voy._eventFlags & EVTFLAG_RECORDING) {
+ if ((_gameCounter - _recordBlinkCounter) > 8) {
+ _recordBlinkCounter = _gameCounter;
+
+ if (_cursorBlinked) {
+ _cursorBlinked = false;
+ _vm->_graphicsManager.setOneColor(128, 220, 20, 20);
+ _vm->_graphicsManager.setColor(128, 220, 20, 20);
+ } else {
+ _cursorBlinked = true;
+ _vm->_graphicsManager.setOneColor(128, 220, 220, 220);
+ _vm->_graphicsManager.setColor(128, 220, 220, 220);
+ }
+ }
+ }
+
+ _vm->_eventsManager._mouseClicked = _vm->_eventsManager._newMouseClicked;
+ _vm->_eventsManager._leftClick = _vm->_eventsManager._newLeftClick;
+ _vm->_eventsManager._rightClick = _vm->_eventsManager._newRightClick;
+ _vm->_eventsManager._mouseUnk = _vm->_eventsManager._newMouseUnk;
+
+ _vm->_eventsManager._newMouseClicked = false;
+ _vm->_eventsManager._newLeftClick = false;
+ _vm->_eventsManager._newRightClick = false;
+ _vm->_eventsManager._mouseUnk = false;
+}
+
+void EventsManager::startCursorBlink() {
+ if (_vm->_voy._eventFlags & EVTFLAG_RECORDING) {
+ _vm->_graphicsManager.setOneColor(128, 55, 5, 5);
+ _vm->_graphicsManager.setColor(128, 220, 20, 20);
+ _intPtr._hasPalette = true;
+
+ _vm->_graphicsManager.drawDot();
+ //copySection();
+ }
+}
+
+void EventsManager::incrementTime(int amt) {
+ for (int i = 0; i < amt; ++i)
+ mainVoyeurIntFunc();
+}
+
+void EventsManager::stopEvidDim() {
+ deleteIntNode(&_evIntNode);
+}
+
+Common::String EventsManager::getEvidString(int eventIndex) {
+ assert(eventIndex <= _vm->_voy._eventCount);
+ VoyeurEvent &e = _vm->_voy._events[eventIndex];
+ return Common::String::format("%03d %.2d:%.2d %s %s", eventIndex + 1,
+ e._hour, e._minute, e._isAM ? AM : PM, EVENT_TYPE_STRINGS[e._type - 1]);
+}
+
+} // End of namespace Voyeur
diff --git a/engines/voyeur/events.h b/engines/voyeur/events.h
new file mode 100644
index 0000000000..eb6cf6d77f
--- /dev/null
+++ b/engines/voyeur/events.h
@@ -0,0 +1,153 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef VOYEUR_EVENTS_H
+#define VOYEUR_EVENTS_H
+
+#include "common/scummsys.h"
+#include "common/list.h"
+#include "graphics/surface.h"
+#include "voyeur/files.h"
+
+namespace Voyeur {
+
+class VoyeurEngine;
+class EventsManager;
+class CMapResource;
+
+#define GAME_FRAME_RATE 50
+#define GAME_FRAME_TIME (1000 / GAME_FRAME_RATE)
+
+typedef void (EventsManager::*EventMethodPtr)();
+
+class IntNode {
+public:
+ EventMethodPtr _intFunc;
+ uint16 _curTime;
+ uint16 _timeReset;
+ uint32 _flags;
+public:
+ IntNode();
+ IntNode(uint16 curTime, uint16 timeReset, uint16 flags);
+};
+
+class IntData {
+public:
+ bool _flipWait;
+ int _flashTimer;
+ int _flashStep;
+ int field26;
+ bool _hasPalette;
+ bool _skipFading;
+ int _palStartIndex;
+ int _palEndIndex;
+ byte *_palette;
+public:
+ IntData();
+};
+
+class EventsManager {
+private:
+ VoyeurEngine *_vm;
+ uint32 _priorFrameTime;
+ bool _counterFlag;
+ uint32 _gameCounter;
+ uint32 _recordBlinkCounter; // Original field was called _joe :)
+ int _mouseButton;
+ Common::List<IntNode *> _intNodes;
+ Common::Point _mousePos;
+ bool _cursorBlinked;
+
+ void mainVoyeurIntFunc();
+private:
+ void checkForNextFrameCounter();
+ void voyeurTimer();
+ void videoTimer();
+ void vDoFadeInt();
+ void vDoCycleInt();
+ void fadeIntFunc();
+ void deleteIntNode(IntNode *node);
+
+ /**
+ * Debugger support method to show the mouse position
+ */
+ void showMousePosition();
+public:
+ IntData _gameData;
+ IntData &_intPtr;
+ IntNode _fadeIntNode;
+ IntNode _fade2IntNode;
+ IntNode _cycleIntNode;
+ IntNode _evIntNode;
+ IntNode _mainIntNode;
+ int _cycleStatus;
+ int _fadeFirstCol, _fadeLastCol;
+ int _fadeCount;
+ int _fadeStatus;
+
+ bool _leftClick, _rightClick;
+ bool _mouseClicked;
+ bool _mouseUnk;
+ bool _newMouseClicked;
+ bool _newLeftClick, _newRightClick;
+ bool _newMouseUnk;
+
+ int _videoDead;
+ int _cycleTime[4];
+ byte *_cycleNext[4];
+ VInitCycleResource *_cyclePtr;
+public:
+ EventsManager();
+ void setVm(VoyeurEngine *vm) { _vm = vm; }
+
+ void resetMouse();
+ void setMousePos(const Common::Point &p) { _mousePos = p; }
+ void startMainClockInt();
+ void sWaitFlip();
+ void vInitColor();
+
+ void delay(int cycles);
+ void delayClick(int cycles);
+ void pollEvents();
+ void startFade(CMapResource *cMap);
+ void addIntNode(IntNode *node);
+ void addFadeInt();
+
+ void setCursor(PictureResource *pic);
+ void setCursor(byte *cursorData, int width, int height);
+ void setCursorColor(int idx, int mode);
+ void showCursor();
+ void hideCursor();
+ Common::Point getMousePos() { return _mousePos; }
+ uint32 getGameCounter() const { return _gameCounter; }
+ void getMouseInfo();
+ void startCursorBlink();
+ void incrementTime(int amt);
+
+ void stopEvidDim();
+
+ Common::String getEvidString(int eventIndex);
+};
+
+} // End of namespace Voyeur
+
+#endif /* VOYEUR_EVENTS_H */
diff --git a/engines/voyeur/files.cpp b/engines/voyeur/files.cpp
new file mode 100644
index 0000000000..3f955fd066
--- /dev/null
+++ b/engines/voyeur/files.cpp
@@ -0,0 +1,1659 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "voyeur/files.h"
+#include "voyeur/graphics.h"
+#include "voyeur/voyeur.h"
+#include "voyeur/staticres.h"
+
+namespace Voyeur {
+
+#define BOLT_GROUP_SIZE 16
+
+BoltFilesState::BoltFilesState() {
+ _curLibPtr = NULL;
+ _curGroupPtr = NULL;
+ _curMemberPtr = NULL;
+ _curMemInfoPtr = NULL;
+ _fromGroupFlag = 0;
+ _xorMask = 0;
+ _encrypt = false;
+ _curFilePosition = 0;
+ _bufferEnd = 0;
+ _bufferBegin = 0;
+ _bytesLeft = 0;
+ _bufSize = 0;
+ _bufStart = NULL;
+ _bufPos = NULL;
+ _historyIndex = 0;
+ _runLength = 0;
+ _decompState = 0;
+ _runType = 0;
+ _runValue = 0;
+ _runOffset = 0;
+ Common::fill(&_historyBuffer[0], &_historyBuffer[0x200], 0);
+ _curFd = NULL;
+ _boltPageFrame = NULL;
+}
+
+#define NEXT_BYTE if (--_bytesLeft < 0) nextBlock()
+
+byte *BoltFilesState::decompress(byte *buf, int size, int mode) {
+ if (!buf) {
+ buf = new byte[size];
+ Common::fill(buf, buf + size, 0);
+ }
+ byte *bufP = buf;
+
+ if (mode & 8) {
+ _decompState = 1;
+ _runType = 0;
+ _runLength = size;
+ }
+
+ while (size > 0) {
+ if (!_decompState) {
+ NEXT_BYTE;
+ byte nextByte = *_bufPos++;
+
+ switch (nextByte & 0xC0) {
+ case 0:
+ _runType = 0;
+ _runLength = 30 - (nextByte & 0x1f) + 1;
+ break;
+ case 0x40:
+ _runType = 1;
+ _runLength = 35 - (nextByte & 0x1f);
+ NEXT_BYTE;
+ _runOffset = *_bufPos++ + ((nextByte & 0x20) << 3);
+ break;
+ case 0x80:
+ _runType = 1;
+ _runLength = (nextByte & 0x20) ? ((32 - (nextByte & 0x1f)) << 2) + 2 :
+ (32 - (nextByte & 0x1f)) << 2;
+ NEXT_BYTE;
+ _runOffset = *_bufPos++ << 1;
+ break;
+ default:
+ _runType = 2;
+
+ if (nextByte & 0x20) {
+ _runLength = 0;
+ } else {
+ NEXT_BYTE;
+ _runLength = ((32 - (nextByte & 0x1f)) + (*_bufPos++ << 5)) << 2;
+ NEXT_BYTE;
+ _bufPos++;
+ NEXT_BYTE;
+ _runValue = *_bufPos++;
+ }
+ break;
+ }
+
+ _runOffset = _historyIndex - _runOffset;
+ }
+
+ int runOffset = _runOffset & 0x1ff;
+ int len;
+ if (_runLength <= size) {
+ len = _runLength;
+ _decompState = 0;
+ } else {
+ _decompState = 1;
+ len = size;
+ _runLength -= size;
+ if (_runType == 1)
+ _runOffset += len;
+ }
+
+ // Reduce the remaining size
+ size -= len;
+
+ // Handle the run lengths
+ switch (_runType) {
+ case 0:
+ while (len-- > 0) {
+ NEXT_BYTE;
+ byte v = *_bufPos++;
+ _historyBuffer[_historyIndex] = v;
+ *bufP++ = v;
+ _historyIndex = (_historyIndex + 1) & 0x1ff;
+ }
+ break;
+ case 1:
+ while (len-- > 0) {
+ _historyBuffer[_historyIndex] = _historyBuffer[runOffset];
+ *bufP++ = _historyBuffer[runOffset];
+ _historyIndex = (_historyIndex + 1) & 0x1ff;
+ runOffset = (runOffset + 1) & 0x1ff;
+ }
+ break;
+ default:
+ while (len-- > 0) {
+ _historyBuffer[_historyIndex] = _runValue;
+ *bufP++ = _runValue;
+ _historyIndex = (_historyIndex + 1) & 0x1ff;
+ }
+ break;
+ }
+ }
+
+ return buf;
+}
+
+#undef NEXT_BYTE
+
+void BoltFilesState::nextBlock() {
+ if (&_curLibPtr->_file != _curFd || _curFd->pos() != _bufferEnd)
+ _curLibPtr->_file.seek(_bufferEnd);
+
+ _curFd = &_curLibPtr->_file;
+ _bufferBegin = _bufferEnd;
+ int bytesRead = _curFd->read(_bufStart, _bufSize);
+
+ _bufferEnd = _curFilePosition = _curFd->pos();
+ _bytesLeft = bytesRead - 1;
+ _bufPos = _bufStart;
+}
+
+/*------------------------------------------------------------------------*/
+
+FilesManager::FilesManager() {
+ _decompressSize = DECOMPRESS_SIZE;
+}
+
+bool FilesManager::openBoltLib(const Common::String &filename, BoltFile *&boltFile) {
+ if (boltFile != NULL) {
+ _boltFilesState._curLibPtr = boltFile;
+ return true;
+ }
+
+ // Create the bolt file interface object and load the index
+ if (filename == "bvoy.blt")
+ boltFile = _boltFilesState._curLibPtr = new BVoyBoltFile(_boltFilesState);
+ else if (filename == "stampblt.blt")
+ boltFile = _boltFilesState._curLibPtr = new StampBoltFile(_boltFilesState);
+ else
+ error("Unknown bolt file specified");
+
+ return true;
+}
+
+byte *FilesManager::fload(const Common::String &filename, int *size) {
+ Common::File f;
+ int filesize;
+ byte *data = NULL;
+
+ if (f.open(filename)) {
+ // Read in the file
+ filesize = f.size();
+ data = new byte[filesize];
+ f.read(data, filesize);
+ } else {
+ filesize = 0;
+ }
+
+ if (size)
+ *size = filesize;
+ return data;
+}
+
+/*------------------------------------------------------------------------*/
+
+BoltFile::BoltFile(const Common::String &filename, BoltFilesState &state): _state(state) {
+ if (!_file.open(filename))
+ error("Could not open %s", filename.c_str());
+ _state._curFilePosition = 0;
+
+ // Read in the file header
+ byte header[16];
+ _file.read(&header[0], 16);
+
+ if (strncmp((const char *)&header[0], "BOLT", 4) != 0)
+ error("Tried to load non-bolt file");
+
+ int totalGroups = header[11] ? header[11] : 0x100;
+ for (int i = 0; i < totalGroups; ++i)
+ _groups.push_back(BoltGroup(&_file));
+}
+
+BoltFile::~BoltFile() {
+ _file.close();
+ if (_state._curFd == &_file)
+ _state._curFd = NULL;
+ if (_state._curLibPtr == this)
+ _state._curLibPtr = NULL;
+}
+
+BoltGroup *BoltFile::getBoltGroup(uint16 id, bool process) {
+ ++_state._fromGroupFlag;
+ _state._curLibPtr = this;
+ _state._curGroupPtr = &_groups[(id >> 8) & 0xff];
+
+ if (!_state._curGroupPtr->_loaded) {
+ // Load the group index
+ _state._curGroupPtr->load(id & 0xff00);
+ }
+
+ if (_state._curGroupPtr->_callInitGro)
+ initGro();
+
+ if (process) {
+ // Pre-process the resources
+ id &= 0xff00;
+ for (int idx = 0; idx < _state._curGroupPtr->_count; ++idx, ++id) {
+ byte *member = getBoltMember(id);
+ assert(member);
+ }
+ } else if (!_state._curGroupPtr->_processed) {
+ _state._curGroupPtr->_processed = true;
+ _state._curGroupPtr->load(id & 0xff00);
+ }
+
+ resolveAll();
+ --_state._fromGroupFlag;
+
+ return _state._curGroupPtr;
+}
+
+void BoltFile::freeBoltGroup(uint16 id, bool freeEntries) {
+ _state._curLibPtr = this;
+ _state._curGroupPtr = &_groups[(id >> 8) & 0xff];
+
+ // Unload the group
+ _state._curGroupPtr->unload();
+}
+
+void BoltFile::freeBoltMember(uint32 id) {
+ // No implementation in ScummVM
+}
+
+BoltEntry &BoltFile::getBoltEntryFromLong(uint32 id) {
+ BoltGroup &group = _groups[id >> 24];
+ assert(group._loaded);
+
+ BoltEntry &entry = group._entries[(id >> 16) & 0xff];
+ assert(!entry.hasResource() || (id & 0xffff) == 0);
+
+ return entry;
+}
+
+BoltEntry &BoltFile::boltEntry(uint16 id) {
+ BoltGroup &group = _groups[id >> 8];
+ assert(group._loaded);
+
+ BoltEntry &entry = group._entries[id & 0xff];
+ assert(entry.hasResource());
+
+ return entry;
+}
+
+PictureResource *BoltFile::getPictureResource(uint32 id) {
+ if ((int32)id == -1)
+ return NULL;
+
+ if (id & 0xffff)
+ id <<= 16;
+ return getBoltEntryFromLong(id)._picResource;
+}
+
+CMapResource *BoltFile::getCMapResource(uint32 id) {
+ if ((int32)id == -1)
+ return NULL;
+
+ if (id & 0xffff)
+ id <<= 16;
+
+ return getBoltEntryFromLong(id)._cMapResource;
+}
+
+byte *BoltFile::memberAddr(uint32 id) {
+ BoltGroup &group = _groups[id >> 8];
+ if (!group._loaded)
+ return NULL;
+
+ // If an entry already has a processed representation, we shouldn't
+ // still be accessing the raw data
+ BoltEntry &entry = group._entries[id & 0xff];
+ assert(!entry.hasResource());
+
+ return entry._data;
+}
+
+byte *BoltFile::memberAddrOffset(uint32 id) {
+ BoltGroup &group = _groups[id >> 24];
+ if (!group._loaded)
+ return NULL;
+
+ // If an entry already has a processed representation, we shouldn't
+ // still be accessing the raw data
+ BoltEntry &entry = group._entries[(id >> 16) & 0xff];
+ assert(!entry.hasResource());
+
+ return entry._data + (id & 0xffff);
+}
+
+/**
+ * Resolves an Id to an offset within a loaded resource
+ */
+void BoltFile::resolveIt(uint32 id, byte **p) {
+ if ((int32)id == -1) {
+ *p = NULL;
+ } else {
+ byte *ptr = memberAddrOffset(id);
+ if (ptr) {
+ *p = ptr;
+ } else {
+ *p = NULL;
+ assert(_state._resolves.size() < 1000);
+ _state._resolves.push_back(ResolveEntry(id, p));
+ }
+ }
+}
+
+void BoltFile::resolveFunction(uint32 id, GraphicMethodPtr *fn) {
+ if ((int32)id == -1)
+ *fn = NULL;
+ else
+ error("Function fnTermGro array not supported");
+}
+
+/**
+ * Resolve any data references to within resources that weren't
+ * previously loaded, but are now
+ */
+void BoltFile::resolveAll() {
+ for (uint idx = 0; idx < _state._resolves.size(); ++idx)
+ *_state._resolves[idx]._p = memberAddrOffset(_state._resolves[idx]._id);
+
+ _state._resolves.clear();
+}
+
+byte *BoltFile::getBoltMember(uint32 id) {
+ _state._curLibPtr = this;
+
+ // Get the group, and load it's entry list if not already loaded
+ _state._curGroupPtr = &_groups[(id >> 8) & 0xff];
+ if (!_state._curGroupPtr->_loaded)
+ _state._curGroupPtr->load(id & 0xff00);
+
+ // Get the entry
+ _state._curMemberPtr = &_state._curGroupPtr->_entries[id & 0xff];
+ if (_state._curMemberPtr->_initMemRequired)
+ initMem(_state._curMemberPtr->_initMemRequired);
+
+ // Return the data for the entry if it's already been loaded
+ if (_state._curMemberPtr->_data)
+ return _state._curMemberPtr->_data;
+
+ _state._xorMask = _state._curMemberPtr->_xorMask;
+ _state._encrypt = (_state._curMemberPtr->_mode & 0x10) != 0;
+
+ if (_state._curGroupPtr->_processed) {
+ error("Processed resources are not supported");
+ } else {
+ _state._bufStart = _state._decompressBuf;
+ _state._bufSize = DECOMPRESS_SIZE;
+
+ if ((_state._curFd != &_file) || (_state._curMemberPtr->_fileOffset < _state._bufferBegin)
+ || (_state._curMemberPtr->_fileOffset >= _state._bufferEnd)) {
+ _state._bytesLeft = 0;
+ _state._bufPos = _state._bufStart;
+ _state._bufferBegin = -1;
+ _state._bufferEnd = _state._curMemberPtr->_fileOffset;
+ } else {
+ _state._bufPos = _state._curMemberPtr->_fileOffset - _state._bufferBegin + _state._bufStart;
+ _state._bytesLeft = _state._bufSize - (_state._bufPos - _state._bufStart);
+ }
+ }
+
+ _state._decompState = 0;
+ _state._historyIndex = 0;
+
+ // Initialize the resource
+ assert(_state._curMemberPtr->_initMethod < 25);
+ initResource(_state._curMemberPtr->_initMethod);
+
+ return _state._curMemberPtr->_data;
+}
+
+void BoltFile::initDefault() {
+ _state._curMemberPtr->_data = _state.decompress(0, _state._curMemberPtr->_size,
+ _state._curMemberPtr->_mode);
+}
+
+/*------------------------------------------------------------------------*/
+
+BVoyBoltFile::BVoyBoltFile(BoltFilesState &state): BoltFile("bvoy.blt", state) {
+}
+
+void BVoyBoltFile::initResource(int resType) {
+ switch (resType) {
+ case 2:
+ // Also used for point list, and ending credits credit data
+ sInitRect();
+ break;
+ case 8:
+ sInitPic();
+ break;
+ case 10:
+ vInitCMap();
+ break;
+ case 11:
+ vInitCycl();
+ break;
+ case 15:
+ initViewPort();
+ break;
+ case 16:
+ initViewPortList();
+ break;
+ case 17:
+ initFont();
+ break;
+ case 18:
+ initFontInfo();
+ break;
+ case 19:
+ initSoundMap();
+ break;
+ default:
+ initDefault();
+ break;
+ }
+}
+
+void BVoyBoltFile::initViewPort() {
+ initDefault();
+
+ ViewPortResource *viewPort;
+ byte *src = _state._curMemberPtr->_data;
+ _state._curMemberPtr->_viewPortResource = viewPort = new ViewPortResource(_state, src);
+
+ // This is done post-constructor, since viewports can be self referential, so
+ // we ned the _viewPortResource field to have been set before resolving the pointer
+ viewPort->_parent = getBoltEntryFromLong(READ_LE_UINT32(src + 2))._viewPortResource;
+}
+
+void BVoyBoltFile::initViewPortList() {
+ initDefault();
+
+ ViewPortListResource *res;
+ _state._curMemberPtr->_viewPortListResource = res = new ViewPortListResource(
+ _state, _state._curMemberPtr->_data);
+
+ _state._vm->_graphicsManager._viewPortListPtr = res;
+ _state._vm->_graphicsManager._vPort = &res->_entries[0];
+}
+
+void BVoyBoltFile::initFontInfo() {
+ initDefault();
+ _state._curMemberPtr->_fontInfoResource = new FontInfoResource(
+ _state, _state._curMemberPtr->_data);
+}
+
+void BVoyBoltFile::initFont() {
+ initDefault();
+ _state._curMemberPtr->_fontResource = new FontResource(_state, _state._curMemberPtr->_data);
+}
+
+void BVoyBoltFile::initSoundMap() {
+ initDefault();
+}
+
+void BVoyBoltFile::sInitRect() {
+ _state._curMemberPtr->_data = _state.decompress(NULL, _state._curMemberPtr->_size,
+ _state._curMemberPtr->_mode);
+
+ // Check whether the resouce Id is in the list of extended rects
+ bool isExtendedRects = false;
+ for (int i = 0; i < 49 && !isExtendedRects; ++i)
+ isExtendedRects = RESOLVE_TABLE[i] == (_state._curMemberPtr->_id & 0xff00);
+
+ int rectSize = isExtendedRects ? 12 : 8;
+ if ((_state._curMemberPtr->_size % rectSize) == 0 || (_state._curMemberPtr->_size % rectSize) == 2)
+ _state._curMemberPtr->_rectResource = new RectResource(_state._curMemberPtr->_data,
+ _state._curMemberPtr->_size, isExtendedRects);
+}
+
+void BVoyBoltFile::sInitPic() {
+ // Read in the header data
+ _state._curMemberPtr->_data = _state.decompress(NULL, 24, _state._curMemberPtr->_mode);
+ _state._curMemberPtr->_picResource = new PictureResource(_state,
+ _state._curMemberPtr->_data);
+}
+
+void BVoyBoltFile::vInitCMap() {
+ initDefault();
+ _state._curMemberPtr->_cMapResource = new CMapResource(
+ _state, _state._curMemberPtr->_data);
+}
+
+void BVoyBoltFile::vInitCycl() {
+ initDefault();
+ _state._curMemberPtr->_vInitCycleResource = new VInitCycleResource(
+ _state, _state._curMemberPtr->_data);
+ _state._curMemberPtr->_vInitCycleResource->vStopCycle();
+}
+
+/*------------------------------------------------------------------------*/
+
+StampBoltFile::StampBoltFile(BoltFilesState &state): BoltFile("stampblt.blt", state) {
+}
+
+void StampBoltFile::initResource(int resType) {
+ switch (resType) {
+ case 0:
+ initThread();
+ break;
+ case 4:
+ initState();
+ break;
+ case 6:
+ initPtr();
+ break;
+ case 24:
+ initControl();
+ break;
+ default:
+ initDefault();
+ break;
+ }
+}
+
+void StampBoltFile::initThread() {
+ initDefault();
+
+ _state._curMemberPtr->_threadResource = new ThreadResource(_state,
+ _state._curMemberPtr->_data);
+}
+
+void StampBoltFile::initPtr() {
+ initDefault();
+
+ _state._curMemberPtr->_ptrResource = new PtrResource(_state,
+ _state._curMemberPtr->_data);
+}
+
+ void initControlData();
+
+
+void StampBoltFile::initControl() {
+ initDefault();
+
+ ControlResource *res;
+ _state._curMemberPtr->_controlResource = res = new ControlResource(_state,
+ _state._curMemberPtr->_data);
+
+ _state._vm->_controlGroupPtr = _state._curGroupPtr;
+ _state._vm->_controlPtr = res;
+}
+
+void StampBoltFile::initState() {
+ initDefault();
+
+ assert(_state._curMemberPtr->_size == 16);
+ _state._curMemberPtr->_stateResource = new StateResource(_state,
+ _state._curMemberPtr->_data);
+}
+
+/*------------------------------------------------------------------------*/
+
+BoltGroup::BoltGroup(Common::SeekableReadStream *f): _file(f) {
+ byte buffer[BOLT_GROUP_SIZE];
+
+ _loaded = false;
+
+ _file->read(&buffer[0], BOLT_GROUP_SIZE);
+ _processed = buffer[0] != 0;
+ _callInitGro = buffer[1] != 0;
+ _termGroIndex = buffer[2];
+ _count = buffer[3] ? buffer[3] : 256;
+ _fileOffset = READ_LE_UINT32(&buffer[8]);
+}
+
+BoltGroup::~BoltGroup() {
+}
+
+void BoltGroup::load(uint16 groupId) {
+ _file->seek(_fileOffset);
+
+ // Read the entries
+ for (int i = 0; i < _count; ++i)
+ _entries.push_back(BoltEntry(_file, groupId + i));
+
+ _loaded = true;
+}
+
+void BoltGroup::unload() {
+ if (!_loaded)
+ return;
+
+ _entries.clear();
+ _loaded = false;
+}
+
+/*------------------------------------------------------------------------*/
+
+BoltEntry::BoltEntry(Common::SeekableReadStream *f, uint16 id): _file(f), _id(id) {
+ _data = nullptr;
+ _rectResource = nullptr;
+ _picResource = nullptr;
+ _viewPortResource = nullptr;
+ _viewPortListResource = nullptr;
+ _fontResource = nullptr;
+ _fontInfoResource = nullptr;
+ _cMapResource = nullptr;
+ _vInitCycleResource = nullptr;
+
+ _ptrResource = nullptr;
+ _stateResource = nullptr;
+ _controlResource = nullptr;
+ _vInitCycleResource = nullptr;
+ _threadResource = nullptr;
+
+ byte buffer[16];
+ _file->read(&buffer[0], 16);
+ _mode = buffer[0];
+ _initMemRequired = buffer[1];
+ _initMethod = buffer[3];
+ _xorMask = buffer[4] & 0xff;
+ _size = READ_LE_UINT32(&buffer[4]) & 0xffffff;
+ _fileOffset = READ_LE_UINT32(&buffer[8]);
+}
+
+BoltEntry::~BoltEntry() {
+ delete[] _data;
+ delete _rectResource;
+ delete _picResource;
+ delete _viewPortResource;
+ delete _viewPortListResource;
+ delete _fontResource;
+ delete _fontInfoResource;
+ delete _cMapResource;
+
+ delete _ptrResource;
+ delete _controlResource;
+ delete _stateResource;
+ delete _vInitCycleResource;
+ delete _threadResource;
+}
+
+void BoltEntry::load() {
+ // Currently, all entry loading and decompression is done in BoltFile::memberAddr.
+}
+
+/**
+ * Returns true if the given bolt entry has an attached resource
+ */
+bool BoltEntry::hasResource() const {
+ return _rectResource || _picResource || _viewPortResource || _viewPortListResource
+ || _fontResource || _fontInfoResource || _cMapResource
+ || _vInitCycleResource
+ || _ptrResource || _controlResource || _stateResource || _threadResource;
+}
+
+/*------------------------------------------------------------------------*/
+
+RectEntry::RectEntry(int x1, int y1, int x2, int y2, int arrIndex, int count):
+ Common::Rect(x1, y1, x2, y2), _arrIndex(arrIndex), _count(count) {
+}
+
+/*------------------------------------------------------------------------*/
+
+RectResource::RectResource(const byte *src, int size, bool isExtendedRects) {
+ int count;
+ int rectSize = isExtendedRects ? 12 : 8;
+ if ((size % rectSize) == 2) {
+ count = READ_LE_UINT16(src);
+ src += 2;
+ } else {
+ count = size / rectSize;
+ }
+
+ for (int i = 0; i < count; ++i, src += 8) {
+ int arrIndex = 0, count = 0;
+ if (isExtendedRects) {
+ arrIndex = READ_LE_UINT16(src);
+ count = READ_LE_UINT16(src + 2);
+ src += 4;
+ }
+
+ int x1 = READ_LE_UINT16(src);
+ int y1 = READ_LE_UINT16(src + 2);
+ int x2 = READ_LE_UINT16(src + 4);
+ int y2 = READ_LE_UINT16(src + 6);
+
+ _entries.push_back(RectEntry(x1, y1, x2, y2, arrIndex, count));
+ }
+
+ left = _entries[0].left;
+ top = _entries[0].top;
+ right = _entries[0].right;
+ bottom = _entries[0].bottom;
+}
+
+RectResource::RectResource(int x1, int y1, int x2, int y2) {
+ left = x1;
+ top = y1;
+ right = x2;
+ bottom = y2;
+}
+
+/*------------------------------------------------------------------------*/
+
+DisplayResource::DisplayResource() {
+ _vm = NULL;
+}
+
+DisplayResource::DisplayResource(VoyeurEngine *vm) {
+ _vm = vm;
+}
+
+void DisplayResource::sFillBox(int width, int height) {
+ assert(_vm);
+ bool saveBack = _vm->_graphicsManager._saveBack;
+ _vm->_graphicsManager._saveBack = false;
+
+ PictureResource pr;
+ pr._flags = 1;
+ pr._select = 0xff;
+ pr._pick = 0;
+ pr._onOff = _vm->_graphicsManager._drawPtr->_penColor;
+ pr._bounds = Common::Rect(0, 0, width, height);
+
+ _vm->_graphicsManager.sDrawPic(&pr, this, _vm->_graphicsManager._drawPtr->_pos);
+ _vm->_graphicsManager._saveBack = saveBack;
+}
+
+bool DisplayResource::clipRect(Common::Rect &rect) {
+ Common::Rect clipRect;
+ if (_vm->_graphicsManager._clipPtr) {
+ clipRect = *_vm->_graphicsManager._clipPtr;
+ } else if (_flags & DISPFLAG_VIEWPORT) {
+ clipRect = ((ViewPortResource *)this)->_clipRect;
+ } else {
+ clipRect = ((PictureResource *)this)->_bounds;
+ }
+
+ Common::Rect r = rect;
+ if (r.left < clipRect.left) {
+ if (r.right <= clipRect.left)
+ return false;
+ r.setWidth(r.right - clipRect.left);
+ }
+ if (r.right >= clipRect.right) {
+ if (r.left >= clipRect.left)
+ return false;
+ r.setWidth(clipRect.right - r.left);
+ }
+
+ if (r.top < clipRect.top) {
+ if (r.bottom <= clipRect.top)
+ return false;
+ r.setHeight(r.bottom - clipRect.top);
+ }
+ if (r.bottom >= clipRect.bottom) {
+ if (r.top >= clipRect.top)
+ return false;
+ r.setWidth(clipRect.bottom - r.top);
+ }
+
+ rect = r;
+ return true;
+}
+
+int DisplayResource::drawText(const Common::String &msg) {
+ GraphicsManager &gfxManager = _vm->_graphicsManager;
+ assert(gfxManager._fontPtr);
+ assert(gfxManager._fontPtr->_curFont);
+ FontInfoResource &fontInfo = *gfxManager._fontPtr;
+ PictureResource &fontChar = *_vm->_graphicsManager._fontChar;
+ FontResource &fontData = *fontInfo._curFont;
+ int xShadows[9] = { 0, 1, 1, 1, 0, -1, -1, -1, 0 };
+ int yShadows[9] = { 0, 1, 0, -1, -1, -1, 0, 1, 1 };
+
+ Common::Rect *clipPtr = gfxManager._clipPtr;
+ if (!(fontInfo._picFlags & DISPFLAG_1))
+ gfxManager._clipPtr = NULL;
+
+ int minChar = fontData._minChar;
+ int padding = fontData._padding;
+ int fontHeight = fontData._fontHeight;
+ int totalChars = fontData._maxChar - fontData._minChar;
+ int msgWidth = 0;
+ int xp = 0, yp = 0;
+
+ Common::Point pos = Common::Point(fontInfo._pos.x, fontInfo._pos.y + fontData._topPadding);
+
+ fontChar._flags = fontInfo._picFlags | DISPFLAG_2;
+ fontChar._select = fontInfo._picSelect;
+ fontChar._bounds.setHeight(fontHeight);
+
+ ViewPortResource *viewPort = !(_flags & DISPFLAG_VIEWPORT) ? NULL :
+ (ViewPortResource *)this;
+
+ if (gfxManager._drawTextPermFlag || (fontInfo._fontFlags & DISPFLAG_1) || fontInfo._justify ||
+ (gfxManager._saveBack && fontInfo._fontSaveBack && (_flags & DISPFLAG_VIEWPORT))) {
+ msgWidth = viewPort->textWidth(msg);
+ yp = pos.y;
+ xp = pos.x;
+
+ switch (fontInfo._justify) {
+ case 1:
+ xp = pos.x + (fontInfo._justifyWidth / 2) - (msgWidth / 2);
+ break;
+ case 2:
+ xp = pos.x + fontInfo._justifyWidth - msgWidth;
+ break;
+ default:
+ break;
+ }
+
+ if (!(fontInfo._fontFlags & 3)) {
+ viewPort->_fontRect.left = xp;
+ viewPort->_fontRect.top = yp;
+ viewPort->_fontRect.setWidth(msgWidth);
+ viewPort->_fontRect.setHeight(fontHeight);
+ } else {
+ viewPort->_fontRect.left = pos.x;
+ viewPort->_fontRect.top = pos.y;
+ viewPort->_fontRect.setWidth(fontInfo._justifyWidth);
+ viewPort->_fontRect.setHeight(fontInfo._justifyHeight);
+ }
+
+ pos.x = xp;
+ pos.y = yp;
+
+ if (fontInfo._fontFlags & 4) {
+ if (fontInfo._shadow.x <= 0) {
+ viewPort->_fontRect.left += fontInfo._shadow.x;
+ viewPort->_fontRect.right -= fontInfo._shadow.x * 2;
+ } else {
+ viewPort->_fontRect.right += fontInfo._shadow.x;
+ }
+
+ if (fontInfo._shadow.y <= 0) {
+ viewPort->_fontRect.top += fontInfo._shadow.y;
+ viewPort->_fontRect.bottom -= fontInfo._shadow.y * 2;
+ } else {
+ viewPort->_fontRect.bottom += fontInfo._shadow.y;
+ }
+ } else if (fontInfo._fontFlags & 8) {
+ if (fontInfo._shadow.x <= 0) {
+ viewPort->_fontRect.left += fontInfo._shadow.x;
+ viewPort->_fontRect.right -= fontInfo._shadow.x * 3;
+ } else {
+ viewPort->_fontRect.right += fontInfo._shadow.x * 3;
+ viewPort->_fontRect.left -= fontInfo._shadow.x;
+ }
+
+ if (fontInfo._shadow.y <= 0) {
+ viewPort->_fontRect.top += fontInfo._shadow.y;
+ viewPort->_fontRect.bottom -= fontInfo._shadow.y * 3;
+ } else {
+ viewPort->_fontRect.bottom += fontInfo._shadow.y * 3;
+ viewPort->_fontRect.top -= fontInfo._shadow.y;
+ }
+ }
+ }
+
+ if (gfxManager._saveBack && fontInfo._fontSaveBack && (_flags & DISPFLAG_VIEWPORT)) {
+ viewPort->addSaveRect(viewPort->_pageIndex, viewPort->_fontRect);
+ }
+
+ if (fontInfo._fontFlags & DISPFLAG_1) {
+ gfxManager._drawPtr->_pos = Common::Point(viewPort->_fontRect.left, viewPort->_fontRect.top);
+ gfxManager._drawPtr->_penColor = fontInfo._backColor;
+ sFillBox(viewPort->_fontRect.width(), viewPort->_fontRect.height());
+ }
+
+ bool saveBack = gfxManager._saveBack;
+ gfxManager._saveBack = false;
+
+ int count = 0;
+ if (fontInfo._fontFlags & DISPFLAG_4)
+ count = 1;
+ else if (fontInfo._fontFlags & DISPFLAG_8)
+ count = 8;
+
+ for (int i = count; i >= 0; --i) {
+ xp = pos.x;
+ yp = pos.y;
+
+ switch (xShadows[i]) {
+ case -1:
+ xp -= fontInfo._shadow.x;
+ break;
+ case 1:
+ xp += fontInfo._shadow.x;
+ break;
+ default:
+ break;
+ }
+
+ switch (yShadows[i]) {
+ case -1:
+ yp -= fontInfo._shadow.y;
+ break;
+ case 1:
+ yp += fontInfo._shadow.y;
+ break;
+ default:
+ break;
+ }
+
+ if (i != 0) {
+ fontChar._pick = 0;
+ fontChar._onOff = fontInfo._shadowColor;
+ } else if (fontData._fontDepth == 1 || (fontInfo._fontFlags & 0x10)) {
+ fontChar._pick = 0;
+ fontChar._onOff = fontInfo._foreColor;
+ } else {
+ fontChar._pick = fontInfo._picPick;
+ fontChar._onOff = fontInfo._picOnOff;
+ fontChar._depth = fontData._fontDepth;
+ }
+
+ // Loop to draw each character in turn
+ msgWidth = -padding;
+ const char *msgP = msg.c_str();
+ char ch;
+
+ while ((ch = *msgP++) != '\0') {
+ int charValue = (int)ch - minChar;
+ if (charValue < 0 || charValue >= totalChars || fontData._charWidth[charValue] == 0)
+ charValue = fontData._maxChar - minChar;
+
+ int charWidth = fontData._charWidth[charValue];
+ fontChar._bounds.setWidth(charWidth);
+
+ uint16 offset = READ_LE_UINT16(fontData._charOffsets + charValue * 2);
+ fontChar._imgData = fontData._charImages + offset * 2;
+
+ gfxManager.sDrawPic(&fontChar, this, Common::Point(xp, yp));
+
+ fontChar._imgData = NULL;
+ xp += charWidth + padding;
+ msgWidth += charWidth + padding;
+ }
+ }
+
+ msgWidth = MAX(msgWidth, 0);
+ if (fontInfo._justify == ALIGN_LEFT)
+ fontInfo._pos.x = xp;
+
+ gfxManager._saveBack = saveBack;
+ gfxManager._clipPtr = clipPtr;
+
+ return msgWidth;
+}
+
+int DisplayResource::textWidth(const Common::String &msg) {
+ if (msg.size() == 0)
+ return 0;
+
+ const char *msgP = msg.c_str();
+ FontResource &fontData = *_vm->_graphicsManager._fontPtr->_curFont;
+ int minChar = fontData._minChar;
+ int maxChar = fontData._maxChar;
+ int padding = fontData._padding;
+ int totalWidth = -padding;
+ char ch;
+
+ // Loop through the characters
+ while ((ch = *msgP++) != '\0') {
+ int charValue = (int)ch;
+ if (charValue < minChar || charValue > maxChar)
+ charValue = maxChar;
+
+ if (!fontData._charWidth[charValue - minChar])
+ charValue = maxChar;
+
+ totalWidth += fontData._charWidth[charValue - minChar] + padding;
+ }
+
+ if (totalWidth < 0)
+ totalWidth = 0;
+ return totalWidth;
+}
+
+/*------------------------------------------------------------------------*/
+
+PictureResource::PictureResource(BoltFilesState &state, const byte *src):
+ DisplayResource(state._vm) {
+ _flags = READ_LE_UINT16(src);
+ _select = src[2];
+ _pick = src[3];
+ _onOff = src[4];
+ _depth = src[5];
+
+ int xs = READ_LE_UINT16(&src[6]);
+ int ys = READ_LE_UINT16(&src[8]);
+ _bounds = Common::Rect(xs, ys, xs + READ_LE_UINT16(&src[10]),
+ ys + READ_LE_UINT16(&src[12]));
+ _maskData = READ_LE_UINT32(&src[14]);
+ _planeSize = READ_LE_UINT16(&src[22]);
+
+ _imgData = NULL;
+ _freeImgData = DisposeAfterUse::YES;
+
+ int nbytes = _bounds.width() * _bounds.height();
+ if (_flags & PICFLAG_20) {
+ if (_flags & (PICFLAG_VFLIP | PICFLAG_HFLIP)) {
+ // Get the raw data for the picture from another resource
+ uint32 id = READ_LE_UINT32(&src[18]);
+ const byte *srcData = state._curLibPtr->boltEntry(id)._data;
+ _imgData = new byte[nbytes];
+
+ // Flip the image data either horizontally or vertically
+ if (_flags & PICFLAG_HFLIP)
+ flipHorizontal(srcData);
+ else
+ flipVertical(srcData);
+ } else {
+ uint32 id = READ_LE_UINT32(&src[18]) >> 16;
+ byte *imgData = state._curLibPtr->boltEntry(id)._picResource->_imgData;
+ _freeImgData = DisposeAfterUse::NO;
+
+ // TODO: Double check code below. Despite different coding in the
+ // original, both looked like they do the same formula
+ if (_flags & PICFLAG_PIC_OFFSET) {
+ _imgData = imgData + (READ_LE_UINT32(&src[18]) & 0xffff);
+ } else {
+ _imgData = imgData + (READ_LE_UINT32(&src[18]) & 0xffff);
+ }
+ }
+ } else if (_flags & PICFLAG_PIC_OFFSET) {
+ int mode = 0;
+ if (_bounds.width() == 320) {
+ mode = 147;
+ state._sImageShift = 2;
+ state._SVGAReset = false;
+ } else {
+ state._SVGAReset = true;
+ if (_bounds.width() == 640) {
+ if (_bounds.height() == 400) {
+ mode = 220;
+ state._sImageShift = 3;
+ } else {
+ mode = 221;
+ state._sImageShift = 3;
+ }
+ } else if (_bounds.width() == 800) {
+ mode = 222;
+ state._sImageShift = 3;
+ } else if (_bounds.width() == 1024) {
+ mode = 226;
+ state._sImageShift = 3;
+ }
+ }
+
+ if (mode != state._vm->_graphicsManager._SVGAMode) {
+ state._vm->_graphicsManager._SVGAMode = mode;
+ state._vm->_graphicsManager.clearPalette();
+ }
+
+ int screenOffset = READ_LE_UINT32(&src[18]) & 0xffff;
+ assert(screenOffset == 0);
+
+ if (_flags & PICFLAG_CLEAR_SCREEN) {
+ // Clear screen picture. That's right. This game actually has a picture
+ // resource flag to clear the screen! Bizarre.
+ Graphics::Surface &s = state._vm->_graphicsManager._screenSurface;
+ s.fillRect(Common::Rect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT), 0);
+ } else {
+ // Direct sceren loading picture. In this case, the raw data of the resource
+ // is directly decompressed into the screen surface. Again, bizarre.
+ byte *pDest = (byte *)state._vm->_graphicsManager._screenSurface.getPixels();
+ state.decompress(pDest, SCREEN_WIDTH * SCREEN_HEIGHT, state._curMemberPtr->_mode);
+ }
+ } else {
+ if (_flags & PICFLAG_CLEAR_SCREEN00) {
+ if (!(_flags & PICFLAG_CLEAR_SCREEN))
+ nbytes = state._curMemberPtr->_size - 24;
+
+ int mask = (nbytes + 0x3FFF) >> 14;
+ _imgData = NULL;
+
+ if (state._boltPageFrame == 0)
+ state.EMSGetFrameAddr(&state._boltPageFrame);
+ if (state._boltPageFrame != 0) {
+ if (!state.EMSAllocatePages(&_planeSize)) {
+ _maskData = mask;
+
+ for (int idx = 0; idx < mask; ++idx)
+ state.EMSMapPageHandle(_planeSize, idx, idx);
+
+ state.decompress(state._boltPageFrame, nbytes, state._curMemberPtr->_mode);
+ return;
+ }
+ }
+ }
+
+ if (_flags & PICFLAG_CLEAR_SCREEN) {
+ _imgData = new byte[nbytes];
+ Common::fill(_imgData, _imgData + nbytes, 0);
+ } else {
+ _imgData = state.decompress(NULL, nbytes, state._curMemberPtr->_mode);
+ }
+ }
+}
+
+PictureResource::PictureResource(Graphics::Surface *surface) {
+ _flags = 0;
+ _select = 0;
+ _pick = 0;
+ _onOff = 0;
+ _depth = 0;
+ _maskData = 0;
+ _planeSize = 0;
+
+ _bounds = Common::Rect(0, 0, surface->w, surface->h);
+ _imgData = (byte *)surface->getPixels();
+ _freeImgData = DisposeAfterUse::NO;
+}
+
+PictureResource::PictureResource() {
+ _flags = 0;
+ _select = 0;
+ _pick = 0;
+ _onOff = 0;
+ _depth = 0;
+ _maskData = 0;
+ _planeSize = 0;
+
+ _imgData = NULL;
+ _freeImgData = DisposeAfterUse::NO;
+}
+
+PictureResource::PictureResource(int flags, int select, int pick, int onOff,
+ int depth, const Common::Rect &bounds, int maskData, byte *imgData,
+ int planeSize) {
+ _flags = flags;
+ _select = select;
+ _pick = pick;
+ _onOff = onOff;
+ _depth = depth;
+ _bounds = bounds;
+ _maskData = maskData;
+ _imgData = imgData;
+ _planeSize = planeSize;
+}
+
+PictureResource::~PictureResource() {
+ if (_freeImgData == DisposeAfterUse::YES)
+ delete[] _imgData;
+}
+
+void PictureResource::flipHorizontal(const byte *data) {
+ const byte *srcP = data + 18;
+ byte *destP = _imgData + _bounds.width() - 1;
+
+ for (int y = 0; y < _bounds.height(); ++y) {
+ for (int x = 0; x < _bounds.width(); ++x, ++srcP, --destP)
+ *destP = *srcP;
+
+ srcP += _bounds.width();
+ destP += _bounds.width();
+ }
+}
+
+void PictureResource::flipVertical(const byte *data) {
+ const byte *srcP = data + 18;
+ byte *destP = _imgData + _bounds.width() * (_bounds.height() - 1);
+
+ for (int y = 0; y < _bounds.height(); ++y) {
+ Common::copy(srcP, srcP + _bounds.width(), destP);
+ srcP += _bounds.width();
+ destP -= _bounds.width();
+ }
+}
+
+/*------------------------------------------------------------------------*/
+
+ViewPortResource::ViewPortResource(BoltFilesState &state, const byte *src):
+ _state(state), DisplayResource(state._vm) {
+ _flags = READ_LE_UINT16(src);
+ _parent = NULL;
+ _pageCount = READ_LE_UINT16(src + 6);
+ _pageIndex = READ_LE_UINT16(src + 8);
+ _lastPage = READ_LE_UINT16(src + 10);
+
+ int xs = READ_LE_UINT16(src + 12);
+ int ys = READ_LE_UINT16(src + 14);
+ _bounds = Common::Rect(xs, ys, xs + READ_LE_UINT16(src + 16),
+ ys + READ_LE_UINT16(src + 18));
+ _field18 = READ_LE_UINT16(src + 0x18);
+
+ _currentPic = state._curLibPtr->getPictureResource(READ_LE_UINT32(src + 0x20));
+ _activePage = state._curLibPtr->getPictureResource(READ_LE_UINT32(src + 0x24));
+ _pages[0] = state._curLibPtr->getPictureResource(READ_LE_UINT32(src + 0x28));
+ _pages[1] = state._curLibPtr->getPictureResource(READ_LE_UINT32(src + 0x2C));
+
+ state._curLibPtr->resolveIt(READ_LE_UINT32(src + 0x30), &_field30);
+
+ // Get the rect list
+ for (int listIndex = 0; listIndex < 3; ++listIndex) {
+ _rectListCount[listIndex] = (int16)READ_LE_UINT16(src + 0x40 + 2 * listIndex);
+ int id = (int)READ_LE_UINT32(src + 0x34 + listIndex * 4);
+
+ if (id == -1) {
+ _rectListPtr[listIndex] = NULL;
+ } else {
+ _rectListPtr[listIndex] = new Common::Array<Common::Rect>();
+
+ if (_rectListCount[listIndex] > 0) {
+ int16 *rectList = (int16 *)state._curLibPtr->memberAddrOffset(id);
+ for (int i = 0; i < _rectListCount[listIndex]; ++i) {
+ xs = FROM_LE_16(rectList[0]);
+ ys = FROM_LE_16(rectList[1]);
+ _rectListPtr[i]->push_back(Common::Rect(xs, ys, xs + FROM_LE_16(rectList[2]),
+ ys + FROM_LE_16(rectList[3])));
+ }
+ }
+ }
+ }
+
+ xs = READ_LE_UINT16(src + 0x46);
+ ys = READ_LE_UINT16(src + 0x48);
+ _clipRect = Common::Rect(xs, ys, xs + READ_LE_UINT16(src + 0x4A),
+ ys + READ_LE_UINT16(src + 0x4C));
+
+ state._curLibPtr->resolveIt(READ_LE_UINT32(src + 0x7A), &_field7A);
+
+ state._curLibPtr->resolveFunction(READ_LE_UINT32(src + 0x7E), (GraphicMethodPtr *)&_fn1);
+ state._curLibPtr->resolveFunction(READ_LE_UINT32(src + 0x82), (GraphicMethodPtr *)&_setupFn);
+ state._curLibPtr->resolveFunction(READ_LE_UINT32(src + 0x86), (GraphicMethodPtr *)&_addFn);
+ state._curLibPtr->resolveFunction(READ_LE_UINT32(src + 0x8A), (GraphicMethodPtr *)&_restoreFn);
+
+ if (!_restoreFn && _addFn)
+ _addFn = &GraphicsManager::addRectNoSaveBack;
+}
+
+ViewPortResource::~ViewPortResource() {
+ for (int i = 0; i < 3; ++i)
+ delete _rectListPtr[i];
+}
+
+void ViewPortResource::setupViewPort(PictureResource *page, Common::Rect *clipRect,
+ ViewPortSetupPtr setupFn, ViewPortAddPtr addFn, ViewPortRestorePtr restoreFn) {
+ PictureResource *pic = _currentPic;
+ Common::Rect r = _bounds;
+ r.translate(pic->_bounds.left, pic->_bounds.top);
+ int xDiff, yDiff;
+
+ if (page) {
+ // Clip based on the passed picture resource
+ xDiff = page->_bounds.left - r.left;
+ yDiff = page->_bounds.top - r.top;
+
+ if (xDiff > 0) {
+ int width = r.width();
+ r.left = page->_bounds.left;
+ r.setWidth(xDiff <= width ? width - xDiff : 0);
+ }
+ if (yDiff > 0) {
+ int height = r.height();
+ r.top = page->_bounds.top;
+ r.setHeight(yDiff <= height ? height - yDiff : 0);
+ }
+
+ xDiff = r.right - page->_bounds.right;
+ yDiff = r.bottom - page->_bounds.bottom;
+
+ if (xDiff > 0)
+ r.setWidth(xDiff <= r.width() ? r.width() - xDiff : 0);
+ if (yDiff > 0)
+ r.setHeight(yDiff <= r.height() ? r.height() - yDiff : 0);
+ }
+
+ if (clipRect) {
+ // Clip based on the passed clip rectangles
+ xDiff = clipRect->left - r.left;
+ yDiff = clipRect->top - r.top;
+
+ if (xDiff > 0) {
+ int width = r.width();
+ r.left = clipRect->left;
+ r.setWidth(xDiff <= width ? width - xDiff : 0);
+ }
+ if (yDiff > 0) {
+ int height = r.height();
+ r.top = clipRect->top;
+ r.setHeight(yDiff <= height ? height - yDiff : 0);
+ }
+
+ xDiff = r.right - clipRect->right;
+ yDiff = r.bottom - clipRect->bottom;
+
+ if (xDiff > 0)
+ r.setWidth(xDiff <= r.width() ? r.width() - xDiff : 0);
+ if (yDiff > 0)
+ r.setHeight(yDiff <= r.height() ? r.height() - yDiff : 0);
+ }
+
+ _activePage = page;
+ _field18 = 0;
+ _clipRect = r;
+ _setupFn = setupFn;
+ _addFn = addFn;
+ _restoreFn = restoreFn;
+
+ if (setupFn)
+ (_state._vm->_graphicsManager.*setupFn)(this);
+}
+
+void ViewPortResource::setupViewPort() {
+ setupViewPort(_state._vm->_graphicsManager._backgroundPage, NULL,
+ &GraphicsManager::setupMCGASaveRect, &GraphicsManager::addRectOptSaveRect,
+ &GraphicsManager::restoreMCGASaveRect);
+}
+
+void ViewPortResource::setupViewPort(PictureResource *pic, Common::Rect *clipRect) {
+ setupViewPort(pic, clipRect,
+ &GraphicsManager::setupMCGASaveRect, &GraphicsManager::addRectOptSaveRect,
+ &GraphicsManager::restoreMCGASaveRect);
+}
+
+void ViewPortResource::addSaveRect(int pageIndex, const Common::Rect &r) {
+ Common::Rect rect = r;
+
+ if (clipRect(rect)) {
+ if (_addFn) {
+ (_state._vm->_graphicsManager.*_addFn)(this, pageIndex, rect);
+ } else if (_rectListCount[pageIndex] != -1) {
+ _rectListPtr[pageIndex]->push_back(rect);
+ }
+ }
+}
+
+void ViewPortResource::fillPic(byte onOff) {
+ _state._vm->_graphicsManager.fillPic(this, onOff);
+}
+
+void ViewPortResource::drawIfaceTime() {
+ // Hour display
+ _state._vm->_graphicsManager.drawANumber(*_state._vm->_graphicsManager._vPort,
+ (_state._vm->_gameHour / 10) == 0 ? 10 : _state._vm->_gameHour / 10,
+ Common::Point(161, 25));
+ _state._vm->_graphicsManager.drawANumber(*_state._vm->_graphicsManager._vPort,
+ _state._vm->_gameHour % 10, Common::Point(172, 25));
+
+ // Minute display
+ _state._vm->_graphicsManager.drawANumber(*_state._vm->_graphicsManager._vPort,
+ _state._vm->_gameMinute / 10, Common::Point(190, 25));
+ _state._vm->_graphicsManager.drawANumber(*_state._vm->_graphicsManager._vPort,
+ _state._vm->_gameMinute % 10, Common::Point(201, 25));
+
+ // AM/PM indicator
+ PictureResource *pic = _state._vm->_bVoy->boltEntry(_state._vm->_voy._isAM ? 272 : 273)._picResource;
+ _state._vm->_graphicsManager.sDrawPic(pic, *_state._vm->_graphicsManager._vPort,
+ Common::Point(215, 27));
+}
+
+void ViewPortResource::drawPicPerm(PictureResource *pic, const Common::Point &pt) {
+ Common::Rect bounds = pic->_bounds;
+ bounds.translate(pt.x, pt.y);
+
+ bool saveBack = _state._vm->_graphicsManager._saveBack;
+ _state._vm->_graphicsManager._saveBack = false;
+ _state._vm->_graphicsManager.sDrawPic(pic, this, pt);
+ clipRect(bounds);
+
+ for (int pageIndex = 0; pageIndex < _pageCount; ++pageIndex) {
+ if (_pageIndex != pageIndex) {
+ addSaveRect(pageIndex, bounds);
+ }
+ }
+
+ _state._vm->_graphicsManager._saveBack = saveBack;
+}
+/*------------------------------------------------------------------------*/
+
+ViewPortListResource::ViewPortListResource(BoltFilesState &state, const byte *src) {
+ uint count = READ_LE_UINT16(src);
+ _palIndex = READ_LE_UINT16(src + 2);
+
+ // Load palette map
+ byte *palData = state._curLibPtr->memberAddr(READ_LE_UINT32(src + 4));
+ for (uint i = 0; i < 256; ++i, palData += 16)
+ _palette.push_back(ViewPortPalEntry(palData));
+
+ // Load view port pointer list
+ const uint32 *idP = (const uint32 *)&src[8];
+ for (uint i = 0; i < count; ++i, ++idP) {
+ uint32 id = READ_LE_UINT32(idP);
+ BoltEntry &entry = state._curLibPtr->getBoltEntryFromLong(id);
+
+ assert(entry._viewPortResource);
+ _entries.push_back(entry._viewPortResource);
+ }
+}
+
+/*------------------------------------------------------------------------*/
+
+ViewPortPalEntry::ViewPortPalEntry(const byte *src) {
+ const uint16 *v = (const uint16 *)src;
+ _rEntry = READ_LE_UINT16(v++);
+ _gEntry = READ_LE_UINT16(v++);
+ _bEntry = READ_LE_UINT16(v++);
+ _rChange = READ_LE_UINT16(v++);
+ _gChange = READ_LE_UINT16(v++);
+ _bChange = READ_LE_UINT16(v++);
+ _palIndex = READ_LE_UINT16(v++);
+}
+
+
+/*------------------------------------------------------------------------*/
+
+FontResource::FontResource(BoltFilesState &state, byte *src) {
+ _minChar = src[0];
+ _maxChar = src[1];
+ _fontDepth = src[2];
+ _padding = src[3];
+ _fontHeight = src[5];
+ _topPadding = (int8)src[6];
+
+ int totalChars = _maxChar - _minChar + 1;
+ _charWidth = new int[totalChars];
+ for (int i = 0; i < totalChars; ++i)
+ _charWidth[i] = READ_LE_UINT16(src + 8 + 2 * i);
+
+ _charOffsets = src + 8 + totalChars * 2;
+ _charImages = _charOffsets + totalChars * 2;
+}
+
+FontResource::~FontResource() {
+ delete[] _charWidth;
+}
+
+/*------------------------------------------------------------------------*/
+
+FontInfoResource::FontInfoResource(BoltFilesState &state, const byte *src) {
+ _curFont = NULL;
+ _picFlags = src[4];
+ _picSelect = src[5];
+ _picPick = src[6];
+ _picOnOff = src[7];
+ _fontFlags = src[8];
+ _justify = (FontJustify)src[9];
+ _fontSaveBack = READ_LE_UINT16(src + 10);
+ _pos.x = (int16)READ_LE_UINT16(src + 12);
+ _pos.y = (int16)READ_LE_UINT16(src + 14);
+ _justifyWidth = READ_LE_UINT16(src + 16);
+ _justifyHeight = READ_LE_UINT16(src + 18);
+ _shadow.x = READ_LE_UINT16(src + 20);
+ _shadow.y = READ_LE_UINT16(src + 22);
+ _foreColor = READ_LE_UINT16(src + 24);
+ _backColor = READ_LE_UINT16(src + 26);
+ _shadowColor = READ_LE_UINT16(src + 28);
+}
+
+FontInfoResource::FontInfoResource() {
+ _curFont = NULL;
+ _picFlags = 3;
+ _picSelect = 0xff;
+ _picPick = 0xff;
+ _picOnOff = 0;
+ _fontFlags = 0;
+ _justify = ALIGN_LEFT;
+ _fontSaveBack = 0;
+ _justifyWidth = 1;
+ _justifyHeight = 1;
+ _shadow = Common::Point(1, 1);
+ _foreColor = 1;
+ _backColor = 0;
+ _shadowColor = 0;
+}
+
+FontInfoResource::FontInfoResource(byte picFlags, byte picSelect, byte picPick, byte picOnOff,
+ byte fontFlags, FontJustify justify, int fontSaveBack, const Common::Point &pos,
+ int justifyWidth, int justifyHeight, const Common::Point &shadow, int foreColor,
+ int backColor, int shadowColor) {
+ _curFont = NULL;
+ _picFlags = picFlags;
+ _picSelect = picSelect;
+ _picPick = picPick;
+ _picOnOff = picOnOff;
+ _fontFlags = fontFlags;
+ _justify = justify;
+ _fontSaveBack = fontSaveBack;
+ _pos = pos;
+ _justifyWidth = justifyWidth;
+ _justifyHeight = justifyHeight;
+ _shadow = shadow;
+ _foreColor = foreColor;
+ _backColor = backColor;
+ _shadowColor = shadowColor;
+}
+
+/*------------------------------------------------------------------------*/
+
+CMapResource::CMapResource(BoltFilesState &state, const byte *src): _vm(state._vm) {
+ _steps = src[0];
+ _fadeStatus = src[1];
+ _start = READ_LE_UINT16(src + 2);
+ _end = READ_LE_UINT16(src + 4);
+
+ int count = _end - _start + 1;
+ _entries = new byte[count * 3];
+ Common::copy(src + 6, src + 6 + 3 * count, _entries);
+
+ int palIndex = state._vm->_graphicsManager._viewPortListPtr->_palIndex;
+ if (_end > palIndex)
+ _end = palIndex;
+ if (_start > palIndex)
+ _start = palIndex;
+}
+
+CMapResource::~CMapResource() {
+ delete[] _entries;
+}
+
+void CMapResource::startFade() {
+ _vm->_eventsManager.startFade(this);
+}
+
+/*------------------------------------------------------------------------*/
+
+VInitCycleResource::VInitCycleResource(BoltFilesState &state, const byte *src):
+ _state(state) {
+ // Set up arrays
+ for (int i = 0; i < 4; ++i) {
+ _type[i] = READ_LE_UINT16(src + i * 2);
+ state._curLibPtr->resolveIt(READ_LE_UINT32(src + 8 + i * 4), &_ptr[i]);
+ }
+}
+
+void VInitCycleResource::vStartCycle(int flags) {
+ EventsManager &evt = _state._vm->_eventsManager;
+ evt._cycleIntNode._flags |= 1;
+ evt._cyclePtr = this;
+
+ for (int i = 0; i < 4; ++i) {
+ evt._cycleNext[i] = _ptr[i];
+ evt._cycleTime[i] = 0;
+ }
+
+ evt._cycleStatus = flags | 1;
+ evt._cycleIntNode._flags &= ~1;
+}
+
+void VInitCycleResource::vStopCycle() {
+ EventsManager &evt = _state._vm->_eventsManager;
+ evt._cycleIntNode._flags |= 1;
+ evt._cycleStatus &= ~1;
+}
+
+/*------------------------------------------------------------------------*/
+
+PtrResource::PtrResource(BoltFilesState &state, const byte *src) {
+ // Load pointer list
+ const uint32 *idP = (const uint32 *)&src[0];
+ int size = state._curMemberPtr->_size;
+
+ for (int i = 0; i < size / 4; ++i, ++idP) {
+ uint32 id = READ_LE_UINT32(idP);
+ BoltEntry &entry = state._curLibPtr->getBoltEntryFromLong(id);
+
+ _entries.push_back(&entry);
+ }
+}
+
+/*------------------------------------------------------------------------*/
+
+ControlResource::ControlResource(BoltFilesState &state, const byte *src) {
+ // Get Id for the state data. Since it refers to a following entry in the same
+ // group, for simplicity we set the _state back in the main playStamp method
+ _stateId = READ_LE_UINT32(&src[0x32]);
+ _state = nullptr;
+
+ for (int i = 0; i < 8; ++i)
+ _memberIds[i] = READ_LE_UINT16(src + i * 2);
+
+ // Load pointer list
+ const uint32 *idP = (const uint32 *)&src[0x10];
+ int count = READ_LE_UINT16(&src[0x36]);
+
+ Common::fill(&_entries[0], &_entries[8], (byte *)nullptr);
+ for (int i = 0; i < count; ++i, ++idP) {
+ uint32 id = READ_LE_UINT32(idP);
+ state._curLibPtr->resolveIt(id, &_entries[i]);
+ }
+}
+
+/*------------------------------------------------------------------------*/
+
+StateResource::StateResource(BoltFilesState &state, const byte *src):
+ _victimIndex(_vals[1]), _victimEvidenceIndex(_vals[2]),
+ _victimMurderIndex(_vals[3]) {
+ for (int i = 0; i < 4; ++i)
+ _vals[i] = READ_LE_UINT32(src + i * 4);
+}
+
+void StateResource::synchronize(Common::Serializer &s) {
+ for (int i = 0; i < 4; ++i)
+ s.syncAsSint32LE(_vals[i]);
+}
+
+} // End of namespace Voyeur
diff --git a/engines/voyeur/files.h b/engines/voyeur/files.h
new file mode 100644
index 0000000000..69802d8f68
--- /dev/null
+++ b/engines/voyeur/files.h
@@ -0,0 +1,650 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef VOYEUR_FILES_H
+#define VOYEUR_FILES_H
+
+#include "common/scummsys.h"
+#include "common/file.h"
+#include "common/rect.h"
+#include "common/str.h"
+#include "voyeur/graphics.h"
+
+namespace Voyeur {
+
+class VoyeurEngine;
+class BoltFile;
+class BoltGroup;
+class BoltEntry;
+class RectResource;
+class PictureResource;
+class ViewPortResource;
+class ViewPortListResource;
+class FontResource;
+class CMapResource;
+class VInitCycleResource;
+class PtrResource;
+class ControlResource;
+class StateResource;
+class ThreadResource;
+
+#define DECOMPRESS_SIZE 0x7000
+
+class ResolveEntry {
+public:
+ uint32 _id;
+ byte **_p;
+
+ ResolveEntry(uint32 id, byte **p) { _id = id; _p = p; }
+};
+
+class BoltFilesState {
+public:
+ VoyeurEngine *_vm;
+ BoltFile *_curLibPtr;
+ BoltGroup *_curGroupPtr;
+ BoltEntry *_curMemberPtr;
+ byte *_curMemInfoPtr;
+ int _fromGroupFlag;
+ byte _xorMask;
+ bool _encrypt;
+ int _curFilePosition;
+ int _bufferEnd;
+ int _bufferBegin;
+ int _bytesLeft;
+ int _bufSize;
+ byte *_bufStart;
+ byte *_bufPos;
+ byte _decompressBuf[DECOMPRESS_SIZE];
+ int _historyIndex;
+ byte _historyBuffer[0x200];
+ int _runLength;
+ int _decompState;
+ int _runType;
+ int _runValue;
+ int _runOffset;
+ Common::File *_curFd;
+ Common::Array<ResolveEntry> _resolves;
+
+ byte *_boltPageFrame;
+ int _sImageShift;
+ bool _SVGAReset;
+public:
+ BoltFilesState();
+
+ byte *decompress(byte *buf, int size, int mode);
+ void nextBlock();
+
+ // Methods in the original stubbed under ScummVM
+ void EMSGetFrameAddr(byte **pageFrame) {}
+ bool EMSAllocatePages(uint *planeSize) { return false; }
+ void EMSMapPageHandle(int planeSize, int idx1, int idx2) {}
+};
+
+class BoltFile {
+private:
+ Common::Array<BoltGroup> _groups;
+protected:
+ BoltFilesState &_state;
+
+ virtual void initResource(int resType) = 0;
+ void initDefault();
+private:
+ void resolveAll();
+ byte *getBoltMember(uint32 id);
+
+ // Methods in the original that are stubbed in ScummVM
+ void termType() {}
+ void initMem(int id) {}
+ void termMem() {}
+ void initGro() {}
+ void termGro() {}
+public:
+ Common::File _file;
+public:
+ BoltFile(const Common::String &filename, BoltFilesState &state);
+ virtual ~BoltFile();
+
+ BoltGroup *getBoltGroup(uint16 id, bool process = true);
+ void freeBoltGroup(uint16 id, bool freeEntries = true);
+ void freeBoltMember(uint32 id);
+ byte *memberAddr(uint32 id);
+ byte *memberAddrOffset(uint32 id);
+ void resolveIt(uint32 id, byte **p);
+ void resolveFunction(uint32 id, GraphicMethodPtr *fn);
+
+ BoltEntry &boltEntry(uint16 id);
+ BoltEntry &getBoltEntryFromLong(uint32 id);
+ PictureResource *getPictureResource(uint32 id);
+ CMapResource *getCMapResource(uint32 id);
+};
+
+class BVoyBoltFile: public BoltFile {
+private:
+ // initType method table
+ void sInitRect();
+ void sInitPic();
+ void vInitCMap();
+ void vInitCycl();
+ void initViewPort();
+ void initViewPortList();
+ void initFontInfo();
+ void initFont();
+ void initSoundMap();
+protected:
+ virtual void initResource(int resType);
+public:
+ BVoyBoltFile(BoltFilesState &state);
+};
+
+class StampBoltFile: public BoltFile {
+private:
+ void initThread();
+ void initState();
+ void initPtr();
+ void initControl();
+protected:
+ virtual void initResource(int resType);
+public:
+ StampBoltFile(BoltFilesState &state);
+};
+
+class BoltGroup {
+private:
+ Common::SeekableReadStream *_file;
+public:
+ byte _loaded;
+ bool _processed;
+ bool _callInitGro;
+ int _termGroIndex;
+ int _count;
+ int _fileOffset;
+ Common::Array<BoltEntry> _entries;
+public:
+ BoltGroup(Common::SeekableReadStream *f);
+ virtual ~BoltGroup();
+
+ void load(uint16 groupId);
+ void unload();
+};
+
+
+class BoltEntry {
+private:
+ Common::SeekableReadStream *_file;
+public:
+ uint16 _id;
+ byte _mode;
+ byte _initMemRequired;
+ byte _initMethod;
+ int _fileOffset;
+ byte _xorMask;
+ int _size;
+ byte *_data;
+
+ // bvoy.blt resource types
+ RectResource *_rectResource;
+ PictureResource *_picResource;
+ ViewPortResource *_viewPortResource;
+ ViewPortListResource *_viewPortListResource;
+ FontResource *_fontResource;
+ FontInfoResource *_fontInfoResource;
+ CMapResource *_cMapResource;
+ VInitCycleResource *_vInitCycleResource;
+
+ // stampblt.blt resource types
+ PtrResource *_ptrResource;
+ ControlResource *_controlResource;
+ StateResource *_stateResource;
+ ThreadResource *_threadResource;
+public:
+ BoltEntry(Common::SeekableReadStream *f, uint16 id);
+ virtual ~BoltEntry();
+
+ void load();
+ bool hasResource() const;
+};
+
+class FilesManager {
+private:
+ int _decompressSize;
+public:
+ BoltFilesState _boltFilesState;
+ BoltFile *_curLibPtr;
+public:
+ FilesManager();
+ void setVm(VoyeurEngine *vm) { _boltFilesState._vm = vm; }
+
+ bool openBoltLib(const Common::String &filename, BoltFile *&boltFile);
+ byte *fload(const Common::String &filename, int *size = NULL);
+};
+
+class RectEntry: public Common::Rect {
+public:
+ int _arrIndex;
+ int _count;
+
+ RectEntry(int x1, int y1, int x2, int y2, int arrIndex, int count);
+};
+
+class RectResource: public Common::Rect {
+public:
+ Common::Array<RectEntry> _entries;
+public:
+ RectResource(const byte *src, int size, bool isExtendedRects);
+ RectResource(int xp, int yp, int width, int height);
+ virtual ~RectResource() {}
+};
+
+enum DisplayFlag { DISPFLAG_1 = 1, DISPFLAG_2 = 2, DISPFLAG_4 = 4, DISPFLAG_8 = 8,
+ DISPFLAG_10 = 0x10, DISPFLAG_20 = 0x20, DISPFLAG_40 = 0x40, DISPFLAG_80 = 0x80,
+ DISPFLAG_100 = 0x100, DISPFLAG_200 = 0x200, DISPFLAG_400 = 0x400,
+ DISPFLAG_800 = 0x800, DISPFLAG_1000 = 0x1000, DISPFLAG_2000 = 0x2000,
+ DISPFLAG_4000 = 0x4000, DISPFLAG_VIEWPORT = 0x8000, DISPFLAG_CURSOR = 0x10000 };
+
+class DisplayResource {
+private:
+ VoyeurEngine *_vm;
+public:
+ uint32 _flags;
+public:
+ DisplayResource();
+ DisplayResource(VoyeurEngine *vm);
+
+ /**
+ * Fill a box of the given size at the current _drawPtr location
+ */
+ void sFillBox(int width, int height);
+
+ /**
+ * Draw text at the current pen position
+ */
+ int drawText(const Common::String &msg);
+
+ /**
+ * Return the width of a given text in the current font
+ */
+ int textWidth(const Common::String &msg);
+
+ /**
+ * Clip the given rectangle by the currently viewable area
+ */
+ bool clipRect(Common::Rect &rect);
+};
+
+/* bvoy.blt resource types */
+
+enum PictureFlag { PICFLAG_2 = 2, PICFLAG_PIC_OFFSET = 8, PICFLAG_CLEAR_SCREEN = 0x10,
+ PICFLAG_20 = 0x20, PICFLAG_HFLIP = 0x40, PICFLAG_VFLIP = 0x80, PICFLAG_100 = 0x100,
+ PICFLAG_CLEAR_SCREEN00 = 0x1000
+};
+
+class PictureResource: public DisplayResource {
+private:
+ /**
+ * Flip the image data horizontally
+ */
+ void flipHorizontal(const byte *data);
+
+ /**
+ * Flip the image data vertically
+ */
+ void flipVertical(const byte *data);
+public:
+ byte _select;
+ byte _pick;
+ byte _onOff;
+ byte _depth;
+ Common::Rect _bounds;
+ uint32 _maskData;
+ uint _planeSize;
+
+ /**
+ * Image data for the picture
+ */
+ byte *_imgData;
+
+ /**
+ * Flag to indicate whether to free the image data
+ */
+ DisposeAfterUse::Flag _freeImgData;
+public:
+ PictureResource(BoltFilesState &state, const byte *src);
+ PictureResource(int flags, int select, int pick, int onOff, int depth,
+ const Common::Rect &bounds, int maskData, byte *imgData, int planeSize);
+ PictureResource(Graphics::Surface *surface);
+ PictureResource();
+ virtual ~PictureResource();
+};
+
+typedef void (ViewPortResource::*ViewPortMethodPtr)();
+
+class ViewPortResource: public DisplayResource {
+private:
+ BoltFilesState &_state;
+private:
+ void setupViewPort(PictureResource *page, Common::Rect *clipRect, ViewPortSetupPtr setupFn,
+ ViewPortAddPtr addFn, ViewPortRestorePtr restoreFn);
+public:
+ ViewPortResource *_parent;
+ int _pageCount;
+ int _pageIndex;
+ int _lastPage;
+ Common::Rect _bounds;
+ int _field18; // Useless variable
+ PictureResource *_currentPic;
+ PictureResource *_activePage;
+ PictureResource *_pages[2];
+ byte *_field30;
+
+ // Rect lists and counts. Note that _rectListCount values of '-1' seem to have
+ // special significance, which is why I'm not making them redundant in favour
+ // of the arrays' .size() method
+ Common::Array<Common::Rect> *_rectListPtr[3];
+ int _rectListCount[3];
+
+ Common::Rect _clipRect;
+ byte *_field7A;
+ GraphicMethodPtr _fn1;
+ ViewPortSetupPtr _setupFn;
+ ViewPortAddPtr _addFn;
+ ViewPortRestorePtr _restoreFn;
+ Common::Rect _fontRect;
+public:
+ ViewPortResource(BoltFilesState &state, const byte *src);
+ virtual ~ViewPortResource();
+
+ void setupViewPort();
+ void setupViewPort(PictureResource *pic, Common::Rect *clipRect = NULL);
+ void addSaveRect(int pageIndex, const Common::Rect &r);
+ void fillPic(byte onOff = 0);
+ void drawIfaceTime();
+ void drawPicPerm(PictureResource *pic, const Common::Point &pt);
+};
+
+class ViewPortPalEntry {
+public:
+ uint16 _rEntry, _gEntry, _bEntry;
+ uint16 _rChange, _gChange, _bChange;
+ uint16 _palIndex;
+public:
+ ViewPortPalEntry(const byte *src);
+};
+
+class ViewPortListResource {
+public:
+ Common::Array<ViewPortPalEntry> _palette;
+ Common::Array<ViewPortResource *> _entries;
+ int _palIndex;
+
+ ViewPortListResource(BoltFilesState &state, const byte *src);
+ virtual ~ViewPortListResource() {}
+};
+
+class FontResource {
+public:
+ int _minChar, _maxChar;
+ int _fontDepth;
+ int _padding;
+ int _fontHeight;
+ int _topPadding;
+ int *_charWidth;
+ byte *_charOffsets;
+ byte *_charImages;
+
+ FontResource(BoltFilesState &state, byte *src);
+ virtual ~FontResource();
+};
+
+enum FontJustify { ALIGN_LEFT = 0, ALIGN_CENTRE = 1, ALIGN_RIGHT = 2 };
+
+class FontInfoResource {
+public:
+ FontResource *_curFont;
+ byte _picFlags;
+ byte _picSelect;
+ byte _picPick;
+ byte _picOnOff;
+ byte _fontFlags;
+ FontJustify _justify;
+ int _fontSaveBack;
+ Common::Point _pos;
+ int _justifyWidth;
+ int _justifyHeight;
+ Common::Point _shadow;
+ int _foreColor;
+ int _backColor;
+ int _shadowColor;
+public:
+ FontInfoResource(BoltFilesState &state, const byte *src);
+ FontInfoResource();
+ FontInfoResource(byte picFlags, byte picSelect, byte picPick, byte picOnOff, byte fontFlags,
+ FontJustify justify, int fontSaveBack, const Common::Point &pos, int justifyWidth,
+ int justifyHeight, const Common::Point &shadow, int foreColor, int backColor,
+ int shadowColor);
+};
+
+class CMapResource {
+private:
+ VoyeurEngine *_vm;
+public:
+ int _steps;
+ int _fadeStatus;
+ int _start;
+ int _end;
+ byte *_entries;
+public:
+ CMapResource(BoltFilesState &state, const byte *src);
+ virtual ~CMapResource();
+
+ void startFade();
+};
+
+class VInitCycleResource {
+private:
+ BoltFilesState &_state;
+public:
+ int _type[4];
+ byte *_ptr[4];
+public:
+ VInitCycleResource(BoltFilesState &state, const byte *src);
+ virtual ~VInitCycleResource() {}
+
+ void vStartCycle(int flags = 0);
+ void vStopCycle();
+};
+
+/* stampblt.blt resources */
+
+class PtrResource {
+public:
+ Common::Array<BoltEntry *> _entries;
+
+ PtrResource(BoltFilesState &state, const byte *src);
+ virtual ~PtrResource() {}
+};
+
+class ControlResource {
+public:
+ int _memberIds[8];
+ byte *_entries[8];
+ int _stateId;
+ StateResource *_state;
+
+ ControlResource(BoltFilesState &state, const byte *src);
+ virtual ~ControlResource() {}
+};
+
+/**
+ * Stores data about the intended victim
+ */
+class StateResource {
+public:
+ int _vals[4];
+ int &_victimIndex;
+ int &_victimEvidenceIndex;
+ int &_victimMurderIndex;
+
+ StateResource(BoltFilesState &state, const byte *src);
+ virtual ~StateResource() {}
+
+ /**
+ * Synchronizes the game data
+ */
+ void synchronize(Common::Serializer &s);
+};
+
+class ThreadResource {
+public:
+ static int _useCount[8];
+ static byte *_threadDataPtr;
+ static CMapResource *_cmd14Pal;
+ static void initUseCount();
+ static void unloadAllStacks(VoyeurEngine *vm);
+
+ static void init();
+private:
+ VoyeurEngine *_vm;
+ Common::Point _aptPos;
+private:
+ bool getStateInfo();
+ byte *getDataOffset();
+ void getButtonsText();
+ void getButtonsFlags();
+ void getButtonsUnused();
+ void performOpenCard();
+ const byte *getRecordOffset(const byte *p);
+ const byte *getNextRecord(const byte *p);
+ const byte *getSTAMPCard(int cardId);
+ int getStateFromID(uint32 id);
+ uint32 getSID(int sid);
+ void cardAction(const byte *p);
+ void doSTAMPCardAction();
+ bool goToStateID(int stackId, int id);
+ const byte *cardPerform(const byte *card);
+ bool cardPerform2(const byte *p, int cardCmdId);
+ void savePrevious();
+ void setButtonFlag(int idx, byte bits);
+ void clearButtonFlag(int idx, byte bits);
+
+ /**
+ * Frees the apartment screen data
+ */
+ void freeTheApt();
+
+ /**
+ * Does any necessary animation at the start or end of showing the apartment.
+ */
+ void doAptAnim(int mode);
+
+ /**
+ * Updates the mansion scroll position if ncessary, and returns true if it
+ * has been changed.
+ */
+ bool checkMansionScroll();
+public:
+ int _stateId;
+ int _stackId;
+ int _savedStateId;
+ int _savedStackId;
+ int _newStateId;
+ int _newStackId;
+ int _flags;
+ int _fieldA[8]; // Useless variable
+ int _field2A[8]; // Useless variable
+ int _stateFlags;
+ int _stateCount;
+ int _parseCount;
+ uint32 _nextStateId;
+ byte *_threadInfoPtr;
+ byte _buttonFlags[64];
+ const byte *_field8E[64]; // Useless variable
+ byte _buttonIds[64];
+ const byte *_buttonUnused[48];
+ byte *_ctlPtr;
+ byte *_playCommandsPtr;
+public:
+ ThreadResource(BoltFilesState &state, const byte *src);
+ virtual ~ThreadResource() {}
+
+ /**
+ * Initialize the thread
+ */
+ void initThreadStruct(int idx, int id);
+
+ /**
+ * Loads the specified stack
+ */
+ bool loadAStack(int stackId);
+
+ /**
+ * Unloads the specified stack
+ */
+ void unloadAStack(int stackId);
+
+ /**
+ * Go to a new state and/or stack
+ */
+ bool goToState(int stackId, int stateId);
+
+ /**
+ * Initializes data for the thread based on the current state
+ */
+ bool doState();
+
+ bool chooseSTAMPButton(int buttonId);
+
+ /**
+ * Parses the script commands from the currently active stack
+ */
+ void parsePlayCommands();
+
+ /**
+ * Do the camera view looking at the mansion
+ */
+ int doInterface();
+
+ /**
+ * Do the display of a room that has one or more evidence hotspots
+ * available for display
+ */
+ void doRoom();
+
+ /**
+ * Shows the apartment screen
+ */
+ int doApt();
+
+ /**
+ * Loads data needed for displaying the initial apartment screen
+ */
+ void loadTheApt();
+
+ /**
+ * Synchronizes the game data
+ */
+ void synchronize(Common::Serializer &s);
+};
+
+} // End of namespace Voyeur
+
+#endif /* VOYEUR_FILES_H */
diff --git a/engines/voyeur/files_threads.cpp b/engines/voyeur/files_threads.cpp
new file mode 100644
index 0000000000..5989c92439
--- /dev/null
+++ b/engines/voyeur/files_threads.cpp
@@ -0,0 +1,1738 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "voyeur/files.h"
+#include "voyeur/graphics.h"
+#include "voyeur/voyeur.h"
+#include "voyeur/staticres.h"
+
+namespace Voyeur {
+
+int ThreadResource::_useCount[8];
+byte *ThreadResource::_threadDataPtr;
+CMapResource *ThreadResource::_cmd14Pal;
+
+void ThreadResource::init() {
+ Common::fill(&_useCount[0], &_useCount[8], 0);
+ _threadDataPtr = nullptr;
+ _cmd14Pal = nullptr;
+}
+
+ThreadResource::ThreadResource(BoltFilesState &state, const byte *src):
+ _vm(state._vm) {
+ _stateId = READ_LE_UINT16(&src[0]);
+ _stackId = READ_LE_UINT16(&src[0]);
+ _savedStateId = READ_LE_UINT16(&src[0]);
+ _savedStackId = READ_LE_UINT16(&src[0]);
+ _flags = src[8];
+ _ctlPtr = nullptr;
+ _aptPos = Common::Point(-1, -1);
+}
+
+void ThreadResource::initThreadStruct(int idx, int id) {
+ _stackId = -1;
+ if (loadAStack(idx)) {
+ _savedStateId = _savedStackId = -1;
+ _stateId = id;
+ _newStateId = -1;
+ _newStackId = -1;
+
+ doState();
+ }
+}
+
+bool ThreadResource::loadAStack(int stackId) {
+ if (_vm->_stampFlags & 1) {
+ unloadAStack(_stackId);
+ if (!_useCount[stackId]) {
+ BoltEntry &boltEntry = _vm->_stampLibPtr->boltEntry(_vm->_controlPtr->_memberIds[stackId]);
+ if (!boltEntry._data)
+ return false;
+
+ _vm->_controlPtr->_entries[stackId] = boltEntry._data;
+ }
+
+ ++_useCount[stackId];
+ }
+
+ _ctlPtr = _vm->_controlPtr->_entries[stackId];
+ _stackId = stackId;
+ return true;
+}
+
+void ThreadResource::unloadAStack(int stackId) {
+ if ((_vm->_stampFlags & 1) && _useCount[stackId]) {
+ if (--_useCount[stackId] == 0) {
+ _vm->_stampLibPtr->freeBoltMember(_vm->_controlPtr->_memberIds[stackId]);
+ }
+ }
+}
+
+bool ThreadResource::doState() {
+ _flags |= 1;
+
+ if (!getStateInfo())
+ return false;
+
+ getButtonsFlags();
+ getButtonsUnused();
+
+ _vm->_glGoState = -1;
+ _vm->_glGoStack = -1;
+
+ performOpenCard();
+ if (_stateFlags & 1) {
+ return chooseSTAMPButton(_vm->getRandomNumber(_stateCount - 1));
+ } else {
+ return true;
+ }
+}
+
+bool ThreadResource::getStateInfo() {
+ _flags &= 0xff;
+ int id = READ_LE_UINT16(_ctlPtr);
+
+ if (id <= _stateId) {
+ _flags |= 0x8000;
+ return false;
+ } else {
+ uint32 fld = READ_LE_UINT32(_ctlPtr + 2);
+ fld += _stateId << 3;
+ _nextStateId = READ_LE_UINT32(_ctlPtr + fld + 4);
+
+ fld = READ_LE_UINT32(_ctlPtr + fld);
+ byte *baseP = _ctlPtr + fld;
+ _stateCount = READ_LE_UINT16(baseP);
+ _stateFlags = READ_LE_UINT16(baseP + 2);
+ _parseCount = READ_LE_UINT16(baseP + 4);
+
+ _playCommandsPtr = getDataOffset();
+ _playCommandsPtr += (READ_LE_UINT32(baseP + 6) / 2) << 1;
+
+ _threadInfoPtr = baseP + 10;
+
+ getButtonsText();
+ return true;
+ }
+}
+
+byte *ThreadResource::getDataOffset() {
+ uint32 offset = READ_LE_UINT32(_ctlPtr + 10);
+ _threadDataPtr = _ctlPtr + offset;
+ return _threadDataPtr;
+}
+
+void ThreadResource::getButtonsText() {
+ int idx = 0;
+
+ for (const byte *p = _threadInfoPtr; *p != 0x49; p = getNextRecord(p)) {
+ if (*p == 0xC0) {
+ ++p;
+ if (*p++ & 0x80) {
+ assert(idx < 63);
+ _field8E[idx] = getRecordOffset(p);
+ p += 4;
+ }
+
+ ++idx;
+ _field8E[idx] = NULL;
+ }
+ }
+}
+
+void ThreadResource::getButtonsFlags() {
+ int idx = 0;
+
+ for (const byte *p = _threadInfoPtr; *p != 0x49; p = getNextRecord(p)) {
+ if (*p == 0xC0) {
+ if (*++p & 0x20)
+ _stateFlags |= 2;
+
+ _buttonFlags[idx] = *p++;
+ _buttonIds[idx] = *p++;
+
+ if (_buttonFlags[idx] & 0x80)
+ p += 4;
+
+ ++idx;
+ }
+ }
+}
+
+void ThreadResource::getButtonsUnused() {
+ int idx = 0;
+
+ for (const byte *p = _threadInfoPtr; *p++ != 0x4A; p = getNextRecord(p)) {
+ assert(idx < 47);
+ _buttonUnused[idx++] = getRecordOffset(p);
+ _buttonUnused[idx] = nullptr;
+ p += 4;
+ }
+}
+
+void ThreadResource::unloadAllStacks(VoyeurEngine *vm) {
+ if (vm->_stampFlags & 1) {
+ for (int i = 0; i < 8; ++i) {
+ if (_useCount[i])
+ vm->_stampLibPtr->freeBoltMember(vm->_controlPtr->_memberIds[i]);
+ }
+ }
+}
+
+void ThreadResource::performOpenCard() {
+ for (const byte *p = _threadInfoPtr; *p != 0x49; p = getNextRecord(p)) {
+ if (*p == 0x47) {
+ cardAction(p + 1);
+ return;
+ }
+ }
+}
+
+void ThreadResource::initUseCount() {
+ Common::fill(&_useCount[0], &_useCount[8], 0);
+}
+
+const byte *ThreadResource::getRecordOffset(const byte *p) {
+ uint32 recSize = READ_LE_UINT32(p) + READ_LE_UINT32(_ctlPtr + 6);
+ return _ctlPtr + recSize;
+}
+
+const byte *ThreadResource::getNextRecord(const byte *p) {
+ byte v = *p++;
+
+ switch (v) {
+ case 2:
+ case 4:
+ case 6:
+ case 8:
+ case 10:
+ return p + 8;
+ case 1:
+ case 3:
+ case 5:
+ case 7:
+ case 9:
+ case 11:
+ case 21:
+ case 22:
+ case 25:
+ case 26:
+ return p + 5;
+ case 17:
+ case 23:
+ case 24:
+ case 27:
+ case 28:
+ return p + 2;
+ case 19:
+ case 41:
+ return p + 6;
+ case 18:
+ case 51:
+ case 52:
+ return p + 1;
+ case 74:
+ return p + 4;
+ case 192:
+ if (*p & 0x80)
+ p += 4;
+ return p + 2;
+ default:
+ return p;
+ }
+}
+
+const byte *ThreadResource::getSTAMPCard(int cardId) {
+ const byte *p;
+ int count = 0;
+
+ for (p = _threadInfoPtr; count <= cardId && *p != 0x49; p = getNextRecord(p)) {
+ if (*p == 0xC0)
+ ++count;
+ }
+
+ return p;
+}
+
+int ThreadResource::getStateFromID(uint32 id) {
+ int count = READ_LE_UINT16(_ctlPtr);
+
+ for (int i = 0; i < count; ++i) {
+ uint32 sid = getSID(i);
+ if (sid == id)
+ return i;
+ }
+
+ return -1;
+}
+
+uint32 ThreadResource::getSID(int sid) {
+ uint32 offset = READ_LE_UINT32(_ctlPtr + 2) + (sid << 3) + 4;
+ return READ_LE_UINT32(_ctlPtr + offset);
+}
+
+void ThreadResource::doSTAMPCardAction() {
+ for (const byte *p = _threadInfoPtr; *p != 0x49; p = getNextRecord(p)) {
+ if (*p == 0x48) {
+ cardAction(p + 1);
+ return;
+ }
+ }
+}
+
+void ThreadResource::cardAction(const byte *card) {
+ _vm->_glGoState = -1;
+ _vm->_glGoStack = -1;
+
+ // Loop to perform card commands
+ while (!_vm->shouldQuit() && *card < 70 && _vm->_glGoState == -1) {
+ card = cardPerform(card);
+ }
+}
+
+bool ThreadResource::chooseSTAMPButton(int buttonId) {
+ _flags &= ~1;
+
+ for (int idx = 0; idx < _stateCount; ++idx) {
+ if (_buttonIds[idx] == buttonId) {
+ const byte *card = getSTAMPCard(idx);
+ cardAction(card);
+
+ bool flag = true;
+ while (!_vm->shouldQuit() && _vm->_glGoStack != -1 && flag) {
+ doSTAMPCardAction();
+ flag = goToStateID(_vm->_glGoStack, _vm->_glGoState);
+ }
+
+ while (!_vm->shouldQuit() && _vm->_glGoState != -1 && flag) {
+ doSTAMPCardAction();
+ flag = goToState(-1, _vm->_glGoState);
+ }
+
+ return flag;
+ }
+ }
+
+ return false;
+}
+
+void ThreadResource::parsePlayCommands() {
+ _vm->_voy._playStampMode = -1;
+ _vm->_voy._audioVisualStartTime = 0;
+ _vm->_voy._audioVisualDuration = 0;
+ _vm->_voy._boltGroupId2 = -1;
+ _vm->_voy._computerTextId = -1;
+ _vm->_voy._eventFlags &= ~EVTFLAG_8;
+ _vm->_eventsManager._videoDead = -1;
+
+ // Reset hotspot data
+ _vm->_voy._videoHotspotTimes.reset();
+ _vm->_voy._audioHotspotTimes.reset();
+ _vm->_voy._evidenceHotspotTimes.reset();
+ Common::fill(&_vm->_voy._roomHotspotsEnabled[0], &_vm->_voy._roomHotspotsEnabled[20], false);
+ byte *dataP = _playCommandsPtr;
+ int v2, v3;
+ PictureResource *pic;
+ CMapResource *pal;
+
+ for (int parseIndex = 0; parseIndex < _parseCount; ++parseIndex) {
+ uint16 id = READ_LE_UINT16(dataP);
+ debugC(DEBUG_BASIC, kDebugScripts, "parsePlayCommands (%d of %d) - cmd #%d",
+ parseIndex + 1, _parseCount, id);
+ dataP += 2;
+
+ switch (id) {
+ case 1:
+ _vm->_currentVocId = READ_LE_UINT16(dataP);
+ dataP += 2;
+ break;
+
+ case 2:
+ // Play an audio event
+ v2 = READ_LE_UINT16(dataP);
+
+ if (v2 == 0 || _vm->_controlPtr->_state->_victimIndex == v2) {
+ _vm->_audioVideoId = READ_LE_UINT16(dataP + 2) - 1;
+ _vm->_voy._audioVisualStartTime = READ_LE_UINT16(dataP + 4);
+ _vm->_voy._audioVisualDuration = READ_LE_UINT16(dataP + 6);
+
+ if (_vm->_voy._RTVNum < _vm->_voy._audioVisualStartTime ||
+ (_vm->_voy._audioVisualStartTime + _vm->_voy._audioVisualDuration) < _vm->_voy._RTVNum) {
+ _vm->_audioVideoId = -1;
+ } else {
+ _vm->_voy._vocSecondsOffset = _vm->_voy._RTVNum - _vm->_voy._audioVisualStartTime;
+ _vm->_voy.addAudioEventStart();
+
+ // Play the audio
+ assert(_vm->_audioVideoId < 38);
+ _vm->playAudio(_vm->_audioVideoId);
+
+ _vm->_voy.addAudioEventEnd();
+ _vm->_eventsManager.incrementTime(1);
+ _vm->_eventsManager.incrementTime(1);
+ _vm->_audioVideoId = -1;
+ parseIndex = 999;
+ }
+ }
+
+ dataP += 8;
+ break;
+
+ case 3:
+ // Play a video event
+ v2 = READ_LE_UINT16(dataP);
+
+ if (v2 == 0 || _vm->_controlPtr->_state->_victimIndex == v2) {
+ _vm->_audioVideoId = READ_LE_UINT16(dataP + 2) - 1;
+ _vm->_voy._audioVisualStartTime = READ_LE_UINT16(dataP + 4);
+ _vm->_voy._audioVisualDuration = READ_LE_UINT16(dataP + 6);
+
+ if (_vm->_voy._RTVNum < _vm->_voy._audioVisualStartTime ||
+ (_vm->_voy._audioVisualStartTime + _vm->_voy._audioVisualDuration) < _vm->_voy._RTVNum) {
+ _vm->_audioVideoId = -1;
+ } else {
+ _vm->_voy._vocSecondsOffset = _vm->_voy._RTVNum - _vm->_voy._audioVisualStartTime;
+ _vm->_voy.addVideoEventStart();
+ _vm->_voy._eventFlags &= ~EVTFLAG_TIME_DISABLED;
+ _vm->_voy._eventFlags |= EVTFLAG_RECORDING;
+ _vm->playAVideo(_vm->_audioVideoId);
+
+ _vm->_voy._eventFlags &= ~EVTFLAG_RECORDING;
+ _vm->_voy._eventFlags |= EVTFLAG_TIME_DISABLED;
+ _vm->_voy.addVideoEventEnd();
+ _vm->_eventsManager.incrementTime(1);
+
+ _vm->_audioVideoId = -1;
+ _vm->_playStampGroupId = -1;
+
+ if (_vm->_eventsManager._videoDead != -1) {
+ _vm->_bVoy->freeBoltGroup(0xE00);
+ _vm->_eventsManager._videoDead = -1;
+ _vm->flipPageAndWait();
+ }
+
+ _vm->_eventsManager._videoDead = -1;
+ if (_stateCount == 2 && _vm->_eventsManager._mouseClicked == 0) {
+ _vm->_voy._playStampMode = 132;
+ parseIndex = 999;
+ } else {
+ _vm->_voy._playStampMode = 129;
+ }
+ }
+ }
+
+ dataP += 8;
+ break;
+
+ case 4:
+ case 22:
+ // Case 22: Endgame news reports
+ _vm->_audioVideoId = READ_LE_UINT16(dataP) - 1;
+ dataP += 2;
+
+ if (id == 22) {
+ int resolveIndex = READ_LE_UINT16(dataP);
+ dataP += 2;
+ _vm->_playStampGroupId = _vm->_resolvePtr[resolveIndex];
+ }
+
+ _vm->_voy._vocSecondsOffset = 0;
+ _vm->_voy._audioVisualStartTime = _vm->_voy._RTVNum;
+ _vm->_voy._eventFlags &= ~(EVTFLAG_TIME_DISABLED | EVTFLAG_RECORDING);
+ _vm->playAVideo(_vm->_audioVideoId);
+ _vm->_voy._eventFlags |= EVTFLAG_TIME_DISABLED;
+
+ if (id != 22) {
+ _vm->_audioVideoId = -1;
+ parseIndex = 999;
+ } else {
+ int count = _vm->_bVoy->getBoltGroup(_vm->_playStampGroupId)->_entries.size() / 2;
+ _vm->_soundManager.stopVOCPlay();
+ _vm->_eventsManager.getMouseInfo();
+
+ for (int i = 0; i < count; ++i) {
+ pic = _vm->_bVoy->boltEntry(_vm->_playStampGroupId + i * 2)._picResource;
+ pal = _vm->_bVoy->boltEntry(_vm->_playStampGroupId + i * 2 + 1)._cMapResource;
+
+ (*_vm->_graphicsManager._vPort)->setupViewPort(pic);
+ pal->startFade();
+
+ _vm->flipPageAndWaitForFade();
+
+ if (i > 0) {
+ _vm->_bVoy->freeBoltMember(_vm->_playStampGroupId + i * 2);
+ _vm->_bVoy->freeBoltMember(_vm->_playStampGroupId + i * 2 + 1);
+ }
+
+ Common::String file = Common::String::format("news%d.voc", i + 1);
+ _vm->_soundManager.startVOCPlay(file);
+
+ while (!_vm->shouldQuit() && !_vm->_eventsManager._mouseClicked &&
+ _vm->_soundManager.getVOCStatus()) {
+ _vm->_eventsManager.delayClick(1);
+ _vm->_eventsManager.getMouseInfo();
+ }
+
+ _vm->_soundManager.stopVOCPlay();
+
+ if (i == (count - 1))
+ _vm->_eventsManager.delayClick(480);
+
+ if (_vm->shouldQuit() || _vm->_eventsManager._mouseClicked)
+ break;
+ }
+
+ _vm->_bVoy->freeBoltGroup(_vm->_playStampGroupId);
+ _vm->_playStampGroupId = -1;
+ _vm->_audioVideoId = -1;
+ parseIndex = 999;
+ }
+ break;
+
+ case 5:
+ // Check whether transition to a given time period is allowed, and
+ // if so, load the time information for the new time period
+ v2 = READ_LE_UINT16(dataP);
+ if (v2 == 0 || _vm->_controlPtr->_state->_victimIndex == v2) {
+ _vm->_voy._playStampMode = 5;
+ int count = READ_LE_UINT16(dataP + 2);
+ _vm->_voy._RTVLimit = READ_LE_UINT16(dataP + 4);
+
+ if (_vm->_voy._transitionId != count) {
+ if (_vm->_voy._transitionId > 1)
+ _vm->_voy._eventFlags &= ~EVTFLAG_100;
+
+ _vm->_voy._transitionId = count;
+ _vm->_gameMinute = LEVEL_M[count - 1];
+ _vm->_gameHour = LEVEL_H[count - 1];
+ //_vm->_v2A0A2 = 0;
+ _vm->_voy._RTVNum = 0;
+ _vm->_voy._RTANum = 255;
+ }
+
+ _vm->_voy._isAM = (_vm->_voy._transitionId == 6);
+ }
+
+ dataP += 6;
+ break;
+
+ case 6:
+ _vm->_voy._playStampMode = 6;
+ v2 = READ_LE_UINT16(dataP);
+ _vm->_playStampGroupId = _vm->_resolvePtr[v2];
+ dataP += 2;
+ break;
+
+ case 7:
+ // Load the video event scene hotspot times data
+ v2 = READ_LE_UINT16(dataP);
+ v3 = READ_LE_UINT16(dataP + 2) - 1;
+
+ if (v2 == 0 || _vm->_controlPtr->_state->_victimIndex == v2) {
+ int idx = 0;
+ while (_vm->_voy._videoHotspotTimes._min[idx][v3] != 9999)
+ ++idx;
+
+ v2 = READ_LE_UINT16(dataP + 4);
+ _vm->_voy._videoHotspotTimes._min[idx][v3] = v2;
+ _vm->_voy._videoHotspotTimes._max[idx][v3] = v2 + READ_LE_UINT16(dataP + 6) - 2;
+ }
+
+ dataP += 8;
+ break;
+
+ case 8:
+ // Load the audio event scene hotspot times data
+ v2 = READ_LE_UINT16(dataP);
+ v3 = READ_LE_UINT16(dataP + 2) - 1;
+
+ if (v2 == 0 || _vm->_controlPtr->_state->_victimIndex == v2) {
+ int idx = 0;
+ while (_vm->_voy._audioHotspotTimes._min[idx][v3] != 9999)
+ ++idx;
+
+ v2 = READ_LE_UINT16(dataP + 4);
+ _vm->_voy._audioHotspotTimes._min[idx][v3] = v2;
+ _vm->_voy._audioHotspotTimes._max[idx][v3] = v2 + READ_LE_UINT16(dataP + 6) - 2;
+ }
+
+ dataP += 8;
+ break;
+
+ case 9:
+ // Load up evidence event scene hotspot times data
+ v2 = READ_LE_UINT16(dataP);
+ v3 = READ_LE_UINT16(dataP + 2) - 1;
+
+ if (v2 == 0 || _vm->_controlPtr->_state->_victimIndex == v2) {
+ int idx = 0;
+ while (_vm->_voy._evidenceHotspotTimes._min[idx][v3] != 9999)
+ ++idx;
+
+ v2 = READ_LE_UINT16(dataP + 4);
+ _vm->_voy._evidenceHotspotTimes._min[idx][v3] = v2;
+ _vm->_voy._evidenceHotspotTimes._max[idx][v3] = v2 + READ_LE_UINT16(dataP + 6) - 2;
+ }
+
+ dataP += 8;
+ break;
+
+ case 10:
+ // Pick the person who is to die, during startup
+ if (_vm->_iForceDeath == -1) {
+ // No specific person has been preset to be killed, so pick one randomly.
+ // The loop below was used because the victim was persisted from the previous
+ // play-through, so it ensured that a different victim is picked.
+ int randomVal;
+ do {
+ randomVal = _vm->getRandomNumber(3) + 1;
+ } while (randomVal == _vm->_voy._victimNumber);
+
+ _vm->_voy._victimNumber = randomVal;
+ _vm->_controlPtr->_state->_victimIndex = randomVal;
+ } else {
+ // Player has seen something that locks in the character to die
+ _vm->_voy._victimNumber = _vm->_iForceDeath;
+ _vm->_controlPtr->_state->_victimIndex = _vm->_iForceDeath;
+ }
+
+ _vm->saveLastInplay();
+ break;
+
+ case 11:
+ _vm->_voy._eventFlags |= EVTFLAG_2;
+ break;
+
+ case 12:
+ v2 = READ_LE_UINT16(dataP);
+
+ if (v2 == 0 || _vm->_controlPtr->_state->_victimIndex == v2) {
+ _vm->_voy._boltGroupId2 = _vm->_resolvePtr[READ_LE_UINT16(dataP + 2)];
+ _vm->_voy._roomHotspotsEnabled[READ_LE_UINT16(dataP + 4) - 1] = true;
+ }
+
+ dataP += 6;
+ break;
+
+ case 13:
+ v2 = READ_LE_UINT16(dataP);
+
+ if (v2 == 0 || _vm->_controlPtr->_state->_victimIndex == v2) {
+ _vm->_voy._computerTextId = READ_LE_UINT16(dataP + 2);
+ _vm->_voy._computerTimeMin = READ_LE_UINT16(dataP + 4);
+ _vm->_voy._computerTimeMax = READ_LE_UINT16(dataP + 6);
+
+ _vm->_voy._rect4E4.left = COMP_BUT_TABLE[_vm->_voy._computerTextId * 4];
+ _vm->_voy._rect4E4.top = COMP_BUT_TABLE[_vm->_voy._computerTextId * 4 + 1];
+ _vm->_voy._rect4E4.right = COMP_BUT_TABLE[_vm->_voy._computerTextId * 4 + 2];
+ _vm->_voy._rect4E4.bottom = COMP_BUT_TABLE[_vm->_voy._computerTextId * 4 + 3];
+ }
+
+ dataP += 8;
+ break;
+
+ case 14:
+ _vm->_playStampGroupId = 2048;
+ _vm->_voy._playStampMode = 130;
+ break;
+
+ case 15:
+ _vm->showEndingNews();
+ break;
+
+ case 16:
+ _vm->_voy._playStampMode = 16;
+ break;
+
+ case 17:
+ _vm->_voy._playStampMode = 17;
+ break;
+
+ case 18:
+ // Called during the murder (Sunday 10:30PM) time period, to specify the
+ // time expired point at which the murder takes place
+ v2 = READ_LE_UINT16(dataP);
+ v3 = READ_LE_UINT16(dataP + 2);
+
+ if (v2 == 0 || _vm->_controlPtr->_state->_victimIndex == v2)
+ _vm->_voy._murderThreshold = v3;
+
+ dataP += 4;
+ break;
+
+ case 19:
+ _vm->_voy._aptLoadMode = 140;
+ loadTheApt();
+ _vm->_voy._aptLoadMode = 141;
+ freeTheApt();
+ break;
+
+ case 20:
+ _vm->_voy._aptLoadMode = -1;
+ loadTheApt();
+ _vm->_voy._aptLoadMode = 141;
+ freeTheApt();
+ break;
+
+ case 21:
+ _vm->_voy._aptLoadMode = -1;
+ loadTheApt();
+ _vm->_voy._aptLoadMode = 140;
+ freeTheApt();
+ break;
+
+ case 23:
+ _vm->_voy._transitionId = 17;
+ _vm->_voy._aptLoadMode = -1;
+ loadTheApt();
+ _vm->_voy._aptLoadMode = 144;
+ freeTheApt();
+ break;
+
+ default:
+ break;
+ }
+ }
+}
+
+const byte *ThreadResource::cardPerform(const byte *card) {
+ uint16 id = *card++;
+ int varD = 5;
+ uint32 v2;
+ byte bVal;
+ uint32 idx1, idx2;
+ debugC(DEBUG_BASIC, kDebugScripts, "cardPerform - %d", id);
+
+ switch (id) {
+ case 1:
+ v2 = READ_LE_UINT32(card);
+ card += 4;
+ _vm->_controlPtr->_state->_vals[*card++] = v2;
+ break;
+
+ case 2:
+ v2 = _vm->_controlPtr->_state->_vals[*card++];
+ _vm->_controlPtr->_state->_vals[*card++] = v2;
+ break;
+
+ case 3:
+ v2 = READ_LE_UINT32(card);
+ card += 4;
+ _vm->_controlPtr->_state->_vals[*card++] = v2;
+ break;
+
+ case 4:
+ v2 = _vm->_controlPtr->_state->_vals[*card++];
+ _vm->_controlPtr->_state->_vals[*card++] = v2;
+ break;
+
+ case 5: {
+ v2 = READ_LE_UINT32(card);
+ card += 4;
+ int &v = _vm->_controlPtr->_state->_vals[*card++];
+ v -= v2;
+ break;
+ }
+
+ case 6: {
+ idx1 = *card++;
+ idx2 = *card++;
+
+ v2 = _vm->_controlPtr->_state->_vals[idx1];
+ int &v = _vm->_controlPtr->_state->_vals[idx2];
+ v -= v2;
+ break;
+ }
+
+ case 7: {
+ int v3 = *card++;
+ v2 = READ_LE_UINT32(card);
+ card += 4;
+ int &v = _vm->_controlPtr->_state->_vals[v3];
+ v *= v2;
+ break;
+ }
+
+ case 8: {
+ idx1 = *card++;
+ idx2 = *card++;
+
+ int &v1 = _vm->_controlPtr->_state->_vals[idx1];
+ int &v2 = _vm->_controlPtr->_state->_vals[idx2];
+ v1 *= v2;
+ break;
+ }
+
+ case 9: {
+ idx1 = *card++;
+ v2 = READ_LE_UINT32(card);
+ card += 4;
+
+ int &v = _vm->_controlPtr->_state->_vals[idx1];
+ v /= v2;
+ break;
+ }
+
+ case 10: {
+ idx1 = *card++;
+ idx2 = *card++;
+
+ int &v1 = _vm->_controlPtr->_state->_vals[idx1];
+ int &v2 = _vm->_controlPtr->_state->_vals[idx2];
+ v1 /= v2;
+ break;
+ }
+
+ case 11:
+ v2 = READ_LE_UINT32(card);
+ card += 4;
+ v2 = _vm->getRandomNumber(v2 - 1) + 1;
+ _vm->_controlPtr->_state->_vals[*card++] = v2;
+ break;
+
+ case 17:
+ _vm->_glGoState = READ_LE_UINT16(card);
+ card += 2;
+ _vm->_glGoStack = -1;
+ break;
+
+ case 18:
+ v2 = _vm->_controlPtr->_state->_vals[*card++];
+ _vm->_glGoState = getStateFromID(v2);
+ break;
+
+ case 19:
+ _vm->_glGoState = READ_LE_UINT32(card);
+ card += 4;
+ _vm->_glGoStack = READ_LE_UINT16(card);
+ card += 2;
+ break;
+
+ case 23:
+ case 24:
+ case 27:
+ case 28:
+ varD -= 3;
+ // Deliberate fall-through
+
+ case 21:
+ case 22:
+ case 25:
+ case 26:
+ bVal = card[varD];
+ if (bVal == 61) {
+ if (cardPerform2(card, id)) {
+ card += varD;
+ while (*card != 30 && *card != 29)
+ card = cardPerform(card);
+
+ if (*card == 29) {
+ int count = 1;
+ while (count > 0) {
+ card = getNextRecord(card);
+ if (*card == 30)
+ --count;
+ if (*card >= 21 && *card <= 28)
+ ++count;
+ }
+ }
+ } else {
+ card += varD;
+ int count = 1;
+ while (count > 0) {
+ card = getNextRecord(card);
+ if (*card == 29 || *card == 30)
+ --count;
+ if (*card < 21 || *card > 28)
+ continue;
+
+ const byte *nextP = getNextRecord(card + 2);
+ if (*nextP == 61)
+ ++count;
+ }
+ }
+
+ ++card;
+ } else {
+ if (cardPerform2(card, id)) {
+ card += varD;
+ card = cardPerform(card);
+ while (*card++ != 61) ;
+ } else {
+ card += varD;
+ while (*card != 61 && *card != 29)
+ ++card;
+ }
+ }
+ break;
+
+ case 41:
+ bVal = *card++;
+ assert(bVal < 8);
+ _fieldA[bVal] = READ_LE_UINT32(card);
+ card += 4;
+
+ _field2A[bVal] = READ_LE_UINT16(card);
+ card += 2;
+
+ case 45:
+ _newStateId = _nextStateId;
+ _newStackId = _stackId;
+ break;
+
+ case 46:
+ _vm->_glGoState = _newStateId;
+ _vm->_glGoStack = _newStackId;
+ _newStateId = -1;
+ _newStackId = -1;
+ break;
+
+ case 51:
+ setButtonFlag(READ_LE_UINT16(card), 64);
+ break;
+
+ case 52:
+ clearButtonFlag(READ_LE_UINT16(card), 64);
+ break;
+
+ default:
+ break;
+ }
+
+ return card;
+}
+
+bool ThreadResource::cardPerform2(const byte *pSrc, int cardCmdId) {
+ int vLong, vLong2;
+
+ switch (cardCmdId) {
+ case 21:
+ vLong = (int32)READ_LE_UINT32(pSrc + 1);
+ return _vm->_controlPtr->_state->_vals[*pSrc] == vLong;
+
+ case 22:
+ vLong = (int32)READ_LE_UINT32(pSrc + 1);
+ return _vm->_controlPtr->_state->_vals[*pSrc] != vLong;
+
+ case 23:
+ vLong = _vm->_controlPtr->_state->_vals[*pSrc];
+ vLong2 = _vm->_controlPtr->_state->_vals[*(pSrc + 1)];
+ return vLong == vLong2;
+
+ case 24:
+ vLong = _vm->_controlPtr->_state->_vals[*pSrc];
+ vLong2 = _vm->_controlPtr->_state->_vals[*(pSrc + 1)];
+ return vLong != vLong2;
+
+ case 25:
+ vLong = _vm->_controlPtr->_state->_vals[*pSrc];
+ vLong2 = (int32)READ_LE_UINT32(pSrc + 1);
+ return vLong < vLong2;
+
+ case 26:
+ vLong = _vm->_controlPtr->_state->_vals[*pSrc];
+ vLong2 = (int32)READ_LE_UINT32(pSrc + 1);
+ return vLong > vLong2;
+
+ case 27:
+ vLong = _vm->_controlPtr->_state->_vals[*pSrc];
+ vLong2 = _vm->_controlPtr->_state->_vals[*(pSrc + 1)];
+ return vLong < vLong2;
+
+ case 28:
+ vLong = _vm->_controlPtr->_state->_vals[*pSrc];
+ vLong2 = _vm->_controlPtr->_state->_vals[*(pSrc + 1)];
+ return vLong > vLong2;
+
+ default:
+ return false;
+ }
+}
+
+int ThreadResource::doApt() {
+ loadTheApt();
+
+ _vm->_currentVocId = 151;
+ _vm->_voy._viewBounds = _vm->_bVoy->boltEntry(_vm->_playStampGroupId)._rectResource;
+ Common::Array<RectEntry> &hotspots = _vm->_bVoy->boltEntry(
+ _vm->_playStampGroupId + 1)._rectResource->_entries;
+ _vm->_eventsManager.getMouseInfo();
+
+ // Very first time apartment is shown, start the phone message
+ if (_aptPos.x == -1) {
+ _aptPos.x = hotspots[2].left;
+ _aptPos.y = hotspots[2].top;
+ _vm->_currentVocId = 153;
+ }
+
+ if (_vm->_voy._playStampMode == 16) {
+ hotspots[0].left = 999;
+ hotspots[3].left = 999;
+ _aptPos.x = hotspots[4].left + 28;
+ _aptPos.y = hotspots[4].top + 28;
+ }
+
+ _vm->_eventsManager.setMousePos(Common::Point(_aptPos.x, _aptPos.y));
+ _vm->_soundManager.startVOCPlay(_vm->_soundManager.getVOCFileName(_vm->_currentVocId));
+ _vm->_currentVocId = 151;
+
+ _vm->_graphicsManager.setColor(129, 82, 82, 82);
+ _vm->_graphicsManager.setColor(130, 112, 112, 112);
+ _vm->_graphicsManager.setColor(131, 215, 215, 215);
+ _vm->_graphicsManager.setColor(132, 235, 235, 235);
+
+ _vm->_eventsManager._intPtr._hasPalette = true;
+
+ // Main loop to allow users to move the cursor and select hotspots
+ int hotspotId;
+ int prevHotspotId = -1;
+ Common::Point pt;
+ PictureResource *pic;
+ Common::Rect gmmHotspot(75, 125, 130, 140);
+
+ do {
+ _vm->_voyeurArea = AREA_APARTMENT;
+
+ if (_vm->_loadGameSlot != -1) {
+ // Load a savegame
+ _vm->loadGame(_vm->_loadGameSlot);
+ _vm->_loadGameSlot = -1;
+ }
+
+ _vm->_eventsManager.getMouseInfo();
+ if (!_vm->_soundManager.getVOCStatus()) {
+ // Previous sound ended, so start up a new one
+ _vm->_currentVocId = 151 - _vm->getRandomNumber(4);
+ _vm->_soundManager.startVOCPlay(_vm->_soundManager.getVOCFileName(_vm->_currentVocId));
+ }
+
+ // Loop through the hotspot list
+ hotspotId = -1;
+ pt = _vm->_eventsManager.getMousePos();
+ for (int idx = 0; idx < (int)hotspots.size(); ++idx) {
+ if (hotspots[idx].contains(pt)) {
+ // Cursor is within hotspot area
+
+ // Don't allow the camera to be highlighted on Monday morning.
+ if (idx == 0 && _vm->_voy._transitionId == 17)
+ continue;
+
+ // Set the highlighted hotspot Id
+ hotspotId = idx;
+
+ if (hotspotId != prevHotspotId) {
+ // Check for whether to replace hotspot Id for "Watch TV" for
+ // "Review the Tape" if player has already watched the TV
+ if ((_vm->_voy._eventFlags & EVTFLAG_100) && (hotspotId == 2))
+ hotspotId = 5;
+
+ // Draw the text description for the highlighted hotspot
+ pic = _vm->_bVoy->boltEntry(_vm->_playStampGroupId +
+ hotspotId + 6)._picResource;
+ _vm->_graphicsManager.sDrawPic(pic, *_vm->_graphicsManager._vPort,
+ Common::Point(106, 200));
+ }
+
+ break;
+ }
+ }
+
+ // Check for presence in ScummVM GMM
+ if (gmmHotspot.contains(pt))
+ hotspotId = 42;
+
+ // Draw either standard or highlighted eye cursor
+ pic = _vm->_bVoy->boltEntry((hotspotId == -1) ? _vm->_playStampGroupId + 2 :
+ _vm->_playStampGroupId + 3)._picResource;
+ _vm->_graphicsManager.sDrawPic(pic, *_vm->_graphicsManager._vPort, pt);
+
+ _vm->flipPageAndWait();
+
+ if (hotspotId == 42 && _vm->_eventsManager._leftClick) {
+ // Show the ScummVM GMM
+ _vm->_eventsManager.getMouseInfo();
+ _vm->openMainMenuDialog();
+ }
+
+ } while (!_vm->shouldQuit() && (!_vm->_eventsManager._leftClick || hotspotId == -1));
+
+ pt = _vm->_eventsManager.getMousePos();
+ _aptPos.x = pt.x;
+ _aptPos.y = pt.y;
+
+ switch (hotspotId) {
+ case 0:
+ _vm->_voy._aptLoadMode = 140;
+ break;
+ case 1:
+ _vm->_voy._aptLoadMode = 143;
+ break;
+ case 2:
+ _vm->_voy._aptLoadMode = 142;
+ case 5:
+ _vm->_voy._aptLoadMode = 141;
+ break;
+ default:
+ _vm->_voy._aptLoadMode = -1;
+ break;
+ }
+
+ freeTheApt();
+ if (_vm->_voy._transitionId == 1 && hotspotId == 0)
+ _vm->checkTransition();
+
+ if (!hotspotId)
+ _vm->makeViewFinder();
+
+ return hotspotId;
+}
+
+void ThreadResource::doRoom() {
+ VoyeurEngine &vm = *_vm;
+ SVoy &voy = vm._voy;
+
+ vm.makeViewFinderP();
+ voy._fadingType = 0;
+
+ if (!vm._bVoy->getBoltGroup(vm._playStampGroupId, true))
+ return;
+
+ vm._graphicsManager._backColors = vm._bVoy->boltEntry(vm._playStampGroupId + 1)._cMapResource;
+ vm._graphicsManager._backgroundPage = vm._bVoy->boltEntry(vm._playStampGroupId)._picResource;
+ (*vm._graphicsManager._vPort)->setupViewPort(vm._graphicsManager._backgroundPage);
+ vm._graphicsManager._backColors->startFade();
+
+ voy._fadingStep1 = 2;
+ voy._fadingStep2 = 0;
+ voy._fadingType = 1;
+
+ Common::Array<RectEntry> &hotspots = vm._bVoy->boltEntry(vm._playStampGroupId + 4)._rectResource->_entries;
+ int hotspotId = -1;
+
+ PictureResource *crosshairsCursor = vm._bVoy->boltEntry(vm._playStampGroupId + 2)._picResource;
+ PictureResource *magnifierCursor = vm._bVoy->boltEntry(vm._playStampGroupId + 3)._picResource;
+ vm._eventsManager.showCursor();
+
+ RectResource viewBounds(48, 38, 336, 202);
+ voy._viewBounds = &viewBounds;
+
+ vm._eventsManager.getMouseInfo();
+ vm._eventsManager.setMousePos(Common::Point(192, 120));
+ voy._fadingType = 0;
+ vm._currentVocId = 146;
+ voy._musicStartTime = voy._RTVNum;
+
+ voy._vocSecondsOffset = 0;
+ vm._soundManager.startVOCPlay(vm._currentVocId);
+ voy._eventFlags &= ~EVTFLAG_TIME_DISABLED;
+
+ bool breakFlag = false;
+ while (!vm.shouldQuit() && !breakFlag) {
+ _vm->_voyeurArea = AREA_ROOM;
+ vm._graphicsManager.setColor(128, 0, 255, 0);
+ vm._eventsManager._intPtr._hasPalette = true;
+
+ do {
+ if (vm._currentVocId != -1 && !vm._soundManager.getVOCStatus()) {
+ voy._musicStartTime = voy._RTVNum;
+ voy._vocSecondsOffset = 0;
+ vm._soundManager.startVOCPlay(vm._currentVocId);
+ }
+
+ vm._eventsManager.getMouseInfo();
+ Common::Point pt = vm._eventsManager.getMousePos();
+ pt += Common::Point(30, 15);
+
+ hotspotId = -1;
+ if (voy._computerTextId != -1 && voy._rect4E4.contains(pt))
+ hotspotId = 999;
+
+ for (uint idx = 0; idx < hotspots.size(); ++idx) {
+ if (hotspots[idx].contains(pt)) {
+ int arrIndex = hotspots[idx]._arrIndex;
+ if (voy._roomHotspotsEnabled[arrIndex - 1]) {
+ hotspotId = idx;
+ break;
+ }
+ }
+ }
+
+ if (hotspotId == -1) {
+ vm._eventsManager.setCursorColor(128, 0);
+ vm._eventsManager.setCursor(crosshairsCursor);
+ } else if (hotspotId != 999 || voy._RTVNum < voy._computerTimeMin ||
+ (voy._computerTimeMax - 2) < voy._RTVNum) {
+ vm._eventsManager.setCursorColor(128, 1);
+ vm._eventsManager.setCursor(magnifierCursor);
+ } else {
+ vm._eventsManager.setCursorColor(128, 2);
+ vm._eventsManager.setCursor(magnifierCursor);
+ }
+
+ vm._eventsManager._intPtr._hasPalette = true;
+ vm._graphicsManager.flipPage();
+ vm._eventsManager.sWaitFlip();
+ } while (!vm.shouldQuit() && !vm._eventsManager._mouseClicked);
+
+ if (!vm._eventsManager._leftClick || hotspotId == -1) {
+ if (vm._eventsManager._rightClick)
+ breakFlag = true;
+
+ Common::Point pt = vm._eventsManager.getMousePos();
+ vm._eventsManager.getMouseInfo();
+ vm._eventsManager.setMousePos(pt);
+ } else {
+ voy._eventFlags |= EVTFLAG_RECORDING;
+ vm._eventsManager.hideCursor();
+ vm._eventsManager.startCursorBlink();
+
+ if (hotspotId == 999) {
+ _vm->flipPageAndWait();
+
+ if (vm._currentVocId != -1) {
+ voy._vocSecondsOffset = voy._RTVNum - voy._musicStartTime;
+ vm._soundManager.stopVOCPlay();
+ }
+
+ vm.getComputerBrush();
+ _vm->flipPageAndWait();
+
+ vm._voy.addComputerEventStart();
+
+ vm._eventsManager._mouseClicked = false;
+ vm._eventsManager.startCursorBlink();
+
+ int totalChars = vm.doComputerText(9999);
+ if (totalChars)
+ vm._voy.addComputerEventEnd(totalChars);
+
+ vm._bVoy->freeBoltGroup(0x4900);
+ } else {
+ vm.doEvidDisplay(hotspotId, 999);
+ }
+
+ voy._eventFlags &= ~EVTFLAG_RECORDING;
+ if (!vm._eventsManager._mouseClicked)
+ vm._eventsManager.delayClick(18000);
+
+ // WORKAROUND: Skipped code from the original, that freed the group,
+ // reloaded it, and reloaded the cursors
+
+ vm._graphicsManager._backColors = vm._bVoy->boltEntry(
+ vm._playStampGroupId + 1)._cMapResource;
+ vm._graphicsManager._backgroundPage = vm._bVoy->boltEntry(
+ vm._playStampGroupId)._picResource;
+
+ (*vm._graphicsManager._vPort)->setupViewPort();
+ vm._graphicsManager._backColors->startFade();
+ _vm->flipPageAndWait();
+
+ while (!vm.shouldQuit() && (vm._eventsManager._fadeStatus & 1))
+ vm._eventsManager.delay(1);
+ vm._eventsManager.hideCursor();
+
+ while (!vm.shouldQuit() && voy._fadingAmount2 > 0) {
+ if (voy._fadingAmount1 < 63) {
+ voy._fadingAmount1 += 4;
+ if (voy._fadingAmount1 > 63)
+ voy._fadingAmount1 = 63;
+ }
+
+ if (voy._fadingAmount2 > 0) {
+ voy._fadingAmount2 -= 8;
+ if (voy._fadingAmount2 < 0)
+ voy._fadingAmount2 = 0;
+ }
+
+ vm._eventsManager.delay(1);
+ }
+
+ _vm->flipPageAndWait();
+
+ vm._graphicsManager.fadeUpICF1(0);
+ voy._eventFlags &= EVTFLAG_RECORDING;
+ vm._eventsManager.showCursor();
+ }
+ }
+
+ voy._eventFlags = EVTFLAG_TIME_DISABLED;
+ vm._eventsManager.incrementTime(1);
+ voy._viewBounds = nullptr;
+ voy._fadingType = 0;
+ vm.makeViewFinderP();
+
+ if (voy._boltGroupId2 != -1) {
+ vm._bVoy->freeBoltGroup(voy._boltGroupId2, 1);
+ voy._boltGroupId2 = -1;
+ }
+
+ if (vm._playStampGroupId != -1) {
+ vm._bVoy->freeBoltGroup(vm._playStampGroupId);
+ vm._playStampGroupId = -1;
+ }
+
+ if (vm._currentVocId != -1) {
+ vm._soundManager.stopVOCPlay();
+ vm._currentVocId = -1;
+ }
+
+ vm._eventsManager.hideCursor();
+ chooseSTAMPButton(0);
+}
+
+int ThreadResource::doInterface() {
+ PictureResource *pic;
+ Common::Point pt;
+
+ _vm->_voy._eventFlags |= EVTFLAG_TIME_DISABLED;
+ if (_vm->_voy._abortInterface) {
+ _vm->_voy._abortInterface = false;
+ return -2;
+ }
+
+ _vm->_voy._eventFlags &= ~EVTFLAG_100;
+ _vm->_playStampGroupId = -1;
+ _vm->_eventsManager._intPtr._flashStep = 1;
+ _vm->_eventsManager._intPtr._flashTimer = 0;
+
+ if (_vm->_voy._RTVNum >= _vm->_voy._RTVLimit || _vm->_voy._RTVNum < 0)
+ _vm->_voy._RTVNum = _vm->_voy._RTVLimit - 1;
+
+ if (_vm->_voy._transitionId < 15 && _vm->_debugger._isTimeActive &&
+ (_vm->_voy._RTVLimit - 3) < _vm->_voy._RTVNum) {
+ _vm->_voy._RTVNum = _vm->_voy._RTVLimit;
+ _vm->makeViewFinder();
+
+ _vm->initIFace();
+ _vm->_voy._RTVNum = _vm->_voy._RTVLimit - 4;
+ _vm->_voy._eventFlags &= ~EVTFLAG_TIME_DISABLED;
+
+ while (!_vm->shouldQuit() && _vm->_voy._RTVNum < _vm->_voy._RTVLimit) {
+ _vm->flashTimeBar();
+ _vm->_eventsManager.delayClick(1);
+ }
+
+ _vm->_voy._eventFlags |= EVTFLAG_TIME_DISABLED;
+ chooseSTAMPButton(20);
+ parsePlayCommands();
+ }
+
+ _vm->checkTransition();
+ _vm->makeViewFinder();
+ _vm->_eventsManager.getMouseInfo();
+ _vm->initIFace();
+
+ Common::Array<RectEntry> *hotspots = &_vm->_bVoy->boltEntry(
+ _vm->_playStampGroupId + 1)._rectResource->_entries;
+ _vm->_currentVocId = 151 - _vm->getRandomNumber(5);
+ _vm->_voy._vocSecondsOffset = _vm->getRandomNumber(29);
+
+ Common::String fname = _vm->_soundManager.getVOCFileName(_vm->_currentVocId);
+ _vm->_soundManager.startVOCPlay(fname);
+ _vm->_eventsManager.getMouseInfo();
+
+ _vm->_graphicsManager.setColor(240, 220, 220, 220);
+ _vm->_eventsManager._intPtr._hasPalette = true;
+ _vm->_voy._eventFlags &= ~EVTFLAG_TIME_DISABLED;
+
+ // Set the cusor
+ PictureResource *crosshairsCursor = _vm->_bVoy->boltEntry(0x112)._picResource;
+ PictureResource *eyeCursor = _vm->_bVoy->boltEntry(0x113)._picResource;
+ PictureResource *listenCursor = _vm->_bVoy->boltEntry(0x114)._picResource;
+ PictureResource *mangifyCursor = _vm->_bVoy->boltEntry(0x115)._picResource;
+
+ _vm->_eventsManager.setCursor(crosshairsCursor);
+
+ // Main loop
+ int regionIndex = 0;
+ Common::Rect mansionViewBounds(MANSION_VIEW_X, MANSION_VIEW_Y,
+ MANSION_VIEW_X + MANSION_VIEW_WIDTH, MANSION_VIEW_Y + MANSION_VIEW_HEIGHT);
+
+ do {
+ _vm->_voyeurArea = AREA_INTERFACE;
+ _vm->doTimeBar(true);
+ _vm->_eventsManager.getMouseInfo();
+
+ if (checkMansionScroll())
+ _vm->doScroll(_vm->_mansionViewPos);
+
+ _vm->checkPhoneCall();
+ if (!_vm->_soundManager.getVOCStatus()) {
+ _vm->_currentVocId = 151 - _vm->getRandomNumber(5);
+ _vm->_soundManager.startVOCPlay(_vm->_soundManager.getVOCFileName(_vm->_currentVocId));
+ }
+
+ // Calculate the mouse position within the entire mansion
+ pt = _vm->_eventsManager.getMousePos();
+ if (!mansionViewBounds.contains(pt))
+ pt = Common::Point(-1, -1);
+ else
+ pt = _vm->_mansionViewPos +
+ Common::Point(pt.x - MANSION_VIEW_X, pt.y - MANSION_VIEW_Y);
+ regionIndex = -1;
+
+ for (int hotspotIdx = 0; hotspotIdx < (int)hotspots->size(); ++hotspotIdx) {
+ if ((*hotspots)[hotspotIdx].contains(pt)) {
+ // Rect check done
+ for (int arrIndex = 0; arrIndex < 3; ++arrIndex) {
+ if (_vm->_voy._audioHotspotTimes.isInRange(arrIndex, hotspotIdx, _vm->_voy._RTVNum)) {
+ // Set the ear cursor for an audio event
+ _vm->_eventsManager.setCursor(listenCursor);
+ regionIndex = hotspotIdx;
+ }
+
+ if (_vm->_voy._evidenceHotspotTimes.isInRange(arrIndex, hotspotIdx, _vm->_voy._RTVNum)) {
+ // Set the magnifier cursor for an evidence event
+ _vm->_eventsManager.setCursor(mangifyCursor);
+ regionIndex = hotspotIdx;
+ }
+ }
+
+ for (int arrIndex = 0; arrIndex < 8; ++arrIndex) {
+ if (_vm->_voy._videoHotspotTimes.isInRange(arrIndex, hotspotIdx, _vm->_voy._RTVNum)) {
+ // Set the eye cursor for a video event
+ _vm->_eventsManager.setCursor(eyeCursor);
+ regionIndex = hotspotIdx;
+ }
+ }
+ }
+ }
+
+ if (regionIndex == -1) {
+ // Reset back to the crosshairs cursor
+ _vm->_eventsManager.setCursor(crosshairsCursor);
+ }
+
+ // Regularly update the time display
+ if (_vm->_voy._RTANum & 2) {
+ _vm->_graphicsManager.drawANumber(*_vm->_graphicsManager._vPort,
+ _vm->_gameMinute / 10, Common::Point(190, 25));
+ _vm->_graphicsManager.drawANumber(*_vm->_graphicsManager._vPort,
+ _vm->_gameMinute % 10, Common::Point(201, 25));
+
+ if (_vm->_voy._RTANum & 4) {
+ int v = _vm->_gameHour / 10;
+ _vm->_graphicsManager.drawANumber(*_vm->_graphicsManager._vPort,
+ v == 0 ? 10 : v, Common::Point(161, 25));
+ _vm->_graphicsManager.drawANumber(*_vm->_graphicsManager._vPort,
+ _vm->_gameHour % 10, Common::Point(172, 25));
+
+ pic = _vm->_bVoy->boltEntry(_vm->_voy._isAM ? 272 : 273)._picResource;
+ _vm->_graphicsManager.sDrawPic(pic, *_vm->_graphicsManager._vPort,
+ Common::Point(215, 27));
+ }
+ }
+
+ _vm->_voy._RTANum = 0;
+ _vm->flipPageAndWait();
+
+ pt = _vm->_eventsManager.getMousePos();
+ if ((_vm->_voy._RTVNum >= _vm->_voy._RTVLimit) || ((_vm->_voy._eventFlags & 0x80) &&
+ _vm->_eventsManager._rightClick && (pt.x == 0))) {
+ // Time to transition to the next time period
+ _vm->_eventsManager.getMouseInfo();
+
+ if (_vm->_voy._transitionId == 15) {
+ regionIndex = 20;
+ _vm->_voy._transitionId = 17;
+ _vm->_soundManager.stopVOCPlay();
+ _vm->checkTransition();
+ _vm->_eventsManager._leftClick = true;
+ } else {
+ _vm->_voy._eventFlags |= EVTFLAG_TIME_DISABLED;
+
+ chooseSTAMPButton(20);
+ parsePlayCommands();
+ _vm->checkTransition();
+ _vm->makeViewFinder();
+
+ _vm->initIFace();
+
+ hotspots = &_vm->_bVoy->boltEntry(_vm->_playStampGroupId + 1)._rectResource->_entries;
+ _vm->_eventsManager.getMouseInfo();
+
+ _vm->_voy._eventFlags &= ~EVTFLAG_TIME_DISABLED;
+ _vm->_eventsManager._intPtr._flashStep = 1;
+ _vm->_eventsManager._intPtr._flashTimer = 0;
+ }
+ }
+ } while (!_vm->_eventsManager._rightClick && !_vm->shouldQuit() &&
+ (!_vm->_eventsManager._leftClick || regionIndex == -1));
+
+ _vm->_eventsManager.hideCursor();
+ _vm->_voy._eventFlags |= EVTFLAG_TIME_DISABLED;
+ _vm->_bVoy->freeBoltGroup(_vm->_playStampGroupId);
+ if (_vm->_currentVocId != -1)
+ _vm->_soundManager.stopVOCPlay();
+
+ return !_vm->_eventsManager._rightClick ? regionIndex : -2;
+}
+
+bool ThreadResource::checkMansionScroll() {
+ Common::Point pt = _vm->_eventsManager.getMousePos() -
+ Common::Point(MANSION_VIEW_X, MANSION_VIEW_Y);
+ Common::Point &viewPos = _vm->_mansionViewPos;
+ bool result = false;
+
+ // Scroll mansion view if close to any of the mansion edges
+ if (pt.x >= 0 && pt.x < MANSION_SCROLL_AREA_X && viewPos.x > 0) {
+ viewPos.x = MAX(viewPos.x - MANSION_SCROLL_INC_X, 0);
+ result = true;
+ }
+ if (pt.x >= (MANSION_VIEW_WIDTH - MANSION_SCROLL_AREA_X) &&
+ pt.x < MANSION_VIEW_WIDTH && viewPos.x < MANSION_MAX_X) {
+ viewPos.x = MIN(viewPos.x + MANSION_SCROLL_INC_X, MANSION_MAX_X);
+ result = true;
+ }
+ if (pt.y >= 0 && pt.y < MANSION_SCROLL_AREA_Y && viewPos.y > 0) {
+ viewPos.y = MAX(viewPos.y - MANSION_SCROLL_INC_Y, 0);
+ result = true;
+ }
+ if (pt.y >= (MANSION_VIEW_HEIGHT - MANSION_SCROLL_AREA_Y) &&
+ pt.y < MANSION_VIEW_HEIGHT && viewPos.y < MANSION_MAX_Y) {
+ viewPos.y = MIN(viewPos.y + MANSION_SCROLL_INC_Y, MANSION_MAX_Y);
+ result = true;
+ }
+
+ // Return whether mansion view area has changed
+ return result;
+}
+
+bool ThreadResource::goToStateID(int stackId, int id) {
+ debugC(DEBUG_BASIC, kDebugScripts, "goToStateID - %d, %d", stackId, id);
+
+ // Save current stack
+ savePrevious();
+
+ if (_stackId == stackId || stackId == -1 || loadAStack(stackId)) {
+ // Now in the correct state
+ _stateId = getStateFromID(id);
+
+ if (_stateId != -1) {
+ return doState();
+ } else {
+ _stateId = _savedStateId;
+ _stackId = _savedStackId;
+ }
+ }
+
+ return false;
+}
+
+bool ThreadResource::goToState(int stackId, int stateId) {
+ debugC(DEBUG_BASIC, kDebugScripts, "goToState - %d, %d", stackId, stateId);
+
+ savePrevious();
+ if (stackId == -1 || loadAStack(stackId)) {
+ if (stateId != -1)
+ _stateId = stateId;
+
+ return doState();
+ } else {
+ return false;
+ }
+}
+
+void ThreadResource::savePrevious() {
+ if (_savedStateId == _stateId && _stackId == _savedStackId) {
+ _flags &= ~1;
+ } else {
+ _flags |= 1;
+ _savedStateId = _stateId;
+ _savedStackId = _stackId;
+ }
+}
+
+void ThreadResource::setButtonFlag(int idx, byte bits) {
+ _buttonFlags[idx] |= bits;
+}
+
+void ThreadResource::clearButtonFlag(int idx, byte bits) {
+ _buttonFlags[idx] &= ~bits;
+}
+
+void ThreadResource::loadTheApt() {
+ switch (_vm->_voy._transitionId) {
+ case 1:
+ case 2:
+ case 5:
+ case 6:
+ case 7:
+ case 8:
+ case 9:
+ case 17:
+ _vm->_playStampGroupId = 0x5700;
+ break;
+ case 3:
+ _vm->_playStampGroupId = 0x5800;
+ break;
+ case 4:
+ case 10:
+ case 11:
+ case 12:
+ case 13:
+ case 14:
+ case 15:
+ case 16:
+ _vm->_playStampGroupId = 0x5900;
+ break;
+ default:
+ break;
+ }
+
+ if (_vm->_voy._aptLoadMode == 143)
+ _vm->_voy._aptLoadMode = -1;
+
+ if (_vm->_voy._aptLoadMode != -1) {
+ doAptAnim(1);
+ _vm->_bVoy->getBoltGroup(_vm->_playStampGroupId);
+ _vm->_voy._aptLoadMode = -1;
+ _vm->_graphicsManager._backgroundPage = _vm->_bVoy->boltEntry(
+ _vm->_playStampGroupId + 5)._picResource;
+ (*_vm->_graphicsManager._vPort)->setupViewPort(
+ _vm->_graphicsManager._backgroundPage);
+ } else {
+ _vm->_bVoy->getBoltGroup(_vm->_playStampGroupId);
+ _vm->_graphicsManager._backgroundPage = _vm->_bVoy->boltEntry(
+ _vm->_playStampGroupId + 5)._picResource;
+ (*_vm->_graphicsManager._vPort)->setupViewPort(
+ _vm->_graphicsManager._backgroundPage);
+ }
+
+ CMapResource *pal = _vm->_bVoy->boltEntry(_vm->_playStampGroupId + 4)._cMapResource;
+ pal->_steps = 1;
+ pal->startFade();
+ _vm->flipPageAndWaitForFade();
+}
+
+void ThreadResource::freeTheApt() {
+ _vm->_graphicsManager.fadeDownICF1(5);
+ _vm->flipPageAndWaitForFade();
+
+ _vm->_graphicsManager.fadeUpICF1(0);
+
+ if (_vm->_currentVocId != -1) {
+ _vm->_soundManager.stopVOCPlay();
+ _vm->_currentVocId = -1;
+ }
+
+ if (_vm->_voy._aptLoadMode == -1) {
+ _vm->_graphicsManager.fadeDownICF(6);
+ } else {
+ doAptAnim(2);
+ }
+
+ if (_vm->_voy._aptLoadMode == 140) {
+ _vm->_graphicsManager.screenReset();
+ _vm->_graphicsManager.resetPalette();
+ }
+
+ (*_vm->_graphicsManager._vPort)->setupViewPort(nullptr);
+ _vm->_bVoy->freeBoltGroup(_vm->_playStampGroupId);
+ _vm->_playStampGroupId = -1;
+ _vm->_voy._viewBounds = nullptr;
+}
+
+void ThreadResource::doAptAnim(int mode) {
+ _vm->_bVoy->freeBoltGroup(0x100, true);
+
+ // Figure out the resource to use
+ int id = 0;
+ switch (_vm->_voy._aptLoadMode) {
+ case 140:
+ id = 0x5A00;
+ break;
+ case 141:
+ id = 0x6000;
+ break;
+ case 142:
+ id = 0x6600;
+ break;
+ case 143:
+ id = 0x6C00;
+ break;
+ case 144:
+ id = 0x6F00;
+ break;
+ default:
+ break;
+ }
+
+ int id2 = (id == 0x6C00 || id == 0x6F00) ? 1 : 2;
+ switch (_vm->_voy._transitionId) {
+ case 3:
+ id += id2 << 8;
+ break;
+ case 4:
+ case 10:
+ case 11:
+ case 12:
+ case 13:
+ case 14:
+ case 15:
+ case 16:
+ id += id2 << 9;
+ break;
+ default:
+ break;
+ }
+
+ if (mode == 1)
+ id += 0x100;
+
+ // Do the display
+ if (_vm->_bVoy->getBoltGroup(id)) {
+ CMapResource *pal = _vm->_bVoy->boltEntry(id)._cMapResource;
+ pal->_steps = 1;
+
+ for (int idx = 0; (idx < 6) && !_vm->shouldQuit(); ++idx) {
+ PictureResource *pic = _vm->_bVoy->boltEntry(id + idx + 1)._picResource;
+ (*_vm->_graphicsManager._vPort)->setupViewPort(pic);
+ pal->startFade();
+
+ _vm->flipPageAndWait();
+ _vm->_eventsManager.delayClick(5);
+ }
+
+ _vm->_bVoy->freeBoltGroup(id);
+ }
+
+ _vm->_bVoy->getBoltGroup(0x100);
+}
+
+void ThreadResource::synchronize(Common::Serializer &s) {
+ s.syncAsSint16LE(_aptPos.x);
+ s.syncAsSint16LE(_aptPos.y);
+
+ int stateId = _stateId;
+ int stackId = _stackId;
+ s.syncAsSint16LE(stateId);
+ s.syncAsSint16LE(stackId);
+
+ if (s.isLoading() && (stateId != _stateId || stackId != _stackId))
+ goToState(stackId, stateId);
+
+ s.syncAsSint16LE(_savedStateId);
+ s.syncAsSint16LE(_savedStackId);
+}
+
+} // End of namespace Voyeur
diff --git a/engines/voyeur/graphics.cpp b/engines/voyeur/graphics.cpp
new file mode 100644
index 0000000000..7ed0591871
--- /dev/null
+++ b/engines/voyeur/graphics.cpp
@@ -0,0 +1,1065 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "voyeur/graphics.h"
+#include "voyeur/voyeur.h"
+#include "voyeur/staticres.h"
+#include "engines/util.h"
+#include "graphics/palette.h"
+#include "graphics/surface.h"
+
+namespace Voyeur {
+
+/*------------------------------------------------------------------------*/
+
+DrawInfo::DrawInfo(int penColor, const Common::Point &pos, int flags) {
+ _penColor = penColor;
+ _pos = pos;
+ _flags = flags;
+}
+
+/*------------------------------------------------------------------------*/
+
+GraphicsManager::GraphicsManager(): _defaultDrawInfo(1, Common::Point(), 0), _drawPtr(&_defaultDrawInfo) {
+ _SVGAPage = 0;
+ _SVGAMode = 0;
+ _SVGAReset = 0;
+ _screenOffset = 0;
+ _planeSelect = 0;
+ _sImageShift = 3;
+ _palFlag = false;
+ _MCGAMode = false;
+ _saveBack = true;
+ _drawTextPermFlag = false;
+ _clipPtr = NULL;
+ _viewPortListPtr = NULL;
+ _backgroundPage = NULL;
+ _vPort = NULL;
+ _fontPtr = NULL;
+ Common::fill(&_VGAColors[0], &_VGAColors[PALETTE_SIZE], 0);
+ _fontChar = new PictureResource(0, 0xff, 0xff, 0, 0, Common::Rect(), 0, NULL, 0);
+}
+
+void GraphicsManager::sInitGraphics() {
+ initGraphics(SCREEN_WIDTH, SCREEN_HEIGHT, false);
+ _screenSurface.create(SCREEN_WIDTH, SCREEN_HEIGHT, Graphics::PixelFormat::createFormatCLUT8());
+ clearPalette();
+}
+
+GraphicsManager::~GraphicsManager() {
+ _screenSurface.free();
+ delete _fontChar;
+}
+
+void GraphicsManager::setupMCGASaveRect(ViewPortResource *viewPort) {
+ _MCGAMode = true;
+
+ if (viewPort->_activePage) {
+ viewPort->_activePage->_flags |= 1;
+ Common::Rect *clipRect = _clipPtr;
+ _clipPtr = &viewPort->_clipRect;
+
+ sDrawPic(viewPort->_activePage, viewPort->_currentPic, Common::Point());
+
+ _clipPtr = clipRect;
+ }
+
+ viewPort->_rectListCount[1] = -1;
+}
+
+void GraphicsManager::addRectOptSaveRect(ViewPortResource *viewPort, int idx, const Common::Rect &bounds) {
+ if (viewPort->_rectListCount[idx] == -1)
+ return;
+
+ // TODO: Lots of code in original, which I suspect may be overlapping rect merging
+ viewPort->_rectListPtr[idx]->push_back(bounds);
+ ++viewPort->_rectListCount[idx];
+}
+
+void GraphicsManager::restoreMCGASaveRect(ViewPortResource *viewPort) {
+ if (viewPort->_rectListCount[0] != -1) {
+ for (int i = 0; i < viewPort->_rectListCount[0]; ++i) {
+ addRectOptSaveRect(viewPort, 1, (*viewPort->_rectListPtr[0])[i]);
+ }
+ } else {
+ viewPort->_rectListCount[1] = -1;
+ }
+
+ restoreBack(*viewPort->_rectListPtr[1], viewPort->_rectListCount[1], viewPort->_pages[0],
+ viewPort->_pages[1]);
+
+ int count = viewPort->_rectListCount[0];
+ restoreBack(*viewPort->_rectListPtr[0], viewPort->_rectListCount[0],
+ viewPort->_activePage, viewPort->_currentPic);
+
+ SWAP(viewPort->_rectListPtr[0], viewPort->_rectListPtr[1]);
+ viewPort->_rectListCount[1] = count;
+}
+
+void GraphicsManager::addRectNoSaveBack(ViewPortResource *viewPort, int idx, const Common::Rect &bounds) {
+ // Stubbed/dummy method in the original.
+}
+
+void GraphicsManager::sDrawPic(DisplayResource *srcDisplay, DisplayResource *destDisplay,
+ const Common::Point &initialOffset) {
+ int var4C = 0;
+ int width1, width2;
+ int widthDiff, widthDiff2;
+ int height1;
+ int srcOffset;
+ int screenOffset;
+ int srcFlags, destFlags;
+ ViewPortResource *destViewPort = NULL;
+ Common::Rect newBounds;
+ Common::Rect backBounds;
+ int var22 = 0;
+ int var24 = 0;
+ bool isClipped = false;
+ int var26;
+ byte pixel = 0;
+ int runLength;
+
+ byte *srcImgData, *destImgData;
+ byte *srcP, *destP;
+ byte byteVal, byteVal2;
+
+ // Get the picture parameters, or deference viewport pointers to get their pictures
+ PictureResource *srcPic = (PictureResource *)srcDisplay;
+ PictureResource *destPic = (PictureResource *)destDisplay;
+
+ if (srcDisplay->_flags & DISPFLAG_VIEWPORT) {
+ // A viewport was passed, not a picture
+ srcPic = ((ViewPortResource *)srcDisplay)->_currentPic;
+ }
+ if (destDisplay->_flags & DISPFLAG_VIEWPORT) {
+ destViewPort = (ViewPortResource *)destDisplay;
+ destPic = destViewPort->_currentPic;
+ }
+
+ Common::Point offset = Common::Point(initialOffset.x + srcPic->_bounds.left - destPic->_bounds.left,
+ initialOffset.y + srcPic->_bounds.top - destPic->_bounds.top);
+ width1 = width2 = srcPic->_bounds.width();
+ height1 = srcPic->_bounds.height();
+ srcOffset = 0;
+ srcFlags = srcPic->_flags;
+ destFlags = destPic->_flags;
+ byte *cursorData = NULL;
+
+ if (srcFlags & 1) {
+ if (_clipPtr) {
+ int xs = _clipPtr->left - destPic->_bounds.left;
+ int ys = _clipPtr->top - destPic->_bounds.top;
+ newBounds = Common::Rect(xs, ys, xs + _clipPtr->width(), ys + _clipPtr->height());
+ } else if (destViewPort) {
+ int xs = destViewPort->_clipRect.left - destPic->_bounds.left;
+ int ys = destViewPort->_clipRect.top - destPic->_bounds.top;
+ newBounds = Common::Rect(xs, ys, xs + destViewPort->_clipRect.width(),
+ ys + destViewPort->_clipRect.height());
+ } else {
+ newBounds = Common::Rect(0, 0, destPic->_bounds.width(), destPic->_bounds.height());
+ }
+
+ var24 = offset.y - newBounds.top;
+ if (var24 < 0) {
+ srcOffset -= var24 * width2;
+ height1 += var24;
+ offset.y = newBounds.top;
+
+ if (height1 <= 0)
+ return;
+
+ isClipped = true;
+ }
+
+ int var20 = newBounds.bottom - (offset.y + height1);
+ if (var20 < 0) {
+ height1 += var20;
+ if (height1 <= 0)
+ return;
+ }
+
+ var22 = offset.x - newBounds.left;
+ if (var22 < 0) {
+ srcOffset -= var22;
+ width2 += var22;
+ offset.x = newBounds.left;
+
+ if (width2 <= 0)
+ return;
+
+ isClipped = true;
+ }
+
+ var26 = newBounds.right - (offset.x + width2);
+ if (var26 < 0) {
+ width2 += var26;
+ if (width2 <= 0)
+ return;
+
+ isClipped = true;
+ }
+ }
+
+ screenOffset = offset.y * destPic->_bounds.width() + offset.x;
+ widthDiff = width1 - width2;
+ widthDiff2 = destPic->_bounds.width() - width2;
+
+ if (destViewPort) {
+ if (!_saveBack || ((srcPic->_flags & DISPFLAG_800) != 0)) {
+ backBounds.left = destPic->_bounds.left + offset.x;
+ backBounds.top = destPic->_bounds.top + offset.y;
+ backBounds.setWidth(width2);
+ backBounds.setHeight(height1);
+ addRectOptSaveRect(destViewPort, 1, backBounds);
+
+ } else if (!destViewPort->_addFn) {
+ if (destViewPort->_rectListCount[destViewPort->_pageIndex] < -1) {
+ Common::Rect r;
+ r.left = destPic->_bounds.left + offset.x;
+ r.top = destPic->_bounds.top + offset.y;
+ r.setWidth(width2);
+ r.setHeight(height1);
+
+ (*destViewPort->_rectListPtr[destViewPort->_pageIndex]).push_back(r);
+ ++destViewPort->_rectListCount[destViewPort->_pageIndex];
+ }
+ } else {
+ int xs = offset.x + destPic->_bounds.left;
+ int ys = offset.y + destPic->_bounds.top;
+ backBounds = Common::Rect(xs, ys, xs + width2, ys + height1);
+
+ (this->*destViewPort->_addFn)(destViewPort, destViewPort->_bounds.top, backBounds);
+ }
+ }
+
+ if (srcFlags & DISPFLAG_1000) {
+ srcImgData = srcPic->_imgData + (var4C << 14) + _screenOffset;
+ for (uint idx = 0; idx < srcPic->_maskData; ++idx) {
+ if (var4C < 4) {
+ EMSMapPageHandle(srcPic->_planeSize, srcPic->_imgData[idx], var4C);
+ ++var4C;
+ }
+ }
+ } else {
+ srcImgData = srcPic->_imgData;
+ }
+ if (destFlags & DISPFLAG_1000) {
+ destImgData = destPic->_imgData + (var4C << 14) + _screenOffset;
+ for (uint idx = 0; idx < srcPic->_maskData; ++idx) {
+ if (var4C < 4) {
+ EMSMapPageHandle(destPic->_planeSize, destPic->_imgData[idx], var4C);
+ ++var4C;
+ }
+ }
+ } else {
+ destImgData = destPic->_imgData;
+ }
+
+ _SVGAPage = _SVGAReset;
+ if (srcPic->_select != 0xff)
+ return;
+
+ if (destFlags & DISPFLAG_CURSOR) {
+ cursorData = new byte[width2 * height1];
+ Common::fill(cursorData, cursorData + width2 * height1, 0);
+ destImgData = cursorData;
+ }
+
+ if (srcPic->_pick == 0xff) {
+ if (srcFlags & DISPFLAG_8) {
+ error("TODO: sDrawPic variation");
+ } else {
+ // loc_258B8
+ srcP = srcImgData + srcOffset;
+
+ if (destFlags & DISPFLAG_8) {
+ // loc_258D8
+ destP = destImgData + screenOffset;
+
+ if (srcFlags & DISPFLAG_2) {
+ // loc_25652
+ srcP = srcImgData + srcOffset;
+
+ if (destFlags & DISPFLAG_8) {
+ // loc_2566F
+ if (srcFlags & DISPFLAG_2) {
+ // loc_256FA
+ srcP = (byte *)_screenSurface.getPixels() + srcOffset;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ for (int xp = 0; xp < width2; ++width2, ++srcP, ++destP) {
+ pixel = *srcP;
+ if (pixel)
+ *destP = pixel;
+ }
+
+ srcP += widthDiff;
+ destP += widthDiff2;
+ }
+ } else {
+ // loc_25706
+ for (int yp = 0; yp < height1; ++yp) {
+ Common::copy(srcP, srcP + width2, destP);
+ srcP += width2 + widthDiff;
+ destP += width2 + widthDiff2;
+ }
+ }
+ } else {
+ // loc_25773
+ destP = destImgData + screenOffset;
+
+ if (srcFlags & DISPFLAG_2) {
+ // loc_25793
+ for (int yp = 0; yp < height1; ++yp) {
+ Common::copy(srcP, srcP + width2, destP);
+ srcP += width2 + widthDiff;
+ destP += width2 + widthDiff2;
+ }
+ } else {
+ // loc_25829
+ destP = (byte *)_screenSurface.getPixels() + screenOffset;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ Common::copy(srcP, srcP + width2, destP);
+ srcP += width2 + widthDiff;
+ destP += width2 + widthDiff2;
+ }
+ }
+ }
+ } else {
+ // loc_25D40
+ if (srcFlags & DISPFLAG_100) {
+ // loc_25D4A
+ error("TODO: sDrawPic variation");
+ } else {
+ // loc_2606D
+ destP = (byte *)_screenSurface.getPixels() + screenOffset;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ Common::copy(srcP, srcP + width2, destP);
+ destP += width2 + widthDiff2;
+ srcP += width2 + widthDiff;
+ }
+ }
+ }
+ } else {
+ // loc_2615E
+ destP = destImgData + screenOffset;
+
+ if (srcFlags & DISPFLAG_2) {
+ // loc_2617e
+ if (srcFlags & DISPFLAG_100) {
+ // loc_26188
+ srcP = srcImgData;
+ if (isClipped) {
+ // loc_26199
+ var22 = (var22 < 0) ? -var22 : 0;
+ var26 = var22 + width2;
+ var24 = (var24 < 0) ? -var24 : 0;
+
+ width2 = srcPic->_bounds.width();
+ height1 = var24 + height1;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ runLength = 0;
+
+ for (int xp = 0; xp < width2; ++xp, --runLength) {
+ if (runLength <= 0) {
+ pixel = *srcP++;
+ if (pixel & 0x80) {
+ pixel &= 0x7f;
+ runLength = *srcP++;
+ if (!runLength)
+ runLength = width2;
+ }
+ }
+
+ if (yp >= var24 && xp >= var22 && xp < var26) {
+ if (pixel > 0)
+ *destP = pixel;
+ ++destP;
+ }
+ }
+
+ if (yp >= var24)
+ destP += widthDiff2;
+ }
+ } else {
+ // loc_262BE
+ byteVal = 0;
+ for (int yp = 0; yp < height1; ++yp) {
+ for (int xp = 0; xp < width2; ++xp) {
+ byteVal2 = 0;
+ if (!byteVal2) {
+ byteVal = *++srcP;
+ if (byteVal & 0x80) {
+ byteVal &= 0x7f;
+ byteVal2 = *srcP++;
+
+ if (!byteVal2)
+ byteVal2 = width2;
+ }
+ }
+
+ if (byteVal > 0)
+ *destP = byteVal;
+
+ ++destP;
+ --byteVal2;
+ }
+
+ destP += widthDiff2;
+ }
+ }
+ } else {
+ // loc_2637F
+ // Copy with transparency
+ for (int yp = 0; yp < height1; ++yp) {
+ for (int xp = 0; xp < width2; ++xp, ++srcP, ++destP) {
+ if (*srcP != 0)
+ *destP = *srcP;
+ }
+
+ destP += widthDiff2;
+ srcP += widthDiff;
+ }
+ }
+ } else {
+ if (srcFlags & 0x100) {
+ // Simple run-length encoded image
+ srcP = srcImgData;
+
+ if (isClipped) {
+ // loc_26424
+ var22 = (var22 < 0) ? -var22 : 0;
+ var26 = var22 + width2;
+ var24 = (var24 < 0) ? -var24 : 0;
+ width2 = srcPic->_bounds.width();
+ height1 = var24 + height1;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ runLength = 0;
+ for (int xp = 0; xp < width2; ++xp, --runLength) {
+ if (runLength <= 0) {
+ pixel = *srcP++;
+ if (pixel & 0x80) {
+ pixel &= 0x7F;
+ runLength = *srcP++;
+
+ if (!runLength)
+ runLength = width2;
+ }
+ }
+
+ if (yp >= var24 && xp >= var22 && xp < var26) {
+ *destP++ = pixel;
+ }
+ }
+
+ if (yp >= var24)
+ destP += widthDiff2;
+ }
+ } else {
+ // loc_26543
+ for (int yp = 0; yp < height1; ++yp) {
+ int runLength = 0;
+ for (int xp = 0; xp < width2; ++xp, --runLength) {
+ if (runLength <= 0) {
+ // Start of run length, so get pixel and repeat length
+ pixel = *srcP++;
+ if (pixel & 0x80) {
+ pixel &= 0x7f;
+ runLength = *srcP++;
+ if (runLength == 0)
+ runLength = width2;
+ }
+ }
+
+ // Copy pixel to output
+ *destP++ = pixel;
+ }
+
+ destP += widthDiff2;
+ }
+ }
+ } else {
+ for (int yp = 0; yp < height1; ++yp) {
+ Common::copy(srcP, srcP + width2, destP);
+ destP += width2 + widthDiff2;
+ srcP += width2 + widthDiff;
+ }
+ }
+ }
+ }
+ }
+ } else {
+ // loc_26666
+ if (srcPic->_pick == 0) {
+ // loc_2727A
+ byte onOff = srcPic->_onOff;
+
+ if (srcFlags & DISPFLAG_2) {
+ if (!(srcFlags & DISPFLAG_8)) {
+ srcP = srcImgData + srcOffset;
+
+ if (destFlags & DISPFLAG_8) {
+ // loc_272C3
+ error("TODO: sDrawPic variation");
+ } else {
+ destP = destImgData + screenOffset;
+ for (int yp = 0; yp < height1; ++yp) {
+ for (int xp = 0; xp < width2; ++xp, ++destP) {
+ if ((int8)*srcP++ < 0)
+ *destP = onOff;
+ }
+
+ destP += widthDiff2;
+ srcP += widthDiff;
+ }
+ }
+ }
+ } else {
+ // loc_27477
+ if (destFlags & DISPFLAG_8) {
+ // loc_27481
+ destP = (byte *)_screenSurface.getPixels() + screenOffset;
+ for (int yp = 0; yp < height1; ++yp) {
+ Common::fill(destP, destP + width2, onOff);
+ destP += width2 + widthDiff2;
+ }
+ } else {
+ // loc_2753C
+ destP = destImgData + screenOffset;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ Common::fill(destP, destP + width2, onOff);
+ destP += width2 + widthDiff2;
+ }
+ }
+ }
+
+ } else {
+ // loc_26673
+ int pick = srcPic->_pick;
+ int onOff = srcPic->_onOff;
+
+ if (!(srcFlags & PICFLAG_PIC_OFFSET)) {
+ srcP = srcImgData += srcOffset;
+ int pixel = 0;
+
+ if (destFlags & PICFLAG_PIC_OFFSET) {
+ destP = destImgData + screenOffset;
+ if (srcFlags & PICFLAG_2) {
+ if (srcFlags & PICFLAG_100) {
+ if (isClipped) {
+ // loc_266E3
+ destP = (byte *)_screenSurface.getPixels() + screenOffset;
+ var22 = (var22 < 0) ? -var22 : 0;
+ var26 = var22 + width2;
+ var24 = (var24 < 0) ? -var24 : 0;
+ pick = 0x7F;
+ width2 = srcPic->_bounds.width();
+ height1 = var24 + height1;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ int runLength = 0;
+ for (int xp = 0; xp < width2; ++xp, --runLength) {
+ if (runLength <= 0) {
+ pixel = *srcP++;
+ if (pixel & 0x80) {
+ pixel &= 0x7F;
+ runLength = *srcP++;
+ if (!runLength)
+ runLength = width2;
+ }
+ }
+
+ if (yp >= var24 && xp >= var22 && xp < var26) {
+ if (pixel) {
+ *destP = (pixel & pick) ^ onOff;
+ }
+ ++destP;
+ }
+ }
+ if (yp >= var24)
+ destP += widthDiff2;
+ }
+ } else {
+ // loc_26815
+ destP = (byte *)_screenSurface.getPixels() + screenOffset;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ for (int xp = 0; xp < width2; ++xp, ++destP) {
+ byteVal2 = 0;
+ for (int xp = 0; xp < width2; ++xp, ++destP, --byteVal2) {
+ if (!byteVal2) {
+ pixel = *srcP++;
+ if (pixel & 0x80) {
+ pixel &= 0x7F;
+ byteVal2 = *srcP++;
+ if (!byteVal2) {
+ byteVal2 = width2;
+ }
+ }
+ }
+
+ if (pixel)
+ *destP = (pixel & pick) ^ onOff;
+ }
+ }
+
+ destP += widthDiff2;
+ }
+ }
+ } else {
+ // Direct screen write
+ destP = (byte *)_screenSurface.getPixels() + screenOffset;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ for (int xp = 0; xp < width2; ++xp, ++srcP, ++destP) {
+ if (*srcP)
+ *destP = (*srcP & pick) ^ onOff;
+ }
+ destP += widthDiff2;
+ srcP += widthDiff;
+ }
+ }
+ } else if (srcFlags & PICFLAG_100) {
+ srcP = srcImgData;
+ if (isClipped) {
+ // loc_269FD
+ var22 = (var22 < 0) ? -var22 : 0;
+ var26 = var22 + width2;
+ var24 = (var24 < 0) ? -var24 : 0;
+ width2 = srcPic->_bounds.width();
+ height1 = var24 + height1;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ runLength = 0;
+ for (int xp = 0; xp < width2; ++xp, --runLength) {
+ if (runLength <= 0) {
+ pixel = *srcP++;
+ if (pixel & 0x80) {
+ pixel &= 0x7F;
+ runLength = *srcP++;
+
+ if (!runLength)
+ runLength = width2;
+ }
+ }
+
+ if (yp >= var24 && xp >= var22 && xp < var26) {
+ *destP++ = (pixel & 0x80) ^ onOff;
+ }
+ }
+ }
+ } else {
+ // loc_26BD5
+ destP = (byte *)_screenSurface.getPixels() + screenOffset;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ byteVal2 = 0;
+
+ for (int xp = 0; xp < width2; ++xp, ++destP) {
+ if (!byteVal2) {
+ pixel = *srcP++;
+ if (pixel & 0x80) {
+ pixel &= 0x7F;
+ byteVal2 = *srcP++;
+ if (!byteVal2)
+ byteVal2 = width2;
+ }
+ }
+
+ *destP = (pixel & pick) ^ onOff;
+ }
+
+ destP += widthDiff2;
+ }
+ }
+ } else {
+ // loc_26C9A
+ destP = (byte *)_screenSurface.getPixels() + screenOffset;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ for (int xp = 0; xp < width2; ++xp, ++srcP, ++destP) {
+ *destP = (*srcP & pick) ^ onOff;
+ }
+ destP += widthDiff2;
+ srcP += widthDiff;
+ }
+ }
+ } else {
+ // loc_26D2F
+ destP = destImgData + screenOffset;
+
+ if (srcFlags & PICFLAG_2) {
+ // loc_26D4F
+ if (srcFlags & PICFLAG_100) {
+ srcP = srcImgData;
+
+ if (isClipped) {
+ // loc_26D6A
+ var22 = (var22 < 0) ? -var22 : 0;
+ var26 = var22 + width2;
+ var24 = (var24 < 0) ? -var24 : 0;
+ width2 = srcPic->_bounds.width();
+ height1 = var24 + height1;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ runLength = 0;
+
+ for (int xp = 0; xp < width2; ++xp, --runLength) {
+ if (runLength <= 0) {
+ pixel = *srcP++;
+ if (pixel & 0x80) {
+ pixel &= 0x7F;
+ runLength = *srcP++;
+ if (!runLength)
+ runLength = width2;
+ }
+ }
+
+ if (yp >= var24 && xp >= var22 && xp < var26) {
+ if (pixel)
+ *destP = (pixel & pick) ^ onOff;
+
+ ++destP;
+ }
+ }
+
+ if (yp >= var24)
+ destP += widthDiff2;
+ }
+ } else {
+ // loc_26E95
+ for (int yp = 0; yp < height1; ++yp) {
+ byteVal2 = 0;
+ for (int xp = 0; xp < width2; ++xp, ++destP, --byteVal2) {
+ if (!byteVal2) {
+ pixel = *srcP++;
+ if (pixel & 0x80) {
+ pixel &= 0x7F;
+ byteVal2 = *srcP++;
+ if (!byteVal2)
+ byteVal2 = width2;
+ }
+ }
+
+ if (pixel)
+ *destP = (pixel & pick) ^ onOff;
+ }
+
+ destP += widthDiff2;
+ }
+ }
+ } else {
+ // loc_26F5D
+ for (int yp = 0; yp < height1; ++yp) {
+ for (int xp = 0; xp < width2; ++xp, ++srcP, ++destP) {
+ if (*srcP)
+ *destP = (*srcP & pick) ^ onOff;
+ }
+ destP += widthDiff2;
+ srcP += widthDiff;
+ }
+ }
+ } else {
+ // loc_26FEF
+ if (srcFlags & PICFLAG_100) {
+ // loc_26FF9
+ for (int yp = 0; yp < height1; ++yp) {
+ for (int xp = 0; xp < width2; ++xp, ++srcP, ++destP) {
+ *destP = (*srcP & pick) ^ onOff;
+ }
+ destP += widthDiff2;
+ srcP += widthDiff;
+ }
+ } else {
+ // loc_271F0
+ srcP = srcImgData;
+
+ if (isClipped) {
+ // loc_2700A
+ var22 = (var22 < 0) ? -var22 : 0;
+ var26 = var22 + width2;
+ var24 = (var24 < 0) ? -var24 : 0;
+ width2 = srcPic->_bounds.width();
+ height1 = var24 + height1;
+
+ for (int yp = 0; yp < height1; ++yp) {
+ runLength = 0;
+
+ for (int xp = 0; xp < width2; ++xp, --runLength) {
+ if (runLength <= 0) {
+ pixel = *srcP++;
+ if (pixel & 0x80) {
+ pixel &= 0x7F;
+ runLength = *srcP++;
+ if (!runLength)
+ runLength = width2;
+ }
+ }
+
+ if (yp >= var24 && xp >= var22 && xp < var26) {
+ *destP++ = (pixel & pick) ^ onOff;
+ }
+ }
+
+ if (yp >= var24)
+ destP += widthDiff2;
+ }
+ } else {
+ // loc_2712F
+ for (int yp = 0; yp < height1; ++yp) {
+ byteVal2 = 0;
+ for (int xp = 0; xp < width2; ++xp, ++destP, --byteVal2) {
+ if (!byteVal2) {
+ pixel = *srcP++;
+ if (pixel & 0x80) {
+ pixel &= 0x7F;
+ byteVal2 = *srcP++;
+ if (!byteVal2)
+ byteVal2 = width2;
+ }
+ }
+
+ *destP = (*srcP & pick) ^ onOff;
+ }
+ destP += widthDiff2;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (cursorData) {
+ _vm->_eventsManager.setCursor(cursorData, width2, height1);
+ delete[] cursorData;
+ }
+}
+
+void GraphicsManager::drawANumber(DisplayResource *display, int num, const Common::Point &pt) {
+ PictureResource *pic = _vm->_bVoy->boltEntry(num + 261)._picResource;
+ sDrawPic(pic, display, pt);
+}
+
+void GraphicsManager::fillPic(DisplayResource *display, byte onOff) {
+ PictureResource *pic;
+ if (display->_flags & DISPFLAG_VIEWPORT) {
+ pic = ((ViewPortResource *)display)->_currentPic;
+ } else {
+ pic = (PictureResource *)display;
+ }
+
+ PictureResource picResource;
+ picResource._flags = 0;
+ picResource._select = 0xff;
+ picResource._pick = 0;
+ picResource._onOff = onOff;
+ picResource._bounds = pic->_bounds;
+
+ sDrawPic(&picResource, display, Common::Point());
+}
+
+/**
+ * Queues the given picture for display
+ */
+void GraphicsManager::sDisplayPic(PictureResource *pic) {
+ _vm->_eventsManager._intPtr._flipWait = true;
+}
+
+void GraphicsManager::flipPage() {
+ Common::Array<ViewPortResource *> &viewPorts = _viewPortListPtr->_entries;
+ bool flipFlag = false;
+
+ for (uint idx = 0; idx < viewPorts.size(); ++idx) {
+ if (viewPorts[idx]->_flags & DISPFLAG_20) {
+ if ((viewPorts[idx]->_flags & (DISPFLAG_8 || DISPFLAG_1))
+ == (DISPFLAG_8 || DISPFLAG_1)) {
+ if (_planeSelect == idx)
+ sDisplayPic(viewPorts[idx]->_currentPic);
+ flipFlag = true;
+ }
+ }
+
+ if (flipFlag) {
+ ViewPortResource &viewPort = *viewPorts[idx];
+
+ viewPort._lastPage = viewPort._pageIndex;
+ ++viewPort._pageIndex;
+
+ if (viewPort._pageIndex >= viewPort._pageCount)
+ viewPort._pageIndex = 0;
+
+ assert(viewPort._pageIndex < 2);
+ viewPort._currentPic = viewPort._pages[viewPort._pageIndex];
+ viewPort._flags = (viewPort._flags & ~DISPFLAG_8) | DISPFLAG_40;
+ }
+ }
+}
+
+void GraphicsManager::restoreBack(Common::Array<Common::Rect> &rectList, int rectListCount,
+ PictureResource *srcPic, PictureResource *destPic) {
+ // WORKAROUND: Since _backgroundPage can point to a resource freed at the end of display methods,
+ // I'm now explicitly resetting it to null in screenReset(), so at this point it can be null
+ if (!srcPic)
+ return;
+
+ bool saveBack = _saveBack;
+ _saveBack = false;
+
+ if (rectListCount == -1) {
+ sDrawPic(srcPic, destPic, Common::Point());
+ } else {
+ for (int i = rectListCount - 1; i >= 0; --i) {
+ _clipPtr = &rectList[i];
+ sDrawPic(srcPic, destPic, Common::Point());
+ }
+ }
+
+ _saveBack = saveBack;
+}
+
+void GraphicsManager::clearPalette() {
+ byte palette[768];
+ Common::fill(&palette[0], &palette[768], 0);
+ g_system->getPaletteManager()->setPalette(&palette[0], 0, 256);
+}
+
+void GraphicsManager::setPalette(const byte *palette, int start, int count) {
+ g_system->getPaletteManager()->setPalette(palette, start, count);
+ _vm->_eventsManager._gameData._hasPalette = false;
+}
+
+void GraphicsManager::setPalette128(const byte *palette, int start, int count) {
+ byte rgb[3];
+ g_system->getPaletteManager()->grabPalette(&rgb[0], 128, 1);
+ g_system->getPaletteManager()->setPalette(palette, start, count);
+ g_system->getPaletteManager()->setPalette(&rgb[0], 128, 1);
+}
+
+
+void GraphicsManager::resetPalette() {
+ for (int i = 0; i < 256; ++i)
+ setColor(i, 0, 0, 0);
+
+ _vm->_eventsManager._intPtr._hasPalette = true;
+}
+
+void GraphicsManager::setColor(int idx, byte r, byte g, byte b) {
+ byte *vgaP = &_VGAColors[idx * 3];
+ vgaP[0] = r;
+ vgaP[1] = g;
+ vgaP[2] = b;
+
+ _vm->_eventsManager._intPtr._palStartIndex = MIN(_vm->_eventsManager._intPtr._palStartIndex, idx);
+ _vm->_eventsManager._intPtr._palEndIndex = MAX(_vm->_eventsManager._intPtr._palEndIndex, idx);
+}
+
+void GraphicsManager::setOneColor(int idx, byte r, byte g, byte b) {
+ byte palEntry[3];
+ palEntry[0] = r;
+ palEntry[1] = g;
+ palEntry[2] = b;
+ g_system->getPaletteManager()->setPalette(&palEntry[0], idx, 1);
+}
+
+void GraphicsManager::setColors(int start, int count, const byte *pal) {
+ for (int i = 0; i < count; ++i) {
+ if ((i + start) != 128) {
+ const byte *rgb = pal + i * 3;
+ setColor(i + start, rgb[0], rgb[1], rgb[2]);
+ }
+ }
+
+ _vm->_eventsManager._intPtr._hasPalette = true;
+}
+
+void GraphicsManager::screenReset() {
+ resetPalette();
+
+ _backgroundPage = NULL;
+ (*_vPort)->setupViewPort(NULL);
+ fillPic(*_vPort, 0);
+
+ _vm->flipPageAndWait();
+}
+
+void GraphicsManager::fadeDownICF1(int steps) {
+ if (steps > 0) {
+ int stepAmount = _vm->_voy._fadingAmount2 / steps;
+
+ for (int idx = 0; idx < steps; ++idx) {
+ _vm->_voy._fadingAmount2 -= stepAmount;
+ _vm->_eventsManager.delay(1);
+ }
+ }
+
+ _vm->_voy._fadingAmount2 = 0;
+}
+
+void GraphicsManager::fadeUpICF1(int steps) {
+ if (steps > 0) {
+ int stepAmount = (63 - _vm->_voy._fadingAmount2) / steps;
+
+ for (int idx = 0; idx < steps; ++idx) {
+ _vm->_voy._fadingAmount2 += stepAmount;
+ _vm->_eventsManager.delay(1);
+ }
+ }
+
+ _vm->_voy._fadingAmount2 = 63;
+}
+
+void GraphicsManager::fadeDownICF(int steps) {
+ if (steps > 0) {
+ _vm->_eventsManager.hideCursor();
+ int stepAmount1 = _vm->_voy._fadingAmount1 / steps;
+ int stepAmount2 = _vm->_voy._fadingAmount2 / steps;
+
+ for (int idx = 0; idx < steps; ++idx) {
+ _vm->_voy._fadingAmount1 -= stepAmount1;
+ _vm->_voy._fadingAmount2 -= stepAmount2;
+ _vm->_eventsManager.delay(1);
+ }
+ }
+
+ _vm->_voy._fadingAmount1 = 0;
+ _vm->_voy._fadingAmount2 = 0;
+}
+
+void GraphicsManager::drawDot() {
+ for (int y = 0; y < 9; ++y) {
+ byte *pDest = (byte *)_screenSurface.getPixels() + DOT_LINE_START[y] + DOT_LINE_OFFSET[y];
+ Common::fill(pDest, pDest + DOT_LINE_LENGTH[y], 0x80);
+ }
+}
+
+void GraphicsManager::synchronize(Common::Serializer &s) {
+ s.syncBytes(&_VGAColors[0], PALETTE_SIZE);
+}
+
+} // End of namespace Voyeur
diff --git a/engines/voyeur/graphics.h b/engines/voyeur/graphics.h
new file mode 100644
index 0000000000..322b90970c
--- /dev/null
+++ b/engines/voyeur/graphics.h
@@ -0,0 +1,134 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef VOYEUR_GRAPHICS_H
+#define VOYEUR_GRAPHICS_H
+
+#include "common/scummsys.h"
+#include "common/array.h"
+#include "common/rect.h"
+#include "common/serializer.h"
+#include "graphics/surface.h"
+
+namespace Voyeur {
+
+#define SCREEN_WIDTH 320
+#define SCREEN_HEIGHT 200
+#define PALETTE_COUNT 256
+#define PALETTE_SIZE (256 * 3)
+
+class VoyeurEngine;
+class GraphicsManager;
+class DisplayResource;
+class PictureResource;
+class ViewPortResource;
+class ViewPortListResource;
+class FontResource;
+class FontInfoResource;
+class CMapResource;
+
+class DrawInfo {
+public:
+ int _penColor;
+ Common::Point _pos;
+ int _flags;
+public:
+ DrawInfo(int penColor, const Common::Point &pos, int flags);
+};
+
+typedef void (GraphicsManager::*GraphicMethodPtr)();
+typedef void (GraphicsManager::*ViewPortSetupPtr)(ViewPortResource *);
+typedef void (GraphicsManager::*ViewPortAddPtr)(ViewPortResource *, int idx, const Common::Rect &bounds);
+typedef void (GraphicsManager::*ViewPortRestorePtr)(ViewPortResource *);
+
+class GraphicsManager {
+public:
+ VoyeurEngine *_vm;
+ bool _palFlag;
+ byte _VGAColors[PALETTE_SIZE];
+ Common::Array<byte *> _colorChain;
+ PictureResource *_backgroundPage;
+ int _SVGAPage;
+ int _SVGAMode;
+ int _SVGAReset;
+ ViewPortListResource *_viewPortListPtr;
+ ViewPortResource **_vPort;
+ bool _MCGAMode;
+ bool _saveBack;
+ Common::Rect *_clipPtr;
+ int _screenOffset;
+ uint _planeSelect;
+ int _sImageShift;
+ Graphics::Surface _screenSurface;
+ CMapResource *_backColors;
+ FontInfoResource *_fontPtr;
+ PictureResource *_fontChar;
+ DrawInfo *_drawPtr;
+ DrawInfo _defaultDrawInfo;
+ bool _drawTextPermFlag;
+private:
+ static void fadeIntFunc();
+ static void vDoCycleInt();
+
+ void restoreBack(Common::Array<Common::Rect> &rectList, int rectListCount,
+ PictureResource *srcPic, PictureResource *destPic);
+public:
+ GraphicsManager();
+ ~GraphicsManager();
+ void setVm(VoyeurEngine *vm) { _vm = vm; }
+ void sInitGraphics();
+
+ void setupMCGASaveRect(ViewPortResource *viewPort);
+ void addRectOptSaveRect(ViewPortResource *viewPort, int idx, const Common::Rect &bounds);
+ void restoreMCGASaveRect(ViewPortResource *viewPort);
+ void addRectNoSaveBack(ViewPortResource *viewPort, int idx, const Common::Rect &bounds);
+
+ void sDrawPic(DisplayResource *srcDisplay, DisplayResource *destDisplay, const Common::Point &initialOffset);
+ void fillPic(DisplayResource *display, byte onOff = 0);
+ void sDisplayPic(PictureResource *pic);
+ void drawANumber(DisplayResource *display, int num, const Common::Point &pt);
+ void flipPage();
+ void clearPalette();
+ void setPalette(const byte *palette, int start, int count);
+ void setPalette128(const byte *palette, int start, int count);
+ void resetPalette();
+ void setColor(int idx, byte r, byte g, byte b);
+ void setOneColor(int idx, byte r, byte g, byte b);
+ void setColors(int start, int count, const byte *pal);
+ void screenReset();
+ void fadeDownICF1(int steps);
+ void fadeUpICF1(int steps);
+ void fadeDownICF(int steps);
+ void drawDot();
+
+ /**
+ * Synchronizes the game data
+ */
+ void synchronize(Common::Serializer &s);
+
+ // Methods in the original that are stubbed in ScummVM
+ void EMSMapPageHandle(int v1, int v2, int v3) {}
+};
+
+} // End of namespace Voyeur
+
+#endif /* VOYEUR_GRAPHICS_H */
diff --git a/engines/voyeur/module.mk b/engines/voyeur/module.mk
new file mode 100644
index 0000000000..aab254cf36
--- /dev/null
+++ b/engines/voyeur/module.mk
@@ -0,0 +1,23 @@
+MODULE := engines/voyeur
+
+MODULE_OBJS := \
+ animation.o \
+ data.o \
+ debugger.o \
+ detection.o \
+ events.o \
+ files.o \
+ files_threads.o \
+ graphics.o \
+ sound.o \
+ staticres.o \
+ voyeur.o \
+ voyeur_game.o
+
+# This module can be built as a plugin
+ifeq ($(ENABLE_VOYEUR), DYNAMIC_PLUGIN)
+PLUGIN := 1
+endif
+
+# Include common rules
+include $(srcdir)/rules.mk
diff --git a/engines/voyeur/sound.cpp b/engines/voyeur/sound.cpp
new file mode 100644
index 0000000000..e81d2891fb
--- /dev/null
+++ b/engines/voyeur/sound.cpp
@@ -0,0 +1,85 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "audio/audiostream.h"
+#include "audio/decoders/raw.h"
+#include "common/memstream.h"
+#include "voyeur/sound.h"
+#include "voyeur/staticres.h"
+
+namespace Voyeur {
+
+SoundManager::SoundManager(Audio::Mixer *mixer) {
+ _mixer = mixer;
+ _vocOffset = 0;
+}
+
+void SoundManager::playVOCMap(byte *voc, int vocSize) {
+ Common::MemoryReadStream *dataStream = new Common::MemoryReadStream(voc, vocSize, DisposeAfterUse::NO);
+ Audio::AudioStream *audioStream = Audio::makeVOCStream(dataStream, Audio::FLAG_UNSIGNED, DisposeAfterUse::YES);
+
+ _mixer->playStream(Audio::Mixer::kSFXSoundType, &_soundHandle, audioStream);
+}
+
+void SoundManager::abortVOCMap() {
+ _mixer->stopHandle(_soundHandle);
+}
+
+void SoundManager::stopVOCPlay() {
+ _mixer->stopHandle(_soundHandle);
+ _vocOffset = 0;
+}
+
+void SoundManager::setVOCOffset(int offset) {
+ _vocOffset = offset;
+}
+
+Common::String SoundManager::getVOCFileName(int idx) {
+ return Common::String::format("%s.voc", SZ_FILENAMES[idx]);
+}
+
+void SoundManager::startVOCPlay(const Common::String &filename) {
+ Common::File f;
+ if (!f.open(filename))
+ error("Could not find voc file - %s", filename.c_str());
+
+ Audio::SeekableAudioStream *audioStream = Audio::makeVOCStream(f.readStream(f.size()),
+ Audio::FLAG_UNSIGNED, DisposeAfterUse::YES);
+
+ _mixer->playStream(Audio::Mixer::kSFXSoundType, &_soundHandle, audioStream);
+ audioStream->seek(Audio::Timestamp(_vocOffset * 1000, 11025));
+}
+
+void SoundManager::startVOCPlay(int soundId) {
+ startVOCPlay(getVOCFileName(soundId));
+}
+
+int SoundManager::getVOCStatus() {
+ return _mixer->isSoundHandleActive(_soundHandle);
+}
+
+uint32 SoundManager::getVOCFrame() {
+ Audio::Timestamp timestamp = _mixer->getElapsedTime(_soundHandle);
+ return timestamp.secs();
+}
+
+} // End of namespace Voyeur
diff --git a/engines/voyeur/sound.h b/engines/voyeur/sound.h
new file mode 100644
index 0000000000..ca05b0bfe0
--- /dev/null
+++ b/engines/voyeur/sound.h
@@ -0,0 +1,60 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef VOYEUR_SOUND_H
+#define VOYEUR_SOUND_H
+
+#include "common/scummsys.h"
+#include "common/str.h"
+#include "audio/mixer.h"
+#include "audio/decoders/voc.h"
+#include "voyeur/files.h"
+
+namespace Voyeur {
+
+class SoundManager {
+private:
+ VoyeurEngine *_vm;
+ Audio::Mixer *_mixer;
+ Audio::SoundHandle _soundHandle;
+ int _vocOffset;
+public:
+ SoundManager(Audio::Mixer *mixer);
+ void setVm(VoyeurEngine *vm) { _vm = vm; }
+
+ void playVOCMap(byte *voc, int vocSize);
+ void stopVOCPlay();
+ void abortVOCMap();
+ void setVOCOffset(int offset);
+ Common::String getVOCFileName(int idx);
+ void startVOCPlay(const Common::String &filename);
+ void startVOCPlay(int soundId);
+ int getVOCStatus();
+ uint32 getVOCFrame();
+
+ // Methods in the original that are stubbed in ScummVM
+ void continueVocMap() {}
+};
+
+} // End of namespace Voyeur
+
+#endif /* VOYEUR_SOUND_H */
diff --git a/engines/voyeur/staticres.cpp b/engines/voyeur/staticres.cpp
new file mode 100644
index 0000000000..9025426c57
--- /dev/null
+++ b/engines/voyeur/staticres.cpp
@@ -0,0 +1,142 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "voyeur/staticres.h"
+
+namespace Voyeur {
+
+const int COMPUTER_DEFAULTS[] = {
+ 18, 1, 0, 1, 33, 0, 998, -1, 18, 2, 0, 1, 41, 0,
+ 998, -1, 18, 3, 0, 1, 47, 0, 998, -1, 18, 4, 0,
+ 1, 53, 0, 998, -1, 18, 5, 0, 1, 46, 0, 998, -1,
+ 18, 6, 0, 1, 50, 0, 998, -1, 18, 7, 0, 1, 40, 0,
+ 998, -1, 18, 8, 0, 1, 43, 0, 998, -1, 19, 1, 0,
+ 2, 28, 0, 998, -1
+};
+
+const int RESOLVE_TABLE[] = {
+ 0x2A00, 0x4A00, 0x1000, 0x4B00, 0x2C00, 0x4F00, 0x1400, 0x5000,
+ 0x1700, 0x5100, 0x1800, 0x5200, 0x3300, 0x5400, 0x3700, 0x5500,
+ 0x1A00, 0x1C00, 0x1E00, 0x1F00, 0x2100, 0x2200, 0x2400, 0x2700,
+ 0x2B00, 0x1100, 0x4C00, 0x1200, 0x4D00, 0x1300, 0x4E00, 0x2E00,
+ 0x1900, 0x3200, 0x3400, 0x3800, 0x2800, 0x3E00, 0x4100, 0x2900,
+ 0x4400, 0x4600, 0x5300, 0x3900, 0x7600, 0x7200, 0x7300, 0x7400,
+ 0x7500
+};
+
+const int LEVEL_H[] = {
+ 4, 7, 7, 8, 9, 10, 2, 2, 4, 8, 8, 9, 9, 10, 10, 11, 11
+};
+
+const int LEVEL_M[] = {
+ 0, 0, 30, 0, 30, 0, 0, 0, 30, 0, 30, 0, 45, 0, 30, 0, 30
+};
+
+const int BLIND_TABLE[] = {
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 9, 10, 11, 1, 11, 5, 12,
+ 13, 16, 15, 16, 17, 18, 5, 6, 18, 17, 13, 13, 14, 14,
+ 5, 12, 6, 6, 13, 14, 13
+};
+
+const int COMP_BUT_TABLE[] = {
+ 269, 128, 307, 163,
+ 269, 128, 307, 163,
+ 68, 79, 98, 102,
+ 68, 79, 98, 102,
+ 68, 79, 98, 102,
+ 68, 79, 98, 102,
+ 248, 138, 291, 163,
+ 83, 132, 143, 156,
+ 248, 138, 291, 163,
+ 83, 132, 143, 156,
+ 83, 132, 143, 156,
+ 248, 138, 291, 163,
+ 68, 79, 98, 102,
+ 68, 79, 98, 102
+};
+
+const char *const SZ_FILENAMES[] = {
+ "A2110100", nullptr, "A2300100", nullptr, "B1220100", nullptr, "C1220100", nullptr,
+ "C1290100", nullptr, "D1220100", nullptr, "D1270100", nullptr, "E1210100", nullptr,
+ "E1260100", nullptr, "E1280100", nullptr, "E1325100", nullptr, "F1200100", nullptr,
+ "G1250100", nullptr, "G1260100", nullptr, "H1200100", nullptr, "H1230100", nullptr,
+ "H1310100", nullptr, "I1300100", nullptr, "J1220100", nullptr, "J1230100", nullptr,
+ "J1320100", nullptr, "K1260100", nullptr, "K1280100", nullptr, "K1325100", nullptr,
+ "L1210100", nullptr, "L1280100", nullptr, "L1290100", nullptr, "L1300100", nullptr,
+ "L1310100", nullptr, "M1260100", nullptr, "M1310100", nullptr, "N1210100", nullptr,
+ "N1225100", nullptr, "N1275510", nullptr, "N1280510", nullptr, "N1325100", nullptr,
+ "O1230100", nullptr, "O1260100", nullptr, "O1260520", nullptr, "O1280100", nullptr,
+ "O1325540", nullptr, "P1276710", nullptr, "P1280540", nullptr, "P1280740", nullptr,
+ "P1290510", nullptr, "P1325100", nullptr, "P1325300", nullptr, "P1325520", nullptr,
+ "Q1230100", nullptr, "Q1240530", nullptr, "Q1240730", nullptr, "Q1260100", nullptr,
+ "Q1260520", nullptr, "Q1260720", nullptr, "Q1325100", nullptr, "R1280540", nullptr,
+ "Z1110510", nullptr, "Z1110520", nullptr, "Z1110530", nullptr, "Z1110540", nullptr,
+ "Z1110545", nullptr, "Z2320100", nullptr, "Z2905300", nullptr, "Z3110100", nullptr,
+ "Z3115510", nullptr, "Z3115520", nullptr, "Z3115530", nullptr, "Z3115540", nullptr,
+ "Z4915100", nullptr, "Z4915200", nullptr, "Z4915300",
+ nullptr, nullptr, nullptr, nullptr, nullptr,
+ "MMARG", "MZACK", "MREED", "MJESSI", "MCHLOE", "MCAMERA", "MENDCRED",
+ "NEWCALL2", "PHONE1", "PHONE2", "PHONE3", "PHONE6", "PHONE8",
+ "B1300100", "C1250100", "C1320100", "D1320100", "E1210200", "E1260200",
+ "E1280200", "E1310100", "G1230100", "G1300100", "I1210100", "I1270100",
+ "I1280100", "J1250100", "J1280100", "K1260200", "K1270100", "K1325200",
+ "L1240100", "M1200100", "M1230100", "M1290100", "N1250100", "N1260100",
+ "N1280100", "O1250510", "O1290510", "O1320510", "O1320710", "P1240100",
+ "P1240530", "P1260100", "P1270100", "P1280100", "P1280530", "P1320530",
+ "Q1240100", "E1325100"
+};
+
+const char *const SATURDAY = "Saturday";
+const char *const SUNDAY = "Sunday";
+const char *const MONDAY = "Monday Morning";
+const char *const AM = "am";
+const char *const PM = "pm";
+
+const char *const START_OF_MESSAGE = "*** Start of Message ***";
+const char *const END_OF_MESSAGE = "*** End of Message ***";
+
+const char *const EVENT_TYPE_STRINGS[4] = { "Video", "Audio", "Evidence", "Computer" };
+
+int DOT_LINE_START[9] = {
+ 0xE880, 0xE9C0, 0xEB00, 0xEC40, 0xED80, 0xEEC0, 0xF000, 0xF140, 0xF280
+};
+int DOT_LINE_OFFSET[9] = {
+ 144, 143, 142, 141, 141, 141, 142, 143, 144
+};
+int DOT_LINE_LENGTH[9] = {
+ 5, 7, 9, 11, 11, 11, 9, 7, 5
+};
+
+const char *const PIRACY_MESSAGE[] = {
+ "It is illegal to make",
+ "unauthorized copies of",
+ "this software. Duplication",
+ "of this software for any",
+ "reason including sale,",
+ "loan, rental, or gift is a",
+ "crime. Penalties include",
+ "fines of up to $50,000",
+ "and jail terms up to",
+ "5 years."
+};
+
+} // End of namespace Voyeur
diff --git a/engines/voyeur/staticres.h b/engines/voyeur/staticres.h
new file mode 100644
index 0000000000..20bffe01e3
--- /dev/null
+++ b/engines/voyeur/staticres.h
@@ -0,0 +1,63 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef VOYEUR_STATICRES_H
+#define VOYEUR_STATICRES_H
+
+#include "common/scummsys.h"
+
+namespace Voyeur {
+
+extern const int COMPUTER_DEFAULTS[];
+
+extern const int RESOLVE_TABLE[];
+
+extern const int LEVEL_H[];
+
+extern const int LEVEL_M[];
+
+extern const int BLIND_TABLE[];
+
+extern const int COMP_BUT_TABLE[];
+
+extern const char *const SZ_FILENAMES[];
+
+extern const char *const SATURDAY;
+extern const char *const SUNDAY;
+extern const char *const MONDAY;
+extern const char *const AM;
+extern const char *const PM;
+
+extern const char *const START_OF_MESSAGE;
+extern const char *const END_OF_MESSAGE;
+
+extern const char *const EVENT_TYPE_STRINGS[4];
+
+extern int DOT_LINE_START[9];
+extern int DOT_LINE_OFFSET[9];
+extern int DOT_LINE_LENGTH[9];
+
+extern const char *const PIRACY_MESSAGE[];
+
+} // End of namespace Voyeur
+
+#endif
diff --git a/engines/voyeur/voyeur.cpp b/engines/voyeur/voyeur.cpp
new file mode 100644
index 0000000000..d7fa92f1cb
--- /dev/null
+++ b/engines/voyeur/voyeur.cpp
@@ -0,0 +1,919 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "voyeur/voyeur.h"
+#include "voyeur/animation.h"
+#include "voyeur/graphics.h"
+#include "voyeur/staticres.h"
+#include "common/scummsys.h"
+#include "common/config-manager.h"
+#include "common/debug-channels.h"
+#include "graphics/palette.h"
+#include "graphics/scaler.h"
+#include "graphics/thumbnail.h"
+
+namespace Voyeur {
+
+VoyeurEngine *g_vm;
+
+VoyeurEngine::VoyeurEngine(OSystem *syst, const VoyeurGameDescription *gameDesc) : Engine(syst),
+ _gameDescription(gameDesc), _randomSource("Voyeur"), _soundManager(_mixer),
+ _defaultFontInfo(3, 0xff, 0xff, 0, 0, ALIGN_LEFT, 0, Common::Point(), 1, 1,
+ Common::Point(1, 1), 1, 0, 0) {
+ _bVoy = NULL;
+ _iForceDeath = -1;
+ _controlPtr = NULL;
+ _stampFlags = 0;
+ _playStampGroupId = _currentVocId = 0;
+ _audioVideoId = -1;
+ _checkTransitionId = -1;
+ _gameHour = 0;
+ _gameMinute = 0;
+ _flashTimeVal = 0;
+ _flashTimeFlag = false;
+ _timeBarVal = -1;
+ _checkPhoneVal = 0;
+ _voyeurArea = AREA_NONE;
+ _loadGameSlot = -1;
+
+ DebugMan.addDebugChannel(kDebugScripts, "scripts", "Game scripts");
+
+ initializeManagers();
+}
+
+VoyeurEngine::~VoyeurEngine() {
+ delete _bVoy;
+}
+
+Common::Error VoyeurEngine::run() {
+ ESP_Init();
+ globalInitBolt();
+
+ // The original allows the victim to be explicitly specified via the command line.
+ // We don't currently support this in ScummVM, but I'm leaving the code below
+ // in case we ever want to make use of it.
+ if (_iForceDeath >= 1 && _iForceDeath <= 4)
+ _voy._eventFlags |= EVTFLAG_VICTIM_PRESET;
+
+ _eventsManager.resetMouse();
+ if (doHeadTitle()) {
+ playStamp();
+ if (!shouldQuit())
+ doTailTitle();
+ }
+
+ //doHeadTitle();
+
+ return Common::kNoError;
+}
+
+
+int VoyeurEngine::getRandomNumber(int maxNumber) {
+ return _randomSource.getRandomNumber(maxNumber);
+}
+
+void VoyeurEngine::initializeManagers() {
+ _debugger.setVm(this);
+ _eventsManager.setVm(this);
+ _filesManager.setVm(this);
+ _graphicsManager.setVm(this);
+ _soundManager.setVm(this);
+ _voy.setVm(this);
+}
+
+void VoyeurEngine::ESP_Init() {
+ ThreadResource::init();
+
+ if (ConfMan.hasKey("save_slot"))
+ _loadGameSlot = ConfMan.getInt("save_slot");
+}
+
+void VoyeurEngine::globalInitBolt() {
+ initBolt();
+
+ _filesManager.openBoltLib("bvoy.blt", _bVoy);
+ _bVoy->getBoltGroup(0x000);
+ _bVoy->getBoltGroup(0x100);
+
+ _graphicsManager._fontPtr = &_defaultFontInfo;
+ _graphicsManager._fontPtr->_curFont = _bVoy->boltEntry(0x101)._fontResource;
+ assert(_graphicsManager._fontPtr->_curFont);
+
+ // Setup default flags
+ _voy._fadeICF0 = false;
+ _voy._viewBounds = nullptr;
+ _voy._curICF0 = _graphicsManager._palFlag ? 0xFFFFA5E0 : 0x5F90;
+
+ _eventsManager.addFadeInt();
+}
+
+void VoyeurEngine::initBolt() {
+ vInitInterrupts();
+ _graphicsManager.sInitGraphics();
+ _eventsManager.vInitColor();
+ initInput();
+}
+
+void VoyeurEngine::vInitInterrupts() {
+ _eventsManager._intPtr._palette = &_graphicsManager._VGAColors[0];
+}
+
+void VoyeurEngine::initInput() {
+}
+
+bool VoyeurEngine::doHeadTitle() {
+// char dest[144];
+
+ _eventsManager.startMainClockInt();
+
+ if (_loadGameSlot == -1) {
+ // Show starting screen
+ if (_bVoy->getBoltGroup(0x500)) {
+ showConversionScreen();
+ _bVoy->freeBoltGroup(0x500);
+
+ if (shouldQuit())
+ return false;
+ }
+
+ if (ConfMan.getBool("copy_protection")) {
+ // Display lock screen
+ bool result = doLock();
+ if (!result || shouldQuit())
+ return false;
+ }
+
+ // Show the title screen
+ _eventsManager.getMouseInfo();
+ showTitleScreen();
+ if (shouldQuit())
+ return false;
+
+ // Opening
+ _eventsManager.getMouseInfo();
+ doOpening();
+ if (shouldQuit())
+ return false;
+
+ _eventsManager.getMouseInfo();
+ doTransitionCard("Saturday Afternoon", "Player's Apartment");
+ _eventsManager.delayClick(90);
+
+ if (_voy._eventFlags & EVTFLAG_VICTIM_PRESET) {
+ // Preset victim turned on, so add a default set of incriminating videos
+ _voy.addEvent(18, 1, EVTYPE_VIDEO, 33, 0, 998, -1);
+ _voy.addEvent(18, 2, EVTYPE_VIDEO, 41, 0, 998, -1);
+ _voy.addEvent(18, 3, EVTYPE_VIDEO, 47, 0, 998, -1);
+ _voy.addEvent(18, 4, EVTYPE_VIDEO, 53, 0, 998, -1);
+ _voy.addEvent(18, 5, EVTYPE_VIDEO, 46, 0, 998, -1);
+ _voy.addEvent(18, 6, EVTYPE_VIDEO, 50, 0, 998, -1);
+ _voy.addEvent(18, 7, EVTYPE_VIDEO, 40, 0, 998, -1);
+ _voy.addEvent(18, 8, EVTYPE_VIDEO, 43, 0, 998, -1);
+ _voy.addEvent(19, 1, EVTYPE_AUDIO, 20, 0, 998, -1);
+ }
+ }
+
+ _voy._aptLoadMode = 140;
+ return true;
+}
+
+void VoyeurEngine::showConversionScreen() {
+ _graphicsManager._backgroundPage = _bVoy->boltEntry(0x502)._picResource;
+ (*_graphicsManager._vPort)->setupViewPort();
+ flipPageAndWait();
+
+ // Immediate palette load to show the initial screen
+ CMapResource *cMap = _bVoy->getCMapResource(0x503);
+ assert(cMap);
+ cMap->_steps = 0;
+ cMap->startFade();
+
+ // Wait briefly
+ _eventsManager.delayClick(150);
+ if (shouldQuit())
+ return;
+
+ // Fade out the screen
+ cMap = _bVoy->getCMapResource(0x5040000);
+ cMap->_steps = 30;
+ cMap->startFade();
+ if (shouldQuit())
+ return;
+
+ flipPageAndWaitForFade();
+
+ _graphicsManager.screenReset();
+}
+
+bool VoyeurEngine::doLock() {
+ bool result = true;
+ int buttonVocSize, wrongVocSize;
+ byte *buttonVoc = _filesManager.fload("button.voc", &buttonVocSize);
+ byte *wrongVoc = _filesManager.fload("wrong.voc", &wrongVocSize);
+
+ if (_bVoy->getBoltGroup(0x700)) {
+ _voy._viewBounds = _bVoy->boltEntry(0x704)._rectResource;
+
+ Common::String password = "3333";
+ PictureResource *cursorPic = _bVoy->getPictureResource(0x702);
+ assert(cursorPic);
+
+ // Get the mappings of keys on the keypad
+ byte *keyData = _bVoy->memberAddr(0x705);
+ int keyCount = READ_LE_UINT16(keyData);
+
+ _graphicsManager._backColors = _bVoy->getCMapResource(0x7010000);
+ _graphicsManager._backgroundPage = _bVoy->getPictureResource(0x700);
+ (*_graphicsManager._vPort)->setupViewPort();
+
+ _graphicsManager._backColors->startFade();
+ (*_graphicsManager._vPort)->_parent->_flags |= DISPFLAG_8;
+ _graphicsManager.flipPage();
+ _eventsManager.sWaitFlip();
+
+ while (!shouldQuit() && (_eventsManager._fadeStatus & 1))
+ _eventsManager.delay(1);
+
+ _eventsManager.setCursorColor(127, 0);
+ _graphicsManager.setColor(1, 64, 64, 64);
+ _graphicsManager.setColor(2, 96, 96, 96);
+ _graphicsManager.setColor(3, 160, 160, 160);
+ _graphicsManager.setColor(4, 224, 224, 224);
+
+ // Set up the cursor
+ _eventsManager.setCursor(cursorPic);
+ _eventsManager.showCursor();
+
+ _eventsManager._intPtr._hasPalette = true;
+
+ _graphicsManager._fontPtr->_curFont = _bVoy->boltEntry(0x708)._fontResource;
+ _graphicsManager._fontPtr->_fontSaveBack = 0;
+ _graphicsManager._fontPtr->_fontFlags = 0;
+
+ Common::String dateString = "ScummVM";
+ Common::String displayString = Common::String::format("Last Play %s", dateString.c_str());
+
+ bool firstLoop = true;
+ bool breakFlag = false;
+ bool flag = false;
+ while (!breakFlag && !shouldQuit()) {
+ (*_graphicsManager._vPort)->setupViewPort();
+ flipPageAndWait();
+
+ // Display the last play time
+ _graphicsManager._fontPtr->_pos = Common::Point(0, 97);
+ _graphicsManager._fontPtr->_justify = ALIGN_CENTRE;
+ _graphicsManager._fontPtr->_justifyWidth = 384;
+ _graphicsManager._fontPtr->_justifyHeight = 97;
+
+ (*_graphicsManager._vPort)->drawText(displayString);
+ flipPageAndWait();
+
+ if (firstLoop) {
+ firstLoop = false;
+ displayString = "";
+ }
+
+ // Loop for getting key presses
+ int key;
+ do {
+ do {
+ // Scan through the list of key rects to check if a keypad key is highlighted
+ key = -1;
+ Common::Point mousePos = _eventsManager.getMousePos() +
+ Common::Point(30, 20);
+
+ for (int keyIndex = 0; keyIndex < keyCount; ++keyIndex) {
+ int x1 = READ_LE_UINT16(keyData + (((keyIndex << 2) + 1) << 1));
+ int x2 = READ_LE_UINT16(keyData + (((keyIndex << 2) + 3) << 1));
+ int y1 = READ_LE_UINT16(keyData + (((keyIndex << 2) + 2) << 1));
+ int y2 = READ_LE_UINT16(keyData + (((keyIndex << 2) + 4) << 1));
+
+ if (mousePos.x >= x1 && mousePos.x <= x2 && mousePos.y >= y1 && mousePos.y <= y2) {
+ key = keyIndex;
+ }
+ }
+
+ _eventsManager.setCursorColor(127, (key == -1) ? 0 : 1);
+ _eventsManager._intPtr._hasPalette = true;
+
+ _eventsManager.delay(1);
+ } while (!shouldQuit() && !_eventsManager._mouseClicked);
+ _eventsManager._mouseClicked = false;
+ } while (!shouldQuit() && key == -1);
+
+ _soundManager.abortVOCMap();
+ _soundManager.playVOCMap(buttonVoc, buttonVocSize);
+
+ while (_soundManager.getVOCStatus()) {
+ if (shouldQuit())
+ break;
+
+ _soundManager.continueVocMap();
+ _eventsManager.delay(1);
+ }
+
+ // Process the key
+ if (key < 10) {
+ // Numeric key
+ if (displayString.size() < 10) {
+ displayString += '0' + key;
+ continue;
+ }
+ } else if (key == 10) {
+ // Accept key
+ if (!flag) {
+ if ((password.empty() && displayString.empty()) || (password == displayString)) {
+ breakFlag = true;
+ result = true;
+ break;
+ }
+ } else {
+ if (displayString.size() > 0) {
+ result = true;
+ breakFlag = true;
+ break;
+ }
+ }
+ } else if (key == 11) {
+ // New code
+ if ((password.empty() && displayString.empty()) || (password != displayString)) {
+ (*_graphicsManager._vPort)->setupViewPort();
+ flag = true;
+ displayString = "";
+ continue;
+ }
+ } else if (key == 12) {
+ // Exit keyword
+ breakFlag = true;
+ result = false;
+ break;
+ } else {
+ continue;
+ }
+
+ _soundManager.playVOCMap(wrongVoc, wrongVocSize);
+ }
+
+ _graphicsManager.fillPic(*_graphicsManager._vPort);
+ flipPageAndWait();
+ _graphicsManager.resetPalette();
+
+ _voy._viewBounds = nullptr;
+ _bVoy->freeBoltGroup(0x700);
+ }
+
+ _eventsManager.hideCursor();
+
+ delete[] buttonVoc;
+ delete[] wrongVoc;
+
+ return result;
+}
+
+void VoyeurEngine::showTitleScreen() {
+ if (_bVoy->getBoltGroup(0x500)) {
+ _graphicsManager._backgroundPage = _bVoy->getPictureResource(0x500);
+
+ (*_graphicsManager._vPort)->setupViewPort();
+ flipPageAndWait();
+
+ // Immediate palette load to show the initial screen
+ CMapResource *cMap = _bVoy->getCMapResource(0x501);
+ assert(cMap);
+ cMap->_steps = 60;
+ cMap->startFade();
+
+ // Wait briefly
+ _eventsManager.delayClick(200);
+ if (shouldQuit())
+ return;
+
+ // Fade out the screen
+ cMap = _bVoy->getCMapResource(0x504);
+ cMap->_steps = 30;
+ cMap->startFade();
+
+ flipPageAndWaitForFade();
+ if (shouldQuit())
+ return;
+
+ _graphicsManager.screenReset();
+ _eventsManager.delayClick(200);
+
+ // Voyeur title
+ playRL2Video("a1100100.rl2");
+ _graphicsManager.screenReset();
+
+ _bVoy->freeBoltGroup(0x500);
+ }
+}
+
+void VoyeurEngine::doOpening() {
+ _graphicsManager.screenReset();
+
+ if (!_bVoy->getBoltGroup(0x200, true))
+ return;
+
+ byte *frameTable = _bVoy->memberAddr(0x215);
+ byte *xyTable = _bVoy->memberAddr(0x216);
+// byte *whTable = _bVoy->memberAddr(0x217);
+ int frameIndex = 0;
+ bool creditShow = true;
+ PictureResource *textPic = nullptr;
+ Common::Point textPos;
+
+ _voy._vocSecondsOffset = 0;
+ _voy._RTVNum = 0;
+ _voy._audioVisualStartTime = _voy._RTVNum;
+ _voy._eventFlags |= EVTFLAG_RECORDING;
+ _gameHour = 4;
+ _gameMinute = 0;
+ _audioVideoId = 1;
+ _eventsManager._videoDead = -1;
+ _voy.addVideoEventStart();
+
+ _voy._eventFlags &= ~EVTFLAG_TIME_DISABLED;
+
+ for (int i = 0; i < 256; ++i)
+ _graphicsManager.setColor(i, 8, 8, 8);
+
+ _eventsManager._intPtr._hasPalette = true;
+ (*_graphicsManager._vPort)->setupViewPort();
+ flipPageAndWait();
+
+ RL2Decoder decoder;
+ decoder.loadFile("a2300100.rl2");
+ decoder.start();
+
+ while (!shouldQuit() && !decoder.endOfVideo() && !_eventsManager._mouseClicked) {
+ if (decoder.hasDirtyPalette()) {
+ const byte *palette = decoder.getPalette();
+ _graphicsManager.setPalette(palette, 0, 256);
+ }
+
+ if (decoder.needsUpdate()) {
+ const Graphics::Surface *frame = decoder.decodeNextFrame();
+
+ Common::copy((const byte *)frame->getPixels(), (const byte *)frame->getPixels() + 320 * 200,
+ (byte *)_graphicsManager._screenSurface.getPixels());
+
+ if (decoder.getCurFrame() >= (int32)READ_LE_UINT32(frameTable + frameIndex * 4)) {
+ if (creditShow) {
+ // Show a credit
+ textPic = _bVoy->boltEntry(frameIndex / 2 + 0x202)._picResource;
+ textPos = Common::Point(READ_LE_UINT16(xyTable + frameIndex * 2),
+ READ_LE_UINT16(xyTable + (frameIndex + 1) * 2));
+
+ creditShow = false;
+ } else {
+ textPic = nullptr;
+
+ creditShow = true;
+ }
+
+ ++frameIndex;
+ }
+
+ if (textPic) {
+ _graphicsManager.sDrawPic(textPic, *_graphicsManager._vPort, textPos);
+ flipPageAndWait();
+ }
+ }
+
+ _eventsManager.getMouseInfo();
+ g_system->delayMillis(10);
+ }
+
+ if ((_voy._RTVNum - _voy._audioVisualStartTime) < 2)
+ _eventsManager.delay(60);
+
+ _voy._eventFlags |= EVTFLAG_TIME_DISABLED;
+ _voy.addVideoEventEnd();
+ _voy._eventFlags &= ~EVTFLAG_RECORDING;
+
+ _bVoy->freeBoltGroup(0x200);
+}
+
+void VoyeurEngine::playRL2Video(const Common::String &filename) {
+ RL2Decoder decoder;
+ decoder.loadFile(filename);
+ decoder.start();
+
+ while (!shouldQuit() && !decoder.endOfVideo() && !_eventsManager._mouseClicked) {
+ if (decoder.hasDirtyPalette()) {
+ const byte *palette = decoder.getPalette();
+ _graphicsManager.setPalette(palette, 0, 256);
+ }
+
+ if (decoder.needsUpdate()) {
+ const Graphics::Surface *frame = decoder.decodeNextFrame();
+
+ Common::copy((const byte *)frame->getPixels(), (const byte *)frame->getPixels() + 320 * 200,
+ (byte *)_graphicsManager._screenSurface.getPixels());
+ }
+
+ _eventsManager.getMouseInfo();
+ g_system->delayMillis(10);
+ }
+}
+
+void VoyeurEngine::playAVideo(int videoId) {
+ playAVideoDuration(videoId, 9999);
+}
+
+void VoyeurEngine::playAVideoDuration(int videoId, int duration) {
+ int totalFrames = duration * 10;
+
+ if (videoId == -1)
+ return;
+
+ PictureResource *pic = NULL;
+ if (videoId == 42) {
+ _eventsManager._videoDead = 0;
+ pic = _bVoy->boltEntry(0xE00 + _eventsManager._videoDead)._picResource;
+ }
+
+ RL2Decoder decoder;
+ decoder.loadVideo(videoId);
+
+ decoder.seek(Audio::Timestamp(_voy._vocSecondsOffset * 1000));
+ decoder.start();
+ int endFrame = decoder.getCurFrame() + totalFrames;
+
+ _eventsManager.getMouseInfo();
+ if (!_voy._fadeICF0)
+ _eventsManager.startCursorBlink();
+
+ while (!shouldQuit() && !decoder.endOfVideo() && !_eventsManager._mouseClicked &&
+ (decoder.getCurFrame() < endFrame)) {
+ if (decoder.needsUpdate()) {
+ const Graphics::Surface *frame = decoder.decodeNextFrame();
+
+ Common::copy((const byte *)frame->getPixels(), (const byte *)frame->getPixels() + 320 * 200,
+ (byte *)_graphicsManager._screenSurface.getPixels());
+ if (_voy._eventFlags & EVTFLAG_RECORDING)
+ _graphicsManager.drawDot();
+ }
+
+ if (decoder.hasDirtyPalette()) {
+ const byte *palette = decoder.getPalette();
+ _graphicsManager.setPalette(palette, 0, decoder.getPaletteCount());
+ _graphicsManager.setOneColor(128, 220, 20, 20);
+ }
+
+ _eventsManager.getMouseInfo();
+ g_system->delayMillis(10);
+ }
+
+ // RL2 finished
+ _graphicsManager.screenReset();
+ _voy._eventFlags &= ~EVTFLAG_RECORDING;
+
+ if (_voy._eventFlags & EVTFLAG_8) {
+ assert(pic);
+ byte *imgData = (*_graphicsManager._vPort)->_currentPic->_imgData;
+ (*_graphicsManager._vPort)->_currentPic->_imgData = pic->_imgData;
+ pic->_imgData = imgData;
+ _voy._eventFlags &= ~EVTFLAG_8;
+ }
+}
+
+void VoyeurEngine::playAudio(int audioId) {
+ _bVoy->getBoltGroup(0x7F00);
+ _graphicsManager._backgroundPage = _bVoy->boltEntry(0x7F00 +
+ BLIND_TABLE[audioId] * 2)._picResource;
+ _graphicsManager._backColors = _bVoy->boltEntry(0x7F01 +
+ BLIND_TABLE[audioId] * 2)._cMapResource;
+
+ (*_graphicsManager._vPort)->setupViewPort();
+ _graphicsManager._backColors->startFade();
+ flipPageAndWaitForFade();
+
+ _voy._eventFlags &= ~EVTFLAG_TIME_DISABLED;
+ _soundManager.setVOCOffset(_voy._vocSecondsOffset);
+ Common::String filename = _soundManager.getVOCFileName(
+ audioId + 159);
+ _soundManager.startVOCPlay(filename);
+ _voy._eventFlags |= EVTFLAG_RECORDING;
+ _eventsManager.startCursorBlink();
+
+ while (!shouldQuit() && !_eventsManager._mouseClicked &&
+ _soundManager.getVOCStatus())
+ _eventsManager.delayClick(1);
+
+ _voy._eventFlags |= EVTFLAG_TIME_DISABLED;
+ _soundManager.stopVOCPlay();
+
+ _bVoy->freeBoltGroup(0x7F00);
+ (*_graphicsManager._vPort)->setupViewPort(NULL);
+
+ _voy._eventFlags &= ~EVTFLAG_RECORDING;
+ _voy._playStampMode = 129;
+}
+
+void VoyeurEngine::doTransitionCard(const Common::String &time, const Common::String &location) {
+ _graphicsManager.setColor(128, 16, 16, 16);
+ _graphicsManager.setColor(224, 220, 220, 220);
+ _eventsManager._intPtr._hasPalette = true;
+
+ (*_graphicsManager._vPort)->setupViewPort(NULL);
+ (*_graphicsManager._vPort)->fillPic(128);
+ _graphicsManager.flipPage();
+ _eventsManager.sWaitFlip();
+
+ flipPageAndWait();
+ (*_graphicsManager._vPort)->fillPic(128);
+
+ FontInfoResource &fi = *_graphicsManager._fontPtr;
+ fi._curFont = _bVoy->boltEntry(257)._fontResource;
+ fi._foreColor = 224;
+ fi._fontSaveBack = 0;
+ fi._pos = Common::Point(0, 116);
+ fi._justify = ALIGN_CENTRE;
+ fi._justifyWidth = 384;
+ fi._justifyHeight = 120;
+
+ (*_graphicsManager._vPort)->drawText(time);
+
+ if (!location.empty()) {
+ fi._pos = Common::Point(0, 138);
+ fi._justify = ALIGN_CENTRE;
+ fi._justifyWidth = 384;
+ fi._justifyHeight = 140;
+
+ (*_graphicsManager._vPort)->drawText(location);
+ }
+
+ flipPageAndWait();
+}
+
+void VoyeurEngine::saveLastInplay() {
+ // No implementation in ScummVM version
+}
+
+void VoyeurEngine::flipPageAndWait() {
+ (*_graphicsManager._vPort)->_flags |= DISPFLAG_8;
+ _graphicsManager.flipPage();
+ _eventsManager.sWaitFlip();
+}
+
+void VoyeurEngine::flipPageAndWaitForFade() {
+ flipPageAndWait();
+
+ while (!shouldQuit() && (_eventsManager._fadeStatus & 1))
+ _eventsManager.delay(1);
+}
+
+void VoyeurEngine::showEndingNews() {
+ _playStampGroupId = (_voy._incriminatedVictimNumber - 1) * 256 + 0x7700;
+ _voy._boltGroupId2 = (_controlPtr->_state->_victimIndex - 1) * 256 + 0x7B00;
+
+ _bVoy->getBoltGroup(_playStampGroupId);
+ _bVoy->getBoltGroup(_voy._boltGroupId2);
+
+ PictureResource *pic = _bVoy->boltEntry(_playStampGroupId)._picResource;
+ CMapResource *pal = _bVoy->boltEntry(_playStampGroupId + 1)._cMapResource;
+
+ (*_graphicsManager._vPort)->setupViewPort(pic);
+ pal->startFade();
+ flipPageAndWaitForFade();
+
+ _eventsManager.getMouseInfo();
+
+ for (int idx = 1; idx < 4; ++idx) {
+ if (idx == 3) {
+ pic = _bVoy->boltEntry(_voy._boltGroupId2)._picResource;
+ pal = _bVoy->boltEntry(_voy._boltGroupId2 + 1)._cMapResource;
+ } else {
+ pic = _bVoy->boltEntry(_playStampGroupId + idx * 2)._picResource;
+ pal = _bVoy->boltEntry(_playStampGroupId + idx * 2 + 1)._cMapResource;
+ }
+
+ (*_graphicsManager._vPort)->setupViewPort(pic);
+ pal->startFade();
+ flipPageAndWaitForFade();
+
+ _bVoy->freeBoltMember(_playStampGroupId + (idx - 1) * 2);
+ _bVoy->freeBoltMember(_playStampGroupId + (idx - 1) * 2 + 1);
+
+ Common::String fname = Common::String::format("news%d.voc", idx);
+ _soundManager.startVOCPlay(fname);
+
+ _eventsManager.getMouseInfo();
+ while (!shouldQuit() && !_eventsManager._mouseClicked &&
+ _soundManager.getVOCStatus()) {
+ _eventsManager.delay(1);
+ _eventsManager.getMouseInfo();
+ }
+
+ _soundManager.stopVOCPlay();
+ if (idx == 3)
+ _eventsManager.delay(3);
+
+ if (shouldQuit() || _eventsManager._mouseClicked)
+ break;
+ }
+
+ _bVoy->freeBoltGroup(_playStampGroupId);
+ _bVoy->freeBoltGroup(_voy._boltGroupId2);
+ _playStampGroupId = -1;
+ _voy._boltGroupId2 = -1;
+}
+
+/*------------------------------------------------------------------------*/
+
+Common::String VoyeurEngine::generateSaveName(int slot) {
+ return Common::String::format("%s.%03d", _targetName.c_str(), slot);
+}
+
+/**
+ * Returns true if it is currently okay to restore a game
+ */
+bool VoyeurEngine::canLoadGameStateCurrently() {
+ return _voyeurArea == AREA_APARTMENT;
+}
+
+/**
+ * Returns true if it is currently okay to save the game
+ */
+bool VoyeurEngine::canSaveGameStateCurrently() {
+ return _voyeurArea == AREA_APARTMENT;
+}
+
+/**
+ * Load the savegame at the specified slot index
+ */
+Common::Error VoyeurEngine::loadGameState(int slot) {
+ _loadGameSlot = slot;
+ return Common::kNoError;
+}
+
+void VoyeurEngine::loadGame(int slot) {
+ // Open up the save file
+ Common::InSaveFile *saveFile = g_system->getSavefileManager()->openForLoading(generateSaveName(slot));
+ if (!saveFile)
+ return;
+
+ Common::Serializer serializer(saveFile, NULL);
+
+ // Store the current time index before the game is loaded
+ _checkTransitionId = _voy._transitionId;
+
+ // Stop any playing sound
+ _soundManager.stopVOCPlay();
+
+ // Read in the savegame header
+ VoyeurSavegameHeader header;
+ if (!header.read(saveFile))
+ return;
+ if (header._thumbnail)
+ header._thumbnail->free();
+ delete header._thumbnail;
+
+ synchronize(serializer);
+
+ delete saveFile;
+
+ // Show a transition card if the time index has changed
+ checkTransition();
+
+ // Load the apartment
+ _mainThread->loadTheApt();
+}
+
+/**
+ * Save the game to the given slot index, and with the given name
+ */
+Common::Error VoyeurEngine::saveGameState(int slot, const Common::String &desc) {
+ // Open the save file for writing
+ Common::OutSaveFile *saveFile = g_system->getSavefileManager()->openForSaving(generateSaveName(slot));
+ if (!saveFile)
+ return Common::kCreatingFileFailed;
+
+ // Write out the header
+ VoyeurSavegameHeader header;
+ header.write(saveFile, this, desc);
+
+ // Set up a serializer
+ Common::Serializer serializer(NULL, saveFile);
+
+ // Synchronise the data
+ synchronize(serializer);
+
+ saveFile->finalize();
+ delete saveFile;
+
+ return Common::kNoError;
+}
+
+void VoyeurEngine::synchronize(Common::Serializer &s) {
+ s.syncAsSint16LE(_glGoState);
+ s.syncAsSint16LE(_glGoStack);
+ s.syncAsSint16LE(_stampFlags);
+ s.syncAsSint16LE(_playStampGroupId);
+ s.syncAsSint16LE(_currentVocId);
+ s.syncAsSint16LE(_audioVideoId);
+
+ s.syncAsSint16LE(_iForceDeath);
+ s.syncAsSint16LE(_gameHour);
+ s.syncAsSint16LE(_gameMinute);
+ s.syncAsSint16LE(_flashTimeVal);
+ s.syncAsSint16LE(_flashTimeFlag);
+ s.syncAsSint16LE(_timeBarVal);
+ s.syncAsSint16LE(_checkPhoneVal);
+
+ // Sub-systems
+ _voy.synchronize(s);
+ _graphicsManager.synchronize(s);
+ _mainThread->synchronize(s);
+ _controlPtr->_state->synchronize(s);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool VoyeurSavegameHeader::read(Common::InSaveFile *f) {
+ char id[4];
+ _thumbnail = NULL;
+
+ uint32 signature = f->readUint32BE();
+ if (signature != MKTAG('V', 'O', 'Y', 'R')) {
+ warning("Invalid savegame");
+ return false;
+ }
+
+ _version = f->readByte();
+ if (_version > VOYEUR_SAVEGAME_VERSION)
+ return false;
+
+ char c;
+ _saveName = "";
+ while ((c = f->readByte()) != 0)
+ _saveName += c;
+
+ // Get the thumbnail
+ _thumbnail = Graphics::loadThumbnail(*f);
+ if (!_thumbnail)
+ return false;
+
+ // Read in the save datet/ime
+ _saveYear = f->readSint16LE();
+ _saveMonth = f->readSint16LE();
+ _saveDay = f->readSint16LE();
+ _saveHour = f->readSint16LE();
+ _saveMinutes = f->readSint16LE();
+ _totalFrames = f->readUint32LE();
+
+ return true;
+}
+
+void VoyeurSavegameHeader::write(Common::OutSaveFile *f, VoyeurEngine *vm, const Common::String &saveName) {
+ // Write ident string
+ f->writeUint32BE(MKTAG('V', 'O', 'Y', 'R'));
+
+ // Write out savegame version
+ f->writeByte(VOYEUR_SAVEGAME_VERSION);
+
+ // Write out savegame name
+ f->write(saveName.c_str(), saveName.size());
+ f->writeByte(0);
+
+ // Create a thumbnail and save it
+ Graphics::Surface *thumb = new Graphics::Surface();
+ ::createThumbnail(thumb, (byte *)vm->_graphicsManager._screenSurface.getPixels(),
+ SCREEN_WIDTH, SCREEN_HEIGHT, vm->_graphicsManager._VGAColors);
+ Graphics::saveThumbnail(*f, *thumb);
+ thumb->free();
+ delete thumb;
+
+ // Write the save datet/ime
+ TimeDate td;
+ g_system->getTimeAndDate(td);
+ f->writeSint16LE(td.tm_year + 1900);
+ f->writeSint16LE(td.tm_mon + 1);
+ f->writeSint16LE(td.tm_mday);
+ f->writeSint16LE(td.tm_hour);
+ f->writeSint16LE(td.tm_min);
+ f->writeUint32LE(vm->_eventsManager.getGameCounter());
+}
+
+} // End of namespace Voyeur
diff --git a/engines/voyeur/voyeur.h b/engines/voyeur/voyeur.h
new file mode 100644
index 0000000000..4daa8f5372
--- /dev/null
+++ b/engines/voyeur/voyeur.h
@@ -0,0 +1,321 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef VOYEUR_VOYEUR_H
+#define VOYEUR_VOYEUR_H
+
+#include "voyeur/debugger.h"
+#include "voyeur/data.h"
+#include "voyeur/events.h"
+#include "voyeur/files.h"
+#include "voyeur/graphics.h"
+#include "voyeur/sound.h"
+#include "common/scummsys.h"
+#include "common/system.h"
+#include "common/error.h"
+#include "common/random.h"
+#include "common/savefile.h"
+#include "common/serializer.h"
+#include "common/util.h"
+#include "engines/engine.h"
+#include "graphics/surface.h"
+
+/**
+ * This is the namespace of the Voyeur engine.
+ *
+ * Status of this engine: In Development
+ *
+ * Games using this engine:
+ * - Voyeur
+ */
+namespace Voyeur {
+
+#define DEBUG_BASIC 1
+#define DEBUG_INTERMEDIATE 2
+#define DEBUG_DETAILED 3
+
+// Constants used for doInterface display of the mansion
+#define MANSION_MAX_X 784
+#define MANSION_MAX_Y 150
+#define MANSION_VIEW_X 40
+#define MANSION_VIEW_Y 27
+#define MANSION_VIEW_WIDTH 240
+#define MANSION_VIEW_HEIGHT 148
+#define MANSION_SCROLL_AREA_X 20
+#define MANSION_SCROLL_AREA_Y 20
+#define MANSION_SCROLL_INC_X 4
+#define MANSION_SCROLL_INC_Y 4
+
+enum VoyeurDebugChannels {
+ kDebugScripts = 1 << 0
+};
+
+enum VoyeurArea { AREA_NONE, AREA_APARTMENT, AREA_INTERFACE, AREA_ROOM, AREA_EVIDENCE };
+
+struct VoyeurGameDescription;
+
+class VoyeurEngine : public Engine {
+private:
+ const VoyeurGameDescription *_gameDescription;
+ Common::RandomSource _randomSource;
+ FontInfoResource _defaultFontInfo;
+
+ void ESP_Init();
+ void initializeManagers();
+ void globalInitBolt();
+ void initBolt();
+ void vInitInterrupts();
+ void initInput();
+
+ bool doHeadTitle();
+ void showConversionScreen();
+ bool doLock();
+ void showTitleScreen();
+ void doOpening();
+
+ void playStamp();
+ void initStamp();
+ void closeStamp();
+
+ /**
+ * Shows the game ending title animation
+ */
+ void doTailTitle();
+
+ /**
+ * Shows the game ending credits
+ */
+ void doClosingCredits();
+
+ /**
+ * Shows the final anti-piracy message before exiting the game
+ */
+ void doPiracy();
+
+ /**
+ * Review previous tape recordings on the TV
+ */
+ void reviewTape();
+
+ /**
+ * Shows the TV gossip animation
+ */
+ void doGossip();
+
+ /**
+ * Shows the animation of the VCR tape during the 'Call the Police' sequence
+ */
+ void doTapePlaying();
+
+ /**
+ * Does a check as to whether a murder has been witnessed
+ */
+ bool checkForMurder();
+
+ /**
+ * Does a check for whether incriminating evidence has been revealed
+ */
+ bool checkForIncriminate();
+
+ /**
+ * Plays a video event previously witnessed
+ */
+ void playAVideoEvent(int eventIndex);
+
+ /**
+ * Shows the user a screen to select one of four characters to send the
+ * video tape to
+ */
+ int getChooseButton();
+
+ /**
+ * Synchronizes the game data
+ */
+ void synchronize(Common::Serializer &s);
+protected:
+ // Engine APIs
+ virtual Common::Error run();
+ virtual bool hasFeature(EngineFeature f) const;
+public:
+ BoltFile *_bVoy;
+ Debugger _debugger;
+ EventsManager _eventsManager;
+ FilesManager _filesManager;
+ GraphicsManager _graphicsManager;
+ SoundManager _soundManager;
+ SVoy _voy;
+
+ BoltFile *_stampLibPtr;
+ BoltGroup *_controlGroupPtr;
+ ControlResource *_controlPtr;
+ byte *_stampData;
+ BoltGroup *_stackGroupPtr;
+ int _glGoState;
+ int _glGoStack;
+ int _stampFlags;
+ int _playStampGroupId;
+ int _currentVocId;
+
+ int _audioVideoId;
+ const int *_resolvePtr;
+ int _iForceDeath;
+ int _checkTransitionId;
+ int _gameHour;
+ int _gameMinute;
+ int _flashTimeVal;
+ bool _flashTimeFlag;
+ int _timeBarVal;
+ int _checkPhoneVal;
+ Common::Point _mansionViewPos;
+ ThreadResource *_mainThread;
+ VoyeurArea _voyeurArea;
+ int _loadGameSlot;
+public:
+ VoyeurEngine(OSystem *syst, const VoyeurGameDescription *gameDesc);
+ virtual ~VoyeurEngine();
+ void GUIError(const Common::String &msg);
+
+ uint32 getFeatures() const;
+ Common::Language getLanguage() const;
+ Common::Platform getPlatform() const;
+ uint16 getVersion() const;
+ bool getIsDemo() const;
+
+ int getRandomNumber(int maxNumber);
+ Common::String generateSaveName(int slotNumber);
+ virtual bool canLoadGameStateCurrently();
+ virtual bool canSaveGameStateCurrently();
+ virtual Common::Error loadGameState(int slot);
+ virtual Common::Error saveGameState(int slot, const Common::String &desc);
+ void loadGame(int slot);
+
+ void playRL2Video(const Common::String &filename);
+ void doTransitionCard(const Common::String &time, const Common::String &location);
+
+ /**
+ * Play a given video
+ */
+ void playAVideo(int videoId);
+
+ /**
+ * Play a given video for a given amount of time. This is particularly used
+ * for later tape playback, where it will only play back as much of the video
+ * as the user originally watched (since they can break out of watching a video).
+ */
+ void playAVideoDuration(int videoId, int duration);
+
+ /**
+ * Play an audio sequence
+ */
+ void playAudio(int audioId);
+
+ /**
+ * Saves the last time the game was played
+ */
+ void saveLastInplay();
+ void makeViewFinder();
+ void makeViewFinderP();
+ void initIFace();
+ void checkTransition();
+ int doComputerText(int maxLen);
+ void getComputerBrush();
+
+ /**
+ * Displays the time/charge remaining on the video camera screen
+ */
+ void doTimeBar(bool force);
+
+ /**
+ * If necessary, flashes the time remaining bar on the video camera screen
+ */
+ void flashTimeBar();
+
+ /**
+ * Handle scrolling of the mansion view in the camera sights
+ */
+ void doScroll(const Common::Point &pt);
+
+ /**
+ * Check for phone call
+ */
+ void checkPhoneCall();
+
+ /**
+ * Display evidence sequence from within a room
+ * Suspension of disbelief needed to believe that recording from a distance,
+ * you could still flip through the often pages of evidence for a single hotspot.
+ */
+ void doEvidDisplay(int evidId, int eventId);
+
+ /**
+ * Flips the active page and waits until it's drawn
+ */
+ void flipPageAndWait();
+
+ /**
+ * Flips the active page and waits until it's drawn and faded in
+ */
+ void flipPageAndWaitForFade();
+
+ /**
+ * Returns the string for the current in-game day of the week
+ */
+ Common::String getDayName();
+
+ /**
+ * Returns the string for the current in-game time of day
+ */
+ Common::String getTimeOfDay();
+
+ /**
+ * Show the ending sequence of the arrest
+ */
+ void showEndingNews();
+};
+
+#define VOYEUR_SAVEGAME_VERSION 1
+
+/**
+ * Header for Voyeur savegame files
+ */
+struct VoyeurSavegameHeader {
+ uint8 _version;
+ Common::String _saveName;
+ Graphics::Surface *_thumbnail;
+ int _saveYear, _saveMonth, _saveDay;
+ int _saveHour, _saveMinutes;
+ int _totalFrames;
+
+ /**
+ * Read in the header from the specified file
+ */
+ bool read(Common::InSaveFile *f);
+
+ /**
+ * Write out header information to the specified file
+ */
+ void write(Common::OutSaveFile *f, VoyeurEngine *vm, const Common::String &saveName);
+};
+
+} // End of namespace Voyeur
+
+#endif /* VOYEUR_VOYEUR_H */
diff --git a/engines/voyeur/voyeur_game.cpp b/engines/voyeur/voyeur_game.cpp
new file mode 100644
index 0000000000..b664074b56
--- /dev/null
+++ b/engines/voyeur/voyeur_game.cpp
@@ -0,0 +1,1423 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "voyeur/voyeur.h"
+#include "voyeur/staticres.h"
+#include "voyeur/animation.h"
+
+namespace Voyeur {
+
+void VoyeurEngine::playStamp() {
+ _stampLibPtr = NULL;
+ _filesManager.openBoltLib("stampblt.blt", _stampLibPtr);
+
+ _stampLibPtr->getBoltGroup(0);
+ _controlPtr->_state = _stampLibPtr->boltEntry(_controlPtr->_stateId >> 16)._stateResource;
+ assert(_controlPtr->_state);
+
+ _resolvePtr = &RESOLVE_TABLE[0];
+ initStamp();
+
+ PtrResource *threadsList = _stampLibPtr->boltEntry(3)._ptrResource;
+ _mainThread = threadsList->_entries[0]->_threadResource;
+ _mainThread->initThreadStruct(0, 0);
+
+ _voy._isAM = false;
+ _gameHour = 9;
+ _gameMinute = 0;
+ _voy._abortInterface = true;
+
+ int buttonId;
+ bool breakFlag = false;
+ while (!breakFlag && !shouldQuit()) {
+ _voyeurArea = AREA_NONE;
+ _eventsManager.getMouseInfo();
+ _playStampGroupId = _currentVocId = -1;
+ _audioVideoId = -1;
+
+ _mainThread->parsePlayCommands();
+
+ bool flag = breakFlag = (_voy._eventFlags & EVTFLAG_2) != 0;
+
+ switch (_voy._playStampMode) {
+ case 5:
+ buttonId = _mainThread->doInterface();
+
+ if (buttonId == -2) {
+ switch (_mainThread->doApt()) {
+ case 0:
+ _voy._aptLoadMode = 140;
+ break;
+ case 1:
+ _voy._eventFlags &= ~EVTFLAG_TIME_DISABLED;
+ _voy._abortInterface = true;
+ _mainThread->chooseSTAMPButton(22);
+ _voy._aptLoadMode = 143;
+ break;
+ case 2:
+ _voy._eventFlags &= ~EVTFLAG_TIME_DISABLED;
+ reviewTape();
+ _voy._abortInterface = true;
+ _voy._aptLoadMode = 142;
+ break;
+ case 3:
+ _voy._eventFlags &= ~EVTFLAG_TIME_DISABLED;
+ _mainThread->chooseSTAMPButton(21);
+ break;
+ case 4:
+ breakFlag = true;
+ break;
+ case 5:
+ doGossip();
+ _voy._abortInterface = true;
+ _voy._aptLoadMode = 141;
+ _voy._eventFlags &= ~EVTFLAG_100;
+ break;
+ default:
+ break;
+ }
+ } else {
+ _mainThread->chooseSTAMPButton(buttonId);
+ }
+
+ flag = true;
+ break;
+
+ case 6:
+ _mainThread->doRoom();
+ flag = true;
+ break;
+
+ case 16:
+ _voy._transitionId = 17;
+ buttonId = _mainThread->doApt();
+
+ switch (buttonId) {
+ case 1:
+ _mainThread->chooseSTAMPButton(22);
+ flag = true;
+ break;
+ case 2:
+ reviewTape();
+ _voy._abortInterface = true;
+ break;
+ case 4:
+ flag = true;
+ breakFlag = true;
+ break;
+ default:
+ break;
+ }
+ break;
+
+ case 17:
+ // Called the police, showing the tape
+ doTapePlaying();
+ if (!checkForMurder() && _voy._transitionId <= 15)
+ checkForIncriminate();
+
+ if (_voy._videoEventId != -1) {
+ // Show the found video that is of interest to the police
+ playAVideoEvent(_voy._videoEventId);
+ _voy._eventFlags &= ~EVTFLAG_RECORDING;
+ }
+
+ // Handle response
+ _mainThread->chooseSTAMPButton(0);
+ flag = true;
+ break;
+
+ case 130: {
+ // user selected to send the tape
+ if (_bVoy->getBoltGroup(_playStampGroupId)) {
+ _graphicsManager._backgroundPage = _bVoy->boltEntry(_playStampGroupId)._picResource;
+ _graphicsManager._backColors = _bVoy->boltEntry(_playStampGroupId + 1)._cMapResource;
+
+ buttonId = getChooseButton();
+ if (_eventsManager._rightClick)
+ // Aborted out of selecting a recipient
+ buttonId = 4;
+
+ _bVoy->freeBoltGroup(_playStampGroupId);
+ _graphicsManager.screenReset();
+ _playStampGroupId = -1;
+ flag = true;
+
+ if (buttonId != 4) {
+ _voy._playStampMode = 131;
+ _voy.checkForKey();
+ _mainThread->chooseSTAMPButton(buttonId);
+ } else {
+ _mainThread->chooseSTAMPButton(buttonId);
+ _voy._abortInterface = true;
+ }
+ }
+ break;
+ }
+
+ default:
+ break;
+ }
+
+ do {
+ if (flag) {
+ if (_currentVocId != -1) {
+ _soundManager.stopVOCPlay();
+ _currentVocId = -1;
+ }
+
+ _audioVideoId = -1;
+
+ if (_voy._boltGroupId2 != -1) {
+ _bVoy->freeBoltGroup(_voy._boltGroupId2);
+ _voy._boltGroupId2 = -1;
+ }
+
+ if (_playStampGroupId != -1) {
+ _bVoy->freeBoltGroup(_playStampGroupId);
+ _playStampGroupId = -1;
+ }
+
+ // Break out of loop
+ flag = false;
+
+ } else if (_mainThread->_stateFlags & 2) {
+ _eventsManager.getMouseInfo();
+ _mainThread->chooseSTAMPButton(0);
+ flag = true;
+ } else {
+ _mainThread->chooseSTAMPButton(0);
+ flag = true;
+ }
+ } while (flag);
+ }
+
+ _voy._viewBounds = nullptr;
+ closeStamp();
+ _stampLibPtr->freeBoltGroup(0);
+ delete _stampLibPtr;
+}
+
+void VoyeurEngine::initStamp() {
+ _stampFlags &= ~1;
+ _stackGroupPtr = _controlGroupPtr;
+
+ if (!_controlPtr->_entries[0])
+ error("No control entries");
+
+ ThreadResource::initUseCount();
+}
+
+void VoyeurEngine::closeStamp() {
+ ThreadResource::unloadAllStacks(this);
+}
+
+void VoyeurEngine::doTailTitle() {
+ (*_graphicsManager._vPort)->setupViewPort(NULL);
+ _graphicsManager.screenReset();
+
+ if (_bVoy->getBoltGroup(0x600)) {
+ RL2Decoder decoder;
+ decoder.loadFile("a1100200.rl2");
+ decoder.start();
+ decoder.play(this);
+
+ if (!shouldQuit() && !_eventsManager._mouseClicked) {
+ doClosingCredits();
+
+ if (!shouldQuit() && !_eventsManager._mouseClicked) {
+ _graphicsManager.screenReset();
+
+ PictureResource *pic = _bVoy->boltEntry(0x602)._picResource;
+ CMapResource *pal = _bVoy->boltEntry(0x603)._cMapResource;
+
+ (*_graphicsManager._vPort)->setupViewPort(pic);
+ pal->startFade();
+ flipPageAndWaitForFade();
+ _eventsManager.delayClick(300);
+
+ pic = _bVoy->boltEntry(0x604)._picResource;
+ pal = _bVoy->boltEntry(0x605)._cMapResource;
+
+ (*_graphicsManager._vPort)->setupViewPort(pic);
+ pal->startFade();
+ flipPageAndWaitForFade();
+ _eventsManager.delayClick(120);
+
+ _soundManager.stopVOCPlay();
+ }
+ }
+
+ _bVoy->freeBoltGroup(0x600);
+ }
+
+ if (!shouldQuit()) {
+ _bVoy->getBoltGroup(0x100);
+ doPiracy();
+ }
+}
+
+void VoyeurEngine::doClosingCredits() {
+ if (!_bVoy->getBoltGroup(0x400))
+ return;
+
+ const char *msg = (const char *)_bVoy->memberAddr(0x404);
+ const byte *creditList = (const byte *)_bVoy->memberAddr(0x405);
+
+ (*_graphicsManager._vPort)->setupViewPort(NULL);
+ _graphicsManager.setColor(1, 180, 180, 180);
+ _graphicsManager.setColor(2, 200, 200, 200);
+ _eventsManager._intPtr._hasPalette = true;
+
+ _graphicsManager._fontPtr->_curFont = _bVoy->boltEntry(0x402)._fontResource;
+ _graphicsManager._fontPtr->_foreColor = 2;
+ _graphicsManager._fontPtr->_backColor = 2;
+ _graphicsManager._fontPtr->_fontSaveBack = false;
+ _graphicsManager._fontPtr->_fontFlags = 0;
+
+ _soundManager.startVOCPlay(152);
+ FontInfoResource &fi = *_graphicsManager._fontPtr;
+
+ for (int idx = 0; idx < 78; ++idx) {
+ const byte *entry = creditList + idx * 6;
+ int flags = READ_LE_UINT16(entry + 4);
+
+ if (flags & 0x10)
+ (*_graphicsManager._vPort)->fillPic();
+
+ if (flags & 1) {
+ fi._foreColor = 1;
+ fi._curFont = _bVoy->boltEntry(0x402)._fontResource;
+ fi._justify = ALIGN_CENTRE;
+ fi._justifyWidth = 384;
+ fi._justifyHeight = 240;
+ fi._pos = Common::Point(0, READ_LE_UINT16(entry));
+
+ (*_graphicsManager._vPort)->drawText(msg);
+ msg += strlen(msg) + 1;
+ }
+
+ if (flags & 0x40) {
+ fi._foreColor = 2;
+ fi._curFont = _bVoy->boltEntry(0x400)._fontResource;
+ fi._justify = ALIGN_CENTRE;
+ fi._justifyWidth = 384;
+ fi._justifyHeight = 240;
+ fi._pos = Common::Point(0, READ_LE_UINT16(entry));
+
+ (*_graphicsManager._vPort)->drawText(msg);
+ msg += strlen(msg) + 1;
+ }
+
+ if (flags & 2) {
+ fi._foreColor = 1;
+ fi._curFont = _bVoy->boltEntry(0x400)._fontResource;
+ fi._justify = ALIGN_LEFT;
+ fi._justifyWidth = 384;
+ fi._justifyHeight = 240;
+ fi._pos = Common::Point(38, READ_LE_UINT16(entry));
+
+ (*_graphicsManager._vPort)->drawText(msg);
+ msg += strlen(msg) + 1;
+
+ fi._foreColor = 2;
+ fi._justify = ALIGN_LEFT;
+ fi._justifyWidth = 384;
+ fi._justifyHeight = 240;
+ fi._pos = Common::Point(198, READ_LE_UINT16(entry));
+
+ (*_graphicsManager._vPort)->drawText(msg);
+ msg += strlen(msg) + 1;
+ }
+
+ if (flags & 4) {
+ fi._foreColor = 1;
+ fi._curFont = _bVoy->boltEntry(0x402)._fontResource;
+ fi._justify = ALIGN_CENTRE;
+ fi._justifyWidth = 384;
+ fi._justifyHeight = 240;
+ fi._pos = Common::Point(0, READ_LE_UINT16(entry));
+
+ (*_graphicsManager._vPort)->drawText(msg);
+ msg += strlen(msg) + 1;
+
+ fi._foreColor = 2;
+ fi._curFont = _bVoy->boltEntry(0x400)._fontResource;
+ fi._justify = ALIGN_CENTRE;
+ fi._justifyWidth = 384;
+ fi._justifyHeight = 240;
+ fi._pos = Common::Point(0, READ_LE_UINT16(entry) + 13);
+
+ (*_graphicsManager._vPort)->drawText(msg);
+ msg += strlen(msg) + 1;
+ }
+
+ if (flags & 0x20) {
+ flipPageAndWait();
+ _eventsManager.delayClick(READ_LE_UINT16(entry + 2) * 60);
+ }
+
+ if (shouldQuit() || _eventsManager._mouseClicked)
+ break;
+ }
+
+ _soundManager.stopVOCPlay();
+ _graphicsManager._fontPtr->_curFont = _bVoy->boltEntry(0x101)._fontResource;
+ _bVoy->freeBoltGroup(0x400);
+}
+
+void VoyeurEngine::doPiracy() {
+ _graphicsManager.screenReset();
+ _graphicsManager.setColor(1, 0, 0, 0);
+ _graphicsManager.setColor(2, 255, 255, 255);
+ _eventsManager._intPtr._hasPalette = true;
+ (*_graphicsManager._vPort)->setupViewPort(NULL);
+ (*_graphicsManager._vPort)->fillPic(1);
+
+ FontInfoResource &fi = *_graphicsManager._fontPtr;
+ fi._curFont = _bVoy->boltEntry(0x101)._fontResource;
+ fi._foreColor = 2;
+ fi._backColor = 2;
+ fi._fontSaveBack = false;
+ fi._fontFlags = 0;
+ fi._justify = ALIGN_CENTRE;
+ fi._justifyWidth = 384;
+ fi._justifyHeight = 230;
+
+ // Loop through the piracy message array to draw each line
+ int yp, idx;
+ for (idx = 0, yp = 33; idx < 10; ++idx) {
+ fi._pos = Common::Point(0, yp);
+ (*_graphicsManager._vPort)->drawText(PIRACY_MESSAGE[idx]);
+
+ yp += fi._curFont->_fontHeight + 4;
+ }
+
+ flipPageAndWait();
+ _eventsManager.getMouseInfo();
+ _eventsManager.delayClick(720);
+}
+
+void VoyeurEngine::reviewTape() {
+ int eventStart = 0;
+ int newX = -1;
+ int newY = -1;
+ int eventLine = 7;
+ Common::Rect tempRect(58, 30, 58 + 223, 30 + 124);
+ Common::Point pt;
+ int foundIndex;
+ int eventNum;
+
+ _bVoy->getBoltGroup(0x900);
+ PictureResource *cursor = _bVoy->boltEntry(0x903)._picResource;
+
+ if ((_voy._eventCount - 8) != 0)
+ eventStart = MAX(_voy._eventCount - 8, 0);
+
+ if ((eventStart + _voy._eventCount) <= 7)
+ eventLine = eventStart + _voy._eventCount - 1;
+
+ bool breakFlag = false;
+ while (!shouldQuit() && !breakFlag) {
+ _voy._viewBounds = _bVoy->boltEntry(0x907)._rectResource;
+ Common::Array<RectEntry> &hotspots = _bVoy->boltEntry(0x906)._rectResource->_entries;
+
+ _graphicsManager._backColors = _bVoy->boltEntry(0x902)._cMapResource;
+ _graphicsManager._backgroundPage = _bVoy->boltEntry(0x901)._picResource;
+ (*_graphicsManager._vPort)->setupViewPort(_graphicsManager._backgroundPage);
+ _graphicsManager._backColors->startFade();
+
+ flipPageAndWaitForFade();
+
+ _graphicsManager.setColor(1, 32, 32, 32);
+ _graphicsManager.setColor(2, 96, 96, 96);
+ _graphicsManager.setColor(3, 160, 160, 160);
+ _graphicsManager.setColor(4, 224, 224, 224);
+ _graphicsManager.setColor(9, 24, 64, 24);
+ _graphicsManager.setColor(10, 64, 132, 64);
+ _graphicsManager.setColor(11, 100, 192, 100);
+ _graphicsManager.setColor(12, 120, 248, 120);
+ _eventsManager.setCursorColor(128, 1);
+
+ _eventsManager._intPtr._hasPalette = true;
+ _graphicsManager._fontPtr->_curFont = _bVoy->boltEntry(0x909)._fontResource;
+ _graphicsManager._fontPtr->_fontSaveBack = false;
+ _graphicsManager._fontPtr->_fontFlags = 0;
+
+ _eventsManager.getMouseInfo();
+ if (newX == -1) {
+ _eventsManager.setMousePos(Common::Point(hotspots[1].left + 12, hotspots[1].top + 6));
+ } else {
+ _eventsManager.setMousePos(Common::Point(newX, newY));
+ }
+
+ _currentVocId = 151;
+ _voy._vocSecondsOffset = 0;
+ bool var1E = true;
+ do {
+ if (_currentVocId != -1 && !_soundManager.getVOCStatus()) {
+ _voy._musicStartTime = _voy._RTVNum;
+ _soundManager.startVOCPlay(_currentVocId);
+ }
+
+ if (var1E) {
+ var1E = false;
+ flipPageAndWait();
+
+ _graphicsManager._drawPtr->_penColor = 0;
+ _graphicsManager._drawPtr->_pos = Common::Point(tempRect.left, tempRect.top);
+ _graphicsManager._backgroundPage->sFillBox(tempRect.width(), tempRect.height());
+
+ int yp = 45;
+ int eventNum = eventStart;
+ for (int lineNum = 0; lineNum < 8 && eventNum < _voy._eventCount; ++lineNum, ++eventNum) {
+ _graphicsManager._fontPtr->_picFlags = 0;
+ _graphicsManager._fontPtr->_picSelect = 0xff;
+ _graphicsManager._fontPtr->_picPick = 7;
+ _graphicsManager._fontPtr->_picOnOff = (lineNum == eventLine) ? 8 : 0;
+ _graphicsManager._fontPtr->_pos = Common::Point(68, yp);
+ _graphicsManager._fontPtr->_justify = ALIGN_LEFT;
+ _graphicsManager._fontPtr->_justifyWidth = 0;
+ _graphicsManager._fontPtr->_justifyHeight = 0;
+
+ Common::String msg = _eventsManager.getEvidString(eventNum);
+ _graphicsManager._backgroundPage->drawText(msg);
+
+ yp += 15;
+ }
+
+ (*_graphicsManager._vPort)->addSaveRect(
+ (*_graphicsManager._vPort)->_lastPage, tempRect);
+ flipPageAndWait();
+
+ (*_graphicsManager._vPort)->addSaveRect(
+ (*_graphicsManager._vPort)->_lastPage, tempRect);
+ }
+
+ _graphicsManager.sDrawPic(cursor, *_graphicsManager._vPort,
+ _eventsManager.getMousePos());
+ flipPageAndWait();
+
+ _eventsManager.getMouseInfo();
+ foundIndex = -1;
+
+ Common::Point tempPos = _eventsManager.getMousePos() + Common::Point(14, 7);
+ for (uint idx = 0; idx < hotspots.size(); ++idx) {
+ if (hotspots[idx].contains(tempPos)) {
+ // Found hotspot area
+ foundIndex = idx;
+ break;
+ }
+ }
+
+ pt = _eventsManager.getMousePos();
+ if (tempPos.x >= 68 && tempPos.x <= 277 && tempPos.y >= 31 && tempPos.y <= 154) {
+ tempPos.y -= 2;
+ foundIndex = (tempPos.y - 31) / 15;
+ if ((tempPos.y - 31) % 15 >= 12 || (eventStart + foundIndex) >= _voy._eventCount) {
+ _eventsManager.setCursorColor(128, 0);
+ foundIndex = 999;
+ } else if (!_eventsManager._leftClick) {
+ _eventsManager.setCursorColor(128, 2);
+ foundIndex = -1;
+ } else {
+ _eventsManager.setCursorColor(128, 2);
+ eventLine = foundIndex;
+
+ flipPageAndWait();
+
+ _graphicsManager._drawPtr->_penColor = 0;
+ _graphicsManager._drawPtr->_pos = Common::Point(tempRect.left, tempRect.top);
+ _graphicsManager._backgroundPage->sFillBox(tempRect.width(), tempRect.height());
+
+ int yp = 45;
+ eventNum = eventStart;
+ for (int idx = 0; idx < 8 && eventNum < _voy._eventCount; ++idx, ++eventNum) {
+ _graphicsManager._fontPtr->_picFlags = 0;
+ _graphicsManager._fontPtr->_picSelect = 0xff;
+ _graphicsManager._fontPtr->_picPick = 7;
+ _graphicsManager._fontPtr->_picOnOff = (idx == eventLine) ? 8 : 0;
+ _graphicsManager._fontPtr->_pos = Common::Point(68, yp);
+ _graphicsManager._fontPtr->_justify = ALIGN_LEFT;
+ _graphicsManager._fontPtr->_justifyWidth = 0;
+ _graphicsManager._fontPtr->_justifyHeight = 0;
+
+ Common::String msg = _eventsManager.getEvidString(eventNum);
+ _graphicsManager._backgroundPage->drawText(msg);
+
+ yp += 15;
+ }
+
+ (*_graphicsManager._vPort)->addSaveRect(
+ (*_graphicsManager._vPort)->_lastPage, tempRect);
+ flipPageAndWait();
+
+ (*_graphicsManager._vPort)->addSaveRect(
+ (*_graphicsManager._vPort)->_lastPage, tempRect);
+ flipPageAndWait();
+
+ _eventsManager.getMouseInfo();
+ foundIndex = -1;
+ }
+ } else if ((_voy._eventFlags & EVTFLAG_40) && _voy._viewBounds->left == pt.x &&
+ _voy._viewBounds->bottom == pt.y) {
+ foundIndex = 999;
+ } else if ((_voy._eventFlags & EVTFLAG_40) && _voy._viewBounds->left == pt.x &&
+ _voy._viewBounds->top == pt.y) {
+ foundIndex = 998;
+ } else {
+ _eventsManager.setCursorColor(128, (foundIndex == -1) ? 0 : 1);
+ }
+
+ _eventsManager._intPtr._hasPalette = true;
+
+ if (_eventsManager._mouseClicked || _eventsManager._mouseUnk) {
+ switch (foundIndex) {
+ case 2:
+ if (eventStart > 0) {
+ --eventStart;
+ var1E = true;
+ }
+ foundIndex = -1;
+ break;
+
+ case 3:
+ if (eventStart > 0) {
+ eventStart -= 8;
+ if (eventStart < 0)
+ eventStart = 0;
+ var1E = true;
+ }
+ foundIndex = -1;
+ break;
+
+ case 4:
+ if ((_voy._eventCount - 8) > eventStart) {
+ ++eventStart;
+ var1E = true;
+ }
+ foundIndex = -1;
+ break;
+
+ case 5:
+ if (_voy._eventCount >= 8 && (_voy._eventCount - 8) != eventStart) {
+ eventStart += 8;
+ if ((_voy._eventCount - 8) < eventStart)
+ eventStart = _voy._eventCount - 8;
+ var1E = true;
+ }
+ foundIndex = -1;
+ break;
+
+ default:
+ break;
+ }
+
+ while (eventLine > 0 && (eventLine + eventStart) >= _voy._eventCount)
+ --eventLine;
+ }
+
+ pt = _eventsManager.getMousePos();
+ if (_eventsManager._mouseClicked && _voy._viewBounds->left == pt.x &&
+ (_voy._eventFlags & EVTFLAG_40) && _eventsManager._rightClick) {
+ _controlPtr->_state->_victimIndex = (pt.y / 60) + 1;
+ foundIndex = -1;
+ _eventsManager._rightClick = 0;
+ }
+
+ if (_eventsManager._rightClick)
+ foundIndex = 0;
+
+ } while (!shouldQuit() && (!_eventsManager._mouseClicked || foundIndex == -1));
+
+ newY = _eventsManager.getMousePos().y;
+ _voy._fadingType = 0;
+ _voy._viewBounds = nullptr;
+ (*_graphicsManager._vPort)->setupViewPort(NULL);
+
+ if (_currentVocId != -1) {
+ _voy._vocSecondsOffset = _voy._RTVNum - _voy._musicStartTime;
+ _soundManager.stopVOCPlay();
+ }
+
+ // Break out if the exit button was pressed
+ if (!foundIndex)
+ break;
+
+ int eventIndex = eventStart + eventLine;
+ VoyeurEvent &e = _voy._events[eventIndex];
+ switch (e._type) {
+ case EVTYPE_VIDEO:
+ playAVideoEvent(eventIndex);
+ break;
+
+ case EVTYPE_AUDIO: {
+ _audioVideoId = e._audioVideoId;
+ _voy._vocSecondsOffset = e._computerOn;
+
+ _bVoy->getBoltGroup(0x7F00);
+ _graphicsManager._backgroundPage = _bVoy->boltEntry(0x7F00 +
+ BLIND_TABLE[_audioVideoId])._picResource;
+ _graphicsManager._backColors = _bVoy->boltEntry(0x7F01 +
+ BLIND_TABLE[_audioVideoId])._cMapResource;
+
+ (*_graphicsManager._vPort)->setupViewPort(_graphicsManager._backgroundPage);
+ _graphicsManager._backColors->startFade();
+ flipPageAndWaitForFade();
+
+ _eventsManager._intPtr._flashStep = 1;
+ _eventsManager._intPtr._flashTimer = 0;
+ _voy._eventFlags &= ~EVTFLAG_TIME_DISABLED;
+
+ // Play suond for the given duration
+ _soundManager.setVOCOffset(_voy._vocSecondsOffset);
+ _soundManager.startVOCPlay(_audioVideoId + 159);
+ uint32 secondsDuration = e._computerOff;
+
+ _eventsManager.getMouseInfo();
+ while (!_eventsManager._mouseClicked && _soundManager.getVOCStatus() &&
+ _soundManager.getVOCFrame() < secondsDuration) {
+ _eventsManager.getMouseInfo();
+ _eventsManager.delay(10);
+ }
+
+ _voy._eventFlags |= EVTFLAG_TIME_DISABLED;
+ _soundManager.stopVOCPlay();
+ _bVoy->freeBoltGroup(0x7F00);
+ break;
+ }
+
+ case EVTYPE_EVID:
+ _voy.reviewAnEvidEvent(eventIndex);
+
+ _voy._vocSecondsOffset = _voy._RTVNum - _voy._musicStartTime;
+ _soundManager.stopVOCPlay();
+ _bVoy->getBoltGroup(0x900);
+ break;
+
+ case EVTYPE_COMPUTER:
+ _voy.reviewComputerEvent(eventIndex);
+
+ _voy._vocSecondsOffset = _voy._RTVNum - _voy._musicStartTime;
+ _soundManager.stopVOCPlay();
+ _bVoy->getBoltGroup(0x900);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ _graphicsManager._fontPtr->_curFont = _bVoy->boltEntry(0x101)._fontResource;
+
+ (*_graphicsManager._vPort)->fillPic(0);
+ flipPageAndWait();
+ _bVoy->freeBoltGroup(0x900);
+}
+
+void VoyeurEngine::doGossip() {
+ _graphicsManager.resetPalette();
+ _graphicsManager.screenReset();
+
+ if (!_bVoy->getBoltGroup(0x300))
+ return;
+
+ // Load the gossip animation
+ RL2Decoder decoder;
+ decoder.loadFile("a2050100.rl2", false);
+ decoder.start();
+
+ // Get the resource data for the first gossip video
+ PictureResource *bgPic = _bVoy->boltEntry(0x300)._picResource;
+ CMapResource *pal = _bVoy->boltEntry(0x301)._cMapResource;
+ pal->startFade();
+
+ // Transfer initial background to video decoder
+ PictureResource videoFrame(decoder.getVideoTrack()->getBackSurface());
+ bgPic->_bounds.moveTo(0, 0);
+ _graphicsManager.sDrawPic(bgPic, &videoFrame, Common::Point(0, 0));
+
+ byte *frameNumsP = _bVoy->memberAddr(0x309);
+ byte *posP = _bVoy->boltEntry(0x30A)._data;
+
+ // Play the initial gossip video
+ decoder.play(this, 0x302, frameNumsP, posP);
+ decoder.close();
+
+ // Reset the palette and clear the screen
+ _graphicsManager.resetPalette();
+ _graphicsManager.screenReset();
+
+ // Play interview video
+ RL2Decoder decoder2;
+ decoder2.loadFile("a2110100.rl2", true);
+ decoder2.start();
+
+ _eventsManager.getMouseInfo();
+ decoder2.play(this);
+ decoder2.close();
+
+ _bVoy->freeBoltGroup(0x300);
+ _graphicsManager.screenReset();
+}
+
+void VoyeurEngine::doTapePlaying() {
+ if (!_bVoy->getBoltGroup(0xA00))
+ return;
+
+ _eventsManager.getMouseInfo();
+ _graphicsManager._backColors = _bVoy->boltEntry(0xA01)._cMapResource;
+ _graphicsManager._backgroundPage = _bVoy->boltEntry(0xA00)._picResource;
+ PictureResource *pic = _bVoy->boltEntry(0xA02)._picResource;
+ VInitCycleResource *cycle = _bVoy->boltEntry(0xA05)._vInitCycleResource;
+
+ (*_graphicsManager._vPort)->setupViewPort(_graphicsManager._backgroundPage);
+ _graphicsManager.sDrawPic(pic, *_graphicsManager._vPort, Common::Point(57, 30));
+ _graphicsManager._backColors->startFade();
+ flipPageAndWaitForFade();
+
+ cycle->vStartCycle();
+
+ _soundManager.startVOCPlay("vcr.voc");
+ while (!shouldQuit() && !_eventsManager._mouseClicked && _soundManager.getVOCStatus()) {
+ _eventsManager.delayClick(2);
+ }
+
+ _soundManager.stopVOCPlay();
+ cycle->vStopCycle();
+ _bVoy->freeBoltGroup(0xA00);
+}
+
+bool VoyeurEngine::checkForMurder() {
+ int v = _controlPtr->_state->_victimMurderIndex;
+
+ for (int idx = 0; idx < _voy._eventCount; ++idx) {
+ VoyeurEvent &evt = _voy._events[idx];
+
+ if (evt._type == EVTYPE_VIDEO) {
+ switch (_controlPtr->_state->_victimIndex) {
+ case 1:
+ if (evt._audioVideoId == 41 && evt._computerOn <= 15 &&
+ (evt._computerOff + evt._computerOn) >= 16) {
+ _controlPtr->_state->_victimMurderIndex = 1;
+ }
+ break;
+
+ case 2:
+ if (evt._audioVideoId == 53 && evt._computerOn <= 19 &&
+ (evt._computerOff + evt._computerOn) >= 21) {
+ _controlPtr->_state->_victimMurderIndex = 2;
+ }
+ break;
+
+ case 3:
+ if (evt._audioVideoId == 50 && evt._computerOn <= 28 &&
+ (evt._computerOff + evt._computerOn) >= 29) {
+ _controlPtr->_state->_victimMurderIndex = 3;
+ }
+ break;
+
+ case 4:
+ if (evt._audioVideoId == 43 && evt._computerOn <= 10 &&
+ (evt._computerOff + evt._computerOn) >= 14) {
+ _controlPtr->_state->_victimMurderIndex = 4;
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ if (_controlPtr->_state->_victimMurderIndex == _controlPtr->_state->_victimIndex) {
+ _voy._videoEventId = idx;
+ return true;
+ }
+ }
+
+ _controlPtr->_state->_victimMurderIndex = v;
+ _voy._videoEventId = -1;
+ return false;
+}
+
+bool VoyeurEngine::checkForIncriminate() {
+ _voy._incriminatedVictimNumber = 0;
+
+ for (int idx = 0; idx < _voy._eventCount; ++idx) {
+ VoyeurEvent &evt = _voy._events[idx];
+
+ if (evt._type == EVTYPE_VIDEO) {
+ if (evt._audioVideoId == 44 && evt._computerOn <= 40 &&
+ (evt._computerOff + evt._computerOn) >= 70) {
+ _voy._incriminatedVictimNumber = 1;
+ }
+
+ if (evt._audioVideoId == 44 && evt._computerOn <= 79 &&
+ (evt._computerOff + evt._computerOn) >= 129) {
+ _voy._incriminatedVictimNumber = 1;
+ }
+
+ if (evt._audioVideoId == 20 && evt._computerOn <= 28 &&
+ (evt._computerOff + evt._computerOn) >= 45) {
+ _voy._incriminatedVictimNumber = 2;
+ }
+
+ if (evt._audioVideoId == 35 && evt._computerOn <= 17 &&
+ (evt._computerOff + evt._computerOn) >= 36) {
+ _voy._incriminatedVictimNumber = 3;
+ }
+
+ if (evt._audioVideoId == 30 && evt._computerOn <= 80 &&
+ (evt._computerOff + evt._computerOn) >= 139) {
+ _voy._incriminatedVictimNumber = 4;
+ }
+ }
+
+ if (_voy._incriminatedVictimNumber) {
+ _controlPtr->_state->_victimMurderIndex = 88;
+ _voy._videoEventId = idx;
+ return true;
+ }
+ }
+
+ _voy._videoEventId = -1;
+ return false;
+}
+
+void VoyeurEngine::playAVideoEvent(int eventIndex) {
+ VoyeurEvent &evt = _voy._events[eventIndex];
+ _audioVideoId = evt._audioVideoId;
+ _voy._vocSecondsOffset = evt._computerOn;
+ _eventsManager._videoDead = evt._dead;
+ _voy._eventFlags &= ~EVTFLAG_TIME_DISABLED;
+
+ playAVideoDuration(_audioVideoId, evt._computerOff);
+
+ _voy._eventFlags |= EVTFLAG_TIME_DISABLED;
+ if (_eventsManager._videoDead != -1) {
+ _bVoy->freeBoltGroup(0xE00);
+ _eventsManager._videoDead = -1;
+ flipPageAndWait();
+ _eventsManager._videoDead = -1;
+ }
+
+ _audioVideoId = -1;
+ if (_eventsManager._videoDead != -1) {
+ _bVoy->freeBoltGroup(0xE00);
+ _eventsManager._videoDead = -1;
+ flipPageAndWait();
+ }
+}
+
+int VoyeurEngine::getChooseButton() {
+ int prevIndex = -2;
+ Common::Array<RectEntry> &hotspots = _bVoy->boltEntry(_playStampGroupId
+ + 6)._rectResource->_entries;
+ int selectedIndex = -1;
+
+ (*_graphicsManager._vPort)->setupViewPort(_graphicsManager._backgroundPage);
+ _graphicsManager._backColors->_steps = 0;
+ _graphicsManager._backColors->startFade();
+ flipPageAndWait();
+
+ _voy._viewBounds = _bVoy->boltEntry(_playStampGroupId + 7)._rectResource;
+ PictureResource *cursorPic = _bVoy->boltEntry(_playStampGroupId + 2)._picResource;
+
+ do {
+ do {
+ if (_currentVocId != -1 && !_soundManager.getVOCStatus())
+ _soundManager.startVOCPlay(_currentVocId);
+
+ _eventsManager.getMouseInfo();
+ selectedIndex = -1;
+ Common::Point pt = _eventsManager.getMousePos();
+
+ for (uint idx = 0; idx < hotspots.size(); ++idx) {
+ if (hotspots[idx].contains(pt)) {
+ if (!_voy._victimMurdered || ((int)idx + 1) != _controlPtr->_state->_victimIndex) {
+ selectedIndex = idx;
+ if (selectedIndex != prevIndex) {
+ PictureResource *btnPic = _bVoy->boltEntry(_playStampGroupId + 8 + idx)._picResource;
+ _graphicsManager.sDrawPic(btnPic, *_graphicsManager._vPort,
+ Common::Point(106, 200));
+
+ cursorPic = _bVoy->boltEntry(_playStampGroupId + 4)._picResource;
+ }
+ }
+ }
+ }
+
+ if (selectedIndex == -1) {
+ cursorPic = _bVoy->boltEntry(_playStampGroupId + 2)._picResource;
+ PictureResource *btnPic = _bVoy->boltEntry(_playStampGroupId + 12)._picResource;
+ _graphicsManager.sDrawPic(btnPic, *_graphicsManager._vPort,
+ Common::Point(106, 200));
+ }
+
+ _graphicsManager.sDrawPic(cursorPic, *_graphicsManager._vPort,
+ Common::Point(pt.x + 13, pt.y - 12));
+
+ flipPageAndWait();
+ } while (!shouldQuit() && !_eventsManager._mouseClicked);
+ } while (!shouldQuit() && selectedIndex == -1 && !_eventsManager._rightClick);
+
+ return selectedIndex;
+}
+
+void VoyeurEngine::makeViewFinder() {
+ _graphicsManager._backgroundPage = _bVoy->boltEntry(0x103)._picResource;
+ _graphicsManager.sDrawPic(_graphicsManager._backgroundPage,
+ *_graphicsManager._vPort, Common::Point(0, 0));
+ CMapResource *pal = _bVoy->boltEntry(0x104)._cMapResource;
+
+ int palOffset = 0;
+ switch (_voy._transitionId) {
+ case 1:
+ case 2:
+ case 5:
+ case 6:
+ case 7:
+ case 8:
+ case 9:
+ case 17:
+ palOffset = 0;
+ break;
+ case 3:
+ palOffset = 1;
+ break;
+ case 4:
+ case 10:
+ case 11:
+ case 12:
+ case 13:
+ case 14:
+ case 15:
+ case 16:
+ palOffset = 2;
+ break;
+ default:
+ break;
+ }
+
+ (*_graphicsManager._vPort)->drawIfaceTime();
+ doTimeBar(true);
+ pal->startFade();
+
+ flipPageAndWaitForFade();
+
+ _graphicsManager.setColor(241, 105, 105, 105);
+ _graphicsManager.setColor(242, 105, 105, 105);
+ _graphicsManager.setColor(243, 105, 105, 105);
+ _graphicsManager.setColor(palOffset + 241, 219, 235, 235);
+
+ _eventsManager._intPtr._hasPalette = true;
+}
+
+void VoyeurEngine::makeViewFinderP() {
+ _graphicsManager.screenReset();
+}
+
+void VoyeurEngine::initIFace() {
+ int playStamp1 = _playStampGroupId;
+ switch (_voy._transitionId) {
+ case 0:
+ break;
+ case 1:
+ case 2:
+ case 5:
+ case 6:
+ case 7:
+ case 8:
+ case 9:
+ _playStampGroupId = 0xB00;
+ break;
+ case 3:
+ _playStampGroupId = 0xC00;
+ break;
+ default:
+ _playStampGroupId = 0xD00;
+ break;
+ }
+ if (playStamp1 != -1)
+ _bVoy->freeBoltGroup(playStamp1, true);
+
+ _bVoy->getBoltGroup(_playStampGroupId);
+ CMapResource *pal = _bVoy->boltEntry(_playStampGroupId + 2)._cMapResource;
+ pal->startFade();
+
+ // Start the mansion off centered
+ _mansionViewPos = Common::Point((MANSION_MAX_X - MANSION_VIEW_WIDTH) / 2,
+ (MANSION_MAX_Y - MANSION_VIEW_HEIGHT) / 2);
+ doScroll(_mansionViewPos);
+
+ _voy._viewBounds = _bVoy->boltEntry(_playStampGroupId)._rectResource;
+
+ // Show the cursor using ScummVM functionality
+ _eventsManager.showCursor();
+
+ // Note: the original did two loops to preload members here, which is
+ // redundant for ScummVM, since computers are faster these days, and
+ // getting resources as needed will be fast enough.
+}
+
+void VoyeurEngine::doScroll(const Common::Point &pt) {
+ Common::Rect clipRect(72, 47, 72 + 240, 47 + 148);
+ (*_graphicsManager._vPort)->setupViewPort(NULL, &clipRect);
+
+ int base = 0;
+ switch (_voy._transitionId) {
+ case 0:
+ break;
+ case 1:
+ case 2:
+ case 5:
+ case 6:
+ case 7:
+ case 8:
+ case 9:
+ base = 0xB00;
+ break;
+ case 3:
+ base = 0xC00;
+ break;
+ default:
+ base = 0xD00;
+ }
+
+ if (base) {
+ PictureResource *pic = _bVoy->boltEntry(base + 3)._picResource;
+ _graphicsManager.sDrawPic(pic, *_graphicsManager._vPort, Common::Point(784 - pt.x - 712, 150 - pt.y - 104));
+ pic = _bVoy->boltEntry(base + 4)._picResource;
+ _graphicsManager.sDrawPic(pic, *_graphicsManager._vPort, Common::Point(784 - pt.x - 712, 150 - pt.y - 44));
+ pic = _bVoy->boltEntry(base + 5)._picResource;
+ _graphicsManager.sDrawPic(pic, *_graphicsManager._vPort, Common::Point(784 - pt.x - 712, 150 - pt.y + 16));
+ pic = _bVoy->boltEntry(base + 6)._picResource;
+ _graphicsManager.sDrawPic(pic, *_graphicsManager._vPort, Common::Point(784 - pt.x - 712, 150 - pt.y + 76));
+ pic = _bVoy->boltEntry(base + 7)._picResource;
+ _graphicsManager.sDrawPic(pic, *_graphicsManager._vPort, Common::Point(784 - pt.x - 712, 150 - pt.y + 136));
+ }
+
+ (*_graphicsManager._vPort)->setupViewPort(NULL);
+}
+
+void VoyeurEngine::checkTransition() {
+ Common::String time, day;
+
+ if (_voy._transitionId != _checkTransitionId) {
+ // Get the day
+ day = getDayName();
+
+ // Only proceed if a valid day string was returned
+ if (!day.empty()) {
+ _graphicsManager.fadeDownICF(6);
+
+ // Get the time of day string
+ time = getTimeOfDay();
+
+ // Show a transition card with the day and time, and wait
+ doTransitionCard(day, time);
+ _eventsManager.delayClick(180);
+ }
+
+ _checkTransitionId = _voy._transitionId;
+ }
+}
+
+Common::String VoyeurEngine::getDayName() {
+ switch (_voy._transitionId) {
+ case 0:
+ return "";
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ return SATURDAY;
+ case 17:
+ return MONDAY;
+ default:
+ return SUNDAY;
+ }
+}
+
+Common::String VoyeurEngine::getTimeOfDay() {
+ if (_voy._transitionId == 17)
+ return "";
+
+ return Common::String::format("%d:%02d%s", _gameHour, _gameMinute, _voy._isAM ? AM : PM);
+}
+
+int VoyeurEngine::doComputerText(int maxLen) {
+ FontInfoResource &font = *_graphicsManager._fontPtr;
+ int totalChars = 0;
+
+ font._curFont = _bVoy->boltEntry(0x4910)._fontResource;
+ font._foreColor = 129;
+ font._fontSaveBack = false;
+ font._fontFlags = 0;
+ if (_voy._vocSecondsOffset > 60)
+ _voy._vocSecondsOffset = 0;
+
+ if (_voy._RTVNum > _voy._computerTimeMax && maxLen == 9999) {
+ if (_currentVocId != -1)
+ _soundManager.startVOCPlay(_currentVocId);
+ font._justify = ALIGN_LEFT;
+ font._justifyWidth = 384;
+ font._justifyHeight = 100;
+ font._pos = Common::Point(128, 100);
+ (*_graphicsManager._vPort)->drawText(END_OF_MESSAGE);
+ } else if (_voy._RTVNum < _voy._computerTimeMin && maxLen == 9999) {
+ if (_currentVocId != -1)
+ _soundManager.startVOCPlay(_currentVocId);
+ font._justify = ALIGN_LEFT;
+ font._justifyWidth = 384;
+ font._justifyHeight = 100;
+ font._pos = Common::Point(120, 100);
+ (*_graphicsManager._vPort)->drawText(START_OF_MESSAGE);
+ } else {
+ char *msg = (char *)_bVoy->memberAddr(0x4900 + _voy._computerTextId);
+ font._pos = Common::Point(96, 60);
+
+ bool showEnd = true;
+ int yp = 60;
+ do {
+ if (_currentVocId != -1 && !_soundManager.getVOCStatus()) {
+ if (_voy._vocSecondsOffset > 60)
+ _voy._vocSecondsOffset = 0;
+ _soundManager.startVOCPlay(_currentVocId);
+ }
+
+ char c = *msg++;
+ if (c == '\0') {
+ if (showEnd) {
+ _eventsManager.delay(90);
+ _graphicsManager._drawPtr->_pos = Common::Point(96, 54);
+ _graphicsManager._drawPtr->_penColor = 254;
+ (*_graphicsManager._vPort)->sFillBox(196, 124);
+ _graphicsManager._fontPtr->_justify = ALIGN_LEFT;
+ _graphicsManager._fontPtr->_justifyWidth = 384;
+ _graphicsManager._fontPtr->_justifyHeight = 100;
+ _graphicsManager._fontPtr->_pos = Common::Point(128, 100);
+ (*_graphicsManager._vPort)->drawText(END_OF_MESSAGE);
+ }
+ break;
+ }
+
+ if (c == '~' || c == '^') {
+ if (c == '^') {
+ yp += 10;
+ } else {
+ _eventsManager.delay(90);
+ _graphicsManager._drawPtr->_pos = Common::Point(96, 54);
+ _graphicsManager._drawPtr->_penColor = 255;
+ (*_graphicsManager._vPort)->sFillBox(196, 124);
+ yp = 60;
+ }
+
+ _graphicsManager._fontPtr->_pos = Common::Point(96, yp);
+ } else if (c == '_') {
+ showEnd = false;
+ } else {
+ _graphicsManager._fontPtr->_justify = ALIGN_LEFT;
+ _graphicsManager._fontPtr->_justifyWidth = 0;
+ _graphicsManager._fontPtr->_justifyHeight = 0;
+ (*_graphicsManager._vPort)->drawText(Common::String(c));
+ _eventsManager.delay(4);
+ }
+
+ flipPageAndWait();
+ _eventsManager.getMouseInfo();
+ ++totalChars;
+
+ } while (!shouldQuit() && !_eventsManager._mouseClicked && totalChars < maxLen);
+
+ _voy._computerTimeMax = 0;
+ }
+
+ flipPageAndWait();
+
+ _graphicsManager._fontPtr->_curFont = _bVoy->boltEntry(0x101)._fontResource;
+ return totalChars;
+}
+
+void VoyeurEngine::getComputerBrush() {
+ if (_bVoy->getBoltGroup(0x4900)) {
+ PictureResource *pic = _bVoy->boltEntry(0x490E)._picResource;
+ int xp = (384 - pic->_bounds.width()) / 2;
+ int yp = (240 - pic->_bounds.height()) / 2 - 4;
+
+ (*_graphicsManager._vPort)->drawPicPerm(pic, Common::Point(xp, yp));
+
+ CMapResource *pal = _bVoy->boltEntry(0x490F)._cMapResource;
+ pal->startFade();
+ }
+}
+
+void VoyeurEngine::doTimeBar(bool force) {
+ flashTimeBar();
+
+ if ((force || _timeBarVal != _voy._RTVNum) && _voy._RTVLimit > 0) {
+ if (_voy._RTVNum > _voy._RTVLimit || _voy._RTVNum < 0)
+ _voy._RTVNum = _voy._RTVLimit - 1;
+
+ _timeBarVal = _voy._RTVNum;
+ int height = ((_voy._RTVLimit - _voy._RTVNum) * 59) / _voy._RTVLimit;
+ int fullHeight = MAX(151 - height, 93);
+
+ _graphicsManager._drawPtr->_penColor = 134;
+ _graphicsManager._drawPtr->_pos = Common::Point(39, 92);
+
+ (*_graphicsManager._vPort)->sFillBox(6, fullHeight - 92);
+ if (height > 0) {
+ _graphicsManager.setColor(215, 238, 238, 238);
+ _eventsManager._intPtr._hasPalette = true;
+
+ _graphicsManager._drawPtr->_penColor = 215;
+ _graphicsManager._drawPtr->_pos = Common::Point(39, fullHeight);
+ (*_graphicsManager._vPort)->sFillBox(6, height);
+ }
+ }
+}
+
+void VoyeurEngine::flashTimeBar() {
+ if (_voy._RTVNum >= 0 && (_voy._RTVLimit - _voy._RTVNum) < 11 &&
+ (_eventsManager._intPtr._flashTimer >= (_flashTimeVal + 15) ||
+ _eventsManager._intPtr._flashTimer < _flashTimeVal)) {
+ // Within camera low power range
+ _flashTimeVal = _eventsManager._intPtr._flashTimer;
+
+ if (_flashTimeFlag)
+ _graphicsManager.setColor(240, 220, 20, 20);
+ else
+ _graphicsManager.setColor(240, 220, 220, 220);
+
+ _eventsManager._intPtr._hasPalette = true;
+ _flashTimeFlag = !_flashTimeFlag;
+ }
+}
+
+void VoyeurEngine::checkPhoneCall() {
+ if ((_voy._RTVLimit - _voy._RTVNum) >= 36 && _voy._totalPhoneCalls < 5 &&
+ _currentVocId <= 151 && _currentVocId > 146) {
+ if ((_voy._switchBGNum < _checkPhoneVal || _checkPhoneVal > 180) &&
+ !_soundManager.getVOCStatus()) {
+ int soundIndex;
+ do {
+ soundIndex = getRandomNumber(4);
+ } while (_voy._phoneCallsReceived[soundIndex]);
+ _currentVocId = 154 + soundIndex;
+
+ _soundManager.stopVOCPlay();
+ _soundManager.startVOCPlay(_currentVocId);
+ _checkPhoneVal = _voy._switchBGNum;
+ ++_voy._phoneCallsReceived[soundIndex];
+ ++_voy._totalPhoneCalls;
+ }
+ }
+}
+
+void VoyeurEngine::doEvidDisplay(int evidId, int eventId) {
+ _eventsManager.getMouseInfo();
+ flipPageAndWait();
+
+ if (_currentVocId != -1) {
+ _voy._vocSecondsOffset = _voy._RTVNum - _voy._musicStartTime;
+ _soundManager.stopVOCPlay();
+ }
+
+ _bVoy->getBoltGroup(_voy._boltGroupId2);
+ PictureResource *pic = _bVoy->boltEntry(_voy._boltGroupId2 + evidId * 2)._picResource;
+ _graphicsManager.sDrawPic(pic, *_graphicsManager._vPort, Common::Point(
+ (384 - pic->_bounds.width()) / 2, (240 - pic->_bounds.height()) / 2));
+ _bVoy->freeBoltMember(_voy._boltGroupId2 + evidId * 2);
+
+ CMapResource *pal = _bVoy->boltEntry(_voy._boltGroupId2 + evidId * 2 + 1)._cMapResource;
+ pal->startFade();
+
+ while (!shouldQuit() && (_eventsManager._fadeStatus & 1))
+ _eventsManager.delay(1);
+ _bVoy->freeBoltMember(_voy._boltGroupId2 + evidId * 2 + 1);
+
+ Common::Array<RectEntry> &hotspots = _bVoy->boltEntry(_playStampGroupId + 4)._rectResource->_entries;
+ int count = hotspots[evidId]._count;
+
+ if (count > 0) {
+ for (int idx = 1; idx <= count; ++idx) {
+ _voy._evPicPtrs[idx - 1] = _bVoy->boltEntry(_voy._boltGroupId2 +
+ (evidId + idx) * 2)._picResource;
+ _voy._evCmPtrs[idx - 1] = _bVoy->boltEntry(_voy._boltGroupId2 +
+ (evidId + idx) * 2 + 1)._cMapResource;
+ }
+ }
+
+ flipPageAndWait();
+ _eventsManager.stopEvidDim();
+
+ if (eventId == 999)
+ _voy.addEvidEventStart(evidId);
+
+ _eventsManager.getMouseInfo();
+
+ int arrIndex = 0;
+ int evidIdx = evidId;
+
+ while (!shouldQuit() && !_eventsManager._rightClick) {
+ _voyeurArea = AREA_EVIDENCE;
+
+ if (_currentVocId != -1 && !_soundManager.getVOCStatus()) {
+ if (_voy._vocSecondsOffset > 60)
+ _voy._vocSecondsOffset = 0;
+
+ _soundManager.startVOCPlay(_currentVocId);
+ }
+
+ _eventsManager.delayClick(600);
+ if (_eventsManager._rightClick)
+ break;
+ if (count == 0 || evidIdx >= eventId)
+ continue;
+
+ PictureResource *pic = _voy._evPicPtrs[arrIndex];
+ _graphicsManager.sDrawPic(pic, *_graphicsManager._vPort,
+ Common::Point((384 - pic->_bounds.width()) / 2,
+ (240 - pic->_bounds.height()) / 2));
+ _voy._evCmPtrs[arrIndex]->startFade();
+ while (!shouldQuit() && (_eventsManager._fadeStatus & 1))
+ _eventsManager.delay(1);
+
+ flipPageAndWait();
+ _eventsManager.delay(6);
+
+ ++evidIdx;
+ ++arrIndex;
+ --count;
+ }
+
+ if (eventId == 999)
+ _voy.addEvidEventEnd(evidIdx);
+
+ for (int idx = 1; idx <= hotspots[evidId]._count; ++idx) {
+ _bVoy->freeBoltMember(_voy._boltGroupId2 + (evidId + idx) * 2);
+ _bVoy->freeBoltMember(_voy._boltGroupId2 + (evidId + idx) * 2 + 1);
+ }
+}
+
+} // End of namespace Voyeur
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-12 22:38:38 +0000