mirror of
https://github.com/libretro/scummvm.git
synced 2025-01-31 16:03:24 +00:00
455 lines
12 KiB
C++
455 lines
12 KiB
C++
/* 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 = 0;
|
|
_roomFlag = 0;
|
|
_playField = nullptr;
|
|
_playFieldWidth = _playFieldHeight = 0;
|
|
_matrixSize = 0;
|
|
_tile = nullptr;
|
|
}
|
|
|
|
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 = 0;
|
|
_function = 0;
|
|
|
|
while (!_vm->shouldQuit()) {
|
|
_vm->_images.clear();
|
|
if (_vm->_startup != -1 && --_vm->_startup != 0) {
|
|
_vm->_events->showCursor();
|
|
_vm->_screen->fadeIn();
|
|
}
|
|
|
|
// TODO: Game loop doesn't seem to have any delay. For now,
|
|
// introduce a slight delay here
|
|
_vm->_events->delay(50);
|
|
|
|
// Handle any events
|
|
_vm->_events->pollEvents();
|
|
|
|
_vm->_player->walk();
|
|
_vm->_sound->midiRepeat();
|
|
_vm->_player->checkScroll();
|
|
doCommands();
|
|
|
|
// DOROOMFLASHBACK jump point
|
|
if (_function == 1) {
|
|
clearRoom();
|
|
break;
|
|
} else if (_function == 2) {
|
|
clearRoom();
|
|
return;
|
|
} else if (_function == 3) {
|
|
reloadRoom1();
|
|
reloadFlag = true;
|
|
break;
|
|
} else if (_function == 4) {
|
|
break;
|
|
}
|
|
|
|
if (_vm->_player->_scrollFlag) {
|
|
_vm->copyBF1BF2();
|
|
_vm->_newRects.clear();
|
|
_function = 0;
|
|
roomLoop();
|
|
|
|
if (_function == 1) {
|
|
clearRoom();
|
|
break;
|
|
} else {
|
|
_vm->plotList();
|
|
_vm->copyRects();
|
|
_vm->copyBF2Vid();
|
|
}
|
|
} else {
|
|
_vm->copyBF1BF2();
|
|
_vm->_newRects.clear();
|
|
_function = 0;
|
|
roomLoop();
|
|
|
|
if (_function == 1) {
|
|
clearRoom();
|
|
break;
|
|
} else {
|
|
_vm->plotList();
|
|
_vm->copyBlocks();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Room::clearRoom() {
|
|
if (_vm->_sound->_music) {
|
|
_vm->_sound->stopSong();
|
|
delete[] _vm->_sound->_music;
|
|
_vm->_sound->_music = nullptr;
|
|
}
|
|
|
|
_vm->_sound->freeSounds();
|
|
_vm->_numAnimTimers = 0;
|
|
|
|
_vm->_animation->freeAnimationData();
|
|
_vm->_scripts->freeScriptData();
|
|
_vm->freeCells();
|
|
freePlayField();
|
|
_vm->freeInactiveData();
|
|
_vm->_player->freeSprites();
|
|
}
|
|
|
|
void Room::loadRoomData(const byte *roomData) {
|
|
RoomInfo roomInfo(roomData);
|
|
|
|
_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->_sound->freeMusic();
|
|
if (roomInfo._musicFile._fileNum != -1) {
|
|
_vm->_sound->_music = _vm->_files->loadFile(roomInfo._musicFile._fileNum,
|
|
roomInfo._musicFile._subfile);
|
|
_vm->_sound->_midiSize = _vm->_files->_filesize;
|
|
_vm->_sound->midiPlay();
|
|
_vm->_sound->_musicRepeat = true;
|
|
}
|
|
|
|
_vm->_scaleH1 = roomInfo._scaleH1;
|
|
_vm->_scaleH2 = roomInfo._scaleH2;
|
|
_vm->_scaleN1 = roomInfo._scaleN1;
|
|
_vm->_scaleT1 = ((_vm->_scaleH2 - _vm->_scaleH1) << 8) / _vm->_scaleN1;
|
|
|
|
if (roomInfo._playFieldFile._fileNum != -1) {
|
|
loadPlayField(roomInfo._playFieldFile._fileNum,
|
|
roomInfo._playFieldFile._subfile);
|
|
setupRoom();
|
|
|
|
_vm->_scaleMaxY = _vm->_playFieldHeight << 4;
|
|
}
|
|
|
|
// Load cells
|
|
_vm->loadCells(roomInfo._cells);
|
|
|
|
// Load script data
|
|
_vm->_scripts->freeScriptData();
|
|
if (roomInfo._scriptFile._fileNum != -1) {
|
|
const byte *data = _vm->_files->loadFile(roomInfo._scriptFile._fileNum,
|
|
roomInfo._scriptFile._subfile);
|
|
_vm->_scripts->setScript(data, _vm->_files->_filesize);
|
|
}
|
|
|
|
// Load animation data
|
|
_vm->_animation->freeAnimationData();
|
|
if (roomInfo._animFile._fileNum != -1) {
|
|
byte *data = _vm->_files->loadFile(roomInfo._animFile._fileNum,
|
|
roomInfo._animFile._subfile);
|
|
_vm->_animation->loadAnimations(data, _vm->_files->_filesize);
|
|
}
|
|
|
|
_vm->_scaleI = roomInfo._scaleI;
|
|
_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._vidTable.size(); ++i) {
|
|
ExtraCell ec;
|
|
ec._vidTable = roomInfo._vidTable[i] & 0xffff;
|
|
ec._vidTable1 = roomInfo._vidTable[i] >> 16;
|
|
|
|
_vm->_extraCells.push_back(ec);
|
|
}
|
|
|
|
// Load sounds for the scene
|
|
_vm->_sound->loadSounds(roomInfo._sounds);
|
|
}
|
|
|
|
void Room::roomLoop() {
|
|
_vm->_scripts->_sequence = 2000;
|
|
_vm->_scripts->searchForSequence();
|
|
_vm->_scripts->executeScript();
|
|
}
|
|
|
|
void Room::setupRoom() {
|
|
_vm->_screen->setScaleTable(_vm->_scale);
|
|
_vm->_screen->setBufferScan();
|
|
|
|
if (_roomFlag != 2)
|
|
setIconPalette();
|
|
|
|
if (_vm->_screen->_vWindowWidth == _playFieldWidth) {
|
|
_vm->_screen->_scrollX = 0;
|
|
_vm->_screen->_scrollCol = 0;
|
|
} else {
|
|
_vm->_screen->_scrollX = _vm->_player->_rawPlayer.x -
|
|
(_vm->_player->_rawPlayer.x >> 4);
|
|
int xp = MAX((_vm->_player->_rawPlayer.x >> 4) -
|
|
(_vm->_screen->_vWindowWidth / 2), 0);
|
|
_vm->_screen->_scrollCol = xp;
|
|
|
|
xp = xp + _vm->_screen->_vWindowWidth - _playFieldWidth;
|
|
if (xp >= 0) {
|
|
_vm->_screen->_scrollCol = xp + 1;
|
|
}
|
|
}
|
|
|
|
if (_vm->_screen->_vWindowHeight == _playFieldHeight) {
|
|
_vm->_screen->_scrollY = 0;
|
|
_vm->_screen->_scrollRow = 0;
|
|
} else {
|
|
_vm->_screen->_scrollY = _vm->_player->_rawPlayer.y -
|
|
(_vm->_player->_rawPlayer.y >> 4);
|
|
int yp = MAX((_vm->_player->_rawPlayer.y >> 4) -
|
|
(_vm->_screen->_vWindowHeight / 2), 0);
|
|
_vm->_screen->_scrollRow = yp;
|
|
|
|
yp = yp + _vm->_screen->_vWindowHeight - _playFieldHeight;
|
|
if (yp >= 0) {
|
|
_vm->_screen->_scrollRow = yp + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
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->_screen->_scrollCol;
|
|
int cnt = _vm->_screen->_vWindowWidth + 1;
|
|
int offset = 0;
|
|
|
|
for (int idx = 0; idx < cnt; offset += TILE_WIDTH, ++idx) {
|
|
buildColumn(_vm->_screen->_scrollCol, offset);
|
|
++_vm->_screen->_scrollCol;
|
|
}
|
|
|
|
_vm->_screen->_scrollCol = scrollCol;
|
|
_vm->copyBF1BF2();
|
|
}
|
|
|
|
void Room::buildColumn(int playX, int screenX) {
|
|
const byte *pSrc = _playField + _vm->_screen->_scrollRow *
|
|
_playFieldWidth + playX;
|
|
|
|
for (int y = 0; y <= _vm->_screen->_vWindowHeight; ++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) {
|
|
error("TODO: buildRow");
|
|
}
|
|
|
|
void Room::init4Quads() {
|
|
error("TODO: init4Quads");
|
|
}
|
|
|
|
void Room::loadPlayField(int fileNum, int subfile) {
|
|
byte *playData = _vm->_files->loadFile(fileNum, subfile);
|
|
Common::MemoryReadStream stream(playData + 0x10, _vm->_files->_filesize - 0x10);
|
|
Screen &screen = *_vm->_screen;
|
|
|
|
// Copy the new palette
|
|
screen.loadRawPalette(&stream);
|
|
|
|
// Copy off the tile data
|
|
_tileSize = playData[2] << 8;
|
|
_tile = new byte[_tileSize];
|
|
stream.read(_tile, _tileSize);
|
|
|
|
// Copy off the playfield data
|
|
_matrixSize = playData[0] * playData[1];
|
|
_playField = new byte[_matrixSize];
|
|
stream.read(_playField, _matrixSize);
|
|
|
|
// Load the plotter data
|
|
int numWalls = READ_LE_UINT16(playData + 6);
|
|
int numBlocks = playData[8];
|
|
_plotter.load(&stream, numWalls, numBlocks);
|
|
|
|
_playFieldWidth = playData[0];
|
|
_playFieldHeight = playData[1];
|
|
screen._vWindowWidth = playData[3];
|
|
screen._vWindowBytesWide = screen._vWindowWidth << 4;
|
|
screen._bufferBytesWide = screen._vWindowBytesWide + 16;
|
|
screen._vWindowHeight = playData[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();
|
|
}
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
RoomInfo::RoomInfo(const byte *data) {
|
|
Common::MemoryReadStream stream(data, 999);
|
|
|
|
_roomFlag = stream.readByte();
|
|
_estIndex = (int16)stream.readUint16LE();
|
|
_musicFile._fileNum = (int16)stream.readUint16LE();
|
|
_musicFile._subfile = stream.readUint16LE();
|
|
_scaleH1 = stream.readByte();
|
|
_scaleH2 = stream.readByte();
|
|
_scaleN1 = stream.readByte();
|
|
_playFieldFile._fileNum = (int16)stream.readUint16LE();
|
|
_playFieldFile._subfile = stream.readUint16LE();
|
|
|
|
for (byte cell = stream.readByte(); cell != 0xff; cell = stream.readByte()) {
|
|
CellIdent ci;
|
|
ci._cell = cell;
|
|
ci._fileNum = (int16)stream.readUint16LE();
|
|
ci._subfile = stream.readUint16LE();
|
|
|
|
_cells.push_back(ci);
|
|
}
|
|
|
|
_scriptFile._fileNum = (int16)stream.readUint16LE();
|
|
_scriptFile._subfile = stream.readUint16LE();
|
|
_animFile._fileNum = (int16)stream.readUint16LE();
|
|
_animFile._subfile = stream.readUint16LE();
|
|
_scaleI = stream.readByte();
|
|
_scrollThreshold = stream.readByte();
|
|
_paletteFile._fileNum = (int16)stream.readUint16LE();
|
|
_paletteFile._subfile = stream.readUint16LE();
|
|
if (_paletteFile._fileNum == -1) {
|
|
_startColor = _numColors = 0;
|
|
} else {
|
|
_startColor = stream.readUint16LE();
|
|
_numColors = stream.readUint16LE();
|
|
}
|
|
|
|
for (int16 v = (int16)stream.readUint16LE(); v != -1;
|
|
v = (int16)stream.readUint16LE()) {
|
|
uint16 v2 = stream.readUint16LE();
|
|
|
|
_vidTable.push_back(v | ((uint32)v2 << 16));
|
|
}
|
|
|
|
for (int16 fileNum = (int16)stream.readUint16LE(); fileNum != -1;
|
|
fileNum = (int16)stream.readUint16LE()) {
|
|
SoundIdent fi;
|
|
fi._fileNum = fileNum;
|
|
fi._subfile = stream.readUint16LE();
|
|
fi._priority = stream.readUint16LE();
|
|
|
|
_sounds.push_back(fi);
|
|
}
|
|
}
|
|
|
|
} // End of namespace Access
|