diff options
Diffstat (limited to 'engines/sword2')
55 files changed, 23606 insertions, 0 deletions
diff --git a/engines/sword2/_mouse.cpp b/engines/sword2/_mouse.cpp new file mode 100644 index 0000000000..db0cf00f73 --- /dev/null +++ b/engines/sword2/_mouse.cpp @@ -0,0 +1,247 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "common/system.h" +#include "common/stream.h" + +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/mouse.h" + +namespace Sword2 { + +// This is the maximum mouse cursor size in the SDL backend +#define MAX_MOUSE_W 80 +#define MAX_MOUSE_H 80 + +#define MOUSEFLASHFRAME 6 + +void Mouse::decompressMouse(byte *decomp, byte *comp, uint8 frame, int width, int height, int pitch, int xOff, int yOff) { + int32 size = width * height; + int32 i = 0; + int x = 0; + int y = 0; + + comp = comp + READ_LE_UINT32(comp + frame * 4) - MOUSE_ANIM_HEADER_SIZE; + + while (i < size) { + if (*comp > 183) { + decomp[(y + yOff) * pitch + x + xOff] = *comp++; + if (++x >= width) { + x = 0; + y++; + } + i++; + } else { + x += *comp; + while (x >= width) { + y++; + x -= width; + } + i += *comp++; + } + } +} + +void Mouse::drawMouse() { + byte mouseData[MAX_MOUSE_W * MAX_MOUSE_H]; + + if (!_mouseAnim.data && !_luggageAnim.data) + return; + + // When an object is used in the game, the mouse cursor should be a + // combination of a standard mouse cursor and a luggage cursor. + // + // However, judging by the original code luggage cursors can also + // appear on their own. I have no idea which cases though. + + uint16 mouse_width = 0; + uint16 mouse_height = 0; + uint16 hotspot_x = 0; + uint16 hotspot_y = 0; + int deltaX = 0; + int deltaY = 0; + + if (_mouseAnim.data) { + hotspot_x = _mouseAnim.xHotSpot; + hotspot_y = _mouseAnim.yHotSpot; + mouse_width = _mouseAnim.mousew; + mouse_height = _mouseAnim.mouseh; + } + + if (_luggageAnim.data) { + if (!_mouseAnim.data) { + hotspot_x = _luggageAnim.xHotSpot; + hotspot_y = _luggageAnim.yHotSpot; + } + if (_luggageAnim.mousew > mouse_width) + mouse_width = _luggageAnim.mousew; + if (_luggageAnim.mouseh > mouse_height) + mouse_height = _luggageAnim.mouseh; + } + + if (_mouseAnim.data && _luggageAnim.data) { + deltaX = _mouseAnim.xHotSpot - _luggageAnim.xHotSpot; + deltaY = _mouseAnim.yHotSpot - _luggageAnim.yHotSpot; + } + + assert(deltaX >= 0); + assert(deltaY >= 0); + + // HACK for maximum cursor size. (The SDL backend imposes this + // restriction) + + if (mouse_width + deltaX > MAX_MOUSE_W) + deltaX = 80 - mouse_width; + if (mouse_height + deltaY > MAX_MOUSE_H) + deltaY = 80 - mouse_height; + + mouse_width += deltaX; + mouse_height += deltaY; + + if ((uint32)(mouse_width * mouse_height) > sizeof(mouseData)) { + warning("Mouse cursor too large"); + return; + } + + memset(mouseData, 0, mouse_width * mouse_height); + + if (_luggageAnim.data) + decompressMouse(mouseData, _luggageAnim.data, 0, + _luggageAnim.mousew, _luggageAnim.mouseh, + mouse_width, deltaX, deltaY); + + if (_mouseAnim.data) + decompressMouse(mouseData, _mouseAnim.data, _mouseFrame, + _mouseAnim.mousew, _mouseAnim.mouseh, mouse_width); + + _vm->_system->setMouseCursor(mouseData, mouse_width, mouse_height, hotspot_x, hotspot_y, 0); +} + +/** + * Animates the current mouse pointer + */ + +int32 Mouse::animateMouse() { + uint8 prevMouseFrame = _mouseFrame; + + if (!_mouseAnim.data) + return RDERR_UNKNOWN; + + if (++_mouseFrame == _mouseAnim.noAnimFrames) + _mouseFrame = MOUSEFLASHFRAME; + + if (_mouseFrame != prevMouseFrame) + drawMouse(); + + return RD_OK; +} + +/** + * Sets the mouse cursor animation. + * @param ma a pointer to the animation data, or NULL to clear the current one + * @param size the size of the mouse animation data + * @param mouseFlash RDMOUSE_FLASH or RDMOUSE_NOFLASH, depending on whether + * or not there is a lead-in animation + */ + +int32 Mouse::setMouseAnim(byte *ma, int32 size, int32 mouseFlash) { + free(_mouseAnim.data); + _mouseAnim.data = NULL; + + if (ma) { + if (mouseFlash == RDMOUSE_FLASH) + _mouseFrame = 0; + else + _mouseFrame = MOUSEFLASHFRAME; + + Common::MemoryReadStream readS(ma, size); + + _mouseAnim.runTimeComp = readS.readByte(); + _mouseAnim.noAnimFrames = readS.readByte(); + _mouseAnim.xHotSpot = readS.readSByte(); + _mouseAnim.yHotSpot = readS.readSByte(); + _mouseAnim.mousew = readS.readByte(); + _mouseAnim.mouseh = readS.readByte(); + + _mouseAnim.data = (byte *)malloc(size - MOUSE_ANIM_HEADER_SIZE); + if (!_mouseAnim.data) + return RDERR_OUTOFMEMORY; + + readS.read(_mouseAnim.data, size - MOUSE_ANIM_HEADER_SIZE); + + animateMouse(); + drawMouse(); + + _vm->_system->showMouse(true); + } else { + if (_luggageAnim.data) + drawMouse(); + else + _vm->_system->showMouse(false); + } + + return RD_OK; +} + +/** + * Sets the "luggage" animation to accompany the mouse animation. Luggage + * sprites are of the same format as mouse sprites. + * @param ma a pointer to the animation data, or NULL to clear the current one + * @param size the size of the animation data + */ + +int32 Mouse::setLuggageAnim(byte *ma, int32 size) { + free(_luggageAnim.data); + _luggageAnim.data = NULL; + + if (ma) { + Common::MemoryReadStream readS(ma, size); + + _luggageAnim.runTimeComp = readS.readByte(); + _luggageAnim.noAnimFrames = readS.readByte(); + _luggageAnim.xHotSpot = readS.readSByte(); + _luggageAnim.yHotSpot = readS.readSByte(); + _luggageAnim.mousew = readS.readByte(); + _luggageAnim.mouseh = readS.readByte(); + + _luggageAnim.data = (byte *)malloc(size - MOUSE_ANIM_HEADER_SIZE); + if (!_luggageAnim.data) + return RDERR_OUTOFMEMORY; + + readS.read(_luggageAnim.data, size - MOUSE_ANIM_HEADER_SIZE); + + animateMouse(); + drawMouse(); + + _vm->_system->showMouse(true); + } else { + if (_mouseAnim.data) + drawMouse(); + else + _vm->_system->showMouse(false); + } + + return RD_OK; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/animation.cpp b/engines/sword2/animation.cpp new file mode 100644 index 0000000000..2ba5df6792 --- /dev/null +++ b/engines/sword2/animation.cpp @@ -0,0 +1,535 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "common/file.h" +#include "common/config-manager.h" +#include "common/system.h" +#include "sound/vorbis.h" +#include "sound/mp3.h" + +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/maketext.h" +#include "sword2/resman.h" +#include "sword2/sound.h" +#include "sword2/animation.h" + +namespace Sword2 { + +AnimationState::AnimationState(Sword2Engine *vm) + : BaseAnimationState(vm->_mixer, vm->_system, 640, 480), _vm(vm) { +} + +AnimationState::~AnimationState() { +} + +#ifdef BACKEND_8BIT + +void AnimationState::setPalette(byte *pal) { + _vm->_screen->setPalette(0, 256, pal, RDPAL_INSTANT); +} + +#else + +void AnimationState::drawTextObject(SpriteInfo *s, byte *src) { + OverlayColor *dst = _overlay + RENDERWIDE * s->y + s->x; + + // FIXME: These aren't the "right" colours, but look good to me. + + OverlayColor pen = _sys->RGBToColor(255, 255, 255); + OverlayColor border = _sys->RGBToColor(0, 0, 0); + + for (int y = 0; y < s->h; y++) { + for (int x = 0; x < s->w; x++) { + switch (src[x]) { + case 1: + dst[x] = border; + break; + case 255: + dst[x] = pen; + break; + default: + break; + } + } + dst += RENDERWIDE; + src += s->w; + } +} + +#endif + +void AnimationState::clearScreen() { +#ifdef BACKEND_8BIT + memset(_vm->_screen->getScreen(), 0, _movieWidth * _movieHeight); +#else + OverlayColor black = _sys->RGBToColor(0, 0, 0); + + for (int i = 0; i < _movieWidth * _movieHeight; i++) + _overlay[i] = black; +#endif +} + +void AnimationState::updateScreen() { +#ifdef BACKEND_8BIT + byte *buf = _vm->_screen->getScreen() + ((480 - _movieHeight) / 2) * RENDERWIDE + (640 - _movieWidth) / 2; + + _vm->_system->copyRectToScreen(buf, _movieWidth, (640 - _movieWidth) / 2, (480 - _movieHeight) / 2, _movieWidth, _movieHeight); +#else + _sys->copyRectToOverlay(_overlay, _movieWidth, 0, 0, _movieWidth, _movieHeight); +#endif + _vm->_system->updateScreen(); +} + +void AnimationState::drawYUV(int width, int height, byte *const *dat) { +#ifdef BACKEND_8BIT + _vm->_screen->plotYUV(_lut, width, height, dat); +#else + plotYUV(width, height, dat); +#endif +} + +MovieInfo MoviePlayer::_movies[] = { + { "carib", 222, false }, + { "escape", 187, false }, + { "eye", 248, false }, + { "finale", 1485, false }, + { "guard", 75, false }, + { "intro", 1800, false }, + { "jungle", 186, false }, + { "museum", 167, false }, + { "pablo", 75, false }, + { "pyramid", 60, false }, + { "quaram", 184, false }, + { "river", 656, false }, + { "sailing", 138, false }, + { "shaman", 788, true }, + { "stone1", 34, false }, + { "stone2", 282, false }, + { "stone3", 65, false }, + { "demo", 60, false }, + { "enddemo", 110, false } +}; + +MoviePlayer::MoviePlayer(Sword2Engine *vm) + : _vm(vm), _snd(_vm->_mixer), _sys(_vm->_system), _textSurface(NULL) { +} + +void MoviePlayer::openTextObject(MovieTextObject *obj) { + if (obj->textSprite) + _vm->_screen->createSurface(obj->textSprite, &_textSurface); +} + +void MoviePlayer::closeTextObject(MovieTextObject *obj) { + if (_textSurface) { + _vm->_screen->deleteSurface(_textSurface); + _textSurface = NULL; + } +} + +void MoviePlayer::drawTextObject(AnimationState *anim, MovieTextObject *obj) { + if (obj->textSprite && _textSurface) { +#ifdef BACKEND_8BIT + _vm->_screen->drawSurface(obj->textSprite, _textSurface); +#else + if (anim) + anim->drawTextObject(obj->textSprite, _textSurface); + else + _vm->_screen->drawSurface(obj->textSprite, _textSurface); +#endif + } +} + +/** + * Plays an animated cutscene. + * @param filename the file name of the cutscene file + * @param text the subtitles and voiceovers for the cutscene + * @param leadInRes lead-in music resource id + * @param leadOutRes lead-out music resource id + */ + +int32 MoviePlayer::play(const char *filename, MovieTextObject *text[], int32 leadInRes, int32 leadOutRes) { + Audio::SoundHandle leadInHandle; + + // This happens if the user quits during the "eye" smacker + if (_vm->_quit) + return RD_OK; + + if (leadInRes) { + byte *leadIn = _vm->_resman->openResource(leadInRes); + uint32 leadInLen = _vm->_resman->fetchLen(leadInRes) - ResHeader::size(); + + assert(_vm->_resman->fetchType(leadIn) == WAV_FILE); + + leadIn += ResHeader::size(); + + _vm->_sound->playFx(&leadInHandle, leadIn, leadInLen, Audio::Mixer::kMaxChannelVolume, 0, false, Audio::Mixer::kMusicSoundType); + } + + byte *leadOut = NULL; + uint32 leadOutLen = 0; + + if (leadOutRes) { + leadOut = _vm->_resman->openResource(leadOutRes); + leadOutLen = _vm->_resman->fetchLen(leadOutRes) - ResHeader::size(); + + assert(_vm->_resman->fetchType(leadOut) == WAV_FILE); + + leadOut += ResHeader::size(); + } + + _leadOutFrame = (uint)-1; + + int i; + + for (i = 0; i < ARRAYSIZE(_movies); i++) { + if (scumm_stricmp(filename, _movies[i].name) == 0) { + _seamless = _movies[i].seamless; + if (_movies[i].frames > 60) + _leadOutFrame = _movies[i].frames - 60; + break; + } + } + + if (i == ARRAYSIZE(_movies)) + warning("Unknown movie, '%s'", filename); + +#ifdef USE_MPEG2 + playMPEG(filename, text, leadOut, leadOutLen); +#else + // No MPEG2? Use the old 'Narration Only' hack + playDummy(filename, text, leadOut, leadOutLen); +#endif + + _snd->stopHandle(leadInHandle); + + // Wait for the lead-out to stop, if there is any. Though don't do it + // for seamless movies, since they are meant to blend into the rest of + // the game. + + if (!_seamless) { + while (_vm->_mixer->isSoundHandleActive(_leadOutHandle)) { + _vm->_screen->updateDisplay(); + _vm->_system->delayMillis(30); + } + } + + if (leadInRes) + _vm->_resman->closeResource(leadInRes); + + if (leadOutRes) + _vm->_resman->closeResource(leadOutRes); + + return RD_OK; +} + +void MoviePlayer::playMPEG(const char *filename, MovieTextObject *text[], byte *leadOut, uint32 leadOutLen) { + uint frameCounter = 0, textCounter = 0; + Audio::SoundHandle handle; + bool skipCutscene = false, textVisible = false; + uint32 flags = Audio::Mixer::FLAG_16BITS; + bool startNextText = false; + + byte oldPal[256 * 4]; + memcpy(oldPal, _vm->_screen->getPalette(), sizeof(oldPal)); + + AnimationState *anim = new AnimationState(_vm); + + if (!anim->init(filename)) { + delete anim; + // Missing Files? Use the old 'Narration Only' hack + playDummy(filename, text, leadOut, leadOutLen); + return; + } + + // Clear the screen, because whatever is on it will be visible when the + // overlay is removed. And if there isn't an overlay, we don't want it + // to be visible during the cutscene. (Not all cutscenes cover the + // entire screen.) + _vm->_screen->clearScene(); + _vm->_screen->updateDisplay(); + +#ifndef SCUMM_BIG_ENDIAN + flags |= Audio::Mixer::FLAG_LITTLE_ENDIAN; +#endif + + while (!skipCutscene && anim->decodeFrame()) { + // The frame has been drawn. Now draw the subtitles, if any, + // before updating the screen. + + if (text && text[textCounter]) { + if (frameCounter == text[textCounter]->startFrame) { + openTextObject(text[textCounter]); + textVisible = true; + + if (text[textCounter]->speech) { + startNextText = true; + } + } + + if (startNextText && !_snd->isSoundHandleActive(handle)) { + _snd->playRaw(&handle, text[textCounter]->speech, text[textCounter]->speechBufferSize, 22050, flags); + startNextText = false; + } + + if (frameCounter == text[textCounter]->endFrame) { + closeTextObject(text[textCounter]); + textCounter++; + textVisible = false; + } + + if (textVisible) + drawTextObject(anim, text[textCounter]); + } + + anim->updateScreen(); + frameCounter++; + + if (frameCounter == _leadOutFrame && leadOut) + _vm->_sound->playFx(&_leadOutHandle, leadOut, leadOutLen, Audio::Mixer::kMaxChannelVolume, 0, false, Audio::Mixer::kMusicSoundType); + + OSystem::Event event; + while (_sys->pollEvent(event)) { + switch (event.type) { +#ifndef BACKEND_8BIT + case OSystem::EVENT_SCREEN_CHANGED: + anim->buildLookup(); + break; +#endif + case OSystem::EVENT_KEYDOWN: + if (event.kbd.keycode == 27) + skipCutscene = true; + break; + case OSystem::EVENT_QUIT: + _vm->closeGame(); + skipCutscene = true; + break; + default: + break; + } + } + } + + if (!skipCutscene) { + // Sleep for one frame so that the last frame is displayed. + _sys->delayMillis(1000 / 12); + } + + if (!_seamless) { + // Most movies fade to black on their own, but not all of them. + // Since we may be hanging around in the cutscene player for a + // while longer, waiting for the lead-out sound to finish, + // paint the overlay black. + + anim->clearScreen(); + } + + // If the speech is still playing, redraw the subtitles. At least in + // the English version this is most noticeable in the "carib" cutscene. + + if (textVisible && _snd->isSoundHandleActive(handle)) + drawTextObject(anim, text[textCounter]); + + if (text) + closeTextObject(text[textCounter]); + + anim->updateScreen(); + + // Wait for the voice to stop playing. This is to make sure that we + // don't cut off the speech in mid-sentence, and - even more + // importantly - that we don't free the sound buffer while it's in use. + + if (skipCutscene) + _snd->stopHandle(handle); + + while (_snd->isSoundHandleActive(handle)) { + _vm->_screen->updateDisplay(false); + _sys->delayMillis(100); + } + + if (!_seamless) { + // Clear the screen again + anim->clearScreen(); + anim->updateScreen(); + } + + _vm->_screen->setPalette(0, 256, oldPal, RDPAL_INSTANT); + + delete anim; +} + +/** + * This just plays the cutscene with voiceovers / subtitles, in case the files + * are missing. + */ + +void MoviePlayer::playDummy(const char *filename, MovieTextObject *text[], byte *leadOut, uint32 leadOutLen) { + if (!text) + return; + + int frameCounter = 0, textCounter = 0; + + byte oldPal[256 * 4]; + byte tmpPal[256 * 4]; + + _vm->_screen->clearScene(); + + // HACK: Draw instructions + // + // I'm using the the menu area, because that's unlikely to be touched + // by anything else during the cutscene. + + memset(_vm->_screen->getScreen(), 0, _vm->_screen->getScreenWide() * MENUDEEP); + + byte *data; + + // Russian version substituted latin characters with cyrillic. That's + // why it renders completely unreadable with default message + if (Common::parseLanguage(ConfMan.get("language")) == Common::RU_RUS) { + byte msg[] = "Po\344uk - to\344\345ko pev\345: hagmute k\344abuwy Ucke\343n, u\344u nocetute ca\343t npoekta u ckava\343te budeo po\344uku"; + data = _vm->_fontRenderer->makeTextSprite(msg, RENDERWIDE, 255, _vm->_speechFontId); + } else { + // TODO: Translate message to other languages? +#ifdef USE_MPEG2 + byte msg[] = "Cutscene - Narration Only: Press ESC to exit, or visit www.scummvm.org to download cutscene videos"; +#else + byte msg[] = "Cutscene - Narration Only: Press ESC to exit, or recompile ScummVM with MPEG2 support"; +#endif + + data = _vm->_fontRenderer->makeTextSprite(msg, RENDERWIDE, 255, _vm->_speechFontId); + } + + FrameHeader frame_head; + SpriteInfo msgSprite; + byte *msgSurface; + + frame_head.read(data); + + msgSprite.x = _vm->_screen->getScreenWide() / 2 - frame_head.width / 2; + msgSprite.y = MENUDEEP / 2 - frame_head.height / 2; + msgSprite.w = frame_head.width; + msgSprite.h = frame_head.height; + msgSprite.type = RDSPR_NOCOMPRESSION; + msgSprite.data = data + FrameHeader::size(); + + _vm->_screen->createSurface(&msgSprite, &msgSurface); + _vm->_screen->drawSurface(&msgSprite, msgSurface); + _vm->_screen->deleteSurface(msgSurface); + + free(data); + + // In case the cutscene has a long lead-in, start just before the first + // line of text. + + frameCounter = text[0]->startFrame - 12; + + // Fake a palette that will hopefully make the text visible. In the + // opening cutscene it seems to use colours 1 (black) and 255 (white). + + memcpy(oldPal, _vm->_screen->getPalette(), sizeof(oldPal)); + memset(tmpPal, 0, sizeof(tmpPal)); + tmpPal[255 * 4 + 0] = 255; + tmpPal[255 * 4 + 1] = 255; + tmpPal[255 * 4 + 2] = 255; + _vm->_screen->setPalette(0, 256, tmpPal, RDPAL_INSTANT); + + Audio::SoundHandle handle; + + bool skipCutscene = false; + + uint32 flags = Audio::Mixer::FLAG_16BITS; + +#ifndef SCUMM_BIG_ENDIAN + flags |= Audio::Mixer::FLAG_LITTLE_ENDIAN; +#endif + + while (1) { + if (!text[textCounter]) + break; + + if (frameCounter == text[textCounter]->startFrame) { + _vm->_screen->clearScene(); + openTextObject(text[textCounter]); + drawTextObject(NULL, text[textCounter]); + if (text[textCounter]->speech) { + _snd->playRaw(&handle, text[textCounter]->speech, text[textCounter]->speechBufferSize, 22050, flags); + } + } + + if (frameCounter == text[textCounter]->endFrame) { + closeTextObject(text[textCounter]); + _vm->_screen->clearScene(); + _vm->_screen->setNeedFullRedraw(); + textCounter++; + } + + frameCounter++; + _vm->_screen->updateDisplay(); + + KeyboardEvent *ke = _vm->keyboardEvent(); + + if ((ke && ke->keycode == 27) || _vm->_quit) { + _snd->stopHandle(handle); + skipCutscene = true; + break; + } + + // Simulate ~12 frames per second. I don't know what frame rate + // the original movies had, or even if it was constant, but + // this seems to work reasonably. + + _sys->delayMillis(90); + } + + // Wait for the voice to stop playing. This is to make sure that we + // don't cut off the speech in mid-sentence, and - even more + // importantly - that we don't free the sound buffer while it's in use. + + while (_snd->isSoundHandleActive(handle)) { + _vm->_screen->updateDisplay(false); + _sys->delayMillis(100); + } + + closeTextObject(text[textCounter]); + + _vm->_screen->clearScene(); + _vm->_screen->setNeedFullRedraw(); + + // HACK: Remove the instructions created above + Common::Rect r; + + memset(_vm->_screen->getScreen(), 0, _vm->_screen->getScreenWide() * MENUDEEP); + r.left = r.top = 0; + r.right = _vm->_screen->getScreenWide(); + r.bottom = MENUDEEP; + _vm->_screen->updateRect(&r); + + // FIXME: For now, only play the lead-out music for cutscenes that have + // subtitles. + + if (!skipCutscene && leadOut) + _vm->_sound->playFx(&_leadOutHandle, leadOut, leadOutLen, Audio::Mixer::kMaxChannelVolume, 0, false, Audio::Mixer::kMusicSoundType); + + _vm->_screen->setPalette(0, 256, oldPal, RDPAL_INSTANT); +} + +} // End of namespace Sword2 diff --git a/engines/sword2/animation.h b/engines/sword2/animation.h new file mode 100644 index 0000000000..e3a554ccd7 --- /dev/null +++ b/engines/sword2/animation.h @@ -0,0 +1,103 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + * + */ + +#ifndef ANIMATION_H +#define ANIMATION_H + +#include "graphics/animation.h" +#include "sound/mixer.h" + +namespace Sword2 { + +struct SpriteInfo; + +// This is the structure which is passed to the sequence player. It includes +// the smack to play, and any text lines which are to be displayed over the top +// of the sequence. + +struct MovieTextObject { + uint16 startFrame; + uint16 endFrame; + SpriteInfo *textSprite; + uint32 speechBufferSize; + uint16 *speech; +}; + +class AnimationState : public ::Graphics::BaseAnimationState { +private: + Sword2Engine *_vm; + +public: + AnimationState(Sword2Engine *vm); + ~AnimationState(); + +#ifndef BACKEND_8BIT + void drawTextObject(SpriteInfo *s, byte *src); +#endif + + void clearScreen(); + void updateScreen(); + +private: + void drawYUV(int width, int height, byte *const *dat); + +#ifdef BACKEND_8BIT + void setPalette(byte *pal); +#endif +}; + +struct MovieInfo { + char name[9]; + uint frames; + bool seamless; +}; + +class MoviePlayer { +private: + Sword2Engine *_vm; + Audio::Mixer *_snd; + OSystem *_sys; + + byte *_textSurface; + + Audio::SoundHandle _leadOutHandle; + + uint _leadOutFrame; + bool _seamless; + + static struct MovieInfo _movies[]; + + void openTextObject(MovieTextObject *obj); + void closeTextObject(MovieTextObject *obj); + void drawTextObject(AnimationState *anim, MovieTextObject *obj); + + void playMPEG(const char *filename, MovieTextObject *text[], byte *leadOut, uint32 leadOutLen); + void playDummy(const char *filename, MovieTextObject *text[], byte *leadOut, uint32 leadOutLen); + +public: + MoviePlayer(Sword2Engine *vm); + int32 play(const char *filename, MovieTextObject *text[], int32 leadInRes, int32 leadOutRes); +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/anims.cpp b/engines/sword2/anims.cpp new file mode 100644 index 0000000000..e64903a61f --- /dev/null +++ b/engines/sword2/anims.cpp @@ -0,0 +1,308 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +// --------------------------------------------------------------------------- +// A more intelligent version of the old ANIMS.C +// All this stuff by James +// DON'T TOUCH! +// --------------------------------------------------------------------------- + +#include "common/stdafx.h" +#include "common/file.h" + +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/build_display.h" +#include "sword2/interpreter.h" +#include "sword2/logic.h" +#include "sword2/maketext.h" +#include "sword2/resman.h" +#include "sword2/router.h" +#include "sword2/sound.h" +#include "sword2/animation.h" + +namespace Sword2 { + +int Router::doAnimate(byte *ob_logic, byte *ob_graph, int32 animRes, bool reverse) { + AnimHeader anim_head; + byte *anim_file; + + ObjectLogic obLogic(ob_logic); + ObjectGraphic obGraph(ob_graph); + + if (obLogic.getLooping() == 0) { + byte *ptr; + + // This is the start of the anim - set up the first frame + + // For testing all anims! + // A script loop can send every resource number to the anim + // function & it will only run the valid ones. See + // 'testing_routines' object in George's Player Character + // section of linc + + if (_vm->_logic->readVar(SYSTEM_TESTING_ANIMS)) { + if (!_vm->_resman->checkValid(animRes)) { + // Not a valid resource number. Switch off + // the sprite. Don't animate - just continue + // script next cycle. + setSpriteStatus(ob_graph, NO_SPRITE); + return IR_STOP; + } + + ptr = _vm->_resman->openResource(animRes); + + // if it's not an animation file + if (_vm->_resman->fetchType(animRes) != ANIMATION_FILE) { + _vm->_resman->closeResource(animRes); + + // switch off the sprite + // don't animate - just continue + // script next cycle + setSpriteStatus(ob_graph, NO_SPRITE); + return IR_STOP; + } + + _vm->_resman->closeResource(animRes); + + // switch on the sprite + setSpriteStatus(ob_graph, SORT_SPRITE); + } + + assert(animRes); + + // open anim file + anim_file = _vm->_resman->openResource(animRes); + + assert(_vm->_resman->fetchType(animRes) == ANIMATION_FILE); + + // point to anim header + anim_head.read(_vm->fetchAnimHeader(anim_file)); + + // now running an anim, looping back to this call again + obLogic.setLooping(1); + obGraph.setAnimResource(animRes); + + if (reverse) + obGraph.setAnimPc(anim_head.noAnimFrames - 1); + else + obGraph.setAnimPc(0); + } else if (_vm->_logic->getSync() != -1) { + // We've received a sync - return to script immediately + debug(5, "**sync stopped %d**", _vm->_logic->readVar(ID)); + + // If sync received, anim finishes right now (remaining on + // last frame). Quit animation, but continue script. + obLogic.setLooping(0); + return IR_CONT; + } else { + // Not first frame, and no sync received - set up the next + // frame of the anim. + + // open anim file and point to anim header + anim_file = _vm->_resman->openResource(obGraph.getAnimResource()); + anim_head.read(_vm->fetchAnimHeader(anim_file)); + + if (reverse) + obGraph.setAnimPc(obGraph.getAnimPc() - 1); + else + obGraph.setAnimPc(obGraph.getAnimPc() + 1); + } + + // check for end of anim + + if (reverse) { + if (obGraph.getAnimPc() == 0) + obLogic.setLooping(0); + } else { + if (obGraph.getAnimPc() == anim_head.noAnimFrames - 1) + obLogic.setLooping(0); + } + + // close the anim file + _vm->_resman->closeResource(obGraph.getAnimResource()); + + // check if we want the script to loop back & call this function again + return obLogic.getLooping() ? IR_REPEAT : IR_STOP; +} + +int Router::megaTableAnimate(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *animTable, bool reverse) { + int32 animRes = 0; + + // If this is the start of the anim, read the anim table to get the + // appropriate anim resource + + ObjectLogic obLogic(ob_logic); + + if (obLogic.getLooping() == 0) { + ObjectMega obMega(ob_mega); + + // Appropriate anim resource is in 'table[direction]' + animRes = READ_LE_UINT32(animTable + 4 * obMega.getCurDir()); + } + + return doAnimate(ob_logic, ob_graph, animRes, reverse); +} + +void Router::setSpriteStatus(byte *ob_graph, uint32 type) { + ObjectGraphic obGraph(ob_graph); + + // Remove the previous status, but don't affect the shading upper-word + obGraph.setType((obGraph.getType() & 0xffff0000) | type); +} + +void Router::setSpriteShading(byte *ob_graph, uint32 type) { + ObjectGraphic obGraph(ob_graph); + + // Remove the previous shading, but don't affect the status lower-word. + // Note that mega frames may still be shaded automatically, even when + // not sent 'RDSPR_SHADOW'. + obGraph.setType((obGraph.getType() & 0x0000ffff) | type); +} + +void Logic::createSequenceSpeech(MovieTextObject *sequenceText[]) { + uint32 line; + uint32 local_text; + uint32 text_res; + byte *text; + uint32 wavId; // ie. offical text number (actor text number) + bool speechRunning; + + // for each sequence text line that's been logged + for (line = 0; line < _sequenceTextLines; line++) { + // allocate this structure + sequenceText[line] = new MovieTextObject; + + sequenceText[line]->startFrame = _sequenceTextList[line].startFrame; + sequenceText[line]->endFrame = _sequenceTextList[line].endFrame; + + // pull out the text line to get the official text number + // (for wav id) + + text_res = _sequenceTextList[line].textNumber / SIZE; + local_text = _sequenceTextList[line].textNumber & 0xffff; + + // open text resource & get the line + text = _vm->fetchTextLine(_vm->_resman->openResource(text_res), local_text); + wavId = (int32)READ_LE_UINT16(text); + + // now ok to close the text file + _vm->_resman->closeResource(text_res); + + // 1st word of text line is the official line number + debug(5,"(%d) SEQUENCE TEXT: %s", READ_LE_UINT16(text), text + 2); + + // is it to be speech or subtitles or both? + // assume speech is not running until know otherwise + + speechRunning = false; + _sequenceTextList[line].speech_mem = NULL; + sequenceText[line]->speech = NULL; + + if (!_vm->_sound->isSpeechMute()) { + _sequenceTextList[line].speechBufferSize = _vm->_sound->preFetchCompSpeech(wavId, &_sequenceTextList[line].speech_mem); + if (_sequenceTextList[line].speechBufferSize) { + // ok, we've got speech! + speechRunning = true; + } + } + + // if we want subtitles, or speech failed to load + + if (_vm->getSubtitles() || !speechRunning) { + // open text resource & get the line + text = _vm->fetchTextLine(_vm->_resman->openResource(text_res), local_text); + // make the sprite + // 'text+2' to skip the first 2 bytes which form the + // line reference number + + // NB. The mem block containing the text sprite is + // currently FLOATING! + + // When rendering text over a sequence we need a + // different colour for the border. + + _sequenceTextList[line].text_mem = _vm->_fontRenderer->makeTextSprite(text + 2, 600, 255, _vm->_speechFontId, 1); + + // ok to close the text resource now + _vm->_resman->closeResource(text_res); + } else { + _sequenceTextList[line].text_mem = NULL; + sequenceText[line]->textSprite = NULL; + } + } + + // for drivers: NULL-terminate the array of pointers to + // MovieTextObject's + sequenceText[_sequenceTextLines] = NULL; + + for (line = 0; line < _sequenceTextLines; line++) { + // if we've made a text sprite for this line... + + if (_sequenceTextList[line].text_mem) { + // now fill out the SpriteInfo structure in the + // MovieTextObjectStructure + FrameHeader frame; + + frame.read(_sequenceTextList[line].text_mem); + + sequenceText[line]->textSprite = new SpriteInfo; + + // center text at bottom of screen + sequenceText[line]->textSprite->x = 320 - frame.width / 2; + sequenceText[line]->textSprite->y = 440 - frame.height; + sequenceText[line]->textSprite->w = frame.width; + sequenceText[line]->textSprite->h = frame.height; + sequenceText[line]->textSprite->type = RDSPR_DISPLAYALIGN | RDSPR_NOCOMPRESSION; + sequenceText[line]->textSprite->data = _sequenceTextList[line].text_mem + FrameHeader::size(); + } + + // if we've loaded a speech sample for this line... + + if (_sequenceTextList[line].speech_mem) { + // for drivers: set up pointer to decompressed wav in + // memory + + sequenceText[line]->speechBufferSize = _sequenceTextList[line].speechBufferSize; + sequenceText[line]->speech = _sequenceTextList[line].speech_mem; + } + } +} + +void Logic::clearSequenceSpeech(MovieTextObject *sequenceText[]) { + for (uint i = 0; i < _sequenceTextLines; i++) { + // free up the memory used by this MovieTextObject + delete sequenceText[i]; + + // free up the mem block containing this text sprite + if (_sequenceTextList[i].text_mem) + free(_sequenceTextList[i].text_mem); + + // free up the mem block containing this speech sample + if (_sequenceTextList[i].speech_mem) + free(_sequenceTextList[i].speech_mem); + } + + // IMPORTANT! Reset the line count ready for the next sequence! + _sequenceTextLines = 0; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/build_display.cpp b/engines/sword2/build_display.cpp new file mode 100644 index 0000000000..bc5a31a1f9 --- /dev/null +++ b/engines/sword2/build_display.cpp @@ -0,0 +1,1070 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +// --------------------------------------------------------------------------- +// BUILD_DISPLAY.CPP like the old spr_engi but slightly more aptly named +// --------------------------------------------------------------------------- + +#include "common/stdafx.h" +#include "common/system.h" + +#include "sword2/sword2.h" +#include "sword2/console.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/maketext.h" +#include "sword2/mouse.h" +#include "sword2/resman.h" +#include "sword2/sound.h" + +namespace Sword2 { + +Screen::Screen(Sword2Engine *vm, int16 width, int16 height) { + _vm = vm; + + _dirtyGrid = _buffer = NULL; + + _vm->_system->initSize(width, height); + + _screenWide = width; + _screenDeep = height; + + _gridWide = width / CELLWIDE; + _gridDeep = height / CELLDEEP; + + if ((width % CELLWIDE) || (height % CELLDEEP)) + error("Bad cell size"); + + _dirtyGrid = (byte *)calloc(_gridWide, _gridDeep); + if (!_dirtyGrid) + error("Could not initialise dirty grid"); + + _buffer = (byte *)malloc(width * height); + if (!_buffer) + error("Could not initialise display"); + + for (int i = 0; i < ARRAYSIZE(_blockSurfaces); i++) + _blockSurfaces[i] = NULL; + + _lightMask = NULL; + _needFullRedraw = false; + + memset(&_thisScreen, 0, sizeof(_thisScreen)); + + _fps = 0; + _frameCount = 0; + _cycleTime = 0; + + _lastPaletteRes = 0; + + _scrollFraction = 16; + + _largestLayerArea = 0; + _largestSpriteArea = 0; + + strcpy(_largestLayerInfo, "largest layer: none registered"); + strcpy(_largestSpriteInfo, "largest sprite: none registered"); + + _fadeStatus = RDFADE_NONE; + _renderAverageTime = 60; + + _layer = 0; +} + +Screen::~Screen() { + free(_buffer); + free(_dirtyGrid); + closeBackgroundLayer(); + free(_lightMask); +} + +void Screen::buildDisplay() { + if (_thisScreen.new_palette) { + // start the layer palette fading up + startNewPalette(); + + // should be reset to zero at start of each screen change + _largestLayerArea = 0; + _largestSpriteArea = 0; + } + + // Does this ever happen? + if (!_thisScreen.background_layer_id) + return; + + // there is a valid screen to run + + setScrollTarget(_thisScreen.scroll_offset_x, _thisScreen.scroll_offset_y); + _vm->_mouse->animateMouse(); + startRenderCycle(); + + byte *file = _vm->_resman->openResource(_thisScreen.background_layer_id); + + MultiScreenHeader screenLayerTable; + + screenLayerTable.read(file + ResHeader::size()); + + // Render at least one frame, but if the screen is scrolling, and if + // there is time left, we will render extra frames to smooth out the + // scrolling. + + do { + // first background parallax + related anims + if (screenLayerTable.bg_parallax[0]) { + renderParallax(_vm->fetchBackgroundParallaxLayer(file, 0), 0); + drawBackPar0Frames(); + } + + // second background parallax + related anims + if (screenLayerTable.bg_parallax[1]) { + renderParallax(_vm->fetchBackgroundParallaxLayer(file, 1), 1); + drawBackPar1Frames(); + } + + // normal backround layer (just the one!) + renderParallax(_vm->fetchBackgroundLayer(file), 2); + + // sprites & layers + drawBackFrames(); // background sprites + drawSortFrames(file); // sorted sprites & layers + drawForeFrames(); // foreground sprites + + // first foreground parallax + related anims + + if (screenLayerTable.fg_parallax[0]) { + renderParallax(_vm->fetchForegroundParallaxLayer(file, 0), 3); + drawForePar0Frames(); + } + + // second foreground parallax + related anims + + if (screenLayerTable.fg_parallax[1]) { + renderParallax(_vm->fetchForegroundParallaxLayer(file, 1), 4); + drawForePar1Frames(); + } + + _vm->_debugger->drawDebugGraphics(); + _vm->_fontRenderer->printTextBlocs(); + _vm->_mouse->processMenu(); + + updateDisplay(); + + _frameCount++; + if (_vm->getMillis() > _cycleTime) { + _fps = _frameCount; + _frameCount = 0; + _cycleTime = _vm->getMillis() + 1000; + } + } while (!endRenderCycle()); + + _vm->_resman->closeResource(_thisScreen.background_layer_id); +} + +/** + * Fades down and displays a message on the screen. + * @param text The message + * @param time The number of seconds to display the message, or 0 to display it + * until the user clicks the mouse or presses a key. + */ + +void Screen::displayMsg(byte *text, int time) { + byte pal[256 * 4]; + byte oldPal[256 * 4]; + + debug(2, "DisplayMsg: %s", text); + + if (getFadeStatus() != RDFADE_BLACK) { + fadeDown(); + waitForFade(); + } + + _vm->_mouse->setMouse(0); + _vm->_mouse->setLuggage(0); + _vm->_mouse->closeMenuImmediately(); + + clearScene(); + + byte *text_spr = _vm->_fontRenderer->makeTextSprite(text, 640, 187, _vm->_speechFontId); + + FrameHeader frame; + + frame.read(text_spr); + + SpriteInfo spriteInfo; + + spriteInfo.x = _screenWide / 2 - frame.width / 2; + if (!time) + spriteInfo.y = _screenDeep / 2 - frame.height / 2 - MENUDEEP; + else + spriteInfo.y = 400 - frame.height; + spriteInfo.w = frame.width; + spriteInfo.h = frame.height; + spriteInfo.scale = 0; + spriteInfo.scaledWidth = 0; + spriteInfo.scaledHeight = 0; + spriteInfo.type = RDSPR_DISPLAYALIGN | RDSPR_NOCOMPRESSION | RDSPR_TRANS; + spriteInfo.blend = 0; + spriteInfo.data = text_spr + FrameHeader::size(); + spriteInfo.colourTable = 0; + + uint32 rv = drawSprite(&spriteInfo); + if (rv) + error("Driver Error %.8x (in DisplayMsg)", rv); + + memcpy(oldPal, _palette, sizeof(oldPal)); + memset(pal, 0, sizeof(pal)); + + pal[187 * 4 + 0] = 255; + pal[187 * 4 + 1] = 255; + pal[187 * 4 + 2] = 255; + + setPalette(0, 256, pal, RDPAL_FADE); + fadeUp(); + free(text_spr); + waitForFade(); + + if (time > 0) { + uint32 targetTime = _vm->getMillis() + (time * 1000); + _vm->sleepUntil(targetTime); + } else { + while (!_vm->_quit) { + MouseEvent *me = _vm->mouseEvent(); + if (me && (me->buttons & (RD_LEFTBUTTONDOWN | RD_RIGHTBUTTONDOWN))) + break; + + if (_vm->keyboardEvent()) + break; + + updateDisplay(); + _vm->_system->delayMillis(50); + } + } + + fadeDown(); + waitForFade(); + clearScene(); + setPalette(0, 256, oldPal, RDPAL_FADE); + fadeUp(); +} + +void Screen::drawBackPar0Frames() { + // frame attached to 1st background parallax + for (uint i = 0; i < _curBgp0; i++) + processImage(&_bgp0List[i]); +} + +void Screen::drawBackPar1Frames() { + // frame attached to 2nd background parallax + for (uint i = 0; i < _curBgp1; i++) + processImage(&_bgp1List[i]); +} + +void Screen::drawBackFrames() { + // background sprite, fixed to main background + for (uint i = 0; i < _curBack; i++) + processImage(&_backList[i]); +} + +void Screen::drawSortFrames(byte *file) { + uint i, j; + + // Sort the sort list. Used to be a separate function, but it was only + // called once, right before calling drawSortFrames(). + + if (_curSort > 1) { + for (i = 0; i < _curSort - 1; i++) { + for (j = 0; j < _curSort - 1; j++) { + if (_sortList[_sortOrder[j]].sort_y > _sortList[_sortOrder[j + 1]].sort_y) { + SWAP(_sortOrder[j], _sortOrder[j + 1]); + } + } + } + } + + // Draw the sorted frames - layers, shrinkers & normal flat sprites + + for (i = 0; i < _curSort; i++) { + if (_sortList[_sortOrder[i]].layer_number) { + // it's a layer - minus 1 for true layer number + // we need to know from the BuildUnit because the + // layers will have been sorted in random order + processLayer(file, _sortList[_sortOrder[i]].layer_number - 1); + } else { + // it's a sprite + processImage(&_sortList[_sortOrder[i]]); + } + } +} + +void Screen::drawForeFrames() { + // foreground sprite, fixed to main background + for (uint i = 0; i < _curFore; i++) + processImage(&_foreList[i]); +} + +void Screen::drawForePar0Frames() { + // frame attached to 1st foreground parallax + for (uint i = 0; i < _curFgp0; i++) + processImage(&_fgp0List[i]); +} + +void Screen::drawForePar1Frames() { + // frame attached to 2nd foreground parallax + for (uint i = 0; i < _curFgp1; i++) + processImage(&_fgp1List[i]); +} + +void Screen::processLayer(byte *file, uint32 layer_number) { + LayerHeader layer_head; + + layer_head.read(_vm->fetchLayerHeader(file, layer_number)); + + SpriteInfo spriteInfo; + + spriteInfo.x = layer_head.x; + spriteInfo.y = layer_head.y; + spriteInfo.w = layer_head.width; + spriteInfo.scale = 0; + spriteInfo.scaledWidth = 0; + spriteInfo.scaledHeight = 0; + spriteInfo.h = layer_head.height; + spriteInfo.type = RDSPR_TRANS | RDSPR_RLE256FAST; + spriteInfo.blend = 0; + spriteInfo.data = file + ResHeader::size() + layer_head.offset; + spriteInfo.colourTable = 0; + + // check for largest layer for debug info + + uint32 current_layer_area = layer_head.width * layer_head.height; + + if (current_layer_area > _largestLayerArea) { + byte buf[NAME_LEN]; + + _largestLayerArea = current_layer_area; + sprintf(_largestLayerInfo, + "largest layer: %s layer(%d) is %dx%d", + _vm->_resman->fetchName(_thisScreen.background_layer_id, buf), + layer_number, layer_head.width, layer_head.height); + } + + uint32 rv = drawSprite(&spriteInfo); + if (rv) + error("Driver Error %.8x in processLayer(%d)", rv, layer_number); +} + +void Screen::processImage(BuildUnit *build_unit) { + byte *file = _vm->_resman->openResource(build_unit->anim_resource); + byte *colTablePtr = NULL; + + byte *frame = _vm->fetchFrameHeader(file, build_unit->anim_pc); + + AnimHeader anim_head; + CdtEntry cdt_entry; + FrameHeader frame_head; + + anim_head.read(_vm->fetchAnimHeader(file)); + cdt_entry.read(_vm->fetchCdtEntry(file, build_unit->anim_pc)); + frame_head.read(frame); + + // so that 0-colour is transparent + uint32 spriteType = RDSPR_TRANS; + + if (anim_head.blend) + spriteType |= RDSPR_BLEND; + + // if the frame is to be flipped (only really applicable to frames + // using offsets) + if (cdt_entry.frameType & FRAME_FLIPPED) + spriteType |= RDSPR_FLIP; + + if (cdt_entry.frameType & FRAME_256_FAST) { + // scaling, shading & blending don't work with RLE256FAST + // but the same compression can be decompressed using the + // RLE256 routines! + + // NOTE: If this restriction refers to drawSprite(), I don't + // think we have it any more. But I'm not sure. + + if (build_unit->scale || anim_head.blend || build_unit->shadingFlag) + spriteType |= RDSPR_RLE256; + else + spriteType |= RDSPR_RLE256FAST; + } else { + switch (anim_head.runTimeComp) { + case NONE: + spriteType |= RDSPR_NOCOMPRESSION; + break; + case RLE256: + spriteType |= RDSPR_RLE256; + break; + case RLE16: + spriteType |= RDSPR_RLE16; + // points to just after last cdt_entry, ie. + // start of colour table + colTablePtr = _vm->fetchAnimHeader(file) + AnimHeader::size() + anim_head.noAnimFrames * CdtEntry::size(); + break; + } + } + + // if we want this frame to be affected by the shading mask, + // add the status bit + if (build_unit->shadingFlag) + spriteType |= RDSPR_SHADOW; + + SpriteInfo spriteInfo; + + spriteInfo.x = build_unit->x; + spriteInfo.y = build_unit->y; + spriteInfo.w = frame_head.width; + spriteInfo.h = frame_head.height; + spriteInfo.scale = build_unit->scale; + spriteInfo.scaledWidth = build_unit->scaled_width; + spriteInfo.scaledHeight = build_unit->scaled_height; + spriteInfo.type = spriteType; + spriteInfo.blend = anim_head.blend; + // points to just after frame header, ie. start of sprite data + spriteInfo.data = frame + FrameHeader::size(); + spriteInfo.colourTable = colTablePtr; + + // check for largest layer for debug info + uint32 current_sprite_area = frame_head.width * frame_head.height; + + if (current_sprite_area > _largestSpriteArea) { + byte buf[NAME_LEN]; + + _largestSpriteArea = current_sprite_area; + sprintf(_largestSpriteInfo, + "largest sprite: %s frame(%d) is %dx%d", + _vm->_resman->fetchName(build_unit->anim_resource, buf), + build_unit->anim_pc, + frame_head.width, + frame_head.height); + } + + if (_vm->_logic->readVar(SYSTEM_TESTING_ANIMS)) { // see anims.cpp + // bring the anim into the visible screen + // but leave extra pixel at edge for box + if (spriteInfo.x + spriteInfo.scaledWidth >= 639) + spriteInfo.x = 639 - spriteInfo.scaledWidth; + + if (spriteInfo.y + spriteInfo.scaledHeight >= 399) + spriteInfo.y = 399 - spriteInfo.scaledHeight; + + if (spriteInfo.x < 1) + spriteInfo.x = 1; + + if (spriteInfo.y < 1) + spriteInfo.y = 1; + + // create box to surround sprite - just outside sprite box + _vm->_debugger->_rectX1 = spriteInfo.x - 1; + _vm->_debugger->_rectY1 = spriteInfo.y - 1; + _vm->_debugger->_rectX2 = spriteInfo.x + spriteInfo.scaledWidth; + _vm->_debugger->_rectY2 = spriteInfo.y + spriteInfo.scaledHeight; + } + + uint32 rv = drawSprite(&spriteInfo); + if (rv) { + byte buf[NAME_LEN]; + + error("Driver Error %.8x with sprite %s (%d) in processImage", + rv, + _vm->_resman->fetchName(build_unit->anim_resource, buf), + build_unit->anim_resource); + } + + // release the anim resource + _vm->_resman->closeResource(build_unit->anim_resource); +} + +void Screen::resetRenderLists() { + // reset the sort lists - do this before a logic loop + // takes into account the fact that the start of the list is pre-built + // with the special sortable layers + + _curBgp0 = 0; + _curBgp1 = 0; + _curBack = 0; + // beginning of sort list is setup with the special sort layers + _curSort = _thisScreen.number_of_layers; + _curFore = 0; + _curFgp0 = 0; + _curFgp1 = 0; + + if (_curSort) { + // there are some layers - so rebuild the sort order list + for (uint i = 0; i < _curSort; i++) + _sortOrder[i] = i; + } +} + +void Screen::registerFrame(byte *ob_mouse, byte *ob_graph, byte *ob_mega, BuildUnit *build_unit) { + ObjectGraphic obGraph(ob_graph); + ObjectMega obMega(ob_mega); + + assert(obGraph.getAnimResource()); + + byte *file = _vm->_resman->openResource(obGraph.getAnimResource()); + + AnimHeader anim_head; + CdtEntry cdt_entry; + FrameHeader frame_head; + + anim_head.read(_vm->fetchAnimHeader(file)); + cdt_entry.read(_vm->fetchCdtEntry(file, obGraph.getAnimPc())); + frame_head.read(_vm->fetchFrameHeader(file, obGraph.getAnimPc())); + + // update player graphic details for on-screen debug info + if (_vm->_logic->readVar(ID) == CUR_PLAYER_ID) { + _vm->_debugger->_graphType = obGraph.getType(); + _vm->_debugger->_graphAnimRes = obGraph.getAnimResource(); + // counting 1st frame as 'frame 1' + _vm->_debugger->_graphAnimPc = obGraph.getAnimPc() + 1; + _vm->_debugger->_graphNoFrames = anim_head.noAnimFrames; + } + + // fill in the BuildUnit structure for this frame + + build_unit->anim_resource = obGraph.getAnimResource(); + build_unit->anim_pc = obGraph.getAnimPc(); + build_unit->layer_number = 0; + + // Affected by shading mask? + if (obGraph.getType() & SHADED_SPRITE) + build_unit->shadingFlag = true; + else + build_unit->shadingFlag = false; + + // Check if this frame has offsets ie. this is a scalable mega frame + + int scale = 0; + + if (cdt_entry.frameType & FRAME_OFFSET) { + scale = obMega.calcScale(); + + // calc final render coordinates (top-left of sprite), based + // on feet coords & scaled offsets + + // add scaled offsets to feet coords + build_unit->x = obMega.getFeetX() + (cdt_entry.x * scale) / 256; + build_unit->y = obMega.getFeetY() + (cdt_entry.y * scale) / 256; + + // Work out new width and height. Always divide by 256 after + // everything else, to maintain accurary + build_unit->scaled_width = ((scale * frame_head.width) / 256); + build_unit->scaled_height = ((scale * frame_head.height) / 256); + } else { + // It's a non-scaling anim. Get render coords for sprite, from cdt + build_unit->x = cdt_entry.x; + build_unit->y = cdt_entry.y; + + // Get width and height + build_unit->scaled_width = frame_head.width; + build_unit->scaled_height = frame_head.height; + } + + // either 0 or required scale, depending on whether 'scale' computed + build_unit->scale = scale; + + // calc the bottom y-coord for sorting purposes + build_unit->sort_y = build_unit->y + build_unit->scaled_height - 1; + + if (ob_mouse) { + // passed a mouse structure, so add to the _mouseList + _vm->_mouse->registerMouse(ob_mouse, build_unit); + + } + + _vm->_resman->closeResource(obGraph.getAnimResource()); +} + +void Screen::registerFrame(byte *ob_mouse, byte *ob_graph, byte *ob_mega) { + ObjectGraphic obGraph(ob_graph); + + // check low word for sprite type + switch (obGraph.getType() & 0x0000ffff) { + case BGP0_SPRITE: + assert(_curBgp0 < MAX_bgp0_sprites); + registerFrame(ob_mouse, ob_graph, ob_mega, &_bgp0List[_curBgp0]); + _curBgp0++; + break; + case BGP1_SPRITE: + assert(_curBgp1 < MAX_bgp1_sprites); + registerFrame(ob_mouse, ob_graph, ob_mega, &_bgp1List[_curBgp1]); + _curBgp1++; + break; + case BACK_SPRITE: + assert(_curBack < MAX_back_sprites); + registerFrame(ob_mouse, ob_graph, ob_mega, &_backList[_curBack]); + _curBack++; + break; + case SORT_SPRITE: + assert(_curSort < MAX_sort_sprites); + _sortOrder[_curSort] = _curSort; + registerFrame(ob_mouse, ob_graph, ob_mega, &_sortList[_curSort]); + _curSort++; + break; + case FORE_SPRITE: + assert(_curFore < MAX_fore_sprites); + registerFrame(ob_mouse, ob_graph, ob_mega, &_foreList[_curFore]); + _curFore++; + break; + case FGP0_SPRITE: + assert(_curFgp0 < MAX_fgp0_sprites); + registerFrame(ob_mouse, ob_graph, ob_mega, &_fgp0List[_curFgp0]); + _curFgp0++; + break; + case FGP1_SPRITE: + assert(_curFgp1 < MAX_fgp1_sprites); + registerFrame(ob_mouse, ob_graph, ob_mega, &_fgp1List[_curFgp1]); + _curFgp1++; + break; + default: + // NO_SPRITE no registering! + break; + } +} + +// FIXME: +// +// The original credits used a different font. I think it's stored in the +// font.clu file, but I don't know how to interpret it. +// +// The original used the entire screen. This version cuts off the top and +// bottom of the screen, because that's where the menus would usually be. +// +// The original had some sort of smoke effect at the bottom of the screen. + +enum { + LINE_LEFT, + LINE_CENTER, + LINE_RIGHT +}; + +struct CreditsLine { + char *str; + byte type; + int top; + int height; + byte *sprite; + + CreditsLine() { + str = NULL; + sprite = NULL; + }; + + ~CreditsLine() { + free(str); + free(sprite); + str = NULL; + sprite = NULL; + } +}; + +#define CREDITS_FONT_HEIGHT 25 +#define CREDITS_LINE_SPACING 20 + +void Screen::rollCredits() { + uint32 loopingMusicId = _vm->_sound->getLoopingMusicId(); + + // Prepare for the credits by fading down, stoping the music, etc. + + _vm->_mouse->setMouse(0); + + _vm->_sound->muteFx(true); + _vm->_sound->muteSpeech(true); + + waitForFade(); + fadeDown(); + waitForFade(); + + _vm->_mouse->closeMenuImmediately(); + + // There are three files which I believe are involved in showing the + // credits: + // + // credits.bmp - The "Smacker" logo, stored as follows: + // + // width 2 bytes, little endian + // height 2 bytes, little endian + // palette 3 * 256 bytes + // data width * height bytes + // + // Note that the maximum colour component in the palette is 0x3F. + // This is the same resolution as the _paletteMatch table. I doubt + // that this is a coincidence, but let's use the image palette + // directly anyway, just to be safe. + // + // credits.clu - The credits text + // + // This is simply a text file with CRLF line endings. + // '^' is not shown, but used to mark the center of the line. + // '@' is used as a placeholder for the "Smacker" logo. At least + // when it appears alone. + // Remaining lines are centered. + // The German version also contains character code 9 for no + // apparent reason. We ignore them. + // + // fonts.clu - The credits font? + // + // FIXME: At this time I don't know how to interpret fonts.clu. For + // now, let's just the standard speech font instead. + + SpriteInfo spriteInfo; + Common::File f; + int i; + + // Read the "Smacker" logo + + uint16 logoWidth = 0; + uint16 logoHeight = 0; + byte *logoData = NULL; + byte palette[256 * 4]; + + if (f.open("credits.bmp")) { + logoWidth = f.readUint16LE(); + logoHeight = f.readUint16LE(); + + for (i = 0; i < 256; i++) { + palette[i * 4 + 0] = f.readByte() << 2; + palette[i * 4 + 1] = f.readByte() << 2; + palette[i * 4 + 2] = f.readByte() << 2; + palette[i * 4 + 3] = 0; + } + + logoData = (byte *)malloc(logoWidth * logoHeight); + + f.read(logoData, logoWidth * logoHeight); + f.close(); + } else { + warning("Can't find credits.bmp"); + memset(palette, 0, sizeof(palette)); + palette[14 * 4 + 0] = 252; + palette[14 * 4 + 1] = 252; + palette[14 * 4 + 2] = 252; + palette[14 * 4 + 3] = 0; + } + + setPalette(0, 256, palette, RDPAL_INSTANT); + + // Read the credits text + + Common::Array<CreditsLine *> creditsLines; + + int lineCount = 0; + int lineTop = 400; + int paragraphStart = 0; + bool hasCenterMark = false; + + if (!f.open("credits.clu")) { + warning("Can't find credits.clu"); + return; + } + + while (1) { + char buffer[80]; + char *line = f.readLine(buffer, sizeof(buffer)); + + if (!line || *line == 0) { + if (!hasCenterMark) { + for (i = paragraphStart; i < lineCount; i++) + creditsLines[i]->type = LINE_CENTER; + } + paragraphStart = lineCount; + hasCenterMark = false; + if (paragraphStart == lineCount) + lineTop += CREDITS_LINE_SPACING; + + if (!line) + break; + + continue; + } + + // The German credits contains character code 9. We don't want + // the credits to show the 'dud' symbol, so we replace them + // with spaces. + + for (char *ptr = line; *ptr; ptr++) { + if (*ptr < 32) + *ptr = 32; + } + + char *center_mark = strchr(line, '^'); + + if (center_mark) { + // The current paragraph has at least one center mark. + hasCenterMark = true; + + if (center_mark != line) { + creditsLines.push_back(new CreditsLine); + + // The center mark is somewhere inside the + // line. Split it into left and right side. + *center_mark = 0; + + creditsLines[lineCount]->top = lineTop; + creditsLines[lineCount]->height = CREDITS_FONT_HEIGHT; + creditsLines[lineCount]->type = LINE_LEFT; + creditsLines[lineCount]->str = strdup(line); + + lineCount++; + *center_mark = '^'; + } + + line = center_mark; + } + + creditsLines.push_back(new CreditsLine); + + creditsLines[lineCount]->top = lineTop; + + if (*line == '^') { + creditsLines[lineCount]->type = LINE_RIGHT; + line++; + } else + creditsLines[lineCount]->type = LINE_LEFT; + + if (strcmp(line, "@") == 0) { + creditsLines[lineCount]->height = logoHeight; + lineTop += logoHeight; + } else { + creditsLines[lineCount]->height = CREDITS_FONT_HEIGHT; + lineTop += CREDITS_LINE_SPACING; + } + + creditsLines[lineCount]->str = strdup(line); + lineCount++; + } + + f.close(); + + // We could easily add some ScummVM stuff to the credits, if we wanted + // to. On the other hand, anyone with the attention span to actually + // read all the credits probably already knows. :-) + + // Start the music and roll the credits + + // The credits music (which can also be heard briefly in the "carib" + // cutscene) is played once. + + _vm->_sound->streamCompMusic(309, false); + + clearScene(); + fadeUp(0); + + spriteInfo.scale = 0; + spriteInfo.scaledWidth = 0; + spriteInfo.scaledHeight = 0; + spriteInfo.type = RDSPR_DISPLAYALIGN | RDSPR_NOCOMPRESSION | RDSPR_TRANS; + spriteInfo.blend = 0; + + int startLine = 0; + int scrollPos = 0; + + bool abortCredits = false; + + int scrollSteps = lineTop + CREDITS_FONT_HEIGHT; + uint32 musicStart = _vm->getMillis(); + + // Ideally the music should last just a tiny bit longer than the + // credits. Note that musicTimeRemaining() will return 0 if the music + // is muted, so we need a sensible fallback for that case. + + uint32 musicLength = MAX((int32)(1000 * (_vm->_sound->musicTimeRemaining() - 3)), 25 * (int32)scrollSteps); + + while (scrollPos < scrollSteps && !_vm->_quit) { + clearScene(); + + for (i = startLine; i < lineCount; i++) { + if (!creditsLines[i]) + continue; + + // Free any sprites that have scrolled off the screen + + if (creditsLines[i]->top + creditsLines[i]->height < scrollPos) { + debug(2, "Freeing line %d: '%s'", i, creditsLines[i]->str); + + delete creditsLines[i]; + creditsLines[i] = NULL; + + startLine = i + 1; + } else if (creditsLines[i]->top < scrollPos + 400) { + if (!creditsLines[i]->sprite) { + debug(2, "Creating line %d: '%s'", i, creditsLines[i]->str); + creditsLines[i]->sprite = _vm->_fontRenderer->makeTextSprite((byte *)creditsLines[i]->str, 600, 14, _vm->_speechFontId, 0); + } + + FrameHeader frame; + + frame.read(creditsLines[i]->sprite); + + spriteInfo.y = creditsLines[i]->top - scrollPos; + spriteInfo.w = frame.width; + spriteInfo.h = frame.height; + spriteInfo.data = creditsLines[i]->sprite + FrameHeader::size(); + + switch (creditsLines[i]->type) { + case LINE_LEFT: + spriteInfo.x = RENDERWIDE / 2 - 5 - frame.width; + break; + case LINE_RIGHT: + spriteInfo.x = RENDERWIDE / 2 + 5; + break; + case LINE_CENTER: + if (strcmp(creditsLines[i]->str, "@") == 0) { + spriteInfo.data = logoData; + spriteInfo.x = (RENDERWIDE - logoWidth) / 2; + spriteInfo.w = logoWidth; + spriteInfo.h = logoHeight; + } else + spriteInfo.x = (RENDERWIDE - frame.width) / 2; + break; + } + + if (spriteInfo.data) + drawSprite(&spriteInfo); + } else + break; + } + + updateDisplay(); + + KeyboardEvent *ke = _vm->keyboardEvent(); + + if (ke && ke->keycode == 27) { + if (!abortCredits) { + abortCredits = true; + fadeDown(); + } + } + + if (abortCredits && getFadeStatus() == RDFADE_BLACK) + break; + + _vm->sleepUntil(musicStart + (musicLength * scrollPos) / scrollSteps); + scrollPos++; + } + + // We're done. Clean up and try to put everything back where it was + // before the credits. + + for (i = 0; i < lineCount; i++) { + delete creditsLines[i]; + } + + free(logoData); + + if (!abortCredits) { + fadeDown(); + + // The music should either have stopped or be about to stop, so + // wait for it to really happen. + + while (_vm->_sound->musicTimeRemaining() && !_vm->_quit) { + updateDisplay(false); + _vm->_system->delayMillis(100); + } + } + + if (_vm->_quit) + return; + + waitForFade(); + + _vm->_sound->muteFx(false); + _vm->_sound->muteSpeech(false); + + if (loopingMusicId) + _vm->_sound->streamCompMusic(loopingMusicId, true); + else + _vm->_sound->stopMusic(false); + + if (!_vm->_mouse->getMouseStatus() || _vm->_mouse->isChoosing()) + _vm->_mouse->setMouse(NORMAL_MOUSE_ID); + + if (_vm->_logic->readVar(DEAD)) + _vm->_mouse->buildSystemMenu(); +} + +// This image used to be shown by CacheNewCluster() while copying a data file +// from the CD to the hard disk. ScummVM doesn't do that, so the image is never +// shown. It'd be nice if we could do something useful with it some day... + +void Screen::splashScreen() { + byte *bgfile = _vm->_resman->openResource(2950); + + initialiseBackgroundLayer(NULL); + initialiseBackgroundLayer(NULL); + initialiseBackgroundLayer(_vm->fetchBackgroundLayer(bgfile)); + initialiseBackgroundLayer(NULL); + initialiseBackgroundLayer(NULL); + + setPalette(0, 256, _vm->fetchPalette(bgfile), RDPAL_FADE); + renderParallax(_vm->fetchBackgroundLayer(bgfile), 2); + + closeBackgroundLayer(); + + byte *loadingBar = _vm->_resman->openResource(2951); + byte *frame = _vm->fetchFrameHeader(loadingBar, 0); + + AnimHeader animHead; + CdtEntry cdt; + FrameHeader frame_head; + + animHead.read(_vm->fetchAnimHeader(loadingBar)); + cdt.read(_vm->fetchCdtEntry(loadingBar, 0)); + frame_head.read(_vm->fetchFrameHeader(loadingBar, 0)); + + SpriteInfo barSprite; + + barSprite.x = cdt.x; + barSprite.y = cdt.y; + barSprite.w = frame_head.width; + barSprite.h = frame_head.height; + barSprite.scale = 0; + barSprite.scaledWidth = 0; + barSprite.scaledHeight = 0; + barSprite.type = RDSPR_RLE256FAST | RDSPR_TRANS; + barSprite.blend = 0; + barSprite.colourTable = 0; + barSprite.data = frame + FrameHeader::size(); + + drawSprite(&barSprite); + + fadeUp(); + waitForFade(); + + for (int i = 0; i < animHead.noAnimFrames; i++) { + frame = _vm->fetchFrameHeader(loadingBar, i); + barSprite.data = frame + FrameHeader::size(); + drawSprite(&barSprite); + updateDisplay(); + _vm->_system->delayMillis(30); + } + + _vm->_resman->closeResource(2951); + + fadeDown(); + waitForFade(); +} + +} // End of namespace Sword2 diff --git a/engines/sword2/build_display.h b/engines/sword2/build_display.h new file mode 100644 index 0000000000..1a362da137 --- /dev/null +++ b/engines/sword2/build_display.h @@ -0,0 +1,441 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef _BUILD_DISPLAY +#define _BUILD_DISPLAY + +#include "common/rect.h" +#include "common/stream.h" + +#define MAX_bgp0_sprites 6 +#define MAX_bgp1_sprites 6 +#define MAX_back_sprites 30 +#define MAX_sort_sprites 30 +#define MAX_fore_sprites 30 +#define MAX_fgp0_sprites 6 +#define MAX_fgp1_sprites 6 + +#define PALTABLESIZE (64 * 64 * 64) + +#define BLOCKWIDTH 64 +#define BLOCKHEIGHT 64 +#define MAXLAYERS 5 + +#define MENUDEEP 40 +#define RENDERWIDE 640 +#define RENDERDEEP (480 - (MENUDEEP * 2)) + +// Maximum scaled size of a sprite +#define SCALE_MAXWIDTH 512 +#define SCALE_MAXHEIGHT 512 + +// Dirty grid cell size +#define CELLWIDE 10 +#define CELLDEEP 20 + +namespace Sword2 { + +class Sword2Engine; + +// Sprite defines + +enum { + // This is the low byte part of the sprite type. + + RDSPR_TRANS = 0x0001, + RDSPR_BLEND = 0x0004, + RDSPR_FLIP = 0x0008, + RDSPR_SHADOW = 0x0010, + RDSPR_DISPLAYALIGN = 0x0020, + RDSPR_NOCOMPRESSION = 0x0040, + RDSPR_EDGEBLEND = 0x0080, // Unused + + // This is the high byte part of the sprite type, which defines what + // type of compression is used. Unless RDSPR_NOCOMPRESSION is set. + + RDSPR_RLE16 = 0x0000, + RDSPR_RLE256 = 0x0100, + RDSPR_RLE256FAST = 0x0200 +}; + +// Fading defines + +enum { + RDFADE_NONE, + RDFADE_UP, + RDFADE_DOWN, + RDFADE_BLACK +}; + +// Palette defines + +enum { + RDPAL_FADE, + RDPAL_INSTANT +}; + +// Blitting FX defines + +enum { + RDBLTFX_SPRITEBLEND = 0x01, + RDBLTFX_SHADOWBLEND = 0x02, + RDBLTFX_EDGEBLEND = 0x04 +}; + +// Structure filled out by each object to register its graphic printing +// requrements + +struct BuildUnit { + int16 x; + int16 y; + uint16 scaled_width; + uint16 scaled_height; + int16 sort_y; + uint32 anim_resource; + uint16 anim_pc; + + // Denotes a scaling sprite at print time - and holds the scaling value + // for the shrink routine + + uint16 scale; + + // Non-zero means this item is a layer - retrieve from background layer + // and send to special renderer + + uint16 layer_number; + + // True means we want this frame to be affected by the shading mask + + bool shadingFlag; +}; + +struct ScreenInfo { + uint16 scroll_offset_x; // Position x + uint16 scroll_offset_y; // Position y + uint16 max_scroll_offset_x; // Calc'ed in fnInitBackground + uint16 max_scroll_offset_y; + int16 player_feet_x; // Feet coordinates to use - cant just + int16 player_feet_y; // fetch the player compact anymore + int16 feet_x; // Special offset-to-player position - + int16 feet_y; // tweek as desired - always set in + // screen manager object startup + uint16 screen_wide; // Size of background layer - hence + uint16 screen_deep; // size of back buffer itself (Paul + // actually malloc's it) + uint32 background_layer_id; // Id of the normal background layer + // from the header of the main + // background layer + uint16 number_of_layers; + uint8 new_palette; // Set to non zero to start the + // palette held within layer file + // fading up after a build_display + uint8 scroll_flag; // Scroll mode 0 off 1 on + bool mask_flag; // Using shading mask +}; + +// The SpriteInfo structure is used to tell the driver96 code what attributes +// are linked to a sprite for drawing. These include position, scaling and +// compression. + +struct SpriteInfo { + int16 x; // coords for top-left of sprite + int16 y; + uint16 w; // dimensions of sprite (before scaling) + uint16 h; + uint16 scale; // scale at which to draw, given in 256ths ['0' or '256' MEANS DON'T SCALE] + uint16 scaledWidth; // new dimensions (we calc these for the mouse area, so may as well pass to you to save time) + uint16 scaledHeight; // + uint16 type; // mask containing 'RDSPR_' bits specifying compression type, flip, transparency, etc + uint16 blend; // holds the blending values. + byte *data; // pointer to the sprite data + byte *colourTable; // pointer to 16-byte colour table, only applicable to 16-col compression type +}; + +struct BlockSurface { + byte data[BLOCKWIDTH * BLOCKHEIGHT]; + bool transparent; +}; + +struct Parallax { + uint16 w; + uint16 h; + + // The dimensions are followed by an offset table, but we don't know in + // advance how big it is. See initializeBackgroundLayer(). + + static const int size() { + return 4; + } + + void read(byte *addr) { + Common::MemoryReadStream readS(addr, size()); + + w = readS.readUint16LE(); + h = readS.readUint16LE(); + } + + void write(byte *addr) { + Common::MemoryWriteStream writeS(addr, size()); + + writeS.writeUint16LE(w); + writeS.writeUint16LE(h); + } +}; + +class Screen { +private: + Sword2Engine *_vm; + + // _thisScreen describes the current back buffer and its in-game scroll + // positions, etc. + + ScreenInfo _thisScreen; + + int32 _renderCaps; + int8 _renderLevel; + + byte *_buffer; + byte *_lightMask; + + // Game screen metrics + int16 _screenWide; + int16 _screenDeep; + + bool _needFullRedraw; + + // Scroll variables. _scrollX and _scrollY hold the current scroll + // position, and _scrollXTarget and _scrollYTarget are the target + // position for the end of the game cycle. + + int16 _scrollX; + int16 _scrollY; + + int16 _scrollXTarget; + int16 _scrollYTarget; + int16 _scrollXOld; + int16 _scrollYOld; + + int16 _parallaxScrollX; // current x offset to link a sprite to the + // parallax layer + int16 _parallaxScrollY; // current y offset to link a sprite to the + // parallax layer + int16 _locationWide; + int16 _locationDeep; + + // Dirty grid handling + byte *_dirtyGrid; + + uint16 _gridWide; + uint16 _gridDeep; + + byte _palette[256 * 4]; + byte _paletteMatch[PALTABLESIZE]; + + uint8 _fadeStatus; + int32 _fadeStartTime; + int32 _fadeTotalTime; + + // 'frames per second' counting stuff + uint32 _fps; + uint32 _cycleTime; + uint32 _frameCount; + + int32 _initialTime; + int32 _startTime; + int32 _totalTime; + int32 _renderAverageTime; + int32 _framesPerGameCycle; + bool _renderTooSlow; + + void startNewPalette(); + + void resetRenderEngine(); + + void startRenderCycle(); + bool endRenderCycle(); + + // Holds the order of the sort list, i.e. the list stays static and we + // sort this array. + + uint16 _sortOrder[MAX_sort_sprites]; + + BuildUnit _bgp0List[MAX_bgp0_sprites]; + BuildUnit _bgp1List[MAX_bgp1_sprites]; + BuildUnit _backList[MAX_back_sprites]; + BuildUnit _sortList[MAX_sort_sprites]; + BuildUnit _foreList[MAX_fore_sprites]; + BuildUnit _fgp0List[MAX_fgp0_sprites]; + BuildUnit _fgp1List[MAX_fgp1_sprites]; + + uint32 _curBgp0; + uint32 _curBgp1; + uint32 _curBack; + uint32 _curSort; + uint32 _curFore; + uint32 _curFgp0; + uint32 _curFgp1; + + void drawBackPar0Frames(); + void drawBackPar1Frames(); + void drawBackFrames(); + void drawSortFrames(byte *file); + void drawForeFrames(); + void drawForePar0Frames(); + void drawForePar1Frames(); + + void processLayer(byte *file, uint32 layer_number); + void processImage(BuildUnit *build_unit); + + uint8 _scrollFraction; + + // Last palette used - so that we can restore the correct one after a + // pause (which dims the screen) and it's not always the main screen + // palette that we want, eg. during the eclipse + + // This flag gets set in startNewPalette() and setFullPalette() + + uint32 _lastPaletteRes; + + // Debugging stuff + uint32 _largestLayerArea; + uint32 _largestSpriteArea; + char _largestLayerInfo[128]; + char _largestSpriteInfo[128]; + + void registerFrame(byte *ob_mouse, byte *ob_graph, byte *ob_mega, BuildUnit *build_unit); + + void mirrorSprite(byte *dst, byte *src, int16 w, int16 h); + int32 decompressRLE256(byte *dst, byte *src, int32 decompSize); + void unwindRaw16(byte *dst, byte *src, uint8 blockSize, byte *colTable); + int32 decompressRLE16(byte *dst, byte *src, int32 decompSize, byte *colTable); + void renderParallax(byte *ptr, int16 layer); + + void markAsDirty(int16 x0, int16 y0, int16 x1, int16 y1); + + uint8 _xBlocks[MAXLAYERS]; + uint8 _yBlocks[MAXLAYERS]; + + // An array of sub-blocks, one for each of the parallax layers. + + BlockSurface **_blockSurfaces[MAXLAYERS]; + + uint16 _xScale[SCALE_MAXWIDTH]; + uint16 _yScale[SCALE_MAXHEIGHT]; + + void blitBlockSurface(BlockSurface *s, Common::Rect *r, Common::Rect *clipRect); + + uint16 _layer; + +public: + Screen(Sword2Engine *vm, int16 width, int16 height); + ~Screen(); + + int8 getRenderLevel(); + void setRenderLevel(int8 level); + + byte *getScreen() { return _buffer; } + byte *getPalette() { return _palette; } + ScreenInfo *getScreenInfo() { return &_thisScreen; } + + int16 getScreenWide() { return _screenWide; } + int16 getScreenDeep() { return _screenDeep; } + + uint32 getCurBgp0() { return _curBgp0; } + uint32 getCurBgp1() { return _curBgp1; } + uint32 getCurBack() { return _curBack; } + uint32 getCurSort() { return _curSort; } + uint32 getCurFore() { return _curFore; } + uint32 getCurFgp0() { return _curFgp0; } + uint32 getCurFgp1() { return _curFgp1; } + + uint32 getFps() { return _fps; } + + uint32 getLargestLayerArea() { return _largestLayerArea; } + uint32 getLargestSpriteArea() { return _largestSpriteArea; } + char *getLargestLayerInfo() { return _largestLayerInfo; } + char *getLargestSpriteInfo() { return _largestSpriteInfo; } + + void setNeedFullRedraw(); + + void clearScene(); + + void resetRenderLists(); + + void setLocationMetrics(uint16 w, uint16 h); + int32 initialiseBackgroundLayer(byte *parallax); + void closeBackgroundLayer(); + + void initialiseRenderCycle(); + + void initBackground(int32 res, int32 new_palette); + void registerFrame(byte *ob_mouse, byte *ob_graph, byte *ob_mega); + + void setScrollFraction(uint8 f) { _scrollFraction = f; } + void setScrollTarget(int16 x, int16 y); + void setScrolling(); + + void setFullPalette(int32 palRes); + void setPalette(int16 startEntry, int16 noEntries, byte *palette, uint8 setNow); + uint8 quickMatch(uint8 r, uint8 g, uint8 b); + int32 fadeUp(float time = 0.75); + int32 fadeDown(float time = 0.75); + uint8 getFadeStatus(); + void dimPalette(); + void waitForFade(); + void fadeServer(); + + void updateDisplay(bool redrawScene = true); + + void displayMsg(byte *text, int time); + + int32 createSurface(SpriteInfo *s, byte **surface); + void drawSurface(SpriteInfo *s, byte *surface, Common::Rect *clipRect = NULL); + void deleteSurface(byte *surface); + int32 drawSprite(SpriteInfo *s); + + void scaleImageFast(byte *dst, uint16 dstPitch, uint16 dstWidth, + uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth, + uint16 srcHeight); + void scaleImageGood(byte *dst, uint16 dstPitch, uint16 dstWidth, + uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth, + uint16 srcHeight, byte *backbuf); + + void updateRect(Common::Rect *r); + + int32 openLightMask(SpriteInfo *s); + int32 closeLightMask(); + + void buildDisplay(); + + void plotPoint(int x, int y, uint8 colour); + void drawLine(int x0, int y0, int x1, int y1, uint8 colour); + +#ifdef BACKEND_8BIT + void plotYUV(byte *lut, int width, int height, byte *const *dat); +#endif + + void rollCredits(); + void splashScreen(); +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/console.cpp b/engines/sword2/console.cpp new file mode 100644 index 0000000000..b465dc369f --- /dev/null +++ b/engines/sword2/console.cpp @@ -0,0 +1,826 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/console.h" +#include "sword2/logic.h" +#include "sword2/maketext.h" +#include "sword2/memory.h" +#include "sword2/mouse.h" +#include "sword2/resman.h" +#include "sword2/sound.h" + +#include "common/debugger.cpp" + +namespace Sword2 { + +Debugger::Debugger(Sword2Engine *vm) + : Common::Debugger<Debugger>() { + _vm = vm; + + memset(_debugTextBlocks, 0, sizeof(_debugTextBlocks)); + memset(_showVar, 0, sizeof(_showVar)); + + _displayDebugText = false; // "INFO" + _displayWalkGrid = false; // "WALKGRID" + _displayMouseMarker = false; // "MOUSE" + _displayTime = false; // "TIME" + _displayPlayerMarker = false; // "PLAYER" + _displayTextNumbers = false; // "TEXT" + + _definingRectangles = false; // "RECT" + _draggingRectangle = 0; // 0 = waiting to start new rect + // 1 = currently dragging a rectangle + + _rectX1 = _rectY1 = 0; + _rectX2 = _rectY2 = 0; + _rectFlicker = false; + + _testingSnR = false; // "SAVEREST" - for system to kill all + // object resources (except player) in + // fnAddHuman() + + _speechScriptWaiting = 0; // The id of whoever we're waiting for + // in a speech script. See fnTheyDo(), + // fnTheyDoWeWait(), fnWeWait(), and + // fnTimedWait(). + + _startTime = 0; // "TIMEON" & "TIMEOFF" - system start + // time + + _textNumber = 0; // Current system text line number + + _graphNoFrames = 0; // No. of frames in currently displayed + // anim + + // Register commands + + DCmd_Register("continue", &Debugger::Cmd_Exit); + DCmd_Register("exit", &Debugger::Cmd_Exit); + DCmd_Register("quit", &Debugger::Cmd_Exit); + DCmd_Register("q", &Debugger::Cmd_Exit); + DCmd_Register("help", &Debugger::Cmd_Help); + DCmd_Register("mem", &Debugger::Cmd_Mem); + DCmd_Register("tony", &Debugger::Cmd_Tony); + DCmd_Register("res", &Debugger::Cmd_Res); + DCmd_Register("reslist", &Debugger::Cmd_ResList); + DCmd_Register("starts", &Debugger::Cmd_Starts); + DCmd_Register("start", &Debugger::Cmd_Start); + DCmd_Register("s", &Debugger::Cmd_Start); + DCmd_Register("info", &Debugger::Cmd_Info); + DCmd_Register("walkgrid", &Debugger::Cmd_WalkGrid); + DCmd_Register("mouse", &Debugger::Cmd_Mouse); + DCmd_Register("player", &Debugger::Cmd_Player); + DCmd_Register("reslook", &Debugger::Cmd_ResLook); + DCmd_Register("cur", &Debugger::Cmd_CurrentInfo); + DCmd_Register("runlist", &Debugger::Cmd_RunList); + DCmd_Register("kill", &Debugger::Cmd_Kill); + DCmd_Register("nuke", &Debugger::Cmd_Nuke); + DCmd_Register("var", &Debugger::Cmd_Var); + DCmd_Register("rect", &Debugger::Cmd_Rect); + DCmd_Register("clear", &Debugger::Cmd_Clear); + DCmd_Register("debugon", &Debugger::Cmd_DebugOn); + DCmd_Register("debugoff", &Debugger::Cmd_DebugOff); + DCmd_Register("saverest", &Debugger::Cmd_SaveRest); + DCmd_Register("timeon", &Debugger::Cmd_TimeOn); + DCmd_Register("timeoff", &Debugger::Cmd_TimeOff); + DCmd_Register("text", &Debugger::Cmd_Text); + DCmd_Register("showvar", &Debugger::Cmd_ShowVar); + DCmd_Register("hidevar", &Debugger::Cmd_HideVar); + DCmd_Register("version", &Debugger::Cmd_Version); + DCmd_Register("animtest", &Debugger::Cmd_AnimTest); + DCmd_Register("texttest", &Debugger::Cmd_TextTest); + DCmd_Register("linetest", &Debugger::Cmd_LineTest); + DCmd_Register("events", &Debugger::Cmd_Events); + DCmd_Register("sfx", &Debugger::Cmd_Sfx); + DCmd_Register("english", &Debugger::Cmd_English); + DCmd_Register("finnish", &Debugger::Cmd_Finnish); + DCmd_Register("polish", &Debugger::Cmd_Polish); +} + +void Debugger::varGet(int var) { + DebugPrintf("%d\n", _vm->_logic->readVar(var)); +} + +void Debugger::varSet(int var, int val) { + DebugPrintf("was %d, ", _vm->_logic->readVar(var)); + _vm->_logic->writeVar(var, val); + DebugPrintf("now %d\n", _vm->_logic->readVar(var)); +} + +void Debugger::preEnter() { + // Pause sound output + if (_vm->_sound) { + _vm->_sound->pauseFx(); + _vm->_sound->pauseSpeech(); + _vm->_sound->pauseMusic(); + } +} + +void Debugger::postEnter() { + if (_vm->_sound) { + // Resume previous sound state + _vm->_sound->unpauseFx(); + _vm->_sound->unpauseSpeech(); + _vm->_sound->unpauseMusic(); + } + + if (_vm->_mouse) { + // Restore old mouse cursor + _vm->_mouse->drawMouse(); + } +} + +// Now the fun stuff: Commands + +bool Debugger::Cmd_Exit(int argc, const char **argv) { + _detach_now = true; + _vm->clearInputEvents(); + return false; +} + +bool Debugger::Cmd_Help(int argc, const char **argv) { + // console normally has 78 line width + // wrap around nicely + int width = 0; + + DebugPrintf("Commands are:\n"); + for (int i = 0 ; i < _dcmd_count ; i++) { + int size = strlen(_dcmds[i].name) + 1; + + if (width + size >= 75) { + DebugPrintf("\n"); + width = size; + } else + width += size; + + DebugPrintf("%s ", _dcmds[i].name); + } + + DebugPrintf("\n"); + return true; +} + +static int compare_blocks(const void *p1, const void *p2) { + const MemBlock *m1 = *(const MemBlock * const *)p1; + const MemBlock *m2 = *(const MemBlock * const *)p2; + + if (m1->size < m2->size) + return 1; + if (m1->size > m2->size) + return -1; + return 0; +} + +bool Debugger::Cmd_Mem(int argc, const char **argv) { + int16 numBlocks = _vm->_memory->getNumBlocks(); + MemBlock *memBlocks = _vm->_memory->getMemBlocks(); + + MemBlock **blocks = (MemBlock **)malloc(numBlocks * sizeof(MemBlock)); + + int i, j; + + for (i = 0, j = 0; i < MAX_MEMORY_BLOCKS; i++) { + if (memBlocks[i].ptr) + blocks[j++] = &memBlocks[i]; + } + + qsort(blocks, numBlocks, sizeof(MemBlock *), compare_blocks); + + DebugPrintf(" size id res type name\n"); + DebugPrintf("---------------------------------------------------------------------------\n"); + + for (i = 0; i < numBlocks; i++) { + const char *type; + + switch (_vm->_resman->fetchType(blocks[i]->ptr)) { + case ANIMATION_FILE: + type = "ANIMATION_FILE"; + break; + case SCREEN_FILE: + type = "SCREEN_FILE"; + break; + case GAME_OBJECT: + type = "GAME_OBJECT"; + break; + case WALK_GRID_FILE: + type = "WALK_GRID_FILE"; + break; + case GLOBAL_VAR_FILE: + type = "GLOBAL_VAR_FILE"; + break; + case PARALLAX_FILE_null: + type = "PARALLAX_FILE_null"; + break; + case RUN_LIST: + type = "RUN_LIST"; + break; + case TEXT_FILE: + type = "TEXT_FILE"; + break; + case SCREEN_MANAGER: + type = "SCREEN_MANAGER"; + break; + case MOUSE_FILE: + type = "MOUSE_FILE"; + break; + case WAV_FILE: + type = "WAV_FILE"; + break; + case ICON_FILE: + type = "ICON_FILE"; + break; + case PALETTE_FILE: + type = "PALETTE_FILE"; + break; + default: + type = "<unknown>"; + break; + } + + DebugPrintf("%9ld %-3d %-4d %-20s %s\n", blocks[i]->size, blocks[i]->id, blocks[i]->uid, type, _vm->_resman->fetchName(blocks[i]->ptr)); + } + + free(blocks); + + DebugPrintf("---------------------------------------------------------------------------\n"); + DebugPrintf("%9ld\n", _vm->_memory->getTotAlloc()); + + return true; +} + +bool Debugger::Cmd_Tony(int argc, const char **argv) { + DebugPrintf("What about him?\n"); + return true; +} + +bool Debugger::Cmd_Res(int argc, const char **argv) { + uint32 numClusters = _vm->_resman->getNumClusters(); + + if (!numClusters) { + DebugPrintf("Argh! No resources!\n"); + return true; + } + + ResourceFile *resFiles = _vm->_resman->getResFiles(); + + for (uint i = 0; i < numClusters; i++) { + const char *locStr[3] = { "HDD", "CD1", "CD2" }; + + DebugPrintf("%-20s %d\n", resFiles[i].fileName, locStr[resFiles[i].cd]); + } + + DebugPrintf("%d resources\n", _vm->_resman->getNumResFiles()); + return true; +} + +bool Debugger::Cmd_ResList(int argc, const char **argv) { + // By default, list only resources that are being held open. + uint minCount = 1; + + if (argc > 1) + minCount = atoi(argv[1]); + + uint32 numResFiles = _vm->_resman->getNumResFiles(); + Resource *resList = _vm->_resman->getResList(); + + for (uint i = 0; i < numResFiles; i++) { + if (resList[i].ptr && resList[i].refCount >= minCount) { + DebugPrintf("%-4d: %-35s refCount: %-3d\n", i, _vm->_resman->fetchName(resList[i].ptr), resList[i].refCount); + } + } + + return true; +} + +bool Debugger::Cmd_Starts(int argc, const char **argv) { + uint32 numStarts = _vm->getNumStarts(); + + if (!numStarts) { + DebugPrintf("Sorry - no startup positions registered?\n"); + + uint32 numScreenManagers = _vm->getNumScreenManagers(); + + if (!numScreenManagers) + DebugPrintf("There is a problem with startup.inf\n"); + else + DebugPrintf(" (%d screen managers found in startup.inf)\n", numScreenManagers); + return true; + } + + StartUp *startList = _vm->getStartList(); + + for (uint i = 0; i < numStarts; i++) + DebugPrintf("%d (%s)\n", i, startList[i].description); + + return true; +} + +bool Debugger::Cmd_Start(int argc, const char **argv) { + uint8 pal[4] = { 255, 255, 255, 0 }; + + if (argc != 2) { + DebugPrintf("Usage: %s number\n", argv[0]); + return true; + } + + uint32 numStarts = _vm->getNumStarts(); + + if (!numStarts) { + DebugPrintf("Sorry - there are no startups!\n"); + return true; + } + + int start = atoi(argv[1]); + + if (start < 0 || start >= (int)numStarts) { + DebugPrintf("Not a legal start position\n"); + return true; + } + + DebugPrintf("Running start %d\n", start); + + _vm->runStart(start); + _vm->_screen->setPalette(187, 1, pal, RDPAL_INSTANT); + return true; +} + +bool Debugger::Cmd_Info(int argc, const char **argv) { + _displayDebugText = !_displayDebugText; + + if (_displayDebugText) + DebugPrintf("Info text on\n"); + else + DebugPrintf("Info Text off\n"); + + return true; +} + +bool Debugger::Cmd_WalkGrid(int argc, const char **argv) { + _displayWalkGrid = !_displayWalkGrid; + + if (_displayWalkGrid) + DebugPrintf("Walk-grid display on\n"); + else + DebugPrintf("Walk-grid display off\n"); + + return true; +} + +bool Debugger::Cmd_Mouse(int argc, const char **argv) { + _displayMouseMarker = !_displayMouseMarker; + + if (_displayMouseMarker) + DebugPrintf("Mouse marker on\n"); + else + DebugPrintf("Mouse marker off\n"); + + return true; +} + +bool Debugger::Cmd_Player(int argc, const char **argv) { + _displayPlayerMarker = !_displayPlayerMarker; + + if (_displayPlayerMarker) + DebugPrintf("Player feet marker on\n"); + else + DebugPrintf("Player feet marker off\n"); + + return true; +} + +bool Debugger::Cmd_ResLook(int argc, const char **argv) { + if (argc != 2) { + DebugPrintf("Usage: %s number\n", argv[0]); + return true; + } + + int res = atoi(argv[1]); + uint32 numResFiles = _vm->_resman->getNumResFiles(); + + if (res < 0 || res >= (int)numResFiles) { + DebugPrintf("Illegal resource %d. There are %d resources, 0-%d.\n", + res, numResFiles, numResFiles - 1); + return true; + } + + if (!_vm->_resman->checkValid(res)) { + DebugPrintf("%d is a null & void resource number\n", res); + return true; + } + + // Open up the resource and take a look inside! + uint8 type = _vm->_resman->fetchType(res);; + byte name[NAME_LEN]; + + _vm->_resman->fetchName(res, name); + + switch (type) { + case ANIMATION_FILE: + DebugPrintf("<anim> %s\n", name); + break; + case SCREEN_FILE: + DebugPrintf("<layer> %s\n", name); + break; + case GAME_OBJECT: + DebugPrintf("<game object> %s\n", name); + break; + case WALK_GRID_FILE: + DebugPrintf("<walk grid> %s\n", name); + break; + case GLOBAL_VAR_FILE: + DebugPrintf("<global variables> %s\n", name); + break; + case PARALLAX_FILE_null: + DebugPrintf("<parallax file NOT USED!> %s\n", name); + break; + case RUN_LIST: + DebugPrintf("<run list> %s\n", name); + break; + case TEXT_FILE: + DebugPrintf("<text file> %s\n", name); + break; + case SCREEN_MANAGER: + DebugPrintf("<screen manager> %s\n", name); + break; + case MOUSE_FILE: + DebugPrintf("<mouse pointer> %s\n", name); + break; + case ICON_FILE: + DebugPrintf("<menu icon> %s\n", name); + break; + default: + DebugPrintf("unrecognised fileType %d\n", type); + break; + } + + return true; +} + +bool Debugger::Cmd_CurrentInfo(int argc, const char **argv) { + // prints general stuff about the screen, etc. + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + if (screenInfo->background_layer_id) { + DebugPrintf("background layer id %d\n", screenInfo->background_layer_id); + DebugPrintf("%d wide, %d high\n", screenInfo->screen_wide, screenInfo->screen_deep); + DebugPrintf("%d normal layers\n", screenInfo->number_of_layers); + + Cmd_RunList(argc, argv); + } else + DebugPrintf("No screen\n"); + return true; +} + +bool Debugger::Cmd_RunList(int argc, const char **argv) { + uint32 runList = _vm->_logic->getRunList(); + + if (runList) { + Common::MemoryReadStream readS(_vm->_resman->openResource(runList), _vm->_resman->fetchLen(runList)); + + readS.seek(ResHeader::size()); + + DebugPrintf("Runlist number %d\n", runList); + + while (1) { + uint32 res = readS.readUint32LE(); + if (!res) + break; + + byte name[NAME_LEN]; + + DebugPrintf("%d %s\n", res, _vm->_resman->fetchName(res, name)); + } + + _vm->_resman->closeResource(runList); + } else + DebugPrintf("No run list set\n"); + + return true; +} + +bool Debugger::Cmd_Kill(int argc, const char **argv) { + if (argc != 2) { + DebugPrintf("Usage: %s number\n", argv[0]); + return true; + } + + int res = atoi(argv[1]); + uint32 numResFiles = _vm->_resman->getNumResFiles(); + + if (res < 0 || res >= (int)numResFiles) { + DebugPrintf("Illegal resource %d. There are %d resources, 0-%d.\n", + res, numResFiles, numResFiles - 1); + return true; + } + + Resource *resList = _vm->_resman->getResList(); + + if (!resList[res].ptr) { + DebugPrintf("Resource %d is not in memory\n", res); + return true; + } + + if (resList[res].refCount) { + DebugPrintf("Resource %d is open - cannot remove\n", res); + return true; + } + + _vm->_resman->remove(res); + DebugPrintf("Trashed %d\n", res); + return true; +} + +bool Debugger::Cmd_Nuke(int argc, const char **argv) { + DebugPrintf("Killing all resources except variable file and player object\n"); + _vm->_resman->killAll(true); + return true; +} + +bool Debugger::Cmd_Var(int argc, const char **argv) { + switch (argc) { + case 2: + varGet(atoi(argv[1])); + break; + case 3: + varSet(atoi(argv[1]), atoi(argv[2])); + break; + default: + DebugPrintf("Usage: %s number value\n", argv[0]); + break; + } + + return true; +} + +bool Debugger::Cmd_Rect(int argc, const char **argv) { + uint32 filter = _vm->setInputEventFilter(0); + + _definingRectangles = !_definingRectangles; + + if (_definingRectangles) { + _vm->setInputEventFilter(filter & ~(RD_LEFTBUTTONUP | RD_RIGHTBUTTONUP)); + DebugPrintf("Mouse rectangles enabled\n"); + } else { + _vm->setInputEventFilter(filter | RD_LEFTBUTTONUP | RD_RIGHTBUTTONUP); + DebugPrintf("Mouse rectangles disabled\n"); + } + + _draggingRectangle = 0; + return true; +} + +bool Debugger::Cmd_Clear(int argc, const char **argv) { + _vm->_resman->killAllObjects(true); + return true; +} + +bool Debugger::Cmd_DebugOn(int argc, const char **argv) { + _displayDebugText = true; + _displayWalkGrid = true; + _displayMouseMarker = true; + _displayPlayerMarker = true; + _displayTextNumbers = true; + DebugPrintf("Enabled all on-screen debug info\n"); + return true; +} + +bool Debugger::Cmd_DebugOff(int argc, const char **argv) { + _displayDebugText = false; + _displayWalkGrid = false; + _displayMouseMarker = false; + _displayPlayerMarker = false; + _displayTextNumbers = false; + DebugPrintf("Disabled all on-screen debug info\n"); + return true; +} + +bool Debugger::Cmd_SaveRest(int argc, const char **argv) { + _testingSnR = !_testingSnR; + + if (_testingSnR) + DebugPrintf("Enabled S&R logic_script stability checking\n"); + else + DebugPrintf("Disabled S&R logic_script stability checking\n"); + + return true; +} + +bool Debugger::Cmd_TimeOn(int argc, const char **argv) { + if (argc == 2) + _startTime = _vm->_system->getMillis() - atoi(argv[1]) * 1000; + else if (_startTime == 0) + _startTime = _vm->_system->getMillis(); + _displayTime = true; + DebugPrintf("Timer display on\n"); + return true; +} + +bool Debugger::Cmd_TimeOff(int argc, const char **argv) { + _displayTime = false; + DebugPrintf("Timer display off\n"); + return true; +} + +bool Debugger::Cmd_Text(int argc, const char **argv) { + _displayTextNumbers = !_displayTextNumbers; + + if (_displayTextNumbers) + DebugPrintf("Text numbers on\n"); + else + DebugPrintf("Text numbers off\n"); + + return true; +} + +bool Debugger::Cmd_ShowVar(int argc, const char **argv) { + int32 showVarNo = 0; + int32 varNo; + + if (argc != 2) { + DebugPrintf("Usage: %s number\n", argv[0]); + return true; + } + + varNo = atoi(argv[1]); + + // search for a spare slot in the watch-list, but also watch out for + // this variable already being in the list + + while (showVarNo < MAX_SHOWVARS && _showVar[showVarNo] != 0 && _showVar[showVarNo] != varNo) + showVarNo++; + + // if we've found a spare slot or the variable's already there + if (showVarNo < MAX_SHOWVARS) { + if (_showVar[showVarNo] == 0) { + // empty slot - add it to the list at this slot + _showVar[showVarNo] = varNo; + DebugPrintf("var(%d) added to the watch-list\n", varNo); + } else + DebugPrintf("var(%d) already in the watch-list!\n", varNo); + } else + DebugPrintf("Sorry - no more allowed - hide one or extend the system watch-list\n"); + + return true; +} + +bool Debugger::Cmd_HideVar(int argc, const char **argv) { + int32 showVarNo = 0; + int32 varNo; + + if (argc != 2) { + DebugPrintf("Usage: %s number\n", argv[0]); + return true; + } + + varNo = atoi(argv[1]); + + // search for 'varNo' in the watch-list + while (showVarNo < MAX_SHOWVARS && _showVar[showVarNo] != varNo) + showVarNo++; + + if (showVarNo < MAX_SHOWVARS) { + // We've found 'varNo' in the list - clear this slot + _showVar[showVarNo] = 0; + DebugPrintf("var(%d) removed from watch-list\n", varNo); + } else + DebugPrintf("Sorry - can't find var(%d) in the list\n", varNo); + + return true; +} + +bool Debugger::Cmd_Version(int argc, const char **argv) { + // This function used to print more information, but nothing we + // particularly care about. + + DebugPrintf("\"Broken Sword II\" (c) Revolution Software 1997.\n"); + return true; +} + +bool Debugger::Cmd_AnimTest(int argc, const char **argv) { + if (argc != 2) { + DebugPrintf("Usage: %s value\n", argv[0]); + return true; + } + + // Automatically do "s 32" to run the animation testing start script + _vm->runStart(32); + + // Same as typing "VAR 912 <value>" at the console + varSet(912, atoi(argv[1])); + + DebugPrintf("Setting flag 'system_testing_anims'\n"); + return true; +} + +bool Debugger::Cmd_TextTest(int argc, const char **argv) { + if (argc != 2) { + DebugPrintf("Usage: %s value\n", argv[0]); + return true; + } + + // Automatically do "s 33" to run the text/speech testing start script + _vm->runStart(33); + + // Same as typing "VAR 1230 <value>" at the console + varSet(1230, atoi(argv[1])); + + _displayTextNumbers = true; + + DebugPrintf("Setting flag 'system_testing_text'\n"); + DebugPrintf("Text numbers on\n"); + return true; +} + +bool Debugger::Cmd_LineTest(int argc, const char **argv) { + if (argc != 3) { + DebugPrintf("Usage: %s value1 value2\n", argv[0]); + return true; + } + + // Automatically do "s 33" to run the text/speech testing start script + _vm->runStart(33); + + // Same as typing "VAR 1230 <value>" at the console + varSet(1230, atoi(argv[1])); + + // Same as typing "VAR 1264 <value>" at the console + varSet(1264, atoi(argv[2])); + + _displayTextNumbers = true; + + DebugPrintf("Setting flag 'system_testing_text'\n"); + DebugPrintf("Setting flag 'system_test_line_no'\n"); + DebugPrintf("Text numbers on\n"); + return true; +} + +bool Debugger::Cmd_Events(int argc, const char **argv) { + EventUnit *eventList = _vm->_logic->getEventList(); + + DebugPrintf("EVENT LIST:\n"); + + for (uint32 i = 0; i < MAX_events; i++) { + if (eventList[i].id) { + byte buf[NAME_LEN]; + uint32 target = eventList[i].id; + uint32 script = eventList[i].interact_id; + + DebugPrintf("slot %2d: id = %s (%d)\n", i, _vm->_resman->fetchName(target, buf), target); + DebugPrintf(" script = %s (%d) pos %d\n", _vm->_resman->fetchName(script / 65536, buf), script / 65536, script % 65536); + } + } + + return true; +} + +bool Debugger::Cmd_Sfx(int argc, const char **argv) { + _vm->_wantSfxDebug = !_vm->_wantSfxDebug; + + if (_vm->_wantSfxDebug) + DebugPrintf("SFX logging activated\n"); + else + DebugPrintf("SFX logging deactivated\n"); + + return true; +} + +bool Debugger::Cmd_English(int argc, const char **argv) { + _vm->initialiseFontResourceFlags(DEFAULT_TEXT); + DebugPrintf("Default fonts selected\n"); + return true; +} + +bool Debugger::Cmd_Finnish(int argc, const char **argv) { + _vm->initialiseFontResourceFlags(FINNISH_TEXT); + DebugPrintf("Finnish fonts selected\n"); + return true; +} + +bool Debugger::Cmd_Polish(int argc, const char **argv) { + _vm->initialiseFontResourceFlags(POLISH_TEXT); + DebugPrintf("Polish fonts selected\n"); + return true; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/console.h b/engines/sword2/console.h new file mode 100644 index 0000000000..95bfbe946d --- /dev/null +++ b/engines/sword2/console.h @@ -0,0 +1,127 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef C_ONSOLE_H +#define C_ONSOLE_H + +#include "common/debugger.h" +#include "sword2/debug.h" + +namespace Sword2 { + +class Debugger : public Common::Debugger<Debugger> { +private: + void varGet(int var); + void varSet(int var, int val); + + bool _displayDebugText; + bool _displayWalkGrid; + bool _displayMouseMarker; + bool _displayTime; + bool _displayPlayerMarker; + bool _displayTextNumbers; + + bool _rectFlicker; + + int32 _startTime; + + int32 _showVar[MAX_SHOWVARS]; + + byte _debugTextBlocks[MAX_DEBUG_TEXTS]; + + void clearDebugTextBlocks(); + void makeDebugTextBlock(char *text, int16 x, int16 y); + + void plotCrossHair(int16 x, int16 y, uint8 pen); + void drawRect(int16 x, int16 y, int16 x2, int16 y2, uint8 pen); + +public: + Debugger(Sword2Engine *vm); + + int16 _rectX1, _rectY1; + int16 _rectX2, _rectY2; + + uint8 _draggingRectangle; + bool _definingRectangles; + + bool _testingSnR; + + int32 _speechScriptWaiting; + + int32 _textNumber; + + int32 _graphType; + int32 _graphAnimRes; + int32 _graphAnimPc; + uint32 _graphNoFrames; + + void buildDebugText(); + void drawDebugGraphics(); + +protected: + Sword2Engine *_vm; + + virtual void preEnter(); + virtual void postEnter(); + + // Commands + bool Cmd_Exit(int argc, const char **argv); + bool Cmd_Help(int argc, const char **argv); + bool Cmd_Mem(int argc, const char **argv); + bool Cmd_Tony(int argc, const char **argv); + bool Cmd_Res(int argc, const char **argv); + bool Cmd_ResList(int argc, const char **argv); + bool Cmd_Starts(int argc, const char **argv); + bool Cmd_Start(int argc, const char **argv); + bool Cmd_Info(int argc, const char **argv); + bool Cmd_WalkGrid(int argc, const char **argv); + bool Cmd_Mouse(int argc, const char **argv); + bool Cmd_Player(int argc, const char **argv); + bool Cmd_ResLook(int argc, const char **argv); + bool Cmd_CurrentInfo(int argc, const char **argv); + bool Cmd_RunList(int argc, const char **argv); + bool Cmd_Kill(int argc, const char **argv); + bool Cmd_Nuke(int argc, const char **argv); + bool Cmd_Var(int argc, const char **argv); + bool Cmd_Rect(int argc, const char **argv); + bool Cmd_Clear(int argc, const char **argv); + bool Cmd_DebugOn(int argc, const char **argv); + bool Cmd_DebugOff(int argc, const char **argv); + bool Cmd_SaveRest(int argc, const char **argv); + bool Cmd_TimeOn(int argc, const char **argv); + bool Cmd_TimeOff(int argc, const char **argv); + bool Cmd_Text(int argc, const char **argv); + bool Cmd_ShowVar(int argc, const char **argv); + bool Cmd_HideVar(int argc, const char **argv); + bool Cmd_Version(int argc, const char **argv); + bool Cmd_AnimTest(int argc, const char **argv); + bool Cmd_TextTest(int argc, const char **argv); + bool Cmd_LineTest(int argc, const char **argv); + bool Cmd_Events(int argc, const char **argv); + bool Cmd_Sfx(int argc, const char **argv); + bool Cmd_English(int argc, const char **argv); + bool Cmd_Finnish(int argc, const char **argv); + bool Cmd_Polish(int argc, const char **argv); +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/controls.cpp b/engines/sword2/controls.cpp new file mode 100644 index 0000000000..df1b38c83e --- /dev/null +++ b/engines/sword2/controls.cpp @@ -0,0 +1,1416 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "common/rect.h" +#include "common/config-manager.h" +#include "common/system.h" + +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/controls.h" +#include "sword2/mouse.h" +#include "sword2/resman.h" +#include "sword2/sound.h" + +#define MAX_STRING_LEN 64 // 20 was too low; better to be safe ;) +#define CHARACTER_OVERLAP 2 // overlap characters by 3 pixels + +// our fonts start on SPACE character (32) +#define SIZE_OF_CHAR_SET (256 - 32) + +namespace Sword2 { + +static int baseSlot = 0; + +class Widget; + +/** + * Base class for all widgets. + */ + +class Widget { +protected: + Sword2Engine *_vm; + Dialog *_parent; + + SpriteInfo *_sprites; + + struct WidgetSurface { + byte *_surface; + bool _original; + }; + + WidgetSurface *_surfaces; + int _numStates; + int _state; + + Common::Rect _hitRect; + +public: + Widget(Dialog *parent, int states); + + virtual ~Widget(); + + void createSurfaceImage(int state, uint32 res, int x, int y, uint32 pc); + void linkSurfaceImage(Widget *from, int state, int x, int y); + + void createSurfaceImages(uint32 res, int x, int y); + void linkSurfaceImages(Widget *from, int x, int y); + + void setHitRect(int x, int y, int width, int height); + bool isHit(int16 x, int16 y); + + void setState(int state); + int getState(); + + virtual void paint(Common::Rect *clipRect = NULL); + + virtual void onMouseEnter() {} + virtual void onMouseExit() {} + virtual void onMouseMove(int x, int y) {} + virtual void onMouseDown(int x, int y) {} + virtual void onMouseUp(int x, int y) {} + virtual void onWheelUp(int x, int y) {} + virtual void onWheelDown(int x, int y) {} + virtual void onKey(KeyboardEvent *ke) {} + virtual void onTick() {} + + virtual void releaseMouse(int x, int y) {} +}; + +/** + * This class is used to draw text in dialogs, buttons, etc. + */ + +class FontRendererGui { +private: + Sword2Engine *_vm; + + struct Glyph { + byte *_data; + int _width; + int _height; + }; + + Glyph _glyph[SIZE_OF_CHAR_SET]; + + int _fontId; + +public: + enum { + kAlignLeft, + kAlignRight, + kAlignCenter + }; + + FontRendererGui(Sword2Engine *vm, int fontId); + ~FontRendererGui(); + + void fetchText(uint32 textId, byte *buf); + + int getCharWidth(byte c); + int getCharHeight(byte c); + + int getTextWidth(byte *text); + int getTextWidth(uint32 textId); + + void drawText(byte *text, int x, int y, int alignment = kAlignLeft); + void drawText(uint32 textId, int x, int y, int alignment = kAlignLeft); +}; + +FontRendererGui::FontRendererGui(Sword2Engine *vm, int fontId) + : _vm(vm), _fontId(fontId) { + byte *font = _vm->_resman->openResource(fontId); + SpriteInfo sprite; + + sprite.type = RDSPR_NOCOMPRESSION | RDSPR_TRANS; + + for (int i = 0; i < SIZE_OF_CHAR_SET; i++) { + byte *frame = _vm->fetchFrameHeader(font, i); + + FrameHeader frame_head; + + frame_head.read(frame); + + sprite.data = frame + FrameHeader::size(); + sprite.w = frame_head.width; + sprite.h = frame_head.height; + _vm->_screen->createSurface(&sprite, &_glyph[i]._data); + _glyph[i]._width = frame_head.width; + _glyph[i]._height = frame_head.height; + } + + _vm->_resman->closeResource(fontId); +} + +FontRendererGui::~FontRendererGui() { + for (int i = 0; i < SIZE_OF_CHAR_SET; i++) + _vm->_screen->deleteSurface(_glyph[i]._data); +} + +void FontRendererGui::fetchText(uint32 textId, byte *buf) { + byte *data = _vm->fetchTextLine(_vm->_resman->openResource(textId / SIZE), textId & 0xffff); + int i; + + for (i = 0; data[i + 2]; i++) { + if (buf) + buf[i] = data[i + 2]; + } + + buf[i] = 0; + _vm->_resman->closeResource(textId / SIZE); +} + +int FontRendererGui::getCharWidth(byte c) { + if (c < 32) + return 0; + return _glyph[c - 32]._width; +} + +int FontRendererGui::getCharHeight(byte c) { + if (c < 32) + return 0; + return _glyph[c - 32]._height; +} + +int FontRendererGui::getTextWidth(byte *text) { + int textWidth = 0; + + for (int i = 0; text[i]; i++) + if (text[i] >= ' ') + textWidth += (getCharWidth(text[i]) - CHARACTER_OVERLAP); + return textWidth; +} + +int FontRendererGui::getTextWidth(uint32 textId) { + byte text[MAX_STRING_LEN]; + + fetchText(textId, text); + return getTextWidth(text); +} + +void FontRendererGui::drawText(byte *text, int x, int y, int alignment) { + SpriteInfo sprite; + int i; + + if (alignment != kAlignLeft) { + int textWidth = getTextWidth(text); + + switch (alignment) { + case kAlignRight: + x -= textWidth; + break; + case kAlignCenter: + x -= (textWidth / 2); + break; + } + } + + sprite.x = x; + sprite.y = y; + + for (i = 0; text[i]; i++) { + if (text[i] >= ' ') { + sprite.w = getCharWidth(text[i]); + sprite.h = getCharHeight(text[i]); + + _vm->_screen->drawSurface(&sprite, _glyph[text[i] - 32]._data); + + sprite.x += (getCharWidth(text[i]) - CHARACTER_OVERLAP); + } + } +} + +void FontRendererGui::drawText(uint32 textId, int x, int y, int alignment) { + byte text[MAX_STRING_LEN]; + + fetchText(textId, text); + drawText(text, x, y, alignment); +} + +// +// Dialog class functions +// + +Dialog::Dialog(Sword2Engine *vm) + : _numWidgets(0), _finish(false), _result(0), _vm(vm) { + _vm->_screen->setFullPalette(CONTROL_PANEL_PALETTE); + _vm->_screen->clearScene(); + _vm->_screen->updateDisplay(); + + // Usually the mouse pointer will already be "normal", but not always. + _vm->_mouse->setMouse(NORMAL_MOUSE_ID); +} + +Dialog::~Dialog() { + for (int i = 0; i < _numWidgets; i++) + delete _widgets[i]; + _vm->_screen->clearScene(); + _vm->_screen->updateDisplay(); +} + +void Dialog::registerWidget(Widget *widget) { + if (_numWidgets < MAX_WIDGETS) + _widgets[_numWidgets++] = widget; +} + +void Dialog::paint() { + _vm->_screen->clearScene(); + for (int i = 0; i < _numWidgets; i++) + _widgets[i]->paint(); +} + +void Dialog::setResult(int result) { + _result = result; + _finish = true; +} + +int Dialog::runModal() { + uint32 oldFilter = _vm->setInputEventFilter(0); + + int i; + + paint(); + + int oldMouseX = -1; + int oldMouseY = -1; + + while (!_finish) { + // So that the menu icons will reach their full size + _vm->_mouse->processMenu(); + _vm->_screen->updateDisplay(false); + + int newMouseX, newMouseY; + + _vm->_mouse->getPos(newMouseX, newMouseY); + + newMouseY += 40; + + MouseEvent *me = _vm->mouseEvent(); + KeyboardEvent *ke = _vm->keyboardEvent(); + + if (ke) { + if (ke->keycode == 27) + setResult(0); + else if (ke->keycode == '\n' || ke->keycode == '\r') + setResult(1); + } + + int oldHit = -1; + int newHit = -1; + + // Find out which widget the mouse was over the last time, and + // which it is currently over. This assumes the widgets do not + // overlap. + + for (i = 0; i < _numWidgets; i++) { + if (_widgets[i]->isHit(oldMouseX, oldMouseY)) + oldHit = i; + if (_widgets[i]->isHit(newMouseX, newMouseY)) + newHit = i; + } + + // Was the mouse inside a widget the last time? + + if (oldHit >= 0) { + if (newHit != oldHit) + _widgets[oldHit]->onMouseExit(); + } + + // Is the mouse currently in a widget? + + if (newHit >= 0) { + if (newHit != oldHit) + _widgets[newHit]->onMouseEnter(); + + if (me) { + switch (me->buttons) { + case RD_LEFTBUTTONDOWN: + _widgets[newHit]->onMouseDown(newMouseX, newMouseY); + break; + case RD_LEFTBUTTONUP: + _widgets[newHit]->onMouseUp(newMouseX, newMouseY); + break; + case RD_WHEELUP: + _widgets[newHit]->onWheelUp(newMouseX, newMouseY); + break; + case RD_WHEELDOWN: + _widgets[newHit]->onWheelDown(newMouseX, newMouseY); + break; + } + } + } + + // Some events are passed to the widgets regardless of where + // the mouse cursor is. + + for (i = 0; i < _numWidgets; i++) { + if (me && me->buttons == RD_LEFTBUTTONUP) { + // So that slider widgets will know when the + // user releases the mouse button, even if the + // cursor is outside of the slider's hit area. + _widgets[i]->releaseMouse(newMouseX, newMouseY); + } + + // This is to make it easier to drag the slider widget + + if (newMouseX != oldMouseX || newMouseY != oldMouseY) + _widgets[i]->onMouseMove(newMouseX, newMouseY); + + if (ke) + _widgets[i]->onKey(ke); + + _widgets[i]->onTick(); + } + + oldMouseX = newMouseX; + oldMouseY = newMouseY; + + _vm->_system->delayMillis(20); + + if (_vm->_quit) + setResult(0); + } + + _vm->setInputEventFilter(oldFilter); + return _result; +} + +// +// Widget functions +// + +Widget::Widget(Dialog *parent, int states) + : _vm(parent->_vm), _parent(parent), _numStates(states), _state(0) { + _sprites = (SpriteInfo *)calloc(states, sizeof(SpriteInfo)); + _surfaces = (WidgetSurface *)calloc(states, sizeof(WidgetSurface)); + + _hitRect.left = _hitRect.right = _hitRect.top = _hitRect.bottom = -1; +} + +Widget::~Widget() { + for (int i = 0; i < _numStates; i++) { + if (_surfaces[i]._original) + _vm->_screen->deleteSurface(_surfaces[i]._surface); + } + free(_sprites); + free(_surfaces); +} + +void Widget::createSurfaceImage(int state, uint32 res, int x, int y, uint32 pc) { + byte *file, *colTablePtr = NULL; + AnimHeader anim_head; + FrameHeader frame_head; + CdtEntry cdt_entry; + uint32 spriteType = RDSPR_TRANS; + + // open anim resource file, point to base + file = _vm->_resman->openResource(res); + + byte *frame = _vm->fetchFrameHeader(file, pc); + + anim_head.read(_vm->fetchAnimHeader(file)); + cdt_entry.read(_vm->fetchCdtEntry(file, pc)); + frame_head.read(frame); + + // If the frame is flipped. (Only really applicable to frames using + // offsets.) + + if (cdt_entry.frameType & FRAME_FLIPPED) + spriteType |= RDSPR_FLIP; + + // Which compression was used? + + switch (anim_head.runTimeComp) { + case NONE: + spriteType |= RDSPR_NOCOMPRESSION; + break; + case RLE256: + spriteType |= RDSPR_RLE256; + break; + case RLE16: + spriteType |= RDSPR_RLE256; + // Points to just after last cdt_entry, i.e. start of colour + // table + colTablePtr = _vm->fetchAnimHeader(file) + AnimHeader::size() + + anim_head.noAnimFrames * CdtEntry::size(); + break; + } + + _sprites[state].x = x; + _sprites[state].y = y; + _sprites[state].w = frame_head.width; + _sprites[state].h = frame_head.height; + _sprites[state].scale = 0; + _sprites[state].type = spriteType; + _sprites[state].blend = anim_head.blend; + + // Points to just after frame header, ie. start of sprite data + _sprites[state].data = frame + FrameHeader::size(); + + _vm->_screen->createSurface(&_sprites[state], &_surfaces[state]._surface); + _surfaces[state]._original = true; + + // Release the anim resource + _vm->_resman->closeResource(res); +} + +void Widget::linkSurfaceImage(Widget *from, int state, int x, int y) { + _sprites[state].x = x; + _sprites[state].y = y; + _sprites[state].w = from->_sprites[state].w; + _sprites[state].h = from->_sprites[state].h; + _sprites[state].scale = from->_sprites[state].scale; + _sprites[state].type = from->_sprites[state].type; + _sprites[state].blend = from->_sprites[state].blend; + + _surfaces[state]._surface = from->_surfaces[state]._surface; + _surfaces[state]._original = false; +} + +void Widget::createSurfaceImages(uint32 res, int x, int y) { + for (int i = 0; i < _numStates; i++) + createSurfaceImage(i, res, x, y, i); +} + +void Widget::linkSurfaceImages(Widget *from, int x, int y) { + for (int i = 0; i < from->_numStates; i++) + linkSurfaceImage(from, i, x, y); +} + +void Widget::setHitRect(int x, int y, int width, int height) { + _hitRect.left = x; + _hitRect.right = x + width; + _hitRect.top = y; + _hitRect.bottom = y + height; +} + +bool Widget::isHit(int16 x, int16 y) { + return _hitRect.left >= 0 && _hitRect.contains(x, y); +} + +void Widget::setState(int state) { + if (state != _state) { + _state = state; + paint(); + } +} + +int Widget::getState() { + return _state; +} + +void Widget::paint(Common::Rect *clipRect) { + _vm->_screen->drawSurface(&_sprites[_state], _surfaces[_state]._surface, clipRect); +} + +/** + * Standard button class. + */ + +class Button : public Widget { +public: + Button(Dialog *parent, int x, int y, int w, int h) + : Widget(parent, 2) { + setHitRect(x, y, w, h); + } + + virtual void onMouseExit() { + setState(0); + } + + virtual void onMouseDown(int x, int y) { + setState(1); + } + + virtual void onMouseUp(int x, int y) { + if (getState() != 0) { + setState(0); + _parent->onAction(this); + } + } +}; + +/** + * Scroll buttons are used to scroll the savegame list. The difference between + * this and a normal button is that we want this to repeat. + */ + +class ScrollButton : public Widget { +private: + uint32 _holdCounter; + +public: + ScrollButton(Dialog *parent, int x, int y, int w, int h) + : Widget(parent, 2), _holdCounter(0) { + setHitRect(x, y, w, h); + } + + virtual void onMouseExit() { + setState(0); + } + + virtual void onMouseDown(int x, int y) { + setState(1); + _parent->onAction(this); + _holdCounter = 0; + } + + virtual void onMouseUp(int x, int y) { + setState(0); + } + + virtual void onTick() { + if (getState() != 0) { + _holdCounter++; + if (_holdCounter > 16 && (_holdCounter % 4) == 0) + _parent->onAction(this); + } + } +}; + +/** + * A switch is a button that changes state when clicked, and keeps that state + * until clicked again. + */ + +class Switch : public Widget { +private: + bool _holding, _value; + int _upState, _downState; + +public: + Switch(Dialog *parent, int x, int y, int w, int h) + : Widget(parent, 2), _holding(false), _value(false), + _upState(0), _downState(1) { + setHitRect(x, y, w, h); + } + + // The sound mute switches have 0 as their "down" state and 1 as + // their "up" state, so this function is needed to get consistent + // behaviour. + + void reverseStates() { + _upState = 1; + _downState = 0; + } + + void setValue(bool value) { + _value = value; + if (_value) + setState(_downState); + else + setState(_upState); + } + + bool getValue() { + return _value; + } + + virtual void onMouseExit() { + if (_holding && !_value) + setState(_upState); + _holding = false; + } + + virtual void onMouseDown(int x, int y) { + _holding = true; + setState(_downState); + } + + virtual void onMouseUp(int x, int y) { + if (_holding) { + _holding = false; + _value = !_value; + if (_value) + setState(_downState); + else + setState(_upState); + _parent->onAction(this, getState()); + } + } +}; + +/** + * A slider is used to specify a value within a pre-defined range. + */ + +class Slider : public Widget { +private: + Widget *_background; + bool _dragging; + int _value, _targetValue; + int _maxValue; + int _valueStep; + int _dragOffset; + + int posFromValue(int value) { + return _hitRect.left + (value * (_hitRect.width() - 38)) / _maxValue; + } + + int valueFromPos(int x) { + return (int)((double)(_maxValue * (x - _hitRect.left)) / (double)(_hitRect.width() - 38) + 0.5); + } + +public: + Slider(Dialog *parent, Widget *background, int max, + int x, int y, int w, int h, int step, Widget *base = NULL) + : Widget(parent, 1), _background(background), + _dragging(false), _value(0), _targetValue(0), + _maxValue(max), _valueStep(step) { + setHitRect(x, y, w, h); + + if (_valueStep <= 0) + _valueStep = 1; + + if (base) + linkSurfaceImages(base, x, y); + else + createSurfaceImages(3406, x, y); + } + + virtual void paint(Common::Rect *clipRect = NULL) { + // This will redraw a bit more than is strictly necessary, + // but I doubt that will make any noticeable difference. + + _background->paint(&_hitRect); + Widget::paint(clipRect); + } + + void setValue(int value) { + _value = value; + _targetValue = value; + _sprites[0].x = posFromValue(_value); + paint(); + } + + int getValue() { + return _value; + } + + virtual void onMouseMove(int x, int y) { + if (_dragging) { + int newX = x - _dragOffset; + int newValue; + + if (newX < _hitRect.left) + newX = _hitRect.left; + else if (newX + 38 > _hitRect.right) + newX = _hitRect.right - 38; + + _sprites[0].x = newX; + + newValue = valueFromPos(newX); + if (newValue != _value) { + _value = newValue; + _targetValue = newValue; + _parent->onAction(this, newValue); + } + + paint(); + } + } + + virtual void onMouseDown(int x, int y) { + if (x >= _sprites[0].x && x < _sprites[0].x + 38) { + _dragging = true; + _dragOffset = x - _sprites[0].x; + } else if (x < _sprites[0].x) { + if (_targetValue >= _valueStep) + _targetValue -= _valueStep; + else + _targetValue = 0; + } else { + if (_targetValue < _maxValue - _valueStep) + _targetValue += _valueStep; + else + _targetValue = _maxValue; + } + } + + virtual void releaseMouse(int x, int y) { + if (_dragging) + _dragging = false; + } + + virtual void onTick() { + if (!_dragging) { + int target = posFromValue(_targetValue); + + if (target != _sprites[0].x) { + if (target < _sprites[0].x) { + _sprites[0].x -= 4; + if (_sprites[0].x < target) + _sprites[0].x = target; + } else if (target > _sprites[0].x) { + _sprites[0].x += 4; + if (_sprites[0].x > target) + _sprites[0].x = target; + } + + int newValue = valueFromPos(_sprites[0].x); + if (newValue != _value) { + _value = newValue; + _parent->onAction(this, newValue); + } + + paint(); + } + } + } +}; + +/** + * The "mini" dialog. + */ + +MiniDialog::MiniDialog(Sword2Engine *vm, uint32 headerTextId, uint32 okTextId, uint32 cancelTextId) : Dialog(vm) { + _headerTextId = headerTextId; + _okTextId = okTextId; + _cancelTextId = cancelTextId; + + _fr = new FontRendererGui(_vm, _vm->_controlsFontId); + + _panel = new Widget(this, 1); + _panel->createSurfaceImages(1996, 203, 104); + + _okButton = new Button(this, 243, 214, 24, 24); + _okButton->createSurfaceImages(2002, 243, 214); + + _cancelButton = new Button(this, 243, 276, 24, 24); + _cancelButton->linkSurfaceImages(_okButton, 243, 276); + + registerWidget(_panel); + registerWidget(_okButton); + registerWidget(_cancelButton); +} + +MiniDialog::~MiniDialog() { + delete _fr; +} + +void MiniDialog::paint() { + Dialog::paint(); + + if (_headerTextId) + _fr->drawText(_headerTextId, 310, 134, FontRendererGui::kAlignCenter); + _fr->drawText(_okTextId, 270, 214); + _fr->drawText(_cancelTextId, 270, 276); +} + +void MiniDialog::onAction(Widget *widget, int result) { + if (widget == _okButton) + setResult(1); + else if (widget == _cancelButton) + setResult(0); +} + +StartDialog::StartDialog(Sword2Engine *vm) : MiniDialog(vm, 0) {} + +int StartDialog::runModal() { + while (1) { + MiniDialog startDialog(_vm, 0, TEXT_RESTART, TEXT_RESTORE); + + if (startDialog.runModal()) + return 1; + + if (_vm->_quit) + return 0; + + RestoreDialog restoreDialog(_vm); + + if (restoreDialog.runModal()) + return 0; + + if (_vm->_quit) + return 0; + } + + return 1; +} + +/** + * The restart dialog. + */ + +RestartDialog::RestartDialog(Sword2Engine *vm) : MiniDialog(vm, TEXT_RESTART) {} + +int RestartDialog::runModal() { + int result = MiniDialog::runModal(); + + if (result) + _vm->restartGame(); + + return result; +} + +/** + * The quit dialog. + */ + +QuitDialog::QuitDialog(Sword2Engine *vm) : MiniDialog(vm, TEXT_QUIT) {} + +int QuitDialog::runModal() { + int result = MiniDialog::runModal(); + + if (result) + _vm->closeGame(); + + return result; +} + +/** + * The game settings dialog. + */ + +OptionsDialog::OptionsDialog(Sword2Engine *vm) : Dialog(vm) { + _fr = new FontRendererGui(_vm, _vm->_controlsFontId); + + _mixer = _vm->_mixer; + + _panel = new Widget(this, 1); + _panel->createSurfaceImages(3405, 0, 40); + + _objectLabelsSwitch = new Switch(this, 304, 100, 53, 32); + _objectLabelsSwitch->createSurfaceImages(3687, 304, 100); + + _subtitlesSwitch = new Switch(this, 510, 100, 53, 32); + _subtitlesSwitch->linkSurfaceImages(_objectLabelsSwitch, 510, 100); + + _reverseStereoSwitch = new Switch(this, 304, 293, 53, 32); + _reverseStereoSwitch->linkSurfaceImages(_objectLabelsSwitch, 304, 293); + + _musicSwitch = new Switch(this, 516, 157, 40, 32); + _musicSwitch->createSurfaceImages(3315, 516, 157); + _musicSwitch->reverseStates(); + + _speechSwitch = new Switch(this, 516, 205, 40, 32); + _speechSwitch->linkSurfaceImages(_musicSwitch, 516, 205); + _speechSwitch->reverseStates(); + + _fxSwitch = new Switch(this, 516, 250, 40, 32); + _fxSwitch->linkSurfaceImages(_musicSwitch, 516, 250); + _fxSwitch->reverseStates(); + + int volStep = Audio::Mixer::kMaxMixerVolume / 10; + + _musicSlider = new Slider(this, _panel, Audio::Mixer::kMaxMixerVolume, 309, 161, 170, 27, volStep); + _speechSlider = new Slider(this, _panel, Audio::Mixer::kMaxMixerVolume, 309, 208, 170, 27, volStep, _musicSlider); + _fxSlider = new Slider(this, _panel, Audio::Mixer::kMaxMixerVolume, 309, 254, 170, 27, volStep, _musicSlider); + _gfxSlider = new Slider(this, _panel, 3, 309, 341, 170, 27, 1, _musicSlider); + + _gfxPreview = new Widget(this, 4); + _gfxPreview->createSurfaceImages(256, 495, 310); + + _okButton = new Button(this, 203, 382, 53, 32); + _okButton->createSurfaceImages(901, 203, 382); + + _cancelButton = new Button(this, 395, 382, 53, 32); + _cancelButton->linkSurfaceImages(_okButton, 395, 382); + + registerWidget(_panel); + registerWidget(_objectLabelsSwitch); + registerWidget(_subtitlesSwitch); + registerWidget(_reverseStereoSwitch); + registerWidget(_musicSwitch); + registerWidget(_speechSwitch); + registerWidget(_fxSwitch); + registerWidget(_musicSlider); + registerWidget(_speechSlider); + registerWidget(_fxSlider); + registerWidget(_gfxSlider); + registerWidget(_gfxPreview); + registerWidget(_okButton); + registerWidget(_cancelButton); + + _objectLabelsSwitch->setValue(_vm->_mouse->getObjectLabels()); + _subtitlesSwitch->setValue(_vm->getSubtitles()); + _reverseStereoSwitch->setValue(_vm->_sound->isReverseStereo()); + _musicSwitch->setValue(!_vm->_sound->isMusicMute()); + _speechSwitch->setValue(!_vm->_sound->isSpeechMute()); + _fxSwitch->setValue(!_vm->_sound->isFxMute()); + + _musicSlider->setValue(_mixer->getVolumeForSoundType(Audio::Mixer::kMusicSoundType)); + _speechSlider->setValue(_mixer->getVolumeForSoundType(Audio::Mixer::kSpeechSoundType)); + _fxSlider->setValue(_mixer->getVolumeForSoundType(Audio::Mixer::kSFXSoundType)); + + _gfxSlider->setValue(_vm->_screen->getRenderLevel()); + _gfxPreview->setState(_vm->_screen->getRenderLevel()); +} + +OptionsDialog::~OptionsDialog() { + delete _fr; +} + +void OptionsDialog::paint() { + Dialog::paint(); + + int maxWidth = 0; + int width; + + uint32 alignTextIds[] = { + TEXT_OBJECT_LABELS, + TEXT_MUSIC_VOLUME, + TEXT_SPEECH_VOLUME, + TEXT_FX_VOLUME, + TEXT_GFX_QUALITY, + TEXT_REVERSE_STEREO + }; + + for (int i = 0; i < ARRAYSIZE(alignTextIds); i++) { + width = _fr->getTextWidth(alignTextIds[i]); + if (width > maxWidth) + maxWidth = width; + } + + _fr->drawText(TEXT_OPTIONS, 321, 55, FontRendererGui::kAlignCenter); + _fr->drawText(TEXT_SUBTITLES, 500, 103, FontRendererGui::kAlignRight); + _fr->drawText(TEXT_OBJECT_LABELS, 299 - maxWidth, 103); + _fr->drawText(TEXT_MUSIC_VOLUME, 299 - maxWidth, 161); + _fr->drawText(TEXT_SPEECH_VOLUME, 299 - maxWidth, 208); + _fr->drawText(TEXT_FX_VOLUME, 299 - maxWidth, 254); + _fr->drawText(TEXT_REVERSE_STEREO, 299 - maxWidth, 296); + _fr->drawText(TEXT_GFX_QUALITY, 299 - maxWidth, 341); + _fr->drawText(TEXT_OK, 193, 382, FontRendererGui::kAlignRight); + _fr->drawText(TEXT_CANCEL, 385, 382, FontRendererGui::kAlignRight); +} + +void OptionsDialog::onAction(Widget *widget, int result) { + // Since there is music playing while the dialog is displayed we need + // to update music volume immediately. + + if (widget == _musicSwitch) { + _vm->_sound->muteMusic(result != 0); + } else if (widget == _musicSlider) { + _vm->_mixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, result); + _vm->_sound->muteMusic(result == 0); + _musicSwitch->setValue(result != 0); + } else if (widget == _speechSlider) { + _speechSwitch->setValue(result != 0); + } else if (widget == _fxSlider) { + _fxSwitch->setValue(result != 0); + } else if (widget == _gfxSlider) { + _gfxPreview->setState(result); + _vm->_screen->setRenderLevel(result); + } else if (widget == _okButton) { + // Apply the changes + _vm->setSubtitles(_subtitlesSwitch->getValue()); + _vm->_mouse->setObjectLabels(_objectLabelsSwitch->getValue()); + _vm->_sound->muteMusic(!_musicSwitch->getValue()); + _vm->_sound->muteSpeech(!_speechSwitch->getValue()); + _vm->_sound->muteFx(!_fxSwitch->getValue()); + _vm->_sound->setReverseStereo(_reverseStereoSwitch->getValue()); + _mixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, _musicSlider->getValue()); + _mixer->setVolumeForSoundType(Audio::Mixer::kSpeechSoundType, _speechSlider->getValue()); + _mixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, _fxSlider->getValue()); + _vm->_screen->setRenderLevel(_gfxSlider->getValue()); + + _vm->writeSettings(); + setResult(1); + } else if (widget == _cancelButton) { + // Revert the changes + _vm->readSettings(); + setResult(0); + } +} + +// Slot button actions. Note that keyboard input generates positive actions + +enum { + kSelectSlot = -1, + kDeselectSlot = -2, + kWheelDown = -3, + kWheelUp = -4, + kStartEditing = -5, + kCursorTick = -6 +}; + +class Slot : public Widget { +private: + int _mode; + FontRendererGui *_fr; + byte _text[SAVE_DESCRIPTION_LEN]; + bool _clickable; + bool _editable; + +public: + Slot(Dialog *parent, int x, int y, int w, int h) + : Widget(parent, 2), _clickable(false), _editable(false) { + setHitRect(x, y, w, h); + _text[0] = 0; + } + + void setMode(int mode) { + _mode = mode; + } + + void setClickable(bool clickable) { + _clickable = clickable; + } + + void setEditable(bool editable) { + _editable = editable; + _vm->_system->setFeatureState(OSystem::kFeatureVirtualKeyboard, editable); + } + + bool isEditable() { + return _editable; + } + + void setText(FontRendererGui *fr, int slot, byte *text) { + _fr = fr; + if (text) + sprintf((char *)_text, "%d. %s", slot, text); + else + sprintf((char *)_text, "%d. ", slot); + } + + byte *getText() { + return &_text[0]; + } + + virtual void paint(Common::Rect *clipRect = NULL) { + Widget::paint(); + + // HACK: The main dialog is responsible for drawing the text + // when in editing mode. + + if (!_editable) + _fr->drawText(_text, _sprites[0].x + 16, _sprites[0].y + 4 + 2 * getState()); + } + + virtual void onMouseDown(int x, int y) { + if (_clickable) { + if (getState() == 0) { + setState(1); + _parent->onAction(this, kSelectSlot); + if (_mode == kSaveDialog) + _parent->onAction(this, kStartEditing); + } else if (_mode == kRestoreDialog) { + setState(0); + _parent->onAction(this, kDeselectSlot); + } + } + } + + virtual void onWheelUp(int x, int y) { + _parent->onAction(this, kWheelUp); + } + + virtual void onWheelDown(int x, int y) { + _parent->onAction(this, kWheelDown); + } + + virtual void onKey(KeyboardEvent *ke) { + if (_editable) { + if (ke->keycode == 8) + _parent->onAction(this, 8); + else if (ke->ascii >= ' ' && ke->ascii <= 255) { + // Accept the character if the font renderer + // has what looks like a valid glyph for it. + if (_fr->getCharWidth(ke->ascii)) + _parent->onAction(this, ke->ascii); + } + } + } + + virtual void onTick() { + if (_editable) + _parent->onAction(this, kCursorTick); + } + + void setY(int y) { + for (int i = 0; i < _numStates; i++) + _sprites[i].y = y; + setHitRect(_hitRect.left, y, _hitRect.width(), _hitRect.height()); + } + + int getY() { + return _sprites[0].y; + } +}; + +SaveRestoreDialog::SaveRestoreDialog(Sword2Engine *vm, int mode) : Dialog(vm) { + int i; + + _mode = mode; + _selectedSlot = -1; + + // FIXME: The "control font" and the "red font" are currently always + // the same font, so one should be eliminated. + + _fr1 = new FontRendererGui(_vm, _vm->_controlsFontId); + _fr2 = new FontRendererGui(_vm, _vm->_redFontId); + + _panel = new Widget(this, 1); + _panel->createSurfaceImages(2016, 0, 40); + + for (i = 0; i < 4; i++) { + _slotButton[i] = new Slot(this, 114, 0, 384, 36); + _slotButton[i]->createSurfaceImages(2006 + i, 114, 0); + _slotButton[i]->setMode(mode); + _slotButton[i + 4] = new Slot(this, 114, 0, 384, 36); + _slotButton[i + 4]->linkSurfaceImages(_slotButton[i], 114, 0); + _slotButton[i + 4]->setMode(mode); + } + + updateSlots(); + + _zupButton = new ScrollButton(this, 516, 65, 17, 17); + _zupButton->createSurfaceImages(1982, 516, 65); + + _upButton = new ScrollButton(this, 516, 85, 17, 17); + _upButton->createSurfaceImages(2067, 516, 85); + + _downButton = new ScrollButton(this, 516, 329, 17, 17); + _downButton->createSurfaceImages(1986, 516, 329); + + _zdownButton = new ScrollButton(this, 516, 350, 17, 17); + _zdownButton->createSurfaceImages(1988, 516, 350); + + _okButton = new Button(this, 130, 377, 24, 24); + _okButton->createSurfaceImages(2002, 130, 377); + + _cancelButton = new Button(this, 350, 377, 24, 24); + _cancelButton->linkSurfaceImages(_okButton, 350, 377); + + registerWidget(_panel); + + for (i = 0; i < 8; i++) + registerWidget(_slotButton[i]); + + registerWidget(_zupButton); + registerWidget(_upButton); + registerWidget(_downButton); + registerWidget(_zdownButton); + registerWidget(_okButton); + registerWidget(_cancelButton); +} + +SaveRestoreDialog::~SaveRestoreDialog() { + delete _fr1; + delete _fr2; +} + +// There aren't really a hundred different button objects of course, there are +// only eight. Re-arrange them to simulate scrolling. + +void SaveRestoreDialog::updateSlots() { + for (int i = 0; i < 8; i++) { + Slot *slot = _slotButton[(baseSlot + i) % 8]; + FontRendererGui *fr; + byte description[SAVE_DESCRIPTION_LEN]; + + slot->setY(72 + i * 36); + + if (baseSlot + i == _selectedSlot) { + slot->setEditable(_mode == kSaveDialog); + slot->setState(1); + fr = _fr2; + } else { + slot->setEditable(false); + slot->setState(0); + fr = _fr1; + } + + if (_vm->getSaveDescription(baseSlot + i, description) == SR_OK) { + slot->setText(fr, baseSlot + i, description); + slot->setClickable(true); + } else { + slot->setText(fr, baseSlot + i, NULL); + slot->setClickable(_mode == kSaveDialog); + } + + if (slot->isEditable()) + drawEditBuffer(slot); + else + slot->paint(); + } +} + +void SaveRestoreDialog::drawEditBuffer(Slot *slot) { + if (_selectedSlot == -1) + return; + + // This will redraw a bit more than is strictly necessary, but I doubt + // that will make any noticeable difference. + + slot->paint(); + _fr2->drawText(_editBuffer, 130, 78 + (_selectedSlot - baseSlot) * 36); +} + +void SaveRestoreDialog::onAction(Widget *widget, int result) { + if (widget == _zupButton) { + if (baseSlot > 0) { + if (baseSlot >= 8) + baseSlot -= 8; + else + baseSlot = 0; + updateSlots(); + } + } else if (widget == _upButton) { + if (baseSlot > 0) { + baseSlot--; + updateSlots(); + } + } else if (widget == _downButton) { + if (baseSlot < 92) { + baseSlot++; + updateSlots(); + } + } else if (widget == _zdownButton) { + if (baseSlot < 92) { + if (baseSlot <= 84) + baseSlot += 8; + else + baseSlot = 92; + updateSlots(); + } + } else if (widget == _okButton) { + setResult(1); + } else if (widget == _cancelButton) { + setResult(0); + } else { + Slot *slot = (Slot *)widget; + int textWidth; + byte tmp; + int i; + int j; + + switch (result) { + case kWheelUp: + onAction(_upButton); + break; + case kWheelDown: + onAction(_downButton); + break; + case kSelectSlot: + case kDeselectSlot: + if (result == kSelectSlot) + _selectedSlot = baseSlot + (slot->getY() - 72) / 35; + else if (result == kDeselectSlot) + _selectedSlot = -1; + + for (i = 0; i < 8; i++) + if (widget == _slotButton[i]) + break; + + for (j = 0; j < 8; j++) { + if (j != i) { + _slotButton[j]->setEditable(false); + _slotButton[j]->setState(0); + } + } + break; + case kStartEditing: + if (_selectedSlot >= 10) + _firstPos = 5; + else + _firstPos = 4; + + strcpy((char *)_editBuffer, (char *)slot->getText()); + _editPos = strlen((char *)_editBuffer); + _cursorTick = 0; + _editBuffer[_editPos] = '_'; + _editBuffer[_editPos + 1] = 0; + slot->setEditable(true); + drawEditBuffer(slot); + break; + case kCursorTick: + _cursorTick++; + if (_cursorTick == 7) { + _editBuffer[_editPos] = ' '; + drawEditBuffer(slot); + } else if (_cursorTick == 14) { + _cursorTick = 0; + _editBuffer[_editPos] = '_'; + drawEditBuffer(slot); + } + break; + case 8: + if (_editPos > _firstPos) { + _editBuffer[_editPos - 1] = _editBuffer[_editPos]; + _editBuffer[_editPos--] = 0; + drawEditBuffer(slot); + } + break; + default: + tmp = _editBuffer[_editPos]; + _editBuffer[_editPos] = 0; + textWidth = _fr2->getTextWidth(_editBuffer); + _editBuffer[_editPos] = tmp; + + if (textWidth < 340 && _editPos < SAVE_DESCRIPTION_LEN - 2) { + _editBuffer[_editPos + 1] = _editBuffer[_editPos]; + _editBuffer[_editPos + 2] = 0; + _editBuffer[_editPos++] = result; + drawEditBuffer(slot); + } + break; + } + } +} + +void SaveRestoreDialog::paint() { + Dialog::paint(); + + _fr1->drawText((_mode == kRestoreDialog) ? TEXT_RESTORE : TEXT_SAVE, 165, 377); + _fr1->drawText(TEXT_CANCEL, 382, 377); +} + +void SaveRestoreDialog::setResult(int result) { + if (result) { + if (_selectedSlot == -1) + return; + + if (_mode == kSaveDialog) { + if (_editPos <= _firstPos) + return; + } + } + + Dialog::setResult(result); +} + +int SaveRestoreDialog::runModal() { + int result = Dialog::runModal(); + + if (result) { + switch (_mode) { + case kSaveDialog: + // Remove the cursor character from the savegame name + _editBuffer[_editPos] = 0; + + if (_vm->saveGame(_selectedSlot, (byte *)&_editBuffer[_firstPos]) != SR_OK) + result = 0; + break; + case kRestoreDialog: + if (_vm->restoreGame(_selectedSlot) != SR_OK) + result = 0; + break; + } + } + + return result; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/controls.h b/engines/sword2/controls.h new file mode 100644 index 0000000000..719489b3ae --- /dev/null +++ b/engines/sword2/controls.h @@ -0,0 +1,183 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef _CONTROL_S +#define _CONTROL_S + +#include "sword2/defs.h" + +#define MAX_WIDGETS 25 + +namespace Sword2 { + +class Sword2Engine; +class FontRendererGui; +class Widget; +class Switch; +class Slider; +class Button; +class ScrollButton; +class Slot; + +enum { + kSaveDialog, + kRestoreDialog +}; + +/** + * Base class for all dialogs. + */ + +class Dialog { +private: + int _numWidgets; + Widget *_widgets[MAX_WIDGETS]; + bool _finish; + int _result; + +public: + Sword2Engine *_vm; + + Dialog(Sword2Engine *vm); + virtual ~Dialog(); + + void registerWidget(Widget *widget); + + virtual void paint(); + virtual void setResult(int result); + + virtual int runModal(); + + virtual void onAction(Widget *widget, int result = 0) {} +}; + +class OptionsDialog : public Dialog { +private: + FontRendererGui *_fr; + Widget *_panel; + Switch *_objectLabelsSwitch; + Switch *_subtitlesSwitch; + Switch *_reverseStereoSwitch; + Switch *_musicSwitch; + Switch *_speechSwitch; + Switch *_fxSwitch; + Slider *_musicSlider; + Slider *_speechSlider; + Slider *_fxSlider; + Slider *_gfxSlider; + Widget *_gfxPreview; + Button *_okButton; + Button *_cancelButton; + + Audio::Mixer *_mixer; + +public: + OptionsDialog(Sword2Engine *vm); + ~OptionsDialog(); + + virtual void paint(); + virtual void onAction(Widget *widget, int result = 0); +}; + +class SaveRestoreDialog : public Dialog { +private: + int _mode, _selectedSlot; + byte _editBuffer[SAVE_DESCRIPTION_LEN]; + int _editPos, _firstPos; + int _cursorTick; + + FontRendererGui *_fr1; + FontRendererGui *_fr2; + Widget *_panel; + Slot *_slotButton[8]; + ScrollButton *_zupButton; + ScrollButton *_upButton; + ScrollButton *_downButton; + ScrollButton *_zdownButton; + Button *_okButton; + Button *_cancelButton; + +public: + SaveRestoreDialog(Sword2Engine *vm, int mode); + ~SaveRestoreDialog(); + + void updateSlots(); + void drawEditBuffer(Slot *slot); + + virtual void onAction(Widget *widget, int result = 0); + virtual void paint(); + virtual void setResult(int result); + virtual int runModal(); +}; + +/** + * A "mini" dialog is usually a yes/no question, but also used for the + * restart/restore dialog at the beginning of the game. + */ + +class MiniDialog : public Dialog { +private: + uint32 _headerTextId; + uint32 _okTextId; + uint32 _cancelTextId; + FontRendererGui *_fr; + Widget *_panel; + Button *_okButton; + Button *_cancelButton; + +public: + MiniDialog(Sword2Engine *vm, uint32 headerTextId, uint32 okTextId = TEXT_OK, uint32 cancelTextId = TEXT_CANCEL); + virtual ~MiniDialog(); + virtual void paint(); + virtual void onAction(Widget *widget, int result = 0); +}; + +class StartDialog : public MiniDialog { +public: + StartDialog(Sword2Engine *vm); + virtual int runModal(); +}; + +class RestartDialog : public MiniDialog { +public: + RestartDialog(Sword2Engine *vm); + virtual int runModal(); +}; + +class QuitDialog : public MiniDialog { +public: + QuitDialog(Sword2Engine *vm); + virtual int runModal(); +}; + +class SaveDialog : public SaveRestoreDialog { +public: + SaveDialog(Sword2Engine *vm) : SaveRestoreDialog(vm, kSaveDialog) {} +}; + +class RestoreDialog : public SaveRestoreDialog { +public: + RestoreDialog(Sword2Engine *vm) : SaveRestoreDialog(vm, kRestoreDialog) {} +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/d_draw.cpp b/engines/sword2/d_draw.cpp new file mode 100644 index 0000000000..7f278996fb --- /dev/null +++ b/engines/sword2/d_draw.cpp @@ -0,0 +1,71 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "common/system.h" +#include "sword2/sword2.h" +#include "sword2/mouse.h" + +namespace Sword2 { + +/** + * @return the graphics detail setting + */ + +int8 Screen::getRenderLevel() { + return _renderLevel; +} + +void Screen::setRenderLevel(int8 level) { + _renderLevel = level; + + switch (_renderLevel) { + case 0: + // Lowest setting: no fancy stuff + _renderCaps = 0; + break; + case 1: + // Medium-low setting: transparency-blending + _renderCaps = RDBLTFX_SPRITEBLEND; + break; + case 2: + // Medium-high setting: transparency-blending + shading + _renderCaps = RDBLTFX_SPRITEBLEND | RDBLTFX_SHADOWBLEND; + break; + case 3: + // Highest setting: transparency-blending + shading + + // edge-blending + improved stretching + _renderCaps = RDBLTFX_SPRITEBLEND | RDBLTFX_SHADOWBLEND | RDBLTFX_EDGEBLEND; + break; + } +} + +/** + * Fill the screen buffer with palette colour zero. Note that it does not + * touch the menu areas of the screen. + */ + +void Screen::clearScene() { + memset(_buffer + MENUDEEP * _screenWide, 0, _screenWide * RENDERDEEP); + _needFullRedraw = true; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/debug.cpp b/engines/sword2/debug.cpp new file mode 100644 index 0000000000..53fc200241 --- /dev/null +++ b/engines/sword2/debug.cpp @@ -0,0 +1,377 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "sword2/sword2.h" +#include "sword2/console.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/maketext.h" +#include "sword2/memory.h" +#include "sword2/mouse.h" +#include "sword2/resman.h" +#include "sword2/router.h" + +namespace Sword2 { + +void Debugger::clearDebugTextBlocks() { + uint8 blockNo = 0; + + while (blockNo < MAX_DEBUG_TEXTS && _debugTextBlocks[blockNo] > 0) { + // kill the system text block + _vm->_fontRenderer->killTextBloc(_debugTextBlocks[blockNo]); + + // clear this element of our array of block numbers + _debugTextBlocks[blockNo] = 0; + + blockNo++; + } +} + +void Debugger::makeDebugTextBlock(char *text, int16 x, int16 y) { + uint8 blockNo = 0; + + while (blockNo < MAX_DEBUG_TEXTS && _debugTextBlocks[blockNo] > 0) + blockNo++; + + assert(blockNo < MAX_DEBUG_TEXTS); + + _debugTextBlocks[blockNo] = _vm->_fontRenderer->buildNewBloc((byte *)text, x, y, 640 - x, 0, RDSPR_DISPLAYALIGN, CONSOLE_FONT_ID, NO_JUSTIFICATION); +} + +void Debugger::buildDebugText() { + char buf[128]; + + int32 showVarNo; // for variable watching + int32 showVarPos; + int32 varNo; + + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + // clear the array of text block numbers for the debug text + clearDebugTextBlocks(); + + // mouse coords + // print mouse coords beside mouse-marker, if it's being displayed + if (_displayMouseMarker) { + int mouseX, mouseY; + + _vm->_mouse->getPos(mouseX, mouseY); + + sprintf(buf, "%d,%d", mouseX + screenInfo->scroll_offset_x, mouseY + screenInfo->scroll_offset_y); + if (mouseX > 560) + makeDebugTextBlock(buf, mouseX - 50, mouseY - 15); + else + makeDebugTextBlock(buf, mouseX + 5, mouseY - 15); + } + + // mouse area coords + + // defining a mouse area the easy way, by creating a box on-screen + if (_draggingRectangle || _vm->_logic->readVar(SYSTEM_TESTING_ANIMS)) { + // so we can see what's behind the lines + _rectFlicker = !_rectFlicker; + + sprintf(buf, "x1=%d", _rectX1); + makeDebugTextBlock(buf, 0, 120); + + sprintf(buf, "y1=%d", _rectY1); + makeDebugTextBlock(buf, 0, 135); + + sprintf(buf, "x2=%d", _rectX2); + makeDebugTextBlock(buf, 0, 150); + + sprintf(buf, "y2=%d", _rectY2); + makeDebugTextBlock(buf, 0, 165); + } + + // testingSnR indicator + + if (_testingSnR) { // see fnAddHuman() + sprintf(buf, "TESTING LOGIC STABILITY!"); + makeDebugTextBlock(buf, 0, 105); + } + +#ifdef SWORD2_DEBUG + // speed-up indicator + + if (_vm->_renderSkip) { // see sword2.cpp + sprintf(buf, "SKIPPING FRAMES FOR SPEED-UP!"); + makeDebugTextBlock(buf, 0, 120); + } +#endif + + // debug info at top of screen - enabled/disabled as one complete unit + + if (_displayTime) { + int32 time = _vm->getMillis(); + + if ((time - _startTime) / 1000 >= 10000) + _startTime = time; + + time -= _startTime; + sprintf(buf, "Time %.2d:%.2d:%.2d.%.3d", (time / 3600000) % 60, (time / 60000) % 60, (time / 1000) % 60, time % 1000); + makeDebugTextBlock(buf, 500, 360); + sprintf(buf, "Game %d", _vm->_gameCycle); + makeDebugTextBlock(buf, 500, 380); + } + + // current text number & speech-sample resource id + + if (_displayTextNumbers) { + if (_textNumber) { + if (_vm->_logic->readVar(SYSTEM_TESTING_TEXT)) { + if (_vm->_logic->readVar(SYSTEM_WANT_PREVIOUS_LINE)) + sprintf(buf, "backwards"); + else + sprintf(buf, "forwards"); + + makeDebugTextBlock(buf, 0, 340); + } + + sprintf(buf, "res: %d", _textNumber / SIZE); + makeDebugTextBlock(buf, 0, 355); + + sprintf(buf, "pos: %d", _textNumber & 0xffff); + makeDebugTextBlock(buf, 0, 370); + + sprintf(buf, "TEXT: %d", _vm->_logic->_officialTextNumber); + makeDebugTextBlock(buf, 0, 385); + } + } + + // resource number currently being checking for animation + + if (_vm->_logic->readVar(SYSTEM_TESTING_ANIMS)) { + sprintf(buf, "trying resource %d", _vm->_logic->readVar(SYSTEM_TESTING_ANIMS)); + makeDebugTextBlock(buf, 0, 90); + } + + // general debug info + + if (_displayDebugText) { + byte name[NAME_LEN]; + +/* + // CD in use + sprintf(buf, "CD-%d", currentCD); + makeDebugTextBlock(buf, 0, 0); +*/ + + // mouse coords & object pointed to + + if (_vm->_logic->readVar(CLICKED_ID)) + sprintf(buf, "last click at %d,%d (id %d: %s)", + _vm->_logic->readVar(MOUSE_X), + _vm->_logic->readVar(MOUSE_Y), + _vm->_logic->readVar(CLICKED_ID), + _vm->_resman->fetchName(_vm->_logic->readVar(CLICKED_ID), name)); + else + sprintf(buf, "last click at %d,%d (---)", + _vm->_logic->readVar(MOUSE_X), + _vm->_logic->readVar(MOUSE_Y)); + + makeDebugTextBlock(buf, 0, 15); + + uint32 mouseTouching = _vm->_mouse->getMouseTouching(); + + int mouseX, mouseY; + + _vm->_mouse->getPos(mouseX, mouseY); + + if (mouseTouching) + sprintf(buf, "mouse %d,%d (id %d: %s)", + mouseX + screenInfo->scroll_offset_x, + mouseY + screenInfo->scroll_offset_y, + mouseTouching, + _vm->_resman->fetchName(mouseTouching, name)); + else + sprintf(buf, "mouse %d,%d (not touching)", + mouseX + screenInfo->scroll_offset_x, + mouseY + screenInfo->scroll_offset_y); + + makeDebugTextBlock(buf, 0, 30); + + // player coords & graphic info + // if player objct has a graphic + + if (_graphAnimRes) + sprintf(buf, "player %d,%d %s (%d) #%d/%d", + screenInfo->player_feet_x, + screenInfo->player_feet_y, + _vm->_resman->fetchName(_graphAnimRes, name), + _graphAnimRes, + _graphAnimPc, + _graphNoFrames); + else + sprintf(buf, "player %d,%d --- %d", + screenInfo->player_feet_x, + screenInfo->player_feet_y, + _graphAnimPc); + + makeDebugTextBlock(buf, 0, 45); + + // frames-per-second counter + + sprintf(buf, "fps %d", _vm->_screen->getFps()); + makeDebugTextBlock(buf, 440, 0); + + // location number + + sprintf(buf, "location=%d", _vm->_logic->readVar(LOCATION)); + makeDebugTextBlock(buf, 440, 15); + + // "result" variable + + sprintf(buf, "result=%d", _vm->_logic->readVar(RESULT)); + makeDebugTextBlock(buf, 440, 30); + + // no. of events in event list + + sprintf(buf, "events=%d", _vm->_logic->countEvents()); + makeDebugTextBlock(buf, 440, 45); + + // sprite list usage + + sprintf(buf, "bgp0: %d/%d", _vm->_screen->getCurBgp0(), MAX_bgp0_sprites); + makeDebugTextBlock(buf, 560, 0); + + sprintf(buf, "bgp1: %d/%d", _vm->_screen->getCurBgp1(), MAX_bgp1_sprites); + makeDebugTextBlock(buf, 560, 15); + + sprintf(buf, "back: %d/%d", _vm->_screen->getCurBack(), MAX_back_sprites); + makeDebugTextBlock(buf, 560, 30); + + sprintf(buf, "sort: %d/%d", _vm->_screen->getCurSort(), MAX_sort_sprites); + makeDebugTextBlock(buf, 560, 45); + + sprintf(buf, "fore: %d/%d", _vm->_screen->getCurFore(), MAX_fore_sprites); + makeDebugTextBlock(buf, 560, 60); + + sprintf(buf, "fgp0: %d/%d", _vm->_screen->getCurFgp0(), MAX_fgp0_sprites); + makeDebugTextBlock(buf, 560, 75); + + sprintf(buf, "fgp1: %d/%d", _vm->_screen->getCurFgp1(), MAX_fgp1_sprites); + makeDebugTextBlock(buf, 560, 90); + + // largest layer & sprite + + // NB. Strings already constructed in Build_display.cpp + makeDebugTextBlock(_vm->_screen->getLargestLayerInfo(), 0, 60); + makeDebugTextBlock(_vm->_screen->getLargestSpriteInfo(), 0, 75); + + // "waiting for person" indicator - set form fnTheyDo and + // fnTheyDoWeWait + + if (_speechScriptWaiting) { + sprintf(buf, "script waiting for %s (%d)", + _vm->_resman->fetchName(_speechScriptWaiting, name), + _speechScriptWaiting); + makeDebugTextBlock(buf, 0, 90); + } + + // variable watch display + + showVarPos = 115; // y-coord for first showVar + + for (showVarNo = 0; showVarNo < MAX_SHOWVARS; showVarNo++) { + varNo = _showVar[showVarNo]; // get variable number + + // if non-zero ie. cannot watch 'id' but not needed + // anyway because it changes throughout the logic loop + + if (varNo) { + sprintf(buf, "var(%d) = %d", varNo, _vm->_logic->readVar(varNo)); + makeDebugTextBlock(buf, 530, showVarPos); + showVarPos += 15; // next line down + } + } + + // memory indicator - this should come last, to show all the + // sprite blocks above! + + uint32 totAlloc = _vm->_memory->getTotAlloc(); + int16 numBlocks = _vm->_memory->getNumBlocks(); + + if (totAlloc < 1024) + sprintf(buf, "%u bytes in %d memory blocks", totAlloc, numBlocks); + else if (totAlloc < 1024 * 1024) + sprintf(buf, "%uK in %d memory blocks", totAlloc / 1024, numBlocks); + else + sprintf(buf, "%.02fM in %d memory blocks", totAlloc / 1048576., numBlocks); + + makeDebugTextBlock(buf, 0, 0); + } +} + +void Debugger::drawDebugGraphics() { + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + // walk-grid + + if (_displayWalkGrid) + _vm->_logic->_router->plotWalkGrid(); + + // player feet coord marker + + if (_displayPlayerMarker) + plotCrossHair(screenInfo->player_feet_x, screenInfo->player_feet_y, 215); + + // mouse marker & coords + + if (_displayMouseMarker) { + int mouseX, mouseY; + + _vm->_mouse->getPos(mouseX, mouseY); + + plotCrossHair(mouseX + screenInfo->scroll_offset_x, mouseY + screenInfo->scroll_offset_y, 215); + } + + // mouse area rectangle / sprite box rectangle when testing anims + + if (_vm->_logic->readVar(SYSTEM_TESTING_ANIMS)) { + // draw box around current frame + drawRect(_rectX1, _rectY1, _rectX2, _rectY2, 184); + } else if (_draggingRectangle) { + // defining a mouse area the easy way, by creating a box + // on-screen + if (_rectFlicker) + drawRect(_rectX1, _rectY1, _rectX2, _rectY2, 184); + } +} + +void Debugger::plotCrossHair(int16 x, int16 y, uint8 pen) { + _vm->_screen->plotPoint(x, y, pen); + + _vm->_screen->drawLine(x - 2, y, x - 5, y, pen); + _vm->_screen->drawLine(x + 2, y, x + 5, y, pen); + + _vm->_screen->drawLine(x, y - 2, x, y - 5, pen); + _vm->_screen->drawLine(x, y + 2, x, y + 5, pen); +} + +void Debugger::drawRect(int16 x1, int16 y1, int16 x2, int16 y2, uint8 pen) { + _vm->_screen->drawLine(x1, y1, x2, y1, pen); // top edge + _vm->_screen->drawLine(x1, y2, x2, y2, pen); // bottom edge + _vm->_screen->drawLine(x1, y1, x1, y2, pen); // left edge + _vm->_screen->drawLine(x2, y1, x2, y2, pen); // right edge +} + +} // End of namespace Sword2 diff --git a/engines/sword2/debug.h b/engines/sword2/debug.h new file mode 100644 index 0000000000..9b0b40f9ec --- /dev/null +++ b/engines/sword2/debug.h @@ -0,0 +1,33 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef D_DEBUG +#define D_DEBUG + +// FIXME: I don't know how large this constant used to be +#define MAX_DEBUG_TEXTS 55 + +#define MAX_SHOWVARS 15 + +namespace Sword2 { +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/defs.h b/engines/sword2/defs.h new file mode 100644 index 0000000000..4acb484f34 --- /dev/null +++ b/engines/sword2/defs.h @@ -0,0 +1,205 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef DEFS +#define DEFS + +#define SIZE 0x10000 // 65536 items per section +#define NuSIZE 0xffff // & with this + +// Return codes + +enum { + // Generic error codes + RD_OK = 0x00000000, + RDERR_UNKNOWN = 0x00000001, + RDERR_OUTOFMEMORY = 0x00000003, + RDERR_INVALIDFILENAME = 0x00000004, + + // Drawing error codes + RDERR_DECOMPRESSION = 0x00010007, + + // Sprite drawing error codes + RDERR_NOTIMPLEMENTED = 0x00060001, + RDERR_NOTCLOSED = 0x00050005, + RDERR_NOTOPEN = 0x00050006, + + // Menubar error codes + RDERR_INVALIDMENU = 0x00060000, + RDERR_INVALIDPOCKET = 0x00060001, + RDERR_INVALIDCOMMAND = 0x00060002, + + // Palette fading error codes + RDERR_FADEINCOMPLETE = 0x00070000, + + // Sound engine error codes + RDERR_SPEECHPLAYING = 0x00080004, + RDERR_SPEECHNOTPLAYING = 0x00080005, + RDERR_INVALIDWAV = 0x00080006, + RDERR_FXALREADYOPEN = 0x00080009, + RDERR_FXNOTOPEN = 0x0008000B, + RDERR_INVALIDID = 0x0008000D +}; + +// Text ids for the control panel etc. + +enum { + TEXT_OK = 0x08EB0000, + TEXT_CANCEL = 0x08EB0001, + TEXT_RESTORE = 0x08EB0002, + TEXT_SAVE = 0x08EB0003, + TEXT_QUIT = 0x08EB0004, + TEXT_RESTART = 0x08EB0005, + TEXT_OPTIONS = 0x08EB000A, + TEXT_SUBTITLES = 0x08EB000B, + TEXT_OBJECT_LABELS = 0x08EB000C, + TEXT_MUSIC_VOLUME = 0x08EB000E, + TEXT_SPEECH_VOLUME = 0x08EB000F, + TEXT_FX_VOLUME = 0x08EB0010, + TEXT_GFX_QUALITY = 0x08EB0011, + TEXT_REVERSE_STEREO = 0x08EB0015, + TEXT_RESTORE_CANT_OPEN = 0x0CBA017E, + TEXT_RESTORE_INCOMPATIBLE = 0x0CBA017F, + TEXT_RESTORE_FAILED = 0x0CBA0181, + TEXT_SAVE_CANT_OPEN = 0x0CBA0182, + TEXT_SAVE_FAILED = 0x0CBA0184 +}; + +// Always 8 (George object used for Nico player character as well) +#define CUR_PLAYER_ID 8 + +// Global variable references + +enum { + ID = 0, + RESULT = 1, + PLAYER_ACTION = 2, + // CUR_PLAYER_ID = 3, + PLAYER_ID = 305, + TALK_FLAG = 13, + + MOUSE_X = 4, + MOUSE_Y = 5, + LEFT_BUTTON = 109, + RIGHT_BUTTON = 110, + CLICKED_ID = 178, + + IN_SUBJECT = 6, + COMBINE_BASE = 7, + OBJECT_HELD = 14, + + SPEECH_ID = 9, + INS1 = 10, + INS2 = 11, + INS3 = 12, + INS4 = 60, + INS5 = 61, + INS_COMMAND = 59, + + PLAYER_FEET_X = 141, + PLAYER_FEET_Y = 142, + PLAYER_CUR_DIR = 937, + + // for debug.cpp + LOCATION = 62, + + // so scripts can force scroll offsets + SCROLL_X = 345, + SCROLL_Y = 346, + + EXIT_CLICK_ID = 710, + EXIT_FADING = 713, + + SYSTEM_TESTING_ANIMS = 912, + SYSTEM_TESTING_TEXT = 1230, + SYSTEM_WANT_PREVIOUS_LINE = 1245, + + // 1=on 0=off (set in fnAddHuman and fnNoHuman) + MOUSE_AVAILABLE = 686, + + // used in fnChoose + AUTO_SELECTED = 1115, + + // see fnStartConversation and fnChooser + CHOOSER_COUNT_FLAG = 15, + + // signifies a demo mode + DEMO = 1153, + + // Indicates to script whether this is the Playstation version. + // PSXFLAG = 1173, + + // for the poor PSX so it knows what language is running. + // GAME_LANGUAGE = 111, + + // 1 = dead + DEAD = 1256, + + // If set indicates that the speech anim is to run through only once. + SPEECHANIMFLAG = 1278, + + // for the engine + SCROLL_OFFSET_X = 1314 +}; + +// Resource IDs + +enum { + // mouse mointers - It's pretty much safe to do it like this + NORMAL_MOUSE_ID = 17, + SCROLL_LEFT_MOUSE_ID = 1440, + SCROLL_RIGHT_MOUSE_ID = 1441, + + // Console Font - does not use game text - only English required + CONSOLE_FONT_ID = 340, + + // Speech Font + ENGLISH_SPEECH_FONT_ID = 341, + FINNISH_SPEECH_FONT_ID = 956, + POLISH_SPEECH_FONT_ID = 955, + + // Control Panel Font (and un-selected savegame descriptions) + ENGLISH_CONTROLS_FONT_ID = 2005, + FINNISH_CONTROLS_FONT_ID = 959, + POLISH_CONTROLS_FONT_ID = 3686, + + // Red Font (for selected savegame descriptions) + // BS2 doesn't draw selected savegames in red, so I guess this is a + // left-over from BS1 + ENGLISH_RED_FONT_ID = 2005, // 1998 // Redfont + FINNISH_RED_FONT_ID = 959, // 960 // FinRedFn + POLISH_RED_FONT_ID = 3686, // 3688 // PolRedFn + + // Control panel palette resource id + CONTROL_PANEL_PALETTE = 261, + + // res id's of the system menu icons + OPTIONS_ICON = 344, + QUIT_ICON = 335, + SAVE_ICON = 366, + RESTORE_ICON = 364, + RESTART_ICON = 342, + + // conversation exit icon, 'EXIT' menu icon (used in fnChoose) + EXIT_ICON = 65 +}; + +#endif diff --git a/engines/sword2/events.cpp b/engines/sword2/events.cpp new file mode 100644 index 0000000000..e8090414aa --- /dev/null +++ b/engines/sword2/events.cpp @@ -0,0 +1,99 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/logic.h" + +namespace Sword2 { + +void Logic::sendEvent(uint32 id, uint32 interact_id) { + for (int i = 0; i < ARRAYSIZE(_eventList); i++) { + if (_eventList[i].id == id || !_eventList[i].id) { + _eventList[i].id = id; + _eventList[i].interact_id = interact_id; + return; + } + } + + error("sendEvent() ran out of event slots"); +} + +void Logic::setPlayerActionEvent(uint32 id, uint32 interact_id) { + // Full script id of action script number 2 + sendEvent(id, (interact_id << 16) | 2); +} + +int Logic::checkEventWaiting() { + for (int i = 0; i < ARRAYSIZE(_eventList); i++) { + if (_eventList[i].id == readVar(ID)) + return 1; + } + + return 0; +} + +void Logic::startEvent() { + // call this from stuff like fnWalk + // you must follow with a return IR_TERMINATE + + for (int i = 0; i < ARRAYSIZE(_eventList); i++) { + if (_eventList[i].id == readVar(ID)) { + logicOne(_eventList[i].interact_id); + _eventList[i].id = 0; + return; + } + } + + error("startEvent() can't find event for id %d", readVar(ID)); +} + +void Logic::clearEvent(uint32 id) { + for (int i = 0; i < ARRAYSIZE(_eventList); i++) { + if (_eventList[i].id == id) { + _eventList[i].id = 0; + return; + } + } +} + +void Logic::killAllIdsEvents(uint32 id) { + for (int i = 0; i < ARRAYSIZE(_eventList); i++) { + if (_eventList[i].id == id) + _eventList[i].id = 0; + } +} + +// For the debugger + +uint32 Logic::countEvents() { + uint32 count = 0; + + for (int i = 0; i < ARRAYSIZE(_eventList); i++) { + if (_eventList[i].id) + count++; + } + + return count; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/function.cpp b/engines/sword2/function.cpp new file mode 100644 index 0000000000..e749e7b497 --- /dev/null +++ b/engines/sword2/function.cpp @@ -0,0 +1,2479 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "common/system.h" +#include "common/file.h" + +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/build_display.h" +#include "sword2/console.h" +#include "sword2/interpreter.h" +#include "sword2/logic.h" +#include "sword2/maketext.h" +#include "sword2/mouse.h" +#include "sword2/resman.h" +#include "sword2/router.h" +#include "sword2/sound.h" +#include "sword2/animation.h" + +namespace Sword2 { + +int32 Logic::fnTestFunction(int32 *params) { + // params: 0 address of a flag + return IR_CONT; +} + +int32 Logic::fnTestFlags(int32 *params) { + // params: 0 value of flag + return IR_CONT; +} + +int32 Logic::fnRegisterStartPoint(int32 *params) { + // params: 0 id of startup script to call - key + // 1 pointer to ascii message + + int32 key = params[0]; + char *name = (char *)decodePtr(params[1]); + + _vm->registerStartPoint(key, name); + return IR_CONT; +} + +int32 Logic::fnInitBackground(int32 *params) { + // this screen defines the size of the back buffer + + // params: 0 res id of normal background layer - cannot be 0 + // 1 1 yes 0 no for a new palette + + _vm->_screen->initBackground(params[0], params[1]); + return IR_CONT; +} + +/** + * This function is used by start scripts. + */ + +int32 Logic::fnSetSession(int32 *params) { + // params: 0 id of new run list + + expressChangeSession(params[0]); + return IR_CONT; +} + +int32 Logic::fnBackSprite(int32 *params) { + // params: 0 pointer to object's graphic structure + _router->setSpriteStatus(decodePtr(params[0]), BACK_SPRITE); + return IR_CONT; +} + +int32 Logic::fnSortSprite(int32 *params) { + // params: 0 pointer to object's graphic structure + _router->setSpriteStatus(decodePtr(params[0]), SORT_SPRITE); + return IR_CONT; +} + +int32 Logic::fnForeSprite(int32 *params) { + // params: 0 pointer to object's graphic structure + _router->setSpriteStatus(decodePtr(params[0]), FORE_SPRITE); + return IR_CONT; +} + +int32 Logic::fnRegisterMouse(int32 *params) { + // this call would be made from an objects service script 0 + // the object would be one with no graphic but with a mouse - i.e. a + // floor or one whose mouse area is manually defined rather than + // intended to fit sprite shape + + // params: 0 pointer to ObjectMouse or 0 for no write to mouse + // list + + _vm->_mouse->registerMouse(decodePtr(params[0]), NULL); + return IR_CONT; +} + +int32 Logic::fnAnim(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 pointer to object's graphic structure + // 2 resource id of animation file + + // Normal forward animation + return _router->doAnimate( + decodePtr(params[0]), + decodePtr(params[1]), + params[2], false); +} + +int32 Logic::fnRandom(int32 *params) { + // params: 0 min + // 1 max + + writeVar(RESULT, _vm->_rnd.getRandomNumberRng(params[0], params[1])); + return IR_CONT; +} + +int32 Logic::fnPreLoad(int32 *params) { + // Forces a resource into memory before it's "officially" opened for + // use. eg. if an anim needs to run on smoothly from another, + // "preloading" gets it into memory in advance to avoid the cacheing + // delay that normally occurs before the first frame. + + // params: 0 resource to preload + + _vm->_resman->openResource(params[0]); + _vm->_resman->closeResource(params[0]); + return IR_CONT; +} + +int32 Logic::fnAddSubject(int32 *params) { + // params: 0 id + // 1 daves reference number + _vm->_mouse->addSubject(params[0], params[1]); + return IR_CONT; +} + +int32 Logic::fnInteract(int32 *params) { + // Run targets action on a subroutine. Called by player on his base + // level 0 idle, for example. + + // params: 0 id of target from which we derive action script + // reference + + writeVar(PLAYER_ACTION, 0); // must clear this + logicUp((params[0] << 16) | 2); // 3rd script of clicked on id + + // Out, up and around again - pc is saved for current level to be + // returned to. + return IR_GOSUB; +} + +int32 Logic::fnChoose(int32 *params) { + // params: none + + // This opcode is used to open the conversation menu. The human is + // switched off so there will be no normal mouse engine. + + // The player's choice is piggy-backed on the standard opcode return + // values, to be used with the CP_JUMP_ON_RETURNED opcode. As far as I + // can tell, this is the only function that uses that feature. + + uint32 response = _vm->_mouse->chooseMouse(); + + if (response == (uint32)-1) + return IR_REPEAT; + + return IR_CONT | (response << 3); +} + +/** + * Walk mega to (x,y,dir). Set RESULT to 0 if it succeeded. Otherwise, set + * RESULT to 1. + */ + +int32 Logic::fnWalk(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 pointer to object's graphic structure + // 2 pointer to object's mega structure + // 3 pointer to object's walkdata structure + // 4 target x-coord + // 5 target y-coord + // 6 target direction (8 means end walk on ANY direction) + + return _router->doWalk( + decodePtr(params[0]), + decodePtr(params[1]), + decodePtr(params[2]), + decodePtr(params[3]), + params[4], params[5], params[6]); +} + +/** + * Walk mega to start position of anim + */ + +int32 Logic::fnWalkToAnim(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 pointer to object's graphic structure + // 2 pointer to object's mega structure + // 3 pointer to object's walkdata structure + // 4 anim resource id + + return _router->walkToAnim( + decodePtr(params[0]), + decodePtr(params[1]), + decodePtr(params[2]), + decodePtr(params[3]), + params[4]); +} + +/** + * Turn mega to the specified direction. + */ + +int32 Logic::fnTurn(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 pointer to object's graphic structure + // 2 pointer to object's mega structure + // 3 pointer to object's walkdata structure + // 4 target direction + + return _router->doFace( + decodePtr(params[0]), + decodePtr(params[1]), + decodePtr(params[2]), + decodePtr(params[3]), + params[4]); +} + +/** + * Stand mega at (x,y,dir) + * Sets up the graphic object, but also needs to set the new 'current_dir' in + * the mega object, so the router knows in future + */ + +int32 Logic::fnStandAt(int32 *params) { + // params: 0 pointer to object's graphic structure + // 1 pointer to object's mega structure + // 2 target x-coord + // 3 target y-coord + // 4 target direction + + _router->standAt( + decodePtr(params[0]), + decodePtr(params[1]), + params[2], params[3], params[4]); + return IR_CONT; +} + +/** + * Stand mega into the specified direction at current feet coords. + * Just needs to call standAt() with current feet coords. + */ + +int32 Logic::fnStand(int32 *params) { + // params: 0 pointer to object's graphic structure + // 1 pointer to object's mega structure + // 2 target direction + byte *ob_mega = decodePtr(params[1]); + + ObjectMega obMega(ob_mega); + + _router->standAt( + decodePtr(params[0]), + ob_mega, obMega.getFeetX(), obMega.getFeetY(), params[2]); + return IR_CONT; +} + +/** + * stand mega at end position of anim + */ + +int32 Logic::fnStandAfterAnim(int32 *params) { + // params: 0 pointer to object's graphic structure + // 1 pointer to object's mega structure + // 2 anim resource id + + _router->standAfterAnim( + decodePtr(params[0]), + decodePtr(params[1]), + params[2]); + return IR_CONT; +} + +int32 Logic::fnPause(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 number of game-cycles to pause + + // NB. Pause-value of 0 causes script to continue, 1 causes a 1-cycle + // quit, 2 gives 2 cycles, etc. + + ObjectLogic obLogic(decodePtr(params[0])); + + if (obLogic.getLooping() == 0) { + obLogic.setLooping(1); + obLogic.setPause(params[1]); + } + + if (obLogic.getPause()) { + obLogic.setPause(obLogic.getPause() - 1); + return IR_REPEAT; + } + + obLogic.setLooping(0); + return IR_CONT; +} + +int32 Logic::fnMegaTableAnim(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 pointer to object's graphic structure + // 2 pointer to object's mega structure + // 3 pointer to animation table + + // Normal forward anim + return _router->megaTableAnimate( + decodePtr(params[0]), + decodePtr(params[1]), + decodePtr(params[2]), + decodePtr(params[3]), + false); +} + +int32 Logic::fnAddMenuObject(int32 *params) { + // params: 0 pointer to a MenuObject structure to copy down + + _vm->_mouse->addMenuObject(decodePtr(params[0])); + return IR_CONT; +} + +/** + * Start a conversation. + * + * Note that fnStartConversation() might accidentally be called every time the + * script loops back for another chooser, but we only want to reset the chooser + * count flag the first time this function is called, i.e. when the talk flag + * is zero. + */ + +int32 Logic::fnStartConversation(int32 *params) { + // params: none + + _vm->_mouse->startConversation(); + return IR_CONT; +} + +/** + * End a conversation. + */ + +int32 Logic::fnEndConversation(int32 *params) { + // params: none + + _vm->_mouse->endConversation(); + return IR_CONT; +} + +int32 Logic::fnSetFrame(int32 *params) { + // params: 0 pointer to object's graphic structure + // 1 resource id of animation file + // 2 frame flag (0=first 1=last) + + int32 res = params[1]; + assert(res); + + // open the resource (& check it's valid) + byte *anim_file = _vm->_resman->openResource(res); + + assert(_vm->_resman->fetchType(res) == ANIMATION_FILE); + + // set up pointer to the animation header + AnimHeader anim_head; + + anim_head.read(_vm->fetchAnimHeader(anim_file)); + + // set up anim resource in graphic object + ObjectGraphic obGraph(decodePtr(params[0])); + + obGraph.setAnimResource(res); + obGraph.setAnimPc(params[2] ? anim_head.noAnimFrames - 1 : 0); + + // Close the anim file and drop out of script + _vm->_resman->closeResource(obGraph.getAnimResource()); + return IR_CONT; +} + +int32 Logic::fnRandomPause(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 minimum number of game-cycles to pause + // 2 maximum number of game-cycles to pause + + ObjectLogic obLogic(decodePtr(params[0])); + int32 pars[2]; + + if (obLogic.getLooping() == 0) { + pars[0] = params[1]; + pars[1] = params[2]; + fnRandom(pars); + pars[1] = readVar(RESULT); + } + + pars[0] = params[0]; + return fnPause(pars); +} + +int32 Logic::fnRegisterFrame(int32 *params) { + // this call would be made from an objects service script 0 + + // params: 0 pointer to mouse structure or NULL for no write to + // mouse list (non-zero means write sprite-shape to + // mouse list) + // 1 pointer to graphic structure + // 2 pointer to mega structure or NULL if not a mega + + _vm->_screen->registerFrame( + decodePtr(params[0]), + decodePtr(params[1]), + decodePtr(params[2])); + return IR_CONT; +} + +int32 Logic::fnNoSprite(int32 *params) { + // params: 0 pointer to object's graphic structure + _router->setSpriteStatus(decodePtr(params[0]), NO_SPRITE); + return IR_CONT; +} + +int32 Logic::fnSendSync(int32 *params) { + // params: 0 sync's recipient + // 1 sync value + + sendSync(params[0], params[1]); + return IR_CONT; +} + +int32 Logic::fnUpdatePlayerStats(int32 *params) { + // engine needs to know certain info about the player + + // params: 0 pointer to mega structure + + ObjectMega obMega(decodePtr(params[0])); + + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + screenInfo->player_feet_x = obMega.getFeetX(); + screenInfo->player_feet_y = obMega.getFeetY(); + + // for the script + writeVar(PLAYER_FEET_X, obMega.getFeetX()); + writeVar(PLAYER_FEET_Y, obMega.getFeetY()); + writeVar(PLAYER_CUR_DIR, obMega.getCurDir()); + writeVar(SCROLL_OFFSET_X, screenInfo->scroll_offset_x); + + debug(5, "fnUpdatePlayerStats: %d %d", + obMega.getFeetX(), obMega.getFeetY()); + + return IR_CONT; +} + +int32 Logic::fnPassGraph(int32 *params) { + // makes an engine local copy of passed ObjectGraphic - run script 4 + // of an object to request this used by fnTurnTo(id) etc + // + // remember, we cannot simply read a compact any longer but instead + // must request it from the object itself + + // params: 0 pointer to an ObjectGraphic structure + + warning("fnPassGraph() is a no-op now"); + return IR_CONT; +} + +int32 Logic::fnInitFloorMouse(int32 *params) { + // params: 0 pointer to object's mouse structure + + byte *ob_mouse = decodePtr(params[0]); + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + // floor is always lowest priority + + ObjectMouse mouse; + + mouse.x1 = 0; + mouse.y1 = 0; + mouse.x2 = screenInfo->screen_wide - 1; + mouse.y2 = screenInfo->screen_deep - 1; + mouse.priority = 9; + mouse.pointer = NORMAL_MOUSE_ID; + + mouse.write(ob_mouse); + return IR_CONT; +} + +int32 Logic::fnPassMega(int32 *params) { + // makes an engine local copy of passed mega_structure - run script 4 + // of an object to request this used by fnTurnTo(id) etc + // + // remember, we cannot simply read a compact any longer but instead + // must request it from the object itself + + // params: 0 pointer to a mega structure + + memcpy(_engineMega, decodePtr(params[0]), ObjectMega::size()); + return IR_CONT; +} + +/** + * Turn mega to face point (x,y) on the floor + */ + +int32 Logic::fnFaceXY(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 pointer to object's graphic structure + // 2 pointer to object's mega structure + // 3 pointer to object's walkdata structure + // 4 target x-coord + // 5 target y-coord + + return _router->faceXY( + decodePtr(params[0]), + decodePtr(params[1]), + decodePtr(params[2]), + decodePtr(params[3]), + params[4], params[5]); +} + +/** + * Causes no more objects in this logic loop to be processed. The logic engine + * will restart at the beginning of the new list. The current screen will not + * be drawn! + */ + +int32 Logic::fnEndSession(int32 *params) { + // params: 0 id of new run-list + + // terminate current and change to next run-list + expressChangeSession(params[0]); + + // stop the script - logic engine will now go around and the new + // screen will begin + return IR_STOP; +} + +int32 Logic::fnNoHuman(int32 *params) { + // params: none + + _vm->_mouse->noHuman(); + return IR_CONT; +} + +int32 Logic::fnAddHuman(int32 *params) { + // params: none + + _vm->_mouse->addHuman(); + return IR_CONT; +} + +/** + * Wait for a target to become waiting, i.e. not busy. + */ + +int32 Logic::fnWeWait(int32 *params) { + // params: 0 target + + assert(_vm->_resman->fetchType(params[0]) == GAME_OBJECT); + + // Run the target's get-speech-state script + runResScript(params[0], 5); + + if (readVar(RESULT) == 0) { + // The target is busy. Try again. + _vm->_debugger->_speechScriptWaiting = params[0]; + return IR_REPEAT; + } + + // The target is waiting, i.e. not busy. + + _vm->_debugger->_speechScriptWaiting = 0; + return IR_CONT; +} + +/** + * Wait for a target to become waiting, i.e. not busy, send a command to it, + * then wait for it to finish. + */ + +int32 Logic::fnTheyDoWeWait(int32 *params) { + // params: 0 pointer to ob_logic + // 1 target + // 2 command + // 3 ins1 + // 4 ins2 + // 5 ins3 + // 6 ins4 + // 7 ins5 + + assert(_vm->_resman->fetchType(params[1]) == GAME_OBJECT); + + // Run the target's get-speech-state script + runResScript(params[1], 5); + + ObjectLogic obLogic(decodePtr(params[0])); + + if (readVar(RESULT) == 1 && readVar(INS_COMMAND) == 0 && obLogic.getLooping() == 0) { + // The target is waiting, i.e. not busy, and there is no other + // command queued. We haven't sent the command yet, so do it. + + debug(5, "fnTheyDoWeWait: sending command to %d", params[1]); + + _vm->_debugger->_speechScriptWaiting = params[1]; + obLogic.setLooping(1); + + writeVar(SPEECH_ID, params[1]); + writeVar(INS_COMMAND, params[2]); + writeVar(INS1, params[3]); + writeVar(INS2, params[4]); + writeVar(INS3, params[5]); + writeVar(INS4, params[6]); + writeVar(INS5, params[7]); + + return IR_REPEAT; + } + + if (obLogic.getLooping() == 0) { + // The command has not been sent yet. Keep waiting. + _vm->_debugger->_speechScriptWaiting = params[1]; + return IR_REPEAT; + } + + if (readVar(RESULT) == 0) { + // The command has been sent, and the target is busy doing it. + // Wait for it to finish. + + debug(5, "fnTheyDoWeWait: Waiting for %d to finish", params[1]); + + _vm->_debugger->_speechScriptWaiting = params[1]; + return IR_REPEAT; + } + + debug(5, "fnTheyDoWeWait: %d finished", params[1]); + + obLogic.setLooping(0); + _vm->_debugger->_speechScriptWaiting = 0; + return IR_CONT; +} + +/** + * Wait for a target to become waiting, i.e. not busy, then send a command to + * it. + */ + +int32 Logic::fnTheyDo(int32 *params) { + // params: 0 target + // 1 command + // 2 ins1 + // 3 ins2 + // 4 ins3 + // 5 ins4 + // 6 ins5 + + assert(_vm->_resman->fetchType(params[0]) == GAME_OBJECT); + + // Run the target's get-speech-state script + runResScript(params[0], 5); + + if (readVar(RESULT) == 1 && !readVar(INS_COMMAND)) { + // The target is waiting, i.e. not busy, and there is no other + // command queued. Send the command. + + debug(5, "fnTheyDo: sending command to %d", params[0]); + + _vm->_debugger->_speechScriptWaiting = 0; + + writeVar(SPEECH_ID, params[0]); + writeVar(INS_COMMAND, params[1]); + writeVar(INS1, params[2]); + writeVar(INS2, params[3]); + writeVar(INS3, params[4]); + writeVar(INS4, params[5]); + writeVar(INS5, params[6]); + + return IR_CONT; + } + + // The target is busy. Come back again next cycle. + + _vm->_debugger->_speechScriptWaiting = params[0]; + return IR_REPEAT; +} + +/** + * Route to the left or right hand side of target id, if possible. + */ + +int32 Logic::fnWalkToTalkToMega(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 pointer to object's graphic structure + // 2 pointer to object's mega structure + // 3 pointer to object's walkdata structure + // 4 id of target mega to face + // 5 separation + + return _router->walkToTalkToMega( + decodePtr(params[0]), + decodePtr(params[1]), + decodePtr(params[2]), + decodePtr(params[3]), + params[4], params[5]); +} + +int32 Logic::fnFadeDown(int32 *params) { + // NONE means up! can only be called when screen is fully faded up - + // multiple calls wont have strange effects + + // params: none + + if (_vm->_screen->getFadeStatus() == RDFADE_NONE) + _vm->_screen->fadeDown(); + + return IR_CONT; +} + +enum { + S_OB_GRAPHIC = 0, + S_OB_SPEECH = 1, + S_OB_LOGIC = 2, + S_OB_MEGA = 3, + + S_TEXT = 4, + S_WAV = 5, + S_ANIM = 6, + S_DIR_TABLE = 7, + S_ANIM_MODE = 8 +}; + +/** + * It's the super versatile fnSpeak. Text and wavs can be selected in any + * combination. + * + * @note We can assume no human - there should be no human, at least! + */ + +int32 Logic::fnISpeak(int32 *params) { + // params: 0 pointer to ob_graphic + // 1 pointer to ob_speech + // 2 pointer to ob_logic + // 3 pointer to ob_mega + // 4 encoded text number + // 5 wav res id + // 6 anim res id + // 7 anim table res id + // 8 animation mode 0 lip synced, + // 1 just straight animation + + static bool cycle_skip = false; + static bool speechRunning; + + // Set up the pointers which we know we'll always need + + ObjectLogic obLogic(decodePtr(params[S_OB_LOGIC])); + ObjectGraphic obGraph(decodePtr(params[S_OB_GRAPHIC])); + + // FIRST TIME ONLY: create the text, load the wav, set up the anim, + // etc. + + if (obLogic.getLooping() == 0) { + // New fudge to wait for smacker samples to finish + // since they can over-run into the game + + if (_vm->_sound->getSpeechStatus() != RDSE_SAMPLEFINISHED) + return IR_REPEAT; + + // New fudge for 'fx' subtitles: If subtitles switched off, and + // we don't want to use a wav for this line either, then just + // quit back to script right now! + + if (!_vm->getSubtitles() && !wantSpeechForLine(params[S_WAV])) + return IR_CONT; + + // Drop out for 1st cycle to allow walks/anims to end and + // display last frame before system locks while speech loaded + + if (!cycle_skip) { + cycle_skip = true; + return IR_REPEAT; + } + + cycle_skip = false; + + _vm->_debugger->_textNumber = params[S_TEXT]; + + // Pull out the text line to get the official text number + // (for wav id). Once the wav id's go into all script text + // commands, we'll only need this for debugging. + + uint32 text_res = params[S_TEXT] / SIZE; + uint32 local_text = params[S_TEXT] & 0xffff; + + // For testing all text & speech! + // + // A script loop can send any text number to fnISpeak and it + // will only run the valid ones or return with 'result' equal + // to '1' or '2' to mean 'invalid text resource' and 'text + // number out of range' respectively + // + // See 'testing_routines' object in George's Player Character + // section of linc + + if (readVar(SYSTEM_TESTING_TEXT)) { + if (!_vm->_resman->checkValid(text_res)) { + // Not a valid resource number - invalid (null + // resource) + writeVar(RESULT, 1); + return IR_CONT; + } + + if (_vm->_resman->fetchType(text_res) != TEXT_FILE) { + // Invalid - not a text resource + _vm->_resman->closeResource(text_res); + writeVar(RESULT, 1); + return IR_CONT; + } + + if (!_vm->checkTextLine(_vm->_resman->openResource(text_res), local_text)) { + // Line number out of range + _vm->_resman->closeResource(text_res); + writeVar(RESULT, 2); + return IR_CONT; + } + + _vm->_resman->closeResource(text_res); + writeVar(RESULT, 0); + } + + byte *text = _vm->fetchTextLine(_vm->_resman->openResource(text_res), local_text); + _officialTextNumber = READ_LE_UINT16(text); + _vm->_resman->closeResource(text_res); + + // Prevent dud lines from appearing while testing text & speech + // since these will not occur in the game anyway + + if (readVar(SYSTEM_TESTING_TEXT)) { + // If actor number is 0 and text line is just a 'dash' + // character + if (_officialTextNumber == 0 && text[2] == '-' && text[3] == 0) { + writeVar(RESULT, 3); + return IR_CONT; + } + } + + // Set the 'looping_flag' and the text-click-delays. We can + // left-click past the text after half a second, and + // right-click past it after a quarter of a second. + + obLogic.setLooping(1); + _leftClickDelay = 6; + _rightClickDelay = 3; + + if (readVar(PLAYER_ID) != CUR_PLAYER_ID) + debug(5, "(%d) Nico: %s", _officialTextNumber, text + 2); + else { + byte buf[NAME_LEN]; + + debug(5, "(%d) %s: %s", _officialTextNumber, _vm->_resman->fetchName(readVar(ID), buf), text + 2); + } + + // Set up the speech animation + + if (params[S_ANIM]) { + // Just a straight anim. + _animId = params[6]; + } else if (params[S_DIR_TABLE]) { + // Use this direction table to derive the anim + // NB. ASSUMES WE HAVE A MEGA OBJECT!! + + ObjectMega obMega(decodePtr(params[S_OB_MEGA])); + byte *anim_table = decodePtr(params[S_DIR_TABLE]); + + _animId = READ_LE_UINT32(anim_table + 4 * obMega.getCurDir()); + } else { + // No animation choosen + _animId = 0; + } + + if (_animId) { + // Set the talker's graphic to the first frame of this + // speech anim for now. + + _speechAnimType = readVar(SPEECHANIMFLAG); + obGraph.setAnimResource(_animId); + obGraph.setAnimPc(0); + } + + // Default back to looped lip synced anims. + writeVar(SPEECHANIMFLAG, 0); + + // Set up _textX and _textY for speech panning and/or text + // sprite position. + + locateTalker(params); + + // Is it to be speech or subtitles or both? + + // Assume not running until know otherwise + speechRunning = false; + + // New fudge for 'fx' subtitles: If speech is selected, and + // this line is allowed speech (not if it's an fx subtitle!) + + if (!_vm->_sound->isSpeechMute() && wantSpeechForLine(_officialTextNumber)) { + // If the wavId parameter is zero because not yet + // compiled into speech command, we can still get it + // from the 1st 2 chars of the text line. + + if (!params[S_WAV]) + params[S_WAV] = (int32)_officialTextNumber; + + // Panning goes from -16 (left) to 16 (right) + int8 speech_pan = ((_textX - 320) * 16) / 320; + + if (speech_pan < -16) + speech_pan = -16; + else if (speech_pan > 16) + speech_pan = 16; + + uint32 rv = _vm->_sound->playCompSpeech(params[S_WAV], 16, speech_pan); + + if (rv == RD_OK) { + // Ok, we've got something to play. Set it + // playing now. (We might want to do this the + // next cycle, don't know yet.) + + speechRunning = true; + _vm->_sound->unpauseSpeech(); + } else { + debug(5, "ERROR: PlayCompSpeech(wav=%d (res=%d pos=%d)) returned %.8x", params[S_WAV], text_res, local_text, rv); + } + } + + if (_vm->getSubtitles() || !speechRunning) { + // We want subtitles, or the speech failed to load. + // Either way, we're going to show the text so create + // the text sprite. + + formText(params); + } + } + + // EVERY TIME: run a cycle of animation, if there is one + + if (_animId) { + // There is an animation - Increment the anim frame number. + obGraph.setAnimPc(obGraph.getAnimPc() + 1); + + byte *anim_file = _vm->_resman->openResource(obGraph.getAnimResource()); + AnimHeader anim_head; + + anim_head.read(_vm->fetchAnimHeader(anim_file)); + + if (!_speechAnimType) { + // ANIM IS TO BE LIP-SYNC'ED & REPEATING + + if (obGraph.getAnimPc() == (int32)anim_head.noAnimFrames) { + // End of animation - restart from frame 0 + obGraph.setAnimPc(0); + } else if (speechRunning && _vm->_sound->amISpeaking() == RDSE_QUIET) { + // The speech is running, but we're at a quiet + // bit. Restart from frame 0 (closed mouth). + obGraph.setAnimPc(0); + } + } else { + // ANIM IS TO PLAY ONCE ONLY + if (obGraph.getAnimPc() == (int32)anim_head.noAnimFrames - 1) { + // Reached the last frame of the anim. Hold + // anim on this last frame + _animId = 0; + } + } + + _vm->_resman->closeResource(obGraph.getAnimResource()); + } else if (_speechAnimType) { + // Placed here so we actually display the last frame of the + // anim. + _speechAnimType = 0; + } + + // EVERY TIME: FIND OUT IF WE NEED TO STOP THE SPEECH NOW... + + // If there is a wav then we're using that to end the speech naturally + + bool speechFinished = false; + + // If playing a sample + + if (speechRunning) { + // Has it finished? + if (_vm->_sound->getSpeechStatus() == RDSE_SAMPLEFINISHED) + speechFinished = true; + } else if (!speechRunning && _speechTime) { + // Counting down text time because there is no sample - this + // ends the speech + + // if no sample then we're using _speechTime to end speech + // naturally + + _speechTime--; + if (!_speechTime) + speechFinished = true; + } + + // Ok, all is running along smoothly - but a click means stop + // unnaturally + + int mouseX, mouseY; + + _vm->_mouse->getPos(mouseX, mouseY); + + // So that we can go to the options panel while text & speech is + // being tested + if (readVar(SYSTEM_TESTING_TEXT) == 0 || mouseY > 0) { + MouseEvent *me = _vm->mouseEvent(); + + // Note that we now have TWO click-delays - one for LEFT + // button, one for RIGHT BUTTON + + if ((!_leftClickDelay && me && (me->buttons & RD_LEFTBUTTONDOWN)) || + (!_rightClickDelay && me && (me->buttons & RD_RIGHTBUTTONDOWN))) { + // Mouse click, after click_delay has expired -> end + // the speech. + + // if testing text & speech + if (readVar(SYSTEM_TESTING_TEXT)) { + // and RB used to click past text + if (me->buttons & RD_RIGHTBUTTONDOWN) { + // then we want the previous line again + writeVar(SYSTEM_WANT_PREVIOUS_LINE, 1); + } else { + // LB just want next line again + writeVar(SYSTEM_WANT_PREVIOUS_LINE, 0); + } + } + + speechFinished = true; + + // if speech sample playing, halt it prematurely + if (speechRunning) + _vm->_sound->stopSpeech(); + } + } + + // If we are finishing the speech this cycle, do the business + + // !speechAnimType, as we want an anim which is playing once to have + // finished. + + if (speechFinished && !_speechAnimType) { + // If there is text, kill it + if (_speechTextBlocNo) { + _vm->_fontRenderer->killTextBloc(_speechTextBlocNo); + _speechTextBlocNo = 0; + } + + // if there is a speech anim, end it on closed mouth frame + if (_animId) { + _animId = 0; + obGraph.setAnimPc(0); + } + + speechRunning = false; + + // no longer in a script function loop + obLogic.setLooping(0); + + _vm->_debugger->_textNumber = 0; + + // reset to zero, in case text line not even extracted (since + // this number comes from the text line) + _officialTextNumber = 0; + + writeVar(RESULT, 0); + return IR_CONT; + } + + // Speech still going, so decrement the click_delay if it's still + // active + + if (_leftClickDelay) + _leftClickDelay--; + + if (_rightClickDelay) + _rightClickDelay--; + + return IR_REPEAT; +} + +/** + * Reset the object and restart script 1 on level 0 + */ + +int32 Logic::fnTotalRestart(int32 *params) { + // mega runs this to restart its base logic again - like being cached + // in again + + // params: none + + _curObjectHub.setLogicLevel(0); + _curObjectHub.setScriptPc(0, 1); + + return IR_TERMINATE; +} + +int32 Logic::fnSetWalkGrid(int32 *params) { + // params: none + + warning("fnSetWalkGrid() is no longer a valid opcode"); + return IR_CONT; +} + +/** + * Receive and sequence the commands sent from the conversation script. We have + * to do this in a slightly tweeky manner as we can no longer have generic + * scripts. + */ + +enum { + INS_talk = 1, + INS_anim = 2, + INS_reverse_anim = 3, + INS_walk = 4, + INS_turn = 5, + INS_face = 6, + INS_trace = 7, + INS_no_sprite = 8, + INS_sort = 9, + INS_foreground = 10, + INS_background = 11, + INS_table_anim = 12, + INS_reverse_table_anim = 13, + INS_walk_to_anim = 14, + INS_set_frame = 15, + INS_stand_after_anim = 16, + INS_quit = 42 +}; + +int32 Logic::fnSpeechProcess(int32 *params) { + // params: 0 pointer to ob_graphic + // 1 pointer to ob_speech + // 2 pointer to ob_logic + // 3 pointer to ob_mega + // 4 pointer to ob_walkdata + + ObjectSpeech obSpeech(decodePtr(params[1])); + + while (1) { + int32 pars[9]; + + // Check which command we're waiting for, and call the + // appropriate function. Once we're done, clear the command + // and set wait_state to 1. + // + // Note: we could save a var and ditch wait_state and check + // 'command' for non zero means busy + // + // Note: I can't see that we ever check the value of wait_state + // but perhaps it accesses that memory location directly? + + switch (obSpeech.getCommand()) { + case 0: + break; + case INS_talk: + pars[0] = params[0]; // ob_graphic + pars[1] = params[1]; // ob_speech + pars[2] = params[2]; // ob_logic + pars[3] = params[3]; // ob_mega + pars[4] = obSpeech.getIns1(); // encoded text number + pars[5] = obSpeech.getIns2(); // wav res id + pars[6] = obSpeech.getIns3(); // anim res id + pars[7] = obSpeech.getIns4(); // anim table res id + pars[8] = obSpeech.getIns5(); // animation mode - 0 lip synced, 1 just straight animation + + if (fnISpeak(pars) != IR_REPEAT) { + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + } + + return IR_REPEAT; + case INS_turn: + pars[0] = params[2]; // ob_logic + pars[1] = params[0]; // ob_graphic + pars[2] = params[3]; // ob_mega + pars[3] = params[4]; // ob_walkdata + pars[4] = obSpeech.getIns1(); // direction to turn to + + if (fnTurn(pars) != IR_REPEAT) { + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + } + + return IR_REPEAT; + case INS_face: + pars[0] = params[2]; // ob_logic + pars[1] = params[0]; // ob_graphic + pars[2] = params[3]; // ob_mega + pars[3] = params[4]; // ob_walkdata + pars[4] = obSpeech.getIns1(); // target + + if (fnFaceMega(pars) != IR_REPEAT) { + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + } + + return IR_REPEAT; + case INS_anim: + pars[0] = params[2]; // ob_logic + pars[1] = params[0]; // ob_graphic + pars[2] = obSpeech.getIns1(); // anim res + + if (fnAnim(pars) != IR_REPEAT) { + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + } + + return IR_REPEAT; + case INS_reverse_anim: + pars[0] = params[2]; // ob_logic + pars[1] = params[0]; // ob_graphic + pars[2] = obSpeech.getIns1(); // anim res + + if (fnReverseAnim(pars) != IR_REPEAT) { + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + } + + return IR_REPEAT; + case INS_table_anim: + pars[0] = params[2]; // ob_logic + pars[1] = params[0]; // ob_graphic + pars[2] = params[3]; // ob_mega + pars[3] = obSpeech.getIns1(); // pointer to anim table + + if (fnMegaTableAnim(pars) != IR_REPEAT) { + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + } + + return IR_REPEAT; + case INS_reverse_table_anim: + pars[0] = params[2]; // ob_logic + pars[1] = params[0]; // ob_graphic + pars[2] = params[3]; // ob_mega + pars[3] = obSpeech.getIns1(); // pointer to anim table + + if (fnReverseMegaTableAnim(pars) != IR_REPEAT) { + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + } + + return IR_REPEAT; + case INS_no_sprite: + fnNoSprite(params); // ob_graphic + + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + return IR_REPEAT ; + case INS_sort: + fnSortSprite(params); // ob_graphic + + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + return IR_REPEAT; + case INS_foreground: + fnForeSprite(params); // ob_graphic + + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + return IR_REPEAT; + case INS_background: + fnBackSprite(params); // ob_graphic + + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + return IR_REPEAT; + case INS_walk: + pars[0] = params[2]; // ob_logic + pars[1] = params[0]; // ob_graphic + pars[2] = params[3]; // ob_mega + pars[3] = params[4]; // ob_walkdata + pars[4] = obSpeech.getIns1(); // target x + pars[5] = obSpeech.getIns2(); // target y + pars[6] = obSpeech.getIns3(); // target direction + + if (fnWalk(pars) != IR_REPEAT) { + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + } + + return IR_REPEAT; + case INS_walk_to_anim: + pars[0] = params[2]; // ob_logic + pars[1] = params[0]; // ob_graphic + pars[2] = params[3]; // ob_mega + pars[3] = params[4]; // ob_walkdata + pars[4] = obSpeech.getIns1(); // anim resource + + if (fnWalkToAnim(pars) != IR_REPEAT) { + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + } + + return IR_REPEAT; + case INS_stand_after_anim: + pars[0] = params[0]; // ob_graphic + pars[1] = params[3]; // ob_mega + pars[2] = obSpeech.getIns1(); // anim resource + + fnStandAfterAnim(pars); + + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + return IR_REPEAT; + case INS_set_frame: + pars[0] = params[0]; // ob_graphic + pars[1] = obSpeech.getIns1(); // anim_resource + pars[2] = obSpeech.getIns2(); // FIRST_FRAME or LAST_FRAME + fnSetFrame(pars); + + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + return IR_REPEAT; + case INS_quit: + // That's it - we're finished with this + obSpeech.setCommand(0); + // obSpeech.setWaitState(0); + return IR_CONT; + default: + // Unimplemented command - just cancel + obSpeech.setCommand(0); + obSpeech.setWaitState(1); + break; + } + + if (readVar(SPEECH_ID) == readVar(ID)) { + // There's a new command for us! Grab the command - + // potentially we only have this cycle to do this - and + // set things up so that the command will be picked up + // on the next iteration of the while loop. + + debug(5, "fnSpeechProcess: Received new command %d", readVar(INS_COMMAND)); + + writeVar(SPEECH_ID, 0); + + obSpeech.setCommand(readVar(INS_COMMAND)); + obSpeech.setIns1(readVar(INS1)); + obSpeech.setIns2(readVar(INS2)); + obSpeech.setIns3(readVar(INS3)); + obSpeech.setIns4(readVar(INS4)); + obSpeech.setIns5(readVar(INS5)); + obSpeech.setWaitState(0); + + writeVar(INS_COMMAND, 0); + } else { + // No new command. We could run a blink anim (or + // something) here. + + obSpeech.setWaitState(1); + return IR_REPEAT; + } + } +} + +int32 Logic::fnSetScaling(int32 *params) { + // params: 0 pointer to object's mega structure + // 1 scale constant A + // 2 scale constant B + + // 256 * s = A * y + B + + // Where s is system scale, which itself is (256 * actual_scale) ie. + // s == 128 is half size + + ObjectMega obMega(decodePtr(params[0])); + + obMega.setScaleA(params[1]); + obMega.setScaleB(params[2]); + + return IR_CONT; +} + +int32 Logic::fnStartEvent(int32 *params) { + // params: none + + startEvent(); + return IR_TERMINATE; +} + +int32 Logic::fnCheckEventWaiting(int32 *params) { + // params: none + + writeVar(RESULT, checkEventWaiting()); + return IR_CONT; +} + +int32 Logic::fnRequestSpeech(int32 *params) { + // change current script - must be followed by a TERMINATE script + // directive + + // params: 0 id of target to catch the event and startup speech + // servicing + + // Full script id to interact with - megas run their own 7th script + sendEvent(params[0], (params[0] << 16) | 6); + return IR_CONT; +} + +int32 Logic::fnGosub(int32 *params) { + // params: 0 id of script + + // Hurray, script subroutines. Logic goes up - pc is saved for current + // level. + logicUp(params[0]); + return IR_GOSUB; +} + +/** + * Wait for a target to become waiting, i.e. not busy, or until we time out. + * This is useful when clicking on a target to talk to it, and it doesn't + * reply. This way, we won't lock up. + * + * If the target becomes waiting, RESULT is set to 0. If we time out, RESULT is + * set to 1. + */ + +int32 Logic::fnTimedWait(int32 *params) { + // params: 0 ob_logic + // 1 target + // 2 number of cycles before give up + + assert(_vm->_resman->fetchType(params[1]) == GAME_OBJECT); + + ObjectLogic obLogic(decodePtr(params[0])); + + if (obLogic.getLooping() == 0) { + // This is the first time, so set up the time-out. + obLogic.setLooping(params[2]); + } + + // Run the target's get-speech-state script + runResScript(params[1], 5); + + if (readVar(RESULT) == 1) { + // The target is waiting, i.e. not busy + + _vm->_debugger->_speechScriptWaiting = 0; + + obLogic.setLooping(0); + writeVar(RESULT, 0); + return IR_CONT; + } + + obLogic.setLooping(obLogic.getLooping() - 1); + + if (obLogic.getLooping() == 0) { + // Time's up. + + debug(5, "fnTimedWait: Timed out waiting for %d", params[1]); + _vm->_debugger->_speechScriptWaiting = 0; + + // Clear the event that hasn't been picked up - in theory, + // none of this should ever happen. + + killAllIdsEvents(params[1]); + writeVar(RESULT, 1); + return IR_CONT; + } + + // Target is busy. Keep trying. + + _vm->_debugger->_speechScriptWaiting = params[1]; + return IR_REPEAT; +} + +int32 Logic::fnPlayFx(int32 *params) { + // params: 0 sample resource id + // 1 type (FX_SPOT, FX_RANDOM, FX_LOOP) + // 2 delay (0..65535) + // 3 volume (0..16) + // 4 pan (-16..16) + + // example script: + // fnPlayFx (FXWATER, FX_LOOP, 0, 10, 15); + // // fx_water is just a local script flag + // fx_water = result; + // . + // . + // . + // fnStopFx (fx_water); + + int32 res = params[0]; + int32 type = params[1]; + int32 delay = params[2]; + int32 volume = params[3]; + int32 pan = params[4]; + + _vm->_sound->queueFx(res, type, delay, volume, pan); + return IR_CONT; +} + +int32 Logic::fnStopFx(int32 *params) { + // params: 0 position in queue + if (_vm->_sound->stopFx(params[0]) != RD_OK) + debug(5, "SFX ERROR: Trying to stop an inactive sound slot"); + + return IR_CONT; +} + +/** + * Start a tune playing, to play once or to loop until stopped or next one + * played. + */ + +int32 Logic::fnPlayMusic(int32 *params) { + // params: 0 tune id + // 1 loop flag (0 or 1) + + char filename[128]; + bool loopFlag; + uint32 rv; + + loopFlag = (params[1] == FX_LOOP); + + rv = _vm->_sound->streamCompMusic(params[0], loopFlag); + + if (rv) + debug(5, "ERROR: streamCompMusic(%s, %d, %d) returned error 0x%.8x", filename, params[0], loopFlag, rv); + + return IR_CONT; +} + +int32 Logic::fnStopMusic(int32 *params) { + // params: none + + _vm->_sound->stopMusic(false); + return IR_CONT; +} + +int32 Logic::fnSetValue(int32 *params) { + // temp. function! + + // used for setting far-referenced megaset resource field in mega + // object, from start script + + // params: 0 pointer to object's mega structure + // 1 value to set it to + + ObjectMega obMega(decodePtr(params[0])); + + obMega.setMegasetRes(params[1]); + return IR_CONT; +} + +int32 Logic::fnNewScript(int32 *params) { + // change current script - must be followed by a TERMINATE script + // directive + + // params: 0 id of script + + writeVar(PLAYER_ACTION, 0); // must clear this + logicReplace(params[0]); + return IR_TERMINATE; +} + +/** + * Like getSync(), but called from scripts. Sets the RESULT variable to + * the sync value, or 0 if none is found. + */ + +int32 Logic::fnGetSync(int32 *params) { + // params: none + + int slot = getSync(); + + writeVar(RESULT, (slot != -1) ? _syncList[slot].sync : 0); + return IR_CONT; +} + +/** + * Wait for sync to happen. Sets the RESULT variable to the sync value, once + * it has been found. + */ + +int32 Logic::fnWaitSync(int32 *params) { + // params: none + + debug(6, "fnWaitSync: %d waits", readVar(ID)); + + int slot = getSync(); + + if (slot == -1) + return IR_REPEAT; + + debug(5, "fnWaitSync: %d got sync %d", readVar(ID), _syncList[slot].sync); + writeVar(RESULT, _syncList[slot].sync); + return IR_CONT; +} + +int32 Logic::fnRegisterWalkGrid(int32 *params) { + // params: none + + warning("fnRegisterWalkGrid() is no longer a valid opcode"); + return IR_CONT; +} + +int32 Logic::fnReverseMegaTableAnim(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 pointer to object's graphic structure + // 2 pointer to object's mega structure + // 3 pointer to animation table + + // Reverse anim + return _router->megaTableAnimate( + decodePtr(params[0]), + decodePtr(params[1]), + decodePtr(params[2]), + decodePtr(params[3]), + true); +} + +int32 Logic::fnReverseAnim(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 pointer to object's graphic structure + // 2 resource id of animation file + + // Reverse anim + return _router->doAnimate( + decodePtr(params[0]), + decodePtr(params[1]), + params[2], true); +} + +/** + * Mark this object for killing - to be killed when player leaves this screen. + * Object reloads and script restarts upon re-entry to screen, which causes + * this object's startup logic to be re-run every time we enter the screen. + * "Which is nice." + * + * @note Call ONCE from object's logic script, i.e. in startup code, so not + * re-called every time script frops off and restarts! + */ + +int32 Logic::fnAddToKillList(int32 *params) { + // params: none + uint32 id = readVar(ID); + + // DON'T EVER KILL GEORGE! + if (id == CUR_PLAYER_ID) + return IR_CONT; + + // Scan the list to see if it's already included + + for (uint32 i = 0; i < _kills; i++) { + if (_objectKillList[i] == id) + return IR_CONT; + } + + assert(_kills < OBJECT_KILL_LIST_SIZE); // no room at the inn + + _objectKillList[_kills++] = id; + + // "another one bites the dust" + + // When we leave the screen, all these object resources are to be + // cleaned out of memory and the kill list emptied by doing + // '_kills = 0', ensuring that all resources are in fact still in + // memory and, more importantly, closed before killing! + + return IR_CONT; +} + +/** + * Set the standby walk coords to be used by fnWalkToAnim() and + * fnStandAfterAnim() when the anim header's start/end coords are zero. + * Useful during development; can stay in final game anyway. + */ + +int32 Logic::fnSetStandbyCoords(int32 *params) { + // params: 0 x-coord + // 1 y-coord + // 2 direction (0..7) + + _router->setStandbyCoords(params[0], params[1], params[2]); + return IR_CONT; +} + +int32 Logic::fnBackPar0Sprite(int32 *params) { + // params: 0 pointer to object's graphic structure + _router->setSpriteStatus(decodePtr(params[0]), BGP0_SPRITE); + return IR_CONT; +} + +int32 Logic::fnBackPar1Sprite(int32 *params) { + // params: 0 pointer to object's graphic structure + _router->setSpriteStatus(decodePtr(params[0]), BGP1_SPRITE); + return IR_CONT; +} + +int32 Logic::fnForePar0Sprite(int32 *params) { + // params: 0 pointer to object's graphic structure + _router->setSpriteStatus(decodePtr(params[0]), FGP0_SPRITE); + return IR_CONT; +} + +int32 Logic::fnForePar1Sprite(int32 *params) { + // params: 0 pointer to object's graphic structure + _router->setSpriteStatus(decodePtr(params[0]), FGP1_SPRITE); + return IR_CONT; +} + +int32 Logic::fnSetPlayerActionEvent(int32 *params) { + // we want to intercept the player character and have him interact + // with an object - from script this code is the same as the mouse + // engine calls when you click on an object - here, a third party + // does the clicking IYSWIM + + // note - this routine used CUR_PLAYER_ID as the target + + // params: 0 id to interact with + + setPlayerActionEvent(CUR_PLAYER_ID, params[0]); + return IR_CONT; +} + +/** + * Set the special scroll offset variables + * + * Call when starting screens and to change the camera within screens + * + * call AFTER fnInitBackground() to override the defaults + */ + +int32 Logic::fnSetScrollCoordinate(int32 *params) { + // params: 0 feet_x value + // 1 feet_y value + + // Called feet_x and feet_y to retain intellectual compatibility with + // Sword1! + // + // feet_x & feet_y refer to the physical screen coords where the + // system will try to maintain George's feet + + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + screenInfo->feet_x = params[0]; + screenInfo->feet_y = params[1]; + return IR_CONT; +} + +/** + * Stand mega at start position of anim + */ + +int32 Logic::fnStandAtAnim(int32 *params) { + // params: 0 pointer to object's graphic structure + // 1 pointer to object's mega structure + // 2 anim resource id + + _router->standAtAnim( + decodePtr(params[0]), + decodePtr(params[1]), + params[2]); + return IR_CONT; +} + +#define SCROLL_MOUSE_WIDTH 20 + +int32 Logic::fnSetScrollLeftMouse(int32 *params) { + // params: 0 pointer to object's mouse structure + + byte *ob_mouse = decodePtr(params[0]); + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + // Highest priority + + ObjectMouse mouse; + + mouse.x1 = 0; + mouse.y1 = 0; + mouse.x2 = screenInfo->scroll_offset_x + SCROLL_MOUSE_WIDTH; + mouse.y2 = screenInfo->screen_deep - 1; + mouse.priority = 0; + + if (screenInfo->scroll_offset_x > 0) { + // not fully scrolled to the left + mouse.pointer = SCROLL_LEFT_MOUSE_ID; + } else { + // so the mouse area doesn't get registered + mouse.pointer = 0; + } + + mouse.write(ob_mouse); + return IR_CONT; +} + +int32 Logic::fnSetScrollRightMouse(int32 *params) { + // params: 0 pointer to object's mouse structure + + byte *ob_mouse = decodePtr(params[0]); + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + // Highest priority + + ObjectMouse mouse; + + mouse.x1 = screenInfo->scroll_offset_x + _vm->_screen->getScreenWide() - SCROLL_MOUSE_WIDTH; + mouse.y1 = 0; + mouse.x2 = screenInfo->screen_wide - 1; + mouse.y2 = screenInfo->screen_deep - 1; + mouse.priority = 0; + + if (screenInfo->scroll_offset_x < screenInfo->max_scroll_offset_x) { + // not fully scrolled to the right + mouse.pointer = SCROLL_RIGHT_MOUSE_ID; + } else { + // so the mouse area doesn't get registered + mouse.pointer = 0; + } + + mouse.write(ob_mouse); + return IR_CONT; +} + +int32 Logic::fnColour(int32 *params) { + // set border colour - useful during script development + // eg. set to colour during a timer situation, then black when timed + // out + + // params 0: colour (see defines above) + +#ifdef SWORD2_DEBUG + // what colour? + switch (params[0]) { + case BLACK: + _vm->_screen->setPalette(0, 1, black, RDPAL_INSTANT); + break; + case WHITE: + _vm->_screen->setPalette(0, 1, white, RDPAL_INSTANT); + break; + case RED: + _vm->_screen->setPalette(0, 1, red, RDPAL_INSTANT); + break; + case GREEN: + _vm->_screen->setPalette(0, 1, green, RDPAL_INSTANT); + break; + case BLUE: + _vm->_screen->setPalette(0, 1, blue, RDPAL_INSTANT); + break; + } +#endif + + return IR_CONT; +} + +#ifdef SWORD2_DEBUG +#define BLACK 0 +#define WHITE 1 +#define RED 2 +#define GREEN 3 +#define BLUE 4 + +static uint8 black[4] = { 0, 0, 0, 0 }; +static uint8 white[4] = { 255, 255, 255, 0 }; +static uint8 red[4] = { 255, 0, 0, 0 }; +static uint8 green[4] = { 0, 255, 0, 0 }; +static uint8 blue[4] = { 0, 0, 255, 0 }; +#endif + +int32 Logic::fnFlash(int32 *params) { + // flash colour 0 (ie. border) - useful during script development + // eg. fnFlash(BLUE) where a text line is missed; RED when some code + // missing, etc + + // params: 0 colour to flash + +#ifdef SWORD2_DEBUG + // what colour? + switch (params[0]) { + case WHITE: + _vm->_screen->setPalette(0, 1, white, RDPAL_INSTANT); + break; + case RED: + _vm->_screen->setPalette(0, 1, red, RDPAL_INSTANT); + break; + case GREEN: + _vm->_screen->setPalette(0, 1, green, RDPAL_INSTANT); + break; + case BLUE: + _vm->_screen->setPalette(0, 1, blue, RDPAL_INSTANT); + break; + } + + // There used to be a busy-wait loop here, so I don't know how long + // the delay was meant to be. Probably doesn't matter much. + + _vm->_screen->updateDisplay(); + _vm->_system->delayMillis(250); + _vm->_screen->setPalette(0, 1, black, RDPAL_INSTANT); +#endif + + return IR_CONT; +} + +int32 Logic::fnPreFetch(int32 *params) { + // Go fetch resource in the background. + + // params: 0 resource to fetch [guess] + + return IR_CONT; +} + +/** + * Reverse of fnPassPlayerSaveData() - run script 8 of player object. + */ + +int32 Logic::fnGetPlayerSaveData(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 pointer to object's graphic structure + // 2 pointer to object's mega structure + + byte *ob_logic = decodePtr(params[0]); + byte *ob_graph = decodePtr(params[1]); + byte *ob_mega = decodePtr(params[2]); + + // Copy from savegame buffers to player object + + memcpy(ob_logic, _saveLogic, ObjectLogic::size()); + memcpy(ob_graph, _saveGraphic, ObjectGraphic::size()); + memcpy(ob_mega, _saveMega, ObjectMega::size()); + + // Any walk-data must be cleared - the player will be set to stand if + // he was walking when saved. + + ObjectMega obMega(ob_mega); + + if (obMega.getIsWalking()) { + ObjectLogic obLogic(ob_logic); + + obMega.setIsWalking(0); + + int32 pars[3]; + + pars[0] = params[1]; // ob_graphic; + pars[1] = params[2]; // ob_mega + pars[2] = obMega.getCurDir(); + + fnStand(pars); + + // Reset looping flag (which would have been 1 during fnWalk) + obLogic.setLooping(0); + } + + return IR_CONT; +} + +/** + * Copies the 4 essential player structures into the savegame header - run + * script 7 of player object to request this. + * + * Remember, we cannot simply read a compact any longer but instead must + * request it from the object itself. + */ + +int32 Logic::fnPassPlayerSaveData(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 pointer to object's graphic structure + // 2 pointer to object's mega structure + + // Copy from player object to savegame buffers + + memcpy(_saveLogic, decodePtr(params[0]), ObjectLogic::size()); + memcpy(_saveGraphic, decodePtr(params[1]), ObjectGraphic::size()); + memcpy(_saveMega, decodePtr(params[2]), ObjectMega::size()); + + return IR_CONT; +} + +int32 Logic::fnSendEvent(int32 *params) { + // we want to intercept the player character and have him interact + // with an object - from script + + // params: 0 id to receive event + // 1 script to run + + sendEvent(params[0], params[1]); + return IR_CONT; +} + +/** + * Add this walkgrid resource to the list of those used for routing in this + * location. Note that this is ignored if the resource is already in the list. + */ + +int32 Logic::fnAddWalkGrid(int32 *params) { + // params: 0 id of walkgrid resource + + // All objects that add walkgrids must be restarted whenever we + // re-enter a location. + + // DON'T EVER KILL GEORGE! + if (readVar(ID) != CUR_PLAYER_ID) { + // Need to call this in case it wasn't called in script! + fnAddToKillList(NULL); + } + + _router->addWalkGrid(params[0]); + fnPreLoad(params); + return IR_CONT; +} + +/** + * Remove this walkgrid resource from the list of those used for routing in + * this location. Note that this is ignored if the resource isn't actually + * in the list. + */ + +int32 Logic::fnRemoveWalkGrid(int32 *params) { + // params: 0 id of walkgrid resource + + _router->removeWalkGrid(params[0]); + return IR_CONT; +} + +// like fnCheckEventWaiting, but starts the event rather than setting RESULT +// to 1 + +int32 Logic::fnCheckForEvent(int32 *params) { + // params: none + + if (checkEventWaiting()) { + startEvent(); + return IR_TERMINATE; + } + + return IR_CONT; +} + +// combination of fnPause and fnCheckForEvent +// - ie. does a pause, but also checks for event each cycle + +int32 Logic::fnPauseForEvent(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 number of game-cycles to pause + + ObjectLogic obLogic(decodePtr(params[0])); + + if (checkEventWaiting()) { + obLogic.setLooping(0); + startEvent(); + return IR_TERMINATE; + } + + return fnPause(params); +} + +int32 Logic::fnClearEvent(int32 *params) { + // params: none + + clearEvent(readVar(ID)); + return IR_CONT; +} + +int32 Logic::fnFaceMega(int32 *params) { + // params: 0 pointer to object's logic structure + // 1 pointer to object's graphic structure + // 2 pointer to object's mega structure + // 3 pointer to object's walkdata structure + // 4 id of target mega to face + + return _router->faceMega( + decodePtr(params[0]), + decodePtr(params[1]), + decodePtr(params[2]), + decodePtr(params[3]), + params[4]); +} + +int32 Logic::fnPlaySequence(int32 *params) { + // params: 0 pointer to null-terminated ascii filename + // 1 number of frames in the sequence, used for PSX. + + char filename[30]; + MovieTextObject *sequenceSpeechArray[MAX_SEQUENCE_TEXT_LINES + 1]; + + // The original code had some #ifdef blocks for skipping or muting the + // cutscenes - fondly described as "the biggest fudge in the history + // of computer games" - but at the very least we want to show the + // cutscene subtitles, so I removed them. + + debug(5, "fnPlaySequence(\"%s\");", (const char *)decodePtr(params[0])); + + // add the appropriate file extension & play it + + strcpy(filename, (const char *)decodePtr(params[0])); + + // Write to walkthrough file (zebug0.txt) + debug(5, "PLAYING SEQUENCE \"%s\"", filename); + + // now create the text sprites, if any + + if (_sequenceTextLines) + createSequenceSpeech(sequenceSpeechArray); + + // don't want to carry on streaming game music when smacker starts! + fnStopMusic(NULL); + + // pause sfx during sequence + _vm->_sound->pauseFx(); + + MoviePlayer player(_vm); + uint32 rv; + + if (_sequenceTextLines && !readVar(DEMO)) + rv = player.play(filename, sequenceSpeechArray, _smackerLeadIn, _smackerLeadOut); + else + rv = player.play(filename, NULL, _smackerLeadIn, _smackerLeadOut); + + // check the error return-value + if (rv) + debug(5, "MoviePlayer.play(\"%s\") returned 0x%.8x", filename, rv); + + // unpause sound fx again, in case we're staying in same location + _vm->_sound->unpauseFx(); + + _smackerLeadIn = 0; + _smackerLeadOut = 0; + + // now clear the text sprites, if any + + if (_sequenceTextLines) + clearSequenceSpeech(sequenceSpeechArray); + + // now clear the screen in case the Sequence was quitted (using ESC) + // rather than fading down to black + + _vm->_screen->clearScene(); + + // zero the entire palette in case we're about to fade up! + + byte pal[4 * 256]; + + memset(pal, 0, sizeof(pal)); + _vm->_screen->setPalette(0, 256, pal, RDPAL_INSTANT); + + debug(5, "fnPlaySequence FINISHED"); + return IR_CONT; +} + +int32 Logic::fnShadedSprite(int32 *params) { + // params: 0 pointer to object's graphic structure + _router->setSpriteShading(decodePtr(params[0]), SHADED_SPRITE); + return IR_CONT; +} + +int32 Logic::fnUnshadedSprite(int32 *params) { + // params: 0 pointer to object's graphic structure + _router->setSpriteShading(decodePtr(params[0]), UNSHADED_SPRITE); + return IR_CONT; +} + +int32 Logic::fnFadeUp(int32 *params) { + // params: none + + _vm->_screen->waitForFade(); + + if (_vm->_screen->getFadeStatus() == RDFADE_BLACK) + _vm->_screen->fadeUp(); + + return IR_CONT; +} + +int32 Logic::fnDisplayMsg(int32 *params) { + // Display a message to the user on the screen. + + // params: 0 Text number of message to be displayed. + + uint32 local_text = params[0] & 0xffff; + uint32 text_res = params[0] / SIZE; + + // Display message for three seconds. + + // +2 to skip the encoded text number in the first 2 chars; 3 is + // duration in seconds + + _vm->_screen->displayMsg(_vm->fetchTextLine(_vm->_resman->openResource(text_res), local_text) + 2, 3); + _vm->_resman->closeResource(text_res); + + return IR_CONT; +} + +int32 Logic::fnSetObjectHeld(int32 *params) { + // params: 0 luggage icon to set + uint32 res = (uint32)params[0]; + + _vm->_mouse->setObjectHeld(res); + return IR_CONT; +} + +int32 Logic::fnAddSequenceText(int32 *params) { + // params: 0 text number + // 1 frame number to start the text displaying + // 2 frame number to stop the text dispalying + + assert(_sequenceTextLines < MAX_SEQUENCE_TEXT_LINES); + + _sequenceTextList[_sequenceTextLines].textNumber = params[0]; + _sequenceTextList[_sequenceTextLines].startFrame = params[1]; + _sequenceTextList[_sequenceTextLines].endFrame = params[2]; + _sequenceTextLines++; + return IR_CONT; +} + +int32 Logic::fnResetGlobals(int32 *params) { + // fnResetGlobals is used by the demo - so it can loop back & restart + // itself + + // params: none + + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + byte *globals = _vm->_resman->openResource(1) + ResHeader::size(); + int32 size = _vm->_resman->fetchLen(1) - ResHeader::size(); + + debug(5, "globals size: %d", size); + + // blank each global variable + memset(globals, 0, size); + + _vm->_resman->closeResource(1); + + // all objects but george + _vm->_resman->killAllObjects(false); + + // FOR THE DEMO - FORCE THE SCROLLING TO BE RESET! + // - this is taken from fnInitBackground + + // switch on scrolling (2 means first time on screen) + screenInfo->scroll_flag = 2; + + // Used to be IR_CONT, but that's a bad idea. We may just have killed + // our own script resource -- continuing will cause a bad memory read + // access. + return IR_STOP; +} + +int32 Logic::fnSetPalette(int32 *params) { + // params: 0 resource number of palette file, or 0 if it's to be + // the palette from the current screen + + _vm->_screen->setFullPalette(params[0]); + return IR_CONT; +} + +// use this in the object's service script prior to registering the mouse area +// ie. before fnRegisterMouse or fnRegisterFrame +// - best if kept at very top of service script + +int32 Logic::fnRegisterPointerText(int32 *params) { + // params: 0 local id of text line to use as pointer text + + _vm->_mouse->registerPointerText(params[0]); + return IR_CONT; +} + +int32 Logic::fnFetchWait(int32 *params) { + // Fetches a resource in the background but prevents the script from + // continuing until the resource is in memory. + + // params: 0 resource to fetch [guess] + + return IR_CONT; +} + +int32 Logic::fnRelease(int32 *params) { + // Releases a resource from memory. Used for freeing memory for + // sprites that have just been used and will not be used again. + // Sometimes it is better to kick out a sprite straight away so that + // the memory can be used for more frequent animations. + + // params: 0 resource to release [guess] + + return IR_CONT; +} + +int32 Logic::fnPrepareMusic(int32 *params) { + // params: 1 id of music to prepare [guess] + return IR_CONT; +} + +int32 Logic::fnSoundFetch(int32 *params) { + // params: 0 id of sound to fetch [guess] + return IR_CONT; +} + +int32 Logic::fnSmackerLeadIn(int32 *params) { + // params: 0 id of lead-in music + + // ready for use in fnPlaySequence + _smackerLeadIn = params[0]; + return IR_CONT; +} + +int32 Logic::fnSmackerLeadOut(int32 *params) { + // params: 0 id of lead-out music + + // ready for use in fnPlaySequence + _smackerLeadOut = params[0]; + return IR_CONT; +} + +/** + * Stops all FX and clears the entire FX queue. + */ + +int32 Logic::fnStopAllFx(int32 *params) { + // params: none + + _vm->_sound->clearFxQueue(); + return IR_CONT; +} + +int32 Logic::fnCheckPlayerActivity(int32 *params) { + // Used to decide when to trigger music cues described as "no player + // activity for a while" + + // params: 0 threshold delay in seconds, ie. what we want to + // check the actual delay against + + uint32 seconds = (uint32)params[0]; + + _vm->_mouse->checkPlayerActivity(seconds); + return IR_CONT; +} + +int32 Logic::fnResetPlayerActivityDelay(int32 *params) { + // Use if you want to deliberately reset the "no player activity" + // counter for any reason + + // params: none + + _vm->_mouse->resetPlayerActivityDelay(); + return IR_CONT; +} + +int32 Logic::fnCheckMusicPlaying(int32 *params) { + // params: none + + // sets result to no. of seconds of current tune remaining + // or 0 if no music playing + + // in seconds, rounded up to the nearest second + writeVar(RESULT, _vm->_sound->musicTimeRemaining()); + return IR_CONT; +} + +int32 Logic::fnPlayCredits(int32 *params) { + // This function just quits the game if this is the playable demo, ie. + // credits are NOT played in the demo any more! + + // params: none + + if (readVar(DEMO)) { + _vm->closeGame(); + return IR_STOP; + } + + _vm->_screen->rollCredits(); + return IR_CONT; +} + +int32 Logic::fnSetScrollSpeedNormal(int32 *params) { + // params: none + + _vm->_screen->setScrollFraction(16); + return IR_CONT; +} + +int32 Logic::fnSetScrollSpeedSlow(int32 *params) { + // params: none + + _vm->_screen->setScrollFraction(32); + return IR_CONT; +} + +// Called from speech scripts to remove the chooser bar when it's not +// appropriate to keep it displayed + +int32 Logic::fnRemoveChooser(int32 *params) { + // params: none + + _vm->_mouse->hideMenu(RDMENU_BOTTOM); + return IR_CONT; +} + +/** + * Alter the volume and pan of a currently playing FX + */ + +int32 Logic::fnSetFxVolAndPan(int32 *params) { + // params: 0 id of fx (ie. the id returned in 'result' from + // fnPlayFx + // 1 new volume (0..16) + // 2 new pan (-16..16) + + debug(5, "fnSetFxVolAndPan(%d, %d, %d)", params[0], params[1], params[2]); + + _vm->_sound->setFxIdVolumePan(params[0], params[1], params[2]); + return IR_CONT; +} + +/** + * Alter the volume of a currently playing FX + */ + +int32 Logic::fnSetFxVol(int32 *params) { + // params: 0 id of fx (ie. the id returned in 'result' from + // fnPlayFx + // 1 new volume (0..16) + + _vm->_sound->setFxIdVolumePan(params[0], params[1]); + return IR_CONT; +} + +int32 Logic::fnRestoreGame(int32 *params) { + // params: none + return IR_CONT; +} + +int32 Logic::fnRefreshInventory(int32 *params) { + // Called from 'menu_look_or_combine' script in 'menu_master' object + // to update the menu to display a combined object while George runs + // voice-over. Note that 'object_held' must be set to the graphic of + // the combined object + + // params: none + + _vm->_mouse->refreshInventory(); + return IR_CONT; +} + +int32 Logic::fnChangeShadows(int32 *params) { + // params: none + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + // if last screen was using a shading mask (see below) + if (screenInfo->mask_flag) { + uint32 rv = _vm->_screen->closeLightMask(); + if (rv) + error("Driver Error %.8x", rv); + screenInfo->mask_flag = false; + } + + return IR_CONT; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/header.h b/engines/sword2/header.h new file mode 100644 index 0000000000..9aefa52832 --- /dev/null +++ b/engines/sword2/header.h @@ -0,0 +1,502 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef _HEADER +#define _HEADER + +#include "common/stream.h" + +namespace Sword2 { + +//---------------------------------------------------------- +// SYSTEM FILE & FRAME HEADERS +//---------------------------------------------------------- + +//---------------------------------------------------------- +// ALL FILES +//---------------------------------------------------------- + +// Standard File Header + +#define NAME_LEN 34 + +struct ResHeader { + uint8 fileType; // Byte to define file type (see below) + uint8 compType; // Type of file compression used ie. + // on whole file (see below) + uint32 compSize; // Length of compressed file (ie. + // length on disk) + uint32 decompSize; // Length of decompressed file held in + // memory (NB. frames still held + // compressed) + byte name[NAME_LEN]; // Name of object + + static const int size() { + return 44; + } + + void read(byte *addr) { + Common::MemoryReadStream readS(addr, size()); + + fileType = readS.readByte(); + compType = readS.readByte(); + compSize = readS.readUint32LE(); + decompSize = readS.readUint32LE(); + readS.read(name, NAME_LEN); + } + + void write(byte *addr) { + Common::MemoryWriteStream writeS(addr, size()); + + writeS.writeByte(fileType); + writeS.writeByte(compType); + writeS.writeUint32LE(compSize); + writeS.writeUint32LE(decompSize); + writeS.write(name, NAME_LEN); + } +}; + +// fileType + +enum { + // 0 something's wrong! + ANIMATION_FILE = 1, // All normal animations & sprites + // including mega-sets & font files + // which are the same format (but all + // frames always uncompressed) + SCREEN_FILE = 2, // Each contains background, palette, + // layer sprites, parallax layers & + // shading mask + GAME_OBJECT = 3, // Each contains object hub + + // structures + script data + WALK_GRID_FILE = 4, // Walk-grid data + GLOBAL_VAR_FILE = 5, // All the global script variables in + // one file; "there can be only one" + PARALLAX_FILE_null = 6, // NOT USED + RUN_LIST = 7, // Each contains a list of object + // resource id's + TEXT_FILE = 8, // Each contains all the lines of text + // for a location or a character's + // conversation script + SCREEN_MANAGER = 9, // One for each location; this contains + // special startup scripts + MOUSE_FILE = 10, // Mouse pointers and luggage icons + // (sprites in General / Mouse pointers + // & Luggage icons) + WAV_FILE = 11, // WAV file + ICON_FILE = 12, // Menu icon (sprites in General / Menu + // icons) + PALETTE_FILE = 13 // separate palette file (see also + // _paletteHeader) +}; + +// compType + +enum { + NO_COMPRESSION = 0, + FILE_COMPRESSION = 1 // standard whole-file compression + // (not yet devised!) +}; + +//---------------------------------------------------------- +// (1) ANIMATION FILES +//---------------------------------------------------------- + +// an animation file consists of: +// +// standard file header +// animation header +// a string of CDT entries (one per frame of the anim) +// a 16-byte colour table ONLY if (runTimeComp==RLE16) +// a string of groups of (frame header + frame data) + +// Animation Header + +struct AnimHeader { + uint8 runTimeComp; // Type of runtime compression used for the + // frame data (see below) + uint16 noAnimFrames; // Number of frames in the anim (ie. no. of + // CDT entries) + uint16 feetStartX; // Start coords for mega to walk to, before + uint16 feetStartY; // running anim + uint8 feetStartDir; // Direction to start in before running anim + uint16 feetEndX; // End coords for mega to stand at after + uint16 feetEndY; // running anim (vital if anim starts from an + // off-screen position, or ends in a different + // place from the start) + uint8 feetEndDir; // Direction to start in after running anim + uint16 blend; + + static const int size() { + return 15; + } + + void read(byte *addr) { + Common::MemoryReadStream readS(addr, size()); + + runTimeComp = readS.readByte(); + noAnimFrames = readS.readUint16LE(); + feetStartX = readS.readUint16LE(); + feetStartY = readS.readUint16LE(); + feetStartDir = readS.readByte(); + feetEndX = readS.readUint16LE(); + feetEndY = readS.readUint16LE(); + feetEndDir = readS.readByte(); + blend = readS.readUint16LE(); + } + + void write(byte *addr) { + Common::MemoryWriteStream writeS(addr, size()); + + writeS.writeByte(runTimeComp); + writeS.writeUint16LE(noAnimFrames); + writeS.writeUint16LE(feetStartX); + writeS.writeUint16LE(feetStartY); + writeS.writeByte(feetStartDir); + writeS.writeUint16LE(feetEndX); + writeS.writeUint16LE(feetEndY); + writeS.writeByte(feetEndDir); + writeS.writeUint16LE(blend); + } + +}; + +// runtimeComp - compression used on each frame of the anim + +enum { + NONE = 0, // No frame compression + RLE256 = 1, // James's RLE for 256-colour sprites + RLE16 = 2 // James's RLE for 16- or 17-colour sprites + // (raw blocks have max 16 colours for 2 pixels + // per byte, so '0's are encoded only as FLAT + // for 17-colour sprites eg. George's mega-set) +}; + +// CDT Entry + +struct CdtEntry { + int16 x; // sprite x-coord OR offset to add to mega's + // feet x-coord to calc sprite y-coord + int16 y; // sprite y-coord OR offset to add to mega's + // feet y-coord to calc sprite y-coord + uint32 frameOffset; // points to start of frame header (from start + // of file header) + uint8 frameType; // 0 = print sprite normally with top-left + // corner at (x,y), otherwise see below... + + static const int size() { + return 9; + } + + void read(byte *addr) { + Common::MemoryReadStream readS(addr, size()); + + x = readS.readUint16LE(); + y = readS.readUint16LE(); + frameOffset = readS.readUint32LE(); + frameType = readS.readByte(); + } + + void write(byte *addr) { + Common::MemoryWriteStream writeS(addr, size()); + + writeS.writeUint16LE(x); + writeS.writeUint16LE(y); + writeS.writeUint32LE(frameOffset); + writeS.writeByte(frameType); + } +}; + +// 'frameType' bit values + +enum { + FRAME_OFFSET = 1, // Print at (feetX + x, feetY + y), with + // scaling according to feetY + FRAME_FLIPPED = 2, // Print the frame flipped Left->Right + FRAME_256_FAST = 4 // Frame has been compressed using Pauls fast + // RLE 256 compression. +}; + +// Frame Header + +struct FrameHeader { + uint32 compSize; // Compressed size of frame - NB. compression + // type is now in Anim Header + uint16 width; // Dimensions of frame + uint16 height; + + static const int size() { + return 8; + } + + void read(byte *addr) { + Common::MemoryReadStream readS(addr, size()); + + compSize = readS.readUint32LE(); + width = readS.readUint16LE(); + height = readS.readUint16LE(); + } + + void write(byte *addr) { + Common::MemoryWriteStream writeS(addr, size()); + + writeS.writeUint32LE(compSize); + writeS.writeUint16LE(width); + writeS.writeUint16LE(height); + } +}; + +//---------------------------------------------------------- +// (2) SCREEN FILES +//---------------------------------------------------------- +// a screen file consists of: +// +// standard file header +// multi screen header +// 4 * 256 bytes of palette data +// 256k palette match table +// 2 background parallax layers +// 1 background layer with screen header +// 2 foreground parallax layers +// a string of layer headers +// a string of layer masks + +// Multi screen header +// Goes at the beginning of a screen file after the standard header. +// Gives offsets from start of table of each of the components + +struct MultiScreenHeader { + uint32 palette; + uint32 bg_parallax[2]; + uint32 screen; + uint32 fg_parallax[2]; + uint32 layers; + uint32 paletteTable; + uint32 maskOffset; + + static const int size() { + return 36; + } + + void read(byte *addr) { + Common::MemoryReadStream readS(addr, size()); + + palette = readS.readUint32LE(); + bg_parallax[0] = readS.readUint32LE(); + bg_parallax[1] = readS.readUint32LE(); + screen = readS.readUint32LE(); + fg_parallax[0] = readS.readUint32LE(); + fg_parallax[1] = readS.readUint32LE(); + layers = readS.readUint32LE(); + paletteTable = readS.readUint32LE(); + maskOffset = readS.readUint32LE(); + } + + void write(byte *addr) { + Common::MemoryWriteStream writeS(addr, size()); + + writeS.writeUint32LE(palette); + writeS.writeUint32LE(bg_parallax[0]); + writeS.writeUint32LE(bg_parallax[1]); + writeS.writeUint32LE(screen); + writeS.writeUint32LE(fg_parallax[0]); + writeS.writeUint32LE(fg_parallax[1]); + writeS.writeUint32LE(layers); + writeS.writeUint32LE(paletteTable); + writeS.writeUint32LE(maskOffset); + } +}; + +// Screen Header + +struct ScreenHeader { + uint16 width; // dimensions of the background screen + uint16 height; + uint16 noLayers; // number of layer areas + + static const int size() { + return 6; + } + + void read(byte *addr) { + Common::MemoryReadStream readS(addr, size()); + + width = readS.readUint16LE(); + height = readS.readUint16LE(); + noLayers = readS.readUint16LE(); + } + + void write(byte *addr) { + Common::MemoryWriteStream writeS(addr, size()); + + writeS.writeUint16LE(width); + writeS.writeUint16LE(height); + writeS.writeUint16LE(noLayers); + } +}; + +// Layer Header + +// Note that all the layer headers are kept together, rather than being placed +// before each layer mask, in order to simplify the sort routine. + +struct LayerHeader { + uint16 x; // coordinates of top-left pixel of area + uint16 y; + uint16 width; + uint16 height; + uint32 maskSize; + uint32 offset; // where to find mask data (from start of + // standard file header) + + static const int size() { + return 16; + } + + void read(byte *addr) { + Common::MemoryReadStream readS(addr, size()); + + x = readS.readUint16LE(); + y = readS.readUint16LE(); + width = readS.readUint16LE(); + height = readS.readUint16LE(); + maskSize = readS.readUint32LE(); + offset = readS.readUint32LE(); + } + + void write(byte *addr) { + Common::MemoryWriteStream writeS(addr, size()); + + writeS.writeUint16LE(x); + writeS.writeUint16LE(y); + writeS.writeUint16LE(width); + writeS.writeUint16LE(height); + writeS.writeUint32LE(maskSize); + writeS.writeUint32LE(offset); + } +}; + +//---------------------------------------------------------- +// (3) SCRIPT OBJECT FILES +//---------------------------------------------------------- +// a script object file consists of: +// +// standard file header +// script object header +// script object data + +//---------------------------------------------------------- +// (5) PALETTE FILES +//---------------------------------------------------------- +// a palette file consists of: +// +// standard file header +// 4 * 256 bytes of palette data +// 256k palette match table + +// an object hub - which represents all that remains of the compact concept + +class ObjectHub { + // int32 type; // type of object + // uint32 logic_level; // what level? + // uint32 logic[3] // NOT USED + // uint32 script_id[3] // need this if script + // uint32 script_pc[3] // need this also + +private: + byte *_addr; + +public: + ObjectHub() { + _addr = NULL; + } + + static const int size() { + return 44; + } + + byte *data() { + return _addr; + } + + void setAddress(byte *addr) { + _addr = addr; + } + + byte *getScriptPcPtr(int level) { + return _addr + 32 + 4 * level; + } + + uint32 getLogicLevel() { + return READ_LE_UINT32(_addr + 4); + } + uint32 getScriptId(int level) { + return READ_LE_UINT32(_addr + 20 + 4 * level); + } + uint32 getScriptPc(int level) { + return READ_LE_UINT32(_addr + 32 + 4 * level); + } + + void setLogicLevel(uint32 x) { + WRITE_LE_UINT32(_addr + 4, x); + } + void setScriptId(int level, uint32 x) { + WRITE_LE_UINT32(_addr + 20 + 4 * level, x); + } + void setScriptPc(int level, uint32 x) { + WRITE_LE_UINT32(_addr + 32 + 4 * level, x); + } +}; + +// (6) text module header + +struct TextHeader { + uint32 noOfLines; // how many lines of text are there in this + // module + + static const int size() { + return 4; + } + + void read(byte *addr) { + Common::MemoryReadStream readS(addr, size()); + + noOfLines = readS.readUint32LE(); + } + + void write(byte *addr) { + Common::MemoryWriteStream writeS(addr, size()); + + writeS.writeUint32LE(noOfLines); + } +}; + +// a text file has: +// +// ResHeader +// TextHeader +// look up table, to +// line of text,0 +// line of text,0 + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/icons.cpp b/engines/sword2/icons.cpp new file mode 100644 index 0000000000..980c20e3b4 --- /dev/null +++ b/engines/sword2/icons.cpp @@ -0,0 +1,216 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "common/stream.h" +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/mouse.h" +#include "sword2/resman.h" + +namespace Sword2 { + +void Mouse::addMenuObject(byte *ptr) { + assert(_totalTemp < TOTAL_engine_pockets); + + Common::MemoryReadStream readS(ptr, 2 * sizeof(int32)); + + _tempList[_totalTemp].icon_resource = readS.readSint32LE(); + _tempList[_totalTemp].luggage_resource = readS.readSint32LE(); + _totalTemp++; +} + +void Mouse::addSubject(int32 id, int32 ref) { + uint32 in_subject = _vm->_logic->readVar(IN_SUBJECT); + + if (in_subject == 0) { + // This is the start of the new subject list. Set the default + // repsonse id to zero in case we're never passed one. + _defaultResponseId = 0; + } + + if (id == -1) { + // Id -1 is used for setting the default response, i.e. the + // response when someone uses an object on a person and he + // doesn't know anything about it. See fnChoose(). + + _defaultResponseId = ref; + } else { + debug(5, "fnAddSubject res %d, uid %d", id, ref); + _subjectList[in_subject].res = id; + _subjectList[in_subject].ref = ref; + _vm->_logic->writeVar(IN_SUBJECT, in_subject + 1); + } +} + +/** + * Create and start the inventory (bottom) menu + */ + +void Mouse::buildMenu() { + uint32 i, j; + + // Clear the temporary inventory list, since we are going to build a + // new one from scratch. + + for (i = 0; i < TOTAL_engine_pockets; i++) + _tempList[i].icon_resource = 0; + + _totalTemp = 0; + + // Run the 'build_menu' script in the 'menu_master' object. This will + // register all carried menu objects. + + _vm->_logic->runResScript(MENU_MASTER_OBJECT, 0); + + // Create a new master list based on the old master inventory list and + // the new temporary inventory list. The purpose of all this is, as + // far as I can tell, that the new list is ordered in the same way as + // the old list, with new objects added to the end of it. + + // Compare new with old. Anything in master thats not in new gets + // removed from master - if found in new too, remove from temp + + for (i = 0; i < _totalMasters; i++) { + bool found_in_temp = false; + + for (j = 0; j < TOTAL_engine_pockets; j++) { + if (_masterMenuList[i].icon_resource == _tempList[j].icon_resource) { + // We alread know about this object, so kill it + // in the temporary list. + _tempList[j].icon_resource = 0; + found_in_temp = true; + break; + } + } + + if (!found_in_temp) { + // The object is in the master list, but not in the + // temporary list. The player must have lost the object + // since the last time we checked, so kill it in the + // master list. + _masterMenuList[i].icon_resource = 0; + } + } + + // Eliminate blank entries from the master list. + + _totalMasters = 0; + + for (i = 0; i < TOTAL_engine_pockets; i++) { + if (_masterMenuList[i].icon_resource) { + if (i != _totalMasters) { + memcpy(&_masterMenuList[_totalMasters], &_masterMenuList[i], sizeof(MenuObject)); + _masterMenuList[i].icon_resource = 0; + } + _totalMasters++; + } + } + + // Add the new objects - i.e. the ones still in the temporary list but + // not yet in the master list - to the end of the master. + + for (i = 0; i < TOTAL_engine_pockets; i++) { + if (_tempList[i].icon_resource) { + memcpy(&_masterMenuList[_totalMasters++], &_tempList[i], sizeof(MenuObject)); + } + } + + // Initialise the menu from the master list. + + for (i = 0; i < 15; i++) { + uint32 res = _masterMenuList[i].icon_resource; + byte *icon = NULL; + + if (res) { + bool icon_coloured; + + uint32 object_held = _vm->_logic->readVar(OBJECT_HELD); + uint32 combine_base = _vm->_logic->readVar(COMBINE_BASE); + + if (_examiningMenuIcon) { + // When examining an object, that object is + // coloured. The rest are greyed out. + icon_coloured = (res == object_held); + } else if (combine_base) { + // When combining two menu object (i.e. using + // one on another), both are coloured. The rest + // are greyed out. + icon_coloured = (res == object_held || combine_base); + } else { + // If an object is selected but we are not yet + // doing anything with it, the selected object + // is greyed out. The rest are coloured. + icon_coloured = (res != object_held); + } + + icon = _vm->_resman->openResource(res) + ResHeader::size(); + + // The coloured icon is stored directly after the + // greyed out one. + + if (icon_coloured) + icon += (RDMENU_ICONWIDE * RDMENU_ICONDEEP); + } + + setMenuIcon(RDMENU_BOTTOM, i, icon); + + if (res) + _vm->_resman->closeResource(res); + } + + showMenu(RDMENU_BOTTOM); +} + +/** + * Build a fresh system (top) menu. + */ + +void Mouse::buildSystemMenu() { + uint32 icon_list[5] = { + OPTIONS_ICON, + QUIT_ICON, + SAVE_ICON, + RESTORE_ICON, + RESTART_ICON + }; + + // Build them all high in full colour - when one is clicked on all the + // rest will grey out. + + for (int i = 0; i < ARRAYSIZE(icon_list); i++) { + byte *icon = _vm->_resman->openResource(icon_list[i]) + ResHeader::size(); + + // The only case when an icon is grayed is when the player + // is dead. Then SAVE is not available. + + if (!_vm->_logic->readVar(DEAD) || icon_list[i] != SAVE_ICON) + icon += (RDMENU_ICONWIDE * RDMENU_ICONDEEP); + + setMenuIcon(RDMENU_TOP, i, icon); + _vm->_resman->closeResource(icon_list[i]); + } + + showMenu(RDMENU_TOP); +} + +} // End of namespace Sword2 diff --git a/engines/sword2/icons.h b/engines/sword2/icons.h new file mode 100644 index 0000000000..ab5ea578ca --- /dev/null +++ b/engines/sword2/icons.h @@ -0,0 +1,41 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef _ICONS +#define _ICONS + +#define MENU_MASTER_OBJECT 44 +#define TOTAL_subjects (375 - 256 + 1) // the speech subject bar +#define TOTAL_engine_pockets (15 + 10) // +10 for overflow + +namespace Sword2 { + +// define these in a script and then register them with the system + +struct MenuObject { + int32 icon_resource; // icon graphic graphic + int32 luggage_resource; // luggage icon resource (for attaching to + // mouse pointer) +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/interpreter.cpp b/engines/sword2/interpreter.cpp new file mode 100644 index 0000000000..1a6e7080b8 --- /dev/null +++ b/engines/sword2/interpreter.cpp @@ -0,0 +1,753 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "common/util.h" +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/interpreter.h" +#include "sword2/logic.h" +#include "sword2/memory.h" +#include "sword2/resman.h" + +namespace Sword2 { + +#define STACK_SIZE 10 + +// The machine code table + +#ifndef REDUCE_MEMORY_USAGE +# define OPCODE(x) { &Logic::x, #x } +#else +# define OPCODE(x) { &Logic::x, "" } +#endif + +typedef int32 (Logic::*OpcodeProc)(int32 *); +struct OpcodeEntry { + OpcodeProc proc; + const char *desc; +}; + +static const OpcodeEntry opcodes[] = { + /* 00 */ + OPCODE(fnTestFunction), + OPCODE(fnTestFlags), + OPCODE(fnRegisterStartPoint), + OPCODE(fnInitBackground), + /* 04 */ + OPCODE(fnSetSession), + OPCODE(fnBackSprite), + OPCODE(fnSortSprite), + OPCODE(fnForeSprite), + /* 08 */ + OPCODE(fnRegisterMouse), + OPCODE(fnAnim), + OPCODE(fnRandom), + OPCODE(fnPreLoad), + /* 0C */ + OPCODE(fnAddSubject), + OPCODE(fnInteract), + OPCODE(fnChoose), + OPCODE(fnWalk), + /* 10 */ + OPCODE(fnWalkToAnim), + OPCODE(fnTurn), + OPCODE(fnStandAt), + OPCODE(fnStand), + /* 14 */ + OPCODE(fnStandAfterAnim), + OPCODE(fnPause), + OPCODE(fnMegaTableAnim), + OPCODE(fnAddMenuObject), + /* 18 */ + OPCODE(fnStartConversation), + OPCODE(fnEndConversation), + OPCODE(fnSetFrame), + OPCODE(fnRandomPause), + /* 1C */ + OPCODE(fnRegisterFrame), + OPCODE(fnNoSprite), + OPCODE(fnSendSync), + OPCODE(fnUpdatePlayerStats), + /* 20 */ + OPCODE(fnPassGraph), + OPCODE(fnInitFloorMouse), + OPCODE(fnPassMega), + OPCODE(fnFaceXY), + /* 24 */ + OPCODE(fnEndSession), + OPCODE(fnNoHuman), + OPCODE(fnAddHuman), + OPCODE(fnWeWait), + /* 28 */ + OPCODE(fnTheyDoWeWait), + OPCODE(fnTheyDo), + OPCODE(fnWalkToTalkToMega), + OPCODE(fnFadeDown), + /* 2C */ + OPCODE(fnISpeak), + OPCODE(fnTotalRestart), + OPCODE(fnSetWalkGrid), + OPCODE(fnSpeechProcess), + /* 30 */ + OPCODE(fnSetScaling), + OPCODE(fnStartEvent), + OPCODE(fnCheckEventWaiting), + OPCODE(fnRequestSpeech), + /* 34 */ + OPCODE(fnGosub), + OPCODE(fnTimedWait), + OPCODE(fnPlayFx), + OPCODE(fnStopFx), + /* 38 */ + OPCODE(fnPlayMusic), + OPCODE(fnStopMusic), + OPCODE(fnSetValue), + OPCODE(fnNewScript), + /* 3C */ + OPCODE(fnGetSync), + OPCODE(fnWaitSync), + OPCODE(fnRegisterWalkGrid), + OPCODE(fnReverseMegaTableAnim), + /* 40 */ + OPCODE(fnReverseAnim), + OPCODE(fnAddToKillList), + OPCODE(fnSetStandbyCoords), + OPCODE(fnBackPar0Sprite), + /* 44 */ + OPCODE(fnBackPar1Sprite), + OPCODE(fnForePar0Sprite), + OPCODE(fnForePar1Sprite), + OPCODE(fnSetPlayerActionEvent), + /* 48 */ + OPCODE(fnSetScrollCoordinate), + OPCODE(fnStandAtAnim), + OPCODE(fnSetScrollLeftMouse), + OPCODE(fnSetScrollRightMouse), + /* 4C */ + OPCODE(fnColour), + OPCODE(fnFlash), + OPCODE(fnPreFetch), + OPCODE(fnGetPlayerSaveData), + /* 50 */ + OPCODE(fnPassPlayerSaveData), + OPCODE(fnSendEvent), + OPCODE(fnAddWalkGrid), + OPCODE(fnRemoveWalkGrid), + /* 54 */ + OPCODE(fnCheckForEvent), + OPCODE(fnPauseForEvent), + OPCODE(fnClearEvent), + OPCODE(fnFaceMega), + /* 58 */ + OPCODE(fnPlaySequence), + OPCODE(fnShadedSprite), + OPCODE(fnUnshadedSprite), + OPCODE(fnFadeUp), + /* 5C */ + OPCODE(fnDisplayMsg), + OPCODE(fnSetObjectHeld), + OPCODE(fnAddSequenceText), + OPCODE(fnResetGlobals), + /* 60 */ + OPCODE(fnSetPalette), + OPCODE(fnRegisterPointerText), + OPCODE(fnFetchWait), + OPCODE(fnRelease), + /* 64 */ + OPCODE(fnPrepareMusic), + OPCODE(fnSoundFetch), + OPCODE(fnPrepareMusic), // Again, apparently + OPCODE(fnSmackerLeadIn), + /* 68 */ + OPCODE(fnSmackerLeadOut), + OPCODE(fnStopAllFx), + OPCODE(fnCheckPlayerActivity), + OPCODE(fnResetPlayerActivityDelay), + /* 6C */ + OPCODE(fnCheckMusicPlaying), + OPCODE(fnPlayCredits), + OPCODE(fnSetScrollSpeedNormal), + OPCODE(fnSetScrollSpeedSlow), + /* 70 */ + OPCODE(fnRemoveChooser), + OPCODE(fnSetFxVolAndPan), + OPCODE(fnSetFxVol), + OPCODE(fnRestoreGame), + /* 74 */ + OPCODE(fnRefreshInventory), + OPCODE(fnChangeShadows) +}; + +#define push(value) \ +do { \ + assert(stackPtr < ARRAYSIZE(stack)); \ + stack[stackPtr++] = (value); \ +} while (false) + +#define push_ptr(ptr) push(_vm->_memory->encodePtr(ptr)) + +#define pop() (assert(stackPtr < ARRAYSIZE(stack)), stack[--stackPtr]) + +int Logic::runResScript(uint32 scriptRes, uint32 offset) { + byte *scriptAddr; + int result; + + scriptAddr = _vm->_resman->openResource(scriptRes); + result = runScript(scriptAddr, scriptAddr, offset); + _vm->_resman->closeResource(scriptRes); + + return result; +} + +int Logic::runResObjScript(uint32 scriptRes, uint32 objRes, uint32 offset) { + byte *scriptAddr, *objAddr; + int result; + + scriptAddr = _vm->_resman->openResource(scriptRes); + objAddr = _vm->_resman->openResource(objRes); + result = runScript(scriptAddr, objAddr, offset); + _vm->_resman->closeResource(objRes); + _vm->_resman->closeResource(scriptRes); + + return result; +} + +int Logic::runScript(byte *scriptData, byte *objectData, uint32 offset) { + byte pc[4]; + + WRITE_LE_UINT32(pc, offset); + return runScript2(scriptData, objectData, pc); +} + +// This form of the runScript function is only called directly from +// the processSession() function, which uses it to update the script PC in the +// current object hub. For reasons which I do not understand, I couldn't get it +// to work if I called the function first with a dummy offset variable, and +// and then updated the object hub myself. + +int Logic::runScript2(byte *scriptData, byte *objectData, byte *offsetPtr) { + // Interestingly, unlike our BASS engine the stack is a local variable. + // I don't know whether or not this is relevant to the working of the + // BS2 engine. + + int32 stack[STACK_SIZE]; + int32 stackPtr = 0; + + uint32 offset = READ_LE_UINT32(offsetPtr); + + ResHeader header; + + header.read(scriptData); + + scriptData += ResHeader::size() + ObjectHub::size(); + + // The script data format: + // int32_TYPE 1 Size of variable space in bytes + // ... The variable space + // int32_TYPE 1 numberOfScripts + // int32_TYPE numberOfScripts The offsets for each script + + // Initialise some stuff + + uint32 ip = 0; // Code pointer + int scriptNumber; + + // Get the start of variables and start of code + + byte *localVars = scriptData + 4; + byte *code = scriptData + READ_LE_UINT32(scriptData) + 4; + uint32 noScripts = READ_LE_UINT32(code); + + code += 4; + + byte *offsetTable = code; + + if (offset < noScripts) { + ip = READ_LE_UINT32(offsetTable + offset * 4); + scriptNumber = offset; + debug(8, "Starting script %d from %d", scriptNumber, ip); + } else { + uint i; + + ip = offset; + + for (i = 1; i < noScripts; i++) { + if (READ_LE_UINT32(offsetTable + 4 * i) >= ip) + break; + } + + scriptNumber = i - 1; + debug(8, "Resuming script %d from %d", scriptNumber, ip); + } + + // There are a couple of known script bugs related to interacting with + // certain objects. We try to work around a few of them. + + bool checkMopBug = false; + bool checkPyramidBug = false; + bool checkElevatorBug = false; + + if (scriptNumber == 2) { + if (strcmp((char *)header.name, "mop_73") == 0) + checkMopBug = true; + else if (strcmp((char *)header.name, "titipoco_81") == 0) + checkPyramidBug = true; + else if (strcmp((char *)header.name, "lift_82") == 0) + checkElevatorBug = true; + } + + code += noScripts * 4; + + // Code should now be pointing at an identifier and a checksum + byte *checksumBlock = code; + + code += 4 * 3; + + if (READ_LE_UINT32(checksumBlock) != 12345678) { + error("Invalid script in object %s", header.name); + return 0; + } + + int32 codeLen = READ_LE_UINT32(checksumBlock + 4); + int32 checksum = 0; + + for (int i = 0; i < codeLen; i++) + checksum += (unsigned char) code[i]; + + if (checksum != (int32)READ_LE_UINT32(checksumBlock + 8)) { + debug(1, "Checksum error in object %s", header.name); + // This could be bad, but there has been a report about someone + // who had problems running the German version because of + // checksum errors. Could there be a version where checksums + // weren't properly calculated? + } + + bool runningScript = true; + + int parameterReturnedFromMcodeFunction = 0; // Allow scripts to return things + int savedStartOfMcode = 0; // For saving start of mcode commands + + while (runningScript) { + int i; + int32 a, b; + int curCommand, parameter, value; // Command and parameter variables + int retVal; + int caseCount; + bool foundCase; + byte *ptr; + + curCommand = code[ip++]; + + switch (curCommand) { + + // Script-related opcodes + + case CP_END_SCRIPT: + // End the script + runningScript = false; + + // WORKAROUND: The dreaded pyramid bug makes the torch + // untakeable when you speak to Titipoco. This is + // because one of the conditions for the torch to be + // takeable is that Titipoco isn't doing anything out + // of the ordinary. Global variable 913 has to be 0 to + // signify that he is in his "idle" state. + // + // Unfortunately, simply the act of speaking to him + // sets variable 913 to 1 (probably to stop him from + // turning around every now and then). The script may + // then go on to set the variable to different values + // to trigger various behaviours in him, but if you + // have run out of these cases the script won't ever + // set it back to 0 again. + // + // So if his click hander finishes, and variable 913 is + // 1, we set it back to 0 manually. + + if (checkPyramidBug && readVar(913) == 1) { + warning("Working around pyramid bug: Resetting Titipoco's state"); + writeVar(913, 0); + } + + // WORKAROUND: The not-so-known-but-should-be-dreaded + // elevator bug. + // + // The click handler for the top of the elevator only + // handles using the elevator, not examining it. When + // examining it, the mouse cursor is removed but never + // restored. + + if (checkElevatorBug && readVar(RIGHT_BUTTON)) { + warning("Working around elevator bug: Restoring mouse pointer"); + fnAddHuman(NULL); + } + + debug(9, "CP_END_SCRIPT"); + break; + case CP_QUIT: + // Quit out for a cycle + WRITE_LE_UINT32(offsetPtr, ip); + debug(9, "CP_QUIT"); + return 0; + case CP_TERMINATE: + // Quit out immediately without affecting the offset + // pointer + debug(9, "CP_TERMINATE"); + return 3; + case CP_RESTART_SCRIPT: + // Start the script again + ip = FROM_LE_32(offsetTable[scriptNumber]); + debug(9, "CP_RESTART_SCRIPT"); + break; + + // Stack-related opcodes + + case CP_PUSH_INT32: + // Push a long word value on to the stack + Read32ip(parameter); + push(parameter); + debug(9, "CP_PUSH_INT32: %d", parameter); + break; + case CP_PUSH_LOCAL_VAR32: + // Push the contents of a local variable + Read16ip(parameter); + push(READ_LE_UINT32(localVars + parameter)); + debug(9, "CP_PUSH_LOCAL_VAR32: localVars[%d] => %d", parameter / 4, READ_LE_UINT32(localVars + parameter)); + break; + case CP_PUSH_GLOBAL_VAR32: + // Push a global variable + Read16ip(parameter); + push(readVar(parameter)); + debug(9, "CP_PUSH_GLOBAL_VAR32: scriptVars[%d] => %d", parameter, readVar(parameter)); + break; + case CP_PUSH_LOCAL_ADDR: + // Push the address of a local variable + + // From what I understand, some scripts store data + // (e.g. mouse pointers) in their local variable space + // from the very beginning, and use this mechanism to + // pass that data to the opcode function. I don't yet + // know the conceptual difference between this and the + // CP_PUSH_DEREFERENCED_STRUCTURE opcode. + + Read16ip(parameter); + push_ptr(localVars + parameter); + debug(9, "CP_PUSH_LOCAL_ADDR: &localVars[%d] => %p", parameter / 4, localVars + parameter); + break; + case CP_PUSH_STRING: + // Push the address of a string on to the stack + // Get the string size + Read8ip(parameter); + + // ip now points to the string + ptr = code + ip; + push_ptr(ptr); + debug(9, "CP_PUSH_STRING: \"%s\"", ptr); + ip += (parameter + 1); + break; + case CP_PUSH_DEREFERENCED_STRUCTURE: + // Push the address of a dereferenced structure + Read32ip(parameter); + ptr = objectData + 4 + ResHeader::size() + ObjectHub::size() + parameter; + push_ptr(ptr); + debug(9, "CP_PUSH_DEREFERENCED_STRUCTURE: %d => %p", parameter, ptr); + break; + case CP_POP_LOCAL_VAR32: + // Pop a value into a local word variable + Read16ip(parameter); + value = pop(); + WRITE_LE_UINT32(localVars + parameter, value); + debug(9, "CP_POP_LOCAL_VAR32: localVars[%d] = %d", parameter / 4, value); + break; + case CP_POP_GLOBAL_VAR32: + // Pop a global variable + Read16ip(parameter); + value = pop(); + + // WORKAROUND for bug #1214168: The not-at-all dreaded + // mop bug. + // + // At the London Docks, global variable 1003 keeps + // track of Nico: + // + // 0: Hiding behind the first crate. + // 1: Hiding behind the second crate. + // 2: Standing in plain view on the deck. + // 3: Hiding on the roof. + // + // The bug happens when trying to pick up the mop while + // hiding on the roof. Nico climbs down, the mop is + // picked up, but the variable remains set to 3. + // Visually, everything looks ok. But as far as the + // scripts are concerned, she's still hiding up on the + // roof. This is not fatal, but leads to a number of + // glitches until the state is corrected. E.g. trying + // to climb back up the ladder will cause Nico to climb + // down again. + // + // Global variable 1017 keeps track of the mop. Setting + // it to 2 means that the mop has been picked up. We + // use that as the signal that Nico's state needs to be + // updated as well. + + if (checkMopBug && parameter == 1017 && readVar(1003) != 2) { + warning("Working around mop bug: Setting Nico's state"); + writeVar(1003, 2); + } + + writeVar(parameter, value); + debug(9, "CP_POP_GLOBAL_VAR32: scriptsVars[%d] = %d", parameter, value); + break; + case CP_ADDNPOP_LOCAL_VAR32: + Read16ip(parameter); + value = READ_LE_UINT32(localVars + parameter) + pop(); + WRITE_LE_UINT32(localVars + parameter, value); + debug(9, "CP_ADDNPOP_LOCAL_VAR32: localVars[%d] => %d", parameter / 4, value); + break; + case CP_SUBNPOP_LOCAL_VAR32: + Read16ip(parameter); + value = READ_LE_UINT32(localVars + parameter) - pop(); + WRITE_LE_UINT32(localVars + parameter, value); + debug(9, "CP_SUBNPOP_LOCAL_VAR32: localVars[%d] => %d", parameter / 4, value); + break; + case CP_ADDNPOP_GLOBAL_VAR32: + // Add and pop a global variable + Read16ip(parameter); + value = readVar(parameter) + pop(); + writeVar(parameter, value); + debug(9, "CP_ADDNPOP_GLOBAL_VAR32: scriptVars[%d] => %d", parameter, value); + break; + case CP_SUBNPOP_GLOBAL_VAR32: + // Sub and pop a global variable + Read16ip(parameter); + value = readVar(parameter) - pop(); + writeVar(parameter, value); + debug(9, "CP_SUBNPOP_GLOBAL_VAR32: scriptVars[%d] => %d", parameter, value); + break; + + // Jump opcodes + + case CP_SKIPONTRUE: + // Skip if the value on the stack is true + Read32ipLeaveip(parameter); + value = pop(); + if (!value) { + ip += 4; + debug(9, "CP_SKIPONTRUE: %d (IS FALSE (NOT SKIPPED))", parameter); + } else { + ip += parameter; + debug(9, "CP_SKIPONTRUE: %d (IS TRUE (SKIPPED))", parameter); + } + break; + case CP_SKIPONFALSE: + // Skip if the value on the stack is false + Read32ipLeaveip(parameter); + value = pop(); + if (value) { + ip += 4; + debug(9, "CP_SKIPONFALSE: %d (IS TRUE (NOT SKIPPED))", parameter); + } else { + ip += parameter; + debug(9, "CP_SKIPONFALSE: %d (IS FALSE (SKIPPED))", parameter); + } + break; + case CP_SKIPALWAYS: + // skip a block + Read32ipLeaveip(parameter); + ip += parameter; + debug(9, "CP_SKIPALWAYS: %d", parameter); + break; + case CP_SWITCH: + // switch + value = pop(); + Read32ip(caseCount); + + // Search the cases + foundCase = false; + for (i = 0; i < caseCount && !foundCase; i++) { + if (value == (int32)READ_LE_UINT32(code + ip)) { + // We have found the case, so lets + // jump to it + foundCase = true; + ip += READ_LE_UINT32(code + ip + 4); + } else + ip += 4 * 2; + } + + // If we found no matching case then use the default + + if (!foundCase) + ip += READ_LE_UINT32(code + ip); + + debug(9, "CP_SWITCH: [SORRY, NO DEBUG INFO]"); + break; + case CP_SAVE_MCODE_START: + // Save the start position on an mcode instruction in + // case we need to restart it again + savedStartOfMcode = ip - 1; + debug(9, "CP_SAVE_MCODE_START"); + break; + case CP_CALL_MCODE: + // Call an mcode routine + Read16ip(parameter); + assert(parameter < ARRAYSIZE(opcodes)); + // amount to adjust stack by (no of parameters) + Read8ip(value); + debug(9, "CP_CALL_MCODE: '%s', %d", opcodes[parameter].desc, value); + stackPtr -= value; + assert(stackPtr >= 0); + retVal = (this->*opcodes[parameter].proc)(&stack[stackPtr]); + + switch (retVal & 7) { + case IR_STOP: + // Quit out for a cycle + WRITE_LE_UINT32(offsetPtr, ip); + return 0; + case IR_CONT: + // Continue as normal + break; + case IR_TERMINATE: + // Return without updating the offset + return 2; + case IR_REPEAT: + // Return setting offset to start of this + // function call + WRITE_LE_UINT32(offsetPtr, savedStartOfMcode); + return 0; + case IR_GOSUB: + // that's really neat + WRITE_LE_UINT32(offsetPtr, ip); + return 2; + default: + error("Bad return code (%d) from '%s'", retVal & 7, opcodes[parameter].desc); + } + parameterReturnedFromMcodeFunction = retVal >> 3; + break; + case CP_JUMP_ON_RETURNED: + // Jump to a part of the script depending on + // the return value from an mcode routine + + // Get the maximum value + Read8ip(parameter); + debug(9, "CP_JUMP_ON_RETURNED: %d => %d", + parameterReturnedFromMcodeFunction, + READ_LE_UINT32(code + ip + parameterReturnedFromMcodeFunction * 4)); + ip += READ_LE_UINT32(code + ip + parameterReturnedFromMcodeFunction * 4); + break; + + // Operators + + case OP_ISEQUAL: + b = pop(); + a = pop(); + push(a == b); + debug(9, "OP_ISEQUAL: RESULT = %d", a == b); + break; + case OP_NOTEQUAL: + b = pop(); + a = pop(); + push(a != b); + debug(9, "OP_NOTEQUAL: RESULT = %d", a != b); + break; + case OP_GTTHAN: + b = pop(); + a = pop(); + push(a > b); + debug(9, "OP_GTTHAN: RESULT = %d", a > b); + break; + case OP_LSTHAN: + b = pop(); + a = pop(); + push(a < b); + debug(9, "OP_LSTHAN: RESULT = %d", a < b); + break; + case OP_GTTHANE: + b = pop(); + a = pop(); + push(a >= b); + debug(9, "OP_GTTHANE: RESULT = %d", a >= b); + break; + case OP_LSTHANE: + b = pop(); + a = pop(); + push(a <= b); + debug(9, "OP_LSTHANE: RESULT = %d", a <= b); + break; + case OP_PLUS: + b = pop(); + a = pop(); + push(a + b); + debug(9, "OP_PLUS: RESULT = %d", a + b); + break; + case OP_MINUS: + b = pop(); + a = pop(); + push(a - b); + debug(9, "OP_MINUS: RESULT = %d", a - b); + break; + case OP_TIMES: + b = pop(); + a = pop(); + push(a * b); + debug(9, "OP_TIMES: RESULT = %d", a * b); + break; + case OP_DIVIDE: + b = pop(); + a = pop(); + push(a / b); + debug(9, "OP_DIVIDE: RESULT = %d", a / b); + break; + case OP_ANDAND: + b = pop(); + a = pop(); + push(a && b); + debug(9, "OP_ANDAND: RESULT = %d", a && b); + break; + case OP_OROR: + b = pop(); + a = pop(); + push(a || b); + debug(9, "OP_OROR: RESULT = %d", a || b); + break; + + // Debugging opcodes, I think + + case CP_DEBUGON: + debug(9, "CP_DEBUGON"); + break; + case CP_DEBUGOFF: + debug(9, "CP_DEBUGOFF"); + break; + case CP_TEMP_TEXT_PROCESS: + Read32ip(parameter); + debug(9, "CP_TEMP_TEXT_PROCESS: %d", parameter); + break; + default: + error("Invalid script command %d", curCommand); + return 3; + } + } + + return 1; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/interpreter.h b/engines/sword2/interpreter.h new file mode 100644 index 0000000000..365f818a98 --- /dev/null +++ b/engines/sword2/interpreter.h @@ -0,0 +1,96 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef _INTERPRETER +#define _INTERPRETER + +namespace Sword2 { + +// Interpreter return codes + +enum { + IR_STOP = 0, // Quit for a cycle + IR_CONT = 1, // Continue as normal + IR_TERMINATE = 2, // Return without updating the offset + IR_REPEAT = 3, // Return; offset at start of function call + IR_GOSUB = 4 // Return with updated offset +}; + +// Get parameter fix so that the playstation version can handle words not on +// word boundaries + +#define Read8ip(var) { var = code[ip]; ip++; } +#define Read16ip(var) { var = (int16)READ_LE_UINT16(code + ip); ip += 2; } +#define Read32ip(var) { var = (int32)READ_LE_UINT32(code + ip); ip += 4; } +#define Read32ipLeaveip(var) { var = (int32)READ_LE_UINT32(code + ip); } + +enum { + // Compiled tokens + + CP_END_SCRIPT = 0, + CP_PUSH_LOCAL_VAR32 = 1, // Push a local variable on to the stack + CP_PUSH_GLOBAL_VAR32 = 2, // Push a global variable + CP_POP_LOCAL_VAR32 = 3, // Pop a local variable from the stack + CP_CALL_MCODE = 4, // Call a machine code function + CP_PUSH_LOCAL_ADDR = 5, // Push the address of a local variable + CP_PUSH_INT32 = 6, // Adjust the stack after calling an fn function + CP_SKIPONFALSE = 7, // Skip if the bottom value on the stack is false + CP_SKIPALWAYS = 8, // Skip a block of code + CP_SWITCH = 9, // Switch on last stack value + CP_ADDNPOP_LOCAL_VAR32 = 10, // Add to a local varible + CP_SUBNPOP_LOCAL_VAR32 = 11, // Subtract from a local variable + CP_SKIPONTRUE = 12, // Skip if the bottom value on the stack is true + CP_POP_GLOBAL_VAR32 = 13, // Pop a global variable + CP_ADDNPOP_GLOBAL_VAR32 = 14, // Add to a global variable + CP_SUBNPOP_GLOBAL_VAR32 = 15, // Subtract from a global variable + CP_DEBUGON = 16, // Turn debugging on + CP_DEBUGOFF = 17, // Turn debugging off + CP_QUIT = 18, // Quit for a cycle + CP_TERMINATE = 19, // Quit script completely + + // Operators + + OP_ISEQUAL = 20, // '==' + OP_PLUS = 21, // '+' + OP_MINUS = 22, // '-' + OP_TIMES = 23, // '*' + OP_DIVIDE = 24, // '/' + OP_NOTEQUAL = 25, // '==' + OP_ANDAND = 26, // '&&' + OP_GTTHAN = 27, // '>' + OP_LSTHAN = 28, // '<' + + // More tokens, mixed types + + CP_JUMP_ON_RETURNED = 29, // Use table of jumps with value returned from fn_mcode + CP_TEMP_TEXT_PROCESS = 30, // A dummy text process command for me + CP_SAVE_MCODE_START = 31, // Save the mcode code start for restarting when necessary + CP_RESTART_SCRIPT = 32, // Start the script from the beginning + CP_PUSH_STRING = 33, // Push a pointer to a string on the stack + CP_PUSH_DEREFERENCED_STRUCTURE = 34, // Push the address of a structure thing + OP_GTTHANE = 35, // >= + OP_LSTHANE = 36, // <= + OP_OROR = 37 // || or OR +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/layers.cpp b/engines/sword2/layers.cpp new file mode 100644 index 0000000000..0b59b5a9b1 --- /dev/null +++ b/engines/sword2/layers.cpp @@ -0,0 +1,191 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +// high level layer initialising + +// the system supports: +// 1 optional background parallax layer +// 1 not optional normal backdrop layer +// 3 normal sorted layers +// up to 2 foreground parallax layers + +#include "common/stdafx.h" + +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/mouse.h" +#include "sword2/resman.h" +#include "sword2/sound.h" + +namespace Sword2 { + +/** + * This function is called when entering a new room. + * @param res resource id of the normal background layer + * @param new_palette 1 for new palette, otherwise 0 + */ + +void Screen::initBackground(int32 res, int32 new_palette) { + byte buf[NAME_LEN]; + int i; + + assert(res); + + _vm->_sound->clearFxQueue(); + waitForFade(); + + debug(1, "CHANGED TO LOCATION \"%s\"", _vm->_resman->fetchName(res, buf)); + + // if last screen was using a shading mask (see below) + if (_thisScreen.mask_flag) { + if (closeLightMask() != RD_OK) + error("Could not close light mask"); + } + + // Close the previous screen, if one is open + if (_thisScreen.background_layer_id) + closeBackgroundLayer(); + + _thisScreen.background_layer_id = res; + _thisScreen.new_palette = new_palette; + + // ok, now read the resource and pull out all the normal sort layer + // info/and set them up at the beginning of the sort list - why do it + // each cycle + + byte *file = _vm->_resman->openResource(_thisScreen.background_layer_id); + ScreenHeader screen_head; + + screen_head.read(_vm->fetchScreenHeader(file)); + + // set number of special sort layers + _thisScreen.number_of_layers = screen_head.noLayers; + _thisScreen.screen_wide = screen_head.width; + _thisScreen.screen_deep = screen_head.height; + + debug(2, "layers=%d width=%d depth=%d", screen_head.noLayers, screen_head.width, screen_head.height); + + // initialise the driver back buffer + setLocationMetrics(screen_head.width, screen_head.height); + + for (i = 0; i < screen_head.noLayers; i++) { + debug(3, "init layer %d", i); + + LayerHeader layer; + + layer.read(_vm->fetchLayerHeader(file, i)); + + // Add the layer to the sort list. We only provide just enough + // information so that it's clear that it's a layer, and where + // to sort it in relation to other things in the list. + + _sortList[i].layer_number = i + 1; + _sortList[i].sort_y = layer.y + layer.height; + } + + // reset scroll offsets + _thisScreen.scroll_offset_x = 0; + _thisScreen.scroll_offset_y = 0; + + if (screen_head.width > _screenWide || screen_head.height > _screenDeep) { + // The layer is larger than the physical screen. Switch on + // scrolling. (2 means first time on screen) + _thisScreen.scroll_flag = 2; + + // Note: if we've already set the player up then we could do + // the initial scroll set here + + // Calculate the maximum scroll offsets to prevent scrolling + // off the edge. The minimum offsets are both 0. + + _thisScreen.max_scroll_offset_x = screen_head.width - _screenWide; + _thisScreen.max_scroll_offset_y = screen_head.height - (_screenDeep - (MENUDEEP * 2)); + } else { + // The later fits on the phyiscal screen. Switch off scrolling. + _thisScreen.scroll_flag = 0; + } + + resetRenderEngine(); + + // These are the physical screen coords where the system will try to + // maintain George's actual feet coords. + + _thisScreen.feet_x = 320; + _thisScreen.feet_y = 340; + + // shading mask + + MultiScreenHeader screenLayerTable; + + screenLayerTable.read(file + ResHeader::size()); + + if (screenLayerTable.maskOffset) { + SpriteInfo spriteInfo; + + spriteInfo.x = 0; + spriteInfo.y = 0; + spriteInfo.w = screen_head.width; + spriteInfo.h = screen_head.height; + spriteInfo.scale = 0; + spriteInfo.scaledWidth = 0; + spriteInfo.scaledHeight = 0; + spriteInfo.type = 0; + spriteInfo.blend = 0; + spriteInfo.data = _vm->fetchShadingMask(file); + spriteInfo.colourTable = 0; + + if (openLightMask(&spriteInfo) != RD_OK) + error("Could not open light mask"); + + // so we know to close it later! (see above) + _thisScreen.mask_flag = true; + } else { + // no need to close a mask later + _thisScreen.mask_flag = false; + } + + // Background parallax layers + + for (i = 0; i < 2; i++) { + if (screenLayerTable.bg_parallax[i]) + initialiseBackgroundLayer(_vm->fetchBackgroundParallaxLayer(file, i)); + else + initialiseBackgroundLayer(NULL); + } + + // Normal backround layer + + initialiseBackgroundLayer(_vm->fetchBackgroundLayer(file)); + + // Foreground parallax layers + + for (i = 0; i < 2; i++) { + if (screenLayerTable.fg_parallax[i]) + initialiseBackgroundLayer(_vm->fetchForegroundParallaxLayer(file, i)); + else + initialiseBackgroundLayer(NULL); + } + + _vm->_resman->closeResource(_thisScreen.background_layer_id); +} + +} // End of namespace Sword2 diff --git a/engines/sword2/layers.h b/engines/sword2/layers.h new file mode 100644 index 0000000000..88aff933b3 --- /dev/null +++ b/engines/sword2/layers.h @@ -0,0 +1,29 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef _LAYERS +#define _LAYERS + +namespace Sword2 { + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/logic.cpp b/engines/sword2/logic.cpp new file mode 100644 index 0000000000..c26d5615b9 --- /dev/null +++ b/engines/sword2/logic.cpp @@ -0,0 +1,267 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/resman.h" +#include "sword2/router.h" +#include "sword2/sound.h" + +namespace Sword2 { + +Logic::Logic(Sword2Engine *vm) : + _vm(vm), _kills(0), _currentRunList(0), _smackerLeadIn(0), + _smackerLeadOut(0), _sequenceTextLines(0), _speechTime(0), _animId(0), + _speechAnimType(0), _leftClickDelay(0), _rightClickDelay(0), + _officialTextNumber(0), _speechTextBlocNo(0) { + + _scriptVars = NULL; + memset(_eventList, 0, sizeof(_eventList)); + memset(_syncList, 0, sizeof(_syncList)); + _router = new Router(_vm); +} + +Logic::~Logic() { + delete _router; +} + +/** + * Do one cycle of the current session. + */ + +int Logic::processSession() { + // might change during the session, so take a copy here + uint32 run_list = _currentRunList; + + _pc = 0; // first object in list + + // by minusing the pc we can cause an immediate cessation of logic + // processing on the current list + + while (_pc != 0xffffffff) { + byte *game_object_list, *head, *raw_script_ad, *raw_data_ad; + uint32 level, ret, script, id; + + game_object_list = _vm->_resman->openResource(run_list) + ResHeader::size(); + + assert(_vm->_resman->fetchType(run_list) == RUN_LIST); + + // read the next id + id = READ_LE_UINT32(game_object_list + 4 * _pc); + _pc++; + + writeVar(ID, id); + + _vm->_resman->closeResource(run_list); + + if (!id) { + // End of list - end the session naturally + return 0; + } + + assert(_vm->_resman->fetchType(id) == GAME_OBJECT); + + head = _vm->_resman->openResource(id); + _curObjectHub.setAddress(head + ResHeader::size()); + + level = _curObjectHub.getLogicLevel(); + + debug(5, "Level %d id(%d) pc(%d)", + level, + _curObjectHub.getScriptId(level), + _curObjectHub.getScriptPc(level)); + + // Do the logic for this object. We keep going until a function + // says to stop - remember, system operations are run via + // function calls to drivers now. + + do { + // There is a distinction between running one of our + // own scripts and that of another object. + + level = _curObjectHub.getLogicLevel(); + script = _curObjectHub.getScriptId(level); + + if (script / SIZE == readVar(ID)) { + // It's our own script + + debug(5, "Run script %d pc=%d", + script / SIZE, + _curObjectHub.getScriptPc(level)); + + // This is the script data. Script and data + // object are the same. + + raw_script_ad = head; + + ret = runScript2(raw_script_ad, raw_script_ad, _curObjectHub.getScriptPcPtr(level)); + } else { + // We're running the script of another game + // object - get our data object address. + + uint8 type = _vm->_resman->fetchType(script / SIZE); + + assert(type == GAME_OBJECT || type == SCREEN_MANAGER); + + raw_script_ad = _vm->_resman->openResource(script / SIZE); + raw_data_ad = head; + + ret = runScript2(raw_script_ad, raw_data_ad, _curObjectHub.getScriptPcPtr(level)); + + _vm->_resman->closeResource(script / SIZE); + + // reset to us for service script + raw_script_ad = raw_data_ad; + } + + if (ret == 1) { + level = _curObjectHub.getLogicLevel(); + + // The script finished - drop down a level + if (level) { + _curObjectHub.setLogicLevel(level - 1); + } else { + // Hmmm, level 0 terminated :-| Let's + // be different this time and simply + // let it restart next go :-) + + // Note that this really does happen a + // lot, so don't make it a warning. + + debug(5, "object %d script 0 terminated!", id); + + // reset to rerun, drop out for a cycle + _curObjectHub.setScriptPc(level, _curObjectHub.getScriptId(level) & 0xffff); + ret = 0; + } + } else if (ret > 2) { + error("processSession: illegal script return type %d", ret); + } + + // if ret == 2 then we simply go around again - a new + // script or subroutine will kick in and run + + // keep processing scripts until 0 for quit is returned + } while (ret); + + // Any post logic system requests to go here + + // Clear any syncs that were waiting for this character - it + // has used them or now looses them + + clearSyncs(readVar(ID)); + + if (_pc != 0xffffffff) { + // The session is still valid so run the graphics/mouse + // service script + runScript(raw_script_ad, raw_script_ad, 0); + } + + // and that's it so close the object resource + + _vm->_resman->closeResource(readVar(ID)); + } + + // Leaving a room so remove all ids that must reboot correctly. Then + // restart the loop. + + for (uint32 i = 0; i < _kills; i++) + _vm->_resman->remove(_objectKillList[i]); + + resetKillList(); + return 1; +} + +/** + * Bring an immediate halt to the session and cause a new one to start without + * a screen update. + */ + +void Logic::expressChangeSession(uint32 sesh_id) { + // Set new session and force the old one to quit. + _currentRunList = sesh_id; + _pc = 0xffffffff; + + // Reset now in case we double-clicked an exit prior to changing screen + writeVar(EXIT_FADING, 0); + + // We're trashing the list - presumably to change room. In theory, + // sync waiting in the list could be left behind and never removed - + // so we trash the lot + memset(_syncList, 0, sizeof(_syncList)); + + // Various clean-ups + _router->clearWalkGridList(); + _vm->_sound->clearFxQueue(); + _router->freeAllRouteMem(); +} + +/** + * @return The private _currentRunList variable. + */ + +uint32 Logic::getRunList() { + return _currentRunList; +} + +/** + * Move the current object up a level. Called by fnGosub command. Remember: + * only the logic object has access to _curObjectHub. + */ + +void Logic::logicUp(uint32 new_script) { + debug(5, "new pc = %d", new_script & 0xffff); + + // going up a level - and we'll keep going this cycle + _curObjectHub.setLogicLevel(_curObjectHub.getLogicLevel() + 1); + + assert(_curObjectHub.getLogicLevel() < 3); // Can be 0, 1, 2 + logicReplace(new_script); +} + +/** + * Force the level to one. + */ + +void Logic::logicOne(uint32 new_script) { + _curObjectHub.setLogicLevel(1); + logicReplace(new_script); +} + +/** + * Change current logic. Script must quit with a TERMINATE directive, which + * does not write to &pc + */ + +void Logic::logicReplace(uint32 new_script) { + uint32 level = _curObjectHub.getLogicLevel(); + + _curObjectHub.setScriptId(level, new_script); + _curObjectHub.setScriptPc(level, new_script & 0xffff); +} + +void Logic::resetKillList() { + _kills = 0; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/logic.h b/engines/sword2/logic.h new file mode 100644 index 0000000000..9e264f603c --- /dev/null +++ b/engines/sword2/logic.h @@ -0,0 +1,316 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +// logic management + +#ifndef _LOGIC +#define _LOGIC + +#include "sword2/memory.h" + +namespace Sword2 { + +struct MovieTextObject; + +#define MAX_events 10 + +#define TREE_SIZE 3 + +// This must allow for the largest number of objects in a screen +#define OBJECT_KILL_LIST_SIZE 50 + +#define MAX_SEQUENCE_TEXT_LINES 15 + +class Sword2Engine; +class Router; + +struct EventUnit { + uint32 id; + uint32 interact_id; +}; + +class Logic { +private: + Sword2Engine *_vm; + + inline byte *decodePtr(int32 n) { + return _vm->_memory->decodePtr(n); + } + + uint32 _objectKillList[OBJECT_KILL_LIST_SIZE]; + + // keeps note of no. of objects in the kill list + uint32 _kills; + + // denotes the res id of the game-object-list in current use + uint32 _currentRunList; + + //pc during logic loop + uint32 _pc; + + // each object has one of these tacked onto the beginning + ObjectHub _curObjectHub; + + EventUnit _eventList[MAX_events]; + + // Resource id of the wav to use as lead-in/lead-out from smacker + uint32 _smackerLeadIn; + uint32 _smackerLeadOut; + + // keeps count of number of text lines to disaply during the sequence + uint32 _sequenceTextLines; + + // FOR TEXT LINES IN SEQUENCE PLAYER + + struct SequenceTextInfo { + uint32 textNumber; + uint16 startFrame; + uint16 endFrame; + byte *text_mem; + uint32 speechBufferSize; + uint16 *speech_mem; + }; + + SequenceTextInfo _sequenceTextList[MAX_SEQUENCE_TEXT_LINES]; + + void createSequenceSpeech(MovieTextObject *sequenceText[]); + void clearSequenceSpeech(MovieTextObject *sequenceText[]); + + // when not playing a wav we calculate the speech time based upon + // length of ascii + + uint32 _speechTime; + + uint32 _animId; + + // 0 lip synced and repeating - 1 normal once through + uint32 _speechAnimType; + + uint32 _leftClickDelay; // click-delay for LEFT mouse button + uint32 _rightClickDelay; // click-delay for RIGHT mouse button + + // calculated by locateTalker() for use in speech-panning & text-sprite + // positioning + + int16 _textX, _textY; + + void locateTalker(int32 *params); + void formText(int32 *params); + bool wantSpeechForLine(uint32 wavId); + + // Set by fnPassMega() + byte _engineMega[56]; + +public: + Logic(Sword2Engine *vm); + ~Logic(); + + EventUnit *getEventList() { return _eventList; } + byte *getEngineMega() { return _engineMega; } + + byte _saveLogic[8]; + byte _saveGraphic[12]; + byte _saveMega[56]; + + // Point to the global variable data + byte *_scriptVars; + + // "TEXT" - current official text line number - will match the wav + // filenames + + int16 _officialTextNumber; + + // so speech text cleared when running a new start-script + uint32 _speechTextBlocNo; + + uint32 readVar(int n) { + return READ_LE_UINT32(_scriptVars + 4 * n); + } + + void writeVar(int n, uint32 value) { + WRITE_LE_UINT32(_scriptVars + 4 * n, value); + } + + int runResScript(uint32 scriptRes, uint32 offset); + int runResObjScript(uint32 scriptRes, uint32 objRes, uint32 offset); + int runScript(byte *scriptData, byte *objectData, uint32 offset); + int runScript2(byte *scriptData, byte *objectData, byte *offset); + + void sendEvent(uint32 id, uint32 interact_id); + void setPlayerActionEvent(uint32 id, uint32 interact_id); + void startEvent(); + int checkEventWaiting(); + void clearEvent(uint32 id); + void killAllIdsEvents(uint32 id); + + uint32 countEvents(); + + struct SyncUnit { + uint32 id; + uint32 sync; + }; + + // There won't be many, will there? Probably 2 at most i reckon + SyncUnit _syncList[10]; + + void clearSyncs(uint32 id); + void sendSync(uint32 id, uint32 sync); + int getSync(); + + Router *_router; + + int32 fnTestFunction(int32 *params); + int32 fnTestFlags(int32 *params); + int32 fnRegisterStartPoint(int32 *params); + int32 fnInitBackground(int32 *params); + int32 fnSetSession(int32 *params); + int32 fnBackSprite(int32 *params); + int32 fnSortSprite(int32 *params); + int32 fnForeSprite(int32 *params); + int32 fnRegisterMouse(int32 *params); + int32 fnAnim(int32 *params); + int32 fnRandom(int32 *params); + int32 fnPreLoad(int32 *params); + int32 fnAddSubject(int32 *params); + int32 fnInteract(int32 *params); + int32 fnChoose(int32 *params); + int32 fnWalk(int32 *params); + int32 fnWalkToAnim(int32 *params); + int32 fnTurn(int32 *params); + int32 fnStandAt(int32 *params); + int32 fnStand(int32 *params); + int32 fnStandAfterAnim(int32 *params); + int32 fnPause(int32 *params); + int32 fnMegaTableAnim(int32 *params); + int32 fnAddMenuObject(int32 *params); + int32 fnStartConversation(int32 *params); + int32 fnEndConversation(int32 *params); + int32 fnSetFrame(int32 *params); + int32 fnRandomPause(int32 *params); + int32 fnRegisterFrame(int32 *params); + int32 fnNoSprite(int32 *params); + int32 fnSendSync(int32 *params); + int32 fnUpdatePlayerStats(int32 *params); + int32 fnPassGraph(int32 *params); + int32 fnInitFloorMouse(int32 *params); + int32 fnPassMega(int32 *params); + int32 fnFaceXY(int32 *params); + int32 fnEndSession(int32 *params); + int32 fnNoHuman(int32 *params); + int32 fnAddHuman(int32 *params); + int32 fnWeWait(int32 *params); + int32 fnTheyDoWeWait(int32 *params); + int32 fnTheyDo(int32 *params); + int32 fnWalkToTalkToMega(int32 *params); + int32 fnFadeDown(int32 *params); + int32 fnISpeak(int32 *params); + int32 fnTotalRestart(int32 *params); + int32 fnSetWalkGrid(int32 *params); + int32 fnSpeechProcess(int32 *params); + int32 fnSetScaling(int32 *params); + int32 fnStartEvent(int32 *params); + int32 fnCheckEventWaiting(int32 *params); + int32 fnRequestSpeech(int32 *params); + int32 fnGosub(int32 *params); + int32 fnTimedWait(int32 *params); + int32 fnPlayFx(int32 *params); + int32 fnStopFx(int32 *params); + int32 fnPlayMusic(int32 *params); + int32 fnStopMusic(int32 *params); + int32 fnSetValue(int32 *params); + int32 fnNewScript(int32 *params); + int32 fnGetSync(int32 *params); + int32 fnWaitSync(int32 *params); + int32 fnRegisterWalkGrid(int32 *params); + int32 fnReverseMegaTableAnim(int32 *params); + int32 fnReverseAnim(int32 *params); + int32 fnAddToKillList(int32 *params); + int32 fnSetStandbyCoords(int32 *params); + int32 fnBackPar0Sprite(int32 *params); + int32 fnBackPar1Sprite(int32 *params); + int32 fnForePar0Sprite(int32 *params); + int32 fnForePar1Sprite(int32 *params); + int32 fnSetPlayerActionEvent(int32 *params); + int32 fnSetScrollCoordinate(int32 *params); + int32 fnStandAtAnim(int32 *params); + int32 fnSetScrollLeftMouse(int32 *params); + int32 fnSetScrollRightMouse(int32 *params); + int32 fnColour(int32 *params); + int32 fnFlash(int32 *params); + int32 fnPreFetch(int32 *params); + int32 fnGetPlayerSaveData(int32 *params); + int32 fnPassPlayerSaveData(int32 *params); + int32 fnSendEvent(int32 *params); + int32 fnAddWalkGrid(int32 *params); + int32 fnRemoveWalkGrid(int32 *params); + int32 fnCheckForEvent(int32 *params); + int32 fnPauseForEvent(int32 *params); + int32 fnClearEvent(int32 *params); + int32 fnFaceMega(int32 *params); + int32 fnPlaySequence(int32 *params); + int32 fnShadedSprite(int32 *params); + int32 fnUnshadedSprite(int32 *params); + int32 fnFadeUp(int32 *params); + int32 fnDisplayMsg(int32 *params); + int32 fnSetObjectHeld(int32 *params); + int32 fnAddSequenceText(int32 *params); + int32 fnResetGlobals(int32 *params); + int32 fnSetPalette(int32 *params); + int32 fnRegisterPointerText(int32 *params); + int32 fnFetchWait(int32 *params); + int32 fnRelease(int32 *params); + int32 fnPrepareMusic(int32 *params); + int32 fnSoundFetch(int32 *params); + int32 fnSmackerLeadIn(int32 *params); + int32 fnSmackerLeadOut(int32 *params); + int32 fnStopAllFx(int32 *params); + int32 fnCheckPlayerActivity(int32 *params); + int32 fnResetPlayerActivityDelay(int32 *params); + int32 fnCheckMusicPlaying(int32 *params); + int32 fnPlayCredits(int32 *params); + int32 fnSetScrollSpeedNormal(int32 *params); + int32 fnSetScrollSpeedSlow(int32 *params); + int32 fnRemoveChooser(int32 *params); + int32 fnSetFxVolAndPan(int32 *params); + int32 fnSetFxVol(int32 *params); + int32 fnRestoreGame(int32 *params); + int32 fnRefreshInventory(int32 *params); + int32 fnChangeShadows(int32 *params); + + // do one cycle of the current session + int processSession(); + + // cause the logic loop to terminate and drop out + void expressChangeSession(uint32 sesh_id); + + uint32 getRunList(); + + // setup script_id and script_pc in _curObjectHub - called by fnGosub() + void logicUp(uint32 new_script); + + void logicReplace(uint32 new_script); + void logicOne(uint32 new_script); + void resetKillList(); +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/maketext.cpp b/engines/sword2/maketext.cpp new file mode 100644 index 0000000000..5edaf5e41e --- /dev/null +++ b/engines/sword2/maketext.cpp @@ -0,0 +1,579 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +// MAKETEXT - Constructs a single-frame text sprite: returns a handle to a +// FLOATING memory block containing the sprite, given a +// null-terminated string, max width allowed, pen colour and +// pointer to required character set. +// +// NB 1) The routine does not create a standard file header or +// an anim header for the text sprite - the data simply begins +// with the frame header. +// +// NB 2) If pen colour is zero, it copies the characters into +// the sprite without remapping the colours. +// ie. It can handle both the standard 2-colour font for speech +// and any multicoloured fonts for control panels, etc. +// +// Based on textsprt.c as used for Broken Sword 1, but updated +// for new system by JEL on 9oct96 and updated again (for font +// as a resource) on 5dec96. + +#include "common/stdafx.h" +#include "common/system.h" +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/maketext.h" +#include "sword2/resman.h" + +namespace Sword2 { + +#define MAX_LINES 30 // max character lines in output sprite + +#define BORDER_COL 200 // source colour for character border (only + // needed for remapping colours) +#define LETTER_COL 193 // source colour for bulk of character ( " ) +#define SPACE ' ' +#define FIRST_CHAR SPACE // first character in character set +#define LAST_CHAR 255 // last character in character set +#define DUD 64 // the first "chequered flag" (dud) symbol in + // our character set is in the '@' position + +/** + * This function creates a new text sprite. The sprite data contains a + * FrameHeader, but not a standard file header. + * + * @param sentence pointer to a null-terminated string + * @param maxWidth the maximum allowed text sprite width in pixels + * @param pen the text colour, or zero to use the source colours + * @param fontRes the font resource id + * @param border the border colour; black by default + * @return a handle to a floating memory block containing the text sprite + * @note The sentence must contain no leading, trailing or extra spaces. + * Out-of-range characters in the string are replaced by a special + * error-signal character (chequered flag) + */ + +byte *FontRenderer::makeTextSprite(byte *sentence, uint16 maxWidth, uint8 pen, uint32 fontRes, uint8 border) { + debug(5, "makeTextSprite(\"%s\", maxWidth=%u)", sentence, maxWidth); + + _borderPen = border; + + // Line- and character spacing are hard-wired, rather than being part + // of the resource. + + if (fontRes == _vm->_speechFontId) { + _lineSpacing = -6; + _charSpacing = -3; + } else if (fontRes == CONSOLE_FONT_ID) { + _lineSpacing = 0; + _charSpacing = 1; + } else { + _lineSpacing = 0; + _charSpacing = 0; + } + + // Allocate memory for array of lineInfo structures + + byte *line = (byte *)malloc(MAX_LINES * sizeof(LineInfo)); + + // Get details of sentence breakdown into array of LineInfo structures + // and get the number of lines involved + + uint16 noOfLines = analyseSentence(sentence, maxWidth, fontRes, (LineInfo *)line); + + // Construct the sprite based on the info gathered - returns floating + // mem block + + byte *textSprite = buildTextSprite(sentence, fontRes, pen, (LineInfo *)line, noOfLines); + + free(line); + return textSprite; +} + +uint16 FontRenderer::analyseSentence(byte *sentence, uint16 maxWidth, uint32 fontRes, LineInfo *line) { + // joinWidth = how much extra space is needed to append a word to a + // line. NB. SPACE requires TWICE the '_charSpacing' to join a word + // to line + + uint16 joinWidth = charWidth(SPACE, fontRes) + 2 * _charSpacing; + + uint16 lineNo = 0; + uint16 pos = 0; + bool firstWord = true; + + byte ch; + + do { + uint16 wordWidth = 0; + uint16 wordLength = 0; + + // Calculate the width of the word. + + ch = sentence[pos++]; + + while (ch && ch != SPACE) { + wordWidth += charWidth(ch, fontRes) + _charSpacing; + wordLength++; + ch = sentence[pos++]; + } + + // Don't include any character spacing at the end of the word. + wordWidth -= _charSpacing; + + // 'ch' is now the SPACE or NULL following the word + // 'pos' indexes to the position following 'ch' + + if (firstWord) { + // This is the first word on the line, so no separating + // space is needed. + + line[0].width = wordWidth; + line[0].length = wordLength; + firstWord = false; + } else { + // See how much extra space this word will need to + // fit on current line (with a separating space + // character - also overlapped) + + uint16 spaceNeeded = joinWidth + wordWidth; + + if (line[lineNo].width + spaceNeeded <= maxWidth) { + // The word fits on this line. + line[lineNo].width += spaceNeeded; + line[lineNo].length += (1 + wordLength); + } else { + // The word spills over to the next line, i.e. + // no separating space. + + lineNo++; + + assert(lineNo < MAX_LINES); + + line[lineNo].width = wordWidth; + line[lineNo].length = wordLength; + } + } + } while (ch); + + return lineNo + 1; +} + +/** + * This function creates a new text sprite in a movable memory block. It must + * be locked before use, i.e. lock, draw sprite, unlock/free. The sprite data + * contains a FrameHeader, but not a standard file header. + * + * @param sentence pointer to a null-terminated string + * @param fontRes the font resource id + * @param pen the text colour, or zero to use the source colours + * @param line array of LineInfo structures, created by analyseSentence() + * @param noOfLines the number of lines, i.e. the number of elements in 'line' + * @return a handle to a floating memory block containing the text sprite + * @note The sentence must contain no leading, trailing or extra spaces. + * Out-of-range characters in the string are replaced by a special + * error-signal character (chequered flag) + */ + +byte *FontRenderer::buildTextSprite(byte *sentence, uint32 fontRes, uint8 pen, LineInfo *line, uint16 noOfLines) { + uint16 i; + + // Find the width of the widest line in the output text + + uint16 spriteWidth = 0; + + for (i = 0; i < noOfLines; i++) + if (line[i].width > spriteWidth) + spriteWidth = line[i].width; + + // Find the total height of the text sprite: the total height of the + // text lines, plus the total height of the spacing between them. + + uint16 char_height = charHeight(fontRes); + uint16 spriteHeight = char_height * noOfLines + _lineSpacing * (noOfLines - 1); + + // Allocate memory for the text sprite + + uint32 sizeOfSprite = spriteWidth * spriteHeight; + byte *textSprite = (byte *)malloc(FrameHeader::size() + sizeOfSprite); + + // At this stage, textSprite points to an unmovable memory block. Set + // up the frame header. + + FrameHeader frame_head; + + frame_head.compSize = 0; + frame_head.width = spriteWidth; + frame_head.height = spriteHeight; + + frame_head.write(textSprite); + + debug(4, "Text sprite size: %ux%u", spriteWidth, spriteHeight); + + // Clear the entire sprite to make it transparent. + + byte *linePtr = textSprite + FrameHeader::size(); + memset(linePtr, 0, sizeOfSprite); + + byte *charSet = _vm->_resman->openResource(fontRes); + + // Build the sprite, one line at a time + + uint16 pos = 0; + + for (i = 0; i < noOfLines; i++) { + // Center each line + byte *spritePtr = linePtr + (spriteWidth - line[i].width) / 2; + + // copy the sprite for each character in this line to the + // text sprite and inc the sprite ptr by the character's + // width minus the 'overlap' + + for (uint j = 0; j < line[i].length; j++) { + byte *charPtr = findChar(sentence[pos++], charSet); + + frame_head.read(charPtr); + + assert(frame_head.height == char_height); + copyChar(charPtr, spritePtr, spriteWidth, pen); + spritePtr += frame_head.width + _charSpacing; + } + + // Skip space at end of last word in this line + pos++; + + linePtr += (char_height + _lineSpacing) * spriteWidth; + } + + _vm->_resman->closeResource(fontRes); + + return textSprite; +} + +/** + * @param ch the ASCII code of the character + * @param fontRes the font resource id + * @return the width of the character + */ + +uint16 FontRenderer::charWidth(byte ch, uint32 fontRes) { + byte *charSet = _vm->_resman->openResource(fontRes); + + FrameHeader frame_head; + + frame_head.read(findChar(ch, charSet)); + _vm->_resman->closeResource(fontRes); + + return frame_head.width; +} + +/** + * @param fontRes the font resource id + * @return the height of a character sprite + * @note All characters in a font are assumed to have the same height, so + * there is no need to specify which one to look at. + */ + +// Returns the height of a character sprite, given the character's ASCII code +// and a pointer to the start of the character set. + +uint16 FontRenderer::charHeight(uint32 fontRes) { + byte *charSet = _vm->_resman->openResource(fontRes); + + FrameHeader frame_head; + + frame_head.read(findChar(FIRST_CHAR, charSet)); + _vm->_resman->closeResource(fontRes); + + return frame_head.height; +} + +/** + * @param ch the ASCII code of the character to find + * @param charSet pointer to the start of the character set + * @return pointer to the requested character or, if it's out of range, the + * 'dud' character (chequered flag) + */ + +byte *FontRenderer::findChar(byte ch, byte *charSet) { + if (ch < FIRST_CHAR) + ch = DUD; + return _vm->fetchFrameHeader(charSet, ch - FIRST_CHAR); +} + +/** + * Copies a character sprite to the sprite buffer. + * @param charPtr pointer to the character sprite + * @param spritePtr pointer to the sprite buffer + * @param spriteWidth the width of the character + * @param pen If zero, copy the data directly. Otherwise remap the + * sprite's colours from BORDER_COL to _borderPen and from + * LETTER_COL to pen. + */ + +void FontRenderer::copyChar(byte *charPtr, byte *spritePtr, uint16 spriteWidth, uint8 pen) { + FrameHeader frame; + + frame.read(charPtr); + + byte *source = charPtr + FrameHeader::size(); + byte *rowPtr = spritePtr; + + for (uint i = 0; i < frame.height; i++) { + byte *dest = rowPtr; + + if (pen) { + // Use the specified colours + for (uint j = 0; j < frame.width; j++) { + switch (*source++) { + case LETTER_COL: + *dest = pen; + break; + case BORDER_COL: + // Don't do a border pixel if there's + // already a bit of another character + // underneath (for overlapping!) + if (!*dest) + *dest = _borderPen; + break; + default: + // Do nothing if source pixel is zero, + // ie. transparent + break; + } + dest++; + } + } else { + // Pen is zero, so just copy character sprites + // directly into text sprite without remapping colours. + // Apparently overlapping is never considered here? + memcpy(dest, source, frame.width); + source += frame.width; + } + rowPtr += spriteWidth; + } +} + +// Distance to keep speech text from edges of screen +#define TEXT_MARGIN 12 + +/** + * Creates a text bloc in the list and returns the bloc number. The list of + * blocs is read and blitted at render time. Choose alignment type + * RDSPR_DISPLAYALIGN or 0 + */ + +uint32 FontRenderer::buildNewBloc(byte *ascii, int16 x, int16 y, uint16 width, uint8 pen, uint32 type, uint32 fontRes, uint8 justification) { + uint32 i = 0; + + while (i < MAX_text_blocs && _blocList[i].text_mem) + i++; + + assert(i < MAX_text_blocs); + + // Create and position the sprite + + _blocList[i].text_mem = makeTextSprite(ascii, width, pen, fontRes); + + // 'NO_JUSTIFICATION' means print sprite with top-left at (x,y) + // without margin checking - used for debug text + + if (justification != NO_JUSTIFICATION) { + FrameHeader frame_head; + + frame_head.read(_blocList[i].text_mem); + + switch (justification) { + case POSITION_AT_CENTRE_OF_BASE: + // This one is always used for SPEECH TEXT; possibly + // also for pointer text + x -= (frame_head.width / 2); + y -= frame_head.height; + break; + case POSITION_AT_CENTRE_OF_TOP: + x -= (frame_head.width / 2); + break; + case POSITION_AT_LEFT_OF_TOP: + // The given coords are already correct for this! + break; + case POSITION_AT_RIGHT_OF_TOP: + x -= frame_head.width; + break; + case POSITION_AT_LEFT_OF_BASE: + y -= frame_head.height; + break; + case POSITION_AT_RIGHT_OF_BASE: + x -= frame_head.width; + y -= frame_head.height; + break; + case POSITION_AT_LEFT_OF_CENTRE: + y -= (frame_head.height / 2); + break; + case POSITION_AT_RIGHT_OF_CENTRE: + x -= frame_head.width; + y -= (frame_head.height) / 2; + break; + } + + // Ensure text sprite is a few pixels inside the visible screen + // remember - it's RDSPR_DISPLAYALIGN + + uint16 text_left_margin = TEXT_MARGIN; + uint16 text_right_margin = 640 - TEXT_MARGIN - frame_head.width; + uint16 text_top_margin = TEXT_MARGIN; + uint16 text_bottom_margin = 400 - TEXT_MARGIN - frame_head.height; + + // Move if too far left or too far right + + if (x < text_left_margin) + x = text_left_margin; + else if (x > text_right_margin) + x = text_right_margin; + + // Move if too high or too low + + if (y < text_top_margin) + y = text_top_margin; + else if (y > text_bottom_margin) + y = text_bottom_margin; + } + + // The sprite is always uncompressed + _blocList[i].type = type | RDSPR_NOCOMPRESSION; + + _blocList[i].x = x; + _blocList[i].y = y; + + return i + 1; +} + +/** + * Called by buildDisplay() + */ + +void FontRenderer::printTextBlocs() { + for (uint i = 0; i < MAX_text_blocs; i++) { + if (_blocList[i].text_mem) { + FrameHeader frame_head; + SpriteInfo spriteInfo; + + frame_head.read(_blocList[i].text_mem); + + spriteInfo.x = _blocList[i].x; + spriteInfo.y = _blocList[i].y; + spriteInfo.w = frame_head.width; + spriteInfo.h = frame_head.height; + spriteInfo.scale = 0; + spriteInfo.scaledWidth = 0; + spriteInfo.scaledHeight = 0; + spriteInfo.type = _blocList[i].type; + spriteInfo.blend = 0; + spriteInfo.data = _blocList[i].text_mem + FrameHeader::size(); + spriteInfo.colourTable = 0; + + uint32 rv = _vm->_screen->drawSprite(&spriteInfo); + if (rv) + error("Driver Error %.8x in printTextBlocs", rv); + } + } +} + +void FontRenderer::killTextBloc(uint32 bloc_number) { + bloc_number--; + free(_blocList[bloc_number].text_mem); + _blocList[bloc_number].text_mem = NULL; +} + +// Resource 3258 contains text from location script for 152 (install, save & +// restore text, etc) + +#define TEXT_RES 3258 + +// Local line number of "save" (actor no. 1826) + +#define SAVE_LINE_NO 1 + +void Sword2Engine::initialiseFontResourceFlags() { + byte *textFile = _resman->openResource(TEXT_RES); + + // If language is Polish or Finnish it requires alternate fonts. + // Otherwise, use regular fonts + + // "tallenna" Finnish for "save" + // "zapisz" Polish for "save" + + // Get the text line (& skip the 2 chars containing the wavId) + char *textLine = (char *)fetchTextLine(textFile, SAVE_LINE_NO) + 2; + + if (strcmp(textLine, "tallenna") == 0) + initialiseFontResourceFlags(FINNISH_TEXT); + else if (strcmp(textLine, "zapisz") == 0) + initialiseFontResourceFlags(POLISH_TEXT); + else + initialiseFontResourceFlags(DEFAULT_TEXT); + + // Get the game name for the windows application + + // According to the GetNameFunction(), which was never called and has + // therefore been removed, the name of the game is: + // + // ENGLISH: "Broken Sword II" + // AMERICAN: "Circle of Blood II" + // GERMAN: "Baphomet's Fluch II" + // default: "Some game or other, part 86" + // + // But we get it from the text resource instead. + + if (_logic->readVar(DEMO)) + textLine = (char *)fetchTextLine(textFile, 451) + 2; + else + textLine = (char *)fetchTextLine(textFile, 54) + 2; + + _system->setWindowCaption(textLine); + _resman->closeResource(TEXT_RES); +} + +/** + * Called from initialiseFontResourceFlags(), and also from console.cpp + */ + +void Sword2Engine::initialiseFontResourceFlags(uint8 language) { + switch (language) { + case FINNISH_TEXT: + _speechFontId = FINNISH_SPEECH_FONT_ID; + _controlsFontId = FINNISH_CONTROLS_FONT_ID; + _redFontId = FINNISH_RED_FONT_ID; + break; + case POLISH_TEXT: + _speechFontId = POLISH_SPEECH_FONT_ID; + _controlsFontId = POLISH_CONTROLS_FONT_ID; + _redFontId = POLISH_RED_FONT_ID; + break; + default: + _speechFontId = ENGLISH_SPEECH_FONT_ID; + _controlsFontId = ENGLISH_CONTROLS_FONT_ID; + _redFontId = ENGLISH_RED_FONT_ID; + break; + } +} + +} // End of namespace Sword2 diff --git a/engines/sword2/maketext.h b/engines/sword2/maketext.h new file mode 100644 index 0000000000..364a412857 --- /dev/null +++ b/engines/sword2/maketext.h @@ -0,0 +1,119 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef _MAKETEXT_H +#define _MAKETEXT_H + +#include "sword2/debug.h" + +namespace Sword2 { + +// Output colour for character border - should be be black but note that we +// have to use a different pen number during sequences + +#define BORDER_PEN 194 + +// Usually the only texts on screen are the subtitles and the mouse-over text, +// but there can also be a considerable number of debugging messages... + +#define MAX_text_blocs MAX_DEBUG_TEXTS + 1 + +enum { + // Doesn't keep the text inside the screen - only for debug text! + NO_JUSTIFICATION = 0, + + // These all force text inside the screen edge margin when necessary + POSITION_AT_CENTRE_OF_BASE = 1, + POSITION_AT_CENTRE_OF_TOP = 2, + POSITION_AT_LEFT_OF_TOP = 3, + POSITION_AT_RIGHT_OF_TOP = 4, + POSITION_AT_LEFT_OF_BASE = 5, + POSITION_AT_RIGHT_OF_BASE = 6, + POSITION_AT_LEFT_OF_CENTRE = 7, + POSITION_AT_RIGHT_OF_CENTRE = 8 +}; + +enum { + DEFAULT_TEXT = 0, + FINNISH_TEXT = 1, + POLISH_TEXT = 2 +}; + +// Info about the text, used to create the SpriteInfo struct + + struct TextBloc { + int16 x; + int16 y; + uint16 type; + byte *text_mem; +}; + +// Info for each line of words in the output text sprite + +struct LineInfo { + uint16 width; // Width in pixels + uint16 length; // Length in characters +}; + +class FontRenderer { +private: + Sword2Engine *_vm; + TextBloc _blocList[MAX_text_blocs]; + + // Layout variables - these used to be defines, but now we're dealing + // with three character sets + + int8 _lineSpacing; // no. of pixels to separate lines of + // characters in the output sprite - negative + // for overlap + int8 _charSpacing; // no. of pixels to separate characters along + // each line - negative for overlap + uint8 _borderPen; // output pen colour of character borders + + uint16 analyseSentence(byte *sentence, uint16 maxWidth, uint32 fontRes, LineInfo *line); + byte *buildTextSprite(byte *sentence, uint32 fontRes, uint8 pen, LineInfo *line, uint16 noOfLines); + uint16 charWidth(byte ch, uint32 fontRes); + uint16 charHeight(uint32 fontRes); + byte *findChar(byte ch, byte *charSet); + void copyChar(byte *charPtr, byte *spritePtr, uint16 spriteWidth, uint8 pen); + +public: + FontRenderer(Sword2Engine *vm) : _vm(vm) { + for (int i = 0; i < MAX_text_blocs; i++) + _blocList[i].text_mem = NULL; + } + + ~FontRenderer() { + for (int i = 0; i < MAX_text_blocs; i++) + free(_blocList[i].text_mem); + } + + byte *makeTextSprite(byte *sentence, uint16 maxWidth, uint8 pen, uint32 fontRes, uint8 border = BORDER_PEN); + + void killTextBloc(uint32 bloc_number); + void printTextBlocs(); + + uint32 buildNewBloc(byte *ascii, int16 x, int16 y, uint16 width, uint8 pen, uint32 type, uint32 fontRes, uint8 justification); +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/memory.cpp b/engines/sword2/memory.cpp new file mode 100644 index 0000000000..7da4e86b51 --- /dev/null +++ b/engines/sword2/memory.cpp @@ -0,0 +1,244 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +// The new memory manager, now only used by the resource manager. The original +// one would allocated a 12 MB memory pool at startup, which may have been +// appropriate for the original Playstation version but didn't work very well +// with our PocketPC version. +// +// There is one thing that prevents us from replacing the whole memory manager +// with the standard memory allocation functions: Broken Sword 2 absolutely, +// positively needs to be able to encode pointers as 32-bit integers. The +// original engine did this simply by casting between pointers and integers, +// but as far as I know that's not a very portable thing to do. +// +// If it had only used pointers as opcode parameters it would have been +// possible, albeit messy, to extend the stack data type. However, there is +// code in walker.cpp that obviously violates that assumption, and there are +// probably other cases as well. +// +// Instead, we take advantage of the fact that the original memory manager +// could only handle up to 999 blocks of memory. That means we can encode a +// pointer as a 10-bit id and a 22-bit offset into the block. Judging by early +// testing, both should be plenty. +// +// The number zero is used to represent the NULL pointer. + +#include "common/stdafx.h" +#include "sword2/sword2.h" +#include "sword2/memory.h" + +namespace Sword2 { + +MemoryManager::MemoryManager(Sword2Engine *vm) : _vm(vm) { + // The id stack contains all the possible ids for the memory blocks. + // We use this to ensure that no two blocks ever have the same id. + + // The memory blocks are stored in an array, indexed on the block's + // id. This means that given a block id we can find the pointer with a + // simple array lookup. + + // The memory block index is an array of pointers to the memory block + // array, sorted on the memory block's pointer. This means that given + // a pointer into a memory block we can find its id with binary + // searching. + // + // A balanced tree might have been more efficient - the index has to + // be re-sorted every time a block is allocated or freed - but such + // beasts are tricky to implement. Anyway, it wouldn't have made + // encoding or decoding pointers any faster, and these are by far the + // most common operations. + + _idStack = (int16 *)malloc(MAX_MEMORY_BLOCKS * sizeof(int16)); + _memBlocks = (MemBlock *)malloc(MAX_MEMORY_BLOCKS * sizeof(MemBlock)); + _memBlockIndex = (MemBlock **)malloc(MAX_MEMORY_BLOCKS * sizeof(MemBlock *)); + + _totAlloc = 0; + _numBlocks = 0; + + for (int i = 0; i < MAX_MEMORY_BLOCKS; i++) { + _idStack[i] = MAX_MEMORY_BLOCKS - i - 1; + _memBlocks[i].ptr = NULL; + _memBlockIndex[i] = NULL; + } + + _idStackPtr = MAX_MEMORY_BLOCKS; +} + +MemoryManager::~MemoryManager() { + for (int i = 0; i < MAX_MEMORY_BLOCKS; i++) + free(_memBlocks[i].ptr); + free(_memBlocks); + free(_memBlockIndex); + free(_idStack); +} + +int32 MemoryManager::encodePtr(byte *ptr) { + if (ptr == NULL) + return 0; + + int idx = findPointerInIndex(ptr); + + assert(idx != -1); + + uint32 id = _memBlockIndex[idx]->id; + uint32 offset = ptr - _memBlocks[id].ptr; + + assert(id < 0x03ff); + assert(offset <= 0x003fffff); + assert(offset < _memBlocks[id].size); + + return ((id + 1) << 22) | (ptr - _memBlocks[id].ptr); +} + +byte *MemoryManager::decodePtr(int32 n) { + if (n == 0) + return NULL; + + uint32 id = ((n & 0xffc00000) >> 22) - 1; + uint32 offset = n & 0x003fffff; + + assert(_memBlocks[id].ptr); + assert(offset < _memBlocks[id].size); + + return _memBlocks[id].ptr + offset; +} + +int16 MemoryManager::findExactPointerInIndex(byte *ptr) { + int left = 0; + int right = _numBlocks - 1; + + while (right >= left) { + int n = (left + right) / 2; + + if (_memBlockIndex[n]->ptr == ptr) + return n; + + if (_memBlockIndex[n]->ptr > ptr) + right = n - 1; + else + left = n + 1; + } + + return -1; +} + +int16 MemoryManager::findPointerInIndex(byte *ptr) { + int left = 0; + int right = _numBlocks - 1; + + while (right >= left) { + int n = (left + right) / 2; + + if (_memBlockIndex[n]->ptr <= ptr && _memBlockIndex[n]->ptr + _memBlockIndex[n]->size > ptr) + return n; + + if (_memBlockIndex[n]->ptr > ptr) + right = n - 1; + else + left = n + 1; + } + + return -1; +} + +int16 MemoryManager::findInsertionPointInIndex(byte *ptr) { + if (_numBlocks == 0) + return 0; + + int left = 0; + int right = _numBlocks - 1; + int n = 0; + + while (right >= left) { + n = (left + right) / 2; + + if (_memBlockIndex[n]->ptr == ptr) + return -1; + + if (_memBlockIndex[n]->ptr > ptr) + right = n - 1; + else + left = n + 1; + } + + if (_memBlockIndex[n]->ptr < ptr) + n++; + + return n; +} + +byte *MemoryManager::memAlloc(uint32 size, int16 uid) { + assert(_idStackPtr > 0); + + // Get the new block's id from the stack. + int16 id = _idStack[--_idStackPtr]; + + // Allocate the new memory block + byte *ptr = (byte *)malloc(size); + + assert(ptr); + + _memBlocks[id].id = id; + _memBlocks[id].uid = uid; + _memBlocks[id].ptr = ptr; + _memBlocks[id].size = size; + + // Update the memory block index. + int16 idx = findInsertionPointInIndex(ptr); + + assert(idx != -1); + + for (int i = _numBlocks; i > idx; i--) + _memBlockIndex[i] = _memBlockIndex[i - 1]; + + _memBlockIndex[idx] = &_memBlocks[id]; + _numBlocks++; + _totAlloc += size; + + return _memBlocks[id].ptr; +} + +void MemoryManager::memFree(byte *ptr) { + int16 idx = findExactPointerInIndex(ptr); + + if (idx == -1) { + warning("Freeing non-allocated pointer %p", ptr); + return; + } + + // Put back the id on the stack + _idStack[_idStackPtr++] = _memBlockIndex[idx]->id; + + // Release the memory block + free(_memBlockIndex[idx]->ptr); + _memBlockIndex[idx]->ptr = NULL; + + _totAlloc -= _memBlockIndex[idx]->size; + + // Remove the memory block from the index + _numBlocks--; + + for (int i = idx; i < _numBlocks; i++) + _memBlockIndex[i] = _memBlockIndex[i + 1]; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/memory.h b/engines/sword2/memory.h new file mode 100644 index 0000000000..3154842cd9 --- /dev/null +++ b/engines/sword2/memory.h @@ -0,0 +1,70 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef MEMORY_H +#define MEMORY_H + +#define MAX_MEMORY_BLOCKS 999 + +namespace Sword2 { + +struct MemBlock { + int16 id; + int16 uid; + byte *ptr; + uint32 size; +}; + +class MemoryManager { +private: + Sword2Engine *_vm; + + MemBlock *_memBlocks; + MemBlock **_memBlockIndex; + int16 _numBlocks; + + uint32 _totAlloc; + + int16 *_idStack; + int16 _idStackPtr; + + int16 findExactPointerInIndex(byte *ptr); + int16 findPointerInIndex(byte *ptr); + int16 findInsertionPointInIndex(byte *ptr); + +public: + MemoryManager(Sword2Engine *vm); + ~MemoryManager(); + + int16 getNumBlocks() { return _numBlocks; } + uint32 getTotAlloc() { return _totAlloc; } + MemBlock *getMemBlocks() { return _memBlocks; } + + int32 encodePtr(byte *ptr); + byte *decodePtr(int32 n); + + byte *memAlloc(uint32 size, int16 uid); + void memFree(byte *ptr); +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/menu.cpp b/engines/sword2/menu.cpp new file mode 100644 index 0000000000..07e00accb6 --- /dev/null +++ b/engines/sword2/menu.cpp @@ -0,0 +1,291 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" + +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/mouse.h" + +namespace Sword2 { + +#define MENUDEEP 40 +#define MAXMENUANIMS 8 + +void Mouse::clearIconArea(int menu, int pocket, Common::Rect *r) { + byte *buf = _vm->_screen->getScreen(); + int16 screenWide = _vm->_screen->getScreenWide(); + + r->top = menu * (RENDERDEEP + MENUDEEP) + (MENUDEEP - RDMENU_ICONDEEP) / 2; + r->bottom = r->top + RDMENU_ICONDEEP; + r->left = RDMENU_ICONSTART + pocket * (RDMENU_ICONWIDE + RDMENU_ICONSPACING); + r->right = r->left + RDMENU_ICONWIDE; + + byte *dst = buf + r->top * screenWide + r->left; + + for (int i = 0; i < RDMENU_ICONDEEP; i++) { + memset(dst, 0, RDMENU_ICONWIDE); + dst += screenWide; + } +} + +/** + * This function should be called regularly to process the menubar system. The + * rate at which this function is called will dictate how smooth the menu + * system is. + */ + +void Mouse::processMenu() { + uint8 menu; + uint8 i, j; + uint8 frameCount; + Common::Rect r1, r2; + static int32 lastTime = 0; + + byte *buf = _vm->_screen->getScreen(); + int16 screenWide = _vm->_screen->getScreenWide(); + + if (lastTime == 0) { + lastTime = _vm->getMillis(); + frameCount = 1; + } else { + int32 delta = _vm->getMillis() - lastTime; + + if (delta > 250) { + lastTime += delta; + delta = 250; + frameCount = 1; + } else { + frameCount = (uint8) ((_iconCount + 8) * delta / 750); + lastTime += frameCount * 750 / (_iconCount + 8); + } + } + + // Note: The "almost hidden" menu state exists only so that the menu + // will be redrawn one last time before it's completely hidden. We do + // not need a corresponding "almost shown" state because the menu will + // always be redrawn while it's shown anyway. (We may want to change + // this later.) + + while (frameCount-- > 0) { + for (menu = RDMENU_TOP; menu <= RDMENU_BOTTOM; menu++) { + if (_menuStatus[menu] == RDMENU_HIDDEN || _menuStatus[menu] == RDMENU_ALMOST_HIDDEN || _menuStatus[menu] == RDMENU_SHOWN) + continue; + + int target, direction, nextState; + + if (_menuStatus[menu] == RDMENU_OPENING) { + target = MAXMENUANIMS; + direction = 1; + nextState = RDMENU_SHOWN; + } else { + target = 0; + direction = -1; + nextState = RDMENU_ALMOST_HIDDEN; + } + + bool complete = true; + + // Propagate animation from the first icon... + for (i = RDMENU_MAXPOCKETS - 1; i > 0; i--) { + _pocketStatus[menu][i] = _pocketStatus[menu][i - 1]; + + if (_pocketStatus[menu][i] != target) + complete = false; + } + + if (_pocketStatus[menu][i] != target) + complete = false; + + // ...and animate the first icon + if (_pocketStatus[menu][0] != target) + _pocketStatus[menu][0] += direction; + + if (complete) + _menuStatus[menu] = nextState; + } + } + + for (menu = RDMENU_TOP; menu <= RDMENU_BOTTOM; menu++) { + if (_menuStatus[menu] == RDMENU_HIDDEN) + continue; + + if (_menuStatus[menu] == RDMENU_ALMOST_HIDDEN) + _menuStatus[menu] = RDMENU_HIDDEN; + + // Draw the menu here. + int32 curx = RDMENU_ICONSTART + RDMENU_ICONWIDE / 2; + int32 cury = (MENUDEEP / 2) + (RENDERDEEP + MENUDEEP) * menu; + + for (i = 0; i < RDMENU_MAXPOCKETS; i++) { + if (_icons[menu][i]) { + int32 xoff, yoff; + + // Since we no longer clear the screen after + // each frame we need to clear the icon area. + + clearIconArea(menu, i, &r1); + + if (_pocketStatus[menu][i] == MAXMENUANIMS) { + xoff = (RDMENU_ICONWIDE / 2); + r2.left = curx - xoff; + r2.right = r2.left + RDMENU_ICONWIDE; + yoff = (RDMENU_ICONDEEP / 2); + r2.top = cury - yoff; + r2.bottom = r2.top + RDMENU_ICONDEEP; + } else { + xoff = (RDMENU_ICONWIDE / 2) * _pocketStatus[menu][i] / MAXMENUANIMS; + r2.left = curx - xoff; + r2.right = curx + xoff; + yoff = (RDMENU_ICONDEEP / 2) * _pocketStatus[menu][i] / MAXMENUANIMS; + r2.top = cury - yoff; + r2.bottom = cury + yoff; + } + + if (xoff != 0 && yoff != 0) { + byte *dst = buf + r2.top * screenWide + r2.left; + byte *src = _icons[menu][i]; + + if (_pocketStatus[menu][i] != MAXMENUANIMS) { + _vm->_screen->scaleImageFast( + dst, screenWide, r2.right - r2.left, r2.bottom - r2.top, + src, RDMENU_ICONWIDE, RDMENU_ICONWIDE, RDMENU_ICONDEEP); + } else { + for (j = 0; j < RDMENU_ICONDEEP; j++) { + memcpy(dst, src, RDMENU_ICONWIDE); + src += RDMENU_ICONWIDE; + dst += screenWide; + } + } + } + _vm->_screen->updateRect(&r1); + } + curx += (RDMENU_ICONSPACING + RDMENU_ICONWIDE); + } + } +} + +/** + * This function brings a specified menu into view. + * @param menu RDMENU_TOP or RDMENU_BOTTOM, depending on which menu to show + * @return RD_OK, or an error code + */ + +int32 Mouse::showMenu(uint8 menu) { + // Check for invalid menu parameter + if (menu > RDMENU_BOTTOM) + return RDERR_INVALIDMENU; + + // Check that the menu is not currently shown, or in the process of + // being shown. + if (_menuStatus[menu] == RDMENU_SHOWN || _menuStatus[menu] == RDMENU_OPENING) + return RDERR_INVALIDCOMMAND; + + _menuStatus[menu] = RDMENU_OPENING; + return RD_OK; +} + +/** + * This function hides a specified menu. + * @param menu RDMENU_TOP or RDMENU_BOTTOM depending on which menu to hide + * @return RD_OK, or an error code + */ + +int32 Mouse::hideMenu(uint8 menu) { + // Check for invalid menu parameter + if (menu > RDMENU_BOTTOM) + return RDERR_INVALIDMENU; + + // Check that the menu is not currently hidden, or in the process of + // being hidden. + if (_menuStatus[menu] == RDMENU_HIDDEN || _menuStatus[menu] == RDMENU_CLOSING) + return RDERR_INVALIDCOMMAND; + + _menuStatus[menu] = RDMENU_CLOSING; + return RD_OK; +} + +/** + * This function hides both menus immediately. + */ + +void Mouse::closeMenuImmediately() { + Common::Rect r; + int i; + + _menuStatus[RDMENU_TOP] = RDMENU_HIDDEN; + _menuStatus[RDMENU_BOTTOM] = RDMENU_HIDDEN; + + for (i = 0; i < RDMENU_MAXPOCKETS; i++) { + if (_icons[RDMENU_TOP][i]) { + clearIconArea(RDMENU_TOP, i, &r); + _vm->_screen->updateRect(&r); + } + if (_icons[RDMENU_BOTTOM][i]) { + clearIconArea(RDMENU_BOTTOM, i, &r); + _vm->_screen->updateRect(&r); + } + } + + memset(_pocketStatus, 0, sizeof(uint8) * 2 * RDMENU_MAXPOCKETS); +} + +/** + * This function sets a menubar icon. + * @param menu RDMENU_TOP or RDMENU_BOTTOM, depending on which menu to change + * @param pocket the menu pocket to change + * @param icon icon data, or NULL to clear the icon + * @return RD_OK, or an error code + */ + +int32 Mouse::setMenuIcon(uint8 menu, uint8 pocket, byte *icon) { + Common::Rect r; + + // Check for invalid menu parameter. + if (menu > RDMENU_BOTTOM) + return RDERR_INVALIDMENU; + + // Check for invalid pocket parameter + if (pocket >= RDMENU_MAXPOCKETS) + return RDERR_INVALIDPOCKET; + + // If there is an icon in the requested menu/pocket, clear it out. + if (_icons[menu][pocket]) { + _iconCount--; + free(_icons[menu][pocket]); + _icons[menu][pocket] = NULL; + clearIconArea(menu, pocket, &r); + _vm->_screen->updateRect(&r); + } + + // Only put the icon in the pocket if it is not NULL + if (icon != NULL) { + _iconCount++; + _icons[menu][pocket] = (byte *)malloc(RDMENU_ICONWIDE * RDMENU_ICONDEEP); + if (_icons[menu][pocket] == NULL) + return RDERR_OUTOFMEMORY; + memcpy(_icons[menu][pocket], icon, RDMENU_ICONWIDE * RDMENU_ICONDEEP); + } + + return RD_OK; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/module.mk b/engines/sword2/module.mk new file mode 100644 index 0000000000..2ee3f39ebb --- /dev/null +++ b/engines/sword2/module.mk @@ -0,0 +1,48 @@ +MODULE := engines/sword2 + +MODULE_OBJS := \ + engines/sword2/_mouse.o \ + engines/sword2/animation.o \ + engines/sword2/anims.o \ + engines/sword2/build_display.o \ + engines/sword2/console.o \ + engines/sword2/controls.o \ + engines/sword2/d_draw.o \ + engines/sword2/debug.o \ + engines/sword2/events.o \ + engines/sword2/function.o \ + engines/sword2/icons.o \ + engines/sword2/interpreter.o \ + engines/sword2/layers.o \ + engines/sword2/logic.o \ + engines/sword2/maketext.o \ + engines/sword2/memory.o \ + engines/sword2/menu.o \ + engines/sword2/mouse.o \ + engines/sword2/music.o \ + engines/sword2/palette.o \ + engines/sword2/protocol.o \ + engines/sword2/rdwin.o \ + engines/sword2/render.o \ + engines/sword2/resman.o \ + engines/sword2/router.o \ + engines/sword2/save_rest.o \ + engines/sword2/scroll.o \ + engines/sword2/sound.o \ + engines/sword2/speech.o \ + engines/sword2/sprite.o \ + engines/sword2/startup.o \ + engines/sword2/sword2.o \ + engines/sword2/sync.o \ + engines/sword2/walker.o + +MODULE_DIRS += \ + engines/sword2 + +# This module can be built as a plugin +ifdef BUILD_PLUGINS +PLUGIN := 1 +endif + +# Include common rules +include $(srcdir)/common.rules diff --git a/engines/sword2/mouse.cpp b/engines/sword2/mouse.cpp new file mode 100644 index 0000000000..f8c315a47f --- /dev/null +++ b/engines/sword2/mouse.cpp @@ -0,0 +1,1437 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "sword2/sword2.h" +#include "sword2/console.h" +#include "sword2/controls.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/maketext.h" +#include "sword2/mouse.h" +#include "sword2/resman.h" +#include "sword2/sound.h" + +namespace Sword2 { + +// Pointer resource id's + +enum { + CROSHAIR = 18, + EXIT0 = 788, + EXIT1 = 789, + EXIT2 = 790, + EXIT3 = 791, + EXIT4 = 792, + EXIT5 = 793, + EXIT6 = 794, + EXIT7 = 795, + EXITDOWN = 796, + EXITUP = 797, + MOUTH = 787, + NORMAL = 17, + PICKUP = 3099, + SCROLL_L = 1440, + SCROLL_R = 1441, + USE = 3100 +}; + +Mouse::Mouse(Sword2Engine *vm) { + _vm = vm; + + setPos(0, 0); + resetMouseList(); + + _mouseTouching = 0; + _oldMouseTouching = 0; + _menuSelectedPos = 0; + _examiningMenuIcon = false; + _mousePointerRes = 0; + _mouseMode = 0; + _mouseStatus = false; + _mouseModeLocked = false; + _currentLuggageResource = 0; + _oldButton = 0; + _buttonClick = 0; + _pointerTextBlocNo = 0; + _playerActivityDelay = 0; + _realLuggageItem = 0; + + _mouseAnim.data = NULL; + _luggageAnim.data = NULL; + + // For the menus + _totalTemp = 0; + memset(_tempList, 0, sizeof(_tempList)); + + _totalMasters = 0; + memset(_masterMenuList, 0, sizeof(_masterMenuList)); + memset(_mouseList, 0, sizeof(_mouseList)); + memset(_subjectList, 0, sizeof(_subjectList)); + + _defaultResponseId = 0; + _choosing = false; + + _iconCount = 0; + + for (int i = 0; i < 2; i++) { + for (int j = 0; j < RDMENU_MAXPOCKETS; j++) { + _icons[i][j] = NULL; + _pocketStatus[i][j] = 0; + } + + _menuStatus[i] = RDMENU_HIDDEN; + } +} + +Mouse::~Mouse() { + free(_mouseAnim.data); + free(_luggageAnim.data); + for (int i = 0; i < 2; i++) + for (int j = 0; j < RDMENU_MAXPOCKETS; j++) + free(_icons[i][j]); +} + +void Mouse::getPos(int &x, int &y) { + x = _pos.x; + y = _pos.y; +} + +void Mouse::setPos(int x, int y) { + _pos.x = x; + _pos.y = y; +} + +/** + * Call at beginning of game loop + */ + +void Mouse::resetMouseList() { + _curMouse = 0; +} + +void Mouse::registerMouse(byte *ob_mouse, BuildUnit *build_unit) { + assert(_curMouse < TOTAL_mouse_list); + + ObjectMouse mouse; + + mouse.read(ob_mouse); + + if (!mouse.pointer) + return; + + if (build_unit) { + _mouseList[_curMouse].rect.left = build_unit->x; + _mouseList[_curMouse].rect.top = build_unit->y; + _mouseList[_curMouse].rect.right = 1 + build_unit->x + build_unit->scaled_width; + _mouseList[_curMouse].rect.bottom = 1 + build_unit->y + build_unit->scaled_height; + } else { + _mouseList[_curMouse].rect.left = mouse.x1; + _mouseList[_curMouse].rect.top = mouse.y1; + _mouseList[_curMouse].rect.right = 1 + mouse.x2; + _mouseList[_curMouse].rect.bottom = 1 + mouse.y2; + } + + _mouseList[_curMouse].priority = mouse.priority; + _mouseList[_curMouse].pointer = mouse.pointer; + + // Change all COGS pointers to CROSHAIR. I'm guessing that this was a + // design decision made in mid-development and they didn't want to go + // back and re-generate the resource files. + + if (_mouseList[_curMouse].pointer == USE) + _mouseList[_curMouse].pointer = CROSHAIR; + + // Check if pointer text field is set due to previous object using this + // slot (ie. not correct for this one) + + // If 'pointer_text' field is set, but the 'id' field isn't same is + // current id then we don't want this "left over" pointer text + + if (_mouseList[_curMouse].pointer_text && _mouseList[_curMouse].id != (int32)_vm->_logic->readVar(ID)) + _mouseList[_curMouse].pointer_text = 0; + + // Get id from system variable 'id' which is correct for current object + _mouseList[_curMouse].id = _vm->_logic->readVar(ID); + + _curMouse++; +} + +void Mouse::registerPointerText(int32 text_id) { + assert(_curMouse < TOTAL_mouse_list); + + // current object id - used for checking pointer_text when mouse area + // registered (in fnRegisterMouse and fnRegisterFrame) + + _mouseList[_curMouse].id = _vm->_logic->readVar(ID); + _mouseList[_curMouse].pointer_text = text_id; +} + +/** + * This function is called every game cycle. + */ + +void Mouse::mouseEngine() { + monitorPlayerActivity(); + clearPointerText(); + + // If George is dead, the system menu is visible all the time, and is + // the only thing that can be used. + + if (_vm->_logic->readVar(DEAD)) { + if (_mouseMode != MOUSE_system_menu) { + _mouseMode = MOUSE_system_menu; + + if (_mouseTouching) { + _oldMouseTouching = 0; + _mouseTouching = 0; + } + + setMouse(NORMAL_MOUSE_ID); + buildSystemMenu(); + } + systemMenuMouse(); + return; + } + + // If the mouse is not visible, do nothing + + if (_mouseStatus) + return; + + switch (_mouseMode) { + case MOUSE_normal: + normalMouse(); + break; + case MOUSE_menu: + menuMouse(); + break; + case MOUSE_drag: + dragMouse(); + break; + case MOUSE_system_menu: + systemMenuMouse(); + break; + case MOUSE_holding: + if (_pos.y < 400) { + _mouseMode = MOUSE_normal; + debug(5, " releasing"); + } + break; + default: + break; + } +} + +#if RIGHT_CLICK_CLEARS_LUGGAGE +bool Mouse::heldIsInInventory() { + int32 object_held = (int32)_vm->_logic->readVar(OBJECT_HELD); + + for (uint i = 0; i < _totalMasters; i++) { + if (_masterMenuList[i].icon_resource == object_held) + return true; + } + return false; +} +#endif + +int Mouse::menuClick(int menu_items) { + if (_pos.x < RDMENU_ICONSTART) + return -1; + + if (_pos.x > RDMENU_ICONSTART + menu_items * (RDMENU_ICONWIDE + RDMENU_ICONSPACING) - RDMENU_ICONSPACING) + return -1; + + return (_pos.x - RDMENU_ICONSTART) / (RDMENU_ICONWIDE + RDMENU_ICONSPACING); +} + +void Mouse::systemMenuMouse() { + uint32 safe_looping_music_id; + MouseEvent *me; + int hit; + byte *icon; + int32 pars[2]; + uint32 icon_list[5] = { + OPTIONS_ICON, + QUIT_ICON, + SAVE_ICON, + RESTORE_ICON, + RESTART_ICON + }; + + // If the mouse is moved off the menu, close it. Unless the player is + // dead, in which case the menu should always be visible. + + if (_pos.y > 0 && !_vm->_logic->readVar(DEAD)) { + _mouseMode = MOUSE_normal; + hideMenu(RDMENU_TOP); + return; + } + + // Check if the user left-clicks anywhere in the menu area. + + me = _vm->mouseEvent(); + + if (!me || !(me->buttons & RD_LEFTBUTTONDOWN)) + return; + + if (_pos.y > 0) + return; + + hit = menuClick(ARRAYSIZE(icon_list)); + + if (hit < 0) + return; + + // No save when dead + + if (icon_list[hit] == SAVE_ICON && _vm->_logic->readVar(DEAD)) + return; + + // Gray out all he icons, except the one that was clicked + + for (int i = 0; i < ARRAYSIZE(icon_list); i++) { + if (i != hit) { + icon = _vm->_resman->openResource(icon_list[i]) + ResHeader::size(); + setMenuIcon(RDMENU_TOP, i, icon); + _vm->_resman->closeResource(icon_list[i]); + } + } + + _vm->_sound->pauseFx(); + + // NB. Need to keep a safe copy of '_loopingMusicId' for savegame & for + // playing when returning from control panels because control panel + // music will overwrite it! + + safe_looping_music_id = _vm->_sound->getLoopingMusicId(); + + pars[0] = 221; + pars[1] = FX_LOOP; + _vm->_logic->fnPlayMusic(pars); + + // HACK: Restore proper looping_music_id + _vm->_sound->setLoopingMusicId(safe_looping_music_id); + + processMenu(); + + // call the relevant screen + + switch (hit) { + case 0: + { + OptionsDialog dialog(_vm); + dialog.runModal(); + } + break; + case 1: + { + QuitDialog dialog(_vm); + dialog.runModal(); + } + break; + case 2: + { + SaveDialog dialog(_vm); + dialog.runModal(); + } + break; + case 3: + { + RestoreDialog dialog(_vm); + dialog.runModal(); + } + break; + case 4: + { + RestartDialog dialog(_vm); + dialog.runModal(); + } + break; + } + + // Menu stays open on death screen. Otherwise it's closed. + + if (!_vm->_logic->readVar(DEAD)) { + _mouseMode = MOUSE_normal; + hideMenu(RDMENU_TOP); + } else { + setMouse(NORMAL_MOUSE_ID); + buildSystemMenu(); + } + + // Back to the game again + + processMenu(); + + // Reset game palette, but not after a successful restore or restart! + // See RestoreFromBuffer() in save_rest.cpp + + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + if (screenInfo->new_palette != 99) { + // 0 means put back game screen palette; see build_display.cpp + _vm->_screen->setFullPalette(0); + + // Stop the engine fading in the restored screens palette + screenInfo->new_palette = 0; + } else + screenInfo->new_palette = 1; + + _vm->_sound->unpauseFx(); + + // If there was looping music before coming into the control panels + // then restart it! NB. If a game has been restored the music will be + // restarted twice, but this shouldn't cause any harm. + + if (_vm->_sound->getLoopingMusicId()) { + pars[0] = _vm->_sound->getLoopingMusicId(); + pars[1] = FX_LOOP; + _vm->_logic->fnPlayMusic(pars); + } else + _vm->_logic->fnStopMusic(NULL); +} + +void Mouse::dragMouse() { + byte buf1[NAME_LEN], buf2[NAME_LEN]; + MouseEvent *me; + int hit; + + // We can use dragged object both on other inventory objects, or on + // objects in the scene, so if the mouse moves off the inventory menu, + // then close it. + + if (_pos.y < 400) { + _mouseMode = MOUSE_normal; + hideMenu(RDMENU_BOTTOM); + return; + } + + // Handles cursors and the luggage on/off according to type + + mouseOnOff(); + + // Now do the normal click stuff + + me = _vm->mouseEvent(); + + if (!me) + return; + +#if RIGHT_CLICK_CLEARS_LUGGAGE + if ((me->buttons & RD_RIGHTBUTTONDOWN) && heldIsInInventory()) { + _vm->_logic->writeVar(OBJECT_HELD, 0); + _menuSelectedPos = 0; + _mouseMode = MOUSE_menu; + setLuggage(0); + buildMenu(); + return; + } +#endif + + if (!(me->buttons & RD_LEFTBUTTONDOWN)) + return; + + // there's a mouse event to be processed + + // could be clicking on an on screen object or on the menu + // which is currently displayed + + if (_mouseTouching) { + // mouse is over an on screen object - and we have luggage + + // Depending on type we'll maybe kill the object_held - like + // for exits + + // Set global script variable 'button'. We know that it was the + // left button, not the right one. + + _vm->_logic->writeVar(LEFT_BUTTON, 1); + _vm->_logic->writeVar(RIGHT_BUTTON, 0); + + // These might be required by the action script about to be run + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + _vm->_logic->writeVar(MOUSE_X, _pos.x + screenInfo->scroll_offset_x); + _vm->_logic->writeVar(MOUSE_Y, _pos.y + screenInfo->scroll_offset_y); + + // For scripts to know what's been clicked. First used for + // 'room_13_turning_script' in object 'biscuits_13' + + _vm->_logic->writeVar(CLICKED_ID, _mouseTouching); + + _vm->_logic->setPlayerActionEvent(CUR_PLAYER_ID, _mouseTouching); + + debug(2, "Used \"%s\" on \"%s\"", + _vm->_resman->fetchName(_vm->_logic->readVar(OBJECT_HELD), buf1), + _vm->_resman->fetchName(_vm->_logic->readVar(CLICKED_ID), buf2)); + + // Hide menu - back to normal menu mode + + hideMenu(RDMENU_BOTTOM); + _mouseMode = MOUSE_normal; + + return; + } + + // Better check for combine/cancel. Cancel puts us back in MOUSE_menu + // mode + + hit = menuClick(TOTAL_engine_pockets); + + if (hit < 0 || !_masterMenuList[hit].icon_resource) + return; + + // Always back into menu mode. Remove the luggage as well. + + _mouseMode = MOUSE_menu; + setLuggage(0); + + if ((uint)hit == _menuSelectedPos) { + // If we clicked on the same icon again, reset the first icon + + _vm->_logic->writeVar(OBJECT_HELD, 0); + _menuSelectedPos = 0; + } else { + // Otherwise, combine the two icons + + _vm->_logic->writeVar(COMBINE_BASE, _masterMenuList[hit].icon_resource); + _vm->_logic->setPlayerActionEvent(CUR_PLAYER_ID, MENU_MASTER_OBJECT); + + // Turn off mouse now, to prevent player trying to click + // elsewhere BUT leave the bottom menu open + + hideMouse(); + + debug(2, "Used \"%s\" on \"%s\"", + _vm->_resman->fetchName(_vm->_logic->readVar(OBJECT_HELD), buf1), + _vm->_resman->fetchName(_vm->_logic->readVar(COMBINE_BASE), buf2)); + } + + // Refresh the menu + + buildMenu(); +} + +void Mouse::menuMouse() { + byte buf[NAME_LEN]; + MouseEvent *me; + int hit; + + // If the mouse is moved off the menu, close it. + + if (_pos.y < 400) { + _mouseMode = MOUSE_normal; + hideMenu(RDMENU_BOTTOM); + return; + } + + me = _vm->mouseEvent(); + + if (!me) + return; + + hit = menuClick(TOTAL_engine_pockets); + + // Check if we clicked on an actual icon. + + if (hit < 0 || !_masterMenuList[hit].icon_resource) + return; + + if (me->buttons & RD_RIGHTBUTTONDOWN) { + // Right button - examine an object, identified by its icon + // resource id. + + _examiningMenuIcon = true; + _vm->_logic->writeVar(OBJECT_HELD, _masterMenuList[hit].icon_resource); + + // Must clear this so next click on exit becomes 1st click + // again + + _vm->_logic->writeVar(EXIT_CLICK_ID, 0); + + _vm->_logic->setPlayerActionEvent(CUR_PLAYER_ID, MENU_MASTER_OBJECT); + + // Refresh the menu + + buildMenu(); + + // Turn off mouse now, to prevent player trying to click + // elsewhere BUT leave the bottom menu open + + hideMouse(); + + debug(2, "Right-click on \"%s\" icon", + _vm->_resman->fetchName(_vm->_logic->readVar(OBJECT_HELD), buf)); + + return; + } + + if (me->buttons & RD_LEFTBUTTONDOWN) { + // Left button - bung us into drag luggage mode. The object is + // identified by its icon resource id. We need the luggage + // resource id for mouseOnOff + + _mouseMode = MOUSE_drag; + + _menuSelectedPos = hit; + _vm->_logic->writeVar(OBJECT_HELD, _masterMenuList[hit].icon_resource); + _currentLuggageResource = _masterMenuList[hit].luggage_resource; + + // Must clear this so next click on exit becomes 1st click + // again + + _vm->_logic->writeVar(EXIT_CLICK_ID, 0); + + // Refresh the menu + + buildMenu(); + + setLuggage(_masterMenuList[hit].luggage_resource); + + debug(2, "Left-clicked on \"%s\" icon - switch to drag mode", + _vm->_resman->fetchName(_vm->_logic->readVar(OBJECT_HELD), buf)); + } +} + +void Mouse::normalMouse() { + // The gane is playing and none of the menus are activated - but, we + // need to check if a menu is to start. Note, won't have luggage + + MouseEvent *me; + + // Check if the cursor has moved onto the system menu area. No save in + // big-object menu lock situation, of if the player is dragging an + // object. + + if (_pos.y < 0 && !_mouseModeLocked && !_vm->_logic->readVar(OBJECT_HELD)) { + _mouseMode = MOUSE_system_menu; + + if (_mouseTouching) { + // We were on something, but not anymore + _oldMouseTouching = 0; + _mouseTouching = 0; + } + + // Reset mouse cursor - in case we're between mice + + setMouse(NORMAL_MOUSE_ID); + buildSystemMenu(); + return; + } + + // Check if the cursor has moved onto the inventory menu area. No + // inventory in big-object menu lock situation, + + if (_pos.y > 399 && !_mouseModeLocked) { + // If an object is being held, i.e. if the mouse cursor has a + // luggage, go to drag mode instead of menu mode, but the menu + // is still opened. + // + // That way, we can still use an object on another inventory + // object, even if the inventory menu was closed after the + // first object was selected. + + if (!_vm->_logic->readVar(OBJECT_HELD)) + _mouseMode = MOUSE_menu; + else + _mouseMode = MOUSE_drag; + + // If mouse is moving off an object and onto the menu then do a + // standard get-off + + if (_mouseTouching) { + _oldMouseTouching = 0; + _mouseTouching = 0; + } + + // Reset mouse cursor + + setMouse(NORMAL_MOUSE_ID); + buildMenu(); + return; + } + + // Check for moving the mouse on or off things + + mouseOnOff(); + + me = _vm->mouseEvent(); + + if (!me) + return; + + bool button_down = (me->buttons & (RD_LEFTBUTTONDOWN | RD_RIGHTBUTTONDOWN)) != 0; + + // For debugging. We can draw a rectangle on the screen and see its + // coordinates. This was probably used to help defining hit areas. + + if (_vm->_debugger->_definingRectangles) { + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + if (_vm->_debugger->_draggingRectangle == 0) { + // Not yet dragging a rectangle, so need click to start + + if (button_down) { + // set both (x1,y1) and (x2,y2) to this point + _vm->_debugger->_rectX1 = _vm->_debugger->_rectX2 = (uint32)_pos.x + screenInfo->scroll_offset_x; + _vm->_debugger->_rectY1 = _vm->_debugger->_rectY2 = (uint32)_pos.y + screenInfo->scroll_offset_y; + _vm->_debugger->_draggingRectangle = 1; + } + } else if (_vm->_debugger->_draggingRectangle == 1) { + // currently dragging a rectangle - click means reset + + if (button_down) { + // lock rectangle, so you can let go of mouse + // to type in the coords + _vm->_debugger->_draggingRectangle = 2; + } else { + // drag rectangle + _vm->_debugger->_rectX2 = (uint32)_pos.x + screenInfo->scroll_offset_x; + _vm->_debugger->_rectY2 = (uint32)_pos.y + screenInfo->scroll_offset_y; + } + } else { + // currently locked to avoid knocking out of place + // while reading off the coords + + if (button_down) { + // click means reset - back to start again + _vm->_debugger->_draggingRectangle = 0; + } + } + + return; + } + +#if RIGHT_CLICK_CLEARS_LUGGAGE + if (_vm->_logic->readVar(OBJECT_HELD) && (me->buttons & RD_RIGHTBUTTONDOWN) && heldIsInInventory()) { + _vm->_logic->writeVar(OBJECT_HELD, 0); + _menuSelectedPos = 0; + setLuggage(0); + return; + } +#endif + + // Now do the normal click stuff + + // We only care about down clicks when the mouse is over an object. + + if (!_mouseTouching || !button_down) + return; + + // There's a mouse event to be processed and the mouse is on something. + // Notice that the floor itself is considered an object. + + // There are no menus about so its nice and simple. This is as close to + // the old advisor_188 script as we get, I'm sorry to say. + + // If player is walking or relaxing then those need to terminate + // correctly. Otherwise set player run the targets action script or, do + // a special walk if clicking on the scroll-more icon + + // PLAYER_ACTION script variable - whatever catches this must reset to + // 0 again + // _vm->_logic->writeVar(PLAYER_ACTION, _mouseTouching); + + // Idle or router-anim will catch it + + // Set global script variable 'button' + + if (me->buttons & RD_LEFTBUTTONDOWN) { + _vm->_logic->writeVar(LEFT_BUTTON, 1); + _vm->_logic->writeVar(RIGHT_BUTTON, 0); + _buttonClick = 0; // for re-click + } else { + _vm->_logic->writeVar(LEFT_BUTTON, 0); + _vm->_logic->writeVar(RIGHT_BUTTON, 1); + _buttonClick = 1; // for re-click + } + + // These might be required by the action script about to be run + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + _vm->_logic->writeVar(MOUSE_X, _pos.x + screenInfo->scroll_offset_x); + _vm->_logic->writeVar(MOUSE_Y, _pos.y + screenInfo->scroll_offset_y); + + if (_mouseTouching == _vm->_logic->readVar(EXIT_CLICK_ID) && (me->buttons & RD_LEFTBUTTONDOWN)) { + // It's the exit double click situation. Let the existing + // interaction continue and start fading down. Switch the human + // off too + + noHuman(); + _vm->_logic->fnFadeDown(NULL); + + // Tell the walker + + _vm->_logic->writeVar(EXIT_FADING, 1); + } else if (_oldButton == _buttonClick && _mouseTouching == _vm->_logic->readVar(CLICKED_ID) && _mousePointerRes != NORMAL_MOUSE_ID) { + // Re-click. Do nothing, except on floors + } else { + // For re-click + + _oldButton = _buttonClick; + + // For scripts to know what's been clicked. First used for + // 'room_13_turning_script' in object 'biscuits_13' + + _vm->_logic->writeVar(CLICKED_ID, _mouseTouching); + + // Must clear these two double-click control flags - do it here + // so reclicks after exit clicks are cleared up + + _vm->_logic->writeVar(EXIT_CLICK_ID, 0); + _vm->_logic->writeVar(EXIT_FADING, 0); + + _vm->_logic->setPlayerActionEvent(CUR_PLAYER_ID, _mouseTouching); + + byte buf1[NAME_LEN], buf2[NAME_LEN]; + + if (_vm->_logic->readVar(OBJECT_HELD)) + debug(2, "Used \"%s\" on \"%s\"", + _vm->_resman->fetchName(_vm->_logic->readVar(OBJECT_HELD), buf1), + _vm->_resman->fetchName(_vm->_logic->readVar(CLICKED_ID), buf2)); + else if (_vm->_logic->readVar(LEFT_BUTTON)) + debug(2, "Left-clicked on \"%s\"", + _vm->_resman->fetchName(_vm->_logic->readVar(CLICKED_ID), buf1)); + else // RIGHT BUTTON + debug(2, "Right-clicked on \"%s\"", + _vm->_resman->fetchName(_vm->_logic->readVar(CLICKED_ID), buf1)); + } +} + +uint32 Mouse::chooseMouse() { + // Unlike the other mouse "engines", this one is called directly by the + // fnChoose() opcode. + + uint i; + + _vm->_logic->writeVar(AUTO_SELECTED, 0); + + uint32 in_subject = _vm->_logic->readVar(IN_SUBJECT); + uint32 object_held = _vm->_logic->readVar(OBJECT_HELD); + + if (object_held) { + // The player used an object on a person. In this case it + // triggered a conversation menu. Act as if the user tried to + // talk to the person about that object. If the person doesn't + // know anything about it, use the default response. + + uint32 response = _defaultResponseId; + + for (i = 0; i < in_subject; i++) { + if (_subjectList[i].res == object_held) { + response = _subjectList[i].ref; + break; + } + } + + // The user won't be holding the object any more, and the + // conversation menu will be closed. + + _vm->_logic->writeVar(OBJECT_HELD, 0); + _vm->_logic->writeVar(IN_SUBJECT, 0); + return response; + } + + if (_vm->_logic->readVar(CHOOSER_COUNT_FLAG) == 0 && in_subject == 1 && _subjectList[0].res == EXIT_ICON) { + // This is the first time the chooser is coming up in this + // conversation, there is only one subject and that's the + // EXIT icon. + // + // In other words, the player doesn't have anything to talk + // about. Skip it. + + // The conversation menu will be closed. We set AUTO_SELECTED + // because the speech script depends on it. + + _vm->_logic->writeVar(AUTO_SELECTED, 1); + _vm->_logic->writeVar(IN_SUBJECT, 0); + return _subjectList[0].ref; + } + + byte *icon; + + if (!_choosing) { + // This is a new conversation menu. + + if (!in_subject) + error("fnChoose with no subjects"); + + for (i = 0; i < in_subject; i++) { + icon = _vm->_resman->openResource(_subjectList[i].res) + ResHeader::size() + RDMENU_ICONWIDE * RDMENU_ICONDEEP; + setMenuIcon(RDMENU_BOTTOM, i, icon); + _vm->_resman->closeResource(_subjectList[i].res); + } + + for (; i < 15; i++) + setMenuIcon(RDMENU_BOTTOM, (uint8) i, NULL); + + showMenu(RDMENU_BOTTOM); + setMouse(NORMAL_MOUSE_ID); + _choosing = true; + return (uint32)-1; + } + + // The menu is there - we're just waiting for a click. We only care + // about left clicks. + + MouseEvent *me = _vm->mouseEvent(); + int mouseX, mouseY; + + getPos(mouseX, mouseY); + + if (!me || !(me->buttons & RD_LEFTBUTTONDOWN) || mouseY < 400) + return (uint32)-1; + + // Check for click on a menu. + + int hit = _vm->_mouse->menuClick(in_subject); + if (hit < 0) + return (uint32)-1; + + // Hilight the clicked icon by greying the others. This can look a bit + // odd when you click on the exit icon, but there are also cases when + // it looks strange if you don't do it. + + for (i = 0; i < in_subject; i++) { + if ((int)i != hit) { + icon = _vm->_resman->openResource(_subjectList[i].res) + ResHeader::size(); + _vm->_mouse->setMenuIcon(RDMENU_BOTTOM, i, icon); + _vm->_resman->closeResource(_subjectList[i].res); + } + } + + // For non-speech scripts that manually call the chooser + _vm->_logic->writeVar(RESULT, _subjectList[hit].res); + + // The conversation menu will be closed + + _choosing = false; + _vm->_logic->writeVar(IN_SUBJECT, 0); + setMouse(0); + + return _subjectList[hit].ref; +} + +void Mouse::mouseOnOff() { + // this handles the cursor graphic when moving on and off mouse areas + // it also handles the luggage thingy + + uint32 pointer_type; + static uint8 mouse_flicked_off = 0; + + _oldMouseTouching = _mouseTouching; + + // don't detect objects that are hidden behind the menu bars (ie. in + // the scrolled-off areas of the screen) + + if (_pos.y < 0 || _pos.y > 399) { + pointer_type = 0; + _mouseTouching = 0; + } else { + // set '_mouseTouching' & return pointer_type + pointer_type = checkMouseList(); + } + + // same as previous cycle? + if (!mouse_flicked_off && _oldMouseTouching == _mouseTouching) { + // yes, so nothing to do + // BUT CARRY ON IF MOUSE WAS FLICKED OFF! + return; + } + + // can reset this now + mouse_flicked_off = 0; + + //the cursor has moved onto something + if (!_oldMouseTouching && _mouseTouching) { + // make a copy of the object we've moved onto because one day + // we'll move back off again! (but the list positioning could + // theoretically have changed) + + // we can only move onto something from being on nothing - we + // stop the system going from one to another when objects + // overlap + + _oldMouseTouching = _mouseTouching; + + // run get on + + if (pointer_type) { + // 'pointer_type' holds the resource id of the + // pointer anim + + setMouse(pointer_type); + + // setup luggage icon + if (_vm->_logic->readVar(OBJECT_HELD)) { + setLuggage(_currentLuggageResource); + } + } else { + byte buf[NAME_LEN]; + + error("ERROR: mouse.pointer==0 for object %d (%s) - update logic script!", _mouseTouching, _vm->_resman->fetchName(_mouseTouching, buf)); + } + } else if (_oldMouseTouching && !_mouseTouching) { + // the cursor has moved off something - reset cursor to + // normal pointer + + _oldMouseTouching = 0; + setMouse(NORMAL_MOUSE_ID); + + // reset luggage only when necessary + } else if (_oldMouseTouching && _mouseTouching) { + // The cursor has moved off something and onto something + // else. Flip to a blank cursor for a cycle. + + // ignore the new id this cycle - should hit next cycle + _mouseTouching = 0; + _oldMouseTouching = 0; + setMouse(0); + + // so we know to set the mouse pointer back to normal if 2nd + // hot-spot doesn't register because mouse pulled away + // quickly (onto nothing) + + mouse_flicked_off = 1; + + // reset luggage only when necessary + } else { + // Mouse was flicked off for one cycle, but then moved onto + // nothing before 2nd hot-spot registered + + // both '_oldMouseTouching' & '_mouseTouching' will be zero + // reset cursor to normal pointer + + setMouse(NORMAL_MOUSE_ID); + } + + // possible check for edge of screen more-to-scroll here on large + // screens +} + +void Mouse::setMouse(uint32 res) { + // high level - whats the mouse - for the engine + _mousePointerRes = res; + + if (res) { + byte *icon = _vm->_resman->openResource(res) + ResHeader::size(); + uint32 len = _vm->_resman->fetchLen(res) - ResHeader::size(); + + // don't pulse the normal pointer - just do the regular anim + // loop + + if (res == NORMAL_MOUSE_ID) + setMouseAnim(icon, len, RDMOUSE_NOFLASH); + else + setMouseAnim(icon, len, RDMOUSE_FLASH); + + _vm->_resman->closeResource(res); + } else { + // blank cursor + setMouseAnim(NULL, 0, 0); + } +} + +void Mouse::setLuggage(uint32 res) { + _realLuggageItem = res; + + if (res) { + byte *icon = _vm->_resman->openResource(res) + ResHeader::size(); + uint32 len = _vm->_resman->fetchLen(res) - ResHeader::size(); + + setLuggageAnim(icon, len); + _vm->_resman->closeResource(res); + } else + setLuggageAnim(NULL, 0); +} + +void Mouse::setObjectHeld(uint32 res) { + setLuggage(res); + + _vm->_logic->writeVar(OBJECT_HELD, res); + _currentLuggageResource = res; + + // mode locked - no menu available + _mouseModeLocked = true; +} + +uint32 Mouse::checkMouseList() { + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + Common::Point mousePos(_pos.x + screenInfo->scroll_offset_x, _pos.y + screenInfo->scroll_offset_y); + + // Number of priorities subject to implementation needs + for (int priority = 0; priority < 10; priority++) { + for (uint i = 0; i < _curMouse; i++) { + // If the mouse pointer is over this + // mouse-detection-box + + if (_mouseList[i].priority == priority && _mouseList[i].rect.contains(mousePos)) { + // Record id + _mouseTouching = _mouseList[i].id; + + createPointerText(_mouseList[i].pointer_text, _mouseList[i].pointer); + + // Return pointer type + return _mouseList[i].pointer; + } + } + } + + // Touching nothing; no pointer to return + _mouseTouching = 0; + return 0; +} + +#define POINTER_TEXT_WIDTH 640 // just in case! +#define POINTER_TEXT_PEN 184 // white + +void Mouse::createPointerText(uint32 text_id, uint32 pointer_res) { + uint32 local_text; + uint32 text_res; + byte *text; + // offsets for pointer text sprite from pointer position + int16 xOffset, yOffset; + uint8 justification; + + if (!_objectLabels || !text_id) + return; + + // Check what the pointer is, to set offsets correctly for text + // position + + switch (pointer_res) { + case CROSHAIR: + yOffset = -7; + xOffset = +10; + break; + case EXIT0: + yOffset = +15; + xOffset = +20; + break; + case EXIT1: + yOffset = +16; + xOffset = -10; + break; + case EXIT2: + yOffset = +10; + xOffset = -22; + break; + case EXIT3: + yOffset = -16; + xOffset = -10; + break; + case EXIT4: + yOffset = -15; + xOffset = +15; + break; + case EXIT5: + yOffset = -12; + xOffset = +10; + break; + case EXIT6: + yOffset = +10; + xOffset = +25; + break; + case EXIT7: + yOffset = +16; + xOffset = +20; + break; + case EXITDOWN: + yOffset = -20; + xOffset = -10; + break; + case EXITUP: + yOffset = +20; + xOffset = +20; + break; + case MOUTH: + yOffset = -10; + xOffset = +15; + break; + case NORMAL: + yOffset = -10; + xOffset = +15; + break; + case PICKUP: + yOffset = -40; + xOffset = +10; + break; + case SCROLL_L: + yOffset = -20; + xOffset = +20; + break; + case SCROLL_R: + yOffset = -20; + xOffset = -20; + break; + case USE: + yOffset = -8; + xOffset = +20; + break; + default: + // Shouldn't happen if we cover all the different mouse + // pointers above + yOffset = -10; + xOffset = +10; + break; + } + + // Set up justification for text sprite, based on its offsets from the + // pointer position + + if (yOffset < 0) { + // Above pointer + if (xOffset < 0) { + // Above left + justification = POSITION_AT_RIGHT_OF_BASE; + } else if (xOffset > 0) { + // Above right + justification = POSITION_AT_LEFT_OF_BASE; + } else { + // Above centre + justification = POSITION_AT_CENTRE_OF_BASE; + } + } else if (yOffset > 0) { + // Below pointer + if (xOffset < 0) { + // Below left + justification = POSITION_AT_RIGHT_OF_TOP; + } else if (xOffset > 0) { + // Below right + justification = POSITION_AT_LEFT_OF_TOP; + } else { + // Below centre + justification = POSITION_AT_CENTRE_OF_TOP; + } + } else { + // Same y-coord as pointer + if (xOffset < 0) { + // Centre left + justification = POSITION_AT_RIGHT_OF_CENTRE; + } else if (xOffset > 0) { + // Centre right + justification = POSITION_AT_LEFT_OF_CENTRE; + } else { + // Centre centre - shouldn't happen anyway! + justification = POSITION_AT_LEFT_OF_CENTRE; + } + } + + // Text resource number, and line number within the resource + + text_res = text_id / SIZE; + local_text = text_id & 0xffff; + + // open text file & get the line + text = _vm->fetchTextLine(_vm->_resman->openResource(text_res), local_text); + + // 'text+2' to skip the first 2 bytes which form the + // line reference number + + _pointerTextBlocNo = _vm->_fontRenderer->buildNewBloc( + text + 2, _pos.x + xOffset, + _pos.y + yOffset, + POINTER_TEXT_WIDTH, POINTER_TEXT_PEN, + RDSPR_TRANS | RDSPR_DISPLAYALIGN, + _vm->_speechFontId, justification); + + // now ok to close the text file + _vm->_resman->closeResource(text_res); +} + +void Mouse::clearPointerText() { + if (_pointerTextBlocNo) { + _vm->_fontRenderer->killTextBloc(_pointerTextBlocNo); + _pointerTextBlocNo = 0; + } +} + +void Mouse::hideMouse() { + // leaves the menus open + // used by the system when clicking right on a menu item to examine + // it and when combining objects + + // for logic scripts + _vm->_logic->writeVar(MOUSE_AVAILABLE, 0); + + // human/mouse off + _mouseStatus = true; + + setMouse(0); + setLuggage(0); +} + +void Mouse::noHuman() { + hideMouse(); + clearPointerText(); + + // Must be normal mouse situation or a largely neutral situation - + // special menus use hideMouse() + + // Don't hide menu in conversations + if (_vm->_logic->readVar(TALK_FLAG) == 0) + hideMenu(RDMENU_BOTTOM); + + if (_mouseMode == MOUSE_system_menu) { + // Close menu + _mouseMode = MOUSE_normal; + hideMenu(RDMENU_TOP); + } +} + +void Mouse::addHuman() { + // For logic scripts + _vm->_logic->writeVar(MOUSE_AVAILABLE, 1); + + if (_mouseStatus) { + // Force engine to choose a cursor + _mouseStatus = false; + _mouseTouching = 1; + } + + // Clear this to reset no-second-click system + _vm->_logic->writeVar(CLICKED_ID, 0); + + // This is now done outside the OBJECT_HELD check in case it's set to + // zero before now! + + // Unlock the mouse from possible large object lock situtations - see + // syphon in rm 3 + + _mouseModeLocked = false; + + if (_vm->_logic->readVar(OBJECT_HELD)) { + // Was dragging something around - need to clear this again + _vm->_logic->writeVar(OBJECT_HELD, 0); + + // And these may also need clearing, just in case + _examiningMenuIcon = false; + _vm->_logic->writeVar(COMBINE_BASE, 0); + + setLuggage(0); + } + + // If mouse is over menu area + if (_pos.y > 399) { + if (_mouseMode != MOUSE_holding) { + // VITAL - reset things & rebuild the menu + _mouseMode = MOUSE_normal; + } + setMouse(NORMAL_MOUSE_ID); + } + + // Enabled/disabled from console; status printed with on-screen debug + // info + + if (_vm->_debugger->_testingSnR) { + uint8 black[4] = { 0, 0, 0, 0 }; + uint8 white[4] = { 255, 255, 255, 0 }; + + // Testing logic scripts by simulating instant Save & Restore + + _vm->_screen->setPalette(0, 1, white, RDPAL_INSTANT); + + // Stops all fx & clears the queue - eg. when leaving a room + _vm->_sound->clearFxQueue(); + + // Trash all object resources so they load in fresh & restart + // their logic scripts + + _vm->_resman->killAllObjects(false); + + _vm->_screen->setPalette(0, 1, black, RDPAL_INSTANT); + } +} + +void Mouse::refreshInventory() { + // Can reset this now + _vm->_logic->writeVar(COMBINE_BASE, 0); + + // Cause 'object_held' icon to be greyed. The rest are coloured. + _examiningMenuIcon = true; + buildMenu(); + _examiningMenuIcon = false; +} + +void Mouse::startConversation() { + if (_vm->_logic->readVar(TALK_FLAG) == 0) { + // See fnChooser & speech scripts + _vm->_logic->writeVar(CHOOSER_COUNT_FLAG, 0); + } + + noHuman(); +} + +void Mouse::endConversation() { + hideMenu(RDMENU_BOTTOM); + + if (_pos.y > 399) { + // Will wait for cursor to move off the bottom menu + _mouseMode = MOUSE_holding; + } + + // In case DC forgets + _vm->_logic->writeVar(TALK_FLAG, 0); +} + +void Mouse::monitorPlayerActivity() { + // if there is at least one mouse event outstanding + if (_vm->checkForMouseEvents()) { + // reset activity delay counter + _playerActivityDelay = 0; + } else { + // no. of game cycles since mouse event queue last empty + _playerActivityDelay++; + } +} + +void Mouse::checkPlayerActivity(uint32 seconds) { + // Convert seconds to game cycles + uint32 threshold = seconds * 12; + + // If the actual delay is at or above the given threshold, reset the + // activity delay counter now that we've got a positive check. + + if (_playerActivityDelay >= threshold) { + _playerActivityDelay = 0; + _vm->_logic->writeVar(RESULT, 1); + } else + _vm->_logic->writeVar(RESULT, 0); +} + +void Mouse::pauseGame() { + // Make the mouse cursor normal. This is the only place where we are + // allowed to clear the luggage this way. + + clearPointerText(); + setLuggageAnim(NULL, 0); + setMouse(0); + setMouseTouching(1); +} + +void Mouse::unpauseGame() { + if (_vm->_logic->readVar(OBJECT_HELD) && _realLuggageItem) + setLuggage(_realLuggageItem); +} + +} // End of namespace Sword2 diff --git a/engines/sword2/mouse.h b/engines/sword2/mouse.h new file mode 100644 index 0000000000..bed5e032ba --- /dev/null +++ b/engines/sword2/mouse.h @@ -0,0 +1,257 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef MOUSE_H +#define MOUSE_H + +#define MAX_SUBJECT_LIST 30 // is that enough? + +#define TOTAL_mouse_list 50 + +namespace Sword2 { + +struct BuildUnit; + +// Menubar defines. + +#define RDMENU_TOP 0 +#define RDMENU_BOTTOM 1 + +enum { + MOUSE_normal = 0, // normal in game + MOUSE_menu = 1, // menu chooser + MOUSE_drag = 2, // dragging luggage + MOUSE_system_menu = 3, // system menu chooser + MOUSE_holding = 4 // special +}; + +enum { + RDMOUSE_NOFLASH, + RDMOUSE_FLASH +}; + +enum { + RDMENU_HIDDEN, + RDMENU_SHOWN, + RDMENU_OPENING, + RDMENU_CLOSING, + RDMENU_ALMOST_HIDDEN +}; + +#define RDMENU_ICONWIDE 35 +#define RDMENU_ICONDEEP 30 +#define RDMENU_ICONSTART 24 +#define RDMENU_ICONSPACING 5 +#define RDMENU_MAXPOCKETS 15 + +#define MOUSE_ANIM_HEADER_SIZE 6 + +struct MouseAnim { + uint8 runTimeComp; // type of runtime compression used for the + // frame data + uint8 noAnimFrames; // number of frames in the anim + int8 xHotSpot; + int8 yHotSpot; + uint8 mousew; + uint8 mouseh; + + byte *data; +}; + +// The MOUSE_holding mode is entered when the conversation menu is closed, and +// exited when the mouse cursor moves off that menu area. I don't know why yet. + +// mouse unit - like ObjectMouse, but with anim resource & pc (needed if +// sprite is to act as mouse detection mask) + +struct MouseUnit { + // Basically the same information as in ObjectMouse, except the + // coordinates are adjusted to conform to standard ScummVM usage. + + Common::Rect rect; + int32 priority; + int32 pointer; + + // In addition, we need an id when checking the mouse list, and a + // text id for mouse-overs. + + int32 id; + int32 pointer_text; +}; + +// Array of these for subject menu build up + + struct SubjectUnit { + uint32 res; + uint32 ref; +}; + +class Mouse { +private: + Sword2Engine *_vm; + + Common::Point _pos; + + MouseUnit _mouseList[TOTAL_mouse_list]; + uint32 _curMouse; + + MenuObject _tempList[TOTAL_engine_pockets]; + uint32 _totalTemp; + + MenuObject _masterMenuList[TOTAL_engine_pockets]; + uint32 _totalMasters; + + SubjectUnit _subjectList[MAX_SUBJECT_LIST]; + + // ref number for default response when luggage icon is used on a + // person & it doesn't match any of the icons which would have been in + // the chooser + + uint32 _defaultResponseId; + + // could alternately use logic->looping of course + bool _choosing; + + uint8 _menuStatus[2]; + byte *_icons[2][RDMENU_MAXPOCKETS]; + uint8 _pocketStatus[2][RDMENU_MAXPOCKETS]; + + uint8 _iconCount; + + // If it's NORMAL_MOUSE_ID (ie. normal pointer) then it's over a floor + // area (or hidden hot-zone) + + uint32 _mousePointerRes; + + MouseAnim _mouseAnim; + MouseAnim _luggageAnim; + + uint8 _mouseFrame; + + uint32 _mouseMode; + + bool _mouseStatus; // Human 0 on/1 off + bool _mouseModeLocked; // 0 not !0 mode cannot be changed from + // normal mouse to top menu (i.e. when + // carrying big objects) + uint32 _realLuggageItem; // Last minute for pause mode + uint32 _currentLuggageResource; + uint32 _oldButton; // For the re-click stuff - must be + // the same button you see + uint32 _buttonClick; + uint32 _pointerTextBlocNo; + uint32 _playerActivityDelay; // Player activity delay counter + + bool _examiningMenuIcon; + + // Set by checkMouseList() + uint32 _mouseTouching; + uint32 _oldMouseTouching; + + bool _objectLabels; + + uint32 _menuSelectedPos; + + void decompressMouse(byte *decomp, byte *comp, uint8 frame, int width, int height, int pitch, int xOff = 0, int yOff = 0); + + int32 setMouseAnim(byte *ma, int32 size, int32 mouseFlash); + int32 setLuggageAnim(byte *la, int32 size); + + void clearIconArea(int menu, int pocket, Common::Rect *r); + +public: + Mouse(Sword2Engine *vm); + ~Mouse(); + + void getPos(int &x, int &y); + void setPos(int x, int y); + + bool getObjectLabels() { return _objectLabels; } + void setObjectLabels(bool b) { _objectLabels = b; } + + bool getMouseStatus() { return _mouseStatus; } + uint32 getMouseTouching() { return _mouseTouching; } + void setMouseTouching(uint32 touching) { _mouseTouching = touching; } + + void pauseGame(); + void unpauseGame(); + + void setMouse(uint32 res); + void setLuggage(uint32 res); + + void setObjectHeld(uint32 res); + + void resetMouseList(); + + void registerMouse(byte *ob_mouse, BuildUnit *build_unit); + void registerPointerText(int32 text_id); + + void createPointerText(uint32 text_id, uint32 pointer_res); + void clearPointerText(); + + void drawMouse(); + int32 animateMouse(); + + void processMenu(); + + void addMenuObject(byte *ptr); + void addSubject(int32 id, int32 ref); + + void buildMenu(); + void buildSystemMenu(); + + int32 showMenu(uint8 menu); + int32 hideMenu(uint8 menu); + int32 setMenuIcon(uint8 menu, uint8 pocket, byte *icon); + + void closeMenuImmediately(); + + void refreshInventory(); + + void startConversation(); + void endConversation(); + + void hideMouse(); + void noHuman(); + void addHuman(); + + void resetPlayerActivityDelay() { _playerActivityDelay = 0; } + void monitorPlayerActivity(); + void checkPlayerActivity(uint32 seconds); + + void mouseOnOff(); + uint32 checkMouseList(); + void mouseEngine(); + + void normalMouse(); + void menuMouse(); + void dragMouse(); + void systemMenuMouse(); + + bool isChoosing() { return _choosing; } + uint32 chooseMouse(); + + int menuClick(int menu_items); +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/music.cpp b/engines/sword2/music.cpp new file mode 100644 index 0000000000..847f4808cf --- /dev/null +++ b/engines/sword2/music.cpp @@ -0,0 +1,856 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +// One feature still missing is the original's DipMusic() function which, as +// far as I can understand, softened the music volume when someone was +// speaking, but only (?) if the music was playing loudly at the time. +// +// All things considered, I think this is more bother than it's worth. + +#include "common/stdafx.h" +#include "common/file.h" +#include "common/system.h" +#include "sound/mp3.h" +#include "sound/vorbis.h" +#include "sound/flac.h" +#include "sound/rate.h" +#include "sound/wave.h" + +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/resman.h" +#include "sword2/sound.h" + +namespace Sword2 { + +static AudioStream *makeCLUStream(Common::File *fp, int size); + +static AudioStream *getAudioStream(SoundFileHandle *fh, const char *base, int cd, uint32 id, uint32 *numSamples) { + debug(3, "Playing %s from CD %d", base, cd); + + if (!fh->file.isOpen()) { + struct { + const char *ext; + int mode; + } file_types[] = { + #ifdef USE_MAD + { "cl3", kMP3Mode }, + #endif + #ifdef USE_VORBIS + { "clg", kVorbisMode }, + #endif + #ifdef USE_FLAC + { "clf", kFlacMode }, + #endif + { "clu", kCLUMode } + }; + + int soundMode = 0; + char filename[20]; + + for (int i = 0; i < ARRAYSIZE(file_types); i++) { + Common::File f; + + sprintf(filename, "%s%d.%s", base, cd, file_types[i].ext); + if (f.open(filename)) { + soundMode = file_types[i].mode; + break; + } + + sprintf(filename, "%s.%s", base, file_types[i].ext); + if (f.open(filename)) { + soundMode = file_types[i].mode; + break; + } + } + + if (soundMode == 0) + return NULL; + + fh->file.open(filename); + fh->fileType = soundMode; + if (!fh->file.isOpen()) { + warning("Very strange fopen error"); + return NULL; + } + if (fh->fileSize != fh->file.size()) { + if (fh->idxTab) { + free(fh->idxTab); + fh->idxTab = NULL; + } + } + } + + uint32 entrySize = (fh->fileType == kCLUMode) ? 2 : 3; + + if (!fh->idxTab) { + fh->file.seek(0); + fh->idxLen = fh->file.readUint32LE(); + fh->file.seek(entrySize * 4); + + fh->idxTab = (uint32*)malloc(fh->idxLen * 3 * sizeof(uint32)); + for (uint32 cnt = 0; cnt < fh->idxLen; cnt++) { + fh->idxTab[cnt * 3 + 0] = fh->file.readUint32LE(); + fh->idxTab[cnt * 3 + 1] = fh->file.readUint32LE(); + if (fh->fileType == kCLUMode) { + fh->idxTab[cnt * 3 + 2] = fh->idxTab[cnt * 3 + 1]; + fh->idxTab[cnt * 3 + 1]--; + } else + fh->idxTab[cnt * 3 + 2] = fh->file.readUint32LE(); + } + } + + uint32 pos = fh->idxTab[id * 3 + 0]; + uint32 len = fh->idxTab[id * 3 + 1]; + uint32 enc_len = fh->idxTab[id * 3 + 2]; + + if (numSamples) + *numSamples = len; + + if (!pos || !len) { + fh->file.close(); + return NULL; + } + + fh->file.seek(pos, SEEK_SET); + + switch (fh->fileType) { + case kCLUMode: + return makeCLUStream(&fh->file, enc_len); +#ifdef USE_MAD + case kMP3Mode: + return makeMP3Stream(&fh->file, enc_len); +#endif +#ifdef USE_VORBIS + case kVorbisMode: + return makeVorbisStream(&fh->file, enc_len); +#endif +#ifdef USE_FLAC + case kFlacMode: + return makeFlacStream(&fh->file, enc_len); +#endif + default: + return NULL; + } +} + +// ---------------------------------------------------------------------------- +// Custom AudioStream class to handle Broken Sword 2's audio compression. +// ---------------------------------------------------------------------------- + +#define GetCompressedShift(n) ((n) >> 4) +#define GetCompressedSign(n) (((n) >> 3) & 1) +#define GetCompressedAmplitude(n) ((n) & 7) + +CLUInputStream::CLUInputStream(Common::File *file, int size) + : _file(file), _firstTime(true), _bufferEnd(_outbuf + BUFFER_SIZE) { + + _file->incRef(); + + // Determine the end position. + _file_pos = _file->pos(); + _end_pos = _file_pos + size; + + // Read in initial data + refill(); +} + +CLUInputStream::~CLUInputStream() { + _file->decRef(); +} + +int CLUInputStream::readBuffer(int16 *buffer, const int numSamples) { + int samples = 0; + while (samples < numSamples && !eosIntern()) { + const int len = MIN(numSamples - samples, (int)(_bufferEnd - _pos)); + memcpy(buffer, _pos, len * 2); + buffer += len; + _pos += len; + samples += len; + if (_pos >= _bufferEnd) { + refill(); + } + } + return samples; +} + +void CLUInputStream::refill() { + byte *in = _inbuf; + int16 *out = _outbuf; + + _file->seek(_file_pos, SEEK_SET); + + uint len_left = _file->read(in, MIN((uint32)BUFFER_SIZE, _end_pos - _file->pos())); + + _file_pos = _file->pos(); + + while (len_left > 0) { + uint16 sample; + + if (_firstTime) { + _firstTime = false; + _prev = READ_LE_UINT16(in); + sample = _prev; + len_left -= 2; + in += 2; + } else { + uint16 delta = GetCompressedAmplitude(*in) << GetCompressedShift(*in); + if (GetCompressedSign(*in)) + sample = _prev - delta; + else + sample = _prev + delta; + + _prev = sample; + len_left--; + in++; + } + + *out++ = sample; + } + + _pos = _outbuf; + _bufferEnd = out; +} + +AudioStream *makeCLUStream(Common::File *file, int size) { + return new CLUInputStream(file, size); +} + +// ---------------------------------------------------------------------------- +// Another custom AudioStream class, to wrap around the various AudioStream +// classes used for music decompression, and to add looping, fading, etc. +// ---------------------------------------------------------------------------- + +// The length of a fade-in/out, in milliseconds. +#define FADE_LENGTH 3000 + +MusicInputStream::MusicInputStream(int cd, SoundFileHandle *fh, uint32 musicId, bool looping) { + _cd = cd; + _fh = fh; + _musicId = musicId; + _looping = looping; + + _bufferEnd = _buffer + BUFFER_SIZE; + _remove = false; + _fading = 0; + + _decoder = getAudioStream(_fh, "music", _cd, _musicId, &_numSamples); + if (_decoder) { + _samplesLeft = _numSamples; + _fadeSamples = (getRate() * FADE_LENGTH) / 1000; + fadeUp(); + + // Read in initial data + refill(); + } +} + +MusicInputStream::~MusicInputStream() { + delete _decoder; +} + +int MusicInputStream::readBuffer(int16 *buffer, const int numSamples) { + if (!_decoder) + return 0; + + int samples = 0; + while (samples < numSamples && !eosIntern()) { + const int len = MIN(numSamples - samples, (int)(_bufferEnd - _pos)); + memcpy(buffer, _pos, len * 2); + buffer += len; + _pos += len; + samples += len; + if (_pos >= _bufferEnd) { + refill(); + } + } + return samples; +} + +void MusicInputStream::refill() { + int16 *buf = _buffer; + uint32 numSamples = 0; + uint32 len_left; + bool endFade = false; + + len_left = BUFFER_SIZE; + + if (_fading > 0 && (uint32)_fading < len_left) + len_left = _fading; + + if (_samplesLeft < len_left) + len_left = _samplesLeft; + + if (!_looping) { + // Non-looping music is faded out at the end. If this fade + // out would have started somewhere within the len_left samples + // to read, we only read up to that point. This way, we can + // treat this fade as any other. + + if (!_fading) { + uint32 currentlyAt = _numSamples - _samplesLeft; + uint32 fadeOutAt = _numSamples - _fadeSamples; + uint32 readTo = currentlyAt + len_left; + + if (fadeOutAt == currentlyAt) + fadeDown(); + else if (fadeOutAt > currentlyAt && fadeOutAt <= readTo) { + len_left = fadeOutAt - currentlyAt; + endFade = true; + } + } + } + + int desired = len_left - numSamples; + int len = _decoder->readBuffer(buf, desired); + + // Shouldn't happen, but if it does it could cause an infinite loop. + // Of course there were bugs that caused it to happen several times + // during development. :-) + + if (len < desired) { + warning("Expected %d samples, but got %d", desired, len); + _samplesLeft = len; + } + + buf += len; + numSamples += len; + len_left -= len; + _samplesLeft -= len; + + int16 *ptr; + + if (_fading > 0) { + // Fade down + for (ptr = _buffer; ptr < buf; ptr++) { + if (_fading > 0) { + _fading--; + *ptr = (*ptr * _fading) / _fadeSamples; + } + if (_fading == 0) { + _looping = false; + _remove = true; + *ptr = 0; + } + } + } else if (_fading < 0) { + // Fade up + for (ptr = _buffer; ptr < buf; ptr++) { + _fading--; + *ptr = -(*ptr * _fading) / _fadeSamples; + if (_fading <= -_fadeSamples) { + _fading = 0; + break; + } + } + } + + if (endFade) + fadeDown(); + + if (!_samplesLeft) { + if (_looping) { + delete _decoder; + _decoder = getAudioStream(_fh, "music", _cd, _musicId, &_numSamples); + _samplesLeft = _numSamples; + } else + _remove = true; + } + + _pos = _buffer; + _bufferEnd = buf; +} + +void MusicInputStream::fadeUp() { + if (_fading > 0) + _fading = -_fading; + else if (_fading == 0) + _fading = -1; +} + +void MusicInputStream::fadeDown() { + if (_fading < 0) + _fading = -_fading; + else if (_fading == 0) + _fading = _fadeSamples; +} + +bool MusicInputStream::readyToRemove() { + return _remove; +} + +int32 MusicInputStream::getTimeRemaining() { + // This is far from exact, but it doesn't have to be. + return (_samplesLeft + BUFFER_SIZE) / getRate(); +} + +// ---------------------------------------------------------------------------- +// Main sound class +// ---------------------------------------------------------------------------- + +// AudioStream API + +int Sound::readBuffer(int16 *buffer, const int numSamples) { + Common::StackLock lock(_mutex); + int i; + + if (_musicPaused) + return 0; + + for (i = 0; i < MAXMUS; i++) { + if (_music[i] && _music[i]->readyToRemove()) { + delete _music[i]; + _music[i] = NULL; + } + } + + memset(buffer, 0, 2 * numSamples); + + if (!_mixBuffer || numSamples > _mixBufferLen) { + if (_mixBuffer) + _mixBuffer = (int16 *)realloc(_mixBuffer, 2 * numSamples); + else + _mixBuffer = (int16 *)malloc(2 * numSamples); + + _mixBufferLen = numSamples; + } + + if (!_mixBuffer) + return 0; + + for (i = 0; i < MAXMUS; i++) { + if (!_music[i]) + continue; + + int len = _music[i]->readBuffer(_mixBuffer, numSamples); + + if (!_musicMuted) { + for (int j = 0; j < len; j++) { + Audio::clampedAdd(buffer[j], _mixBuffer[j]); + } + } + } + + bool inUse[MAXMUS]; + + for (i = 0; i < MAXMUS; i++) + inUse[i] = false; + + for (i = 0; i < MAXMUS; i++) { + if (_music[i]) { + if (_music[i]->getCD() == 1) + inUse[0] = true; + else + inUse[1] = true; + } + } + + for (i = 0; i < MAXMUS; i++) { + if (!inUse[i] && !_musicFile[i].inUse && _musicFile[i].file.isOpen()) + _musicFile[i].file.close(); + } + + return numSamples; +} + +bool Sound::endOfData() const { + for (int i = 0; i < MAXMUS; i++) { + if (_musicFile[i].file.isOpen()) + return false; + } + + return true; +} + +// ---------------------------------------------------------------------------- +// MUSIC +// ---------------------------------------------------------------------------- + +/** + * Stops the music dead in its tracks. Any music that is currently being + * streamed is paused. + */ + +void Sound::pauseMusic() { + Common::StackLock lock(_mutex); + + _musicPaused = true; +} + +/** + * Restarts the music from where it was stopped. + */ + +void Sound::unpauseMusic() { + Common::StackLock lock(_mutex); + + _musicPaused = false; +} + +/** + * Fades out and stops the music. + */ + +void Sound::stopMusic(bool immediately) { + Common::StackLock lock(_mutex); + + _loopingMusicId = 0; + + for (int i = 0; i < MAXMUS; i++) { + if (_music[i]) { + if (immediately) { + delete _music[i]; + _music[i] = NULL; + } else + _music[i]->fadeDown(); + } + } +} + +/** + * Streams music from a cluster file. + * @param musicId the id of the music to stream + * @param loop true if the music is to loop back to the start + * @return RD_OK or an error code + */ +int32 Sound::streamCompMusic(uint32 musicId, bool loop) { + //Common::StackLock lock(_mutex); + + _mutex.lock(); + int cd = _vm->_resman->getCD(); + + if (loop) + _loopingMusicId = musicId; + else + _loopingMusicId = 0; + + int primary = -1; + int secondary = -1; + + // If both music streams are active, one of them will have to go. + + if (_music[0] && _music[1]) { + int32 fade0 = _music[0]->isFading(); + int32 fade1 = _music[1]->isFading(); + + if (!fade0 && !fade1) { + // Neither is fading. This shouldn't happen, so just + // pick one and be done with it. + primary = 0; + } else if (fade0 && !fade1) { + // Stream 0 is fading, so pick that one. + primary = 0; + } else if (!fade0 && fade1) { + // Stream 1 is fading, so pick that one. + primary = 1; + } else { + // Both streams are fading. Pick the one that is + // closest to silent. + if (ABS(fade0) < ABS(fade1)) + primary = 0; + else + primary = 1; + } + + delete _music[primary]; + _music[primary] = NULL; + } + + // Pick the available music stream. If no music is playing it doesn't + // matter which we use. + + if (_music[0] || _music[1]) { + if (_music[0]) { + primary = 1; + secondary = 0; + } else { + primary = 0; + secondary = 1; + } + } else + primary = 0; + + // Don't start streaming if the volume is off. + if (isMusicMute()) { + _mutex.unlock(); + return RD_OK; + } + + if (secondary != -1) + _music[secondary]->fadeDown(); + SoundFileHandle *fh = (cd == 1) ? &_musicFile[0] : &_musicFile[1]; + fh->inUse = true; + _mutex.unlock(); + + MusicInputStream *tmp = new MusicInputStream(cd, fh, musicId, loop); + + if (tmp->isReady()) { + _mutex.lock(); + _music[primary] = tmp; + fh->inUse = false; + _mutex.unlock(); + return RD_OK; + } else { + _mutex.lock(); + fh->inUse = false; + _mutex.unlock(); + delete tmp; + return RDERR_INVALIDFILENAME; + } +} + +/** + * @return the time left for the current music, in seconds. + */ + +int32 Sound::musicTimeRemaining() { + Common::StackLock lock(_mutex); + + for (int i = 0; i < MAXMUS; i++) { + if (_music[i] && _music[i]->isFading() <= 0) + return _music[i]->getTimeRemaining(); + } + + return 0; +} + +// ---------------------------------------------------------------------------- +// SPEECH +// ---------------------------------------------------------------------------- + +/** + * Mutes/Unmutes the speech. + * @param mute If mute is false, restore the volume to the last set master + * level. Otherwise the speech is muted (volume 0). + */ + +void Sound::muteSpeech(bool mute) { + _speechMuted = mute; + + if (_vm->_mixer->isSoundHandleActive(_soundHandleSpeech)) { + uint volume = mute ? 0 : Audio::Mixer::kMaxChannelVolume; + + _vm->_mixer->setChannelVolume(_soundHandleSpeech, volume); + } +} + +/** + * Stops the speech dead in its tracks. + */ + +void Sound::pauseSpeech() { + _speechPaused = true; + _vm->_mixer->pauseHandle(_soundHandleSpeech, true); +} + +/** + * Restarts the speech from where it was stopped. + */ + +void Sound::unpauseSpeech() { + _speechPaused = false; + _vm->_mixer->pauseHandle(_soundHandleSpeech, false); +} + +/** + * Stops the speech from playing. + */ + +int32 Sound::stopSpeech() { + if (_vm->_mixer->isSoundHandleActive(_soundHandleSpeech)) { + _vm->_mixer->stopHandle(_soundHandleSpeech); + return RD_OK; + } + + return RDERR_SPEECHNOTPLAYING; +} + +/** + * @return Either RDSE_SAMPLEPLAYING or RDSE_SAMPLEFINISHED + */ + +int32 Sound::getSpeechStatus() { + return _vm->_mixer->isSoundHandleActive(_soundHandleSpeech) ? RDSE_SAMPLEPLAYING : RDSE_SAMPLEFINISHED; +} + +/** + * Returns either RDSE_QUIET or RDSE_SPEAKING + */ + +int32 Sound::amISpeaking() { + if (!_speechMuted && !_speechPaused && _vm->_mixer->isSoundHandleActive(_soundHandleSpeech)) + return RDSE_SPEAKING; + + return RDSE_QUIET; +} + +/** + * This function loads and decompresses a list of speech from a cluster, but + * does not play it. This is used for cutscene voice-overs, presumably to + * avoid having to read from more than one file on the CD during playback. + * @param speechId the text line id used to reference the speech + * @param buf a pointer to the buffer that will be allocated for the sound + */ + +uint32 Sound::preFetchCompSpeech(uint32 speechId, uint16 **buf) { + int cd = _vm->_resman->getCD(); + uint32 numSamples; + + SoundFileHandle *fh = (cd == 1) ? &_speechFile[0] : &_speechFile[1]; + + AudioStream *input = getAudioStream(fh, "speech", cd, speechId, &numSamples); + + if (!input) + return 0; + + *buf = NULL; + + // Decompress data into speech buffer. + + uint32 bufferSize = 2 * numSamples; + + *buf = (uint16 *)malloc(bufferSize); + if (!*buf) { + delete input; + fh->file.close(); + return 0; + } + + uint32 readSamples = input->readBuffer((int16 *)*buf, numSamples); + + fh->file.close(); + delete input; + + return 2 * readSamples; +} + +/** + * This function loads, decompresses and plays a line of speech. An error + * occurs if speech is already playing. + * @param speechId the text line id used to reference the speech + * @param vol volume, 0 (minimum) to 16 (maximum) + * @param pan panning, -16 (full left) to 16 (full right) + */ + +int32 Sound::playCompSpeech(uint32 speechId, uint8 vol, int8 pan) { + if (_speechMuted) + return RD_OK; + + if (getSpeechStatus() == RDERR_SPEECHPLAYING) + return RDERR_SPEECHPLAYING; + + int cd = _vm->_resman->getCD(); + SoundFileHandle *fh = (cd == 1) ? &_speechFile[0] : &_speechFile[1]; + + AudioStream *input = getAudioStream(fh, "speech", cd, speechId, NULL); + + if (!input) + return RDERR_INVALIDID; + + // Modify the volume according to the master volume + + byte volume = _speechMuted ? 0 : vol * Audio::Mixer::kMaxChannelVolume / 16; + int8 p = (pan * 127) / 16; + + if (isReverseStereo()) + p = -p; + + // Start the speech playing + _vm->_mixer->playInputStream(Audio::Mixer::kSpeechSoundType, &_soundHandleSpeech, input, -1, volume, p); + return RD_OK; +} + +// ---------------------------------------------------------------------------- +// SOUND EFFECTS +// ---------------------------------------------------------------------------- + +/** + * Mutes/Unmutes the sound effects. + * @param mute If mute is false, restore the volume to the last set master + * level. Otherwise the sound effects are muted (volume 0). + */ + +void Sound::muteFx(bool mute) { + _fxMuted = mute; + + // Now update the volume of any fxs playing + for (int i = 0; i < FXQ_LENGTH; i++) { + if (_fxQueue[i].resource) { + _vm->_mixer->setChannelVolume(_fxQueue[i].handle, mute ? 0 : _fxQueue[i].volume); + } + } +} + +/** + * Sets the volume and pan of the sample which is currently playing + * @param id the id of the sample + * @param vol volume + * @param pan panning + */ + +int32 Sound::setFxIdVolumePan(int32 id, int vol, int pan) { + if (!_fxQueue[id].resource) + return RDERR_FXNOTOPEN; + + if (vol > 16) + vol = 16; + + _fxQueue[id].volume = (vol * Audio::Mixer::kMaxChannelVolume) / 16; + + if (pan != 255) { + if (isReverseStereo()) + pan = -pan; + _fxQueue[id].pan = (pan * 127) / 16; + } + + if (!_fxMuted && _vm->_mixer->isSoundHandleActive(_fxQueue[id].handle)) { + _vm->_mixer->setChannelVolume(_fxQueue[id].handle, _fxQueue[id].volume); + if (pan != -1) + _vm->_mixer->setChannelBalance(_fxQueue[id].handle, _fxQueue[id].pan); + } + + return RD_OK; +} + +void Sound::pauseFx() { + if (_fxPaused) + return; + + for (int i = 0; i < FXQ_LENGTH; i++) { + if (_fxQueue[i].resource) + _vm->_mixer->pauseHandle(_fxQueue[i].handle, true); + } + + _fxPaused = true; +} + +void Sound::unpauseFx() { + if (!_fxPaused) + return; + + for (int i = 0; i < FXQ_LENGTH; i++) + if (_fxQueue[i].resource) + _vm->_mixer->pauseHandle(_fxQueue[i].handle, false); + + _fxPaused = false; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/object.h b/engines/sword2/object.h new file mode 100644 index 0000000000..1fd434f8a0 --- /dev/null +++ b/engines/sword2/object.h @@ -0,0 +1,342 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef _SCRIPT_STRUCTURES +#define _SCRIPT_STRUCTURES + +#include "common/stream.h" + +namespace Sword2 { + +// these structures represent the broken up compact components +// these here declared to the system must be the same as those declared to +// LINC (or it wont work) + +// mouse structure - defines mouse detection area, detection priority & +// 'type' flag + +struct ObjectMouse { + int32 x1; // Top-left and bottom-right of mouse + int32 y1; // area. (These coords are inclusive.) + int32 x2; + int32 y2; + int32 priority; + int32 pointer; // type (or resource id?) of pointer used over this area + + static const int size() { + return 24; + } + + void read(byte *addr) { + Common::MemoryReadStream readS(addr, size()); + + x1 = readS.readSint32LE(); + y1 = readS.readSint32LE(); + x2 = readS.readSint32LE(); + y2 = readS.readSint32LE(); + priority = readS.readSint32LE(); + pointer = readS.readSint32LE(); + } + + void write(byte *addr) { + Common::MemoryWriteStream writeS(addr, size()); + + writeS.writeSint32LE(x1); + writeS.writeSint32LE(y1); + writeS.writeSint32LE(x2); + writeS.writeSint32LE(y2); + writeS.writeSint32LE(priority); + writeS.writeSint32LE(pointer); + } +}; + +// logic structure - contains fields used in logic script processing + +class ObjectLogic { + // int32 looping; // 0 when first calling fn<function>; + // 1 when calling subsequent times in + // same loop + // int32 pause; // pause count, used by fnPause() + +private: + byte *_addr; + +public: + ObjectLogic(byte *addr) { + _addr = addr; + } + + static const int size() { + return 8; + } + + byte *data() { + return _addr; + } + + int32 getLooping() { return READ_LE_UINT32(_addr); } + int32 getPause() { return READ_LE_UINT32(_addr + 4); } + + void setLooping(int32 x) { WRITE_LE_UINT32(_addr, x); } + void setPause(int32 x) { WRITE_LE_UINT32(_addr + 4, x); } +}; + +// status bits for 'type' field of ObjectGraphic) + +// in low word: + +#define NO_SPRITE 0x00000000 // don't print +#define BGP0_SPRITE 0x00000001 // fixed to background parallax[0] +#define BGP1_SPRITE 0x00000002 // fixed to background parallax[1] +#define BACK_SPRITE 0x00000004 // 'background' sprite, fixed to main background +#define SORT_SPRITE 0x00000008 // 'sorted' sprite, fixed to main background +#define FORE_SPRITE 0x00000010 // 'foreground' sprite, fixed to main background +#define FGP0_SPRITE 0x00000020 // fixed to foreground parallax[0] +#define FGP1_SPRITE 0x00000040 // fixed to foreground parallax[0] + +// in high word: + +#define UNSHADED_SPRITE 0x00000000 // not to be shaded +#define SHADED_SPRITE 0x00010000 // to be shaded, based on shading mask + +// graphic structure - contains fields appropriate to sprite output + +class ObjectGraphic { + // int32 type; // see above + // int32 anim_resource; // resource id of animation file + // int32 anim_pc; // current frame number of animation + +private: + byte *_addr; + +public: + ObjectGraphic(byte *addr) { + _addr = addr; + } + + static const int size() { + return 12; + } + + byte *data() { + return _addr; + } + + int32 getType() { return READ_LE_UINT32(_addr); } + int32 getAnimResource() { return READ_LE_UINT32(_addr + 4); } + int32 getAnimPc() { return READ_LE_UINT32(_addr + 8); } + + void setType(int32 x) { WRITE_LE_UINT32(_addr, x); } + void setAnimResource(int32 x) { WRITE_LE_UINT32(_addr + 4, x); } + void setAnimPc(int32 x) { WRITE_LE_UINT32(_addr + 8, x); } +}; + +// speech structure - contains fields used by speech scripts & text output + +class ObjectSpeech { + // int32 pen; // colour to use for body of characters + // int32 width; // max width of text sprite + // int32 command; // speech script command id + // int32 ins1; // speech script instruction parameters + // int32 ins2; + // int32 ins3; + // int32 ins4; + // int32 ins5; + // int32 wait_state; // 0 not waiting, + // 1 waiting for next speech command + +private: + byte *_addr; + +public: + ObjectSpeech(byte *addr) { + _addr = addr; + } + + static const int size() { + return 36; + } + + byte *data() { + return _addr; + } + + int32 getPen() { return READ_LE_UINT32(_addr); } + int32 getWidth() { return READ_LE_UINT32(_addr + 4); } + int32 getCommand() { return READ_LE_UINT32(_addr + 8); } + int32 getIns1() { return READ_LE_UINT32(_addr + 12); } + int32 getIns2() { return READ_LE_UINT32(_addr + 16); } + int32 getIns3() { return READ_LE_UINT32(_addr + 20); } + int32 getIns4() { return READ_LE_UINT32(_addr + 24); } + int32 getIns5() { return READ_LE_UINT32(_addr + 28); } + int32 getWaitState() { return READ_LE_UINT32(_addr + 32); } + + void setPen(int32 x) { WRITE_LE_UINT32(_addr, x); } + void setWidth(int32 x) { WRITE_LE_UINT32(_addr + 4, x); } + void setCommand(int32 x) { WRITE_LE_UINT32(_addr + 8, x); } + void setIns1(int32 x) { WRITE_LE_UINT32(_addr + 12, x); } + void setIns2(int32 x) { WRITE_LE_UINT32(_addr + 16, x); } + void setIns3(int32 x) { WRITE_LE_UINT32(_addr + 20, x); } + void setIns4(int32 x) { WRITE_LE_UINT32(_addr + 24, x); } + void setIns5(int32 x) { WRITE_LE_UINT32(_addr + 28, x); } + void setWaitState(int32 x) { WRITE_LE_UINT32(_addr + 32, x); } +}; + +// mega structure - contains fields used for mega-character & mega-set +// processing + +class ObjectMega { + // int32 NOT_USED_1; // only free roaming megas need to + // check this before registering their + // graphics for drawing + // int32 NOT_USED_2; // id of floor on which we are standing + // int32 NOT_USED_3; // id of object which we are getting to + // int32 NOT_USED_4; // pixel distance to stand from player + // character when in conversation + // int32 currently_walking; // number given us by the auto router + // int32 walk_pc; // current frame number of walk-anim + // int32 scale_a; // current scale factors, taken from + // int32 scale_b; // floor data + // int32 feet_x; // mega feet coords - frame-offsets are + // int32 feet_y; // added to these position mega frames + // int32 current_dir; // current dirction faced by mega; used + // by autorouter to determine turns + // required + // int32 NOT_USED_5; // means were currently avoiding a + // collision (see fnWalk) + // int32 megaset_res; // resource id of mega-set file + // int32 NOT_USED_6; // NOT USED + +private: + byte *_addr; + +public: + ObjectMega(byte *addr) { + _addr = addr; + } + + static const int size() { + return 56; + } + + byte *data() { + return _addr; + } + + int32 getIsWalking() { return READ_LE_UINT32(_addr + 16); } + int32 getWalkPc() { return READ_LE_UINT32(_addr + 20); } + int32 getScaleA() { return READ_LE_UINT32(_addr + 24); } + int32 getScaleB() { return READ_LE_UINT32(_addr + 28); } + int32 getFeetX() { return READ_LE_UINT32(_addr + 32); } + int32 getFeetY() { return READ_LE_UINT32(_addr + 36); } + int32 getCurDir() { return READ_LE_UINT32(_addr + 40); } + int32 getMegasetRes() { return READ_LE_UINT32(_addr + 48); } + + void setIsWalking(int32 x) { WRITE_LE_UINT32(_addr + 16, x); } + void setWalkPc(int32 x) { WRITE_LE_UINT32(_addr + 20, x); } + void setScaleA(int32 x) { WRITE_LE_UINT32(_addr + 24, x); } + void setScaleB(int32 x) { WRITE_LE_UINT32(_addr + 28, x); } + void setFeetX(int32 x) { WRITE_LE_UINT32(_addr + 32, x); } + void setFeetY(int32 x) { WRITE_LE_UINT32(_addr + 36, x); } + void setCurDir(int32 x) { WRITE_LE_UINT32(_addr + 40, x); } + void setMegasetRes(int32 x) { WRITE_LE_UINT32(_addr + 48, x); } + + int32 calcScale() { + // Calc scale at which to print the sprite, based on feet + // y-coord & scaling constants (NB. 'scale' is actually + // 256 * true_scale, to maintain accuracy) + + // Ay+B gives 256 * scale ie. 256 * 256 * true_scale for even + // better accuracy, ie. scale = (Ay + B) / 256 + return (getScaleA() * getFeetY() + getScaleB()) / 256; + } +}; + +// walk-data structure - contains details of layout of frames in the +// mega-set, and how they are to be used + +struct ObjectWalkdata { + int32 nWalkFrames; // no. of frames per walk-cycle + int32 usingStandingTurnFrames; // 0 = no 1 = yes + int32 usingWalkingTurnFrames; // 0 = no 1 = yes + int32 usingSlowInFrames; // 0 = no 1 = yes + int32 usingSlowOutFrames; // 0 = no !0 = number of slow-out frames in each direction + int32 nSlowInFrames[8]; // no. of slow-in frames in each direction + int32 leadingLeg[8]; // leading leg for walk in each direction (0 = left 1 = right) + int32 dx[8 * (12 + 1)]; // walk step distances in x direction + int32 dy[8 * (12 + 1)]; // walk step distances in y direction + + static const int size() { + return 916; + } + + void read(byte *addr) { + Common::MemoryReadStream readS(addr, size()); + + nWalkFrames = readS.readUint32LE(); + usingStandingTurnFrames = readS.readUint32LE(); + usingWalkingTurnFrames = readS.readUint32LE(); + usingSlowInFrames = readS.readUint32LE(); + usingSlowOutFrames = readS.readUint32LE(); + + int i; + + for (i = 0; i < ARRAYSIZE(nSlowInFrames); i++) + nSlowInFrames[i] = readS.readUint32LE(); + + for (i = 0; i < ARRAYSIZE(leadingLeg); i++) + leadingLeg[i] = readS.readUint32LE(); + + for (i = 0; i < ARRAYSIZE(dx); i++) + dx[i] = readS.readUint32LE(); + + for (i = 0; i < ARRAYSIZE(dy); i++) + dy[i] = readS.readUint32LE(); + } + + void write(byte *addr) { + Common::MemoryWriteStream writeS(addr, size()); + + writeS.writeUint32LE(nWalkFrames); + writeS.writeUint32LE(usingStandingTurnFrames); + writeS.writeUint32LE(usingWalkingTurnFrames); + writeS.writeUint32LE(usingSlowInFrames); + writeS.writeUint32LE(usingSlowOutFrames); + + int i; + + for (i = 0; i < ARRAYSIZE(nSlowInFrames); i++) + writeS.writeUint32LE(nSlowInFrames[i]); + + for (i = 0; i < ARRAYSIZE(leadingLeg); i++) + writeS.writeUint32LE(leadingLeg[i]); + + for (i = 0; i < ARRAYSIZE(dx); i++) + writeS.writeUint32LE(dx[i]); + + for (i = 0; i < ARRAYSIZE(dy); i++) + writeS.writeUint32LE(dy[i]); + } +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/palette.cpp b/engines/sword2/palette.cpp new file mode 100644 index 0000000000..0b6b7a8ca2 --- /dev/null +++ b/engines/sword2/palette.cpp @@ -0,0 +1,267 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "common/system.h" +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/resman.h" + +namespace Sword2 { + +/** + * Start layer palette fading up + */ + +void Screen::startNewPalette() { + // If the screen is still fading down then wait for black - could + // happen when everythings cached into a large memory model + waitForFade(); + + byte *screenFile = _vm->_resman->openResource(_thisScreen.background_layer_id); + + memcpy(_paletteMatch, _vm->fetchPaletteMatchTable(screenFile), PALTABLESIZE); + setPalette(0, 256, _vm->fetchPalette(screenFile), RDPAL_FADE); + + // Indicating that it's a screen palette + _lastPaletteRes = 0; + + _vm->_resman->closeResource(_thisScreen.background_layer_id); + fadeUp(); + _thisScreen.new_palette = 0; +} + +void Screen::setFullPalette(int32 palRes) { + // fudge for hut interior + // - unpausing should restore last palette as normal (could be screen + // palette or 'dark_palette_13') + // - but restoring the screen palette after 'dark_palette_13' should + // now work properly too! + + // "Hut interior" refers to the watchman's hut in Marseille, and this + // is apparently needed for the palette to be restored properly when + // you turn the light off. (I didn't even notice the light switch!) + + if (_vm->_logic->readVar(LOCATION) == 13) { + // unpausing + if (palRes == -1) { + // restore whatever palette was last set (screen + // palette or 'dark_palette_13') + palRes = _lastPaletteRes; + } + } else { + // check if we're just restoring the current screen palette + // because we might actually need to use a separate palette + // file anyway eg. for pausing & unpausing during the eclipse + + // unpausing (fudged for location 13) + if (palRes == -1) { + // we really meant '0' + palRes = 0; + } + + if (palRes == 0 && _lastPaletteRes) + palRes = _lastPaletteRes; + } + + // If non-zero, set palette to this separate palette file. Otherwise, + // set palette to current screen palette. + + if (palRes) { + byte *pal = _vm->_resman->openResource(palRes); + + assert(_vm->_resman->fetchType(pal) == PALETTE_FILE); + + pal += ResHeader::size(); + + // always set colour 0 to black because most background screen + // palettes have a bright colour 0 although it should come out + // as black in the game! + + pal[0] = 0; + pal[1] = 0; + pal[2] = 0; + pal[3] = 0; + + setPalette(0, 256, pal, RDPAL_INSTANT); + _vm->_resman->closeResource(palRes); + } else { + if (_thisScreen.background_layer_id) { + byte *data = _vm->_resman->openResource(_thisScreen.background_layer_id); + memcpy(_paletteMatch, _vm->fetchPaletteMatchTable(data), PALTABLESIZE); + setPalette(0, 256, _vm->fetchPalette(data), RDPAL_INSTANT); + _vm->_resman->closeResource(_thisScreen.background_layer_id); + } else + error("setFullPalette(0) called, but no current screen available!"); + } + + if (palRes != CONTROL_PANEL_PALETTE) + _lastPaletteRes = palRes; +} + +/** + * Matches a colour triplet to a palette index. + * @param r red colour component + * @param g green colour component + * @param b blue colour component + * @return the palette index of the closest matching colour in the palette + */ + +// FIXME: This used to be inlined - probably a good idea - but the +// linker complained when I tried to use it in sprite.cpp. + +uint8 Screen::quickMatch(uint8 r, uint8 g, uint8 b) { + return _paletteMatch[((int32)(r >> 2) << 12) + ((int32)(g >> 2) << 6) + (b >> 2)]; +} + +/** + * Sets the palette. + * @param startEntry the first colour entry to set + * @param noEntries the number of colour entries to set + * @param colourTable the new colour entries + * @param fadeNow whether to perform the change immediately or delayed + */ + +void Screen::setPalette(int16 startEntry, int16 noEntries, byte *colourTable, uint8 fadeNow) { + assert(noEntries > 0); + + memcpy(&_palette[4 * startEntry], colourTable, noEntries * 4); + + if (fadeNow == RDPAL_INSTANT) { + _vm->_system->setPalette(_palette, startEntry, noEntries); + setNeedFullRedraw(); + } +} + +void Screen::dimPalette() { + byte *p = _palette; + + for (int i = 0; i < 256; i++) { + p[i * 4 + 0] /= 2; + p[i * 4 + 1] /= 2; + p[i * 4 + 2] /= 2; + } + + _vm->_system->setPalette(p, 0, 256); + setNeedFullRedraw(); +} + +/** + * Fades the palette up from black to the current palette. + * @param time the time it will take the palette to fade up + */ + +int32 Screen::fadeUp(float time) { + if (getFadeStatus() != RDFADE_BLACK && getFadeStatus() != RDFADE_NONE) + return RDERR_FADEINCOMPLETE; + + _fadeTotalTime = (int32)(time * 1000); + _fadeStatus = RDFADE_UP; + _fadeStartTime = _vm->_system->getMillis(); + + return RD_OK; +} + +/** + * Fades the palette down to black from the current palette. + * @param time the time it will take the palette to fade down + */ + +int32 Screen::fadeDown(float time) { + if (getFadeStatus() != RDFADE_BLACK && getFadeStatus() != RDFADE_NONE) + return RDERR_FADEINCOMPLETE; + + _fadeTotalTime = (int32)(time * 1000); + _fadeStatus = RDFADE_DOWN; + _fadeStartTime = _vm->_system->getMillis(); + + return RD_OK; +} + +/** + * Get the current fade status + * @return RDFADE_UP (fading up), RDFADE_DOWN (fading down), RDFADE_NONE + * (not faded), or RDFADE_BLACK (completely faded down) + */ + +uint8 Screen::getFadeStatus() { + return _fadeStatus; +} + +void Screen::waitForFade() { + while (getFadeStatus() != RDFADE_NONE && getFadeStatus() != RDFADE_BLACK && !_vm->_quit) { + updateDisplay(); + _vm->_system->delayMillis(20); + } +} + +void Screen::fadeServer() { + static int32 previousTime = 0; + byte fadePalette[256 * 4]; + byte *newPalette = fadePalette; + int32 currentTime; + int16 fadeMultiplier; + int16 i; + + // If we're not in the process of fading, do nothing. + if (getFadeStatus() != RDFADE_UP && getFadeStatus() != RDFADE_DOWN) + return; + + // I don't know if this is necessary, but let's limit how often the + // palette is updated, just to be safe. + currentTime = _vm->_system->getMillis(); + if (currentTime - previousTime <= 25) + return; + + previousTime = currentTime; + + if (getFadeStatus() == RDFADE_UP) { + if (currentTime >= _fadeStartTime + _fadeTotalTime) { + _fadeStatus = RDFADE_NONE; + newPalette = _palette; + } else { + fadeMultiplier = (int16)(((int32)(currentTime - _fadeStartTime) * 256) / _fadeTotalTime); + for (i = 0; i < 256; i++) { + newPalette[i * 4 + 0] = (_palette[i * 4 + 0] * fadeMultiplier) >> 8; + newPalette[i * 4 + 1] = (_palette[i * 4 + 1] * fadeMultiplier) >> 8; + newPalette[i * 4 + 2] = (_palette[i * 4 + 2] * fadeMultiplier) >> 8; + } + } + } else { + if (currentTime >= _fadeStartTime + _fadeTotalTime) { + _fadeStatus = RDFADE_BLACK; + memset(newPalette, 0, sizeof(fadePalette)); + } else { + fadeMultiplier = (int16)(((int32)(_fadeTotalTime - (currentTime - _fadeStartTime)) * 256) / _fadeTotalTime); + for (i = 0; i < 256; i++) { + newPalette[i * 4 + 0] = (_palette[i * 4 + 0] * fadeMultiplier) >> 8; + newPalette[i * 4 + 1] = (_palette[i * 4 + 1] * fadeMultiplier) >> 8; + newPalette[i * 4 + 2] = (_palette[i * 4 + 2] * fadeMultiplier) >> 8; + } + } + } + + _vm->_system->setPalette(newPalette, 0, 256); + setNeedFullRedraw(); +} + +} // End of namespace Sword2 diff --git a/engines/sword2/protocol.cpp b/engines/sword2/protocol.cpp new file mode 100644 index 0000000000..23010e27a9 --- /dev/null +++ b/engines/sword2/protocol.cpp @@ -0,0 +1,216 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "sword2/sword2.h" +#include "sword2/resman.h" + +namespace Sword2 { + +/** + * Returns a pointer to the first palette entry, given the pointer to the start + * of the screen file. + */ + +byte *Sword2Engine::fetchPalette(byte *screenFile) { + MultiScreenHeader mscreenHeader; + + mscreenHeader.read(screenFile + ResHeader::size()); + + byte *palette = screenFile + ResHeader::size() + mscreenHeader.palette; + + // Always set colour 0 to black, because while most background screen + // palettes have a bright colour 0 it should come out as black in the + // game. + + palette[0] = 0; + palette[1] = 0; + palette[2] = 0; + palette[3] = 0; + + return palette; +} + +/** + * Returns a pointer to the start of the palette match table, given the pointer + * to the start of the screen file. + */ + +byte *Sword2Engine::fetchPaletteMatchTable(byte *screenFile) { + MultiScreenHeader mscreenHeader; + + mscreenHeader.read(screenFile + ResHeader::size()); + + return screenFile + ResHeader::size() + mscreenHeader.paletteTable; +} + +/** + * Returns a pointer to the screen header, given the pointer to the start of + * the screen file. + */ + +byte *Sword2Engine::fetchScreenHeader(byte *screenFile) { + MultiScreenHeader mscreenHeader; + + mscreenHeader.read(screenFile + ResHeader::size()); + + return screenFile + ResHeader::size() + mscreenHeader.screen; +} + +/** + * Returns a pointer to the requested layer header, given the pointer to the + * start of the screen file. Drops out if the requested layer number exceeds + * the number of layers on this screen. + */ + +byte *Sword2Engine::fetchLayerHeader(byte *screenFile, uint16 layerNo) { +#ifdef SWORD2_DEBUG + ScreenHeader screenHead; + + screenHead.read(fetchScreenHeader(screenFile)); + assert(layerNo < screenHead.noLayers); +#endif + + MultiScreenHeader mscreenHeader; + + mscreenHeader.read(screenFile + ResHeader::size()); + + return screenFile + ResHeader::size() + mscreenHeader.layers + layerNo * LayerHeader::size(); +} + +/** + * Returns a pointer to the start of the shading mask, given the pointer to the + * start of the screen file. + */ + +byte *Sword2Engine::fetchShadingMask(byte *screenFile) { + MultiScreenHeader mscreenHeader; + + mscreenHeader.read(screenFile + ResHeader::size()); + + return screenFile + ResHeader::size() + mscreenHeader.maskOffset; +} + +/** + * Returns a pointer to the anim header, given the pointer to the start of the + * anim file. + */ + +byte *Sword2Engine::fetchAnimHeader(byte *animFile) { + return animFile + ResHeader::size(); +} + +/** + * Returns a pointer to the requested frame number's cdtEntry, given the + * pointer to the start of the anim file. Drops out if the requested frame + * number exceeds the number of frames in this anim. + */ + +byte *Sword2Engine::fetchCdtEntry(byte *animFile, uint16 frameNo) { +#ifdef SWORD2_DEBUG + AnimHeader animHead; + + animHead.read(fetchAnimHeader(animFile)); + + if (frameNo > animHead->noAnimFrames - 1) + error("fetchCdtEntry(animFile,%d) - anim only %d frames", frameNo, animHead.noAnimFrames); +#endif + + return fetchAnimHeader(animFile) + AnimHeader::size() + frameNo * CdtEntry::size(); +} + +/** + * Returns a pointer to the requested frame number's header, given the pointer + * to the start of the anim file. Drops out if the requested frame number + * exceeds the number of frames in this anim + */ + +byte *Sword2Engine::fetchFrameHeader(byte *animFile, uint16 frameNo) { + // required address = (address of the start of the anim header) + frameOffset + CdtEntry cdt; + + cdt.read(fetchCdtEntry(animFile, frameNo)); + + return animFile + ResHeader::size() + cdt.frameOffset; +} + +/** + * Returns a pointer to the requested parallax layer data. + */ + +byte *Sword2Engine::fetchBackgroundParallaxLayer(byte *screenFile, int layer) { + MultiScreenHeader mscreenHeader; + + mscreenHeader.read(screenFile + ResHeader::size()); + assert(mscreenHeader.bg_parallax[layer]); + + return screenFile + ResHeader::size() + mscreenHeader.bg_parallax[layer]; +} + +byte *Sword2Engine::fetchBackgroundLayer(byte *screenFile) { + MultiScreenHeader mscreenHeader; + + mscreenHeader.read(screenFile + ResHeader::size()); + assert(mscreenHeader.screen); + + return screenFile + ResHeader::size() + mscreenHeader.screen + ScreenHeader::size(); +} + +byte *Sword2Engine::fetchForegroundParallaxLayer(byte *screenFile, int layer) { + MultiScreenHeader mscreenHeader; + + mscreenHeader.read(screenFile + ResHeader::size()); + assert(mscreenHeader.fg_parallax[layer]); + + return screenFile + ResHeader::size() + mscreenHeader.fg_parallax[layer]; +} + +byte *Sword2Engine::fetchTextLine(byte *file, uint32 text_line) { + TextHeader text_header; + static byte errorLine[128]; + + text_header.read(file + ResHeader::size()); + + if (text_line >= text_header.noOfLines) { + sprintf((char *)errorLine, "xxMissing line %d of %s (only 0..%d)", text_line, _resman->fetchName(file), text_header.noOfLines - 1); + + // first 2 chars are NULL so that actor-number comes out as '0' + errorLine[0] = 0; + errorLine[1] = 0; + return errorLine; + } + + // The "number of lines" field is followed by a lookup table + + return file + READ_LE_UINT32(file + ResHeader::size() + 4 + 4 * text_line); +} + +// Used for testing text & speech (see fnISpeak in speech.cpp) + +bool Sword2Engine::checkTextLine(byte *file, uint32 text_line) { + TextHeader text_header; + + text_header.read(file + ResHeader::size()); + + return text_line < text_header.noOfLines; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/rdwin.cpp b/engines/sword2/rdwin.cpp new file mode 100644 index 0000000000..310b66abf7 --- /dev/null +++ b/engines/sword2/rdwin.cpp @@ -0,0 +1,118 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "common/system.h" +#include "sword2/sword2.h" + +namespace Sword2 { + +/** + * Tell updateDisplay() that the scene needs to be completely updated. + */ + +void Screen::setNeedFullRedraw() { + _needFullRedraw = true; +} + +/** + * Mark an area of the screen as dirty, first generation. + */ + +void Screen::markAsDirty(int16 x0, int16 y0, int16 x1, int16 y1) { + int16 gridX0 = x0 / CELLWIDE; + int16 gridY0 = y0 / CELLDEEP; + int16 gridX1 = x1 / CELLWIDE; + int16 gridY1 = y1 / CELLDEEP; + + for (int16 i = gridY0; i <= gridY1; i++) + for (int16 j = gridX0; j <= gridX1; j++) + _dirtyGrid[i * _gridWide + j] = 2; +} + +/** + * This function has two purposes: It redraws the scene, and it handles input + * events, palette fading, etc. It should be called at a high rate (> 20 per + * second), but the scene is usually only redrawn about 12 times per second, + * except when then screen is scrolling. + * + * @param redrawScene If true, redraw the scene. + */ + +void Screen::updateDisplay(bool redrawScene) { + _vm->parseInputEvents(); + fadeServer(); + + if (redrawScene) { + int i; + + // Note that the entire scene is always rendered, which is less + // than optimal, but at least we can try to be intelligent + // about updating the screen afterwards. + + if (_needFullRedraw) { + // Update the entire screen. This is necessary when + // scrolling, fading, etc. + + _vm->_system->copyRectToScreen(_buffer + MENUDEEP * _screenWide, _screenWide, 0, MENUDEEP, _screenWide, _screenDeep - 2 * MENUDEEP); + _needFullRedraw = false; + } else { + // Update only the dirty areas of the screen + + int j, x, y; + int stripWide; + + for (i = 0; i < _gridDeep; i++) { + stripWide = 0; + + for (j = 0; j < _gridWide; j++) { + if (_dirtyGrid[i * _gridWide + j]) { + stripWide++; + } else if (stripWide) { + x = CELLWIDE * (j - stripWide); + y = CELLDEEP * i; + _vm->_system->copyRectToScreen(_buffer + y * _screenWide + x, _screenWide, x, y, stripWide * CELLWIDE, CELLDEEP); + stripWide = 0; + } + } + + if (stripWide) { + x = CELLWIDE * (j - stripWide); + y = CELLDEEP * i; + _vm->_system->copyRectToScreen(_buffer + y * _screenWide + x, _screenWide, x, y, stripWide * CELLWIDE, CELLDEEP); + stripWide = 0; + } + } + } + + // Age the dirty cells one generation. This way we keep track + // of both the cells that were updated this time, and the ones + // that were updated the last time. + + for (i = 0; i < _gridWide * _gridDeep; i++) + _dirtyGrid[i] >>= 1; + } + + // We always need to update because of fades, menu animations, etc. + _vm->_system->updateScreen(); +} + +} // End of namespace Sword2 diff --git a/engines/sword2/render.cpp b/engines/sword2/render.cpp new file mode 100644 index 0000000000..da60ecd6d9 --- /dev/null +++ b/engines/sword2/render.cpp @@ -0,0 +1,584 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "common/system.h" + +#include "graphics/primitives.h" + +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/build_display.h" + +#ifdef BACKEND_8BIT +#include "sword2/animation.h" +#endif + +namespace Sword2 { + +#define MILLISECSPERCYCLE 83 +#define RENDERAVERAGETOTAL 4 + +void Screen::updateRect(Common::Rect *r) { + _vm->_system->copyRectToScreen(_buffer + r->top * _screenWide + r->left, + _screenWide, r->left, r->top, r->right - r->left, + r->bottom - r->top); +} + +void Screen::blitBlockSurface(BlockSurface *s, Common::Rect *r, Common::Rect *clipRect) { + if (!r->intersects(*clipRect)) + return; + + byte *src = s->data; + + if (r->top < clipRect->top) { + src -= BLOCKWIDTH * (r->top - clipRect->top); + r->top = clipRect->top; + } + if (r->left < clipRect->left) { + src -= (r->left - clipRect->left); + r->left = clipRect->left; + } + if (r->bottom > clipRect->bottom) + r->bottom = clipRect->bottom; + if (r->right > clipRect->right) + r->right = clipRect->right; + + byte *dst = _buffer + r->top * _screenWide + r->left; + int i; + + if (s->transparent) { + for (i = 0; i < r->bottom - r->top; i++) { + for (int j = 0; j < r->right - r->left; j++) { + if (src[j]) + dst[j] = src[j]; + } + src += BLOCKWIDTH; + dst += _screenWide; + } + } else { + for (i = 0; i < r->bottom - r->top; i++) { + memcpy(dst, src, r->right - r->left); + src += BLOCKWIDTH; + dst += _screenWide; + } + } +} + +// There are two different separate functions for scaling the image - one fast +// and one good. Or at least that's the theory. I'm sure there are better ways +// to scale an image than this. The latter is used at the highest graphics +// quality setting. Note that the "good" scaler takes an extra parameter, a +// pointer to the area of the screen where the sprite will be drawn. +// +// This code isn't quite like the original DrawSprite(), but should be close +// enough. + +void Screen::scaleImageFast(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth, uint16 srcHeight) { + int x, y; + + for (x = 0; x < dstWidth; x++) + _xScale[x] = (x * srcWidth) / dstWidth; + + for (y = 0; y < dstHeight; y++) + _yScale[y] = (y * srcHeight) / dstHeight; + + for (y = 0; y < dstHeight; y++) { + for (x = 0; x < dstWidth; x++) { + dst[x] = src[_yScale[y] * srcPitch + _xScale[x]]; + } + dst += dstPitch; + } +} + +void Screen::scaleImageGood(byte *dst, uint16 dstPitch, uint16 dstWidth, uint16 dstHeight, byte *src, uint16 srcPitch, uint16 srcWidth, uint16 srcHeight, byte *backbuf) { + for (int y = 0; y < dstHeight; y++) { + for (int x = 0; x < dstWidth; x++) { + uint8 c1, c2, c3, c4; + + uint32 xPos = (x * srcWidth) / dstWidth; + uint32 yPos = (y * srcHeight) / dstHeight; + uint32 xFrac = dstWidth - (x * srcWidth) % dstWidth; + uint32 yFrac = dstHeight - (y * srcHeight) % dstHeight; + + byte *srcPtr = src + yPos * srcPitch + xPos; + byte *backPtr = backbuf + y * _screenWide + x; + + bool transparent = true; + + if (*srcPtr) { + c1 = *srcPtr; + transparent = false; + } else + c1 = *backPtr; + + if (x < dstWidth - 1) { + if (*(srcPtr + 1)) { + c2 = *(srcPtr + 1); + transparent = false; + } else + c2 = *(backPtr + 1); + } else + c2 = c1; + + if (y < dstHeight - 1) { + if (*(srcPtr + srcPitch)) { + c3 = *(srcPtr + srcPitch); + transparent = false; + } else + c3 = *(backPtr + _screenWide); + } else + c3 = c1; + + if (x < dstWidth - 1 && y < dstHeight - 1) { + if (*(srcPtr + srcPitch + 1)) { + c4 = *(srcPtr + srcPitch + 1); + transparent = false; + } else + c4 = *(backPtr + _screenWide + 1); + } else + c4 = c3; + + if (!transparent) { + uint32 r1 = _palette[c1 * 4 + 0]; + uint32 g1 = _palette[c1 * 4 + 1]; + uint32 b1 = _palette[c1 * 4 + 2]; + + uint32 r2 = _palette[c2 * 4 + 0]; + uint32 g2 = _palette[c2 * 4 + 1]; + uint32 b2 = _palette[c2 * 4 + 2]; + + uint32 r3 = _palette[c3 * 4 + 0]; + uint32 g3 = _palette[c3 * 4 + 1]; + uint32 b3 = _palette[c3 * 4 + 2]; + + uint32 r4 = _palette[c4 * 4 + 0]; + uint32 g4 = _palette[c4 * 4 + 1]; + uint32 b4 = _palette[c4 * 4 + 2]; + + uint32 r5 = (r1 * xFrac + r2 * (dstWidth - xFrac)) / dstWidth; + uint32 g5 = (g1 * xFrac + g2 * (dstWidth - xFrac)) / dstWidth; + uint32 b5 = (b1 * xFrac + b2 * (dstWidth - xFrac)) / dstWidth; + + uint32 r6 = (r3 * xFrac + r4 * (dstWidth - xFrac)) / dstWidth; + uint32 g6 = (g3 * xFrac + g4 * (dstWidth - xFrac)) / dstWidth; + uint32 b6 = (b3 * xFrac + b4 * (dstWidth - xFrac)) / dstWidth; + + uint32 r = (r5 * yFrac + r6 * (dstHeight - yFrac)) / dstHeight; + uint32 g = (g5 * yFrac + g6 * (dstHeight - yFrac)) / dstHeight; + uint32 b = (b5 * yFrac + b6 * (dstHeight - yFrac)) / dstHeight; + + dst[y * dstWidth + x] = quickMatch(r, g, b); + } else + dst[y * dstWidth + x] = 0; + } + } +} + +/** + * Plots a point relative to the top left corner of the screen. This is only + * used for debugging. + * @param x x-coordinate of the point + * @param y y-coordinate of the point + * @param colour colour of the point + */ + +void Screen::plotPoint(int x, int y, uint8 colour) { + byte *buf = _buffer + MENUDEEP * RENDERWIDE; + + x -= _scrollX; + y -= _scrollY; + + if (x >= 0 && x < RENDERWIDE && y >= 0 && y < RENDERDEEP) { + buf[y * RENDERWIDE + x] = colour; + markAsDirty(x, y + MENUDEEP, x, y + MENUDEEP); + } +} + +static void plot(int x, int y, int colour, void *data) { + Screen *screen = (Screen *)data; + screen->plotPoint(x, y, (uint8) colour); +} + +/** + * Draws a line from one point to another. This is only used for debugging. + * @param x0 x-coordinate of the start point + * @param y0 y-coordinate of the start point + * @param x1 x-coordinate of the end point + * @param y1 y-coordinate of the end point + * @param colour colour of the line + */ + +void Screen::drawLine(int x0, int y0, int x1, int y1, uint8 colour) { + Graphics::drawLine(x0, y0, x1, y1, colour, &plot, this); +} + +/** + * This function tells the driver the size of the background screen for the + * current location. + * @param w width of the current location + * @param h height of the current location + */ + +void Screen::setLocationMetrics(uint16 w, uint16 h) { + _locationWide = w; + _locationDeep = h; + setNeedFullRedraw(); +} + +/** + * Draws a parallax layer at the current position determined by the scroll. A + * parallax can be either foreground, background or the main screen. + */ + +void Screen::renderParallax(byte *ptr, int16 l) { + Parallax p; + int16 x, y; + Common::Rect r; + + p.read(ptr); + + if (_locationWide == _screenWide) + x = 0; + else + x = ((int32)((p.w - _screenWide) * _scrollX) / (int32)(_locationWide - _screenWide)); + + if (_locationDeep == _screenDeep - MENUDEEP * 2) + y = 0; + else + y = ((int32)((p.h - (_screenDeep - MENUDEEP * 2)) * _scrollY) / (int32)(_locationDeep - (_screenDeep - MENUDEEP * 2))); + + Common::Rect clipRect; + + // Leave enough space for the top and bottom menues + + clipRect.left = 0; + clipRect.right = _screenWide; + clipRect.top = MENUDEEP; + clipRect.bottom = _screenDeep - MENUDEEP; + + for (int j = 0; j < _yBlocks[l]; j++) { + for (int i = 0; i < _xBlocks[l]; i++) { + if (_blockSurfaces[l][i + j * _xBlocks[l]]) { + r.left = i * BLOCKWIDTH - x; + r.right = r.left + BLOCKWIDTH; + r.top = j * BLOCKHEIGHT - y + MENUDEEP; + r.bottom = r.top + BLOCKHEIGHT; + blitBlockSurface(_blockSurfaces[l][i + j * _xBlocks[l]], &r, &clipRect); + } + } + } + + _parallaxScrollX = _scrollX - x; + _parallaxScrollY = _scrollY - y; +} + +// Uncomment this when benchmarking the drawing routines. +#define LIMIT_FRAME_RATE + +/** + * Initialises the timers before the render loop is entered. + */ + +void Screen::initialiseRenderCycle() { + _initialTime = _vm->_system->getMillis(); + _totalTime = _initialTime + MILLISECSPERCYCLE; +} + +/** + * This function should be called when the game engine is ready to start the + * render cycle. + */ + +void Screen::startRenderCycle() { + _scrollXOld = _scrollX; + _scrollYOld = _scrollY; + + _startTime = _vm->_system->getMillis(); + + if (_startTime + _renderAverageTime >= _totalTime) { + _scrollX = _scrollXTarget; + _scrollY = _scrollYTarget; + _renderTooSlow = true; + } else { + _scrollX = (int16)(_scrollXOld + ((_scrollXTarget - _scrollXOld) * (_startTime - _initialTime + _renderAverageTime)) / (_totalTime - _initialTime)); + _scrollY = (int16)(_scrollYOld + ((_scrollYTarget - _scrollYOld) * (_startTime - _initialTime + _renderAverageTime)) / (_totalTime - _initialTime)); + _renderTooSlow = false; + } + + if (_scrollXOld != _scrollX || _scrollYOld != _scrollY) + setNeedFullRedraw(); + + _framesPerGameCycle = 0; +} + +/** + * This function should be called at the end of the render cycle. + * @return true if the render cycle is to be terminated, + * or false if it should continue + */ + +bool Screen::endRenderCycle() { + static int32 renderTimeLog[4] = { 60, 60, 60, 60 }; + static int32 renderCountIndex = 0; + int32 time; + + time = _vm->_system->getMillis(); + renderTimeLog[renderCountIndex] = time - _startTime; + _startTime = time; + _renderAverageTime = (renderTimeLog[0] + renderTimeLog[1] + renderTimeLog[2] + renderTimeLog[3]) >> 2; + + _framesPerGameCycle++; + + if (++renderCountIndex == RENDERAVERAGETOTAL) + renderCountIndex = 0; + + if (_renderTooSlow) { + initialiseRenderCycle(); + return true; + } + + if (_startTime + _renderAverageTime >= _totalTime) { + _totalTime += MILLISECSPERCYCLE; + _initialTime = time; + return true; + } + +#ifdef LIMIT_FRAME_RATE + if (_scrollXTarget == _scrollX && _scrollYTarget == _scrollY) { + // If we have already reached the scroll target sleep for the + // rest of the render cycle. + _vm->sleepUntil(_totalTime); + _initialTime = _vm->_system->getMillis(); + _totalTime += MILLISECSPERCYCLE; + return true; + } +#endif + + // This is an attempt to ensure that we always reach the scroll target. + // Otherwise the game frequently tries to pump out new interpolation + // frames without ever getting anywhere. + + if (ABS(_scrollX - _scrollXTarget) <= 1 && ABS(_scrollY - _scrollYTarget) <= 1) { + _scrollX = _scrollXTarget; + _scrollY = _scrollYTarget; + } else { + _scrollX = (int16)(_scrollXOld + ((_scrollXTarget - _scrollXOld) * (_startTime - _initialTime + _renderAverageTime)) / (_totalTime - _initialTime)); + _scrollY = (int16)(_scrollYOld + ((_scrollYTarget - _scrollYOld) * (_startTime - _initialTime + _renderAverageTime)) / (_totalTime - _initialTime)); + } + + if (_scrollX != _scrollXOld || _scrollY != _scrollYOld) + setNeedFullRedraw(); + +#ifdef LIMIT_FRAME_RATE + // Give the other threads some breathing space. This apparently helps + // against bug #875683, though I was never able to reproduce it for + // myself. + _vm->_system->delayMillis(10); +#endif + + return false; +} + +/** + * Reset scrolling stuff. This function is called from initBackground() + */ + +void Screen::resetRenderEngine() { + _parallaxScrollX = 0; + _parallaxScrollY = 0; + _scrollX = 0; + _scrollY = 0; +} + +/** + * This function should be called five times with either the parallax layer + * or a NULL pointer in order of background parallax to foreground parallax. + */ + +int32 Screen::initialiseBackgroundLayer(byte *parallax) { + Parallax p; + uint16 i, j, k; + byte *data; + byte *dst; + + debug(2, "initialiseBackgroundLayer"); + + assert(_layer < MAXLAYERS); + + if (!parallax) { + _layer++; + return RD_OK; + } + + p.read(parallax); + + _xBlocks[_layer] = (p.w + BLOCKWIDTH - 1) / BLOCKWIDTH; + _yBlocks[_layer] = (p.h + BLOCKHEIGHT - 1) / BLOCKHEIGHT; + + _blockSurfaces[_layer] = (BlockSurface **)calloc(_xBlocks[_layer] * _yBlocks[_layer], sizeof(BlockSurface *)); + if (!_blockSurfaces[_layer]) + return RDERR_OUTOFMEMORY; + + // Decode the parallax layer into a large chunk of memory + + byte *memchunk = (byte *)calloc(_xBlocks[_layer] * _yBlocks[_layer], BLOCKWIDTH * BLOCKHEIGHT); + if (!memchunk) + return RDERR_OUTOFMEMORY; + + for (i = 0; i < p.h; i++) { + uint32 p_offset = READ_LE_UINT32(parallax + Parallax::size() + 4 * i); + + if (!p_offset) + continue; + + byte *pLine = parallax + p_offset; + uint16 packets = READ_LE_UINT16(pLine); + uint16 offset = READ_LE_UINT16(pLine + 2); + + data = pLine + 4; + dst = memchunk + i * p.w + offset; + + if (!packets) { + memcpy(dst, data, p.w); + continue; + } + + bool zeros = false; + + for (j = 0; j < packets; j++) { + if (zeros) { + dst += *data; + offset += *data; + data++; + zeros = false; + } else if (!*data) { + data++; + zeros = true; + } else { + uint16 count = *data++; + memcpy(dst, data, count); + data += count; + dst += count; + offset += count; + zeros = true; + } + } + } + + // The large memory chunk is now divided into a number of smaller + // surfaces. For most parallax layers, we'll end up using less memory + // this way, and it will be faster to draw since completely transparent + // surfaces are discarded. + + for (i = 0; i < _xBlocks[_layer] * _yBlocks[_layer]; i++) { + bool block_has_data = false; + bool block_is_transparent = false; + + int x = BLOCKWIDTH * (i % _xBlocks[_layer]); + int y = BLOCKHEIGHT * (i / _xBlocks[_layer]); + + data = memchunk + p.w * y + x; + + for (j = 0; j < BLOCKHEIGHT; j++) { + for (k = 0; k < BLOCKWIDTH; k++) { + if (x + k < p.w && y + j < p.h) { + if (data[j * p.w + k]) + block_has_data = true; + else + block_is_transparent = true; + } + } + } + + // Only assign a surface to the block if it contains data. + + if (block_has_data) { + _blockSurfaces[_layer][i] = (BlockSurface *)malloc(sizeof(BlockSurface)); + + // Copy the data into the surfaces. + dst = _blockSurfaces[_layer][i]->data; + for (j = 0; j < BLOCKHEIGHT; j++) { + memcpy(dst, data, BLOCKWIDTH); + data += p.w; + dst += BLOCKWIDTH; + } + + _blockSurfaces[_layer][i]->transparent = block_is_transparent; + + } else + _blockSurfaces[_layer][i] = NULL; + } + + free(memchunk); + _layer++; + + return RD_OK; +} + +/** + * Should be called once after leaving the room to free up memory. + */ + +void Screen::closeBackgroundLayer() { + debug(2, "CloseBackgroundLayer"); + + for (int i = 0; i < MAXLAYERS; i++) { + if (_blockSurfaces[i]) { + for (int j = 0; j < _xBlocks[i] * _yBlocks[i]; j++) + if (_blockSurfaces[i][j]) + free(_blockSurfaces[i][j]); + free(_blockSurfaces[i]); + _blockSurfaces[i] = NULL; + } + } + + _layer = 0; +} + +#ifdef BACKEND_8BIT +void Screen::plotYUV(byte *lut, int width, int height, byte *const *dat) { + byte *buf = _buffer + ((480 - height) / 2) * RENDERWIDE + (640 - width) / 2; + + int x, y; + + int ypos = 0; + int cpos = 0; + int linepos = 0; + + for (y = 0; y < height; y += 2) { + for (x = 0; x < width; x += 2) { + int i = ((((dat[2][cpos] + ROUNDADD) >> SHIFT) * (BITDEPTH + 1)) + ((dat[1][cpos] + ROUNDADD) >> SHIFT)) * (BITDEPTH + 1); + cpos++; + + buf[linepos ] = lut[i + ((dat[0][ ypos ] + ROUNDADD) >> SHIFT)]; + buf[RENDERWIDE + linepos++] = lut[i + ((dat[0][width + ypos++] + ROUNDADD) >> SHIFT)]; + buf[linepos ] = lut[i + ((dat[0][ ypos ] + ROUNDADD) >> SHIFT)]; + buf[RENDERWIDE + linepos++] = lut[i + ((dat[0][width + ypos++] + ROUNDADD) >> SHIFT)]; + } + linepos += (2 * RENDERWIDE - width); + ypos += width; + } +} +#endif + + +} // End of namespace Sword2 diff --git a/engines/sword2/resman.cpp b/engines/sword2/resman.cpp new file mode 100644 index 0000000000..7387dc8f50 --- /dev/null +++ b/engines/sword2/resman.cpp @@ -0,0 +1,633 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "common/file.h" +#include "common/system.h" +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/console.h" +#include "sword2/logic.h" +#include "sword2/memory.h" +#include "sword2/resman.h" +#include "sword2/router.h" +#include "sword2/sound.h" + +#define Debug_Printf _vm->_debugger->DebugPrintf + +namespace Sword2 { + +// Welcome to the easy resource manager - written in simple code for easy +// maintenance +// +// The resource compiler will create two files +// +// resource.inf which is a list of ascii cluster file names +// resource.tab which is a table which tells us which cluster a resource +// is located in and the number within the cluster + +enum { + BOTH = 0x0, // Cluster is on both CDs + CD1 = 0x1, // Cluster is on CD1 only + CD2 = 0x2, // Cluster is on CD2 only + LOCAL_CACHE = 0x4, // Cluster is cached on HDD + LOCAL_PERM = 0x8 // Cluster is on HDD. +}; + +struct CdInf { + uint8 clusterName[20]; // Null terminated cluster name. + uint8 cd; // Cd cluster is on and whether it is on the local drive or not. +}; + +ResourceManager::ResourceManager(Sword2Engine *vm) { + _vm = vm; + + // Until proven differently, assume we're on CD 1. This is so the start + // dialog will be able to play any music at all. + setCD(1); + + // We read in the resource info which tells us the names of the + // resource cluster files ultimately, although there might be groups + // within the clusters at this point it makes no difference. We only + // wish to know what resource files there are and what is in each + + Common::File file; + uint32 size; + byte *temp; + + _totalClusters = 0; + _resConvTable = NULL; + + if (!file.open("resource.inf")) + error("Cannot open resource.inf"); + + size = file.size(); + + // Get some space for the incoming resource file - soon to be trashed + temp = (byte *)malloc(size); + + if (file.read(temp, size) != size) { + file.close(); + error("init cannot *READ* resource.inf"); + } + + file.close(); + + // Ok, we've loaded in the resource.inf file which contains a list of + // all the files now extract the filenames. + + // Using this method the Gode generated resource.inf must have #0d0a on + // the last entry + + uint32 i = 0; + uint32 j = 0; + + do { + // item must have an #0d0a + while (temp[i] != 13) { + _resFiles[_totalClusters].fileName[j] = temp[i]; + i++; + j++; + } + + // NULL terminate our extracted string + _resFiles[_totalClusters].fileName[j] = '\0'; + _resFiles[_totalClusters].numEntries = -1; + _resFiles[_totalClusters].entryTab = NULL; + + // Reset position in current slot between entries, skip the + // 0x0a in the source and increase the number of clusters. + + j = 0; + i += 2; + _totalClusters++; + + // TODO: put overload check here + } while (i != size); + + free(temp); + + // Now load in the binary id to res conversion table + if (!file.open("resource.tab")) + error("Cannot open resource.tab"); + + // Find how many resources + size = file.size(); + + _totalResFiles = size / 4; + + // Table seems ok so malloc some space + _resConvTable = (uint16 *)malloc(size); + + for (i = 0; i < size / 2; i++) + _resConvTable[i] = file.readUint16LE(); + + if (file.ioFailed()) { + file.close(); + error("Cannot read resource.tab"); + } + + file.close(); + + if (!file.open("cd.inf")) + error("Cannot open cd.inf"); + + CdInf *cdInf = new CdInf[_totalClusters]; + + for (i = 0; i < _totalClusters; i++) { + file.read(cdInf[i].clusterName, sizeof(cdInf[i].clusterName)); + + cdInf[i].cd = file.readByte(); + + if (file.ioFailed()) + error("Cannot read cd.inf"); + + // It has been reported that there are two different versions + // of the cd.inf file: One where all clusters on CD also have + // the LOCAL_CACHE bit set. This bit is no longer used. To + // avoid future problems, let's normalize the flag once and for + // all here. + + if (cdInf[i].cd & LOCAL_PERM) + cdInf[i].cd = 0; + else if (cdInf[i].cd & CD1) + cdInf[i].cd = 1; + else if (cdInf[i].cd & CD2) + cdInf[i].cd = 2; + else + cdInf[i].cd = 0; + } + + file.close(); + + for (i = 0; i < _totalClusters; i++) { + for (j = 0; j < _totalClusters; j++) { + if (scumm_stricmp((char *)cdInf[j].clusterName, _resFiles[i].fileName) == 0) + break; + } + + if (j == _totalClusters) + error("%s is not in cd.inf", _resFiles[i].fileName); + + _resFiles[i].cd = cdInf[j].cd; + } + + delete [] cdInf; + + debug(1, "%d resources in %d cluster files", _totalResFiles, _totalClusters); + for (i = 0; i < _totalClusters; i++) + debug(2, "filename of cluster %d: -%s (%d)", i, _resFiles[i].fileName, _resFiles[i].cd); + + _resList = (Resource *)malloc(_totalResFiles * sizeof(Resource)); + + for (i = 0; i < _totalResFiles; i++) { + _resList[i].ptr = NULL; + _resList[i].size = 0; + _resList[i].refCount = 0; + _resList[i].prev = _resList[i].next = NULL; + } + _cacheStart = _cacheEnd = NULL; + _usedMem = 0; +} + +ResourceManager::~ResourceManager() { + Resource *res = _cacheStart; + while (res) { + _vm->_memory->memFree(res->ptr); + res = res->next; + } + for (uint i = 0; i < _totalClusters; i++) + free(_resFiles[i].entryTab); + free(_resList); + free(_resConvTable); +} + +/** + * Returns the address of a resource. Loads if not in memory. Retains a count. + */ + +byte *ResourceManager::openResource(uint32 res, bool dump) { + assert(res < _totalResFiles); + + // Is the resource in memory already? If not, load it. + + if (!_resList[res].ptr) { + // Fetch the correct file and read in the correct portion. + uint16 cluFileNum = _resConvTable[res * 2]; // points to the number of the ascii filename + assert(cluFileNum != 0xffff); + + // Relative resource within the file + // First we have to find the file via the _resConvTable + uint16 actual_res = _resConvTable[(res * 2) + 1]; + + debug(5, "openResource %s res %d", _resFiles[cluFileNum].fileName, res); + + // If we're loading a cluster that's only available from one + // of the CDs, remember which one so that we can play the + // correct speech and music. + + setCD(_resFiles[cluFileNum].cd); + + // Actually, as long as the file can be found we don't really + // care which CD it's on. But if we can't find it, keep asking + // for the CD until we do. + + Common::File *file = openCluFile(cluFileNum); + + if (_resFiles[cluFileNum].entryTab == NULL) { + // we didn't read from this file before, get its index table + readCluIndex(cluFileNum, file); + } + + uint32 pos = _resFiles[cluFileNum].entryTab[actual_res * 2 + 0]; + uint32 len = _resFiles[cluFileNum].entryTab[actual_res * 2 + 1]; + + file->seek(pos, SEEK_SET); + + debug(6, "res len %d", len); + + // Ok, we know the length so try and allocate the memory. + _resList[res].ptr = _vm->_memory->memAlloc(len, res); + _resList[res].size = len; + _resList[res].refCount = 0; + + file->read(_resList[res].ptr, len); + + debug(3, "Loaded resource '%s' from '%s' on CD %d (%d)", fetchName(_resList[res].ptr), _resFiles[cluFileNum].fileName, getCD(), _resFiles[cluFileNum].cd); + + if (dump) { + char buf[256]; + const char *tag; + Common::File out; + + switch (fetchType(_resList[res].ptr)) { + case ANIMATION_FILE: + tag = "anim"; + break; + case SCREEN_FILE: + tag = "layer"; + break; + case GAME_OBJECT: + tag = "object"; + break; + case WALK_GRID_FILE: + tag = "walkgrid"; + break; + case GLOBAL_VAR_FILE: + tag = "globals"; + break; + case PARALLAX_FILE_null: + tag = "parallax"; // Not used! + break; + case RUN_LIST: + tag = "runlist"; + break; + case TEXT_FILE: + tag = "text"; + break; + case SCREEN_MANAGER: + tag = "screen"; + break; + case MOUSE_FILE: + tag = "mouse"; + break; + case WAV_FILE: + tag = "wav"; + break; + case ICON_FILE: + tag = "icon"; + break; + case PALETTE_FILE: + tag = "palette"; + break; + default: + tag = "unknown"; + break; + } + +#if defined(MACOS_CARBON) + sprintf(buf, ":dumps:%s-%d.dmp", tag, res); +#else + sprintf(buf, "dumps/%s-%d.dmp", tag, res); +#endif + + if (!out.exists(buf, "")) { + if (out.open(buf, Common::File::kFileWriteMode, "")) + out.write(_resList[res].ptr, len); + } + } + + // close the cluster + file->close(); + delete file; + + _usedMem += len; + checkMemUsage(); + } else if (_resList[res].refCount == 0) + removeFromCacheList(_resList + res); + + _resList[res].refCount++; + + return _resList[res].ptr; +} + +void ResourceManager::closeResource(uint32 res) { + assert(res < _totalResFiles); + + // Don't try to close the resource if it has already been forcibly + // closed, e.g. by fnResetGlobals(). + + if (_resList[res].ptr == NULL) + return; + + assert(_resList[res].refCount > 0); + + _resList[res].refCount--; + if (_resList[res].refCount == 0) + addToCacheList(_resList + res); + + // It's tempting to free the resource immediately when refCount + // reaches zero, but that'd be a mistake. Closing a resource does not + // mean "I'm not going to use this resource any more". It means that + // "the next time I use this resource I'm going to ask for a new + // pointer to it". + // + // Since the original memory manager had to deal with memory + // fragmentation, keeping a resource open - and thus locked down to a + // specific memory address - was considered a bad thing. +} + +void ResourceManager::removeFromCacheList(Resource *res) { + if (_cacheStart == res) + _cacheStart = res->next; + + if (_cacheEnd == res) + _cacheEnd = res->prev; + + if (res->prev) + res->prev->next = res->next; + if (res->next) + res->next->prev = res->prev; + res->prev = res->next = NULL; +} + +void ResourceManager::addToCacheList(Resource *res) { + res->prev = NULL; + res->next = _cacheStart; + if (_cacheStart) + _cacheStart->prev = res; + _cacheStart = res; + if (!_cacheEnd) + _cacheEnd = res; +} + +Common::File *ResourceManager::openCluFile(uint16 fileNum) { + Common::File *file = new Common::File; + while (!file->open(_resFiles[fileNum].fileName)) { + // HACK: We have to check for this, or it'll be impossible to + // quit while the game is asking for the user to insert a CD. + // But recovering from this situation gracefully is just too + // much trouble, so quit now. + if (_vm->_quit) + g_system->quit(); + + // If the file is supposed to be on hard disk, or we're + // playing a demo, then we're in trouble if the file + // can't be found! + + if ((_vm->_features & GF_DEMO) || _resFiles[fileNum].cd == 0) + error("Could not find '%s'", _resFiles[fileNum].fileName); + + askForCD(_resFiles[fileNum].cd); + } + return file; +} + +void ResourceManager::readCluIndex(uint16 fileNum, Common::File *file) { + if (_resFiles[fileNum].entryTab == NULL) { + // we didn't read from this file before, get its index table + if (file == NULL) + file = openCluFile(fileNum); + else + file->incRef(); + + // 1st DWORD of a cluster is an offset to the look-up table + uint32 table_offset = file->readUint32LE(); + debug(6, "table offset = %d", table_offset); + uint32 tableSize = file->size() - table_offset; // the table is stored at the end of the file + file->seek(table_offset); + + assert((tableSize % 8) == 0); + _resFiles[fileNum].entryTab = (uint32*)malloc(tableSize); + _resFiles[fileNum].numEntries = tableSize / 8; + file->read(_resFiles[fileNum].entryTab, tableSize); + if (file->ioFailed()) + error("unable to read index table from file %s\n", _resFiles[fileNum].fileName); +#ifdef SCUMM_BIG_ENDIAN + for (int tabCnt = 0; tabCnt < _resFiles[fileNum].numEntries * 2; tabCnt++) + _resFiles[fileNum].entryTab[tabCnt] = FROM_LE_32(_resFiles[fileNum].entryTab[tabCnt]); +#endif + file->decRef(); + } +} + +/** + * Returns true if resource is valid, otherwise false. + */ + +bool ResourceManager::checkValid(uint32 res) { + // Resource number out of range + if (res >= _totalResFiles) + return false; + + // Points to the number of the ascii filename + uint16 parent_res_file = _resConvTable[res * 2]; + + // Null & void resource + if (parent_res_file == 0xffff) + return false; + + return true; +} + +/** + * Returns the total file length of a resource - i.e. all headers are included + * too. + */ + +uint32 ResourceManager::fetchLen(uint32 res) { + if (_resList[res].ptr) + return _resList[res].size; + + // Does this ever happen? + warning("fetchLen: Resource %u is not loaded; reading length from file", res); + + // Points to the number of the ascii filename + uint16 parent_res_file = _resConvTable[res * 2]; + + // relative resource within the file + uint16 actual_res = _resConvTable[(res * 2) + 1]; + + // first we have to find the file via the _resConvTable + // open the cluster file + + if (_resFiles[parent_res_file].entryTab == NULL) { + readCluIndex(parent_res_file); + } + return _resFiles[parent_res_file].entryTab[actual_res * 2 + 1]; +} + +void ResourceManager::checkMemUsage() { + while (_usedMem > MAX_MEM_CACHE) { + // we're using up more memory than we wanted to. free some old stuff. + // Newly loaded objects are added to the start of the list, + // we start freeing from the end, to free the oldest items first + if (_cacheEnd) { + Resource *tmp = _cacheEnd; + assert((tmp->refCount == 0) && (tmp->ptr) && (tmp->next == NULL)); + removeFromCacheList(tmp); + + _vm->_memory->memFree(tmp->ptr); + tmp->ptr = NULL; + _usedMem -= tmp->size; + } else { + warning("%d bytes of memory used, but cache list is empty!\n"); + return; + } + } +} + +void ResourceManager::remove(int res) { + if (_resList[res].ptr) { + removeFromCacheList(_resList + res); + + _vm->_memory->memFree(_resList[res].ptr); + _resList[res].ptr = NULL; + _resList[res].refCount = 0; + _usedMem -= _resList[res].size; + } +} + +/** + * Remove all res files from memory - ready for a total restart. This includes + * the player object and global variables resource. + */ + +void ResourceManager::removeAll() { + // We need to clear the FX queue, because otherwise the sound system + // will still believe that the sound resources are in memory, and that + // it's ok to close them. + + _vm->_sound->clearFxQueue(); + + for (uint i = 0; i < _totalResFiles; i++) + remove(i); +} + +/** + * Remove all resources from memory. + */ + +void ResourceManager::killAll(bool wantInfo) { + int nuked = 0; + + // We need to clear the FX queue, because otherwise the sound system + // will still believe that the sound resources are in memory, and that + // it's ok to close them. + + _vm->_sound->clearFxQueue(); + + for (uint i = 0; i < _totalResFiles; i++) { + // Don't nuke the global variables or the player object! + if (i == 1 || i == CUR_PLAYER_ID) + continue; + + if (_resList[i].ptr) { + if (wantInfo) + Debug_Printf("Nuked %5d: %s\n", i, fetchName(_resList[i].ptr)); + + remove(i); + nuked++; + } + } + + if (wantInfo) + Debug_Printf("Expelled %d resources\n", nuked); +} + +/** + * Like killAll but only kills objects (except George & the variable table of + * course) - ie. forcing them to reload & restart their scripts, which + * simulates the effect of a save & restore, thus checking that each object's + * re-entrant logic works correctly, and doesn't cause a statuette to + * disappear forever, or some plaster-filled holes in sand to crash the game & + * get James in trouble again. + */ + +void ResourceManager::killAllObjects(bool wantInfo) { + int nuked = 0; + + for (uint i = 0; i < _totalResFiles; i++) { + // Don't nuke the global variables or the player object! + if (i == 1 || i == CUR_PLAYER_ID) + continue; + + if (_resList[i].ptr) { + if (fetchType(_resList[i].ptr) == GAME_OBJECT) { + if (wantInfo) + Debug_Printf("Nuked %5d: %s\n", i, fetchName(_resList[i].ptr)); + + remove(i); + nuked++; + } + } + } + + if (wantInfo) + Debug_Printf("Expelled %d resources\n", nuked); +} + +void ResourceManager::askForCD(int cd) { + byte *textRes; + + // Stop any music from playing - so the system no longer needs the + // current CD - otherwise when we take out the CD, Windows will + // complain! + + _vm->_sound->stopMusic(true); + + textRes = openResource(2283); + _vm->_screen->displayMsg(_vm->fetchTextLine(textRes, 5 + cd) + 2, 0); + closeResource(2283); + + // The original code probably determined automagically when the correct + // CD had been inserted, but our backend doesn't support that, and + // anyway I don't know if all systems allow that sort of thing. So we + // wait for the user to press any key instead, or click the mouse. + // + // But just in case we ever try to identify the CDs by their labels, + // they should be: + // + // CD1: "RBSII1" (or "PCF76" for the PCF76 version, whatever that is) + // CD2: "RBSII2" +} + +} // End of namespace Sword2 diff --git a/engines/sword2/resman.h b/engines/sword2/resman.h new file mode 100644 index 0000000000..18b5cb8765 --- /dev/null +++ b/engines/sword2/resman.h @@ -0,0 +1,134 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef RESMAN_H +#define RESMAN_H + +namespace Common { + class File; +} + +#define MAX_MEM_CACHE (8 * 1024 * 1024) // we keep up to 8 megs of resource data files in memory +#define MAX_res_files 20 + +namespace Sword2 { + +class Sword2Engine; + +struct Resource { + byte *ptr; + uint32 size; + uint32 refCount; + Resource *next, *prev; +}; + +struct ResourceFile { + char fileName[20]; + int32 numEntries; + uint32 *entryTab; + uint8 cd; +}; + +class ResourceManager { +private: + Common::File *openCluFile(uint16 fileNum); + void readCluIndex(uint16 fileNum, Common::File *file = NULL); + void removeFromCacheList(Resource *res); + void addToCacheList(Resource *res); + void checkMemUsage(); + + Sword2Engine *_vm; + + int _curCD; + uint32 _totalResFiles; + uint32 _totalClusters; + + // Gode generated res-id to res number/rel number conversion table + + uint16 *_resConvTable; + ResourceFile _resFiles[MAX_res_files]; + Resource *_resList; + + Resource *_cacheStart, *_cacheEnd; + uint32 _usedMem; // amount of used memory in bytes + +public: + ResourceManager(Sword2Engine *vm); // read in the config file + ~ResourceManager(); + + uint32 getNumResFiles() { return _totalResFiles; } + uint32 getNumClusters() { return _totalClusters; } + ResourceFile *getResFiles() { return _resFiles; } + Resource *getResList() { return _resList; } + + byte *openResource(uint32 res, bool dump = false); + void closeResource(uint32 res); + + bool checkValid(uint32 res); + uint32 fetchLen(uint32 res); + uint8 fetchType(uint32 res) { + byte *ptr = openResource(res); + uint8 type = ptr[0]; + closeResource(res); + + return type; + } + + uint8 fetchType(byte *ptr) { + return ptr[0]; + } + + byte *fetchName(uint32 res, byte *buf) { + byte *ptr = openResource(res); + memcpy(buf, ptr + 10, NAME_LEN); + closeResource(res); + + return buf; + } + + byte *fetchName(byte *ptr) { + return ptr + 10; + } + + // Prompts the user for the specified CD. + void askForCD(int cd); + + void setCD(int cd) { + if (cd) + _curCD = cd; + } + + int getCD() { + return _curCD; + } + + void remove(int res); + void removeAll(); + + // ----console commands + + void killAll(bool wantInfo); + void killAllObjects(bool wantInfo); +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/router.cpp b/engines/sword2/router.cpp new file mode 100644 index 0000000000..bbca609e3c --- /dev/null +++ b/engines/sword2/router.cpp @@ -0,0 +1,2506 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +// --------------------------------------------------------------------------- +// ROUTER.CPP by James +// +// A rehash of Jeremy's original jrouter.c, containing low-level system +// routines for calculating routes between points inside a walk-grid, and +// constructing walk animations from mega-sets. +// +// jrouter.c underwent 2 major reworks from the original: +// (1) Restructured to allow more flexibility in the mega-sets, ie. more info +// taken from the walk-data +// - the new George & Nico mega-sets & walk-data were then tested & +// tweaked in the Sword1 system +// (2) Updated for the new Sword2 system, ie. new object structures +// - now compatible with Sword2, the essential code already having been +// tested +// +// --------------------------------------------------------------------------- + +/**************************************************************************** + * JROUTER.C polygon router with modular walks + * using a tree of modules + * 21 july 94 + * 3 november 94 + * System currently works by scanning grid data and coming up with a ROUTE + * as a series of way points(nodes), the smoothest eight directional PATH + * through these nodes is then found, and a WALK created to fit the PATH. + * + * Two funtions are called by the user, RouteFinder creates a route as a + * module list, HardWalk creates an animation list from the module list. + * The split is only provided to allow the possibility of turning the + * autorouter over two game cycles. + **************************************************************************** + * + * Routine timings on osborne 486 + * + * Read floor resource (file already loaded) 112 pixels + * + * Read mega resource (file already loaded) 112 pixels + * + * + * + **************************************************************************** + * + * Modified 12 Oct 95 + * + * Target Points within 1 pixel of a line are ignored ??? + * + * Modules split into Points within 1 pixel of a line are ignored ??? + * + **************************************************************************** + * + * TOTALLY REHASHED BY JAMES FOR NEW MEGAS USING OLD SYSTEM + * THEN REINCARNATED BY JAMES FOR NEW MEGAS USING NEW SYSTEM + * + ****************************************************************************/ + +#include "common/stdafx.h" +#include "common/stream.h" +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/resman.h" +#include "sword2/router.h" + +namespace Sword2 { + +//---------------------------------------------------------- +// (4) WALK-GRID FILES +//---------------------------------------------------------- +// a walk-grid file consists of: +// +// standard file header +// walk-grid file header +// walk-grid data + +// Walk-Grid Header - taken directly from old "header.h" in STD_INC + +struct WalkGridHeader { + int32 numBars; // number of bars on the floor + int32 numNodes; // number of nodes +}; + +uint8 Router::returnSlotNo(uint32 megaId) { + if (_vm->_logic->readVar(ID) == CUR_PLAYER_ID) { + // George (8) + return 0; + } else { + // One of Nico's mega id's + return 1; + } +} + +void Router::allocateRouteMem() { + uint8 slotNo; + + // Player character always always slot 0, while the other mega + // (normally Nico) always uses slot 1 + // Better this way, so that if mega object removed from memory while + // in middle of route, the old route will be safely cleared from + // memory just before they create a new one + + slotNo = returnSlotNo(_vm->_logic->readVar(ID)); + + // if this slot is already used, then it can't be needed any more + // because this id is creating a new route! + + if (_routeSlots[slotNo]) + freeRouteMem(); + + _routeSlots[slotNo] = (WalkData *)malloc(sizeof(WalkData) * O_WALKANIM_SIZE); + + // 12000 bytes were used for this in Sword1 mega compacts, based on + // 20 bytes per 'WalkData' frame + // ie. allowing for 600 frames including end-marker + // Now 'WalkData' is 8 bytes, so 8*600 = 4800 bytes. + // Note that a 600 frame walk lasts about 48 seconds! + // (600fps / 12.5s = 48s) + + // mega keeps note of which slot contains the pointer to it's walk + // animation mem block + // +1 so that '0' can mean "not walking" + // megaObject->route_slot_id = slotNo + 1; +} + +WalkData *Router::getRouteMem() { + uint8 slotNo = returnSlotNo(_vm->_logic->readVar(ID)); + + return (WalkData *)_routeSlots[slotNo]; +} + +void Router::freeRouteMem() { + uint8 slotNo = returnSlotNo(_vm->_logic->readVar(ID)); + + free(_routeSlots[slotNo]); + _routeSlots[slotNo] = NULL; +} + +void Router::freeAllRouteMem() { + for (int i = 0; i < TOTAL_ROUTE_SLOTS; i++) { + free(_routeSlots[i]); + _routeSlots[i] = NULL; + } +} + +int32 Router::routeFinder(byte *ob_mega, byte *ob_walkdata, int32 x, int32 y, int32 dir) { + /********************************************************************* + * RouteFinder.C polygon router with modular walks + * 21 august 94 + * 3 november 94 + * routeFinder creates a list of modules that enables HardWalk to + * create an animation list. + * + * routeFinder currently works by scanning grid data and coming up + * with a ROUTE as a series of way points(nodes), the smoothest eight + * directional PATH through these nodes is then found, this + * information is made available to HardWalk for a WALK to be created + * to fit the PATH. + * + * 30 november 94 return values modified + * + * return 0 = failed to find a route + * + * 1 = found a route + * + * 2 = mega already at target + * + *********************************************************************/ + + int32 routeFlag = 0; + int32 solidFlag = 0; + WalkData *walkAnim; + + // megaId = id; + + setUpWalkGrid(ob_mega, x, y, dir); + loadWalkData(ob_walkdata); + + walkAnim = getRouteMem(); + + // All route data now loaded start finding a route + + // Check if we can get a route through the floor. changed 12 Oct95 JPS + + routeFlag = getRoute(); + + switch (routeFlag) { + case 2: + // special case for zero length route + + // if target direction specified as any + if (_targetDir > 7) + _targetDir = _startDir; + + // just a turn on the spot is required set an end module for + // the route let the animator deal with it + // modularPath is normally set by extractRoute + + _modularPath[0].dir = _startDir; + _modularPath[0].num = 0; + _modularPath[0].x = _startX; + _modularPath[0].y = _startY; + _modularPath[1].dir = _targetDir; + _modularPath[1].num = 0; + _modularPath[1].x = _startX; + _modularPath[1].y = _startY; + _modularPath[2].dir = 9; + _modularPath[2].num = ROUTE_END_FLAG; + + slidyWalkAnimator(walkAnim); + routeFlag = 2; + break; + case 1: + // A normal route. Convert the route to an exact path + smoothestPath(); + + // The Route had waypoints and direction options + + // The Path is an exact set of lines in 8 directions that + // reach the target. + + // The path is in module format, but steps taken in each + // direction are not accurate + + // if target dir = 8 then the walk isn't linked to an anim so + // we can create a route without sliding and miss the exact + // target + +#ifndef FORCE_SLIDY + if (_targetDir == 8) { + // can end facing ANY direction (ie. exact end + // position not vital) - so use SOLID walk to + // avoid sliding to exact position + + solidPath(); + solidFlag = solidWalkAnimator(walkAnim); + } +#endif + + if (!solidFlag) { + // if we failed to create a SOLID route, do a SLIDY + // one instead + + slidyPath(); + slidyWalkAnimator(walkAnim); + } + + break; + default: + // Route didn't reach target so assume point was off the floor + // routeFlag = 0; + break; + } + + return routeFlag; // send back null route +} + +int32 Router::getRoute() { + /********************************************************************* + * GetRoute.C extract a path from walk grid + * 12 october 94 + * + * GetRoute currently works by scanning grid data and coming up with + * a ROUTE as a series of way points(nodes). + * + * static routeData _route[O_ROUTE_SIZE]; + * + * return 0 = failed to find a route + * + * 1 = found a route + * + * 2 = mega already at target + * + * 3 = failed to find a route because target was on a line + * + *********************************************************************/ + + int32 routeGot = 0; + + if (_startX == _targetX && _startY == _targetY) + routeGot = 2; + else { + // 'else' added by JEL (23jan96) otherwise 'routeGot' affected + // even when already set to '2' above - causing some 'turns' + // to walk downwards on the spot + + // returns 3 if target on a line ( +- 1 pixel ) + routeGot = checkTarget(_targetX, _targetY); + } + + if (routeGot == 0) { + // still looking for a route check if target is within a pixel + // of a line + + // scan through the nodes linking each node to its nearest + // neighbour until no more nodes change + + // This is the routine that finds a route using scan() + + int32 level = 1; + + while (scan(level)) + level++; + + // Check to see if the route reached the target + + if (_node[_nNodes].dist < 9999) { + // it did so extract the route as nodes and the + // directions to go between each node + + routeGot = 1; + extractRoute(); + + // route.X,route.Y and route.Dir now hold all the + // route infomation with the target dir or route + // continuation + } + } + + return routeGot; +} + +// THE SLIDY PATH ROUTINES + +int32 Router::smoothestPath() { + // This is the second big part of the route finder and the the only + // bit that tries to be clever (the other bits are clever). + // + // This part of the autorouter creates a list of modules from a set of + // lines running across the screen. The task is complicated by two + // things: + // + // Firstly in choosing a route through the maze of nodes the routine + // tries to minimise the amount of each individual turn avoiding 90 + // degree and greater turns (where possible) and reduces the total + // number of turns (subject to two 45 degree turns being better than + // one 90 degree turn). + // + // Secondly when walking in a given direction the number of steps + // required to reach the end of that run is not calculated accurately. + // This is because I was unable to derive a function to relate number + // of steps taken between two points to the shrunken step size + + int i; + int32 steps = 0; + int32 lastDir; + int32 tempturns[4]; + int32 turns[4]; + int32 turntable[NO_DIRECTIONS] = { 0, 1, 3, 5, 7, 5, 3, 1 }; + + // route.X route.Y and route.Dir start at far end + + _smoothPath[0].x = _startX; + _smoothPath[0].y = _startY; + _smoothPath[0].dir = _startDir; + _smoothPath[0].num = 0; + + lastDir = _startDir; + + // for each section of the route + + for (int p = 0; p < _routeLength; p++) { + int32 dirS = _route[p].dirS; + int32 dirD = _route[p].dirD; + int32 nextDirS = _route[p + 1].dirS; + int32 nextDirD = _route[p + 1].dirD; + + // Check directions into and out of a pair of nodes going in + int32 dS = dirS - lastDir; + if (dS < 0) + dS = dS + NO_DIRECTIONS; + + int32 dD = dirD - lastDir; + if (dD < 0) + dD = dD + NO_DIRECTIONS; + + // coming out + int32 dSS = dirS - nextDirS; + if (dSS < 0) + dSS = dSS + NO_DIRECTIONS; + + int32 dDD = dirD - nextDirD; + if (dDD < 0) + dDD = dDD + NO_DIRECTIONS; + + int32 dSD = dirS - nextDirD; + if (dSD < 0) + dSD = dSD + NO_DIRECTIONS; + + int32 dDS = dirD - nextDirS; + if (dDS < 0) + dDS = dDS + NO_DIRECTIONS; + + // Determine the amount of turning involved in each possible + // path + + dS = turntable[dS]; + dD = turntable[dD]; + dSS = turntable[dSS]; + dDD = turntable[dDD]; + dSD = turntable[dSD]; + dDS = turntable[dDS]; + + // get the best path out ie assume next section uses best + // direction + + if (dSD < dSS) + dSS = dSD; + + if (dDS < dDD) + dDD = dDS; + + // Rate each option. Split routes look crap so weight against + // them + + int32 SS = dS + dSS + 3; + int32 SD = dS + dDD; + int32 DS = dD + dSS; + int32 DD = dD + dDD + 3; + + // set up turns as a sorted array of the turn values + + tempturns[0] = SS; + turns[0] = 0; + tempturns[1] = SD; + turns[1] = 1; + tempturns[2] = DS; + turns[2] = 2; + tempturns[3] = DD; + turns[3] = 3; + + for (i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { + if (tempturns[j] > tempturns[j + 1]) { + SWAP(turns[j], turns[j + 1]); + SWAP(tempturns[j], tempturns[j + 1]); + } + } + } + + // best option matched in order of the priority we would like + // to see on the screen but each option must be checked to see + // if it can be walked + + int32 options = newCheck(1, _route[p].x, _route[p].y, _route[p + 1].x, _route[p + 1].y); + + assert(options); + + i = 0; + steps = 0; + + do { + int32 opt = 1 << turns[i]; + if (options & opt) + steps = smoothCheck(turns[i], p, dirS, dirD); + i++; + } while (steps == 0 && i < 4); + + assert(steps); + + // route.X route.Y route.dir and bestTurns start at far end + } + + // best turns will end heading as near as possible to target dir rest + // is down to anim for now + + _smoothPath[steps].dir = 9; + _smoothPath[steps].num = ROUTE_END_FLAG; + return 1; +} + +int32 Router::smoothCheck(int32 best, int32 p, int32 dirS, int32 dirD) { + /********************************************************************* + * Slip sliding away + * This path checker checks to see if a walk that exactly follows the + * path would be valid. This should be inherently true for atleast one + * of the turn options. + * No longer checks the data it only creates the smoothPath array JPS + *********************************************************************/ + + static int32 k; + int32 dsx, dsy; + int32 ddx, ddy; + int32 ss0, ss1, ss2; + int32 sd0, sd1, sd2; + + if (p == 0) + k = 1; + + int32 x = _route[p].x; + int32 y = _route[p].y; + int32 x2 = _route[p + 1].x; + int32 y2 = _route[p + 1].y; + int32 ldx = x2 - x; + int32 ldy = y2 - y; + int32 dirX = 1; + int32 dirY = 1; + + if (ldx < 0) { + ldx = -ldx; + dirX = -1; + } + + if (ldy < 0) { + ldy = -ldy; + dirY = -1; + } + + // set up sd0-ss2 to reflect possible movement in each direction + + if (dirS == 0 || dirS == 4) { // vert and diag + ddx = ldx; + ddy = (ldx * _diagonaly) / _diagonalx; + dsy = ldy - ddy; + ddx = ddx * dirX; + ddy = ddy * dirY; + dsy = dsy * dirY; + dsx = 0; + + sd0 = (ddx + _modX[dirD] / 2) / _modX[dirD]; + ss0 = (dsy + _modY[dirS] / 2) / _modY[dirS]; + sd1 = sd0 / 2; + ss1 = ss0 / 2; + sd2 = sd0 - sd1; + ss2 = ss0 - ss1; + } else { + ddy = ldy; + ddx = (ldy * _diagonalx) / _diagonaly; + dsx = ldx - ddx; + ddy = ddy * dirY; + ddx = ddx * dirX; + dsx = dsx * dirX; + dsy = 0; + + sd0 = (ddy + _modY[dirD] / 2) / _modY[dirD]; + ss0 = (dsx + _modX[dirS] / 2) / _modX[dirS]; + sd1 = sd0 / 2; + ss1 = ss0 / 2; + sd2 = sd0 - sd1; + ss2 = ss0 - ss1; + } + + switch (best) { + case 0: // halfsquare, diagonal, halfsquare + _smoothPath[k].x = x + dsx / 2; + _smoothPath[k].y = y + dsy / 2; + _smoothPath[k].dir = dirS; + _smoothPath[k].num = ss1; + k++; + + _smoothPath[k].x = x + dsx / 2 + ddx; + _smoothPath[k].y = y + dsy / 2 + ddy; + _smoothPath[k].dir = dirD; + _smoothPath[k].num = sd0; + k++; + + _smoothPath[k].x = x + dsx + ddx; + _smoothPath[k].y = y + dsy + ddy; + _smoothPath[k].dir = dirS; + _smoothPath[k].num = ss2; + k++; + + break; + case 1: // square, diagonal + _smoothPath[k].x = x + dsx; + _smoothPath[k].y = y + dsy; + _smoothPath[k].dir = dirS; + _smoothPath[k].num = ss0; + k++; + + _smoothPath[k].x = x2; + _smoothPath[k].y = y2; + _smoothPath[k].dir = dirD; + _smoothPath[k].num = sd0; + k++; + + break; + case 2: // diagonal square + _smoothPath[k].x = x + ddx; + _smoothPath[k].y = y + ddy; + _smoothPath[k].dir = dirD; + _smoothPath[k].num = sd0; + k++; + + _smoothPath[k].x = x2; + _smoothPath[k].y = y2; + _smoothPath[k].dir = dirS; + _smoothPath[k].num = ss0; + k++; + + break; + default: // halfdiagonal, square, halfdiagonal + _smoothPath[k].x = x + ddx / 2; + _smoothPath[k].y = y + ddy / 2; + _smoothPath[k].dir = dirD; + _smoothPath[k].num = sd1; + k++; + + _smoothPath[k].x = x + dsx + ddx / 2; + _smoothPath[k].y = y + dsy + ddy / 2; + _smoothPath[k].dir = dirS; + _smoothPath[k].num = ss0; + k++; + + _smoothPath[k].x = x2; + _smoothPath[k].y = y2; + _smoothPath[k].dir = dirD; + _smoothPath[k].num = sd2; + k++; + + break; + } + + return k; +} + +void Router::slidyPath() { + /********************************************************************* + * slidyPath creates a path based on part steps with no sliding to get + * as near as possible to the target without any sliding this routine + * is intended for use when just clicking about. + * + * produce a module list from the line data + *********************************************************************/ + + int32 smooth = 1; + int32 slidy = 1; + + // strip out the short sections + + _modularPath[0].x = _smoothPath[0].x; + _modularPath[0].y = _smoothPath[0].y; + _modularPath[0].dir = _smoothPath[0].dir; + _modularPath[0].num = 0; + + while (_smoothPath[smooth].num < ROUTE_END_FLAG) { + int32 scale = _scaleA * _smoothPath[smooth].y + _scaleB; + int32 deltaX = _smoothPath[smooth].x - _modularPath[slidy - 1].x; + int32 deltaY = _smoothPath[smooth].y - _modularPath[slidy - 1].y; + // quarter a step minimum + int32 stepX = (scale * _modX[_smoothPath[smooth].dir]) >> 19; + int32 stepY = (scale * _modY[_smoothPath[smooth].dir]) >> 19; + + if (ABS(deltaX) >= ABS(stepX) && ABS(deltaY) >= ABS(stepY)) { + _modularPath[slidy].x = _smoothPath[smooth].x; + _modularPath[slidy].y = _smoothPath[smooth].y; + _modularPath[slidy].dir = _smoothPath[smooth].dir; + _modularPath[slidy].num = 1; + slidy++; + } + smooth++; + } + + // in case the last bit had no steps + + if (slidy > 1) { + _modularPath[slidy - 1].x = _smoothPath[smooth - 1].x; + _modularPath[slidy - 1].y = _smoothPath[smooth - 1].y; + } + + // set up the end of the walk + + _modularPath[slidy].x = _smoothPath[smooth - 1].x; + _modularPath[slidy].y = _smoothPath[smooth - 1].y; + _modularPath[slidy].dir = _targetDir; + _modularPath[slidy].num = 0; + slidy++; + + _modularPath[slidy].x = _smoothPath[smooth - 1].x; + _modularPath[slidy].y = _smoothPath[smooth - 1].y; + _modularPath[slidy].dir = 9; + _modularPath[slidy].num = ROUTE_END_FLAG; + slidy++; +} + +// SLOW IN + +bool Router::addSlowInFrames(WalkData *walkAnim) { + if (_walkData.usingSlowInFrames && _modularPath[1].num > 0) { + for (int slowInFrameNo = 0; slowInFrameNo < _walkData.nSlowInFrames[_currentDir]; slowInFrameNo++) { + walkAnim[_stepCount].frame = _firstSlowInFrame[_currentDir] + slowInFrameNo; + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = _currentDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + } + return true; + } + + return false; +} + +void Router::earlySlowOut(byte *ob_mega, byte *ob_walkdata) { + int32 slowOutFrameNo; + int32 walk_pc; + WalkData *walkAnim; + + ObjectMega obMega(ob_mega); + + debug(5, "EARLY SLOW-OUT"); + + loadWalkData(ob_walkdata); + + debug(5, "********************************"); + debug(5, "_framesPerStep = %d", _framesPerStep); + debug(5, "_numberOfSlowOutFrames = %d", _numberOfSlowOutFrames); + debug(5, "_firstWalkingTurnLeftFrame = %d", _firstWalkingTurnLeftFrame); + debug(5, "_firstWalkingTurnRightFrame = %d", _firstWalkingTurnRightFrame); + debug(5, "_firstSlowOutFrame = %d", _firstSlowOutFrame); + debug(5, "********************************"); + + walk_pc = obMega.getWalkPc(); + + walkAnim = getRouteMem(); + + // if this mega does actually have slow-out frames + if (_walkData.usingSlowOutFrames) { + // overwrite the next step (half a cycle) of the walk + // (ie .step - 0..5) + + do { + debug(5, "STEP NUMBER: walkAnim[%d].step = %d", walk_pc, walkAnim[walk_pc].step); + debug(5, "ORIGINAL FRAME: walkAnim[%d].frame = %d", walk_pc, walkAnim[walk_pc].frame); + + // map from existing walk frame across to correct + // frame number of slow-out - remember, there may be + // more slow-out frames than walk-frames! + + if (walkAnim[walk_pc].frame >= _firstWalkingTurnRightFrame) { + // if it's a walking turn-right, rather than a + // normal step, then map it to a normal step + // frame first + + walkAnim[walk_pc].frame -= _firstWalkingTurnRightFrame; + debug(5, "MAPPED TO WALK: walkAnim[%d].frame = %d (walking turn-right frame --> walk frame)", walk_pc, walkAnim[walk_pc].frame); + } else if (walkAnim[walk_pc].frame >= _firstWalkingTurnLeftFrame) { + // if it's a walking turn-left, rather than a + // normal step, then map it to a normal step + // frame first + + walkAnim[walk_pc].frame -= _firstWalkingTurnLeftFrame; + debug(5, "MAPPED TO WALK: walkAnim[%d].frame = %d (walking turn-left frame --> walk frame)", walk_pc, walkAnim[walk_pc].frame); + } + + walkAnim[walk_pc].frame += _firstSlowOutFrame + ((walkAnim[walk_pc].frame / _framesPerStep) * (_numberOfSlowOutFrames - _framesPerStep)); + walkAnim[walk_pc].step = 0; + debug(5, "SLOW-OUT FRAME: walkAnim[%d].frame = %d",walk_pc, walkAnim[walk_pc].frame); + walk_pc++; + } while (walkAnim[walk_pc].step > 0); + + // add stationary frame(s) (OPTIONAL) + + for (slowOutFrameNo = _framesPerStep; slowOutFrameNo < _numberOfSlowOutFrames; slowOutFrameNo++) { + walkAnim[walk_pc].frame = walkAnim[walk_pc - 1].frame + 1; + debug(5, "EXTRA FRAME: walkAnim[%d].frame = %d", walk_pc, walkAnim[walk_pc].frame); + walkAnim[walk_pc].step = 0; + walkAnim[walk_pc].dir = walkAnim[walk_pc - 1].dir; + walkAnim[walk_pc].x = walkAnim[walk_pc - 1].x; + walkAnim[walk_pc].y = walkAnim[walk_pc - 1].y; + walk_pc++; + } + } else { + // this mega doesn't have slow-out frames + // stand in current direction + + walkAnim[walk_pc].frame = _firstStandFrame + walkAnim[walk_pc - 1].dir; + walkAnim[walk_pc].step = 0; + walkAnim[walk_pc].dir = walkAnim[walk_pc - 1].dir; + walkAnim[walk_pc].x = walkAnim[walk_pc - 1].x; + walkAnim[walk_pc].y = walkAnim[walk_pc - 1].y; + walk_pc++; + } + + // end of sequence + walkAnim[walk_pc].frame = 512; + + // so that this doesn't happen again while 'george_walking' is still + // '2' + walkAnim[walk_pc].step = 99; +} + +// SLOW OUT + +void Router::addSlowOutFrames(WalkData *walkAnim) { + int32 slowOutFrameNo; + + // if the mega did actually walk, we overwrite the last step (half a + // cycle) with slow-out frames + add any necessary stationary frames + + if (_walkData.usingSlowOutFrames && _lastCount >= _framesPerStep) { + // place stop frames here + // slowdown at the end of the last walk + + slowOutFrameNo = _lastCount - _framesPerStep; + + debug(5, "SLOW OUT: slowOutFrameNo(%d) = _lastCount(%d) - _framesPerStep(%d)", slowOutFrameNo, _lastCount, _framesPerStep); + + // overwrite the last step (half a cycle) of the walk + + do { + // map from existing walk frame across to correct + // frame number of slow-out - remember, there may be + // more slow-out frames than walk-frames! + + walkAnim[slowOutFrameNo].frame += _firstSlowOutFrame + ((walkAnim[slowOutFrameNo].frame / _framesPerStep) * (_numberOfSlowOutFrames - _framesPerStep)); + + // because no longer a normal walk-step + walkAnim[slowOutFrameNo].step = 0; + + debug(5, "walkAnim[%d].frame = %d",slowOutFrameNo,walkAnim[slowOutFrameNo].frame); + slowOutFrameNo++; + } while (slowOutFrameNo < _lastCount); + + // add stationary frame(s) (OPTIONAL) + + for (slowOutFrameNo = _framesPerStep; slowOutFrameNo < _numberOfSlowOutFrames; slowOutFrameNo++) { + walkAnim[_stepCount].frame = walkAnim[_stepCount - 1].frame + 1; + + debug(5, "EXTRA FRAMES: walkAnim[%d].frame = %d", _stepCount, walkAnim[_stepCount].frame); + + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = walkAnim[_stepCount - 1].dir; + walkAnim[_stepCount].x = walkAnim[_stepCount - 1].x; + walkAnim[_stepCount].y = walkAnim[_stepCount - 1].y; + _stepCount++; + } + } +} + +void Router::slidyWalkAnimator(WalkData *walkAnim) { + /********************************************************************* + * Skidding every where HardWalk creates an animation that exactly + * fits the smoothPath and uses foot slipping to fit whole steps into + * the route + * + * Parameters: georgeg, mouseg + * Returns: rout + * + * produce a module list from the line data + *********************************************************************/ + + static int32 left = 0; + int32 p; + int32 lastDir; + int32 lastRealDir; + int32 turnDir; + int32 scale; + int32 step; + int32 module; + int32 moduleEnd; + int32 module16X; + int32 module16Y; + int32 stepX; + int32 stepY; + int32 errorX; + int32 errorY; + int32 lastErrorX; + int32 lastErrorY; + int32 frameCount; + int32 frames; + + p = 0; + lastDir = _modularPath[0].dir; + _currentDir = _modularPath[1].dir; + + if (_currentDir == NO_DIRECTIONS) + _currentDir = lastDir; + + _moduleX = _startX; + _moduleY = _startY; + module16X = _moduleX << 16; + module16Y = _moduleY << 16; + _stepCount = 0; + + // START THE WALK WITH THE FIRST STANDFRAME THIS MAY CAUSE A DELAY + // BUT IT STOPS THE PLAYER MOVING FOR COLLISIONS ARE DETECTED + + debug(5, "SLIDY: STARTING THE WALK"); + + module = _framesPerChar + lastDir; + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = lastDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + + // TURN TO START THE WALK + + debug(5, "SLIDY: TURNING TO START THE WALK"); + // rotate if we need to + + if (lastDir != _currentDir) { + // get the direction to turn + turnDir = _currentDir - lastDir; + if (turnDir < 0) + turnDir += NO_DIRECTIONS; + + if (turnDir > 4) + turnDir = -1; + else if (turnDir > 0) + turnDir = 1; + + // rotate to new walk direction + // for george and nico put in a head turn at the start + + if (_walkData.usingStandingTurnFrames) { + // new frames for turn frames 29oct95jps + if (turnDir < 0) + module = _firstStandingTurnLeftFrame + lastDir; + else + module = _firstStandingTurnRightFrame + lastDir; + + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = lastDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + } + + // rotate till were facing new dir then go back 45 degrees + while (lastDir != _currentDir) { + lastDir += turnDir; + + // new frames for turn frames 29oct95jps + if (turnDir < 0) { + if ( lastDir < 0) + lastDir += NO_DIRECTIONS; + module = _firstStandingTurnLeftFrame + lastDir; + } else { + if ( lastDir > 7) + lastDir -= NO_DIRECTIONS; + module = _firstStandingTurnRightFrame + lastDir; + } + + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = lastDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + } + + // the back 45 degrees bit + // step back one because new head turn for george takes us + // past the new dir + _stepCount--; + } + + // his head is in the right direction + lastRealDir = _currentDir; + + // SLIDY: THE SLOW IN + + addSlowInFrames(walkAnim); + + // THE WALK + + debug(5, "SLIDY: THE WALK"); + + // start the walk on the left or right leg, depending on how the + // slow-in frames were drawn + + // (0 = left; 1 = right) + + if (_walkData.leadingLeg[_currentDir] == 0) { + // start the walk on the left leg (ie. at beginning of the + // first step of the walk cycle) + left = 0; + } else { + // start the walk on the right leg (ie. at beginning of the + // second step of the walk cycle) + left = _framesPerStep; + } + + _lastCount = _stepCount; + + // this ensures that we don't put in turn frames for the start + lastDir = 99; + + // this ensures that we don't put in turn frames for the start + _currentDir = 99; + + do { + assert(_stepCount < O_WALKANIM_SIZE); + while (_modularPath[p].num == 0) { + p++; + if (_currentDir != 99) + lastRealDir = _currentDir; + lastDir = _currentDir; + _lastCount = _stepCount; + } + + // calculate average amount to lose in each step on the way + // to the next node + + _currentDir = _modularPath[p].dir; + + if (_currentDir < NO_DIRECTIONS) { + module = _currentDir * _framesPerStep * 2 + left; + + if (left == 0) + left = _framesPerStep; + else + left = 0; + + moduleEnd = module + _framesPerStep; + step = 0; + scale = (_scaleA * _moduleY + _scaleB); + + do { + module16X += _walkData.dx[module] * scale; + module16Y += _walkData.dy[module] * scale; + _moduleX = module16X >> 16; + _moduleY = module16Y >> 16; + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = step; // normally 0,1,2,3,4,5,0,1,2,etc + walkAnim[_stepCount].dir = _currentDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + step++; + module++; + } while (module < moduleEnd); + + stepX = _modX[_modularPath[p].dir]; + stepY = _modY[_modularPath[p].dir]; + errorX = _modularPath[p].x - _moduleX; + errorX = errorX * stepX; + errorY = _modularPath[p].y - _moduleY; + errorY = errorY * stepY; + + if (errorX < 0 || errorY < 0) { + _modularPath[p].num = 0; // the end of the path + + // okay those last steps took us past our + // target but do we want to scoot or moonwalk + + frames = _stepCount - _lastCount; + errorX = _modularPath[p].x - walkAnim[_stepCount - 1].x; + errorY = _modularPath[p].y - walkAnim[_stepCount - 1].y; + + if (frames > _framesPerStep) { + lastErrorX = _modularPath[p].x - walkAnim[_stepCount - 7].x; + lastErrorY = _modularPath[p].y - walkAnim[_stepCount - 7].y; + + if (stepX == 0) { + if (3 * ABS(lastErrorY) < ABS(errorY)) { + // the last stop was + // closest + _stepCount -= _framesPerStep; + if (left == 0) + left = _framesPerStep; + else + left = 0; + } + } else { + if (3 * ABS(lastErrorX) < ABS(errorX)) { + //the last stop was + // closest + _stepCount -= _framesPerStep; + if (left == 0) + left = _framesPerStep; + else + left = 0; + } + } + } + + errorX = _modularPath[p].x - walkAnim[_stepCount-1].x; + errorY = _modularPath[p].y - walkAnim[_stepCount-1].y; + + // okay we've reached the end but we still + // have an error + + if (errorX != 0) { + frameCount = 0; + frames = _stepCount - _lastCount; + + do { + frameCount++; + walkAnim[_lastCount + frameCount - 1].x += errorX * frameCount / frames; + } while (frameCount < frames); + } + + if (errorY != 0) { + frameCount = 0; + frames = _stepCount - _lastCount; + do { + frameCount++; + walkAnim[_lastCount + frameCount - 1].y += errorY * frameCount / frames; + } while (frameCount < frames); + } + + // Now is the time to put in the turn frames + // for the last turn + + if (frames < _framesPerStep) { + // this ensures that we don't put in + // turn frames for this walk or the + // next + _currentDir = 99; + } + + if (_currentDir != 99) + lastRealDir = _currentDir; + + // check each turn condition in turn + + // only for george + if (lastDir != 99 && _currentDir != 99 && _walkData.usingWalkingTurnFrames) { + // 1 and -7 going right -1 and 7 going + // left + lastDir = _currentDir - lastDir; + + if (lastDir == -1 || lastDir == 7 || lastDir == -2 || lastDir == 6) { + // turn at the end of the last + // walk + + _frame = _lastCount - _framesPerStep; + do { + // turning left + walkAnim[_frame].frame += _firstWalkingTurnLeftFrame; + _frame++; + } while (_frame < _lastCount); + } else if (lastDir == 1 || lastDir == -7 || lastDir == 2 || lastDir == -6) { + // turn at the end of the + // current walk + + _frame = _lastCount - _framesPerStep; + do { + // turning right + walkAnim[_frame].frame += _firstWalkingTurnRightFrame; + _frame++; + } while (_frame < _lastCount); + } + lastDir = _currentDir; + } + + // all turns checked + + _lastCount = _stepCount; + _moduleX = walkAnim[_stepCount - 1].x; + _moduleY = walkAnim[_stepCount - 1].y; + module16X = _moduleX << 16; + module16Y = _moduleY << 16; + } + } + } while (_modularPath[p].dir < NO_DIRECTIONS); + +#ifdef SWORD2_DEBUG + if (lastRealDir == 99) + error("slidyWalkAnimatorlast direction error"); +#endif + + // THE SLOW OUT + addSlowOutFrames(walkAnim); + + // TURNS TO END THE WALK ? + + // We've done the walk now put in any turns at the end + + if (_targetDir == 8) { + // ANY direction -> stand in the last direction + + module = _firstStandFrame + lastRealDir; + _targetDir = lastRealDir; + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = lastRealDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + } + + if (_targetDir == 9) { + // 'stance' was non-zero + if (_stepCount == 0) { + module = _framesPerChar + lastRealDir; + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = lastRealDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + } + } else if (_targetDir != lastRealDir) { + // rotate to target direction + turnDir = _targetDir - lastRealDir; + if ( turnDir < 0) + turnDir += NO_DIRECTIONS; + + if (turnDir > 4) + turnDir = -1; + else if (turnDir > 0) + turnDir = 1; + + // rotate to target direction + // for george and nico put in a head turn at the start + + if (_walkData.usingStandingTurnFrames) { + // new frames for turn frames 29oct95jps + if (turnDir < 0) + module = _firstStandingTurnLeftFrame + lastDir; + else + module = _firstStandingTurnRightFrame + lastDir; + + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = lastRealDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + } + + // rotate if we need to + + while (lastRealDir != _targetDir) { + lastRealDir += turnDir; + + // new frames for turn frames 29oct95jps + if (turnDir < 0) { + if (lastRealDir < 0) + lastRealDir += NO_DIRECTIONS; + module = _firstStandingTurnLeftFrame + lastRealDir; + } else { + if (lastRealDir > 7) + lastRealDir -= NO_DIRECTIONS; + module = _firstStandingTurnRightFrame + lastRealDir; + } + + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = lastRealDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + } + + module = _firstStandFrame + lastRealDir; + walkAnim[_stepCount - 1].frame = module; + } else { + // just stand at the end + module = _firstStandFrame + lastRealDir; + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = lastRealDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + } + + walkAnim[_stepCount].frame = 512; + walkAnim[_stepCount].step = 99; + _stepCount++; + + walkAnim[_stepCount].frame = 512; + walkAnim[_stepCount].step = 99; + _stepCount++; + + walkAnim[_stepCount].frame = 512; + walkAnim[_stepCount].step = 99; + + // write all the frames to "debug.txt" + debug(5, "THE WALKDATA:"); + + for (_frame = 0; _frame <= _stepCount; _frame++) + debug(5, "walkAnim[%d].frame=%d", _frame, walkAnim[_frame].frame); + + debug(5, "routeFinder RouteSize is %d", _stepCount); + return; +} + +#ifndef FORCE_SLIDY + +// THE SOLID PATH ROUTINES + +int32 Router::solidPath() { + /********************************************************************* + * SolidPath creates a path based on whole steps with no sliding to + * get as near as possible to the target without any sliding this + * routine is currently unused, but is intended for use when just + * clicking about. + * + * produce a module list from the line data + *********************************************************************/ + + int32 smooth; + int32 solid; + int32 scale; + int32 stepX; + int32 stepY; + int32 deltaX; + int32 deltaY; + + // strip out the short sections + + solid = 1; + smooth = 1; + _modularPath[0].x = _smoothPath[0].x; + _modularPath[0].y = _smoothPath[0].y; + _modularPath[0].dir = _smoothPath[0].dir; + _modularPath[0].num = 0; + + do { + scale = _scaleA * _smoothPath[smooth].y + _scaleB; + deltaX = _smoothPath[smooth].x - _modularPath[solid - 1].x; + deltaY = _smoothPath[smooth].y - _modularPath[solid - 1].y; + stepX = _modX[_smoothPath[smooth].dir]; + stepY = _modY[_smoothPath[smooth].dir]; + stepX = stepX * scale; + stepY = stepY * scale; + stepX = stepX >> 16; + stepY = stepY >> 16; + + if (ABS(deltaX) >= ABS(stepX) && ABS(deltaY) >= ABS(stepY)) { + _modularPath[solid].x = _smoothPath[smooth].x; + _modularPath[solid].y = _smoothPath[smooth].y; + _modularPath[solid].dir = _smoothPath[smooth].dir; + _modularPath[solid].num = 1; + solid++; + } + + smooth++; + } while (_smoothPath[smooth].num < ROUTE_END_FLAG); + + // in case the last bit had no steps + + if (solid == 1) { + // there were no paths so put in a dummy end + solid = 2; + _modularPath[1].dir = _smoothPath[0].dir; + _modularPath[1].num = 0; + } + + _modularPath[solid - 1].x = _smoothPath[smooth - 1].x; + _modularPath[solid - 1].y = _smoothPath[smooth - 1].y; + + // set up the end of the walk + _modularPath[solid].x = _smoothPath[smooth - 1].x; + _modularPath[solid].y = _smoothPath[smooth - 1].y; + _modularPath[solid].dir = 9; + _modularPath[solid].num = ROUTE_END_FLAG; + + return 1; +} + +int32 Router::solidWalkAnimator(WalkData *walkAnim) { + /********************************************************************* + * SolidWalk creates an animation based on whole steps with no sliding + * to get as near as possible to the target without any sliding. This + * routine is is intended for use when just clicking about. + * + * produce a module list from the line data + * + * returns 0 if solid route not found + *********************************************************************/ + + int32 left; + int32 turnDir; + int32 scale; + int32 step; + int32 errorX; + int32 errorY; + int32 moduleEnd; + bool slowStart = false; + + // start at the beginning for a change + + int32 lastDir = _modularPath[0].dir; + int32 module = _framesPerChar + lastDir; + + _currentDir = _modularPath[1].dir; + _moduleX = _startX; + _moduleY = _startY; + _stepCount = 0; + + int32 module16X = _moduleX << 16; + int32 module16Y = _moduleY << 16; + + // START THE WALK WITH THE FIRST STANDFRAME THIS MAY CAUSE A DELAY + // BUT IT STOPS THE PLAYER MOVING FOR COLLISIONS ARE DETECTED + + debug(5, "SOLID: STARTING THE WALK"); + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = lastDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + + // TURN TO START THE WALK + + debug(5, "SOLID: TURNING TO START THE WALK"); + + // rotate if we need to + + if (lastDir != _currentDir) { + // get the direction to turn + turnDir = _currentDir - lastDir; + if (turnDir < 0) + turnDir += NO_DIRECTIONS; + + if (turnDir > 4) + turnDir = -1; + else if (turnDir > 0) + turnDir = 1; + + // rotate to new walk direction + // for george and nico put in a head turn at the start + + if (_walkData.usingStandingTurnFrames) { + // new frames for turn frames 29oct95jps + if (turnDir < 0) + module = _firstStandingTurnLeftFrame + lastDir; + else + module = _firstStandingTurnRightFrame + lastDir; + + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = lastDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + } + + // rotate till were facing new dir then go back 45 degrees + + while (lastDir != _currentDir) { + lastDir += turnDir; + + // new frames for turn frames + if (turnDir < 0) { + if (lastDir < 0) + lastDir += NO_DIRECTIONS; + module = _firstStandingTurnLeftFrame + lastDir; + } else { + if (lastDir > 7) + lastDir -= NO_DIRECTIONS; + module = _firstStandingTurnRightFrame + lastDir; + } + + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = lastDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + } + + // the back 45 degrees bit + // step back one because new head turn for george takes us + // past the new dir + + _stepCount--; + } + + // THE SLOW IN + + slowStart = addSlowInFrames(walkAnim); + + // THE WALK + + debug(5, "SOLID: THE WALK"); + + // start the walk on the left or right leg, depending on how the + // slow-in frames were drawn + + // (0 = left; 1 = right) + if (_walkData.leadingLeg[_currentDir] == 0) { + // start the walk on the left leg (ie. at beginning of the + // first step of the walk cycle) + left = 0; + } else { + // start the walk on the right leg (ie. at beginning of the + // second step of the walk cycle) + left = _framesPerStep; + } + + _lastCount = _stepCount; + + // this ensures that we don't put in turn frames for the start + lastDir = 99; + + // this ensures that we don't put in turn frames for the start + _currentDir = 99; + + int32 p = 1; + + do { + while (_modularPath[p].num > 0) { + _currentDir = _modularPath[p].dir; + if (_currentDir < NO_DIRECTIONS) { + module = _currentDir * _framesPerStep * 2 + left; + + if (left == 0) + left = _framesPerStep; + else + left = 0; + + moduleEnd = module + _framesPerStep; + step = 0; + scale = (_scaleA * _moduleY + _scaleB); + + do { + module16X += _walkData.dx[module] * scale; + module16Y += _walkData.dy[module] * scale; + _moduleX = module16X >> 16; + _moduleY = module16Y >> 16; + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = step; // normally 0,1,2,3,4,5,0,1,2,etc + walkAnim[_stepCount].dir = _currentDir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + module++; + step++; + } while (module < moduleEnd); + + errorX = _modularPath[p].x - _moduleX; + errorX = errorX * _modX[_modularPath[p].dir]; + errorY = _modularPath[p].y - _moduleY; + errorY = errorY * _modY[_modularPath[p].dir]; + + if (errorX < 0 || errorY < 0) { + _modularPath[p].num = 0; + _stepCount -= _framesPerStep; + + if (left == 0) + left = _framesPerStep; + else + left = 0; + + // Okay this is the end of a section + + _moduleX = walkAnim[_stepCount - 1].x; + _moduleY = walkAnim[_stepCount - 1].y; + module16X = _moduleX << 16; + module16Y = _moduleY << 16; + _modularPath[p].x = _moduleX; + _modularPath[p].y = _moduleY; + + // Now is the time to put in the turn + // frames for the last turn + + if (_stepCount - _lastCount < _framesPerStep) { + // no step taken + + // clean up if a slow in but no + // walk + + if (slowStart) { + _stepCount -= _walkData.nSlowInFrames[_currentDir]; + _lastCount -= _walkData.nSlowInFrames[_currentDir]; + slowStart = false; + } + + // this ensures that we don't + // put in turn frames for this + // walk or the next + + _currentDir = 99; + } + + // check each turn condition in turn + if (lastDir != 99 && _currentDir != 99 && _walkData.usingWalkingTurnFrames) { + // only for george + // 1 and -7 going right -1 and + // 7 going left + + lastDir = _currentDir - lastDir; + + if (lastDir == -1 || lastDir == 7 || lastDir == -2 || lastDir == 6) { + // turn at the end of + // the last walk + + _frame = _lastCount - _framesPerStep; + + do { + // turning left + walkAnim[_frame].frame += _firstWalkingTurnLeftFrame; + _frame++; + } while (_frame < _lastCount); + } else if (lastDir == 1 || lastDir == -7 || lastDir == 2 || lastDir == -6) { + // turn at the end of + // the current walk + + _frame = _lastCount - _framesPerStep; + do { + // turning right + walkAnim[_frame].frame += _firstWalkingTurnRightFrame; + _frame++; + } while (_frame < _lastCount); + } + } + + // all turns checked + _lastCount = _stepCount; + } + } + } + p++; + lastDir = _currentDir; + + // can only be valid first time round + slowStart = false; + } while (_modularPath[p].dir < NO_DIRECTIONS); + + // THE SLOW OUT + + addSlowOutFrames(walkAnim); + + module = _framesPerChar + _modularPath[p - 1].dir; + walkAnim[_stepCount].frame = module; + walkAnim[_stepCount].step = 0; + walkAnim[_stepCount].dir = _modularPath[p - 1].dir; + walkAnim[_stepCount].x = _moduleX; + walkAnim[_stepCount].y = _moduleY; + _stepCount++; + + walkAnim[_stepCount].frame = 512; + walkAnim[_stepCount].step = 99; + _stepCount++; + + walkAnim[_stepCount].frame = 512; + walkAnim[_stepCount].step = 99; + _stepCount++; + + walkAnim[_stepCount].frame = 512; + walkAnim[_stepCount].step = 99; + + debug(5, "THE WALKDATA:"); + + for (_frame = 0; _frame <= _stepCount; _frame++) + debug(5, "walkAnim[%d].frame=%d", _frame, walkAnim[_frame].frame); + + // NO END TURNS + + debug(5, "routeFinder RouteSize is %d", _stepCount); + // now check the route + + int i = 0; + + do { + if (!check(_modularPath[i].x, _modularPath[i].y, _modularPath[i + 1].x, _modularPath[i + 1].y)) + p = 0; + i++; + } while (i < p - 1); + + if (p != 0) { + _targetDir = _modularPath[p - 1].dir; + if (checkTarget(_moduleX, _moduleY) == 3) { + // new target on a line + p = 0; + debug(5, "Solid walk target was on a line %d %d", _moduleX, _moduleY); + } + } + + return p; +} +#endif + +// THE SCAN ROUTINES + +bool Router::scan(int32 level) { + /********************************************************************* + * Called successively from routeFinder until no more changes take + * place in the grid array, ie he best path has been found + * + * Scans through every point in the node array and checks if there is + * a route between each point and if this route gives a new route. + * + * This routine could probably halve its processing time if it doubled + * up on the checks after each route check + * + *********************************************************************/ + + int32 x1, y1, x2, y2; + int32 distance; + bool changed = false; + + // For all the nodes that have new values and a distance less than + // enddist, ie dont check for new routes from a point we checked + // before or from a point that is already further away than the best + // route so far. + + for (int i = 0; i < _nNodes; i++) { + if (_node[i].dist < _node[_nNodes].dist && _node[i].level == level) { + x1 = _node[i].x; + y1 = _node[i].y; + + for (int j = _nNodes; j > 0; j--) { + if (_node[j].dist > _node[i].dist) { + x2 = _node[j].x; + y2 = _node[j].y; + + if (ABS(x2 - x1) > 4.5 * ABS(y2 - y1)) + distance = (8 * ABS(x2 - x1) + 18 * ABS(y2 - y1)) / (54 * 8) + 1; + else + distance = (6 * ABS(x2 - x1) + 36 * ABS(y2 - y1)) / (36 * 14) + 1; + + if (distance + _node[i].dist < _node[_nNodes].dist && distance + _node[i].dist < _node[j].dist) { + if (newCheck(0, x1, y1, x2, y2)) { + _node[j].level = level + 1; + _node[j].dist = distance + _node[i].dist; + _node[j].prev = i; + changed = true; + } + } + } + } + } + } + + return changed; +} + +int32 Router::newCheck(int32 status, int32 x1, int32 y1, int32 x2, int32 y2) { + /********************************************************************* + * newCheck routine checks if the route between two points can be + * achieved without crossing any of the bars in the Bars array. + * + * newCheck differs from check in that that 4 route options are + * considered corresponding to actual walked routes. + * + * Note distance doesnt take account of shrinking ??? + * + * Note Bars array must be properly calculated ie min max dx dy co + *********************************************************************/ + + int32 ldx; + int32 ldy; + int32 dlx; + int32 dly; + int32 dirX; + int32 dirY; + int32 step1; + int32 step2; + int32 step3; + int32 steps; + int32 options; + + steps = 0; + options = 0; + ldx = x2 - x1; + ldy = y2 - y1; + dirX = 1; + dirY = 1; + + if (ldx < 0) { + ldx = -ldx; + dirX = -1; + } + + if (ldy < 0) { + ldy = -ldy; + dirY = -1; + } + + // make the route options + + if (_diagonaly * ldx > _diagonalx * ldy) { + // dir = 1,2 or 2,3 or 5,6 or 6,7 + + dly = ldy; + dlx = (ldy * _diagonalx) / _diagonaly; + ldx = ldx - dlx; + dlx = dlx * dirX; + dly = dly * dirY; + ldx = ldx * dirX; + ldy = 0; + + // options are square, diagonal a code 1 route + + step1 = check(x1, y1, x1 + ldx, y1); + if (step1 != 0) { + step2 = check(x1 + ldx, y1, x2, y2); + if (step2 != 0) { + steps = step1 + step2; + options |= 2; + } + } + + // diagonal, square a code 2 route + + if (steps == 0 || status == 1) { + step1 = check(x1, y1, x1 + dlx, y1 + dly); + if (step1 != 0) { + step2 = check(x1 + dlx, y2, x2, y2); + if (step2 != 0) { + steps = step1 + step2; + options |= 4; + } + } + } + + // halfsquare, diagonal, halfsquare a code 0 route + + if (steps == 0 || status == 1) { + step1 = check(x1, y1, x1 + ldx / 2, y1); + if (step1 != 0) { + step2 = check(x1 + ldx / 2, y1, x1 + ldx / 2 + dlx, y2); + if (step2 != 0) { + step3 = check(x1 + ldx / 2 + dlx, y2, x2, y2); + if (step3 != 0) { + steps = step1 + step2 + step3; + options |= 1; + } + } + } + } + + //halfdiagonal, square, halfdiagonal a code 3 route + + if (steps == 0 || status == 1) { + step1 = check(x1, y1, x1 + dlx / 2, y1 + dly / 2); + if (step1 != 0) { + step2 = check(x1 + dlx / 2, y1 + dly / 2, x1 + ldx + dlx / 2, y1 + dly / 2); + if (step2 != 0) { + step3 = check(x1 + ldx + dlx / 2, y1 + dly / 2, x2, y2); + if (step3 != 0) { + steps = step1 + step2 + step3; + options |= 8; + } + } + } + } + } else { + // dir = 7,0 or 0,1 or 3,4 or 4,5 + + dlx = ldx; + dly = (ldx * _diagonaly) / _diagonalx; + ldy = ldy - dly; + dlx = dlx * dirX; + dly = dly * dirY; + ldy = ldy * dirY; + ldx = 0; + + // options are square, diagonal a code 1 route + + step1 = check(x1 ,y1, x1, y1 + ldy); + if (step1 != 0) { + step2 = check(x1, y1 + ldy, x2, y2); + if (step2 != 0) { + steps = step1 + step2; + options |= 2; + } + } + + // diagonal, square a code 2 route + + if (steps == 0 || status == 1) { + step1 = check(x1, y1, x2, y1 + dly); + if (step1 != 0) { + step2 = check(x2, y1 + dly, x2, y2); + if (step2 != 0) { + steps = step1 + step2; + options |= 4; + } + } + } + + // halfsquare, diagonal, halfsquare a code 0 route + + if (steps == 0 || status == 1) { + step1 = check(x1, y1, x1, y1 + ldy / 2); + if (step1 != 0) { + step2 = check(x1, y1 + ldy / 2, x2, y1 + ldy / 2 + dly); + if (step2 != 0) { + step3 = check(x2, y1 + ldy / 2 + dly, x2, y2); + if (step3 != 0) { + steps = step1 + step2 + step3; + options |= 1; + } + } + } + } + + // halfdiagonal, square, halfdiagonal a code 3 route + + if (steps == 0 || status == 1) { + step1 = check(x1, y1, x1 + dlx / 2, y1 + dly / 2); + if (step1 != 0) { + step2 = check(x1 + dlx / 2, y1 + dly / 2, x1 + dlx / 2, y1 + ldy + dly / 2); + if (step2 != 0) { + step3 = check(x1 + dlx / 2, y1 + ldy + dly / 2, x2, y2); + if (step3 != 0) { + steps = step1 + step2 + step3; + options |= 8; + } + } + } + } + } + + if (status == 0) + status = steps; + else + status = options; + + return status; +} + +// CHECK ROUTINES + +bool Router::check(int32 x1, int32 y1, int32 x2, int32 y2) { + // call the fastest line check for the given line + // returns true if line didn't cross any bars + + if (x1 == x2 && y1 == y2) + return true; + + if (x1 == x2) + return vertCheck(x1, y1, y2); + + if (y1 == y2) + return horizCheck(x1, y1, x2); + + return lineCheck(x1, y1, x2, y2); +} + +bool Router::lineCheck(int32 x1, int32 y1, int32 x2, int32 y2) { + bool linesCrossed = true; + + int32 xmin = MIN(x1, x2); + int32 xmax = MAX(x1, x2); + int32 ymin = MIN(y1, y2); + int32 ymax = MAX(y1, y2); + + // Line set to go one step in chosen direction so ignore if it hits + // anything + + int32 dirx = x2 - x1; + int32 diry = y2 - y1; + + int32 co = (y1 * dirx) - (x1 * diry); // new line equation + + for (int i = 0; i < _nBars && linesCrossed; i++) { + // skip if not on module + if (xmax >= _bars[i].xmin && xmin <= _bars[i].xmax && ymax >= _bars[i].ymin && ymin <= _bars[i].ymax) { + // Okay, it's a valid line. Calculate an intercept. Wow + // but all this arithmetic we must have loads of time + + // slope it he slope between the two lines + int32 slope = (_bars[i].dx * diry) - (_bars[i].dy *dirx); + // assuming parallel lines don't cross + if (slope != 0) { + // calculate x intercept and check its on both + // lines + int32 xc = ((_bars[i].co * dirx) - (co * _bars[i].dx)) / slope; + + // skip if not on module + if (xc >= xmin - 1 && xc <= xmax + 1) { + // skip if not on line + if (xc >= _bars[i].xmin - 1 && xc <= _bars[i].xmax + 1) { + int32 yc = ((_bars[i].co * diry) - (co * _bars[i].dy)) / slope; + + // skip if not on module + if (yc >= ymin - 1 && yc <= ymax + 1) { + // skip if not on line + if (yc >= _bars[i].ymin - 1 && yc <= _bars[i].ymax + 1) { + linesCrossed = false; + } + } + } + } + } + } + } + + return linesCrossed; +} + +bool Router::horizCheck(int32 x1, int32 y, int32 x2) { + bool linesCrossed = true; + + int32 xmin = MIN(x1, x2); + int32 xmax = MAX(x1, x2); + + // line set to go one step in chosen direction so ignore if it hits + // anything + + for (int i = 0; i < _nBars && linesCrossed; i++) { + // skip if not on module + if (xmax >= _bars[i].xmin && xmin <= _bars[i].xmax && y >= _bars[i].ymin && y <= _bars[i].ymax) { + // Okay, it's a valid line calculate an intercept. Wow + // but all this arithmetic we must have loads of time + + if (_bars[i].dy == 0) + linesCrossed = false; + else { + int32 ldy = y - _bars[i].y1; + int32 xc = _bars[i].x1 + (_bars[i].dx * ldy) / _bars[i].dy; + // skip if not on module + if (xc >= xmin - 1 && xc <= xmax + 1) + linesCrossed = false; + } + } + } + + return linesCrossed; +} + +bool Router::vertCheck(int32 x, int32 y1, int32 y2) { + bool linesCrossed = true; + + int32 ymin = MIN(y1, y2); + int32 ymax = MAX(y1, y2); + + // Line set to go one step in chosen direction so ignore if it hits + // anything + + for (int i = 0; i < _nBars && linesCrossed; i++) { + // skip if not on module + if (x >= _bars[i].xmin && x <= _bars[i].xmax && ymax >= _bars[i].ymin && ymin <= _bars[i].ymax) { + // Okay, it's a valid line calculate an intercept. Wow + // but all this arithmetic we must have loads of time + + // both lines vertical and overlap in x and y so they + // cross + + if (_bars[i].dx == 0) + linesCrossed = false; + else { + int32 ldx = x - _bars[i].x1; + int32 yc = _bars[i].y1 + (_bars[i].dy * ldx) / _bars[i].dx; + // the intercept overlaps + if (yc >= ymin - 1 && yc <= ymax + 1) + linesCrossed = false; + } + } + } + + return linesCrossed; +} + +int32 Router::checkTarget(int32 x, int32 y) { + int32 onLine = 0; + + int32 xmin = x - 1; + int32 xmax = x + 1; + int32 ymin = y - 1; + int32 ymax = y + 1; + + // check if point +- 1 is on the line + // so ignore if it hits anything + + for (int i = 0; i < _nBars && onLine == 0; i++) { + // overlapping line + if (xmax >= _bars[i].xmin && xmin <= _bars[i].xmax && ymax >= _bars[i].ymin && ymin <= _bars[i].ymax) { + int32 xc, yc; + + // okay this line overlaps the target calculate + // an y intercept for x + + // vertical line so we know it overlaps y + if (_bars[i].dx == 0) + yc = 0; + else { + int ldx = x - _bars[i].x1; + yc = _bars[i].y1 + (_bars[i].dy * ldx) / _bars[i].dx; + } + + // overlapping point for y + if (yc >= ymin && yc <= ymax) { + // target on a line so drop out + onLine = 3; + debug(5, "RouteFail due to target on a line %d %d", x, y); + } else { + // vertical line so we know it overlaps y + if (_bars[i].dy == 0) + xc = 0; + else { + int32 ldy = y - _bars[i].y1; + xc = _bars[i].x1 + (_bars[i].dx * ldy) / _bars[i].dy; + } + + // skip if not on module + if (xc >= xmin && xc <= xmax) { + // target on a line so drop out + onLine = 3; + debug(5, "RouteFail due to target on a line %d %d", x, y); + } + } + } + } + + return onLine; +} + +// THE SETUP ROUTINES + +void Router::loadWalkData(byte *ob_walkdata) { + uint16 firstFrameOfDirection; + uint16 walkFrameNo; + uint32 frameCounter = 0; // starts at frame 0 of mega set + int i; + + _walkData.read(ob_walkdata); + + // 0 = not using slow out frames; non-zero = using that many frames + // for each leading leg for each direction + + _numberOfSlowOutFrames = _walkData.usingSlowOutFrames; + + for (i = 0; i < NO_DIRECTIONS; i++) { + firstFrameOfDirection = i * _walkData.nWalkFrames; + + _modX[i] = 0; + _modY[i] = 0; + + for (walkFrameNo = firstFrameOfDirection; walkFrameNo < firstFrameOfDirection + _walkData.nWalkFrames / 2; walkFrameNo++) { + // eg. _modX[0] is the sum of the x-step sizes for the + // first half of the walk cycle for direction 0 + _modX[i] += _walkData.dx[walkFrameNo]; + _modY[i] += _walkData.dy[walkFrameNo]; + } + } + + _diagonalx = _modX[3]; + _diagonaly = _modY[3]; + + // interpret the walk data + + _framesPerStep = _walkData.nWalkFrames / 2; + _framesPerChar = _walkData.nWalkFrames * NO_DIRECTIONS; + + // offset pointers added Oct 30 95 JPS + // mega id references removed 16sep96 by JEL + + // WALK FRAMES + // start on frame 0 + + frameCounter += _framesPerChar; + + // STAND FRAMES + // stand frames come after the walk frames + // one stand frame for each direction + + _firstStandFrame = frameCounter; + frameCounter += NO_DIRECTIONS; + + // STANDING TURN FRAMES - OPTIONAL! + // standing turn-left frames come after the slow-out frames + // one for each direction + // standing turn-left frames come after the standing turn-right frames + // one for each direction + + if (_walkData.usingStandingTurnFrames) { + _firstStandingTurnLeftFrame = frameCounter; + frameCounter += NO_DIRECTIONS; + + _firstStandingTurnRightFrame = frameCounter; + frameCounter += NO_DIRECTIONS; + } else { + // refer instead to the normal stand frames + _firstStandingTurnLeftFrame = _firstStandFrame; + _firstStandingTurnRightFrame = _firstStandFrame; + } + + // WALKING TURN FRAMES - OPTIONAL! + // walking left-turn frames come after the stand frames + // walking right-turn frames come after the walking left-turn frames + + if (_walkData.usingWalkingTurnFrames) { + _firstWalkingTurnLeftFrame = frameCounter; + frameCounter += _framesPerChar; + + _firstWalkingTurnRightFrame = frameCounter; + frameCounter += _framesPerChar; + } else { + _firstWalkingTurnLeftFrame = 0; + _firstWalkingTurnRightFrame = 0; + } + + // SLOW-IN FRAMES - OPTIONAL! + // slow-in frames come after the walking right-turn frames + + if (_walkData.usingSlowInFrames) { + // Make note of frame number of first slow-in frame for each + // direction. There may be a different number of slow-in + // frames in each direction + + for (i = 0; i < NO_DIRECTIONS; i++) { + _firstSlowInFrame[i] = frameCounter; + frameCounter += _walkData.nSlowInFrames[i]; + } + } + + // SLOW-OUT FRAMES - OPTIONAL! + // slow-out frames come after the slow-in frames + + if (_walkData.usingSlowOutFrames) + _firstSlowOutFrame = frameCounter; +} + +// THE ROUTE EXTRACTOR + +void Router::extractRoute() { + /********************************************************************* + * extractRoute gets route from the node data after a full scan, route + * is written with just the basic way points and direction options for + * heading to the next point. + *********************************************************************/ + + int32 prev; + int32 prevx; + int32 prevy; + int32 last; + int32 point; + int32 p; + int32 dirx; + int32 diry; + int32 dir; + int32 ldx; + int32 ldy; + + // extract the route from the node data + + prev = _nNodes; + last = prev; + point = O_ROUTE_SIZE - 1; + _route[point].x = _node[last].x; + _route[point].y = _node[last].y; + + do { + point--; + prev = _node[last].prev; + prevx = _node[prev].x; + prevy = _node[prev].y; + _route[point].x = prevx; + _route[point].y = prevy; + last = prev; + } while (prev > 0); + + // now shuffle route down in the buffer + + _routeLength = 0; + + do { + _route[_routeLength].x = _route[point].x; + _route[_routeLength].y = _route[point].y; + point++; + _routeLength++; + } while (point < O_ROUTE_SIZE); + + _routeLength--; + + // okay the route exists as a series point now put in some directions + + p = 0; + + do { + ldx = _route[p + 1].x - _route[p].x; + ldy = _route[p + 1].y - _route[p].y; + dirx = 1; + diry = 1; + + if (ldx < 0) { + ldx = -ldx; + dirx = -1; + } + + if (ldy < 0) { + ldy = -ldy; + diry = -1; + } + + if (_diagonaly * ldx > _diagonalx * ldy) { + // dir = 1,2 or 2,3 or 5,6 or 6,7 + + // 2 or 6 + dir = 4 - 2 * dirx; + _route[p].dirS = dir; + + // 1, 3, 5 or 7 + dir = dir + diry * dirx; + _route[p].dirD = dir; + } else { + // dir = 7,0 or 0,1 or 3,4 or 4,5 + + // 0 or 4 + dir = 2 + 2 * diry; + _route[p].dirS = dir; + + // 2 or 6 + dir = 4 - 2 * dirx; + + // 1, 3, 5 or 7 + dir = dir + diry * dirx; + _route[p].dirD = dir; + } + p++; + } while (p < _routeLength); + + // set the last dir to continue previous route unless specified + + if (_targetDir == 8) { + // ANY direction + _route[p].dirS = _route[p - 1].dirS; + _route[p].dirD = _route[p - 1].dirD; + } else { + _route[p].dirS = _targetDir; + _route[p].dirD = _targetDir; + } + + return; +} + +void Router::setUpWalkGrid(byte *ob_mega, int32 x, int32 y, int32 dir) { + ObjectMega obMega(ob_mega); + + // get walk grid file + extra grid into 'bars' & 'node' arrays + loadWalkGrid(); + + // copy the mega structure into the local variables for use in all + // subroutines + + _startX = obMega.getFeetX(); + _startY = obMega.getFeetY(); + _startDir = obMega.getCurDir(); + _targetX = x; + _targetY = y; + _targetDir = dir; + + _scaleA = obMega.getScaleA(); + _scaleB = obMega.getScaleB(); + + // mega's current position goes into first node + + _node[0].x = _startX; + _node[0].y = _startY; + _node[0].level = 1; + _node[0].prev = 0; + _node[0].dist = 0; + + // reset other nodes + + for (int i = 1; i < _nNodes; i++) { + _node[i].level = 0; + _node[i].prev = 0; + _node[i].dist = 9999; + } + + // target position goes into final node + _node[_nNodes].x = _targetX; + _node[_nNodes].y = _targetY; + _node[_nNodes].level = 0; + _node[_nNodes].prev = 0; + _node[_nNodes].dist = 9999; +} + +void Router::plotWalkGrid() { + int32 i; + + // get walk grid file + extra grid into 'bars' & 'node' arrays + loadWalkGrid(); + + // lines + + for (i = 0; i < _nBars; i++) + _vm->_screen->drawLine(_bars[i].x1, _bars[i].y1, _bars[i].x2, _bars[i].y2, 254); + + // nodes + + // leave node 0 for start node + for (i = 1; i < _nNodes; i++) + plotCross(_node[i].x, _node[i].y, 184); +} + +void Router::plotCross(int16 x, int16 y, uint8 colour) { + _vm->_screen->drawLine(x - 1, y - 1, x + 1, y + 1, colour); + _vm->_screen->drawLine(x + 1, y - 1, x - 1, y + 1, colour); +} + +void Router::loadWalkGrid() { + WalkGridHeader floorHeader; + byte *fPolygrid; + uint16 fPolygridLen; + + _nBars = 0; // reset counts + _nNodes = 1; // leave node 0 for start-node + + // STATIC GRIDS (added/removed by object logics) + + // go through walkgrid list + for (int i = 0; i < MAX_WALKGRIDS; i++) { + if (_walkGridList[i]) { + int j; + + // open walk grid file + fPolygrid = _vm->_resman->openResource(_walkGridList[i]); + fPolygridLen = _vm->_resman->fetchLen(_walkGridList[i]); + + Common::MemoryReadStream readS(fPolygrid, fPolygridLen); + + readS.seek(ResHeader::size()); + + floorHeader.numBars = readS.readSint32LE(); + floorHeader.numNodes = readS.readSint32LE(); + + // check that we're not going to exceed the max + // allowed in the complete walkgrid arrays + + assert(_nBars + floorHeader.numBars < O_GRID_SIZE); + assert(_nNodes + floorHeader.numNodes < O_GRID_SIZE); + + // lines + + for (j = 0; j < floorHeader.numBars; j++) { + _bars[_nBars + j].x1 = readS.readSint16LE(); + _bars[_nBars + j].y1 = readS.readSint16LE(); + _bars[_nBars + j].x2 = readS.readSint16LE(); + _bars[_nBars + j].y2 = readS.readSint16LE(); + _bars[_nBars + j].xmin = readS.readSint16LE(); + _bars[_nBars + j].ymin = readS.readSint16LE(); + _bars[_nBars + j].xmax = readS.readSint16LE(); + _bars[_nBars + j].ymax = readS.readSint16LE(); + _bars[_nBars + j].dx = readS.readSint16LE(); + _bars[_nBars + j].dy = readS.readSint16LE(); + _bars[_nBars + j].co = readS.readSint32LE(); + } + + // nodes + + // leave node 0 for start node + for (j = 0; j < floorHeader.numNodes; j++) { + _node[_nNodes + j].x = readS.readSint16LE(); + _node[_nNodes + j].y = readS.readSint16LE(); + } + + // close walk grid file + _vm->_resman->closeResource(_walkGridList[i]); + + // increment counts of total bars & nodes in whole + // walkgrid + + _nBars += floorHeader.numBars; + _nNodes += floorHeader.numNodes; + } + } +} + +void Router::clearWalkGridList() { + memset(_walkGridList, 0, sizeof(_walkGridList)); +} + +// called from fnAddWalkGrid + +void Router::addWalkGrid(int32 gridResource) { + int i; + // First, scan the list to see if this grid is already included + + for (i = 0; i < MAX_WALKGRIDS; i++) { + if (_walkGridList[i] == gridResource) + return; + } + + // Scan the list for a free slot + + for (i = 0; i < MAX_WALKGRIDS; i++) { + if (_walkGridList[i] == 0) { + _walkGridList[i] = gridResource; + return; + } + } + + error("_walkGridList[] full"); +} + +// called from fnRemoveWalkGrid + +void Router::removeWalkGrid(int32 gridResource) { + for (int i = 0; i < MAX_WALKGRIDS; i++) { + if (_walkGridList[i] == gridResource) { + // If we've found it in the list, reset entry to zero. + // Otherwise just ignore the request. + _walkGridList[i] = 0; + break; + } + } +} + +} // End of namespace Sword2 diff --git a/engines/sword2/router.h b/engines/sword2/router.h new file mode 100644 index 0000000000..45efd046bd --- /dev/null +++ b/engines/sword2/router.h @@ -0,0 +1,255 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef _ROUTER_H +#define _ROUTER_H + +// This used to be a variable, but it was never set. Actually, it wasn't even +// initialised! +// +// Define this to force the use of slidy router (so solid path not used when +// ending walk in ANY direction) +// +// #define FORCE_SLIDY + +#include "sword2/object.h" + +namespace Sword2 { + +struct WalkData { + uint16 frame; + int16 x; + int16 y; + uint8 step; + uint8 dir; +}; + +struct BarData { + int16 x1; + int16 y1; + int16 x2; + int16 y2; + int16 xmin; + int16 ymin; + int16 xmax; + int16 ymax; + int16 dx; // x2 - x1 + int16 dy; // y2 - y1 + int32 co; // co = (y1 * dx) - (x1 * dy) from an equation for a + // line y * dx = x * dy + co +}; + +struct NodeData { + int16 x; + int16 y; + int16 level; + int16 prev; + int16 dist; +}; + +// because we only have 2 megas in the game! +#define TOTAL_ROUTE_SLOTS 2 + +#define MAX_FRAMES_PER_CYCLE 16 +#define NO_DIRECTIONS 8 +#define MAX_FRAMES_PER_CHAR (MAX_FRAMES_PER_CYCLE * NO_DIRECTIONS) +#define ROUTE_END_FLAG 255 + +#define MAX_WALKGRIDS 10 + +#define O_WALKANIM_SIZE 600 // max number of nodes in router output +#define O_GRID_SIZE 200 // max 200 lines & 200 points +#define O_ROUTE_SIZE 50 // max number of modules in a route + +struct RouteData { + int32 x; + int32 y; + int32 dirS; + int32 dirD; +}; + +struct PathData { + int32 x; + int32 y; + int32 dir; + int32 num; +}; + +class Router { +private: + Sword2Engine *_vm; + + int16 _standbyX; // see fnSetStandbyCoords() + int16 _standbyY; + int16 _standbyDir; + + // stores pointers to mem blocks containing routes created & used by + // megas (NULL if slot not in use) + WalkData *_routeSlots[TOTAL_ROUTE_SLOTS]; + + BarData _bars[O_GRID_SIZE]; + NodeData _node[O_GRID_SIZE]; + + int32 _walkGridList[MAX_WALKGRIDS]; + + int32 _nBars; + int32 _nNodes; + + int32 _startX; + int32 _startY; + int32 _startDir; + int32 _targetX; + int32 _targetY; + int32 _targetDir; + int32 _scaleA; + int32 _scaleB; + + RouteData _route[O_ROUTE_SIZE]; + PathData _smoothPath[O_ROUTE_SIZE]; + PathData _modularPath[O_ROUTE_SIZE]; + int32 _routeLength; + + int32 _framesPerStep; + int32 _framesPerChar; + + ObjectWalkdata _walkData; + + int8 _modX[NO_DIRECTIONS]; + int8 _modY[NO_DIRECTIONS]; + int32 _diagonalx; + int32 _diagonaly; + + int32 _firstStandFrame; + + int32 _firstStandingTurnLeftFrame; + int32 _firstStandingTurnRightFrame; + + int32 _firstWalkingTurnLeftFrame; // left walking turn + int32 _firstWalkingTurnRightFrame; // right walking turn + + uint32 _firstSlowInFrame[NO_DIRECTIONS]; + + int32 _firstSlowOutFrame; + + // number of slow-out frames on for each leading-leg in each direction + // ie. total number of slow-out frames = (numberOfSlowOutFrames * 2 * + // NO_DIRECTIONS) + + int32 _numberOfSlowOutFrames; + + int32 _stepCount; + + int32 _moduleX; + int32 _moduleY; + int32 _currentDir; + int32 _lastCount; + int32 _frame; + + uint8 returnSlotNo(uint32 megaId); + + int32 getRoute(); + void extractRoute(); + void loadWalkGrid(); + void setUpWalkGrid(byte *ob_mega, int32 x, int32 y, int32 dir); + void loadWalkData(byte *ob_walkdata); + bool scan(int32 level); + + int32 newCheck(int32 status, int32 x1, int32 y1, int32 x2, int32 y2); + bool lineCheck(int32 x1, int32 x2, int32 y1, int32 y2); + bool vertCheck(int32 x, int32 y1, int32 y2); + bool horizCheck(int32 x1, int32 y, int32 x2); + bool check(int32 x1, int32 y1, int32 x2, int32 y2); + int32 checkTarget(int32 x, int32 y); + + int32 smoothestPath(); + void slidyPath(); + + int32 smoothCheck(int32 best, int32 p, int32 dirS, int32 dirD); + + bool addSlowInFrames(WalkData *walkAnim); + void addSlowOutFrames(WalkData *walkAnim); + void slidyWalkAnimator(WalkData *walkAnim); + +#ifndef FORCE_SLIDY + int32 solidPath(); + int32 solidWalkAnimator(WalkData *walkAnim); +#endif + + void plotCross(int16 x, int16 y, uint8 colour); + +public: + Router(Sword2Engine *vm) : _vm(vm), _diagonalx(0), _diagonaly(0) { + memset(_routeSlots, 0, sizeof(_routeSlots)); + memset(_bars, 0, sizeof(_bars)); + memset(_node, 0, sizeof(_node)); + memset(_walkGridList, 0, sizeof(_walkGridList)); + memset(_route, 0, sizeof(_route)); + memset(_smoothPath, 0, sizeof(_smoothPath)); + memset(_modularPath, 0, sizeof(_modularPath)); + memset(_modX, 0, sizeof(_modX)); + memset(_modY, 0, sizeof(_modY)); + memset(_firstSlowInFrame, 0, sizeof(_firstSlowInFrame)); + } + + void setStandbyCoords(int16 x, int16 y, uint8 dir); + int whatTarget(int startX, int startY, int destX, int destY); + + // Sprites + void setSpriteStatus(byte *ob_graph, uint32 type); + void setSpriteShading(byte *ob_graph, uint32 type); + + // Animation + int doAnimate(byte *ob_logic, byte *ob_graph, int32 animRes, bool reverse); + int megaTableAnimate(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *animTable, bool reverse); + + // Walking + int doWalk(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *ob_walkdata, int16 target_x, int16 target_y, uint8 target_dir); + int walkToAnim(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *ob_walkdata, uint32 animRes); + int walkToTalkToMega(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *ob_walkdata, uint32 megaId, uint32 separation); + + // Turning + int doFace(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *ob_walkdata, uint8 target_dir); + int faceXY(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *ob_walkdata, int16 target_x, int16 target_y); + int faceMega(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *ob_walkdata, uint32 megaId); + + // Standing + void standAt(byte *ob_graph, byte *ob_mega, int32 x, int32 y, int32 dir); + void standAfterAnim(byte *ob_graph, byte *ob_mega, uint32 animRes); + void standAtAnim(byte *ob_graph, byte *ob_mega, uint32 animRes); + + int32 routeFinder(byte *ob_mega, byte *ob_walkdata, int32 x, int32 y, int32 dir); + + void earlySlowOut(byte *ob_mega, byte *ob_walkdata); + + void allocateRouteMem(); + WalkData *getRouteMem(); + void freeRouteMem(); + void freeAllRouteMem(); + void addWalkGrid(int32 gridResource); + void removeWalkGrid(int32 gridResource); + void clearWalkGridList(); + + void plotWalkGrid(); +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/save_rest.cpp b/engines/sword2/save_rest.cpp new file mode 100644 index 0000000000..df03c21be3 --- /dev/null +++ b/engines/sword2/save_rest.cpp @@ -0,0 +1,414 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +// --------------------------------------------------------------------------- +// SAVE_REST.CPP save, restore & restart functions +// +// James 05feb97 +// +// "Jesus Saves", but could he Restore or Restart? He can now... +// +// --------------------------------------------------------------------------- + +#include "common/stdafx.h" +#include "common/savefile.h" +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/mouse.h" +#include "sword2/resman.h" +#include "sword2/sound.h" + +namespace Sword2 { + +// A savegame consists of a header and the global variables + +// Max length of a savegame filename +#define MAX_FILENAME_LEN 128 + +/** + * Calculate size of required savegame buffer + */ + +uint32 Sword2Engine::findBufferSize() { + // Size of savegame header + size of global variables + return 212 + _resman->fetchLen(1); +} + +/** + * Save the game. + */ + +uint32 Sword2Engine::saveGame(uint16 slotNo, byte *desc) { + char description[SAVE_DESCRIPTION_LEN]; + uint32 bufferSize = findBufferSize(); + byte *saveBuffer = (byte *)malloc(bufferSize); + ScreenInfo *screenInfo = _screen->getScreenInfo(); + + memset(description, 0, sizeof(description)); + strncpy(description, (char *)desc, SAVE_DESCRIPTION_LEN - 1); + + Common::MemoryWriteStream writeS(saveBuffer, bufferSize); + + byte *globalVars = _resman->openResource(1); + byte *objectHub = _resman->openResource(CUR_PLAYER_ID) + ResHeader::size(); + + // Script no. 7 - 'george_savedata_request' calls fnPassPlayerSaveData + _logic->runResScript(CUR_PLAYER_ID, 7); + + writeS.writeUint32LE(0); // Checksum + writeS.write(description, SAVE_DESCRIPTION_LEN); + writeS.writeUint32LE(_resman->fetchLen(1)); + writeS.writeUint32LE(screenInfo->background_layer_id); + writeS.writeUint32LE(_logic->getRunList()); + writeS.writeUint32LE(screenInfo->feet_x); + writeS.writeUint32LE(screenInfo->feet_y); + writeS.writeUint32LE(_sound->getLoopingMusicId()); + writeS.write(objectHub, ObjectHub::size()); + writeS.write(_logic->_saveLogic, ObjectLogic::size()); + writeS.write(_logic->_saveGraphic, ObjectGraphic::size()); + writeS.write(_logic->_saveMega, ObjectMega::size()); + writeS.write(globalVars, _resman->fetchLen(1)); + + WRITE_LE_UINT32(saveBuffer, calcChecksum(saveBuffer + 4, bufferSize - 4)); + + _resman->closeResource(CUR_PLAYER_ID); + _resman->closeResource(1); + + uint32 errorCode = saveData(slotNo, saveBuffer, bufferSize); + + free(saveBuffer); + + if (errorCode != SR_OK) { + uint32 textId; + + switch (errorCode) { + case SR_ERR_FILEOPEN: + textId = TEXT_SAVE_CANT_OPEN; + break; + default: + textId = TEXT_SAVE_FAILED; + break; + } + + _screen->displayMsg(fetchTextLine(_resman->openResource(textId / SIZE), textId & 0xffff) + 2, 0); + } + + return errorCode; +} + +uint32 Sword2Engine::saveData(uint16 slotNo, byte *buffer, uint32 bufferSize) { + char saveFileName[MAX_FILENAME_LEN]; + + sprintf(saveFileName, "%s.%.3d", _targetName.c_str(), slotNo); + + Common::OutSaveFile *out; + + if (!(out = _saveFileMan->openForSaving(saveFileName))) { + return SR_ERR_FILEOPEN; + } + + out->write(buffer, bufferSize); + out->flush(); + + if (!out->ioFailed()) { + delete out; + return SR_OK; + } + + delete out; + return SR_ERR_WRITEFAIL; +} + +/** + * Restore the game. + */ + +uint32 Sword2Engine::restoreGame(uint16 slotNo) { + uint32 bufferSize = findBufferSize(); + byte *saveBufferMem = (byte *)malloc(bufferSize); + + uint32 errorCode = restoreData(slotNo, saveBufferMem, bufferSize); + + // If it was read in successfully, then restore the game from the + // buffer & free the buffer. Note that restoreFromBuffer() frees the + // buffer in order to clear it from memory before loading in the new + // screen and runlist, so we only need to free it in case of failure. + + if (errorCode == SR_OK) + errorCode = restoreFromBuffer(saveBufferMem, bufferSize); + else + free(saveBufferMem); + + if (errorCode != SR_OK) { + uint32 textId; + + switch (errorCode) { + case SR_ERR_FILEOPEN: + textId = TEXT_RESTORE_CANT_OPEN; + break; + case SR_ERR_INCOMPATIBLE: + textId = TEXT_RESTORE_INCOMPATIBLE; + break; + default: + textId = TEXT_RESTORE_FAILED; + break; + } + + _screen->displayMsg(fetchTextLine(_resman->openResource(textId / SIZE), textId & 0xffff) + 2, 0); + } else { + // Prime system with a game cycle + + // Reset the graphic 'BuildUnit' list before a new logic list + // (see fnRegisterFrame) + _screen->resetRenderLists(); + + // Reset the mouse hot-spot list. See fnRegisterMouse() + // and fnRegisterFrame() + _mouse->resetMouseList(); + + if (_logic->processSession()) + error("restore 1st cycle failed??"); + } + + // Force the game engine to pick a cursor. This appears to be needed + // when using the -x command-line option to restore a game. + _mouse->setMouseTouching(1); + return errorCode; +} + +uint32 Sword2Engine::restoreData(uint16 slotNo, byte *buffer, uint32 bufferSize) { + char saveFileName[MAX_FILENAME_LEN]; + + sprintf(saveFileName, "%s.%.3d", _targetName.c_str(), slotNo); + + Common::InSaveFile *in; + + if (!(in = _saveFileMan->openForLoading(saveFileName))) { + // error: couldn't open file + return SR_ERR_FILEOPEN; + } + + // Read savegame into the buffer + uint32 itemsRead = in->read(buffer, bufferSize); + + delete in; + + if (itemsRead != bufferSize) { + // We didn't get all of it. At the moment we have no way of + // knowing why, so assume that it's an incompatible savegame. + + return SR_ERR_INCOMPATIBLE; + } + + return SR_OK; +} + +uint32 Sword2Engine::restoreFromBuffer(byte *buffer, uint32 size) { + Common::MemoryReadStream readS(buffer, size); + + // Calc checksum & check that aginst the value stored in the header + + if (readS.readUint32LE() != calcChecksum(buffer + 4, size - 4)) { + free(buffer); + return SR_ERR_INCOMPATIBLE; + } + + readS.seek(SAVE_DESCRIPTION_LEN, SEEK_CUR); + + // Check savegame against length of current global variables resource + // This would most probably be trapped by the checksum test anyway, + // but it doesn't do any harm to check this as well. + + // Historical note: During development, earlier savegames would often + // be shorter than the current expected length. + + if (readS.readUint32LE() != _resman->fetchLen(1)) { + free(buffer); + return SR_ERR_INCOMPATIBLE; + } + + byte *globalVars = _resman->openResource(1); + byte *objectHub = _resman->openResource(CUR_PLAYER_ID) + ResHeader::size(); + + uint32 screenId = readS.readUint32LE(); + uint32 runListId = readS.readUint32LE(); + uint32 feetX = readS.readUint32LE(); + uint32 feetY = readS.readUint32LE(); + uint32 musicId = readS.readUint32LE(); + + // Trash all resources from memory except player object & global vars + _resman->killAll(false); + _logic->resetKillList(); + + readS.read(objectHub, ObjectHub::size()); + readS.read(_logic->_saveLogic, ObjectLogic::size()); + readS.read(_logic->_saveGraphic, ObjectGraphic::size()); + readS.read(_logic->_saveMega, ObjectMega::size()); + + // Fill out the player object structures from the savegame structures. + // Also run the appropriate scripts to set up George's anim tables and + // walkdata, and Nico's anim tables. + + // Script no. 8 - 'george_savedata_return' calls fnGetPlayerSaveData + _logic->runResScript(CUR_PLAYER_ID, 8); + + // Script no. 14 - 'set_up_nico_anim_tables' + _logic->runResScript(CUR_PLAYER_ID, 14); + + // Which megaset was the player at the time of saving? + ObjectMega obMega(_logic->_saveMega); + + uint32 scriptNo = 0; + + switch (obMega.getMegasetRes()) { + case 36: // GeoMega: + scriptNo = 9; // script no.9 - 'player_is_george' + break; + case 2003: // GeoMegaB: + scriptNo = 13; // script no.13 - 'player_is_georgeB' + break; + case 1366: // NicMegaA: + scriptNo = 11; // script no.11 - 'player_is_nicoA' + break; + case 1437: // NicMegaB: + scriptNo = 12; // script no.12 - 'player_is_nicoB' + break; + case 1575: // NicMegaC: + scriptNo = 10; // script no.10 - 'player_is_nicoC' + break; + } + + _logic->runResScript(CUR_PLAYER_ID, scriptNo); + + // Copy variables from savegame buffer to memory + readS.read(globalVars, _resman->fetchLen(1)); + + _resman->closeResource(CUR_PLAYER_ID); + _resman->closeResource(1); + + free(buffer); + + int32 pars[2]; + + pars[0] = screenId; + pars[1] = 1; + _logic->fnInitBackground(pars); + + ScreenInfo *screenInfo = _screen->getScreenInfo(); + + // So palette not restored immediately after control panel - we want to + // fade up instead! + screenInfo->new_palette = 99; + + // These need setting after the defaults get set in fnInitBackground. + // Remember that these can change through the game, so need saving & + // restoring too. + + screenInfo->feet_x = feetX; + screenInfo->feet_y = feetY; + + // Start the new run list + _logic->expressChangeSession(runListId); + + // Force in the new scroll position, so unsightly scroll-catch-up does + // not occur when screen first draws after returning from restore panel + + // Set the screen record of player position - ready for setScrolling() + + screenInfo->player_feet_x = obMega.getFeetX(); + screenInfo->player_feet_y = obMega.getFeetY(); + + // if this screen is wide, recompute the scroll offsets now + if (screenInfo->scroll_flag) + _screen->setScrolling(); + + // Any music required will be started after we've returned from + // restoreControl() - see systemMenuMouse() in mouse.cpp! + + // Restart any looping music. Originally this was - and still is - done + // in systemMenuMouse(), but with ScummVM we have other ways of + // restoring savegames so it's easier to put it here as well. + + if (musicId) { + pars[0] = musicId; + pars[1] = FX_LOOP; + _logic->fnPlayMusic(pars); + } else + _logic->fnStopMusic(NULL); + + return SR_OK; +} + +/** + * Get the description of a savegame + */ + +uint32 Sword2Engine::getSaveDescription(uint16 slotNo, byte *description) { + char saveFileName[MAX_FILENAME_LEN]; + + sprintf(saveFileName, "%s.%.3d", _targetName.c_str(), slotNo); + + Common::InSaveFile *in; + + if (!(in = _saveFileMan->openForLoading(saveFileName))) { + return SR_ERR_FILEOPEN; + } + + in->readUint32LE(); + in->read(description, SAVE_DESCRIPTION_LEN); + + delete in; + return SR_OK; +} + +bool Sword2Engine::saveExists() { + for (int i = 0; i <= 99; i++) + if (saveExists(i)) + return true; + return false; +} + +bool Sword2Engine::saveExists(uint16 slotNo) { + char saveFileName[MAX_FILENAME_LEN]; + + sprintf(saveFileName, "%s.%.3d", _targetName.c_str(), slotNo); + + Common::InSaveFile *in; + + if (!(in = _saveFileMan->openForLoading(saveFileName))) { + return false; + } + + delete in; + return true; +} + +uint32 Sword2Engine::calcChecksum(byte *buffer, uint32 size) { + uint32 total = 0; + + for (uint32 pos = 0; pos < size; pos++) + total += buffer[pos]; + + return total; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/save_rest.h b/engines/sword2/save_rest.h new file mode 100644 index 0000000000..9463f3fd4a --- /dev/null +++ b/engines/sword2/save_rest.h @@ -0,0 +1,47 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef SAVE_REST_H +#define SAVE_REST_H + +namespace Sword2 { + +#define SAVE_DESCRIPTION_LEN 64 + +// Save & Restore error codes + +enum { + SR_OK, // No worries + SR_ERR_FILEOPEN, // Can't open file - Couldn't create file for + // saving, or couldn't find file for loading. + SR_ERR_INCOMPATIBLE, // (Restore) Incompatible savegame data. + // Savegame file is obsolete. (Won't happen + // after development stops) + SR_ERR_READFAIL, // (Restore) Failed on reading savegame file - + // Something screwed up during the read + SR_ERR_WRITEFAIL // (Save) Failed on writing savegame file - + // Something screwed up during the write - + // could be hard-drive full..? +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/scroll.cpp b/engines/sword2/scroll.cpp new file mode 100644 index 0000000000..3d0a263bc6 --- /dev/null +++ b/engines/sword2/scroll.cpp @@ -0,0 +1,151 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/logic.h" + +namespace Sword2 { + +// Max no of pixel allowed to scroll per cycle +#define MAX_SCROLL_DISTANCE 8 + +/** + * Sets the scroll target position for the end of the game cycle. The driver + * will then automatically scroll as many times as it can to reach this + * position in the allotted time. + */ + +void Screen::setScrollTarget(int16 sx, int16 sy) { + _scrollXTarget = sx; + _scrollYTarget = sy; +} + +/** + * If the room is larger than the physical screen, this function is called + * every game cycle to update the scroll offsets. + */ + +void Screen::setScrolling() { + // Normally we aim to get George's feet at (320,250) from top left + // of screen window + // feet_x = 128 + 320 + // feet_y = 128 + 250 + + // Set scroll offsets according to the player's coords + + // If the scroll offsets are being forced in script, ensure that they + // are neither too far to the right nor too far down. + uint32 scrollX = _vm->_logic->readVar(SCROLL_X); + uint32 scrollY = _vm->_logic->readVar(SCROLL_Y); + + if (scrollX || scrollY) { + _thisScreen.scroll_offset_x = MIN((uint16)scrollX, _thisScreen.max_scroll_offset_x); + _thisScreen.scroll_offset_y = MIN((uint16)scrollY, _thisScreen.max_scroll_offset_y); + return; + } + + // George's offset from the centre - the desired position for him + + int16 offset_x = _thisScreen.player_feet_x - _thisScreen.feet_x; + int16 offset_y = _thisScreen.player_feet_y - _thisScreen.feet_y; + + // Prevent scrolling too far left/right/up/down + + if (offset_x < 0) + offset_x = 0; + else if (offset_x > _thisScreen.max_scroll_offset_x) + offset_x = _thisScreen.max_scroll_offset_x; + + if (offset_y < 0) + offset_y = 0; + else if (offset_y > _thisScreen.max_scroll_offset_y) + offset_y = _thisScreen.max_scroll_offset_y; + + // First time on this screen - need absolute scroll immediately! + + if (_thisScreen.scroll_flag == 2) { + debug(5, "init scroll"); + _thisScreen.scroll_offset_x = offset_x; + _thisScreen.scroll_offset_y = offset_y; + _thisScreen.scroll_flag = 1; + return; + } + + // Catch up with required scroll offsets - speed depending on distance + // to catch up (dx and dy) and _scrollFraction used, but limit to + // certain number of pixels per cycle (MAX_SCROLL_DISTANCE) + + int16 dx = _thisScreen.scroll_offset_x - offset_x; + int16 dy = _thisScreen.scroll_offset_y - offset_y; + + uint16 scroll_distance_x; // how much we want to scroll + uint16 scroll_distance_y; + + if (dx < 0) { + // Current scroll_offset_x is less than the required value + + // NB. I'm adding 1 to the result of dx / SCROLL_FRACTION, + // because it would otherwise not scroll at all when + // dx < SCROLL_FRACTION + + // => inc by (fraction of the differnce) NB. dx is -ve, so we + // subtract dx / SCROLL_FRACTION + + scroll_distance_x = 1 - dx / _scrollFraction; + + if (scroll_distance_x > MAX_SCROLL_DISTANCE) + scroll_distance_x = MAX_SCROLL_DISTANCE; + + _thisScreen.scroll_offset_x += scroll_distance_x; + } else if (dx > 0) { + // Current scroll_offset_x is greater than + // the required value + + // => dec by (fraction of the differnce) + + scroll_distance_x = 1 + dx / _scrollFraction; + + if (scroll_distance_x > MAX_SCROLL_DISTANCE) + scroll_distance_x = MAX_SCROLL_DISTANCE; + + _thisScreen.scroll_offset_x -= scroll_distance_x; + } + + if (dy < 0) { + scroll_distance_y = 1 - dy / _scrollFraction; + + if (scroll_distance_y > MAX_SCROLL_DISTANCE) + scroll_distance_y = MAX_SCROLL_DISTANCE; + + _thisScreen.scroll_offset_y += scroll_distance_y; + } else if (dy > 0) { + scroll_distance_y = 1 + dy / _scrollFraction; + + if (scroll_distance_y > MAX_SCROLL_DISTANCE) + scroll_distance_y = MAX_SCROLL_DISTANCE; + + _thisScreen.scroll_offset_y -= scroll_distance_y; + } +} + +} // End of namespace Sword2 diff --git a/engines/sword2/sound.cpp b/engines/sword2/sound.cpp new file mode 100644 index 0000000000..d855e88afb --- /dev/null +++ b/engines/sword2/sound.cpp @@ -0,0 +1,319 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +// --------------------------------------------------------------------------- +// BROKEN SWORD 2 +// +// SOUND.CPP Contains the sound engine, fx & music functions +// Some very 'sound' code in here ;) +// +// (16Dec96 JEL) +// +// --------------------------------------------------------------------------- + +#include "common/stdafx.h" +#include "common/file.h" +#include "common/system.h" + +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/resman.h" +#include "sword2/sound.h" + +#include "sound/wave.h" + +namespace Sword2 { + +Sound::Sound(Sword2Engine *vm) { + int i; + + _vm = vm; + + for (i = 0; i < FXQ_LENGTH; i++) + _fxQueue[i].resource = 0; + + for (i = 0; i < MAXMUS; i++) { + _music[i] = NULL; + + _musicFile[i].idxTab = NULL; + _musicFile[i].idxLen = 0; + _musicFile[i].fileSize = 0; + _musicFile[i].fileType = 0; + _musicFile[i].inUse = false; + + _speechFile[i].idxTab = NULL; + _speechFile[i].idxLen = 0; + _speechFile[i].fileSize = 0; + _speechFile[i].fileType = 0; + _speechFile[i].inUse = false; + } + + _speechPaused = false; + _musicPaused = false; + _fxPaused = false; + + _speechMuted = false; + _musicMuted = false; + _fxMuted = false; + + _reverseStereo = false; + + _loopingMusicId = 0; + + _mixBuffer = NULL; + _mixBufferLen = 0; + + _vm->_mixer->setupPremix(this, Audio::Mixer::kMusicSoundType); +} + +Sound::~Sound() { + _vm->_mixer->setupPremix(0); + + clearFxQueue(); + stopMusic(true); + stopSpeech(); + + free(_mixBuffer); + + for (int i = 0; i < MAXMUS; i++) { + if (_musicFile[i].file.isOpen()) + _musicFile[i].file.close(); + if (_speechFile[i].file.isOpen()) + _speechFile[i].file.close(); + + free(_musicFile[i].idxTab); + free(_speechFile[i].idxTab); + } +} + +void Sound::setReverseStereo(bool reverse) { + if (reverse != _reverseStereo) { + _reverseStereo = reverse; + + for (int i = 0; i < FXQ_LENGTH; i++) { + if (!_fxQueue[i].resource) + continue; + + _fxQueue[i].pan = -_fxQueue[i].pan; + _vm->_mixer->setChannelBalance(_fxQueue[i].handle, _fxQueue[i].pan); + } + } +} + +/** + * Stop all sounds, close their resources and clear the FX queue. + */ + +void Sound::clearFxQueue() { + for (int i = 0; i < FXQ_LENGTH; i++) { + if (_fxQueue[i].resource) { + stopFx(i); + } + } +} + +/** + * Process the FX queue. This function is called once every game cycle. + */ + +void Sound::processFxQueue() { + for (int i = 0; i < FXQ_LENGTH; i++) { + if (!_fxQueue[i].resource) + continue; + + switch (_fxQueue[i].type) { + case FX_RANDOM: + // 1 in 'delay' chance of this fx occurring + if (_vm->_rnd.getRandomNumber(_fxQueue[i].delay) == 0) + playFx(&_fxQueue[i]); + break; + case FX_SPOT: + if (_fxQueue[i].delay) + _fxQueue[i].delay--; + else { + playFx(&_fxQueue[i]); + _fxQueue[i].type = FX_SPOT2; + } + break; + case FX_LOOP: + playFx(&_fxQueue[i]); + _fxQueue[i].type = FX_LOOPING; + break; + case FX_SPOT2: + // Once the FX has finished remove it from the queue. + if (!_vm->_mixer->isSoundHandleActive(_fxQueue[i].handle)) { + _vm->_resman->closeResource(_fxQueue[i].resource); + _fxQueue[i].resource = 0; + } + break; + case FX_LOOPING: + // Once the looped FX has started we can ignore it, + // but we can't close it since the WAV data is in use. + break; + } + } +} + +/** + * Queue a sound effect for playing later. + * @param res the sound resource number + * @param type the type of sound effect + * @param delay when to play the sound effect + * @param volume the sound effect volume (0 through 16) + * @param pan the sound effect panning (-16 through 16) + */ + +void Sound::queueFx(int32 res, int32 type, int32 delay, int32 volume, int32 pan) { + if (_vm->_wantSfxDebug) { + const char *typeStr; + + switch (type) { + case FX_SPOT: + typeStr = "SPOT"; + break; + case FX_LOOP: + typeStr = "LOOPED"; + break; + case FX_RANDOM: + typeStr = "RANDOM"; + break; + default: + typeStr = "INVALID"; + break; + } + + byte buf[NAME_LEN]; + + debug(0, "SFX (sample=\"%s\", vol=%d, pan=%d, delay=%d, type=%s)", _vm->_resman->fetchName(res, buf), volume, pan, delay, typeStr); + } + + for (int i = 0; i < FXQ_LENGTH; i++) { + if (!_fxQueue[i].resource) { + byte *data = _vm->_resman->openResource(res); + + assert(_vm->_resman->fetchType(data) == WAV_FILE); + + uint32 len = _vm->_resman->fetchLen(res) - ResHeader::size(); + + if (type == FX_RANDOM) { + // For spot effects and loops the delay is the + // number of frames to wait. For random + // effects, however, it's the average number of + // seconds between playing the sound, so we + // have to multiply by the frame rate. + delay *= 12; + } + + volume = (volume * Audio::Mixer::kMaxChannelVolume) / 16; + pan = (pan * 127) / 16; + + if (isReverseStereo()) + pan = -pan; + + _fxQueue[i].resource = res; + _fxQueue[i].data = data + ResHeader::size(); + _fxQueue[i].len = len; + _fxQueue[i].delay = delay; + _fxQueue[i].volume = volume; + _fxQueue[i].pan = pan; + _fxQueue[i].type = type; + + // Keep track of the index in the loop so that + // fnStopFx() can be used later to kill this sound. + // Mainly for FX_LOOP and FX_RANDOM. + + _vm->_logic->writeVar(RESULT, i); + return; + } + } + + warning("No free slot in FX queue"); +} + +int32 Sound::playFx(FxQueueEntry *fx) { + return playFx(&fx->handle, fx->data, fx->len, fx->volume, fx->pan, (fx->type == FX_LOOP), Audio::Mixer::kSFXSoundType); +} + +int32 Sound::playFx(Audio::SoundHandle *handle, byte *data, uint32 len, uint8 vol, int8 pan, bool loop, Audio::Mixer::SoundType soundType) { + if (_fxMuted) + return RD_OK; + + if (_vm->_mixer->isSoundHandleActive(*handle)) + return RDERR_FXALREADYOPEN; + + Common::MemoryReadStream stream(data, len); + int rate, size; + byte flags; + + if (!loadWAVFromStream(stream, size, rate, flags)) { + warning("playFX: Not a valid WAV file"); + return RDERR_INVALIDWAV; + } + + // The resource manager must have complete control over when resources + // are freed, or reference counting will break horribly. Besides, the + // data pointer is not valid for passing to free(). Why the hell is the + // AUTOFREE flag set by default anyway? + + flags &= ~Audio::Mixer::FLAG_AUTOFREE; + + if (isReverseStereo()) + flags |= Audio::Mixer::FLAG_REVERSE_STEREO; + + if (loop) + flags |= Audio::Mixer::FLAG_LOOP; + + _vm->_mixer->playRaw(handle, data + stream.pos(), size, rate, flags, -1, vol, pan, 0, 0, soundType); + return RD_OK; +} + +/** + * This function closes a sound effect which has been previously opened for + * playing. Sound effects must be closed when they are finished with, otherwise + * you will run out of sound effect buffers. + * @param i the index of the sound to close + */ + +int32 Sound::stopFx(int32 i) { + if (!_fxQueue[i].resource) + return RDERR_FXNOTOPEN; + + _vm->_mixer->stopHandle(_fxQueue[i].handle); + + _vm->_resman->closeResource(_fxQueue[i].resource); + _fxQueue[i].resource = 0; + return RD_OK; +} + +void Sound::pauseAllSound() { + pauseMusic(); + pauseSpeech(); + pauseFx(); +} + +void Sound::unpauseAllSound() { + unpauseMusic(); + unpauseSpeech(); + unpauseFx(); +} + +} // End of namespace Sword2 diff --git a/engines/sword2/sound.h b/engines/sword2/sound.h new file mode 100644 index 0000000000..7390a60bbc --- /dev/null +++ b/engines/sword2/sound.h @@ -0,0 +1,272 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +/***************************************************************************** + * SOUND.H Sound engine + * + * SOUND.CPP Contains the sound engine, fx & music functions + * Some very 'sound' code in here ;) + * + * (16Dec96 JEL) + * + ****************************************************************************/ + +#ifndef SOUND_H +#define SOUND_H + +#include "common/file.h" +#include "sound/audiostream.h" +#include "sound/mixer.h" + +// Max number of sound fx +#define MAXMUS 2 + +// Max number of fx in queue at once +#define FXQ_LENGTH 32 + +#define BUFFER_SIZE 4096 + +namespace Sword2 { + +enum { + kCLUMode = 1, + kMP3Mode, + kVorbisMode, + kFlacMode +}; + +enum { + // These three types correspond to types set by the scripts + FX_SPOT = 0, + FX_LOOP = 1, + FX_RANDOM = 2, + + // These are used for FX queue bookkeeping + FX_SPOT2 = 3, + FX_LOOPING = 4 +}; + +// Sound defines + +enum { + RDSE_SAMPLEFINISHED = 0, + RDSE_SAMPLEPLAYING = 1, + RDSE_FXTOCLEAR = 0, // Unused + RDSE_FXCACHED = 1, // Unused + RDSE_FXSPOT = 0, + RDSE_FXLOOP = 1, + RDSE_FXLEADIN = 2, + RDSE_FXLEADOUT = 3, + RDSE_QUIET = 1, + RDSE_SPEAKING = 0 +}; + +class CLUInputStream : public AudioStream { +private: + Common::File *_file; + bool _firstTime; + uint32 _file_pos; + uint32 _end_pos; + int16 _outbuf[BUFFER_SIZE]; + byte _inbuf[BUFFER_SIZE]; + const int16 *_bufferEnd; + const int16 *_pos; + + uint16 _prev; + + void refill(); + + inline bool eosIntern() const { + return _pos >= _bufferEnd; + } + +public: + CLUInputStream(Common::File *file, int size); + ~CLUInputStream(); + + int readBuffer(int16 *buffer, const int numSamples); + + bool endOfData() const { return eosIntern(); } + bool isStereo() const { return false; } + int getRate() const { return 22050; } +}; + +struct SoundFileHandle { + Common::File file; + uint32 *idxTab; + uint32 idxLen; + uint32 fileSize; + uint32 fileType; + volatile bool inUse; +}; + +class MusicInputStream : public AudioStream { +private: + int _cd; + SoundFileHandle *_fh; + uint32 _musicId; + AudioStream *_decoder; + int16 _buffer[BUFFER_SIZE]; + const int16 *_bufferEnd; + const int16 *_pos; + bool _remove; + uint32 _numSamples; + uint32 _samplesLeft; + bool _looping; + int32 _fading; + int32 _fadeSamples; + bool _paused; + + void refill(); + + inline bool eosIntern() const { + if (_looping) + return false; + return _remove || _pos >= _bufferEnd; + } + +public: + MusicInputStream(int cd, SoundFileHandle *fh, uint32 musicId, bool looping); + ~MusicInputStream(); + + int readBuffer(int16 *buffer, const int numSamples); + + bool endOfData() const { return eosIntern(); } + bool isStereo() const { return _decoder->isStereo(); } + int getRate() const { return _decoder->getRate(); } + + int getCD() { return _cd; } + + void fadeUp(); + void fadeDown(); + + bool isReady() { return _decoder != NULL; } + int32 isFading() { return _fading; } + + bool readyToRemove(); + int32 getTimeRemaining(); +}; + +class Sound : public AudioStream { +private: + Sword2Engine *_vm; + + Common::Mutex _mutex; + + struct FxQueueEntry { + Audio::SoundHandle handle; // sound handle + uint32 resource; // resource id of sample + byte *data; // pointer to WAV data + uint32 len; // WAV data length + uint16 delay; // cycles to wait before playing (or 'random chance' if FX_RANDOM) + uint8 volume; // sound volume + int8 pan; // sound panning + uint8 type; // FX_SPOT, FX_RANDOM, FX_LOOP + }; + + FxQueueEntry _fxQueue[FXQ_LENGTH]; + + void triggerFx(uint8 i); + + bool _reverseStereo; + + bool _speechMuted; + bool _fxMuted; + bool _musicMuted; + + bool _speechPaused; + bool _fxPaused; + bool _musicPaused; + + int32 _loopingMusicId; + + Audio::SoundHandle _soundHandleSpeech; + + MusicInputStream *_music[MAXMUS]; + SoundFileHandle _musicFile[MAXMUS]; + SoundFileHandle _speechFile[MAXMUS]; + + int16 *_mixBuffer; + int _mixBufferLen; + +public: + Sound(Sword2Engine *vm); + ~Sound(); + + // AudioStream API + + int readBuffer(int16 *buffer, const int numSamples); + bool isStereo() const { return false; } + bool endOfData() const; + int getRate() const { return 22050; } + + // End of AudioStream API + + void clearFxQueue(); + void processFxQueue(); + + void setReverseStereo(bool reverse); + bool isReverseStereo() const { return _reverseStereo; } + + void muteSpeech(bool mute); + bool isSpeechMute() const { return _speechMuted; } + + void muteFx(bool mute); + bool isFxMute() const { return _fxMuted; } + + void muteMusic(bool mute) { _musicMuted = mute; } + bool isMusicMute() const { return _musicMuted; } + + void setLoopingMusicId(int32 id) { _loopingMusicId = id; } + int32 getLoopingMusicId() const { return _loopingMusicId; } + + void pauseSpeech(); + void unpauseSpeech(); + + void pauseFx(); + void unpauseFx(); + + void pauseMusic(); + void unpauseMusic(); + + void pauseAllSound(); + void unpauseAllSound(); + + void queueFx(int32 res, int32 type, int32 delay, int32 volume, int32 pan); + int32 playFx(FxQueueEntry *fx); + int32 playFx(Audio::SoundHandle *handle, byte *data, uint32 len, uint8 vol, int8 pan, bool loop, Audio::Mixer::SoundType soundType); + int32 stopFx(int32 i); + int32 setFxIdVolumePan(int32 id, int vol, int pan = 255); + + int32 getSpeechStatus(); + int32 amISpeaking(); + int32 playCompSpeech(uint32 speechId, uint8 vol, int8 pan); + uint32 preFetchCompSpeech(uint32 speechId, uint16 **buf); + int32 stopSpeech(); + + int32 streamCompMusic(uint32 musicId, bool loop); + void stopMusic(bool immediately); + int32 musicTimeRemaining(); +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/speech.cpp b/engines/sword2/speech.cpp new file mode 100644 index 0000000000..da6bd258ea --- /dev/null +++ b/engines/sword2/speech.cpp @@ -0,0 +1,229 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "common/file.h" + +#include "sword2/sword2.h" +#include "sword2/console.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/maketext.h" +#include "sword2/resman.h" + +namespace Sword2 { + +// To request the status of a target, we run its 4th script, get-speech-state. +// This will cause RESULT to be set to either 1 (target is waiting) or 0 +// (target is busy). + +// Distance kept above talking sprite +#define GAP_ABOVE_HEAD 20 + +enum { + S_OB_GRAPHIC = 0, + S_OB_SPEECH = 1, + S_OB_LOGIC = 2, + S_OB_MEGA = 3, + + S_TEXT = 4, + S_WAV = 5, + S_ANIM = 6, + S_DIR_TABLE = 7, + S_ANIM_MODE = 8 +}; + +/** + * Sets _textX and _textY for position of text sprite. Note that _textX is + * also used to calculate speech pan. + */ + +void Logic::locateTalker(int32 *params) { + // params: 0 pointer to ob_graphic + // 1 pointer to ob_speech + // 2 pointer to ob_logic + // 3 pointer to ob_mega + // 4 encoded text number + // 5 wav res id + // 6 anim res id + // 7 pointer to anim table + // 8 animation mode 0 lip synced, + // 1 just straight animation + + if (!_animId) { + // There is no animation. Assume it's voice-over text, and put + // it at the bottom of the screen. + + _textX = 320; + _textY = 400; + return; + } + + byte *file = _vm->_resman->openResource(_animId); + + // '0' means 1st frame + + CdtEntry cdt_entry; + FrameHeader frame_head; + + cdt_entry.read(_vm->fetchCdtEntry(file, 0)); + frame_head.read(_vm->fetchFrameHeader(file, 0)); + + // Note: This part of the code is quite similar to registerFrame(). + + if (cdt_entry.frameType & FRAME_OFFSET) { + // The frame has offsets, i.e. it's a scalable mega frame + ObjectMega obMega(decodePtr(params[S_OB_MEGA])); + + uint16 scale = obMega.calcScale(); + + // Calc suitable centre point above the head, based on scaled + // height + + // just use 'feet_x' as centre + _textX = obMega.getFeetX(); + + // Add scaled y-offset to feet_y coord to get top of sprite + _textY = obMega.getFeetY() + (cdt_entry.y * scale) / 256; + } else { + // It's a non-scaling anim - calc suitable centre point above + // the head, based on scaled width + + // x-coord + half of width + _textX = cdt_entry.x + frame_head.width / 2; + _textY = cdt_entry.y; + } + + _vm->_resman->closeResource(_animId); + + // Leave space above their head + _textY -= GAP_ABOVE_HEAD; + + // Adjust the text coords for RDSPR_DISPLAYALIGN + + ScreenInfo *screenInfo = _vm->_screen->getScreenInfo(); + + _textX -= screenInfo->scroll_offset_x; + _textY -= screenInfo->scroll_offset_y; +} + +/** + * This function is called the first time to build the text, if we need one. If + * If necessary it also brings in the wav and sets up the animation. + * + * If there is an animation it can be repeating lip-sync or run-once. + * + * If there is no wav, then the text comes up instead. There can be any + * combination of text/wav playing. + */ + +void Logic::formText(int32 *params) { + // params 0 pointer to ob_graphic + // 1 pointer to ob_speech + // 2 pointer to ob_logic + // 3 pointer to ob_mega + // 4 encoded text number + // 5 wav res id + // 6 anim res id + // 7 pointer to anim table + // 8 animation mode 0 lip synced, + // 1 just straight animation + + // There should always be a text line, as all text is derived from it. + // If there is none, that's bad... + + if (!params[S_TEXT]) { + warning("No text line for speech wav %d", params[S_WAV]); + return; + } + + ObjectSpeech obSpeech(decodePtr(params[S_OB_SPEECH])); + + // Establish the max width allowed for this text sprite. + uint32 textWidth = obSpeech.getWidth(); + + if (!textWidth) + textWidth = 400; + + // Pull out the text line, and make the sprite and text block + + uint32 text_res = params[S_TEXT] / SIZE; + uint32 local_text = params[S_TEXT] & 0xffff; + byte *text = _vm->fetchTextLine(_vm->_resman->openResource(text_res), local_text); + + // 'text + 2' to skip the first 2 bytes which form the line reference + // number + + _speechTextBlocNo = _vm->_fontRenderer->buildNewBloc( + text + 2, _textX, _textY, + textWidth, obSpeech.getPen(), + RDSPR_TRANS | RDSPR_DISPLAYALIGN, + _vm->_speechFontId, POSITION_AT_CENTRE_OF_BASE); + + _vm->_resman->closeResource(text_res); + + // Set speech duration, in case not using a wav. + _speechTime = strlen((char *)text) + 30; +} + +/** + * There are some hard-coded cases where speech is used to illustrate a sound + * effect. In this case there is no sound associated with the speech itself. + */ + +bool Logic::wantSpeechForLine(uint32 wavId) { + switch (wavId) { + case 1328: // AttendantSpeech + // SFX(Phone71); + // FX <Telephone rings> + case 2059: // PabloSpeech + // SFX (2059); + // FX <Sound of sporadic gunfire from below> + case 4082: // DuaneSpeech + // SFX (4082); + // FX <Pffffffffffft! Frp. (Unimpressive, flatulent noise.)> + case 4214: // cat_52 + // SFX (4214); + // 4214FXMeow! + case 4568: // trapdoor_13 + // SFX (4568); + // 4568fx<door slamming> + case 4913: // LobineauSpeech + // SFX (tone2); + // FX <Lobineau hangs up> + case 5120: // bush_66 + // SFX (5120); + // 5120FX<loud buzzing> + case 528: // PresidentaSpeech + // SFX (528); + // FX <Nearby Crash of Collapsing Masonry> + case 920: // Zombie Island forest maze (bird) + case 923: // Zombie Island forest maze (monkey) + case 926: // Zombie Island forest maze (zombie) + // Don't want speech for these lines! + return false; + default: + // Ok for all other lines + return true; + } +} + +} // End of namespace Sword2 diff --git a/engines/sword2/sprite.cpp b/engines/sword2/sprite.cpp new file mode 100644 index 0000000000..a0ba7f7189 --- /dev/null +++ b/engines/sword2/sprite.cpp @@ -0,0 +1,655 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" + +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/build_display.h" + +namespace Sword2 { + +/** + * This function takes a sprite and creates a mirror image of it. + * @param dst destination buffer + * @param src source buffer + * @param w width of the sprite + * @param h height of the sprite + */ + +void Screen::mirrorSprite(byte *dst, byte *src, int16 w, int16 h) { + for (int y = 0; y < h; y++) { + for (int x = 0; x < w; x++) { + *dst++ = *(src + w - x - 1); + } + src += w; + } +} + +/** + * This function takes a compressed frame of a sprite with up to 256 colours + * and decompresses it. + * @param dst destination buffer + * @param src source buffer + * @param decompSize the expected size of the decompressed sprite + */ + +int32 Screen::decompressRLE256(byte *dst, byte *src, int32 decompSize) { + // PARAMETERS: + // source points to the start of the sprite data for input + // decompSize gives size of decompressed data in bytes + // dest points to start of destination buffer for decompressed + // data + + byte headerByte; // block header byte + byte *endDest = dst + decompSize; // pointer to byte after end of decomp buffer + int32 rv; + + while (1) { + // FLAT block + // read FLAT block header & increment 'scan' to first pixel + // of block + headerByte = *src++; + + // if this isn't a zero-length block + if (headerByte) { + if (dst + headerByte > endDest) { + rv = 1; + break; + } + + // set the next 'headerByte' pixels to the next colour + // at 'source' + memset(dst, *src, headerByte); + + // increment destination pointer to just after this + // block + dst += headerByte; + + // increment source pointer to just after this colour + src++; + + // if we've decompressed all of the data + if (dst == endDest) { + rv = 0; // return "OK" + break; + } + } + + // RAW block + // read RAW block header & increment 'scan' to first pixel of + // block + headerByte = *src++; + + // if this isn't a zero-length block + if (headerByte) { + if (dst + headerByte > endDest) { + rv = 1; + break; + } + + // copy the next 'headerByte' pixels from source to + // destination + memcpy(dst, src, headerByte); + + // increment destination pointer to just after this + // block + dst += headerByte; + + // increment source pointer to just after this block + src += headerByte; + + // if we've decompressed all of the data + if (dst == endDest) { + rv = 0; // return "OK" + break; + } + } + } + + return rv; +} + +/** + * Unwinds a run of 16-colour data into 256-colour palette data. + */ + +void Screen::unwindRaw16(byte *dst, byte *src, uint8 blockSize, byte *colTable) { + // for each pair of pixels + while (blockSize > 1) { + // 1st colour = number in table at position given by upper + // nibble of source byte + *dst++ = colTable[(*src) >> 4]; + + // 2nd colour = number in table at position given by lower + // nibble of source byte + *dst++ = colTable[(*src) & 0x0f]; + + // point to next source byte + src++; + + // decrement count of how many pixels left to read + blockSize -= 2; + } + + // if there's a final odd pixel + if (blockSize) { + // colour = number in table at position given by upper nibble + // of source byte + *dst++ = colTable[(*src) >> 4]; + } +} + +/** + * This function takes a compressed frame of a sprite (with up to 16 colours) + * and decompresses it. + * @param dst destination buffer + * @param src source buffer + * @param decompSize the expected size of the uncompressed sprite + * @param colTable mapping from the 16 encoded colours to the current palette + */ + +int32 Screen::decompressRLE16(byte *dst, byte *src, int32 decompSize, byte *colTable) { + byte headerByte; // block header byte + byte *endDest = dst + decompSize; // pointer to byte after end of decomp buffer + int32 rv; + + while (1) { + // FLAT block + // read FLAT block header & increment 'scan' to first pixel + // of block + headerByte = *src++; + + // if this isn't a zero-length block + if (headerByte) { + if (dst + headerByte > endDest) { + rv = 1; + break; + } + + // set the next 'headerByte' pixels to the next + // colour at 'source' + memset(dst, *src, headerByte); + + // increment destination pointer to just after this + // block + dst += headerByte; + + // increment source pointer to just after this colour + src++; + + // if we've decompressed all of the data + if (dst == endDest) { + rv = 0; // return "OK" + break; + } + } + + // RAW block + // read RAW block header & increment 'scan' to first pixel of + // block + headerByte = *src++; + + // if this isn't a zero-length block + if (headerByte) { + if (dst + headerByte > endDest) { + rv = 1; + break; + } + + // copy the next 'headerByte' pixels from source to + // destination (NB. 2 pixels per byte) + unwindRaw16(dst, src, headerByte, colTable); + + // increment destination pointer to just after this + // block + dst += headerByte; + + // increment source pointer to just after this block + // (NB. headerByte gives pixels, so /2 for bytes) + src += (headerByte + 1) / 2; + + // if we've decompressed all of the data + if (dst >= endDest) { + rv = 0; // return "OK" + break; + } + } + } + + return rv; +} + +/** + * Creates a sprite surface. Sprite surfaces are used by the in-game dialogs + * and for displaying cutscene subtitles, which makes them much easier to draw + * than standard sprites. + * @param s information about how to decode the sprite + * @param sprite the buffer that will be created to store the surface + * @return RD_OK, or an error code + */ + +int32 Screen::createSurface(SpriteInfo *s, byte **sprite) { + *sprite = (byte *)malloc(s->w * s->h); + if (!*sprite) + return RDERR_OUTOFMEMORY; + + // Surfaces are either uncompressed or RLE256-compressed. No need to + // test for anything else. + + if (s->type & RDSPR_NOCOMPRESSION) { + memcpy(*sprite, s->data, s->w * s->h); + } else if (decompressRLE256(*sprite, s->data, s->w * s->h)) { + free(*sprite); + return RDERR_DECOMPRESSION; + } + + return RD_OK; +} + +/** + * Draws the sprite surface created earlier. + * @param s information about how to place the sprite + * @param surface pointer to the surface created earlier + * @param clipRect the clipping rectangle + */ + +void Screen::drawSurface(SpriteInfo *s, byte *surface, Common::Rect *clipRect) { + Common::Rect rd, rs; + uint16 x, y; + byte *src, *dst; + + rs.left = 0; + rs.right = s->w; + rs.top = 0; + rs.bottom = s->h; + + rd.left = s->x; + rd.right = rd.left + rs.right; + rd.top = s->y; + rd.bottom = rd.top + rs.bottom; + + Common::Rect defClipRect(0, 0, _screenWide, _screenDeep); + + if (!clipRect) { + clipRect = &defClipRect; + } + + if (clipRect->left > rd.left) { + rs.left += (clipRect->left - rd.left); + rd.left = clipRect->left; + } + + if (clipRect->top > rd.top) { + rs.top += (clipRect->top - rd.top); + rd.top = clipRect->top; + } + + if (clipRect->right < rd.right) { + rd.right = clipRect->right; + } + + if (clipRect->bottom < rd.bottom) { + rd.bottom = clipRect->bottom; + } + + if (rd.width() <= 0 || rd.height() <= 0) + return; + + src = surface + rs.top * s->w + rs.left; + dst = _buffer + _screenWide * rd.top + rd.left; + + // Surfaces are always transparent. + + for (y = 0; y < rd.height(); y++) { + for (x = 0; x < rd.width(); x++) { + if (src[x]) + dst[x] = src[x]; + } + src += s->w; + dst += _screenWide; + } + + updateRect(&rd); +} + +/** + * Destroys a surface. + */ + +void Screen::deleteSurface(byte *surface) { + free(surface); +} + +/** + * Draws a sprite onto the screen. The type of the sprite can be a combination + * of the following flags, some of which are mutually exclusive: + * RDSPR_DISPLAYALIGN The sprite is drawn relative to the top left corner + * of the screen + * RDSPR_FLIP The sprite is mirrored + * RDSPR_TRANS The sprite has a transparent colour zero + * RDSPR_BLEND The sprite is translucent + * RDSPR_SHADOW The sprite is affected by the light mask. (Scaled + * sprites always are.) + * RDSPR_NOCOMPRESSION The sprite data is not compressed + * RDSPR_RLE16 The sprite data is a 16-colour compressed sprite + * RDSPR_RLE256 The sprite data is a 256-colour compressed sprite + * @param s all the information needed to draw the sprite + * @warning Sprites will only be drawn onto the background, not over menubar + * areas. + */ + +// FIXME: I'm sure this could be optimized. There's plenty of data copying and +// mallocing here. + +int32 Screen::drawSprite(SpriteInfo *s) { + byte *src, *dst; + byte *sprite, *newSprite; + uint16 scale; + int16 i, j; + uint16 srcPitch; + bool freeSprite = false; + Common::Rect rd, rs; + + // ----------------------------------------------------------------- + // Decompression and mirroring + // ----------------------------------------------------------------- + + if (s->type & RDSPR_NOCOMPRESSION) + sprite = s->data; + else { + sprite = (byte *)malloc(s->w * s->h); + freeSprite = true; + if (!sprite) + return RDERR_OUTOFMEMORY; + if ((s->type & 0xff00) == RDSPR_RLE16) { + if (decompressRLE16(sprite, s->data, s->w * s->h, s->colourTable)) { + free(sprite); + return RDERR_DECOMPRESSION; + } + } else { + if (decompressRLE256(sprite, s->data, s->w * s->h)) { + free(sprite); + return RDERR_DECOMPRESSION; + } + } + } + + if (s->type & RDSPR_FLIP) { + newSprite = (byte *)malloc(s->w * s->h); + if (newSprite == NULL) { + if (freeSprite) + free(sprite); + return RDERR_OUTOFMEMORY; + } + mirrorSprite(newSprite, sprite, s->w, s->h); + if (freeSprite) + free(sprite); + sprite = newSprite; + freeSprite = true; + } + + // ----------------------------------------------------------------- + // Positioning and clipping. + // ----------------------------------------------------------------- + + int16 spriteX = s->x; + int16 spriteY = s->y; + + if (!(s->type & RDSPR_DISPLAYALIGN)) { + spriteX += _parallaxScrollX; + spriteY += _parallaxScrollY; + } + + spriteY += MENUDEEP; + + // A scale factor 0 or 256 means don't scale. Why do they use two + // different values to mean the same thing? Normalize it here for + // convenience. + + scale = (s->scale == 0) ? 256 : s->scale; + + rs.top = 0; + rs.left = 0; + + if (scale != 256) { + rs.right = s->scaledWidth; + rs.bottom = s->scaledHeight; + srcPitch = s->scaledWidth; + } else { + rs.right = s->w; + rs.bottom = s->h; + srcPitch = s->w; + } + + rd.top = spriteY; + rd.left = spriteX; + + if (!(s->type & RDSPR_DISPLAYALIGN)) { + rd.top -= _scrollY; + rd.left -= _scrollX; + } + + rd.right = rd.left + rs.right; + rd.bottom = rd.top + rs.bottom; + + // Check if the sprite would end up completely outside the screen. + + if (rd.left > RENDERWIDE || rd.top > RENDERDEEP + MENUDEEP || rd.right < 0 || rd.bottom < MENUDEEP) { + if (freeSprite) + free(sprite); + return RD_OK; + } + + if (rd.top < MENUDEEP) { + rs.top = MENUDEEP - rd.top; + rd.top = MENUDEEP; + } + if (rd.bottom > RENDERDEEP + MENUDEEP) { + rd.bottom = RENDERDEEP + MENUDEEP; + rs.bottom = rs.top + (rd.bottom - rd.top); + } + if (rd.left < 0) { + rs.left = -rd.left; + rd.left = 0; + } + if (rd.right > RENDERWIDE) { + rd.right = RENDERWIDE; + rs.right = rs.left + (rd.right - rd.left); + } + + // ----------------------------------------------------------------- + // Scaling + // ----------------------------------------------------------------- + + if (scale != 256) { + if (s->scaledWidth > SCALE_MAXWIDTH || s->scaledHeight > SCALE_MAXHEIGHT) { + if (freeSprite) + free(sprite); + return RDERR_NOTIMPLEMENTED; + } + + newSprite = (byte *)malloc(s->scaledWidth * s->scaledHeight); + if (newSprite == NULL) { + if (freeSprite) + free(sprite); + return RDERR_OUTOFMEMORY; + } + + if (_renderCaps & RDBLTFX_EDGEBLEND) + scaleImageGood(newSprite, s->scaledWidth, s->scaledWidth, s->scaledHeight, sprite, s->w, s->w, s->h, _buffer + _screenWide * rd.top + rd.left); + else + scaleImageFast(newSprite, s->scaledWidth, s->scaledWidth, s->scaledHeight, sprite, s->w, s->w, s->h); + + if (freeSprite) + free(sprite); + sprite = newSprite; + freeSprite = true; + } + + // ----------------------------------------------------------------- + // Light masking + // ----------------------------------------------------------------- + + // The light mask is an optional layer that covers the entire room + // and which is used to simulate light and shadows. Scaled sprites + // (actors, presumably) are always affected. + + if ((_renderCaps & RDBLTFX_SHADOWBLEND) && _lightMask && (scale != 256 || (s->type & RDSPR_SHADOW))) { + byte *lightMap; + + // Make sure that we never apply the shadow to the original + // resource data. This could only ever happen in the + // RDSPR_NOCOMPRESSION case. + + if (!freeSprite) { + newSprite = (byte *)malloc(s->w * s->h); + memcpy(newSprite, sprite, s->w * s->h); + sprite = newSprite; + freeSprite = true; + } + + src = sprite + rs.top * srcPitch + rs.left; + lightMap = _lightMask + (rd.top + _scrollY - MENUDEEP) * _locationWide + rd.left + _scrollX; + + for (i = 0; i < rs.height(); i++) { + for (j = 0; j < rs.width(); j++) { + if (src[j] && lightMap[j]) { + uint8 r = ((32 - lightMap[j]) * _palette[src[j] * 4 + 0]) >> 5; + uint8 g = ((32 - lightMap[j]) * _palette[src[j] * 4 + 1]) >> 5; + uint8 b = ((32 - lightMap[j]) * _palette[src[j] * 4 + 2]) >> 5; + src[j] = quickMatch(r, g, b); + } + } + src += srcPitch; + lightMap += _locationWide; + } + } + + // ----------------------------------------------------------------- + // Drawing + // ----------------------------------------------------------------- + + src = sprite + rs.top * srcPitch + rs.left; + dst = _buffer + _screenWide * rd.top + rd.left; + + if (s->type & RDSPR_BLEND) { + // The original code had two different blending cases. One for + // s->blend & 0x01 and one for s->blend & 0x02. However, the + // only values that actually appear in the cluster files are + // 0, 513 and 1025 so the s->blend & 0x02 case was never used. + // Which is just as well since that code made no sense to me. + + if (!(_renderCaps & RDBLTFX_SPRITEBLEND)) { + for (i = 0; i < rs.height(); i++) { + for (j = 0; j < rs.width(); j++) { + if (src[j] && ((i & 1) == (j & 1))) + dst[j] = src[j]; + } + src += srcPitch; + dst += _screenWide; + } + } else { + uint8 n = s->blend >> 8; + + for (i = 0; i < rs.height(); i++) { + for (j = 0; j < rs.width(); j++) { + if (src[j]) { + uint8 r1 = _palette[src[j] * 4 + 0]; + uint8 g1 = _palette[src[j] * 4 + 1]; + uint8 b1 = _palette[src[j] * 4 + 2]; + uint8 r2 = _palette[dst[j] * 4 + 0]; + uint8 g2 = _palette[dst[j] * 4 + 1]; + uint8 b2 = _palette[dst[j] * 4 + 2]; + + uint8 r = (r1 * n + r2 * (8 - n)) >> 3; + uint8 g = (g1 * n + g2 * (8 - n)) >> 3; + uint8 b = (b1 * n + b2 * (8 - n)) >> 3; + dst[j] = quickMatch(r, g, b); + } + } + src += srcPitch; + dst += _screenWide; + } + } + } else { + if (s->type & RDSPR_TRANS) { + for (i = 0; i < rs.height(); i++) { + for (j = 0; j < rs.width(); j++) { + if (src[j]) + dst[j] = src[j]; + } + src += srcPitch; + dst += _screenWide; + } + } else { + for (i = 0; i < rs.height(); i++) { + memcpy(dst, src, rs.width()); + src += srcPitch; + dst += _screenWide; + } + } + } + + if (freeSprite) + free(sprite); + + markAsDirty(rd.left, rd.top, rd.right - 1, rd.bottom - 1); + return RD_OK; +} + +/** + * Opens the light masking sprite for a room. + */ + +int32 Screen::openLightMask(SpriteInfo *s) { + // FIXME: The light mask is only needed on higher graphics detail + // settings, so to save memory we could simply ignore it on lower + // settings. But then we need to figure out how to ensure that it + // is properly loaded if the user changes the settings in mid-game. + + if (_lightMask) + return RDERR_NOTCLOSED; + + _lightMask = (byte *)malloc(s->w * s->h); + if (!_lightMask) + return RDERR_OUTOFMEMORY; + + if (decompressRLE256(_lightMask, s->data, s->w * s->h)) + return RDERR_DECOMPRESSION; + + return RD_OK; +} + +/** + * Closes the light masking sprite for a room. + */ + +int32 Screen::closeLightMask() { + if (!_lightMask) + return RDERR_NOTOPEN; + + free(_lightMask); + _lightMask = NULL; + return RD_OK; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/startup.cpp b/engines/sword2/startup.cpp new file mode 100644 index 0000000000..2e1dd7b0ae --- /dev/null +++ b/engines/sword2/startup.cpp @@ -0,0 +1,173 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "common/file.h" + +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/maketext.h" +#include "sword2/memory.h" +#include "sword2/resman.h" +#include "sword2/router.h" +#include "sword2/sound.h" + +namespace Sword2 { + +bool Sword2Engine::initStartMenu() { + // Print out a list of all the start points available. + // There should be a linc produced file called startup.txt. + // This file should contain ascii numbers of all the resource game + // objects that are screen managers. + // We query each in turn and setup an array of start structures. + // If the file doesn't exist then we say so and return a 0. + + Common::File fp; + + // ok, load in the master screen manager file + + _totalStartups = 0; + _totalScreenManagers = 0; + + if (!fp.open("startup.inf")) { + warning("Cannot open startup.inf - the debugger won't have a start menu"); + return false; + } + + // The startup.inf file which contains a list of all the files. Now + // extract the filenames + + int start_ids[MAX_starts]; + + while (1) { + bool done = false; + + start_ids[_totalScreenManagers] = 0; + + // Scan the string until the LF in CRLF + + int b; + + do { + b = fp.readByte(); + + if (fp.ioFailed()) { + done = true; + break; + } + + if (isdigit(b)) { + start_ids[_totalScreenManagers] *= 10; + start_ids[_totalScreenManagers] += (b - '0'); + } + } while (b != 10); + + if (done) + break; + + _totalScreenManagers++; + + if (_totalScreenManagers == MAX_starts) { + warning("MAX_starts exceeded"); + break; + } + } + + fp.close(); + + // Using this method the Gode generated resource.inf must have #0d0a + // on the last entry + + debug(1, "%d screen manager objects", _totalScreenManagers); + + // Open each object and make a query call. The object must fill in a + // startup structure. It may fill in several if it wishes - for + // instance a startup could be set for later in the game where + // specific vars are set + + for (uint i = 0; i < _totalScreenManagers; i++) { + _startRes = start_ids[i]; + + debug(2, "Querying screen manager %d", _startRes); + + // Open each one and run through the interpreter. Script 0 is + // the query request script + + // if the resource number is within range & it's not a null + // resource + // - need to check in case un-built sections included in + // start list + + if (_resman->checkValid(_startRes)) { + _logic->runResScript(_startRes, 0); + } else + warning("Start menu resource %d invalid", _startRes); + } + + return 1; +} + +void Sword2Engine::registerStartPoint(int32 key, char *name) { + assert(_totalStartups < MAX_starts); + + _startList[_totalStartups].start_res_id = _startRes; + _startList[_totalStartups].key = key; + + strncpy(_startList[_totalStartups].description, name, MAX_description); + _startList[_totalStartups].description[MAX_description - 1] = 0; + + _totalStartups++; +} + +void Sword2Engine::runStart(int start) { + // Restarting - stop sfx, music & speech! + + _sound->clearFxQueue(); + _logic->fnStopMusic(NULL); + _sound->unpauseSpeech(); + _sound->stopSpeech(); + + // Remove all resources from memory, including player object and global + // variables + + _resman->removeAll(); + + // Reopen global variables resource and player object + setupPersistentResources(); + + // Free all the route memory blocks from previous game + _logic->_router->freeAllRouteMem(); + + // If there was speech text, kill the text block + if (_logic->_speechTextBlocNo) { + _fontRenderer->killTextBloc(_logic->_speechTextBlocNo); + _logic->_speechTextBlocNo = 0; + } + + _logic->runResObjScript(_startList[start].start_res_id, CUR_PLAYER_ID, _startList[start].key & 0xffff); + + // Make sure there's a mouse, in case restarting while mouse not + // available + _logic->fnAddHuman(NULL); +} + +} // End of namespace Sword2 diff --git a/engines/sword2/sword2.cpp b/engines/sword2/sword2.cpp new file mode 100644 index 0000000000..6056d636b7 --- /dev/null +++ b/engines/sword2/sword2.cpp @@ -0,0 +1,689 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" + +#include "backends/fs/fs.h" + +#include "base/gameDetector.h" +#include "base/plugins.h" + +#include "common/config-manager.h" +#include "common/file.h" +#include "common/system.h" + +#include "sword2/sword2.h" +#include "sword2/console.h" +#include "sword2/controls.h" +#include "sword2/defs.h" +#include "sword2/logic.h" +#include "sword2/maketext.h" +#include "sword2/memory.h" +#include "sword2/mouse.h" +#include "sword2/resman.h" +#include "sword2/router.h" +#include "sword2/sound.h" + +#ifdef _WIN32_WCE +extern bool isSmartphone(); +#endif + +struct Sword2GameSettings { + const char *gameid; + const char *description; + uint32 features; + const char *detectname; + GameSettings toGameSettings() const { + GameSettings dummy = { gameid, description, features }; + return dummy; + } +}; + +static const Sword2GameSettings sword2_settings[] = { + /* Broken Sword 2 */ + {"sword2", "Broken Sword 2: The Smoking Mirror", GF_DEFAULT_TO_1X_SCALER, "players.clu" }, + {"sword2alt", "Broken Sword 2: The Smoking Mirror (alt)", GF_DEFAULT_TO_1X_SCALER, "r2ctlns.ocx" }, + {"sword2demo", "Broken Sword 2: The Smoking Mirror (Demo)", GF_DEFAULT_TO_1X_SCALER | Sword2::GF_DEMO, "players.clu" }, + {NULL, NULL, 0, NULL} +}; + +GameList Engine_SWORD2_gameList() { + const Sword2GameSettings *g = sword2_settings; + GameList games; + while (g->gameid) { + games.push_back(g->toGameSettings()); + g++; + } + return games; +} + +DetectedGameList Engine_SWORD2_detectGames(const FSList &fslist) { + DetectedGameList detectedGames; + const Sword2GameSettings *g; + + // TODO: It would be nice if we had code here which distinguishes + // between the 'sword2' and 'sword2demo' targets. The current code + // can't do that since they use the same detectname. + + for (g = sword2_settings; g->gameid; ++g) { + // Iterate over all files in the given directory + for (FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) { + if (!file->isDirectory()) { + const char *gameName = file->displayName().c_str(); + + if (0 == scumm_stricmp(g->detectname, gameName)) { + // Match found, add to list of candidates, then abort inner loop. + detectedGames.push_back(g->toGameSettings()); + break; + } + } + } + } + return detectedGames; +} + +Engine *Engine_SWORD2_create(GameDetector *detector, OSystem *syst) { + return new Sword2::Sword2Engine(detector, syst); +} + +REGISTER_PLUGIN(SWORD2, "Broken Sword 2") + +namespace Sword2 { + +Sword2Engine::Sword2Engine(GameDetector *detector, OSystem *syst) : Engine(syst) { + // Add default file directories + Common::File::addDefaultDirectory(_gameDataPath + "CLUSTERS/"); + Common::File::addDefaultDirectory(_gameDataPath + "SWORD2/"); + Common::File::addDefaultDirectory(_gameDataPath + "VIDEO/"); + Common::File::addDefaultDirectory(_gameDataPath + "clusters/"); + Common::File::addDefaultDirectory(_gameDataPath + "sword2/"); + Common::File::addDefaultDirectory(_gameDataPath + "video/"); + + _features = detector->_game.features; + _targetName = detector->_targetName; + + _bootParam = ConfMan.getInt("boot_param"); + _saveSlot = ConfMan.getInt("save_slot"); + + _memory = NULL; + _resman = NULL; + _sound = NULL; + _screen = NULL; + _mouse = NULL; + _logic = NULL; + _fontRenderer = NULL; + _debugger = NULL; + + _keyboardEvent.pending = false; + _keyboardEvent.repeat = 0; + _mouseEvent.pending = false; + + _wantSfxDebug = false; + +#ifdef SWORD2_DEBUG + _stepOneCycle = false; + _renderSkip = false; +#endif + + _gamePaused = false; + _graphicsLevelFudged = false; + + _gameCycle = 0; + + _quit = false; +} + +Sword2Engine::~Sword2Engine() { + delete _debugger; + delete _sound; + delete _fontRenderer; + delete _screen; + delete _mouse; + delete _logic; + delete _resman; + delete _memory; +} + +void Sword2Engine::errorString(const char *buf1, char *buf2) { + strcpy(buf2, buf1); + +#ifdef _WIN32_WCE + if (isSmartphone()) + return; +#endif + + // Unless an error -originated- within the debugger, spawn the + // debugger. Otherwise exit out normally. + if (_debugger && !_debugger->isAttached()) { + // (Print it again in case debugger segfaults) + printf("%s\n", buf2); + _debugger->attach(buf2); + _debugger->onFrame(); + } +} + +void Sword2Engine::registerDefaultSettings() { + ConfMan.registerDefault("music_mute", false); + ConfMan.registerDefault("speech_mute", false); + ConfMan.registerDefault("sfx_mute", false); + ConfMan.registerDefault("gfx_details", 2); + ConfMan.registerDefault("subtitles", false); + ConfMan.registerDefault("reverse_stereo", false); +} + +void Sword2Engine::readSettings() { + _mixer->setVolumeForSoundType(Audio::Mixer::kMusicSoundType, ConfMan.getInt("music_volume")); + _mixer->setVolumeForSoundType(Audio::Mixer::kSpeechSoundType, ConfMan.getInt("speech_volume")); + _mixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, ConfMan.getInt("sfx_volume")); + setSubtitles(ConfMan.getBool("subtitles")); + _sound->muteMusic(ConfMan.getBool("music_mute")); + _sound->muteSpeech(ConfMan.getBool("speech_mute")); + _sound->muteFx(ConfMan.getBool("sfx_mute")); + _sound->setReverseStereo(ConfMan.getBool("reverse_stereo")); + _mouse->setObjectLabels(ConfMan.getBool("object_labels")); + _screen->setRenderLevel(ConfMan.getInt("gfx_details")); +} + +void Sword2Engine::writeSettings() { + ConfMan.set("music_volume", _mixer->getVolumeForSoundType(Audio::Mixer::kMusicSoundType)); + ConfMan.set("speech_volume", _mixer->getVolumeForSoundType(Audio::Mixer::kSpeechSoundType)); + ConfMan.set("sfx_volume", _mixer->getVolumeForSoundType(Audio::Mixer::kSFXSoundType)); + ConfMan.set("music_mute", _sound->isMusicMute()); + ConfMan.set("speech_mute", _sound->isSpeechMute()); + ConfMan.set("sfx_mute", _sound->isFxMute()); + ConfMan.set("gfx_details", _screen->getRenderLevel()); + ConfMan.set("subtitles", getSubtitles()); + ConfMan.set("object_labels", _mouse->getObjectLabels()); + ConfMan.set("reverse_stereo", _sound->isReverseStereo()); + + ConfMan.flushToDisk(); +} + +/** + * The global script variables and player object should be kept open throughout + * the game, so that they are never expelled by the resource manager. + */ + +void Sword2Engine::setupPersistentResources() { + _logic->_scriptVars = _resman->openResource(1) + ResHeader::size(); + _resman->openResource(CUR_PLAYER_ID); +} + +int Sword2Engine::init(GameDetector &detector) { + // Get some falling RAM and put it in your pocket, never let it slip + // away + + _system->beginGFXTransaction(); + initCommonGFX(detector); + _screen = new Screen(this, 640, 480); + _system->endGFXTransaction(); + + // Create the debugger as early as possible (but not before the + // screen object!) so that errors can be displayed in it. In + // particular, we want errors about missing files to be clearly + // visible to the user. + + _debugger = new Debugger(this); + + _memory = new MemoryManager(this); + _resman = new ResourceManager(this); + _logic = new Logic(this); + _fontRenderer = new FontRenderer(this); + _sound = new Sound(this); + _mouse = new Mouse(this); + + // Setup mixer + if (!_mixer->isReady()) + warning("Sound initialization failed"); + + registerDefaultSettings(); + readSettings(); + + initStartMenu(); + + // During normal gameplay, we care neither about mouse button releases + // nor the scroll wheel. + setInputEventFilter(RD_LEFTBUTTONUP | RD_RIGHTBUTTONUP | RD_WHEELUP | RD_WHEELDOWN); + + setupPersistentResources(); + initialiseFontResourceFlags(); + + if (_features & GF_DEMO) + _logic->writeVar(DEMO, 1); + else + _logic->writeVar(DEMO, 0); + + if (_saveSlot != -1) { + if (saveExists(_saveSlot)) + restoreGame(_saveSlot); + else { + RestoreDialog dialog(this); + if (!dialog.runModal()) + startGame(); + } + } else if (!_bootParam && saveExists()) { + int32 pars[2] = { 221, FX_LOOP }; + bool result; + + _mouse->setMouse(NORMAL_MOUSE_ID); + _logic->fnPlayMusic(pars); + + StartDialog dialog(this); + + result = (dialog.runModal() != 0); + + // If the game is started from the beginning, the cutscene + // player will kill the music for us. Otherwise, the restore + // will either have killed the music, or done a crossfade. + + if (_quit) + return 0; + + if (result) + startGame(); + } else + startGame(); + + _screen->initialiseRenderCycle(); + + return 0; +} + +int Sword2Engine::go() { + while (1) { + if (_debugger->isAttached()) + _debugger->onFrame(); + +#ifdef SWORD2_DEBUG + if (_stepOneCycle) { + pauseGame(); + _stepOneCycle = false; + } +#endif + + KeyboardEvent *ke = keyboardEvent(); + + if (ke) { + if ((ke->modifiers == OSystem::KBD_CTRL && ke->keycode == 'd') || ke->ascii == '#' || ke->ascii == '~') { + _debugger->attach(); + } else if (ke->modifiers == 0 || ke->modifiers == OSystem::KBD_SHIFT) { + switch (ke->keycode) { + case 'p': + if (_gamePaused) + unpauseGame(); + else + pauseGame(); + break; + case 'c': + if (!_logic->readVar(DEMO) && !_mouse->isChoosing()) { + ScreenInfo *screenInfo = _screen->getScreenInfo(); + _logic->fnPlayCredits(NULL); + screenInfo->new_palette = 99; + } + break; +#ifdef SWORD2_DEBUG + case ' ': + if (_gamePaused) { + _stepOneCycle = true; + unpauseGame(); + } + break; + case 's': + _renderSkip = !_renderSkip; + break; +#endif + default: + break; + } + } + } + + // skip GameCycle if we're paused + if (!_gamePaused) { + _gameCycle++; + gameCycle(); + } + + // We can't use this as termination condition for the loop, + // because we want the break to happen before updating the + // screen again. + + if (_quit) + break; + + // creates the debug text blocks + _debugger->buildDebugText(); + +#ifdef SWORD2_DEBUG + // if not in console & '_renderSkip' is set, only render + // display once every 4 game-cycles + + if (!_renderSkip || (_gameCycle % 4) == 0) + _screen->buildDisplay(); +#else + _screen->buildDisplay(); +#endif + } + + return 0; +} + +void Sword2Engine::closeGame() { + _quit = true; +} + +void Sword2Engine::restartGame() { + ScreenInfo *screenInfo = _screen->getScreenInfo(); + uint32 temp_demo_flag; + + _mouse->closeMenuImmediately(); + + // Restart the game. To do this, we must... + + // Stop music instantly! + _sound->stopMusic(true); + + // In case we were dead - well we're not anymore! + _logic->writeVar(DEAD, 0); + + // Restart the game. Clear all memory and reset the globals + temp_demo_flag = _logic->readVar(DEMO); + + // Remove all resources from memory, including player object and + // global variables + _resman->removeAll(); + + // Reopen global variables resource and player object + setupPersistentResources(); + + _logic->writeVar(DEMO, temp_demo_flag); + + // Free all the route memory blocks from previous game + _logic->_router->freeAllRouteMem(); + + // Call the same function that first started us up + startGame(); + + // Prime system with a game cycle + + // Reset the graphic 'BuildUnit' list before a new logic list + // (see fnRegisterFrame) + _screen->resetRenderLists(); + + // Reset the mouse hot-spot list (see fnRegisterMouse and + // fnRegisterFrame) + _mouse->resetMouseList(); + + _mouse->closeMenuImmediately(); + + // FOR THE DEMO - FORCE THE SCROLLING TO BE RESET! + // - this is taken from fnInitBackground + // switch on scrolling (2 means first time on screen) + screenInfo->scroll_flag = 2; + + if (_logic->processSession()) + error("restart 1st cycle failed??"); + + // So palette not restored immediately after control panel - we want + // to fade up instead! + screenInfo->new_palette = 99; +} + +bool Sword2Engine::checkForMouseEvents() { + return _mouseEvent.pending; +} + +MouseEvent *Sword2Engine::mouseEvent() { + if (!_mouseEvent.pending) + return NULL; + + _mouseEvent.pending = false; + return &_mouseEvent; +} + +KeyboardEvent *Sword2Engine::keyboardEvent() { + if (!_keyboardEvent.pending) + return NULL; + + _keyboardEvent.pending = false; + return &_keyboardEvent; +} + +uint32 Sword2Engine::setInputEventFilter(uint32 filter) { + uint32 oldFilter = _inputEventFilter; + + _inputEventFilter = filter; + return oldFilter; +} + +/** + * Clear the input events. This is so that we won't get any keyboard repeat + * right after using the debugging console. + */ + +void Sword2Engine::clearInputEvents() { + _keyboardEvent.pending = false; + _keyboardEvent.repeat = 0; + _mouseEvent.pending = false; +} + +/** + * OSystem Event Handler. Full of cross platform goodness and 99% fat free! + */ + +void Sword2Engine::parseInputEvents() { + OSystem::Event event; + + uint32 now = _system->getMillis(); + + while (_system->pollEvent(event)) { + switch (event.type) { + case OSystem::EVENT_KEYDOWN: + if (!(_inputEventFilter & RD_KEYDOWN)) { + _keyboardEvent.pending = true; + _keyboardEvent.repeat = now + 400; + _keyboardEvent.ascii = event.kbd.ascii; + _keyboardEvent.keycode = event.kbd.keycode; + _keyboardEvent.modifiers = event.kbd.flags; + } + break; + case OSystem::EVENT_KEYUP: + _keyboardEvent.repeat = 0; + break; + case OSystem::EVENT_MOUSEMOVE: + if (!(_inputEventFilter & RD_KEYDOWN)) { + _mouse->setPos(event.mouse.x, event.mouse.y - MENUDEEP); + } + break; + case OSystem::EVENT_LBUTTONDOWN: + if (!(_inputEventFilter & RD_LEFTBUTTONDOWN)) { + _mouseEvent.pending = true; + _mouseEvent.buttons = RD_LEFTBUTTONDOWN; + } + break; + case OSystem::EVENT_RBUTTONDOWN: + if (!(_inputEventFilter & RD_RIGHTBUTTONDOWN)) { + _mouseEvent.pending = true; + _mouseEvent.buttons = RD_RIGHTBUTTONDOWN; + } + break; + case OSystem::EVENT_LBUTTONUP: + if (!(_inputEventFilter & RD_LEFTBUTTONUP)) { + _mouseEvent.pending = true; + _mouseEvent.buttons = RD_LEFTBUTTONUP; + } + break; + case OSystem::EVENT_RBUTTONUP: + if (!(_inputEventFilter & RD_RIGHTBUTTONUP)) { + _mouseEvent.pending = true; + _mouseEvent.buttons = RD_RIGHTBUTTONUP; + } + break; + case OSystem::EVENT_WHEELUP: + if (!(_inputEventFilter & RD_WHEELUP)) { + _mouseEvent.pending = true; + _mouseEvent.buttons = RD_WHEELUP; + } + break; + case OSystem::EVENT_WHEELDOWN: + if (!(_inputEventFilter & RD_WHEELDOWN)) { + _mouseEvent.pending = true; + _mouseEvent.buttons = RD_WHEELDOWN; + } + break; + case OSystem::EVENT_QUIT: + closeGame(); + break; + default: + break; + } + } + + // Handle keyboard auto-repeat + if (!_keyboardEvent.pending && _keyboardEvent.repeat && now >= _keyboardEvent.repeat) { + _keyboardEvent.pending = true; + _keyboardEvent.repeat = now + 100; + } +} + +void Sword2Engine::gameCycle() { + // Do one game cycle, that is run the logic session until a full loop + // has been performed. + + if (_logic->getRunList()) { + do { + // Reset the 'BuildUnit' and mouse hot-spot lists + // before each new logic list. The service scripts + // will fill thrm through fnRegisterFrame() and + // fnRegisterMouse(). + + _screen->resetRenderLists(); + _mouse->resetMouseList(); + + // Keep going as long as new lists keep getting put in + // - i.e. screen changes. + } while (_logic->processSession()); + } else { + // Start the console and print the start options perhaps? + _debugger->attach("AWAITING START COMMAND: (Enter 's 1' then 'q' to start from beginning)"); + } + + // If this screen is wide, recompute the scroll offsets every cycle + ScreenInfo *screenInfo = _screen->getScreenInfo(); + + if (screenInfo->scroll_flag) + _screen->setScrolling(); + + _mouse->mouseEngine(); + _sound->processFxQueue(); +} + +void Sword2Engine::startGame() { + // Boot the game straight into a start script. It's always George's + // script #1, but with different ScreenManager objects depending on + // if it's the demo or the full game, or if we're using a boot param. + + int screen_manager_id = 0; + + debug(5, "startGame() STARTING:"); + + if (!_bootParam) { + if (_logic->readVar(DEMO)) + screen_manager_id = 19; // DOCKS SECTION START + else + screen_manager_id = 949; // INTRO & PARIS START + } else { + // FIXME this could be validated against startup.inf for valid + // numbers to stop people shooting themselves in the foot + + if (_bootParam != 0) + screen_manager_id = _bootParam; + } + + _logic->runResObjScript(screen_manager_id, CUR_PLAYER_ID, 1); +} + +// FIXME: Move this to some better place? + +void Sword2Engine::sleepUntil(uint32 time) { + while (getMillis() < time) { + // Make sure menu animations and fades don't suffer, but don't + // redraw the entire scene. + _mouse->processMenu(); + _screen->updateDisplay(false); + _system->delayMillis(10); + } +} + +void Sword2Engine::pauseGame() { + // Don't allow Pause while screen fading or while black + if (_screen->getFadeStatus() != RDFADE_NONE) + return; + + _sound->pauseAllSound(); + _mouse->pauseGame(); + + // If render level is at max, turn it down because palette-matching + // won't work when the palette is dimmed. + + if (_screen->getRenderLevel() == 3) { + _screen->setRenderLevel(2); + _graphicsLevelFudged = true; + } + +#ifdef SWORD2_DEBUG + // Don't dim it if we're single-stepping through frames + // dim the palette during the pause + + if (!_stepOneCycle) + _screen->dimPalette(); +#else + _screen->dimPalette(); +#endif + + _gamePaused = true; +} + +void Sword2Engine::unpauseGame() { + _mouse->unpauseGame(); + _sound->unpauseAllSound(); + + // Put back game screen palette; see build_display.cpp + _screen->setFullPalette(-1); + + // If graphics level at max, turn up again + if (_graphicsLevelFudged) { + _screen->setRenderLevel(3); + _graphicsLevelFudged = false; + } + + _gamePaused = false; + + // If mouse is about or we're in a chooser menu + if (!_mouse->getMouseStatus() || _mouse->isChoosing()) + _mouse->setMouse(NORMAL_MOUSE_ID); +} + +uint32 Sword2Engine::getMillis() { + return _system->getMillis(); +} + +} // End of namespace Sword2 diff --git a/engines/sword2/sword2.h b/engines/sword2/sword2.h new file mode 100644 index 0000000000..bcb80ec957 --- /dev/null +++ b/engines/sword2/sword2.h @@ -0,0 +1,240 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#ifndef _SWORD2 +#define _SWORD2 + +// Enable this to make it possible to clear the mouse cursor luggage by +// right-clicking. The original didn't do this, but it feels natural to me. +// However, I'm afraid that it'll interfer badly with parts of the game, so +// for now I'll keep it disabled. + +#define RIGHT_CLICK_CLEARS_LUGGAGE 0 + +#include "base/engine.h" + +#include "common/util.h" + +#include "sword2/build_display.h" +#include "sword2/header.h" +#include "sword2/icons.h" +#include "sword2/object.h" +#include "sword2/save_rest.h" + +#define MAX_starts 100 +#define MAX_description 100 + +class GameDetector; +class OSystem; + +namespace Sword2 { + +enum { + GF_DEMO = 1 << 0 +}; + +class MemoryManager; +class ResourceManager; +class Sound; +class Screen; +class Mouse; +class Logic; +class FontRenderer; +class Gui; +class Debugger; + +enum { + RD_LEFTBUTTONDOWN = 0x01, + RD_LEFTBUTTONUP = 0x02, + RD_RIGHTBUTTONDOWN = 0x04, + RD_RIGHTBUTTONUP = 0x08, + RD_WHEELUP = 0x10, + RD_WHEELDOWN = 0x20, + RD_KEYDOWN = 0x40, + RD_MOUSEMOVE = 0x80 +}; + +struct MouseEvent { + bool pending; + uint16 buttons; +}; + +struct KeyboardEvent { + bool pending; + uint32 repeat; + uint16 ascii; + int keycode; + int modifiers; +}; + +struct StartUp { + char description[MAX_description]; + + // id of screen manager object + uint32 start_res_id; + + // Tell the manager which startup you want (if there are more than 1) + // (i.e more than 1 entrance to a screen and/or separate game boots) + uint32 key; +}; + +class Sword2Engine : public Engine { +private: + uint32 _inputEventFilter; + + // The event "buffers" + MouseEvent _mouseEvent; + KeyboardEvent _keyboardEvent; + + uint32 _bootParam; + int32 _saveSlot; + + void getPlayerStructures(); + void putPlayerStructures(); + + uint32 saveData(uint16 slotNo, byte *buffer, uint32 bufferSize); + uint32 restoreData(uint16 slotNo, byte *buffer, uint32 bufferSize); + + uint32 calcChecksum(byte *buffer, uint32 size); + + void pauseGame(); + void unpauseGame(); + + uint32 _totalStartups; + uint32 _totalScreenManagers; + uint32 _startRes; + + bool _useSubtitles; + + StartUp _startList[MAX_starts]; + +public: + Sword2Engine(GameDetector *detector, OSystem *syst); + ~Sword2Engine(); + int go(); + int init(GameDetector &detector); + + void registerDefaultSettings(); + void readSettings(); + void writeSettings(); + + void setupPersistentResources(); + + bool getSubtitles() { return _useSubtitles; } + void setSubtitles(bool b) { _useSubtitles = b; } + + bool _quit; + + uint32 _features; + Common::String _targetName; // target name for saves + + MemoryManager *_memory; + ResourceManager *_resman; + Sound *_sound; + Screen *_screen; + Mouse *_mouse; + Logic *_logic; + FontRenderer *_fontRenderer; + + Debugger *_debugger; + + Common::RandomSource _rnd; + + uint32 _speechFontId; + uint32 _controlsFontId; + uint32 _redFontId; + + uint32 setInputEventFilter(uint32 filter); + + void clearInputEvents(); + void parseInputEvents(); + + bool checkForMouseEvents(); + MouseEvent *mouseEvent(); + KeyboardEvent *keyboardEvent(); + + bool _wantSfxDebug; + + int32 _gameCycle; + +#ifdef SWORD2_DEBUG + bool _renderSkip; + bool _stepOneCycle; +#endif + +#if RIGHT_CLICK_CLEARS_LUGGAGE + bool heldIsInInventory(); +#endif + + byte *fetchPalette(byte *screenFile); + byte *fetchScreenHeader(byte *screenFile); + byte *fetchLayerHeader(byte *screenFile, uint16 layerNo); + byte *fetchShadingMask(byte *screenFile); + + byte *fetchAnimHeader(byte *animFile); + byte *fetchCdtEntry(byte *animFile, uint16 frameNo); + byte *fetchFrameHeader(byte *animFile, uint16 frameNo); + byte *fetchBackgroundParallaxLayer(byte *screenFile, int layer); + byte *fetchBackgroundLayer(byte *screenFile); + byte *fetchForegroundParallaxLayer(byte *screenFile, int layer); + byte *fetchTextLine(byte *file, uint32 text_line); + bool checkTextLine(byte *file, uint32 text_line); + byte *fetchPaletteMatchTable(byte *screenFile); + + uint32 saveGame(uint16 slotNo, byte *description); + uint32 restoreGame(uint16 slotNo); + uint32 getSaveDescription(uint16 slotNo, byte *description); + bool saveExists(); + bool saveExists(uint16 slotNo); + uint32 restoreFromBuffer(byte *buffer, uint32 size); + uint32 findBufferSize(); + + bool _gamePaused; + bool _graphicsLevelFudged; + + void startGame(); + void gameCycle(); + void closeGame(); + void restartGame(); + + void sleepUntil(uint32 time); + + void errorString(const char *buf_input, char *buf_output); + void initialiseFontResourceFlags(); + void initialiseFontResourceFlags(uint8 language); + + bool initStartMenu(); + void registerStartPoint(int32 key, char *name); + + uint32 getNumStarts() { return _totalStartups; } + uint32 getNumScreenManagers() { return _totalScreenManagers; } + StartUp *getStartList() { return _startList; } + + void runStart(int start); + + // Convenience alias for OSystem::getMillis(). + // This is a bit hackish, of course :-). + uint32 getMillis(); +}; + +} // End of namespace Sword2 + +#endif diff --git a/engines/sword2/sync.cpp b/engines/sword2/sync.cpp new file mode 100644 index 0000000000..205e273873 --- /dev/null +++ b/engines/sword2/sync.cpp @@ -0,0 +1,76 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +#include "common/stdafx.h" +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/logic.h" + +namespace Sword2 { + +/** + * Clear any syncs registered for this id. Call this just after the id has been + * processed. Theoretically there could be more than one sync waiting for us, + * so clear the lot. + */ + +void Logic::clearSyncs(uint32 id) { + for (int i = 0; i < ARRAYSIZE(_syncList); i++) { + if (_syncList[i].id == id) { + debug(5, "removing sync %d for %d", i, id); + _syncList[i].id = 0; + } + } +} + +void Logic::sendSync(uint32 id, uint32 sync) { + for (int i = 0; i < ARRAYSIZE(_syncList); i++) { + if (_syncList[i].id == 0) { + debug(5, "%d sends sync %d to %d", readVar(ID), sync, id); + _syncList[i].id = id; + _syncList[i].sync = sync; + return; + } + } + + // The original code didn't even check for this condition, so maybe + // it should be a fatal error? + + warning("No free sync slot"); +} + +/** + * Check for a sync waiting for this character. Called from fnAnim() to see if + * animation is to be finished. Returns an index into _syncList[], or -1. + */ + +int Logic::getSync() { + uint32 id = readVar(ID); + + for (int i = 0; i < ARRAYSIZE(_syncList); i++) { + if (_syncList[i].id == id) + return i; + } + + return -1; +} + +} // End of namespace Sword2 diff --git a/engines/sword2/walker.cpp b/engines/sword2/walker.cpp new file mode 100644 index 0000000000..82ef80f65f --- /dev/null +++ b/engines/sword2/walker.cpp @@ -0,0 +1,454 @@ +/* Copyright (C) 1994-1998 Revolution Software Ltd. + * Copyright (C) 2003-2006 The ScummVM project + * + * 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. + * + * $URL$ + * $Id$ + */ + +// WALKER.CPP by James (14nov96) + +// Functions for moving megas about the place & also for keeping tabs on them + +#include "common/stdafx.h" +#include "sword2/sword2.h" +#include "sword2/defs.h" +#include "sword2/interpreter.h" +#include "sword2/logic.h" +#include "sword2/resman.h" +#include "sword2/router.h" + +namespace Sword2 { + +void Router::setStandbyCoords(int16 x, int16 y, uint8 dir) { + assert(dir <= 7); + + _standbyX = x; + _standbyY = y; + _standbyDir = dir; +} + +/** + * Work out direction from start to dest. + */ + +// Used in whatTarget(); not valid for all megas +#define diagonalx 36 +#define diagonaly 8 + +int Router::whatTarget(int startX, int startY, int destX, int destY) { + int deltaX = destX - startX; + int deltaY = destY - startY; + + // 7 0 1 + // 6 2 + // 5 4 3 + + // Flat route + + if (ABS(deltaY) * diagonalx < ABS(deltaX) * diagonaly / 2) + return (deltaX > 0) ? 2 : 6; + + // Vertical route + + if (ABS(deltaY) * diagonalx / 2 > ABS(deltaX) * diagonaly) + return (deltaY > 0) ? 4 : 0; + + // Diagonal route + + if (deltaX > 0) + return (deltaY > 0) ? 3 : 1; + + return (deltaY > 0) ? 5 : 7; +} + +/** + * Walk meta to (x,y,dir). Set RESULT to 0 if it succeeded. Otherwise, set + * RESULT to 1. Return true if the mega has finished walking. + */ + +int Router::doWalk(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *ob_walkdata, int16 target_x, int16 target_y, uint8 target_dir) { + ObjectLogic obLogic(ob_logic); + ObjectGraphic obGraph(ob_graph); + ObjectMega obMega(ob_mega); + + // If this is the start of the walk, calculate the route. + + if (obLogic.getLooping() == 0) { + // If we're already there, don't even bother allocating + // memory and calling the router, just quit back & continue + // the script! This avoids an embarassing mega stand frame + // appearing for one cycle when we're already in position for + // an anim eg. repeatedly clicking on same object to repeat + // an anim - no mega frame will appear in between runs of the + // anim. + + if (obMega.getFeetX() == target_x && obMega.getFeetY() == target_y && obMega.getCurDir() == target_dir) { + _vm->_logic->writeVar(RESULT, 0); + return IR_CONT; + } + + assert(target_dir <= 8); + + obMega.setWalkPc(0); + + // Set up mem for _walkData in route_slots[] & set mega's + // 'route_slot_id' accordingly + allocateRouteMem(); + + int32 route = routeFinder(ob_mega, ob_walkdata, target_x, target_y, target_dir); + + // 0 = can't make route to target + // 1 = created route + // 2 = zero route but may need to turn + + if (route != 1 && route != 2) { + freeRouteMem(); + _vm->_logic->writeVar(RESULT, 1); + return IR_CONT; + } + + // Walk is about to start + + obMega.setIsWalking(1); + obLogic.setLooping(1); + obGraph.setAnimResource(obMega.getMegasetRes()); + } else if (_vm->_logic->readVar(EXIT_FADING) && _vm->_screen->getFadeStatus() == RDFADE_BLACK) { + // Double clicked an exit, and the screen has faded down to + // black. Ok, that's it. Back to script and change screen. + + // We have to clear te EXIT_CLICK_ID variable in case there's a + // walk instruction on the new screen, or it'd be cut short. + + freeRouteMem(); + + obLogic.setLooping(0); + obMega.setIsWalking(0); + _vm->_logic->writeVar(EXIT_CLICK_ID, 0); + _vm->_logic->writeVar(RESULT, 0); + + return IR_CONT; + } + + // Get pointer to walkanim & current frame position + + WalkData *walkAnim = getRouteMem(); + int32 walk_pc = obMega.getWalkPc(); + + // If stopping the walk early, overwrite the next step with a + // slow-out, then finish + + if (_vm->_logic->checkEventWaiting() && walkAnim[walk_pc].step == 0 && walkAnim[walk_pc + 1].step == 1) { + // At the beginning of a step + earlySlowOut(ob_mega, ob_walkdata); + } + + // Get new frame of walk + + obGraph.setAnimPc(walkAnim[walk_pc].frame); + obMega.setCurDir(walkAnim[walk_pc].dir); + obMega.setFeetX(walkAnim[walk_pc].x); + obMega.setFeetY(walkAnim[walk_pc].y); + + // Is the NEXT frame is the end-marker (512) of the walk sequence? + + if (walkAnim[walk_pc + 1].frame != 512) { + // No, it wasn't. Increment the walk-anim frame number and + // come back next cycle. + obMega.setWalkPc(obMega.getWalkPc() + 1); + return IR_REPEAT; + } + + // We have reached the end-marker, which means we can return to the + // script just as the final (stand) frame of the walk is set. + + freeRouteMem(); + obLogic.setLooping(0); + obMega.setIsWalking(0); + + // If George's walk has been interrupted to run a new action script for + // instance or Nico's walk has been interrupted by player clicking on + // her to talk + + // There used to be code here for checking if two megas were colliding, + // but it had been commented out, and it was only run if a function + // that always returned zero returned non-zero. + + if (_vm->_logic->checkEventWaiting()) { + _vm->_logic->startEvent(); + _vm->_logic->writeVar(RESULT, 1); + return IR_TERMINATE; + } + + _vm->_logic->writeVar(RESULT, 0); + + // CONTINUE the script so that RESULT can be checked! Also, if an anim + // command follows the fnWalk command, the 1st frame of the anim (which + // is always a stand frame itself) can replace the final stand frame of + // the walk, to hide the slight difference between the shrinking on the + // mega frames and the pre-shrunk anim start-frame. + + return IR_CONT; +} + +/** + * Walk mega to start position of anim + */ + +int Router::walkToAnim(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *ob_walkdata, uint32 animRes) { + int16 target_x = 0; + int16 target_y = 0; + uint8 target_dir = 0; + + // Walkdata is needed for earlySlowOut if player clicks elsewhere + // during the walk. + + // If this is the start of the walk, read anim file to get start coords + + ObjectLogic obLogic(ob_logic); + + if (obLogic.getLooping() == 0) { + byte *anim_file = _vm->_resman->openResource(animRes); + AnimHeader anim_head; + + anim_head.read(_vm->fetchAnimHeader(anim_file)); + + target_x = anim_head.feetStartX; + target_y = anim_head.feetStartY; + target_dir = anim_head.feetStartDir; + + _vm->_resman->closeResource(animRes); + + // If start coords not yet set in anim header, use the standby + // coords (which should be set beforehand in the script). + + if (target_x == 0 && target_y == 0) { + target_x = _standbyX; + target_y = _standbyY; + target_dir = _standbyDir; + } + + assert(target_dir <= 7); + } + + return doWalk(ob_logic, ob_graph, ob_mega, ob_walkdata, target_x, target_y, target_dir); +} + +/** + * Route to the left or right hand side of target id, if possible. + */ + +int Router::walkToTalkToMega(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *ob_walkdata, uint32 megaId, uint32 separation) { + ObjectMega obMega(ob_mega); + + int16 target_x = 0; + int16 target_y = 0; + uint8 target_dir = 0; + + // If this is the start of the walk, calculate the route. + + ObjectLogic obLogic(ob_logic); + + if (obLogic.getLooping() == 0) { + assert(_vm->_resman->fetchType(megaId) == GAME_OBJECT); + + // Call the base script. This is the graphic/mouse service + // call, and will set _engineMega to the ObjectMega of mega we + // want to route to. + + _vm->_logic->runResScript(megaId, 3); + + ObjectMega targetMega(_vm->_logic->getEngineMega()); + + // Stand exactly beside the mega, ie. at same y-coord + target_y = targetMega.getFeetY(); + + int scale = obMega.calcScale(); + int mega_separation = (separation * scale) / 256; + + debug(4, "Target is at (%d, %d), separation %d", targetMega.getFeetX(), targetMega.getFeetY(), mega_separation); + + if (targetMega.getFeetX() < obMega.getFeetX()) { + // Target is left of us, so aim to stand to their + // right. Face down_left + + target_x = targetMega.getFeetX() + mega_separation; + target_dir = 5; + } else { + // Ok, must be right of us so aim to stand to their + // left. Face down_right. + + target_x = targetMega.getFeetX() - mega_separation; + target_dir = 3; + } + } + + return doWalk(ob_logic, ob_graph, ob_mega, ob_walkdata, target_x, target_y, target_dir); +} +/** + * Turn mega to the specified direction. Just needs to call doWalk() with + * current feet coords, so router can produce anim of turn frames. + */ + +int Router::doFace(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *ob_walkdata, uint8 target_dir) { + int16 target_x = 0; + int16 target_y = 0; + + // If this is the start of the turn, get the mega's current feet + // coords + the required direction + + ObjectLogic obLogic(ob_logic); + + if (obLogic.getLooping() == 0) { + assert(target_dir <= 7); + + ObjectMega obMega(ob_mega); + + target_x = obMega.getFeetX(); + target_y = obMega.getFeetY(); + } + + return doWalk(ob_logic, ob_graph, ob_mega, ob_walkdata, target_x, target_y, target_dir); +} + +/** + * Turn mega to face point (x,y) on the floor + */ + +int Router::faceXY(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *ob_walkdata, int16 target_x, int16 target_y) { + uint8 target_dir = 0; + + // If this is the start of the turn, get the mega's current feet + // coords + the required direction + + ObjectLogic obLogic(ob_logic); + + if (obLogic.getLooping() == 0) { + ObjectMega obMega(ob_mega); + + target_dir = whatTarget(obMega.getFeetX(), obMega.getFeetY(), target_x, target_y); + } + + return doFace(ob_logic, ob_graph, ob_mega, ob_walkdata, target_dir); +} + +/** + * Turn mega to face another mega. + */ + +int Router::faceMega(byte *ob_logic, byte *ob_graph, byte *ob_mega, byte *ob_walkdata, uint32 megaId) { + uint8 target_dir = 0; + + // If this is the start of the walk, decide where to walk to. + + ObjectLogic obLogic(ob_logic); + + if (obLogic.getLooping() == 0) { + assert(_vm->_resman->fetchType(megaId) == GAME_OBJECT); + + // Call the base script. This is the graphic/mouse service + // call, and will set _engineMega to the ObjectMega of mega we + // want to turn to face. + + _vm->_logic->runResScript(megaId, 3); + + ObjectMega obMega(ob_mega); + ObjectMega targetMega(_vm->_logic->getEngineMega()); + + target_dir = whatTarget(obMega.getFeetX(), obMega.getFeetY(), targetMega.getFeetX(), targetMega.getFeetY()); + } + + return doFace(ob_logic, ob_graph, ob_mega, ob_walkdata, target_dir); +} + +/** + * Stand mega at (x,y,dir) + * Sets up the graphic object, but also needs to set the new 'current_dir' in + * the mega object, so the router knows in future + */ + +void Router::standAt(byte *ob_graph, byte *ob_mega, int32 x, int32 y, int32 dir) { + assert(dir >= 0 && dir <= 7); + + ObjectGraphic obGraph(ob_graph); + ObjectMega obMega(ob_mega); + + // Set up the stand frame & set the mega's new direction + + obMega.setFeetX(x); + obMega.setFeetY(y); + obMega.setCurDir(dir); + + // Mega-set animation file + obGraph.setAnimResource(obMega.getMegasetRes()); + + // Dir + first stand frame (always frame 96) + obGraph.setAnimPc(dir + 96); +} + +/** + * Stand mega at end position of anim + */ + +void Router::standAfterAnim(byte *ob_graph, byte *ob_mega, uint32 animRes) { + byte *anim_file = _vm->_resman->openResource(animRes); + AnimHeader anim_head; + + anim_head.read(_vm->fetchAnimHeader(anim_file)); + + int32 x = anim_head.feetEndX; + int32 y = anim_head.feetEndY; + int32 dir = anim_head.feetEndDir; + + _vm->_resman->closeResource(animRes); + + // If start coords not available either use the standby coords (which + // should be set beforehand in the script) + + if (x == 0 && y == 0) { + x = _standbyX; + y = _standbyY; + dir = _standbyDir; + } + + standAt(ob_graph, ob_mega, x, y, dir); +} + +void Router::standAtAnim(byte *ob_graph, byte *ob_mega, uint32 animRes) { + byte *anim_file = _vm->_resman->openResource(animRes); + AnimHeader anim_head; + + anim_head.read(_vm->fetchAnimHeader(anim_file)); + + int32 x = anim_head.feetStartX; + int32 y = anim_head.feetStartY; + int32 dir = anim_head.feetStartDir; + + _vm->_resman->closeResource(animRes); + + // If start coords not available use the standby coords (which should + // be set beforehand in the script) + + if (x == 0 && y == 0) { + x = _standbyX; + y = _standbyY; + dir = _standbyDir; + } + + standAt(ob_graph, ob_mega, x, y, dir); +} + +} // End of namespace Sword2 |