[Scummvm-cvs-logs] CVS: scummvm/gob music.cpp,NONE,1.1 music.h,NONE,1.1 cdrom.cpp,1.6,1.7 draw.cpp,1.17,1.18 draw.h,1.8,1.9 game.cpp,1.31,1.32 game.h,1.7,1.8 gob.cpp,1.30,1.31 gob.h,1.14,1.15 goblin.cpp,1.27,1.28 goblin.h,1.7,1.8 init.cpp,1.14,1.15 inter.cpp,1.29,1.30 inter_v1.cpp,1.2,1.3 map.cpp,1.19,1.20 module.mk,1.6,1.7 mult.cpp,1.15,1.16 parse.cpp,1.17,1.18 scenery.cpp,1.22,1.23

Sven Hesse drmccoy at users.sourceforge.net
Sat Jan 7 14:30:02 CET 2006


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

Modified Files:
	cdrom.cpp draw.cpp draw.h game.cpp game.h gob.cpp gob.h 
	goblin.cpp goblin.h init.cpp inter.cpp inter_v1.cpp map.cpp 
	module.mk mult.cpp parse.cpp scenery.cpp 
Added Files:
	music.cpp music.h 
Log Message:
Added initial support for ADL music files; continued underscoring of member variables


--- NEW FILE: music.cpp ---
/* ScummVM - Scumm Interpreter
 * Copyright (C) 2006 The ScummVM project
 * Original ADL-Player source Copyright (C) 2004 by Dorian Gray
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * $Header: /cvsroot/scummvm/scummvm/gob/music.cpp,v 1.1 2006/01/07 22:28:54 drmccoy Exp $
 *
 */

#include "gob/music.h"
#include "gob/gob.h"

namespace Gob {

const unsigned char Music::_operators[] = {0, 1, 2, 8, 9, 10, 16, 17, 18};
const unsigned char Music::_volRegNums[] = { 
	3,  4,  5,
	11, 12, 13,
	19, 20, 21
};


Music::Music(GobEngine *vm) : _vm(vm) {
	_data = 0;
	_playPos = 0;
	_dataSize = 0;
	_rate = _vm->_mixer->getOutputRate();
	_opl = makeAdlibOPL(_rate);
	_vm->_mixer->setupPremix(this, Audio::Mixer::kMusicSoundType);
	_first = true;
	_ended = false;
	_playing = false;
	_looping = true;
	_samplesTillPoll = 0;

	setFreqs();
}

Music::~Music(void) {
	if (_data);
		delete _data;
	_vm->_mixer->setupPremix(0);
}

void Music::premixerCall(int16 *buf, uint len) {
	if (!_playing) {
		memset(buf, 0, 2 * len * sizeof(int16));
		return;
	}
	else {
		if (_first) {
			memset(buf, 0, 2 * len * sizeof(int16));
			pollMusic();
			return;
		}
		else {
			uint32 render;
			int16 *data = buf;
			uint datalen = len;
			while (datalen) {
				if(_samplesTillPoll) {
					render = (datalen > _samplesTillPoll) ? (_samplesTillPoll) : (datalen);
					datalen -= render;
					_samplesTillPoll -= render;
					YM3812UpdateOne(_opl, data, render);
					data += render;
				} else {
					pollMusic();
					if(_ended) {
						memset(data, 0, datalen * sizeof(int16));
						datalen = 0;
					}
				}
			}
		}
		if(_ended) {
			_first = true;
			_ended = false;
			_playPos = _data + 3 + (_data[1] + 1) * 0x38;
			_samplesTillPoll = 0;
			if(_looping) {
				reset();
				setVoices();
			}
			else
				_playing = false;
		}
		// Convert mono data to stereo
		for (int i = (len - 1); i >= 0; i--) {
			buf[2 * i] = buf[2 * i + 1] = buf[i];
		}
	}
}

void Music::writeOPL(byte reg, byte val) {
	debug(5, "writeOPL(%02X, %02X)", reg, val);
	OPLWriteReg(_opl, reg, val);
}

void Music::setFreqs(void) {
	byte lin;
	byte col;
	long val;

	// Run through the 11 channels
	for (lin = 0; lin < 11; lin ++) {
		_notes[lin] = 0;
		_notCol[lin] = 0;
		_notLin[lin] = 0;
		_notOn[lin] = false;
	} 
		
	// Run through the 25 lines
	for (lin = 0; lin < 25; lin ++) {
		// Run through the 12 columns
		for (col = 0; col < 12; col ++) {
			if (!col)
				val = (((0x2710L + lin * 0x18) * 0xCB78 / 0x3D090) << 0xE) * 9 / 0x1B503;
			_freqs[lin][col] = (short)((val + 4) >> 3);
			val = val * 0x6A / 0x64;
	//      val = val *  392 / 370;
		} 
	}
}

void Music::reset() {
	// Set frequencies and octave to 0; notes off
	for (int i = 0; i < 9; i++) {
		writeOPL(0xA0 | i, 0);
		writeOPL(0xB0 | i, 0);
		writeOPL(0xE0 | _operators[i]    , 0);
		writeOPL(0xE0 | _operators[i] + 3, 0);
	}

	// Authorize the control of the waveformes
	writeOPL(0x01, 0x20);
}

void Music::setVoices() {
	// Definitions of the 9 instruments
	for (int i = 0; i < 9; i++)
		setVoice(i, i, true);
}

void Music::setVoice(byte voice, byte instr, bool set) {
	unsigned short *strct;
	byte channel;

	// i = 0 :  0  1  2  3  4  5  6  7  8  9 10 11 12 26
	// i = 1 : 13 14 15 16 17 18 19 20 21 22 23 24 25 27
	for (int i = 0; i < 2; i++) {
		strct = (unsigned short*)(_data + 3 + instr * 0x38 + i * 0x1A);
		channel = _operators[voice] + i * 3;
		writeOPL(0xBD, 0x00);
		writeOPL(0x08, 0x00);
		writeOPL(0x40 | channel, ((strct[0] & 3) << 6) | (strct[8] & 0x3F));
		if (!i)
			writeOPL(0xC0 | voice  , ((strct[2] & 7) << 1) | (1 - (strct[12] & 1)));
		writeOPL(0x60 | channel, ((strct[3] & 0xF) << 4) | (strct[6] & 0xF));
		writeOPL(0x80 | channel, ((strct[4] & 0xF) << 4) | (strct[7] & 0xF));
		writeOPL(0x20 | channel, ((strct[9] & 1) << 7) |
			((strct[10] & 1) << 6) | ((strct[5] & 1) << 5) |
			((strct[11] & 1) << 4) |  (strct[1] & 0xF));
		if (!i)
			writeOPL(0xE0 | channel, (strct[26] & 3));
		else
			writeOPL(0xE0 | channel, (strct[14] & 3));
		if (i & set)
			writeOPL(0x40 | channel, 0);
	}
}

void Music::setKey(byte voice, byte note, bool on, bool spec) {
	short freq = 0;
	short octa = 0;

	// Instruction AX
	if (spec) {
		// 0x7F donne 0x16B;
		//     7F
		// <<   7 =  3F80
		// + E000 = 11F80
		// & FFFF =  1F80
		// *   19 = 31380
		// / 2000 =    18 => Ligne 18h, colonne  0 => freq 16B

		// 0x3A donne 0x2AF;
		//     3A
		// <<   7 =  1D00
		// + E000 =  FD00 négatif
		// *   19 = xB500
		// / 2000 =    -2 => Ligne 17h, colonne -1

		//     2E
		// <<   7 =  1700
		// + E000 =  F700 négatif
		// *   19 = x1F00
		// / 2000 =
		short a;
		short lin;
		short col;

		a = (note << 7) + 0xE000; // Volontairement tronqué
		a = (short)((long)a * 25 / 0x2000);
		if (a < 0) {
			col = - ((24 - a) / 25);
			lin = (-a % 25);
			if (lin)
				lin = 25 - lin;
		}
		else {
			col = a / 25;
			lin = a % 25;
		}

		_notCol[voice] = col;
		_notLin[voice] = lin;
		note = _notes[voice];
	}
	// Instructions 0X 9X 8X
	else {
		note -= 12;
		_notOn[voice] = on;
	}

	_notes[voice] = note;
	note += _notCol[voice];
	note = MIN(0x5F, note);
	octa = note / 12;
	freq = _freqs[_notLin[voice]][note - octa * 12];

	writeOPL(0xA0 + voice,  freq & 0xff);
	writeOPL(0xB0 + voice, (freq >> 8) | (octa << 2) | 0x20 * on);

	if (!freq)
		warning("Voice %d, note %02X unknown\n", voice, note);
}

void Music::setVolume(byte voice, byte volume) {
	volume = 0x3F - (volume * 0x7E + 0x7F) / 0xFE;
	writeOPL(0x40 + _volRegNums[voice], volume);
}

void Music::pollMusic(void) {
	unsigned char instr;
	byte channel;
	byte note;
	byte volume;
	uint16 tempo;

	if (_playPos > (_data + _dataSize)) {
		_ended = true;
		return;
	}

	// First tempo, we'll ignore it...
	if (_first) {
		tempo = *(_playPos++);
		// Tempo on 2 bytes
		if (tempo & 0x80)
			tempo = ((tempo & 3) << 8) | *(_playPos++);
	}
	_first = false;

	// Instruction
	instr = *(_playPos++);
	channel = instr & 0x0F;

	switch (instr & 0xF0) {
		// Note on + Volume
		case 0x00:
			note = *(_playPos++);
			_pollNotes[channel] = note;
			setVolume(channel, *(_playPos++));
			setKey(channel, note, true, false);
			break;
		// Note on
		case 0x90:
			note = *(_playPos++);
			_pollNotes[channel] = note;
			setKey(channel, note, true, false);
			break;
		// Last note off
		case 0x80:
			note = _pollNotes[channel];
			setKey(channel, note, false, false);
			break;
		// Frequency on/off
		case 0xA0:
			note = *(_playPos++);
			setKey(channel, note, _notOn[channel], true);
			break;
		// Volume
		case 0xB0:
			volume = *(_playPos++);
			setVolume(channel, volume);
			break;
		// Program change
		case 0xC0:
			setVoice(channel, *(_playPos++), false);
			break;
		// Special
		case 0xF0:
			break;
		default:
			warning("Unknown command in ADL, stopping playback");
			_looping = false;
			_ended = true;
			break;
	}
	// End instruction
	if (instr == 0xFF) {
		_ended = true;
	}

	// Temporization
	tempo = *(_playPos++);
	// End tempo
	if (tempo == 0xFF) {
		_ended = true;
		return;
	}
	// Tempo on 2 bytes
	if (tempo & 0x80)
		tempo = ((tempo & 3) << 8) | *(_playPos++);
	if (!tempo)
		tempo ++;

	_samplesTillPoll = tempo * (_rate / 1000);
}

void Music::startPlay(void) {
	if (!_data)
		return;
	
	_playing = true;
}

bool Music::loadMusic(const char *filename) {
	Common::File song;

	song.open(filename);
	if (!song.isOpen())
		return false;

	_dataSize = song.size();
	_data = new byte[_dataSize];
	song.read(_data, _dataSize);
	song.close();

	reset();
	setVoices();
	_playPos = _data + 3 + (_data[1] + 1) * 0x38;
	
	return true;
}

void Music::unloadMusic(void) {
	_playing = false;

	if (_data)
		delete _data;
}

} // End of namespace Gob

--- NEW FILE: music.h ---
/* ScummVM - Scumm Interpreter
 * Copyright (C) 2006 The ScummVM project
 * Original ADL-Player source Copyright (C) 2004 by Dorian Gray
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * $Header: /cvsroot/scummvm/scummvm/gob/music.h,v 1.1 2006/01/07 22:28:54 drmccoy Exp $
 *
 */

#ifndef GOB_MUSIC_H
#define GOB_MUSIC_H

#include "sound/audiostream.h"
#include "sound/fmopl.h"

#include "gob/gob.h"

namespace Gob {

class GobEngine;

class Music : public AudioStream {
public:
	Music(GobEngine *vm);
	~Music();

