path: root/engines/sherlock/scene.cpp

/* 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 "sherlock/scene.h"
#include "sherlock/sherlock.h"
#include "sherlock/screen.h"
#include "sherlock/scalpel/scalpel.h"
#include "sherlock/scalpel/scalpel_people.h"
#include "sherlock/scalpel/scalpel_scene.h"
#include "sherlock/tattoo/tattoo.h"
#include "sherlock/tattoo/tattoo_scene.h"
#include "sherlock/tattoo/tattoo_user_interface.h"

namespace Sherlock {

static const int FS_TRANS[8] = {
	Scalpel::STOP_UP, Scalpel::STOP_UPRIGHT, Scalpel::STOP_RIGHT, Scalpel::STOP_DOWNRIGHT, 
	Scalpel::STOP_DOWN, Scalpel::STOP_DOWNLEFT, Scalpel::STOP_LEFT, Scalpel::STOP_UPLEFT
};

/*----------------------------------------------------------------*/

BgFileHeader::BgFileHeader() {
	_numStructs = -1;
	_numImages = -1;
	_numcAnimations = -1;
	_descSize = -1;
	_seqSize = -1;

	// Serrated Scalpel
	_fill = -1;

	// Rose Tattoo
	_scrollSize = -1;
	_bytesWritten = -1;
	_fadeStyle = -1;
	Common::fill(&_palette[0], &_palette[PALETTE_SIZE], 0);
}

void BgFileHeader::load(Common::SeekableReadStream &s, bool isRoseTattoo) {
	_numStructs = s.readUint16LE();
	_numImages = s.readUint16LE();
	_numcAnimations = s.readUint16LE();
	_descSize = s.readUint16LE();
	_seqSize = s.readUint16LE();

	if (isRoseTattoo) {
		_scrollSize = s.readUint16LE();
		_bytesWritten = s.readUint32LE();
		_fadeStyle = s.readByte();
	} else {
		_fill = s.readUint16LE();

	}
}

/*----------------------------------------------------------------*/

void BgFileHeaderInfo::load(Common::SeekableReadStream &s) {
	_filesize = s.readUint32LE();
	_maxFrames = s.readByte();

	char buffer[9];
	s.read(buffer, 9);
	_filename = Common::String(buffer);
}

void BgFileHeaderInfo::load3DO(Common::SeekableReadStream &s) {
	_filesize = s.readUint32BE();
	_maxFrames = s.readByte();

	char buffer[9];
	s.read(buffer, 9);
	_filename = Common::String(buffer);
	s.skip(2); // only on 3DO!
}

/*----------------------------------------------------------------*/

void Exit::load(Common::SeekableReadStream &s, bool isRoseTattoo) {
	if (isRoseTattoo) {
		char buffer[41];
		s.read(buffer, 41);
		_dest = Common::String(buffer);
	}

	left = s.readSint16LE();
	top = s.readSint16LE();
	setWidth(s.readUint16LE());
	setHeight(s.readUint16LE());

	_image = isRoseTattoo ? s.readByte() : 0;
	_scene = s.readSint16LE();

	if (!isRoseTattoo)
		_allow = s.readSint16LE();

	_newPosition.x = s.readSint16LE();
	_newPosition.y = s.readSint16LE();
	_newPosition._facing = s.readUint16LE();

	if (isRoseTattoo)
		_allow = s.readSint16LE();
}

void Exit::load3DO(Common::SeekableReadStream &s) {
	left = s.readSint16BE();
	top = s.readSint16BE();
	setWidth(s.readUint16BE());
	setHeight(s.readUint16BE());

	_image = 0;
	_scene = s.readSint16BE();

	_allow = s.readSint16BE();

	_newPosition.x = s.readSint16BE();
	_newPosition.y = s.readSint16BE();
	_newPosition._facing = s.readUint16BE();
	s.skip(2); // Filler
}

/*----------------------------------------------------------------*/

void SceneEntry::load(Common::SeekableReadStream &s) {
	_startPosition.x = s.readSint16LE();
	_startPosition.y = s.readSint16LE();
	_startDir = s.readByte();
	_allow = s.readByte();
}

void SceneEntry::load3DO(Common::SeekableReadStream &s) {
	_startPosition.x = s.readSint16BE();
	_startPosition.y = s.readSint16BE();
	_startDir = s.readByte();
	_allow = s.readByte();
}

void SceneSound::load(Common::SeekableReadStream &s) {
	char buffer[9];
	s.read(buffer, 8);
	buffer[8] = '\0';

	_name = Common::String(buffer);
	_priority = s.readByte();
}

void SceneSound::load3DO(Common::SeekableReadStream &s) {
	load(s);
}

/*----------------------------------------------------------------*/

int ObjectArray::indexOf(const Object &obj) const {
	for (uint idx = 0; idx < size(); ++idx) {
		if (&(*this)[idx] == &obj)
			return idx;
	}

	return -1;
}

/*----------------------------------------------------------------*/

void ScaleZone::load(Common::SeekableReadStream &s) {
	left = s.readSint16LE();
	top = s.readSint16LE();
	setWidth(s.readUint16LE());
	setHeight(s.readUint16LE());

	_topNumber = s.readByte();
	_bottomNumber = s.readByte();
}

/*----------------------------------------------------------------*/

void WalkArray::load(Common::SeekableReadStream &s, bool isRoseTattoo) {
	_pointsCount = (int8)s.readByte();

	for (int idx = 0; idx < _pointsCount; ++idx) {
		int x = s.readSint16LE();
		int y = isRoseTattoo ? s.readSint16LE() : s.readByte();
		push_back(Common::Point(x, y));
	}
}

/*----------------------------------------------------------------*/

Scene *Scene::init(SherlockEngine *vm) {
	if (vm->getGameID() == GType_SerratedScalpel)
		return new Scalpel::ScalpelScene(vm);
	else
		return new Tattoo::TattooScene(vm);
}

Scene::Scene(SherlockEngine *vm): _vm(vm) {
	_sceneStats = new bool *[SCENES_COUNT];
	_sceneStats[0] = new bool[SCENES_COUNT * 65];
	Common::fill(&_sceneStats[0][0], &_sceneStats[0][SCENES_COUNT * 65], false);
	for (int idx = 1; idx < SCENES_COUNT; ++idx) {
		_sceneStats[idx] = _sceneStats[idx - 1] + 65;
	}
	_currentScene = -1;
	_goToScene = -1;
	_loadingSavedGame = false;
	_walkedInScene = false;
	_version = 0;
	_compressed = false;
	_invGraphicItems = 0;
	_cAnimFramePause = 0;
	_restoreFlag = false;
	_animating = 0;
	_doBgAnimDone = true;
	_tempFadeStyle = 0;
	_doBgAnimDone = false;
}

Scene::~Scene() {
	freeScene();
	delete[] _sceneStats[0];
	delete[] _sceneStats;
}

