Merging in changes from trunk

svn-id: r41989

1 files changed, 187 insertions, 209 deletions

diff --git a/engines/gob/scenery.cpp b/engines/gob/scenery.cpp
index 71750509b4..7a4b8ad868 100644
--- a/engines/gob/scenery.cpp
+++ b/engines/gob/scenery.cpp
@@ -31,6 +31,8 @@
 #include "gob/global.h"
 #include "gob/draw.h"
 #include "gob/game.h"
+#include "gob/script.h"
+#include "gob/resources.h"
 #include "gob/inter.h"
 #include "gob/map.h"
 #include "gob/videoplayer.h"
@@ -39,33 +41,33 @@ namespace Gob {
 
 Scenery::Scenery(GobEngine *vm) : _vm(vm) {
 	for (int i = 0; i < 20; i++) {
-		_spriteRefs[i] = 0;
+		_spriteRefs[i]  = 0;
 		_spriteResId[i] = 0;
 	}
 
 	for (int i = 0; i < 10; i++) {
 		_staticPictCount[i] = 0;
-		_staticResId[i] = 0;
-		_animPictCount[i] = 0;
-		_animResId[i] = 0;
+		_staticResId[i]     = 0;
+		_animPictCount[i]   = 0;
+		_animResId[i]       = 0;
 	}
 
-	_curStatic = 0;
+	_curStatic      = 0;
 	_curStaticLayer = 0;
 
-	_toRedrawLeft = 0;
-	_toRedrawRight = 0;
-	_toRedrawTop = 0;
+	_toRedrawLeft   = 0;
+	_toRedrawRight  = 0;
+	_toRedrawTop    = 0;
 	_toRedrawBottom = 0;
 
-	_animTop = 0;
+	_animTop  = 0;
 	_animLeft = 0;
 
 	_pCaptureCounter = 0;
 
 	for (int i = 0; i < 70; i++ ) {
 		_staticPictToSprite[i] = 0;
-		_animPictToSprite[i] = 0;
+		_animPictToSprite[i]   = 0;
 	}
 }
 
@@ -78,17 +80,17 @@ Scenery::~Scenery() {
 
 void Scenery::init() {
 	for (int i = 0; i < 10; i++) {
-		_animPictCount[i] = 0;
+		_animPictCount[i]   =  0;
 		_staticPictCount[i] = -1;
 	}
 
 	for (int i = 0; i < 20; i++) {
-		_spriteRefs[i] = 0;
+		_spriteRefs[i]  =  0;
 		_spriteResId[i] = -1;
 	}
 
 	_curStaticLayer = -1;
-	_curStatic = -1;
+	_curStatic      = -1;
 }
 
 int16 Scenery::loadStatic(char search) {
@@ -97,28 +99,26 @@ int16 Scenery::loadStatic(char search) {
 	int16 picsCount;
 	int16 resId;
 	int16 sceneryIndex;
-	byte *extData = 0;
-	byte *dataPtr;
 	Static *ptr;
 	int16 width;
 	int16 height;
 	int16 sprResId;
 	int16 sprIndex;
 
-	_vm->_inter->evalExpr(&sceneryIndex);
+	_vm->_game->_script->evalExpr(&sceneryIndex);
 
-	size = _vm->_inter->load16();
-	backsPtr = (int16 *) _vm->_global->_inter_execPtr;
-	_vm->_global->_inter_execPtr += size * 2;
-	picsCount = _vm->_inter->load16();
-	resId = _vm->_inter->load16();
+	size      = _vm->_game->_script->readInt16();
+	backsPtr  = (int16 *) (_vm->_game->_script->getData() + _vm->_game->_script->pos());
+	_vm->_game->_script->skip(size * 2);
+	picsCount = _vm->_game->_script->readInt16();
+	resId     = _vm->_game->_script->readInt16();
 
 	if (search) {
 		int i;
 
 		for (i = 0; i < 10; i++) {
 			if ((_staticPictCount[i] != -1) && (_staticResId[i] == resId)) {
-				_vm->_global->_inter_execPtr += 8 * _staticPictCount[i];
+				_vm->_game->_script->skip(8 * _staticPictCount[i]);
 				return i;
 			}
 
@@ -128,52 +128,54 @@ int16 Scenery::loadStatic(char search) {
 	}
 
 	_staticPictCount[sceneryIndex] = picsCount;
-	_staticResId[sceneryIndex] = resId;
+	_staticResId[sceneryIndex]     = resId;
 
-	if (resId >= 30000) {
-		extData = _vm->_game->loadExtData(resId, 0, 0);
-		dataPtr = extData;
-	} else
-		dataPtr = _vm->_game->loadTotResource(resId);
+	Resource *resource = _vm->_game->_resources->getResource((uint16) resId);
+	if (!resource)
+		return 0;
 
 	ptr = &_statics[sceneryIndex];
 
-	ptr->layersCount = (int16) READ_LE_UINT16(dataPtr);
-	dataPtr += 2;
+	ptr->layersCount = resource->stream()->readSint16LE();
 
 	ptr->layers = new StaticLayer[ptr->layersCount];
 
 	for (int i = 0; i < ptr->layersCount; i++) {
-		int16 offset = READ_LE_UINT16(dataPtr + i * 2);
-		Common::MemoryReadStream layerData(dataPtr + offset, 4294967295U);
+		Common::SeekableReadStream &layerData = *resource->stream();
 
-		ptr->layers[i].planeCount = layerData.readSint16LE();
+		layerData.seek(2 + i * 2);
+		layerData.seek(layerData.readUint16LE());
 
-		ptr->layers[i].planes = new StaticPlane[ptr->layers[i].planeCount];
-		for (int j = 0; j < ptr->layers[i].planeCount; ++j) {
-			ptr->layers[i].planes[j].pictIndex = layerData.readByte();
-			ptr->layers[i].planes[j].pieceIndex = layerData.readByte();
-			ptr->layers[i].planes[j].drawOrder = layerData.readByte();
-			ptr->layers[i].planes[j].destX = layerData.readSint16LE();
-			ptr->layers[i].planes[j].destY = layerData.readSint16LE();
-			ptr->layers[i].planes[j].transp = layerData.readSByte();
-		}
+		ptr->layers[i].backResId  = layerData.readSint16LE();
+		ptr->layers[i].planeCount = layerData.readSint16LE();
+		if (ptr->layers[i].planeCount > 0) {
+			ptr->layers[i].planes = new StaticPlane[ptr->layers[i].planeCount];
+			for (int j = 0; j < ptr->layers[i].planeCount; j++) {
+				ptr->layers[i].planes[j].pictIndex  = layerData.readByte();
+				ptr->layers[i].planes[j].pieceIndex = layerData.readByte();
+				ptr->layers[i].planes[j].drawOrder  = layerData.readByte();
+				ptr->layers[i].planes[j].destX      = layerData.readSint16LE();
+				ptr->layers[i].planes[j].destY      = layerData.readSint16LE();
+				ptr->layers[i].planes[j].transp     = layerData.readSByte();
+			}
+		} else
+			ptr->layers[i].planes = 0;
 
 		ptr->layers[i].backResId = (int16) READ_LE_UINT16(backsPtr);
 		backsPtr++;
 	}
 
-	ptr->pieces = new PieceDesc*[picsCount];
+	ptr->pieces      = new PieceDesc*[picsCount];
 	ptr->piecesCount = new uint32[picsCount];
 
 	for (int i = 0; i < picsCount; i++) {
-		int16 pictDescId = _vm->_inter->load16();
+		int16 pictDescId = _vm->_game->_script->readInt16();
 
 		loadPieces(pictDescId, ptr->pieces[i], ptr->piecesCount[i]);
 
-		width = _vm->_inter->load16();
-		height = _vm->_inter->load16();
-		sprResId = _vm->_inter->load16();
+		width    = _vm->_game->_script->readInt16();
+		height   = _vm->_game->_script->readInt16();
+		sprResId = _vm->_game->_script->readInt16();
 		for (sprIndex = 0; sprIndex < 20; sprIndex++) {
 			if (_spriteResId[sprIndex] == sprResId)
 				break;
@@ -183,9 +185,7 @@ int16 Scenery::loadStatic(char search) {
 			_staticPictToSprite[7 * sceneryIndex + i] = sprIndex;
 			_spriteRefs[sprIndex]++;
 		} else {
-			for (sprIndex = 19; _vm->_draw->_spritesArray[sprIndex] != 0;
-				sprIndex--)
-				;
+			for (sprIndex = 19; _vm->_draw->_spritesArray[sprIndex] != 0; sprIndex--);
 
 			_staticPictToSprite[7 * sceneryIndex + i] = sprIndex;
 			_spriteRefs[sprIndex] = 1;
@@ -193,17 +193,16 @@ int16 Scenery::loadStatic(char search) {
 			_vm->_draw->initSpriteSurf(sprIndex, width, height, 2);
 
 			_vm->_video->clearSurf(*_vm->_draw->_spritesArray[sprIndex]);
-			_vm->_draw->_destSurface = sprIndex;
-			_vm->_draw->_spriteLeft = sprResId;
+			_vm->_draw->_destSurface  = sprIndex;
+			_vm->_draw->_spriteLeft   = sprResId;
 			_vm->_draw->_transparency = 0;
-			_vm->_draw->_destSpriteX = 0;
-			_vm->_draw->_destSpriteY = 0;
+			_vm->_draw->_destSpriteX  = 0;
+			_vm->_draw->_destSpriteY  = 0;
 			_vm->_draw->spriteOperation(DRAW_LOADSPRITE);
 		}
 	}
 
-	delete[] extData;
-
+	delete resource;
 	return sceneryIndex + 100;
 }
 
@@ -211,7 +210,7 @@ void Scenery::freeStatic(int16 index) {
 	int16 spr;
 
 	if (index == -1)
-		_vm->_inter->evalExpr(&index);
+		_vm->_game->_script->evalExpr(&index);
 
 	if (_staticPictCount[index] == -1)
 		return;
@@ -229,12 +228,13 @@ void Scenery::freeStatic(int16 index) {
 
 	for (int i = 0; i < _statics[index].layersCount; i++)
 		delete[] _statics[index].layers[i].planes;
+
 	delete[] _statics[index].layers;
 	delete[] _statics[index].pieces;
 	delete[] _statics[index].piecesCount;
 
 	_statics[index].layersCount = 0;
-	_staticPictCount[index] = -1;
+	_staticPictCount[index]     = -1;
 }
 
 void Scenery::renderStatic(int16 scenery, int16 layer) {
@@ -261,22 +261,21 @@ void Scenery::renderStatic(int16 scenery, int16 layer) {
 
 	_vm->_draw->_spriteLeft = layerPtr->backResId;
 	if (_vm->_draw->_spriteLeft != -1) {
-		_vm->_draw->_destSpriteX = 0;
-		_vm->_draw->_destSpriteY = 0;
-		_vm->_draw->_destSurface = 21;
-		_vm->_draw->_transparency = 0;
+		_vm->_draw->_destSpriteX  =  0;
+		_vm->_draw->_destSpriteY  =  0;
+		_vm->_draw->_destSurface  = 21;
+		_vm->_draw->_transparency =  0;
 		_vm->_draw->spriteOperation(DRAW_LOADSPRITE);
 	}
 
 	planeCount = layerPtr->planeCount;
 	for (order = 0; order < 100; order++) {
-		for (plane = 0, planePtr = layerPtr->planes;
-		    plane < planeCount; plane++, planePtr++) {
+		for (plane = 0, planePtr = layerPtr->planes; plane < planeCount; plane++, planePtr++) {
 			if (planePtr->drawOrder != order)
 				continue;
 
 			pieceIndex = planePtr->pieceIndex;
-			pictIndex = planePtr->pictIndex - 1;
+			pictIndex  = planePtr->pictIndex - 1;
 
 			if (pictIndex >= _staticPictCount[scenery])
 				continue;
@@ -289,19 +288,19 @@ void Scenery::renderStatic(int16 scenery, int16 layer) {
 
 			_vm->_draw->_destSpriteX = planePtr->destX;
 			_vm->_draw->_destSpriteY = planePtr->destY;
-			left = ptr->pieces[pictIndex][pieceIndex].left;
-			right = ptr->pieces[pictIndex][pieceIndex].right;
-			top = ptr->pieces[pictIndex][pieceIndex].top;
+			left   = ptr->pieces[pictIndex][pieceIndex].left;
+			right  = ptr->pieces[pictIndex][pieceIndex].right;
+			top    = ptr->pieces[pictIndex][pieceIndex].top;
 			bottom = ptr->pieces[pictIndex][pieceIndex].bottom;
 
 			_vm->_draw->_sourceSurface =
 			    _staticPictToSprite[scenery * 7 + pictIndex];
-			_vm->_draw->_destSurface = 21;
-			_vm->_draw->_spriteLeft = left;
-			_vm->_draw->_spriteTop = top;
-			_vm->_draw->_spriteRight = right - left + 1;
-			_vm->_draw->_spriteBottom = bottom - top + 1;
-			_vm->_draw->_transparency = planePtr->transp ? 3 : 0;
+			_vm->_draw->_destSurface   = 21;
+			_vm->_draw->_spriteLeft    = left;
+			_vm->_draw->_spriteTop     = top;
+			_vm->_draw->_spriteRight   = right - left + 1;
+			_vm->_draw->_spriteBottom  = bottom - top + 1;
+			_vm->_draw->_transparency  = planePtr->transp ? 3 : 0;
 			_vm->_draw->spriteOperation(DRAW_BLITSURF);
 		}
 	}
@@ -337,7 +336,7 @@ void Scenery::updateStatic(int16 orderFrom, byte index, byte layer) {
 				continue;
 
 			pieceIndex = planePtr->pieceIndex;
-			pictIndex = planePtr->pictIndex - 1;
+			pictIndex  = planePtr->pictIndex - 1;
 
 			if (pictIndex >= _staticPictCount[index])
 				continue;
@@ -351,9 +350,9 @@ void Scenery::updateStatic(int16 orderFrom, byte index, byte layer) {
 			_vm->_draw->_destSpriteX = planePtr->destX;
 			_vm->_draw->_destSpriteY = planePtr->destY;
 
-			left = pictPtr[pictIndex][pieceIndex].left;
-			right = pictPtr[pictIndex][pieceIndex].right;
-			top = pictPtr[pictIndex][pieceIndex].top;
+			left   = pictPtr[pictIndex][pieceIndex].left;
+			right  = pictPtr[pictIndex][pieceIndex].right;
+			top    = pictPtr[pictIndex][pieceIndex].top;
 			bottom = pictPtr[pictIndex][pieceIndex].bottom;
 
 			if (_vm->_draw->_destSpriteX > _toRedrawRight)
@@ -372,10 +371,10 @@ void Scenery::updateStatic(int16 orderFrom, byte index, byte layer) {
 				_vm->_draw->_destSpriteY = _toRedrawTop;
 			}
 
-			_vm->_draw->_spriteLeft = left;
-			_vm->_draw->_spriteTop = top;
-			_vm->_draw->_spriteRight = right - left + 1;
-			_vm->_draw->_spriteBottom = bottom - top + 1;
+			_vm->_draw->_spriteLeft   = left;
+			_vm->_draw->_spriteTop    = top;
+			_vm->_draw->_spriteRight  = right  - left + 1;
+			_vm->_draw->_spriteBottom = bottom - top  + 1;
 
 			if ((_vm->_draw->_spriteRight <= 0) ||
 			    (_vm->_draw->_spriteBottom <= 0))
@@ -393,8 +392,8 @@ void Scenery::updateStatic(int16 orderFrom, byte index, byte layer) {
 
 			_vm->_draw->_sourceSurface =
 			    _staticPictToSprite[index * 7 + pictIndex];
-			_vm->_draw->_destSurface = 21;
-			_vm->_draw->_transparency = planePtr->transp ? 3 : 0;
+			_vm->_draw->_destSurface   = 21;
+			_vm->_draw->_transparency  = planePtr->transp ? 3 : 0;
 			_vm->_draw->spriteOperation(DRAW_BLITSURF);
 		}
 	}
@@ -422,8 +421,6 @@ int16 Scenery::loadAnim(char search) {
 	int16 j;
 	int16 sceneryIndex;
 	int16 framesCount;
-	byte *extData;
-	byte *dataPtr;
 	Animation *ptr;
 	int16 width;
 	int16 height;
@@ -431,15 +428,14 @@ int16 Scenery::loadAnim(char search) {
 	int16 sprIndex;
 	uint32 layerPos;
 
-	extData = 0;
-	_vm->_inter->evalExpr(&sceneryIndex);
-	picsCount = _vm->_inter->load16();
-	resId = _vm->_inter->load16();
+	_vm->_game->_script->evalExpr(&sceneryIndex);
+	picsCount = _vm->_game->_script->readInt16();
+	resId = _vm->_game->_script->readInt16();
 
 	if (search) {
 		for (i = 0; i < 10; i++) {
 			if ((_animPictCount[i] != 0) && (_animResId[i] == resId)) {
-				_vm->_global->_inter_execPtr += 8 * _animPictCount[i];
+				_vm->_game->_script->skip(8 * _animPictCount[i]);
 				return i;
 			}
 
@@ -451,50 +447,50 @@ int16 Scenery::loadAnim(char search) {
 	_animPictCount[sceneryIndex] = picsCount;
 	_animResId[sceneryIndex] = resId;
 
-	if (resId >= 30000) {
-		extData = _vm->_game->loadExtData(resId, 0, 0);
-		dataPtr = extData;
-	} else
-		dataPtr = _vm->_game->loadTotResource(resId);
+	Resource *resource = _vm->_game->_resources->getResource((uint16) resId);
+	if (!resource)
+		return 0;
 
 	ptr = &_animations[sceneryIndex];
 
-	ptr->layersCount = READ_LE_UINT16(dataPtr);
-	dataPtr += 2;
+	ptr->layersCount = resource->stream()->readSint16LE();
 
 	ptr->layers = new AnimLayer[ptr->layersCount];
 
 	for (i = 0; i < ptr->layersCount; i++) {
-		int16 offset = READ_LE_UINT16(dataPtr + i * 2);
-		Common::MemoryReadStream layerData(dataPtr + offset - 2, 4294967295U);
-
-		ptr->layers[i].unknown0 = layerData.readSint16LE();
-		ptr->layers[i].posX = layerData.readSint16LE();
-		ptr->layers[i].posY = layerData.readSint16LE();
-		ptr->layers[i].animDeltaX = layerData.readSint16LE();
-		ptr->layers[i].animDeltaY = layerData.readSint16LE();
-		ptr->layers[i].transp = layerData.readSByte();
+		Common::SeekableReadStream &layerData = *resource->stream();
+
+		layerData.seek(2 + i * 2);
+		layerData.seek(layerData.readUint16LE());
+
+		ptr->layers[i].unknown0    = layerData.readSint16LE();
+		ptr->layers[i].posX        = layerData.readSint16LE();
+		ptr->layers[i].posY        = layerData.readSint16LE();
+		ptr->layers[i].animDeltaX  = layerData.readSint16LE();
+		ptr->layers[i].animDeltaY  = layerData.readSint16LE();
+		ptr->layers[i].transp      = layerData.readSByte();
 		ptr->layers[i].framesCount = layerData.readSint16LE();
 
+		// Going through the AnimFramePiece, finding the end for each
 		layerPos = layerData.pos();
 		framesCount = 0;
-		layerData.seek(4, SEEK_CUR);
-		for (j = 0; j < ptr->layers[i].framesCount;
-				j++, framesCount++, layerData.seek(4, SEEK_CUR)) {
+		for (j = 0; j < ptr->layers[i].framesCount; j++) {
+			layerData.skip(4); // pictIndex, pieceIndex, destX, destY
 			while (layerData.readByte() == 1) {
 				framesCount++;
-				layerData.seek(4, SEEK_CUR);
+				layerData.skip(4); // pictIndex, pieceIndex, destX, destY
 			}
+			framesCount++;
 		}
 		layerData.seek(layerPos);
 
 		ptr->layers[i].frames = new AnimFramePiece[framesCount];
 		for (j = 0; j < framesCount; j++) {
-			ptr->layers[i].frames[j].pictIndex = layerData.readByte();
+			ptr->layers[i].frames[j].pictIndex  = layerData.readByte();
 			ptr->layers[i].frames[j].pieceIndex = layerData.readByte();
-			ptr->layers[i].frames[j].destX = layerData.readSByte();
-			ptr->layers[i].frames[j].destY = layerData.readSByte();
-			ptr->layers[i].frames[j].notFinal = layerData.readSByte();
+			ptr->layers[i].frames[j].destX      = layerData.readSByte();
+			ptr->layers[i].frames[j].destY      = layerData.readSByte();
+			ptr->layers[i].frames[j].notFinal   = layerData.readSByte();
 		}
 	}
 
@@ -502,13 +498,13 @@ int16 Scenery::loadAnim(char search) {
 	ptr->piecesCount = new uint32[picsCount];
 
 	for (i = 0; i < picsCount; i++) {
-		int16 pictDescId = _vm->_inter->load16();
+		int16 pictDescId = _vm->_game->_script->readInt16();
 
 		loadPieces(pictDescId, ptr->pieces[i], ptr->piecesCount[i]);
 
-		width = _vm->_inter->load16();
-		height = _vm->_inter->load16();
-		sprResId = _vm->_inter->load16();
+		width    = _vm->_game->_script->readInt16();
+		height   = _vm->_game->_script->readInt16();
+		sprResId = _vm->_game->_script->readInt16();
 		for (sprIndex = 0; sprIndex < 20; sprIndex++)
 			if (_spriteResId[sprIndex] == sprResId)
 				break;
@@ -522,22 +518,21 @@ int16 Scenery::loadAnim(char search) {
 				;
 
 			_animPictToSprite[7 * sceneryIndex + i] = sprIndex;
-			_spriteRefs[sprIndex] = 1;
+			_spriteRefs[sprIndex]  = 1;
 			_spriteResId[sprIndex] = sprResId;
 			_vm->_draw->initSpriteSurf(sprIndex, width, height, 2);
 
 			_vm->_video->clearSurf(*_vm->_draw->_spritesArray[sprIndex]);
-			_vm->_draw->_destSurface = sprIndex;
-			_vm->_draw->_spriteLeft = sprResId;
+			_vm->_draw->_destSurface  = sprIndex;
+			_vm->_draw->_spriteLeft   = sprResId;
 			_vm->_draw->_transparency = 0;
-			_vm->_draw->_destSpriteX = 0;
-			_vm->_draw->_destSpriteY = 0;
+			_vm->_draw->_destSpriteX  = 0;
+			_vm->_draw->_destSpriteY  = 0;
 			_vm->_draw->spriteOperation(DRAW_LOADSPRITE);
 		}
 	}
 
-	delete[] extData;
-
+	delete resource;
 	return sceneryIndex + 100;
 }
 
@@ -545,7 +540,7 @@ void Scenery::freeAnim(int16 index) {
 	int16 spr;
 
 	if (index == -1)
-		_vm->_inter->evalExpr(&index);
+		_vm->_game->_script->evalExpr(&index);
 
 	if (_animPictCount[index] == 0)
 		return;
@@ -563,6 +558,7 @@ void Scenery::freeAnim(int16 index) {
 
 	for (int i = 0; i < _animations[index].layersCount; i++)
 		delete[] _animations[index].layers[i].frames;
+
 	delete[] _animations[index].layers;
 	delete[] _animations[index].pieces;
 	delete[] _animations[index].piecesCount;
@@ -607,8 +603,8 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 				return;
 
 			_vm->_game->capturePush(_toRedrawLeft, _toRedrawTop,
-					_toRedrawRight - _toRedrawLeft + 1,
-					_toRedrawBottom - _toRedrawTop + 1);
+					_toRedrawRight  - _toRedrawLeft + 1,
+					_toRedrawBottom - _toRedrawTop  + 1);
 
 			*_pCaptureCounter = *_pCaptureCounter + 1;
 		}
@@ -628,7 +624,7 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 			while (_vm->_vidPlayer->getCurrentFrame(obj.videoSlot - 1) <= frame)
 				_vm->_vidPlayer->slotPlay(obj.videoSlot - 1);
 		} else {
-			int16 curFrame = _vm->_vidPlayer->getCurrentFrame(obj.videoSlot - 1);
+			int16 curFrame  = _vm->_vidPlayer->getCurrentFrame(obj.videoSlot - 1);
 			uint8 frameWrap = curFrame / 256;
 			frame = (frame + 1) % 256;
 
@@ -636,17 +632,17 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 				_vm->_vidPlayer->slotPlay(obj.videoSlot - 1);
 		}
 
-		destX = 0;
-		destY = 0;
-		left = *(obj.pPosX);
-		top = *(obj.pPosY);
-		right = left + _vm->_vidPlayer->getWidth(obj.videoSlot - 1) - 1;
-		bottom = top + _vm->_vidPlayer->getHeight(obj.videoSlot - 1) - 1;
+		destX  = 0;
+		destY  = 0;
+		left   = *(obj.pPosX);
+		top    = *(obj.pPosY);
+		right  = left + _vm->_vidPlayer->getWidth(obj.videoSlot  - 1) - 1;
+		bottom = top  + _vm->_vidPlayer->getHeight(obj.videoSlot - 1) - 1;
 
 		if (flags & 2) {
 			if (left < _vm->_mult->_animLeft) {
 				destX += _vm->_mult->_animLeft - left;
-				left = _vm->_mult->_animLeft;
+				left   = _vm->_mult->_animLeft;
 			}
 
 			if ((_vm->_mult->_animLeft + _vm->_mult->_animWidth) <= right)
@@ -654,7 +650,7 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 
 			if (top < _vm->_mult->_animTop) {
 				destY += _vm->_mult->_animTop - top;
-				top = _vm->_mult->_animTop;
+				top    = _vm->_mult->_animTop;
 			}
 
 			if ((_vm->_mult->_animTop + _vm->_mult->_animHeight) <= bottom)
@@ -663,7 +659,7 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 		} else if (flags & 4) {
 			if (left < _toRedrawLeft) {
 				destX += _toRedrawLeft - left;
-				left = _toRedrawLeft;
+				left   = _toRedrawLeft;
 			}
 
 			if (right > _toRedrawRight)
@@ -671,16 +667,16 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 
 			if (top < _toRedrawTop) {
 				destY += _toRedrawTop - top;
-				top = _toRedrawTop;
+				top    = _toRedrawTop;
 			}
 
 			if (bottom > _toRedrawBottom)
 				bottom = _toRedrawBottom;
 
 		} else {
-			_toRedrawTop = top;
-			_toRedrawLeft = left;
-			_toRedrawRight = right;
+			_toRedrawTop    = top;
+			_toRedrawLeft   = left;
+			_toRedrawRight  = right;
 			_toRedrawBottom = bottom;
 		}
 
@@ -690,7 +686,7 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 
 			if (left < _vm->_mult->_animLeft) {
 				destX += _vm->_mult->_animLeft - left;
-				left = _vm->_mult->_animLeft;
+				left   = _vm->_mult->_animLeft;
 			}
 
 			if ((_vm->_mult->_animLeft + _vm->_mult->_animWidth) <= right)
@@ -698,40 +694,40 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 
 			if (top < _vm->_mult->_animTop) {
 				destY += _vm->_mult->_animTop - top;
-				top = _vm->_mult->_animTop;
+				top    = _vm->_mult->_animTop;
 			}
 
 			if ((_vm->_mult->_animTop + _vm->_mult->_animHeight) <= bottom)
 				bottom = _vm->_mult->_animTop + _vm->_mult->_animHeight - 1;
 
-			_vm->_draw->_spriteLeft = destX;
-			_vm->_draw->_spriteTop = destY;
-			_vm->_draw->_spriteRight = right - left + 1;
-			_vm->_draw->_spriteBottom = bottom - top + 1;
-			_vm->_draw->_destSpriteX = left;
-			_vm->_draw->_destSpriteY = top;
+			_vm->_draw->_spriteLeft   = destX;
+			_vm->_draw->_spriteTop    = destY;
+			_vm->_draw->_spriteRight  = right  - left + 1;
+			_vm->_draw->_spriteBottom = bottom - top  + 1;
+			_vm->_draw->_destSpriteX  = left;
+			_vm->_draw->_destSpriteY  = top;
 			_vm->_draw->_transparency = layer;
 			if (layer & 0x80)
 				_vm->_draw->_spriteLeft = _vm->_vidPlayer->getWidth(obj.videoSlot - 1)  -
 					(destX + _vm->_draw->_spriteRight);
 
 			_vm->_vidPlayer->slotCopyFrame(obj.videoSlot - 1, _vm->_draw->_backSurface->getVidMem(),
-					_vm->_draw->_spriteLeft, _vm->_draw->_spriteTop,
+					_vm->_draw->_spriteLeft,  _vm->_draw->_spriteTop,
 					_vm->_draw->_spriteRight, _vm->_draw->_spriteBottom,
 					_vm->_draw->_destSpriteX, _vm->_draw->_destSpriteY,
 					_vm->_draw->_backSurface->getWidth(),
 					(_vm->_draw->_transparency != 0) ? 0 : -1);
 
 			_vm->_draw->invalidateRect(_vm->_draw->_destSpriteX, _vm->_draw->_destSpriteY,
-					_vm->_draw->_destSpriteX + _vm->_draw->_spriteRight - 1,
+					_vm->_draw->_destSpriteX + _vm->_draw->_spriteRight  - 1,
 					_vm->_draw->_destSpriteY + _vm->_draw->_spriteBottom - 1);
 
 		}
 
 		if (!(flags & 4)) {
-			_animLeft = _toRedrawLeft = left;
-			_animTop = _toRedrawTop = top;
-			_animRight = _toRedrawRight = right;
+			_animLeft   = _toRedrawLeft = left;
+			_animTop    = _toRedrawTop = top;
+			_animRight  = _toRedrawRight = right;
 			_animBottom = _toRedrawBottom = bottom;
 		}
 
@@ -757,13 +753,13 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 			return;
 
 		_vm->_game->capturePush(_toRedrawLeft, _toRedrawTop,
-		    _toRedrawRight - _toRedrawLeft + 1,
-		    _toRedrawBottom - _toRedrawTop + 1);
+		    _toRedrawRight  - _toRedrawLeft + 1,
+		    _toRedrawBottom - _toRedrawTop  + 1);
 
 		*_pCaptureCounter = *_pCaptureCounter + 1;
 	}
 
-	pictPtr = _animations[animation].pieces;
+	pictPtr  = _animations[animation].pieces;
 	framePtr = layerPtr->frames;
 
 	for (i = 0; i < frame; i++, framePtr++)
@@ -771,9 +767,9 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 			framePtr++;
 
 	if (flags & 4) {
-		_toRedrawLeft = MAX(_toRedrawLeft, _vm->_mult->_animLeft);
-		_toRedrawTop = MAX(_toRedrawTop, _vm->_mult->_animTop);
-		_toRedrawRight = MIN(_toRedrawRight,
+		_toRedrawLeft   = MAX(_toRedrawLeft, _vm->_mult->_animLeft);
+		_toRedrawTop    = MAX(_toRedrawTop, _vm->_mult->_animTop);
+		_toRedrawRight  = MIN(_toRedrawRight,
 		    (int16)(_vm->_mult->_animLeft + _vm->_mult->_animWidth - 1));
 		_toRedrawBottom = MIN(_toRedrawBottom,
 		    (int16)(_vm->_mult->_animTop + _vm->_mult->_animHeight - 1));
@@ -844,7 +840,7 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 					(_vm->_mult->_animLeft + _vm->_mult->_animWidth) + 1;
 
 			if (destY < _vm->_mult->_animTop) {
-				top += _vm->_mult->_animTop - destY;
+				top  += _vm->_mult->_animTop - destY;
 				destY = _vm->_mult->_animTop;
 			}
 
@@ -863,7 +859,7 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 				right -= destX + right - left - _toRedrawRight;
 
 			if (destY < _toRedrawTop) {
-				top += _toRedrawTop - destY;
+				top  += _toRedrawTop - destY;
 				destY = _toRedrawTop;
 			}
 
@@ -877,33 +873,33 @@ void Scenery::updateAnim(int16 layer, int16 frame, int16 animation, int16 flags,
 		if (doDraw) {
 			_vm->_draw->_sourceSurface =
 			    _animPictToSprite[animation * 7 + pictIndex];
-			_vm->_draw->_destSurface = 21;
+			_vm->_draw->_destSurface   = 21;
 
-			_vm->_draw->_spriteLeft = left;
-			_vm->_draw->_spriteTop = top;
-			_vm->_draw->_spriteRight = right - left + 1;
+			_vm->_draw->_spriteLeft   = left;
+			_vm->_draw->_spriteTop    = top;
+			_vm->_draw->_spriteRight  = right - left + 1;
 			_vm->_draw->_spriteBottom = bottom - top + 1;
-			_vm->_draw->_destSpriteX = destX;
-			_vm->_draw->_destSpriteY = destY;
+			_vm->_draw->_destSpriteX  = destX;
+			_vm->_draw->_destSpriteY  = destY;
 			_vm->_draw->_transparency = transp;
 			_vm->_draw->spriteOperation(DRAW_BLITSURF);
 		}
 
 		if (!(flags & 4)) {
 			if (_toRedrawLeft == -12345) {
-				_toRedrawLeft = destX;
-				_animLeft = destX;
-				_toRedrawTop = destY;
-				_animTop = destY;
-				_toRedrawRight = destX + right - left;
-				_animRight = destX + right - left;
+				_toRedrawLeft   = destX;
+				_animLeft       = destX;
+				_toRedrawTop    = destY;
+				_animTop        = destY;
+				_toRedrawRight  = destX + right  - left;
+				_animRight      = destX + right  - left;
 				_toRedrawBottom = destY + bottom - top;
-				_animBottom = destY + bottom - top;
+				_animBottom     = destY + bottom - top;
 			} else {
-				_toRedrawLeft = MIN(_toRedrawLeft, destX);
-				_toRedrawTop = MIN(_toRedrawTop, destY);
-				_toRedrawRight =
-					MAX(_toRedrawRight, (int16)(destX + right - left));
+				_toRedrawLeft   = MIN(_toRedrawLeft, destX);
+				_toRedrawTop    = MIN(_toRedrawTop, destY);
+				_toRedrawRight  =
+					MAX(_toRedrawRight,  (int16)(destX + right - left));
 				_toRedrawBottom =
 					MAX(_toRedrawBottom, (int16)(destY + bottom - top));
 			}
@@ -952,41 +948,23 @@ Scenery::AnimLayer *Scenery::getAnimLayer(uint16 index, uint16 layer) {
 }
 
 void Scenery::loadPieces(int16 pictDescId, PieceDesc *&pieceDesc, uint32 &piecesCount) {
-	byte *data;
-	uint32 size;
-	bool fromExt = false;
-
-	if (pictDescId >= 30000) {
-		fromExt = true;
-
-		uint32 eSize;
-
-		data = _vm->_game->loadExtData(pictDescId, 0, 0, &eSize);
-		size = eSize;
-	} else {
-		int16 tSize;
-
-		data = _vm->_game->loadTotResource(pictDescId, &tSize);
-		size = tSize;
+	Resource *resource = _vm->_game->_resources->getResource(pictDescId);
+	if (!resource) {
+		warning("Scenery::loadPieces(): Can't load %d", pictDescId);
+		return;
 	}
 
-	if (!data)
-		error("Scenery::loadPieces(): Can't load pictDescId %d", pictDescId);
-
-	piecesCount = size / 8;
+	piecesCount = resource->getSize() / 8;
 	pieceDesc = new PieceDesc[piecesCount];
 
-	Common::MemoryReadStream pieceData(data, size);
-
 	for (uint32 i = 0; i < piecesCount; i++) {
-		pieceDesc[i].left = (int16) pieceData.readUint16LE();
-		pieceDesc[i].right = (int16) pieceData.readUint16LE();
-		pieceDesc[i].top = (int16) pieceData.readUint16LE();
-		pieceDesc[i].bottom = (int16) pieceData.readUint16LE();
+		pieceDesc[i].left   = resource->stream()->readSint16LE();
+		pieceDesc[i].right  = resource->stream()->readSint16LE();
+		pieceDesc[i].top    = resource->stream()->readSint16LE();
+		pieceDesc[i].bottom = resource->stream()->readSint16LE();
 	}
 
-	if (fromExt)
-		delete[] data;
+	delete resource;
 }
 
 } // End of namespace Gob