	bool playing() { return _playing; }
	bool getLooping() { return _looping; }
	void setLooping(bool looping) { _looping = looping; }
	void startPlay(void);
	void stopPlay(void) { _playing = false; }
	bool loadMusic(const char *filename);
	void unloadMusic(void);

// AudioStream API
	int readBuffer(int16 *buffer, const int numSamples) {
		premixerCall(buffer, numSamples / 2);
		return numSamples;
	}
	bool isStereo() const { return true; }
	bool endOfData() const { return false; }
	int getRate() const { return _rate; }
	
protected:
	static const unsigned char _operators[];
	static const unsigned char _volRegNums [];
	FM_OPL *_opl;
	byte *_data;
	byte *_playPos;
	uint32 _dataSize;
	uint32 _rate;
	short _freqs[25][12];
	byte _notes[11];
	byte _notCol[11];
	byte _notLin[11];
	bool _notOn[11];
	byte _pollNotes[16];
	uint32 _samplesTillPoll;
	bool _playing;
	bool _first;
	bool _ended;
	bool _looping;
	GobEngine *_vm;

	void premixerCall(int16 *buf, uint len);
	void writeOPL(byte reg, byte val);
	void setFreqs(void);
	void reset(void);
	void setVoices();
	void setVoice(byte voice, byte instr, bool set);
	void setKey(byte voice, byte note, bool on, bool spec);
	void setVolume(byte voice, byte volume);
	void pollMusic(void);
};

} // End of namespace Gob

#endif

Index: cdrom.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/cdrom.cpp,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- cdrom.cpp	4 Jan 2006 01:48:14 -0000	1.6
+++ cdrom.cpp	7 Jan 2006 22:28:53 -0000	1.7
@@ -124,7 +124,7 @@
 	};
 
 	for (int i = 0; i < ARRAYSIZE(tracks); i++)
-		if (!scumm_stricmp(_vm->_game->curTotFile, tracks[i][0])) {
+		if (!scumm_stricmp(_vm->_game->_curTotFile, tracks[i][0])) {
 			startTrack(tracks[i][1]);
 			break;
 		}
@@ -141,7 +141,7 @@
 	};
 
 	for (int i = 0; i < ARRAYSIZE(tracks); i++)