void Scene::selectScene() {
	Events &events = *_vm->_events;
	People &people = *_vm->_people;
	Screen &screen = *_vm->_screen;
	Talk &talk = *_vm->_talk;
	UserInterface &ui = *_vm->_ui;

	// Reset fields
	ui._windowOpen = ui._infoFlag = false;
	ui._menuMode = STD_MODE;

	// Free any previous scene
	freeScene();

	// Load the scene
	Common::String sceneFile = Common::String::format("res%02d", _goToScene);
	// _rrmName gets set during loadScene()
	// _rrmName is for ScalpelScene::startCAnim
	_currentScene = _goToScene;
	_goToScene = -1;

	loadScene(sceneFile);

	// If the fade style was changed from running a movie, then reset it
	if (_tempFadeStyle) {
		screen._fadeStyle = _tempFadeStyle;
		_tempFadeStyle = 0;
	}

	people[HOLMES]._walkDest = Common::Point(people[HOLMES]._position.x / FIXED_INT_MULTIPLIER,
		people[HOLMES]._position.y / FIXED_INT_MULTIPLIER);

	_restoreFlag = true;
	events.clearEvents();

	// If there were any scripts waiting to be run, but were interrupt by a running
	// canimation (probably the last scene's exit canim), clear the _scriptMoreFlag
	if (talk._scriptMoreFlag == 3)
		talk._scriptMoreFlag = 0;
}

void Scene::freeScene() {
	if (_currentScene == -1)
		return;

	_vm->_ui->clearWindow();
	_vm->_talk->freeTalkVars();
	_vm->_inventory->freeInv();
	_vm->_music->freeSong();
	_vm->_sound->freeLoadedSounds();

	if (!_loadingSavedGame)
		saveSceneStatus();
	else
		_loadingSavedGame = false;

	_sequenceBuffer.clear();
	_descText.clear();
	_walkPoints.clear();
	_cAnim.clear();
	_bgShapes.clear();
	_zones.clear();
	_canimShapes.clear();

	for (uint idx = 0; idx < _images.size(); ++idx)
		delete _images[idx]._images;
	_images.clear();

	_currentScene = -1;
}

