diff options
Diffstat (limited to 'engines')
96 files changed, 59864 insertions, 0 deletions
diff --git a/engines/mads/action.cpp b/engines/mads/action.cpp new file mode 100644 index 0000000000..1db143aaad --- /dev/null +++ b/engines/mads/action.cpp @@ -0,0 +1,696 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/action.h" +#include "mads/inventory.h" +#include "mads/resources.h" +#include "mads/scene.h" +#include "mads/staticres.h" + +namespace MADS { + +void ActionDetails::synchronize(Common::Serializer &s) { + s.syncAsUint16LE(_verbId); + s.syncAsUint16LE(_objectNameId); + s.syncAsUint16LE(_indirectObjectId); +} + +void ActionSavedFields::synchronize(Common::Serializer &s) { + s.syncAsByte(_commandError); + s.syncAsSint16LE(_commandSource); + s.syncAsSint16LE(_command); + s.syncAsSint16LE(_mainObject); + s.syncAsSint16LE(_secondObject); + s.syncAsSint16LE(_mainObjectSource); + s.syncAsSint16LE(_secondObjectSource); + s.syncAsSint16LE(_articleNumber); + s.syncAsSint16LE(_lookFlag); +} + +/*------------------------------------------------------------------------*/ + +MADSAction::MADSAction(MADSEngine *vm) : _vm(vm) { + clear(); + _statusTextIndex = -1; + _selectedAction = 0; + _inProgress = false; + + _savedFields._commandSource = 0; + _savedFields._mainObjectSource = 0; + _savedFields._command = -1; + _savedFields._mainObject = 0; + _savedFields._secondObject = 0; + _savedFields._secondObjectSource = 0; + _savedFields._articleNumber = PREP_NONE; + _savedFields._lookFlag = false; +} + +void MADSAction::clear() { + _interAwaiting = AWAITING_COMMAND; + _commandSource = CAT_NONE; + _mainObjectSource = CAT_NONE; + _secondObjectSource = CAT_NONE; + _recentCommandSource = CAT_NONE; + _articleNumber = 0; + _lookFlag = false; + _pointEstablished = 0; + _statusText.clear(); + _selectedRow = -1; + _hotspotId = -1; + _secondObject = -1; + _recentCommand = -1; + _action._verbId = VERB_NONE; + _action._objectNameId = -1; + _action._indirectObjectId = -1; + _textChanged = true; +} + +void MADSAction::appendVocab(int vocabId, bool capitalize) { + Common::String vocabStr = _vm->_game->_scene.getVocab(vocabId); + if (capitalize) + vocabStr.setChar(toupper(vocabStr[0]), 0); + + _statusText += vocabStr; + _statusText += " "; +} + +void MADSAction::startWalkingDirectly(int walkType) { + Scene &scene = _vm->_game->_scene; + Player &player = _vm->_game->_player; + + if (_pointEstablished && (walkType == -3 || _savedFields._command < 0)) { + player._needToWalk = true; + player._prepareWalkPos = scene._customDest; + } +} + +void MADSAction::set() { + Scene &scene = _vm->_game->_scene; + UserInterface &userInterface = scene._userInterface; + _statusText = ""; + + _action._verbId = VERB_NONE; + _action._objectNameId = -1; + _action._indirectObjectId = -1; + + if (_commandSource == CAT_TALK_ENTRY) { + // Handle showing the conversation selection. Rex at least doesn't actually seem to use this + if (_selectedRow >= 0) { + _action._verbId = userInterface._talkIds[_selectedRow]; + Common::String desc = userInterface._talkStrings[_selectedRow]; + if (!desc.empty()) + _statusText = desc; + } + } else if (_lookFlag && (_selectedRow == 0)) { + // Two 'look' actions in succession, so the action becomes 'Look around' + _statusText = kLookAroundStr; + } else { + bool flag = false; + if ((_commandSource == CAT_INV_VOCAB) && (_selectedRow >= 0) + && (_verbType == VERB_THAT) && (_prepType == PREP_NONE)) { + // Use/to action + int invIndex = userInterface._selectedInvIndex; + InventoryObject &objEntry = _vm->_game->_objects.getItem(invIndex); + + _action._objectNameId = objEntry._descId; + _action._verbId = objEntry._vocabList[_selectedRow]._vocabId; + + // Set up the status text string + _statusText = kUseStr; + appendVocab(_action._objectNameId); + _statusText += kToStr; + appendVocab(_action._verbId); + } else { + // Handling for if an action has been selected + if (_selectedRow >= 0) { + if (_commandSource == CAT_COMMAND) { + // Standard verb action + _action._verbId = scene._verbList[_selectedRow]._id; + } else { + // Selected action on an inventory object + int invIndex = userInterface._selectedInvIndex; + InventoryObject &objEntry = _vm->_game->_objects.getItem(invIndex); + + _action._verbId = objEntry._vocabList[_selectedRow]._vocabId; + } + + appendVocab(_action._verbId, true); + + if (_action._verbId == VERB_LOOK) { + // Add in the word 'add' + _statusText += kArticleList[PREP_AT]; + _statusText += " "; + } + } + + // Add in any necessary article if necessary + if ((_hotspotId >= 0) && (_selectedRow >= 0) && (_articleNumber > 0) && (_verbType == VERB_THAT)) { + flag = true; + + _statusText += kArticleList[_articleNumber]; + _statusText += " "; + } + + // Handling for hotspot + if (_hotspotId >= 0) { + if (_selectedRow < 0) { + int verbId; + + if (_hotspotId < (int)scene._hotspots.size()) { + // Get the verb Id from the hotspot + verbId = scene._hotspots[_hotspotId]._verbId; + } else { + // Get the verb Id from the scene object + verbId = scene._dynamicHotspots[_hotspotId - scene._hotspots.size()]._verbId; + } + + if (verbId > 0) { + // Set the specified action + _action._verbId = verbId; + appendVocab(_action._verbId, true); + } else { + // Default to a standard 'walk to' + _action._verbId = VERB_WALKTO; + _statusText += kWalkToStr; + } + } + + if ((_mainObjectSource == CAT_INV_LIST) || (_mainObjectSource == CAT_INV_ANIM)) { + // Get name from given inventory object + InventoryObject &invObject = _vm->_game->_objects.getItem(_hotspotId); + _action._objectNameId = invObject._descId; + } else if (_hotspotId < (int)scene._hotspots.size()) { + // Get name from scene hotspot + _action._objectNameId = scene._hotspots[_hotspotId]._vocabId; + } else { + // Get name from temporary scene hotspot + _action._objectNameId = scene._dynamicHotspots[_hotspotId - scene._hotspots.size()]._descId; + } + appendVocab(_action._objectNameId); + } + } + + if (_secondObject >= 0) { + if (_secondObjectSource == CAT_INV_LIST || _secondObjectSource == CAT_INV_ANIM) { + InventoryObject &invObject = _vm->_game->_objects.getItem(_secondObject); + _action._indirectObjectId = invObject._descId; + } else if (_secondObject < (int)scene._hotspots.size()) { + _action._indirectObjectId = scene._hotspots[_secondObject]._vocabId; + } else { + _action._indirectObjectId = scene._dynamicHotspots[_secondObject - scene._hotspots.size()]._descId; + } + } + + if ((_hotspotId >= 0) && (_articleNumber > 0) && !flag) { + if (_articleNumber == PREP_RELATIONAL) { + if (_secondObject >= 0) { + int articleNum = 0; + + if ((_secondObjectSource == 2) || (_secondObjectSource == 5)) { + InventoryObject &invObject = _vm->_game->_objects.getItem(_hotspotId); + articleNum = invObject._article; + } else if (_hotspotId < (int)scene._hotspots.size()) { + articleNum = scene._hotspots[_hotspotId]._articleNumber; + } else { + articleNum = scene._dynamicHotspots[_hotspotId - scene._hotspots.size()]._articleNumber; + } + + _statusText += kArticleList[articleNum]; + } + } else if ((_articleNumber == VERB_LOOK) || (_vm->getGameID() != GType_RexNebular) || + (_action._indirectObjectId >= 0 && scene._vocabStrings[_action._indirectObjectId] != kFenceStr)) { + // Write out the article + _statusText += kArticleList[_articleNumber]; + } else { + // Special case for a 'fence' entry in Rex Nebular + _statusText += kOverStr; + } + + _statusText += " "; + } + + // Append object description if necessary + if (_secondObject >= 0) + appendVocab(_action._indirectObjectId); + + // Remove any trailing space character + if (_statusText.hasSuffix(" ")) + _statusText.deleteLastChar(); + } + + _textChanged = true; +} + +void MADSAction::refresh() { + Scene &scene = _vm->_game->_scene; + + // Exit immediately if nothing has changed + if (!_textChanged) + return; + + // Remove any old copy of the status text + if (_statusTextIndex >= 0) { + scene._textDisplay.expire(_statusTextIndex); + _statusTextIndex = -1; + } + + if (!_statusText.empty()) { + if ((_vm->_game->_screenObjects._inputMode == kInputBuildingSentences) || + (_vm->_game->_screenObjects._inputMode == kInputLimitedSentences)) { + Font *font = _vm->_font->getFont(FONT_MAIN); + int textSpacing = -1; + + int strWidth = font->getWidth(_statusText); + if (strWidth > MADS_SCREEN_WIDTH) { + // Too large to fit, so fall back on interface font + font = _vm->_font->getFont(FONT_INTERFACE); + strWidth = font->getWidth(_statusText, 0); + textSpacing = 0; + } + + // Add a new text display entry to display the status text at the bottom of the screen area + _statusTextIndex = scene._textDisplay.add(160 - (strWidth / 2), + MADS_SCENE_HEIGHT + scene._posAdjust.y - 13, 3, textSpacing, _statusText, font); + } + } + + _textChanged = false; +} + +void MADSAction::startAction() { + Game &game = *_vm->_game; + Player &player = game._player; + Scene &scene = _vm->_game->_scene; + DynamicHotspots &dynHotspots = scene._dynamicHotspots; + Hotspots &hotspots = scene._hotspots; + + player.cancelCommand(); + + _inProgress = true; + _savedFields._commandError = false; + _savedFields._command = _selectedRow; + _savedFields._mainObject = _hotspotId; + _savedFields._secondObject = _secondObject; + _savedFields._articleNumber = _articleNumber; + _savedFields._commandSource = _commandSource; + _savedFields._mainObjectSource = _mainObjectSource; + _savedFields._secondObjectSource = _secondObjectSource; + _savedFields._lookFlag = _lookFlag; + _activeAction = _action; + + // Copy the action to be active + _activeAction = _action; + _sentence = _statusText; + + if ((_mainObjectSource == CAT_HOTSPOT) && (_secondObjectSource == 4)) + _savedFields._commandError = true; + + player._needToWalk = false; + int hotspotId = -1; + + if (!_savedFields._lookFlag && (_vm->_game->_screenObjects._inputMode != kInputConversation)) { + if (_savedFields._mainObjectSource == CAT_HOTSPOT) + hotspotId = _savedFields._mainObject; + else if (_secondObjectSource == 4) + hotspotId = _savedFields._secondObject; + + if (hotspotId >= (int)hotspots.size()) { + DynamicHotspot &hs = dynHotspots[hotspotId - hotspots.size()]; + if ((hs._feetPos.x == -1) || (hs._feetPos.x == -3)) { + startWalkingDirectly(hs._feetPos.x); + } else if (hs._feetPos.x == 0) { + player._prepareWalkFacing = hs._facing; + } else if (_savedFields._commandSource == CAT_NONE || hs._cursor >= CURSOR_WAIT) { + player._needToWalk = true; + player._prepareWalkPos = hs._feetPos; + } + + player._prepareWalkFacing = hs._facing; + hotspotId = -1; + } + } + + if (hotspotId >= 0 && hotspotId < (int)hotspots.size()) { + Hotspot &hs = hotspots[hotspotId]; + + if (hs._feetPos.x == -1 || hs._feetPos.x == -3) { + startWalkingDirectly(hs._feetPos.x); + } else if (hs._feetPos.x >= 0) { + if (_savedFields._commandSource == CAT_NONE || hs._cursor < CURSOR_WAIT) { + player._needToWalk = true; + player._prepareWalkPos = hs._feetPos; + } + } + + player._prepareWalkFacing = hs._facing; + } + + player._readyToWalk = player._needToWalk; +} + +void MADSAction::checkAction() { + if (isAction(VERB_LOOK) || isAction(VERB_THROW)) + _vm->_game->_player._needToWalk = false; +} + +bool MADSAction::isAction(int verbId, int objectNameId, int indirectObjectId) { + if (_activeAction._verbId != verbId) + return false; + if ((objectNameId != 0) && (_activeAction._objectNameId != objectNameId)) + return false; + if ((indirectObjectId != 0) && (_activeAction._indirectObjectId != indirectObjectId)) + return false; + + return true; +} + +bool MADSAction::isObject(int objectNameId) { + return _activeAction._objectNameId == objectNameId; +} + +bool MADSAction::isTarget(int objectNameId) { + return _activeAction._indirectObjectId == objectNameId; +} + +void MADSAction::checkActionAtMousePos() { + Scene &scene = _vm->_game->_scene; + UserInterface &userInterface = scene._userInterface; + + if ((userInterface._category == CAT_COMMAND || userInterface._category == CAT_INV_VOCAB) && + _interAwaiting != AWAITING_COMMAND && _pickedWord >= 0) { + if (_recentCommandSource == userInterface._category || _recentCommand != _pickedWord || + (_interAwaiting != AWAITING_THIS && _interAwaiting != 3)) + clear(); + else if (_selectedRow != 0 || userInterface._category != CAT_COMMAND) + scene._lookFlag = false; + else + scene._lookFlag = true; + } + + if (_vm->_events->_rightMousePressed && _vm->_events->_mouseButtons) { + switch (userInterface._category) { + case CAT_COMMAND: + case CAT_INV_VOCAB: + return; + + case CAT_INV_LIST: + case CAT_HOTSPOT: + case CAT_INV_ANIM: + if (_interAwaiting != AWAITING_THAT) { + if (userInterface._selectedActionIndex >= 0) { + _commandSource = CAT_COMMAND; + _selectedRow = userInterface._selectedActionIndex; + _verbType = scene._verbList[_selectedRow]._verbType; + _prepType = scene._verbList[_selectedRow]._prepType; + _interAwaiting = AWAITING_THIS; + } else if (userInterface._selectedItemVocabIdx >= 0) { + _commandSource = CAT_INV_VOCAB; + _selectedRow = userInterface._selectedItemVocabIdx; + int objectId = _vm->_game->_objects._inventoryList[_selectedRow]; + InventoryObject &invObject = _vm->_game->_objects[objectId]; + + _verbType = invObject._vocabList[_selectedRow - 1]._verbType; + _prepType = invObject._vocabList[_selectedRow - 1]._prepType; + _mainObjectSource = CAT_INV_LIST; + _hotspotId = userInterface._selectedInvIndex; + _articleNumber = _prepType; + + if ((_verbType == VERB_THIS && _prepType == PREP_NONE) || + (_verbType == VERB_THAT && _prepType != PREP_NONE)) + _interAwaiting = AWAITING_RIGHT_MOUSE; + else + _interAwaiting = AWAITING_THAT; + } + } + break; + + default: + break; + } + } + + switch (_interAwaiting) { + case AWAITING_COMMAND: + _articleNumber = 0; + switch (userInterface._category) { + case CAT_COMMAND: + _commandSource = CAT_COMMAND; + _selectedRow = _pickedWord; + if (_selectedRow >= 0) { + _verbType = scene._verbList[_selectedRow]._verbType; + _prepType = scene._verbList[_selectedRow]._prepType; + } + break; + + case CAT_INV_VOCAB: + _commandSource = CAT_INV_VOCAB; + _selectedRow = _pickedWord; + if (_selectedRow < 0) { + _hotspotId = -1; + _mainObjectSource = CAT_NONE; + } else { + InventoryObject &invObject = _vm->_game->_objects.getItem(userInterface._selectedInvIndex); + _verbType = invObject._vocabList[_selectedRow]._verbType; + _prepType = invObject._vocabList[_selectedRow]._prepType; + _hotspotId = userInterface._selectedInvIndex; + _mainObjectSource = CAT_INV_LIST; + + if (_verbType == VERB_THAT) + _articleNumber = _prepType; + } + break; + + case CAT_HOTSPOT: + _selectedRow = -1; + _commandSource = CAT_NONE; + _mainObjectSource = CAT_HOTSPOT; + _hotspotId = _pickedWord; + break; + + case CAT_TALK_ENTRY: + _commandSource = CAT_TALK_ENTRY; + _selectedRow = _pickedWord; + break; + + default: + break; + } + break; + + case AWAITING_THIS: + _articleNumber = 0; + switch (userInterface._category) { + case CAT_INV_LIST: + case CAT_HOTSPOT: + case CAT_INV_ANIM: + _mainObjectSource = userInterface._category; + _hotspotId = _pickedWord; + break; + default: + break; + } + break; + + case AWAITING_THAT: + switch (userInterface._category) { + case CAT_INV_LIST: + case CAT_HOTSPOT: + case CAT_INV_ANIM: + _secondObjectSource = userInterface._category; + _secondObject = _pickedWord; + break; + default: + break; + } + break; + + default: + break; + } +} + +void MADSAction::leftClick() { + Scene &scene = _vm->_game->_scene; + UserInterface &userInterface = scene._userInterface; + bool abortFlag = false; + + if ((userInterface._category == CAT_COMMAND || userInterface._category == CAT_INV_VOCAB) && + _interAwaiting != 1 && _pickedWord >= 0 && + _recentCommandSource == userInterface._category && _recentCommand == _pickedWord && + (_interAwaiting == 2 || userInterface._category == CAT_INV_VOCAB)) { + abortFlag = true; + if (_selectedRow == 0 && userInterface._category == CAT_COMMAND) { + _selectedAction = CAT_COMMAND; + scene._lookFlag = true; + } else { + _selectedAction = CAT_NONE; + scene._lookFlag = false; + clear(); + } + } + + if (abortFlag || (_vm->_events->_rightMousePressed && (userInterface._category == CAT_COMMAND || + userInterface._category == CAT_INV_VOCAB))) + return; + + switch (_interAwaiting) { + case AWAITING_COMMAND: + switch (userInterface._category) { + case CAT_COMMAND: + if (_selectedRow >= 0) { + if (_verbType == VERB_ONLY) { + _selectedAction = -1; + } + else { + _recentCommand = _selectedRow; + _recentCommandSource = _commandSource; + _interAwaiting = AWAITING_THIS; + } + } + break; + + case CAT_INV_LIST: + if (_pickedWord >= 0) { + userInterface.selectObject(_pickedWord); + } + break; + + case CAT_INV_VOCAB: + if (_selectedRow >= 0) { + if (_verbType != VERB_THIS || _prepType != PREP_NONE) { + if (_verbType != VERB_THAT || _prepType == PREP_NONE) { + _interAwaiting = AWAITING_THAT; + _articleNumber = _prepType; + } else { + _articleNumber = _prepType; + _selectedAction = -1; + } + } else { + _selectedAction = -1; + } + + _recentCommand = _selectedRow; + _recentCommandSource = _commandSource; + } + break; + + case CAT_HOTSPOT: + _recentCommand = -1; + _recentCommandSource = CAT_NONE; + + if (_vm->_events->currentPos().y < MADS_SCENE_HEIGHT) { + scene._customDest = _vm->_events->currentPos() + scene._posAdjust; + _selectedAction = -1; + _pointEstablished = true; + } + break; + + case CAT_TALK_ENTRY: + if (_selectedRow >= 0) + _selectedAction = -1; + break; + + default: + break; + } + break; + + case AWAITING_THIS: + switch (userInterface._category) { + case CAT_INV_LIST: + case CAT_HOTSPOT: + case CAT_INV_ANIM: + if (_hotspotId >= 0) { + if (_prepType) { + _articleNumber = _prepType; + _interAwaiting = AWAITING_THAT; + } else { + _selectedAction = -1; + } + + if (userInterface._category == CAT_HOTSPOT) { + scene._customDest = _vm->_events->mousePos() + scene._posAdjust; + _pointEstablished = true; + } + } + break; + default: + break; + } + break; + + case AWAITING_THAT: + switch (userInterface._category) { + case CAT_INV_LIST: + case CAT_HOTSPOT: + case CAT_INV_ANIM: + if (_secondObject >= 0) { + _selectedAction = -1; + + if (userInterface._category == CAT_HOTSPOT) { + if (!_pointEstablished) { + scene._customDest = _vm->_events->mousePos() + scene._posAdjust; + _pointEstablished = true; + } + } + } + break; + default: + break; + } + break; + + default: + break; + } +} + +void MADSAction::synchronize(Common::Serializer &s) { + _action.synchronize(s); + _activeAction.synchronize(s); + s.syncAsSint16LE(_articleNumber); + s.syncAsByte(_lookFlag); + s.syncAsByte(_textChanged); + s.syncAsSint16LE(_selectedRow); + s.syncAsSint16LE(_selectedAction); + s.syncAsSint16LE(_statusTextIndex); + s.syncAsSint16LE(_hotspotId); + _savedFields.synchronize(s); + s.syncString(_sentence); + + s.syncAsSint16LE(_verbType); + s.syncAsSint16LE(_prepType); + s.syncAsSint16LE(_commandSource); + s.syncAsSint16LE(_mainObjectSource); + s.syncAsSint16LE(_secondObject); + s.syncAsSint16LE(_secondObjectSource); + s.syncAsSint16LE(_recentCommandSource); + s.syncAsSint16LE(_recentCommand); + s.syncAsSint16LE(_interAwaiting); + s.syncAsSint16LE(_pickedWord); + s.syncAsByte(_pointEstablished); + s.syncAsByte(_inProgress); +} + +} // End of namespace MADS diff --git a/engines/mads/action.h b/engines/mads/action.h new file mode 100644 index 0000000000..3010226787 --- /dev/null +++ b/engines/mads/action.h @@ -0,0 +1,176 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_ACTION_H +#define MADS_ACTION_H + +#include "common/scummsys.h" +#include "common/serializer.h" +#include "common/str.h" + +namespace MADS { + +enum TriggerMode { + SEQUENCE_TRIGGER_PARSER = 0, // Triggers parser + SEQUENCE_TRIGGER_DAEMON = 1, // Triggers step/daemon code + SEQUENCE_TRIGGER_PREPARE = 2 // Triggers preparser +}; + +enum InterAwaiting { + AWAITING_NONE = 0, + AWAITING_COMMAND = 1, // Initial state: waiting for a command verb + AWAITING_THIS = 2, // Waiting for object + AWAITING_THAT = 3, // Waiting for a second object + AWAITING_RIGHT_MOUSE = 4 // Waiting for mouse button release +}; + +enum { + VERB_NONE = 0, + VERB_LOOK = 3, + VERB_TAKE = 4, + VERB_PUSH = 5, + VERB_OPEN = 6, + VERB_PUT = 7, + VERB_TALKTO = 8, + VERB_GIVE = 9, + VERB_PULL = 10, + VERB_CLOSE = 11, + VERB_THROW = 12, + VERB_WALKTO = 13 +}; + +enum VerbType { VERB_ONLY, VERB_THIS, VERB_THAT }; + +enum PrepType { + PREP_NONE, PREP_WITH, PREP_TO, PREP_AT, PREP_FROM, PREP_ON, PREP_IN, + PREP_UNDER, PREP_BEHIND, PREP_RELATIONAL = 0xff +}; + +enum ScrCategory { + CAT_NONE = 0, CAT_COMMAND = 1, CAT_INV_LIST = 2, CAT_INV_VOCAB = 3, + CAT_HOTSPOT = 4, CAT_INV_ANIM = 5, CAT_TALK_ENTRY = 6, CAT_INV_SCROLLER = 7, + CAT_12 = 12 +}; + +class MADSEngine; + +struct ActionDetails { + int _verbId; + int _objectNameId; + int _indirectObjectId; + + /** + * Synchronize the action details + */ + void synchronize(Common::Serializer &s); +}; + +struct ActionSavedFields { + bool _commandError; + int _commandSource; + int _command; + int _mainObject; + int _secondObject; + int _mainObjectSource; + int _secondObjectSource; + int _articleNumber; + int _lookFlag; + + /** + * Synchronize the saved action details + */ + void synchronize(Common::Serializer &s); +}; + +class MADSAction { +private: + MADSEngine *_vm; + Common::String _statusText; + + void appendVocab(int vocabId, bool capitalize = false); + + void startWalkingDirectly(int walkType); +public: + ActionDetails _action, _activeAction; + int _articleNumber; + bool _lookFlag; + int _selectedRow; + bool _textChanged; + int _selectedAction; + int _statusTextIndex; + int _hotspotId; + ActionSavedFields _savedFields; + Common::String _sentence; + + VerbType _verbType; + PrepType _prepType; + ScrCategory _commandSource; + ScrCategory _mainObjectSource; + int _secondObject; + ScrCategory _secondObjectSource; + ScrCategory _recentCommandSource; + bool _pointEstablished; + int _recentCommand; + InterAwaiting _interAwaiting; + bool _inProgress; + int _pickedWord; + +public: + MADSAction(MADSEngine *vm); + + void clear(); + void set(); + const Common::String &statusText() const { return _statusText; } + void refresh(); + + /** + * Accepts the currently defined sentence from the ScreenObjects parser. + * Copies the data, and checks to see if the action requires the player + * to walk to the given hotspot. + */ + void startAction(); + + void checkAction(); + bool isAction(int verbId, int objectNameId = 0, int indirectObjectId = 0); + bool isObject(int objectNameId); + bool isTarget(int objectNameId); + + /** + * Check the result of the current action on the sentence + * with the provision that the action is not yet complete. + */ + void checkActionAtMousePos(); + + /** + * Execute a click within the scene + */ + void leftClick(); + + /** + * Synchronize the saved action details + */ + void synchronize(Common::Serializer &s); +}; + +} // End of namespace MADS + +#endif /* MADS_ACTION_H */ diff --git a/engines/mads/animation.cpp b/engines/mads/animation.cpp new file mode 100644 index 0000000000..ac8c9969b7 --- /dev/null +++ b/engines/mads/animation.cpp @@ -0,0 +1,574 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "mads/animation.h" +#include "mads/compression.h" + +#define FILENAME_SIZE 13 + +namespace MADS { + +void AAHeader::load(Common::SeekableReadStream *f) { + _spriteSetsCount = f->readUint16LE(); + _miscEntriesCount = f->readUint16LE(); + _frameEntriesCount = f->readUint16LE(); + _messagesCount = f->readUint16LE(); + f->skip(1); + _flags = f->readByte(); + + f->skip(2); + _bgType = (AnimBgType)f->readUint16LE(); + _roomNumber = f->readUint16LE(); + f->skip(2); + _manualFlag = f->readUint16LE() != 0; + _spritesIndex = f->readUint16LE(); + _scrollPosition.x = f->readSint16LE(); + _scrollPosition.y = f->readSint16LE(); + _scrollTicks = f->readUint32LE(); + f->skip(6); + + char buffer[FILENAME_SIZE]; + f->read(buffer, FILENAME_SIZE); + buffer[FILENAME_SIZE - 1] = '\0'; + _interfaceFile = Common::String(buffer); + + for (int i = 0; i < 50; ++i) { + f->read(buffer, FILENAME_SIZE); + buffer[FILENAME_SIZE - 1] = '\0'; + if (i < _spriteSetsCount) + _spriteSetNames.push_back(Common::String(buffer)); + } + + f->read(buffer, FILENAME_SIZE); + buffer[FILENAME_SIZE - 1] = '\0'; + _soundName = Common::String(buffer); + + f->skip(13); + f->read(buffer, FILENAME_SIZE); + buffer[FILENAME_SIZE - 1] = '\0'; + _dsrName = Common::String(buffer); + + f->read(buffer, FILENAME_SIZE); + buffer[FILENAME_SIZE - 1] = '\0'; + _fontResource = Common::String(buffer); +} + +/*------------------------------------------------------------------------*/ + +void AnimMessage::load(Common::SeekableReadStream *f) { + _soundId = f->readSint16LE(); + + char buffer[64]; + f->read(&buffer[0], 64); + _msg = Common::String(buffer); + f->skip(4); + _pos.x = f->readSint16LE(); + _pos.y = f->readSint16LE(); + _flags = f->readUint16LE(); + _rgb1[0] = f->readByte() << 2; + _rgb1[1] = f->readByte() << 2; + _rgb1[2] = f->readByte() << 2; + _rgb2[0] = f->readByte() << 2; + _rgb2[1] = f->readByte() << 2; + _rgb2[2] = f->readByte() << 2; + f->skip(2); // Space for kernelMsgIndex + _kernelMsgIndex = -1; + f->skip(6); + _startFrame = f->readUint16LE(); + _endFrame = f->readUint16LE(); + f->skip(2); +} + +void AnimFrameEntry::load(Common::SeekableReadStream *f, bool uiFlag) { + if (uiFlag) { + f->skip(2); + _frameNumber = -1; // Unused + _seqIndex = f->readByte(); + _spriteSlot._spritesIndex = f->readByte(); + _spriteSlot._frameNumber = (int8)f->readByte(); + f->skip(1); + _spriteSlot._position.x = f->readSint16LE(); + _spriteSlot._position.y = f->readSint16LE(); + } else { + _frameNumber = f->readUint16LE(); + _seqIndex = f->readByte(); + _spriteSlot._spritesIndex = f->readByte(); + _spriteSlot._frameNumber = f->readSint16LE(); + _spriteSlot._position.x = f->readSint16LE(); + _spriteSlot._position.y = f->readSint16LE(); + _spriteSlot._depth = f->readSByte(); + _spriteSlot._scale = (int8)f->readByte(); + } +} + +/*------------------------------------------------------------------------*/ + +void AnimMiscEntry::load(Common::SeekableReadStream *f) { + _soundId = f->readByte(); + _msgIndex = f->readSByte(); + _numTicks = f->readUint16LE(); + _posAdjust.x = f->readSint16LE(); + _posAdjust.y = f->readSint16LE(); + _field8 = f->readUint16LE(); +} + +/*------------------------------------------------------------------------*/ + +void AnimUIEntry::load(Common::SeekableReadStream *f) { + _probability = f->readUint16LE(); + _imageCount = f->readUint16LE(); + _firstImage = f->readUint16LE(); + _lastImage = f->readUint16LE(); + _counter = f->readSint16LE(); + for (int i = 0; i < ANIM_SPAWN_COUNT; ++i) + _spawn[i] = f->readByte(); + for (int i = 0; i < ANIM_SPAWN_COUNT; ++i) + _spawnFrame[i] = f->readUint16LE(); + _sound = f->readUint16LE() & 0xFF; + _soundFrame = f->readUint16LE(); +} + +/*------------------------------------------------------------------------*/ + +Animation *Animation::init(MADSEngine *vm, Scene *scene) { + return new Animation(vm, scene); +} + +Animation::Animation(MADSEngine *vm, Scene *scene) : _vm(vm), _scene(scene) { + _font = nullptr; + _resetFlag = false; + _messageCtr = 0; + _skipLoad = false; +} + +Animation::~Animation() { + Scene &scene = _vm->_game->_scene; + + if (_header._manualFlag) + scene._sprites.remove(_spriteListIndexes[_header._spritesIndex]); + + for (int idx = 0; idx < _header._spriteSetsCount; ++idx) { + if (!_header._manualFlag || _header._spritesIndex != idx) + scene._sprites.remove(_spriteListIndexes[idx]); + } +} + +void Animation::load(UserInterface &interfaceSurface, DepthSurface &depthSurface, + const Common::String &resName, int flags, Common::Array<PaletteCycle> *palCycles, + SceneInfo *sceneInfo) { + Common::String resourceName = resName; + if (!resourceName.contains(".")) + resourceName += ".AA"; + + File f(resourceName); + MadsPack madsPack(&f); + + Common::SeekableReadStream *stream = madsPack.getItemStream(0); + _header.load(stream); + delete stream; + + if (_header._bgType == ANIMBG_INTERFACE) + flags |= PALFLAG_RESERVED; + + if (flags & ANIMFLAG_LOAD_BACKGROUND) { + loadInterface(interfaceSurface, depthSurface, _header, flags, palCycles, sceneInfo); + } + if (flags & ANIMFLAG_LOAD_BACKGROUND_ONLY) { + // No data + _header._messagesCount = 0; + _header._frameEntriesCount = 0; + _header._miscEntriesCount = 0; + } + + // Initialize the reference list + _spriteListIndexes.clear(); + for (int i = 0; i < _header._spriteSetsCount; ++i) + _spriteListIndexes.push_back(-1); + + int streamIndex = 1; + _messages.clear(); + if (_header._messagesCount > 0) { + // Chunk 2: Following is a list of any messages for the animation + Common::SeekableReadStream *msgStream = madsPack.getItemStream(streamIndex++); + + for (int i = 0; i < _header._messagesCount; ++i) { + AnimMessage rec; + rec.load(msgStream); + _messages.push_back(rec); + } + + delete msgStream; + } + + _frameEntries.clear(); + if (_header._frameEntriesCount > 0) { + // Chunk 3: animation frame info + Common::SeekableReadStream *frameStream = madsPack.getItemStream(streamIndex++); + + for (int i = 0; i < _header._frameEntriesCount; i++) { + AnimFrameEntry rec; + rec.load(frameStream, flags & ANIMFLAG_LOAD_BACKGROUND); + _frameEntries.push_back(rec); + } + + delete frameStream; + } + + _miscEntries.clear(); + _uiEntries.clear(); + if (_header._miscEntriesCount > 0) { + // Chunk 4: Misc Data + Common::SeekableReadStream *miscStream = madsPack.getItemStream(streamIndex++); + + if (flags & ANIMFLAG_LOAD_BACKGROUND) { + for (int i = 0; i < _header._miscEntriesCount; ++i) { + AnimUIEntry rec; + rec.load(miscStream); + _uiEntries.push_back(rec); + } + } else { + for (int i = 0; i < _header._miscEntriesCount; ++i) { + AnimMiscEntry rec; + rec.load(miscStream); + _miscEntries.push_back(rec); + } + } + + delete miscStream; + } + + // If the animation specifies a font, then load it for access + delete _font; + if (_header._flags & ANIMFLAG_CUSTOM_FONT) { + Common::String fontName = "*" + _header._fontResource; + _font = _vm->_font->getFont(fontName.c_str()); + } else { + _font = nullptr; + } + + // Load all the sprite sets for the animation + for (uint i = 0; i < _spriteSets.size(); ++i) + delete _spriteSets[i]; + _spriteSets.clear(); + _spriteSets.resize(_header._spriteSetsCount); + + for (int i = 0; i < _header._spriteSetsCount; ++i) { + if (_header._manualFlag && (i == _header._spritesIndex)) { + // Skip over field, since it's manually loaded + _spriteSets[i] = nullptr; + } else { + _spriteSets[i] = new SpriteAsset(_vm, _header._spriteSetNames[i], flags); + _spriteListIndexes[i] = _vm->_game->_scene._sprites.add(_spriteSets[i]); + } + } + + if (_header._manualFlag) { + Common::String assetResName = "*" + _header._spriteSetNames[_header._spritesIndex]; + SpriteAsset *sprites = new SpriteAsset(_vm, assetResName, flags); + _spriteSets[_header._spritesIndex] = sprites; + + _spriteListIndexes[_header._spritesIndex] = _scene->_sprites.add(sprites); + } + + Common::Array<int> usageList; + for (int idx = 0; idx < _header._spriteSetsCount; ++idx) + usageList.push_back(_spriteSets[idx]->_usageIndex); + + if (usageList.size() > 0) + _vm->_palette->_paletteUsage.updateUsage(usageList, _header._messagesCount); + + // Remaps the sprite list indexes for frames to the loaded sprite list indexes + for (uint i = 0; i < _frameEntries.size(); ++i) { + int spriteListIndex = _frameEntries[i]._spriteSlot._spritesIndex; + _frameEntries[i]._spriteSlot._spritesIndex = _spriteListIndexes[spriteListIndex]; + } + + f.close(); +} + +void Animation::preLoad(const Common::String &resName, int level) { + // No implementation in ScummVM, since access is fast enough that data + // doesn't need to be preloaded +} + +void Animation::startAnimation(int endTrigger) { + _messageCtr = 0; + _skipLoad = true; + + if (_header._manualFlag) { + _unkIndex = -1; + //SpriteAsset *asset = _scene->_sprites[_spriteListIndexes[_header._spritesIndex]]; + + // TODO: Weird stuff with _unkList. Seems like it's treated as pointers + // here, but in processText, it's used as POINTs? + + loadFrame(1); + } + + if (_vm->_game->_kernelMode == KERNEL_ACTIVE_CODE) + _vm->_palette->refreshSceneColors(); + + _currentFrame = 0; + _oldFrameEntry = 0; + _nextFrameTimer = _vm->_game->_scene._frameStartTime; + _trigger = endTrigger; + _triggerMode = _vm->_game->_triggerSetupMode; + _actionDetails = _vm->_game->_scene._action._activeAction; + + for (int idx = 0; idx < _header._messagesCount; ++idx) { + _messages[idx]._kernelMsgIndex = -1; + } +} + +void Animation::loadFrame(int frameNumber) { + Scene &scene = _vm->_game->_scene; + if (_skipLoad) + return; + + Common::Point pt; + int spriteListIndex = _spriteListIndexes[_header._spritesIndex]; + SpriteAsset &spriteSet = *scene._sprites[spriteListIndex]; + + if (_unkIndex < 0) { + MSurface *frame = spriteSet.getFrame(0); + pt.x = frame->getBounds().left; + pt.y = frame->getBounds().top; + } else { + pt.x = _unkList[_unkIndex].x; + pt.y = _unkList[_unkIndex].y; + _unkIndex = 1 - _unkIndex; + } + + if (drawFrame(spriteSet, pt, frameNumber)) + error("drawFrame failure"); +} + +bool Animation::drawFrame(SpriteAsset &spriteSet, const Common::Point &pt, int frameNumber) { + return 0; +} + +void Animation::loadInterface(UserInterface &interfaceSurface, DepthSurface &depthSurface, + AAHeader &header, int flags, Common::Array<PaletteCycle> *palCycles, SceneInfo *sceneInfo) { + _scene->_depthStyle = 0; + if (header._bgType <= ANIMBG_FULL_SIZE) { + _vm->_palette->_paletteUsage.setEmpty(); + sceneInfo->load(header._roomNumber, flags, header._interfaceFile, 0, depthSurface, interfaceSurface); + _scene->_depthStyle = sceneInfo->_depthStyle == 2 ? 1 : 0; + if (palCycles) { + palCycles->clear(); + for (uint i = 0; i < sceneInfo->_paletteCycles.size(); ++i) + palCycles->push_back(sceneInfo->_paletteCycles[i]); + } + } else if (header._bgType == ANIMBG_INTERFACE) { + // Load a scene interface + Common::String resourceName = "*" + header._interfaceFile; + interfaceSurface.load(resourceName); + + if (palCycles) + palCycles->clear(); + } else { + // Original has useless code here + } +} + +bool Animation::hasScroll() const { + return (_header._scrollPosition.x != 0) || (_header._scrollPosition.y != 0); +} + +void Animation::update() { + Scene &scene = _vm->_game->_scene; + + if (_header._manualFlag) { + int spriteListIndex = _spriteListIndexes[_header._spritesIndex]; + int newIndex = -1; + + for (uint idx = _oldFrameEntry; idx < _frameEntries.size(); ++idx) { + if (_frameEntries[idx]._frameNumber > _currentFrame) + break; + if (_frameEntries[idx]._spriteSlot._spritesIndex == spriteListIndex) + newIndex = _frameEntries[idx]._spriteSlot._frameNumber; + } + + if (newIndex >= 0) + loadFrame(newIndex); + } + + // If it's not time for the next frame, then exit + if (_vm->_game->_scene._frameStartTime < _nextFrameTimer) + return; + + for (uint idx = 0; idx < scene._spriteSlots.size(); ++idx) { + if (scene._spriteSlots[idx]._seqIndex >= 0x80) + scene._spriteSlots[idx]._flags = IMG_ERASE; + } + + // Validate the current frame + if (_currentFrame >= (int)_miscEntries.size()) { + // Is the animation allowed to be repeated? + if (_resetFlag) { + _currentFrame = 0; + _oldFrameEntry = 0; + } else { + _freeFlag = true; + return; + } + } + + // Handle executing any sound command for this frame + AnimMiscEntry &misc = _miscEntries[_currentFrame]; + if (misc._soundId) + _vm->_sound->command(misc._soundId); + + // Handle any screen scrolling + if (hasScroll()) { + scene._backgroundSurface.scrollX(_header._scrollPosition.x); + scene._backgroundSurface.scrollY(_header._scrollPosition.y); + scene._spriteSlots.fullRefresh(); + } + + // Handle any offset adjustment for sprites as of this frame + bool paChanged = false; + if (scene._posAdjust.x != misc._posAdjust.x) { + scene._posAdjust.x = misc._posAdjust.x; + paChanged = true; + } + if (scene._posAdjust.y != misc._posAdjust.y) { + scene._posAdjust.y = misc._posAdjust.y; + paChanged = true; + } + + if (paChanged) { + int newIndex = scene._spriteSlots.add(); + scene._spriteSlots[newIndex]._seqIndex = -1; + scene._spriteSlots[newIndex]._flags = IMG_REFRESH; + } + + // Main frame animation loop - frames get animated by being placed, as necessary, into the + // main sprite slot array + while ((uint)_oldFrameEntry < _frameEntries.size()) { + if (_frameEntries[_oldFrameEntry]._frameNumber > _currentFrame) + break; + else if (_frameEntries[_oldFrameEntry]._frameNumber == _currentFrame) { + // Found the correct frame + int spriteSlotIndex = 0; + int index = 0; + + for (;;) { + if ((spriteSlotIndex == 0) && (index < (int)scene._spriteSlots.size())) { + int seqIndex = _frameEntries[_oldFrameEntry]._seqIndex - scene._spriteSlots[index]._seqIndex; + if (seqIndex == 0x80) { + if (scene._spriteSlots[index] == _frameEntries[_oldFrameEntry]._spriteSlot) { + scene._spriteSlots[index]._flags = IMG_STATIC; + spriteSlotIndex = -1; + } + } + ++index; + continue; + } + + if (spriteSlotIndex == 0) { + int slotIndex = scene._spriteSlots.add(); + SpriteSlot &slot = scene._spriteSlots[slotIndex]; + slot.copy(_frameEntries[_oldFrameEntry]._spriteSlot); + slot._seqIndex = _frameEntries[_oldFrameEntry]._seqIndex + 0x80; + + SpriteAsset &spriteSet = *scene._sprites[ + scene._spriteSlots[slotIndex]._spritesIndex]; + slot._flags = spriteSet.isBackground() ? IMG_DELTA : IMG_UPDATE; + } + break; + } + } + + ++_oldFrameEntry; + } + + // Handle the display of any messages + for (uint idx = 0; idx < _messages.size(); ++idx) { + if (_messages[idx]._kernelMsgIndex >= 0) { + // Handle currently active message + if ((_currentFrame < _messages[idx]._startFrame) || (_currentFrame > _messages[idx]._endFrame)) { + scene._kernelMessages.remove(_messages[idx]._kernelMsgIndex); + _messages[idx]._kernelMsgIndex = -1; + --_messageCtr; + } + } else if ((_currentFrame >= _messages[idx]._startFrame) && (_currentFrame <= _messages[idx]._endFrame)) { + // Start displaying the message + AnimMessage &me = _messages[idx]; + + // The color index to use is dependant on how many messages are currently on-screen + uint8 colIndex; + switch (_messageCtr) { + case 1: + colIndex = 252; + break; + case 2: + colIndex = 16; + break; + default: + colIndex = 250; + break; + } + + _vm->_palette->setEntry(colIndex, me._rgb1[0], me._rgb1[1], me._rgb1[2]); + _vm->_palette->setEntry(colIndex + 1, me._rgb2[0], me._rgb2[1], me._rgb2[2]); + + // Add a kernel message to display the given text + me._kernelMsgIndex = scene._kernelMessages.add(me._pos, colIndex * 0x101 + 0x100, + 0, 0, INDEFINITE_TIMEOUT, me._msg); + assert(me._kernelMsgIndex >= 0); + ++_messageCtr; + } + } + + // Move to the next frame + _currentFrame++; + if (_currentFrame >= (int)_miscEntries.size()) { + // Animation is complete + if (_trigger != 0) { + _vm->_game->_trigger = _trigger; + _vm->_game->_triggerMode = _triggerMode; + + if (_triggerMode != SEQUENCE_TRIGGER_DAEMON) { + // Copy the noun list + scene._action._activeAction = _actionDetails; + } + } + } + + int frameNum = MIN(_currentFrame, (int)_miscEntries.size() - 1); + _nextFrameTimer = _vm->_game->_scene._frameStartTime + _miscEntries[frameNum]._numTicks; +} + +void Animation::setCurrentFrame(int frameNumber) { + _currentFrame = frameNumber; + _oldFrameEntry = 0; + _freeFlag = false; + + _nextScrollTimer = _nextFrameTimer = _vm->_game->_scene._frameStartTime; +} + +void Animation::setNextFrameTimer(int frameNumber) { + _nextFrameTimer = frameNumber; +} + +} // End of namespace MADS diff --git a/engines/mads/animation.h b/engines/mads/animation.h new file mode 100644 index 0000000000..15086d3e41 --- /dev/null +++ b/engines/mads/animation.h @@ -0,0 +1,230 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_ANIMATION_H +#define MADS_ANIMATION_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "common/rect.h" +#include "mads/msurface.h" +#include "mads/scene_data.h" +#include "mads/font.h" +#include "mads/user_interface.h" + +namespace MADS { + +enum AnimFlag { + ANIMFLAG_DITHER = 0x0001, // Dither to 16 colors + ANIMFLAG_CUSTOM_FONT = 0x0020, // Load ccustom font + ANIMFLAG_LOAD_BACKGROUND = 0x0100, // Load background + ANIMFLAG_LOAD_BACKGROUND_ONLY = 0x0200 // Load background only +}; + +enum AnimBgType { + ANIMBG_ROOM = 1, ANIMBG_FULL_SIZE = 2, ANIMBG_BLACK_SCREEN = 3, + ANIMBG_INTERFACE = 4 +}; + +class MADSEngine; +class Scene; + +class AnimMessage { +public: + int16 _soundId; + Common::String _msg; + Common::Point _pos; + byte _rgb1[3], _rgb2[3]; + int _flags; + int _startFrame, _endFrame; + int _kernelMsgIndex; + + /** + * Loads data for the message from a stream + */ + void load(Common::SeekableReadStream *f); +}; + +class AnimFrameEntry { +public: + int _frameNumber; + int _seqIndex; + SpriteSlotSubset _spriteSlot; + + /** + * Loads data for the record + */ + void load(Common::SeekableReadStream *f, bool uiFlag); +}; + +class AnimMiscEntry { +public: + int _soundId; + int _msgIndex; + int _numTicks; + Common::Point _posAdjust; + int _field8; + + /** + * Loads data for the record + */ + void load(Common::SeekableReadStream *f); +}; + +#define ANIM_SPAWN_COUNT 2 + +class AnimUIEntry { +public: + int _probability; + int _imageCount; + int _firstImage; + int _lastImage; + int _counter; + int _spawn[ANIM_SPAWN_COUNT]; + int _spawnFrame[ANIM_SPAWN_COUNT]; + int _sound; + int _soundFrame; + + /** + * Loads the data for the record + */ + void load(Common::SeekableReadStream *f); +}; + +class AAHeader { +public: + int _spriteSetsCount; + int _miscEntriesCount; + int _frameEntriesCount; + int _messagesCount; + byte _flags; + AnimBgType _bgType; + int _roomNumber; + bool _manualFlag; + int _spritesIndex; + Common::Point _scrollPosition; + uint32 _scrollTicks; + Common::String _interfaceFile; + Common::StringArray _spriteSetNames; + Common::String _lbmFilename; + Common::String _spritesFilename; + Common::String _soundName; + Common::String _dsrName; + Common::String _fontResource; + + /** + * Loads the data for a animation file header + */ + void load(Common::SeekableReadStream *f); +}; + +class Animation { +private: + MADSEngine *_vm; + Scene *_scene; + + Common::Array<AnimMiscEntry> _miscEntries; + Common::Array<SpriteAsset *> _spriteSets; + Font *_font; + + bool _freeFlag; + bool _skipLoad; + int _unkIndex; + Common::Point _unkList[2]; + uint32 _nextFrameTimer; + uint32 _nextScrollTimer; + int _messageCtr; + int _trigger; + TriggerMode _triggerMode; + ActionDetails _actionDetails; + + /** + * Load data for a given frame + * @param frameNumber Frame number + */ + void loadFrame(int frameNumber); + + bool drawFrame(SpriteAsset &spriteSet, const Common::Point &pt, int frameNumber); + + /** + * Load the user interface display for an animation + */ + void loadInterface(UserInterface &interfaceSurface, DepthSurface &depthSurface, + AAHeader &header, int flags, Common::Array<PaletteCycle> *palCycles, SceneInfo *sceneInfo); + + /** + * Returns true if there is a scroll required + */ + bool hasScroll() const; +protected: + Animation(MADSEngine *vm, Scene *scene); +public: + AAHeader _header; + Common::Array<int> _spriteListIndexes; + Common::Array<AnimFrameEntry> _frameEntries; + Common::Array<AnimUIEntry> _uiEntries; + Common::Array<AnimMessage> _messages; + bool _resetFlag; + int _currentFrame; + int _oldFrameEntry; + + static Animation *init(MADSEngine *vm, Scene *scene); + /* + * Destructor + */ + ~Animation(); + + /** + * Loads animation data + */ + void load(UserInterface &interfaceSurface, DepthSurface &depthSurface, const Common::String &resName, + int flags, Common::Array<PaletteCycle> *palCycles, SceneInfo *sceneInfo); + + /** + * Preload animation data for the scene + */ + void preLoad(const Common::String &resName, int level); + + /** + * Setups up a loaded animation for playback + */ + void startAnimation(int endTrigger); + + /** + * Update the animation + */ + void update(); + + void setNextFrameTimer(int frameNumber); + int getNextFrameTimer() const { return _nextFrameTimer; } + void setCurrentFrame(int frameNumber); + int getCurrentFrame() const { return _currentFrame; } + + bool freeFlag() const { return _freeFlag; } + int roomNumber() const { return _header._roomNumber; } + + void resetSpriteSetsCount() { _header._spriteSetsCount = 0; } // CHECKME: See if it doesn't leak the memory when the destructor is called +}; + +} // End of namespace MADS + +#endif /* MADS_ANIMATION_H */ diff --git a/engines/mads/assets.cpp b/engines/mads/assets.cpp new file mode 100644 index 0000000000..1cb174bbed --- /dev/null +++ b/engines/mads/assets.cpp @@ -0,0 +1,227 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/assets.h" +#include "mads/compression.h" +#include "mads/events.h" +#include "mads/palette.h" + +namespace MADS { + +SpriteAsset::SpriteAsset(MADSEngine *vm, const Common::String &resourceName, int flags) : + _vm(vm) { + Common::String resName = resourceName; + if (!resName.hasSuffix(".SS") && !resName.hasSuffix(".ss")) + resName += ".SS"; + + File file(resName); + load(&file, flags); + + file.close(); +} + +SpriteAsset::SpriteAsset(MADSEngine *vm, Common::SeekableReadStream *stream, int flags) : + _vm(vm) { + load(stream, flags); +} + +SpriteAsset::~SpriteAsset() { + if (_usageIndex) + _vm->_palette->_paletteUsage.resetPalFlags(_usageIndex); + + for (uint i = 0; i < _frames.size(); ++i) + delete _frames[i]._frame; + + delete _charInfo; +} + +void SpriteAsset::load(Common::SeekableReadStream *stream, int flags) { + int curFrame = 0; + uint32 frameOffset = 0; + MadsPack sprite(stream); + _frameRate = 0; + _pixelSpeed = 0; + _maxWidth = 0; + _maxHeight = 0; + _usageIndex = -1; + + Common::SeekableReadStream *spriteStream = sprite.getItemStream(0); + _mode = spriteStream->readByte(); + spriteStream->skip(1); + int type1 = spriteStream->readUint16LE(); + int type2 = spriteStream->readUint16LE(); + _isBackground = (type1 != 0) && (type2 < 4); + spriteStream->skip(32); + _frameCount = spriteStream->readUint16LE(); + + if ((flags & SPRITE_SET_CHAR_INFO) == 0) + _charInfo = nullptr; + else + _charInfo = new SpriteSetCharInfo(spriteStream); + + delete spriteStream; + + // Get the palette data + Common::SeekableReadStream *palStream = sprite.getItemStream(2); + Common::Array<RGB6> palette; + + int numColors = palStream->readUint16LE(); + assert(numColors <= 252); + _colorCount = numColors; + + // Load in the palette + palette.resize(numColors); + for (int i = 0; i < numColors; ++i) + palette[i].load(palStream); + delete palStream; + + // Process the palette data + if (flags & 9) { + _usageIndex = 0; + + if (flags & 8) { + int newPalCtr = 0; + + for (uint i = 0; i < palette.size(); ++i) { + RGB6 &rgb = palette[i]; + + // Scan for existing rgb at beginning of the main palette + bool found = false; + for (int pIndex = 0; pIndex < 4 && !found; ++pIndex) { + byte *palP = &_vm->_palette->_mainPalette[pIndex * 3]; + if (palP[0] == rgb.r && palP[1] == rgb.g && palP[2] == rgb.b) { + rgb._palIndex = pIndex; + found = true; + } + } + + if (!found) { + // Existing palette entry not found, so need to add it in + int palIndex = (0xF7F607 >> (8 * newPalCtr)) & 0xff; + byte *palP = &_vm->_palette->_mainPalette[palIndex * 3]; + palP[0] = rgb.r; + palP[1] = rgb.g; + palP[2] = rgb.b; + rgb._palIndex = palIndex; + + newPalCtr = MIN(newPalCtr + 1, 2); + } + } + } + } else { + _usageIndex = _vm->_palette->_paletteUsage.process(palette, flags); + assert(_usageIndex >= 0); + } + + spriteStream = sprite.getItemStream(1); + Common::SeekableReadStream *spriteDataStream = sprite.getItemStream(3); + SpriteAssetFrame frame; + Common::Array<int> frameSizes; + for (curFrame = 0; curFrame < _frameCount; curFrame++) { + frame._stream = 0; + frame._comp = 0; + frameOffset = spriteStream->readUint32LE(); + _frameOffsets.push_back(frameOffset); + uint32 frameSize = spriteStream->readUint32LE(); + frameSizes.push_back(frameSize); + + frame._bounds.left = spriteStream->readSint16LE(); + frame._bounds.top = spriteStream->readSint16LE(); + frame._bounds.setWidth(spriteStream->readUint16LE()); + frame._bounds.setHeight(spriteStream->readUint16LE()); + + if (curFrame == 0) + debugC(1, kDebugGraphics, "%i frames, x = %i, y = %i, w = %i, h = %i\n", + _frameCount, frame._bounds.left, frame._bounds.top, + frame._bounds.width(), frame._bounds.height()); + + if (_mode == 0) { + // Create a frame and decompress the raw pixel data + uint32 currPos = (uint32)spriteDataStream->pos(); + frame._frame = new MSprite(spriteDataStream, palette, frame._bounds); + assert((uint32)spriteDataStream->pos() == (currPos + frameSize)); + } + + _frames.push_back(frame); + } + + if (_mode != 0) { + // Handle decompressing Fab encoded data + for (curFrame = 0; curFrame < _frameCount; curFrame++) { + FabDecompressor fab; + + int srcSize = (curFrame == (_frameCount - 1)) ? spriteDataStream->size() - _frameOffsets[curFrame] : + _frameOffsets[curFrame + 1] - _frameOffsets[curFrame]; + byte *srcData = new byte[srcSize]; + assert(srcData); + spriteDataStream->read(srcData, srcSize); + + byte *destData = new byte[frameSizes[curFrame]]; + assert(destData); + + fab.decompress(srcData, srcSize, destData, frameSizes[curFrame]); + + // Load the frames + Common::MemoryReadStream *rs = new Common::MemoryReadStream(destData, frameSizes[curFrame]); + _frames[curFrame]._frame = new MSprite(rs, palette, _frames[curFrame]._bounds); + delete rs; + + delete[] srcData; + delete[] destData; + } + } + + delete spriteStream; + delete spriteDataStream; +} + +MSprite *SpriteAsset::getFrame(int frameIndex) { + if ((uint)frameIndex < _frames.size()) { + return _frames[frameIndex]._frame; + } else { + debugC(kDebugGraphics, "SpriteAsset::getFrame: Invalid frame %d, out of %d", frameIndex, _frames.size()); + return _frames[_frames.size() - 1]._frame; + } +} + +/*------------------------------------------------------------------------*/ + +SpriteSetCharInfo::SpriteSetCharInfo(Common::SeekableReadStream *s) { + _totalFrames = s->readByte(); + s->skip(1); + _numEntries = s->readUint16LE(); + + for (int i = 0; i < 16; ++i) + _startFrames[i] = s->readUint16LE(); + for (int i = 0; i < 16; ++i) + _stopFrames[i] = s->readUint16LE(); + for (int i = 0; i < 16; ++i) + _ticksList[i] = s->readUint16LE(); + + _velocity = s->readUint16LE(); + _ticksAmount = s->readByte(); + _centerOfGravity = s->readByte(); +} + +} // End of namespace MADS diff --git a/engines/mads/assets.h b/engines/mads/assets.h new file mode 100644 index 0000000000..874eee7925 --- /dev/null +++ b/engines/mads/assets.h @@ -0,0 +1,112 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_ASSETS_H +#define MADS_ASSETS_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "mads/palette.h" + +namespace MADS { + +#define SPRITE_SET_CHAR_INFO 4 + +class MADSEngine; +class MSprite; +class MSurface; + +struct SpriteAssetFrame { + uint32 _stream; + Common::Rect _bounds; + uint32 _comp; + MSprite *_frame; +}; + +class SpriteSetCharInfo { +public: + SpriteSetCharInfo(Common::SeekableReadStream *s); + + int _totalFrames; + int _numEntries; + int _startFrames[16]; + int _stopFrames[16]; + int _ticksList[16]; + int _velocity; + int _ticksAmount; + int _centerOfGravity; +}; + +class SpriteAsset { +private: + MADSEngine *_vm; + byte _palette[PALETTE_SIZE]; + int _colorCount; + uint32 _srcSize; + int _frameRate, _pixelSpeed; + int _maxWidth, _maxHeight; + int _frameCount; + Common::Array<uint32> _frameOffsets; + Common::Array<SpriteAssetFrame> _frames; + uint32 _frameStartOffset; + uint8 _mode; + bool _isBackground; + + /** + * Load the data for the asset + */ + void load(Common::SeekableReadStream *stream, int flags); +public: + SpriteSetCharInfo *_charInfo; + int _usageIndex; +public: + /** + * Constructor + */ + SpriteAsset(MADSEngine *vm, const Common::String &resourceName, int flags); + + /** + * Constructor + */ + SpriteAsset(MADSEngine *vm, Common::SeekableReadStream *stream, int flags); + + /** + * Destructor + */ + ~SpriteAsset(); + + int getCount() { return _frameCount; } + int getFrameRate() const { return _frameRate; } + int getPixelSpeed() const { return _pixelSpeed; } + int getFrameWidth(int index); + int getFrameHeight(int index); + int getMaxFrameWidth() const { return _maxWidth; } + int getMaxFrameHeight() const { return _maxHeight; } + MSprite *getFrame(int frameIndex); + byte *getPalette() { return _palette; } + int getColorCount() { return _colorCount; } + bool isBackground() const { return _isBackground; } +}; + +} // End of namespace MADS + +#endif /* MADS_ASSETS_H */ diff --git a/engines/mads/audio.cpp b/engines/mads/audio.cpp new file mode 100644 index 0000000000..1c61e13957 --- /dev/null +++ b/engines/mads/audio.cpp @@ -0,0 +1,129 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "mads/audio.h" +#include "mads/compression.h" + +#include "common/stream.h" +#include "audio/audiostream.h" +#include "audio/mixer.h" +#include "audio/decoders/raw.h" + +namespace MADS { + +AudioPlayer::AudioPlayer(Audio::Mixer *mixer, uint32 gameID) : _mixer(mixer), _gameID(gameID) { + setVolume(Audio::Mixer::kMaxChannelVolume); + setDefaultSoundGroup(); +} + +AudioPlayer::~AudioPlayer() { + _dsrEntries.clear(); +} + +bool AudioPlayer::isPlaying() const { + return _mixer->isSoundHandleActive(_handle); +} + +void AudioPlayer::setVolume(int volume) { + _mixer->setVolumeForSoundType(Audio::Mixer::kSFXSoundType, volume); + _mixer->setVolumeForSoundType(Audio::Mixer::kSpeechSoundType, volume); +} + +void AudioPlayer::setDefaultSoundGroup() { + switch (_gameID) { + case GType_RexNebular: + setSoundGroup("rex009.dsr"); + break; + case GType_Dragonsphere: + setSoundGroup("drag009.dsr"); + break; + case GType_Phantom: + setSoundGroup("phan009.dsr"); + break; + default: + error("setDefaultSoundGroup: Unknown game"); + } +} + +void AudioPlayer::setSoundGroup(const Common::String &filename) { + _dsrEntries.clear(); + + _filename = filename; + _dsrFile.open(filename); + + // Read header + uint16 entryCount = _dsrFile.readUint16LE(); + + for (uint16 i = 0; i < entryCount; i++) { + DSREntry newEntry; + newEntry.frequency = _dsrFile.readUint16LE(); + newEntry.channels = _dsrFile.readUint32LE(); + newEntry.compSize = _dsrFile.readUint32LE(); + newEntry.uncompSize = _dsrFile.readUint32LE(); + newEntry.offset = _dsrFile.readUint32LE(); + _dsrEntries.push_back(newEntry); + } + + _dsrFile.close(); +} + +void AudioPlayer::playSound(int soundIndex, bool loop) { + if (_dsrEntries.empty()) { + warning("DSR file not loaded, not playing sound"); + return; + } + + if (soundIndex < 0 || soundIndex > (int)_dsrEntries.size() - 1) { + warning("Invalid sound index: %i (max %i), not playing sound", soundIndex, _dsrEntries.size() - 1); + return; + } + + // Get sound data + FabDecompressor fab; + int32 compSize = _dsrEntries[soundIndex].compSize; + int32 uncompSize = _dsrEntries[soundIndex].uncompSize; + int32 offset = _dsrEntries[soundIndex].offset; + int16 frequency = _dsrEntries[soundIndex].frequency; + byte *compData = new byte[compSize]; + byte *buffer = new byte[uncompSize]; + _dsrFile.open(_filename); + _dsrFile.seek(offset, SEEK_SET); + _dsrFile.read(compData, compSize); + _dsrFile.close(); + + fab.decompress(compData, compSize, buffer, uncompSize); + + // Play sound + Audio::AudioStream *stream = Audio::makeLoopingAudioStream( + Audio::makeRawStream(buffer, uncompSize, frequency, Audio::FLAG_UNSIGNED), + loop ? 0 : 1); + _mixer->playStream(Audio::Mixer::kSFXSoundType, &_handle, stream, -1, Audio::Mixer::kMaxChannelVolume); + + /* + // Dump the sound file + FILE *destFile = fopen("sound.raw", "wb"); + fwrite(_dsrFile.dsrEntries[soundIndex]->data, _dsrFile.dsrEntries[soundIndex].uncompSize, 1, destFile); + fclose(destFile); + */ +} + +} // End of namespace M4 diff --git a/engines/mads/audio.h b/engines/mads/audio.h new file mode 100644 index 0000000000..21f4bed59a --- /dev/null +++ b/engines/mads/audio.h @@ -0,0 +1,64 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_AUDIO_H +#define MADS_AUDIO_H + +#include "mads/resources.h" + +#include "common/array.h" +#include "audio/mixer.h" + +namespace MADS { + +struct DSREntry { + int16 frequency; + int channels; + int32 compSize; + int32 uncompSize; + int32 offset; +}; + +class AudioPlayer { +public: + AudioPlayer(Audio::Mixer *mixer, uint32 gameID); + ~AudioPlayer(); + + void setSoundGroup(const Common::String &filename); + void setDefaultSoundGroup(); + void playSound(int soundIndex, bool loop = false); + void setVolume(int volume); + bool isPlaying() const; + + private: + Audio::Mixer *_mixer; + Audio::SoundHandle _handle; + uint32 _gameID; + + File _dsrFile; + Common::String _filename; + Common::Array<DSREntry> _dsrEntries; +}; + +} // End of namespace MADS + +#endif diff --git a/engines/mads/compression.cpp b/engines/mads/compression.cpp new file mode 100644 index 0000000000..de893e7b1a --- /dev/null +++ b/engines/mads/compression.cpp @@ -0,0 +1,190 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "mads/compression.h" + +namespace MADS { + +const char *const madsPackString = "MADSPACK"; +const char *const FabInputExceededError = "FabDecompressor - Passed end of input buffer during decompression"; +const char *const FabOutputExceededError = "FabDecompressor - Decompressed data exceeded specified size"; + +bool MadsPack::isCompressed(Common::SeekableReadStream *stream) { + // Check whether the passed stream is packed + + char tempBuffer[8]; + stream->seek(0); + if (stream->read(tempBuffer, 8) == 8) { + if (!strncmp(tempBuffer, madsPackString, 8)) + return true; + } + + return false; +} + +MadsPack::MadsPack(Common::SeekableReadStream *stream) { + initialise(stream); +} + +MadsPack::MadsPack(const Common::String &resourceName, MADSEngine *vm) { + File file(resourceName); + initialise(&file); + file.close(); +} + +void MadsPack::initialise(Common::SeekableReadStream *stream) { + if (!MadsPack::isCompressed(stream)) + error("Attempted to decompress a resource that was not MadsPacked"); + + stream->seek(14); + _count = stream->readUint16LE(); + _items = new MadsPackEntry[_count]; + + byte *headerData = new byte[0xA0]; + byte *header = headerData; + stream->read(headerData, 0xA0); + + for (int i = 0; i < _count; ++i, header += 10) { + // Get header data + _items[i].hash = READ_LE_UINT16(header); + _items[i].size = READ_LE_UINT32(header + 2); + _items[i].compressedSize = READ_LE_UINT32(header + 6); + + byte *sourceData = new byte[_items[i].compressedSize]; + stream->read(sourceData, _items[i].compressedSize); + + if (_items[i].size == _items[i].compressedSize && + !FabDecompressor::isCompressed(sourceData)) { + // Entry isn't compressed + _items[i].data = sourceData; + } else { + // Decompress the entry + _items[i].data = new byte[_items[i].size]; + + FabDecompressor fab; + fab.decompress(sourceData, _items[i].compressedSize, _items[i].data, _items[i].size); + delete[] sourceData; + } + } + + delete[] headerData; + _dataOffset = stream->pos(); +} + +MadsPack::~MadsPack() { + for (int i = 0; i < _count; ++i) + delete[] _items[i].data; + delete[] _items; +} + +//-------------------------------------------------------------------------- + +bool FabDecompressor::isCompressed(const byte *srcData) { + return strncmp((const char *)srcData, "FAB", 3) == 0; +} + +void FabDecompressor::decompress(const byte *srcData, int srcSize, byte *destData, int destSize) { + byte copyLen, copyOfsShift, copyOfsMask, copyLenMask; + unsigned long copyOfs; + byte *destP; + + // Validate that the data starts with the FAB header + if (strncmp((const char *)srcData, "FAB", 3) != 0) + error("FabDecompressor - Invalid compressed data"); + + int shiftVal = srcData[3]; + if ((shiftVal < 10) || (shiftVal > 13)) + error("FabDecompressor - Invalid shift start"); + + copyOfsShift = 16 - shiftVal; + copyOfsMask = 0xFF << (shiftVal - 8); + copyLenMask = (1 << copyOfsShift) - 1; + copyOfs = 0xFFFF0000; + destP = destData; + + // Initialise data fields + _srcData = srcData; + _srcP = _srcData + 6; + _srcSize = srcSize; + _bitsLeft = 16; + _bitBuffer = READ_LE_UINT16(srcData + 4); + + for (;;) { + if (getBit() == 0) { + if (getBit() == 0) { + copyLen = ((getBit() << 1) | getBit()) + 2; + copyOfs = *_srcP++ | 0xFFFFFF00; + } else { + copyOfs = (((_srcP[1] >> copyOfsShift) | copyOfsMask) << 8) | _srcP[0]; + copyLen = _srcP[1] & copyLenMask; + _srcP += 2; + if (copyLen == 0) { + copyLen = *_srcP++; + if (copyLen == 0) + break; + else if (copyLen == 1) + continue; + else + copyLen++; + } else { + copyLen += 2; + } + copyOfs |= 0xFFFF0000; + } + while (copyLen-- > 0) { + if (destP - destData == destSize) + error(FabOutputExceededError); + + *destP = destP[(signed int)copyOfs]; + destP++; + } + } else { + if (_srcP - srcData == srcSize) + error(FabInputExceededError); + if (destP - destData == destSize) + error(FabOutputExceededError); + + *destP++ = *_srcP++; + } + } + + if (destP - destData != destSize) + error("FabDecompressor - Decompressed data does not match header decompressed size"); +} + +int FabDecompressor::getBit() { + _bitsLeft--; + if (_bitsLeft == 0) { + if (_srcP - _srcData == _srcSize) + error(FabInputExceededError); + + _bitBuffer = (READ_LE_UINT16(_srcP) << 1) | (_bitBuffer & 1); + _srcP += 2; + _bitsLeft = 16; + } + + int bit = _bitBuffer & 1; + _bitBuffer >>= 1; + return bit; +} + +} // End of namespace MADS diff --git a/engines/mads/compression.h b/engines/mads/compression.h new file mode 100644 index 0000000000..43a966f48c --- /dev/null +++ b/engines/mads/compression.h @@ -0,0 +1,88 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_COMPRESSION_H +#define MADS_COMPRESSION_H + +#include "common/scummsys.h" +#include "common/endian.h" +#include "common/memstream.h" +#include "common/stream.h" + +#include "mads/mads.h" + +namespace MADS { + +struct MadsPackEntry { +public: + uint16 hash; + uint32 size; + uint32 compressedSize; + byte *data; +}; + +class MadsPack { +private: + MadsPackEntry *_items; + int _count; + int _dataOffset; + + void initialise(Common::SeekableReadStream *stream); +public: + static bool isCompressed(Common::SeekableReadStream *stream); + MadsPack(Common::SeekableReadStream *stream); + MadsPack(const Common::String &resourceName, MADSEngine *_vm); + ~MadsPack(); + + int getCount() const { return _count; } + MadsPackEntry &getItem(int index) const { + assert(index < _count); + return _items[index]; } + MadsPackEntry &operator[](int index) const { + assert(index < _count); + return _items[index]; + } + Common::MemoryReadStream *getItemStream(int index) { + assert(index < _count); + return new Common::MemoryReadStream(_items[index].data, _items[index].size, + DisposeAfterUse::NO); + } + int getDataOffset() const { return _dataOffset; } +}; + +class FabDecompressor { +private: + int _bitsLeft; + uint32 _bitBuffer; + const byte *_srcData, *_srcP; + int _srcSize; + + int getBit(); +public: + void decompress(const byte *srcData, int srcSize, byte *destData, int destSize); + + static bool isCompressed(const byte *srcData); +}; + +} // End of namespace MADS + +#endif diff --git a/engines/mads/configure.engine b/engines/mads/configure.engine new file mode 100644 index 0000000000..60d833e9e8 --- /dev/null +++ b/engines/mads/configure.engine @@ -0,0 +1,3 @@ +# This file is included from the main "configure" script +# add_engine [name] [desc] [build-by-default] [subengines] [base games] [deps] +add_engine mads "Rex Nebular and the Cosmic Gender Bender" no diff --git a/engines/mads/debugger.cpp b/engines/mads/debugger.cpp new file mode 100644 index 0000000000..9f5735f318 --- /dev/null +++ b/engines/mads/debugger.cpp @@ -0,0 +1,326 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/file.h" +#include "mads/mads.h" +#include "mads/debugger.h" + +namespace MADS { + +Debugger::Debugger(MADSEngine *vm) : GUI::Debugger(), _vm(vm) { + _showMousePos = false; + + DCmd_Register("continue", WRAP_METHOD(Debugger, Cmd_Exit)); + DCmd_Register("mouse", WRAP_METHOD(Debugger, Cmd_Mouse)); + DCmd_Register("scene", WRAP_METHOD(Debugger, Cmd_LoadScene)); + DCmd_Register("show_hotspots", WRAP_METHOD(Debugger, Cmd_ShowHotSpots)); + DCmd_Register("list_hotspots", WRAP_METHOD(Debugger, Cmd_ListHotSpots)); + DCmd_Register("play_sound", WRAP_METHOD(Debugger, Cmd_PlaySound)); + DCmd_Register("play_audio", WRAP_METHOD(Debugger, Cmd_PlayAudio)); + DCmd_Register("show_codes", WRAP_METHOD(Debugger, Cmd_ShowCodes)); + DCmd_Register("dump_file", WRAP_METHOD(Debugger, Cmd_DumpFile)); + DCmd_Register("show_quote", WRAP_METHOD(Debugger, Cmd_ShowQuote)); + DCmd_Register("show_vocab", WRAP_METHOD(Debugger, Cmd_ShowVocab)); + DCmd_Register("dump_vocab", WRAP_METHOD(Debugger, Cmd_DumpVocab)); + DCmd_Register("show_message", WRAP_METHOD(Debugger, Cmd_ShowMessage)); + DCmd_Register("show_item", WRAP_METHOD(Debugger, Cmd_ShowItem)); + DCmd_Register("dump_items", WRAP_METHOD(Debugger, Cmd_DumpItems)); + DCmd_Register("item", WRAP_METHOD(Debugger, Cmd_Item)); +} + +static int strToInt(const char *s) { + if (!*s) + // No string at all + return 0; + else if (toupper(s[strlen(s) - 1]) != 'H') + // Standard decimal string + return atoi(s); + + // Hexadecimal string + uint tmp = 0; + int read = sscanf(s, "%xh", &tmp); + if (read < 1) + error("strToInt failed on string \"%s\"", s); + return (int)tmp; +} + +bool Debugger::Cmd_Mouse(int argc, const char **argv) { + if (argc < 2) { + DebugPrintf("Usage: %s [ on | off ]\n", argv[0]); + } else { + _showMousePos = strcmp(argv[1], "on") == 0; + } + + return true; +} + +bool Debugger::Cmd_LoadScene(int argc, const char **argv) { + if (argc != 2) { + DebugPrintf("Current scene is: %d\n", _vm->_game->_scene._currentSceneId); + DebugPrintf("Usage: %s <scene number>\n", argv[0]); + return true; + } else { + _vm->_game->_scene._nextSceneId = strToInt(argv[1]); + return false; + } +} + +bool Debugger::Cmd_ShowHotSpots(int argc, const char **argv) { + Scene &scene = _vm->_game->_scene; + + // hotspots + byte hotspotCol = _vm->getRandomNumber(255); + for (uint i = 0; i < scene._hotspots.size(); i++) { + scene._backgroundSurface.frameRect(scene._hotspots[i]._bounds, hotspotCol); + } + + // Dynamic hotspots (red) + hotspotCol = _vm->getRandomNumber(255); + for (uint i = 0; i < scene._dynamicHotspots.size(); i++) { + scene._backgroundSurface.frameRect(scene._dynamicHotspots[i]._bounds, hotspotCol); + } + + scene._spriteSlots.fullRefresh(); + return false; +} + +bool Debugger::Cmd_ListHotSpots(int argc, const char **argv) { + Hotspots &hotspots = _vm->_game->_scene._hotspots; + + DebugPrintf("%d hotspots present\n", hotspots.size()); + + for (uint index = 0; index < hotspots.size(); ++index) { + DebugPrintf("(%d): %p x1 = %d; y1 = %d; x2 = %d; y2 = %d\n", + index, (void *)&hotspots[index], + hotspots[index]._bounds.left, hotspots[index]._bounds.top, + hotspots[index]._bounds.right, hotspots[index]._bounds.bottom); + } + + return true; +} + +bool Debugger::Cmd_PlaySound(int argc, const char **argv) { + if (argc < 2) { + DebugPrintf("Usage: %s <sound file>\n", argv[0]); + } else { + int commandId = strToInt(argv[1]); + int param = (argc >= 3) ? strToInt(argv[2]) : 0; + + _vm->_sound->command(commandId, param); + } + + return false; +} + +bool Debugger::Cmd_PlayAudio(int argc, const char **argv) { + if (argc < 2) { + DebugPrintf("Usage: %s <sound index> <sound group>\n", argv[0]); + DebugPrintf("If the sound group isn't defined, the default one will be used\n"); + } else { + int index = strToInt(argv[1]); + Common::String soundGroup = (argc >= 3) ? argv[2] : ""; + if (argc >= 3) + _vm->_audio->setSoundGroup(argv[2]); + else + _vm->_audio->setDefaultSoundGroup(); + + _vm->_audio->playSound(index); + } + + return true; +} + +bool Debugger::Cmd_ShowCodes(int argc, const char **argv) { + Scene &scene = _vm->_game->_scene; + + // Copy the depth/walk surface to the background and flag for screen refresh + scene._depthSurface.copyTo(&scene._backgroundSurface); + scene._spriteSlots.fullRefresh(); + + // Draw the locations of scene nodes onto the background + int color = _vm->getRandomNumber(255); + for (int i = 0; i < (int)scene._sceneInfo->_nodes.size(); ++i) { + Common::Point &pt = scene._sceneInfo->_nodes[i]._walkPos; + + scene._backgroundSurface.hLine(pt.x - 2, pt.y, pt.x + 2, color); + scene._backgroundSurface.vLine(pt.x, pt.y - 2, pt.y + 2, color); + } + + return false; +} + +bool Debugger::Cmd_DumpFile(int argc, const char **argv) { + if (argc != 2) { + DebugPrintf("Usage: %s <resource>\n", argv[0]); + } else { + Common::DumpFile outFile; + Common::File inFile; + + if (!inFile.open(argv[1])) { + DebugPrintf("Specified resource does not exist\n"); + } else { + outFile.open(argv[1]); + byte *data = new byte[inFile.size()]; + + inFile.read(data, inFile.size()); + outFile.write(data, inFile.size()); + outFile.flush(); + + delete[] data; + inFile.close(); + outFile.close(); + + DebugPrintf("File written successfully.\n"); + } + } + + return true; +} + +bool Debugger::Cmd_ShowQuote(int argc, const char **argv) { + if (argc != 2) + DebugPrintf("Usage: %s <quote number>\n", argv[0]); + else + DebugPrintf("%s", _vm->_game->getQuote(strToInt(argv[1])).c_str()); + + return true; +} + +bool Debugger::Cmd_ShowVocab(int argc, const char **argv) { + if (argc != 2) { + for (uint32 i = 0; i < _vm->_game->_scene.getVocabStringsCount(); i++) { + DebugPrintf("%03d: '%s'\n", i, _vm->_game->_scene.getVocab(i + 1).c_str()); + } + } else { + int vocabId = strToInt(argv[1]); + DebugPrintf("%03d: '%s'\n", vocabId, _vm->_game->_scene.getVocab(vocabId + 1).c_str()); + } + + return true; +} + +bool Debugger::Cmd_DumpVocab(int argc, const char **argv) { + Common::DumpFile outFile; + outFile.open("vocab.txt"); + + for (uint32 i = 0; i < _vm->_game->_scene.getVocabStringsCount(); i++) { + Common::String curId = Common::String::format("%x", i + 1); + Common::String curVocab = _vm->_game->_scene.getVocab(i + 1); + curVocab.toUppercase(); + + for (uint j = 0; j < curVocab.size(); j++) { + if (curVocab[j] == ' ' || curVocab[j] == '-') + curVocab.setChar('_', j); + } + + Common::String cur = "\tNOUN_" + curVocab + " = 0x" + curId + ",\n"; + + outFile.writeString(cur.c_str()); + } + + outFile.flush(); + outFile.close(); + + DebugPrintf("Game vocab dumped\n"); + + return true; +} + +bool Debugger::Cmd_ShowMessage(int argc, const char **argv) { + if (argc != 2) { + DebugPrintf("Usage: %s <message number>\n", argv[0]); + } else { + int messageId = strToInt(argv[1]); + Common::StringArray msg = _vm->_game->getMessage(messageId); + for (uint idx = 0; idx < msg.size(); ++idx) { + Common::String srcLine = msg[idx]; + DebugPrintf("%s\n", srcLine.c_str()); + } + } + + return true; +} + +bool Debugger::Cmd_ShowItem(int argc, const char **argv) { + InventoryObjects &objects = _vm->_game->_objects; + + if (argc != 2) { + for (uint32 i = 0; i < objects.size(); i++) { + Common::String desc = _vm->_game->_scene.getVocab(objects[i]._descId); + DebugPrintf("%03d: '%s'\n", i, desc.c_str()); + } + } else { + int vocabId = strToInt(argv[1]); + Common::String desc = _vm->_game->_scene.getVocab(objects[vocabId]._descId); + DebugPrintf("%03d: '%s'\n", vocabId, desc.c_str()); + } + + return true; +} + +bool Debugger::Cmd_DumpItems(int argc, const char **argv) { + InventoryObjects &objects = _vm->_game->_objects; + + Common::DumpFile outFile; + outFile.open("items.txt"); + + for (uint32 i = 0; i < objects.size(); i++) { + Common::String curId = Common::String::format("%d", i); + Common::String desc = _vm->_game->_scene.getVocab(objects[i]._descId); + desc.toUppercase(); + + for (uint j = 0; j < desc.size(); j++) { + if (desc[j] == ' ' || desc[j] == '-') + desc.setChar('_', j); + } + + Common::String cur = "\tOBJ_" + desc + " = " + curId + ",\n"; + + outFile.writeString(cur.c_str()); + } + + outFile.flush(); + outFile.close(); + + DebugPrintf("Game items dumped\n"); + + return true; +} + +bool Debugger::Cmd_Item(int argc, const char **argv) { + InventoryObjects &objects = _vm->_game->_objects; + + if (argc != 2) { + DebugPrintf("Usage: %s <item number>\n", argv[0]); + return true; + } else { + int objectId = strToInt(argv[1]); + + if (!objects.isInInventory(objectId)) + objects.addToInventory(objectId); + + DebugPrintf("Item added.\n"); + return false; + } +} + +} // End of namespace MADS diff --git a/engines/mads/debugger.h b/engines/mads/debugger.h new file mode 100644 index 0000000000..351eb13615 --- /dev/null +++ b/engines/mads/debugger.h @@ -0,0 +1,61 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_DEBUGGER_H +#define MADS_DEBUGGER_H + +#include "common/scummsys.h" +#include "gui/debugger.h" + +namespace MADS { + +class MADSEngine; + +class Debugger : public GUI::Debugger { +private: + MADSEngine *_vm; +protected: + bool Cmd_Mouse(int argc, const char **argv); + bool Cmd_LoadScene(int argc, const char **argv); + bool Cmd_ShowHotSpots(int argc, const char **argv); + bool Cmd_ListHotSpots(int argc, const char **argv); + bool Cmd_PlaySound(int argc, const char **argv); + bool Cmd_PlayAudio(int argc, const char **argv); + bool Cmd_ShowCodes(int argc, const char **argv); + bool Cmd_DumpFile(int argc, const char **argv); + bool Cmd_ShowQuote(int argc, const char **argv); + bool Cmd_ShowVocab(int argc, const char **argv); + bool Cmd_DumpVocab(int argc, const char **argv); + bool Cmd_ShowMessage(int argc, const char **argv); + bool Cmd_ShowItem(int argc, const char **argv); + bool Cmd_DumpItems(int argc, const char **argv); + bool Cmd_Item(int argc, const char **argv); +public: + bool _showMousePos; +public: + Debugger(MADSEngine *vm); + virtual ~Debugger() {} +}; + +} // End of namespace MADS + +#endif /* MADS_DEBUGGER_H */ diff --git a/engines/mads/detection.cpp b/engines/mads/detection.cpp new file mode 100644 index 0000000000..971acde024 --- /dev/null +++ b/engines/mads/detection.cpp @@ -0,0 +1,194 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * + */ + +#include "mads/mads.h" + +#include "base/plugins.h" +#include "common/savefile.h" +#include "common/str-array.h" +#include "common/memstream.h" +#include "engines/advancedDetector.h" +#include "common/system.h" +#include "graphics/colormasks.h" +#include "graphics/surface.h" +#include "mads/events.h" +#include "mads/game.h" + +#define MAX_SAVES 99 + +namespace MADS { + +struct MADSGameDescription { + ADGameDescription desc; + + int gameID; + uint32 features; +}; + +uint32 MADSEngine::getGameID() const { + return _gameDescription->gameID; +} + +uint32 MADSEngine::getGameFeatures() const { + return _gameDescription->features; +} + +uint32 MADSEngine::getFeatures() const { + return _gameDescription->desc.flags; +} + +Common::Language MADSEngine::getLanguage() const { + return _gameDescription->desc.language; +} + +Common::Platform MADSEngine::getPlatform() const { + return _gameDescription->desc.platform; +} + +} // End of namespace MADS + +static const PlainGameDescriptor MADSGames[] = { + {"MADS", "MADS"}, + {"dragonsphere", "Dragonsphere"}, + {"nebular", "Rex Nebular and the Cosmic Gender Bender"}, + {"phantom", "Return of the Phantom"}, + {0, 0} +}; + +#include "mads/detection_tables.h" + +class MADSMetaEngine : public AdvancedMetaEngine { +public: + MADSMetaEngine() : AdvancedMetaEngine(MADS::gameDescriptions, sizeof(MADS::MADSGameDescription), MADSGames) { + _maxScanDepth = 3; + } + + virtual const char *getName() const { + return "MADS Engine"; + } + + virtual const char *getOriginalCopyright() const { + return "MADS (c)"; + } + + virtual bool hasFeature(MetaEngineFeature f) const; + virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const; + virtual SaveStateList listSaves(const char *target) const; + virtual int getMaximumSaveSlot() const; + virtual void removeSaveState(const char *target, int slot) const; + SaveStateDescriptor querySaveMetaInfos(const char *target, int slot) const; +}; + +bool MADSMetaEngine::hasFeature(MetaEngineFeature f) const { + return + (f == kSupportsListSaves) || + (f == kSupportsLoadingDuringStartup) || + (f == kSupportsDeleteSave) || + (f == kSavesSupportMetaInfo) || + (f == kSavesSupportThumbnail); +} + +bool MADS::MADSEngine::hasFeature(EngineFeature f) const { + return + (f == kSupportsRTL) || + (f == kSupportsLoadingDuringRuntime) || + (f == kSupportsSavingDuringRuntime); +} + +bool MADSMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const { + const MADS::MADSGameDescription *gd = (const MADS::MADSGameDescription *)desc; + if (gd) { + *engine = new MADS::MADSEngine(syst, gd); + } + return gd != 0; +} + +SaveStateList MADSMetaEngine::listSaves(const char *target) const { + Common::SaveFileManager *saveFileMan = g_system->getSavefileManager(); + Common::StringArray filenames; + Common::String saveDesc; + Common::String pattern = Common::String::format("%s.0??", target); + MADS::MADSSavegameHeader header; + + filenames = saveFileMan->listSavefiles(pattern); + sort(filenames.begin(), filenames.end()); // Sort to get the files in numerical order + + SaveStateList saveList; + for (Common::StringArray::const_iterator file = filenames.begin(); file != filenames.end(); ++file) { + const char *ext = strrchr(file->c_str(), '.'); + int slot = ext ? atoi(ext + 1) : -1; + + if (slot >= 0 && slot < MAX_SAVES) { + Common::InSaveFile *in = g_system->getSavefileManager()->openForLoading(*file); + + if (in) { + MADS::Game::readSavegameHeader(in, header); + saveList.push_back(SaveStateDescriptor(slot, header._saveName)); + + header._thumbnail->free(); + delete header._thumbnail; + delete in; + } + } + } + + return saveList; +} + +int MADSMetaEngine::getMaximumSaveSlot() const { + return MAX_SAVES; +} + +void MADSMetaEngine::removeSaveState(const char *target, int slot) const { + Common::String filename = Common::String::format("%s.%03d", target, slot); + g_system->getSavefileManager()->removeSavefile(filename); +} + +SaveStateDescriptor MADSMetaEngine::querySaveMetaInfos(const char *target, int slot) const { + Common::String filename = Common::String::format("%s.%03d", target, slot); + Common::InSaveFile *f = g_system->getSavefileManager()->openForLoading(filename); + + if (f) { + MADS::MADSSavegameHeader header; + MADS::Game::readSavegameHeader(f, header); + delete f; + + // Create the return descriptor + SaveStateDescriptor desc(slot, header._saveName); + desc.setThumbnail(header._thumbnail); + desc.setSaveDate(header._year, header._month, header._day); + desc.setSaveTime(header._hour, header._minute); + desc.setPlayTime(header._totalFrames * GAME_FRAME_TIME); + + return desc; + } + + return SaveStateDescriptor(); +} + + +#if PLUGIN_ENABLED_DYNAMIC(MADS) + REGISTER_PLUGIN_DYNAMIC(MADS, PLUGIN_TYPE_ENGINE, MADSMetaEngine); +#else + REGISTER_PLUGIN_STATIC(MADS, PLUGIN_TYPE_ENGINE, MADSMetaEngine); +#endif diff --git a/engines/mads/detection_tables.h b/engines/mads/detection_tables.h new file mode 100644 index 0000000000..a5a9c33456 --- /dev/null +++ b/engines/mads/detection_tables.h @@ -0,0 +1,104 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +namespace MADS { + +static const MADSGameDescription gameDescriptions[] = { +#if 0 + { + // Rex Nebular and the Cosmic Gender Bender DOS English (compressed) + // Removed for now, until the original floppy compression is supported + { + "nebular", + 0, + { + {"mpslabs.001", 0, "4df5c557b52abb5b661cf4befe5ae301", 1315354}, + AD_LISTEND + }, + Common::EN_ANY, + Common::kPlatformDOS, + ADGF_NO_FLAGS, + GUIO1(GUIO_NONE) + }, + GType_RexNebular, + 0 + }, +#endif + + { + // Rex Nebular and the Cosmic Gender Bender DOS English + { + "nebular", + 0, + { + {"section1.hag", 0, "6f725eb38660de8af31ec7cdd628d615", 927222}, + AD_LISTEND + }, + Common::EN_ANY, + Common::kPlatformDOS, + ADGF_NO_FLAGS, + GUIO1(GUIO_NONE) + }, + GType_RexNebular, + 0 + }, + + { + // Return of the Phantom DOS English + { + "phantom", + 0, + { + {"section1.hag", 0, "76e2d47a7aebafe48edc9884b3d91782", 1130939}, + AD_LISTEND + }, + Common::EN_ANY, + Common::kPlatformDOS, + ADGF_NO_FLAGS, + GUIO1(GUIO_NONE) + }, + GType_Phantom, + 0 + }, + + { + // Dragonsphere DOS English + { + "dragonsphere", + 0, + { + {"section1.hag", 0, "2770e441d296be5e806194693eebd95a", 2061199}, + AD_LISTEND + }, + Common::EN_ANY, + Common::kPlatformDOS, + ADGF_NO_FLAGS, + GUIO1(GUIO_NONE) + }, + GType_Dragonsphere, + 0 + }, + + { AD_TABLE_END_MARKER, 0, 0 } +}; + +} // End of namespace MADS diff --git a/engines/mads/dialogs.cpp b/engines/mads/dialogs.cpp new file mode 100644 index 0000000000..b1a0b53b5a --- /dev/null +++ b/engines/mads/dialogs.cpp @@ -0,0 +1,396 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "common/config-manager.h" +#include "mads/mads.h" +#include "mads/screen.h" +#include "mads/msurface.h" +#include "mads/nebular/dialogs_nebular.h" + +namespace MADS { + +Dialog::Dialog(MADSEngine *vm): _vm(vm), _savedSurface(nullptr), + _position(Common::Point(-1, -1)), _width(0), _height(0) { + TEXTDIALOG_CONTENT1 = 0XF8; + TEXTDIALOG_CONTENT2 = 0XF9; + TEXTDIALOG_EDGE = 0XFA; + TEXTDIALOG_BACKGROUND = 0XFB; + TEXTDIALOG_FC = 0XFC; + TEXTDIALOG_FD = 0XFD; + TEXTDIALOG_FE = 0XFE; + TEXTDIALOG_BLACK = 0; +} + +Dialog::~Dialog() { +} + +void Dialog::save() { + _savedSurface = new MSurface(_width, _height); + _vm->_screen.copyTo(_savedSurface, + Common::Rect(_position.x, _position.y, _position.x + _width, _position.y + _height), + Common::Point()); + + _vm->_screen.copyRectToScreen(getBounds()); +} + +void Dialog::restore() { + if (_savedSurface) { + _savedSurface->copyTo(&_vm->_screen, _position); + delete _savedSurface; + _savedSurface = nullptr; + + _vm->_screen.copyRectToScreen(getBounds()); + + Common::copy(&_dialogPalette[0], &_dialogPalette[8 * 3], + &_vm->_palette->_mainPalette[248 * 3]); + _vm->_palette->setPalette(_vm->_palette->_mainPalette, 248, 8); + } +} + +void Dialog::draw() { + // Calculate the dialog positioning + calculateBounds(); + + // Save the screen portion the dialog will overlap + save(); + + setDialogPalette(); + + // Draw the dialog + // Fill entire content of dialog + Common::Rect bounds = getBounds(); + _vm->_screen.fillRect(bounds, TEXTDIALOG_BACKGROUND); + + // Draw the outer edge lines + _vm->_screen.hLine(_position.x + 1, _position.y + _height - 2, + _position.x + _width - 2, TEXTDIALOG_EDGE); + _vm->_screen.hLine(_position.x, _position.y + _height - 1, + _position.x + _width - 1, TEXTDIALOG_EDGE); + _vm->_screen.vLine(_position.x + _width - 2, _position.y + 2, + _position.y + _height - 2, TEXTDIALOG_EDGE); + _vm->_screen.vLine(_position.x + _width - 1, _position.y + 1, + _position.y + _height - 1, TEXTDIALOG_EDGE); + + // Draw the gravelly dialog content + drawContent(Common::Rect(_position.x + 2, _position.y + 2, + _position.x + _width - 2, _position.y + _height - 2), 0, + TEXTDIALOG_CONTENT1, TEXTDIALOG_CONTENT2); +} + +void Dialog::setDialogPalette() { + // Save the high end of the palette, and set up the entries for dialog display + Common::copy(&_vm->_palette->_mainPalette[TEXTDIALOG_CONTENT1 * 3], + &_vm->_palette->_mainPalette[TEXTDIALOG_CONTENT1 * 3 + 8 * 3], + &_dialogPalette[0]); + Palette::setGradient(_vm->_palette->_mainPalette, TEXTDIALOG_CONTENT1, 2, 0x90, 0x80); + Palette::setGradient(_vm->_palette->_mainPalette, TEXTDIALOG_EDGE, 2, 0x9C, 0x70); + Palette::setGradient(_vm->_palette->_mainPalette, TEXTDIALOG_FC, 2, 0x90, 0x80); + Palette::setGradient(_vm->_palette->_mainPalette, TEXTDIALOG_FE, 1, 0xDC, 0xDC); + + _vm->_palette->setPalette(_vm->_palette->_mainPalette + (TEXTDIALOG_CONTENT1 * 3), + TEXTDIALOG_CONTENT1, 8); +} + +void Dialog::calculateBounds() { +} + +void Dialog::drawContent(const Common::Rect &r, int seed, byte color1, byte color2) { + uint16 currSeed = seed ? seed : 0xB78E; + + for (int yp = 0; yp < r.height(); ++yp) { + byte *destP = _vm->_screen.getBasePtr(r.left, r.top + yp); + + for (int xp = 0; xp < r.width(); ++xp) { + uint16 seedAdjust = currSeed; + currSeed += 0x181D; + seedAdjust = (seedAdjust >> 9) | ((seedAdjust & 0x1ff) << 7); + currSeed ^= seedAdjust; + seedAdjust = (seedAdjust >> 3) | ((seedAdjust & 7) << 13); + currSeed += seedAdjust; + + *destP++ = (currSeed & 0x10) ? color2 : color1; + } + } +} + +/*------------------------------------------------------------------------*/ + +TextDialog::TextDialog(MADSEngine *vm, const Common::String &fontName, + const Common::Point &pos, int maxChars): + Dialog(vm) { + _vm = vm; + _font = _vm->_font->getFont(fontName); + _position = pos; + + _vm->_font->setColors(TEXTDIALOG_BLACK, TEXTDIALOG_BLACK, TEXTDIALOG_BLACK, TEXTDIALOG_BLACK); + + _innerWidth = (_font->maxWidth() + 1) * maxChars; + _width = _innerWidth + 10; + _lineSize = maxChars * 2; + _lineWidth = 0; + _currentX = 0; + _numLines = 0; + Common::fill(&_lineXp[0], &_lineXp[TEXT_DIALOG_MAX_LINES], 0); + _askLineNum = -1; + _askXp = 0; +} + +TextDialog::~TextDialog() { +} + +void TextDialog::addLine(const Common::String &line, bool underline) { + if (_lineWidth > 0 || _currentX > 0) + incNumLines(); + + int stringWidth = _font->getWidth(line, 1); + if (stringWidth >= _innerWidth || (int)line.size() >= _lineSize) { + wordWrap(line); + } else { + _lineXp[_numLines] = (_innerWidth / 2) - (stringWidth / 2); + _lines[_numLines] = line; + + if (underline) + underlineLine(); + } + + incNumLines(); +} + +void TextDialog::underlineLine() { + _lineXp[_numLines] |= 0x80; +} + +void TextDialog::downPixelLine() { + _lineXp[_numLines] |= 0x40; +} + +void TextDialog::incNumLines() { + _lineWidth = 0; + _currentX = 0; + if (++_numLines == TEXT_DIALOG_MAX_LINES) + error("Exceeded text dialog line max"); +} + +void TextDialog::wordWrap(const Common::String &line) { + Common::String tempLine; + + if (!line.empty()) { + const char *srcP = line.c_str(); + + do { + tempLine = ""; + bool endWord = false; + bool newLine = false; + bool continueFlag = true; + + do { + if (!*srcP) { + continueFlag = false; + } else { + tempLine += *srcP; + + if (*srcP == 10) { + continueFlag = false; + newLine = true; + ++srcP; + tempLine.deleteLastChar(); + } else if (*srcP == ' ') { + ++srcP; + endWord = true; + } else if (!endWord) { + ++srcP; + } else { + tempLine.deleteLastChar(); + continueFlag = false; + } + } + } while (continueFlag); + + if (tempLine.hasSuffix(" ")) + tempLine.deleteLastChar(); + + Common::String tempLine2; + if (_currentX > 0) + tempLine2 += ' '; + tempLine2 += tempLine; + + int lineWidth = _font->getWidth(tempLine2, 1); + if (((_currentX + (int)tempLine2.size()) > _lineSize) || + ((_lineWidth + lineWidth) > _innerWidth)) { + incNumLines(); + appendLine(tempLine); + } else { + appendLine(tempLine2); + } + + if (newLine) + incNumLines(); + } while (*srcP); + } +} + +void TextDialog::appendLine(const Common::String &line) { + _currentX += line.size(); + _lineWidth += _font->getWidth(line, 1) + 1; + _lines[_numLines] += line; +} + +void TextDialog::addInput() { + _askXp = _currentX + 1; + _askLineNum = _numLines; + incNumLines(); +} + +void TextDialog::addBarLine() { + if (_lineWidth > 0 || _currentX > 0) + incNumLines(); + + _lineXp[_numLines] = 0xFF; + incNumLines(); +} + +void TextDialog::setLineXp(int xp) { + _lineXp[_numLines] = xp; +} + +void TextDialog::draw() { + if (!_lineWidth) + --_numLines; + + // Figure out the size and position for the dialog + calculateBounds(); + + // Draw the underlying dialog + Dialog::draw(); + + // Draw the text lines + int lineYp = _position.y + 5; + for (int lineNum = 0; lineNum <= _numLines; ++lineNum) { + if (_lineXp[lineNum] == -1) { + // Draw a line across the entire dialog + _vm->_screen.hLine(_position.x + 2, + lineYp + (_font->getHeight() + 1) / 2, + _position.x + _width - 4, TEXTDIALOG_BLACK); + } else { + // Draw a text line + int xp = (_lineXp[lineNum] & 0x7F) + _position.x + 5; + int yp = lineYp; + if (_lineXp[lineNum] & 0x40) + ++yp; + + _font->writeString(&_vm->_screen, _lines[lineNum], + Common::Point(xp, yp), 1); + + if (_lineXp[lineNum] & 0x80) { + // Draw an underline under the text + int lineWidth = _font->getWidth(_lines[lineNum], 1); + _vm->_screen.hLine(xp, yp + _font->getHeight(), xp + lineWidth, + TEXTDIALOG_BLACK); + } + } + + lineYp += _font->getHeight() + 1; + } + + _vm->_screen.copyRectToScreen(getBounds()); +} + +void TextDialog::calculateBounds() { + _height = (_font->getHeight() + 1) * (_numLines + 1) + 10; + if (_position.x == -1) + _position.x = 160 - (_width / 2); + if (_position.y == -1) + _position.y = 100 - (_height / 2); + + if ((_position.x + _width) > _vm->_screen.getWidth()) + _position.x = _vm->_screen.getWidth() - (_position.x + _width); + if ((_position.y + _height) > _vm->_screen.getHeight()) + _position.y = _vm->_screen.getHeight() - (_position.y + _height); +} + +void TextDialog::drawWithInput() { + //int innerWidth = _innerWidth; + //int lineHeight = _font->getHeight() + 1; + //int xp = _position.x + 5; + + // Draw the content of the dialog + drawContent(Common::Rect(_position.x + 2, _position.y + 2, + _position.x + _width - 2, _position.y + _height - 2), 0, + TEXTDIALOG_CONTENT1, TEXTDIALOG_CONTENT2); + + error("TODO: drawWithInput"); +} + +void TextDialog::show() { + // Draw the dialog + draw(); + _vm->_events->showCursor(); + + // Wait for mouse click + do { + _vm->_events->waitForNextFrame(); + } while (!_vm->shouldQuit() && !_vm->_events->isKeyPressed() && !_vm->_events->_mouseReleased); + + // Allow the mouse release or keypress to be gobbled up + if (!_vm->shouldQuit()) { + _vm->_events->waitForNextFrame(); + _vm->_events->_pendingKeys.clear(); + } + + // Restore the background + restore(); +} + +/*------------------------------------------------------------------------*/ + +MessageDialog::MessageDialog(MADSEngine *vm, int maxChars, ...): + TextDialog(vm, FONT_INTERFACE, Common::Point(-1, -1), maxChars) { + // Add in passed line list + va_list va; + va_start(va, maxChars); + + const char *line = va_arg(va, const char *); + while (line) { + addLine(line); + line = va_arg(va, const char *); + } + va_end(va); +} + +/*------------------------------------------------------------------------*/ + +Dialogs *Dialogs::init(MADSEngine *vm) { + if (vm->getGameID() == GType_RexNebular) + return new Nebular::DialogsNebular(vm); + + // Throw a warning for now, since the associated Dialogs class isn't implemented yet + warning("Dialogs: Unknown game"); + // HACK: Reuse the implemented Nebular dialogs for now, to avoid crashing later on + return new Nebular::DialogsNebular(vm); +} + +Dialogs::Dialogs(MADSEngine *vm): _vm(vm) { + _pendingDialog = DIALOG_NONE; +} + +} // End of namespace MADS diff --git a/engines/mads/dialogs.h b/engines/mads/dialogs.h new file mode 100644 index 0000000000..6de6ea71c1 --- /dev/null +++ b/engines/mads/dialogs.h @@ -0,0 +1,229 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_DIALOGS_H +#define MADS_DIALOGS_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/font.h" +#include "mads/msurface.h" + +namespace MADS { + +class Dialog { +private: + void setDialogPalette(); +protected: + MADSEngine *_vm; + MSurface *_savedSurface; + Common::Point _position; + int _width; + int _height; + byte _dialogPalette[8 * 3]; + + int TEXTDIALOG_CONTENT1; + int TEXTDIALOG_CONTENT2; + int TEXTDIALOG_EDGE; + int TEXTDIALOG_BACKGROUND; + int TEXTDIALOG_FC; + int TEXTDIALOG_FD; + int TEXTDIALOG_FE; + int TEXTDIALOG_BLACK; +protected: + /** + * Draw the dialog + */ + virtual void draw(); + + /** + * Calculate bounds for the dialog + */ + virtual void calculateBounds(); + + /** + * Save the section of the passed surface the dialog will cover. + */ + virtual void save(); + + /** + * Restore saved dialog surface + */ + virtual void restore(); + + /** + * Draws the content of a dialog with a gravelly alternating color. + */ + void drawContent(const Common::Rect &r, int seed, byte color1, byte color2); +public: + /** + * Constructor + */ + Dialog(MADSEngine *vm); + + /** + * Destructor + */ + virtual ~Dialog(); + + /** + * Return the bounds of the dialog. + */ + Common::Rect getBounds() const { + return Common::Rect(_position.x, _position.y, + _position.x + _width, _position.y + _height); + } +}; + +#define TEXT_DIALOG_MAX_LINES 20 + +class TextDialog: protected Dialog { +private: + /** + * Append text to the currently end line. + */ + void appendLine(const Common::String &line); + + /** + * Clean up after finishing displaying the dialog + */ + void restorePalette(); +protected: + Font *_font; + int _innerWidth; + int _lineWidth; + int _currentX; + int _numLines; + int _lineSize; + int _askXp; + int _askLineNum; + Common::String _lines[TEXT_DIALOG_MAX_LINES]; + int _lineXp[TEXT_DIALOG_MAX_LINES]; + + /** + * Calculate the bounds for the dialog + */ + virtual void calculateBounds(); +public: + /** + * Constructor + * @param vm Engine reference + * @param fontName Font to use for display + * @param pos Position for window top-left + * @param maxChars Horizontal width of window in characters + */ + TextDialog(MADSEngine *vm, const Common::String &fontName, const Common::Point &pos, + int maxChars); + + /** + * Destructor + */ + virtual ~TextDialog(); + + /** + * Draw the dialog + */ + virtual void draw(); + + /** + * Draw the dialog along with any input box + */ + void drawWithInput(); + + /** + * Add a new line to the dialog + */ + void addLine(const Common::String &line, bool underline = false); + + /** + * Adds one or more lines, word wrapping the passed text + */ + void wordWrap(const Common::String &line); + + /** + * Increments the number of text lines the text dialog uses + */ + void incNumLines(); + + /** + * Adds an input area following previously added text + */ + void addInput(); + + /** + * Adds a bar line to separate sections of text + */ + void addBarLine(); + + /** + * Flags the previously added line to be underlined + */ + void underlineLine(); + + void downPixelLine(); + + /** + * Set the x position for the given line + */ + void setLineXp(int xp); + + /** + * Show the dialog, and wait until a key or mouse press. + */ + virtual void show(); +}; + +class MessageDialog: public TextDialog { +public: + MessageDialog(MADSEngine *vm, int lines, ...); + + virtual ~MessageDialog() {} +}; + +enum DialogId { + DIALOG_NONE = 0, DIALOG_GAME_MENU = 1, DIALOG_SAVE = 2, DIALOG_RESTORE = 3, + DIALOG_OPTIONS = 4, DIALOG_DIFFICULTY = 5, DIALOG_ERROR = 6 +}; + +class Dialogs { +protected: + MADSEngine *_vm; + + Dialogs(MADSEngine *vm); +public: + static Dialogs *init(MADSEngine *vm); +public: + Common::Point _defaultPosition; + DialogId _pendingDialog; + int _indexList[10]; + + virtual ~Dialogs() {} + + virtual void showDialog() = 0; + virtual void showItem(int objectId, int messageId, int speech = 0) = 0; + virtual Common::String getVocab(int vocabId) = 0; + virtual bool show(int messageId, int objectId = -1) = 0; +}; + +} // End of namespace MADS + +#endif /* MADS_DIALOGS_H */ diff --git a/engines/mads/dragonsphere/dragonsphere_scenes.cpp b/engines/mads/dragonsphere/dragonsphere_scenes.cpp new file mode 100644 index 0000000000..40c9a89f44 --- /dev/null +++ b/engines/mads/dragonsphere/dragonsphere_scenes.cpp @@ -0,0 +1,239 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "common/config-manager.h" +#include "mads/mads.h" +#include "mads/compression.h" +#include "mads/resources.h" +#include "mads/scene.h" +#include "mads/dragonsphere/game_dragonsphere.h" +#include "mads/dragonsphere/dragonsphere_scenes.h" + +namespace MADS { + +namespace Dragonsphere { + +SceneLogic *SceneFactory::createScene(MADSEngine *vm) { + Scene &scene = vm->_game->_scene; + + // TODO + //scene.addActiveVocab(NOUN_DROP); + + // TODO: Just return a dummy scene for now + return new DummyScene(vm); + + switch (scene._nextSceneId) { + // Scene group #1 (Castle, river and caves) + case 101: // king's bedroom + return new DummyScene(vm); // TODO + case 102: // queen's bedroom + return new DummyScene(vm); // TODO + case 103: // outside king's bedroom + return new DummyScene(vm); // TODO + case 104: // fireplace / bookshelf + return new DummyScene(vm); // TODO + case 105: // dining room + return new DummyScene(vm); // TODO + case 106: // throne room + return new DummyScene(vm); // TODO + case 107: // council chamber + return new DummyScene(vm); // TODO + case 108: // dungeon, cell entrance + return new DummyScene(vm); // TODO + case 109: // cell + return new DummyScene(vm); // TODO + case 110: // outside castle, merchants and well + return new DummyScene(vm); // TODO + case 111: // Dragonsphere closeup + return new DummyScene(vm); // TODO + case 112: // well descend + return new DummyScene(vm); // TODO + case 113: // bottom of well, river and trap door + return new DummyScene(vm); // TODO + case 114: // cave + return new DummyScene(vm); // TODO + case 115: // cave with passageway to west + return new DummyScene(vm); // TODO + case 116: // cave with pedestral + return new DummyScene(vm); // TODO + case 117: // river + return new DummyScene(vm); // TODO + case 118: // castle courtyard and gate + return new DummyScene(vm); // TODO + case 119: // castle stairs + return new DummyScene(vm); // TODO + case 120: // map + return new DummyScene(vm); // TODO + + // Scene group #2 (Slathan ni Patan, land of shapeshifters) + case 201: // guardhouse, entrance to Slathan ni Patan + return new DummyScene(vm); // TODO + case 203: // forest + return new DummyScene(vm); // TODO + case 204: // cave + return new DummyScene(vm); // TODO + case 205: // outside village + return new DummyScene(vm); // TODO + case 206: // village + return new DummyScene(vm); // TODO + + // Scene group #3 (Brynn-Fann, Land of faeries) + case 301: // maze entrance + return new DummyScene(vm); // TODO + case 302: // maze + return new DummyScene(vm); // TODO + case 303: // toads + return new DummyScene(vm); // TODO + + // Scene group #4 (The Desert) + case 401: // desert + return new DummyScene(vm); // TODO + case 402: // desert + return new DummyScene(vm); // TODO + case 403: // desert + return new DummyScene(vm); // TODO + case 404: // desert with dunes + return new DummyScene(vm); // TODO + case 405: // oasis + return new DummyScene(vm); // TODO + case 406: // inside tent + return new DummyScene(vm); // TODO + case 407: // gem sack closeup + return new DummyScene(vm); // TODO + case 408: // spirit plane + return new DummyScene(vm); // TODO + case 409: // spirit plane top down view, disks + return new DummyScene(vm); // TODO + case 410: // snake pit and spirit tree + return new DummyScene(vm); // TODO + case 411: // nest + return new DummyScene(vm); // TODO + case 412: // desert + return new DummyScene(vm); // TODO + case 454: // cutscene + return new DummyScene(vm); // TODO + + // Scene group #5 (The Mountain) + case 501: // base of mountain / wall + return new DummyScene(vm); // TODO + case 502: // base of mountain + return new DummyScene(vm); // TODO + case 503: // waterfall + return new DummyScene(vm); // TODO + case 504: // hermit's cave + return new DummyScene(vm); // TODO + case 505: // rock trees + return new DummyScene(vm); // TODO + case 506: // nest + return new DummyScene(vm); // TODO + case 507: // above nest + return new DummyScene(vm); // TODO + case 508: // ledge, right + return new DummyScene(vm); // TODO + case 509: // ledge, left + return new DummyScene(vm); // TODO + case 510: // nest top down view and pillars + return new DummyScene(vm); // TODO + case 511: // pillars + return new DummyScene(vm); // TODO + case 512: // nest + return new DummyScene(vm); // TODO + case 557: // cutscene + return new DummyScene(vm); // TODO + + // Scene group #6 (The Tower) + case 601: // ??? (tile count mismatch) + return new DummyScene(vm); // TODO + case 603: // eye chamber + return new DummyScene(vm); // TODO + case 604: // room of magic + return new DummyScene(vm); // TODO + case 605: // science room + return new DummyScene(vm); // TODO + case 606: // doorway + return new DummyScene(vm); // TODO + case 607: // prison + return new DummyScene(vm); // TODO + case 609: // stone pedestral chamber + return new DummyScene(vm); // TODO + case 612: // infernal machine room + return new DummyScene(vm); // TODO + case 613: // room with lava floor + return new DummyScene(vm); // TODO + case 614: // sorcerer's room + return new DummyScene(vm); // TODO + + default: + error("Invalid scene %d called", scene._nextSceneId); + } +} + +/*------------------------------------------------------------------------*/ + +DragonsphereScene::DragonsphereScene(MADSEngine *vm) : SceneLogic(vm), + _globals(static_cast<GameDragonsphere *>(vm->_game)->_globals), + _game(*static_cast<GameDragonsphere *>(vm->_game)), + _action(vm->_game->_scene._action) { +} + +Common::String DragonsphereScene::formAnimName(char sepChar, int suffixNum) { + return Resources::formatName(_scene->_currentSceneId, sepChar, suffixNum, + EXT_NONE, ""); +} + +/*------------------------------------------------------------------------*/ + +void SceneInfoDragonsphere::loadCodes(MSurface &depthSurface, int variant) { + File f(Resources::formatName(RESPREFIX_RM, _sceneId, ".DAT")); + MadsPack codesPack(&f); + Common::SeekableReadStream *stream = codesPack.getItemStream(variant + 1); + + loadCodes(depthSurface, stream); + + delete stream; + f.close(); +} + +void SceneInfoDragonsphere::loadCodes(MSurface &depthSurface, Common::SeekableReadStream *stream) { + byte *destP = depthSurface.getData(); + byte *endP = depthSurface.getBasePtr(0, depthSurface.h); + + byte runLength = stream->readByte(); + while (destP < endP && runLength > 0) { + byte runValue = stream->readByte(); + + // Write out the run length + Common::fill(destP, destP + runLength, runValue); + destP += runLength; + + // Get the next run length + runLength = stream->readByte(); + } + + if (destP < endP) + Common::fill(destP, endP, 0); +} + +} // End of namespace Dragonsphere + +} // End of namespace MADS diff --git a/engines/mads/dragonsphere/dragonsphere_scenes.h b/engines/mads/dragonsphere/dragonsphere_scenes.h new file mode 100644 index 0000000000..2d23381d25 --- /dev/null +++ b/engines/mads/dragonsphere/dragonsphere_scenes.h @@ -0,0 +1,695 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_DRAGONSPHERE_SCENES_H +#define MADS_DRAGONSPHERE_SCENES_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/scene.h" +#include "mads/dragonsphere/game_dragonsphere.h" +//#include "mads/dragonsphere/globals_dragonsphere.h" + + +namespace MADS { + +namespace Dragonsphere { + +enum Noun { + NOUN_GAME = 0x1, + NOUN_QSAVE = 0x2, + NOUN_LOOK = 0x3, + NOUN_TAKE = 0x4, + NOUN_PUSH = 0x5, + NOUN_OPEN = 0x6, + NOUN_PUT = 0x7, + NOUN_TALK_TO = 0x8, + NOUN_GIVE = 0x9, + NOUN_PULL = 0xA, + NOUN_CLOSE = 0xB, + NOUN_THROW = 0xC, + NOUN_WALK_TO = 0xD, + NOUN_NOTHING = 0xE, + NOUN_ = 0xF, + NOUN_FLOOR = 0x10, + NOUN_WALK_ACROSS = 0x11, + NOUN_RUG = 0x12, + NOUN_CARPET = 0x13, + NOUN_WALL = 0x14, + NOUN_BED = 0x15, + NOUN_PILLOW = 0x16, + NOUN_CHEST = 0x17, + NOUN_WINDOW = 0x18, + NOUN_NIGHTSTAND = 0x19, + NOUN_TAPESTRY = 0x1A, + NOUN_DRESSING_SCREEN = 0x1B, + NOUN_WALK_BEHIND = 0x1C, + NOUN_ROYAL_CREST = 0x1D, + NOUN_LOOK_AT = 0x1E, + NOUN_WASHBASIN = 0x1F, + NOUN_WASH_AT = 0x20, + NOUN_BOOK = 0x21, + NOUN_FIREPLACE = 0x22, + NOUN_FIREPLACE_SCREEN = 0x23, + NOUN_DOOR_TO_QUEENS_ROOM = 0x24, + NOUN_WALK_THROUGH = 0x25, + NOUN_HALL_TO_SOUTH = 0x26, + NOUN_WALK_INTO = 0x27, + NOUN_WALL_PLAQUE = 0x28, + NOUN_DECORATION = 0x29, + NOUN_SWORDS = 0x2A, + NOUN_WALL_SCONCE = 0x2B, + NOUN_BUST_ON_WALL = 0x2C, + NOUN_WALL_ARCH = 0x2D, + NOUN_SIGNET_RING = 0x2E, + NOUN_INVOKE = 0x2F, + NOUN_POLISH = 0x30, + NOUN_GANGBANG = 0x31, + NOUN_BIRD_FIGURINE = 0x32, + NOUN_RUB = 0x33, + NOUN_BIRDCALL = 0x34, + NOUN_USE = 0x35, + NOUN_MAKE_NOISE = 0x36, + NOUN_SHIELDSTONE = 0x37, + NOUN_SWORD = 0x38, + NOUN_ATTACK = 0x39, + NOUN_CARVE_UP = 0x3A, + NOUN_GOBLET = 0x3B, + NOUN_FILL = 0x3C, + NOUN_DRINK_FROM = 0x3D, + NOUN_BONE = 0x3E, + NOUN_GNAW = 0x3F, + NOUN_FRUIT = 0x40, + NOUN_EAT = 0x41, + NOUN_DOLL = 0x42, + NOUN_PLAY_WITH = 0x43, + NOUN_HEAL = 0x44, + NOUN_HEAL_THYSELF = 0x45, + NOUN_HEAL_SELF = 0x46, + NOUN_POLYSTONE = 0x47, + NOUN_MIMIC = 0x48, + NOUN_RED_POWERSTONE = 0x49, + NOUN_YELLOW_POWERSTONE = 0x4A, + NOUN_BLUE_POWERSTONE = 0x4B, + NOUN_KEY_CROWN = 0x4C, + NOUN_WEAR = 0x4D, + NOUN_DATES = 0x4E, + NOUN_STATUE = 0x4F, + NOUN_BOTTLE_OF_FLIES = 0x50, + NOUN_LISTEN_TO = 0x51, + NOUN_SOUL_EGG = 0x52, + NOUN_BREAK = 0x53, + NOUN_MAGIC_BELT = 0x54, + NOUN_ADJUST = 0x55, + NOUN_AMULET = 0x56, + NOUN_THRUST = 0x57, + NOUN_MUD = 0x58, + NOUN_FEEL = 0x59, + NOUN_TASTE = 0x5A, + NOUN_FEATHERS = 0x5B, + NOUN_TICKLE = 0x5C, + NOUN_TORCH = 0x5D, + NOUN_WAVE = 0x5E, + NOUN_FLASK = 0x5F, + NOUN_FLASK_FULL_OF_ACID = 0x60, + NOUN_POUR_CONTENTS = 0x61, + NOUN_POUR = 0x62, + NOUN_POUR_CONTENTS_OF = 0x63, + NOUN_DRINK = 0x64, + NOUN_ROPE = 0x65, + NOUN_TIE = 0x66, + NOUN_POWER_VACUUM_STONE = 0x67, + NOUN_TAKE_MAGIC_FROM = 0x68, + NOUN_DEAD_RAT = 0x69, + NOUN_PET = 0x6A, + NOUN_MAP = 0x6B, + NOUN_FOLD = 0x6C, + NOUN_CRYSTAL_BALL = 0x6D, + NOUN_GAZE_INTO = 0x6E, + NOUN_INVOKE_POWER_OF = 0x6F, + NOUN_BLACK_SPHERE = 0x70, + NOUN_SOPTUS_SOPORIFIC = 0x71, + NOUN_SHIFTER_RING = 0x72, + NOUN_SHIFT_SELF = 0x73, + NOUN_SHIFT_INTO_BEAR = 0x74, + NOUN_SHIFT_INTO_SEAL = 0x75, + NOUN_SHIFT_INTO_SNAKE = 0x76, + NOUN_REVERT = 0x77, + NOUN_MEDICINE_BUNDLE = 0x78, + NOUN_SHAKE = 0x79, + NOUN_PARTLY_BUILT_BUNDLE = 0x7A, + NOUN_RATSICLE = 0x7B, + NOUN_LICK = 0x7C, + NOUN_TENTACLE_PARTS = 0x7D, + NOUN_CHEW = 0x7E, + NOUN_TELEPORT_DOOR = 0x7F, + NOUN_UNROLL = 0x80, + NOUN_RARE_COIN = 0x81, + NOUN_ADMIRE = 0x82, + NOUN_CRYSTAL_FLOWER = 0x83, + NOUN_DIAMOND_DUST = 0x84, + NOUN_RUBY_RING = 0x85, + NOUN_GOLD_NUGGET = 0x86, + NOUN_MAGIC_MUSIC_BOX = 0x87, + NOUN_EMERALD = 0x88, + NOUN_PIECE_OF_PAPER = 0x89, + NOUN_SPEAK_WORDS_ON = 0x8A, + NOUN_VORTEX_STONE = 0x8B, + NOUN_RUG2 = 0x8C, + NOUN_FIREPLACE_SCREEN2 = 0x8D, + NOUN_BUST_ON_WALL2 = 0x8E, + NOUN_LOOK_AT2 = 0x8F, + NOUN_DRAGON = 0x90, + NOUN_DRAGONSPHERE = 0x91, + NOUN_TOUCH = 0x92, + NOUN_THRONE_ROOM = 0x93, + NOUN_RETURN_TO = 0x94, + NOUN_CAVE = 0x95, + NOUN_PASSAGEWAY_TO_WEST = 0x96, + NOUN_PASSAGEWAY_TO_EAST = 0x97, + NOUN_CAVE_FLOOR = 0x98, + NOUN_STONE_COLUMN = 0x99, + NOUN_ABYSS = 0x9A, + NOUN_LOOK_INTO = 0x9B, + NOUN_CASTLE = 0x9C, + NOUN_CASTLE_GATE = 0x9D, + NOUN_GROUND = 0x9E, + NOUN_BARREL = 0x9F, + NOUN_BARRELS = 0xA0, + NOUN_HAYSTACK = 0xA1, + NOUN_ROOT_THROUGH = 0xA2, + NOUN_BATTLEMENTS = 0xA3, + NOUN_GATE_TO_THRONE_ROOM = 0xA4, + NOUN_CASTLE_WALL = 0xA5, + NOUN_DOOR = 0xA6, + NOUN_WALL_SWITCH = 0xA7, + NOUN_STAIRS = 0xA8, + NOUN_WALK_DOWN = 0xA9, + NOUN_EDGE_OF_ABYSS = 0xAA, + NOUN_COURTYARD = 0xAB, + NOUN_ROCK = 0xAC, + NOUN_CAVE_CEILING = 0xAD, + NOUN_CAVE_WALL = 0xAE, + NOUN_BRAZIER = 0xAF, + NOUN_DOOR_TO_THRONE_ROOM = 0xB0, + NOUN_GO_THROUGH = 0xB1, + NOUN_DINING_TABLE = 0xB2, + NOUN_ACTIVATE = 0xB3, + NOUN_BATTLEMENT = 0xB4, + NOUN_DOOR_TO_GAURDROOM = 0xB5, + NOUN_DUNGEON_FLOOR = 0xB6, + NOUN_DUNGEON_WALLS = 0xB7, + NOUN_DUNGEON_CEILING = 0xB8, + NOUN_BEDDING = 0xB9, + NOUN_FLOOR_GRATE = 0xBA, + NOUN_MANACLES = 0xBB, + NOUN_CALENDAR = 0xBC, + NOUN_DOOR_TO_GUARDROOM = 0xBD, + NOUN_DOOR_TO_COUNCIL_ROOM = 0xBE, + NOUN_GUARD_STATION = 0xBF, + NOUN_DOOR_TO_DUNGEON_CELL = 0xC0, + NOUN_DOORWAY_TO_CELL = 0xC1, + NOUN_DUNGEON_DOOR = 0xC2, + NOUN_DUNGEON_WALL = 0xC3, + NOUN_CEILING = 0xC4, + NOUN_DOOR_TO_HALLWAY = 0xC5, + NOUN_TABLE = 0xC6, + NOUN_BOOKSHELF = 0xC7, + NOUN_TROPHY = 0xC8, + NOUN_READING_BENCH = 0xC9, + NOUN_CHAIR = 0xCA, + NOUN_LOVESEAT = 0xCB, + NOUN_WOOD_BASKET = 0xCC, + NOUN_STOOL = 0xCD, + NOUN_GUARD_STOOL = 0xCE, + NOUN_ROCKS = 0xCF, + NOUN_DIVIDING_WALL = 0xD0, + NOUN_ARCHWAY = 0xD1, + NOUN_MARKET_GROUNDS = 0xD2, + NOUN_HEDGE = 0xD3, + NOUN_SKY = 0xD4, + NOUN_PLAINS = 0xD5, + NOUN_FIELDS = 0xD6, + NOUN_GATE_TO_COURTYARD = 0xD7, + NOUN_ROAD_TO_EAST = 0xD8, + NOUN_TREES = 0xD9, + NOUN_CLOUDS = 0xDA, + NOUN_MERCHANTS_STALL = 0xDB, + NOUN_WELL = 0xDC, + NOUN_DOWN_WELL = 0xDD, + NOUN_GO = 0xDE, + NOUN_GO_DOWN = 0xDF, + NOUN_CRANK = 0xE0, + NOUN_BUCKET = 0xE1, + NOUN_JUMP_DOWN = 0xE2, + NOUN_WALLS = 0xE3, + NOUN_DOORWAY_TO_SOUTH = 0xE4, + NOUN_PEDESTAL = 0xE5, + NOUN_DOOR_TO_NORTH = 0xE6, + NOUN_PAINTING = 0xE7, + NOUN_DOCUMENT = 0xE8, + NOUN_INK_BOTTLE = 0xE9, + NOUN_QUILL_PEN = 0xEA, + NOUN_CHANDELIER = 0xEB, + NOUN_COUNCIL_TABLE = 0xEC, + NOUN_CANDLESTICK = 0xED, + NOUN_DESK = 0xEE, + NOUN_TURN = 0xEF, + NOUN_POLE = 0xF0, + NOUN_THE_SCENE = 0xF1, + NOUN_LEAVE = 0xF2, + NOUN_END_TABLE = 0xF3, + NOUN_BATTLE_AXES = 0xF4, + NOUN_DOOR_TO_KINGS_ROOM = 0xF5, + NOUN_COAT_OF_ARMS = 0xF6, + NOUN_LARGE_WINDOW = 0xF7, + NOUN_SMALL_WINDOW = 0xF8, + NOUN_DOOR_TO_MEETING_ROOM = 0xF9, + NOUN_DOOR_TO_BALLROOM = 0xFA, + NOUN_FLOWERS = 0xFB, + NOUN_SHUTTERS = 0xFC, + NOUN_BOOKCASE = 0xFD, + NOUN_DOOR_TO_COURTYARD = 0xFE, + NOUN_PLATFORM = 0xFF, + NOUN_STEP = 0x100, + NOUN_RED_CARPET = 0x101, + NOUN_KINGS_THRONE = 0x102, + NOUN_SIT_IN = 0x103, + NOUN_QUEENS_THRONE = 0x104, + NOUN_TRAPDOOR = 0x105, + NOUN_GRATE = 0x106, + NOUN_RIVER = 0x107, + NOUN_DIARIES = 0x108, + NOUN_SWIM_DOWN = 0x109, + NOUN_SCULLERY_MAID = 0x10A, + NOUN_DOORWAY_TO_DUNGEON = 0x10B, + NOUN_WARD = 0x10C, + NOUN_DARKNESS_BEAST = 0x10D, + NOUN_BEAST = 0x10E, + NOUN_PUT_MAGIC_INTO = 0x10F, + NOUN_GUARD = 0x110, + NOUN_CROWN = 0x111, + NOUN_BOOKS = 0x112, + NOUN_SECRET_DOOR = 0x113, + NOUN_WALL_PANEL = 0x114, + NOUN_DOORWAY = 0x115, + NOUN_FAERIE = 0x116, + NOUN_SOPTUS_ECLIPTUS = 0x117, + NOUN_GUARD_CAPTAIN = 0x118, + NOUN_MERCHANT = 0x119, + NOUN_SHAPECHANGER = 0x11A, + NOUN_RED_STONE = 0x11B, + NOUN_YELLOW_STONE = 0x11C, + NOUN_BLUE_STONE = 0x11D, + NOUN_FLIES = 0x11E, + NOUN_FLASK_OF_ACID = 0x11F, + NOUN_PARTIAL_BUNDLE = 0x120, + NOUN_SOPORIFIC = 0x121, + NOUN_PARCHMENT = 0x122, + NOUN_KING = 0x123, + NOUN_MACMORN = 0x124, + NOUN_MOUNTAINSIDE = 0x125, + NOUN_PATH_TO_SOUTH = 0x126, + NOUN_ROUGH_STONE = 0x127, + NOUN_CLIMB_UP = 0x128, + NOUN_LARGE_ROCK = 0x129, + NOUN_SMALL_ROCK = 0x12A, + NOUN_PATH_TO_WEST = 0x12B, + NOUN_CAVE_ENTRANCE = 0x12C, + NOUN_PALLET = 0x12D, + NOUN_BLANKET = 0x12E, + NOUN_FIREPIT = 0x12F, + NOUN_FLAT_STONE = 0x130, + NOUN_MOVE = 0x131, + NOUN_SPIRIT_BUNDLE = 0x132, + NOUN_TRAIL_LEADING_UP = 0x133, + NOUN_FOLLOW = 0x134, + NOUN_TRAIL_LEADING_DOWN = 0x135, + NOUN_NEST = 0x136, + NOUN_REACH_IN = 0x137, + NOUN_TRAIL_LEADING_WEST = 0x138, + NOUN_PATH_TO_EAST = 0x139, + NOUN_WATERFALL = 0x13A, + NOUN_PUDDLE = 0x13B, + NOUN_EDGE_OF_CLIFF = 0x13C, + NOUN_LEDGE = 0x13D, + NOUN_CLIMB_DOWN = 0x13E, + NOUN_LANDING = 0x13F, + NOUN_BOULDERS = 0x140, + NOUN_ROCK_TUMBLE = 0x141, + NOUN_ROCK_TREE = 0x142, + NOUN_PILLAR = 0x143, + NOUN_JUMP_TO = 0x144, + NOUN_CLIFF = 0x145, + NOUN_PILLARS = 0x146, + NOUN_SPECIAL_ROCK = 0x147, + NOUN_GAZE_UPON = 0x148, + NOUN_SCONCE = 0x149, + NOUN_LADDER = 0x14A, + NOUN_STAIRWAY = 0x14B, + NOUN_MECHANISM = 0x14C, + NOUN_SPEARHEADS = 0x14D, + NOUN_TRAP_DOOR = 0x14E, + NOUN_SWIM = 0x14F, + NOUN_DOWN_RIVER = 0x150, + NOUN_SWIM_UP = 0x151, + NOUN_UP_RIVER = 0x152, + NOUN_SHORE = 0x153, + NOUN_SWIM_TO = 0x154, + NOUN_SWIM_TOWARDS = 0x155, + NOUN_KING_CALLASH = 0x156, + NOUN_KINGS_THRONE2 = 0x157, + NOUN_KING2 = 0x158, + NOUN_GROTTO = 0x159, + NOUN_CLIMB_THROUGH = 0x15A, + NOUN_QUEEN_MOTHER = 0x15B, + NOUN_MACMORN2 = 0x15C, + NOUN_SMALL_LEDGE = 0x15D, + NOUN_MACMORN3 = 0x15E, + NOUN_TO_110 = 0x15F, + NOUN_TO_KITTY_HEAVEN = 0x160, + NOUN_KITTY_HEAVEN = 0x161, + NOUN_ROOM_110 = 0x162, + NOUN_LLANIE = 0x163, + NOUN_CW = 0x164, + NOUN_HERMIT = 0x165, + NOUN_TROU = 0x166, + NOUN_SHAK = 0x167, + NOUN_ROOM_501 = 0x168, + NOUN_MOON = 0x169, + NOUN_UFO = 0x16A, + NOUN_SIT_ON = 0x16B, + NOUN_STRANGER = 0x16C, + NOUN_TOWER_DOOR = 0x16D, + NOUN_DOOR_TO_EAST = 0x16E, + NOUN_DOOR_TO_WEST = 0x16F, + NOUN_EYE = 0x170, + NOUN_DOORWAY_TO_EAST = 0x171, + NOUN_DOORWAY_TO_WEST = 0x172, + NOUN_SKULL = 0x173, + NOUN_DOOR_TO_MAGIC_ROOM = 0x174, + NOUN_ANCIENT_BARREL = 0x175, + NOUN_COBWEBS = 0x176, + NOUN_SHELF = 0x177, + NOUN_MUSTY_CHART = 0x178, + NOUN_LAB_TABLE = 0x179, + NOUN_PETCOCK = 0x17A, + NOUN_NOZZLE = 0x17B, + NOUN_TUBING = 0x17C, + NOUN_BEAKER = 0x17D, + NOUN_FLAME = 0x17E, + NOUN_METAL_PLATE = 0x17F, + NOUN_SHAFT_OF_LIGHT = 0x180, + NOUN_CABINET = 0x181, + NOUN_BALANCE = 0x182, + NOUN_CAGE = 0x183, + NOUN_FREEZER = 0x184, + NOUN_CONTENTS_OF_FREEZER = 0x185, + NOUN_CAGE_WITH_RATS = 0x186, + NOUN_DOOR_TO_SOUTH = 0x187, + NOUN_TRAIL_OF_GREEN_SLIME = 0x188, + NOUN_NECK_LOCK = 0x189, + NOUN_BENCH = 0x18A, + NOUN_SKELETON = 0x18B, + NOUN_LEG_CLAMPS = 0x18C, + NOUN_LEG_LOCK = 0x18D, + NOUN_WAIST_LOCK = 0x18E, + NOUN_NER_TOM = 0x18F, + NOUN_BELT = 0x190, + NOUN_JUMP_INTO = 0x191, + NOUN_CLOSET = 0x192, + NOUN_DOOR_TO_EYE_CHAMBER = 0x193, + NOUN_DRESSER = 0x194, + NOUN_SCROLL = 0x195, + NOUN_WITCH_PARAPHERNALIA = 0x196, + NOUN_SHELVES = 0x197, + NOUN_MAGIC_TOMES = 0x198, + NOUN_MAGIC_PARAPHERNALIA = 0x199, + NOUN_BOOK_OF_MAGIC = 0x19A, + NOUN_HOURGLASS = 0x19B, + NOUN_STONE_SPHERE = 0x19C, + NOUN_SHADOW_OF_WINDOW = 0x19D, + NOUN_MUSIC_BOX = 0x19E, + NOUN_LARGE_SPIDER_WEB = 0x19F, + NOUN_INFERNAL_MACHINE = 0x1A0, + NOUN_WATER_SOURCE = 0x1A1, + NOUN_FLOW_OF_WATER = 0x1A2, + NOUN_RETORT = 0x1A3, + NOUN_DOORWAY_TO_CORRIDOR = 0x1A4, + NOUN_TELESCOPE = 0x1A5, + NOUN_STRANGE_MAP = 0x1A6, + NOUN_CIRCLE_OF_SPHERES = 0x1A7, + NOUN_STONE_BED = 0x1A8, + NOUN_DRAGON_SCULPTURE = 0x1A9, + NOUN_RAT = 0x1AA, + NOUN_RAT_CAGE = 0x1AB, + NOUN_DOWN_BUTTON = 0x1AC, + NOUN_DOOR_TO_MACHINE_ROOM = 0x1AD, + NOUN_STRANGE_PORTAL = 0x1AE, + NOUN_DOOR_FRAME = 0x1AF, + NOUN_ELEVATOR_HOLE = 0x1B0, + NOUN_UP_BUTTON = 0x1B1, + NOUN_DOORWAY_TO_DARK_ROOM = 0x1B2, + NOUN_BIG_SKULL = 0x1B3, + NOUN_ELEVATOR_PLATFORM = 0x1B4, + NOUN_BUTTON = 0x1B5, + NOUN_TOP_BUTTON = 0x1B6, + NOUN_BOTTOM_BUTTON = 0x1B7, + NOUN_TELEPORTAL = 0x1B8, + NOUN_EYE_CHAMBER_DOORWAY = 0x1B9, + NOUN_MACHINE_ROOM_DOORWAY = 0x1BA, + NOUN_GLOWING_FLOOR = 0x1BB, + NOUN_BRYNN_FANN = 0x1BC, + NOUN_GRAN_CALLAHACH = 0x1BD, + NOUN_SLATHAN_NI_PATAN = 0x1BE, + NOUN_HIGHTOWER = 0x1BF, + NOUN_SOPTUS_ECLIPTUS2 = 0x1C0, + NOUN_TOWER = 0x1C1, + NOUN_MOUNTAIN_PATH = 0x1C2, + NOUN_PATH_BEHIND_TOWER = 0x1C3, + NOUN_VINES = 0x1C4, + NOUN_SLATHAN_NI_PATAN2 = 0x1C5, + NOUN_SICK = 0x1C6, + NOUN_PATH_AROUND_TOWER = 0x1C7, + NOUN_PATH_TO_HIGHTOWER = 0x1C8, + NOUN_SPIRIT_PLANE = 0x1C9, + NOUN_SPIRIT_TREE = 0x1CA, + NOUN_WALK = 0x1CB, + NOUN_REMAINS = 0x1CC, + NOUN_DOORWAY_TO_ELEVATOR = 0x1CD, + NOUN_DRAGON_DOOR = 0x1CE, + NOUN_DRAGON_BONES = 0x1CF, + NOUN_IRON_FLOOR = 0x1D0, + NOUN_HOLE = 0x1D1, + NOUN_STONE = 0x1D2, + NOUN_HOMEMADE_BUNDLE = 0x1D3, + NOUN_LEFT = 0x1D4, + NOUN_RIGHT = 0x1D5, + NOUN_UP = 0x1D6, + NOUN_DOWN = 0x1D7, + NOUN_WEST = 0x1D8, + NOUN_DESERT_TO_WEST = 0x1D9, + NOUN_CROSS = 0x1DA, + NOUN_DESERT_TO_EAST = 0x1DB, + NOUN_DESERT_TO_SOUTH = 0x1DC, + NOUN_DESERT_TO_NORTH = 0x1DD, + NOUN_DESERT = 0x1DE, + NOUN_POWERSTONE = 0x1DF, + NOUN_BONES = 0x1E0, + NOUN_TENT = 0x1E1, + NOUN_BUSH = 0x1E2, + NOUN_SANWE = 0x1E3, + NOUN_TANGLE = 0x1E4, + NOUN_SAND = 0x1E5, + NOUN_MAGIC_GRAPES = 0x1E6, + NOUN_ROCS_NEST = 0x1E7, + NOUN_GRAPE_VINE = 0x1E8, + NOUN_STRANGE_SQUARE = 0x1E9, + NOUN_WATER_SPHERE = 0x1EA, + NOUN_EAST_END_OF_ISLAND = 0x1EB, + NOUN_ISLAND = 0x1EC, + NOUN_SECRET_MESSAGE = 0x1ED, + NOUN_FIND = 0x1EE, + NOUN_SAND_NEAR_STONES = 0x1EF, + NOUN_DESERT_SKY = 0x1F0, + NOUN_POOL = 0x1F1, + NOUN_PALM_TREE = 0x1F2, + NOUN_OASIS = 0x1F3, + NOUN_LEAN_TO = 0x1F4, + NOUN_TRADER = 0x1F5, + NOUN_SIGN = 0x1F6, + NOUN_WATER_FLOW = 0x1F7, + NOUN_FLOATING_DISK = 0x1F8, + NOUN_GNARLED_ROOT = 0x1F9, + NOUN_SNAKE_PIT = 0x1FA, + NOUN_MARKER = 0x1FB, + NOUN_SHAMAN = 0x1FC, + NOUN_GUARDHOUSE = 0x1FD, + NOUN_BONE_TREE = 0x1FE, + NOUN_EAR_ROCK = 0x1FF, + NOUN_MOUTH_ROCK = 0x200, + NOUN_NOSE_ROCK = 0x201, + NOUN_NEW_BUNDLE = 0x202, + NOUN_LIZARD = 0x203, + NOUN_ROC = 0x204, + NOUN_ROCS_NEST2 = 0x205, + NOUN_SELECT = 0x206, + NOUN_PURPLE_GEM = 0x207, + NOUN_PURPLE_STONE = 0x208, + NOUN_GREEN_STONE = 0x209, + NOUN_PATH = 0x20A, + NOUN_GUARDS = 0x20B, + NOUN_LAMP = 0x20C, + NOUN_SCIMITAR = 0x20D, + NOUN_SITTING_PILLOW = 0x20E, + NOUN_WATER_GOURD = 0x20F, + NOUN_JAR = 0x210, + NOUN_TENT_POLE = 0x211, + NOUN_EXIT = 0x212, + NOUN_PARAPHERNALIA = 0x213, + NOUN_SLATHAN_NI_PATAN3 = 0x214, + NOUN_EYE_ROCK = 0x215, + NOUN_BODY_TREE = 0x216, + NOUN_CLEARING = 0x217, + NOUN_TENTACLES = 0x218, + NOUN_SPELL_SHIELD = 0x219, + NOUN_POOL_MONSTER = 0x21A, + NOUN_SHIFTER_BOULDER = 0x21B, + NOUN_DEAD_TREE = 0x21C, + NOUN_PIT = 0x21D, + NOUN_SHIFTER_VILLAGE = 0x21E, + NOUN_SLATHAN_SKY = 0x21F, + NOUN_SHIFTER = 0x220, + NOUN_WALK_AROUND = 0x221, + NOUN_WRECKED_BRIDGE = 0x222, + NOUN_SHACK = 0x223, + NOUN_WRECKED_SHACK = 0x224, + NOUN_WISE_SHIFTER = 0x225, + NOUN_GRASS = 0x226, + NOUN_ENTRANCE_TO_MAZE = 0x227, + NOUN_TOPIARY_TOAD = 0x228, + NOUN_BOULDER = 0x229, + NOUN_MUSHROOM = 0x22A, + NOUN_SLATHAN_SKY2 = 0x22B, + NOUN_GRETA = 0x22C, + NOUN_TREE_STUMP = 0x22D, + NOUN_SANCTUARY_WOODS = 0x22E, + NOUN_TOADS = 0x22F, + NOUN_DOOFUS = 0x230, + NOUN_SHIFTING_MONSTER = 0x231, + NOUN_SPRITE = 0x232, + NOUN_MAZE = 0x233, + NOUN_TOPIARY_TOADSTOOL = 0x234, + NOUN_TOPIARY_GARGOYLE = 0x235, + NOUN_TOPIARY_DRAGON = 0x236, + NOUN_GUARDIAN = 0x237, + NOUN_BUTTERFLY_KING = 0x238, + NOUN_ROBE = 0x239, + NOUN_CEDAR_CHEST = 0x23A, + NOUN_DRAGONSPHERE2 = 0x23B, + NOUN_PATH_TO_HIGHTOWER2 = 0x23C, + NOUN_CALIPH = 0x23D +}; + +class SceneFactory { +public: + static SceneLogic *createScene(MADSEngine *vm); +}; + +/** + * Specialized base class for Dragonsphere game scenes + */ +class DragonsphereScene : public SceneLogic { +protected: + DragonsphereGlobals &_globals; + GameDragonsphere &_game; + MADSAction &_action; + + /** + * Forms an animation resource name + */ + Common::String formAnimName(char sepChar, int suffixNum); + + /** + * Plays appropriate sound for entering varous rooms + */ + void lowRoomsEntrySound(); +public: + /** + * Constructor + */ + DragonsphereScene(MADSEngine *vm); + + void sub7178C(); +}; + +class SceneInfoDragonsphere : public SceneInfo { + friend class SceneInfo; +protected: + virtual void loadCodes(MSurface &depthSurface, int variant); + + virtual void loadCodes(MSurface &depthSurface, Common::SeekableReadStream *stream); + + /** + * Constructor + */ + SceneInfoDragonsphere(MADSEngine *vm) : SceneInfo(vm) {} +}; + +// TODO: Temporary, remove once implemented properly +class Scene1xx : public DragonsphereScene { +protected: + /** + * Plays an appropriate sound when entering a scene + */ + void sceneEntrySound() {} + + /** + *Sets the AA file to use for the scene + */ + void setAAName() {} + + /** + * Updates the prefix used for getting player sprites for the scene + */ + void setPlayerSpritesPrefix() {} +public: + Scene1xx(MADSEngine *vm) : DragonsphereScene(vm) {} +}; + +// TODO: Temporary, remove once implemented properly +class DummyScene: public DragonsphereScene { +public: + DummyScene(MADSEngine *vm) : DragonsphereScene(vm) { + warning("Unimplemented scene"); + } + + virtual void setup() {} + virtual void enter() {} + virtual void actions() {} +}; + +} // End of namespace Dragonsphere + +} // End of namespace MADS + +#endif /* MADS_DRAGONSPHERE_SCENES_H */ diff --git a/engines/mads/dragonsphere/game_dragonsphere.cpp b/engines/mads/dragonsphere/game_dragonsphere.cpp new file mode 100644 index 0000000000..bee5312660 --- /dev/null +++ b/engines/mads/dragonsphere/game_dragonsphere.cpp @@ -0,0 +1,172 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "common/config-manager.h" +#include "mads/mads.h" +#include "mads/game.h" +#include "mads/screen.h" +#include "mads/msurface.h" +#include "mads/dragonsphere/game_dragonsphere.h" +//#include "mads/nebular/dialogs_nebular.h" +//#include "mads/nebular/globals_nebular.h" +#include "mads/dragonsphere/dragonsphere_scenes.h" + +namespace MADS { + +namespace Dragonsphere { + +GameDragonsphere::GameDragonsphere(MADSEngine *vm): Game(vm) { + _surface = new MSurface(MADS_SCREEN_WIDTH, MADS_SCENE_HEIGHT); + _storyMode = STORYMODE_NAUGHTY; +} + +ProtectionResult GameDragonsphere::checkCopyProtection() { + /* + // DEBUG: Flag copy protection failure + _globals[5] = -1; + + if (!ConfMan.getBool("copy_protection")) + return true; + + * DEBUG: Disabled for now + CopyProtectionDialog *dlg = new CopyProtectionDialog(_vm, false); + dlg->show(); + delete dlg; + */ + + // DEBUG: Return that copy protection failed + return PROTECTION_SUCCEED; +} + +void GameDragonsphere::initializeGlobals() { + //int count, count2; + //int bad; + + _globals.reset(); + //_globals[kTalkInanimateCount] = 8; + + /* Section #1 variables */ + // TODO + + /* Section #2 variables */ + // TODO + + /* Section #3 variables */ + // TODO + + /* Section #4 variables */ + // TODO + + /* Section #5 variables */ + // TODO + + /* Section #6 variables */ + // TODO + + /* Section #9 variables */ + // TODO + + _player._facing = FACING_NORTH; + _player._turnToFacing = FACING_NORTH; + + //Player::preloadSequences("RXM", 1); + //Player::preloadSequences("ROX", 1); +} + +void GameDragonsphere::setSectionHandler() { + delete _sectionHandler; + + switch (_sectionNumber) { + case 1: + _sectionHandler = new Section1Handler(_vm); + break; + case 2: + _sectionHandler = new Section2Handler(_vm); + break; + case 3: + _sectionHandler = new Section3Handler(_vm); + break; + case 4: + _sectionHandler = new Section4Handler(_vm); + break; + case 5: + _sectionHandler = new Section5Handler(_vm); + break; + case 6: + _sectionHandler = new Section6Handler(_vm); + break; + case 7: + _sectionHandler = new Section7Handler(_vm); + break; + case 8: + _sectionHandler = new Section8Handler(_vm); + break; + default: + break; + } +} + +void GameDragonsphere::checkShowDialog() { + // TODO: Copied from Nebular + if (_vm->_dialogs->_pendingDialog && _player._stepEnabled && !_globals[5]) { + _player.releasePlayerSprites(); + _vm->_dialogs->showDialog(); + _vm->_dialogs->_pendingDialog = DIALOG_NONE; + } +} + +void GameDragonsphere::doObjectAction() { + // TODO: Copied from Nebular + //Scene &scene = _scene; + MADSAction &action = _scene._action; + //Dialogs &dialogs = *_vm->_dialogs; + //int id; + + action._inProgress = false; +} + +void GameDragonsphere::unhandledAction() { + // TODO +} + +void GameDragonsphere::step() { + if (_player._visible && _player._stepEnabled && !_player._moving && + (_player._facing == _player._turnToFacing)) { + + // TODO + } + +} + +void GameDragonsphere::synchronize(Common::Serializer &s, bool phase1) { + Game::synchronize(s, phase1); + + // TODO: Copied from Nebular + if (!phase1) { + _globals.synchronize(s); + } +} + +} // End of namespace Dragonsphere + +} // End of namespace MADS diff --git a/engines/mads/dragonsphere/game_dragonsphere.h b/engines/mads/dragonsphere/game_dragonsphere.h new file mode 100644 index 0000000000..259c4168c1 --- /dev/null +++ b/engines/mads/dragonsphere/game_dragonsphere.h @@ -0,0 +1,151 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_GAME_DRAGONSPHERE_H +#define MADS_GAME_DRAGONSPHERE_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/globals.h" +//#include "mads/nebular/globals_nebular.h" + +namespace MADS { + +namespace Dragonsphere { + +// TODO: Adapt for Dragonsphere's difficulty setting +enum StoryMode { STORYMODE_NAUGHTY = 1, STORYMODE_NICE = 2 }; + +enum InventoryObject { + OBJ_NONE = -1, + OBJ_SIGNET_RING = 0, + OBJ_BIRD_FIGURINE = 1, + OBJ_BIRDCALL = 2, + OBJ_SHIELDSTONE = 3, + OBJ_SWORD = 4, + OBJ_GOBLET = 5, + OBJ_BONE = 6, + OBJ_FRUIT = 7, + OBJ_DOLL = 8, + OBJ_POLYSTONE = 9, + OBJ_RED_STONE = 10, + OBJ_YELLOW_STONE = 11, + OBJ_BLUE_STONE = 12, + OBJ_KEY_CROWN = 13, + OBJ_DATES = 14, + OBJ_STATUE = 15, + OBJ_FLIES = 16, + OBJ_SOUL_EGG = 17, + OBJ_MAGIC_BELT = 18, + OBJ_AMULET = 19, + OBJ_MUD = 20, + OBJ_FEATHERS = 21, + OBJ_TORCH = 22, + OBJ_FLASK = 23, + OBJ_FLASK_OF_ACID = 24, + OBJ_ROPE = 25, + OBJ_VORTEX_STONE = 26, + OBJ_DEAD_RAT = 27, + OBJ_MAP = 28, + OBJ_CRYSTAL_BALL = 29, + OBJ_BLACK_SPHERE = 30, + OBJ_SOPORIFIC = 31, + OBJ_SHIFTER_RING = 32, + OBJ_SPIRIT_BUNDLE = 33, + OBJ_PARTIAL_BUNDLE = 34, + OBJ_RATSICLE = 35, + OBJ_TENTACLE_PARTS = 36, + OBJ_TELEPORT_DOOR = 37, + OBJ_RARE_COIN = 38, + OBJ_CRYSTAL_FLOWER = 39, + OBJ_DIAMOND_DUST = 40, + OBJ_RUBY_RING = 41, + OBJ_GOLD_NUGGET = 42, + OBJ_MUSIC_BOX = 43, + OBJ_EMERALD = 44, + OBJ_PARCHMENT = 45, + OBJ_GAME = 46, + OBJ_GAME2 = 47, + OBJ_NEW_BUNDLE = 48 +}; + +// HACK: A stub for now, remove from here once it's implemented properly +class DragonsphereGlobals: public Globals { +public: + DragonsphereGlobals() { + resize(210); // Rex has 210 globals + } + virtual ~DragonsphereGlobals() {} +}; + +class GameDragonsphere: public Game { + friend class Game; +protected: + GameDragonsphere(MADSEngine *vm); + + virtual ProtectionResult checkCopyProtection(); + + virtual void initializeGlobals(); + + virtual void setSectionHandler(); + + virtual void checkShowDialog(); +public: + DragonsphereGlobals _globals; + StoryMode _storyMode; + + virtual Globals &globals() { return _globals; } + + virtual void doObjectAction(); + + virtual void unhandledAction(); + + virtual void step(); + + virtual void synchronize(Common::Serializer &s, bool phase1); +}; + + +class Section1Handler: public SectionHandler { +public: + Section1Handler(MADSEngine *vm): SectionHandler(vm) {} + + // TODO: Properly implement handler methods + virtual void preLoadSection() {} + virtual void sectionPtr2() {} + virtual void postLoadSection() {} +}; + +// TODO: Properly implement handler classes +typedef Section1Handler Section2Handler; +typedef Section1Handler Section3Handler; +typedef Section1Handler Section4Handler; +typedef Section1Handler Section5Handler; +typedef Section1Handler Section6Handler; +typedef Section1Handler Section7Handler; +typedef Section1Handler Section8Handler; + +} // End of namespace Nebular + +} // End of namespace MADS + +#endif /* MADS_GAME_DRAGONSPHERE_H */ diff --git a/engines/mads/events.cpp b/engines/mads/events.cpp new file mode 100644 index 0000000000..3f2a7390fb --- /dev/null +++ b/engines/mads/events.cpp @@ -0,0 +1,254 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "graphics/cursorman.h" +#include "common/events.h" +#include "engines/util.h" +#include "mads/mads.h" +#include "mads/events.h" +#include "mads/scene.h" + +namespace MADS { + +EventsManager::EventsManager(MADSEngine *vm) { + _vm = vm; + _cursorSprites = nullptr; + _frameCounter = 10; + _priorFrameTime = 0; + _mouseClicked = false; + _mouseReleased = false; + _mouseButtons = 0; + _mouseStatus = 0; + _vD2 = 0; + _mouseStatusCopy = 0; + _mouseMoved = false; + _vD8 = 0; + _rightMousePressed = false; +} + +EventsManager::~EventsManager() { + freeCursors(); +} + +void EventsManager::loadCursors(const Common::String &spritesName) { + delete _cursorSprites; + _cursorSprites = new SpriteAsset(_vm, spritesName, 0x4000); +} + +void EventsManager::setCursor(CursorType cursorId) { + _cursorId = cursorId; + changeCursor(); +} + +void EventsManager::setCursor2(CursorType cursorId) { + _cursorId = cursorId; + _newCursorId = cursorId; + changeCursor(); +} + +void EventsManager::showCursor() { + CursorMan.showMouse(true); +} + +void EventsManager::hideCursor() { + CursorMan.showMouse(false); +} + +bool EventsManager::isCursorVisible() { + return CursorMan.isVisible(); +} + +void EventsManager::waitCursor() { + CursorType cursorId = (CursorType)MIN(_cursorSprites->getCount(), (int)CURSOR_WAIT); + _newCursorId = cursorId; + if (_cursorId != _newCursorId) { + changeCursor(); + _cursorId = _newCursorId; + } +} + +void EventsManager::changeCursor() { + if (_cursorSprites) { + MSprite *cursor = _cursorSprites->getFrame(_cursorId - 1); + assert(cursor->w == cursor->h); + byte transIndex = cursor->getTransparencyIndex(); + + // Check for hotspot indication pixels along the right-hand and bottom + // row. Put together, these give the cursor's hotspot x,y + int hotspotX = 0, hotspotY = 0; + byte *cursorData = cursor->getData(); + for (int idx = 0; idx < cursor->w; ++idx) { + if (cursorData[(cursor->h - 1) * cursor->w + idx] != transIndex) + hotspotX = idx; + + if (cursorData[(idx + 1) * cursor->w - 1] != transIndex) + hotspotY = idx; + } + + // Reduce the cursor data to remove the last column from each row, since + // the cursor routines don't have a pitch option + byte *destCursor = new byte[(cursor->w - 1) * (cursor->h - 1)]; + byte *srcP = cursorData; + byte *destP = destCursor; + + for (int idx = 0; idx < (cursor->h - 1); ++idx) { + Common::copy(srcP, srcP + cursor->w - 1, destP); + srcP += cursor->w; + destP += cursor->w - 1; + } + + // Set the raw cursor data to use + CursorMan.replaceCursor(destCursor, cursor->w - 1, cursor->h - 1, + hotspotX, hotspotY, transIndex); + showCursor(); + delete[] destCursor; + } +} + +void EventsManager::freeCursors() { + delete _cursorSprites; + _cursorSprites = nullptr; +} + +void EventsManager::pollEvents() { + checkForNextFrameCounter(); + _mouseMoved = false; + + Common::Event event; + while (g_system->getEventManager()->pollEvent(event)) { + // Handle keypress + switch (event.type) { + case Common::EVENT_QUIT: + case Common::EVENT_RTL: + return; + + case Common::EVENT_KEYDOWN: + // Check for debugger + if (event.kbd.keycode == Common::KEYCODE_d && (event.kbd.flags & Common::KBD_CTRL)) { + // Attach to the debugger + _vm->_debugger->attach(); + _vm->_debugger->onFrame(); + } else { + _pendingKeys.push(event); + } + return; + case Common::EVENT_KEYUP: + return; + case Common::EVENT_LBUTTONDOWN: + case Common::EVENT_RBUTTONDOWN: + _mouseClicked = true; + _mouseButtons = 1; + _mouseMoved = true; + if (event.type == Common::EVENT_RBUTTONDOWN) { + _rightMousePressed = true; + _mouseStatus |= 2; + } else { + _mouseStatus |= 1; + } + return; + case Common::EVENT_LBUTTONUP: + case Common::EVENT_RBUTTONUP: + _mouseClicked = false; + _mouseReleased = true; + _mouseMoved = true; + _rightMousePressed = false; + if (event.type == Common::EVENT_RBUTTONUP) { + _mouseStatus &= ~2; + } else { + _mouseStatus &= ~1; + } + return; + case Common::EVENT_MOUSEMOVE: + _mousePos = event.mouse; + _currentPos = event.mouse; + _mouseMoved = true; + break; + default: + break; + } + } +} + +void EventsManager::checkForNextFrameCounter() { + // Check for next game frame + uint32 milli = g_system->getMillis(); + if ((milli - _priorFrameTime) >= GAME_FRAME_TIME) { + ++_frameCounter; + _priorFrameTime = milli; + + // Do any palette cycling + _vm->_game->_scene.animatePalette(); + + // Give time to the debugger + _vm->_debugger->onFrame(); + + // Display the frame + _vm->_screen.updateScreen(); + + // Signal the ScummVM debugger + _vm->_debugger->onFrame(); + } +} + +void EventsManager::delay(int cycles) { + uint32 totalMilli = cycles * 1000 / GAME_FRAME_RATE; + uint32 delayEnd = g_system->getMillis() + totalMilli; + + while (!_vm->shouldQuit() && g_system->getMillis() < delayEnd) { + g_system->delayMillis(10); + + pollEvents(); + } +} + +void EventsManager::waitForNextFrame() { + _mouseClicked = false; + _mouseReleased = false; + _mouseButtons = 0; + + bool mouseClicked = false; + bool mouseReleased = false; + int mouseButtons = 0; + + uint32 frameCtr = getFrameCounter(); + while (!_vm->shouldQuit() && frameCtr == _frameCounter) { + delay(1); + + mouseClicked |= _mouseClicked; + mouseReleased |= _mouseReleased; + mouseButtons |= _mouseButtons; + } + + _mouseClicked = mouseClicked; + _mouseReleased = mouseReleased; + _mouseButtons = mouseButtons; + _mouseMoved |= _mouseClicked || _mouseReleased; +} + +void EventsManager::initVars() { + _mousePos = Common::Point(-1, -1); + _mouseStatusCopy = _mouseStatus; + _vD2 = _vD8 = 0; +} + +} // End of namespace MADS diff --git a/engines/mads/events.h b/engines/mads/events.h new file mode 100644 index 0000000000..3d7504c0bd --- /dev/null +++ b/engines/mads/events.h @@ -0,0 +1,164 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_EVENTS_H +#define MADS_EVENTS_H + +#include "common/scummsys.h" +#include "common/events.h" +#include "common/stack.h" +#include "mads/assets.h" +#include "mads/sprites.h" + +namespace MADS { + +enum CursorType { CURSOR_NONE = 0, CURSOR_ARROW = 1, CURSOR_WAIT = 2, CURSOR_GO_DOWN = 3, + CURSOR_GO_UP = 4, CURSOR_GO_LEFT = 5, CURSOR_GO_RIGHT = 6 }; + +#define GAME_FRAME_RATE 50 +#define GAME_FRAME_TIME (1000 / GAME_FRAME_RATE) + +class MADSEngine; + +class EventsManager { +private: + MADSEngine *_vm; + uint32 _frameCounter; + uint32 _priorFrameTime; + Common::Point _mousePos; + Common::Point _currentPos; + + /** + * Updates the cursor image when the current cursor changes + */ + void changeCursor(); + + /** + * Checks for whether the next game frame number has been reached. + */ + void checkForNextFrameCounter(); +public: + SpriteAsset *_cursorSprites; + CursorType _cursorId; + CursorType _newCursorId; + bool _mouseClicked; + bool _mouseReleased; + byte _mouseButtons; + bool _rightMousePressed; + int _mouseStatus; + int _vD2; + int _mouseStatusCopy; + bool _mouseMoved; + int _vD8; + Common::Stack<Common::Event> _pendingKeys; +public: + /** + * Constructor + */ + EventsManager(MADSEngine *vm); + + /** + * Destructor + */ + ~EventsManager(); + + /** + * Loads the sprite set containing the cursors + */ + void loadCursors(const Common::String &spritesName); + + /** + * Sets the cursor + */ + void setCursor(CursorType cursorId); + + /** + * Sets the cursor + */ + void setCursor2(CursorType cursorId); + + /** + * Show the mouse cursor + */ + void showCursor(); + + /** + * Hide the mouse cursor + */ + void hideCursor(); + + /** + * Returns if the mouse cursor is visible + */ + bool isCursorVisible(); + + /** + * Shows the wait cursor + */ + void waitCursor(); + + /** + * Free currently loaded cursors + */ + void freeCursors(); + + /** + * Poll any pending events + */ + void pollEvents(); + + /** + * Return the current mouse position + */ + Common::Point mousePos() const { return _mousePos; } + + /** + * Return the current mouse position + */ + Common::Point currentPos() const { return _currentPos; } + + /** + * Delay for a given number of frames + */ + void delay(int amount); + + /** + * Wait for the next frame + */ + void waitForNextFrame(); + + /** + * Gets the current frame counter + */ + uint32 getFrameCounter() const { return _frameCounter; } + + void initVars(); + + /** + * Returns true if there's any pending keys to be processed + */ + bool isKeyPressed() const { return !_pendingKeys.empty(); } +}; + +} // End of namespace MADS + +#endif /* MADS_EVENTS_H */ diff --git a/engines/mads/font.cpp b/engines/mads/font.cpp new file mode 100644 index 0000000000..6f2d2b8168 --- /dev/null +++ b/engines/mads/font.cpp @@ -0,0 +1,246 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/compression.h" +#include "mads/font.h" +#include "mads/msurface.h" + +namespace MADS { + +MADSEngine *Font::_vm; + +Common::HashMap<Common::String, Font *> *Font::_fonts; + +uint8 Font::_fontColors[4]; + +void Font::init(MADSEngine *vm) { + _vm = vm; + _fontColors[0] = 0xFF; + _fontColors[1] = 0xF; + _fontColors[2] = 7; + _fontColors[3] = 8; + + _fonts = new Common::HashMap<Common::String, Font *>(); +} + +void Font::deinit() { + Common::HashMap<Common::String, Font *>::iterator i; + for (i = _fonts->begin(); i != _fonts->end(); ++i) + delete (*i)._value; + + delete _fonts; +} + +Font *Font::getFont(const Common::String &fontName) { + if (_fonts->contains(fontName)) { + return _fonts->getVal(fontName); + } else { + Font *font = new Font(fontName); + _fonts->setVal(fontName, font); + return font; + } +} + +Font::Font() { + setFont(FONT_INTERFACE); +} + +Font::Font(const Common::String &filename) { + setFont(filename); +} + +Font::~Font() { + delete[] _charWidths; + delete[] _charOffs; + delete[] _charData; +} + +void Font::setFont(const Common::String &filename) { + if (!_filename.empty() && (filename == _filename)) + // Already using specified font, so don't bother reloading + return; + + _filename = filename; + + MadsPack fontData(filename, _vm); + Common::SeekableReadStream *fontFile = fontData.getItemStream(0); + + _maxHeight = fontFile->readByte(); + _maxWidth = fontFile->readByte(); + + _charWidths = new uint8[128]; + // Char data is shifted by 1 + _charWidths[0] = 0; + fontFile->read(_charWidths + 1, 127); + fontFile->readByte(); // remainder + + _charOffs = new uint16[128]; + + uint startOffs = 2 + 128 + 256; + uint fontSize = fontFile->size() - startOffs; + + // Char data is shifted by 1 + _charOffs[0] = 0; + for (int i = 1; i < 128; i++) + _charOffs[i] = fontFile->readUint16LE() - startOffs; + fontFile->readUint16LE(); // remainder + + _charData = new uint8[fontSize]; + fontFile->read(_charData, fontSize); + + delete fontFile; +} + +void Font::setColors(uint8 v1, uint8 v2, uint8 v3, uint8 v4) { + _fontColors[0] = v1; + _fontColors[1] = v2; + _fontColors[2] = v3; + _fontColors[3] = v4; +} + +void Font::setColorMode(SelectionMode mode) { + switch (mode) { + case SELMODE_UNSELECTED: + setColors(0xFF, 4, 4, 0); + break; + case SELMODE_HIGHLIGHTED: + setColors(0xFF, 5, 5, 0); + break; + case SELMODE_SELECTED: + setColors(0xFF, 6, 6, 0); + break; + default: + break; + } +} + +int Font::writeString(MSurface *surface, const Common::String &msg, const Common::Point &pt, + int spaceWidth, int width) { + int xEnd; + if (width > 0) + xEnd = MIN((int)surface->w, pt.x + width); + else + xEnd = surface->w; + + int x = pt.x; + int y = pt.y; + + int skipY = 0; + if (y < 0) { + skipY = -y; + y = 0; + } + + int height = MAX(0, _maxHeight - skipY); + if (height == 0) + return x; + + int bottom = y + height - 1; + if (bottom > surface->getHeight() - 1) { + height -= MIN(height, bottom - (surface->getHeight() - 1)); + } + + if (height <= 0) + return x; + + byte *destPtr = surface->getBasePtr(x, y); + uint8 *oldDestPtr = destPtr; + + int xPos = x; + + const char *text = msg.c_str(); + while (*text) { + char theChar = (*text++) & 0x7F; + int charWidth = _charWidths[(byte)theChar]; + + if (charWidth > 0) { + + if (xPos + charWidth > xEnd) + return xPos; + + uint8 *charData = &_charData[_charOffs[(byte)theChar]]; + int bpp = getBpp(charWidth); + + if (skipY != 0) + charData += bpp * skipY; + + for (int i = 0; i < height; i++) { + for (int j = 0; j < bpp; j++) { + if (*charData & 0xc0) + *destPtr = _fontColors[(*charData & 0xc0) >> 6]; + destPtr++; + if (*charData & 0x30) + *destPtr = _fontColors[(*charData & 0x30) >> 4]; + destPtr++; + if (*charData & 0x0C) + *destPtr = _fontColors[(*charData & 0x0C) >> 2]; + destPtr++; + if (*charData & 0x03) + *destPtr = _fontColors[*charData & 0x03]; + destPtr++; + charData++; + } + + destPtr += surface->getWidth() - bpp * 4; + + } + + destPtr = oldDestPtr + charWidth + spaceWidth; + oldDestPtr = destPtr; + + } + + xPos += charWidth + spaceWidth; + + } + + return xPos; + +} + +int Font::getWidth(const Common::String &msg, int spaceWidth) { + int width = 0; + const char *text = msg.c_str(); + + if (msg.size() > 0) { + while (*text) + width += _charWidths[*text++ & 0x7F] + spaceWidth; + width -= spaceWidth; + } + + return width; +} + +int Font::getBpp(int charWidth) { + if (charWidth > 12) + return 4; + else if (charWidth > 8) + return 3; + else if (charWidth > 4) + return 2; + else + return 1; +} + +} // End of namespace MADS diff --git a/engines/mads/font.h b/engines/mads/font.h new file mode 100644 index 0000000000..1d733280df --- /dev/null +++ b/engines/mads/font.h @@ -0,0 +1,95 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_FONT_H +#define MADS_FONT_H + +#include "common/scummsys.h" +#include "common/hashmap.h" +#include "common/endian.h" +#include "common/util.h" +#include "mads/msurface.h" + +namespace MADS { + +#define FONT_CONVERSATION "*FONTCONV.FF" +#define FONT_INTERFACE "*FONTINTR.FF" +#define FONT_MAIN "*FONTMAIN.FF" +#define FONT_MENU "*FONTMENU.FF" // Not in Rex (uses bitmap files for menu strings) +#define FONT_MISC "*FONTMISC.FF" +#define FONT_TELE "*FONTTELE.FF" // Not in Phantom +#define FONT_PHAN "*FONTPHAN.FF" // Phantom only + +enum SelectionMode { + SELMODE_UNSELECTED = 0, SELMODE_HIGHLIGHTED = 1, SELMODE_SELECTED = 2 +}; + +class MADSEngine; + +class Font { +private: + static uint8 _fontColors[4]; + static MADSEngine *_vm; + static Common::HashMap<Common::String, Font *> *_fonts; +public: + /** + * Initialise the font system + */ + static void init(MADSEngine *vm); + + /** + * Free up the resources used by the font + */ + static void deinit(); + + /** + * Returns a new Font instance using the specified font name + */ + static Font *getFont(const Common::String &fontName); +private: + uint8 _maxWidth, _maxHeight; + uint8 *_charWidths; + uint16 *_charOffs; + uint8 *_charData; + Common::String _filename; + + int getBpp(int charWidth); + + void setFont(const Common::String &filename); +public: + Font(); + Font(const Common::String &filename); + virtual ~Font(); + + void setColors(uint8 v1, uint8 v2, uint8 v3, uint8 v4); + void setColorMode(SelectionMode mode); + + int maxWidth() const { return _maxWidth; } + int getWidth(const Common::String &msg, int spaceWidth = -1); + int getHeight() const { return _maxHeight; } + int writeString(MSurface *surface, const Common::String &msg, const Common::Point &pt, + int spaceWidth = 0, int width = 0); +}; + +} // End of namespace MADS + +#endif /* MADS_FONT_H */ diff --git a/engines/mads/game.cpp b/engines/mads/game.cpp new file mode 100644 index 0000000000..3f424711f7 --- /dev/null +++ b/engines/mads/game.cpp @@ -0,0 +1,593 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "common/config-manager.h" +#include "common/memstream.h" +#include "common/serializer.h" +#include "graphics/palette.h" +#include "graphics/scaler.h" +#include "graphics/thumbnail.h" +#include "mads/mads.h" +#include "mads/compression.h" +#include "mads/game.h" +#include "mads/game_data.h" +#include "mads/events.h" +#include "mads/screen.h" +#include "mads/msurface.h" +#include "mads/resources.h" +#include "mads/dragonsphere/game_dragonsphere.h" +#include "mads/nebular/game_nebular.h" +#include "mads/phantom/game_phantom.h" + +namespace MADS { + +Game *Game::init(MADSEngine *vm) { + switch (vm->getGameID()) { + case GType_RexNebular: + return new Nebular::GameNebular(vm); + case GType_Dragonsphere: + return new Dragonsphere::GameDragonsphere(vm); + case GType_Phantom: + return new Phantom::GamePhantom(vm); + default: + error("Game: Unknown game"); + } + + return nullptr; +} + +Game::Game(MADSEngine *vm): _vm(vm), _surface(nullptr), _objects(vm), + _scene(vm), _screenObjects(vm), _player(vm) { + _sectionNumber = _priorSectionNumber = 0; + _loadGameSlot = -1; + _lastSave = -1; + _saveFile = nullptr; + _statusFlag = 0; + _sectionHandler = nullptr; + _sectionNumber = 1; + _priorSectionNumber = 0; + _currentSectionNumber = -1; + _kernelMode = KERNEL_GAME_LOAD; + _quoteEmergency = false; + _vocabEmergency = false; + _aaName = "*I0.AA"; + _priorFrameTimer = 0; + _anyEmergency = false; + _triggerMode = SEQUENCE_TRIGGER_PARSER; + _triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _winStatus = 0; + _widepipeCtr = 0; + + // Load the inventory object list + _objects.load(); + if (_objects._inventoryList.size() > 0) + // At least one item in default inventory, so select first item for display + _scene._userInterface._selectedInvIndex = 0; + + // Load the quotes + loadQuotes(); +} + +Game::~Game() { + delete _saveFile; + delete _surface; + delete _sectionHandler; +} + +void Game::run() { + initializeGlobals(); + + // If requested, load a savegame instead of showing the intro + if (ConfMan.hasKey("save_slot")) { + int saveSlot = ConfMan.getInt("save_slot"); + if (saveSlot >= 0 && saveSlot <= 999) + _loadGameSlot = saveSlot; + } + + _statusFlag = true; + int protectionResult = -1; + + if (_loadGameSlot == -1) { + protectionResult = checkCopyProtection(); + switch (protectionResult) { + case PROTECTION_FAIL: + // Copy protection failed + _scene._nextSceneId = 804; + break; + case PROTECTION_ESCAPE: + // User escaped out of copy protection dialog + _vm->quitGame(); + break; + default: + // Copy protection check succeeded + _scene._nextSceneId = 101; + _scene._priorSceneId = -1; + break; + } + } + + // Get the initial starting time for the first scene + _scene._frameStartTime = _vm->_events->getFrameCounter(); + + if (_saveFile == nullptr && protectionResult != -1 && protectionResult != -2) { + initSection(_sectionNumber); + _statusFlag = true; + + _vm->_dialogs->_pendingDialog = DIALOG_DIFFICULTY; + _vm->_dialogs->showDialog(); + _vm->_dialogs->_pendingDialog = DIALOG_NONE; + + _priorSectionNumber = 0; + _priorSectionNumber = -1; + _scene._priorSceneId = 0; + _scene._currentSceneId = -1; + } + + if (protectionResult != 1 && protectionResult != 2) { + initializeGlobals(); + } + + if (_statusFlag) + gameLoop(); +} + +void Game::gameLoop() { + while (!_vm->shouldQuit() && _statusFlag) { + if (_loadGameSlot != -1) { + loadGame(_loadGameSlot); + _loadGameSlot = -1; + } + + setSectionHandler(); + _sectionHandler->preLoadSection(); + initSection(_sectionNumber); + _vm->_sound->init(_sectionNumber); + _sectionHandler->postLoadSection(); + + _scene._spriteSlots.reset(); + + if (_sectionNumber == _currentSectionNumber) + sectionLoop(); + + _player.releasePlayerSprites(); + assert(_scene._sprites._assetCount == 0); + + _vm->_palette->unlock(); + _vm->_events->waitCursor(); + _vm->_events->freeCursors(); + _vm->_sound->closeDriver(); + } + + _vm->_palette->close(); +} + +void Game::sectionLoop() { + while (!_vm->shouldQuit() && _statusFlag && (_sectionNumber == _currentSectionNumber)) { + _kernelMode = KERNEL_ROOM_PRELOAD; + _player._spritesChanged = true; + _quoteEmergency = false; + _vocabEmergency = false; + _vm->_events->waitCursor(); + + _scene.clearVocab(); + _scene._dynamicHotspots.clear(); + _scene.loadSceneLogic(); + + _player._walkAnywhere = false; + _player._stepEnabled = true; + _player._visible = true; + _vm->_dialogs->_defaultPosition = Common::Point(-1, -1); + _visitedScenes.add(_scene._nextSceneId); + + // Reset the user interface + _screenObjects._forceRescan = true; + _screenObjects._inputMode = kInputBuildingSentences; + _scene._userInterface._scrollbarActive = SCROLLBAR_NONE; + + _player._loadsFirst = true; + + _scene._sceneLogic->setup(); + if (_player._spritesChanged || _player._loadsFirst) { + if (_player._spritesLoaded) + _player.releasePlayerSprites(); + _vm->_palette->resetGamePalette(18, 10); + _scene._spriteSlots.reset(); + } else { + _vm->_palette->initPalette(); + } + + // Set up scene palette usage + _scene._scenePaletteUsage.clear(); + _scene._scenePaletteUsage.push_back(PaletteUsage::UsageEntry(0xF0)); + _scene._scenePaletteUsage.push_back(PaletteUsage::UsageEntry(0xF1)); + _scene._scenePaletteUsage.push_back(PaletteUsage::UsageEntry(0xF2)); + _vm->_palette->_paletteUsage.load(&_scene._scenePaletteUsage); + + if (!_player._spritesLoaded && _player._loadsFirst) { + if (_player.loadSprites("")) + _vm->quitGame(); + _player._loadedFirst = true; + } + + _scene.loadScene(_scene._nextSceneId, _aaName, 0); + _vm->_sound->pauseNewCommands(); + + if (!_player._spritesLoaded) { + if (_player.loadSprites("")) + _vm->quitGame(); + _player._loadedFirst = false; + } + + _vm->_events->initVars(); + _scene._userInterface._highlightedCommandIndex = -1; + _scene._userInterface._highlightedInvIndex = -1; + _scene._userInterface._highlightedItemVocabIndex = -1; + + _scene._action.clear(); + _player.setFinalFacing(); + _player._facing = _player._turnToFacing; + _player.cancelCommand(); + _kernelMode = KERNEL_ROOM_INIT; + + switch (_vm->_screenFade) { + case SCREEN_FADE_SMOOTH: + _fx = kTransitionFadeOutIn; + break; + case SCREEN_FADE_FAST: + _fx = kCenterVertTransition; + break; + default: + _fx = kTransitionNone; + break; + } + + _trigger = 0; + _priorFrameTimer = _scene._frameStartTime; + + // Call the scene logic for entering the given scene + _triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene._sceneLogic->enter(); + + // If in the middle of restoring a game, handle the rest of the loading + if (_saveFile != nullptr) { + Common::Serializer s(_saveFile, nullptr); + synchronize(s, false); + delete _saveFile; + _saveFile = nullptr; + } + + // Set player data + _player._targetPos = _player._playerPos; + _player._turnToFacing = _player._facing; + _player._targetFacing = _player._facing; + _player.selectSeries(); + _player.updateFrame(); + + _player._beenVisible = _player._visible; + _player._special = _scene.getDepthHighBits(_player._playerPos); + _player._priorTimer = _scene._frameStartTime - _player._ticksAmount; + _player.idle(); + + if (_scene._userInterface._selectedInvIndex >= 0) { + _scene._userInterface.loadInventoryAnim( + _objects._inventoryList[_scene._userInterface._selectedInvIndex]); + } else { + _scene._userInterface.noInventoryAnim(); + } + + _kernelMode = KERNEL_ACTIVE_CODE; + _scene._roomChanged = false; + + if ((_quoteEmergency || _vocabEmergency) && !_anyEmergency) { + _scene._currentSceneId = _scene._priorSceneId; + _anyEmergency = true; + } else { + _anyEmergency = false; + _scene.loop(); + } + + _vm->_events->waitCursor(); + _kernelMode = KERNEL_ROOM_PRELOAD; + + delete _scene._activeAnimation; + _scene._activeAnimation = nullptr; + + _scene._reloadSceneFlag = false; + + _scene._userInterface.noInventoryAnim(); + _scene.removeSprites(); + + if (!_player._loadedFirst) { + _player._spritesLoaded = false; + _player._spritesChanged = true; + } + + // Clear the scene + _scene.freeCurrentScene(); + _sectionNumber = _scene._nextSceneId / 100; + + // Check whether to show a dialog + checkShowDialog(); + } +} + +void Game::initSection(int sectionNumber) { + _priorSectionNumber = _currentSectionNumber; + _currentSectionNumber = sectionNumber; + + _vm->_palette->resetGamePalette(18, 10); + _vm->_palette->setLowRange(); + + if (_scene._layer == LAYER_GUI) + _vm->_palette->setPalette(_vm->_palette->_mainPalette, 0, 4); + + _vm->_events->loadCursors("*CURSOR.SS"); + + assert(_vm->_events->_cursorSprites); + _vm->_events->setCursor2((_vm->_events->_cursorSprites->getCount() <= 1) ? + CURSOR_ARROW : CURSOR_WAIT); +} + +void Game::loadQuotes() { + File f("*QUOTES.DAT"); + + Common::String msg; + while (true) { + uint8 b = f.readByte(); + + msg += b; + if (f.eos() || b == '\0') { + // end of string, add it to the strings list + _quotes.push_back(msg); + msg = ""; + } + + if (f.eos()) break; + } + + f.close(); +} + +Common::StringArray Game::getMessage(uint32 id) { + File f("*MESSAGES.DAT"); + int count = f.readUint16LE(); + + for (int idx = 0; idx < count; ++idx) { + uint32 itemId = f.readUint32LE(); + uint32 offset = f.readUint32LE(); + uint16 size = f.readUint16LE(); + + if (itemId == id) { + // Get the source buffer size + uint16 sizeIn; + if (idx == (count - 1)) { + sizeIn = f.size() - offset; + } else { + f.skip(4); + uint32 nextOffset = f.readUint32LE(); + sizeIn = nextOffset - offset; + } + + // Get the compressed data + f.seek(offset); + byte *bufferIn = new byte[sizeIn]; + f.read(bufferIn, sizeIn); + + // Decompress it + char *bufferOut = new char[size]; + FabDecompressor fab; + fab.decompress(bufferIn, sizeIn, (byte *)bufferOut, size); + + // Form the output string list + Common::StringArray result; + const char *p = bufferOut; + while (p < (bufferOut + size)) { + result.push_back(p); + p += strlen(p) + 1; + } + + delete[] bufferIn; + delete[] bufferOut; + return result; + } + } + + error("Invalid message Id specified"); +} + +static const char *const DEBUG_STRING = "WIDEPIPE"; + +void Game::handleKeypress(const Common::Event &event) { + if (event.kbd.flags & Common::KBD_CTRL) { + if (_widepipeCtr == 8) { + // Implement original game cheating keys here someday + } else { + if (event.kbd.keycode == (Common::KEYCODE_a + + (DEBUG_STRING[_widepipeCtr] - 'a'))) { + if (++_widepipeCtr == 8) { + MessageDialog *dlg = new MessageDialog(_vm, 2, + "CHEATING ENABLED", "(for your convenience)."); + dlg->show(); + delete dlg; + } + } + } + } + + switch (event.kbd.keycode) { + case Common::KEYCODE_F1: + _vm->_dialogs->_pendingDialog = DIALOG_GAME_MENU; + break; + case Common::KEYCODE_F5: + _vm->_dialogs->_pendingDialog = DIALOG_SAVE; + break; + case Common::KEYCODE_F7: + _vm->_dialogs->_pendingDialog = DIALOG_RESTORE; + break; + default: + break; + } + + warning("TODO: handleKeypress - %d", (int)event.kbd.keycode); +} + +void Game::synchronize(Common::Serializer &s, bool phase1) { + if (phase1) { + s.syncAsSint16LE(_fx); + s.syncAsSint16LE(_trigger); + s.syncAsUint16LE(_triggerSetupMode); + s.syncAsUint16LE(_triggerMode); + s.syncString(_aaName); + s.syncAsSint16LE(_lastSave); + + _scene.synchronize(s); + _objects.synchronize(s); + _visitedScenes.synchronize(s); + _player.synchronize(s); + _screenObjects.synchronize(s); + } else { + // Load scene specific data for the loaded scene + _scene._sceneLogic->synchronize(s); + } +} + +void Game::loadGame(int slotNumber) { + _saveFile = g_system->getSavefileManager()->openForLoading( + _vm->generateSaveName(slotNumber)); + + Common::Serializer s(_saveFile, nullptr); + + // Load the savaegame header + MADSSavegameHeader header; + if (!readSavegameHeader(_saveFile, header)) + error("Invalid savegame"); + + if (header._thumbnail) { + header._thumbnail->free(); + delete header._thumbnail; + } + + // Load most of the savegame data with the exception of scene specific info + synchronize(s, true); + + // Set up section/scene and other initial states for post-load + _currentSectionNumber = -2; + _scene._currentSceneId = -2; + _sectionNumber = _scene._nextSceneId / 100; + _scene._frameStartTime = _vm->_events->getFrameCounter(); + _vm->_screen._shakeCountdown = -1; + + // Default the selected inventory item to the first one, if the player has any + _scene._userInterface._selectedInvIndex = _objects._inventoryList.size() > 0 ? 0 : -1; + + // Set player sprites sets flags + _player._spritesLoaded = false; + _player._spritesChanged = true; +} + +void Game::saveGame(int slotNumber, const Common::String &saveName) { + Common::OutSaveFile *out = g_system->getSavefileManager()->openForSaving( + _vm->generateSaveName(slotNumber)); + + MADSSavegameHeader header; + header._saveName = saveName; + writeSavegameHeader(out, header); + + Common::Serializer s(nullptr, out); + synchronize(s, true); + synchronize(s, false); + + out->finalize(); + delete out; +} + +const char *const SAVEGAME_STR = "MADS"; +#define SAVEGAME_STR_SIZE 4 + +bool Game::readSavegameHeader(Common::InSaveFile *in, MADSSavegameHeader &header) { + char saveIdentBuffer[SAVEGAME_STR_SIZE + 1]; + header._thumbnail = nullptr; + + // Validate the header Id + in->read(saveIdentBuffer, SAVEGAME_STR_SIZE + 1); + if (strncmp(saveIdentBuffer, SAVEGAME_STR, SAVEGAME_STR_SIZE)) + return false; + + header._version = in->readByte(); + if (header._version > MADS_SAVEGAME_VERSION) + return false; + + // Read in the string + header._saveName.clear(); + char ch; + while ((ch = (char)in->readByte()) != '\0') header._saveName += ch; + + // Get the thumbnail + header._thumbnail = Graphics::loadThumbnail(*in); + if (!header._thumbnail) + return false; + + // Read in save date/time + header._year = in->readSint16LE(); + header._month = in->readSint16LE(); + header._day = in->readSint16LE(); + header._hour = in->readSint16LE(); + header._minute = in->readSint16LE(); + header._totalFrames = in->readUint32LE(); + + return true; +} + +void Game::writeSavegameHeader(Common::OutSaveFile *out, MADSSavegameHeader &header) { + // Write out a savegame header + out->write(SAVEGAME_STR, SAVEGAME_STR_SIZE + 1); + + out->writeByte(MADS_SAVEGAME_VERSION); + + // Write savegame name + out->write(header._saveName.c_str(), header._saveName.size()); + out->writeByte('\0'); + + // Get the active palette + uint8 thumbPalette[256 * 3]; + g_system->getPaletteManager()->grabPalette(thumbPalette, 0, 256); + + // Create a thumbnail and save it + Graphics::Surface *thumb = new Graphics::Surface(); + ::createThumbnail(thumb, _vm->_screen.getData(), MADS_SCREEN_WIDTH, MADS_SCREEN_HEIGHT, thumbPalette); + Graphics::saveThumbnail(*out, *thumb); + thumb->free(); + delete thumb; + + // Write out the save date/time + TimeDate td; + g_system->getTimeAndDate(td); + out->writeSint16LE(td.tm_year + 1900); + out->writeSint16LE(td.tm_mon + 1); + out->writeSint16LE(td.tm_mday); + out->writeSint16LE(td.tm_hour); + out->writeSint16LE(td.tm_min); + out->writeUint32LE(_vm->_events->getFrameCounter()); +} + +} // End of namespace MADS diff --git a/engines/mads/game.h b/engines/mads/game.h new file mode 100644 index 0000000000..a55de617fd --- /dev/null +++ b/engines/mads/game.h @@ -0,0 +1,229 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_GAME_H +#define MADS_GAME_H + +#include "common/scummsys.h" +#include "common/savefile.h" +#include "common/str-array.h" +#include "common/serializer.h" +#include "mads/audio.h" +#include "mads/scene.h" +#include "mads/game_data.h" +#include "mads/globals.h" +#include "mads/inventory.h" +#include "mads/player.h" +#include "mads/screen.h" + +namespace MADS { + +class MADSEngine; + +enum { + PLAYER_INVENTORY = 2 +}; + +enum KernelMode { + KERNEL_GAME_LOAD = 0, KERNEL_SECTION_PRELOAD = 1, KERNEL_SECTION_INIT = 2, + KERNEL_ROOM_PRELOAD = 3, KERNEL_ROOM_INIT = 4, KERNEL_ACTIVE_CODE = 5 +}; + +enum ProtectionResult { + PROTECTION_SUCCEED = 0, PROTECTION_FAIL = 1, PROTECTION_ESCAPE = 2 +}; + +#define MADS_SAVEGAME_VERSION 1 + +struct MADSSavegameHeader { + uint8 _version; + Common::String _saveName; + Graphics::Surface *_thumbnail; + int _year, _month, _day; + int _hour, _minute; + int _totalFrames; +}; + +class Game { +private: + /** + * Main game loop + */ + void gameLoop(); + + /** + * Inner game loop for executing gameplay within a game section + */ + void sectionLoop(); + + /** + * Load quotes data + */ + void loadQuotes(); +protected: + MADSEngine *_vm; + MSurface *_surface; + int _statusFlag; + Common::StringArray _quotes; + bool _quoteEmergency; + bool _vocabEmergency; + bool _anyEmergency; + int _lastSave; + Common::String _saveName; + Common::InSaveFile *_saveFile; + + /** + * Constructor + */ + Game(MADSEngine *vm); + + /** + * Initialises the current section number of the game + */ + void initSection(int sectionNumber); + + //@{ + /** @name Virtual Method list */ + + /** + * Perform any copy protection check + */ + virtual ProtectionResult checkCopyProtection() = 0; + + /** + * Initialises global variables for a new game + */ + virtual void initializeGlobals() = 0; + + /** + * Set up the section handler specific to each section + */ + virtual void setSectionHandler() = 0; + + /** + * Checks for whether to show a dialog + */ + virtual void checkShowDialog() = 0; + + //@} + +public: + static Game *init(MADSEngine *vm); + +public: + Player _player; + ScreenObjects _screenObjects; + int _sectionNumber; + int _priorSectionNumber; + int _currentSectionNumber; + InventoryObjects _objects; + SectionHandler *_sectionHandler; + VisitedScenes _visitedScenes; + Scene _scene; + KernelMode _kernelMode; + int _trigger; + ScreenTransition _fx; + TriggerMode _triggerMode; + TriggerMode _triggerSetupMode; + uint32 _priorFrameTimer; + Common::String _aaName; + int _winStatus; + int _widepipeCtr; + int _loadGameSlot; + +public: + virtual ~Game(); + + /** + * Main outer loop for the game + */ + void run(); + + uint32 getQuotesSize() { return _quotes.size(); } + const Common::String &getQuote(uint32 index) { return _quotes[index - 1]; } + void splitQuote(Common::String quote, Common::String part1, Common::String part2) {warning("TODO: splitQuote()");} + Common::StringArray getMessage(uint32 id); + + /** + * Returns the globals for the game + */ + virtual Globals &globals() = 0; + + /** + * Standard object handling across the game + */ + virtual void doObjectAction() = 0; + + /** + * Fallback handler for any action that isn't explicitly handled + */ + virtual void unhandledAction() = 0; + + /** + * Global game step + */ + virtual void step() = 0; + + /** + * Synchronise the game data + * @param s Serializer + * @param phase1 If true, it's synchronising the basic scene information + */ + virtual void synchronize(Common::Serializer &s, bool phase1); + + // DEPRECATED: ScummVM re-implementation keeps all the quotes loaded, so the methods below are stubs + void clearQuotes() {} + void loadQuoteRange(int startNum, int endNum) {} + void loadQuoteSet(...) {} + void loadQuote(int quoteNum) {} + + /** + * Handle a keyboard event + */ + void handleKeypress(const Common::Event &event); + + /** + * Starts a savegame loading. + * @remarks Due to the way the engine is implemented, loading is done in two + * parts, the second part after the specific scene has been loaded + */ + void loadGame(int slotNumber); + + /** + * Save the current game + */ + void saveGame(int slotNumber, const Common::String &saveName); + + /** + * Write out a savegame header + */ + void writeSavegameHeader(Common::OutSaveFile *out, MADSSavegameHeader &header); + + /** + * Read in a savegame header + */ + static bool readSavegameHeader(Common::InSaveFile *in, MADSSavegameHeader &header); +}; + +} // End of namespace MADS + +#endif /* MADS_GAME_H */ diff --git a/engines/mads/game_data.cpp b/engines/mads/game_data.cpp new file mode 100644 index 0000000000..0e2dcec70f --- /dev/null +++ b/engines/mads/game_data.cpp @@ -0,0 +1,54 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/game.h" +#include "mads/nebular/game_nebular.h" +#include "mads/screen.h" +#include "mads/msurface.h" +#include "mads/resources.h" + +namespace MADS { + +void VisitedScenes::add(int sceneId) { + _sceneRevisited = exists(sceneId); + + if (!_sceneRevisited) + push_back(sceneId); +} + +bool VisitedScenes::exists(int sceneId) { + for (uint i = 0; i < size(); ++i) { + if ((*this)[i] == sceneId) + return true; + } + + return false; +} + +void VisitedScenes::synchronize(Common::Serializer &s) { + SynchronizedList::synchronize(s); + s.syncAsByte(_sceneRevisited); +} + +} // End of namespace MADS diff --git a/engines/mads/game_data.h b/engines/mads/game_data.h new file mode 100644 index 0000000000..6ea59d6d2b --- /dev/null +++ b/engines/mads/game_data.h @@ -0,0 +1,73 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_GAME_DATA_H +#define MADS_GAME_DATA_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "mads/resources.h" + +namespace MADS { + +class MADSEngine; +class Game; + +class VisitedScenes: public SynchronizedList { +public: + /** + * Stores true when a previously visited scene is revisited + */ + bool _sceneRevisited; + + /** + * Returns true if a given Scene Id exists in the listed of previously visited scenes. + */ + bool exists(int sceneId); + + /** + * Adds a scene Id to the list of previously visited scenes, if it doesn't already exist + */ + void add(int sceneId); + + /** + * Synchronizes the list + */ + void synchronize(Common::Serializer &s); +}; + +class SectionHandler { +protected: + MADSEngine *_vm; +public: + SectionHandler(MADSEngine *vm): _vm(vm) {} + virtual ~SectionHandler() {} + + virtual void preLoadSection() = 0; + virtual void sectionPtr2() = 0; + virtual void postLoadSection() = 0; + virtual void step() {} +}; + +} // End of namespace MADS + +#endif /* MADS_GAME_DATA_H */ diff --git a/engines/mads/globals.cpp b/engines/mads/globals.cpp new file mode 100644 index 0000000000..1d088992ea --- /dev/null +++ b/engines/mads/globals.cpp @@ -0,0 +1,33 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/globals.h" + +namespace MADS { + +void Globals::reset() { + for (uint i = 0; i < size(); ++i) + (*this)[i] = 0; +} + +} // End of namespace MADS diff --git a/engines/mads/globals.h b/engines/mads/globals.h new file mode 100644 index 0000000000..92cd0bb403 --- /dev/null +++ b/engines/mads/globals.h @@ -0,0 +1,47 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_GLOBALS_H +#define MADS_GLOBALS_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "common/serializer.h" +#include "mads/resources.h" + +namespace MADS { + +class Globals: public SynchronizedList { +public: + Globals() {} + + virtual ~Globals() {} + + /* + * Resets all the globals to empty + */ + void reset(); +}; + +} // End of namespace MADS + +#endif /* MADS_GLOBALS_H */ diff --git a/engines/mads/hotspots.cpp b/engines/mads/hotspots.cpp new file mode 100644 index 0000000000..d3ce0a9263 --- /dev/null +++ b/engines/mads/hotspots.cpp @@ -0,0 +1,206 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "mads/mads.h" +#include "mads/hotspots.h" + +namespace MADS { + +DynamicHotspot::DynamicHotspot() { + _seqIndex = 0; + _facing = FACING_NONE; + _descId = 0; + _verbId = 0; + _articleNumber = 0; + _cursor = CURSOR_NONE; +} + +void DynamicHotspot::synchronize(Common::Serializer &s) { + +} + +/*------------------------------------------------------------------------*/ + +DynamicHotspots::DynamicHotspots(MADSEngine *vm) : _vm(vm) { + for (int i = 0; i < DYNAMIC_HOTSPOTS_SIZE; ++i) { + DynamicHotspot rec; + rec._active = false; + _entries.push_back(rec); + } + + _changed = true; + _count = 0; +} + +int DynamicHotspots::add(int descId, int verbId, int seqIndex, const Common::Rect &bounds) { + // Find a free slot + uint idx = 0; + while ((idx < _entries.size()) && _entries[idx]._active) + ++idx; + if (idx == _entries.size()) + error("DynamicHotspots overflow"); + + _entries[idx]._active = true; + _entries[idx]._descId = descId; + _entries[idx]._seqIndex = seqIndex; + _entries[idx]._bounds = bounds; + _entries[idx]._feetPos = Common::Point(-3, 0); + _entries[idx]._facing = FACING_NONE; + _entries[idx]._verbId = verbId; + _entries[idx]._articleNumber = PREP_IN; + _entries[idx]._cursor = CURSOR_NONE; + + ++_count; + _changed = true; + + if (seqIndex >= 0) + _vm->_game->_scene._sequences[seqIndex]._dynamicHotspotIndex = idx; + + return idx; +} + +int DynamicHotspots::setPosition(int index, const Common::Point &pos, Facing facing) { + if (index >= 0) { + _entries[index]._feetPos = pos; + _entries[index]._facing = facing; + } + + return index; +} + +int DynamicHotspots::setCursor(int index, CursorType cursor) { + if (index >= 0) + _entries[index]._cursor = cursor; + + return index; +} + +void DynamicHotspots::remove(int index) { + Scene &scene = _vm->_game->_scene; + + if (index >= 0 && _entries[index]._active) { + if (_entries[index]._seqIndex >= 0) + scene._sequences[_entries[index]._seqIndex]._dynamicHotspotIndex = -1; + _entries[index]._active = false; + + --_count; + _changed = true; + } +} + +void DynamicHotspots::clear() { + for (uint i = 0; i < _entries.size(); ++i) + _entries[i]._active = false; + + _changed = false; + _count = 0; +} + +void DynamicHotspots::reset() { + for (uint i = 0; i < _entries.size(); ++i) + remove(i); + + _count = 0; + _changed = false; +} + +void DynamicHotspots::refresh() { + // Reset the screen objects back to only contain UI elements + ScreenObjects &scrObjects = _vm->_game->_screenObjects; + scrObjects.resize(scrObjects._uiCount); + + // Loop through adding hotspots + for (uint i = 0; i < _entries.size(); ++i) { + DynamicHotspot &dh = (*this)[i]; + + if ((*this)[i]._active) { + switch (scrObjects._inputMode) { + case kInputBuildingSentences: + case kInputLimitedSentences: + scrObjects.add(dh._bounds, _vm->_game->_scene._layer, CAT_12, dh._descId); + scrObjects._forceRescan = true; + break; + default: + break; + } + } + } +} + +void DynamicHotspots::synchronize(Common::Serializer &s) { + int count = _entries.size(); + s.syncAsSint16LE(count); + + if (s.isSaving()) { + for (int i = 0; i < count; ++i) + _entries[i].synchronize(s); + } else { + DynamicHotspot rec; + rec.synchronize(s); + _entries.push_back(rec); + } +} + +/*------------------------------------------------------------------------*/ + +Hotspot::Hotspot() { + _facing = FACING_NONE; + _articleNumber = 0; + _cursor = CURSOR_NONE; + _vocabId = 0; + _verbId = 0; + _active = false; +} + +Hotspot::Hotspot(Common::SeekableReadStream &f, bool isV2) { + _bounds.left = f.readSint16LE(); + _bounds.top = f.readSint16LE(); + _bounds.right = f.readSint16LE(); + _bounds.bottom = f.readSint16LE(); + _feetPos.x = f.readSint16LE(); + _feetPos.y = f.readSint16LE(); + _facing = (Facing)f.readByte(); + _articleNumber = f.readByte(); + _active = f.readByte() != 0; + _cursor = (CursorType)f.readByte(); + if (isV2) { + // This looks to be some sort of bitmask. Perhaps it signifies + // the valid verbs for this hotspot + f.skip(2); // unknown + } + _vocabId = f.readUint16LE(); + _verbId = f.readUint16LE(); +} + +/*------------------------------------------------------------------------*/ + +void Hotspots::activate(int vocabId, bool active) { + for (uint idx = 0; idx < size(); ++idx) { + Hotspot &hotspot = (*this)[idx]; + if (hotspot._vocabId == vocabId) { + hotspot._active = active; + _vm->_game->_screenObjects.setActive(CAT_HOTSPOT, idx, active); + } + } +} + +} // End of namespace MADS diff --git a/engines/mads/hotspots.h b/engines/mads/hotspots.h new file mode 100644 index 0000000000..5fd910e1aa --- /dev/null +++ b/engines/mads/hotspots.h @@ -0,0 +1,114 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_HOTSPOTS_H +#define MADS_HOTSPOTS_H + +#include "common/scummsys.h" +#include "mads/events.h" +#include "mads/player.h" + +namespace MADS { + +class MADSEngine; + +class DynamicHotspot { +public: + bool _active; + int _seqIndex; + Common::Rect _bounds; + Common::Point _feetPos; + Facing _facing; + int _descId; + int _verbId; + int _articleNumber; + CursorType _cursor; + + /** + * Constructor + */ + DynamicHotspot(); + + /** + * Synchronize the data + */ + void synchronize(Common::Serializer &s); +}; + +#define DYNAMIC_HOTSPOTS_SIZE 8 + +class DynamicHotspots { +private: + MADSEngine *_vm; + Common::Array<DynamicHotspot> _entries; + int _count; +public: + bool _changed; +public: + DynamicHotspots(MADSEngine *vm); + + Common::Array<MADS::DynamicHotspot>::size_type size() const { return _entries.size(); } + DynamicHotspot &operator[](uint idx) { return _entries[idx]; } + int add(int descId, int verbId, int seqIndex, const Common::Rect &bounds); + int setPosition(int index, const Common::Point &pos, Facing facing); + int setCursor(int index, CursorType cursor); + void remove(int index); + void clear(); + void reset(); + void refresh(); + + /** + * Synchronize the data + */ + void synchronize(Common::Serializer &s); +}; + +class Hotspot { +public: + Common::Rect _bounds; + Common::Point _feetPos; + Facing _facing; + int _articleNumber; + bool _active; + CursorType _cursor; + int _vocabId; + int _verbId; + + Hotspot(); + Hotspot(Common::SeekableReadStream &f, bool isV2); +}; + +class Hotspots : public Common::Array<Hotspot> { +private: + MADSEngine *_vm; +public: + Hotspots(MADSEngine *vm) : _vm(vm) {} + + /** + * Sets the active state of a given hotspot + */ + void activate(int vocabId, bool active); +}; + +} // End of namespace MADS + +#endif /* MADS_HOTSPOTS_H */ diff --git a/engines/mads/inventory.cpp b/engines/mads/inventory.cpp new file mode 100644 index 0000000000..434d284244 --- /dev/null +++ b/engines/mads/inventory.cpp @@ -0,0 +1,226 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/inventory.h" + +namespace MADS { + +void InventoryObject::synchronize(Common::Serializer &s) { + s.syncAsUint16LE(_descId); + s.syncAsUint16LE(_roomNumber); + s.syncAsByte(_article); + s.syncAsByte(_vocabCount); + s.syncAsByte(_qualitiesCount); + s.skip(1); + + for (int i = 0; i < MAX_VOCAB; ++i) { + s.syncAsUint16LE(_vocabList[i]._vocabId); + s.syncAsByte(_vocabList[i]._verbType); + s.syncAsByte(_vocabList[i]._prepType); + } + + for (int i = 0; i < MAX_QUALITIES; ++i) + s.syncAsByte(_qualityId[i]); + for (int i = 0; i < MAX_QUALITIES; ++i) + s.syncAsSint32LE(_qualityValue[i]); +} + +bool InventoryObject::hasQuality(int qualityId) const { + for (int i = 0; i < _qualitiesCount; ++i) { + if (_qualityId[i] == qualityId) + return true; + } + + return false; +} + +void InventoryObject::setQuality(int qualityId, int qualityValue) { + for (int i = 0; i < _qualitiesCount; ++i) { + if (_qualityId[i] == qualityId) { + _qualityValue[i] = qualityValue; + } + } +} + +int InventoryObject::getQuality(int qualityId) const { + for (int i = 0; i < _qualitiesCount; ++i) { + if (_qualityId[i] == qualityId) { + return _qualityValue[i]; + } + } + + return 0; +} + +/*------------------------------------------------------------------------*/ + +void InventoryObjects::load() { + File f("*OBJECTS.DAT"); + int count = f.readUint16LE(); + Common::Serializer s(&f, nullptr); + + // Load the objects data + reserve(count); + for (int i = 0; i < count; ++i) { + InventoryObject obj; + obj.synchronize(s); + push_back(obj); + + // If it's for the player's inventory, add the index to the inventory list + if (obj._roomNumber == PLAYER_INVENTORY) { + _inventoryList.push_back(i); + assert(_inventoryList.size() <= 32); + } + } +} + +void InventoryObjects::synchronize(Common::Serializer &s) { + int count = size(); + s.syncAsUint16LE(count); + + if (s.isSaving()) { + // Store the data for each object in the inventory lsit + for (int idx = 0; idx < count; ++idx) + (*this)[idx].synchronize(s); + + // Synchronize the player's inventory + _inventoryList.synchronize(s); + } else { + clear(); + + // Read in each object + reserve(count); + for (int i = 0; i < count; ++i) { + InventoryObject obj; + obj.synchronize(s); + push_back(obj); + } + + // Synchronize the player's inventory + _inventoryList.synchronize(s); + } +} + +void InventoryObjects::setRoom(int objectId, int sceneNumber) { + InventoryObject &obj = (*this)[objectId]; + + if (obj._roomNumber == PLAYER_INVENTORY) + removeFromInventory(objectId, 1); + + if (sceneNumber == PLAYER_INVENTORY) + addToInventory(objectId); + else + obj._roomNumber = sceneNumber; +} + +bool InventoryObjects::isInRoom(int objectId) const { + return objectId >= 0 && (*this)[objectId]._roomNumber == _vm->_game->_scene._currentSceneId; +} + +bool InventoryObjects::isInInventory(int objectId) const { + return objectId >= 0 && (*this)[objectId]._roomNumber == PLAYER_INVENTORY; +} + +void InventoryObjects::addToInventory(int objectId) { + assert(_inventoryList.size() < 32); + UserInterface &userInterface = _vm->_game->_scene._userInterface; + + if (!isInInventory(objectId)) { + _inventoryList.push_back(objectId); + userInterface._selectedInvIndex = _inventoryList.size() - 1; + userInterface._inventoryTopIndex = CLIP(userInterface._inventoryTopIndex, + 0, (int)_inventoryList.size() - 1); + + if ((userInterface._inventoryTopIndex + 5) <= (int)_inventoryList.size()) + userInterface._inventoryTopIndex = size() - 4; + userInterface._inventoryChanged = true; + + (*this)[objectId]._roomNumber = PLAYER_INVENTORY; + + if (_vm->_game->_kernelMode == KERNEL_ACTIVE_CODE && + _vm->_game->_screenObjects._inputMode == kInputBuildingSentences) { + userInterface.categoryChanged(); + userInterface.selectObject(userInterface._selectedInvIndex); + } + } +} + +void InventoryObjects::removeFromInventory(int objectId, int newScene) { + Scene &scene = _vm->_game->_scene; + UserInterface &userInterface = scene._userInterface; + + // Scan the inventory list for the object + int invIndex = -1; + for (int idx = 0; idx < (int)_inventoryList.size() && invIndex == -1; ++idx) { + if (_inventoryList[idx] == objectId) + invIndex = idx; + } + + // If the object isn't in the player's inventory, stop here + if (invIndex < 0) + return; + + int selectedIndex = userInterface._selectedInvIndex; + bool noSelection = selectedIndex < 0; + + if (_vm->_game->_kernelMode == KERNEL_ACTIVE_CODE && + _vm->_game->_screenObjects._inputMode == kInputBuildingSentences) + userInterface.selectObject(-1); + + // Remove the item from the inventory list + _inventoryList.remove_at(invIndex); + + if (invIndex > userInterface._inventoryTopIndex) { + userInterface._inventoryTopIndex = MAX(userInterface._inventoryTopIndex, 0); + } + + userInterface._inventoryChanged = true; + (*this)[objectId]._roomNumber = newScene; + + int newIndex = selectedIndex; + if (!noSelection) { + if (newIndex >= invIndex) + --newIndex; + if (newIndex < 0 && size() > 0) + newIndex = 0; + } + + if (_vm->_game->_kernelMode == KERNEL_ACTIVE_CODE && + _vm->_game->_screenObjects._inputMode == kInputBuildingSentences) { + userInterface.categoryChanged(); + userInterface.selectObject(newIndex); + } +} + +int InventoryObjects::getIdFromDesc(int descId) { + for (int i = 0; i < (int)size(); ++i) { + InventoryObject &obj = (*this)[i]; + if (obj._descId == descId) + return i; + } + + return -1; +} + +} // End of namespace MADS diff --git a/engines/mads/inventory.h b/engines/mads/inventory.h new file mode 100644 index 0000000000..7fb123e047 --- /dev/null +++ b/engines/mads/inventory.h @@ -0,0 +1,141 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_INVENTORY_H +#define MADS_INVENTORY_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "common/serializer.h" + +namespace MADS { + +enum { + NOWHERE = 1 +}; + +class MADSEngine; + +#define MAX_VOCAB 5 +#define MAX_QUALITIES 4 + +class InventoryObject { +public: + int _descId; + int _roomNumber; + int _article; + int _vocabCount; + int _qualitiesCount; + int syntax; + + struct { + int _vocabId; + VerbType _verbType; + PrepType _prepType; + } _vocabList[MAX_VOCAB]; + + int _qualityId[MAX_QUALITIES]; + int _qualityValue[MAX_QUALITIES]; + + /** + * Synchronizes the data for a given object + */ + void synchronize(Common::Serializer &s); + + /** + * Returns true if the given object has the specified quality + */ + bool hasQuality(int qualityId) const; + + /** + * Sets the quality value for a given quality Id + */ + void setQuality(int qualityId, int qualityValue); + + /** + * Gets the quality value for a given quality Id + */ + int getQuality(int qualityId) const; +}; + +class InventoryObjects: public Common::Array<InventoryObject> { +private: + MADSEngine *_vm; + +public: + SynchronizedList _inventoryList; + + /** + * Constructor + */ + InventoryObjects(MADSEngine *vm): _vm(vm) {} + + /** + * Loads the game's object list + */ + void load(); + + /** + * Synchronize the objects list in a savegame + */ + void synchronize(Common::Serializer &s); + + /** + * Returns the inventory item from the player's inventory + */ + InventoryObject &getItem(int itemIndex) { + return (*this)[_inventoryList[itemIndex]]; + } + + /** + * Sets an item's scene number + */ + void setRoom(int objectId, int sceneNumber); + + /** + * Returns true if a given object is in the player's current scene + */ + bool isInRoom(int objectId) const; + + /** + * Returns true if a given object is in the player's inventory + */ + bool isInInventory(int objectId) const; + + /** + * Removes the specified object from the player's inventory + */ + void addToInventory(int objectId); + + /** + * Removes the specified object to the player's inventory + * @param objectId Object to remove + * @param newScene Specifies the new scene to set the item to + */ + void removeFromInventory(int objectId, int newScene); + + int getIdFromDesc(int objectId); +}; + +} // End of namespace MADS + +#endif /* MADS_INVENTORY_H */ diff --git a/engines/mads/mads.cpp b/engines/mads/mads.cpp new file mode 100644 index 0000000000..bcd8fdba8f --- /dev/null +++ b/engines/mads/mads.cpp @@ -0,0 +1,156 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "common/config-manager.h" +#include "common/debug-channels.h" +#include "common/events.h" +#include "engines/util.h" +#include "mads/mads.h" +#include "mads/game.h" +#include "mads/screen.h" +#include "mads/msurface.h" +#include "mads/resources.h" +#include "mads/sound.h" +#include "mads/sprites.h" + +namespace MADS { + +MADSEngine::MADSEngine(OSystem *syst, const MADSGameDescription *gameDesc) : + _gameDescription(gameDesc), Engine(syst), _randomSource("MADS") { + + // Initialise fields + _easyMouse = true; + _invObjectsAnimated = true; + _textWindowStill = false; + _screenFade = SCREEN_FADE_SMOOTH; + _musicFlag = true; + _dithering = false; + + _debugger = nullptr; + _dialogs = nullptr; + _events = nullptr; + _font = nullptr; + _game = nullptr; + _palette = nullptr; + _resources = nullptr; + _sound = nullptr; +} + +MADSEngine::~MADSEngine() { + delete _debugger; + delete _dialogs; + delete _events; + delete _font; + Font::deinit(); + delete _game; + delete _palette; + delete _resources; + delete _sound; +} + +void MADSEngine::initialise() { + // Set up debug channels + DebugMan.addDebugChannel(kDebugPath, "Path", "Pathfinding debug level"); + DebugMan.addDebugChannel(kDebugScripts, "scripts", "Game scripts"); + DebugMan.addDebugChannel(kDebugGraphics, "graphics", "Graphics handling"); + + // Initial sub-system engine references + MSurface::setVm(this); + MSprite::setVm(this); + + Resources::init(this); + Conversation::init(this); + _debugger = new Debugger(this); + _dialogs = Dialogs::init(this); + _events = new EventsManager(this); + _palette = new Palette(this); + Font::init(this); + _font = new Font(); + _screen.init(); + _sound = new SoundManager(this, _mixer); + _audio = new AudioPlayer(_mixer, getGameID()); + _game = Game::init(this); + + _screen.empty(); +} + +Common::Error MADSEngine::run() { + initGraphics(MADS_SCREEN_WIDTH, MADS_SCREEN_HEIGHT, false); + initialise(); + + // Run the game + _game->run(); + + // Dummy loop to keep application active + _events->delay(9999); + + return Common::kNoError; +} + +int MADSEngine::getRandomNumber(int maxNumber) { + return _randomSource.getRandomNumber(maxNumber); +} + +int MADSEngine::getRandomNumber(int minNumber, int maxNumber) { + int range = maxNumber - minNumber; + + return minNumber + _randomSource.getRandomNumber(range); +} + +int MADSEngine::hypotenuse(int xv, int yv) { + return (int)sqrt((double)(xv * xv + yv * yv)); +} + +bool MADSEngine::canLoadGameStateCurrently() { + return !_game->_winStatus && !_game->globals()[5] + && _dialogs->_pendingDialog == DIALOG_NONE + && _events->_cursorId != CURSOR_WAIT; +} + +bool MADSEngine::canSaveGameStateCurrently() { + return !_game->_winStatus && !_game->globals()[5] + && _dialogs->_pendingDialog == DIALOG_NONE + && _events->_cursorId != CURSOR_WAIT; +} + +/** +* Support method that generates a savegame name +* @param slot Slot number +*/ +Common::String MADSEngine::generateSaveName(int slot) { + return Common::String::format("%s.%03d", _targetName.c_str(), slot); +} + +Common::Error MADSEngine::loadGameState(int slot) { + _game->_loadGameSlot = slot; + _game->_scene._currentSceneId = -1; + _game->_currentSectionNumber = -1; + return Common::kNoError; +} + +Common::Error MADSEngine::saveGameState(int slot, const Common::String &desc) { + _game->saveGame(slot, desc); + return Common::kNoError; +} + +} // End of namespace MADS diff --git a/engines/mads/mads.h b/engines/mads/mads.h new file mode 100644 index 0000000000..3f325fd6a1 --- /dev/null +++ b/engines/mads/mads.h @@ -0,0 +1,152 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_MADS_H +#define MADS_MADS_H + +#include "common/scummsys.h" +#include "common/system.h" +#include "common/error.h" +#include "common/random.h" +#include "common/util.h" +#include "engines/engine.h" +#include "graphics/surface.h" +#include "mads/debugger.h" +#include "mads/dialogs.h" +#include "mads/events.h" +#include "mads/font.h" +#include "mads/game.h" +#include "mads/screen.h" +#include "mads/msurface.h" +#include "mads/resources.h" +#include "mads/sound.h" + +/** + * This is the namespace of the MADS engine. + * + * Status of this engine: In Development + * + * Games using this engine: + * - Rex Nebular and the Cosmic Gender Bender + */ +namespace MADS { + +#define DEBUG_BASIC 1 +#define DEBUG_INTERMEDIATE 2 +#define DEBUG_DETAILED 3 + +enum MADSDebugChannels { + kDebugPath = 1 << 0, + kDebugScripts = 1 << 1, + kDebugGraphics = 1 << 2 +}; + +enum { + GType_RexNebular = 0, + GType_Dragonsphere = 1, + GType_Phantom = 2 +}; + +enum ScreenFade { + SCREEN_FADE_SMOOTH = 0, + SCREEN_FADE_MEDIUM = 1, + SCREEN_FADE_FAST = 2 +}; + +struct MADSGameDescription; + + +class MADSEngine : public Engine { +private: + const MADSGameDescription *_gameDescription; + Common::RandomSource _randomSource; + + /** + * Handles basic initialisation + */ + void initialise(); +protected: + // Engine APIs + virtual Common::Error run(); + virtual bool hasFeature(EngineFeature f) const; +public: + Debugger *_debugger; + Dialogs *_dialogs; + EventsManager *_events; + Font *_font; + Game *_game; + Palette *_palette; + Resources *_resources; + ScreenSurface _screen; + SoundManager *_sound; + AudioPlayer *_audio; + bool _easyMouse; + bool _invObjectsAnimated; + bool _textWindowStill; + ScreenFade _screenFade; + bool _musicFlag; + bool _dithering; +public: + MADSEngine(OSystem *syst, const MADSGameDescription *gameDesc); + virtual ~MADSEngine(); + + uint32 getFeatures() const; + Common::Language getLanguage() const; + Common::Platform getPlatform() const; + uint16 getVersion() const; + uint32 getGameID() const; + uint32 getGameFeatures() const; + + int getRandomNumber(int maxNumber); + int getRandomNumber(int minNumber, int maxNumber); + int hypotenuse(int xv, int yv); + + /** + * Returns true if it is currently okay to restore a game + */ + bool canLoadGameStateCurrently(); + + /** + * Returns true if it is currently okay to save the game + */ + bool canSaveGameStateCurrently(); + + /** + * Support method that generates a savegame name + * @param slot Slot number + */ + Common::String generateSaveName(int slot); + + /** + * Handles loading a game via the GMM + */ + virtual Common::Error loadGameState(int slot); + + /** + * Handles saving the game via the GMM + */ + virtual Common::Error saveGameState(int slot, const Common::String &desc); +}; + +} // End of namespace MADS + +#endif /* MADS_MADS_H */ diff --git a/engines/mads/messages.cpp b/engines/mads/messages.cpp new file mode 100644 index 0000000000..263d8fa661 --- /dev/null +++ b/engines/mads/messages.cpp @@ -0,0 +1,566 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/font.h" +#include "mads/screen.h" +#include "mads/messages.h" +#include "mads/scene_data.h" + +namespace MADS { + +RandomMessages::RandomMessages() { + reserve(RANDOM_MESSAGE_SIZE); + _randomSpacing = 0; +} + +void RandomMessages::reset() { + for (uint i = 0; i < size(); ++i) { + (*this)[i]._handle = -1; + (*this)[i]._quoteId = -1; + } +} + + +KernelMessages::KernelMessages(MADSEngine *vm): _vm(vm) { + for (int i = 0; i < KERNEL_MESSAGES_SIZE; ++i) { + KernelMessage rec; + _entries.push_back(rec); + } + + _talkFont = _vm->_font->getFont(FONT_CONVERSATION); +} + +KernelMessages::~KernelMessages() { +} + +void KernelMessages::clear() { + Scene &scene = _vm->_game->_scene; + + for (uint i = 0; i < _entries.size(); ++i) + _entries[i]._flags = 0; + + scene._textSpacing = -1; +} + +int KernelMessages::add(const Common::Point &pt, uint fontColor, uint8 flags, + uint8 abortTimers, uint32 timeout, const Common::String &msg) { + Scene &scene = _vm->_game->_scene; + + // Find a free slot + uint idx = 0; + while ((idx < _entries.size()) && ((_entries[idx]._flags & KMSG_ACTIVE) != 0)) + ++idx; + if (idx == _entries.size()) { + if (abortTimers == 0) + return -1; + + error("KernelMessages overflow"); + } + + KernelMessage &rec = _entries[idx]; + rec._msg = msg; + rec._flags = flags | KMSG_ACTIVE; + rec._color1 = fontColor & 0xff; + rec._color2 = fontColor >> 8; + rec._position = pt; + rec._textDisplayIndex = -1; + rec._timeout = timeout; + rec._frameTimer = _vm->_game->_priorFrameTimer; + rec._trigger = abortTimers; + rec._abortMode = _vm->_game->_triggerSetupMode; + + rec._actionDetails = scene._action._activeAction; + + if (flags & KMSG_PLAYER_TIMEOUT) + rec._frameTimer = _vm->_game->_player._ticksAmount + + _vm->_game->_player._priorTimer; + + return idx; +} + +int KernelMessages::addQuote(int quoteId, int abortTimers, uint32 timeout) { + Common::String quoteStr = _vm->_game->getQuote(quoteId); + return add(Common::Point(), 0x1110, KMSG_PLAYER_TIMEOUT | KMSG_CENTER_ALIGN, + abortTimers, timeout, quoteStr); +} + +void KernelMessages::scrollMessage(int msgIndex, int numTicks, bool quoted) { + if (msgIndex < 0) + return; + + _entries[msgIndex]._flags |= quoted ? (KMSG_SCROLL | KMSG_QUOTED) : KMSG_SCROLL; + _entries[msgIndex]._msgOffset = 0; + _entries[msgIndex]._numTicks = numTicks; + _entries[msgIndex]._frameTimer2 = _vm->_game->_priorFrameTimer; + + Common::String msg = _entries[msgIndex]._msg; + + if (_entries[msgIndex]._flags & KMSG_PLAYER_TIMEOUT) + _entries[msgIndex]._frameTimer2 = _vm->_game->_player._ticksAmount + + _vm->_game->_player._priorTimer; + + _entries[msgIndex]._frameTimer = _entries[msgIndex]._frameTimer2; +} + +void KernelMessages::setSeqIndex(int msgIndex, int seqIndex) { + if (msgIndex >= 0) { + _entries[msgIndex]._flags |= KMSG_SEQ_ENTRY; + _entries[msgIndex]._sequenceIndex = seqIndex; + } +} + +void KernelMessages::remove(int msgIndex) { + KernelMessage &rec = _entries[msgIndex]; + Scene &scene = _vm->_game->_scene; + + if (rec._flags & KMSG_ACTIVE) { + if (rec._flags & KMSG_SCROLL) { + // WORKAROUND: Code here no longer needed in ScummVM + } + + if (rec._textDisplayIndex >= 0) + scene._textDisplay.expire(rec._textDisplayIndex); + + rec._flags &= ~KMSG_ACTIVE; + } +} + +void KernelMessages::reset() { + for (uint i = 0; i < _entries.size(); ++i) + remove(i); + + _talkFont = _vm->_font->getFont(FONT_CONVERSATION); + _randomMessages.clear(); +} + +void KernelMessages::update() { + uint32 currentTimer = _vm->_game->_scene._frameStartTime; + + for (uint i = 0; i < _entries.size() && !_vm->_game->_trigger; ++i) { + KernelMessage &msg = _entries[i]; + + if (((msg._flags & KMSG_ACTIVE) != 0) && (currentTimer >= msg._frameTimer)) + processText(i); + } +} + +void KernelMessages::processText(int msgIndex) { + Scene &scene = _vm->_game->_scene; + KernelMessage &msg = _entries[msgIndex]; + uint32 currentTimer = _vm->_game->_priorFrameTimer; + bool flag = false; + + if ((msg._flags & KMSG_EXPIRE) != 0) { + scene._textDisplay.expire(msg._textDisplayIndex); + msg._flags &= !KMSG_ACTIVE; + return; + } + + if ((msg._flags & KMSG_SCROLL) == 0) { + msg._timeout -= 3; + } + + if (msg._flags & KMSG_SEQ_ENTRY) { + SequenceEntry &seqEntry = scene._sequences[msg._sequenceIndex]; + if (seqEntry._doneFlag || !seqEntry._active) + msg._timeout = 0; + } + + if ((msg._timeout <= 0) && (_vm->_game->_trigger == 0)) { + msg._flags |= KMSG_EXPIRE; + if (msg._trigger != 0) { + _vm->_game->_trigger = msg._trigger; + _vm->_game->_triggerMode = msg._abortMode; + + if (_vm->_game->_triggerMode != SEQUENCE_TRIGGER_DAEMON) { + scene._action._activeAction = msg._actionDetails; + } + } + } + + msg._frameTimer = currentTimer + 3; + int x1 = 0, y1 = 0; + + if (msg._flags & KMSG_SEQ_ENTRY) { + SequenceEntry &seqEntry = scene._sequences[msg._sequenceIndex]; + if (!seqEntry._nonFixed) { + SpriteAsset &spriteSet = *scene._sprites[seqEntry._spritesIndex]; + MSprite *frame = spriteSet.getFrame(seqEntry._frameIndex - 1); + x1 = frame->getBounds().left; + y1 = frame->getBounds().top; + } else { + x1 = seqEntry._position.x; + y1 = seqEntry._position.y; + } + } + + Player &player = _vm->_game->_player; + if (msg._flags & KMSG_PLAYER_TIMEOUT) { + if (player._beenVisible) { + SpriteAsset &asset = *_vm->_game->_scene._sprites[player._spritesStart + player._spritesIdx]; + MSprite *frame = asset.getFrame(player._frameNumber - 1); + + int yAmount = player._currentScale * player._centerOfGravity / 100; + x1 = player._playerPos.x; + y1 = (frame->h * player._currentScale / -100) + yAmount + + player._playerPos.y - 15; + } else { + x1 = 160; + y1 = 78; + } + } + + x1 += msg._position.x; + y1 += msg._position.y; + + Common::String displayMsg = msg._msg; + + if ((msg._flags & KMSG_SCROLL) && (msg._frameTimer >= currentTimer)) { + ++msg._msgOffset; + + if (msg._msgOffset >= msg._msg.size()) { + // End of message + msg._flags &= ~KMSG_SCROLL; + } else { + displayMsg = Common::String(msg._msg.c_str(), msg._msg.c_str() + msg._msgOffset); + } + + msg._frameTimer = msg._frameTimer2 = currentTimer + msg._numTicks; + flag = true; + } + + int strWidth = _talkFont->getWidth(displayMsg, scene._textSpacing); + + if (msg._flags & (KMSG_RIGHT_ALIGN | KMSG_CENTER_ALIGN)) { + x1 -= (msg._flags & KMSG_CENTER_ALIGN) ? strWidth / 2 : strWidth; + } + + // Make sure text appears entirely on-screen + int x2 = x1 + strWidth; + if (x2 > MADS_SCREEN_WIDTH) + x1 -= x2 - MADS_SCREEN_WIDTH; + if (x1 > (MADS_SCREEN_WIDTH - 1)) + x1 = MADS_SCREEN_WIDTH - 1; + if (x1 < 0) + x1 = 0; + + if (y1 >(MADS_SCENE_HEIGHT - 1)) + y1 = MADS_SCENE_HEIGHT - 1; + if (y1 < 0) + y1 = 0; + + if (msg._textDisplayIndex >= 0) { + TextDisplay &textEntry = scene._textDisplay[msg._textDisplayIndex]; + + if (flag || (textEntry._bounds.left != x1) || (textEntry._bounds.top != y1)) { + // Mark the associated text entry as deleted, so it can be re-created + scene._textDisplay.expire(msg._textDisplayIndex); + msg._textDisplayIndex = -1; + } + } + + if (msg._textDisplayIndex < 0) { + // Need to create a new text display entry for this message + int idx = scene._textDisplay.add(x1, y1, msg._color1 | (msg._color2 << 8), + scene._textSpacing, displayMsg, _talkFont); + if (idx >= 0) + msg._textDisplayIndex = idx; + } +} + +void KernelMessages::delay(uint32 priorFrameTime, uint32 currentTime) { + for (uint i = 0; i < _entries.size(); ++i) { + _entries[i]._timeout += currentTime - priorFrameTime; + } +} + +void KernelMessages::setQuoted(int msgIndex, int numTicks, bool quoted) { + if (msgIndex >= 0) { + KernelMessage &msg = _entries[msgIndex]; + + msg._flags |= KMSG_SCROLL; + if (quoted) + msg._flags |= KMSG_QUOTED; + + msg._msgOffset = 0; + msg._numTicks = numTicks; + msg._frameTimer2 = _vm->_game->_scene._frameStartTime; + + if (msg._flags & KMSG_PLAYER_TIMEOUT) { + msg._frameTimer2 = _vm->_game->_player._priorTimer + + _vm->_game->_player._ticksAmount; + } + + msg._frameTimer = msg._frameTimer2; + } +} + +#define RANDOM_MESSAGE_TRIGGER 240 + +void KernelMessages::randomServer() { + if ((_vm->_game->_trigger >= RANDOM_MESSAGE_TRIGGER) && + (_vm->_game->_trigger < (RANDOM_MESSAGE_TRIGGER + (int)_randomMessages.size()))) { + _randomMessages[_vm->_game->_trigger - RANDOM_MESSAGE_TRIGGER]._handle = -1; + _randomMessages[_vm->_game->_trigger - RANDOM_MESSAGE_TRIGGER]._quoteId = -1; + } +} + +int KernelMessages::checkRandom() { + int total = 0; + + for (uint i = 0; i < _randomMessages.size(); ++i) { + if (_randomMessages[i]._handle >= 0) + ++total; + } + + return total; +} + +bool KernelMessages::generateRandom(int major, int minor) { + bool generatedMessage = false; + + // Scan through the random messages array + for (uint msgCtr = 0; msgCtr < _randomMessages.size(); msgCtr++) { + // Find currently active random messages + if (_randomMessages[msgCtr]._handle < 0) { + // Check whether there's any existing 'scrolling in' message + bool bad = false; + for (uint scanCtr = 0; scanCtr < _randomMessages.size(); ++scanCtr) { + if (_randomMessages[scanCtr]._handle >= 0) { + if (_entries[_randomMessages[scanCtr]._handle]._flags & KMSG_SCROLL) { + bad = true; + break; + } + } + } + + // Do a random check for a new message to appear + if (_vm->getRandomNumber(major) <= minor && !bad) { + int quoteId; + + // Pick a random quote to display from the available list + do { + int quoteIdx = _vm->getRandomNumber(_randomQuotes.size() - 1); + quoteId = _randomQuotes[quoteIdx]; + + // Ensure the quote isn't already in use + bad = false; + for (uint scanCtr = 0; scanCtr < _randomMessages.size(); ++scanCtr) { + if (quoteId == _randomMessages[scanCtr]._quoteId) { + bad = true; + break; + } + } + } while (bad); + + // Store the quote Id to be used + _randomMessages[msgCtr]._quoteId = quoteId; + + // Position the message at a random position + Common::Point textPos; + textPos.x = _vm->getRandomNumber(_randomMessages._bounds.left, + _randomMessages._bounds.right); + + // Figure out Y position, making sure not to be overlapping with + // any other on-screen message + int abortCounter = 0; + + do { + // Ensure we don't get stuck in an infinite loop if too many messages + // are alrady on-screen + if (abortCounter++ > 100) goto done; + bad = false; + + // Set potential new Y position + textPos.y = _vm->getRandomNumber(_randomMessages._bounds.top, + _randomMessages._bounds.bottom); + + // Ensure it doesn't overlap an existing on-screen message + for (uint msgCtr2 = 0; msgCtr2 < _randomMessages.size(); ++msgCtr2) { + if (_randomMessages[msgCtr2]._handle >= 0) { + int lastY = _entries[_randomMessages[msgCtr2]._handle]._position.y; + + if ((textPos.y >= (lastY - _randomMessages._randomSpacing)) && + (textPos.y <= (lastY + _randomMessages._randomSpacing))) { + bad = true; + } + } + } + } while (bad); + + // Add the message + _randomMessages[msgCtr]._handle = add(textPos, _randomMessages._color, 0, + RANDOM_MESSAGE_TRIGGER + msgCtr, _randomMessages._duration, + _vm->_game->getQuote(_randomMessages[msgCtr]._quoteId)); + + if (_randomMessages._scrollRate > 0) { + if (_randomMessages[msgCtr]._handle >= 0) { + setQuoted(_randomMessages[msgCtr]._handle, + _randomMessages._scrollRate, true); + } + } + + generatedMessage = true; + break; + } + } + } + +done: + return generatedMessage; +} + +void KernelMessages::initRandomMessages(int maxSimultaneousMessages, + const Common::Rect &bounds, int minYSpacing, int scrollRate, + int color, int duration, int quoteId, ...) { + // Reset the random messages list + _randomMessages.clear(); + _randomMessages.resize(maxSimultaneousMessages); + + // Store passed parameters + _randomMessages._bounds = bounds; + _randomMessages._randomSpacing = minYSpacing; + _randomMessages._scrollRate = scrollRate; + _randomMessages._color = color; + _randomMessages._duration = duration; + + // Store the variable length random quote list + va_list va; + va_start(va, quoteId); + _randomQuotes.clear(); + + while (quoteId > 0) { + _randomQuotes.push_back(quoteId); + assert(_randomQuotes.size() < 100); + quoteId = va_arg(va, int); + } + + va_end(va); +} + + +/*------------------------------------------------------------------------*/ + +TextDisplay::TextDisplay() { + _active = false; + _expire = 0; + _spacing = 0; + _color1 = 0; + _color2 = 0; + _font = nullptr; +} + +/*------------------------------------------------------------------------*/ + +TextDisplayList::TextDisplayList(MADSEngine *vm) : _vm(vm) { + for (int i = 0; i < TEXT_DISPLAY_SIZE; ++i) { + TextDisplay rec; + rec._active = false; + rec._expire = 0; + push_back(rec); + } +} + +void TextDisplayList::reset() { + for (int i = 0; i < TEXT_DISPLAY_SIZE; ++i) + (*this)[i]._active = false; +} + +int TextDisplayList::add(int xp, int yp, uint fontColor, int charSpacing, + const Common::String &msg, Font *font) { + int usedSlot = -1; + + for (int idx = 0; idx < TEXT_DISPLAY_SIZE; ++idx) { + TextDisplay &td = (*this)[idx]; + if (!td._active) { + usedSlot = idx; + + td._bounds.left = xp; + td._bounds.top = yp; + td._font = font; + td._msg = msg; + td._bounds.setWidth(font->getWidth(msg, charSpacing)); + td._bounds.setHeight(font->getHeight()); + td._color1 = fontColor & 0xff; + td._color2 = fontColor >> 8; + td._spacing = charSpacing; + td._expire = 1; + td._active = true; + break; + } + } + + return usedSlot; +} + +void TextDisplayList::setDirtyAreas() { + Scene &scene = _vm->_game->_scene; + + for (uint idx = 0, dirtyIdx = SPRITE_SLOTS_MAX_SIZE; dirtyIdx < size(); ++idx, ++dirtyIdx) { + if (((*this)[idx]._expire >= 0) || !(*this)[idx]._active) { + scene._dirtyAreas[dirtyIdx]._active = false; + } else { + scene._dirtyAreas[dirtyIdx]._textActive = true; + scene._dirtyAreas[dirtyIdx].setTextDisplay(&(*this)[idx]); + } + } +} + +void TextDisplayList::setDirtyAreas2() { + Scene &scene = _vm->_game->_scene; + + for (uint idx = 0, dirtyIdx = SPRITE_SLOTS_MAX_SIZE; idx < size(); ++idx, ++dirtyIdx) { + if ((*this)[idx]._active && ((*this)[idx]._expire >= 0)) { + scene._dirtyAreas[dirtyIdx].setTextDisplay(&(*this)[idx]); + scene._dirtyAreas[dirtyIdx]._textActive = ((*this)[idx]._expire <= 0) ? 0 : 1; + } + } +} + +void TextDisplayList::draw(MSurface *s) { + for (uint idx = 0; idx < size(); ++idx) { + TextDisplay &td = (*this)[idx]; + if (td._active && (td._expire >= 0)) { + td._font->setColors(0xFF, td._color1, td._color2, 0); + td._font->writeString(s, td._msg, + Common::Point(td._bounds.left, td._bounds.top), + td._spacing, td._bounds.width()); + } + } +} + +void TextDisplayList::cleanUp() { + for (uint idx = 0; idx < size(); ++idx) { + if ((*this)[idx]._expire < 0) { + (*this)[idx]._active = false; + (*this)[idx]._expire = 0; + } + } +} + +void TextDisplayList::expire(int idx) { + (*this)[idx]._expire = -1; +} + +} // End of namespace MADS diff --git a/engines/mads/messages.h b/engines/mads/messages.h new file mode 100644 index 0000000000..241f493434 --- /dev/null +++ b/engines/mads/messages.h @@ -0,0 +1,192 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_MESSAGES_H +#define MADS_MESSAGES_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "mads/action.h" +#include "mads/font.h" +#include "mads/msurface.h" + +namespace MADS { + +#define KERNEL_MESSAGES_SIZE 10 +#define INDEFINITE_TIMEOUT 9999999 +#define TEXT_DISPLAY_SIZE 40 +#define RANDOM_MESSAGE_SIZE 4 + +enum KernelMessageFlags { + KMSG_QUOTED = 1, KMSG_PLAYER_TIMEOUT = 2, KMSG_SEQ_ENTRY = 4, KMSG_SCROLL = 8, + KMSG_RIGHT_ALIGN = 0x10, KMSG_CENTER_ALIGN = 0x20, KMSG_EXPIRE = 0x40, + KMSG_ACTIVE = 0x80 +}; + +class MADSEngine; + +class KernelMessage { +public: + uint8 _flags; + int _sequenceIndex; + int _color1; + int _color2; + Common::Point _position; + int _textDisplayIndex; + uint32 _msgOffset; + int _numTicks; + uint32 _frameTimer2; + uint32 _frameTimer; + int32 _timeout; + int _trigger; + TriggerMode _abortMode; + ActionDetails _actionDetails; + Common::String _msg; + + KernelMessage(); +}; + +struct RandomEntry { + int _handle; + int _quoteId; + + RandomEntry() { _handle = _quoteId = -1; } +}; + +class RandomMessages: public Common::Array<RandomEntry> { +public: + Common::Rect _bounds; + int _randomSpacing; + int _color; + int _duration; + int _scrollRate; +public: + RandomMessages(); + + void reset(); +}; + +class KernelMessages { +private: + MADSEngine *_vm; + + Common::Array<int> _randomQuotes; + RandomMessages _randomMessages; +public: + Common::Array<KernelMessage> _entries; + Font *_talkFont; +public: + KernelMessages(MADSEngine *vm); + ~KernelMessages(); + + void clear(); + int add(const Common::Point &pt, uint fontColor, uint8 flags, uint8 abortTimers, + uint32 timeout, const Common::String &msg); + int addQuote(int quoteId, int abortTimers, uint32 timeout); + void scrollMessage(int msgIndex, int numTicks, bool quoted); + void setSeqIndex(int msgIndex, int seqIndex); + void remove(int msgIndex); + void reset(); + void update(); + void processText(int msgIndex); + void delay(uint32 priorFrameTime, uint32 currentTime); + void setQuoted(int msgIndex, int numTicks, bool quoted); + + void initRandomMessages(int maxSimultaneousMessages, + const Common::Rect &bounds, int minYSpacing, int scrollRate, + int color, int duration, int quoteId, ...); + + /** + * Handles expiring any active random messages as necessary + */ + void randomServer(); + + /** + * Return the number of currently active random messages + */ + int checkRandom(); + + /** + * Handles generating new random messages + */ + bool generateRandom(int major, int minor); +}; + +class TextDisplay { +public: + bool _active; + int _expire; + int _spacing; + Common::Rect _bounds; + uint8 _color1; + uint8 _color2; + Font *_font; + Common::String _msg; + + TextDisplay(); +}; + +#define TEXT_DISPLAY_SIZE 40 + +class TextDisplayList: public Common::Array<TextDisplay> { +private: + MADSEngine *_vm; +public: + TextDisplayList(MADSEngine *vm); + + /** + * Expire a given text display entry + */ + void expire(int idx); + + int add(int xp, int yp, uint fontColor, int charSpacing, const Common::String &, Font *font); + + /** + * Reset all of the text display entries in the list to inactive + */ + void reset(); + + /** + * Draw any text in the list to the specified surface + * @param surface Surface + */ + void draw(MSurface *s); + + /** + * Determine dirty areas for active text areas + */ + void setDirtyAreas(); + + /** + * Secondary setup dirty areas for the text areas + */ + void setDirtyAreas2(); + + /** + * Deactivates any text display entries that are finished + */ + void cleanUp(); +}; + +} // End of namespace MADS + +#endif /* MADS_MESSAGES_H */ diff --git a/engines/mads/module.mk b/engines/mads/module.mk new file mode 100644 index 0000000000..61e810e215 --- /dev/null +++ b/engines/mads/module.mk @@ -0,0 +1,58 @@ +MODULE := engines/mads + +MODULE_OBJS := \ + dragonsphere/game_dragonsphere.o \ + dragonsphere/dragonsphere_scenes.o \ + phantom/game_phantom.o \ + phantom/phantom_scenes.o \ + nebular/dialogs_nebular.o \ + nebular/game_nebular.o \ + nebular/globals_nebular.o \ + nebular/sound_nebular.o \ + nebular/nebular_scenes.o \ + nebular/nebular_scenes1.o \ + nebular/nebular_scenes2.o \ + nebular/nebular_scenes3.o \ + nebular/nebular_scenes4.o \ + nebular/nebular_scenes5.o \ + nebular/nebular_scenes6.o \ + nebular/nebular_scenes7.o \ + nebular/nebular_scenes8.o \ + action.o \ + animation.o \ + assets.o \ + audio.o \ + compression.o \ + debugger.o \ + detection.o \ + dialogs.o \ + events.o \ + font.o \ + game.o \ + game_data.o \ + globals.o \ + hotspots.o \ + inventory.o \ + mads.o \ + messages.o \ + msurface.o \ + palette.o \ + player.o \ + rails.o \ + resources.o \ + scene.o \ + scene_data.o \ + screen.o \ + sequence.o \ + sound.o \ + sprites.o \ + staticres.o \ + user_interface.o + +# This module can be built as a plugin +ifeq ($(ENABLE_MADS), DYNAMIC_PLUGIN) +PLUGIN := 1 +endif + +# Include common rules +include $(srcdir)/rules.mk diff --git a/engines/mads/msurface.cpp b/engines/mads/msurface.cpp new file mode 100644 index 0000000000..6d74fefaab --- /dev/null +++ b/engines/mads/msurface.cpp @@ -0,0 +1,551 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "engines/util.h" +#include "mads/compression.h" +#include "mads/screen.h" +#include "mads/mads.h" +#include "mads/msurface.h" +#include "mads/resources.h" +#include "mads/sprites.h" + +namespace MADS { + +MADSEngine *MSurface::_vm = nullptr; + +MSurface::MSurface() { + pixels = nullptr; + _freeFlag = false; +} + +MSurface::MSurface(int width, int height) { + pixels = nullptr; + _freeFlag = false; + setSize(width, height); +} + +MSurface::~MSurface() { + if (_freeFlag) + Graphics::Surface::free(); +} + +void MSurface::setSize(int width, int height) { + if (_freeFlag) + Graphics::Surface::free(); + Graphics::Surface::create(width, height, Graphics::PixelFormat::createFormatCLUT8()); + _freeFlag = true; +} + +void MSurface::setPixels(byte *pData, int horizSize, int vertSize) { + _freeFlag = false; + pixels = pData; + w = pitch = horizSize; + h = vertSize; + format.bytesPerPixel = 1; +} + +int MSurface::scaleValue(int value, int scale, int err) { + int scaled = 0; + while (value--) { + err -= scale; + while (err < 0) { + scaled++; + err += 100; + } + } + return scaled; +} + +void MSurface::drawSprite(const Common::Point &pt, SpriteInfo &info, const Common::Rect &clipRect) { + + enum { + kStatusSkip, + kStatusScale, + kStatusDraw + }; + + // NOTE: The current clipping code assumes that the top left corner of the clip + // rectangle is always 0, 0 + assert(clipRect.top == 0 && clipRect.left == 0); + + // TODO: Put err* and scaled* into SpriteInfo + int errX = info.hotX * info.scaleX % 100; + int errY = info.hotY * info.scaleY % 100; + int scaledWidth = scaleValue(info.width, info.scaleX, errX); + int scaledHeight = scaleValue(info.height, info.scaleY, errY); + + int x = pt.x, y = pt.y; + int clipX = 0, clipY = 0; + // Clip the sprite's width and height according to the clip rectangle's dimensions + // This clips the sprite to the bottom and right + if (x >= 0) { + scaledWidth = MIN<int>(x + scaledWidth, clipRect.right) - x; + } else { + clipX = x; + scaledWidth = x + scaledWidth; + } + if (y >= 0) { + scaledHeight = MIN<int>(y + scaledHeight, clipRect.bottom) - y; + } else { + clipY = y; + scaledHeight = y + scaledHeight; + } + + // Check if sprite is inside the screen. If it's not, there's no need to draw it + if (scaledWidth + x <= 0 || scaledHeight + y <= 0) // check left and top (in case x,y are negative) + return; + if (scaledWidth <= 0 || scaledHeight <= 0) // check right and bottom + return; + int heightAmt = scaledHeight; + + byte *src = info.sprite->getData(); + byte *dst = getBasePtr(x - info.hotX - clipX, y - info.hotY - clipY); + + int status = kStatusSkip; + byte *scaledLineBuf = new byte[scaledWidth]; + + while (heightAmt > 0) { + + if (status == kStatusSkip) { + // Skip line + errY -= info.scaleY; + if (errY < 0) + status = kStatusScale; + else + src += info.width; + } else { + + if (status == kStatusScale) { + // Scale current line + byte *lineDst = scaledLineBuf; + int curErrX = errX; + int width = scaledWidth; + byte *tempSrc = src; + int startX = clipX; + while (width > 0) { + byte pixel = *tempSrc++; + curErrX -= info.scaleX; + while (curErrX < 0) { + if (startX == 0) { + *lineDst++ = pixel; + width--; + } else { + startX++; + } + curErrX += 100; + } + } + src += info.width; + status = kStatusDraw; + } + + if (status == kStatusDraw && clipY == 0) { + // Draw previously scaled line + // TODO Implement different drawing types (depth, shadow etc.) + byte *tempDst = dst; + for (int lineX = 0; lineX < scaledWidth; lineX++) { + byte pixel = scaledLineBuf[lineX]; + + if (info.encoding & 0x80) { + + if (pixel == 0x80) { + pixel = 0; + } else { + byte destPixel = *tempDst; + byte r, g, b; + r = CLIP((info.palette[destPixel * 3] * pixel) >> 10, 0, 31); + g = CLIP((info.palette[destPixel * 3 + 1] * pixel) >> 10, 0, 31); + b = CLIP((info.palette[destPixel * 3 + 2] * pixel) >> 10, 0, 31); + pixel = info.inverseColorTable[(b << 10) | (g << 5) | r]; + } + } + + if (pixel) + *tempDst = pixel; + + tempDst++; + } + dst += pitch; + heightAmt--; + // TODO depth etc. + //depthAddress += Destination -> Width; + + errY += 100; + if (errY >= 0) + status = kStatusSkip; + } else if (status == kStatusDraw && clipY < 0) { + clipY++; + + errY += 100; + if (errY >= 0) + status = kStatusSkip; + } + + } + + } + + delete[] scaledLineBuf; + +} + +void MSurface::empty() { + Common::fill(getBasePtr(0, 0), getBasePtr(0, h), 0); +} + +void MSurface::copyFrom(MSurface *src, const Common::Rect &srcBounds, + const Common::Point &destPos, int transparentColor) { + // Validation of the rectangle and position + int destX = destPos.x, destY = destPos.y; + if ((destX >= w) || (destY >= h)) + return; + + Common::Rect copyRect = srcBounds; + if (destX < 0) { + copyRect.left += -destX; + destX = 0; + } else if (destX + copyRect.width() > w) { + copyRect.right -= destX + copyRect.width() - w; + } + if (destY < 0) { + copyRect.top += -destY; + destY = 0; + } else if (destY + copyRect.height() > h) { + copyRect.bottom -= destY + copyRect.height() - h; + } + + if (!copyRect.isValidRect()) + return; + + // Copy the specified area + + byte *data = src->getData(); + byte *srcPtr = data + (src->getWidth() * copyRect.top + copyRect.left); + byte *destPtr = (byte *)pixels + (destY * getWidth()) + destX; + + for (int rowCtr = 0; rowCtr < copyRect.height(); ++rowCtr) { + if (transparentColor == -1) { + // No transparency, so copy line over + Common::copy(srcPtr, srcPtr + copyRect.width(), destPtr); + } else { + // Copy each byte one at a time checking for the transparency color + for (int xCtr = 0; xCtr < copyRect.width(); ++xCtr) + if (srcPtr[xCtr] != transparentColor) destPtr[xCtr] = srcPtr[xCtr]; + } + + srcPtr += src->getWidth(); + destPtr += getWidth(); + } +} + +void MSurface::copyFrom(MSurface *src, const Common::Point &destPos, int depth, + DepthSurface *depthSurface, int scale, int transparentColor) { + + int destX = destPos.x, destY = destPos.y; + if (scale == 100) { + // Copy the specified area + Common::Rect copyRect(0, 0, src->getWidth(), src->getHeight()); + + if (destX < 0) { + copyRect.left += -destX; + destX = 0; + } + else if (destX + copyRect.width() > w) { + copyRect.right -= destX + copyRect.width() - w; + } + if (destY < 0) { + copyRect.top += -destY; + destY = 0; + } + else if (destY + copyRect.height() > h) { + copyRect.bottom -= destY + copyRect.height() - h; + } + + if (!copyRect.isValidRect()) + return; + + byte *data = src->getData(); + byte *srcPtr = data + (src->getWidth() * copyRect.top + copyRect.left); + byte *destPtr = (byte *)pixels + (destY * pitch) + destX; + + // 100% scaling variation + for (int rowCtr = 0; rowCtr < copyRect.height(); ++rowCtr) { + // Copy each byte one at a time checking against the depth + for (int xCtr = 0; xCtr < copyRect.width(); ++xCtr) { + int pixelDepth = depthSurface == nullptr ? 15 : + depthSurface->getDepth(Common::Point(destX + xCtr, destY + rowCtr)); + if ((depth <= pixelDepth) && (srcPtr[xCtr] != transparentColor)) + destPtr[xCtr] = srcPtr[xCtr]; + } + + srcPtr += src->getWidth(); + destPtr += getWidth(); + } + + return; + } + + // Start of draw logic for scaled sprites + const byte *srcPixelsP = src->getData(); + + int destRight = this->getWidth() - 1; + int destBottom = this->getHeight() - 1; + bool normalFrame = true; + int frameWidth = src->getWidth(); + int frameHeight = src->getHeight(); + + int highestDim = MAX(frameWidth, frameHeight); + bool lineDist[MADS_SCREEN_WIDTH]; + int distIndex = 0; + int distXCount = 0, distYCount = 0; + + int distCtr = 0; + do { + distCtr += scale; + if (distCtr < 100) { + lineDist[distIndex] = false; + } else { + lineDist[distIndex] = true; + distCtr -= 100; + + if (distIndex < frameWidth) + ++distXCount; + + if (distIndex < frameHeight) + ++distYCount; + } + } while (++distIndex < highestDim); + + destX -= distXCount / 2; + destY -= distYCount - 1; + + // Check x bounding area + int spriteLeft = 0; + int spriteWidth = distXCount; + int widthAmount = destX + distXCount - 1; + + if (destX < 0) { + spriteWidth += destX; + spriteLeft -= destX; + } + widthAmount -= destRight; + if (widthAmount > 0) + spriteWidth -= widthAmount; + + int spriteRight = spriteLeft + spriteWidth; + if (spriteWidth <= 0) + return; + if (!normalFrame) { + destX += distXCount - 1; + spriteLeft = -(distXCount - spriteRight); + spriteRight = (-spriteLeft + spriteWidth); + } + + // Check y bounding area + int spriteTop = 0; + int spriteHeight = distYCount; + int heightAmount = destY + distYCount - 1; + + if (destY < 0) { + spriteHeight += destY; + spriteTop -= destY; + } + heightAmount -= destBottom; + if (heightAmount > 0) + spriteHeight -= heightAmount; + int spriteBottom = spriteTop + spriteHeight; + + if (spriteHeight <= 0) + return; + + byte *destPixelsP = this->getBasePtr(destX + spriteLeft, destY + spriteTop); + + spriteLeft = (spriteLeft * (normalFrame ? 1 : -1)); + + // Loop through the lines of the sprite + for (int yp = 0, sprY = -1; yp < frameHeight; ++yp, srcPixelsP += src->pitch) { + if (!lineDist[yp]) + // Not a display line, so skip it + continue; + // Check whether the sprite line is in the display range + ++sprY; + if ((sprY >= spriteBottom) || (sprY < spriteTop)) + continue; + + // Found a line to display. Loop through the pixels + const byte *srcP = srcPixelsP; + byte *destP = destPixelsP; + + for (int xp = 0, sprX = 0; xp < frameWidth; ++xp, ++srcP) { + if (xp < spriteLeft) + // Not yet reached start of display area + continue; + if (!lineDist[sprX++]) + // Not a display pixel + continue; + + // Get depth of current output pixel in depth surface + Common::Point pt((destP - (byte *)this->pixels) % this->pitch, + (destP - (byte *)this->pixels) / this->pitch); + int pixelDepth = (depthSurface == nullptr) ? 15 : depthSurface->getDepth(pt); + + if ((*srcP != transparentColor) && (depth <= pixelDepth)) + *destP = *srcP; + + ++destP; + } + + // Move to the next destination line + destPixelsP += this->pitch; + } +} + +void MSurface::scrollX(int xAmount) { + if (xAmount == 0) + return; + + byte buffer[80]; + int direction = (xAmount > 0) ? -1 : 1; + int xSize = ABS(xAmount); + assert(xSize <= 80); + + byte *srcP = getBasePtr(0, 0); + + for (int y = 0; y < this->h; ++y, srcP += pitch) { + if (direction < 0) { + // Copy area to be overwritten + Common::copy(srcP, srcP + xSize, &buffer[0]); + // Shift the remainder of the line over the given area + Common::copy(srcP + xSize, srcP + this->w, srcP); + // Move buffered area to the end of the line + Common::copy(&buffer[0], &buffer[xSize], srcP + this->w - xSize); + } else { + // Copy area to be overwritten + Common::copy_backward(srcP + this->w - xSize, srcP + this->w, &buffer[80]); + // Shift the remainder of the line over the given area + Common::copy_backward(srcP, srcP + this->w - xSize, srcP + this->w); + // Move buffered area to the start of the line + Common::copy_backward(&buffer[80 - xSize], &buffer[80], srcP + xSize); + } + } +} + +void MSurface::scrollY(int yAmount) { + if (yAmount == 0) + return; + + int direction = (yAmount > 0) ? 1 : -1; + int ySize = ABS(yAmount); + assert(ySize < (this->h / 2)); + assert(this->w == pitch); + + int blockSize = ySize * this->w; + byte *tempData = new byte[blockSize]; + byte *pixelsP = getBasePtr(0, 0); + + if (direction > 0) { + // Buffer the lines to be overwritten + byte *srcP = (byte *)getBasePtr(0, this->h - ySize); + Common::copy(srcP, srcP + (pitch * ySize), tempData); + // Vertically shift all the lines + Common::copy_backward(pixelsP, pixelsP + (pitch * (this->h - ySize)), + pixelsP + (pitch * this->h)); + // Transfer the buffered lines top the top of the screen + Common::copy(tempData, tempData + blockSize, pixelsP); + } else { + // Buffer the lines to be overwritten + Common::copy(pixelsP, pixelsP + (pitch * ySize), tempData); + // Vertically shift all the lines + Common::copy(pixelsP + (pitch * ySize), pixelsP + (pitch * this->h), pixelsP); + // Transfer the buffered lines to the bottom of the screen + Common::copy(tempData, tempData + blockSize, pixelsP + (pitch * (this->h - ySize))); + } + + delete[] tempData; +} + + +void MSurface::translate(Common::Array<RGB6> &palette) { + for (int y = 0; y < this->h; ++y) { + byte *pDest = getBasePtr(0, y); + + for (int x = 0; x < this->w; ++x, ++pDest) { + if (*pDest < 255) // scene 752 has some palette indices of 255 + *pDest = palette[*pDest]._palIndex; + } + } +} + +void MSurface::translate(byte map[PALETTE_COUNT]) { + for (int y = 0; y < this->h; ++y) { + byte *pDest = getBasePtr(0, y); + + for (int x = 0; x < this->w; ++x, ++pDest) { + *pDest = map[*pDest]; + } + } +} + +MSurface *MSurface::flipHorizontal() const { + MSurface *dest = new MSurface(this->w, this->h); + + for (int y = 0; y < this->h; ++y) { + const byte *srcP = getBasePtr(this->w - 1, y); + byte *destP = dest->getBasePtr(0, y); + + for (int x = 0; x < this->w; ++x) + *destP++ = *srcP--; + } + + return dest; +} + +/*------------------------------------------------------------------------*/ + +int DepthSurface::getDepth(const Common::Point &pt) { + if (_vm->_game->_scene._sceneInfo->_depthStyle == 2) { + int bits = (3 - (pt.x % 4)) * 2; + byte v = *getBasePtr(pt.x >> 2, pt.y); + return v >> bits; + } else { + if (pt.x < 0 || pt.y < 0 || pt.x >= this->w || pt.y >= this->h) + return 0; + + return *getBasePtr(pt.x, pt.y) & 0xF; + } +} + +int DepthSurface::getDepthHighBit(const Common::Point &pt) { + if (_vm->_game->_scene._sceneInfo->_depthStyle == 2) { + int bits = (3 - (pt.x % 4)) * 2; + byte v = *getBasePtr(pt.x >> 2, pt.y); + return (v >> bits) & 2; + } else { + if (pt.x < 0 || pt.y < 0 || pt.x >= this->w || pt.y >= this->h) + return 0; + + return *getBasePtr(pt.x, pt.y) & 0x80; + } +} + + +} // End of namespace MADS diff --git a/engines/mads/msurface.h b/engines/mads/msurface.h new file mode 100644 index 0000000000..e3cf89d649 --- /dev/null +++ b/engines/mads/msurface.h @@ -0,0 +1,240 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_MSURFACE_H +#define MADS_MSURFACE_H + +#include "common/scummsys.h" +#include "common/rect.h" +#include "graphics/surface.h" +#include "mads/palette.h" + +namespace MADS { + +class MADSEngine; +class MSprite; +class DepthSurface; + +/** + * Basic sprite information + */ +struct SpriteInfo { + MSprite *sprite; + int hotX, hotY; + int width, height; + int scaleX, scaleY; + uint8 encoding; + byte *inverseColorTable; + byte *palette; +}; + +/* + * MADS graphics surface + */ +class MSurface : public Graphics::Surface { +private: + bool _freeFlag; +protected: + static MADSEngine *_vm; +public: + /** + * Sets the engine refrence used all surfaces + */ + static void setVm(MADSEngine *vm) { _vm = vm; } + + /** + * Helper method for calculating new dimensions when scaling a sprite + */ + static int scaleValue(int value, int scale, int err); +public: + /** + * Basic constructor + */ + MSurface(); + + /** + * Constructor for a surface with fixed dimensions + */ + MSurface(int width, int height); + + /** + * Destructor + */ + virtual ~MSurface(); + + /** + * Reinitialises a surface to have a given set of dimensions + */ + void setSize(int width, int height); + + /** + * Sets the pixels the surface is associated with + * @remarks The surface will not free the data block + */ + void setPixels(byte *pData, int horizSize, int vertSize); + + /** + * Draws an arbitrary line on the screen using a specified color + * @param startPos Starting position + * @param endPos Ending position + * @param color Color to use + */ + void line(const Common::Point &startPos, const Common::Point &endPos, byte color); + + /** + * Draws a sprite + * @param pt Position to draw sprite at + * @param info General sprite details + * @param clipRect Clipping rectangle to constrain sprite drawing within + */ + void drawSprite(const Common::Point &pt, SpriteInfo &info, const Common::Rect &clipRect); + + /** + * Returns the width of the surface + */ + int getWidth() const { return w; } + + /** + * Returns the height of the surface + */ + int getHeight() const { return h; } + + /** + * Returns the size of the surface as a Rect + */ + Common::Rect getBounds() const { + return Common::Rect(0, 0, w, h); + } + + /** + * Returns a pointer to the surface data + */ + byte *getData() { return (byte *)Graphics::Surface::getPixels(); } + + /** + * Returns a pointer to a given position within the surface + */ + byte *getBasePtr(int x, int y) { return (byte *)Graphics::Surface::getBasePtr(x, y); } + + /** + * Returns a pointer to a given position within the surface + */ + const byte *getBasePtr(int x, int y) const { return (const byte *)Graphics::Surface::getBasePtr(x, y); } + + /** + * Clears the surface + */ + void empty(); + + /** + * Copys a sub-section of another surface into the current one. + * @param src Source surface + * @param srcBounds Area of source surface to copy + * @param destPos Destination position to draw in current surface + * @param transparentColor Transparency palette index + */ + void copyFrom(MSurface *src, const Common::Rect &srcBounds, const Common::Point &destPos, + int transparentColor = -1); + + /** + * Copys a sub-section of another surface into the current one. + * @param src Source surface + * @param destPos Destination position to draw in current surface + * @param depth Depth of sprite + * @param depthSurface Depth surface to use with sprite depth + * @param transparentColor Transparency palette index + */ + void copyFrom(MSurface *src, const Common::Point &destPos, int depth, DepthSurface *depthSurface, + int scale, int transparentColor = -1); + + /** + * Copies the surface to a given destination surface + */ + void copyTo(MSurface *dest, int transparentColor = -1) { + dest->copyFrom(this, Common::Rect(w, h), Common::Point(), transparentColor); + } + + /** + * Copies the surface to a given destination surface + */ + void copyTo(MSurface *dest, const Common::Point &pt, int transparentColor = -1) { + dest->copyFrom(this, Common::Rect(w, h), pt, transparentColor); + } + + /** + * Copies the surface to a given destination surface + */ + void copyTo(MSurface *dest, const Common::Rect &srcBounds, const Common::Point &destPos, + int transparentColor = -1) { + dest->copyFrom(this, srcBounds, destPos, transparentColor); + } + + /** + * Scroll the screen horizontally by a given amount + * @param xAmount Horizontal amount + */ + void scrollX(int xAmount); + + /** + * Scroll the screen vertically by a given amount + * @param yAmount Vertical amount + */ + void scrollY(int yAmount); + + /** + * Translates the pixels of an image used the passed palette with RGB mapping + */ + void translate(Common::Array<RGB6> &palette); + + /** + * Translates the pixels of an image used the passed palette with RGB mapping + */ + void translate(byte map[PALETTE_COUNT]); + + /** + * Create a new surface which is a flipped horizontal copy of the current one + */ + MSurface *flipHorizontal() const; +}; + +class DepthSurface : public MSurface { +private: + MADSEngine *_vm; +public: + /** + * Constructor + */ + DepthSurface(MADSEngine *vm) : _vm(vm) {} + + /** + * Returns the depth at a given position + */ + int getDepth(const Common::Point &pt); + + /** + */ + int getDepthHighBit(const Common::Point &pt); +}; + +} // End of namespace MADS + +#endif /* MADS_MSURFACE_H */ diff --git a/engines/mads/nebular/dialogs_nebular.cpp b/engines/mads/nebular/dialogs_nebular.cpp new file mode 100644 index 0000000000..a4a7694d2c --- /dev/null +++ b/engines/mads/nebular/dialogs_nebular.cpp @@ -0,0 +1,693 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "common/config-manager.h" +#include "common/util.h" +#include "mads/mads.h" +#include "mads/screen.h" +#include "mads/msurface.h" +#include "mads/staticres.h" +#include "mads/nebular/dialogs_nebular.h" + +namespace MADS { + +namespace Nebular { + +bool DialogsNebular::show(int messageId, int objectId) { + MADSAction &action = _vm->_game->_scene._action; + Common::StringArray msg = _vm->_game->getMessage(messageId); + Common::String title; + Common::String commandText; + Common::String valStr; + Common::String dialogText; + bool result = true; + bool centerFlag = false; + bool underlineFlag = false; + bool commandFlag = false; + bool crFlag = false; + TextDialog *dialog = nullptr; + _dialogWidth = 17; + _capitalizationMode = kUppercase; + + // Loop through the lines of the returned text + for (uint idx = 0; idx < msg.size(); ++idx) { + Common::String srcLine = msg[idx]; + const char *srcP = srcLine.c_str(); + + // Loop through the text of the line + while (srcP < srcLine.c_str() + srcLine.size()) { + if (*srcP == '[') { + // Starting a command + commandText = ""; + commandFlag = true; + } else if (*srcP == ']') { + // Ending a command + if (commandFlag) { + if (commandCheck("CENTER", valStr, commandText)) { + centerFlag = true; + } else if (commandCheck("TITLE", valStr, commandText)) { + centerFlag = true; + underlineFlag = true; + crFlag = true; + int v = atoi(valStr.c_str()); + if (v != 0) + _dialogWidth = v; + } else if (commandCheck("CR", valStr, commandText)) { + if (centerFlag) { + crFlag = true; + } else { + if (objectId == -1) { + dialog = new TextDialog(_vm, FONT_INTERFACE, _defaultPosition, _dialogWidth); + } else { + dialog = new PictureDialog(_vm, _defaultPosition, _dialogWidth, objectId); + } + dialog->wordWrap(dialogText); + dialog->incNumLines(); + } + } else if (commandCheck("ASK", valStr, commandText)) { + dialog->addInput(); + } else if (commandCheck("VERB", valStr, commandText)) { + dialogText += getVocab(action._activeAction._verbId); + } else if (commandCheck("INDEX", valStr, commandText)) { + int idxLocal = atoi(valStr.c_str()); + if (_indexList[idxLocal]) + dialogText += getVocab(_indexList[idxLocal]); + } else if (commandCheck("NUMBER", valStr, commandText)) { + int idxLocal = atoi(valStr.c_str()); + dialogText += Common::String::format("%.4d", _indexList[idxLocal]); + } else if (commandCheck("NOUN1", valStr, commandText)) { + if (!textNoun(dialogText, 1, valStr)) + dialogText += getVocab(action._activeAction._objectNameId); + } else if (commandCheck("NOUN2", valStr, commandText)) { + if (!textNoun(dialogText, 2, valStr)) + dialogText += getVocab(action._activeAction._indirectObjectId); + } else if (commandCheck("PREP", valStr, commandText)) { + dialogText += kArticleList[action._savedFields._articleNumber]; + } else if (commandCheck("SENTENCE", valStr, commandText)) { + dialogText += action._sentence; + } else if (commandCheck("WIDTH", valStr, commandText)) { + _dialogWidth = atoi(valStr.c_str()); + } else if (commandCheck("BAR", valStr, commandText)) { + dialog->addBarLine(); + } else if (commandCheck("UNDER", valStr, commandText)) { + underlineFlag = true; + } else if (commandCheck("DOWN", valStr, commandText)) { + dialog->downPixelLine(); + } else if (commandCheck("TAB", valStr, commandText)) { + int xp = atoi(valStr.c_str()); + dialog->setLineXp(xp); + } + } + + commandFlag = false; + } else if (commandFlag) { + // Add the next character to the command + commandText += *srcP; + } else { + // Add to the text to be displayed in the dialog + dialogText += *srcP; + } + + ++srcP; + } + + if (!dialog) { + if (objectId == -1) { + dialog = new TextDialog(_vm, FONT_INTERFACE, _defaultPosition, _dialogWidth); + } else { + dialog = new PictureDialog(_vm, _defaultPosition, _dialogWidth, objectId); + } + } + + if (centerFlag) { + dialog->addLine(dialogText, underlineFlag); + if (crFlag) + dialog->incNumLines(); + } else { + dialog->wordWrap(dialogText); + } + + // Reset line processing flags in preparation for next line + dialogText = ""; + commandFlag = false; + underlineFlag = false; + centerFlag = false; + crFlag = false; + } + + if (!centerFlag) + dialog->incNumLines(); + + // Show the dialog + _vm->_events->setCursor(CURSOR_ARROW); + dialog->show(); + + delete dialog; + return result; +} + +void DialogsNebular::showItem(int objectId, int messageId, int speech) { + // MADS engine doesn't currently support speech + assert(!speech); + + show(messageId, objectId); +} + +Common::String DialogsNebular::getVocab(int vocabId) { + assert(vocabId > 0); + + Common::String vocab = _vm->_game->_scene.getVocab(vocabId); + + switch (_capitalizationMode) { + case kUppercase: + vocab.toUppercase(); + break; + case kLowercase: + vocab.toLowercase(); + break; + case kUpperAndLower: + vocab.toLowercase(); + vocab.setChar(toupper(vocab[0]), 0); + default: + break; + } + + return vocab; +} + +bool DialogsNebular::textNoun(Common::String &dest, int nounId, const Common::String &source) { + // Ensure the destination has parameter specifications + if (!source.hasPrefix(":")) + return false; + + // Extract the first (singular) result value + Common::String param1 = Common::String(source.c_str() + 1); + Common::String param2; + const char *sepChar = strchr(source.c_str() + 1, ':'); + if (sepChar) { + param1 = Common::String(source.c_str() + 1, sepChar); + + // Get the second, plural form + param2 = Common::String(sepChar + 1); + } + + // Get the vocab to use + MADSAction &action = _vm->_game->_scene._action; + Common::String vocab = _vm->_dialogs->getVocab(action._activeAction._verbId); + Common::String *str; + + if (vocab.hasSuffix("s") || vocab.hasSuffix("S")) { + str = ¶m2; + } else { + str = ¶m1; + + if (param1 == "a ") { + switch (toupper(vocab[0])) { + case 'A': + case 'E': + case 'I': + case 'O': + case 'U': + param1 = "an "; + break; + default: + break; + } + } + } + + dest += *str; + return true; +} + +bool DialogsNebular::commandCheck(const char *idStr, Common::String &valStr, + const Common::String &command) { + uint idLen = strlen(idStr); + + valStr = (command.size() <= idLen) ? "" : Common::String(command.c_str() + idLen); + + // Check whether the command starts with the given Id + int result = scumm_strnicmp(idStr, command.c_str(), idLen) == 0; + if (!result) + return false; + + // It does, so set the command case mode + if (Common::isUpper(command[0]) && Common::isUpper(command[1])) { + _capitalizationMode = kUppercase; + } else if (Common::isUpper(command[0])) { + _capitalizationMode = kUpperAndLower; + } else { + _capitalizationMode = kLowercase; + } + + return true; +} + +void DialogsNebular::showDialog() { + switch (_pendingDialog) { + case DIALOG_GAME_MENU: + //GameMenuDialog::show(); + break; + default: + break; + } +} + +/*------------------------------------------------------------------------*/ + +CopyProtectionDialog::CopyProtectionDialog(MADSEngine *vm, bool priorAnswerWrong) : +TextDialog(vm, FONT_INTERFACE, Common::Point(-1, -1), 32) { + getHogAnusEntry(_hogEntry); + + if (priorAnswerWrong) { + addLine("ANSWER INCORRECT!", true); + wordWrap("\n"); + addLine("(But we'll give you another chance!)"); + } + else { + addLine("REX NEBULAR version 8.43", true); + wordWrap("\n"); + addLine("(Copy Protection, for your convenience)"); + } + wordWrap("\n"); + + wordWrap("Now comes the part that everybody hates. But if we don't"); + wordWrap("do this, nasty rodent-like people will pirate this game"); + wordWrap("and a whole generation of talented designers, programmers,"); + wordWrap("artists, and playtesters will go hungry, and will wander"); + wordWrap("aimlessly through the land at night searching for peace."); + wordWrap("So let's grit our teeth and get it over with. Just get"); + + Common::String line = "out your copy of "; + line += _hogEntry._bookId == 103 ? "the GAME MANUAL" : "REX'S LOGBOOK"; + line += ". See! That was easy. "; + wordWrap(line); + + line = Common::String::format("Next, just turn to page %d. On line %d, find word number %d, ", + _hogEntry._pageNum, _hogEntry._lineNum, _hogEntry._wordNum); + wordWrap(line); + + wordWrap("and type it on the line below (we',27h,'ve even given you"); + wordWrap("first letter as a hint). As soon as you do that, we can get"); + wordWrap("right into this really COOL adventure game!\n"); + wordWrap("\n"); + wordWrap(" "); + addInput(); + wordWrap("\n"); +} + +void CopyProtectionDialog::show() { + draw(); + _vm->_events->showCursor(); + + // TODO: Replace with text input + while (!_vm->shouldQuit() && !_vm->_events->isKeyPressed() && + !_vm->_events->_mouseClicked) { + _vm->_events->delay(1); + } + + _vm->_events->_pendingKeys.clear(); +} + +bool CopyProtectionDialog::getHogAnusEntry(HOGANUS &entry) { + File f; + f.open("*HOGANUS.DAT"); + + // Read in the total number of entries, and randomly pick an entry to use + int numEntries = f.readUint16LE(); + int entryIndex = _vm->getRandomNumber(1, numEntries); + + // Read in the encrypted entry + f.seek(28 * entryIndex + 2); + byte entryData[28]; + f.read(entryData, 28); + + // Decrypt it + for (int i = 0; i < 28; ++i) + entryData[i] = ~entryData[i]; + + // Fill out the fields + entry._bookId = entryData[0]; + entry._pageNum = READ_LE_UINT16(&entryData[2]); + entry._lineNum = READ_LE_UINT16(&entryData[4]); + entry._wordNum = READ_LE_UINT16(&entryData[6]); + entry._word = Common::String((char *)&entryData[8]); + + f.close(); + return true; +} + +/*------------------------------------------------------------------------*/ + +PictureDialog::PictureDialog(MADSEngine *vm, const Common::Point &pos, + int maxChars, int objectId) : + TextDialog(vm, FONT_INTERFACE, pos, maxChars), _objectId(objectId) { + // Turn off cycling if active + Scene &scene = _vm->_game->_scene; + _cyclingActive = scene._cyclingActive; + scene._cyclingActive = false; +} + +PictureDialog::~PictureDialog() { + // Restore cycling flag + Scene &scene = _vm->_game->_scene; + scene._cyclingActive = _cyclingActive; +} + +void PictureDialog::save() { + Palette &palette = *_vm->_palette; + byte map[PALETTE_COUNT]; + + // Save the entire screen + _savedSurface = new MSurface(MADS_SCREEN_WIDTH, MADS_SCREEN_HEIGHT); + _vm->_screen.copyTo(_savedSurface); + + // Save palette information + Common::copy(&palette._mainPalette[0], &palette._mainPalette[PALETTE_SIZE], &_palette[0]); + Common::copy(&palette._palFlags[0], &palette._palFlags[PALETTE_COUNT], &_palFlags[0]); + _rgbList.copy(palette._rgbList); + + // Set up palette allocation + Common::fill(&palette._colorFlags[0], &palette._colorFlags[3], true); + + uint32 *palFlagP = &palette._palFlags[0]; + for (int idx = 0; idx < PALETTE_COUNT; ++idx, ++palFlagP) { + if (idx < PALETTE_RESERVED_LOW_COUNT || + idx >= (PALETTE_COUNT - PALETTE_RESERVED_HIGH_COUNT - 10)) { + *palFlagP = 1; + map[idx] = idx; + } else { + *palFlagP = 0; + } + } + + // Reset the flag list + palette._rgbList.reset(); + + // Fade the screen to grey + int numColors = PALETTE_COUNT - PALETTE_RESERVED_LOW_COUNT - PALETTE_RESERVED_HIGH_COUNT; + palette.fadeOut(palette._mainPalette, &map[PALETTE_RESERVED_LOW_COUNT], + PALETTE_RESERVED_LOW_COUNT, numColors, 248, 8, 1, 16); + + // Remap the greyed out screen to use the small greyscale range + // at the top end of the palette + _vm->_screen.translate(map); + + // Load the inventory picture + Common::String setName = Common::String::format("*OB%.3d.SS", _objectId); + SpriteAsset *asset = new SpriteAsset(_vm, setName, 0x8000); + palette.setFullPalette(palette._mainPalette); + + // Get the inventory frame, and adjust the dialog position to allow for it + MSprite *frame = asset->getFrame(0); + _position.y = frame->h + 12; + + // Draw the inventory picture + frame->copyTo(&_vm->_screen, Common::Point(160 - frame->w / 2, 6), + frame->getTransparencyIndex()); + _vm->_screen.copyRectToScreen(_vm->_screen.getBounds()); + + // Adjust the dialog colors to use + TEXTDIALOG_CONTENT1 -= 10; + TEXTDIALOG_CONTENT2 -= 10; + TEXTDIALOG_EDGE -= 10; + TEXTDIALOG_BACKGROUND -= 10; + TEXTDIALOG_FC -= 10; + TEXTDIALOG_FD -= 10; + TEXTDIALOG_FE -= 10; +} + +void PictureDialog::restore() { + if (_savedSurface) { + _savedSurface->copyTo(&_vm->_screen); + delete _savedSurface; + _savedSurface = nullptr; + + _vm->_screen.copyRectToScreen(_vm->_screen.getBounds()); + + // Restore palette information + Palette &palette = *_vm->_palette; + Common::copy(&_palette[0], &_palette[PALETTE_SIZE], &palette._mainPalette[0]); + _vm->_palette->setFullPalette(palette._mainPalette); + Common::copy(&_palFlags[0], &_palFlags[PALETTE_COUNT], &palette._palFlags[0]); + palette._rgbList.copy(_rgbList); + + _vm->_dialogs->_defaultPosition.y = -1; + } +} + +/*------------------------------------------------------------------------*/ + +ScreenDialog::DialogLine::DialogLine() { + _state = 0; + _textDisplayIndex = -1; + _font = nullptr; + _widthAdjust = 0; +} + +ScreenDialog::DialogLine::DialogLine(const Common::String &s) { + _state = 0; + _textDisplayIndex = -1; + _font = nullptr; + _widthAdjust = -1; + _msg = s; +} + +/*------------------------------------------------------------------------*/ + +ScreenDialog::ScreenDialog(MADSEngine *vm) : _vm(vm), + _savedSurface(MADS_SCREEN_WIDTH, MADS_SCREEN_HEIGHT) { + Game &game = *_vm->_game; + Scene &scene = game._scene; + + _v1 = 0; + _selectedLine = 0; + _dirFlag = false; + _textLineCount = 0; + + game.loadQuoteSet(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 0); + game._kernelMode = KERNEL_ROOM_PRELOAD; + _vm->_events->waitCursor(); + scene.clearVocab(); + scene._dynamicHotspots.clear(); + _vm->_dialogs->_defaultPosition = Common::Point(-1, -1); + + bool palFlag = false; + int nextSceneId = scene._nextSceneId; + int currentSceneId = scene._currentSceneId; + int priorSceneId = scene._priorSceneId; + + if (_vm->_dialogs->_pendingDialog == DIALOG_DIFFICULTY) { + palFlag = true; + } else { + _vm->_palette->initPalette(); + } + scene.loadScene(_screenId, game._aaName, palFlag); + + scene._priorSceneId = priorSceneId; + scene._currentSceneId = currentSceneId; + scene._nextSceneId = nextSceneId; + _vm->_screen._offset.y = 22; + _vm->_sound->pauseNewCommands(); + _vm->_events->initVars(); + game._kernelMode = KERNEL_ROOM_INIT; + + SpriteAsset *menuSprites = new SpriteAsset(_vm, "*MENU", 0); + _menuSpritesIndex = scene._sprites.add(menuSprites); + + byte pal[768]; + if (_vm->_screenFade) { + Common::fill(&pal[0], &pal[PALETTE_SIZE], 0); + _vm->_palette->setFullPalette(pal); + } else { + _vm->_palette->getFullPalette(pal); + _vm->_palette->fadeOut(pal, nullptr, 0, PALETTE_COUNT, 0, 1, 1, 16); + } + + _vm->_screen.copyTo(&_savedSurface); + /* + _vm->_screen.hLine(0, 0, MADS_SCREEN_WIDTH, 2); + _vm->_screen.copyRectToScreen(Common::Rect(0, _vm->_screen._offset.y, + MADS_SCREEN_WIDTH, _vm->_screen._offset.y + 1)); + _vm->_screen.copyRectToScreen(Common::Rect(0, _vm->_screen._offset.y + 157, + MADS_SCREEN_WIDTH, _vm->_screen._offset.y + 157)); + */ + + game._fx = _vm->_screenFade == SCREEN_FADE_SMOOTH ? + kCenterVertTransition : kTransitionFadeIn; + game._trigger = 0; + _vm->_events->setCursor(CURSOR_ARROW); + + _vm->_palette->setEntry(10, 0, 63, 0); + _vm->_palette->setEntry(11, 0, 45, 0); + _vm->_palette->setEntry(12, 63, 63, 0); + _vm->_palette->setEntry(13, 45, 45, 0); + _vm->_palette->setEntry(14, 63, 63, 63); + _vm->_palette->setEntry(15, 45, 45, 45); +} + +void ScreenDialog::clearLines() { + Scene &scene = _vm->_game->_scene; + _lines.clear(); + scene._spriteSlots.fullRefresh(true); +} + +void ScreenDialog::addQuote(int id1, int id2, DialogTextAlign align, + const Common::Point &pt, Font *font) { + Common::String msg = _vm->_game->getQuote(id1); + + if (id2 > 0) { + msg += " "; + msg += _vm->_game->getQuote(id2); + } + + addLine(msg, align, pt, font); +} + +void ScreenDialog::addLine(const Common::String &msg, DialogTextAlign align, + const Common::Point &pt, Font *font) { + Scene &scene = _vm->_game->_scene; + DialogLine *line; + + if (_lineIndex < (int)_lines.size()) { + if (_lines.size() >= 20) + goto finish; + + _lines.push_back(msg); + line = &_lines[_lines.size() - 1]; + } else { + line = &_lines[_lineIndex]; + if (msg.compareToIgnoreCase(msg)) + goto finish; + + if (line->_textDisplayIndex >= 0) { + TextDisplay &textDisplay = scene._textDisplay[line->_textDisplayIndex]; + if (textDisplay._active) { + textDisplay._expire = -1; + if (_textLineCount < 20) { + textDisplay._msg = msg; + ++_textLineCount; + } + } + } + } + + line->_font = font; + line->_state = 0; + line->_pos = pt; + line->_widthAdjust = -1; + line->_textDisplayIndex = -1; + + int xOffset; + switch (align) { + case ALIGN_CENTER: + xOffset = (MADS_SCREEN_WIDTH / 2) - font->getWidth(msg, -1) / 2; + line->_pos.x += xOffset; + break; + + case ALIGN_AT_CENTER: { + const char *msgP = msg.c_str(); + const char *ch = strchr(msgP, '@'); + if (ch) { + xOffset = (MADS_SCREEN_WIDTH / 2) - font->getWidth( + Common::String(msgP, ch), line->_widthAdjust); + line->_pos.x += xOffset; + } + break; + } + + case ALIGN_RIGHT: + xOffset = font->getWidth(msg, -1); + line->_pos.x -= xOffset; + break; + + default: + break; + } + +finish: + ++_lineIndex; +} + +void ScreenDialog::initVars() { + _v1 = -1; + _selectedLine = -1; + _lineIndex = 0; + _enterFlag = false; + _textLineCount = 0; +} + +void ScreenDialog::chooseBackground() { + switch (_vm->_game->_currentSectionNumber) { + case 1: + case 2: + _screenId = 921; + break; + case 3: + case 4: + _screenId = 922; + break; + case 5: + case 6: + case 7: + _screenId = 923; + break; + case 8: + _screenId = 924; + break; + default: + _screenId = 920; + break; + } +} + +void ScreenDialog::setFrame(int frameNumber, int depth) { + Scene &scene = _vm->_game->_scene; + SpriteSlot &spriteSlot = scene._spriteSlots[scene._spriteSlots.add()]; + spriteSlot._flags = IMG_UPDATE; + spriteSlot._seqIndex = 1; + spriteSlot._spritesIndex = _menuSpritesIndex; + spriteSlot._frameNumber = frameNumber; + +} + +/*------------------------------------------------------------------------*/ + +GameMenuDialog::GameMenuDialog(MADSEngine *vm) : ScreenDialog(vm) { + clearLines(); + setFrame(1, 2); +} + +void GameMenuDialog::addLines() { + initVars(); + Font *font = _vm->_font->getFont(FONT_CONVERSATION); + int top = 78 - (font->getHeight() + 2) * 12; + addQuote(10, 0, ALIGN_CENTER, Common::Point(0, top), font); + // TODO +} + +} // End of namespace Nebular + +} // End of namespace MADS diff --git a/engines/mads/nebular/dialogs_nebular.h b/engines/mads/nebular/dialogs_nebular.h new file mode 100644 index 0000000000..643d440d67 --- /dev/null +++ b/engines/mads/nebular/dialogs_nebular.h @@ -0,0 +1,180 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_DIALOGS_NEBULAR_H +#define MADS_DIALOGS_NEBULAR_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/dialogs.h" + +namespace MADS { + +namespace Nebular { + +enum CapitalizationMode { kUppercase = 0, kLowercase = 1, kUpperAndLower = 2 }; + +class DialogsNebular: public Dialogs { + friend class Dialogs; +private: + int _dialogWidth; + CapitalizationMode _capitalizationMode; + + DialogsNebular(MADSEngine *vm): Dialogs(vm) {} + + virtual Common::String getVocab(int vocabId); + + bool textNoun(Common::String &dest, int nounId, const Common::String &source); + + bool commandCheck(const char *idStr, Common::String &valStr, const Common::String &command); +public: + virtual void showDialog(); + + virtual void showItem(int objectId, int messageId, int speech = -1); + + virtual bool show(int messageId, int objectId = -1); +}; + +struct HOGANUS { + int _bookId; + int _pageNum; + int _lineNum; + int _wordNum; + Common::String _word; +}; + +class CopyProtectionDialog: public TextDialog { +private: + HOGANUS _hogEntry; + + /** + * Get a random copy protection entry from the HOGANUS resource + */ + bool getHogAnusEntry(HOGANUS &entry); +public: + /** + * Constructor + */ + CopyProtectionDialog(MADSEngine *vm, bool priorAnswerWrong); + + /** + * Show the dialog + */ + virtual void show(); +}; + +class PictureDialog : public TextDialog { +private: + int _objectId; + bool _cyclingActive; + byte _palette[PALETTE_SIZE]; + uint32 _palFlags[PALETTE_COUNT]; + RGBList _rgbList; +protected: + virtual void save(); + + virtual void restore(); +public: + PictureDialog(MADSEngine *vm, const Common::Point &pos, int maxChars, int objectId); + + virtual ~PictureDialog(); +}; + +enum DialogTextAlign { ALIGN_CENTER = -1, ALIGN_AT_CENTER = -2, ALIGN_RIGHT = -3 }; + +class ScreenDialog { + struct DialogLine { + int _state; + Common::Point _pos; + int _textDisplayIndex; + Common::String _msg; + Font *_font; + int _widthAdjust; + + DialogLine(); + DialogLine(const Common::String &s); + }; +protected: + MADSEngine *_vm; + MSurface _savedSurface; + Common::Array<DialogLine> _lines; + int _v1; + int _selectedLine; + bool _dirFlag; + int _screenId; + int _menuSpritesIndex; + int _lineIndex; + bool _enterFlag; + int _textLineCount; + + /** + * Reset the lines list for the dialog + */ + void clearLines(); + + /** + * Add a quote to the lines list + */ + void addQuote(int id1, int id2, DialogTextAlign align, const Common::Point &pt, Font *font); + + /** + * Adds a line to the lines list + */ + void addLine(const Common::String &msg, DialogTextAlign align, const Common::Point &pt, Font *font); + + /** + * Initializes variables + */ + void initVars(); + + /** + * Sets the display for the screen background behind the dialog + */ + void setFrame(int frameNumber, int depth); + + /** + * Choose the background to display for the dialog + */ + void chooseBackground(); +public: + /** + * Constructor + */ + ScreenDialog(MADSEngine *vm); +}; + +class GameMenuDialog : public ScreenDialog { +private: + /** + * Add the lines for the Game Menu dialog + */ + void addLines(); +public: + GameMenuDialog(MADSEngine *vm); + +}; + +} // End of namespace Nebular + +} // End of namespace MADS + +#endif /* MADS_DIALOGS_NEBULAR_H */ diff --git a/engines/mads/nebular/game_nebular.cpp b/engines/mads/nebular/game_nebular.cpp new file mode 100644 index 0000000000..51e06d092c --- /dev/null +++ b/engines/mads/nebular/game_nebular.cpp @@ -0,0 +1,766 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "common/config-manager.h" +#include "mads/mads.h" +#include "mads/game.h" +#include "mads/screen.h" +#include "mads/msurface.h" +#include "mads/nebular/game_nebular.h" +#include "mads/nebular/dialogs_nebular.h" +#include "mads/nebular/globals_nebular.h" +#include "mads/nebular/nebular_scenes.h" + +namespace MADS { + +namespace Nebular { + +GameNebular::GameNebular(MADSEngine *vm): Game(vm) { + _surface = new MSurface(MADS_SCREEN_WIDTH, MADS_SCENE_HEIGHT); + _storyMode = STORYMODE_NAUGHTY; + _difficulty = DIFFICULTY_EASY; +} + +ProtectionResult GameNebular::checkCopyProtection() { + /* + // DEBUG: Flag copy protection failure + _globals[kCopyProtectFailed] = -1; + + if (!ConfMan.getBool("copy_protection")) + return true; + + * DEBUG: Disabled for now + CopyProtectionDialog *dlg = new CopyProtectionDialog(_vm, false); + dlg->show(); + delete dlg; + */ + + // DEBUG: Return that copy protection failed + return PROTECTION_SUCCEED; +} + +void GameNebular::initializeGlobals() { + int count, count2; + int bad; + + _globals.reset(); + _globals[kTalkInanimateCount] = 8; + + /* Section #1 variables */ + _globals[kNeedToStandUp] = true; + _globals[kTurkeyExploded] = false; + _globals[kMedicineCabinetOpen] = false; + _globals[kMedicineCabinetVirgin] = true; + _globals[kWatchedViewScreen] = false; + _globals[kHoovicAlive] = true; + _globals[kWaterInAPuddle] = false; + + _globals[kFishIn105] = true; + _globals[kFishIn107] = true; + _globals[kFishIn108] = true; + + /* Section #2 variables */ + _globals[kLadderBroken] = false; + _globals[kBone202Status] = 0; + _globals[kRhotundaStatus] = RHOTUNDA_HUNGRY; + _globals[kMonkeyStatus] = MONKEY_AMBUSH_READY; + _globals[kMeteorologistStatus] = METEOROLOGIST_PRESENT; + _globals[kMeteorologistEverSeen] = false; + _globals[kMeteorologistWatch] = METEOROLOGIST_NORMAL; + _globals[kTeleporterCommand] = TELEPORTER_NONE; + _globals[kTeleporterUnderstood] = false; + _globals[kTwinklesStatus] = TWINKLES_AT_HOME; + _globals[kTwinklesApproached] = 0; + + /* Section #3 variables */ + _globals[kAfterHavoc] = false; + _globals[kKickedIn391Grate] = false; + + /* Section #4 variables */ + _globals[kBadFirstIngredient] = -1; + _objects[OBJ_CHARGE_CASES].setQuality(EXPLOSIVES_INSIDE, 0); + _globals[kHasPurchased] = false; + _globals[kBeenThruHelgaScene] = false; + _globals[kNextIngredient] = 0; + _globals[kHasSaidTimer] = false; + _globals[kHasSaidBinocs] = false; + _globals[kBottleDisplayed] = false; + _globals[kHasBeenScanned] = false; + _globals[kSomeoneHasExploded] = false; + + // Generate a random ingredient list + for (count = 0; count < 4; ++count) { + do { + _globals[kIngredientList + count] = _vm->getRandomNumber(3); + bad = false; + for (count2 = 0; count2 < count; ++count2) { + if (_globals[kIngredientList + count] == _globals[kIngredientList + count2]) { + bad = true; + } + } + } while (bad); + } + + // Generate random ingredient quantities + for (count = 0; count < 4; ++count) { + do { + _globals[kIngredientQuantity + count] = _vm->getRandomNumber(3); + bad = false; + for (count2 = 0; count2 < count; ++count2) { + if (_globals[kIngredientQuantity + count] == _globals[kIngredientQuantity + count2]) { + bad = true; + } + } + } while (bad); + } + + + /* Section #5 variables */ + _globals[kHoverCarLocation] = 501; + _globals[kHoverCarDestination] = -1; + _globals[kCityFlooded] = false; + _globals[kBoatRaised] = true; + _globals[kLaserHoleIsThere] = false; + _globals[kLineStatus] = LINE_NOT_DROPPED; + + + /* Section #6 variables */ + _globals[kHasTalkedToHermit] = false; + _globals[kHandsetCellStatus] = FIRST_TIME_PHONE_CELLS; + _globals[kTimebombStatus] = TIMEBOMB_DEACTIVATED; + _globals[kWarnedFloodCity] = false; + _globals._timebombClock = 0; + _globals._timebombTimer = 0; + + + /* Section #7 variables */ + _globals[kBottleStatus] = BOTTLE_EMPTY; + _globals[kBoatStatus] = BOAT_UNFLOODED; + + + /* Section #8 variables */ + _globals[kWindowFixed] = false; + _globals[kInSpace] = false; + _globals[kReturnFromCut] = false; + _globals[kBeamIsUp] = false; + _globals[kForceBeamDown] = false; + _globals[kCameFromCut] = false; + _globals[kDontRepeat] = false; + _globals[kHoppyDead] = false; + _globals[kHasWatchedAntigrav] = false; + _globals[kRemoteSequenceRan] = false; + _globals[kRemoteOnGround] = false; + _globals[kFromCockpit] = false; + _globals[kExitShip] = false; + _globals[kBetweenRooms] = false; + _globals[kTopButtonPushed] = false; + _globals[kShieldModInstalled] = false; + _globals[kTargetModInstalled] = false; + _globals[kUpBecauseOfRemote] = false; + + + /* Set up the game's teleporters */ + _globals[kTeleporterRoom] = 201; + _globals[kTeleporterRoom + 1] = 301; + _globals[kTeleporterRoom + 2] = 413; + _globals[kTeleporterRoom + 3] = 706; + _globals[kTeleporterRoom + 4] = 801; + _globals[kTeleporterRoom + 5] = 551; + _globals[kTeleporterRoom + 6] = 752; + _globals[kTeleporterRoom + 7] = 0; + _globals[kTeleporterRoom + 8] = 0; + _globals[kTeleporterRoom + 9] = 0; + + for (count = 0; count < TELEPORTER_COUNT; ++count) { + do { + _globals[kTeleporterCode + count] = _vm->getRandomNumber(9999); + bad = false; + for (count2 = 0; count2 < count; ++count2) { + if (_globals[kTeleporterCode + count] == _globals[kTeleporterCode + count2]) { + bad = true; + } + } + } while (bad); + } + + // Final setup based on selected difficulty level + switch (_difficulty) { + case DIFFICULTY_HARD: + _objects.setRoom(OBJ_PLANT_STALK, NOWHERE); + _objects.setRoom(OBJ_PENLIGHT, NOWHERE); + + _globals[kLeavesStatus] = LEAVES_ON_TRAP; + break; + + case DIFFICULTY_MEDIUM: + _objects.setRoom(OBJ_PLANT_STALK, NOWHERE); + + _globals[kLeavesStatus] = LEAVES_ON_GROUND; + _globals[kDurafailRecharged] = true; + _globals[kPenlightCellStatus] = FIRST_TIME_CHARGED_DURAFAIL; + break; + + case DIFFICULTY_EASY: + _objects.setRoom(OBJ_BLOWGUN, NOWHERE); + _objects.setRoom(OBJ_NOTE, NOWHERE); + + _globals[kLeavesStatus] = LEAVES_ON_GROUND; + _globals[kPenlightCellStatus] = FIRST_TIME_UNCHARGED_DURAFAIL; + _globals[kDurafailRecharged] = false; + break; + } + + _player._facing = FACING_NORTH; + _player._turnToFacing = FACING_NORTH; + + Player::preloadSequences("RXM", 1); + Player::preloadSequences("ROX", 1); +} + +void GameNebular::setSectionHandler() { + delete _sectionHandler; + + switch (_sectionNumber) { + case 1: + _sectionHandler = new Section1Handler(_vm); + break; + case 2: + _sectionHandler = new Section2Handler(_vm); + break; + case 3: + _sectionHandler = new Section3Handler(_vm); + break; + case 4: + _sectionHandler = new Section4Handler(_vm); + break; + case 5: + _sectionHandler = new Section5Handler(_vm); + break; + case 6: + _sectionHandler = new Section6Handler(_vm); + break; + case 7: + _sectionHandler = new Section7Handler(_vm); + break; + case 8: + _sectionHandler = new Section8Handler(_vm); + break; + default: + break; + } +} + +void GameNebular::checkShowDialog() { + if (_vm->_dialogs->_pendingDialog && _player._stepEnabled && !_globals[kCopyProtectFailed]) { + _player.releasePlayerSprites(); + _vm->_dialogs->showDialog(); + _vm->_dialogs->_pendingDialog = DIALOG_NONE; + } +} + +void GameNebular::doObjectAction() { + Scene &scene = _scene; + MADSAction &action = _scene._action; + Dialogs &dialogs = *_vm->_dialogs; + int id; + + if (action.isAction(VERB_SMELL) && scene._currentSceneId > 103 && scene._currentSceneId < 111) { + dialogs.show(440); + } else if (action.isAction(VERB_EAT) && scene._currentSceneId > 103 && scene._currentSceneId < 111) { + dialogs.show(441); + } else if (action.isAction(VERB_SMELL, NOUN_BURGER)) { + dialogs.show(442); + } else if (action.isAction(VERB_EAT, NOUN_BURGER)) { + dialogs.show(443); + } else if (action.isAction(VERB_SMELL, NOUN_STUFFED_FISH)) { + dialogs.show(444); + } else if (action.isAction(VERB_EAT, NOUN_STUFFED_FISH)) { + dialogs.show(445); + } else if (action.isAction(401, 289)) { + dialogs.show(scene._currentSceneId > 103 && scene._currentSceneId < 111 ? 446 : 447); + } else if (action.isAction(306, 371)) { + dialogs.show(448); + } else if (action.isAction(951, 35)) { + dialogs.show(449); + } else if (action.isAction(203, 276)) { + dialogs.show(450); + } else if (action.isAction(VERB_EAT, 378)) { + _objects.setRoom(OBJ_TWINKIFRUIT, PLAYER_INVENTORY); + dialogs.show(451); + } else if (action.isAction(153, 378)) { + _objects.setRoom(OBJ_TWINKIFRUIT, PLAYER_INVENTORY); + dialogs.show(452); + } else if (action.isAction(152)) { + dialogs.show(453); + } else if (action.isAction(1187, OBJ_PHONE_CELLS)) { + dialogs.show(454); + } else if (action.isAction(1188, 92)) { + dialogs.show(455); + } else if (action.isAction(140, 72)) { + dialogs.show(456); + } else if (action.isAction(1189, OBJ_VASE)) { + dialogs.show(457); + } else if (action.isAction(306, 369)) { + dialogs.show(458); + } else if (action.isAction(1192, 774)) { + dialogs.show(459); + } else if (action.isAction(1191, 359)) { + dialogs.show(460); + } else if (action.isAction(1190)) { + dialogs.show(461); + } else if (action.isAction(934, 277)) { + dialogs.show(462); + } else if (action.isAction(329, 277)) { + dialogs.show(465); + } else if (action.isAction(368, 135)) { + dialogs.show(463); + } else if (action.isAction(25, 135)) { + dialogs.show(463); + } else if (action.isAction(379)) { + dialogs.show(464); + } else if (action.isAction(869)) { + dialogs.show(466); + } else if (action.isAction(530, 288)) { + dialogs.show(467); + } else if (action.isAction(VERB_EAT, 74)) { + dialogs.show(469); + } else if (action.isAction(50, 381)) { + dialogs.show(471); + } else if (action.isAction(307, 950)) { + dialogs.show(472); + } else if (action.isAction(VERB_READ, NOUN_LOG)) { + dialogs.show(473); + } else if (action.isAction(1189, 43)) { + dialogs.show(474); + } else if (action.isAction(114, 726)) { + dialogs.show(475); + } else if (action.isAction(114, 727)) { + dialogs.show(476); + } else if (action.isAction(114, 937)) { + dialogs.show(477); + } else if (action.isAction(VERB_PUT, 276, NOUN_PLANT_STALK) && _objects.isInInventory(OBJ_POISON_DARTS) + && _objects.isInInventory(OBJ_PLANT_STALK)) { + _objects.addToInventory(OBJ_BLOWGUN); + _objects.setRoom(OBJ_PLANT_STALK, NOWHERE); + _globals[kBlowgunStatus] = 0; + dialogs.showItem(OBJ_BLOWGUN, 809); + } else if (action.isAction(VERB_PUT, 276, NOUN_BLOWGUN) && _objects.isInInventory(OBJ_POISON_DARTS) + && _objects.isInInventory(OBJ_BLOWGUN)) { + dialogs.show(433); + } else if (action.isAction(1161) && action.isAction(1195) && action.isAction(1197)) { + dialogs.show(434); + } else if (action.isAction(1196)) { + dialogs.show(479); + } else if ((action.isAction(287) || action.isAction(VERB_LOOK_AT) || action.isAction(VERB_LOOK)) && + action.isAction(936) && _objects.isInInventory(OBJ_NOTE)) { + _objects.setRoom(OBJ_NOTE, PLAYER_INVENTORY); + _objects.addToInventory(OBJ_COMBINATION); + dialogs.showItem(OBJ_COMBINATION, 851); + } else if ((action.isAction(VERB_LOOK) || action.isAction(VERB_READ)) && + ((id = _objects.getIdFromDesc(action._activeAction._objectNameId)) > 0 || + (action._activeAction._indirectObjectId > 0 && + (id = _objects.getIdFromDesc(action._activeAction._indirectObjectId))))) { + if (id == OBJ_REPAIR_LIST) { + dialogs._indexList[0] = _globals[kTeleporterCode + 7]; + dialogs._indexList[1] = _globals[kTeleporterCode + 8]; + dialogs._indexList[2] = _globals[kTeleporterCode + 6]; + dialogs._indexList[3] = _globals[kTeleporterCode + 9]; + dialogs._indexList[4] = _globals[kTeleporterCode + 0]; + dialogs._indexList[5] = _globals[kTeleporterCode + 1]; + dialogs._indexList[6] = _globals[kTeleporterCode + 4]; + dialogs._indexList[7] = _globals[kTeleporterCode + 5]; + dialogs._indexList[8] = _globals[kTeleporterCode + 2]; + + dialogs.showItem(id, 402); + } else { + int messageId = 800 + id; + if ((id == OBJ_CHARGE_CASES) && _objects[OBJ_CHARGE_CASES].getQuality(3) != 0) { + messageId = 860; + } + + if (id == OBJ_TAPE_PLAYER && _objects[OBJ_AUDIO_TAPE]._roomNumber == OBJ_TAPE_PLAYER) + messageId = 867; + + if (id == 32 && _objects[OBJ_FISHING_LINE]._roomNumber == 3) + messageId = 862; + + if (id == OBJ_BOTTLE && _globals[kBottleStatus] != 0) + messageId = 862 + _globals[kBottleStatus]; + + if (id == OBJ_PHONE_HANDSET && _globals[kHandsetCellStatus]) + messageId = 861; + + dialogs.showItem(id, messageId); + } + } else if (action.isAction(VERB_PUT, NOUN_BURGER, NOUN_DEAD_FISH)) { + if (_objects.isInInventory(OBJ_BURGER) || _objects.isInInventory(OBJ_DEAD_FISH)) { + _objects.removeFromInventory(OBJ_DEAD_FISH, PLAYER_INVENTORY); + _objects.removeFromInventory(OBJ_BURGER, PLAYER_INVENTORY); + _objects.addToInventory(OBJ_STUFFED_FISH); + dialogs.showItem(OBJ_STUFFED_FISH, 803); + } + } else if (action.isAction(VERB_PUT, 26, 357) && _objects.isInInventory(OBJ_AUDIO_TAPE) && + _objects.isInInventory(OBJ_TAPE_PLAYER)) { + _objects.setRoom(OBJ_AUDIO_TAPE, 25); + } else if (action.isAction(118, 357) && _objects.isInInventory(OBJ_TAPE_PLAYER)) { + if (_objects[OBJ_AUDIO_TAPE]._roomNumber == 25) { + _objects.addToInventory(OBJ_AUDIO_TAPE); + } else { + dialogs.show(407); + } + } else if (action.isAction(108, 357)) { + dialogs.show(408); + } else if (action.isAction(14, 291)) { + dialogs.show(_globals[kTopButtonPushed] ? 502 : 501); + } else if ((action.isAction(25, 106, 72) || action.isAction(VERB_PUT, 106, 72)) && + _objects.isInInventory(OBJ_DETONATORS) && _objects.isInInventory(OBJ_CHARGE_CASES)) { + if (_objects[OBJ_CHARGE_CASES].getQuality(3)) { + _objects.setRoom(OBJ_CHARGE_CASES, 1); + _objects.setRoom(OBJ_DETONATORS, 1); + _objects.addToInventory(OBJ_BOMBS); + dialogs.showItem(OBJ_BOMBS, 403); + } else { + dialogs.show(405); + } + } else if (action.isAction(25, 106)) { + dialogs.show(470); + } else if ((action.isAction(25, 371, 43) || action.isAction(7, 371, 43) || action.isAction(25, 371, 42) + || action.isAction(VERB_PUT, 371, 42)) && _objects.isInInventory(OBJ_TIMER_MODULE) && ( + _objects.isInInventory(OBJ_BOMBS) || _objects.isInInventory(OBJ_BOMB))) { + if (_objects.isInInventory(OBJ_BOMBS)) { + _objects.setRoom(OBJ_BOMBS, PLAYER_INVENTORY); + _objects.addToInventory(OBJ_BOMB); + } else { + _objects.setRoom(OBJ_BOMB, PLAYER_INVENTORY); + } + + _objects.setRoom(OBJ_TIMER_MODULE, PLAYER_INVENTORY); + _objects.addToInventory(OBJ_TIMEBOMB); + dialogs.showItem(OBJ_TIMEBOMB, 404); + } else if (action.isAction(140, 271)) { + dialogs.show(410); + } else if (action.isAction(119, 46)) { + _globals[kBottleStatus] = 0; + dialogs.show(432); + } else if (action.isAction(108, 136)) { + if (_objects[OBJ_FISHING_LINE]._roomNumber == 3) { + _objects.addToInventory(OBJ_FISHING_LINE); + dialogs.showItem(OBJ_FISHING_LINE, 409); + } else { + dialogs.show(428); + } + } else if (action.isAction(108, 262)) { + switch (_globals[kPenlightCellStatus]) { + case 1: + case 2: + _objects.addToInventory(OBJ_DURAFAIL_CELLS); + dialogs.showItem(OBJ_DURAFAIL_CELLS, 412); + break; + case 3: + _objects.addToInventory(OBJ_PHONE_CELLS); + dialogs.showItem(OBJ_DURAFAIL_CELLS, 413); + break; + case 5: + _objects.addToInventory(OBJ_DURAFAIL_CELLS); + dialogs.showItem(OBJ_DURAFAIL_CELLS, 411); + break; + case 6: + _objects.addToInventory(OBJ_DURAFAIL_CELLS); + dialogs.showItem(OBJ_DURAFAIL_CELLS, 429); + break; + default: + dialogs.show(478); + break; + } + } else if (action.isAction(108, 264)) { + switch (_globals[kHandsetCellStatus]) { + case 1: + _objects.addToInventory(OBJ_DURAFAIL_CELLS); + dialogs.showItem(OBJ_DURAFAIL_CELLS, + _difficulty != 1 || _globals[kDurafailRecharged] ? 415 : 414); + break; + case 2: + _objects.addToInventory(OBJ_DURAFAIL_CELLS); + if (_difficulty == 1) { + dialogs.showItem(OBJ_DURAFAIL_CELLS, 416); + } else { + _globals[kHandsetCellStatus] = 0; + } + break; + case 3: + _objects.addToInventory(OBJ_PHONE_CELLS); + dialogs.showItem(OBJ_PHONE_CELLS, 418); + break; + case 4: + _objects.addToInventory(OBJ_PHONE_CELLS); + dialogs.showItem(OBJ_PHONE_CELLS, 417); + break; + default: + dialogs.show(478); + break; + } + } else if (action.isAction(VERB_PUT, 263, 262)) { + if (_globals[kPenlightCellStatus] == 0) { + _globals[kPenlightCellStatus] = 3; + _objects.setRoom(OBJ_PHONE_CELLS, PLAYER_INVENTORY); + dialogs.show(419); + } else { + dialogs.show(420); + } + } else if (action.isAction(VERB_PUT, 263, 264)) { + if (_globals[kHandsetCellStatus] == 0) { + _globals[kHandsetCellStatus] = 3; + _objects.setRoom(OBJ_PHONE_CELLS, PLAYER_INVENTORY); + dialogs.show(421); + } else { + dialogs.show(422); + } + } else if (action.isAction(VERB_PUT, 115, 262)) { + if (_globals[kPenlightCellStatus]) { + dialogs.show(424); + } else { + _objects.setRoom(OBJ_DURAFAIL_CELLS, PLAYER_INVENTORY); + _globals[kPenlightCellStatus] = _difficulty != 1 || _globals[kDurafailRecharged] ? 1 : 2; + dialogs.show(423); + } + } else if (action.isAction(VERB_PUT, 115, 264)) { + if (_globals[kHandsetCellStatus]) { + dialogs.show(424); + } else { + _objects.setRoom(OBJ_DURAFAIL_CELLS, PLAYER_INVENTORY); + _globals[kDurafailRecharged] = _difficulty != 1 || _globals[kHandsetCellStatus] ? 1 : 2; + dialogs.show(425); + } + } else if (action.isAction(306, 369)) { + dialogs.show(427); + } else if (action.isAction(VERB_PUT, 42, 73) || action.isAction(VERB_PUT, 43, 73)) { + _objects.setRoom(OBJ_CHICKEN, PLAYER_INVENTORY); + if (_objects.isInInventory(OBJ_BOMBS)) { + _objects.setRoom(OBJ_BOMBS, PLAYER_INVENTORY); + _objects.addToInventory(OBJ_BOMB); + } else { + _objects.setRoom(OBJ_BOMB, PLAYER_INVENTORY); + } + + _objects.addToInventory(OBJ_CHICKEN_BOMB); + dialogs.showItem(OBJ_CHICKEN_BOMB, 430); + } else { + return; + } + + action._inProgress = false; +} + +void GameNebular::unhandledAction() { + int randVal = _vm->getRandomNumber(1, 1000); + MADSAction &action = _scene._action; + + if (action.isAction(VERB_THROW, NOUN_BOMB) || action.isAction(VERB_THROW, NOUN_BOMBS) + || action.isAction(VERB_THROW, NOUN_TIMEBOMB) || action.isAction(VERB_THROW, NOUN_CHICKEN_BOMB)) + _vm->_dialogs->show(42); + else if (action.isAction(0x6C)) + _vm->_dialogs->show(435); + else if ((action.isAction(VERB_EAT, NOUN_DEAD_FISH) || action.isAction(VERB_EAT, NOUN_STUFFED_FISH)) && _vm->_game->_objects.isInInventory(_vm->_game->_objects.getIdFromDesc(action._activeAction._objectNameId))) + _vm->_dialogs->show(12); + else if ((action.isAction(VERB_SMELL, NOUN_DEAD_FISH) || action.isAction(VERB_SMELL, NOUN_STUFFED_FISH)) && _vm->_game->_objects.isInInventory(_vm->_game->_objects.getIdFromDesc(action._activeAction._objectNameId))) + _vm->_dialogs->show(13); + else if (action.isAction(VERB_EAT, NOUN_CHICKEN) && _vm->_game->_objects.isInInventory(OBJ_CHICKEN)) + _vm->_dialogs->show(912); + else if ((action.isAction(VERB_SHOOT) || action.isAction(VERB_HOSE_DOWN)) && action.isObject(NOUN_BLOWGUN)) { + if ((_scene._currentSceneId >= 104) && (_scene._currentSceneId <= 111)) + _vm->_dialogs->show(38); + else if (action.isAction(0x10D)) + _vm->_dialogs->show(41); + else if (action.isObject(NOUN_CHICKEN) || action.isAction(0x185) || action.isAction(0x14D) + || action.isAction(0x1DD) || action.isAction(0x15F) || action.isObject(NOUN_CAPTIVE_CREATURE)) { + _vm->_dialogs->show(40); + } else + _vm->_dialogs->show(39); + } else if (action.isAction(VERB_TALKTO)) { + _globals[kTalkInanimateCount] = (_globals[kTalkInanimateCount] + 1) % 16; + if (!_globals[kTalkInanimateCount]) { + _vm->_dialogs->show(2); + } else { + Common::String tmpMsg = "\"Greetings, "; + tmpMsg += _vm->_game->_scene.getVocab(action._activeAction._objectNameId); + tmpMsg += "!\""; + _scene._kernelMessages.reset(); + _scene._kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, tmpMsg); + } + } else if (action.isAction(VERB_GIVE, NOUN_DOOR, 0x46) || action.isAction(VERB_CLOSE, NOUN_CHAIR)) + _vm->_dialogs->show(3); + else if (action.isAction(VERB_THROW)) { + int objId = _vm->_game->_objects.getIdFromDesc(action._activeAction._objectNameId); + if (objId < 0) + _vm->_dialogs->show(4); + else if (_vm->_game->_objects[objId]._roomNumber != 2) + _vm->_dialogs->show(5); + else + _vm->_dialogs->show(6); + } else if (action.isAction(VERB_LOOK)) { + if (action.isAction(0x27) && (action._activeAction._indirectObjectId > 0)) + _vm->_dialogs->show(10); + else if (randVal < 600) + _vm->_dialogs->show(7); + else + _vm->_dialogs->show(21); + } else if (action.isAction(VERB_TAKE)) { + int objId = _vm->_game->_objects.getIdFromDesc(action._activeAction._objectNameId); + if (_vm->_game->_objects.isInInventory(objId)) + _vm->_dialogs->show(16); + else if (randVal <= 333) + _vm->_dialogs->show(8); + else if (randVal <= 666) + _vm->_dialogs->show(22); + else + _vm->_dialogs->show(23); + } else if (action.isAction(VERB_CLOSE)) { + if (randVal <= 333) + _vm->_dialogs->show(9); + else + _vm->_dialogs->show(33); + } else if (action.isAction(VERB_OPEN)) { + if (randVal <= 500) + _vm->_dialogs->show(30); + else if (randVal <= 750) + _vm->_dialogs->show(31); + else + _vm->_dialogs->show(32); + } else if (action.isAction(VERB_PULL)) + _vm->_dialogs->show(18); + else if (action.isAction(VERB_PUSH)) { + if (randVal < 750) + _vm->_dialogs->show(19); + else + _vm->_dialogs->show(20); + } else if (action.isAction(VERB_PUT)) { + int objId = _vm->_game->_objects.getIdFromDesc(action._activeAction._objectNameId); + if (_vm->_game->_objects.isInInventory(objId)) + _vm->_dialogs->show(25); + else + _vm->_dialogs->show(24); + } else if (action.isAction(VERB_GIVE)) { + int objId = _vm->_game->_objects.getIdFromDesc(action._activeAction._objectNameId); + if (!_vm->_game->_objects.isInInventory(objId)) + _vm->_dialogs->show(26); + else if (randVal <= 500) + _vm->_dialogs->show(28); + else + _vm->_dialogs->show(29); + } else if (!action.isAction(VERB_WALKTO) && !action.isAction(0x187) && !action.isAction(0x18C) && !action.isAction(0x1AD) + && !action.isAction(0x15C) && !action.isAction(0x159) && !action.isAction(0x15A) && !action.isAction(0x15B) + && !action.isAction(0x15E)) { + if (randVal <= 100) + _vm->_dialogs->show(36); + else if (randVal <= 200) + _vm->_dialogs->show(1); + else if (randVal <= 475) + _vm->_dialogs->show(34); + else if (randVal <= 750) + _vm->_dialogs->show(35); + else + _vm->_dialogs->show(37); + } +} + +void GameNebular::step() { + if (_player._visible && _player._stepEnabled && !_player._moving && + (_player._facing == _player._turnToFacing)) { + if (_scene._frameStartTime >= *((uint32 *)&_globals[kWalkerTiming])) { + if (!_player._stopWalkerIndex) { + int randomVal = _vm->getRandomNumber(29999);; + if (_globals[kSexOfRex] == REX_MALE) { + switch (_player._facing) { + case FACING_SOUTHWEST: + case FACING_SOUTHEAST: + case FACING_NORTHWEST: + case FACING_NORTHEAST: + if (randomVal < 200) { + _player.addWalker(-1, 0); + _player.addWalker(1, 0); + } + break; + + case FACING_WEST: + case FACING_EAST: + if (randomVal < 500) { + for (int count = 0; count < 10; ++count) { + _player.addWalker(1, 0); + } + } + break; + + case FACING_SOUTH: + if (randomVal < 500) { + for (int count = 0; count < 10; ++count) { + _player.addWalker((randomVal < 250) ? 1 : 2, 0); + } + } else if (randomVal < 750) { + for (int count = 0; count < 5; ++count) { + _player.addWalker(1, 0); + } + + _player.addWalker(0, 0); + _player.addWalker(0, 0); + + for (int count = 0; count < 5; ++count) { + _player.addWalker(2, 0); + } + } + break; + + default: + break; + } + } + } + + *((uint32 *)&_globals[kWalkerTiming]) += 6; + } + } + + // Below is countdown to set the timebomb off in room 604 + if (_globals[kTimebombStatus] == TIMEBOMB_ACTIVATED) { + int diff = _scene._frameStartTime - *((uint32 *)&_globals[kTimebombClock]); + if ((diff >= 0) && (diff <= 60)) { + *((uint32 *)&_globals[kTimebombTimer]) += diff; + } else { + ++*((uint32 *)&_globals[kTimebombTimer]); + } + *((uint32 *)&_globals[kTimebombClock]) = _scene._frameStartTime; + } +} + +void GameNebular::synchronize(Common::Serializer &s, bool phase1) { + Game::synchronize(s, phase1); + + if (phase1) { + _globals.synchronize(s); + s.syncAsByte(_storyMode); + s.syncAsByte(_difficulty); + } +} + +} // End of namespace Nebular + +} // End of namespace MADS diff --git a/engines/mads/nebular/game_nebular.h b/engines/mads/nebular/game_nebular.h new file mode 100644 index 0000000000..da252219f4 --- /dev/null +++ b/engines/mads/nebular/game_nebular.h @@ -0,0 +1,151 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_GAME_NEBULAR_H +#define MADS_GAME_NEBULAR_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/globals.h" +#include "mads/nebular/globals_nebular.h" + +namespace MADS { + +namespace Nebular { + +enum StoryMode { STORYMODE_NAUGHTY = 1, STORYMODE_NICE = 2 }; + +enum Difficulty { + DIFFICULTY_HARD = 1, DIFFICULTY_MEDIUM = 2, DIFFICULTY_EASY = 3 +}; + +enum InventoryObject { + OBJ_NONE = -1, + OBJ_BINOCULARS = 0, + OBJ_BURGER = 1, + OBJ_DEAD_FISH = 2, + OBJ_STUFFED_FISH = 3, + OBJ_REBREATHER = 4, + OBJ_TIMER_MODULE = 5, + OBJ_BIG_LEAVES = 6, + OBJ_POISON_DARTS = 7, + OBJ_PLANT_STALK = 8, + OBJ_BLOWGUN = 9, + OBJ_TWINKIFRUIT = 10, + OBJ_BONE = 11, + OBJ_CHICKEN = 12, + OBJ_SCALPEL = 13, + OBJ_AUDIO_TAPE = 14, + OBJ_CREDIT_CHIP = 15, + OBJ_SECURITY_CARD = 16, + OBJ_CHARGE_CASES = 17, + OBJ_ESTROTOXIN = 18, + OBJ_BOMB = 19, + OBJ_TIMEBOMB = 20, + OBJ_REPAIR_LIST = 21, + OBJ_ALIEN_LIQUOR = 22, + OBJ_TARGET_MODULE = 23, + OBJ_SHIELD_MODULATOR = 24, + OBJ_TAPE_PLAYER = 25, + OBJ_PHONE_CELLS = 26, + OBJ_PENLIGHT = 27, + OBJ_DURAFAIL_CELLS = 28, + OBJ_FAKE_ID = 29, + OBJ_ID_CARD = 30, + OBJ_POLYCEMENT = 31, + OBJ_FISHING_ROD = 32, + OBJ_FISHING_LINE = 33, + OBJ_PADLOCK_KEY = 34, + OBJ_DOOR_KEY = 35, + OBJ_REARVIEW_MIRROR = 36, + OBJ_COMPACT_CASE = 37, + OBJ_DETONATORS = 39, + OBJ_BOTTLE = 40, + OBJ_CHICKEN_BOMB = 41, + OBJ_VASE = 42, + OBJ_REMOTE = 43, + OBJ_COMPUTER_GAME = 44, + OBJ_PHONE_HANDSET = 45, + OBJ_BONES = 46, + OBJ_GUARDS_ARM = 47, + OBJ_LOG = 48, + OBJ_BOMBS = 49, + OBJ_NOTE = 50, + OBJ_COMBINATION = 51, + OBJ_FORMALDEHYDE = 52, + OBJ_PETROX = 53, + OBJ_LECITHIN = 54 +}; + +class GameNebular: public Game { + friend class Game; +protected: + GameNebular(MADSEngine *vm); + + virtual ProtectionResult checkCopyProtection(); + + virtual void initializeGlobals(); + + virtual void setSectionHandler(); + + virtual void checkShowDialog(); +public: + NebularGlobals _globals; + StoryMode _storyMode; + Difficulty _difficulty; + + virtual Globals &globals() { return _globals; } + + virtual void doObjectAction(); + + virtual void unhandledAction(); + + virtual void step(); + + virtual void synchronize(Common::Serializer &s, bool phase1); +}; + + +class Section1Handler: public SectionHandler { +public: + Section1Handler(MADSEngine *vm): SectionHandler(vm) {} + + // TODO: Properly implement handler methods + virtual void preLoadSection() {} + virtual void sectionPtr2() {} + virtual void postLoadSection() {} +}; + +// TODO: Properly implement handler classes +typedef Section1Handler Section2Handler; +typedef Section1Handler Section3Handler; +typedef Section1Handler Section4Handler; +typedef Section1Handler Section5Handler; +typedef Section1Handler Section6Handler; +typedef Section1Handler Section7Handler; +typedef Section1Handler Section8Handler; + +} // End of namespace Nebular + +} // End of namespace MADS + +#endif /* MADS_GAME_NEBULAR_H */ diff --git a/engines/mads/nebular/globals_nebular.cpp b/engines/mads/nebular/globals_nebular.cpp new file mode 100644 index 0000000000..7bb89a570c --- /dev/null +++ b/engines/mads/nebular/globals_nebular.cpp @@ -0,0 +1,54 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "common/config-manager.h" +#include "mads/nebular/globals_nebular.h" + +namespace MADS { + +namespace Nebular { + +NebularGlobals::NebularGlobals(): Globals() { + // Initialize lists + resize(210); + _spriteIndexes.resize(30); + _sequenceIndexes.resize(30); + + // Initialize game flags + _timebombClock = 0; + _timebombTimer = 0; +} + +void NebularGlobals::synchronize(Common::Serializer &s) { + Globals::synchronize(s); + + s.syncAsUint32LE(_timebombClock); + s.syncAsUint32LE(_timebombTimer); + _spriteIndexes.synchronize(s); + _sequenceIndexes.synchronize(s); +} + + +} // End of namespace Nebular + +} // End of namespace MADS diff --git a/engines/mads/nebular/globals_nebular.h b/engines/mads/nebular/globals_nebular.h new file mode 100644 index 0000000000..980e6ea1eb --- /dev/null +++ b/engines/mads/nebular/globals_nebular.h @@ -0,0 +1,305 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_GLOBALS_NEBULAR_H +#define MADS_GLOBALS_NEBULAR_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "mads/game.h" +#include "mads/resources.h" + +namespace MADS { + +namespace Nebular { + +enum GlobalId { + kSexOfRex = 0, + kOldSexOfRex = 1, + kWalkerTiming = 2, +// kWalkerTiming0 = 3, + kTalkInanimateCount = 4, + kCopyProtectFailed = 5, + + /* Section #1 variables */ + kNeedToStandUp = 10, + kTurkeyExploded = 11, + kMedicineCabinetOpen = 12, + kMedicineCabinetVirgin = 13, + kWatchedViewScreen = 14, + kHoovicAlive = 15, + kHoovicSated = 16, + kHoovicFishEaten = 17, + kWaterInAPuddle = 18, + kFishIn105 = 19, + kFishIn107 = 20, + kFishIn108 = 21, + kRandomNumber = 29, + + /* Section #2 variables */ + kCurtainOpen = 30, + kLadderBroken = 31, + kBone202Status = 32, + kMeteorologistStatus = 33, + kRhotundaStatus = 34, + kLeavesStatus = 35, + kMonkeyStatus = 36, + kMeteorologistEverSeen = 37, + kMeteorologistWatch = 38, + kTeleporterCommand = 39, + + kTeleporterDestination = 40, + kTeleporterUnderstood = 41, + kConv205 = 42, + kChickenPermitted = 43, + kTwinklesStatus = 44, + kTwinklesApproached = 45, + kConvTwinkles1 = 46, + kConvTwinkles2 = 47, + kConvTwinkles3 = 48, + kConvTwinkles5 = 49, + + kConvTwinkles6 = 50, + kConvTwinkles7 = 51, + kConvTwinkles8 = 52, + kBlowgunStatus = 53, + + /* Section #3 Variables */ + kAfterHavoc = 60, + kHaveYourStuff = 61, + kRightView320 = 62, + kConvBuddy1 = 63, + kConvBuddy2 = 64, + kMetBuddyBeast = 65, + kKnowsBuddyBeast = 66, + kConvSlache1 = 67, + kConvSlache2 = 68, + kConvSlache3 = 69, + + kRexHasMetSlache = 70, + kConvIntern = 71, + kHasSeenProfPyro = 72, + kKickedIn391Grate = 73, + + /* Section #4 Variables */ + kArmoryDoorOpen = 80, + kStorageDoorOpen = 81, + kNextIngredient = 82, + kIngredientList = 83, + kIngredientList1 = 84, + kIngredientList2 = 85, + kIngredientList3 = 86, + kIngredientQuantity = 87, + kIngredientQuantity1 = 88, + kIngredientQuantity2 = 89, + + kIngredientQuantity3 = 90, + kconvPyro_1 = 91, + kconvPyro_2 = 92, + kconvPyro_3 = 93, + kconvPyro_4 = 94, + kBadFirstIngredient = 95, + kConvBartender1 = 96, + kConvBartender2 = 97, + kConvBartender3 = 98, + kConvBartender4 = 99, + + kHasPurchased = 100, + kBeenThruHelgaScene = 101, + kHasSaidBinocs = 102, + kHasSaidTimer = 103, + kBottleDisplayed = 104, + kHasBeenScanned = 105, + kSomeoneHasExploded = 106, + + /* Section #5 Variables */ + kBoatRaised = 110, + kCarStatus = 111, + kCityFlooded = 112, + kLaserOn = 113, + kLaserHoleIsThere = 114, + kCarIsGone = 115, + kRegisterOpen = 116, + kSafeStatus = 117, + kDogStatus = 118, + kLineStatus = 119, + + kHoverCarLocation = 120, + kHoverCarDestination = 121, + + /* Section #6 Variables */ + kConvHermit1 = 130, + kconvHermit2 = 131, + kHasTalkedToHermit = 132, + kExecuted_1_11 = 133, + kHandsetCellStatus = 134, + kBeenInVideoStore = 135, + kDurafailRecharged = 136, + kPenlightCellStatus = 137, + kTimebombStatus = 138, + kCheckDaemonTimebomb = 140, + + kResurrectRoom = 141, + + /* Section #6 Time-Bomb Variables */ + kTimebombClock = 142, +// kTimebombClock0 = 143, + kTimebombTimer = 144, +// kTimebombTimer0 = 145, + kWarnedFloodCity = 146, + + /* Section #7 Variables */ + kBottleStatus = 150, + kMonsterAlive = 151, + kConvBottleFillNode = 152, + kBoatStatus = 153, + + /* Section #8 Variables */ + kAntigravClock = 160, +// kAntigravClock0 = 161, + kAntigravTiming = 162, +// kAntigravTiming0 = 163, + kWindowFixed = 164, + kInSpace = 165, + kReturnFromCut = 166, + kBeamIsUp = 167, + kForceBeamDown = 168, + kCameFromCut = 169, + + kCutX = 170, + kCutY = 171, + kCutFacing = 172, + kDontRepeat = 173, + kHoppyDead = 174, + kHasWatchedAntigrav = 175, + kRemoteSequenceRan = 176, + kRemoteOnGround = 177, + kFromCockpit = 178, + kExitShip = 179, + + kBetweenRooms = 180, + kTopButtonPushed = 181, + kTargetModInstalled = 182, + kShieldModInstalled = 183, + kUpBecauseOfRemote = 184, + + kTeleporterRoom = 190, + kTeleporterCode = 200 +}; + +/* Enums used for specific individual globals */ +/* Section #1 */ +// Rex's sex/swimming state +enum { REX_MALE = 0, REX_MALE_SWIMMER = 1, REX_FEMALE = 2 }; +// State of Meteorologist in the outpost +enum { METEOROLOGIST_ABSENT = 0, METEOROLOGIST_PRESENT = 1, METEOROLOGIST_GONE = 2 }; + +// State of watching the Meteorologist +enum { METEOROLOGIST_NORMAL = 0, METEOROLOGIST_GROUND = 1, METEOROLOGIST_TOWER = 2 }; + +// The fat bouncy lady that can squish you on the plains +enum { RHOTUNDA_HUNGRY = 0, RHOTUNDA_STUCK = 1, RHOTUNDA_GONE = 2 }; + +// Flags for the bones you can take +enum { BONE_202_LEFT_GONE = 1, BONE_202_RIGHT_GONE = 2 }; + +// Leaves used to cover the trap +enum { LEAVES_ON_GROUND = 0, LEAVES_WITH_PLAYER = 1, LEAVES_ON_TRAP = 2 }; + +// Monkey ambush state +enum { MONKEY_AMBUSH_READY = 0, MONKEY_HAS_BINOCULARS = 1, MONKEY_IS_GONE = 2 }; + +// Teleporter status flags +enum { + TELEPORTER_NONE = 0, TELEPORTER_BEAM_IN = 1, TELEPORTER_BEAM_OUT = 2, + TELEPORTER_STEP_OUT = 3, TELEPORTER_WRONG = 4 +}; + +// TWinkies status +enum { TWINKLES_AT_HOME = 0, TWINKLES_GONE = 1 }; + +/* Section #4 */ +// Status of the explosives +enum { EXPLOSIVES_INSIDE = 3 }; + +/* Section # 5 */ +enum { LINE_NOT_DROPPED = 1, LINE_DROPPED = 2, LINE_TIED = 3, LINE_NOW_UNTIED = 4 }; + +/* Section #6 */ +enum { + NO_CELLS = 0, // Handset doesn't contain any cells + CHARGED_DURAFAIL = 1, // Handset has charged durafail cells + UNCHARGED_DURAFAIL = 2, // Handset has uncharged durafail cells */ + PHONE_CELLS = 3, // Handset has already charged phone cells + FIRST_TIME_PHONE_CELLS = 4, // First time phone cells are in the handset + FIRST_TIME_UNCHARGED_DURAFAIL = 5, // First time uncharged cells are in penlight + FIRST_TIME_CHARGED_DURAFAIL = 6 // First time charged cells are in penlight +}; + +// Time bomb status +enum { + TIMEBOMB_DEACTIVATED = 0, TIMEBOMB_ACTIVATED = 1, + TIMEBOMB_BLOW_UP = 2, TIMEBOMB_DEAD = 3 +}; + +/* Section #7 */ +// Status of the the bottle +enum { + BOTTLE_EMPTY = 0, BOTTLE_ONE_QUARTER_FULL = 1, BOTTLE_HALF_FULL = 2, + BOTTLE_THREE_QUARTERS_FULL = 3, BOTTLE_FULL = 4 +}; + +// Status of the boat +enum { + BOAT_UNFLOODED = 0, BOAT_ADRIFT = 1, BOAT_TIED_FLOATING = 2, + BOAT_TIED = 3, BOAT_GONE = 4 +}; + + +/* Miscellaneous defines */ +#define TELEPORTER_COUNT 10 // Total number of teleporters +#define TELEPORTER_WORK_COUNT 6 // Total number that actually work + + +class NebularGlobals: public Globals { +public: + SynchronizedList _spriteIndexes; + SynchronizedList _sequenceIndexes; + + int _timebombClock, _timebombTimer; +public: + /** + * Constructor + */ + NebularGlobals(); + + /** + * Synchronize the globals data + */ + virtual void synchronize(Common::Serializer &s); +}; + +} // End of namespace Nebular + +} // End of namespace MADS + +#endif /* MADS_GLOBALS_NEBULAR_H */ diff --git a/engines/mads/nebular/nebular_scenes.cpp b/engines/mads/nebular/nebular_scenes.cpp new file mode 100644 index 0000000000..cbfc055b6f --- /dev/null +++ b/engines/mads/nebular/nebular_scenes.cpp @@ -0,0 +1,615 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "common/config-manager.h" +#include "mads/mads.h" +#include "mads/compression.h" +#include "mads/resources.h" +#include "mads/scene.h" +#include "mads/nebular/game_nebular.h" +#include "mads/nebular/nebular_scenes.h" +#include "mads/nebular/nebular_scenes1.h" +#include "mads/nebular/nebular_scenes2.h" +#include "mads/nebular/nebular_scenes3.h" +#include "mads/nebular/nebular_scenes4.h" +#include "mads/nebular/nebular_scenes5.h" +#include "mads/nebular/nebular_scenes6.h" +#include "mads/nebular/nebular_scenes7.h" +#include "mads/nebular/nebular_scenes8.h" + +namespace MADS { + +namespace Nebular { + +SceneLogic *SceneFactory::createScene(MADSEngine *vm) { + Scene &scene = vm->_game->_scene; + + scene.addActiveVocab(NOUN_DROP); + scene.addActiveVocab(NOUN_DOLLOP); + scene.addActiveVocab(NOUN_DASH); + scene.addActiveVocab(NOUN_SPLASH); + scene.addActiveVocab(NOUN_ALCOHOL); + + switch (scene._nextSceneId) { + // Scene group #1 (ship, ocean, cave) + case 101: // Ship, cockpit + return new Scene101(vm); + case 102: // Ship, dining room + return new Scene102(vm); + case 103: // Ship, engine room + return new Scene103(vm); + case 104: // Ocean, northwest cliff + return new Scene104(vm); + case 105: // Ocean, northeast cliff with mine + return new Scene105(vm); + case 106: // Ocean, outside ship + return new Scene106(vm); + case 107: // Ocean, bushes + return new Scene107(vm); + case 108: // Ocean, southwest cliff + return new Scene108(vm); + case 109: // Ocean, tunnel + return new Scene109(vm); + case 110: // Ocean, cave with tunnel + return new Scene110(vm); + case 111: // Cave with pool and opening + return new Scene111(vm); + case 112: // cutscene, looking at view screen + return new Scene112(vm); + + // Scene group #2 (island) + case 201: // outside teleporter + return new Scene201(vm); + case 202: // village + return new Scene202(vm); + case 203: // tree with Rhotunda (fat woman) + return new Scene203(vm); + case 205: // village + return new Scene205(vm); + case 207: // outside witch doctor's hut + return new Scene207(vm); + case 208: // pit with leaves (trap) + return new Scene208(vm); + case 209: // palm tree and bamboo plant + return new Scene209(vm); + case 210: // outside native woman's hut + return new Scene210(vm); + case 211: // palm tree with monkey + return new Scene211(vm); + case 212: // outside cave + return new Scene212(vm); + case 213: // inside teleporter + return new Scene213(vm); + case 214: // inside witch doctor's hut + return new Scene214(vm); + case 215: // inside native woman's hut + return new Scene215(vm); + case 216: // cutscene, monitor showing Rex and native woman + return new Scene216(vm); + + // Scene group #3 (women's base, cell block) + case 301: // outside teleporter (before chaos) + return new Scene301(vm); + case 302: // room with statue (before chaos) + return new Scene302(vm); + case 303: // western corridor (before chaos) + return new Scene303(vm); + case 304: // crossing with traffic light (before chaos) + return new Scene304(vm); + case 307: // Rex's cell (before chaos) + return new Scene307(vm); + case 308: // sauropod's cell (before chaos) + return new Scene308(vm); + case 309: // multihand monster's cell (before chaos) + return new Scene309(vm); + case 310: // empty cell (before chaos) + return new Scene310(vm); + case 311: // warden's desk (before chaos) + return new Scene311(vm); + case 313: // air shaft overview + return new Scene313(vm); + case 316: // Gender Bender + return new Scene316(vm); + case 318: // doctor's gurney + return new Scene318(vm); + case 319: // doctor Slache closeup (lying on the gurney) + return new Scene319(vm); + case 320: // warden's desk closeup / monitors + return new Scene320(vm); + case 321: // gender bender sex change sequence + return new Scene321(vm); + case 322: // inside teleporter + return new Scene322(vm); + case 351: // outside teleporter (after chaos) + return new Scene351(vm); + case 352: // room with statue (after chaos) + return new Scene352(vm); + case 353: // western corridor (after chaos) + return new Scene353(vm); + case 354: // crossing with traffic light (after chaos) + return new Scene354(vm); + case 357: // Rex's cell (after chaos) + return new Scene357(vm); + case 358: // sauropod's cell (after chaos) + return new Scene358(vm); + case 359: // multihand monster's cell (after chaos) + return new Scene359(vm); + case 360: // empty cell (after chaos) + return new Scene360(vm); + case 361: // warden's desk (after chaos) + return new Scene361(vm); + case 366: // air shaft ending at Gender Bender + return new Scene366(vm); + case 387: // air shaft ending at cell + return new Scene387(vm); + case 388: // air shaft ending at sauropod's cell + return new Scene388(vm); + case 389: // air shaft ending at multihand monster's cell (before chaos) + return new Scene389(vm); + case 390: // air shaft ending at cell + return new Scene390(vm); + case 391: // air shaft ending at warden's desk + return new Scene391(vm); + case 399: // air shaft ending at multihand monster's cell (after chaos) + return new Scene399(vm); + + // Scene group #4 (women's base) + case 401: // outside bar + return new Scene401(vm); + case 402: // inside bar + return new Scene402(vm); + case 405: // outside armory + return new Scene405(vm); + case 406: // outside storage room + return new Scene406(vm); + case 407: // eastern corridor + return new Scene407(vm); + case 408: // inside armory + return new Scene408(vm); + case 409: // inside female only teleporter + return new Scene409(vm); + case 410: // inside storage room + return new Scene410(vm); + case 411: // lab + return new Scene411(vm); + case 413: // outside female only teleporter + return new Scene413(vm); + + // Scene group #5 (men's city, lower floor) + case 501: // outside car + return new Scene501(vm); + case 502: // inside male only teleporter + return new Scene502(vm); + case 503: // guard tower + return new Scene503(vm); + case 504: // inside car + return new Scene504(vm); + case 505: // car view screen + return new Scene505(vm); + case 506: // shopping street + return new Scene506(vm); + case 507: // inside software house + return new Scene507(vm); + case 508: // laser cannon + return new Scene508(vm); + case 511: // outside pleasure dome + return new Scene511(vm); + case 512: // inside pleasure dome + return new Scene512(vm); + case 513: // outside mall + return new Scene513(vm); + case 515: // overview + return new Scene515(vm); + case 551: // outside teleporter (with skeleton) + return new Scene551(vm); + + // Scene group #6 (men's city, upper floor) + case 601: // outside Bruce's house + return new Scene601(vm); + case 602: // Bruce's house, living room + return new Scene602(vm); + case 603: // Bruce's house, bedroom + return new Scene603(vm); + case 604: // viewport + return new Scene604(vm); + case 605: // viewport closeup + return new Scene605(vm); + case 607: // outside Abdul's garage + return new Scene607(vm); + case 608: // inside Abdul's garage + return new Scene608(vm); + case 609: // outside Buckluster video store + return new Scene609(vm); + case 610: // inside Buckluster video store + return new Scene610(vm); + case 611: // back alley + return new Scene611(vm); + case 612: // expressway / maintenance building + return new Scene612(vm); + case 620: // cutscene, viewport glass breaking + return new Scene620(vm); + + // Scene group #7 (submerged men's city / upper floor) + case 701: // outside elevator (after city is submerged) + return new Scene701(vm); + case 702: // outside teleporter (after city is submerged) + return new Scene702(vm); + case 703: // water + return new Scene703(vm); + case 704: // water, building in the distance + return new Scene704(vm); + case 705: // water, outside building + return new Scene705(vm); + case 706: // inside building, pedestral room, outside teleporter + return new Scene706(vm); + case 707: // teleporter + return new Scene707(vm); + case 710: // looking at pedestral room through binoculars + return new Scene710(vm); + case 711: // inside teleporter + return new Scene711(vm); + case 751: // outside elevator (before city is submerged) + return new Scene751(vm); + case 752: // outside teleporter (before city is submerged) + return new Scene752(vm); + + // Scene group #8 + case 801: // control room, outside teleporter + return new Scene801(vm); + case 802: // launch pad with destroyed ship + return new Scene802(vm); + case 803: // empty launch pad + return new Scene803(vm); + case 804: // inside Rex's ship - cockpit + return new Scene804(vm); + case 805: // service panel + return new Scene805(vm); + case 807: // teleporter + return new Scene807(vm); + case 808: // antigrav control + return new Scene808(vm); + case 810: // cutscene: Rex's ship leaving the planet + return new Scene810(vm); + + default: + error("Invalid scene %d called", scene._nextSceneId); + } +} + +/*------------------------------------------------------------------------*/ + +NebularScene::NebularScene(MADSEngine *vm) : SceneLogic(vm), + _globals(static_cast<GameNebular *>(vm->_game)->_globals), + _game(*static_cast<GameNebular *>(vm->_game)), + _action(vm->_game->_scene._action) { +} + +Common::String NebularScene::formAnimName(char sepChar, int suffixNum) { + return Resources::formatName(_scene->_currentSceneId, sepChar, suffixNum, + EXT_NONE, ""); +} + +/*------------------------------------------------------------------------*/ + +void SceneInfoNebular::loadCodes(MSurface &depthSurface, int variant) { + File f(Resources::formatName(RESPREFIX_RM, _sceneId, ".DAT")); + MadsPack codesPack(&f); + Common::SeekableReadStream *stream = codesPack.getItemStream(variant + 1); + + loadCodes(depthSurface, stream); + + delete stream; + f.close(); +} + +void SceneInfoNebular::loadCodes(MSurface &depthSurface, Common::SeekableReadStream *stream) { + byte *destP = depthSurface.getData(); + byte *endP = depthSurface.getBasePtr(0, depthSurface.h); + + byte runLength = stream->readByte(); + while (destP < endP && runLength > 0) { + byte runValue = stream->readByte(); + + // Write out the run length + Common::fill(destP, destP + runLength, runValue); + destP += runLength; + + // Get the next run length + runLength = stream->readByte(); + } + + if (destP < endP) + Common::fill(destP, endP, 0); +} + +/*------------------------------------------------------------------------*/ + +int SceneTeleporter::teleporterAddress(int code, bool working) { + int limit = working ? 6 : 10; + + for (int i = 0; i < limit; i++) { + if (code == _globals[kTeleporterCode + i]) + return _globals[kTeleporterRoom + i]; + } + + return -1; +} + +Common::Point SceneTeleporter::teleporterComputeLocation() { + Common::Point result; + + switch (_buttonTyped) { + case 0: + result = Common::Point(179, 200); + break; + + case 1: + result = Common::Point(166, 170); + break; + + case 2: + result = Common::Point(179, 170); + break; + + case 3: + result = Common::Point(192, 170); + break; + + case 4: + result = Common::Point(166, 180); + break; + + case 5: + result = Common::Point(179, 180); + break; + + case 6: + result = Common::Point(192, 180); + break; + + case 7: + result = Common::Point(166, 190); + break; + + case 8: + result = Common::Point(179, 190); + break; + + case 9: + result = Common::Point(192, 190); + break; + + case 10: + result = Common::Point(194, 200); + break; + + case 11: + result = Common::Point(164, 200); + break; + + default: + error("teleporterComputeLocation() - Unexpected button pressed"); + } + + return result; +} + +void SceneTeleporter::teleporterHandleKey() { + switch (_game._trigger) { + case 0: { + _game._player._stepEnabled = false; + Common::Point msgPos = teleporterComputeLocation(); + _handSequenceId = _scene->_sequences.startReverseCycle(_handSpriteId, false, 4, 2, 0, 0); + _scene->_sequences.setPosition(_handSequenceId, msgPos); + _scene->_sequences.setDepth(_handSequenceId, 2); + _scene->_sequences.addSubEntry(_handSequenceId, SEQUENCE_TRIGGER_LOOP, 0, 1); + _scene->_sequences.addSubEntry(_handSequenceId, SEQUENCE_TRIGGER_EXPIRE, 0, 2); + + if (_globals[kMeteorologistWatch] == METEOROLOGIST_NORMAL) + _vm->_events->hideCursor(); + + } + break; + + case 1: + _scene->_sequences.addSubEntry(_handSequenceId, SEQUENCE_TRIGGER_SPRITE, 3, 3); + if (_buttonTyped <= 9) { + if (_digitCount < 4) { + _curCode *= 10; + _curCode += _buttonTyped; + _digitCount++; + _msgText = Common::String::format("%d", _curCode); + if (_digitCount < 4) + _msgText += "_"; + + if (_scene->_currentSceneId != 711) + _vm->_sound->command(32); + } + } else if (_buttonTyped == 11) { + _digitCount = 0; + _curCode = 0; + _msgText = "_"; + if (_scene->_currentSceneId != 711) + _vm->_sound->command(33); + } else if (_digitCount == 4) { + if (_scene->_currentSceneId != 711) + _finishedCodeCounter = 1; + + if (teleporterAddress(_curCode, true) > 0) { + _vm->_palette->setEntry(252, 0, 63, 0); + if (_scene->_currentSceneId != 711) + _vm->_sound->command(34); + } else { + _vm->_palette->setEntry(252, 63, 0, 0); + if (_scene->_currentSceneId != 711) + _vm->_sound->command(35); + } + } + + if (_scene->_currentSceneId != 711) { + if (_curMessageId >= 0) + _scene->_kernelMessages.remove(_curMessageId); + _curMessageId = _scene->_kernelMessages.add(Common::Point(143, 61), 0xFDFC, 16, 0, 9999999, _msgText); + } + break; + + case 2: + if (_finishedCodeCounter == 1) { + _finishedCodeCounter++; + + if (_globals[kMeteorologistWatch] != METEOROLOGIST_NORMAL) + _scene->_nextSceneId = 202; + else { + _vm->_events->showCursor(); + int destination = teleporterAddress(_curCode, true); + + if (destination > 0) { + _globals[kTeleporterCommand] = 2; + _scene->_nextSceneId = _teleporterSceneId; + _globals[kTeleporterDestination] = destination; + } else { + _globals[kTeleporterCommand] = 4; + _scene->_nextSceneId = _teleporterSceneId; + } + } + } else if (_globals[kMeteorologistWatch] != METEOROLOGIST_NORMAL) + _scene->_sequences.addTimer(30, 230 + _meteorologistCurPlace); + + break; + + case 3: + if (!_finishedCodeCounter) { + if (_globals[kMeteorologistWatch] == METEOROLOGIST_NORMAL) { + _game._player._stepEnabled = true; + _vm->_events->showCursor(); + } + } + break; + + default: + break; + } +} + +void SceneTeleporter::teleporterEnter() { + _game._player._visible = false; + _game._player._stepEnabled = (_globals[kMeteorologistWatch] == METEOROLOGIST_NORMAL); + _scene->_kernelMessages._talkFont = _vm->_font->getFont(FONT_TELE); + _scene->_textSpacing = 0; + _curCode = 0; + _digitCount = 0; + _finishedCodeCounter = 0; + _curMessageId = -1; + _msgText = "_"; + + if (_scene->_priorSceneId == -2) + _scene->_priorSceneId = _globals[kTeleporterDestination]; + + if (_scene->_priorSceneId < 101) + _scene->_priorSceneId = 201; + + _globals[kTeleporterDestination] = _scene->_priorSceneId; + _vm->_palette->setEntry(252, 63, 63, 0); + _vm->_palette->setEntry(253, 0, 0, 0); + _teleporterSceneId = _scene->_priorSceneId; + if (_teleporterSceneId == 202) + _teleporterSceneId = 201; + + int tmpVal = 0; + for (int i = 0; i < 10; i++) { + if (_teleporterSceneId == _globals[kTeleporterRoom + i]) + tmpVal = _globals[kTeleporterRoom + i]; + + if (_globals[kTeleporterRoom + i] == 301) + _meteorologistNextPlace = _globals[kTeleporterCode + i]; + } + + Common::String msgText2 = Common::String::format("#%.4d", tmpVal); + + if (_scene->_currentSceneId != 711) { + _scene->_kernelMessages.add(Common::Point(133, 34), 0, 32, 0, 9999999, msgText2); + _scene->_kernelMessages.add(Common::Point(143, 61), 0xFDFC, 16, 0, 9999999, _msgText); + } + + _meteorologistCurPlace = 0; + + if (_globals[kMeteorologistWatch] != METEOROLOGIST_NORMAL) + _scene->_sequences.addTimer(30, 230); + + _vm->_sound->command(36); +} + +bool SceneTeleporter::teleporterActions() { + bool retVal = false; + static int _buttonList[12] = { NOUN_0_KEY, NOUN_1_KEY, NOUN_2_KEY, NOUN_3_KEY, NOUN_4_KEY, NOUN_5_KEY, NOUN_6_KEY, NOUN_7_KEY, NOUN_8_KEY, NOUN_9_KEY, NOUN_SMILE_KEY, NOUN_FROWN_KEY }; + + if (_action.isAction(VERB_PRESS) || _action.isAction(VERB_PUSH)) { + for (int i = 0; i < 12; i++) { + if (_action._activeAction._objectNameId == _buttonList[i]) + _buttonTyped = i; + } + teleporterHandleKey(); + retVal = true; + } + + if (_action.isAction(VERB_EXIT_FROM, NOUN_DEVICE)) { + _globals[kTeleporterCommand] = 3; + _scene->_nextSceneId = _teleporterSceneId; + retVal = true; + } + + return (retVal); +} + +void SceneTeleporter::teleporterStep() { + if (_globals[kMeteorologistWatch] == METEOROLOGIST_NORMAL) + return; + + if (_game._trigger >= 230) { + int place = _game._trigger - 230; + int digit; + + if (place < 4) { + digit = _meteorologistNextPlace; + for (int i = 0; i < (3 - place); i++) + digit = digit / 10; + + digit = digit % 10; + } else { + digit = 10; + } + _buttonTyped = digit; + _meteorologistCurPlace = place + 1; + _game._trigger = -1; + } + + if (_game._trigger) { + if (_game._trigger == -1) + _game._trigger = 0; + teleporterHandleKey(); + } +} + +} // End of namespace Nebular + +} // End of namespace MADS diff --git a/engines/mads/nebular/nebular_scenes.h b/engines/mads/nebular/nebular_scenes.h new file mode 100644 index 0000000000..8df43e92e9 --- /dev/null +++ b/engines/mads/nebular/nebular_scenes.h @@ -0,0 +1,1383 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_NEBULAR_SCENES_H +#define MADS_NEBULAR_SCENES_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/scene.h" +#include "mads/nebular/game_nebular.h" +#include "mads/nebular/globals_nebular.h" + + +namespace MADS { + +namespace Nebular { + +enum { + SEX_MALE = 0, SEX_UNKNOWN = 1, SEX_FEMALE = 2 +}; + +enum Verb { + VERB_ACTIVATE = 0x00E, + VERB_ATTACH = 0x019, + VERB_BREAK = 0x032, + VERB_BREATHE_AIR = 0x033, + VERB_CAST = 0x03D, + VERB_CLIMB_DOWN = 0x04E, + VERB_CLIMB_THROUGH = 0x04F, + VERB_CLIMB_UP = 0x050, + VERB_CUT = 0x061, + VERB_DAMPEN = 0x064, + VERB_DIVE_INTO = 0x06D, + VERB_DRINK = 0x072, + VERB_EAT = 0x075, + VERB_EXAMINE = 0x07D, + VERB_HOSE_DOWN = 0x0A6, + VERB_IGNITE = 0x0B4, + VERB_INFLATE = 0x0B5, + VERB_INSERT = 0x0B6, + VERB_INSPECT = 0x0B7, + VERB_HURL = 0x0A9, + VERB_LOOK_AT = 0x0D1, + VERB_LOOK_IN = 0x0D2, + VERB_LOOK_THROUGH = 0x0D3, + VERB_PEER_THROUGH = 0x103, + VERB_PLAY = 0x112, + VERB_PRESS = 0x11A, + VERB_PRY = 0x11C, + VERB_READ = 0x11F, + VERB_SHOOT = 0x13A, + VERB_SIT_IN = 0x13F, + VERB_SMELL = 0x147, + VERB_STARE_AT = 0x155, + VERB_SWIM_INTO = 0x15A, + VERB_SWIM_THROUGH = 0x15B, + VERB_SWIM_TO = 0x15C, + VERB_SWIM_TOWARDS = 0x15D, + VERB_SWIM_UNDER = 0x15E, + VERB_UNLOCK = 0x17B, + VERB_WALK_INSIDE = 0x188, + VERB_WALK_THROUGH = 0x18B, + VERB_WALK_TOWARDS = 0x18C, + VERB_WALK_DOWN = 0x1AD, + VERB_LEAVE = 0x1CD, + VERB_EXIT_FROM = 0x1CE, + VERB_USE = 0x20C, + VERB_SIT_AT = 0x21F, + VERB_WALK_UP = 0x227, + VERB_WALK_INTO = 0x242, + VERB_EXIT = 0x298, + VERB_WALK_ONTO = 0x2B5, + VERB_RETURN_TO = 0x2D5, + VERB_CLIMB_INTO = 0x2F7, + VERB_STEP_INTO = 0x2F9, + VERB_CRAWL_TO = 0x2FB, + VERB_SIT_ON = 0x30B, + VERB_WALK_ALONG = 0x312, + VERB_WALK = 0x32F, + VERB_REFLECT = 0x365, + VERB_GET_INTO = 0x36A, + VERB_ENTER = 0x3B8, + VERB_INSTALL = 0x474, + VERB_REMOVE = 0x476 +}; + +enum Noun { + //NOUN_GAME = 0x1, + //NOUN_QSAVE = 0x2, + //NOUN_LOOK = 0x3, + //NOUN_TAKE = 0x4, + //NOUN_PUSH = 0x5, + //NOUN_OPEN = 0x6, + //NOUN_PUT = 0x7, + //NOUN_TALK_TO = 0x8, + //NOUN_GIVE = 0x9, + //NOUN_PULL = 0xA, + //NOUN_CLOSE = 0xB, + //NOUN_THROW = 0xC, + //NOUN_WALK_TO = 0xD, + //NOUN_ACTIVATE = 0xE, + //NOUN_ADMIRE = 0xF, + NOUN_ADSM = 0x10, + NOUN_AIR_VENT = 0x11, + NOUN_ALOE_PLANT = 0x12, + NOUN_ANEMONE = 0x13, + NOUN_ANOMOMETER = 0x14, + NOUN_AREA_AROUND_HUT = 0x15, + NOUN_AREA_TO_SOUTH = 0x16, + NOUN_AREA_TO_WEST = 0x17, + NOUN_AROMATIC_MEAT = 0x18, + //NOUN_ATTACH = 0x19, + NOUN_AUDIO_TAPE = 0x1A, + NOUN_AUXILIARY_POWER = 0x1B, + NOUN_BADMITTON_BRAT = 0x1C, + NOUN_BAG = 0x1D, + NOUN_BAMBOO_TREE = 0x1E, + NOUN_BATS = 0x1F, + NOUN_BAWLEMER_ORIOLE_HUN = 0x20, + NOUN_BEAR_RUG = 0x21, + NOUN_BEASTLY_TROPHY = 0x22, + NOUN_BIG_LEAVES = 0x23, + NOUN_BIG_PIPES = 0x24, + NOUN_BIG_SKY = 0x25, + NOUN_BIG_STONE = 0x26, + NOUN_BINOCULARS = 0x27, + NOUN_BIRDIES = 0x28, + NOUN_BLOWGUN = 0x29, + NOUN_BOMB = 0x2A, + NOUN_BOMBS = 0x2B, + NOUN_BONE = 0x2C, + NOUN_BONES = 0x2D, + NOUN_BOTTLE = 0x2E, + NOUN_BOULDER = 0x2F, + NOUN_BOULDERS = 0x30, + NOUN_BRA = 0x31, + //NOUN_BREAK = 0x32, + //NOUN_BREATHE_AIR = 0x33, + NOUN_BULKHEAD = 0x34, + NOUN_BURGER = 0x35, + NOUN_BURN = 0x36, + NOUN_BURNT_OUT_WARP_COIL = 0x37, + NOUN_BUSH_LIKE_FORMATION = 0x38, + NOUN_BUSHES = 0x39, + NOUN_BUSHY_FERN = 0x3A, + NOUN_CACTUS = 0x3B, + NOUN_CARD = 0x3C, + //NOUN_CAST = 0x3D, + NOUN_CAULDRON = 0x3E, + NOUN_CAVE = 0x3F, + NOUN_CAVE_CEILING = 0x40, + NOUN_CAVE_ENTRANCE = 0x41, + NOUN_CAVE_EXIT = 0x42, + NOUN_CAVE_FLOOR = 0x43, + NOUN_CAVE_TO_EAST = 0x44, + NOUN_CAVE_WALL = 0x45, + NOUN_CEILING = 0x46, + NOUN_CHAIR = 0x47, + NOUN_CHARGE_CASES = 0x48, + NOUN_CHICKEN = 0x49, + NOUN_CHICKEN_BOMB = 0x4A, + NOUN_CLEARING_TO_EAST = 0x4B, + NOUN_CLEARING_TO_SOUTH = 0x4C, + NOUN_CLIFF_FACE = 0x4D, + NOUN_CLIMB_DOWN = 0x4E, + NOUN_CLIMB_THROUGH = 0x4F, + NOUN_CLIMB_UP = 0x50, + NOUN_CLOCK = 0x51, + NOUN_CLOSET = 0x52, + NOUN_CLOTHESLINE = 0x53, + NOUN_CLUMP_OF_TREES = 0x54, + NOUN_COAL = 0x55, + NOUN_COCOANUT = 0x56, + NOUN_COMPACT_CASE = 0x57, + NOUN_COMPUTER_GAME = 0x58, + NOUN_CONTROL_PANEL = 0x59, + NOUN_CORAL = 0x5A, + NOUN_CRAB = 0x5B, + NOUN_CREDIT_CHIP = 0x5C, + NOUN_CUMULOUS_CLOUD = 0x5D, + NOUN_CURIOUS_WEED_PATCH = 0x5E, + NOUN_CURTAIN = 0x5F, + NOUN_CURTAINS = 0x60, + //NOUN_CUT = 0x61, + NOUN_DAMAGE_CONTROL = 0x62, + NOUN_DAMAGE_CONTROL_PANEL = 0x63, + //NOUN_DAMPEN = 0x64, + NOUN_DEAD_FISH = 0x65, + NOUN_DEAD_PURPLE_MONSTER = 0x66, + NOUN_DECLIVITOUS_CHASM = 0x67, + NOUN_DEEP_DARK_FOREST = 0x68, + NOUN_DENSE_FOREST = 0x69, + NOUN_DETONATORS = 0x6A, + NOUN_DINO_MITE = 0x6B, + //NOUN_DISASSEMBLE = 0x6C, + //NOUN_DIVE_INTO = 0x6D, + NOUN_DOOR = 0x6E, + NOUN_DOOR_KEY = 0x6F, + NOUN_DOORWAY = 0x70, + NOUN_DRAWER = 0x71, + //NOUN_DRINK = 0x72, + NOUN_DURAFAIL_CELLS = 0x73, + NOUN_EASTERN_CLIFF_FACE = 0x74, + //NOUN_EAT = 0x75, + //NOUN_EJECT = 0x76, + //NOUN_EMPTY = 0x77, + NOUN_ENGINEERING_CONTROLS = 0x78, + NOUN_ENGINEERING_SECTION = 0x79, + NOUN_ENTER_KEY = 0x7A, + NOUN_ESCAPE_HATCH = 0x7B, + NOUN_ESTROTOXIN = 0x7C, + //NOUN_EXAMINE = 0x7D, + NOUN_EXPERIMENT_CAGE = 0x7E, + NOUN_EXTINGUISH = 0x7F, + NOUN_FACE_ID = 0x80, + NOUN_FERN = 0x81, + NOUN_FIELD_TO_NORTH = 0x82, + NOUN_FIELD_TO_SOUTH = 0x83, + NOUN_FIELD_TO_WEST = 0x84, + NOUN_FILL = 0x85, + NOUN_FIRE_PIT = 0x86, + NOUN_FISHING_LINE = 0x87, + NOUN_FISHING_ROD = 0x88, + NOUN_FLOOR = 0x89, + NOUN_FLOOR_OF_HUT = 0x8A, + NOUN_FLOOR_TILE = 0x8B, + //NOUN_FONDLE = 0x8C, + NOUN_FOREST_TO_EAST = 0x8D, + NOUN_FRONT_WINDOW = 0x8E, + NOUN_FUNGOIDS = 0x8F, + NOUN_FURNACE = 0x90, + NOUN_FUZZY_DICE = 0x91, + //NOUN_GAZE = 0x92, + //NOUN_GAZE_AT = 0x93, + //NOUN_GAZE_IN = 0x94, + //NOUN_GLANCE_AT = 0x95, + NOUN_GLOVE = 0x96, + NOUN_GNARLY_SHRUB = 0x97, + //NOUN_GNAW_ON = 0x98, + //NOUN_GORGE_ON = 0x99, + NOUN_GRAIN_ALCHOHOL = 0x9A, + NOUN_GRASSLAND_TO_EAST = 0x9B, + NOUN_GRASSLAND_TO_SOUTH = 0x9C, + NOUN_GRASSY_AREA = 0x9D, + NOUN_GRASSY_AREA_TO_NORTH = 0x9E, + NOUN_GRASSY_KNOLL = 0x9F, + //NOUN_GRIND = 0xA0, + NOUN_GROOVILACTIC_TREE = 0xA1, + NOUN_GUARDS_ARM = 0xA2, + NOUN_HATCHWAY = 0xA3, + //NOUN_HOOK_UP = 0xA4, + NOUN_HORIZON = 0xA5, + //NOUN_HOSE_DOWN = 0xA6, + NOUN_HOTPANTS = 0xA7, + NOUN_HULL = 0xA8, + //NOUN_HURL = 0xA9, + NOUN_HUT = 0xAA, + NOUN_HUT_AREA = 0xAB, + NOUN_HUT_TO_EAST = 0xAC, + NOUN_HUT_TO_SOUTH = 0xAD, + NOUN_HUT_TO_THE_SOUTH = 0xAE, + NOUN_HUT_TO_WEST = 0xAF, + NOUN_HUTS_TO_NORTH = 0xB0, + NOUN_HYDROSPANNER = 0xB1, + NOUN_HYPERDRIVE_JUMP_UNIT = 0xB2, + NOUN_ID_CARD = 0xB3, + //NOUN_IGNITE = 0xB4, + //NOUN_INFLATE = 0xB5, + //NOUN_INSERT = 0xB6, + //NOUN_INSPECT = 0xB7, + NOUN_JUNGLE = 0xB8, + NOUN_JUNGLE_TO_EAST = 0xB9, + NOUN_JUNGLE_TO_WEST = 0xBA, + NOUN_KEY_1 = 0xBB, + NOUN_KEY_2 = 0xBC, + NOUN_KEY_3 = 0xBD, + NOUN_KEY_4 = 0xBE, + NOUN_KEY_5 = 0xBF, + NOUN_KEY_6 = 0xC0, + NOUN_KEY_7 = 0xC1, + NOUN_KEY_8 = 0xC2, + NOUN_KEY_9 = 0xC3, + NOUN_KEYPAD = 0xC4, + NOUN_KNEELING_WOMAN = 0xC5, + NOUN_KNIFE = 0xC6, + NOUN_LADDER = 0xC7, + NOUN_LARGE_STALAGMITE = 0xC8, + //NOUN_LEER_AT = 0xC9, + NOUN_LIBRARY_COMPUTER = 0xCA, + //NOUN_LICK = 0xCB, + NOUN_LIFE_SUPPORT_SECTION = 0xCC, + NOUN_LIGHT = 0xCD, + //NOUN_LOAD = 0xCE, + //NOUN_LOCK = 0xCF, + NOUN_LOG = 0xD0, + //NOUN_LOOK_AT = 0xD1, + //NOUN_LOOK_IN = 0xD2, + //NOUN_LOOK_THROUGH = 0xD3, + NOUN_LOUNGE_AREA = 0xD4, + NOUN_LOVE_ALTAR = 0xD5, + NOUN_LOWLANDS = 0xD6, + NOUN_MACHINE = 0xD7, + NOUN_MAGNET = 0xD8, + NOUN_MAIN_AIRLOCK = 0xD9, + NOUN_MANTA_RAY = 0xDA, + NOUN_MARSHY_WETLANDS = 0xDB, + NOUN_MATCH = 0xDC, + NOUN_MEDICAL_WASTE = 0xDD, + NOUN_MEDICINE_CABINET = 0xDE, + NOUN_MEN_WHO_CAME_BEFORE = 0xDF, + NOUN_MINE = 0xE0, + NOUN_MIRROR = 0xE1, + NOUN_MONITOR = 0xE2, + NOUN_MONKEY = 0xE3, + NOUN_MONKEY_LIVER_JUICE = 0xE4, + NOUN_MONSTER_SLUDGE = 0xE5, + NOUN_MOUNTAIN = 0xE6, + NOUN_MOUNTAIN_RANGE = 0xE7, + NOUN_MOUNTAINS = 0xE8, + NOUN_MTAM = 0xE9, + NOUN_MUSHROOMS = 0xEA, + NOUN_NAVIGATION_CONTROLS = 0xEB, + NOUN_NORTH_PATH = 0xEC, + NOUN_NORTHERN_EXPOSURE = 0xED, + NOUN_NORTHERN_SEA_CLIFF = 0xEE, + NOUN_OBSTACLE = 0xEF, + NOUN_OCEAN_FLOOR = 0xF0, + NOUN_ODD_ROCK_FORMATION = 0xF1, + NOUN_OOGLY_BOOGLY_JUICE = 0xF2, + NOUN_OPEN_AREA_TO_EAST = 0xF3, + NOUN_OPEN_AREA_TO_NORTH = 0xF4, + NOUN_OPEN_AREA_TO_SOUTH = 0xF5, + NOUN_OPEN_AREA_TO_WEST = 0xF6, + NOUN_OPEN_FIELD = 0xF7, + NOUN_OUTER_HULL = 0xF8, + NOUN_OUTSIDE = 0xF9, + NOUN_OVEN = 0xFA, + NOUN_OVERHANG_TO_EAST = 0xFB, + NOUN_OVERHANG_TO_WEST = 0xFC, + NOUN_OVERHEAD_LAMP = 0xFD, + NOUN_PAD_OF_PAPER = 0xFE, + NOUN_PADLOCK_KEY = 0xFF, + NOUN_PALM_TREE = 0x100, + NOUN_PASSAGE_WAY_TO_SOUTH = 0x101, + NOUN_PASSION_PUSS = 0x102, + NOUN_PEER_THROUGH = 0x103, + NOUN_PENCIL = 0x104, + NOUN_PENDULOUS_CRAG = 0x105, + NOUN_PENLIGHT = 0x106, + NOUN_PHONE_CELLS = 0x107, + NOUN_PHONE_HANDSET = 0x108, + NOUN_PILE_OF_ROCKS = 0x109, + NOUN_PILLOW = 0x10A, + NOUN_PILOTS_CHAIR = 0x10B, + NOUN_PIPE = 0x10C, + NOUN_PIRANHA = 0x10D, + NOUN_PLANT = 0x10E, + NOUN_PLANT_STALK = 0x10F, + NOUN_PLANTS = 0x110, + NOUN_PLASTIC_JESUS = 0x111, + //NOUN_PLAY = 0x112, + NOUN_PLUNGER = 0x113, + NOUN_POISON_DARTS = 0x114, + NOUN_POLYCEMENT = 0x115, + NOUN_POOL = 0x116, + NOUN_POSTER = 0x117, + NOUN_POWER_STATUS_PANEL = 0x118, + NOUN_PRECIPICE = 0x119, + //NOUN_PRESS = 0x11A, + NOUN_PRESSURE_GAUGE = 0x11B, + //NOUN_PRY = 0x11C, + NOUN_RAGING_RIVER = 0x11D, + NOUN_RAMOLYAN_RUGBY_RATS = 0x11E, + //NOUN_READ = 0x11F, + NOUN_REARVIEW_MIRROR = 0x120, + NOUN_REBREATHER = 0x121, + NOUN_REFRIGERATOR = 0x122, + NOUN_REMOTE = 0x123, + NOUN_REPAIR_LIST = 0x124, + NOUN_RIVER = 0x125, + NOUN_RIVER_TO_WEST = 0x126, + NOUN_ROBO_KITCHEN = 0x127, + NOUN_ROCK = 0x128, + NOUN_ROCKS = 0x129, + NOUN_ROCKY_AREA = 0x12A, + NOUN_ROLLING_HILL = 0x12B, + NOUN_SCALPEL = 0x12C, + NOUN_SCENIC_MOUNTAINS = 0x12D, + NOUN_SEA_CLIFF = 0x12E, + NOUN_SEAWEED = 0x12F, + NOUN_SEAWEED_BANK = 0x130, + NOUN_SECURITY_CARD = 0x131, + //NOUN_SET = 0x132, + NOUN_SHAKE_HANDS = 0x133, + NOUN_SHARPEN = 0x134, + NOUN_SHIELD_ACCESS_PANEL = 0x135, + NOUN_SHIELD_GENERATOR = 0x136, + NOUN_SHIELD_MODULATOR = 0x137, + NOUN_SHIELD_STATUS_PANEL = 0x138, + NOUN_SHIP = 0x139, + //NOUN_SHOOT = 0x13A, + NOUN_SHOVEL = 0x13B, + //NOUN_SHRED = 0x13C, + NOUN_SHRUNKEN_HEADS = 0x13D, + NOUN_SINGED_MEAT = 0x13E, + //NOUN_SIT_IN = 0x13F, + NOUN_SKULL = 0x140, + NOUN_SKULL_AND_CROSSBONES = 0x141, + NOUN_SKY = 0x142, + //NOUN_SLEEP_ON = 0x143, + NOUN_SLITHERING_SNAKE = 0x144, + NOUN_SLUG_SECRETION = 0x145, + NOUN_SMALL_HOLE = 0x146, + //NOUN_SMELL = 0x147, + NOUN_SNAKE = 0x148, + //NOUN_SNIFF = 0x149, + //NOUN_SOAK = 0x14A, + NOUN_SPECIAL_KEY_1 = 0x14B, + NOUN_SPECIAL_KEY_2 = 0x14C, + NOUN_SPIDER = 0x14D, + NOUN_SPILT_MILK = 0x14E, + NOUN_SPIT_FIRE = 0x14F, + //NOUN_SPRAY = 0x150, + //NOUN_STAB = 0x151, + NOUN_STAIRS = 0x152, + NOUN_STALAGMITES = 0x153, + //NOUN_STAND_INSIDE = 0x154, + //NOUN_STARE_AT = 0x155, + NOUN_STEPS = 0x156, + NOUN_STUFFED_FISH = 0x157, + NOUN_SURFACE = 0x158, + //NOUN_SWIM_ACROSS = 0x159, + //NOUN_SWIM_INTO = 0x15A, + //NOUN_SWIM_THROUGH = 0x15B, + //NOUN_SWIM_TO = 0x15C, + //NOUN_SWIM_TOWARDS = 0x15D, + //NOUN_SWIM_UNDER = 0x15E, + NOUN_SWOOPING_CREATURE = 0x15F, + NOUN_TABLE = 0x160, + //NOUN_TAKE_LIVER = 0x161, + //NOUN_TAKE_OFF = 0x162, + //NOUN_TAKE_PAGE = 0x163, + NOUN_TALL_GRASS = 0x164, + NOUN_TAPE_PLAYER = 0x165, + NOUN_TARGET_COMPUTER = 0x166, + NOUN_TARGET_MODULE = 0x167, + NOUN_TARGETTING_COMPUTER = 0x168, + NOUN_TASMANIAN_DEVIL = 0x169, + NOUN_TASTY_TURKEY = 0x16A, + NOUN_TELEPORT_DEVICE = 0x16B, + NOUN_TELEPORTER = 0x16C, + NOUN_THATCHED_ROOF = 0x16D, + NOUN_THORNS = 0x16E, + NOUN_THORNY_BUSH = 0x16F, + //NOUN_TIE = 0x170, + NOUN_TIMEBOMB = 0x171, + NOUN_TIMER = 0x172, + NOUN_TIMER_MODULE = 0x173, + NOUN_TREE = 0x174, + NOUN_TREES = 0x175, + NOUN_TRODDEN_PATH = 0x176, + NOUN_TUBE = 0x177, + NOUN_TUNNEL = 0x178, + NOUN_TWINKIE_BUSH = 0x179, + NOUN_TWINKIFRUIT = 0x17A, + //NOUN_UNLOCK = 0x17B, + NOUN_UZI = 0x17C, + NOUN_VASE = 0x17D, + NOUN_VIDEO_GAME = 0x17E, + //NOUN_VIEW = 0x17F, + NOUN_VIEW_SCREEN = 0x180, + NOUN_VIEWPORT = 0x181, + NOUN_VILLAGE_AREA = 0x182, + NOUN_VILLAGE_TO_WEST = 0x183, + NOUN_VOLCANO = 0x184, + NOUN_VULTURE = 0x185, + NOUN_WAD_OF_CATTLE_PARTS = 0x186, + //NOUN_WALK_ACROSS = 0x187, + //NOUN_WALK_INSIDE = 0x188, + //NOUN_WALK_ON = 0x189, + //NOUN_WALK_OUTSIDE = 0x18A, + //NOUN_WALK_THROUGH = 0x18B, + //NOUN_WALK_TOWARDS = 0x18C, + NOUN_WALL = 0x18D, + NOUN_WATCH_TOWER = 0x18E, + NOUN_WATER = 0x18F, + NOUN_WEAPONS_DISPLAY = 0x190, + //NOUN_WEAR = 0x191, + NOUN_WEATHER_STATION = 0x192, + NOUN_WEATHER_VANE = 0x193, + NOUN_WEIGHT_MACHINE = 0x194, + NOUN_WESTERN_CLIFF_FACE = 0x195, + NOUN_WHEEL = 0x196, + NOUN_WINDOW = 0x197, + NOUN_WITCHDOCTOR_HUT = 0x198, + NOUN_WORKBENCH = 0x199, + //NOUN_WRITE_ON = 0x19A, + NOUN_YELLOW_BIRDY = 0x19B, + NOUN_GRASS = 0x19C, + NOUN_BOUNCING_REPTILE = 0x19D, + NOUN_DEEP_PIT = 0x19E, + NOUN_LOWLANDS_TO_NORTH = 0x19F, + NOUN_SMALL_BUSH = 0x1A0, + NOUN_SMALL_CACTUS = 0x1A1, + NOUN_ROCKY_AREA_TO_NORTH = 0x1A2, + NOUN_BAMBOO_LIKE_PLANT = 0x1A3, + NOUN_MOUNTAINSIDE = 0x1A4, + NOUN_FIELD = 0x1A5, + NOUN_GRASSY_FIELD = 0x1A6, + NOUN_CRAG = 0x1A7, + NOUN_HUGE_LEGS = 0x1A8, + NOUN_LEAF_COVERED_PIT = 0x1A9, + NOUN_PILE_OF_LEAVES = 0x1AA, + NOUN_OPEN_FIELD_TO_EAST = 0x1AB, + NOUN_LAWN = 0x1AC, + //NOUN_WALK_DOWN = 0x1AD, + NOUN_PATH_TO_WEST = 0x1AE, + NOUN_HEDGE = 0x1AF, + NOUN_VILLAGE_PATH = 0x1B0, + NOUN_PATH_TO_NORTHEAST = 0x1B1, + NOUN_JUNGLE_PATH = 0x1B2, + NOUN_THICK_UNDERGROWTH = 0x1B3, + NOUN_OCEAN = 0x1B4, + NOUN_OCEAN_IN_DISTANCE = 0x1B5, + NOUN_STRANGE_DEVICE = 0x1B6, + NOUN_BUSH = 0x1B7, + NOUN_ANEMOMETER = 0x1B8, + NOUN_ISLAND_IN_DISTANCE = 0x1B9, + NOUN_PATH = 0x1BA, + NOUN_TROPHY = 0x1BB, + NOUN_SPECIMEN_JARS = 0x1BC, + NOUN_BOWL = 0x1BD, + NOUN_LARGE_BOWL = 0x1BE, + NOUN_PATH_TO_NORTH = 0x1BF, + NOUN_HUT_TO_NORTH = 0x1C0, + NOUN_PATH_TO_EAST = 0x1C1, + NOUN_CHICKEN_ON_SPIT = 0x1C2, + NOUN_CAPTIVE_CREATURE = 0x1C3, + NOUN_TWINKIFRUIT_BUSH = 0x1C4, + NOUN_STREAM = 0x1C5, + NOUN_OPPOSITE_SHORE = 0x1C6, + NOUN_PATH_TO_SOUTH = 0x1C7, + NOUN_OPPOSITE_BANK = 0x1C8, + NOUN_BROKEN_LADDER = 0x1C9, + NOUN_BAG_OF_TWINKIFRUITS = 0x1CA, + NOUN_BED = 0x1CB, + NOUN_DISPLAY = 0x1CC, + //NOUN_LEAVE = 0x1CD, + //NOUN_EXIT_FROM = 0x1CE, + NOUN_DEVICE = 0x1CF, + NOUN_0_KEY = 0x1D0, + NOUN_1_KEY = 0x1D1, + NOUN_2_KEY = 0x1D2, + NOUN_3_KEY = 0x1D3, + NOUN_4_KEY = 0x1D4, + NOUN_5_KEY = 0x1D5, + NOUN_6_KEY = 0x1D6, + NOUN_7_KEY = 0x1D7, + NOUN_8_KEY = 0x1D8, + NOUN_9_KEY = 0x1D9, + NOUN_FROWN_KEY = 0x1DA, + NOUN_SMILE_KEY = 0x1DB, + NOUN_NATIVE_WOMAN = 0x1DC, + NOUN_YELLOW_BIRD = 0x1DD, + NOUN_BLEEPER = 0x1DE, + NOUN_SIZEMOMETER = 0x1DF, + NOUN_PANEL = 0x1E0, + NOUN_PRINTER = 0x1E1, + NOUN_HARD_DRIVE = 0x1E2, + NOUN_BATHROOM = 0x1E3, + NOUN_DESK = 0x1E4, + NOUN_PASSAGEWAY = 0x1E5, + NOUN_FIRE_HYDRANT = 0x1E6, + NOUN_FREEZER = 0x1E7, + NOUN_EQUIDIGITIZER = 0x1E8, + NOUN_VISION_VIEW = 0x1E9, + NOUN_TELEDETECTOR = 0x1EA, + NOUN_POLE = 0x1EB, + NOUN_TRANSPOSITION_DEVICE = 0x1EC, + NOUN_STATUESQUE = 0x1ED, + NOUN_TEMPERATURE_GAUGE = 0x1EE, + NOUN_CHECK = 0x1EF, + NOUN_WATCH = 0x1F0, + NOUN_ELECTRO_SCANNER = 0x1F1, + NOUN_HALL = 0x1F2, + NOUN_SCANNER = 0x1F3, + //NOUN_PLACE_HAND_ON = 0x1F4, + NOUN_SECURITY_MONITOR = 0x1F5, + NOUN_DIGITORAMA = 0x1F6, + NOUN_RAIL_BEAM = 0x1F7, + NOUN_VAULT = 0x1F8, + NOUN_HALLWAY = 0x1F9, + NOUN_PIPES = 0x1FA, + NOUN_AIR_VENT_GRATE = 0x1FB, + NOUN_SECURITY_OFFICE = 0x1FC, + NOUN_SIGNAL = 0x1FD, + NOUN_BLEEP = 0x1FE, + NOUN_BLIP = 0x1FF, + NOUN_LOFT = 0x200, + NOUN_ELECTRONIC_ANT_FARM = 0x201, + NOUN_ELECTRIC_WIRING = 0x202, + NOUN_SECURITY_PANEL = 0x203, + NOUN_CORRIDOR = 0x204, + NOUN_CIRCUIT_CONTROLS = 0x205, + NOUN_AIR_DUCT = 0x206, + NOUN_CELL_WALL = 0x207, + NOUN_LIGHTS = 0x208, + //NOUN_STARE_INTO = 0x209, + NOUN_CELL_CONTROLS = 0x20A, + NOUN_COMMODE = 0x20B, + //NOUN_USE = 0x20C, + NOUN_BASIN = 0x20D, + //NOUN_JUMP_INSIDE = 0x20E, + NOUN_PREVIOUS_CELL = 0x20F, + NOUN_NEXT_ROOM = 0x210, + NOUN_ZINK = 0x211, + //NOUN_GAZE_INTO = 0x212, + NOUN_THRONE = 0x213, + NOUN_SACK = 0x214, + NOUN_LIMB = 0x215, + NOUN_SINK = 0x216, + NOUN_JOHNNY_ON_THE_SPOT = 0x217, + NOUN_DEBRIS = 0x218, + NOUN_BUNK = 0x219, + NOUN_NEXT_CELL = 0x21A, + NOUN_TOILET = 0x21B, + NOUN_MONITOR_AREA = 0x21C, + NOUN_SIDEWALL = 0x21D, + NOUN_COFFEE_MUG = 0x21E, + //NOUN_SIT_AT = 0x21F, + NOUN_LIGHTING_FIXTURE = 0x220, + NOUN_MONITORS = 0x221, + NOUN_GENDER_CONTROLS = 0x222, + NOUN_NEURO_ANALYZER = 0x223, + NOUN_MOLECULAR_RECORDER = 0x224, + NOUN_MAINTENANCE_PANEL = 0x225, + NOUN_RAMP = 0x226, + //NOUN_WALK_UP = 0x227, + NOUN_SUBSONIC_ATOMIZER = 0x228, + NOUN_EIGHT_BALL = 0x229, + NOUN_DNA_INVERTER = 0x22A, + NOUN_DNA_CONVERTER = 0x22B, + NOUN_PLATFORM = 0x22C, + NOUN_GUINEA_PIG_TEST_BOX = 0x22D, + NOUN_GASEOUS_PROBE_WARPER = 0x22E, + NOUN_TOOL_CABINET = 0x22F, + NOUN_SURGICAL_BOXES = 0x230, + NOUN_FETAL_HEART_MONITOR = 0x231, + NOUN_XRAY_CABINET = 0x232, + NOUN_STERILIZATION_SINK = 0x233, + NOUN_DRIPOLATOR = 0x234, + NOUN_SHOCK_MACHINE = 0x235, + NOUN_INTERROGATION_TABLE = 0x236, + NOUN_LIE_DOWN_ON = 0x237, + //NOUN_DECIPHER = 0x238, + NOUN_GUARD = 0x239, + NOUN_RIP_IN_FLOOR = 0x23A, + NOUN_TELEPORT_AREA = 0x23B, + NOUN_BROKEN_BEAM = 0x23C, + NOUN_ROCK_CHUNK = 0x23D, + NOUN_BLOODY_CELL_WALL = 0x23E, + NOUN_WALL_BOARD = 0x23F, + NOUN_GENDER_SCANNER = 0x240, + NOUN_BAR = 0x241, + //NOUN_WALK_INTO = 0x242, + NOUN_HALLWAY_TO_SOUTH = 0x243, + NOUN_SIGN = 0x244, + NOUN_HALLWAY_TO_NORTH = 0x245, + NOUN_BOTTLES = 0x246, + NOUN_UPPER_DANCE_FLOOR = 0x247, + NOUN_DANCE_FLOOR = 0x248, + NOUN_RAILING = 0x249, + NOUN_BAR_STOOL = 0x24A, + NOUN_LADY = 0x24B, + NOUN_UPPER_LEVEL = 0x24C, + NOUN_ALCOVE = 0x24D, + NOUN_DISCO_BALL = 0x24E, + NOUN_LADIES = 0x24F, + NOUN_COACH_LAMP = 0x250, + NOUN_CARD_SLOT = 0x251, + NOUN_HOOP = 0x252, + NOUN_CANNONBALLS = 0x253, + NOUN_WATER_FOUNTAIN = 0x254, + NOUN_HALLWAY_TO_EAST = 0x255, + NOUN_HALLWAY_TO_WEST = 0x256, + NOUN_SUPPORT = 0x257, + NOUN_BACKBOARD = 0x258, + NOUN_WIDE_DOOR = 0x259, + NOUN_SIGN_POST = 0x25A, + NOUN_FIRE_EXTINGUISHER = 0x25B, + NOUN_TRASH = 0x25C, + NOUN_MISSILES = 0x25D, + NOUN_TANK = 0x25E, + NOUN_TWO_TON_WEIGHT = 0x25F, + NOUN_ONE_TON_TOMATO = 0x260, + NOUN_ANVIL = 0x261, + NOUN_MINUTEMAN_IV_ICBM = 0x262, + NOUN_CHEST = 0x263, + NOUN_ARMOR = 0x264, + NOUN_CARTON = 0x265, + NOUN_POWDER = 0x266, + NOUN_RAFT = 0x267, + NOUN_WHATZIT = 0x268, + NOUN_CATAPULT = 0x269, + NOUN_HAND_GRENADE = 0x26A, + NOUN_BARRELS = 0x26B, + NOUN_LOADING_RAMP = 0x26C, + NOUN_BLIMP = 0x26D, + NOUN_FLOUR = 0x26E, + NOUN_FLY_PAPER = 0x26F, + NOUN_RUG = 0x270, + NOUN_CARPET = 0x271, + NOUN_CAN = 0x272, + NOUN_RUBBER_DUCKIE = 0x273, + NOUN_GOLF_CLUBS = 0x274, + NOUN_RAT = 0x275, + NOUN_BARREL = 0x276, + NOUN_BUCKET_OF_TAR = 0x277, + NOUN_SACKS = 0x278, + NOUN_STORAGE = 0x279, + NOUN_120V_3_PHASE_400HZ = 0x27A, + NOUN_LAB_EQUIPMENT = 0x27B, + NOUN_AIR_HORN = 0x27C, + NOUN_JAR = 0x27D, + NOUN_SEVERED_CABLE = 0x27E, + NOUN_PROBE_ASSEMBLY = 0x27F, + NOUN_KNIFE_SWITCH = 0x280, + NOUN_WORK_BENCH = 0x281, + NOUN_HEATER = 0x282, + NOUN_TOXIC_WASTE = 0x283, + NOUN_EXPERIMENT = 0x284, + NOUN_DRAWING_BOARD = 0x285, + NOUN_MISHAP = 0x286, + NOUN_AIR_PURIFIER = 0x287, + NOUN_DUMMY = 0x288, + NOUN_PICTURE = 0x289, + NOUN_BAGGAGE_CHECK = 0x28A, + NOUN_DEPARTURE_SCHEDULE = 0x28B, + NOUN_SHADE_OF_PALE = 0x28C, + NOUN_ITINERARY = 0x28D, + NOUN_BARGAIN_VAT = 0x28E, + NOUN_PENCILS = 0x28F, + NOUN_PAD_IF_PAPER = 0x290, + NOUN_DEEPEST_DEPTHS = 0x291, + NOUN_ROLODEX = 0x292, + NOUN_MONA_TISA = 0x293, + NOUN_ABSTRACT_ART = 0x294, + NOUN_SPACE_QUESTING_VIII = 0x295, + NOUN_THEATRICAL_ART = 0x296, + NOUN_METAL_POLE = 0x297, + NOUN_EXIT = 0x298, + NOUN_SWIRLING_LIGHT = 0x299, + NOUN_REGISTER = 0x29A, + NOUN_PEACHY_BUNS = 0x29B, + NOUN_OUR_TOWN = 0x29C, + NOUN_EMBROIDERED_ART = 0x29D, + NOUN_GEORGE_BUSH_ALIKE = 0x29E, + NOUN_COUNTER = 0x29F, + NOUN_SENSOR = 0x2A0, + NOUN_SOFTWARE_INFORMATION = 0x2A1, + NOUN_WALK_BEHIND = 0x2A2, + NOUN_BARGAINS = 0x2A3, + NOUN_SCAN_LIGHT = 0x2A4, + NOUN_OLD_SOFTWARE_STAND = 0x2A5, + NOUN_SOFTWARE_SHELF = 0x2A6, + NOUN_HOTTEST_SOFTWARE = 0x2A7, + NOUN_GREAT_PAINTBALL_ART = 0x2A8, + NOUN_SCENIC_VISTA = 0x2A9, + NOUN_LASER = 0x2AA, + NOUN_LASER_JET = 0x2AB, + NOUN_LEVER = 0x2AC, + NOUN_BULLSEYE = 0x2AD, + NOUN_STAND = 0x2AE, + NOUN_CONTROL_STATION = 0x2AF, + NOUN_STRANGE_MONSTER = 0x2B0, + NOUN_GHASTLY_BEAST = 0x2B1, + //NOUN_GAWK_AT = 0x2B2, + NOUN_CORRIDOR_TO_SOUTH = 0x2B3, + NOUN_CORRIDOR_TO_NORTH = 0x2B4, + NOUN_WALK_ONTO = 0x2B5, + NOUN_ROCK_WALL = 0x2B6, + NOUN_WOMAN = 0x2B7, + NOUN_WOMEN = 0x2B8, + NOUN_CORRIDOR_TO_EAST = 0x2B9, + NOUN_CORRIDOR_TO_WEST = 0x2BA, + NOUN_AMMUNITION = 0x2BB, + NOUN_ARMORED_VEHICLE = 0x2BC, + NOUN_TOMATO = 0x2BD, + NOUN_MISSILE = 0x2BE, + NOUN_SUIT_OF_ARMOR = 0x2BF, + NOUN_POWDER_CONTAINER = 0x2C0, + NOUN_INFLATABLE_RAFT = 0x2C1, + NOUN_GRENADE = 0x2C2, + NOUN_FENCE = 0x2C3, + NOUN_WOODEN_STATUE = 0x2C4, + NOUN_CONVEYER_BELT = 0x2C5, + NOUN_CONTROLS = 0x2C6, + NOUN_EQUIPMENT = 0x2C7, + NOUN_SHELF = 0x2C8, + NOUN_CABINETS = 0x2C9, + NOUN_CONTROL_CONSOLE = 0x2CA, + NOUN_FAUCET = 0x2CB, + NOUN_PANEL_BOX = 0x2CC, + NOUN_STATUE = 0x2CD, + NOUN_GAUGE = 0x2CE, + NOUN_CIRCUIT_PANEL = 0x2CF, + NOUN_CATWALK = 0x2D0, + NOUN_CIRCUITS = 0x2D1, + NOUN_BLOOD_STAIN = 0x2D2, + NOUN_GRATE = 0x2D3, + NOUN_AIR_SHAFT = 0x2D4, + //NOUN_RETURN_TO = 0x2D5, + NOUN_FORMALDEHYDE = 0x2D6, + NOUN_PETROX = 0x2D7, + NOUN_SODIUM_BENZOATE = 0x2D8, + NOUN_GURNEY = 0x2D9, + NOUN_IRONING_BOARD = 0x2DA, + NOUN_LEFT_MONITOR = 0x2DB, + NOUN_RIGHT_MONITOR = 0x2DC, + NOUN_RED_BUTTON = 0x2DD, + NOUN_GREEN_BUTTON = 0x2DE, + NOUN_RIGHT_ONE_KEY = 0x2DF, + NOUN_RIGHT_1_KEY = 0x2E0, + NOUN_RIGHT_2_KEY = 0x2E1, + NOUN_RIGHT_3_KEY = 0x2E2, + NOUN_RIGHT_4_KEY = 0x2E3, + NOUN_RIGHT_5_KEY = 0x2E4, + NOUN_RIGHT_6_KEY = 0x2E5, + NOUN_RIGHT_7_KEY = 0x2E6, + NOUN_RIGHT_8_KEY = 0x2E7, + NOUN_LEFT_1_KEY = 0x2E8, + NOUN_LEFT_2_KEY = 0x2E9, + NOUN_LEFT_3_KEY = 0x2EA, + NOUN_LEFT_4_KEY = 0x2EB, + NOUN_CORRIDOR_WALL = 0x2EC, + NOUN_MUG = 0x2ED, + NOUN_DOUGHNUT = 0x2EE, + NOUN_SECURITY_STATION = 0x2EF, + NOUN_NEWSPAPER = 0x2F0, + NOUN_MAGAZINE = 0x2F1, + NOUN_CLIPBOARD = 0x2F2, + NOUN_PAPER_FOOTBALL = 0x2F3, + NOUN_YOUR_STUFF = 0x2F4, + NOUN_OTHER_STUFF = 0x2F5, + NOUN_LAMP = 0x2F6, + NOUN_CLIMB_INTO = 0x2F7, + NOUN_LIGHT_BULB = 0x2F8, + //NOUN_STEP_INTO = 0x2F9, + NOUN_ROOM = 0x2FA, + //NOUN_CRAWL_TO = 0x2FB, + NOUN_FOURTH_CELL = 0x2FC, + NOUN_THIRD_CELL = 0x2FD, + NOUN_SECOND_CELL = 0x2FE, + NOUN_FIRST_CELL = 0x2FF, + NOUN_EQUIPMENT_ROOM = 0x300, + //NOUN_CRAWL_DOWN = 0x301, + NOUN_DESCENDING_SHAFT = 0x302, + NOUN_SAUROPOD = 0x303, + NOUN_MONSTER = 0x304, + NOUN_FAKE_ID = 0x305, + NOUN_ALIEN_LIQUOR = 0x306, + NOUN_INTERN = 0x307, + NOUN_INSTRUMENT_TABLE = 0x308, + NOUN_WOMAN_ON_BALCONY = 0x309, + NOUN_WOMAN_IN_CHAIR = 0x30A, + //NOUN_SIT_ON = 0x30B, + NOUN_WOMAN_IN_ALCOVE = 0x30C, + NOUN_KETTLE = 0x30D, + NOUN_BARTENDER = 0x30E, + NOUN_WHISKEY = 0x30F, + NOUN_ALCOHOL = 0x310, + NOUN_RIM = 0x311, + //NOUN_WALK_ALONG = 0x312, + NOUN_SUBMERGED_CITY = 0x313, + NOUN_GOVERNORS_HOUSE = 0x314, + NOUN_RIM_TOWARDS_EAST = 0x315, + NOUN_CEMENT_PYLON = 0x316, + NOUN_ELEVATOR = 0x317, + NOUN_ELEVATOR_SHAFT = 0x318, + NOUN_CONVEYOR_BELT = 0x319, + NOUN_CANNON_BALLS = 0x31A, + NOUN_ELECTRICAL_OVERHANG = 0x31B, + NOUN_GUTTER_PIPE = 0x31C, + NOUN_SIDEWALK = 0x31D, + NOUN_STREET = 0x31E, + NOUN_BARRICADE = 0x31F, + NOUN_DOOR_CONTROL_SLOT = 0x320, + NOUN_STREET_TO_EAST = 0x321, + NOUN_SIDEWALK_TO_EAST = 0x322, + NOUN_BUILDING = 0x323, + NOUN_CAR = 0x324, + //NOUN_GET_INSIDE = 0x325, + NOUN_MARQUEE = 0x326, + NOUN_BUILDING_ENTRANCE = 0x327, + NOUN_GUARD_STATION = 0x328, + NOUN_TECHNICAL_EQUIPMENT = 0x329, + NOUN_GUARD_TURRET = 0x32A, + NOUN_PILLAR = 0x32B, + NOUN_PAPERS = 0x32C, + NOUN_FILE_CABINET = 0x32D, + NOUN_WINDOWS = 0x32E, + //NOUN_WALK = 0x32F, + NOUN_STORAGE_BOX = 0x330, + NOUN_WATER_COOLER = 0x331, + NOUN_BOX = 0x332, + NOUN_RIFLES = 0x333, + NOUN_SLINGSHOT = 0x334, + NOUN_MAUSOLEUM = 0x335, + NOUN_SOFTWARE_STORE = 0x336, + NOUN_CONCRETE_BUILDING = 0x337, + NOUN_HUMONGOUS_MONITOR = 0x338, + NOUN_SPACE_BIKE = 0x339, + NOUN_BILLBOARD = 0x33A, + NOUN_LACK_OF_NOOKIE_MOTEL = 0x33B, + NOUN_BIDETS_XCREETZA_HUT = 0x33C, + NOUN_BUILDINGS = 0x33D, + NOUN_SKYSCRAPER = 0x33E, + NOUN_SOFTWARE_LOGO = 0x33F, + NOUN_GIANT_TELESCOPE = 0x340, + NOUN_HANDLE = 0x341, + NOUN_HOLE = 0x342, + NOUN_LASER_BEAM = 0x343, + NOUN_PEDESTAL = 0x344, + NOUN_BOAT = 0x345, + NOUN_GIANT_MONUMENT = 0x346, + NOUN_ROPE = 0x347, + NOUN_SAND_BAR_RESTAURANT = 0x348, + NOUN_PORTHOLE = 0x349, + NOUN_TICKET_BOOTH = 0x34A, + NOUN_POLLYS_ENTRANCE = 0x34B, + NOUN_RESTAURANT_ENTRANCE = 0x34C, + NOUN_THE_PLEASURE_DOME = 0x34D, + NOUN_STARFISH = 0x34E, + NOUN_FLIPPER = 0x34F, + NOUN_SAND_DOLLAR = 0x350, + NOUN_SHELL = 0x351, + NOUN_GUEST_LIST = 0x352, + NOUN_WEIRD_ANIMAL_HEAD = 0x353, + NOUN_SHIPS_WHEEL = 0x354, + NOUN_HANDICAP_SIGN = 0x355, + NOUN_ELEVATOR_CONTROLS = 0x356, + NOUN_BRICK_WALL = 0x357, + NOUN_BIKE_RACK = 0x358, + NOUN_ODONALDS_SIGN = 0x359, + NOUN_ELEVATOR_ENTRANCE = 0x35A, + NOUN_SPECIAL_SALE_SIGN = 0x35B, + NOUN_ATTORNEYS_AT_LAW = 0x35C, + NOUN_SLEDGE_MALL = 0x35D, + NOUN_SKELETON = 0x35E, + NOUN_STRANGE_EQUIPMENT = 0x35F, + NOUN_STREET_TO_WEST = 0x360, + NOUN_SIDEWALK_TO_WEST = 0x361, + NOUN_TELEPORTER_ENTRANCE = 0x362, + NOUN_SOFTWARE_DOOR = 0x363, + NOUN_SPINACH_PATCH_DOLL = 0x364, + //NOUN_REFLECT = 0x365, + NOUN_REGISTER_DRAWER = 0x366, + NOUN_ELEVATOR_DOOR = 0x367, + NOUN_HYDRAULIC_SUPPORT = 0x368, + NOUN_EQUIPMENT_OVERHEAD = 0x369, + //NOUN_GET_INTO = 0x36A, + NOUN_WARNING_LABEL = 0x36B, + NOUN_NUCLEAR_SLINGSHOT = 0x36C, + NOUN_DISPLAY_CASE = 0x36D, + NOUN_PHOTON_RIFLES = 0x36E, + NOUN_MONITORING_EQUIPMENT = 0x36F, + NOUN_TELESCOPE = 0x370, + NOUN_MOTEL = 0x371, + NOUN_RESTAURANT = 0x372, + NOUN_SOFTWARE_STORE_SIGN = 0x373, + NOUN_ADVERTISING_POSTER = 0x374, + NOUN_ADVERTISEMENT = 0x375, + NOUN_OLD_SOFTWARE = 0x376, + NOUN_CASH_REGISTER = 0x377, + NOUN_ENTRANCE = 0x378, + NOUN_LASER_CANNON = 0x379, + NOUN_SAND_BAGS = 0x37A, + NOUN_PLEASURE_DOME = 0x37B, + NOUN_DOME_ENTRANCE = 0x37C, + NOUN_LABORATORY = 0x37D, + NOUN_STREET_TO_SOUTH = 0x37E, + NOUN_ELEVATOR_ACCESS_SLOT = 0x37F, + NOUN_CAR_CONTROLS = 0x380, + NOUN_SCENT_PACKET = 0x381, + NOUN_KITTY = 0x382, + NOUN_GLOVE_COMPARTMENT = 0x383, + NOUN_MOLDY_SOCK = 0x384, + NOUN_SODA_CANS = 0x385, + NOUN_WINDSHIELD = 0x386, + NOUN_DASHBOARD = 0x387, + NOUN_INTERIOR_OF_CAR = 0x388, + NOUN_VIEW_RIGHT_BUTTON = 0x389, + NOUN_BLACK_BUTTON = 0x38A, + NOUN_WHITE_BUTTON = 0x38B, + NOUN_INSIDE_OF_CAR = 0x38C, + NOUN_RIM_TOWARDS_WEST = 0x38D, + NOUN_CEMENT_BLOCK = 0x38E, + NOUN_CITY = 0x38F, + NOUN_SPEAKER = 0x390, + NOUN_EYE_CHART = 0x391, + NOUN_LAUNCH_PAD = 0x392, + NOUN_BUILDING_TO_WEST = 0x393, + NOUN_PAD_TO_EAST = 0x394, + NOUN_PAD_TO_WEST = 0x395, + NOUN_TOWER = 0x396, + NOUN_LOOK_OUT = 0x397, + NOUN_SERVICE_PANEL = 0x398, + NOUN_CRACK = 0x399, + NOUN_THROTTLE = 0x39A, + NOUN_GRAB = 0x39B, + NOUN_INSTRUMENTATION = 0x39C, + NOUN_TP = 0x39D, + NOUN_SEAT = 0x39E, + NOUN_STATUS_PANEL = 0x39F, + NOUN_SHIPS_CONTROLS = 0x3A0, + NOUN_PROFESSOR = 0x3A1, + NOUN_PROFESSORS_GURNEY = 0x3A2, + NOUN_WELCOME_MAT = 0x3A3, + NOUN_MELON_MUSH = 0x3A4, + NOUN_BADMINTON_BRAT = 0x3A5, + //NOUN_APPLY = 0x3A6, + NOUN_COMBINATION = 0x3A7, + NOUN_NOTE = 0x3A8, + NOUN_LECITHIN = 0x3A9, + NOUN_REPAIR_WOMAN = 0x3AA, + NOUN_EXPLOSIVES = 0x3AB, + NOUN_DOLLOP = 0x3AC, + NOUN_DROP = 0x3AD, + NOUN_DASH = 0x3AE, + NOUN_SPLASH = 0x3AF, + NOUN_DOCK_TO_SOUTH = 0x3B0, + NOUN_STEER_TOWARDS = 0x3B1, + NOUN_BUILDING_TO_NORTH = 0x3B2, + NOUN_VOLCANO_RIM = 0x3B3, + NOUN_OPEN_WATER_TO_SOUTH = 0x3B4, + NOUN_PROJECTOR = 0x3B5, + NOUN_GUARDS_ARM2 = 0x3B6, + //NOUN_NIBBLE_ON = 0x3B7, + //NOUN_ENTER = 0x3B8, + NOUN_ = 0x3B9, + NOUN_TIMER_BUTTON_1 = 0x3BA, + NOUN_REMOTE_BUTTON_1 = 0x3BB, + NOUN_START_BUTTON_2 = 0x3BC, + NOUN_REMOTE_BUTTON_2 = 0x3BD, + NOUN_TIMER_BUTTON_2 = 0x3BE, + NOUN_START_BUTTON_1 = 0x3BF, + NOUN_ANTIGRAV_CONTROLS = 0x3C0, + NOUN_BRUCES_TREE = 0x3C1, + NOUN_COLISEUM = 0x3C2, + NOUN_BRUCES_GARDEN_ROOM = 0x3C3, + NOUN_FOUNTAIN = 0x3C4, + NOUN_HOUSE_OF_BRUCE = 0x3C5, + NOUN_CITY_BACKDROP = 0x3C6, + NOUN_BRUCES_BALCONY = 0x3C7, + NOUN_BRUCES_ENTRANCE = 0x3C8, + NOUN_BRUCES_LOGO = 0x3C9, + NOUN_LOUNGE_CHAIR = 0x3CA, + NOUN_LIVING_ROOM_FLOOR = 0x3CB, + NOUN_LIVINGROOM_FLOOR = 0x3CC, + NOUN_PERFUME_BOTTLE = 0x3CD, + NOUN_COOL_NEON_LIGHT = 0x3CE, + NOUN_FLOWER_POT = 0x3CF, + NOUN_COFFEE_TABLE = 0x3D0, + NOUN_FLOWERS = 0x3D1, + NOUN_ART_DECO_CHAIR = 0x3D2, + NOUN_SAFE = 0x3D3, + NOUN_SPLASHY_DECOR = 0x3D4, + NOUN_THEATRICAL_FACES = 0x3D5, + NOUN_ART_DECO_PIECE = 0x3D6, + NOUN_END_OF_ROOM = 0x3D7, + NOUN_FIREPLACE = 0x3D8, + NOUN_ARTWORK = 0x3D9, + NOUN_COOL_NEON_LIGHTS = 0x3DA, + NOUN_GLASS_PLATED_WINDOW = 0x3DB, + NOUN_BEDROOM_FLOOR = 0x3DC, + NOUN_BAUBLE = 0x3DD, + NOUN_SNAPSHOT = 0x3DE, + NOUN_PERFUME = 0x3DF, + NOUN_CLAPBOARD = 0x3E0, + NOUN_BERET = 0x3E1, + NOUN_HORSE_WHIP = 0x3E2, + NOUN_CORNER_TABLE = 0x3E3, + NOUN_BOA = 0x3E4, + NOUN_WIG_STAND = 0x3E5, + NOUN_PARTITION = 0x3E6, + NOUN_MEGAPHONE = 0x3E7, + NOUN_SLIP = 0x3E8, + NOUN_SCONCE = 0x3E9, + NOUN_VANITY = 0x3EA, + NOUN_BEDBOARD = 0x3EB, + NOUN_LOVE_SEAT = 0x3EC, + NOUN_SOUVENIR_TICKETS = 0x3ED, + NOUN_REVIEW = 0x3EE, + NOUN_BRUCE_AT_THE_GALA = 0x3EF, + NOUN_ART_DECO_RUG = 0x3F0, + NOUN_LIVINGROOM = 0x3F1, + NOUN_SCULPTURE = 0x3F2, + NOUN_SPECIMEN_EPITHET = 0x3F3, + NOUN_VENT = 0x3F4, + NOUN_FLOWER_BOX = 0x3F5, + NOUN_LEDGE = 0x3F6, + NOUN_BOLT = 0x3F7, + NOUN_OBSERVATION_WINDOW = 0x3F8, + NOUN_AIR_HOSE = 0x3F9, + NOUN_AUTO_SHOP = 0x3FA, + NOUN_MANHOLE = 0x3FB, + NOUN_AUTO_SHOP_ENTRANCE = 0x3FC, + NOUN_BROKEN_WINDOW = 0x3FD, + NOUN_WOMANHOLE = 0x3FE, + NOUN_GARAGE_DOOR = 0x3FF, + NOUN_SCRATCH_PAD = 0x400, + NOUN_GAS_PRICES = 0x401, + NOUN_UP_BUTTON = 0x402, + NOUN_DOWN_BUTTON = 0x403, + NOUN_SPARE_PARTS_LIST = 0x404, + NOUN_SKYLIGHT = 0x405, + NOUN_TOOL_BOX = 0x406, + NOUN_CAR_LIFT = 0x407, + NOUN_CAR_SEAT = 0x408, + NOUN_GARAGE_FLOOR = 0x409, + NOUN_GARAGE_DOOR_CONTROLS = 0x40A, + NOUN_AMISH_HAT = 0x40B, + NOUN_JACK = 0x40C, + NOUN_COILS = 0x40D, + NOUN_OIL_CAN = 0x40E, + NOUN_FAN_BELTS = 0x40F, + NOUN_REAR_OF_GARAGE = 0x410, + NOUN_FRONT_OF_GARAGE = 0x411, + NOUN_MUFFLER = 0x412, + NOUN_SPARE_PART = 0x413, + NOUN_HUBCAP = 0x414, + NOUN_CANDLE = 0x415, + NOUN_RATES = 0x416, + NOUN_GREASE_CAN = 0x417, + NOUN_CALENDAR = 0x418, + NOUN_FORK_LIFT = 0x419, + NOUN_TRASH_CAN = 0x41A, + NOUN_SHAKER_CHAIR = 0x41B, + NOUN_QUARTER_PANEL = 0x41C, + NOUN_AREA_BEHIND_CAR = 0x41D, + NOUN_DANGER_ZONE = 0x41E, + NOUN_NEWSSTAND = 0x41F, + NOUN_LADY_GODIVA_MONUMENT = 0x420, + NOUN_SPOT_A_POT = 0x421, + NOUN_GUARD_RAIL = 0x422, + NOUN_ALLEY = 0x423, + NOUN_DITCH = 0x424, + NOUN_VIDEO_STORE_DOOR = 0x425, + NOUN_BUCKLUSTER_MARQUEE = 0x426, + NOUN_VIDEO_STORE = 0x427, + NOUN_HORMONE_BILLBOARD = 0x428, + NOUN_PHONE_ANTENNA = 0x429, + NOUN_RETURN_SLOT = 0x42A, + NOUN_NOOSE = 0x42B, + NOUN_COMEDY_VIDEOS = 0x42C, + NOUN_SMELLY_SNEAKER = 0x42D, + NOUN_PIPPYS_STOCKING = 0x42E, + NOUN_PHONE_CRADLE = 0x42F, + NOUN_DRAMA_VIDEOS = 0x430, + NOUN_SPOTLIGHT = 0x431, + NOUN_STOREROOM_FLOOR = 0x432, + NOUN_ALL_SALES_FINAL = 0x433, + NOUN_MACHOPROSE_TEE_SHIRT = 0x434, + NOUN_UNKNOWN_COMIC_HANDS = 0x435, + NOUN_WET_CEMENT = 0x436, + NOUN_PIPPYS_TINY_IMPRINT = 0x437, + NOUN_OBNOXIOUS_DOG_PAWS = 0x438, + NOUN_LEG_AND_A_LEG_JEANS = 0x439, + NOUN_VIDEO_STORE_EXIT = 0x43A, + NOUN_AISLE = 0x43B, + NOUN_VIDEO_MONITOR = 0x43C, + NOUN_POLLY_PIGS_IMPRINT = 0x43D, + NOUN_JOHN_WYNNS_IMPRINT = 0x43E, + NOUN_MR_NEDS_IMPRINT = 0x43F, + NOUN_PEG_LEG_PETE_IMPRINT = 0x440, + NOUN_MARX_BROS_POSTER = 0x441, + NOUN_PIPPY_BILLBOARD = 0x442, + NOUN_VIDEOS_NOONE_WANTS = 0x443, + NOUN_MORE_CLASSIC_VIDEOS = 0x444, + NOUN_JOIN_OUR_PRICE_CLUB = 0x445, + NOUN_EDUCATIONAL_VIDEOS = 0x446, + NOUN_DEEP_DISCOUNT_TITLES = 0x447, + NOUN_WORLD_CHAMPS_POSTER = 0x448, + NOUN_WORKOUT_VIDEOS = 0x449, + NOUN_20_PERCENT_OFF_SIGN = 0x44A, + NOUN_CIVILIZATION_AD = 0x44B, + NOUN_NEW_RELEASE_VIDEOS = 0x44C, + NOUN_PORNO_VIDEOS = 0x44D, + NOUN_FOREIGN_VIDEOS = 0x44E, + NOUN_CLASSIC_VIDEOS = 0x44F, + NOUN_ADVENTURE_VIDEOS = 0x450, + NOUN_BUCKLUSTER_LOGO = 0x451, + NOUN_WINE_BOTTLE = 0x452, + NOUN_DIRT_PILE = 0x453, + NOUN_MAMMOTH_PENCIL_HEAD = 0x454, + NOUN_WREAKY_PUMPKIN = 0x455, + NOUN_MILK_CARTON = 0x456, + NOUN_BUCKET = 0x457, + NOUN_EMPTY_BOX = 0x458, + NOUN_DIAPER_BOX = 0x459, + NOUN_HERMIT = 0x45A, + NOUN_METAL_PIPE = 0x45B, + NOUN_CONCRETE_SUPPORT = 0x45C, + NOUN_VARIOUS_TRASH = 0x45D, + NOUN_ARMATURE = 0x45E, + NOUN_CONTROL_BOX = 0x45F, + NOUN_TOP_OF_DOME = 0x460, + NOUN_EXPRESSWAY_TO_EAST = 0x461, + NOUN_GO_TOWARDS = 0x462, + NOUN_EXPRESSWAY_TO_WEST = 0x463, + NOUN_DOME = 0x464, + NOUN_VIEW_OF_CITY = 0x465, + NOUN_EXPRESSWAY = 0x466, + NOUN_HOOK = 0x467, + NOUN_SEA_MONSTER = 0x468, + NOUN_EDGE_OF_VOLCANO = 0x469, + NOUN_JUMP_THROUGH = 0x46A, + NOUN_OLD_TEA_CUP = 0x46B, + NOUN_NAME_PLATE = 0x46C, + NOUN_OLD_VASE = 0x46D, + NOUN_PORTRAIT = 0x46E, + NOUN_PUT_DOWN = 0x46F, + NOUN_TALL_BUILDING = 0x470, + NOUN_OBNOXIOUS_DOG = 0x471, + NOUN_GUTS = 0x472, + NOUN_BIG_HEADS = 0x473, + NOUN_INSTALL = 0x474, + NOUN_LIFE_SUPPORT_MODULE = 0x475, + NOUN_REMOVE = 0x476, + NOUN_LARGE_BLADE = 0x477, + NOUN_SIDE_ENTRANCE = 0x478, + NOUN_INDICATOR = 0x479, + NOUN_SIGNPOST = 0x47A, + NOUN_PIN = 0x47B, + NOUN_POWDER_PUFF = 0x47C, + NOUN_SHELVES = 0x47D, + NOUN_ELECTRODES = 0x47E, + NOUN_MISHAP2 = 0x47F, + NOUN_ISLD_SUPERSTRUCTURE = 0x480, + NOUN_FILE_CABINETS = 0x481, + NOUN_CYCLE_SHOP = 0x482, + NOUN_AIR_BIKE = 0x483, + NOUN_EMERGENCY_LIGHT = 0x484, + NOUN_TARGET_AREA = 0x485, + NOUN_ICE_CHESTS = 0x486, + NOUN_BIRDS = 0x487, + NOUN_DOCTORS_OFFICE = 0x488, + NOUN_DEFACE = 0x489, + NOUN_LARGE_HEADS = 0x48A, + NOUN_SMALL_TABLE = 0x48B, + NOUN_COLLOSSEUM = 0x48C, + NOUN_HOUSE = 0x48D, + NOUN_BALCONY = 0x48E, + NOUN_GARDEN_ROOM = 0x48F, + NOUN_COVE_LIGHTS = 0x490, + NOUN_MASKS = 0x491, + NOUN_NEON_LIGHTS = 0x492, + NOUN_GLASS_BLOCK_WALL = 0x493, + NOUN_SCREEN = 0x494, + NOUN_SPARE_RIBS = 0x495, + NOUN_BANNER = 0x496, + NOUN_INSTRUCTIONAL_VIDEOS = 0x497, + NOUN_CEMENT = 0x498, + NOUN_STORE = 0x499, + NOUN_CARDBOARD_BOX = 0x49A, + NOUN_GRAFFITTI = 0x49B, + NOUN_GRAFFITI = 0x49C, + NOUN_PHOTOGRAPH = 0x49D, + NOUN_DIRECTORS_SLATE = 0x49E, + NOUN_CROP = 0x49F, + NOUN_HAT = 0x4A0, + NOUN_LOGO = 0x4A1, + NOUN_MAINTENANCE_BUILDING = 0x4A2, + NOUN_MASSAGE = 0x4A3, + NOUN_MANGLE = 0x4A4, + NOUN_RUB = 0x4A5, + NOUN_JUGGLE = 0x4A6, + NOUN_SMASH = 0x4A7, + NOUN_GUZZLE = 0x4A8, + NOUN_WEST_END_OF_PLATFORM = 0x4A9, + NOUN_EAST_END_OF_PLATFORM = 0x4AA, + NOUN_FOLD = 0x4AB, + NOUN_SPINDLE = 0x4AC + //NOUN_MUTILATE = 0x4AD +}; + +class SceneFactory { +public: + static SceneLogic *createScene(MADSEngine *vm); +}; + +/** + * Specialized base class for Rex Nebular game scenes + */ +class NebularScene : public SceneLogic { +protected: + NebularGlobals &_globals; + GameNebular &_game; + MADSAction &_action; + + /** + * Forms an animation resource name + */ + Common::String formAnimName(char sepChar, int suffixNum); + + /** + * Plays appropriate sound for entering various rooms + */ + void lowRoomsEntrySound(); +public: + /** + * Constructor + */ + NebularScene(MADSEngine *vm); + + void sub7178C(); +}; + +class SceneInfoNebular : public SceneInfo { + friend class SceneInfo; +protected: + virtual void loadCodes(MSurface &depthSurface, int variant); + + virtual void loadCodes(MSurface &depthSurface, Common::SeekableReadStream *stream); + + /** + * Constructor + */ + SceneInfoNebular(MADSEngine *vm) : SceneInfo(vm) {} +}; + +class SceneTeleporter : public NebularScene { +protected: + int _buttonTyped; + int _curCode; + int _digitCount; + int _curMessageId; + int _handSpriteId; + int _handSequenceId; + int _finishedCodeCounter; + int _meteorologistNextPlace; + int _meteorologistCurPlace; + int _teleporterSceneId; + Common::String _msgText; + + int teleporterAddress(int code, bool working); + + void teleporterHandleKey(); + Common::Point teleporterComputeLocation(); + void teleporterEnter(); + bool teleporterActions(); + void teleporterStep(); + +protected: + /** + * Constructor + */ + SceneTeleporter(MADSEngine *vm) : NebularScene(vm) {} +}; + +} // End of namespace Nebular +} // End of namespace MADS + +#endif /* MADS_NEBULAR_SCENES_H */ diff --git a/engines/mads/nebular/nebular_scenes1.cpp b/engines/mads/nebular/nebular_scenes1.cpp new file mode 100644 index 0000000000..cd3b90089e --- /dev/null +++ b/engines/mads/nebular/nebular_scenes1.cpp @@ -0,0 +1,3168 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" +#include "mads/nebular/nebular_scenes1.h" + +namespace MADS { + +namespace Nebular { + +void Scene1xx::setAAName() { + int idx = (_scene->_nextSceneId > 103 && _scene->_nextSceneId < 112) ? 1 : 0; + _game._aaName = Resources::formatAAName(idx); +} + +void Scene1xx::sceneEntrySound() { + if (_vm->_musicFlag) { + switch (_scene->_nextSceneId) { + case 101: + _vm->_sound->command(11); + break; + case 102: + _vm->_sound->command(12); + break; + case 103: + _vm->_sound->command(3); + _vm->_sound->command(25); + break; + case 109: + _vm->_sound->command(13); + break; + case 110: + _vm->_sound->command(10); + break; + case 111: + _vm->_sound->command(3); + break; + case 112: + _vm->_sound->command(15); + break; + default: + if (_scene->_priorSceneId < 104 || _scene->_priorSceneId > 108) + _vm->_sound->command(10); + break; + } + } +} + +void Scene1xx::setPlayerSpritesPrefix() { + _vm->_sound->command(5); + Common::String oldName = _game._player._spritesPrefix; + if (_scene->_nextSceneId <= 103 || _scene->_nextSceneId == 111) { + if (_globals[kSexOfRex] == SEX_FEMALE) + _game._player._spritesPrefix = "ROX"; + else { + _game._player._spritesPrefix = "RXM"; + _globals[kSexOfRex] = SEX_MALE; + } + } else if (_scene->_nextSceneId <= 110) { + _game._player._spritesPrefix = "RXSW"; + _globals[kSexOfRex] = SEX_UNKNOWN; + } else if (_scene->_nextSceneId == 112) + _game._player._spritesPrefix = ""; + + if (oldName == _game._player._spritesPrefix) + _game._player._spritesChanged = true; + + if (_scene->_nextSceneId == 105 || (_scene->_nextSceneId == 109 && _globals[kHoovicAlive])) { + _game._player._spritesChanged = true; + _game._player._loadsFirst = false; + } + + _game._player._trigger = 0; + _vm->_palette->setEntry(16, 10, 63, 63); + _vm->_palette->setEntry(17, 10, 45, 45); +} + +/*------------------------------------------------------------------------*/ + +Scene101::Scene101(MADSEngine *vm) : Scene1xx(vm) { + _sittingFl = false; + _panelOpened = false; + _messageNum = 0; + _posY = 0; + _shieldSpriteIdx = 0; + _chairHotspotId = 0; + _oldSpecial = 0; +} + +void Scene101::synchronize(Common::Serializer &s) { + Scene1xx::synchronize(s); + + s.syncAsByte(_sittingFl); + s.syncAsByte(_panelOpened); + s.syncAsSint16LE(_messageNum); + s.syncAsSint16LE(_posY); + s.syncAsSint16LE(_shieldSpriteIdx); + s.syncAsSint16LE(_chairHotspotId); + s.syncAsSint16LE(_oldSpecial); +} + +void Scene101::setup() { + _scene->_animationData->preLoad(formAnimName('A', -1), 3); + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene101::sayDang() { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _game._player._stepEnabled = false; + + switch (_game._trigger) { + case 0: + _scene->_sequences.remove(_globals._sequenceIndexes[11]); + _globals._sequenceIndexes[11] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[11], false, 3, 6, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[11], 17, 21); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + _vm->_sound->command(17); + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 3, 2, 0, 0); + break; + + case 72: + _globals._sequenceIndexes[11] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[11], false, 6, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[11], 17, 17); + _scene->_kernelMessages.add(Common::Point(143, 61), 0x1110, 0, 0, 60, _game.getQuote(57)); + _scene->_sequences.addTimer(120, 73); + break; + + case 73: + _vm->_dialogs->show(10117); + _game._player._stepEnabled = true; + break; + + default: + break; + } +} + +void Scene101::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 2)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 3)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('x', 4)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('x', 5)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('x', 6)); + _globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('x', 7)); + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('m', -1)); + _globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('b', 1)); + _globals._spriteIndexes[10] = _scene->_sprites.addSprites(formAnimName('b', 2)); + _globals._spriteIndexes[11] = _scene->_sprites.addSprites(formAnimName('a', 0)); + _globals._spriteIndexes[12] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _globals._spriteIndexes[13] = _scene->_sprites.addSprites(formAnimName('x', 8)); + _globals._spriteIndexes[14] = _scene->_sprites.addSprites(formAnimName('x', 0)); + + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 5, 0, 0, 25); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 4, 0, 1, 0); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 6, 0, 2, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 7, 70); + _globals._sequenceIndexes[4] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[4], false, 10, 0, 0, 60); + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 5, 0, 1, 0); + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 10, 0, 2, 0); + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 6, 0, 0, 0); + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], false, 6, 0, 10, 4); + _globals._sequenceIndexes[10] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[10], false, 6, 0, 32, 47); + + _scene->_hotspots.activate(NOUN_SHIELD_MODULATOR, false); + _panelOpened = false; + + // HACK: set the prior scene to 102 for now when the game starts, to avoid Rex's getting up animation + if (_scene->_priorSceneId == -1) + _scene->_priorSceneId = 102; + + if (_scene->_priorSceneId != -1) + _globals[kNeedToStandUp] = false; + + if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(100, 152); + + if ((_scene->_priorSceneId == 112) || ((_scene->_priorSceneId == -2) && _sittingFl )) { + _game._player._visible = false; + _sittingFl = true; + _game._player._playerPos = Common::Point(161, 123); + _game._player._facing = FACING_NORTHEAST; + _globals._sequenceIndexes[11] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[11], false, 3, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[11], 17, 17); + _scene->_hotspots.activate(NOUN_CHAIR, false); + _chairHotspotId = _scene->_dynamicHotspots.add(NOUN_CHAIR, 0x13F, -1, Common::Rect(159, 84, 159 + 33, 84 + 36)); + if (_scene->_priorSceneId == 112) + sayDang(); + } else { + _globals._sequenceIndexes[12] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[12], false, 6, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[12], 4); + } + + _game.loadQuoteSet(0x31, 0x32, 0x39, 0x36, 0x37, 0x38, 0); + + if (_globals[kNeedToStandUp]) { + _scene->loadAnimation(Resources::formatName(101, 'S', -1, EXT_AA, ""), 71); + _game._player._visible = false; + _game._player._stepEnabled = false; + _game._player._playerPos = Common::Point(68, 140); + _game._player._facing = FACING_WEST; + + _messageNum = 0; + _posY = 30; + } + + _oldSpecial = false; + + sceneEntrySound(); +} + +void Scene101::step() { + if (_oldSpecial != _game._player._special) { + _oldSpecial = _game._player._special; + if (_oldSpecial) + _vm->_sound->command(39); + else + _vm->_sound->command(11); + } + + switch (_game._trigger) { + case 70: + _vm->_sound->command(9); + break; + + case 71: + _globals[kNeedToStandUp] = false; + _game._player._visible = true; + _game._player._stepEnabled = true; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + break; + + case 72: + case 73: + sayDang(); + break; + + default: + break; + } + + if (_scene->_activeAnimation != nullptr) { + if ((_scene->_activeAnimation->getCurrentFrame() >= 6) && (_messageNum == 0)) { + _messageNum++; + _scene->_kernelMessages.add(Common::Point(63, _posY), 0x1110, 0, 0, 240, _game.getQuote(49)); + _posY += 14; + } + + if ((_scene->_activeAnimation->getCurrentFrame() >= 7) && (_messageNum == 1)) { + _messageNum++; + _scene->_kernelMessages.add(Common::Point(63, _posY), 0x1110, 0, 0, 240, _game.getQuote(54)); + _posY += 14; + } + + if ((_scene->_activeAnimation->getCurrentFrame() >= 10) && (_messageNum == 2)) { + _messageNum++; + _scene->_kernelMessages.add(Common::Point(63, _posY), 0x1110, 0, 0, 240, _game.getQuote(55)); + _posY += 14; + } + + if ((_scene->_activeAnimation->getCurrentFrame() >= 17) && (_messageNum == 3)) { + _messageNum++; + _scene->_kernelMessages.add(Common::Point(63, _posY), 0x1110, 0, 0, 240, _game.getQuote(56)); + _posY += 14; + } + + if ((_scene->_activeAnimation->getCurrentFrame() >= 20) && (_messageNum == 4)) { + _messageNum++; + _scene->_kernelMessages.add(Common::Point(63, _posY), 0x1110, 0, 0, 240, _game.getQuote(50)); + _posY += 14; + } + } +} + +void Scene101::preActions() { + if (_action.isAction(VERB_LOOK, NOUN_VIEW_SCREEN)) + _game._player._needToWalk = true; + + if (_sittingFl) { + if (_action.isAction(VERB_LOOK) || _action.isObject(NOUN_CHAIR) || _action.isAction(VERB_TALKTO) || _action.isAction(VERB_PEER_THROUGH) || _action.isAction(VERB_EXAMINE)) + _game._player._needToWalk = false; + + if (_game._player._needToWalk) { + switch (_game._trigger) { + case 0: + _game._player._readyToWalk = false; + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[11]); + _globals._sequenceIndexes[11] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[11], false, 3, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[11], 1, 17); + _vm->_sound->command(16); + break; + + case 1: + _sittingFl = false; + _game._player._visible = true; + _game._player._stepEnabled = true; + _game._player._readyToWalk = true; + _scene->_hotspots.activate(71, true); + _scene->_dynamicHotspots.remove(_chairHotspotId); + _globals._sequenceIndexes[12] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[12], false, 6, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[12], 4); + break; + + default: + break; + } + } + } + + if (_panelOpened && !(_action.isObject(NOUN_SHIELD_ACCESS_PANEL) || _action.isObject(NOUN_SHIELD_MODULATOR))) { + switch (_game._trigger) { + case 0: + if (_game._player._needToWalk) { + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _shieldSpriteIdx = _game._objects.isInRoom(OBJ_SHIELD_MODULATOR) ? 13 : 14; + _globals._sequenceIndexes[13] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[_shieldSpriteIdx], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _game._player._stepEnabled = false; + _vm->_sound->command(20); + } + break; + + case 1: + _game._player._stepEnabled = true; + _panelOpened = false; + _scene->_hotspots.activate(NOUN_SHIELD_MODULATOR, false); + break; + + default: + break; + } + } +} + +void Scene101::actions() { + if (_action._lookFlag) { + _vm->_dialogs->show(10125); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_WALKTO, NOUN_LIFE_SUPPORT_SECTION)) { + _scene->_nextSceneId = 102; + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_SIT_IN, NOUN_CHAIR) || (_action.isAction(VERB_LOOK, NOUN_VIEW_SCREEN) && !_sittingFl)) { + if (!_sittingFl) { + switch (_game._trigger) { + case 0: + _scene->_sequences.remove(_globals._sequenceIndexes[12]); + _globals._sequenceIndexes[11] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[11], false, 3, 1); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[11], 1, 17); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_SPRITE, 10, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + _game._player._stepEnabled = false; + _game._player._visible = false; + _action._inProgress = false; + return; + + case 1: + _vm->_sound->command(16); + break; + + case 2: + _globals._sequenceIndexes[11] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[11], false, 3, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[11], 17, 17); + _game._player._stepEnabled = true; + _sittingFl = true; + _scene->_hotspots.activate(71, false); + _chairHotspotId = _scene->_dynamicHotspots.add(71, 0x13F, -1, Common::Rect(159, 84, 159 + 33, 84 + 36)); + if (!_action.isAction(VERB_LOOK, NOUN_VIEW_SCREEN)) { + _action._inProgress = false; + return; + } + _game._trigger = 0; + break; + + default: + break; + } + } else { + _vm->_dialogs->show(10131); + _action._inProgress = false; + return; + } + } + + if ((_action.isAction(VERB_WALKTO, NOUN_SHIELD_ACCESS_PANEL) || _action.isAction(VERB_OPEN, NOUN_SHIELD_ACCESS_PANEL)) && !_panelOpened) { + switch (_game._trigger) { + case 0: + _shieldSpriteIdx = _game._objects.isInRoom(OBJ_SHIELD_MODULATOR) ? 13 : 14; + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[_shieldSpriteIdx], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _game._player._stepEnabled = false; + _vm->_sound->command(20); + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[_shieldSpriteIdx], false, 6, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], -2, -2); + _game._player._stepEnabled = true; + _panelOpened = true; + if (_game._objects.isInRoom(OBJ_SHIELD_MODULATOR)) + _scene->_hotspots.activate(NOUN_SHIELD_MODULATOR, true); + break; + + default: + break; + } + _action._inProgress = false; + return; + } + + if ((_action.isAction(VERB_TAKE, NOUN_SHIELD_MODULATOR) || _action.isAction(VERB_PULL, NOUN_SHIELD_MODULATOR)) && _game._objects.isInRoom(OBJ_SHIELD_MODULATOR)) { + _game._objects.addToInventory(OBJ_SHIELD_MODULATOR); + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[14], false, 6, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], -2, -2); + _scene->_hotspots.activate(NOUN_SHIELD_MODULATOR, false); + _vm->_dialogs->showItem(OBJ_SHIELD_MODULATOR, 10120); + _vm->_sound->command(22); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_SHIELD_ACCESS_PANEL) || (_action.isAction(VERB_LOOK, NOUN_SHIELD_MODULATOR) && !_game._objects.isInInventory(OBJ_SHIELD_MODULATOR)) ) { + if (_panelOpened) { + if (_game._objects.isInRoom(OBJ_SHIELD_MODULATOR)) + _vm->_dialogs->show(10128); + else + _vm->_dialogs->show(10129); + } else + _vm->_dialogs->show(10127); + + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_OPEN, NOUN_SHIELD_ACCESS_PANEL) && _panelOpened) { + _vm->_dialogs->show(10130); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_VIEW_SCREEN) && _sittingFl) { + if (_globals[kWatchedViewScreen]) + sayDang(); + else { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[11]); + _globals._sequenceIndexes[11] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[11], false, 3, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[11], 17, 21); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _vm->_sound->command(17); + break; + + case 1: + _globals._sequenceIndexes[11] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[11], false, 3, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[11], 17, 21); + break; + + case 2: + _globals._sequenceIndexes[11] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[11], false, 3, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[11], 17, 17); + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 3, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: + _game._player._stepEnabled = true; + _globals[kWatchedViewScreen] = true; + _sittingFl = true; + _scene->_nextSceneId = 112; + break; + + default: + break; + } + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_CHAIR)) { + _vm->_dialogs->show(10101); + _action._inProgress = false; + return; + } + + if ((_action.isAction(VERB_LOOK) || _action.isAction(VERB_PEER_THROUGH)) && (_action.isObject(NOUN_FRONT_WINDOW) || _action.isObject(NOUN_OUTSIDE))) { + _vm->_dialogs->show(10102); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_HULL) || _action.isAction(VERB_LOOK, NOUN_OUTER_HULL) || _action.isAction(VERB_EXAMINE, NOUN_HULL) || _action.isAction(VERB_EXAMINE, NOUN_OUTER_HULL)) { + _vm->_dialogs->show(10103); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_FUZZY_DICE)) { + _vm->_dialogs->show(10104); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_MIRROR) || _action.isAction(VERB_LOOK_IN, NOUN_MIRROR)) { + _vm->_dialogs->show(10105); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_CURTAINS)) { + _vm->_dialogs->show(10106); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_PLASTIC_JESUS)) { + _vm->_dialogs->show(10107); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_ESCAPE_HATCH) || (_action.isAction(VERB_OPEN, NOUN_ESCAPE_HATCH) && !_game._objects.isInInventory(OBJ_REBREATHER))) { + _vm->_dialogs->show(10109); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_OPEN, NOUN_ESCAPE_HATCH)) { + _vm->_dialogs->show(10110); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_TARGET_COMPUTER)) { + _vm->_dialogs->show(10111); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_LIBRARY_COMPUTER)) { + _vm->_dialogs->show(10126); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_DAMAGE_CONTROL_PANEL)) { + _vm->_dialogs->show(10112); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_NAVIGATION_CONTROLS)) { + _vm->_dialogs->show(10113); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_ENGINEERING_CONTROLS)) { + _vm->_dialogs->show(10114); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_WEAPONS_DISPLAY)) { + _vm->_dialogs->show(10115); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_SHIELD_STATUS_PANEL)) { + _vm->_dialogs->show(10116); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_PLASTIC_JESUS)) { + _vm->_dialogs->show(10118); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_FUZZY_DICE)) { + _vm->_dialogs->show(10119); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_OPEN, NOUN_DAMAGE_CONTROL_PANEL)) { + _vm->_dialogs->show(10121); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_OPEN, NOUN_CURTAINS)) { + _vm->_dialogs->show(10122); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_CLOSE, NOUN_CURTAINS)) { + _vm->_dialogs->show(10123); + _action._inProgress = false; + return; + } + + if ((_action.isAction(VERB_LOOK) || _action.isAction(VERB_PLAY)) && _action.isObject(NOUN_VIDEO_GAME)) { + _vm->_dialogs->show(10124); + _action._inProgress = false; + return; + } +} + +/*------------------------------------------------------------------------*/ + +Scene102::Scene102(MADSEngine *vm) : Scene1xx(vm) { + _fridgeOpenedFl = false; + _fridgeOpenedDescr = false; + _fridgeFirstOpenFl = false; + _chairDescrFl = false; + _drawerDescrFl = false; + _activeMsgFl = false; + _fridgeCommentCount = 0; +} + +void Scene102::synchronize(Common::Serializer &s) { + Scene1xx::synchronize(s); + + s.syncAsByte(_fridgeOpenedFl); + s.syncAsByte(_fridgeOpenedDescr); + s.syncAsByte(_fridgeFirstOpenFl); + s.syncAsByte(_chairDescrFl); + s.syncAsByte(_drawerDescrFl); + s.syncAsByte(_activeMsgFl); + + s.syncAsSint16LE(_fridgeCommentCount); +} + +void Scene102::setup() { + _scene->_animationData->preLoad(formAnimName('A', -1), 3); + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene102::addRandomMessage() { + _scene->_kernelMessages.reset(); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + int quoteId = _vm->getRandomNumber(65, 69); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 73, 120, _game.getQuote(quoteId)); + _activeMsgFl = true; +} + +void Scene102::enter() { + sceneEntrySound(); + + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 2)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 3)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('x', 4)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('x', 5)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('b', -1)); + _globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('c', -1)); + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('e', -1)); + _globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('n', -1)); + _globals._spriteIndexes[10] = _scene->_sprites.addSprites(formAnimName('g', -1)); + _globals._spriteIndexes[11] = _scene->_sprites.addSprites("*RXMRC_8"); + _globals._spriteIndexes[13] = _scene->_sprites.addSprites(formAnimName('x', 0)); + + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 8, 0, 0, 0); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 170, 0, 1, 6); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 11, 0, 2, 3); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 4, 0, 1, 0); + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 3, 0, 0, 5); + + if (_game._objects.isInRoom(OBJ_BINOCULARS)) + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], false, 24, 0, 0, 24); + else + _scene->_hotspots.activate(NOUN_BINOCULARS, false); + + _scene->_hotspots.activate(NOUN_BURGER, false); + + if (_globals[kMedicineCabinetOpen]) { + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 6, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], -2, -2); + } + + if (_scene->_priorSceneId == 101) { + _game._player._playerPos = Common::Point(229, 109); + _game._player._stepEnabled = false; + _globals._sequenceIndexes[6] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[6], false, 6, 1, 2, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 70); + } else if (_scene->_priorSceneId == 103) + _game._player._playerPos = Common::Point(47, 152); + else if (_scene->_priorSceneId != -2) { + _game._player._facing = FACING_NORTHWEST; + _game._player._playerPos = Common::Point(32, 129); + } + + if (_scene->_priorSceneId != 106) { + if (_globals[kWaterInAPuddle]) { + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[13], false, 6, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], -2, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 5); + } + } else { + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[13], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 5); + _vm->_sound->command(24); + _vm->_sound->command(28); + } + + _fridgeOpenedFl = false; + _fridgeOpenedDescr = false; + _fridgeCommentCount = 0; + _fridgeFirstOpenFl = true; + _chairDescrFl = false; + _activeMsgFl = false; + + _game.loadQuoteSet(0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x45, 0x43, 0); + + if (_scene->_priorSceneId == 101) + _vm->_sound->command(20); +} + +void Scene102::step() { + if (_game._trigger == 70) + _game._player._stepEnabled = true; + + if (_game._trigger == 72) { + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[13], false, 6, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], -2, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 5); + _scene->_sequences.addTimer(48, 90); + } + + if (_game._trigger >= 90) { + if (_game._trigger >= 94) { + _scene->loadAnimation(formAnimName('B', -1), 71); + _game._player._stepEnabled = false; + _game._player._visible = false; + + _globals[kWaterInAPuddle] = true; + _vm->_sound->command(24); + } else { + _vm->_sound->command(23); + _scene->_sequences.addTimer(48, _game._trigger + 1); + } + } + + if (_game._trigger == 71) { + _game._player._stepEnabled = true; + _game._player._visible = true; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + } + + if (_fridgeOpenedFl && !_fridgeOpenedDescr) { + _fridgeCommentCount++; + if (_fridgeCommentCount > 16384) { + _fridgeOpenedDescr = true; + _vm->_dialogs->show(10213); + } + } + + if (!_activeMsgFl && (_game._player._playerPos == Common::Point(177, 114)) && (_game._player._facing == FACING_NORTH) + && (_vm->getRandomNumber(1, 5000) == 1)) { + _scene->_kernelMessages.reset(); + _activeMsgFl = false; + addRandomMessage(); + } + + if (_game._trigger == 73) + _activeMsgFl = false; +} + +void Scene102::preActions() { + if (_action.isObject(NOUN_REFRIGERATOR) || _action.isObject(NOUN_POSTER)) + _game._player._needToWalk = _game._player._readyToWalk; + + if (_fridgeOpenedFl && !_action.isObject(NOUN_REFRIGERATOR)) { + switch (_game._trigger) { + case 0: + if (_game._player._needToWalk) { + _scene->_sequences.remove(_globals._sequenceIndexes[7]); + _globals._sequenceIndexes[7] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[7], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 15); + _game._player._stepEnabled = false; + _vm->_sound->command(20); + } + break; + + case 1: + if (_game._objects.isInRoom(OBJ_BURGER)) { + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + _scene->_hotspots.activate(NOUN_BURGER, false); + } + _fridgeOpenedFl = false; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } + + if (_game._player._needToWalk) + _scene->_kernelMessages.reset(); +} + +void Scene102::actions() { + if (_action._lookFlag) { + _vm->_dialogs->show(10234); + _action._inProgress = false; + return; + } + + bool justOpenedFl = false; + if (_action.isObject(NOUN_REFRIGERATOR) && !_fridgeOpenedFl) { + switch (_game._trigger) { + case 0: + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 15); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + if (_game._objects.isInRoom(OBJ_BURGER)) { + _globals._sequenceIndexes[10] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[10], false, 7, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 14); + } + _game._player._stepEnabled = false; + _vm->_sound->command(20); + _action._inProgress = false; + return; + + case 1: + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 6, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[7], -2, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 15); + int delay; + if (_action.isAction(VERB_WALKTO) && !_fridgeFirstOpenFl) + delay = 0; + else + delay = 48; + _scene->_sequences.addTimer(delay, 2); + _action._inProgress = false; + return; + + case 2: + _fridgeOpenedFl = true; + _fridgeOpenedDescr = false; + _fridgeCommentCount = 0; + _game._player._stepEnabled = true; + justOpenedFl = true; + if (_game._objects.isInRoom(OBJ_BURGER)) + _scene->_hotspots.activate(NOUN_BURGER, true); + break; + + default: + break; + } + } + + if (_action.isAction(VERB_LOOK, NOUN_REFRIGERATOR) || _action.isAction(VERB_OPEN, NOUN_REFRIGERATOR)) { + if (_game._objects.isInRoom(OBJ_BURGER)) + _vm->_dialogs->show(10230); + else + _vm->_dialogs->show(10229); + + _fridgeFirstOpenFl = false; + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_WALKTO, NOUN_REFRIGERATOR) && justOpenedFl) { + _fridgeFirstOpenFl = false; + int quoteId = _vm->getRandomNumber(59, 63); + Common::String curQuote = _game.getQuote(quoteId); + int width = _vm->_font->getWidth(curQuote, -1); + _scene->_kernelMessages.reset(); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_kernelMessages.add(Common::Point(210, 60), 0x1110, 0, 73, 120, curQuote); + _scene->_kernelMessages.add(Common::Point(214 + width, 60), 0x1110, 0, 73, 120, _game.getQuote(64)); + _activeMsgFl = true; + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_CLOSE, NOUN_REFRIGERATOR)) { + _vm->_dialogs->show(10213); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_REFRIGERATOR)) { + _vm->_dialogs->show(8); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOOR)) { + switch (_game._trigger) { + case 0: + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _game._player._stepEnabled = false; + _vm->_sound->command(20); + break; + + case 1: + _scene->_nextSceneId = 101; + break; + + default: + break; + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_WALKTO, NOUN_ENGINEERING_SECTION)) { + _scene->_nextSceneId = 103; + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_WALKTO, NOUN_POSTER) || _action.isAction(VERB_LOOK, NOUN_POSTER) || _action.isAction(VERB_WALKTO, NOUN_BINOCULARS)) { + addRandomMessage(); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_WEIGHT_MACHINE)) { + _vm->_dialogs->show(10212); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_ENGINEERING_SECTION)) { + _vm->_dialogs->show(10205); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_DOOR)) { + _vm->_dialogs->show(10204); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_STARE_AT, NOUN_CEILING) || _action.isAction(VERB_LOOK, NOUN_CEILING)) { + _vm->_dialogs->show(10203); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_STARE_AT, NOUN_OVERHEAD_LAMP) || _action.isAction(VERB_LOOK, NOUN_OVERHEAD_LAMP)) { + _vm->_dialogs->show(10202); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_ROBO_KITCHEN)) { + _vm->_dialogs->show(10215); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_PUT, NOUN_BURGER, NOUN_ROBO_KITCHEN) && _game._objects.isInInventory(OBJ_BURGER)) { + _vm->_dialogs->show(10216); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_PUT, NOUN_REFRIGERATOR) && _game._objects.isInInventory(_game._objects.getIdFromDesc(_action._activeAction._objectNameId))) { + _vm->_dialogs->show(10217); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_PUT, NOUN_DEAD_FISH, NOUN_ROBO_KITCHEN) || _action.isAction(VERB_PUT, NOUN_STUFFED_FISH, NOUN_ROBO_KITCHEN)) { + _vm->_dialogs->show(10230); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_OPEN, NOUN_ROBO_KITCHEN)) { + _vm->_dialogs->show(10218); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_CLOSET)) { + _vm->_dialogs->show(10219); + _action._inProgress = false; + return; + } + + if ((_action.isObject(NOUN_LADDER) || _action.isObject(NOUN_HATCHWAY)) && (_action.isAction(VERB_LOOK) || _action.isAction(VERB_CLIMB_UP) || _action.isAction(VERB_CLIMB_THROUGH))) { + if (_game._objects.isInInventory(OBJ_REBREATHER)) { + if (!_action.isAction(VERB_CLIMB_UP) && !_action.isAction(VERB_CLIMB_THROUGH)) { + _vm->_dialogs->show(10231); + _action._inProgress = false; + return; + } + } else if (_action.isAction(VERB_LOOK) || (_game._difficulty != DIFFICULTY_EASY)) { + _vm->_dialogs->show(10222); + _action._inProgress = false; + return; + } + } + + if ((_action.isObject(NOUN_LADDER) || _action.isObject(NOUN_HATCHWAY)) && (_action.isAction(VERB_CLIMB_UP) || _action.isAction(VERB_CLIMB_THROUGH)) ) { + switch (_game._trigger) { + case 0: + _scene->loadAnimation(formAnimName('A', -1), 1); + _game._player._stepEnabled = false; + _game._player._visible = false; + break; + + case 1: + _vm->_sound->command(24); + _scene->_sequences.addTimer(48, 2); + break; + + case 2: + case 3: + case 4: + _vm->_sound->command(23); + _scene->_sequences.addTimer(48, _game._trigger + 1); + break; + + case 5: + _vm->_sound->command(24); + _scene->_sequences.addTimer(48, _game._trigger + 1); + break; + + case 6: + if (_game._objects.isInInventory(OBJ_REBREATHER) && !_game._visitedScenes.exists(106)) + _vm->_dialogs->show(10237); + _scene->_nextSceneId = 106; + break; + + default: + break; + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_POWER_STATUS_PANEL)) { + _vm->_dialogs->show(10226); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_WINDOW) || _action.isAction(VERB_LOOK_THROUGH, NOUN_WINDOW)) { + _vm->_dialogs->show(10227); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_DOORWAY) || _action.isAction(VERB_WALKTO, NOUN_DOORWAY)) { + _vm->_dialogs->show(10228); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_DRAWER) || ((_action.isAction(VERB_CLOSE, NOUN_DRAWER) || _action.isAction(VERB_PUSH, NOUN_DRAWER)) && !_drawerDescrFl)) { + _vm->_dialogs->show(10220); + _drawerDescrFl = true; + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_CLOSE, NOUN_DRAWER) || _action.isAction(VERB_PUSH, NOUN_DRAWER)) { + _vm->_dialogs->show(10221); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_OPEN, NOUN_DRAWER)) { + _vm->_dialogs->show(10236); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_CHAIR) || (_action.isAction(VERB_SIT_IN, NOUN_CHAIR) && !_chairDescrFl)) { + _chairDescrFl = true; + _vm->_dialogs->show(10210); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_SIT_IN, NOUN_CHAIR)) { + _vm->_dialogs->show(10211); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_MEDICINE_CABINET)) { + if (_globals[kMedicineCabinetOpen]) + _vm->_dialogs->show(10207); + else + _vm->_dialogs->show(10206); + + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_CLOSE, NOUN_MEDICINE_CABINET) && _globals[kMedicineCabinetOpen]) { + switch (_game._trigger) { + case 0: + _scene->_sequences.remove(_globals._sequenceIndexes[8]); + _globals._sequenceIndexes[8] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[8], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _game._player._stepEnabled = false; + _vm->_sound->command(21); + break; + + case 1: + _scene->_sequences.addTimer(48, 2); + break; + + case 2: + _game._player._stepEnabled = true; + _globals[kMedicineCabinetOpen] = false; + _vm->_dialogs->show(10209); + break; + + default: + break; + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_OPEN, NOUN_MEDICINE_CABINET) && !_globals[kMedicineCabinetOpen]) { + switch (_game._trigger) { + case 0: + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _game._player._stepEnabled = false; + _vm->_sound->command(21); + break; + + case 1: + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 6, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], -2, -2); + _scene->_sequences.addTimer(48, 2); + break; + + case 2: + _game._player._stepEnabled = true; + _globals[kMedicineCabinetOpen] = true; + if (_globals[kMedicineCabinetVirgin]) { + _vm->_dialogs->show(10208); + } else { + _vm->_dialogs->show(10207); + } + _globals[kMedicineCabinetVirgin] = false; + break; + + default: + break; + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_BINOCULARS) && _game._objects.isInRoom(OBJ_BINOCULARS)) { + switch (_game._trigger) { + case 0: + _globals._sequenceIndexes[11] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[11], false, 3, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[11]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _game._player._visible = false; + _game._player._stepEnabled = false; + break; + + case 1: + _game._objects.addToInventory(OBJ_BINOCULARS); + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _scene->_hotspots.activate(NOUN_BINOCULARS, false); + _game._player._visible = true; + _game._player._stepEnabled = true; + _vm->_sound->command(22); + _vm->_dialogs->showItem(OBJ_BINOCULARS, 10201); + break; + + default: + break; + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_BURGER) && _game._objects.isInRoom(OBJ_BURGER)) { + if (_game._trigger == 0) { + _vm->_dialogs->showItem(OBJ_BURGER, 10235); + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + _game._objects.addToInventory(OBJ_BURGER); + _scene->_hotspots.activate(NOUN_BURGER, false); + _vm->_sound->command(22); + _game._player._visible = true; + _game._player._stepEnabled = true; + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_POSTER)) { + _vm->_dialogs->show(10224); + _action._inProgress = false; + return; + } + + if ((_action.isAction(VERB_PUSH) || _action.isAction(VERB_PULL)) && _action.isObject(NOUN_WEIGHT_MACHINE)) { + _vm->_dialogs->show(10225); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_FLOOR)) { + _vm->_dialogs->show(10232); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_BINOCULARS) && !_game._objects.isInInventory(OBJ_BINOCULARS)) { + _vm->_dialogs->show(10233); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_BURGER) && (_action._mainObjectSource == 4)) { + _vm->_dialogs->show(801); + _action._inProgress = false; + } +} + +void Scene102::postActions() { + if (_action.isAction(VERB_PUT, NOUN_ROBO_KITCHEN) && _game._objects.isInInventory(_game._objects.getIdFromDesc(_action._activeAction._objectNameId))) { + _vm->_dialogs->show(10217); + _action._inProgress = false; + } +} + +/*------------------------------------------------------------------------*/ + +Scene103::Scene103(MADSEngine *vm) : Scene1xx(vm) { + _updateClock = 0; +} + +void Scene103::synchronize(Common::Serializer &s) { + Scene1xx::synchronize(s); + + byte dummy = 0; + s.syncAsByte(dummy); // In order to avoid to break savegame compatibility + s.syncAsUint32LE(_updateClock); +} + +void Scene103::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene103::enter() { + _globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 2)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 3)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('x', 4)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('x', 5)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('b', -1)); + _globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('h', -1)); + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('m', -1)); + _globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('t', -1)); + _globals._spriteIndexes[10] = _scene->_sprites.addSprites(formAnimName('r', -1)); + _globals._spriteIndexes[11] = _scene->_sprites.addSprites(formAnimName('c', -1)); + _globals._spriteIndexes[12] = _scene->_sprites.addSprites("*RXMBD_2"); + _globals._spriteIndexes[13] = _scene->_sprites.addSprites("*RXMRD_3"); + _globals._spriteIndexes[15] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0], false, 7, 0, 1, 0); + + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 6, 0, 2, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 0); + + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 6, 0, 0, 25); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 2, 72); + + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 6, 0, 1, 37); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 2, 73); + + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 8); + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 6); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 6); + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 6); + + if (_game._objects.isInRoom(OBJ_TIMER_MODULE)) + _globals._sequenceIndexes[11] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[11], false, 6); + else + _vm->_game->_scene._hotspots.activate(371, false); + + if (_game._objects.isInRoom(OBJ_REBREATHER)) + _globals._sequenceIndexes[10] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[10], false, 6); + else + _vm->_game->_scene._hotspots.activate(289, false); + + if (_globals[kTurkeyExploded]) { + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], false, 6); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[9], -2, -2); + _scene->_hotspots.activate(362, false); + } + + if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(237, 74); + + if (_scene->_priorSceneId == 102) { + _game._player._stepEnabled = false; + _globals._sequenceIndexes[6] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[6], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 70); + } + + sceneEntrySound(); + _vm->_game->loadQuoteSet(70, 51, 71, 7, 73, 0); + + if (!_game._visitedScenes._sceneRevisited) { + int msgIndex = _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(70)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + } + + if (_scene->_priorSceneId == 102) + _vm->_sound->command(20); + + _vm->_palette->setEntry(252, 63, 63, 10); + _vm->_palette->setEntry(253, 45, 45, 10); + _updateClock = _scene->_frameStartTime; +} + +void Scene103::step() { + switch (_vm->_game->_trigger) { + case 70: + _vm->_game->_player._stepEnabled = true; + break; + + case 72: { + Common::Point pt = _vm->_game->_player._playerPos; + int dist = _vm->hypotenuse(pt.x - 58, pt.y - 93); + _vm->_sound->command(27, (dist * -128 / 378) + 127); + } + break; + + case 73: { + Common::Point pt = _vm->_game->_player._playerPos; + int dist = _vm->hypotenuse(pt.x - 266, pt.y - 81); + _vm->_sound->command(27, (dist * -127 / 378) + 127); + } + break; + + default: + break; + } + + if (_scene->_frameStartTime >= _updateClock) { + Common::Point pt = _vm->_game->_player._playerPos; + int dist = _vm->hypotenuse(pt.x - 79, pt.y - 137); + _vm->_sound->command(29, (dist * -127 / 378) + 127); + + pt = _vm->_game->_player._playerPos; + dist = _vm->hypotenuse(pt.x - 69, pt.y - 80); + _vm->_sound->command(30, (dist * -127 / 378) + 127); + + pt = _vm->_game->_player._playerPos; + dist = _vm->hypotenuse(pt.x - 266, pt.y - 138); + _vm->_sound->command(32, (dist * -127 / 378) + 127); + + _updateClock = _scene->_frameStartTime + _vm->_game->_player._ticksAmount; + } +} + +void Scene103::actions() { + if (_action._savedFields._lookFlag) + _vm->_dialogs->show(10322); + else if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOOR)) { + switch (_vm->_game->_trigger) { + case 0: + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 6, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _game._player._stepEnabled = false; + _vm->_sound->command(20); + break; + + case 1: + _vm->_sound->command(1); + _scene->_nextSceneId = 102; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_TAKE, 371) && _game._objects.isInRoom(OBJ_TIMER_MODULE)) { + switch (_vm->_game->_trigger) { + case 0: + _scene->changeVariant(1); + _globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 3, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[13]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_SPRITE, 7, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + _vm->_game->_player._visible = false; + _vm->_game->_player._stepEnabled = false; + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[11]); + break; + + case 2: + _vm->_sound->command(22); + _game._objects.addToInventory(OBJ_TIMER_MODULE); + _scene->changeVariant(0); + _scene->drawElements(kTransitionNone, false); + _scene->_hotspots.activate(371, false); + _vm->_game->_player._visible = true; + _vm->_game->_player._stepEnabled = true; + _vm->_dialogs->showItem(OBJ_REBREATHER, 805); + break; + + default: + break; + } + } else if (_action.isAction(VERB_TAKE, 289, 0) && _game._objects.isInRoom(OBJ_REBREATHER)) { + switch (_vm->_game->_trigger) { + case 0: + _scene->changeVariant(1); + _globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 3, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[12]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_SPRITE, 6, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + _vm->_game->_player._visible = false; + _vm->_game->_player._stepEnabled = false; + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + break; + + case 2: + _vm->_sound->command(22); + _game._objects.addToInventory(OBJ_REBREATHER); + _scene->_hotspots.activate(289, false); + _vm->_game->_player._visible = true; + _vm->_game->_player._stepEnabled = true; + _vm->_dialogs->showItem(OBJ_REBREATHER, 804); + break; + + default: + break; + } + } else if (_action.isAction(VERB_LOOK, 362)) + _vm->_dialogs->show(10301); + else if (_action.isAction(VERB_TAKE, 362)) { + // Take Turkey + if (!_vm->_game->_trigger) + _vm->_sound->command(31); + + if (_vm->_game->_trigger < 2) { + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], false, 6, _vm->_game->_trigger < 1 ? 1 : 0); + if (_vm->_game->_trigger) { + // Lock the turkey into a permanent "exploded" frame + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[9], -2, -2); + + // Rex says "Gads.." + Common::String msg = _game.getQuote(51); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 18, 0, 60, msg); + _scene->_sequences.addTimer(120, _vm->_game->_trigger + 1); + } else { + // Initial turky explosion + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + } + } + + // Re-enable player if sequence is ended, and set global flag + _game._player._stepEnabled = _game._trigger == 2; + _globals[kTurkeyExploded] = -1; + + if (_game._trigger == 2) { + // Show exposition dialog at end of sequence + _vm->_dialogs->show(10302); + _scene->_hotspots.activate(362, false); + } + } else if (_action.isAction(VERB_LOOK, 250)) + _vm->_dialogs->show(!_globals[kTurkeyExploded] ? 10323 : 10303); + else if (_action.isAction(VERB_TALKTO, 27)) { + switch (_vm->_game->_trigger) { + case 0: { + _game._player._stepEnabled = false; + Common::String msg = _game.getQuote(71); + _scene->_kernelMessages.add(Common::Point(), 0x1110, 18, 1, 120, msg); + break; + } + + case 1: { + Common::String msg = _game.getQuote(72); + _scene->_kernelMessages.add(Common::Point(310, 132), 0xFDFC, 16, 2, 120, msg); + break; + } + + case 2: + _scene->_kernelMessages.reset(); + _scene->_sequences.addTimer(1, 3); + break; + + case 3: + _game._player._stepEnabled = true; + _vm->_dialogs->show(10306); + break; + + default: + break; + } + } else if (_action.isAction(VERB_LOOK, 27)) + _vm->_dialogs->show(10304); + else if (_action.isAction(VERB_LOOK, 36)) + _vm->_dialogs->show(10307); + else if (_action.isAction(VERB_LOOK, 55)) + _vm->_dialogs->show(10308); + else if (_action.isAction(VERB_TAKE, 315)) + _vm->_dialogs->show(10309); + else if (_action.isAction(VERB_TAKE, 85)) + _vm->_dialogs->show(10310); + else if (_action.isAction(VERB_LOOK, 144)) + _vm->_dialogs->show(10312); + else if (_action.isAction(VERB_OPEN, 144)) + _vm->_dialogs->show(10313); + else if (_action.isAction(VERB_CLOSE, 27)) + _vm->_dialogs->show(10314); + else if (_action.isAction(VERB_LOOK, 310)) + _vm->_dialogs->show(10315); + else if (_action.isAction(VERB_LOOK, 178)) + _vm->_dialogs->show(10316); + else if (_action.isAction(VERB_LOOK, 283)) + _vm->_dialogs->show(10317); + else if (_action.isAction(VERB_LOOK, 120)) + _vm->_dialogs->show(10318); + else if (_action.isAction(VERB_LOOK, 289) && _game._objects.isInInventory(OBJ_REBREATHER)) + _vm->_dialogs->show(10319); + else if (_action.isAction(VERB_LOOK, 371) && _game._objects.isInInventory(OBJ_TIMER_MODULE)) + _vm->_dialogs->show(10320); + else if (_action.isAction(VERB_LOOK, 137)) + _vm->_dialogs->show(10321); + else if (_action.isAction(VERB_LOOK, 409)) + _vm->_dialogs->show(_game._objects.isInInventory(OBJ_TIMER_MODULE) ? 10324 : 10325); + else + return; + + _action._inProgress = false; +} + +void Scene103::postActions() { + if (_action.isAction(27) && !_action.isAction(VERB_WALKTO)) { + _vm->_dialogs->show(10305); + _action._inProgress = false; + } else if (_action.isAction(VERB_PUT, 85, 144)) { + Common::String msg = _game.getQuote(73); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, msg); + _action._inProgress = false; + } +} + +/*------------------------------------------------------------------------*/ + +Scene104::Scene104(MADSEngine *vm) : Scene1xx(vm) { + _kargShootingFl = false; + _loseFl = false; +} + +void Scene104::synchronize(Common::Serializer &s) { + Scene1xx::synchronize(s); + + s.syncAsByte(_kargShootingFl); + s.syncAsByte(_loseFl); +} + +void Scene104::setup() { + // Preloading has been skipped + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene104::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('h', -1)); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 14, 0, 0, 1); + + if (_scene->_priorSceneId == 105) + _game._player._playerPos = Common::Point(302, 107); + else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(160, 134); + + _loseFl = false; + _game.loadQuoteSet(0x35, 0x34, 0); + _kargShootingFl = false; + + if (_vm->getRandomNumber(1, 3) == 1) { + _scene->loadAnimation(Resources::formatName(104, 'B', -1, EXT_AA, ""), 0); + _kargShootingFl = true; + } + + sceneEntrySound(); +} + +void Scene104::step() { + if ((_game._player._playerPos == Common::Point(189, 70)) && (_game._trigger || !_loseFl)) { + if (_game._player._facing == FACING_SOUTHWEST || _game._player._facing == FACING_SOUTHEAST) + _game._player._facing = FACING_SOUTH; + + if (_game._player._facing == FACING_NORTHWEST || _game._player._facing == FACING_NORTHEAST) + _game._player._facing = FACING_NORTH; + + bool mirrorFl = false; + if (_game._player._facing == FACING_WEST) { + _game._player._facing = FACING_EAST; + mirrorFl = true; + } + + _loseFl = true; + + switch (_game._player._facing) { + case FACING_EAST: + switch (_game._trigger) { + case 0: + _scene->_kernelMessages.reset(); + _scene->freeAnimation(); + _scene->resetScene(); + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('a', 0)); + _vm->_palette->refreshSceneColors(); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], mirrorFl, 7, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(198, 143)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], mirrorFl, 7, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(198, 143)); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], -2, -2); + _scene->_sequences.addTimer(90, 2); + break; + + case 2: + _vm->_dialogs->show(10406); + _scene->_reloadSceneFlag = true; + break; + + default: + break; + } + break; + + case FACING_SOUTH: + switch (_game._trigger) { + case 0: + _scene->_kernelMessages.reset(); + _scene->freeAnimation(); + _scene->resetScene(); + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _vm->_palette->refreshSceneColors(); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 6, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[3], Common::Point(198, 143)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 4); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 14); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 5, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[3], Common::Point(198, 143)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 4); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 15, 32); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 2: + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 3, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[3], Common::Point(198, 143)); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], -2, -2); + _scene->_sequences.addTimer(90, 3); + break; + + case 3: + _vm->_dialogs->show(10406); + _scene->_reloadSceneFlag = true; + break; + + default: + break; + } + break; + + case FACING_NORTH: + switch (_game._trigger) { + case 0: + _scene->_kernelMessages.reset(); + _scene->freeAnimation(); + _scene->resetScene(); + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('a', 2)); + _vm->_palette->refreshSceneColors(); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 8, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(198, 143)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + if (_game._storyMode >= STORYMODE_NICE) + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_SPRITE, 15, 2); + break; + + case 1: + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 8, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(198, 143)); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], -2, -2); + _scene->_sequences.addTimer(90, 2); + break; + + case 2: + _vm->_dialogs->show(10406); + _scene->_reloadSceneFlag = true; + break; + + default: + break; + } + break; + default: + break; + } + + if (!_game._trigger) + _vm->_sound->command(34); + } + + if (_game._player._moving && (_scene->_rails.getNext() > 0)) { + _game._player.cancelCommand(); + _game._player.startWalking(Common::Point(189, 70), FACING_NONE); + _scene->_rails.resetNext(); + } + + if ((_game._player._special > 0) && _game._player._stepEnabled) + _game._player._stepEnabled = false; + + if (_kargShootingFl && (_scene->_activeAnimation->getCurrentFrame() >= 19)) { + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(52)); + _kargShootingFl = false; + } +} + +void Scene104::preActions() { + if (_action.isAction(VERB_SWIM_TOWARDS, NOUN_EASTERN_CLIFF_FACE)) + _game._player._walkOffScreenSceneId = 105; + + if (_action.isAction(VERB_SWIM_TOWARDS, NOUN_OPEN_AREA_TO_SOUTH)) + _game._player._walkOffScreenSceneId = 106; +} + +void Scene104::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(10405); + else if (_action.isAction(VERB_LOOK, NOUN_CURIOUS_WEED_PATCH)) + _vm->_dialogs->show(10404); + else if (_action.isAction(VERB_LOOK, NOUN_SURFACE)) + _vm->_dialogs->show(10403); + else if (_action.isAction(VERB_LOOK, NOUN_CLIFF_FACE)) + _vm->_dialogs->show(10401); + else if (_action.isAction(VERB_LOOK, NOUN_OCEAN_FLOOR)) + _vm->_dialogs->show(10402); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene105::Scene105(MADSEngine *vm) : Scene1xx(vm) { + _explosionFl = false; +} + +void Scene105::synchronize(Common::Serializer &s) { + Scene1xx::synchronize(s); + + s.syncAsByte(_explosionFl); +} + +void Scene105::setup() { + // Preloading has been skipped + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene105::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('m', 1)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('f', 4)); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 8, 0, 0, 0); + + if (_globals[kFishIn105]) { + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 6, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(48, 144)); + + int idx = _scene->_dynamicHotspots.add(101, 348, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(56, 141), FACING_NORTHWEST); + } + + if (_scene->_priorSceneId == 104) + _game._player._playerPos = Common::Point(13, 97); + else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(116, 147); + + _game.loadQuoteSet(0x4A, 0x4B, 0x4C, 0x35, 0x34, 0); + _explosionFl = false; + + sceneEntrySound(); +} + +void Scene105::step() { + if ((_game._player._playerPos == Common::Point(170, 87)) && (_game._trigger || !_explosionFl)) { + _explosionFl = true; + switch (_game._trigger) { + case 0: + _scene->_kernelMessages.reset(); + _scene->resetScene(); + _game._player._stepEnabled = false; + _game._player._visible = false; + + _globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('m', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('m', 2)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('m', 3)); + _vm->_sound->command(33); + _scene->clearSequenceList(); + _vm->_palette->refreshSceneColors(); + + _globals._sequenceIndexes[0] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[0], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[0], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + + if (_game._storyMode >= STORYMODE_NICE) + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[0], SEQUENCE_TRIGGER_SPRITE, 8, 3); + break; + + case 1: + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 6, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 8); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], -2, -2); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 9, 1, 0, 0); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], _globals._sequenceIndexes[0]); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 8); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 5, 7); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 2: { + int oldIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 9, 0, 0, 0); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], oldIdx); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 8); + _scene->_sequences.addTimer(90, 3); + } + break; + + case 3: + _vm->_dialogs->show(10507); + _scene->_reloadSceneFlag = true; + _scene->_sequences.addTimer(90, 4); + break; + + default: + break; + } + } + + if (_game._player._moving && (_scene->_rails.getNext() > 0)) { + _game._player.cancelCommand(); + _game._player.startWalking(Common::Point(170, 87), FACING_NONE); + _scene->_rails.resetNext(); + } + + if ((_game._player._special > 0) && _game._player._stepEnabled) + _game._player._stepEnabled = false; +} + +void Scene105::preActions() { + if (_action.isAction(VERB_SWIM_TOWARDS, NOUN_WESTERN_CLIFF_FACE)) + _game._player._walkOffScreenSceneId = 104; + + if (_action.isAction(VERB_SWIM_TOWARDS, NOUN_OPEN_AREA_TO_SOUTH)) + _game._player._walkOffScreenSceneId = 107; + + if (_action.isObject(NOUN_MINE) && (_action.isAction(VERB_TALKTO) || _action.isAction(VERB_LOOK))) + _game._player._needToWalk = false; +} + +void Scene105::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(10512); + else if (_action.isAction(VERB_TAKE, NOUN_DEAD_FISH) && _globals[kFishIn105]) { + if (_game._objects.isInInventory(OBJ_DEAD_FISH)) { + int randVal = _vm->getRandomNumber(74, 76); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(randVal)); + } else { + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _game._objects.addToInventory(OBJ_DEAD_FISH); + _globals[kFishIn105] = false; + _vm->_dialogs->showItem(OBJ_DEAD_FISH, 802, 0); + } + } else if (_action.isAction(VERB_LOOK, NOUN_WESTERN_CLIFF_FACE)) + _vm->_dialogs->show(10501); + else if (_action.isAction(VERB_LOOK, NOUN_CLIFF_FACE)) + _vm->_dialogs->show(10502); + else if (_action.isAction(VERB_LOOK, NOUN_OCEAN_FLOOR)) + _vm->_dialogs->show(10503); + else if (_action.isAction(VERB_LOOK, NOUN_MEDICAL_WASTE)) + _vm->_dialogs->show(10504); + else if (_action.isAction(VERB_TAKE, NOUN_MEDICAL_WASTE)) + _vm->_dialogs->show(10505); + else if (_action.isAction(VERB_LOOK, NOUN_MINE)) + _vm->_dialogs->show(10506); + else if (_action.isAction(VERB_LOOK, NOUN_DEAD_FISH)) + _vm->_dialogs->show(10508); + else if (_action.isAction(VERB_LOOK, NOUN_SURFACE)) + _vm->_dialogs->show(10509); + else if (_action.isAction(VERB_LOOK, NOUN_OPEN_AREA_TO_SOUTH)) + _vm->_dialogs->show(10510); + else if (_action.isAction(VERB_LOOK, NOUN_ROCKS)) + _vm->_dialogs->show(10511); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene106::Scene106(MADSEngine *vm) : Scene1xx(vm) { + _backToShipFl = false; + _shadowFl = false; + _firstEmergingFl = false; + _positionY = 0; +} + +void Scene106::synchronize(Common::Serializer &s) { + Scene1xx::synchronize(s); + + s.syncAsByte(_backToShipFl); + s.syncAsByte(_shadowFl); + s.syncAsByte(_firstEmergingFl); + s.syncAsSint32LE(_positionY); +} + +void Scene106::setup() { + setPlayerSpritesPrefix(); + setAAName(); + + if ((_scene->_priorSceneId == 102) && !_game._objects.isInInventory(OBJ_REBREATHER) && !_scene->_roomChanged) + _game._player._spritesPrefix = ""; + + _vm->_dialogs->_defaultPosition.y = 100; +} + +void Scene106::enter() { + _globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('H', -1)); + + if (_game._objects.isInInventory(OBJ_REBREATHER) || (_scene->_priorSceneId != 102) || _scene->_roomChanged) { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('A', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('A', 1)); + } + + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('G', -1)); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 21, 0, 0, 0); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('I', -1)); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 6, 0, 32, 47); + + if (_scene->_priorSceneId == 102) { + _globals._sequenceIndexes[0] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0], false, 6, 1, 4, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[0], SEQUENCE_TRIGGER_EXPIRE, 0, 70); + _game._player._visible = false; + _game._player._stepEnabled = false; + _game._player._facing = FACING_EAST; + _game._player._playerPos = Common::Point(106, 69); + } else if (_scene->_priorSceneId != -2) { + if (_scene->_priorSceneId == 107) { + _game._player._playerPos = Common::Point(319, 84); + _game._player._facing = _game._player._prepareWalkFacing = FACING_WEST; + } else { + _game._player._playerPos = Common::Point(319, 44); + _game._player._facing = _game._player._prepareWalkFacing = FACING_SOUTHWEST; + _scene->_sprites[_game._player._spritesStart + 3]->_charInfo->_velocity = 24; + } + + _game._player._prepareWalkPos = Common::Point(246, 69); + _game._player._needToWalk = true; + _game._player._readyToWalk = true; + } + + if (_scene->_priorSceneId != 102) { + _globals._sequenceIndexes[0] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0], false, 6, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[0], -2, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[0], 14); + } + + _backToShipFl = false; + _shadowFl = false; + _firstEmergingFl = false; + + _game.loadQuoteSet(0x31, 0x32, 0x34, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0); + sceneEntrySound(); +} + +void Scene106::step() { + if (_game._trigger == 70) { + _globals._sequenceIndexes[0] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0], false, 6, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[0], -2, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[0], 14); + + if (!_game._objects.isInInventory(OBJ_REBREATHER) && !_scene->_roomChanged) { + _scene->loadAnimation(Resources::formatName(106, 'A', -1, EXT_AA, ""), 75); + } else { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 4, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_SPRITE, 28, 71); + } + } + + if (_game._trigger == 71) { + _game._player._prepareWalkPos = Common::Point(246, 69); + _game._player._prepareWalkFacing = FACING_EAST; + _game._player._needToWalk = true; + _game._player._readyToWalk = true; + _game._player._visible = true; + + if (_game._visitedScenes._sceneRevisited) { + _game._player._stepEnabled = true; + } else { + _game._player._prepareWalkFacing = FACING_SOUTHWEST; + _firstEmergingFl = true; + _scene->loadAnimation(Resources::formatName(106, 'B', -1, EXT_AA, ""), 80); + } + } + + if (_firstEmergingFl && (_scene->_activeAnimation->getCurrentFrame() >= 19)) { + _firstEmergingFl = false; + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(52)); + } + + if ((_game._trigger >= 80) && (_game._trigger <= 87)) { + int tmpVal = _game._trigger - 80; + int msgId = -1; + switch (tmpVal) { + case 0: + _positionY = 26; + msgId = 49; + break; + + case 1: + case 2: + case 3: + case 4: + case 5: + msgId = 76 + tmpVal; + break; + + case 6: + msgId = 50; + break; + + default: + msgId = -1; + _game._player._stepEnabled = true; + break; + } + + if (msgId >= 0) { + int nextAbortVal = _game._trigger + 1; + _scene->_kernelMessages.add(Common::Point(15, _positionY), 0x1110, 0, 0, 360, _game.getQuote(msgId)); + _scene->_sequences.addTimer(150, nextAbortVal); + _positionY += 14; + } + } + + if (_backToShipFl) { + if (!_shadowFl) { + if (_game._player._playerPos.x < 204) { + _shadowFl = true; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 4, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 44, 73); + } + } else if (_game._trigger == 73) + _game._player._visible = false; + else if (_game._trigger == 72) + _scene->_sequences.addTimer(24, 74); + else if (_game._trigger == 74) + _scene->_nextSceneId = 102; + } + + if (_game._trigger == 75) { + _game._visitedScenes.pop_back(); + _scene->_nextSceneId = 102; + } +} + +void Scene106::preActions() { + if (_action.isAction(VERB_SWIM_TOWARDS, NOUN_SEA_CLIFF) || _action.isAction(VERB_SWIM_TOWARDS, NOUN_SEAWEED_BANK)) { + _game._player._stepEnabled = false; + _scene->_sprites[_game._player._spritesStart + 1]->_charInfo->_velocity = 24; + _game._player._walkOffScreenSceneId = 104; + } + + if (_action.isAction(VERB_SWIM_TOWARDS, NOUN_OPEN_AREA_TO_EAST)) + _game._player._walkOffScreenSceneId = 107; +} + +void Scene106::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(10614); + else if (_action.isAction(VERB_SWIM_TO, NOUN_MAIN_AIRLOCK)) { + _game._player._stepEnabled = false; + _game._player._prepareWalkPos = Common::Point(95, 72); + _game._player._prepareWalkFacing = FACING_WEST; + _game._player._needToWalk = true; + _game._player._readyToWalk = true; + _game._player._frameNumber = 9; + _backToShipFl = true; + } else if (_action.isAction(VERB_LOOK, NOUN_ANEMONE) || _action.isAction(VERB_LOOK_AT, NOUN_ANEMONE)) + _vm->_dialogs->show(10601); + else if (_action.isAction(VERB_TAKE, NOUN_ANEMONE)) + _vm->_dialogs->show(10602); + else if (_action.isAction(VERB_LOOK, NOUN_SEAWEED) || _action.isAction(VERB_LOOK, NOUN_SEAWEED_BANK)) + _vm->_dialogs->show(10603); + else if (_action.isAction(VERB_TAKE, NOUN_SEAWEED) || _action.isAction(VERB_TAKE, NOUN_SEAWEED_BANK)) + _vm->_dialogs->show(10604); + else if (_action.isAction(VERB_LOOK, NOUN_OPEN_AREA_TO_EAST)) + _vm->_dialogs->show(10605); + else if (_action.isAction(VERB_LOOK, NOUN_PILE_OF_ROCKS) || _action.isAction(VERB_LOOK_AT, NOUN_PILE_OF_ROCKS)) + _vm->_dialogs->show(10606); + else if (_action.isObject(NOUN_PILE_OF_ROCKS) && (_action.isAction(VERB_PUSH) || _action.isAction(VERB_PULL) || _action.isAction(VERB_TAKE))) + _vm->_dialogs->show(10607); + else if (_action.isAction(VERB_LOOK, NOUN_SHIP) || _action.isAction(VERB_LOOK_AT, NOUN_SHIP)) + _vm->_dialogs->show(10608); + else if (_action.isAction(VERB_LOOK, NOUN_MAIN_AIRLOCK)) + _vm->_dialogs->show(10609); + else if (_action.isAction(VERB_OPEN, NOUN_MAIN_AIRLOCK)) + _vm->_dialogs->show(10610); + else if (_action.isAction(VERB_CLOSE, NOUN_MAIN_AIRLOCK)) + _vm->_dialogs->show(10611); + else if (_action.isAction(VERB_LOOK, NOUN_SEA_CLIFF)) + _vm->_dialogs->show(10612); + else if (_action.isAction(VERB_LOOK, NOUN_OCEAN_FLOOR)) + _vm->_dialogs->show(10613); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene107::Scene107(MADSEngine *vm) : Scene1xx(vm) { + _shootingFl = false; +} + +void Scene107::synchronize(Common::Serializer &s) { + Scene1xx::synchronize(s); + + s.syncAsByte(_shootingFl); +} + +void Scene107::setup() { + setPlayerSpritesPrefix(); + setAAName(); + + _scene->addActiveVocab(NOUN_MANTA_RAY); +} + +void Scene107::enter() { + for (int i = 0; i < 3; i++) + _globals._spriteIndexes[i + 1] = _scene->_sprites.addSprites(formAnimName('G', i)); + + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(Resources::formatName(105, 'f', 4, EXT_SS, "")); + + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 14, 0, 0, 7); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 17, 0, 0, 13); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 19, 0, 0, 9); + + for (int i = 1; i < 4; i++) + _scene->_sequences.setDepth(_globals._sequenceIndexes[i], 0); + + if (_globals[kFishIn107]) { + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 6, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(68, 151)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 1); + int idx = _scene->_dynamicHotspots.add(101, 348, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(78, 135), FACING_SOUTHWEST); + } + + if (_scene->_priorSceneId == 105) + _game._player._playerPos = Common::Point(132, 47); + else if (_scene->_priorSceneId == 106) + _game._player._playerPos = Common::Point(20, 91); + else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(223, 151); + + if (((_scene->_priorSceneId == 105) || (_scene->_priorSceneId == 106)) && (_vm->getRandomNumber(1, 3) == 1)) { + _globals._spriteIndexes[0] = _scene->_sprites.addSprites(Resources::formatName(105, 'R', 1, EXT_SS, "")); + _globals._sequenceIndexes[0] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0], true, 4, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[0], Common::Point(270, 150)); + _scene->_sequences.setMotion(_globals._sequenceIndexes[0], SEQUENCE_TRIGGER_SPRITE, -200, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[0], 2); + _scene->_dynamicHotspots.add(218, 348, _globals._sequenceIndexes[0], Common::Rect(0, 0, 0, 0)); + } + + _game.loadQuoteSet(0x4A, 0x4B, 0x4C, 0x35, 0x34, 0); + _shootingFl = false; + + if (_vm->getRandomNumber(1, 3) == 1) { + _scene->loadAnimation(Resources::formatName(107, 'B', -1, EXT_AA, ""), 0); + _shootingFl = true; + } + + sceneEntrySound(); +} + +void Scene107::step() { + if (_shootingFl && (_scene->_activeAnimation->getCurrentFrame() >= 19)) { + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(52)); + _shootingFl = false; + } +} + +void Scene107::preActions() { + if (_action.isAction(VERB_SWIM_TOWARDS, NOUN_OPEN_AREA_TO_WEST)) + _game._player._walkOffScreenSceneId = 106; + + if (_action.isAction(VERB_SWIM_TOWARDS, NOUN_OPEN_AREA_TO_SOUTH)) + _game._player._walkOffScreenSceneId = 108; +} + +void Scene107::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(10708); + else if (_action.isAction(VERB_TAKE, NOUN_DEAD_FISH) && _globals[kFishIn107]) { + if (_game._objects.isInInventory(OBJ_DEAD_FISH)) { + int randVal = _vm->getRandomNumber(74, 76); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(randVal)); + } else { + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _game._objects.addToInventory(OBJ_DEAD_FISH); + _globals[kFishIn107] = false; + _vm->_dialogs->showItem(OBJ_DEAD_FISH, 802); + } + } else if (_action.isAction(VERB_SWIM_TOWARDS, NOUN_NORTHERN_SEA_CLIFF)) + _scene->_nextSceneId = 105; + else if (_action.isAction(VERB_LOOK, NOUN_NORTHERN_SEA_CLIFF)) + _vm->_dialogs->show(10701); + else if (_action.isAction(VERB_LOOK, NOUN_DEAD_FISH) && (_action._mainObjectSource == 4)) + _vm->_dialogs->show(10702); + else if (_action.isAction(VERB_LOOK, NOUN_BUSH_LIKE_FORMATION)) + _vm->_dialogs->show(10703); + else if (_action.isAction(VERB_LOOK, NOUN_ROCK)) + _vm->_dialogs->show(10704); + else if (_action.isAction(VERB_LOOK, NOUN_SEAWEED)) + _vm->_dialogs->show(10705); + else if (_action.isAction(VERB_LOOK, NOUN_OPEN_AREA_TO_SOUTH)) + _vm->_dialogs->show(10706); + else if (_action.isAction(VERB_LOOK, NOUN_CLIFF_FACE)) + _vm->_dialogs->show(10707); + else if (_action.isAction(VERB_LOOK, NOUN_MANTA_RAY)) + _vm->_dialogs->show(10709); + else if (_action.isAction(VERB_TAKE, NOUN_MANTA_RAY)) + _vm->_dialogs->show(10710); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene108::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene108::enter() { + if (_globals[kHoovicSated] == 2) + _globals[kHoovicSated] = 0; + + _globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('X', 0)); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('X', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('X', 2)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('X', 3)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(Resources::formatName(105, 'f', 4, EXT_SS, "")); + + _globals._sequenceIndexes[0] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0], false, 13, 0, 0, 7); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 16, 0, 0, 9); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 17, 0, 0, 3); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 14, 0, 0, 13); + + for (int i = 0; i <= 3; i++) + _scene->_sequences.setDepth(_globals._sequenceIndexes[i], 0); + + if (_globals[kFishIn108]) { + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 6, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(41, 109)); + int idx = _scene->_dynamicHotspots.add(101, 348, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(41, 109), FACING_NORTHWEST); + } + + if (_scene->_priorSceneId == 107) + _game._player._playerPos = Common::Point(138, 58); + else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(305, 98); + + _game.loadQuoteSet(0x4A, 0x4B, 0x4C, 0x35, 0x34, 0); + sceneEntrySound(); +} + +void Scene108::preActions() { + if (_action.isAction(VERB_SWIM_UNDER, NOUN_OVERHANG_TO_EAST)) + _game._player._walkOffScreenSceneId = 109; +} + +void Scene108::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(10812); + else if (_action.isAction(VERB_TAKE, NOUN_DEAD_FISH) && _globals[kFishIn108]) { + if (_game._objects.isInInventory(OBJ_DEAD_FISH)) { + int randVal = _vm->getRandomNumber(74, 76); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(randVal)); + } else { + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _game._objects.addToInventory(OBJ_DEAD_FISH); + _globals[kFishIn108] = false; + _vm->_dialogs->showItem(OBJ_DEAD_FISH, 10808); + } + } else if (_action.isAction(VERB_SWIM_TOWARDS, NOUN_OPEN_AREA_TO_NORTH)) + _scene->_nextSceneId = 107; + else if (_action.isAction(VERB_LOOK, NOUN_CLIFF_FACE)) + _vm->_dialogs->show(10801); + else if (_action.isAction(VERB_LOOK, NOUN_OCEAN_FLOOR)) + _vm->_dialogs->show(10802); + else if (_action.isAction(VERB_LOOK, NOUN_ODD_ROCK_FORMATION)) + _vm->_dialogs->show(10803); + else if (_action.isAction(VERB_TAKE, NOUN_ODD_ROCK_FORMATION)) + _vm->_dialogs->show(10804); + else if (_action.isAction(VERB_LOOK, NOUN_ROCKS)) + _vm->_dialogs->show(10805); + else if (_action.isAction(VERB_TAKE, NOUN_ROCKS)) + _vm->_dialogs->show(10806); + else if (_action.isAction(VERB_LOOK, NOUN_DEAD_FISH)) + _vm->_dialogs->show(10807); + else if (_action.isAction(VERB_LOOK, NOUN_OVERHANG_TO_EAST)) + _vm->_dialogs->show(10809); + else if (_action.isAction(VERB_LOOK, NOUN_OPEN_AREA_TO_NORTH)) + _vm->_dialogs->show(10810); + else if (_action.isAction(VERB_LOOK, NOUN_SURFACE)) + _vm->_dialogs->show(10811); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene109::Scene109(MADSEngine *vm) : Scene1xx(vm) { + _rexThrowingObject = false; + _hoovicDifficultFl = false; + _beforeEatingRex = false; + _eatingRex = false; + _hungryFl = false; + _eatingFirstFish = false; + + _throwingObjectId = -1; + _hoovicTrigger = 0; +} + +void Scene109::synchronize(Common::Serializer &s) { + Scene1xx::synchronize(s); + + s.syncAsByte(_rexThrowingObject); + s.syncAsByte(_hoovicDifficultFl); + s.syncAsByte(_beforeEatingRex); + s.syncAsByte(_eatingRex); + s.syncAsByte(_hungryFl); + s.syncAsByte(_eatingFirstFish); + s.syncAsSint32LE(_throwingObjectId); + s.syncAsSint32LE(_hoovicTrigger); +} + +void Scene109::setup() { + _scene->addActiveVocab(NOUN_DEAD_PURPLE_MONSTER); + _scene->addActiveVocab(NOUN_MONSTER_SLUDGE); + + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene109::enter() { + _globals[kFishIn105] = true; + + _globals._spriteIndexes[0] = _scene->_sprites.addSprites("*RXSWRC_6"); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('O', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('O', 2)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('O', 0)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('H', 4)); + + _rexThrowingObject = false; + _throwingObjectId = 0; + _beforeEatingRex = false; + _eatingRex = false; + _hungryFl = false; + + if (_scene->_priorSceneId == 110) { + _game._player._playerPos = Common::Point(248, 38); + _globals[kHoovicSated] = 2; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(20, 68); + _game._player._facing = FACING_EAST; + } + + if (!_globals[kHoovicAlive]) { + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 4); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], -2, -2); + + int idx = _scene->_dynamicHotspots.add(102, 348, -1, Common::Rect(256, 57, 267, 87)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(241, 91), FACING_NORTHEAST); + idx = _scene->_dynamicHotspots.add(102, 348, -1, Common::Rect(242, 79, 265, 90)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(241, 91), FACING_NORTHEAST); + idx = _scene->_dynamicHotspots.add(229, 348, -1, Common::Rect(231, 88, 253, 94)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(241, 91), FACING_NORTHEAST); + } + + if (!_globals[kHoovicAlive] || _globals[kHoovicSated]) + _scene->changeVariant(1); + + if (_game._objects.isInRoom(OBJ_BURGER)) { + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 6, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], -2, -2); + int idx = _scene->_dynamicHotspots.add(53, 348, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-3, 0), FACING_NORTHEAST); + } else if (_scene->_roomChanged) + _game._objects.addToInventory(OBJ_BURGER); + + if (_scene->_roomChanged) { + _game._objects.addToInventory(OBJ_DEAD_FISH); + _game._objects.addToInventory(OBJ_STUFFED_FISH); + } + + _vm->_palette->setEntry(252, 50, 50, 63); + _vm->_palette->setEntry(253, 30, 30, 50); + + _game.loadQuoteSet(0x53, 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0); + _eatingFirstFish = (!_game._visitedScenes._sceneRevisited) && (_scene->_priorSceneId < 110); + + if (_eatingFirstFish) { + _globals._spriteIndexes[10] = _scene->_sprites.addSprites(Resources::formatName(105, 'F', 1, EXT_SS, "")); + _globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('H', 1)); + + _globals._sequenceIndexes[10] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[10], true, 4, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 5); + _scene->_sequences.setPosition(_globals._sequenceIndexes[10], Common::Point(126, 39)); + _scene->_sequences.setMotion(_globals._sequenceIndexes[10], 0, 200, 0); + _scene->_sequences.setScale(_globals._sequenceIndexes[10], 80); + _game._player._stepEnabled = false; + } + + sceneEntrySound(); +} + +void Scene109::step() { + if (_beforeEatingRex) { + if (!_eatingRex) { + if (_game._player._playerPos.x > 205) { + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_SPRITE, 6, 70); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + + _eatingRex = true; + _vm->_sound->command(34); + } + } else { + switch (_game._trigger) { + case 70: + _game._player._visible = false; + break; + + case 71: + _scene->_reloadSceneFlag = true; + break; + } + } + } + + if (_hungryFl && (_game._player._playerPos == Common::Point(160, 32)) && (_game._player._facing == FACING_EAST)) { + _game._player.walk(Common::Point(226, 24), FACING_EAST); + _game._player._stepEnabled = false; + _hungryFl = false; + _beforeEatingRex = true; + _scene->_sprites.remove(_globals._spriteIndexes[6]); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('H', 0)); + _vm->_palette->refreshSceneColors(); + } + + if (_game._player._moving && (_scene->_rails.getNext() > 0) && _globals[kHoovicAlive] && !_globals[kHoovicSated] && !_hungryFl && !_beforeEatingRex) { + _game._player.cancelCommand(); + _game._player.startWalking(Common::Point(160, 32), FACING_EAST); + _scene->_rails.resetNext(); + _hungryFl = true; + } + + if (_eatingFirstFish && (_scene->_sequences[_globals._sequenceIndexes[10]]._position.x >= 178)) { + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], false, 4, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_SPRITE, 29, 72); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 29, 73); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[10], _globals._sequenceIndexes[9]); + _eatingFirstFish = false; + _game._player._stepEnabled = true; + _vm->_sound->command(34); + } + + if (_game._trigger == 72) + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + + if (_game._trigger == 73) { + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _scene->_sprites.remove(_globals._spriteIndexes[9]); + _scene->_sprites.remove(_globals._spriteIndexes[10]); + + _scene->_spriteSlots.clear(); + _scene->_spriteSlots.fullRefresh(); + + int randVal = _vm->getRandomNumber(85, 88); + int idx = _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(randVal)); + _scene->_kernelMessages.setQuoted(idx, 4, true); + _scene->_kernelMessages._entries[idx]._frameTimer = _scene->_frameStartTime + 4; + } +} + +void Scene109::preActions() { + if (_action.isAction(VERB_SWIM_UNDER, NOUN_OVERHANG_TO_WEST)) + _game._player._walkOffScreenSceneId = 108; + + if ((_action.isAction(VERB_THROW) || _action.isAction(VERB_GIVE) || _action.isAction(VERB_PUT)) + && (_action.isObject(NOUN_SMALL_HOLE) || _action.isObject(NOUN_TUNNEL)) + && (_action.isObject(NOUN_DEAD_FISH) || _action.isObject(NOUN_STUFFED_FISH) || _action.isObject(NOUN_BURGER))) { + int idx = _game._objects.getIdFromDesc(_action._activeAction._objectNameId); + if ((idx >= 0) && _game._objects.isInInventory(idx)) { + _game._player._prepareWalkPos = Common::Point(106, 38); + _game._player._prepareWalkFacing = FACING_EAST; + _game._player._needToWalk = true; + _game._player._readyToWalk = true; + } + } + + if ((_action.isAction(VERB_SWIM_INTO, NOUN_TUNNEL) || _action.isAction(VERB_SWIM_TO, NOUN_SMALL_HOLE)) + && (!_globals[kHoovicAlive] || _globals[kHoovicSated]) && (_action.isObject(NOUN_TUNNEL))) + _game._player._walkOffScreenSceneId = 110; + + _hungryFl = false; +} + +void Scene109::actions() { + if (_action._lookFlag) { + _vm->_dialogs->show(10912); + _action._inProgress = false; + return; + } + + if ((_action.isAction(VERB_THROW) || _action.isAction(VERB_GIVE)) && (_action.isTarget(0x146) || _action.isTarget(0x178))) { + if (_action.isObject(NOUN_DEAD_FISH) || _action.isObject(NOUN_STUFFED_FISH) || _action.isObject(NOUN_BURGER)) { + _throwingObjectId = _game._objects.getIdFromDesc(_action._activeAction._objectNameId); + if (_throwingObjectId >= 0) { + if ((_game._objects.isInInventory(_throwingObjectId) && _globals[kHoovicAlive]) || _rexThrowingObject) { + switch (_game._trigger) { + case 0: + _rexThrowingObject = true; + _hoovicDifficultFl = false; + _game._objects.setRoom(_throwingObjectId, NOWHERE); + _globals._sequenceIndexes[0] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0], false, 4, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[0]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[0], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _game._player._visible = false; + _game._player._stepEnabled = false; + + switch (_throwingObjectId) { + case OBJ_DEAD_FISH: + case OBJ_STUFFED_FISH: + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('H', 1)); + break; + + case OBJ_BURGER: + _hoovicDifficultFl = (_game._difficulty == DIFFICULTY_EASY); + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('H', (_hoovicDifficultFl ? 3 : 1))); + break; + } + + _vm->_palette->refreshSceneColors(); + break; + + case 1: + _game._player._visible = true; + _hoovicTrigger = 4; + switch (_throwingObjectId) { + case OBJ_BURGER: + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, (_hoovicDifficultFl ? 4 : 6), 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 2, 2); + if (_hoovicDifficultFl) { + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 30); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 5); + } else { + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 8); + _hoovicTrigger = 3; + } + break; + case OBJ_DEAD_FISH: + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 4, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_SPRITE, 2, 2); + break; + case OBJ_STUFFED_FISH: + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 4, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 2, 2); + _hoovicTrigger = 3; + break; + } + break; + + case 2: + if (_hoovicDifficultFl) + _globals._sequenceIndexes[8] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[8], false, 4, 2, 0, 0); + else + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 4, 1, 0, 0); + + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, _hoovicTrigger); + _vm->_sound->command(34); + break; + + case 3: + _scene->loadAnimation(Resources::formatName(109, 'H', 2, EXT_AA, ""), 4); + _vm->_sound->command(35); + _globals[kHoovicAlive] = false; + break; + + case 4: + if (!_globals[kHoovicAlive]) { + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 4); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], -2, -2); + int idx = _scene->_dynamicHotspots.add(102, 348, -1, Common::Rect(256, 57, 256 + 12, 57 + 31)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(241, 91), FACING_NORTHEAST); + idx = _scene->_dynamicHotspots.add(102, 348, -1, Common::Rect(242, 79, 242 + 24, 79 + 12)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(241, 91), FACING_NORTHEAST); + idx = _scene->_dynamicHotspots.add(229, 348, -1, Common::Rect(231, 88, 231 + 23, 88 + 7)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(241, 91), FACING_NORTHEAST); + _scene->changeVariant(1); + } else { + if (_throwingObjectId == OBJ_DEAD_FISH) { + ++_globals[kHoovicFishEaten]; + int threshold; + switch (_game._difficulty) { + case DIFFICULTY_HARD: + threshold = 1; + break; + case DIFFICULTY_MEDIUM: + threshold = 3; + break; + default: + threshold = 50; + break; + } + + if (_globals[kHoovicFishEaten] >= threshold) { + int randVal = _vm->getRandomNumber(83, 84); + _scene->_kernelMessages.add(Common::Point(230, 24), 0xFDFC, 0, 0, 120, _game.getQuote(randVal)); + _globals[kHoovicFishEaten] = 0; + _globals[kHoovicSated] = 1; + _scene->changeVariant(1); + } + } + } + _scene->freeAnimation(); + _scene->_sequences.remove(_globals._sequenceIndexes[8]); + _scene->_sprites.remove(_globals._spriteIndexes[8]); + _scene->_spriteSlots.clear(); + _scene->_spriteSlots.fullRefresh(); + _scene->_sequences.scan(); + if (_game._player._visible) { + _game._player._forceRefresh = true; + _game._player.update(); + } + + _game._player._stepEnabled = true; + _rexThrowingObject = false; + break; + + case 5: { + _game._objects.setRoom(OBJ_BURGER, _scene->_currentSceneId); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 6, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 30, 30); + int idx = _scene->_dynamicHotspots.add(53, 348, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-3, 0), FACING_NORTHEAST); + _scene->_sequences.addTimer(65, 6); + } + break; + + case 6: { + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 6, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 31, 46); + int idx = _scene->_dynamicHotspots.add(53, 348, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-3, 0), FACING_NORTHEAST); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 7); + } + break; + + case 7: { + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + int idx = _scene->_dynamicHotspots.add(53, 348, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-3, 0), FACING_NORTHEAST); + _vm->_dialogs->show(10915); + } + break; + + case 8: + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 5, 16); + break; + } + _action._inProgress = false; + return; + } else if (_game._objects.isInInventory(_throwingObjectId)) { + // Nothing. + } + } + } + } + + if (_action.isAction(VERB_TAKE, NOUN_BURGER) && _game._objects.isInRoom(OBJ_BURGER)) { + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _game._objects.addToInventory(OBJ_BURGER); + } else if (_action.isAction(VERB_LOOK, NOUN_OCEAN_FLOOR)) + _vm->_dialogs->show(10901); + else if (_action.isAction(VERB_LOOK, NOUN_CORAL)) + _vm->_dialogs->show(10902); + else if ((_action.isAction(VERB_TAKE) || _action.isAction(VERB_PULL)) && _action.isObject(NOUN_CORAL)) + _vm->_dialogs->show(10903); + else if (_action.isAction(VERB_LOOK, NOUN_ROCKS)) + _vm->_dialogs->show(10904); + else if (_action.isAction(VERB_TAKE, NOUN_ROCKS)) + _vm->_dialogs->show(10905); + else if (_action.isAction(VERB_LOOK, NOUN_CAVE_WALL)) + _vm->_dialogs->show(10906); + else if (_action.isAction(VERB_LOOK, NOUN_TUNNEL)) { + if (_globals[kHoovicAlive]) + _vm->_dialogs->show(10907); + else + _vm->_dialogs->show(10913); + } else if (_action.isAction(VERB_LOOK, NOUN_SMALL_HOLE)) + _vm->_dialogs->show(10908); + else if (_action.isAction(VERB_LOOK, NOUN_OVERHANG_TO_WEST)) + _vm->_dialogs->show(10911); + else if (_action.isAction(VERB_PUT, NOUN_SMALL_HOLE)) + _vm->_dialogs->show(10910); + else if (_action.isAction(VERB_LOOK, NOUN_DEAD_PURPLE_MONSTER)) + _vm->_dialogs->show(10914); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene110::Scene110(MADSEngine *vm) : Scene1xx(vm) { + _crabsFl = false; +} + +void Scene110::synchronize(Common::Serializer &s) { + Scene1xx::synchronize(s); + + s.syncAsByte(_crabsFl); +} + +void Scene110::setup() { + setPlayerSpritesPrefix(); + setAAName(); + + _scene->addActiveVocab(NOUN_CRAB); +} + +void Scene110::enter() { + _globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('X', 0)); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('X', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('X', 2)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('X', 3)); + + _crabsFl = false; + + if (_scene->_priorSceneId == 109) { + _game._player._playerPos = Common::Point(59, 71); + + _globals._sequenceIndexes[0] = _scene->_sequences.startCycle(_globals._spriteIndexes[0], false, 1); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + + _crabsFl = true; + + int idx = _scene->_dynamicHotspots.add(91, 348, _globals._sequenceIndexes[0], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-1, 0), FACING_NONE); + idx = _scene->_dynamicHotspots.add(91, 348, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-1, 0), FACING_NONE); + idx = _scene->_dynamicHotspots.add(91, 348, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-1, 0), FACING_NONE); + idx = _scene->_dynamicHotspots.add(91, 348, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-1, 0), FACING_NONE); + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(194, 23); + _game._player._facing = FACING_SOUTH; + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->loadAnimation(Resources::formatName(110, 'T', 1,EXT_AA, ""), 70); + } + + sceneEntrySound(); + _game.loadQuoteSet(0x59, 0); + + if (!_game._visitedScenes._sceneRevisited && (_scene->_priorSceneId == 109)) + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(109)); +} + +void Scene110::step() { + if (_game._trigger == 70) { + _game._player._visible = true; + _game._player._stepEnabled = true; + } +} + +void Scene110::preActions() { + if (_action.isAction(VERB_SWIM_THROUGH, NOUN_CAVE_ENTRANCE)) + _game._player._walkOffScreenSceneId = 109; + + if (_crabsFl) { + _crabsFl = false; + + _scene->_sequences.remove(_globals._sequenceIndexes[0]); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + + _globals._sequenceIndexes[0] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0], false, 16, 1, 0, 0); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 16, 1, 0, 0); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 16, 1, 0, 0); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 16, 1, 0, 0); + + int idx = _scene->_dynamicHotspots.add(91, 348, _globals._sequenceIndexes[0], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-1, 0), FACING_NONE); + idx = _scene->_dynamicHotspots.add(91, 348, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-1, 0), FACING_NONE); + idx = _scene->_dynamicHotspots.add(91, 348, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-1, 0), FACING_NONE); + idx = _scene->_dynamicHotspots.add(91, 348, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-1, 0), FACING_NONE); + } +} + +void Scene110::actions() { + if (_action.isAction(VERB_SWIM_THROUGH, NOUN_TUNNEL)) { + switch (_game._trigger) { + case 0: + _scene->loadAnimation(Resources::formatName(110, 'T', 0, EXT_AA, ""), 1); + _scene->_activeAnimation->setNextFrameTimer(_game._player._ticksAmount + _game._player._priorTimer); + _game._player._stepEnabled = false; + _game._player._visible = false; + break; + case 1: + _game._player._visible = true; + _game._player._stepEnabled = true; + _scene->_nextSceneId = 111; + break; + } + } else if ((_action._lookFlag) || _action.isAction(VERB_LOOK, NOUN_CAVE)) + _vm->_dialogs->show(11001); + else if (_action.isAction(VERB_LOOK, NOUN_CAVE_CEILING) || _action.isAction(VERB_LOOK_AT, NOUN_CAVE_CEILING)) + _vm->_dialogs->show(11002); + else if (_action.isAction(VERB_LOOK, NOUN_ROCKS)) + _vm->_dialogs->show(11003); + else if (_action.isAction(VERB_TAKE, NOUN_ROCKS)) + _vm->_dialogs->show(11004); + else if (_action.isAction(VERB_LOOK, NOUN_TUNNEL)) + _vm->_dialogs->show(11005); + else if (_action.isAction(VERB_LOOK, NOUN_CAVE_ENTRANCE)) + _vm->_dialogs->show(11006); + else if (_action.isAction(VERB_LOOK, NOUN_FUNGOIDS)) + _vm->_dialogs->show(11007); + else if (_action.isAction(VERB_TAKE, NOUN_FUNGOIDS)) + _vm->_dialogs->show(11008); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene111::Scene111(MADSEngine *vm) : Scene1xx(vm) { + _stampedFl = false; + _launch1Fl = false; + _launched2Fl = false; + _rexDivingFl = false; +} + +void Scene111::synchronize(Common::Serializer &s) { + Scene1xx::synchronize(s); + + s.syncAsByte(_stampedFl); + s.syncAsByte(_launch1Fl); + s.syncAsByte(_launched2Fl); + s.syncAsByte(_rexDivingFl); +} + +void Scene111::setup() { + _scene->addActiveVocab(NOUN_BATS); + + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene111::enter() { + _globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('X', 0)); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('X', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('X', 2)); + + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('B', 0)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('B', 1)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('B', 2)); + + _globals._sequenceIndexes[0] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0], false, 8, 0, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[0], SEQUENCE_TRIGGER_SPRITE, 9, 73); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[0], SEQUENCE_TRIGGER_SPRITE, 13, 73); + + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 5, 0, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_SPRITE, 71, 71); + + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 0, 0, 0); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 1); + + int idx = _scene->_dynamicHotspots.add(NOUN_BATS, 0xD1, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-2, 0), FACING_NONE); + idx = _scene->_dynamicHotspots.add(NOUN_BATS, 0xD1, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-2, 0), FACING_NONE); + idx = _scene->_dynamicHotspots.add(NOUN_BATS, 0xD1, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-2, 0), FACING_NONE); + + _launch1Fl = false; + _launched2Fl = false; + _stampedFl = false; + + if ((_scene->_priorSceneId < 201) && (_scene->_priorSceneId != -2)) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->loadAnimation(Resources::formatName(111, 'A', 0, EXT_AA, ""), 70); + _game._player._playerPos = Common::Point(234, 116); + _game._player._facing = FACING_EAST; + + _launch1Fl = true; + _launched2Fl = true; + + _vm->_sound->command(36); + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(300, 130); + _game._player._facing = FACING_WEST; + } + + _rexDivingFl = false; + + sceneEntrySound(); +} + +void Scene111::step() { + if (_game._trigger == 70) { + _game._player._stepEnabled = true; + _game._player._visible = true; + _launch1Fl = false; + _launched2Fl = false; + } + + if ((_game._trigger == 71) && !_stampedFl) { + _stampedFl = true; + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 18, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + } + + if (_game._trigger == 72) { + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 20); + } + + if (!_launch1Fl && (_vm->getRandomNumber(1, 5000) == 1)) { + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 5, 1, 0, 0); + _launch1Fl = true; + int idx = _scene->_dynamicHotspots.add(NOUN_BATS, 0xD1, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-2, 0), FACING_NONE); + } + + if (!_launched2Fl && (_vm->getRandomNumber(1, 30000) == 1)) { + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 5, 1, 0, 0); + int idx = _scene->_dynamicHotspots.add(NOUN_BATS, 0xD1, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-2, 0), FACING_NONE); + _launched2Fl = true; + } + + if (_game._trigger == 73) + _vm->_sound->command(37); + + if (_rexDivingFl && (_scene->_activeAnimation->getCurrentFrame() >= 9)) { + _vm->_sound->command(36); + _rexDivingFl = false; + } +} + +void Scene111::preActions() { + if (_action.isAction(VERB_WALK_THROUGH, NOUN_CAVE_ENTRANCE)) + _game._player._walkOffScreenSceneId = 212; +} + +void Scene111::actions() { + if (_action.isAction(VERB_DIVE_INTO, NOUN_POOL) && _game._objects.isInInventory(OBJ_REBREATHER)) { + switch (_game._trigger) { + case 0: + _scene->loadAnimation(Resources::formatName(111, 'A', 1, EXT_AA, ""), 1); + _rexDivingFl = true; + _game._player._stepEnabled = false; + _game._player._visible = false; + break; + + case 1: + _scene->_nextSceneId = 110; + break; + } + } else if (_action.isAction(VERB_LOOK, NOUN_CAVE_FLOOR)) + _vm->_dialogs->show(11101); + else if (_action.isAction(VERB_LOOK, NOUN_POOL)) + _vm->_dialogs->show(11102); + else if (_action.isAction(VERB_LOOK, NOUN_CAVE_ENTRANCE)) + _vm->_dialogs->show(11103); + else if (_action.isAction(VERB_LOOK, NOUN_STALAGMITES)) + _vm->_dialogs->show(11104); + else if (_action.isAction(VERB_LOOK, NOUN_LARGE_STALAGMITE)) + _vm->_dialogs->show(11105); + else if ((_action.isAction(VERB_PULL) || _action.isAction(VERB_TAKE)) && (_action.isObject(NOUN_STALAGMITES) || _action.isObject(NOUN_LARGE_STALAGMITE))) + _vm->_dialogs->show(11106); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene112::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene112::enter() { + sceneEntrySound(); + + _globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('X', 0)); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('X', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('X', 2)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('X', 5)); + + _globals._sequenceIndexes[0] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0], false, 10, 0, 17, 20); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 4, 0, 0, 0); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 6, 0, 3, 0); + + _game._player._stepEnabled = false; + _game._player._visible = false; + + _scene->_userInterface.emptyConversationList(); + _scene->_userInterface.setup(kInputConversation); + + _scene->loadAnimation(Resources::formatName(112, 'X', -1, EXT_AA, ""), 70); +} + +void Scene112::step() { + if ((_scene->_activeAnimation != nullptr) && (_game._storyMode == STORYMODE_NICE)) { + if (_scene->_activeAnimation->getCurrentFrame() >= 54) { + _scene->freeAnimation(); + _game._trigger = 70; + } + } + + if (_game._trigger == 70) { + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 7, 3, 0, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + } + + if (_game._trigger == 71) { + _scene->_nextSceneId = 101; + _game._player._stepEnabled = true; + _game._player._visible = true; + } +} + +/*------------------------------------------------------------------------*/ + +} // End of namespace Nebular +} // End of namespace MADS diff --git a/engines/mads/nebular/nebular_scenes1.h b/engines/mads/nebular/nebular_scenes1.h new file mode 100644 index 0000000000..96d2bb95eb --- /dev/null +++ b/engines/mads/nebular/nebular_scenes1.h @@ -0,0 +1,264 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_NEBULAR_SCENES1_H +#define MADS_NEBULAR_SCENES1_H + +#include "common/scummsys.h" +#include "common/serializer.h" +#include "mads/game.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" + +namespace MADS { + +namespace Nebular { + +class Scene1xx : public NebularScene { +protected: + /** + * Plays an appropriate sound when entering a scene + */ + void sceneEntrySound(); + + /** + *Sets the AA file to use for the scene + */ + void setAAName(); + + /** + * Updates the prefix used for getting player sprites for the scene + */ + void setPlayerSpritesPrefix(); +public: + Scene1xx(MADSEngine *vm) : NebularScene(vm) {} +}; + +class Scene101: public Scene1xx { +private: + bool _sittingFl; + bool _panelOpened; + + int _messageNum; + int _posY; + int _shieldSpriteIdx; + int _chairHotspotId; + int _oldSpecial; + + void sayDang(); + +public: + Scene101(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene102 : public Scene1xx { +private: + bool _fridgeOpenedFl; + bool _fridgeOpenedDescr; + bool _fridgeFirstOpenFl; + bool _chairDescrFl; + bool _drawerDescrFl; + bool _activeMsgFl; + + int _fridgeCommentCount; + + void addRandomMessage(); + +public: + Scene102(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); + virtual void postActions(); +}; + +class Scene103 : public Scene1xx { +private: + uint32 _updateClock; + +public: + Scene103(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); + virtual void postActions(); +}; + +class Scene104 : public Scene1xx { +private: + bool _kargShootingFl; + bool _loseFl; + +public: + Scene104(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene105 : public Scene1xx { +private: + bool _explosionFl; + +public: + Scene105(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene106 : public Scene1xx { +private: + bool _backToShipFl; + bool _shadowFl; + bool _firstEmergingFl; + + int _positionY; + +public: + Scene106(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene107 : public Scene1xx { +private: + bool _shootingFl; + +public: + Scene107(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene108 : public Scene1xx { +public: + Scene108(MADSEngine *vm) : Scene1xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene109 : public Scene1xx { +private: + bool _rexThrowingObject; + bool _hoovicDifficultFl; + bool _beforeEatingRex; + bool _eatingRex; + bool _hungryFl; + bool _eatingFirstFish; + + int _throwingObjectId; + int _hoovicTrigger; + +public: + Scene109(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene110 : public Scene1xx { +private: + bool _crabsFl; + +public: + Scene110(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene111 : public Scene1xx { +private: + bool _stampedFl; + bool _launch1Fl; + bool _launched2Fl; + bool _rexDivingFl; + +public: + Scene111(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene112 : public Scene1xx { +public: + Scene112(MADSEngine *vm) : Scene1xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions() {}; +}; + +} // End of namespace Nebular +} // End of namespace MADS + +#endif /* MADS_NEBULAR_SCENES1_H */ diff --git a/engines/mads/nebular/nebular_scenes2.cpp b/engines/mads/nebular/nebular_scenes2.cpp new file mode 100644 index 0000000000..f93ea3931d --- /dev/null +++ b/engines/mads/nebular/nebular_scenes2.cpp @@ -0,0 +1,5374 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" +#include "mads/nebular/nebular_scenes2.h" + +namespace MADS { + +namespace Nebular { + +void Scene2xx::setAAName() { + int idx = (_scene->_nextSceneId == 216) ? 4 : 2; + _game._aaName = Resources::formatAAName(idx); +} + +void Scene2xx::setPlayerSpritesPrefix() { + _vm->_sound->command(5); + Common::String oldName = _game._player._spritesPrefix; + + switch(_scene->_nextSceneId) { + case 213: + case 216: + _game._player._spritesPrefix = ""; + break; + default: + if (_globals[kSexOfRex] != SEX_MALE) { + _game._player._spritesPrefix = "ROX"; + } else { + _game._player._spritesPrefix = "RXM"; + } + break; + } + + _game._player._scalingVelocity = (_scene->_nextSceneId <= 212); + + if (oldName != _game._player._spritesPrefix) + _game._player._spritesChanged = true; + + if ((_scene->_nextSceneId == 203 || _scene->_nextSceneId == 204) && _globals[kRhotundaStatus]) + _game._player._loadsFirst = false; + + _vm->_palette->setEntry(16, 10, 63, 63); + _vm->_palette->setEntry(17, 10, 45, 45); +} + +void Scene2xx::sceneEntrySound() { + if (_vm->_musicFlag) { + switch (_scene->_nextSceneId) { + case 201: + if ((_globals[kTeleporterCommand] == 2) || (_globals[kTeleporterCommand] == 4) || (_globals[kMeteorologistStatus] != 1)) + _vm->_sound->command(9); + else + _vm->_sound->command(17); + break; + case 202: + case 203: + case 204: + case 205: + case 208: + case 209: + case 212: + _vm->_sound->command(9); + break; + case 206: + case 211: + case 215: + _vm->_sound->command(10); + break; + case 207: + case 214: + _vm->_sound->command(11); + break; + case 210: + if (_globals[kTwinklesStatus] == 0) + _vm->_sound->command(15); + else + _vm->_sound->command(10); + break; + case 213: + if (_globals[kMeteorologistWatch] == METEOROLOGIST_NORMAL) + _vm->_sound->command(1); + else + _vm->_sound->command(9); + break; + case 216: + _vm->_sound->command(16); + break; + default: + _vm->_sound->command(10); + break; + } + } else + _vm->_sound->command(2); +} + +/*------------------------------------------------------------------------*/ + +Scene201::Scene201(MADSEngine *vm) : Scene2xx(vm) { + _pterodactylFlag = false; +} + +void Scene201::synchronize(Common::Serializer &s) { + Scene2xx::synchronize(s); + + s.syncAsByte(_pterodactylFlag); +} + +void Scene201::setup() { + setPlayerSpritesPrefix(); + setAAName(); + + _scene->addActiveVocab(NOUN_SWOOPING_CREATURE); + _scene->addActiveVocab(NOUN_BIRDS); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene201::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('m', -1)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('b', -1)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites("*SC002Z1"); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 6, 0, 1, 0); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 15, 0, 0, 50); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 4, 0, 0, 0); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 6, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 8); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(185, 46)); + + int idx = _scene->_dynamicHotspots.add(NOUN_BIRDS, 209, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(186, 81), FACING_NORTH); + + if ((_scene->_priorSceneId == 202) || (_scene->_priorSceneId == -1)) { + _game._player._playerPos = Common::Point(165, 152); + } else { + _game._player._playerPos = Common::Point(223, 149); + _game._player._facing = FACING_SOUTH; + } + + if (_globals[kTeleporterCommand]) { + _game._player._visible = false; + _game._player._stepEnabled = false; + int sepChar = (_globals[kSexOfRex] == SEX_UNKNOWN) ? 't' : 'u'; + // Guess values. What is the default value used by the compiler? + int suffixNum = -1; + int abortTimers = -1; + switch(_globals[kTeleporterCommand]) { + case 1: + suffixNum = 3; + abortTimers = 76; + _globals[kTeleporterUnderstood] = true; + break; + case 2: + suffixNum = 1; + abortTimers = 77; + break; + case 3: + _game._player._visible = true; + _game._player._stepEnabled = true; + suffixNum = -1; + break; + case 4: + suffixNum = 2; + abortTimers = 78; + break; + } + _globals[kTeleporterCommand] = 0; + if (suffixNum >= 0) + _scene->loadAnimation(formAnimName(sepChar, suffixNum), abortTimers); + } + + if ((_scene->_priorSceneId == 202) && (_globals[kMeteorologistStatus] == METEOROLOGIST_PRESENT) && !_scene->_roomChanged) { + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('a', 0)); + _globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _game.loadQuoteSet(90, 91, 0); + _game._player._stepEnabled = false; + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], -1, 12); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_SPRITE, 12, 70); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 1); + _pterodactylFlag = false; + _game._player.walk(Common::Point(157, 143), FACING_NORTH); + _vm->_palette->setEntry(252, 45, 63, 45); + _vm->_palette->setEntry(253, 20, 45, 20); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 2, 0, 120, _game.getQuote(90)); + } else + _pterodactylFlag = true; + + if (_globals[kTeleporterUnderstood]) + _scene->_hotspots.activate(NOUN_STRANGE_DEVICE, false); + + sceneEntrySound(); +} + +void Scene201::step() { + if (_pterodactylFlag && (_vm->getRandomNumber(5000) == 9)) { + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 5, 1, 6, 0); + int idx = _scene->_dynamicHotspots.add(351, 13, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(270, 80), FACING_EAST); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 8); + _vm->_sound->command(14); + _pterodactylFlag = false; + } + + if (_game._trigger == 70) { + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 9, 1, 0, 0); + _game._player._visible = false; + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 12, 16); + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 9, 1, 0, 0); + _vm->_sound->command(42); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_SPRITE, 3, 81); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 73); + } + + if (_game._trigger == 81) { + _scene->_kernelMessages.reset(); + } + + if (_game._trigger == 71) { + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 9, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[7], -2, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 1); + } + + if (_game._trigger == 73) { + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 9, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 17, -2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 74); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 1); + } + + if (_game._trigger == 74) { + _vm->_sound->command(40); + + _scene->_kernelMessages.add(Common::Point(125, 56), 0xFDFC, 32, 82, 180, _game.getQuote(91)); + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 9, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 1); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], -2, -2); + _scene->_sequences.addTimer(180, 75); + } + + if (_game._trigger == 75) { + _globals[kMeteorologistEverSeen] = 0; + _scene->_nextSceneId = 202; + } + + if (_game._trigger == 76) { + _game._player._stepEnabled = true; + _game._player._visible = true; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + } + + if (_game._trigger == 77) { + _globals[kTeleporterCommand] = 1; + _scene->_nextSceneId = _globals[kTeleporterDestination]; + _scene->_reloadSceneFlag = true; + } + + if (_game._trigger == 78) { + _vm->_sound->command(40); + _vm->_dialogs->show(20114); + _scene->_reloadSceneFlag = true; + } +} + +void Scene201::actions() { + if (_action._lookFlag == false) { + if (_action.isAction(VERB_WALK_TOWARDS, NOUN_FIELD_TO_SOUTH)) + _scene->_nextSceneId = 202; + else if ((_action.isAction(VERB_CLIMB_UP, NOUN_STEPS)) || (_action.isAction(VERB_WALK_INSIDE, NOUN_TELEPORTER)) || (_action.isAction(VERB_WALK_INSIDE, NOUN_STRANGE_DEVICE))) { + if (_game._trigger == 0) { + _game._player._stepEnabled = false; + _game._player._visible = false; + int sepChar = (_globals[kSexOfRex] == SEX_MALE) ? 't' : 'u'; + _scene->loadAnimation(formAnimName(sepChar, 0), 1); + } else if (_game._trigger == 1) { + _scene->_nextSceneId = 213; + } + } else if (_action.isAction(VERB_LOOK, NOUN_GRASSY_FIELD)) { + _vm->_dialogs->show(20101); + } else if (_action.isAction(VERB_LOOK, NOUN_ROCKS)) { + _vm->_dialogs->show(20102); + } else if (_action.isAction(VERB_LOOK, NOUN_THORNY_BUSH)) { + _vm->_dialogs->show(20103); + } else if (_action.isAction(VERB_LOOK, NOUN_SKY)) { + _vm->_dialogs->show(20104); + } else if (_action.isAction(VERB_LOOK, NOUN_WATER)) { + _vm->_dialogs->show(20105); + } else if (_action.isAction(VERB_LOOK, NOUN_ISLAND_IN_DISTANCE)) { + _vm->_dialogs->show(20106); + } else if (_action.isAction(VERB_LOOK, NOUN_WEATHER_STATION)) { + _vm->_dialogs->show(20107); + } else if (_action.isAction(VERB_LOOK, NOUN_PATH)) { + _vm->_dialogs->show(20108); + } else if (_action.isAction(VERB_LOOK, NOUN_FIELD_TO_SOUTH)) { + _vm->_dialogs->show(20110); + } else if (_action.isAction(VERB_LOOK, NOUN_STRANGE_DEVICE)) { + if (_globals[kMeteorologistEverSeen]) + _vm->_dialogs->show(20112); + else + _vm->_dialogs->show(20109); + } else if (_action.isAction(VERB_LOOK, NOUN_TELEPORTER)) { + _vm->_dialogs->show(20113); + } else + return; + } else { + _vm->_dialogs->show(20111); + } + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene202::Scene202(MADSEngine *vm) : Scene2xx(vm) { + _activeMsgFl = false; + _ladderTopFl = false; + _waitingMeteoFl = false; + _ladderHotspotId = -1; + _meteoClock1 = 0; + _meteoClock2 = 0; + _toStationFl = false; + _toTeleportFl = false; + _lastRoute = 0; + _stationCounter = 0; + _meteoFrame = 0; +} + +void Scene202::synchronize(Common::Serializer &s) { + Scene2xx::synchronize(s); + + s.syncAsByte(_activeMsgFl); + s.syncAsByte(_ladderTopFl); + s.syncAsByte(_waitingMeteoFl); + s.syncAsByte(_toStationFl); + s.syncAsByte(_toTeleportFl); + + s.syncAsSint32LE(_ladderHotspotId); + s.syncAsSint32LE(_lastRoute); + s.syncAsSint32LE(_stationCounter); + s.syncAsSint32LE(_meteoFrame); + + s.syncAsUint32LE(_meteoClock1); + s.syncAsUint32LE(_meteoClock2); + s.syncAsUint32LE(_startTime); + + s.syncAsByte(_meteorologistSpecial); +} + +void Scene202::setup() { + setPlayerSpritesPrefix(); + setAAName(); + + _scene->addActiveVocab(NOUN_LADDER); + _scene->addActiveVocab(VERB_CLIMB_DOWN); + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(NOUN_BONE); + _scene->addActiveVocab(NOUN_SKULL); + _scene->addActiveVocab(NOUN_BROKEN_LADDER); +} + +void Scene202::enter() { + _game._player._beenVisible = true; + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('b', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('b', 1)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('b', 2)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('l', -1)); + if (_globals[kSexOfRex] != SEX_MALE) { + _globals._spriteIndexes[7] = _scene->_sprites.addSprites("*ROXBD_2"); + } else { + _globals._spriteIndexes[7] = _scene->_sprites.addSprites("*RXMBD_2"); + } + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('a', 0)); + _globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _globals._spriteIndexes[11] = _scene->_sprites.addSprites(formAnimName('a', 2)); + + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 6, 0, 0, 0); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 6, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(149, 113)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 10); + int idx = _scene->_dynamicHotspots.add(NOUN_BONE, VERB_WALKTO, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(153, 97), FACING_SOUTH); + + if (!(_globals[kBone202Status] & 1)) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 6, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(130, 108)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + idx = _scene->_dynamicHotspots.add(NOUN_BONE, VERB_WALKTO, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(132, 97), FACING_SOUTH); + } + + if (!(_globals[kBone202Status] & 2)) { + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 6, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[6], Common::Point(166, 110)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 10); + idx = _scene->_dynamicHotspots.add(NOUN_BONE, VERB_WALKTO, _globals._sequenceIndexes[6], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(165, 99), FACING_SOUTH); + } + + if (_globals[kBone202Status]) + _scene->changeVariant(_globals[kBone202Status]); + + if (_scene->_priorSceneId == 201) { + _game._player._playerPos = Common::Point(190, 91); + _game._player._facing = FACING_SOUTH; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(178, 152); + _game._player._facing = FACING_NORTH; + } + + if (_globals[kLadderBroken]) { + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 6, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 6); + _scene->_hotspots.activate(NOUN_LADDER, false); + idx = _scene->_dynamicHotspots.add(NOUN_BROKEN_LADDER, VERB_WALKTO, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(246, 124), FACING_NORTH); + } + + _game.loadQuoteSet(0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x62, 0x63, 0x64, 0x65, 0x66, 0x61, 0); + _activeMsgFl = false; + + if (_scene->_priorSceneId == -2) { + if (_waitingMeteoFl) { + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 1); + _game._player._visible = false; + } + } else { + _waitingMeteoFl = false; + _ladderTopFl = false; + } + + _meteoClock1 = _meteoClock2 = _scene->_frameStartTime; + + if (_scene->_roomChanged) + _game._objects.addToInventory(OBJ_BINOCULARS); + + if (_globals[kMeteorologistWatch] != METEOROLOGIST_NORMAL) { + _game._player._visible = false; + _game._player._stepEnabled = false; + _ladderTopFl = (_globals[kMeteorologistWatch] == METEOROLOGIST_TOWER); + + if (_ladderTopFl) { + _globals._sequenceIndexes[10] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], true, 8); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 1); + + _scene->_sequences.setPosition(_globals._sequenceIndexes[10], Common::Point(247, 82)); + _game._player._playerPos = Common::Point(246, 124); + _game._player._facing = FACING_NORTH; + _globals[kTeleporterUnderstood] = true; + } else { + _globals._sequenceIndexes[10] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 1); + + _scene->_sequences.setPosition(_globals._sequenceIndexes[10], Common::Point(172, 123)); + _game._player._playerPos = Common::Point(171, 122); + _game._player._facing = FACING_NORTH; + } + + _scene->loadAnimation(formAnimName('M', -1), 71); + _scene->_activeAnimation->setCurrentFrame(200); + } else { + if (_ladderTopFl) { + _game._player._visible = false; + _scene->_sequences.startCycle(_globals._sequenceIndexes[9], true, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[9], Common::Point(247, 82)); + _game._player._playerPos = Common::Point(246, 124); + _game._player._facing = FACING_NORTH; + } + } + + _meteorologistSpecial = false; +} + +void Scene202::setRandomKernelMessage() { + int vocabId = _vm->getRandomNumber(92, 96); + _scene->_kernelMessages.reset(); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 70, 120, _game.getQuote(vocabId)); + _activeMsgFl = true; +} + +void Scene202::step() { + if (!_activeMsgFl && (_game._player._playerPos == Common::Point(77, 105)) && (_game._player._facing == FACING_NORTH) && (_vm->getRandomNumber(999) == 0)) { + _scene->_kernelMessages.reset(); + _activeMsgFl = false; + if (_vm->getRandomNumber(4) == 0) + setRandomKernelMessage(); + } + + if (_game._trigger == 70) + _activeMsgFl = false; + + if (_game._trigger == 71) { + _vm->_sound->command(3); + _vm->_sound->command(9); + + _meteoClock1 = _scene->_frameStartTime + 15 * 60; + + if (_globals[kMeteorologistWatch] != METEOROLOGIST_NORMAL) { + Common::Point msgPos; + int msgFlag; + if (!_ladderTopFl) { + msgPos = Common::Point(0, 0); + msgFlag = 2; + } else { + msgPos = Common::Point(248, 15); + msgFlag = 0; + } + int msgIndex = _scene->_kernelMessages.add(msgPos, 0x1110, msgFlag | 32, 0, 120, _game.getQuote(102)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + + if (_globals[kMeteorologistWatch] == METEOROLOGIST_GROUND) { + _action._activeAction._verbId = VERB_LOOK; + _action._activeAction._objectNameId = NOUN_BINOCULARS; + _action._activeAction._indirectObjectId = NOUN_STRANGE_DEVICE; + _game._triggerSetupMode = SEQUENCE_TRIGGER_PARSER; + _scene->_sequences.addTimer(2 * 60, 2); + _meteorologistSpecial = true; + } else if (_globals[kMeteorologistWatch] == METEOROLOGIST_TOWER) { + _scene->_sequences.addTimer(2 * 60, 90); + } + } + + _globals[kMeteorologistWatch] = METEOROLOGIST_NORMAL; + } + + switch (_game._trigger) { + case 90: + _vm->_sound->command(41); + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + _globals._sequenceIndexes[9] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[9], true, 6, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[9], Common::Point(247, 82)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 91); + break; + case 91: + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], true, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[9], Common::Point(247, 82)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 1); + _scene->_sequences.addTimer(60, 92); + break; + case 92: { + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _globals._sequenceIndexes[11] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[11], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[11], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_EXPIRE, 0, 93); + _scene->_kernelMessages.reset(); + int msgIndex = _scene->_kernelMessages.add(Common::Point(0, -65), 0x1110, 32, 0, 60, _game.getQuote(98)); + _scene->_kernelMessages.setSeqIndex(msgIndex, _globals._sequenceIndexes[11]); + } + break; + case 93: { + _globals[kLadderBroken] = false; + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 6, 0, 0, 0); + _scene->_hotspots.activate(NOUN_LADDER, false); + int idx = _scene->_dynamicHotspots.add(NOUN_BROKEN_LADDER, VERB_WALKTO, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(246, 124), FACING_NORTH); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[11], _globals._sequenceIndexes[5]); + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[11]); + _game._player._stepEnabled = true; + _game._player._visible = true; + _ladderTopFl = false; + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(99)); + } + break; + default: + break; + } + + if (!_scene->_activeAnimation && (_globals[kMeteorologistStatus] != METEOROLOGIST_GONE) && (_meteoClock2 <= _scene->_frameStartTime) && (_meteoClock1 <= _scene->_frameStartTime)) { + int randVal = _vm->getRandomNumber(1, 500); + int threshold = 1; + if (_ladderTopFl) + threshold += 25; + if (!_globals[kMeteorologistEverSeen]) + threshold += 25; + if (threshold >= randVal) { + _vm->_sound->command(17); + _scene->loadAnimation(formAnimName('M', -1), 71); + _toStationFl = true; + _toTeleportFl = false; + _globals[kMeteorologistEverSeen] = true; + _lastRoute = 0; + _stationCounter = 0; + _meteoClock2 = _scene->_frameStartTime + 2; + } + } + + if (!_scene->_activeAnimation) + return; + + if (_waitingMeteoFl) { + if (_scene->_activeAnimation->getCurrentFrame() >= 200) { + if ((_globals[kMeteorologistWatch] == METEOROLOGIST_TOWER) || _globals[kLadderBroken]) { + _scene->_nextSceneId = 213; + } else { + _vm->_dialogs->show(20201); + _scene->_reloadSceneFlag = true; + } + } + + if ((_scene->_activeAnimation->getCurrentFrame() == 160) && (_meteoFrame != _scene->_activeAnimation->getCurrentFrame())) { + Common::Point msgPos; + int msgFlag; + if (!_ladderTopFl) { + msgPos = Common::Point(0, 0); + msgFlag = 2; + } else { + msgPos = Common::Point(248, 15); + msgFlag = 0; + } + int msgIndex = _scene->_kernelMessages.add(msgPos, 0x1110, msgFlag | 32, 0, 120, _game.getQuote(101)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + } + } + + if (_meteoClock2 + 120 * 60 <= _scene->_frameStartTime) { + _toTeleportFl = true; + } + + if (_scene->_activeAnimation->getCurrentFrame() == _meteoFrame) { + return; + } + + _meteoFrame = _scene->_activeAnimation->getCurrentFrame(); + int randVal = _vm->getRandomNumber(1, 1000); + int frameStep = -1; + + switch (_scene->_activeAnimation->getCurrentFrame()) { + case 42: + case 77: + case 96: + _stationCounter = 0; + frameStep = subStep1(randVal); + break; + case 51: + case 74: + _toStationFl = false; + frameStep = subStep2(randVal); + break; + case 27: + case 119: + case 159: + frameStep = subStep3(randVal); + break; + case 176: + frameStep = subStep4(randVal); + break; + case 59: + _lastRoute = 3; + ++_stationCounter; + if (randVal <= 800) + frameStep = 55; + break; + case 89: + _lastRoute = 1; + if (randVal <= 700) + frameStep = 83; + break; + case 137: + _lastRoute = 2; + if (randVal <= 700) + frameStep = 126; + break; + } + + if (frameStep >= 0 && frameStep != _scene->_activeAnimation->getCurrentFrame() + 1) { + _scene->_activeAnimation->setCurrentFrame(frameStep); + _meteoFrame = frameStep; + } +} + +int Scene202::subStep1(int randVal) { + if ((randVal <= 100) || _toStationFl) + return 42; + + if ((randVal <= 200) || _toTeleportFl) + return 96; + + if ((randVal <= 300) && (_lastRoute != 1)) + return 77; + + return 76; +} + +int Scene202::subStep2(int randVal) { + if ((randVal <= 150) && (_stationCounter < 5)) + return 51; + + if ((randVal <= 300) || _toTeleportFl) + return 74; + + if (randVal <= 400) + return 64; + + return 44; +} + +int Scene202::subStep3(int randVal) { + if ((randVal <= 100) || _toStationFl) + return 27; + + if ((randVal <= 200) || _toTeleportFl) + return 159; + + if ((randVal <= 300) && (_lastRoute != 2)) + return 119; + + return 110; +} + +int Scene202::subStep4(int randVal) { + if ((randVal <= 100) || _toTeleportFl) + return 176; + + if (randVal <= 200) + return 19; + + return 166; +} + +void Scene202::preActions() { + Player &player = _vm->_game->_player; + + if (player._readyToWalk) + _scene->_kernelMessages.reset(); + + if (!_ladderTopFl && (_action.isAction(VERB_CLIMB_DOWN, NOUN_LADDER) || !player._readyToWalk)) { + if (_game._trigger == 0) { + _vm->_sound->command(29); + player._readyToWalk = false; + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _globals._sequenceIndexes[8] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[8], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + } else if (_game._trigger == 1) { + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[8]); + _scene->_dynamicHotspots.remove(_ladderHotspotId); + _game._player._visible = true; + player._readyToWalk = true; + _game._player._stepEnabled = true; + _ladderTopFl = false; + } + } + + if (_action.isAction(VERB_LOOK, NOUN_BINOCULARS) && (_action._activeAction._indirectObjectId > 0)) { + if (!player._readyToWalk || _ladderTopFl) + _game._player._needToWalk = false; + else + _game._player._needToWalk = true; + + if (!_ladderTopFl) + _game._player.walk(Common::Point(171, 122), FACING_NORTH); + } +} + +void Scene202::actions() { + if (_action._lookFlag) { + _vm->_dialogs->show(20219); + return; + } + + if (_action.isAction(VERB_CLIMB_DOWN, NOUN_LADDER)) { + _action._inProgress = false; + return; + } else if (_action.isAction(VERB_WALK_TOWARDS, NOUN_FIELD_TO_SOUTH)) { + _scene->_nextSceneId = 203; + } else if (_action.isAction(VERB_WALK_TOWARDS, NOUN_FIELD_TO_NORTH)) { + if (_globals[kMeteorologistStatus] != METEOROLOGIST_GONE) { + if (_scene->_activeAnimation) + _globals[kMeteorologistStatus] = METEOROLOGIST_PRESENT; + else + _globals[kMeteorologistStatus] = METEOROLOGIST_ABSENT; + } + _scene->_nextSceneId = 201; + } else if (_action.isAction(VERB_TAKE, NOUN_BONE) && (_action._mainObjectSource == 4)) { + switch (_game._trigger) { + case 0: + if (_game._objects.isInInventory(OBJ_BONES)) { + _vm->_dialogs->show(20221); + } else { + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[7] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[7], false, 3, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[7]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_SPRITE, 6, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } + break; + case 1: + if (_game._player._playerPos == Common::Point(132, 97)) { + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals[kBone202Status] |= BONE_202_LEFT_GONE; + } else { + _scene->_sequences.remove(_globals._sequenceIndexes[6]); + _globals[kBone202Status] |= BONE_202_RIGHT_GONE; + } + break; + case 2: + if (_game._objects.isInInventory(OBJ_BONE)) { + _game._objects.removeFromInventory(OBJ_BONE, NOWHERE); + _game._objects.addToInventory(OBJ_BONES); + _vm->_dialogs->showItem(OBJ_BONES, 20218); + } else { + _game._objects.addToInventory(OBJ_BONE); + _vm->_dialogs->showItem(OBJ_BONE, 20218); + } + _scene->changeVariant(_globals[kBone202Status]); + _game._player._stepEnabled = true; + _game._player._visible = true; + break; + default: + break; + } + + _action._inProgress = false; + } else if ((_action.isAction(VERB_CLIMB_UP, NOUN_LADDER)) && !_globals[kLadderBroken]) { + switch (_game._trigger) { + case 0: + _vm->_sound->command(29); + _meteoClock1 = _scene->_frameStartTime; + _game._player._visible = false; + _game._player._stepEnabled = false; + + _ladderHotspotId = _scene->_dynamicHotspots.add(NOUN_LADDER, 79, -1, Common::Rect(241, 68, 241 + 12, 68 + 54)); + _scene->_dynamicHotspots.setPosition(_ladderHotspotId, Common::Point(246, 124), FACING_NORTH); + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + case 1: { + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], true, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[9], Common::Point(247, 82)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[8], _globals._sequenceIndexes[9]); + _ladderTopFl = true; + _game._player._stepEnabled = true; + int msgIndex = _scene->_kernelMessages.add(Common::Point(248, 15), 0x1110, 32, 0, 60, _game.getQuote(97)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + } + break; + default: + _action._inProgress = false; + return; + } + } else if (((_action.isAction(VERB_LOOK, NOUN_BINOCULARS, 0x82)) || (_action.isAction(VERB_LOOK, NOUN_BINOCULARS, 0x1B6))) && (_globals[kSexOfRex] == SEX_MALE)) { + if (!_ladderTopFl) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible= false; + _globals._sequenceIndexes[10] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], false, 6, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[10], 1, 6); + _scene->_sequences.setPosition(_globals._sequenceIndexes[10], Common::Point(172, 123)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 1); + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[10]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[10], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + case 1: + _globals._sequenceIndexes[10] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[10], Common::Point(172, 123)); + if (_scene->_activeAnimation) { + _waitingMeteoFl = true; + _globals[kMeteorologistWatch] = METEOROLOGIST_GROUND; + } else { + _scene->_sequences.addTimer(120, 2); + } + break; + case 2: + if (!_scene->_activeAnimation && !_meteorologistSpecial) { + _vm->_dialogs->show(20222); + } + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + _globals._sequenceIndexes[10] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[9], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 1); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[10], 1, 6); + _scene->_sequences.setPosition(_globals._sequenceIndexes[10], Common::Point(172, 123)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[10], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + case 3: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[10]); + _game._player._stepEnabled = true; + _game._player._visible = true; + break; + default: + _action._inProgress = false; + return; + } + } else { + switch (_game._trigger) { + case 0: + _toTeleportFl = true; + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], true, 6, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[9], Common::Point(247, 82)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + case 1: + _globals._sequenceIndexes[10] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], true, -2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[10], Common::Point(247, 82)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 1); + if (_scene->_activeAnimation) { + if (_scene->_activeAnimation->getCurrentFrame() > 200) { + _scene->_sequences.addTimer(120, 2); + } else { + _waitingMeteoFl = true; + _globals[kMeteorologistWatch] = METEOROLOGIST_GONE; + if ((_scene->_activeAnimation->getCurrentFrame() >= 44) && (_scene->_activeAnimation->getCurrentFrame() <= 75)) { + _scene->_kernelMessages.reset(); + int msgIndex = _scene->_kernelMessages.add(Common::Point(248, 15), 0x1110, 32, 0, 60, _game.getQuote(100)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, false); + } else { + _action._inProgress = false; + return; + } + } + } else { + _scene->_sequences.addTimer(120, 2); + } + break; + case 2: + if (!_scene->_activeAnimation) + _vm->_dialogs->show(20222); + _meteorologistSpecial = false; + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + _globals._sequenceIndexes[9] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[9], false, 6, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[9], Common::Point(247, 82)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + case 3: + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], true, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[9], Common::Point(247, 82)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 1); + _game._player._stepEnabled = true; + break; + default: + _action._inProgress = false; + return; + } + } + } else if (_action.isAction(VERB_WALK_INSIDE, NOUN_HUT)) { + setRandomKernelMessage(); + } else if (_action.isAction(VERB_LOOK, NOUN_ROCKS)) { + _vm->_dialogs->show(20202); + } else if (_action.isAction(VERB_LOOK, NOUN_FIRE_PIT)) { + _vm->_dialogs->show(20203); + } else if (_action.isAction(VERB_LOOK, NOUN_GRASS)) { + _vm->_dialogs->show(20204); + } else if (_action.isAction(VERB_LOOK, NOUN_FIELD_TO_NORTH)) { + if ((_globals[kMeteorologistStatus] == METEOROLOGIST_ABSENT) || (_globals[kMeteorologistStatus] == METEOROLOGIST_GONE)) + _vm->_dialogs->show(20205); + else if (_globals[kMeteorologistStatus] == METEOROLOGIST_PRESENT) + _vm->_dialogs->show(20220); + } else if (_action.isAction(VERB_LOOK, NOUN_WATCH_TOWER)) { + _vm->_dialogs->show(20206); + } else if (_action.isAction(VERB_LOOK, NOUN_TALL_GRASS)) { + _vm->_dialogs->show(20207); + } else if (_action.isAction(VERB_LOOK, NOUN_TREES)) { + _vm->_dialogs->show(20208); + } else if (_action.isAction(VERB_LOOK, NOUN_TREE)) { + _vm->_dialogs->show(20209); + } else if (_action.isAction(VERB_LOOK, NOUN_SKY)) { + _vm->_dialogs->show(20210); + } else if (_action.isAction(VERB_LOOK, NOUN_HUT)) { + if ((_game._player._playerPos == Common::Point(77, 105)) && (_game._player._facing == FACING_NORTH)) + _vm->_dialogs->show(20212); + else + _vm->_dialogs->show(20211); + } else if (_action.isAction(VERB_LOOK, NOUN_STRANGE_DEVICE)) { + _vm->_dialogs->show(20213); + } else if (_action.isAction(VERB_LOOK, NOUN_OCEAN_IN_DISTANCE)) { + _vm->_dialogs->show(20214); + } else if (_action.isAction(VERB_LOOK, NOUN_SKULL)) { + _vm->_dialogs->show(20215); + } else if (_action.isAction(VERB_TAKE, NOUN_SKULL)) { + _vm->_dialogs->show(20216); + } else if (_action.isAction(VERB_LOOK, NOUN_BONES) && _action._commandSource == 4) { + _vm->_dialogs->show(20217); + } + + _action._inProgress = false; +} + +/*****************************************************************************/ + +Scene203::Scene203(MADSEngine *vm) : Scene2xx(vm) { + _rhotundaEat2Fl = false; + _rhotundaEatFl = false; +} + +void Scene203::synchronize(Common::Serializer &s) { + Scene2xx::synchronize(s); + + s.syncAsByte(_rhotundaEat2Fl); + s.syncAsByte(_rhotundaEatFl); +} + +void Scene203::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(477); +} + +void Scene203::enter() { + if (_scene->_priorSceneId == 202) { + _game._player._playerPos = Common::Point(187, 99); + _game._player._facing = FACING_SOUTH; + } else if (_scene->_priorSceneId == 209) { + _game._player._playerPos = Common::Point(308, 117); + _game._player._facing = FACING_WEST; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(155, 152); + _game._player._facing = FACING_NORTH; + } + + _rhotundaEatFl = false; + _rhotundaEat2Fl = false; + + if ((_globals[kRhotundaStatus] == 0) && (!_scene->_roomChanged)) { + _rhotundaEatFl = true; + _game._player.walk(Common::Point(158, 135), FACING_SOUTH); + int idx = _scene->_dynamicHotspots.add(131, 396, 0, Common::Rect(0, 0, 320, 156)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(155, 152), FACING_SOUTH); + _scene->_dynamicHotspots.setCursor(idx, CURSOR_GO_DOWN); + } + + if (!_rhotundaEatFl) { + _globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('b', -1)); + if (_vm->getRandomNumber(1, 3) == 2) { + _globals._spriteIndexes[15] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0], false, 9, 1, 0, 0); + int idx = _scene->_dynamicHotspots.add(477, 209, _globals._spriteIndexes[15], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(-2, 0), FACING_NONE); + _vm->_sound->command(14); + } + } + + _game.loadQuoteSet(0x67, 0x68, 0x69, 0x6A, 0x5A, 0); + + if (_rhotundaEatFl) { + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(_vm->getRandomNumber(103, 106))); + } + + sceneEntrySound(); +} + +void Scene203::step() { + if (!_rhotundaEatFl) + return; + + if ((_game._trigger == 0) && _rhotundaEat2Fl) + return; + + if ((_game._player._playerPos != Common::Point(158, 136)) || (_game._player._facing != FACING_SOUTH)) + return; + + _rhotundaEat2Fl = true; + + if (_game._trigger == 0) { + _game._player._visible = false; + _game._player._stepEnabled = false; + _vm->_palette->lock(); + _scene->_kernelMessages.reset(); + _scene->resetScene(); + _vm->_events->setCursor2(CURSOR_WAIT); + _scene->loadAnimation(Resources::formatName(203, 'a', -1, EXT_AA, ""), 81); + } else if (_game._trigger == 81) { + _scene->_nextSceneId = 208; + _scene->_reloadSceneFlag = true; + } +} + +void Scene203::preActions() { + if (_rhotundaEatFl && !_action.isAction(VERB_WALK_TOWARDS, NOUN_FIELD_TO_SOUTH)) { + _game._player.walk(Common::Point(158, 136), FACING_SOUTH); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_WALKTO, NOUN_OPEN_AREA_TO_EAST)) + _game._player._walkOffScreenSceneId = 209; +} + +void Scene203::actions() { + if (_action._savedFields._lookFlag) { + _vm->_dialogs->show(20307); + } else if (_action.isAction(VERB_WALK_TOWARDS, NOUN_FIELD_TO_SOUTH)) { + _scene->_nextSceneId = 208; + } else if (_action.isAction(VERB_WALK_TOWARDS, NOUN_FIELD_TO_NORTH)) { + _scene->_nextSceneId = 202; + } else if (_action.isAction(VERB_LOOK, NOUN_SKY)) { + _vm->_dialogs->show(20301); + } else if (_action.isAction(VERB_LOOK, NOUN_CLIFF_FACE)) { + _vm->_dialogs->show(20302); + } else if (_action.isAction(VERB_LOOK, NOUN_PALM_TREE)) { + _vm->_dialogs->show(20303); + } else if (_action.isAction(VERB_LOOK, NOUN_FIELD_TO_NORTH)) { + _vm->_dialogs->show(20304); + } else if (_action.isAction(VERB_LOOK, NOUN_GRASSY_FIELD)) { + _vm->_dialogs->show(20305); + } else if (_action.isAction(VERB_LOOK, NOUN_BOULDERS)) { + _vm->_dialogs->show(20305); + } else + return; + + _action._inProgress = false; +} + +/*****************************************************************************/ + +void Scene205::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(NOUN_CHICKEN); + _scene->addActiveVocab(NOUN_PIRANHA); +} + +Scene205::Scene205(MADSEngine *vm) : Scene2xx(vm) { + _lastFishTime = 0; + _chickenTime = 0; + _beingKicked = false; + _kernelMessage = -1; +} + +void Scene205::synchronize(Common::Serializer &s) { + Scene2xx::synchronize(s); + + s.syncAsUint32LE(_lastFishTime); + s.syncAsUint32LE(_chickenTime); + s.syncAsByte(_beingKicked); + s.syncAsSint16LE(_kernelMessage); +} + +void Scene205::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 2)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('f', -1)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('c', -1)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('p', -1)); + + if (_globals[kSexOfRex] == SEX_MALE) + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('a', 1)); + + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 10, 0, 0, 3); + int idx = _scene->_dynamicHotspots.add(73, 13, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(162, 120), FACING_NORTHEAST); + + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 15, 0, 0, 0); + idx = _scene->_dynamicHotspots.add(73, 13, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(162, 120), FACING_NORTHEAST); + + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 9, 0, 0, 0); + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 6, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 11); + + if (!_game._visitedScenes._sceneRevisited) { + _lastFishTime = _scene->_frameStartTime; + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 7, 1, 0, 0); + idx = _scene->_dynamicHotspots.add(269, 13, _globals._sequenceIndexes[6], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(49, 86), FACING_NORTH); + } + + if (_game._objects[12]._roomNumber == 205) { + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 7, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 11); + } else { + _scene->_hotspots.activate(450, false); + } + + _beingKicked = false; + _game.loadQuoteSet(0x6B, 0x70, 0x71, 0x72, 0x5A, 0x74, 0x75, 0x76, 0x77, 0x78, 0x73, 0x79, 0x7A, 0x7B, 0x7C, + 0x7D, 0x7E, 0x7F, 0x80, 0xAC, 0xAD, 0xAE, 0x6C, 0x6D, 0x6E, 0x6F, 0x2, 0); + _dialog1.setup(0x2A, 0x5A, 0x78, 0x74, 0x75, 0x76, 0x77, 0); + + if (!_game._visitedScenes._sceneRevisited) + _dialog1.set(0x5A, 0x74, 0x75, 0x77, 0); + + _vm->_palette->setEntry(250, 63, 50, 20); + _vm->_palette->setEntry(251, 50, 40, 15); + _vm->_palette->setEntry(252, 63, 63, 40); + _vm->_palette->setEntry(253, 50, 50, 30); + + _chickenTime = _vm->_game->_scene._frameStartTime; + + if (_globals[kSexOfRex] == SEX_FEMALE) + _scene->_kernelMessages.initRandomMessages(3, + Common::Rect(195, 99, 264, 134), 13, 2, 0xFDFC, 60, + 108, 108, 109, 109, 110, 110, 111, 108, 0); + + if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(99, 152); + + if (_globals[kSexOfRex] != SEX_MALE) { + _scene->loadAnimation(formAnimName('a', -1)); + _scene->_activeAnimation->_resetFlag = false; + } else { + _beingKicked = true; + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 8, 1, 0, 0); + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_SPRITE, 6, 73); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_SPRITE, 11, 74); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 0); + } + sceneEntrySound(); +} + +void Scene205::step() { + if (_globals[kSexOfRex] == SEX_FEMALE) { + _scene->_kernelMessages.randomServer(); + + if (_vm->_game->_scene._frameStartTime >= _chickenTime) { + int chanceMinor = _scene->_kernelMessages.checkRandom() + 1; + if (_scene->_kernelMessages.generateRandom(100, chanceMinor)) + _vm->_sound->command(28); + + _chickenTime = _vm->_game->_scene._frameStartTime + 2; + } + } + + if (_vm->_game->_scene._frameStartTime - _lastFishTime > 1300) { + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle( + _globals._spriteIndexes[6], false, 5, 1, 0, 0); + int idx = _scene->_dynamicHotspots.add(269, 13, _globals._sequenceIndexes[6], + Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(49, 86), FACING_NORTH); + _lastFishTime = _vm->_game->_scene._frameStartTime; + } + + if (_game._trigger == 73) + _scene->_kernelMessages.add(Common::Point(160, 68), 0xFBFA, 32, 0, 60, _game.getQuote(112)); + + if (_game._trigger == 74) { + _vm->_sound->command(26); + _scene->_kernelMessages.add(Common::Point(106, 90), 0x1110, 32, 0, 60, _game.getQuote(113)); + } + + if (_game._trigger == 71) { + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 6, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 2); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], -2, -2); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(160, 68), 0xFBFA, 32, 72, 180, _game.getQuote(114)); + } + + if (_game._trigger == 72) + _scene->_nextSceneId = 211; +} + +void Scene205::handleWomanSpeech(int quote) { + _kernelMessage = _scene->_kernelMessages.add(Common::Point(186, 27), 0xFBFA, 0, 0, 9999999, _game.getQuote(quote)); +} + +void Scene205::actions() { + if (_game._screenObjects._inputMode == 1) { + if (_kernelMessage >= 0) + _scene->_kernelMessages.remove(_kernelMessage); + _kernelMessage = -1; + + if (_game._trigger == 0) { + _game._player._stepEnabled = false; + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 18, 1, 120, _game.getQuote(_action._activeAction._verbId)); + } else { + if ((_game._trigger > 1) || (_action._activeAction._verbId != 0x76)) + _game._player._stepEnabled = true; + + switch (_action._activeAction._verbId) { + case 0x5A: + handleWomanSpeech(0x7A); + _dialog1.write(0x78, true); + _dialog1.write(0x5A, false); + break; + + case 0x74: + handleWomanSpeech(0x7C); + _dialog1.write(0x74, false); + _dialog1.write(0x76, true); + break; + + case 0x75: + case 0x78: + handleWomanSpeech(0x7B); + _dialog1.write(_action._activeAction._verbId, false); + _vm->_dialogs->show(20501); + break; + + case 0x76: + if (_game._trigger == 1) { + handleWomanSpeech(0x7D); + _scene->_sequences.addTimer(120, 2); + } else if (_game._trigger == 2) { + handleWomanSpeech(0x7E); + _dialog1.write(0x76, false); + _globals[kChickenPermitted] = true; + } + break; + + case 0x77: + _scene->_kernelMessages.add(Common::Point(186, 27), 0xFBFA, 0, 0, 120, _game.getQuote(0x7F)); + _scene->_userInterface.setup(kInputBuildingSentences); + break; + + default: + break; + } + + if (_action._activeAction._verbId != 0x77) + _dialog1.start(); + } + } else if (_action._lookFlag) + _vm->_dialogs->show(20502); + else if (_action.isAction(VERB_LOOK, NOUN_BINOCULARS, 0x1C8)) + _vm->_dialogs->show(20518); + else if (_action.isAction(VERB_TALKTO, NOUN_NATIVE_WOMAN)) { + if (_game._trigger == 0) { + _game._player._stepEnabled = false; + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 18, 1, 120, _game.getQuote(0x73)); + } else if (_game._trigger == 1) { + _game._player._stepEnabled = true; + handleWomanSpeech (0x79); + _dialog1.write(0x5A, true); + _dialog1.write(0x75, true); + _dialog1.start(); + } + } else if (_action.isAction(VERB_GIVE, NOUN_NATIVE_WOMAN) && _game._objects.isInInventory(_game._objects.getIdFromDesc(_action._activeAction._objectNameId))) { + if (_game._trigger == 0) { + _game._player._stepEnabled = false; + int rndVal = _vm->getRandomNumber(0xAC, 0xAE); + _scene->_kernelMessages.add(Common::Point(186, 27), 0xFBFA, 32, 1, 120, _game.getQuote(rndVal)); + } else if (_game._trigger == 1) + _game._player._stepEnabled = true; + } else if (_action.isAction(VERB_WALKTO, NOUN_OPPOSITE_BANK)) { + if (_game._trigger == 0) { + _game._player._visible = false; + _game._player._stepEnabled = false; + _vm->_palette->lock(); + _scene->_kernelMessages.reset(); + _game._player.removePlayerSprites(); + _globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('a', 0)); + _vm->_palette->refreshSceneColors(); + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[9], -1); + _vm->_sound->command(27); + } else if (_game._trigger == 1) { + if (_scene->_activeAnimation != nullptr) + _scene->_activeAnimation->resetSpriteSetsCount(); + + _vm->_dialogs->show(20516); + _scene->_reloadSceneFlag = true; + } + } else { + if (_action.isAction(VERB_WALK_DOWN, NOUN_PATH_TO_SOUTH)) + _scene->_nextSceneId = 210; + + if (_action.isAction(VERB_WALKTO, NOUN_FIRE_PIT) || _action.isAction(VERB_WALKTO, NOUN_CHICKEN_ON_SPIT)) { + if (_game._objects.isInRoom(OBJ_CHICKEN)) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x6B)); + } + } else if (_action.isAction(VERB_TAKE, NOUN_CHICKEN_ON_SPIT) && _globals[kChickenPermitted] && _game._objects.isInRoom(OBJ_CHICKEN)) { + _game._objects.addToInventory(OBJ_CHICKEN); + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _scene->_hotspots.activate(NOUN_CHICKEN_ON_SPIT, false); + _vm->_dialogs->showItem(OBJ_CHICKEN, 812); + } else if (_action.isAction(VERB_TAKE, NOUN_CHICKEN_ON_SPIT) && (!_globals[kChickenPermitted])) + _scene->_kernelMessages.add(Common::Point(186, 27), 0xFBFA, 32, 0, 120, _game.getQuote(0x80)); + else if (_action.isAction(VERB_LOOK, NOUN_NATIVE_WOMAN)) + _vm->_dialogs->show(20503); + else if (_action.isAction(VERB_LOOK, NOUN_HUT)) + _vm->_dialogs->show(20504); + else if (_action.isAction(VERB_LOOK, NOUN_CHICKEN) && (_action._mainObjectSource == 4)) + _vm->_dialogs->show(20505); + else if (_action.isAction(VERB_TAKE, NOUN_CHICKEN) && (_action._mainObjectSource == 4)) + _vm->_dialogs->show(20506); + else if (_action.isAction(VERB_LOOK, NOUN_CHICKEN_ON_SPIT)) + _vm->_dialogs->show(20507); + else if (_action.isAction(VERB_LOOK, NOUN_FIRE_PIT)) + _vm->_dialogs->show(20508); + else if (_action.isAction(VERB_TAKE, NOUN_FIRE_PIT)) + _vm->_dialogs->show(20509); + else if (_action.isAction(VERB_LOOK, NOUN_STREAM)) + _vm->_dialogs->show(20510); + else if (_action.isAction(VERB_LOOK, NOUN_OPPOSITE_BANK)) + _vm->_dialogs->show(20511); + else if (_game._objects.isInInventory(_game._objects.getIdFromDesc(_action._activeAction._objectNameId)) + && ( _action.isAction(VERB_GIVE, NOUN_STREAM) || _action.isAction(VERB_THROW, NOUN_STREAM) + || _action.isAction(VERB_GIVE, NOUN_PIRANHA) || _action.isAction(VERB_THROW, NOUN_PIRANHA))) + _vm->_dialogs->show(20512); + else if (_action.isAction(VERB_LOOK, NOUN_PIRANHA)) + _vm->_dialogs->show(20513); + else if (_action.isAction(VERB_LOOK, NOUN_TWINKIFRUIT_BUSH)) + _vm->_dialogs->show(20514); + else if (_action.isAction(VERB_TAKE, NOUN_TWINKIFRUIT_BUSH)) + _vm->_dialogs->show(20515); + else if (_action.isAction(VERB_TAKE, NOUN_NATIVE_WOMAN)) + _vm->_dialogs->show(20517); + else + return; + } + + _action._inProgress = false; +} + +/*****************************************************************************/ + +Scene207::Scene207(MADSEngine *vm) : Scene2xx(vm) { + _vultureFl = false; + _spiderFl = false; + _eyeFl = false; + _spiderHotspotId = -1; + _vultureHotspotId = -1; + _spiderTime = 0; + _vultureTime = 0; +} + +void Scene207::synchronize(Common::Serializer &s) { + Scene2xx::synchronize(s); + + s.syncAsByte(_vultureFl); + s.syncAsByte(_spiderFl); + s.syncAsByte(_eyeFl); + + s.syncAsSint32LE(_spiderHotspotId); + s.syncAsSint32LE(_vultureHotspotId); + s.syncAsSint32LE(_spiderTime); + s.syncAsSint32LE(_vultureTime); +} + +void Scene207::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_VULTURE); + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(NOUN_SPIDER); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene207::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('h', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('h', 1)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('c', -1)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('e', 0)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('e', 1)); + _globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('g', 1)); + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('g', 0)); + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 7, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 7); + + int var2; + if (!_game._visitedScenes._sceneRevisited) { + var2 = 1; + } else { + var2 = _vm->getRandomNumber(4) + 1; + } + + if (var2 > 2) + _vultureFl = false; + else + _vultureFl = true; + + _spiderFl = (var2 & 1); + + if (_vultureFl) { + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 30, 0, 0, 400); + _vultureTime = _game._player._priorTimer; + _vultureHotspotId = _scene->_dynamicHotspots.add(389, 13, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_vultureHotspotId, Common::Point(254, 94), FACING_WEST); + } + + if (_spiderFl) { + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], -1, -1); + _spiderTime = _game._player._priorTimer; + _spiderHotspotId = _scene->_dynamicHotspots.add(333, 13, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_spiderHotspotId, Common::Point(59, 132), FACING_SOUTH); + } + + _eyeFl = false; + if (_scene->_priorSceneId == 211) { + _game._player._playerPos = Common::Point(13, 105); + _game._player._facing = FACING_EAST; + } else if (_scene->_priorSceneId == 214) { + _game._player._playerPos = Common::Point(164, 117); + _game._player._facing = FACING_SOUTH; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(305, 131); + } + + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 1, 22); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 6); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 70); +} + +void Scene207::moveVulture() { + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0); + _vm->_sound->command(43); + _vultureFl = false; + _vultureTime = _game._player._priorTimer; + _scene->_dynamicHotspots.remove(_vultureHotspotId); +} + +void Scene207::moveSpider() { + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 5, 1, 0, 0); + _spiderFl = false; + _spiderTime = _game._player._priorTimer; + _scene->_dynamicHotspots.remove(_spiderHotspotId); +} + +void Scene207::step() { + if (!_vultureFl) + moveVulture(); + + if (_spiderFl) + moveSpider(); + + if (_game._trigger == 70) { + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 10, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 23, 34); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 6); + } + + if (_game._trigger == 71) + _eyeFl = false; + + if (_eyeFl) + return; + + if ((_game._player._playerPos.x >= 124) && (_game._player._playerPos.x <= 201)) { + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 10, 1, 0, 0); + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 8, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 6); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + _eyeFl = true; + } +} + +void Scene207::preActions() { + if (_action.isAction(VERB_WALK_DOWN, NOUN_PATH_TO_WEST)) + _game._player._walkOffScreenSceneId = 211; + + if (_action.isAction(VERB_WALK_TOWARDS, NOUN_OPEN_FIELD_TO_EAST)) + _game._player._walkOffScreenSceneId = 208; + + if ((_action.isAction(VERB_WALKTO)) || (_action.isAction(VERB_LOOK))) { + if (_action.isAction(0x185)) { + _vultureTime = -9999; + } else if (_action.isAction(0x14D)) { + _spiderTime = -9999; + } + } +} + +void Scene207::actions() { + if (_action._savedFields._lookFlag) + _vm->_dialogs->show(20711); + else if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOORWAY)) + _scene->_nextSceneId = 214; + else { + if ((_game._player._playerPos.x > 150) && (_game._player._playerPos.x < 189) && + (_game._player._playerPos.y > 111) && (_game._player._playerPos.y < 130)) { + if ((_game._player._playerPos.x <= 162) || (_game._player._playerPos.x >= 181) || + (_game._player._playerPos.y <= 115) || (_game._player._playerPos.y >= 126)) { + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 10, 2, 0, 0); + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 8, 2, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 6); + } + } else if (_eyeFl) { + _scene->_sequences.remove(_globals._sequenceIndexes[7]); + _scene->_sequences.remove(_globals._sequenceIndexes[8]); + _eyeFl = false; + } + + if (_action.isAction(VERB_LOOK, NOUN_DENSE_FOREST)) + _vm->_dialogs->show(20701); + else if (_action.isAction(VERB_LOOK, NOUN_HEDGE)) + _vm->_dialogs->show(20702); + else if (_action.isAction(VERB_LOOK, NOUN_SKULL_AND_CROSSBONES)) + _vm->_dialogs->show(20703); + else if (_action.isAction(VERB_LOOK, NOUN_CAULDRON)) + _vm->_dialogs->show(20704); + else if (_action.isAction(VERB_LOOK, NOUN_WITCHDOCTOR_HUT)) + _vm->_dialogs->show(20705); + else if (_action.isAction(VERB_LOOK, NOUN_PATH_TO_WEST)) + _vm->_dialogs->show(20706); + else if (_action.isAction(VERB_LOOK, NOUN_MOUNTAINS)) + _vm->_dialogs->show(20707); + else if (_action.isAction(VERB_LOOK, NOUN_ALOE_PLANT)) + _vm->_dialogs->show(20708); + else if (_action.isAction(VERB_LOOK, NOUN_LAWN)) + _vm->_dialogs->show(20709); + else if (_action.isAction(VERB_LOOK, NOUN_VULTURE)) + _vm->_dialogs->show(20710); + else if (_action.isAction(VERB_TAKE, NOUN_SKULL_AND_CROSSBONES)) + _vm->_dialogs->show(20712); + else if (_action.isAction(VERB_TAKE, NOUN_ALOE_PLANT)) + _vm->_dialogs->show(20713); + else if (_action.isAction(VERB_LOOK, NOUN_SPIDER)) + _vm->_dialogs->show(20714); + else if (_action.isAction(VERB_TAKE, NOUN_SPIDER)) + _vm->_dialogs->show(20715); + else + return; + } + + _action._inProgress = false; +} + +/*****************************************************************************/ + +Scene208::Scene208(MADSEngine *vm) : Scene2xx(vm) { + _rhotundaTurnFl = false; + _boundingFl = false; + _rhotundaTime = 0; +} + +void Scene208::synchronize(Common::Serializer &s) { + Scene2xx::synchronize(s); + + s.syncAsByte(_rhotundaTurnFl); + s.syncAsByte(_boundingFl); + s.syncAsSint32LE(_rhotundaTime); +} + +void Scene208::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_HUGE_LEGS); + _scene->addActiveVocab(NOUN_LEAF_COVERED_PIT); + _scene->addActiveVocab(NOUN_PILE_OF_LEAVES); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene208::updateTrap() { + if (_globals[kRhotundaStatus] == 1) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 8, 0, 0, 24); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 5); + int idx = _scene->_dynamicHotspots.add(NOUN_HUGE_LEGS, VERB_WALKTO, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(100, 146), FACING_NORTH); + _scene->_hotspots.activate(414, false); + return; + } + + switch (_globals[kLeavesStatus]) { + case 0: { + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 15); + int idx = _scene->_dynamicHotspots.add(NOUN_PILE_OF_LEAVES, VERB_WALKTO, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(60, 152), FACING_NORTH); + } + break; + case 2: { + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 15); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_hotspots.activate(NOUN_DEEP_PIT, false); + int idx = _scene->_dynamicHotspots.add(NOUN_LEAF_COVERED_PIT, VERB_WALKTO, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(100, 146), FACING_NORTH); + _scene->_dynamicHotspots[idx]._articleNumber = PREP_ON; + } + break; + } +} + +void Scene208::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('x', 2)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites("*RXMBD_8"); + + updateTrap(); + + _rhotundaTurnFl = false; + _boundingFl = false; + _scene->_kernelMessages._talkFont = _vm->_font->getFont(FONT_INTERFACE); + _scene->_textSpacing = 0; + + if (_scene->_priorSceneId == 207) { + _game._player._playerPos = Common::Point(8, 122); + _game._player._facing = FACING_EAST; + } else if (_scene->_priorSceneId == 203) { + _game._player._playerPos = Common::Point(142, 108); + _game._player._facing = FACING_SOUTH; + } else if (_scene->_priorSceneId == 209) { + _game._player._playerPos = Common::Point(307, 123); + _game._player._facing = FACING_WEST; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(162, 149); + _game._player._facing = FACING_NORTH; + } + + _game.loadQuoteSet(0x81, 0x46, 0); + + if ((_scene->_priorSceneId == 207) && (_globals[kMonkeyStatus] == MONKEY_HAS_BINOCULARS)) { + int msgIndex = _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(129)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + } + + _vm->_palette->setEntry(16, 0, 0, 63); + _vm->_palette->setEntry(17, 0, 0, 45); + sceneEntrySound(); +} + +void Scene208::step() { + if (_boundingFl && (_rhotundaTime <= _scene->_activeAnimation->getCurrentFrame())) { + _rhotundaTime = _scene->_activeAnimation->getCurrentFrame(); + + if (_rhotundaTime == 125) + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + } + + if (!_rhotundaTurnFl) + return; + + if ((_game._player._playerPos != Common::Point(20, 148)) || (_game._player._facing != FACING_EAST)) + return; + + if ((_game._trigger == 0) && _boundingFl) + return; + + _boundingFl = true; + + switch (_game._trigger) { + case 0: + _scene->loadAnimation(formAnimName('A', -1), 81); + _rhotundaTime = 0; + break; + case 81: + _scene->_sequences.remove(_globals._spriteIndexes[15]); + _globals[kRhotundaStatus] = 1; + updateTrap(); + _scene->_sequences.addTimer(90, 82); + break; + case 82: + _game._player._stepEnabled = true; + break; + } +} + +void Scene208::preActions() { + Player &player = _vm->_game->_player; + + if (_action.isAction(VERB_LOOK) && player._readyToWalk) + player._needToWalk = true; + + if (_action.isAction(VERB_WALK_TOWARDS, NOUN_GRASSLAND_TO_EAST)) + player._walkOffScreenSceneId = 209; + + if (_action.isAction(VERB_WALK_TOWARDS, NOUN_OPEN_AREA_TO_WEST)) + player._walkOffScreenSceneId = 207; +} + +void Scene208::subAction(int mode) { + + switch (_game._trigger) { + case 0: { + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 6, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + + int abortVal; + if ((mode == 1) || (mode == 2)) + abortVal = 1; + else + abortVal = 2; + + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, abortVal); + } + break; + case 1: { + int oldVal = _globals._sequenceIndexes[5]; + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 12, 3, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 3, 4); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], oldVal); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + _vm->_sound->command(20); + } + break; + + case 2: { + switch (mode) { + case 1: + _game._objects.addToInventory(OBJ_BIG_LEAVES); + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals[kLeavesStatus] = 1; + break; + + case 2: + _game._objects.setRoom(OBJ_BIG_LEAVES, 1); + _globals[kLeavesStatus] = 2; + updateTrap(); + break; + + case 3: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _game._objects.removeFromInventory(OBJ_TWINKIFRUIT, 1); + _vm->_sound->command(34); + break; + + case 4: + _game._objects.removeFromInventory(OBJ_BURGER, 1); + _vm->_sound->command(33); + break; + + case 5: + _game._objects.removeFromInventory(OBJ_DEAD_FISH, 1); + _vm->_sound->command(33); + break; + + default: + break; + } + + int oldVal = _globals._sequenceIndexes[5]; + _globals._sequenceIndexes[5] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[5], false, 6, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], oldVal); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + } + break; + + case 3: + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } +} + +void Scene208::actions() { + if (_action.isAction(VERB_WALK_TOWARDS, NOUN_LOWLANDS_TO_NORTH)) { + if (_globals[kRhotundaStatus]) + _scene->_nextSceneId = 203; + else if (_game._trigger == 0) { + _game._player._stepEnabled = false; + int msgIndex = _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 1, 120, _game.getQuote(70)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + } else if (_game._trigger == 1) + _scene->_nextSceneId = 203; + } else if (_action.isAction(VERB_WALK_TOWARDS, NOUN_FIELD_TO_SOUTH)) + _scene->_nextSceneId = 212; + else if (_action.isAction(VERB_TAKE, NOUN_PILE_OF_LEAVES) && (!_globals[kLeavesStatus] || _game._trigger)) { + subAction(1); + if (_game._player._stepEnabled) + _vm->_dialogs->showItem(OBJ_BIG_LEAVES, 0x326, 0); + } else if (_action.isAction(VERB_PUT, NOUN_BIG_LEAVES, NOUN_DEEP_PIT) && (_globals[kLeavesStatus] == 1 || _game._trigger)) + subAction(2); + else if (_action.isAction(VERB_PUT, NOUN_TWINKIFRUIT, NOUN_LEAF_COVERED_PIT)) { + subAction(3); + if (_game._player._stepEnabled) { + _game._player._stepEnabled = false; + _rhotundaTurnFl = true; + _game._player.walk(Common::Point(20, 148), FACING_EAST); + } + } else if (_action.isAction(VERB_PUT, NOUN_BURGER, NOUN_LEAF_COVERED_PIT)) { + subAction(4); + if (_game._player._stepEnabled) + _vm->_dialogs->show(20812); + } else if (_action.isAction(VERB_PUT, NOUN_DEAD_FISH, NOUN_LEAF_COVERED_PIT)) { + subAction(5); + if (_game._player._stepEnabled) + _vm->_dialogs->show(20812); + } else if (_action.isAction(VERB_LOOK, NOUN_CUMULOUS_CLOUD)) + _vm->_dialogs->show(20801); + else if (_action.isAction(VERB_LOOK, NOUN_OPEN_AREA_TO_WEST)) + _vm->_dialogs->show(20802); + else if (_action.isAction(VERB_LOOK, NOUN_THORNY_BUSH)) + _vm->_dialogs->show(20803); + else if (_action.isAction(VERB_LOOK, NOUN_ROCKS)) + _vm->_dialogs->show(20804); + else if (_action.isAction(VERB_LOOK, NOUN_SMALL_CACTUS)) + _vm->_dialogs->show(20805); + else if (_action.isAction(VERB_TAKE, NOUN_SMALL_CACTUS)) + _vm->_dialogs->show(20806); + else if (_action.isAction(VERB_LOOK, NOUN_GRASSLAND_TO_EAST)) + _vm->_dialogs->show(20807); + else if (_action.isAction(VERB_LOOK, NOUN_DEEP_PIT)) + _vm->_dialogs->show(20808); + else if (_action.isAction(VERB_LOOK, NOUN_PILE_OF_LEAVES)) + _vm->_dialogs->show(20809); + else if (_action.isAction(VERB_LOOK, NOUN_LEAF_COVERED_PIT)) { + if (_game._difficulty == DIFFICULTY_EASY) + _vm->_dialogs->show(20810); + else + _vm->_dialogs->show(20811); + } else if (_action.isAction(VERB_LOOK, NOUN_TREE) || _action.isAction(VERB_LOOK, NOUN_TREES)) + _vm->_dialogs->show(20813); + else if (_action.isAction(VERB_TAKE, NOUN_LEAF_COVERED_PIT)) + _vm->_dialogs->show(20814); + else if (_action.isAction(VERB_LOOK, NOUN_HUGE_LEGS)) + _vm->_dialogs->show(20815); + else if (_action.isAction(VERB_TAKE, NOUN_HUGE_LEGS) || _action.isAction(VERB_PULL, NOUN_HUGE_LEGS)) + _vm->_dialogs->show(20816); + else if (_action._savedFields._lookFlag && (_globals[kRhotundaStatus] == 1)) + _vm->_dialogs->show(20819); + else if (_action._savedFields._lookFlag && (_globals[kLeavesStatus] == 2)) + _vm->_dialogs->show(20818); + else if (_action._savedFields._lookFlag) + _vm->_dialogs->show(20817); + else + return; + + _action._inProgress = false; +} + +/*****************************************************************************/ + +Scene209::Scene209(MADSEngine *vm) : Scene2xx(vm) { + _dodgeFl = false; + _forceDodgeFl = false; + _pitchFl = false; + _fallFl = false; + _forceFallFl = false; + _playingAnimFl = false; + _shouldFallFl = false; + _shouldDodgeFl = false; + _monkeyPosition = 0; + _counter = 0; + _pauseMode = 0; + _binocularsDroppedFl = false; + _startShootingInTimerFl = false; + _dialogAbortVal = 0; + _playingDialogFl = false; + _shootMissedLastFl = false; + _removeMonkeyFl = false; + _shootReadyFl = false; + _pauseCounterThreshold = 0; + _pauseCounter = 0; +} + +void Scene209::synchronize(Common::Serializer &s) { + Scene2xx::synchronize(s); + + s.syncAsByte(_dodgeFl); + s.syncAsByte(_forceDodgeFl); + s.syncAsByte(_shouldDodgeFl); + s.syncAsByte(_pitchFl); + s.syncAsByte(_fallFl); + s.syncAsByte(_forceFallFl); + s.syncAsByte(_shouldFallFl); + s.syncAsByte(_playingAnimFl); + s.syncAsByte(_playingDialogFl); + + s.syncAsSint32LE(_pauseMode); + s.syncAsSint32LE(_pauseCounterThreshold); + s.syncAsSint32LE(_pauseCounter); + + s.syncAsByte(_removeMonkeyFl); + + s.syncAsSint32LE(_monkeyPosition); + + s.syncAsByte(_shootReadyFl); + s.syncAsByte(_startShootingInTimerFl); + s.syncAsByte(_shootMissedLastFl); + s.syncAsByte(_binocularsDroppedFl); + + s.syncAsSint32LE(_dialogAbortVal); + s.syncAsSint32LE(_counter); +} + +void Scene209::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_PLANT_STALK); +} + +void Scene209::handlePause() { + switch (_game._trigger) { + case 124: + if (++_pauseCounter <= _pauseCounterThreshold) + _scene->_sequences.addTimer(60, 124); + else + _pauseMode = 0; + break; + } +} + +void Scene209::initPauseCounterThreshold() { + switch (_game._trigger) { + case 226: + _scene->_sequences.addTimer(1, 124); + _pauseCounterThreshold = _vm->getRandomNumber(7,12); + _pauseMode = 2; + _pauseCounter = 0; + break; + } +} + +void Scene209::handlePeek() { + switch (_game._trigger) { + case 133: + _vm->_sound->command(18); + _globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 51, 52); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 134); + break; + + case 134: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 6); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addTimer(60, 135); + } + break; + + case 135: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 7); + _scene->_sequences.addTimer(10, 136); + break; + + case 136: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 6); + _scene->_sequences.addTimer(50, 137); + break; + + case 137: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 51, 52); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 138); + break; + + case 138: + _pauseMode = 1; + _scene->_hotspots.activate(227, false); + _playingAnimFl = false; + break; + } +} + +void Scene209::handleVerticalMove() { + switch (_game._trigger) { + case 140: + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 8, 8, 0, 1); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 141); + break; + + case 141: { + _vm->_sound->command(18); + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 5); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addTimer(60, 142); + } + break; + + case 142: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 143); + break; + + case 143: + _pauseMode = 1; + _playingAnimFl = false; + _scene->_hotspots.activate(227, false); + break; + } +} + +void Scene209::handleLookStay() { + switch (_game._trigger) { + case 145: + _vm->_sound->command(18); + _monkeyPosition = 2; + _globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 51, 52); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 146); + break; + + case 146: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 6); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addTimer(15, 147); + } + break; + + case 147: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 7); + _scene->_sequences.addTimer(8, 148); + break; + + case 148: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 6); + + if (!_dodgeFl) { + _scene->_sequences.addTimer(90, 149); + } else { + _scene->_sequences.addTimer(1, 149); + _shouldDodgeFl = true; + } + break; + + case 149: + _playingAnimFl = false; + break; + } +} + +void Scene209::handleLookRight() { + switch (_game._trigger) { + case 151: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 8, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 8, 14); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 152); + break; + + case 152: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 6); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addTimer(60, 153); + } + break; + + case 153: + _playingAnimFl = false; + if (_dodgeFl) + _shouldDodgeFl = true; + break; + } +} + +void Scene209::handleBlink() { + switch (_game._trigger) { + case 155: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 6); + _scene->_sequences.addTimer(50, 156); + break; + + case 156: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 7); + _scene->_sequences.addTimer(10, 157); + break; + + case 157: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 6); + _scene->_sequences.addTimer(50, 158); + break; + + case 158: + _playingAnimFl = false; + if (_dodgeFl) + _shouldDodgeFl = true; + break; + } +} + +void Scene209::handleGetBinoculars() { + switch (_game._trigger) { + case 161: + _vm->_sound->command(18); + _monkeyPosition = 3; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 8, 24); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 20, 165); + if (!_fallFl && !_dodgeFl) { + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 162); + } else { + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 163); + } + break; + + case 162: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 8, 6, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 23, 25); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 163); + } + break; + + case 163: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 8, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 23, 24); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addTimer(8, 164); + } + break; + + case 164: + _playingAnimFl = false; + if (_fallFl) + _shouldFallFl = true; + break; + + case 165: + _vm->_sound->command(18); + break; + } +} + +void Scene209::handleBinocularBlink() { + switch (_game._trigger) { + case 167: { + int oldIdx = _globals._sequenceIndexes[3]; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 8, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 23, 25); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 168); + } + break; + + case 168: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 8, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 23, 24); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addTimer(30, 169); + } + break; + + case 169: + _playingAnimFl = false; + if (_fallFl) + _shouldFallFl = true; + break; + } +} + +void Scene209::handleBinocularScan() { + switch (_game._trigger) { + case 171: { + int oldIdx = _globals._sequenceIndexes[3]; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 43, 45); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 172); + } + break; + + case 172: { + int oldIdx = _globals._sequenceIndexes[3]; + int randAction = _vm->getRandomNumber(1,2); + switch (randAction) { + case 1: + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0); + break; + case 2: + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 4, 0, 0); + break; + } + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 23, 25); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 173); + } + break; + + case 173: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 26, 30); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 174); + } + break; + + case 174: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 23, 24); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addTimer(60, 175); + } + break; + + case 175: + _playingAnimFl = false; + if (_fallFl) + _shouldFallFl = true; + break; + } +} + +void Scene209::handleJumpInTree() { + switch (_game._trigger) { + case 178: { + int oldIdx = 0; + _monkeyPosition = 1; + if (_removeMonkeyFl) + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + else + oldIdx = _globals._sequenceIndexes[3]; + + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 46, 49); + if (!_removeMonkeyFl) + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 179); + } + break; + + case 179: { + _vm->_sound->command(18); + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 53, 61); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 180); + } + break; + + case 180: + _removeMonkeyFl = true; + _pauseMode = 1; + _playingAnimFl = false; + _scene->_hotspots.activate(227, false); + break; + } +} + +void Scene209::handleTongue() { + switch (_game._trigger) { + case 182: { + int oldIdx = _globals._sequenceIndexes[3]; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 26, 30); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 183); + } + break; + + case 183: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 31, 33); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 184); + } + break; + + case 184: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 36, 37); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 185); + } + break; + + case 185: { + _vm->_sound->command(18); + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 6, 20, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 38, 39); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 186); + } + break; + + case 186: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 40, 41); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 178); + _removeMonkeyFl = false; + } + break; + } +} + +void Scene209::handleStandFromPeek() { + switch (_game._trigger) { + case 189: + _monkeyPosition = 4; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 50); + _scene->_sequences.addTimer(8, 190); + break; + + case 190: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 6); + _scene->_sequences.addTimer(8, 191); + break; + + case 191: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 1, 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 192); + break; + + case 192: { + _vm->_sound->command(18); + int oldIdx = _globals._sequenceIndexes[6]; + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], oldIdx); + _scene->_sequences.addTimer(8, 193); + } + break; + + case 193: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 22); + _scene->_sequences.addTimer(5, 194); + break; + + case 194: + _playingAnimFl = false; + _counter = 0; + break; + } +} + +void Scene209::handleStandBlink() { + switch (_game._trigger) { + case 246: + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 22); + _scene->_sequences.addTimer(10, 247); + break; + + case 247: + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 23); + _scene->_sequences.addTimer(8, 248); + break; + + case 248: + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 22); + _scene->_sequences.addTimer(10, 249); + break; + + case 249: + _playingAnimFl = false; + break; + } +} + +void Scene209::handleJumpAndHide() { + switch (_game._trigger) { + case 196: + _vm->_sound->command(18); + _monkeyPosition = 1; + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 16); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 197); + break; + + case 197: + _pauseMode = 1; + _scene->_hotspots.activate(227, false); + _playingAnimFl = false; + break; + } +} + +void Scene209::handleMonkeyEating() { + switch (_game._trigger) { + case 199: + _vm->_sound->command(18); + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 1, 14); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 200); + break; + + case 200: { + int oldIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 10, 10, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 15, 16); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 201); + } + break; + + case 201: { + int oldIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 12); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx); + _scene->_sequences.addTimer(20, 202); + } + break; + + case 202: + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 19); + _scene->_sequences.addTimer(20, 203); + break; + + case 203: + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 17); + _scene->_sequences.addTimer(20, 204); + break; + + case 204: + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 10, 8, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 18, 19); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 205); + break; + + case 205: { + int oldIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 10, 8, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 20, 21); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 206); + } + break; + + case 206: { + int oldIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 22, 25); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx); + if (!_dodgeFl && !_fallFl) + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 207); + else + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 209); + } + break; + + case 207: { + _vm->_sound->command(18); + int msgIndex = _scene->_kernelMessages.add(Common::Point(180, 25), 0xFDFC, 0, 0, 90, _game.getQuote(130)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + + int oldIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 15, 4, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 26, 27); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 208); + } + break; + + case 208: { + _scene->_kernelMessages.add(Common::Point(180, 39), 0xFDFC, 0, 0, 90, _game.getQuote(131)); + int oldIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 10, 4, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 28, 29); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 209); + } + break; + + case 209: { + int oldIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 22); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx); + _scene->_sequences.addTimer(1, 210); + } + break; + + case 210: + _playingAnimFl = false; + break; + } +} + +void Scene209::handleMonkeyFall() { + switch (_game._trigger) { + case 219: { + _vm->_sound->command(25); + _scene->_sprites.remove(_globals._spriteIndexes[7]); + _scene->_sprites.remove(_globals._spriteIndexes[6]); + _scene->_sprites.remove(_globals._spriteIndexes[5]); + _scene->_sprites.remove(_globals._spriteIndexes[4]); + + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('m', 4)); + _scene->_kernelMessages.add(Common::Point(180, 26), 0xFDFC, 0, 0, 90, _game.getQuote(151)); + _scene->_sequences.addTimer(40, 100); + _scene->_hotspots.activate(227, false); + int oldIdx = _globals._sequenceIndexes[3]; + _monkeyPosition = 1; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], 1, 35); + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 6); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 220); + } + break; + + case 220: { + _vm->_sound->command(18); + _scene->_kernelMessages.add(Common::Point(182, 109), 0xFDFC, 0, 0, 90, _game.getQuote(159)); + _scene->_hotspots.activate(227, false); + int oldIdx = _globals._sequenceIndexes[3]; + _monkeyPosition = 1; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], 36, 42); + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 6); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 221); + } + break; + + case 221: { + _game._objects.setRoom(OBJ_BINOCULARS, 209); + _binocularsDroppedFl = true; + int oldIdx = _globals._sequenceIndexes[8]; + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 8, 1, 0, 0); + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[9], oldIdx); + _scene->_sequences.setPosition(_globals._sequenceIndexes[9], Common::Point(201, 131)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[8], oldIdx); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], 43, 72); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 222); + int idx = _scene->_dynamicHotspots.add(39, 13, _globals._sequenceIndexes[9], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(200, 133), FACING_NORTH); + } + break; + + case 222: { + _scene->_kernelMessages.add(Common::Point(182, 109), 0xFDFC, 0, 0, 70, _game.getQuote(160)); + int oldIdx = _globals._sequenceIndexes[8]; + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], 73, 78); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[8], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 223); + } + break; + + case 223: + _scene->loadAnimation(Resources::formatName(209, 'e', -1, EXT_AA, ""), 224); + _vm->_sound->command(38); + break; + + case 224: + _playingAnimFl = false; + _fallFl = false; + _counter = 0; + _pauseMode = 0; + _vm->_dialogs->show(20910); + _game._player._stepEnabled = true; + break; + } +} + +void Scene209::handleMonkey1() { + switch (_game._trigger) { + case 212: + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 9, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 1, 13); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 213); + break; + + case 213: { + int oldIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[7], 1, 22); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[7], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 214); + } + break; + + case 214: { + int oldIdx = _globals._sequenceIndexes[7]; + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[7], 23, 26); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[7], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 215); + int msgIndex = _scene->_kernelMessages.add(Common::Point(170, 21), 0xFDFC, 0, 0, 90, _game.getQuote(156)); + _scene->_kernelMessages.setQuoted(msgIndex, 3, true); + } + break; + + case 215: { + _vm->_sound->command(18); + _scene->loadAnimation(Resources::formatName(209, 'a', -1, EXT_AA, ""), 251); + int oldIdx = _globals._sequenceIndexes[7]; + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[7], 27, 35); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[7], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 216); + } + break; + + case 216: { + int oldIdx = _globals._sequenceIndexes[7]; + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 22); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx); + _scene->_sequences.addTimer(25, 217); + } + break; + + case 217: + _pitchFl = false; + _counter = 0; + _pauseMode = 0; + _scene->_sequences.addTimer(1, 196); + break; + } +} + +void Scene209::handleMonkey2() { + switch (_game._trigger) { + case 251: + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 60, _game.getQuote(137)); + _vm->_sound->command(22); + _globals._sequenceIndexes[12] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[12], false, 11, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[12], Common::Point(111, 133)); + _scene->_sequences.setScale(_globals._sequenceIndexes[12], 79); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[12], 1, 6); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 252); + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _game._player._visible = false; + break; + + case 252: { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(132)); + int oldIdx = _globals._sequenceIndexes[12]; + _globals._sequenceIndexes[12] = _scene->_sequences.startCycle(_globals._spriteIndexes[12], false, 7); + _scene->_sequences.setPosition(_globals._sequenceIndexes[12], Common::Point(111, 133)); + _scene->_sequences.setScale(_globals._sequenceIndexes[12], 79); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[12], oldIdx); + _scene->_sequences.addTimer(120, 253); + } + break; + + case 253: + _scene->_sequences.remove(_globals._sequenceIndexes[12]); + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + } +} + +void Scene209::handleDodge() { + switch (_game._trigger) { + case 241: + _scene->_hotspots.activate(227, true); + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 7); + _scene->_sequences.addTimer(6, 242); + break; + + case 242: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 5); + _scene->_sequences.addTimer(25, 243); + _vm->_sound->command(24); + break; + + case 243: + _vm->_sound->command(18); + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 6); + _playingAnimFl = false; + _pauseMode = 0; + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(180, 21), 0xFDFC, 0, 0, 90, _game.getQuote(155)); + if (!_shootMissedLastFl) { + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(135)); + _shootMissedLastFl = true; + } else { + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(136)); + } + break; + } +} + +void Scene209::enter() { + _globals._spriteIndexes[12] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('e', -1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('a', 0)); + _globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('b', 1)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('m', 0)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('m', 1)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('m', 3)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('m', 6)); + _globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('m', 8)); + + _game.loadQuoteSet(0x82, 0x83, 0x84, 0x9C, 0x97, 0x95, 0x99, 0x9E, 0x98, 0x9B, 0xA0, 0x96, 0x9F, + 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x91, 0x92, 0x93, 0x94, 0x89, 0x85, 0x8A, 0x86, 0x87, 0x88, 0); + + _vm->_palette->setEntry(252, 63, 44, 30); + _vm->_palette->setEntry(253, 63, 20, 22); + + if (_game._objects.isInRoom(OBJ_PLANT_STALK)) { + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + int idx = _scene->_dynamicHotspots.add(271, 13, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(263, 129), FACING_SOUTH); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 13); + } + + if (_scene->_priorSceneId == 208) { + _game._player._playerPos = Common::Point(11, 121); + _game._player._facing = FACING_EAST; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(28, 121); + _game._player._facing = FACING_SOUTH; + } + + if (_game._objects.isInRoom(OBJ_BINOCULARS)) { + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[9], Common::Point(201, 131)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + int idx = _scene->_dynamicHotspots.add(39, 13, _globals._sequenceIndexes[9], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(200, 133), FACING_NORTH); + } + + if (_scene->_roomChanged) { + _game._objects.addToInventory(OBJ_POISON_DARTS); + _game._objects.addToInventory(OBJ_BLOWGUN); + _globals[kMonkeyStatus] = MONKEY_HAS_BINOCULARS; + } + + _pitchFl = false; + _fallFl = false; + _dodgeFl = false; + _playingAnimFl = false; + _monkeyPosition = 1; + _counter = 0; + _pauseMode = 0; + _forceFallFl = false; + _shouldFallFl = false; + _forceDodgeFl = false; + _binocularsDroppedFl = false; + _shouldDodgeFl = false; + _startShootingInTimerFl = false; + _dialogAbortVal = 5; + _playingDialogFl = false; + _shootMissedLastFl = false; + _removeMonkeyFl = true; + _shootReadyFl = false; + + _scene->_hotspots.activate(227, false); + + sceneEntrySound(); +} + +void Scene209::step() { + if (!_playingAnimFl && !_pitchFl && !_fallFl && !_dodgeFl && (_pauseMode == 0) && (_globals[kMonkeyStatus] == MONKEY_HAS_BINOCULARS)) { + int randAction = _vm->getRandomNumber(1,50); + switch (randAction) { + case 1: + if ((_monkeyPosition == 1) && (_counter < 2)) { + _scene->_sequences.addTimer(1, 133); + _playingAnimFl = true; + _scene->_hotspots.activate(227, true); + ++_counter; + } + break; + + case 2: + if ((_monkeyPosition == 1) && (_counter < 2)) { + _scene->_sequences.addTimer(1, 140); + _scene->_hotspots.activate(227, true); + _playingAnimFl = true; + ++_counter; + } + break; + + case 3: + if (_monkeyPosition == 1) { + _scene->_sequences.addTimer(1, 145); + _scene->_hotspots.activate(227, true); + _playingAnimFl = true; + _counter = 0; + } + break; + + case 4: + if ((_monkeyPosition == 2) && (_counter < 2)) { + _scene->_sequences.addTimer(1, 151); + _scene->_hotspots.activate(227, true); + ++_counter; + _playingAnimFl = true; + } + break; + + case 5: + if (_monkeyPosition == 2) { + _scene->_sequences.addTimer(1, 161); + _scene->_hotspots.activate(227, true); + _counter = 0; + _playingAnimFl = true; + } + break; + + case 6: + if (_monkeyPosition == 2) { + _scene->_sequences.addTimer(1, 189); + _scene->_hotspots.activate(227, true); + _counter = 0; + _playingAnimFl = true; + } + break; + case 7: + if (_monkeyPosition == 3) { + _scene->_hotspots.activate(227, true); + _scene->_sequences.addTimer(1, 167); + _playingAnimFl = true; + } + break; + + case 8: + if (_monkeyPosition == 3) { + _scene->_sequences.addTimer(1, 178); + _playingAnimFl = true; + _scene->_hotspots.activate(227, true); + _counter = 0; + } + break; + + case 9: + if ((_monkeyPosition == 3) && (_game._player._playerPos.x<120)) { + _scene->_sequences.addTimer(1, 182); + _scene->_hotspots.activate(227, true); + _counter = 0; + _playingAnimFl = true; + } + break; + + case 10: + if (_monkeyPosition == 4) { + _scene->_sequences.addTimer(1, 196); + _scene->_hotspots.activate(227, true); + _playingAnimFl = true; + _counter = 0; + } + break; + + case 11: + if ((_monkeyPosition == 4) && (_counter < 3)) { + _scene->_sequences.addTimer(1, 199); + _scene->_hotspots.activate(227, true); + ++_counter; + _playingAnimFl = true; + } + break; + + case 30: + if (_monkeyPosition == 4) { + _scene->_sequences.addTimer(1, 246); + _scene->_hotspots.activate(227, true); + _counter = 0; + _playingAnimFl = true; + } + break; + + default: + if ((randAction >= 12) && (randAction <= 20) && (_monkeyPosition == 2) && (_counter < 5)) { + _scene->_sequences.addTimer(1, 155); + ++_counter; + _playingAnimFl = true; + } + + if ((randAction >= 21) && (randAction <= 29) && (_monkeyPosition == 3) && (_counter < 3)) { + _scene->_sequences.addTimer(1, 171); + _playingAnimFl = true; + ++_counter; + } + break; + } + } + + if (!_dodgeFl && !_pitchFl && !_fallFl && (_pauseMode == 1)) + _scene->_sequences.addTimer(1, 226); + + if (!_dodgeFl && !_pitchFl && !_fallFl && (_pauseMode == 2)) + handlePause(); + + if (!_dodgeFl && !_pitchFl && !_fallFl && (_pauseMode == 1)) + initPauseCounterThreshold(); + + handlePeek(); + handleVerticalMove(); + handleLookStay(); + handleLookRight(); + handleBlink(); + handleGetBinoculars(); + handleStandFromPeek(); + handleDodge(); + handleBinocularBlink(); + handleBinocularScan(); + handleJumpInTree(); + handleTongue(); + handleMonkeyFall(); + handleJumpAndHide(); + handleMonkeyEating(); + handleMonkey1(); + handleStandBlink(); + handleMonkey2(); + + if ((_monkeyPosition == 1) && !_playingAnimFl && _fallFl) { + _scene->_sequences.addTimer(1, 145); + _playingAnimFl = true; + } + + if ((_monkeyPosition == 2) && !_playingAnimFl && _fallFl) { + _scene->_sequences.addTimer(1, 161); + _playingAnimFl = true; + } + + if ((_monkeyPosition == 4) && !_playingAnimFl && _fallFl) { + _scene->_sequences.addTimer(1, 196); + _playingAnimFl = true; + } + + if ((_monkeyPosition == 3) && !_playingAnimFl && _fallFl && _forceFallFl) { + _scene->_sequences.addTimer(1, 219); + _playingAnimFl = true; + } + + if ((_monkeyPosition == 1) && !_playingAnimFl && _pitchFl) { + _scene->_sequences.addTimer(1, 145); + _playingAnimFl = true; + } + + if ((_monkeyPosition == 2) && !_playingAnimFl && _pitchFl) { + _scene->_sequences.addTimer(1, 189); + _playingAnimFl = true; + } + + if ((_monkeyPosition == 4) && !_playingAnimFl && _pitchFl) { + _scene->_sequences.addTimer(1, 212); + _playingAnimFl = true; + } + + if ((_monkeyPosition == 3) && !_playingAnimFl && _pitchFl) { + _scene->_sequences.addTimer(1, 178); + _playingAnimFl = true; + } + + if ((_monkeyPosition == 1) && !_playingAnimFl && _dodgeFl) { + _scene->_sequences.addTimer(1, 145); + _playingAnimFl = true; + } + + if ((_monkeyPosition == 4) && !_playingAnimFl && _dodgeFl) { + _scene->_sequences.addTimer(1, 196); + _playingAnimFl = true; + } + + if ((_monkeyPosition == 3) && !_playingAnimFl && _dodgeFl) { + _scene->_sequences.addTimer(1, 178); + _playingAnimFl = true; + } + + if ((_monkeyPosition == 2) && !_playingAnimFl && _dodgeFl && _forceDodgeFl) { + _scene->_sequences.addTimer(1, 241); + _playingAnimFl = true; + } + + if (_dodgeFl || _fallFl) { /* if want to dodge or fall */ + if (!_playingAnimFl && (_monkeyPosition == 2)) + _shouldDodgeFl = true; + + if (!_playingAnimFl && (_monkeyPosition == 3)) + _shouldFallFl = true; + + switch (_game._trigger) { + case 228: + _game._player._visible = false; + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 7); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(116, 131)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 229); + break; + + case 229: { + int oldIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 7); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(116, 131)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], oldIdx); + _scene->_sequences.addTimer(35, 230); + } + break; + + case 230: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 7); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(116, 131)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 231); + break; + + case 231: { + int oldIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 8, 10); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(116, 131)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 232); + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], -1); + _game._player._visible = false; + } + break; + + case 232: { + int oldIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 10); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(116, 131)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], oldIdx); + _scene->_sequences.addTimer(2, 233); + _scene->_kernelMessages.reset(); + if (_dodgeFl && (_monkeyPosition != 1) && (_monkeyPosition != 2)) + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 34463, _game.getQuote(138)); + if (_fallFl && (_monkeyPosition != 3)) + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 34463, _game.getQuote(138)); + } + break; + + case 233: + _shootReadyFl = true; + break; + + case 234: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _scene->_kernelMessages.reset(); + if (_action.isAction(VERB_HOSE_DOWN, NOUN_BLOWGUN, NOUN_MONKEY)) { + _globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 7, 16, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 11, 12); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(116, 131)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 12, 239); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 235); + } else if (_action.isAction(VERB_SHOOT, NOUN_BLOWGUN, NOUN_MONKEY)) { + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 11, 12); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(116, 131)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 235); + _vm->_sound->command(23); + } + break; + + case 235: { + int oldIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 13); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(116, 131)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], oldIdx); + _scene->_sequences.addTimer(12, 236); + _forceFallFl = true; + _forceDodgeFl = true; + } + break; + + case 236: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 14, 16); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(116, 131)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 237); + break; + + case 237: + _game._player._visible = true; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _scene->_sequences.addTimer(1, 238); + break; + + case 238: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + if (_dodgeFl) + _game._player._stepEnabled = true; + + _startShootingInTimerFl = false; + + if (_fallFl) { + _globals[kMonkeyStatus] = MONKEY_IS_GONE; + _game._objects.setRoom(OBJ_POISON_DARTS, NOWHERE); + } + _dodgeFl = false; + _fallFl = false; + _forceFallFl = false; + _forceDodgeFl = false; + _shouldFallFl = false; + _shouldDodgeFl = false; + break; + + case 239: + _vm->_sound->command(23); + break; + } + } + + if (_game._trigger == 100) + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(134)); + + if (_shootReadyFl && (_shouldFallFl || _shouldDodgeFl)) { + _scene->_sequences.addTimer(4, 234); + _shootReadyFl = false; + } +} + +void Scene209::preActions() { + if (_action.isAction(VERB_WALK_TOWARDS, NOUN_FIELD_TO_WEST)) + _game._player._walkOffScreenSceneId = 208; + + if (_globals[kMonkeyStatus] == MONKEY_HAS_BINOCULARS) { + if ((_action.isAction(VERB_SHOOT) || _action.isAction(VERB_HOSE_DOWN)) && _action.isTarget(NOUN_MONKEY) + && _action.isObject(NOUN_BLOWGUN) && _game._objects.isInInventory(OBJ_BLOWGUN) && _game._objects.isInInventory(OBJ_POISON_DARTS)) { + _game._player._prepareWalkPos = Common::Point(111, 129); + _game._player._prepareWalkFacing = FACING_NORTHEAST; + _game._player._needToWalk = true; + _game._player._readyToWalk = true; + } + + if (_action.isAction(VERB_LOOK, NOUN_MONKEY) || _action.isAction(VERB_TALKTO, NOUN_MONKEY)) { + _game._player._prepareWalkPos = Common::Point(111, 129); + _game._player._prepareWalkFacing = FACING_NORTHEAST; + _game._player._needToWalk = true; + _game._player._readyToWalk = true; + } + } +} + +void Scene209::actions() { + if (_action._lookFlag) { + _vm->_dialogs->show(20912); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_WALK_TOWARDS, NOUN_ROCKY_AREA_TO_NORTH)) { + _scene->_nextSceneId = 203; + _action._inProgress = false; + return; + } + + if ((_action.isAction(VERB_TALKTO, NOUN_MONKEY)) && !_pitchFl && !_playingDialogFl) { + _scene->_sequences.addTimer(1, _dialogAbortVal); + _playingDialogFl = true; + _game._player._stepEnabled = false; + _action._inProgress = false; + return; + } + + switch (_game._trigger) { + case 130: + _game._player._stepEnabled = true; + _playingDialogFl = false; + _action._inProgress = false; + return; + + case 5: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 6, 180, _game.getQuote(139)); + _action._inProgress = false; + return; + + case 6: + _scene->_kernelMessages.add(Common::Point(180, 21), 0xFDFC, 0, 0, 60, _game.getQuote(151)); + _scene->_sequences.addTimer(60, 130); + _dialogAbortVal = 7; + _action._inProgress = false; + return; + + case 7: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 8, 180, _game.getQuote(140)); + _action._inProgress = false; + return; + + case 8: + _scene->_kernelMessages.add(Common::Point(180, 21), 0xFDFC, 0, 0, 60, _game.getQuote(149)); + _scene->_sequences.addTimer(60, 130); + _dialogAbortVal = 9; + _action._inProgress = false; + return; + + case 9: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 180, _game.getQuote(141)); + _scene->_sequences.addTimer(200, 10); + _action._inProgress = false; + return; + + case 10: + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 11, 180, _game.getQuote(142)); + _action._inProgress = false; + return; + + case 11: + _scene->_kernelMessages.add(Common::Point(180, 21), 0xFDFC, 0, 0, 60, _game.getQuote(152)); + _scene->_sequences.addTimer(60, 130); + _dialogAbortVal = 12; + _action._inProgress = false; + return; + + case 12: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 130, _game.getQuote(143)); + _scene->_sequences.addTimer(150, 13); + _action._inProgress = false; + return; + + case 13: + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 14, 180, _game.getQuote(145)); + _action._inProgress = false; + return; + + case 14: + _scene->_kernelMessages.add(Common::Point(180, 21), 0xFDFC, 0, 0, 60, _game.getQuote(151)); + _scene->_sequences.addTimer(60, 130); + _dialogAbortVal = 15; + _action._inProgress = false; + return; + + case 15: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 16, 180, _game.getQuote(146)); + _action._inProgress = false; + return; + + case 16: + _scene->_kernelMessages.add(Common::Point(180, 21), 0xFDFC, 0, 17, 60, _game.getQuote(154)); + _action._inProgress = false; + return; + + case 17: + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 130, 60, _game.getQuote(147)); + _dialogAbortVal = 18; + _action._inProgress = false; + return; + + case 18: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 180, _game.getQuote(148)); + _pitchFl = true; + _playingDialogFl = false; + _dialogAbortVal = 5; + _action._inProgress = false; + return; + } + + if (_globals[kMonkeyStatus] == MONKEY_HAS_BINOCULARS) { + if ((_action.isAction(VERB_SHOOT) || _action.isAction(VERB_HOSE_DOWN)) && _action.isTarget(NOUN_MONKEY) + && _action.isObject(NOUN_BLOWGUN) && _game._objects.isInInventory(OBJ_BLOWGUN) && _game._objects.isInInventory(OBJ_POISON_DARTS)) { + if (_action.isAction(VERB_SHOOT, NOUN_BLOWGUN, NOUN_MONKEY) && !_startShootingInTimerFl) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 231); + _startShootingInTimerFl = true; + _game._player._stepEnabled = false; + _dodgeFl = true; + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_HOSE_DOWN, NOUN_BLOWGUN, NOUN_MONKEY) && !_startShootingInTimerFl) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 228); + _game._player._stepEnabled = false; + _fallFl = true; + _startShootingInTimerFl = true; + _action._inProgress = false; + return; + } + } + + if (_action.isAction(VERB_LOOK, NOUN_MONKEY)) { + _pitchFl = true; + _game._player._stepEnabled = false; + _vm->_dialogs->show(20914); + _action._inProgress = false; + return; + } + } + + if (_action.isAction(VERB_TAKE, NOUN_PLANT_STALK) && (_game._trigger || _game._objects.isInRoom(OBJ_PLANT_STALK))) { + switch (_game._trigger) { + case 0: + _globals._spriteIndexes[11] = _scene->_sprites.addSprites("*RXMBD_2"); + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[11] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[11], false, 3, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[11]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_SPRITE, 4, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _game._objects.addToInventory(OBJ_PLANT_STALK); + break; + + case 2: + _game._player._visible = true; + _game._player._stepEnabled = true; + _scene->_sequences.addTimer(4, 3); + _vm->_dialogs->showItem(OBJ_PLANT_STALK, 0x328); + break; + + case 3: + _scene->_sprites.remove(_globals._spriteIndexes[11]); + break; + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_BINOCULARS) && (_game._trigger || _game._objects.isInRoom(OBJ_BINOCULARS))) { + switch (_game._trigger) { + case 0: + _globals._spriteIndexes[10] = _scene->_sprites.addSprites("*RXMBD_8"); + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[10] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[10], false, 3, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[10]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[10], SEQUENCE_TRIGGER_SPRITE, 4, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[10], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _game._objects.addToInventory(OBJ_BINOCULARS); + break; + + case 2: + _game._player._visible = true; + _game._player._stepEnabled = true; + _binocularsDroppedFl = false; + _scene->_sequences.addTimer(4, 3); + break; + + case 3: + _vm->_dialogs->showItem (OBJ_BINOCULARS, 0x51AF); + _scene->_sprites.remove(_globals._spriteIndexes[10]); + break; + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_SKY)) { + _vm->_dialogs->show(20901); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_BAMBOO_LIKE_PLANT)) { + _vm->_dialogs->show(20902); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_MOUNTAINSIDE)) { + _vm->_dialogs->show(20903); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_GRASSY_FIELD)) { + _vm->_dialogs->show(20904); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_FIELD_TO_WEST)) { + _vm->_dialogs->show(20905); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_ROCKY_AREA_TO_NORTH)) { + _vm->_dialogs->show(20906); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_PLANT_STALK) && (_action._savedFields._mainObjectSource == 4)) { + _vm->_dialogs->show(20907); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_GIVE, NOUN_TWINKIFRUIT, 0xE3) || _action.isAction(VERB_THROW, NOUN_TWINKIFRUIT, 0xE3)) { + _vm->_dialogs->show(20909); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_TREES)) { + _vm->_dialogs->show(20913); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_THROW, NOUN_MONKEY) && _game._objects.isInInventory(_game._objects.getIdFromDesc(_action._activeAction._objectNameId))) { + if (!_action.isAction(0x114)) { + _vm->_dialogs->show(20915); + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_THROW, NOUN_POISON_DARTS, 0xE3)) { + _vm->_dialogs->show(20916); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_PALM_TREE)) { + if (_globals[kMonkeyStatus] == MONKEY_HAS_BINOCULARS) { + if (_monkeyPosition == 1) + _vm->_dialogs->show(20917); + else + _vm->_dialogs->show(20918); + } else { + if (_globals[kMonkeyStatus] == MONKEY_AMBUSH_READY) + _vm->_dialogs->show(20917); + else + _vm->_dialogs->show(20919); + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_MELON_MUSH)) { + _vm->_dialogs->show(20920); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_MELON_MUSH)) { + _vm->_dialogs->show(20921); + _action._inProgress = false; + return; + } +} + +/*****************************************************************************/ + +Scene210::Scene210(MADSEngine *vm) : Scene2xx(vm) { + _curDialogNode = -1; + _nextHandsPlace = 0; + _twinkleAnimationType = 0; + _twinklesCurrentFrame = 0; + _shouldTalk = false; + _shouldFaceRex = false; + _shouldMoveHead = false; + _stopWalking = false; + _twinklesTalking = false; + _twinklesTalk2 = false; + _doorway = 0; + _subQuote2 = ""; +} + +void Scene210::synchronize(Common::Serializer &s) { + Scene2xx::synchronize(s); + + s.syncAsSint32LE(_curDialogNode); + s.syncAsSint32LE(_nextHandsPlace); + s.syncAsSint32LE(_twinkleAnimationType); + s.syncAsSint32LE(_twinklesCurrentFrame); + + s.syncAsByte(_shouldTalk); + s.syncAsByte(_shouldFaceRex); + s.syncAsByte(_shouldMoveHead); + s.syncAsByte(_stopWalking); + s.syncAsByte(_twinklesTalking); + s.syncAsByte(_twinklesTalk2); + + s.syncAsSint32LE(_doorway); + + s.syncString(_subQuote2); +} + +void Scene210::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_DOORWAY); + _scene->addActiveVocab(VERB_WALK_THROUGH); +} + +void Scene210::handleConversations() { + if (_game._trigger == 0) { + _scene->_kernelMessages.reset(); + _game._player._stepEnabled = false; + Common::String curQuote = _game.getQuote(_action._activeAction._verbId); + if (_vm->_font->getWidth(curQuote, _scene->_textSpacing) > 200) { + Common::String subQuote1; + _game.splitQuote(curQuote, subQuote1, _subQuote2); + _scene->_kernelMessages.add(Common::Point(0, -14), 0x1110, 34, 0, 240, subQuote1); + _scene->_sequences.addTimer(60, 50); + } else { + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 1, 120, curQuote); + } + } else if (_game._trigger == 50) { + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 240, _subQuote2); + _scene->_sequences.addTimer(180, 1); + } else { + if (_game._trigger == 1) + _scene->_kernelMessages.reset(); + + switch (_curDialogNode) { + case 1: + handleConversation1(); + break; + + case 2: + handleConversation2(); + break; + + case 3: + handleConversation3(); + break; + + case 5: + handleConversation5(); + break; + + case 6: + handleConversation6(); + break; + + case 7: + handleConversation7(); + break; + + case 8: + handleConversation8(); + break; + } + } +} + +void Scene210::handleConversation1() { + switch (_action._activeAction._verbId) { + case 180: + setDialogNode(2); + break; + + case 181: + setDialogNode(6); + break; + + case 182: + setDialogNode(4); + break; + + case 183: + setDialogNode(9); + break; + + case 184: + setDialogNode(0); + break; + } +} + +void Scene210::handleConversation2() { + switch (_action._activeAction._verbId) { + case 187: + setDialogNode(3); + break; + + case 188: + setDialogNode(4); + break; + + case 189: + setDialogNode(0); + break; + } +} + +void Scene210::handleConversation3() { + switch (_action._activeAction._verbId) { + case 193: + setDialogNode(6); + break; + + case 194: + setDialogNode(5); + break; + + case 195: + setDialogNode(4); + break; + + case 196: + setDialogNode(0); + break; + } +} + +void Scene210::handleConversation5() { + switch (_action._activeAction._verbId) { + case 204: + setDialogNode(6); + break; + + case 205: + case 206: + setDialogNode(4); + break; + + case 207: + setDialogNode(0); + break; + } +} + +void Scene210::handleConversation6() { + switch (_action._activeAction._verbId) { + case 211: + setDialogNode(7); + break; + + case 212: + setDialogNode(4); + break; + + case 213: + setDialogNode(0); + break; + } +} + +void Scene210::handleConversation7() { + switch (_action._activeAction._verbId) { + case 216: + case 217: + case 219: + setDialogNode(4); + break; + + case 218: + setDialogNode(8); + break; + + case 220: + setDialogNode(0); + break; + } +} + +void Scene210::handleConversation8() { + switch (_action._activeAction._verbId) { + case 223: + case 224: + setDialogNode(4); + break; + + case 225: + case 226: + setDialogNode(9); + break; + + case 227: + setDialogNode(0); + break; + } +} + +void Scene210::setDialogNode(int node) { + switch (node) { + case 0: + _scene->_userInterface.setup(kInputBuildingSentences); + _shouldFaceRex = false; + _shouldTalk = false; + _game._player._stepEnabled = true; + _curDialogNode = 0; + break; + + case 2: + switch (_game._trigger) { + case 1: + _nextHandsPlace = 1; + _shouldTalk = true; + _game._player._stepEnabled = false; + if (_twinklesTalking) { + handleTwinklesSpeech(0xB9, -1, 0); + _scene->_sequences.addTimer(180, 2); + } else { + _scene->_sequences.addTimer(6, 1); + } + break; + + case 2: + _nextHandsPlace = 0; + handleTwinklesSpeech(186, 0, 0); + _scene->_sequences.addTimer(180, 3); + break; + + default: + _nextHandsPlace = 0; + _shouldTalk = false; + _game._player._stepEnabled = true; + newNode(2); + break; + } + break; + + case 3: + switch (_game._trigger) { + case 1: + _nextHandsPlace = 0; + _shouldTalk = true; + _game._player._stepEnabled = false; + if (_twinklesTalking) { + handleTwinklesSpeech(0xBE, -2, 0); + _scene->_sequences.addTimer(180, 2); + } else { + _scene->_sequences.addTimer(6, 1); + } + break; + case 2: + _nextHandsPlace = 2; + handleTwinklesSpeech(191, -1, 0); + _scene->_sequences.addTimer(180, 3); + break; + case 3: + _nextHandsPlace = 0; + handleTwinklesSpeech(192, 0, 0); + _scene->_sequences.addTimer(180, 4); + break; + default: + _shouldTalk = false; + _game._player._stepEnabled = true; + newNode(3); + break; + } + break; + + case 4: + if (_game._trigger == 1) { + _nextHandsPlace = 1; + _shouldTalk = true; + _game._player._stepEnabled = false; + + int quote; + if (_game._storyMode == STORYMODE_NAUGHTY) + quote = _vm->getRandomNumber(199, 201); + else + quote = _vm->getRandomNumber(197, 198); + + if (_twinklesTalking) { + handleTwinklesSpeech(quote, 0, 360); + _scene->_sequences.addTimer(120, 2); + } else { + _scene->_sequences.addTimer(6, 1); + } + } else { + _scene->_userInterface.setup(kInputBuildingSentences); + _shouldFaceRex = false; + _shouldTalk = false; + _game._player._stepEnabled = true; + } + break; + + case 5: + switch (_game._trigger) { + case 1: + _nextHandsPlace = 2; + _shouldTalk = true; + _game._player._stepEnabled = false; + if (_twinklesTalking) { + handleTwinklesSpeech(0xCA, -1, 0); + _scene->_sequences.addTimer(180, 2); + } else { + _scene->_sequences.addTimer(6, 1); + } + break; + + case 2: + _nextHandsPlace = 1; + handleTwinklesSpeech(0xCB, 0, 0); + _scene->_sequences.addTimer(180, 3); + break; + + default: + _nextHandsPlace = 2; + _shouldTalk = false; + _game._player._stepEnabled = true; + newNode(5); + break; + } + break; + + case 6: + switch (_game._trigger) { + case 1: + _nextHandsPlace = 1; + _shouldTalk = true; + _game._player._stepEnabled = false; + if (_twinklesTalking) { + handleTwinklesSpeech(0xD0, -2, 0); + _scene->_sequences.addTimer(180, 2); + } else { + _scene->_sequences.addTimer(6, 1); + } + break; + + case 2: + handleTwinklesSpeech(0xD1, -1, 0); + _scene->_sequences.addTimer(180, 3); + break; + + case 3: + _nextHandsPlace = 1; + handleTwinklesSpeech(0xD2, 0, 0); + _scene->_sequences.addTimer(180, 4); + break; + + default: + _nextHandsPlace = 0; + _shouldTalk = false; + _game._player._stepEnabled = true; + newNode(6); + break; + } + break; + + case 7: + switch (_game._trigger) { + case 1: + _nextHandsPlace = 2; + _shouldTalk = true; + _game._player._stepEnabled = false; + if (_twinklesTalking) { + handleTwinklesSpeech(0xD6, -1, 0); + _scene->_sequences.addTimer(180, 2); + } else { + _scene->_sequences.addTimer(6, 1); + } + break; + + case 2: + handleTwinklesSpeech(0xD7, 0, 0); + _scene->_sequences.addTimer(180, 3); + break; + + default: + _shouldTalk = false; + _game._player._stepEnabled = true; + newNode(7); + break; + } + break; + + case 8: + switch (_game._trigger) { + case 1: + _nextHandsPlace = 2; + _shouldTalk = true; + _game._player._stepEnabled = false; + if (_twinklesTalking) { + handleTwinklesSpeech(0xDD, -1, 0); + _scene->_sequences.addTimer(180, 2); + } else { + _scene->_sequences.addTimer(6, 1); + } + break; + + case 2: + handleTwinklesSpeech(0xDE, 0, 0); + _scene->_sequences.addTimer(180, 3); + break; + + default: + _shouldTalk = false; + _game._player._stepEnabled = true; + newNode(8); + break; + } + break; + + + case 9: + switch (_game._trigger) { + case 1: + _nextHandsPlace = 0; + _shouldTalk = true; + _game._player._stepEnabled = false; + if (_twinklesTalking) { + _scene->_userInterface.emptyConversationList(); + _scene->_userInterface.setup(kInputConversation); + handleTwinklesSpeech(0xE4, -1, 0); + _scene->_sequences.addTimer(180, 2); + } else { + _scene->_sequences.addTimer(6, 1); + } + break; + + case 2: + handleTwinklesSpeech(0xE5, 0, 0); + _scene->_sequences.addTimer(180, 3); + break; + + case 3: + _twinkleAnimationType = 2; + _globals[kCurtainOpen] = true; + _game._player._visible = false; + _vm->_palette->lock(); + _scene->_kernelMessages.reset(); + _scene->freeAnimation(); + _scene->_activeAnimation = nullptr; + _scene->resetScene(); + + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('c', -1)); + _game.loadQuoteSet(0xE6, 0xE9, 0xEA, 0xE7, 0xE8, 0); + _scene->loadAnimation(formAnimName('B', -1), 4); + break; + + case 4: { + _globals._spriteIndexes[8] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 5); + _scene->_sequences.setDepth(_globals._spriteIndexes[8], 1); + + int msgIndex = _scene->_kernelMessages.add(Common::Point(160, 20), 0x1110, 32, 5, 180, _game.getQuote(231)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + } + break; + + case 5: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(160, 40), 0xFDFC, 32, 6, 180, _game.getQuote(233)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + } + break; + + case 6: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(160, 60), 0x1110, 32, 7, 180, _game.getQuote(232)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + } + break; + + case 7: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(160, 80), 0xFDFC, 32, 8, 180, _game.getQuote(234)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + } + break; + + case 8: + _globals[kTwinklesStatus] = TWINKLES_GONE; + _scene->_nextSceneId = 216; + break; + } + break; + } +} + +void Scene210::handleTwinklesSpeech(int quoteId, int shiftX, uint32 delay) { + _scene->_kernelMessages.add(Common::Point(10, 70 + (shiftX * 14)), 0xFDFC, 0, 0, (delay == 0) ? 9999999 : delay, _game.getQuote(quoteId)); +} + +void Scene210::newNode(int node) { + _curDialogNode = node; + + switch (_curDialogNode) { + case 1: + _conv1.start(); + break; + + case 2: + _conv2.start(); + break; + + case 3: + _conv3.start(); + break; + + case 5: + _conv5.start(); + break; + + case 6: + _conv6.start(); + break; + + case 7: + _conv7.start(); + break; + + case 8: + _conv8.start(); + break; + + default: + break; + } +} + +void Scene210::restoreDialogNode(int node, int msgId, int posY) { + int curQuoteId = msgId; + int curY = 1 - posY; + for (int count = 0; count < posY; count++) { + handleTwinklesSpeech(curQuoteId, curY, 0); + curY++; + curQuoteId++; + } + + newNode(node); +} + +void Scene210::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('c', -1)); + + if (!_game._visitedScenes._sceneRevisited) + _globals[kCurtainOpen] = 0; + + if (_scene->_priorSceneId == 205) + _game._player._playerPos = Common::Point(277, 56); + else if (_scene->_priorSceneId == 215) { + _game._player._playerPos = Common::Point(168, 128); + _game._player._facing = FACING_SOUTH; + _globals[kCurtainOpen] = true; + } else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(308, 132); + + if (!_globals[kCurtainOpen]) { + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 5); + } else { + int idx = _scene->_dynamicHotspots.add(112, 395, -1, Common::Rect(163, 87, 163 + 19, 87 + 36)); + _doorway = _scene->_dynamicHotspots.setPosition(idx, Common::Point(168, 127), FACING_NORTH); + _scene->_dynamicHotspots.setCursor(_doorway, CURSOR_GO_UP); + } + + _game.loadQuoteSet(0x5A, 0x73, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB8, 0xB7, + 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, + 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, + 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0); + + _conv1.setup(0x2E, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0); + + if (!_game._visitedScenes._sceneRevisited) { + _conv1.set(0x2E, 0xB4, 0xB5, 0xB6, 0xB8, 0); + + if (_game._widepipeCtr >= 2) + _conv1.write(0xB7, true); + } + + bool sceneRevisited = _game._visitedScenes._sceneRevisited; + _conv2.setup(0x2F, 0xBC, 0xBB, 0xBD, sceneRevisited ? 0 : -1); + _conv3.setup(0x30, 0xC3, 0xC2, 0xC1, 0xC4, sceneRevisited ? 0 : -1); + _conv5.setup(0x31, 0xCD, 0xCC, 0xCE, 0xCF, sceneRevisited ? 0 : -1); + _conv6.setup(0x32, 0xD3, 0xD4, 0xD5, sceneRevisited ? 0 : -1); + _conv7.setup(0x33, 0xD8, 0xDA, 0xD9, 0xDB, 0xDC, sceneRevisited ? 0 : -1); + _conv8.setup(0x34, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, sceneRevisited ? 0 : -1); + + _twinkleAnimationType = 0; + _twinklesCurrentFrame = 0; + + if (_scene->_priorSceneId != -2) { + _shouldMoveHead = false; + _shouldFaceRex = false; + _shouldTalk = false; + _nextHandsPlace = 0; + _twinklesTalking = false; + _curDialogNode = 0; + _stopWalking = false; + _twinklesTalk2 = (_globals[kTwinklesApproached] > 0); + } + + if (_globals[kTwinklesStatus] == 0) { + _scene->loadAnimation(formAnimName('A', -1)); + _twinkleAnimationType = 1; + } else + _scene->_hotspots.activate(476, false); + + if (_curDialogNode) { + int quote = 0; + int number = 0; + + switch (_curDialogNode) { + case 1: + quote = 0xB3; + number = 1; + break; + case 2: + quote = 0xB9; + number = 2; + break; + case 3: + quote = 0xBE; + number = 3; + break; + case 5: + quote = 0xCA; + number = 2; + break; + case 6: + quote = 0xD0; + number = 3; + break; + case 7: + quote = 0xD6; + number = 2; + break; + case 8: + quote = 0xDD; + number = 2; + break; + } + + restoreDialogNode(_curDialogNode, quote, number); + _scene->_activeAnimation->setCurrentFrame(131); + } + + _vm->_palette->setEntry(252, 63, 63, 10); + _vm->_palette->setEntry(253, 45, 45, 5); + + sceneEntrySound(); +} + +void Scene210::step() { + if ((_twinkleAnimationType == 1) && _scene->_activeAnimation) { + if (_twinklesCurrentFrame != _scene->_activeAnimation->getCurrentFrame()) { + _twinklesCurrentFrame = _scene->_activeAnimation->getCurrentFrame(); + int reset_frame = -1; + int random = _vm->getRandomNumber(1, 1000); + + switch (_twinklesCurrentFrame) { + case 31: + case 58: + case 74: + case 108: + case 190: + if (_shouldFaceRex) + reset_frame = 108; + else if ((random <= 100) || _shouldMoveHead) + reset_frame = 74; + else if (random <= 300) + reset_frame = 58; + else if (random <= 500) + reset_frame = 31; + else + reset_frame = 0; + break; + + case 80: + case 90: + _twinklesTalking = false; + if (_shouldMoveHead) { + reset_frame = 90; + } else if (_twinklesCurrentFrame == 90) { + if ((random <= 400) || _shouldFaceRex) + reset_frame = 99; + else + reset_frame = 79; + } + break; + + case 98: + if (_shouldMoveHead) + reset_frame = 91; + break; + + case 99: + if ((random <= 400) && !_shouldFaceRex) + reset_frame = 79; + break; + + case 124: + case 136: + case 174: + case 143: + case 152: + if (_nextHandsPlace == 3) + reset_frame = 174; + else if (!_shouldFaceRex) + reset_frame = 174; + else if (_nextHandsPlace == 1) + reset_frame = 136; + else if (_nextHandsPlace == 2) + reset_frame = 152; + else if (_shouldTalk) + reset_frame = 124; + else + reset_frame = (random <= 200) ? 131 : 143; + break; + + case 131: + if (_shouldTalk) { + switch (_nextHandsPlace) { + case 1: + reset_frame = 136; + break; + case 2: + reset_frame = 152; + break; + default: + reset_frame = 124; + break; + } + } + break; + + case 138: + case 141: + if ((_nextHandsPlace == 0) || !_shouldFaceRex) + reset_frame = 141; + else if (_nextHandsPlace == 2) + reset_frame = 152; + else if (!_shouldTalk || (_twinklesCurrentFrame == 141)) + reset_frame = 137; + break; + + case 153: + case 169: + if ((_nextHandsPlace == 0) || !_shouldFaceRex) + reset_frame = 169; + else if (_nextHandsPlace == 1) + reset_frame = 136; + else if (_shouldTalk) + reset_frame = 153; + else + reset_frame = 162; + break; + + case 162: + if (_shouldTalk) { + switch (_nextHandsPlace) { + case 0: + reset_frame = 124; + break; + case 1: + reset_frame = 136; + break; + default: + reset_frame = 153; + break; + } + } + break; + } + + if (reset_frame >= 0) { + if (reset_frame != _scene->_activeAnimation->getCurrentFrame()) { + _scene->_activeAnimation->setCurrentFrame(reset_frame); + _twinklesCurrentFrame = reset_frame; + } + + if ((reset_frame == 90) || (reset_frame == 91) || (reset_frame == 124) || (reset_frame == 153) + || ((reset_frame == 137) && _shouldTalk)) { + _twinklesTalking = true; + } else { + _twinklesTalking = false; + } + } + } + } + + if ((_twinkleAnimationType == 2) && _scene->_activeAnimation) { + if (_twinklesCurrentFrame != _scene->_activeAnimation->getCurrentFrame()) { + _twinklesCurrentFrame = _scene->_activeAnimation->getCurrentFrame(); + int reset_frame = -1; + + if (_twinklesCurrentFrame == 53) { + _scene->_kernelMessages.add(Common::Point(151, 61), 0xFDFC, 32, 70, 180, _game.getQuote(230)); + _shouldTalk = true; + } else if ((_twinklesCurrentFrame == 75) && _shouldTalk) + reset_frame = 60; + + if ((reset_frame >= 0) && (reset_frame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(reset_frame); + _twinklesCurrentFrame = reset_frame; + } + } + + if (_game._trigger == 70) + _shouldTalk = false; + } + + if ((_twinkleAnimationType == 1) && (_scene->_rails.getNext() > 0)) { + _game._player.walk(Common::Point(214, 150), FACING_NORTHWEST); + _scene->_rails.resetNext(); + _stopWalking = true; + } +} + +void Scene210::preActions() { + _stopWalking = false; + + if (_action.isAction(VERB_WALK_DOWN, NOUN_PATH_TO_EAST)) + _game._player._walkOffScreenSceneId = 211; +} + +void Scene210::actions() { + if (_action.isAction(VERB_LOOK, NOUN_BINOCULARS, 0x1C0)) { + _vm->_dialogs->show(21017); + } else if (_game._screenObjects._inputMode == 1) { + handleConversations(); + } else if (_action.isAction(VERB_TALKTO, NOUN_NATIVE_WOMAN) || + ((_game._player._playerPos == Common::Point(214, 150)) && (_game._player._facing == FACING_NORTHWEST) && (_twinkleAnimationType == 1) && _stopWalking)) { + switch (_game._trigger) { + case 0: { + _game._player._stepEnabled = false; + int quote; + if (_globals[kTwinklesApproached] == 0) + quote = 90; + else if (_globals[kTwinklesApproached] == 1) + quote = 115; + else + quote = 171; + + _shouldFaceRex = true; + _nextHandsPlace = 0; + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.addQuote(quote, 1, 120); + } + break; + + case 1: + _shouldTalk = true; + if (!_twinklesTalking) { + _scene->_sequences.addTimer(6, 1); + } else { + if (_globals[kTwinklesApproached] == 0) { + handleTwinklesSpeech(0xAF, -1, 0); + handleTwinklesSpeech(0xB0, 0, 0); + } else if (_globals[kTwinklesApproached] == 1) { + handleTwinklesSpeech(0xB1, 0, 0); + } else { + int quote = _twinklesTalk2 ? 0xB3 : 0xB2; + _twinklesTalk2 = true; + handleTwinklesSpeech(quote, 0, 0); + } + _scene->_sequences.addTimer(60, 3); + } + break; + + case 3: + _game._player._stepEnabled = true; + _shouldMoveHead = false; + _shouldTalk = false; + + if (_globals[kTwinklesApproached] < 2) + _globals[kTwinklesApproached]++; + + _conv1.start(); + _curDialogNode = 1; + break; + } + } else if (_action.isAction(VERB_GIVE, NOUN_NATIVE_WOMAN) && _game._objects.isInInventory(_game._objects.getIdFromDesc(_action._activeAction._objectNameId))) { + switch (_game._trigger) { + case 0: { + int quote = _vm->getRandomNumber(172, 174); + _shouldMoveHead = true; + _game._player._stepEnabled = false; + handleTwinklesSpeech(quote, 0, 120); + _scene->_sequences.addTimer(120, 1); + } + break; + + case 1: + _game._player._stepEnabled = true; + _shouldMoveHead = false; + break; + } + } else if (_action.isAction(VERB_WALK_DOWN, NOUN_PATH_TO_NORTH) || _action.isAction(VERB_WALK_TOWARDS, NOUN_HUT_TO_NORTH)) { + _scene->_nextSceneId = 205; + } else if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOORWAY)) { + _scene->_nextSceneId = 215; + } else if ((_action.isAction(VERB_PULL, NOUN_CURTAIN) || _action.isAction(VERB_OPEN, NOUN_CURTAIN)) && !_globals[kCurtainOpen]) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[1], false, 12, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: + _game._player._stepEnabled = true; + _globals[kCurtainOpen] = true; + _doorway = _scene->_dynamicHotspots.add(112, 395, -1, Common::Rect(163, 87, 163 + 19, 87 + 36)); + _scene->_dynamicHotspots.setPosition(_doorway, Common::Point(168, 127), FACING_NORTH); + _scene->_dynamicHotspots.setCursor(_doorway, CURSOR_GO_UP); + break; + } + } else if ((_action.isAction(VERB_PULL, NOUN_CURTAIN) || _action.isAction(VERB_CLOSE, NOUN_CURTAIN)) && _globals[kCurtainOpen]) { + switch (_game._trigger) { + case 0: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _game._player._stepEnabled = false; + _game._player._facing = FACING_NORTH; + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 12, 0, 0, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _game._player._stepEnabled = false; + break; + case 1: + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 5); + _scene->_sequences.addTimer(48, 2); + break; + case 2: + _scene->_dynamicHotspots.remove(_doorway); + _game._player._stepEnabled = true; + _globals[kCurtainOpen] = false; + break; + } + } else if (_action.isAction(VERB_LOOK, NOUN_HUT)) { + if (_globals[kTwinklesStatus] == TWINKLES_GONE) { + if (_game._storyMode == STORYMODE_NAUGHTY) + _vm->_dialogs->show(21003); + else + _vm->_dialogs->show(21002); + } else { + _vm->_dialogs->show(21001); + } + } else if (_action.isAction(VERB_LOOK, NOUN_BRA)) { + _vm->_dialogs->show(21004); + } else if (_action.isAction(VERB_LOOK, NOUN_HOTPANTS)) { + _vm->_dialogs->show(21005); + } else if (_action.isAction(VERB_TAKE, NOUN_HOTPANTS) || _action.isAction(VERB_TAKE, NOUN_BRA)) { + _vm->_dialogs->show(21006); + } else if (_action.isAction(VERB_LOOK, NOUN_STREAM)) { + _vm->_dialogs->show(21007); + } else if (_action.isAction(VERB_LOOK, NOUN_BUSHY_FERN)) { + _vm->_dialogs->show(21008); + } else if (_action.isAction(VERB_LOOK, NOUN_VILLAGE_PATH)) { + _vm->_dialogs->show(21009); + } else if (_action.isAction(VERB_LOOK, NOUN_NATIVE_WOMAN)) { + _vm->_dialogs->show(21010); + } else if (_action.isAction(VERB_SHOOT, NOUN_NATIVE_WOMAN) || _action.isAction(VERB_HOSE_DOWN, NOUN_NATIVE_WOMAN)) { + _vm->_dialogs->show(21011); + } else if (_action.isAction(VERB_LOOK, NOUN_PATH_TO_NORTH)) { + _vm->_dialogs->show(21012); + } else if (_action.isAction(VERB_LOOK, NOUN_CURTAIN)) { + _vm->_dialogs->show(21013); + } else if (_action.isAction(VERB_LOOK, NOUN_CLOTHESLINE)) { + _vm->_dialogs->show(21014); + } else if (_action.isAction(VERB_TAKE, NOUN_CLOTHESLINE)) { + _vm->_dialogs->show(21015); + } else if (_action.isAction(VERB_LOOK, NOUN_HUT_TO_NORTH)) { + _vm->_dialogs->show(21016); + } else { + // Not handled + return; + } + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene211::Scene211(MADSEngine *vm) : Scene2xx(vm) { + _ambushFl = false; + _wakeFl = false; + _monkeyFrame = 0; + _scrollY = 0; + _monkeyTime = 0; +} + +void Scene211::synchronize(Common::Serializer &s) { + Scene2xx::synchronize(s); + + s.syncAsByte(_ambushFl); + s.syncAsByte(_wakeFl); + + s.syncAsSint32LE(_monkeyFrame); + s.syncAsSint32LE(_scrollY); + s.syncAsUint32LE(_monkeyTime); +} + +void Scene211::setup() { + setPlayerSpritesPrefix(); + setAAName(); + + _scene->addActiveVocab(NOUN_SLITHERING_SNAKE); +} + +void Scene211::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites("*SC002Z2"); + _wakeFl = false; + + if (_scene->_priorSceneId == 210) + _game._player._playerPos = Common::Point(25, 148); + else if (_scene->_priorSceneId == 205) { + _game._player._playerPos = Common::Point(49, 133); + _game._player._facing = FACING_WEST; + _wakeFl = true; + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->loadAnimation(formAnimName('A', -1), 100); + _scene->_activeAnimation->setCurrentFrame(169); + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(310, 31); + _game._player._facing = FACING_SOUTHWEST; + } + + if (_vm->getRandomNumber(1, 8) == 1) { + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 6, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(202, 126)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 8); + _scene->_sequences.setMotion(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, -200, 0); + _scene->_dynamicHotspots.add(324, 13, _globals._sequenceIndexes[2], Common::Rect(1, 1, 1 + 41, 1 + 10)); + } + + if (_scene->_roomChanged) + _game._objects.addToInventory(OBJ_BINOCULARS); + + _vm->_palette->setEntry(252, 63, 44, 30); + _vm->_palette->setEntry(253, 63, 20, 22); + _game.loadQuoteSet(0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 1, 0); + + if (_globals[kMonkeyStatus] == MONKEY_AMBUSH_READY) + _scene->_kernelMessages.initRandomMessages(2, + Common::Rect(0, 0, 54, 30), 13, 2, 0xFDFC, 60, + 151, 152, 153, 154, 0); + + _monkeyTime = _vm->_game->_scene._frameStartTime; + _scrollY = 30; + + _ambushFl = false; + _monkeyFrame = 0; + + sceneEntrySound(); +} + +void Scene211::step() { + if (_globals[kMonkeyStatus] == MONKEY_AMBUSH_READY) { + _scene->_kernelMessages.randomServer(); + + if (!_ambushFl && !_wakeFl && (_vm->_game->_scene._frameStartTime >= _monkeyTime)) { + int chanceMinor = _scene->_kernelMessages.checkRandom() * 4 + 1; + if (_scene->_kernelMessages.generateRandom(80, chanceMinor)) + _vm->_sound->command(18); + + _monkeyTime = _vm->_game->_scene._frameStartTime + 2; + } + + if ((_game._player._playerPos == Common::Point(52, 132)) && (_game._player._facing == FACING_WEST) && !_game._player._moving && + (_game._trigger || !_ambushFl)) { + switch (_game._trigger) { + case 0: + if (_game._objects.isInInventory(OBJ_BINOCULARS)) { + _ambushFl = true; + _monkeyFrame = 0; + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->_kernelMessages.reset(); + _scene->loadAnimation(formAnimName('A', -1), 90); + _vm->_sound->command(19); + int count = (int)_game._objects._inventoryList.size(); + for (int idx = 0; idx < count; idx++) { + if ((_game._objects._inventoryList[idx] == OBJ_BINOCULARS) && (_scene->_userInterface._selectedInvIndex != idx)) + _scene->_userInterface.selectObject(idx); + } + } + break; + + case 90: + _vm->_sound->command(10); + _game._player._stepEnabled = true; + _game._player._visible = true; + _game._player._playerPos = Common::Point(49, 133); + _ambushFl = false; + _globals[kMonkeyStatus] = MONKEY_HAS_BINOCULARS; + break; + } + } + } + + if (_ambushFl && (_scene->_activeAnimation->getCurrentFrame() > _monkeyFrame)) { + _monkeyFrame = _scene->_activeAnimation->getCurrentFrame(); + switch (_monkeyFrame) { + case 2: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(12, 4), 0xFDFC, 0, 0, 60, _game.getQuote(157)); + _scene->_kernelMessages.setQuoted(msgIndex, 2, true); + } + break; + + case 12: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(35, 20), 0xFDFC, 0, 0, 60, _game.getQuote(155)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + } + break; + + case 42: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(60, 45), 0xFDFC, 0, 0, 60, _game.getQuote(156)); + _scene->_kernelMessages.setQuoted(msgIndex, 6, true); + } + break; + + case 73: + _scene->_kernelMessages.add(Common::Point(102, 95), 0xFDFC, 32, 0, 75, _game.getQuote(157)); + break; + + case 90: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(102, 95), 0xFDFC, 32, 0, 60, _game.getQuote(158)); + _scene->_kernelMessages.setQuoted(msgIndex, 6, true); + } + break; + + case 97: + _scene->_userInterface.selectObject(-1); + _game._objects.removeFromInventory(OBJ_BINOCULARS, 1); + break; + + case 177: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(63, _scrollY), 0x1110, 0, 0, 180, _game.getQuote(161)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + _scrollY += 14; + } + break; + + case 181: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(63, _scrollY), 0x1110, 0, 0, 180, _game.getQuote(162)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + _scrollY += 14; + } + break; + + case 188: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(63, _scrollY), 0x1110, 0, 0, 180, _game.getQuote(163)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + _scrollY += 14; + } + break; + + case 200: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(63, _scrollY), 0x1110, 0, 0, 180, _game.getQuote(164)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + _scrollY += 14; + } + break; + } + } + + if (_wakeFl) { + if (_game._trigger == 100) { + _game._player._visible = true; + _game._player._stepEnabled = true; + _wakeFl = false; + } + + if (_scene->_activeAnimation->getCurrentFrame() > _monkeyFrame) { + _monkeyFrame = _scene->_activeAnimation->getCurrentFrame(); + switch (_scene->_activeAnimation->getCurrentFrame()) { + case 177: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(63, _scrollY), 0x1110, 0, 0, 180, _game.getQuote(165)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + _scrollY += 14; + } + break; + + case 181: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(63, _scrollY), 0x1110, 0, 0, 180, _game.getQuote(166)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + _scrollY += 14; + } + break; + + case 188: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(63, _scrollY), 0x1110, 0, 0, 180, _game.getQuote(167)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + _scrollY += 14; + } + break; + + case 200: { + int msgIndex = _scene->_kernelMessages.add(Common::Point(63, _scrollY), 0x1110, 0, 0, 180, _game.getQuote(168)); + _scene->_kernelMessages.setQuoted(msgIndex, 4, true); + _scrollY += 14; + } + break; + } + } + } +} + +void Scene211::preActions() { + if (_action.isAction(VERB_WALK_DOWN, NOUN_JUNGLE_PATH) && _game._objects.isInInventory(OBJ_BINOCULARS) && (_globals[kMonkeyStatus] == MONKEY_AMBUSH_READY) + && (_scene->_customDest.x <= 52) && (_scene->_customDest.y >= 132)) + _game._player.walk(Common::Point(52, 132), FACING_WEST); + + if (_action.isAction(VERB_WALK_DOWN, NOUN_PATH_TO_WEST)) { + if (_game._objects.isInInventory(OBJ_BINOCULARS) && (_globals[kMonkeyStatus] == MONKEY_AMBUSH_READY)) + _game._player.walk(Common::Point(52, 132), FACING_WEST); + else + _game._player._walkOffScreenSceneId = 210; + } + + if (_action.isAction(VERB_WALK_DOWN, NOUN_PATH_TO_NORTHEAST)) + _game._player._walkOffScreenSceneId = 207; +} + +void Scene211::actions() { + if (_action._lookFlag && (_globals[kMonkeyStatus] == MONKEY_AMBUSH_READY)) + _vm->_dialogs->show(21111); + else if (_action.isAction(VERB_LOOK, NOUN_BINOCULARS, 0x100)) + _vm->_dialogs->show(21116); + else if (_action.isAction(VERB_LOOK, NOUN_BUSHY_FERN)) + _vm->_dialogs->show(21101); + else if (_action.isAction(VERB_LOOK, NOUN_JUNGLE_PATH)) + _vm->_dialogs->show(21102); + else if (_action.isAction(VERB_LOOK, NOUN_PALM_TREE)) { + if (_globals[kMonkeyStatus] == MONKEY_AMBUSH_READY) { + if (_game._storyMode == STORYMODE_NAUGHTY) + _vm->_dialogs->show(21103); + else + _vm->_dialogs->show(21104); + } else { + _vm->_dialogs->show(21105); + } + } else if (_action.isAction(VERB_LOOK, NOUN_THICK_UNDERGROWTH)) { + if (_game._storyMode == STORYMODE_NAUGHTY) + _vm->_dialogs->show(21106); + else + _vm->_dialogs->show(21107); + } else if (_action.isAction(VERB_LOOK, NOUN_JUNGLE)) + _vm->_dialogs->show(21108); + else if (_action.isAction(VERB_LOOK, NOUN_PATH_TO_NORTHEAST)) + _vm->_dialogs->show(21109); + else if (_action.isAction(VERB_LOOK, NOUN_PATH_TO_WEST)) + _vm->_dialogs->show(21110); + else if (_action.isAction(VERB_LOOK, NOUN_SLITHERING_SNAKE)) + _vm->_dialogs->show(21113); + else if (_action.isAction(VERB_TAKE, NOUN_SLITHERING_SNAKE)) + _vm->_dialogs->show(21114); + else if (_action.isAction(VERB_LOOK, NOUN_ROCKS)) + _vm->_dialogs->show(21115); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene212::setup() { + setPlayerSpritesPrefix(); + setAAName(); + + _scene->addActiveVocab(NOUN_BOUNCING_REPTILE); +} + +void Scene212::enter() { + // CHECKME: Some useless variables have been remove here + + if (_scene->_priorSceneId == 208) { + _game._player._playerPos = Common::Point(195, 85); + _game._player._facing = FACING_SOUTH; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(67, 117); + _game._player._facing = FACING_NORTHEAST; + } + + sceneEntrySound(); +} + +void Scene212::step() { +// CHECKME: Could we move the dino? +} + +void Scene212::preActions() { + if (_action.isAction(VERB_WALK_THROUGH, NOUN_CAVE_ENTRANCE)) + _game._player._walkOffScreenSceneId = 111; +} + +void Scene212::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(21209); + else if (_action.isAction(VERB_WALK_TOWARDS) && (_action.isObject(NOUN_FIELD_TO_NORTH) || _action.isObject(NOUN_MOUNTAINS))) + _scene->_nextSceneId = 208; + else if (_action.isAction(VERB_WALK_TOWARDS, NOUN_CAVE)) + _scene->_nextSceneId = 111; + else if (_action.isAction(VERB_LOOK, NOUN_GRASS)) + _vm->_dialogs->show(21201); + else if (_action.isAction(VERB_LOOK, NOUN_ROCKS)) + _vm->_dialogs->show(21202); + else if (_action.isAction(VERB_LOOK, NOUN_CAVE_ENTRANCE)) + _vm->_dialogs->show(21203); + else if (_action.isAction(VERB_LOOK, NOUN_SKY)) + _vm->_dialogs->show(21204); + else if (_action.isAction(VERB_LOOK, NOUN_FIELD_TO_NORTH)) + _vm->_dialogs->show(21205); + else if (_action.isAction(VERB_LOOK, NOUN_TREES)) + _vm->_dialogs->show(21206); + else if (_action.isAction(VERB_LOOK, NOUN_PLANTS)) + _vm->_dialogs->show(21207); + else if (_action.isAction(VERB_LOOK, NOUN_MOUNTAINS)) + _vm->_dialogs->show(21208); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene213::setup() { + _game._player._spritesPrefix = ""; + + // The original is calling Scene2xx::setAAName() + _game._aaName = Resources::formatAAName(2); +} + +void Scene213::enter() { + if (_globals[kMeteorologistWatch] != METEOROLOGIST_NORMAL) + _handSpriteId = _scene->_sprites.addSprites("*METHAND"); + else if (_globals[kSexOfRex] == REX_MALE) + _handSpriteId = _scene->_sprites.addSprites("*REXHAND"); + else + _handSpriteId = _scene->_sprites.addSprites("*ROXHAND"); + + teleporterEnter(); + + // The original is calling Scene2xx::sceneEntrySound() + if (_vm->_musicFlag) { + if (_globals[kMeteorologistWatch] == METEOROLOGIST_NORMAL) + _vm->_sound->command(1); + else + _vm->_sound->command(9); + } else + _vm->_sound->command(2); +} + +void Scene213::step() { + teleporterStep(); +} + +void Scene213::actions() { + if (teleporterActions()) { + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_CONTROL_PANEL)) + _vm->_dialogs->show(21301); + else if (_action.isAction(VERB_LOOK, NOUN_KEYPAD) || _action.isAction (VERB_INSPECT, NOUN_KEYPAD)) + _vm->_dialogs->show(21302); + else if (_action.isAction(VERB_LOOK, NOUN_DISPLAY)) + _vm->_dialogs->show(21303); + else if (_action.isAction(VERB_LOOK, NOUN_VIEWPORT) || _action.isAction(VERB_PEER_THROUGH, NOUN_VIEWPORT)) + _vm->_dialogs->show(21304); + else if (_action.isAction(VERB_LOOK, NOUN_DEVICE)) + _vm->_dialogs->show(21305); + else if (_action.isAction(VERB_LOOK, NOUN_0_KEY) || _action.isAction(VERB_LOOK, NOUN_1_KEY) + || _action.isAction(VERB_LOOK, NOUN_2_KEY) || _action.isAction(VERB_LOOK, NOUN_3_KEY) + || _action.isAction(VERB_LOOK, NOUN_4_KEY) || _action.isAction(VERB_LOOK, NOUN_5_KEY) + || _action.isAction(VERB_LOOK, NOUN_6_KEY) || _action.isAction(VERB_LOOK, NOUN_7_KEY) + || _action.isAction(VERB_LOOK, NOUN_8_KEY) || _action.isAction(VERB_LOOK, NOUN_9_KEY) + || _action.isAction(VERB_LOOK, NOUN_SMILE_KEY) || _action.isAction(VERB_LOOK, NOUN_FROWN_KEY) + || _action.isAction(VERB_LOOK, NOUN_ENTER_KEY)) + _vm->_dialogs->show(21306); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene214::Scene214(MADSEngine *vm) : Scene2xx(vm) { + _devilTime = 0; + _devilRunningFl = false; +} + +void Scene214::synchronize(Common::Serializer &s) { + Scene2xx::synchronize(s); + + s.syncAsUint32LE(_devilTime); + s.syncAsByte(_devilRunningFl); +} + +void Scene214::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_CAPTIVE_CREATURE); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene214::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('e', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('e', 1)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('t', -1)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*RXMRD_7"); + + _devilTime = _game._player._priorTimer; + _devilRunningFl = false; + + if (_game._objects.isInRoom(OBJ_POISON_DARTS)) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 6, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(103, 86)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 11); + } else { + _scene->_hotspots.activate(NOUN_POISON_DARTS, false); + } + + if (_game._objects.isInRoom(OBJ_BLOWGUN)) { + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 6, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(90, 87)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 13); + } else { + _scene->_hotspots.activate(NOUN_BLOWGUN, false); + } + + if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(191, 152); + + sceneEntrySound(); +} + +void Scene214::step() { + if ((_game._player._priorTimer - _devilTime > 800) && !_devilRunningFl) { + _devilRunningFl = true; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 9, 1, 6, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 2); + _scene->_dynamicHotspots.add(451, 13, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + } + + if (_devilRunningFl) { + switch (_game._trigger) { + case 71: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 9, 5, 0, 0); + _scene->_sequences.updateTimeout(oldIdx, _globals._sequenceIndexes[3]); + _scene->_dynamicHotspots.add(451, VERB_WALKTO, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 5, 8); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + } + break; + + case 72: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0); + _scene->_sequences.updateTimeout(oldIdx, _globals._sequenceIndexes[3]); + _scene->_dynamicHotspots.add(451, VERB_WALKTO, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 9, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 2); + _devilTime = _game._player._priorTimer; + _devilRunningFl = false; + } + break; + } + } +} + +void Scene214::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(21427); + else if (_action.isAction(0x18A, 0xAA)) + _scene->_nextSceneId = 207; + else if (_action.isAction(VERB_TAKE, NOUN_POISON_DARTS) && (_game._trigger || _game._objects.isInRoom(OBJ_POISON_DARTS))) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], true, 6, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: + _globals._sequenceIndexes[4] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[4], true, 6, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _game._objects.addToInventory(OBJ_POISON_DARTS); + _scene->_hotspots.activate(NOUN_POISON_DARTS, false); + break; + + case 2: + _game._player._visible = true; + _scene->_sequences.addTimer(48, 3); + break; + + case 3: + _game._player._stepEnabled = true; + _vm->_dialogs->showItem(OBJ_POISON_DARTS, 0x53A5); + break; + } + } else if (_action.isAction(VERB_TAKE, NOUN_BLOWGUN) && (_game._trigger || _game._objects.isInRoom(OBJ_BLOWGUN))) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 6, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: + _globals._sequenceIndexes[4] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[4], false, 6, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _game._objects.addToInventory(OBJ_BLOWGUN); + _scene->_hotspots.activate(NOUN_BLOWGUN, false); + break; + + case 2: + _game._player._visible = true; + _scene->_sequences.addTimer(48, 3); + break; + + case 3: + _game._player._stepEnabled = true; + _vm->_dialogs->showItem(OBJ_BLOWGUN, 0x329); + break; + } + } else if (_action.isAction(VERB_LOOK, NOUN_WINDOW)) + _vm->_dialogs->show(21401); + else if (_action.isAction(VERB_LOOK, NOUN_EXPERIMENT_CAGE)) + _vm->_dialogs->show(21402); + else if (_action.isAction(VERB_LOOK, NOUN_CAPTIVE_CREATURE)) + _vm->_dialogs->show(21403); + else if (_action.isAction(VERB_LOOK, NOUN_BEAR_RUG)) + _vm->_dialogs->show(21404); + else if (_action.isAction(VERB_LOOK, NOUN_TROPHY)) + _vm->_dialogs->show(21405); + else if (_action.isAction(VERB_LOOK, NOUN_LARGE_BOWL)) { + if (_game._storyMode == STORYMODE_NAUGHTY) { + _vm->_dialogs->show(21406); + } else { + _vm->_dialogs->show(21407); + } + } else if (_action.isAction(VERB_LOOK, NOUN_SPECIMEN_JARS)) + _vm->_dialogs->show(21408); + else if (_action.isAction(VERB_TAKE, NOUN_LARGE_BOWL) || _action.isAction(VERB_TAKE, NOUN_SPECIMEN_JARS)) + _vm->_dialogs->show(21409); + else if (_action.isAction(VERB_LOOK, NOUN_SHRUNKEN_HEADS)) + _vm->_dialogs->show(21410); + else if (_action.isAction(VERB_TAKE, NOUN_SHRUNKEN_HEADS) || _action.isAction(VERB_TAKE, NOUN_LARGE_HEADS)) + _vm->_dialogs->show(21411); + else if (_action.isAction(VERB_LOOK, NOUN_LARGE_HEADS)) + _vm->_dialogs->show(21428); + else if (_action.isAction(VERB_LOOK, NOUN_POISON_DARTS) && (_action._savedFields._mainObjectSource == 4)) + _vm->_dialogs->show(21412); + else if (_action.isAction(VERB_OPEN, NOUN_EXPERIMENT_CAGE)) + _vm->_dialogs->show(21414); + else if (_action.isAction(VERB_TALKTO, NOUN_CAPTIVE_CREATURE)) + _vm->_dialogs->show(21415); + else if (_action.isAction(VERB_GIVE, NOUN_TWINKIFRUIT, 0x1C3)) + _vm->_dialogs->show(21416); + else if (_action.isAction(VERB_SHOOT, 0x29, 0x1C3) || _action.isAction(VERB_HOSE_DOWN, 0x29, 0x1C3)) + _vm->_dialogs->show(21417); + else if (_action.isAction(VERB_LOOK, NOUN_BIG_HEADS)) + _vm->_dialogs->show(21418); + else if (_action.isAction(VERB_TAKE, NOUN_BIG_HEADS)) + _vm->_dialogs->show(21419); + else if (_action.isAction(VERB_TAKE, NOUN_BEAR_RUG)) + _vm->_dialogs->show(21420); + else if (_action.isAction(VERB_LOOK, NOUN_FLOOR_OF_HUT)) + _vm->_dialogs->show(21421); + else if (_action.isAction(VERB_LOOK, NOUN_BLOWGUN)) + _vm->_dialogs->show(21422); + else if (_action.isAction(VERB_LOOK, NOUN_TABLE)) { + if (_game._objects.isInRoom(OBJ_POISON_DARTS) && _game._objects.isInRoom(OBJ_BLOWGUN)) { + _vm->_dialogs->show(21423); + } else if (_game._objects.isInRoom(OBJ_POISON_DARTS) && !_game._objects.isInRoom(OBJ_BLOWGUN)) { + _vm->_dialogs->show(21424); + } else if (!_game._objects.isInRoom(OBJ_POISON_DARTS) && _game._objects.isInRoom(OBJ_BLOWGUN)) { + _vm->_dialogs->show(21425); + } else { + _vm->_dialogs->show(21426); + } + } else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene215::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene215::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('e', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('a', 0)); + + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle (_globals._spriteIndexes[1], false, 7, 0, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(235, 83)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + + if (_globals[kSexOfRex] == REX_MALE) + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*RXMRC_9"); + else + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*ROXRC_9"); + + if (_scene->_priorSceneId == 216) { + _game._player._playerPos = Common::Point(140, 119); + _game._player._facing = FACING_SOUTHWEST; + _game._player._visible = false; + _game._player._stepEnabled = false; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.addTimer(120, 70); + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(204, 152); + _game._player._facing = FACING_NORTH; + } + + _game.loadQuoteSet(0xA9, 0xAA, 0); + sceneEntrySound(); +} + +void Scene215::step() { + if (_game._trigger == 70) { + _scene->_sequences.remove (_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + } + + if (_game._trigger == 71) { + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[3]); + _game._player._visible = true; + _game._player._stepEnabled = true; + } +} + +void Scene215::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(21509); + else if (_action.isAction(VERB_TAKE, NOUN_TWINKIFRUIT)) { + if (!_game._objects.isInInventory(OBJ_TWINKIFRUIT) || _game._trigger) { + switch (_game._trigger) { + case 0: + if (_globals[kSexOfRex] == REX_MALE) { + _game._player._visible = false; + _game._player._stepEnabled = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 6, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 4); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_LOOP, 0, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } else { + _game._objects.addToInventory(OBJ_TWINKIFRUIT); + _vm->_dialogs->showItem(OBJ_TWINKIFRUIT, 0x5404); + } + break; + + case 1: + if (!_game._objects.isInInventory(OBJ_TWINKIFRUIT)) { + _game._objects.addToInventory(OBJ_TWINKIFRUIT); + _vm->_dialogs->showItem(OBJ_TWINKIFRUIT, 0x5404); + } + break; + + case 2: + _game._player._visible = true; + _game._player._stepEnabled = true; + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[2]); + break; + } + } else { + int idx = _vm->getRandomNumber(169, 170); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(idx)); + } + } else if (_action.isAction(0x18A, 0xAA)) + _scene->_nextSceneId = 210; + else if (_action.isAction(VERB_LOOK, NOUN_BEAR_RUG)) + _vm->_dialogs->show(21501); + else if (_action.isAction(VERB_LOOK, NOUN_BED)) + _vm->_dialogs->show(21502); + else if (_action.isAction(VERB_LOOK, NOUN_WELCOME_MAT)) + _vm->_dialogs->show(21503); + else if (_action.isAction(VERB_LOOK, NOUN_LOVE_ALTAR)) + _vm->_dialogs->show(21504); + else if (_action.isAction(VERB_LOOK, NOUN_WINDOW)) + _vm->_dialogs->show(21505); + else if (_action.isAction(VERB_LOOK, NOUN_PICTURE)) + _vm->_dialogs->show(21506); + else if (_action.isAction(VERB_LOOK, NOUN_TWINKIFRUIT) && (_action._savedFields._mainObjectSource == 4)) + _vm->_dialogs->show(21507); + else if (_action.isAction(VERB_TAKE, NOUN_BEAR_RUG)) + _vm->_dialogs->show(21510); + else if (_action.isAction(VERB_TAKE, NOUN_LOVE_ALTAR)) + _vm->_dialogs->show(21511); + else if (_action.isAction(VERB_LOOK, NOUN_BAG_OF_TWINKIFRUITS)) + _vm->_dialogs->show(21512); + else if (_action.isAction(VERB_TAKE, NOUN_BAG_OF_TWINKIFRUITS)) + _vm->_dialogs->show(21513); + else if (_action.isAction(VERB_TAKE, NOUN_WELCOME_MAT)) + _vm->_dialogs->show(21514); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene216::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene216::enter() { + _game._player._stepEnabled = false; + _game._player._visible = false; + + _scene->_userInterface.emptyConversationList(); + _scene->_userInterface.setup(kInputConversation); + _scene->loadAnimation(formAnimName('A', -1), 60); + + sceneEntrySound(); +} + +void Scene216::step() { + if (_game._trigger == 60) + _scene->_nextSceneId = 215; +} + +/*------------------------------------------------------------------------*/ + +} // End of namespace Nebular +} // End of namespace MADS diff --git a/engines/mads/nebular/nebular_scenes2.h b/engines/mads/nebular/nebular_scenes2.h new file mode 100644 index 0000000000..e70444a256 --- /dev/null +++ b/engines/mads/nebular/nebular_scenes2.h @@ -0,0 +1,325 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_NEBULAR_SCENES2_H +#define MADS_NEBULAR_SCENES2_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" + +namespace MADS { + +namespace Nebular { + +class Scene2xx : public NebularScene { +protected: + /** + * Plays an appropriate sound when entering a scene + */ + void setAAName(); + + /** + * Updates the prefix used for getting player sprites for the scene + */ + void setPlayerSpritesPrefix(); + + void sceneEntrySound(); +public: + Scene2xx(MADSEngine *vm) : NebularScene(vm) {} +}; + +class Scene201: public Scene2xx { +private: + bool _pterodactylFlag; + +public: + Scene201(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene202: public Scene2xx { +private: + bool _activeMsgFl, _ladderTopFl, _waitingMeteoFl, _toStationFl, _toTeleportFl; + int _ladderHotspotId, _lastRoute, _stationCounter, _meteoFrame; + uint32 _meteoClock1, _meteoClock2, _startTime; + bool _meteorologistSpecial; + + int subStep1(int randVal); + int subStep2(int randVal); + int subStep3(int randVal); + int subStep4(int randVal); + +public: + Scene202(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); + + void setRandomKernelMessage(); +}; + +class Scene203: public Scene2xx { +private: + bool _rhotundaEat2Fl, _rhotundaEatFl; + +public: + Scene203(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene205: public Scene2xx { +private: + uint32 _lastFishTime, _chickenTime; + bool _beingKicked; + int _kernelMessage; + Conversation _dialog1; + + void handleWomanSpeech(int quoteId); + +public: + Scene205(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene207: public Scene2xx { +private: + bool _vultureFl, _spiderFl, _eyeFl; + int _spiderHotspotId, _vultureHotspotId; + int32 _spiderTime, _vultureTime; + + void moveVulture(); + void moveSpider(); + +public: + Scene207(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene208: public Scene2xx { +private: + bool _rhotundaTurnFl, _boundingFl; + int32 _rhotundaTime; + + void updateTrap(); + void subAction(int mode); + +public: + Scene208(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene209: public Scene2xx { +private: + bool _dodgeFl, _forceDodgeFl, _shouldDodgeFl; + bool _pitchFl; + bool _fallFl, _forceFallFl, _shouldFallFl; + bool _playingAnimFl, _playingDialogFl; + int _pauseMode, _pauseCounterThreshold, _pauseCounter; + bool _removeMonkeyFl; + int _monkeyPosition; + bool _shootReadyFl, _startShootingInTimerFl, _shootMissedLastFl; + bool _binocularsDroppedFl; + int _dialogAbortVal; + int _counter; + + void handlePause(); + void initPauseCounterThreshold(); + void handlePeek(); + void handleVerticalMove(); + void handleLookStay(); + void handleLookRight(); + void handleBlink(); + void handleGetBinoculars(); + void handleStandFromPeek(); + void handleDodge(); + void handleBinocularBlink(); + void handleBinocularScan(); + void handleJumpInTree(); + void handleTongue(); + void handleMonkeyFall(); + void handleJumpAndHide(); + void handleMonkeyEating(); + void handleMonkey1(); + void handleStandBlink(); + void handleMonkey2(); + +public: + Scene209(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene210: public Scene2xx { +private: + int _curDialogNode; + int _nextHandsPlace; + int _twinkleAnimationType; + int _twinklesCurrentFrame; + bool _shouldTalk, _shouldFaceRex, _shouldMoveHead; + bool _stopWalking; + bool _twinklesTalking; + bool _twinklesTalk2; + int _doorway; + Common::String _subQuote2; + Conversation _conv1, _conv2, _conv3; + Conversation _conv5, _conv6, _conv7, _conv8; + + void handleConversations(); + void handleConversation1(); + void handleConversation2(); + void handleConversation3(); + void handleConversation5(); + void handleConversation6(); + void handleConversation7(); + void handleConversation8(); + void setDialogNode(int node); + void handleTwinklesSpeech(int quoteId, int shiftX, uint32 delay); + void newNode(int node); + void restoreDialogNode(int node, int msgId, int posY); + +public: + Scene210(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene211: public Scene2xx { +private: + bool _ambushFl, _wakeFl; + int _monkeyFrame, _scrollY; + uint32 _monkeyTime; + +public: + Scene211(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene212: public Scene2xx { +public: + Scene212(MADSEngine *vm) : Scene2xx(vm) {} + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene213: public SceneTeleporter { +public: + Scene213(MADSEngine *vm) : SceneTeleporter(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene214: public Scene2xx { +private: + uint32 _devilTime; + bool _devilRunningFl; + +public: + Scene214(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene215: public Scene2xx { +public: + Scene215(MADSEngine *vm) : Scene2xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene216: public Scene2xx { +public: + Scene216(MADSEngine *vm) : Scene2xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions() {}; +}; + +} // End of namespace Nebular + +} // End of namespace MADS + +#endif /* MADS_NEBULAR_SCENES2_H */ diff --git a/engines/mads/nebular/nebular_scenes3.cpp b/engines/mads/nebular/nebular_scenes3.cpp new file mode 100644 index 0000000000..d54ffbdb2b --- /dev/null +++ b/engines/mads/nebular/nebular_scenes3.cpp @@ -0,0 +1,5807 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" +#include "mads/nebular/nebular_scenes3.h" + +namespace MADS { + +namespace Nebular { + +void Scene3xx::setAAName() { + _game._aaName = Resources::formatAAName(4); +} + +void Scene3xx::setPlayerSpritesPrefix() { + _vm->_sound->command(5); + + Common::String oldName = _game._player._spritesPrefix; + + if (_globals[kSexOfRex] == REX_MALE) + _game._player._spritesPrefix = "RXM"; + else + _game._player._spritesPrefix = "ROX"; + + if ((_scene->_nextSceneId == 313) || (_scene->_nextSceneId == 366) + || ((_scene->_nextSceneId >= 301) && (_scene->_nextSceneId <= 303)) + || ((_scene->_nextSceneId == 304) && (_scene->_currentSceneId == 303)) + || ((_scene->_nextSceneId == 311) && (_scene->_currentSceneId == 304)) + || ((_scene->_nextSceneId >= 308) && (_scene->_nextSceneId <= 310)) + || ((_scene->_nextSceneId >= 319) && (_scene->_nextSceneId <= 322)) + || ((_scene->_nextSceneId >= 387) && (_scene->_nextSceneId <= 391))) { + _game._player._spritesPrefix = ""; + _game._player._spritesChanged = true; + } + + _game._player._scalingVelocity = true; + if (oldName != _game._player._spritesPrefix) + _game._player._spritesChanged = true; + + _vm->_palette->setEntry(16, 10, 63, 63); + _vm->_palette->setEntry(17, 10, 45, 45); +} + +void Scene3xx::sceneEntrySound() { + if (!_vm->_musicFlag) { + _vm->_sound->command(2); + return; + } + + switch (_scene->_nextSceneId) { + case 301: + case 302: + case 303: + case 304: + case 308: + case 309: + case 310: + _vm->_sound->command(11); + break; + + case 311: + if (_scene->_priorSceneId == 304) + _vm->_sound->command(11); + else + _vm->_sound->command(10); + break; + + case 313: + case 316: + case 320: + case 322: + case 357: + case 358: + case 359: + case 360: + case 361: + case 387: + case 388: + case 389: + case 390: + case 391: + case 399: + _vm->_sound->command(10); + break; + + case 318: + if ((_scene->_priorSceneId == 357) || (_scene->_priorSceneId == 407)) + _vm->_sound->command(10); + else if (_scene->_priorSceneId == 319) + _vm->_sound->command(16); + else + _vm->_sound->command(3); + + _vm->_sound->command(50); + break; + + case 319: + _vm->_sound->command(16); + break; + + case 321: + _vm->_sound->command(18); + break; + + default: + break; + } +} + +void Scene3xx::initForceField(ForceField *force, bool flag) { + force->_flag = flag; + force->_vertical = 0; + force->_horizontal = 0; + force->_timer = 0; + + for (int count = 0; count < 40; count++) + force->_seqId[count] = -1; + + if (force->_flag) + _vm->_sound->command(24); +} + +int Scene3xx::computeScale(int low, int high, int id) { + int diff = high - (low + 2); + int quotient = diff / 20; + int remainder = diff % 20; + int value = low + 2 + (quotient * id) + (remainder / (id + 1)); + + return (value); +} + +void Scene3xx::handleForceField(ForceField *force, int *sprites) { + if (_game._trigger >= 150) { + int id = _game._trigger - 150; + if (id < 40) { + if (id < 20) + force->_vertical--; + else + force->_horizontal--; + + force->_seqId[id] = -1; + } + return; + } + + if (!force->_flag || (_scene->_frameStartTime < force->_timer) || (force->_vertical + force->_horizontal >= 5)) + return; + + if (_vm->getRandomNumber(1, 1000) <= (200 + ((40 - (force->_vertical + force->_horizontal)) << 5))) { + int id = -1; + for (int i = 0; i < 100; i++) { + int randIdx = _vm->getRandomNumber(0, 39); + if (force->_seqId[randIdx] < 0) { + id = randIdx; + break; + } + } + + if (id < 0) { + for (int i = 0; i < 40; i++) { + if (force->_seqId[i] < 0) { + id = i; + break; + } + } + } + + int speedX, speedY; + int posX, posY; + int randVal = _vm->getRandomNumber(1, 100); + int spriteId; + bool mirror; + + if (id >= 20) { + spriteId = 2; + mirror = (randVal <= 50); + posX = mirror ? 315 : 5; + posY = computeScale(15, 119, id - 20); + speedX = 1000 * (mirror ? -1 : 1); + speedY = 0; + } else if (randVal <= 50) { + spriteId = 1; + mirror = false; + posX = computeScale(21, 258, id); + posY = 0; + speedX = 0; + speedY = 600; + } else { + spriteId = 0; + mirror = false; + posX = computeScale(21, 258, id); + posY = 155; + speedX = 0; + speedY = -600; + } + + if (id >= 0) { + force->_seqId[id] = _scene->_sequences.addSpriteCycle(sprites[spriteId], mirror, 2, 0, 0, 0); + _scene->_sequences.setDepth(force->_seqId[id], 8); + _scene->_sequences.setPosition(force->_seqId[id], Common::Point(posX, posY)); + _scene->_sequences.setMotion(force->_seqId[id], 2, speedX, speedY); + _scene->_sequences.addSubEntry(force->_seqId[id], SEQUENCE_TRIGGER_EXPIRE, 0, 150 + id); + if (spriteId == 2) + force->_horizontal++; + else + force->_vertical++; + } + } + + force->_timer = _scene->_frameStartTime + 4; +} + +/*------------------------------------------------------------------------*/ + +void Scene300s::preActions() { + _game._player._needToWalk = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene301::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene301::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 9, 0, 0, 0); + + _globals[kMeteorologistStatus] = METEOROLOGIST_GONE; + _globals[kTeleporterCommand] = TELEPORTER_NONE; + + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->loadAnimation(formAnimName('a', -1), 60); + + sceneEntrySound(); +} + +void Scene301::step() { + if (_game._trigger == 60) + _scene->_nextSceneId = 302; +} + +/*------------------------------------------------------------------------*/ + +Scene302::Scene302(MADSEngine *vm) : Scene3xx(vm) { + _oldFrame = 0; +} + +void Scene302::synchronize(Common::Serializer &s) { + Scene3xx::synchronize(s); + + s.syncAsSint32LE(_oldFrame); +} + +void Scene302::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene302::enter() { + _game._player._stepEnabled = false; + _game._player._visible = false; + + _scene->loadAnimation(formAnimName('a', -1), 71); + sceneEntrySound(); +} + +void Scene302::step() { + if (_game._trigger == 71) + _scene->_nextSceneId = 303; + + if ((_scene->_activeAnimation != nullptr) && (_scene->_activeAnimation->getCurrentFrame() != _oldFrame)) { + _oldFrame = _scene->_activeAnimation->getCurrentFrame(); + if (_oldFrame == 147) { + _game._objects.setRoom(OBJ_POISON_DARTS, 1); + _game._objects.setRoom(OBJ_BLOWGUN, 1); + _game._objects.setRoom(OBJ_REBREATHER, 1); + _game._objects.setRoom(OBJ_STUFFED_FISH, 1); + _game._objects.setRoom(OBJ_DEAD_FISH, 1); + _game._objects.setRoom(OBJ_BURGER, 1); + + int count = (int)_game._objects._inventoryList.size(); + for (int idx = 0; idx < count; idx++) { + if (_game._objects.isInInventory(idx)) + _game._objects.setRoom(idx, 50); + } + } + } +} + +/*------------------------------------------------------------------------*/ + +void Scene303::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene303::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('b', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('b', 1)); + + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 10, 0, 50, 120); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 10, 0, 0, 0); + + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->loadAnimation(formAnimName('a', -1), 60); + + sceneEntrySound(); +} + +void Scene303::step() { + if (_game._trigger == 60) + _scene->_nextSceneId = 304; +} + +/*------------------------------------------------------------------------*/ + +Scene304::Scene304(MADSEngine *vm) : Scene3xx(vm) { + _explosionSpriteId = -1; +} + +void Scene304::synchronize(Common::Serializer &s) { + Scene3xx::synchronize(s); + + s.syncAsSint32LE(_explosionSpriteId); +} + +void Scene304::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene304::enter() { + if (_scene->_priorSceneId == 303) { + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->loadAnimation(formAnimName('a', -1), 60); + } else { + if (_globals[kSexOfRex] == REX_MALE) + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('a', 0)); + else + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('a', 2)); + + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('b', 0)); + + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 150, 0, 3, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 2); + _vm->_palette->setEntry(252, 45, 63, 45); + _vm->_palette->setEntry(253, 20, 45, 20); + + if (_globals[kSexOfRex] == REX_MALE) + _game._player._playerPos = Common::Point(111, 117); + else + _game._player._playerPos = Common::Point(113, 116); + + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 11, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], -1, -1); + _scene->_sequences.addTimer(48, 70); + } + + sceneEntrySound(); + _game.loadQuoteSet(0xEB, 0xEC, 0); +} + +void Scene304::step() { + if (_game._trigger == 60) + _scene->_nextSceneId = 311; + + if (_game._trigger >= 70) { + switch (_game._trigger) { + case 70: { + _game._player._visible = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 2, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + if (_globals[kSexOfRex] == REX_MALE) + _explosionSpriteId = _globals._spriteIndexes[1]; + else + _explosionSpriteId = _globals._spriteIndexes[4]; + + int sprIdx = _scene->_sequences.addSpriteCycle(_explosionSpriteId, false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(sprIdx, -1, 4); + _scene->_sequences.setDepth(sprIdx, 1); + _scene->_sequences.addSubEntry(sprIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 71); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 74); + } + break; + + case 71: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 60, _game.getQuote(0xEB)); + _scene->_sequences.addTimer(1, 72); + break; + + case 72: { + _vm->_sound->command(43); + int sprIdx = _scene->_sequences.addSpriteCycle(_explosionSpriteId, false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(sprIdx, 5, -2); + _scene->_sequences.setDepth(sprIdx, 1); + _scene->_sequences.addSubEntry(sprIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 73); + if (_game._storyMode == STORYMODE_NICE) + _scene->_sequences.addSubEntry(sprIdx, SEQUENCE_TRIGGER_SPRITE, 8, 78); + } + break; + + case 73: { + int sprIdx = _scene->_sequences.addSpriteCycle(_explosionSpriteId, false, 8, 0, 0, 0); + _scene->_sequences.setAnimRange(sprIdx, -2, -2); + _scene->_sequences.setDepth(sprIdx, 1); + } + break; + + case 74: + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 5, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 75); + break; + + case 75: + _globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 2, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 76); + break; + + case 76: + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 8, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 2, 2); + _scene->_sequences.addTimer(48, 77); + break; + + case 77: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(211, 45), 0xFDFC, 32, 0, 180, _game.getQuote(0xEC)); + _scene->_sequences.addTimer(120, 78); + break; + + case 78: + _scene->_nextSceneId = 316; + break; + + default: + break; + } + } +} + +/*------------------------------------------------------------------------*/ + +Scene307::Scene307(MADSEngine *vm) : Scene3xx(vm) { + _afterPeeingFl = false; + _duringPeeingFl = false; + _grateOpenedFl = false; + _activePrisonerFl = false; + + _animationMode = -1; + _prisonerMessageId = -1; + _fieldCollisionCounter = -1; + + _lastFrameTime = 0; + _guardTime = 0; + _prisonerTimer = 0; + + _subQuote2 = ""; +} + +void Scene307::synchronize(Common::Serializer &s) { + Scene3xx::synchronize(s); + + _forceField.synchronize(s); + + s.syncAsByte(_afterPeeingFl); + s.syncAsByte(_duringPeeingFl); + s.syncAsByte(_grateOpenedFl); + s.syncAsByte(_activePrisonerFl); + + s.syncAsSint32LE(_animationMode); + s.syncAsSint32LE(_prisonerMessageId); + s.syncAsSint32LE(_fieldCollisionCounter); + + s.syncAsUint32LE(_lastFrameTime); + s.syncAsUint32LE(_guardTime); + s.syncAsUint32LE(_prisonerTimer); + + s.syncString(_subQuote2); +} + +void Scene307::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_AIR_VENT); + _scene->addActiveVocab(NOUN_CLIMB_INTO); +} + +void Scene307::handleRexDialog(int quote) { + Common::String curQuote = _game.getQuote(_action._activeAction._verbId); + if (_vm->_font->getWidth(curQuote, _scene->_textSpacing) > 200) { + Common::String subQuote1; + _game.splitQuote(curQuote, subQuote1, _subQuote2); + _scene->_kernelMessages.add(Common::Point(0, -14), 0x1110, 34, 0, 240, subQuote1); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 1, 180, _subQuote2); + } else + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 1, 120, curQuote); +} + +void Scene307::handlePrisonerEncounter() { + switch (_action._activeAction._verbId) { + case 275: + setDialogNode(5); + break; + + case 277: + setDialogNode(4); + break; + + case 276: + setDialogNode(6); + break; + } +} + +void Scene307::handlePrisonerSpeech(int firstQuoteId, int number, long timeout) { + int height = number * 14; + int posY; + + if (height < 60) + posY = 65 - height; + else + posY = 78 - (height / 2); + + _scene->_kernelMessages.reset(); + _activePrisonerFl = true; + + int quoteId = firstQuoteId; + for (int count = 0; count < number; count++) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_kernelMessages.add(Common::Point(5, posY), 0xFDFC, 0, 81, timeout, _game.getQuote(quoteId)); + posY += 14; + quoteId++; + } +} + +void Scene307::setDialogNode(int node) { + switch (node) { + case 0: + handlePrisonerSpeech(0x153, 2, 120); + _scene->_userInterface.setup(kInputBuildingSentences); + break; + + case 1: + _globals[kMetBuddyBeast] = true; + handlePrisonerSpeech(0x10F, 2, 9999999); + _dialog1.start(); + break; + + case 2: + _globals[kMetBuddyBeast] = true; + handlePrisonerSpeech(0x111, 2, 9999999); + _dialog1.start(); + break; + + case 4: + handlePrisonerSpeech(0x116, 1, 120); + _scene->_userInterface.setup(kInputBuildingSentences); + break; + + case 5: + _globals[kKnowsBuddyBeast] = true; + handlePrisonerSpeech(0x117, 2, 9999999); + _dialog2.start(); + break; + + case 6: + handlePrisonerSpeech(0x123, 1, 120); + _scene->_userInterface.setup(kInputBuildingSentences); + break; + + case 7: + _globals[kKnowsBuddyBeast] = true; + handlePrisonerSpeech(0x124, 10, 9999999); + _dialog2.write(0x11A, false); + _dialog2.write(0x11B, true); + _dialog2.write(0x120, true); + _dialog2.start(); + break; + + case 8: + handlePrisonerSpeech(0x12E, 6, 9999999); + _dialog2.write(0x11A, false); + _dialog2.write(0x11B, false); + _dialog2.write(0x11C, true); + _dialog2.write(0x11D, true); + _dialog2.write(0x11F, true); + _dialog2.start(); + break; + + case 9: + handlePrisonerSpeech(0x134, 4, 9999999); + _dialog2.write(0x11D, false); + _dialog2.start(); + break; + + case 10: + handlePrisonerSpeech(0x138, 6, 9999999); + _dialog2.write(0x11E, false); + _dialog2.start(); + break; + + case 11: + handlePrisonerSpeech(0x13E, 6, 9999999); + _dialog2.write(0x11F, false); + _dialog2.write(0x121, true); + _dialog2.start(); + break; + + case 12: + handlePrisonerSpeech(0x144, 4, 9999999); + _dialog2.write(0x11C, false); + _dialog2.start(); + break; + + case 13: + handlePrisonerSpeech(0x148, 7, 9999999); + _dialog2.write(0x120, false); + _dialog2.start(); + break; + + case 14: + handlePrisonerSpeech(0x14F, 3, 9999999); + _dialog2.write(0x121, false); + _dialog2.start(); + break; + + case 15: + handlePrisonerSpeech(0x152, 1, 120); + _scene->_userInterface.setup(kInputBuildingSentences); + break; + + case 16: + _globals[kKnowsBuddyBeast] = true; + handlePrisonerSpeech(0x10C, 1, 9999999); + _dialog2.start(); + break; + + default: + break; + } +} + +void Scene307::handlePrisonerDialog() { + switch (_action._activeAction._verbId) { + case 0x11A: + setDialogNode(7); + break; + + case 0x11B: + setDialogNode(8); + break; + + case 0x11C: + setDialogNode(12); + break; + + case 0x11D: + setDialogNode(9); + break; + + case 0x11E: + setDialogNode(10); + break; + + case 0x11F: + setDialogNode(11); + break; + + case 0x120: + setDialogNode(13); + break; + + case 0x121: + setDialogNode(14); + break; + + case 0x122: + setDialogNode(15); + break; + } +} + +void Scene307::handleDialog() { + if (_game._trigger == 0) { + _scene->_kernelMessages.reset(); + _game._player._stepEnabled = false; + handleRexDialog(_action._activeAction._verbId); + } else { + _game._player._stepEnabled = true; + + if (!_globals[kKnowsBuddyBeast]) { + handlePrisonerEncounter(); + } else { + handlePrisonerDialog(); + } + } +} + +void Scene307::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites("*SC003x0"); + _globals._spriteIndexes[0] = _scene->_sprites.addSprites("*SC003x1"); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*SC003x2"); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('x', 0)); + + initForceField(&_forceField, true); + + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 15); + + _animationMode = 0; + _fieldCollisionCounter = 0; + + _scene->changeVariant(1); + + _game.loadQuoteSet(0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0x10C, 0x104, 0x106, 0x107, 0x108, 0x105, + 0x109, 0x10A, 0x10B, 0x10D, 0x10E, 0x10F, 0x110, 0x111, 0x112, 0x113, 0x114, 0x115, 0x116, 0x117, + 0x118, 0x119, 0x11A, 0x11B, 0x11C, 0x11D, 0x11E, 0x11F, 0x120, 0x121, 0x122, 0x123, 0x124, 0x125, + 0x126, 0x127, 0x128, 0x129, 0x12A, 0x12B, 0x12C, 0x12D, 0x12E, 0x12F, 0x130, 0x131, 0x132, 0x133, + 0x134, 0x135, 0x136, 0x137, 0x138, 0x139, 0x13A, 0x13B, 0x13C, 0x13D, 0x13E, 0x13F, 0x140, 0x141, + 0x142, 0x143, 0x144, 0x145, 0x146, 0x147, 0x148, 0x149, 0x14A, 0x14B, 0x14C, 0x14D, 0x14E, 0x14F, + 0x150, 0x151, 0x152, 0x153, 0); + + _dialog1.setup(0x3F, 0x113, 0x114, 0x115, -1); + _dialog2.setup(0x40, 0x11A, 0x11B, 0x11C, 0x11D, 0x11E, 0x11F, 0x120, 0x121, 0x122, 0); + + if (!_game._visitedScenes._sceneRevisited) + _dialog2.set(0x11A, 0x122, 0); + else if (_scene->_priorSceneId == 318) + _dialog2.write(0x11E, true); + + + if (_scene->_priorSceneId == -2) { + if (_grateOpenedFl) + _vm->_sound->command(10); + else + _vm->_sound->command(3); + } else { + _afterPeeingFl = false; + _duringPeeingFl = false; + _guardTime = 0; + _grateOpenedFl = false; + _activePrisonerFl = false; + _prisonerTimer = 0; + _prisonerMessageId = 0x104; + + if (_scene->_priorSceneId == 308) { + _game._player._visible = false; + _game._player._stepEnabled = false; + _game._player._playerPos = Common::Point(156, 113); + _game._player._facing = FACING_NORTH; + _animationMode = 1; + _vm->_sound->command(11); + _scene->loadAnimation(formAnimName('a', -1), 60); + } else if (_scene->_priorSceneId == 387) { + _game._player._playerPos = Common::Point(129, 108); + _game._player._facing = FACING_NORTH; + _vm->_sound->command(3); + _grateOpenedFl = true; + } else { + _game._player._playerPos = Common::Point(159, 109); + _game._player._facing = FACING_SOUTH; + _vm->_sound->command(3); + } + } + + if (_grateOpenedFl) { + _scene->_hotspots.activate(17, false); + + int idx = _scene->_dynamicHotspots.add(17, 0x2F7, -1, Common::Rect(117, 67, 117 + 19, 67 + 13)); + int hotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(129, 104), FACING_NORTH); + _scene->_dynamicHotspots.setCursor(hotspotId, CURSOR_GO_UP); + + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 15); + } + + _vm->_palette->setEntry(252, 63, 30, 20); + _vm->_palette->setEntry(253, 45, 15, 12); + + sceneEntrySound(); + + if ((_scene->_priorSceneId == 318) || (_scene->_priorSceneId == 387)) + _scene->_kernelMessages.addQuote(0xF3, 120, 0); +} + +void Scene307::step() { + handleForceField(&_forceField, &_globals._spriteIndexes[0]); + + if ((_animationMode == 1) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() == 126) { + _forceField._flag = false; + _vm->_sound->command(5); + } + + if (_scene->_activeAnimation->getCurrentFrame() == 194) { + _forceField._flag = true; + _vm->_sound->command(24); + } + } + + if ((_animationMode == 2) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() == 54) + _forceField._flag = false; + + if (_scene->_activeAnimation->getCurrentFrame() == 150) { + _game._player._visible = false; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + } + } + + if (_game._trigger == 60) { + _game._player._visible = true; + _game._player._stepEnabled = true; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _animationMode = 0; + _vm->_sound->command(9); + } + + if ((_lastFrameTime != _scene->_frameStartTime) && !_duringPeeingFl) { + int32 elapsedTime = _lastFrameTime - _scene->_frameStartTime; + if ((elapsedTime > 0) && (elapsedTime <= 4)) { + _guardTime += elapsedTime; + _prisonerTimer += elapsedTime; + } else { + _guardTime++; + _prisonerTimer++; + } + _lastFrameTime = _scene->_frameStartTime; + + // FIXME: The active animation is never a zero pointer, so the guards never show up + if ((_guardTime > 3000) && !_duringPeeingFl /*&& (_scene->_activeAnimation == nullptr)*/ + && (_game._screenObjects._inputMode != 1) && _globals[kMetBuddyBeast] && !_activePrisonerFl) { + if (!_game._objects.isInInventory(OBJ_SCALPEL) && !_grateOpenedFl) { + _game._player._stepEnabled = false; + _game._player.walk(Common::Point(151, 119), FACING_SOUTHEAST); + _animationMode = 2; + _vm->_sound->command(11); + _scene->loadAnimation(formAnimName('b', -1), 70); + } + _guardTime = 0; + } else if ((_prisonerTimer > 300) && (_game._screenObjects._inputMode != 1) && (_scene->_activeAnimation == nullptr) && !_activePrisonerFl) { + if (!_globals[kMetBuddyBeast]) { + int idx = _scene->_kernelMessages.add(Common::Point(5, 51), 0xFDFC, 0, 81, 120, _game.getQuote(_prisonerMessageId)); + _scene->_kernelMessages.setQuoted(idx, 4, true); + _prisonerMessageId++; + if (_prisonerMessageId > 0x10A) + _prisonerMessageId = 0x104; + } else if (_globals[kKnowsBuddyBeast] && (_dialog2.read(0) > 1) && (_vm->getRandomNumber(1, 3) == 1)) { + int idx = _scene->_kernelMessages.add(Common::Point(5, 51), 0xFDFC, 0, 81, 120, _game.getQuote(267)); + _scene->_kernelMessages.setQuoted(idx, 4, true); + } + _prisonerTimer = 0; + } + } + + if (_game._trigger == 70) + _scene->_nextSceneId = 318; + + if (_game._trigger == 81) { + _prisonerTimer = 0; + if (_activePrisonerFl && (_guardTime > 2600)) + _guardTime = 3000 - _vm->getRandomNumber(1, 800); + + _activePrisonerFl = false; + } +} + +void Scene307::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(30715); + else if (_game._screenObjects._inputMode == 1) + handleDialog(); + else if (_action.isAction(VERB_TALKTO, NOUN_CELL_WALL) || _action.isAction(VERB_TALKTO, NOUN_WALL) || _action.isAction(VERB_TALKTO, NOUN_TOILET)) { + int node, say; + if (_globals[kKnowsBuddyBeast]) { + say = 0x10E; + node = 16; + } else if (_globals[kMetBuddyBeast]) { + say = 0x10E; + node = 2; + } else { + say = 0x10D; + node = 1; + } + + switch (_game._trigger) { + case 0: + handleRexDialog(say); + break; + + case 1: + setDialogNode(node); + break; + } + } else if (_action.isAction(VERB_PRY, 0x12C, 0x11)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(239)); + _scene->_sequences.addTimer(120, 1); + break; + + case 1: + _globals._spriteIndexes[5] = _scene->_sprites.addSprites("*RXCL_8"); + _game._player._visible = false; + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], -1, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 2: { + int oldIdx = _globals._sequenceIndexes[5]; + _globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 12, 6, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 2, 3); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + } + break; + + case 3: { + int oldIdx = _globals._sequenceIndexes[5]; + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 1); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], oldIdx); + _scene->_sequences.addTimer(48, 4); + } + break; + + case 4: + _vm->_sound->command(26); + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 15); + _scene->_sequences.addTimer(90, 5); + break; + + case 5: + _vm->_sound->command(10); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(241)); + _scene->_sequences.addTimer(120, 6); + break; + + case 6: { + _game._player._visible = true; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _grateOpenedFl = true; + _scene->_hotspots.activate(17, false); + int idx = _scene->_dynamicHotspots.add(17, 0x2F7, -1, Common::Rect(117, 67, 117 + 19, 67 + 13)); + int hotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(129, 104), FACING_NORTH); + _scene->_dynamicHotspots.setCursor(hotspotId, CURSOR_GO_UP); + _game._objects.removeFromInventory(OBJ_SCALPEL, NOWHERE); + _scene->_kernelMessages.addQuote(0xF2, 120, 7); + } + break; + + case 7: + _scene->_sprites.remove(_globals._spriteIndexes[5]); + _game._player._stepEnabled = true; + break; + + default: + break; + } + }else if (_action.isAction(VERB_CLIMB_INTO, NOUN_AIR_VENT)) { + if (_grateOpenedFl) { + switch (_game._trigger) { + case 0: + _globals._spriteIndexes[5] = _scene->_sprites.addSprites("*RXCL_8"); + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 60, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 3, -2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 15); + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 18, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], -1, 4); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, -2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 15); + break; + + case 2: { + int oldIdx = _globals._sequenceIndexes[5]; + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 4, 10); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + } + break; + + case 3: + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 3); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 1); + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 11); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.setPosition(_globals._sequenceIndexes[5], Common::Point(129, 102)); + _scene->_sequences.addTimer(48, 4); + break; + + case 4: + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 1); + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 12, 14); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.setPosition(_globals._sequenceIndexes[5], Common::Point(129, 102)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 5); + break; + + case 5: + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 15); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.setPosition(_globals._sequenceIndexes[5], Common::Point(129, 102)); + _scene->_sequences.addTimer(48, 6); + break; + + case 6: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 1); + _scene->_sequences.addTimer(48, 7); + break; + + case 7: + _scene->_nextSceneId = 313; + break; + + default: + break; + } + } + } else if (_action.isAction(VERB_USE, NOUN_TOILET) && (_game._storyMode != STORYMODE_NAUGHTY)) + _vm->_dialogs->show(30723); + else if (_action.isAction(VERB_USE, NOUN_TOILET)) { + if (!_afterPeeingFl) { + switch (_game._trigger) { + case 0: + _vm->_sound->command(25); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('a', 0)); + _duringPeeingFl = true; + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], -1, 2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 9, 5, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 3, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[3]); + _game._player._visible = true; + _scene->_sequences.addTimer(48, 3); + break; + + case 3: { + _scene->_sprites.remove(_globals._spriteIndexes[3]); + _scene->_kernelMessages.reset(); + int idx = _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 4, 120, _game.getQuote(237)); + _scene->_kernelMessages.setQuoted(idx, 4, true); + } + break; + + case 4: + _game._player._stepEnabled = true; + _duringPeeingFl = false; + _afterPeeingFl = true; + break; + + default: + break; + } + } else { + _scene->_kernelMessages.reset(); + int idx = _scene->_kernelMessages.add(Common::Point(85, 39), 0x1110, 0, 0, 180, _game.getQuote(238)); + _scene->_kernelMessages.setQuoted(idx, 4, true); + } + } else if (_action.isAction(VERB_LOOK, NOUN_AIR_VENT)) { + if (!_grateOpenedFl) + _vm->_dialogs->show(30710); + else + _vm->_dialogs->show(30711); + } else if (_action.isAction(VERB_LOOK, NOUN_BED)) + _vm->_dialogs->show(30712); + else if (_action.isAction(VERB_LOOK, NOUN_SINK)) + _vm->_dialogs->show(30713); + else if (_action.isAction(VERB_LOOK, NOUN_TOILET)) + _vm->_dialogs->show(30714); + else if (_action.isAction(0x134, 0x12C)) + _vm->_dialogs->show(30716); + else if (_action.isAction(VERB_LOOK, NOUN_CELL_WALL)) + _vm->_dialogs->show(30717); + else if (_action.isAction(VERB_LOOK, NOUN_LIGHT)) + _vm->_dialogs->show(30718); + else if (_action.isAction(VERB_WALK_INTO, NOUN_CORRIDOR)) { + switch (_fieldCollisionCounter) { + case 0: + _vm->_dialogs->show(30719); + _fieldCollisionCounter = 1; + break; + + case 1: + _vm->_dialogs->show(30720); + _fieldCollisionCounter = 2; + break; + + case 2: + _vm->_dialogs->show(30721); + _fieldCollisionCounter = 3; + break; + + case 3: + _vm->_dialogs->show(30722); + break; + } + } else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene308::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene308::synchronize(Common::Serializer &s) { + Scene3xx::synchronize(s); + + _forceField.synchronize(s); +} + +void Scene308::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites("*SC003x0"); + _globals._spriteIndexes[0] = _scene->_sprites.addSprites("*SC003x1"); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*SC003x2"); + + initForceField(&_forceField, true); + + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('b', 0)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(Resources::formatName(307, 'X', 0, EXT_SS, "")); + + _vm->_palette->setEntry(252, 63, 30, 20); + _vm->_palette->setEntry(253, 45, 15, 12); + + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 15); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9); + _scene->_sequences.addTimer(48, 70); + + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->loadAnimation(formAnimName('a', -1), 60); + + sceneEntrySound(); + _game.loadQuoteSet(0xF4, 0xF5, 0xF6, 0); +} + +void Scene308::step() { + handleForceField(&_forceField, &_globals._spriteIndexes[0]); + + if (_game._trigger == 60) + _scene->_nextSceneId = 307; + + if (_game._trigger < 70) + return; + + switch (_game._trigger) { + case 70: { + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 18, 9, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 2, 3); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9); + _scene->_kernelMessages.reset(); + int idx = _scene->_kernelMessages.add(Common::Point(171, 21), 0xFDFC, 0, 0, 120, _game.getQuote(244)); + _scene->_kernelMessages.setQuoted(idx, 2, true); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + } + break; + + case 71: { + int seqIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], seqIdx); + _scene->_sequences.addTimer(48, 72); + } + break; + + case 72: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 20, 5, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 3, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9); + _scene->_kernelMessages.reset(); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 73); + break; + + case 73: { + int seqIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], seqIdx); + _scene->_sequences.addTimer(48, 74); + } + break; + + case 74: { + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 20, 8, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 6, 7); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9); + _scene->_kernelMessages.reset(); + int idx = _scene->_kernelMessages.add(Common::Point(171, 21), 0xFDFC, 0, 0, 120, _game.getQuote(245)); + _scene->_kernelMessages.setQuoted(idx, 2, true); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 75); + } + break; + + case 75: { + int seqIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 23, 5, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 8, 10); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], seqIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 76); + } + break; + + case 76: { + int seqIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 26, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 2, 3); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9); + _scene->_kernelMessages.reset(); + int idx = _scene->_kernelMessages.add(Common::Point(171, 21), 0xFDFC, 0, 0, 120, _game.getQuote(246)); + _scene->_kernelMessages.setQuoted(idx, 2, true); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], seqIdx); + } + break; + + default: + break; + } +} + +/*------------------------------------------------------------------------*/ + +Scene309::Scene309(MADSEngine *vm) : Scene3xx(vm) { + for (int i = 0; i < 3; i++) { + _characterSpriteIndexes[i] = -1; + _messagesIndexes[i] = -1; + } + + _lastFrame = -1; +} + +void Scene309::synchronize(Common::Serializer &s) { + Scene3xx::synchronize(s); + + _forceField.synchronize(s); + + for (int i = 0; i < 3; ++i) + s.syncAsSint32LE(_characterSpriteIndexes[i]); + for (int i = 0; i < 3; ++i) + s.syncAsSint32LE(_messagesIndexes[i]); + s.syncAsSint32LE(_lastFrame); +} + +void Scene309::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene309::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites("*SC003x0"); + _globals._spriteIndexes[0] = _scene->_sprites.addSprites("*SC003x1"); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*SC003x2"); + + initForceField(&_forceField, true); + + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(Resources::formatName(307, 'X', 0, EXT_SS, "")); + + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 15); + + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], -1, 3); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 3, 70); + + _vm->_palette->setEntry(252, 63, 37, 26); + _vm->_palette->setEntry(253, 45, 24, 17); + _vm->_palette->setEntry(16, 63, 63, 63); + _vm->_palette->setEntry(17, 45, 45, 45); + _vm->_palette->setEntry(250, 63, 20, 20); + _vm->_palette->setEntry(251, 45, 10, 10); + + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->loadAnimation(formAnimName('a', -1), 60); + + _characterSpriteIndexes[0] = _scene->_activeAnimation->_spriteListIndexes[2]; + _characterSpriteIndexes[1] = _scene->_activeAnimation->_spriteListIndexes[2]; + _characterSpriteIndexes[2] = _scene->_activeAnimation->_spriteListIndexes[1]; + + _messagesIndexes[0] = -1; + _messagesIndexes[1] = -1; + _messagesIndexes[2] = -1; + + sceneEntrySound(); + + _game.loadQuoteSet(0xF7, 0xF8, 0xF9, 0x15C, 0x15D, 0x15E, 0); +} + +void Scene309::step() { + handleForceField(&_forceField, &_globals._spriteIndexes[0]); + + if (_game._trigger == 61) { + _messagesIndexes[0] = -1; + _messagesIndexes[1] = -1; + } + + if (_game._trigger == 62) + _messagesIndexes[2] = -1; + + if (_scene->_activeAnimation != nullptr) { + if (_lastFrame != _scene->_activeAnimation->getCurrentFrame()) { + _lastFrame = _scene->_activeAnimation->getCurrentFrame(); + if (_lastFrame == 39) { + _messagesIndexes[0] = _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 32, 61, 210, _game.getQuote(348)); + _messagesIndexes[1] = _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 32, 0, 210, _game.getQuote(349)); + } + + if (_lastFrame == 97) + _messagesIndexes[2] = _scene->_kernelMessages.add(Common::Point(0, 0), 0xFBFA, 32, 62, 180, _game.getQuote(350)); + + for (int charIdx = 0; charIdx < 3; charIdx++) { + if (_messagesIndexes[charIdx] >= 0) { + bool match = false; + int j = -1; + for (j = _scene->_activeAnimation->_oldFrameEntry; j < _scene->_activeAnimation->_header._frameEntriesCount; j++) { + if (_scene->_activeAnimation->_frameEntries[j]._spriteSlot._spritesIndex == _characterSpriteIndexes[charIdx]) { + match = true; + break; + } + } + + if (match) { + SpriteSlotSubset *curSpriteSlot = &_scene->_activeAnimation->_frameEntries[j]._spriteSlot; + _scene->_kernelMessages._entries[_messagesIndexes[charIdx]]._position.x = curSpriteSlot->_position.x; + _scene->_kernelMessages._entries[_messagesIndexes[charIdx]]._position.y = curSpriteSlot->_position.y - (50 + (14 * ((charIdx == 0) ? 2 : 1))); + } + } + } + } + } + + if (_game._trigger >= 70) { + switch (_game._trigger) { + case 70: { + int idx = _scene->_dynamicHotspots.add(689, 690, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(142, 146), FACING_NORTHEAST); + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 4, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 2, 3); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + } + break; + + case 71: { + int _oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 4, 7); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], _oldIdx); + int idx = _scene->_kernelMessages.add(Common::Point(85, 37), 0xFDFC, 0, 0, 120, _game.getQuote(248)); + _scene->_kernelMessages.setQuoted(idx, 2, true); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + } + break; + + case 72: { + int _oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 8, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 8, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], _oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 73); + } + break; + + case 73: { + int _oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 12, 20); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], _oldIdx); + int idx = _scene->_kernelMessages.add(Common::Point(170, 49), 0xFDFC, 0, 0, 120, _game.getQuote(249)); + _scene->_kernelMessages.setQuoted(idx, 2, true); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 74); + } + break; + + case 74: { + int _oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 6, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 21, 23); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], _oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 75); + } + break; + + case 75: { + int _oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 6, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 24, 25); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], _oldIdx); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 76); + } + break; + + case 76: { + int _oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 26, 28); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], _oldIdx); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 77); + } + break; + + case 77: { + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 90, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 29, 30); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 11); + int idx = _scene->_kernelMessages.add(Common::Point(15, 46), 0xFDFC, 0, 0, 120, _game.getQuote(247)); + _scene->_kernelMessages.setQuoted(idx, 2, true); + _scene->_sequences.addTimer(120, 78); + } + break; + } + } + + if (_game._trigger == 60) + _scene->_nextSceneId = 308; +} + +/*------------------------------------------------------------------------*/ + +void Scene310::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene310::synchronize(Common::Serializer &s) { + Scene3xx::synchronize(s); + + _forceField.synchronize(s); +} + +void Scene310::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites("*SC003x0"); + _globals._spriteIndexes[0] = _scene->_sprites.addSprites("*SC003x1"); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*SC003x2"); + + initForceField(&_forceField, true); + + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(Resources::formatName(307, 'X', 0, EXT_SS, "")); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[3], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 15); + + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->loadAnimation(formAnimName('a', -1), 70); + + sceneEntrySound(); +} + +void Scene310::step() { + handleForceField(&_forceField, &_globals._spriteIndexes[0]); + + if (_game._trigger == 70) + _scene->_nextSceneId = 309; +} + +/*------------------------------------------------------------------------*/ + +Scene311::Scene311(MADSEngine *vm) : Scene3xx(vm) { + _checkGuardFl = false; +} + +void Scene311::synchronize(Common::Serializer &s) { + Scene3xx::synchronize(s); + + s.syncAsByte(_checkGuardFl); +} + +void Scene311::setup() { + if (_scene->_currentSceneId == 391) + _globals[kSexOfRex] = REX_MALE; + + setPlayerSpritesPrefix(); + setAAName(); + + if (_scene->_currentSceneId == 304) + _game._player._spritesPrefix = ""; +} + +void Scene311::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(Resources::formatName(307, 'X', 0, EXT_SS, "")); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*RXCL_8"); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*RXCL_2"); + + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + + _checkGuardFl = false; + _game.loadQuoteSet(0xFA, 0); + + if (_scene->_priorSceneId == 391) { + _globals[kSexOfRex] = REX_MALE; + _game._player._stepEnabled = false; + _game._player._visible = false; + _game._player._facing = FACING_SOUTH; + _game._player._playerPos = Common::Point(166, 101); + _scene->_sequences.addTimer(120, 71); + } else if (_scene->_priorSceneId == 310) + _game._player._playerPos = Common::Point(302, 145); + else if (_scene->_priorSceneId == 320) { + _game._player._playerPos = Common::Point(129, 113); + _game._player._facing = FACING_SOUTH; + } else if (_scene->_priorSceneId != -2) { + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->loadAnimation(formAnimName('a', -1), 70); + } + + sceneEntrySound(); +} + +void Scene311::step() { + if (_game._trigger == 70) + _scene->_nextSceneId = 310; + + if (_game._trigger >= 71) { + switch (_game._trigger) { + case 71: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addTimer(15, 72); + break; + + case 72: + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addTimer(15, 73); + break; + + case 73: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 3); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addTimer(15, 74); + break; + + case 74: + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 4, 5); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 75); + break; + + case 75: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 6); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addTimer(15, 76); + } + break; + + case 76: + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 7); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addTimer(15, 77); + break; + + case 77: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 8); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addTimer(15, 78); + break; + + case 78: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 9); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addTimer(15, 79); + break; + + case 79: + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 10, -2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 80); + break; + + case 80: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[3]); + _game._player._stepEnabled = true; + _game._player._visible = true; + break; + + default: + break; + } + } + + if (_game._player._moving && (_scene->_rails.getNext() > 0)) { + int x = _game._player._prepareWalkPos.x; + if (x < 75) + x = 75; + if (x > 207) + x = 207; + + _checkGuardFl = true; + _game._player.startWalking(Common::Point(x, 122), FACING_SOUTH); + _scene->_rails.resetNext(); + } +} + +void Scene311::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(31119); + else if (_checkGuardFl) { + _checkGuardFl = false; + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.addQuote(0xFA, 120, 0); + } else if (_action.isAction(VERB_SIT_AT, NOUN_DESK)) + _scene->_nextSceneId = 320; + else if (_action.isAction(VERB_CLIMB_INTO, NOUN_AIR_VENT)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 50, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 3, -2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 15, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], -1, 4); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: { + int oldIdx = _globals._sequenceIndexes[1]; + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[1], oldIdx); + } + break; + + case 2: { + int oldIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 4, 10); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + } + break; + + case 3: { + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 3); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + int oldIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 11); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(167, 100)); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], oldIdx); + _scene->_sequences.addTimer(15, 4); + } + break; + + case 4: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 12, 14); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(167, 100)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 5); + break; + + case 5: { + int oldIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 15); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(167, 100)); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], oldIdx); + _scene->_sequences.addTimer(15, 6); + } + break; + + case 6: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _scene->_sequences.addTimer(15, 7); + break; + + case 7: + _scene->_nextSceneId = 313; + break; + + default: + break; + } + } else if (_action.isAction(VERB_LOOK, NOUN_DESK)) + _vm->_dialogs->show(31110); + else if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(31111); + else if (_action.isAction(VERB_LOOK, NOUN_LIGHTING_FIXTURE) || _action.isAction(VERB_STARE_AT, NOUN_LIGHTING_FIXTURE)) + _vm->_dialogs->show(31112); + else if (_action.isAction(VERB_LOOK, NOUN_LIGHTS) || _action.isAction(VERB_STARE_AT, NOUN_LIGHTS)) + _vm->_dialogs->show(31113); + else if (_action.isAction(VERB_TAKE, NOUN_LIGHTS)) + _vm->_dialogs->show(31114); + else if (_action.isAction(VERB_LOOK, NOUN_LIGHT) || _action.isAction(VERB_STARE_AT, NOUN_LIGHT)) + _vm->_dialogs->show(31115); + else if (_action.isAction(VERB_TAKE, NOUN_LIGHT)) + _vm->_dialogs->show(31116); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_WEST)) + _vm->_dialogs->show(31117); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_EAST)) + _vm->_dialogs->show(31118); + else if (_action.isAction(VERB_LOOK, NOUN_AIR_VENT)) + _vm->_dialogs->show(31120); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene313::setup() { + setPlayerSpritesPrefix(); + _game._player._spritesPrefix = "RM313A"; + setAAName(); +} + +void Scene313::enter() { + _scene->_userInterface.setup(kInputLimitedSentences); + + if ((_scene->_priorSceneId == 366) || (_scene->_priorSceneId == 316)) { + _game._player._playerPos = Common::Point(30, 80); + _game._player._facing = FACING_NORTH; + } else if ((_scene->_priorSceneId == 311) || (_scene->_priorSceneId == 361) || (_scene->_priorSceneId == 391)) { + _game._player._playerPos = Common::Point(90, 70); + _game._player._facing = FACING_EAST; + } else if (_scene->_priorSceneId == 390) { + _game._player._playerPos = Common::Point(126, 70); + _game._player._facing = FACING_EAST; + } else if ((_scene->_priorSceneId == 389) || (_scene->_priorSceneId == 399)) { + _game._player._playerPos = Common::Point(163, 70); + _game._player._facing = FACING_WEST; + } else if (_scene->_priorSceneId == 388) { + _game._player._playerPos = Common::Point(199, 70); + _game._player._facing = FACING_WEST; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(234, 70); + _game._player._facing = FACING_WEST; + } + + if (_globals[kAfterHavoc]) { + for (uint16 i = 0; i < _scene->_paletteCycles.size(); i++) { + int palIdx = _scene->_paletteCycles[i]._firstColorIndex; + int size = _scene->_paletteCycles[i]._colorCount * 3; + memset(&_vm->_palette->_cyclingPalette[palIdx], 0, size); + memset(&_vm->_palette->_mainPalette[palIdx], 0, size); + } + } + + sceneEntrySound(); +} + +void Scene313::actions() { + if (_action.isAction(VERB_CRAWL_TO, NOUN_FOURTH_CELL)) + _scene->_nextSceneId = 387; + else if (_action.isAction(VERB_CRAWL_TO, NOUN_THIRD_CELL)) + _scene->_nextSceneId = 388; + else if (_action.isAction(VERB_CRAWL_TO, NOUN_SECOND_CELL)) { + if (_globals[kAfterHavoc]) + _scene->_nextSceneId = 399; + else + _scene->_nextSceneId = 389; + } else if (_action.isAction(VERB_CRAWL_TO, NOUN_FIRST_CELL)) + _scene->_nextSceneId = 390; + else if (_action.isAction(VERB_CRAWL_TO, NOUN_SECURITY_STATION)) { + if (_globals[kSexOfRex] == REX_FEMALE) { + _globals[kSexOfRex] = REX_MALE; + _vm->_dialogs->show(31301); + } + _scene->_nextSceneId = 391; + } else if (_action.isAction(VERB_CRAWL_TO, NOUN_EQUIPMENT_ROOM)) { + if (_globals[kSexOfRex] == REX_FEMALE) { + _globals[kSexOfRex] = REX_MALE; + _vm->_dialogs->show(31301); + } + _scene->_nextSceneId = 366; + } else if (!_action.isAction(0x301, 0x2D4)) + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene316::setup() { + if (_scene->_currentSceneId == 366) + _globals[kSexOfRex] = REX_MALE; + + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene316::handleRexInGrate() { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addTimer(15, 1); + break; + + case 1: + _scene->_sequences.setDone(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 12, 3, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 2, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 2: { + int oldIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 4, 8); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx); + + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 2, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 12); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 4); + } + break; + + case 3: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 12); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + } + break; + + case 4: { + int oldIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 10, 11); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx); + + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 5, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 5); + } + break; + + case 5: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 3); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + + oldIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 12); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], oldIdx); + _scene->_sequences.addTimer(15, 6); + } + break; + + case 6: + _scene->_sequences.setDone(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 13, 14); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 2, 3); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 7); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 8); + break; + + case 7: + _scene->_sequences.setDone(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 15); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], -1); + break; + + case 8: { + int oldIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], oldIdx); + _scene->_sequences.addTimer(15, 9); + } + break; + + case 9: + _scene->_sequences.setDone(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.addTimer(48, 10); + break; + + case 10: + _scene->_nextSceneId = 313; + break; + + default: + break; + } +} + +void Scene316::handleRoxInGrate() { + int temp; + int temp1; + + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 1); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.addTimer(15, 1); + break; + + case 1: + _scene->_sequences.setDone(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 17, 3, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 2, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 2: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 17, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 2, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 12); + + temp = _globals._sequenceIndexes[5]; + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 17, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 4, 8); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], temp); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 4); + break; + + case 3: + temp1 = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 12); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], temp1); + break; + + case 4: + temp = _globals._sequenceIndexes[5]; + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 17, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 10, 11); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], temp); + + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 17, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 5, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 5); + break; + + case 5: + temp = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 3); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], temp); + + temp = _globals._sequenceIndexes[5]; + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 12); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], temp); + _scene->_sequences.addTimer(20, 6); + break; + + case 6: + _scene->_sequences.setDone(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 17, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 13, 15); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 17, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 2, 3); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 7); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 8); + break; + + case 7: + _scene->_sequences.setDone(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 16); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], -1); + break; + + case 8: + temp = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], temp); + _scene->_sequences.addTimer(20, 9); + break; + + case 9: + _scene->_sequences.setDone(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.addTimer(48, 10); + break; + + case 10: + _scene->_nextSceneId = 313; + break; + + default: + break; + } +} + +void Scene316::enter() { + if (_globals[kSexOfRex] == REX_MALE) { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('g', -1)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*RXCL_8"); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites("*RXCL_2"); + } else { + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('g', 0)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites("*ROXCL_8"); + } + + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('v', 0)); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 12); + + if (_scene->_priorSceneId == 366) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _game._player._playerPos = Common::Point(78, 87); + _game._player._facing = FACING_SOUTH; + _scene->_sequences.addTimer(48, 70); + } else if (_scene->_priorSceneId == 321) { + _game._player._playerPos = Common::Point(153, 102); + _game._player._facing = FACING_SOUTH; + _game._player._stepEnabled = false; + _game._player._visible = false; + _vm->_sound->command(44); + int spriteIdx = (_globals[kSexOfRex] == REX_MALE) ? 1 : 2; + _globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[spriteIdx], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 60); + } else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(291, 126); + + sceneEntrySound(); + _game.loadQuoteSet(0xFD, 0); +} + +void Scene316::step() { + if (_game._trigger == 60) { + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[1]); + _game._player._visible = true; + _game._player._stepEnabled = true; + } + + if (_game._trigger >= 70) { + switch (_game._trigger) { + case 70: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 2, 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 1, 5); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[6]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + break; + + case 71: { + int synxIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], synxIdx); + } + break; + + case 72: { + int synxIdx = _globals._sequenceIndexes[6]; + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 6, 9); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[6]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[6], synxIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 73); + } + break; + + case 73: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 12); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[6]); + + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 10, -2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[6]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 74); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 75); + break; + + case 74: { + int synxIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 12); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], synxIdx); + } + break; + + case 75: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[6]); + _game._player._stepEnabled = true; + _game._player._visible = true; + break; + + default: + break; + } + } +} + +void Scene316::preActions() { + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_EAST)) { + if (_globals[kAfterHavoc]) + _game._player._walkOffScreenSceneId = 354; + else + _game._player._walkOffScreenSceneId = 304; + } +} + +void Scene316::actions() { + if (_action.isAction(VERB_CLIMB_INTO, NOUN_AIR_VENT)) { + if (_globals[kSexOfRex] == REX_FEMALE) + handleRoxInGrate(); + else + handleRexInGrate(); + } else if (_action.isAction(VERB_WALK_UP, NOUN_RAMP) || _action.isAction(VERB_WALK_ONTO, NOUN_PLATFORM)) { + switch (_game._trigger) { + case 0: + if (_globals[kCityFlooded]) { + _vm->_dialogs->show(31623); + } else { + _vm->_sound->command(45); + _game._player._stepEnabled = false; + _game._player._visible = false; + if (_globals[kSexOfRex] == REX_MALE) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], -1, 7); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + } else { + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + } + } + break; + + case 1: + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 8, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 2); + _scene->_kernelMessages.reset(); + if (!_game._visitedScenes.exists(321)) + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(253)); + + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 2: + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 7, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], -2, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 2); + _scene->_sequences.addTimer(48, 4); + break; + + case 3: + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 7, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], -2, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 2); + _scene->_sequences.addTimer(48, 4); + break; + + case 4: + _scene->_nextSceneId = 321; + break; + } + } else if (_action.isAction(VERB_LOOK, NOUN_PLATFORM)) + _vm->_dialogs->show(31610); + else if (_action.isAction(VERB_LOOK, NOUN_STRANGE_DEVICE)) { + if (_game._visitedScenes.exists(321)) + _vm->_dialogs->show(31612); + else + _vm->_dialogs->show(31611); + } else if (_action.isAction(VERB_LOOK, NOUN_CONTROLS)) + _vm->_dialogs->show(31613); + else if (_action.isAction(VERB_LOOK, NOUN_EQUIPMENT)) + _vm->_dialogs->show(31614); + else if (_action.isAction(VERB_LOOK, NOUN_PANEL)) + _vm->_dialogs->show(31615); + else if (_action.isAction(VERB_LOOK, NOUN_MONITOR)) + _vm->_dialogs->show(31616); + else if (_action.isAction(VERB_LOOK, NOUN_RAMP)) + _vm->_dialogs->show(31617); + else if (_action.isAction(VERB_LOOK, NOUN_AIR_VENT)) + _vm->_dialogs->show(31618); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_EAST)) { + if (!_globals[kAfterHavoc]) { + if (_game._difficulty != DIFFICULTY_EASY) + _vm->_dialogs->show(31620); + else + _vm->_dialogs->show(31619); + } + } else if (_action.isAction(VERB_LOOK, NOUN_FLOOR)) + _vm->_dialogs->show(31621); + else if (_action.isAction(VERB_LOOK, NOUN_SUPPORT)) + _vm->_dialogs->show(31622); + else + return; + + _action._inProgress = false; +} + + +/*------------------------------------------------------------------------*/ + +Scene318::Scene318(MADSEngine *vm) : Scene3xx(vm) { + _dropTimer = 0; + + _lastFrame = -1; + _animMode = -1; + _internCounter = -1; + _counter = -1; + + _dialogFl = false; + _internTalkingFl = false; + _internWalkingFl = false; + _internVisibleFl = false; + _explosionFl = false; + + _lastFrameCounter = 0; + + _subQuote2 = ""; +} + +void Scene318::synchronize(Common::Serializer &s) { + Scene3xx::synchronize(s); + + s.syncAsUint32LE(_dropTimer); + + s.syncAsSint32LE(_lastFrame); + s.syncAsSint32LE(_animMode); + s.syncAsSint32LE(_internCounter); + s.syncAsSint32LE(_counter); + + s.syncAsByte(_dialogFl); + s.syncAsByte(_internTalkingFl); + s.syncAsByte(_internWalkingFl); + s.syncAsByte(_internVisibleFl); + s.syncAsByte(_explosionFl); + + s.syncAsUint32LE(_lastFrameCounter); + + s.syncString(_subQuote2); +} + +void Scene318::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene318::handleDialog() { + if (!_game._trigger) { + _game._player._stepEnabled = false; + handleRexDialogs(_action._activeAction._verbId); + } else if (_game._trigger == 2) { + int synxIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(142, 121)); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], synxIdx); + _vm->_sound->command(3); + _scene->_userInterface.setup(kInputLimitedSentences); + _game._player._stepEnabled = true; + } else { + if (_action._activeAction._verbId < 0x19C) + _dialog1.write(_action._activeAction._verbId, false); + + switch (_action._activeAction._verbId) { + case 0x191: + handleInternDialog(0x19E, 2, 9999999); + _dialog1.write(0x192, true); + break; + + case 0x192: + handleInternDialog(0x1A0, 5, 9999999); + _dialog1.write(0x193, true); + break; + + case 0x193: + handleInternDialog(0x1A5, 4, 9999999); + _dialog1.write(0x194, true); + break; + + case 0x194: + handleInternDialog(0x1A9, 6, 9999999); + _dialog1.write(0x195, true); + _dialog1.write(0x196, true); + _dialog1.write(0x19D, false); + break; + + case 0x195: + handleInternDialog(0x1AF, 7, 9999999); + if (!_dialog1.read(0x196)) + _dialog1.write(0x197, true); + break; + + case 0x196: + handleInternDialog(0x1B6, 5, 9999999); + if (!_dialog1.read(0x195)) + _dialog1.write(0x197, true); + break; + + case 0x197: + handleInternDialog(0x1BB, 5, 9999999); + break; + + case 0x198: + handleInternDialog(0x1C0, 5, 9999999); + _dialog1.write(0x19A, true); + break; + + case 0x199: + handleInternDialog(0x1C5, 3, 9999999); + break; + + case 0x19A: + handleInternDialog(0x1C8, 5, 9999999); + _dialog1.write(0x19B, true); + break; + + case 0x19B: + handleInternDialog(0x1CD, 3, 9999999); + break; + + case 0x19C: + case 0x19D: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(142, 121)); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 6, 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + + _dialogFl = false; + handleInternDialog(0x1D0, 1, 120); + if (_dialog1.read(0) || (_action._activeAction._verbId == 0x19D)) { + _explosionFl = true; + _internCounter = 3420; + } + break; + } + + if (_action._activeAction._verbId < 0x19C) { + _dialog1.start(); + _game._player._stepEnabled = true; + } + + } +} + +void Scene318::handleRexDialogs(int quote) { + _scene->_kernelMessages.reset(); + + Common::String curQuote = _game.getQuote(quote); + if (_vm->_font->getWidth(curQuote, _scene->_textSpacing) > 200) { + Common::String subQuote1; + _game.splitQuote(curQuote, subQuote1, _subQuote2); + _scene->_kernelMessages.add(Common::Point(138, 59), 0x1110, 32, 0, 240, subQuote1); + _scene->_kernelMessages.add(Common::Point(138, 73), 0x1110, 32, 1, 180, _subQuote2); + } else + _scene->_kernelMessages.add(Common::Point(138, 73), 0x1110, 32, 1, 120, curQuote); +} + +void Scene318::handleInternDialog(int quoteId, int quoteNum, uint32 timeout) { + int height = quoteNum * 14; + int posY; + if (height < 85) + posY = 87 - height; + else + posY = 2; + + int curQuoteId= quoteId; + + int maxWidth = 0; + for (int i = 0; i < quoteNum; i++) { + maxWidth = MAX(maxWidth, _vm->_font->getWidth(_game.getQuote(curQuoteId), -1)); + curQuoteId++; + } + + int posX = MIN(319 - maxWidth, 178 - (maxWidth >> 1)); + curQuoteId = quoteId; + + _scene->_kernelMessages.reset(); + _internTalkingFl = true; + + for (int i = 0; i < quoteNum; i++) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(180, 63); + _scene->_kernelMessages.add(Common::Point(posX, posY), 0xFDFC, 0, 0, timeout, _game.getQuote(curQuoteId)); + posY += 14; + curQuoteId++; + } +} + +void Scene318::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('k', -1)); + + if (_globals[kAfterHavoc]) { + _scene->loadAnimation(formAnimName('f', -1)); + _scene->_activeAnimation->_resetFlag = true; + } else if (!_globals[kHasSeenProfPyro]) { + _scene->_hotspots.activate(NOUN_PROFESSORS_GURNEY, false); + _scene->_hotspots.activate(NOUN_PROFESSOR, false); + _scene->_hotspots.activate(NOUN_TAPE_PLAYER, false); + } + + if (_game._objects.isInRoom(OBJ_SCALPEL)) { + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 6, 0, 0, 120); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 4); + _scene->_dynamicHotspots.add(NOUN_SCALPEL, VERB_TAKE, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + } + + if (_scene->_priorSceneId == 357) + _game._player._playerPos = Common::Point(15, 110); + else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(214, 152); + + _dialog1.setup(0x47, 0x191, 0x192, 0x193, 0x194, 0x195, 0x196, 0x197, 0x198, 0x199, 0x19A, 0x19B, 0x19C, 0x19D, 0); + + if (!_game._visitedScenes._sceneRevisited) { + _dialog1.set(0x191, 0x198, 0x199, 0x19C, 0); + if (_game._widepipeCtr >= 2) + _dialog1.write(0x19D, true); + } + + if (_scene->_priorSceneId == 307) { + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->loadAnimation(formAnimName('a', -1), 60); + _animMode = 1; + } + + _lastFrame = 0; + _scene->_hotspots.activate(NOUN_INTERN, false); + + if (_scene->_priorSceneId != -2) { + _dialogFl = false; + _internWalkingFl = false; + _counter= 0; + _internCounter= 0; + _internVisibleFl = true; + _explosionFl = false; + } + + _game.loadQuoteSet(0x18C, 0x18D, 0x18E, 0x18F, 0x191, 0x192, 0x193, 0x194, 0x195, 0x196, + 0x197, 0x198, 0x199, 0x19A, 0x19B, 0x19C, 0x19E, 0x19E, 0x1A0, 0x1A1, 0x1A2, 0x1A3, + 0x1A4, 0x1A5, 0x1A6, 0x1A7, 0x1A8, 0x1A9, 0x1AA, 0x1AB, 0x1AC, 0x1AD, 0x1AE, 0x1AF, + 0x1B0, 0x1B1, 0x1B2, 0x1B3, 0x1B4, 0x1B5, 0x1B6, 0x1B7, 0x1B8, 0x1B9, 0x1BA, 0x1BB, + 0x1BC, 0x1BD, 0x1BE, 0x1BF, 0x1C0, 0x1C1, 0x1C2, 0x1C3, 0x1C4, 0x1C5, 0x1C6, 0x1C7, + 0x1C8, 0x1C9, 0x1CA, 0x1CB, 0x1CC, 0x1CD, 0x1CE, 0x1CF, 0x1D0, 0x1D1, 0x1D2, 0x1D3, + 0x190, 0x19D, 0); + + if ((_scene->_priorSceneId== -2) || (((_scene->_priorSceneId == 318) || (_scene->_priorSceneId == -1)) && (!_globals[kAfterHavoc]))) { + if (!_globals[kAfterHavoc]) { + _game._player._visible = false; + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('g', -1)); + _animMode = 2; + + if (_game._visitedScenes.exists(319) || !_internVisibleFl) { + _internVisibleFl = false; + _dialogFl = false; + } else { + _scene->loadAnimation(formAnimName('b', -1), 61); + _scene->_hotspots.activate(NOUN_INTERN, true); + } + + if (_dialogFl) { + _dialog1.start(); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 8); + } else + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(142, 121)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + } + } + + if (_scene->_priorSceneId == 319) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _animMode = 4; + if (!_globals[kHasSeenProfPyro]) { + _scene->loadAnimation(formAnimName('d', -1), 64); + _globals[kHasSeenProfPyro] = true; + } else { + _scene->loadAnimation(formAnimName('e', -1), 64); + } + } + + _internTalkingFl = false; + _vm->_palette->setEntry(252, 63, 63, 10); + _vm->_palette->setEntry(253, 45, 45, 05); + + _dropTimer = _vm->_game->_scene._frameStartTime; + sceneEntrySound(); + + if (_dialogFl) + _vm->_sound->command(15); +} + +void Scene318::step() { + if ((_scene->_activeAnimation != nullptr) && (_animMode == 2)) { + if (_lastFrame != _scene->_activeAnimation->getCurrentFrame()) { + _lastFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextFrame = -1; + + switch (_lastFrame) { + case 20: + case 30: + case 40: + case 50: + case 60: + case 70: + case 80: + case 90: + case 100: + case 110: + case 120: + case 130: + case 140: + case 149: + if (_internWalkingFl) { + nextFrame = 149; + } else if (_internTalkingFl) { + nextFrame = 149; + } else if (_lastFrame == 149) { + nextFrame = 4; + } + break; + + case 151: + if (_internWalkingFl) + nextFrame = 183; + break; + + case 167: + case 184: + if (_internWalkingFl) { + nextFrame = 184; + } else if (!_internTalkingFl) { + nextFrame = 0; + } else if (_vm->getRandomNumber(1, 100) <= 50) { + nextFrame = 151; + } else { + nextFrame = 167; + } + + if (nextFrame == 184) { + handleInternDialog(0x1D1, 3, 240); + _scene->_hotspots.activate(NOUN_INTERN, false); + _internVisibleFl = false; + } + break; + } + + if ((nextFrame >= 0) && (nextFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextFrame); + _lastFrame = nextFrame; + } + } + } + + switch (_game._trigger) { + case 60: + _vm->_sound->command(3); + _animMode = 2; + _scene->_reloadSceneFlag = true; + break; + + case 61: + _counter = 0; + break; + + case 62: + _scene->_nextSceneId = 319; + break; + + case 63: + _internTalkingFl = false; + break; + + case 64: + _vm->_sound->command(3); + _scene->_nextSceneId = 307; + break; + } + + uint32 tmpFrame = _vm->_events->getFrameCounter(); + long diffFrame = tmpFrame - _lastFrameCounter; + _lastFrameCounter = tmpFrame; + + if ((_animMode == 2) && !_internVisibleFl && _game._player._stepEnabled) { + if ((diffFrame >= 0) && (diffFrame <= 4)) + _counter += diffFrame; + else + _counter++; + + int extraCounter = _game._objects.isInInventory(OBJ_SCALPEL) ? 900 : 0; + + if (_counter + extraCounter >= 1800) { + _scene->freeAnimation(); + _game._player._stepEnabled = false; + _scene->loadAnimation(formAnimName('c', -1), 62); + _animMode = 3; + } + } else if ((_animMode == 2) && _explosionFl && _internVisibleFl && !_dialogFl + && !_internWalkingFl && (_game._screenObjects._inputMode != 1)) { + if ((diffFrame >= 0) && (diffFrame <= 4)) + _internCounter += diffFrame; + else + _internCounter++; + + if (_internCounter >= 3600) { + _vm->_sound->command(59); + _vm->_screen._shakeCountdown = 20; + _internWalkingFl = true; + } + } + + if ((_vm->_game->_scene._frameStartTime - _dropTimer) > 600) { + _vm->_sound->command(51); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 14, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _dropTimer = _vm->_game->_scene._frameStartTime; + } +} + +void Scene318::preActions() { + if (_game._player._needToWalk) + _game._player._needToWalk = _game._player._visible; + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_WEST)) + _game._player._walkOffScreenSceneId = 357; +} + +void Scene318::actions() { + if (_game._screenObjects._inputMode == 1) { + handleDialog(); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TALKTO, NOUN_INTERN)) { + switch (_game._trigger) { + case 0: { + _dialogFl = true; + _vm->_sound->command(15); + _game._player._stepEnabled = false; + handleRexDialogs(_vm->getRandomNumber(0x18C, 0x18E)); + + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 80); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(142, 121)); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 6, 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } + break; + + case 1: + _game._player._stepEnabled = true; + handleInternDialog(0x18F, 1, 9999999); + _dialog1.start(); + break; + + case 2: { + int oldIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 8); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(142, 121)); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], oldIdx); + } + break; + + default: + break; + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_SCALPEL) && (_game._objects.isInRoom(OBJ_SCALPEL) || _game._trigger)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 8, 2, 0, 80); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(142, 121)); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 2, 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 5, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + if (_internVisibleFl) + handleInternDialog(0x190, 1, 120); + else { + _game._objects.addToInventory(OBJ_SCALPEL); + _vm->_dialogs->showItem(OBJ_SCALPEL, 0x7C5D); + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + } + break; + + case 2: { + int oldIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(142, 121)); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], oldIdx); + _scene->_sequences.addTimer(60, 3); + } + break; + + case 3: + _game._player._stepEnabled = true; + break; + } + _action._inProgress = false; + return; + } + + if (_game._player._visible) { + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_SOUTH)) { + _scene->_nextSceneId = 407; + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_TAPE_PLAYER)) { + if (_game._objects.isInRoom(OBJ_AUDIO_TAPE)) { + _vm->_dialogs->showItem(OBJ_AUDIO_TAPE, 0x7C5B); + _game._objects.addToInventory(OBJ_AUDIO_TAPE); + } else + _vm->_dialogs->show(31834); + + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_TAPE_PLAYER)) { + if (_game._objects.isInRoom(OBJ_AUDIO_TAPE)) + _vm->_dialogs->show(31833); + else + _vm->_dialogs->show(31834); + + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_WALK_INTO, NOUN_DOCTORS_OFFICE)) { + _vm->_dialogs->show(31831); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_GURNEY)) { + _vm->_dialogs->show(31823); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_INSTRUMENT_TABLE)) { + _vm->_dialogs->show(31825); + _action._inProgress = false; + return; + } + } else { // Not visible + if (_action.isAction(VERB_LOOK, NOUN_GURNEY)) { + _vm->_dialogs->show(31822); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_INSTRUMENT_TABLE)) { + _vm->_dialogs->show(31824); + _action._inProgress = false; + return; + } + } + + if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(31810); + else if (_action.isAction(VERB_LOOK, NOUN_FLOOR)) + _vm->_dialogs->show(31811); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_WEST)) + _vm->_dialogs->show(31812); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_SOUTH)) + _vm->_dialogs->show(31813); + else if (_action.isAction(VERB_LOOK, NOUN_FAUCET)) + _vm->_dialogs->show(31814); + else if (_action.isAction(VERB_LOOK, NOUN_SINK)) + _vm->_dialogs->show(31815); + else if (_action.isAction(VERB_LOOK, NOUN_CONVEYOR_BELT)) + _vm->_dialogs->show(31816); + else if (_action.isAction(VERB_LOOK, NOUN_LARGE_BLADE)) + _vm->_dialogs->show(31817); + else if (_action.isAction(VERB_LOOK, NOUN_MONITOR)) + _vm->_dialogs->show(31818); + else if (_action.isAction(VERB_LOOK, NOUN_CABINETS)) + _vm->_dialogs->show(31819); + else if (_action.isAction(VERB_LOOK, NOUN_EQUIPMENT)) + _vm->_dialogs->show(31820); + else if (_action.isAction(VERB_LOOK, NOUN_SHELF)) + _vm->_dialogs->show(31821); + else if (_action.isAction(VERB_OPEN, NOUN_CABINETS)) + _vm->_dialogs->show(31829); + else if (_action.isAction(VERB_LOOK, NOUN_INTERN)) + _vm->_dialogs->show(31830); + else if (_action.isAction(VERB_LOOK, NOUN_PROFESSOR)) + _vm->_dialogs->show(31832); + else if (_action.isAction(VERB_LOOK, NOUN_PROFESSORS_GURNEY)) + _vm->_dialogs->show(31836); + else if (_action._lookFlag) { + if (_game._player._visible || _game._objects.isInInventory(OBJ_SCALPEL)) + _vm->_dialogs->show(31828); + else if (_internVisibleFl) + _vm->_dialogs->show(31826); + else + _vm->_dialogs->show(31827); + } else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene319::Scene319(MADSEngine *vm) : Scene3xx(vm) { + _animMode = -1; + _animFrame = -1; + _nextAction1 = -1; + _nextAction2 = -1; + _slacheMode = -1; + _slacheTopic = -1; + _slachePosY = -1; + + _slacheTalkingFl = false; + _slacheReady = false; + _slacheInitFl = false; + + _subQuote2 = ""; +} + +void Scene319::synchronize(Common::Serializer &s) { + Scene3xx::synchronize(s); + + s.syncAsUint32LE(_animMode); + s.syncAsUint32LE(_animFrame); + s.syncAsUint32LE(_nextAction1); + s.syncAsUint32LE(_nextAction2); + s.syncAsUint32LE(_slacheMode); + s.syncAsUint32LE(_slacheTopic); + s.syncAsUint32LE(_slachePosY); + + s.syncAsByte(_slacheTalkingFl); + s.syncAsByte(_slacheReady); + s.syncAsByte(_slacheInitFl); + + s.syncString(_subQuote2); +} + +void Scene319::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene319::handleRexDialogues(int quote) { + _scene->_kernelMessages.reset(); + + Common::String curQuote = _game.getQuote(quote); + if (_vm->_font->getWidth(curQuote, _scene->_textSpacing) > 200) { + Common::String subQuote1; + _game.splitQuote(curQuote, subQuote1, _subQuote2); + _scene->_kernelMessages.add(Common::Point(160, 106), 0x1110, 32, 0, 120, subQuote1); + _scene->_kernelMessages.add(Common::Point(160, 120), 0x1110, 32, 1, 120, _subQuote2); + } else + _scene->_kernelMessages.add(Common::Point(160, 120), 0x1110, 32, 1, 120, curQuote); +} + +void Scene319::handleSlacheDialogs(int quoteId, int counter, uint32 timer) { + int curQuote = quoteId; + int posY = 5 + (_slachePosY * 14); + + for (int count = 0; count < counter; count++, curQuote++) { + _scene->_kernelMessages.add(Common::Point(8, posY), 0xFDFC, 0, 0, timer, _game.getQuote(curQuote)); + posY += 14; + } +} + +void Scene319::enter() { + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('e', 0)); + _globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('a', 0)); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('a', 2)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('a', 3)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('k', -1)); + + if (!_game._objects.isInInventory(OBJ_SCALPEL)) { + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 1); + } + + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 18, 0, 0, 300); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 67, 0, 0, 377); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 173, 0, 0, 233); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 14); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 14); + + _globals._sequenceIndexes[0] = _scene->_sequences.startCycle(_globals._spriteIndexes[0], false, 1); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + + _dialog1.setup(0x43, 0x165, 0x166, 0x167, 0x168, 0x169, 0x16A, 0); + _dialog2.setup(0x44, 0x171, 0x172, 0x173, 0x174, 0x175, 0x176, 0); + _dialog3.setup(0x45, 0x17D, 0x17E, 0x17F, 0x180, 0x181, 0x182, 0x183, 0); + + if (_scene->_priorSceneId != -2) { + _dialog1.set(0x165, 0x166, 0x167, 0x168, 0); + _dialog2.set(0x171, 0x172, 0x173, 0x174, 0); + _dialog3.set(0x17D, 0x17E, 0x17F, 0x180, 0); + } + + _game.loadQuoteSet(0x15F, 0x160, 0x161, 0x162, 0x163, 0x164, 0x16B, 0x16C, 0x16D, + 0x16E, 0x16F, 0x170, 0x177, 0x178, 0x178, 0x17A, 0x17B, 0x17C, 0x165, 0x166, + 0x167, 0x168, 0x169, 0x16A, 0x171, 0x172, 0x173, 0x174, 0x175, 0x176, 0x17D, + 0x17E, 0x17F, 0x180, 0x181, 0x182, 0x183, 0x184, 0x185, 0x186, 0x187, 0x188, + 0x189, 0x18A, 0x18B, 0); + + _vm->_palette->setEntry(252, 63, 30, 2); + _vm->_palette->setEntry(253, 45, 15, 1); + + _slachePosY = 0; + _slacheInitFl = false; + _slacheTalkingFl = false; + _slacheReady = false; + _animFrame = 0; + + _scene->loadAnimation(formAnimName('b', 0)); + + if (_scene->_priorSceneId != -2) { + _animMode = 1; + _nextAction1 = 2; + _nextAction2 = 2; + _slacheMode = 1; + _slacheTopic = 1; + _slacheInitFl = true; + + if (_globals[kRexHasMetSlache]) { + handleSlacheDialogs(0x18A, 2, 9999999); + _slachePosY = 3; + } else { + handleSlacheDialogs(0x186, 4, 9999999); + _slachePosY = 5; + } + } + + switch (_slacheTopic) { + case 1: + handleSlacheDialogs(0x15F, 2, 9999999); + _dialog1.start(); + break; + + case 2: + handleSlacheDialogs(0x16B, 2, 9999999); + _dialog2.start(); + break; + + case 3: + handleSlacheDialogs(0x177, 2, 9999999); + _dialog3.start(); + break; + + default: + break; + } + + _slachePosY = 0; + sceneEntrySound(); +} + +void Scene319::step() { + if (_scene->_activeAnimation == nullptr) + return; + + if (_animFrame != _scene->_activeAnimation->getCurrentFrame()) { + _animFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextFrame = -1; + if (_animMode == 1) { + switch (_animFrame) { + case 6: + _slacheTalkingFl = true; + break; + + case 29: + _slacheReady = true; + break; + + case 39: + if (_slacheInitFl) { + _slacheInitFl = false; + if (_nextAction1 == 2) + nextFrame = 0; + } else if (_nextAction1 == 2) + _nextAction1 = 1; + break; + + case 50: + case 60: + case 70: + case 85: + if (_nextAction1 == 2) + nextFrame = 0; + else if (_nextAction1 == 3) { + nextFrame = 85; + _slacheTalkingFl = true; + } else if (_animFrame == 85) { + if (!_game._player._stepEnabled) + _slacheTalkingFl = true; + nextFrame = 40; + } + break; + + case 115: + _slacheReady = true; + break; + + case 129: + if (_nextAction1 == 3) { + nextFrame = 115; + if (!_game._player._stepEnabled) + _slacheTalkingFl = true; + } + break; + + case 145: + nextFrame = 40; + break; + + default: + break; + } + + if ((_animFrame > 40) && (_animFrame < 85) && (nextFrame < 0)) { + switch (_nextAction1) { + case 4: + _animFrame = 0; + _scene->freeAnimation(); + _animMode = 2; + _scene->loadAnimation(formAnimName('b', 3), 70); + break; + + case 5: + _animFrame = 0; + _scene->freeAnimation(); + _animMode = 3; + _scene->loadAnimation(formAnimName('b', 4), 71); + break; + + case 6: + _animFrame = 0; + _scene->freeAnimation(); + _animMode = 4; + _scene->loadAnimation(formAnimName('b', 5), 72); + break; + + default: + break; + } + + if (!_animFrame) { + _scene->_sequences.remove(_globals._sequenceIndexes[0]); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + + for (int i = 0; i <= 1; i++) { + _globals._sequenceIndexes[i] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[i], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[i], 1, 7); + } + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[0], SEQUENCE_TRIGGER_EXPIRE, 0, 73); + } + } + } + + if (_animMode == 2) { + if (_animFrame == 13) + _vm->_screen._shakeCountdown = 40; + + if (_animFrame == 16) + _vm->_screen._shakeCountdown = 1; + } + + if (_animMode == 3) { + if (_animFrame == 11) + _vm->_screen._shakeCountdown = 60; + + if (_animFrame == 18) + _vm->_screen._shakeCountdown = 1; + } + + if ((_animMode == 4) && (_animFrame == 16)) + _vm->_screen._shakeCountdown = 80; + + if ((nextFrame >= 0) && (nextFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextFrame); + _animFrame = nextFrame; + } + } + + switch (_game._trigger) { + case 70: + case 71: + _animMode = 1; + _nextAction1 = _nextAction2; + _animFrame = 0; + _scene->freeAnimation(); + _scene->loadAnimation(formAnimName('b', 0)); + if (_nextAction1 == 3) + _scene->_activeAnimation->setCurrentFrame(85); + else if (_nextAction1 == 1) + _scene->_activeAnimation->setCurrentFrame(40); + + _animFrame = _scene->_activeAnimation->getCurrentFrame(); + _slacheTalkingFl = true; + _vm->_screen._shakeCountdown = 1; + + for (int i = 0; i <= 1; i++) { + int oldIdx = _globals._sequenceIndexes[i]; + _scene->_sequences.remove(_globals._sequenceIndexes[i]); + _globals._sequenceIndexes[i] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[i], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[i], 8, 13); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[i], oldIdx); + } + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[0], SEQUENCE_TRIGGER_EXPIRE, 0, 74); + break; + + case 72: + _vm->_palette->setColorFlags(0xFF, 0, 0); + _vm->_palette->setColorValues(0, 0, 0); + _vm->_palette->fadeOut(_vm->_palette->_mainPalette, nullptr, 18, 228, + 248, 0, 1, 16); + _vm->_screen._shakeCountdown = 1; + _scene->_reloadSceneFlag = true; + break; + + case 73: + for (int i = 0; i <= 1; i++) { + int oldIdx = _globals._sequenceIndexes[i]; + _scene->_sequences.remove(_globals._sequenceIndexes[i]); + _globals._sequenceIndexes[i] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[i], false, 8, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[i], 6, 7); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[i], oldIdx); + } + break; + + case 74: + for (int i = 0; i <= 1; i++) { + int oldIdx = _globals._sequenceIndexes[i]; + _scene->_sequences.remove(_globals._sequenceIndexes[i]); + _globals._sequenceIndexes[i] = _scene->_sequences.startCycle(_globals._spriteIndexes[i], false, 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[i], oldIdx); + } + break; + + default: + break; + } +} + +void Scene319::actions() { + if (_game._trigger == 0) { + _game._player._stepEnabled = false; + handleRexDialogues(_action._activeAction._verbId); + } else { + if ((_action._activeAction._verbId == 0x165) || (_action._activeAction._verbId == 0x166)) { + if (_game._trigger == 1) { + _nextAction1 = 3; + _slacheTalkingFl = false; + _slacheMode = 1; + _slacheTopic = 2; + } + + if (!_slacheTalkingFl) { + _scene->_sequences.addTimer(4, 2); + } else { + handleSlacheDialogs(0x16B, 2, 9999999); + _dialog2.start(); + _game._player._stepEnabled = true; + } + } + + if ((_action._activeAction._verbId == 0x171) || (_action._activeAction._verbId == 0x172)) { + if (_game._trigger == 1) { + _nextAction1 = 2; + _slacheTalkingFl = false; + _slacheMode = 1; + _slacheTopic = 3; + } + + if (!_slacheTalkingFl) { + _scene->_sequences.addTimer(4, 2); + } else { + handleSlacheDialogs(0x177, 2, 9999999); + _dialog3.start(); + _game._player._stepEnabled = true; + } + } + + if ((_action._activeAction._verbId == 0x17D) || (_action._activeAction._verbId == 0x17E)) { + if (_game._trigger == 1) { + _nextAction1 = 3; + _slacheTalkingFl = false; + _slacheReady = false; + _slacheMode = 1; + _slacheTopic = 1; + } + + if (!_slacheTalkingFl) { + _scene->_sequences.addTimer(4, 2); + } else { + if (_game._trigger == 2) + handleSlacheDialogs(0x184, 2, 180); + + if (!_slacheReady) { + _scene->_sequences.addTimer(120, 3); + } else { + _globals[kRexHasMetSlache] = true; + _scene->_nextSceneId = 318; + } + } + } + + if ((_action._activeAction._verbId == 0x168) || (_action._activeAction._verbId == 0x174) || + (_action._activeAction._verbId == 0x180) || (_action._activeAction._verbId == 0x169) || + (_action._activeAction._verbId == 0x175) || (_action._activeAction._verbId == 0x181) || + (_action._activeAction._verbId == 0x16A) || (_action._activeAction._verbId == 0x176) || + (_action._activeAction._verbId == 0x182) || (_action._activeAction._verbId == 0x183) || + (_action._activeAction._verbId == 0x167) || (_action._activeAction._verbId == 0x173) || + (_action._activeAction._verbId == 0x17F)) { + + bool addDialogLine = !((_action._activeAction._verbId == 0x167) || (_action._activeAction._verbId == 0x173) || + (_action._activeAction._verbId == 0x17F) || (_action._activeAction._verbId == 0x16A) || + (_action._activeAction._verbId == 0x176) || (_action._activeAction._verbId == 0x182) || + (_action._activeAction._verbId == 0x183)); + + int addVerbId = _action._activeAction._verbId + 1; + if ((addVerbId == 0x182) && (_game._storyMode != STORYMODE_NAUGHTY)) + addVerbId = 0x183; + + if (_slacheMode == 1) { + if (_game._trigger == 1) { + _nextAction2 = _nextAction1; + _nextAction1 = 4; + } + + if (_nextAction1 != _nextAction2) { + _scene->_sequences.addTimer(4, 2); + } else { + Conversation *curDialog; + int nextDocQuote; + if ((_action._activeAction._verbId == 0x168) || (_action._activeAction._verbId == 0x167)) { + curDialog = &_dialog1; + nextDocQuote = 0x161; + } else if ((_action._activeAction._verbId == 0x174) || (_action._activeAction._verbId == 0x1753)) { + nextDocQuote = 0x16D; + curDialog = &_dialog2; + } else { + nextDocQuote = 0x179; + curDialog = &_dialog3; + } + + handleSlacheDialogs(nextDocQuote, 2, 9999999); + if (addDialogLine) { + curDialog->write(_action._activeAction._verbId, false); + curDialog->write(addVerbId, true); + } + + curDialog->start(); + _game._player._stepEnabled = true; + _slacheMode = 2; + } + } else if (_slacheMode == 2) { + if (_game._trigger == 1) { + _nextAction2 = _nextAction1; + _nextAction1 = 5; + } + + if (_nextAction1 != _nextAction2) { + _scene->_sequences.addTimer(4, 2); + } else { + Conversation *curDialog; + int nextDocQuote; + if ((_action._activeAction._verbId == 0x168) || (_action._activeAction._verbId == 0x169) || (_action._activeAction._verbId == 0x167)) { + curDialog = &_dialog1; + nextDocQuote = 0x163; + } else if ((_action._activeAction._verbId == 0x174) || (_action._activeAction._verbId == 0x175) || (_action._activeAction._verbId == 0x173)) { + nextDocQuote = 0x16F; + curDialog = &_dialog2; + } else { + nextDocQuote = 0x17B; + curDialog = &_dialog3; + } + + handleSlacheDialogs(nextDocQuote, 2, 9999999); + if (addDialogLine) { + curDialog->write(_action._activeAction._verbId, false); + curDialog->write(addVerbId, true); + } + + curDialog->start(); + _game._player._stepEnabled = true; + _slacheMode = 3; + } + } else { + _nextAction2 = _nextAction1; + _nextAction1 = 6; + } + } + } + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene320::Scene320(MADSEngine *vm) : Scene300s(vm) { + _blinkFl = false; + _flippedFl = false; + + _buttonId = -1; + _lastFrame = -1; + _leftItemId = -1; + _posX = -1; + _rightItemId = -1; +} + +void Scene320::synchronize(Common::Serializer &s) { + Scene3xx::synchronize(s); + + s.syncAsByte(_blinkFl); + s.syncAsByte(_flippedFl); + + s.syncAsSint32LE(_buttonId); + s.syncAsSint32LE(_lastFrame); + s.syncAsSint32LE(_leftItemId); + s.syncAsSint32LE(_posX); + s.syncAsSint32LE(_rightItemId); +} + +void Scene320::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene320::setRightView(int view) { + if (_rightItemId < 8) _scene->_sequences.remove(_globals._sequenceIndexes[10]); + + int spriteNum; + switch (view) { + case 0: + spriteNum = 16; + break; + + case 1: + spriteNum = 14; + break; + + case 2: + spriteNum = 17; + break; + + case 3: + spriteNum = 15; + break; + + default: + spriteNum = view + 6; + break; + } + + if (view != 8) { + _globals._sequenceIndexes[10] = _scene->_sequences.startCycle(_globals._spriteIndexes[spriteNum], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 0); + } + + _globals[kRightView320] = _rightItemId = view; +} + +void Scene320::setLeftView(int view) { + if (_leftItemId < 10) + _scene->_sequences.remove(_globals._sequenceIndexes[0]); + + if (view != 10) { + _globals._sequenceIndexes[0] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[view], false, 6, 0, 0, 18); + _scene->_sequences.setDepth(_globals._sequenceIndexes[0], 0); + if (!_blinkFl) + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[0], 2, 2); + } + + _leftItemId = view; +} + +void Scene320::handleButtons() { + switch(_action._activeAction._objectNameId) { + case 0x2DD: + _buttonId = 5; + break; + + case 0x2DE: + _buttonId = 4; + break; + + case 0x2E0: + _buttonId = 6; + break; + + case 0x2E1: + _buttonId = 7; + break; + + case 0x2E2: + _buttonId = 8; + break; + + case 0x2E3: + _buttonId = 9; + break; + + case 0x2E4: + _buttonId = 10; + break; + + case 0x2E5: + _buttonId = 11; + break; + + case 0x2E6: + _buttonId = 12; + break; + + case 0x2E7: + _buttonId = 13; + break; + + case 0x2E8: + _buttonId = 0; + break; + + case 0x2E9: + _buttonId = 1; + break; + + case 0x2EA: + _buttonId = 2; + break; + + case 0x2EB: + _buttonId = 3; + break; + + default: + break; + } + + if (_buttonId <= 3) { + _posX = (8 * _buttonId) - 2; + _flippedFl = true; + } else if (_buttonId <= 5) { + _posX = (13 * _buttonId) - 14; + _flippedFl = true; + } else { + _posX = (8 * _buttonId) + 98; + _flippedFl = false; + } +} + +void Scene320::enter() { + _blinkFl = true; + _rightItemId = 8; + _leftItemId = 10; + _lastFrame = 0; + + for (int i = 0; i < 10; i++) + _globals._spriteIndexes[i] = _scene->_sprites.addSprites(formAnimName('M', i)); + + for (int i = 0; i < 8; i++) + _globals._spriteIndexes[10 + i] = _scene->_sprites.addSprites(formAnimName('N', i)); + + _globals._spriteIndexes[18] = _scene->_sprites.addSprites("*REXHAND"); + _game._player._visible = false; + + setRightView(_globals[kRightView320]); + setLeftView(0); + + _vm->_palette->setEntry(252, 63, 30, 20); + _vm->_palette->setEntry(253, 45, 15, 10); + + sceneEntrySound(); +} + +void Scene320::step() { + if (_scene->_activeAnimation != nullptr) { + if (_lastFrame != _scene->_activeAnimation->getCurrentFrame()) { + _lastFrame = _scene->_activeAnimation->getCurrentFrame(); + switch (_lastFrame) { + case 95: + _blinkFl = true; + setLeftView(9); + _vm->_sound->command(41); + break; + + case 139: + _blinkFl = false; + setLeftView(9); + break; + + case 191: + _scene->_kernelMessages.add(Common::Point(1, 1), 0xFDFC, 0, 0, 60, _game.getQuote(0xFE)); + break; + + case 417: + case 457: + _vm->_screen._shakeCountdown = 40; + _vm->_sound->command(59); + break; + + case 430: + _blinkFl = true; + setLeftView(4); + break; + + default: + break; + } + } + } + + if (_game._trigger == 70) { + _globals[kAfterHavoc] = true; + _globals[kTeleporterRoom + 1] = 351; + _scene->_nextSceneId = 361; + } +} + +void Scene320::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(32011); + else if ((_action.isAction(VERB_PRESS) || _action.isAction(VERB_PUSH)) && + (_action.isObject(NOUN_LEFT_1_KEY) || _action.isObject(NOUN_LEFT_2_KEY) || _action.isObject(NOUN_LEFT_3_KEY) || _action.isObject(NOUN_LEFT_4_KEY) || + _action.isObject(NOUN_GREEN_BUTTON) || _action.isObject(NOUN_RED_BUTTON) || _action.isObject(NOUN_RIGHT_1_KEY) || _action.isObject(NOUN_RIGHT_2_KEY) || + _action.isObject(NOUN_RIGHT_3_KEY) || _action.isObject(NOUN_RIGHT_4_KEY) || _action.isObject(NOUN_RIGHT_5_KEY) || _action.isObject(NOUN_RIGHT_6_KEY) || + _action.isObject(NOUN_RIGHT_7_KEY) || _action.isObject(NOUN_RIGHT_8_KEY) + )) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + handleButtons(); + _globals._sequenceIndexes[18] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[18], _flippedFl, 4, 2, 0, 0); + _scene->_sequences.setScale(_globals._sequenceIndexes[18], 60); + _scene->_sequences.setPosition(_globals._sequenceIndexes[18], Common::Point(_posX, 170)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[18], 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[18], SEQUENCE_TRIGGER_LOOP, 0, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[18], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + if (_buttonId >= 6) { + _vm->_sound->command(60); + setRightView(_buttonId - 6); + } + if (_buttonId == 4) { + _vm->_sound->command(38); + if (_leftItemId == 3) + setLeftView(0); + else + setLeftView(3); + } + if (_buttonId == 5) { + _vm->_sound->command(38); + if (_leftItemId == 1) + setLeftView(2); + else + setLeftView(1); + } + if (_buttonId <= 3) { + _vm->_sound->command(60); + setLeftView(_buttonId + 5); + } + break; + + case 2: + _game._player._stepEnabled = true; + if (_buttonId == 5) { + if (_leftItemId == 2) { + _game._player._stepEnabled = false; + setRightView(8); + setLeftView(10); + _scene->_kernelMessages.reset(); + _scene->resetScene(); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('m', 2)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('m', 4)); + _globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('m', 9)); + _blinkFl = false; + setLeftView(2); + _game.loadQuoteSet(0xFE, 0); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->loadAnimation(formAnimName('a', -1), 70); + _vm->_sound->command(17); + } + } + break; + + default: + break; + } + } else if (_action.isAction(VERB_LEAVE, NOUN_SECURITY_STATION)) + _scene->_nextSceneId = 311; + else if (_action.isAction(VERB_LOOK, NOUN_RIGHT_MONITOR)) + _vm->_dialogs->show(32001); + else if (_action.isAction(VERB_LOOK, NOUN_LEFT_MONITOR)) + _vm->_dialogs->show(32002); + else if (_action.isAction(VERB_LOOK, NOUN_DESK)) + _vm->_dialogs->show(32003); + else if (_action.isAction(VERB_LOOK, NOUN_SECURITY_STATION)) + _vm->_dialogs->show(32004); + else if (_action.isAction(VERB_LOOK, NOUN_MUG)) + _vm->_dialogs->show(32005); + else if (_action.isAction(VERB_LOOK, NOUN_DOUGHNUT)) + _vm->_dialogs->show(32006); + else if (_action.isAction(VERB_LOOK, NOUN_MAGAZINE)) + _vm->_dialogs->show(32006); + else if (_action.isAction(VERB_LOOK, NOUN_PAPER_FOOTBALL)) + _vm->_dialogs->show(32008); + else if (_action.isAction(VERB_LOOK, NOUN_NEWSPAPER)) + _vm->_dialogs->show(32009); + else if (_action.isAction(VERB_LOOK, NOUN_CLIPBOARD)) + _vm->_dialogs->show(32010); + else if (_action.isAction(VERB_TAKE, NOUN_MUG)) + _vm->_dialogs->show(32012); + else if (_action.isAction(VERB_TAKE, NOUN_CLIPBOARD)) + _vm->_dialogs->show(32013); + else if (_action.isAction(VERB_TAKE, NOUN_DOUGHNUT) || _action.isAction(VERB_EAT, NOUN_DOUGHNUT)) + _vm->_dialogs->show(32014); + else if (_action.isAction(VERB_TAKE, NOUN_PAPER_FOOTBALL)) + _vm->_dialogs->show(32015); + else if (_action.isAction(VERB_TAKE, NOUN_MAGAZINE)) + _vm->_dialogs->show(32016); + else if (_action.isAction(VERB_TAKE, NOUN_NEWSPAPER)) + _vm->_dialogs->show(32017); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene321::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene321::enter() { + _game._player._visible = false; + _game._player._stepEnabled = false; + + _scene->_userInterface.emptyConversationList(); + _scene->_userInterface.setup(kInputConversation); + + int suffixNum; + if (_globals[kSexOfRex] == REX_FEMALE) { + _globals[kSexOfRex] = REX_MALE; + suffixNum = 1; + } else { + _globals[kSexOfRex] = REX_FEMALE; + suffixNum = _game._visitedScenes._sceneRevisited ? 2 : 0; + } + + _scene->loadAnimation(formAnimName('g', suffixNum), 60); + sceneEntrySound(); +} + +void Scene321::step() { + if (_scene->_activeAnimation != nullptr) { + if ((_scene->_activeAnimation->getCurrentFrame() >= 260) && (_globals[kSexOfRex] == REX_MALE) && (_game._storyMode >= STORYMODE_NICE)) + _scene->_nextSceneId = 316; + } + + if (_game._trigger == 60) + _scene->_nextSceneId = 316; +} + +/*------------------------------------------------------------------------*/ + +void Scene322::setup() { + _game._player._spritesPrefix = ""; + // The original is calling scene3xx_setAAName() + _game._aaName = Resources::formatAAName(4); +} + +void Scene322::enter() { + if (_globals[kSexOfRex] == REX_MALE) + _handSpriteId = _scene->_sprites.addSprites("*REXHAND"); + else + _handSpriteId = _scene->_sprites.addSprites("*ROXHAND"); + + teleporterEnter(); + + // The original is using scene3xx_sceneEntrySound() + if (!_vm->_musicFlag) + _vm->_sound->command(2); + else + _vm->_sound->command(10); +} + +void Scene322::step() { + teleporterStep(); +} + +void Scene322::actions() { + if (_action._lookFlag) { + _vm->_dialogs->show(32214); + _action._inProgress = false; + return; + } + + if (teleporterActions()) { + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_VIEWPORT) || _action.isAction(VERB_PEER_THROUGH, NOUN_VIEWPORT)) + _vm->_dialogs->show(32210); + else if (_action.isAction(VERB_LOOK, NOUN_KEYPAD)) + _vm->_dialogs->show(32211); + else if (_action.isAction(VERB_LOOK, NOUN_DISPLAY)) + _vm->_dialogs->show(32212); + else if (_action.isAction(VERB_LOOK, NOUN_0_KEY) || _action.isAction(VERB_LOOK, NOUN_1_KEY) + || _action.isAction(VERB_LOOK, NOUN_2_KEY) || _action.isAction(VERB_LOOK, NOUN_3_KEY) + || _action.isAction(VERB_LOOK, NOUN_4_KEY) || _action.isAction(VERB_LOOK, NOUN_5_KEY) + || _action.isAction(VERB_LOOK, NOUN_6_KEY) || _action.isAction(VERB_LOOK, NOUN_7_KEY) + || _action.isAction(VERB_LOOK, NOUN_8_KEY) || _action.isAction(VERB_LOOK, NOUN_9_KEY) + || _action.isAction(VERB_LOOK, NOUN_SMILE_KEY) || _action.isAction(VERB_LOOK, NOUN_ENTER_KEY) + || _action.isAction(VERB_LOOK, NOUN_FROWN_KEY)) + _vm->_dialogs->show(32213); + else if (_action.isAction(VERB_LOOK, NOUN_DEVICE)) + _vm->_dialogs->show(32214); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene351::setup() { + if (_scene->_currentSceneId == 391) + _globals[kSexOfRex] = REX_MALE; + + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene351::enter() { + _globals[kAfterHavoc] = -1; + _globals[kTeleporterRoom + 1] = 351; + + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('c', -1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*ROXRC_7"); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*RXRD_7"); + + if (_game._objects.isInRoom(OBJ_CREDIT_CHIP)) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 6, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 4); + } else + _scene->_hotspots.activate(NOUN_CREDIT_CHIP, false); + + if (_scene->_priorSceneId == 352) + _game._player._playerPos = Common::Point(148, 152); + else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(207, 81); + _game._player._facing = FACING_NORTH; + } + + if (_globals[kTeleporterCommand]) { + _game._player._visible = false; + _game._player._stepEnabled = false; + + char sepChar = 'a'; + if (_globals[kSexOfRex] != REX_MALE) + sepChar = 'b'; + + int suffixNum = -1; + int trigger = 0; + + switch (_globals[kTeleporterCommand]) { + case 1: + suffixNum = 0; + trigger = 60; + _globals[kTeleporterCommand] = true; + break; + + case 2: + suffixNum = 1; + trigger = 61; + break; + + case 3: + case 4: + _game._player._visible = true; + _game._player._stepEnabled = true; + _game._player._turnToFacing = FACING_SOUTH; + suffixNum = -1; + break; + + default: + break; + } + + _globals[kTeleporterCommand] = 0; + + if (suffixNum >= 0) + _scene->loadAnimation(formAnimName(sepChar, suffixNum), trigger); + } + + sceneEntrySound(); +} + +void Scene351::step() { + if (_game._trigger == 60) { + _game._player._stepEnabled = true; + _game._player._visible = true; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _game._player._turnToFacing = FACING_SOUTH; + } + + if (_game._trigger == 61) { + _globals[kTeleporterCommand] = 1; + _scene->_nextSceneId = _globals[kTeleporterDestination]; + _scene->_reloadSceneFlag = true; + } +} + +void Scene351::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(35121); + else if (_action.isAction(VERB_STEP_INTO, NOUN_TELEPORTER)) + _scene->_nextSceneId = 322; + else if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_SOUTH)) + _scene->_nextSceneId = 352; + else if (_action.isAction(VERB_TAKE, NOUN_CREDIT_CHIP)) { + if (_game._trigger || !_game._objects.isInInventory(0xF)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + if (_globals[kSexOfRex] == REX_FEMALE) { + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 5, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 5, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } else { + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 5, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 6, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } + break; + + case 1: + _scene->_hotspots.activate(NOUN_CREDIT_CHIP, false); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _game._objects.addToInventory(OBJ_CREDIT_CHIP); + break; + + case 2: + _game._player._visible = true; + _game._player._stepEnabled = true; + _vm->_dialogs->showItem(OBJ_CREDIT_CHIP, 0x32F); + break; + } + } + } else if (_action.isAction(VERB_LOOK, NOUN_VIEW_SCREEN)) + _vm->_dialogs->show(35110); + else if (_action.isAction(VERB_LOOK, NOUN_RIP_IN_FLOOR)) + _vm->_dialogs->show(35111); + else if (_action.isAction(VERB_LOOK, NOUN_FIRE_HYDRANT)) + _vm->_dialogs->show(35112); + else if (_action.isAction(VERB_LOOK, NOUN_GUARD)) { + if (_game._objects[0xF]._roomNumber == 351) + _vm->_dialogs->show(35114); + else + _vm->_dialogs->show(35113); + } else if (_action.isAction(VERB_LOOK, NOUN_EQUIPMENT)) + _vm->_dialogs->show(35115); + else if (_action.isAction(VERB_LOOK, NOUN_DESK)) + _vm->_dialogs->show(35116); + else if (_action.isAction(VERB_LOOK, NOUN_MACHINE)) + _vm->_dialogs->show(35117); + else if (_action.isAction(VERB_LOOK, NOUN_TELEPORTER)) + _vm->_dialogs->show(35118); + else if (_action.isAction(VERB_LOOK, NOUN_CONTROL_PANEL)) + _vm->_dialogs->show(35119); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_SOUTH)) + _vm->_dialogs->show(35120); + else if (_action.isAction(VERB_LOOK, NOUN_POLE)) + _vm->_dialogs->show(35122); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene352::Scene352(MADSEngine *vm) : Scene3xx(vm) { + _vaultOpenFl = false; + _mustPutArmDownFl = false; + _leaveRoomFl = false; + + _tapePlayerHotspotIdx = -1; + _hotspot1Idx = -1; + _hotspot2Idx = -1; + _lampHostpotIdx = -1; + _commonSequenceIdx = -1; + _commonSpriteIndex = -1; +} + +void Scene352::synchronize(Common::Serializer &s) { + Scene3xx::synchronize(s); + + s.syncAsByte(_vaultOpenFl); + s.syncAsByte(_mustPutArmDownFl); + s.syncAsByte(_leaveRoomFl); + + s.syncAsSint32LE(_tapePlayerHotspotIdx); + s.syncAsSint32LE(_hotspot1Idx); + s.syncAsSint32LE(_hotspot2Idx); + s.syncAsSint32LE(_lampHostpotIdx); + s.syncAsSint32LE(_commonSequenceIdx); + s.syncAsSint32LE(_commonSpriteIndex); +} + +void Scene352::setup() { + setPlayerSpritesPrefix(); + setAAName(); + + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(NOUN_YOUR_STUFF); + _scene->addActiveVocab(NOUN_OTHER_STUFF); + _scene->addActiveVocab(NOUN_LAMP); +} + +void Scene352::putArmDown(bool corridorExit, bool doorwayExit) { + switch (_game._trigger) { + case 0: + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 60, _game.getQuote(0xFF)); + _scene->_sequences.addTimer(48, 1); + break; + + case 1: + _game._player._stepEnabled = false; + _game._player._visible = false; + if (_globals[kSexOfRex] == REX_FEMALE) { + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 5, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 5, 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + } else { + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 5, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_SPRITE, 6, 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + } + break; + + case 2: { + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 6, 0, 0, 0); + int idx = _scene->_dynamicHotspots.add(NOUN_GUARDS_ARM, 0xD, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(230, 117), FACING_NORTHWEST); + _scene->changeVariant(0); + } + break; + + case 3: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x100)); + _game._objects.setRoom(0x2F, _scene->_currentSceneId); + _game._player._visible = true; + if (corridorExit) + _scene->_sequences.addTimer(48, 6); + else if (doorwayExit) + _scene->_sequences.addTimer(48, 4); + else { + _mustPutArmDownFl = false; + _game._player._stepEnabled = true; + } + break; + + case 4: + _game._player.walk(Common::Point(116, 107), FACING_NORTH); + _game._player._stepEnabled = true; + _mustPutArmDownFl = false; + _scene->_sequences.addTimer(180, 5); + _leaveRoomFl = true; + break; + + case 5: + if (_leaveRoomFl) + _scene->_nextSceneId = 351; + + break; + + case 6: + _game._player.walk(Common::Point(171, 152), FACING_SOUTH); + _game._player._stepEnabled = true; + _mustPutArmDownFl = false; + _scene->_sequences.addTimer(180, 7); + _leaveRoomFl = true; + break; + + case 7: + if (_leaveRoomFl) + _scene->_nextSceneId = 353; + + break; + + default: + break; + } +} + +void Scene352::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites("*RM302x0"); + _globals._spriteIndexes[13] = _scene->_sprites.addSprites("*RM302x2"); + _globals._spriteIndexes[12] = _scene->_sprites.addSprites("*RM302x3"); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('g', -1)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('b', -1)); + + + if (_globals[kSexOfRex] == REX_FEMALE) { + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*ROXRC_7"); + _globals._spriteIndexes[7] = _scene->_sprites.addSprites("*ROXRC_6"); + _globals._spriteIndexes[15] = _scene->_sprites.addSprites("*ROXRC_9"); + _globals._spriteIndexes[11] = _scene->_sprites.addSprites(formAnimName('a', 3)); + _globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('a', 2)); + } else { + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*RXRD_7"); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites("*RXRC_6"); + _globals._spriteIndexes[14] = _scene->_sprites.addSprites("*RXMRC_9"); + _globals._spriteIndexes[10] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('a', 0)); + } + + _leaveRoomFl = false; + + if (_game._objects.isInRoom(OBJ_TAPE_PLAYER)) { + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 12, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 5); + int idx = _scene->_dynamicHotspots.add(NOUN_TAPE_PLAYER, 0xD, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0)); + _tapePlayerHotspotIdx = _scene->_dynamicHotspots.setPosition(idx, Common::Point(84, 145), FACING_WEST); + } + + _vaultOpenFl = false; + + if (_scene->_priorSceneId != -2) { + _mustPutArmDownFl = false; + if (!_game._visitedScenes._sceneRevisited) + _globals[kHaveYourStuff] = false; + } + + if (_game._objects.isInRoom(OBJ_GUARDS_ARM)) { + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 6, 0, 0, 0); + int idx = _scene->_dynamicHotspots.add(NOUN_GUARDS_ARM, 0xD, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(230, 117), FACING_NORTHWEST); + } else + _mustPutArmDownFl = true; + + if (_scene->_priorSceneId == 353) + _game._player._playerPos = Common::Point(171, 155); + else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(116, 107); + + sceneEntrySound(); + + _game.loadQuoteSet(0xFF, 0x100, 0x101, 0x102, 0x103, 0); +} + +void Scene352::preActions() { + _leaveRoomFl = false; + + if (_action.isAction(VERB_OPEN, NOUN_VAULT)) + _game._player.walk(Common::Point(266, 111), FACING_NORTHEAST); + + if (_vaultOpenFl && !_action.isAction(0x1F8) && !_action.isAction(0x2F6) && !_action.isAction(0x2F5) && !_action.isAction(0x2F4)) { + if (_globals[kHaveYourStuff]) { + _commonSpriteIndex = _globals._spriteIndexes[13]; + _commonSequenceIdx = _globals._sequenceIndexes[13]; + } else { + _commonSpriteIndex = _globals._spriteIndexes[1]; + _commonSequenceIdx = _globals._sequenceIndexes[1]; + } + + switch (_game._trigger) { + case 0: + if (_game._player._needToWalk) { + _game._player._stepEnabled = false; + _scene->_sequences.remove(_commonSequenceIdx); + _vm->_sound->command(20); + _commonSequenceIdx = _scene->_sequences.startReverseCycle(_commonSpriteIndex, false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_commonSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _scene->_sequences.setDepth(_commonSequenceIdx, 15); + } + break; + + case 1: + if (!_globals[kHaveYourStuff]) + _scene->_dynamicHotspots.remove(_hotspot2Idx); + + _scene->_dynamicHotspots.remove(_hotspot1Idx); + _scene->_dynamicHotspots.remove(_lampHostpotIdx); + _vaultOpenFl = false; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } + + if (_action.isAction(VERB_PUT, NOUN_GUARDS_ARM, 0x1F3)) { + if (_globals[kSexOfRex] == REX_MALE) + _game._player.walk(Common::Point(269, 111), FACING_NORTHEAST); + else + _game._player.walk(Common::Point(271, 111), FACING_NORTHEAST); + } + + if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOORWAY) || _action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_SOUTH) || _action.isAction(VERB_PUT, NOUN_GUARDS_ARM, 0x89)) { + if (_game._objects.isInInventory(OBJ_GUARDS_ARM)) + _game._player.walk(Common::Point(230, 117), FACING_NORTHWEST); + } +} + +void Scene352::actions() { + if (_action._lookFlag) { + _vm->_dialogs->show(35225); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_OPEN, NOUN_VAULT)) { + if (!_vaultOpenFl) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + if (_globals[kSexOfRex] == REX_FEMALE) + _commonSpriteIndex = _globals._spriteIndexes[9]; + else + _commonSpriteIndex = _globals._spriteIndexes[8]; + + _commonSequenceIdx = _scene->_sequences.addSpriteCycle(_commonSpriteIndex, false, 8, 1, 0, 0); + _scene->_sequences.updateTimeout(_commonSequenceIdx, -1); + _scene->_sequences.addSubEntry(_commonSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + _vm->_sound->command(21); + _globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 7, 2, 20, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[12], FACING_NORTH); + int oldIdx = _commonSequenceIdx; + _commonSequenceIdx = _scene->_sequences.startCycle(_commonSpriteIndex, false, -2); + _scene->_sequences.updateTimeout(_commonSequenceIdx, oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } + break; + + case 2: + _vm->_sound->command(22); + _scene->_sequences.remove(_commonSequenceIdx); + _commonSequenceIdx = _scene->_sequences.startReverseCycle(_commonSpriteIndex, false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_commonSequenceIdx, 1, 3); + _scene->_sequences.addSubEntry(_commonSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: + _scene->_sequences.updateTimeout(-1, _commonSequenceIdx); + _game._player._visible = true; + _scene->_sequences.addTimer(60, 4); + break; + + case 4: + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x101)); + _game._player._stepEnabled = true; + break; + } + } + _action._inProgress = false; + return; + } + + if (_game._objects.isInInventory(OBJ_GUARDS_ARM)) { + _mustPutArmDownFl = true; + } + + bool exit_corridor = false; + bool exit_doorway = false; + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_SOUTH)) { + exit_corridor = true; + } + + if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOORWAY)) { + exit_doorway = true; + } + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_SOUTH) || _action.isAction(VERB_WALK_THROUGH, NOUN_DOORWAY) || _action.isAction(VERB_PUT, NOUN_GUARDS_ARM, 0x89)) { + if (_mustPutArmDownFl) + putArmDown(exit_corridor, exit_doorway); + else if (exit_corridor) + _scene->_nextSceneId = 353; + else + _scene->_nextSceneId = 351; + + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_GUARDS_ARM)) { + if (_game._trigger || !_game._objects.isInInventory(OBJ_GUARDS_ARM)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + if (_globals[kSexOfRex] == REX_FEMALE) { + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 5, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 5, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } else { + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 5, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_SPRITE, 6, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _game._objects.addToInventory(OBJ_GUARDS_ARM); + _scene->changeVariant(1); + break; + + case 2: + _game._player._visible = true; + _game._player._stepEnabled = true; + _vm->_dialogs->showItem(0x2F, 0x899C); + break; + } + _action._inProgress = false; + return; + } + } + + if (_action.isAction(VERB_PUT, NOUN_GUARDS_ARM, 0x1F3)) { + if (!_vaultOpenFl) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + if (_globals[kSexOfRex] == REX_FEMALE) + _commonSpriteIndex = _globals._spriteIndexes[11]; + else + _commonSpriteIndex = _globals._spriteIndexes[10]; + + _commonSequenceIdx = _scene->_sequences.addSpriteCycle(_commonSpriteIndex, false, 8, 1, 0, 0); + _scene->_sequences.updateTimeout(_commonSequenceIdx, -1); + _scene->_sequences.addSubEntry(_commonSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + _vm->_sound->command(21); + _globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 7, 2, 20, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[12], 8); + int oldIdx = _commonSequenceIdx; + _commonSequenceIdx = _scene->_sequences.startCycle(_commonSpriteIndex, false, -2); + _scene->_sequences.updateTimeout(_commonSequenceIdx, oldIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } + break; + + case 2: + _vm->_sound->command(23); + _scene->_sequences.remove(_commonSequenceIdx); + _commonSequenceIdx = _scene->_sequences.startReverseCycle(_commonSpriteIndex, false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_commonSequenceIdx, 1, 4); + _scene->_sequences.addSubEntry(_commonSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + + case 3: + _scene->_sequences.updateTimeout(-1, _commonSequenceIdx); + _game._player._visible = true; + if (_globals[kHaveYourStuff]) + _commonSpriteIndex = _globals._spriteIndexes[13]; + else + _commonSpriteIndex = _globals._spriteIndexes[1]; + + _vm->_sound->command(20); + _commonSequenceIdx = _scene->_sequences.addSpriteCycle(_commonSpriteIndex, false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_commonSequenceIdx, 15); + _scene->_sequences.addSubEntry(_commonSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 4); + break; + + case 4: + _commonSequenceIdx = _scene->_sequences.addSpriteCycle(_commonSpriteIndex, false, 6, 0, 0, 0); + _scene->_sequences.setAnimRange(_commonSequenceIdx, -2, -2); + _scene->_sequences.setDepth(_commonSequenceIdx, 15); + _scene->_sequences.addTimer(60, 5); + break; + + case 5: { + _vaultOpenFl = true; + int idx; + if (!_globals[kHaveYourStuff]) { + idx = _scene->_dynamicHotspots.add(NOUN_YOUR_STUFF, 0xD, -1, Common::Rect(282, 87, 282 + 13, 87 + 7)); + _hotspot2Idx = _scene->_dynamicHotspots.setPosition(idx, Common::Point(280, 111), FACING_NORTHEAST); + _globals._sequenceIndexes[1] = _commonSequenceIdx; + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x102)); + } else { + _globals._sequenceIndexes[13] = _commonSequenceIdx; + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x103)); + } + + idx = _scene->_dynamicHotspots.add(NOUN_OTHER_STUFF, 0xD, -1, Common::Rect(282, 48, 282 + 36, 48 + 27)); + _hotspot1Idx = _scene->_dynamicHotspots.setPosition(idx, Common::Point(287, 115), FACING_NORTHEAST); + idx = _scene->_dynamicHotspots.add(NOUN_LAMP, 0xD, -1, Common::Rect(296, 76, 296 + 11, 76 + 17)); + _lampHostpotIdx = _scene->_dynamicHotspots.setPosition(idx, Common::Point(287, 115), FACING_NORTHEAST); + _game._player._stepEnabled = true; + } + break; + } + } + } else if (_action.isAction(VERB_TAKE, NOUN_YOUR_STUFF)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + if (_globals[kSexOfRex] == REX_MALE) { + _globals._sequenceIndexes[14] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[14], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[14], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[14]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[14], SEQUENCE_TRIGGER_SPRITE, 2, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[14], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } else { + _globals._sequenceIndexes[15] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[15], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[15], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[15]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[15], SEQUENCE_TRIGGER_SPRITE, 2, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[15], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } + break; + + case 1: + _scene->_dynamicHotspots.remove(_hotspot2Idx); + _globals[kHaveYourStuff] = true; + + for (uint16 i = 0; i < _game._objects.size(); i++) { + if (_game._objects[i]._roomNumber == 50) + _game._objects.addToInventory(i); + } + + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[13] = _scene->_sequences.startCycle(_globals._spriteIndexes[13], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 15); + break; + + case 2: + if (_globals[kSexOfRex] == REX_MALE) + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[14]); + else + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[15]); + + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_TAKE, NOUN_TAPE_PLAYER) && !_game._objects.isInInventory(OBJ_TAPE_PLAYER)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + if (_globals[kSexOfRex] == REX_MALE) { + _globals._sequenceIndexes[6] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[6], true, 6, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[6]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_SPRITE, 6, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } else { + _globals._sequenceIndexes[7] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[7], true, 6, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[7]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_SPRITE, 6, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _scene->_dynamicHotspots.remove(_tapePlayerHotspotIdx); + break; + + case 2: + _game._objects.addToInventory(OBJ_TAPE_PLAYER); + if (_globals[kSexOfRex] == REX_MALE) + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[6]); + else + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[7]); + + _game._player._visible = true; + _game._player._stepEnabled = true; + _vm->_dialogs->showItem(OBJ_TAPE_PLAYER, 0x899B); + break; + + default: + break; + } + } else if (_action.isAction(VERB_LOOK, NOUN_SCANNER)) + _vm->_dialogs->show(35210); + else if (_action.isAction(VERB_LOOK, NOUN_MONITOR)) { + if (_game._storyMode == STORYMODE_NAUGHTY) + _vm->_dialogs->show(35211); + else + _vm->_dialogs->show(35212); + } else if (_action.isAction(VERB_LOOK, NOUN_DISPLAY)) + _vm->_dialogs->show(35213); + else if (_action.isAction(VERB_LOOK, NOUN_STATUE)) + _vm->_dialogs->show(35214); + else if (_action.isAction(VERB_LOOK, NOUN_TAPE_PLAYER) && (_action._savedFields._mainObjectSource == 4)) + _vm->_dialogs->show(35215); + else if (_action.isAction(VERB_LOOK, NOUN_AIR_VENT)) + _vm->_dialogs->show(35216); + else if (_action.isAction(VERB_LOOK, NOUN_GUARDS_ARM) && (_action._savedFields._mainObjectSource == 4)) + _vm->_dialogs->show(35217); + else if (_action.isAction(VERB_LOOK, NOUN_IRONING_BOARD)) + _vm->_dialogs->show(35218); + else if (_action.isAction(VERB_LOOK, NOUN_CLOCK)) + _vm->_dialogs->show(35219); + else if (_action.isAction(VERB_LOOK, NOUN_GAUGE)) + _vm->_dialogs->show(35220); + else if (_action.isAction(VERB_LOOK, NOUN_VAULT)) { + if (!_vaultOpenFl) + _vm->_dialogs->show(35221); + } else if (_action.isAction(VERB_LOOK, NOUN_YOUR_STUFF)) + _vm->_dialogs->show(35222); + else if (_action.isAction(VERB_LOOK, NOUN_OTHER_STUFF)) + _vm->_dialogs->show(35223); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_SOUTH)) + _vm->_dialogs->show(35224); + else if (_action.isAction(VERB_TAKE, NOUN_OTHER_STUFF)) + _vm->_dialogs->show(35226); + else if (_action.isAction(VERB_LOOK, NOUN_DESK)) + _vm->_dialogs->show(35229); + else if (_action.isAction(VERB_LOOK, NOUN_GUARD)) + _vm->_dialogs->show(35230); + else if (_action.isAction(VERB_LOOK, NOUN_DOORWAY)) + _vm->_dialogs->show(35231); + else if (_action.isAction(VERB_LOOK, NOUN_TABLE)) + _vm->_dialogs->show(35232); + else if (_action.isAction(VERB_LOOK, NOUN_PROJECTOR)) + _vm->_dialogs->show(35233); + else if (_action.isAction(VERB_LOOK, NOUN_SUPPORT)) + _vm->_dialogs->show(35234); + else if (_action.isAction(VERB_LOOK, NOUN_SECURITY_MONITOR)) + _vm->_dialogs->show(35235); + else + return; +} + +/*------------------------------------------------------------------------*/ + +void Scene353::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene353::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(Resources::formatName(303, 'B', 0, EXT_SS, "")); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 5, 0, 5, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + if (_scene->_priorSceneId == 352) + _game._player._playerPos = Common::Point(144, 95); + else + _game._player._playerPos = Common::Point(139, 155); + + sceneEntrySound(); +} + +void Scene353::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(35315); + else if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOORWAY)) + _scene->_nextSceneId = 352; + else if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_SOUTH)) + _scene->_nextSceneId = 354; + else if (_action.isAction(VERB_LOOK, NOUN_ROCK_CHUNK)) + _vm->_dialogs->show(35310); + else if (_action.isAction(VERB_LOOK, NOUN_PIPES) || _action.isAction(VERB_LOOK, NOUN_PIPE)) + _vm->_dialogs->show(35311); + else if (_action.isAction(VERB_LOOK, NOUN_BROKEN_BEAM)) + _vm->_dialogs->show(35312); + else if (_action.isAction(VERB_LOOK, NOUN_DOORWAY)) + _vm->_dialogs->show(35313); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_SOUTH)) + _vm->_dialogs->show(35314); + else if (_action.isAction(VERB_LOOK, NOUN_FLOOR)) + _vm->_dialogs->show(35316); + else if (_action.isAction(VERB_LOOK, NOUN_CEILING)) + _vm->_dialogs->show(35317); + else if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(35318); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene354::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene354::enter() { + _globals[kAfterHavoc] = true; + _globals[kTeleporterRoom + 1] = 351; + + if (_scene->_priorSceneId == 361) + _game._player._playerPos = Common::Point(231, 110); + else if (_scene->_priorSceneId == 401) { + _game._player._playerPos = Common::Point(106, 152); + _game._player._facing = FACING_NORTH; + } else if (_scene->_priorSceneId == 316) + _game._player._playerPos = Common::Point(71, 107); + else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(167, 57); + + sceneEntrySound(); +} + +void Scene354::preActions() { + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_SOUTH)) + _game._player._walkOffScreenSceneId = 401; +} + +void Scene354::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(35414); + else if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_NORTH)) { + _game._player.startWalking(Common::Point(208, 0), FACING_NORTHEAST); + _game._player._walkOffScreenSceneId = 353; + } else if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_EAST)) + _scene->_nextSceneId = 361; + else if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_WEST)) + _scene->_nextSceneId = 316; + else if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_SOUTH)) + _scene->_nextSceneId = 401; + else if (_action.isAction(VERB_LOOK, NOUN_CONTROLS)) + _vm->_dialogs->show(35410); + else if (_action.isAction(VERB_LOOK, NOUN_SIGNAL)) + _vm->_dialogs->show(35411); + else if (_action.isAction(VERB_LOOK, NOUN_CATWALK)) + _vm->_dialogs->show(35412); + else if (_action.isAction(VERB_LOOK, NOUN_AIR_DUCT)) + _vm->_dialogs->show(35413); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_NORTH)) + _vm->_dialogs->show(35415); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_SOUTH)) + _vm->_dialogs->show(35416); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_EAST)) + _vm->_dialogs->show(35417); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_WEST)) + _vm->_dialogs->show(35418); + else if (_action.isAction(VERB_LOOK, NOUN_DEBRIS)) + _vm->_dialogs->show(35419); + else if (_action.isAction(VERB_LOOK, NOUN_GUARD)) + _vm->_dialogs->show(35420); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene357::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene357::enter() { + _globals[kAfterHavoc] = true; + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(Resources::formatName(307, 'X', 0, EXT_SS, "")); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + + if (_scene->_priorSceneId == 318) + _game._player._playerPos = Common::Point(298, 142); + else if (_scene->_priorSceneId == 313) + _game._player._playerPos = Common::Point(127, 101); + else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(15, 148); + + sceneEntrySound(); +} + +void Scene357::preActions() { + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_EAST)) + _game._player._walkOffScreenSceneId = 318; + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_WEST)) + _game._player._walkOffScreenSceneId = 358; +} + +void Scene357::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(35715); + else if (_action.isAction(VERB_LOOK, NOUN_AIR_VENT)) + _vm->_dialogs->show(35710); + else if (_action.isAction(VERB_CLIMB_INTO, NOUN_AIR_VENT)) + _vm->_dialogs->show(35711); + else if (_action.isAction(VERB_LOOK, NOUN_BED)) + _vm->_dialogs->show(35712); + else if (_action.isAction(VERB_LOOK, NOUN_SINK)) + _vm->_dialogs->show(35713); + else if (_action.isAction(VERB_LOOK, NOUN_TOILET)) + _vm->_dialogs->show(35714); + else if (_action.isAction(VERB_LOOK, NOUN_CELL_WALL)) + _vm->_dialogs->show(35716); + else if (_action.isAction(VERB_LOOK, NOUN_LIGHT)) + _vm->_dialogs->show(35717); + else if (_action.isAction(VERB_LOOK, NOUN_RIP_IN_FLOOR)) + _vm->_dialogs->show(35718); + else if (_action.isAction(VERB_LOOK, NOUN_DEBRIS)) + _vm->_dialogs->show(35719); + else if (_action.isAction(VERB_TAKE, NOUN_DEBRIS)) + _vm->_dialogs->show(35720); + else if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(35721); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_EAST)) + _vm->_dialogs->show(35722); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_WEST)) + _vm->_dialogs->show(35723); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene358::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene358::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(Resources::formatName(307, 'X', 0, EXT_SS, "")); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + + if (_scene->_priorSceneId == 357) + _game._player._playerPos = Common::Point(305, 142); + else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(12, 141); + + sceneEntrySound(); +} + +void Scene358::preActions() { + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_EAST)) + _game._player._walkOffScreenSceneId = 357; + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_WEST)) + _game._player._walkOffScreenSceneId = 359; +} + +void Scene358::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(35815); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_WEST)) + _vm->_dialogs->show(35810); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_EAST)) + _vm->_dialogs->show(35811); + else if (_action.isAction(VERB_LOOK, NOUN_BED)) + _vm->_dialogs->show(35812); + else if (_action.isAction(VERB_LOOK, NOUN_SINK)) + _vm->_dialogs->show(35813); + else if (_action.isAction(VERB_LOOK, NOUN_TOILET)) + _vm->_dialogs->show(35814); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR) || _action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(35816); + else if (_action.isAction(VERB_LOOK, NOUN_AIR_VENT)) + _vm->_dialogs->show(35817); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene359::Scene359(MADSEngine *vm) : Scene3xx(vm) { + _cardHotspotId = -1; +} + +void Scene359::synchronize(Common::Serializer &s) { + Scene3xx::synchronize(s); + + s.syncAsSint32LE(_cardHotspotId); +} + +void Scene359::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene359::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('b', -1)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(Resources::formatName(307, 'X', 0, EXT_SS, "")); + + if (_globals[kSexOfRex] == REX_MALE) + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*RXMBD_2"); + else + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*ROXBD_2"); + + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[3], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 15); + + if (_game._objects.isInRoom(OBJ_SECURITY_CARD)) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 9, 0, 0, 0); + _cardHotspotId = _scene->_dynamicHotspots.add(NOUN_SECURITY_CARD, 0xD, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_cardHotspotId, Common::Point(107, 107), FACING_SOUTH); + } + + if (_scene->_priorSceneId == 358) + _game._player._playerPos = Common::Point(301, 141); + else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(15, 148); + + sceneEntrySound(); +} + +void Scene359::preActions() { + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_EAST)) + _game._player._walkOffScreenSceneId = 358; + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_WEST)) + _game._player._walkOffScreenSceneId = 360; +} + +void Scene359::actions() { + if (_action._lookFlag) { + if ((_game._difficulty != DIFFICULTY_HARD) && (_game._objects[OBJ_SECURITY_CARD]._roomNumber == 359)) + _vm->_dialogs->show(35914); + else + _vm->_dialogs->show(35915); + } else if (_action.isAction(VERB_TAKE, NOUN_SECURITY_CARD)) { + if (_game._trigger || !_game._objects.isInInventory(OBJ_SECURITY_CARD)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _vm->_dialogs->show(35920); + if (_globals[kSexOfRex] == REX_MALE) { + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 4, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 6, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } else { + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], true, 7, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(106, 110)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_SPRITE, 6, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->_dynamicHotspots.remove(_cardHotspotId); + _vm->_sound->command(57); + _game._objects.addToInventory(OBJ_SECURITY_CARD); + _vm->_dialogs->showItem(OBJ_SECURITY_CARD, 0x330); + _scene->changeVariant(1); + break; + + case 2: + if (_globals[kSexOfRex] == REX_MALE) + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[2]); + else + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[4]); + + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } + } else if (_action.isAction(VERB_LOOK, NOUN_BLOODY_CELL_WALL)) + _vm->_dialogs->show(35910); + else if (_action.isAction(VERB_LOOK, NOUN_BED)) + _vm->_dialogs->show(35911); + else if (_action.isAction(VERB_LOOK, NOUN_SINK)) + _vm->_dialogs->show(35912); + else if (_action.isAction(VERB_LOOK, NOUN_TOILET)) + _vm->_dialogs->show(35913); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_EAST)) + _vm->_dialogs->show(35916); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_WEST)) + _vm->_dialogs->show(35917); + else if (_action.isAction(VERB_LOOK, NOUN_LIMB)) + _vm->_dialogs->show(35918); + else if (_action.isAction(VERB_TAKE, NOUN_LIMB)) + _vm->_dialogs->show(35919); + else if (_action.isAction(VERB_LOOK, NOUN_SECURITY_CARD) && (_action._mainObjectSource == 4)) + _vm->_dialogs->show(35921); + else if (_action.isAction(VERB_LOOK, NOUN_BLOOD_STAIN)) { + if ((_game._difficulty != DIFFICULTY_HARD) && (_game._objects[OBJ_SECURITY_CARD]._roomNumber == 359)) + _vm->_dialogs->show(35922); + else + _vm->_dialogs->show(35923); + } else if (_action.isAction(VERB_LOOK, NOUN_WALL_BOARD)) + _vm->_dialogs->show(35924); + else if (_action.isAction(VERB_TAKE, NOUN_WALL_BOARD)) + _vm->_dialogs->show(35925); + else if (_action.isAction(VERB_LOOK, NOUN_RIP_IN_FLOOR)) + _vm->_dialogs->show(35926); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR)) + _vm->_dialogs->show(35927); + else if (_action.isAction(VERB_LOOK, NOUN_FLOOR)) { + if ((_game._difficulty != DIFFICULTY_HARD) && (_game._objects[OBJ_SECURITY_CARD]._roomNumber == 359)) + _vm->_dialogs->show(35928); + else + _vm->_dialogs->show(35929); + } else if (_action.isAction(VERB_OPEN, NOUN_AIR_VENT) || _action.isAction(VERB_LOOK, NOUN_AIR_VENT)) + _vm->_dialogs->show(36016); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene360::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene360::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(Resources::formatName(307, 'X', 0, EXT_SS, "")); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(127, 78)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + + if (_scene->_priorSceneId == 359) + _game._player._playerPos = Common::Point(304, 143); + else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(13, 141); + + sceneEntrySound(); +} + +void Scene360::preActions() { + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_EAST)) + _game._player._walkOffScreenSceneId = 359; + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_WEST)) + _game._player._walkOffScreenSceneId = 361; +} + +void Scene360::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(36015); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_WEST)) + _vm->_dialogs->show(36010); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_EAST)) + _vm->_dialogs->show(36011); + else if (_action.isAction(VERB_LOOK, NOUN_BED)) + _vm->_dialogs->show(36012); + else if (_action.isAction(VERB_LOOK, NOUN_SINK)) + _vm->_dialogs->show(36013); + else if (_action.isAction(VERB_LOOK, NOUN_TOILET)) + _vm->_dialogs->show(36014); + else if (_action.isAction(VERB_LOOK, NOUN_AIR_VENT)) + _vm->_dialogs->show(36016); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR)) + _vm->_dialogs->show(36017); + else if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(36018); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene361::setup() { + if (_scene->_currentSceneId == 391) + _globals[kSexOfRex] = REX_MALE; + + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene361::handleRexAction() { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 50, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 3, -2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 15, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], -1, 4); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: { + int seqIdx = _globals._sequenceIndexes[1]; + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 4); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[1], seqIdx); + } + break; + + case 2: { + int seqIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 4, 10); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], seqIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + } + break; + + case 3: { + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 3); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + int seqIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 11); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(167, 100)); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], seqIdx); + _scene->_sequences.addTimer(15, 4); + } + break; + + case 4: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + _scene->_sequences.setDone(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 12, 14); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(167, 100)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 5); + break; + + case 5: { + int seqIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 15); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], Common::Point(167, 100)); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], seqIdx); + _scene->_sequences.addTimer(15, 6); + } + break; + + case 6: + _scene->_sequences.setDone(_globals._sequenceIndexes[2]); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _scene->_sequences.addTimer(48, 7); + break; + + case 7: + _scene->_nextSceneId = 313; + break; + + default: + break; + } +} + +void Scene361::handleRoxAction() { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 18, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 2, 4); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 18, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], -1, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: { + int tmpIdx = _globals._sequenceIndexes[1]; + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 4); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[1], tmpIdx); + } + break; + + case 2: { + int tmpIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 4, 8); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], tmpIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + } + break; + + case 3: { + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 3); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + int tmpIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 9, 10); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(167, 100)); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], tmpIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 4); + } + break; + + case 4: { + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + int tmpIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 11, 15); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(167, 100)); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], tmpIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 5); + } + break; + + case 5: { + int tmpIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 16); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(167, 100)); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], tmpIdx); + _scene->_sequences.addTimer(48, 6); + } + break; + + case 6: + _scene->_sequences.setDone(_globals._sequenceIndexes[4]); + + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _scene->_sequences.addTimer(48, 7); + break; + + case 7: + _scene->_nextSceneId = 313; + break; + + default: + break; + } +} + +void Scene361::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(Resources::formatName(307, 'X', 0, EXT_SS, "")); + + if (_globals[kSexOfRex] == REX_MALE) { + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*RXCL_8"); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*RXCL_2"); + } else + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*ROXCL_8"); + + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + + if (_scene->_priorSceneId == 391) { + _globals[kSexOfRex] = REX_MALE; + _game._player._stepEnabled = false; + _game._player._visible = false; + _game._player._facing = FACING_SOUTH; + _game._player._playerPos = Common::Point(166, 101); + _scene->_sequences.addTimer(120, 70); + } else if (_scene->_priorSceneId == 360) + _game._player._playerPos = Common::Point(302, 145); + else if (_scene->_priorSceneId == 320) { + _game._player._playerPos = Common::Point(129, 113); + _game._player._facing = FACING_SOUTH; + } else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(13, 145); + + _game.loadQuoteSet(0xFB, 0xFC, 0); + + if (_scene->_priorSceneId == 320) + _scene->_kernelMessages.setQuoted(_scene->_kernelMessages.addQuote(0xFB, 0, 0x78), 4, true); + + sceneEntrySound(); +} + +void Scene361::step() { + if (_game._trigger >= 70) { + switch (_game._trigger) { + case 70: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addTimer(15, 71); + break; + + case 71: + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addTimer(15, 72); + break; + + case 72: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 3); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addTimer(15, 73); + break; + + case 73: + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 4, 5); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 74); + break; + + case 74: { + int seqIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 6); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], seqIdx); + _scene->_sequences.addTimer(15, 75); + } + break; + + case 75: + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 7); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addTimer(15, 76); + break; + + case 76: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 8); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addTimer(15, 77); + break; + + case 77: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(165, 76)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 15); + + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 9); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addTimer(15, 78); + break; + + case 78: + _scene->_sequences.setDone(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 10, -2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 79); + break; + + case 79: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[3]); + _game._player._stepEnabled = true; + _game._player._visible = true; + break; + + default: + break; + } + } +} + +void Scene361::preActions() { + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_EAST)) + _game._player._walkOffScreenSceneId = 360; + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_WEST)) + _game._player._walkOffScreenSceneId = 354; +} + +void Scene361::actions() { + if (_action._lookFlag) + _vm->_dialogs->show(36119); + else if (_action.isAction(VERB_SIT_AT, NOUN_DESK)) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.addQuote(0xFC, 120, 0); + } else if (_action.isAction(VERB_CLIMB_INTO, NOUN_AIR_VENT)) { + if (_globals[kSexOfRex] == REX_FEMALE) + handleRoxAction(); + else + handleRexAction(); + } else if (_action.isAction(VERB_LOOK, NOUN_DESK)) + _vm->_dialogs->show(36110); + else if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(36111); + else if (_action.isAction(VERB_LOOK, NOUN_LIGHTING_FIXTURE) || _action.isAction(VERB_STARE_AT, NOUN_LIGHTING_FIXTURE)) + _vm->_dialogs->show(36112); + else if (_action.isAction(VERB_LOOK, NOUN_LIGHTS) || _action.isAction(VERB_STARE_AT, NOUN_LIGHTS)) + _vm->_dialogs->show(36113); + else if (_action.isAction(VERB_TAKE, NOUN_LIGHTS)) + _vm->_dialogs->show(36114); + else if (_action.isAction(VERB_LOOK, NOUN_LIGHT_BULB) || _action.isAction(VERB_STARE_AT, NOUN_LIGHT_BULB)) + _vm->_dialogs->show(36115); + else if (_action.isAction(VERB_TAKE, NOUN_LIGHT_BULB)) + _vm->_dialogs->show(36116); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_WEST)) + _vm->_dialogs->show(36117); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_EAST)) + _vm->_dialogs->show(36118); + else if (_action.isAction(VERB_LOOK, NOUN_AIR_VENT)) + _vm->_dialogs->show(36120); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene366::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene366::enter() { + _scene->_userInterface.setup(kInputLimitedSentences); + _game._player._visible = false; + sceneEntrySound(); +} + +void Scene366::actions() { + if (_action.isAction(VERB_RETURN_TO, NOUN_AIR_SHAFT)) + _scene->_nextSceneId = 302; + else if (_action.isAction(VERB_OPEN, NOUN_GRATE)) { + if (_game._visitedScenes.exists(316)) + _vm->_dialogs->show(36612); + else + _vm->_dialogs->show(36613); + _scene->_nextSceneId = 316; + } else if (_action.isAction(VERB_LOOK_THROUGH, NOUN_GRATE)) { + if (_game._visitedScenes.exists(321)) + _vm->_dialogs->show(36611); + else + _vm->_dialogs->show(36610); + } else { + return; + } + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene387::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene387::enter() { + _scene->_userInterface.setup(kInputLimitedSentences); + _game._player._visible = false; + + sceneEntrySound(); +} + +void Scene387::actions() { + if (_action.isAction(VERB_RETURN_TO, NOUN_AIR_SHAFT)) + _scene->_nextSceneId = 313; + else if (_action.isAction(VERB_LOOK_THROUGH, NOUN_GRATE)) + _vm->_dialogs->show(38710); + else if (_action.isAction(VERB_OPEN, NOUN_GRATE)) + _vm->_dialogs->show(38711); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene388::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene388::enter() { + _scene->_userInterface.setup(kInputLimitedSentences); + + if (_globals[kAfterHavoc]) + _scene->_hotspots.activate(NOUN_SAUROPOD, false); + else { + _globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('b', 0)); + _globals._sequenceIndexes[0] = _scene->_sequences.startCycle(_globals._spriteIndexes[0], false, 1); + } + + _game._player._visible = false; + _vm->_palette->setEntry(252, 63, 30, 20); + _vm->_palette->setEntry(253, 45, 15, 12); + _game.loadQuoteSet(0x154, 0x155, 0x156, 0x157, 0x158, 0); + + sceneEntrySound(); +} + +void Scene388::actions() { + if (_action.isAction(VERB_RETURN_TO, NOUN_AIR_SHAFT)) + _scene->_nextSceneId = 313; + else if (_action.isAction(VERB_TALKTO, NOUN_SAUROPOD)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(160, 136), 0x1110, 32, 1, 120, _game.getQuote(0x154)); + break; + + case 1: + _scene->_kernelMessages.add(Common::Point(82, 38), 0xFDFC, 0, 0, 300, _game.getQuote(0x156)); + _scene->_kernelMessages.add(Common::Point(82, 52), 0xFDFC, 0, 0, 300, _game.getQuote(0x157)); + _scene->_kernelMessages.add(Common::Point(82, 66), 0xFDFC, 0, 2, 300, _game.getQuote(0x158)); + break; + + case 2: + _game._player._stepEnabled = true; + _scene->_kernelMessages.add(Common::Point(160, 136), 0x1110, 32, 0, 120, _game.getQuote(0x155)); + break; + + default: + break; + } + } else if (_action.isAction(VERB_LOOK_THROUGH, NOUN_GRATE)) { + if (_globals[kAfterHavoc]) + _vm->_dialogs->show(38811); + else + _vm->_dialogs->show(38810); + } else if (_action.isAction(VERB_OPEN, NOUN_GRATE)) + _vm->_dialogs->show(38812); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene389::Scene389(MADSEngine *vm) : Scene300s(vm) { + _monsterTime = 0; + _circularQuoteId = -1; +} + +void Scene389::synchronize(Common::Serializer &s) { + Scene3xx::synchronize(s); + + s.syncAsUint32LE(_monsterTime); + s.syncAsSint32LE(_circularQuoteId); +} + +void Scene389::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene389::enter() { + _scene->_userInterface.setup(kInputLimitedSentences); + _monsterTime = 0; + _circularQuoteId = 0x159; + + if (_globals[kAfterHavoc]) + _scene->_hotspots.activate(NOUN_MONSTER, false); + else { + _globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('m', -1)); + _globals._sequenceIndexes[0] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0], false, 6, 0, 0, 0); + _scene->_kernelMessages.initRandomMessages(1, + Common::Rect(88, 19, 177, 77), 13, 2, 0xFDFC, 60, + 247, 248, 249, 0); + } + + _vm->_palette->setEntry(252, 63, 37, 26); + _vm->_palette->setEntry(253, 45, 24, 17); + _game._player._visible = false; + _game.loadQuoteSet(0xF7, 0xF8, 0xF9, 0x159, 0x15A, 0x15B, 0); + + sceneEntrySound(); +} + +void Scene389::step() { + _scene->_kernelMessages.randomServer(); + if (_scene->_frameStartTime >= _monsterTime) { + int chanceMinor = _scene->_kernelMessages.checkRandom() * 4 + 1; + _scene->_kernelMessages.generateRandom(20, chanceMinor); + _monsterTime = _scene->_frameStartTime + 2; + } +} + +void Scene389::actions() { + if (_action.isAction(VERB_RETURN_TO, NOUN_AIR_SHAFT)) + _scene->_nextSceneId = 313; + else if (_action.isAction(VERB_TALKTO, NOUN_MONSTER)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_kernelMessages.add(Common::Point(160, 136), 0x1110, 32, 1, 120, _game.getQuote(_circularQuoteId)); + _circularQuoteId++; + if (_circularQuoteId > 0x15B) + _circularQuoteId = 0x159; + + break; + + case 1: + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_LOOK_THROUGH, NOUN_GRATE)) { + if (_globals[kAfterHavoc]) { + if ((_game._difficulty != DIFFICULTY_HARD) && (_game._objects[OBJ_SECURITY_CARD]._roomNumber == 359)) + _vm->_dialogs->show(38911); + else + _vm->_dialogs->show(38912); + } else + _vm->_dialogs->show(38910); + } else if (_action.isAction(VERB_OPEN, NOUN_GRATE)) { + if (_globals[kAfterHavoc]) + _vm->_dialogs->show(38914); + else + _vm->_dialogs->show(38913); + } else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene390::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene390::enter() { + _scene->_userInterface.setup(kInputLimitedSentences); + _game._player._visible = false; + + sceneEntrySound(); +} + +void Scene390::actions() { + if (_action.isAction(VERB_RETURN_TO, NOUN_AIR_SHAFT)) + _scene->_nextSceneId = 313; + else if (_action.isAction(VERB_LOOK_THROUGH, NOUN_GRATE)) + _vm->_dialogs->show(39010); + else if (_action.isAction(VERB_OPEN, NOUN_GRATE)) + _vm->_dialogs->show(39011); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene391::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene391::enter() { + _scene->_userInterface.setup(kInputLimitedSentences); + _game._player._visible = false; + sceneEntrySound(); +} + +void Scene391::actions() { + if (_action.isAction(VERB_RETURN_TO, NOUN_AIR_SHAFT)) + _scene->_nextSceneId = 313; + else if (_action.isAction(VERB_OPEN, NOUN_GRATE)) { + if (_globals[kKickedIn391Grate]) + _vm->_dialogs->show(39113); + else { + _vm->_dialogs->show(39112); + _globals[kKickedIn391Grate] = true; + } + + if (_globals[kAfterHavoc]) + _scene->_nextSceneId = 361; + else + _scene->_nextSceneId = 311; + } else if (_action.isAction(VERB_LOOK_THROUGH, NOUN_GRATE)) { + if (_globals[kAfterHavoc]) + _vm->_dialogs->show(39111); + else + _vm->_dialogs->show(39110); + } else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene399::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene399::enter() { + _scene->_userInterface.setup(kInputLimitedSentences); + _game._player._visible = false; + sceneEntrySound(); +} + +void Scene399::actions() { + if (_action.isAction(VERB_RETURN_TO, NOUN_AIR_SHAFT)) + _scene->_nextSceneId = 313; + else if (_action.isAction(VERB_LOOK_THROUGH, NOUN_GRATE)) { + if (_globals[kAfterHavoc]) { + if ((_game._difficulty != DIFFICULTY_HARD) && (_game._objects[OBJ_SECURITY_CARD]._roomNumber == 359)) + _vm->_dialogs->show(38911); + else + _vm->_dialogs->show(38912); + } else + _vm->_dialogs->show(38910); + } else if (_action.isAction(VERB_OPEN, NOUN_GRATE)) { + if (_globals[kAfterHavoc]) + _vm->_dialogs->show(38914); + else + _vm->_dialogs->show(38913); + } else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +} // End of namespace Nebular +} // End of namespace MADS diff --git a/engines/mads/nebular/nebular_scenes3.h b/engines/mads/nebular/nebular_scenes3.h new file mode 100644 index 0000000000..30ab333e53 --- /dev/null +++ b/engines/mads/nebular/nebular_scenes3.h @@ -0,0 +1,540 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_NEBULAR_SCENES3_H +#define MADS_NEBULAR_SCENES3_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" + +namespace MADS { + +namespace Nebular { + +typedef struct { + bool _flag; + int _vertical; + int _horizontal; + int _seqId[40]; + uint32 _timer; + + void synchronize(Common::Serializer &s) { + s.syncAsByte(_flag); + s.syncAsSint32LE(_vertical); + s.syncAsSint32LE(_horizontal); + for (int i = 0; i < 40; ++i) + s.syncAsSint32LE(_seqId[i]); + s.syncAsUint32LE(_timer); + }; +} ForceField; + +class Scene3xx : public NebularScene { +protected: + /** + * Plays an appropriate sound when entering a scene + */ + void setAAName(); + + /** + * Updates the prefix used for getting player sprites for the scene + */ + void setPlayerSpritesPrefix(); + + void sceneEntrySound(); + + void initForceField(ForceField *force, bool flag); + void handleForceField(ForceField *force, int *sprites); + int computeScale(int low, int high, int id); + +public: + Scene3xx(MADSEngine *vm) : NebularScene(vm) {} + + virtual void actions() {} +}; + +class Scene300s : public Scene3xx { +public: + Scene300s(MADSEngine *vm) : Scene3xx(vm) {} + + virtual void preActions(); +}; + +class Scene301: public Scene3xx { +public: + Scene301(MADSEngine *vm) : Scene3xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); +}; + +class Scene302: public Scene3xx { +private: + int _oldFrame; + +public: + Scene302(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); +}; + +class Scene303: public Scene3xx { +public: + Scene303(MADSEngine *vm) : Scene3xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); +}; + +class Scene304: public Scene3xx { +private: + int _explosionSpriteId; + +public: + Scene304(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); +}; + +class Scene307: public Scene3xx { +private: + ForceField _forceField; + + bool _afterPeeingFl; + bool _duringPeeingFl; + bool _grateOpenedFl; + bool _activePrisonerFl; + + int _animationMode; + int _prisonerMessageId; + int _fieldCollisionCounter; + + uint32 _lastFrameTime; + uint32 _guardTime; + uint32 _prisonerTimer; + + Common::String _subQuote2; + + Conversation _dialog1, _dialog2; + + void handleDialog(); + void handleRexDialog(int quote); + void handlePrisonerDialog(); + void handlePrisonerEncounter(); + void setDialogNode(int node); + void handlePrisonerSpeech(int firstQuoteId, int number, long timeout); + +public: + Scene307(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene308: public Scene3xx { +private: + ForceField _forceField; + +public: + Scene308(MADSEngine *vm) : Scene3xx(vm) {} + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); +}; + +class Scene309: public Scene3xx { +private: + ForceField _forceField; + int _characterSpriteIndexes[3]; + int _messagesIndexes[3]; + int _lastFrame; + +public: + Scene309(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); +}; + +class Scene310: public Scene3xx { +private: + ForceField _forceField; + +public: + Scene310(MADSEngine *vm) : Scene3xx(vm) {} + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); +}; + +class Scene311: public Scene3xx { +private: + bool _checkGuardFl; + +public: + Scene311(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene313: public Scene3xx { +public: + Scene313(MADSEngine *vm) : Scene3xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +class Scene316: public Scene3xx { +private: + void handleRexInGrate(); + void handleRoxInGrate(); + +public: + Scene316(MADSEngine *vm) : Scene3xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene318: public Scene3xx { +private: + uint32 _dropTimer; + + int _lastFrame; + int _animMode; + int _internCounter; + int _counter; + + bool _dialogFl; + bool _internTalkingFl; + bool _internWalkingFl; + bool _internVisibleFl; + bool _explosionFl; + + uint32 _lastFrameCounter; + + Common::String _subQuote2; + + Conversation _dialog1; + + void handleDialog(); + void handleRexDialogs(int quote); + void handleInternDialog(int quoteId, int quoteNum, uint32 timeout); + +public: + Scene318(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene319: public Scene3xx { +private: + Conversation _dialog1, _dialog2, _dialog3; + + int _animMode, _animFrame; + int _nextAction1, _nextAction2; + int _slacheMode; + int _slacheTopic; + int _slachePosY; + + bool _slacheTalkingFl; + bool _slacheReady; + bool _slacheInitFl; + + Common::String _subQuote2; + + void handleRexDialogues(int quote); + void handleSlacheDialogs(int quoteId, int counter, uint32 timer); +public: + Scene319(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene320: public Scene300s { +private: + void setRightView(int view); + void setLeftView(int view); + void handleButtons(); + + bool _blinkFl; + bool _flippedFl; + + int _buttonId; + int _lastFrame; + int _leftItemId; + int _posX; + int _rightItemId; + +public: + Scene320(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene321: public Scene3xx { +public: + Scene321(MADSEngine *vm) : Scene3xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); +}; + +class Scene322: public SceneTeleporter { +public: + Scene322(MADSEngine *vm) : SceneTeleporter(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene351: public Scene3xx { +public: + Scene351(MADSEngine *vm) : Scene3xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene352: public Scene3xx { +private: + bool _vaultOpenFl; + bool _mustPutArmDownFl; + bool _leaveRoomFl; + + int _tapePlayerHotspotIdx; + int _hotspot1Idx; + int _hotspot2Idx; + int _lampHostpotIdx; + int _commonSequenceIdx; + int _commonSpriteIndex; + + void putArmDown(bool corridorExit, bool doorwayExit); + +public: + Scene352(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene353: public Scene3xx { +public: + Scene353(MADSEngine *vm) : Scene3xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +class Scene354: public Scene3xx { +public: + Scene354(MADSEngine *vm) : Scene3xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene357: public Scene3xx { +public: + Scene357(MADSEngine *vm) : Scene3xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene358: public Scene3xx { +public: + Scene358(MADSEngine *vm) : Scene3xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene359: public Scene3xx { +private: + int _cardHotspotId; + +public: + Scene359(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene360: public Scene3xx { +public: + Scene360(MADSEngine *vm) : Scene3xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene361: public Scene3xx { +private: + void handleRexAction(); + void handleRoxAction(); + +public: + Scene361(MADSEngine *vm) : Scene3xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene366: public Scene300s { +public: + Scene366(MADSEngine *vm) : Scene300s(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +class Scene387: public Scene300s { +public: + Scene387(MADSEngine *vm) : Scene300s(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +class Scene388: public Scene300s { +public: + Scene388(MADSEngine *vm) : Scene300s(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +class Scene389: public Scene300s { +private: + uint32 _monsterTime; + + int _circularQuoteId; + +public: + Scene389(MADSEngine *vm); + virtual void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene390: public Scene300s { +public: + Scene390(MADSEngine *vm) : Scene300s(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +class Scene391: public Scene300s { +public: + Scene391(MADSEngine *vm) : Scene300s(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +class Scene399: public Scene300s { +public: + Scene399(MADSEngine *vm) : Scene300s(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +} // End of namespace Nebular + +} // End of namespace MADS + +#endif /* MADS_NEBULAR_SCENES3_H */ diff --git a/engines/mads/nebular/nebular_scenes4.cpp b/engines/mads/nebular/nebular_scenes4.cpp new file mode 100644 index 0000000000..b1b2b098af --- /dev/null +++ b/engines/mads/nebular/nebular_scenes4.cpp @@ -0,0 +1,4191 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" +#include "mads/nebular/nebular_scenes4.h" + +namespace MADS { + +namespace Nebular { + +void Scene4xx::setAAName() { + _game._aaName = Resources::formatAAName(4); +} + +void Scene4xx::setPlayerSpritesPrefix() { + _vm->_sound->command(5); + Common::String oldName = _game._player._spritesPrefix; + + if ((_scene->_nextSceneId == 403) || (_scene->_nextSceneId == 409)) + _game._player._spritesPrefix = ""; + else if (_globals[kSexOfRex] == REX_FEMALE) + _game._player._spritesPrefix = "ROX"; + else + _game._player._spritesPrefix = "RXM"; + + _game._player._scalingVelocity = true; + + if (oldName != _game._player._spritesPrefix) + _game._player._spritesChanged = true; + + _vm->_palette->setEntry(16, 10, 63, 63); + _vm->_palette->setEntry(17, 10, 45, 45); +} + +void Scene4xx::sceneEntrySound() { + if (!_vm->_musicFlag) { + _vm->_sound->command(2); + return; + } + + switch (_scene->_nextSceneId) { + case 401: + _vm->_sound->startQueuedCommands(); + if (_scene->_priorSceneId == 402) + _vm->_sound->command(12, 64); + else + _vm->_sound->command(12, 1); + break; + + case 402: + _vm->_sound->startQueuedCommands(); + _vm->_sound->command(12, 127); + break; + + case 405: + case 407: + case 409: + case 410: + case 413: + _vm->_sound->command(10); + break; + + case 408: + _vm->_sound->command(52); + break; + + default: + break; + } +} + +/*------------------------------------------------------------------------*/ + +Scene401::Scene401(MADSEngine *vm) : Scene4xx(vm), _destPos(0, 0) { + _northFl = false; + _timer = 0; +} + +void Scene401::synchronize(Common::Serializer &s) { + Scene4xx::synchronize(s); + + s.syncAsByte(_northFl); + s.syncAsSint16LE(_destPos.x); + s.syncAsSint16LE(_destPos.y); + s.syncAsUint32LE(_timer); +} + +void Scene401::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene401::enter() { + if (_scene->_priorSceneId != -2) + _northFl = false; + + _timer = 0; + + if (_scene->_priorSceneId == 402) { + _game._player._playerPos = Common::Point(203, 115); + _game._player._facing = FACING_WEST; + } else if (_scene->_priorSceneId == 354) { + _game._player._playerPos = Common::Point(149, 90); + _game._player._facing = FACING_SOUTH; + _northFl = true; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(142, 131); + _game._player._facing = FACING_NORTH; + } + + _game.loadQuoteSet(0x1D4, 0); + sceneEntrySound(); +} + +void Scene401::step() { + if (_game._trigger == 70) { + _scene->_nextSceneId = 354; + _scene->_reloadSceneFlag = true; + } + + if (_game._trigger == 80) { + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _game._player._stepEnabled = true; + _game._player._visible = true; + _northFl = false; + _game._player.walk(Common::Point(149, 110), FACING_SOUTH); + } + + if (_scene->_frameStartTime >= _timer) { + int dist = 64 - ((_vm->hypotenuse(_game._player._playerPos.x - 219, _game._player._playerPos.y - 115) * 64) / 120); + + if (dist > 64) + dist = 64; + else if (dist < 1) + dist = 1; + + _vm->_sound->command(12, dist); + _timer = _scene->_frameStartTime + _game._player._ticksAmount; + } + +} + +void Scene401::preActions() { + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_NORTH)) { + _game._player.walk(Common::Point(149, 89), FACING_NORTH); + _northFl = false; + } + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_SOUTH) && !_northFl) + _game._player._walkOffScreenSceneId = 405; + + if (_action.isAction(VERB_TAKE)) + _game._player._needToWalk = false; + + if (_game._player._needToWalk && _northFl) { + if (_globals[kSexOfRex] == REX_MALE) + _destPos = Common::Point(148, 94); + else + _destPos = Common::Point(149, 99); + + _game._player.walk(_destPos, FACING_SOUTH); + } +} + +void Scene401::actions() { + if ((_game._player._playerPos == _destPos) && _northFl) { + if (_globals[kSexOfRex] == REX_MALE) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _game._player._stepEnabled = false; + _game._player._visible = false; + _vm->_sound->command(21); + _scene->loadAnimation(formAnimName('s', 1), 70); + _globals[kHasBeenScanned] = true; + _vm->_sound->command(22); + int idx = _scene->_kernelMessages.add(Common::Point(153, 46), 0x1110, 32, 0, 60, _game.getQuote(0x1D4)); + _scene->_kernelMessages.setQuoted(idx, 4, true); + } + + if (_globals[kSexOfRex] == REX_FEMALE) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _game._player._stepEnabled = false; + _game._player._visible = false; + _vm->_sound->command(21); + _scene->loadAnimation(formAnimName('s', 2), 80); + _vm->_sound->command(23); + _globals[kHasBeenScanned] = true; + } + } + + if (_action.isAction(VERB_WALK_INTO, NOUN_BAR)) { + if (!_northFl) + _scene->_nextSceneId = 402; + } else if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_NORTH)) + _scene->_nextSceneId = 354; + else if (_action.isAction(VERB_LOOK, NOUN_SCANNER)) { + if (_globals[kHasBeenScanned]) + _vm->_dialogs->show(40111); + else + _vm->_dialogs->show(40110); + } else if (_action.isAction(VERB_LOOK, NOUN_BAR)) + _vm->_dialogs->show(40112); + else if (_action.isAction(VERB_LOOK, NOUN_SIGN)) + _vm->_dialogs->show(40113); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_SOUTH)) + _vm->_dialogs->show(40114); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_NORTH)) + _vm->_dialogs->show(40115); + else if (_action._lookFlag) + _vm->_dialogs->show(40116); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene402::Scene402(MADSEngine *vm) : Scene4xx(vm) { + _lightOn = false; + _blowingSmoke = false; + _leftWomanMoving = false; + _rightWomanMoving = false; + _firstTalkToGirlInChair = false; + _waitingGinnyMove = false; + _ginnyLooking = false; + _bigBeatFl = false; + _roxOnStool = false; + _bartenderSteady = false; + _bartenderHandsHips = false; + _bartenderLooksLeft = false; + _bartenderReady = false; + _bartenderTalking = false; + _bartenderCalled = false; + _conversationFl = false; + _activeTeleporter = false; + _activeArrows = false; + _activeArrow1 = false; + _activeArrow2 = false; + _activeArrow3 = false; + _cutSceneReady = false; + _cutSceneNeeded = false; + _helgaReady = false; + _refuseAlienLiquor = false; + + _drinkTimer = -1; + _beatCounter = -1; + _bartenderMode = -1; + _bartenderDialogNode = -1; + _bartenderCurrentQuestion = -1; + _helgaTalkMode = -1; + _roxMode = -1; + _rexMode = -1; + _talkTimer = -1; +} + +void Scene402::synchronize(Common::Serializer &s) { + Scene4xx::synchronize(s); + + s.syncAsByte(_lightOn); + s.syncAsByte(_blowingSmoke); + s.syncAsByte(_leftWomanMoving); + s.syncAsByte(_rightWomanMoving); + s.syncAsByte(_firstTalkToGirlInChair); + s.syncAsByte(_waitingGinnyMove); + s.syncAsByte(_ginnyLooking); + s.syncAsByte(_bigBeatFl); + s.syncAsByte(_roxOnStool); + s.syncAsByte(_bartenderSteady); + s.syncAsByte(_bartenderHandsHips); + s.syncAsByte(_bartenderLooksLeft); + s.syncAsByte(_bartenderReady); + s.syncAsByte(_bartenderTalking); + s.syncAsByte(_bartenderCalled); + s.syncAsByte(_conversationFl); + s.syncAsByte(_activeTeleporter); + s.syncAsByte(_activeArrows); + s.syncAsByte(_activeArrow1); + s.syncAsByte(_activeArrow2); + s.syncAsByte(_activeArrow3); + s.syncAsByte(_cutSceneReady); + s.syncAsByte(_cutSceneNeeded); + s.syncAsByte(_helgaReady); + s.syncAsByte(_refuseAlienLiquor); + + s.syncAsSint16LE(_drinkTimer); + s.syncAsSint16LE(_beatCounter); + s.syncAsSint16LE(_bartenderMode); + s.syncAsSint16LE(_bartenderDialogNode); + s.syncAsSint16LE(_bartenderCurrentQuestion); + s.syncAsSint16LE(_helgaTalkMode); + s.syncAsSint16LE(_roxMode); + s.syncAsSint16LE(_rexMode); + s.syncAsSint16LE(_talkTimer); +} + +void Scene402::setup() { + setPlayerSpritesPrefix(); + setAAName(); + + _scene->addActiveVocab(NOUN_BARTENDER); + _scene->addActiveVocab(NOUN_ALIEN_LIQUOR); + _scene->addActiveVocab(VERB_DRINK); + _scene->addActiveVocab(NOUN_BINOCULARS); + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(NOUN_CREDIT_CHIP); + _scene->addActiveVocab(VERB_TAKE); + _scene->addActiveVocab(NOUN_REPAIR_LIST); + _scene->addActiveVocab(VERB_LOOK_AT); +} + +void Scene402::setDialogNode(int node) { + if (node > 0) + _bartenderDialogNode = node; + + _game._player._stepEnabled = true; + + switch (node) { + case 0: + _scene->_userInterface.setup(kInputBuildingSentences); + _conversationFl = false; + _bartenderDialogNode = 0; + break; + + case 1: + _dialog1.start(); + _bartenderDialogNode = 1; + break; + + case 2: + _dialog2.start(); + _bartenderDialogNode = 2; + break; + + case 3: + _dialog3.start(); + _bartenderDialogNode = 3; + break; + + case 4: + _dialog4.start(); + _bartenderDialogNode = 4; + break; + + default: + break; + } +} + +void Scene402::handleConversation1() { + switch (_action._activeAction._verbId) { + case 0x214: { + int quoteId = 0; + int quotePosX = 0; + switch (_vm->getRandomNumber(1, 3)) { + case 1: + quoteId = 0x1E4; + _bartenderCurrentQuestion = 4; + quotePosX = 205; + break; + + case 2: + quoteId = 0x1E5; + _bartenderCurrentQuestion = 5; + quotePosX = 203; + break; + + case 3: + quoteId = 0x1E6; + _bartenderCurrentQuestion = 6; + quotePosX = 260; + break; + + default: + break; + } + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(quotePosX, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(quoteId)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 120; + setDialogNode(2); + } + break; + + case 0x215: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(260, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1EC)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 120; + _bartenderCurrentQuestion = 1; + setDialogNode(3); + break; + + case 0x237: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(208, 41), 0xFDFC, 0, 0, 100, _game.getQuote(0x1FD)); + setDialogNode(0); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 1120; + break; + + default: + break; + } +} + +void Scene402::handleConversation2() { + switch (_action._activeAction._verbId) { + case 0x216: + _dialog2.write(0x216, false); + _dialog2.write(0x21D, true); + break; + + case 0x219: + _dialog2.write(0x219, false); + _dialog2.write(0x220, true); + break; + + case 0x21A: + _dialog2.write(0x21A, false); + _dialog2.write(0x223, true); + break; + + case 0x21B: + _dialog2.write(0x21B, false); + _dialog2.write(0x224, true); + break; + + case 0x21D: + _dialog2.write(0x21D, false); + _dialog2.write(0x227, true); + break; + + case 0x220: + _dialog2.write(0x220, false); + _dialog2.write(0x22A, true); + break; + + case 0x223: + _dialog2.write(0x223, false); + _dialog2.write(0x22D, true); + break; + + case 0x224: + _dialog2.write(0x224, false); + _dialog2.write(0x230, true); + break; + + case 0x227: + _dialog2.write(0x227, false); + break; + + case 0x22A: + _dialog2.write(0x22A, false); + break; + + case 0x22D: + _dialog2.write(0x22D, false); + break; + + case 0x230: + _dialog2.write(0x230, false); + break; + + case 0x21C: + setDialogNode(0); + break; + + default: + break; + + } + + if (_action._activeAction._verbId != 0x21C) { + switch (_vm->getRandomNumber(1, 3)) { + case 1: + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 180; + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(198, 27), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1E7)); + _scene->_kernelMessages.add(Common::Point(201, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1E8)); + _bartenderCurrentQuestion = 7; + break; + + case 2: + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 180; + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(220, 27), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1E9)); + _scene->_kernelMessages.add(Common::Point(190, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1EA)); + _bartenderCurrentQuestion = 8; + break; + + case 3: + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 150; + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(196, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1EB)); + _bartenderCurrentQuestion = 9; + break; + + default: + break; + } + _dialog2.start(); + } else { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(208, 41), 0xFDFC, 0, 0, 100, _game.getQuote(0x1FD)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 1120; + } +} + +void Scene402::handleConversation3() { + switch (_action._activeAction._verbId) { + case 0x233: + case 0x234: + case 0x235: + case 0x236: + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 86); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(188, 27), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1ED)); + _scene->_kernelMessages.add(Common::Point(199, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1EE)); + setDialogNode(4); + _bartenderCurrentQuestion = 2; + break; + + case 0x237: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(208, 41), 0xFDFC, 0, 0, 100, _game.getQuote(0x1FD)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 1120; + setDialogNode(0); + break; + + default: + break; + } +} + +void Scene402::handleConversation4() { + switch (_action._activeAction._verbId) { + case 0x238: + _scene->_kernelMessages.reset(); + setDialogNode(0); + _game._player._stepEnabled = false; + _scene->_kernelMessages.add(Common::Point(196, 13), 0xFDFC, 0, 0, 180, _game.getQuote(0x1F0)); + _scene->_kernelMessages.add(Common::Point(184, 27), 0xFDFC, 0, 0, 180, _game.getQuote(0x1F1)); + _scene->_kernelMessages.add(Common::Point(200, 41), 0xFDFC, 0, 0, 180, _game.getQuote(0x1F2)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 1100; + _dialog4.write(0x238, false); + _bartenderMode = 22; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(100, 95); + _refuseAlienLiquor = true; + break; + + case 0x239: + _game._player._stepEnabled = false; + _roxMode = 21; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 92); + _scene->_userInterface.setup(kInputBuildingSentences); + _conversationFl = false; + break; + + case 0x23A: + setDialogNode(0); + _game._player._stepEnabled = false; + _scene->_kernelMessages.add(Common::Point(193, 27), 0xFDFC, 0, 0, 150, _game.getQuote(0x1F4)); + _scene->_kernelMessages.add(Common::Point(230, 41), 0xFDFC, 0, 0, 150, _game.getQuote(0x1F5)); + _dialog4.write(0x23A, false); + _globals[kHasSaidTimer] = true; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 1100; + _bartenderMode = 22; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(100, 95); + _refuseAlienLiquor = true; + break; + + case 0x23D: + setDialogNode(0); + _game._player._stepEnabled = false; + _scene->_kernelMessages.add(Common::Point(153, 27), 0xFDFC, 0, 0, 150, _game.getQuote(0x1F6)); + _scene->_kernelMessages.add(Common::Point(230, 41), 0xFDFC, 0, 0, 150, _game.getQuote(0x1F7)); + _dialog4.write(0x23D, false); + _globals[kHasSaidBinocs] = true; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 1100; + _bartenderMode = 22; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(100, 95); + _refuseAlienLiquor = true; + break; + + case 0x23E: + _scene->_kernelMessages.reset(); + setDialogNode(0); + _game._player._stepEnabled = false; + _scene->_kernelMessages.add(Common::Point(205, 41), 0xFDFC, 0, 0, 100, _game.getQuote(0x1F8)); + _bartenderMode = 22; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 1050; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(50, 95); + _refuseAlienLiquor = true; + break; + + default: + break; + } +} + +void Scene402::handleDialogs() { + if (_game._trigger == 0) { + _scene->_kernelMessages.reset(); + _game._player._stepEnabled = false; + Common::String curQuote = _game.getQuote(_action._activeAction._verbId); + if (_vm->_font->getWidth(curQuote, _scene->_textSpacing) > 200) { + Common::String subQuote1, subQuote2; + _game.splitQuote(curQuote, subQuote1, subQuote2); + _scene->_kernelMessages.add(Common::Point(230, 42), 0x1110, 32, 0, 140, subQuote1); + _scene->_kernelMessages.add(Common::Point(230, 56), 0x1110, 32, 0, 140, subQuote2); + _scene->_sequences.addTimer(160, 120); + } else { + _scene->_kernelMessages.add(Common::Point(230, 56), 0x1110, 32, 1, 140, curQuote); + _scene->_sequences.addTimer(160, 120); + } + } else if (_game._trigger == 120) { + _game._player._stepEnabled = true; + switch (_bartenderDialogNode) { + case 1: + handleConversation1(); + break; + + case 2: + handleConversation2(); + break; + + case 3: + handleConversation3(); + break; + + case 4: + handleConversation4(); + break; + + default: + break; + } + } +} + +void Scene402::enter() { + _globals._spriteIndexes[0] = _scene->_sprites.addSprites(formAnimName('n', -1)); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 2)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('g', 0)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('g', 1)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('a', 0)); + _globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _globals._spriteIndexes[15] = _scene->_sprites.addSprites(formAnimName('x', 5)); + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('x', 4)); + _globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('b', 0)); + _globals._spriteIndexes[10] = _scene->_sprites.addSprites(formAnimName('b', 1)); + _globals._spriteIndexes[11] = _scene->_sprites.addSprites(formAnimName('b', 2)); + _globals._spriteIndexes[12] = _scene->_sprites.addSprites(formAnimName('b', 3)); + _globals._spriteIndexes[13] = _scene->_sprites.addSprites(formAnimName('c', 0)); + _globals._spriteIndexes[14] = _scene->_sprites.addSprites(formAnimName('l', 0)); + _globals._spriteIndexes[16] = _scene->_sprites.addSprites(formAnimName('h', 0)); + _globals._spriteIndexes[17] = _scene->_sprites.addSprites(formAnimName('z', 0)); + _globals._spriteIndexes[18] = _scene->_sprites.addSprites(formAnimName('z', 1)); + _globals._spriteIndexes[19] = _scene->_sprites.addSprites(formAnimName('z', 2)); + _globals._spriteIndexes[20] = _scene->_sprites.addSprites(formAnimName('x', 6)); + _globals._spriteIndexes[21] = _scene->_sprites.addSprites("*ROXRC_9"); + _globals._spriteIndexes[22] = _scene->_sprites.addSprites("*ROXCL_8"); + + if (_scene->_priorSceneId == 401) { + _game._player._playerPos = Common::Point(160, 150); + _game._player._facing = FACING_NORTH; + _roxOnStool = false; + _bartenderDialogNode = 1; + _conversationFl = false; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(160, 150); + _game._player._facing = FACING_NORTH; + _game._objects.addToInventory(OBJ_CREDIT_CHIP); + _game._objects.addToInventory(OBJ_BINOCULARS); + _game._objects.addToInventory(OBJ_TIMER_MODULE); + _roxOnStool = false; + _bartenderDialogNode = 1; + _conversationFl = false; + } + + _game.loadQuoteSet(0x1D7, 0x1D8, 0x1D9, 0x1DA, 0x1DB, 0x1DC, 0x1DD, 0x1DE, 0x1DF, 0x1E2, 0x1E3, 0x1E6, 0x1E5, 0x1E7, + 0x1E8, 0x1E9, 0x1EA, 0x1EF, 0x1F0, 0x1F1, 0x1F2, 0x1F3, 0x1F4, 0x1F5, 0x1F6, 0x1F7, 0x1F8, 0x1F9, 0x1FA, 0x1FB, + 0x1FC, 0x1EB, 0x1EC, 0x1ED, 0x1EE, 0x1E4, 0x1FD, 0x1E0, 0x1E1, 0x1FE, 0x1FF, 0x200, 0x201, 0x202, 0x203, 0x204, + 0x205, 0x206, 0x207, 0x208, 0x209, 0x20A, 0x20B, 0x20C, 0x20F, 0x20D, 0x20E, 0x210, 0x211, 0x212, 0x213, 0x214, + 0x215, 0x237, 0x216, 0x219, 0x21A, 0x21B, 0x21C, 0x21D, 0x220, 0x223, 0x224, 0x227, 0x22A, 0x22D, 0x230, 0x233, + 0x234, 0x235, 0x236, 0x238, 0x239, 0x23A, 0x23D, 0x23E, 0x23F, 0); + + _vm->_palette->setEntry(250, 47, 41, 40); + _vm->_palette->setEntry(251, 50, 63, 55); + _vm->_palette->setEntry(252, 38, 34, 25); + _vm->_palette->setEntry(253, 45, 41, 35); + + _dialog1.setup(0x60, 0x214, 0x215, 0x237, 0); + _dialog2.setup(0x61, 0x216, 0x219, 0x21A, 0x21B, 0x21D, 0x220, 0x223, 0x224, 0x227, 0x22A, 0x22D, 0x230, 0x21C, 0); + _dialog3.setup(0x62, 0x233, 0x234, 0x235, 0x236, 0x237, -1); + _dialog4.setup(0x63, 0x238, 0x239, 0x23A, 0x23D, 0x23E, 0); + + if (!_game._visitedScenes._sceneRevisited) { + _dialog2.set(0x61, 0x216, 0x219, 0x21A, 0x21B, 0x21C, 0); + _dialog4.set(0x63, 0x238, 0x23E, 0); + _dialog1.set(0x60, 0x214, 0x215, 0x237, 0); + } + + if (_game._objects.isInInventory(OBJ_CREDIT_CHIP)) + _dialog4.write(0x239, true); + else + _dialog4.write(0x239, false); + + if (_game._objects.isInInventory(OBJ_BINOCULARS) && !_globals[kHasSaidBinocs]) + _dialog4.write(0x23D, true); + else + _dialog4.write(0x23D, false); + + if (_game._objects.isInInventory(OBJ_TIMER_MODULE) && !_globals[kHasSaidTimer]) + _dialog4.write(0x23A, true); + else + _dialog4.write(0x23A, false); + + if (_dialog2.read(0) <= 1) + _dialog1.write(0x214, false); + + if (_conversationFl) { + switch (_bartenderDialogNode) { + case 0: + _scene->_userInterface.setup(kInputBuildingSentences); + _bartenderDialogNode = 1; + break; + + case 1: + _dialog1.start(); + break; + + case 2: + _dialog2.start(); + break; + + case 3: + _dialog3.start(); + break; + + case 4: + _dialog4.start(); + break; + + default: + break; + } + + switch (_bartenderCurrentQuestion) { + case 1: + _scene->_kernelMessages.add(Common::Point(260, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1EC)); + break; + + case 2: + _scene->_kernelMessages.add(Common::Point(188, 27), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1ED)); + _scene->_kernelMessages.add(Common::Point(199, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1EE)); + break; + + case 3: + _scene->_kernelMessages.add(Common::Point(177, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1EF)); + break; + + case 4: + _scene->_kernelMessages.add(Common::Point(205, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1E4)); + break; + + case 5: + _scene->_kernelMessages.add(Common::Point(203, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1E5)); + break; + + case 6: + _scene->_kernelMessages.add(Common::Point(260, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1E6)); + break; + + case 7: + _scene->_kernelMessages.add(Common::Point(198, 27), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1E7)); + _scene->_kernelMessages.add(Common::Point(201, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1E8)); + break; + + case 8: + _scene->_kernelMessages.add(Common::Point(220, 27), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1E9)); + _scene->_kernelMessages.add(Common::Point(190, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1EA)); + break; + + case 9: + _scene->_kernelMessages.add(Common::Point(196, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1EB)); + break; + + case 10: + _scene->_kernelMessages.add(Common::Point(198, 27), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1E2)); + _scene->_kernelMessages.add(Common::Point(199, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1E3)); + break; + + default: + break; + } + } + + _firstTalkToGirlInChair = false; + _lightOn = false; + _blowingSmoke = false; + _leftWomanMoving = false; + _rightWomanMoving = false; + _ginnyLooking = false; + _beatCounter = 0; + _waitingGinnyMove = false; + _bigBeatFl = true; + _bartenderHandsHips = false; + _bartenderSteady = true; + _bartenderLooksLeft = false; + _activeTeleporter = false; + _activeArrows = false; + _activeArrow1 = false; + _activeArrow2 = false; + _activeArrow3 = false; + _cutSceneReady = false; + _cutSceneNeeded = false; + _helgaReady = true; + _bartenderReady = true; + _drinkTimer = 0; + _bartenderTalking = false; + _bartenderCalled = false; + _helgaTalkMode = 0; + _rexMode = 0; + _refuseAlienLiquor = false; + + _scene->loadAnimation(Resources::formatName(402, 'd', 1, EXT_AA, "")); + _scene->_activeAnimation->_resetFlag = true; + + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 1); + + _globals._sequenceIndexes[13] = _scene->_sequences.startCycle(_globals._spriteIndexes[13], false, 2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + + if (!_game._objects.isInInventory(OBJ_REPAIR_LIST)) { + _globals._sequenceIndexes[14] = _scene->_sequences.startCycle(_globals._spriteIndexes[14], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[14], 7); + _scene->_sequences.setPosition(_globals._sequenceIndexes[14], Common::Point(210, 80)); + int idx = _scene->_dynamicHotspots.add(NOUN_REPAIR_LIST, 0xD1, _globals._sequenceIndexes[14], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(0, 0), FACING_NONE); + } + + { + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + int idx = _scene->_dynamicHotspots.add(NOUN_BARTENDER, 0xD, _globals._sequenceIndexes[9], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(228, 83), FACING_SOUTH); + } + + if (!_game._objects.isInRoom(OBJ_ALIEN_LIQUOR) && !_game._objects.isInInventory(OBJ_CREDIT_CHIP)) { + _globals._sequenceIndexes[15] = _scene->_sequences.startCycle(_globals._spriteIndexes[15], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[15], 8); + _scene->_sequences.setPosition(_globals._sequenceIndexes[15], Common::Point(250, 80)); + int idx = _scene->_dynamicHotspots.add(NOUN_CREDIT_CHIP, 0x4, _globals._sequenceIndexes[15], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(0, 0), FACING_NONE); + } + + _globals._sequenceIndexes[20] = _scene->_sequences.startCycle(_globals._spriteIndexes[20], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[20], 7); + _scene->_sequences.setPosition(_globals._sequenceIndexes[20], Common::Point(234, 72)); + + if (_globals[kBottleDisplayed]) { + _globals._sequenceIndexes[8] = _scene->_sequences.startCycle(_globals._spriteIndexes[8], false, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 7); + } + + if (_roxOnStool) { + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 5); + _game._player._visible = false; + } + + sceneEntrySound(); +} + +void Scene402::step() { + if (_game._trigger == 104) { + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._visible = true; + _scene->_sequences.remove(_globals._sequenceIndexes[15]); + _game._objects.addToInventory(OBJ_CREDIT_CHIP); + _vm->_dialogs->showItem(OBJ_CREDIT_CHIP, 40242); + _game._player._stepEnabled = true; + } + + if ((_vm->getRandomNumber(1, 1500) == 1) && (!_activeTeleporter) && (_game._player._playerPos.x < 150)) { + _vm->_sound->command(30); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 13, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 1, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 14); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 48); + _activeTeleporter = true; + _globals[kSomeoneHasExploded] = true; + } + + if (_game._trigger == 48) + _activeTeleporter = false; + + if (_game._trigger == 100) { + _bartenderReady = false; + if (_bartenderHandsHips) { + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + _bartenderHandsHips = false; + } else if (_bartenderLooksLeft) { + _scene->_sequences.remove(_globals._sequenceIndexes[11]); + _bartenderLooksLeft = false; + } else if (_bartenderSteady) { + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _bartenderSteady = false; + } + + if (!_bartenderTalking) { + _globals._sequenceIndexes[10] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[10], false, 7, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[10], 3, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 8); + int idx = _scene->_dynamicHotspots.add(NOUN_BARTENDER, 0xD, _globals._sequenceIndexes[10], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(228, 83), FACING_SOUTH); + _bartenderTalking = true; + if (_talkTimer > 1000) + _scene->_sequences.addTimer(_talkTimer - 1000, 101); + else + _scene->_sequences.addTimer(_talkTimer, 101); + } + } + + if ((_game._trigger == 101) && _bartenderTalking) { + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 1); + int idx = _scene->_dynamicHotspots.add(NOUN_BARTENDER, 0xD, _globals._sequenceIndexes[9], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(228, 83), FACING_SOUTH); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + _bartenderSteady = true; + _bartenderTalking = false; + if (_talkTimer < 1000) + _bartenderReady = true; + } + + if (_game._trigger == 28) + _game._player._stepEnabled = true; + + switch (_game._trigger) { + case 92: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[6]); + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[7], 1, 2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 93); + break; + + case 93: { + int seqIdx = _globals._sequenceIndexes[7]; + switch (_roxMode) { + case 20: + _vm->_sound->command(57); + _scene->_sequences.remove(_globals._sequenceIndexes[15]); + _game._objects.addToInventory(OBJ_CREDIT_CHIP); + _vm->_dialogs->showItem(OBJ_CREDIT_CHIP, 40242); + break; + + case 22: + _vm->_sound->command(57); + _scene->_sequences.remove(_globals._sequenceIndexes[8]); + _game._objects.addToInventory(OBJ_ALIEN_LIQUOR); + _globals[kBottleDisplayed] = false; + _vm->_dialogs->showItem(OBJ_ALIEN_LIQUOR, 40241); + break; + + case 21: + _globals._sequenceIndexes[15] = _scene->_sequences.startCycle(_globals._spriteIndexes[15], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[15], 8); + _scene->_sequences.setPosition(_globals._sequenceIndexes[15], Common::Point(250, 80)); + break; + + default: + break; + } + _globals._sequenceIndexes[7] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[7], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[7], 1, 3); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 5); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[7], seqIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 94); + + if (_roxMode == 21) { + if (_game._objects.isInInventory(OBJ_CREDIT_CHIP)) + _game._objects.setRoom (OBJ_CREDIT_CHIP, NOWHERE); + + _bartenderMode = 20; + _scene->_sequences.addTimer(60, 95); + } + } + break; + + case 94: { + int seqIdx = _globals._sequenceIndexes[7]; + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 5); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[6], seqIdx); + if (_roxMode == 22) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(230, 56), 0x1110, 32, 0, 120, _game.getQuote(0x23F)); + _bartenderMode = 21; + _globals[kHasPurchased] = true; + _scene->_sequences.addTimer(140, 95); + } else if (_roxMode == 20) + _game._player._stepEnabled = true; + + } + break; + } + + switch (_game._trigger) { + case 95: + _bartenderReady = false; + _game._player._stepEnabled = false; + if (_bartenderHandsHips || _bartenderTalking) { + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + _bartenderHandsHips = false; + _bartenderTalking = false; + } + + if (_bartenderLooksLeft) { + _scene->_sequences.remove(_globals._sequenceIndexes[11]); + _bartenderLooksLeft = false; + } + + if (_bartenderSteady) { + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _bartenderSteady = false; + } + _globals._sequenceIndexes[12] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[12], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[12], 1, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[12], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 96); + break; + + case 96: { + int seqIdx = _globals._sequenceIndexes[12]; + _globals._sequenceIndexes[12] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[12], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[12], 6, 7); + _scene->_sequences.setDepth(_globals._sequenceIndexes[12], 8); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[12], seqIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 97); + } + break; + + case 97: { + int seqIdx = _globals._sequenceIndexes[12]; + switch (_bartenderMode) { + case 20: + _scene->_sequences.remove(_globals._sequenceIndexes[15]); + break; + + case 21: { + _globals._sequenceIndexes[15] = _scene->_sequences.startCycle(_globals._spriteIndexes[15], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[15], 8); + _scene->_sequences.setPosition(_globals._sequenceIndexes[15], Common::Point(250, 80)); + int idx = _scene->_dynamicHotspots.add(NOUN_CREDIT_CHIP, 0x4, _globals._sequenceIndexes[15], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(0, 0), FACING_NONE); + } + break; + + case 22: + _scene->_sequences.remove(_globals._sequenceIndexes[8]); + _globals[kBottleDisplayed] = false; + break; + + default: + break; + } + + _globals._sequenceIndexes[12] = _scene->_sequences.startCycle(_globals._spriteIndexes[12], false, 6); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[12], seqIdx); + _scene->_sequences.setDepth(_globals._sequenceIndexes[12], 8); + _scene->_sequences.addTimer(10, 98); + } + break; + + case 98: + _scene->_sequences.remove(_globals._sequenceIndexes[12]); + _globals._sequenceIndexes[12] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[12], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[12], 1, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[12], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 99); + break; + + case 99: { + int seqIdx = _globals._sequenceIndexes[12]; + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 1); + _bartenderSteady = true; + int idx = _scene->_dynamicHotspots.add(NOUN_BARTENDER, 0xD, _globals._sequenceIndexes[9], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(228, 83), FACING_SOUTH); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[9], seqIdx); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + if (_bartenderMode == 20) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(210, 41), 0xFDFC, 0, 0, 100, _game.getQuote(0x1F3)); + _scene->_sequences.addTimer(5, 100); + _talkTimer = 180; + _roxMode = 22; + _scene->_sequences.addTimer(65, 92); + } else if ((_bartenderMode == 21) || (_bartenderMode == 22)) { + _game._player._stepEnabled = true; + _bartenderReady = true; + } + + } + break; + } + + switch (_game._trigger) { + case 86: + _bartenderReady = false; + _game._player._stepEnabled = false; + if ((_bartenderHandsHips) || (_bartenderTalking)) { + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + _bartenderHandsHips = false; + _bartenderTalking = false; + } else if (_bartenderLooksLeft) { + _scene->_sequences.remove(_globals._sequenceIndexes[11]); + _bartenderLooksLeft = false; + } else if (_bartenderSteady) { + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _bartenderSteady = false; + } + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[9], 1, 9); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 87); + break; + + case 87: { + int seqIdx = _globals._sequenceIndexes[9]; + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 9); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[9], seqIdx); + _scene->_sequences.addTimer(10, 89); + + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], 1, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 7); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 88); + } + break; + + case 88: + _globals._sequenceIndexes[8] = _scene->_sequences.startCycle(_globals._spriteIndexes[8], false, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 7); + _globals[kBottleDisplayed] = true; + break; + + case 89: + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + _scene->_sequences.addTimer(10, 90); + break; + + case 90: + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + _scene->_sequences.addTimer(10, 91); + break; + + case 91: { + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 1); + int idx = _scene->_dynamicHotspots.add(NOUN_BARTENDER, 0xD, _globals._sequenceIndexes[9], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(228, 83), FACING_SOUTH); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + _bartenderSteady = true; + _game._player._stepEnabled = true; + _bartenderReady = true; + } + break; + } + + if (!_waitingGinnyMove && !_ginnyLooking) { + _waitingGinnyMove = true; + ++ _beatCounter; + if (_beatCounter >= 20) { + _ginnyLooking = true; + _beatCounter = 0; + _scene->_sequences.addTimer(60, 54); + } else { + _scene->_sequences.addTimer(30, 75); + } + } + + switch (_game._trigger) { + case 75: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _bigBeatFl = !_bigBeatFl; + + if (_bigBeatFl) { + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 5); + _scene->_sequences.addTimer(8, 130); + } else { + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 5); + _scene->_sequences.addTimer(8, 53); + } + + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 1); + break; + + case 130: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 1); + _scene->_sequences.addTimer(8, 131); + break; + + case 131: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 1); + _scene->_sequences.addTimer(8, 53); + break; + + case 53: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 1); + _waitingGinnyMove = false; + break; + } + + if ((_game._trigger == 54) && _ginnyLooking) { + ++_beatCounter; + if (_beatCounter >= 10) { + _ginnyLooking = false; + _waitingGinnyMove = false; + _beatCounter = 0; + _bigBeatFl = true; + } else { + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, _vm->getRandomNumber(1, 4)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 1); + _scene->_sequences.addTimer(60, 54); + } + } + + if (_bartenderReady) { + if (_vm->getRandomNumber(1, 250) == 1) { + if (_bartenderLooksLeft) { + _scene->_sequences.remove(_globals._sequenceIndexes[11]); + _bartenderLooksLeft = false; + } else if (_bartenderHandsHips) { + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + _bartenderHandsHips = false; + } else if (_bartenderSteady) { + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _bartenderSteady = false; + } + + switch (_vm->getRandomNumber(1, 3)) { + case 1: { + _globals._sequenceIndexes[10] = _scene->_sequences.startCycle(_globals._spriteIndexes[10], false, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 8); + int idx = _scene->_dynamicHotspots.add(NOUN_BARTENDER, 0xD, _globals._sequenceIndexes[10], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(228, 83), FACING_SOUTH); + _bartenderHandsHips = true; + } + break; + + case 2: { + _globals._sequenceIndexes[11] = _scene->_sequences.startCycle(_globals._spriteIndexes[11], false, 2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[11], 8); + int idx = _scene->_dynamicHotspots.add(NOUN_BARTENDER, 0xD, _globals._sequenceIndexes[11], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(228, 83), FACING_SOUTH); + _bartenderLooksLeft = true; + } + break; + + case 3: { + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + int idx = _scene->_dynamicHotspots.add(NOUN_BARTENDER, 0xD, _globals._sequenceIndexes[9], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(228, 83), FACING_SOUTH); + _bartenderSteady = true; + } + break; + + default: + break; + } + } + } + + if (_game._trigger == 76) { + int seqIdx = _globals._sequenceIndexes[6]; + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 5); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[6], seqIdx); + if (!_globals[kBeenThruHelgaScene]) { + _game._player._stepEnabled = false; + _cutSceneNeeded = true; + } else { + _game._player._stepEnabled = true; + } + _roxOnStool = true; + } + + switch (_game._trigger) { + case 77: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[6]); + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[7], 10, 12); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 78); + break; + + case 78: { + _vm->_sound->command(57); + int seqIdx = _globals._sequenceIndexes[7]; + _game._objects.addToInventory(OBJ_REPAIR_LIST); + _scene->_sequences.remove(_globals._sequenceIndexes[14]); + _globals._sequenceIndexes[7] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[7], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[7], 10, 12); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 5); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[7], seqIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 79); + } + break; + + case 79: { + int seqIdx = _globals._sequenceIndexes[7]; + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 5); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[6], seqIdx); + _scene->_sequences.addTimer(20, 180); + } + break; + + case 180: + _vm->_dialogs->showItem(OBJ_REPAIR_LIST, 40240); + _game._player._stepEnabled = true; + break; + + default: + break; + } + + if (_cutSceneNeeded && _cutSceneReady) { + _cutSceneNeeded = false; + _scene->_sequences.addTimer(20, 55); + _helgaReady = false; + _bartenderReady = false; + } + + if (_vm->getRandomNumber(1, 25) == 1) { + if (_lightOn) { + _scene->_sequences.remove(_globals._sequenceIndexes[0]); + _lightOn = false; + } else { + _globals._sequenceIndexes[0] = _scene->_sequences.startCycle(_globals._spriteIndexes[0], false, 1); + _lightOn = true; + } + } + + if (!_blowingSmoke && (_vm->getRandomNumber(1, 300) == 1)) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 1, 14); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 14); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 30); + _blowingSmoke = true; + } + + switch (_game._trigger) { + case 30: + _globals._sequenceIndexes[1] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[1], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 1, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 14); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1],SEQUENCE_TRIGGER_EXPIRE, 0, 31); + break; + + case 31: + _blowingSmoke = false; + break; + } + + if (!_leftWomanMoving) { + if (_vm->getRandomNumber(1, 1000) == 1) { + switch (_vm->getRandomNumber(1, 2)) { + case 1: + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 33); + _leftWomanMoving = true; + break; + + case 2: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + _scene->_sequences.addTimer(12, 35); + _leftWomanMoving = true; + break; + + default: + break; + } + } + } + + switch (_game._trigger) { + case 33: { + int seqIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 9); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], seqIdx); + _scene->_sequences.addTimer(_vm->getRandomNumber(60, 250), 34); + } + break; + + case 34: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[2], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 38); + break; + + case 35: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 2); + _scene->_sequences.addTimer(_vm->getRandomNumber(60, 300), 36); + break; + + case 36: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + _scene->_sequences.addTimer(12, 37); + break; + + case 37: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _leftWomanMoving = false; + break; + + case 38: + _leftWomanMoving = false; + break; + + default: + break; + } + + if (!_rightWomanMoving) { + if (_vm->getRandomNumber(1, 300) == 1) { + switch (_vm->getRandomNumber(1, 4)) { + case 1: + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 32); + _rightWomanMoving = true; + break; + + case 2: + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 4, 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 32); + _rightWomanMoving = true; + break; + + case 3: + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 4, 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 32); + _rightWomanMoving = true; + break; + + case 4: + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 3, 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 32); + _rightWomanMoving = true; + break; + + default: + break; + } + } + } + + if (_game._trigger == 32) + _rightWomanMoving = false; + + if (_scene->_activeAnimation->getCurrentFrame() == 1) { + switch (_vm->getRandomNumber(1, 50)) { + case 1: + _scene->_activeAnimation->setCurrentFrame(2); + break; + + case 2: + _scene->_activeAnimation->setCurrentFrame(7); + break; + + case 3: + _scene->_activeAnimation->setCurrentFrame(11); + break; + + default: + _scene->_activeAnimation->setCurrentFrame(0); + break; + } + } + + if ((_scene->_activeAnimation->getCurrentFrame() == 4) && (_drinkTimer < 10)) { + ++ _drinkTimer; + _scene->_activeAnimation->setCurrentFrame(3); + } + + if (_drinkTimer == 10) { + _drinkTimer = 0; + _scene->_activeAnimation->setCurrentFrame(4); + _scene->_activeAnimation->_currentFrame = 5; + } + + + switch (_scene->_activeAnimation->getCurrentFrame()) { + case 6: + case 10: + case 14: + _scene->_activeAnimation->setCurrentFrame(0); + break; + + default: + break; + } + + switch (_game._trigger) { + case 39: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(89, 67), 0xFDFC, 32, 0, 120, _game.getQuote(0x1D8)); + _scene->_sequences.addTimer(150, 40); + break; + + case 40: + _scene->_kernelMessages.add(Common::Point(89, 67), 0xFDFC, 32, 0, 120, _game.getQuote(0x1D9)); + _scene->_sequences.addTimer(150, 41); + break; + + case 41: + _scene->_kernelMessages.add(Common::Point(89, 67), 0xFDFC, 32, 0, 120, _game.getQuote(0x1DA)); + _game._player._stepEnabled = true; + break; + + case 42: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(89, 67), 0xFDFC, 32, 0, 120, _game.getQuote(0x1DC)); + _scene->_sequences.addTimer(150, 43); + break; + + case 43: + _scene->_kernelMessages.add(Common::Point(89, 67), 0xFDFC, 32, 0, 120, _game.getQuote(0x1DD)); + _game._player._stepEnabled = true; + break; + + case 44: + _game._player._stepEnabled = true; + break; + + default: + break; + } + + switch (_game._trigger) { + case 55: + if (_bartenderHandsHips) { + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + _bartenderHandsHips = false; + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 1); + int idx = _scene->_dynamicHotspots.add(NOUN_BARTENDER, 0xD, _globals._sequenceIndexes[9], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(228, 83), FACING_SOUTH); + _bartenderSteady = true; + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + } else if (_bartenderLooksLeft) { + _scene->_sequences.remove(_globals._sequenceIndexes[11]); + _bartenderLooksLeft = false; + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 1); + int idx = _scene->_dynamicHotspots.add(NOUN_BARTENDER, 0xD, _globals._sequenceIndexes[9], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(228, 83), FACING_SOUTH); + _bartenderSteady = true; + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + } + _game._player._stepEnabled = false; + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(180, 47), 0xFBFA, 0, 0, 100, _game.getQuote(0x1FE)); + _scene->_sequences.addTimer(120, 56); + break; + + case 56: + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[13], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 2, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 57); + break; + + case 57: { + int seqIdx = _globals._sequenceIndexes[13]; + _scene->_sequences.remove(_globals._sequenceIndexes[20]); + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[13], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 6, 9); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 58); + } + break; + + case 58: { + int seqIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[13], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 5, 9); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 59); + } + break; + + case 59: { + int seqIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[13], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 1, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 60); + _globals._sequenceIndexes[20] = _scene->_sequences.startCycle(_globals._spriteIndexes[20], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[20], 8); + _scene->_sequences.setPosition(_globals._sequenceIndexes[20], Common::Point(234, 72)); + } + break; + + case 60: { + int seqIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.startCycle(_globals._spriteIndexes[13], false, 2); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.addTimer(10, 61); + } + break; + + case 61: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(181, 33), 0xFBFA, 0, 0, 130, _game.getQuote(0x1FF)); + _scene->_kernelMessages.add(Common::Point(171, 47), 0xFBFA, 0, 0, 130, _game.getQuote(0x200)); + _scene->_sequences.addTimer(150, 63); + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 30, 4, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 10, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 62); + break; + + case 62: { + int seqIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.startCycle(_globals._spriteIndexes[13], false, 2); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + } + break; + + case 63: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(160, 33), 0xFBFA, 0, 0, 130, _game.getQuote(0x201)); + _scene->_kernelMessages.add(Common::Point(165, 47), 0xFBFA, 0, 0, 130, _game.getQuote(0x202)); + _scene->_sequences.addTimer(150, 64); + break; + + case 64: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(210, 27), 0xFDFC, 0, 0, 130, _game.getQuote(0x1E0)); + _scene->_kernelMessages.add(Common::Point(198, 41), 0xFDFC, 0, 0, 130, _game.getQuote(0x1E1)); + _scene->_sequences.addTimer(150, 65); + _scene->_sequences.addTimer(1, 100); + _talkTimer = 1130; + break; + + case 65: + _vm->_sound->command(30); + _globals._sequenceIndexes[16] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[16], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[16], 1, 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[16], 9); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[16], SEQUENCE_TRIGGER_EXPIRE, 0, 66); + break; + + case 66: { + int seqIdx = _globals._sequenceIndexes[16]; + _globals._sequenceIndexes[16] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[16], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[16], 7, 37); + _scene->_sequences.setDepth(_globals._sequenceIndexes[16], 9); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[16], seqIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[16], SEQUENCE_TRIGGER_EXPIRE, 0, 68); + + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[13], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 12, 13); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 67); + } + break; + + case 67: { + int seqIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.startCycle(_globals._spriteIndexes[13], false, 13); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + } + break; + + case 68: + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _globals._sequenceIndexes[13] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[13], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 12, 13); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 69); + break; + + case 69: { + int seqIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 25, 4, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 10, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(179, 33), 0xFBFA, 0, 0, 130, _game.getQuote(0x203)); + _scene->_kernelMessages.add(Common::Point(167, 47), 0xFBFA, 0, 0, 130, _game.getQuote(0x204)); + _scene->_sequences.addTimer(150, 71); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 70); + } + break; + + case 70: + _globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 25, 4, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 10, 12); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + break; + + case 71: + _scene->_sequences.addTimer(210, 73); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(168, 33), 0xFBFA, 0, 0, 180, _game.getQuote(0x205)); + _scene->_kernelMessages.add(Common::Point(151, 47), 0xFBFA, 0, 0, 180, _game.getQuote(0x206)); + if (!_game._objects.isInInventory(OBJ_REPAIR_LIST)) + _activeArrows = true; + break; + + case 72: { + int seqIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.startCycle(_globals._spriteIndexes[13], false, 2); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + } + break; + + case 73: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(177, 33), 0xFBFA, 0, 0, 150, _game.getQuote(0x207)); + _scene->_kernelMessages.add(Common::Point(172, 47), 0xFBFA, 0, 0, 150, _game.getQuote(0x208)); + _bartenderSteady = true; + _game._player._stepEnabled = true; + _helgaReady = true; + _bartenderReady = true; + _globals[kBeenThruHelgaScene] = true; + _activeArrows = false; + break; + + default: + break; + } + + if (_helgaReady) { + int rndVal = _vm->getRandomNumber(1, 1000); + if (rndVal < 6) + switch (rndVal) { + case 1: + _cutSceneReady = false; + _helgaReady = false; + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[13], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 2, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 82); + break; + + case 2: + _cutSceneReady = false; + _helgaReady = false; + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 15, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 11, 13); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 26); + break; + + case 3: + _cutSceneReady = false; + _helgaReady = false; + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[13], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 10, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 26); + break; + + case 4: + _cutSceneReady = false; + _helgaReady = false; + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 15, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 14, 15); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 26); + break; + + case 5: + _cutSceneReady = false; + _helgaReady = false; + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[13], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 16, 19); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 80); + break; + + default: + break; + } + } + + if (_game._trigger == 80) { + int seqIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.startCycle(_globals._spriteIndexes[13], false, 19); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.addTimer(_vm->getRandomNumber(60, 120), 81); + } + + if (_game._trigger == 81) { + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _globals._sequenceIndexes[13] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[13], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 16, 19); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 26); + } + + if (_game._trigger == 26) { + int seqIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.startCycle(_globals._spriteIndexes[13], false, 2); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _cutSceneReady = true; + + if (!_cutSceneNeeded) + _helgaReady = true; + } + + if (_game._trigger == 82) { + _scene->_sequences.remove(_globals._sequenceIndexes[20]); + int seqIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[13], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 6, 9); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 83); + } + + if (_game._trigger == 83) { + int seqIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[13], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 5, 9); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 84); + } + + if (_game._trigger == 84) { + int seqIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[13], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[13], 1, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 85); + + _globals._sequenceIndexes[20] = _scene->_sequences.startCycle(_globals._spriteIndexes[20], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[20], 8); + _scene->_sequences.setPosition(_globals._sequenceIndexes[20], Common::Point(234, 72)); + } + + if (_game._trigger == 85) { + int seqIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.startCycle(_globals._spriteIndexes[13], false, 2); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], seqIdx); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _cutSceneReady = true; + if (!_cutSceneNeeded) + _helgaReady = true; + } + + if (_game._trigger == 102) { + _scene->_sequences.remove(_globals._sequenceIndexes[6]); + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[7], 14, 18); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 103); + } else if (_game._trigger == 103) { + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _roxOnStool = false; + _game._player._facing = FACING_SOUTH; + _game._player.selectSeries(); + _game._player._visible = true; + _game._player._stepEnabled = true; + _game._player._readyToWalk = true; + } + + if (_activeArrows) { + if (!_activeArrow1) { + _globals._sequenceIndexes[17] = _scene->_sequences.startCycle(_globals._spriteIndexes[17], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[17], 1); + _scene->_sequences.addTimer(_vm->getRandomNumber(10, 15), 49); + _activeArrow1 = true; + } + + if (!_activeArrow2) { + _globals._sequenceIndexes[18] = _scene->_sequences.startCycle(_globals._spriteIndexes[18], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[18], 1); + _scene->_sequences.addTimer(_vm->getRandomNumber(10, 15), 50); + _activeArrow2 = true; + } + + if (!_activeArrow3) { + _globals._sequenceIndexes[19] = _scene->_sequences.startCycle(_globals._spriteIndexes[19], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[19], 1); + _scene->_sequences.addTimer(_vm->getRandomNumber(10, 15), 51); + _activeArrow3 = true; + } + } + + if (_game._trigger == 49) { + _scene->_sequences.remove(_globals._sequenceIndexes[17]); + _scene->_sequences.addTimer(_vm->getRandomNumber(10, 15), 45); + } + + if (_game._trigger == 45) + _activeArrow1 = false; + + if (_game._trigger == 50) { + _scene->_sequences.remove(_globals._sequenceIndexes[18]); + _scene->_sequences.addTimer(_vm->getRandomNumber(10, 15), 46); + } + + if (_game._trigger == 46) + _activeArrow2 = false; + + if (_game._trigger == 51) { + _scene->_sequences.remove(_globals._sequenceIndexes[19]); + _scene->_sequences.addTimer(_vm->getRandomNumber(10, 15), 47); + } + + if (_game._trigger == 47) + _activeArrow3 = false; +} + +void Scene402::preActions() { + if (_action.isAction(VERB_SIT_ON, NOUN_BAR_STOOL) && (_game._player._prepareWalkPos.x != 248)) + _game._player.walk(Common::Point(232, 112), FACING_EAST); + + if (_action.isAction(VERB_WALKTO, NOUN_WOMAN_ON_BALCONY)) + _game._player._needToWalk = _game._player._readyToWalk; + + if (!_roxOnStool && _action.isAction(VERB_TAKE, NOUN_CREDIT_CHIP) && !_game._objects.isInInventory(OBJ_CREDIT_CHIP)) + _game._player.walk(Common::Point(246, 108), FACING_NORTH); + + if (_action.isAction(VERB_TAKE)) + _game._player._needToWalk = false; + + if (_action.isAction(VERB_TAKE, NOUN_CREDIT_CHIP) && !_roxOnStool) + _game._player._needToWalk = true; + + if (_roxOnStool) { + if (_action.isAction(VERB_LOOK) || _action.isAction(0x24A) || _action.isAction(VERB_TALKTO)) + _game._player._needToWalk = false; + + if (_action.isAction(VERB_TAKE, NOUN_REPAIR_LIST) || _action.isAction(VERB_TAKE, NOUN_CREDIT_CHIP)) + _game._player._needToWalk = false; + + if (_action.isAction(VERB_TALKTO, NOUN_WOMAN_IN_CHAIR) || _action.isAction(VERB_TALKTO, NOUN_WOMAN_IN_ALCOVE)) + _game._player._needToWalk = _game._player._readyToWalk; + + if (_game._player._needToWalk) { + _game._player._facing = FACING_SOUTH; + _game._player._readyToWalk = false; + _game._player._stepEnabled = false; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 102); + } + } + + if (_action.isAction(VERB_TAKE, NOUN_REPAIR_LIST) && !_roxOnStool && !_game._objects.isInInventory(OBJ_REPAIR_LIST)) + _game._player.walk(Common::Point(191, 99), FACING_NORTHEAST); + + if (_action.isAction(VERB_TALKTO, NOUN_BARTENDER) && !_roxOnStool) + _game._player.walk(Common::Point(228, 83), FACING_SOUTH); + + if (_action.isAction(VERB_TALKTO, NOUN_REPAIR_WOMAN) && !_roxOnStool) + _game._player.walk(Common::Point(208, 102), FACING_NORTHEAST); +} + +void Scene402::actions() { + if (_action.isAction(VERB_TAKE, NOUN_REPAIR_LIST) && _game._objects.isInRoom(OBJ_REPAIR_LIST) && _roxOnStool) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 77); + _game._player._needToWalk = false; + } else if (_action.isAction(VERB_TAKE, NOUN_REPAIR_LIST) && _game._objects.isInRoom(OBJ_REPAIR_LIST) && !_roxOnStool) { + if (_game._trigger == 0) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[21] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[21], false, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[21], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[21]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[21], SEQUENCE_TRIGGER_SPRITE, 2, 165); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[21], SEQUENCE_TRIGGER_EXPIRE, 0, 166); + } else if (_game._trigger == 165) { + _scene->_sequences.remove(_globals._sequenceIndexes[14]); + _game._objects.addToInventory(OBJ_REPAIR_LIST); + } + } else if (_game._trigger == 166) { + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._visible = true; + _scene->_sequences.addTimer(20, 167); + } else if (_game._trigger == 167) { + _vm->_dialogs->showItem(OBJ_REPAIR_LIST, 40240); + _game._player._stepEnabled = true; + } else if (_game._screenObjects._inputMode == 1) + handleDialogs(); + else if (_action.isAction(VERB_WALK_INTO, NOUN_CORRIDOR_TO_SOUTH)) + _scene->_nextSceneId = 401; + else if (_action.isAction(VERB_WALK_ONTO, NOUN_DANCE_FLOOR)) + ; // just... nothing + else if (_action.isAction(VERB_TALKTO, NOUN_REPAIR_WOMAN)) { + switch (_game._trigger) { + case 0: { + _game._player._stepEnabled = false; + int random = _vm->getRandomNumber(1, 3); + if (_helgaTalkMode == 0) + random = 1; + + int centerFlag; + Common::Point centerPos; + if (_roxOnStool) { + centerFlag = 0; + centerPos = Common::Point(230, 56); + } else { + centerFlag = 2; + centerPos = Common::Point(0, 0); + } + + switch (random) { + case 1: + _scene->_kernelMessages.add(centerPos, 0x1110, 32 | centerFlag, 0, 90, _game.getQuote(0x211)); + _scene->_sequences.addTimer(110, 25); + break; + + case 2: + _scene->_kernelMessages.add(centerPos, 0x1110, 32 | centerFlag, 0, 90, _game.getQuote(0x212)); + _scene->_sequences.addTimer(110, 25); + break; + + case 3: + _scene->_kernelMessages.add(centerPos, 0x1110, 32 | centerFlag, 0, 90, _game.getQuote(0x213)); + _scene->_sequences.addTimer(110, 25); + break; + + default: + break; + } + } + break; + + case 25: + switch (_helgaTalkMode) { + case 0: + _game._player._stepEnabled = false; + _helgaTalkMode = 1; + _scene->_kernelMessages.add(Common::Point(177, 33), 0xFBFA, 0, 0, 130, _game.getQuote(0x209)); + _scene->_kernelMessages.add(Common::Point(182, 47), 0xFBFA, 0, 0, 130, _game.getQuote(0x20A)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(130, 28); + break; + + case 1: + _game._player._stepEnabled = false; + _helgaTalkMode = 2; + _scene->_kernelMessages.add(Common::Point(157, 47), 0xFBFA, 0, 0, 100, _game.getQuote(0x20B)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(100, 28); + break; + + case 2: + _game._player._stepEnabled = false; + _helgaTalkMode = 3; + _scene->_kernelMessages.add(Common::Point(172, 47), 0xFBFA, 0, 0, 100, _game.getQuote(0x20C)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(100, 28); + break; + + case 3: + _game._player._stepEnabled = true; + break; + + default: + break; + } + break; + } + } else if (_action.isAction(VERB_TALKTO, NOUN_WOMAN_IN_CHAIR) && !_firstTalkToGirlInChair) { + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x1D7)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(150, 39); + _game._player._stepEnabled = false; + _firstTalkToGirlInChair = true; + } else if (_action.isAction(VERB_TALKTO, NOUN_WOMAN_IN_CHAIR) && _firstTalkToGirlInChair) { + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x1DB)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(150, 42); + _game._player._stepEnabled = false; + } else if (_action.isAction(VERB_TALKTO, NOUN_WOMAN_IN_ALCOVE) || _action.isAction(VERB_WALKTO, NOUN_WOMAN_IN_ALCOVE)) { + _scene->_kernelMessages.add(Common::Point(102, 48), 0xFBFA, 0, 0, 120, _game.getQuote(0x1DE)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(120, 44); + _game._player._stepEnabled = false; + } else if (_action.isAction(VERB_WALK_ALONG, NOUN_BAR_STOOL) && (_game._player._targetPos.x == 248)){ + _scene->_kernelMessages.add(Common::Point(0, -14), 0x1110, 34, 0, 120, _game.getQuote(0x20D)); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x20E)); + } else if (_action.isAction(VERB_WALK_ALONG, NOUN_BAR_STOOL) && !_roxOnStool && (_game._player._targetPos.x != 248)) { + _game._player._visible = false; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 1, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 76); + _game._player._stepEnabled = false; + } else if (_action.isAction(VERB_TAKE, NOUN_CREDIT_CHIP) && !_game._objects.isInInventory(OBJ_CREDIT_CHIP) && _roxOnStool) { + _roxMode = 20; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 92); + } else if (_action.isAction(VERB_TAKE, NOUN_CREDIT_CHIP) && !_game._objects.isInInventory(OBJ_CREDIT_CHIP) && !_roxOnStool) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[22] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[22], false, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[22], 1, 2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[22], Common::Point(_game._player._playerPos.x, _game._player._playerPos.y + 1)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[22], 5); + _scene->_sequences.setScale(_globals._sequenceIndexes[22], 88); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[22], SEQUENCE_TRIGGER_EXPIRE, 0, 104); + } else if (_action.isAction(VERB_TALKTO, NOUN_BARTENDER)) { + switch (_game._trigger) { + case 0: { + int centerFlag; + Common::Point centerPos; + if (_roxOnStool) { + centerFlag = 0; + centerPos = Common::Point(230, 56); + } else { + centerFlag = 2; + centerPos = Common::Point(0, 0); + } + + _game._player._stepEnabled = false; + int quoteId; + if (_bartenderCalled) { + quoteId = 0x210; + } else { + quoteId = 0x20F; + _bartenderCalled = true; + } + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(centerPos, 0x1110, 32 | centerFlag, 0, 90, _game.getQuote(quoteId)); + _scene->_sequences.addTimer(110, 29); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(90, 28); + } + break; + + case 29: + _scene->_kernelMessages.reset(); + if (!_roxOnStool) { + if (_game._objects.isInRoom(OBJ_ALIEN_LIQUOR)) { + _scene->_kernelMessages.add(Common::Point(177, 41), 0xFDFC, 0, 0, 120, _game.getQuote(0x1DF)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 120; + } else if (_rexMode == 0) { + _scene->_kernelMessages.add(Common::Point(175, 13), 0xFDFC, 0, 0, 180, _game.getQuote(0x1F9)); + _scene->_kernelMessages.add(Common::Point(184, 27), 0xFDFC, 0, 0, 180, _game.getQuote(0x1FA)); + _scene->_kernelMessages.add(Common::Point(200, 41), 0xFDFC, 0, 0, 180, _game.getQuote(0x1FB)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 180; + _rexMode = 1; + } else if (_rexMode == 1) { + _scene->_kernelMessages.add(Common::Point(205, 41), 0xFDFC, 0, 0, 120, _game.getQuote(0x1FC)); + _game._player._stepEnabled = true; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 120; + _rexMode = 3; + } else { + _game._player._stepEnabled = true; + } + } else { + if (_game._objects.isInRoom(OBJ_ALIEN_LIQUOR)) { + if (!_refuseAlienLiquor) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(198, 27), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1E2)); + _scene->_kernelMessages.add(Common::Point(199, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1E3)); + _bartenderCurrentQuestion = 10; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 120; + _conversationFl = true; + _bartenderDialogNode = 1; + if (_dialog2.read(0) <= 1) + _dialog1.write(0x214, false); + + _dialog1.start(); + } else { + _scene->_kernelMessages.add(Common::Point(177, 41), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x1EF)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 120; + _bartenderCurrentQuestion = 3; + _conversationFl = true; + _bartenderDialogNode = 1; + if (_dialog2.read(0) <= 1) + _dialog1.write(0x214, false); + + _dialog1.start(); + _game._player._stepEnabled = true; + } + } else { + if (_rexMode == 0) { + _scene->_kernelMessages.add(Common::Point(175, 13), 0xFDFC, 0, 0, 180, _game.getQuote(0x1F9)); + _scene->_kernelMessages.add(Common::Point(184, 27), 0xFDFC, 0, 0, 180, _game.getQuote(0x1FA)); + _scene->_kernelMessages.add(Common::Point(200, 41), 0xFDFC, 0, 0, 180, _game.getQuote(0x1FB)); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 180; + _rexMode = 1; + } else if (_rexMode == 1) { + _scene->_kernelMessages.add(Common::Point(205, 41), 0xFDFC, 0, 0, 120, _game.getQuote(0x1FC)); + _game._player._stepEnabled = true; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(1, 100); + _talkTimer = 120; + _rexMode = 3; + } else { + _game._player._stepEnabled = true; + } + } + } + break; + + default: + break; + } + } else if (_action.isAction(VERB_LOOK, NOUN_DANCE_FLOOR)) + _vm->_dialogs->show(40210); + else if (_action.isAction(VERB_LOOK, NOUN_TELEPORTER)) { + if (_globals[kSomeoneHasExploded]) + _vm->_dialogs->show(40212); + else + _vm->_dialogs->show(40211); + } else if (_action.isAction(VERB_LOOK, NOUN_BAR)) + _vm->_dialogs->show(40213); + else if (_action.isAction(VERB_LOOK, NOUN_BARTENDER)) + _vm->_dialogs->show(40214); + else if (_action.isAction(VERB_LOOK, NOUN_WOMAN_IN_ALCOVE)) + _vm->_dialogs->show(40215); + else if (_action.isAction(VERB_LOOK, NOUN_WOMAN_ON_BALCONY)) + _vm->_dialogs->show(40216); + else if (_action.isAction(VERB_LOOK, NOUN_WOMAN_IN_CHAIR)) + _vm->_dialogs->show(40217); + else if (_action.isAction(VERB_LOOK, NOUN_REPAIR_WOMAN)) + _vm->_dialogs->show(40218); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_SOUTH)) + _vm->_dialogs->show(40219); + else if (_action._lookFlag) + _vm->_dialogs->show(40220); + else if (_action.isAction(VERB_LOOK, NOUN_WOMEN)) + _vm->_dialogs->show(40221); + else if (_action.isAction(VERB_PUSH, NOUN_REPAIR_WOMAN) || _action.isAction(VERB_PULL, NOUN_REPAIR_WOMAN)) + _vm->_dialogs->show(40222); + else if (_action.isAction(VERB_TALKTO, NOUN_WOMEN)) + _vm->_dialogs->show(40223); + else if (_action.isAction(VERB_TALKTO, NOUN_WOMAN_ON_BALCONY)) + _vm->_dialogs->show(40224); + else if (_action.isAction(VERB_LOOK, NOUN_RAILING)) + _vm->_dialogs->show(40225); + else if (_action.isAction(VERB_LOOK, NOUN_TABLE)) + _vm->_dialogs->show(40226); + else if (_action.isAction(VERB_TAKE, NOUN_TABLE)) + _vm->_dialogs->show(40227); + else if (_action.isAction(VERB_LOOK, NOUN_SIGN)) + _vm->_dialogs->show(40228); + else if (_action.isAction(VERB_TAKE, NOUN_SIGN)) + _vm->_dialogs->show(40229); + else if (_action.isAction(VERB_LOOK, NOUN_BAR_STOOL)) + _vm->_dialogs->show(40230); + else if (_action.isAction(VERB_TAKE, NOUN_BAR_STOOL)) + _vm->_dialogs->show(40231); + else if (_action.isAction(VERB_LOOK, NOUN_CACTUS)) + _vm->_dialogs->show(40232); + else if (_action.isAction(VERB_TAKE, NOUN_CACTUS)) + _vm->_dialogs->show(40233); + else if (_action.isAction(VERB_LOOK, NOUN_DISCO_BALL)) + _vm->_dialogs->show(40234); + else if (_action.isAction(VERB_LOOK, NOUN_UPPER_DANCE_FLOOR)) + _vm->_dialogs->show(40235); + else if (_action.isAction(VERB_LOOK, NOUN_TREE)) + _vm->_dialogs->show(40236); + else if (_action.isAction(VERB_LOOK, NOUN_PLANT)) + _vm->_dialogs->show(40237); + else if (_action.isAction(VERB_TAKE, NOUN_PLANT)) + _vm->_dialogs->show(40238); + else if (_action.isAction(VERB_LOOK, NOUN_REPAIR_LIST) && _game._objects.isInRoom(OBJ_REPAIR_LIST)) + _vm->_dialogs->show(40239); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene405::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene405::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*ROXCL_8"); + + if (_scene->_priorSceneId == 401) { + _game._player._playerPos = Common::Point(23, 123); + _game._player._facing = FACING_EAST; + } else if (_scene->_priorSceneId == 406) { + _game._player._playerPos = Common::Point(300, 128); + _game._player._facing = FACING_WEST; + } else if (_scene->_priorSceneId == 408) { + _game._player._playerPos = Common::Point(154, 109); + _game._player._facing = FACING_SOUTH; + } else if (_scene->_priorSceneId == 413) { + _game._player._playerPos = Common::Point(284, 109); + _game._player._facing = FACING_SOUTH; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(23, 123); + _game._player._facing = FACING_EAST; + } + + if (_globals[kArmoryDoorOpen]) + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + else + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + + if (_scene->_roomChanged) { + _globals[kArmoryDoorOpen] = false; + _game._objects.addToInventory(OBJ_SECURITY_CARD); + } + + _game.loadQuoteSet(0x24F, 0); + sceneEntrySound(); +} + +void Scene405::step() { + if (_game._trigger == 80) { + _scene->_sequences.addTimer(20, 81); + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._visible = true; + } + + if (_game._trigger == 81) { + _game._player._stepEnabled = true; + _vm->_dialogs->show(40525); + } + + if (_game._trigger == 70) { + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount ; + _game._player._visible = true; + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + _vm->_sound->command(19); + } + + if (_game._trigger == 71) { + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _globals[kArmoryDoorOpen] = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _game._player._stepEnabled = true; + } + + if (_game._trigger == 75) { + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount ; + _game._player._visible = true; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0); + _globals[kArmoryDoorOpen] = true; + _game._player._stepEnabled = true; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle (_globals._spriteIndexes[2], + false, 1); + _vm->_sound->command(19); + } +} + +void Scene405::preActions() { + if (_action.isAction(VERB_TAKE)) + _game._player._needToWalk = false; + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_WEST)) + _game._player._walkOffScreenSceneId = 401; + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_EAST)) + _game._player._walkOffScreenSceneId = 406; + + if (_action.isAction(VERB_CLOSE, NOUN_WIDE_DOOR) && _globals[kArmoryDoorOpen]) + _game._player.walk(Common::Point(212, 113), FACING_NORTH); +} + +void Scene405::actions() { + if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOOR)) + _scene->_nextSceneId = 413; + else if (_action.isAction(VERB_WALK_THROUGH, NOUN_WIDE_DOOR) && _globals[kArmoryDoorOpen]) + _scene->_nextSceneId = 408; + else if (_action.isAction(VERB_WALK_THROUGH, NOUN_WIDE_DOOR) && !_globals[kArmoryDoorOpen]) + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 60, _game.getQuote(0x24F)); + else if (_action.isAction(VERB_PUT, NOUN_SECURITY_CARD, 0x251) && !_globals[kArmoryDoorOpen]) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 75); + Common::Point msgPos = Common::Point(_game._player._playerPos.x, _game._player._playerPos.y + 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[3], msgPos); + _scene->_sequences.setScale(_globals._sequenceIndexes[3], 87); + } else if ((_action.isAction(VERB_PUT, NOUN_SECURITY_CARD, 0x251) || _action.isAction(VERB_CLOSE, NOUN_WIDE_DOOR)) && _globals[kArmoryDoorOpen]) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 70); + _scene->_sequences.setPosition(_globals._sequenceIndexes[3], _game._player._playerPos); + _scene->_sequences.setScale(_globals._sequenceIndexes[3], 87); + } else if (_action.isAction(VERB_PUT, NOUN_CARD_SLOT)) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 80); + _scene->_sequences.setPosition(_globals._sequenceIndexes[3], _game._player._playerPos); + _scene->_sequences.setScale(_globals._sequenceIndexes[3], 87); + } else if (_action.isAction(VERB_LOOK, NOUN_CANNON_BALLS)) + _vm->_dialogs->show(40510); + else if (_action.isAction(VERB_TAKE, NOUN_CANNON_BALLS)) + _vm->_dialogs->show(40511); + else if (_action.isAction(VERB_LOOK, NOUN_WATER_FOUNTAIN)) + _vm->_dialogs->show(40512); + else if (_action.isAction(VERB_LOOK, NOUN_BACKBOARD) || _action.isAction(VERB_LOOK, NOUN_HOOP)) + _vm->_dialogs->show(40513); + else if (_action.isAction(VERB_LOOK, NOUN_LIGHT)) + _vm->_dialogs->show(40514); + else if (_action.isAction(VERB_LOOK, NOUN_CARD_SLOT)) + _vm->_dialogs->show(40515); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_EAST)) + _vm->_dialogs->show(40516); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_WEST)) + _vm->_dialogs->show(40517); + else if (_action.isAction(VERB_LOOK, NOUN_MONITOR)) + _vm->_dialogs->show(40518); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR) || _action._lookFlag) + _vm->_dialogs->show(40519); + else if (_action.isAction(VERB_LOOK, NOUN_WIDE_DOOR)) { + if (_globals[kArmoryDoorOpen]) + _vm->_dialogs->show(40521); + else + _vm->_dialogs->show(40520); + } else if (_action.isAction(VERB_LOOK, NOUN_DOOR)) + _vm->_dialogs->show(40522); + else if (_action.isAction(VERB_LOOK, NOUN_COACH_LAMP)) + _vm->_dialogs->show(40523); + else if (_action.isAction(VERB_LOOK, NOUN_SUPPORT)) + _vm->_dialogs->show(40524); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene406::Scene406(MADSEngine *vm) : Scene4xx(vm) { + _hitStorageDoor = false; +} + +void Scene406::synchronize(Common::Serializer &s) { + Scene4xx::synchronize(s); + + s.syncAsByte(_hitStorageDoor); +} + +void Scene406::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene406::enter() { + _game._player._visible = true; + if (_scene->_priorSceneId == 405) { + _game._player._playerPos = Common::Point(15, 129); + _game._player._facing = FACING_EAST; + } else if (_scene->_priorSceneId == 407) { + _game._player._playerPos = Common::Point(270, 127); + _game._player._facing = FACING_WEST; + } else if (_scene->_priorSceneId == 410) { + _game._player._playerPos = Common::Point(30, 108); + _game._player._facing = FACING_SOUTH; + } else if (_scene->_priorSceneId == 411) { + _game._player._playerPos = Common::Point(153, 108); + _game._player._facing = FACING_SOUTH; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(15, 129); + _game._player._facing = FACING_EAST; + } + + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*ROXCL_8"); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 1)); + + if (_scene->_roomChanged) { + _globals[kStorageDoorOpen] = false; + _game._objects.addToInventory(OBJ_SECURITY_CARD); + } + + if (!_globals[kStorageDoorOpen]) + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + + if (_scene->_priorSceneId != 411) + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + else { + _game._player._stepEnabled = false; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 3, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 90); + _vm->_sound->command(19); + } + + _game.loadQuoteSet(0x24F, 0); + _hitStorageDoor = false; + sceneEntrySound(); +} + +void Scene406::step() { + if (_game._trigger == 90) { + _game._player._stepEnabled = true; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + } + + if (_game._trigger == 80) + _scene->_nextSceneId = 411; + + if (_game._trigger == 100) { + _vm->_dialogs->show(40622); + _hitStorageDoor = true; + } + + if (_game._trigger == 110) { + _scene->_sequences.addTimer(20, 111); + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._visible = true; + } + + if (_game._trigger == 111) { + _game._player._stepEnabled = true; + _vm->_dialogs->show(40613); + } + + if (_game._trigger == 70) { + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._visible = true; + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 4, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + _vm->_sound->command(19); + } + + if (_game._trigger == 71) { + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _globals[kStorageDoorOpen] = false; + _game._player._stepEnabled = true; + } + + if (_game._trigger == 75) { + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 4, 1, 0, 0); + _globals[kStorageDoorOpen] = true; + _game._player._stepEnabled = true; + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._visible = true; + _vm->_sound->command(19); + } +} + +void Scene406::preActions() { + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_WEST)) + _game._player._walkOffScreenSceneId = 405; + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_EAST)) + _game._player._walkOffScreenSceneId = 407; + + if (_action.isAction(VERB_TAKE)) + _game._player._needToWalk = false; + + if (_action.isAction(VERB_LOOK, NOUN_SIGN) || _action.isAction(VERB_LOOK, NOUN_TRASH)) + _game._player._needToWalk = true; +} + +void Scene406::actions() { + if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOOR) && (_game._player._targetPos.x> 100)) { + _game._player._stepEnabled = false; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 3, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 80); + _vm->_sound->command(19); + } else if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOOR) && _globals[kStorageDoorOpen] && (_game._player._targetPos.x < 100)) + _scene->_nextSceneId = 410; + else if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOOR) && !_globals[kStorageDoorOpen] && (_game._player._targetPos.x < 100)) { + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 60, _game.getQuote(0x24F)); + if (!_hitStorageDoor) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(80, 100); + } + } else if (_action.isAction(VERB_PUT, NOUN_SECURITY_CARD, 0x251) && !_globals[kStorageDoorOpen]) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 75); + Common::Point msgPos = Common::Point(_game._player._playerPos.x, _game._player._playerPos.y + 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], msgPos); + _scene->_sequences.setScale(_globals._sequenceIndexes[2], 87); + } else if (_action.isAction(VERB_PUT, NOUN_SECURITY_CARD, 0x251) && _globals[kStorageDoorOpen]) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 70); + Common::Point msgPos = Common::Point(_game._player._playerPos.x, _game._player._playerPos.y + 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], msgPos); + _scene->_sequences.setScale(_globals._sequenceIndexes[2], 87); + } else if (_action.isAction(VERB_PUT, NOUN_CARD_SLOT)) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 110); + _scene->_sequences.setPosition(_globals._sequenceIndexes[2], _game._player._playerPos); + _scene->_sequences.setScale(_globals._sequenceIndexes[2], 87); + } else if (_action.isAction(VERB_LOOK, NOUN_TRASH)) + _vm->_dialogs->show(40610); + else if (_action.isAction(VERB_TAKE, NOUN_TRASH)) + _vm->_dialogs->show(40611); + else if (_action.isAction(VERB_LOOK, NOUN_CARD_SLOT)) + _vm->_dialogs->show(40612); + else if (_action.isAction(VERB_LOOK, NOUN_FIRE_EXTINGUISHER)) + _vm->_dialogs->show(40614); + else if (_action.isAction(VERB_TAKE, NOUN_FIRE_EXTINGUISHER)) + _vm->_dialogs->show(40615); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_EAST)) + _vm->_dialogs->show(40616); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_WEST)) + _vm->_dialogs->show(40617); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR) || _action._lookFlag) + _vm->_dialogs->show(40618); + else if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(40619); + else if (_action.isAction(VERB_LOOK, NOUN_DOOR)) { + if (_globals[kStorageDoorOpen]) + _vm->_dialogs->show(40621); + else + _vm->_dialogs->show(40620); + } else if (_action.isAction(VERB_LOOK, NOUN_MONITOR)) + _vm->_dialogs->show(40623); + else if (_action.isAction(VERB_LOOK, NOUN_SIGNPOST)) + _vm->_dialogs->show(40624); + else if (_action.isAction(VERB_TAKE, NOUN_SIGNPOST)) + _vm->_dialogs->show(40625); + else if (_action.isAction(VERB_LOOK, NOUN_BOULDER)) + _vm->_dialogs->show(40626); + else if (_action.isAction(VERB_TAKE, NOUN_BOULDER)) + _vm->_dialogs->show(40627); + else if (_action.isAction(VERB_LOOK, NOUN_SIGN)) + _vm->_dialogs->show(40628); + else if (_action.isAction(VERB_TAKE, NOUN_SIGN)) + _vm->_dialogs->show(40629); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene407::Scene407(MADSEngine *vm) : Scene4xx(vm), _destPos(0, 0) { + _fromNorth = false; +} + +void Scene407::synchronize(Common::Serializer &s) { + Scene4xx::synchronize(s); + + s.syncAsByte(_fromNorth); + s.syncAsSint16LE(_destPos.x); + s.syncAsSint16LE(_destPos.y); +} + +void Scene407::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene407::enter() { + if (_scene->_priorSceneId != -2) + _fromNorth = false; + + if (_scene->_priorSceneId == 318) { + _game._player._playerPos = Common::Point(172, 92); + _game._player._facing = FACING_SOUTH; + _fromNorth = true; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(172, 132); + _game._player._facing = FACING_NORTH; + } + + _game.loadQuoteSet(0x250, 0); + sceneEntrySound(); +} + +void Scene407::step() { + if (_game._trigger == 70) { + _scene->_nextSceneId = 318; + _scene->_reloadSceneFlag = true; + } + + if (_game._trigger == 80) { + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _game._player._stepEnabled = true; + _game._player._visible = true; + _fromNorth = false; + _game._player.walk(Common::Point(173, 104), FACING_SOUTH); + } +} + +void Scene407::preActions() { + if (_action.isAction(VERB_TAKE)) + _game._player._needToWalk = false; + + if (_action.isAction(VERB_LOOK, NOUN_DOOR)) + _game._player._needToWalk = true; + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_NORTH)) { + _game._player.walk(Common::Point(172, 91), FACING_NORTH); + _fromNorth = false; + } + + if (_game._player._needToWalk && _fromNorth) { + if (_globals[kSexOfRex] == REX_MALE) + _destPos = Common::Point(171, 95); + else + _destPos = Common::Point(173, 96); + + _game._player.walk(_destPos, FACING_SOUTH); + } +} + +void Scene407::actions() { + if ((_game._player._playerPos == _destPos) && _fromNorth) { + if (_globals[kSexOfRex] == REX_MALE) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _game._player._stepEnabled = false; + _game._player._visible = false; + _vm->_sound->command(21); + _scene->loadAnimation(formAnimName('s', 1), 70); + _globals[kHasBeenScanned] = true; + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 60, _game.getQuote(60)); + _vm->_sound->command(22); + } + + if (_globals[kSexOfRex] == REX_FEMALE) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _game._player._stepEnabled = false; + _game._player._visible = false; + _vm->_sound->command(21); + _scene->loadAnimation(formAnimName('s', 2), 80); + _vm->_sound->command(23); + _globals[kHasBeenScanned] = true; + } + } + + if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_SOUTH) && !_fromNorth) + _scene->_nextSceneId = 406; + else if (_action.isAction(VERB_WALK_DOWN, NOUN_CORRIDOR_TO_NORTH)) + _scene->_nextSceneId = 318; + else if (_action.isAction(VERB_LOOK, NOUN_SCANNER)) { + if (_globals[kHasBeenScanned]) + _vm->_dialogs->show(40711); + else + _vm->_dialogs->show(40710); + } else if (_action.isAction(VERB_LOOK, NOUN_DOOR)) + _vm->_dialogs->show(40712); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_SOUTH)) + _vm->_dialogs->show(40713); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_NORTH)) + _vm->_dialogs->show(40714); + else if (_action._lookFlag) + _vm->_dialogs->show(40715); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene408::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_TARGET_MODULE); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene408::enter() { + _game._player._playerPos = Common::Point(137, 150); + _game._player._facing = FACING_NORTH; + + _globals._spriteIndexes[1] = _scene->_sprites.addSprites("*ROXRC_7"); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('m', -1)); + + if (_game._objects.isInRoom(OBJ_TARGET_MODULE)) { + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 3); + int idx = _scene->_dynamicHotspots.add(NOUN_TARGET_MODULE, 0xD, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(283, 128), FACING_NORTHEAST); + } + sceneEntrySound(); +} + +void Scene408::preActions() { + if ((_action.isAction(VERB_TAKE) && !_action.isAction(0x167)) || _action.isAction(VERB_PULL, NOUN_PIN) || _action.isAction(VERB_OPEN, NOUN_CARTON)) + _game._player._needToWalk = false; + + if ((_action.isAction(VERB_LOOK, NOUN_TARGET_MODULE) && _game._objects.isInRoom(OBJ_TARGET_MODULE)) || _action.isAction(VERB_LOOK, NOUN_CHEST)) + _game._player._needToWalk = true; +} + +void Scene408::actions() { + if (_action.isAction(VERB_WALK_INTO, NOUN_CORRIDOR_TO_SOUTH)) { + _scene->_nextSceneId = 405; + _vm->_sound->command(58); + } else if (_action.isAction(VERB_TAKE, NOUN_TARGET_MODULE) && (_game._objects.isInRoom(OBJ_TARGET_MODULE) || _game._trigger)) { + switch (_game._trigger) { + case (0): + _vm->_sound->command(57); + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], true, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[1]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_SPRITE, 2, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _game._objects.addToInventory(OBJ_TARGET_MODULE); + _vm->_dialogs->showItem(OBJ_TARGET_MODULE, 40847); + break; + + case 2: + _game._player._priorTimer = _game._player._ticksAmount + _scene->_frameStartTime; + _game._player._visible = true; + _scene->_sequences.addTimer(20, 3); + break; + + case 3: + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_LOOK, NOUN_ARMORED_VEHICLE)) + _vm->_dialogs->show(40810); + else if (_action.isAction(VERB_TAKE, NOUN_ARMORED_VEHICLE) || _action.isAction(VERB_TAKE, NOUN_ANVIL) || _action.isAction(VERB_TAKE, NOUN_TWO_TON_WEIGHT)) + _vm->_dialogs->show(40811); + else if (_action.isAction(VERB_LOOK, NOUN_MISSILE)) + _vm->_dialogs->show(40812); + else if (_action.isAction(VERB_TAKE, NOUN_MISSILE)) + _vm->_dialogs->show(40813); + else if (_action.isAction(VERB_LOOK, NOUN_GRENADE)) + _vm->_dialogs->show(40814); + else if (_action.isAction(VERB_TAKE, NOUN_GRENADE)) + _vm->_dialogs->show(40815); + else if (_action.isAction(VERB_TAKE, NOUN_PIN) || _action.isAction(VERB_PULL, NOUN_PIN)) + _vm->_dialogs->show(40816); + else if (_action.isAction(VERB_LOOK, NOUN_BLIMP)) + _vm->_dialogs->show(40817); + else if (_action.isAction(VERB_TAKE, NOUN_BLIMP)) + _vm->_dialogs->show(40818); + else if (_action.isAction(VERB_LOOK, NOUN_AMMUNITION)) + _vm->_dialogs->show(40819); + else if (_action.isAction(VERB_TAKE, NOUN_AMMUNITION)) + _vm->_dialogs->show(40820); + else if (_action.isAction(VERB_LOOK, NOUN_CATAPULT)) + _vm->_dialogs->show(40821); + else if (_action.isAction(VERB_TAKE, NOUN_CATAPULT)) + _vm->_dialogs->show(40822); + else if (_action.isAction(VERB_LOOK, NOUN_CHEST)) { + if (_game._objects.isInRoom(OBJ_TARGET_MODULE)) + _vm->_dialogs->show(40823); + else + _vm->_dialogs->show(40824); + } else if (_action.isAction(VERB_TAKE, NOUN_CHEST)) + _vm->_dialogs->show(40825); + else if (_action.isAction(VERB_LOOK, NOUN_SUIT_OF_ARMOR)) + _vm->_dialogs->show(40826); + else if (_action.isAction(VERB_TAKE, NOUN_SUIT_OF_ARMOR)) + _vm->_dialogs->show(40827); + else if (_action.isAction(VERB_LOOK, NOUN_ESCAPE_HATCH)) + _vm->_dialogs->show(40828); + else if (_action.isAction(VERB_OPEN, NOUN_ESCAPE_HATCH) || _action.isAction(VERB_PULL, NOUN_ESCAPE_HATCH)) + _vm->_dialogs->show(40829); + else if (_action.isAction(VERB_LOOK, NOUN_BARRELS)) + _vm->_dialogs->show(40830); + else if (_action.isAction(VERB_TAKE, NOUN_BARRELS)) + _vm->_dialogs->show(40831); + else if (_action.isAction(VERB_LOOK, NOUN_INFLATABLE_RAFT)) + _vm->_dialogs->show(40832); + else if (_action.isAction(VERB_TAKE, NOUN_INFLATABLE_RAFT)) + _vm->_dialogs->show(40833); + else if (_action.isAction(VERB_LOOK, NOUN_TOMATO)) + _vm->_dialogs->show(40834); + else if (_action.isAction(VERB_TAKE, NOUN_TOMATO)) + _vm->_dialogs->show(40835); + else if (_action.isAction(VERB_LOOK, NOUN_ANVIL)) + _vm->_dialogs->show(40836); + else if (_action.isAction(VERB_LOOK, NOUN_TWO_TON_WEIGHT)) + _vm->_dialogs->show(40837); + else if (_action.isAction(VERB_LOOK, NOUN_POWDER_CONTAINER)) + _vm->_dialogs->show(40838); + else if (_action.isAction(VERB_LOOK, NOUN_POWDER_PUFF)) + _vm->_dialogs->show(40839); + else if (_action.isAction(VERB_TAKE, NOUN_POWDER_PUFF)) + _vm->_dialogs->show(40840); + else if (_action.isAction(VERB_LOOK, NOUN_CARTON)) + _vm->_dialogs->show(40841); + else if (_action.isAction(VERB_TAKE, NOUN_CARTON)) + _vm->_dialogs->show(40842); + else if (_action.isAction(VERB_OPEN, NOUN_CARTON)) + _vm->_dialogs->show(40843); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_SOUTH)) + _vm->_dialogs->show(40844); + else if (_action._lookFlag) + _vm->_dialogs->show(40845); + else if (_action.isAction(VERB_LOOK, NOUN_TARGET_MODULE) && _game._objects.isInRoom(OBJ_TARGET_MODULE)) + _vm->_dialogs->show(40846); + else if (_action.isAction(VERB_LOOK, NOUN_LOADING_RAMP)) + _vm->_dialogs->show(40848); + else if (_action.isAction(VERB_OPEN, NOUN_CHEST)) + _vm->_dialogs->show(40849); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene409::setup() { + _game._player._spritesPrefix = ""; + + // The original is calling Scene4xx::setAAName() + _game._aaName = Resources::formatAAName(4); +} + +void Scene409::enter() { + _handSpriteId = _scene->_sprites.addSprites("*ROXHAND"); + teleporterEnter(); + + // The original is calling Scene4xx::sceneEntrySound() + if (!_vm->_musicFlag) + _vm->_sound->command(2); + else + _vm->_sound->command(10); +} + +void Scene409::step() { + teleporterStep(); +} + +void Scene409::actions() { + if (teleporterActions()) { + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_VIEWPORT)) + _vm->_dialogs->show(40910); + else if (_action.isAction(VERB_PEER_THROUGH, NOUN_VIEWPORT)) + _vm->_dialogs->show(40910); + else if (_action.isAction(VERB_LOOK, NOUN_KEYPAD)) + _vm->_dialogs->show(40911); + else if (_action.isAction(VERB_INSPECT, NOUN_KEYPAD)) + _vm->_dialogs->show(40911); + else if (_action.isAction(VERB_LOOK, NOUN_DISPLAY)) + _vm->_dialogs->show(40912); + else if (_action.isAction(VERB_LOOK, NOUN_1_KEY) || _action.isAction(VERB_LOOK, NOUN_2_KEY) + || _action.isAction(VERB_LOOK, NOUN_3_KEY) || _action.isAction(VERB_LOOK, NOUN_4_KEY) + || _action.isAction(VERB_LOOK, NOUN_5_KEY) || _action.isAction(VERB_LOOK, NOUN_6_KEY) + || _action.isAction(VERB_LOOK, NOUN_7_KEY) || _action.isAction(VERB_LOOK, NOUN_8_KEY) + || _action.isAction(VERB_LOOK, NOUN_9_KEY) || _action.isAction(VERB_LOOK, NOUN_0_KEY) + || _action.isAction(VERB_LOOK, NOUN_SMILE_KEY) || _action.isAction(VERB_LOOK, NOUN_FROWN_KEY)) + _vm->_dialogs->show(40913); + else if (_action.isAction(VERB_LOOK, NOUN_DEVICE)) + _vm->_dialogs->show(40914); + else if (_action._lookFlag) + _vm->_dialogs->show(40914); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene410::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene410::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('y', -1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*ROXRC_7"); + + if (_game._objects.isInRoom(OBJ_CHARGE_CASES)) + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + else + _scene->_hotspots.activate(NOUN_CHARGE_CASES, false); + + if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(155, 150); + _game._player._facing = FACING_NORTH; + } + + sceneEntrySound(); + + _scene->loadAnimation(Resources::formatName(410, 'r', -1, EXT_AA, "")); + _scene->_activeAnimation->_resetFlag = true; +} + +void Scene410::step() { + if (_scene->_activeAnimation->getCurrentFrame() == 1) { + if (_vm->getRandomNumber(1, 30) == 1) + _scene->_activeAnimation->setCurrentFrame(2); + else + _scene->_activeAnimation->setCurrentFrame(0); + } + + if (_scene->_activeAnimation->getCurrentFrame() == 9) { + if (_vm->getRandomNumber(1, 30) == 1) + _scene->_activeAnimation->setCurrentFrame(10); + else + _scene->_activeAnimation->setCurrentFrame(8); + } + + if (_scene->_activeAnimation->getCurrentFrame() == 5) { + if (_vm->getRandomNumber(1, 30) == 1) + _scene->_activeAnimation->setCurrentFrame(6); + else + _scene->_activeAnimation->setCurrentFrame(4); + } + + if (_scene->_activeAnimation->getCurrentFrame() == 3) { + if (_vm->getRandomNumber(1, 2) == 1) + _scene->_activeAnimation->setCurrentFrame(4); + else // == 2 + _scene->_activeAnimation->setCurrentFrame(8); + } +} + +void Scene410::preActions() { + if (_action.isAction(VERB_TAKE) && !_action.isAction(0x48)) + _game._player._needToWalk = false; + + if (_action.isAction(VERB_LOOK, NOUN_CHARGE_CASES) && _game._objects.isInRoom(OBJ_CHARGE_CASES)) + _game._player._needToWalk = true; + + if (_action.isAction(VERB_OPEN, NOUN_SACKS) || _action.isAction(VERB_OPEN, NOUN_SACK)) + _game._player._needToWalk = false; + + if (_action.isAction(VERB_LOOK, NOUN_CAN)) + _game._player._needToWalk = true; +} + +void Scene410::actions() { + if (_action.isAction(VERB_WALK_INTO, NOUN_CORRIDOR_TO_SOUTH)) + _scene->_nextSceneId = 406; + else if (_action.isAction(VERB_TAKE, NOUN_CHARGE_CASES) && (_game._objects.isInRoom(OBJ_CHARGE_CASES) || _game._trigger)) { + switch (_game._trigger) { + case (0): + _vm->_sound->command(57); + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 3, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->_hotspots.activate(NOUN_CHARGE_CASES, false); + _game._objects.addToInventory(OBJ_CHARGE_CASES); + _vm->_dialogs->showItem(OBJ_CHARGE_CASES, 41032); + break; + + case 2: + _game._player._priorTimer = _game._player._ticksAmount + _scene->_frameStartTime; + _game._player._visible = true; + _scene->_sequences.addTimer(20, 3); + break; + + case 3: + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_LOOK, NOUN_BARREL)) + _vm->_dialogs->show(41010); + else if (_action.isAction(VERB_TAKE, NOUN_BARREL)) + _vm->_dialogs->show(41011); + else if (_action.isAction(VERB_OPEN, NOUN_BARREL)) + _vm->_dialogs->show(41012); + else if (_action.isAction(VERB_LOOK, NOUN_RUG)) + _vm->_dialogs->show(41013); + else if (_action.isAction(VERB_TAKE, NOUN_RUG)) + _vm->_dialogs->show(41014); + else if (_action.isAction(VERB_LOOK, NOUN_CARTON) || _action.isAction(VERB_OPEN, NOUN_CARTON)) { + if (_game._objects.isInRoom(OBJ_CHARGE_CASES)) + _vm->_dialogs->show(41015); + else + _vm->_dialogs->show(41016); + } else if (_action.isAction(VERB_LOOK, NOUN_FLOUR)) + _vm->_dialogs->show(41017); + else if (_action.isAction(VERB_TAKE, NOUN_FLOUR)) + _vm->_dialogs->show(41018); + else if (_action.isAction(VERB_LOOK, NOUN_SACKS)) + _vm->_dialogs->show(41019); + else if (_action.isAction(VERB_LOOK, NOUN_SACK)) + _vm->_dialogs->show(41019); + else if (_action.isAction(VERB_OPEN, NOUN_SACKS)) + _vm->_dialogs->show(41020); + else if (_action.isAction(VERB_OPEN, NOUN_SACK)) + _vm->_dialogs->show(41020); + else if (_action.isAction(VERB_LOOK, NOUN_BUCKET_OF_TAR)) + _vm->_dialogs->show(41021); + else if (_action.isAction(VERB_TAKE, NOUN_BUCKET_OF_TAR)) + _vm->_dialogs->show(41022); + else if (_action.isAction(VERB_LOOK, NOUN_CAN)) + _vm->_dialogs->show(41023); + else if (_action.isAction(VERB_TAKE, NOUN_CAN)) + _vm->_dialogs->show(41024); + else if (_action.isAction(VERB_LOOK, NOUN_CHARGE_CASES) && _game._objects.isInRoom(OBJ_CHARGE_CASES)) + _vm->_dialogs->show(41025); + else if (_action.isAction(VERB_LOOK, NOUN_FENCE)) + _vm->_dialogs->show(41027); + else if (_action.isAction(VERB_LOOK, NOUN_SHELVES)) + _vm->_dialogs->show(41028); + else if (_action.isAction(VERB_LOOK, NOUN_RAT)) + _vm->_dialogs->show(41029); + else if (_action.isAction(VERB_TAKE, NOUN_RAT)) + _vm->_dialogs->show(41030); + else if (_action.isAction(VERB_THROW, NOUN_RAT)) + _vm->_dialogs->show(41031); + else if (_action._lookFlag) + _vm->_dialogs->show(41033); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene411::Scene411(MADSEngine *vm) : Scene4xx(vm) { + _curAnimationFrame = -1; + _newIngredient = -1; + _newQuantity = -1; + _resetFrame = -1; + _badThreshold = -1; + + _killRox = false; + _makeMushroomCloud = false; +} + +void Scene411::synchronize(Common::Serializer &s) { + Scene4xx::synchronize(s); + + s.syncAsSint32LE(_curAnimationFrame); + s.syncAsSint32LE(_newIngredient); + s.syncAsSint32LE(_newQuantity); + s.syncAsSint32LE(_resetFrame); + s.syncAsSint32LE(_badThreshold); + + s.syncAsByte(_killRox); + s.syncAsByte(_makeMushroomCloud); +} + +bool Scene411::addIngredient() { + bool retVal = false; + + switch (_newIngredient) { + case OBJ_LECITHIN: + if (_globals[kIngredientList + _globals[kNextIngredient]] == 1) + retVal = true; + + _badThreshold = 1; + break; + + case OBJ_ALIEN_LIQUOR: + if (_globals[kIngredientList + _globals[kNextIngredient]] == 0) + retVal = true; + + _badThreshold = 0; + break; + + case OBJ_FORMALDEHYDE: + if (_globals[kIngredientList + _globals[kNextIngredient]] == 3) + retVal = true; + + _badThreshold = 3; + break; + + case OBJ_PETROX: + if (_globals[kIngredientList + _globals[kNextIngredient]] == 2) + retVal = true; + + _badThreshold = 2; + break; + + default: + break; + } + + if (!retVal && (_globals[kNextIngredient] == 0)) + _globals[kBadFirstIngredient] = _badThreshold; + + if (_globals[kNextIngredient] == 0) + retVal = true; + + return(retVal); +} + +bool Scene411::addQuantity() { + bool retVal = false; + + if (_globals[kIngredientQuantity + _globals[kNextIngredient]] == _newQuantity) + retVal = true; + + if (!retVal && (_globals[kNextIngredient] == 0)) + _globals[kBadFirstIngredient] = _badThreshold; + + if (_globals[kNextIngredient] == 0) + retVal = true; + + return(retVal); +} + +int Scene411::computeQuoteAndQuantity() { + int quoteId; + int quantity; + + switch (_action._activeAction._verbId) { + case 0x252: + quoteId = 0x26F; + quantity = 0; + break; + + case 0x253: + quoteId = 0x271; + quantity = 0; + break; + + case 0x254: + quoteId = 0x270; + quantity = 0; + break; + + case 0x255: + quoteId = 0x272; + quantity = 0; + break; + + case 0x256: + quoteId = 0x267; + quantity = 2; + break; + + case 0x257: + quoteId = 0x269; + quantity = 2; + break; + + case 0x258: + quoteId = 0x268; + quantity = 2; + break; + + case 0x259: + quoteId = 0x26A; + quantity = 2; + break; + + case 0x25A: + quoteId = 0x26B; + quantity = 3; + break; + + case 0x25B: + quoteId = 0x26D; + quantity = 3; + break; + + case 0x25C: + quoteId = 0x26C; + quantity = 3; + break; + + case 0x25D: + quoteId = 0x26E; + quantity = 3; + break; + + case 0x25E: + quoteId = 0x263; + quantity = 1; + break; + + case 0x25F: + quoteId = 0x265; + quantity = 1; + break; + + case 0x260: + quoteId = 0x264; + quantity = 1; + break; + + case 0x261: + quoteId = 0x266; + quantity = 1; + break; + + default: + quoteId = 0; + quantity = 0; + break; + } + + _scene->_kernelMessages.add(Common::Point(202, 82), 0x1110, 32, 0, 120, _game.getQuote(quoteId)); + return quantity; +} + +void Scene411::handleKettleAction() { + switch (_globals[kNextIngredient]) { + case (1): + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], + false, 15, 0, 0, 0); + break; + + case (2): + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], + false, 6, 0, 0, 0); + break; + + case (3): + _makeMushroomCloud = true; + break; + + default: + break; + } +} + +void Scene411::handleDialog() { + if ((_action._activeAction._verbId != 0x262) && (_game._trigger == 0)) { + if (_game._objects.isInInventory(_newIngredient)) { + switch (_newIngredient) { + case OBJ_FORMALDEHYDE: + _resetFrame = 17; + break; + + case OBJ_PETROX: + _resetFrame = 55; + break; + + case OBJ_LECITHIN: + _resetFrame = 36; + break; + + default: + _resetFrame = 112; + break; + } + + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->_activeAnimation->setCurrentFrame(_resetFrame); + } + _scene->_kernelMessages.reset(); + _newQuantity = computeQuoteAndQuantity (); + + if ((_globals[kNextIngredient] == 1) && (_globals[kBadFirstIngredient] > -1)) + _killRox = true; + else if (addIngredient() && addQuantity()) { + handleKettleAction(); + _globals[kNextIngredient]++; + } else + _killRox = true; + + _scene->_userInterface.setup(kInputBuildingSentences); + } else if (_action._activeAction._verbId == 0x262) + _scene->_userInterface.setup(kInputBuildingSentences); +} + +void Scene411::giveToRex(int object) { + switch (object) { + case (0): + _game._objects.addToInventory(OBJ_ALIEN_LIQUOR); + break; + + case (1): + _game._objects.addToInventory(OBJ_LECITHIN); + break; + + case (2): + _game._objects.addToInventory(OBJ_PETROX); + break; + + case (3): + _game._objects.addToInventory(OBJ_FORMALDEHYDE); + break; + + default: + break; + } +} + +void Scene411::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(NOUN_ALIEN_LIQUOR); + _scene->addActiveVocab(NOUN_FORMALDEHYDE); + _scene->addActiveVocab(NOUN_PETROX); + _scene->addActiveVocab(NOUN_LECITHIN); +} + +void Scene411::enter() { + if (_scene->_priorSceneId == 411) { + if ((_globals[kNextIngredient] == 1) && (_globals[kBadFirstIngredient] > -1)) + giveToRex(_globals[kBadFirstIngredient]); + else if (_globals[kNextIngredient] > 0) { + for (int i = 0; i < _globals[kNextIngredient]; i ++) + giveToRex(_globals[kIngredientList + i]); + } + _globals[kNextIngredient] = 0; + _globals[kBadFirstIngredient] = -1; + } + + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('c', 0)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('f', 0)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('f', 1)); + _globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('f', 2)); + _globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('c', 1)); + _globals._spriteIndexes[10] = _scene->_sprites.addSprites(formAnimName('a', 6)); + _globals._spriteIndexes[11] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _globals._spriteIndexes[8] = _scene->_sprites.addSprites("*ROXRC_9"); + + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 5, 0, 0, 0); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 50, 0, 0, 0); + + _game.loadQuoteSet(0x252, 0x25E, 0x25A, 0x256, 0x253, 0x25F, 0x25B, 0x257, 0x254, 0x260, 0x25C, 0x258, 0x255, + 0x261, 0x25D, 0x259, 0x262, 0x267, 0x263, 0x26B, 0x26F, 0x268, 0x264, 0x26C, 0x270, 0x26A, 0x266, 0x26E, + 0x272, 0x269, 0x265, 0x26D, 0x271, 0); + + _dialog1.setup(0x5B, 0x252, 0x25E, 0x25A, 0x256, 0x262, -1); + _dialog2.setup(0x5C, 0x253, 0x25F, 0x25B, 0x257, 0x262, -1); + _dialog3.setup(0x5D, 0x254, 0x260, 0x25C, 0x258, 0x262, -1); + _dialog4.setup(0x5E, 0x255, 0x261, 0x25D, 0x259, 0x262, -1); + + if (_globals[kNextIngredient] >= 4 && _game._objects[OBJ_CHARGE_CASES].getQuality(3)) { + _scene->_hotspots.activate(NOUN_EXPLOSIVES, false); + _scene->_hotspots.activate(NOUN_KETTLE, true); + } else { + _scene->_hotspots.activate(NOUN_KETTLE, false); + _scene->_hotspots.activate(NOUN_EXPLOSIVES, true); + } + + if (_globals[kNextIngredient] >= 4 && _game._objects[OBJ_CHARGE_CASES].getQuality(3)) { + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], true, 6); + } else if (!_game._objects[OBJ_CHARGE_CASES].getQuality(3)) { + switch (_globals[kNextIngredient]) { + case 1: + _vm->_sound->command(53); + break; + + case 2: + _vm->_sound->command(53); + _vm->_sound->command(54); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 15, 0, 0, 0); + break; + + case 3: + _vm->_sound->command(53); + _vm->_sound->command(54); + _vm->_sound->command(55); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 6, 0, 0, 0); + break; + + case (4): + _vm->_sound->command(53); + _vm->_sound->command(54); + _vm->_sound->command(55); + _vm->_sound->command(56); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 6, 0, 0, 0); + break; + + default: + _vm->_sound->command(10); + break; + } + } + + if (_globals[kNextIngredient] >= 4 && _game._objects[OBJ_CHARGE_CASES].getQuality(3)) { + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], true, 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 1); + } + + if (_game._objects.isInRoom(OBJ_FORMALDEHYDE)) { + _globals._sequenceIndexes[7] = _scene->_sequences.startCycle(_globals._spriteIndexes[7], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 1); + int idx = _scene->_dynamicHotspots.add(NOUN_FORMALDEHYDE, VERB_WALKTO, _globals._sequenceIndexes[7], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(206, 145), FACING_SOUTHEAST); + } + + if (_game._objects.isInRoom(OBJ_PETROX)) { + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 8); + int idx = _scene->_dynamicHotspots.add(NOUN_PETROX, VERB_WALKTO, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(186, 112), FACING_NORTHEAST); + } + + if (_game._objects.isInRoom(OBJ_LECITHIN)) { + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 8); + int idx = _scene->_dynamicHotspots.add(NOUN_LECITHIN, VERB_WALKTO, _globals._sequenceIndexes[6], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(220, 121), FACING_NORTHEAST); + } + + if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(60, 146); + _game._player._facing = FACING_NORTHEAST; + } + + sceneEntrySound(); + + if (_scene->_roomChanged) { + _game._objects.addToInventory(OBJ_ALIEN_LIQUOR); + _game._objects.addToInventory(OBJ_CHARGE_CASES); + _game._objects.addToInventory(OBJ_TAPE_PLAYER); + _game._objects.addToInventory(OBJ_AUDIO_TAPE); + } + + _scene->loadAnimation(formAnimName('a', -1)); + _scene->_activeAnimation->setCurrentFrame(128); + + _makeMushroomCloud = false; + _killRox = false; +} + +void Scene411::step() { + if (_scene->_activeAnimation != nullptr) { + if (_curAnimationFrame != _scene->_activeAnimation->getCurrentFrame()) { + _curAnimationFrame = _scene->_activeAnimation->getCurrentFrame(); + _resetFrame = -1; + + switch (_curAnimationFrame) { + case 16: + _game._player._stepEnabled = true; + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._visible = true; + _resetFrame = 128; + break; + + case 35: + case 54: + case 71: + case 127: + if (_killRox) { + _resetFrame = 72; + } else { + _resetFrame = 0; + _game._objects.removeFromInventory(_newIngredient, NOWHERE); + switch (_globals[kNextIngredient]) { + case 1: + _vm->_sound->command(53); + break; + + case 2: + _vm->_sound->command(54); + break; + + case 3: + _vm->_sound->command(55); + break; + + case 4: + _vm->_sound->command(56); + break; + + default: + break; + } + } + break; + + case (22): + case (41): + case (59): + case (115): + if (_makeMushroomCloud) { + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], false, 5, 1, 0, 0); + _makeMushroomCloud = false; + _scene->_hotspots.activate(NOUN_EXPLOSIVES, false); + _scene->_hotspots.activate(NOUN_KETTLE, true); + } + break; + + case 111: + _resetFrame = 111; + _scene->_reloadSceneFlag = true; + break; + + case 129: + _resetFrame = 128; + break; + + default: + break; + } + + if ((_resetFrame >= 0) && (_resetFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(_resetFrame); + _curAnimationFrame = _resetFrame; + } + } + } + + if (_scene->_activeAnimation->getCurrentFrame() == 86) + _vm->_sound->command(59); +} + +void Scene411::preActions() { + if (_action.isAction(VERB_LOOK, NOUN_PETROX) && (_game._objects.isInRoom(OBJ_PETROX))) + _game._player._needToWalk = true; + + if (_action.isAction(VERB_LOOK, NOUN_LECITHIN) && (_game._objects.isInRoom(OBJ_LECITHIN))) + _game._player._needToWalk = true; + + if (_action.isAction(VERB_LOOK, NOUN_FORMALDEHYDE) && (_game._objects.isInRoom(OBJ_FORMALDEHYDE))) + _game._player._needToWalk = true; + + if (_action.isAction(VERB_LOOK, NOUN_EXPLOSIVES) || _action.isAction(VERB_LOOK, NOUN_KETTLE) || _action.isAction(VERB_LOOK, NOUN_MISHAP) || + _action.isAction(VERB_LOOK, NOUN_ALCOVE) || _action.isAction(VERB_LOOK, NOUN_SINK) || _action.isAction(VERB_PUT, NOUN_SINK) || + _action.isAction(VERB_LOOK, NOUN_EXPERIMENT) || _action.isAction(VERB_LOOK, NOUN_DRAWING_BOARD)) + _game._player._needToWalk = true; + + if (_action.isAction(VERB_PULL, NOUN_KNIFE_SWITCH) || _action.isAction(VERB_PUSH, NOUN_KNIFE_SWITCH)) + _game._player._needToWalk = false; +} + +void Scene411::actions() { + if (_game._screenObjects._inputMode != 1) { + handleDialog(); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_WALK_INTO, NOUN_CORRIDOR_TO_SOUTH)) { + _scene->_nextSceneId = 406; + _vm->_sound->command(10); + _action._inProgress = false; + return; + } + + if ((_globals[kNextIngredient] >= 4) && (_action.isAction(VERB_TAKE, NOUN_EXPLOSIVES) || _action.isAction(VERB_PUT, NOUN_CHARGE_CASES, 0x3AB)) + && !_game._objects[OBJ_CHARGE_CASES].getQuality(3) + && _game._objects.isInInventory(OBJ_CHARGE_CASES)) { + switch (_game._trigger) { + case 0: + _vm->_sound->command(10); + _vm->_sound->command(57); + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[10] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[10], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[10], 1, 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[10], SEQUENCE_TRIGGER_EXPIRE, 0, 110); + break; + + case 110: { + int idx = _globals._sequenceIndexes[10]; + _globals._sequenceIndexes[10] = _scene->_sequences.startCycle(_globals._spriteIndexes[10], false, 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 3); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[10], idx); + _scene->_sequences.addTimer(180, 111); + } + break; + + case 111: + _scene->_hotspots.activate(NOUN_KETTLE, true); + _scene->_hotspots.activate(NOUN_EXPLOSIVES, false); + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], true, 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 1); + + _globals._sequenceIndexes[10] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[10], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[10], 1, 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[10], SEQUENCE_TRIGGER_EXPIRE, 0, 112); + // No break on purpose + case 112: + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _game._player._visible = true; + _game._player._stepEnabled = true; + _game._objects[OBJ_CHARGE_CASES].setQuality(3, 1); + _vm->_dialogs->showItem(OBJ_CHARGE_CASES, 41142); + break; + } + _action._inProgress = false; + return; + } else if (!_game._objects.isInInventory(OBJ_CHARGE_CASES) && _action.isAction(VERB_TAKE, NOUN_EXPLOSIVES)) { + _vm->_dialogs->show(41143); + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_PETROX) && (_game._objects.isInRoom(OBJ_PETROX) || _game._trigger)) { + switch (_game._trigger) { + case (0): + _vm->_sound->command(57); + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[8] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[8], false, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[8]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_SPRITE, 2, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _game._objects.addToInventory(OBJ_PETROX); + _vm->_dialogs->showItem(OBJ_PETROX, 41120); + break; + + case 2: + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._visible = true; + _scene->_sequences.addTimer(20, 3); + break; + + case 3: + _game._player._stepEnabled = true; + break; + + default: + break; + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_LECITHIN) && (_game._objects.isInRoom(OBJ_LECITHIN) || _game._trigger)) { + switch (_game._trigger) { + case (0): + _vm->_sound->command(57); + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[8] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[8], false, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[8]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_SPRITE, 2, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[6]); + _game._objects.addToInventory(OBJ_LECITHIN); + _vm->_dialogs->showItem(OBJ_LECITHIN, 41124); + break; + + case 2: + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._visible = true; + _scene->_sequences.addTimer(20, 3); + break; + + case 3: + _game._player._stepEnabled = true; + break; + + default: + break; + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_FORMALDEHYDE) && _game._objects.isInRoom(OBJ_FORMALDEHYDE) && (_game._trigger == 0)) { + _vm->_sound->command(57); + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[11] = _scene->_sequences.startCycle(_globals._spriteIndexes[11], false, 2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[11], 1); + _scene->_sequences.addTimer(20, 100); + _scene->_sequences.remove(_globals._sequenceIndexes[7]); + _game._objects.addToInventory(OBJ_FORMALDEHYDE); + _action._inProgress = false; + return; + } + + if (_game._trigger == 100) { + _scene->_sequences.remove(_globals._sequenceIndexes[11]); + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _game._player._visible = true; + _game._player._stepEnabled = true; + _scene->_sequences.addTimer(20, 10); + } + + if (_game._trigger == 10) + _vm->_dialogs->showItem(OBJ_FORMALDEHYDE, 41124); + + if (_action.isAction(VERB_PUT, NOUN_KETTLE)) { + if (_action.isAction(0x2D7) || _action.isAction(0x2D6) || _action.isAction(0x3A9) || _action.isAction(0x306)) { + _newIngredient = _game._objects.getIdFromDesc(_action._activeAction._objectNameId); + switch (_newIngredient) { + case (OBJ_ALIEN_LIQUOR): + _dialog1.start(); + break; + + case (OBJ_FORMALDEHYDE): + _dialog3.start(); + break; + + case (OBJ_PETROX): + _dialog4.start(); + break; + + case (OBJ_LECITHIN): + _dialog2.start(); + break; + + default: + break; + } + } + } + + + if (_action.isAction(VERB_LOOK, NOUN_MONITOR)) + _vm->_dialogs->show(41110); + else if (_action.isAction(VERB_LOOK, NOUN_AIR_PURIFIER)) + _vm->_dialogs->show(41111); + else if (_action.isAction(VERB_LOOK, NOUN_LAB_EQUIPMENT)) + _vm->_dialogs->show(41112); + else if (_action.isAction(VERB_LOOK, NOUN_KNIFE_SWITCH)) + _vm->_dialogs->show(41113); + else if (_action.isAction(VERB_PUSH, NOUN_KNIFE_SWITCH) || _action.isAction(VERB_PULL, NOUN_KNIFE_SWITCH)) + _vm->_dialogs->show(41114); + else if (_action.isAction(VERB_LOOK, NOUN_TOXIC_WASTE)) + _vm->_dialogs->show(41115); + else if (_action.isAction(VERB_TAKE, NOUN_TOXIC_WASTE)) + _vm->_dialogs->show(41116); + else if (_action.isAction(VERB_LOOK, NOUN_DRAWING_BOARD)) + _vm->_dialogs->show(41117); + else if (_action.isAction(VERB_LOOK, NOUN_EXPERIMENT)) + _vm->_dialogs->show(41118); + else if (_action.isAction(VERB_LOOK, NOUN_PETROX) && _game._objects.isInRoom(OBJ_PETROX)) + _vm->_dialogs->show(41119); + else if (_action.isAction(VERB_LOOK, NOUN_ALCOVE)) + _vm->_dialogs->show(41121); + else if ((_action.isAction(VERB_LOOK, NOUN_FORMALDEHYDE)) && (_game._objects.isInRoom(OBJ_FORMALDEHYDE))) + _vm->_dialogs->show(41122); + else if ((_action.isAction(VERB_LOOK, NOUN_LECITHIN)) && (_game._objects.isInRoom(OBJ_LECITHIN))) + _vm->_dialogs->show(41123); + else if (_action.isAction(VERB_LOOK, NOUN_KETTLE)) { + if (_globals[kNextIngredient] > 0 && !_game._objects[OBJ_CHARGE_CASES].getQuality(3)) { + _vm->_dialogs->show(41126); + } else if (_globals[kNextIngredient] == 0 || _game._objects[OBJ_CHARGE_CASES].getQuality(3)) { + _vm->_dialogs->show(41125); + } + } else if (_action.isAction(VERB_LOOK, NOUN_EXPLOSIVES) && _game._objects[OBJ_CHARGE_CASES].getQuality(3) == 0) { + _vm->_dialogs->show(41127); + } else if (_action.isAction(VERB_TAKE, NOUN_KETTLE)) + _vm->_dialogs->show(41128); + else if (_action.isAction(VERB_LOOK, NOUN_CONTROL_PANEL)) + _vm->_dialogs->show(41129); + else if (_action.isAction(VERB_LOOK, NOUN_MISHAP)) + _vm->_dialogs->show(41130); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_SOUTH)) + _vm->_dialogs->show(41131); + else if (_action._lookFlag) + _vm->_dialogs->show(41132); + else if (_action.isAction(VERB_LOOK, NOUN_AIR_HORN)) + _vm->_dialogs->show(41133); + else if (_action.isAction(VERB_LOOK, NOUN_DEBRIS)) + _vm->_dialogs->show(41134); + else if (_action.isAction(VERB_LOOK, NOUN_HEATER)) + _vm->_dialogs->show(41135); + else if (_action.isAction(VERB_LOOK, NOUN_PIPE)) + _vm->_dialogs->show(41136); + else if (_action.isAction(VERB_LOOK, NOUN_SINK)) + _vm->_dialogs->show(41137); + else if (_action.isAction(VERB_PUT, NOUN_SINK)) + _vm->_dialogs->show(41138); + else if (_action.isAction(VERB_TAKE, NOUN_EXPERIMENT)) + _vm->_dialogs->show(41139); + else if (_action.isAction(VERB_LOOK, NOUN_ELECTRODES)) + _vm->_dialogs->show(41140); + else if (_action.isAction(VERB_TAKE, NOUN_ELECTRODES)) + _vm->_dialogs->show(41141); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene413::Scene413(MADSEngine *vm) : Scene4xx(vm) { + _rexDeath = -1; + _canMove = -1; +} + +void Scene413::synchronize(Common::Serializer &s) { + Scene4xx::synchronize(s); + + s.syncAsSint32LE(_rexDeath); + s.syncAsSint32LE(_canMove); +} + +void Scene413::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene413::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('a', 2)); + _rexDeath = false; + + if (_scene->_priorSceneId == 405) { + _game._player._playerPos = Common::Point(142, 146); + _game._player._facing = FACING_NORTH; + _game._player._visible = true; + } else if (_scene->_priorSceneId != -2) { + if (_globals[kSexOfRex] == REX_MALE) { + _scene->loadAnimation(Resources::formatName(413, 'd', 1, EXT_AA, ""), 78); + _vm->_sound->command(30); + _game._player._visible = false; + _game._player._stepEnabled = false; + _rexDeath = true; + } else if (!_globals[kTeleporterCommand]) { + _game._player._playerPos = Common::Point(136, 117); + _game._player.walk(Common::Point(141, 130), FACING_SOUTH); + _game._player._facing = FACING_SOUTH; + _game._player._visible = true; + } + } + + if ((_globals[kTeleporterCommand]) && (!_rexDeath)) { + switch (_globals[kTeleporterCommand]) { + case 1: + _vm->_sound->command(30); + _game._player._visible = false; + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 1, 19); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 76); + break; + + case 2: + _game._player._visible = false; + _vm->_sound->command(30); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 1, 20); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 77); + break; + + case 3: + case 4: + _game._player._playerPos = Common::Point(136, 117); + _game._player._facing = FACING_SOUTH; + _game._player.walk(Common::Point(141, 130), FACING_SOUTH); + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + _globals[kTeleporterCommand] = 0; + } + + _canMove = true; + sceneEntrySound(); +} + +void Scene413::step() { + if (_scene->_activeAnimation && _scene->_activeAnimation->getCurrentFrame() == 38) + _scene->_activeAnimation->setCurrentFrame(37); + + if (_scene->_activeAnimation && _scene->_activeAnimation->getCurrentFrame() == 21 && _canMove) { + _vm->_sound->command(27); + _canMove = false; + } + + if (_game._trigger == 76) { + _game._player._playerPos = Common::Point(136, 117); + _game._player.walk(Common::Point(141, 130), FACING_SOUTH); + _game._player._facing = FACING_SOUTH; + _game._player.selectSeries(); + _game._player._visible = true; + _game._player._stepEnabled = true; + } + + if (_game._trigger == 77) { + _globals[kTeleporterCommand] = TELEPORTER_BEAM_IN; + _scene->_nextSceneId = _globals[kTeleporterDestination]; + _scene->_reloadSceneFlag = true; + } + + if (_game._trigger == 78) { + _scene->_reloadSceneFlag = true; + _scene->_nextSceneId = _scene->_priorSceneId; + _globals[kTeleporterCommand] = TELEPORTER_NONE; + } +} + +void Scene413::preActions() { + if (_action.isAction(VERB_TAKE) || _action.isAction(VERB_PUT, NOUN_CONVEYOR_BELT)) + _game._player._needToWalk = false; + + if (_action.isAction(VERB_LOOK, NOUN_WOODEN_STATUE) || _action.isAction(VERB_LOOK, NOUN_DISPLAY) + || _action.isAction(VERB_LOOK, NOUN_PICTURE) || _action.isAction(VERB_LOOK, NOUN_PLANT)) { + _game._player._needToWalk = true; + } +} + +void Scene413::actions() { + if (_action.isAction(VERB_WALK_INSIDE, NOUN_TELEPORTER)) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->_nextSceneId = 409; + } else if (_action.isAction(VERB_WALK_INSIDE, NOUN_CORRIDOR_TO_SOUTH)) + _scene->_nextSceneId = 405; + else if (_action.isAction(VERB_LOOK, NOUN_WOODEN_STATUE)) + _vm->_dialogs->show(41310); + else if (_action.isAction(VERB_TAKE, NOUN_WOODEN_STATUE)) + _vm->_dialogs->show(41311); + else if (_action.isAction(VERB_LOOK, NOUN_CONVEYOR_BELT)) + _vm->_dialogs->show(41312); + else if (_action.isAction(VERB_PUT, NOUN_CONVEYOR_BELT)) + _vm->_dialogs->show(41313); + else if (_action.isAction(VERB_LOOK, NOUN_TELEPORTER)) + _vm->_dialogs->show(41314); + else if (_action.isAction(VERB_LOOK, NOUN_DISPLAY)) + _vm->_dialogs->show(41315); + else if (_action.isAction(VERB_LOOK, NOUN_CORRIDOR_TO_SOUTH)) + _vm->_dialogs->show(41316); + else if (_action.isAction(VERB_LOOK, NOUN_PICTURE)) + _vm->_dialogs->show(41317); + else if (_action.isAction(VERB_LOOK, NOUN_PLANT)) + _vm->_dialogs->show(41318); + else if (_action.isAction(VERB_TAKE, NOUN_PLANT)) + _vm->_dialogs->show(41319); + else if (_action._lookFlag) + _vm->_dialogs->show(41320); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +} // End of namespace Nebular +} // End of namespace MADS diff --git a/engines/mads/nebular/nebular_scenes4.h b/engines/mads/nebular/nebular_scenes4.h new file mode 100644 index 0000000000..4544e0887f --- /dev/null +++ b/engines/mads/nebular/nebular_scenes4.h @@ -0,0 +1,258 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_NEBULAR_SCENES4_H +#define MADS_NEBULAR_SCENES4_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" + +namespace MADS { + +namespace Nebular { + +class Scene4xx : public NebularScene { +protected: + /** + * Plays an appropriate sound when entering a scene + */ + void setAAName(); + + /** + * Updates the prefix used for getting player sprites for the scene + */ + void setPlayerSpritesPrefix(); + + void sceneEntrySound(); + +public: + Scene4xx(MADSEngine *vm) : NebularScene(vm) {} +}; + +class Scene401: public Scene4xx { +private: + bool _northFl; + Common::Point _destPos; + uint32 _timer; + +public: + Scene401(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene402: public Scene4xx { +private: + bool _lightOn; + bool _blowingSmoke; + bool _leftWomanMoving; + bool _rightWomanMoving; + bool _firstTalkToGirlInChair; + bool _waitingGinnyMove; + bool _ginnyLooking; + bool _bigBeatFl; + bool _roxOnStool; + bool _bartenderSteady; + bool _bartenderHandsHips; + bool _bartenderLooksLeft; + bool _bartenderReady; + bool _bartenderTalking; + bool _bartenderCalled; + bool _conversationFl; + bool _activeTeleporter; + bool _activeArrows; + bool _activeArrow1; + bool _activeArrow2; + bool _activeArrow3; + bool _cutSceneReady; + bool _cutSceneNeeded; + bool _helgaReady; + bool _refuseAlienLiquor; + + int _drinkTimer; + int _beatCounter; + int _bartenderMode; + int _bartenderDialogNode; + int _bartenderCurrentQuestion; + int _helgaTalkMode; + int _roxMode; + int _rexMode; + int _talkTimer; + + Conversation _dialog1; + Conversation _dialog2; + Conversation _dialog3; + Conversation _dialog4; + + void setDialogNode(int node); + void handleConversation1(); + void handleConversation2(); + void handleConversation3(); + void handleConversation4(); + void handleDialogs(); + +public: + Scene402(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene405: public Scene4xx { +public: + Scene405(MADSEngine *vm) : Scene4xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene406: public Scene4xx { +private: + bool _hitStorageDoor; + +public: + Scene406(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene407: public Scene4xx { +private: + bool _fromNorth; + Common::Point _destPos; + +public: + Scene407(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene408: public Scene4xx { +public: + Scene408(MADSEngine *vm) : Scene4xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene409: public SceneTeleporter { +public: + Scene409(MADSEngine *vm) : SceneTeleporter(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene410: public Scene4xx { +public: + Scene410(MADSEngine *vm) : Scene4xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene411: public Scene4xx { +private: + int _curAnimationFrame; + int _newIngredient; + int _newQuantity; + int _resetFrame; + int _badThreshold; + + bool _killRox; + bool _makeMushroomCloud; + + Conversation _dialog1; + Conversation _dialog2; + Conversation _dialog3; + Conversation _dialog4; + + void giveToRex(int object); + void handleDialog(); + void handleKettleAction(); + + int computeQuoteAndQuantity(); + + bool addQuantity(); + bool addIngredient(); + +public: + Scene411(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene413: public Scene4xx { +private: + int _rexDeath; + int _canMove; + +public: + Scene413(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; +} // End of namespace Nebular +} // End of namespace MADS + +#endif /* MADS_NEBULAR_SCENES4_H */ diff --git a/engines/mads/nebular/nebular_scenes5.cpp b/engines/mads/nebular/nebular_scenes5.cpp new file mode 100644 index 0000000000..a8c6b22591 --- /dev/null +++ b/engines/mads/nebular/nebular_scenes5.cpp @@ -0,0 +1,2871 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" +#include "mads/nebular/nebular_scenes5.h" + +namespace MADS { + +namespace Nebular { + +void Scene5xx::setAAName() { + _game._aaName = Resources::formatAAName(5); +} + +void Scene5xx::setPlayerSpritesPrefix() { + _vm->_sound->command(5); + + Common::String oldName = _game._player._spritesPrefix; + + if ((_scene->_nextSceneId == 502) || (_scene->_nextSceneId == 504) || (_scene->_nextSceneId == 505) || (_scene->_nextSceneId == 515)) + _game._player._spritesPrefix = ""; + else if (_globals[kSexOfRex] == REX_MALE) + _game._player._spritesPrefix = "RXM"; + else if ((_scene->_nextSceneId == 501) || (_scene->_nextSceneId == 503) || (_scene->_nextSceneId == 551)) + _game._player._spritesPrefix = "ROX"; + + _game._player._scalingVelocity = true; + + if ((_scene->_nextSceneId == 512) || (_scene->_nextSceneId == 507)) + _game._player._scalingVelocity = false; + + if (oldName != _game._player._spritesPrefix) + _game._player._spritesChanged = true; + + _vm->_palette->setEntry(16, 10, 63, 63); + _vm->_palette->setEntry(17, 10, 45, 45); +} + +void Scene5xx::sceneEntrySound() { + if (!_vm->_musicFlag) { + _vm->_sound->command(2); + return; + } + + switch (_scene->_nextSceneId) { + case 501: + case 502: + case 504: + case 505: + case 506: + case 507: + case 508: + case 511: + case 512: + case 513: + case 515: + case 551: + if (_scene->_priorSceneId == 503) + _vm->_sound->command(38); + else + _vm->_sound->command(29); + break; + case 503: + _vm->_sound->command(41); + break; + default: + break; + } +} + +/*------------------------------------------------------------------------*/ + +Scene501::Scene501(MADSEngine *vm) : Scene5xx(vm) { + _mainSequenceId = -1; + _mainSpriteId = -1; + _doorHotspotid = -1; + + _rexPunched = false; +} + +void Scene501::synchronize(Common::Serializer &s) { + Scene5xx::synchronize(s); + + s.syncAsSint16LE(_mainSequenceId); + s.syncAsSint16LE(_mainSpriteId); + s.syncAsSint16LE(_doorHotspotid); + s.syncAsByte(_rexPunched); +} + +void Scene501::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_DOOR); + _scene->addActiveVocab(VERB_WALK_THROUGH); +} + +void Scene501::handleSlotActions() { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + int numTicks, frameIndex; + if (_globals[kSexOfRex] == REX_MALE) { + _mainSpriteId = _globals._spriteIndexes[4]; + numTicks = 8; + frameIndex = 3; + } else { + _mainSpriteId = _globals._spriteIndexes[5]; + numTicks = 10; + frameIndex = 2; + } + + _mainSequenceId = _scene->_sequences.startReverseCycle(_mainSpriteId, false, numTicks, 1, 0, 0); + _scene->_sequences.setAnimRange(_mainSequenceId, 1, frameIndex); + _scene->_sequences.setMsgLayout(_mainSequenceId); + _vm->_sound->command(10); + _scene->_sequences.addSubEntry(_mainSequenceId, SEQUENCE_TRIGGER_SPRITE, frameIndex, 1); + _scene->_sequences.addSubEntry(_mainSequenceId, SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 12, 6, 0, 0); + break; + + case 2: + _scene->_sequences.updateTimeout(-1, _mainSequenceId); + _game._player._visible = true; + _scene->_sequences.addTimer(15, 3); + break; + + case 3: + _game._player.walk(Common::Point(282, 110), FACING_NORTH); + _scene->_sequences.addTimer(60, 4); + break; + + default: + break; + } +} + +void Scene501::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('c', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 0)); + + if (_globals[kSexOfRex] == REX_MALE) { + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*RXMRC_9"); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites("*RXCD_7"); + } else { + _globals._spriteIndexes[5] = _scene->_sprites.addSprites("*ROXRC_9"); + _globals._spriteIndexes[7] = _scene->_sprites.addSprites("*ROXCD_7"); + } + + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + int idx = _scene->_dynamicHotspots.add(NOUN_DOOR, 0x18B, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _doorHotspotid = _scene->_dynamicHotspots.setPosition(idx,Common::Point(282, 110), FACING_NORTH); + _scene->_dynamicHotspots.setCursor(_doorHotspotid, CURSOR_GO_UP); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _rexPunched = true; + + if (_scene->_priorSceneId == 504) { + _game._player._stepEnabled = false; + _game._player._playerPos = Common::Point(74, 121); + _game._player._facing = FACING_NORTHWEST; + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + if (_globals[kSexOfRex] == REX_MALE) + _scene->loadAnimation(formAnimName('G', 2), 70); + else + _scene->loadAnimation(formAnimName('R', 2), 70); + } else if (_scene->_priorSceneId == 503) { + _game._player._playerPos = Common::Point(317, 102); + _game._player._facing = FACING_SOUTHWEST; + _scene->_sequences.addTimer(15, 80); + } else if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(299, 131); + + if (_scene->_roomChanged) { + _game._objects.addToInventory(OBJ_FAKE_ID); + _game._objects.addToInventory(OBJ_SECURITY_CARD); + _game._objects.addToInventory(OBJ_ID_CARD); + } + + sceneEntrySound(); + _game.loadQuoteSet(0x275, 0x276, 0x277, 0); + + if (!_game._visitedScenes._sceneRevisited) + _scene->_sequences.addTimer(2, 90); +} + +void Scene501::step() { + if (_game._trigger == 90) + _vm->_dialogs->show(50127); + + if (_game._trigger >= 80) { + switch (_game._trigger) { + case 80: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 12, 6, 0, 0); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7); + _vm->_sound->command(11); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 81); + break; + + case 81: + _scene->_dynamicHotspots.remove(_doorHotspotid); + _game._player.walk(Common::Point(276, 110), FACING_SOUTHWEST); + _scene->_sequences.addTimer(120, 82); + break; + + case 82: + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7); + _vm->_sound->command(12); + _doorHotspotid = _scene->_dynamicHotspots.add(NOUN_DOOR, 0x18B, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_globals._sequenceIndexes[3], Common::Point(282, 110), FACING_NORTH); + _scene->_dynamicHotspots.setCursor(_doorHotspotid, CURSOR_GO_UP); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 83); + break; + + case 83: + _game._player._stepEnabled = true; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7); + break; + + default: + break; + } + } + + if (_game._trigger >= 70 && _game._trigger <= 73) { + switch (_game._trigger) { + case 70: + _game._player._visible = true; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _scene->_sequences.addTimer(15, 71); + break; + + case 71: + _game._player.walk(Common::Point(92, 130), FACING_SOUTH); + _scene->_sequences.addTimer(30, 72); + break; + + case 72: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 73); + break; + + case 73: + _game._player._stepEnabled = true; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + break; + + default: + break; + } + } +} + +void Scene501::preActions() { + if (_action.isAction(VERB_WALK_DOWN) && (_action.isObject(NOUN_STREET_TO_EAST) || _action.isObject(NOUN_SIDEWALK_TO_EAST))) + _game._player._walkOffScreenSceneId = 551; +} + +void Scene501::actions() { + if (_action.isAction(VERB_GET_INTO, NOUN_CAR)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], syncIdx); + _scene->_sequences.addTimer(15, 2); + } + break; + + case 2: + _game._player._visible = false; + if (_globals[kSexOfRex] == REX_MALE) + _mainSpriteId = _globals._spriteIndexes[6]; + else + _mainSpriteId = _globals._spriteIndexes[7]; + + _mainSequenceId = _scene->_sequences.addSpriteCycle(_mainSpriteId, false, 8, 1, 0, 0); + _scene->_sequences.setMsgLayout(_mainSequenceId); + _scene->_sequences.addSubEntry(_mainSequenceId, SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: { + int syncIdx = _mainSequenceId; + _mainSequenceId = _scene->_sequences.startCycle(_mainSpriteId, false, -2); + _scene->_sequences.setMsgLayout(_mainSequenceId); + _scene->_sequences.updateTimeout(_mainSequenceId, syncIdx); + _scene->_sequences.addTimer(30, 4); + } + break; + + case 4: + _scene->_nextSceneId = 504; + break; + + default: + break; + } + } else if (_action.isAction(VERB_PUT, NOUN_SECURITY_CARD, 0x251)) + _vm->_dialogs->show(50113); + else if (_action.isAction(VERB_PUT, NOUN_FAKE_ID, 0x251)) { + switch (_game._trigger) { + case 0: + case 1: + case 2: + case 3: + handleSlotActions(); + break; + + case 4: + if (_globals[kSexOfRex] == REX_MALE) { + _game._player._visible = false; + _vm->_sound->command(13); + _scene->loadAnimation(formAnimName('G', 1), 5); + } else { + _rexPunched = false; + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 6, 120, _game.getQuote(0x277)); + } + break; + + case 5: + _game._player._visible = true; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _scene->_sequences.addTimer(30, 6); + break; + + case 6: + if (_globals[kSexOfRex] == REX_MALE) { + if (_rexPunched) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x275)); + _rexPunched = false; + } else { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x276)); + } + } + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_PUT, NOUN_ID_CARD, 0x251)) { + switch (_game._trigger) { + case 0: + case 1: + case 2: + case 3: + handleSlotActions(); + + case 4: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _scene->_dynamicHotspots.remove(_doorHotspotid); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7); + _vm->_sound->command(11); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 6); + break; + + case 6: + _game._player.walk(Common::Point(317, 102), FACING_NORTHEAST); + _scene->_sequences.addTimer(120, 7); + break; + + case 7: { + _vm->_sound->command(12); + int syncIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx); + _vm->_sound->command(12); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 8); + } + break; + + case 8: { + int syncIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx); + _scene->_nextSceneId = 503; + } + break; + + default: + break; + } + } else if (_action._lookFlag || _action.isAction(VERB_LOOK, NOUN_STREET)) + _vm->_dialogs->show(50121); + else if (_action.isAction(VERB_LOOK, NOUN_DOOR)) + _vm->_dialogs->show(50110); + else if (_action.isAction(VERB_LOOK, NOUN_CARD_SLOT)) + _vm->_dialogs->show(50112); + else if (_action.isAction(VERB_LOOK, NOUN_SIGN)) + _vm->_dialogs->show(50114); + else if (_action.isAction(VERB_TAKE, NOUN_SIGN)) + _vm->_dialogs->show(50115); + else if (_action.isAction(VERB_LOOK, NOUN_SIDEWALK_TO_EAST)) + _vm->_dialogs->show(50118); + else if (_action.isAction(VERB_LOOK, NOUN_SIDEWALK_TO_WEST) || _action.isAction(VERB_LOOK, NOUN_STREET_TO_WEST) + || _action.isAction(VERB_WALK_DOWN, NOUN_SIDEWALK_TO_WEST) || _action.isAction(VERB_WALK_DOWN, NOUN_STREET_TO_WEST)) + _vm->_dialogs->show(50119); + else if (_action.isAction(VERB_LOOK, NOUN_BUILDING)) + _vm->_dialogs->show(50120); + else if (_action.isAction(VERB_OPEN, NOUN_DOOR)) + _vm->_dialogs->show(50122); + else if (_action.isAction(VERB_LOOK, NOUN_FIRE_HYDRANT)) + _vm->_dialogs->show(50123); + else if (_action.isAction(VERB_OPEN, NOUN_FIRE_HYDRANT)) + _vm->_dialogs->show(50124); + else if (_action.isAction(VERB_LOOK, NOUN_EQUIPMENT_OVERHEAD)) + _vm->_dialogs->show(50125); + else if (_action.isAction(VERB_LOOK, NOUN_PIPES) || _action.isAction(VERB_LOOK, NOUN_PIPE)) + _vm->_dialogs->show(50126); + else if (_action.isAction(VERB_LOOK, NOUN_CAR)) { + if (!_game._visitedScenes.exists(504)) + _vm->_dialogs->show(50116); + else + _vm->_dialogs->show(50117); + } else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene502::setup() { + _game._player._spritesPrefix = ""; + // The original is using Scene5xx_setAAName() + _game._aaName = Resources::formatAAName(5); +} + +void Scene502::enter() { + if (_globals[kSexOfRex] == REX_MALE) + _handSpriteId = _scene->_sprites.addSprites("*REXHAND"); + else + _handSpriteId = _scene->_sprites.addSprites("*ROXHAND"); + + teleporterEnter(); + + // The original uses scene5xx_sceneEntrySound + if (!_vm->_musicFlag) + _vm->_sound->command(2); + else if (_scene->_priorSceneId == 503) + _vm->_sound->command(38); + else + _vm->_sound->command(29); +} + +void Scene502::step() { + teleporterStep(); +} + +void Scene502::actions() { + if (teleporterActions()) { + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_VIEWPORT) || _action.isAction(VERB_PEER_THROUGH, NOUN_VIEWPORT)) + _vm->_dialogs->show(50210); + else if (_action.isAction(VERB_LOOK, NOUN_KEYPAD)) + _vm->_dialogs->show(50211); + else if (_action.isAction(VERB_LOOK, NOUN_DISPLAY)) + _vm->_dialogs->show(50212); + else if (_action.isAction(VERB_LOOK, NOUN_0_KEY) || _action.isAction(VERB_LOOK, NOUN_1_KEY) + || _action.isAction(VERB_LOOK, NOUN_2_KEY) || _action.isAction(VERB_LOOK, NOUN_3_KEY) + || _action.isAction(VERB_LOOK, NOUN_4_KEY) || _action.isAction(VERB_LOOK, NOUN_5_KEY) + || _action.isAction(VERB_LOOK, NOUN_6_KEY) || _action.isAction(VERB_LOOK, NOUN_7_KEY) + || _action.isAction(VERB_LOOK, NOUN_8_KEY) || _action.isAction(VERB_LOOK, NOUN_9_KEY) + || _action.isAction(VERB_LOOK, NOUN_SMILE_KEY) || _action.isAction(VERB_LOOK, NOUN_ENTER_KEY) + || _action.isAction(VERB_LOOK, NOUN_FROWN_KEY)) + _vm->_dialogs->show(50213); + else if (_action.isAction(VERB_LOOK, NOUN_DEVICE) || _action._lookFlag) + _vm->_dialogs->show(50214); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene503::Scene503(MADSEngine *vm) : Scene5xx(vm) { + _detonatorHotspotId = -1; +} + +void Scene503::synchronize(Common::Serializer &s) { + Scene5xx::synchronize(s); + + s.syncAsSint16LE(_detonatorHotspotId); +} + +void Scene503::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_DETONATORS); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene503::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('c', -1)); + + if (_globals[kSexOfRex] == REX_MALE) + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*RXMBD_2"); + else + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*ROXBD_2"); + + if (_game._objects[OBJ_DETONATORS]._roomNumber == _scene->_currentSceneId) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 9, 0, 0, 0); + _detonatorHotspotId = _scene->_dynamicHotspots.add(NOUN_DETONATORS, 0xD, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_detonatorHotspotId, Common::Point(254, 135), FACING_SOUTH); + } + + if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(191, 152); + _game._player._facing = FACING_NORTHWEST; + } + + sceneEntrySound(); +} + +void Scene503::actions() { + if (_action.isAction(VERB_WALK, NOUN_OUTSIDE)) + _scene->_nextSceneId = 501; + else if (_action.isAction(VERB_TAKE, NOUN_DETONATORS)) { + if ( _game._trigger || !_game._objects.isInInventory(OBJ_DETONATORS)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + if (_globals[kSexOfRex] == REX_MALE) { + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 3, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } else { + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], true, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 4); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 4, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } + break; + + case 1: + _vm->_sound->command(9); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->_dynamicHotspots.remove(_detonatorHotspotId); + _game._objects.addToInventory(OBJ_DETONATORS); + _vm->_dialogs->showItem(OBJ_DETONATORS, 50326); + break; + + case 2: + if (_globals[kSexOfRex] == REX_MALE) + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[2]); + else + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[3]); + + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } + } else if (_action._lookFlag) + _vm->_dialogs->show(50328); + else if (_action.isAction(VERB_LOOK, NOUN_MONITORING_EQUIPMENT)) + _vm->_dialogs->show(50310); + else if (_action.isAction(VERB_LOOK, NOUN_PHOTON_RIFLES)) + _vm->_dialogs->show(50311); + else if (_action.isAction(VERB_TAKE, NOUN_PHOTON_RIFLES) || _action.isAction(VERB_TAKE, NOUN_NUCLEAR_SLINGSHOT)) + _vm->_dialogs->show(50312); + else if (_action.isAction(VERB_LOOK, NOUN_DISPLAY_CASE)) + _vm->_dialogs->show(50313); + else if (_action.isAction(VERB_LOOK, NOUN_NUCLEAR_SLINGSHOT)) + _vm->_dialogs->show(50314); + else if (_action.isAction(VERB_LOOK, NOUN_WATER_COOLER)) + _vm->_dialogs->show(50315); + else if (_action.isAction(VERB_LOOK, NOUN_STORAGE_BOX)) + _vm->_dialogs->show(50316); + else if (_action.isAction(VERB_OPEN, NOUN_STORAGE_BOX)) + _vm->_dialogs->show(50317); + else if (_action.isAction(VERB_LOOK, NOUN_WARNING_LABEL)) + _vm->_dialogs->show(50318); + else if (_action.isAction(VERB_LOOK, NOUN_DESK)) + _vm->_dialogs->show(50319); + else if (_action.isAction(VERB_LOOK, NOUN_MONITOR)) + _vm->_dialogs->show(50320); + else if (_action.isAction(VERB_LOOK, NOUN_FILE_CABINETS)) + _vm->_dialogs->show(50322); + else if (_action.isAction(VERB_LOOK, NOUN_BOX)) { + if (_game._objects.isInRoom(OBJ_DETONATORS)) + _vm->_dialogs->show(50323); + else + _vm->_dialogs->show(50324); + } else if (_action.isAction(VERB_LOOK, NOUN_DETONATORS) && (_action._savedFields._mainObjectSource == 4)) + _vm->_dialogs->show(50325); + else if (_action.isAction(VERB_LOOK, NOUN_WINDOWS)) + _vm->_dialogs->show(50327); + else if (_action.isAction(VERB_OPEN, NOUN_DISPLAY_CASE)) + _vm->_dialogs->show(50329); + else if (_action.isAction(VERB_THROW, NOUN_DISPLAY_CASE) && _game._objects.isInInventory(_game._objects.getIdFromDesc(_action._activeAction._objectNameId))) + _vm->_dialogs->show(50330); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene504::Scene504(MADSEngine *vm) : Scene5xx(vm) { + _carAnimationMode = -1; + _carFrame = -1; +} + +void Scene504::synchronize(Common::Serializer &s) { + Scene5xx::synchronize(s); + + s.syncAsSint16LE(_carAnimationMode); + s.syncAsSint16LE(_carFrame); +} + +void Scene504::setup() { + _game._player._spritesPrefix = ""; + setAAName(); +} + +void Scene504::enter() { + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('a', 2)); + + for (int i = 0; i < 4; i++) + _globals._spriteIndexes[5 + i] = _scene->_sprites.addSprites(formAnimName('m', i)); + + if (_globals[kSexOfRex] == REX_MALE) + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('a', 0)); + else { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _scene->changeVariant(1); + } + + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 0); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 6, 0, 0, 0); + _carFrame = -1; + + if ((_scene->_priorSceneId == 505) && (_globals[kHoverCarDestination] != _globals[kHoverCarLocation])){ + _carAnimationMode = 1; + _scene->loadAnimation(formAnimName('A', -1)); + _vm->_sound->command(14); + _scene->_sequences.addTimer(1, 70); + _game._player._stepEnabled = false; + } else { + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('a', 3)); + _carAnimationMode = 1; + _scene->loadAnimation(formAnimName('A', -1)); + if ((_scene->_priorSceneId != -2) && (_scene->_priorSceneId != 505)) + _globals[kHoverCarLocation] = _scene->_priorSceneId; + + _globals._sequenceIndexes[7] = _scene->_sequences.startCycle(_globals._spriteIndexes[7], false, 1); + } + + if (_globals[kTimebombTimer] > 10500) + _globals[kTimebombTimer] = 10500; + + sceneEntrySound(); +} + +void Scene504::step() { + if ((_carAnimationMode == 1) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() != _carFrame) { + _carFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextFrame; + + if (_carFrame == 1) + nextFrame = 0; + else + nextFrame = -1; + + if ((nextFrame >= 0) && (nextFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextFrame); + _carFrame = nextFrame; + } + } + } + + + if (_game._trigger >= 70) { + switch (_game._trigger) { + case 70: + if (_globals[kHoverCarDestination] != -1) { + _game._player._stepEnabled = false; + _scene->freeAnimation(); + _carAnimationMode = 2; + if (((_globals[kHoverCarLocation] >= 500 && _globals[kHoverCarLocation] <= 599) && + (_globals[kHoverCarDestination] >= 500 && _globals[kHoverCarDestination] <= 599)) || + ((_globals[kHoverCarLocation] >= 600 && _globals[kHoverCarLocation] <= 699) && + (_globals[kHoverCarDestination] >= 600 && _globals[kHoverCarDestination] <= 699))) { + _scene->loadAnimation(formAnimName('A', -1), 71); + } else if (_globals[kHoverCarLocation] > _globals[kHoverCarDestination]) + _scene->loadAnimation(formAnimName('C', -1), 71); + else + _scene->loadAnimation(formAnimName('B', -1), 71); + } + break; + + case 71: + _vm->_sound->command(15); + _scene->_nextSceneId = _globals[kHoverCarDestination]; + break; + + default: + break; + } + } + + if ((_globals[kTimebombTimer] >= 10800) && (_globals[kTimebombStatus] == TIMEBOMB_ACTIVATED) && (_game._difficulty != 3)) { + _globals[kTimebombStatus] = TIMEBOMB_DEAD; + _globals[kTimebombTimer] = 0; + _globals[kCheckDaemonTimebomb] = false; + _scene->_nextSceneId = 620; + } +} + +void Scene504::preActions() { + _game._player._needToWalk = false; +} + +void Scene504::actions() { + if (_action.isAction(VERB_EXIT_FROM, NOUN_CAR)) { + _vm->_sound->command(15); + _scene->_nextSceneId = _globals[kHoverCarLocation]; + } else if (_action.isAction(VERB_ACTIVATE, NOUN_CAR_CONTROLS)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _vm->_sound->command(39); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 13); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _scene->_sequences.remove(_globals._sequenceIndexes[7]); + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 18, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 14); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 13); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 6); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx); + } + break; + + case 2: + _scene->_sequences.addTimer(10, 3); + break; + + case 3: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + if (_globals[kSexOfRex] == REX_MALE) { + _vm->_sound->command(34); + _scene->_sequences.addTimer(60, 4); + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 14); + } else { + _vm->_sound->command(40); + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 18, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 14); + _scene->_sequences.addTimer(120, 5); + } + break; + + case 4: + _game._player._stepEnabled = true; + _globals[kHoverCarDestination] = _globals[kHoverCarLocation]; + _scene->_nextSceneId = 505; + break; + + case 5: + _game._player._stepEnabled = true; + _scene->_sequences.remove(_globals._sequenceIndexes[8]); + _globals._sequenceIndexes[7] = _scene->_sequences.startCycle(_globals._spriteIndexes[7], false, 1); + _vm->_dialogs->show(50421); + break; + + default: + break; + } + } else if (_action._lookFlag || _action.isAction(VERB_LOOK, NOUN_INTERIOR_OF_CAR)) + _vm->_dialogs->show(50412); + else if (_action.isAction(VERB_LOOK, NOUN_GLOVE_COMPARTMENT)) + _vm->_dialogs->show(50410); + else if (_action.isAction(VERB_LOOK, NOUN_CAR_CONTROLS) || _action.isAction(VERB_LOOK, NOUN_DASHBOARD)) + _vm->_dialogs->show(50411); + else if (_action.isAction(VERB_LOOK, NOUN_SCENT_PACKET)) + _vm->_dialogs->show(50413); + else if (_action.isAction(VERB_LOOK, NOUN_SODA_CANS)) + _vm->_dialogs->show(50414); + else if (_action.isAction(VERB_LOOK, NOUN_KITTY)) + _vm->_dialogs->show(50415); + else if (_action.isAction(VERB_LOOK, NOUN_WINDSHIELD) || _action.isAction(VERB_LOOK_THROUGH, NOUN_WINDSHIELD)) + _vm->_dialogs->show(50416); + else if (_action.isAction(VERB_LOOK, NOUN_REARVIEW_MIRROR)) + _vm->_dialogs->show(50417); + else if (_action.isAction(VERB_TAKE, NOUN_REARVIEW_MIRROR)) + _vm->_dialogs->show(50418); + else if (_action.isAction(VERB_LOOK, NOUN_MOLDY_SOCK)) + _vm->_dialogs->show(50419); + else if (_action.isAction(VERB_TAKE, NOUN_MOLDY_SOCK)) + _vm->_dialogs->show(50420); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene505::Scene505(MADSEngine *vm) : Scene5xx(vm) { + _frame = -1; + _nextButtonId = -1; + _homeSelectedId = -1; + _selectedId = -1; + _activeCars = -1; + + for (int i = 0; i < 9; i++) + _carLocations[i] = -1; +} + +void Scene505::synchronize(Common::Serializer &s) { + Scene5xx::synchronize(s); + + s.syncAsSint16LE(_frame); + s.syncAsSint16LE(_nextButtonId); + s.syncAsSint16LE(_homeSelectedId); + s.syncAsSint16LE(_selectedId); + s.syncAsSint16LE(_activeCars); + + for (int i = 0; i < 9; i++) + s.syncAsSint16LE(_carLocations[i]); +} + +void Scene505::setup() { + _game._player._spritesPrefix = ""; + setAAName(); +} + +void Scene505::enter() { + for (int i = 0; i < 9; i++) + _globals._spriteIndexes[i] = _scene->_sprites.addSprites(formAnimName('a', i + 1)); + + _globals._spriteIndexes[13] = _scene->_sprites.addSprites(formAnimName('b', 1)); + _globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('g', 1)); + _globals._spriteIndexes[10] = _scene->_sprites.addSprites(formAnimName('g', 0)); + _globals._spriteIndexes[11] = _scene->_sprites.addSprites(formAnimName('t', -1)); + _globals._spriteIndexes[12] = _scene->_sprites.addSprites(formAnimName('e', -1)); + + if (_scene->_priorSceneId != -2) + _globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 6, 1, 0, 0); + + _globals._sequenceIndexes[13] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[13], false, 6, 1, 120, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 60); + _scene->_sequences.addTimer(30, 62); + + _carLocations[0] = 501; + _carLocations[1] = 506; + _carLocations[2] = 511; + _carLocations[3] = 513; + _carLocations[4] = 601; + _carLocations[5] = 604; + _carLocations[6] = 607; + _carLocations[7] = 609; + _carLocations[8] = 612; + + _activeCars = false; + + for (int i = 0; i < 9; i++) { + if (_globals[kHoverCarLocation] == _carLocations[i]) { + _homeSelectedId = i; + if (_scene->_priorSceneId != -2) + _selectedId = i; + } + } + + _game._player._visible = false; + _game._player._stepEnabled = false; + _frame = -1; + _scene->loadAnimation(formAnimName('a', -1)); + _scene->_activeAnimation->setCurrentFrame(86); + + sceneEntrySound(); + _vm->_sound->command(16); +} + +void Scene505::step() { + if (_frame != _scene->_activeAnimation->getCurrentFrame()) { + _frame = _scene->_activeAnimation->getCurrentFrame(); + int resetFrame = -1; + + switch (_frame) { + case 4: + case 24: + case 33: + case 53: + case 62: + case 82: + if (_nextButtonId == 0x38A) + resetFrame = 4; + else if (_nextButtonId == 0x38B) + resetFrame = 33; + else if (_nextButtonId == 0x2DE) + resetFrame = 62; + + break; + + case 15: + case 44: + case 73: { + int this_button; + int old_select; + _vm->_sound->command(17); + old_select = _selectedId; + if (_frame == 15) { + this_button = 0x38A; + _selectedId = (_selectedId + 1) % 9; + } else if (_frame == 44) { + this_button = 0x38B; + _selectedId--; + if (_selectedId < 0) + _selectedId = 8; + } else { + this_button = 0x2DE; + if ((_globals[kTimebombStatus] == TIMEBOMB_ACTIVATED) && (_carLocations[_selectedId] == 501)) + _vm->_dialogs->show(431); + else if (_selectedId != _homeSelectedId) { + _nextButtonId = 0; + _activeCars = true; + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->_sequences.remove(_globals._sequenceIndexes[0]); + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _globals._sequenceIndexes[13] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[13], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[13], SEQUENCE_TRIGGER_EXPIRE, 0, 63); + _vm->_sound->command(18); + } + } + + if (_nextButtonId == this_button) + _nextButtonId = 0; + + if (old_select != _selectedId) { + _scene->_sequences.remove(_globals._sequenceIndexes[11]); + _globals._sequenceIndexes[11] = _scene->_sequences.startCycle(_globals._spriteIndexes[11], false, _selectedId + 1); + if (old_select != _homeSelectedId) + _scene->_sequences.remove(_globals._sequenceIndexes[0]); + + if (_selectedId != _homeSelectedId) { + _globals._sequenceIndexes[0] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0 + _selectedId], false, 24, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[0], 1); + } + } + break; + } + + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + if (_nextButtonId == 0x38A) + resetFrame = 29 - _frame; + + break; + + case 26: + case 55: + case 84: + if (_nextButtonId != 0) + resetFrame = 3; + + break; + + case 27: + case 56: + case 85: + if (_nextButtonId != 0) + resetFrame = 2; + + break; + + case 29: + case 58: + case 87: + if (_activeCars) + _globals[kHoverCarDestination] = _carLocations[_selectedId]; + + if (_nextButtonId == 0x38A) + resetFrame = 0; + else if (_nextButtonId == 0x38B) + resetFrame = 29; + else if (_nextButtonId == 0x2DE) + resetFrame = 58; + else + resetFrame = 86; + break; + + case 47: + case 48: + case 49: + case 50: + case 51: + case 52: + if (_nextButtonId == 0x38B) + resetFrame = 87 - _frame; + + break; + + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + if (_nextButtonId == 0x2DE) + resetFrame = 145 - _frame; + + break; + + default: + break; + } + + if ((resetFrame >= 0) && (resetFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(resetFrame); + _frame = resetFrame; + } + } + + switch (_game._trigger) { + case 60: { + _game._player._stepEnabled = true; + int syncIdx = _globals._sequenceIndexes[13]; + _globals._sequenceIndexes[13] = _scene->_sequences.startCycle(_globals._spriteIndexes[13], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[13], syncIdx); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[_homeSelectedId], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _globals._sequenceIndexes[11] = _scene->_sequences.startCycle(_globals._spriteIndexes[11], false, _selectedId + 1); + + if (_selectedId != _homeSelectedId) { + _globals._sequenceIndexes[0] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[0 + _selectedId], false, 24, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[0], 1); + } + break; + } + + case 61: + _globals._sequenceIndexes[10] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[10], false, 8, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 8); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[10], _globals._sequenceIndexes[9]); + break; + + case 62: + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], false, 8, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 61); + break; + + case 63: + _globals[kHoverCarDestination] = _carLocations[_selectedId]; + _scene->_nextSceneId = 504; + break; + + default: + break; + } +} + +void Scene505::actions() { + if (_action.isAction(VERB_PRESS)) + _nextButtonId = _action._activeAction._objectNameId; + else if (_action.isAction(VERB_RETURN_TO, NOUN_INSIDE_OF_CAR)) + _scene->_nextSceneId = 504; + else if (_action.isAction(VERB_LOOK, NOUN_VIEW_SCREEN)) + _vm->_dialogs->show(50510); + else if (_action.isAction(VERB_LOOK, NOUN_CONTROL_PANEL)) + _vm->_dialogs->show(50511); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene506::Scene506(MADSEngine *vm) : Scene5xx(vm), _doorPos(0, 0) { + _heroFacing = FACING_DUMMY; + + _doorDepth = -1; + _doorSpriteIdx = -1; + _doorSequenceIdx = -1; + _doorWord = -1; + + _labDoorFl = false; + _firstDoorFl = false; + _actionFl = false; +} + +void Scene506::synchronize(Common::Serializer &s) { + Scene5xx::synchronize(s); + + s.syncAsSint16LE(_doorPos.x); + s.syncAsSint16LE(_doorPos.y); + + s.syncAsByte(_heroFacing); + + s.syncAsSint16LE(_doorDepth); + s.syncAsSint16LE(_doorSpriteIdx); + s.syncAsSint16LE(_doorSequenceIdx); + s.syncAsSint16LE(_doorWord); + + s.syncAsByte(_labDoorFl); + s.syncAsByte(_firstDoorFl); + s.syncAsByte(_actionFl); +} + +void Scene506::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(VERB_WALK_INTO); + _scene->addActiveVocab(NOUN_SOFTWARE_STORE); + _scene->addActiveVocab(NOUN_LABORATORY); +} + +void Scene506::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('q', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('q', 1)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('c', -1)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*RXCD_3"); + + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + int idx = _scene->_dynamicHotspots.add(NOUN_LABORATORY, 0x242, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + int hotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(65, 125), FACING_NORTHWEST); + _scene->_dynamicHotspots.setCursor(hotspotId, CURSOR_GO_LEFT); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + idx = _scene->_dynamicHotspots.add(NOUN_SOFTWARE_STORE, 0x242, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + hotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(112, 102), FACING_NORTHWEST); + _scene->_dynamicHotspots.setCursor(hotspotId, CURSOR_GO_LEFT); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 13); + + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 5); + _firstDoorFl = true; + _actionFl = false; + + if (_scene->_priorSceneId == 508) { + _game._player._playerPos = Common::Point(16, 111); + _game._player._facing = FACING_SOUTHEAST; + _scene->_sequences.addTimer(15, 80); + _game._player._stepEnabled = false; + } else if (_scene->_priorSceneId == 507) { + _game._player._playerPos = Common::Point(80, 102); + _game._player._facing = FACING_SOUTHEAST; + _scene->_sequences.addTimer(60, 80); + _game._player._stepEnabled = false; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(138, 116); + _game._player._facing = FACING_NORTHEAST; + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 5); + _scene->loadAnimation(formAnimName('R', 1), 70); + } + sceneEntrySound(); +} + +void Scene506::step() { + if (_game._trigger >= 80) { + if (_firstDoorFl) { + _heroFacing = FACING_SOUTHEAST; + if (_scene->_priorSceneId == 507) { + _doorPos = Common::Point(112, 102); + _doorWord = 0x336; + } else { + _doorPos = Common::Point(65, 125); + _doorWord = 0x37D; + } + } + handleDoorSequences(); + } + + if (_game._trigger >= 70) { + switch (_game._trigger) { + case 70: + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + _scene->_sequences.addTimer(6, 71); + break; + + case 71: + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + break; + + case 72: + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 5); + _game._player._stepEnabled = true; + break; + + default: + break; + } + } +} + +void Scene506::handleDoorSequences() { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + + if (_firstDoorFl) { + if (_action.isAction(VERB_WALK_INTO, NOUN_SOFTWARE_STORE) || ((_scene->_priorSceneId == 507) && !_actionFl)) { + _doorDepth = 13; + _doorSpriteIdx = _globals._spriteIndexes[2]; + _doorSequenceIdx = _globals._sequenceIndexes[2]; + _labDoorFl = false; + } else { + _doorDepth = 10; + _doorSpriteIdx = _globals._spriteIndexes[1]; + _doorSequenceIdx = _globals._sequenceIndexes[1]; + _labDoorFl = true; + } + _firstDoorFl = false; + } + + switch (_game._trigger) { + case 0: + case 80: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_doorSequenceIdx); + _doorSequenceIdx = _scene->_sequences.addSpriteCycle(_doorSpriteIdx, false, 7, 1, 0, 0); + _scene->_sequences.setDepth(_doorSequenceIdx, _doorDepth); + _scene->changeVariant(1); + _scene->_sequences.addSubEntry(_doorSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 81); + break; + + + case 81: + _doorSequenceIdx = _scene->_sequences.startCycle(_doorSpriteIdx, false, -2); + _scene->_sequences.setDepth(_doorSequenceIdx, _doorDepth); + _game._player._walkAnywhere = true; + _game._player.walk(_doorPos, _heroFacing); + _scene->_sequences.addTimer(120, 82); + break; + + case 82: + _scene->_sequences.remove(_doorSequenceIdx); + _doorSequenceIdx = _scene->_sequences.startReverseCycle(_doorSpriteIdx, false, 7, 1, 0, 0); + _scene->_sequences.setDepth(_doorSequenceIdx, _doorDepth); + if (_actionFl) + _scene->_sequences.addSubEntry(_doorSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 84); + else + _scene->_sequences.addSubEntry(_doorSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 83); + + break; + + case 83: { + _doorSequenceIdx = _scene->_sequences.startCycle(_doorSpriteIdx, false, 1); + int idx = _scene->_dynamicHotspots.add(_doorWord, 0x242, _doorSequenceIdx, Common::Rect(0, 0, 0, 0)); + int hotspotId = _scene->_dynamicHotspots.setPosition(idx, _doorPos, FACING_NORTHWEST); + _scene->_dynamicHotspots.setCursor(hotspotId, CURSOR_GO_LEFT); + _scene->_sequences.setDepth(_doorSequenceIdx, _doorDepth); + _firstDoorFl = true; + if (_labDoorFl) { + _globals._spriteIndexes[1] = _doorSpriteIdx; + _globals._sequenceIndexes[1] = _doorSequenceIdx; + } else { + _globals._spriteIndexes[2] = _doorSpriteIdx; + _globals._sequenceIndexes[2] = _doorSequenceIdx; + } + _game._player._stepEnabled = true; + + } + break; + + case 84: + _actionFl = false; + _game._player._stepEnabled = true; + if (_labDoorFl) + _scene->_nextSceneId = 508; + else + _scene->_nextSceneId = 507; + + break; + + default: + break; + } +} + +void Scene506::actions() { + if (_action.isAction(VERB_WALK_INTO, NOUN_LABORATORY)) { + if (_firstDoorFl) { + _heroFacing = FACING_NORTHWEST; + _doorPos = Common::Point(16, 111); + } + _actionFl = true; + handleDoorSequences(); + } else if (_action.isAction(VERB_WALK_INTO, NOUN_SOFTWARE_STORE)) { + if (_firstDoorFl) { + _heroFacing = FACING_NORTHWEST; + _doorPos = Common::Point(80, 102); + } + _actionFl = true; + handleDoorSequences(); + } else if (_action.isAction(VERB_GET_INTO, NOUN_CAR)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx); + _scene->_sequences.addTimer(6, 2); + } + break; + + case 2: + _game._player._visible = false; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 10, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: { + int syncIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, -2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], syncIdx); + _scene->_nextSceneId = 504; + } + break; + + default: + break; + } + } else if (_action._lookFlag || _action.isAction(VERB_LOOK, NOUN_STREET)) + _vm->_dialogs->show(50618); + else if (_action.isAction(VERB_LOOK, NOUN_RESTAURANT)) + _vm->_dialogs->show(50610); + else if (_action.isAction(VERB_LOOK, NOUN_MOTEL)) + _vm->_dialogs->show(50611); + else if (_action.isAction(VERB_LOOK, NOUN_CYCLE_SHOP)) + _vm->_dialogs->show(50612); + else if (_action.isAction(VERB_LOOK, NOUN_AIR_BIKE)) + _vm->_dialogs->show(50613); + else if (_action.isAction(VERB_TAKE, NOUN_AIR_BIKE)) + _vm->_dialogs->show(50614); + else if (_action.isAction(VERB_LOOK, NOUN_SOFTWARE_STORE)) + _vm->_dialogs->show(50615); + else if (_action.isAction(VERB_LOOK, NOUN_LABORATORY)) + _vm->_dialogs->show(50616); + else if (_action.isAction(VERB_LOOK, NOUN_STREET_TO_WEST) || _action.isAction(VERB_WALK_DOWN, NOUN_STREET_TO_WEST)) + _vm->_dialogs->show(50617); + else if (_action.isAction(VERB_LOOK, NOUN_SOFTWARE_STORE_SIGN)) + _vm->_dialogs->show(50619); + else if (_action.isAction(VERB_LOOK, NOUN_CAR)) + _vm->_dialogs->show(50620); + else if (_action.isAction(VERB_LOOK, NOUN_SKY)) + _vm->_dialogs->show(50621); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene507::Scene507(MADSEngine *vm) : Scene5xx(vm) { + _penlightHotspotId = -1; +} + +void Scene507::synchronize(Common::Serializer &s) { + Scene5xx::synchronize(s); + + s.syncAsSint16LE(_penlightHotspotId); +} + +void Scene507::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_PENLIGHT); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene507::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('p', -1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*RXMRD_3"); + + if ((_game._difficulty != DIFFICULTY_EASY) && (_game._objects[OBJ_PENLIGHT]._roomNumber == _scene->_currentSceneId)) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 9, 0, 0, 0); + _penlightHotspotId = _scene->_dynamicHotspots.add(NOUN_PENLIGHT, VERB_WALKTO, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_penlightHotspotId, Common::Point(233, 152), FACING_SOUTHEAST); + } + + if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(121, 147); + _game._player._facing = FACING_NORTH; + } + + sceneEntrySound(); +} +void Scene507::actions() { + if (_action.isAction(VERB_WALK_THROUGH, NOUN_ENTRANCE)) + _scene->_nextSceneId = 506; + else if (_action.isAction(VERB_TAKE, NOUN_PENLIGHT)) { + if (_game._trigger || !_game._objects.isInInventory(OBJ_PENLIGHT)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 5); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 5, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->_dynamicHotspots.remove(_penlightHotspotId); + _vm->_sound->command(27); + _game._objects.addToInventory(OBJ_PENLIGHT); + _vm->_dialogs->showItem(OBJ_PENLIGHT, 50730); + break; + + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[2]); + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } + } else if (_action._lookFlag) + _vm->_dialogs->show(50722); + else if (_action.isAction(VERB_LOOK, NOUN_SWIRLING_LIGHT)) + _vm->_dialogs->show(50710); + else if (_action.isAction(VERB_TAKE, NOUN_SWIRLING_LIGHT)) + _vm->_dialogs->show(50711); + else if (_action.isAction(VERB_LOOK, NOUN_OLD_SOFTWARE)) + _vm->_dialogs->show(50712); + else if (_action.isAction(VERB_TAKE, NOUN_OLD_SOFTWARE)) + _vm->_dialogs->show(50713); + else if (_action.isAction(VERB_LOOK, NOUN_ADVERTISEMENT)) + _vm->_dialogs->show(50714); + else if (_action.isAction(VERB_LOOK, NOUN_ADVERTISING_POSTER)) + _vm->_dialogs->show(50715); + else if (_action.isAction(VERB_LOOK, NOUN_SIGN)) { + if (_scene->_customDest.x < 100) + _vm->_dialogs->show(50726); + else + _vm->_dialogs->show(50716); + } else if (_action.isAction(VERB_LOOK, NOUN_HOTTEST_SOFTWARE)) + _vm->_dialogs->show(50717); + else if (_action.isAction(VERB_LOOK, NOUN_SOFTWARE_SHELF)) + _vm->_dialogs->show(50718); + else if (_action.isAction(VERB_LOOK, NOUN_SENSOR)) + _vm->_dialogs->show(50719); + else if (_action.isAction(VERB_LOOK, NOUN_CASH_REGISTER)) + _vm->_dialogs->show(50720); + else if (_action.isAction(VERB_LOOK, NOUN_PAD_OF_PAPER)) + _vm->_dialogs->show(50721); + else if (_action.isAction(VERB_OPEN, NOUN_CASH_REGISTER)) + _vm->_dialogs->show(50723); + else if (_action.isAction(VERB_LOOK, NOUN_BARGAIN_VAT)) + _vm->_dialogs->show(50724); + else if (_action.isAction(VERB_LOOK, NOUN_WINDOW)) + _vm->_dialogs->show(50725); + else if (_action.isAction(VERB_LOOK, NOUN_COUNTER)) { + if (_game._objects.isInRoom(OBJ_PENLIGHT)) + _vm->_dialogs->show(50728); + else + _vm->_dialogs->show(50727); + } else if (_action.isAction(VERB_LOOK, NOUN_PENLIGHT) && !_game._objects.isInInventory(OBJ_PENLIGHT)) { + if (_game._objects.isInRoom(OBJ_PENLIGHT)) + _vm->_dialogs->show(50729); + } else if (_action.isAction(VERB_LOOK, NOUN_EMERGENCY_LIGHT)) + _vm->_dialogs->show(50731); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene508::Scene508(MADSEngine *vm) : Scene5xx(vm) { + _chosenObject = -1; +} + +void Scene508::synchronize(Common::Serializer &s) { + Scene5xx::synchronize(s); + + s.syncAsSint16LE(_chosenObject); +} + +void Scene508::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_SPINACH_PATCH_DOLL); + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(NOUN_LASER_BEAM); +} + +void Scene508::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('a', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('m', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('h', 0)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('l', 2)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('t', 0)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites("*RXMRC_9"); + _globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('l', 3)); + + if (!_game._visitedScenes._sceneRevisited) { + _globals[kLaserOn] = false; + _chosenObject = 0; + } + + if (!_globals[kLaserOn]) { + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 8); + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, -2); + int idx = _scene->_dynamicHotspots.add(NOUN_LASER_BEAM, VERB_WALKTO, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(57, 116), FACING_NORTHEAST); + _scene->_hotspots.activate(NOUN_HOLE, false); + _scene->_hotspots.activate(NOUN_LASER_BEAM, false); + } else { + _scene->changeVariant(1); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 8); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 11); + int idx = _scene->_dynamicHotspots.add(NOUN_LASER_BEAM, VERB_WALKTO, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(57, 116), FACING_NORTHEAST); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 15, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 6, 8); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 6); + if (_globals[kLaserHoleIsThere]) { + _globals._sequenceIndexes[7] = _scene->_sequences.startCycle(_globals._spriteIndexes[7], false, -2); + _scene->_hotspots.activate(NOUN_HOLE, true); + _scene->_hotspots.activate(NOUN_LASER_BEAM, true); + } + _vm->_sound->command(21); + } + _vm->_sound->command(20); + + if (_scene->_priorSceneId == 515) { + _game._player._playerPos = Common::Point(57, 116); + _game._player._facing = FACING_NORTHEAST; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(289, 139); + _game._player._facing = FACING_WEST; + } + + sceneEntrySound(); + _game.loadQuoteSet(0x273, 0); + + if (_scene->_roomChanged) { + _game._objects.addToInventory(OBJ_COMPACT_CASE); + _game._objects.addToInventory(OBJ_REARVIEW_MIRROR); + } +} + +void Scene508::preActions() { + if (_action.isAction(VERB_WALK, NOUN_OUTSIDE)) + _game._player._walkOffScreenSceneId = 506; +} + +void Scene508::handlePedestral() { + if (!_globals[kLaserOn]) + _vm->_dialogs->show(50835); + + if (_globals[kLaserHoleIsThere]) + _vm->_dialogs->show(50836); + + if (_globals[kLaserOn] && !_globals[kLaserHoleIsThere]) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[6] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[6], false, 9, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 1, 4); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[6]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_SPRITE, 4, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 1: + if (_chosenObject == 2) + _game._objects.removeFromInventory(OBJ_COMPACT_CASE, 1); + else + _game._objects.removeFromInventory(OBJ_REARVIEW_MIRROR, 1); + + _globals._sequenceIndexes[7] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[7], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[7], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 2: + _globals._sequenceIndexes[7] = _scene->_sequences.startCycle(_globals._spriteIndexes[7], false, -2); + _scene->_hotspots.activate(NOUN_HOLE, true); + _scene->_hotspots.activate(NOUN_LASER_BEAM, true); + break; + + case 3: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[6]); + _game._player._visible = true; + _scene->_sequences.addTimer(120, 4); + break; + + case 4: + _vm->_dialogs->show(50834); + _globals[kLaserHoleIsThere] = true; + _scene->_nextSceneId = 515; + break; + + default: + break; + } + } +} + +void Scene508::actions() { + if (_action.isAction(VERB_PULL, NOUN_LEVER)) { + if (!_globals[kLaserOn]) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 2, 120, _game.getQuote(0x273)); + break; + + case 2: + _game._player._visible = false; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 10, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 7); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[1], -1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: + _vm->_sound->command(19); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 15, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 6); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 4); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 8); + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[1]); + _game._player._visible = true; + _scene->_sequences.addTimer(15, 5); + break; + + case 4: + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 15, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 6, 8); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 6); + break; + + case 5: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _scene->loadAnimation(formAnimName('B', 1), 6); + break; + + case 6: { + _vm->_sound->command(22); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 11); + int idx = _scene->_dynamicHotspots.add(NOUN_LASER_BEAM, VERB_WALKTO, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(57, 116), FACING_NORTHEAST); + _scene->_kernelMessages.reset(); + _scene->changeVariant(1); + _scene->_sequences.addTimer(30, 7); + } + break; + + case 7: + _globals[kLaserOn] = true; + _vm->_dialogs->show(50833); + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else { + _vm->_dialogs->show(50837); + } + } else if (_action.isAction(VERB_REFLECT, 0x120, 0x343) || _action.isAction(VERB_PUT, NOUN_REARVIEW_MIRROR, 0x344) || _action.isAction(VERB_PUT, NOUN_REARVIEW_MIRROR, 0x343)) { + _chosenObject = 1; + handlePedestral(); + } else if (_action.isAction(VERB_PUT, NOUN_COMPACT_CASE, 0x344) || _action.isAction(VERB_PUT, NOUN_COMPACT_CASE, 0x343) || _action.isAction(VERB_REFLECT, 0x57, 0x343)) { + _chosenObject = 2; + handlePedestral(); + } else if (_action._lookFlag) + _vm->_dialogs->show(50822); + else if (_action.isAction(VERB_LOOK, NOUN_TARGET_AREA)) + _vm->_dialogs->show(50810); + else if (_action.isAction(VERB_LOOK, NOUN_SPINACH_PATCH_DOLL)) + _vm->_dialogs->show(50811); + else if (_action.isAction(VERB_TAKE, NOUN_SPINACH_PATCH_DOLL)) + _vm->_dialogs->show(50812); + else if (_action.isAction(VERB_LOOK, NOUN_SAND_BAGS)) + _vm->_dialogs->show(50816); + else if (_action.isAction(VERB_TAKE, NOUN_SAND_BAGS)) + _vm->_dialogs->show(50817); + else if (_action.isAction(VERB_LOOK, NOUN_CONTROL_STATION)) + _vm->_dialogs->show(50818); + else if (_action.isAction(VERB_LOOK, NOUN_MONITOR)) { + if (_globals[kLaserOn]) + _vm->_dialogs->show(50820); + else + _vm->_dialogs->show(50819); + } else if (_action.isAction(VERB_LOOK, NOUN_LASER_CANNON)) { + if (_globals[kLaserOn]) + _vm->_dialogs->show(50822); + else + _vm->_dialogs->show(50821); + } else if (_action.isAction(VERB_TAKE, NOUN_LASER_CANNON)) + _vm->_dialogs->show(50823); + else if (_action.isAction(VERB_LOOK, NOUN_LEVER)) { + if (_globals[kLaserOn]) + _vm->_dialogs->show(50825); + else + _vm->_dialogs->show(50824); + } else if (_action.isAction(VERB_PUSH, NOUN_LEVER)) + _vm->_dialogs->show(50826); + else if (_action.isAction(VERB_LOOK, NOUN_LASER_BEAM)) { + if (_globals[kLaserHoleIsThere]) + _vm->_dialogs->show(50828); + else + _vm->_dialogs->show(50827); + } else if (_action.isAction(VERB_TAKE, NOUN_LASER_BEAM)) + _vm->_dialogs->show(50829); + else if (_action.isAction(VERB_LOOK, NOUN_CEILING)) { + if (_globals[kLaserHoleIsThere]) + _vm->_dialogs->show(50831); + else + _vm->_dialogs->show(50830); + } else if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(50832); + else if (_action.isAction(VERB_LOOK, NOUN_PEDESTAL)) { + if (!_globals[kLaserOn]) + _vm->_dialogs->show(50813); + else if (!_globals[kLaserHoleIsThere]) + _vm->_dialogs->show(50814); + else + _vm->_dialogs->show(50815); + } else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene511::Scene511(MADSEngine *vm) : Scene5xx(vm) { + _handingLine = false; + _lineMoving = false; + + _lineAnimationMode = -1; + _lineFrame = -1; + _lineAnimationPosition = -1; +} + +void Scene511::synchronize(Common::Serializer &s) { + Scene5xx::synchronize(s); + + s.syncAsByte(_handingLine); + s.syncAsByte(_lineMoving); + + s.syncAsSint16LE(_lineAnimationMode); + s.syncAsSint16LE(_lineFrame); + s.syncAsSint16LE(_lineAnimationPosition); +} + +void Scene511::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_BOAT); + _scene->addActiveVocab(NOUN_FISHING_LINE); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene511::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('c', 0)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*RXCD_6"); + + if (_scene->_priorSceneId != -2) + _handingLine = false; + + if (_globals[kBoatRaised]) { + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('b', 0)); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 3); + _scene->_hotspots.activate(NOUN_BOAT, false); + int idx = _scene->_dynamicHotspots.add(NOUN_BOAT, VERB_WALKTO, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(75, 124), FACING_NORTH); + _scene->_hotspots.activate(NOUN_ROPE, false); + } else { + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('b', 2)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('b', 3)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('b', 1)); + + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 1, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 5); + + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 4); + + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6],5); + + _scene->_hotspots.activate(NOUN_ROPE, true); + _scene->_hotspots.activate(NOUN_BOAT, true); + _scene->changeVariant(1); + } + + int frame = 0; + if (_globals[kLineStatus] == 2) + frame = -1; + else if (_globals[kLineStatus] == 3) + frame = -2; + + if (_globals[kLineStatus] == 2 || _globals[kLineStatus] == 3) { + _globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('b', 4)); + _globals._sequenceIndexes[7] = _scene->_sequences.startCycle(_globals._spriteIndexes[7], false, frame); + int idx = _scene->_dynamicHotspots.add(NOUN_FISHING_LINE, VERB_WALKTO, _globals._sequenceIndexes[7], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(26, 153), FACING_NORTHEAST); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 3); + if (_globals[kBoatRaised]) + _scene->changeVariant(2); + } + + _lineFrame = -1; + _lineMoving = false; + + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + if (_scene->_priorSceneId == 512) { + _game._player._playerPos = Common::Point(60, 112); + _game._player._facing = FACING_SOUTHEAST; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(55, 152); + _game._player._facing = FACING_NORTHWEST; + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _scene->loadAnimation(formAnimName('R', 1), 70); + } else if (_handingLine) { + _game._player._visible = false; + _lineAnimationMode = 1; + _lineAnimationPosition = 1; + _scene->loadAnimation(formAnimName('R', -1)); + _lineFrame = 2; + } + sceneEntrySound(); +} + +void Scene511::step() { + if ((_lineAnimationMode == 1) && _scene->_activeAnimation) { + if (_lineFrame != _scene->_activeAnimation->getCurrentFrame()) { + _lineFrame = _scene->_activeAnimation->getCurrentFrame(); + int resetFrame = -1; + + if ((_lineAnimationPosition == 2) && (_lineFrame == 14)) + _lineMoving = false; + + if (_lineAnimationPosition == 1) { + if (_lineFrame == 3) { + _lineMoving = false; + resetFrame = 2; + } + + if (_handingLine) + resetFrame = 2; + } + + if ((resetFrame >= 0) && (resetFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(resetFrame); + _lineFrame = resetFrame; + } + } + } + + switch (_game._trigger) { + case 70: + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + _scene->_sequences.addTimer(6, 71); + break; + + case 71: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + break; + + case 72: + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _game._player._stepEnabled = true; + break; + + default: + break; + } +} + +void Scene511::preActions() { + if (!_handingLine) + return; + + if (_action.isAction(VERB_LOOK) || _action.isAction(0x87) || _action.isAction(VERB_TALKTO)) + _game._player._needToWalk = false; + + if ((!_action.isAction(0x170, 0x87, 0x345) || !_action.isAction(0x19, 0x87, 0x345)) && _game._player._needToWalk) { + if (_game._trigger == 0) { + _game._player._readyToWalk = false; + _game._player._stepEnabled = false; + _scene->freeAnimation (); + _lineAnimationMode = 2; + _scene->loadAnimation(formAnimName('R',2), 1); + } else if (_game._trigger == 1) { + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + _game._objects.setRoom(OBJ_FISHING_LINE, 1); + _handingLine = false; + _game._player._stepEnabled = true; + _game._player._readyToWalk = true; + } + } +} + +void Scene511::actions() { + if (_action.isAction(VERB_WALK_INTO, NOUN_RESTAURANT)) + _scene->_nextSceneId = 512; + else if (_action.isAction(VERB_GET_INTO, NOUN_CAR)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[1]; + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[1], syncIdx); + _scene->_sequences.addTimer(6, 2); + } + break; + + case 2: + _game._player._visible = false; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 8, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: { + int syncIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, -2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], syncIdx); + _scene->_nextSceneId = 504; + } + break; + + default: + break; + } + } else if (_action.isAction(VERB_TAKE, NOUN_FISHING_LINE)) { + if (!_globals[kBoatRaised]) { + if (_globals[kLineStatus] == 2) { + if (_globals[kLineStatus] != 3) { + if (_game._trigger == 0) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _lineAnimationMode = 1; + _lineAnimationPosition = 1; + _lineMoving = true; + _scene->loadAnimation(formAnimName('R', -1)); + _scene->_sequences.addTimer(1, 1); + } else if (_game._trigger == 1) { + if (_lineMoving) { + _scene->_sequences.addTimer(1, 1); + } else { + _game._objects.addToInventory(OBJ_FISHING_LINE); + _lineMoving = true; + _handingLine = true; + _game._player._stepEnabled = true; + } + } + } else + _vm->_dialogs->show(51129); + } else + return; + } else { + _vm->_dialogs->show(51130); + } + } else if (_action.isAction(0x170, 0x87, 0x345) || _action.isAction(0x19, 0x87, 0x345)) { + if (_globals[kBoatRaised]) + _vm->_dialogs->show(51131); + else if (_globals[kLineStatus] == 1) + _vm->_dialogs->show(51130); + else if (!_globals[kBoatRaised] && _handingLine) { + if (_globals[kLineStatus] != 3) { + if (_game._trigger == 0) { + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[7]); + _lineMoving = true; + _lineAnimationPosition = 2; + _scene->_sequences.addTimer(1, 1); + } else if (_game._trigger == 1) { + if (_lineMoving) + _scene->_sequences.addTimer(1, 1); + else { + _game._player._visible = true; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _globals._sequenceIndexes[7] = _scene->_sequences.startCycle(_globals._spriteIndexes[7], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 4); + int idx = _scene->_dynamicHotspots.add(NOUN_FISHING_LINE, VERB_WALKTO, _globals._sequenceIndexes[7], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(26, 153), FACING_NORTHEAST); + _game._objects.removeFromInventory(OBJ_FISHING_LINE, 1); + _handingLine = false; + _lineMoving = true; + _globals[kLineStatus] = 3; + _game._player._stepEnabled = true; + } + } + } + } + } else if (_action.isAction(VERB_LOOK, NOUN_STREET) || _action._lookFlag) { + if (_globals[kLineStatus] == 2) + _vm->_dialogs->show(51110); + else { + if (_globals[kLineStatus] == 3) + _vm->_dialogs->show(51111); + else + _vm->_dialogs->show(51112); + } + } else if (_action.isAction(VERB_LOOK, NOUN_CAR)) + _vm->_dialogs->show(51113); + else if (_action.isAction(VERB_LOOK, NOUN_SIDEWALK)) + _vm->_dialogs->show(51114); + else if (_action.isAction(VERB_WALK_DOWN, NOUN_SIDEWALK_TO_EAST) || _action.isAction(VERB_WALK_DOWN, NOUN_SIDEWALK_TO_WEST) || _action.isAction(VERB_WALK_DOWN, NOUN_STREET_TO_EAST)) + _vm->_dialogs->show(51115); + else if (_action.isAction(VERB_LOOK, NOUN_PLEASURE_DOME)) + _vm->_dialogs->show(51116); + else if (_action.isAction(VERB_LOOK, NOUN_TICKET_BOOTH)) + _vm->_dialogs->show(51117); + else if (_action.isAction(VERB_LOOK, NOUN_DOME_ENTRANCE)) + _vm->_dialogs->show(51118); + else if (_action.isAction(VERB_UNLOCK, 0xFF, 0x37C) || _action.isAction(VERB_UNLOCK, 0x6F, 0x37C)) + _vm->_dialogs->show(51119); + else if ( (_action.isAction(VERB_PUT) || _action.isAction(VERB_THROW)) + && (_action.isAction(0x171) || _action.isAction(0x2A) || _action.isAction(0x2B)) + && _action.isAction(0x37C)) + _vm->_dialogs->show(51120); + else if (_action.isAction(VERB_LOOK, NOUN_RESTAURANT)) { + if (_globals[kBoatRaised]) + _vm->_dialogs->show(51121); + else + _vm->_dialogs->show(51128); + } else if (_action.isAction(VERB_LOOK, NOUN_PORTHOLE)) + _vm->_dialogs->show(51122); + else if (_action.isAction(VERB_LOOK, NOUN_FISHING_LINE) && (_action._mainObjectSource == 4) && (_globals[kLineStatus] == 2)) + _vm->_dialogs->show(51126); + else if (_action.isAction(VERB_LOOK, NOUN_FISHING_LINE) && (_action._mainObjectSource == 4) && (_globals[kLineStatus] == 3)) + _vm->_dialogs->show(51133); + else if (_action.isAction(VERB_LOOK, NOUN_STATUE)) + _vm->_dialogs->show(51127); + else if (_action.isAction(VERB_LOOK, NOUN_BOAT)) + if (_globals[kBoatRaised]) + _vm->_dialogs->show(51123); + else if (_globals[kLineStatus] != 3) + _vm->_dialogs->show(51124); + else + _vm->_dialogs->show(51125); + else if (_action.isAction(VERB_LOOK, NOUN_FISHING_LINE) && (_globals[kLineStatus] == 3)) + _vm->_dialogs->show(51125); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene512::Scene512(MADSEngine *vm) : Scene5xx(vm) { + _fishingRodHotspotId = -1; + _keyHotspotId = -1; +} + +void Scene512::synchronize(Common::Serializer &s) { + Scene5xx::synchronize(s); + + s.syncAsSint16LE(_fishingRodHotspotId); + s.syncAsSint16LE(_keyHotspotId); +} + +void Scene512::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_FISHING_ROD); + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(NOUN_PADLOCK_KEY); + _scene->addActiveVocab(NOUN_REGISTER_DRAWER); +} + +void Scene512::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('r', -1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*RXMRC_9"); + _globals._spriteIndexes[8] = _scene->_sprites.addSprites("*RXMRC_8"); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('x', 2)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('x', 3)); + + if (_game._objects[OBJ_FISHING_ROD]._roomNumber == _scene->_currentSceneId) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 9, 0, 0, 0); + _fishingRodHotspotId = _scene->_dynamicHotspots.add(NOUN_FISHING_ROD, VERB_WALKTO, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_fishingRodHotspotId, Common::Point(199, 101), FACING_NORTHEAST); + } + + if (!_game._visitedScenes._sceneRevisited) + _globals[kRegisterOpen] = false; + + _scene->_hotspots.activate(NOUN_PADLOCK_KEY, false); + if (_game._difficulty == DIFFICULTY_EASY) { + if (_game._objects[OBJ_PADLOCK_KEY]._roomNumber == _scene->_currentSceneId) { + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 10, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 3); + _keyHotspotId = _scene->_dynamicHotspots.add(NOUN_PADLOCK_KEY, VERB_WALKTO, _globals._sequenceIndexes[6], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_keyHotspotId, Common::Point(218, 152), FACING_NORTHEAST); + } + if (_globals[kRegisterOpen]) { + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_hotspots.activate(NOUN_PADLOCK_KEY, false); + } + } else if (_globals[kRegisterOpen]) { + if (_game._objects[OBJ_PADLOCK_KEY]._roomNumber == _scene->_currentSceneId) { + _scene->_hotspots.activate(NOUN_PADLOCK_KEY, true); + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 3); + } else { + _scene->_hotspots.activate(NOUN_PADLOCK_KEY, false); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + } + } else + _scene->_hotspots.activate(NOUN_PADLOCK_KEY, false); + + if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(144, 152); + _game._player._facing = FACING_NORTHEAST; + } + + sceneEntrySound(); +} + +void Scene512::actions() { + if (_action.isAction(VERB_WALK, NOUN_OUTSIDE)) + _scene->_nextSceneId = 511; + else if (_action.isAction(VERB_TAKE, NOUN_FISHING_ROD)) { + if (_game._trigger || !_game._objects.isInInventory(OBJ_FISHING_ROD)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 5, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _vm->_sound->command(9); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->_dynamicHotspots.remove(_fishingRodHotspotId); + _game._objects.addToInventory(OBJ_FISHING_ROD); + _vm->_dialogs->showItem(OBJ_FISHING_ROD, 51217); + break; + + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[2]); + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } + } else if (_action.isAction(VERB_OPEN, NOUN_CASH_REGISTER)) { + if (!_globals[kRegisterOpen]) { + switch (_game._trigger) { + case 0: + _vm->_dialogs->show(51236); + _game._player._stepEnabled = false; + _game._player._facing = FACING_NORTH; + _scene->_sequences.addTimer(15, 1); + break; + + case 1: + _game._player._visible = false; + _globals._sequenceIndexes[8] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[8], false, 9, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[8], 1, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[8]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[8]); + _game._player._visible = true; + _scene->_sequences.addTimer(30, 3); + break; + + case 3: + _game._player._facing = FACING_NORTHEAST; + if (!_game._objects.isInRoom(OBJ_PADLOCK_KEY) || (_game._difficulty == DIFFICULTY_EASY)) { + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 4); + } else { + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 12, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 5); + } + _vm->_sound->command(23); + break; + + case 4: + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.addTimer(60, 6); + break; + + case 5: + _globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 14, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 3); + _scene->_hotspots.activate(NOUN_PADLOCK_KEY, true); + _scene->_sequences.addTimer(60, 6); + break; + + case 6: + _globals[kRegisterOpen] = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else + _vm->_dialogs->show(51239); + } else if (_action.isAction(VERB_CLOSE, NOUN_CASH_REGISTER) && _globals[kRegisterOpen]) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[2]); + _game._player._visible = true; + if (!_game._objects.isInRoom(OBJ_PADLOCK_KEY) || _game._difficulty == DIFFICULTY_EASY) { + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 12, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } else { + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 12, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 3); + _scene->_hotspots.activate(NOUN_PADLOCK_KEY, false); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } + break; + + case 2: + _globals[kRegisterOpen] = false; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_TAKE, NOUN_PADLOCK_KEY)) { + if (_game._trigger || !_game._objects.isInInventory(OBJ_PADLOCK_KEY)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + + int endVal; + if (_game._player._playerPos == Common::Point(218, 152)) + endVal = 3; + else + endVal = 2; + + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, endVal); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, endVal, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + if (_game._player._playerPos == Common::Point(218, 152)) { + _scene->_sequences.remove(_globals._sequenceIndexes[6]); + _scene->_dynamicHotspots.remove(_keyHotspotId); + } else { + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 3); + _scene->_hotspots.activate(NOUN_PADLOCK_KEY, false); + } + _vm->_sound->command(9); + _game._objects.addToInventory(OBJ_PADLOCK_KEY); + _vm->_dialogs->showItem(OBJ_PADLOCK_KEY, 51226); + break; + + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[2]); + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } + } else if (_action._lookFlag) + _vm->_dialogs->show(51225); + else if (_action.isAction(VERB_LOOK, NOUN_PADLOCK_KEY) && _game._objects.isInRoom(OBJ_PADLOCK_KEY)) + _vm->_dialogs->show(51215); + else if (_action.isAction(VERB_LOOK, NOUN_FISHING_ROD) && (_scene->_activeAnimation->getCurrentFrame() == 4)) + _vm->_dialogs->show(51216); + else if (_action.isAction(VERB_LOOK, NOUN_SHIPS_WHEEL)) + _vm->_dialogs->show(51218); + else if (_action.isAction(VERB_TAKE, NOUN_SHIPS_WHEEL)) + _vm->_dialogs->show(51219); + else if (_action.isAction(VERB_LOOK, NOUN_PORTHOLE) || _action.isAction(VERB_PEER_THROUGH, NOUN_PORTHOLE)) + _vm->_dialogs->show(51220); + else if (_action.isAction(VERB_LOOK, NOUN_TABLE)) + _vm->_dialogs->show(51221); + else if (_action.isAction(VERB_LOOK, NOUN_STARFISH)) + _vm->_dialogs->show(51222); + else if (_action.isAction(VERB_TAKE, NOUN_STARFISH)) + _vm->_dialogs->show(51223); + else if (_action.isAction(VERB_LOOK, NOUN_OUTSIDE)) + _vm->_dialogs->show(51224); + else if (_action.isAction(VERB_LOOK, NOUN_POSTER)) + _vm->_dialogs->show(51227); + else if (_action.isAction(VERB_TAKE, NOUN_POSTER)) + _vm->_dialogs->show(51228); + else if (_action.isAction(VERB_LOOK, NOUN_TROPHY)) { + if (_game._visitedScenes.exists(604)) + _vm->_dialogs->show(51229); + else + _vm->_dialogs->show(51230); + } if (_action.isAction(VERB_LOOK, NOUN_CHAIR)) + _vm->_dialogs->show(51231); + else if (_action.isAction(VERB_LOOK, NOUN_ROPE)) + _vm->_dialogs->show(51232); + else if (_action.isAction(VERB_TAKE, NOUN_ROPE)) + _vm->_dialogs->show(51233); + else if (_action.isAction(VERB_LOOK, NOUN_LAMP)) + _vm->_dialogs->show(51234); + else if (_action.isAction(VERB_LOOK, NOUN_COUNTER)) + _vm->_dialogs->show(51235); + else if (_action.isAction(VERB_LOOK, NOUN_ICE_CHESTS)) + _vm->_dialogs->show(51237); + else if (_action.isAction(VERB_OPEN, NOUN_ICE_CHESTS)) + _vm->_dialogs->show(51238); + else if (_action.isAction(VERB_LOOK, NOUN_CASH_REGISTER)) { + if (!_globals[kRegisterOpen]) + _vm->_dialogs->show(51212); + else if (_game._objects.isInRoom(OBJ_PADLOCK_KEY)) + _vm->_dialogs->show(51214); + else + _vm->_dialogs->show(51213); + } else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene513::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_ELEVATOR_DOOR); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene513::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('c', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*RXCD_9"); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*RXMRC_9"); + + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 2); + + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + + if ((_scene->_priorSceneId == 751) || (_scene->_priorSceneId == 701)) { + _game._player._playerPos = Common::Point(296, 147); + _game._player._facing = FACING_WEST; + _game._player._stepEnabled = false; + _scene->_sequences.addTimer(15, 80); + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(63, 149); + _game._player._facing = FACING_NORTHEAST; + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _scene->loadAnimation(formAnimName('R', 1), 70); + } + + sceneEntrySound(); + + if (_scene->_roomChanged) + _game._objects.addToInventory(OBJ_SECURITY_CARD); + + _game.loadQuoteSet(0x278, 0); +} + +void Scene513::step() { + switch (_game._trigger) { + case 80: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 2); + _vm->_sound->command(24); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 81); + break; + + case 81: + _game._player.walk(Common::Point(265, 152), FACING_WEST); + _scene->_sequences.addTimer(120, 82); + break; + + case 82: + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 2); + _vm->_sound->command(25); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 83); + break; + + case 83: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 2); + _game._player._stepEnabled = true; + break; + + default: + break; + } + + switch (_game._trigger) { + case 70: + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + _scene->_sequences.addTimer(6, 71); + break; + + case 71: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + break; + + case 72: + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _game._player._stepEnabled = true; + break; + + default: + break; + } +} + +void Scene513::actions() { + if (_action.isAction(VERB_GET_INTO, NOUN_CAR)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[1]; + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[1], syncIdx); + _scene->_sequences.addTimer(6, 2); + } + break; + + case 2: + _game._player._visible = false; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 10, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: { + int syncIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx); + _scene->_nextSceneId = 504; + } + break; + + default: + break; + } + } else if (_action.isAction(VERB_PUT, NOUN_ID_CARD, 0x251) || _action.isAction(VERB_PUT, NOUN_FAKE_ID, 0x251)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[4]); + _game._player._visible = true; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 2); + _vm->_sound->command(24); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x278)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 2: + _game._player.walk(Common::Point(296, 147), FACING_WEST); + _scene->_sequences.addTimer(120, 3); + break; + + case 3: + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 2); + _vm->_sound->command(25); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 4); + break; + + case 4: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 2); + _game._player._stepEnabled = true; + if (_globals[kCityFlooded]) + _scene->_nextSceneId = 701; + else + _scene->_nextSceneId = 751; + + break; + + default: + break; + } + } else if ((_action._lookFlag) || _action.isAction(VERB_LOOK, NOUN_STREET)) + _vm->_dialogs->show(51318); + else if (_action.isAction(VERB_LOOK, NOUN_ELEVATOR)) + _vm->_dialogs->show(51310); + else if (_action.isAction(VERB_LOOK, NOUN_ELEVATOR_DOOR)) + _vm->_dialogs->show(51311); + else if (_action.isAction(VERB_LOOK, NOUN_CARD_SLOT)) + _vm->_dialogs->show(51312); + else if (_action.isAction(VERB_LOOK, NOUN_HANDICAP_SIGN)) + _vm->_dialogs->show(51313); + else if (_action.isAction(VERB_LOOK, NOUN_BIKE_RACK)) + _vm->_dialogs->show(51314); + else if (_action.isAction(VERB_LOOK, NOUN_BUILDING)) + _vm->_dialogs->show(51315); + else if (_action.isAction(VERB_LOOK, NOUN_SIGN)) + _vm->_dialogs->show(51316); + else if (_action.isAction(VERB_LOOK, NOUN_STREET_TO_WEST) || _action.isAction(VERB_WALK_DOWN, NOUN_STREET_TO_WEST)) + _vm->_dialogs->show(51317); + else if (_action.isAction(VERB_OPEN, NOUN_ELEVATOR_DOOR) || _action.isAction(VERB_OPEN, NOUN_ELEVATOR)) + _vm->_dialogs->show(51319); + else if (_action.isAction(VERB_LOOK, NOUN_CAR)) + _vm->_dialogs->show(51321); + else if (_action.isAction(VERB_LOOK, NOUN_BRICK_WALL)) + _vm->_dialogs->show(51322); + else if (_action.isAction(VERB_PUT, NOUN_SECURITY_CARD, 0x251)) + _vm->_dialogs->show(51320); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene515::setup() { + _game._player._spritesPrefix = ""; + setAAName(); +} + +void Scene515::enter() { + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->_sequences.addTimer(30, 70); + + sceneEntrySound(); +} + +void Scene515::step() { + if (_game._trigger == 70) + _scene->loadAnimation(formAnimName('A', -1), 71); + else if (_game._trigger == 71) + _scene->_nextSceneId = 508; +} + +/*------------------------------------------------------------------------*/ + +void Scene551::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene551::enter() { + if (_globals[kSexOfRex] == REX_MALE) + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('a', 0)); + else + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('a', 1)); + + if (_scene->_priorSceneId == 501) + _game._player._playerPos = Common::Point(18, 130); + else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(124, 119); + _game._player._facing = FACING_NORTH; + } + + if (_globals[kTeleporterCommand]) { + _game._player._visible = false; + _game._player._stepEnabled = false; + + char sepChar; + if (_globals[kSexOfRex] == REX_MALE) + sepChar = 'e'; + else + sepChar = 'u'; + + int suffixNum; + int trigger; + + switch (_globals[kTeleporterCommand]) { + case 1: + suffixNum = 3; + trigger = 75; + _globals[kTeleporterUnderstood] = true; + break; + + case 2: + suffixNum = 1; + trigger = 80; + break; + + case 4: + suffixNum = 2; + trigger = 90; + break; + + default: + trigger = 0; + suffixNum = 0; + } + + _globals[kTeleporterCommand] = 0; + + if (suffixNum > 0) + _scene->loadAnimation(formAnimName(sepChar, suffixNum), trigger); + else { + _game._player._visible = true; + _game._player._stepEnabled = true; + } + } + + sceneEntrySound(); +} + +void Scene551::step() { + switch (_game._trigger) { + case 75: + _game._player._stepEnabled = true; + _game._player._visible = true; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + break; + + case 80: + _globals[kTeleporterCommand] = 1; + _scene->_nextSceneId = _globals[kTeleporterDestination]; + _scene->_reloadSceneFlag = true; + break; + + case 90: + if (_globals[kSexOfRex] == REX_MALE) { + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 8); + } else { + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 8); + } + _vm->_sound->command(28); + _scene->_sequences.addTimer(60, 91); + break; + + case 91: + _scene->_reloadSceneFlag = true; + break; + + default: + break; + } +} + +void Scene551::preActions() { + if (_action.isAction(VERB_WALK_DOWN) && (_action.isObject(NOUN_STREET_TO_WEST) || _action.isObject(NOUN_SIDEWALK_TO_WEST))) + _game._player._walkOffScreenSceneId = 501; +} + +void Scene551::actions() { + if (_action.isAction(VERB_STEP_INTO, NOUN_TELEPORTER)) + _scene->_nextSceneId = 502; + else if ((_action._lookFlag)) + _vm->_dialogs->show(55117); + else if (_action.isAction(VERB_LOOK, NOUN_SKELETON)) + _vm->_dialogs->show(55110); + else if (_action.isAction(VERB_LOOK, NOUN_ELEVATOR_SHAFT)) + _vm->_dialogs->show(55111); + else if (_action.isAction(VERB_WALKTO, NOUN_ELEVATOR_SHAFT)) + _vm->_dialogs->show(55112); + else if (_action.isAction(VERB_LOOK, NOUN_BUILDING)) + _vm->_dialogs->show(55113); + else if (_action.isAction(VERB_LOOK, NOUN_TELEPORTER)) + _vm->_dialogs->show(55114); + else if (_action.isAction(VERB_LOOK, NOUN_BUILDING)) + _vm->_dialogs->show(55115); + else if (_action.isAction(VERB_LOOK, NOUN_SIDEWALK_TO_WEST)) { + if (_game._visitedScenes.exists(505)) + _vm->_dialogs->show(55116); + else + _vm->_dialogs->show(55115); + } else if (_action.isAction(VERB_LOOK, NOUN_SIDEWALK)) + _vm->_dialogs->show(55118); + else if (_action.isAction(VERB_LOOK, NOUN_EQUIPMENT_OVERHEAD)) + _vm->_dialogs->show(55119); + else if (_action.isAction(VERB_LOOK, NOUN_RAILING)) + _vm->_dialogs->show(55120); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +} // End of namespace Nebular +} // End of namespace MADS diff --git a/engines/mads/nebular/nebular_scenes5.h b/engines/mads/nebular/nebular_scenes5.h new file mode 100644 index 0000000000..4022f1c85b --- /dev/null +++ b/engines/mads/nebular/nebular_scenes5.h @@ -0,0 +1,254 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_NEBULAR_SCENES5_H +#define MADS_NEBULAR_SCENES5_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" + +namespace MADS { + +namespace Nebular { + +class Scene5xx : public NebularScene { +protected: + /** + * Plays an appropriate sound when entering a scene + */ + void setAAName(); + + /** + * Updates the prefix used for getting player sprites for the scene + */ + void setPlayerSpritesPrefix(); + + void sceneEntrySound(); + +public: + Scene5xx(MADSEngine *vm) : NebularScene(vm) {} +}; + +class Scene501: public Scene5xx{ +private: + int _mainSequenceId; + int _mainSpriteId; + int _doorHotspotid; + bool _rexPunched; + + void handleSlotActions(); + +public: + Scene501(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene502: public SceneTeleporter { +public: + Scene502(MADSEngine *vm) : SceneTeleporter(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene503: public Scene5xx{ +private: + int _detonatorHotspotId; + +public: + Scene503(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +class Scene504: public Scene5xx{ +private: + int _carAnimationMode; + int _carFrame; + +public: + Scene504(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene505: public Scene5xx{ +private: + int _frame; + int _nextButtonId; + int _homeSelectedId; + int _selectedId; + int _activeCars; + + int _carLocations[9]; + +public: + Scene505(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene506: public Scene5xx{ +private: + Common::Point _doorPos; + Facing _heroFacing; + + int _doorDepth; + int _doorSpriteIdx; + int _doorSequenceIdx; + int _doorWord; + + bool _labDoorFl; + bool _firstDoorFl; + bool _actionFl; + + void handleDoorSequences(); + +public: + Scene506(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene507: public Scene5xx{ +private: + int _penlightHotspotId; + +public: + Scene507(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +class Scene508: public Scene5xx{ +private: + int _chosenObject; + + void handlePedestral(); + +public: + Scene508(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene511: public Scene5xx{ +private: + bool _handingLine; + bool _lineMoving; + + int _lineAnimationMode; + int _lineFrame; + int _lineAnimationPosition; + +public: + Scene511(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene512: public Scene5xx{ +private: + int _fishingRodHotspotId; + int _keyHotspotId; + +public: + Scene512(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +class Scene513: public Scene5xx{ +public: + Scene513(MADSEngine *vm) : Scene5xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene515: public Scene5xx{ +public: + Scene515(MADSEngine *vm) : Scene5xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions() {}; +}; + +class Scene551: public Scene5xx{ +public: + Scene551(MADSEngine *vm) : Scene5xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; +} // End of namespace Nebular +} // End of namespace MADS + +#endif /* MADS_NEBULAR_SCENES5_H */ diff --git a/engines/mads/nebular/nebular_scenes6.cpp b/engines/mads/nebular/nebular_scenes6.cpp new file mode 100644 index 0000000000..1821a72c16 --- /dev/null +++ b/engines/mads/nebular/nebular_scenes6.cpp @@ -0,0 +1,4771 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" +#include "mads/nebular/nebular_scenes6.h" + +namespace MADS { + +namespace Nebular { + +void Scene6xx::setAAName() { + _game._aaName = Resources::formatAAName(5); +} + +void Scene6xx::setPlayerSpritesPrefix() { + _vm->_sound->command(5); + Common::String oldName = _game._player._spritesPrefix; + + if ((_scene->_nextSceneId == 605) || (_scene->_nextSceneId == 620)) + _game._player._spritesPrefix = ""; + else if (_globals[kSexOfRex] == REX_MALE) + _game._player._spritesPrefix = "RXM"; + else + _game._player._spritesPrefix = "ROX"; + + if (oldName != _game._player._spritesPrefix) + _game._player._spritesChanged = true; + + _game._player._scalingVelocity = true; + _vm->_palette->setEntry(16, 10, 63, 63); + _vm->_palette->setEntry(17, 10, 45, 45); +} + +void Scene6xx::sceneEntrySound() { + if (!_vm->_musicFlag) { + _vm->_sound->command(2); + return; + } + + switch (_scene->_nextSceneId) { + case 601: + case 602: + case 603: + case 604: + case 605: + case 607: + case 608: + case 609: + case 610: + case 612: + case 620: + _vm->_sound->command(29); + break; + case 611: + _vm->_sound->command(24); + break; + default: + break; + } +} + +/*------------------------------------------------------------------------*/ + +void Scene601::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_LASER_BEAM); + _scene->addActiveVocab(VERB_LOOK_AT); +} + +void Scene601::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('c', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*RXCD_4"); + + if (_globals[kLaserHoleIsThere]) { + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -2); + _scene->_dynamicHotspots.add(NOUN_LASER_BEAM, 0xD1, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + } + + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 3); + + if (_scene->_priorSceneId == 504) { + _game._player._playerPos = Common::Point(73, 148); + _game._player._facing = FACING_WEST; + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 3); + _scene->loadAnimation(formAnimName('R', 1), 70); + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(229, 129); + _game._player._facing = FACING_SOUTHWEST; + } + + sceneEntrySound(); +} + +void Scene601::step() { + switch (_game._trigger) { + case 70: + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + _scene->_sequences.addTimer(30, 71); + break; + + case 71: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + break; + + case 72: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 3); + _game._player._stepEnabled = true; + break; + + default: + break; + } +} + +void Scene601::actions() { + if (_action.isAction(VERB_WALK_THROUGH, NOUN_ENTRANCE)) + _scene->_nextSceneId = 602; + else if (_action.isAction(0x325, 0x324)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], syncIdx); + _scene->_sequences.addTimer(6, 2); + } + break; + + case 2: + _game._player._visible = false; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 10, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: { + int syncIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx); + _scene->_nextSceneId = 504; + } + break; + + default: + break; + } + } else if (_action._lookFlag || _action.isAction(VERB_LOOK, NOUN_STREET)) { + if (!_globals[kLaserHoleIsThere]) + _vm->_dialogs->show(60110); + else + _vm->_dialogs->show(60111); + } else if (_action.isAction(VERB_LOOK, NOUN_CAR)) + _vm->_dialogs->show(60112); + else if (_action.isAction(VERB_LOOK, NOUN_PAPERS)) + _vm->_dialogs->show(60113); + else if (_action.isAction(VERB_LOOK, NOUN_BUILDING)) + _vm->_dialogs->show(60114); + else if (_action.isAction(VERB_WALK_DOWN, NOUN_STREET)) + _vm->_dialogs->show(60115); + else if (_action.isAction(VERB_LOOK, NOUN_BALCONY)) + _vm->_dialogs->show(60116); + else if (_action.isAction(VERB_LOOK, NOUN_ENTRANCE)) + _vm->_dialogs->show(60117); + else if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(60118); + else if (_action.isAction(VERB_LOOK, NOUN_CITY)) + _vm->_dialogs->show(60119); + else if (_action.isAction(VERB_LOOK, NOUN_FOUNTAIN)) + _vm->_dialogs->show(60120); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene602::Scene602(MADSEngine *vm) : Scene6xx(vm) { + _lastSpriteIdx = -1; + _lastSequenceIdx = -1; + _cycleIndex = -1; + _safeMode = -1; +} + +void Scene602::synchronize(Common::Serializer &s) { + Scene6xx::synchronize(s); + + s.syncAsSint16LE(_lastSpriteIdx); + s.syncAsSint16LE(_lastSequenceIdx); + s.syncAsSint16LE(_cycleIndex); + s.syncAsSint16LE(_safeMode); +} + +void Scene602::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(NOUN_SAFE); + _scene->addActiveVocab(NOUN_LASER_BEAM); +} + +void Scene602::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('h', -1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('l', 0)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites("*RXMRC_9"); + + if (!_game._visitedScenes._sceneRevisited) + _globals[kSafeStatus] = 0; + + if (_globals[kLaserHoleIsThere]) { + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 9); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 9); + int idx = _scene->_dynamicHotspots.add(NOUN_LASER_BEAM, VERB_WALKTO, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(80, 134), FACING_NORTHEAST); + _scene->changeVariant(1); + } else + _scene->_hotspots.activate(NOUN_HOLE, false); + + if (_globals[kSafeStatus] == 0) { + _lastSpriteIdx = _globals._spriteIndexes[2]; + _cycleIndex = -1; + } else if (_globals[kSafeStatus] == 1) { + _lastSpriteIdx = _globals._spriteIndexes[2]; + _cycleIndex = -2; + } else if (_globals[kSafeStatus] == 3) { + _lastSpriteIdx = _globals._spriteIndexes[3]; + _cycleIndex = -2; + } else { + _lastSpriteIdx = _globals._spriteIndexes[3]; + _cycleIndex = -1; + } + + _lastSequenceIdx = _scene->_sequences.startCycle(_lastSpriteIdx, false, _cycleIndex); + _scene->_sequences.setDepth(_lastSequenceIdx, 14); + int idx = _scene->_dynamicHotspots.add(NOUN_SAFE, VERB_WALKTO, _lastSequenceIdx, Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(185, 113), FACING_NORTHWEST); + + if (_game._objects.isInRoom(OBJ_DOOR_KEY)) { + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('k', -1)); + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 15); + if (_globals[kSafeStatus] == 0 || _globals[kSafeStatus] == 2) + _scene->_hotspots.activate(NOUN_DOOR_KEY, false); + } else + _scene->_hotspots.activate(NOUN_DOOR_KEY, false); + + if (_scene->_priorSceneId == 603) { + _game._player._playerPos = Common::Point(228, 126); + _game._player._facing = FACING_WEST; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(50, 127); + _game._player._facing = FACING_EAST; + } + + sceneEntrySound(); + _game.loadQuoteSet(0x2F1, 0x2F2, 0x2F3, 0); + + if (_scene->_roomChanged) { + _game._objects.addToInventory(OBJ_NOTE); + _game._objects.addToInventory(OBJ_REARVIEW_MIRROR); + _game._objects.addToInventory(OBJ_COMPACT_CASE); + } +} + +void Scene602::handleSafeActions() { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], true, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_SPRITE, 3, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 1: + if (_safeMode == 1 || _safeMode == 3) { + if (_globals[kSafeStatus] == 0 && _safeMode == 1) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x2F1)); + _scene->_sequences.addTimer(120, 4); + } else { + _scene->_sequences.remove(_lastSequenceIdx); + if (_safeMode == 3) + _lastSpriteIdx = _globals._spriteIndexes[2]; + else + _lastSpriteIdx = _globals._spriteIndexes[3]; + + _lastSequenceIdx = _scene->_sequences.addSpriteCycle(_lastSpriteIdx, false, 12, 1, 0, 0); + _scene->_sequences.setDepth(_lastSequenceIdx, 14); + if (_game._objects[OBJ_DOOR_KEY]._roomNumber == _scene->_currentSceneId) + _scene->_hotspots.activate(NOUN_DOOR_KEY, true); + + _scene->_sequences.addSubEntry(_lastSequenceIdx, + SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } + } else { + _scene->_sequences.remove(_lastSequenceIdx); + if (_globals[kSafeStatus] == 1) + _lastSpriteIdx = _globals._spriteIndexes[2]; + else + _lastSpriteIdx = _globals._spriteIndexes[3]; + + _lastSequenceIdx = _scene->_sequences.startReverseCycle(_lastSpriteIdx, false, 12, 1, 0, 0); + _scene->_sequences.setDepth(_lastSequenceIdx, 14); + if (_game._objects[OBJ_DOOR_KEY]._roomNumber == _scene->_currentSceneId) + _scene->_hotspots.activate(NOUN_DOOR_KEY, false); + + _scene->_sequences.addSubEntry(_lastSequenceIdx, SEQUENCE_TRIGGER_EXPIRE, 0, 2); + } + break; + + case 2: { + int synxIdx = _lastSequenceIdx; + _lastSequenceIdx = _scene->_sequences.startCycle(_lastSpriteIdx, false, _cycleIndex); + _scene->_sequences.setDepth(_lastSequenceIdx, 14); + _scene->_sequences.updateTimeout(_lastSequenceIdx, synxIdx); + int idx = _scene->_dynamicHotspots.add(NOUN_SAFE, VERB_WALKTO, _lastSequenceIdx, Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(185, 113), FACING_NORTHWEST); + if (_safeMode == 3) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x2F3)); + _scene->_sequences.addTimer(120, 4); + } else + _scene->_sequences.addTimer(60, 4); + break; + } + + case 3: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[5]); + _game._player._visible = true; + break; + + case 4: + if (_safeMode == 1) { + if (_globals[kSafeStatus] == 2) + _globals[kSafeStatus] = 3; + } else if (_safeMode == 2) { + if (_globals[kSafeStatus] == 3) + _globals[kSafeStatus] = 2; + else + _globals[kSafeStatus] = 0; + } else + _globals[kSafeStatus] = 1; + + _game._player._stepEnabled = true; + break; + + default: + break; + } +} + +void Scene602::actions() { + if (_action.isAction(VERB_WALK_THROUGH, NOUN_HALLWAY)) + _scene->_nextSceneId = 601; + else if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOORWAY)) + _scene->_nextSceneId = 603; + else if (_action.isAction(VERB_OPEN, NOUN_SAFE) && ((_globals[kSafeStatus] == 0) || (_globals[kSafeStatus] == 2))) { + _safeMode = 1; + _cycleIndex = -2; + handleSafeActions(); + } else if (_action.isAction(VERB_CLOSE, NOUN_SAFE) && ((_globals[kSafeStatus] == 1) || (_globals[kSafeStatus] == 3))) { + _safeMode = 2; + _cycleIndex = -1; + handleSafeActions(); + } else if (_action.isAction(VERB_UNLOCK, 0x3A7, 0x3D3)) { + if ((_globals[kSafeStatus] == 0) && (_game._difficulty != DIFFICULTY_HARD)) { + _safeMode = 3; + _cycleIndex = -2; + handleSafeActions(); + } + } else if ((_action.isAction(VERB_PUT, NOUN_REARVIEW_MIRROR, 0x343) || _action.isAction(VERB_PUT, NOUN_COMPACT_CASE, 0x343) + || _action.isAction(VERB_REFLECT, 0x57, 0x343) || _action.isAction(VERB_REFLECT, 0x120, 0x343)) && (_globals[kSafeStatus] == 0)) { + switch (_game._trigger) { + case 0: + _vm->_dialogs->show(60230); + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _scene->_sequences.remove(_lastSequenceIdx); + _scene->loadAnimation(formAnimName('L', 1), 1); + break; + + case 1: { + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + _lastSpriteIdx = _globals._spriteIndexes[3]; + _lastSequenceIdx = _scene->_sequences.startCycle(_lastSpriteIdx, false, -1); + _scene->_sequences.setDepth(_lastSequenceIdx, 14); + int idx = _scene->_dynamicHotspots.add(NOUN_SAFE, VERB_WALKTO, _lastSequenceIdx, Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(185, 113), FACING_NORTHWEST); + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 9); + idx = _scene->_dynamicHotspots.add(NOUN_LASER_BEAM, VERB_WALKTO, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(80, 134), FACING_NORTHEAST); + _scene->_sequences.addTimer(60, 2); + } + break; + + case 2: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x2F2)); + _globals[kSafeStatus] = 2; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_TAKE, NOUN_DOOR_KEY) && (_game._trigger || _game._objects.isInRoom(OBJ_DOOR_KEY))) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], true, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_SPRITE, 3, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[6]); + _scene->_hotspots.activate(NOUN_DOOR_KEY, false); + _vm->_sound->command(9); + _game._objects.addToInventory(OBJ_DOOR_KEY); + break; + + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[5]); + _game._player._visible = true; + _game._player._stepEnabled = true; + _vm->_dialogs->showItem(OBJ_DOOR_KEY, 835); + break; + + default: + break; + } + } else if (_action._lookFlag) + _vm->_dialogs->show(60210); + else if (_action.isAction(VERB_LOOK, NOUN_FLOOR)) + _vm->_dialogs->show(60211); + else if (_action.isAction(VERB_LOOK, NOUN_HALLWAY)) + _vm->_dialogs->show(60212); + else if (_action.isAction(VERB_LOOK, NOUN_TABLE)) + _vm->_dialogs->show(60213); + else if (_action.isAction(VERB_LOOK, NOUN_CHAIR) || _action.isAction(VERB_LOOK, NOUN_LOUNGE_CHAIR)) + _vm->_dialogs->show(60214); + else if (_action.isAction(VERB_LOOK, NOUN_NEON_LIGHTS)) + _vm->_dialogs->show(60215); + else if (_action.isAction(VERB_LOOK, NOUN_FIREPLACE)) + _vm->_dialogs->show(60216); + else if (_action.isAction(VERB_LOOK, NOUN_PICTURE)) + _vm->_dialogs->show(60217); + else if (_action.isAction(VERB_LOOK, NOUN_LAMP)) + _vm->_dialogs->show(60218); + else if (_action.isAction(VERB_LOOK, NOUN_MASKS)) + _vm->_dialogs->show(60219); + else if (_action.isAction(VERB_LOOK, NOUN_GLASS_BLOCK_WALL)) + _vm->_dialogs->show(60220); + else if (_action.isAction(VERB_LOOK, NOUN_DOORWAY)) + _vm->_dialogs->show(60221); + else if (_action.isAction(VERB_LOOK, NOUN_SAFE)) { + if (_globals[kSafeStatus] == 0) + _vm->_dialogs->show(60222); + else if (_globals[kSafeStatus] == 1) { + if (!_game._objects.isInRoom(OBJ_DOOR_KEY)) + _vm->_dialogs->show(60223); + else + _vm->_dialogs->show(60224); + } else if (_globals[kSafeStatus] == 2) + _vm->_dialogs->show(60234); + else if (_game._objects.isInRoom(OBJ_DOOR_KEY)) + _vm->_dialogs->show(60235); + else + _vm->_dialogs->show(60236); + } else if (_action.isAction(VERB_UNLOCK, 0x6F, 0x3D3) || _action.isAction(VERB_UNLOCK, 0xFF, 0x3D3)) + _vm->_dialogs->show(60225); + else if (_action.isAction(VERB_PULL, NOUN_SAFE)) + _vm->_dialogs->show(60226); + else if (_action.isAction(VERB_PUT, NOUN_FIREPLACE) && _game._objects.isInInventory(_game._objects.getIdFromDesc(_action._activeAction._objectNameId))) + _vm->_dialogs->show(60227); + else if (_action.isAction(VERB_LOOK, NOUN_HOLE)) + _vm->_dialogs->show(60228); + else if (_action.isAction(VERB_LOOK, NOUN_LASER_BEAM)) + _vm->_dialogs->show(60229); + else if (_action.isAction(VERB_LOOK, NOUN_FLOWER_BOX)) + _vm->_dialogs->show(60231); + else if (_action.isAction(VERB_THROW, NOUN_BOMB, 0x3D3) || _action.isAction(VERB_THROW, NOUN_BOMBS, 0x3D3)) + _vm->_dialogs->show(60232); + else if (_action.isAction(VERB_PUT, NOUN_TIMEBOMB)) + _vm->_dialogs->show(60233); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene603::Scene603(MADSEngine *vm) : Scene6xx(vm) { + _compactCaseHotspotId = -1; + _noteHotspotId = -1; +} + +void Scene603::synchronize(Common::Serializer &s) { + Scene6xx::synchronize(s); + + s.syncAsSint16LE(_compactCaseHotspotId); + s.syncAsSint16LE(_noteHotspotId); +} + +void Scene603::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(NOUN_COMPACT_CASE); + _scene->addActiveVocab(NOUN_NOTE); +} + +void Scene603::enter() { + if (_game._objects[OBJ_COMPACT_CASE]._roomNumber == _scene->_currentSceneId) { + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*RXMRD_3"); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('c', -1)); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _compactCaseHotspotId = _scene->_dynamicHotspots.add(NOUN_COMPACT_CASE, VERB_WALKTO, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_compactCaseHotspotId, Common::Point(250, 152), FACING_SOUTHEAST); + } + + if ((_game._difficulty != DIFFICULTY_HARD) && (_game._objects[OBJ_NOTE]._roomNumber == _scene->_currentSceneId)) { + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*RXMRC_9"); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('p', -1)); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 14); + _noteHotspotId = _scene->_dynamicHotspots.add(NOUN_NOTE, VERB_WALKTO, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_noteHotspotId, Common::Point(242, 118), FACING_NORTHEAST); + } + + if (_scene->_priorSceneId != -2) + _game._player._playerPos = Common::Point(113, 134); + + sceneEntrySound(); +} + +void Scene603::actions() { + if (_action.isAction(VERB_WALK_TOWARDS, NOUN_LIVINGROOM)) + _scene->_nextSceneId = 602; + else if (_action.isAction(VERB_TAKE, NOUN_COMPACT_CASE)) { + if ( _game._trigger || !_game._objects.isInInventory(OBJ_COMPACT_CASE)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 1, 5); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_SPRITE, 5, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _vm->_sound->command(9); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->_dynamicHotspots.remove(_compactCaseHotspotId); + _game._objects.addToInventory(OBJ_COMPACT_CASE); + _vm->_dialogs->showItem(OBJ_COMPACT_CASE, 60330); + break; + + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[4]); + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } + } else if (_action.isAction(VERB_TAKE, NOUN_NOTE)) { + if ( _game._trigger || !_game._objects.isInInventory(OBJ_NOTE)) { + if (_game._trigger == 0) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addTimer(15, 1); + } else if (_game._trigger == 1) { + _vm->_sound->command(9); + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _scene->_dynamicHotspots.remove(_noteHotspotId); + _game._objects.addToInventory(OBJ_NOTE); + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _game._player._visible = true; + _game._player._stepEnabled = true; + } + } + } else if (_action._lookFlag) + _vm->_dialogs->show(60310); + else if (_action.isAction(VERB_LOOK, NOUN_BED)) + _vm->_dialogs->show(60311); + else if (_action.isAction(VERB_LOOK, NOUN_WIG_STAND)) + _vm->_dialogs->show(60312); + else if (_action.isAction(VERB_TAKE, NOUN_WIG_STAND)) + _vm->_dialogs->show(60313); + else if (_action.isAction(VERB_LOOK, NOUN_REVIEW)) + _vm->_dialogs->show(60314); + else if (_action.isAction(VERB_LOOK, NOUN_SOUVENIR_TICKETS)) + _vm->_dialogs->show(60315); + else if (_action.isAction(VERB_LOOK, NOUN_PHOTOGRAPH)) + _vm->_dialogs->show(60316); + else if (_action.isAction(VERB_LOOK, NOUN_LAMP)) + _vm->_dialogs->show(60317); + else if (_action.isAction(VERB_LOOK, NOUN_DIRECTORS_SLATE) || _action.isAction(VERB_LOOK, NOUN_CROP) || _action.isAction(VERB_LOOK, NOUN_MEGAPHONE)) + _vm->_dialogs->show(60318); + else if (_action.isAction(VERB_LOOK, NOUN_SNAPSHOT)) + _vm->_dialogs->show(60319); + else if (_action.isAction(VERB_TAKE, NOUN_SNAPSHOT)) + _vm->_dialogs->show(60320); + else if (_action.isAction(VERB_LOOK, NOUN_PERFUME)) + _vm->_dialogs->show(60321); + else if (_action.isAction(VERB_TAKE, NOUN_PERFUME)) + _vm->_dialogs->show(60322); + else if (_action.isAction(VERB_TAKE, NOUN_NOTE)) + _vm->_dialogs->show(60323); + else if (_action.isAction(VERB_LOOK, NOUN_NOTE)) { + if (_game._objects[OBJ_NOTE]._roomNumber == _scene->_currentSceneId) + _vm->_dialogs->show(60324); + } else if (_action.isAction(VERB_LOOK, NOUN_CORNER_TABLE)) { + if (_game._objects[OBJ_NOTE]._roomNumber == _scene->_currentSceneId) + _vm->_dialogs->show(60326); + else + _vm->_dialogs->show(60325); + } else if (_action.isAction(VERB_LOOK, NOUN_VANITY)) { + if (_game._objects[OBJ_COMPACT_CASE]._roomNumber == _scene->_currentSceneId) + _vm->_dialogs->show(60327); + else + _vm->_dialogs->show(60328); + } else if (_action.isAction(VERB_LOOK, NOUN_COMPACT_CASE) && (_action._mainObjectSource == 4)) + _vm->_dialogs->show(60329); + // For the next two checks, the second part of the check wasn't surrounded par parenthesis, which was obviously wrong + else if (_action.isAction(VERB_LOOK) && (_action.isAction(0x31) || _action.isAction(0x3EA) || _action.isAction(0x3E8))) + _vm->_dialogs->show(60331); + else if (_action.isAction(VERB_TAKE) && (_action.isAction(0x31) || _action.isAction(0x3EA) || _action.isAction(0x3E8))) + _vm->_dialogs->show(60332); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene604::Scene604(MADSEngine *vm) : Scene6xx(vm) { + _timebombHotspotId = -1; + _bombMode = -1; + _monsterFrame = -1; + + _monsterTimer = 0; + + _monsterActive = false; + _animationActiveFl = false; +} + +void Scene604::synchronize(Common::Serializer &s) { + Scene6xx::synchronize(s); + + s.syncAsSint16LE(_timebombHotspotId); + s.syncAsSint16LE(_bombMode); + s.syncAsSint16LE(_monsterFrame); + + s.syncAsUint32LE(_monsterTimer); + + s.syncAsByte(_monsterActive); + s.syncAsByte(_animationActiveFl); +} + +void Scene604::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_SEA_MONSTER); + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(NOUN_TIMEBOMB); +} + +void Scene604::enter() { + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('c', 0)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*RXCD_9"); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(Resources::formatName(620, 'b', 0, EXT_SS, "")); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites("*RXMRC_9"); + + if (_globals[kTimebombStatus] == 1) { + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, -1); + _timebombHotspotId = _scene->_dynamicHotspots.add(NOUN_TIMEBOMB, VERB_WALKTO, _globals._sequenceIndexes[6], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_timebombHotspotId, Common::Point(166, 118), FACING_NORTHEAST); + } + + if (_scene->_roomChanged) + _game._objects.addToInventory(OBJ_TIMEBOMB); + + _vm->_palette->setEntry(252, 63, 37, 26); + _vm->_palette->setEntry(253, 45, 24, 17); + _animationActiveFl = false; + + if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(72, 149); + _game._player._facing = FACING_NORTHEAST; + _game._player._visible = false; + _game._player._stepEnabled = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->loadAnimation(formAnimName('R', 1), 70); + _animationActiveFl = true; + } else { + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + } + + _monsterTimer = _scene->_frameStartTime; + _monsterActive = false; + + sceneEntrySound(); + _game.loadQuoteSet(0x2E7, 0x2E8, 0x2E9, 0x2EA, 0x2EB, 0x2EC, 0x2ED, 0x2EE, 0x2EF, 0x2F0, 0); +} + +void Scene604::step() { + switch (_game._trigger) { + case 70: + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + _scene->_sequences.addTimer(30, 71); + break; + + case 71: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + break; + + case 72: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _game._player._stepEnabled = true; + _animationActiveFl = false; + break; + + default: + break; + } + + if (_monsterActive && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() != _monsterFrame) { + _monsterFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextMonsterFrame = -1; + + switch (_monsterFrame) { + case 50: + case 137: + case 174: { + int randVal = _vm->getRandomNumber(1, 1000); + if ((randVal <= 450) && (_game._player._special)) { + if (_game._player._special == 1) + nextMonsterFrame = 50; + else if (_game._player._special == 2) + nextMonsterFrame = 84; + else + nextMonsterFrame = 137; + } else if (randVal <= 150) + nextMonsterFrame = 50; + else if (randVal <= 300) + nextMonsterFrame = 84; + else if (randVal <= 450) + nextMonsterFrame = 137; + else if (randVal < 750) + nextMonsterFrame = 13; + else + nextMonsterFrame = 114; + + } + break; + + case 84: + nextMonsterFrame = 14; + break; + + default: + break; + } + + if ((nextMonsterFrame >= 0) && (nextMonsterFrame != _monsterFrame)) { + _scene->_activeAnimation->setCurrentFrame(nextMonsterFrame); + _monsterFrame = nextMonsterFrame; + } + } + } + + if ((!_monsterActive && !_animationActiveFl) && (_scene->_frameStartTime > (_monsterTimer + 4))) { + _monsterTimer = _scene->_frameStartTime; + if ((_vm->getRandomNumber(1, 1000) < 25) || !_game._visitedScenes._sceneRevisited) { + _monsterActive = true; + _scene->freeAnimation(); + _scene->loadAnimation(formAnimName('m', -1)); + } + } +} + +void Scene604::handleBombActions() { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 9, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + if (_bombMode == 1) + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_SPRITE, 3, 1); + else + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_SPRITE, 3, 2); + + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 1: + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, -1); + _timebombHotspotId = _scene->_dynamicHotspots.add(NOUN_TIMEBOMB, VERB_WALKTO, _globals._sequenceIndexes[6], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_timebombHotspotId, Common::Point(166, 118), FACING_NORTHEAST); + _game._objects.setRoom(OBJ_TIMEBOMB, _scene->_currentSceneId); + break; + + case 2: + _scene->_sequences.remove(_globals._sequenceIndexes[6]); + _scene->_dynamicHotspots.remove(_timebombHotspotId); + _game._objects.addToInventory(OBJ_TIMEBOMB); + break; + + case 3: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[5]); + _game._player._visible = true; + _game._player._stepEnabled = true; + if (_bombMode == 1) { + _vm->_dialogs->show(60421); + _globals[kTimebombStatus] = TIMEBOMB_ACTIVATED; + _globals[kTimebombTimer] = 0; + } else { + _vm->_dialogs->show(60423); + _globals[kTimebombStatus] = TIMEBOMB_DEACTIVATED; + _globals[kTimebombTimer] = 0; + } + break; + + default: + break; + } +} + +void Scene604::actions() { + if (_action.isAction(0x325, 0x324)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], syncIdx); + _scene->_sequences.addTimer(6, 2); + } + break; + + case 2: + _game._player._visible = false; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 10, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: { + int syncIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, -2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], syncIdx); + _scene->_nextSceneId = 504; + } + break; + + default: + break; + } + } else if ((_action.isAction(VERB_PUT, NOUN_LEDGE) || _action.isAction(VERB_PUT, NOUN_VIEWPORT) || _action.isAction(VERB_THROW, NOUN_VIEWPORT)) + && (_action.isAction(0x2A) || _action.isAction(0x2B))) + _vm->_dialogs->show(60420); + else if (_action.isAction(VERB_PUT, NOUN_TIMEBOMB, 0x3F6) || _action.isAction(VERB_PUT, NOUN_TIMEBOMB, 0x181)) { + _bombMode = 1; + if ((_game._difficulty == DIFFICULTY_HARD) || _globals[kWarnedFloodCity]) + handleBombActions(); + else if ((_game._objects.isInInventory(OBJ_POLYCEMENT) && _game._objects.isInInventory(OBJ_CHICKEN)) + && ((_globals[kLineStatus] == LINE_TIED) || ((_game._difficulty == DIFFICULTY_EASY) && (!_globals[kBoatRaised])))) + handleBombActions(); + else if (_game._difficulty == DIFFICULTY_EASY) + _vm->_dialogs->show(60424); + else { + _vm->_dialogs->show(60425); + _globals[kWarnedFloodCity] = true; + } + } else if (_action.isAction(VERB_TAKE, NOUN_TIMEBOMB)) { + if (_game._trigger || !_game._objects.isInInventory(OBJ_TIMEBOMB)) { + _bombMode = 2; + handleBombActions(); + } + } else if (_action._lookFlag) + _vm->_dialogs->show(60411); + else if (_action.isAction(VERB_LOOK, NOUN_VIEWPORT)) { + if (_monsterActive) { + _vm->_dialogs->show(60413); + } else { + _vm->_dialogs->show(60412); + } + } else if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(60414); + else if (_action.isAction(VERB_LOOK, NOUN_VENT)) + _vm->_dialogs->show(60415); + else if (_action.isAction(VERB_LOOK, NOUN_INDICATOR)) + _vm->_dialogs->show(60416); + else if (_action.isAction(VERB_LOOK, NOUN_SCULPTURE)) + _vm->_dialogs->show(60417); + else if (_action.isAction(VERB_LOOK, NOUN_CAR)) + _vm->_dialogs->show(60418); + else if (_action.isAction(VERB_LOOK, NOUN_FOUNTAIN)) + _vm->_dialogs->show(60419); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene605::setup() { + _game._player._spritesPrefix = ""; + setAAName(); +} + +void Scene605::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('r', -1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('b', -1)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('l', -1)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('p', -1)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('n', -1)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('f', -1)); + + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 15, 0, 0, 0); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 17, 0, 0, 0); + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 14, 0, 0, 0); + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 13, 0, 0, 0); + _globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 17, 0, 0, 0); + _globals._sequenceIndexes[6] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[6], false, 18, 0, 0, 0); + + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->_sequences.addTimer(600, 70); + _scene->_userInterface.setup(kInputLimitedSentences); + sceneEntrySound(); + _vm->_sound->command(22); +} + +void Scene605::step() { + if (_game._trigger == 70) { + _vm->_sound->command(23); + if (_globals[kResurrectRoom] >= 700) + _vm->_dialogs->show(60598); + else + _vm->_dialogs->show(60599); + + _scene->_nextSceneId = _globals[kResurrectRoom]; + } +} + +void Scene605::actions() { + return; +} + +/*------------------------------------------------------------------------*/ + +Scene607::Scene607(MADSEngine *vm) : Scene6xx(vm) { + _dogTimer = 0; + _lastFrameTime = 0; + + _dogLoop = false; + _dogEatsRex = false; + _dogBarking = false; + _shopAvailable = false; + + _animationMode = -1; + _animationActive = -1; + _counter = -1; +} + +void Scene607::synchronize(Common::Serializer &s) { + Scene6xx::synchronize(s); + + s.syncAsUint32LE(_dogTimer); + s.syncAsUint32LE(_lastFrameTime); + + s.syncAsByte(_dogLoop); + s.syncAsByte(_dogEatsRex); + s.syncAsByte(_dogBarking); + s.syncAsByte(_shopAvailable); + + s.syncAsSint16LE(_animationMode); + s.syncAsSint16LE(_animationActive); + s.syncAsSint16LE(_counter); +} + +void Scene607::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_OBNOXIOUS_DOG); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene607::enter() { + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('c', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*RXCD_3"); + + if (!_game._visitedScenes._sceneRevisited && (_scene->_priorSceneId != 608)) + _globals[kDogStatus] = 1; + + if ((_scene->_priorSceneId == 608) && (_globals[kDogStatus] < 3)) + _globals[kDogStatus] = 3; + + _animationActive = 0; + + if ((_globals[kDogStatus] == 1) && (_game._difficulty != DIFFICULTY_EASY)) { + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('g', 3)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('g', 7)); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('g', 0)); + + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 6); + _dogBarking = false; + _dogLoop = false; + _shopAvailable = false; + _dogEatsRex = false; + _dogTimer = 0; + } else + _scene->_hotspots.activate(NOUN_OBNOXIOUS_DOG, false); + + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + + if (_scene->_priorSceneId == 608) { + _game._player._playerPos = Common::Point(297, 50); + _game._player._facing = FACING_SOUTHEAST; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(40, 104); + _game._player._facing = FACING_SOUTHEAST; + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->loadAnimation(formAnimName('R', 1), 80); + } else if (_globals[kDogStatus] == 2) { + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('g', 3)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('g', 7)); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('g', 0)); + } + + sceneEntrySound(); + + if (_scene->_roomChanged) + _game._objects.addToInventory(OBJ_BONES); + + _vm->_palette->setEntry(252, 63, 44, 30); + _vm->_palette->setEntry(253, 63, 20, 22); + _game.loadQuoteSet(0x2F8, 0x2F7, 0x2F6, 0x2F9, 0x2FA, 0); +} + +void Scene607::step() { + if (_globals[kDogStatus] == 2) { + int32 diff = _scene->_frameStartTime - _lastFrameTime; + if ((diff >= 0) && (diff <= 4)) + _dogTimer += diff; + else + _dogTimer++; + + _lastFrameTime = _scene->_frameStartTime; + } + + if ((_dogTimer >= 480) && !_dogLoop && !_shopAvailable && (_globals[kDogStatus] == 2) && !_game._player._special) { + _vm->_sound->command(14); + _dogLoop = true; + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 10, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 91); + _dogLoop = false; + _dogTimer = 0; + } + + if (_game._trigger == 91) { + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 6); + _dogBarking = false; + _globals[kDogStatus] = 1; + _scene->_hotspots.activate(NOUN_OBNOXIOUS_DOG, true); + } + + if (!_dogEatsRex && (_game._difficulty != DIFFICULTY_EASY) && !_animationActive && (_globals[kDogStatus] == 1) + && !_dogBarking && (_vm->getRandomNumber(1, 50) == 10)) { + _dogBarking = true; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 5, 8, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 6); + _scene->_kernelMessages.reset(); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_SPRITE, 2, 100); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 70); + _counter = 0; + } + + if ((_game._trigger == 70) && !_dogEatsRex && (_globals[kDogStatus] == 1) && !_animationActive) { + int syncIdx = _globals._sequenceIndexes[1]; + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 6); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[1], syncIdx); + _scene->_kernelMessages.reset(); + _dogBarking = false; + } + + if (_game._trigger == 100) { + _counter++; + _vm->_sound->command(12); + + if ((_counter >= 1) && (_counter <= 4)) { + Common::Point pos(0, 0); + switch (_counter) { + case 1: + pos = Common::Point(237, 5); + break; + + case 2: + pos = Common::Point(270, 15); + break; + + case 3: + pos = Common::Point(237, 25); + break; + + case 4: + pos = Common::Point(270, 36); + break; + + default: + break; + } + _scene->_kernelMessages.add(pos, 0xFDFC, 0, 0, 120, _game.getQuote(0x2F9)); + } + } + + if (_game._player._moving && (_game._difficulty != DIFFICULTY_EASY) && !_shopAvailable && (_globals[kDogStatus] == 1) && (_scene->_rails.getNext() > 0)) { + _game._player.cancelCommand(); + _game._player.startWalking(Common::Point(268, 72), FACING_NORTHEAST); + _scene->_rails.resetNext(); + } + + if ((_game._player._special > 0) && (_game._difficulty != DIFFICULTY_EASY) && (_globals[kDogStatus] == 1) && _game._player._stepEnabled) + _game._player._stepEnabled = false; + + if ((_game._difficulty != DIFFICULTY_EASY) && (_globals[kDogStatus] == 1) && (_game._player._playerPos == Common::Point(268, 72)) + && (_game._trigger || !_dogEatsRex)) { + _dogEatsRex = true; + switch (_game._trigger) { + case 91: + case 0: + _animationActive = 1; + _game._player._visible = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], -1, 7); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 1); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x2FA)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 60); + _scene->_sequences.addTimer(10, 64); + break; + + case 60: { + int syncIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 5, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 8, 45); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], syncIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 61); + } + break; + + case 61: { + int syncIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 15, 3, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 46, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], syncIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 62); + } + break; + + case 62: { + int syncIdx = _globals._sequenceIndexes[4]; + _animationActive = 2; + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], syncIdx); + _scene->_sequences.addTimer(60, 63); + } + break; + + case 63: + _vm->_dialogs->show(60729); + _animationActive = 0; + _dogEatsRex = false; + _scene->_reloadSceneFlag = true; + _game._player._stepEnabled = true; + break; + + case 64: + if (_dogEatsRex && (_animationActive == 1)) { + _vm->_sound->command(12); + _scene->_sequences.addTimer(10, 64); + } + break; + + default: + break; + } + } + + switch (_game._trigger) { + case 80: + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + _scene->_sequences.addTimer(6, 81); + break; + + case 81: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 82); + break; + + case 82: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _game._player._stepEnabled = true; + break; + + default: + break; + } +} + +void Scene607::handleThrowingBone() { + _animationActive = -1; + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _game._player._visible = false; + _scene->loadAnimation(formAnimName('D', _animationMode), 1); + break; + + case 1: + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + + if (_animationMode != 1) + _scene->_hotspots.activate(NOUN_OBNOXIOUS_DOG, false); + else { + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 6); + } + + _dogBarking = false; + if (_game._objects.isInInventory(OBJ_BONE)) { + _game._objects.setRoom(OBJ_BONE, 1); + if (_animationMode == 1) + _globals[kBone202Status] = 0; + } else { + _game._objects.setRoom(OBJ_BONES, 1); + _game._objects.addToInventory(OBJ_BONE); + } + + _scene->_sequences.addTimer(60, 2); + break; + + case 2: { + int quoteId = 0x2F8; + if (_animationMode == 1) + quoteId = 0x2F7; + + if (_animationMode == 2) { + _globals[kDogStatus] = 2; + _dogTimer = 0; + } + + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(quoteId)); + _scene->_sequences.addTimer(60, 3); + } + break; + + case 3: + _game._player._stepEnabled = true; + _animationActive = 0; + break; + + default: + break; + } +} + +void Scene607::preActions() { + if (_action.isAction(VERB_TALKTO, NOUN_OBNOXIOUS_DOG)) + _game._player._needToWalk = false; + + if (_action.isAction(VERB_WALK_THROUGH, NOUN_SIDE_ENTRANCE) && (_globals[kDogStatus] == 2) && (_game._difficulty != DIFFICULTY_EASY)) { + _shopAvailable = true; + _dogTimer = 0; + } + + if (_action.isAction(VERB_THROW, NOUN_BONES, 0x471) || _action.isAction(VERB_THROW, NOUN_BONE, 0x471)) + _game._player.walk(Common::Point(193, 100), FACING_NORTHEAST); + + if (_action.isAction(VERB_THROW, NOUN_BONES, 0x2C3) || _action.isAction(VERB_THROW, NOUN_BONE, 0x2C3)) + _game._player.walk(Common::Point(201, 107), FACING_SOUTHEAST); +} + +void Scene607::actions() { + if (_action.isAction(VERB_WALK_THROUGH, NOUN_SIDE_ENTRANCE)) + _scene->_nextSceneId = 608; + else if (_action.isAction(0x325, 0x324)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], syncIdx); + _scene->_sequences.addTimer(6, 2); + } + break; + + case 2: + _game._player._visible = false; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 10, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: { + int syncIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx); + _scene->_nextSceneId = 504; + } + break; + + default: + break; + } + } else if (_action.isAction(VERB_THROW, NOUN_BONES, 0x471) || _action.isAction(VERB_THROW, NOUN_BONE, 0x471)) { + if (_game._difficulty != DIFFICULTY_EASY) { + _animationMode = 1; + _scene->_kernelMessages.reset(); + if (_game._trigger == 0) + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x2F6)); + + handleThrowingBone(); + } + } else if ((_action.isAction(VERB_THROW, NOUN_BONES, 0x2C3) || _action.isAction(VERB_THROW, NOUN_BONE, 0x2C3)) && (_game._difficulty != DIFFICULTY_EASY) + && ((_globals[kDogStatus] == 1) || _game._trigger)) { + _animationMode = 2; + if (_game._trigger == 0) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x2F6)); + } + handleThrowingBone(); + } else if (_action._lookFlag || _action.isAction(VERB_LOOK, NOUN_STREET)) { + if ((_globals[kDogStatus] == 1) || (_game._difficulty == DIFFICULTY_EASY)) + _vm->_dialogs->show(60710); + else + _vm->_dialogs->show(60711); + } else if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(60712); + else if (_action.isAction(VERB_LOOK, NOUN_FENCE)) + _vm->_dialogs->show(60713); + else if (_action.isAction(VERB_LOOK, NOUN_CAR)) + _vm->_dialogs->show(60714); + else if (_action.isAction(VERB_LOOK, NOUN_MANHOLE)) + _vm->_dialogs->show(60715); + else if (_action.isAction(VERB_LOOK, NOUN_FIRE_HYDRANT) && (_globals[kDogStatus] == 1)) + _vm->_dialogs->show(60716); + else if (_action.isAction(VERB_LOOK, NOUN_SIGN)) + _vm->_dialogs->show(60717); + else if (_action.isAction(VERB_LOOK, NOUN_BROKEN_WINDOW)) + _vm->_dialogs->show(60718); + else if (_action.isAction(VERB_LOOK, NOUN_GARAGE_DOOR)) + _vm->_dialogs->show(60719); + else if (_action.isAction(VERB_LOOK, NOUN_SIDEWALK)) + _vm->_dialogs->show(60720); + else if (_action.isAction(VERB_LOOK, NOUN_AIR_HOSE)) + _vm->_dialogs->show(60721); + else if (_action.isAction(VERB_LOOK, NOUN_AUTO_SHOP)) { + if (_globals[kDogStatus] == 1) + _vm->_dialogs->show(60723); + else + _vm->_dialogs->show(60722); + } else if (_action.isAction(VERB_LOOK, NOUN_SIDE_ENTRANCE)) { + if (_globals[kDogStatus] == 1) + _vm->_dialogs->show(60725); + else + _vm->_dialogs->show(60724); + } else if (_action.isAction(VERB_LOOK, NOUN_OBNOXIOUS_DOG)) + _vm->_dialogs->show(60726); + else if (_action.isAction(VERB_TALKTO, NOUN_OBNOXIOUS_DOG)) + _vm->_dialogs->show(60727); + else if (_action.isAction(VERB_LOOK, NOUN_BARRICADE)) + _vm->_dialogs->show(60728); + else if (_action.isAction(VERB_WALK_DOWN, NOUN_STREET)) + _vm->_dialogs->show(60730); + else if (_action.isAction(0x3FF) && (_action.isAction(VERB_OPEN) || _action.isAction(VERB_PUSH) || _action.isAction(VERB_PULL))) + _vm->_dialogs->show(60731); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene608::Scene608(MADSEngine *vm) : Scene6xx(vm) { + _carMode = -1; + _carFrame = -1; + _carMoveMode = -1; + _dogDeathMode = -1; + _carHotspotId = -1; + _barkCount = -1; + _polycementHotspotId = -1; + _animationMode = -1; + _nextTrigger = -1; + _throwMode = -1; + + _resetPositionsFl = false; + _dogActiveFl = false; + _dogBarkingFl = false; + _dogFirstEncounter = false; + _rexBeingEaten = false; + _dogHitWindow = false; + _checkFl = false; + _dogSquashFl = false; + _dogSafeFl = false; + _buttonPressedonTimeFl = false; + _dogUnderCar = false; + _dogYelping = false; + + _dogWindowTimer = -1; + _dogRunTimer = -1; + + _dogTimer1 = 0; + _dogTimer2 = 0; +} + +void Scene608::synchronize(Common::Serializer &s) { + Scene6xx::synchronize(s); + + s.syncAsSint16LE(_carMode); + s.syncAsSint16LE(_carFrame); + s.syncAsSint16LE(_carMoveMode); + s.syncAsSint16LE(_dogDeathMode); + s.syncAsSint16LE(_carHotspotId); + s.syncAsSint16LE(_barkCount); + s.syncAsSint16LE(_polycementHotspotId); + s.syncAsSint16LE(_animationMode); + s.syncAsSint16LE(_nextTrigger); + s.syncAsSint16LE(_throwMode); + + s.syncAsByte(_resetPositionsFl); + s.syncAsByte(_dogActiveFl); + s.syncAsByte(_dogBarkingFl); + s.syncAsByte(_dogFirstEncounter); + s.syncAsByte(_rexBeingEaten); + s.syncAsByte(_dogHitWindow); + s.syncAsByte(_checkFl); + s.syncAsByte(_dogSquashFl); + s.syncAsByte(_dogSafeFl); + s.syncAsByte(_buttonPressedonTimeFl); + s.syncAsByte(_dogUnderCar); + s.syncAsByte(_dogYelping); + + s.syncAsSint32LE(_dogWindowTimer); + s.syncAsSint32LE(_dogRunTimer); + + s.syncAsUint32LE(_dogTimer1); + s.syncAsUint32LE(_dogTimer2); +} + +void Scene608::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(NOUN_POLYCEMENT); + _scene->addActiveVocab(NOUN_CAR); + _scene->addActiveVocab(NOUN_OBNOXIOUS_DOG); +} + +void Scene608::resetDogVariables() { + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 1); + int idx = _scene->_dynamicHotspots.add(NOUN_OBNOXIOUS_DOG, VERB_WALKTO, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(194, 142), FACING_EAST); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 4); + _dogBarkingFl = false; + _dogFirstEncounter = false; +} + +void Scene608::restoreAnimations() { + _scene->freeAnimation(); + _carMode = 0; + _game._player._stepEnabled = true; + if (_throwMode == 6) + _dogSquashFl = true; + + if (_globals[kCarStatus] == 0) { + _scene->_sequences.remove(_globals._sequenceIndexes[6]); + _scene->_sequences.remove(_globals._sequenceIndexes[7]); + _scene->loadAnimation(formAnimName('A', -1)); + } else { + _scene->_sequences.remove(_globals._sequenceIndexes[8]); + _scene->_sequences.remove(_globals._sequenceIndexes[6]); + _scene->_sequences.remove(_globals._sequenceIndexes[7]); + _scene->loadAnimation(formAnimName('A', -1)); + _scene->_activeAnimation->setCurrentFrame(6); + } +} + +void Scene608::setCarAnimations() { + _scene->freeAnimation(); + if (_globals[kCarStatus] == 0) { + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[6], Common::Point(143, 98)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 6); + _globals._sequenceIndexes[7] = _scene->_sequences.startCycle(_globals._spriteIndexes[7], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[7], Common::Point(141, 67)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 15); + } else { + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[6], Common::Point(143, 128)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 6); + _globals._sequenceIndexes[7] = _scene->_sequences.startCycle(_globals._spriteIndexes[7], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[7], Common::Point(141, 97)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[7], 15); + _globals._sequenceIndexes[8] = _scene->_sequences.startCycle(_globals._spriteIndexes[8], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[8], Common::Point(144, 126)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 5); + } +} + +void Scene608::handleThrowingBone() { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + setCarAnimations(); + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _animationMode = -1; + _game._player._visible = false; + _carMode = _throwMode; + if (_throwMode == 4) + _scene->loadAnimation(formAnimName('X', 2), 1); + else if (_throwMode == 5) + _scene->loadAnimation(formAnimName('X', 1), 1); + else + _scene->loadAnimation(formAnimName('X', 3), 1); + break; + + case 1: + _nextTrigger = 1; + _scene->_sequences.addTimer(1, 2); + break; + + case 2: + if (_nextTrigger != 2) + _scene->_sequences.addTimer(1, 2); + else { + if (_game._objects.isInInventory(OBJ_BONE)) + _game._objects.setRoom(OBJ_BONE, 1); + else { + _game._objects.setRoom(OBJ_BONES, 1); + _game._objects.addToInventory(OBJ_BONE); + } + _scene->_sequences.addTimer(60, 3); + } + break; + + case 3: + if (_throwMode != 6) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x304)); + _scene->_sequences.addTimer(120, 4); + } else + restoreAnimations(); + break; + + case 4: + restoreAnimations(); + break; + + default: + break; + } +} + +void Scene608::enter() { + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*RXMRD_7"); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*RXMRC_9"); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('c', 2)); + _globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('c', 0)); + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('c', 1)); + + if (_game._objects.isInRoom(OBJ_POLYCEMENT)) { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('g', -1)); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + int idx = _scene->_dynamicHotspots.add(NOUN_POLYCEMENT, VERB_WALKTO, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _polycementHotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(249, 129), FACING_NORTHEAST); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 6); + } + + if (_game._objects.isInRoom(OBJ_REARVIEW_MIRROR)) { + _globals._spriteIndexes[12] = _scene->_sprites.addSprites(formAnimName('m', -1)); + _globals._sequenceIndexes[12] = _scene->_sequences.startCycle(_globals._spriteIndexes[12], false, 1); + int idx = _scene->_dynamicHotspots.add(NOUN_REARVIEW_MIRROR, VERB_WALKTO, _globals._sequenceIndexes[12], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(71, 113), FACING_NORTHEAST); + _scene->_sequences.setDepth(_globals._sequenceIndexes[12], 15); + } + + if (_game._difficulty == DIFFICULTY_HARD) { + _globals._spriteIndexes[9] = _scene->_sprites.addSprites(formAnimName('g', 0)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('g', 1)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('g', 2)); + _globals._spriteIndexes[10] = _scene->_sprites.addSprites(formAnimName('h', 2)); + _globals._spriteIndexes[11] = _scene->_sprites.addSprites(formAnimName('h', 3)); + _rexBeingEaten = false; + + if (!_game._visitedScenes._sceneRevisited) { + _globals[kDogStatus] = 3; + _dogActiveFl = true; + } else + _dogActiveFl = (_globals[kDogStatus] != 4); + } else { + _globals[kDogStatus] = 4; + _dogActiveFl = false; + } + + _dogSquashFl = false; + _buttonPressedonTimeFl = false; + _dogWindowTimer = 0; + _dogRunTimer = 0; + _dogHitWindow = false; + _checkFl = false; + _dogUnderCar = false; + _dogYelping = false; + + + if (!_game._visitedScenes._sceneRevisited) + _globals[kCarStatus] = 0; + + _animationMode = 0; + _carMoveMode = 0; + _carFrame = -1; + + if (_globals[kCarStatus] == 0) { + _carMode = 0; + _dogDeathMode = 0; + _resetPositionsFl = false; + int idx = _scene->_dynamicHotspots.add(NOUN_CAR, VERB_WALKTO, -1, Common::Rect(99, 69, 99 + 82, 69 + 25)); + _carHotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(96, 132), FACING_NORTHEAST); + _scene->loadAnimation(formAnimName('A', -1)); + } else if (_globals[kCarStatus] == 3) { + _carMode = 0; + _dogDeathMode = 0; + _resetPositionsFl = false; + int idx = _scene->_dynamicHotspots.add(NOUN_CAR, VERB_WALKTO, -1, Common::Rect(100, 100, 100 + 82, 100 + 25)); + _carHotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(96, 132), FACING_NORTHEAST); + _scene->loadAnimation(formAnimName('A', -1)); + _scene->_activeAnimation->setCurrentFrame(6); + } else if (_globals[kCarStatus] == 1) { + _carMode = 2; + _dogDeathMode = 0; + _resetPositionsFl = false; + int idx = _scene->_dynamicHotspots.add(NOUN_CAR, VERB_WALKTO, -1, Common::Rect(99, 69, 99 + 82, 69 + 25)); + _carHotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(96, 132), FACING_NORTHEAST); + _scene->loadAnimation(formAnimName('C', -1)); + } else if (_globals[kCarStatus] == 2) { + _carMode = 1; + _dogDeathMode = 2; + _resetPositionsFl = true; + int idx = _scene->_dynamicHotspots.add(NOUN_CAR, VERB_WALKTO, -1, Common::Rect(99, 69, 99 + 82, 69 + 25)); + _carHotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(96, 132), FACING_NORTHEAST); + _scene->loadAnimation(formAnimName('B', -1)); + } else { + _carMode = 3; + _dogDeathMode = 2; + _resetPositionsFl = true; + int idx = _scene->_dynamicHotspots.add(NOUN_CAR, VERB_WALKTO, -1, Common::Rect(100, 100, 100 + 82, 100 + 25)); + _carHotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(96, 132), FACING_NORTHEAST); + _scene->loadAnimation(formAnimName('D', -1)); + } + + _vm->_palette->setEntry(252, 63, 44, 30); + _vm->_palette->setEntry(253, 63, 20, 22); + + if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(46, 132); + _game._player._facing = FACING_EAST; + if (_game._difficulty == DIFFICULTY_HARD) { + if (!_game._visitedScenes._sceneRevisited) + _dogFirstEncounter = true; + else if (_dogActiveFl) + resetDogVariables(); + } + } else if ((_game._difficulty == DIFFICULTY_HARD) && !_dogFirstEncounter && _dogActiveFl) { + if (!_dogUnderCar) + resetDogVariables(); + else { + _globals._sequenceIndexes[10] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[10], false, 9, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[10], 10, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 6); + } + } + + sceneEntrySound(); + + if (_scene->_roomChanged) + _game._objects.addToInventory(OBJ_BONES); + + _game.loadQuoteSet(0x2FB, 0x2FC, 0x2FE, 0x2FD, 0x2FF, 0x300, 0x301, 0x302, 0x303, 0x304, 0); +} + +void Scene608::step() { + if (_dogFirstEncounter) { + long diff = _scene->_frameStartTime - _dogTimer1; + if ((diff >= 0) && (diff <= 1)) + _dogWindowTimer += diff; + else + _dogWindowTimer++; + + _dogTimer1 = _scene->_frameStartTime; + } + + if (_dogActiveFl && (_dogWindowTimer >= 2) && !_dogHitWindow) { + _dogHitWindow = true; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 11, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 1); + _vm->_sound->command(14); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 70); + _dogWindowTimer = 0; + } + + if (_game._trigger == 70) + resetDogVariables(); + + if ((_game._difficulty == DIFFICULTY_HARD) && !_animationMode && _dogActiveFl && !_dogFirstEncounter && !_dogUnderCar) { + if (!_dogBarkingFl) { + if (_vm->getRandomNumber(1, 50) == 10) { + _dogBarkingFl = true; + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 5, 8, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 4); + int idx = _scene->_dynamicHotspots.add(NOUN_OBNOXIOUS_DOG, VERB_WALKTO, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(194, 142), FACING_EAST); + _barkCount = 0; + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_SPRITE, 2, 100); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 60); + } + } else if (_game._trigger == 60) { + int syncIdx = _globals._sequenceIndexes[5]; + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 6); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], syncIdx); + _scene->_kernelMessages.reset(); + _dogBarkingFl = false; + } + } + + if ((_game._trigger == 100) && _dogBarkingFl) { + _vm->_sound->command(12); + _barkCount++; + + if ((_barkCount >= 1) && (_barkCount <= 4)) { + Common::Point _barkPos(0, 0); + switch (_barkCount) { + case 1: + _barkPos = Common::Point(197, 66); + break; + + case 2: + _barkPos = Common::Point(230, 76); + break; + + case 3: + _barkPos = Common::Point(197, 86); + break; + + case 4: + _barkPos = Common::Point(230, 97); + break; + + default: + break; + } + _scene->_kernelMessages.add(_barkPos, 0xFDFC, 0, 0, 120, _game.getQuote(0x2FB)); + } + } + + if (_dogSquashFl && !_dogFirstEncounter && _dogUnderCar && _dogActiveFl) { + long diff = _scene->_frameStartTime - _dogTimer2; + if ((diff >= 0) && (diff <= 4)) + _dogRunTimer += diff; + else + _dogRunTimer++; + + _dogTimer2 = _scene->_frameStartTime; + } + + // CHECKME: _checkFl is always false? + if (_dogRunTimer >= 480 && !_checkFl && !_buttonPressedonTimeFl && !_dogFirstEncounter && _dogUnderCar && _dogActiveFl) { + _checkFl = true; + _dogSquashFl = false; + _dogSafeFl = true; + _checkFl = false; + _dogRunTimer = 0; + } else { + _dogSafeFl = false; + if (_game._player._moving && (_game._difficulty == DIFFICULTY_HARD) && _dogActiveFl && (_scene->_rails.getNext() > 0) && _dogUnderCar) + _dogSafeFl = true; + } + + if (_dogActiveFl && _dogSafeFl && !_buttonPressedonTimeFl) { + _dogDeathMode = 0; + _globals[kCarStatus] = 0; + _carMode = 0; + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + _dogUnderCar = false; + _dogYelping = false; + _scene->_kernelMessages.reset(); + _globals._sequenceIndexes[11] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[11], false, 6, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[11], SEQUENCE_TRIGGER_EXPIRE, 0, 92); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x2FF)); + } + + if (_game._trigger == 92) { + resetDogVariables(); + _animationMode = 0; + } + + if ((_carMode == 4) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() != _carFrame) { + _carFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextFrame = -1; + + if (_carFrame == 10) { + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + } + + if (_carFrame == 56) { + resetDogVariables(); + _animationMode = 0; + _nextTrigger = 2; + } + + if ((nextFrame >= 0) && (nextFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextFrame); + _carFrame = nextFrame; + } + } + } + + if ((_carMode == 5) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() != _carFrame) { + _carFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextFrame = -1; + + if (_carFrame == 10) { + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + } + + if (_carFrame == 52) { + resetDogVariables(); + _animationMode = 0; + _nextTrigger = 2; + } + + if ((nextFrame >= 0) && (nextFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextFrame); + _carFrame = nextFrame; + } + } + } + + + if ((_carMode == 6) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() != _carFrame) { + _carFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextFrame = -1; + + if (_carFrame == 11) { + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + } + + if (_carFrame == 41) { + _globals._sequenceIndexes[10] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[10], false, 9, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[10], 10, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[10], 6); + _dogUnderCar = true; + _nextTrigger = 2; + } + + + if ((nextFrame >= 0) && (nextFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextFrame); + _carFrame = nextFrame; + } + } + } + + if (_dogUnderCar) { + if (!_dogYelping) { + if (_vm->getRandomNumber(1, 50) == 10) { + _dogYelping = true; + _barkCount = 0; + _scene->_sequences.addTimer(12, 110); + _scene->_sequences.addTimer(22, 111); + _scene->_sequences.addTimer(120, 112); + } + _scene->_kernelMessages.reset(); + } + } else + _dogYelping = false; + + if (_game._trigger == 110) { + _vm->_sound->command(12); + _scene->_kernelMessages.add(Common::Point(150, 97), 0xFDFC, 0, 0, 60, _game.getQuote(0x303)); + } + + if (_game._trigger == 111) { + _vm->_sound->command(12); + _scene->_kernelMessages.add(Common::Point(183, 93), 0xFDFC, 0, 0, 60, _game.getQuote(0x303)); + } + + if (_game._trigger == 112) + _dogYelping = false; + + if ((_carMode == 0) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() != _carFrame) { + _carFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextFrame = -1; + + if ((_globals[kCarStatus] == 0) || (_globals[kCarStatus] == 3)) { + switch (_carMoveMode) { + case 0: + if (_globals[kCarStatus] == 0) + nextFrame = 0; + else + nextFrame = 6; + break; + + case 1: + if (_scene->_activeAnimation->getCurrentFrame() >= 12) { + nextFrame = 0; + _carMoveMode = 0; + _globals[kCarStatus] = 0; + } + break; + + case 2: + if (_scene->_activeAnimation->getCurrentFrame() >= 6) { + nextFrame = 6; + _carMoveMode = 0; + _globals[kCarStatus] = 3; + } + break; + + default: + break; + } + } + + if ((nextFrame >= 0) && (nextFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextFrame); + _carFrame = nextFrame; + } + } + } + + if ((_carMode == 2) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() != _carFrame) { + _carFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextFrame = -1; + + if (_carMoveMode == 0) + nextFrame = 28; + else if (_scene->_activeAnimation->getCurrentFrame() >= 28) { + nextFrame = 28; + _carMoveMode = 0; + } + + if ((nextFrame >= 0) && (nextFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextFrame); + _carFrame = nextFrame; + } + } + } + + if ((_carMode == 3) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() != _carFrame) { + _carFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextFrame = -1; + + if (_resetPositionsFl) { + nextFrame = 0; + _carMoveMode = 0; + } else if (_carMoveMode == 0) + nextFrame = 6; + else if (_scene->_activeAnimation->getCurrentFrame() >= 6) { + nextFrame = 6; + _carMoveMode = 0; + } + + if ((nextFrame >= 0) && (nextFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextFrame); + _carFrame = nextFrame; + } + } + } + + + if ((_carMode == 1) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() != _carFrame) { + _carFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextFrame = -1; + + if (_resetPositionsFl) { + nextFrame = 0; + _carMoveMode = 0; + } else if (_carMoveMode == 0) + nextFrame = 6; + else if (_scene->_activeAnimation->getCurrentFrame() >= 6) { + nextFrame = 6; + _carMoveMode = 0; + } + + if ((nextFrame >= 0) && (nextFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextFrame); + _carFrame = nextFrame; + } + } + } + + if (_game._player._moving && (_game._difficulty == DIFFICULTY_HARD) && _dogActiveFl && (_scene->_rails.getNext() > 0)) { + _game._player.cancelCommand(); + _game._player.startWalking(Common::Point(194, 142), FACING_EAST); + _scene->_rails.resetNext(); + if (_dogUnderCar) + _dogSafeFl = true; + } + + if (_game._player._special > 0 && (_game._difficulty == DIFFICULTY_HARD) && _dogActiveFl && _game._player._stepEnabled) + _game._player._stepEnabled = false; + + if ((_game._difficulty == DIFFICULTY_HARD) && _dogActiveFl && (_game._player._playerPos == Common::Point(194, 142)) + && (_game._trigger || !_rexBeingEaten)) { + _rexBeingEaten = true; + switch (_game._trigger) { + case 0: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _animationMode = 1; + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[9], 1, 2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 80); + _scene->_sequences.addTimer(10, 85); + break; + + case 80: + _game._player._visible = false; + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[9], 3, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 5); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[9], -1); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x2FC)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 81); + break; + + case 81: { + int syncIdx = _globals._sequenceIndexes[9]; + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], false, 5, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[9], 6, 38); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 5); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[9], syncIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 82); + } + break; + + case 82: { + int syncIdx = _globals._sequenceIndexes[9]; + _globals._sequenceIndexes[9] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[9], false, 15, 5, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[9], 39, 40); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 5); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[9], syncIdx); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 83); + } + break; + + case 83: { + _animationMode = 2; + int syncIdx = _globals._sequenceIndexes[9]; + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[9], 5); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[9], syncIdx); + _scene->_sequences.addTimer(60, 84); + } + break; + + case 84: + _rexBeingEaten = false; + _animationMode = 0; + _scene->_reloadSceneFlag = true; + _game._player._stepEnabled = true; + break; + + case 85: + if (_rexBeingEaten && (_animationMode == 1)) { + _vm->_sound->command(12); + _scene->_sequences.addTimer(10, 85); + } + break; + + default: + break; + } + } +} + +void Scene608::preActions() { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + + if ((_action.isAction(VERB_THROW, NOUN_BONE, 0x410) || _action.isAction(VERB_THROW, NOUN_BONES, 0x410) + || _action.isAction(VERB_THROW, NOUN_BONE, 0x411) || _action.isAction(VERB_THROW, NOUN_BONES, 0x411) + || _action.isAction(VERB_THROW, NOUN_BONES, 0x471) || _action.isAction(VERB_THROW, NOUN_BONE, 0x471)) && _dogActiveFl) { + _game._player._stepEnabled = false; + _game._player.walk(Common::Point(56, 146), FACING_EAST); + } + + if ((_action.isAction(VERB_THROW, NOUN_BONES, 0x41D) || _action.isAction(VERB_THROW, NOUN_BONE, 0x41D) + || _action.isAction(VERB_THROW, NOUN_BONES, 0x41E) || _action.isAction(VERB_THROW, NOUN_BONE, 0x41E)) && _dogActiveFl) { + _game._player._stepEnabled = false; + _game._player.walk(Common::Point(75, 136), FACING_EAST); + } + + if (_action.isAction(VERB_PUSH, NOUN_DOWN_BUTTON) && _dogUnderCar) { + _buttonPressedonTimeFl = true; + _dogDeathMode = 1; + } else + _buttonPressedonTimeFl = false; +} + +void Scene608::actions() { + if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOORWAY)) + _scene->_nextSceneId = 607; + else if (_action.isAction(VERB_PUSH, NOUN_DOWN_BUTTON)) { + _game._player._stepEnabled = true; + switch (_game._trigger) { + case 0: + if ((_globals[kCarStatus] == 0) || (_globals[kCarStatus] == 1) || (_globals[kCarStatus] == 2)) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], true, 6, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + } else + _vm->_dialogs->show(60839); + break; + + case 1: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[3]); + _game._player._visible = true; + if (_dogDeathMode == 0) + _carMode = 0; + else if (_dogDeathMode == 1) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x300)); + _globals[kCarStatus] = 1; + _carMode = 2; + _globals[kDogStatus] = 4; + _dogActiveFl = false; + _dogUnderCar = false; + _scene->_sequences.remove(_globals._sequenceIndexes[10]); + _scene->freeAnimation(); + _scene->loadAnimation(formAnimName('C', -1)); + } else { + _resetPositionsFl = false; + _carMode = 1; + _scene->freeAnimation(); + _scene->loadAnimation(formAnimName('B', -1)); + } + + _carMoveMode = 2; + _scene->_sequences.addTimer(1, 2); + break; + + case 2: + if (_carMoveMode != 0) + _scene->_sequences.addTimer(1, 2); + else { + _scene->_dynamicHotspots.remove(_carHotspotId); + int idx = _scene->_dynamicHotspots.add(NOUN_CAR, VERB_WALKTO, -1, Common::Rect(100, 100, 100 + 82, 100 + 25)); + _carHotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(96, 132), FACING_NORTHEAST); + if (_globals[kCarStatus] == 1) + _scene->_sequences.addTimer(120, 3); + else { + if (_dogDeathMode == 0) + _globals[kCarStatus] = 3; + else { + _globals[kCarStatus] = 4; + _carMode = 3; + _dogDeathMode = 2; + } + _game._player._stepEnabled = true; + } + } + break; + + case 3: + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x302)); + _globals[kCarStatus] = 4; + _carMode = 3; + _dogDeathMode = 2; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_PUSH, NOUN_UP_BUTTON)) { + switch (_game._trigger) { + case 0: + if ((_globals[kCarStatus] == 3) || (_globals[kCarStatus] == 4)) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], true, 6, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 3); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + } else + _vm->_dialogs->show(60840); + break; + + case 1: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[3]); + _game._player._visible = true; + if (_dogDeathMode == 0) + _carMode = 0; + else { + _carMode = 3; + _resetPositionsFl = false; + _scene->freeAnimation(); + _scene->loadAnimation(formAnimName('D', -1)); + } + _carMoveMode = 1; + _scene->_sequences.addTimer(1, 2); + break; + + case 2: { + if (_carMoveMode != 0) + _scene->_sequences.addTimer(1, 2); + else if (_dogDeathMode == 0) + _globals[kCarStatus] = 0; + else if (_dogDeathMode == 2) { + _globals[kCarStatus] = 2; + _carMode = 3; + _dogDeathMode = 2; + } + _scene->_dynamicHotspots.remove(_carHotspotId); + int idx = _scene->_dynamicHotspots.add(NOUN_CAR, VERB_WALKTO, -1, Common::Rect(99, 69, 99 + 82, 69 + 25)); + _carHotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(96, 132), FACING_NORTHEAST); + _game._player._stepEnabled = true; + } + break; + + default: + break; + } + } else if (_action.isAction(VERB_THROW, NOUN_BONE, 0x410) || _action.isAction(VERB_THROW, NOUN_BONES, 0x410) + || _action.isAction(VERB_THROW, NOUN_BONES, 0x471) || _action.isAction(VERB_THROW, NOUN_BONE, 0x471)) { + _game._player._stepEnabled = true; + if (_dogActiveFl) { + if (_game._trigger == 0) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x2FE)); + } + _throwMode = 4; + handleThrowingBone(); + } else + _vm->_dialogs->show(60841); + } else if (_action.isAction(VERB_THROW, NOUN_BONE, 0x411) || _action.isAction(VERB_THROW, NOUN_BONES, 0x411)) { + _game._player._stepEnabled = true; + if (_dogActiveFl) { + if (_game._trigger == 0) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x2FD)); + } + _throwMode = 5; + handleThrowingBone(); + } else + _vm->_dialogs->show(60841); + } else if (_action.isAction(VERB_THROW, NOUN_BONES, 0x41D) || _action.isAction(VERB_THROW, NOUN_BONE, 0x41D) + || _action.isAction(VERB_THROW, NOUN_BONES, 0x41E) || _action.isAction(VERB_THROW, NOUN_BONE, 0x41E)) { + _game._player._stepEnabled = true; + if ((_globals[kCarStatus] == 0) && _dogActiveFl) { + if (_dogActiveFl) { + if (_game._trigger == 0) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x301)); + } + _throwMode = 6; + handleThrowingBone(); + } else + _vm->_dialogs->show(60841); + } else + _vm->_dialogs->show(60842); + } else if (_action.isAction(VERB_TAKE, NOUN_POLYCEMENT) && (_game._trigger || !_game._objects.isInInventory(OBJ_POLYCEMENT))) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], true, 6, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 4, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _vm->_sound->command(9); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->_dynamicHotspots.remove(_polycementHotspotId); + break; + + case 2: + _game._objects.addToInventory(OBJ_POLYCEMENT); + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[2]); + _game._player._visible = true; + _game._player._stepEnabled = true; + _vm->_dialogs->showItem(OBJ_POLYCEMENT, 60833); + break; + + default: + break; + } + } else if (_action.isAction(VERB_TAKE, NOUN_REARVIEW_MIRROR) && (_game._trigger || !_game._objects.isInInventory(OBJ_REARVIEW_MIRROR))) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], true, 6, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 2, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _vm->_sound->command(9); + _scene->_sequences.remove(_globals._sequenceIndexes[12]); + _game._objects.addToInventory(OBJ_REARVIEW_MIRROR); + _vm->_dialogs->showItem(OBJ_REARVIEW_MIRROR, 60827); + break; + + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[2]); + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action._lookFlag) { + if (_game._difficulty != DIFFICULTY_HARD) + _vm->_dialogs->show(60810); + else if (_globals[kDogStatus] == 4) + _vm->_dialogs->show(60812); + else + _vm->_dialogs->show(60811); + } else if (_action.isAction(VERB_LOOK) && (_action.isAction(0x412) || _action.isAction(0x408) || _action.isAction(0x414) + || _action.isAction(0x40D) || _action.isAction(0x41C))) + _vm->_dialogs->show(60813); + else if (_action.isAction(VERB_TAKE) && (_action.isAction(0x412) || _action.isAction(0x408) || _action.isAction(0x414) + || _action.isAction(0x40D) || _action.isAction(0x41C))) + _vm->_dialogs->show(60814); + else if (_action.isAction(VERB_LOOK, NOUN_GARAGE_FLOOR) || _action.isAction(VERB_LOOK, NOUN_FRONT_OF_GARAGE) || _action.isAction(VERB_LOOK, NOUN_REAR_OF_GARAGE)) { + if (_dogActiveFl) + _vm->_dialogs->show(60815); + else + _vm->_dialogs->show(60816); + } else if (_action.isAction(VERB_LOOK, NOUN_SPARE_RIBS)) + _vm->_dialogs->show(60817); + else if (_action.isAction(VERB_TAKE, NOUN_SPARE_RIBS)) { + if (_game._difficulty == DIFFICULTY_HARD) + _vm->_dialogs->show(60818); + else + _vm->_dialogs->show(60819); + } else if (_action.isAction(VERB_LOOK, NOUN_UP_BUTTON)) + _vm->_dialogs->show(60820); + else if (_action.isAction(VERB_LOOK, NOUN_DOWN_BUTTON)) + _vm->_dialogs->show(60821); + else if (_action.isAction(VERB_LOOK, NOUN_TRASH_CAN)) + _vm->_dialogs->show(60822); + else if (_action.isAction(VERB_LOOK, NOUN_CALENDAR)) + _vm->_dialogs->show(60823); + else if (_action.isAction(VERB_LOOK, NOUN_STORAGE_BOX)) { + if (_game._objects[OBJ_REARVIEW_MIRROR]._roomNumber == _scene->_currentSceneId) + _vm->_dialogs->show(60825); + else + _vm->_dialogs->show(60824); + } else if (_action.isAction(VERB_OPEN, NOUN_STORAGE_BOX)) + _vm->_dialogs->show(60826); + else if (_action.isAction(VERB_LOOK, NOUN_REARVIEW_MIRROR) && (_action._mainObjectSource == 4)) + _vm->_dialogs->show(60828); + else if (_action.isAction(VERB_LOOK, NOUN_TOOL_BOX)) { + if (_game._objects[OBJ_POLYCEMENT]._roomNumber == _scene->_currentSceneId) + _vm->_dialogs->show(60829); + else + _vm->_dialogs->show(60830); + } else if (_action.isAction(VERB_OPEN, NOUN_TOOL_BOX)) + _vm->_dialogs->show(60831); + else if ((_action.isAction(VERB_LOOK, NOUN_POLYCEMENT)) && (_game._objects.isInRoom(OBJ_POLYCEMENT))) + _vm->_dialogs->show(60832); + else if (_action.isAction(VERB_LOOK, NOUN_GREASE_CAN) || _action.isAction(VERB_LOOK, NOUN_OIL_CAN)) + _vm->_dialogs->show(60834); + else if (_action.isAction(VERB_LOOK, NOUN_CAR_LIFT)) + _vm->_dialogs->show(60835); + else if (_action.isAction(VERB_LOOK, NOUN_CHAIR) || _action.isAction(VERB_LOOK, NOUN_HAT)) + _vm->_dialogs->show(60836); + else if (_action.isAction(VERB_LOOK, NOUN_DANGER_ZONE)) + _vm->_dialogs->show(60838); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene609::Scene609(MADSEngine *vm) : Scene6xx(vm) { + _videoDoorMode = -1; +} + +void Scene609::synchronize(Common::Serializer &s) { + Scene6xx::synchronize(s); + + s.syncAsSint16LE(_videoDoorMode); +} + +void Scene609::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene609::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('c', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('h', 0)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*RXCD_9"); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites("*RXMRC_9"); + + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 5); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 9); + + if (!_game._visitedScenes._sceneRevisited) + _globals[kBeenInVideoStore] = false; + + if (_scene->_priorSceneId == 611) { + _game._player._playerPos = Common::Point(264, 69); + _game._player._facing = FACING_SOUTHWEST; + } else if (_scene->_priorSceneId == 610) { + _game._player._playerPos = Common::Point(23, 90); + _game._player._facing = FACING_EAST; + _scene->_sequences.addTimer(60, 60); + _game._player._stepEnabled = false; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(86, 136); + _game._player._facing = FACING_NORTHEAST; + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 5); + _scene->loadAnimation(formAnimName('R', 1), 70); + } + + if (_scene->_roomChanged) { + _game._objects.addToInventory(OBJ_DOOR_KEY); + if (_game._difficulty != DIFFICULTY_EASY) + _game._objects.addToInventory(OBJ_PENLIGHT); + } + + sceneEntrySound(); + _game.loadQuoteSet(0x305, 0x306, 0x307, 0x308, 0x309, 0); +} + +void Scene609::step() { + switch (_game._trigger) { + case 60: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 9); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 61); + break; + + case 61: + _scene->_hotspots.activate(NOUN_VIDEO_STORE_DOOR, false); + _game._player.walk(Common::Point(101, 100), FACING_EAST); + _scene->_sequences.addTimer(180, 62); + break; + + case 62: + _scene->_sequences.remove( _globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0); + _scene->_hotspots.activate(NOUN_VIDEO_STORE_DOOR, true); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 9); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 63); + break; + + case 63: + if (!_globals[kHasTalkedToHermit] && (_game._difficulty != DIFFICULTY_HARD)) { + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 26, 2, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7); + _scene->_sequences.setPosition(_globals._sequenceIndexes[3], Common::Point(287, 73)); + _scene->_sequences.setScale(_globals._sequenceIndexes[3], 47); + } + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 9); + _game._player._stepEnabled = true; + break; + + default: + break; + } + + switch (_game._trigger) { + case 70: + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + _scene->_sequences.addTimer(6, 71); + break; + + case 71: + if (!_globals[kHasTalkedToHermit]) { + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 26, 2, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7); + _scene->_sequences.setPosition(_globals._sequenceIndexes[3], Common::Point(287, 73)); + _scene->_sequences.setScale(_globals._sequenceIndexes[3], 47); + } + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + break; + + case 72: + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 5); + _game._player._stepEnabled = true; + break; + + default: + break; + } +} + +void Scene609::enterStore() { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + if (_videoDoorMode == 2) + _scene->_sequences.addTimer(1, 4); + else { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x305)); + _scene->_sequences.addTimer(120, 1); + } + break; + + case 1: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x306)); + _scene->_sequences.addTimer(60, 2); + break; + + case 2: + _game._player._visible = false; + _globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], true, 11, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[5]); + _game._player._visible = true; + _game._objects.setRoom(OBJ_DOOR_KEY, 1); + _scene->_sequences.addTimer(15, 4); + break; + + case 4: + _game._player._visible = false; + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], true, 1); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.addTimer(15, 5); + break; + + case 5: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _game._player._visible = true; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 9); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 6); + break; + + case 6: + _scene->_hotspots.activate(NOUN_VIDEO_STORE_DOOR, false); + if (_videoDoorMode == 1) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 180, _game.getQuote(0x307)); + } + _game._player.walk(Common::Point(23, 90), FACING_WEST); + _scene->_sequences.addTimer(180, 7); + break; + + case 7: + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 9); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 8); + break; + + case 8: + _scene->_hotspots.activate(NOUN_VIDEO_STORE_DOOR, true); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 9); + _globals[kBeenInVideoStore] = true; + _game._player._stepEnabled = true; + _scene->_nextSceneId = 610; + break; + + default: + break; + } +} + +void Scene609::preActions() { + if (_action.isAction(VERB_UNLOCK, 0x6F, 0x425)) + _game._player.walk(Common::Point(78, 99), FACING_NORTHWEST); +} + +void Scene609::actions() { + if (_action.isAction(VERB_WALK_TOWARDS, NOUN_ALLEY)) + _scene->_nextSceneId = 611; + else if (_action.isAction(VERB_WALK_THROUGH, NOUN_VIDEO_STORE_DOOR)) { + if (!_globals[kBeenInVideoStore]) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x308)); + _scene->_sequences.addTimer(120, 1); + break; + + case 1: + _game._player._visible = false; + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], true, 1); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.addTimer(30, 2); + break; + + case 2: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _game._player._visible = true; + _scene->_sequences.addTimer(60, 3); + break; + + case 3: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x309)); + _scene->_sequences.addTimer(120, 4); + break; + + case 4: + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else { + _videoDoorMode = 2; + enterStore(); + } + } else if (_action.isAction(VERB_UNLOCK, 0x6F, 0x425)) { + _videoDoorMode = 1; + enterStore(); + } else if (_action.isAction(0x325, 0x324)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 5); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[1]; + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 5); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[1], syncIdx); + _scene->_sequences.addTimer(6, 2); + } + break; + + case 2: + _game._player._visible = false; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 10, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: { + int syncIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, -2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], syncIdx); + _scene->_nextSceneId = 504; + } + break; + + default: + break; + } + } else if (_action._lookFlag) + _vm->_dialogs->show(60910); + else if (_action.isAction(VERB_LOOK, NOUN_STREET)) + _vm->_dialogs->show(60911); + else if (_action.isAction(VERB_LOOK, NOUN_SPOT_A_POT)) + _vm->_dialogs->show(60912); + else if (_action.isAction(VERB_LOOK, NOUN_VIDEO_STORE)) + _vm->_dialogs->show(60913); + else if (_action.isAction(VERB_LOOK, NOUN_BILLBOARD)) + _vm->_dialogs->show(60914); + else if (_action.isAction(VERB_LOOK, NOUN_STATUE)) + _vm->_dialogs->show(60915); + else if (_action.isAction(VERB_LOOK, NOUN_CAR)) + _vm->_dialogs->show(60916); + else if (_action.isAction(VERB_LOOK, NOUN_NEWSSTAND)) + _vm->_dialogs->show(60917); + else if (_action.isAction(VERB_LOOK, NOUN_VIDEO_STORE_DOOR)) { + if (!_globals[kBeenInVideoStore]) + _vm->_dialogs->show(60918); + else + _vm->_dialogs->show(60919); + } else if (_action.isAction(VERB_WALK_DOWN, NOUN_STREET)) + _vm->_dialogs->show(60730); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene610::Scene610(MADSEngine *vm) : Scene6xx(vm) { + _handsetHotspotId = -1; + _checkVal = -1; + + _cellCharging = false; + + _cellChargingTimer = -1; + _lastFrameTimer = 0; +} + +void Scene610::synchronize(Common::Serializer &s) { + Scene6xx::synchronize(s); + + s.syncAsSint16LE(_handsetHotspotId); + s.syncAsSint16LE(_checkVal); + + s.syncAsByte(_cellCharging); + + s.syncAsSint32LE(_cellChargingTimer); + s.syncAsUint32LE(_lastFrameTimer); +} + +void Scene610::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_PHONE_HANDSET); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene610::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('p', -1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*RXMRC_9"); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('x', 1)); + + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 60, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 13); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 30, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 9); + + if (!_game._visitedScenes._sceneRevisited) + _cellCharging = false; + + if (_game._objects[OBJ_PHONE_HANDSET]._roomNumber == _scene->_currentSceneId) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 9, 0, 0, 0); + _handsetHotspotId = _scene->_dynamicHotspots.add(NOUN_PHONE_HANDSET, VERB_WALKTO, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_handsetHotspotId, Common::Point(132, 121), FACING_NORTHWEST); + if ((_globals[kHandsetCellStatus] == 2) && (_game._difficulty == DIFFICULTY_HARD) && !_globals[kDurafailRecharged]) + _globals[kHandsetCellStatus] = 1; + } + + if (_scene->_roomChanged && _game._difficulty != DIFFICULTY_EASY) + _game._objects.addToInventory(OBJ_PENLIGHT); + + if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(175, 152); + _game._player._facing = FACING_NORTHWEST; + } + + sceneEntrySound(); +} + +void Scene610::step() { + if (_cellCharging) { + long diff = _scene->_frameStartTime - _lastFrameTimer; + if ((diff >= 0) && (diff <= 60)) + _cellChargingTimer += diff; + else + _cellChargingTimer++; + + _lastFrameTimer = _scene->_frameStartTime; + } + + // CHECKME: _checkVal is always false, could be removed + if ((_cellChargingTimer >= 60) && !_checkVal) { + _checkVal = true; + _globals[kHandsetCellStatus] = 1; + _cellCharging = false; + _checkVal = false; + _cellChargingTimer = 0; + } +} + +void Scene610::actions() { + if (_action.isAction(VERB_EXIT_FROM, NOUN_VIDEO_STORE)) + _scene->_nextSceneId = 609; + else if (_action.isAction(VERB_TAKE, NOUN_PHONE_HANDSET)) { + if ( _game._trigger || !_game._objects.isInInventory(OBJ_PHONE_HANDSET)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], true, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 2, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _vm->_sound->command(9); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->_dynamicHotspots.remove(_handsetHotspotId); + _game._objects.addToInventory(OBJ_PHONE_HANDSET); + _vm->_dialogs->showItem(OBJ_PHONE_HANDSET, 61017); + break; + + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[2]); + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } + } else if (_action.isAction(VERB_PUT, NOUN_PHONE_HANDSET, 0x42F)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], true, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 2, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 9, 0, 0, 0); + _handsetHotspotId = _scene->_dynamicHotspots.add(NOUN_PHONE_HANDSET, VERB_WALKTO, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(_handsetHotspotId, Common::Point(132, 121), FACING_NORTHWEST); + _game._objects.setRoom(OBJ_PHONE_HANDSET, _scene->_currentSceneId); + break; + + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[2]); + _game._player._visible = true; + _game._player._stepEnabled = true; + if ((_globals[kHandsetCellStatus] == 2) && (_game._difficulty == DIFFICULTY_HARD) && !_globals[kDurafailRecharged]) + _cellCharging = true; + + _vm->_dialogs->show(61032); + break; + + default: + break; + } + } else if (_action.isAction(VERB_LOOK, NOUN_PIPPY_BILLBOARD)) + _vm->_dialogs->show(61010); + else if (_action.isAction(VERB_LOOK, NOUN_CIVILIZATION_AD)) + _vm->_dialogs->show(61011); + else if (_action.isAction(VERB_LOOK, NOUN_MARX_BROS_POSTER)) + _vm->_dialogs->show(61012); + else if (_action.isAction(VERB_LOOK, NOUN_VIDEO_MONITOR)) + _vm->_dialogs->show(61013); + else if (_action.isAction(VERB_LOOK, NOUN_VIDEO_STORE)) + _vm->_dialogs->show(61014); + else if (_action._lookFlag) + _vm->_dialogs->show(61015); + else if (_action.isAction(VERB_LOOK, NOUN_LOGO)) + _vm->_dialogs->show(61018); + else if (_action.isAction(VERB_LOOK, NOUN_CEMENT)) { + if (_game._visitedScenes.exists(601)) + _vm->_dialogs->show(61020); + else + _vm->_dialogs->show(61019); + } else if (_action.isAction(VERB_LOOK, NOUN_COUNTER)) + _vm->_dialogs->show(61021); + else if (_action.isAction(VERB_LOOK, NOUN_PHONE_ANTENNA)) + _vm->_dialogs->show(61022); + else if (_action.isAction(VERB_LOOK, NOUN_SMELLY_SNEAKER)) + _vm->_dialogs->show(61023); + else if (_action.isAction(VERB_TAKE, NOUN_SMELLY_SNEAKER)) + _vm->_dialogs->show(61024); + else if (_action.isAction(VERB_LOOK, NOUN_SPOTLIGHT)) + _vm->_dialogs->show(61025); + else if (_action.isAction(VERB_LOOK, NOUN_PHONE_HANDSET) && (_action._mainObjectSource == 4)) + _vm->_dialogs->show(61026); + else if (_action.isAction(VERB_LOOK, NOUN_PHONE_CRADLE)) + _vm->_dialogs->show(61027); + else if (_action.isAction(VERB_LOOK, NOUN_RETURN_SLOT)) + _vm->_dialogs->show(61028); + else if (_action.isAction(VERB_PUT, NOUN_RETURN_SLOT) + && _game._objects.isInInventory(_game._objects.getIdFromDesc(_action._activeAction._objectNameId))) + _vm->_dialogs->show(61029); + else if ( _action.isAction(0x44F) || _action.isAction(0x444) || _action.isAction(0x430) + || _action.isAction(0x44C) || _action.isAction(0x44D) || _action.isAction(0x446) + || _action.isAction(0x497) || _action.isAction(0x449) || _action.isAction(0x44E) + || _action.isAction(0x450) || _action.isAction(0x42C)) { + if (_action.isAction(VERB_LOOK)) + _vm->_dialogs->show(61030); + else if (_action.isAction(VERB_TAKE)) + _vm->_dialogs->show(61031); + else + return; + } else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene611::Scene611(MADSEngine *vm) : Scene6xx(vm), _defaultDialogPos(0, 0) { + _seenRatFl = false; + _eyesRunningFl = false; + _shouldRemoveEyes = false; + _ratPresentFl = false; + _duringDialogFl = false; + _resetBatterieText = false; + _hermitTalkingFl = false; + _hermitMovingFl = false; + _alreadyTalkingFl = false; + _giveBatteriesFl = false; + _startTradingFl = false; + _check1Fl = false; + _stickFingerFl = false; + + _randVal = -1; + _ratHotspotId = -1; + _hermitDialogNode = -1; + _hermitDisplayedQuestion = -1; + _nextFrame = -1; + _hermitMode = -1; + + _ratTimer = 0; +} + +void Scene611::synchronize(Common::Serializer &s) { + Scene6xx::synchronize(s); + + s.syncAsByte(_seenRatFl); + s.syncAsByte(_eyesRunningFl); + s.syncAsByte(_shouldRemoveEyes); + s.syncAsByte(_ratPresentFl); + s.syncAsByte(_duringDialogFl); + s.syncAsByte(_resetBatterieText); + s.syncAsByte(_hermitTalkingFl); + s.syncAsByte(_hermitMovingFl); + s.syncAsByte(_alreadyTalkingFl); + s.syncAsByte(_giveBatteriesFl); + s.syncAsByte(_startTradingFl); + s.syncAsByte(_check1Fl); + s.syncAsByte(_stickFingerFl); + + s.syncAsSint16LE(_randVal); + s.syncAsSint16LE(_ratHotspotId); + s.syncAsSint16LE(_hermitDialogNode); + s.syncAsSint16LE(_hermitDisplayedQuestion); + s.syncAsSint16LE(_nextFrame); + s.syncAsSint16LE(_hermitMode); + + s.syncAsUint32LE(_ratTimer); + + s.syncAsSint16LE(_defaultDialogPos.x); + s.syncAsSint16LE(_defaultDialogPos.y); +} + +void Scene611::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_RAT); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene611::handleRatMoves() { + _ratPresentFl = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 11, -2); + _ratTimer = _game._player._priorTimer; + _scene->_dynamicHotspots.remove(_ratHotspotId); +} + +void Scene611::handleTrading() { + if (_game._objects.isInInventory(OBJ_DURAFAIL_CELLS)) + _game._objects.setRoom(OBJ_DURAFAIL_CELLS, 1); + + if (_game._objects.isInInventory(OBJ_PHONE_CELLS)) + _game._objects.setRoom(OBJ_PHONE_CELLS, 1); + + _game._objects.addToInventory(OBJ_FAKE_ID); +} + +void Scene611::setDialogNode(int node) { + if (node > 0) + _hermitDialogNode = node; + + _game._player._stepEnabled = true; + + switch (node) { + case 0: + _scene->_userInterface.setup(kInputBuildingSentences); + _duringDialogFl = false; + _hermitDialogNode = 0; + break; + + case 1: + _dialog1.start(); + _duringDialogFl = true; + _hermitDialogNode = 1; + break; + + case 2: + _dialog2.start(); + _duringDialogFl = true; + _hermitDialogNode = 2; + break; + + default: + break; + } +} + +bool Scene611::check2ChargedBatteries() { + if ((_game._objects.isInInventory(OBJ_DURAFAIL_CELLS) && !_game._objects.isInInventory(OBJ_PHONE_CELLS)) + || (!_game._objects.isInInventory(OBJ_DURAFAIL_CELLS) && _game._objects.isInInventory(OBJ_PHONE_CELLS))) + return true; + + return false; +} + +bool Scene611::check4ChargedBatteries() { + if (_game._objects.isInInventory(OBJ_DURAFAIL_CELLS) && _game._objects.isInInventory(OBJ_PHONE_CELLS) && _globals[136]) + return true; + + return false; +} + +void Scene611::handleTalking(int delay) { + if (_hermitTalkingFl) + _alreadyTalkingFl = true; + + _hermitTalkingFl = true; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(delay, 100); +} + +void Scene611::handleSubDialog1() { + switch (_action._activeAction._verbId) { + case 0x287: + _stickFingerFl = true; + _nextFrame = 34; + _hermitMovingFl = false; + _hermitMode = 5; + displayHermitQuestions(5); + _dialog1.write(0x287, false); + if (!_dialog1.read(0x288)) + _dialog1.write(0x28E, true); + + _dialog2.write(0x29C, true); + _dialog2.write(0x29D, true); + _dialog2.write(0x29E, true); + setDialogNode(2); + break; + + case 0x288: + handleTalking(500); + displayHermitQuestions(6); + _dialog1.write(0x288, false); + _dialog1.write(0x289, true); + if (!_dialog1.read(0x287)) + _dialog1.write(0x28E, true); + + setDialogNode(1); + break; + + case 0x289: + handleTalking(500); + displayHermitQuestions(10); + _dialog1.write(0x289, false); + _dialog1.write(0x28A, true); + _dialog1.write(0x28B, true); + setDialogNode(1); + break; + + case 0x28A: + handleTalking(500); + displayHermitQuestions(11); + _dialog1.write(0x28A, false); + setDialogNode(1); + break; + + case 0x28B: + handleTalking(500); + displayHermitQuestions(12); + _dialog1.write(0x28C, true); + _dialog1.write(0x28D, true); + _dialog1.write(0x28B, false); + setDialogNode(1); + break; + + case 0x28C: + handleTalking(500); + displayHermitQuestions(13); + _dialog1.write(0x28C, false); + setDialogNode(1); + break; + + case 0x28D: + handleTalking(500); + displayHermitQuestions(14); + _dialog1.write(0x290, true); + _dialog1.write(0x28D, false); + _dialog1.write(0x28F, true); + setDialogNode(1); + break; + + case 0x28E: + handleTalking(500); + displayHermitQuestions(15); + _dialog1.write(0x295, true); + _dialog1.write(0x28E, false); + setDialogNode(1); + break; + + case 0x290: + handleTalking(500); + displayHermitQuestions(17); + _dialog1.write(0x290, false); + _dialog1.write(0x28E, false); + if (!_dialog1.read(0x28F)) + _dialog1.write(0x291, true); + + setDialogNode(1); + break; + + case 0x291: + handleTalking(500); + displayHermitQuestions(18); + _dialog1.write(0x291, false); + if ((!_game._objects.isInInventory(OBJ_DURAFAIL_CELLS)) && (!_game._objects.isInInventory(OBJ_PHONE_CELLS))) { + _dialog1.write(0x292, true); + _dialog1.write(0x293, true); + } + + if ((_game._objects.isInInventory(OBJ_DURAFAIL_CELLS)) || (_game._objects.isInInventory(OBJ_PHONE_CELLS))) + _dialog1.write(0x294, true); + + if (!_game._objects.isInInventory(OBJ_DURAFAIL_CELLS) && !_game._objects.isInInventory(OBJ_PHONE_CELLS)) + _globals[kExecuted_1_11] = true; + + setDialogNode(1); + break; + + case 0x28F: + handleTalking(500); + displayHermitQuestions(16); + _dialog1.write(0x28F, false); + if (!_dialog1.read(0x290)) + _dialog1.write(0x291, true); + + setDialogNode(1); + break; + + case 0x295: + handleTalking(500); + displayHermitQuestions(20); + _dialog1.write(0x295, false); + setDialogNode(1); + break; + + case 0x292: + handleTalking(500); + displayHermitQuestions(19); + _dialog1.write(0x292, false); + _dialog1.write(0x293, false); + setDialogNode(1); + break; + + case 0x293: { + handleTalking(200); + _scene->_kernelMessages.reset(); + + Common::String curQuote = _game.getQuote(0x2D1); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y), 0xFDFC, 0, 0, 120, curQuote); + + curQuote = _game.getQuote(0x2D2); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 14), 0xFDFC, 0, 0, 120, curQuote); + + _dialog1.write(0x293, false); + setDialogNode(0); + } + break; + + case 0x294: { + bool hermitPleasedFl = false; + + switch (_game._difficulty) { + case DIFFICULTY_EASY: + hermitPleasedFl = _game._objects.isInInventory(OBJ_DURAFAIL_CELLS) || _game._objects.isInInventory(OBJ_PHONE_CELLS); + break; + + case DIFFICULTY_MEDIUM: + hermitPleasedFl = _game._objects.isInInventory(OBJ_DURAFAIL_CELLS) && _game._objects.isInInventory(OBJ_PHONE_CELLS); + break; + + default: // HARD + hermitPleasedFl = check4ChargedBatteries(); + break; + } + + if (hermitPleasedFl) { + _hermitDisplayedQuestion = 21; + if (!_giveBatteriesFl) + setDialogNode(0); + else + _giveBatteriesFl = false; + } else if (((_game._difficulty == DIFFICULTY_MEDIUM) || (_game._difficulty == DIFFICULTY_HARD)) && check2ChargedBatteries()) { + _hermitDisplayedQuestion = 22; + if (!_giveBatteriesFl) + setDialogNode(0); + else + _giveBatteriesFl = false; + } else { + _hermitDisplayedQuestion = 23; + if (!_giveBatteriesFl) + setDialogNode(0); + else + _giveBatteriesFl = false; + } + _startTradingFl = true; + } + break; + + case 0x296: { + _scene->_kernelMessages.reset(); + + Common::String curQuote = _game.getQuote(0x2E6); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 14), 0xFDFC, 0, 0, 120, curQuote); + + setDialogNode(0); + handleTalking(200); + } + break; + + default: + break; + } +} + +void Scene611::handleSubDialog2() { + switch (_action._activeAction._verbId) { + case 0x29C: + displayHermitQuestions(7); + setDialogNode(1); + handleTalking(500); + break; + + case 0x29D: + displayHermitQuestions(8); + setDialogNode(1); + handleTalking(500); + break; + + case 0x29E: + displayHermitQuestions(9); + setDialogNode(1); + handleTalking(500); + break; + + case 0x29F: { + _scene->_kernelMessages.reset(); + Common::String curQuote = _game.getQuote(0x2A7); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 14), 0xFDFC, 0, 0, 120, curQuote); + setDialogNode(0); + _dialog2.write(0x29F, false); + } + break; + + default: + break; + } +} + +void Scene611::handleDialog() { + if (_game._trigger == 0) { + _scene->_kernelMessages.reset(); + _game._player._stepEnabled = false; + + Common::String curQuote = _game.getQuote(_action._activeAction._verbId); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + + if (width > 200) { + Common::String subQuote1, subQuote2; + _game.splitQuote(curQuote, subQuote1, subQuote2); + _scene->_kernelMessages.add(Common::Point(0, -14), 0x1110, 34, 0, 150, subQuote1); + + if (_action._activeAction._verbId == 0x29D) + _scene->_kernelMessages.add(Common::Point(-18, 0), 0x1110, 34, 1, 150, subQuote2); + else if (_action._activeAction._verbId == 0x28A) + _scene->_kernelMessages.add(Common::Point(-10, 0), 0x1110, 34, 1, 150, subQuote2); + else + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 1, 150, subQuote2); + + _scene->_sequences.addTimer(170, 50); + } else { + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 1, 120, curQuote); + _scene->_sequences.addTimer(140, 50); + } + } else if (_game._trigger == 50) { + if (_hermitDialogNode == 1) + handleSubDialog1(); + else if (_hermitDialogNode == 2) + handleSubDialog2(); + } +} + +void Scene611::displayHermitQuestions(int question) { + _scene->_kernelMessages.reset(); + _hermitDisplayedQuestion = question; + + switch (question) { + case 1: { + Common::String curQuote = _game.getQuote(0x281); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x282); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 14), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 2: { + Common::String curQuote = _game.getQuote(0x283); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x284); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 14), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 3: { + Common::String curQuote = _game.getQuote(0x285); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 14), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 4: { + Common::String curQuote = _game.getQuote(0x286); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 14), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 5: { + Common::String curQuote = _game.getQuote(0x297); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y - 14), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x298); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x299); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 14), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 6: { + Common::String curQuote = _game.getQuote(0x29A); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x29B); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 14), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 7: { + Common::String curQuote = _game.getQuote(0x2A0); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2A1); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 8: { + Common::String curQuote = _game.getQuote(0x2A2); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2A3); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2A4); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 9: { + Common::String curQuote = _game.getQuote(0x2A5); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2A6); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 10: { + Common::String curQuote = _game.getQuote(0x2A8); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2A9); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2AA); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 11: { + Common::String curQuote = _game.getQuote(0x2AB); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 17), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2AC); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2AD); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2AE); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 12: { + Common::String curQuote = _game.getQuote(0x2AF); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 17), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2B0); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2B1); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2B2); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 13: { + Common::String curQuote = _game.getQuote(0x2B3); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 3), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2B4); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 17), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2B5); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2B6); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + _scene->_kernelMessages.add(Common::Point(11, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x2B7)); + _scene->_kernelMessages.add(Common::Point(11, _defaultDialogPos.y + 73), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x2B8)); + _scene->_kernelMessages.add(Common::Point(11, _defaultDialogPos.y + 87), 0xFDFC, 0, 0, 9999999, _game.getQuote(0x2B9)); + } + break; + + case 14: { + Common::String curQuote = _game.getQuote(0x2BA); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 17), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2BB); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2BC); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2BD); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 15: { + Common::String curQuote = _game.getQuote(0x2BE); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 17), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2BF); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2C0); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2C1); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 16: { + Common::String curQuote = _game.getQuote(0x2C2); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 3), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2C3); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 17), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2C4); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2C5); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2C6); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 17: { + Common::String curQuote = _game.getQuote(0x2C7); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 17), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2C8); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2C0); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2CA); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 18: { + Common::String curQuote = _game.getQuote(0x2CB); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2CC); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2CD); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 19: { + Common::String curQuote = _game.getQuote(0x2CE); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2CF); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2D0); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 20: { + Common::String curQuote = _game.getQuote(0x2E1); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 3), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2E2); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 17), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2E3); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2E4); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2E5); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 21: { + Common::String curQuote = _game.getQuote(0x2D3); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 3), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2D4); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 17), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2D5); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2D6); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 9999999, curQuote); + + curQuote = _game.getQuote(0x2D7); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 9999999, curQuote); + } + break; + + case 22: { + Common::String curQuote = _game.getQuote(0x2D8); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 17), 0xFDFC, 0, 0, 700, curQuote); + + curQuote = _game.getQuote(0x2D9); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 700, curQuote); + + curQuote = _game.getQuote(0x2DA); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 700, curQuote); + + curQuote = _game.getQuote(0x2DB); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 700, curQuote); + } + break; + + case 23: { + Common::String curQuote = _game.getQuote(0x2DC); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 3), 0xFDFC, 0, 0, 700, curQuote); + + curQuote = _game.getQuote(0x2DD); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 17), 0xFDFC, 0, 0, 700, curQuote); + + curQuote = _game.getQuote(0x2DE); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 31), 0xFDFC, 0, 0, 700, curQuote); + + curQuote = _game.getQuote(0x2DF); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 45), 0xFDFC, 0, 0, 700, curQuote); + + curQuote = _game.getQuote(0x2E0); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 59), 0xFDFC, 0, 0, 700, curQuote); + } + break; + + default: + break; + } +} + +void Scene611::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*RXMRC_9"); + + _game.loadQuoteSet(0x279, 0x27A, 0x27B, 0x27C, 0x27D, 0x27E, 0x27F, 0x280, 0x281, 0x282, 0x283, 0x284, + 0x285, 0x286, 0x287, 0x288, 0x289, 0x28A, 0x28B, 0x28C, 0x28D, 0x28E, 0x28F, 0x290, 0x291, 0x292, + 0x293, 0x294, 0x295, 0x296, 0x297, 0x298, 0x299, 0x29A, 0x29B, 0x29C, 0x29D, 0x29E, 0x29F, 0x2A0, + 0x2A1, 0x2A2, 0x2A3, 0x2A4, 0x2A5, 0x2A6, 0x2A7, 0x2A8, 0x2A9, 0x2AA, 0x2AB, 0x2AC, 0x2AD, 0x2AE, + 0x2AF, 0x2B0, 0x2B1, 0x2B2, 0x2B3, 0x2B4, 0x2B5, 0x2B6, 0x2B7, 0x2B8, 0x2B9, 0x2BA, 0x2BB, 0x2BC, + 0x2BD, 0x2BE, 0x2BF, 0x2C0, 0x2C1, 0x2C2, 0x2C3, 0x2C4, 0x2C5, 0x2C6, 0x2C7, 0x2C8, 0x2C9, 0x2CA, + 0x2CB, 0x2CC, 0x2CD, 0x2CE, 0x2CF, 0x2D0, 0x2D1, 0x2D2, 0x2D3, 0x2D4, 0x2D5, 0x2D6, 0x2D7, 0x2D8, + 0x2D9, 0x2DA, 0x2DB, 0x2DC, 0x2DD, 0x2DE, 0x2DF, 0x2E0, 0x2E1, 0x2E2, 0x2E3, 0x2E4, 0x2E5, 0x2E6, + 0x323, 0x324, 0); + + _dialog1.setup(0x82, 0x287, 0x288, 0x289, 0x28A, 0x28B, 0x28C, 0x28D, 0x28E, 0x28F, 0x290, + 0x291, 0x292, 0x293, 0x294, 0x295, 0x296, 0); + + _dialog2.setup(0x83, 0x29C, 0x29D, 0x29E, 0x29F, 0); + + if (!_game._visitedScenes._sceneRevisited) { + _dialog1.set(0x82, 0x287, 0x288, 0x296, 0); + _dialog2.set(0x83, 0x29F, 0); + } + + _vm->_palette->setEntry(252, 51, 51, 47); + _vm->_palette->setEntry(253, 37, 37, 37); + + _ratPresentFl = false; + _seenRatFl = true; + _eyesRunningFl = false; + _shouldRemoveEyes = false; + _randVal = 0; + _defaultDialogPos = Common::Point(264, 43); + _giveBatteriesFl = false; + _resetBatterieText = false; + _alreadyTalkingFl = false; + _startTradingFl = false; + + if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(22, 132); + _game._player._facing = FACING_EAST; + _duringDialogFl = false; + } + + if (!_globals[kHasTalkedToHermit]) { + _scene->loadAnimation(Resources::formatName(611, 'h', -1, EXT_AA, ""), 0); + _scene->loadAnimation(Resources::formatName(203, 'a', -1, EXT_AA, ""), 81); + _nextFrame = 47; + _hermitMode = 1; + _hermitTalkingFl = false; + _hermitMovingFl = true; + _check1Fl = true; + _stickFingerFl = false; + } else { + _hermitMode = 0; + _scene->_hotspots.activate(NOUN_HERMIT, false); + } + + // CHECKME: The last line of the block looks extremely useless + if (_globals[kExecuted_1_11]) { + _dialog1.write(0x294, true); + _dialog1.write(0x292, false); + _globals[kExecuted_1_11] = true; + } + + if (_duringDialogFl) { + _game._player._playerPos = Common::Point(237, 129); + _game._player._facing = FACING_NORTHEAST; + + switch (_hermitDialogNode) { + case 0: + _scene->_userInterface.setup(kInputBuildingSentences); + _hermitDialogNode = 1; + break; + + case 1: + _dialog1.start(); + break; + + case 2: + _dialog2.start(); + break; + + default: + break; + } + displayHermitQuestions(_hermitDisplayedQuestion); + } + + sceneEntrySound(); +} + +void Scene611::step() { + if (_seenRatFl && (_vm->getRandomNumber(1, 100) == 10)) { + _seenRatFl = false; + _scene->_sequences.addTimer(1, 80); + } + + if (_game._trigger == 80) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 1, 8); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _ratPresentFl = true; + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 81); + } else if (_game._trigger == 81) { + int syncId = _globals._sequenceIndexes[1]; + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 20, 0, 0, 0); + int idx = _scene->_dynamicHotspots.add(NOUN_RAT, VERB_WALKTO, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _ratHotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(272, 154), FACING_SOUTHEAST); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 9, 10); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[1], syncId); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + _ratTimer = _game._player._priorTimer; + } + + if (_ratPresentFl && ((_game._player._priorTimer - _ratTimer) > 1200)) + handleRatMoves(); + + if (!_eyesRunningFl) { + _randVal = _vm->getRandomNumber(1, 30); + _eyesRunningFl = true; + _scene->_sequences.addTimer(1, 70); + } + + if (_game._trigger == 70) { + switch (_randVal) { + case 2: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _shouldRemoveEyes = true; + _scene->_sequences.addTimer(60, 71); + break; + + case 6: + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 12, 3, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 2, 4); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + break; + + case 7: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _shouldRemoveEyes = true; + _scene->_sequences.addTimer(60, 71); + break; + + case 9: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _shouldRemoveEyes = true; + _scene->_sequences.addTimer(60, 71); + break; + + case 13: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 7); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _shouldRemoveEyes = true; + _scene->_sequences.addTimer(60, 71); + break; + + case 14: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 8); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _shouldRemoveEyes = true; + _scene->_sequences.addTimer(60, 71); + break; + + case 15: + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 24, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 5, 8); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + break; + + case 17: + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 20, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 9, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + break; + + case 21: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 9); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _shouldRemoveEyes = true; + _scene->_sequences.addTimer(60, 71); + break; + + case 25: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 10); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _shouldRemoveEyes = true; + _scene->_sequences.addTimer(60, 71); + break; + + case 27: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 11); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _shouldRemoveEyes = true; + _scene->_sequences.addTimer(60, 71); + break; + + case 29: + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 20, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + break; + + default: + _scene->_sequences.addTimer(1, 71); + break; + } + } + + if (_game._trigger == 71) { + if (_shouldRemoveEyes) { + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _shouldRemoveEyes = false; + } + _eyesRunningFl = false; + _randVal = 0; + } + + if (_game._trigger == 100) { + if (_alreadyTalkingFl) + _alreadyTalkingFl = false; + else + _hermitMovingFl = true; + } + + if (_stickFingerFl && (_scene->_activeAnimation->getCurrentFrame() == 47)) { + _stickFingerFl = false; + _hermitMovingFl = true; + _hermitMode = 1; + } + + if ((_scene->_activeAnimation->getCurrentFrame() == 240) && _check1Fl) { + _check1Fl = false; + _scene->_kernelMessages.add(Common::Point(33, 88), 0xFDFC, 0, 0, 90, _game.getQuote(0x27E)); + _scene->_sequences.addTimer(120, 120); + } + + if (_game._trigger == 120) { + int msgIdx = _scene->_kernelMessages.add(Common::Point(28, 102), 0xFDFC, 0, 0, 90, _game.getQuote(0x27F)); + _scene->_kernelMessages.setQuoted(msgIdx, 4, true); + _scene->_sequences.addTimer(100, 121); + } + + if (_game._trigger == 121) { + int msgIdx = _scene->_kernelMessages.add(Common::Point(23, 116), 0xFDFC, 0, 0, 90, _game.getQuote(0x280)); + _scene->_kernelMessages.setQuoted(msgIdx, 4, true); + } + + if (_hermitMode == 1) { + if (_startTradingFl) { + _hermitMode = 6; + _hermitMovingFl = false; + _hermitTalkingFl = false; + _scene->_sequences.addTimer(1, 110); + } else if (_hermitTalkingFl) { + _hermitMode = 2; + _nextFrame = 18; + _hermitMovingFl = false; + } else { + switch (_vm->getRandomNumber(1, 5)) { + case 1: + _nextFrame = 46; + break; + + case 2: + _nextFrame = 47; + break; + + case 3: + _nextFrame = 48; + break; + + case 4: + _nextFrame = 49; + break; + + case 5: + _nextFrame = 50; + break; + + default: + break; + } + } + } + + if (_hermitMode == 2) { + if (_startTradingFl) { + _hermitMode = 6; + _hermitMovingFl = false; + _hermitTalkingFl = false; + _scene->_sequences.addTimer(1, 110); + } else if (_hermitMovingFl) { + _hermitMode = 1; + _nextFrame = 47; + _hermitTalkingFl = false; + } else { + switch (_vm->getRandomNumber(1, 4)) { + case 1: + _nextFrame = 18; + break; + + case 2: + _nextFrame = 20; + break; + + case 3: + _nextFrame = 22; + break; + + case 4: + _nextFrame = 24; + break; + + default: + break; + } + } + } + + if (_scene->_activeAnimation->getCurrentFrame() == 254) + _game._player._stepEnabled = true; + + if (_game._trigger == 110) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 111); + } + + if (_game._trigger == 111) { + int syncIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx); + _nextFrame = 1; + } + + if (_game._trigger == 112) { + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _game._player._visible = true; + } + + if (_hermitMode == 6) { + if ((_scene->_activeAnimation->getCurrentFrame() == 9) && _check1Fl) { + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 112); + _check1Fl = false; + } + + if ((_scene->_activeAnimation->getCurrentFrame() == 17) && !_check1Fl) { + _nextFrame = 26; + _hermitMode = 4; + _check1Fl = true; + } + } + + if (_hermitMode == 4) { + if ((_scene->_activeAnimation->getCurrentFrame() == 33) && _check1Fl) { + displayHermitQuestions(_hermitDisplayedQuestion); + _nextFrame = 1; + _check1Fl = false; + } + + if ((_scene->_activeAnimation->getCurrentFrame() == 9) && !_check1Fl) { + _nextFrame = 8; + _scene->_sequences.addTimer(1, 113); + _check1Fl = true; + } + } + + if (_game._trigger == 113) { + _game._player._visible = false; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 114); + } + + if (_game._trigger == 114) { + _resetBatterieText = true; + int syncIdx = _globals._sequenceIndexes[3]; + _nextFrame = 10; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 2); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 115); + } + + if ((_nextFrame >= 0) && (_nextFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(_nextFrame); + _nextFrame = -1; + } + + if (_game._trigger == 115) { + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _game._player._visible = true; + if (_hermitDisplayedQuestion == 21) { + _game._player._stepEnabled = false; + handleTrading(); + _hermitMode = 0; + _startTradingFl = false; + _nextFrame = 52; + _globals[kHasTalkedToHermit] = true; + _scene->_hotspots.activate(NOUN_HERMIT, false); + } else { + _game._player._stepEnabled = true; + _hermitMode = 1; + _nextFrame = 47; + _hermitTalkingFl = false; + _startTradingFl = false; + _check1Fl = true; + } + } +} + +void Scene611::preActions() { + if (_action.isAction(VERB_WALK_DOWN, NOUN_ALLEY)) + _game._player._walkOffScreenSceneId = 609; + + if (_resetBatterieText) + _scene->_kernelMessages.reset(); +} + +void Scene611::actions() { + if (_game._screenObjects._inputMode == 1) + handleDialog(); + else if ((_action.isAction(VERB_GIVE, NOUN_PHONE_CELLS, 0x45A)) || (_action.isAction(VERB_GIVE, NOUN_DURAFAIL_CELLS, 0x45A))) { + _action._activeAction._verbId = 0x294; + _giveBatteriesFl = true; + handleSubDialog1(); + } else if (_action.isAction(VERB_GIVE, NOUN_HERMIT)) { + _scene->_kernelMessages.reset(); + + Common::String curQuote = _game.getQuote(0x323); + int width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + int quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y), 0xFDFC, 0, 0, 120, curQuote); + + curQuote = _game.getQuote(0x324); + width = _vm->_font->getWidth(curQuote, _scene->_textSpacing); + quotePosX = _defaultDialogPos.x - (width / 2); + _scene->_kernelMessages.add(Common::Point(quotePosX, _defaultDialogPos.y + 14), 0xFDFC, 0, 0, 120, curQuote); + } else if (_game._trigger == 90) { + if (_dialog2.read(0x29C) && _dialog2.read(0x29D) && _dialog2.read(0x29E)) { + handleTalking(180); + if (_vm->getRandomNumber(1, 2) == 1) + displayHermitQuestions(1); + else + displayHermitQuestions(2); + } else { + handleTalking(180); + if (_vm->getRandomNumber(1, 2) == 1) + displayHermitQuestions(3); + else + displayHermitQuestions(4); + } + + _duringDialogFl = true; + if (_dialog2.read(0x29F)) { + _hermitDialogNode = 1; + _dialog1.start(); + _duringDialogFl = true; + } else { + _hermitDialogNode = 2; + _dialog2.write(0x29F, true); + _dialog2.start(); + _duringDialogFl = true; + } + } else if (_action.isAction(VERB_TALKTO, NOUN_HERMIT)) { + if (!_dialog1.read(0x287)) { + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x27A)); + _scene->_sequences.addTimer(120, 90); + } else { + int nextQuote = 0; + switch (_vm->getRandomNumber(1, 3)) { + case 1: + nextQuote = 0x27B; + break; + + case 2: + nextQuote = 0x27C; + break; + + case 3: + nextQuote = 0x27D; + break; + } + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(nextQuote)); + _scene->_sequences.addTimer(120, 90); + } + } else if ((_action.isAction(VERB_WALKTO) || _action.isAction(VERB_LOOK)) && _action.isAction(0x275)) { + switch (_game._trigger) { + case 0: + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x279)); + _scene->_sequences.addTimer(60, 1); + break; + + case 1: + handleRatMoves(); + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action._lookFlag) { + if (_globals[kHasTalkedToHermit]) + _vm->_dialogs->show(61111); + else + _vm->_dialogs->show(61110); + } else if (_action.isAction(VERB_LOOK, NOUN_HERMIT)) + _vm->_dialogs->show(61112); + else if (_action.isAction(VERB_LOOK, NOUN_TRASH)) + _vm->_dialogs->show(61113); + else if (_action.isAction(VERB_TAKE, NOUN_TRASH)) + _vm->_dialogs->show(61114); + else if (_action.isAction(VERB_LOOK, NOUN_CARDBOARD_BOX)) + _vm->_dialogs->show(61115); + else if (_action.isAction(VERB_TAKE, NOUN_CARDBOARD_BOX)) + _vm->_dialogs->show(61116); + else if (_action.isAction(VERB_OPEN, NOUN_CARDBOARD_BOX)) + _vm->_dialogs->show(61117); + else if (_action.isAction(VERB_LOOK, NOUN_REFRIGERATOR)) + _vm->_dialogs->show(61118); + else if (_action.isAction(VERB_OPEN, NOUN_REFRIGERATOR)) + _vm->_dialogs->show(61119); + else if (_action.isAction(VERB_TAKE, NOUN_REFRIGERATOR)) + _vm->_dialogs->show(61120); + else if (_action.isAction(VERB_LOOK, NOUN_BUILDING)) + _vm->_dialogs->show(61121); + else if (_action.isAction(VERB_LOOK, NOUN_GRAFFITI)) + _vm->_dialogs->show(61122); + else if (_action.isAction(VERB_LOOK, NOUN_METAL_PIPE)) + _vm->_dialogs->show(61123); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene612::Scene612(MADSEngine *vm) : Scene6xx(vm) { + _actionMode = -1; + _cycleIndex = -1; +} + +void Scene612::synchronize(Common::Serializer &s) { + Scene6xx::synchronize(s); + + s.syncAsSint16LE(_actionMode); + s.syncAsSint16LE(_cycleIndex); +} + +void Scene612::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_FISHING_LINE); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene612::handleWinchMovement() { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 10, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 1, 5); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[4]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_SPRITE, 5, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + // CHECKME: Is the "else" block useful as action is always equal to 1 at this point? + // Or is it a missing bit of code we could fix? + if (_actionMode == 1) { + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 17, 7, 0, 0); + _vm->_sound->command(19); + _game._objects.setRoom(OBJ_PADLOCK_KEY, 1); + _globals[kBoatRaised] = false; + } else { + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 17, 9, 0, 0); + _vm->_sound->command(18); + } + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[4]); + _game._player._visible = true; + break; + + case 3: { + int syncIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, _cycleIndex); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], syncIdx); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x2F4)); + _game._player._stepEnabled = true; + + _vm->_dialogs->show(61217); + } + break; + + default: + break; + } +} + +void Scene612::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('c', -1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('p', -1)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*RXCD_3"); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*RXRC_6"); + + if ((_globals[kLineStatus] == 2) || (_globals[kLineStatus] == 3)) { + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('f', -1)); + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 1); + int idx = _scene->_dynamicHotspots.add(NOUN_FISHING_LINE, VERB_WALKTO, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(34, 117), FACING_SOUTHEAST); + } + + if (_globals[kBoatRaised]) + _cycleIndex = -2; + else + _cycleIndex = -1; + + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, _cycleIndex); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 1); + + if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(280, 75); + _game._player._facing = FACING_SOUTHWEST; + _game._player._visible = false; + _game._player._stepEnabled = false; + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 3); + _scene->loadAnimation(formAnimName('R', 1), 70); + } + + sceneEntrySound(); + + if (_scene->_roomChanged) + _game._objects.addToInventory(OBJ_PADLOCK_KEY); + + _game.loadQuoteSet(0x2F5, 0x2F4, 0); +} + +void Scene612::step() { + switch (_game._trigger) { + case 70: + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + _scene->_sequences.addTimer(6, 71); + break; + + case 71: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 72); + break; + + case 72: + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 2); + _game._player._stepEnabled = true; + break; + + default: + break; + } +} + +void Scene612::actions() { + if (_action.isAction(0x325, 0x324)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[1]; + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 3); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[1], syncIdx); + _scene->_sequences.addTimer(6, 2); + } + break; + + case 2: + _game._player._visible = false; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], true, 10, 1, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: { + int syncIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], true, -2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx); + _scene->_nextSceneId = 504; + } + break; + + default: + break; + } + } else if (_action.isAction(VERB_UNLOCK, 0xFF, 0x45F)) { + _cycleIndex = -2; + _actionMode = 1; + handleWinchMovement(); + } else if (_action._lookFlag || _action.isAction(VERB_LOOK, NOUN_EXPRESSWAY)) + _vm->_dialogs->show(61210); + else if (_action.isAction(VERB_LOOK, NOUN_ROPE) || _action.isAction(VERB_LOOK, NOUN_ARMATURE)) { + if (_globals[kBoatRaised]) + _vm->_dialogs->show(61211); + else + _vm->_dialogs->show(61212); + } else if (_action.isAction(VERB_TAKE, NOUN_ROPE)) + _vm->_dialogs->show(61213); + else if (_action.isAction(VERB_LOOK, NOUN_CONTROL_BOX)) { + if (_globals[kBoatRaised]) + _vm->_dialogs->show(61214); + else + _vm->_dialogs->show(61216); + } else if (_action.isAction(VERB_OPEN, NOUN_CONTROL_BOX)) + _vm->_dialogs->show(61215); + else if (_action.isAction(VERB_LOOK, NOUN_BUILDINGS)) + _vm->_dialogs->show(61218); + else if (_action.isAction(VERB_LOOK, NOUN_DOME)) + _vm->_dialogs->show(61219); + else if (_action.isAction(VERB_LOOK, NOUN_STATUE)) + _vm->_dialogs->show(61220); + else if (_action.isAction(VERB_LOOK, NOUN_MAINTENANCE_BUILDING)) + _vm->_dialogs->show(61221); + else if (_action.isAction(VERB_OPEN, NOUN_MAINTENANCE_BUILDING)) + _vm->_dialogs->show(61222); + else if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(61223); + else if (_action.isAction(VERB_LOOK, NOUN_SUPPORT)) + _vm->_dialogs->show(61224); + else if (_action.isAction(VERB_WALK_DOWN, NOUN_EXPRESSWAY_TO_EAST) || _action.isAction(VERB_WALK_DOWN, NOUN_EXPRESSWAY_TO_WEST)) + _vm->_dialogs->show(61225); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene620::setup() { + _game._player._spritesPrefix = ""; + setAAName(); +} + +void Scene620::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('b', 0)); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->_sequences.addTimer(30, 70); + _scene->_userInterface.setup(kInputLimitedSentences); + sceneEntrySound(); +} + +void Scene620::step() { + switch (_game._trigger) { + case 70: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->loadAnimation(formAnimName('E', -1), 71); + break; + + case 71: + if (_scene->_priorSceneId == 751) { + _globals[kCityFlooded] = true; + _globals[kTeleporterRoom + 5] = 0; + _scene->_nextSceneId = 701; + } else if (_scene->_priorSceneId == 752) { + _globals[kCityFlooded] = true; + _globals[kTeleporterRoom + 5] = 0; + _scene->_nextSceneId = 702; + } else if (_scene->_priorSceneId < 501 || _scene->_priorSceneId > 752) { + _globals[kCityFlooded] = true; + _globals[kTeleporterRoom + 5] = 0; + _scene->_nextSceneId = _scene->_priorSceneId; + } else if (_scene->_priorSceneId >= 501 && _scene->_priorSceneId <= 612) { + _globals[kResurrectRoom] = _globals[kHoverCarLocation]; + _game._objects.addToInventory(OBJ_TIMEBOMB); + _globals[kTimebombStatus] = 0; + _globals[kTimebombTimer] = 0; + _scene->_nextSceneId = 605; + } + _game._player._stepEnabled = true; + break; + + default: + break; + } +} + +/*------------------------------------------------------------------------*/ + +} // End of namespace Nebular +} // End of namespace MADS diff --git a/engines/mads/nebular/nebular_scenes6.h b/engines/mads/nebular/nebular_scenes6.h new file mode 100644 index 0000000000..74467858bd --- /dev/null +++ b/engines/mads/nebular/nebular_scenes6.h @@ -0,0 +1,322 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_NEBULAR_SCENES6_H +#define MADS_NEBULAR_SCENES6_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" + +namespace MADS { + +namespace Nebular { + +class Scene6xx : public NebularScene { +protected: + /** + * Plays an appropriate sound when entering a scene + */ + void setAAName(); + + /** + * Updates the prefix used for getting player sprites for the scene + */ + void setPlayerSpritesPrefix(); + + void sceneEntrySound(); + +public: + Scene6xx(MADSEngine *vm) : NebularScene(vm) {} +}; + +class Scene601: public Scene6xx{ +public: + Scene601(MADSEngine *vm) : Scene6xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene602: public Scene6xx{ +private: + int _lastSpriteIdx; + int _lastSequenceIdx; + int _cycleIndex; + int _safeMode; + + void handleSafeActions(); + +public: + Scene602(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +class Scene603: public Scene6xx{ +private: + int _compactCaseHotspotId; + int _noteHotspotId; + +public: + Scene603(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +class Scene604: public Scene6xx{ +private: + int _timebombHotspotId; + int _bombMode; + int _monsterFrame; + + uint32 _monsterTimer; + + bool _monsterActive; + bool _animationActiveFl; + + void handleBombActions(); + +public: + Scene604(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene605: public Scene6xx{ +public: + Scene605(MADSEngine *vm) : Scene6xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene607: public Scene6xx{ +private: + uint32 _dogTimer; + uint32 _lastFrameTime; + + bool _dogLoop; + bool _dogEatsRex; + bool _dogBarking; + bool _shopAvailable; + + int _animationMode; + int _animationActive; + int _counter; + + void handleThrowingBone(); + +public: + Scene607(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene608: public Scene6xx{ +private: + int _carMode; + int _carFrame; + int _carMoveMode; + int _dogDeathMode; + int _carHotspotId; + int _barkCount; + int _polycementHotspotId; + int _animationMode; + int _nextTrigger; + int _throwMode; + + bool _resetPositionsFl; + bool _dogActiveFl; + bool _dogBarkingFl; + bool _dogFirstEncounter; + bool _rexBeingEaten; + bool _dogHitWindow; + bool _checkFl; + bool _dogSquashFl; + bool _dogSafeFl; + bool _buttonPressedonTimeFl; + bool _dogUnderCar; + bool _dogYelping; + + long _dogWindowTimer; + long _dogRunTimer; + + uint32 _dogTimer1; + uint32 _dogTimer2; + + void resetDogVariables(); + void restoreAnimations(); + void setCarAnimations(); + void handleThrowingBone(); + +public: + Scene608(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene609: public Scene6xx{ +private: + int _videoDoorMode; + + void enterStore(); + +public: + Scene609(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene610: public Scene6xx{ +private: + int _handsetHotspotId; + int _checkVal; + + bool _cellCharging; + + long _cellChargingTimer; + uint32 _lastFrameTimer; + +public: + Scene610(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene611: public Scene6xx{ +private: + bool _seenRatFl; + bool _eyesRunningFl; + bool _shouldRemoveEyes; + bool _ratPresentFl; + bool _duringDialogFl; + bool _resetBatterieText; + bool _hermitTalkingFl; + bool _hermitMovingFl; + bool _alreadyTalkingFl; + bool _giveBatteriesFl; + bool _startTradingFl; + bool _check1Fl; + bool _stickFingerFl; + + int _randVal; + int _ratHotspotId; + int _hermitDialogNode; + int _hermitDisplayedQuestion; + int _nextFrame; + int _hermitMode; + + uint32 _ratTimer; + + Conversation _dialog1; + Conversation _dialog2; + + Common::Point _defaultDialogPos; + + void handleTrading(); + void handleRatMoves(); + void handleDialog(); + void handleSubDialog1(); + void handleSubDialog2(); + void handleTalking(int delay); + void setDialogNode(int node); + void displayHermitQuestions(int question); + + bool check2ChargedBatteries(); + bool check4ChargedBatteries(); + +public: + Scene611(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene612: public Scene6xx{ +private: + int _actionMode; + int _cycleIndex; + + void handleWinchMovement(); + +public: + Scene612(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene620: public Scene6xx{ +public: + Scene620(MADSEngine *vm) : Scene6xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions() {}; +}; +} // End of namespace Nebular +} // End of namespace MADS + +#endif /* MADS_NEBULAR_SCENES6_H */ diff --git a/engines/mads/nebular/nebular_scenes7.cpp b/engines/mads/nebular/nebular_scenes7.cpp new file mode 100644 index 0000000000..08b85bfbd4 --- /dev/null +++ b/engines/mads/nebular/nebular_scenes7.cpp @@ -0,0 +1,2678 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" +#include "mads/nebular/nebular_scenes7.h" + +namespace MADS { + +namespace Nebular { + +void Scene7xx::setAAName() { + _game._aaName = Resources::formatAAName(5); +} + +void Scene7xx::setPlayerSpritesPrefix() { + _vm->_sound->command(5); + + Common::String oldName = _game._player._spritesPrefix; + + if ((_scene->_nextSceneId == 703) || (_scene->_nextSceneId == 704) || (_scene->_nextSceneId == 705) + || (_scene->_nextSceneId == 707) || (_scene->_nextSceneId == 710) || (_scene->_nextSceneId == 711)) + _game._player._spritesPrefix = ""; + else if (_globals[kSexOfRex] == REX_MALE) + _game._player._spritesPrefix = "RXM"; + else + _game._player._spritesPrefix = "ROX"; + + _game._player._scalingVelocity = true; + + if (oldName != _game._player._spritesPrefix) + _game._player._spritesChanged = true; + + _vm->_palette->setEntry(16, 10, 63, 63); + _vm->_palette->setEntry(17, 10, 45, 45); +} + +void Scene7xx::sceneEntrySound() { + if (!_vm->_musicFlag) { + _vm->_sound->command(2); + return; + } + + switch (_scene->_nextSceneId) { + case 701: + case 702: + case 704: + case 705: + case 751: + _vm->_sound->command(38); + break; + case 703: + if (_globals[kMonsterAlive] == 0) + _vm->_sound->command(24); + else + _vm->_sound->command(27); + break; + case 706: + case 707: + case 710: + case 711: + _vm->_sound->command(25); + break; + default: + break; + } +} + +/*------------------------------------------------------------------------*/ + +Scene701::Scene701(MADSEngine *vm) : Scene7xx(vm) { + _fishingLineId = -1; +} + +void Scene701::synchronize(Common::Serializer &s) { + Scene7xx::synchronize(s); + + s.syncAsSint16LE(_fishingLineId); +} + +void Scene701::setup() { + setPlayerSpritesPrefix(); + setAAName(); + + _scene->addActiveVocab(NOUN_BOAT); + _scene->addActiveVocab(VERB_CLIMB_INTO); + _scene->addActiveVocab(NOUN_FISHING_LINE); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene701::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('b', 5)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('b', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('b', 1)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites("*RM202A1"); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('b', 8)); + + if (_scene->_roomChanged) { + _game._objects.addToInventory(OBJ_BINOCULARS); + _game._objects.addToInventory(OBJ_TWINKIFRUIT); + _game._objects.addToInventory(OBJ_BOMB); + _game._objects.addToInventory(OBJ_CHICKEN); + _game._objects.addToInventory(OBJ_BONES); + + _globals[kCityFlooded] = true; + _globals[kLineStatus] = LINE_TIED; + _globals[kBoatRaised] = false; + } + + if (_globals[kBoatStatus] == BOAT_UNFLOODED) { + if (_globals[kBoatRaised]) + _globals[kBoatStatus] = BOAT_GONE; + else if (_globals[kLineStatus] == LINE_TIED) + _globals[kBoatStatus] = BOAT_TIED_FLOATING; + else if (_game._difficulty == DIFFICULTY_HARD) + _globals[kBoatStatus] = BOAT_ADRIFT; + else + _globals[kBoatStatus] = BOAT_TIED; + } + + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + + int boatStatus = (_scene->_priorSceneId == 703) ? BOAT_GONE : _globals[kBoatStatus]; + + switch (boatStatus) { + case BOAT_TIED_FLOATING: + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 20, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 10); + break; + case BOAT_ADRIFT: + _globals._sequenceIndexes[6] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[6], false, 20, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 10); + break; + case BOAT_TIED: + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 9); + break; + case BOAT_GONE: + _scene->_hotspots.activate(NOUN_BOAT, false); + break; + default: + break; + } + + if (_globals[kLineStatus] == LINE_DROPPED || _globals[kLineStatus] == LINE_TIED) { + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 8); + int idx = _scene->_dynamicHotspots.add(NOUN_FISHING_LINE, VERB_WALKTO, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _fishingLineId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(234, 129), FACING_NORTHEAST); + } + + if (_scene->_priorSceneId == 702) { + _game._player._playerPos = Common::Point(309, 138); + _game._player._facing = FACING_WEST; + } else if (_scene->_priorSceneId == 710) { + _game._player._playerPos = Common::Point(154, 129); + _game._player._facing = FACING_NORTH; + _game._player._visible = false; + _game._player._stepEnabled = false; + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[5], Common::Point(155, 129)); + _scene->_sequences.addTimer(15, 60); + } else if (_scene->_priorSceneId == 703) { + _game._player._playerPos = Common::Point(231, 127); + _game._player._facing = FACING_SOUTH; + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->loadAnimation(formAnimName('B', 1), 80); + _vm->_sound->command(28); + } else if (_scene->_priorSceneId != -2 && _scene->_priorSceneId != 620) { + _game._player._playerPos = Common::Point(22, 131); + _game._player._facing = FACING_EAST; + _game._player._stepEnabled = false; + _scene->_sequences.addTimer(60, 70); + } + + _game.loadQuoteSet(0x310, 0x30F, 0); + sceneEntrySound(); +} + +void Scene701::step() { + switch(_game._trigger) { + case 60: + _scene->_sequences.remove(_globals._sequenceIndexes[5]); + _globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], false, 6, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[5], Common::Point(155, 129)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 61); + break; + + case 61: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[5]); + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + case 70: + _vm->_sound->command(16); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + break; + + case 71: + _game._player.walk(Common::Point(61, 131), FACING_EAST); + _scene->_sequences.addTimer(120, 72); + break; + + case 72: + _vm->_sound->command(17); + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 73); + break; + + case 73: + _game._player._stepEnabled = true; + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _scene->_kernelMessages.reset(); + break; + + case 80: { + _game._player._visible = true; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 9); + int idx = _scene->_dynamicHotspots.add(NOUN_BOAT, VERB_CLIMB_INTO, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(234, 129), FACING_NORTH); + _globals[kBoatStatus] = BOAT_TIED; + _game._player._stepEnabled = true; + } + break; + + default: + break; + } +} + +void Scene701::preActions() { + if (_action.isAction(VERB_WALKTO, NOUN_EAST_END_OF_PLATFORM)) + _game._player._walkOffScreenSceneId = 702; + + if (_action.isAction(VERB_LOOK, NOUN_BUILDING)) + _game._player.walk(Common::Point(154, 129), FACING_NORTHEAST); + + if (_action.isAction(VERB_LOOK, NOUN_BINOCULARS, NOUN_BUILDING)) + _game._player.walk(Common::Point(154, 129), FACING_NORTH); +} + +void Scene701::actions() { + if (_action.isAction(VERB_WALK_ALONG, NOUN_PLATFORM)) + return; + + if (_action.isAction(VERB_LOOK, NOUN_BINOCULARS, NOUN_BUILDING) && _game._objects[OBJ_VASE]._roomNumber == 706) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 6, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[5], Common::Point(155, 129)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + int temp = _globals._sequenceIndexes[5]; + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, -2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[5], Common::Point(155, 129)); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[5], temp); + _scene->_sequences.addTimer(15, 2); + } + break; + + case 2: + _scene->_nextSceneId = 710; + break; + + default: + break; + } + } else if (_action.isAction(VERB_STEP_INTO, NOUN_ELEVATOR)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _vm->_sound->command(16); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x310, 34, 0, 120, _game.getQuote(0x30D)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: + _game._player.walk(Common::Point(22, 131), FACING_EAST); + _scene->_sequences.addTimer(120, 3); + break; + + case 3: + _vm->_sound->command(17); + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 4); + break; + + case 4: + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _globals[kResurrectRoom] = 701; + _scene->_nextSceneId = 605; + break; + + default: + break; + } + } else if ((_action.isAction(VERB_PULL, NOUN_BOAT) || _action.isAction(VERB_TAKE, NOUN_BOAT) || + _action.isAction(VERB_PULL, NOUN_FISHING_LINE) || _action.isAction(VERB_TAKE, NOUN_FISHING_LINE)) && + !_game._objects.isInInventory(OBJ_FISHING_LINE)) { + if (_globals[kBoatStatus] == BOAT_TIED_FLOATING) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _scene->_dynamicHotspots.remove(_fishingLineId); + _scene->_hotspots.activate(NOUN_BOAT, false); + _game._player._visible = false; + _scene->loadAnimation(formAnimName('E', -1), 1); + break; + + case 1: { + _game._player._visible = true; + _game._player._priorTimer = _scene->_activeAnimation->getNextFrameTimer() - _game._player._ticksAmount; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -1); + _scene->_sequences.setDepth (_globals._sequenceIndexes[2], 9); + int idx = _scene->_dynamicHotspots.add(NOUN_BOAT, VERB_CLIMB_INTO, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(231, 127), FACING_NORTH); + _scene->_sequences.addTimer(15, 2); + } + break; + + case 2: + _globals[kBoatStatus] = BOAT_TIED; + _globals[kLineStatus] = LINE_NOW_UNTIED; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_globals[kBoatStatus] == BOAT_TIED) { + _vm->_dialogs->show(70125); + } else if (_globals[kLineStatus] == LINE_DROPPED) { + _globals[kLineStatus] = LINE_NOW_UNTIED; + _game._objects.addToInventory(OBJ_FISHING_LINE); + _vm->_sound->command(15); + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _vm->_dialogs->showItem(OBJ_FISHING_LINE, 70126); + } else { + _vm->_dialogs->show(70127); + } + } else if (_action.isAction(VERB_CLIMB_INTO, NOUN_BOAT) && _globals[kBoatStatus] == BOAT_TIED) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _game._player._visible = false; + _scene->loadAnimation(formAnimName('B', 0), 1); + break; + + case 1: + _scene->_nextSceneId = 703; + break; + + default: + break; + } + } else if (_action._lookFlag) { + if (_globals[kBoatStatus] != BOAT_GONE) { + if (_globals[kBoatStatus] == BOAT_TIED) + _vm->_dialogs->show(70128); + else + _vm->_dialogs->show(70110); + } else + _vm->_dialogs->show(70111); + } else if (_action.isAction(VERB_LOOK, NOUN_SUBMERGED_CITY)) + _vm->_dialogs->show(70112); + else if (_action.isAction(VERB_LOOK, 0)) + _vm->_dialogs->show(70113); + else if (_action.isAction(VERB_LOOK, NOUN_PLATFORM)) + _vm->_dialogs->show(70114); + else if (_action.isAction(VERB_LOOK, NOUN_CEMENT_PYLON)) + _vm->_dialogs->show(70115); + else if (_action.isAction(VERB_LOOK, NOUN_HOOK)) { + if (_globals[kLineStatus] == LINE_NOT_DROPPED || _globals[kLineStatus] == LINE_NOW_UNTIED) + _vm->_dialogs->show(70116); + else + _vm->_dialogs->show(70117); + } else if (_action.isAction(VERB_LOOK, NOUN_ROCK)) + _vm->_dialogs->show(70118); + else if (_action.isAction(VERB_TAKE, NOUN_ROCK)) + _vm->_dialogs->show(70119); + else if (_action.isAction(VERB_LOOK, NOUN_EAST_END_OF_PLATFORM)) + _vm->_dialogs->show(70120); + else if (_action.isAction(VERB_LOOK, NOUN_BUILDING)) + _vm->_dialogs->show(70121); + else if (_action.isAction(VERB_LOOK, NOUN_BOAT)) { + if (_globals[kBoatStatus] == BOAT_ADRIFT || _globals[kBoatStatus] == BOAT_TIED_FLOATING) + _vm->_dialogs->show(70122); + else + _vm->_dialogs->show(70123); + } else if (_action.isAction(VERB_CAST, NOUN_FISHING_ROD, NOUN_BOAT) && _game._objects.isInInventory(OBJ_FISHING_LINE)) + _vm->_dialogs->show(70124); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene702::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene702::enter() { + _globals._spriteIndexes[12] = _scene->_sprites.addSprites("*RXMBD_8"); + + if (_scene->_priorSceneId == 701) { + _game._player._playerPos = Common::Point(13, 145); + _game._player._facing = FACING_EAST; + } else if (_scene->_priorSceneId != -2 && _scene->_priorSceneId != 620) { + _game._player._playerPos = Common::Point(289, 138); + _game._player.walk(Common::Point(262, 148), FACING_WEST); + _game._player._facing = FACING_WEST; + _game._player._visible = true; + } + + if (_game._globals[kTeleporterCommand]) { + switch(_game._globals[kTeleporterCommand]) { + case TELEPORTER_BEAM_OUT: + case TELEPORTER_WRONG: + case TELEPORTER_STEP_OUT: + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + default: + break; + } + + _game._globals[kTeleporterCommand] = TELEPORTER_NONE; + } + + sceneEntrySound(); +} + +void Scene702::preActions() { + if (_action.isAction(VERB_WALKTO, NOUN_WEST_END_OF_PLATFORM)) + _game._player._walkOffScreenSceneId = 701; +} + +void Scene702::actions() { + if (_action.isAction(VERB_WALK_ALONG, NOUN_PLATFORM)) + ; // Only set the action as finished + else if (_action.isAction(VERB_STEP_INTO, NOUN_TELEPORTER)) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->_nextSceneId = 711; + } else if (_action.isAction(VERB_TAKE, NOUN_BONES) && (_action._mainObjectSource == 4) && (!_game._objects.isInInventory(OBJ_BONES) || _game._trigger)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 5, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[12]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_SPRITE, 4, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + case 1: + _vm->_sound->command(0xF); + if (_game._objects.isInInventory(OBJ_BONE)) + _game._objects.setRoom(OBJ_BONE, 1); + _game._objects.addToInventory(OBJ_BONES); + _vm->_dialogs->show(OBJ_BONES, 70218); + break; + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[12]); + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + default: + break; + } + } else if (_action._lookFlag) + _vm->_dialogs->show(70210); + else if (_action.isAction(VERB_LOOK, NOUN_PLATFORM)) + _vm->_dialogs->show(70211); + else if (_action.isAction(VERB_LOOK, NOUN_CEMENT_BLOCK)) + _vm->_dialogs->show(70212); + else if (_action.isAction(VERB_LOOK, NOUN_ROCK)) + _vm->_dialogs->show(70213); + else if (_action.isAction(VERB_TAKE, NOUN_ROCK)) + _vm->_dialogs->show(70214); + else if (_action.isAction(VERB_LOOK, NOUN_WEST_END_OF_PLATFORM)) + _vm->_dialogs->show(70215); + else if (_action.isAction(VERB_LOOK, NOUN_TELEPORTER)) + _vm->_dialogs->show(70216); + else if (_action.isAction(VERB_LOOK, NOUN_BONES) && (_action._mainObjectSource == 4)) + _vm->_dialogs->show(70217); + else if (_action.isAction(VERB_TAKE, NOUN_BONES) && (_action._mainObjectSource == 4)) { + if (_game._objects.isInInventory(OBJ_BONES)) + _vm->_dialogs->show(70219); + } else if (_action.isAction(VERB_LOOK, NOUN_SUBMERGED_CITY)) + _vm->_dialogs->show(70220); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene703::Scene703(MADSEngine *vm) : Scene7xx(vm) { + _monsterMode = -1; + _boatFrame = -1; + _curSequence = -1; + _boatDir = -1; + + _useBomb = false; + _startMonsterTimer = false; + _rexDeathFl = false; + _restartTrigger70Fl = false; + + _lastFrameTime = 0; + _monsterTime = 0; +} + +void Scene703::synchronize(Common::Serializer &s) { + Scene7xx::synchronize(s); + + s.syncAsSint16LE(_monsterMode); + s.syncAsSint16LE(_boatFrame); + s.syncAsSint16LE(_curSequence); + s.syncAsSint16LE(_boatDir); + + s.syncAsByte(_useBomb); + s.syncAsByte(_startMonsterTimer); + s.syncAsByte(_rexDeathFl); + s.syncAsByte(_restartTrigger70Fl); + + s.syncAsUint32LE(_lastFrameTime); + s.syncAsUint32LE(_monsterTime); +} + +void Scene703::setup() { + _game._player._spritesPrefix = ""; + setAAName(); +} + +void Scene703::handleBottleInterface() { + switch (_globals[kBottleStatus]) { + case 0: + _dialog1.write(0x311, true); + _dialog1.write(0x312, true); + _dialog1.write(0x313, true); + _dialog1.write(0x314, true); + _dialog1.write(0x315, true); + break; + + case 1: + _dialog1.write(0x311, false); + _dialog1.write(0x312, true); + _dialog1.write(0x313, true); + _dialog1.write(0x314, true); + _dialog1.write(0x315, true); + break; + + case 2: + _dialog1.write(0x311, false); + _dialog1.write(0x312, false); + _dialog1.write(0x313, true); + _dialog1.write(0x314, true); + _dialog1.write(0x315, true); + break; + + case 3: + _dialog1.write(0x311, false); + _dialog1.write(0x312, false); + _dialog1.write(0x313, false); + _dialog1.write(0x314, true); + _dialog1.write(0x315, true); + break; + + default: + break; + } +} + +void Scene703::setBottleSequence() { + _scene->_userInterface.setup(kInputBuildingSentences); + _game._player._stepEnabled = false; + if (_boatDir == 2) + _curSequence = 6; + else + _curSequence = 7; +} + +void Scene703::handleFillBottle(int quote) { + switch (quote) { + case 0x311: + _globals[kBottleStatus] = 1; + setBottleSequence(); + break; + + case 0x312: + _globals[kBottleStatus] = 2; + setBottleSequence(); + break; + + case 0x313: + _globals[kBottleStatus] = 3; + setBottleSequence(); + break; + + case 0x314: + _globals[kBottleStatus] = 4; + setBottleSequence(); + break; + + case 0x315: + _scene->_userInterface.setup(kInputBuildingSentences); + break; + + default: + break; + } +} + +void Scene703::enter() { + _game._player._visible = false; + + if (!_game._visitedScenes._sceneRevisited) { + if (_scene->_priorSceneId == 704) + _globals[kMonsterAlive] = false; + else + _globals[kMonsterAlive] = true; + } + + _startMonsterTimer = true; + _rexDeathFl = true; + _monsterTime = 0; + _restartTrigger70Fl = true; + _useBomb = false; + _boatFrame = -1; + + if (!_globals[kMonsterAlive]) + _scene->_hotspots.activate(NOUN_SEA_MONSTER, false); + + if (_scene->_priorSceneId == 704) { + _game._player._stepEnabled = false; + _curSequence = 2; + _boatDir = 2; + _monsterMode = 0; + _scene->loadAnimation(formAnimName('A', -1)); + _scene->_activeAnimation->setCurrentFrame(34); + } else if (_scene->_priorSceneId != -2) { + _game._player._stepEnabled = false; + _boatDir = 1; + if (_globals[kMonsterAlive]) { + _monsterMode = 1; + _curSequence = 0; + _scene->loadAnimation(formAnimName('B', -1)); + } else { + _curSequence = 0; + _monsterMode = 0; + _scene->loadAnimation(formAnimName('A', -1)); + } + } else if (_globals[kMonsterAlive]) { + _curSequence = 0; + _boatDir = 1; + _monsterMode = 1; + _scene->loadAnimation(formAnimName('B', -1)); + _scene->_activeAnimation->setCurrentFrame(39); + } else if (_boatDir == 1) { + _curSequence = 0; + _monsterMode = 0; + _scene->loadAnimation(formAnimName('A', -1)); + _scene->_activeAnimation->setCurrentFrame(9); + } else if (_boatDir == 2) { + _curSequence = 0; + _monsterMode = 0; + _scene->loadAnimation(formAnimName('A', -1)); + _scene->_activeAnimation->setCurrentFrame(56); + } + + if (_scene->_roomChanged) { + _game._objects.addToInventory(OBJ_TWINKIFRUIT); + _game._objects.addToInventory(OBJ_BOMB); + _game._objects.addToInventory(OBJ_CHICKEN); + _game._objects.addToInventory(OBJ_BONES); + } + + _game.loadQuoteSet(0x311, 0x312, 0x313, 0x314, 0x315, 0); + _dialog1.setup(0x98, 0x311, 0x312, 0x313, 0x314, 0x315, 0); + sceneEntrySound(); + _vm->_sound->command(28); +} + +void Scene703::step() { + if (_startMonsterTimer) { + long diff = _scene->_frameStartTime - _lastFrameTime; + if ((diff >= 0) && (diff <= 12)) + _monsterTime += diff; + else + _monsterTime++; + + _lastFrameTime = _scene->_frameStartTime; + } + + if ((_monsterTime >= 2400) && !_rexDeathFl && !_useBomb) { + _startMonsterTimer = false; + _rexDeathFl = true; + _game._player._stepEnabled = false; + _scene->freeAnimation(); + _monsterMode = 3; + _scene->loadAnimation(formAnimName('D', -1)); + _rexDeathFl = false; + _monsterTime = 0; + } + + + if (_game._trigger == 70) + _scene->_reloadSceneFlag = true; + + if ((_monsterMode == 3) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() != _boatFrame) { + _boatFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextBoatFrame = -1; + + if (_boatFrame == 62) { + nextBoatFrame = 61; + if (_restartTrigger70Fl) { + _restartTrigger70Fl = false; + _scene->_sequences.addTimer(15, 70); + } + } + + if ((nextBoatFrame >= 0) && (nextBoatFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextBoatFrame); + _boatFrame = nextBoatFrame; + } + } + } + + if (_game._trigger == 70) + _scene->_reloadSceneFlag = true; + + if ((_monsterMode == 0) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() != _boatFrame) { + _boatFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextBoatFrame = -1; + + switch (_boatFrame) { + case 11: + if (_curSequence == 7) { + _curSequence = 0; + nextBoatFrame = 100; + } else if (_curSequence == 5) + nextBoatFrame = 82; + else if (_curSequence == 1) + nextBoatFrame = 11; + else { + nextBoatFrame = 9; + if (!_game._player._stepEnabled) + _game._player._stepEnabled = true; + } + break; + + case 34: + if (_curSequence != 2) + _scene->_nextSceneId = 704; + break; + + case 57: + if (_curSequence == 6) { + _curSequence = 0; + nextBoatFrame = 91; + } else if (_curSequence == 4) + nextBoatFrame = 73; + else if (_curSequence == 3) + nextBoatFrame = 57; + else { + nextBoatFrame = 56; + if (!_game._player._stepEnabled) + _game._player._stepEnabled = true; + } + break; + + case 73: + _scene->_nextSceneId = 701; + break; + + case 82: + nextBoatFrame = 11; + break; + + case 91: + nextBoatFrame = 57; + break; + + case 100: + nextBoatFrame = 56; + if (!_game._player._stepEnabled) { + _scene->_sequences.addTimer(30, 80); + _game._player._stepEnabled = true; + } + break; + + case 110: + nextBoatFrame = 9; + if (!_game._player._stepEnabled) { + _scene->_sequences.addTimer(30, 80); + _game._player._stepEnabled = true; + } + break; + + default: + break; + } + + if ((nextBoatFrame >= 0) && (nextBoatFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextBoatFrame); + _boatFrame = nextBoatFrame; + } + } + } + + if (_game._trigger == 80) { + switch (_globals[kBottleStatus]) { + case 0: + _vm->_dialogs->show(432); + break; + + case 1: + _vm->_dialogs->show(70324); + break; + + case 2: + _vm->_dialogs->show(70325); + break; + + case 3: + _vm->_dialogs->show(70326); + break; + + case 4: + _vm->_dialogs->show(70327); + break; + + default: + break; + } + } + + + if ((_monsterMode == 1) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() != _boatFrame) { + _boatFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextBoatFrame = -1; + + switch (_boatFrame) { + case 39: + _game._player._stepEnabled = true; + _startMonsterTimer = true; + _rexDeathFl = false; + break; + + case 40: + case 49: + case 54: + case 67: + case 78: + case 87: + case 96: + case 105: + case 114: + case 123: + if (_curSequence == 8) + nextBoatFrame = 129; + + break; + + case 129: + nextBoatFrame = 39; + break; + + case 151: + _scene->_nextSceneId = 701; + break; + + default: + break; + } + + if ((nextBoatFrame >= 0) && (nextBoatFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextBoatFrame); + _boatFrame = nextBoatFrame; + } + } + } + + if ((_monsterMode == 2) && (_scene->_activeAnimation != nullptr)) { + if (_scene->_activeAnimation->getCurrentFrame() != _boatFrame) { + _boatFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextBoatFrame = -1; + + switch (_boatFrame) { + case 14: + if (!_useBomb) { + if (_game._difficulty == DIFFICULTY_HARD) + _game._objects.setRoom(OBJ_CHICKEN, 1); + else + _vm->_dialogs->show(70319); + } + nextBoatFrame = 80; + break; + + case 33: + if (_game._objects.isInInventory(OBJ_BONES)) { + _game._objects.setRoom(OBJ_BONES, 1); + _game._objects.addToInventory(OBJ_BONE); + } else + _game._objects.setRoom(OBJ_BONE, 1); + + nextBoatFrame = 80; + break; + + case 53: + _game._objects.setRoom(OBJ_TWINKIFRUIT, 1); + nextBoatFrame = 80; + _curSequence = 9; + break; + + case 80: + if (_game._difficulty == DIFFICULTY_HARD) { + _game._objects.setRoom(OBJ_BOMB, 1); + _vm->_dialogs->show(70318); + } else + _vm->_dialogs->show(70317); + + _scene->freeAnimation(); + _monsterMode = 1; + _scene->loadAnimation(formAnimName('B', -1)); + _scene->_activeAnimation->setCurrentFrame(39); + _game._player._stepEnabled = true; + break; + + case 91: + if (!_useBomb) { + _scene->freeAnimation(); + _monsterMode = 1; + _scene->loadAnimation(formAnimName('B', -1)); + _scene->_activeAnimation->setCurrentFrame(39); + _game._player._stepEnabled = true; + } else + _game._objects.setRoom(OBJ_CHICKEN_BOMB, 1); + + break; + + case 126: + _scene->_hotspots.activate(NOUN_SEA_MONSTER, false); + _globals[kMonsterAlive] = false; + _scene->freeAnimation(); + _monsterMode = 0; + _scene->loadAnimation(formAnimName('A', -1)); + _scene->_activeAnimation->setCurrentFrame(9); + _game._player._stepEnabled = true; + if (_game._storyMode == STORYMODE_NAUGHTY) + _vm->_dialogs->show(70321); + else + _vm->_dialogs->show(70322); + + break; + + default: + break; + } + + if ((nextBoatFrame >= 0) && (nextBoatFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextBoatFrame); + _boatFrame = nextBoatFrame; + } + } + } +} + +void Scene703::actions() { + if (_game._screenObjects._inputMode == 1) + handleFillBottle(_action._activeAction._verbId); + else if (_action.isAction(0x3B1, 0x3B0)) { + _game._player._stepEnabled = false; + if (_globals[kMonsterAlive]) + _curSequence = 8; + else if (_boatDir == 1) + _curSequence = 5; + else + _curSequence = 3; + } else if (_action.isAction(0x3B1, 0x3B2)) { + _game._player._stepEnabled = false; + if (_globals[kMonsterAlive]) { + _startMonsterTimer = false; + _rexDeathFl = true; + _monsterTime = 0; + _scene->freeAnimation(); + _monsterMode = 3; + _scene->loadAnimation(formAnimName('D', -1)); + } else if (_boatDir == 2) + _curSequence = 4; + else + _curSequence = 1; + } else if (_action.isAction(VERB_THROW, NOUN_BONE, 0x468) || _action.isAction(VERB_THROW, NOUN_BONES, 0x468)) { + _game._player._stepEnabled = false; + _scene->freeAnimation(); + _monsterMode = 2; + _scene->loadAnimation(formAnimName('C', -1)); + _scene->_activeAnimation->setCurrentFrame(19); + } else if (_action.isAction(VERB_THROW, NOUN_CHICKEN, 0x468)) { + _game._player._stepEnabled = false; + _scene->freeAnimation(); + _monsterMode = 2; + _scene->loadAnimation(formAnimName('C', -1)); + } else if (_action.isAction(VERB_THROW, NOUN_TWINKIFRUIT, 0x468)) { + _game._player._stepEnabled = false; + _scene->freeAnimation(); + _monsterMode = 2; + _scene->loadAnimation(formAnimName('C', -1)); + _scene->_activeAnimation->setCurrentFrame(39); + } else if (_action.isAction(VERB_THROW, NOUN_BOMB, 0x468)) { + _game._player._stepEnabled = false; + _scene->freeAnimation(); + _monsterMode = 2; + _scene->loadAnimation(formAnimName('C', -1)); + _scene->_activeAnimation->setCurrentFrame(59); + } else if (_action.isAction(VERB_THROW, NOUN_CHICKEN_BOMB, 0x468)) { + _useBomb = true; + _game._player._stepEnabled = false; + _scene->freeAnimation(); + _monsterMode = 2; + _scene->loadAnimation(formAnimName('C', -1)); + } else if (_action.isAction(VERB_PUT, NOUN_BOTTLE, 0x18F) || _action.isAction(0x85, 0x2E, 0x18F)) { + if (_globals[kBottleStatus] != 4) { + handleBottleInterface(); + _dialog1.start(); + } else + _vm->_dialogs->show(70323); + } else if (_action._lookFlag || _action.isAction(VERB_LOOK, NOUN_SEA_MONSTER)) { + if (_globals[kMonsterAlive]) + _vm->_dialogs->show(70310); + } else if (_action.isAction(VERB_LOOK, NOUN_WATER)) { + if (!_globals[kMonsterAlive]) + _vm->_dialogs->show(70311); + else + _vm->_dialogs->show(70312); + } else if (_action.isAction(VERB_LOOK, NOUN_BUILDING_TO_NORTH)) { + if (_globals[kMonsterAlive]) + _vm->_dialogs->show(70313); + else if (_game._visitedScenes.exists(710)) + _vm->_dialogs->show(70314); + else + _vm->_dialogs->show(70315); + } else if (_action.isAction(VERB_LOOK, NOUN_VOLCANO_RIM)) + _vm->_dialogs->show(70316); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene704::Scene704(MADSEngine *vm) : Scene7xx(vm) { + _bottleHotspotId = -1; + _boatCurrentFrame = -1; + _animationMode = -1; + _boatDirection = -1; + + _takeBottleFl = false; +} + +void Scene704::synchronize(Common::Serializer &s) { + Scene7xx::synchronize(s); + + s.syncAsSint16LE(_bottleHotspotId); + s.syncAsSint16LE(_boatCurrentFrame); + s.syncAsSint16LE(_animationMode); + s.syncAsSint16LE(_boatDirection); + + s.syncAsByte(_takeBottleFl); +} + +void Scene704::setup() { + _game._player._spritesPrefix = ""; + setAAName(); + _scene->addActiveVocab(NOUN_BOTTLE); + _scene->addActiveVocab(VERB_LOOK_AT); +} + +void Scene704::handleBottleInterface() { + switch (_globals[kBottleStatus]) { + case 0: + _dialog1.write(0x311, true); + _dialog1.write(0x312, true); + _dialog1.write(0x313, true); + _dialog1.write(0x314, true); + _dialog1.write(0x315, true); + break; + + case 1: + _dialog1.write(0x311, false); + _dialog1.write(0x312, true); + _dialog1.write(0x313, true); + _dialog1.write(0x314, true); + _dialog1.write(0x315, true); + break; + + case 2: + _dialog1.write(0x311, false); + _dialog1.write(0x312, false); + _dialog1.write(0x313, true); + _dialog1.write(0x314, true); + _dialog1.write(0x315, true); + break; + + case 3: + _dialog1.write(0x311, false); + _dialog1.write(0x312, false); + _dialog1.write(0x313, false); + _dialog1.write(0x314, true); + _dialog1.write(0x315, true); + break; + + default: + break; + } +} + +void Scene704::setBottleSequence() { + _scene->_userInterface.setup(kInputBuildingSentences); + _game._player._stepEnabled = false; + if (_boatDirection == 2) + _animationMode = 6; + else + _animationMode = 7; +} + +void Scene704::handleFillBottle(int quote) { + switch (quote) { + case 0x311: + _globals[kBottleStatus] = 1; + setBottleSequence(); + break; + + case 0x312: + _globals[kBottleStatus] = 2; + setBottleSequence(); + break; + + case 0x313: + _globals[kBottleStatus] = 3; + setBottleSequence(); + break; + + case 0x314: + _globals[kBottleStatus] = 4; + setBottleSequence(); + break; + + case 0x315: + _scene->_userInterface.setup(kInputBuildingSentences); + break; + + default: + break; + } +} + +void Scene704::enter() { + if (_game._objects[OBJ_BOTTLE]._roomNumber == _scene->_currentSceneId) { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('b', 0)); + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 0, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + if (_scene->_priorSceneId == 705) { + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(123, 125)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + } else { + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(190, 122)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 2); + } + int idx = _scene->_dynamicHotspots.add(NOUN_BONES, 0xD1, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _bottleHotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(-2, 0), FACING_NONE); + } + + _game._player._visible = false; + _takeBottleFl = false; + _boatCurrentFrame = -1; + + if (_scene->_priorSceneId == 705) { + _game._player._stepEnabled = false; + _animationMode = 2; + _boatDirection = 2; + _scene->loadAnimation(formAnimName('A', -1)); + _scene->_activeAnimation->setCurrentFrame(36); + } else if (_scene->_priorSceneId != -2) { + _game._player._stepEnabled = false; + _boatDirection = 1; + _scene->loadAnimation(formAnimName('A', -1)); + } else if (_boatDirection == 1) { + _scene->loadAnimation(formAnimName('A', -1)); + _scene->_activeAnimation->setCurrentFrame(8); + } else if (_boatDirection == 2) { + if (_game._objects[OBJ_BOTTLE]._roomNumber == _scene->_currentSceneId) { + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(123, 125)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + } + _scene->loadAnimation(formAnimName('A', -1)); + _scene->_activeAnimation->setCurrentFrame(57); + } + + if (_scene->_roomChanged) + _globals[kMonsterAlive] = false; + + _game.loadQuoteSet(0x311, 0x312, 0x313, 0x314, 0x315, 0); + _dialog1.setup(0x98, 0x311, 0x312, 0x313, 0x314, 0x315, 0); + + sceneEntrySound(); + _vm->_sound->command(28); +} + +void Scene704::step() { + if (_scene->_activeAnimation != nullptr) { + if (_scene->_activeAnimation->getCurrentFrame() != _boatCurrentFrame) { + _boatCurrentFrame = _scene->_activeAnimation->getCurrentFrame(); + int nextFrame = -1; + + switch (_boatCurrentFrame) { + case 10: + switch (_animationMode) { + case 1: + nextFrame = 10; + break; + case 5: + nextFrame = 74; + break; + case 7: + _animationMode = 0; + nextFrame = 92; + break; + default: + if (!_game._player._stepEnabled) + _game._player._stepEnabled = true; + + nextFrame = 8; + break; + } + break; + + case 36: + if (_animationMode != 2) + _scene->_nextSceneId = 705; + break; + + case 59: + switch (_animationMode) { + case 3: + nextFrame = 59; + break; + + case 4: + nextFrame = 65; + break; + + case 6: + _animationMode = 0; + nextFrame = 83; + break; + + default: + if (!_game._player._stepEnabled) { + _game._player._stepEnabled = true; + } + nextFrame = 57; + break; + } + break; + + case 65: + _scene->_nextSceneId = 703; + break; + + case 74: + nextFrame = 10; + break; + + case 83: + nextFrame = 59; + break; + + case 90: + if (_takeBottleFl) { + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->_dynamicHotspots.remove(_bottleHotspotId); + _game._objects.addToInventory(OBJ_BOTTLE); + _vm->_sound->command(15); + _vm->_dialogs->showItem(OBJ_BOTTLE, 70415); + } + break; + + case 92: + nextFrame = 57; + if (!_game._player._stepEnabled && !_takeBottleFl) { + _scene->_sequences.addTimer(30, 70); + _game._player._stepEnabled = true; + } + break; + + case 98: + if (_takeBottleFl) { + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->_dynamicHotspots.remove(_bottleHotspotId); + _game._objects.addToInventory(OBJ_BOTTLE); + _vm->_sound->command(15); + _vm->_dialogs->showItem(OBJ_BOTTLE, 70415); + } + break; + + case 101: + nextFrame = 8; + if (!_game._player._stepEnabled && !_takeBottleFl) { + _scene->_sequences.addTimer(30, 70); + _game._player._stepEnabled = true; + } + break; + + default: + break; + } + + if ((nextFrame >= 0) && (nextFrame != _scene->_activeAnimation->getCurrentFrame())) { + _scene->_activeAnimation->setCurrentFrame(nextFrame); + _boatCurrentFrame = nextFrame; + } + } + } + + if (_game._trigger == 70) { + switch (_globals[kBottleStatus]) { + case 0: + _vm->_dialogs->show(432); + break; + + case 1: + _vm->_dialogs->show(70324); + break; + + case 2: + _vm->_dialogs->show(70325); + break; + + case 3: + _vm->_dialogs->show(70326); + break; + + case 4: + _vm->_dialogs->show(70327); + break; + + default: + break; + } + } +} + +void Scene704::actions() { + if (_game._screenObjects._inputMode == 1) + handleFillBottle(_action._activeAction._verbId); + else if (_action.isAction(0x3B1, 0x3B4)) { + _game._player._stepEnabled = false; + if (_boatDirection == 1) + _animationMode = 5; + else + _animationMode = 3; + } else if (_action.isAction(0x3B1, 0x3B2)) { + _game._player._stepEnabled = false; + if (_boatDirection == 2) + _animationMode = 4; + else + _animationMode = 1; + } else if (_action.isAction(VERB_TAKE, NOUN_BOTTLE)) { + if (!_game._objects.isInInventory(OBJ_BOTTLE)) { + _game._player._stepEnabled = false; + _takeBottleFl = true; + if (_boatDirection == 2) { + _animationMode = 6; + } else { + _animationMode = 7; + } + } + } else if (_action.isAction(VERB_PUT, NOUN_BOTTLE, 0x18F) || _action.isAction(0x85, 0x2E, 0x18F)) { + if (_game._objects.isInInventory(OBJ_BOTTLE)) { + if (_globals[kBottleStatus] != 4) { + _takeBottleFl = false; + handleBottleInterface(); + _dialog1.start(); + } else + _vm->_dialogs->show(70323); + } + } else if (_action._lookFlag || _action.isAction(VERB_LOOK, NOUN_WATER)) + _vm->_dialogs->show(70410); + else if (_action.isAction(VERB_LOOK, NOUN_BUILDING_TO_NORTH)) { + if (_game._visitedScenes.exists(710)) + _vm->_dialogs->show(70411); + else + _vm->_dialogs->show(70412); + } else if (_action.isAction(VERB_LOOK, NOUN_VOLCANO_RIM)) + _vm->_dialogs->show(70413); + else if (_action.isAction(VERB_LOOK, NOUN_BOTTLE) && (_action._mainObjectSource == 4)) + _vm->_dialogs->show(70414); + else if (_action.isAction(VERB_LOOK, NOUN_OPEN_WATER_TO_SOUTH)) + _vm->_dialogs->show(70416); + else if (_action.isAction(VERB_LOOK, NOUN_SKY)) + _vm->_dialogs->show(70417); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene705::setup() { + _game._player._spritesPrefix = ""; + setAAName(); +} + +void Scene705::synchronize(Common::Serializer &s) { + Scene7xx::synchronize(s); +} + +void Scene705::handleBottleInterface() { + switch (_globals[kBottleStatus]) { + case 0: + _dialog1.write(0x311, true); + _dialog1.write(0x312, true); + _dialog1.write(0x313, true); + _dialog1.write(0x314, true); + _dialog1.write(0x315, true); + break; + + case 1: + _dialog1.write(0x311, false); + _dialog1.write(0x312, true); + _dialog1.write(0x313, true); + _dialog1.write(0x314, true); + _dialog1.write(0x315, true); + break; + + case 2: + _dialog1.write(0x311, false); + _dialog1.write(0x312, false); + _dialog1.write(0x313, true); + _dialog1.write(0x314, true); + _dialog1.write(0x315, true); + break; + + case 3: + _dialog1.write(0x311, false); + _dialog1.write(0x312, false); + _dialog1.write(0x313, false); + _dialog1.write(0x314, true); + _dialog1.write(0x315, true); + break; + + default: + break; + } +} + +void Scene705::setBottleSequence() { + _scene->_userInterface.setup(kInputBuildingSentences); + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->loadAnimation(formAnimName('F', -1), 90); +} + +void Scene705::handleFillBottle(int quote) { + switch (quote) { + case 0x311: + _globals[kBottleStatus] = 1; + setBottleSequence(); + break; + + case 0x312: + _globals[kBottleStatus] = 2; + setBottleSequence(); + break; + + case 0x313: + _globals[kBottleStatus] = 3; + setBottleSequence(); + break; + + case 0x314: + _globals[kBottleStatus] = 4; + setBottleSequence(); + break; + + case 0x315: + _scene->_userInterface.setup(kInputBuildingSentences); + break; + + default: + break; + } +} + +void Scene705::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('b', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('b', 1)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('a', 0)); + + _game._player._visible = false; + + if (_scene->_priorSceneId == 706) { + _game._player._stepEnabled = false; + _globals._sequenceIndexes[3] = _scene->_sequences.addReverseSpriteCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + } else if (_scene->_priorSceneId != -2) { + _game._player._stepEnabled = false; + _scene->_sequences.addTimer(1, 80); + _vm->_sound->command(28); + } else + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + + if (_scene->_roomChanged) + _game._objects.addToInventory(OBJ_BOTTLE); + + _game.loadQuoteSet(0x311, 0x312, 0x313, 0x314, 0x315, 0); + _dialog1.setup(0x98, 0x311, 0x312, 0x313, 0x314, 0x315, 0); + sceneEntrySound(); +} + +void Scene705::step() { + switch (_game._trigger) { + case 70: + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 9, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + break; + + case 71: { + int syncIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx); + _game._player._stepEnabled = true; + } + break; + + default: + break; + } + + switch (_game._trigger) { + case 80: + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 9, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 81); + break; + + case 81: { + _vm->_sound->command(19); + int syncIdx = _globals._sequenceIndexes[1]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx); + _game._player._stepEnabled = true; + } + break; + + default: + break; + } + + switch (_game._trigger) { + case 90: + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.addTimer(30, 91); + break; + + case 91: + switch (_globals[kBottleStatus]) { + case 0: + _vm->_dialogs->show(432); + break; + + case 1: + _vm->_dialogs->show(70324); + break; + + case 2: + _vm->_dialogs->show(70325); + break; + + case 3: + _vm->_dialogs->show(70326); + break; + + case 4: + _vm->_dialogs->show(70327); + break; + + default: + break; + } + _game._player._stepEnabled = true; + break; + + default: + break; + } +} + +void Scene705::actions() { + if (_game._screenObjects._inputMode == 1) + handleFillBottle(_action._activeAction._verbId); + else if (_action.isAction(0x3B1, 0x3B4)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 6, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + _vm->_sound->command(18); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 2); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], syncIdx); + _scene->_nextSceneId = 704; + _game._player._stepEnabled = true; + } + break; + + default: + break; + } + } else if (_action.isAction(VERB_CLIMB_THROUGH, NOUN_WINDOW)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[3]); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 6, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 16); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[3]; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 16); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[3], syncIdx); + _scene->_nextSceneId = 706; + _game._player._stepEnabled = true; + } + break; + + default: + break; + } + } else if (_action.isAction(0x85, 0x2E, 0x18F) || _action.isAction(VERB_PUT, NOUN_BOTTLE, 0x18F)) { + if (_globals[kBottleStatus] != 4) { + handleBottleInterface(); + _dialog1.start(); + } else + _vm->_dialogs->show(70323); + } if (_action._lookFlag || _action.isAction(VERB_LOOK, NOUN_WATER)) + _vm->_dialogs->show(70511); + else if (_action.isAction(VERB_LOOK, NOUN_VOLCANO_RIM)) + _vm->_dialogs->show(70512); + else if (_action.isAction(VERB_LOOK, NOUN_OPEN_WATER_TO_SOUTH)) + _vm->_dialogs->show(70513); + else if (_action.isAction(VERB_LOOK, NOUN_SKY)) + _vm->_dialogs->show(70514); + else if (_action.isAction(VERB_LOOK, NOUN_BUILDING)) + _vm->_dialogs->show(70515); + else if (_action.isAction(VERB_LOOK, NOUN_WINDOW)) + _vm->_dialogs->show(70516); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene706::Scene706(MADSEngine *vm) : Scene7xx(vm) { + _vaseHotspotId = -1; + _vaseMode = -1; + _animationMode = -1; + _animationFrame = -1; + + _emptyPedestral = false; +} + +void Scene706::synchronize(Common::Serializer &s) { + Scene7xx::synchronize(s); + + s.syncAsSint16LE(_vaseHotspotId); + s.syncAsSint16LE(_vaseMode); + s.syncAsSint16LE(_animationMode); + s.syncAsSint16LE(_animationFrame); + + s.syncAsByte(_emptyPedestral); +} + +void Scene706::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_BOTTLE); + _scene->addActiveVocab(NOUN_VASE); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene706::handleRexDeath() { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->loadAnimation(formAnimName('a', -1), 2); + break; + + case 2: + if (_animationMode == 1) + _vm->_dialogs->show(70625); + else if (_globals[kBottleStatus] < 2) + _vm->_dialogs->show(70628); + else + _vm->_dialogs->show(70629); + + _game._objects.setRoom(OBJ_VASE, _scene->_currentSceneId); + if (_animationMode == 2) + _game._objects.setRoom(OBJ_BOTTLE, 2); + + _animationMode = 0; + _scene->_reloadSceneFlag = true; + break; + + default: + break; + } +} + +void Scene706::handleTakeVase() { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[3] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[3], false, 4, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[3]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 7, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _vm->_sound->command(9); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _scene->_dynamicHotspots.remove(_vaseHotspotId); + _game._objects.addToInventory(OBJ_VASE); + if (_vaseMode == 1) { + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 4); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(195, 99)); + int idx = _scene->_dynamicHotspots.add(NOUN_BOTTLE, VERB_WALKTO, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(175, 124), FACING_SOUTHEAST); + _game._objects.setRoom(OBJ_BOTTLE, _scene->_currentSceneId); + } + break; + + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[3]); + _game._player._visible = true; + _vm->_dialogs->showItem(OBJ_VASE, 70630); + _game._player._stepEnabled = true; + break; + } +} + +void Scene706::enter() { + _globals._spriteIndexes[3] = _scene->_sprites.addSprites("*RXMRC_3"); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('b', -1)); + + if (!_game._visitedScenes._sceneRevisited) + _emptyPedestral = false; + + if (_game._objects[OBJ_VASE]._roomNumber == _scene->_currentSceneId) { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('v', -1)); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 4); + int idx = _scene->_dynamicHotspots.add(NOUN_VASE, VERB_WALKTO, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _vaseHotspotId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(175, 124), FACING_SOUTHEAST); + } else if (_game._objects.isInRoom(OBJ_BOTTLE)) { + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 4); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(195, 99)); + int idx = _scene->_dynamicHotspots.add(NOUN_BOTTLE, VERB_WALKTO, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(175, 124), FACING_SOUTHEAST); + } + + _game._player._visible = true; + + if (_scene->_priorSceneId == 707) { + _game._player._playerPos = Common::Point(277, 103); + _game._player._facing = FACING_SOUTHWEST; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(167, 152); + _game._player._facing = FACING_NORTH; + } + + if (_globals[kTeleporterCommand]) { + _game._player._visible = false; + _game._player._stepEnabled = false; + + switch (_globals[kTeleporterCommand]) { + case 1: + _scene->loadAnimation(formAnimName('E', 1), 75); + break; + + case 2: + _scene->loadAnimation(formAnimName('E', -1), 80); + break; + + default: + _game._player.walk(Common::Point(264, 116), FACING_SOUTHWEST); + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + } + _globals[kTeleporterCommand] = 0; + } + + _animationMode = 0; + + if (_scene->_roomChanged) { + _game._objects.addToInventory(OBJ_BOTTLE); + _globals[kBottleStatus] = 2; + } + + sceneEntrySound(); +} + +void Scene706::step() { + if (_game._trigger == 75) { + _game._player._stepEnabled = true; + _game._player._visible = true; + _game._player._priorTimer = _scene->_frameStartTime - _game._player._ticksAmount; + _game._player.walk(Common::Point(264, 116), FACING_SOUTHWEST); + } + + if (_game._trigger == 80) { + _globals[kTeleporterCommand] = 1; + _scene->_nextSceneId = _globals[kTeleporterDestination]; + _scene->_reloadSceneFlag = true; + } + + if (_scene->_activeAnimation != nullptr) { + if ((_animationMode != 0) && (_scene->_activeAnimation->getCurrentFrame() != _animationFrame)) { + _animationFrame = _scene->_activeAnimation->getCurrentFrame(); + + if (_animationFrame == 6) { + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _game._objects.setRoom(OBJ_VASE, 2); + + if (_animationMode == 2) { + _game._objects.setRoom(OBJ_BOTTLE, 1); + + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 4); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(195, 99)); + int idx = _scene->_dynamicHotspots.add(NOUN_BOTTLE, VERB_WALKTO, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(175, 124), FACING_SOUTHEAST); + } + } + } + } +} + +void Scene706::preActions() { + if (_action.isAction(VERB_LOOK, NOUN_PORTRAIT)) + _game._player._needToWalk = true; +} + +void Scene706::actions() { + if (_action.isAction(VERB_WALK_INSIDE, NOUN_TELEPORTER)) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->_nextSceneId = 707; + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_EXIT, NOUN_ROOM)) { + _scene->_nextSceneId = 705; + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_TAKE, NOUN_VASE)) { + if (_game._difficulty != DIFFICULTY_EASY) { + _animationMode = 1; + handleRexDeath(); + } else if (_game._trigger || !_game._objects.isInInventory(OBJ_VASE)) { + handleTakeVase(); + _emptyPedestral = true; + } + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_PUT, NOUN_BOTTLE, 0x344)) { + if ((_globals[kBottleStatus] == 2 && _game._difficulty == DIFFICULTY_HARD) || + (_globals[kBottleStatus] != 0 && _game._difficulty != DIFFICULTY_HARD)) { + if (!_game._objects.isInInventory(OBJ_VASE) || _game._trigger) { + _vaseMode = 1; + handleTakeVase(); + _action._inProgress = false; + return; + } + } else if (_game._objects.isInRoom(OBJ_VASE) || _game._trigger) { + _animationMode = 2; + handleRexDeath(); + _action._inProgress = false; + return; + } + } + + if (_action.isAction(VERB_PUT, NOUN_PEDESTAL) && _game._objects.isInInventory(_game._objects.getIdFromDesc(_action._activeAction._objectNameId))) { + int objectId = _game._objects.getIdFromDesc(_action._activeAction._objectNameId); + if (_game._objects[objectId].hasQuality(10)) + _vm->_dialogs->show(70626); + else + _vm->_dialogs->show(70627); + } else if (_action.isAction(VERB_TAKE, NOUN_BOTTLE) && _game._objects.isInInventory(OBJ_VASE)) + _vm->_dialogs->show(70631); + else if (_action._lookFlag) { + if (_game._objects[OBJ_VASE]._roomNumber == _scene->_currentSceneId) + _vm->_dialogs->show(70610); + else + _vm->_dialogs->show(70611); + } else if (_action.isAction(VERB_LOOK, NOUN_FLOOR)) + _vm->_dialogs->show(70612); + else if (_action.isAction(VERB_LOOK, NOUN_PILLAR)) + _vm->_dialogs->show(70613); + else if (_action.isAction(VERB_LOOK, NOUN_OLD_TEA_CUP)) + _vm->_dialogs->show(70614); + else if (_action.isAction(VERB_TAKE, NOUN_OLD_TEA_CUP)) + _vm->_dialogs->show(70615); + else if (_action.isAction(VERB_LOOK, NOUN_OLD_VASE)) + _vm->_dialogs->show(70616); + else if (_action.isAction(VERB_LOOK, NOUN_PORTRAIT)) + _vm->_dialogs->show(70617); + else if (_action.isAction(VERB_LOOK, NOUN_NAME_PLATE)) + _vm->_dialogs->show(70618); + else if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(70619); + else if (_action.isAction(VERB_LOOK, NOUN_PEDESTAL)) { + if (_game._objects[OBJ_VASE]._roomNumber == _scene->_currentSceneId) + _vm->_dialogs->show(70620); + else if (_game._objects[OBJ_BOTTLE]._roomNumber == _scene->_currentSceneId) + _vm->_dialogs->show(70622); + else + _vm->_dialogs->show(70621); + } else if (_action.isAction(VERB_LOOK, NOUN_TELEPORTER)) + _vm->_dialogs->show(70623); + else if (_action.isAction(VERB_LOOK, NOUN_VASE) && (_game._objects[OBJ_VASE]._roomNumber == _scene->_currentSceneId)) + _vm->_dialogs->show(70624); + else if (_action.isAction(VERB_LOOK, NOUN_BOTTLE) && (_action._mainObjectSource == 4)) + _vm->_dialogs->show(70632); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene707::setup() { + _game._player._spritesPrefix = ""; + // The original calls Scene7xx::setAAName() + _game._aaName = Resources::formatAAName(5); +} + +void Scene707::enter() { + _handSpriteId = _scene->_sprites.addSprites("*REXHAND"); + teleporterEnter(); + + // The original uses Scene7xx_sceneEntrySound + if (!_vm->_musicFlag) + _vm->_sound->command(2); + else + _vm->_sound->command(25); +} + +void Scene707::step() { + teleporterStep(); +} + +void Scene707::actions() { + if (teleporterActions()) { + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_VIEWPORT) || _action.isAction(VERB_PEER_THROUGH, NOUN_VIEWPORT)) + _vm->_dialogs->show(70710); + else if (_action.isAction(VERB_LOOK, NOUN_KEYPAD)) + _vm->_dialogs->show(70711); + else if (_action.isAction(VERB_LOOK, NOUN_DISPLAY)) + _vm->_dialogs->show(70712); + else if (_action.isAction(VERB_LOOK, NOUN_0_KEY) || _action.isAction(VERB_LOOK, NOUN_1_KEY) + || _action.isAction(VERB_LOOK, NOUN_2_KEY) || _action.isAction(VERB_LOOK, NOUN_3_KEY) + || _action.isAction(VERB_LOOK, NOUN_4_KEY) || _action.isAction(VERB_LOOK, NOUN_5_KEY) + || _action.isAction(VERB_LOOK, NOUN_6_KEY) || _action.isAction(VERB_LOOK, NOUN_7_KEY) + || _action.isAction(VERB_LOOK, NOUN_8_KEY) || _action.isAction(VERB_LOOK, NOUN_9_KEY) + || _action.isAction(VERB_LOOK, NOUN_SMILE_KEY) || _action.isAction(VERB_LOOK, NOUN_ENTER_KEY) + || _action.isAction(VERB_LOOK, NOUN_FROWN_KEY)) + _vm->_dialogs->show(70713); + else if (_action.isAction(VERB_LOOK, NOUN_DEVICE) || _action._lookFlag) + _vm->_dialogs->show(70714); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene710::setup() { + _game._player._spritesPrefix = ""; + setAAName(); +} + +void Scene710::enter() { + _scene->_userInterface.setup(kInputLimitedSentences); + + if (_game._objects[OBJ_VASE]._roomNumber == 706) { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('g', -1)); + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 6, 0, 0, 0); + } + + _game._player._visible = false; + _scene->_sequences.addTimer(600, 70); + + sceneEntrySound(); +} + +void Scene710::step() { + if (_game._trigger == 70) { + if (_game._globals[kCityFlooded]) + _scene->_nextSceneId = 701; + else + _scene->_nextSceneId = 751; + } +} + +void Scene710::actions() { + if (_action.isAction(0x46F, 0x27)) { + _game._player._stepEnabled = false; + + if (_game._globals[kCityFlooded]) + _scene->_nextSceneId = 701; + else + _scene->_nextSceneId = 751; + + _action._inProgress = false; + } +} + +/*------------------------------------------------------------------------*/ + +void Scene711::setup() { + // The original was calling Scene7xx::setPlayerSpreitesPrefix() + _vm->_sound->command(5); + Common::String oldName = _game._player._spritesPrefix; + _game._player._spritesPrefix = ""; + _game._player._scalingVelocity = true; + + if (oldName != _game._player._spritesPrefix) + _game._player._spritesChanged = true; + + _vm->_palette->setEntry(16, 10, 63, 63); + _vm->_palette->setEntry(17, 10, 45, 45); + + // The original was calling Scene7xx::setAAName() + _game._aaName = Resources::formatAAName(5); + + _game._player._spritesPrefix = ""; +} + +void Scene711::enter() { + if (_globals[kSexOfRex] == REX_FEMALE) + _handSpriteId = _scene->_sprites.addSprites("*ROXHAND"); + else + _handSpriteId = _scene->_sprites.addSprites("*REXHAND"); + + teleporterEnter(); + + // The original was using Scene7xx_SceneEntrySound() + if (!_vm->_musicFlag) + _vm->_sound->command(2); + else + _vm->_sound->command(25); +} + +void Scene711::step() { + teleporterStep(); +} + +void Scene711::actions() { + if (teleporterActions()) + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene751::Scene751(MADSEngine *vm) : Scene7xx(vm) { + _rexHandingLine = false; +} + +void Scene751::synchronize(Common::Serializer &s) { + Scene7xx::synchronize(s); + + s.syncAsByte(_rexHandingLine); +} + +void Scene751::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_FISHING_LINE); + _scene->addActiveVocab(VERB_WALKTO); +} + +void Scene751::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites("*RM701X0"); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('a', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('f', 0)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites("*RM202A1"); + + if (!_game._visitedScenes._sceneRevisited) + _rexHandingLine = false; + + if (_globals[kLineStatus] == 2 || _globals[kLineStatus] == 3) { + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7); + int idx = _scene->_dynamicHotspots.add(NOUN_FISHING_LINE, 0xD, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(268, 140), FACING_NORTHWEST); + } + + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + + if (_scene->_priorSceneId == 752) { + _game._player._playerPos = Common::Point(309, 138); + _game._player._facing = FACING_WEST; + } else if (_scene->_priorSceneId == 710) { + _game._player._playerPos = Common::Point(154, 129); + _game._player._facing = FACING_NORTH; + _game._player._visible = false; + _game._player._stepEnabled = false; + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, -2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(155, 129)); + _scene->_sequences.addTimer(15, 70); + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(22, 131); + _game._player._facing = FACING_EAST; + _game._player._stepEnabled = false; + _scene->_sequences.addTimer(60, 60); + } else if (_rexHandingLine) { + _game._player._visible = false; + _game._player._playerPos = Common::Point(268, 140); + _game._player._facing = FACING_NORTHWEST; + _game._player._visible = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 7); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + } else if (_globals[kLineStatus] == 2) { + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7); + int idx = _scene->_dynamicHotspots.add(NOUN_FISHING_LINE, 0xD, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(268, 140), FACING_NORTHWEST); + } + + if (_scene->_roomChanged) { + _game._objects.addToInventory(OBJ_FISHING_LINE); + _game._objects.addToInventory(OBJ_BINOCULARS); + } + + sceneEntrySound(); + _game.loadQuoteSet(0x30A, 0x30B, 0x30C, 0x30D, 0x30E, 0); + + if (_globals[kTimebombTimer] > 0) + _globals[kTimebombTimer] = 10200; +} + +void Scene751::step() { + switch (_game._trigger) { + case 70: + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 6, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(155, 129)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + break; + + case 71: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[4]); + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + + if ((_globals[kTimebombTimer] >= 10800) && (_globals[kTimebombStatus] == 1)) { + _globals[kTimebombStatus] = 3; + _globals[kTimebombTimer] = 0; + _globals[kCheckDaemonTimebomb] = false; + _scene->_nextSceneId = 620; + } + + switch (_game._trigger) { + case 60: + _vm->_sound->command(16); + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 61); + break; + + case 61: + _game._player.walk(Common::Point(61, 131), FACING_EAST); + _scene->_sequences.addTimer(120, 62); + break; + + case 62: + _vm->_sound->command(17); + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 63); + break; + + case 63: + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _game._player._stepEnabled = true; + _scene->_kernelMessages.reset(); + break; + + default: + break; + } +} + +void Scene751::preActions() { + if (_action.isAction(VERB_LOOK, NOUN_TALL_BUILDING)) + _game._player.walk(Common::Point(154, 129), FACING_NORTHEAST); + + if (_action.isAction(VERB_LOOK, NOUN_BINOCULARS, 0x470)) + _game._player.walk(Common::Point(154, 129), FACING_NORTH); + + if (_action.isAction(VERB_WALKTO, NOUN_EAST_END_OF_PLATFORM)) + _game._player._walkOffScreenSceneId = 752; + + if (!_rexHandingLine) + return; + + if (_action.isAction(VERB_LOOK) || _action.isAction(0x87) || _action.isAction(VERB_TALKTO)) + _game._player._needToWalk = false; + + if ((!_action.isAction(VERB_PUT, NOUN_FISHING_LINE, 0x467) || !_action.isAction(0x170, 0x87, 0x467) || !_action.isAction(0x19, 0x87, 0x467)) + && (_game._player._needToWalk)) { + switch (_game._trigger) { + case 0: + _game._player._readyToWalk = false; + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 11, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], -1, 7); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[2]); + _game._player._visible = true; + _rexHandingLine = false; + _game._player._stepEnabled = true; + _game._player._readyToWalk = true; + break; + + default: + break; + } + } +} + +void Scene751::actions() { + if (_action.isAction(VERB_WALK_ALONG, NOUN_PLATFORM)) + ; // Nothing + else if (_action.isAction(VERB_LOOK, NOUN_BINOCULARS, 0x470)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 6, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(155, 129)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, -2); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(155, 129)); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], syncIdx); + _scene->_sequences.addTimer(15, 2); + } + break; + + case 2: + _scene->_nextSceneId = 710; + break; + + default: + break; + } + } else if (_action.isAction(VERB_STEP_INTO, NOUN_ELEVATOR)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _vm->_sound->command(16); + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _scene->_kernelMessages.reset(); + _scene->_kernelMessages.add(Common::Point(0, 0), 0x1110, 34, 0, 120, _game.getQuote(0x30D)); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: + _game._player.walk(Common::Point(22, 131), FACING_EAST); + _scene->_sequences.addTimer(120, 3); + break; + + case 3: + _vm->_sound->command(17); + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 5, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 4); + break; + + case 4: + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, -1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(48, 136)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 10); + _scene->_sequences.addTimer(60, 5); + break; + + case 5: + _game._player._stepEnabled = true; + _scene->_nextSceneId = 513; + break; + + default: + break; + } + } else if (_action.isAction(VERB_PUT, NOUN_FISHING_LINE, 0x467) || _action.isAction(0x170, 0x87, 0x467) || _action.isAction(0x19, 0x87, 0x467)) { + if (_globals[kLineStatus] == 1) { + switch (_game._trigger) { + case 0: + _game._player._visible = false; + _game._player._stepEnabled = false; + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], -1, 6); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], -1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 1); + break; + + case 1: { + int syncIdx = _globals._sequenceIndexes[2]; + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 7); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[2], syncIdx); + _scene->_sequences.addTimer(30, 2); + } + break; + + case 2: + _rexHandingLine = true; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 8, -2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 3); + break; + + case 3: { + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[2]); + _game._player._visible = true; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, -1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 7); + int idx = _scene->_dynamicHotspots.add(NOUN_FISHING_LINE, 0xD, _globals._sequenceIndexes[3], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(268, 140), FACING_NORTHWEST); + _scene->_kernelMessages.reset(); + _game._objects.setRoom(OBJ_FISHING_LINE, _scene->_currentSceneId); + _rexHandingLine = false; + _globals[kLineStatus] = 2; + _game._player._stepEnabled = true; + _vm->_dialogs->show(75120); + } + break; + + default: + break; + } + } + } else if (_action._lookFlag || _action.isAction(VERB_LOOK, NOUN_CITY)) + _vm->_dialogs->show(75110); + else if (_action.isAction(VERB_LOOK, NOUN_ELEVATOR)) + _vm->_dialogs->show(75112); + else if (_action.isAction(VERB_LOOK, NOUN_PLATFORM)) + _vm->_dialogs->show(75113); + else if (_action.isAction(VERB_LOOK, NOUN_CEMENT_PYLON)) + _vm->_dialogs->show(75114); + else if ((_action.isAction(VERB_LOOK, NOUN_HOOK) || _action.isAction(VERB_LOOK, NOUN_FISHING_LINE)) + && (_globals[kLineStatus] == 2 || _globals[kLineStatus] == 3)) + _vm->_dialogs->show(75116); + else if (_action.isAction(VERB_LOOK, NOUN_HOOK)) + _vm->_dialogs->show(75115); + else if (_action.isAction(VERB_LOOK, NOUN_ROCK)) + _vm->_dialogs->show(75117); + else if (_action.isAction(VERB_TAKE, NOUN_ROCK)) + _vm->_dialogs->show(75118); + else if (_action.isAction(VERB_LOOK, NOUN_EAST_END_OF_PLATFORM)) + _vm->_dialogs->show(75119); + else if (_action.isAction(VERB_TAKE, NOUN_FISHING_LINE) && (_globals[kLineStatus] == 3 || _globals[kLineStatus] == 2)) + _vm->_dialogs->show(75121); + else if (_action.isAction(VERB_LOOK, NOUN_TALL_BUILDING)) + _vm->_dialogs->show(75122); + else if (_action.isAction(0x170, 0x87, 0x316) || _action.isAction(0x19, 0x87, 0x316)) + _vm->_dialogs->show(75123); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene752::Scene752(MADSEngine *vm) : Scene7xx(vm) { + _cardId = -1; +} + +void Scene752::synchronize(Common::Serializer &s) { + Scene7xx::synchronize(s); + + s.syncAsSint16LE(_cardId); +} + +void Scene752::setup() { + setPlayerSpritesPrefix(); + setAAName(); + + _scene->addActiveVocab(NOUN_ID_CARD); + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(VERB_LOOK_AT); + _scene->addActiveVocab(NOUN_LASER_BEAM); +} + +void Scene752::enter() { + _globals._spriteIndexes[14] = _scene->_sprites.addSprites(formAnimName('l', -1)); + _globals._spriteIndexes[12] = _scene->_sprites.addSprites("*RXMBD_8"); + + if (_scene->_priorSceneId == 751) { + _game._player._playerPos = Common::Point(13, 145); + _game._player._facing = FACING_EAST; + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(289, 138); + _game._player.walk(Common::Point(262, 148), FACING_WEST); + _game._player._facing = FACING_WEST; + _game._player._visible = true; + } + + if (_game._objects[OBJ_ID_CARD]._roomNumber == 752) { + _globals._spriteIndexes[13] = _scene->_sprites.addSprites(formAnimName('i', -1)); + _globals._sequenceIndexes[13] = _scene->_sequences.startCycle(_globals._spriteIndexes[13], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[13], 8); + int idx = _scene->_dynamicHotspots.add(NOUN_ID_CARD, VERB_WALKTO, _globals._sequenceIndexes[13], Common::Rect(0, 0, 0, 0)); + _cardId = _scene->_dynamicHotspots.setPosition(idx, Common::Point(234, 135), FACING_NORTH); + } + + if (_game._globals[kLaserHoleIsThere]) { + _globals._sequenceIndexes[14] = _scene->_sequences.startCycle(_globals._spriteIndexes[14], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[14], 13); + int idx = _scene->_dynamicHotspots.add(NOUN_LASER_BEAM, VERB_LOOK_AT, _globals._sequenceIndexes[14], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(215, 130), FACING_NORTHWEST); + } + + if (_game._globals[kTeleporterCommand]) { + switch(_game._globals[kTeleporterCommand]) { + case TELEPORTER_BEAM_OUT: + case TELEPORTER_WRONG: + case TELEPORTER_STEP_OUT: + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + default: + break; + } + + _game._globals[kTeleporterCommand] = TELEPORTER_NONE; + } + + if (_globals._timebombTimer > 0) + _globals._timebombTimer = 10800 - 600; + + sceneEntrySound(); +} + +void Scene752::step() { + if (_globals._timebombTimer >= 10800 && _game._globals[kTimebombStatus] == TIMEBOMB_ACTIVATED) { + _globals[kTimebombStatus] = TIMEBOMB_DEAD; + _globals._timebombTimer = 0; + _globals[kCheckDaemonTimebomb] = false; + _scene->_nextSceneId = 620; + } +} + +void Scene752::preActions() { + if (_action.isAction(VERB_WALKTO, NOUN_WEST_END_OF_PLATFORM)) { + _game._player._walkOffScreenSceneId = 751; + } +} + +void Scene752::actions() { + if (_action.isAction(VERB_WALK_ALONG, NOUN_PLATFORM)) + ; + else if (_action.isAction(VERB_STEP_INTO, NOUN_TELEPORTER)) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->_nextSceneId = 711; + } else if (_action.isAction(VERB_TAKE, NOUN_ID_CARD) && (!_game._objects.isInInventory(OBJ_ID_CARD) || _game._trigger)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 5, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[12]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_SPRITE, 4, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + case 1: + _vm->_sound->command(0xF); + _scene->_sequences.remove(_globals._sequenceIndexes[13]); + _game._objects.addToInventory(OBJ_ID_CARD); + _scene->_dynamicHotspots.remove(_cardId); + _vm->_dialogs->show(OBJ_ID_CARD, 830); + break; + case 2: + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + default: + break; + } + } else if (_action.isAction(VERB_TAKE, NOUN_BONES) && (_action._mainObjectSource == 4) && (!_game._objects.isInInventory(OBJ_BONES) || _game._trigger)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[12] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[12], false, 5, 2, 0, 0); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[12]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_SPRITE, 4, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[12], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + case 1: + _vm->_sound->command(0xF); + if (_game._objects.isInInventory(OBJ_BONE)) + _game._objects.setRoom(OBJ_BONE, 1); + _game._objects.addToInventory(OBJ_BONES); + _vm->_dialogs->show(OBJ_BONES, 75221); + break; + case 2: + _scene->_sequences.updateTimeout(-1, _globals._sequenceIndexes[12]); + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + default: + break; + } + } else if (_action._lookFlag || _action.isAction(VERB_LOOK, NOUN_CITY)) { + if (_globals[kLaserHoleIsThere]) + _vm->_dialogs->show(75212); + else + _vm->_dialogs->show(75210); + } else if (_action.isAction(VERB_LOOK, NOUN_PLATFORM)) + _vm->_dialogs->show(75213); + else if (_action.isAction(VERB_LOOK, NOUN_CEMENT_BLOCK)) + _vm->_dialogs->show(75214); + else if (_action.isAction(VERB_LOOK, NOUN_ROCK)) + _vm->_dialogs->show(75215); + else if (_action.isAction(VERB_TAKE, NOUN_ROCK)) + _vm->_dialogs->show(75216); + else if (_action.isAction(VERB_LOOK, NOUN_WEST_END_OF_PLATFORM)) + _vm->_dialogs->show(75217); + else if (_action.isAction(VERB_LOOK, NOUN_TELEPORTER)) + _vm->_dialogs->show(75218); + else if ((_action.isAction(VERB_LOOK, NOUN_BONES) || _action.isAction(VERB_LOOK, NOUN_ID_CARD)) && (_action._mainObjectSource == 4)) { + if (_game._objects[OBJ_ID_CARD]._roomNumber == 752) + _vm->_dialogs->show(75219); + else + _vm->_dialogs->show(75220); + } else if (_action.isAction(VERB_TAKE, NOUN_BONES) && (_action._mainObjectSource == 4)) { + if (_game._objects.isInInventory(OBJ_BONES)) + _vm->_dialogs->show(75222); + } else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +} // End of namespace Nebular +} // End of namespace MADS diff --git a/engines/mads/nebular/nebular_scenes7.h b/engines/mads/nebular/nebular_scenes7.h new file mode 100644 index 0000000000..454c76ebe9 --- /dev/null +++ b/engines/mads/nebular/nebular_scenes7.h @@ -0,0 +1,238 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_NEBULAR_SCENES7_H +#define MADS_NEBULAR_SCENES7_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" + +namespace MADS { + +namespace Nebular { + +class Scene7xx : public NebularScene { +protected: + /** + * Plays an appropriate sound when entering a scene + */ + void setAAName(); + + /** + * Updates the prefix used for getting player sprites for the scene + */ + void setPlayerSpritesPrefix(); + + void sceneEntrySound(); + +public: + Scene7xx(MADSEngine *vm) : NebularScene(vm) {} +}; + +class Scene701: public Scene7xx { +private: + int _fishingLineId; + +public: + Scene701(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void preActions(); + virtual void actions(); + virtual void step(); +}; + +class Scene702: public Scene7xx { +public: + Scene702(MADSEngine *vm) : Scene7xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene703: public Scene7xx{ +private: + int _monsterMode; + int _boatFrame; + int _curSequence; + int _boatDir; + + bool _useBomb; + bool _startMonsterTimer; + bool _rexDeathFl; + bool _restartTrigger70Fl; + + uint32 _lastFrameTime; + uint32 _monsterTime; + + Conversation _dialog1; + + void handleBottleInterface(); + void setBottleSequence(); + void handleFillBottle(int quote); + +public: + Scene703(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene704: public Scene7xx{ +private: + int _bottleHotspotId; + int _boatCurrentFrame; + int _animationMode; + int _boatDirection; + + bool _takeBottleFl; + + Conversation _dialog1; + + void handleFillBottle(int quote); + void setBottleSequence(); + void handleBottleInterface(); + +public: + Scene704(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene705: public Scene7xx{ +private: + Conversation _dialog1; + + void handleFillBottle(int quote); + void setBottleSequence(); + void handleBottleInterface(); + +public: + Scene705(MADSEngine *vm) : Scene7xx(vm) {} + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene706: public Scene7xx{ +private: + int _vaseHotspotId; + int _vaseMode; + int _animationMode; + int _animationFrame; + + bool _emptyPedestral; + + void handleTakeVase(); + void handleRexDeath(); + +public: + Scene706(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene707: public SceneTeleporter { +public: + Scene707(MADSEngine *vm) : SceneTeleporter(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene710: public Scene7xx { +public: + Scene710(MADSEngine *vm) : Scene7xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene711: public SceneTeleporter { +public: + Scene711(MADSEngine *vm) : SceneTeleporter(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene751: public Scene7xx{ +private: + bool _rexHandingLine; + +public: + Scene751(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene752: public Scene7xx { +private: + int _cardId; + +public: + Scene752(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +} // End of namespace Nebular +} // End of namespace MADS + +#endif /* MADS_NEBULAR_SCENES7_H */ diff --git a/engines/mads/nebular/nebular_scenes8.cpp b/engines/mads/nebular/nebular_scenes8.cpp new file mode 100644 index 0000000000..c0f24a78fc --- /dev/null +++ b/engines/mads/nebular/nebular_scenes8.cpp @@ -0,0 +1,1524 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" +#include "mads/nebular/nebular_scenes8.h" + +namespace MADS { + +namespace Nebular { + +void Scene8xx::setPlayerSpritesPrefix() { + _vm->_sound->command(5); + if ((_globals[kFromCockpit] && !_globals[kExitShip]) || + _scene->_nextSceneId == 804 || _scene->_nextSceneId == 805 || + _scene->_nextSceneId == 808 || _scene->_nextSceneId == 810) { + _game._player._spritesPrefix = ""; + } else + _game._player._spritesPrefix = _globals[kSexOfRex] == SEX_FEMALE ? "ROX" : "RXM"; + + _vm->_palette->setEntry(16, 0x0A, 0x3F, 0x3F); + _vm->_palette->setEntry(17, 0x0A, 0x2D, 0x2D); +} + +void Scene8xx::setAAName() { + _game._aaName = Resources::formatAAName(5); +} + +void Scene8xx::sceneEntrySound() { + if (!_vm->_musicFlag) + _vm->_sound->command(2); + else { + switch (_scene->_nextSceneId) { + case 801: + case 802: + case 803: + case 804: + case 806: + case 807: + case 808: + _vm->_sound->command(20); + break; + + case 805: + _vm->_sound->command(23); + break; + + case 810: + _vm->_sound->command(10); + break; + + default: + break; + } + } +} + +/*------------------------------------------------------------------------*/ + +Scene801::Scene801(MADSEngine *vm) : Scene8xx(vm) { + _walkThroughDoor = false; +} + +void Scene801::synchronize(Common::Serializer &s) { + Scene8xx::synchronize(s); + + s.syncAsByte(_walkThroughDoor); +} + +void Scene801::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene801::enter() { + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('x', 2)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('x', 3)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('a', -1)); + + if (_scene->_priorSceneId != 802) { + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 13); + } + + if ((_globals[kCameFromCut]) && (_globals[kCutX] != 0)) { + _game._player._playerPos = Common::Point(_globals[kCutX], _globals[kCutY]); + _game._player._facing = (Facing)_globals[kCutFacing]; + _globals[kCutX] = 0; + _globals[kCameFromCut] = false; + _globals[kReturnFromCut] = false; + _globals[kBeamIsUp] = false; + _globals[kForceBeamDown] = false; + _globals[kDontRepeat] = false; + } else if (_scene->_priorSceneId == 808) { + _game._player._playerPos = Common::Point(148, 110); + _game._player._facing = FACING_NORTH; + } else if (_scene->_priorSceneId == 802) { + _game._player._playerPos = Common::Point(307, 111); + _game._player.walk(Common::Point(270, 118), FACING_WEST); + _game._player._visible = true; + } else if ((_scene->_priorSceneId != -2) && !_globals[kTeleporterCommand]) { + _game._player._playerPos = Common::Point(8, 117); + _game._player.walk(Common::Point(41, 115), FACING_EAST); + _game._player._visible = true; + } + + _globals[kBetweenRooms] = false; + + if (_globals[kTeleporterCommand]) { + _game._player._stepEnabled = false; + switch (_globals[kTeleporterCommand]) { + case 1: + _game._player._playerPos = Common::Point(8, 117); + _globals[kTeleporterUnderstood] = true; + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 1, 13); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 75); + _vm->_sound->command(30); + break; + + case 2: + _game._player._playerPos = Common::Point(8, 117); + _globals[kTeleporterUnderstood] = true; + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 1, 13); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 8090); + _vm->_sound->command(30); + break; + + case 3: + case 4: + _game._player._playerPos = Common::Point(8, 117); + _game._player.walk(Common::Point(41, 115), FACING_EAST); + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + _globals[kTeleporterCommand] = 0; + } + + _walkThroughDoor = false; + if (_scene->_priorSceneId == 802) { + _game._player._stepEnabled = false; + _walkThroughDoor = true; + } + + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 11, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], -1, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 14); + + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 9, 0, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], -1, -2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 14); + + sceneEntrySound(); +} + +void Scene801::step() { + if (_game._trigger == 75) { + if (_globals[kSexOfRex] == REX_FEMALE) { + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 8); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 140); + } else { + _game._player._stepEnabled = true; + _game._player._visible = true; + _game._player._playerPos = Common::Point(8, 117); + _game._player.walk(Common::Point(41, 115), FACING_EAST); + } + } + + if (_game._trigger == 140) { + _vm->_sound->command(27); + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, 8); + _scene->_sequences.addTimer(100, 141); + } + + if (_game._trigger == 141) { + _scene->_reloadSceneFlag = true; + _scene->_nextSceneId = _scene->_priorSceneId; + _globals[kTeleporterCommand] = 0; + } + + if (_game._trigger == 80) { + _globals[kTeleporterCommand] = 1; + _scene->_nextSceneId = _globals[kTeleporterDestination]; + _scene->_reloadSceneFlag = true; + } + + if (_walkThroughDoor && (_game._player._playerPos == Common::Point(270, 118))) { + _game._player._stepEnabled = false; + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 4, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 10); + _walkThroughDoor = false; + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 120); + } + + if (_game._trigger == 120) { + _vm->_sound->command(12); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 10); + _game._player._stepEnabled = true; + } + + if (_game._trigger == 90) { + _game._player.walk(Common::Point(307, 111), FACING_EAST); + _scene->_sequences.addTimer(80, 130); + } + + if (_game._trigger == 130) { + _vm->_sound->command(12); + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 4, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 10); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 110); + } + + if (_game._trigger == 110) { + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 10); + _scene->_nextSceneId = 802; + } +} + +void Scene801::preActions() { + if (_action.isAction(VERB_LOOK, NOUN_CONTROL_PANEL)) { + _game._player.walk(Common::Point(148, 110), FACING_NORTH); + _game._player._needToWalk = true; + _game._player._readyToWalk = true; + } + + if (_action.isAction(VERB_WALK_INSIDE, NOUN_TELEPORTER) && _globals[kBeamIsUp]) { + _globals[kCutX] = _game._player._playerPos.x; + _globals[kCutY] = _game._player._playerPos.y; + _globals[kCutFacing] = _game._player._facing; + _globals[kForceBeamDown] = true; + _globals[kDontRepeat] = true; + _scene->_nextSceneId = 803; + } +} + +void Scene801::actions() { + if (_action.isAction(VERB_LOOK, NOUN_CONTROL_PANEL)) + _scene->_nextSceneId = 808; + else if (_action.isAction(VERB_WALK_INSIDE, NOUN_TELEPORTER)) { + _game._player._stepEnabled = false; + _game._player._visible = false; + _scene->_nextSceneId = 807; + } else if (_action.isAction(VERB_WALK_THROUGH, NOUN_DOOR) && (_game._player._playerPos == Common::Point(270, 118))) { + _game._player._stepEnabled = false; + _game._player._facing = FACING_EAST; + _game._player.selectSeries(); + _globals[kBetweenRooms] = true; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 4, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 90); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 5); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 13); + _vm->_sound->command(11); + } else if (_action.isAction(VERB_LOOK, NOUN_CEILING)) + _vm->_dialogs->show(80110); + else if (_action.isAction(VERB_LOOK, NOUN_MONITOR)) + _vm->_dialogs->show(80111); + else if (_action.isAction(VERB_LOOK, NOUN_TELEPORTER)) + _vm->_dialogs->show(80112); + else if (_action.isAction(VERB_LOOK, NOUN_EQUIPMENT) || _action._lookFlag) + _vm->_dialogs->show(80113); + else if (_action.isAction(VERB_LOOK, NOUN_SPEAKER)) + _vm->_dialogs->show(80114); + else if (_action.isAction(VERB_LOOK, NOUN_EYE_CHART)) + _vm->_dialogs->show(80115); + else if (_action.isAction(VERB_LOOK, NOUN_WALL)) + _vm->_dialogs->show(80116); + else if (_action.isAction(VERB_LOOK, NOUN_DOOR)) + _vm->_dialogs->show(80117); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene802::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_SHIELD_MODULATOR); + _scene->addActiveVocab(VERB_WALKTO); + _scene->addActiveVocab(NOUN_REMOTE); +} + +void Scene802::enter() { + _globals._spriteIndexes[2] = _scene->_sprites.addSprites("*RXMRC_8"); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('f', 2)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('f', 0)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('f', 1)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites("*RXMBD_8"); + _globals[kBetweenRooms] = false; + + if ((_globals[kCameFromCut]) && (_globals[kCutX] != 0)) { + _game._player._playerPos.x = _globals[kCutX]; + _game._player._playerPos.y = _globals[kCutY]; + _game._player._facing = (Facing)_globals[kCutFacing]; + _globals[kCutX] = 0; + _globals[kCameFromCut] = false; + _globals[kReturnFromCut] = false; + _globals[kBeamIsUp] = false; + _globals[kForceBeamDown] = false; + _globals[kDontRepeat] = false; + _globals[kAntigravClock] = _scene->_frameStartTime; + } else if (_scene->_priorSceneId == 801) { + _game._player._playerPos = Common::Point(15, 129); + _game._player._facing = FACING_EAST; + } else if (_scene->_priorSceneId == 803) { + _game._player._playerPos = Common::Point(303, 119); + _game._player._facing = FACING_WEST; + + } else if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(15, 129); + _game._player._facing = FACING_EAST; + } + + _game._player._visible = true; + + + + if (_globals[kHasWatchedAntigrav] && !_globals[kRemoteSequenceRan]) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _scene->_sequences.addTimer(200, 70); + } + + if ((_globals[kRemoteOnGround]) && (!_game._objects.isInInventory(OBJ_REMOTE))) { + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 8); + int idx = _scene->_dynamicHotspots.add(NOUN_REMOTE, 0xD,_globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(107, 99), FACING_NORTH); + } + + if (!_game._objects.isInInventory(OBJ_SHIELD_MODULATOR) && !_globals[kShieldModInstalled]) { + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 8); + int idx = _scene->_dynamicHotspots.add(NOUN_SHIELD_MODULATOR, 0xD, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(93, 97), FACING_NORTH); + } + sceneEntrySound(); +} + +void Scene802::step() { + if (_game._trigger == 70) { + _game._player._stepEnabled = false; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[3], 1, 19); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_SPRITE, 4, 72); + } + + if (_game._trigger == 71) { + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 8); + int idx = _scene->_dynamicHotspots.add(NOUN_REMOTE, 0xD, _globals._sequenceIndexes[4], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(107, 99), FACING_NORTH); + + _globals[kRemoteSequenceRan] = true; + _globals[kRemoteOnGround] = true; + _game._player._stepEnabled = true; + } + + if (_game._trigger == 72) + _vm->_sound->command(13); +} + +void Scene802::preActions() { + if (_action.isAction(VERB_WALK_TOWARDS, NOUN_BUILDING_TO_WEST)) + _game._player._walkOffScreenSceneId = 801; + + if (_action.isAction(VERB_WALK_DOWN, NOUN_PATH_TO_EAST)) { + _game._player._walkOffScreenSceneId = 803; + _globals[kForceBeamDown] = false; + } + + if (_action.isAction(VERB_TAKE, NOUN_SHIP)) + _game._player._needToWalk = false; +} + +void Scene802::actions() { + if (_action.isAction(VERB_TAKE, NOUN_SHIELD_MODULATOR) && !_game._objects.isInInventory(OBJ_SHIELD_MODULATOR)) { + switch (_game._trigger) { + case (0): + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], true, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], 1, 2); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[2]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_SPRITE, 2, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _vm->_sound->command(9); + break; + + case 2: + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._visible = true; + _scene->_sequences.addTimer(20, 3); + break; + + case 3: + _game._player._stepEnabled = true; + _game._objects.addToInventory(OBJ_SHIELD_MODULATOR); + _vm->_dialogs->showItem(OBJ_SHIELD_MODULATOR, 80215); + break; + + default: + break; + } + } else if ((_action.isAction(VERB_TAKE, NOUN_REMOTE)) && (!_game._objects.isInInventory(OBJ_REMOTE))) { + switch (_game._trigger) { + case (0): + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[5] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[5], true, 7, 2, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 4); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[5]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_SPRITE, 4, 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 2); + break; + + case 1: + _scene->_sequences.remove(_globals._sequenceIndexes[4]); + _vm->_sound->command(9); + _globals[kRemoteOnGround] = false; + break; + + case 2: + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._visible = true; + _scene->_sequences.addTimer(20, 3); + break; + + case 3: + _game._player._stepEnabled = true; + _game._objects.addToInventory(OBJ_REMOTE); + _vm->_dialogs->showItem(OBJ_REMOTE, 80223); + break; + + default: + break; + } + } else if (!_globals[kRemoteOnGround] && (_game._objects.isInInventory(OBJ_SHIELD_MODULATOR) || _globals[kShieldModInstalled]) + && (_action.isAction(VERB_LOOK, NOUN_LAUNCH_PAD) || _action._lookFlag)) + _vm->_dialogs->show(80210); + else if (!_globals[kRemoteOnGround]&& !_game._objects.isInInventory(OBJ_SHIELD_MODULATOR) && !_globals[kShieldModInstalled] + && (_action.isAction(VERB_LOOK, NOUN_LAUNCH_PAD) || _action._lookFlag)) + _vm->_dialogs->show(80211); + else if (_globals[kRemoteOnGround] && !_game._objects.isInInventory(OBJ_SHIELD_MODULATOR) && !_globals[kShieldModInstalled] + && (_action.isAction(VERB_LOOK, NOUN_LAUNCH_PAD) || _action._lookFlag)) + _vm->_dialogs->show(80213); + else if (_globals[kRemoteOnGround] && (_game._objects.isInInventory(OBJ_SHIELD_MODULATOR) || _globals[kShieldModInstalled]) + && (_action.isAction(VERB_LOOK, NOUN_LAUNCH_PAD) || _action._lookFlag)) + _vm->_dialogs->show(80212); + else if (!_game._objects.isInInventory(OBJ_SHIELD_MODULATOR) && !_globals[kShieldModInstalled] && _action.isAction(VERB_LOOK, NOUN_SHIELD_MODULATOR)) + _vm->_dialogs->show(80214); + else if (_globals[kRemoteOnGround] && _action.isAction(VERB_LOOK, NOUN_REMOTE)) + _vm->_dialogs->show(80216); + else if (_action.isAction(VERB_LOOK, NOUN_SHIP)) { + if ((!_game._objects.isInInventory(OBJ_SHIELD_MODULATOR)) && (!_globals[kShieldModInstalled])) + _vm->_dialogs->show(80218); + else + _vm->_dialogs->show(80217); + } else if (_action.isAction(VERB_LOOK, NOUN_BUSHES)) + _vm->_dialogs->show(80219); + else if (_action.isAction(VERB_LOOK, NOUN_PATH_TO_EAST)) + _vm->_dialogs->show(80220); + else if (_action.isAction(VERB_LOOK, NOUN_SKY)) + _vm->_dialogs->show(80221); + else if (_action.isAction(VERB_TAKE, NOUN_SHIP)) + _vm->_dialogs->show(80222); + else if (_action.isAction(VERB_LOOK, NOUN_TREE) || _action.isAction(VERB_LOOK, NOUN_TREES)) + _vm->_dialogs->show(80224); + else if (_action.isAction(VERB_LOOK, NOUN_BUILDING_TO_WEST)) + _vm->_dialogs->show(80225); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene803::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_GUTS); + _scene->addActiveVocab(VERB_WALKTO); + + if ((!_globals[kFromCockpit] && _globals[kReturnFromCut] && !_globals[kBeamIsUp]) + || (_globals[kFromCockpit] && !_globals[kExitShip])) { + _game._player._spritesPrefix = ""; + _game._player._spritesChanged = true; + } +} + +void Scene803::enter() { + _globals[kBetweenRooms] = false; + _game._player._visible = false; + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('f', 1)); + _globals._spriteIndexes[9] = _scene->_sprites.addSprites("*RXMBD_2"); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('d', 1)); + + _game.loadQuoteSet(0x31B, 0x31C, 0x31D, 0x31E, 0x31F, 0x320, 0x321, 0x322, 0); + + if (_globals[kHoppyDead]) { + _globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('e', 1)); + _globals._sequenceIndexes[7] = _scene->_sequences.startCycle(_globals._spriteIndexes[7], false, 1); + int idx = _scene->_dynamicHotspots.add(NOUN_GUTS, 0xD, _globals._sequenceIndexes[7], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(66, 123), FACING_SOUTH); + } + + if (!_globals[kBeamIsUp] && !_globals[kReturnFromCut] && (!_globals[kFromCockpit] || _globals[kExitShip])) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 2, 2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + } + + if (!_globals[kFromCockpit]) { + if (!_globals[kReturnFromCut]) { + if (_scene->_priorSceneId != -2) { + _game._player._playerPos = Common::Point(15, 130); + _game._player._facing = FACING_EAST; + } + _game._player._visible = true; + } else if (!_globals[kBeamIsUp]){ + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('a', 3)); + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('a', 2)); + _game._player._visible = false; + _game._player._stepEnabled = false; + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 15); + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 8, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 80); + _vm->_sound->command(14); + } + + if (_globals[kBeamIsUp] && !_globals[kReturnFromCut]){ + if (_globals[kForceBeamDown]) + _game._player._visible = false; + else + _game._player._visible = true; + + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('b', 1)); + _vm->_sound->command(15); + _game._player._stepEnabled = false; + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 1, 6); + _scene->_sequences.setDepth(_globals._sequenceIndexes[5], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5], SEQUENCE_TRIGGER_EXPIRE, 0, 100); + } + } else if (!_globals[kExitShip]) { + if (!_globals[kBeamIsUp]) { + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _game._player._visible = false; + _game._player._stepEnabled = false; + _globals._sequenceIndexes[3] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[3], false, 8, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[3], SEQUENCE_TRIGGER_EXPIRE, 0, 130); + _vm->_sound->command(14); + } else { + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('c', 1)); + _game._player._visible = false; + _game._player._stepEnabled = false; + _globals._sequenceIndexes[8] = _scene->_sequences.startCycle(_globals._spriteIndexes[8], false, 1); + _globals._sequenceIndexes[8] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[8], false, 8, 1, 0, 0); + _scene->_sequences.setDepth(_globals._sequenceIndexes[8], 1); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[8], SEQUENCE_TRIGGER_EXPIRE, 0, 140); + } + } else { + _game._player._stepEnabled = false; + _game._player._playerPos = Common::Point(197, 96); + _game._player._facing = FACING_SOUTHWEST; + _game._player._visible = true; + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('d', 1)); + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, 19); + _scene->_sequences.addTimer(1, 150); + } + + sceneEntrySound(); +} + +void Scene803::step() { + if (_game._trigger == 120) { + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, 19); + _scene->_nextSceneId = 804; + } + + if (_game._trigger == 100) { + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], 2, 2); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 1); + if (!_globals[kHoppyDead]) { + _globals._sequenceIndexes[5] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[5], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[5], 7, 12); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[5],SEQUENCE_TRIGGER_EXPIRE, 0, 101); + } else { + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, -2); + int idx = _scene->_dynamicHotspots.add(NOUN_GUTS, 0xD, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(66, 123), FACING_SOUTH); + _vm->_sound->command(16); + _globals[kCameFromCut] = true; + _globals[kBeamIsUp] = false; + _globals[kReturnFromCut] = false; + _globals[kDontRepeat] = false; + _globals[kHoppyDead] = true; + _globals[kHasWatchedAntigrav] = true; + + if (_globals[kForceBeamDown]) + _scene->_nextSceneId = _scene->_priorSceneId; + else + _game._player._stepEnabled = true; + } + } + + if (_game._trigger == 101) { + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], false, -2); + int idx = _scene->_dynamicHotspots.add(NOUN_GUTS, 0xD, _globals._sequenceIndexes[5], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(66, 123), FACING_SOUTH); + _vm->_sound->command(16); + _globals[kCameFromCut] = true; + _globals[kBeamIsUp] = false; + _globals[kReturnFromCut] = false; + _globals[kDontRepeat] = false; + _globals[kHoppyDead] = true; + _globals[kHasWatchedAntigrav] = true; + + if (_globals[kForceBeamDown]) + _scene->_nextSceneId = _scene->_priorSceneId; + else + _game._player._stepEnabled = true; + } + + if (_game._trigger == 80) { + if (!_globals[kHoppyDead]) + _scene->_sequences.addTimer(350, 70); + + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 12, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 1, 3); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 90); + } + + if (_game._trigger == 70) { + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 8, 1, 0, 0); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + _vm->_sound->command(31); + } + + if (_game._trigger == 71) + _scene->_sequences.addTimer(200, 110); + + if (_game._trigger == 90) { + int syncIdx = _globals._sequenceIndexes[4]; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 15, 0, 0, 0); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[4], syncIdx); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[4], 4, 9); + if (_globals[kHoppyDead]) + _scene->_sequences.addTimer(200, 110); + } + + if (_game._trigger == 110) + _scene->_nextSceneId = 808; + + if (_game._trigger == 130) { + _globals[kBeamIsUp] = true; + _scene->_nextSceneId = 804; + } + + if (_game._trigger == 140) { + if (!_globals[kWindowFixed]) { + _scene->_nextSceneId = 810; + _globals[kInSpace] = true; + } else { + if (!_globals[kShieldModInstalled]) + _game._winStatus = 1; + else if (!_globals[kTargetModInstalled]) + _game._winStatus = 2; + else + _game._winStatus = 3; + + _vm->quitGame(); + } + } + + if (_game._trigger == 150) { + _scene->_sequences.remove(_globals._sequenceIndexes[6]); + _vm->_sound->command(18); + _globals._sequenceIndexes[6] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[6], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 1, 19); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 151); + } + + if (_game._trigger == 151) { + _globals[kBeamIsUp] = false; + _globals[kFromCockpit] = false; + _globals[kExitShip] = false; + _game._player._stepEnabled = true; + } +} + +void Scene803::preActions() { + if (_action.isAction(VERB_WALK_DOWN, NOUN_PATH_TO_WEST)) + _game._player._walkOffScreenSceneId = 802; + + if (_action.isAction(VERB_TAKE, NOUN_SHIP)) + _game._player._needToWalk = false; +} + +void Scene803::actions() { + if (_action.isAction(VERB_TAKE, NOUN_GUTS)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _game._player._visible = false; + _globals._sequenceIndexes[9] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[9], true, 6, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[9], 1, 4); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[9]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 160); + break; + + case 160: { + int syncIdx = _globals._sequenceIndexes[9]; + _globals._sequenceIndexes[9] = _scene->_sequences.startCycle(_globals._spriteIndexes[9], false, 4); + _scene->_sequences.updateTimeout(_globals._sequenceIndexes[9], syncIdx); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[9]); + _scene->_sequences.addTimer(60, 161); + } + break; + + case 161: { + int quoteId = 0x31A + _vm->getRandomNumber(1, 8); + _scene->_kernelMessages.add(Common::Point(64, 67), 0x1110, 32, 0, 80, _game.getQuote(quoteId)); + _scene->_sequences.addTimer(60, 162); + } + break; + + case 162: + _scene->_sequences.remove(_globals._sequenceIndexes[9]); + _globals._sequenceIndexes[9] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[9], true, 6, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[9], 1, 4); + _scene->_sequences.setMsgLayout(_globals._sequenceIndexes[9]); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[9], SEQUENCE_TRIGGER_EXPIRE, 0, 163); + break; + + case 163: + _game._player._priorTimer = _scene->_frameStartTime + _game._player._ticksAmount; + _game._player._visible = true; + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_ENTER, NOUN_SHIP)) { + _vm->_sound->command(17); + _game._player._stepEnabled = false; + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _globals._sequenceIndexes[6] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[6], false, 8, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[6], 1, 19); + _scene->_sequences.setDepth(_globals._sequenceIndexes[6], 4); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[6], SEQUENCE_TRIGGER_EXPIRE, 0, 120); + _globals[kBeamIsUp] = false; + } else if (_action.isAction(VERB_LOOK, NOUN_LAUNCH_PAD)) + _vm->_dialogs->show(80310); + else if (_action._lookFlag) + _vm->_dialogs->show(80310); + else if (_action.isAction(VERB_LOOK, NOUN_PAD_TO_WEST)) + _vm->_dialogs->show(80311); + else if (_action.isAction(VERB_LOOK, NOUN_GUTS)) { + if (_game._storyMode == STORYMODE_NICE) + _vm->_dialogs->show(80312); + else + _vm->_dialogs->show(80313); + } else if (_action.isAction(VERB_LOOK, NOUN_BUSHES)) + _vm->_dialogs->show(80315); + else if (_action.isAction(VERB_LOOK, NOUN_SHIP)) + _vm->_dialogs->show(80317); + else if (_action.isAction(VERB_LOOK, NOUN_TOWER)) + _vm->_dialogs->show(80318); + else if (_action.isAction(VERB_LOOK, NOUN_TREE) || _action.isAction(VERB_LOOK, NOUN_TREES)) + _vm->_dialogs->show(80319); + else if (_action.isAction(VERB_LOOK, NOUN_SKY)) + _vm->_dialogs->show(80320); + else if (_action.isAction(VERB_TAKE, NOUN_SHIP)) + _vm->_dialogs->show(80321); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene804::Scene804(MADSEngine *vm) : Scene8xx(vm) { + _messWithThrottle = false; + _movingThrottle = false; + _throttleGone = false; + _dontPullThrottleAgain = false; + _pullThrottleReally = false; + _alreadyOrgan = false; + _alreadyPop = false; + + _throttleCounter = 0; + _resetFrame = -1; +} + +void Scene804::synchronize(Common::Serializer &s) { + Scene8xx::synchronize(s); + + s.syncAsByte(_messWithThrottle); + s.syncAsByte(_movingThrottle); + s.syncAsByte(_throttleGone); + s.syncAsByte(_dontPullThrottleAgain); + s.syncAsByte(_pullThrottleReally); + s.syncAsByte(_alreadyOrgan); + s.syncAsByte(_alreadyPop); + + s.syncAsSint16LE(_resetFrame); + s.syncAsUint32LE(_throttleCounter); +} + +void Scene804::setup() { + Scene8xx::setPlayerSpritesPrefix(); + Scene8xx::setAAName(); +} + +void Scene804::enter() { + _messWithThrottle = false; + _throttleCounter = 0; + _movingThrottle = false; + _throttleGone = false; + _dontPullThrottleAgain = false; + _resetFrame = -1; + _pullThrottleReally = false; + _alreadyOrgan = false; + _alreadyPop = false; + + + if (_globals[kCopyProtectFailed]) { + // Copy protection failed + _globals[kInSpace] = true; + _globals[kWindowFixed] = 0; + } + + _globals._spriteIndexes[4] = _scene->_sprites.addSprites(formAnimName('x', 0)); + _globals._spriteIndexes[5] = _scene->_sprites.addSprites(formAnimName('x', 1)); + _globals._spriteIndexes[6] = _scene->_sprites.addSprites(formAnimName('x', 2)); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('x', 3)); + _globals._spriteIndexes[7] = _scene->_sprites.addSprites(formAnimName('x', 4)); + _globals._spriteIndexes[8] = _scene->_sprites.addSprites(formAnimName('f', 1)); + + _game.loadQuoteSet(791, 0); + + if (_globals[kInSpace]) { + if (_globals[kWindowFixed]) { + _globals._sequenceIndexes[5] = _scene->_sequences.startCycle(_globals._spriteIndexes[5], 0, 1); + _scene->_sequences.addTimer(60, 100); + } else { + _globals._sequenceIndexes[6] = _scene->_sequences.startCycle(_globals._spriteIndexes[6], false, 1); + _globals._sequenceIndexes[7] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[7], false, 4, 0, 0, 0); + _scene->_sequences.addTimer(160, 70); + _game._player._stepEnabled = false; + } + } else { + if (_globals[kBeamIsUp] == 0) + _globals._sequenceIndexes[8] = _scene->_sequences.startCycle(_globals._spriteIndexes[8], false, 1); + + if (_globals[kWindowFixed] == 0) + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(133, 139)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 8); + } + + _scene->loadAnimation(Resources::formatName(804, 'r', 1, EXT_AA, "")); + + Scene8xx::sceneEntrySound(); + + if (_globals[kInSpace] && !_globals[kWindowFixed]) { + _scene->_userInterface.setup(kInputLimitedSentences); + _vm->_sound->command(19); + } +} + +void Scene804::step() { + if (!_messWithThrottle) { + + if ((_throttleGone) && (_movingThrottle) && (_scene->_activeAnimation->getCurrentFrame() == 39)) { + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle + (_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setPosition(_globals._sequenceIndexes[1], Common::Point(133, 139)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 8); + _throttleGone = false; + } + + if ((_movingThrottle) && (_scene->_activeAnimation->getCurrentFrame() == 42)) { + _resetFrame = 0; + _movingThrottle = false; + } + + if (_game._trigger == 70) { + _resetFrame = 42; + } + + if (_scene->_activeAnimation->getCurrentFrame() == 65) + _scene->_sequences.remove(_globals._sequenceIndexes[7]); + + switch (_game._storyMode) { + case STORYMODE_NAUGHTY: + if (_scene->_activeAnimation->getCurrentFrame() == 81) { + _resetFrame = 80; + _globals[kInSpace] = false; + _globals[kBeamIsUp] = true; + + assert(!_globals[kCopyProtectFailed]); + _game._winStatus = 4; + _vm->quitGame(); + } + break; + + case STORYMODE_NICE: + if (_scene->_activeAnimation->getCurrentFrame() == 68) { + _resetFrame = 66; + _globals[kInSpace] = false; + _globals[kBeamIsUp] = true; + + assert(!_globals[kCopyProtectFailed]); + _game._winStatus = 4; + _vm->quitGame(); + } + } + + if (_scene->_activeAnimation->getCurrentFrame() == 34) { + _resetFrame = 36; + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + } + + if (_scene->_activeAnimation->getCurrentFrame() == 37) { + _resetFrame = 36; + if (!_dontPullThrottleAgain) { + _dontPullThrottleAgain = true; + _scene->_sequences.addTimer(60, 80); + } + } + + if (_game._trigger == 80) { + _scene->_nextSceneId = 803; + } + + if ((_scene->_activeAnimation->getCurrentFrame() == 7) && (!_globals[kWindowFixed])) { + _globals._sequenceIndexes[4] = _scene->_sequences.startCycle(_globals._spriteIndexes[4], false, 1); + _scene->_sequences.addTimer(20, 110); + _globals[kWindowFixed] = true; + } + + if (_scene->_activeAnimation->getCurrentFrame() == 10) { + _resetFrame = 0; + _game._player._stepEnabled = true; + _game._objects.setRoom(OBJ_POLYCEMENT, NOWHERE); + } + + if (_scene->_activeAnimation->getCurrentFrame() == 1) { + int randomVal = _vm->getRandomNumber(29) + 1; + switch (randomVal) { + case 1: + _resetFrame = 25; + break; + case 2: + _resetFrame = 27; + break; + case 3: + _resetFrame = 29; + break; + default: + _resetFrame = 0; + break; + } + } + + switch (_scene->_activeAnimation->getCurrentFrame()) { + case 26: + case 28: + case 31: + _resetFrame = 0; + break; + } + } else { + if ((_scene->_activeAnimation->getCurrentFrame() == 36) && (!_throttleGone)) { + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _throttleGone = true; + } + + if (_scene->_activeAnimation->getCurrentFrame() == 39) { + _movingThrottle = false; + switch (_throttleCounter) { + case 1: + break; + case 3: + _scene->_sequences.addTimer(130, 120); + break; + } + } + + if (!_movingThrottle) { + ++_throttleCounter; + _movingThrottle = true; + if (_throttleCounter < 4) { + _resetFrame = 34; + } else { + _messWithThrottle = false; + _throttleCounter = 0; + _game._player._stepEnabled = true; + } + } + } + + if (_game._trigger == 120) { + _vm->_dialogs->show(80422); + } + + if (_game._trigger == 110) { + _vm->_dialogs->show(80426); + } + + if (_pullThrottleReally) { + _resetFrame = 32; + _pullThrottleReally = false; + } + + if (_resetFrame >= 0) { + if (_resetFrame != _scene->_activeAnimation->getCurrentFrame()) { + _scene->_activeAnimation->setCurrentFrame(_resetFrame); + _resetFrame = -1; + } + } + + if (_game._trigger == 90) { + _scene->_nextSceneId = 803; + } + + if ((_scene->_activeAnimation->getCurrentFrame() == 72) && !_alreadyPop) { + _vm->_sound->command(21); + _alreadyPop = true; + } + + if ((_scene->_activeAnimation->getCurrentFrame() == 80) && !_alreadyOrgan) { + _vm->_sound->command(22); + _alreadyOrgan = true; + } +} + +/*------------------------------------------------------------------------*/ + +void Scene805::setup() { + setPlayerSpritesPrefix(); + setAAName(); + _scene->addActiveVocab(NOUN_REMOVE); + _scene->addActiveVocab(NOUN_TARGET_MODULE); + _scene->addActiveVocab(NOUN_SHIELD_MODULATOR); +} + +void Scene805::enter() { + _game._player._visible = false; + _scene->_userInterface.setup(kInputLimitedSentences); + + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('a', 1)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('a', 2)); + + if (_globals[kShieldModInstalled]) { + _scene->_hotspots.activate(OBJ_SHIELD_MODULATOR, false); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 25); + int idx = _scene->_dynamicHotspots.add(NOUN_SHIELD_MODULATOR, 0x476, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(0, 0), FACING_DUMMY); + } + + if (_globals[kTargetModInstalled]) { + _scene->_hotspots.activate(OBJ_TARGET_MODULE, false); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 12); + int idx = _scene->_dynamicHotspots.add(NOUN_TARGET_MODULE, 0x476, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(0, 0), FACING_DUMMY); + } + + sceneEntrySound(); +} + +void Scene805::step() { + if (_game._trigger == 70) { + _scene->_hotspots.activate(OBJ_SHIELD_MODULATOR, false); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 25); + int idx = _scene->_dynamicHotspots.add(NOUN_SHIELD_MODULATOR, 0x476, _globals._sequenceIndexes[1], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(0, 0), FACING_DUMMY); + _globals[kShieldModInstalled] = true; + _game._objects.setRoom(OBJ_SHIELD_MODULATOR, NOWHERE); + _game._player._stepEnabled = true; + _vm->_sound->command(24); + } + + if (_game._trigger == 80) { + _scene->_hotspots.activate(OBJ_TARGET_MODULE, false); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 12); + int idx = _scene->_dynamicHotspots.add(NOUN_TARGET_MODULE, 0x476, _globals._sequenceIndexes[2], Common::Rect(0, 0, 0, 0)); + _scene->_dynamicHotspots.setPosition(idx, Common::Point(0, 0), FACING_DUMMY); + _globals[kTargetModInstalled] = true; + _game._objects.setRoom(OBJ_TARGET_MODULE, NOWHERE); + _game._player._stepEnabled = true; + _vm->_sound->command(24); + } + + if (_game._trigger == 71) { + _scene->_hotspots.activate(OBJ_SHIELD_MODULATOR, true); + _globals[kShieldModInstalled] = false; + _game._objects.addToInventory(OBJ_SHIELD_MODULATOR); + _game._player._stepEnabled = true; + } + + if (_game._trigger == 81) { + _scene->_hotspots.activate(OBJ_TARGET_MODULE, true); + _globals[kTargetModInstalled] = false; + _game._objects.addToInventory(OBJ_TARGET_MODULE); + _game._player._stepEnabled = true; + } +} + +void Scene805::preActions() { + _game._player._needToWalk = false; +} + +void Scene805::actions() { + if (_action.isAction(VERB_EXIT, NOUN_SERVICE_PANEL)) + _scene->_nextSceneId = 804; + else if (_action.isAction(VERB_INSTALL, NOUN_SHIELD_MODULATOR) && _game._objects.isInInventory(OBJ_SHIELD_MODULATOR)) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _globals._sequenceIndexes[1] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[1], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], -1, -2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 70); + _game._player._stepEnabled = false; + } else if (_action.isAction(VERB_INSTALL, NOUN_TARGET_MODULE) && _game._objects.isInInventory(OBJ_TARGET_MODULE)) { + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _globals._sequenceIndexes[2] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], -1, -2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 80); + _game._player._stepEnabled = false; + } else if (_action.isAction(VERB_REMOVE, NOUN_SHIELD_MODULATOR) && _globals[kShieldModInstalled]) { + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _globals._sequenceIndexes[1] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[1], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[1], -1, -2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[1], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + _game._player._stepEnabled = false; + } else if (_action.isAction(VERB_REMOVE, NOUN_TARGET_MODULE) && _globals[kTargetModInstalled]) { + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _game._triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _globals._sequenceIndexes[2] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[2], false, 7, 1, 0, 0); + _scene->_sequences.setAnimRange(_globals._sequenceIndexes[2], -1, -2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[2], SEQUENCE_TRIGGER_EXPIRE, 0, 81); + _game._player._stepEnabled = false; + } else if (_action.isAction(VERB_INSTALL, NOUN_SHIELD_MODULATOR) && !_game._objects.isInInventory(OBJ_SHIELD_MODULATOR)) + _vm->_dialogs->show(80511); + else if (_action.isAction(VERB_INSTALL, NOUN_TARGET_MODULE) && !_game._objects.isInInventory(OBJ_TARGET_MODULE)) + _vm->_dialogs->show(80510); + else if (_action.isAction(VERB_REMOVE, NOUN_LIFE_SUPPORT_MODULE)) + _vm->_dialogs->show(80512); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +void Scene807::setup() { + _game._player._spritesPrefix = ""; + // The original was calling Scene8xx::setAAName() + _game._aaName = Resources::formatAAName(5); +} + +void Scene807::enter() { + if (_globals[kSexOfRex] == REX_FEMALE) + _handSpriteId = _scene->_sprites.addSprites("*ROXHAND"); + else + _handSpriteId = _scene->_sprites.addSprites("*REXHAND"); + + teleporterEnter(); + + // The original uses Scene8xx::SceneEntrySound() + if (!_vm->_musicFlag) + _vm->_sound->command(2); + else + _vm->_sound->command(20); +} + +void Scene807::step() { + teleporterStep(); +} + +void Scene807::actions() { + if (teleporterActions()) { + _action._inProgress = false; + return; + } + + if (_action.isAction(VERB_LOOK, NOUN_VIEWPORT)) + _vm->_dialogs->show(80710); + else if (_action.isAction(VERB_PEER_THROUGH, NOUN_VIEWPORT)) + _vm->_dialogs->show(80710); + else if (_action.isAction(VERB_LOOK, NOUN_KEYPAD) && _action.isAction(VERB_INSPECT, NOUN_KEYPAD)) + _vm->_dialogs->show(80711); + else if (_action.isAction(VERB_LOOK, NOUN_DISPLAY)) + _vm->_dialogs->show(80712); + else if (_action.isAction(VERB_LOOK, NOUN_1_KEY) || _action.isAction(VERB_LOOK, NOUN_2_KEY) + || _action.isAction(VERB_LOOK, NOUN_3_KEY) || _action.isAction(VERB_LOOK, NOUN_4_KEY) + || _action.isAction(VERB_LOOK, NOUN_5_KEY) || _action.isAction(VERB_LOOK, NOUN_6_KEY) + || _action.isAction(VERB_LOOK, NOUN_7_KEY) || _action.isAction(VERB_LOOK, NOUN_8_KEY) + || _action.isAction(VERB_LOOK, NOUN_9_KEY) || _action.isAction(VERB_LOOK, NOUN_0_KEY) + || _action.isAction(VERB_LOOK, NOUN_SMILE_KEY) || _action.isAction(VERB_LOOK, NOUN_FROWN_KEY)) + _vm->_dialogs->show(80713); + else if (_action.isAction(VERB_LOOK, NOUN_DEVICE) && _action._lookFlag) + _vm->_dialogs->show(80714); + else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene808::Scene808(MADSEngine *vm) : Scene8xx(vm) { + _goingTo803 = false; +} + +void Scene808::synchronize(Common::Serializer &s) { + Scene8xx::synchronize(s); + + s.syncAsByte(_goingTo803); +} + +void Scene808::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene808::enter() { + _scene->_userInterface.setup(kInputLimitedSentences); + + _globals._spriteIndexes[4] = _scene->_sprites.addSprites ("*REXHAND"); + _globals._spriteIndexes[1] = _scene->_sprites.addSprites(formAnimName('b', 0)); + _globals._spriteIndexes[2] = _scene->_sprites.addSprites(formAnimName('b', 1)); + _globals._spriteIndexes[3] = _scene->_sprites.addSprites(formAnimName('b', 2)); + + if (_globals[kTopButtonPushed]) + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + else + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + + _goingTo803 = false; + + if (_globals[kCameFromCut] && _globals[kCutX] != 0) { + _globals[kCutX] = 0; + _globals[kCameFromCut] = false; + _globals[kReturnFromCut] = false; + _globals[kBeamIsUp] = false; + _globals[kForceBeamDown] = false; + _globals[kDontRepeat] = false; + } else if ((_scene->_priorSceneId == 803) && _globals[kReturnFromCut]){ + _globals[kDontRepeat] = false; + _globals[kBeamIsUp] = true; + _globals[kAntigravClock] = _scene->_frameStartTime; + _globals[kAntigravTiming] = _scene->_frameStartTime; + _globals[kForceBeamDown] = false; + _globals[kReturnFromCut] = false; + } + + _globals[kBetweenRooms] = false; + + if (_globals[kBeamIsUp]) { + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 8); + } + + sceneEntrySound(); +} + +void Scene808::actions() { + if (_action.isAction(VERB_PRESS, NOUN_START_BUTTON_2)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 4, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(248, 211)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 70); + break; + + case 70: + if (!_globals[kBeamIsUp] && !_globals[kTopButtonPushed]) { + _globals._sequenceIndexes[3] = _scene->_sequences.startCycle(_globals._spriteIndexes[3], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[3], 8); + _goingTo803 = true; + _vm->_sound->command(20); + _vm->_sound->command(25); + } + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 4, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(248, 211)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 71); + break; + + case 71: + _game._player._stepEnabled = true; + if (_goingTo803 && !_globals[kTopButtonPushed]) { + _goingTo803 = false; + _globals[kReturnFromCut] = true; + _scene->_nextSceneId = 803; + } + break; + + default: + break; + } + } else if (_action.isAction(VERB_PRESS, NOUN_TIMER_BUTTON_2)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 4, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(248, 186)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 90); + break; + case 90: + if (_globals[kTopButtonPushed]) { + _scene->_sequences.remove(_globals._sequenceIndexes[1]); + _globals._sequenceIndexes[2] = _scene->_sequences.startCycle(_globals._spriteIndexes[2], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[2], 8); + _vm->_sound->command(20); + } + _globals[kTopButtonPushed] = false; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 4, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(248, 186)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 91); + break; + + case 91: + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_PRESS, NOUN_REMOTE_BUTTON_2)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _globals._sequenceIndexes[4] = _scene->_sequences.addSpriteCycle(_globals._spriteIndexes[4], false, 4, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(248, 163)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 80); + break; + + case 80: + if (!_globals[kTopButtonPushed]) { + _scene->_sequences.remove(_globals._sequenceIndexes[2]); + _globals._sequenceIndexes[1] = _scene->_sequences.startCycle(_globals._spriteIndexes[1], false, 1); + _scene->_sequences.setDepth(_globals._sequenceIndexes[1], 8); + _vm->_sound->command(20); + } + _globals[kTopButtonPushed] = true; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 4, 1, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(248, 163)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 81); + break; + + case 81: + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_PRESS, NOUN_START_BUTTON_1)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 4, 2, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(168, 211)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 70); + break; + + case 70: + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_PRESS, NOUN_REMOTE_BUTTON_1)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 4, 2, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(172, 163)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 80); + break; + + case 80: + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_PRESS, NOUN_TIMER_BUTTON_1)) { + switch (_game._trigger) { + case 0: + _game._player._stepEnabled = false; + _globals._sequenceIndexes[4] = _scene->_sequences.startReverseCycle(_globals._spriteIndexes[4], false, 4, 2, 0, 0); + _scene->_sequences.setPosition(_globals._sequenceIndexes[4], Common::Point(172, 186)); + _scene->_sequences.setDepth(_globals._sequenceIndexes[4], 2); + _scene->_sequences.addSubEntry(_globals._sequenceIndexes[4], SEQUENCE_TRIGGER_EXPIRE, 0, 90); + break; + + case 90: + _game._player._stepEnabled = true; + break; + + default: + break; + } + } else if (_action.isAction(VERB_EXIT, NOUN_PANEL)) { + _scene->_nextSceneId = 801; + _globals[kBetweenRooms] = true; + } else + return; + + _action._inProgress = false; +} + +/*------------------------------------------------------------------------*/ + +Scene810::Scene810(MADSEngine *vm) : Scene8xx(vm) { + _moveAllowed = false; +} + +void Scene810::synchronize(Common::Serializer &s) { + Scene8xx::synchronize(s); + + s.syncAsByte(_moveAllowed); +} + +void Scene810::setup() { + setPlayerSpritesPrefix(); + setAAName(); +} + +void Scene810::enter() { + _scene->_userInterface.setup(kInputLimitedSentences); + _game._player._visible = false; + _game._player._stepEnabled = false; + _scene->loadAnimation(Resources::formatName(810, 'a', -1, EXT_AA, "")); + _moveAllowed = true; + + sceneEntrySound(); +} + +void Scene810::step() { + if ((_scene->_activeAnimation->getCurrentFrame() == 200) && _moveAllowed) { + _scene->_sequences.addTimer(100, 70); + _moveAllowed = false; + } + + if (_game._trigger == 70) + _scene->_nextSceneId = 804; +} + +/*------------------------------------------------------------------------*/ + +} // End of namespace Nebular +} // End of namespace MADS diff --git a/engines/mads/nebular/nebular_scenes8.h b/engines/mads/nebular/nebular_scenes8.h new file mode 100644 index 0000000000..150951dcaf --- /dev/null +++ b/engines/mads/nebular/nebular_scenes8.h @@ -0,0 +1,165 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_NEBULAR_SCENES8_H +#define MADS_NEBULAR_SCENES8_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/scene.h" +#include "mads/nebular/nebular_scenes.h" + +namespace MADS { + +namespace Nebular { + +class Scene8xx : public NebularScene { +protected: + /** + * Initial setup code shared by several scenes + */ + void setPlayerSpritesPrefix(); + + /** + * Initial setup code shared by several scenes + */ + void setAAName(); + + /** + * Common scene enter code used by multiple scenes + */ + void sceneEntrySound(); +public: + Scene8xx(MADSEngine *vm) : NebularScene(vm) {} +}; + +class Scene801: public Scene8xx{ +private: + bool _walkThroughDoor; + +public: + Scene801(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene802: public Scene8xx{ +public: + Scene802(MADSEngine *vm) : Scene8xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene803: public Scene8xx{ +public: + Scene803(MADSEngine *vm) : Scene8xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene804: public Scene8xx { +private: + bool _messWithThrottle; + bool _movingThrottle; + bool _throttleGone; + bool _dontPullThrottleAgain; + bool _pullThrottleReally; + bool _alreadyOrgan; + bool _alreadyPop; + uint32 _throttleCounter; + int _resetFrame; + +public: + Scene804(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions() {}; +}; + +class Scene805: public Scene8xx{ +public: + Scene805(MADSEngine *vm) : Scene8xx(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void preActions(); + virtual void actions(); +}; + +class Scene807: public SceneTeleporter { +public: + Scene807(MADSEngine *vm) : SceneTeleporter(vm) {} + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions(); +}; + +class Scene808: public Scene8xx{ +private: + bool _goingTo803; + +public: + Scene808(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void actions(); +}; + +class Scene810: public Scene8xx{ +private: + bool _moveAllowed; + +public: + Scene810(MADSEngine *vm); + void synchronize(Common::Serializer &s); + + virtual void setup(); + virtual void enter(); + virtual void step(); + virtual void actions() {}; +}; + +} // End of namespace Nebular +} // End of namespace MADS + +#endif /* MADS_NEBULAR_SCENES8_H */ diff --git a/engines/mads/nebular/sound_nebular.cpp b/engines/mads/nebular/sound_nebular.cpp new file mode 100644 index 0000000000..6bc697459a --- /dev/null +++ b/engines/mads/nebular/sound_nebular.cpp @@ -0,0 +1,3111 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "audio/audiostream.h" +#include "audio/decoders/raw.h" +#include "common/algorithm.h" +#include "common/debug.h" +#include "common/memstream.h" +#include "mads/sound.h" +#include "mads/nebular/sound_nebular.h" + +namespace MADS { + +namespace Nebular { + +bool AdlibChannel::_channelsEnabled; + +AdlibChannel::AdlibChannel() { + _activeCount = 0; + _field1 = 0; + _field2 = 0; + _field3 = 0; + _field4 = 0; + _sampleIndex = 0; + _volume = 0; + _field7 = 0; + _field8 = 0; + _field9 = 0; + _fieldA = 0; + _fieldB = 0; + _fieldC = 0; + _fieldD = 0; + _fieldE = 0; + _ptr1 = nullptr; + _pSrc = nullptr; + _ptr3 = nullptr; + _ptr4 = nullptr; + _field17 = 0; + _field19 = 0; + _soundData = nullptr; + _field1D = 0; + _field1E = 0; + _field1F = 0; + + _field20 = 0; +} + +void AdlibChannel::reset() { + _activeCount = 0; + _field1 = 0; + _field2 = 0; + _field3 = 0; +} + +void AdlibChannel::enable(int flag) { + if (_activeCount) { + _fieldE = flag; + + // WORKAROUND: Original set _soundData pointer to flag. Since this seems + // just intended to invalidate any prior pointer, I've replaced it with + // a simple null pointer + _soundData = nullptr; + } + + _channelsEnabled = true; +} + +void AdlibChannel::setPtr2(byte *pData) { + _pSrc = pData; + _field2 = 0xFF; + _fieldA = 1; + _field9 = 1; +} + +void AdlibChannel::load(byte *pData) { + _ptr1 = _pSrc = _ptr3 = pData; + _ptr4 = _soundData = pData; + _fieldA = 0xFF; + _activeCount = 1; + _fieldD = 64; + _field1 = 0; + _field1F = 0; + _field2 = _field3 = 0; + _volume = _field7 = 0; + _field1D = _field1E = 0; + _fieldE = 0; + _field9 = 0; + _fieldB = 0; + _field17 = 0; + _field19 = 0; +} + +void AdlibChannel::check(byte *nullPtr) { + if (_activeCount && _fieldE) { + if (!_field1E) { + _pSrc = nullPtr; + _fieldE = 0; + } else { + _field2 = 0xFF; + _fieldA = 4; + if (!_field9) + _field9 = 1; + } + } +} + +/*-----------------------------------------------------------------------*/ + +AdlibSample::AdlibSample(Common::SeekableReadStream &s) { + _attackRate = s.readByte(); + _decayRate = s.readByte(); + _sustainLevel = s.readByte(); + _releaseRate = s.readByte(); + _egTyp = s.readByte() != 0; + _ksr = s.readByte() != 0; + _totalLevel = s.readByte(); + _scalingLevel = s.readByte(); + _waveformSelect = s.readByte(); + _freqMultiple = s.readByte(); + _feedback = s.readByte(); + _ampMod = s.readByte() != 0; + _vib = s.readByte(); + _alg = s.readByte(); + _fieldE = s.readByte(); + s.skip(1); + _freqMask = s.readUint16LE(); + _freqBase = s.readUint16LE(); + _field14 = s.readUint16LE(); +} + +/*-----------------------------------------------------------------------*/ + +ASound::ASound(Audio::Mixer *mixer, const Common::String &filename, int dataOffset) { + // Open up the appropriate sound file + if (!_soundFile.open(filename)) + error("Could not open file - %s", filename.c_str()); + + // Initialize fields + _commandParam = 0; + _activeChannelPtr = nullptr; + _samplePtr = nullptr; + _frameCounter = 0; + _isDisabled = false; + _v1 = 0; + _v2 = 0; + _activeChannelNumber = 0; + _freqMask1 = _freqMask2 = 0; + _freqBase1 = _freqBase2 = 0; + _channelNum1 = _channelNum2 = 0; + _v7 = 0; + _v8 = 0; + _v9 = 0; + _v10 = 0; + _pollResult = 0; + _resultFlag = 0; + _nullData[0] = _nullData[1] = 0; + Common::fill(&_ports[0], &_ports[256], 0); + _stateFlag = false; + _activeChannelReg = 0; + _v11 = 0; + _randomSeed = 1234; + _amDep = _vibDep = _splitPoint = true; + + _samplesTillCallback = 0; + _samplesTillCallbackRemainder = 0; + _samplesPerCallback = getRate() / CALLBACKS_PER_SECOND; + _samplesPerCallbackRemainder = getRate() % CALLBACKS_PER_SECOND; + + AdlibChannel::_channelsEnabled = false; + + // Store passed parameters, and setup OPL + _dataOffset = dataOffset; + _mixer = mixer; + _opl = OPL::Config::create(); + assert(_opl); + + _opl->init(getRate()); + _mixer->playStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, + Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true); + + // Initialise the Adlib + adlibInit(); + + // Reset the adlib + command0(); +} + +ASound::~ASound() { + Common::List<CachedDataEntry>::iterator i; + for (i = _dataCache.begin(); i != _dataCache.end(); ++i) + delete[] (*i)._data; + + _mixer->stopHandle(_soundHandle); + delete _opl; +} + +void ASound::adlibInit() { + write(4, 0x60); + write(4, 0x80); + write(2, 0xff); + write(4, 0x21); + write(4, 0x60); + write(4, 0x80); +} + +int ASound::stop() { + command0(); + int result = _pollResult; + _pollResult = 0; + return result; +} + +int ASound::poll() { + // Update any playing sounds + update(); + + // Return result + int result = _pollResult; + _pollResult = 0; + return result; +} + +void ASound::noise() { + int randomVal = getRandomNumber(); + + if (_v1) { + setFrequency(_channelNum1, ((randomVal ^ 0xFFFF) & _freqMask1) + _freqBase1); + } + + if (_v2) { + setFrequency(_channelNum2, (randomVal & _freqMask2) + _freqBase2); + } +} + +void ASound::write(int reg, int val) { + _queue.push(RegisterValue(reg, val)); +} + +int ASound::write2(int state, int reg, int val) { + // TODO: Original has a state parameter, not used when in Adlib mode? + _ports[reg] = val; + write(reg, val); + return state; +} + +void ASound::flush() { + Common::StackLock slock(_driverMutex); + + while (!_queue.empty()) { + RegisterValue v = _queue.pop(); + _opl->writeReg(v._regNum, v._value); + } +} + +void ASound::channelOn(int reg, int volume) { + write2(8, reg, (_ports[reg] & 0xC0) | (volume & 0x3F)); +} + +void ASound::channelOff(int reg) { + write2(8, reg, _ports[reg] | 0x3F); +} + +void ASound::resultCheck() { + if (_resultFlag != 1) { + _resultFlag = 1; + _pollResult = 1; + } +} + +byte *ASound::loadData(int offset, int size) { + // First scan for an existing copy + Common::List<CachedDataEntry>::iterator i; + for (i = _dataCache.begin(); i != _dataCache.end(); ++i) { + CachedDataEntry &e = *i; + if (e._offset == offset) + return e._data; + } + + // No existing entry found, so load up data and store as a new entry + CachedDataEntry rec; + rec._offset = offset; + rec._data = new byte[size]; + _soundFile.seek(_dataOffset + offset); + _soundFile.read(rec._data, size); + _dataCache.push_back(rec); + + // Return the data + return rec._data; +} + +void ASound::playSound(int offset, int size) { + // Load the specified data block + playSoundData(loadData(offset, size)); +} + +void ASound::playSoundData(byte *pData, int startingChannel) { + // Scan for a high level free channel + for (int i = startingChannel; i < ADLIB_CHANNEL_COUNT; ++i) { + if (!_channels[i]._activeCount) { + _channels[i].load(pData); + return; + } + } + + // None found, do a secondary scan for an interruptable channel + for (int i = ADLIB_CHANNEL_COUNT - 1; i >= startingChannel; --i) { + if (_channels[i]._fieldE == 0xFF) { + _channels[i].load(pData); + return; + } + } +} + +bool ASound::isSoundActive(byte *pData) { + for (int i = 0; i < ADLIB_CHANNEL_MIDWAY; ++i) { + if (_channels[i]._activeCount && _channels[i]._soundData == pData) + return true; + } + + return false; +} + +void ASound::setFrequency(int channel, int freq) { + write2(8, 0xA0 + channel, freq & 0xFF); + write2(8, 0xB0 + channel, (freq >> 8) | 0x20); +} + +int ASound::getRandomNumber() { + int v = 0x9248 + (int)_randomSeed; + _randomSeed = ((v >> 3) | (v << 13)) & 0xFFFF; + return _randomSeed; +} + +void ASound::update() { + getRandomNumber(); + if (_isDisabled) + return; + + ++_frameCounter; + pollChannels(); + checkChannels(); + + if (_v1 == _v2) { + if (_resultFlag != -1) { + _resultFlag = -1; + _pollResult = -1; + } + } else { + if (_v1) { + _freqBase1 += _v7; + if (!--_v1) { + if (!_v2 || _channelNum1 != _channelNum2) { + write2(8, 0xA0 + _channelNum1, 0); + write2(8, 0xB0 + _channelNum1, 0); + } + } + } + + if (_v2) { + _freqBase2 += _v8; + if (!--_v2) { + if (!_v1 || _channelNum2 != _channelNum1) { + write2(8, 0xA0 + _channelNum2, 0); + write2(8, 0xB0 + _channelNum2, 0); + } + } + } + } +} + +void ASound::pollChannels() { + _activeChannelNumber = 0; + for (int i = 0; i < ADLIB_CHANNEL_COUNT; ++i) { + _activeChannelPtr = &_channels[i]; + pollActiveChannel(); + } +} + +void ASound::checkChannels() { + if (AdlibChannel::_channelsEnabled) { + for (int i = 0; i < ADLIB_CHANNEL_COUNT; ++i) + _channels[i].check(_nullData); + } +} + +void ASound::pollActiveChannel() { + AdlibChannel *chan = _activeChannelPtr; + + if (chan->_activeCount) { + if (chan->_field8 > 0 && --chan->_field8 == 0) + updateOctave(); + + bool updateFlag = true; + if (--_activeChannelPtr->_activeCount <= 0) { + for (;;) { + byte *pSrc = chan->_pSrc; + if (!chan->_ptr1) { + warning("pollActiveChannel(): No data found for sound channel"); + break; + } + if (!(*pSrc & 0x80) || (*pSrc <= 0xF0)) { + if (updateFlag) + updateActiveChannel(); + + chan->_field4 = *pSrc++; + chan->_activeCount = *pSrc++; + chan->_pSrc += 2; + + if (!chan->_field4 || !chan->_activeCount) { + updateOctave(); + } else { + chan->_field8 = chan->_activeCount - chan->_field7; + updateChannelState(); + } + + // Break out of processing loop + break; + } else { + updateFlag = false; + + switch ((~*pSrc) & 0xF) { + case 0: + if (!chan->_field17) { + if (*++pSrc == 0) { + chan->_pSrc += 2; + chan->_ptr3 = chan->_pSrc; + chan->_field17 = 0; + } else { + chan->_field17 = *pSrc; + chan->_pSrc = chan->_ptr3; + } + } else if (--chan->_field17) { + chan->_pSrc = chan->_ptr3; + } else { + chan->_pSrc += 2; + chan->_ptr3 = chan->_pSrc; + } + break; + + case 1: + if (!chan->_field19) { + if (*++pSrc == 0) { + chan->_pSrc += 2; + chan->_ptr4 = chan->_pSrc; + chan->_ptr3 = chan->_pSrc; + chan->_field17 = 0; + chan->_field19 = 0; + } else { + chan->_field19 = *pSrc; + chan->_pSrc = chan->_ptr4; + chan->_ptr3 = chan->_ptr4; + } + } else if (--chan->_field19) { + chan->_ptr4 = chan->_pSrc; + chan->_ptr3 = chan->_pSrc; + } else { + chan->_pSrc += 2; + chan->_ptr4 = chan->_pSrc; + chan->_ptr3 = chan->_pSrc; + } + break; + + case 2: + // Loop sound data + chan->_field1 = 0; + chan->_field2 = chan->_field3 = 0; + chan->_volume = chan->_field7 = 0; + chan->_field1D = chan->_field1E = 0; + chan->_field8 = 0; + chan->_field9 = 0; + chan->_fieldB = 0; + chan->_field17 = 0; + chan->_field19 = 0; + chan->_fieldD = 0x40; + chan->_ptr1 = chan->_soundData; + chan->_pSrc = chan->_soundData; + chan->_ptr3 = chan->_soundData; + chan->_ptr4 = chan->_soundData; + + chan->_pSrc += 2; + break; + + case 3: + chan->_sampleIndex = *++pSrc; + chan->_pSrc += 2; + loadSample(chan->_sampleIndex); + break; + + case 4: + chan->_field7 = *++pSrc; + chan->_pSrc += 2; + break; + + case 5: + chan->_field1 = *++pSrc; + chan->_pSrc += 2; + break; + + case 6: + ++pSrc; + if (chan->_fieldE) { + chan->_pSrc += 2; + } else { + chan->_volume = *pSrc >> 1; + updateFlag = true; + chan->_pSrc += 2; + } + break; + + case 7: + ++pSrc; + if (!chan->_fieldE) { + chan->_fieldA = *pSrc; + chan->_field2 = *++pSrc; + chan->_field9 = 1; + } + + chan->_pSrc += 3; + break; + + case 8: + chan->_field1D = *++pSrc; + chan->_pSrc += 2; + break; + + case 9: { + int v1 = *++pSrc; + ++pSrc; + int v2 = (v1 - 1) & getRandomNumber(); + int v3 = pSrc[v2]; + int v4 = pSrc[v1]; + + pSrc[v4 + v1 + 1] = v3; + chan->_pSrc += v1 + 3; + break; + } + + case 10: + ++pSrc; + if (chan->_fieldE) { + chan->_pSrc += 2; + } else { + chan->_field1E = *pSrc >> 1; + updateFlag = true; + chan->_pSrc += 2; + } + break; + + case 11: + chan->_fieldD = *++pSrc; + updateFlag = true; + chan->_pSrc += 2; + break; + + case 12: + chan->_fieldC = *++pSrc; + chan->_field3 = *++pSrc; + chan->_fieldB = 1; + chan->_pSrc += 2; + break; + + case 13: + ++pSrc; + chan->_pSrc += 2; + break; + + case 14: + chan->_field1F = *++pSrc; + chan->_pSrc += 2; + break; + + default: + break; + } + } + } + } + + if (chan->_field1) + updateFNumber(); + + updateFlag = false; + if (chan->_field9 || chan->_fieldB) { + if (!--chan->_field9) { + chan->_field9 = chan->_fieldA; + if (chan->_field2) { + int8 newVal = (int8)chan->_field2 + (int8)chan->_field1E; + if (newVal < 0) { + chan->_field9 = 0; + newVal = 0; + } else if (newVal > 63) { + chan->_field9 = 0; + newVal = 63; + } + + chan->_field1E = newVal; + updateFlag = true; + } + } + + if (!--chan->_fieldB) { + chan->_fieldB = chan->_fieldC; + if (chan->_field3) { + chan->_fieldD = chan->_field3; + updateFlag = true; + } + } + + if (updateFlag) + updateActiveChannel(); + } + } + + ++_activeChannelNumber; +} + +void ASound::updateOctave() { + int reg = 0xB0 + _activeChannelNumber; + write2(8, reg, _ports[reg] & 0xDF); +} + +static int _vList1[] = { + 0x200, 0x21E, 0x23F, 0x261, 0x285, 0x2AB, + 0x2D4, 0x2FF, 0x32D, 0x35D, 0x390, 0x3C7 +}; + +void ASound::updateChannelState() { + updateActiveChannel(); + + if (_channelData[_activeChannelNumber]._field0) { + if (_channelNum1 == _activeChannelNumber) + _stateFlag = 0; + if (_channelNum2 == _activeChannelNumber) + _stateFlag = 1; + + if (!_stateFlag) { + _stateFlag = 1; + if (_v1) + write2(8, 0xB0 + _channelNum1, _ports[0xB0 + _channelNum1] & 0xDF); + + _channelNum1 = _activeChannelNumber; + _v1 = _channelData[_channelNum1]._field0; + _freqMask1 = _channelData[_channelNum1]._freqMask; + _freqBase1 = _channelData[_channelNum1]._freqBase; + _v7 = _channelData[_channelNum1]._field6; + } else { + _stateFlag = 0; + if (_v2) + write2(8, 0xB0 + _channelNum2, _ports[0xB0 + _channelNum2] & 0xDF); + + _channelNum2 = _activeChannelNumber; + _v2 = _channelData[_channelNum2]._field0; + _freqMask2 = _channelData[_channelNum2]._freqMask; + _freqBase2 = _channelData[_channelNum2]._freqBase; + _v8 = _channelData[_channelNum2]._field6; + } + + resultCheck(); + } else { + int reg = 0xA0 + _activeChannelNumber; + int vTimes = (_activeChannelPtr->_field4 + _activeChannelPtr->_field1F) / 12; + int vOffset = (_activeChannelPtr->_field4 + _activeChannelPtr->_field1F) % 12; + int val = _vList1[vOffset] + _activeChannelPtr->_field1D; + write2(8, reg, val & 0xFF); + + reg += 0x10; + write2(8, reg, (_ports[reg] & 0x20) | (vTimes << 2) | (val >> 8)); + + write2(8, reg, _ports[reg] | 0x20); + } +} + +static const int outputIndexes[] = { + 0, 3, 1, 4, 2, 5, 6, 9, 7, 10, 8, 11, 12, 15, 13, 16, 14, 17 +}; +static const int outputChannels[] = { + 0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 16, 17, 18, 19, 20, 21, 0 +}; +static const int volumeList[] = { + 0x3F, 0x3F, 0x36, 0x31, 0x2D, 0x2A, 0x28, 0x26, 0x24, 0x22, 0x21, 0x20, 0x1F, 0x1E, 0x1D, 0x1C, + 0x1B, 0x1A, 0x19, 0x19, 0x18, 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x14, 0x14, 0x13, 0x12, 0x12, + 0x11, 0x11, 0x10, 0x10, 0x0F, 0x0F, 0x0E, 0x0E, 0x0D, 0x0D, 0x0C, 0x0C, 0x0B, 0x0B, 0x0A, 0x0A, + 0x0A, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + +void ASound::updateActiveChannel() { + int reg = 0x40 + outputChannels[outputIndexes[_activeChannelNumber * 2 + 1]]; + int portVal = _ports[reg] & 0xFFC0; + int newVolume = CLIP(_activeChannelPtr->_volume + _activeChannelPtr->_field1E, 0, 63); + + // Note: Original had a whole block not seeming to be used, since the initialisation + // sets a variable to 5660h, and doesn't change it, so the branch is never taken + int val = CLIP(newVolume - volumeList[_activeChannelPtr->_fieldD], 0, 63); + val = (63 - val) | portVal; + + int val2 = CLIP(newVolume - volumeList[-(_activeChannelPtr->_fieldD - 127)], 0, 63); + val2 = (63 - val2) | portVal; + write2(0, reg, val); + write2(2, reg, val2); +} + +void ASound::loadSample(int sampleIndex) { + _activeChannelReg = 0xB0 + _activeChannelNumber; + write2(8, _activeChannelReg, _ports[_activeChannelReg] & 0xDF); + + _activeChannelReg = _activeChannelNumber; + _samplePtr = &_samples[sampleIndex * 2]; + _v11 = outputChannels[outputIndexes[_activeChannelReg * 2]]; + processSample(); + + AdlibChannelData &cd = _channelData[_activeChannelNumber]; + cd._field6 = _samplePtr->_field14; + cd._freqBase = _samplePtr->_freqBase; + cd._freqMask = _samplePtr->_freqMask; + cd._field0 = _samplePtr->_fieldE; + + _samplePtr = &_samples[sampleIndex * 2 + 1]; + _v11 = outputChannels[outputIndexes[_activeChannelReg * 2 + 1]]; + processSample(); +} + +void ASound::processSample() { + // Write out vib flags and split point + write2(8, 0x40 + _v11, 0x3F); + int depthRhythm = (_ports[0xBD] & 0x3F) | (_amDep ? 0x80 : 0) | + (_vibDep ? 0x40 : 0); + write2(8, 0xBD, depthRhythm); + write2(8, 8, _splitPoint ? 0x40 : 0); + + // Write out feedback & Alg + int val = (_samplePtr->_feedback << 1) | (1 - _samplePtr->_alg); + write2(8, 0xC0 + _activeChannelReg, val); + + // Write out attack/decay rate + val = (_samplePtr->_attackRate << 4) | (_samplePtr->_decayRate & 0xF); + write2(8, 0x60 + _v11, val); + + // Write out sustain level/release rate + val = (_samplePtr->_sustainLevel << 4) | (_samplePtr->_releaseRate & 0xF); + write2(8, 0x80 + _v11, val); + + // Write out misc flags + val = (_samplePtr->_ampMod ? 0x80 : 0) | (_samplePtr->_vib ? 0x40 : 0) + | (_samplePtr->_egTyp ? 0x20 : 0) | (_samplePtr->_ksr ? 0x10 : 0) + | (_samplePtr->_freqMultiple & 0xF); + write2(8, 0x20 + _v11, val); + + // Write out waveform select + write2(8, 0xE0 + _v11, _samplePtr->_waveformSelect & 3); + + // Write out total level & scaling level + val = -((_samplePtr->_totalLevel & 0x3F) - 0x3F) | (_samplePtr->_scalingLevel << 6); + write2(8, 0x40 + _v11, val); +} + +void ASound::updateFNumber() { + int loReg = 0xA0 + _activeChannelNumber; + int hiReg = 0xB0 + _activeChannelNumber; + int val1 = (_ports[hiReg] & 0x1F) << 8; + val1 += _ports[loReg] + _activeChannelPtr->_field1; + write2(8, loReg, val1); + + int val2 = (_ports[hiReg] & 0x20) | (val1 >> 8); + write2(8, hiReg, val2); +} + +int ASound::readBuffer(int16 *buffer, const int numSamples) { + Common::StackLock slock(_driverMutex); + + int32 samplesLeft = numSamples; + memset(buffer, 0, sizeof(int16) * numSamples); + while (samplesLeft) { + if (!_samplesTillCallback) { + poll(); + flush(); + + _samplesTillCallback = _samplesPerCallback; + _samplesTillCallbackRemainder += _samplesPerCallbackRemainder; + if (_samplesTillCallbackRemainder >= CALLBACKS_PER_SECOND) { + _samplesTillCallback++; + _samplesTillCallbackRemainder -= CALLBACKS_PER_SECOND; + } + } + + int32 render = MIN<int>(samplesLeft, _samplesTillCallback); + samplesLeft -= render; + _samplesTillCallback -= render; + + _opl->readBuffer(buffer, render); + buffer += render; + } + return numSamples; +} + +int ASound::command0() { + bool isDisabled = _isDisabled; + _isDisabled = true; + + for (int i = 0; i < ADLIB_CHANNEL_COUNT; ++i) + _channels[i].reset(); + + _v1 = 0; + _v2 = 0; + _freqMask1 = _freqMask2 = 0; + _freqBase1 = _freqBase2 = 0; + _v7 = 0; + _v8 = 0; + + // Reset Adlib port registers + for (int reg = 0x4F; reg >= 0x40; --reg) + write2(8, reg, 0x3F); + for (int reg = 0xFF; reg >= 0x60; --reg) + write2(8, reg, 0); + for (int reg = 0x3F; reg > 0; --reg) + write2(8, reg, 0); + write2(8, 1, 0x20); + + _isDisabled = isDisabled; + return 0; +} + +int ASound::command1() { + for (int i = 0; i < ADLIB_CHANNEL_COUNT; ++i) + _channels[i].enable(0xFF); + return 0; +} + +int ASound::command2() { + for (int i = 0; i < ADLIB_CHANNEL_MIDWAY; ++i) + _channels[i].setPtr2(_nullData); + return 0; +} + +int ASound::command3() { + for (int i = 0; i < ADLIB_CHANNEL_MIDWAY; ++i) + _channels[i].enable(0xFF); + return 0; +} + +int ASound::command4() { + for (int i = ADLIB_CHANNEL_MIDWAY; i < ADLIB_CHANNEL_COUNT; ++i) + _channels[i].setPtr2(_nullData); + return 0; +} + +int ASound::command5() { + for (int i = 5; i < ADLIB_CHANNEL_COUNT; ++i) + _channels[i].enable(0xFF); + return 0; +} + +int ASound::command6() { + _v9 = _v1; + _v1 = 0; + _v10 = _v2; + _v2 = 0; + + channelOff(0x43); + channelOff(0x44); + channelOff(0x45); + channelOff(0x4B); + channelOff(0x4C); + channelOff(0x4D); + channelOff(0x53); + channelOff(0x54); + channelOff(0x55); + + return 0; +} + +int ASound::command7() { + channelOn(0x43, _channels[0]._volume); + channelOn(0x44, _channels[1]._volume); + channelOn(0x45, _channels[2]._volume); + channelOn(0x4B, _channels[3]._volume); + channelOn(0x4C, _channels[4]._volume); + channelOn(0x4D, _channels[5]._volume); + + _v1 = _v9; + _v2 = _v10; + + if (_v9 != _v10) + resultCheck(); + + _isDisabled = 0; + return _v10; +} + +int ASound::command8() { + int result = 0; + for (int i = 0; i < ADLIB_CHANNEL_COUNT; ++i) + result |= _channels[i]._activeCount; + + return result; +} + +/*-----------------------------------------------------------------------*/ + +const ASound1::CommandPtr ASound1::_commandList[42] = { + &ASound1::command0, &ASound1::command1, &ASound1::command2, &ASound1::command3, + &ASound1::command4, &ASound1::command5, &ASound1::command6, &ASound1::command7, + &ASound1::command8, &ASound1::command9, &ASound1::command10, &ASound1::command11, + &ASound1::command12, &ASound1::command13, &ASound1::command14, &ASound1::command15, + &ASound1::command16, &ASound1::command17, &ASound1::command18, &ASound1::command19, + &ASound1::command20, &ASound1::command21, &ASound1::command22, &ASound1::command23, + &ASound1::command24, &ASound1::command25, &ASound1::command26, &ASound1::command27, + &ASound1::command28, &ASound1::command29, &ASound1::command30, &ASound1::command31, + &ASound1::command32, &ASound1::command33, &ASound1::command34, &ASound1::command35, + &ASound1::command36, &ASound1::command37, &ASound1::command38, &ASound1::command39, + &ASound1::command40, &ASound1::command41 +}; + +ASound1::ASound1(Audio::Mixer *mixer): ASound(mixer, "asound.001", 0x1520) { + _cmd23Toggle = false; + + // Load sound samples + _soundFile.seek(_dataOffset + 0x12C); + for (int i = 0; i < 98; ++i) + _samples.push_back(AdlibSample(_soundFile)); +} + +int ASound1::command(int commandId, int param) { + if (commandId > 41) + return 0; + + _commandParam = param; + _frameCounter = 0; + return (this->*_commandList[commandId])(); +} + +int ASound1::command9() { + playSound(0xC68, 12); + return 0; +} + +int ASound1::command10() { + byte *pData1 = loadData(0x130E, 48); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0x133E, 392)); + _channels[2].load(loadData(0x14C6, 46)); + _channels[3].load(loadData(0x14F4, 48)); + } + + return 0; +} + +int ASound1::command11() { + command111213(); + _channels[0]._field1E = 0; + _channels[1]._field1E = 0; + return 0; +} + +int ASound1::command12() { + command111213(); + _channels[0]._field1E = 40; + _channels[1]._field1E = 0; + return 0; +} + +int ASound1::command13() { + command111213(); + _channels[0]._field1E = 40; + _channels[1]._field1E = 50; + return 0; +} + +int ASound1::command14() { + playSound(0x1216, 248); + return 0; +} + +int ASound1::command15() { + byte *pData1 = loadData(0x1524, 152); + if (!isSoundActive(pData1)) { + command1(); + _channels[4].load(pData1); + _channels[5].load(loadData(0x15BC, 94)); + _channels[6].load(loadData(0x161A, 94)); + _channels[7].load(loadData(0x1678, 42)); + _channels[8].load(loadData(0x16A2, 42)); + } + + return 0; +} + +int ASound1::command16() { + playSound(0xC74, 14); + return 0; +} + +int ASound1::command17() { + playSound(0xE9A, 10); + return 0; +} + +int ASound1::command18() { + command1(); + playSound(0xCA6, 20); + return 0; +} + +int ASound1::command19() { + command1(); + playSound(0xCBA, 74); + return 0; +} + +int ASound1::command20() { + byte *pData = loadData(0xD18, 28); + if (!isSoundActive(pData)) + playSoundData(pData); + return 0; +} + +int ASound1::command21() { + playSound(0xD04, 20); + return 0; +} + +int ASound1::command22() { + byte *pData = loadData(0xD34, 10); + pData[6] = (getRandomNumber() & 7) + 85; + + if (!isSoundActive(pData)) + playSoundData(pData); + + return 0; +} + +int ASound1::command23() { + _cmd23Toggle = !_cmd23Toggle; + playSound(_cmd23Toggle ? 0xD3E : 0xD46, 8); + return 0; +} + +int ASound1::command24() { + playSound(0xD4E, 18); + playSound(0xD60, 20); + playSound(0xD74, 14); + return 0; +} + +int ASound1::command25() { + byte *pData = loadData(0xD82, 16); + if (!isSoundActive(pData)) + playSoundData(pData); + + return 0; +} + +int ASound1::command26() { + byte *pData = loadData(0xEEC, 10); + pData[5] = (command2627293032() + 0x7F) & 0xFF; + + if (!isSoundActive(pData)) + _channels[6].load(pData); + + return 0; +} + +int ASound1::command27() { + byte *pData = loadData(0xEE2, 10); + pData[5] = (command2627293032() + 0x40) & 0xFF; + + if (!isSoundActive(pData)) + _channels[7].load(pData); + + return 0; +} + +int ASound1::command28() { + playSound(0xD92, 28); + return 0; +} + +int ASound1::command29() { + byte *pData = loadData(0xC82, 36); + byte v = (command2627293032() + 0x40) & 0xFF; + pData[7] = pData[13] = pData[21] = pData[27] = v; + + if (!isSoundActive(pData)) + playSoundData(pData, 0); + + return 0; +} + +int ASound1::command30() { + byte *pData = loadData(0xEA6, 16); + pData[7] = (command2627293032() + 0x40) & 0xFF; + + if (!isSoundActive(pData)) + playSoundData(pData, 0); + + return 0; +} + +int ASound1::command31() { + byte *pData = loadData(0xDAE, 14); + if (!isSoundActive(pData)) + playSoundData(pData); + + return 0; +} + +int ASound1::command32() { + byte *pData = loadData(0xEB4, 46); + int v = command2627293032() + 0x40; + pData[9] = pData[17] = pData[25] = pData[33] = v & 0xFF; + pData[11] = pData[19] = pData[27] = pData[35] = v >> 8; + + if (!isSoundActive(pData)) + playSoundData(pData, 0); + + return 0; +} + +int ASound1::command33() { + playSound(0xDBC, 10); + playSound(0xDC6, 10); + return 0; +} + +int ASound1::command34() { + int v = getRandomNumber() & 0x20; + if (!v) + v = 0x60; + + byte *pData = loadData(0xDD0, 22); + pData[8] = pData[15] = v; + playSoundData(pData); + return 0; +} + +int ASound1::command35() { + playSound(0xDE6, 16); + return 0; +} + +int ASound1::command36() { + playSound(0xE10, 10); + command34(); + + return 0; +} + +int ASound1::command37() { + playSound(0xE1A, 14); + return 0; +} + +int ASound1::command38() { + playSound(0xE28, 114); + return 0; +} + +int ASound1::command39() { + byte *pData1 = loadData(0x16CC, 82); + if (!isSoundActive(pData1)) { + _channels[5].load(pData1); + _channels[6].load(loadData(0x171E, 30)); + _channels[7].load(loadData(0x173C, 40)); + _channels[8].load(loadData(0x1764, 64)); + } + return 0; +} + +int ASound1::command40() { + playSound(0xDF6, 26); + return 0; +} + +int ASound1::command41() { + playSound(0xC32, 34); + playSound(0xC54, 20); + return 0; +} + +void ASound1::command111213() { + byte *pData1 = loadData(0xEF6, 408); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0x108E, 266)); + _channels[2].load(loadData(0x1198, 66)); + _channels[2].load(loadData(0x11DA, 60)); + } +} + +int ASound1::command2627293032() { + return (_commandParam > 0x40) ? _commandParam - 0x40 : _commandParam & 0xff00; +} + + +/*-----------------------------------------------------------------------*/ + +const ASound2::CommandPtr ASound2::_commandList[44] = { + &ASound2::command0, &ASound2::command1, &ASound2::command2, &ASound2::command3, + &ASound2::command4, &ASound2::command5, &ASound2::command6, &ASound2::command7, + &ASound2::command8, &ASound2::command9, &ASound2::command10, &ASound2::command11, + &ASound2::command12, &ASound2::command13, &ASound2::command14, &ASound2::command15, + &ASound2::command16, &ASound2::command17, &ASound2::command18, &ASound2::command19, + &ASound2::command20, &ASound2::command21, &ASound2::command22, &ASound2::command23, + &ASound2::command24, &ASound2::command25, &ASound2::command26, &ASound2::command27, + &ASound2::command28, &ASound2::command29, &ASound2::command30, &ASound2::command31, + &ASound2::command32, &ASound2::command33, &ASound2::command34, &ASound2::command35, + &ASound2::command36, &ASound2::command37, &ASound2::command38, &ASound2::command39, + &ASound2::command40, &ASound2::command41, &ASound2::command42, &ASound2::command43 +}; + +ASound2::ASound2(Audio::Mixer *mixer) : ASound(mixer, "asound.002", 0x15E0) { + _command12Param = 0xFD; + + // Load sound samples + _soundFile.seek(_dataOffset + 0x144); + for (int i = 0; i < 164; ++i) + _samples.push_back(AdlibSample(_soundFile)); +} + +int ASound2::command(int commandId, int param) { + if (commandId > 43) + return 0; + + _frameCounter = 0; + return (this->*_commandList[commandId])(); +} + +int ASound2::command0() { + _command12Param = 0xFD; + return ASound::command0(); +} + +int ASound2::command9() { + byte *pData1 = loadData(0x1094, 376); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[2].load(loadData(0x123E, 130)); + + command9Randomize(); + _channels[1].load(loadData(0x120C, 50)); + } + return 0; +} + +void ASound2::command9Randomize() { + // Randomization + int v; + while (((v = getRandomNumber()) & 0x3F) > 36) + ; + + byte *pData = loadData(0x120C, 50); + command9Apply(pData, v + 20, -1); + command9Apply(pData + 1, 10 - ((v + 1) / 6), 1); +} + +void ASound2::command9Apply(byte *data, int val, int incr) { + data += 8; + for (int ctr = 0; ctr < 10; ++ctr, data += 4, val += incr) { + *data = val; + } +} + +int ASound2::command10() { + byte *pData1 = loadData(0x12C0, 60); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0x12FC, 318)); + _channels[2].load(loadData(0x143A, 110)); + } + + return 0; +} + +int ASound2::command11() { + byte *pData = loadData(0x14A8, 170); + if (!isSoundActive(pData)) { + playSoundData(pData); + playSoundData(loadData(0x1552, 1802)); + playSoundData(loadData(0x1C5C, 716)); + playSoundData(loadData(0x1F28, 106)); + } + + return 0; +} + +int ASound2::command12() { + _command12Param += 26; + byte v = _command12Param & 0x7f; + + byte *pData = loadData(0x4A5E, 38); + pData[5] = pData[20] = v; + playSoundData(pData); + + pData = loadData(0x4A84, 30); + pData[5] = pData[18] = v; + playSoundData(pData); + + return 0; +} + +int ASound2::command13() { + playSoundData(loadData(0x4AA2, 20)); + playSoundData(loadData(0x4AB6, 20)); + + return 0; +} + +int ASound2::command14() { + playSound(0x4ACA, 40); + playSound(0x4AF2, 42); + + return 0; +} + +int ASound2::command15() { + byte *pData1 = loadData(0x1F92, 1074); + if (!isSoundActive(pData1)) { + command1(); + playSoundData(pData1); + playSound(0x23C4, 1050); + playSound(0x27DE, 58); + playSound(0x2818, 712); + playSound(0x2AE0, 256); + } + + return 0; +} + +int ASound2::command16() { + byte *pData1 = loadData(0x3960, 280); + if (!isSoundActive(pData1)) { + command1(); + playSoundData(pData1); + playSound(0x3A78, 266); + playSound(0x3B72, 322); + playSound(0x3CC4, 488); + playSound(0x3EAC, 104); + playSound(0x3F14, 104); + } + + return 0; +} + +int ASound2::command17() { + byte *pData1 = loadData(0x3F7C, 432); + if (!isSoundActive(pData1)) { + command1(); + playSoundData(pData1); + playSound(0x412C, 422); + playSound(0x42D2, 424); + playSound(0x447A, 418); + } + + return 0; +} + +static const int command18_list[16][2] = { + { 0x337C, 28 }, { 0x3398, 26 }, { 0x33B2, 26 }, { 0x33CC, 26 }, + { 0x33E6, 56 }, { 0x341E, 46 }, { 0x344C, 56 }, { 0x3484, 22 }, + { 0x349A, 38 }, { 0x34C0, 62 }, { 0x34FE, 26 }, { 0x3518, 26 }, + { 0x3532, 26 }, { 0x354C, 26 }, { 0x3566, 32 }, { 0x3586, 24 } +}; + +int ASound2::command18() { + if (_channels[3]._activeCount == 0) { + int idx = (getRandomNumber() & 0x1E) >> 1; + byte *pData = loadData(command18_list[idx][0], command18_list[idx][1]); + _channels[3].load(pData); + } + + return 0; +} + +int ASound2::command19() { + byte *pData1 = loadData(0x2BE0, 366); + if (!isSoundActive(pData1)) { + command1(); + playSoundData(pData1); + playSound(0x2D4E, 460); + playSound(0x2F1A, 266); + playSound(0x3024, 328); + playSound(0x316C, 162); + playSound(0x320E, 366); + } + + return 0; +} + +int ASound2::command20() { + playSound(0x4A36, 40); + + return 0; +} + +int ASound2::command21() { + playSound(0x49DE, 16); + playSound(0x49EE, 16); + playSound(0x49FF, 16); + + return 0; +} + +int ASound2::command22() { + playSound(0x4A0E, 24); + playSound(0x4A26, 16); + + return 0; +} + +int ASound2::command23() { + playSound(0x49B6, 16); + + return 0; +} + +int ASound2::command24() { + playSound(0x49C6, 24); + + return 0; +} + +int ASound2::command25() { + playSound(0x49AC, 10); + + return 0; +} + +int ASound2::command26() { + playSound(0x498A, 14); + playSound(0x4998, 20); + + return 0; +} + +int ASound2::command27() { + playSound(0x4912, 80); + playSound(0x4962, 40); + + return 0; +} + +int ASound2::command28() { + playSound(0x48E8, 28); + playSound(0x4904, 14); + + return 0; +} + +int ASound2::command29() { + playSound(0x48B2, 22); + + return 0; +} + +int ASound2::command30() { + playSound(0x4870, 22); + playSound(0x4886, 22); + playSound(0x489C, 22); + + return 0; +} + +int ASound2::command31() { + playSound(0x482E, 22); + playSound(0x4844, 22); + playSound(0x489C, 22); + + return 0; +} + +int ASound2::command32() { + playSound(0x46E8, 10); + + return 0; +} + +int ASound2::command33() { + playSound(0x46D8, 16); + + return 0; +} + +int ASound2::command34() { + playSound(0x46C8, 16); + + return 0; +} + +int ASound2::command35() { + playSound(0x46B2, 22); + + return 0; +} + +int ASound2::command36() { + playSound(0x4624, 16); + + return 0; +} + +int ASound2::command37() { + playSound(0x4674, 20); + playSound(0x4688, 32); + playSound(0x46A8, 10); + + return 0; +} + +int ASound2::command38() { + byte *pData1 = loadData(0x359E, 202); + if (!isSoundActive(pData1)) { + command1(); + playSoundData(pData1); + playSound(0x3668, 220); + playSound(0x3744, 124); + playSound(0x37C0, 162); + playSound(0x3862, 78); + playSound(0x38B0, 176); + } + + return 0; +} + +int ASound2::command39() { + byte *pData = loadData(0x466A, 10); + pData[6] = (getRandomNumber() & 7) + 85; + playSoundData(pData); + + return 0; +} + +int ASound2::command40() { + playSound(0x4634, 34); + playSound(0x4656, 20); + + return 0; +} + +int ASound2::command41() { + playSound(0x48C8, 32); + + return 0; +} + +int ASound2::command42() { + playSound(0x46F2, 156); + playSound(0x478E, 160); + + return 0; +} + +int ASound2::command43() { + playSound(0x4B1C, 40); + playSound(0x4B44, 41); + + return 0; +} + +/*-----------------------------------------------------------------------*/ + +const ASound3::CommandPtr ASound3::_commandList[61] = { + &ASound3::command0, &ASound3::command1, &ASound3::command2, &ASound3::command3, + &ASound3::command4, &ASound3::command5, &ASound3::command6, &ASound3::command7, + &ASound3::command8, &ASound3::command9, &ASound3::command10, &ASound3::command11, + &ASound3::nullCommand, &ASound3::command13, &ASound3::command14, &ASound3::command15, + &ASound3::command16, &ASound3::command17, &ASound3::command18, &ASound3::command19, + &ASound3::command20, &ASound3::command21, &ASound3::command22, &ASound3::command23, + &ASound3::command24, &ASound3::command25, &ASound3::command26, &ASound3::command27, + &ASound3::command28, &ASound3::command29, &ASound3::command30, &ASound3::command31, + &ASound3::command32, &ASound3::command33, &ASound3::command34, &ASound3::command35, + &ASound3::command36, &ASound3::command37, &ASound3::command38, &ASound3::command39, + &ASound3::command40, &ASound3::command41, &ASound3::command42, &ASound3::command43, + &ASound3::command44, &ASound3::command45, &ASound3::command46, &ASound3::command47, + &ASound3::nullCommand, &ASound3::command49, &ASound3::command50, &ASound3::command51, + &ASound3::nullCommand, &ASound3::nullCommand, &ASound3::nullCommand, &ASound3::nullCommand, + &ASound3::nullCommand, &ASound3::command57, &ASound3::nullCommand, &ASound3::command59, + &ASound3::command60 +}; + +ASound3::ASound3(Audio::Mixer *mixer) : ASound(mixer, "asound.003", 0x15B0) { + _command39Flag = false; + + // Load sound samples + _soundFile.seek(_dataOffset + 0x122); + for (int i = 0; i < 192; ++i) + _samples.push_back(AdlibSample(_soundFile)); +} + +int ASound3::command(int commandId, int param) { + if (commandId > 60) + return 0; + + _commandParam = param; + _frameCounter = 0; + return (this->*_commandList[commandId])(); +} + +int ASound3::command9() { + AdlibChannel::_channelsEnabled = _commandParam != 0; + + return 0; +} + +int ASound3::command10() { + byte *pData1 = loadData(0x13EA, 254); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0X14E8, 452)); + _channels[2].load(loadData(0x16AC, 396)); + _channels[3].load(loadData(0x1838, 118)); + _channels[4].load(loadData(0x18AE, 74)); + } + + return 0; +} + +int ASound3::command11() { + byte *pData1 = loadData(0x2B84, 596); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0x2DD8, 562)); + _channels[2].load(loadData(0x300A, 1694)); + _channels[3].load(loadData(0x36A8, 1100)); + _channels[4].load(loadData(0x3AF4, 420)); + _channels[5].load(loadData(0x3C98, 1516)); + } + + return 0; +} + +int ASound3::command13() { + byte *pData1 = loadData(0x4470, 64); + if (!isSoundActive(pData1)) { + command1(); + playSoundData(pData1); + playSound(0x44B0, 64); + playSound(0x44F0, 64); + playSound(0x4530, 64); + playSound(0x4570, 64); + playSound(0X45b0, 64); + } + + return 0; +} + +int ASound3::command14() { + byte *pData1 = loadData(0X45F0, 36); + if (!isSoundActive(pData1)) { + command1(); + playSoundData(pData1); + playSound(0x4614, 36); + playSound(0x4638, 36); + playSound(0x465C, 32); + playSound(0x467C, 76); + playSound(0x46C8, 74); + } + + return 0; +} + +int ASound3::command15() { + _channels[3].load(loadData(0x36A8, 1100)); + _channels[4].load(loadData(0x3AF4, 420)); + _channels[5].load(loadData(0x3C98, 1516)); + + _channels[3]._field20 = 0xDD; + _channels[4]._field20 = 0xDD; + _channels[5]._field20 = 0xDD; + + return 0; +} + +int ASound3::command16() { + byte *pData1 = loadData(0x4712, 398); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0x48A0, 354)); + _channels[2].load(loadData(0x4A02, 410)); + _channels[3].load(loadData(0x4B9C, 392)); + } + + return 0; +} + +int ASound3::command17() { + byte *pData1 = loadData(0x18F8, 400); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0x1A88, 680)); + _channels[2].load(loadData(0x1D30, 478)); + _channels[3].load(loadData(0x1F0E, 1146)); + _channels[4].load(loadData(0x2388, 1006)); + _channels[5].load(loadData(0x2776, 1038)); + } + + return 0; +} + +int ASound3::command18() { + byte *pData1 = loadData(0x4284, 142); + if (!isSoundActive(pData1)) { + command1(); + playSoundData(pData1); + playSound(0x4312, 172); + playSound(0x43BE, 88); + playSound(0x4416, 90); + } + + return 0; +} + +int ASound3::command19() { + playSound(0x4F6, 8); + + return 0; +} + +int ASound3::command20() { + playSound(0x4F1C, 10); + + return 0; +} + +int ASound3::command21() { + playSound(0x4F2E, 8); + + return 0; +} + +int ASound3::command22() { + playSound(0x4F36, 16); + + return 0; +} + +int ASound3::command23() { + playSound(0x4F50, 10); + playSound(0x4F46, 10); + + return 0; +} + +int ASound3::command24() { + // WORKAROUND: Original calls isSoundActive without loading data pointer + byte *pData = loadData(0x4EFC, 12); + if (!isSoundActive(pData)) { + int v; + while ((v = (getRandomNumber() & 0x3F)) > 45) + ; + + pData[6] = v + 19; + playSoundData(pData); + } + + return 0; +} + +int ASound3::command25() { + playSound(0x4EE6, 22); + + return 0; +} + +int ASound3::command26() { + playSound(0x4F5A, 8); + + return 0; +} + +int ASound3::command27() { + playSound(0x4DA2, 34); + playSound(0x4DC4, 20); + + return 0; +} + +int ASound3::command28() { + playSound(0x4F72, 10); + playSound(0x4F72, 10); + + return 0; +} + +int ASound3::command29() { + playSound(0x4F72, 10); + playSound(0x4F72, 10); + + return 0; +} + +int ASound3::command30() { + playSound(0x4E5A, 22); + playSound(0x4E70, 22); + playSound(0x4E86, 22); + + return 0; +} + +int ASound3::command31() { + playSound(0x4F7C, 40); + + return 0; +} + +int ASound3::command32() { + playSound(0x4ED2, 10); + + return 0; +} + +int ASound3::command33() { + playSound(0x4EC2, 16); + + return 0; +} + +int ASound3::command34() { + playSound(0x4EB2, 16); + + return 0; +} + +int ASound3::command35() { + playSound(0x4E9C, 22); + + return 0; +} + +int ASound3::command36() { + playSound(0x4D2C, 16); + + return 0; +} + +int ASound3::command37() { + playSound(0x4E1E, 20); + playSound(0x4E32, 30); + playSound(0x4E50, 10); + + return 0; +} + +int ASound3::command38() { + playSound(0x4FAC, 10); + + return 0; +} + +int ASound3::command39() { + _command39Flag = !_command39Flag; + if (_command39Flag) { + playSound(0x4FD0, 8); + } else { + playSound(0x4FD8, 8); + } + + return 0; +} + +int ASound3::command40() { + _command39Flag = !_command39Flag; + if (_command39Flag) { + playSound(0x4EE0, 8); + } else { + playSound(0x4EE8, 8); + } + + return 0; +} + +int ASound3::command41() { + playSound(0x4F08, 20); + + return 0; +} + +int ASound3::command42() { + playSound(0x4DD8, 28); + playSound(0x4DF4, 42); + + return 0; +} + +int ASound3::command43() { + playSound(0x4FB6, 12); + playSound(0x4FC2, 14); + + return 0; +} + +int ASound3::command44() { + playSound(0x4FFE, 14); + + return 0; +} + +int ASound3::command45() { + playSound(0x500C, 14); + + return 0; +} + +int ASound3::command46() { + playSound(0x4D78, 14); + playSound(0x4D86, 14); + playSound(0x4D94, 14); + + return 0; +} + +int ASound3::command47() { + playSound(0x4D62, 8); + playSound(0x4D6A, 14); + + return 0; +} + +int ASound3::command49() { + playSound(0x4D62, 8); + playSound(0x4D6A, 14); + + return 0; +} + +int ASound3::command50() { + playSound(0x4D3C, 14); + playSound(0x4D4A, 14); + playSound(0x4D58, 10); + + return 0; +} + +int ASound3::command51() { + playSound(0x4FF0, 14); + + return 0; +} + +int ASound3::command57() { + byte *pData = loadData(0x4EDC, 10); + pData[6] = (getRandomNumber() & 7) + 85; + playSoundData(pData); + + return 0; +} + +int ASound3::command59() { + playSound(0x4F62, 16); + + return 0; +} + +int ASound3::command60() { + playSound(0x4FA4, 8); + + return 0; +} + +/*-----------------------------------------------------------------------*/ + +const ASound4::CommandPtr ASound4::_commandList[61] = { + &ASound4::command0, &ASound4::command1, &ASound4::command2, &ASound4::command3, + &ASound4::command4, &ASound4::command5, &ASound4::command6, &ASound4::command7, + &ASound4::command8, &ASound4::nullCommand, &ASound4::command10, &ASound4::nullCommand, + &ASound4::command12, &ASound4::nullCommand, &ASound4::nullCommand, &ASound4::nullCommand, + &ASound4::nullCommand, &ASound4::nullCommand, &ASound4::nullCommand, &ASound4::command19, + &ASound4::command20, &ASound4::command21, &ASound4::nullCommand, &ASound4::nullCommand, + &ASound4::command24, &ASound4::nullCommand, &ASound4::nullCommand, &ASound4::command27, + &ASound4::nullCommand, &ASound4::nullCommand, &ASound4::command30, &ASound4::nullCommand, + &ASound4::command32, &ASound4::command33, &ASound4::command34, &ASound4::command35, + &ASound4::command36, &ASound4::command37, &ASound4::command38, &ASound4::nullCommand, + &ASound4::nullCommand, &ASound4::nullCommand, &ASound4::nullCommand, &ASound4::command43, + &ASound4::nullCommand, &ASound4::nullCommand, &ASound4::nullCommand, &ASound4::nullCommand, + &ASound4::nullCommand, &ASound4::nullCommand, &ASound4::nullCommand, &ASound4::nullCommand, + &ASound4::nullCommand, &ASound4::nullCommand, &ASound4::nullCommand, &ASound4::nullCommand, + &ASound4::nullCommand, &ASound4::command57, &ASound4::nullCommand, &ASound4::command59, + &ASound4::command60 +}; + +ASound4::ASound4(Audio::Mixer *mixer) : ASound(mixer, "asound.004", 0x14F0) { + // Load sound samples + _soundFile.seek(_dataOffset + 0x122); + for (int i = 0; i < 210; ++i) + _samples.push_back(AdlibSample(_soundFile)); +} + +int ASound4::command(int commandId, int param) { + if (commandId > 60) + return 0; + + _commandParam = param; + _frameCounter = 0; + return (this->*_commandList[commandId])(); +} + +int ASound4::command10() { + byte *pData = loadData(0x22AA, 254); + if (!isSoundActive(pData)) { + command1(); + _channels[0].load(pData); + _channels[1].load(loadData(0x23A8, 452)); + _channels[2].load(loadData(0x256C, 396)); + _channels[3].load(loadData(0x26F8, 118)); + _channels[4].load(loadData(0x276E, 74)); + } + + return 0; +} + +int ASound4::command12() { + byte *pData = loadData(0x16A8, 550); + if (!isSoundActive(pData)) { + command1(); + _channels[0].load(pData); + _channels[1].load(loadData(0x18CE, 442)); + _channels[2].load(loadData(0x1A88, 298)); + _channels[3].load(loadData(0x1BB2, 354)); + _channels[4].load(loadData(0x1D14, 572)); + _channels[4].load(loadData(0x1F50, 560)); + } + + int v = (_commandParam > 0x40) ? _commandParam - 0x40 : 0; + v += 0xB5; + for (int channelNum = 0; channelNum < 6; ++channelNum) + _channels[channelNum]._field20 = v; + + return 0; +} + +int ASound4::command19() { + playSound(0x28EC, 8); + + return 0; +} + +int ASound4::command20() { + playSound(0x28E2, 10); + + return 0; +} + +int ASound4::command21() { + playSound(0x27C0, 8); + + return 0; +} + +int ASound4::command24() { + int v; + while ((v = (getRandomNumber() & 0x3F)) > 45) + ; + + byte *pData = loadData(0x28D6, 12); + pData[6] = v + 19; + playSoundData(pData); + + return 0; +} + +int ASound4::command27() { + playSound(0x27D8, 34); + playSound(0x27FA, 20); + + return 0; +} + +int ASound4::command30() { + playSound(0x284A, 22); + playSound(0x2860, 22); + playSound(0x2876, 22); + + return 0; +} + +int ASound4::command32() { + playSound(0x28C2, 10); + + return 0; +} + +int ASound4::command33() { + playSound(0x28B2, 16); + + return 0; +} + +int ASound4::command34() { + playSound(0x28A2, 16); + + return 0; +} + +int ASound4::command35() { + playSound(0x288C, 22); + + return 0; +} + +int ASound4::command36() { + playSound(0x27C8, 16); + + return 0; +} + +int ASound4::command37() { + playSound(0x280E, 20); + playSound(0x2822, 30); + playSound(0x2840, 10); + + return 0; +} + +int ASound4::command38() { + playSound(0x2904, 10); + + return 0; +} + +int ASound4::command43() { + playSound(0x290E, 12); + playSound(0x291A, 14); + + return 0; +} + +int ASound4::command52() { + byte *pData = loadData(0x23A8, 452); + if (_channels[1]._ptr1 == pData) { + pData = loadData(0x146E, 570); + if (!isSoundActive(pData)) { + _channels[0].load(pData); + _channels[1]._field20 = 0xD8; + _channels[2]._field20 = 0xD8; + } + } + + return 0; +} + +int ASound4::command53() { + method1(); + _channels[0]._field20 = 0; + + return 0; +} + +int ASound4::command54() { + method1(); + _channels[1]._field20 = 0; + _channels[2]._field20 = 0; + + return 0; +} + +int ASound4::command55() { + method1(); + _channels[3]._field20 = 0; + _channels[4]._field20 = 0; + + return 0; +} + +int ASound4::command56() { + method1(); + _channels[5]._field20 = 0; + + return 0; +} + +int ASound4::command57() { + int v = (getRandomNumber() & 7) + 85; + byte *pData = loadData(0x28CC, 10); + pData[6] = v; + playSoundData(pData); + + return 0; +} + +int ASound4::command58() { + byte *pData = loadData(0x146E, 570); + if (_channels[1]._ptr1 == pData) { + _channels[0].load(loadData(0x22AA, 254)); + _channels[1]._field20 = 0; + _channels[2]._field20 = 0; + } + + return 0; +} + +int ASound4::command59() { + playSound(0x28F4, 8); + + return 0; +} + +int ASound4::command60() { + playSound(0x28FC, 8); + + return 0; +} + +void ASound4::method1() { + byte *pData = loadData(0x2180, 58); + if (!isSoundActive(pData)) { + command1(); + + _channels[0].load(pData); + _channels[1].load(loadData(0x21BA, 48)); + _channels[2].load(loadData(0x21EA, 50)); + _channels[3].load(loadData(0x221C, 40)); + _channels[4].load(loadData(0x2244, 28)); + _channels[5].load(loadData(0x2260, 74)); + + for (int channel = 0; channel < 6; ++channel) + _channels[channel]._field20 = 0xB5; + } +} + + +/*-----------------------------------------------------------------------*/ + +const ASound5::CommandPtr ASound5::_commandList[42] = { + &ASound5::command0, &ASound5::command1, &ASound5::command2, &ASound5::command3, + &ASound5::command4, &ASound5::command5, &ASound5::command6, &ASound5::command7, + &ASound5::command8, &ASound5::command9, &ASound5::command10, &ASound5::command11, + &ASound5::command11, &ASound5::command13, &ASound5::command14, &ASound5::command15, + &ASound5::command16, &ASound5::command17, &ASound5::command18, &ASound5::command19, + &ASound5::command20, &ASound5::command21, &ASound5::command22, &ASound5::command23, + &ASound5::command11, &ASound5::command11, &ASound5::command26, &ASound5::command27, + &ASound5::command28, &ASound5::command29, &ASound5::command30, &ASound5::command31, + &ASound5::command32, &ASound5::command33, &ASound5::command34, &ASound5::command35, + &ASound5::command36, &ASound5::command37, &ASound5::command38, &ASound5::command39, + &ASound5::command40, &ASound5::command41 +}; + +ASound5::ASound5(Audio::Mixer *mixer) : ASound(mixer, "asound.002", 0x15E0) { + // Load sound samples + _soundFile.seek(_dataOffset + 0x144); + for (int i = 0; i < 164; ++i) + _samples.push_back(AdlibSample(_soundFile)); +} + +int ASound5::command(int commandId, int param) { + if (commandId > 41) + return 0; + + _frameCounter = 0; + return (this->*_commandList[commandId])(); +} + +int ASound5::command9() { + byte *pData = loadData(0x2114, 10); + pData[6] = (getRandomNumber() & 7) + 85; + playSoundData(pData); + + return 0; +} + +int ASound5::command10() { + playSound(0x211E, 10); + + return 0; +} + +int ASound5::command11() { + playSound(0x2016, 10); + + return 0; +} + +int ASound5::command13() { + playSound(0x2154, 10); + + return 0; +} + +int ASound5::command14() { + playSound(0x21DC, 22); + + return 0; +} + +int ASound5::command15() { + byte *pData = loadData(0x21DC, 22); + if (_channels[0]._ptr1 == pData) { + pData = loadData(0x1F2, 12); + _channels[0]._soundData = pData; + _channels[0]._field17 = 1; + _channels[0]._field19 = 1; + } + + return 0; +} + +int ASound5::command16() { + playSound(0x214C, 8); + + return 0; +} + +int ASound5::command17() { + playSound(0x2142, 10); + + return 0; +} + +int ASound5::command18() { + playSound(0x21A2, 22); + + return 0; +} + +int ASound5::command19() { + playSound(0x2190, 18); + + return 0; +} + +int ASound5::command20() { + playSound(0x2170, 16); + + return 0; +} + +int ASound5::command21() { + playSound(0x2180, 16); + + return 0; +} + +int ASound5::command22() { + playSound(0x2168, 8); + + return 0; +} + +int ASound5::command23() { + playSound(0x215E, 10); + + return 0; +} + +int ASound5::command26() { + playSound(0x21B8, 12); + + return 0; +} + +int ASound5::command27() { + playSound(0x21C4, 24); + + return 0; +} + +int ASound5::command28() { + playSound(0x2020, 34); + playSound(0x4904, 20); + + return 0; +} + +int ASound5::command29() { + byte *pData = loadData(0x17C, 312); + if (!isSoundActive(pData)) { + command1(); + _channels[0].load(pData); + _channels[1].load(loadData(0x1864, 304)); + _channels[2].load(loadData(0x1994, 222)); + _channels[3].load(loadData(0x1864, 304)); + _channels[4].load(loadData(0x1994, 222)); + } + + return 0; +} + +int ASound5::command30() { + playSound(0x2092, 22); + playSound(0x20A8, 22); + playSound(0x20BE, 22); + + return 0; +} + +int ASound5::command31() { + playSound(0x2128, 22); + playSound(0x2134, 14); + + return 0; +} + +int ASound5::command32() { + playSound(0x210A, 10); + + return 0; +} + +int ASound5::command33() { + playSound(0x20FA, 16); + + return 0; +} + +int ASound5::command34() { + playSound(0x20EA, 16); + + return 0; +} + +int ASound5::command35() { + playSound(0x20D4, 22); + + return 0; +} + +int ASound5::command36() { + playSound(0x2006, 16); + + return 0; +} + +int ASound5::command37() { + playSound(0x2056, 20); + playSound(0x206A, 30); + playSound(0x2088, 10); + + return 0; +} + +int ASound5::command38() { + byte *pData1 = loadData(0x14F2, 570); + if (_channels[3]._ptr1 == pData1) { + _channels[3].load(loadData(0x1A72, 522)); + _channels[3].load(loadData(0x1C7C, 874)); + } + + return 0; +} + +int ASound5::command39() { + playSound(0x1FEE, 8); + + return 0; +} + +int ASound5::command40() { + playSound(0x1FF6, 16); + + return 0; +} + +int ASound5::command41() { + byte *pData1 = loadData(0x14F2, 570); + if (!isSoundActive(pData1)) { + byte *pData2 = loadData(0x1A72, 522); + if (_channels[3]._ptr1 == pData2) { + _channels[3].load(pData1); + _channels[4].load(loadData(0x1FE6, 8)); + } + } + + return 0; +} + +/*-----------------------------------------------------------------------*/ + +const ASound6::CommandPtr ASound6::_commandList[30] = { + &ASound6::command0, &ASound6::command1, &ASound6::command2, &ASound6::command3, + &ASound6::command4, &ASound6::command5, &ASound6::command6, &ASound6::command7, + &ASound6::command8, &ASound6::command9, &ASound6::command10, &ASound6::command11, + &ASound6::command11, &ASound6::command13, &ASound6::command14, &ASound6::command15, + &ASound6::command16, &ASound6::command17, &ASound6::command18, &ASound6::command19, + &ASound6::command20, &ASound6::command21, &ASound6::command22, &ASound6::command23, + &ASound6::command11, &ASound6::command11, &ASound6::nullCommand, &ASound6::nullCommand, + &ASound6::nullCommand, &ASound6::command29 +}; + +ASound6::ASound6(Audio::Mixer *mixer) : ASound(mixer, "asound.006", 0x1390) { + // Load sound samples + _soundFile.seek(_dataOffset + 0x122); + for (int i = 0; i < 200; ++i) + _samples.push_back(AdlibSample(_soundFile)); +} + +int ASound6::command(int commandId, int param) { + if (commandId > 29) + return 0; + + _frameCounter = 0; + return (this->*_commandList[commandId])(); +} + +int ASound6::command9() { + byte *pData = loadData(0x2194, 10); + pData[6] = (getRandomNumber() & 7) + 85; + playSoundData(pData); + + return 0; +} + +int ASound6::command10() { + playSound(0x2224, 24); + + return 0; +} + +int ASound6::command11() { + playSound(0x2202, 34); + + return 0; +} + +int ASound6::command12() { + playSound(0x2246, 8); + + return 0; +} + +int ASound6::command13() { + playSound(0x2298, 28); + + return 0; +} + +int ASound6::command14() { + playSound(0x22B4, 27); + + return 0; +} + +int ASound6::command15() { + playSound(0x219E, 12); + + return 0; +} + +int ASound6::command16() { + playSound(0x21AA, 22); + playSound(0x21C0, 12); + + return 0; +} + +int ASound6::command17() { + playSound(0x21CC, 54); + + return 0; +} + +int ASound6::command18() { + playSound(0x2270, 16); + + return 0; +} + +int ASound6::command19() { + playSound(0x2280, 16); + + return 0; +} + +int ASound6::command20() { + playSound(0x223C, 10); + + return 0; +} + +int ASound6::command21() { + playSound(0x224E, 34); + + return 0; +} + +int ASound6::command22() { + playSound(0x2290, 8); + + return 0; +} + +int ASound6::command23() { + playSound(0x215E, 34); + playSound(0x2180, 20); + + return 0; +} + +int ASound6::command24() { + byte *pData1 = loadData(0x1D54, 540); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0x1F70, 52)); + _channels[2].load(loadData(0x1FA4, 430)); + } + + return 0; +} + +int ASound6::command25() { + playSound(0x2152, 12); + + return 0; +} + +int ASound6::command29() { + byte *pData1 = loadData(0x149A, 312); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0x15D2, 304)); + _channels[2].load(loadData(0x1702, 222)); + _channels[3].load(loadData(0x17E0, 522)); + _channels[4].load(loadData(0x19EA, 874)); + } + + return 0; +} + +/*-----------------------------------------------------------------------*/ + +const ASound7::CommandPtr ASound7::_commandList[38] = { + &ASound7::command0, &ASound7::command1, &ASound7::command2, &ASound7::command3, + &ASound7::command4, &ASound7::command5, &ASound7::command6, &ASound7::command7, + &ASound7::command8, &ASound7::command9, &ASound7::nullCommand, &ASound7::nullCommand, + &ASound7::nullCommand, &ASound7::nullCommand, &ASound7::nullCommand, &ASound7::command15, + &ASound7::command16, &ASound7::command16, &ASound7::command18, &ASound7::command19, + &ASound7::command20, &ASound7::command21, &ASound7::command22, &ASound7::command23, + &ASound7::command24, &ASound7::command25, &ASound7::command26, &ASound7::command27, + &ASound7::command28, &ASound7::nullCommand, &ASound7::command30, &ASound7::nullCommand, + &ASound7::command32, &ASound7::command33, &ASound7::command34, &ASound7::command35, + &ASound7::command36, &ASound7::command37 +}; + +ASound7::ASound7(Audio::Mixer *mixer) : ASound(mixer, "asound.007", 0x1460) { + // Load sound samples + _soundFile.seek(_dataOffset + 0x122); + for (int i = 0; i < 214; ++i) + _samples.push_back(AdlibSample(_soundFile)); +} + +int ASound7::command(int commandId, int param) { + if (commandId > 38) + return 0; + + _frameCounter = 0; + return (this->*_commandList[commandId])(); +} + +int ASound7::command9() { + byte *pData1 = loadData(0x2992, 122); + if (!isSoundActive(pData1)) { + _channels[0].load(pData1); + _channels[1].load(loadData(0x2A0C, 76)); + _channels[2].load(loadData(0x2A58, 122)); + _channels[3].load(loadData(0x2AD2, 38)); + } + + return 0; +} + +int ASound7::command15() { + byte *pData = loadData(0x2B3E, 10); + pData[6] = (getRandomNumber() & 7) + 85; + + return 0; +} + +int ASound7::command16() { + playSound(0x2CE2, 8); + + return 0; +} + +int ASound7::command18() { + playSound(0x2C94, 22); + + return 0; +} + +int ASound7::command19() { + byte *pData1 = loadData(0x2C94, 22); + byte *pData2 = loadData(0x2CAA, 16); + if (_channels[8]._ptr1 == pData1 || _channels[8]._ptr1 == pData2) { + _channels[8]._soundData = loadData(0x2CBA, 12); + _channels[8]._field17 = 1; + _channels[8]._field19 = 1; + } + + return 0; +} + +int ASound7::command20() { + playSound(0x2CD0, 18); + + return 0; +} + +int ASound7::command21() { + playSound(0x2CC6, 10); + + return 0; +} + +int ASound7::command22() { + playSound(0x2C08, 140); + + return 0; +} + +int ASound7::command23() { + playSound(0x2B08, 34); + playSound(0x2B2A, 20); + + return 0; +} + +int ASound7::command24() { + byte *pData1 = loadData(0x14C6, 144); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0x1556, 146)); + _channels[2].load(loadData(0x15E8, 138)); + _channels[3].load(loadData(0x1672, 122)); + _channels[4].load(loadData(0x16EC, 74)); + } + + return 0; +} + +int ASound7::command25() { + byte *pData1 = loadData(0x1DBE, 182); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0x1E74, 182)); + _channels[2].load(loadData(0x1F2A, 186)); + _channels[3].load(loadData(0x1FE4, 244)); + } + + return 0; +} + +int ASound7::command26() { + byte *pData1 = loadData(0x20D8, 312); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0x2210, 304)); + _channels[2].load(loadData(0x2340, 222)); + _channels[3].load(loadData(0x241E, 522)); + _channels[4].load(loadData(0x2628, 874)); + } + + return 0; +} + +int ASound7::command27() { + byte *pData1 = loadData(0x1736, 158); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0x17D4, 288)); + _channels[2].load(loadData(0x18F4, 290)); + _channels[3].load(loadData(0x1A16, 396)); + _channels[4].load(loadData(0x1BA2, 380)); + _channels[5].load(loadData(0x1D1E, 160)); + } + + return 0; +} + +int ASound7::command28() { + playSound(0x2CAA, 16); + + return 0; +} + +int ASound7::command30() { + playSound(0x2B86, 22); + playSound(0x2B9C, 22); + playSound(0x2BB2, 22); + + return 0; +} + +int ASound7::command32() { + playSound(0x2BFE, 10); + + return 0; +} + +int ASound7::command33() { + playSound(0x2BEE, 16); + + return 0; +} + +int ASound7::command34() { + playSound(0x2BDE, 16); + + return 0; +} + +int ASound7::command35() { + playSound(0x2BC8, 22); + + return 0; +} + +int ASound7::command36() { + playSound(0x2AF8, 16); + + return 0; +} + +int ASound7::command37() { + playSound(0x2B48, 20); + playSound(0x2B5C, 32); + playSound(0x2B7C, 10); + + return 0; +} + +/*-----------------------------------------------------------------------*/ + +const ASound8::CommandPtr ASound8::_commandList[38] = { + &ASound8::command0, &ASound8::command1, &ASound8::command2, &ASound8::command3, + &ASound8::command4, &ASound8::command5, &ASound8::command6, &ASound8::command7, + &ASound8::command8, &ASound8::command9, &ASound8::command10, &ASound8::command11, + &ASound8::command12, &ASound8::command13, &ASound8::command14, &ASound8::command15, + &ASound8::command16, &ASound8::command16, &ASound8::command18, &ASound8::command19, + &ASound8::command20, &ASound8::command21, &ASound8::command22, &ASound8::command23, + &ASound8::command24, &ASound8::command25, &ASound8::command26, &ASound8::command27, + &ASound8::command28, &ASound8::command29, &ASound8::command30, &ASound8::command31, + &ASound8::command32, &ASound8::command33, &ASound8::command34, &ASound8::command35, + &ASound8::command36, &ASound8::command37 +}; + +ASound8::ASound8(Audio::Mixer *mixer) : ASound(mixer, "asound.008", 0x1490) { + // Load sound samples + _soundFile.seek(_dataOffset + 0x122); + for (int i = 0; i < 174; ++i) + _samples.push_back(AdlibSample(_soundFile)); +} + +int ASound8::command(int commandId, int param) { + if (commandId > 38) + return 0; + + _frameCounter = 0; + return (this->*_commandList[commandId])(); +} + +int ASound8::command9() { + byte *pData = loadData(0x15BE, 10); + pData[6] = (getRandomNumber() & 7) + 85; + playSoundData(pData); + + return 0; +} + +int ASound8::command10() { + byte *pData = loadData(0x2B3E, 10); + pData[6] = (getRandomNumber() & 7) + 85; + playSoundData(pData); + + return 0; +} + +int ASound8::command11() { + playSound(0x17CA, 12); + + return 0; +} + +int ASound8::command12() { + playSound(0x17D6, 12); + + return 0; +} + +int ASound8::command13() { + playSound(0x1694, 10); + + return 0; +} + +int ASound8::command14() { + playSound(0x169E, 24); + + return 0; +} + +int ASound8::command15() { + byte *pData = loadData(0x169E, 24); + if (_channels[8]._ptr1 == pData) { + _channels[8]._soundData = loadData(0x16B6, 12); + _channels[8]._field17 = 1; + _channels[8]._field19 = 1; + } + + return 0; +} + +int ASound8::command16() { + playSound(0x1686, 14); + + return 0; +} + +int ASound8::command17() { + playSound(0x17EC, 12); + + return 0; +} + +int ASound8::command18() { + playSound(0x17F8, 12); + + return 0; +} + +int ASound8::command19() { + playSound(0x16D8, 8); + + return 0; +} + +int ASound8::command20() { + playSound(0x16E0, 8); + + return 0; +} + +int ASound8::command21() { + playSound(0x17E2, 10); + + return 0; +} + +int ASound8::command22() { + playSound(0x178C, 14); + playSound(0x179A, 14); + playSound(0x17A8, 14); + + return 0; +} + +int ASound8::command23() { + playSound(0x2B08, 34); + playSound(0x2B2A, 20); + + return 0; +} + +int ASound8::command24() { + playSound(0x17B6, 8); + + return 0; +} + +int ASound8::command25() { + playSound(0x17BE, 12); + + return 0; +} + +int ASound8::command26() { + playSound(0x16C2, 22); + + return 0; +} + +int ASound8::command27() { + playSound(0x1588, 34); + playSound(0x15AA, 20); + + return 0; +} + +int ASound8::command28() { + byte *pData1 = loadData(0x114E, 376); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[2].load(loadData(0x12F8, 130)); + + byte *pData = loadData(0x12C6, 50); + method1(pData); + _channels[1].load(pData); + } + + return 0; +} + +void ASound8::method1(byte *pData) { + int v; + while ((v = (getRandomNumber() & 0x3F)) > 36) + ; + + adjustRange(pData, v + 20, -1); + adjustRange(pData + 1, 10 - ((v + 1) / 6), 1); +} + +void ASound8::adjustRange(byte *pData, byte v, int incr) { + pData += 8; + + for (int i = 0; i < 10; ++i, pData += 4, v += incr) { + *pData = v; + } +} + +int ASound8::command29() { + byte *pData1 = loadData(0x137A, 60); + if (!isSoundActive(pData1)) { + command1(); + _channels[0].load(pData1); + _channels[1].load(loadData(0x13B6, 318)); + _channels[2].load(loadData(0x14F4, 118)); + } + + return 0; +} + +int ASound8::command30() { + playSound(0x1644, 22); + playSound(0x165A, 22); + playSound(0x1670, 22); + + return 0; +} + +int ASound8::command31() { + playSound(0x156A, 14); + + return 0; +} + +int ASound8::command32() { + playSound(0x163A, 10); + + return 0; +} + +int ASound8::command33() { + playSound(0x162A, 16); + + return 0; +} + +int ASound8::command34() { + playSound(0x161A, 16); + + return 0; +} + +int ASound8::command35() { + playSound(0x1604, 22); + + return 0; +} + +int ASound8::command36() { + playSound(0x1578, 16); + + return 0; +} + +int ASound8::command37() { + playSound(0x15C8, 20); + playSound(0x15DC, 30); + playSound(0X15FA, 10); + + return 0; +} + +} // End of namespace Nebular + +} // End of namespace MADS diff --git a/engines/mads/nebular/sound_nebular.h b/engines/mads/nebular/sound_nebular.h new file mode 100644 index 0000000000..b5dee5b3ed --- /dev/null +++ b/engines/mads/nebular/sound_nebular.h @@ -0,0 +1,720 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_SOUND_NEBULAR_H +#define MADS_SOUND_NEBULAR_H + +#include "common/scummsys.h" +#include "common/file.h" +#include "common/mutex.h" +#include "common/queue.h" +#include "audio/audiostream.h" +#include "audio/fmopl.h" +#include "audio/mixer.h" + +namespace MADS { + +class SoundManager; + +namespace Nebular { + +/** + * Represents the data for a channel on the Adlib + */ +class AdlibChannel { +public: + int _activeCount; + int _field1; + int _field2; + int _field3; + int _field4; + int _sampleIndex; + int _volume; + int _field7; + int _field8; + int _field9; + int _fieldA; + uint8 _fieldB; + int _fieldC; + int _fieldD; + int _fieldE; + byte *_ptr1; + byte *_pSrc; + byte *_ptr3; + byte *_ptr4; + int _field17; + int _field19; + byte *_soundData; + int _field1D; + int _field1E; + int _field1F; + + // TODO: Only used by asound.003. Figure out usage + byte _field20; +public: + static bool _channelsEnabled; +public: + AdlibChannel(); + + void reset(); + void enable(int flag); + void setPtr2(byte *pData); + void load(byte *pData); + void check(byte *nullPtr); +}; + +class AdlibChannelData { +public: + int _field0; + int _freqMask; + int _freqBase; + int _field6; +}; + +class AdlibSample { +public: + int _attackRate; + int _decayRate; + int _sustainLevel; + int _releaseRate; + bool _egTyp; + bool _ksr; + int _totalLevel; + int _scalingLevel; + int _waveformSelect; + int _freqMultiple; + int _feedback; + bool _ampMod; + int _vib; + int _alg; + int _fieldE; + int _freqMask; + int _freqBase; + int _field14; + + AdlibSample() {} + AdlibSample(Common::SeekableReadStream &s); +}; + +struct RegisterValue { + uint8 _regNum; + uint8 _value; + + RegisterValue(int regNum, int value) { + _regNum = regNum; _value = value; + } +}; + +#define ADLIB_CHANNEL_COUNT 9 +#define ADLIB_CHANNEL_MIDWAY 5 +#define CALLBACKS_PER_SECOND 60 + +/** + * Base class for the sound player resource files + */ +class ASound: public Audio::AudioStream { +private: + struct CachedDataEntry { + int _offset; + byte *_data; + }; + Common::List<CachedDataEntry> _dataCache; + uint16 _randomSeed; + + /** + * Does the initial Adlib initialisation + */ + void adlibInit(); + + /** + * Does on-going processing for the Adlib sounds being played + */ + void update(); + + /** + * Polls each of the channels for updates + */ + void pollChannels(); + + /** + * Checks the status of the channels + */ + void checkChannels(); + + /** + * Polls the currently active channel + */ + void pollActiveChannel(); + + /** + * Updates the octave of the currently active channel + */ + void updateOctave(); + + void updateChannelState(); + void updateActiveChannel(); + + /** + * Loads up the specified sample + */ + void loadSample(int sampleIndex); + + /** + * Writes out the data of the selected sample to the Adlib + */ + void processSample(); + + void updateFNumber(); +protected: + int _commandParam; + + /** + * Queue a byte for an Adlib register + */ + void write(int reg, int val); + + /** + * Queue a byte for an Adlib register, and store it in the _ports array + */ + int write2(int state, int reg, int val); + + /** + * Flush any pending Adlib register values to the OPL driver + */ + void flush(); + + /** + * Turn a channel on + */ + void channelOn(int reg, int volume); + + /** + * Turn a channel off + */ + void channelOff(int reg); + + /** + * Checks for whether a poll result needs to be set + */ + void resultCheck(); + + /** + * Loads a data block from the sound file, caching the result for any future + * calls for the same data + */ + byte *loadData(int offset, int size); + + /** + * Play the specified sound + * @param offset Offset of sound data within sound player data segment + * @param size Size of sound data block + */ + void playSound(int offset, int size); + + /** + * Play the specified raw sound data + * @param pData Pointer to data block containing sound data + * @param startingChannel Channel to start scan from + */ + void playSoundData(byte *pData, int startingChannel = ADLIB_CHANNEL_MIDWAY); + + /** + * Checks to see whether the given block of data is already loaded into a channel. + */ + bool isSoundActive(byte *pData); + + /** + * Sets the frequency for a given channel. + */ + void setFrequency(int channel, int freq); + + /** + * Returns a 16-bit random number + */ + int getRandomNumber(); + + virtual int command0(); + int command1(); + int command2(); + int command3(); + int command4(); + int command5(); + int command6(); + int command7(); + int command8(); + + int nullCommand() { return 0; } +public: + Audio::Mixer *_mixer; + FM_OPL *_opl; + Audio::SoundHandle _soundHandle; + AdlibChannel _channels[ADLIB_CHANNEL_COUNT]; + AdlibChannel *_activeChannelPtr; + AdlibChannelData _channelData[11]; + Common::Array<AdlibSample> _samples; + AdlibSample *_samplePtr; + Common::File _soundFile; + Common::Queue<RegisterValue> _queue; + Common::Mutex _driverMutex; + int _dataOffset; + int _frameCounter; + bool _isDisabled; + int _v1; + int _v2; + int _activeChannelNumber; + int _freqMask1; + int _freqMask2; + int _freqBase1; + int _freqBase2; + int _channelNum1, _channelNum2; + int _v7; + int _v8; + int _v9; + int _v10; + int _pollResult; + int _resultFlag; + byte _nullData[2]; + int _ports[256]; + bool _stateFlag; + int _activeChannelReg; + int _v11; + bool _amDep, _vibDep, _splitPoint; + int _samplesPerCallback; + int _samplesPerCallbackRemainder; + int _samplesTillCallback; + int _samplesTillCallbackRemainder; +public: + /** + * Constructor + * @param filename Specifies the adlib sound player file to use + * @param dataOffset Offset in the file of the data segment + */ + ASound(Audio::Mixer *mixer, const Common::String &filename, int dataOffset); + + /** + * Destructor + */ + virtual ~ASound(); + + /** + * Execute a player command. Most commands represent sounds to play, but some + * low number commands also provide control operations. + * @param commandId Player ommand to execute. + * @param param Optional parameter used by a few commands + */ + virtual int command(int commandId, int param) = 0; + + /** + * Stop all currently playing sounds + */ + int stop(); + + /** + * Main poll method to allow sounds to progress + */ + int poll(); + + /** + * General noise/note output + */ + void noise(); + + /** + * Return the current frame counter + */ + int getFrameCounter() { return _frameCounter; } + + // AudioStream interface + /** + * Main buffer read + */ + virtual int readBuffer(int16 *buffer, const int numSamples); + + /** + * Mono sound only + */ + virtual bool isStereo() const { return false; } + + /** + * Data is continuously pushed, so definitive end + */ + virtual bool endOfData() const { return false; } + + /** + * Return sample rate + */ + virtual int getRate() const { return 11025; } +}; + +class ASound1: public ASound { +private: + typedef int (ASound1::*CommandPtr)(); + static const CommandPtr _commandList[42]; + bool _cmd23Toggle; + + int command9(); + int command10(); + int command11(); + int command12(); + int command13(); + int command14(); + int command15(); + int command16(); + int command17(); + int command18(); + int command19(); + int command20(); + int command21(); + int command22(); + int command23(); + int command24(); + int command25(); + int command26(); + int command27(); + int command28(); + int command29(); + int command30(); + int command31(); + int command32(); + int command33(); + int command34(); + int command35(); + int command36(); + int command37(); + int command38(); + int command39(); + int command40(); + int command41(); + + void command111213(); + int command2627293032(); +public: + ASound1(Audio::Mixer *mixer); + + virtual int command(int commandId, int param); +}; + +class ASound2 : public ASound { +private: + byte _command12Param; +private: + typedef int (ASound2::*CommandPtr)(); + static const CommandPtr _commandList[44]; + + virtual int command0(); + int command9(); + int command10(); + int command11(); + int command12(); + int command13(); + int command14(); + int command15(); + int command16(); + int command17(); + int command18(); + int command19(); + int command20(); + int command21(); + int command22(); + int command23(); + int command24(); + int command25(); + int command26(); + int command27(); + int command28(); + int command29(); + int command30(); + int command31(); + int command32(); + int command33(); + int command34(); + int command35(); + int command36(); + int command37(); + int command38(); + int command39(); + int command40(); + int command41(); + int command42(); + int command43(); + + void command9Randomize(); + void command9Apply(byte *data, int val, int incr); +public: + ASound2(Audio::Mixer *mixer); + + virtual int command(int commandId, int param); +}; + +class ASound3 : public ASound { +private: + bool _command39Flag; + + typedef int (ASound3::*CommandPtr)(); + static const CommandPtr _commandList[61]; + + int command9(); + int command10(); + int command11(); + int command13(); + int command14(); + int command15(); + int command16(); + int command17(); + int command18(); + int command19(); + int command20(); + int command21(); + int command22(); + int command23(); + int command24(); + int command25(); + int command26(); + int command27(); + int command28(); + int command29(); + int command30(); + int command31(); + int command32(); + int command33(); + int command34(); + int command35(); + int command36(); + int command37(); + int command38(); + int command39(); + int command40(); + int command41(); + int command42(); + int command43(); + int command44(); + int command45(); + int command46(); + int command47(); + int command49(); + int command50(); + int command51(); + int command57(); + int command59(); + int command60(); + + void command9Randomize(); + void command9Apply(byte *data, int val, int incr); +public: + ASound3(Audio::Mixer *mixer); + + virtual int command(int commandId, int param); +}; + +class ASound4 : public ASound { +private: + typedef int (ASound4::*CommandPtr)(); + static const CommandPtr _commandList[61]; + + int command10(); + int command12(); + int command19(); + int command20(); + int command21(); + int command24(); + int command27(); + int command30(); + int command32(); + int command33(); + int command34(); + int command35(); + int command36(); + int command37(); + int command38(); + int command43(); + int command52(); + int command53(); + int command54(); + int command55(); + int command56(); + int command57(); + int command58(); + int command59(); + int command60(); + + void method1(); +public: + ASound4(Audio::Mixer *mixer); + + virtual int command(int commandId, int param); +}; + +class ASound5 : public ASound { +private: + typedef int (ASound5::*CommandPtr)(); + static const CommandPtr _commandList[42]; + + int command9(); + int command10(); + int command11(); + int command12(); + int command13(); + int command14(); + int command15(); + int command16(); + int command17(); + int command18(); + int command19(); + int command20(); + int command21(); + int command22(); + int command23(); + int command24(); + int command25(); + int command26(); + int command27(); + int command28(); + int command29(); + int command30(); + int command31(); + int command32(); + int command33(); + int command34(); + int command35(); + int command36(); + int command37(); + int command38(); + int command39(); + int command40(); + int command41(); + int command42(); + int command43(); +public: + ASound5(Audio::Mixer *mixer); + + virtual int command(int commandId, int param); +}; + +class ASound6 : public ASound { +private: + typedef int (ASound6::*CommandPtr)(); + static const CommandPtr _commandList[30]; + + int command9(); + int command10(); + int command11(); + int command12(); + int command13(); + int command14(); + int command15(); + int command16(); + int command17(); + int command18(); + int command19(); + int command20(); + int command21(); + int command22(); + int command23(); + int command24(); + int command25(); + int command29(); +public: + ASound6(Audio::Mixer *mixer); + + virtual int command(int commandId, int param); +}; + +class ASound7 : public ASound { +private: + typedef int (ASound7::*CommandPtr)(); + static const CommandPtr _commandList[38]; + + int command9(); + int command15(); + int command16(); + int command18(); + int command19(); + int command20(); + int command21(); + int command22(); + int command23(); + int command24(); + int command25(); + int command26(); + int command27(); + int command28(); + int command30(); + int command32(); + int command33(); + int command34(); + int command35(); + int command36(); + int command37(); +public: + ASound7(Audio::Mixer *mixer); + + virtual int command(int commandId, int param); +}; + +class ASound8 : public ASound { +private: + typedef int (ASound8::*CommandPtr)(); + static const CommandPtr _commandList[38]; + + int command9(); + int command10(); + int command11(); + int command12(); + int command13(); + int command14(); + int command15(); + int command16(); + int command17(); + int command18(); + int command19(); + int command20(); + int command21(); + int command22(); + int command23(); + int command24(); + int command25(); + int command26(); + int command27(); + int command28(); + int command29(); + int command30(); + int command31(); + int command32(); + int command33(); + int command34(); + int command35(); + int command36(); + int command37(); + + void method1(byte *pData); + void adjustRange(byte *pData, byte v, int incr); +public: + ASound8(Audio::Mixer *mixer); + + virtual int command(int commandId, int param); +}; + +} // End of namespace Nebular + +} // End of namespace MADS + +#endif /* MADS_SOUND_NEBULAR_H */ diff --git a/engines/mads/palette.cpp b/engines/mads/palette.cpp new file mode 100644 index 0000000000..9f56223aa6 --- /dev/null +++ b/engines/mads/palette.cpp @@ -0,0 +1,829 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "engines/util.h" +#include "graphics/palette.h" +#include "mads/mads.h" +#include "mads/msurface.h" +#include "mads/staticres.h" + +namespace MADS { + +#define VGA_COLOR_TRANS(x) ((x) * 255 / 63) + +void RGB6::load(Common::SeekableReadStream *f) { + r = VGA_COLOR_TRANS(f->readByte()); + g = VGA_COLOR_TRANS(f->readByte()); + b = VGA_COLOR_TRANS(f->readByte()); + _palIndex = f->readByte(); + _u2 = f->readByte(); + _flags = f->readByte(); +} + +/*------------------------------------------------------------------------*/ + +PaletteUsage::PaletteUsage(MADSEngine *vm) { + _vm = vm; + _data = nullptr; +} + +void PaletteUsage::load(Common::Array<UsageEntry> *data) { + _data = data; +} + +void PaletteUsage::getKeyEntries(Common::Array<RGB6> &palette) { + _data->clear(); + + for (uint i = 0; i < palette.size(); ++i) { + byte *uPtr = &palette[i]._flags; + if ((*uPtr & 0x10) && _data->size() < 3) { + _data->push_back(UsageEntry(i)); + } + } +} + +static bool sortHelper(const PaletteUsage::UsageEntry &ue1, const PaletteUsage::UsageEntry &ue2) { + return ue1._sortValue < ue2._sortValue; +} + +void PaletteUsage::prioritize(Common::Array<RGB6> &palette) { + for (uint i = 0; i < _data->size(); ++i) { + RGB6 &palEntry = palette[(*_data)[i]._palIndex]; + (*_data)[i]._sortValue = _vm->_palette->rgbMerge(palEntry); + } + + Common::sort(_data->begin(), _data->end(), sortHelper); +} + +static bool rangeSorter(const PaletteUsage::UsageRange &ur1, const PaletteUsage::UsageRange &ur2) { + return ur1._v2 < ur2._v2; +} + +int PaletteUsage::process(Common::Array<RGB6> &palette, uint flags) { + int palLow; + int palHigh = (flags & 0x800) ? 0x100 : 0xFC; + int palIdx; + + PaletteUsage tempUsage(_vm); + Common::Array<UsageEntry> tempUsageData; + tempUsage.load(&tempUsageData); + + if (flags & 0x4000) { + palLow = 0; + palIdx = palHigh; + } else { + palLow = _vm->_palette->_lowRange; + if ((PALETTE_COUNT - _vm->_palette->_highRange) > palHigh) { + palIdx = palHigh; + } else { + palIdx = PALETTE_COUNT - _vm->_palette->_highRange; + } + } + + int rgbIndex = _vm->_palette->_rgbList.scan(); + uint32 rgbMask = 1 << rgbIndex; + bool noUsageFlag = flags & 0x8000; + bool hasUsage = _data != nullptr; + bool flag1 = false; + + if (hasUsage) { + if (noUsageFlag || _data->size() == 0) + hasUsage = false; + + if (noUsageFlag && _data->size() > 0) + flag1 = true; + } + + if (hasUsage) { + tempUsage.getKeyEntries(palette); + tempUsage.prioritize(palette); + } + + int freeIndex; + int palCount = getGamePalFreeIndex(&freeIndex); + Common::Array<UsageRange> palRange; + + for (uint palIndex = 0; palIndex < palette.size(); ++palIndex) { + byte pal2 = palIndex; + byte pal1 = 0; + + if (!(palette[palIndex]._flags & 0x80)) { + pal1 = 0x40; + } + if (palette[palIndex]._flags & 0x60) { + pal1 |= 0x20; + } + + palRange.push_back(UsageRange(pal1, pal2)); + } + + Common::sort(palRange.begin(), palRange.end(), rangeSorter); + + int var3A = (flags & 0x4000) ? 0xffff : 0xfffe; + + for (uint palIndex = 0; palIndex < palette.size(); ++palIndex) { + bool var48 = false; + int var4 = 0xffff; + int v1 = palRange[palIndex]._v2; + + if (palette[v1]._flags & 8) { + var48 = true; + var4 = 0xFD; + } + + if (hasUsage && palette[v1]._flags & 0x10) { + for (uint usageIndex = 0; usageIndex < tempUsage._data->size() && !var48; ++usageIndex) { + if ((*tempUsage._data)[usageIndex]._palIndex == palIndex) { + var48 = true; + int dataIndex = MIN(usageIndex, _data->size() - 1); + var4 = (*_data)[dataIndex]._palIndex; + } + } + } + + if (flag1 && palette[palIndex]._flags & 0x10) { + for (uint usageIndex = 0; usageIndex < _data->size() && !var48; ++usageIndex) { + if ((*_data)[usageIndex]._palIndex == palIndex) { + var48 = true; + var4 = 0xF0 + usageIndex; + + // Copy data into the high end of the main palette + RGB6 &pSrc = palette[palIndex]; + byte *pDest = &_vm->_palette->_mainPalette[var4 * 3]; + pDest[0] = pSrc.r; + pDest[1] = pSrc.g; + pDest[2] = pSrc.b; + } + } + } + + if (!var48 && !noUsageFlag) { + int var2 = (palette[palIndex]._flags & 0x20) || + (((flags & 0x2000) || (palette[palIndex]._flags & 0x4000)) && + ((flags & 0x1000) || (palCount == 0))) ? 0x7fff : 1; + int var36 = (palette[palIndex]._flags & 0x80) ? 0 : 2; + + for (int idx = palLow; idx < palIdx; ++idx) { + uint32 v = _vm->_palette->_palFlags[idx]; + if ((v & var3A) && !(v & var36)) { + int var10; + + if (var2 > 1) { + var10 = rgbFactor(&_vm->_palette->_mainPalette[idx * 3], palette[palIndex]); + } + else if (_vm->_palette->_mainPalette[idx * 3] != palette[palIndex].r || + _vm->_palette->_mainPalette[idx * 3 + 1] != palette[palIndex].g || + _vm->_palette->_mainPalette[idx * 3 + 2] != palette[palIndex].b) { + var10 = 1; + } else { + var10 = 0; + } + + if (var2 > var10) { + var48 = true; + var4 = idx; + var2 = var10; + } + } + } + } + + if (!var48 && (!(flags & 0x1000) || (!(palette[palIndex]._flags & 0x60) && !(flags & 0x2000)))) { + for (int idx = freeIndex; idx < palIdx && !var48; ++idx) { + if (!_vm->_palette->_palFlags[idx]) { + --palCount; + ++freeIndex; + var48 = true; + var4 = idx; + + RGB6 &pSrc = palette[palIndex]; + byte *pDest = &_vm->_palette->_mainPalette[idx * 3]; + pDest[0] = pSrc.r; + pDest[1] = pSrc.g; + pDest[2] = pSrc.b; + } + } + } + + assert(var48); + int var52 = (noUsageFlag && palette[palIndex]._u2) ? 2 : 0; + + _vm->_palette->_palFlags[var4] |= var52 | rgbMask; + palette[palIndex]._palIndex = var4; + } + + _vm->_palette->_rgbList[rgbIndex] = true; + + return rgbIndex; +} + +void PaletteUsage::transform(Common::Array<RGB6> &palette) { + if (!empty()) { + for (uint i = 0; i < _data->size(); ++i) { + int palIndex = (*_data)[i]._palIndex; + (*_data)[i]._palIndex = palette[palIndex]._palIndex; + } + } +} + +void PaletteUsage::updateUsage(Common::Array<int> &usageList, int sceneUsageIndex) { + uint32 mask1 = 0xFFFFFFFF; + uint32 mask2 = 0; + + for (uint idx = 0; idx < usageList.size(); ++idx) { + uint32 bitMask = 1 << usageList[idx]; + mask1 ^= bitMask; + mask2 |= bitMask; + _vm->_palette->_rgbList[usageList[idx]] = false; + } + + uint32 mask3 = 1 << sceneUsageIndex; + + for (uint idx = 0; idx < PALETTE_COUNT; ++idx) { + uint32 mask = mask2 & _vm->_palette->_palFlags[idx]; + if (mask) { + _vm->_palette->_palFlags[idx] = (_vm->_palette->_palFlags[idx] & + mask1) | mask3; + } + } + + _vm->_palette->_rgbList[sceneUsageIndex] = true; +} + +void PaletteUsage::resetPalFlags(int idx) { + if (idx >= 0 && idx < 32) { + uint32 rgbMask = ~(1 << idx); + + uint32 *flagP = _vm->_palette->_palFlags; + for (int i = 0; i < 256; ++i, ++flagP) { + *flagP &= rgbMask; + if (*flagP == 2) + *flagP = 0; + } + + _vm->_palette->_rgbList[idx] = 0; + } +} + +int PaletteUsage::getGamePalFreeIndex(int *palIndex) { + *palIndex = -1; + int count = 0; + + for (int i = 0; i < PALETTE_COUNT; ++i) { + if (!_vm->_palette->_palFlags[i]) { + ++count; + if (*palIndex < 0) + *palIndex = i; + } + } + + return count; +} + +int PaletteUsage::rgbFactor(byte *palEntry, RGB6 &pal6) { + int total = 0; + total += (palEntry[0] - pal6.r) * (palEntry[0] - pal6.r); + total += (palEntry[1] - pal6.g) * (palEntry[1] - pal6.g); + total += (palEntry[2] - pal6.b) * (palEntry[2] - pal6.b); + + return total; +} + +/*------------------------------------------------------------------------*/ + +void RGBList::clear() { + for (int i = 0; i < 32; i++) + _data[i] = false; +} + +void RGBList::reset() { + for (int i = 2; i < 32; i++) + _data[i] = false; +} + +int RGBList::scan() { + for (int i = 0; i < 32; ++i) { + if (!_data[i]) + return i; + } + + error("RGBList was full"); +} + +void RGBList::copy(RGBList &src) { + Common::copy(&src._data[0], &src._data[32], &_data[0]); +} + +/*------------------------------------------------------------------------*/ + +Fader::Fader(MADSEngine *vm): _vm(vm) { + _colorFlags[0] = _colorFlags[1] = _colorFlags[2] = true; + _colorFlags[3] = false; + _colorValues[0] = _colorValues[1] = 0; + _colorValues[2] = _colorValues[3] = 0; + + // TODO: It would be better if the fader routines could be refactored + // to work directly with 8-bit RGB values rather than 6-bit RGB values + Common::fill(&_rgb64Map[0], &_rgb64Map[PALETTE_COUNT], 0); + for (int i = 0; i < 64; ++i) + _rgb64Map[VGA_COLOR_TRANS(i)] = i; + byte v = 0; + for (int i = 0; i < PALETTE_COUNT; ++i) { + if (_rgb64Map[i]) + v = _rgb64Map[i]; + else + _rgb64Map[i] = v; + } +} + + +void Fader::setPalette(const byte *colors, uint start, uint num) { + g_system->getPaletteManager()->setPalette(colors, start, num); +} + +void Fader::grabPalette(byte *colors, uint start, uint num) { + g_system->getPaletteManager()->grabPalette(colors, start, num); +} + +void Fader::fadeOut(byte palette[PALETTE_SIZE], byte *paletteMap, + int baseColor, int numColors, int baseGrey, int numGreys, + int tickDelay, int steps) { + GreyEntry map[PALETTE_COUNT]; + int intensity; + byte palIndex[PALETTE_COUNT][3]; + int8 signs[PALETTE_COUNT][3]; + + mapToGreyRamp(palette, baseColor, numColors, baseGrey, numGreys, map); + + for (int palCtr = baseColor; palCtr < (baseColor + numColors); ++palCtr) { + int index = palCtr - baseColor; + for (int colorCtr = 0; colorCtr < 3; ++colorCtr) { + if (_colorFlags[colorCtr]) { + int shiftSign = _colorValues[colorCtr]; + if (shiftSign >= 0) { + intensity = map[index]._intensity << shiftSign; + } else { + intensity = map[index]._intensity >> ABS(shiftSign); + } + } else { + intensity = _colorValues[colorCtr]; + } + + int diff = intensity - _rgb64Map[palette[palCtr * 3 + colorCtr]]; + palIndex[palCtr][colorCtr] = (byte)ABS(diff); + signs[palCtr][colorCtr] = (diff == 0) ? 0 : (diff < 0 ? -1 : 1); + } + } + + for (int stepCtr = 0; stepCtr < steps; ++stepCtr) { + for (int palCtr = baseColor; palCtr < (baseColor + numColors); ++palCtr) { + int index = palCtr - baseColor; + for (int colorCtr = 0; colorCtr < 3; ++colorCtr) { + map[index]._accum[colorCtr] += palIndex[palCtr][colorCtr]; + while (map[index]._accum[colorCtr] >= steps) { + map[index]._accum[colorCtr] -= steps; + + byte rgb63 = _rgb64Map[palette[palCtr * 3 + colorCtr]] + + signs[palCtr][colorCtr]; + palette[palCtr * 3 + colorCtr] = VGA_COLOR_TRANS(rgb63); + } + } + } + + setFullPalette(palette); + + _vm->_events->waitForNextFrame(); + } + + if (paletteMap != nullptr) { + for (int palCtr = 0; palCtr < numColors; palCtr++) { + paletteMap[palCtr] = map[palCtr]._mapColor; + } + } +} + +void Fader::fadeIn(byte palette[PALETTE_SIZE], byte destPalette[PALETTE_SIZE], + int baseColor, int numColors, int baseGrey, int numGreys, + int tickDelay, int steps) { + GreyEntry map[PALETTE_COUNT]; + byte tempPal[PALETTE_SIZE];; + int8 signs[PALETTE_COUNT][3]; + byte palIndex[PALETTE_COUNT][3]; + int intensity; + + Common::copy(destPalette, destPalette + PALETTE_SIZE, tempPal); + + mapToGreyRamp(tempPal, baseColor, numColors, baseGrey, numGreys, map); + + for (int palCtr = baseColor; palCtr < (baseColor + numColors); ++palCtr) { + int index = palCtr - baseColor; + for (int colorCtr = 0; colorCtr < 3; ++colorCtr) { + if (_colorFlags[colorCtr]) { + int shiftSign = _colorValues[colorCtr]; + if (shiftSign >= 0) { + intensity = map[index]._intensity << shiftSign; + } + else { + intensity = map[index]._intensity >> abs(shiftSign); + } + } + else { + intensity = _colorValues[colorCtr]; + } + + int diff = _rgb64Map[destPalette[palCtr * 3 + colorCtr]] - intensity; + palIndex[palCtr][colorCtr] = (byte)ABS(diff); + signs[palCtr][colorCtr] = (diff == 0) ? 0 : (diff < 0 ? -1 : 1); + + map[index]._accum[colorCtr] = 0; + } + } + + for (int stepCtr = 0; stepCtr < steps; ++stepCtr) { + for (int palCtr = baseColor; palCtr < (baseColor + numColors); ++palCtr) { + int index = palCtr - baseColor; + for (int colorCtr = 0; colorCtr < 3; ++colorCtr) { + map[index]._accum[colorCtr] += palIndex[palCtr][colorCtr]; + while (map[index]._accum[colorCtr] >= steps) { + map[index]._accum[colorCtr] -= steps; + + byte rgb63 = _rgb64Map[palette[palCtr * 3 + colorCtr]] + + signs[palCtr][colorCtr]; + palette[palCtr * 3 + colorCtr] = VGA_COLOR_TRANS(rgb63); + } + } + } + + setFullPalette(palette); + + _vm->_events->waitForNextFrame(); + } +} + +void Fader::mapToGreyRamp(byte palette[PALETTE_SIZE], int baseColor, int numColors, + int baseGrey, int numGreys, GreyEntry *map) { + byte greyList[PALETTE_COUNT]; + byte greyMapping[PALETTE_COUNT]; + byte greyTable[64]; + byte greyIntensity[64]; + int intensity, shiftSign; + + getGreyValues(palette, greyList, baseColor, numColors); + greyPopularity(greyList, greyTable, numColors); + + for (int idx = 0; idx < numColors; ++idx) { + greyMapping[idx] = idx; + Common::fill(&map[idx]._accum[0], &map[idx]._accum[3], 0); + } + + for (int idx = 0; idx < PALETTE_COUNT; ++idx) { + map[idx]._mapColor = (byte)idx; + } + + // Sort the mapping lists + insertionSort(numColors, greyList, greyMapping); + + // Initialise state variables + int greySum = 0; + int greyScan = 0; + int greyMark = 0; + int greyColors = 0; + int greyAccum = 0; + int firstColor = 0; + + for (int greyCtr = 0; greyCtr < 64; ++greyCtr) { + for (int idx = 0; idx < greyTable[greyCtr]; ++idx) { + greySum += greyList[greyScan++]; + ++greyColors; + + greyAccum += numGreys; + while (greyAccum >= numColors) { + greyAccum -= numColors; + if (greyColors > 0) { + greyIntensity[greyMark] = (byte)(greySum / greyColors); + } + + for (int rescan = firstColor; rescan < greyScan; ++rescan) { + map[greyMapping[rescan]]._intensity = greyIntensity[greyMark]; + map[greyMapping[rescan]]._mapColor = (byte)(greyMark + baseGrey); + } + + firstColor = greyScan; + greySum = 0; + greyColors = 0; + ++greyMark; + } + } + } + + // Set the palette range of greyscale values to be used + byte *palP = &palette[baseGrey * 3]; + for (int greys = 0; greys < numGreys; ++greys) { + for (int color = 0; color < 3; ++color) { + if (_colorFlags[color]) { + shiftSign = (byte)_colorValues[color]; + if (shiftSign >= 0) { + intensity = greyIntensity[greys] << shiftSign; + } else { + intensity = greyIntensity[greys] >> abs(shiftSign); + } + } else { + intensity = _colorValues[color]; + } + *palP++ = VGA_COLOR_TRANS(intensity); + } + } +} + +void Fader::getGreyValues(const byte palette[PALETTE_SIZE], + byte greyList[PALETTE_COUNT], int baseColor, int numColors) { + const byte *palP = &palette[baseColor * 3]; + + for (int i = 0; i < numColors; ++i, palP += 3) { + int v = rgbMerge(palP[0], palP[1], palP[2]); + greyList[i] = v >> 7; + } +} + +void Fader::greyPopularity(const byte greyList[PALETTE_COUNT], + byte greyTable[64], int numColors) { + Common::fill(&greyTable[0], &greyTable[64], 0); + for (int i = 0; i < numColors; ++i) { + int idx = greyList[i]; + ++greyTable[idx]; + } +} + +void Fader::insertionSort(int size, byte *id, byte *value) { + bool restartFlag; + int endIndex = size - 1; + + do { + restartFlag = false; + if (endIndex <= 0) + break; + + for (int arrIndex = 0; arrIndex < endIndex && !restartFlag; ++arrIndex) { + byte *idP = id + arrIndex; + byte *valueP = value + arrIndex; + + // Check whether the next index is out of order with the one following it + if (*idP > *(idP + 1)) { + // Found an incorrect ordering + restartFlag = true; + + // Save id/value at current index + byte savedId = *idP; + byte savedValue = *valueP; + + int moveCount = size - arrIndex - 1; + if (moveCount > 0) { + Common::copy(idP + 1, idP + moveCount + 2, idP); + Common::copy(valueP + 1, valueP + moveCount + 2, valueP); + } + + // Scan for insert spot + int idx = 0; + if (endIndex > 0) { + bool breakFlag = false; + for (; idx <= endIndex && !breakFlag; ++idx) { + breakFlag = savedId < id[idx]; + } + } + + // Set up an insert point for entry + moveCount = size - idx - 1; + if (moveCount > 0) { + Common::copy_backward(id + idx, id + idx + moveCount, id + idx + moveCount + 1); + Common::copy_backward(value + idx, value + idx + moveCount, value + idx + moveCount + 1); + } + + // Set shifted values at the new position + id[idx] = savedId; + value[idx] = savedValue; + } + } + } while (restartFlag); +} + +int Fader::rgbMerge(RGB6 &palEntry) { + return rgbMerge(palEntry.r, palEntry.g, palEntry.b); +} + +int Fader::rgbMerge(byte r, byte g, byte b) { + return _rgb64Map[r] * 38 + _rgb64Map[g] * 76 + _rgb64Map[b] * 14; +} + +/*------------------------------------------------------------------------*/ + +Palette::Palette(MADSEngine *vm) : Fader(vm), _paletteUsage(vm) { + _lockFl = false; + _lowRange = 0; + _highRange = 0; + Common::fill(&_mainPalette[0], &_mainPalette[PALETTE_SIZE], 0); + Common::fill(&_palFlags[0], &_palFlags[PALETTE_COUNT], 0); +} + +void Palette::setEntry(byte palIndex, byte r, byte g, byte b) { + _mainPalette[palIndex * 3] = VGA_COLOR_TRANS(r); + _mainPalette[palIndex * 3 + 1] = VGA_COLOR_TRANS(g); + _mainPalette[palIndex * 3 + 2] = VGA_COLOR_TRANS(b); + + setPalette((const byte *)&_mainPalette[palIndex * 3], palIndex, 1); +} + +uint8 Palette::palIndexFromRgb(byte r, byte g, byte b, byte *paletteData) { + byte index = 0; + int32 minDist = 0x7fffffff; + byte palData[PALETTE_SIZE]; + + if (paletteData == NULL) { + g_system->getPaletteManager()->grabPalette(palData, 0, PALETTE_COUNT); + paletteData = &palData[0]; + } + + for (int palIndex = 0; palIndex < PALETTE_COUNT; ++palIndex) { + int Rdiff = r - paletteData[palIndex * 3]; + int Gdiff = g - paletteData[palIndex * 3 + 1]; + int Bdiff = b - paletteData[palIndex * 3 + 2]; + + if (Rdiff * Rdiff + Gdiff * Gdiff + Bdiff * Bdiff < minDist) { + minDist = Rdiff * Rdiff + Gdiff * Gdiff + Bdiff * Bdiff; + index = (uint8)palIndex; + } + } + + return (uint8)index; +} + +void Palette::setGradient(byte *palette, int start, int count, int rgbValue1, int rgbValue2) { + int rgbCurrent = rgbValue2; + int rgbDiff = -(rgbValue2 - rgbValue1); + + if (count > 0) { + byte *pDest = palette + start * 3; + int endVal = count - 1; + int numLeft = count; + + int rgbCtr = 0; + do { + pDest[0] = pDest[1] = pDest[2] = rgbCurrent; + + if (numLeft > 1) { + rgbCtr += rgbDiff; + if (rgbCtr >= endVal) { + do { + ++rgbCurrent; + rgbCtr += 1 - numLeft; + } while (rgbCtr >= endVal); + } + } + + pDest += 3; + } while (--numLeft > 0); + } +} + +void Palette::setSystemPalette() { + byte palData[4 * 3]; + palData[0 * 3] = palData[0 * 3 + 1] = palData[0 * 3 + 2] = 0; + palData[1 * 3] = palData[1 * 3 + 1] = palData[1 * 3 + 2] = 0x54; + palData[2 * 3] = palData[2 * 3 + 1] = palData[2 * 3 + 2] = 0xb4; + palData[3 * 3] = palData[3 * 3 + 1] = palData[3 * 3 + 2] = 0xff; + + setPalette(palData, 0, 4); +} + +void Palette::resetGamePalette(int lowRange, int highRange) { + Common::fill((byte *)&_palFlags[0], (byte *)&_palFlags[PALETTE_COUNT], 0); + initVGAPalette(_mainPalette); + + // Reserve the start of the palette for things like on-screen text + if (lowRange) { + Common::fill(&_palFlags[0], &_palFlags[lowRange], 1); + } + + // Reserve the high end of the palette for dialog display + if (highRange) { + Common::fill(&_palFlags[256 - highRange], &_palFlags[256], 1); + } + + _rgbList.clear(); + _rgbList[0] = _rgbList[1] = true; + + _lockFl = false; + _lowRange = lowRange; + _highRange = highRange; +} + +void Palette::initPalette() { + uint32 palMask = 1; + + if (_vm->_game->_player._spritesLoaded && _vm->_game->_player._numSprites) { + + for (int idx = 0; idx < _vm->_game->_player._numSprites; ++idx) { + SpriteAsset *asset = _vm->_game->_scene._sprites[ + _vm->_game->_player._spritesStart + idx]; + + uint32 mask = 1; + if (asset->_usageIndex) + mask <<= asset->_usageIndex; + + palMask = mask; + } + } + + for (int idx = 0; idx < PALETTE_COUNT; ++idx) + _palFlags[idx] = palMask; + + _lockFl = false; + _rgbList.reset(); +} + +void Palette::initVGAPalette(byte *palette) { + byte *destP = palette; + for (int palIndex = 0; palIndex < 16; ++palIndex) { + for (int byteCtr = 2; byteCtr >= 0; --byteCtr) + *destP++ = ((DEFAULT_VGA_LOW_PALETTE[palIndex] >> (8 * byteCtr)) & 0xff) >> 2; + } + + destP = &palette[0xF0 * 3]; + for (int palIndex = 0; palIndex < 16; ++palIndex) { + for (int byteCtr = 2; byteCtr >= 0; --byteCtr) + *destP++ = ((DEFAULT_VGA_HIGH_PALETTE[palIndex] >> (8 * byteCtr)) & 0xff) >> 2; + } +} + +void Palette::setLowRange() { + _mainPalette[0] = _mainPalette[1] = _mainPalette[2] = VGA_COLOR_TRANS(0); + _mainPalette[3] = _mainPalette[4] = _mainPalette[5] = VGA_COLOR_TRANS(0x15); + _mainPalette[6] = _mainPalette[7] = _mainPalette[8] = VGA_COLOR_TRANS(0x2A); + _mainPalette[9] = _mainPalette[10] = _mainPalette[11] = VGA_COLOR_TRANS(0x3F); + _vm->_palette->setPalette(_mainPalette, 0, 4); +} + +void Palette::setColorFlags(byte r, byte g, byte b) { + _colorFlags[0] = r; + _colorFlags[1] = g; + _colorFlags[2] = b; +} + +void Palette::setColorValues(byte r, byte g, byte b) { + _colorValues[0] = r; + _colorValues[1] = g; + _colorValues[2] = b; +} + +void Palette::lock() { + if (_rgbList[31] && !_lockFl) + error("Palette Lock - Unexpected values"); + + _lockFl = true; + _rgbList[31] = true; + + for (int i = 0; i < 256; i++) { + if (_palFlags[i]) + _palFlags[i] |= 0x80000000; + } +} + +void Palette::unlock() { + if (!_lockFl) + return; + + for (int i = 0; i < 256; i++) + _palFlags[i] &= 0x7FFFFFFF; + + _rgbList[31] = false; + _lockFl = false; +} + +void Palette::refreshSceneColors() { + int val = 18; + if (_vm->_game->_scene._cyclingActive) + val += _vm->_game->_scene._totalCycleColors; + + setPalette(_mainPalette + (val * 3), val, 256 - val); +} + +} // End of namespace MADS diff --git a/engines/mads/palette.h b/engines/mads/palette.h new file mode 100644 index 0000000000..0698e21a5f --- /dev/null +++ b/engines/mads/palette.h @@ -0,0 +1,330 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_PALETTE_H +#define MADS_PALETTE_H + +#include "common/scummsys.h" +#include "common/stream.h" + +namespace MADS { + +class MADSEngine; + +#define PALETTE_USAGE_COUNT 4 + +#define PALETTE_RESERVED_LOW_COUNT 18 +#define PALETTE_RESERVED_HIGH_COUNT 10 + +#define PALETTE_COUNT 256 +#define PALETTE_SIZE (256 * 3) + +/** + * Palette mapping options + */ +enum { + PALFLAG_BACKGROUND = 0x8000, // Loading initial background + PALFLAG_RESERVED = 0x4000, // Enable mapping reserved colors + PALFLAG_ANY_TO_CLOSEST = 0x2000, // Any color can map to closest + PALFLAG_ALL_TO_CLOSEST = 0x1000, // Any colors that can map must map + PALFLAG_TOP_COLORS = 0x0800, // Allow mapping to high four colors + PALFLAG_DEFINE_RESERVED = 0x0400, // Define initial reserved color + PALFLAG_MASK = 0xfc00 // Mask for all the palette flags +}; + +struct PaletteCycle { + byte _colorCount; + byte _firstListColor; + byte _firstColorIndex; + byte _ticks; + + PaletteCycle() { _colorCount = _firstListColor = _firstColorIndex = _ticks = 0; } +}; + +struct RGB6 { + byte r; + byte g; + byte b; + byte _palIndex; + byte _u2; + byte _flags; + + /** + * Load an entry from a stream + */ + void load(Common::SeekableReadStream *f); +}; + +class PaletteUsage { +public: + struct UsageEntry { + uint16 _palIndex; + int _sortValue; + + UsageEntry(int palIndex) { _palIndex = palIndex; _sortValue = -1; } + UsageEntry() { _palIndex = 0; _sortValue = 0; } + }; + struct UsageRange { + byte _v1, _v2; + + UsageRange(byte v1, byte v2) { _v1 = v1; _v2 = v2; } + }; +private: + MADSEngine *_vm; + Common::Array<UsageEntry> *_data; + + int getGamePalFreeIndex(int *palIndex); + + int rgbFactor(byte *palEntry, RGB6 &pal6); + + Common::Array<UsageEntry> _nullUsage; +public: + /** + * Constructor + */ + PaletteUsage(MADSEngine *vm); + + void load(Common::Array<UsageEntry> *data); + + /** + * Returns whether the usage list is empty + */ + bool empty() const { return _data == nullptr; } + + uint16 &operator[](int index) { return (*_data)[index]._palIndex; } + + /** + * Assigns the class to an empty usage array + */ + void setEmpty() { _data = &_nullUsage; } + + /** + * Gets key entries from the passed palette + * @param palette 6-bit per entry read in palette + */ + void getKeyEntries(Common::Array<RGB6> &palette); + + /** + * Prioritizes the palette index list based on the intensity of the + * RGB values of the palette entries that they refer to + */ + void prioritize(Common::Array<RGB6> &palette); + + int process(Common::Array<RGB6> &palette, uint flags); + + void transform(Common::Array<RGB6> &palette); + + void updateUsage(Common::Array<int> &usageList, int sceneUsageIndex); + + void resetPalFlags(int idx); +}; + +class RGBList { +private: + bool _data[32]; +public: + RGBList() { clear(); } + + void clear(); + + void reset(); + + /** + * Copies the data from another instance + */ + void copy(RGBList &src); + + /** + * Scans for a free slot + */ + int scan(); + + bool &operator[](int idx) { return _data[idx]; } +}; + +class Fader { +public: + struct GreyEntry { + byte _intensity; + byte _mapColor; + uint16 _accum[3]; + }; +private: + void mapToGreyRamp(byte palette[PALETTE_SIZE], int baseColor, int numColors, + int baseGrey, int numGreys, GreyEntry *map); + + void getGreyValues(const byte palette[PALETTE_SIZE], byte greyList[PALETTE_COUNT], + int baseColor, int numColors); + + /** + * Given a grey value list containing grey shades (0-63), creates a 64 byte + * grey table containing the number of grey values for each intensity + */ + void greyPopularity(const byte greyList[PALETTE_COUNT], byte greyTable[64], int numColors); + + /** + * Does an insertion sort of a given id/value array pair + */ + void insertionSort(int size, byte *id, byte *value); +protected: + MADSEngine *_vm; + byte _rgb64Map[PALETTE_COUNT]; +public: + bool _colorFlags[4]; + int _colorValues[4]; +public: + /** + * Constructor + */ + Fader(MADSEngine *vm); + + /** + * Sets a new palette + */ + void setPalette(const byte *colors, uint start, uint num); + + /** + * Returns a subset of the currently loaded palette + */ + void grabPalette(byte *colors, uint start, uint num); + + /** + * Gets the entire palette at once + */ + void getFullPalette(byte palette[PALETTE_SIZE]) { + grabPalette(&palette[0], 0, PALETTE_COUNT); + } + + /** + * Sets the entire palette at once + */ + void setFullPalette(byte palette[PALETTE_SIZE]) { + setPalette(&palette[0], 0, PALETTE_COUNT); + } + + /** + * Calculates a merge/hash for a given palette entry + */ + int rgbMerge(byte r, byte g, byte b); + + /** + * Calculates a merge/hash for a given palette entry + */ + int rgbMerge(RGB6 &palEntry); + + /** + * Fades the given palette out to black or grey + */ + void fadeOut(byte palette[PALETTE_SIZE], byte *paletteMap, + int baseColor, int numColors, int baseGrey, int numGreys, + int tickDelay, int steps); + + /** + * Fade into the given palette + */ + void fadeIn(byte palette[PALETTE_SIZE], byte destPalette[PALETTE_SIZE], + int baseColor, int numColors, int baseGrey, int numGreys, + int tickDelay, int steps); +}; + +class Palette: public Fader { +private: + /** + * Initialises the first 16 palette indexes with the equivalent + * standard VGA palette + */ + void initVGAPalette(byte *palette); +public: + byte _mainPalette[PALETTE_SIZE]; + byte _cyclingPalette[PALETTE_SIZE]; + uint32 _palFlags[PALETTE_COUNT]; + PaletteUsage _paletteUsage; + RGBList _rgbList; + bool _lockFl; + int _lowRange; + int _highRange; +public: + /** + * Constructor + */ + Palette(MADSEngine *vm); + + /** + * Destructor + */ + virtual ~Palette() {} + + /** + * Set a palette entry + */ + void setEntry(byte palIndex, byte r, byte g, byte b); + + /** + * Returns the palette index in the palette that most closely matches the + * specified RGB pair + */ + uint8 palIndexFromRgb(byte r, byte g, byte b, byte *paletteData = nullptr); + + /** + * Sets a small set of system/core colors needed by the game + */ + void setSystemPalette(); + + /** + * Update a range of an arbitrary palette + */ + static void setGradient(byte *palette, int start, int count, int rgbValue1, int rgbValue2); + + /** + * Resets the game palette + */ + void resetGamePalette(int v1, int v2); + + /** + * Initialises the main palette + */ + void initPalette(); + + /** + * Set the first four palette entries with preset values + */ + void setLowRange(); + + /** + * Set up the palette as the game ends + */ + void close() { + warning("TODO: Palette::close"); + } + + void setColorFlags(byte r, byte g, byte b); + void setColorValues(byte r, byte g, byte b); + + void lock(); + void unlock(); + + void refreshSceneColors(); +}; + +} // End of namespace MADS + +#endif /* MADS_PALETTE_H */ diff --git a/engines/mads/phantom/game_phantom.cpp b/engines/mads/phantom/game_phantom.cpp new file mode 100644 index 0000000000..bcaec8e648 --- /dev/null +++ b/engines/mads/phantom/game_phantom.cpp @@ -0,0 +1,160 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "common/config-manager.h" +#include "mads/mads.h" +#include "mads/game.h" +#include "mads/screen.h" +#include "mads/msurface.h" +#include "mads/phantom/game_phantom.h" +//#include "mads/nebular/dialogs_nebular.h" +//#include "mads/nebular/globals_nebular.h" +#include "mads/phantom/phantom_scenes.h" + +namespace MADS { + +namespace Phantom { + +GamePhantom::GamePhantom(MADSEngine *vm): Game(vm) { + _surface = new MSurface(MADS_SCREEN_WIDTH, MADS_SCENE_HEIGHT); + _storyMode = STORYMODE_NAUGHTY; +} + +ProtectionResult GamePhantom::checkCopyProtection() { + /* + // DEBUG: Flag copy protection failure + _globals[5] = -1; + + if (!ConfMan.getBool("copy_protection")) + return true; + + * DEBUG: Disabled for now + CopyProtectionDialog *dlg = new CopyProtectionDialog(_vm, false); + dlg->show(); + delete dlg; + */ + + // DEBUG: Return that copy protection failed + return PROTECTION_SUCCEED; +} + +void GamePhantom::initializeGlobals() { + //int count, count2; + //int bad; + + _globals.reset(); + //_globals[kTalkInanimateCount] = 8; + + /* Section #1 variables */ + // TODO + + /* Section #2 variables */ + // TODO + + /* Section #3 variables */ + // TODO + + /* Section #4 variables */ + // TODO + + /* Section #5 variables */ + // TODO + + /* Section #9 variables */ + // TODO + + _player._facing = FACING_NORTH; + _player._turnToFacing = FACING_NORTH; + + //Player::preloadSequences("RXM", 1); + //Player::preloadSequences("ROX", 1); +} + +void GamePhantom::setSectionHandler() { + delete _sectionHandler; + + switch (_sectionNumber) { + case 1: + _sectionHandler = new Section1Handler(_vm); + break; + case 2: + _sectionHandler = new Section2Handler(_vm); + break; + case 3: + _sectionHandler = new Section3Handler(_vm); + break; + case 4: + _sectionHandler = new Section4Handler(_vm); + break; + case 5: + _sectionHandler = new Section5Handler(_vm); + break; + default: + break; + } +} + +void GamePhantom::checkShowDialog() { + // TODO: Copied from Nebular + if (_vm->_dialogs->_pendingDialog && _player._stepEnabled && !_globals[5]) { + _player.releasePlayerSprites(); + _vm->_dialogs->showDialog(); + _vm->_dialogs->_pendingDialog = DIALOG_NONE; + } +} + +void GamePhantom::doObjectAction() { + // TODO: Copied from Nebular + //Scene &scene = _scene; + MADSAction &action = _scene._action; + //Dialogs &dialogs = *_vm->_dialogs; + //int id; + + action._inProgress = false; +} + +void GamePhantom::unhandledAction() { + // TODO +} + +void GamePhantom::step() { + if (_player._visible && _player._stepEnabled && !_player._moving && + (_player._facing == _player._turnToFacing)) { + + // TODO + } + +} + +void GamePhantom::synchronize(Common::Serializer &s, bool phase1) { + Game::synchronize(s, phase1); + + // TODO: Copied from Nebular + if (!phase1) { + _globals.synchronize(s); + } +} + +} // End of namespace Phantom + +} // End of namespace MADS diff --git a/engines/mads/phantom/game_phantom.h b/engines/mads/phantom/game_phantom.h new file mode 100644 index 0000000000..c99e81ee70 --- /dev/null +++ b/engines/mads/phantom/game_phantom.h @@ -0,0 +1,124 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_GAME_PHANTOM_H +#define MADS_GAME_PHANTOM_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/globals.h" +//#include "mads/nebular/globals_nebular.h" + +namespace MADS { + +namespace Phantom { + +// TODO: Adapt for Phantom's difficulty setting +enum StoryMode { STORYMODE_NAUGHTY = 1, STORYMODE_NICE = 2 }; + +enum InventoryObject { + OBJ_NONE = -1, + OBJ_KEY = 0, + OBJ_LANTERN = 1, + OBJ_RED_FRAME = 2, + OBJ_SANDBAG = 3, + OBJ_YELLOW_FRAME = 4, + OBJ_FIRE_AXE = 5, + OBJ_SMALL_NOTE = 6, + OBJ_ROPE = 7, + OBJ_SWORD = 8, + OBJ_ENVELOPE = 9, + OBJ_TICKET = 10, + OBJ_PIECE_OF_PAPER = 11, + OBJ_PARCHMENT = 12, + OBJ_LETTER = 13, + OBJ_NOTICE = 14, + OBJ_BOOK = 15, + OBJ_CRUMPLED_NOTE = 16, + OBJ_BLUE_FRAME = 17, + OBJ_LARGE_NOTE = 18, + OBJ_GREEN_FRAME = 19, + OBJ_MUSIC_SCORE = 20, + OBJ_WEDDING_RING = 21, + OBJ_CABLE_HOOK = 22, + OBJ_ROPE_WITH_HOOK = 23, + OBJ_OAR = 24 +}; + +// HACK: A stub for now, remove from here once it's implemented properly +class PhantomGlobals: public Globals { +public: + PhantomGlobals() { + resize(210); // Rex has 210 globals + } + virtual ~PhantomGlobals() {} +}; + +class GamePhantom: public Game { + friend class Game; +protected: + GamePhantom(MADSEngine *vm); + + virtual ProtectionResult checkCopyProtection(); + + virtual void initializeGlobals(); + + virtual void setSectionHandler(); + + virtual void checkShowDialog(); +public: + PhantomGlobals _globals; + StoryMode _storyMode; + + virtual Globals &globals() { return _globals; } + + virtual void doObjectAction(); + + virtual void unhandledAction(); + + virtual void step(); + + virtual void synchronize(Common::Serializer &s, bool phase1); +}; + + +class Section1Handler: public SectionHandler { +public: + Section1Handler(MADSEngine *vm): SectionHandler(vm) {} + + // TODO: Properly implement handler methods + virtual void preLoadSection() {} + virtual void sectionPtr2() {} + virtual void postLoadSection() {} +}; + +// TODO: Properly implement handler classes +typedef Section1Handler Section2Handler; +typedef Section1Handler Section3Handler; +typedef Section1Handler Section4Handler; +typedef Section1Handler Section5Handler; + +} // End of namespace Nebular + +} // End of namespace MADS + +#endif /* MADS_GAME_PHANTOM_H */ diff --git a/engines/mads/phantom/phantom_scenes.cpp b/engines/mads/phantom/phantom_scenes.cpp new file mode 100644 index 0000000000..dbce014525 --- /dev/null +++ b/engines/mads/phantom/phantom_scenes.cpp @@ -0,0 +1,204 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "common/config-manager.h" +#include "mads/mads.h" +#include "mads/compression.h" +#include "mads/resources.h" +#include "mads/scene.h" +#include "mads/phantom/game_phantom.h" +#include "mads/phantom/phantom_scenes.h" + +namespace MADS { + +namespace Phantom { + +SceneLogic *SceneFactory::createScene(MADSEngine *vm) { + Scene &scene = vm->_game->_scene; + + // TODO + //scene.addActiveVocab(NOUN_DROP); + + switch (scene._nextSceneId) { + // Scene group #1 (theater, stage and dressing rooms) + case 101: // seats + return new DummyScene(vm); // TODO + case 102: // music stands + return new DummyScene(vm); // TODO + case 103: // below stage + return new DummyScene(vm); // TODO + case 104: // stage + return new DummyScene(vm); // TODO + case 105: // ground floor, storage room + return new DummyScene(vm); // TODO + case 106: // behind stage + return new DummyScene(vm); // TODO + case 107: // stage right wing + return new DummyScene(vm); // TODO + case 108: // stage left wing + return new DummyScene(vm); // TODO + case 109: // upper floor, staircase + return new DummyScene(vm); // TODO + case 110: // outside dressing rooms 1 + return new DummyScene(vm); // TODO + case 111: // outside dressing rooms 2 + return new DummyScene(vm); // TODO + case 112: // inside dressing room 1 + return new DummyScene(vm); // TODO + case 113: // inside dressing room 2 + return new DummyScene(vm); // TODO + case 114: // lower floor, storage room + return new DummyScene(vm); // TODO + case 150: // cutscene + return new DummyScene(vm); // TODO + + // Scene group #2 (theater entrance, offices, balcony) + case 201: // entrance / ticket office + return new DummyScene(vm); // TODO + case 202: // outside offices / paintings room + return new DummyScene(vm); // TODO + case 203: // office + return new DummyScene(vm); // TODO + case 204: // library + return new DummyScene(vm); // TODO + case 205: // upper floor, outside balcony boxes + return new DummyScene(vm); // TODO + case 206: // balcony box #1 + return new DummyScene(vm); // TODO + case 207: // balcony box #2 + return new DummyScene(vm); // TODO + case 208: // stage and balcony view + return new DummyScene(vm); // TODO + case 250: // cutscene + return new DummyScene(vm); // TODO + + // Scene group #3 (catwalks, chandelier, lake / catacombs entrance) + case 301: // catwalk #1 above stage + return new DummyScene(vm); // TODO + case 302: // catwalk #2 above stage + return new DummyScene(vm); // TODO + case 303: // above chandelier + return new DummyScene(vm); // TODO + case 304: // chandelier + return new DummyScene(vm); // TODO + case 305: // chandelier fight, phantom closeup + return new DummyScene(vm); // TODO + case 306: // chandelier #2 + return new DummyScene(vm); // TODO + case 307: // catwalk #3 above stage + return new DummyScene(vm); // TODO + case 308: // hidden staircase behind balcony box + return new DummyScene(vm); // TODO + case 309: // lake and archway + return new DummyScene(vm); // TODO + case 310: // lake + return new DummyScene(vm); // TODO + + // Scene group #4 (labyrinth) + case 401: // labyrinth room, 3 exits + return new DummyScene(vm); // TODO + case 403: // labyrinth room (big), 4 exits + 1 bricked door, left + return new DummyScene(vm); // TODO + case 404: // labyrinth room, 3 exits + return new DummyScene(vm); // TODO + case 406: // labyrinth room, 2 exits + return new DummyScene(vm); // TODO + case 407: // catacomb room / lake + return new DummyScene(vm); // TODO + case 408: // catacomb corridor + return new DummyScene(vm); // TODO + case 409: // catacomb room, door with switch panel + return new DummyScene(vm); // TODO + case 410: // skull switch panel + return new DummyScene(vm); // TODO + case 453: // Labyrinth room (big), 4 exits + 1 bricked door, right + return new DummyScene(vm); // TODO + case 456: // Labyrinth room, 2 exits + return new DummyScene(vm); // TODO + + // Scene group #5 (Phantom's hideout) + case 501: // catacombs, outside phantom's hideout, lake and boat + return new DummyScene(vm); // TODO + case 502: // push panel trap + return new DummyScene(vm); // TODO + case 504: // Phantom's hideout, church organ + return new DummyScene(vm); // TODO + case 505: // Phantom's hideout, sarcophagus + return new DummyScene(vm); // TODO + case 506: // catacomb room with ramp + return new DummyScene(vm); // TODO + + default: + error("Invalid scene %d called", scene._nextSceneId); + } +} + +/*------------------------------------------------------------------------*/ + +PhantomScene::PhantomScene(MADSEngine *vm) : SceneLogic(vm), + _globals(static_cast<GamePhantom *>(vm->_game)->_globals), + _game(*static_cast<GamePhantom *>(vm->_game)), + _action(vm->_game->_scene._action) { +} + +Common::String PhantomScene::formAnimName(char sepChar, int suffixNum) { + return Resources::formatName(_scene->_currentSceneId, sepChar, suffixNum, + EXT_NONE, ""); +} + +/*------------------------------------------------------------------------*/ + +void SceneInfoPhantom::loadCodes(MSurface &depthSurface, int variant) { + File f(Resources::formatName(RESPREFIX_RM, _sceneId, ".DAT")); + MadsPack codesPack(&f); + Common::SeekableReadStream *stream = codesPack.getItemStream(variant + 1); + + loadCodes(depthSurface, stream); + + delete stream; + f.close(); +} + +void SceneInfoPhantom::loadCodes(MSurface &depthSurface, Common::SeekableReadStream *stream) { + byte *destP = depthSurface.getData(); + byte *endP = depthSurface.getBasePtr(0, depthSurface.h); + + byte runLength = stream->readByte(); + while (destP < endP && runLength > 0) { + byte runValue = stream->readByte(); + + // Write out the run length + Common::fill(destP, destP + runLength, runValue); + destP += runLength; + + // Get the next run length + runLength = stream->readByte(); + } + + if (destP < endP) + Common::fill(destP, endP, 0); +} + +} // End of namespace Phantom + +} // End of namespace MADS diff --git a/engines/mads/phantom/phantom_scenes.h b/engines/mads/phantom/phantom_scenes.h new file mode 100644 index 0000000000..e585ead542 --- /dev/null +++ b/engines/mads/phantom/phantom_scenes.h @@ -0,0 +1,521 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_PHANTOM_SCENES_H +#define MADS_PHANTOM_SCENES_H + +#include "common/scummsys.h" +#include "mads/game.h" +#include "mads/scene.h" +#include "mads/phantom/game_phantom.h" +//#include "mads/phantom/globals_phantom.h" + + +namespace MADS { + +namespace Phantom { + +enum Noun { + NOUN_GAME = 0x1, + NOUN_QSAVE = 0x2, + NOUN_LOOK = 0x3, + NOUN_TAKE = 0x4, + NOUN_PUSH = 0x5, + NOUN_OPEN = 0x6, + NOUN_PUT = 0x7, + NOUN_TALK_TO = 0x8, + NOUN_GIVE = 0x9, + NOUN_PULL = 0xA, + NOUN_CLOSE = 0xB, + NOUN_THROW = 0xC, + NOUN_WALK_TO = 0xD, + NOUN_ = 0xE, + NOUN_IN_ONE = 0xF, + NOUN_IN_TWO = 0x10, + NOUN_ACT_CURTAIN = 0x11, + NOUN_AISLE = 0x12, + NOUN_APRON = 0x13, + NOUN_ATTACK = 0x14, + NOUN_BACKSTAGE = 0x15, + NOUN_BEAR_PROP = 0x16, + NOUN_BLUE_FRAME = 0x17, + NOUN_BOOK = 0x18, + NOUN_BUST = 0x19, + NOUN_CABLE = 0x1A, + NOUN_CARPET = 0x1B, + NOUN_CARTON = 0x1C, + NOUN_CARTONS = 0x1D, + NOUN_CEILING = 0x1E, + NOUN_CHAIR = 0x1F, + NOUN_CIRCULAR_STAIRCASE = 0x20, + NOUN_CLIMB_DOWN = 0x21, + NOUN_CLIMB_INTO = 0x22, + NOUN_CLIMB_THROUGH = 0x23, + NOUN_COLUMN_PROP = 0x24, + NOUN_CONDUCTORS_STAND = 0x25, + NOUN_CORRIDOR = 0x26, + NOUN_COUCH = 0x27, + NOUN_COUNTERWEIGHT_SYSTEM = 0x28, + NOUN_CRATE = 0x29, + NOUN_CRATES = 0x2A, + NOUN_CRUMPLED_NOTE = 0x2B, + NOUN_CYCLORAMA = 0x2C, + NOUN_CYLINDER = 0x2D, + NOUN_DOOR = 0x2E, + NOUN_DRESSING_ROOM_DOOR = 0x2F, + NOUN_DRESSING_SCREEN = 0x30, + NOUN_DRESSING_TABLE = 0x31, + NOUN_ELEPHANT_PROP = 0x32, + NOUN_ENVELOPE = 0x33, + NOUN_EXIT = 0x34, + NOUN_EXIT_DOWN = 0x35, + NOUN_EXIT_SIGN = 0x36, + NOUN_EXIT_TO = 0x37, + NOUN_EXIT_TO_BACKSTAGE = 0x38, + NOUN_EXIT_TO_CELLAR = 0x39, + NOUN_EXIT_TO_CORRIDOR = 0x3A, + NOUN_EXIT_TO_DRESSING_RMS = 0x3B, + NOUN_EXIT_TO_LEFT_WING = 0x3C, + NOUN_EXIT_TO_PIT = 0x3D, + NOUN_EXIT_TO_RIGHT_WING = 0x3E, + NOUN_EXIT_TO_STAGE = 0x3F, + NOUN_EXIT_TO_STAIRWELL = 0x40, + NOUN_EXIT_TO_TRAP_ROOM = 0x41, + NOUN_EXIT_UP = 0x42, + NOUN_EXPOSED_BRICK = 0x43, + NOUN_FAN = 0x44, + NOUN_FIRE_AXE = 0x45, + NOUN_FL = 0x46, + NOUN_FLAT = 0x47, + NOUN_FLATS = 0x48, + NOUN_FLOOR = 0x49, + NOUN_FOLDING_CHAIRS = 0x4A, + NOUN_GARBAGE_CAN = 0x4B, + NOUN_GRAFFITI = 0x4C, + NOUN_GREEN_FRAME = 0x4D, + NOUN_HEMP = 0x4E, + NOUN_HOLE = 0x4F, + NOUN_HOUSE = 0x50, + NOUN_IN_ONE2 = 0x51, + NOUN_IN_TWO2 = 0x52, + NOUN_JUMP_INTO = 0x53, + NOUN_JUNK = 0x54, + NOUN_KEY = 0x55, + NOUN_LAMP = 0x56, + NOUN_LANTERN = 0x57, + NOUN_LARGE_NOTE = 0x58, + NOUN_LASSO = 0x59, + NOUN_LEG = 0x5A, + NOUN_LETTER = 0x5B, + NOUN_LIGHT_FIXTURE = 0x5C, + NOUN_LOCK = 0x5D, + NOUN_LOCKING_RAIL = 0x5E, + NOUN_LOCKRAIL = 0x5F, + NOUN_LOOK_AT = 0x60, + NOUN_LOOK_THROUGH = 0x61, + NOUN_MANNEQUINS = 0x62, + NOUN_MIRROR = 0x63, + NOUN_MUMMY_PROP = 0x64, + NOUN_MURAL = 0x65, + NOUN_MUSIC_SCORE = 0x66, + NOUN_MUSIC_STAND = 0x67, + NOUN_MUSIC_STANDS = 0x68, + NOUN_NOTHING = 0x69, + NOUN_NOTICE = 0x6A, + NOUN_ORCHESTRA_DOOR = 0x6B, + NOUN_ORCHESTRA_PIT = 0x6C, + NOUN_PAINTING = 0x6D, + NOUN_PARCHMENT = 0x6E, + NOUN_PIECE_OF_PAPER = 0x6F, + NOUN_PIPE = 0x70, + NOUN_PIT = 0x71, + NOUN_PLANT = 0x72, + NOUN_POSTER = 0x73, + NOUN_PROMPTERS_BOX = 0x74, + NOUN_PROP_TABLE = 0x75, + NOUN_PROPS = 0x76, + NOUN_PROSCENIUM_ARCH = 0x77, + NOUN_PURCHASE_LINES = 0x78, + NOUN_RAILING = 0x79, + NOUN_READ = 0x7A, + NOUN_RED_FRAME = 0x7B, + NOUN_REMOVE = 0x7C, + NOUN_ROPE = 0x7D, + NOUN_RUG = 0x7E, + NOUN_SANDBAG = 0x7F, + NOUN_SCAFFOLDING = 0x80, + NOUN_SEATS = 0x81, + NOUN_SIDE_WALL = 0x82, + NOUN_SMALL_NOTE = 0x83, + NOUN_STAGE = 0x84, + NOUN_STAGE_EXIT = 0x85, + NOUN_STAGE_LEFT = 0x86, + NOUN_STAGE_RIGHT = 0x87, + NOUN_STAGEMANAGERS_POST = 0x88, + NOUN_STAIR_UNIT = 0x89, + NOUN_STAIRCASE = 0x8A, + NOUN_STAIRWELL = 0x8B, + NOUN_STOOL = 0x8C, + NOUN_STRIKE = 0x8D, + NOUN_SWORD = 0x8E, + NOUN_TABLE = 0x8F, + NOUN_THE_HOUSE = 0x90, + NOUN_THUNDER_MACHINE = 0x91, + NOUN_TICKET = 0x92, + NOUN_TRAP_CEILING = 0x93, + NOUN_TRAP_DOOR = 0x94, + NOUN_TURN_OFF = 0x95, + NOUN_TURN_ON = 0x96, + NOUN_UNLOCK = 0x97, + NOUN_URN = 0x98, + NOUN_WALK_ACROSS = 0x99, + NOUN_WALK_DOWN = 0x9A, + NOUN_WALK_THROUGH = 0x9B, + NOUN_WALK_UP = 0x9C, + NOUN_WALL = 0x9D, + NOUN_WARDROBE = 0x9E, + NOUN_WASTE_BASKET = 0x9F, + NOUN_WATER_PIPE = 0xA0, + NOUN_WEAR = 0xA1, + NOUN_WEDDING_RING = 0xA2, + NOUN_YELLOW_FRAME = 0xA3, + NOUN_PROP = 0xA4, + NOUN_CLIMB_UP = 0xA5, + NOUN_WALK_ONTO = 0xA6, + NOUN_WALK = 0xA7, + NOUN_LEFT_DOOR = 0xA8, + NOUN_RIGHT_DOOR = 0xA9, + NOUN_DOOR_TO_PIT = 0xAA, + NOUN_HEADPHONES = 0xAB, + NOUN_BOXES = 0xAC, + NOUN_MUG = 0xAD, + NOUN_DINETTE_SET = 0xAE, + NOUN_BOX = 0xAF, + NOUN_CASES = 0xB0, + NOUN_TRASH_BUCKET = 0xB1, + NOUN_CORK_BOARD = 0xB2, + NOUN_HEADSET = 0xB3, + NOUN_GRAND_FOYER = 0xB4, + NOUN_BACK_WALL = 0xB5, + NOUN_BALLET_BAR = 0xB6, + NOUN_THROW_RUGS = 0xB7, + NOUN_COSTUME_RACK = 0xB8, + NOUN_COAT_RACK = 0xB9, + NOUN_PAINTINGS = 0xBA, + NOUN_UMBRELLA = 0xBB, + NOUN_SHELF = 0xBC, + NOUN_CONTAINER = 0xBD, + NOUN_TORN_POSTER = 0xBE, + NOUN_REVIEW = 0xBF, + NOUN_REVIEWS = 0xC0, + NOUN_STAGE_RIGHT_WING = 0xC1, + NOUN_STAGE_LEFT_WING = 0xC2, + NOUN_PEDESTAL = 0xC3, + NOUN_PLANT_PROP = 0xC4, + NOUN_STATUE = 0xC5, + NOUN_BATTEN = 0xC6, + NOUN_BIG_PROP = 0xC7, + NOUN_VENTILATION_DUCT = 0xC8, + NOUN_CHANDELIER = 0xC9, + NOUN_BARRIER = 0xCA, + NOUN_PLACARD = 0xCB, + NOUN_TICKET_WINDOW = 0xCC, + NOUN_ARCHWAY = 0xCD, + NOUN_COLUMN = 0xCE, + NOUN_RAIL = 0xCF, + NOUN_SEAT = 0xD0, + NOUN_LOGE_CORRIDOR = 0xD1, + NOUN_HOUSE_LIGHT = 0xD2, + NOUN_FLOV = 0xD3, + NOUN_LEFT_COLUMN = 0xD4, + NOUN_RIGHT_COLUMN = 0xD5, + NOUN_BOOKCASE = 0xD6, + NOUN_DOORWAY = 0xD7, + NOUN_COMFY_CHAIR = 0xD8, + NOUN_DESK = 0xD9, + NOUN_MANAGERS_CHAIR = 0xDA, + NOUN_DESK_LAMP = 0xDB, + NOUN_WINDOW = 0xDC, + NOUN_SHEERS = 0xDD, + NOUN_TAPESTRY = 0xDE, + NOUN_OVERDOOR_MEDALLION = 0xDF, + NOUN_LATTICEWORK = 0xE0, + NOUN_DECORATIVE_MOLDING = 0xE1, + NOUN_LEFT_DOORWAY = 0xE2, + NOUN_LEFT_ARCHWAY = 0xE3, + NOUN_RIGHT_DOORWAY = 0xE4, + NOUN_RIGHT_ARCHWAY = 0xE5, + NOUN_SOFA = 0xE6, + NOUN_END_TABLE = 0xE7, + NOUN_COFFEE_TABLE = 0xE8, + NOUN_DECORATIVE_VASE = 0xE9, + NOUN_MARBLE_COLUMN = 0xEA, + NOUN_BOX_FIVE = 0xEB, + NOUN_ENTER = 0xEC, + NOUN_BOX_SIX = 0xED, + NOUN_BOX_SEVEN = 0xEE, + NOUN_BOX_EIGHT = 0xEF, + NOUN_BOX_NINE = 0xF0, + NOUN_STEP = 0xF1, + NOUN_PANEL = 0xF2, + NOUN_WALK_BEHIND = 0xF3, + NOUN_MIDDLE_DOORWAY = 0xF4, + NOUN_LIGHT = 0xF5, + NOUN_CANDLE = 0xF6, + NOUN_CASE = 0xF7, + NOUN_HANDLE = 0xF8, + NOUN_AXE = 0xF9, + NOUN_DOOR_CHUNKS = 0xFA, + NOUN_FLO = 0xFB, + NOUN_BULLETIN_BOARD = 0xFC, + NOUN_JULIE = 0xFD, + NOUN_GLASS_CASE = 0xFE, + NOUN_KEYHOLE = 0xFF, + NOUN_MIDDLE_DOOR = 0x100, + NOUN_DRESSING_GOWN = 0x101, + NOUN_MONSIEUR_BRIE = 0x102, + NOUN_CATWALK = 0x103, + NOUN_GRID = 0x104, + NOUN_GIRDER = 0x105, + NOUN_GRIDWORK = 0x106, + NOUN_DUCTWORK = 0x107, + NOUN_OPENING = 0x108, + NOUN_DOME = 0x109, + NOUN_ALCOVE = 0x10A, + NOUN_CHRISTINE_DAAE = 0x10B, + NOUN_CHRISTINE = 0x10C, + NOUN_WOMAN = 0x10D, + NOUN_PROMPTERS_STAND = 0x10E, + NOUN_SUPPORT = 0x10F, + NOUN_OTHER_CATWALK = 0x110, + NOUN_SLOT = 0x111, + NOUN_BEAM_POSITION = 0x112, + NOUN_LIGHTING_INSTRUMENT = 0x113, + NOUN_TARP = 0x114, + NOUN_FACE = 0x115, + NOUN_CATWALK_OVER_HOUSE = 0x116, + NOUN_STAIRCASE_POST = 0x117, + NOUN_JACQUES = 0x118, + NOUN_GENTLEMAN = 0x119, + NOUN_BODY = 0x11A, + NOUN_HOLLOW_COLUMN = 0x11B, + NOUN_UPPER_LEVEL = 0x11C, + NOUN_MIDDLE_LEVEL = 0x11D, + NOUN_LOWER_LEVEL = 0x11E, + NOUN_LADDER = 0x11F, + NOUN_CLIMB = 0x120, + NOUN_CHANDELIER_TRAP = 0x121, + NOUN_PIECE_OF_WOOD = 0x122, + NOUN_CUT_HEMP = 0x123, + NOUN_STONE_WALL = 0x124, + NOUN_LAKE = 0x125, + NOUN_STONE_COLUMN = 0x126, + NOUN_EXIT_THROUGH = 0x127, + NOUN_STONE_FLOOR = 0x128, + NOUN_STONE_ARCHWAY = 0x129, + NOUN_CHARLES = 0x12A, + NOUN_SWITCH = 0x12B, + NOUN_PROMPTERS_SEAT = 0x12C, + NOUN_LEVER = 0x12D, + NOUN_MONSIEUR_RICHARD = 0x12E, + NOUN_JULIE2 = 0x12F, + NOUN_CABLE_HOOK = 0x130, + NOUN_ATTACH = 0x131, + NOUN_ROPE_WITH_HOOK = 0x132, + NOUN_GRAPPLE = 0x133, + NOUN_OAR = 0x134, + NOUN_ORGAN = 0x135, + NOUN_SIT_AT = 0x136, + NOUN_ORGAN_BENCH = 0x137, + NOUN_SIT_ON = 0x138, + NOUN_LARGE_CHAIR = 0x139, + NOUN_SIT_IN = 0x13A, + NOUN_SARCOPHAGUS = 0x13B, + NOUN_SKULL = 0x13C, + NOUN_SKULLS = 0x13D, + NOUN_TOTEM = 0x13E, + NOUN_POLE = 0x13F, + NOUN_CURTAIN = 0x140, + NOUN_TORCH = 0x141, + NOUN_RAMP = 0x142, + NOUN_MADAME_GIRY = 0x143, + NOUN_PANELS = 0x144, + NOUN_MORE_CATACOMBS = 0x145, + NOUN_BLOCKED_ARCHWAY = 0x146, + NOUN_GRATE = 0x147, + NOUN_CATACOMBS = 0x148, + NOUN_TICKET_SELLER = 0x149, + NOUN_USHER = 0x14A, + NOUN_UNLUCKY_ADVENTURER = 0x14B, + NOUN_SWITCH_PANEL = 0x14C, + NOUN_SKULL_SWITCH = 0x14D, + NOUN_TOGGLE = 0x14E, + NOUN_CATACOMB_ROOM = 0x14F, + NOUN_BOX_TEN = 0x150, + NOUN_FOYER = 0x151, + NOUN_WALK_DOWN_STAIRCASE = 0x152, + NOUN_WALK_DOWN_STAIRS_TO = 0x153, + NOUN_HAT_RACK = 0x154, + NOUN_VASE = 0x155, + NOUN_CLOTHES_DUMMY = 0x156, + NOUN_NOTICES = 0x157, + NOUN_ARCHWAY_TO_NORTH = 0x158, + NOUN_ARCHWAY_TO_WEST = 0x159, + NOUN_ARCHWAY_TO_EAST = 0x15A, + NOUN_GATE = 0x15B, + NOUN_NEST = 0x15C, + NOUN_POT = 0x15D, + NOUN_PUDDLE = 0x15E, + NOUN_WEB = 0x15F, + NOUN_PLANK = 0x160, + NOUN_BLOCK = 0x161, + NOUN_RATS_NEST = 0x162, + NOUN_BROKEN_POT = 0x163, + NOUN_STONE = 0x164, + NOUN_DRAIN = 0x165, + NOUN_FATE = 0x166, + NOUN_SKULL_SWITCH_1 = 0x167, + NOUN_SKULL_SWITCH_2 = 0x168, + NOUN_SKULL_SWITCH_3 = 0x169, + NOUN_SKULL_SWITCH_4 = 0x16A, + NOUN_SKULL_SWITCH_5 = 0x16B, + NOUN_SKULL_SWITCH_6 = 0x16C, + NOUN_SKULL_SWITCH_7 = 0x16D, + NOUN_SKULL_SWITCH_8 = 0x16E, + NOUN_SKULL_SWITCH_9 = 0x16F, + NOUN_SKULL_SWITCH_10 = 0x170, + NOUN_SKULL_SWITCH_11 = 0x171, + NOUN_SKULL_SWITCH_12 = 0x172, + NOUN_SKULL_SWITCH_13 = 0x173, + NOUN_SKULL_SWITCH_14 = 0x174, + NOUN_SKULL_SWITCH_15 = 0x175, + NOUN_SKULL_SWITCH_16 = 0x176, + NOUN_SKULL_SWITCH_17 = 0x177, + NOUN_SKULL_SWITCH_18 = 0x178, + NOUN_SKULL_SWITCH_19 = 0x179, + NOUN_SKULL_SWITCH_20 = 0x17A, + NOUN_SKULL_SWITCH_21 = 0x17B, + NOUN_SKULL_SWITCH_22 = 0x17C, + NOUN_SKULL_SWITCH_23 = 0x17D, + NOUN_SKULL_SWITCH_24 = 0x17E, + NOUN_SKULL_SWITCH_25 = 0x17F, + NOUN_SKULL_SWITCH_26 = 0x180, + NOUN_EDGAR_DEGAS = 0x181, + NOUN_CHANDELIER_CABLE = 0x182, + NOUN_COB_WEB = 0x183, + NOUN_SKULL_FACE = 0x184, + NOUN_BOAT = 0x185, + NOUN_HOOK = 0x186, + NOUN_AROUND = 0x187, + NOUN_CANE = 0x188, + NOUN_MASK = 0x189, + NOUN_COVER = 0x18A, + NOUN_PADLOCK = 0x18B, + NOUN_LID = 0x18C, + NOUN_COBWEB = 0x18D, + NOUN_PHANTOM = 0x18E, + NOUN_PAPER = 0x18F +}; + +class SceneFactory { +public: + static SceneLogic *createScene(MADSEngine *vm); +}; + +/** + * Specialized base class for Dragonsphere game scenes + */ +class PhantomScene : public SceneLogic { +protected: + PhantomGlobals &_globals; + GamePhantom &_game; + MADSAction &_action; + + /** + * Forms an animation resource name + */ + Common::String formAnimName(char sepChar, int suffixNum); + + /** + * Plays appropriate sound for entering varous rooms + */ + void lowRoomsEntrySound(); +public: + /** + * Constructor + */ + PhantomScene(MADSEngine *vm); + + void sub7178C(); +}; + +class SceneInfoPhantom : public SceneInfo { + friend class SceneInfo; +protected: + virtual void loadCodes(MSurface &depthSurface, int variant); + + virtual void loadCodes(MSurface &depthSurface, Common::SeekableReadStream *stream); + + /** + * Constructor + */ + SceneInfoPhantom(MADSEngine *vm) : SceneInfo(vm) {} +}; + +// TODO: Temporary, remove once implemented properly +class Scene1xx : public PhantomScene { +protected: + /** + * Plays an appropriate sound when entering a scene + */ + void sceneEntrySound() {} + + /** + *Sets the AA file to use for the scene + */ + void setAAName() {} + + /** + * Updates the prefix used for getting player sprites for the scene + */ + void setPlayerSpritesPrefix() {} +public: + Scene1xx(MADSEngine *vm) : PhantomScene(vm) {} +}; + +// TODO: Temporary, remove once implemented properly +class DummyScene: public PhantomScene { +public: + DummyScene(MADSEngine *vm) : PhantomScene(vm) { + warning("Unimplemented scene"); + } + + virtual void setup() {} + virtual void enter() {} + virtual void actions() {} +}; + +} // End of namespace Phantom + +} // End of namespace MADS + +#endif /* MADS_PHANTOM_SCENES_H */ diff --git a/engines/mads/player.cpp b/engines/mads/player.cpp new file mode 100644 index 0000000000..077771306e --- /dev/null +++ b/engines/mads/player.cpp @@ -0,0 +1,785 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/player.h" + +namespace MADS { + +#define PLAYER_SEQ_INDEX -2 + +const int Player::_directionListIndexes[32] = { + 0, 7, 4, 3, 6, 0, 2, 5, 0, 1, 9, 4, 1, 2, 7, 9, 3, 8, 9, 6, 7, 2, 3, 6, 1, 7, 9, 4, 7, 8, 0, 0 +}; + +Player::Player(MADSEngine *vm): _vm(vm) { + _action = nullptr; + _facing = FACING_NORTH; + _turnToFacing = FACING_NORTH; + _targetFacing = FACING_NORTH; + _prepareWalkFacing = FACING_NONE; + _mirror = false; + _spritesLoaded = false; + _spritesStart = 0; + _spritesIdx = 0; + _numSprites = 0; + _stepEnabled = false; + _visible = false; + _priorVisible = false; + _needToWalk = false; + _readyToWalk = false; + _beenVisible = false; + _loadsFirst = false; + _loadedFirst = false; + _walkAnywhere = false; + _special = 0; + _ticksAmount = 0; + _priorTimer = 0; + _trigger = 0; + _scalingVelocity = false; + _spritesChanged = false; + _forceRefresh = false; + _highSprites = false; + _currentDepth = 0; + _currentScale = 0; + _frameNumber = 0; + _centerOfGravity = 0; + _frameCount = 0; + _velocity = 0; + _upcomingTrigger = 0; + _trigger = 0; + _frameListIndex = 0; + _stopWalkerIndex = 0; + _totalDistance = 0; + + Common::fill(&_stopWalkerList[0], &_stopWalkerList[12], 0); + Common::fill(&_stopWalkerTrigger[0], &_stopWalkerTrigger[12], 0); + Common::fill(&_spriteSetsPresent[0], &_spriteSetsPresent[PLAYER_SPRITES_FILE_COUNT], false); +} + +void Player::cancelWalk() { + Scene &scene = _vm->_game->_scene; + _action = &scene._action; + _targetPos = _playerPos; + _targetFacing = FACING_NONE; + _turnToFacing = _facing; + _moving = false; + _walkOffScreen = _walkOffScreenSceneId = 0; + scene._rails.resetRoute(); + _walkAnywhere = false; + + _needToWalk = false; + _readyToWalk = false; +} + +bool Player::loadSprites(const Common::String &prefix) { + Common::String suffixList = "89632741"; + + Common::String newPrefix; + if (prefix.empty()) { + newPrefix = _spritesPrefix; + } else { + _spritesPrefix = prefix; + newPrefix = prefix; + } + + _numSprites = 0; + if (!_spritesPrefix.empty()) { + for (int fileIndex = 0; fileIndex < PLAYER_SPRITES_FILE_COUNT; ++fileIndex) { + Common::String setName = Common::String::format("*%s_%c.SS", + newPrefix.c_str(), suffixList[fileIndex]); + if (fileIndex >= 5) + _highSprites = true; + + _spriteSetsPresent[fileIndex] = true; + + int setIndex = -1; + if (Common::File::exists(setName)) { + setIndex = _vm->_game->_scene._sprites.addSprites(setName, 4); + ++_numSprites; + } else if (fileIndex < 5) { + _highSprites = 0; + return true; + } else { + _spriteSetsPresent[fileIndex] = false; + } + + if (fileIndex == 0) + _spritesStart = setIndex; + } + + _spritesLoaded = true; + _spritesChanged = false; + _highSprites = false; + return false; + } else { + Common::fill(&_spriteSetsPresent[0], &_spriteSetsPresent[PLAYER_SPRITES_FILE_COUNT], false); + _highSprites = false; + return false; + } +} + +void Player::setFinalFacing() { + if (_targetFacing != FACING_NONE) + _turnToFacing = _targetFacing; +} + +void Player::changeFacing() { + int dirIndex = 0, dirIndex2 = 0; + int newDir = 0, newDir2 = 0; + + if (_facing != _turnToFacing) { + // Find the index for the given direction in the player direction list + int tempDir = _facing; + do { + ++dirIndex; + newDir += tempDir; + tempDir = _directionListIndexes[tempDir + 10]; + } while (tempDir != _turnToFacing); + } + + + if (_facing != _turnToFacing) { + // Find the index for the given direction in the player direction list + int tempDir = _facing; + do { + ++dirIndex2; + newDir2 += tempDir; + tempDir = _directionListIndexes[tempDir + 20]; + } while (tempDir != _turnToFacing); + } + + int diff = dirIndex - dirIndex2; + if (diff == 0) + diff = newDir - newDir2; + + _facing = (diff >= 0) ? (Facing)_directionListIndexes[_facing + 20] : + (Facing)_directionListIndexes[_facing + 10]; + selectSeries(); + + if ((_facing == _turnToFacing) && !_moving) + updateFrame(); + + _priorTimer += 1; +} + +void Player::cancelCommand() { + cancelWalk(); + _action->_inProgress = false; +} + +void Player::selectSeries() { + Scene &scene = _vm->_game->_scene; + + clearStopList(); + _mirror = false; + + _spritesIdx = _directionListIndexes[_facing]; + if (!_spriteSetsPresent[_spritesIdx]) { + // Direction isn't present, so use alternate direction, with entries flipped + _spritesIdx -= 4; + _mirror = true; + } + + // If the user isn't to be present (such as for a cutscene), exit immediately + // WORKAROUND: Original didn't do a secondary check for the sprite set being + // present, but it's needed to prevent invalid reads during cutscenes + if ((_spritesStart + _spritesIdx) < 0 || !_spriteSetsPresent[_spritesIdx]) + return; + + SpriteAsset &spriteSet = *scene._sprites[_spritesStart + _spritesIdx]; + assert(spriteSet._charInfo); + _velocity = MAX(spriteSet._charInfo->_velocity, 100); + setBaseFrameRate(); + + _frameCount = spriteSet._charInfo->_totalFrames; + if (_frameCount == 0) + _frameCount = spriteSet.getCount(); + + _centerOfGravity = spriteSet._charInfo->_centerOfGravity; + + if ((_frameNumber <= 0) || (_frameNumber > _frameCount)) + _frameNumber = 1; + + _forceRefresh = true; +} + +void Player::updateFrame() { + // WORKAROUND: Prevent character info being referenced when not present + if ((_spritesStart + _spritesIdx) < 0 || !_spriteSetsPresent[_spritesStart + _spritesIdx]) + return; + + Scene &scene = _vm->_game->_scene; + SpriteAsset &spriteSet = *scene._sprites[_spritesStart + _spritesIdx]; + assert(spriteSet._charInfo); + + if (!spriteSet._charInfo->_numEntries) { + _frameNumber = 1; + } else { + _frameListIndex = _stopWalkerList[_stopWalkerIndex]; + + if (!_visible) { + _upcomingTrigger = 0; + } else { + _upcomingTrigger = _stopWalkerTrigger[_stopWalkerIndex]; + + if (_stopWalkerIndex > 0) + --_stopWalkerIndex; + } + + // Set the player frame number + int listIndex = ABS(_frameListIndex); + _frameNumber = (_frameListIndex >= 0) ? spriteSet._charInfo->_startFrames[listIndex] : + spriteSet._charInfo->_stopFrames[listIndex]; + + // Set next waiting period in ticks + if (listIndex == 0) { + setBaseFrameRate(); + } else { + _ticksAmount = spriteSet._charInfo->_ticksList[listIndex]; + } + } + + _forceRefresh = true; +} + +void Player::update() { + Scene &scene = _vm->_game->_scene; + + if (_forceRefresh || (_visible != _priorVisible)) { + int slotIndex = getSpriteSlot(); + if (slotIndex >= 0) + scene._spriteSlots[slotIndex]._flags = IMG_ERASE; + + int newDepth = 1; + int yp = MIN(_playerPos.y, (int16)(MADS_SCENE_HEIGHT - 1)); + + for (int idx = 1; idx < 15; ++idx) { + if (scene._sceneInfo->_depthList[newDepth] >= yp) + newDepth = idx + 1; + } + _currentDepth = newDepth; + + // Get the scale + int newScale = getScale(_playerPos.y); + _currentScale = MIN(newScale, 100); + + if (_visible) { + // Player sprite needs to be rendered + SpriteSlot slot; + slot._flags = IMG_UPDATE; + slot._seqIndex = PLAYER_SEQ_INDEX; + slot._spritesIndex = _spritesStart + _spritesIdx; + slot._frameNumber = _mirror ? -_frameNumber : _frameNumber; + slot._position.x = _playerPos.x; + slot._position.y = _playerPos.y + (_centerOfGravity * newScale) / 100; + slot._depth = newDepth; + slot._scale = newScale; + + if (slotIndex >= 0) { + // Check if the existing player slot has the same details, and can be re-used + SpriteSlot &s2 = scene._spriteSlots[slotIndex]; + bool equal = (s2._seqIndex == slot._seqIndex) + && (s2._spritesIndex == slot._spritesIndex) + && (s2._frameNumber == slot._frameNumber) + && (s2._position == slot._position) + && (s2._depth == slot._depth) + && (s2._scale == slot._scale); + + if (equal) + // Undo the prior expiry of the player sprite + s2._flags = IMG_STATIC; + else + slotIndex = -1; + } + + if (slotIndex < 0) { + // New slot needed, so allocate one and copy the slot data + slotIndex = scene._spriteSlots.add(); + scene._spriteSlots[slotIndex] = slot; + } + + // If changing a scene, check to change the scene when the player + // has moved off-screen + if (_walkOffScreen) { + SpriteAsset *asset = scene._sprites[slot._spritesIndex]; + MSprite *frame = asset->getFrame(_frameNumber - 1); + int xScale = frame->w * newScale / 200; + int yScale = frame->h * newScale / 100; + int playerX = slot._position.x; + int playerY = slot._position.y; + + if ((playerX + xScale) < 0 || (playerX + xScale) >= MADS_SCREEN_WIDTH || + playerY < 0 || (playerY + yScale) >= MADS_SCENE_HEIGHT) { + scene._nextSceneId = _walkOffScreen; + _walkOffScreen = 0; + _walkAnywhere = false; + } + } + + } + } + + _beenVisible |= _visible; + _priorVisible = _visible; + _forceRefresh = false; +} + +void Player::clearStopList() { + _stopWalkerList[0] = 0; + _stopWalkerTrigger[0] = 0; + _stopWalkerIndex = 0; + _upcomingTrigger = 0; + _trigger = 0; +} + +void Player::startWalking(const Common::Point &pt, Facing facing) { + Scene &scene = _vm->_game->_scene; + + clearStopList(); + setBaseFrameRate(); + _moving = true; + _targetFacing = facing; + + bool v = scene._depthSurface.getDepthHighBit(pt); + + scene._rails.setupRoute(v, _playerPos, pt); +} + +void Player::walk(const Common::Point &pos, Facing facing) { + cancelWalk(); + _needToWalk = true; + _readyToWalk = true; + _prepareWalkPos = pos; + _prepareWalkFacing = facing; +} + +void Player::nextFrame() { + Scene &scene = _vm->_game->_scene; + + uint32 newTime = _priorTimer + _ticksAmount; + if (scene._frameStartTime >= newTime) { + _priorTimer = scene._frameStartTime; + if (_moving) { + move(); + } else { + idle(); + } + + setFrame(); + update(); + } +} + +void Player::move() { + Scene &scene = _vm->_game->_scene; + Rails &rails = scene._rails; + bool newFacing = false; + + if (_moving) { + while (!_walkOffScreen && _playerPos == _targetPos) { + bool isRouteEmpty = rails.empty(); + if (!isRouteEmpty) { + const WalkNode &node = rails.popNode(); + + _targetPos = node._walkPos; + newFacing = true; + } else if (!_walkOffScreenSceneId) { + // End of walking path + rails.resetRoute(); + _moving = false; + setFinalFacing(); + newFacing = true; + } else { + _walkOffScreen = _walkOffScreenSceneId; + _walkAnywhere = true; + _walkOffScreenSceneId = 0; + _stepEnabled = false; + newFacing = false; + } + + if (!_moving) + break; + } + } + + if (newFacing && _moving) + startMovement(); + + if (_turnToFacing != _facing) + changeFacing(); + else if (!_moving) + updateFrame(); + + int velocity = _velocity; + if (_scalingVelocity && (_totalDistance > 0)) { + int angleRange = 100 - _currentScale; + int angleScale = angleRange * (_posDiff.x - 1) / _totalDistance + _currentScale; + velocity = MAX(1L, (angleScale * _currentScale * velocity) / 10000L); + } + + if (!_moving || (_facing != _turnToFacing)) + return; + + Common::Point newPos = _playerPos; + newFacing = false; + _special = 0; + + if (_distAccum < velocity) { + do { + if (_pixelAccum < _posDiff.x) + _pixelAccum += _posDiff.y; + if (_pixelAccum >= _posDiff.x) { + if ((_posChange.y > 0) || _walkOffScreen) + newPos.y += _yDirection; + --_posChange.y; + _pixelAccum -= _posDiff.x; + } + + if (_pixelAccum < _posDiff.x) { + if ((_posChange.x > 0) || _walkOffScreen) + newPos.x += _xDirection; + --_posChange.x; + } + + if (!_walkAnywhere && !_walkOffScreen && (_walkOffScreenSceneId == 0)) { + newFacing = scene._depthSurface.getDepthHighBit(newPos); + + if (_special == 0) + _special = scene.getDepthHighBits(newPos); + } + + _distAccum += _deltaDistance; + + } while ((_distAccum < velocity) && !newFacing && ((_posChange.x > 0) || (_posChange.y > 0) || (_walkOffScreen != 0))); + } + + _distAccum -= velocity; + + if (newFacing) { + cancelCommand(); + } else { + if (!_walkOffScreen) { + // If the move is complete, make sure the position is exactly on the given destination + if (_posChange.x == 0) + newPos.x = _targetPos.x; + if (_posChange.y == 0) + newPos.y = _targetPos.y; + } + + _playerPos = newPos; + } +} + +void Player::idle() { + Scene &scene = _vm->_game->_scene; + + if (_facing != _turnToFacing) { + // The direction has changed, so reset for new direction + changeFacing(); + return; + } + + if ((_spritesStart + _spritesIdx) < 0 || !_spriteSetsPresent[_spritesStart + _spritesIdx]) + return; + + SpriteAsset &spriteSet = *scene._sprites[_spritesStart + _spritesIdx]; + assert(spriteSet._charInfo); + if (spriteSet._charInfo->_numEntries == 0) + // No entries, so exit immediately + return; + + int frameIndex = ABS(_frameListIndex); + int direction = (_frameListIndex < 0) ? -1 : 1; + + if (frameIndex >= spriteSet._charInfo->_numEntries) { + // Reset back to the start of the list + _frameListIndex = 0; + } else { + _frameNumber += direction; + _forceRefresh = true; + + if (spriteSet._charInfo->_stopFrames[frameIndex] < _frameNumber) { + _trigger = _upcomingTrigger; + updateFrame(); + } + if (spriteSet._charInfo->_startFrames[frameIndex] < _frameNumber) { + _trigger = _upcomingTrigger; + updateFrame(); + } + } +} + +void Player::setFrame() { + if (_moving) { + if (++_frameNumber > _frameCount) + _frameNumber = 1; + _forceRefresh = true; + } else { + if (!_forceRefresh) + idle(); + } +} + +int Player::getSpriteSlot() { + SpriteSlots &spriteSlots = _vm->_game->_scene._spriteSlots; + + for (uint idx = 0; idx < spriteSlots.size(); ++idx) { + if (spriteSlots[idx]._seqIndex == PLAYER_SEQ_INDEX && + spriteSlots[idx]._flags >= IMG_STATIC) + return idx; + } + + return - 1; +} + +int Player::getScale(int yp) { + Scene &scene = _vm->_game->_scene; + + int scale = (scene._bandsRange == 0) ? scene._sceneInfo->_maxScale : + (yp - scene._sceneInfo->_yBandsStart) * scene._scaleRange / scene._bandsRange + + scene._sceneInfo->_minScale; + + return MIN(scale, 100); +} + +void Player::setBaseFrameRate() { + Scene &scene = _vm->_game->_scene; + + SpriteAsset &spriteSet = *scene._sprites[_spritesStart + _spritesIdx]; + assert(spriteSet._charInfo); + + _ticksAmount = spriteSet._charInfo->_ticksAmount; + if (_ticksAmount == 0) + _ticksAmount = 6; +} + +void Player::startMovement() { + int xDiff = _targetPos.x - _playerPos.x; + int yDiff = _targetPos.y - _playerPos.y; + int srcScale = getScale(_playerPos.y); + int destScale = getScale(_targetPos.y); + + // Sets the X direction + if (xDiff > 0) + _xDirection = 1; + else if (xDiff < 0) + _xDirection = -1; + else + _xDirection = 0; + + // Sets the Y direction + if (yDiff > 0) + _yDirection = 1; + else if (yDiff < 0) + _yDirection = -1; + else + _yDirection = 0; + + xDiff = ABS(xDiff); + yDiff = ABS(yDiff); + int scaleDiff = ABS(srcScale - destScale); + + int xAmt100 = xDiff * 100; + int yAmt100 = yDiff * 100; + int xAmt33 = xDiff * 33; + + int scaleAmount = (_scalingVelocity ? scaleDiff * 3 : 0) + 100 * yDiff / 100; + int scaleAmount100 = scaleAmount * 100; + + // Figure out direction that will need to be moved in + int majorDir; + if (xDiff == 0) { + majorDir = 1; + } else if (yDiff == 0) { + majorDir = 3; + } else { + if ((scaleAmount < xDiff) && ((xAmt33 / scaleAmount) >= 141)) + majorDir = 3; + else if (yDiff <= xDiff) + majorDir = 2; + else if ((scaleAmount100 / xDiff) >= 141) + majorDir = 1; + else + majorDir = 2; + } + + switch (majorDir) { + case 1: + _turnToFacing = (_yDirection <= 0) ? FACING_NORTH : FACING_SOUTH; + break; + case 2: { + _turnToFacing = (Facing)(((_yDirection <= 0) ? 9 : 3) - ((_xDirection <= 0) ? 2 : 0)); + break; + } + case 3: + _turnToFacing = (_xDirection <= 0) ? FACING_WEST : FACING_EAST; + break; + default: + break; + } + + _totalDistance = sqrt((double)(xAmt100 * xAmt100 + yAmt100 * yAmt100)); + _posDiff.x = xDiff + 1; + _posDiff.y = yDiff + 1; + _posChange.x = xDiff; + _posChange.y = yDiff; + + int majorChange = MAX(xDiff, yDiff); + _deltaDistance = (majorChange == 0) ? 0 : _totalDistance / majorChange; + + if (_playerPos.x > _targetPos.x) + _pixelAccum = MAX(_posChange.x, _posChange.y); + else + _pixelAccum = 0; + + _totalDistance /= 100; + _distAccum = -_deltaDistance; +} + +void Player::newWalk() { + if (_needToWalk && _readyToWalk) { + startWalking(_prepareWalkPos, _prepareWalkFacing); + _needToWalk = false; + } +} + +void Player::addWalker(int walker, int trigger) { + Scene &scene = _vm->_game->_scene; + SpriteAsset &spriteSet = *scene._sprites[_spritesStart + _spritesIdx]; + assert(spriteSet._charInfo); + + if (walker < spriteSet._charInfo->_numEntries && _stopWalkerIndex < 11) { + ++_stopWalkerIndex; + _stopWalkerList[_stopWalkerIndex] = walker; + _stopWalkerTrigger[_stopWalkerIndex] = trigger; + } +} + + +/** +* Releases any sprites used by the player +*/ +void Player::releasePlayerSprites() { + Scene &scene = _vm->_game->_scene; + + if (_spritesLoaded && _numSprites > 0) { + int spriteEnd = _spritesStart + _numSprites - 1; + do { + scene._sprites.remove(spriteEnd); + } while (--spriteEnd >= _spritesStart); + } + + _numSprites = 0; + _spritesLoaded = false; + _spritesChanged = true; + + if (scene._sprites._assetCount > 0) { + warning("Player::releasePlayerSprites(): leftover sprites remain, clearing list"); + scene._sprites.clear(); + } +} + +void Player::synchronize(Common::Serializer &s) { + s.syncAsByte(_moving); + s.syncAsSint16LE(_playerPos.x); + s.syncAsSint16LE(_playerPos.y); + s.syncAsSint16LE(_targetPos.x); + s.syncAsSint16LE(_targetPos.y); + s.syncAsSint16LE(_xDirection); + s.syncAsSint16LE(_yDirection); + s.syncAsSint16LE(_posDiff.x); + s.syncAsSint16LE(_posDiff.y); + s.syncAsSint16LE(_posChange.x); + s.syncAsSint16LE(_posChange.y); + s.syncAsUint16LE(_targetFacing); + s.syncAsSint16LE(_special); + s.syncAsByte(_forceRefresh); + s.syncAsSint16LE(_ticksAmount); + s.syncAsByte(_walkAnywhere); + s.syncAsUint16LE(_walkOffScreenSceneId); + s.syncAsByte(_walkOffScreen); + s.syncAsByte(_needToWalk); + s.syncAsByte(_readyToWalk); + s.syncAsUint16LE(_prepareWalkFacing); + s.syncAsSint16LE(_prepareWalkPos.x); + s.syncAsSint16LE(_prepareWalkPos.y); + s.syncAsByte(_stepEnabled); + s.syncAsByte(_visible); + s.syncAsByte(_priorVisible); + + for (int i = 0; i < 8; ++i) + s.syncAsByte(_spriteSetsPresent[i]); + + s.syncAsByte(_facing); + s.syncAsByte(_turnToFacing); + s.syncAsSint16LE(_spritesIdx); + s.syncAsSint16LE(_frameNumber); + s.syncAsSint16LE(_currentDepth); + s.syncAsSint16LE(_currentScale); + s.syncAsSint16LE(_frameListIndex); + + for (int i = 0; i < 12; ++i) { + s.syncAsSint16LE(_stopWalkerList[i]); + s.syncAsSint16LE(_stopWalkerTrigger[i]); + } + + s.syncAsSint16LE(_stopWalkerIndex); + s.syncAsSint16LE(_upcomingTrigger); + s.syncAsSint16LE(_trigger); + s.syncAsSint16LE(_scalingVelocity); + s.syncAsSint16LE(_pixelAccum); + s.syncAsSint16LE(_distAccum); + s.syncAsSint16LE(_deltaDistance); + s.syncAsSint16LE(_totalDistance); + s.syncAsSint16LE(_velocity); + s.syncAsUint16LE(_frameCount); + s.syncString(_spritesPrefix); + s.syncAsUint32LE(_priorTimer); + s.syncAsByte(_loadsFirst); + s.syncAsByte(_loadedFirst); + s.syncAsByte(_spritesLoaded); + s.syncAsByte(_spritesChanged); + s.syncAsByte(_beenVisible); + s.syncAsSint16LE(_centerOfGravity); + s.syncAsByte(_mirror); +} + +void Player::removePlayerSprites() { + Scene &scene = _vm->_game->_scene; + int heroSpriteId = _spritesStart; + for (int i = 0; i < 8; i++) { + if (_spriteSetsPresent[i]) { + scene._sprites.remove(heroSpriteId++); + _spriteSetsPresent[i] = false; + } + } + + if (scene._activeAnimation != nullptr) + scene._activeAnimation->resetSpriteSetsCount(); + + scene._spriteSlots.fullRefresh(); + _visible = false; +} + +} // End of namespace MADS diff --git a/engines/mads/player.h b/engines/mads/player.h new file mode 100644 index 0000000000..671ac9d16e --- /dev/null +++ b/engines/mads/player.h @@ -0,0 +1,228 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_PLAYER_H +#define MADS_PLAYER_H + +#include "common/scummsys.h" +#include "common/str.h" +#include "common/serializer.h" + +namespace MADS { + +class MADSEngine; +class MADSAction; + +#define PLAYER_SPRITES_FILE_COUNT 8 +#define MAX_ROUTE_NODES 22 + +/** + * Player facings + */ +enum Facing { + FACING_NORTH = 8, FACING_SOUTH = 2, FACING_EAST = 6, FACING_WEST = 4, + FACING_NORTHEAST = 9, FACING_SOUTHEAST = 3, + FACING_SOUTHWEST = 1, FACING_NORTHWEST = 7, + FACING_NONE = 5, FACING_DUMMY = 0 +}; + +class Player { +private: + static const int _directionListIndexes[32]; +private: + MADSEngine *_vm; + bool _highSprites; + bool _spriteSetsPresent[PLAYER_SPRITES_FILE_COUNT]; + bool _mirror; + int _frameCount; + int _frameListIndex; + int _distAccum; + int _pixelAccum; + int _deltaDistance; + int _stopWalkerList[12]; + int _stopWalkerTrigger[12]; + int _totalDistance; + + void clearStopList(); + + /** + * If the player is moving, handles figuring out the correct motion + */ + void move(); + + /** + * Update the player's frame number + */ + void setFrame(); + + /** + * Get the sprite slot index for the player + */ + int getSpriteSlot(); + + /** + * Get the scale for the player at the given Y position + */ + int getScale(int yp); + + /** + * Sets the frame rate for the current sprite set + */ + void setBaseFrameRate(); + + /** + * Starts a player moving to a given destination + */ + void startMovement(); + + void changeFacing(); +public: + MADSAction *_action; + + Facing _facing; + Facing _turnToFacing; + Facing _prepareWalkFacing; + int _xDirection, _yDirection; + Facing _targetFacing; + bool _spritesLoaded; + int _spritesStart; + int _spritesIdx; + int _numSprites; + bool _stepEnabled; + bool _spritesChanged; + bool _visible; + bool _priorVisible; + bool _beenVisible; + bool _walkAnywhere; + int _frameNumber; + bool _loadsFirst; + bool _loadedFirst; + Common::Point _playerPos; + Common::Point _targetPos; + Common::Point _posChange; + Common::Point _posDiff; + Common::Point _prepareWalkPos; + bool _moving; + int _walkOffScreen, _walkOffScreenSceneId; + int _special; + int _ticksAmount; + uint32 _priorTimer; + int _velocity; + int _upcomingTrigger; + int _trigger; + bool _scalingVelocity; + bool _forceRefresh; + bool _needToWalk; + bool _readyToWalk; + int _stopWalkerIndex; + int _centerOfGravity; + int _currentDepth; + int _currentScale; + Common::String _spritesPrefix; +public: + Player(MADSEngine *vm); + + /** + * Load sprites for the player + */ + bool loadSprites(const Common::String &prefix); + + /** + * Called when the player has reached the given destination, start him + * turning to the specified facing + */ + void setFinalFacing(); + + /** + * Stops the player walking + */ + void cancelWalk(); + + /** + * Cancels any oustanding player action + */ + void cancelCommand(); + + /** + * Set up control parameters for the current active series (the + * direction which the player is facing in) */ + void selectSeries(); + + /* + * Moves to the next frame for the currently active player sprite set + */ + void updateFrame(); + + void update(); + + /** + * Handler method for when the player is not moving + */ + void idle(); + + /** + * Starts the player walking towards a given point and direction facing + * @param pos Destination location + * @param facing Direction to face once the destination is reached + */ + void startWalking(const Common::Point &pt, Facing facing); + + /** + * Used by the game scripst to make the player walk to a given destination. + * The difference from startWalking is that this contains several extra + * layers of checking that startWalking bypasses. + */ + void walk(const Common::Point &pos, Facing facing); + + /** + * If a new walk sequence is pending, and has been okayed by the preparser, + * start the actual walking + */ + void newWalk(); + + void nextFrame(); + + /** + * Add a walker to the current queue + */ + void addWalker(int walker, int trigger); + + /** + * Delete any sprites used by the player + */ + void releasePlayerSprites(); + + /** + * Serialize the data of the player + */ + void synchronize(Common::Serializer &s); + + static void preloadSequences(const Common::String &prefix, int level) { + // No implementation in ScummVM + } + + void removePlayerSprites(); +}; + +} // End of namespace MADS + +#endif /* MADS_PLAYER_H */ diff --git a/engines/mads/rails.cpp b/engines/mads/rails.cpp new file mode 100644 index 0000000000..6beee5a242 --- /dev/null +++ b/engines/mads/rails.cpp @@ -0,0 +1,284 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/rails.h" + +namespace MADS { + +WalkNode::WalkNode() { + _active = false; + Common::fill(&_distances[0], &_distances[MAX_ROUTE_NODES], 0); +} + +void WalkNode::load(Common::SeekableReadStream *f) { + _walkPos.x = f->readSint16LE(); + _walkPos.y = f->readSint16LE(); + for (int i = 0; i < MAX_ROUTE_NODES; ++i) + _distances[i] = f->readUint16LE(); +} + +/*------------------------------------------------------------------------*/ + +Rails::Rails() { + _depthSurface = nullptr; + _routeLength = 0; +} + +void Rails::load(const WalkNodeList &nodes, DepthSurface *depthSurface, int depthStyle) { + // Store the depth surface and depth style to use + _depthSurface = depthSurface; + _depthStyle = depthStyle; + + // Load the passed node list + _nodes.clear(); + + for (uint i = 0; i < nodes.size(); ++i) + _nodes.push_back(nodes[i]); + + // Add two more empty nodes for the start and end points of any walk sequence + _nodes.push_back(WalkNode()); + _nodes.push_back(WalkNode()); +} + + +void Rails::setupRoute(bool bitFlag, const Common::Point &srcPos, const Common::Point &destPos) { + // Reset the nodes in as being inactive + for (uint i = 0; i < _nodes.size(); ++i) + _nodes[i]._active = false; + + // Set the two extra walk nodes to the start and destination positions + setNodePosition(_nodes.size() - 2, srcPos); + setNodePosition(_nodes.size() - 1, destPos); + + // Start constructing route node list + _routeLength = 0x3FFF; + _routeIndexes.clear(); + + // Recursively form a route from the destination walk node back to the player's position + setupRouteNode(&_tempRoute[0], _nodes.size() - 1, bitFlag ? 0xC000 : 0x8000, 0); + + _next = 0; + if (_routeIndexes.size() > 0) { + Common::Point currPos = srcPos; + for (int routeCtr = size() - 1; (routeCtr >= 0) && !_next; --routeCtr) { + int idx = _routeIndexes[routeCtr]; + const Common::Point &pt = _nodes[idx]._walkPos; + + _next = scanPath(currPos, pt); + currPos = pt; + } + } +} + +void Rails::setupRouteNode(int *routeIndexP, int nodeIndex, int flags, int routeLength) { + WalkNode ¤tNode = _nodes[nodeIndex]; + currentNode._active = true; + + *routeIndexP++ = nodeIndex; + + // Get the index of the ultimate source position (the player) + int subIndex = _nodes.size() - 2; + + int distanceVal = _nodes[nodeIndex]._distances[subIndex]; + if (distanceVal & flags) { + routeLength += distanceVal & 0x3FFF; + if (routeLength < _routeLength) { + // Found a new shorter route to destination, so set up the route with the found one + _routeIndexes.clear(); + for (int i = 0; routeIndexP != &_tempRoute[i]; ++i) + _routeIndexes.push(_tempRoute[i]); + _routeLength = routeLength; + } + } else { + for (int idx = _nodes.size() - 2; idx > 0; --idx) { + int nodePos = idx - 1; + if (!_nodes[nodePos]._active && ((currentNode._distances[nodePos] & flags) != 0)) + setupRouteNode(routeIndexP, nodePos, 0x8000, routeLength + (distanceVal & 0x3fff)); + } + } + + currentNode._active = false; +} + + +int Rails::scanPath(const Common::Point &srcPos, const Common::Point &destPos) { + // For compressed depth surfaces, always return 0 + if (_depthStyle == 2) + return 0; + + int yDiff = destPos.y - srcPos.y; + int yAmount = MADS_SCREEN_WIDTH; + + if (yDiff < 0) { + yDiff = -yDiff; + yAmount = -yAmount; + } + + int xDiff = destPos.x - srcPos.x; + int xDirection = 1; + int xAmount = 0; + if (xDiff < 0) { + xDiff = -xDiff; + xDirection = -xDirection; + xAmount = MIN(yDiff, xDiff); + } + + ++xDiff; + ++yDiff; + + const byte *srcP = _depthSurface->getBasePtr(srcPos.x, srcPos.y); + int index = xAmount; + + // Outer loop + for (int xCtr = 0; xCtr < xDiff; ++xCtr, srcP += xDirection) { + index += yDiff; + int v = (*srcP & 0x7F) >> 4; + if (v) + return v; + + // Inner loop for handling vertical movement + while (index >= xDiff) { + index -= xDiff; + + v = (*srcP & 0x7F) >> 4; + if (v) + return v; + + srcP += yAmount; + } + } + + return 0; +} + +void Rails::resetRoute() { + _routeIndexes.clear(); + _next = 0; +} + +const WalkNode &Rails::popNode() { + assert(!_routeIndexes.empty()); + + return _nodes[_routeIndexes.pop()]; +} + +void Rails::setNodePosition(int nodeIndex, const Common::Point &pt) { + int flags, hypotenuse; + + _nodes[nodeIndex]._walkPos = pt; + + // Recalculate inter-node lengths + for (uint idx = 0; idx < _nodes.size(); ++idx) { + int entry; + if (idx == (uint)nodeIndex) { + entry = 0x3FFF; + } else { + // Process the node + flags = getRouteFlags(pt, _nodes[idx]._walkPos); + + int xDiff = ABS(_nodes[idx]._walkPos.x - pt.x); + int yDiff = ABS(_nodes[idx]._walkPos.y - pt.y); + hypotenuse = sqrt((double)(xDiff * xDiff + yDiff * yDiff)); + + if (hypotenuse >= 0x3FFF) + // Shouldn't ever be this large + hypotenuse = 0x3FFF; + + entry = hypotenuse | flags; + } + + _nodes[idx]._distances[nodeIndex] = entry; + _nodes[nodeIndex]._distances[idx] = entry; + } +} + +int Rails::getRouteFlags(const Common::Point &src, const Common::Point &dest) { + int result = 0x8000; + bool flag = false; + + int xDiff = ABS(dest.x - src.x); + int yDiff = ABS(dest.y - src.y); + int xDirection = dest.x >= src.x ? 1 : -1; + int yDirection = dest.y >= src.y ? _depthSurface->w : -_depthSurface->w; + int minorDiff = 0; + if (dest.x < src.x) + minorDiff = MIN(xDiff, yDiff); + ++xDiff; + ++yDiff; + + byte *srcP = _depthSurface->getBasePtr(src.x, src.y); + + int totalCtr = minorDiff; + for (int xCtr = 0; xCtr < xDiff; ++xCtr, srcP += xDirection) { + totalCtr += yDiff; + + if ((*srcP & 0x80) == 0) + flag = false; + else if (!flag) { + flag = true; + result -= 0x4000; + if (result == 0) + break; + } + + while (totalCtr >= xDiff) { + totalCtr -= xDiff; + + if ((*srcP & 0x80) == 0) + flag = false; + else if (!flag) { + flag = true; + result -= 0x4000; + if (result == 0) + break; + } + + srcP += yDirection; + } + if (result == 0) + break; + } + + return result; +} + +void Rails::synchronize(Common::Serializer &s) { + s.syncAsSint16LE(_routeLength); + s.syncAsSint16LE(_next); + + int count = _routeIndexes.size(); + if (s.isSaving()) { + for (int i = 0; i < count; ++i) + s.syncAsUint16LE(_routeIndexes[i]); + } else { + _routeIndexes.clear(); + for (int i = 0; i < count; ++i) { + int v = 0; + s.syncAsUint16LE(v); + _routeIndexes.push(v); + } + } +} + +} // End of namespace MADS diff --git a/engines/mads/rails.h b/engines/mads/rails.h new file mode 100644 index 0000000000..e6cab08f85 --- /dev/null +++ b/engines/mads/rails.h @@ -0,0 +1,134 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_RAILS_H +#define MADS_RAILS_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "common/rect.h" +#include "common/serializer.h" +#include "common/stack.h" +#include "mads/msurface.h" + +namespace MADS { + +class WalkNode { +public: + Common::Point _walkPos; + uint16 _distances[MAX_ROUTE_NODES]; + bool _active; + + /** + * Constructor + */ + WalkNode(); + + /** + * Loads the scene node + */ + void load(Common::SeekableReadStream *f); +}; +typedef Common::Array<WalkNode> WalkNodeList; + +/** + * This class handles storing the intermediate walk node points for a + * given scene, and calculating walking routes between any two positions. + */ +class Rails { +private: + WalkNodeList _nodes; + DepthSurface *_depthSurface; + int _depthStyle; + int _routeLength; + int _next; + int _tempRoute[MAX_ROUTE_NODES]; + Common::Stack<int> _routeIndexes; +private: + /** + * Change the position of a walking node. Doing so causes a recalculation of the + * distance between it and every other node, and vice versa + */ + void setNodePosition(int nodeIndex, const Common::Point &pt); + + int getRouteFlags(const Common::Point &src, const Common::Point &dest); +public: + /** + * Constructor + */ + Rails(); + + /** + * Loads the scene data for the list of intermediate walk nodes and the + * depth surface to use. + * @param nodes Intermediate walk-points + * @param depthSurface Depth surface to use + */ + void load(const WalkNodeList &nodes, DepthSurface *depthSurface, int depthStyle); + + /** + * Set up a route between two points in a scene + */ + void setupRoute(bool bitFlag, const Common::Point &srcPos, const Common::Point &destPos); + + void setupRouteNode(int *routeIndexP, int nodeIndex, int flags, int routeLength); + + /** + * Resets any currently running route + */ + void resetRoute(); + + /** + * Scans along an edge connecting two points within the depths/walk surface, and returns the information of the first + * pixel high nibble encountered with a non-zero value + */ + int scanPath(const Common::Point &srcPos, const Common::Point &destPos); + + /* + * Return the number of walk nodes in the calculated route + */ + int size() const { return _routeIndexes.size(); } + + /** + * Returns true if the current calculated walk route is empty + */ + bool empty() const { return _routeIndexes.empty(); } + + /** + * Returns the data for a given walk node + */ + const WalkNode &operator[](int idx) { return _nodes[_routeIndexes[idx]]; } + + const WalkNode &popNode(); + + void resetNext() { _next = 0; } + int getNext() { return _next; } + + /** + * Synchronize the data for the route + */ + void synchronize(Common::Serializer &s); +}; + +} // End of namespace MADS + +#endif /* MADS_RAILS_H */ diff --git a/engines/mads/resources.cpp b/engines/mads/resources.cpp new file mode 100644 index 0000000000..745583b516 --- /dev/null +++ b/engines/mads/resources.cpp @@ -0,0 +1,416 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "common/archive.h" +#include "common/textconsole.h" +#include "mads/mads.h" +#include "mads/resources.h" + +namespace MADS { + +enum ResourceType {RESTYPE_ROOM, RESTYPE_SC, RESTYPE_TEXT, RESTYPE_QUO, RESTYPE_I, + RESTYPE_OB, RESTYPE_FONT, RESTYPE_SOUND, RESTYPE_SPEECH, RESTYPE_HAS_EXT, RESTYPE_NO_EXT}; + +/** + * HAG Archives implementation + */ +class HagArchive : public Common::Archive { +private: + /** + * Details of a single entry in a HAG file index + */ + struct HagEntry { + Common::String _resourceName; + uint32 _offset; + uint32 _size; + + HagEntry(): _offset(0), _size(0) {} + HagEntry(Common::String resourceName, uint32 offset, uint32 size): + _resourceName(resourceName), _offset(offset), _size(size) {} + }; + + class HagIndex { + public: + Common::List<HagEntry> _entries; + Common::String _filename; + }; + + Common::Array<HagIndex> _index; + + /** + * Load the index of all the game's HAG files + */ + void loadIndex(MADSEngine *vm); + + /** + * Given a resource name, opens up the correct HAG file and returns whether + * an entry with the given name exists. + */ + bool getHeaderEntry(const Common::String &resourceName, HagIndex &hagIndex, HagEntry &hagEntry) const; + + /** + * Returns the HAG resource filename that will contain a given resource + */ + Common::String getResourceFilename(const Common::String &resourceName) const; + + /** + * Return a resource type given a resource name + */ + ResourceType getResourceType(const Common::String &resourceName) const; +public: + HagArchive(MADSEngine *vm); + virtual ~HagArchive(); + + // Archive implementation + virtual bool hasFile(const Common::String &name) const; + virtual int listMembers(Common::ArchiveMemberList &list) const; + virtual const Common::ArchiveMemberPtr getMember(const Common::String &name) const; + virtual Common::SeekableReadStream *createReadStreamForMember(const Common::String &name) const; +}; + +const char *const MADSCONCAT_STRING = "MADSCONCAT"; + +HagArchive::HagArchive(MADSEngine *vm) { + loadIndex(vm); +} + +HagArchive::~HagArchive() { +} + +// Archive implementation +bool HagArchive::hasFile(const Common::String &name) const { + HagIndex hagIndex; + HagEntry hagEntry; + return getHeaderEntry(name, hagIndex, hagEntry); +} + +int HagArchive::listMembers(Common::ArchiveMemberList &list) const { + int members = 0; + + for (uint hagCtr = 0; hagCtr < _index.size(); ++hagCtr) { + HagIndex hagIndex = _index[hagCtr]; + Common::List<HagEntry>::iterator i; + + for (i = hagIndex._entries.begin(); i != hagIndex._entries.end(); ++i) { + list.push_back(Common::ArchiveMemberList::value_type( + new Common::GenericArchiveMember((*i)._resourceName, this))); + ++members; + } + } + + return members; +} + +const Common::ArchiveMemberPtr HagArchive::getMember(const Common::String &name) const { + if (!hasFile(name)) + return Common::ArchiveMemberPtr(); + + return Common::ArchiveMemberPtr(new Common::GenericArchiveMember(name, this)); +} + +Common::SeekableReadStream *HagArchive::createReadStreamForMember(const Common::String &name) const { + HagIndex hagIndex; + HagEntry hagEntry; + + if (getHeaderEntry(name, hagIndex, hagEntry)) { + // Entry found. If the correct file is not already open, open it + Common::File f; + if (!f.open(hagIndex._filename)) + error("Could not open HAG file"); + + // Return a new stream for the specific resource + f.seek(hagEntry._offset); + return f.readStream(hagEntry._size); + } + + return nullptr; +} + +void HagArchive::loadIndex(MADSEngine *vm) { + Common::File hagFile; + + for (int sectionIndex = -1; sectionIndex < 11; ++sectionIndex) { + if (sectionIndex == 0) + continue; + + // Dragonsphere does not have some sections - skip them + if (vm->getGameID() == GType_Dragonsphere) { + if (sectionIndex == 7 || sectionIndex == 8) + continue; + } + + // Phantom does not have some sections - skip them + if (vm->getGameID() == GType_Phantom) { + if (sectionIndex == 6 || sectionIndex == 7 || sectionIndex == 8) + continue; + } + + Common::String filename = (sectionIndex == -1) ? "GLOBAL.HAG" : + Common::String::format("SECTION%d.HAG", sectionIndex); + if (sectionIndex == 10) { + // Speech + if (!Common::File::exists("SPEECH.HAG")) + break; + else + filename = "SPEECH.HAG"; + } + if (!hagFile.open(filename)) + error("Could not locate HAG file - %s", filename.c_str()); + + // Check for header + char headerBuffer[16]; + if ((hagFile.read(headerBuffer, 16) != 16) || + (strncmp(headerBuffer, MADSCONCAT_STRING, 10) != 0)) + error("Invalid HAG file opened"); + + // Scan through the HAG index + int numEntries = hagFile.readUint16LE(); + + HagIndex hagIndex; + hagIndex._filename = filename; + + for (int idx = 0; idx < numEntries; ++idx) { + // Read in the details of the next resource + char resourceBuffer[14]; + uint32 offset = hagFile.readUint32LE(); + uint32 size = hagFile.readUint32LE(); + hagFile.read(resourceBuffer, 14); + + hagIndex._entries.push_back(HagEntry(resourceBuffer, offset, size)); + } + + hagFile.close(); + _index.push_back(hagIndex); + } +} + +bool HagArchive::getHeaderEntry(const Common::String &resourceName, + HagIndex &hagIndex, HagEntry &hagEntry) const { + Common::String resName = resourceName; + resName.toUppercase(); + if (resName[0] == '*') + resName.deleteChar(0); + + Common::String hagFilename = getResourceFilename(resName); + + // Find the index for the given file + for (uint hagCtr = 0; hagCtr < _index.size(); ++hagCtr) { + hagIndex = _index[hagCtr]; + + if (hagIndex._filename == hagFilename) { + Common::List<HagEntry>::iterator ei; + for (ei = hagIndex._entries.begin(); ei != hagIndex._entries.end(); ++ei) { + hagEntry = *ei; + if (hagEntry._resourceName.compareToIgnoreCase(resName) == 0) + return true; + } + } + } + + return false; +} + +Common::String HagArchive::getResourceFilename(const Common::String &resourceName) const { + ResourceType resType = getResourceType(resourceName); + Common::String outputFilename = "GLOBAL.HAG"; + + if ((resType == RESTYPE_ROOM) || (resType == RESTYPE_SC)) { + int value = atoi(resourceName.c_str() + 2); + int hagFileNum = (resType == RESTYPE_ROOM) ? value / 100 : value; + + if (hagFileNum > 0) + outputFilename = Common::String::format("SECTION%d.HAG", hagFileNum); + } + + if (resType == RESTYPE_SPEECH) + outputFilename = "SPEECH.HAG"; + + return outputFilename; +} + +ResourceType HagArchive::getResourceType(const Common::String &resourceName) const { + if (resourceName.hasPrefix("RM")) { + // Room resource + return RESTYPE_ROOM; + } else if (resourceName.hasPrefix("SC")) { + // SC resource + return RESTYPE_SC; + } else if (resourceName.hasSuffix(".TXT")) { + // Text resource + return RESTYPE_TEXT; + } else if (resourceName.hasSuffix(".QUO")) { + // QUO resource + return RESTYPE_QUO; + } else if (resourceName.hasPrefix("I")) { + // I resource + return RESTYPE_I; + } else if (resourceName.hasPrefix("OB")) { + // OB resource + return RESTYPE_OB; + } else if (resourceName.hasPrefix("FONT")) { + // FONT resource + return RESTYPE_FONT; + } else if (resourceName.hasPrefix("SOUND")) { + // SOUND resource + return RESTYPE_SOUND; + } else if (resourceName.hasPrefix("SPCHC")) { + // SPEECH resource + return RESTYPE_SPEECH; + } + + // Check for a known extension + const char *extPos = strchr(resourceName.c_str(), '.'); + if (extPos) { + ++extPos; + if (!strcmp(extPos, "FL") || !strcmp(extPos, "LBM") || !strcmp(extPos, "ANM") || + !strcmp(extPos, "AA") || !strcmp(extPos, "SS")) { + return RESTYPE_HAS_EXT; + } + } + + return RESTYPE_NO_EXT; +} + +/*------------------------------------------------------------------------*/ + +void Resources::init(MADSEngine *vm) { + SearchMan.add("HAG", new HagArchive(vm)); +} + +Common::String Resources::formatName(RESPREFIX resType, int id, const Common::String &ext) { + Common::String result = "*"; + + if (resType == 3 && !id) { + id = id / 100; + } + + if (!ext.empty()) { + switch (resType) { + case RESPREFIX_GL: + result += "GL000"; + break; + case RESPREFIX_SC: + result += Common::String::format("SC%.3d", id); + break; + case RESPREFIX_RM: + result += Common::String::format("RM%.3d", id); + break; + default: + break; + } + + result += ext; + } + + return result; +} + +Common::String Resources::formatName(int prefix, char asciiCh, int id, EXTTYPE extType, + const Common::String &suffix) { + Common::String result; + if (prefix <= 0) { + result = "*"; + } else { + result = Common::String::format("%s%.3d", + (prefix < 100) ? "*SC" : "*RM", prefix); + } + + result += Common::String::format("%c", asciiCh); + if (id >= 0) + result += Common::String::format("%d", id); + if (!suffix.empty()) + result += suffix; + + switch (extType) { + case EXT_SS: + result += ".SS"; + break; + case EXT_AA: + result += ".AA"; + break; + case EXT_DAT: + result += ".DAT"; + break; + case EXT_HH: + result += ".HH"; + break; + case EXT_ART: + result += ".ART"; + break; + case EXT_INT: + result += ".INT"; + break; + default: + break; + } + + return result; +} + +Common::String Resources::formatResource(const Common::String &resName, + const Common::String &hagFilename) { +// int v1 = 0, v2 = 0; + + if (resName.hasPrefix("*")) { + // Resource file specified + error("TODO: formatResource"); + } else { + // File outside of hag file + return resName; + } +} + +Common::String Resources::formatAAName(int idx) { + return formatName(0, 'I', idx, EXT_AA, ""); +} + +/*------------------------------------------------------------------------*/ + +void File::openFile(const Common::String &filename) { + if (!Common::File::open(filename)) + error("Could not open file - %s", filename.c_str()); +} + +/*------------------------------------------------------------------------*/ + +void SynchronizedList::synchronize(Common::Serializer &s) { + int v; + int count = size(); + s.syncAsUint16LE(count); + + if (s.isSaving()) { + for (int idx = 0; idx < count; ++idx) { + v = (*this)[idx]; + s.syncAsSint32LE(v); + } + } else { + clear(); + reserve(count); + for (int idx = 0; idx < count; ++idx) { + s.syncAsSint32LE(v); + push_back(v); + } + } +} + +} // End of namespace MADS diff --git a/engines/mads/resources.h b/engines/mads/resources.h new file mode 100644 index 0000000000..003684ef84 --- /dev/null +++ b/engines/mads/resources.h @@ -0,0 +1,89 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_RESOURCES_H +#define MADS_RESOURCES_H + +#include "common/scummsys.h" +#include "common/file.h" +#include "common/serializer.h" +#include "common/str.h" + +namespace MADS { + +class MADSEngine; + +enum RESPREFIX { + RESPREFIX_GL = 1, RESPREFIX_SC = 2, RESPREFIX_RM = 3 +}; + +enum EXTTYPE { + EXT_NONE = -1, EXT_SS = 1, EXT_AA = 2, EXT_DAT = 3, EXT_HH = 4, + EXT_ART = 5, EXT_INT = 6 +}; + +class Resources { +public: + /** + * Instantiates the resource manager + */ + static void init(MADSEngine *vm); + + static Common::String formatName(RESPREFIX resType, int id, const Common::String &ext); + static Common::String formatName(int prefix, char asciiCh, int id, + EXTTYPE extType, const Common::String &suffix); + static Common::String formatResource(const Common::String &resName, const Common::String &hagFilename); + static Common::String formatAAName(int idx); +}; + +/** + * Derived file class + */ +class File: public Common::File { +public: + /** + * Constructor + */ + File(): Common::File() {} + + /** + * Constructor + */ + File(const Common::String &filename) { openFile(filename); } + + /** + * Opens the given file, throwing an error if it can't be opened + */ + void openFile(const Common::String &filename); +}; + +class SynchronizedList : public Common::Array<int> { +public: + /** + * Synchronize the list + */ + void synchronize(Common::Serializer &s); +}; + +} // End of namespace MADS + +#endif /* MADS_RESOURCES_H */ diff --git a/engines/mads/scene.cpp b/engines/mads/scene.cpp new file mode 100644 index 0000000000..4af956a9f6 --- /dev/null +++ b/engines/mads/scene.cpp @@ -0,0 +1,718 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/scene.h" +#include "mads/compression.h" +#include "mads/mads.h" +#include "mads/dragonsphere/dragonsphere_scenes.h" +#include "mads/nebular/nebular_scenes.h" +#include "mads/phantom/phantom_scenes.h" + +namespace MADS { + +Scene::Scene(MADSEngine *vm): _vm(vm), _action(_vm), _depthSurface(vm), + _dirtyAreas(_vm), _dynamicHotspots(vm), _hotspots(vm), + _kernelMessages(vm), _sequences(vm), _sprites(vm), _spriteSlots(vm), + _textDisplay(vm), _userInterface(vm) { + _priorSceneId = 0; + _nextSceneId = 0; + _currentSceneId = 0; + _sceneLogic = nullptr; + _sceneInfo = nullptr; + _cyclingActive = false; + _cyclingThreshold = 0; + _cyclingDelay = 0; + _totalCycleColors = 0; + _depthStyle = 0; + _roomChanged = false; + _reloadSceneFlag = false; + _freeAnimationFlag = false; + _animationData = nullptr; + _activeAnimation = nullptr; + _textSpacing = -1; + _frameStartTime = 0; + _layer = LAYER_GUI; + _lookFlag = false; + _bandsRange = 0; + _scaleRange = 0; + _interfaceY = 0; + _spritesCount = 0; + _variant = 0; + + _paletteUsageF.push_back(PaletteUsage::UsageEntry(0xF)); + + // Set up a scene surface that maps to our physical screen drawing surface + _sceneSurface.init(MADS_SCREEN_WIDTH, MADS_SCENE_HEIGHT, MADS_SCREEN_WIDTH, + _vm->_screen.getPixels(), Graphics::PixelFormat::createFormatCLUT8()); + + // Set up the verb list + _verbList.push_back(VerbInit(VERB_LOOK, VERB_THAT, PREP_NONE)); + _verbList.push_back(VerbInit(VERB_TAKE, VERB_THAT, PREP_NONE)); + _verbList.push_back(VerbInit(VERB_PUSH, VERB_THAT, PREP_NONE)); + _verbList.push_back(VerbInit(VERB_OPEN, VERB_THAT, PREP_NONE)); + _verbList.push_back(VerbInit(VERB_PUT, VERB_THIS, PREP_RELATIONAL)); + _verbList.push_back(VerbInit(VERB_TALKTO, VERB_THAT, PREP_NONE)); + _verbList.push_back(VerbInit(VERB_GIVE, VERB_THIS, PREP_TO)); + _verbList.push_back(VerbInit(VERB_PULL, VERB_THAT, PREP_NONE)); + _verbList.push_back(VerbInit(VERB_CLOSE, VERB_THAT, PREP_NONE)); + _verbList.push_back(VerbInit(VERB_THROW, VERB_THIS, PREP_TO)); +} + +Scene::~Scene() { + delete _sceneLogic; + delete _sceneInfo; +} + +void Scene::clearVocab() { + _activeVocabs.clear(); +} + +void Scene::addActiveVocab(int vocabId) { + if (activeVocabIndexOf(vocabId) == -1) { + assert(_activeVocabs.size() < 200); + _activeVocabs.push_back(vocabId); + } +} + +int Scene::activeVocabIndexOf(int vocabId) { + for (uint i = 0; i < _activeVocabs.size(); ++i) { + if (_activeVocabs[i] == vocabId) + return i; + } + + return -1; +} + +void Scene::clearSequenceList() { + _sequences.clear(); +} + +void Scene::clearMessageList() { + _kernelMessages.clear(); + _talkFont = FONT_CONVERSATION; + _textSpacing = -1; +} + +void Scene::loadSceneLogic() { + delete _sceneLogic; + + switch (_vm->getGameID()) { + case GType_RexNebular: + _sceneLogic = Nebular::SceneFactory::createScene(_vm); + break; + case GType_Dragonsphere: + _sceneLogic = Dragonsphere::SceneFactory::createScene(_vm); + break; + case GType_Phantom: + _sceneLogic = Phantom::SceneFactory::createScene(_vm); + break; + default: + error("Scene logic: Unknown game"); + } +} + +void Scene::loadScene(int sceneId, const Common::String &prefix, bool palFlag) { + // Store the previously active scene number and set the new one + _priorSceneId = _currentSceneId; + _currentSceneId = sceneId; + + _variant = 0; + if (palFlag) + _vm->_palette->resetGamePalette(18, 10); + + _spriteSlots.reset(false); + _sequences.clear(); + _kernelMessages.clear(); + _vm->_palette->_paletteUsage.load(&_scenePaletteUsage); + + int flags = SCENEFLAG_LOAD_SHADOW; + if (_vm->_dithering) + flags |= SCENEFLAG_DITHER; + + _sceneInfo = SceneInfo::init(_vm); + _sceneInfo->load(_currentSceneId, _variant, Common::String(), flags, + _depthSurface, _backgroundSurface); + + // Initialise palette animation for the scene + initPaletteAnimation(_sceneInfo->_paletteCycles, false); + + // Copy over nodes + _rails.load(_sceneInfo->_nodes, &_depthSurface, _sceneInfo->_depthStyle); + + // Load hotspots + loadHotspots(); + + // Load vocab + loadVocab(); + + // Load palette usage + _vm->_palette->_paletteUsage.load(&_paletteUsageF); + + // Load interface + flags = PALFLAG_RESERVED | ANIMFLAG_LOAD_BACKGROUND; + if (_vm->_dithering) + flags |= ANIMFLAG_DITHER; + if (_vm->_textWindowStill) + flags |= ANIMFLAG_LOAD_BACKGROUND_ONLY; + + _animationData = Animation::init(_vm, this); + DepthSurface depthSurface(_vm); + _animationData->load(_userInterface, depthSurface, prefix, flags, nullptr, nullptr); + + _vm->_palette->_paletteUsage.load(&_scenePaletteUsage); + + _bandsRange = _sceneInfo->_yBandsEnd - _sceneInfo->_yBandsStart; + _scaleRange = _sceneInfo->_maxScale - _sceneInfo->_minScale; + + _spriteSlots.reset(false); + _interfaceY = MADS_SCENE_HEIGHT; + _spritesCount = _sprites.size(); + + _userInterface.setup(_vm->_game->_screenObjects._inputMode); + + _vm->_game->_screenObjects._category = CAT_NONE; + _vm->_events->showCursor(); +} + +void Scene::loadHotspots() { + File f(Resources::formatName(RESPREFIX_RM, _currentSceneId, ".HH")); + MadsPack madsPack(&f); + bool isV2 = (_vm->getGameID() != GType_RexNebular); + + Common::SeekableReadStream *stream = madsPack.getItemStream(0); + int count = stream->readUint16LE(); + delete stream; + + stream = madsPack.getItemStream(1); + _hotspots.clear(); + for (int i = 0; i < count; ++i) + _hotspots.push_back(Hotspot(*stream, isV2)); + + delete stream; + f.close(); +} + +void Scene::loadVocab() { + // Add all the verbs to the active vocab list + for (uint i = 0; i < _verbList.size(); ++i) + addActiveVocab(_verbList[i]._id); + + // Load the vocabs for any object descriptions and custom actions + for (uint objIndex = 0; objIndex < _vm->_game->_objects.size(); ++objIndex) { + InventoryObject &io = _vm->_game->_objects[objIndex]; + addActiveVocab(io._descId); + + for (int vocabIndex = 0; vocabIndex <io._vocabCount; ++vocabIndex) { + addActiveVocab(io._vocabList[vocabIndex]._vocabId); + } + } + + // Load scene hotspot list vocabs and verbs + for (uint i = 0; i < _hotspots.size(); ++i) { + addActiveVocab(_hotspots[i]._vocabId); + if (_hotspots[i]._verbId) + addActiveVocab(_hotspots[i]._verbId); + } + + loadVocabStrings(); +} + +void Scene::loadVocabStrings() { + _vocabStrings.clear(); + File f("*VOCAB.DAT"); + Common::String msg; + + for (;;) { + char c = (char)f.readByte(); + if (f.eos()) break; + + if (c == '\0') { + _vocabStrings.push_back(msg); + msg = ""; + } else { + msg += c; + } + } + + f.close(); +} + +uint32 Scene::getVocabStringsCount() const { + return _vocabStrings.size(); +} + +void Scene::initPaletteAnimation(Common::Array<PaletteCycle> &palCycles, bool animFlag) { + // Initialize the animation palette and ticks list + _cycleTicks.clear(); + _paletteCycles.clear(); + + for (uint i = 0; i < palCycles.size(); ++i) { + _cycleTicks.push_back(_vm->_events->getFrameCounter()); + _paletteCycles.push_back(palCycles[i]); + } + + // Save the initial starting palette + Common::copy(&_vm->_palette->_mainPalette[0], &_vm->_palette->_mainPalette[PALETTE_SIZE], + &_vm->_palette->_cyclingPalette[0]); + + // Calculate total + _totalCycleColors = 0; + for (uint i = 0; i < _paletteCycles.size(); ++i) + _totalCycleColors += _paletteCycles[i]._colorCount; + + _cyclingThreshold = (_totalCycleColors > 16) ? 3 : 0; + _cyclingActive = animFlag; +} + +void Scene::animatePalette() { + byte rgb[3]; + + if (_cyclingActive) { + Scene::_cyclingDelay++; + if (_cyclingDelay >= _cyclingThreshold) { + uint32 frameCounter = _vm->_events->getFrameCounter(); + bool changesFlag = false; + for (uint16 idx = 0; idx < _paletteCycles.size(); idx++) { + if (frameCounter >= (_cycleTicks[idx] + _paletteCycles[idx]._ticks)) { + _cycleTicks[idx] = frameCounter; + int count = _paletteCycles[idx]._colorCount; + int first = _paletteCycles[idx]._firstColorIndex; + int listIndex = _paletteCycles[idx]._firstListColor; + changesFlag = true; + + if (count > 1) { + // Make a copy of the last color + byte *pSrc = &_vm->_palette->_cyclingPalette[first * 3]; + byte *pEnd = pSrc + count * 3; + Common::copy(pEnd - 3, pEnd, &rgb[0]); + + // Shift the cycle palette forward one entry + Common::copy_backward(pSrc, pEnd - 3, pEnd); + + // Move the saved color to the start of the cycle + Common::copy(&rgb[0], &rgb[3], pSrc); + + if (++listIndex >= count) + listIndex = 0; + } + + _paletteCycles[idx]._firstListColor = listIndex; + } + } + + if (changesFlag) { + int firstColor = _paletteCycles[0]._firstColorIndex; + byte *pSrc = &_vm->_palette->_cyclingPalette[firstColor * 3]; + _vm->_palette->setPalette(pSrc, firstColor, _totalCycleColors); + } + + _cyclingDelay = 0; + } + } +} + +bool Scene::getDepthHighBits(const Common::Point &pt) { + if (_sceneInfo->_depthStyle == 2) { + return 0; + } else { + const byte *p = _depthSurface.getBasePtr(pt.x, pt.y); + return (*p & 0x70) >> 4; + } +} + +void Scene::loop() { + while (!_vm->shouldQuit() && !_reloadSceneFlag && (_nextSceneId == _currentSceneId)) { + // Handle drawing a game frame + doFrame(); + + // TODO: Verify correctness of frame wait + _vm->_events->waitForNextFrame(); + + if (_vm->_dialogs->_pendingDialog != DIALOG_NONE && !_vm->_game->_trigger + && _vm->_game->_player._stepEnabled) + _reloadSceneFlag = true; + } +} + +void Scene::doFrame() { + Player &player = _vm->_game->_player; + bool flag = false; + + if (_action._selectedAction || !player._stepEnabled) { + _action.clear(); + _action._selectedAction = 0; + } + + if (!_vm->_game->_trigger && !player._trigger) { + // Refresh the dynamic hotspots if they've changed + if (_dynamicHotspots._changed) + _dynamicHotspots.refresh(); + + // Check all on-screen visual objects + _vm->_game->_screenObjects.check(player._stepEnabled && !player._needToWalk && + !_vm->_game->_fx); + } + + if (_action._selectedAction && player._stepEnabled && !player._needToWalk && + !_vm->_game->_trigger && !player._trigger) { + _action.startAction(); + if (_action._activeAction._verbId == Nebular::VERB_LOOK_AT) { + _action._activeAction._verbId = VERB_LOOK; + _action._savedFields._command = false; + } + + flag = true; + } + + if (flag || (_vm->_game->_trigger && _vm->_game->_triggerMode == SEQUENCE_TRIGGER_PREPARE)) { + doPreactions(); + } + + player.newWalk(); + if (!_vm->_game->_fx) + _frameStartTime = _vm->_events->getFrameCounter(); + + // Handle parser actions as well as game triggers + if ((_action._inProgress && !player._moving && !player._needToWalk && + (player._facing == player._turnToFacing) && !_vm->_game->_trigger) || + (_vm->_game->_trigger && (_vm->_game->_triggerMode == SEQUENCE_TRIGGER_PARSER))) { + doAction(); + } + + if (_currentSceneId != _nextSceneId) { + _freeAnimationFlag = true; + } else { + doSceneStep(); + checkKeyboard(); + + if (_currentSceneId != _nextSceneId) { + _freeAnimationFlag = true; + } else { + player.nextFrame(); + + // Cursor update code + updateCursor(); + + if (!_vm->_game->_trigger) { + // Handle any active sequences + _sequences.tick(); + + // Handle any active animation + if (_activeAnimation) + _activeAnimation->update(); + } + + // If the debugget flag is set, show the mouse position + int mouseTextIndex = 0; + if (_vm->_debugger->_showMousePos) { + Common::Point pt = _vm->_events->mousePos(); + Common::String msg = Common::String::format("(%d,%d)", pt.x, pt.y); + mouseTextIndex = _kernelMessages.add(Common::Point(5, 5), + 0x203, 0, 0, 1, msg); + } + + if (!_vm->_game->_trigger) { + if (_reloadSceneFlag || _currentSceneId != _nextSceneId) + _kernelMessages.reset(); + _kernelMessages.update(); + } + + _userInterface._uiSlots.draw(!_vm->_game->_fx, _vm->_game->_fx); + + // Write any text needed by the interface + if (_vm->_game->_fx) + _userInterface.drawTextElements(); + + // Draw any elements + drawElements((ScreenTransition)_vm->_game->_fx, _vm->_game->_fx); + + // Handle message updates + if (_vm->_game->_fx) { + uint32 priorTime = _vm->_game->_priorFrameTimer; + uint32 newTime = _vm->_events->getFrameCounter(); + _sequences.delay(newTime, priorTime); + _kernelMessages.delay(newTime, priorTime); + } + + if (_vm->_debugger->_showMousePos) + // Mouse position display isn't persistent, so remove it + _kernelMessages.remove(mouseTextIndex); + + // Original had a debugger check/call here to allow pausing after + // drawing each frame. Not implemented under ScummVM + } + } + + if (_vm->_game->_fx) + _cyclingActive = true; + _vm->_game->_fx = kTransitionNone; + + if (_freeAnimationFlag) + freeAnimation(); +} + +void Scene::drawElements(ScreenTransition transitionType, bool surfaceFlag) { + // Draw any sprite backgrounds + _spriteSlots.drawBackground(); + + // Set up dirty areas for any text display + _textDisplay.setDirtyAreas(); + + // Merge any identified dirty areas + _dirtyAreas.merge(1, DIRTY_AREAS_SIZE); + + // Copy background for the dirty areas to the screen + _dirtyAreas.copy(&_backgroundSurface, &_vm->_screen, _posAdjust); + + // Handle dirty areas for foreground objects + if (_vm->getGameID() == GType_RexNebular) // TODO: Implement for V2 games + _spriteSlots.setDirtyAreas(); + _textDisplay.setDirtyAreas2(); + _dirtyAreas.merge(1, DIRTY_AREAS_SIZE); + + // Draw sprites that have changed + if (_vm->getGameID() == GType_RexNebular) // TODO: Implement for V2 games + _spriteSlots.drawSprites(&_sceneSurface); + + // Draw text elements onto the view + _textDisplay.draw(&_vm->_screen); + + if (transitionType) { + // Fading in the screen + _vm->_screen.transition(transitionType, surfaceFlag); + _vm->_sound->startQueuedCommands(); + } else { + // Copy dirty areas to the screen + _dirtyAreas.copyToScreen(_vm->_screen._offset); + } + + _spriteSlots.cleanUp(); + _textDisplay.cleanUp(); +} + +void Scene::doPreactions() { + if (_vm->_game->_screenObjects._inputMode == kInputBuildingSentences || + _vm->_game->_screenObjects._inputMode == kInputLimitedSentences) { + _vm->_game->_triggerSetupMode = SEQUENCE_TRIGGER_PREPARE; + _action.checkAction(); + _sceneLogic->preActions(); + + if (_vm->_game->_triggerMode == SEQUENCE_TRIGGER_PREPARE) + _vm->_game->_trigger = 0; + } +} + +void Scene::doAction() { + bool flag = false; + + _vm->_game->_triggerSetupMode = SEQUENCE_TRIGGER_PARSER; + if ((_action._inProgress || _vm->_game->_trigger) && !_action._savedFields._commandError) { + _sceneLogic->actions(); + flag = !_action._inProgress; + } + + if (_vm->_game->_screenObjects._inputMode == kInputConversation) { + _action._inProgress = false; + } else { + if ((_action._inProgress || _vm->_game->_trigger) || + (!flag && _action._savedFields._commandError == flag)) { + _vm->_game->_sectionHandler->sectionPtr2(); + flag = !_action._inProgress; + } + + if ((_action._inProgress || _vm->_game->_trigger) && + (!flag || _action._savedFields._commandError == flag)) { + _vm->_game->doObjectAction(); + } + + if (!_action._savedFields._lookFlag) { + if (_action._inProgress) { + _action._savedFields._commandError = true; + _sceneLogic->postActions(); + } + + if (_action._inProgress) { + _action._savedFields._commandError = true; + _sceneLogic->unhandledAction(); + } + + if (_action._inProgress) + _vm->_game->unhandledAction(); + } + } + + _action._inProgress = false; + if (_vm->_game->_triggerMode == SEQUENCE_TRIGGER_PARSER) + _vm->_game->_trigger = 0; +} + +void Scene::doSceneStep() { + _vm->_game->_triggerSetupMode = SEQUENCE_TRIGGER_DAEMON; + _sceneLogic->step(); + _vm->_game->_sectionHandler->step(); + _vm->_game->step(); + + if (_vm->_game->_triggerMode == SEQUENCE_TRIGGER_DAEMON) + _vm->_game->_trigger = 0; +} + +void Scene::checkKeyboard() { + if (_vm->_events->isKeyPressed()) { + Common::Event evt = _vm->_events->_pendingKeys.pop(); + _vm->_game->handleKeypress(evt); + } + + if ((_vm->_events->_mouseStatus & 3) == 3 && _vm->_game->_player._stepEnabled) { + _reloadSceneFlag = true; + _vm->_dialogs->_pendingDialog = DIALOG_GAME_MENU; + _action.clear(); + _action._selectedAction = 0; + } +} + +void Scene::loadAnimation(const Common::String &resName, int trigger) { + // WORKAROUND: If there's already a previous active animation used by the + // scene, then free it before we create the new one + if (_activeAnimation) + freeAnimation(); + + DepthSurface depthSurface(_vm); + UserInterface interfaceSurface(_vm); + + _activeAnimation = Animation::init(_vm, this); + _activeAnimation->load(interfaceSurface, depthSurface, resName, + _vm->_dithering ? ANIMFLAG_DITHER : 0, nullptr, nullptr); + _activeAnimation->startAnimation(trigger); +} + +void Scene::updateCursor() { + Player &player = _vm->_game->_player; + + CursorType cursorId = CURSOR_ARROW; + if (_action._interAwaiting == AWAITING_COMMAND && !_vm->_events->_rightMousePressed && + _vm->_game->_screenObjects._category == CAT_HOTSPOT) { + int idx = _vm->_game->_screenObjects._selectedObject - + _userInterface._categoryIndexes[CAT_HOTSPOT - 1]; + assert(idx >= 0); + + if (idx >= (int)_hotspots.size()) { + idx -= _hotspots.size(); + _vm->_events->_newCursorId = _dynamicHotspots[idx]._cursor; + } else { + idx = _hotspots.size() - idx - 1; + _vm->_events->_newCursorId = _hotspots[idx]._cursor; + } + + cursorId = _vm->_events->_newCursorId == CURSOR_NONE ? + CURSOR_ARROW : _vm->_events->_newCursorId; + } + + if (!player._stepEnabled) + cursorId = CURSOR_WAIT; + if (cursorId >= _vm->_events->_cursorSprites->getCount()) + cursorId = (CursorType)_vm->_events->_cursorSprites->getCount(); + _vm->_events->_newCursorId = cursorId; + + if (cursorId != _vm->_events->_cursorId) { + _vm->_events->setCursor(cursorId); + } +} + +void Scene::freeCurrentScene() { + if (_animationData) { + delete _animationData; + _animationData = nullptr; + } + if (_activeAnimation) { + delete _activeAnimation; + _activeAnimation = nullptr; + } + + _vm->_palette->_paletteUsage.load(nullptr); + _hotspots.clear(); + _backgroundSurface.free(); + _depthSurface.free(); + + delete _sceneInfo; + _sceneInfo = nullptr; +} + +void Scene::removeSprites() { + for (int idx = _sprites.size() - 1; idx >= _spritesCount; --idx) + _sprites.remove(idx); +} + +void Scene::changeVariant(int variant) { + _variant = variant; + _sceneInfo->loadCodes(_depthSurface, variant); + _spriteSlots.fullRefresh(); +} + +void Scene::resetScene() { + _vm->_game->clearQuotes(); + _spriteSlots.fullRefresh(true); + _sequences.clear(); +} + +void Scene::freeAnimation() { + if (_activeAnimation) { + Player &player = _vm->_game->_player; + + if (!_freeAnimationFlag) { + _spriteSlots.fullRefresh(true); + _sequences.scan(); + } + + // Refresh the player + if (player._visible) { + player._forceRefresh = true; + player.update(); + } + + // Remove any kernel messages in use by the animation + for (uint i = 0; i < _activeAnimation->_messages.size(); ++i) { + int msgIndex = _activeAnimation->_messages[i]._kernelMsgIndex; + if (msgIndex >= 0) + _kernelMessages.remove(msgIndex); + } + + // Delete the animation + delete _activeAnimation; + _activeAnimation = nullptr; + } + + _freeAnimationFlag = false; +} + +void Scene::synchronize(Common::Serializer &s) { + _action.synchronize(s); + _rails.synchronize(s); + _userInterface.synchronize(s); + s.syncAsByte(_reloadSceneFlag); + s.syncAsByte(_roomChanged); + s.syncAsUint16LE(_nextSceneId); + s.syncAsUint16LE(_priorSceneId); + _dynamicHotspots.synchronize(s); +} + +} // End of namespace MADS diff --git a/engines/mads/scene.h b/engines/mads/scene.h new file mode 100644 index 0000000000..7a01d7360a --- /dev/null +++ b/engines/mads/scene.h @@ -0,0 +1,251 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_SCENE_H +#define MADS_SCENE_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "common/rect.h" +#include "mads/assets.h" +#include "mads/screen.h" +#include "mads/hotspots.h" +#include "mads/messages.h" +#include "mads/msurface.h" +#include "mads/scene_data.h" +#include "mads/animation.h" +#include "mads/rails.h" +#include "mads/sequence.h" +#include "mads/sprites.h" +#include "mads/user_interface.h" + +namespace MADS { + +class Scene { +private: + /** + * Return the index of a given Vocab in the active vocab list + */ + int activeVocabIndexOf(int vocabId); + + /** + * Secondary loading vocab list + */ + void loadVocabStrings(); + + /* + * Initialises the data for palette animation within the scene + */ + void initPaletteAnimation(Common::Array<PaletteCycle> &palCycles, bool animFlag); + + /** + * Handles a single frame within the game scene + */ + void doFrame(); + + void doPreactions(); + + void doAction(); + + /** + * Calls all the necessary step handlers for the current frame + */ + void doSceneStep(); + + /** + * Checks whether there's a pending keypress, and if so handles it. + */ + void checkKeyboard(); + + /** + * Checks for a highlighted hotspot, and updates the cursor accordingly + */ + void updateCursor(); +protected: + MADSEngine *_vm; +public: + SceneLogic *_sceneLogic; + MSurface _sceneSurface; + int _priorSceneId; + int _nextSceneId; + int _currentSceneId; + Common::Array<VerbInit> _verbList; + TextDisplayList _textDisplay; + SpriteSlots _spriteSlots; + SpriteSets _sprites; + DynamicHotspots _dynamicHotspots; + Common::Array<int> _activeVocabs; + SequenceList _sequences; + KernelMessages _kernelMessages; + Rails _rails; + Common::String _talkFont; + int _textSpacing; + Hotspots _hotspots; + DirtyAreas _dirtyAreas; + int _variant; + SceneInfo *_sceneInfo; + MSurface _backgroundSurface; + DepthSurface _depthSurface; + UserInterface _userInterface; + bool _cyclingActive; + int _cyclingThreshold; + int _cyclingDelay; + int _totalCycleColors; + Common::Array<uint32> _cycleTicks; + Common::Array<PaletteCycle> _paletteCycles; + Common::StringArray _vocabStrings; + Animation *_animationData; + Animation *_activeAnimation; + bool _freeAnimationFlag; + int _depthStyle; + int _bandsRange; + int _scaleRange; + int _interfaceY; + int _spritesCount; + MADSAction _action; + bool _roomChanged; + bool _reloadSceneFlag; + Common::Point _posAdjust; + uint32 _frameStartTime; + Layer _layer; + bool _lookFlag; + Common::Point _customDest; + Common::Array<PaletteUsage::UsageEntry> _paletteUsageF; + Common::Array<PaletteUsage::UsageEntry> _scenePaletteUsage; + + /** + * Constructor + */ + Scene(MADSEngine *vm); + + /** + * Destructor + */ + ~Scene(); + + /** + * Clear the vocabulary list + */ + void clearVocab(); + + /** + * Add a given vocab entry to the active list + */ + void addActiveVocab(int vocabId); + + /** + * Get the number of entries in the game's vocabulary + */ + uint32 getVocabStringsCount() const; + + /** + * Clear the sequence list + */ + void clearSequenceList(); + + /** + * Clear the message list + */ + void clearMessageList(); + + /** + * Loads the scene logic for a given scene + */ + void loadSceneLogic(); + + /** + * Loads the resources associated with the given scene + * @param sceneId Scene to load + * @param prefix Prefix to use for retrieving animation data + * @param palFlag Flag for whether to reset the high/lo palette areas + */ + void loadScene(int sceneId, const Common::String &prefix, bool palFlag); + + /** + * Loads the hotstpots for the scene + */ + void loadHotspots(); + + /** + * Loads the vocab list + */ + void loadVocab(); + + bool getDepthHighBits(const Common::Point &pt); + + /** + * Main scene loop + */ + void loop(); + + /** + * Draw all the elements onto the scene + */ + void drawElements(ScreenTransition transitionType, bool surfaceFlag); + + /** + * Handles cycling palette colors for the scene + */ + void animatePalette(); + + /** + * Load an animation + */ + void loadAnimation(const Common::String &resName, int trigger = 0); + + /** + * Returns a vocab entry + */ + Common::String getVocab(int vocabId) { return _vocabStrings[vocabId - 1]; } + + /** + * Clear the data for the currently loaded scene + */ + void freeCurrentScene(); + + /** + * Set the walk surface for a scene to a different variant + */ + void changeVariant(int variant); + + void resetScene(); + + /** + * Removes all the scene specific sprites fromt the sprites list, + * leaving any player sprites list in place at the start of the list. + */ + void removeSprites(); + + /** + * Frees any currently active animation for the scene + */ + void freeAnimation(); + + /** + * Synchronise the game + */ + void synchronize(Common::Serializer &s); +}; + +} // End of namespace MADS + +#endif /* MADS_SCENE_H */ diff --git a/engines/mads/scene_data.cpp b/engines/mads/scene_data.cpp new file mode 100644 index 0000000000..5656ac4069 --- /dev/null +++ b/engines/mads/scene_data.cpp @@ -0,0 +1,446 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/scene_data.h" +#include "mads/mads.h" +#include "mads/compression.h" +#include "mads/screen.h" +#include "mads/resources.h" +#include "mads/dragonsphere/dragonsphere_scenes.h" +#include "mads/nebular/nebular_scenes.h" +#include "mads/phantom/phantom_scenes.h" + +namespace MADS { + +KernelMessage::KernelMessage() { + _flags = 0; + _sequenceIndex = 0; + _color1 = 0; + _color2 = 0; + _msgOffset = 0; + _numTicks = 0; + _frameTimer2 = 0; + _frameTimer = 0; + _timeout = 0; + _trigger = 0; + _abortMode = SEQUENCE_TRIGGER_PARSER; + _actionDetails._verbId = VERB_NONE; + _actionDetails._objectNameId = 0; + _actionDetails._indirectObjectId = 0; +} + +/*------------------------------------------------------------------------*/ + +void ARTHeader::load(Common::SeekableReadStream *f, bool isV2) { + if (!isV2) { + // Read in dimensions of image + _width = f->readUint16LE(); + _height = f->readUint16LE(); + } + + // Read in palette information + int palCount = f->readUint16LE(); + for (int i = 0; i < palCount; ++i) { + RGB6 rgb; + rgb.load(f); + _palette.push_back(rgb); + } + f->skip(6 * (256 - palCount)); + + // Read palette animations + int cycleCount = f->readUint16LE(); + for (int i = 0; i < cycleCount; ++i) { + PaletteCycle cycle; + cycle._colorCount = f->readByte(); + cycle._firstListColor = f->readByte(); + cycle._firstColorIndex = f->readByte(); + cycle._ticks = f->readByte(); + + _paletteCycles.push_back(cycle); + } +} + +/*------------------------------------------------------------------------*/ + +void SceneInfo::SpriteInfo::load(Common::SeekableReadStream *f) { + f->skip(3); + _spriteSetIndex = f->readByte(); + f->skip(2); + _position.x = f->readSint16LE(); + _position.y = f->readSint16LE(); + _depth = f->readByte(); + _scale = f->readByte(); +} + +/*------------------------------------------------------------------------*/ + +SceneInfo *SceneInfo::init(MADSEngine *vm) { + switch (vm->getGameID()) { + case GType_RexNebular: + return new Nebular::SceneInfoNebular(vm); + case GType_Dragonsphere: + return new Dragonsphere::SceneInfoDragonsphere(vm); + case GType_Phantom: + return new Phantom::SceneInfoPhantom(vm); + default: + error("SceneInfo: Unknown game"); + } + + return nullptr; +} + +void SceneInfo::load(int sceneId, int variant, const Common::String &resName, + int flags, DepthSurface &depthSurface, MSurface &bgSurface) { + bool sceneFlag = sceneId >= 0; + + // Figure out the resource to use + Common::String resourceName; + if (sceneFlag) { + resourceName = Resources::formatName(RESPREFIX_RM, sceneId, ".DAT"); + } else { + resourceName = "*" + Resources::formatResource(resName, resName); + } + + // Open the scene info resource for access + File infoFile(resourceName); + MadsPack infoPack(&infoFile); + + // Read in basic data + Common::SeekableReadStream *infoStream = infoPack.getItemStream(0); + if (_vm->getGameID() == GType_RexNebular) { + _sceneId = infoStream->readUint16LE(); + } else { + infoStream->skip(6); // actual scene ID (string) + _sceneId = sceneId; + } + + // TODO: The following isn't quite right for V2 games (it's all 0) + _artFileNum = infoStream->readUint16LE(); + _depthStyle = infoStream->readUint16LE(); + _width = infoStream->readUint16LE(); + _height = infoStream->readUint16LE(); + + // HACK for V2 games (for now) + if (_vm->getGameID() != GType_RexNebular) { + _width = 320; + _height = 156; + } + + infoStream->skip(24); + + int nodeCount = infoStream->readUint16LE(); + _yBandsEnd = infoStream->readUint16LE(); + _yBandsStart = infoStream->readUint16LE(); + _maxScale = infoStream->readUint16LE(); + _minScale = infoStream->readUint16LE(); + for (int i = 0; i < DEPTH_BANDS_SIZE; ++i) + _depthList[i] = infoStream->readUint16LE(); + _field4A = infoStream->readUint16LE(); + + // Load the set of objects that are associated with the scene + for (int i = 0; i < 20; ++i) { + WalkNode node; + node.load(infoStream); + + if (i < nodeCount) + _nodes.push_back(node); + } + + int spriteSetsCount = infoStream->readUint16LE(); + int spriteInfoCount = infoStream->readUint16LE(); + + // Load in sprite sets + Common::StringArray setNames; + for (int i = 0; i < 10; ++i) { + char name[64]; + infoStream->read(name, 64); + + if (i < spriteSetsCount) + setNames.push_back(Common::String(name)); + } + + // Load in sprite draw information + Common::Array<SpriteInfo> spriteInfo; + // TODO: The following isn't quite right for V2 games + if (_vm->getGameID() == GType_RexNebular) { + for (int i = 0; i < 50; ++i) { + SpriteInfo info; + info.load(infoStream); + + if (i < spriteInfoCount) + spriteInfo.push_back(info); + } + } + delete infoStream; + + int width = _width; + int height = _height; + + if (!bgSurface.getPixels()) { + bgSurface.setSize(width, height); + } + + if (_depthStyle == 2) + width >>= 2; + if (!depthSurface.getPixels()) { + depthSurface.setSize(width, height); + } + + if (_vm->getGameID() == GType_RexNebular) { + // Load the depth surface with the scene codes + Common::SeekableReadStream *depthStream = infoPack.getItemStream(variant + 1); + loadCodes(depthSurface, depthStream); + delete depthStream; + } + + infoFile.close(); + + if (_vm->getGameID() == GType_RexNebular) { + loadMadsV1Background(sceneId, resName, flags, bgSurface); + loadPalette(sceneId, _artFileNum, resName, flags, bgSurface); + } else { + loadMadsV2Background(sceneId, resName, flags, bgSurface); + loadPalette(sceneId, sceneId, resName, flags, bgSurface); + } + + Common::Array<SpriteAsset *> spriteSets; + Common::Array<int> usageList; + + // TODO: The following isn't quite right for V2 games + if (_vm->getGameID() == GType_RexNebular) { + for (uint i = 0; i < setNames.size(); ++i) { + Common::String setResName; + if (sceneFlag || resName.hasPrefix("*")) + setResName += "*"; + setResName += setNames[i]; + + SpriteAsset *sprites = new SpriteAsset(_vm, setResName, flags); + spriteSets.push_back(sprites); + usageList.push_back(sprites->_usageIndex); + } + } + + _vm->_palette->_paletteUsage.updateUsage(usageList, _usageIndex); + + for (uint i = 0; i < spriteInfo.size(); ++i) { + SpriteInfo &si = spriteInfo[i]; + SpriteAsset *asset = spriteSets[si._spriteSetIndex]; + assert(asset && _depthStyle != 2); + + MSprite *spr = asset->getFrame(asset->getCount() - 1); + bgSurface.copyFrom(spr, si._position, si._depth, &depthSurface, si._scale, + spr->getTransparencyIndex()); + } + + // Free the sprite sets + for (int i = (int)spriteSets.size() - 1; i >= 0; --i) { + warning("TODO: sub_201C8 SPRITE_SET.field_6"); + delete spriteSets[i]; + } +} + +void SceneInfo::loadPalette(int sceneId, int artFileNum, const Common::String &resName, int flags, MSurface &bgSurface) { + bool sceneFlag = sceneId >= 0; + Common::String resourceName; + bool isV2 = (_vm->getGameID() != GType_RexNebular); + Common::String extension = !isV2 ? ".ART" : ".TT"; + int paletteStream = !isV2 ? 0 : 2; + + // Get the ART resource + if (sceneFlag) { + resourceName = Resources::formatName(RESPREFIX_RM, artFileNum, extension); + } else { + resourceName = "*" + Resources::formatResource(resName, resName); + } + + // Load in the ART header and palette + File artFile(resourceName); + MadsPack artResource(&artFile); + Common::SeekableReadStream *stream = artResource.getItemStream(paletteStream); + + ARTHeader artHeader; + artHeader.load(stream, isV2); + delete stream; + + // Copy out the palette animation data + for (uint i = 0; i < artHeader._paletteCycles.size(); ++i) + _paletteCycles.push_back(artHeader._paletteCycles[i]); + + if (!(flags & 1)) { + if (!_vm->_palette->_paletteUsage.empty()) { + _vm->_palette->_paletteUsage.getKeyEntries(artHeader._palette); + _vm->_palette->_paletteUsage.prioritize(artHeader._palette); + } + + _usageIndex = _vm->_palette->_paletteUsage.process(artHeader._palette, + (flags & 0xF800) | 0x8000); + if (_usageIndex > 0) { + _vm->_palette->_paletteUsage.transform(artHeader._palette); + + for (uint i = 0; i < _paletteCycles.size(); ++i) { + byte listColor = _paletteCycles[i]._firstListColor; + _paletteCycles[i]._firstColorIndex = artHeader._palette[listColor]._palIndex; + } + } + } + + if (!(flags & 1)) { + // Translate the background to use the correct palette indexes + bgSurface.translate(artHeader._palette); + } +} + +void SceneInfo::loadMadsV1Background(int sceneId, const Common::String &resName, int flags, MSurface &bgSurface) { + bool sceneFlag = sceneId >= 0; + Common::String resourceName; + Common::SeekableReadStream *stream; + + // Get the ART resource + if (sceneFlag) { + resourceName = Resources::formatName(RESPREFIX_RM, _artFileNum, ".ART"); + } else { + resourceName = "*" + Resources::formatResource(resName, resName); + } + + // Load in the ART data + File artFile(resourceName); + MadsPack artResource(&artFile); + + // Read in the background surface data + assert(_width == bgSurface.w && _height == bgSurface.h); + stream = artResource.getItemStream(1); + stream->read(bgSurface.getPixels(), bgSurface.w * bgSurface.h); + + // Close the ART file + delete stream; + artFile.close(); +} + +void SceneInfo::loadMadsV2Background(int sceneId, const Common::String &resName, int flags, MSurface &bgSurface) { + Common::String tileMapResourceName = Resources::formatName(RESPREFIX_RM, sceneId, ".MM"); + File tileMapFile(tileMapResourceName); + MadsPack tileMapPack(&tileMapFile); + Common::SeekableReadStream *mapStream = tileMapPack.getItemStream(0); + + // Get the details of the tiles and map + mapStream->readUint32LE(); + int tileCountX = mapStream->readUint16LE(); + int tileCountY = mapStream->readUint16LE(); + int tileWidthMap = mapStream->readUint16LE(); + int tileHeightMap = mapStream->readUint16LE(); + int screenWidth = mapStream->readUint16LE(); + int screenHeight = mapStream->readUint16LE(); + int tileCountMap = tileCountX * tileCountY; + delete mapStream; + + // Obtain tile map information + typedef Common::List<Common::SharedPtr<MSurface> > TileSetList; + typedef TileSetList::iterator TileSetIterator; + TileSetList tileSet; + uint16 *tileMap = new uint16[tileCountMap]; + mapStream = tileMapPack.getItemStream(1); + for (int i = 0; i < tileCountMap; ++i) + tileMap[i] = mapStream->readUint16LE(); + delete mapStream; + tileMapFile.close(); + + // -------------------------------------------------------------------------------- + + // Tile data, which needs to be kept compressed, as the tile map offsets refer to + // the compressed data. Each tile is then uncompressed separately + Common::String tileDataResourceName = Resources::formatName(RESPREFIX_RM, sceneId, ".TT"); + File tileDataFile(tileDataResourceName); + MadsPack tileDataPack(&tileDataFile); + Common::SeekableReadStream *tileDataUncomp = tileDataPack.getItemStream(0); + + // Validate that the data matches between the tiles and tile map file and is valid + int tileCount = tileDataUncomp->readUint16LE(); + int tileWidth = tileDataUncomp->readUint16LE(); + int tileHeight = tileDataUncomp->readUint16LE(); + delete tileDataUncomp; + assert(tileCountMap == tileCount); + assert(tileWidth == tileWidthMap); + assert(tileHeight == tileHeightMap); + assert(screenWidth == _width); + assert(screenHeight <= _height); + + // -------------------------------------------------------------------------------- + + // Get tile data + + tileDataUncomp = tileDataPack.getItemStream(1); + FabDecompressor fab; + uint32 compressedTileDataSize = 0; + + for (int i = 0; i < tileCount; i++) { + tileDataUncomp->seek(i * 4, SEEK_SET); + uint32 tileOfs = tileDataUncomp->readUint32LE(); + MSurface* newTile = new MSurface(tileWidth, tileHeight); + + if (i == tileCount - 1) + compressedTileDataSize = tileDataFile.size() - tileOfs; + else + compressedTileDataSize = tileDataUncomp->readUint32LE() - tileOfs; + + //debugCN(kDebugGraphics, "Tile: %i, compressed size: %i\n", i, compressedTileDataSize); + + newTile->empty(); + + byte *compressedTileData = new byte[compressedTileDataSize]; + + tileDataFile.seek(tileDataPack.getDataOffset() + tileOfs, SEEK_SET); + tileDataFile.read(compressedTileData, compressedTileDataSize); + + fab.decompress(compressedTileData, compressedTileDataSize, (byte*)newTile->getPixels(), tileWidth * tileHeight); + tileSet.push_back(TileSetList::value_type(newTile)); + delete[] compressedTileData; + } + + delete tileDataUncomp; + + // -------------------------------------------------------------------------------- + + // Loop through the mapping data to place the tiles on the screen + + uint16 *tIndex = &tileMap[0]; + for (int y = 0; y < tileCountY; y++) { + for (int x = 0; x < tileCountX; x++) { + int tileIndex = *tIndex++; + assert(tileIndex < tileCount); + TileSetIterator tile = tileSet.begin(); + for (int i = 0; i < tileIndex; i++) + ++tile; + ((*tile).get())->copyTo(&bgSurface, Common::Point(x * tileWidth, y * tileHeight)); + } + } + tileSet.clear(); + tileDataFile.close(); +} + +/*------------------------------------------------------------------------*/ + +SceneLogic::SceneLogic(MADSEngine *vm) : _vm(vm) { + _scene = &_vm->_game->_scene; +} + +} // End of namespace MADS diff --git a/engines/mads/scene_data.h b/engines/mads/scene_data.h new file mode 100644 index 0000000000..392383af2f --- /dev/null +++ b/engines/mads/scene_data.h @@ -0,0 +1,223 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_SCENE_DATA_H +#define MADS_SCENE_DATA_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "common/serializer.h" +#include "common/str.h" +#include "common/str-array.h" +#include "common/rect.h" +#include "mads/action.h" +#include "mads/assets.h" +#include "mads/events.h" +#include "mads/game_data.h" +#include "mads/hotspots.h" +#include "mads/messages.h" +#include "mads/rails.h" +#include "mads/user_interface.h" + +namespace MADS { + +class MADSEngine; +class Scene; +class SpriteSlot; + +#define MADS_INTERFACE_HEIGHT 44 +#define MADS_SCENE_HEIGHT 156 + +#define DEPTH_BANDS_SIZE 15 + +#define SPRITE_SLOTS_MAX_SIZE 50 +#define TEXT_DISPLAY_MAX_SIZE 40 +#define DIRTY_AREAS_SIZE (SPRITE_SLOTS_MAX_SIZE + TEXT_DISPLAY_MAX_SIZE) + +enum { + SCENEFLAG_DITHER = 0x01, // Dither to 16 colors + SCENEFLAG_LOAD_SHADOW = 0x10 // Load hard shadows +}; + +class VerbInit { +public: + int _id; + VerbType _verbType; + PrepType _prepType; + + VerbInit() {} + VerbInit(int id, VerbType verbType, PrepType prepType): _id(id), + _verbType(verbType), _prepType(prepType) {} +}; + +class SceneLogic { +protected: + MADSEngine *_vm; + Scene *_scene; +public: + /** + * Constructor + */ + SceneLogic(MADSEngine *vm); + + /** + * Destructor + */ + virtual ~SceneLogic() {} + + /** + * Called to initially setup a scene + */ + virtual void setup() = 0; + + /** + * Called as the scene is entered (made active) + */ + virtual void enter() = 0; + + /** + * Called one per frame + */ + virtual void step() {} + + /** + * Called before an action is started + */ + virtual void preActions() {} + + /** + * Handles scene actions + */ + virtual void actions() = 0; + + /** + * Post-action handling + */ + virtual void postActions() {} + + /** + * Unhandled action handling + */ + virtual void unhandledAction() {} + + /** + * Synchronize any local data for the scene + */ + virtual void synchronize(Common::Serializer &s) {} +}; + +struct ARTHeader { + int _width; + int _height; + Common::Array<RGB6> _palette; + Common::Array<PaletteCycle> _paletteCycles; + + void load(Common::SeekableReadStream *f, bool isV2); +}; + +/** + * Handles general data for a given scene + */ +class SceneInfo { + class SpriteInfo { + public: + int _spriteSetIndex; + Common::Point _position; + int _depth; + int _scale; + + void load(Common::SeekableReadStream *f); + }; +protected: + MADSEngine *_vm; + + /** + * Constructor + */ + SceneInfo(MADSEngine *vm) : _vm(vm) {} +public: + int _sceneId; + int _artFileNum; + int _depthStyle; + int _width; + int _height; + + int _yBandsEnd; + int _yBandsStart; + int _maxScale; + int _minScale; + int _depthList[DEPTH_BANDS_SIZE]; + int _field4A; + + int _usageIndex; + Common::Array<PaletteCycle> _paletteCycles; + WalkNodeList _nodes; +public: + /** + * Destructor + */ + virtual ~SceneInfo() {} + + /** + * Instantiates the class + */ + static SceneInfo *init(MADSEngine *vm); + + /** + * loads the data + */ + void load(int sceneId, int variant, const Common::String &resName, int flags, + DepthSurface &depthSurface, MSurface &bgSurface); + + /** + * Loads the palette for a scene + */ + void loadPalette(int sceneId, int artFileNum, const Common::String &resName, int flags, MSurface &bgSurface); + + /** + * Loads a V1 game background + */ + void loadMadsV1Background(int sceneId, const Common::String &resName, int flags, MSurface &bgSurface); + + /** + * Loads a V2 game background + */ + void loadMadsV2Background(int sceneId, const Common::String &resName, int flags, MSurface &bgSurface); + + /** + * Loads the given surface with depth information of a given scene + * @param depthSurface Depth/walk surface + * @param variant Variant number to load + */ + virtual void loadCodes(MSurface &depthSurface, int variant) = 0; + + /** + * Loads the given surface with depth information of a given scene + * @param depthSurface Depth/walk surface + * @param stream Stream to load the data from + */ + virtual void loadCodes(MSurface &depthSurface, Common::SeekableReadStream *stream) = 0; +}; + +} // End of namespace MADS + +#endif /* MADS_SCENE_DATA_H */ diff --git a/engines/mads/screen.cpp b/engines/mads/screen.cpp new file mode 100644 index 0000000000..dacd20a348 --- /dev/null +++ b/engines/mads/screen.cpp @@ -0,0 +1,641 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/game.h" +#include "mads/screen.h" +#include "mads/palette.h" +#include "mads/user_interface.h" + +namespace MADS { + +MADSEngine *DirtyArea::_vm = nullptr; + +DirtyArea::DirtyArea() { + _active = false; + _textActive = false; + _mergedArea = nullptr; +} + +void DirtyArea::setArea(int width, int height, int maxWidth, int maxHeight) { + if (_bounds.left % 2) { + --_bounds.left; + ++width; + } + + if (_bounds.left < 0) + _bounds.left = 0; + else if (_bounds.left > maxWidth) + _bounds.left = maxWidth; + int right = _bounds.left + width; + if (right < 0) + right = 0; + if (right > maxWidth) + right = maxWidth; + + _bounds.right = right; + + if (_bounds.top < 0) + _bounds.top = 0; + else if (_bounds.top > maxHeight) + _bounds.top = maxHeight; + int bottom = _bounds.top + height; + if (bottom < 0) + bottom = 0; + if (bottom > maxHeight) + bottom = maxHeight; + + _bounds.bottom = bottom; + _active = true; +} + + +void DirtyArea::setSpriteSlot(const SpriteSlot *spriteSlot) { + int width, height; + Scene &scene = _vm->_game->_scene; + + if (spriteSlot->_flags == IMG_REFRESH) { + // Special entry to refresh the entire screen + _bounds.left = 0; + _bounds.top = 0; + width = MADS_SCREEN_WIDTH; + height = MADS_SCENE_HEIGHT; + } else { + // Standard sprite slots + _bounds.left = spriteSlot->_position.x - scene._posAdjust.x; + _bounds.top = spriteSlot->_position.y - scene._posAdjust.y; + + SpriteAsset &spriteSet = *scene._sprites[spriteSlot->_spritesIndex]; + MSprite *frame = spriteSet.getFrame(ABS(spriteSlot->_frameNumber) - 1); + + if (spriteSlot->_scale == -1) { + width = frame->w; + height = frame->h; + } else { + width = frame->w * spriteSlot->_scale / 100; + height = frame->h * spriteSlot->_scale / 100; + + _bounds.left -= width / 2; + _bounds.top += -(height - 1); + } + } + + setArea(width, height, MADS_SCREEN_WIDTH, MADS_SCENE_HEIGHT); +} + +void DirtyArea::setTextDisplay(const TextDisplay *textDisplay) { + _bounds.left = textDisplay->_bounds.left; + _bounds.top = textDisplay->_bounds.top; + + setArea(textDisplay->_bounds.width(), textDisplay->_bounds.height(), + MADS_SCREEN_WIDTH, MADS_SCENE_HEIGHT); +} + +void DirtyArea::setUISlot(const UISlot *slot) { + int type = slot->_flags; + if (type <= IMG_UPDATE_ONLY) + type += -IMG_UPDATE_ONLY; + if (type >= 0x40) + type &= ~0x40; + + MSurface &intSurface = _vm->_game->_scene._userInterface; + switch (type) { + case IMG_REFRESH: + _bounds.left = 0; + _bounds.top = 0; + setArea(intSurface.w, intSurface.h, intSurface.w, intSurface.h); + break; + + case IMG_OVERPRINT: + _bounds.left = slot->_position.x; + _bounds.top = slot->_position.y; + _bounds.setWidth(slot->_width); + _bounds.setHeight(slot->_height); + setArea(slot->_width, slot->_height, intSurface.w, intSurface.h); + break; + + default: { + SpriteAsset *asset = _vm->_game->_scene._sprites[slot->_spritesIndex]; + MSprite *frame = asset->getFrame(slot->_frameNumber - 1); + int w = frame->w; + int h = frame->h; + + if (slot->_segmentId == IMG_SPINNING_OBJECT) { + _bounds.left = slot->_position.x; + _bounds.top = slot->_position.y; + } else { + _bounds.left = slot->_position.x + w / 2; + _bounds.top = slot->_position.y - h + 1; + } + + setArea(w, h, intSurface.w, intSurface.h); + break; + } + } +} + +/*------------------------------------------------------------------------*/ + +DirtyAreas::DirtyAreas(MADSEngine *vm) : _vm(vm) { + DirtyArea::_vm = vm; + + for (int i = 0; i < DIRTY_AREAS_SIZE; ++i) { + DirtyArea rec; + rec._active = false; + push_back(rec); + } +} + +void DirtyAreas::merge(int startIndex, int count) { + if (startIndex >= count) + return; + + for (int outerCtr = startIndex - 1, idx = 0; idx < count; ++outerCtr, ++idx) { + if (!(*this)[outerCtr]._active) + continue; + + for (int innerCtr = outerCtr + 1; innerCtr < count; ++innerCtr) { + if (!(*this)[innerCtr]._active || !intersects(outerCtr, innerCtr)) + continue; + + if ((*this)[outerCtr]._textActive && (*this)[innerCtr]._textActive) + mergeAreas(innerCtr, outerCtr); + } + } +} + +/** +* Returns true if two dirty areas intersect +*/ +bool DirtyAreas::intersects(int idx1, int idx2) { + return (*this)[idx1]._bounds.intersects((*this)[idx2]._bounds); +} + +void DirtyAreas::mergeAreas(int idx1, int idx2) { + DirtyArea &da1 = (*this)[idx1]; + DirtyArea &da2 = (*this)[idx2]; + + da1._bounds.extend(da2._bounds); + + da2._active = false; + da2._mergedArea = &da1; + da1._textActive = true; +} + +void DirtyAreas::copy(MSurface *srcSurface, MSurface *destSurface, const Common::Point &posAdjust) { + for (uint i = 0; i < size(); ++i) { + const Common::Rect &srcBounds = (*this)[i]._bounds; + + // Check if this is a sane rectangle before attempting to create it + if (srcBounds.left >= srcBounds.right || srcBounds.top >= srcBounds.bottom) + continue; + + Common::Rect bounds(srcBounds.left + posAdjust.x, srcBounds.top + posAdjust.y, + srcBounds.right + posAdjust.x, srcBounds.bottom + posAdjust.y); + + if ((*this)[i]._active && bounds.isValidRect()) { + srcSurface->copyTo(destSurface, bounds, Common::Point(bounds.left, bounds.top)); + } + } +} + +void DirtyAreas::copyToScreen(const Common::Point &posAdjust) { + for (uint i = 0; i < size(); ++i) { + const Common::Rect &srcBounds = (*this)[i]._bounds; + + // Check if this is a sane rectangle before attempting to create it + if (srcBounds.left >= srcBounds.right || srcBounds.top >= srcBounds.bottom) + continue; + + Common::Rect bounds(srcBounds.left + posAdjust.x, srcBounds.top + posAdjust.y, + srcBounds.right + posAdjust.x, srcBounds.bottom + posAdjust.y); + + if ((*this)[i]._active && (*this)[i]._bounds.isValidRect()) { + _vm->_screen.copyRectToScreen(bounds); + } + } +} + +void DirtyAreas::reset() { + for (uint i = 0; i < size(); ++i) + (*this)[i]._active = false; +} + +/*------------------------------------------------------------------------*/ + +ScreenObject::ScreenObject() { + _category = CAT_NONE; + _descId = 0; + _layer = 0; +} + +/*------------------------------------------------------------------------*/ + +ScreenObjects::ScreenObjects(MADSEngine *vm) : _vm(vm) { + _objectY = -1; + _forceRescan = false; + _inputMode = kInputBuildingSentences; + _v7FED6 = 0; + _v8332A = 0; + _category = CAT_NONE; + _spotId = 0; + _released = false; + _uiCount = 0; + _selectedObject = -1; + _eventFlag = false; + _baseTime = 0; +} + +void ScreenObjects::add(const Common::Rect &bounds, Layer layer, ScrCategory category, int descId) { + //assert(size() < 100); + + ScreenObject so; + so._bounds = bounds; + so._category = category; + so._descId = descId; + so._layer = layer; + so._active = true; + + push_back(so); +} + +void ScreenObjects::check(bool scanFlag) { + Scene &scene = _vm->_game->_scene; + UserInterface &userInterface = scene._userInterface; + + if (!_vm->_events->_mouseButtons || _inputMode != kInputBuildingSentences) + _vm->_events->_rightMousePressed = false; + + if ((_vm->_events->_mouseMoved || userInterface._scrollbarActive + || _v8332A || _forceRescan) && scanFlag) { + _category = CAT_NONE; + _selectedObject = scanBackwards(_vm->_events->currentPos(), LAYER_GUI); + if (_selectedObject > 0) { + ScreenObject &scrObject = (*this)[_selectedObject]; + _category = (ScrCategory)(scrObject._category & 7); + _spotId = scrObject._descId; + } + + // Handling for easy mouse + ScrCategory category = scene._userInterface._category; + if (_vm->_easyMouse && _vm->_events->_mouseButtons && category != _category + && scene._userInterface._category != CAT_NONE) { + _released = true; + if (category >= CAT_COMMAND && category <= CAT_TALK_ENTRY) { + elementHighlighted(); + } + + scene._action.checkActionAtMousePos(); + } + + //_released = _vm->_events->_mouseReleased; + if (_vm->_events->_vD2 || (_vm->_easyMouse && !_vm->_events->_mouseStatusCopy)) + scene._userInterface._category = _category; + + if (!_vm->_events->_mouseButtons || _vm->_easyMouse) { + if (userInterface._category >= CAT_COMMAND && userInterface._category <= CAT_TALK_ENTRY) { + elementHighlighted(); + } + } + + if (_vm->_events->_mouseButtons || (_vm->_easyMouse && scene._action._interAwaiting > AWAITING_COMMAND + && scene._userInterface._category == CAT_INV_LIST) || + (_vm->_easyMouse && scene._userInterface._category == CAT_HOTSPOT)) { + scene._action.checkActionAtMousePos(); + } + + if (_vm->_events->_mouseReleased) { + scene._action.leftClick(); + scene._userInterface._category = CAT_NONE; + } + + if (_vm->_events->_mouseButtons || _vm->_easyMouse || userInterface._scrollbarActive) + scene._userInterface.updateInventoryScroller(); + + if (_vm->_events->_mouseButtons || _vm->_easyMouse) + scene._action.set(); + + _forceRescan = false; + } + + scene._action.refresh(); + + uint32 currentTicks = _vm->_events->getFrameCounter(); + if (currentTicks >= _baseTime) { + // Check the user interface slots to see if there's any slots that need to be expired + UISlots &uiSlots = userInterface._uiSlots; + for (uint idx = 0; idx < uiSlots.size(); ++idx) { + UISlot &slot = uiSlots[idx]; + + if (slot._flags != IMG_REFRESH && slot._flags > IMG_UPDATE_ONLY + && slot._segmentId != IMG_SPINNING_OBJECT) + slot._flags = IMG_ERASE; + } + + // Any background animation in the user interface + userInterface.doBackgroundAnimation(); + + // Handle animating the selected inventory item + userInterface.inventoryAnim(); + + // Set the base time + _baseTime = currentTicks + 6; + } +} + +int ScreenObjects::scanBackwards(const Common::Point &pt, int layer) { + for (int i = (int)size(); i >= 1; --i) { + ScreenObject &sObj = (*this)[i]; + if (sObj._active && sObj._bounds.contains(pt) && sObj._layer == layer) + return i; + } + + // Entry not found + return 0; +} + +void ScreenObjects::elementHighlighted() { + Scene &scene = _vm->_game->_scene; + UserInterface &userInterface = scene._userInterface; + Common::Array<int> &invList = _vm->_game->_objects._inventoryList; + MADSAction &action = scene._action; + int varA; + int topIndex; + int *idxP; + int var4; + int index; + int indexEnd = -1; + int var8 = 0; + int uiCount; + + switch (userInterface._category) { + case CAT_COMMAND: + index = 10; + indexEnd = 9; + varA = 5; + topIndex = 0; + idxP = !_vm->_events->_rightMousePressed ? &userInterface._highlightedCommandIndex : + &userInterface._selectedActionIndex; + + if (_vm->_events->_rightMousePressed && userInterface._selectedItemVocabIdx >= 0) + userInterface.updateSelection(CAT_INV_VOCAB, -1, &userInterface._selectedItemVocabIdx); + + var4 = _released && !_vm->_events->_rightMousePressed ? 1 : 0; + break; + + case CAT_INV_LIST: + userInterface.scrollInventory(); + + index = MIN((int)invList.size() - userInterface._inventoryTopIndex, 5); + indexEnd = invList.size() - 1; + varA = 0; + topIndex = userInterface._inventoryTopIndex; + idxP = &userInterface._highlightedInvIndex; + var4 = (!_released || (_vm->_events->_mouseButtons && action._interAwaiting == 1)) ? 0 : 1; + break; + + case CAT_INV_VOCAB: + if (userInterface._selectedInvIndex >= 0) { + InventoryObject &invObject = _vm->_game->_objects.getItem( + userInterface._selectedInvIndex); + index = invObject._vocabCount; + indexEnd = index - 1; + } else { + index = 0; + } + + varA = 0; + topIndex = 0; + idxP = _vm->_events->_rightMousePressed ? &userInterface._selectedItemVocabIdx : &userInterface._highlightedItemVocabIndex; + + if (_vm->_events->_rightMousePressed && userInterface._selectedActionIndex >= 0) + userInterface.updateSelection(CAT_COMMAND, -1, &userInterface._selectedActionIndex); + + var4 = _released && !_vm->_events->_rightMousePressed ? 1 : 0; + break; + + case CAT_INV_ANIM: + index = 1; + indexEnd = invList.size() - 1; + varA = 0; + topIndex = userInterface._selectedInvIndex; + idxP = &var8; + var4 = -1; + break; + + case CAT_TALK_ENTRY: + index = userInterface._talkStrings.size(); + indexEnd = index - 1; + varA = 0; + topIndex = 0; + idxP = &userInterface._highlightedCommandIndex; + var4 = -1; + break; + + default: + uiCount = size() - _uiCount; + index = uiCount + scene._hotspots.size(); + indexEnd = index - 1; + varA = 0; + topIndex = 0; + idxP = &var8; + var4 = -1; + break; + } + + int newIndex = -1; + int catIndex = userInterface._categoryIndexes[userInterface._category - 1]; + int newX = 0, newY = 0; + Common::Point currentPos = _vm->_events->currentPos(); + + for (int idx = 0; idx < index && newIndex < 0; ++idx) { + int scrObjIndex = (_category == CAT_HOTSPOT) ? catIndex - idx + index - 1 : + catIndex + idx; + + ScreenObject &scrObject = (*this)[scrObjIndex]; + if (!scrObject._active) + continue; + + const Common::Rect &bounds = scrObject._bounds; + newY = MAX((int)bounds.bottom, newY); + newX = MAX((int)bounds.left, newX); + + if (currentPos.y >= bounds.top && currentPos.y < bounds.bottom) { + if (var4) { + if (currentPos.x >= bounds.left && currentPos.x < bounds.right) { + // Cursor is inside hotspot bounds + newIndex = scrObjIndex - catIndex; + if (_category == CAT_HOTSPOT && newIndex < (int)scene._hotspots.size()) + newIndex = scene._hotspots.size() - newIndex - 1; + } + } else if (!varA) { + newIndex = idx; + } else if (varA <= idx) { + if (currentPos.x > bounds.left) + newIndex = idx; + } else { + if (currentPos.x < bounds.right) + newIndex = idx; + } + } + } + + if (newIndex == -1 && index > 0 && !var4) { + if (_vm->_events->currentPos().y <= newY) { + newIndex = 0; + if (varA && _vm->_events->currentPos().x >= newX) + newIndex = varA; + } else { + newIndex = index - 1; + } + } + + if (newIndex >= 0) + newIndex = MIN(newIndex + topIndex, indexEnd); + + action._pickedWord = newIndex; + + if (_category == CAT_INV_LIST || _category == CAT_INV_ANIM) { + if (action._interAwaiting == 1 && newIndex >= 0 && _released && + (!_vm->_events->_mouseReleased || !_vm->_easyMouse)) + newIndex = -1; + } + + if (_released && !_vm->_events->_rightMousePressed && + (_vm->_events->_mouseReleased || !_vm->_easyMouse)) + newIndex = -1; + + if (_category != CAT_HOTSPOT && _category != CAT_INV_ANIM) + userInterface.updateSelection(_category, newIndex, idxP); +} + +void ScreenObjects::setActive(ScrCategory category, int descId, bool active) { + for (uint idx = 1; idx < size(); ++idx) { + ScreenObject &sObj = (*this)[idx]; + if (sObj._category == category && sObj._descId == descId) + sObj._active = active; + } +} + +void ScreenObjects::synchronize(Common::Serializer &s) { + s.syncAsSint16LE(_selectedObject); + s.syncAsSint16LE(_category); +} + +/*------------------------------------------------------------------------*/ + +ScreenSurface::ScreenSurface() { + _shakeCountdown = -1; + _random = 0x4D2; +} + +void ScreenSurface::init() { + setSize(g_system->getWidth(), g_system->getHeight()); +} + +void ScreenSurface::copyRectToScreen(const Common::Point &destPos, + const Common::Rect &bounds) { + const byte *buf = getBasePtr(destPos.x, destPos.y); + + if (bounds.width() != 0 && bounds.height() != 0) + g_system->copyRectToScreen(buf, this->pitch, bounds.left, bounds.top, + bounds.width(), bounds.height()); +} + +void ScreenSurface::copyRectToScreen(const Common::Rect &bounds) { + copyRectToScreen(Common::Point(bounds.left, bounds.top), bounds); +} + +void ScreenSurface::updateScreen() { + if (_shakeCountdown >= 0) { + _random = _random * 5 + 1; + int offset = (_random >> 8) & 3; + if (_shakeCountdown-- <= 0) + offset = 0; + + // Copy the screen with the left hand hide side of the screen of a given + // offset width shown at the very right. The offset changes to give + // an effect of shaking the screen + offset *= 4; + const byte *buf = getBasePtr(offset, 0); + g_system->copyRectToScreen(buf, this->pitch, 0, 0, + this->pitch - offset, this->h); + if (offset > 0) + g_system->copyRectToScreen(this->pixels, this->pitch, + this->pitch - offset, 0, offset, this->h); + } + + g_system->updateScreen(); +} + +void ScreenSurface::transition(ScreenTransition transitionType, bool surfaceFlag) { + Palette &pal = *_vm->_palette; + byte palData[PALETTE_SIZE]; + + switch (transitionType) { + case kTransitionFadeIn: + case kTransitionFadeOutIn: + Common::fill(&pal._colorValues[0], &pal._colorValues[3], 0); + Common::fill(&pal._colorFlags[0], &pal._colorFlags[3], false); + + if (transitionType == kTransitionFadeOutIn) { + // Fade out + pal.getFullPalette(palData); + pal.fadeOut(palData, nullptr, 0, PALETTE_COUNT, 0, 0, 1, 16); + } + + // Reset palette to black + Common::fill(&palData[0], &palData[PALETTE_SIZE], 0); + pal.setFullPalette(palData); + + copyRectToScreen(getBounds()); + pal.fadeIn(palData, pal._mainPalette, 0, 256, 0, 1, 1, 16); + break; + + case kTransitionBoxInBottomLeft: + case kTransitionBoxInBottomRight: + case kTransitionBoxInTopLeft: + case kTransitionBoxInTopRight: + error("TODO: transition"); + break; + + case kTransitionPanLeftToRight: + case kTransitionPanRightToLeft: + error("TODO: transition"); + + case kTransitionCircleIn1: + case kTransitionCircleIn2: + case kTransitionCircleIn3: + case kTransitionCircleIn4: + error("TODO circle transition"); + + case kCenterVertTransition: + error("TODO: center vert transition"); + + default: + // Quick transitions + break; + } +} + +} // End of namespace MADS diff --git a/engines/mads/screen.h b/engines/mads/screen.h new file mode 100644 index 0000000000..b81fddd87a --- /dev/null +++ b/engines/mads/screen.h @@ -0,0 +1,240 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_SCREEN_H +#define MADS_SCREEN_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "mads/msurface.h" +#include "mads/action.h" + +namespace MADS { + +#define MADS_SCREEN_WIDTH 320 +#define MADS_SCREEN_HEIGHT 200 + +enum Layer { + LAYER_GUI = 19 +}; + +enum ScreenTransition { + kTransitionNone = 0, + kTransitionFadeIn, kTransitionFadeOutIn, + kTransitionBoxInBottomLeft, kTransitionBoxInBottomRight, + kTransitionBoxInTopLeft, kTransitionBoxInTopRight, + kTransitionPanLeftToRight, kTransitionPanRightToLeft, + kTransitionCircleIn1, kTransitionCircleIn2, + kTransitionCircleIn3, kTransitionCircleIn4, + kVertTransition1, kVertTransition2, kVertTransition3, + kVertTransition4, kVertTransition5, kVertTransition6, + kVertTransition7, kCenterVertTransition +}; + +enum InputMode { + kInputBuildingSentences = 0, // Normal sentence building + kInputConversation = 1, // Conversation mode + kInputLimitedSentences = 2 // Use only scene hotspots +}; + +class SpriteSlot; +class TextDisplay; +class UISlot; + +class DirtyArea { +private: + static MADSEngine *_vm; + friend class DirtyAreas; +public: + Common::Rect _bounds; + bool _textActive; + bool _active; + DirtyArea *_mergedArea; + + DirtyArea(); + + void setArea(int width, int height, int maxWidth, int maxHeight); + + /** + * Set up a dirty area for a sprite slot + */ + void setSpriteSlot(const SpriteSlot *spriteSlot); + + /** + * Set up a dirty area for a text display + */ + void setTextDisplay(const TextDisplay *textDisplay); + + /** + * Set up a dirty area for a UI slot + */ + void setUISlot(const UISlot *slot); +}; + +class DirtyAreas : public Common::Array<DirtyArea> { +private: + MADSEngine *_vm; +public: + DirtyAreas(MADSEngine *vm); + + /** + * Merge together any designated dirty areas that overlap + * @param startIndex 1-based starting dirty area starting index + * @param count Number of entries to process + */ + void merge(int startIndex, int count); + + bool intersects(int idx1, int idx2); + void mergeAreas(int idx1, int idx2); + + /** + * Copy the data specified by the dirty rect list between surfaces + * @param srcSurface Source surface + * @param destSurface Dest surface + * @param posAdjust Position adjustment + */ + void copy(MSurface *srcSurface, MSurface *destSurface, const Common::Point &posAdjust); + + /** + * Use the lsit of dirty areas to copy areas of the screen surface to + * the physical screen + * @param posAdjust Position adjustment */ + void copyToScreen(const Common::Point &posAdjust); + + void reset(); +}; + + +class ScreenObject { +public: + bool _active; + Common::Rect _bounds; + ScrCategory _category; + int _descId; + int _layer; + + ScreenObject(); +}; + +class ScreenObjects : public Common::Array<ScreenObject> { +private: + MADSEngine *_vm; + int _objectY; + + int scanBackwards(const Common::Point &pt, int layer); +public: + InputMode _inputMode; + int _v7FED6; + int _v8332A; + int _forceRescan; + int _selectedObject; + ScrCategory _category; + bool _released; + int _uiCount; + bool _eventFlag; + uint32 _baseTime; + int _spotId; + + /* + * Constructor + */ + ScreenObjects(MADSEngine *vm); + + /** + * Add a new item to the list + */ + void add(const Common::Rect &bounds, Layer layer, ScrCategory category, int descId); + + /** + */ + void check(bool scanFlag); + + /** + * Handle an element being highlighted on the screen, and make it active. + */ + void elementHighlighted(); + + /** + * Retrieve a ScreenObject from the list + * @remarks This array is 1-based indexed by the game + */ + ScreenObject &operator[](int idx) { + assert(idx > 0); + return Common::Array<ScreenObject>::operator[](idx - 1); + } + + /** + * Sets an item identified by category and Desc Id as active or not + * @param category Screen category + * @param descId Description for item + * @param active Whether to set item as active or not + */ + void setActive(ScrCategory category, int descId, bool active); + + /** + * Synchronize the data + */ + void synchronize(Common::Serializer &s); +}; + +class ScreenSurface : public MSurface { +private: + uint16 _random; +public: + Common::Point _offset; + int _shakeCountdown; +public: + /** + * Constructor + */ + ScreenSurface(); + + /** + * Initialise the surface + */ + void init(); + + /** + * Copys an area of the screen surface to a given destination position on + * the ScummVM physical screen buffer + * @param destPos Destination position + * @param bounds Area of screen surface to copy + */ + void copyRectToScreen(const Common::Point &destPos, const Common::Rect &bounds); + + /** + * Copys an area of the screen surface to the ScmmVM physical screen buffer + * @param bounds Area of screen surface to copy + */ + void copyRectToScreen(const Common::Rect &bounds); + + /** + * Updates the screen with the contents of the surface + */ + void updateScreen(); + + void transition(ScreenTransition transitionType, bool surfaceFlag); +}; + +} // End of namespace MADS + +#endif /* MADS_SCREEN_H */ diff --git a/engines/mads/sequence.cpp b/engines/mads/sequence.cpp new file mode 100644 index 0000000000..6461102a5e --- /dev/null +++ b/engines/mads/sequence.cpp @@ -0,0 +1,533 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/assets.h" +#include "mads/sequence.h" +#include "mads/scene.h" + +namespace MADS { + +SequenceEntry::SequenceEntry() { + _spritesIndex = 0; + _flipped = 0; + _frameIndex = 0; + _frameStart = 0; + _numSprites = 0; + _animType = ANIMTYPE_NONE; + _frameInc = 0; + _depth = 0; + _scale = 0; + _dynamicHotspotIndex = -1; + _triggerCountdown = 0; + _doneFlag = 0; + _triggerMode = SEQUENCE_TRIGGER_DAEMON; + _numTicks = 0; + _extraTicks = 0; + _timeout = 0; + + _entries._count = 0; + Common::fill(&_entries._mode[0], &_entries._mode[SEQUENCE_ENTRY_SUBSET_MAX], SEQUENCE_TRIGGER_EXPIRE); + Common::fill(&_entries._frameIndex[0], &_entries._frameIndex[SEQUENCE_ENTRY_SUBSET_MAX], 0); + Common::fill(&_entries._trigger[0], &_entries._trigger[SEQUENCE_ENTRY_SUBSET_MAX], 0); +} + +/*------------------------------------------------------------------------*/ + +#define SEQUENCE_LIST_SIZE 30 + +SequenceList::SequenceList(MADSEngine *vm) : _vm(vm) { + // IMPORTANT: Preallocate timer slots. Note that sprite slots refer to entries + // in this list by index, so we can't just add or delete entries later + for (int i = 0; i < SEQUENCE_LIST_SIZE; ++i) { + SequenceEntry rec; + rec._active = false; + rec._dynamicHotspotIndex = -1; + _entries.push_back(rec); + } +} + +void SequenceList::clear() { + for (uint i = 0; i < _entries.size(); ++i) { + _entries[i]._active = false; + _entries[i]._dynamicHotspotIndex = -1; + } +} + +bool SequenceList::addSubEntry(int index, SequenceTrigger mode, int frameIndex, int trigger) { + if (_entries[index]._entries._count >= SEQUENCE_ENTRY_SUBSET_MAX) + return true; + + int subIndex = _entries[index]._entries._count++; + _entries[index]._entries._mode[subIndex] = mode; + _entries[index]._entries._frameIndex[subIndex] = frameIndex; + _entries[index]._entries._trigger[subIndex] = trigger; + + return false; +} + +int SequenceList::add(int spriteListIndex, bool flipped, int frameIndex, int triggerCountdown, int delayTicks, int extraTicks, int numTicks, + int msgX, int msgY, bool nonFixed, int scale, int depth, int frameInc, SpriteAnimType animType, int numSprites, + int frameStart) { + Scene &scene = _vm->_game->_scene; + + // Find a free slot + uint seqIndex = 0; + while ((seqIndex < _entries.size()) && _entries[seqIndex]._active) + ++seqIndex; + if (seqIndex == _entries.size()) + error("TimerList full"); + + if (frameStart <= 0) + frameStart = 1; + if (numSprites == 0) + numSprites = scene._sprites[spriteListIndex]->getCount(); + if (frameStart == numSprites) + frameInc = 0; + + // Set the list entry fields + _entries[seqIndex]._active = true; + _entries[seqIndex]._spritesIndex = spriteListIndex; + _entries[seqIndex]._flipped = flipped; + _entries[seqIndex]._frameIndex = frameIndex; + _entries[seqIndex]._frameStart = frameStart; + _entries[seqIndex]._numSprites = numSprites; + _entries[seqIndex]._animType = animType; + _entries[seqIndex]._frameInc = frameInc; + _entries[seqIndex]._depth = depth; + _entries[seqIndex]._scale = scale; + _entries[seqIndex]._nonFixed = nonFixed; + _entries[seqIndex]._position.x = msgX; + _entries[seqIndex]._position.y = msgY; + _entries[seqIndex]._numTicks = numTicks; + _entries[seqIndex]._extraTicks = extraTicks; + + _entries[seqIndex]._timeout = scene._frameStartTime + delayTicks; + + _entries[seqIndex]._triggerCountdown = triggerCountdown; + _entries[seqIndex]._doneFlag = false; + _entries[seqIndex]._flags = 0; + _entries[seqIndex]._dynamicHotspotIndex = -1; + _entries[seqIndex]._entries._count = 0; + _entries[seqIndex]._triggerMode = _vm->_game->_triggerSetupMode; + + _entries[seqIndex]._actionNouns = _vm->_game->_scene._action._activeAction; + + return seqIndex; +} + +int SequenceList::addTimer(int timeout, int abortVal) { + Scene &scene = _vm->_game->_scene; + uint seqIndex; + for (seqIndex = 0; seqIndex < _entries.size(); ++seqIndex) { + if (!_entries[seqIndex]._active) + break; + } + assert(seqIndex < _entries.size()); + + SequenceEntry &se = _entries[seqIndex]; + se._active = true; + se._spritesIndex = -1; + se._numTicks = timeout; + se._extraTicks = 0; + se._timeout = scene._frameStartTime + timeout; + se._triggerCountdown = true; + se._doneFlag = false; + se._entries._count = 0; + se._triggerMode = _vm->_game->_triggerSetupMode; + se._actionNouns = _vm->_game->_scene._action._activeAction; + addSubEntry(seqIndex, SEQUENCE_TRIGGER_EXPIRE, 0, abortVal); + + return seqIndex; +} + +void SequenceList::remove(int seqIndex) { + Scene &scene = _vm->_game->_scene; + + if (_entries[seqIndex]._active) { + if (_entries[seqIndex]._dynamicHotspotIndex >= 0) + scene._dynamicHotspots.remove(_entries[seqIndex]._dynamicHotspotIndex); + } + + _entries[seqIndex]._active = false; + scene._spriteSlots.deleteTimer(seqIndex); +} + +void SequenceList::setSpriteSlot(int seqIndex, SpriteSlot &spriteSlot) { + Scene &scene = _vm->_game->_scene; + SequenceEntry &timerEntry = _entries[seqIndex]; + SpriteAsset &spriteSet = *scene._sprites[timerEntry._spritesIndex]; + + spriteSlot._flags = spriteSet.isBackground() ? IMG_DELTA : IMG_UPDATE; + spriteSlot._seqIndex = seqIndex; + spriteSlot._spritesIndex = timerEntry._spritesIndex; + spriteSlot._frameNumber = timerEntry._flipped ? -timerEntry._frameIndex : timerEntry._frameIndex; + spriteSlot._depth = timerEntry._depth; + spriteSlot._scale = timerEntry._scale; + + if (!timerEntry._nonFixed) { + spriteSlot._position = timerEntry._position; + } else { + MSprite *sprite = spriteSet.getFrame(timerEntry._frameIndex - 1); + spriteSlot._position = sprite->_offset; + } +} + +bool SequenceList::loadSprites(int seqIndex) { + Scene &scene = _vm->_game->_scene; + SequenceEntry &seqEntry = _entries[seqIndex]; + int slotIndex; + bool result = false; + int idx = -1; + + scene._spriteSlots.deleteTimer(seqIndex); + if (seqEntry._doneFlag) { + remove(seqIndex); + return false; + } + + if (seqEntry._spritesIndex == -1) { + // Doesn't have an associated sprite anymore, so mark as done + seqEntry._doneFlag = true; + } else if ((slotIndex = scene._spriteSlots.add()) >= 0) { + SpriteSlot &spriteSlot = scene._spriteSlots[slotIndex]; + setSpriteSlot(seqIndex, spriteSlot); + + if ((seqEntry._flags != 0) || (seqEntry._dynamicHotspotIndex >= 0)) { + SpriteAsset &spriteSet = *scene._sprites[seqEntry._spritesIndex]; + MSprite *frame = spriteSet.getFrame(seqEntry._frameIndex - 1); + int width = frame->getWidth() * seqEntry._scale / 200; + int height = frame->getHeight() * seqEntry._scale / 100; + Common::Point pt = spriteSlot._position; + + // Handle sprite movement, if present + if (seqEntry._flags & 1) { + seqEntry._posAccum.x += seqEntry._posDiff.x; + if (seqEntry._posAccum.x >= 100) { + int v = seqEntry._posAccum.x / 100; + seqEntry._position.x += v * seqEntry._posSign.x; + seqEntry._posAccum.x -= v * 100; + } + + seqEntry._posAccum.y += seqEntry._posDiff.y; + if (seqEntry._posAccum.y >= 100) { + int v = seqEntry._posAccum.y / 100; + seqEntry._position.y += v * seqEntry._posSign.y; + seqEntry._posAccum.y -= v * 100; + } + } + + if (seqEntry._flags & 2) { + // Check for object having moved off-scren + if ((pt.x + width) < 0 || (pt.x + width) >= MADS_SCREEN_WIDTH || + pt.y < 0 || (pt.y - height) >= MADS_SCENE_HEIGHT) { + result = true; + seqEntry._doneFlag = true; + } + } + + if (seqEntry._dynamicHotspotIndex >= 0) { + DynamicHotspot &dynHotspot = scene._dynamicHotspots[seqEntry._dynamicHotspotIndex]; + + dynHotspot._bounds.left = MAX(pt.x - width, 0); + dynHotspot._bounds.top = MAX(pt.y - height, 0); + dynHotspot._bounds.right = dynHotspot._bounds.left + width; + dynHotspot._bounds.bottom = dynHotspot._bounds.top + height; + + scene._dynamicHotspots._changed = true; + } + } + + // Frame adjustments + if (seqEntry._frameStart != seqEntry._numSprites) + seqEntry._frameIndex += seqEntry._frameInc; + + if (seqEntry._frameIndex >= seqEntry._frameStart) { + if (seqEntry._frameIndex > seqEntry._numSprites) { + result = true; + if (seqEntry._animType == ANIMTYPE_CYCLED) { + // back to the starting frame (cyclic) + seqEntry._frameIndex = seqEntry._frameStart; + } else { + // Switch into reverse mode + seqEntry._frameIndex = seqEntry._numSprites - 1; + seqEntry._frameInc = -1; + } + } + } else { + // Currently in reverse mode and moved past starting frame + result = true; + + if (seqEntry._animType == ANIMTYPE_CYCLED) + { + // Switch back to forward direction again + seqEntry._frameIndex = seqEntry._frameStart + 1; + seqEntry._frameInc = 1; + } else { + // Otherwise reset back to last sprite for further reverse animating + seqEntry._frameIndex = seqEntry._numSprites; + } + } + + if (result && (seqEntry._triggerCountdown != 0)) { + if (--seqEntry._triggerCountdown == 0) + seqEntry._doneFlag = true; + } + } else { + // Out of sprite display slots, so mark entry as done + seqEntry._doneFlag = true; + } + + for (int i = 0; i < seqEntry._entries._count; ++i) { + switch (seqEntry._entries._mode[i]) { + case SEQUENCE_TRIGGER_EXPIRE: + case SEQUENCE_TRIGGER_LOOP: + if (((seqEntry._entries._mode[i] == SEQUENCE_TRIGGER_EXPIRE) && seqEntry._doneFlag) || + ((seqEntry._entries._mode[i] == SEQUENCE_TRIGGER_LOOP) && result)) + idx = i; + break; + + case SEQUENCE_TRIGGER_SPRITE: { + int v = seqEntry._entries._frameIndex[i]; + if ((v == seqEntry._frameIndex) || (v == 0)) + idx = i; + break; + } + + default: + break; + } + } + + if (idx >= 0) { + _vm->_game->_trigger = seqEntry._entries._trigger[idx]; + _vm->_game->_triggerMode = seqEntry._triggerMode; + + if (seqEntry._triggerMode != SEQUENCE_TRIGGER_DAEMON) + scene._action._activeAction = seqEntry._actionNouns; + } + + return result; +} + +/** +* Handles counting down entries in the timer list for action +*/ +void SequenceList::tick() { + Scene &scene = _vm->_game->_scene; + for (uint idx = 0; idx < _entries.size(); ++idx) { + if ((_vm->_game->_fx == 0) && (_vm->_game->_trigger != 0)) + break; + + SequenceEntry &seqEntry = _entries[idx]; + uint32 currentTimer = scene._frameStartTime; + + if (!seqEntry._active || (currentTimer < seqEntry._timeout)) + continue; + + // Set the next timeout for the timer entry + seqEntry._timeout = currentTimer + seqEntry._numTicks; + + // Action the sprite + if (loadSprites(idx)) { + seqEntry._timeout += seqEntry._extraTicks; + } + } +} + +void SequenceList::delay(uint32 priorFrameTime, uint32 currentTime) { + for (uint idx = 0; idx < _entries.size(); ++idx) { + if (_entries[idx]._active) { + _entries[idx]._timeout += currentTime - priorFrameTime; + } + } +} + +void SequenceList::setAnimRange(int seqIndex, int startVal, int endVal) { + Scene &scene = _vm->_game->_scene; + SequenceEntry &seqEntry = _entries[seqIndex]; + SpriteAsset &spriteSet = *scene._sprites[seqEntry._spritesIndex]; + int numSprites = spriteSet.getCount(); + int tempStart, tempEnd; + + switch (startVal) { + case -2: + tempStart = numSprites; + break; + case -1: + tempStart = 1; + break; + default: + tempStart = startVal; + break; + } + + switch (endVal) { + case -2: + case 0: + tempEnd = numSprites; + break; + case -1: + tempEnd = 1; + break; + default: + tempEnd = endVal; + break; + } + + seqEntry._frameStart = tempStart; + seqEntry._numSprites = tempEnd; + + seqEntry._frameIndex = (seqEntry._frameInc >= 0) ? tempStart : tempEnd; +} + +void SequenceList::scan() { + Scene &scene = _vm->_game->_scene; + + for (uint i = 0; i < _entries.size(); ++i) { + if (_entries[i]._active && (_entries[i]._spritesIndex != -1)) { + int idx = scene._spriteSlots.add(); + setSpriteSlot(i, scene._spriteSlots[idx]); + } + } +} + +/** +* Sets the depth of the specified entry in the sequence list +*/ +void SequenceList::setDepth(int seqIndex, int depth) { + _entries[seqIndex]._depth = depth; +} + +void SequenceList::setPosition(int seqIndex, const Common::Point &pt) { + _entries[seqIndex]._position = pt; + _entries[seqIndex]._nonFixed = false; +} + +int SequenceList::addSpriteCycle(int srcSpriteIdx, bool flipped, int numTicks, int triggerCountdown, int timeoutTicks, int extraTicks) { + Scene &scene = _vm->_game->_scene; + MSprite *spriteFrame = scene._sprites[srcSpriteIdx]->getFrame(0); + int depth = scene._depthSurface.getDepth(Common::Point( + spriteFrame->_offset.x + (spriteFrame->w / 2), + spriteFrame->_offset.y + (spriteFrame->h / 2))); + + return add(srcSpriteIdx, flipped, 1, triggerCountdown, timeoutTicks, extraTicks, numTicks, 0, 0, + true, 100, depth - 1, 1, ANIMTYPE_CYCLED, 0, 0); +} + +int SequenceList::addReverseSpriteCycle(int srcSpriteIdx, bool flipped, int numTicks, + int triggerCountdown, int timeoutTicks, int extraTicks) { + Scene &scene = _vm->_game->_scene; + + SpriteAsset *asset = scene._sprites[srcSpriteIdx]; + MSprite *spriteFrame = asset->getFrame(0); + int depth = scene._depthSurface.getDepth(Common::Point( + spriteFrame->_offset.x + (spriteFrame->w / 2), + spriteFrame->_offset.y + (spriteFrame->h / 2))); + + return add(srcSpriteIdx, flipped, asset->getCount(), triggerCountdown, timeoutTicks, extraTicks, + numTicks, 0, 0, true, 100, depth - 1, -1, ANIMTYPE_CYCLED, 0, 0); +} + + +int SequenceList::startCycle(int srcSpriteIndex, bool flipped, int cycleIndex) { + int result = addSpriteCycle(srcSpriteIndex, flipped, INDEFINITE_TIMEOUT, 0, 0, 0); + if (result >= 0) + setAnimRange(result, cycleIndex, cycleIndex); + + return result; +} + +int SequenceList::startReverseCycle(int srcSpriteIndex, bool flipped, int numTicks, + int triggerCountdown, int timeoutTicks, int extraTicks) { + SpriteAsset *sprites = _vm->_game->_scene._sprites[srcSpriteIndex]; + MSprite *frame = sprites->getFrame(0); + int depth = _vm->_game->_scene._depthSurface.getDepth(Common::Point( + frame->_offset.x + frame->w / 2, frame->_offset.y + frame->h / 2)); + + return add(srcSpriteIndex, flipped, 1, triggerCountdown, timeoutTicks, extraTicks, + numTicks, 0, 0, true, 100, depth - 1, 1, ANIMTYPE_REVERSIBLE, 0, 0); +} + +void SequenceList::updateTimeout(int spriteIdx, int seqIndex) { + Player &player = _vm->_game->_player; + int timeout; + + if (spriteIdx >= 0) + timeout = _entries[spriteIdx]._timeout; + else + timeout = player._priorTimer + player._ticksAmount; + + if (seqIndex >= 0) + _entries[seqIndex]._timeout = timeout; + else + player._priorTimer = timeout - player._ticksAmount; + +} + +void SequenceList::setScale(int spriteIdx, int scale) { + _entries[spriteIdx]._scale = scale; +} + +void SequenceList::setMsgLayout(int seqIndex) { + Player &player = _vm->_game->_player; + int yp = player._playerPos.y + (player._centerOfGravity * player._currentScale) / 100; + setPosition(seqIndex, Common::Point(player._playerPos.x, yp)); + setDepth(seqIndex, player._currentDepth); + setScale(seqIndex, player._currentScale); + updateTimeout(-1, seqIndex); +} + +void SequenceList::setDone(int seqIndex) { + _entries[seqIndex]._doneFlag = true; + _entries[seqIndex]._timeout = _vm->_game->_player._priorTimer; +} + +void SequenceList::setMotion(int seqIndex, int flags, int deltaX, int deltaY) { + SequenceEntry &se = _entries[seqIndex]; + se._flags = flags | 1; + + // Set the direction sign for movement + if (deltaX > 0) { + se._posSign.x = 1; + } else if (deltaX < 0) { + se._posSign.x = -1; + } else { + se._posSign.x = 0; + } + + if (deltaY > 0) { + se._posSign.y = 1; + } + else if (deltaY < 0) { + se._posSign.y = -1; + } else { + se._posSign.y = 0; + } + + se._posDiff.x = ABS(deltaX); + se._posDiff.y = ABS(deltaY); + se._posAccum.x = se._posAccum.y = 0; +} + +} // End of namespace diff --git a/engines/mads/sequence.h b/engines/mads/sequence.h new file mode 100644 index 0000000000..ee587ff02d --- /dev/null +++ b/engines/mads/sequence.h @@ -0,0 +1,131 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_SEQUENCE_H +#define MADS_SEQUENCE_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "common/rect.h" +#include "mads/action.h" + +namespace MADS { + +class SpriteSlot; + +enum SequenceTrigger { + SEQUENCE_TRIGGER_EXPIRE = 0, // Trigger when the sequence finishes + SEQUENCE_TRIGGER_LOOP = 1, // Trigger when the sequence loops + SEQUENCE_TRIGGER_SPRITE = 2 // Trigger when sequence reaches specific sprite +}; + +enum SpriteAnimType { ANIMTYPE_NONE = 0, ANIMTYPE_CYCLED = 1, ANIMTYPE_REVERSIBLE = 2 }; + +#define SEQUENCE_ENTRY_SUBSET_MAX 5 + +struct SequenceSubEntries { + int _count; + SequenceTrigger _mode[SEQUENCE_ENTRY_SUBSET_MAX]; + int _frameIndex[SEQUENCE_ENTRY_SUBSET_MAX]; + int _trigger[SEQUENCE_ENTRY_SUBSET_MAX]; +}; + +struct SequenceEntry { + bool _active; + int8 _spritesIndex; + bool _flipped; + + int _frameIndex; + int _frameStart; + int _numSprites; + + SpriteAnimType _animType; + int _frameInc; + + int _depth; + int _scale; + int _dynamicHotspotIndex; + + bool _nonFixed; + uint32 _flags; + + Common::Point _position; + Common::Point _posDiff; + Common::Point _posSign; + Common::Point _posAccum; + int _triggerCountdown; + bool _doneFlag; + SequenceSubEntries _entries; + TriggerMode _triggerMode; + + ActionDetails _actionNouns; + int _numTicks; + int _extraTicks; + uint32 _timeout; + + SequenceEntry(); +}; + +class MADSEngine; + +class SequenceList { +private: + MADSEngine *_vm; + Common::Array<SequenceEntry> _entries; +public: + SequenceList(MADSEngine *vm); + + SequenceEntry &operator[](int index) { return _entries[index]; } + void clear(); + bool addSubEntry(int index, SequenceTrigger mode, int frameIndex, int trigger); + int add(int spriteListIndex, bool flipped, int frameIndex, int triggerCountdown, int delayTicks, + int extraTicks, int numTicks, int msgX, int msgY, bool nonFixed, int scale, int depth, + int frameInc, SpriteAnimType animType, int numSprites, int frameStart); + + int addTimer(int timeout, int abortVal); + void remove(int seqIndex); + void setSpriteSlot(int seqIndex, SpriteSlot &spriteSlot); + bool loadSprites(int seqIndex); + void tick(); + void delay(uint32 priorFrameTime, uint32 currentTime); + void setAnimRange(int seqIndex, int startVal, int endVal); + void scan(); + void setDepth(int seqIndex, int depth); + void setPosition(int seqIndex, const Common::Point &pt); + int addSpriteCycle(int srcSpriteIdx, bool flipped, int numTicks, + int triggerCountdown = 0, int timeoutTicks = 0, int extraTicks = 0); + int addReverseSpriteCycle(int srcSpriteIdx, bool flipped, int numTicks, + int triggerCountdown = 0, int timeoutTicks = 0, int extraTicks = 0); + + int startCycle(int srcSpriteIdx, bool flipped, int cycleIndex); + int startReverseCycle(int srcSpriteIndex, bool flipped, int numTicks, + int triggerCountdown = 0, int timeoutTicks = 0, int extraTicks = 0); + void updateTimeout(int spriteIdx, int seqIndex); + void setScale(int spriteIdx, int scale); + void setMsgLayout(int seqIndex); + void setDone(int seqIndex); + void setMotion(int seqIndex, int flags, int deltaX, int deltaY); +}; + +} // End of namespace MADS + +#endif /* MADS_SEQUENCE_H */ diff --git a/engines/mads/sound.cpp b/engines/mads/sound.cpp new file mode 100644 index 0000000000..bd99aed2f4 --- /dev/null +++ b/engines/mads/sound.cpp @@ -0,0 +1,142 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "audio/audiostream.h" +#include "audio/decoders/raw.h" +#include "common/memstream.h" +#include "mads/sound.h" +#include "mads/mads.h" +#include "mads/nebular/sound_nebular.h" + +namespace MADS { + +SoundManager::SoundManager(MADSEngine *vm, Audio::Mixer *mixer) { + _vm = vm; + _mixer = mixer; + _driver = nullptr; + _pollSoundEnabled = false; + _soundPollFlag = false; + _newSoundsPaused = false; +} + +SoundManager::~SoundManager() { + delete _driver; +} + +void SoundManager::init(int sectionNumber) { + assert(sectionNumber > 0 && sectionNumber < 10); + + switch (_vm->getGameID()) { + case GType_RexNebular: + switch (sectionNumber) { + case 1: + _driver = new Nebular::ASound1(_mixer); + break; + case 2: + _driver = new Nebular::ASound2(_mixer); + break; + case 3: + _driver = new Nebular::ASound3(_mixer); + break; + case 4: + _driver = new Nebular::ASound4(_mixer); + break; + case 5: + _driver = new Nebular::ASound5(_mixer); + break; + case 6: + _driver = new Nebular::ASound6(_mixer); + break; + case 7: + _driver = new Nebular::ASound7(_mixer); + break; + case 8: + _driver = new Nebular::ASound8(_mixer); + break; + case 9: + error("Sound driver 9 not implemented"); + default: + _driver = nullptr; + break; + } + break; + + default: + warning("SoundManager: Unknown game"); + _driver = nullptr; + break; + } +} + +void SoundManager::closeDriver() { + if (_driver) { + command(0); + setEnabled(false); + stop(); + + removeDriver(); + } +} + +void SoundManager::removeDriver() { + delete _driver; + _driver = nullptr; +} + +void SoundManager::setEnabled(bool flag) { + _pollSoundEnabled = flag; + _soundPollFlag = false; +} + +void SoundManager::pauseNewCommands() { + _newSoundsPaused = true; +} + +void SoundManager::startQueuedCommands() { + _newSoundsPaused = false; + + while (!_queuedCommands.empty()) { + int commandId = _queuedCommands.pop(); + command(commandId); + } +} + +void SoundManager::command(int commandId, int param) { + if (_newSoundsPaused) { + if (_queuedCommands.size() < 8) + _queuedCommands.push(commandId); + } else if (_driver) { + _driver->command(commandId, param); + } +} + +void SoundManager::stop() { + if (_driver) + _driver->stop(); +} + +void SoundManager::noise() { + if (_driver) + _driver->noise(); +} + +} // End of namespace MADS diff --git a/engines/mads/sound.h b/engines/mads/sound.h new file mode 100644 index 0000000000..0fd9ac1095 --- /dev/null +++ b/engines/mads/sound.h @@ -0,0 +1,103 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_SOUND_H +#define MADS_SOUND_H + +#include "common/scummsys.h" +#include "common/queue.h" +#include "audio/audiostream.h" +#include "audio/mixer.h" +#include "mads/nebular/sound_nebular.h" + +namespace MADS { + +class MADSEngine; + +class SoundManager { +private: + MADSEngine *_vm; + Audio::Mixer *_mixer; + Nebular::ASound *_driver; + bool _pollSoundEnabled; + bool _soundPollFlag; + bool _newSoundsPaused; + Common::Queue<int> _queuedCommands; +public: + SoundManager(MADSEngine *vm, Audio::Mixer *mixer); + ~SoundManager(); + + /** + * Initialises the sound driver for a given game section + */ + void init(int sectionNumber); + + /** + * Stop any currently active sound and remove the driver + */ + void closeDriver(); + + /** + * Remove the driver + */ + void removeDriver(); + + /** + * Sets the enabled status of the sound + * @flag True if sound should be enabled + */ + void setEnabled(bool flag); + + /** + * Temporarily pause the playback of any new sound commands + */ + void pauseNewCommands(); + + /** + * Stop queueing sound commands, and execute any previously queued ones + */ + void startQueuedCommands(); + + //@{ + /** + * Executes a command on the sound driver + * @param commandid Command Id to execute + * @param param Optional paramater specific to a few commands + */ + void command(int commandId, int param = 0); + + /** + * Stops any currently playing sound + */ + void stop(); + + /** + * Noise + * Some sort of random noise generation? + */ + void noise(); + //@} +}; + +} // End of namespace MADS + +#endif /* MADS_SOUND_H */ diff --git a/engines/mads/sprites.cpp b/engines/mads/sprites.cpp new file mode 100644 index 0000000000..c98a0963f6 --- /dev/null +++ b/engines/mads/sprites.cpp @@ -0,0 +1,416 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "engines/util.h" +#include "graphics/palette.h" +#include "mads/mads.h" +#include "mads/screen.h" +#include "mads/msurface.h" +#include "mads/sprites.h" + +namespace MADS { + +enum { + kEndOfLine = 0, + kEndOfSprite = 1, + kMarker = 2 +}; + +#define TRANSPARENT_COLOR_INDEX 0xFF + +class DepthEntry { +public: + int depth; + int index; + + DepthEntry(int depthAmt, int indexVal) { depth = depthAmt; index = indexVal; } +}; + +bool sortHelper(const DepthEntry &entry1, const DepthEntry &entry2) { + return entry1.depth < entry2.depth; +} + +typedef Common::List<DepthEntry> DepthList; + +/*------------------------------------------------------------------------*/ + +MSprite::MSprite(): MSurface() { +} + +MSprite::MSprite(Common::SeekableReadStream *source, const Common::Array<RGB6> &palette, + const Common::Rect &bounds): + MSurface(bounds.width(), bounds.height()), + _offset(Common::Point(bounds.left, bounds.top)) { + // Load the sprite data + loadSprite(source, palette); +} + +MSprite::~MSprite() { +} + +void MSprite::loadSprite(Common::SeekableReadStream *source, + const Common::Array<RGB6> &palette) { + byte *outp, *lineStart; + bool newLine = false; + + outp = getData(); + lineStart = getData(); + int spriteSize = this->w * this->h; + byte transIndex = getTransparencyIndex(); + Common::fill(outp, outp + spriteSize, transIndex); + + for (;;) { + byte cmd1, cmd2, count, pixel; + + if (newLine) { + outp = lineStart + getWidth(); + lineStart = outp; + newLine = false; + } + + cmd1 = source->readByte(); + + if (cmd1 == 0xFC) + break; + else if (cmd1 == 0xFF) + newLine = true; + else if (cmd1 == 0xFD) { + while (!newLine) { + count = source->readByte(); + if (count == 0xFF) { + newLine = true; + } else { + pixel = source->readByte(); + while (count--) + *outp++ = (pixel == 0xFD) ? getTransparencyIndex() : pixel; + } + } + } else { + while (!newLine) { + cmd2 = source->readByte(); + if (cmd2 == 0xFF) { + newLine = true; + } else if (cmd2 == 0xFE) { + count = source->readByte(); + pixel = source->readByte(); + while (count--) + *outp++ = (pixel == 0xFD) ? getTransparencyIndex() : pixel; + } else { + *outp++ = (cmd2 == 0xFD) ? getTransparencyIndex() : cmd2; + } + } + } + } + + // Do a final iteration over the sprite to convert it's pixels to + // the final positions in the main palette + for (outp = getData(); spriteSize > 0; --spriteSize, ++outp) { + if (*outp != transIndex) + *outp = palette[*outp]._palIndex; + } +} + +byte MSprite::getTransparencyIndex() const { + return TRANSPARENT_COLOR_INDEX; +} + +/*------------------------------------------------------------------------*/ + +MADSEngine *SpriteSlot::_vm = nullptr; + +SpriteSlot::SpriteSlot() { + _flags = IMG_STATIC; + _seqIndex = 0; + _spritesIndex = 0; + _frameNumber = 0; + _depth = 0; + _scale = 0; +} + +SpriteSlot::SpriteSlot(SpriteFlags type, int seqIndex) { + _flags = type; + _seqIndex = seqIndex; + _spritesIndex = 0; + _frameNumber = 0; + _depth = 0; + _scale = 0; +} + +bool SpriteSlot::operator==(const SpriteSlotSubset &other) const { + return (_spritesIndex == other._spritesIndex) && (_frameNumber == other._frameNumber) && + (_position == other._position) && (_depth == other._depth) && + (_scale == other._scale); +} + +void SpriteSlot::copy(const SpriteSlotSubset &other) { + _spritesIndex = other._spritesIndex; + _frameNumber = other._frameNumber; + _position = other._position; + _depth = other._depth; + _scale = other._scale; +} + +/*------------------------------------------------------------------------*/ + +SpriteSlots::SpriteSlots(MADSEngine *vm) : _vm(vm) { + SpriteSlot::_vm = vm; +} + +void SpriteSlots::reset(bool flag) { + _vm->_game->_scene._textDisplay.reset(); + + if (flag) + _vm->_game->_scene._sprites.clear(); + + Common::Array<SpriteSlot>::clear(); + push_back(SpriteSlot(IMG_REFRESH, -1)); +} + +void SpriteSlots::deleteEntry(int index) { + remove_at(index); +} + +void SpriteSlots::setDirtyAreas() { + Scene &scene = _vm->_game->_scene; + + for (uint i = 0; i < size(); ++i) { + if ((*this)[i]._flags >= IMG_STATIC) { + scene._dirtyAreas[i].setSpriteSlot(&(*this)[i]); + + scene._dirtyAreas[i]._textActive = ((*this)[i]._flags <= IMG_STATIC) ? 0 : 1; + (*this)[i]._flags = IMG_STATIC; + } + } +} + +void SpriteSlots::fullRefresh(bool clearAll) { + if (clearAll) + Common::Array<SpriteSlot>::clear(); + + push_back(SpriteSlot(IMG_REFRESH, -1)); +} + +void SpriteSlots::deleteTimer(int seqIndex) { + for (uint idx = 0; idx < size(); ++idx) { + SpriteSlot &slot = (*this)[idx]; + if (slot._seqIndex == seqIndex) { + slot._flags = IMG_ERASE; + return; + } + } +} + +int SpriteSlots::add() { + SpriteSlot ss; + push_back(ss); + return size() - 1; +} + +void SpriteSlots::drawBackground() { + Scene &scene = _vm->_game->_scene; + + // Initial draw loop for any active sprites in the background + for (uint i = 0; i < size(); ++i) { + SpriteSlot &spriteSlot = (*this)[i]; + DirtyArea &dirtyArea = scene._dirtyAreas[i]; + + if (spriteSlot._flags >= IMG_STATIC) { + // Foreground sprite, so we can ignore it + dirtyArea._active = false; + } else { + dirtyArea._active = true; + dirtyArea.setSpriteSlot(&spriteSlot); + + if (spriteSlot._flags == IMG_DELTA) { + // Background object, so need to draw it + assert(spriteSlot._frameNumber > 0); + SpriteAsset *asset = scene._sprites[spriteSlot._spritesIndex]; + MSprite *frame = asset->getFrame(spriteSlot._frameNumber - 1); + + Common::Point pt = spriteSlot._position; + if (spriteSlot._scale != -1) { + // Adjust the drawing position + pt.x -= frame->w / 2; + pt.y -= frame->h / 2; + } + + + if (spriteSlot._depth <= 1) { + frame->copyTo(&scene._backgroundSurface, pt, frame->getTransparencyIndex()); + } else if (scene._depthStyle == 0) { + scene._backgroundSurface.copyFrom(frame, pt, spriteSlot._depth, &scene._depthSurface, + 100, frame->getTransparencyIndex()); + } else { + error("Unsupported depth style"); + } + } + } + } + + // Mark any remaning sprite slot dirty areas as inactive + for (uint i = size(); i < SPRITE_SLOTS_MAX_SIZE; ++i) + scene._dirtyAreas[i]._active = false; + + // Flag any active text display + for (uint i = 0; i < scene._textDisplay.size(); ++i) { + TextDisplay &textDisplay = scene._textDisplay[i]; + DirtyArea &dirtyArea = scene._dirtyAreas[i + SPRITE_SLOTS_MAX_SIZE]; + + if (textDisplay._expire >= 0 || !textDisplay._active) { + dirtyArea._active = false; + } else { + dirtyArea._active = true; + dirtyArea.setTextDisplay(&textDisplay); + } + } +} + +void SpriteSlots::drawSprites(MSurface *s) { + DepthList depthList; + Scene &scene = _vm->_game->_scene; + + // Get a list of sprite object depths for active objects + for (uint i = 0; i < size(); ++i) { + SpriteSlot &spriteSlot = (*this)[i]; + if (spriteSlot._flags >= IMG_STATIC) { + DepthEntry rec(16 - spriteSlot._depth, i); + depthList.push_back(rec); + } + } + + // Sort the list in order of the depth + Common::sort(depthList.begin(), depthList.end(), sortHelper); + + // Loop through each of the objects + DepthList::iterator i; + for (i = depthList.begin(); i != depthList.end(); ++i) { + DepthEntry &de = *i; + SpriteSlot &slot = (*this)[de.index]; + assert(slot._spritesIndex < (int)scene._sprites.size()); + SpriteAsset &spriteSet = *scene._sprites[slot._spritesIndex]; + + // Get the sprite frame + int frameNumber = ABS(slot._frameNumber); + bool flipped = slot._frameNumber < 0; + + assert(frameNumber > 0); + MSprite *sprite = spriteSet.getFrame(frameNumber - 1); + + MSurface *spr = sprite; + if (flipped) { + // Create a flipped copy of the sprite temporarily + spr = sprite->flipHorizontal(); + } + + if ((slot._scale < 100) && (slot._scale != -1)) { + // Minimalised drawing + s->copyFrom(spr, slot._position, slot._depth, &scene._depthSurface, + slot._scale, sprite->getTransparencyIndex()); + } else { + int xp, yp; + + if (slot._scale == -1) { + xp = slot._position.x - scene._posAdjust.x; + yp = slot._position.y - scene._posAdjust.y; + } else { + xp = slot._position.x - (spr->w / 2) - scene._posAdjust.x; + yp = slot._position.y - spr->h - scene._posAdjust.y + 1; + } + + if (slot._depth > 1) { + // Draw the frame with depth processing + s->copyFrom(spr, Common::Point(xp, yp), slot._depth, &scene._depthSurface, + 100, sprite->getTransparencyIndex()); + } else { + // No depth, so simply draw the image + spr->copyTo(s, Common::Point(xp, yp), sprite->getTransparencyIndex()); + } + } + + // Free sprite if it was a flipped one + if (flipped) + delete spr; + } +} + +void SpriteSlots::cleanUp() { + for (int i = (int)size() - 1; i >= 0; --i) { + if ((*this)[i]._flags < IMG_STATIC) + remove_at(i); + } +} + +/*------------------------------------------------------------------------*/ + +SpriteSets::~SpriteSets() { + clear(); +} + +int SpriteSets::add(SpriteAsset *asset, int idx) { + if (idx) + idx = idx + 49; + else + idx = size(); + + if (idx >= (int)size()) + resize(idx + 1); + + if ((*this)[idx]) { + delete (*this)[idx]; + } else { + ++_assetCount; + } + + (*this)[idx] = asset; + return idx; +} + +int SpriteSets::addSprites(const Common::String &resName, int flags) { + return add(new SpriteAsset(_vm, resName, flags)); +} + +void SpriteSets::clear() { + for (uint i = 0; i < size(); ++i) + delete (*this)[i]; + + _assetCount = 0; + Common::Array<SpriteAsset *>::clear(); +} + +void SpriteSets::remove(int idx) { + if (idx >= 0) { + if (idx < ((int)size() - 1)) { + delete (*this)[idx]; + (*this)[idx] = nullptr; + } else { + while (size() > 0 && (*this)[size() - 1] == nullptr) { + remove_at(size() - 1); + } + } + + if (_assetCount > 0) + --_assetCount; + } +} + +} // End of namespace MADS diff --git a/engines/mads/sprites.h b/engines/mads/sprites.h new file mode 100644 index 0000000000..f807e733b7 --- /dev/null +++ b/engines/mads/sprites.h @@ -0,0 +1,239 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_SPRITES_H +#define MADS_SPRITES_H + +#include "common/scummsys.h" +#include "common/array.h" +#include "mads/assets.h" +#include "mads/msurface.h" + +namespace MADS { + +enum SpriteFlags { + IMG_STATIC = 0, // Item should remain fixed on the screen + IMG_UPDATE = 1, // Item needs to be redrawn + IMG_ERASE = -1, // Erase image and remove it + IMG_REFRESH = -2, // Full refresh + IMG_OVERPRINT = -3, // Interface overprint + IMG_DELTA = -4, // Delta change + IMG_FULL_UPDATE = -5, // Interface refresh + IMG_UPDATE_ONLY = -20 // Update the active screen area only +}; + +class MADSEngine; + +struct BGR8 { + uint8 b, g, r; +}; + +typedef struct { + int32 x; // x position relative to GrBuff(0, 0) + int32 y; // y position relative to GrBuff(0, 0) + int32 scale_x; // x scale factor (can be negative for reverse draw) + int32 scale_y; // y scale factor (can't be negative) + uint8* depth_map; // depth code array for destination (doesn't care if srcDepth is 0) + BGR8* Pal; // palette for shadow draw (doesn't care if SHADOW bit is not set in Src.encoding) + uint8* ICT; // Inverse Color Table (doesn't care if SHADOW bit is not set in Src.encoding) + uint8 depth; // depth code for source (0 if no depth processing) +} DrawRequestX; + +typedef struct { + uint32 Pack; + uint32 Stream; + long hot_x; + long hot_y; + uint32 Width; + uint32 Height; + uint32 Comp; + uint32 Reserved[8]; + uint8* data; +} RendCell; + +#define SS_HEADER_NUM_FIELDS 14 +struct SpriteSeriesHeader { + uint32 header; + uint32 size; + uint32 packing; + uint32 frameRate; + uint32 pixSpeed; + uint32 maxWidth; + uint32 maxHeight; + uint32 reserved3; + uint32 reserved4; + uint32 reserved5; + uint32 reserved6; + uint32 reserved7; + uint32 reserved8; + uint32 count; +}; + +#define SF_HEADER_NUM_FIELDS 15 +struct SpriteFrameHeader { + uint32 pack; + uint32 stream; + uint32 x; + uint32 y; + uint32 width; + uint32 height; + uint32 comp; + uint32 reserved1; + uint32 reserved2; + uint32 reserved3; + uint32 reserved4; + uint32 reserved5; + uint32 reserved6; + uint32 reserved7; + uint32 reserved8; +}; + +class MSprite: public MSurface { +private: + void loadSprite(Common::SeekableReadStream *source, const Common::Array<RGB6> &palette); +public: + MSprite(); + MSprite(Common::SeekableReadStream *source, const Common::Array<RGB6> &palette, + const Common::Rect &bounds); + virtual ~MSprite(); + + Common::Point _offset; + + byte getTransparencyIndex() const; +}; + +class SpriteSlotSubset { +public: + int _spritesIndex; + int _frameNumber; + Common::Point _position; + int _depth; + int _scale; +}; + +class SpriteSlot : public SpriteSlotSubset { +private: + static MADSEngine *_vm; + friend class SpriteSlots; +public: + SpriteFlags _flags; + int _seqIndex; +public: + SpriteSlot(); + SpriteSlot(SpriteFlags type, int seqIndex); + + void setup(int dirtyAreaIndex); + bool operator==(const SpriteSlotSubset &other) const; + void copy(const SpriteSlotSubset &other); +}; + +class SpriteSlots : public Common::Array<SpriteSlot> { +private: + MADSEngine *_vm; +public: + SpriteSlots(MADSEngine *vm); + + /** + * Clears any pending slot data and schedules a full screen refresh. + * @param flag Also reset sprite list + */ + void reset(bool flag = true); + + /** + * Delete a sprite entry + * @param index Specifies the index in the array + */ + void deleteEntry(int index); + + /** + * Setup dirty areas for the sprite slots + */ + void setDirtyAreas(); + + /** + * Adds a full screen refresh to the sprite slots + */ + void fullRefresh(bool clearAll = false); + + /** + * Delete a timer entry with the given Id + */ + void deleteTimer(int seqIndex); + + /** + * Add a new slot entry and return it's index + */ + int add(); + + /** + * Draw any sprites into the background of the scene + */ + void drawBackground(); + + /** + * Draw any sprites into the foreground of the scene + */ + void drawSprites(MSurface *s); + + void cleanUp(); +}; + +class SpriteSets : public Common::Array<SpriteAsset *> { +private: + MADSEngine *_vm; +public: + int _assetCount; + + /** + * Constructor + */ + SpriteSets(MADSEngine *vm) : _vm(vm), _assetCount(0) {} + + /** + * Destructor + */ + ~SpriteSets(); + + /** + * Clears the current list, freeing any laoded assets + */ + void clear(); + + /** + * Add a sprite asset to the list + */ + int add(SpriteAsset *asset, int idx = 0); + + /** + * Adds a sprite asset to the list by name + */ + int addSprites(const Common::String &resName, int flags = 0); + + /** + * Remove an asset from the list + */ + void remove(int idx); +}; + +} // End of namespace MADS + +#endif /* MADS_SPRITES_H */ diff --git a/engines/mads/staticres.cpp b/engines/mads/staticres.cpp new file mode 100644 index 0000000000..189e5f72e7 --- /dev/null +++ b/engines/mads/staticres.cpp @@ -0,0 +1,58 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/staticres.h" + +namespace MADS { + +const char *const kArticleList[9] = { + nullptr, "with", "to", "at", "from", "on", "in", "under", "behind" +}; + +const char *const kCheatingEnabledDesc[3] = { + "CHEATING ENABLED", + "(For your convenience).", + nullptr +}; + +const char *const kLookAroundStr = "Look around"; +const char *const kToStr = "to "; +const char *const kUseStr = "Use "; +const char *const kWalkToStr = "Walk to "; +const char *const kFenceStr = "fence"; +const char *const kOverStr = "over"; + +const char *const kGameReleaseInfoStr = "ScummVM rev: 8.43 14-Sept-92"; +const char *const kGameReleaseTitleStr = "GAME RELASE VERSION INFO"; + +const uint32 DEFAULT_VGA_LOW_PALETTE[16] = { + 0x000000, 0x0000a8, 0x00a800, 0x00a8a8, 0xa80000, 0xa800a8, 0xa85400, 0xa8a8a8, + 0x545454, 0x5454fc, 0x54fc54, 0x54fcfc, 0xfc5454, 0xfc54fc, 0xfcfc54, 0xfcfcfc +}; + +const uint32 DEFAULT_VGA_HIGH_PALETTE[16] = { + 0x2c402c, 0x2c4030, 0x2c4034, 0x2c403c, 0x2c4040, 0x2c3c40, 0x2c3440, 0x2c3040, + 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000 +}; + +} // End of namespace MADS diff --git a/engines/mads/staticres.h b/engines/mads/staticres.h new file mode 100644 index 0000000000..560fd12e67 --- /dev/null +++ b/engines/mads/staticres.h @@ -0,0 +1,47 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_STATICRES_H +#define MADS_STATICRES_H + +namespace MADS { + +extern const char *const kArticleList[9]; + +extern const char *const kCheatingEnabledDesc[3]; + +extern const char *const kLookAroundStr; +extern const char *const kToStr; +extern const char *const kUseStr; +extern const char *const kWalkToStr; +extern const char *const kFenceStr; +extern const char *const kOverStr; + +extern const char *const kGameReleaseInfoStr; +extern const char *const kGameReleaseTitleStr; + +extern const uint32 DEFAULT_VGA_LOW_PALETTE[16]; +extern const uint32 DEFAULT_VGA_HIGH_PALETTE[16]; + +} // End of namespace MADS + +#endif /* MADS_STATICRES_H */ diff --git a/engines/mads/user_interface.cpp b/engines/mads/user_interface.cpp new file mode 100644 index 0000000000..e21a0f6243 --- /dev/null +++ b/engines/mads/user_interface.cpp @@ -0,0 +1,1092 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/scummsys.h" +#include "mads/mads.h" +#include "mads/compression.h" +#include "mads/user_interface.h" +#include "mads/nebular/game_nebular.h" + +namespace MADS { + +UISlot::UISlot() { + _flags = IMG_STATIC; + _segmentId = 0; + _spritesIndex = 0; + _frameNumber = 0; + _width = _height = 0; +} + +/*------------------------------------------------------------------------*/ + +void UISlots::fullRefresh() { + UISlot slot; + slot._flags = IMG_REFRESH; + slot._segmentId = -1; + + push_back(slot); +} + +void UISlots::add(const Common::Rect &bounds) { + assert(size() < 50); + + UISlot ie; + ie._flags = IMG_OVERPRINT; + ie._segmentId = IMG_TEXT_UPDATE; + ie._position = Common::Point(bounds.left, bounds.top); + ie._width = bounds.width(); + ie._height = bounds.height(); + + push_back(ie); +} + +void UISlots::add(const AnimFrameEntry &frameEntry) { + assert(size() < 50); + + UISlot ie; + ie._flags = IMG_UPDATE; + ie._segmentId = frameEntry._seqIndex; + ie._spritesIndex = frameEntry._spriteSlot._spritesIndex; + ie._frameNumber = frameEntry._spriteSlot._frameNumber; + ie._position = frameEntry._spriteSlot._position; + + push_back(ie); +} + +void UISlots::draw(bool updateFlag, bool delFlag) { + Scene &scene = _vm->_game->_scene; + UserInterface &userInterface = scene._userInterface; + DirtyArea *dirtyAreaPtr = nullptr; + + // Loop through setting up the dirty areas + for (uint idx = 0; idx < size(); ++idx) { + DirtyArea &dirtyArea = userInterface._dirtyAreas[idx]; + UISlot &slot = (*this)[idx]; + + if (slot._flags >= IMG_STATIC) { + dirtyArea._active = false; + } else { + dirtyArea.setUISlot(&slot); + dirtyArea._textActive = true; + if (slot._segmentId == IMG_SPINNING_OBJECT && slot._flags == IMG_FULL_UPDATE) { + dirtyArea._active = false; + dirtyAreaPtr = &dirtyArea; + } + } + } + + userInterface._dirtyAreas.merge(1, userInterface._uiSlots.size()); + if (dirtyAreaPtr) + dirtyAreaPtr->_active = true; + + // Copy parts of the user interface background that need to be erased + for (uint idx = 0; idx < size(); ++idx) { + DirtyArea &dirtyArea = userInterface._dirtyAreas[idx]; + UISlot &slot = (*this)[idx]; + + if (dirtyArea._active && dirtyArea._bounds.width() > 0 + && dirtyArea._bounds.height() > 0 && slot._flags > -20) { + + if (slot._flags >= IMG_ERASE) { + // Merge area + userInterface.mergeFrom(&userInterface._surface, dirtyArea._bounds, + Common::Point(dirtyArea._bounds.left, dirtyArea._bounds.top)); + } else { + // Copy area + userInterface._surface.copyTo(&userInterface, dirtyArea._bounds, + Common::Point(dirtyArea._bounds.left, dirtyArea._bounds.top)); + } + } + } + + for (uint idx = 0; idx < size(); ++idx) { + DirtyArea &dirtyArea = userInterface._dirtyAreas[idx]; + UISlot &slot = (*this)[idx]; + + int slotType = slot._flags; + if (slotType >= IMG_STATIC) { + dirtyArea.setUISlot(&slot); + if (!updateFlag) + slotType &= ~0x40; + + dirtyArea._textActive = slotType > 0; + slot._flags &= 0x40; + } + } + + userInterface._dirtyAreas.merge(1, userInterface._uiSlots.size()); + + for (uint idx = 0; idx < size(); ++idx) { + DirtyArea *dirtyArea = &userInterface._dirtyAreas[idx]; + UISlot &slot = (*this)[idx]; + + if (slot._flags >= IMG_STATIC && !(slot._flags & 0x40)) { + if (!dirtyArea->_active) { + do { + dirtyArea = dirtyArea->_mergedArea; + } while (!dirtyArea->_active); + } + + if (dirtyArea->_textActive) { + SpriteAsset *asset = scene._sprites[slot._spritesIndex]; + + // Get the frame details + int frameNumber = ABS(slot._frameNumber); + bool flipped = slot._frameNumber < 0; + + if (slot._segmentId == IMG_SPINNING_OBJECT) { + MSprite *sprite = asset->getFrame(frameNumber); + sprite->copyTo(&userInterface, slot._position, + sprite->getTransparencyIndex()); + } else { + MSprite *sprite = asset->getFrame(frameNumber - 1); + + if (flipped) { + MSurface *spr = sprite->flipHorizontal(); + userInterface.mergeFrom(spr, spr->getBounds(), slot._position, + sprite->getTransparencyIndex()); + delete spr; + } else { + userInterface.mergeFrom(sprite, sprite->getBounds(), slot._position, + sprite->getTransparencyIndex()); + } + } + } + } + } + + // Mark areas of the screen surface for updating + if (updateFlag) { + for (uint idx = 0; idx < size(); ++idx) { + DirtyArea &dirtyArea = userInterface._dirtyAreas[idx]; + + if (dirtyArea._active && dirtyArea._textActive && + dirtyArea._bounds.width() > 0 && dirtyArea._bounds.height() > 0) { + // Flag area of screen as needing update + Common::Rect r = dirtyArea._bounds; + r.translate(0, scene._interfaceY); + _vm->_screen.copyRectToScreen(r); + } + } + } + + // Post-processing to remove slots no longer needed + for (int idx = (int)size() - 1; idx >= 0; --idx) { + UISlot &slot = (*this)[idx]; + + if (slot._flags < IMG_STATIC) { + if (delFlag || updateFlag) + remove_at(idx); + else if (slot._flags > -20) + slot._flags -= 20; + } else { + if (updateFlag) + slot._flags &= ~0x40; + else + slot._flags |= 0x40; + } + } +} + +/*------------------------------------------------------------------------*/ + +MADSEngine *Conversation::_vm; + +void Conversation::init(MADSEngine *vm) { + _vm = vm; +} + +void Conversation::setup(int globalId, ...) { + va_list va; + va_start(va, globalId); + + // Load the list of conversation quotes + _quotes.clear(); + int quoteId = va_arg(va, int); + while (quoteId > 0) { + _quotes.push_back(quoteId); + quoteId = va_arg(va, int); + } + va_end(va); + + if (quoteId < 0) { + // For an ending value of -1, also initial the bitflags for the global + // associated with the conversation entry, which enables all the quote Ids + _vm->_game->globals()[globalId] = (int16)0xffff; + } + + _globalId = globalId; +} + +void Conversation::set(int quoteId, ...) { + _vm->_game->globals()[_globalId] = 0; + + va_list va; + va_start(va, quoteId); + + // Loop through handling each quote + while (quoteId > 0) { + for (uint idx = 0; idx < _quotes.size(); ++idx) { + if (_quotes[idx] == quoteId) { + // Found index, so set that bit in the global keeping track of conversation state + _vm->_game->globals()[_globalId] |= 1 << idx; + break; + } + } + + quoteId = va_arg(va, int); + } + va_end(va); +} + +int Conversation::read(int quoteId) { + uint16 flags = _vm->_game->globals()[_globalId]; + int count = 0; + + for (uint idx = 0; idx < _quotes.size(); ++idx) { + if (flags & (1 << idx)) + ++count; + + if (_quotes[idx] == quoteId) + return flags & (1 << idx); + } + + // Could not find it, simply return number of active quotes + return count; +} + +void Conversation::write(int quoteId, bool flag) { + for (uint idx = 0; idx < _quotes.size(); ++idx) { + if (_quotes[idx] == quoteId) { + // Found index, so set or clear the flag + if (flag) { + // Set bit + _vm->_game->globals()[_globalId] |= 1 << idx; + } else { + // Clear bit + _vm->_game->globals()[_globalId] &= ~(1 << idx); + } + return; + } + } +} + +void Conversation::start() { + UserInterface &userInterface = _vm->_game->_scene._userInterface; + userInterface.emptyConversationList(); + + // Loop through each of the quotes loaded into the conversation + for (uint idx = 0; idx < _quotes.size(); ++idx) { + // Check whether the given quote is enabled or not + if (_vm->_game->globals()[_globalId] & (1 << idx)) { + // Quote enabled, so add it to the list of talk selections + Common::String msg = _vm->_game->getQuote(_quotes[idx]); + userInterface.addConversationMessage(_quotes[idx], msg); + } + } + + userInterface.setup(kInputConversation); +} + +/*------------------------------------------------------------------------*/ + +UserInterface::UserInterface(MADSEngine *vm) : _vm(vm), _dirtyAreas(vm), + _uiSlots(vm) { + _invSpritesIndex = -1; + _invFrameNumber = 1; + _scrollMilli = 0; + _scrollFlag = false; + _category = CAT_NONE; + _inventoryTopIndex = 0; + _selectedInvIndex = -1; + _selectedActionIndex = 0; + _selectedItemVocabIdx = -1; + _scrollbarActive = SCROLLBAR_NONE; + _scrollbarOldActive = SCROLLBAR_NONE; + _scrollbarStrokeType = SCROLLBAR_NONE; + _scrollbarQuickly = false; + _scrollbarMilliTime = 0; + _scrollbarElevator = _scrollbarOldElevator = 0; + _highlightedCommandIndex = -1; + _highlightedInvIndex = -1; + _highlightedItemVocabIndex = -1; + _dirtyAreas.resize(50); + _inventoryChanged = false; + Common::fill(&_categoryIndexes[0], &_categoryIndexes[7], 0); + + // Map the user interface to the bottom of the game's screen surface + byte *pData = _vm->_screen.getBasePtr(0, MADS_SCENE_HEIGHT); + setPixels(pData, MADS_SCREEN_WIDTH, MADS_INTERFACE_HEIGHT); + + _surface.setSize(MADS_SCREEN_WIDTH, MADS_INTERFACE_HEIGHT); +} + +void UserInterface::load(const Common::String &resName) { + File f(resName); + MadsPack madsPack(&f); + + // Load in the palette + Common::SeekableReadStream *palStream = madsPack.getItemStream(0); + + uint32 *gamePalP = &_vm->_palette->_palFlags[0]; + byte *palP = &_vm->_palette->_mainPalette[0]; + + for (int i = 0; i < 16; ++i, gamePalP++, palP += 3) { + RGB6 rgb; + rgb.load(palStream); + palP[0] = rgb.r; + palP[1] = rgb.g; + palP[2] = rgb.b; + *gamePalP |= 1; + } + delete palStream; + + // Read in the surface data + Common::SeekableReadStream *pixelsStream = madsPack.getItemStream(1); + pixelsStream->read(_surface.getData(), MADS_SCREEN_WIDTH * MADS_INTERFACE_HEIGHT); + delete pixelsStream; +} + +void UserInterface::setup(InputMode inputMode) { + Scene &scene = _vm->_game->_scene; + + if (_vm->_game->_screenObjects._inputMode != inputMode) { + Common::String resName = _vm->_game->_aaName; + + // Strip off any extension + const char *p = strchr(resName.c_str(), '.'); + if (p) { + resName = Common::String(resName.c_str(), p); + } + + // Add on suffix if necessary + if (inputMode != kInputBuildingSentences) + resName += "A"; + + resName += ".INT"; + + load(resName); + _surface.copyTo(this); + } + _vm->_game->_screenObjects._inputMode = inputMode; + + scene._userInterface._uiSlots.clear(); + scene._userInterface._uiSlots.fullRefresh(); + _vm->_game->_screenObjects._baseTime = _vm->_events->getFrameCounter(); + _highlightedCommandIndex = -1; + _highlightedItemVocabIndex = -1; + _highlightedInvIndex = -1; + + if (_vm->_game->_kernelMode == KERNEL_ACTIVE_CODE) + scene._userInterface._uiSlots.draw(false, false); + + scene._action.clear(); + drawTextElements(); + loadElements(); + scene._dynamicHotspots.refresh(); +} + +void UserInterface::drawTextElements() { + if (_vm->_game->_screenObjects._inputMode) { + drawConversationList(); + } else { + // Draw the actions + drawActions(); + drawInventoryList(); + drawItemVocabList(); + } +} + +void UserInterface::mergeFrom(MSurface *src, const Common::Rect &srcBounds, + const Common::Point &destPos, int transparencyIndex) { + // Validation of the rectangle and position + int destX = destPos.x, destY = destPos.y; + if ((destX >= w) || (destY >= h)) + return; + + Common::Rect copyRect = srcBounds; + if (destX < 0) { + copyRect.left += -destX; + destX = 0; + } else if (destX + copyRect.width() > w) { + copyRect.right -= destX + copyRect.width() - w; + } + if (destY < 0) { + copyRect.top += -destY; + destY = 0; + } else if (destY + copyRect.height() > h) { + copyRect.bottom -= destY + copyRect.height() - h; + } + + if (!copyRect.isValidRect()) + return; + + // Copy the specified area + + byte *data = src->getData(); + byte *srcPtr = data + (src->getWidth() * copyRect.top + copyRect.left); + byte *destPtr = (byte *)this->pixels + (destY * getWidth()) + destX; + + for (int rowCtr = 0; rowCtr < copyRect.height(); ++rowCtr) { + // Process each line of the area + for (int xCtr = 0; xCtr < copyRect.width(); ++xCtr) { + // Check for the range used for the user interface background, + // which are the only pixels that can be replaced + if ((destPtr[xCtr] >= 8 && destPtr[xCtr] <= 15) && (int)srcPtr[xCtr] != transparencyIndex) + destPtr[xCtr] = srcPtr[xCtr]; + } + + srcPtr += src->getWidth(); + destPtr += getWidth(); + } +} + +void UserInterface::drawActions() { + for (int idx = 0; idx < 10; ++idx) { + writeVocab(CAT_COMMAND, idx); + } +} + +void UserInterface::drawInventoryList() { + int endIndex = MIN((int)_vm->_game->_objects._inventoryList.size(), _inventoryTopIndex + 5); + for (int idx = _inventoryTopIndex; idx < endIndex; ++idx) { + writeVocab(CAT_INV_LIST, idx); + } +} + +void UserInterface::drawItemVocabList() { + if (_selectedInvIndex >= 0) { + InventoryObject &io = _vm->_game->_objects[ + _vm->_game->_objects._inventoryList[_selectedInvIndex]]; + for (int idx = 0; idx < io._vocabCount; ++idx) { + writeVocab(CAT_INV_VOCAB, idx); + } + } +} + +void UserInterface::drawScrolller() { + if (_scrollbarActive) + writeVocab(CAT_INV_SCROLLER, _scrollbarActive); + writeVocab(CAT_INV_SCROLLER, 4); +} + +void UserInterface::updateInventoryScroller() { + ScreenObjects &screenObjects = _vm->_game->_screenObjects; + Common::Array<int> &inventoryList = _vm->_game->_objects._inventoryList; + + if (screenObjects._inputMode != kInputBuildingSentences) + return; + + _scrollbarActive = SCROLLBAR_NONE; + + if ((screenObjects._category == CAT_INV_SCROLLER) || (screenObjects._category != CAT_INV_SCROLLER + && _scrollbarOldActive == SCROLLBAR_ELEVATOR && _vm->_events->_mouseStatusCopy)) { + if (_vm->_events->_mouseStatusCopy || _vm->_easyMouse) { + if ((_vm->_events->_mouseClicked || (_vm->_easyMouse && !_vm->_events->_mouseStatusCopy)) + && (screenObjects._category == CAT_INV_SCROLLER)) + _scrollbarStrokeType = (ScrollbarActive)screenObjects._spotId; + + if (screenObjects._spotId == _scrollbarStrokeType || _scrollbarOldActive == SCROLLBAR_ELEVATOR) { + _scrollbarActive = _scrollbarStrokeType; + uint32 currentMilli = g_system->getMillis(); + uint32 timeInc = _scrollbarQuickly ? 100 : 380; + + if (_vm->_events->_mouseStatus && (_scrollbarMilliTime + timeInc) <= currentMilli) { + _scrollbarQuickly = _vm->_events->_vD2 < 1; + _scrollbarMilliTime = currentMilli; + + switch (_scrollbarStrokeType) { + case SCROLLBAR_UP: + // Scroll up + if (_inventoryTopIndex > 0 && inventoryList.size() > 0) { + --_inventoryTopIndex; + _inventoryChanged = true; + } + break; + + case SCROLLBAR_DOWN: + // Scroll down + if (_inventoryTopIndex < ((int)inventoryList.size() - 1) && inventoryList.size() > 1) { + ++_inventoryTopIndex; + _inventoryChanged = true; + } + break; + + case SCROLLBAR_ELEVATOR: { + // Inventory slider + int newIndex = CLIP((int)_vm->_events->currentPos().y - 170, 0, 17) + * inventoryList.size() / 10; + if (newIndex >= (int)inventoryList.size()) + newIndex = inventoryList.size() - 1; + + if (inventoryList.size() > 0) { + _inventoryChanged = newIndex != _inventoryTopIndex; + _inventoryTopIndex = newIndex; + } + break; + } + + default: + break; + } + + if (_inventoryChanged) { + int dummy; + updateSelection(CAT_INV_LIST, 0, &dummy); + } + } + } + } + } + + if (_scrollbarActive != _scrollbarOldActive || _scrollbarElevator != _scrollbarOldElevator) + scrollbarChanged(); + + _scrollbarOldActive = _scrollbarActive; + _scrollbarOldElevator = _scrollbarElevator; +} + +void UserInterface::scrollbarChanged() { + Common::Rect r(73, 4, 73 + 9, 4 + 38); + _uiSlots.add(r); + _uiSlots.draw(false, false); + drawScrolller(); + updateRect(r); +} + +void UserInterface::writeVocab(ScrCategory category, int id) { + Common::Rect bounds; + if (!getBounds(category, id, bounds)) + return; + + Scene &scene = _vm->_game->_scene; + Font *font = nullptr; + + int vocabId; + Common::String vocabStr; + switch (category) { + case CAT_COMMAND: + font = _vm->_font->getFont(FONT_INTERFACE); + vocabId = scene._verbList[id]._id; + if (id == _highlightedCommandIndex) { + _vm->_font->setColorMode(SELMODE_HIGHLIGHTED); + } else { + _vm->_font->setColorMode(id == _selectedActionIndex ? SELMODE_SELECTED : SELMODE_UNSELECTED); + } + vocabStr = scene.getVocab(vocabId); + vocabStr.setChar(toupper(vocabStr[0]), 0); + font->writeString(this, vocabStr, Common::Point(bounds.left, bounds.top)); + break; + + case CAT_INV_LIST: + font = _vm->_font->getFont(FONT_INTERFACE); + vocabId = _vm->_game->_objects.getItem(id)._descId; + if (id == _highlightedInvIndex) { + _vm->_font->setColorMode(SELMODE_HIGHLIGHTED); + } else { + _vm->_font->setColorMode(id == _selectedInvIndex ? SELMODE_SELECTED : SELMODE_UNSELECTED); + } + + vocabStr = scene.getVocab(vocabId); + vocabStr.setChar(toupper(vocabStr[0]), 0); + font->writeString(this, vocabStr, Common::Point(bounds.left, bounds.top)); + break; + + case CAT_TALK_ENTRY: + font = _vm->_font->getFont(FONT_INTERFACE); + font->setColorMode(id == _highlightedCommandIndex ? SELMODE_HIGHLIGHTED : SELMODE_UNSELECTED); + font->writeString(this, _talkStrings[id], Common::Point(bounds.left, bounds.top)); + break; + + case CAT_INV_SCROLLER: + font = _vm->_font->getFont(FONT_MISC); + + switch (id) { + case 1: + vocabStr = "a"; + break; + case 2: + vocabStr = "b"; + break; + case 3: + vocabStr = "d"; + break; + case 4: + vocabStr = "c"; + break; + default: + break; + } + + font->setColorMode((id == 4) || (_scrollbarActive == SCROLLBAR_ELEVATOR) ? + SELMODE_HIGHLIGHTED : SELMODE_UNSELECTED); + font->writeString(this, vocabStr, Common::Point(bounds.left, bounds.top)); + break; + default: + // Item specific verbs + font = _vm->_font->getFont(FONT_INTERFACE); + vocabId = _vm->_game->_objects.getItem(_selectedInvIndex)._vocabList[id]._vocabId; + if (id == _highlightedItemVocabIndex) { + _vm->_font->setColorMode(SELMODE_HIGHLIGHTED); + } else { + _vm->_font->setColorMode(id == _selectedInvIndex ? SELMODE_SELECTED : SELMODE_UNSELECTED); + vocabStr = scene.getVocab(vocabId); + vocabStr.setChar(toupper(vocabStr[0]), 0); + font->writeString(this, vocabStr, Common::Point(bounds.left, bounds.top)); + break; + } + break; + } +} + +void UserInterface::loadElements() { + Scene &scene = _vm->_game->_scene; + Common::Rect bounds; + _vm->_game->_screenObjects.clear(); + + if (_vm->_game->_screenObjects._inputMode == kInputBuildingSentences) { + // Set up screen objects for the inventory scroller + for (int idx = 1; idx <= 3; ++idx) { + getBounds(CAT_INV_SCROLLER, idx, bounds); + moveRect(bounds); + + _vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_INV_SCROLLER, idx); + } + + // Set up actions + _categoryIndexes[CAT_COMMAND - 1] = _vm->_game->_screenObjects.size() + 1; + for (int idx = 0; idx < 10; ++idx) { + getBounds(CAT_COMMAND, idx, bounds); + moveRect(bounds); + + _vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_COMMAND, idx); + } + + // Set up inventory list + _categoryIndexes[CAT_INV_LIST - 1] = _vm->_game->_screenObjects.size() + 1; + for (int idx = 0; idx < 5; ++idx) { + getBounds(CAT_INV_LIST, idx, bounds); + moveRect(bounds); + + _vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_INV_LIST, idx); + } + + // Set up the inventory vocab list + _categoryIndexes[CAT_INV_VOCAB - 1] = _vm->_game->_screenObjects.size() + 1; + for (int idx = 0; idx < 5; ++idx) { + getBounds(CAT_INV_VOCAB, idx, bounds); + moveRect(bounds); + + _vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_INV_VOCAB, idx); + } + + // Set up the inventory item picture + _categoryIndexes[CAT_INV_ANIM - 1] = _vm->_game->_screenObjects.size() + 1; + _vm->_game->_screenObjects.add(Common::Rect(160, 159, 231, 194), LAYER_GUI, + CAT_INV_ANIM, 0); + } + + if (_vm->_game->_screenObjects._inputMode == kInputBuildingSentences || + _vm->_game->_screenObjects._inputMode == kInputLimitedSentences) { + _categoryIndexes[CAT_HOTSPOT - 1] = _vm->_game->_screenObjects.size() + 1; + for (int hotspotIdx = scene._hotspots.size() - 1; hotspotIdx >= 0; --hotspotIdx) { + Hotspot &hs = scene._hotspots[hotspotIdx]; + _vm->_game->_screenObjects.add(hs._bounds, LAYER_GUI, CAT_HOTSPOT, hotspotIdx); + } + } + + if (_vm->_game->_screenObjects._inputMode == kInputConversation) { + // setup areas for talk entries + _categoryIndexes[CAT_TALK_ENTRY - 1] = _vm->_game->_screenObjects.size() + 1; + for (int idx = 0; idx < 5; ++idx) { + getBounds(CAT_TALK_ENTRY, idx, bounds); + moveRect(bounds); + + _vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_TALK_ENTRY, idx); + } + } + + // Store the number of UI elements loaded for easy nuking/refreshing hotspots added later + _vm->_game->_screenObjects._uiCount = _vm->_game->_screenObjects.size(); +} + +bool UserInterface::getBounds(ScrCategory category, int v, Common::Rect &bounds) { + int heightMultiplier, widthMultiplier; + int leftStart, yOffset, widthAmt; + + switch (category) { + case CAT_COMMAND: + heightMultiplier = v % 5; + widthMultiplier = v / 5; + leftStart = 2; + yOffset = 3; + widthAmt = 32; + break; + + case CAT_INV_LIST: + if (v < _inventoryTopIndex || v >= (_inventoryTopIndex + 5)) + return false; + + heightMultiplier = v - _inventoryTopIndex; + widthMultiplier = 0; + leftStart = 90; + yOffset = 3; + widthAmt = 69; + break; + + case CAT_TALK_ENTRY: + heightMultiplier = v; + widthMultiplier = 0; + leftStart = 2; + yOffset = 3; + widthAmt = 310; + break; + + case CAT_INV_SCROLLER: + heightMultiplier = 0; + widthMultiplier = 0; + yOffset = 0; + widthAmt = 9; + leftStart = (v != 73) ? 73 : 75; + break; + + default: + heightMultiplier = v; + widthMultiplier = 0; + leftStart = 240; + yOffset = 3; + widthAmt = 80; + break; + } + + bounds.left = (widthMultiplier > 0) ? widthMultiplier * widthAmt + leftStart : leftStart; + bounds.setWidth(widthAmt); + bounds.top = heightMultiplier * 8 + yOffset; + bounds.setHeight(8); + + if (category == CAT_INV_SCROLLER) { + switch (v) { + case SCROLLBAR_UP: + // Arrow up + bounds.top = 4; + bounds.setHeight(7); + break; + case SCROLLBAR_DOWN: + // Arrow down + bounds.top = 35; + bounds.setHeight(7); + break; + case SCROLLBAR_ELEVATOR: + // Scroller + bounds.top = 12; + bounds.setHeight(22); + break; + case SCROLLBAR_THUMB: + // Thumb + bounds.top = _scrollbarElevator + 14; + bounds.setHeight(1); + break; + default: + break; + } + } + + return true; +} + +void UserInterface::moveRect(Common::Rect &bounds) { + bounds.translate(0, MADS_SCENE_HEIGHT); +} + +void UserInterface::drawConversationList() { + for (uint idx = 0; idx < _talkStrings.size(); ++idx) { + writeVocab(CAT_TALK_ENTRY, idx); + } +} + +void UserInterface::emptyConversationList() { + _talkStrings.clear(); + _talkIds.clear(); +} + +void UserInterface::addConversationMessage(int vocabId, const Common::String &msg) { + assert(_talkStrings.size() < 5); + + _talkStrings.push_back(msg); + _talkIds.push_back(vocabId); +} + +void UserInterface::loadInventoryAnim(int objectId) { + Scene &scene = _vm->_game->_scene; + noInventoryAnim(); + + if (_vm->_invObjectsAnimated) { + Common::String resName = Common::String::format("*OB%.3dI", objectId); + SpriteAsset *asset = new SpriteAsset(_vm, resName, 8); + _invSpritesIndex = scene._sprites.add(asset, 1); + if (_invSpritesIndex >= 0) { + _invFrameNumber = 1; + } + } +} + +void UserInterface::noInventoryAnim() { + Scene &scene = _vm->_game->_scene; + + if (_invSpritesIndex >= 0) { + scene._sprites.remove(_invSpritesIndex); + _vm->_game->_screenObjects._baseTime = _vm->_events->getFrameCounter(); + _invSpritesIndex = -1; + } + + if (_vm->_game->_screenObjects._inputMode == kInputBuildingSentences) + refresh(); +} + +void UserInterface::refresh() { + _uiSlots.clear(); + _uiSlots.fullRefresh(); + _uiSlots.draw(false, false); + + drawTextElements(); +} + +void UserInterface::inventoryAnim() { + Scene &scene = _vm->_game->_scene; + if (_vm->_game->_screenObjects._inputMode == kInputConversation || + _vm->_game->_screenObjects._inputMode == kInputLimitedSentences || + _invSpritesIndex < 0) + return; + + // Move to the next frame number in the sequence, resetting if at the end + SpriteAsset *asset = scene._sprites[_invSpritesIndex]; + if (++_invFrameNumber > asset->getCount()) + _invFrameNumber = 1; + + // Loop through the slots list for inventory animation entry + for (uint i = 0; i < _uiSlots.size(); ++i) { + if (_uiSlots[i]._segmentId == IMG_SPINNING_OBJECT) + _uiSlots[i]._flags = IMG_FULL_UPDATE; + } + + // Add a new slot entry for the inventory animation + UISlot slot; + slot._flags = IMG_UPDATE; + slot._segmentId = IMG_SPINNING_OBJECT; + slot._frameNumber = _invFrameNumber; + slot._spritesIndex = _invSpritesIndex; + slot._position = Common::Point(160, 3); + + _uiSlots.push_back(slot); +} + +void UserInterface::doBackgroundAnimation() { + Scene &scene = _vm->_game->_scene; + Common::Array<AnimUIEntry> &uiEntries = scene._animationData->_uiEntries; + Common::Array<AnimFrameEntry> &frameEntries = scene._animationData->_frameEntries; + + _noSegmentsActive = !_someSegmentsActive; + _someSegmentsActive = false; + + for (int idx = 0; idx < (int)uiEntries.size(); ++idx) { + AnimUIEntry &uiEntry = uiEntries[idx]; + + if (uiEntry._counter < 0) { + if (uiEntry._counter == -1) { + int probabilityRandom = _vm->getRandomNumber(1, 30000); + int probability = uiEntry._probability; + if (uiEntry._probability > 30000) { + if (_noSegmentsActive) { + probability -= 30000; + } else { + probability = -1; + } + } + if (probabilityRandom <= probability) { + uiEntry._counter = uiEntry._firstImage; + _someSegmentsActive = true; + } + } else { + uiEntry._counter = uiEntry._firstImage; + _someSegmentsActive = true; + } + } else { + for (int idx2 = 0; idx2 < ANIM_SPAWN_COUNT; idx2++) { + if (uiEntry._spawnFrame[idx2] == (uiEntry._counter - uiEntry._firstImage)) { + int tempIndex = uiEntry._spawn[idx2]; + if (idx >= tempIndex) { + uiEntries[tempIndex]._counter = uiEntries[tempIndex]._firstImage; + } else { + uiEntries[tempIndex]._counter = -2; + } + _someSegmentsActive = true; + } + } + + ++uiEntry._counter; + if (uiEntry._counter > uiEntry._lastImage) { + uiEntry._counter = -1; + } else { + _someSegmentsActive = true; + } + } + } + + for (uint idx = 0; idx < uiEntries.size(); ++idx) { + int imgScan = uiEntries[idx]._counter; + if (imgScan >= 0) { + _uiSlots.add(frameEntries[imgScan]); + } + } +} + +void UserInterface::categoryChanged() { + _highlightedInvIndex = -1; + _vm->_events->initVars(); + _category = CAT_NONE; +} + +void UserInterface::selectObject(int invIndex) { + if (_selectedInvIndex != invIndex || _inventoryChanged) { + int oldVocabCount = _selectedInvIndex < 0 ? 0 : _vm->_game->_objects.getItem(_selectedInvIndex)._vocabCount; + int newVocabCount = invIndex < 0 ? 0 : _vm->_game->_objects.getItem(invIndex)._vocabCount; + int maxVocab = MAX(oldVocabCount, newVocabCount); + + updateSelection(CAT_INV_LIST, invIndex, &_selectedInvIndex); + _highlightedItemVocabIndex = -1; + _selectedItemVocabIdx = -1; + + if (maxVocab) { + assert(_uiSlots.size() < 50); + int vocabHeight = maxVocab * 8; + + Common::Rect bounds(240, 3, 240 + 80, 3 + vocabHeight); + _uiSlots.add(bounds); + _uiSlots.draw(false, false); + drawItemVocabList(); + updateRect(bounds); + } + } + + if (invIndex == -1) { + noInventoryAnim(); + } else { + loadInventoryAnim(_vm->_game->_objects._inventoryList[invIndex]); + _vm->_palette->setPalette(_vm->_palette->_mainPalette, 7, 1); + _vm->_palette->setPalette(_vm->_palette->_mainPalette, 246, 2); + } +} + +void UserInterface::updateSelection(ScrCategory category, int newIndex, int *idx) { + Game &game = *_vm->_game; + Common::Array<int> &invList = game._objects._inventoryList; + Common::Rect bounds; + + if (category == CAT_INV_LIST && _inventoryChanged) { + *idx = newIndex; + bounds = Common::Rect(90, 3, 90 + 69, 3 + 40); + _uiSlots.add(bounds); + _uiSlots.draw(false, false); + drawInventoryList(); + updateRect(bounds); + _inventoryChanged = false; + + if (invList.size() < 2) { + _scrollbarElevator = 0; + } else { + int v = _inventoryTopIndex * 18 / (invList.size() - 1); + _scrollbarElevator = MIN(v, 17); + } + } else { + int oldIndex = *idx; + *idx = newIndex; + + if (oldIndex >= 0) { + writeVocab(category, oldIndex); + + if (getBounds(category, oldIndex, bounds)) + updateRect(bounds); + } + + if (newIndex >= 0) { + writeVocab(category, newIndex); + + if (getBounds(category, newIndex, bounds)) + updateRect(bounds); + } + } +} + +void UserInterface::updateRect(const Common::Rect &bounds) { + Common::Rect r = bounds; + r.translate(0, MADS_SCENE_HEIGHT); + _vm->_screen.copyRectToScreen(r); +} + +void UserInterface::scrollerChanged() { + warning("TODO: scrollerChanged"); +} + +void UserInterface::scrollInventory() { + Common::Array<int> &invList = _vm->_game->_objects._inventoryList; + + if (_vm->_events->_mouseButtons) { + int yp = _vm->_events->currentPos().y; + if (yp < MADS_SCENE_HEIGHT || yp == (MADS_SCREEN_HEIGHT - 1)) { + uint32 timeDiff = _scrollFlag ? 100 : 380; + uint32 currentMilli = g_system->getMillis(); + _vm->_game->_screenObjects._v8332A = -1; + + if (currentMilli >= (_scrollMilli + timeDiff)) { + _scrollMilli = currentMilli; + _scrollFlag = true; + + if (yp == (MADS_SCREEN_HEIGHT - 1)) { + if (_inventoryTopIndex < ((int)invList.size() - 1)) { + ++_inventoryTopIndex; + _inventoryChanged = true; + } + } else { + if (_inventoryTopIndex > 0) { + --_inventoryTopIndex; + _inventoryChanged = true; + } + } + } + } + } + + _vm->_game->_screenObjects._v8332A = 0; +} + +void UserInterface::synchronize(Common::Serializer &s) { + InventoryObjects &invObjects = _vm->_game->_objects; + + if (s.isLoading()) { + _selectedInvIndex = invObjects._inventoryList.empty() ? -1 : 0; + } + + for (int i = 0; i < 8; ++i) + s.syncAsSint16LE(_categoryIndexes[i]); +} + +} // End of namespace MADS diff --git a/engines/mads/user_interface.h b/engines/mads/user_interface.h new file mode 100644 index 0000000000..827fa3041f --- /dev/null +++ b/engines/mads/user_interface.h @@ -0,0 +1,306 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef MADS_USER_INTERFACE_H +#define MADS_USER_INTERFACE_H + +#include "common/scummsys.h" +#include "common/rect.h" +#include "common/str.h" +#include "mads/msurface.h" +#include "mads/screen.h" + +namespace MADS { + +enum { IMG_SPINNING_OBJECT = 200, IMG_TEXT_UPDATE = 201 }; + +enum ScrollbarActive { + SCROLLBAR_NONE = 0, // No state + SCROLLBAR_UP = 1, // Up butotn + SCROLLBAR_DOWN = 2, // Down button + SCROLLBAR_ELEVATOR = 3, // Elevator bar + SCROLLBAR_THUMB = 4 // Scrollbar thumb +}; + +class AnimFrameEntry; +class MADSEngine; + +class UISlot { +public: + int _flags; + int _segmentId; + int _spritesIndex; + int _frameNumber; + Common::Point _position; + + // Only used for IMG_OVERPRINT + int _width; + int _height; + + UISlot(); +}; + +/** + * Sprite list for the user interface + */ +class UISlots : public Common::Array<UISlot> { +private: + MADSEngine *_vm; +public: + /** + * Constructor + */ + UISlots(MADSEngine *vm) : _vm(vm) {} + + /** + * Add an overprint (text) entry to the list + */ + void add(const Common::Rect &bounds); + + /** + * Loads the data from an aimation frame entry + */ + void add(const AnimFrameEntry &frameEntry); + + /** + * Adds a special entry for full refresh of the user interface + */ + void fullRefresh(); + + /** + * Draw all the sprites in the list on the user interface. + * @param updateFlag Flag drawn areas to be updated on physical screen + * @param delFlag Controls how used slots are deleted after drawing + */ + void draw(bool updateFlag, bool delFlag); +}; + +class Conversation { +private: + static MADSEngine *_vm; +public: + static void init(MADSEngine *vm); +public: + int _globalId; + Common::Array<int> _quotes; + + /** + * Set up a conversation sequence + */ + void setup(int globalId, ...); + + /** + * Activates the passed set of quotes in the given conversation node + */ + void set(int quoteId, ...); + + /** + * Returns the bit for a given quote to indicate whether it's active or not or, + * if 0 is passed, returns the number of currently active quotes + */ + int read(int quoteId); + + /** + * Activates or deactivates the specified quote in the given conversation node + */ + void write(int quoteId, bool flag); + + /** + * Starts the conversation + */ + void start(); +}; + +class UserInterface : public MSurface { + friend class UISlots; +private: + MADSEngine *_vm; + int _invSpritesIndex; + int _invFrameNumber; + uint32 _scrollMilli; + bool _scrollFlag; + int _noSegmentsActive; + int _someSegmentsActive; + ScrollbarActive _scrollbarStrokeType; + + /** + * Loads the elements of the user interface + */ + void loadElements(); + + /** + * Returns the area within the user interface a given element falls + */ + bool getBounds(ScrCategory category, int invIndex, Common::Rect &bounds); + + /** + * Reposition a bounding rectangle to physical co-ordinates + */ + void moveRect(Common::Rect &bounds); + + /** + * Draw options during a conversation. + */ + void drawConversationList(); + + /** + * Draw the action list + */ + void drawActions(); + + /** + * Draw the inventory list + */ + void drawInventoryList(); + + /** + * Draw the inventory item vocab list + */ + void drawItemVocabList(); + + /** + * Draw the inventory scroller + */ + void drawScrolller(); + + /** + * Called when the inventory scrollbar has changed + */ + void scrollbarChanged(); + + /** + * Draw a UI textual element + */ + void writeVocab(ScrCategory category, int id); + + void refresh(); + + void updateRect(const Common::Rect &bounds); +public: + MSurface _surface; + UISlots _uiSlots; + DirtyAreas _dirtyAreas; + ScrCategory _category; + Common::Rect *_rectP; + int _inventoryTopIndex; + int _selectedInvIndex; + int _selectedActionIndex; + int _selectedItemVocabIdx; + ScrollbarActive _scrollbarActive, _scrollbarOldActive; + int _highlightedCommandIndex; + int _highlightedInvIndex; + int _highlightedItemVocabIndex; + bool _inventoryChanged; + int _categoryIndexes[8]; + Common::StringArray _talkStrings; + Common::Array<int> _talkIds; + bool _scrollbarQuickly; + uint32 _scrollbarMilliTime; + int _scrollbarElevator, _scrollbarOldElevator; +public: + /** + * Constructor + */ + UserInterface(MADSEngine *vm); + + /** + * Loads an interface from a specified resource + */ + void load(const Common::String &resName); + + /** + * Set up the interface + */ + void setup(InputMode inputMode); + + void drawTextElements(); + + /** + * Merges a sub-section of another surface into the user interface without + * destroying any on-screen text + * @param src Source surface + * @param srcBounds Area to copy/merge from + * @param destPos Destination position to draw in current surface + * @param transparencyIndex Transparency color + */ + void mergeFrom(MSurface *src, const Common::Rect &srcBounds, const Common::Point &destPos, + int transparencyIndex = -1); + + /** + * Loads the animation sprite data for a given inventory object + */ + void loadInventoryAnim(int objectId); + + /** + * Resets the inventory animation when no inventory item is selected + */ + void noInventoryAnim(); + + /** + * Handles any animation that occurs in the background of the user interface + */ + void doBackgroundAnimation(); + + /** + * Handles queuing a new frame of an inventory animation for drawing + */ + void inventoryAnim(); + + void categoryChanged(); + + /** + * Select an item from the inventory list + * @param invIndex Index in the inventory list of the item to select + */ + void selectObject(int invIndex); + + void updateSelection(ScrCategory category, int newIndex, int *idx); + + void scrollerChanged(); + + void scrollInventory(); + + /** + * Checks for the mouse being on the user interface inventory scroller, + * and update the scroller highlight and selected inventory object as necessary + */ + void updateInventoryScroller(); + + /** + * Empties the current conversation talk list + */ + void emptyConversationList(); + + /** + * Add a msesage to the list of conversation items to select from + */ + void addConversationMessage(int vocabId, const Common::String &msg); + + /** + * Synchronize the data + */ + void synchronize(Common::Serializer &s); +}; + +} // End of namespace MADS + +#endif /* MADS_USER_INTERFACE_H */ |