-		if (!scumm_stricmp(_vm->_game->curTotFile, tracks[i][0])) {
+		if (!scumm_stricmp(_vm->_game->_curTotFile, tracks[i][0])) {
 			_cdPlaying = true;
 			startTrack(tracks[i][_vm->_global->_language + 1]);
 			break;

Index: draw.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/draw.cpp,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -d -r1.17 -r1.18
--- draw.cpp	4 Jan 2006 01:48:14 -0000	1.17
+++ draw.cpp	7 Jan 2006 22:28:53 -0000	1.18
@@ -34,92 +34,92 @@
 namespace Gob {
 
 Draw::Draw(GobEngine *vm) : _vm(vm) {
-	fontIndex = 0;
-	spriteLeft = 0;
-	spriteTop = 0;
-	spriteRight = 0;
-	spriteBottom = 0;
-	destSpriteX = 0;
-	destSpriteY = 0;
-	backColor = 0;
[...1180 lines suppressed...]
 			ptr++;
 		}
 	}
 
-	renderFlags = savedFlags;
-	if (renderFlags & 4) {
+	_renderFlags = savedFlags;
+	if (_renderFlags & 4) {
 		warning("printText: Input not supported!");
 //              xor     ax, ax
 //              loc_436_1391:
@@ -942,7 +942,7 @@
 //              add     sp, 0Ch
 	}
 
-	if ((renderFlags & RENDERFLAG_CAPTUREPOP) && *_vm->_scenery->pCaptureCounter != 0) {
+	if ((_renderFlags & RENDERFLAG_CAPTUREPOP) && *_vm->_scenery->pCaptureCounter != 0) {
 		(*_vm->_scenery->pCaptureCounter)--;
 		_vm->_game->capturePop(1);
 	}

Index: draw.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/draw.h,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- draw.h	4 Jan 2006 01:48:14 -0000	1.8
+++ draw.h	7 Jan 2006 22:28:53 -0000	1.9
@@ -41,67 +41,67 @@
 		FontToSprite() : sprite(0), base(0), width(0), height() {}
 	} FontToSprite;
 
-	int16 fontIndex;
-	int16 spriteLeft;
-	int16 spriteTop;
-	int16 spriteRight;
-	int16 spriteBottom;
-	int16 destSpriteX;
-	int16 destSpriteY;
-	int16 backColor;
-	int16 frontColor;
-	char letterToPrint;
-	FontToSprite fontToSprite[4];
-	int16 destSurface;
-	int16 sourceSurface;
-	int16 renderFlags;
-	int16 backDeltaX;
-	int16 backDeltaY;
-	Video::FontDesc *fonts[4];
-	char *textToPrint;
-	int16 transparency;
-	Video::SurfaceDesc *spritesArray[50];
+	int16 _fontIndex;
+	int16 _spriteLeft;
+	int16 _spriteTop;
+	int16 _spriteRight;
+	int16 _spriteBottom;
+	int16 _destSpriteX;
+	int16 _destSpriteY;
+	int16 _backColor;
+	int16 _frontColor;
+	char _letterToPrint;
+	FontToSprite _fontToSprite[4];
+	int16 _destSurface;
+	int16 _sourceSurface;
+	int16 _renderFlags;
+	int16 _backDeltaX;
+	int16 _backDeltaY;
+	Video::FontDesc *_fonts[4];
+	char *_textToPrint;
+	int16 _transparency;
+	Video::SurfaceDesc *_spritesArray[50];
 
-	int16 invalidatedCount;
-	int16 invalidatedTops[30];
-	int16 invalidatedLefts[30];
-	int16 invalidatedRights[30];
-	int16 invalidatedBottoms[30];
+	int16 _invalidatedCount;
+	int16 _invalidatedTops[30];
+	int16 _invalidatedLefts[30];
+	int16 _invalidatedRights[30];
+	int16 _invalidatedBottoms[30];
 
-	int8 noInvalidated;
+	int8 _noInvalidated;
 //	int8 doFullFlip; // Never used?!?
-	int8 paletteCleared;
+	int8 _paletteCleared;
 
-	int16 gcursorIndex;
-	int16 transparentCursor;
-	uint32 cursorTimeKey;
+	int16 _cursorIndex;
+	int16 _transparentCursor;
+	uint32 _cursorTimeKey;
 
-	Video::SurfaceDesc *backSurface;
-	Video::SurfaceDesc *frontSurface;
+	Video::SurfaceDesc *_backSurface;
+	Video::SurfaceDesc *_frontSurface;
 
-	int16 unusedPalette1[18];
-	int16 unusedPalette2[16];
-	Video::Color vgaPalette[256];
-	Video::Color vgaSmallPalette[16];
+	int16 _unusedPalette1[18];
+	int16 _unusedPalette2[16];
+	Video::Color _vgaPalette[256];
+	Video::Color _vgaSmallPalette[16];
 
-	int16 cursorX;
-	int16 cursorY;
-	int16 cursorWidth;
-	int16 cursorHeight;
+	int16 _cursorX;
+	int16 _cursorY;
+	int16 _cursorWidth;
+	int16 _cursorHeight;
 
-	int16 cursorXDeltaVar;
-	int16 cursorYDeltaVar;
+	int16 _cursorXDeltaVar;
+	int16 _cursorYDeltaVar;
 
-	Video::SurfaceDesc *cursorSprites;
-	Video::SurfaceDesc *cursorBack;
-	int16 cursorAnim;
-	int8 cursorAnimLow[40];
-	int8 cursorAnimHigh[40];
-	int8 cursorAnimDelays[40];
-	int8 applyPal;
+	Video::SurfaceDesc *_cursorSprites;
+	Video::SurfaceDesc *_cursorBack;
+	int16 _cursorAnim;
+	int8 _cursorAnimLow[40];
+	int8 _cursorAnimHigh[40];
+	int8 _cursorAnimDelays[40];
+	int8 _applyPal;
 
-	int16 palLoadData1[4];
-	int16 palLoadData2[4];
+	int16 _palLoadData1[4];
+	int16 _palLoadData2[4];
 		
 	void invalidateRect(int16 left, int16 top, int16 right, int16 bottom);
 	void blitInvalidated(void);

Index: game.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/game.cpp,v
retrieving revision 1.31
retrieving revision 1.32
diff -u -d -r1.31 -r1.32
--- game.cpp	4 Jan 2006 01:48:14 -0000	1.31
+++ game.cpp	7 Jan 2006 22:28:53 -0000	1.32
@@ -36,49 +36,49 @@
 
 namespace Gob {
 
-int16 Game::captureCount = 0;
-Common::Rect Game::captureStack[20];
+int16 Game::_captureCount = 0;
+Common::Rect Game::_captureStack[20];
 
 Game::Game(GobEngine *vm) : _vm(vm) {
-	extTable = 0;
-	totFileData = 0;
[...1736 lines suppressed...]
 }
 
 void Game::start(void) {
-	collisionAreas = (Collision *)malloc(250 * sizeof(Collision));
+	_collisionAreas = (Collision *)malloc(250 * sizeof(Collision));
 	prepareStart();
 	playTot(0);
 
-	free(collisionAreas);
+	free(_collisionAreas);
 
-	_vm->_video->freeSurfDesc(_vm->_draw->cursorSprites);
-	_vm->_video->freeSurfDesc(_vm->_draw->cursorBack);
-	_vm->_video->freeSurfDesc(_vm->_draw->backSurface);
+	_vm->_video->freeSurfDesc(_vm->_draw->_cursorSprites);
+	_vm->_video->freeSurfDesc(_vm->_draw->_cursorBack);
+	_vm->_video->freeSurfDesc(_vm->_draw->_backSurface);
 }
 
 } // End of namespace Gob

Index: game.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/game.h,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- game.h	3 Jan 2006 23:14:39 -0000	1.7
+++ game.h	7 Jan 2006 22:28:54 -0000	1.8
@@ -93,26 +93,26 @@
 	} GCC_PACK InputDesc;
 #pragma END_PACK_STRUCTS
 
-	TotResTable *totResourceTable;
-	Collision *collisionAreas;
-	Collision *collStack[3];
+	TotResTable *_totResourceTable;
+	Collision *_collisionAreas;
+	Collision *_collStack[3];
 
-	TotTextTable *totTextData;
+	TotTextTable *_totTextData;
 
-	char curTotFile[14];
-	char curExtFile[14];
+	char _curTotFile[14];
+	char _curExtFile[14];
 
-	char *imFileData;
-	char *totFileData;
+	char *_imFileData;
+	char *_totFileData;
 
-	int16 extHandle;
+	int16 _extHandle;
 
-	Snd::SoundDesc *soundSamples[20];
+	Snd::SoundDesc *_soundSamples[20];
 
-	char totToLoad[20];
+	char _totToLoad[20];
 
-	int32 startTimeKey;
-	int16 mouseButtons;
+	int32 _startTimeKey;
+	int16 _mouseButtons;
 
 	Game(GobEngine *vm);
 
@@ -149,32 +149,32 @@
 
 protected:
 
-	int16 lastCollKey;
-	int16 lastCollAreaIndex;
-	int16 lastCollId;
+	int16 _lastCollKey;
+	int16 _lastCollAreaIndex;
+	int16 _lastCollId;
 
-	int16 activeCollResId;
-	int16 activeCollIndex;
-	char ghandleMouse;
-	char forceHandleMouse;
+	int16 _activeCollResId;
+	int16 _activeCollIndex;
+	char _handleMouse;
+	char _forceHandleMouse;
 
-	char tempStr[256];
+	char _tempStr[256];
 
-	ExtTable *extTable;
-	char curImaFile[18];
+	ExtTable *_extTable;
+	char _curImaFile[18];
 
-	int16 collStackSize;
-	int16 collStackElemSizes[3];
+	int16 _collStackSize;
+	int16 _collStackElemSizes[3];
 
-	char soundFromExt[20];
+	char _soundFromExt[20];
 
-	char shouldPushColls;
+	char _shouldPushColls;
 
 	// Capture
-	static Common::Rect captureStack[20];
-	static int16 captureCount;
+	static Common::Rect _captureStack[20];
+	static int16 _captureCount;
 
-	char collStr[256];
+	char _collStr[256];
 
 	GobEngine *_vm;
 		

Index: gob.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/gob.cpp,v
retrieving revision 1.30
retrieving revision 1.31
diff -u -d -r1.30 -r1.31
--- gob.cpp	5 Jan 2006 16:06:53 -0000	1.30
+++ gob.cpp	7 Jan 2006 22:28:54 -0000	1.31
@@ -43,6 +43,7 @@
 #include "gob/scenery.h"
 #include "gob/timer.h"
 #include "gob/util.h"
+#include "gob/music.h"
 
 enum {
 	// We only compute MD5 of the first megabyte of our data files.
@@ -216,8 +217,8 @@
 REGISTER_PLUGIN(GOB, "Gob Engine")
 
 namespace Gob {
+
 #define MAX_TIME_DELTA 100
-//GobEngine *_vm = NULL;
 
 GobEngine::GobEngine(GameDetector *detector, OSystem * syst, uint32 features)
  : Engine(syst) {
@@ -253,6 +254,7 @@
 	delete _gtimer;
 	delete _util;
 	delete _inter;
+	delete _music;
 }
 
 void GobEngine::errorString(const char *buf1, char *buf2) {
@@ -288,6 +290,7 @@
 	_scenery = new Scenery(this);
 	_gtimer = new GTimer();
 	_util = new Util(this);
+	_music = new Music(this);
 	if (_features & Gob::GF_GOB1)
 		_inter = new Inter_v1(this);
 	else if (_features & Gob::GF_GOB2)

Index: gob.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/gob.h,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -d -r1.14 -r1.15
--- gob.h	5 Jan 2006 16:06:55 -0000	1.14
+++ gob.h	7 Jan 2006 22:28:54 -0000	1.15
@@ -55,6 +55,7 @@
 class Scenery;
 class GTimer;
 class Util;
+class Music;
 
 #define	VAR_OFFSET(offs)		(*(uint32 *)(_vm->_global->_inter_variables + (offs)))
 #define	VAR(var)			VAR_OFFSET((var) << 2)
@@ -117,6 +118,7 @@
 	GTimer *_gtimer;
 	Util *_util;
 	Inter *_inter;
+	Music *_music;
 };
 
 } // End of namespace Gob

Index: goblin.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/goblin.cpp,v
retrieving revision 1.27
retrieving revision 1.28
diff -u -d -r1.27 -r1.28
--- goblin.cpp	4 Jan 2006 01:48:14 -0000	1.27
+++ goblin.cpp	7 Jan 2006 22:28:54 -0000	1.28
@@ -36,130 +36,130 @@
 namespace Gob {
 
 Goblin::Goblin(GobEngine *vm) : _vm(vm) {
-	goesAtTarget = 0;
-	readyToAct = 0;
-	gobAction = 0;
-	itemIndInPocket = 5;
-	itemIdInPocket = 2;
-	itemByteFlag = 0;
-	destItemId = -1;
-	destActionItem = 0;
[...3039 lines suppressed...]
-		    (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
+			objDesc->xPos += _gobPositions[0].x * 12 + 14
 			    - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2;
 		} else {
-			objDesc->xPos += gobPositions[0].x * 12
+			objDesc->xPos += _gobPositions[0].x * 12
 			    - (_vm->_scenery->toRedrawLeft + _vm->_scenery->toRedrawRight) / 2;
 		}
 
-		itemIndInPocket = -1;
-		itemIdInPocket = -1;
+		_itemIndInPocket = -1;
+		_itemIdInPocket = -1;
 		_vm->_util->beep(50);
 		break;
 

Index: goblin.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/goblin.h,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- goblin.h	3 Jan 2006 23:14:39 -0000	1.7
+++ goblin.h	7 Jan 2006 22:28:54 -0000	1.8
@@ -91,91 +91,91 @@
 	} GCC_PACK Gob_Pos;
 #pragma END_PACK_STRUCTS
 
-	Util::List *objList;
-	Gob_Object *goblins[4];
-	int16 currentGoblin;
-	Snd::SoundDesc *soundData[16];
-	int16 gobStateLayer;
-	char goesAtTarget;
-	char readyToAct;
-	int16 gobAction;	// 0 - move, 3 - do action, 4 - pick
+	Util::List *_objList;
+	Gob_Object *_goblins[4];
+	int16 _currentGoblin;
+	Snd::SoundDesc *_soundData[16];
+	int16 _gobStateLayer;
+	char _goesAtTarget;
+	char _readyToAct;
+	int16 _gobAction;	// 0 - move, 3 - do action, 4 - pick
 						// goblins  0 - picker, 1 - fighter, 2 - mage
-	Gob_Pos gobPositions[3];
-	int16 gobDestX;
-	int16 gobDestY;
-	int16 pressedMapX;
-	int16 pressedMapY;
-	char pathExistence;
+	Gob_Pos _gobPositions[3];
+	int16 _gobDestX;
+	int16 _gobDestY;
+	int16 _pressedMapX;
+	int16 _pressedMapY;
+	char _pathExistence;
 
 	// Pointers to interpreter variables
-	int32 *some0ValPtr;
+	int32 *_some0ValPtr;
 
-	int32 *gobRetVarPtr;
-	int32 *curGobVarPtr;
-	int32 *curGobXPosVarPtr;
-	int32 *curGobYPosVarPtr;
-	int32 *itemInPocketVarPtr;
+	int32 *_gobRetVarPtr;
+	int32 *_curGobVarPtr;
+	int32 *_curGobXPosVarPtr;
+	int32 *_curGobYPosVarPtr;
+	int32 *_itemInPocketVarPtr;
 
-	int32 *curGobStateVarPtr;
-	int32 *curGobFrameVarPtr;
-	int32 *curGobMultStateVarPtr;
-	int32 *curGobNextStateVarPtr;
-	int32 *curGobScrXVarPtr;
-	int32 *curGobScrYVarPtr;
-	int32 *curGobLeftVarPtr;
-	int32 *curGobTopVarPtr;
-	int32 *curGobRightVarPtr;
-	int32 *curGobBottomVarPtr;
-	int32 *curGobDoAnimVarPtr;
-	int32 *curGobOrderVarPtr;
-	int32 *curGobNoTickVarPtr;
-	int32 *curGobTypeVarPtr;
-	int32 *curGobMaxTickVarPtr;
-	int32 *curGobTickVarPtr;
-	int32 *curGobActStartStateVarPtr;
-	int32 *curGobLookDirVarPtr;
-	int32 *curGobPickableVarPtr;
-	int32 *curGobRelaxVarPtr;
-	int32 *curGobMaxFrameVarPtr;
+	int32 *_curGobStateVarPtr;
+	int32 *_curGobFrameVarPtr;
+	int32 *_curGobMultStateVarPtr;
+	int32 *_curGobNextStateVarPtr;
+	int32 *_curGobScrXVarPtr;
+	int32 *_curGobScrYVarPtr;
+	int32 *_curGobLeftVarPtr;
+	int32 *_curGobTopVarPtr;
+	int32 *_curGobRightVarPtr;
+	int32 *_curGobBottomVarPtr;
+	int32 *_curGobDoAnimVarPtr;
+	int32 *_curGobOrderVarPtr;
+	int32 *_curGobNoTickVarPtr;
+	int32 *_curGobTypeVarPtr;
+	int32 *_curGobMaxTickVarPtr;
+	int32 *_curGobTickVarPtr;
+	int32 *_curGobActStartStateVarPtr;
+	int32 *_curGobLookDirVarPtr;
+	int32 *_curGobPickableVarPtr;
+	int32 *_curGobRelaxVarPtr;
+	int32 *_curGobMaxFrameVarPtr;
 
-	int32 *destItemStateVarPtr;
-	int32 *destItemFrameVarPtr;
-	int32 *destItemMultStateVarPtr;
-	int32 *destItemNextStateVarPtr;
-	int32 *destItemScrXVarPtr;
-	int32 *destItemScrYVarPtr;
-	int32 *destItemLeftVarPtr;
-	int32 *destItemTopVarPtr;
-	int32 *destItemRightVarPtr;
-	int32 *destItemBottomVarPtr;
-	int32 *destItemDoAnimVarPtr;
-	int32 *destItemOrderVarPtr;
-	int32 *destItemNoTickVarPtr;
-	int32 *destItemTypeVarPtr;
-	int32 *destItemMaxTickVarPtr;
-	int32 *destItemTickVarPtr;
-	int32 *destItemActStartStVarPtr;
-	int32 *destItemLookDirVarPtr;
-	int32 *destItemPickableVarPtr;
-	int32 *destItemRelaxVarPtr;
-	int32 *destItemMaxFrameVarPtr;
+	int32 *_destItemStateVarPtr;
+	int32 *_destItemFrameVarPtr;
+	int32 *_destItemMultStateVarPtr;
+	int32 *_destItemNextStateVarPtr;
+	int32 *_destItemScrXVarPtr;
+	int32 *_destItemScrYVarPtr;
+	int32 *_destItemLeftVarPtr;
+	int32 *_destItemTopVarPtr;
+	int32 *_destItemRightVarPtr;
+	int32 *_destItemBottomVarPtr;
+	int32 *_destItemDoAnimVarPtr;
+	int32 *_destItemOrderVarPtr;
+	int32 *_destItemNoTickVarPtr;
+	int32 *_destItemTypeVarPtr;
+	int32 *_destItemMaxTickVarPtr;
+	int32 *_destItemTickVarPtr;
+	int32 *_destItemActStartStVarPtr;
+	int32 *_destItemLookDirVarPtr;
+	int32 *_destItemPickableVarPtr;
+	int32 *_destItemRelaxVarPtr;
+	int32 *_destItemMaxFrameVarPtr;
 
-	int16 destItemType;
-	int16 destItemState;
-	int16 itemToObject[20];
-	Gob_Object *objects[20];
-	int16 objCount;
-	int16 gobsCount;
-	int16 itemIndInPocket;
-	int16 itemIdInPocket;
-	char itemByteFlag;
-	int16 destItemId;
-	int16 destActionItem;
-	Gob_Object *actDestItemDesc;
-	int16 forceNextState[10];
-	char boreCounter;
-	int16 positionedGob;
-	char noPick;
+	int16 _destItemType;
+	int16 _destItemState;
+	int16 _itemToObject[20];
+	Gob_Object *_objects[20];
+	int16 _objCount;
+	int16 _gobsCount;
+	int16 _itemIndInPocket;
+	int16 _itemIdInPocket;
+	char _itemByteFlag;
+	int16 _destItemId;
+	int16 _destActionItem;
+	Gob_Object *_actDestItemDesc;
+	int16 _forceNextState[10];
+	char _boreCounter;
+	int16 _positionedGob;
+	char _noPick;
 
 	// Functions
 	char rotateState(int16 from, int16 to);
@@ -206,7 +206,7 @@
 	Goblin(GobEngine *vm);
 
 protected:
-	int16 rotStates[4][4];
+	int16 _rotStates[4][4];
 	GobEngine *_vm;
 
 	int16 peekGoblin(Gob_Object *curGob);

Index: init.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/init.cpp,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -d -r1.14 -r1.15
--- init.cpp	4 Jan 2006 01:48:15 -0000	1.14
+++ init.cpp	7 Jan 2006 22:28:54 -0000	1.15
@@ -168,22 +168,22 @@
 	_vm->_global->_mouseXShift = 1;
 	_vm->_global->_mouseYShift = 1;
 
-	_vm->_game->totTextData = 0;
-	_vm->_game->totFileData = 0;
-	_vm->_game->totResourceTable = 0;
+	_vm->_game->_totTextData = 0;
+	_vm->_game->_totFileData = 0;
+	_vm->_game->_totResourceTable = 0;
 	_vm->_global->_inter_variables = 0;
 	_palDesc = (Video::PalDesc *)malloc(12);
 
 	if (_vm->_global->_videoMode != 0x13)
 		error("initGame: Only 0x13 video mode is supported!");
 
-	_palDesc->vgaPal = _vm->_draw->vgaPalette;
-	_palDesc->unused1 = _vm->_draw->unusedPalette1;
-	_palDesc->unused2 = _vm->_draw->unusedPalette2;
+	_palDesc->vgaPal = _vm->_draw->_vgaPalette;
+	_palDesc->unused1 = _vm->_draw->_unusedPalette1;
+	_palDesc->unused2 = _vm->_draw->_unusedPalette2;
 	_vm->_video->setFullPalette(_palDesc);
 
 	for (i = 0; i < 4; i++)
-		_vm->_draw->fonts[i] = 0;
+		_vm->_draw->_fonts[i] = 0;
 
 	handle = _vm->_dataio->openData("intro.inf");
 
@@ -192,7 +192,7 @@
 			handle2 = _vm->_dataio->openData(_fontNames[i]);
 			if (handle2 >= 0) {
 				_vm->_dataio->closeData(handle2);
-				_vm->_draw->fonts[i] =
+				_vm->_draw->_fonts[i] =
 				    _vm->_util->loadFont(_fontNames[i]);
 			}
 		}
@@ -214,7 +214,7 @@
 			handle2 = _vm->_dataio->openData(buffer);
 			if (handle2 >= 0) {
 				_vm->_dataio->closeData(handle2);
-				_vm->_draw->fonts[i] = _vm->_util->loadFont(buffer);
+				_vm->_draw->_fonts[i] = _vm->_util->loadFont(buffer);
 			}
 
 			if (infPtr == infEnd)
@@ -247,7 +247,7 @@
 		_vm->_global->_inter_variables = (char *)malloc(varsCount * 4);
 		memset(_vm->_global->_inter_variables, 0, varsCount * 4);
 
-		strcpy(_vm->_game->curTotFile, buffer);
+		strcpy(_vm->_game->_curTotFile, buffer);
 
 		_vm->_cdrom->testCD(1, "GOB");
 		_vm->_cdrom->readLIC("gob.lic");
@@ -257,14 +257,14 @@
 		_vm->_cdrom->freeLICbuffer();
 
 		free(_vm->_global->_inter_variables);
-		free(_vm->_game->totFileData);
-		free(_vm->_game->totTextData);
-		free(_vm->_game->totResourceTable);
+		free(_vm->_game->_totFileData);
+		free(_vm->_game->_totTextData);
+		free(_vm->_game->_totResourceTable);
 	}
 
 	for (i = 0; i < 4; i++) {
-		if (_vm->_draw->fonts[i] != 0)
-			_vm->_util->freeFont(_vm->_draw->fonts[i]);
+		if (_vm->_draw->_fonts[i] != 0)
+			_vm->_util->freeFont(_vm->_draw->_fonts[i]);
 	}
 
 	free(_palDesc);

Index: inter.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/inter.cpp,v
retrieving revision 1.29
retrieving revision 1.30
diff -u -d -r1.29 -r1.30
--- inter.cpp	5 Jan 2006 16:06:55 -0000	1.29
+++ inter.cpp	7 Jan 2006 22:28:54 -0000	1.30
@@ -100,21 +100,21 @@
 	_vm->_video->waitRetrace(_vm->_global->_videoMode);
 
 	if (_animPalDir == -1) {
-		col = _vm->_draw->vgaSmallPalette[_animPalLowIndex];
+		col = _vm->_draw->_vgaSmallPalette[_animPalLowIndex];
 
 		for (i = _animPalLowIndex; i < _animPalHighIndex; i++)
-			_vm->_draw->vgaSmallPalette[i] = _vm->_draw->vgaSmallPalette[i + 1];
+			_vm->_draw->_vgaSmallPalette[i] = _vm->_draw->_vgaSmallPalette[i + 1];
 
-		_vm->_draw->vgaSmallPalette[_animPalHighIndex] = col;
+		_vm->_draw->_vgaSmallPalette[_animPalHighIndex] = col;
 	} else {
-		col = _vm->_draw->vgaSmallPalette[_animPalHighIndex];
+		col = _vm->_draw->_vgaSmallPalette[_animPalHighIndex];
 		for (i = _animPalHighIndex; i > _animPalLowIndex; i--)
-			_vm->_draw->vgaSmallPalette[i] = _vm->_draw->vgaSmallPalette[i - 1];
+			_vm->_draw->_vgaSmallPalette[i] = _vm->_draw->_vgaSmallPalette[i - 1];
 
-		_vm->_draw->vgaSmallPalette[_animPalLowIndex] = col;
+		_vm->_draw->_vgaSmallPalette[_animPalLowIndex] = col;
 	}
 
-	_vm->_global->_pPaletteDesc->vgaPal = _vm->_draw->vgaSmallPalette;
+	_vm->_global->_pPaletteDesc->vgaPal = _vm->_draw->_vgaSmallPalette;
 	_vm->_video->setFullPalette(_vm->_global->_pPaletteDesc);
 }
 
@@ -175,11 +175,11 @@
 }
 
 void Inter::storeKey(int16 key) {
-	WRITE_VAR(12, _vm->_util->getTimeKey() - _vm->_game->startTimeKey);
+	WRITE_VAR(12, _vm->_util->getTimeKey() - _vm->_game->_startTimeKey);
 
 	WRITE_VAR(2, _vm->_global->_inter_mouseX);
 	WRITE_VAR(3, _vm->_global->_inter_mouseY);
-	WRITE_VAR(4, _vm->_game->mouseButtons);
+	WRITE_VAR(4, _vm->_game->_mouseButtons);
 	WRITE_VAR(1, _vm->_snd->_playingSound);
 
 	if (key == 0x4800)
@@ -257,7 +257,7 @@
 
 void Inter::callSub(int16 retFlag) {
 	int16 block;
-	while (_vm->_global->_inter_execPtr != 0 && (char *)_vm->_global->_inter_execPtr != _vm->_game->totFileData) {
+	while (_vm->_global->_inter_execPtr != 0 && (char *)_vm->_global->_inter_execPtr != _vm->_game->_totFileData) {
 		block = *_vm->_global->_inter_execPtr;
 		if (block == 1) {
 			funcBlock(retFlag);
@@ -266,7 +266,7 @@
 		}
 	}
 
-	if ((char *)_vm->_global->_inter_execPtr == _vm->_game->totFileData)
+	if ((char *)_vm->_global->_inter_execPtr == _vm->_game->_totFileData)
 		_terminate = true;
 }
 

Index: inter_v1.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/inter_v1.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- inter_v1.cpp	5 Jan 2006 20:54:53 -0000	1.2
+++ inter_v1.cpp	7 Jan 2006 22:28:54 -0000	1.3
@@ -533,19 +533,19 @@
 	int16 i;
 
 	debug(3, "printText");
-	_vm->_draw->destSpriteX = _vm->_parse->parseValExpr();
-	_vm->_draw->destSpriteY = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSpriteX = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSpriteY = _vm->_parse->parseValExpr();
 
-	_vm->_draw->backColor = _vm->_parse->parseValExpr();
-	_vm->_draw->frontColor = _vm->_parse->parseValExpr();
-	_vm->_draw->fontIndex = _vm->_parse->parseValExpr();
-	_vm->_draw->destSurface = 21;
-	_vm->_draw->textToPrint = buf;
-	_vm->_draw->transparency = 0;
+	_vm->_draw->_backColor = _vm->_parse->parseValExpr();
+	_vm->_draw->_frontColor = _vm->_parse->parseValExpr();
+	_vm->_draw->_fontIndex = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSurface = 21;
+	_vm->_draw->_textToPrint = buf;
+	_vm->_draw->_transparency = 0;
 
-	if (_vm->_draw->backColor >= 16) {
-		_vm->_draw->backColor = 0;
-		_vm->_draw->transparency = 1;
+	if (_vm->_draw->_backColor >= 16) {
+		_vm->_draw->_backColor = 0;
+		_vm->_draw->_transparency = 1;
 	}
 
 	do {
@@ -610,8 +610,8 @@
 	int16 count;
 	int16 i;
 
-	_vm->_draw->cursorXDeltaVar = _vm->_parse->parseVarIndex();
-	_vm->_draw->cursorYDeltaVar = _vm->_parse->parseVarIndex();
+	_vm->_draw->_cursorXDeltaVar = _vm->_parse->parseVarIndex();
+	_vm->_draw->_cursorYDeltaVar = _vm->_parse->parseVarIndex();
 
 	width = load16();
 	if (width < 16)
@@ -625,37 +625,37 @@
 	if (count < 2)
 		count = 2;
 
-	if (width != _vm->_draw->cursorWidth || height != _vm->_draw->cursorHeight ||
-	    _vm->_draw->cursorSprites->width != width * count) {
+	if (width != _vm->_draw->_cursorWidth || height != _vm->_draw->_cursorHeight ||
+	    _vm->_draw->_cursorSprites->width != width * count) {
 
-		_vm->_video->freeSurfDesc(_vm->_draw->cursorSprites);
-		_vm->_video->freeSurfDesc(_vm->_draw->cursorBack);
+		_vm->_video->freeSurfDesc(_vm->_draw->_cursorSprites);
+		_vm->_video->freeSurfDesc(_vm->_draw->_cursorBack);
 
-		_vm->_draw->cursorWidth = width;
-		_vm->_draw->cursorHeight = height;
+		_vm->_draw->_cursorWidth = width;
+		_vm->_draw->_cursorHeight = height;
 
 		if (count < 0x80)
-			_vm->_draw->transparentCursor = 1;
+			_vm->_draw->_transparentCursor = 1;
 		else
-			_vm->_draw->transparentCursor = 0;
+			_vm->_draw->_transparentCursor = 0;
 
 		if (count > 0x80)
 			count -= 0x80;
 
-		_vm->_draw->cursorSprites =
-		    _vm->_video->initSurfDesc(_vm->_global->_videoMode, _vm->_draw->cursorWidth * count,
-		    _vm->_draw->cursorHeight, 2);
-		_vm->_draw->spritesArray[23] = _vm->_draw->cursorSprites;
+		_vm->_draw->_cursorSprites =
+		    _vm->_video->initSurfDesc(_vm->_global->_videoMode, _vm->_draw->_cursorWidth * count,
+		    _vm->_draw->_cursorHeight, 2);
+		_vm->_draw->_spritesArray[23] = _vm->_draw->_cursorSprites;
 
-		_vm->_draw->cursorBack =
-		    _vm->_video->initSurfDesc(_vm->_global->_videoMode, _vm->_draw->cursorWidth,
-		    _vm->_draw->cursorHeight, 0);
+		_vm->_draw->_cursorBack =
+		    _vm->_video->initSurfDesc(_vm->_global->_videoMode, _vm->_draw->_cursorWidth,
+		    _vm->_draw->_cursorHeight, 0);
 		for (i = 0; i < 40; i++) {
-			_vm->_draw->cursorAnimLow[i] = -1;
-			_vm->_draw->cursorAnimDelays[i] = 0;
-			_vm->_draw->cursorAnimHigh[i] = 0;
+			_vm->_draw->_cursorAnimLow[i] = -1;
+			_vm->_draw->_cursorAnimDelays[i] = 0;
+			_vm->_draw->_cursorAnimHigh[i] = 0;
 		}
-		_vm->_draw->cursorAnimLow[1] = 0;
+		_vm->_draw->_cursorAnimLow[1] = 0;
 	}
 }
 
@@ -663,18 +663,18 @@
 	int16 ind;
 
 	ind = _vm->_parse->parseValExpr();
-	_vm->_draw->cursorAnimLow[ind] = load16();
-	_vm->_draw->cursorAnimHigh[ind] = load16();
-	_vm->_draw->cursorAnimDelays[ind] = load16();
+	_vm->_draw->_cursorAnimLow[ind] = load16();
+	_vm->_draw->_cursorAnimHigh[ind] = load16();
+	_vm->_draw->_cursorAnimDelays[ind] = load16();
 }
 
 void Inter_v1::o1_clearCursorAnim(void) {
 	int16 ind;
 
 	ind = _vm->_parse->parseValExpr();
-	_vm->_draw->cursorAnimLow[ind] = -1;
-	_vm->_draw->cursorAnimHigh[ind] = 0;
-	_vm->_draw->cursorAnimDelays[ind] = 0;
+	_vm->_draw->_cursorAnimLow[ind] = -1;
+	_vm->_draw->_cursorAnimHigh[ind] = 0;
+	_vm->_draw->_cursorAnimDelays[ind] = 0;
 }
 
 bool Inter_v1::o1_drawOperations(char &cmdCount, int16 &counter, int16 &retFlag) {
@@ -772,8 +772,8 @@
 	size = _vm->_parse->parseValExpr();
 	offset = _vm->_parse->parseValExpr();
 
-	if (_vm->_game->extHandle >= 0)
-		_vm->_dataio->closeData(_vm->_game->extHandle);
+	if (_vm->_game->_extHandle >= 0)
+		_vm->_dataio->closeData(_vm->_game->_extHandle);
 
 	WRITE_VAR(1, 1);
 	handle = _vm->_dataio->openData(_vm->_global->_inter_resStr);
@@ -791,8 +791,8 @@
 			WRITE_VAR(1, 0);
 	}
 
-	if (_vm->_game->extHandle >= 0)
-		_vm->_game->extHandle = _vm->_dataio->openData(_vm->_game->curExtFile);
+	if (_vm->_game->_extHandle >= 0)
+		_vm->_game->_extHandle = _vm->_dataio->openData(_vm->_game->_curExtFile);
 	return false;
 }
 
@@ -803,17 +803,17 @@
 	evalExpr(0);
 	index = load16();
 
-	if (_vm->_draw->fonts[index] != 0)
-		_vm->_util->freeFont(_vm->_draw->fonts[index]);
+	if (_vm->_draw->_fonts[index] != 0)
+		_vm->_util->freeFont(_vm->_draw->_fonts[index]);
 
 	_vm->_draw->animateCursor(4);
-	if (_vm->_game->extHandle >= 0)
-		_vm->_dataio->closeData(_vm->_game->extHandle);
+	if (_vm->_game->_extHandle >= 0)
+		_vm->_dataio->closeData(_vm->_game->_extHandle);
 
-	_vm->_draw->fonts[index] = _vm->_util->loadFont(_vm->_global->_inter_resStr);
+	_vm->_draw->_fonts[index] = _vm->_util->loadFont(_vm->_global->_inter_resStr);
 
-	if (_vm->_game->extHandle >= 0)
-		_vm->_game->extHandle = _vm->_dataio->openData(_vm->_game->curExtFile);
+	if (_vm->_game->_extHandle >= 0)
+		_vm->_game->_extHandle = _vm->_dataio->openData(_vm->_game->_curExtFile);
 	return false;
 }
 
@@ -821,10 +821,10 @@
 	int16 index;
 
 	index = load16();
-	if (_vm->_draw->fonts[index] != 0)
-		_vm->_util->freeFont(_vm->_draw->fonts[index]);
+	if (_vm->_draw->_fonts[index] != 0)
+		_vm->_util->freeFont(_vm->_draw->_fonts[index]);
 
-	_vm->_draw->fonts[index] = 0;
+	_vm->_draw->_fonts[index] = 0;
 	return false;
 }
 