bool Scene::loadScene(const Common::String &filename) {
	Events &events = *_vm->_events;
	Music &music = *_vm->_music;
	People &people = *_vm->_people;
	Resources &res = *_vm->_res;
	SaveManager &saves = *_vm->_saves;
	Screen &screen = *_vm->_screen;
	UserInterface &ui = *_vm->_ui;
	bool flag;

	_walkedInScene = false;

	// Reset the list of walkable areas
	_zones.clear();
	_zones.push_back(Common::Rect(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT));

	_descText.clear();
	_comments = "";
	_bgShapes.clear();
	_cAnim.clear();
	_sequenceBuffer.clear();

	//
	// Load the room resource file for the scene
	//

	if (!IS_3DO) {
		// PC version
		Common::String roomFilename = filename + ".rrm";
		_roomFilename = roomFilename;

		flag = _vm->_res->exists(roomFilename);
		if (flag) {
			Common::SeekableReadStream *rrmStream = _vm->_res->load(roomFilename);

			rrmStream->seek(39);
			if (IS_SERRATED_SCALPEL) {
				_version = rrmStream->readByte();
				_compressed = _version == 10;
			} else {
				_compressed = rrmStream->readByte() > 0;
			}

			// Go to header and read it in
			rrmStream->seek(rrmStream->readUint32LE());

			BgFileHeader bgHeader;
			bgHeader.load(*rrmStream, IS_ROSE_TATTOO);
			_invGraphicItems = bgHeader._numImages + 1;

			if (IS_ROSE_TATTOO) {
				// Resize the screen if necessary
				int fullWidth = SHERLOCK_SCREEN_WIDTH + bgHeader._scrollSize;
				if (screen._backBuffer1.w() != fullWidth) {
					screen._backBuffer1.create(fullWidth, SHERLOCK_SCREEN_HEIGHT);
					screen._backBuffer2.create(fullWidth, SHERLOCK_SCREEN_HEIGHT);
				}

				// Handle initializing the palette
				screen.initPaletteFade(bgHeader._bytesWritten);
				rrmStream->read(screen._cMap, PALETTE_SIZE);
				screen.translatePalette(screen._cMap);

				paletteLoaded();

				// Read in background
				if (_compressed) {
					res.decompress(*rrmStream, (byte *)screen._backBuffer1.getPixels(), fullWidth * SHERLOCK_SCREEN_HEIGHT);
				} else {
					rrmStream->read(screen._backBuffer1.getPixels(), fullWidth * SHERLOCK_SCREEN_HEIGHT);
				}
			} 

			// Read in the shapes header info
			Common::Array<BgFileHeaderInfo> bgInfo;
			bgInfo.resize(bgHeader._numStructs);

			for (uint idx = 0; idx < bgInfo.size(); ++idx)
				bgInfo[idx].load(*rrmStream);

			// Read information
			if (IS_ROSE_TATTOO) {
				// Load shapes
				Common::SeekableReadStream *infoStream = !_compressed ? rrmStream : res.decompress(*rrmStream, bgHeader._numStructs * 625);

				_bgShapes.resize(bgHeader._numStructs);
				for (int idx = 0; idx < bgHeader._numStructs; ++idx)
					_bgShapes[idx].load(*infoStream, true);

				if (_compressed)
					delete infoStream;

				// Load description text
				_descText.resize(bgHeader._descSize);
				if (_compressed)
					res.decompress(*rrmStream, (byte *)&_descText[0], bgHeader._descSize);
				else
					rrmStream->read(&_descText[0], bgHeader._descSize);

				// Load sequences
				_sequenceBuffer.resize(bgHeader._seqSize);
				if (_compressed)
					res.decompress(*rrmStream, &_sequenceBuffer[0], bgHeader._seqSize);
				else
					rrmStream->read(&_sequenceBuffer[0], bgHeader._seqSize);
			} else if (!_compressed) {
				// Serrated Scalpel uncompressed info
				_bgShapes.resize(bgHeader._numStructs);
				for (int idx = 0; idx < bgHeader._numStructs; ++idx)
					_bgShapes[idx].load(*rrmStream, false);

				if (bgHeader._descSize) {
					_descText.resize(bgHeader._descSize);
					rrmStream->read(&_descText[0], bgHeader._descSize);
				}

				if (bgHeader._seqSize) {
					_sequenceBuffer.resize(bgHeader._seqSize);
					rrmStream->read(&_sequenceBuffer[0], bgHeader._seqSize);
				}
			} else {
				// Serrated Scalpel compressed info
				Common::SeekableReadStream *infoStream;

				// Read shapes
				infoStream = Resources::decompressLZ(*rrmStream, bgHeader._numStructs * 569);

				_bgShapes.resize(bgHeader._numStructs);
				for (int idx = 0; idx < bgHeader._numStructs; ++idx)
					_bgShapes[idx].load(*infoStream, false);

				delete infoStream;

				// Read description texts
				if (bgHeader._descSize) {
					infoStream = Resources::decompressLZ(*rrmStream, bgHeader._descSize);

					_descText.resize(bgHeader._descSize);
					infoStream->read(&_descText[0], bgHeader._descSize);

					delete infoStream;
				}

				// Read sequences
				if (bgHeader._seqSize) {
					infoStream = Resources::decompressLZ(*rrmStream, bgHeader._seqSize);

					_sequenceBuffer.resize(bgHeader._seqSize);
					infoStream->read(&_sequenceBuffer[0], bgHeader._seqSize);

					delete infoStream;
				}
			}

			// Set up the list of images used by the scene
			_images.resize(bgHeader._numImages + 1);
			for (int idx = 0; idx < bgHeader._numImages; ++idx) {
				_images[idx + 1]._filesize = bgInfo[idx]._filesize;
				_images[idx + 1]._maxFrames = bgInfo[idx]._maxFrames;

				// Read in the image data
				Common::SeekableReadStream *imageStream = _compressed ?
					res.decompress(*rrmStream, bgInfo[idx]._filesize) :
					rrmStream->readStream(bgInfo[idx]._filesize);

				_images[idx + 1]._images = new ImageFile(*imageStream);

				delete imageStream;
			}

			// Set up the bgShapes
			for (int idx = 0; idx < bgHeader._numStructs; ++idx) {
				_bgShapes[idx]._images = _images[_bgShapes[idx]._misc]._images;
				_bgShapes[idx]._imageFrame = !_bgShapes[idx]._images ? (ImageFrame *)nullptr :
					&(*_bgShapes[idx]._images)[0];

				_bgShapes[idx]._examine = Common::String(&_descText[_bgShapes[idx]._descOffset]);
				_bgShapes[idx]._sequences = &_sequenceBuffer[_bgShapes[idx]._sequenceOffset];
				_bgShapes[idx]._misc = 0;
				_bgShapes[idx]._seqCounter = 0;
				_bgShapes[idx]._seqCounter2 = 0;
				_bgShapes[idx]._seqStack = 0;
				_bgShapes[idx]._frameNumber = -1;
				_bgShapes[idx]._oldPosition = Common::Point(0, 0);
				_bgShapes[idx]._oldSize = Common::Point(1, 1);
			}

			// Load in cAnim list
			_cAnim.clear();
			if (bgHeader._numcAnimations) {
				int animSize = IS_SERRATED_SCALPEL ? 65 : 47;
				Common::SeekableReadStream *cAnimStream = _compressed ?
					res.decompress(*rrmStream, animSize * bgHeader._numcAnimations) :
					rrmStream->readStream(animSize * bgHeader._numcAnimations);

				// Load cAnim offset table as well
				uint32 *cAnimOffsetTablePtr = new uint32[bgHeader._numcAnimations];
				uint32 *cAnimOffsetPtr = cAnimOffsetTablePtr;
				memset(cAnimOffsetTablePtr, 0, bgHeader._numcAnimations * sizeof(uint32));
 				if (IS_SERRATED_SCALPEL) {
					// Save current stream offset
					int32 curOffset = rrmStream->pos();
					rrmStream->seek(44); // Seek to cAnim-Offset-Table
					for (uint16 curCAnim = 0; curCAnim < bgHeader._numcAnimations; curCAnim++) {
						*cAnimOffsetPtr = rrmStream->readUint32LE();
						cAnimOffsetPtr++;
					}
					// Seek back to original stream offset
					rrmStream->seek(curOffset);
				}
				// TODO: load offset table for Rose Tattoo as well

				// Go to the start of the cAnimOffsetTable
				cAnimOffsetPtr = cAnimOffsetTablePtr;

				_cAnim.resize(bgHeader._numcAnimations);
				for (uint idx = 0; idx < _cAnim.size(); ++idx) {
					_cAnim[idx].load(*cAnimStream, IS_ROSE_TATTOO, *cAnimOffsetPtr);
					cAnimOffsetPtr++;
				}

				delete cAnimStream;
				delete[] cAnimOffsetTablePtr;
			}

			

			// Read in the room bounding areas
			int size = rrmStream->readUint16LE();
			Common::SeekableReadStream *boundsStream = !_compressed ? rrmStream :
				res.decompress(*rrmStream, size);

			_zones.resize(size / 10);
			for (uint idx = 0; idx < _zones.size(); ++idx) {
				_zones[idx].left = boundsStream->readSint16LE();
				_zones[idx].top = boundsStream->readSint16LE();
				_zones[idx].setWidth(boundsStream->readSint16LE() + 1);
				_zones[idx].setHeight(boundsStream->readSint16LE() + 1);
				boundsStream->skip(2);	// Skip unused scene number field
			}

			if (_compressed)
				delete boundsStream;

			// Ensure we've reached the path version byte
			if (rrmStream->readByte() != (IS_SERRATED_SCALPEL ? 254 : 251))
				error("Invalid scene path data");

			// Load the walk directory and walk data
			assert(_zones.size() < MAX_ZONES);


			for (uint idx1 = 0; idx1 < _zones.size(); ++idx1) {
				Common::fill(&_walkDirectory[idx1][0], &_walkDirectory[idx1][MAX_ZONES], 0);
				for (uint idx2 = 0; idx2 < _zones.size(); ++idx2)
					_walkDirectory[idx1][idx2] = rrmStream->readSint16LE();
			}

			// Read in the walk data
			size = rrmStream->readUint16LE();
			Common::SeekableReadStream *walkStream = !_compressed ? rrmStream :
				res.decompress(*rrmStream, size);

			int startPos = walkStream->pos();
			while ((walkStream->pos() - startPos) < size) {
				_walkPoints.push_back(WalkArray());
				_walkPoints[_walkPoints.size() - 1]._fileOffset = walkStream->pos() - startPos;
				_walkPoints[_walkPoints.size() - 1].load(*walkStream, IS_ROSE_TATTOO);
			}

			if (_compressed)
				delete walkStream;

			// Translate the file offsets of the walk directory to indexes in the loaded walk data
			for (uint idx1 = 0; idx1 < _zones.size(); ++idx1) {
				for (uint idx2 = 0; idx2 < _zones.size(); ++idx2) {
					int fileOffset = _walkDirectory[idx1][idx2];
					if (fileOffset == -1)
						continue;

					uint dataIndex = 0;
					while (dataIndex < _walkPoints.size() && _walkPoints[dataIndex]._fileOffset != fileOffset)
						++dataIndex;
					assert(dataIndex < _walkPoints.size());
					_walkDirectory[idx1][idx2] = dataIndex;
				}
			}

			if (IS_ROSE_TATTOO) {
				// Read in the entrance
				_entrance.load(*rrmStream);

				// Load scale zones
				_scaleZones.resize(rrmStream->readByte());
				for (uint idx = 0; idx < _scaleZones.size(); ++idx)
					_scaleZones[idx].load(*rrmStream);
			}

			// Read in the exits
			int numExits = rrmStream->readByte();
			_exits.resize(numExits);

			for (int idx = 0; idx < numExits; ++idx)
				_exits[idx].load(*rrmStream, IS_ROSE_TATTOO);

			if (IS_SERRATED_SCALPEL)
				// Read in the entrance
				_entrance.load(*rrmStream);

			// Initialize sound list
			int numSounds = rrmStream->readByte();
			_sounds.resize(numSounds);

			for (int idx = 0; idx < numSounds; ++idx)
				_sounds[idx].load(*rrmStream);

			loadSceneSounds();

			if (IS_ROSE_TATTOO) {
				// Load the object sound list
				char buffer[27];
			
				_objSoundList.resize(rrmStream->readUint16LE());
				for (uint idx = 0; idx < _objSoundList.size(); ++idx) {
					rrmStream->read(buffer, 27);
					_objSoundList[idx] = Common::String(buffer);
				}
			} else {
				// Read in palette
				rrmStream->read(screen._cMap, PALETTE_SIZE);
				screen.translatePalette(screen._cMap);
				Common::copy(screen._cMap, screen._cMap + PALETTE_SIZE, screen._sMap);

				// Read in the background
				Common::SeekableReadStream *bgStream = !_compressed ? rrmStream :
					res.decompress(*rrmStream, SHERLOCK_SCREEN_WIDTH * SHERLOCK_SCENE_HEIGHT);

				bgStream->read(screen._backBuffer1.getPixels(), SHERLOCK_SCREEN_WIDTH * SHERLOCK_SCENE_HEIGHT);

				if (_compressed)
					delete bgStream;
			}

			// Backup the image and set the palette
			screen._backBuffer2.blitFrom(screen._backBuffer1);
			screen.setPalette(screen._cMap);

			delete rrmStream;
		}

	} else {
		// === 3DO version ===
		_roomFilename = "rooms/" + filename + ".rrm";
		flag = _vm->_res->exists(_roomFilename);
		if (!flag)
			error("loadScene: 3DO room data file not found");

		Common::SeekableReadStream *roomStream = _vm->_res->load(_roomFilename);
		uint32 roomStreamSize = roomStream->size();

		// there should be at least all bytes of the header data
		if (roomStreamSize < 128)
			error("loadScene: 3DO room data file is too small");

		// Read 3DO header
		roomStream->skip(4); // UINT32: offset graphic data?
		uint16 header3DO_numStructs = roomStream->readUint16BE();
		uint16 header3DO_numImages = roomStream->readUint16BE();
		uint16 header3DO_numAnimations = roomStream->readUint16BE();
		roomStream->skip(6);

		uint32 header3DO_bgInfo_offset        = roomStream->readUint32BE() + 0x80;
		uint32 header3DO_bgInfo_size          = roomStream->readUint32BE();
		uint32 header3DO_bgShapes_offset      = roomStream->readUint32BE() + 0x80;
		uint32 header3DO_bgShapes_size        = roomStream->readUint32BE();
		uint32 header3DO_descriptions_offset  = roomStream->readUint32BE() + 0x80;
		uint32 header3DO_descriptions_size    = roomStream->readUint32BE();
		uint32 header3DO_sequence_offset      = roomStream->readUint32BE() + 0x80;
		uint32 header3DO_sequence_size        = roomStream->readUint32BE();
		uint32 header3DO_cAnim_offset         = roomStream->readUint32BE() + 0x80;
		uint32 header3DO_cAnim_size           = roomStream->readUint32BE();
		uint32 header3DO_roomBounding_offset  = roomStream->readUint32BE() + 0x80;
		uint32 header3DO_roomBounding_size    = roomStream->readUint32BE();
		uint32 header3DO_walkDirectory_offset = roomStream->readUint32BE() + 0x80;
		uint32 header3DO_walkDirectory_size   = roomStream->readUint32BE();
		uint32 header3DO_walkData_offset      = roomStream->readUint32BE() + 0x80;
		uint32 header3DO_walkData_size        = roomStream->readUint32BE();
		uint32 header3DO_exits_offset         = roomStream->readUint32BE() + 0x80;
		uint32 header3DO_exits_size           = roomStream->readUint32BE();
		uint32 header3DO_entranceData_offset  = roomStream->readUint32BE() + 0x80;
		uint32 header3DO_entranceData_size    = roomStream->readUint32BE();
		uint32 header3DO_soundList_offset     = roomStream->readUint32BE() + 0x80;
		uint32 header3DO_soundList_size       = roomStream->readUint32BE();
		//uint32 header3DO_unknown_offset       = roomStream->readUint32BE() + 0x80;
		//uint32 header3DO_unknown_size         = roomStream->readUint32BE();
		roomStream->skip(8); // Skip over unknown offset+size
		uint32 header3DO_bgGraphicData_offset = roomStream->readUint32BE() + 0x80;
		uint32 header3DO_bgGraphicData_size   = roomStream->readUint32BE();

		// Calculate amount of entries
		int32 header3DO_soundList_count       = header3DO_soundList_size / 9;

		_invGraphicItems = header3DO_numImages + 1;

		// Verify all offsets
		if (header3DO_bgInfo_offset >= roomStreamSize)
			error("loadScene: 3DO bgInfo offset points outside of room file");
		if (header3DO_bgInfo_size > (roomStreamSize - header3DO_bgInfo_offset))
			error("loadScene: 3DO bgInfo size goes beyond room file");
		if (header3DO_bgShapes_offset >= roomStreamSize)
			error("loadScene: 3DO bgShapes offset points outside of room file");
		if (header3DO_bgShapes_size > (roomStreamSize - header3DO_bgShapes_offset))
			error("loadScene: 3DO bgShapes size goes beyond room file");
		if (header3DO_descriptions_offset >= roomStreamSize)
			error("loadScene: 3DO descriptions offset points outside of room file");
		if (header3DO_descriptions_size > (roomStreamSize - header3DO_descriptions_offset))
			error("loadScene: 3DO descriptions size goes beyond room file");
		if (header3DO_sequence_offset >= roomStreamSize)
			error("loadScene: 3DO sequence offset points outside of room file");
		if (header3DO_sequence_size > (roomStreamSize - header3DO_sequence_offset))
			error("loadScene: 3DO sequence size goes beyond room file");
		if (header3DO_cAnim_offset >= roomStreamSize)
			error("loadScene: 3DO cAnim offset points outside of room file");
		if (header3DO_cAnim_size > (roomStreamSize - header3DO_cAnim_offset))
			error("loadScene: 3DO cAnim size goes beyond room file");
		if (header3DO_roomBounding_offset >= roomStreamSize)
			error("loadScene: 3DO roomBounding offset points outside of room file");
		if (header3DO_roomBounding_size > (roomStreamSize - header3DO_roomBounding_offset))
			error("loadScene: 3DO roomBounding size goes beyond room file");
		if (header3DO_walkDirectory_offset >= roomStreamSize)
			error("loadScene: 3DO walkDirectory offset points outside of room file");
		if (header3DO_walkDirectory_size > (roomStreamSize - header3DO_walkDirectory_offset))
			error("loadScene: 3DO walkDirectory size goes beyond room file");
		if (header3DO_walkData_offset >= roomStreamSize)
			error("loadScene: 3DO walkData offset points outside of room file");
		if (header3DO_walkData_size > (roomStreamSize - header3DO_walkData_offset))
			error("loadScene: 3DO walkData size goes beyond room file");
		if (header3DO_exits_offset >= roomStreamSize)
			error("loadScene: 3DO exits offset points outside of room file");
		if (header3DO_exits_size > (roomStreamSize - header3DO_exits_offset))
			error("loadScene: 3DO exits size goes beyond room file");
		if (header3DO_entranceData_offset >= roomStreamSize)
			error("loadScene: 3DO entranceData offset points outside of room file");
		if (header3DO_entranceData_size > (roomStreamSize - header3DO_entranceData_offset))
			error("loadScene: 3DO entranceData size goes beyond room file");
		if (header3DO_soundList_offset >= roomStreamSize)
			error("loadScene: 3DO soundList offset points outside of room file");
		if (header3DO_soundList_size > (roomStreamSize - header3DO_soundList_offset))
			error("loadScene: 3DO soundList size goes beyond room file");
		if (header3DO_bgGraphicData_offset >= roomStreamSize)
			error("loadScene: 3DO bgGraphicData offset points outside of room file");
		if (header3DO_bgGraphicData_size > (roomStreamSize - header3DO_bgGraphicData_offset))
			error("loadScene: 3DO bgGraphicData size goes beyond room file");

		// === BGINFO === read in the shapes header info
		Common::Array<BgFileHeaderInfo> bgInfo;

		uint32 expected3DO_bgInfo_size = header3DO_numStructs * 16;
		if (expected3DO_bgInfo_size != header3DO_bgInfo_size) // Security check
			error("loadScene: 3DO bgInfo size mismatch");

		roomStream->seek(header3DO_bgInfo_offset);
		bgInfo.resize(header3DO_numStructs);
		for (uint idx = 0; idx < bgInfo.size(); ++idx)
			bgInfo[idx].load3DO(*roomStream);

		// === BGSHAPES === read in the shapes info
		uint32 expected3DO_bgShapes_size = header3DO_numStructs * 588;
		if (expected3DO_bgShapes_size != header3DO_bgShapes_size) // Security check
			error("loadScene: 3DO bgShapes size mismatch");

		roomStream->seek(header3DO_bgShapes_offset);
		_bgShapes.resize(header3DO_numStructs);
		for (int idx = 0; idx < header3DO_numStructs; ++idx)
			_bgShapes[idx].load3DO(*roomStream);

		// === DESCRIPTION === read description text
		if (header3DO_descriptions_size) {
			roomStream->seek(header3DO_descriptions_offset);
			_descText.resize(header3DO_descriptions_size);
			roomStream->read(&_descText[0], header3DO_descriptions_size);
		}

		// === SEQUENCE === read sequence buffer
		if (header3DO_sequence_size) {
			roomStream->seek(header3DO_sequence_offset);
			_sequenceBuffer.resize(header3DO_sequence_size);
			roomStream->read(&_sequenceBuffer[0], header3DO_sequence_size);
		}

		// === IMAGES === set up the list of images used by the scene
		roomStream->seek(header3DO_bgGraphicData_offset);
		_images.resize(header3DO_numImages + 1);
		for (int idx = 0; idx < header3DO_numImages; ++idx) {
			_images[idx + 1]._filesize = bgInfo[idx]._filesize;
			_images[idx + 1]._maxFrames = bgInfo[idx]._maxFrames;

			// Read image data into memory
			Common::SeekableReadStream *imageStream = roomStream->readStream(bgInfo[idx]._filesize);

			// Load image data into an ImageFile array as room file data
			// which is basically a fixed header, followed by a raw cel header, followed by regular cel data
			_images[idx + 1]._images = new ImageFile3DO(*imageStream, true);

			delete imageStream;
		}

		// === BGSHAPES === Set up the bgShapes
		for (int idx = 0; idx < header3DO_numStructs; ++idx) {
			_bgShapes[idx]._images = _images[_bgShapes[idx]._misc]._images;
			_bgShapes[idx]._imageFrame = !_bgShapes[idx]._images ? (ImageFrame *)nullptr :
				&(*_bgShapes[idx]._images)[0];

			_bgShapes[idx]._examine = Common::String(&_descText[_bgShapes[idx]._descOffset]);
			_bgShapes[idx]._sequences = &_sequenceBuffer[_bgShapes[idx]._sequenceOffset];
			_bgShapes[idx]._misc = 0;
			_bgShapes[idx]._seqCounter = 0;
			_bgShapes[idx]._seqCounter2 = 0;
			_bgShapes[idx]._seqStack = 0;
			_bgShapes[idx]._frameNumber = -1;
			_bgShapes[idx]._oldPosition = Common::Point(0, 0);
			_bgShapes[idx]._oldSize = Common::Point(1, 1);
		}

		// === CANIM === read cAnim list
		_cAnim.clear();
		if (header3DO_numAnimations) {
			roomStream->seek(header3DO_cAnim_offset);
			Common::SeekableReadStream *cAnimStream = roomStream->readStream(header3DO_cAnim_size);

			uint32 *cAnimOffsetTablePtr = new uint32[header3DO_numAnimations];
			uint32 *cAnimOffsetPtr = cAnimOffsetTablePtr;
			uint32 cAnimOffset = 0;
			memset(cAnimOffsetTablePtr, 0, header3DO_numAnimations * sizeof(uint32));

			// Seek to end of graphics data and load cAnim offset table from there
			roomStream->seek(header3DO_bgGraphicData_offset + header3DO_bgGraphicData_size);
			for (uint16 curCAnim = 0; curCAnim < header3DO_numAnimations; curCAnim++) {
				cAnimOffset = roomStream->readUint32BE();
				if (cAnimOffset >= roomStreamSize)
					error("loadScene: 3DO cAnim entry offset points outside of room file");

				*cAnimOffsetPtr = cAnimOffset;
				cAnimOffsetPtr++;
			}

			// Go to the start of the cAnimOffsetTable
			cAnimOffsetPtr = cAnimOffsetTablePtr;

			_cAnim.resize(header3DO_numAnimations);
			for (uint idx = 0; idx < _cAnim.size(); ++idx) {
				_cAnim[idx].load3DO(*cAnimStream, *cAnimOffsetPtr);
				cAnimOffsetPtr++;
			}

			delete cAnimStream;
			delete[] cAnimOffsetTablePtr;
		}

		// === BOUNDING AREAS === Read in the room bounding areas
		int roomBoundingCount = header3DO_roomBounding_size / 12;
		uint32 expected3DO_roomBounding_size = roomBoundingCount * 12;
		if (expected3DO_roomBounding_size != header3DO_roomBounding_size)
			error("loadScene: 3DO roomBounding size mismatch");

		roomStream->seek(header3DO_roomBounding_offset);
		_zones.resize(roomBoundingCount);
		for (uint idx = 0; idx < _zones.size(); ++idx) {
			_zones[idx].left = roomStream->readSint16BE();
			_zones[idx].top = roomStream->readSint16BE();
			_zones[idx].setWidth(roomStream->readSint16BE() + 1);
			_zones[idx].setHeight(roomStream->readSint16BE() + 1);
			roomStream->skip(4); // skip UINT32
		}

		// === WALK DIRECTORY === Load the walk directory
		uint32 expected3DO_walkDirectory_size = _zones.size() * _zones.size() * 2;
		if (expected3DO_walkDirectory_size != header3DO_walkDirectory_size)
			error("loadScene: 3DO walkDirectory size mismatch");

		roomStream->seek(header3DO_walkDirectory_offset);
		assert(_zones.size() < MAX_ZONES);
		for (uint idx1 = 0; idx1 < _zones.size(); ++idx1) {
			for (uint idx2 = 0; idx2 < _zones.size(); ++idx2)
				_walkDirectory[idx1][idx2] = roomStream->readSint16BE();
		}

		// === WALK DATA === Read in the walk data
		roomStream->seek(header3DO_walkData_offset);

		int startPos = roomStream->pos();
		while ((roomStream->pos() - startPos) < (int)header3DO_walkData_size) {
			_walkPoints.push_back(WalkArray());
			_walkPoints[_walkPoints.size() - 1]._fileOffset = roomStream->pos() - startPos;
			_walkPoints[_walkPoints.size() - 1].load(*roomStream, false);
		}

		// Translate the file offsets of the walk directory to indexes in the loaded walk data
		for (uint idx1 = 0; idx1 < _zones.size(); ++idx1) {
			for (uint idx2 = 0; idx2 < _zones.size(); ++idx2) {
				int fileOffset = _walkDirectory[idx1][idx2];
				if (fileOffset == -1)
					continue;

				uint dataIndex = 0;
				while (dataIndex < _walkPoints.size() && _walkPoints[dataIndex]._fileOffset != fileOffset)
					++dataIndex;
				assert(dataIndex < _walkPoints.size());
				_walkDirectory[idx1][idx2] = dataIndex;
			}
		}

		// === EXITS === Read in the exits
		roomStream->seek(header3DO_exits_offset);

		int exitsCount = header3DO_exits_size / 20;

		_exits.resize(exitsCount);
		for (int idx = 0; idx < exitsCount; ++idx)
			_exits[idx].load3DO(*roomStream);

		// === ENTRANCE === Read in the entrance
		if (header3DO_entranceData_size != 8)
			error("loadScene: 3DO entranceData size mismatch");

		roomStream->seek(header3DO_entranceData_offset);
		_entrance.load3DO(*roomStream);

		// === SOUND LIST === Initialize sound list
		roomStream->seek(header3DO_soundList_offset);
		_sounds.resize(header3DO_soundList_count);
		for (int idx = 0; idx < header3DO_soundList_count; ++idx)
			_sounds[idx].load3DO(*roomStream);

		delete roomStream;

		// === BACKGROUND PICTURE ===
		// load from file rooms\[filename].bg
		// it's uncompressed 15-bit RGB555 data

		Common::String roomBackgroundFilename = "rooms/" + filename + ".bg";
		flag = _vm->_res->exists(roomBackgroundFilename);
		if (!flag)
			error("loadScene: 3DO room background file not found (%s)", roomBackgroundFilename.c_str());

		Common::File roomBackgroundStream;
		if (!roomBackgroundStream.open(roomBackgroundFilename))
			error("Could not open file - %s", roomBackgroundFilename.c_str());

		int totalPixelCount = SHERLOCK_SCREEN_WIDTH * SHERLOCK_SCENE_HEIGHT;
		uint16 *roomBackgroundDataPtr = NULL;
		uint16 *pixelSourcePtr = NULL;
		uint16 *pixelDestPtr = (uint16 *)screen._backBuffer1.getPixels();
		uint16  curPixel = 0;
		uint32  roomBackgroundStreamSize = roomBackgroundStream.size();
		uint32  expectedBackgroundSize   = totalPixelCount * 2;

		// Verify file size of background file
		if (expectedBackgroundSize != roomBackgroundStreamSize)
			error("loadScene: 3DO room background file not expected size");

		roomBackgroundDataPtr = new uint16[totalPixelCount];
		roomBackgroundStream.read(roomBackgroundDataPtr, roomBackgroundStreamSize);
		roomBackgroundStream.close();

		// Convert data from RGB555 to RGB565
		pixelSourcePtr = roomBackgroundDataPtr;
		for (int pixels = 0; pixels < totalPixelCount; pixels++) {
			curPixel = READ_BE_UINT16(pixelSourcePtr++);

			byte curPixelRed   = (curPixel >> 10) & 0x1F;
			byte curPixelGreen = (curPixel >> 5) & 0x1F;
			byte curPixelBlue  = curPixel & 0x1F;
			*pixelDestPtr = ((curPixelRed << 11) | (curPixelGreen << 6) | (curPixelBlue));
			pixelDestPtr++;
		}

		delete[] roomBackgroundDataPtr;

#if 0
		// code to show the background
		screen.blitFrom(screen._backBuffer1);
		_vm->_events->wait(10000);
#endif

		// Backup the image
		screen._backBuffer2.blitFrom(screen._backBuffer1);
	}

	// Handle drawing any on-screen interface
	ui.drawInterface();

	checkSceneStatus();

	if (!saves._justLoaded) {
		for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
			if (_bgShapes[idx]._type == HIDDEN && _bgShapes[idx]._aType == TALK_EVERY)
				_bgShapes[idx].toggleHidden();
		}

		// Check for TURNON objects
		for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
			if (_bgShapes[idx]._type == HIDDEN && (_bgShapes[idx]._flags & TURNON_OBJ))
				_bgShapes[idx].toggleHidden();
		}

		// Check for TURNOFF objects
		for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
			if (_bgShapes[idx]._type != HIDDEN && (_bgShapes[idx]._flags & TURNOFF_OBJ) &&
					_bgShapes[idx]._type != INVALID)
				_bgShapes[idx].toggleHidden();
			if (_bgShapes[idx]._type == HIDE_SHAPE)
				// Hiding isn't needed, since objects aren't drawn yet
				_bgShapes[idx]._type = HIDDEN;
		}
	}

	checkSceneFlags(false);
	checkInventory();

	// Handle starting any music for the scene
	if (IS_SERRATED_SCALPEL && music._musicOn && music.loadSong(_currentScene))
		music.startSong();

	// Load walking images if not already loaded
	people.loadWalk();

	// Transition to the scene and setup entrance co-ordinates and animations
	transitionToScene();

	// Player has not yet walked in this scene
	_walkedInScene = false;
	saves._justLoaded = false;

	events.clearEvents();
	return flag;
}

