LAB: Renaming of Anim

7 files changed, 343 insertions, 352 deletions

diff --git a/engines/lab/anim.cpp b/engines/lab/anim.cpp
index 689f9038e3..908c4e4b19 100644
--- a/engines/lab/anim.cpp
+++ b/engines/lab/anim.cpp
@@ -38,46 +38,46 @@ extern byte **startoffile;
 extern BitMap *DispBitMap;
 
 Anim::Anim(LabEngine *vm) : _vm(vm) {
-	header = 0;
-	CurBit = 0;
-	numchunks = 1;
-	IsBM = false;
-	headerdata._width = 0;
-	headerdata._height = 0;
-	headerdata._fps = 0;
-	headerdata._flags = 0;
-	WaitSec = 0;
-	WaitMicros = 0;
-	DelayMicros = 0;
-	continuous = false;
-	IsPlaying = false;
-	IsAnim = false;
-	IsPal = false;
-	nopalchange = false;
-	donepal = false;
-	framenumber = 0;
-	PlayOnce = false;
-	Buffer = nullptr;
-	storagefordifffile = nullptr;
-	difffile = &storagefordifffile;
-	size = 0;
-	RawDiffBM._bytesPerRow = 0;
-	RawDiffBM._flags = 0;
+	_header = 0;
+	_curBit = 0;
+	_numChunks = 1;
+	_isBM = false;
+	_headerdata._width = 0;
+	_headerdata._height = 0;
+	_headerdata._fps = 0;
+	_headerdata._flags = 0;
+	_waitSec = 0;
+	_waitMicros = 0;
+	_delayMicros = 0;
+	_continuous = false;
+	_isPlaying = false;
+	_isAnim = false;
+	_isPal = false;
+	_noPalChange = false;
+	_donePal = false;
+	_frameNum = 0;
+	_playOnce = false;
+	_buffer = nullptr;
+	_storeDiffFile = nullptr;
+	_diffFile = &_storeDiffFile;
+	_size = 0;
+	_rawDiffBM._bytesPerRow = 0;
+	_rawDiffBM._flags = 0;
 	for (int i = 0; i < 16; i++)
-		RawDiffBM._planes[i] = nullptr;
-	RawDiffBM._rows = 0;
-	waitForEffect = false;
-	StopPlayingEnd = false;
-	samplespeed = 0;
-	DoBlack = false;
-	start = nullptr;
-	diffwidth = 0;
-	diffheight = 0;
-	stopsound = false;
+		_rawDiffBM._planes[i] = nullptr;
+	_rawDiffBM._rows = 0;
+	_waitForEffect = false;
+	_stopPlayingEnd = false;
+	_sampleSpeed = 0;
+	_doBlack = false;
+	_start = nullptr;
+	_diffWidth = 0;
+	_diffHeight = 0;
+	_stopSound = false;
 	_dataBytesPerRow = 0;
 
 	for (int i = 0; i < 3 * 256; i++)
-		diffcmap[i] = 0;
+		_diffPalette[i] = 0;
 
 }
 