@@ -907,74 +907,74 @@
 
 bool Inter_v1::o1_invalidate(char &cmdCount, int16 &counter, int16 &retFlag) {
 	warning("invalidate: 'bugged' function!");
-	_vm->_draw->destSurface = load16();
-	_vm->_draw->destSpriteX = _vm->_parse->parseValExpr();
-	_vm->_draw->destSpriteY = _vm->_parse->parseValExpr();
-	_vm->_draw->spriteRight = _vm->_parse->parseValExpr();
-	_vm->_draw->frontColor = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSurface = load16();
+	_vm->_draw->_destSpriteX = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSpriteY = _vm->_parse->parseValExpr();
+	_vm->_draw->_spriteRight = _vm->_parse->parseValExpr();
+	_vm->_draw->_frontColor = _vm->_parse->parseValExpr();
 	_vm->_draw->spriteOperation(DRAW_INVALIDATE);
 	return false;
 }
 
 bool Inter_v1::o1_loadSpriteContent(char &cmdCount, int16 &counter, int16 &retFlag) {
-	_vm->_draw->spriteLeft = load16();
-	_vm->_draw->destSurface = load16();
-	_vm->_draw->transparency = load16();
-	_vm->_draw->destSpriteX = 0;
-	_vm->_draw->destSpriteY = 0;
+	_vm->_draw->_spriteLeft = load16();
+	_vm->_draw->_destSurface = load16();
+	_vm->_draw->_transparency = load16();
+	_vm->_draw->_destSpriteX = 0;
+	_vm->_draw->_destSpriteY = 0;
 	_vm->_draw->spriteOperation(DRAW_LOADSPRITE);
 	return false;
 }
 
 bool Inter_v1::o1_copySprite(char &cmdCount, int16 &counter, int16 &retFlag) {
-	_vm->_draw->sourceSurface = load16();
-	_vm->_draw->destSurface = load16();
+	_vm->_draw->_sourceSurface = load16();
+	_vm->_draw->_destSurface = load16();
 
-	_vm->_draw->spriteLeft = _vm->_parse->parseValExpr();
-	_vm->_draw->spriteTop = _vm->_parse->parseValExpr();
-	_vm->_draw->spriteRight = _vm->_parse->parseValExpr();
-	_vm->_draw->spriteBottom = _vm->_parse->parseValExpr();
+	_vm->_draw->_spriteLeft = _vm->_parse->parseValExpr();
+	_vm->_draw->_spriteTop = _vm->_parse->parseValExpr();
+	_vm->_draw->_spriteRight = _vm->_parse->parseValExpr();
+	_vm->_draw->_spriteBottom = _vm->_parse->parseValExpr();
 
-	_vm->_draw->destSpriteX = _vm->_parse->parseValExpr();
-	_vm->_draw->destSpriteY = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSpriteX = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSpriteY = _vm->_parse->parseValExpr();
 
-	_vm->_draw->transparency = load16();
+	_vm->_draw->_transparency = load16();
 	_vm->_draw->spriteOperation(DRAW_BLITSURF);
 	return false;
 }
 
 bool Inter_v1::o1_putPixel(char &cmdCount, int16 &counter, int16 &retFlag) {
-	_vm->_draw->destSurface = load16();
+	_vm->_draw->_destSurface = load16();
 
-	_vm->_draw->destSpriteX = _vm->_parse->parseValExpr();
-	_vm->_draw->destSpriteY = _vm->_parse->parseValExpr();
-	_vm->_draw->frontColor = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSpriteX = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSpriteY = _vm->_parse->parseValExpr();
+	_vm->_draw->_frontColor = _vm->_parse->parseValExpr();
 	_vm->_draw->spriteOperation(DRAW_PUTPIXEL);
 	return false;
 }
 
 bool Inter_v1::o1_fillRect(char &cmdCount, int16 &counter, int16 &retFlag) {
-	_vm->_draw->destSurface = load16();
+	_vm->_draw->_destSurface = load16();
 
-	_vm->_draw->destSpriteX = _vm->_parse->parseValExpr();
-	_vm->_draw->destSpriteY = _vm->_parse->parseValExpr();
-	_vm->_draw->spriteRight = _vm->_parse->parseValExpr();
-	_vm->_draw->spriteBottom = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSpriteX = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSpriteY = _vm->_parse->parseValExpr();
+	_vm->_draw->_spriteRight = _vm->_parse->parseValExpr();
+	_vm->_draw->_spriteBottom = _vm->_parse->parseValExpr();
 
-	_vm->_draw->backColor = _vm->_parse->parseValExpr();
+	_vm->_draw->_backColor = _vm->_parse->parseValExpr();
 	_vm->_draw->spriteOperation(DRAW_FILLRECT);
 	return false;
 }
 
 bool Inter_v1::o1_drawLine(char &cmdCount, int16 &counter, int16 &retFlag) {
-	_vm->_draw->destSurface = load16();
+	_vm->_draw->_destSurface = load16();
 
-	_vm->_draw->destSpriteX = _vm->_parse->parseValExpr();
-	_vm->_draw->destSpriteY = _vm->_parse->parseValExpr();
-	_vm->_draw->spriteRight = _vm->_parse->parseValExpr();
-	_vm->_draw->spriteBottom = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSpriteX = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSpriteY = _vm->_parse->parseValExpr();
+	_vm->_draw->_spriteRight = _vm->_parse->parseValExpr();
+	_vm->_draw->_spriteBottom = _vm->_parse->parseValExpr();
 
-	_vm->_draw->frontColor = _vm->_parse->parseValExpr();
+	_vm->_draw->_frontColor = _vm->_parse->parseValExpr();
 	_vm->_draw->spriteOperation(DRAW_DRAWLINE);
 	return false;
 }