void Scene::loadSceneSounds() {
	Sound &sound = *_vm->_sound;

	for (uint idx = 0; idx < _sounds.size(); ++idx)
		sound.loadSound(_sounds[idx]._name, _sounds[idx]._priority);
}

void Scene::checkSceneStatus() {
	if (_sceneStats[_currentScene][64]) {
		for (uint idx = 0; idx < 64; ++idx) {
			bool flag = _sceneStats[_currentScene][idx];

			if (idx < _bgShapes.size()) {
				Object &obj = _bgShapes[idx];

				if (flag) {
					// No shape to erase, so flag as hidden
					obj._type = HIDDEN;
				} else if (obj._images == nullptr || obj._images->size() == 0) {
					// No shape
					obj._type = NO_SHAPE;
				} else {
					obj._type = ACTIVE_BG_SHAPE;
				}
			} else {
				// Finished checks
				return;
			}
		}
	}
}

void Scene::saveSceneStatus() {
	// Flag any objects for the scene that have been altered
	int count = MIN((int)_bgShapes.size(), 64);
	for (int idx = 0; idx < count; ++idx) {
		Object &obj = _bgShapes[idx];
		_sceneStats[_currentScene][idx] = obj._type == HIDDEN || obj._type == REMOVE
			|| obj._type == HIDE_SHAPE || obj._type == INVALID;
	}

	// Flag scene as having been visited
	_sceneStats[_currentScene][64] = true;
}

