[Scummvm-cvs-logs] CVS: scummvm/gob draw.cpp,1.18,1.19 game.cpp,1.33,1.34 goblin.cpp,1.29,1.30 inter.cpp,1.31,1.32 inter_v1.cpp,1.4,1.5 map.cpp,1.20,1.21 mult.cpp,1.16,1.17 mult.h,1.7,1.8 scenery.cpp,1.23,1.24 scenery.h,1.8,1.9

Sven Hesse drmccoy at users.sourceforge.net
Mon Jan 9 08:11:02 CET 2006


Update of /cvsroot/scummvm/scummvm/gob
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv30816

Modified Files:
	draw.cpp game.cpp goblin.cpp inter.cpp inter_v1.cpp map.cpp 
	mult.cpp mult.h scenery.cpp scenery.h 
Log Message:
More variable underscoring, that should be all


Index: draw.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/draw.cpp,v
retrieving revision 1.18
retrieving revision 1.19
diff -u -d -r1.18 -r1.19
--- draw.cpp	7 Jan 2006 22:28:53 -0000	1.18
+++ draw.cpp	9 Jan 2006 16:10:22 -0000	1.19
@@ -800,7 +800,7 @@
 		_spriteBottom = READ_LE_UINT16(ptr + 6) - _destSpriteY + 1;
 		_vm->_game->capturePush(_destSpriteX, _destSpriteY,
 						 _spriteRight, _spriteBottom);
-		(*_vm->_scenery->pCaptureCounter)++;
+		(*_vm->_scenery->_pCaptureCounter)++;
 	}
 	_destSpriteX = READ_LE_UINT16(ptr);
 	destX = _destSpriteX;
@@ -942,8 +942,8 @@
 //              add     sp, 0Ch
 	}
 
-	if ((_renderFlags & RENDERFLAG_CAPTUREPOP) && *_vm->_scenery->pCaptureCounter != 0) {
-		(*_vm->_scenery->pCaptureCounter)--;
+	if ((_renderFlags & RENDERFLAG_CAPTUREPOP) && *_vm->_scenery->_pCaptureCounter != 0) {
+		(*_vm->_scenery->_pCaptureCounter)--;
 		_vm->_game->capturePop(1);
 	}
 }

Index: game.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/game.cpp,v
retrieving revision 1.33
retrieving revision 1.34
diff -u -d -r1.33 -r1.34
--- game.cpp	8 Jan 2006 20:03:20 -0000	1.33
+++ game.cpp	9 Jan 2006 16:10:22 -0000	1.34
@@ -449,12 +449,12 @@
 	_vm->_util->processInput();
 
 	if (VAR(58) != 0) {
-		if (_vm->_mult->frameStart != (int)VAR(58) - 1)
-			_vm->_mult->frameStart++;
+		if (_vm->_mult->_frameStart != (int)VAR(58) - 1)
+			_vm->_mult->_frameStart++;
 		else
-			_vm->_mult->frameStart = 0;
+			_vm->_mult->_frameStart = 0;
 
-		_vm->_mult->playMult(_vm->_mult->frameStart + VAR(57), _vm->_mult->frameStart + VAR(57), 1,
+		_vm->_mult->playMult(_vm->_mult->_frameStart + VAR(57), _vm->_mult->_frameStart + VAR(57), 1,
 		    handleMouse);
 	}
 
@@ -1743,12 +1743,12 @@
 
 	oldNestLevel = _vm->_inter->_nestLevel;
 	oldBreakFrom = _vm->_inter->_breakFromLevel;
-	oldCaptureCounter = _vm->_scenery->pCaptureCounter;
+	oldCaptureCounter = _vm->_scenery->_pCaptureCounter;
 	savedIP = _vm->_global->_inter_execPtr;
 
 	_vm->_inter->_nestLevel = &nestLevel;
 	_vm->_inter->_breakFromLevel = &breakFrom;
-	_vm->_scenery->pCaptureCounter = &_captureCounter;
+	_vm->_scenery->_pCaptureCounter = &_captureCounter;
 	strcpy(savedTotName, _curTotFile);
 
 	if (skipPlay == 0) {
@@ -1899,7 +1899,7 @@
 
 			_extHandle = -1;
 
-			for (i = 0; i < *_vm->_scenery->pCaptureCounter; i++)
+			for (i = 0; i < *_vm->_scenery->_pCaptureCounter; i++)
 				capturePop(0);
 
 			_vm->_mult->checkFreeMult();
@@ -1926,7 +1926,7 @@
 
 	_vm->_inter->_nestLevel = oldNestLevel;
 	_vm->_inter->_breakFromLevel = oldBreakFrom;
-	_vm->_scenery->pCaptureCounter = oldCaptureCounter;
+	_vm->_scenery->_pCaptureCounter = oldCaptureCounter;
 	_vm->_global->_inter_execPtr = savedIP;
 }
 

Index: goblin.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/goblin.cpp,v
retrieving revision 1.29
retrieving revision 1.30
diff -u -d -r1.29 -r1.30
--- goblin.cpp	8 Jan 2006 20:03:20 -0000	1.29
+++ goblin.cpp	9 Jan 2006 16:10:22 -0000	1.30
@@ -257,20 +257,20 @@
 		_vm->_scenery->updateAnim(layer, objDesc->curFrame, objDesc->animation,
 		    0, objDesc->xPos, objDesc->yPos, 0);
 
-		if (_vm->_scenery->toRedrawLeft == -12345) {
+		if (_vm->_scenery->_toRedrawLeft == -12345) {
 			objDesc->dirtyLeft = objDesc->left;
 			objDesc->dirtyRight = objDesc->right;
 			objDesc->dirtyTop = objDesc->top;
 			objDesc->dirtyBottom = objDesc->bottom;
 		} else {
 			objDesc->dirtyLeft =
-			    MIN(objDesc->left, _vm->_scenery->toRedrawLeft);
+			    MIN(objDesc->left, _vm->_scenery->_toRedrawLeft);
 			objDesc->dirtyRight =
-			    MAX(objDesc->right, _vm->_scenery->toRedrawRight);
+			    MAX(objDesc->right, _vm->_scenery->_toRedrawRight);
 			objDesc->dirtyTop =
-			    MIN(objDesc->top, _vm->_scenery->toRedrawTop);
+			    MIN(objDesc->top, _vm->_scenery->_toRedrawTop);
 			objDesc->dirtyBottom =
-			    MAX(objDesc->bottom, _vm->_scenery->toRedrawBottom);
+			    MAX(objDesc->bottom, _vm->_scenery->_toRedrawBottom);
 		}
 
 		objDesc->dirtyLeft = 0;
@@ -300,21 +300,21 @@
 					    objDesc->animation, 2,
 					    objDesc->xPos, objDesc->yPos, 1);
 				}