@@ -991,11 +991,11 @@
 
 	flag = load16();
 	if (flag == 1)
-		_vm->_draw->spritesArray[index] = _vm->_video->initSurfDesc(_vm->_global->_videoMode, width, height, 2);
+		_vm->_draw->_spritesArray[index] = _vm->_video->initSurfDesc(_vm->_global->_videoMode, width, height, 2);
 	else
-		_vm->_draw->spritesArray[index] = _vm->_video->initSurfDesc(_vm->_global->_videoMode, width, height, 0);
+		_vm->_draw->_spritesArray[index] = _vm->_video->initSurfDesc(_vm->_global->_videoMode, width, height, 0);
 
-	_vm->_video->clearSurf(_vm->_draw->spritesArray[index]);
+	_vm->_video->clearSurf(_vm->_draw->_spritesArray[index]);
 	return false;
 }
 
@@ -1003,11 +1003,11 @@
 	int16 index;
 
 	index = load16();
-	if (_vm->_draw->spritesArray[index] == 0)
+	if (_vm->_draw->_spritesArray[index] == 0)
 		return false;
 
-	_vm->_video->freeSurfDesc(_vm->_draw->spritesArray[index]);
-	_vm->_draw->spritesArray[index] = 0;
+	_vm->_video->freeSurfDesc(_vm->_draw->_spritesArray[index]);
+	_vm->_draw->_spritesArray[index] = 0;
 	return false;
 }
 
@@ -1022,7 +1022,7 @@
 	for (i = 0; i < 50; i++)
 		composition[i] = (int16)VAR_OFFSET(dataVar + i * 4);
 
-	_vm->_snd->playComposition(_vm->_game->soundSamples, composition, freqVal);
+	_vm->_snd->playComposition(_vm->_game->_soundSamples, composition, freqVal);
 	return false;
 }
 
@@ -1044,7 +1044,7 @@
 
 	_vm->_snd->stopSound(0);
 	_soundEndTimeKey = 0;
-	if (_vm->_game->soundSamples[index] == 0)
+	if (_vm->_game->_soundSamples[index] == 0)
 		return false;
 
 	if (repCount < 0) {
@@ -1055,17 +1055,17 @@
 		_soundEndTimeKey = _vm->_util->getTimeKey();
 
 		if (frequency == 0) {
-			freq2 = _vm->_game->soundSamples[index]->frequency;
+			freq2 = _vm->_game->_soundSamples[index]->frequency;
 		} else {
 			freq2 = frequency;
 		}
 		_soundStopVal =
-		    (10 * (_vm->_game->soundSamples[index]->size / 2)) / freq2;
+		    (10 * (_vm->_game->_soundSamples[index]->size / 2)) / freq2;
 		_soundEndTimeKey +=
-		    ((_vm->_game->soundSamples[index]->size * repCount -
-			_vm->_game->soundSamples[index]->size / 2) * 1000) / freq2;
+		    ((_vm->_game->_soundSamples[index]->size * repCount -
+			_vm->_game->_soundSamples[index]->size / 2) * 1000) / freq2;
 	}
-	_vm->_snd->playSample(_vm->_game->soundSamples[index], repCount, frequency);
+	_vm->_snd->playSample(_vm->_game->_soundSamples[index], repCount, frequency);
 	return false;
 }
 
@@ -1080,44 +1080,44 @@
 
 	id = load16();
 	index = *_vm->_global->_inter_execPtr++;
-	itemPtr = &_vm->_game->totResourceTable->items[id];
+	itemPtr = &_vm->_game->_totResourceTable->items[id];
 	offset = itemPtr->offset;
 
 	if (offset >= 0) {
 		dataBuf =
-		    ((char *)_vm->_game->totResourceTable) + szGame_TotResTable +
-		    szGame_TotResItem * _vm->_game->totResourceTable->itemsCount + offset;
+		    ((char *)_vm->_game->_totResourceTable) + szGame_TotResTable +
+		    szGame_TotResItem * _vm->_game->_totResourceTable->itemsCount + offset;
 	} else {
-		dataBuf = _vm->_game->imFileData + (int32)READ_LE_UINT32(&((int32 *)_vm->_game->imFileData)[-offset - 1]);
+		dataBuf = _vm->_game->_imFileData + (int32)READ_LE_UINT32(&((int32 *)_vm->_game->_imFileData)[-offset - 1]);
 	}
 
 	width = itemPtr->width;
 	height = itemPtr->height;
 