void Scene::checkSceneFlags(bool flag) {
	SpriteType mode = flag ? HIDE_SHAPE : HIDDEN;

	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
		Object &o = _bgShapes[idx];
		bool objectFlag = true;

		if (o._requiredFlag[0] || o._requiredFlag[1]) {
			if (o._requiredFlag[0] != 0)
				objectFlag = _vm->readFlags(o._requiredFlag[0]);
			if (o._requiredFlag[1] != 0)
				objectFlag &= _vm->readFlags(o._requiredFlag[1]);

			if (!objectFlag) {
				// Kill object
				if (o._type != HIDDEN && o._type != INVALID) {
					if (o._images == nullptr || o._images->size() == 0)
						// No shape to erase, so flag as hidden
						o._type = HIDDEN;
					else
						// Flag it as needing to be hidden after first erasing it
						o._type = mode;
				}
			} else if (IS_ROSE_TATTOO || o._requiredFlag[0] > 0) {
				// Restore object
				if (o._images == nullptr || o._images->size() == 0)
					o._type = NO_SHAPE;
				else
					o._type = ACTIVE_BG_SHAPE;
			}
		}
	}

	// Check inventory for items to remove based on flag changes
	for (int idx = 0; idx < _vm->_inventory->_holdings; ++idx) {
		InventoryItem &ii = (*_vm->_inventory)[idx];
		if (ii._requiredFlag && !_vm->readFlags(ii._requiredFlag)) {
			// Kill object: move it after the active holdings
			InventoryItem tempItem = (*_vm->_inventory)[idx];
			_vm->_inventory->insert_at(_vm->_inventory->_holdings, tempItem);
			_vm->_inventory->remove_at(idx);
			_vm->_inventory->_holdings--;
		}
	}

	// Check inactive inventory items for ones to reactivate based on flag changes
	for (uint idx = _vm->_inventory->_holdings; idx < _vm->_inventory->size(); ++idx) {
		InventoryItem &ii = (*_vm->_inventory)[idx];
		if (ii._requiredFlag && _vm->readFlags(ii._requiredFlag)) {
			// Restore object: move it after the active holdings
			InventoryItem tempItem = (*_vm->_inventory)[idx];
			_vm->_inventory->remove_at(idx);
			_vm->_inventory->insert_at(_vm->_inventory->_holdings, tempItem);
			_vm->_inventory->_holdings++;
		}
	}
}