-				if (_vm->_scenery->toRedrawLeft == -12345) {
+				if (_vm->_scenery->_toRedrawLeft == -12345) {
 					objDesc->left = 0;
 					objDesc->top = 0;
 					objDesc->right = 0;
 					objDesc->bottom = 0;
 				} else {
-					_vm->_draw->invalidateRect(_vm->_scenery->toRedrawLeft,
-					    _vm->_scenery->toRedrawTop,
-					    _vm->_scenery->toRedrawRight,
-					    _vm->_scenery->toRedrawBottom);
+					_vm->_draw->invalidateRect(_vm->_scenery->_toRedrawLeft,
+					    _vm->_scenery->_toRedrawTop,
+					    _vm->_scenery->_toRedrawRight,
+					    _vm->_scenery->_toRedrawBottom);
 
-					objDesc->left = _vm->_scenery->toRedrawLeft;
-					objDesc->top = _vm->_scenery->toRedrawTop;
-					objDesc->right = _vm->_scenery->toRedrawRight;
-					objDesc->bottom = _vm->_scenery->toRedrawBottom;
+					objDesc->left = _vm->_scenery->_toRedrawLeft;
+					objDesc->top = _vm->_scenery->_toRedrawTop;
+					objDesc->right = _vm->_scenery->_toRedrawRight;
+					objDesc->bottom = _vm->_scenery->_toRedrawBottom;
 					_vm->_scenery->updateStatic(objDesc->order);
 				}
 			} else {
@@ -347,10 +347,10 @@
 				if (gobDesc2->dirtyBottom < objDesc->top)
 					continue;
 
-				_vm->_scenery->toRedrawLeft = gobDesc2->dirtyLeft;
-				_vm->_scenery->toRedrawRight = gobDesc2->dirtyRight;
-				_vm->_scenery->toRedrawTop = gobDesc2->dirtyTop;
-				_vm->_scenery->toRedrawBottom = gobDesc2->dirtyBottom;
+				_vm->_scenery->_toRedrawLeft = gobDesc2->dirtyLeft;
+				_vm->_scenery->_toRedrawRight = gobDesc2->dirtyRight;
+				_vm->_scenery->_toRedrawTop = gobDesc2->dirtyTop;
+				_vm->_scenery->_toRedrawBottom = gobDesc2->dirtyBottom;
 
 				layer =
 				    objDesc->stateMach[objDesc->
@@ -447,7 +447,7 @@
 
 			layer = objDesc->stateMach[objDesc->state][0]->layer;
 			pLayer =
-			    _vm->_scenery->animations[objDesc->animation].layers[layer];
+			    _vm->_scenery->_animations[objDesc->animation].layers[layer];
 
 			if (objDesc->curFrame < pLayer->framesCount)
 				continue;
@@ -522,7 +522,7 @@
 		_vm->_scenery->updateAnim(layer, 0, objDesc->animation, 0,
 		    objDesc->xPos, objDesc->yPos, 0);
 
-		objDesc->order = _vm->_scenery->toRedrawBottom / 24 + 3;
+		objDesc->order = _vm->_scenery->_toRedrawBottom / 24 + 3;
 
 		objDesc->left = objDesc->xPos;
 		objDesc->right = objDesc->xPos;
@@ -542,7 +542,7 @@
 	int16 layer;
 
 	layer = objDesc->stateMach[objDesc->state][0]->layer;
-	return _vm->_scenery->animations[objDesc->animation].layers[layer]->framesCount -
+	return _vm->_scenery->_animations[objDesc->animation].layers[layer]->framesCount -
 	    1;
 }
 
@@ -604,7 +604,7 @@
 	layer = gobDesc->stateMach[gobDesc->state][0]->layer;
 
 	frameCount =
-	    _vm->_scenery->animations[gobDesc->animation].layers[layer]->framesCount;
+	    _vm->_scenery->_animations[gobDesc->animation].layers[layer]->framesCount;
 	state = gobDesc->state;
 	frame = gobDesc->curFrame;
 
@@ -950,8 +950,8 @@
 			_vm->_scenery->updateAnim(layer, 0, itemDesc->animation, 0,
 			    itemDesc->xPos, itemDesc->yPos, 0);
 
-			tmpX = (_vm->_scenery->toRedrawRight + _vm->_scenery->toRedrawLeft) / 2;
-			tmpY = _vm->_scenery->toRedrawBottom;
+			tmpX = (_vm->_scenery->_toRedrawRight + _vm->_scenery->_toRedrawLeft) / 2;
+			tmpY = _vm->_scenery->_toRedrawBottom;
 
 			tmpPosY = tmpY / 6;
 			if ((tmpY % 3) < 3 && tmpPosY > 0)
@@ -1586,11 +1586,11 @@
 		gobDesc->multState = -1;
 
 		newX =
-		    _vm->_scenery->animations[gobDesc->animation].
+		    _vm->_scenery->_animations[gobDesc->animation].
 		    layers[_gobStateLayer]->animDeltaX + gobDesc->xPos;
 
 		newY =
-		    _vm->_scenery->animations[gobDesc->animation].
+		    _vm->_scenery->_animations[gobDesc->animation].
 		    layers[_gobStateLayer]->animDeltaY + gobDesc->yPos;
 
 		_gobStateLayer = nextLayer(gobDesc);
@@ -1679,10 +1679,10 @@
 
 				gobDesc->yPos =
 				    (_vm->_map->_curGoblinY + 1) * 6 -
-				    (_vm->_scenery->toRedrawBottom - _vm->_scenery->animTop);
+				    (_vm->_scenery->_toRedrawBottom - _vm->_scenery->_animTop);
 				gobDesc->xPos =
-				    _vm->_map->_curGoblinX * 12 - (_vm->_scenery->toRedrawLeft -
-				    _vm->_scenery->animLeft);
+				    _vm->_map->_curGoblinX * 12 - (_vm->_scenery->_toRedrawLeft -
+				    _vm->_scenery->_animLeft);
 			}
 
 			if ((gobDesc->state == 10 || gobDesc->state == 11)
@@ -1762,10 +1762,10 @@
 		    gobDesc->xPos, gobDesc->yPos, 0);
 
 		gobDesc->yPos =
-		    (_vm->_map->_curGoblinY + 1) * 6 - (_vm->_scenery->toRedrawBottom -
-		    _vm->_scenery->animTop);
+		    (_vm->_map->_curGoblinY + 1) * 6 - (_vm->_scenery->_toRedrawBottom -
+		    _vm->_scenery->_animTop);
 		gobDesc->xPos =