-	_vm->_video->fillRect(_vm->_draw->cursorSprites, index * _vm->_draw->cursorWidth, 0,
-	    index * _vm->_draw->cursorWidth + _vm->_draw->cursorWidth - 1,
-	    _vm->_draw->cursorHeight - 1, 0);
+	_vm->_video->fillRect(_vm->_draw->_cursorSprites, index * _vm->_draw->_cursorWidth, 0,
+	    index * _vm->_draw->_cursorWidth + _vm->_draw->_cursorWidth - 1,
+	    _vm->_draw->_cursorHeight - 1, 0);
 
 	_vm->_video->drawPackedSprite((byte*)dataBuf, width, height,
-	    index * _vm->_draw->cursorWidth, 0, 0, _vm->_draw->cursorSprites);
-	_vm->_draw->cursorAnimLow[index] = 0;
+	    index * _vm->_draw->_cursorWidth, 0, 0, _vm->_draw->_cursorSprites);
+	_vm->_draw->_cursorAnimLow[index] = 0;
 
 	return false;
 }
 
 bool Inter_v1::o1_loadSpriteToPos(char &cmdCount, int16 &counter, int16 &retFlag) {
 	debug(4, "loadSpriteToPos");
-	_vm->_draw->spriteLeft = load16();
+	_vm->_draw->_spriteLeft = load16();
 
-	_vm->_draw->destSpriteX = _vm->_parse->parseValExpr();
-	_vm->_draw->destSpriteY = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSpriteX = _vm->_parse->parseValExpr();
+	_vm->_draw->_destSpriteY = _vm->_parse->parseValExpr();
 
-	_vm->_draw->transparency = _vm->_global->_inter_execPtr[0];
-	_vm->_draw->destSurface = (_vm->_global->_inter_execPtr[0] / 2) - 1;
+	_vm->_draw->_transparency = _vm->_global->_inter_execPtr[0];
+	_vm->_draw->_destSurface = (_vm->_global->_inter_execPtr[0] / 2) - 1;
 
-	if (_vm->_draw->destSurface < 0)
-		_vm->_draw->destSurface = 101;
-	_vm->_draw->transparency &= 1;
+	if (_vm->_draw->_destSurface < 0)
+		_vm->_draw->_destSurface = 101;
+	_vm->_draw->_transparency &= 1;
 	_vm->_global->_inter_execPtr += 2;
 	_vm->_draw->spriteOperation(DRAW_LOADSPRITE);
 
@@ -1144,7 +1144,7 @@
 
 	strcat(buf, ".tot");
 	_terminate = true;
-	strcpy(_vm->_game->totToLoad, buf);
+	strcpy(_vm->_game->_totToLoad, buf);
 
 	return false;
 }
@@ -1217,7 +1217,7 @@
 			_vm->_util->waitKey();
 			return false;
 		}
-		key = _vm->_game->checkKeys(&_vm->_global->_inter_mouseX, &_vm->_global->_inter_mouseY, &_vm->_game->mouseButtons, 0);
+		key = _vm->_game->checkKeys(&_vm->_global->_inter_mouseX, &_vm->_global->_inter_mouseY, &_vm->_game->_mouseButtons, 0);
 
 		storeKey(key);
 		return false;
@@ -1302,7 +1302,7 @@
 }
 
 void Inter_v1::o1_setRenderFlags(void) {
-	_vm->_draw->renderFlags = _vm->_parse->parseValExpr();
+	_vm->_draw->_renderFlags = _vm->_parse->parseValExpr();
 }
 
 void Inter_v1::o1_loadAnim(void) {
@@ -1385,18 +1385,18 @@
 
 void Inter_v1::o1_loadFontToSprite(void) {
 	int16 i = load16();
-	_vm->_draw->fontToSprite[i].sprite = load16();
-	_vm->_draw->fontToSprite[i].base = load16();
-	_vm->_draw->fontToSprite[i].width = load16();
-	_vm->_draw->fontToSprite[i].height = load16();
+	_vm->_draw->_fontToSprite[i].sprite = load16();
+	_vm->_draw->_fontToSprite[i].base = load16();
+	_vm->_draw->_fontToSprite[i].width = load16();
+	_vm->_draw->_fontToSprite[i].height = load16();
 }
 
 void Inter_v1::o1_freeFontToSprite(void) {
 	int16 i = load16();
-	_vm->_draw->fontToSprite[i].sprite = -1;
-	_vm->_draw->fontToSprite[i].base = -1;
-	_vm->_draw->fontToSprite[i].width = -1;
-	_vm->_draw->fontToSprite[i].height = -1;
+	_vm->_draw->_fontToSprite[i].sprite = -1;
+	_vm->_draw->_fontToSprite[i].base = -1;
+	_vm->_draw->_fontToSprite[i].width = -1;
+	_vm->_draw->_fontToSprite[i].height = -1;
 }
 
 void Inter_v1::executeDrawOpcode(byte i) {
@@ -1441,7 +1441,7 @@
 
 bool Inter_v1::o1_callSub(char &cmdCount, int16 &counter, int16 &retFlag) {
 	char *storedIP = _vm->_global->_inter_execPtr;
-	_vm->_global->_inter_execPtr = (char *)_vm->_game->totFileData + READ_LE_UINT16(_vm->_global->_inter_execPtr);
+	_vm->_global->_inter_execPtr = (char *)_vm->_game->_totFileData + READ_LE_UINT16(_vm->_global->_inter_execPtr);
 
 	if (counter == cmdCount && retFlag == 2)
 		return true;
@@ -1570,8 +1570,8 @@
 }
 
 bool Inter_v1::o1_setBackDelta(char &cmdCount, int16 &counter, int16 &retFlag) {
-	_vm->_draw->backDeltaX = _vm->_parse->parseValExpr();
-	_vm->_draw->backDeltaY = _vm->_parse->parseValExpr();
+	_vm->_draw->_backDeltaX = _vm->_parse->parseValExpr();
+	_vm->_draw->_backDeltaY = _vm->_parse->parseValExpr();
 	return false;
 }
 
@@ -1595,7 +1595,7 @@
 	_vm->_util->waitEndFrame();
 	animPalette();
 	storeKey(_vm->_game->checkKeys(&_vm->_global->_inter_mouseX,
-		&_vm->_global->_inter_mouseY, &_vm->_game->mouseButtons, 0));
+		&_vm->_global->_inter_mouseY, &_vm->_game->_mouseButtons, 0));
 	return false;
 }
 

Index: map.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/map.cpp,v
retrieving revision 1.19
retrieving revision 1.20
diff -u -d -r1.19 -r1.20
--- map.cpp	4 Jan 2006 01:23:20 -0000	1.19
+++ map.cpp	7 Jan 2006 22:28:54 -0000	1.20
@@ -428,7 +428,7 @@
 	count = loadFromAvo_LE_UINT16();
 	for (i = 0; i < count; i++) {
 		_avoDataPtr += 20;
-		_vm->_goblin->itemToObject[i] = loadFromAvo_LE_UINT16();
+		_vm->_goblin->_itemToObject[i] = loadFromAvo_LE_UINT16();
 		_avoDataPtr += 5;
 	}
 }
@@ -510,41 +510,41 @@
 	savedPtr3 = _avoDataPtr;
 	_avoDataPtr += count3 * 8;
 
-	_vm->_goblin->gobsCount = loadFromAvo_LE_UINT16();
-	for (i = 0; i < _vm->_goblin->gobsCount; i++) {
-		_vm->_goblin->goblins[i] = (Goblin::Gob_Object *)malloc(sizeof(Goblin::Gob_Object));
+	_vm->_goblin->_gobsCount = loadFromAvo_LE_UINT16();
+	for (i = 0; i < _vm->_goblin->_gobsCount; i++) {
+		_vm->_goblin->_goblins[i] = (Goblin::Gob_Object *)malloc(sizeof(Goblin::Gob_Object));
 
-		_vm->_goblin->goblins[i]->xPos = READ_LE_UINT16(savedPtr2);
+		_vm->_goblin->_goblins[i]->xPos = READ_LE_UINT16(savedPtr2);
 		savedPtr2 += 2;
 
-		_vm->_goblin->goblins[i]->yPos = READ_LE_UINT16(savedPtr2);
+		_vm->_goblin->_goblins[i]->yPos = READ_LE_UINT16(savedPtr2);
 		savedPtr2 += 2;
 
-		_vm->_goblin->goblins[i]->order = READ_LE_UINT16(savedPtr2);
+		_vm->_goblin->_goblins[i]->order = READ_LE_UINT16(savedPtr2);
 		savedPtr2 += 2;
 
-		_vm->_goblin->goblins[i]->state = READ_LE_UINT16(savedPtr2);
+		_vm->_goblin->_goblins[i]->state = READ_LE_UINT16(savedPtr2);
 		savedPtr2 += 2;
 
 		if (i == 3)
-			_vm->_goblin->goblins[i]->stateMach = (Goblin::Gob_StateLine *)malloc(szGob_StateLine * 70);
+			_vm->_goblin->_goblins[i]->stateMach = (Goblin::Gob_StateLine *)malloc(szGob_StateLine * 70);
 		else
-			_vm->_goblin->goblins[i]->stateMach = (Goblin::Gob_StateLine *)malloc(szGob_StateLine * 40);
+			_vm->_goblin->_goblins[i]->stateMach = (Goblin::Gob_StateLine *)malloc(szGob_StateLine * 40);
 
 		// FIXME: All is wrong further. We should unwind calls to loadDataFromAvo()
-		loadDataFromAvo((char *)_vm->_goblin->goblins[i]->stateMach, 40 * szGob_StateLine);
+		loadDataFromAvo((char *)_vm->_goblin->_goblins[i]->stateMach, 40 * szGob_StateLine);
 		_avoDataPtr += 160;
-		_vm->_goblin->goblins[i]->multObjIndex = *_avoDataPtr;
+		_vm->_goblin->_goblins[i]->multObjIndex = *_avoDataPtr;
 		_avoDataPtr += 2;
 
-		_vm->_goblin->goblins[i]->realStateMach = _vm->_goblin->goblins[i]->stateMach;
+		_vm->_goblin->_goblins[i]->realStateMach = _vm->_goblin->_goblins[i]->stateMach;
 		for (state = 0; state < 40; state++) {
 			for (col = 0; col < 6; col++) {
-				if (_vm->_goblin->goblins[i]->stateMach[state][col] == 0)
+				if (_vm->_goblin->_goblins[i]->stateMach[state][col] == 0)
 					continue;
 
 				Goblin::Gob_State *tmpState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State));
-				_vm->_goblin->goblins[i]->stateMach[state][col] = tmpState;
+				_vm->_goblin->_goblins[i]->stateMach[state][col] = tmpState;
 
 				tmpState->animation = loadFromAvo_LE_UINT16();
 				tmpState->layer = loadFromAvo_LE_UINT16();
@@ -568,7 +568,7 @@
 	}
 
 	pState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State));
-	_vm->_goblin->goblins[0]->stateMach[39][0] = pState;
+	_vm->_goblin->_goblins[0]->stateMach[39][0] = pState;
 	pState->animation = 0;
 	pState->layer = 98;
 	pState->unk0 = 0;
@@ -576,7 +576,7 @@
 	pState->sndItem = -1;
 
 	pState = (Goblin::Gob_State *) malloc(sizeof(Goblin::Gob_State));
-	_vm->_goblin->goblins[1]->stateMach[39][0] = pState;
+	_vm->_goblin->_goblins[1]->stateMach[39][0] = pState;
 	pState->animation = 0;
 	pState->layer = 99;
 	pState->unk0 = 0;
@@ -584,25 +584,25 @@
 	pState->sndItem = -1;
 
 	pState = (Goblin::Gob_State *) malloc(sizeof(Goblin::Gob_State));
-	_vm->_goblin->goblins[2]->stateMach[39][0] = pState;
+	_vm->_goblin->_goblins[2]->stateMach[39][0] = pState;
 	pState->animation = 0;
 	pState->layer = 100;
 	pState->unk0 = 0;
 	pState->unk1 = 0;
 	pState->sndItem = -1;
 