void Scene::checkInventory() {
	for (uint shapeIdx = 0; shapeIdx < _bgShapes.size(); ++shapeIdx) {
		for (int invIdx = 0; invIdx < _vm->_inventory->_holdings; ++invIdx) {
			if (_bgShapes[shapeIdx]._name.equalsIgnoreCase((*_vm->_inventory)[invIdx]._name)) {
				_bgShapes[shapeIdx]._type = INVALID;
				break;
			}
		}
	}
}

void Scene::transitionToScene() {
	People &people = *_vm->_people;
	SaveManager &saves = *_vm->_saves;
	Screen &screen = *_vm->_screen;
	Talk &talk = *_vm->_talk;
	Point32 &hSavedPos = people._savedPos;
	int &hSavedFacing = people._savedPos._facing;

	if (hSavedPos.x < 1) {
		// No exit information from last scene-check entrance info
		if (_entrance._startPosition.x < 1) {
			// No entrance info either, so use defaults
			if (IS_SERRATED_SCALPEL) {
				hSavedPos = Point32(160 * FIXED_INT_MULTIPLIER, 100 * FIXED_INT_MULTIPLIER);
				hSavedFacing = 4;
			} else {
				hSavedPos = people[HOLMES]._position;
				hSavedFacing = people[HOLMES]._sequenceNumber;
			}
		} else {
			// setup entrance info
			hSavedPos.x = _entrance._startPosition.x * FIXED_INT_MULTIPLIER;
			hSavedPos.y = _entrance._startPosition.y * FIXED_INT_MULTIPLIER;
			if (IS_SERRATED_SCALPEL) {
				hSavedPos.x /= 100;
				hSavedPos.y /= 100;
			}

			hSavedFacing = _entrance._startDir;
		}
	} else {
		// Exit information exists, translate it to real sequence info
		// Note: If a savegame was just loaded, then the data is already correct.
		// Otherwise, this is a linked scene or entrance info, and must be translated
		if (hSavedFacing < 8 && !saves._justLoaded) {
			hSavedFacing = FS_TRANS[hSavedFacing];
			hSavedPos.x *= FIXED_INT_MULTIPLIER;
			hSavedPos.y *= FIXED_INT_MULTIPLIER;
		}
	}

	int cAnimNum = -1;

	if (hSavedFacing < 101) {
		// Standard info, so set it
		people[HOLMES]._position = hSavedPos;
		people[HOLMES]._sequenceNumber = hSavedFacing;
	} else {
		// It's canimation information
		cAnimNum = hSavedFacing - 101;
	}

	// Reset positioning for next load
	hSavedPos = Common::Point(-1, -1);
	hSavedFacing = -1;

	if (cAnimNum != -1) {
		// Prevent Holmes from being drawn
		people[HOLMES]._position = Common::Point(0, 0);
	}

	for (uint objIdx = 0; objIdx < _bgShapes.size(); ++objIdx) {
		Object &obj = _bgShapes[objIdx];

		if (obj._aType > 1 && obj._type != INVALID && obj._type != HIDDEN) {
			Common::Point topLeft = obj._position;
			Common::Point bottomRight;

			if (obj._type != NO_SHAPE) {
				topLeft += obj._imageFrame->_offset;
				bottomRight.x = topLeft.x + obj._imageFrame->_frame.w;
				bottomRight.y = topLeft.y + obj._imageFrame->_frame.h;
			} else {
				bottomRight = topLeft + obj._noShapeSize;
			}

			if (Common::Rect(topLeft.x, topLeft.y, bottomRight.x, bottomRight.y).contains(
					Common::Point(people[HOLMES]._position.x / FIXED_INT_MULTIPLIER, 
					people[HOLMES]._position.y / FIXED_INT_MULTIPLIER))) {
				// Current point is already inside box - impact occurred on
				// a previous call. So simply do nothing except talk until the
				// player is clear of the box
				switch (obj._aType) {
				case FLAG_SET:
					for (int useNum = 0; useNum < USE_COUNT; ++useNum) {
						if (obj._use[useNum]._useFlag) {
							if (!_vm->readFlags(obj._use[useNum]._useFlag))
								_vm->setFlags(obj._use[useNum]._useFlag);
						}

						if (!talk._talkToAbort) {
							for (int nameIdx = 0; nameIdx < NAMES_COUNT; ++nameIdx) {
								toggleObject(obj._use[useNum]._names[nameIdx]);
							}
						}
					}

					obj._type = HIDDEN;
					break;

				default:
					break;
				}
			}
		}
	}

	updateBackground();

	// Actually do the transition
	if (screen._fadeStyle) {
		if (!IS_3DO) {
			// do pixel-transition for PC
			screen.randomTransition();
		} else {
			// fade in for 3DO
			screen.clear();
			screen.fadeIntoScreen3DO(3);
		}
	} else {
		screen.blitFrom(screen._backBuffer1);
	}
	screen.update();

	// Start any initial animation for the scene
	if (cAnimNum != -1) {
		CAnim &c = _cAnim[cAnimNum];
		PositionFacing pt = c._goto[0];

		c._goto[0].x = c._goto[0].y = -1;
		people[HOLMES]._position = Common::Point(0, 0);

		startCAnim(cAnimNum, 1);
		c._goto[0] = pt;
	}
}