-		    _vm->_map->_curGoblinX * 12 - (_vm->_scenery->toRedrawLeft - _vm->_scenery->animLeft);
+		    _vm->_map->_curGoblinX * 12 - (_vm->_scenery->_toRedrawLeft - _vm->_scenery->_animLeft);
 
 		if ((gobDesc->state == 10 || gobDesc->state == 11)
 		    && _currentGoblin != 0)
@@ -1785,7 +1785,7 @@
 
 	layer = gobDesc->stateMach[gobDesc->state][0]->layer;
 	framesCount =
-	    _vm->_scenery->animations[gobDesc->animation].layers[layer]->framesCount;
+	    _vm->_scenery->_animations[gobDesc->animation].layers[layer]->framesCount;
 
 	if (VAR(59) == 0 &&
 	    gobDesc->state != 30 && gobDesc->state != 31) {
@@ -2152,14 +2152,14 @@
 	    itemDesc->xPos, itemDesc->yPos, 0);
 
 	itemDesc->yPos +=
-	    (_gobPositions[0].y * 6) + 5 - _vm->_scenery->toRedrawBottom;
+	    (_gobPositions[0].y * 6) + 5 - _vm->_scenery->_toRedrawBottom;
 
 	if (lookDir == 4) {
 		itemDesc->xPos += (_gobPositions[0].x * 12 + 14)
-		    - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2;
+		    - (_vm->_scenery->_toRedrawLeft + _vm->_scenery->_toRedrawRight) / 2;
 	} else {
 		itemDesc->xPos += (_gobPositions[0].x * 12)
-		    - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2;
+		    - (_vm->_scenery->_toRedrawLeft + _vm->_scenery->_toRedrawRight) / 2;
 	}
 
 	_vm->_map->placeItem(xPos, yPos, idInPocket);
@@ -2272,14 +2272,14 @@
 	    placeObj->yPos, 0);
 
 	placeObj->yPos +=
-	    (_gobPositions[0].y * 6) + 5 - _vm->_scenery->toRedrawBottom;
+	    (_gobPositions[0].y * 6) + 5 - _vm->_scenery->_toRedrawBottom;
 
 	if (_vm->_map->_itemPoses[idToPlace].orient == 4) {
 		placeObj->xPos += (_gobPositions[0].x * 12 + 14)
-		    - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2;
+		    - (_vm->_scenery->_toRedrawLeft + _vm->_scenery->_toRedrawRight) / 2;
 	} else {
 		placeObj->xPos += (_gobPositions[0].x * 12)
-		    - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2;
+		    - (_vm->_scenery->_toRedrawLeft + _vm->_scenery->_toRedrawRight) / 2;
 	}
 }
 
@@ -2790,11 +2790,11 @@
 		    objDesc->xPos, objDesc->yPos, 0);
 
 		objDesc->yPos =
-		    (_gobPositions[item].y * 6 + 6) - (_vm->_scenery->toRedrawBottom -
-		    _vm->_scenery->animTop);
+		    (_gobPositions[item].y * 6 + 6) - (_vm->_scenery->_toRedrawBottom -
+		    _vm->_scenery->_animTop);
 		objDesc->xPos =
-		    _gobPositions[item].x * 12 - (_vm->_scenery->toRedrawLeft -
-		    _vm->_scenery->animLeft);
+		    _gobPositions[item].x * 12 - (_vm->_scenery->_toRedrawLeft -
+		    _vm->_scenery->_animLeft);
 
 		objDesc->curFrame = 0;
 		objDesc->state = 21;
@@ -2833,10 +2833,10 @@
 			layer = objDesc->stateMach[objDesc->state][0]->layer;
 
 			objDesc->xPos =
-			    _vm->_scenery->animations[objDesc->animation].layers[layer]->
+			    _vm->_scenery->_animations[objDesc->animation].layers[layer]->
 			    posX;
 			objDesc->yPos =
-			    _vm->_scenery->animations[objDesc->animation].layers[layer]->
+			    _vm->_scenery->_animations[objDesc->animation].layers[layer]->
 			    posY;
 
 			*_curGobScrXVarPtr = objDesc->xPos;
@@ -2861,9 +2861,9 @@
 		    objDesc->xPos, objDesc->yPos, 0);
 
 		objDesc->yPos =
-		    (yPos * 6 + 6) - (_vm->_scenery->toRedrawBottom - _vm->_scenery->animTop);
+		    (yPos * 6 + 6) - (_vm->_scenery->_toRedrawBottom - _vm->_scenery->_animTop);
 		objDesc->xPos =
-		    xPos * 12 - (_vm->_scenery->toRedrawLeft - _vm->_scenery->animLeft);
+		    xPos * 12 - (_vm->_scenery->_toRedrawLeft - _vm->_scenery->_animLeft);
 
 		_gobPositions[item].x = xPos;
 		_pressedMapX = xPos;
@@ -2900,9 +2900,9 @@
 		    objDesc->xPos, objDesc->yPos, 0);
 
 		objDesc->yPos =
-		    (yPos * 6 + 6) - (_vm->_scenery->toRedrawBottom - _vm->_scenery->animTop);
+		    (yPos * 6 + 6) - (_vm->_scenery->_toRedrawBottom - _vm->_scenery->_animTop);
 		objDesc->xPos =
-		    xPos * 12 - (_vm->_scenery->toRedrawLeft - _vm->_scenery->animLeft);
+		    xPos * 12 - (_vm->_scenery->_toRedrawLeft - _vm->_scenery->_animLeft);
 
 		objDesc->curFrame = 0;
 		objDesc->state = 21;
@@ -2929,9 +2929,9 @@
 		layer = objDesc->stateMach[objDesc->state][0]->layer;
 
 		objDesc->xPos =
-		    _vm->_scenery->animations[objDesc->animation].layers[layer]->posX;
+		    _vm->_scenery->_animations[objDesc->animation].layers[layer]->posX;
 		objDesc->yPos =
-		    _vm->_scenery->animations[objDesc->animation].layers[layer]->posY;
+		    _vm->_scenery->_animations[objDesc->animation].layers[layer]->posY;
 
 		if (item == _currentGoblin) {
 			*_curGobScrXVarPtr = objDesc->xPos;
@@ -2952,9 +2952,9 @@
 		nextLayer(objDesc);
 		layer = objDesc->stateMach[objDesc->state][0]->layer;
 		objDesc->xPos =
-		    _vm->_scenery->animations[objDesc->animation].layers[layer]->posX;
+		    _vm->_scenery->_animations[objDesc->animation].layers[layer]->posX;
 		objDesc->yPos =
-		    _vm->_scenery->animations[objDesc->animation].layers[layer]->posY;
+		    _vm->_scenery->_animations[objDesc->animation].layers[layer]->posY;
 
 		objDesc->toRedraw = 1;
 		objDesc->type = 0;
@@ -3203,10 +3203,10 @@
 			    gobDesc->xPos, gobDesc->yPos, 0);
 
 			gobDesc->yPos =