-	_vm->_goblin->goblins[2]->stateMach[10][0]->sndFrame = 13;
-	_vm->_goblin->goblins[2]->stateMach[11][0]->sndFrame = 13;
-	_vm->_goblin->goblins[2]->stateMach[28][0]->sndFrame = 13;
-	_vm->_goblin->goblins[2]->stateMach[29][0]->sndFrame = 13;
+	_vm->_goblin->_goblins[2]->stateMach[10][0]->sndFrame = 13;
+	_vm->_goblin->_goblins[2]->stateMach[11][0]->sndFrame = 13;
+	_vm->_goblin->_goblins[2]->stateMach[28][0]->sndFrame = 13;
+	_vm->_goblin->_goblins[2]->stateMach[29][0]->sndFrame = 13;
 
-	_vm->_goblin->goblins[1]->stateMach[10][0]->sndFrame = 13;
-	_vm->_goblin->goblins[1]->stateMach[11][0]->sndFrame = 13;
+	_vm->_goblin->_goblins[1]->stateMach[10][0]->sndFrame = 13;
+	_vm->_goblin->_goblins[1]->stateMach[11][0]->sndFrame = 13;
 
 	for (state = 40; state < 70; state++) {
 		pState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State));
-		_vm->_goblin->goblins[3]->stateMach[state][0] = pState;
-		_vm->_goblin->goblins[3]->stateMach[state][1] = 0;
+		_vm->_goblin->_goblins[3]->stateMach[state][0] = pState;
+		_vm->_goblin->_goblins[3]->stateMach[state][1] = 0;
 
 		pState->animation = 9;
 		pState->layer = state - 40;
@@ -610,38 +610,38 @@
 		pState->sndFrame = 0;
 	}
 
-	_vm->_goblin->objCount = loadFromAvo_LE_UINT16();
-	for (i = 0; i < _vm->_goblin->objCount; i++) {
-		_vm->_goblin->objects[i] =
+	_vm->_goblin->_objCount = loadFromAvo_LE_UINT16();
+	for (i = 0; i < _vm->_goblin->_objCount; i++) {
+		_vm->_goblin->_objects[i] =
 		    (Goblin::Gob_Object *) malloc(sizeof(Goblin::Gob_Object));
 
-		_vm->_goblin->objects[i]->xPos = READ_LE_UINT16(savedPtr3);
+		_vm->_goblin->_objects[i]->xPos = READ_LE_UINT16(savedPtr3);
 		savedPtr3 += 2;
 
-		_vm->_goblin->objects[i]->yPos = READ_LE_UINT16(savedPtr3);
+		_vm->_goblin->_objects[i]->yPos = READ_LE_UINT16(savedPtr3);
 		savedPtr3 += 2;
 
-		_vm->_goblin->objects[i]->order = READ_LE_UINT16(savedPtr3);
+		_vm->_goblin->_objects[i]->order = READ_LE_UINT16(savedPtr3);
 		savedPtr3 += 2;
 
-		_vm->_goblin->objects[i]->state = READ_LE_UINT16(savedPtr3);
+		_vm->_goblin->_objects[i]->state = READ_LE_UINT16(savedPtr3);
 		savedPtr3 += 2;
 
-		_vm->_goblin->objects[i]->stateMach = (Goblin::Gob_StateLine *)malloc(szGob_StateLine * 40);
+		_vm->_goblin->_objects[i]->stateMach = (Goblin::Gob_StateLine *)malloc(szGob_StateLine * 40);
 
-		loadDataFromAvo((char *)_vm->_goblin->objects[i]->stateMach, 40 * szGob_StateLine);
+		loadDataFromAvo((char *)_vm->_goblin->_objects[i]->stateMach, 40 * szGob_StateLine);
 		_avoDataPtr += 160;
-		_vm->_goblin->objects[i]->multObjIndex = *_avoDataPtr;
+		_vm->_goblin->_objects[i]->multObjIndex = *_avoDataPtr;
 		_avoDataPtr += 2;
 
-		_vm->_goblin->objects[i]->realStateMach = _vm->_goblin->objects[i]->stateMach;
+		_vm->_goblin->_objects[i]->realStateMach = _vm->_goblin->_objects[i]->stateMach;
 		for (state = 0; state < 40; state++) {
 			for (col = 0; col < 6; col++) {
-				if (_vm->_goblin->objects[i]->stateMach[state][col] == 0)
+				if (_vm->_goblin->_objects[i]->stateMach[state][col] == 0)
 					continue;
 
 				Goblin::Gob_State *tmpState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State));
-				_vm->_goblin->objects[i]->stateMach[state][col] = tmpState;
+				_vm->_goblin->_objects[i]->stateMach[state][col] = tmpState;
 
 				tmpState->animation = loadFromAvo_LE_UINT16();
 				tmpState->layer = loadFromAvo_LE_UINT16();
@@ -664,14 +664,14 @@
 		}
 	}
 
-	_vm->_goblin->objects[10] = (Goblin::Gob_Object *)malloc(sizeof(Goblin::Gob_Object));
-	memset(_vm->_goblin->objects[10], 0, sizeof(Goblin::Gob_Object));
+	_vm->_goblin->_objects[10] = (Goblin::Gob_Object *)malloc(sizeof(Goblin::Gob_Object));
+	memset(_vm->_goblin->_objects[10], 0, sizeof(Goblin::Gob_Object));
 
-	_vm->_goblin->objects[10]->stateMach = (Goblin::Gob_StateLine *)malloc(szGob_StateLine * 40);
-	memset(_vm->_goblin->objects[10]->stateMach, 0, szGob_StateLine * 40);
+	_vm->_goblin->_objects[10]->stateMach = (Goblin::Gob_StateLine *)malloc(szGob_StateLine * 40);
+	memset(_vm->_goblin->_objects[10]->stateMach, 0, szGob_StateLine * 40);
 
 	pState = (Goblin::Gob_State *)malloc(sizeof(Goblin::Gob_State));
-	_vm->_goblin->objects[10]->stateMach[0][0] = pState;
+	_vm->_goblin->_objects[10]->stateMach[0][0] = pState;
 
 	memset(pState, 0, sizeof(Goblin::Gob_State));
 	pState->animation = 9;
@@ -681,11 +681,11 @@
 	pState->sndItem = -1;
 	pState->sndFrame = 0;
 
-	_vm->_goblin->placeObject(_vm->_goblin->objects[10], 1);
+	_vm->_goblin->placeObject(_vm->_goblin->_objects[10], 1);
 
-	_vm->_goblin->objects[10]->realStateMach = _vm->_goblin->objects[10]->stateMach;
-	_vm->_goblin->objects[10]->type = 1;
-	_vm->_goblin->objects[10]->unk14 = 1;
+	_vm->_goblin->_objects[10]->realStateMach = _vm->_goblin->_objects[10]->stateMach;
+	_vm->_goblin->_objects[10]->type = 1;
+	_vm->_goblin->_objects[10]->unk14 = 1;
 
 	state = loadFromAvo_LE_UINT16();
 	for (i = 0; i < state; i++) {
@@ -711,7 +711,7 @@
 
 	free(dataBuf);
 
-	_vm->_goblin->soundData[14] = _vm->_snd->loadSoundData("diamant1.snd");
+	_vm->_goblin->_soundData[14] = _vm->_snd->loadSoundData("diamant1.snd");
 
 	for (i = 0; i < soundCount; i++) {
 		handle = _vm->_dataio->openData(sndNames[i]);
@@ -719,7 +719,7 @@
 			continue;
 
 		_vm->_dataio->closeData(handle);
-		_vm->_goblin->soundData[i] = _vm->_snd->loadSoundData(sndNames[i]);
+		_vm->_goblin->_soundData[i] = _vm->_snd->loadSoundData(sndNames[i]);
 	}
 }
 
@@ -731,34 +731,34 @@
 		error("load: Loading .pas/.pos files is not supported!");
 
 	for (i = 0; i < 3; i++) {
-		_vm->_goblin->nextLayer(_vm->_goblin->goblins[i]);
+		_vm->_goblin->nextLayer(_vm->_goblin->_goblins[i]);
 	}
 
 	for (i = 0; i < 3; i++) {
 
 		layer =
-		    _vm->_goblin->goblins[i]->stateMach[_vm->_goblin->goblins[i]->state][0]->layer;
+		    _vm->_goblin->_goblins[i]->stateMach[_vm->_goblin->_goblins[i]->state][0]->layer;
 
-		_vm->_scenery->updateAnim(layer, 0, _vm->_goblin->goblins[i]->animation, 0,
-		    _vm->_goblin->goblins[i]->xPos, _vm->_goblin->goblins[i]->yPos, 0);
+		_vm->_scenery->updateAnim(layer, 0, _vm->_goblin->_goblins[i]->animation, 0,
+		    _vm->_goblin->_goblins[i]->xPos, _vm->_goblin->_goblins[i]->yPos, 0);
 
-		_vm->_goblin->goblins[i]->yPos = (_vm->_goblin->gobPositions[i].y + 1) * 6 -
+		_vm->_goblin->_goblins[i]->yPos = (_vm->_goblin->_gobPositions[i].y + 1) * 6 -
 		    (_vm->_scenery->toRedrawBottom - _vm->_scenery->animTop);
 
-		_vm->_goblin->goblins[i]->xPos = _vm->_goblin->gobPositions[i].x * 12 -
+		_vm->_goblin->_goblins[i]->xPos = _vm->_goblin->_gobPositions[i].x * 12 -
 		    (_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;
-	_vm->_goblin->pressedMapX = _vm->_goblin->gobPositions[0].x;
-	_vm->_goblin->pressedMapY = _vm->_goblin->gobPositions[0].y;
-	_vm->_goblin->pathExistence = 0;
+	_vm->_goblin->_currentGoblin = 0;
+	_vm->_goblin->_pressedMapX = _vm->_goblin->_gobPositions[0].x;
+	_vm->_goblin->_pressedMapY = _vm->_goblin->_gobPositions[0].y;
+	_vm->_goblin->_pathExistence = 0;
 
-	_vm->_goblin->goblins[0]->doAnim = 0;
-	_vm->_goblin->goblins[1]->doAnim = 1;
-	_vm->_goblin->goblins[2]->doAnim = 1;
+	_vm->_goblin->_goblins[0]->doAnim = 0;
+	_vm->_goblin->_goblins[1]->doAnim = 1;
+	_vm->_goblin->_goblins[2]->doAnim = 1;
 }
 
 }				// End of namespace Gob

Index: module.mk
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/module.mk,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- module.mk	5 Jan 2006 16:06:55 -0000	1.6
+++ module.mk	7 Jan 2006 22:28:54 -0000	1.7
@@ -16,6 +16,7 @@
 	gob/inter_v2.o \
 	gob/map.o \
 	gob/mult.o \
+	gob/music.o \
 	gob/pack.o \
 	gob/palanim.o \
 	gob/parse.o \

Index: mult.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/mult.cpp,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -d -r1.15 -r1.16
--- mult.cpp	4 Jan 2006 01:48:15 -0000	1.15
+++ mult.cpp	7 Jan 2006 22:28:54 -0000	1.16
@@ -254,15 +254,15 @@
 		if (pNeedRedraw[i] == 0 || objects[i].lastLeft == -1)
 			continue;
 
-		_vm->_draw->sourceSurface = 22;
-		_vm->_draw->destSurface = 21;
-		_vm->_draw->spriteLeft = pDirtyLefts[i] - _vm->_anim->_areaLeft;
-		_vm->_draw->spriteTop = pDirtyTops[i] - _vm->_anim->_areaTop;
-		_vm->_draw->spriteRight = pDirtyRights[i] - pDirtyLefts[i] + 1;
-		_vm->_draw->spriteBottom = pDirtyBottoms[i] - pDirtyTops[i] + 1;
-		_vm->_draw->destSpriteX = pDirtyLefts[i];
-		_vm->_draw->destSpriteY = pDirtyTops[i];
-		_vm->_draw->transparency = 0;
+		_vm->_draw->_sourceSurface = 22;
+		_vm->_draw->_destSurface = 21;
+		_vm->_draw->_spriteLeft = pDirtyLefts[i] - _vm->_anim->_areaLeft;
+		_vm->_draw->_spriteTop = pDirtyTops[i] - _vm->_anim->_areaTop;
+		_vm->_draw->_spriteRight = pDirtyRights[i] - pDirtyLefts[i] + 1;
+		_vm->_draw->_spriteBottom = pDirtyBottoms[i] - pDirtyTops[i] + 1;
+		_vm->_draw->_destSpriteX = pDirtyLefts[i];
+		_vm->_draw->_destSpriteY = pDirtyTops[i];
+		_vm->_draw->_transparency = 0;
 		_vm->_draw->spriteOperation(DRAW_BLITSURF);
 		objects[i].lastLeft = -1;
 	}