int Scene::toggleObject(const Common::String &name) {
	int count = 0;

	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
		if (name.equalsIgnoreCase(_bgShapes[idx]._name)) {
			++count;
			_bgShapes[idx].toggleHidden();
		}
	}

	return count;
}

void Scene::updateBackground() {
	People &people = *_vm->_people;

	// Update Holmes if he's turned on
	for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
		if (people[idx]._type == CHARACTER)
			people[idx].adjustSprite();
	}

	// Flag the bg shapes which need to be redrawn
	checkBgShapes();

	// Draw the shapes for the scene
	drawAllShapes();
}

Exit *Scene::checkForExit(const Common::Rect &r) {
	for (uint idx = 0; idx < _exits.size(); ++idx) {
		if (_exits[idx].intersects(r))
			return &_exits[idx];
	}

	return nullptr;
}

int Scene::findBgShape(const Common::Point &pt) {
	if (!_doBgAnimDone)
		// New frame hasn't been drawn yet
		return -1;

	for (int idx = (int)_bgShapes.size() - 1; idx >= 0; --idx) {
		Object &o = _bgShapes[idx];
		if (o._type != INVALID && o._type != NO_SHAPE && o._type != HIDDEN
			&& o._aType <= PERSON) {
			if (o.getNewBounds().contains(pt))
				return idx;
		} else if (o._type == NO_SHAPE) {
			if (o.getNoShapeBounds().contains(pt))
				return idx;
		}
	}

	return -1;
}