-			    (yPos * 6 + 6) - (_vm->_scenery->toRedrawBottom -
-			    _vm->_scenery->animTop);
+			    (yPos * 6 + 6) - (_vm->_scenery->_toRedrawBottom -
+			    _vm->_scenery->_animTop);
 			gobDesc->xPos =
-			    xPos * 12 - (_vm->_scenery->toRedrawLeft - _vm->_scenery->animLeft);
+			    xPos * 12 - (_vm->_scenery->_toRedrawLeft - _vm->_scenery->_animLeft);
 		}
 
 		if (gobDesc->state != 10)
@@ -3233,14 +3233,14 @@
 		    objDesc->xPos, objDesc->yPos, 0);
 
 		objDesc->yPos +=
-		    (_gobPositions[0].y * 6 + 5) - _vm->_scenery->toRedrawBottom;
+		    (_gobPositions[0].y * 6 + 5) - _vm->_scenery->_toRedrawBottom;
 
 		if (gobDesc->curLookDir == 4) {
 			objDesc->xPos += _gobPositions[0].x * 12 + 14
-			    - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2;
+			    - (_vm->_scenery->_toRedrawLeft + _vm->_scenery->_toRedrawRight) / 2;
 		} else {
 			objDesc->xPos += _gobPositions[0].x * 12
-			    - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2;
+			    - (_vm->_scenery->_toRedrawLeft + _vm->_scenery->_toRedrawRight) / 2;
 		}
 
 		_itemIndInPocket = -1;

Index: inter.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/inter.cpp,v
retrieving revision 1.31
retrieving revision 1.32
diff -u -d -r1.31 -r1.32
--- inter.cpp	8 Jan 2006 20:03:20 -0000	1.31
+++ inter.cpp	9 Jan 2006 16:10:22 -0000	1.32
@@ -274,7 +274,7 @@
 	*_nestLevel = 0;
 	*_breakFromLevel = -1;
 
-	*_vm->_scenery->pCaptureCounter = 0;
+	*_vm->_scenery->_pCaptureCounter = 0;
 
 	_breakFlag = false;
 	_terminate = false;

Index: inter_v1.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/inter_v1.cpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- inter_v1.cpp	8 Jan 2006 20:03:20 -0000	1.4
+++ inter_v1.cpp	9 Jan 2006 16:10:22 -0000	1.5
@@ -517,13 +517,13 @@
 	width = _vm->_parse->parseValExpr();
 	height = _vm->_parse->parseValExpr();
 	_vm->_game->capturePush(left, top, width, height);
-	(*_vm->_scenery->pCaptureCounter)++;
+	(*_vm->_scenery->_pCaptureCounter)++;
 	return false;
 }
 
 bool Inter_v1::o1_capturePop(char &cmdCount, int16 &counter, int16 &retFlag) {
-	if (*_vm->_scenery->pCaptureCounter != 0) {
-		(*_vm->_scenery->pCaptureCounter)--;
+	if (*_vm->_scenery->_pCaptureCounter != 0) {
+		(*_vm->_scenery->_pCaptureCounter)--;
 		_vm->_game->capturePop(1);
 	}
 	return false;

Index: map.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/map.cpp,v
retrieving revision 1.20
retrieving revision 1.21
diff -u -d -r1.20 -r1.21
--- map.cpp	7 Jan 2006 22:28:54 -0000	1.20
+++ map.cpp	9 Jan 2006 16:10:22 -0000	1.21
@@ -743,12 +743,12 @@
 		    _vm->_goblin->_goblins[i]->xPos, _vm->_goblin->_goblins[i]->yPos, 0);
 
 		_vm->_goblin->_goblins[i]->yPos = (_vm->_goblin->_gobPositions[i].y + 1) * 6 -
-		    (_vm->_scenery->toRedrawBottom - _vm->_scenery->animTop);
+		    (_vm->_scenery->_toRedrawBottom - _vm->_scenery->_animTop);
 
 		_vm->_goblin->_goblins[i]->xPos = _vm->_goblin->_gobPositions[i].x * 12 -
-		    (_vm->_scenery->toRedrawLeft - _vm->_scenery->animLeft);
+		    (_vm->_scenery->_toRedrawLeft - _vm->_scenery->_animLeft);
 
-		_vm->_goblin->_goblins[i]->order = _vm->_scenery->toRedrawBottom / 24 + 3;
+		_vm->_goblin->_goblins[i]->order = _vm->_scenery->_toRedrawBottom / 24 + 3;
 	}
 
 	_vm->_goblin->_currentGoblin = 0;

Index: mult.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/mult.cpp,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -d -r1.16 -r1.17
--- mult.cpp	7 Jan 2006 22:28:54 -0000	1.16
+++ mult.cpp	9 Jan 2006 16:10:22 -0000	1.17
@@ -36,80 +36,80 @@
 namespace Gob {
 
 Mult::Mult(GobEngine *vm) : _vm(vm) {
-	objects = 0;
-	renderData = 0;
-	objCount = 0;
-	underAnimSurf = 0;
-	multData = 0;
-	frame = 0;
-	doPalSubst = 0;
-	counter = 0;
[...1367 lines suppressed...]
-		free(animArrayData);
-		animArrayData = 0;
+		free(_animArrayData);
+		_animArrayData = 0;
 
 		if (_vm->_anim->_animSurf)
 			_vm->_video->freeSurfDesc(_vm->_anim->_animSurf);
 		_vm->_anim->_animSurf = 0;
 
-		animDataAllocated = 0;
+		_animDataAllocated = 0;
 	}
 }
 
 void Mult::checkFreeMult(void) {
-	if (multData != 0)
+	if (_multData != 0)
 		freeMultKeys();
 }
 

Index: mult.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/mult.h,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- mult.h	3 Jan 2006 23:14:39 -0000	1.7
+++ mult.h	9 Jan 2006 16:10:22 -0000	1.8
@@ -107,70 +107,70 @@
 
 	// Globals
 
-	Mult_Object *objects;
-	int16 *renderData;
-	int16 objCount;
-	Video::SurfaceDesc *underAnimSurf;
+	Mult_Object *_objects;
+	int16 *_renderData;
+	int16 _objCount;
+	Video::SurfaceDesc *_underAnimSurf;
 
-	char *multData;
-	int16 frame;
-	char doPalSubst;
-	int16 counter;
-	int16 frameRate;
+	char *_multData;
+	int16 _frame;
+	char _doPalSubst;
+	int16 _counter;
+	int16 _frameRate;
 