@@ -470,10 +470,10 @@
 		_vm->_anim->_animSurf = _vm->_video->initSurfDesc(_vm->_global->_videoMode,
 		    _vm->_anim->_areaWidth, _vm->_anim->_areaHeight, 0);
 
-		_vm->_draw->spritesArray[22] = _vm->_anim->_animSurf;
+		_vm->_draw->_spritesArray[22] = _vm->_anim->_animSurf;
 	}
 
-	_vm->_video->drawSprite(_vm->_draw->backSurface, _vm->_anim->_animSurf,
+	_vm->_video->drawSprite(_vm->_draw->_backSurface, _vm->_anim->_animSurf,
 	    _vm->_anim->_areaLeft, _vm->_anim->_areaTop,
 	    _vm->_anim->_areaLeft + _vm->_anim->_areaWidth - 1,
 	    _vm->_anim->_areaTop + _vm->_anim->_areaHeight - 1, 0, 0, 0);
@@ -577,7 +577,7 @@
 
 		_vm->_scenery->curStatic = staticIndices[_vm->_scenery->curStatic];
 		_vm->_scenery->renderStatic(_vm->_scenery->curStatic, _vm->_scenery->curStaticLayer);
-		_vm->_video->drawSprite(_vm->_draw->backSurface, _vm->_anim->_animSurf,
+		_vm->_video->drawSprite(_vm->_draw->_backSurface, _vm->_anim->_animSurf,
 		    0, 0, 319, 199, 0, 0, 0);
 	}
 	return stop;
@@ -811,13 +811,13 @@
 			if (sndKey->cmd == 1) {
 				_vm->_snd->stopSound(0);
 				stop = 0;
-				playSound(_vm->_game->soundSamples[sndKey->soundIndex], sndKey->repCount,
+				playSound(_vm->_game->_soundSamples[sndKey->soundIndex], sndKey->repCount,
 				    sndKey->freq, sndKey->channel);
 
 			} else if (sndKey->cmd == 4) {
 				_vm->_snd->stopSound(0);
 				stop = 0;
-				playSound(_vm->_game->soundSamples[sndKey->soundIndex], sndKey->repCount,
+				playSound(_vm->_game->_soundSamples[sndKey->soundIndex], sndKey->repCount,
 				    sndKey->freq, sndKey->channel);
 			}
 		} else {
@@ -888,9 +888,9 @@
 
 			_vm->_anim->_animSurf =
 			    _vm->_video->initSurfDesc(_vm->_global->_videoMode, 320, 200, 0);
-			_vm->_draw->spritesArray[22] = _vm->_anim->_animSurf;
+			_vm->_draw->_spritesArray[22] = _vm->_anim->_animSurf;
 
-			_vm->_video->drawSprite(_vm->_draw->backSurface, _vm->_anim->_animSurf,
+			_vm->_video->drawSprite(_vm->_draw->_backSurface, _vm->_anim->_animSurf,
 			    0, 0, 319, 199, 0, 0, 0);
 
 			animDataAllocated = 1;

Index: parse.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/parse.cpp,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -d -r1.17 -r1.18
--- parse.cpp	4 Jan 2006 01:48:15 -0000	1.17
+++ parse.cpp	7 Jan 2006 22:28:54 -0000	1.18
@@ -36,7 +36,7 @@
 
 	switch (type) {
 	case kExecPtr:
-		offset = ptr - _vm->_game->totFileData;
+		offset = ptr - _vm->_game->_totFileData;
 		break;
 	case kInterVar:
 		offset = ptr - _vm->_global->_inter_variables;
@@ -56,7 +56,7 @@
 
 	switch (n >> 28) {
 	case kExecPtr:
-		ptr = _vm->_game->totFileData;
+		ptr = _vm->_game->_totFileData;
 		break;
 	case kInterVar:
 		ptr = _vm->_global->_inter_variables;

Index: scenery.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/gob/scenery.cpp,v
retrieving revision 1.22
retrieving revision 1.23
diff -u -d -r1.22 -r1.23
--- scenery.cpp	4 Jan 2006 01:48:15 -0000	1.22
+++ scenery.cpp	7 Jan 2006 22:28:54 -0000	1.23
@@ -162,22 +162,22 @@
 			    sprIndex;
 			spriteRefs[sprIndex]++;
 		} else {
-			for (sprIndex = 19; _vm->_draw->spritesArray[sprIndex] != 0;
+			for (sprIndex = 19; _vm->_draw->_spritesArray[sprIndex] != 0;
 			    sprIndex--);
 
 			staticPictToSprite[7 * sceneryIndex + i] =
 			    sprIndex;
 			spriteRefs[sprIndex] = 1;
 			spriteResId[sprIndex] = sprResId;
-			_vm->_draw->spritesArray[sprIndex] =
+			_vm->_draw->_spritesArray[sprIndex] =
 			    _vm->_video->initSurfDesc(_vm->_global->_videoMode, width, height, 2);
 
-			_vm->_video->clearSurf(_vm->_draw->spritesArray[sprIndex]);
-			_vm->_draw->destSurface = sprIndex;
-			_vm->_draw->spriteLeft = sprResId;
-			_vm->_draw->transparency = 0;
-			_vm->_draw->destSpriteX = 0;
-			_vm->_draw->destSpriteY = 0;
+			_vm->_video->clearSurf(_vm->_draw->_spritesArray[sprIndex]);
+			_vm->_draw->_destSurface = sprIndex;
+			_vm->_draw->_spriteLeft = sprResId;
+			_vm->_draw->_transparency = 0;
+			_vm->_draw->_destSpriteX = 0;
+			_vm->_draw->_destSpriteY = 0;
 			_vm->_draw->spriteOperation(DRAW_LOADSPRITE);
 		}
 	}
@@ -201,8 +201,8 @@
 		spr = staticPictToSprite[index * 7 + i];
 		spriteRefs[spr]--;
 		if (spriteRefs[spr] == 0) {
-			_vm->_video->freeSurfDesc(_vm->_draw->spritesArray[spr]);
-			_vm->_draw->spritesArray[spr] = 0;
+			_vm->_video->freeSurfDesc(_vm->_draw->_spritesArray[spr]);
+			_vm->_draw->_spritesArray[spr] = 0;
 			spriteResId[spr] = -1;
 		}
 	}
@@ -239,12 +239,12 @@
 
 	layerPtr = ptr->layers[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->_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->spriteOperation(DRAW_LOADSPRITE);
 	}
 
@@ -258,21 +258,21 @@
 			pieceIndex = planePtr->pieceIndex;
 			pictIndex = planePtr->pictIndex - 1;
 
-			_vm->_draw->destSpriteX = planePtr->destX;
-			_vm->_draw->destSpriteY = planePtr->destY;
+			_vm->_draw->_destSpriteX = planePtr->destX;
+			_vm->_draw->_destSpriteY = planePtr->destY;
 			left = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].left);
 			right = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].right);
 			top = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].top);
 			bottom = FROM_LE_16(ptr->pieces[pictIndex][pieceIndex].bottom);
 
-			_vm->_draw->sourceSurface =
+			_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);
 		}
 	}
@@ -326,53 +326,53 @@
 
 			pieceIndex = planePtr->pieceIndex;
 			pictIndex = planePtr->pictIndex - 1;
-			_vm->_draw->destSpriteX = planePtr->destX;
-			_vm->_draw->destSpriteY = planePtr->destY;
+			_vm->_draw->_destSpriteX = planePtr->destX;
+			_vm->_draw->_destSpriteY = planePtr->destY;
 
 			left = FROM_LE_16(pictPtr[pictIndex][pieceIndex].left);
 			right = FROM_LE_16(pictPtr[pictIndex][pieceIndex].right);
 			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;
-			_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)
+			if (_vm->_draw->_spriteRight <= 0 || _vm->_draw->_spriteBottom <= 0)
 				continue;
 
-			if (_vm->_draw->destSpriteX + _vm->_draw->spriteRight - 1 >
+			if (_vm->_draw->_destSpriteX + _vm->_draw->_spriteRight - 1 >
 			    toRedrawRight)
-				_vm->_draw->spriteRight =
-				    toRedrawRight - _vm->_draw->destSpriteX + 1;
+				_vm->_draw->_spriteRight =
+				    toRedrawRight - _vm->_draw->_destSpriteX + 1;
 
-			if (_vm->_draw->destSpriteY + _vm->_draw->spriteBottom - 1 >
+			if (_vm->_draw->_destSpriteY + _vm->_draw->_spriteBottom - 1 >
 			    toRedrawBottom)
-				_vm->_draw->spriteBottom =
-				    toRedrawBottom - _vm->_draw->destSpriteY + 1;
+				_vm->_draw->_spriteBottom =
+				    toRedrawBottom - _vm->_draw->_destSpriteY + 1;
 
-			_vm->_draw->sourceSurface =
+			_vm->_draw->_sourceSurface =
 			    staticPictToSprite[curStatic * 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);
 		}
 	}
@@ -479,21 +479,21 @@
 			animPictToSprite[7 * sceneryIndex + i] = sprIndex;
 			spriteRefs[sprIndex]++;
 		} else {
-			for (sprIndex = 19; _vm->_draw->spritesArray[sprIndex] != 0;
+			for (sprIndex = 19; _vm->_draw->_spritesArray[sprIndex] != 0;
 			    sprIndex--);
 
 			animPictToSprite[7 * sceneryIndex + i] = sprIndex;
 			spriteRefs[sprIndex] = 1;
 			spriteResId[sprIndex] = sprResId;
-			_vm->_draw->spritesArray[sprIndex] =
+			_vm->_draw->_spritesArray[sprIndex] =
 			    _vm->_video->initSurfDesc(_vm->_global->_videoMode, width, height, 2);
 
-			_vm->_video->clearSurf(_vm->_draw->spritesArray[sprIndex]);
-			_vm->_draw->destSurface = sprIndex;
-			_vm->_draw->spriteLeft = sprResId;
-			_vm->_draw->transparency = 0;
-			_vm->_draw->destSpriteX = 0;
-			_vm->_draw->destSpriteY = 0;
+			_vm->_video->clearSurf(_vm->_draw->_spritesArray[sprIndex]);
+			_vm->_draw->_destSurface = sprIndex;
+			_vm->_draw->_spriteLeft = sprResId;
+			_vm->_draw->_transparency = 0;
+			_vm->_draw->_destSpriteX = 0;
+			_vm->_draw->_destSpriteY = 0;
 			_vm->_draw->spriteOperation(DRAW_LOADSPRITE);
 		}
 	}
@@ -668,17 +668,17 @@
 			continue;
 
 		if (doDraw) {
-			_vm->_draw->sourceSurface =
+			_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->spriteBottom = bottom - top + 1;
-			_vm->_draw->destSpriteX = destX;
-			_vm->_draw->destSpriteY = destY;
-			_vm->_draw->transparency = transp;
+			_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->_transparency = transp;
 			_vm->_draw->spriteOperation(DRAW_BLITSURF);
 		}
 
@@ -723,9 +723,9 @@
 		spr = animPictToSprite[animation * 7 + i];
 		spriteRefs[spr]--;
 		if (spriteRefs[spr] == 0) {
-			_vm->_video->freeSurfDesc(_vm->_draw->spritesArray[spr]);
+			_vm->_video->freeSurfDesc(_vm->_draw->_spritesArray[spr]);
 
-			_vm->_draw->spritesArray[spr] = 0;
+			_vm->_draw->_spritesArray[spr] = 0;
 			spriteResId[spr] = -1;
 		}
 	}





More information about the Scummvm-git-logs mailing list