int Scene::checkForZones(const Common::Point &pt, int zoneType) {
	int matches = 0;

	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
		Object &o = _bgShapes[idx];
		if ((o._aType == zoneType && o._type != INVALID) && o._type != HIDDEN) {
			Common::Rect r = o._type == NO_SHAPE ? o.getNoShapeBounds() : o.getNewBounds();

			if (r.contains(pt)) {
				++matches;
				o.setFlagsAndToggles();
				_vm->_talk->talkTo(o._use[0]._target);
			}
		}
	}

	return matches;
}

int Scene::whichZone(const Common::Point &pt) {
	for (uint idx = 0; idx < _zones.size(); ++idx) {
		if (_zones[idx].contains(pt))
			return idx;
	}

	return -1;
}

void Scene::synchronize(Serializer &s) {
	if (s.isSaving())
		saveSceneStatus();

	if (s.isSaving()) {
		s.syncAsSint16LE(_currentScene);
	} else {
		s.syncAsSint16LE(_goToScene);
		_loadingSavedGame = true;
	}

	for (int sceneNum = 0; sceneNum < SCENES_COUNT; ++sceneNum) {
		for (int flag = 0; flag < 65; ++flag) {
			s.syncAsByte(_sceneStats[sceneNum][flag]);
		}
	}
}

void Scene::checkBgShapes() {
	People &people = *_vm->_people;
	Person &holmes = people[HOLMES];
	Common::Point pt(holmes._position.x / FIXED_INT_MULTIPLIER, holmes._position.y / FIXED_INT_MULTIPLIER);

	// Iterate through the shapes
	for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
		Object &obj = _bgShapes[idx];
		if (obj._type == ACTIVE_BG_SHAPE || (IS_SERRATED_SCALPEL && obj._type == STATIC_BG_SHAPE)) {
			if ((obj._flags & 5) == 1) {
				obj._misc = (pt.y < (obj._position.y + obj.frameHeight() - 1)) ?
					NORMAL_FORWARD : NORMAL_BEHIND;
			} else if (!(obj._flags & OBJ_BEHIND)) {
				obj._misc = BEHIND;
			} else if (obj._flags & OBJ_FORWARD) {
				obj._misc = FORWARD;
			}
		}
	}
}

} // End of namespace Sherlock