-	int32 *animArrayX;
-	int32 *animArrayY;
+	int32 *_animArrayX;
+	int32 *_animArrayY;
 
-	Mult_AnimData *animArrayData;
+	Mult_AnimData *_animArrayData;
 
-	int16 index;
+	int16 _index;
 
 	// Static keys
-	int16 staticKeysCount;
-	Mult_StaticKey *staticKeys;
-	int16 staticIndices[10];
+	int16 _staticKeysCount;
+	Mult_StaticKey *_staticKeys;
+	int16 _staticIndices[10];
 
 	// Anim keys
-	Mult_AnimKey *animKeys[4];
-	int16 animKeysCount[4];
-	int16 animLayer;
-	int16 animIndices[10];
+	Mult_AnimKey *_animKeys[4];
+	int16 _animKeysCount[4];
+	int16 _animLayer;
+	int16 _animIndices[10];
 
 	// Text keys
-	int16 textKeysCount;
-	Mult_TextKey *textKeys;
+	int16 _textKeysCount;
+	Mult_TextKey *_textKeys;
 
-	int16 frameStart;
+	int16 _frameStart;
 
 	// Palette keys
-	int16 palKeyIndex;
-	int16 palKeysCount;
-	Mult_PalKey *palKeys;
-	Video::Color *oldPalette;
-	Video::Color palAnimPalette[256];
-	int16 palAnimKey;
-	int16 palAnimIndices[4];
-	int16 palAnimRed[4];
-	int16 palAnimGreen[4];
-	int16 palAnimBlue[4];
+	int16 _palKeyIndex;
+	int16 _palKeysCount;
+	Mult_PalKey *_palKeys;
+	Video::Color *_oldPalette;
+	Video::Color _palAnimPalette[256];
+	int16 _palAnimKey;
+	int16 _palAnimIndices[4];
+	int16 _palAnimRed[4];
+	int16 _palAnimGreen[4];
+	int16 _palAnimBlue[4];
 
 	// Palette fading
-	Mult_PalFadeKey *palFadeKeys;
-	int16 palFadeKeysCount;
-	char palFadingRed;
-	char palFadingGreen;
-	char palFadingBlue;
+	Mult_PalFadeKey *_palFadeKeys;
+	int16 _palFadeKeysCount;
+	char _palFadingRed;
+	char _palFadingGreen;
+	char _palFadingBlue;
 
-	char animDataAllocated;
+	char _animDataAllocated;
 
-	char *dataPtr;
-	int16 staticLoaded[10];
-	int16 animLoaded[10];
-	int16 sndSlotsCount;
+	char *_dataPtr;
+	int16 _staticLoaded[10];
+	int16 _animLoaded[10];
+	int16 _sndSlotsCount;
 
 	// Sound keys
-	int16 sndKeysCount;
-	Mult_SndKey *sndKeys;
+	int16 _sndKeysCount;
+	Mult_SndKey *_sndKeys;
 
 	void zeroMultData(void);
 	void loadMult(int16 resId);
@@ -191,7 +191,7 @@
 	Mult(GobEngine *vm);
 
 protected:
-	Video::Color fadePal[5][16];
+	Video::Color _fadePal[5][16];
 	GobEngine *_vm;
 
 	char drawStatics(char stop);

