Initial commit
This commit is contained in:
997
engines/mohawk/riven_scripts.cpp
Normal file
997
engines/mohawk/riven_scripts.cpp
Normal file
@@ -0,0 +1,997 @@
|
||||
/* 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 "mohawk/cursors.h"
|
||||
#include "mohawk/riven.h"
|
||||
#include "mohawk/riven_card.h"
|
||||
#include "mohawk/riven_graphics.h"
|
||||
#include "mohawk/riven_scripts.h"
|
||||
#include "mohawk/riven_sound.h"
|
||||
#include "mohawk/riven_stack.h"
|
||||
#include "mohawk/riven_stacks/aspit.h"
|
||||
#include "mohawk/riven_video.h"
|
||||
#include "common/memstream.h"
|
||||
|
||||
#include "common/debug-channels.h"
|
||||
#include "common/stream.h"
|
||||
#include "common/system.h"
|
||||
|
||||
namespace Mohawk {
|
||||
|
||||
static void printTabs(byte tabs) {
|
||||
for (byte i = 0; i < tabs; i++)
|
||||
debugN("\t");
|
||||
}
|
||||
|
||||
RivenScriptManager::RivenScriptManager(MohawkEngine_Riven *vm) :
|
||||
_vm(vm),
|
||||
_runningQueuedScripts(false),
|
||||
_stoppingAllScripts(false) {
|
||||
|
||||
_storedMovieOpcode.time = 0;
|
||||
_storedMovieOpcode.slot = 0;
|
||||
}
|
||||
|
||||
RivenScriptManager::~RivenScriptManager() {
|
||||
clearStoredMovieOpcode();
|
||||
}
|
||||
|
||||
RivenScriptPtr RivenScriptManager::readScript(Common::ReadStream *stream) {
|
||||
RivenScriptPtr script = RivenScriptPtr(new RivenScript());
|
||||
|
||||
uint16 commandCount = stream->readUint16BE();
|
||||
|
||||
for (uint16 i = 0; i < commandCount; i++) {
|
||||
RivenCommandPtr command = readCommand(stream);
|
||||
script->addCommand(command);
|
||||
}
|
||||
|
||||
return script;
|
||||
}
|
||||
|
||||
RivenCommandPtr RivenScriptManager::readCommand(Common::ReadStream *stream) {
|
||||
RivenCommandType type = (RivenCommandType) stream->readUint16BE();
|
||||
|
||||
switch (type) {
|
||||
case kRivenCommandSwitch:
|
||||
return RivenCommandPtr(RivenSwitchCommand::createFromStream(_vm, stream));
|
||||
case kRivenCommandChangeStack:
|
||||
return RivenCommandPtr(RivenStackChangeCommand::createFromStream(_vm, stream));
|
||||
default:
|
||||
return RivenCommandPtr(RivenSimpleCommand::createFromStream(_vm, type, stream));
|
||||
}
|
||||
}
|
||||
|
||||
RivenScriptList RivenScriptManager::readScripts(Common::ReadStream *stream) {
|
||||
RivenScriptList scriptList;
|
||||
|
||||
uint16 scriptCount = stream->readUint16BE();
|
||||
for (uint16 i = 0; i < scriptCount; i++) {
|
||||
RivenTypedScript script;
|
||||
script.type = stream->readUint16BE();
|
||||
script.script = readScript(stream);
|
||||
scriptList.push_back(script);
|
||||
}
|
||||
|
||||
return scriptList;
|
||||
}
|
||||
|
||||
void RivenScriptManager::stopAllScripts() {
|
||||
_stoppingAllScripts = true;
|
||||
}
|
||||
|
||||
void RivenScriptManager::setStoredMovieOpcode(const StoredMovieOpcode &op) {
|
||||
clearStoredMovieOpcode();
|
||||
_storedMovieOpcode.script = op.script;
|
||||
_storedMovieOpcode.slot = op.slot;
|
||||
_storedMovieOpcode.time = op.time;
|
||||
}
|
||||
|
||||
void RivenScriptManager::runStoredMovieOpcode() {
|
||||
if (_storedMovieOpcode.script) {
|
||||
runScript(_storedMovieOpcode.script, false);
|
||||
clearStoredMovieOpcode();
|
||||
}
|
||||
}
|
||||
|
||||
void RivenScriptManager::clearStoredMovieOpcode() {
|
||||
_storedMovieOpcode.script = RivenScriptPtr();
|
||||
_storedMovieOpcode.time = 0;
|
||||
_storedMovieOpcode.slot = 0;
|
||||
}
|
||||
|
||||
void RivenScriptManager::runScript(const RivenScriptPtr &script, bool queue) {
|
||||
if (!script || script->empty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!queue) {
|
||||
script->run(this);
|
||||
} else {
|
||||
_queue.push_back(script);
|
||||
}
|
||||
}
|
||||
|
||||
bool RivenScriptManager::hasQueuedScripts() const {
|
||||
return !_queue.empty();
|
||||
}
|
||||
|
||||
void RivenScriptManager::runQueuedScripts() {
|
||||
_runningQueuedScripts = true;
|
||||
|
||||
for (uint i = 0; i < _queue.size(); i++) {
|
||||
_queue[i]->run(this);
|
||||
}
|
||||
|
||||
_queue.clear();
|
||||
|
||||
_stoppingAllScripts = false; // Once the queue is empty, all scripts have been stopped
|
||||
_runningQueuedScripts = false;
|
||||
}
|
||||
|
||||
RivenScriptPtr RivenScriptManager::createScriptFromData(uint commandCount, ...) {
|
||||
va_list args;
|
||||
va_start(args, commandCount);
|
||||
|
||||
// Build a script from the variadic arguments
|
||||
Common::MemoryWriteStreamDynamic writeStream = Common::MemoryWriteStreamDynamic(DisposeAfterUse::YES);
|
||||
writeStream.writeUint16BE((uint16)commandCount);
|
||||
|
||||
for (uint i = 0; i < commandCount; i++) {
|
||||
uint16 command = va_arg(args, int);
|
||||
writeStream.writeUint16BE(command);
|
||||
|
||||
if (command == kRivenCommandSwitch) {
|
||||
// The switch command has a different format that is not implemented
|
||||
error("Cannot create a Switch command from data");
|
||||
}
|
||||
|
||||
uint16 argumentCount = va_arg(args, int);
|
||||
writeStream.writeUint16BE(argumentCount);
|
||||
|
||||
for (uint j = 0; j < argumentCount; j++) {
|
||||
uint16 argument = va_arg(args, int);
|
||||
writeStream.writeUint16BE(argument);
|
||||
}
|
||||
}
|
||||
|
||||
va_end(args);
|
||||
|
||||
Common::MemoryReadStream readStream = Common::MemoryReadStream(writeStream.getData(), writeStream.size());
|
||||
return readScript(&readStream);
|
||||
}
|
||||
|
||||
RivenScriptPtr RivenScriptManager::readScriptFromData(uint16 *data, uint16 size) {
|
||||
// Script data is expected to be in big endian
|
||||
for (uint i = 0; i < size; i++) {
|
||||
data[i] = TO_BE_16(data[i]);
|
||||
}
|
||||
|
||||
Common::MemoryReadStream patchStream((const byte *)(data), size * sizeof(uint16));
|
||||
return _vm->_scriptMan->readScript(&patchStream);
|
||||
}
|
||||
|
||||
RivenScriptPtr RivenScriptManager::createScriptWithCommand(RivenCommand *command) {
|
||||
assert(command);
|
||||
|
||||
RivenScriptPtr script = RivenScriptPtr(new RivenScript());
|
||||
script->addCommand(RivenCommandPtr(command));
|
||||
return script;
|
||||
}
|
||||
|
||||
bool RivenScriptManager::runningQueuedScripts() const {
|
||||
return _runningQueuedScripts;
|
||||
}
|
||||
|
||||
bool RivenScriptManager::stoppingAllScripts() const {
|
||||
return _stoppingAllScripts;
|
||||
}
|
||||
|
||||
RivenScript::RivenScript() {
|
||||
}
|
||||
|
||||
RivenScript::~RivenScript() {
|
||||
}
|
||||
|
||||
void RivenScript::dumpScript(byte tabs) {
|
||||
for (uint16 i = 0; i < _commands.size(); i++) {
|
||||
_commands[i]->dump(tabs);
|
||||
}
|
||||
}
|
||||
|
||||
void RivenScript::run(RivenScriptManager *scriptManager) {
|
||||
for (uint i = 0; i < _commands.size(); i++) {
|
||||
if (scriptManager->stoppingAllScripts()) {
|
||||
return;
|
||||
}
|
||||
|
||||
_commands[i]->execute();
|
||||
}
|
||||
}
|
||||
|
||||
void RivenScript::addCommand(RivenCommandPtr command) {
|
||||
_commands.push_back(command);
|
||||
}
|
||||
|
||||
bool RivenScript::empty() const {
|
||||
return _commands.empty();
|
||||
}
|
||||
|
||||
RivenScript &RivenScript::operator+=(const RivenScript &other) {
|
||||
_commands.push_back(other._commands);
|
||||
return *this;
|
||||
}
|
||||
|
||||
const char *RivenScript::getTypeName(uint16 type) {
|
||||
static const char *names[] = {
|
||||
"MouseDown",
|
||||
"MouseDrag",
|
||||
"MouseUp",
|
||||
"MouseEnter",
|
||||
"MouseInside",
|
||||
"MouseLeave",
|
||||
"CardLoad",
|
||||
"CardLeave",
|
||||
"CardUnknown",
|
||||
"CardEnter",
|
||||
"CardUpdate"
|
||||
};
|
||||
|
||||
assert(type < ARRAYSIZE(names));
|
||||
return names[type];
|
||||
}
|
||||
|
||||
void RivenScript::applyCardPatches(MohawkEngine_Riven *vm, uint32 cardGlobalId, uint16 scriptType, uint16 hotspotId) {
|
||||
bool shouldApplyPatches = false;
|
||||
|
||||
// On Prison Island when pressing the dome viewer switch to close the dome,
|
||||
// the game schedules an ambient sound change using kRivenCommandStoreMovieOpcode
|
||||
// but does not play the associated video in a blocking way. The stored opcode
|
||||
// is not immediately used, stays in memory and may be triggered by some
|
||||
// other action. (Bug #9958)
|
||||
// We replace kRivenCommandStoreMovieOpcode by kRivenCommandActivateSLST
|
||||
// to make the ambient sound change happen immediately.
|
||||
//
|
||||
// Script before patch:
|
||||
// playMovieBlocking(3); // Dome closing
|
||||
// playMovie(4); // Dome spinning up
|
||||
// activatePLST(2); // Dome closed
|
||||
// playMovieBlocking(4); // Dome spinning up
|
||||
// storeMovieOpcode(1, 0, 0, 40, 2); // Schedule ambient sound change to "dome spinning"
|
||||
// after movie 1 finishes blocking playback
|
||||
// playMovie(1); // Dome spinning
|
||||
//
|
||||
// Script after patch:
|
||||
// playMovieBlocking(3); // Dome closing
|
||||
// playMovie(4); // Dome spinning up
|
||||
// activatePLST(2); // Dome closed
|
||||
// playMovieBlocking(4); // Dome spinning up
|
||||
// activateSLST(2); // Ambient sound change to "dome spinning"
|
||||
// playMovie(1); // Dome spinning
|
||||
if (cardGlobalId == 0x1AC1 && scriptType == kCardEnterScript) {
|
||||
shouldApplyPatches = true;
|
||||
for (uint i = 0; i < _commands.size(); i++) {
|
||||
if (_commands[i]->getType() == kRivenCommandStoreMovieOpcode) {
|
||||
RivenSimpleCommand::ArgumentArray arguments;
|
||||
arguments.push_back(2);
|
||||
_commands[i] = RivenCommandPtr(new RivenSimpleCommand(vm, kRivenCommandActivateSLST, arguments));
|
||||
debugC(kRivenDebugPatches, "Applied immediate ambient sound patch to card %x", cardGlobalId);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// On Jungle Island when entering the submarine from the dock beside the main walkway,
|
||||
// the sound of the hatch closing does not play (Bug #9972).
|
||||
// This happens only in the CD version of the game.
|
||||
//
|
||||
// Script before patch:
|
||||
// transition(16);
|
||||
// switchCard(534);
|
||||
//
|
||||
// Script after patch:
|
||||
// transition(16);
|
||||
// switchCard(534);
|
||||
// playSound(112, 256, 0);
|
||||
if (cardGlobalId == 0x2E900 && scriptType == kMouseDownScript && hotspotId == 3
|
||||
&& !vm->isGameVariant(GF_DVD)) {
|
||||
shouldApplyPatches = true;
|
||||
RivenSimpleCommand::ArgumentArray arguments;
|
||||
arguments.push_back(112);
|
||||
arguments.push_back(256);
|
||||
arguments.push_back(0);
|
||||
_commands.push_back(RivenCommandPtr(new RivenSimpleCommand(vm, kRivenCommandPlaySound, arguments)));
|
||||
debugC(kRivenDebugPatches, "Applied missing closing sound patch to card %x", cardGlobalId);
|
||||
}
|
||||
|
||||
// Second part of the patch to fix the invalid card change when entering Gehn's office
|
||||
// The first part is in the card patches.
|
||||
if (cardGlobalId == 0x2E76 && scriptType == kCardUpdateScript && !vm->isGameVariant(GF_DVD)) {
|
||||
shouldApplyPatches = true;
|
||||
|
||||
for (uint i = 0; i < _commands.size(); i++) {
|
||||
int transitionIndex = -1;
|
||||
if (_commands[i]->getType() == kRivenCommandTransition) {
|
||||
transitionIndex = i;
|
||||
}
|
||||
if (transitionIndex >= 0) {
|
||||
_commands.remove_at(transitionIndex + 1);
|
||||
_commands.remove_at(transitionIndex);
|
||||
|
||||
RivenSimpleCommand::ArgumentArray arguments;
|
||||
arguments.push_back(6);
|
||||
_commands.push_back(RivenCommandPtr(new RivenSimpleCommand(vm, kRivenCommandActivatePLST, arguments)));
|
||||
}
|
||||
}
|
||||
|
||||
debugC(kRivenDebugPatches, "Applied invalid card change during screen update (2/2) to card %x", cardGlobalId);
|
||||
}
|
||||
|
||||
// First part of the patch to fix the invalid steam sounds
|
||||
// when looking at the Boiler island bridge from Temple island.
|
||||
// The second part is in the card patches.
|
||||
if (cardGlobalId == 0x22118 && scriptType == kCardLoadScript) {
|
||||
shouldApplyPatches = true;
|
||||
|
||||
// Remove all the activateSLST calls.
|
||||
// Fixed calls will be added back in the second part of the patch.
|
||||
for (uint i = 0; i < _commands.size(); i++) {
|
||||
if (_commands[i]->getType() == kRivenCommandActivateSLST) {
|
||||
_commands.remove_at(i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
debugC(kRivenDebugPatches, "Applied incorrect steam sounds (1/2) to card %x", cardGlobalId);
|
||||
}
|
||||
|
||||
// Override the main menu new game script to call an external command.
|
||||
// This way we can reset all the state when starting a new game while a game is already started.
|
||||
if (cardGlobalId == 0xE2E && scriptType == kMouseDownScript && hotspotId == 16
|
||||
&& vm->isGameVariant(GF_25TH)) {
|
||||
shouldApplyPatches = true;
|
||||
_commands.clear();
|
||||
|
||||
RivenSimpleCommand::ArgumentArray arguments;
|
||||
arguments.push_back(RivenStacks::ASpit::kExternalNewGame);
|
||||
arguments.push_back(0);
|
||||
_commands.push_back(RivenCommandPtr(new RivenSimpleCommand(vm, kRivenCommandRunExternal, arguments)));
|
||||
debugC(kRivenDebugPatches, "Applied override new game script patch to card %x", cardGlobalId);
|
||||
}
|
||||
|
||||
if (shouldApplyPatches) {
|
||||
for (uint i = 0; i < _commands.size(); i++) {
|
||||
_commands[i]->applyCardPatches(cardGlobalId, scriptType, hotspotId);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
RivenScriptPtr &operator+=(RivenScriptPtr &lhs, const RivenScriptPtr &rhs) {
|
||||
if (rhs) {
|
||||
*lhs += *rhs;
|
||||
}
|
||||
return lhs;
|
||||
}
|
||||
|
||||
RivenCommand::RivenCommand(MohawkEngine_Riven *vm) :
|
||||
_vm(vm) {
|
||||
|
||||
}
|
||||
|
||||
RivenCommand::~RivenCommand() {
|
||||
|
||||
}
|
||||
|
||||
RivenSimpleCommand::RivenSimpleCommand(MohawkEngine_Riven *vm, RivenCommandType type, const ArgumentArray &arguments) :
|
||||
RivenCommand(vm),
|
||||
_type(type),
|
||||
_arguments(arguments) {
|
||||
setupOpcodes();
|
||||
}
|
||||
|
||||
RivenSimpleCommand::~RivenSimpleCommand() {
|
||||
}
|
||||
|
||||
RivenSimpleCommand *RivenSimpleCommand::createFromStream(MohawkEngine_Riven *vm, RivenCommandType type, Common::ReadStream *stream) {
|
||||
uint16 argc = stream->readUint16BE();
|
||||
|
||||
Common::Array<uint16> arguments;
|
||||
arguments.resize(argc);
|
||||
|
||||
for (uint16 i = 0; i < argc; i++) {
|
||||
arguments[i] = stream->readUint16BE();
|
||||
}
|
||||
|
||||
return new RivenSimpleCommand(vm, type, arguments);
|
||||
}
|
||||
|
||||
#define OPCODE(x) { &RivenSimpleCommand::x, #x }
|
||||
|
||||
void RivenSimpleCommand::setupOpcodes() {
|
||||
static const RivenOpcode riven_opcodes[] = {
|
||||
// 0x00 (0 decimal)
|
||||
OPCODE(empty),
|
||||
OPCODE(drawBitmap),
|
||||
OPCODE(switchCard),
|
||||
OPCODE(playScriptSLST),
|
||||
// 0x04 (4 decimal)
|
||||
OPCODE(playSound),
|
||||
OPCODE(empty), // Empty
|
||||
OPCODE(empty), // Complex animation (not used)
|
||||
OPCODE(setVariable),
|
||||
// 0x08 (8 decimal)
|
||||
OPCODE(empty), // Not a SimpleCommand
|
||||
OPCODE(enableHotspot),
|
||||
OPCODE(disableHotspot),
|
||||
OPCODE(empty), // Empty
|
||||
// 0x0C (12 decimal)
|
||||
OPCODE(stopSound),
|
||||
OPCODE(changeCursor),
|
||||
OPCODE(delay),
|
||||
OPCODE(empty), // Empty
|
||||
// 0x10 (16 decimal)
|
||||
OPCODE(empty), // Empty
|
||||
OPCODE(runExternalCommand),
|
||||
OPCODE(transition),
|
||||
OPCODE(refreshCard),
|
||||
// 0x14 (20 decimal)
|
||||
OPCODE(beginScreenUpdate),
|
||||
OPCODE(applyScreenUpdate),
|
||||
OPCODE(empty), // Empty
|
||||
OPCODE(empty), // Empty
|
||||
// 0x18 (24 decimal)
|
||||
OPCODE(incrementVariable),
|
||||
OPCODE(empty), // Empty
|
||||
OPCODE(empty), // Empty
|
||||
OPCODE(empty), // Not a SimpleCommand
|
||||
// 0x1C (28 decimal)
|
||||
OPCODE(disableMovie),
|
||||
OPCODE(disableAllMovies),
|
||||
OPCODE(empty), // Set movie rate (not used)
|
||||
OPCODE(enableMovie),
|
||||
// 0x20 (32 decimal)
|
||||
OPCODE(playMovieBlocking),
|
||||
OPCODE(playMovie),
|
||||
OPCODE(stopMovie),
|
||||
OPCODE(empty), // Start a water effect (not used)
|
||||
// 0x24 (36 decimal)
|
||||
OPCODE(unk_36), // Unknown
|
||||
OPCODE(fadeAmbientSounds),
|
||||
OPCODE(storeMovieOpcode),
|
||||
OPCODE(activatePLST),
|
||||
// 0x28 (40 decimal)
|
||||
OPCODE(activateSLST),
|
||||
OPCODE(activateMLSTAndPlay),
|
||||
OPCODE(empty), // Empty
|
||||
OPCODE(activateBLST),
|
||||
// 0x2C (44 decimal)
|
||||
OPCODE(activateFLST),
|
||||
OPCODE(zipMode),
|
||||
OPCODE(activateMLST),
|
||||
OPCODE(empty) // Activate an SLST with a volume parameter (not used)
|
||||
};
|
||||
|
||||
_opcodes = riven_opcodes;
|
||||
}
|
||||
|
||||
////////////////////////////////
|
||||
// Opcodes
|
||||
////////////////////////////////
|
||||
|
||||
// Command 1: draw tBMP resource (tbmp_id, left, top, right, bottom, u0, u1, u2, u3)
|
||||
void RivenSimpleCommand::drawBitmap(uint16 op, const ArgumentArray &args) {
|
||||
if (args.size() < 5) // Copy the image to the whole screen, ignoring the rest of the parameters
|
||||
_vm->_gfx->copyImageToScreen(args[0], 0, 0, 608, 392);
|
||||
else // Copy the image to a certain part of the screen
|
||||
_vm->_gfx->copyImageToScreen(args[0], args[1], args[2], args[3], args[4]);
|
||||
}
|
||||
|
||||
// Command 2: go to card (card id)
|
||||
void RivenSimpleCommand::switchCard(uint16 op, const ArgumentArray &args) {
|
||||
_vm->changeToCard(args[0]);
|
||||
}
|
||||
|
||||
// Command 3: play an SLST from the script
|
||||
void RivenSimpleCommand::playScriptSLST(uint16 op, const ArgumentArray &args) {
|
||||
int offset = 0, j = 0;
|
||||
uint16 soundCount = args[offset++];
|
||||
|
||||
SLSTRecord slstRecord;
|
||||
slstRecord.index = 0; // not set by the scripts, so we set it to 0
|
||||
slstRecord.soundIds.resize(soundCount);
|
||||
|
||||
for (j = 0; j < soundCount; j++)
|
||||
slstRecord.soundIds[j] = args[offset++];
|
||||
slstRecord.fadeFlags = args[offset++];
|
||||
slstRecord.loop = args[offset++];
|
||||
slstRecord.globalVolume = args[offset++];
|
||||
slstRecord.u0 = args[offset++];
|
||||
slstRecord.suspend = args[offset++];
|
||||
|
||||
slstRecord.volumes.resize(soundCount);
|
||||
slstRecord.balances.resize(soundCount);
|
||||
slstRecord.u2.resize(soundCount);
|
||||
|
||||
for (j = 0; j < soundCount; j++)
|
||||
slstRecord.volumes[j] = args[offset++];
|
||||
|
||||
for (j = 0; j < soundCount; j++)
|
||||
slstRecord.balances[j] = args[offset++]; // negative = left, 0 = center, positive = right
|
||||
|
||||
for (j = 0; j < soundCount; j++)
|
||||
slstRecord.u2[j] = args[offset++]; // Unknown
|
||||
|
||||
// Play the requested sound list
|
||||
_vm->_sound->playSLST(slstRecord);
|
||||
}
|
||||
|
||||
// Command 4: play local tWAV resource (twav_id, volume, block)
|
||||
void RivenSimpleCommand::playSound(uint16 op, const ArgumentArray &args) {
|
||||
uint16 volume = args[1];
|
||||
bool playOnDraw = args[2] == 1;
|
||||
|
||||
_vm->_sound->playSound(args[0], volume, playOnDraw);
|
||||
}
|
||||
|
||||
// Command 7: set variable value (variable, value)
|
||||
void RivenSimpleCommand::setVariable(uint16 op, const ArgumentArray &args) {
|
||||
_vm->getStackVar(args[0]) = args[1];
|
||||
}
|
||||
|
||||
// Command 9: enable hotspot (blst_id)
|
||||
void RivenSimpleCommand::enableHotspot(uint16 op, const ArgumentArray &args) {
|
||||
RivenHotspot *hotspot = _vm->getCard()->getHotspotByBlstId(args[0]);
|
||||
if (hotspot) {
|
||||
hotspot->enable(true);
|
||||
}
|
||||
}
|
||||
|
||||
// Command 10: disable hotspot (blst_id)
|
||||
void RivenSimpleCommand::disableHotspot(uint16 op, const ArgumentArray &args) {
|
||||
RivenHotspot *hotspot = _vm->getCard()->getHotspotByBlstId(args[0]);
|
||||
if (hotspot) {
|
||||
hotspot->enable(false);
|
||||
}
|
||||
}
|
||||
|
||||
// Command 12: stop sounds (flags)
|
||||
void RivenSimpleCommand::stopSound(uint16 op, const ArgumentArray &args) {
|
||||
// WORKAROUND: The Play Riven/Visit Riven/Start New Game buttons
|
||||
// in the main menu call this function to stop ambient sounds
|
||||
// after the change stack call to Temple Island. However, this
|
||||
// would cause all ambient sounds not to play. An alternative
|
||||
// fix would be to stop all scripts on a stack change, but this
|
||||
// does fine for now.
|
||||
if (_vm->getStack()->getId() == kStackTspit && (_vm->getStack()->getCurrentCardGlobalId() == 0x6e9a ||
|
||||
_vm->getStack()->getCurrentCardGlobalId() == 0xfeeb))
|
||||
return;
|
||||
|
||||
// The argument is a bitflag for the setting.
|
||||
// bit 0 is normal sound stopping
|
||||
// bit 1 is ambient sound stopping
|
||||
// Having no flags set means clear all
|
||||
if (args[0] & 2 || args[0] == 0)
|
||||
_vm->_sound->stopAllSLST();
|
||||
|
||||
if (args[0] & 1 || args[0] == 0)
|
||||
_vm->_sound->stopSound();
|
||||
}
|
||||
|
||||
// Command 13: set mouse cursor (cursor_id)
|
||||
void RivenSimpleCommand::changeCursor(uint16 op, const ArgumentArray &args) {
|
||||
_vm->_cursor->setCursor(args[0]);
|
||||
}
|
||||
|
||||
// Command 14: pause script execution (delay in ms, u1)
|
||||
void RivenSimpleCommand::delay(uint16 op, const ArgumentArray &args) {
|
||||
if (args[0] > 0)
|
||||
_vm->delay(args[0]);
|
||||
}
|
||||
|
||||
// Command 17: call external command
|
||||
void RivenSimpleCommand::runExternalCommand(uint16 op, const ArgumentArray &args) {
|
||||
uint16 commandNameid = args[0];
|
||||
uint16 argumentCount = args[1];
|
||||
|
||||
Common::Array<uint16> commandArgs(argumentCount ? &args[2] : nullptr, argumentCount);
|
||||
|
||||
_vm->getStack()->runCommand(commandNameid, commandArgs);
|
||||
}
|
||||
|
||||
// Command 18: transition
|
||||
// Note that this opcode has 1 or 5 parameters, depending on args.size()
|
||||
// Parameter 0: transition type
|
||||
// Parameters 1-4: transition rectangle
|
||||
void RivenSimpleCommand::transition(uint16 op, const ArgumentArray &args) {
|
||||
if (args.size() == 1)
|
||||
_vm->_gfx->scheduleTransition((RivenTransition) args[0]);
|
||||
else
|
||||
_vm->_gfx->scheduleTransition((RivenTransition) args[0], Common::Rect(args[1], args[2], args[3], args[4]));
|
||||
}
|
||||
|
||||
// Command 19: reload card
|
||||
void RivenSimpleCommand::refreshCard(uint16 op, const ArgumentArray &args) {
|
||||
_vm->getCard()->enter(false);
|
||||
}
|
||||
|
||||
// Command 20: begin screen update
|
||||
void RivenSimpleCommand::beginScreenUpdate(uint16 op, const ArgumentArray &args) {
|
||||
_vm->_gfx->beginScreenUpdate();
|
||||
}
|
||||
|
||||
// Command 21: apply screen update
|
||||
void RivenSimpleCommand::applyScreenUpdate(uint16 op, const ArgumentArray &args) {
|
||||
_vm->_gfx->applyScreenUpdate();
|
||||
}
|
||||
|
||||
// Command 24: increment variable (variable, value)
|
||||
void RivenSimpleCommand::incrementVariable(uint16 op, const ArgumentArray &args) {
|
||||
_vm->getStackVar(args[0]) += args[1];
|
||||
}
|
||||
|
||||
// Command 28: disable a movie
|
||||
void RivenSimpleCommand::disableMovie(uint16 op, const ArgumentArray &args) {
|
||||
RivenVideo *video = _vm->_video->openSlot(args[0]);
|
||||
if (video)
|
||||
video->disable();
|
||||
}
|
||||
|
||||
// Command 29: disable all movies
|
||||
void RivenSimpleCommand::disableAllMovies(uint16 op, const ArgumentArray &args) {
|
||||
_vm->_video->disableAllMovies();
|
||||
}
|
||||
|
||||
// Command 31: enable a movie
|
||||
void RivenSimpleCommand::enableMovie(uint16 op, const ArgumentArray &args) {
|
||||
RivenVideo *video = _vm->_video->openSlot(args[0]);
|
||||
video->enable();
|
||||
}
|
||||
|
||||
// Command 32: play foreground movie - blocking (movie_id)
|
||||
void RivenSimpleCommand::playMovieBlocking(uint16 op, const ArgumentArray &args) {
|
||||
RivenVideo *video = _vm->_video->openSlot(args[0]);
|
||||
video->setLooping(false);
|
||||
video->enable();
|
||||
video->playBlocking();
|
||||
}
|
||||
|
||||
// Command 33: play background movie - nonblocking (movie_id)
|
||||
void RivenSimpleCommand::playMovie(uint16 op, const ArgumentArray &args) {
|
||||
RivenVideo *video = _vm->_video->openSlot(args[0]);
|
||||
video->enable();
|
||||
video->play();
|
||||
}
|
||||
|
||||
// Command 34: stop a movie
|
||||
void RivenSimpleCommand::stopMovie(uint16 op, const ArgumentArray &args) {
|
||||
RivenVideo *video = _vm->_video->openSlot(args[0]);
|
||||
video->stop();
|
||||
}
|
||||
|
||||
// Command 36: unknown
|
||||
void RivenSimpleCommand::unk_36(uint16 op, const ArgumentArray &args) {
|
||||
}
|
||||
|
||||
// Command 37: fade ambient sounds
|
||||
void RivenSimpleCommand::fadeAmbientSounds(uint16 op, const ArgumentArray &args) {
|
||||
// Similar to stopSound(), but does fading
|
||||
_vm->_sound->stopAllSLST(true);
|
||||
}
|
||||
|
||||
// Command 38: Store an opcode for use when playing a movie (movie id, time high, time low, opcode, arguments...)
|
||||
void RivenSimpleCommand::storeMovieOpcode(uint16 op, const ArgumentArray &args) {
|
||||
// This opcode is used to delay an opcode's usage based on the elapsed
|
||||
// time of a specified movie. However, every use in the game is for
|
||||
// delaying an activateSLST opcode.
|
||||
|
||||
uint32 delayTime = (args[1] << 16) + args[2];
|
||||
|
||||
// Store the script
|
||||
RivenScriptManager::StoredMovieOpcode storedOp;
|
||||
storedOp.script = _vm->_scriptMan->createScriptFromData(1, args[3], 1, args[4]);
|
||||
storedOp.time = delayTime;
|
||||
storedOp.slot = args[0];
|
||||
|
||||
// Store the opcode for later
|
||||
_vm->_scriptMan->setStoredMovieOpcode(storedOp);
|
||||
}
|
||||
|
||||
// Command 39: activate PLST record (card picture lists)
|
||||
void RivenSimpleCommand::activatePLST(uint16 op, const ArgumentArray &args) {
|
||||
_vm->_activatedPLST = true;
|
||||
|
||||
RivenCard::Picture picture = _vm->getCard()->getPicture(args[0]);
|
||||
_vm->_gfx->copyImageToScreen(picture.id, picture.rect.left, picture.rect.top, picture.rect.right, picture.rect.bottom);
|
||||
}
|
||||
|
||||
// Command 40: activate SLST record (card ambient sound lists)
|
||||
void RivenSimpleCommand::activateSLST(uint16 op, const ArgumentArray &args) {
|
||||
_vm->_activatedSLST = true;
|
||||
|
||||
SLSTRecord slstRecord = _vm->getCard()->getSound(args[0]);
|
||||
_vm->_sound->playSLST(slstRecord);
|
||||
}
|
||||
|
||||
// Command 41: activate MLST record and play
|
||||
void RivenSimpleCommand::activateMLSTAndPlay(uint16 op, const ArgumentArray &args) {
|
||||
MLSTRecord mlstRecord = _vm->getCard()->getMovie(args[0]);
|
||||
activateMLST(mlstRecord);
|
||||
|
||||
RivenVideo *video = _vm->_video->openSlot(mlstRecord.playbackSlot);
|
||||
video->enable();
|
||||
video->play();
|
||||
}
|
||||
|
||||
// Command 43: activate BLST record (card hotspot enabling lists)
|
||||
void RivenSimpleCommand::activateBLST(uint16 op, const ArgumentArray &args) {
|
||||
_vm->getCard()->activateHotspotEnableRecord(args[0]);
|
||||
}
|
||||
|
||||
// Command 44: activate FLST record (information on which SFXE resource this card should use)
|
||||
void RivenSimpleCommand::activateFLST(uint16 op, const ArgumentArray &args) {
|
||||
_vm->getCard()->activateWaterEffect(args[0]);
|
||||
}
|
||||
|
||||
// Command 45: do zip mode
|
||||
void RivenSimpleCommand::zipMode(uint16 op, const ArgumentArray &args) {
|
||||
assert(_vm->getCard() && _vm->getCard()->getCurHotspot());
|
||||
|
||||
// Check the ZIPS records to see if we have a match to the hotspot name
|
||||
Common::String hotspotName = _vm->getCard()->getCurHotspot()->getName();
|
||||
|
||||
for (uint16 i = 0; i < _vm->_zipModeData.size(); i++)
|
||||
if (_vm->_zipModeData[i].name == hotspotName) {
|
||||
_vm->changeToCard(_vm->_zipModeData[i].id);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Command 46: activate MLST record (movie lists)
|
||||
void RivenSimpleCommand::activateMLST(uint16 op, const ArgumentArray &args) {
|
||||
MLSTRecord mlstRecord = _vm->getCard()->getMovie(args[0]);
|
||||
activateMLST(mlstRecord);
|
||||
}
|
||||
|
||||
void RivenSimpleCommand::activateMLST(const MLSTRecord &mlstRecord) const {
|
||||
RivenVideo *ptr = _vm->_video->openSlot(mlstRecord.playbackSlot);
|
||||
ptr->load(mlstRecord.movieID);
|
||||
ptr->moveTo(mlstRecord.left, mlstRecord.top);
|
||||
ptr->setLooping(mlstRecord.loop != 0);
|
||||
ptr->setVolume(mlstRecord.volume);
|
||||
}
|
||||
|
||||
Common::String RivenSimpleCommand::describe() const {
|
||||
Common::String desc;
|
||||
|
||||
if (_type == kRivenCommandSwitch) { // Use the variable name
|
||||
Common::String varName = _vm->getStack()->getName(kVariableNames, _arguments[0]);
|
||||
desc = Common::String::format("%s = %d", varName.c_str(), _arguments[1]);
|
||||
} else if (_type == kRivenCommandRunExternal) { // Use the external command name
|
||||
Common::String externalCommandName = _vm->getStack()->getName(kExternalCommandNames, _arguments[0]);
|
||||
desc = Common::String::format("%s(", externalCommandName.c_str());
|
||||
uint16 varCount = _arguments[1];
|
||||
for (uint16 j = 0; j < varCount; j++) {
|
||||
desc += Common::String::format("%d", _arguments[2 + j]);
|
||||
if (j != varCount - 1)
|
||||
desc += ", ";
|
||||
}
|
||||
desc += ")";
|
||||
} else if (_type == kRivenCommandIncrementVariable) { // Use the variable name
|
||||
Common::String varName = _vm->getStack()->getName(kVariableNames, _arguments[0]);
|
||||
desc = Common::String::format("%s += %d", varName.c_str(), _arguments[1]);
|
||||
} else if (_type == kRivenCommandSetVariable) { // Use the variable name
|
||||
Common::String varName = _vm->getStack()->getName(kVariableNames, _arguments[0]);
|
||||
desc = Common::String::format("%s = %d", varName.c_str(), _arguments[1]);
|
||||
} else {
|
||||
desc = Common::String::format("%s(", _opcodes[_type].desc);
|
||||
for (uint16 j = 0; j < _arguments.size(); j++) {
|
||||
desc += Common::String::format("%d", _arguments[j]);
|
||||
if (j != _arguments.size() - 1)
|
||||
desc += ", ";
|
||||
}
|
||||
desc += ")";
|
||||
}
|
||||
|
||||
return desc;
|
||||
}
|
||||
|
||||
void RivenSimpleCommand::dump(byte tabs) {
|
||||
printTabs(tabs);
|
||||
debugN("%s;\n", describe().c_str());
|
||||
}
|
||||
|
||||
void RivenSimpleCommand::execute() {
|
||||
if (DebugMan.isDebugChannelEnabled(kRivenDebugScript)) {
|
||||
debugC(kRivenDebugScript, "Running opcode: %s", describe().c_str());
|
||||
}
|
||||
|
||||
(this->*(_opcodes[_type].proc)) (_type, _arguments);
|
||||
}
|
||||
|
||||
RivenCommandType RivenSimpleCommand::getType() const {
|
||||
return _type;
|
||||
}
|
||||
|
||||
RivenSwitchCommand::RivenSwitchCommand(MohawkEngine_Riven *vm) :
|
||||
RivenCommand(vm),
|
||||
_variableId(0) {
|
||||
|
||||
}
|
||||
|
||||
RivenSwitchCommand::~RivenSwitchCommand() {
|
||||
|
||||
}
|
||||
|
||||
RivenSwitchCommand *RivenSwitchCommand::createFromStream(MohawkEngine_Riven *vm, Common::ReadStream *stream) {
|
||||
RivenSwitchCommand *command = new RivenSwitchCommand(vm);
|
||||
|
||||
if (stream->readUint16BE() != 2) {
|
||||
// This value is not used in the original engine
|
||||
warning("if-then-else unknown value is not 2");
|
||||
}
|
||||
|
||||
// variable to check against
|
||||
command->_variableId = stream->readUint16BE();
|
||||
|
||||
// number of logic blocks
|
||||
uint16 logicBlockCount = stream->readUint16BE();
|
||||
command->_branches.resize(logicBlockCount);
|
||||
|
||||
for (uint16 i = 0; i < logicBlockCount; i++) {
|
||||
Branch &branch = command->_branches[i];
|
||||
|
||||
// Value for this logic block
|
||||
branch.value = stream->readUint16BE();
|
||||
branch.script = vm->_scriptMan->readScript(stream);
|
||||
}
|
||||
|
||||
return command;
|
||||
}
|
||||
|
||||
void RivenSwitchCommand::dump(byte tabs) {
|
||||
Common::String varName = _vm->getStack()->getName(kVariableNames, _variableId);
|
||||
printTabs(tabs); debugN("switch (%s) {\n", varName.c_str());
|
||||
for (uint16 j = 0; j < _branches.size(); j++) {
|
||||
printTabs(tabs + 1);
|
||||
if (_branches[j].value == 0xFFFF)
|
||||
debugN("default:\n");
|
||||
else
|
||||
debugN("case %d:\n", _branches[j].value);
|
||||
_branches[j].script->dumpScript(tabs + 2);
|
||||
printTabs(tabs + 2); debugN("break;\n");
|
||||
}
|
||||
printTabs(tabs); debugN("}\n");
|
||||
}
|
||||
|
||||
void RivenSwitchCommand::execute() {
|
||||
if (DebugMan.isDebugChannelEnabled(kRivenDebugScript)) {
|
||||
Common::String varName = _vm->getStack()->getName(kVariableNames, _variableId);
|
||||
debugC(kRivenDebugScript, "Running opcode: switch(%s)", varName.c_str());
|
||||
}
|
||||
|
||||
// Get the switch variable value
|
||||
uint32 value = _vm->getStackVar(_variableId);
|
||||
|
||||
// Look for a case matching the value
|
||||
for (uint i = 0; i < _branches.size(); i++) {
|
||||
if (_branches[i].value == value) {
|
||||
_vm->_scriptMan->runScript(_branches[i].script, false);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Look for the default case if any
|
||||
for (uint i = 0; i < _branches.size(); i++) {
|
||||
if (_branches[i].value == 0Xffff) {
|
||||
_vm->_scriptMan->runScript(_branches[i].script, false);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
RivenCommandType RivenSwitchCommand::getType() const {
|
||||
return kRivenCommandSwitch;
|
||||
}
|
||||
|
||||
void RivenSwitchCommand::applyCardPatches(uint32 globalId, int scriptType, uint16 hotspotId) {
|
||||
for (uint i = 0; i < _branches.size(); i++) {
|
||||
_branches[i].script->applyCardPatches(_vm, globalId, scriptType, hotspotId);
|
||||
}
|
||||
}
|
||||
|
||||
RivenStackChangeCommand::RivenStackChangeCommand(MohawkEngine_Riven *vm, uint16 stackId, uint32 globalCardId,
|
||||
bool byStackId, bool byStackCardId) :
|
||||
RivenCommand(vm),
|
||||
_stackId(stackId),
|
||||
_cardId(globalCardId),
|
||||
_byStackId(byStackId),
|
||||
_byStackCardId(byStackCardId) {
|
||||
|
||||
}
|
||||
|
||||
RivenStackChangeCommand::~RivenStackChangeCommand() {
|
||||
|
||||
}
|
||||
|
||||
RivenStackChangeCommand *RivenStackChangeCommand::createFromStream(MohawkEngine_Riven *vm, Common::ReadStream *stream) {
|
||||
/* argumentsSize = */ stream->readUint16BE();
|
||||
uint16 stackId = stream->readUint16BE();
|
||||
uint32 globalCardId = stream->readUint32BE();
|
||||
|
||||
return new RivenStackChangeCommand(vm, stackId, globalCardId, false, false);
|
||||
}
|
||||
|
||||
void RivenStackChangeCommand::execute() {
|
||||
debugC(kRivenDebugScript, "Running opcode: changeStack(%d, %d)", _stackId, _cardId);
|
||||
|
||||
uint16 stackID;
|
||||
if (_byStackId) {
|
||||
stackID = _stackId;
|
||||
} else {
|
||||
Common::String stackName = _vm->getStack()->getName(kStackNames, _stackId);
|
||||
|
||||
stackID = RivenStacks::getId(stackName.c_str());
|
||||
if (stackID == kStackUnknown) {
|
||||
error ("'%s' is not a stack name!", stackName.c_str());
|
||||
}
|
||||
}
|
||||
|
||||
_vm->changeToStack(stackID);
|
||||
|
||||
uint16 cardID;
|
||||
if (_byStackCardId) {
|
||||
cardID = _cardId;
|
||||
} else {
|
||||
cardID = _vm->getStack()->getCardStackId(_cardId);
|
||||
}
|
||||
|
||||
_vm->changeToCard(cardID);
|
||||
}
|
||||
|
||||
void RivenStackChangeCommand::dump(byte tabs) {
|
||||
printTabs(tabs);
|
||||
debugN("changeStack(%d, %d);\n", _stackId, _cardId);
|
||||
}
|
||||
|
||||
RivenCommandType RivenStackChangeCommand::getType() const {
|
||||
return kRivenCommandChangeStack;
|
||||
}
|
||||
|
||||
RivenTimerCommand::RivenTimerCommand(MohawkEngine_Riven *vm, const Common::SharedPtr<RivenStack::TimerProc> &timerProc) :
|
||||
RivenCommand(vm),
|
||||
_timerProc(timerProc) {
|
||||
|
||||
}
|
||||
|
||||
void RivenTimerCommand::execute() {
|
||||
(*_timerProc)();
|
||||
}
|
||||
|
||||
void RivenTimerCommand::dump(byte tabs) {
|
||||
printTabs(tabs);
|
||||
debugN("doTimer();\n");
|
||||
}
|
||||
|
||||
RivenCommandType RivenTimerCommand::getType() const {
|
||||
return kRivenCommandTimer;
|
||||
}
|
||||
|
||||
} // End of namespace Mohawk
|
||||
Reference in New Issue
Block a user