diff options
Diffstat (limited to 'engines/access/room.cpp')
| -rw-r--r-- | engines/access/room.cpp | 833 |
1 files changed, 833 insertions, 0 deletions
diff --git a/engines/access/room.cpp b/engines/access/room.cpp new file mode 100644 index 0000000000..607259ec6f --- /dev/null +++ b/engines/access/room.cpp @@ -0,0 +1,833 @@ +/* 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/memstream.h" +#include "access/access.h" +#include "access/resources.h" +#include "access/room.h" + +namespace Access { + +Room::Room(AccessEngine *vm) : Manager(vm) { + _function = FN_NONE; + _roomFlag = 0; + _playField = nullptr; + _playFieldWidth = _playFieldHeight = 0; + _matrixSize = 0; + _tile = nullptr; + _selectCommand = 0; + _conFlag = false; + _selectCommand = -1; +} + +Room::~Room() { + delete[] _playField; + delete[] _tile; +} + +void Room::freePlayField() { + delete[] _playField; + _playField = nullptr; +} + +void Room::freeTileData() { + delete[] _tile; + _tile = nullptr; +} + +void Room::doRoom() { + bool reloadFlag = false; + + while (!_vm->shouldQuit()) { + if (!reloadFlag) { + _vm->_images.clear(); + _vm->_newRects.clear(); + _vm->_oldRects.clear(); + _vm->_numAnimTimers = 0; + + reloadRoom(); + } + + reloadFlag = false; + _vm->_startup = 8; + _function = FN_NONE; + + while (!_vm->shouldQuit()) { + _vm->_images.clear(); + if (_vm->_startup != -1 && --_vm->_startup == 0) { + _vm->_events->showCursor(); + _vm->_screen->fadeIn(); + } + + // Poll for events + _vm->_canSaveLoad = true; + _vm->_events->pollEventsAndWait(); + _vm->_canSaveLoad = false; + + _vm->_player->walk(); + _vm->_midi->midiRepeat(); + _vm->_player->checkScroll(); + + doCommands(); + if (_vm->shouldQuitOrRestart()) + return; + + // DOROOMFLASHBACK jump point + if (_function == FN_CLEAR1) { + clearRoom(); + break; + } else if (_function == FN_CLEAR2) { + clearRoom(); + return; + } else if (_function == FN_RELOAD) { + reloadRoom1(); + reloadFlag = true; + break; + } else if (_function == FN_BREAK) { + break; + } + + if (_vm->_player->_scrollFlag) { + _vm->copyBF1BF2(); + _vm->_newRects.clear(); + _function = FN_NONE; + roomLoop(); + + if (_function == FN_CLEAR1) { + clearRoom(); + break; + } else { + _vm->plotList(); + _vm->copyRects(); + _vm->copyBF2Vid(); + } + } else { + _vm->copyBF1BF2(); + _vm->_newRects.clear(); + _function = FN_NONE; + + roomLoop(); + if (_vm->shouldQuitOrRestart()) + return; + + if (_function == FN_CLEAR1) { + clearRoom(); + break; + } else { + _vm->plotList(); + + if (_vm->_events->_mousePos.y < 177) + _vm->_events->setCursor(_vm->_events->_normalMouse); + else + _vm->_events->setCursor(CURSOR_ARROW); + + _vm->copyBlocks(); + } + } + } + } +} + +void Room::clearRoom() { + if (_vm->_midi->_music) { + _vm->_midi->stopSong(); + _vm->_midi->freeMusic(); + } + + _vm->_sound->freeSounds(); + _vm->_numAnimTimers = 0; + + _vm->_animation->freeAnimationData(); + _vm->_scripts->freeScriptData(); + _vm->freeCells(); + freePlayField(); + freeTileData(); + _vm->_player->freeSprites(); +} + +void Room::loadRoomData(const byte *roomData) { + RoomInfo roomInfo(roomData, _vm->getGameID(), _vm->isCD(), _vm->isDemo()); + + _roomFlag = roomInfo._roomFlag; + + _vm->_establishFlag = false; + if (roomInfo._estIndex != -1) { + _vm->_establishFlag = true; + if (_vm->_establishTable[roomInfo._estIndex] != 1) { + _vm->_establishTable[roomInfo._estIndex] = 1; + _vm->establish(0, roomInfo._estIndex); + } + } + + _vm->_midi->freeMusic(); + if (roomInfo._musicFile._fileNum != -1) { + _vm->_midi->loadMusic(roomInfo._musicFile); + _vm->_midi->midiPlay(); + _vm->_midi->setLoop(true); + } + + _vm->_scaleH1 = roomInfo._scaleH1; + _vm->_scaleH2 = roomInfo._scaleH2; + _vm->_scaleN1 = roomInfo._scaleN1; + _vm->_scaleT1 = ((_vm->_scaleH1 - _vm->_scaleH2) << 8) / _vm->_scaleN1; + + if (roomInfo._playFieldFile._fileNum != -1) { + loadPlayField(roomInfo._playFieldFile._fileNum, + roomInfo._playFieldFile._subfile); + setupRoom(); + + _vm->_scaleMaxY = _playFieldHeight << 4; + } + + // Load cells + _vm->loadCells(roomInfo._cells); + + // Load script data + _vm->_scripts->freeScriptData(); + if (roomInfo._scriptFile._fileNum != -1) { + Resource *newScript = _vm->_files->loadFile(roomInfo._scriptFile); + _vm->_scripts->setScript(newScript); + } + + // Load animation data + _vm->_animation->freeAnimationData(); + if (roomInfo._animFile._fileNum != -1) { + Resource *anim = _vm->_files->loadFile(roomInfo._animFile); + _vm->_animation->loadAnimations(anim); + delete anim; + } + + _vm->_scale = _vm->_scaleI = roomInfo._scaleI; + _vm->_screen->setScaleTable(_vm->_scale); + _vm->_player->_scrollThreshold = roomInfo._scrollThreshold; + + // Handle loading scene palette data + if (roomInfo._paletteFile._fileNum != -1) { + _vm->_screen->_startColor = roomInfo._startColor; + _vm->_screen->_numColors = roomInfo._numColors; + _vm->_screen->loadPalette(roomInfo._paletteFile._fileNum, + roomInfo._paletteFile._subfile); + } + + // Load extra cells + _vm->_extraCells.clear(); + for (uint i = 0; i < roomInfo._extraCells.size(); ++i) + _vm->_extraCells.push_back(roomInfo._extraCells[i]); + + // Load sounds for the scene + _vm->_sound->loadSounds(roomInfo._sounds); +} + +void Room::roomLoop() { + _vm->_scripts->_sequence = ROOM_SCRIPT; + _vm->_scripts->searchForSequence(); + _vm->_scripts->executeScript(); +} + +void Room::setupRoom() { + Screen &screen = *_vm->_screen; + screen.setScaleTable(_vm->_scale); + screen.setBufferScan(); + + if (_roomFlag != 2) + screen.setIconPalette(); + + if (screen._vWindowWidth == _playFieldWidth) { + _vm->_scrollX = 0; + _vm->_scrollCol = 0; + } else { + int xv = _vm->_player->_rawPlayer.x / TILE_WIDTH; + _vm->_scrollX = _vm->_player->_rawPlayer.x % TILE_WIDTH; + _vm->_scrollCol = MAX(xv - (screen._vWindowWidth / 2), 0); + + int sx = _vm->_scrollCol + screen._vWindowWidth - _playFieldWidth; + if (sx >= 0) { + _vm->_scrollCol -= sx + 1; + } + } + + if (screen._vWindowHeight == _playFieldHeight) { + _vm->_scrollY = 0; + _vm->_scrollRow = 0; + } else { + _vm->_scrollY = _vm->_player->_rawPlayer.y - + (_vm->_player->_rawPlayer.y / 16) * 16; + int yc = MAX((_vm->_player->_rawPlayer.y >> 4) - + (screen._vWindowHeight / 2), 0); + _vm->_scrollRow = yc; + + yc = yc + screen._vWindowHeight - _playFieldHeight; + if (yc >= 0) { + _vm->_scrollRow = _playFieldHeight - screen._vWindowHeight; + _vm->_scrollY = 0; + } + } +} + +void Room::setWallCodes() { + _jetFrame.clear(); + _jetFrame.resize(_plotter._walls.size()); + + _vm->_player->_rawXTemp = _vm->_player->_rawPlayer.x; + _vm->_player->_rawYTemp = _vm->_player->_rawPlayer.y; +} + +void Room::buildScreen() { + int scrollCol = _vm->_scrollCol; + int offset = 0; + + // Clear current background buffer + _vm->_buffer1.clearBuffer(); + + // WORKAROUND: Original's use of '+ 1' would frequently cause memory overruns + int w = MIN(_vm->_screen->_vWindowWidth + 1, _playFieldWidth); + + // Loop through drawing each column of tiles forming the background + for (int idx = 0; idx < w; offset += TILE_WIDTH, ++idx) { + buildColumn(_vm->_scrollCol, offset); + ++_vm->_scrollCol; + } + + _vm->_scrollCol = scrollCol; + _vm->copyBF1BF2(); +} + +void Room::buildColumn(int playX, int screenX) { + if (playX < 0 || playX >= _playFieldWidth) + return; + + const byte *pSrc = _playField + _vm->_scrollRow * + _playFieldWidth + playX; + + // WORKAROUND: Original's use of '+ 1' would frequently cause memory overruns + int h = MIN(_vm->_screen->_vWindowHeight + 1, _playFieldHeight); + + for (int y = 0; y < h; ++y) { + byte *pTile = _tile + (*pSrc << 8); + byte *pDest = (byte *)_vm->_buffer1.getBasePtr(screenX, y * TILE_HEIGHT); + + for (int tileY = 0; tileY < TILE_HEIGHT; ++tileY) { + Common::copy(pTile, pTile + TILE_WIDTH, pDest); + pTile += TILE_WIDTH; + pDest += _vm->_buffer1.pitch; + } + + pSrc += _playFieldWidth; + } +} + +void Room::buildRow(int playY, int screenY) { + if (playY < 0 || playY >= _playFieldHeight) + return; + assert(screenY <= (_vm->_screen->h - TILE_HEIGHT)); + + const byte *pSrc = _playField + playY *_playFieldWidth + _vm->_scrollCol; + + // WORKAROUND: Original's use of '+ 1' would frequently cause memory overruns + int w = MIN(_vm->_screen->_vWindowWidth + 1, _playFieldWidth); + + for (int x = 0; x < w; ++x) { + byte *pTile = _tile + (*pSrc << 8); + byte *pDest = (byte *)_vm->_buffer1.getBasePtr(x * TILE_WIDTH, screenY); + + for (int tileY = 0; tileY < TILE_HEIGHT; ++tileY) { + Common::copy(pTile, pTile + TILE_WIDTH, pDest); + pTile += TILE_WIDTH; + pDest += _vm->_buffer1.pitch; + } + + ++pSrc; + } +} + +void Room::loadPlayField(int fileNum, int subfile) { + Resource *playData = _vm->_files->loadFile(fileNum, subfile); + byte header[16]; + playData->_stream->read(&header[0], 16); + Screen &screen = *_vm->_screen; + + // Copy the new palette + screen.loadRawPalette(playData->_stream); + + // Copy off the tile data + int tileSize = (int)header[2] << 8; + _tile = new byte[tileSize]; + playData->_stream->read(_tile, tileSize); + + // Copy off the playfield data + _matrixSize = header[0] * header[1]; + _playField = new byte[_matrixSize]; + playData->_stream->read(_playField, _matrixSize); + + // Load the plotter data + int numWalls = READ_LE_UINT16(&header[6]); + int numBlocks = header[8]; + _plotter.load(playData->_stream, numWalls, numBlocks); + + _playFieldWidth = header[0]; + _playFieldHeight = header[1]; + screen._vWindowWidth = header[3]; + screen._vWindowBytesWide = screen._vWindowWidth << 4; + screen._bufferBytesWide = screen._vWindowBytesWide + 16; + screen._vWindowHeight = header[4]; + screen._vWindowLinesTall = screen._vWindowHeight << 4; + + _vm->_screen->setBufferScan(); + delete playData; +} + +/*------------------------------------------------------------------------*/ + +Plotter::Plotter() { + _delta = _blockIn = 0; +} + +void Plotter::load(Common::SeekableReadStream *stream, int wallCount, int blockCount) { + // Load the wall count + _walls.resize(wallCount); + + for (int i = 0; i < wallCount; ++i) + _walls[i].left = stream->readSint16LE(); + for (int i = 0; i < wallCount; ++i) + _walls[i].top = stream->readSint16LE(); + for (int i = 0; i < wallCount; ++i) + _walls[i].right = stream->readSint16LE(); + for (int i = 0; i < wallCount; ++i) + _walls[i].bottom = stream->readSint16LE(); + + // Load the block list + _blocks.resize(blockCount); + + for (int i = 0; i < blockCount; ++i) + _blocks[i].left = stream->readSint16LE(); + for (int i = 0; i < blockCount; ++i) + _blocks[i].top = stream->readSint16LE(); + for (int i = 0; i < blockCount; ++i) + _blocks[i].right = stream->readSint16LE(); + for (int i = 0; i < blockCount; ++i) + _blocks[i].bottom = stream->readSint16LE(); +} + +void Room::doCommands() { + int commandId = 0; + Common::KeyState keyState; + + if (_vm->_startup != -1) + return; + + if (_vm->_inventory->_invChangeFlag) + _vm->_inventory->refreshInventory(); + + if (_vm->_screen->_screenChangeFlag) { + _vm->_screen->_screenChangeFlag = false; + _vm->_events->_cursorExitFlag = true; + executeCommand(7); + } + else if (_vm->_events->_wheelUp || _vm->_events->_wheelDown) { + // Handle scrolling mouse wheel + cycleCommand(_vm->_events->_wheelUp ? 1 : -1); + + } else if (_vm->_events->_middleButton) { + // Switch back to walking + handleCommand(7); + + } else if (_vm->_events->_leftButton) { + if (_vm->_events->_mouseRow >= 22) { + // Mouse in user interface area + for (commandId = 0; commandId < 10; ++commandId) { + if (_vm->_events->_mousePos.x >= RMOUSE[commandId][0] && + _vm->_events->_mousePos.x < RMOUSE[commandId][1]) + break; + } + if (commandId < 10) + handleCommand(commandId); + + } else { + // Mouse click in main game area + mainAreaClick(); + } + } else if (_vm->_events->getKey(keyState)) { + if (keyState.keycode == Common::KEYCODE_F1) + handleCommand(keyState.keycode - Common::KEYCODE_F1 + 1); + else if (keyState.keycode >= Common::KEYCODE_F2 && keyState.keycode <= Common::KEYCODE_F10) + handleCommand(keyState.keycode - Common::KEYCODE_F1); + } +} + +void Room::cycleCommand(int incr) { + int command = _selectCommand + incr; + if (command < -1) + command = 6; + else if (command == -1) + command = 7; + else if (command == 1) + command = (incr == 1) ? 2 : 0; + else if (command == 4) + command = (incr == 1) ? 5 : 3; + + handleCommand(command); +} + +void Room::handleCommand(int commandId) { + if (commandId == 1) + --commandId; + + if (commandId == 9) { + _vm->_events->debounceLeft(); + _vm->_canSaveLoad = true; + _vm->openMainMenuDialog(); + _vm->_canSaveLoad = false; + } else if (commandId == _selectCommand) { + _vm->_events->debounceLeft(); + commandOff(); + } else { + _vm->_events->debounceLeft(); + executeCommand(commandId); + } +} + +void Room::executeCommand(int commandId) { + EventsManager &events = *_vm->_events; + _selectCommand = commandId; + + switch (commandId) { + case 0: + events.forceSetCursor(CURSOR_LOOK); + break; + case 2: + events.forceSetCursor(CURSOR_USE); + break; + case 3: + events.forceSetCursor(CURSOR_TAKE); + break; + case 4: + events.setCursor(CURSOR_ARROW); + if (_vm->_inventory->newDisplayInv() == 2) { + commandOff(); + return; + } + break; + case 5: + events.forceSetCursor(CURSOR_CLIMB); + break; + case 6: + events.forceSetCursor(CURSOR_TALK); + break; + case 7: + walkCursor(); + return; + case 8: + events.forceSetCursor(CURSOR_HELP); + break; + default: + break; + } + + // Draw the default toolbar menu at the bottom of the screen + roomMenu(); + _vm->_screen->saveScreen(); + _vm->_screen->setDisplayScan(); + + // Get the toolbar icons resource + Resource *iconData = _vm->_files->loadFile("ICONS.LZ"); + SpriteResource *spr = new SpriteResource(_vm, iconData); + delete iconData; + + // Draw the button as selected + _vm->_screen->plotImage(spr, _selectCommand + 2, + Common::Point(RMOUSE[_selectCommand][0], 176)); + + _vm->_screen->restoreScreen(); + _vm->_boxSelect = true; +} + +void Room::walkCursor() { + EventsManager &events = *_vm->_events; + + events.forceSetCursor(CURSOR_CROSSHAIRS); + _vm->_scripts->_sequence = 5000; + _vm->_scripts->searchForSequence(); + roomMenu(); + _selectCommand = -1; + + _conFlag = true; + while (_conFlag && !_vm->shouldQuitOrRestart()) { + _conFlag = false; + _vm->_scripts->executeScript(); + } + + _vm->_boxSelect = true; +} + +void Room::commandOff() { + _selectCommand = -1; + _vm->_events->forceSetCursor(CURSOR_CROSSHAIRS); + roomMenu(); +} + +int Room::checkBoxes() { + return checkBoxes1(_vm->_player->_rawPlayer); +} + +int Room::checkBoxes1(const Common::Point &pt) { + return checkBoxes2(pt, 0, _plotter._blocks.size()); +} + +int Room::checkBoxes2(const Common::Point &pt, int start, int count) { + for (; count > 0; --count, ++start) { + if (_plotter._blocks[start].contains(pt)) { + _plotter._blockIn = start; + return start; + } + } + + return -1; +} + +void Room::checkBoxes3() { + Common::Point pt = _vm->_events->calcRawMouse(); + + for (uint start = 0; start < _plotter._blocks.size(); ++start) { + if (_plotter._blocks[start].contains(pt)) { + _plotter._blockIn = start; + if (!(validateBox(start) & 0x80)) { + _vm->_events->debounceLeft(); + _vm->_boxSelect = start; + + _conFlag = true; + while (_conFlag && !_vm->shouldQuitOrRestart()) { + _conFlag = false; + _vm->_scripts->executeScript(); + } + + _vm->_boxSelect = true; + return; + } + } + } +} + +int Room::validateBox(int boxId) { + _vm->_scripts->_sequence = boxId; + _vm->_scripts->searchForSequence(); + return _vm->_scripts->executeScript(); +} + +void Room::swapOrg() { + SWAP<int>(_vm->_screen->_orgX1, _vm->_screen->_orgX2); + SWAP<int>(_vm->_screen->_orgY1, _vm->_screen->_orgY2); +} + +int Room::calcLR(int yp) { + const Screen &screen = *_vm->_screen; + + int yv = (yp - screen._orgY1) * (screen._orgX2 - screen._orgX1); + int yd = screen._orgY2 - screen._orgY1; + + int rem = (yv % yd) << 1; + yv /= yd; + if (rem >= yd || rem < 0) + ++yv; + + return yv + screen._orgX1; +} + +int Room::calcUD(int xp) { + const Screen &screen = *_vm->_screen; + + int xv = (xp - screen._orgX1) * (screen._orgY2 - screen._orgY1); + int xd = screen._orgX2 - screen._orgX1; + + int rem = (xv % xd) << 1; + xv /= xd; + if (rem >= xd || rem < 0) + ++xv; + + return xv + screen._orgY1; +} + +bool Room::codeWalls() { + Screen &screen = *_vm->_screen; + Player &player = *_vm->_player; + + if (_plotter._walls.size() == 0) + return false; + + for (uint i = 0; i < _plotter._walls.size(); ++i) { + Common::Rect &r = _plotter._walls[i]; + JetFrame &jf = _jetFrame[i]; + + jf._wallCode = 0; + jf._wallCode1 = 0; + screen._orgX1 = r.left; + screen._orgY1 = r.top; + screen._orgX2 = r.right; + screen._orgY2 = r.bottom; + + if (screen._orgY2 != screen._orgY1) { + if (screen._orgY2 < screen._orgY1) + swapOrg(); + + if ((player._rawYTemp >= screen._orgY1) && + (player._rawYTemp <= screen._orgY2)) { + jf._wallCode |= (calcLR(player._rawYTemp) - player._rawXTemp) < 0 ? 2 : 1; + jf._wallCode1 |= (calcLR(player._rawYTemp) - + (player._rawXTemp + player._playerOffset.x)) < 0 ? 2 : 1; + } + } + + if (screen._orgX2 != screen._orgX1) { + if (screen._orgX2 < screen._orgX1) + swapOrg(); + + if ((player._rawXTemp >= screen._orgX1) && + (player._rawXTemp <= screen._orgX2)) { + int y = screen._orgY2; + if (y != screen._orgY1) + y = calcUD(player._rawXTemp); + + jf._wallCode |= (player._rawYTemp - y) < 0 ? 4 : 8; + } + + int x = player._rawXTemp + player._playerOffset.x; + if ((x >= screen._orgX1) && (x <= screen._orgX2)) { + int y = screen._orgY2; + if (screen._orgY2 != screen._orgY1) + y = calcUD(player._rawXTemp + player._playerOffset.x); + + jf._wallCode1 |= (player._rawYTemp - y) < 0 ? 4 : 8; + } + } + } + + for (uint i = 0; i < _jetFrame.size(); ++i) { + JetFrame &jf = _jetFrame[i]; + if (checkCode(jf._wallCode, jf._wallCodeOld) || + checkCode(jf._wallCode1, jf._wallCode1Old)) + return true; + } + + // Copy the current wall calculations to the old properties + for (uint i = 0; i < _jetFrame.size(); ++i) { + JetFrame &jf = _jetFrame[i]; + jf._wallCodeOld = jf._wallCode; + jf._wallCode1Old = jf._wallCode1; + } + + return false; +} + +bool Room::checkCode(int v1, int v2) { + Player &p = *_vm->_player; + + if (!v1 || !v2 || (v1 == v2)) + return false; + + if (v1 & 1) { + if (v2 & 2) { + p._collideFlag = true; + return true; + } + } else if (v1 & 2) { + if (v2 & 1) { + p._collideFlag = true; + return true; + } + } else if (v1 & 4) { + if (v2 & 8) { + p._collideFlag = true; + return true; + } + } else if (v1 & 8) { + if (v2 & 4) { + p._collideFlag = true; + return true; + } + } + + return false; +} + +/*------------------------------------------------------------------------*/ + +RoomInfo::RoomInfo(const byte *data, int gameType, bool isCD, bool isDemo) { + Common::MemoryReadStream stream(data, 999); + + _roomFlag = stream.readByte(); + + if (gameType == GType_Amazon) { + if (isCD) + _estIndex = stream.readSint16LE(); + else { + _estIndex = -1; + if (!isDemo) + stream.readSint16LE(); + } + } else + _estIndex = -1; + + _musicFile.load(stream); + _scaleH1 = stream.readByte(); + _scaleH2 = stream.readByte(); + _scaleN1 = stream.readByte(); + _playFieldFile.load(stream); + + for (byte cell = stream.readByte(); cell != 0xff; cell = stream.readByte()) { + CellIdent ci; + ci._cell = cell; + ci.load(stream); + + _cells.push_back(ci); + } + + _scriptFile.load(stream); + _animFile.load(stream); + _scaleI = stream.readByte(); + _scrollThreshold = stream.readByte(); + _paletteFile.load(stream); + if (_paletteFile._fileNum == -1) { + _startColor = _numColors = 0; + } else { + _startColor = stream.readUint16LE(); + _numColors = stream.readUint16LE(); + } + + for (int16 v = stream.readSint16LE(); v != -1; v = stream.readSint16LE()) { + ExtraCell ec; + ec._vid._fileNum = v; + ec._vid._subfile = stream.readSint16LE(); + + _extraCells.push_back(ec); + } + + for (int16 fileNum = stream.readSint16LE(); fileNum != -1; fileNum = stream.readSint16LE()) { + SoundIdent fi; + fi._fileNum = fileNum; + fi._subfile = stream.readUint16LE(); + fi._priority = stream.readUint16LE(); + + _sounds.push_back(fi); + } +} + +} // End of namespace Access |