Index: scenery.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/scenery.cpp,v
retrieving revision 1.23
retrieving revision 1.24
diff -u -d -r1.23 -r1.24
--- scenery.cpp	7 Jan 2006 22:28:54 -0000	1.23
+++ scenery.cpp	9 Jan 2006 16:10:22 -0000	1.24
@@ -35,34 +35,34 @@
 
 Scenery::Scenery(GobEngine *vm) : _vm(vm) {
 	for (int i = 0; i < 20; i++) {
-		spriteRefs[i] = 0;
-		spriteResId[i] = 0;
+		_spriteRefs[i] = 0;
+		_spriteResId[i] = 0;
 	}
 	for (int i = 0; i < 70; i++ ) {
-		staticPictToSprite[i] = 0;
-		animPictToSprite[i] = 0;
+		_staticPictToSprite[i] = 0;
+		_animPictToSprite[i] = 0;
 	}
 	for (int i = 0; i < 10; i++) {
-		staticPictCount[i] = 0;
-		staticFromExt[i] = 0;
-		staticResId[i] = 0;
-		animPictCount[i] = 0;
-		animFromExt[i] = 0;
-		animResId[i] = 0;
+		_staticPictCount[i] = 0;
+		_staticFromExt[i] = 0;
+		_staticResId[i] = 0;
+		_animPictCount[i] = 0;
+		_animFromExt[i] = 0;
+		_animResId[i] = 0;
 	}
 
-	curStatic = 0;
-	curStaticLayer = 0;
+	_curStatic = 0;
+	_curStaticLayer = 0;
 
-	toRedrawLeft = 0;
-	toRedrawRight = 0;
-	toRedrawTop = 0;
-	toRedrawBottom = 0;
+	_toRedrawLeft = 0;
+	_toRedrawRight = 0;
+	_toRedrawTop = 0;
+	_toRedrawBottom = 0;
 
-	animTop = 0;
-	animLeft = 0;
+	_animTop = 0;
+	_animLeft = 0;
 
-	pCaptureCounter = 0;
+	_pCaptureCounter = 0;
 }
 
 int16 Scenery::loadStatic(char search) {
@@ -89,28 +89,28 @@
 	resId = _vm->_inter->load16();
 	if (search) {
 		for (i = 0; i < 10; i++) {
-			if (staticPictCount[i] != -1 && staticResId[i] == resId) {
-				_vm->_global->_inter_execPtr += 8 * staticPictCount[i];
+			if (_staticPictCount[i] != -1 && _staticResId[i] == resId) {
+				_vm->_global->_inter_execPtr += 8 * _staticPictCount[i];
 				return i;
 			}
 
-			if (staticPictCount[i] == -1 && i < sceneryIndex)
+			if (_staticPictCount[i] == -1 && i < sceneryIndex)
 				sceneryIndex = i;
 		}
 	}
 
-	staticPictCount[sceneryIndex] = picsCount;
-	staticResId[sceneryIndex] = resId;
+	_staticPictCount[sceneryIndex] = picsCount;
+	_staticResId[sceneryIndex] = resId;
 
 	if (resId >= 30000) {
-		staticFromExt[sceneryIndex] = 1;
+		_staticFromExt[sceneryIndex] = 1;
 		dataPtr = _vm->_game->loadExtData(resId, 0, 0);
 	} else {
-		staticFromExt[sceneryIndex] = 0;
+		_staticFromExt[sceneryIndex] = 0;
 		dataPtr = _vm->_game->loadTotResource(resId);
 	}
 
-	ptr = &statics[sceneryIndex];
+	ptr = &_statics[sceneryIndex];
 	ptr->dataPtr = dataPtr;
 
 	ptr->layersCount = (int16)READ_LE_UINT16(dataPtr);
@@ -153,22 +153,22 @@
 		height = _vm->_inter->load16();
 		sprResId = _vm->_inter->load16();
 		for (sprIndex = 0; sprIndex < 20; sprIndex++) {
-			if (spriteResId[sprIndex] == sprResId)
+			if (_spriteResId[sprIndex] == sprResId)
 				break;
 		}
 
 		if (sprIndex < 20) {
-			staticPictToSprite[7 * sceneryIndex + i] =
+			_staticPictToSprite[7 * sceneryIndex + i] =
 			    sprIndex;
-			spriteRefs[sprIndex]++;
+			_spriteRefs[sprIndex]++;
 		} else {
 			for (sprIndex = 19; _vm->_draw->_spritesArray[sprIndex] != 0;
 			    sprIndex--);
 
-			staticPictToSprite[7 * sceneryIndex + i] =
+			_staticPictToSprite[7 * sceneryIndex + i] =
 			    sprIndex;
-			spriteRefs[sprIndex] = 1;
-			spriteResId[sprIndex] = sprResId;
+			_spriteRefs[sprIndex] = 1;
+			_spriteResId[sprIndex] = sprResId;
 			_vm->_draw->_spritesArray[sprIndex] =
 			    _vm->_video->initSurfDesc(_vm->_global->_videoMode, width, height, 2);
 
@@ -191,30 +191,30 @@
 	if (index == -1)
 		_vm->_inter->evalExpr(&index);
 
-	if (staticPictCount[index] == -1)
+	if (_staticPictCount[index] == -1)
 		return;
 
-	for (i = 0; i < staticPictCount[index]; i++) {
-		if (statics[index].piecesFromExt[i] == 1)
-			free(statics[index].pieces[i]);
+	for (i = 0; i < _staticPictCount[index]; i++) {
+		if (_statics[index].piecesFromExt[i] == 1)
+			free(_statics[index].pieces[i]);
 
-		spr = staticPictToSprite[index * 7 + i];
-		spriteRefs[spr]--;
-		if (spriteRefs[spr] == 0) {
+		spr = _staticPictToSprite[index * 7 + i];
+		_spriteRefs[spr]--;
+		if (_spriteRefs[spr] == 0) {
 			_vm->_video->freeSurfDesc(_vm->_draw->_spritesArray[spr]);
 			_vm->_draw->_spritesArray[spr] = 0;
-			spriteResId[spr] = -1;
+			_spriteResId[spr] = -1;
 		}
 	}
 
-	free(statics[index].layers);
-	free(statics[index].pieces);
-	free(statics[index].piecesFromExt);
-	if (staticFromExt[index] == 1)
-		free(statics[index].dataPtr);
+	free(_statics[index].layers);
+	free(_statics[index].pieces);
+	free(_statics[index].piecesFromExt);
+	if (_staticFromExt[index] == 1)
+		free(_statics[index].dataPtr);
 
-	staticFromExt[index] = 0;
-	staticPictCount[index] = -1;
+	_staticFromExt[index] = 0;
+	_staticPictCount[index] = -1;
 }
 
 void Scenery::renderStatic(int16 scenery, int16 layer) {
@@ -233,7 +233,7 @@
 	int16 top;
 	int16 bottom;
 
-	ptr = &statics[scenery];
+	ptr = &_statics[scenery];
 	if (layer >= ptr->layersCount)
 		return;
 
@@ -266,7 +266,7 @@
 			bottom = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].bottom);
 
 			_vm->_draw->_sourceSurface =
-			    staticPictToSprite[scenery * 7 + pictIndex];
+			    _staticPictToSprite[scenery * 7 + pictIndex];
 			_vm->_draw->_destSurface = 21;
 			_vm->_draw->_spriteLeft = left;
 			_vm->_draw->_spriteTop = top;
@@ -288,8 +288,8 @@
 }
 
 void Scenery::interLoadCurLayer(void) {
-	_vm->_inter->evalExpr(&curStatic);
-	_vm->_inter->evalExpr(&curStaticLayer);
+	_vm->_inter->evalExpr(&_curStatic);
+	_vm->_inter->evalExpr(&_curStaticLayer);
 }
 
 void Scenery::updateStatic(int16 orderFrom) {
@@ -307,14 +307,14 @@
 	int16 top;
 	int16 bottom;
 
-	if (curStatic == -1)
+	if (_curStatic == -1)
 		return;
 
-	if (curStaticLayer >= statics[curStatic].layersCount)
+	if (_curStaticLayer >= _statics[_curStatic].layersCount)
 		return;
 
-	layerPtr = statics[curStatic].layers[curStaticLayer];
-	pictPtr = statics[curStatic].pieces;
+	layerPtr = _statics[_curStatic].layers[_curStaticLayer];
+	pictPtr = _statics[_curStatic].pieces;
 
 	planeCount = layerPtr->planeCount;
 
@@ -334,20 +334,20 @@
 			top = FROM_LE_16(pictPtr[pictIndex][pieceIndex].top);
 			bottom = FROM_LE_16(pictPtr[pictIndex][pieceIndex].bottom);
 
-			if (_vm->_draw->_destSpriteX > toRedrawRight)
+			if (_vm->_draw->_destSpriteX > _toRedrawRight)
 				continue;
 
-			if (_vm->_draw->_destSpriteY > toRedrawBottom)
+			if (_vm->_draw->_destSpriteY > _toRedrawBottom)
 				continue;
 
-			if (_vm->_draw->_destSpriteX < toRedrawLeft) {
-				left += toRedrawLeft - _vm->_draw->_destSpriteX;
-				_vm->_draw->_destSpriteX = toRedrawLeft;
+			if (_vm->_draw->_destSpriteX < _toRedrawLeft) {
+				left += _toRedrawLeft - _vm->_draw->_destSpriteX;
+				_vm->_draw->_destSpriteX = _toRedrawLeft;
 			}
 
-			if (_vm->_draw->_destSpriteY < toRedrawTop) {
-				top += toRedrawTop - _vm->_draw->_destSpriteY;
-				_vm->_draw->_destSpriteY = toRedrawTop;
+			if (_vm->_draw->_destSpriteY < _toRedrawTop) {
+				top += _toRedrawTop - _vm->_draw->_destSpriteY;
+				_vm->_draw->_destSpriteY = _toRedrawTop;
 			}
 
 			_vm->_draw->_spriteLeft = left;
@@ -359,17 +359,17 @@
 				continue;
 
 			if (_vm->_draw->_destSpriteX + _vm->_draw->_spriteRight - 1 >
-			    toRedrawRight)
+			    _toRedrawRight)
 				_vm->_draw->_spriteRight =
-				    toRedrawRight - _vm->_draw->_destSpriteX + 1;
+				    _toRedrawRight - _vm->_draw->_destSpriteX + 1;
 
 			if (_vm->_draw->_destSpriteY + _vm->_draw->_spriteBottom - 1 >
-			    toRedrawBottom)
+			    _toRedrawBottom)
 				_vm->_draw->_spriteBottom =
-				    toRedrawBottom - _vm->_draw->_destSpriteY + 1;
+				    _toRedrawBottom - _vm->_draw->_destSpriteY + 1;
 
 			_vm->_draw->_sourceSurface =
-			    staticPictToSprite[curStatic * 7 +
+			    _staticPictToSprite[_curStatic * 7 +
 			    pictIndex];
 			_vm->_draw->_destSurface = 21;
 			_vm->_draw->_transparency = planePtr->transp ? 3 : 0;
@@ -405,29 +405,29 @@
 
 	if (search) {
 		for (i = 0; i < 10; i++) {
-			if (animPictCount[i] != 0
-			    && animResId[i] == resId) {
-				_vm->_global->_inter_execPtr += 8 * animPictCount[i];
+			if (_animPictCount[i] != 0
+			    && _animResId[i] == resId) {
+				_vm->_global->_inter_execPtr += 8 * _animPictCount[i];
 				return i;
 			}
 
-			if (animPictCount[i] == 0 && i < sceneryIndex)
+			if (_animPictCount[i] == 0 && i < sceneryIndex)
 				sceneryIndex = i;
 		}
 	}
 
-	animPictCount[sceneryIndex] = picsCount;
-	animResId[sceneryIndex] = resId;
+	_animPictCount[sceneryIndex] = picsCount;
+	_animResId[sceneryIndex] = resId;
 
 	if (resId >= 30000) {
-		animFromExt[sceneryIndex] = 1;
+		_animFromExt[sceneryIndex] = 1;
 		dataPtr = _vm->_game->loadExtData(resId, 0, 0);
 	} else {
-		animFromExt[sceneryIndex] = 0;
+		_animFromExt[sceneryIndex] = 0;
 		dataPtr = _vm->_game->loadTotResource(resId);
 	}
 
-	ptr = &animations[sceneryIndex];
+	ptr = &_animations[sceneryIndex];
 	ptr->dataPtr = dataPtr;
 
 	ptr->layersCount = READ_LE_UINT16(dataPtr);
@@ -471,20 +471,20 @@
 		height = _vm->_inter->load16();
 		sprResId = _vm->_inter->load16();
 		for (sprIndex = 0; sprIndex < 20; sprIndex++) {
-			if (spriteResId[sprIndex] == sprResId)
+			if (_spriteResId[sprIndex] == sprResId)
 				break;
 		}
 
 		if (sprIndex < 20) {
-			animPictToSprite[7 * sceneryIndex + i] = sprIndex;
-			spriteRefs[sprIndex]++;
+			_animPictToSprite[7 * sceneryIndex + i] = sprIndex;
+			_spriteRefs[sprIndex]++;
 		} else {
 			for (sprIndex = 19; _vm->_draw->_spritesArray[sprIndex] != 0;
 			    sprIndex--);
 
-			animPictToSprite[7 * sceneryIndex + i] = sprIndex;
-			spriteRefs[sprIndex] = 1;
-			spriteResId[sprIndex] = sprResId;
+			_animPictToSprite[7 * sceneryIndex + i] = sprIndex;
+			_spriteRefs[sprIndex] = 1;
+			_spriteResId[sprIndex] = sprResId;
 			_vm->_draw->_spritesArray[sprIndex] =
 			    _vm->_video->initSurfDesc(_vm->_global->_videoMode, width, height, 2);
 
@@ -527,10 +527,10 @@
 	int16 destX;
 	int16 destY;
 
-	if (layer >= animations[animation].layersCount)
+	if (layer >= _animations[animation].layersCount)
 		return;
 
-	layerPtr = animations[animation].layers[layer];
+	layerPtr = _animations[animation].layers[layer];
 
 	if (frame >= layerPtr->framesCount)
 		return;
@@ -540,16 +540,16 @@
 		updateAnim(layer, frame, animation, 0, drawDeltaX,
 		    drawDeltaY, 0);
 
-		if (toRedrawLeft == -12345)	// Some magic number?
+		if (_toRedrawLeft == -12345)	// Some magic number?
 			return;
 
-		_vm->_game->capturePush(toRedrawLeft, toRedrawTop,
-		    toRedrawRight - toRedrawLeft + 1,
-		    toRedrawBottom - toRedrawTop + 1);
+		_vm->_game->capturePush(_toRedrawLeft, _toRedrawTop,
+		    _toRedrawRight - _toRedrawLeft + 1,
+		    _toRedrawBottom - _toRedrawTop + 1);
 
-		*pCaptureCounter = *pCaptureCounter + 1;
+		*_pCaptureCounter = *_pCaptureCounter + 1;
 	}
-	pictPtr = animations[animation].pieces;
+	pictPtr = _animations[animation].pieces;
 	framePtr = layerPtr->frames;
 
 	for (i = 0; i < frame; i++, framePtr++) {
@@ -558,17 +558,17 @@
 	}
 
 	if ((flags & 4) == 0) {
-		toRedrawLeft = -12345;
+		_toRedrawLeft = -12345;
 	} else {
-		toRedrawLeft =
-		    MAX(toRedrawLeft, _vm->_anim->_areaLeft);
-		toRedrawTop =
-		    MAX(toRedrawTop, _vm->_anim->_areaTop);
-		toRedrawRight =
-		    MIN(toRedrawRight,
+		_toRedrawLeft =
+		    MAX(_toRedrawLeft, _vm->_anim->_areaLeft);
+		_toRedrawTop =
+		    MAX(_toRedrawTop, _vm->_anim->_areaTop);
+		_toRedrawRight =
+		    MIN(_toRedrawRight,
 		    (int16)(_vm->_anim->_areaLeft + _vm->_anim->_areaWidth - 1));
-		toRedrawBottom =
-		    MIN(toRedrawBottom,
+		_toRedrawBottom =
+		    MIN(_toRedrawBottom,
 		    (int16)(_vm->_anim->_areaTop + _vm->_anim->_areaHeight - 1));
 	}
 
@@ -643,25 +643,25 @@
 				    1;
 
 		} else if (flags & 4) {
-			if (destX < toRedrawLeft) {
-				left += toRedrawLeft - destX;
-				destX = toRedrawLeft;
+			if (destX < _toRedrawLeft) {
+				left += _toRedrawLeft - destX;
+				destX = _toRedrawLeft;
 			}
 
 			if (left <= right
-			    && destX + right - left > toRedrawRight)
+			    && destX + right - left > _toRedrawRight)
 				right -=
-				    destX + right - left - toRedrawRight;
+				    destX + right - left - _toRedrawRight;
 
-			if (destY < toRedrawTop) {
-				top += toRedrawTop - destY;
-				destY = toRedrawTop;
+			if (destY < _toRedrawTop) {
+				top += _toRedrawTop - destY;
+				destY = _toRedrawTop;
 			}
 
 			if (top <= bottom
-			    && destY + bottom - top > toRedrawBottom)
+			    && destY + bottom - top > _toRedrawBottom)
 				bottom -=
-				    destY + bottom - top - toRedrawBottom;
+				    destY + bottom - top - _toRedrawBottom;
 		}
 
 		if (left > right || top > bottom)
@@ -669,7 +669,7 @@
 
 		if (doDraw) {
 			_vm->_draw->_sourceSurface =
-			    animPictToSprite[animation * 7 + pictIndex];
+			    _animPictToSprite[animation * 7 + pictIndex];
 			_vm->_draw->_destSurface = 21;
 
 			_vm->_draw->_spriteLeft = left;
@@ -683,23 +683,23 @@
 		}
 
 		if ((flags & 4) == 0) {
-			if (toRedrawLeft == -12345) {
-				toRedrawLeft = destX;
-				animLeft = destX;
-				toRedrawTop = destY;
-				animTop = destY;
-				toRedrawRight = destX + right - left;
-				toRedrawBottom = destY + bottom - top;
+			if (_toRedrawLeft == -12345) {
+				_toRedrawLeft = destX;
+				_animLeft = destX;
+				_toRedrawTop = destY;
+				_animTop = destY;
+				_toRedrawRight = destX + right - left;
+				_toRedrawBottom = destY + bottom - top;
 			} else {
-				toRedrawLeft =
-				    MIN(toRedrawLeft, destX);
-				toRedrawTop =
-				    MIN(toRedrawTop, destY);
-				toRedrawRight =
-				    MAX(toRedrawRight,
+				_toRedrawLeft =
+				    MIN(_toRedrawLeft, destX);
+				_toRedrawTop =
+				    MIN(_toRedrawTop, destY);
+				_toRedrawRight =
+				    MAX(_toRedrawRight,
 				    (int16)(destX + right - left));
-				toRedrawBottom =
-				    MAX(toRedrawBottom,
+				_toRedrawBottom =
+				    MAX(_toRedrawBottom,
 				    (int16)(destY + bottom - top));
 			}
 		}
@@ -713,31 +713,31 @@
 	if (animation == -1)
 		_vm->_inter->evalExpr(&animation);
 
-	if (animPictCount[animation] == 0)
+	if (_animPictCount[animation] == 0)
 		return;
 
-	for (i = 0; i < animPictCount[animation]; i++) {
-		if (animations[animation].piecesFromExt[i] == 1)
-			free(animations[animation].pieces[i]);
+	for (i = 0; i < _animPictCount[animation]; i++) {
+		if (_animations[animation].piecesFromExt[i] == 1)
+			free(_animations[animation].pieces[i]);
 
-		spr = animPictToSprite[animation * 7 + i];
-		spriteRefs[spr]--;
-		if (spriteRefs[spr] == 0) {
+		spr = _animPictToSprite[animation * 7 + i];
+		_spriteRefs[spr]--;
+		if (_spriteRefs[spr] == 0) {
 			_vm->_video->freeSurfDesc(_vm->_draw->_spritesArray[spr]);
 
 			_vm->_draw->_spritesArray[spr] = 0;
-			spriteResId[spr] = -1;
+			_spriteResId[spr] = -1;
 		}
 	}
 
-	free(animations[animation].layers);
-	free(animations[animation].pieces);
-	free(animations[animation].piecesFromExt);
-	if (animFromExt[animation] == 1)
-		free(animations[animation].dataPtr);
+	free(_animations[animation].layers);
+	free(_animations[animation].pieces);
+	free(_animations[animation].piecesFromExt);
+	if (_animFromExt[animation] == 1)
+		free(_animations[animation].dataPtr);
 
-	animFromExt[animation] = 0;
-	animPictCount[animation] = 0;
+	_animFromExt[animation] = 0;
+	_animPictCount[animation] = 0;
 }
 
 void Scenery::interUpdateAnim(void) {
@@ -767,7 +767,7 @@
 
 	_vm->_inter->evalExpr(&animation);
 	_vm->_inter->evalExpr(&layer);
-	layerPtr = animations[animation].layers[layer];
+	layerPtr = _animations[animation].layers[layer];
 
 	var = _vm->_parse->parseVarIndex();
 	WRITE_VAR_OFFSET(var, layerPtr->animDeltaX);

Index: scenery.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/scenery.h,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- scenery.h	3 Jan 2006 23:14:39 -0000	1.8
+++ scenery.h	9 Jan 2006 16:10:22 -0000	1.9
@@ -93,33 +93,33 @@
 
 	// Global variables
 
-	char spriteRefs[20];
-	int16 spriteResId[20];
+	char _spriteRefs[20];
+	int16 _spriteResId[20];
 
-	char staticPictToSprite[70];
-	int16 staticPictCount[10];
-	Static statics[10];
-	char staticFromExt[10];
-	int16 staticResId[10];
+	char _staticPictToSprite[70];
+	int16 _staticPictCount[10];
+	Static _statics[10];
+	char _staticFromExt[10];
+	int16 _staticResId[10];
 
-	char animPictToSprite[70];
-	int16 animPictCount[10];
-	char animFromExt[10];
-	Animation animations[10];
-	int16 animResId[10];
+	char _animPictToSprite[70];
+	int16 _animPictCount[10];
+	char _animFromExt[10];
+	Animation _animations[10];
+	int16 _animResId[10];
 
-	int16 curStatic;
-	int16 curStaticLayer;
+	int16 _curStatic;
+	int16 _curStaticLayer;
 
-	int16 toRedrawLeft;
-	int16 toRedrawRight;
-	int16 toRedrawTop;
-	int16 toRedrawBottom;
+	int16 _toRedrawLeft;
+	int16 _toRedrawRight;
+	int16 _toRedrawTop;
+	int16 _toRedrawBottom;
 
-	int16 animTop;
-	int16 animLeft;
+	int16 _animTop;
+	int16 _animLeft;
 
-	int16 *pCaptureCounter;
+	int16 *_pCaptureCounter;
 
 	// Functions
 





More information about the Scummvm-git-logs mailing list