@@ -192,14 +192,14 @@ bool Anim::unDIFFMemory(byte *dest, byte *diff, uint16 headerSize, uint16 copySi
 /* Undiffs a piece of memory when header size is a byte, and copy/skip size  */
 /* is a byte.                                                                */
 /*****************************************************************************/
-void Anim::VUnDIFFByteByte(byte *Dest, byte *diff, uint16 bytesperrow) {
-	byte *CurPtr;
+void Anim::VUnDIFFByteByte(byte *dest, byte *diff, uint16 bytesPerRow) {
+	byte *curPtr;
 	uint16 skip, copy;
 	uint16 counter = 0;
 
 
 	while (counter < _dataBytesPerRow) {
-		CurPtr = Dest + counter;
+		curPtr = dest + counter;
 
 		for (;;) {
 			skip = *diff;
@@ -213,12 +213,12 @@ void Anim::VUnDIFFByteByte(byte *Dest, byte *diff, uint16 bytesperrow) {
 			}
 
 			else {
-				CurPtr += (skip * bytesperrow);
+				curPtr += (skip * bytesPerRow);
 
 				while (copy) {
 					copy--;
-					*CurPtr = *diff;
-					CurPtr += bytesperrow;
+					*curPtr = *diff;
+					curPtr += bytesPerRow;
 					diff++;
 				}
 			}
@@ -230,16 +230,15 @@ void Anim::VUnDIFFByteByte(byte *Dest, byte *diff, uint16 bytesperrow) {
 /* Undiffs a piece of memory when header size is a byte, and copy/skip size  */
 /* is a word.                                                                */
 /*****************************************************************************/
-void Anim::VUnDIFFByteWord(uint16 *Dest, uint16 *diff, uint16 bytesperrow) {
-	uint16 *CurPtr;
+void Anim::VUnDIFFByteWord(uint16 *dest, uint16 *diff, uint16 bytesPerRow) {
+	uint16 *curPtr;
 	uint16 skip, copy;
-	uint16 counter = 0, wordsperrow;
-
+	uint16 counter = 0;
 
-	wordsperrow = bytesperrow / 2;
+	uint16 wordsPerRow = bytesPerRow / 2;
 
 	while (counter < (_dataBytesPerRow >> 1)) {
-		CurPtr = Dest + counter;
+		curPtr = dest + counter;
 
 		for (;;) {
 			skip = ((byte *)diff)[0];
@@ -254,11 +253,11 @@ void Anim::VUnDIFFByteWord(uint16 *Dest, uint16 *diff, uint16 bytesperrow) {
 			}
 
 			else {
-				CurPtr += (skip * wordsperrow);
+				curPtr += (skip * wordsPerRow);
 
 				while (copy) {
-					*CurPtr = *diff; //swapUShort(*diff);
-					CurPtr += wordsperrow;
+					*curPtr = *diff; //swapUShort(*diff);
+					curPtr += wordsPerRow;
 					diff++;
 					copy--;
 				}
@@ -271,17 +270,17 @@ void Anim::VUnDIFFByteWord(uint16 *Dest, uint16 *diff, uint16 bytesperrow) {
 /* Undiffs a piece of memory when header size is a byte, and copy/skip size  */
 /* is a long.                                                                */
 /*****************************************************************************/
-void Anim::VUnDIFFByteLong(uint32 *Dest, uint32 *diff, uint16 bytesperrow) {
-	uint32 *CurPtr;
+void Anim::VUnDIFFByteLong(uint32 *dest, uint32 *diff, uint16 bytesPerRow) {
+	uint32 *_curPtr;
 	uint16 skip, copy;
-	uint16 counter = 0, longsperrow;
-	byte *diff1 = (byte *)diff;
 
+	uint16 counter = 0;
+	byte *diff1 = (byte *)diff;
 
-	longsperrow = bytesperrow / 4;
+	uint16 longsperrow = bytesPerRow / 4;
 
 	while (counter < (_dataBytesPerRow >> 2)) {
-		CurPtr = Dest + counter;
+		_curPtr = dest + counter;
 
 		for (;;) {
 			skip = *diff1;
@@ -297,11 +296,11 @@ void Anim::VUnDIFFByteLong(uint32 *Dest, uint32 *diff, uint16 bytesperrow) {
 			}
 
 			else {
-				CurPtr += (skip * longsperrow);
+				_curPtr += (skip * longsperrow);
 
 				while (copy) {
-					*CurPtr = *(uint32 *)diff1; //swapULong(*diff);
-					CurPtr += longsperrow;
+					*_curPtr = *(uint32 *)diff1; //swapULong(*diff);
+					_curPtr += longsperrow;
 					diff1 += 4;
 					copy--;
 				}
@@ -313,17 +312,14 @@ void Anim::VUnDIFFByteLong(uint32 *Dest, uint32 *diff, uint16 bytesperrow) {
 /*****************************************************************************/
 /* UnDiffs a coded DIFF string onto an already initialized piece of memory.  */
 /*****************************************************************************/
-bool Anim::VUnDIFFMemory(byte *Dest, byte *diff, uint16 HeaderSize, uint16 CopySize, uint16 bytesperrow) {
-	if (HeaderSize == 1) {
-		if (CopySize == 1)
-			VUnDIFFByteByte(Dest, diff, bytesperrow);
-
-		else if (CopySize == 2)
-			VUnDIFFByteWord((uint16 *)Dest, (uint16 *)diff, bytesperrow);
-
-		else if (CopySize == 4)
-			VUnDIFFByteLong((uint32 *)Dest, (uint32 *)diff, bytesperrow);
-
+bool Anim::VUnDIFFMemory(byte *dest, byte *diff, uint16 headerSize, uint16 copySize, uint16 bytesPerRow) {
+	if (headerSize == 1) {
+		if (copySize == 1)
+			VUnDIFFByteByte(dest, diff, bytesPerRow);
+		else if (copySize == 2)
+			VUnDIFFByteWord((uint16 *)dest, (uint16 *)diff, bytesPerRow);
+		else if (copySize == 4)
+			VUnDIFFByteLong((uint32 *)dest, (uint32 *)diff, bytesPerRow);
 		else
 			return false;
 	} else
@@ -335,29 +331,28 @@ bool Anim::VUnDIFFMemory(byte *Dest, byte *diff, uint16 HeaderSize, uint16 CopyS
 /*****************************************************************************/
 /* Runlength decodes a chunk of memory.                                      */
 /*****************************************************************************/
-void Anim::runLengthDecode(byte *Dest, byte *Source) {
+void Anim::runLengthDecode(byte *dest, byte *source) {
 	int8 num;
 	int16 count;
 
-
 	while (1) {
-		num = (int8)*Source;
-		Source++;
+		num = (int8)*source;
+		source++;
 
 		if (num == 127) {
 			return;
 		} else if (num > '\0') {
-			memcpy(Dest, Source, num);
-			Source += num;
-			Dest   += num;
+			memcpy(dest, source, num);
+			source += num;
+			dest   += num;
 		} else {
 			count = (int16)(-num);
-			num   = *Source;
-			Source++;
+			num   = *source;
+			source++;
 
 			while (count) {
-				*Dest = num;
-				Dest++;
+				*dest = num;
+				dest++;
 				count--;
 			}
 		}
@@ -367,40 +362,40 @@ void Anim::runLengthDecode(byte *Dest, byte *Source) {
 /*****************************************************************************/
 /* Does a vertical run length decode.                                        */
 /*****************************************************************************/
-void Anim::VRunLengthDecode(byte *Dest, byte *Source, uint16 bytesperrow) {
+void Anim::VRunLengthDecode(byte *dest, byte *source, uint16 bytesPerRow) {
 	int8 num;
 	int16 count;
-	byte *Top = Dest;
+	byte *top = dest;
 
 	for (uint16 i = 0; i < _dataBytesPerRow; i++) {
-		Dest = Top;
-		Dest += i;
+		dest = top;
+		dest += i;
 
-		num = (int8)*Source;
-		Source++;
+		num = (int8)*source;
+		source++;
 
 		while (num != 127) {
 			if (num > '\0') {
 				while (num) {
-					*Dest = *Source;
-					Source++;
-					Dest += bytesperrow;
+					*dest = *source;
+					source++;
+					dest += bytesPerRow;
 					num--;
 				}
 			} else {
 				count = (int16)(-num);
-				num   = (int8)*Source;
-				Source++;
+				num   = (int8)*source;
+				source++;
 
 				while (count) {
-					*Dest = num;
-					Dest += bytesperrow;
+					*dest = num;
+					dest += bytesPerRow;
 					count--;
 				}
 			}
 
-			num = *Source;
-			Source++;
+			num = *source;
+			source++;
 		}
 	}
 }
@@ -408,21 +403,19 @@ void Anim::VRunLengthDecode(byte *Dest, byte *Source, uint16 bytesperrow) {
 /*****************************************************************************/
 /* Does the undiffing between the bitmaps.                                   */
 /*****************************************************************************/
-void Anim::unDiff(byte *NewBuf, byte *OldBuf, byte *DiffData, uint16 bytesperrow, bool IsV) {
-	byte buftype;
+void Anim::unDiff(byte *newBuf, byte *oldBuf, byte *diffData, uint16 bytesPerRow, bool isV) {
+	diffData++;
+	byte bufType = *diffData;
+	diffData++;
 
-	DiffData++;
-	buftype  = *DiffData;
-	DiffData++;
-
-	if (IsV)
-		VUnDIFFMemory(NewBuf, DiffData, 1, buftype + 1, bytesperrow);
+	if (isV)
+		VUnDIFFMemory(newBuf, diffData, 1, bufType + 1, bytesPerRow);
 	else
-		unDIFFMemory(NewBuf, DiffData, 1, buftype + 1);
+		unDIFFMemory(newBuf, diffData, 1, bufType + 1);
 }
 
 void Anim::diffNextFrame() {
-	if (header == 65535)  /* Already done. */
+	if (_header == 65535)  /* Already done. */
 		return;
 
 	if (DispBitMap->_flags & BITMAPF_VIDEO) {
@@ -436,37 +429,37 @@ void Anim::diffNextFrame() {
 	_vm->_event->mouseHide();
 
 	while (1) {
-		if (CurBit >= numchunks) {
+		if (_curBit >= _numChunks) {
 			_vm->_event->mouseShow();
 
-			if (!IsBM) {
-				if (headerdata._fps) {
-					_vm->waitForTime(WaitSec, WaitMicros);
-					_vm->addCurTime(0L, DelayMicros, &WaitSec, &WaitMicros);
+			if (!_isBM) {
+				if (_headerdata._fps) {
+					_vm->waitForTime(_waitSec, _waitMicros);
+					_vm->addCurTime(0L, _delayMicros, &_waitSec, &_waitMicros);
 				}
 
-				if (IsPal && !nopalchange) {
-					_vm->setPalette(diffcmap, 256);
-					IsPal = false;
+				if (_isPal && !_noPalChange) {
+					_vm->setPalette(_diffPalette, 256);
+					_isPal = false;
 				}
 
-				donepal = true;
+				_donePal = true;
 			}
 
-			if (IsPal && !nopalchange && !IsBM && !donepal) {
-				_vm->setPalette(diffcmap, 256);
-				IsPal = false;
+			if (_isPal && !_noPalChange && !_isBM && !_donePal) {
+				_vm->setPalette(_diffPalette, 256);
+				_isPal = false;
 			}
 
-			donepal = false;
+			_donePal = false;
 
-			framenumber++;
+			_frameNum++;
 
-			if ((framenumber == 1) && (continuous || (!PlayOnce)))
-				Buffer = *difffile;
+			if ((_frameNum == 1) && (_continuous || (!_playOnce)))
+				_buffer = *_diffFile;
 
-			IsAnim = (framenumber >= 3) && (!PlayOnce);
-			CurBit = 0;
+			_isAnim = (_frameNum >= 3) && (!_playOnce);
+			_curBit = 0;
 
 			if (DispBitMap->_flags & BITMAPF_VIDEO)
 				_vm->screenUpdate();
@@ -475,92 +468,92 @@ void Anim::diffNextFrame() {
 		}
 
 		_vm->_music->updateMusic();
-		header = READ_LE_UINT32(*difffile);
-		*difffile += 4;
+		_header = READ_LE_UINT32(*_diffFile);
+		*_diffFile += 4;
 
-		size = READ_LE_UINT32(*difffile);
-		*difffile += 4;
+		_size = READ_LE_UINT32(*_diffFile);
+		*_diffFile += 4;
 
-		switch (header) {
+		switch (_header) {
 		case 8L:
-			readBlock(diffcmap, size, difffile);
-			IsPal = true;
+			readBlock(_diffPalette, _size, _diffFile);
+			_isPal = true;
 			break;
 
 		case 10L:
-			RawDiffBM._planes[CurBit] = *difffile;
+			_rawDiffBM._planes[_curBit] = *_diffFile;
 
-			if (IsBM)
-				(*difffile) += size;
+			if (_isBM)
+				(*_diffFile) += _size;
 			else {
-				readBlock(DrawBitMap->_planes[CurBit], size, difffile);
+				readBlock(DrawBitMap->_planes[_curBit], _size, _diffFile);
 			}
 
-			CurBit++;
+			_curBit++;
 			break;
 
 		case 11L:
-			(*difffile) += 4;
-			runLengthDecode(DrawBitMap->_planes[CurBit], *difffile);
-			CurBit++;
-			(*difffile) += size - 4;
+			(*_diffFile) += 4;
+			runLengthDecode(DrawBitMap->_planes[_curBit], *_diffFile);
+			_curBit++;
+			(*_diffFile) += _size - 4;
 			break;
 
 		case 12L:
-			(*difffile) += 4;
-			VRunLengthDecode(DrawBitMap->_planes[CurBit], *difffile, DrawBitMap->_bytesPerRow);
-			CurBit++;
-			(*difffile) += size - 4;
+			(*_diffFile) += 4;
+			VRunLengthDecode(DrawBitMap->_planes[_curBit], *_diffFile, DrawBitMap->_bytesPerRow);
+			_curBit++;
+			(*_diffFile) += _size - 4;
 			break;
 
 		case 20L:
-			unDiff(DrawBitMap->_planes[CurBit], DispBitMap->_planes[CurBit], *difffile, DrawBitMap->_bytesPerRow, false);
-			CurBit++;
-			(*difffile) += size;
+			unDiff(DrawBitMap->_planes[_curBit], DispBitMap->_planes[_curBit], *_diffFile, DrawBitMap->_bytesPerRow, false);
+			_curBit++;
+			(*_diffFile) += _size;
 			break;
 
 		case 21L:
-			unDiff(DrawBitMap->_planes[CurBit], DispBitMap->_planes[CurBit], *difffile, DrawBitMap->_bytesPerRow, true);
-			CurBit++;
-			(*difffile) += size;
+			unDiff(DrawBitMap->_planes[_curBit], DispBitMap->_planes[_curBit], *_diffFile, DrawBitMap->_bytesPerRow, true);
+			_curBit++;
+			(*_diffFile) += _size;
 			break;
 
 		case 25L:
-			CurBit++;
+			_curBit++;
 			break;
 
 		case 26L:
-			CurBit++;
+			_curBit++;
 			break;
 
 		case 30L:
 		case 31L: {
-			if (waitForEffect) {
+			if (_waitForEffect) {
 				while (_vm->_music->isSoundEffectActive()) {
 					_vm->_music->updateMusic();
 					_vm->waitTOF();
 				}
 			}
 
-			size -= 8L;
+			_size -= 8L;
 
 
-			(*difffile) += 4;
-			samplespeed = READ_LE_UINT16(*difffile);
-			(*difffile) += 4;
+			(*_diffFile) += 4;
+			_sampleSpeed = READ_LE_UINT16(*_diffFile);
+			(*_diffFile) += 4;
 
-			byte *music = *difffile;
-			uint32 musicsize = size;
-			(*difffile) += size;
+			byte *music = *_diffFile;
+			uint32 musicsize = _size;
+			(*_diffFile) += _size;
 
-			_vm->_music->playSoundEffect(samplespeed, musicsize, music);
+			_vm->_music->playSoundEffect(_sampleSpeed, musicsize, music);
 			break;
 				  }
 		case 65535L:
-			if ((framenumber == 1) || PlayOnce || StopPlayingEnd) {
+			if ((_frameNum == 1) || _playOnce || _stopPlayingEnd) {
 				int didTOF = 0;
 
-				if (waitForEffect) {
+				if (_waitForEffect) {
 					while (_vm->_music->isSoundEffectActive()) {
 						_vm->_music->updateMusic();
 						_vm->waitTOF();
@@ -570,7 +563,7 @@ void Anim::diffNextFrame() {
 					}
 				}
 
-				IsPlaying = false;
+				_isPlaying = false;
 				_vm->_event->mouseShow();
 
 				if (!didTOF)
@@ -579,12 +572,12 @@ void Anim::diffNextFrame() {
 				return;
 			}
 
-			framenumber = 4;  /* Random frame number so it never gets back to 2 */
-			*difffile = Buffer;
+			_frameNum = 4;  /* Random frame number so it never gets back to 2 */
+			*_diffFile = _buffer;
 			break;
 
 		default:
-			(*difffile) += size;
+			(*_diffFile) += _size;
 			break;
 		}
 	}
@@ -594,92 +587,92 @@ void Anim::diffNextFrame() {
 /* A separate task launched by readDiff.  Plays the DIFF.                    */
 /*****************************************************************************/
 void Anim::playDiff() {
-	WaitSec   = 0L;
-	WaitMicros = 0L;
-	DelayMicros = 0L;
-	header      = 0;
-	CurBit = 0;
-	framenumber = 0;
-	numchunks   = 1;
-	donepal     = false;
-	StopPlayingEnd = false;
-	difffile    = &storagefordifffile;
-
-	IsPlaying   = true;
-
-	if (DoBlack) {
-		DoBlack = false;
+	_waitSec   = 0L;
+	_waitMicros = 0L;
+	_delayMicros = 0L;
+	_header      = 0;
+	_curBit = 0;
+	_frameNum = 0;
+	_numChunks   = 1;
+	_donePal     = false;
+	_stopPlayingEnd = false;
+	_diffFile    = &_storeDiffFile;
+
+	_isPlaying   = true;
+
+	if (_doBlack) {
+		_doBlack = false;
 		blackScreen();
 	}
 
-	start = *startoffile;            /* Make a copy of the pointer to the start of the file    */
-	*difffile = start;               /* Now can modify the file without modifying the original */
+	_start = *startoffile;            /* Make a copy of the pointer to the start of the file    */
+	*_diffFile = _start;               /* Now can modify the file without modifying the original */
 
-	if (start == NULL) {
-		IsPlaying = false;
+	if (_start == NULL) {
+		_isPlaying = false;
 		return;
 	}
 
-	continuous = false;
-	uint32 signature = READ_BE_UINT32(*difffile);
-	(*difffile) += 4;
+	_continuous = false;
+	uint32 signature = READ_BE_UINT32(*_diffFile);
+	(*_diffFile) += 4;
 
-	header = READ_LE_UINT32(*difffile);
-	(*difffile) += 4;
+	_header = READ_LE_UINT32(*_diffFile);
+	(*_diffFile) += 4;
 
-	if ((signature != MKTAG('D', 'I', 'F', 'F')) || (header != 1219009121L)) {
-		IsPlaying = false;
+	if ((signature != MKTAG('D', 'I', 'F', 'F')) || (_header != 1219009121L)) {
+		_isPlaying = false;
 		return;
 	}
 
-	header = READ_LE_UINT32(*difffile);
-	(*difffile) += 4;
+	_header = READ_LE_UINT32(*_diffFile);
+	(*_diffFile) += 4;
 
-	size = READ_LE_UINT32(*difffile);
-	(*difffile) += 4;
+	_size = READ_LE_UINT32(*_diffFile);
+	(*_diffFile) += 4;
 
-	if (header == 0) {
+	if (_header == 0) {
 		// sizeof(headerdata) != 18, but the padding might be at the end
-		headerdata._version = READ_LE_UINT16(*difffile);
-		(*difffile) += 2;
-		headerdata._width = READ_LE_UINT16(*difffile);
-		(*difffile) += 2;
-		headerdata._height = READ_LE_UINT16(*difffile);
-		(*difffile) += 2;
-		headerdata._depth = *difffile[0];
-		(*difffile)++;
-		headerdata._fps = *difffile[0];
-		(*difffile)++;
-		headerdata._bufferSize = READ_LE_UINT32(*difffile);
-		(*difffile) += 4;
-		headerdata._machine = READ_LE_UINT16(*difffile);
-		(*difffile) += 2;
-		headerdata._flags = READ_LE_UINT32(*difffile);
-		(*difffile) += 4;
-
-		(*difffile) += size - 18;
-
-		continuous = CONTINUOUS & headerdata._flags;
-		diffwidth = headerdata._width;
-		diffheight = headerdata._height;
-		_dataBytesPerRow = diffwidth;
-
-		numchunks = (((int32) diffwidth) * diffheight) / 0x10000;
-
-		if ((uint32)(numchunks * 0x10000) < (uint32)(((int32) diffwidth) * diffheight))
-			numchunks++;
+		_headerdata._version = READ_LE_UINT16(*_diffFile);
+		(*_diffFile) += 2;
+		_headerdata._width = READ_LE_UINT16(*_diffFile);
+		(*_diffFile) += 2;
+		_headerdata._height = READ_LE_UINT16(*_diffFile);
+		(*_diffFile) += 2;
+		_headerdata._depth = *_diffFile[0];
+		(*_diffFile)++;
+		_headerdata._fps = *_diffFile[0];
+		(*_diffFile)++;
+		_headerdata._bufferSize = READ_LE_UINT32(*_diffFile);
+		(*_diffFile) += 4;
+		_headerdata._machine = READ_LE_UINT16(*_diffFile);
+		(*_diffFile) += 2;
+		_headerdata._flags = READ_LE_UINT32(*_diffFile);
+		(*_diffFile) += 4;
+
+		(*_diffFile) += _size - 18;
+
+		_continuous = CONTINUOUS & _headerdata._flags;
+		_diffWidth = _headerdata._width;
+		_diffHeight = _headerdata._height;
+		_dataBytesPerRow = _diffWidth;
+
+		_numChunks = (((int32) _diffWidth) * _diffHeight) / 0x10000;
+
+		if ((uint32)(_numChunks * 0x10000) < (uint32)(((int32) _diffWidth) * _diffHeight))
+			_numChunks++;
 	} else {
 		return;
 	}
 
-	for (header = 0; header < 8; header++)
-		RawDiffBM._planes[header] = NULL;
+	for (_header = 0; _header < 8; _header++)
+		_rawDiffBM._planes[_header] = NULL;
 
-	if (headerdata._fps)
-		DelayMicros = ONESECOND / headerdata._fps;
+	if (_headerdata._fps)
+		_delayMicros = ONESECOND / _headerdata._fps;
 
-	if (PlayOnce) {
-		while (header != 65535)
+	if (_playOnce) {
+		while (_header != 65535)
 			diffNextFrame();
 	} else
 		diffNextFrame();
@@ -689,19 +682,17 @@ void Anim::playDiff() {
 /* Stops an animation from running.                                          */
 /*****************************************************************************/
 void Anim::stopDiff() {
-	if (IsPlaying) {
-		if (IsAnim)
-			blackScreen();
-	}
+	if (_isPlaying && _isAnim)
+		blackScreen();
 }
 
 /*****************************************************************************/
 /* Stops an animation from running.                                          */
 /*****************************************************************************/
 void Anim::stopDiffEnd() {
-	if (IsPlaying) {
-		StopPlayingEnd = true;
-		while (IsPlaying) {
+	if (_isPlaying) {
+		_stopPlayingEnd = true;
+		while (_isPlaying) {
 			g_lab->_music->updateMusic();
 			diffNextFrame();
 		}
@@ -712,14 +703,14 @@ void Anim::stopDiffEnd() {
 /* Stops the continuous sound from playing.                                  */
 /*****************************************************************************/
 void Anim::stopSound() {
-	stopsound = true;
+	_stopSound = true;
 }
 
 /*****************************************************************************/
 /* Reads in a DIFF file.                                                     */
 /*****************************************************************************/
-bool Anim::readDiff(bool playonce) {
-	PlayOnce = playonce;
+bool Anim::readDiff(bool playOnce) {
+	_playOnce = playOnce;
 	playDiff();
 	return true;
 }
diff --git a/engines/lab/anim.h b/engines/lab/anim.h
index 62c7e39a83..3fed57d929 100644
--- a/engines/lab/anim.h
+++ b/engines/lab/anim.h
@@ -63,29 +63,29 @@ class Anim {
 private:
 	LabEngine *_vm;
 
-	uint32 header;
-	uint16 CurBit;
-	uint16 numchunks;
-	uint32 WaitSec;
-	uint32 WaitMicros;
-	uint32 DelayMicros;
-	bool continuous;
-	bool IsPlaying;
-	bool IsAnim;
-	bool IsPal;
-	bool donepal;
-	uint16 framenumber;
-	bool PlayOnce;
-	byte *Buffer;
-	byte *storagefordifffile;
-	byte **difffile;
-	uint32 size;
-	bool StopPlayingEnd;
-	uint16 samplespeed;
-	byte *start;
-	uint32 diffwidth;
-	uint32 diffheight;
-	bool stopsound;
+	uint32 _header;
+	uint16 _curBit;
+	uint16 _numChunks;
+	uint32 _waitSec;
+	uint32 _waitMicros;
+	uint32 _delayMicros;
+	bool _continuous;
+	bool _isPlaying;
+	bool _isAnim;
+	bool _isPal;
+	bool _donePal;
+	uint16 _frameNum;
+	bool _playOnce;
+	byte *_buffer;
+	byte *_storeDiffFile;
+	byte **_diffFile;
+	uint32 _size;
+	bool _stopPlayingEnd;
+	uint16 _sampleSpeed;
+	byte *_start;
+	uint32 _diffWidth;
+	uint32 _diffHeight;
+	bool _stopSound;
 	uint16 _dataBytesPerRow;
 
 	void unDIFFByteByte(byte *dest, byte *diff);
@@ -97,24 +97,24 @@ private:
 public:
 	Anim(LabEngine *vm);
 
-	DIFFHeader headerdata;
-	char diffcmap[256 * 3];
-	bool IsBM;          /* Just fill in the RawDIFFBM structure */
-	bool waitForEffect; /* Wait for each sound effect to finish before continuing. */
-	bool DoBlack;       /* Black the screen before new picture  */
-	bool nopalchange;   /* Don't change the palette.            */
-	BitMap RawDiffBM;
+	DIFFHeader _headerdata;
+	char _diffPalette[256 * 3];
+	bool _isBM;          /* Just fill in the RawDIFFBM structure */
+	bool _waitForEffect; /* Wait for each sound effect to finish before continuing. */
+	bool _doBlack;       /* Black the screen before new picture  */
+	bool _noPalChange;   /* Don't change the palette.            */
+	BitMap _rawDiffBM;
 
-	void unDiff(byte *NewBuf, byte *OldBuf, byte *DiffData, uint16 bytesperrow, bool IsV);
+	void unDiff(byte *newBuf, byte *oldBuf, byte *diffData, uint16 bytesperrow, bool isV);
 	bool unDIFFMemory(byte *dest,           /* Where to Un-DIFF */
-                  byte *diff,           /* The DIFFed code. */
-                  uint16 headerSize,    /* Size of header (1, 2 or 4 bytes) (only supports 1 currently */
-                  uint16 copySize);     /* Size of minimum copy or skip. (1, 2 or 4 bytes) */
+					  byte *diff,           /* The DIFFed code. */
+					  uint16 headerSize,    /* Size of header (1, 2 or 4 bytes) (only supports 1 currently */
+					  uint16 copySize);     /* Size of minimum copy or skip. (1, 2 or 4 bytes) */
 
 	bool VUnDIFFMemory(byte *dest, byte *diff, uint16 headerSize, uint16 copySize, uint16 bytesPerRow);
 	void runLengthDecode(byte *dest, byte *source);
 	void VRunLengthDecode(byte *dest, byte *source, uint16 bytesPerRow);
-	bool readDiff(bool playonce);
+	bool readDiff(bool playOnce);
 	void diffNextFrame();
 	void readSound(bool waitTillFinished, Common::File *file);
 	void stopDiff();
diff --git a/engines/lab/engine.cpp b/engines/lab/engine.cpp
index e401e062ed..b8845412aa 100644
--- a/engines/lab/engine.cpp
+++ b/engines/lab/engine.cpp
@@ -447,17 +447,17 @@ static const char *getInvName(uint16 CurInv) {
 
 	else if (CurInv == WESTPAPERNUM) {
 		CurFileName = Inventory[CurInv].BInvName;
-		g_lab->_anim->nopalchange = true;
+		g_lab->_anim->_noPalChange = true;
 		readPict(CurFileName, false);
-		g_lab->_anim->nopalchange = false;
+		g_lab->_anim->_noPalChange = false;
 		doWestPaper();
 	}
 
 	else if (CurInv == NOTESNUM) {
 		CurFileName = Inventory[CurInv].BInvName;
-		g_lab->_anim->nopalchange = true;
+		g_lab->_anim->_noPalChange = true;
 		readPict(CurFileName, false);
-		g_lab->_anim->nopalchange = false;
+		g_lab->_anim->_noPalChange = false;
 		doNotes();
 	}
 
@@ -531,18 +531,18 @@ bool LabEngine::doUse(uint16 CurInv) {
 			_conditions->inclElement(LAMPON);
 		}
 
-		_anim->DoBlack = false;
-		_anim->waitForEffect = true;
+		_anim->_doBlack = false;
+		_anim->_waitForEffect = true;
 		readPict("Music:Click", true);
-		_anim->waitForEffect = false;
+		_anim->_waitForEffect = false;
 
-		_anim->DoBlack = false;
+		_anim->_doBlack = false;
 		Test = getInvName(CurInv);
 	} else if (CurInv == BELTNUM) {                    /* LAB: Labyrinth specific */
 		if (!_conditions->in(BELTGLOW))
 			_conditions->inclElement(BELTGLOW);
 
-		_anim->DoBlack = false;
+		_anim->_doBlack = false;
 		Test = getInvName(CurInv);
 	} else if (CurInv == WHISKEYNUM) {                 /* LAB: Labyrinth specific */
 		_conditions->inclElement(USEDHELMET);
@@ -782,7 +782,7 @@ bool LabEngine::from_crumbs(uint32 tmpClass, uint16 code, uint16 Qualifier, Comm
 	uint16 NewDir;
 
 
-	_anim->DoBlack = false;
+	_anim->_doBlack = false;
 
 	if ((msgClass == RAWKEY) && (!LongWinInFront)) {
 		if (code == 13) { /* The return key */
@@ -809,7 +809,7 @@ bool LabEngine::from_crumbs(uint32 tmpClass, uint16 code, uint16 Qualifier, Comm
 					if (Alternate) {
 						eatMessages();
 						Alternate = false;
-						_anim->DoBlack = true;
+						_anim->_doBlack = true;
 						DoNotDrawMessage = false;
 
 						MainDisplay = true;
@@ -888,7 +888,7 @@ bool LabEngine::from_crumbs(uint32 tmpClass, uint16 code, uint16 Qualifier, Comm
 			if ((actionMode == 4) && (gadgetId == 4) && (CPtr != NULL)) {
 				doMainView(&CPtr);
 
-				_anim->DoBlack = true;
+				_anim->_doBlack = true;
 				HCPtr = NULL;
 				CPtr = NULL;
 				mayShowCrumbIndicator();
@@ -897,7 +897,7 @@ bool LabEngine::from_crumbs(uint32 tmpClass, uint16 code, uint16 Qualifier, Comm
 				eatMessages();
 
 				Alternate = true;
-				_anim->DoBlack = true;
+				_anim->_doBlack = true;
 				DoNotDrawMessage = false;
 				interfaceOn(); /* Sets the correct gadget list */
 
@@ -958,7 +958,7 @@ bool LabEngine::from_crumbs(uint32 tmpClass, uint16 code, uint16 Qualifier, Comm
 				NewDir = Direction;
 				processArrow(&NewDir, gadgetId - 6);
 				doTurn(Direction, NewDir, &CPtr);
-				_anim->DoBlack = true;
+				_anim->_doBlack = true;
 				Direction = NewDir;
 				forceDraw = true;
 
@@ -969,9 +969,9 @@ bool LabEngine::from_crumbs(uint32 tmpClass, uint16 code, uint16 Qualifier, Comm
 
 				if (doGoForward(&CPtr)) {
 					if (OldRoomNum == _roomNum)
-						_anim->DoBlack = true;
+						_anim->_doBlack = true;
 				} else {
-					_anim->DoBlack = true;
+					_anim->_doBlack = true;
 					processArrow(&Direction, gadgetId - 6);
 
 					if (OldRoomNum != _roomNum) {
@@ -980,7 +980,7 @@ bool LabEngine::from_crumbs(uint32 tmpClass, uint16 code, uint16 Qualifier, Comm
 						CurFileName = " ";
 						forceDraw = true;
 					} else {
-						_anim->DoBlack = true;
+						_anim->_doBlack = true;
 						drawStaticMessage(kTextNoPath);
 					}
 				}
@@ -1031,12 +1031,12 @@ bool LabEngine::from_crumbs(uint32 tmpClass, uint16 code, uint16 Qualifier, Comm
 			}
 		}
 	} else if ((msgClass == GADGETUP) && Alternate) {
-		_anim->DoBlack = true;
+		_anim->_doBlack = true;
 
 		if (gadgetId == 0) {
 			eatMessages();
 			Alternate = false;
-			_anim->DoBlack = true;
+			_anim->_doBlack = true;
 			DoNotDrawMessage = false;
 
 			MainDisplay = true;
@@ -1135,7 +1135,7 @@ bool LabEngine::from_crumbs(uint32 tmpClass, uint16 code, uint16 Qualifier, Comm
 
 					eatMessages();
 					Alternate = false;
-					_anim->DoBlack = true;
+					_anim->_doBlack = true;
 					DoNotDrawMessage = false;
 
 					MainDisplay = true;
@@ -1203,7 +1203,7 @@ bool LabEngine::from_crumbs(uint32 tmpClass, uint16 code, uint16 Qualifier, Comm
 						drawStaticMessage(kTextNothing);
 				} else if (TempCPtr->GraphicName) {
 					if (*(TempCPtr->GraphicName)) {
-						_anim->DoBlack = true;
+						_anim->_doBlack = true;
 						CPtr = TempCPtr;
 					} else if (curPos.y < (VGAScaleY(149) + SVGACord(2)))
 						drawStaticMessage(kTextNothing);
@@ -1254,7 +1254,7 @@ bool LabEngine::from_crumbs(uint32 tmpClass, uint16 code, uint16 Qualifier, Comm
 	} else if ((msgClass == MOUSEBUTTONS) && (IEQUALIFIER_RBUTTON & Qualifier)) {
 		eatMessages();
 		Alternate = !Alternate;
-		_anim->DoBlack = true;
+		_anim->_doBlack = true;
 		DoNotDrawMessage = false;
 		MainDisplay = true;
 		interfaceOn(); /* Sets the correct gadget list */
@@ -1308,7 +1308,7 @@ void LabEngine::go() {
 		Intro intro;
 		intro.introSequence();
 	} else
-		_anim->DoBlack = true;
+		_anim->_doBlack = true;
 
 	if (mem) {
 		_event->mouseShow();
diff --git a/engines/lab/graphics.cpp b/engines/lab/graphics.cpp
index 16283eab5e..54a4f352c2 100644
--- a/engines/lab/graphics.cpp
+++ b/engines/lab/graphics.cpp
@@ -85,7 +85,7 @@ bool readMusic(const char *filename, bool waitTillFinished) {
 	if (!file)
 		return false;
 
-	g_lab->_anim->DoBlack = false;
+	g_lab->_anim->_doBlack = false;
 	g_lab->_anim->readSound(waitTillFinished, file);
 
 	return true;
@@ -474,23 +474,23 @@ void LabEngine::doScrollWipe(char *filename) {
 		waitTOF();
 	}
 
-	_anim->IsBM = true;
+	_anim->_isBM = true;
 	readPict(filename, true);
-	setPalette(_anim->diffcmap, 256);
-	_anim->IsBM = false;
-	byte *mem = _anim->RawDiffBM._planes[0];
+	setPalette(_anim->_diffPalette, 256);
+	_anim->_isBM = false;
+	byte *mem = _anim->_rawDiffBM._planes[0];
 
 	_music->updateMusic();
 	uint16 by = VGAScaleX(3);
 	uint16 nheight = height;
 
-	while (onrow < _anim->headerdata._height) {
+	while (onrow < _anim->_headerdata._height) {
 		_music->updateMusic();
 
 		if ((by > nheight) && nheight)
 			by = nheight;
 
-		if ((startline + by) > (_anim->headerdata._height - height - 1))
+		if ((startline + by) > (_anim->_headerdata._height - height - 1))
 			break;
 
 		if (nheight)
@@ -536,10 +536,10 @@ void LabEngine::doScrollBounce() {
 	_event->mouseHide();
 	int width = VGAScaleX(320);
 	int height = VGAScaleY(149) + SVGACord(2);
-	byte *mem = _anim->RawDiffBM._planes[0];
+	byte *mem = _anim->_rawDiffBM._planes[0];
 
 	_music->updateMusic();
-	int startline = _anim->headerdata._height - height - 1;
+	int startline = _anim->_headerdata._height - height - 1;
 
 	for (int i = 0; i < 5; i++) {
 		_music->updateMusic();
@@ -620,7 +620,7 @@ void LabEngine::doTransWipe(CloseDataPtr *cPtr, char *filename) {
 		CurFileName = getPictName(cPtr);
 
 	byte *BitMapMem = readPictToMem(CurFileName, _screenWidth, lastY + 5);
-	setPalette(_anim->diffcmap, 256);
+	setPalette(_anim->_diffPalette, 256);
 
 	if (BitMapMem) {
 		imSource.Width = _screenWidth;
diff --git a/engines/lab/intro.cpp b/engines/lab/intro.cpp
index a35984e623..adc4fd2efb 100644
--- a/engines/lab/intro.cpp
+++ b/engines/lab/intro.cpp
@@ -237,7 +237,7 @@ void Intro::nReadPict(const char *filename, bool playOnce) {
 	if (_quitIntro)
 		return;
 
-	g_lab->_anim->DoBlack = _introDoBlack;
+	g_lab->_anim->_doBlack = _introDoBlack;
 	g_lab->_anim->stopDiffEnd();
 	readPict(finalFileName.c_str(), playOnce);
 }
@@ -254,7 +254,7 @@ void Intro::introSequence() {
 		0x0CB3, 0x0DC4, 0x0DD6, 0x0EE7
 	};
 
-	g_lab->_anim->DoBlack = true;
+	g_lab->_anim->_doBlack = true;
 
 	if (g_lab->getPlatform() != Common::kPlatformWindows) {
 		nReadPict("EA0", true);
@@ -276,12 +276,12 @@ void Intro::introSequence() {
 
 	g_lab->_music->initMusic();
 
-	g_lab->_anim->nopalchange = true;
+	g_lab->_anim->_noPalChange = true;
 	if (g_lab->getPlatform() != Common::kPlatformWindows)
 		nReadPict("TNDcycle.pic", true);
 	else
 		nReadPict("TNDcycle2.pic", true);
-	g_lab->_anim->nopalchange = false;
+	g_lab->_anim->_noPalChange = false;
 
 	FadePalette = palette;
 
@@ -289,9 +289,9 @@ void Intro::introSequence() {
 		if (_quitIntro)
 			break;
 
-		palette[i] = ((g_lab->_anim->diffcmap[i * 3] >> 2) << 8) +
-		             ((g_lab->_anim->diffcmap[i * 3 + 1] >> 2) << 4) +
-		              (g_lab->_anim->diffcmap[i * 3 + 2] >> 2);
+		palette[i] = ((g_lab->_anim->_diffPalette[i * 3] >> 2) << 8) +
+		             ((g_lab->_anim->_diffPalette[i * 3 + 1] >> 2) << 4) +
+		              (g_lab->_anim->_diffPalette[i * 3 + 2] >> 2);
 	}
 
 	g_lab->_music->updateMusic();
@@ -346,14 +346,14 @@ void Intro::introSequence() {
 
 	TextFont *msgFont = g_lab->_resource->getFont("P:Map.fon");
 
-	g_lab->_anim->nopalchange = true;
+	g_lab->_anim->_noPalChange = true;
 	nReadPict("Intro.1", true);
-	g_lab->_anim->nopalchange = false;
+	g_lab->_anim->_noPalChange = false;
 
 	for (uint16 i = 0; i < 16; i++) {
-		palette[i] = ((g_lab->_anim->diffcmap[i * 3] >> 2) << 8) +
-		             ((g_lab->_anim->diffcmap[i * 3 + 1] >> 2) << 4) +
-		              (g_lab->_anim->diffcmap[i * 3 + 2] >> 2);
+		palette[i] = ((g_lab->_anim->_diffPalette[i * 3] >> 2) << 8) +
+		             ((g_lab->_anim->_diffPalette[i * 3 + 1] >> 2) << 4) +
+		              (g_lab->_anim->_diffPalette[i * 3 + 2] >> 2);
 	}
 
 	doPictText("i.1", msgFont, true);
@@ -393,11 +393,11 @@ void Intro::introSequence() {
 	if (!_quitIntro)
 		for (uint16 i = 0; i < 50; i++) {
 			for (uint16 idx = (8 * 3); idx < (255 * 3); idx++)
-				g_lab->_anim->diffcmap[idx] = 255 - g_lab->_anim->diffcmap[idx];
+				g_lab->_anim->_diffPalette[idx] = 255 - g_lab->_anim->_diffPalette[idx];
 
 			g_lab->_music->updateMusic();
 			g_lab->waitTOF();
-			g_lab->setPalette(g_lab->_anim->diffcmap, 256);
+			g_lab->setPalette(g_lab->_anim->_diffPalette, 256);
 			g_lab->waitTOF();
 			g_lab->waitTOF();
 		}
@@ -458,7 +458,7 @@ void Intro::introSequence() {
 	if (_quitIntro) {
 		g_lab->setAPen(0);
 		g_lab->rectFill(0, 0, g_lab->_screenWidth - 1, g_lab->_screenHeight - 1);
-		g_lab->_anim->DoBlack = true;
+		g_lab->_anim->_doBlack = true;
 	}
 
 	closeFont(msgFont);
diff --git a/engines/lab/processroom.cpp b/engines/lab/processroom.cpp
index 5807227c51..0145c83cd4 100644
--- a/engines/lab/processroom.cpp
+++ b/engines/lab/processroom.cpp
@@ -378,7 +378,7 @@ static void doActions(Action * APtr, CloseDataPtr *LCPtr) {
 
 		case NOUPDATE:
 			noupdatediff = true;
-			g_lab->_anim->DoBlack = false;
+			g_lab->_anim->_doBlack = false;
 			break;
 
 		case FORCEUPDATE:
@@ -444,7 +444,7 @@ static void doActions(Action * APtr, CloseDataPtr *LCPtr) {
 			g_lab->_roomNum   = APtr->Param1;
 			Direction = APtr->Param2 - 1;
 			*LCPtr      = NULL;
-			g_lab->_anim->DoBlack = true;
+			g_lab->_anim->_doBlack = true;
 			break;
 
 		case SETCLOSEUP:
@@ -554,17 +554,17 @@ static void doActions(Action * APtr, CloseDataPtr *LCPtr) {
 
 		case SPECIALCMD:
 			if (APtr->Param1 == 0)
-				g_lab->_anim->DoBlack = true;
+				g_lab->_anim->_doBlack = true;
 			else if (APtr->Param1 == 1)
-				g_lab->_anim->DoBlack = (CPtr == NULL);
+				g_lab->_anim->_doBlack = (CPtr == NULL);
 			else if (APtr->Param1 == 2)
-				g_lab->_anim->DoBlack = (CPtr != NULL);
+				g_lab->_anim->_doBlack = (CPtr != NULL);
 			else if (APtr->Param1 == 5) { /* inverse the palette */
 				for (uint16 idx = (8 * 3); idx < (255 * 3); idx++)
-					g_lab->_anim->diffcmap[idx] = 255 - g_lab->_anim->diffcmap[idx];
+					g_lab->_anim->_diffPalette[idx] = 255 - g_lab->_anim->_diffPalette[idx];
 
 				g_lab->waitTOF();
-				g_lab->setPalette(g_lab->_anim->diffcmap, 256);
+				g_lab->setPalette(g_lab->_anim->_diffPalette, 256);
 				g_lab->waitTOF();
 				g_lab->waitTOF();
 			} else if (APtr->Param1 == 4) { /* white the palette */
@@ -573,7 +573,7 @@ static void doActions(Action * APtr, CloseDataPtr *LCPtr) {
 				g_lab->waitTOF();
 			} else if (APtr->Param1 == 6) { /* Restore the palette */
 				g_lab->waitTOF();
-				g_lab->setPalette(g_lab->_anim->diffcmap, 256);
+				g_lab->setPalette(g_lab->_anim->_diffPalette, 256);
 				g_lab->waitTOF();
 				g_lab->waitTOF();
 			} else if (APtr->Param1 == 7) { /* Quick pause */
diff --git a/engines/lab/special.cpp b/engines/lab/special.cpp
index 6f70cb0f1a..2744d3de32 100644
--- a/engines/lab/special.cpp
+++ b/engines/lab/special.cpp
@@ -110,7 +110,7 @@ static byte *loadBackPict(const char *fileName, bool tomem) {
 	byte *res = NULL;
 
 	FadePalette = hipal;
-	g_lab->_anim->nopalchange = true;
+	g_lab->_anim->_noPalChange = true;
 
 	if (tomem)
 		res = readPictToMem(fileName, g_lab->_screenWidth, g_lab->_screenHeight);
@@ -118,12 +118,12 @@ static byte *loadBackPict(const char *fileName, bool tomem) {
 		readPict(fileName, true);
 
 	for (uint16 i = 0; i < 16; i++) {
-		hipal[i] = ((g_lab->_anim->diffcmap[i * 3] >> 2) << 8) +
-		           ((g_lab->_anim->diffcmap[i * 3 + 1] >> 2) << 4) +
-		           ((g_lab->_anim->diffcmap[i * 3 + 2] >> 2));
+		hipal[i] = ((g_lab->_anim->_diffPalette[i * 3] >> 2) << 8) +
+		           ((g_lab->_anim->_diffPalette[i * 3 + 1] >> 2) << 4) +
+		           ((g_lab->_anim->_diffPalette[i * 3 + 2] >> 2));
 	}
 
-	g_lab->_anim->nopalchange = false;
+	g_lab->_anim->_noPalChange = false;
 
 	return res;
 }
@@ -143,10 +143,10 @@ void showCombination(const char *filename) {
 	byte **buffer;
 
 	resetBuffer();
-	g_lab->_anim->DoBlack = true;
-	g_lab->_anim->nopalchange = true;
+	g_lab->_anim->_doBlack = true;
+	g_lab->_anim->_noPalChange = true;
 	readPict(filename, true);
-	g_lab->_anim->nopalchange = false;
+	g_lab->_anim->_noPalChange = false;
 
 	blackScreen();
 
@@ -159,7 +159,7 @@ void showCombination(const char *filename) {
 
 	doCombination();
 
-	g_lab->setPalette(g_lab->_anim->diffcmap, 256);
+	g_lab->setPalette(g_lab->_anim->_diffPalette, 256);
 }
 
 
@@ -286,10 +286,10 @@ void showTile(const char *filename, bool showsolution) {
 	byte **buffer;
 
 	resetBuffer();
-	g_lab->_anim->DoBlack = true;
-	g_lab->_anim->nopalchange = true;
+	g_lab->_anim->_doBlack = true;
+	g_lab->_anim->_noPalChange = true;
 	readPict(filename, true);
-	g_lab->_anim->nopalchange = false;
+	g_lab->_anim->_noPalChange = false;
 	blackScreen();
 
 	if (showsolution) {
@@ -310,7 +310,7 @@ void showTile(const char *filename, bool showsolution) {
 
 	doTile(showsolution);
 
-	g_lab->setPalette(g_lab->_anim->diffcmap, 256);
+	g_lab->setPalette(g_lab->_anim->_diffPalette, 256);
 }
 
 static void scrollRaster(int16 dx, int16 dy, uint16 x1, uint16 y1, uint16 x2, uint16 y2) {
@@ -424,7 +424,7 @@ static void changeTile(uint16 col, uint16 row) {
 
 		if (check) {
 			g_lab->_conditions->inclElement(BRICKOPEN);  /* unlocked combination */
-			g_lab->_anim->DoBlack = true;
+			g_lab->_anim->_doBlack = true;
 			check = readPict("p:Up/BDOpen", true);
 		}
 	}
@@ -457,7 +457,7 @@ void doNotes() {
 	char *ntext = g_lab->_resource->getText("Lab:Rooms/Notes");
 
 	flowText(noteFont, -2 + SVGACord(1), 0, 0, false, false, true, true, VGAScaleX(25) + SVGACord(15), VGAScaleY(50), VGAScaleX(295) - SVGACord(15), VGAScaleY(148), ntext);
-	g_lab->setPalette(g_lab->_anim->diffcmap, 256);
+	g_lab->setPalette(g_lab->_anim->_diffPalette, 256);
 
 	closeFont(noteFont);
 	delete[] ntext;
@@ -501,7 +501,7 @@ void doWestPaper() {
 	delete[] ntext;
 	closeFont(paperFont);
 
-	g_lab->setPalette(g_lab->_anim->diffcmap, 256);
+	g_lab->setPalette(g_lab->_anim->_diffPalette, 256);
 	freeAllStolenMem();
 }
 
@@ -673,14 +673,14 @@ void LabEngine::drawJournal(uint16 wipenum, bool needFade) {
 	if (needFade)
 		fade(true, 0);
 
-	g_lab->_anim->nopalchange = true;
+	g_lab->_anim->_noPalChange = true;
 	JBackImage.ImageData = readPictToMem("P:Journal.pic", _screenWidth, _screenHeight);
 	GotBackImage = true;
 
 	eatMessages();
 	_event->mouseShow();
 
-	g_lab->_anim->nopalchange = false;
+	g_lab->_anim->_noPalChange = false;
 }
 
 /*****************************************************************************/