Initial commit

engines/nancy/action/overlay.cpp

@@ -0,0 +1,441 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "engines/nancy/nancy.h"
+#include "engines/nancy/sound.h"
+#include "engines/nancy/resource.h"
+#include "engines/nancy/util.h"
+#include "engines/nancy/input.h"
+#include "engines/nancy/cursor.h"
+#include "engines/nancy/graphics.h"
+
+#include "engines/nancy/action/overlay.h"
+
+#include "engines/nancy/state/scene.h"
+
+#include "common/serializer.h"
+
+namespace Nancy {
+namespace Action {
+
+void Overlay::init() {
+	// Autotext overlays need special handling when blitting
+	if (_imageName.baseName().hasPrefix("USE_")) {
+		_usesAutotext = true;
+	}
+
+	g_nancy->_resource->loadImage(_imageName, _fullSurface);
+
+	_currentFrame = _firstFrame;
+
+	RenderObject::init();
+}
+
+void Overlay::handleInput(NancyInput &input) {
+	// For no apparent reason, from nancy3 on the original engine handles Overlay input as a special case,
+	// rather than simply set the general hotspot inside the ActionRecord struct. Special cases
+	// (a.k.a puzzle types) get handled before regular ActionRecords, which means an Overlay
+	// must take precedence when handling the mouse. Thus, out ActionManager class first iterates
+	// through all records and calls their handleInput() function just to make sure this special
+	// case is handled. This fixes nancy3 scene 7081.
+	if (g_nancy->getGameType() >= kGameTypeNancy3) {
+		if (_hasHotspot) {
+			if (NancySceneState.getViewport().convertViewportToScreen(_hotspot).contains(input.mousePos)) {
+				g_nancy->_cursor->setCursorType(CursorManager::kHotspot);
+
+				if (input.input & NancyInput::kLeftMouseButtonUp) {
+					_state = kActionTrigger;
+
+					// Make sure nothing else gets triggered
+					// This is nancy3 and up, since we actually want to trigger other records in nancy2 (e.g. scene 2541)
+					input.eatMouseInput();
+				}
+			}
+		}
+	}
+}
+
+void Overlay::readData(Common::SeekableReadStream &stream) {
+	Common::Serializer ser(&stream, nullptr);
+	ser.setVersion(g_nancy->getGameType());
+
+	uint16 numSrcRects = 0;
+
+	readFilename(ser, _imageName);
+	ser.skip(2); // VIDEO_STOP_RENDERING or VIDEO_CONTINUE_RENDERING
+	ser.syncAsUint16LE(_transparency);
+	ser.syncAsUint16LE(_hasSceneChange);
+	ser.syncAsUint16LE(_enableHotspot, kGameTypeNancy2, kGameTypeNancy2);
+	ser.syncAsUint16LE(_z, kGameTypeNancy2);
+	ser.syncAsUint16LE(_overlayType, kGameTypeNancy2);
+	ser.syncAsUint16LE(numSrcRects, kGameTypeNancy2);
+
+	ser.syncAsUint16LE(_playDirection);
+	ser.syncAsUint16LE(_loop);
+	ser.syncAsUint16LE(_firstFrame);
+	ser.syncAsUint16LE(_loopFirstFrame);
+	ser.syncAsUint16LE(_loopLastFrame);
+	uint16 framesPerSec = stream.readUint16LE();
+
+	// Avoid divide by 0
+	if (framesPerSec) {
+		_frameTime = Common::Rational(1000, framesPerSec).toInt();
+	}
+
+	ser.syncAsUint16LE(_z, kGameTypeNancy1, kGameTypeNancy1);
+
+	if (ser.getVersion() > kGameTypeNancy2) {
+		if (_overlayType == kPlayOverlayStatic) {
+			_enableHotspot = (_hasSceneChange == kPlayOverlaySceneChange) ? kPlayOverlayWithHotspot : kPlayOverlayNoHotspot;
+		}
+	}
+
+	if (_isInterruptible) {
+			ser.syncAsSint16LE(_interruptCondition.label);
+			ser.syncAsUint16LE(_interruptCondition.flag);
+		} else {
+			_interruptCondition.label = kEvNoEvent;
+			_interruptCondition.flag = g_nancy->_false;
+		}
+
+	_sceneChange.readData(stream);
+	_flagsOnTrigger.readData(stream);
+	_sound.readNormal(stream);
+
+	uint numViewportFrames = stream.readUint16LE();
+
+	if (_overlayType == kPlayOverlayAnimated) {
+		numSrcRects = _loopLastFrame - _firstFrame + 1;
+	}
+
+	readRectArray(ser, _srcRects, numSrcRects);
+
+	_blitDescriptions.resize(numViewportFrames);
+	for (auto &bm : _blitDescriptions) {
+		bm.readData(stream, ser.getVersion() >= kGameTypeNancy2);
+	}
+}
+
+void Overlay::execute() {
+	uint32 _currentFrameTime = g_nancy->getTotalPlayTime();
+	switch (_state) {
+	case kBegin:
+		init();
+		registerGraphics();
+		g_nancy->_sound->loadSound(_sound);
+		g_nancy->_sound->playSound(_sound);
+		_state = kRun;
+		// fall through
+	case kRun: {
+		// Check the timer to see if we need to draw the next animation frame
+		if (_overlayType == kPlayOverlayAnimated && _nextFrameTime <= _currentFrameTime) {
+			bool shouldTrigger = false;
+
+			// Check for interrupt flag
+			if (NancySceneState.getEventFlag(_interruptCondition)) {
+				shouldTrigger = true;
+			}
+
+			// Wait until sound stops (if present)
+			if (!g_nancy->_sound->isSoundPlaying(_sound)) {
+				// Check if we're at the last frame
+				if ((_currentFrame == _loopLastFrame) && (_playDirection == kPlayOverlayForward) && (_loop == kPlayOverlayOnce)) {
+					shouldTrigger = true;
+				} else if ((_currentFrame == _loopFirstFrame) && (_playDirection == kPlayOverlayReverse) && (_loop == kPlayOverlayOnce)) {
+					shouldTrigger = true;
+				}
+			}
+
+			if (shouldTrigger) {
+				_state = kActionTrigger;
+			} else {
+				// Check if we've moved the viewport
+				uint16 newFrame = NancySceneState.getSceneInfo().frameID;
+
+				if (_currentViewportFrame != newFrame) {
+					_currentViewportFrame = newFrame;
+
+					setVisible(false);
+					_hasHotspot = false;
+
+					for (uint i = 0; i < _blitDescriptions.size(); ++i) {
+						if (_currentViewportFrame == _blitDescriptions[i].frameID) {
+							moveTo(_blitDescriptions[i].dest);
+							setVisible(true);
+
+							if (_enableHotspot == kPlayOverlayWithHotspot) {
+								_hotspot = _screenPosition;
+								_hasHotspot = true;
+							}
+
+							break;
+						}
+					}
+				}
+
+				uint16 frameDiff = 1;
+				uint16 nextFrame = _currentFrame;
+
+				if (_nextFrameTime == 0) {
+					_nextFrameTime = _currentFrameTime + _frameTime;
+				} else {
+					uint32 timeDiff = _currentFrameTime - _nextFrameTime;
+					frameDiff = timeDiff / MAX<uint32>(_frameTime, 1); // Fix for nancy2 scene 1090, where _frameTime is 0
+					_nextFrameTime += _frameTime * frameDiff;
+				}
+
+				if (_playDirection == kPlayOverlayReverse) {
+					if (nextFrame - frameDiff < _loopFirstFrame) {
+						// We keep looping if sound is present (nancy1/2 only)
+						if (_loop == kPlayOverlayLoop || (_sound.name != "NO SOUND" && g_nancy->getGameType() <= kGameTypeNancy2)) {
+							nextFrame = _loopLastFrame - (frameDiff % (_loopLastFrame - _loopFirstFrame + 1));
+						}
+					} else {
+						nextFrame -= frameDiff;
+					}
+				} else {
+					if (nextFrame + frameDiff > _loopLastFrame) {
+						if (_loop == kPlayOverlayLoop || (_sound.name != "NO SOUND" && g_nancy->getGameType() <= kGameTypeNancy2)) {
+							nextFrame = _loopFirstFrame + (frameDiff % (_loopLastFrame - _loopFirstFrame + 1));
+						}
+					} else {
+						nextFrame += frameDiff;
+					}
+				}
+
+				// Workaround for:
+				// - the arcade machine in nancy1 scene 833
+				// - the fireplace in nancy2 scene 2491, where one of the rects is invalid.
+				// - the ball thing in nancy2 scene 1562, where one of the rects is twice as tall as it should be
+				// Assumes all rects in a single animation have the same dimensions
+				Common::Rect srcRect = _srcRects[nextFrame];
+				if (!srcRect.isValidRect() || srcRect.width() != _srcRects[0].width() || srcRect.height() != _srcRects[0].height()) {
+					srcRect.setWidth(_srcRects[0].width());
+					srcRect.setHeight(_srcRects[0].height());
+				}
+
+				_drawSurface.create(_fullSurface, srcRect);
+				setTransparent(_transparency == kPlayOverlayTransparent);
+
+				_currentFrame = nextFrame;
+				_needsRedraw = true;
+			}
+		} else {
+			// Check if we've moved the viewport
+			uint16 newFrame = NancySceneState.getSceneInfo().frameID;
+
+			if (_currentViewportFrame != newFrame) {
+				_currentViewportFrame = newFrame;
+
+				setVisible(false);
+				_hasHotspot = false;
+
+				// First, check if there's more than one blit description for the current viewport frame.
+				// This happens in nancy7 scene 3600
+				Common::Array<uint16> blitsForThisFrame;
+				Common::Rect destRect;
+				for (uint i = 0; i < _blitDescriptions.size(); ++i) {
+					if (_currentViewportFrame == _blitDescriptions[i].frameID) {
+						blitsForThisFrame.push_back(i);
+						if (destRect.isEmpty()) {
+							destRect = _blitDescriptions[i].dest;
+						} else {
+							destRect.extend(_blitDescriptions[i].dest);
+						}
+					}
+				}
+
+				if (_overlayType == kPlayOverlayStatic && blitsForThisFrame.size()) {
+					moveTo(destRect);
+					setVisible(true);
+
+					if (blitsForThisFrame.size() != 1) {
+						_drawSurface.create(destRect.width(), destRect.height(), _fullSurface.format);
+						setTransparent(true); // Force transparency. This shouldn't break anything. Hopefully.
+						_drawSurface.clear(_drawSurface.getTransparentColor());
+					}
+
+					for (uint i = 0; i < blitsForThisFrame.size(); ++i) {
+						// In static mode every "animation" frame corresponds to a viewport frame
+						// Static mode overlays use both the general source rects (_srcRects),
+						// and the ones inside the blit description struct corresponding to the current scene background.
+
+						// BlitDescriptions contain the id of the source rect to actually use
+						Common::Rect srcRect = _srcRects[_blitDescriptions[blitsForThisFrame[i]].staticRectID];
+						Common::Rect staticBounds = _blitDescriptions[blitsForThisFrame[i]].src;
+
+						if (_usesAutotext) {
+							// For autotext overlays, the srcRect is junk data
+							srcRect = staticBounds;
+						} else {
+							// Lastly, the general source rect we just got may also be completely empty (nancy5 scenes 2056, 2057),
+							// or have coordinates other than (0, 0) (nancy3 scene 3070, nancy5 scene 2000). Presumably,
+							// the general source rect was used for blitting to an (optional) intermediate surface, while the ones
+							// inside the blit description below were used for blitting from that intermediate surface to the screen.
+							// We can achieve the same results by doung the calculations below
+							srcRect.translate(staticBounds.left, staticBounds.top);
+
+							if (srcRect.isEmpty()) {
+								srcRect.setWidth(staticBounds.width());
+								srcRect.setHeight(staticBounds.height());
+							} else {
+								// Grab whichever dimensions are smaller. Fixes the book in nancy5 scene 3000
+								srcRect.setWidth(MIN<int>(staticBounds.width(), srcRect.width()));
+								srcRect.setHeight(MIN<int>(staticBounds.height(), srcRect.height()));
+							}
+						}
+
+						// Make sure the srcRect doesn't extend beyond the image.
+						// This fixes nancy7 scene 4228
+						srcRect.clip(_fullSurface.getBounds());
+
+						if (blitsForThisFrame.size() == 1) {
+							_drawSurface.create(_fullSurface, srcRect);
+							setTransparent(_transparency == kPlayOverlayTransparent);
+						} else {
+							Common::Rect d = _blitDescriptions[blitsForThisFrame[i]].dest;
+							d.translate(-destRect.left, -destRect.top);
+							_drawSurface.blitFrom(_fullSurface, srcRect, d);
+						}
+
+						_needsRedraw = true;
+
+						if (g_nancy->getGameType() <= kGameTypeNancy2) {
+							// In nancy2, the presence of a hotspot relies on whether the Overlay has a scene change
+							if (_enableHotspot == kPlayOverlayWithHotspot) {
+								_hotspot = _screenPosition;
+								_hasHotspot = true;
+							}
+						} else {
+							// nancy3 added a per-frame flag for hotspots. This allows the overlay to be clickable
+							// even without a scene change (useful for setting flags).
+							if (_blitDescriptions[i].hasHotspot == kPlayOverlayWithHotspot) {
+								_hotspot = _screenPosition;
+								_hasHotspot = true;
+							}
+						}
+					}
+				}
+			}
+		}
+
+		break;
+	}
+	case kActionTrigger:
+		setVisible(false);
+		g_nancy->_sound->stopSound(_sound);
+
+		_flagsOnTrigger.execute();
+		if (_hasSceneChange == kPlayOverlaySceneChange) {
+			NancySceneState.changeScene(_sceneChange);
+		}
+
+		finishExecution();
+
+		break;
+	}
+}
+
+Common::String Overlay::getRecordTypeName() const {
+	if (g_nancy->getGameType() <= kGameTypeNancy1) {
+		if (_isInterruptible) {
+			return "PlayIntStaticBitmapAnimation";
+		} else {
+			return "PlayStaticBitmapAnimation";
+		}
+	} else {
+		return "Overlay";
+	}
+}
+
+void OverlayStaticTerse::readData(Common::SeekableReadStream &stream) {
+	readFilename(stream, _imageName);
+	_transparency = stream.readUint16LE();
+	_z = stream.readUint16LE();
+
+	Common::Rect dest, src;
+	readRect(stream, dest);
+	readRect(stream, src);
+
+	_srcRects.push_back(src);
+	_blitDescriptions.resize(1);
+	_blitDescriptions[0].src = Common::Rect(src.width(), src.height());
+	_blitDescriptions[0].dest = dest;
+
+	_overlayType = kPlayOverlayStatic;
+}
+
+void OverlayAnimTerse::readData(Common::SeekableReadStream &stream) {
+	readFilename(stream, _imageName);
+	stream.skip(2); // VIDEO_STOP_RENDERING, VIDEO_CONTINUE_RENDERING
+	_transparency = stream.readUint16LE();
+	_hasSceneChange = stream.readUint16LE();
+	_z = stream.readUint16LE();
+	_playDirection = stream.readUint16LE();
+	_loop = stream.readUint16LE();
+
+	_sceneChange.sceneID = stream.readUint16LE();
+	_sceneChange.continueSceneSound = kContinueSceneSound;
+	_sceneChange.listenerFrontVector.set(0, 0, 1);
+	_flagsOnTrigger.descs[0].label = stream.readSint16LE();
+	_flagsOnTrigger.descs[0].flag = stream.readUint16LE();
+
+	_firstFrame = _loopFirstFrame = stream.readUint16LE();
+	_loopLastFrame = stream.readUint16LE();
+
+	_blitDescriptions.resize(1);
+	readRect(stream, _blitDescriptions[0].dest);
+
+	readRectArray(stream, _srcRects, _loopLastFrame - _loopFirstFrame + 1);
+
+	_overlayType = kPlayOverlayAnimated;
+	_frameTime = Common::Rational(1000, 15).toInt(); // Always set to 15 fps
+}
+
+void TableIndexOverlay::readData(Common::SeekableReadStream &stream) {
+	_tableIndex = stream.readUint16LE();
+	Overlay::readData(stream);
+}
+
+void TableIndexOverlay::execute() {
+	if (_state == kBegin) {
+		Overlay::execute();
+	}
+
+	TableData *playerTable = (TableData *)NancySceneState.getPuzzleData(TableData::getTag());
+	assert(playerTable);
+	auto *tabl = GetEngineData(TABL);
+	assert(tabl);
+
+	if (_lastIndexVal != playerTable->singleValues[_tableIndex - 1]) {
+		_lastIndexVal = playerTable->singleValues[_tableIndex - 1];
+		_srcRects.clear();
+		_srcRects.push_back(tabl->srcRects[_lastIndexVal - 1]);
+		_currentViewportFrame = -1; // Force redraw
+	}
+
+	if (_state != kBegin) {
+		Overlay::execute();
+	}
+}
+
+} // End of namespace Action
+} // End of namespace Nancy