[Scummvm-cvs-logs] CVS: scummvm/scumm actor.cpp,1.181,1.182 actor.h,1.43,1.44 akos.cpp,1.85,1.86 akos.h,1.24,1.25 base-costume.h,1.13,1.14 bomp.cpp,2.11,2.12 boxes.cpp,1.65,1.66 camera.cpp,2.11,2.12 charset.cpp,2.64,2.65 charset.h,2.20,2.21 costume.cpp,1.114,1.115 costume.h,1.23,1.24 debugger.cpp,1.90,1.91 debugger.h,1.26,1.27 dialogs.cpp,1.72,1.73 dialogs.h,1.23,1.24 gfx.cpp,2.215,2.216 gfx.h,1.46,1.47 imuse.cpp,2.101,2.102 imuse.h,1.46,1.47 imuse_digi.cpp,1.48,1.49 imuse_digi.h,1.14,1.15 imuse_internal.h,2.26,2.27 intern.h,2.113,2.114 nut_renderer.cpp,1.32,1.33 nut_renderer.h,1.13,1.14 object.cpp,1.142,1.143 player_mod.cpp,2.6,2.7 player_mod.h,2.5,2.6 player_v1.cpp,1.10,1.11 player_v1.h,1.7,1.8 player_v2.cpp,2.35,2.36 player_v2.h,2.16,2.17 player_v2a.cpp,2.8,2.9 player_v2a.h,2.1,2.2 player_v3a.cpp,1.12,1.13 player_v3a.h,1.9,1.10 resource.cpp,1.162,1.163 resource_v2.cpp,1.33,1.34 resource_v3.cpp,1.21,1.22 resource_v4.cpp,1.6,1.7 saveload.cpp,1.110,1.111 script.cpp,1.134,1.135 script_v2.cpp,2.203,2.204 script_v5.cpp,1.194,1.195 script_v6.cpp,1.200,1.201 script_v8.cpp,2.197,2.198 scumm.h,1.306,1.307 scummvm.cpp,2.411,2.412 sound.cpp,1.259,1.260 sound.h,1.48,1.49 string.cpp,1.160,1.161 usage_bits.cpp,1.7,1.8 vars.cpp,1.59,1.60 verbs.cpp,1.79,1.80

Max Horn fingolfin at users.sourceforge.net
Thu Oct 2 15:43:07 CEST 2003


Update of /cvsroot/scummvm/scummvm/scumm
In directory sc8-pr-cvs1:/tmp/cvs-serv16448

Modified Files:
	actor.cpp actor.h akos.cpp akos.h base-costume.h bomp.cpp 
	boxes.cpp camera.cpp charset.cpp charset.h costume.cpp 
	costume.h debugger.cpp debugger.h dialogs.cpp dialogs.h 
	gfx.cpp gfx.h imuse.cpp imuse.h imuse_digi.cpp imuse_digi.h 
	imuse_internal.h intern.h nut_renderer.cpp nut_renderer.h 
	object.cpp player_mod.cpp player_mod.h player_v1.cpp 
	player_v1.h player_v2.cpp player_v2.h player_v2a.cpp 
	player_v2a.h player_v3a.cpp player_v3a.h resource.cpp 
	resource_v2.cpp resource_v3.cpp resource_v4.cpp saveload.cpp 
	script.cpp script_v2.cpp script_v5.cpp script_v6.cpp 
	script_v8.cpp scumm.h scummvm.cpp sound.cpp sound.h string.cpp 
	usage_bits.cpp vars.cpp verbs.cpp 
Log Message:
renamed class Scumm to ScummEngine (consisten with other engine names; also makes room for a potential 'Scumm' namespace)

Index: actor.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/actor.cpp,v
retrieving revision 1.181
retrieving revision 1.182
diff -u -d -r1.181 -r1.182
--- actor.cpp	2 Oct 2003 17:43:02 -0000	1.181
+++ actor.cpp	2 Oct 2003 22:42:02 -0000	1.182
@@ -33,9 +33,9 @@
 #include "usage_bits.h"
 
 byte Actor::kInvalidBox = 0;
-Scumm *Actor::_vm = 0;
+ScummEngine *Actor::_vm = 0;
 
-void Actor::initActorClass(Scumm *scumm) {
+void Actor::initActorClass(ScummEngine *scumm) {
 	_vm = scumm;
 	if (_vm->_features & GF_SMALL_HEADER) {
 		kInvalidBox = 255;
@@ -141,7 +141,7 @@
 	}
 }
 
-int Scumm::getAngleFromPos(int x, int y) const {
+int ScummEngine::getAngleFromPos(int x, int y) const {
 	if (_gameId == GID_DIG || _gameId == GID_CMI) {
 		double temp = atan2((double)x, (double)-y);
 		return normalizeAngle((int)(temp * 180 / 3.1415926535));
@@ -783,7 +783,7 @@
 	needRedraw = true;
 }
 
-void Scumm::showActors() {
+void ScummEngine::showActors() {
 	int i;
 
 	for (i = 1; i < _numActors; i++) {
@@ -792,7 +792,7 @@
 	}
 }
 
-void Scumm::walkActors() {
+void ScummEngine::walkActors() {
 	int i;
 
 	for (i = 1; i < _numActors; i++) {
@@ -805,7 +805,7 @@
 }
 
 /* Used in Scumm v5 only. Play sounds associated with actors */
-void Scumm::playActorSounds() {
+void ScummEngine::playActorSounds() {
 	int i;
 
 	for (i = 1; i < _numActors; i++) {
@@ -820,7 +820,7 @@
 	}
 }
 
-Actor *Scumm::derefActor(int id, const char *errmsg) const {
+Actor *ScummEngine::derefActor(int id, const char *errmsg) const {
 	if (id == 0)
 		debug(3, "derefActor(0, \"%s\") in script %d, opcode 0x%x", errmsg, vm.slot[_curExecScript].number, _opcode);
 	if (id < 0 || id >= _numActors || _actors[id].number != id) {
@@ -832,7 +832,7 @@
 	return &_actors[id];
 }
 
-Actor *Scumm::derefActorSafe(int id, const char *errmsg) const {
+Actor *ScummEngine::derefActorSafe(int id, const char *errmsg) const {
 	if (id == 0)
 		debug(3, "derefActorSafe(0, \"%s\") in script %d, opcode 0x%x", errmsg, vm.slot[_curExecScript].number, _opcode);
 	if (id < 0 || id >= _numActors || _actors[id].number != id) {
@@ -871,7 +871,7 @@
 	return actor1->number - actor2->number;
 }
 
-void Scumm::processActors() {
+void ScummEngine::processActors() {
 	int numactors = 0;
 
 	// TODO : put this actors as a member array. It never has to grow or shrink
@@ -912,7 +912,7 @@
 
 // Used in Scumm v8, to allow the verb coin to be drawn over the inventory
 // chest. I'm assuming that draw order won't matter here.
-void Scumm::processUpperActors() {
+void ScummEngine::processUpperActors() {
 	int i;
 
 	for (i = 1; i < _numActors; i++) {
@@ -1069,7 +1069,7 @@
 	}
 }
 
-void Scumm::setActorRedrawFlags() {
+void ScummEngine::setActorRedrawFlags() {
 	int i, j;
 
 	if (_fullRedraw) {
@@ -1090,7 +1090,7 @@
 	}
 }
 
-void Scumm::resetActorBgs() {
+void ScummEngine::resetActorBgs() {
 	int i, j;
 
 	for (i = 0; i < gdi._numStrips; i++) {
@@ -1112,7 +1112,7 @@
 	}
 }
 
-int Scumm::getActorFromPos(int x, int y) {
+int ScummEngine::getActorFromPos(int x, int y) {
 	int i;
 
 	if (!testGfxAnyUsageBits(x >> 3))
@@ -1127,7 +1127,7 @@
 	return 0;
 }
 
-void Scumm::actorTalk() {
+void ScummEngine::actorTalk() {
 	Actor *a;
 
 	_msgPtrToAdd = _charsetBuffer;
@@ -1179,7 +1179,7 @@
 	CHARSET_1();
 }
 
-void Scumm::stopTalk() {
+void ScummEngine::stopTalk() {
 	int act;
 
 	_sound->stopTalkSound();
@@ -1200,7 +1200,7 @@
 	restoreCharsetBg();
 }
 
-void Scumm::clearMsgQueue() {
+void ScummEngine::clearMsgQueue() {
 	_messagePtr = (const byte *)" ";
 	stopTalk();
 }

Index: actor.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/actor.h,v
retrieving revision 1.43
retrieving revision 1.44
diff -u -d -r1.43 -r1.44
--- actor.h	2 Oct 2003 17:43:02 -0000	1.43
+++ actor.h	2 Oct 2003 22:42:02 -0000	1.44
@@ -79,7 +79,7 @@
 public:
 	static byte kInvalidBox;
 	
-	static void initActorClass(Scumm *scumm);
+	static void initActorClass(ScummEngine *scumm);
 
 public:
 	Common::Point _pos;
@@ -119,7 +119,7 @@
 	ActorWalkData walkdata;
 	int16 animVariable[16];
 
-	static Scumm *_vm;
+	static ScummEngine *_vm;
 
 public:
 

Index: akos.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/akos.cpp,v
retrieving revision 1.85
retrieving revision 1.86
diff -u -d -r1.85 -r1.86
--- akos.cpp	18 Aug 2003 10:56:21 -0000	1.85
+++ akos.cpp	2 Oct 2003 22:42:02 -0000	1.86
@@ -112,7 +112,7 @@
 	}
 }
 
-bool Scumm::akos_hasManyDirections(Actor *a) {
+bool ScummEngine::akos_hasManyDirections(Actor *a) {
 	byte *akos;
 	const AkosHeader *akhd;
 
@@ -123,14 +123,14 @@
 	return (akhd->flags & 2) != 0;
 }
 
-int Scumm::akos_frameToAnim(Actor *a, int frame) {
+int ScummEngine::akos_frameToAnim(Actor *a, int frame) {
 	if (akos_hasManyDirections(a))
 		return toSimpleDir(1, a->getFacing()) + frame * 8;
 	else
 		return newDirToOldDir(a->getFacing()) + frame * 4;
 }
 
-void Scumm::akos_decodeData(Actor *a, int frame, uint usemask) {
+void ScummEngine::akos_decodeData(Actor *a, int frame, uint usemask) {
 	uint anim;
 	const byte *akos, *r;
 	const AkosHeader *akhd;
@@ -1057,7 +1057,7 @@
 	return 0;
 }
 
-bool Scumm::akos_increaseAnims(const byte *akos, Actor *a) {
+bool ScummEngine::akos_increaseAnims(const byte *akos, Actor *a) {
 	const byte *aksq, *akfo;
 	int i;
 	uint size;
@@ -1080,7 +1080,7 @@
 #define GUW(o) READ_LE_UINT16(aksq+curpos+(o))
 #define GB(o) aksq[curpos+(o)]
 
-bool Scumm::akos_increaseAnim(Actor *a, int chan, const byte *aksq, const uint16 *akfo, int numakfo) {
+bool ScummEngine::akos_increaseAnim(Actor *a, int chan, const byte *aksq, const uint16 *akfo, int numakfo) {
 	byte active;
 	uint old_curpos, curpos, end;
 	uint code;
@@ -1313,7 +1313,7 @@
 	return curpos != old_curpos;
 }
 
-void Scumm::akos_queCommand(byte cmd, Actor *a, int param_1, int param_2) {
+void ScummEngine::akos_queCommand(byte cmd, Actor *a, int param_1, int param_2) {
 	switch (cmd) {
 	case 1:
 		a->putActor(0, 0, 0);

Index: akos.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/akos.h,v
retrieving revision 1.24
retrieving revision 1.25
diff -u -d -r1.24 -r1.25
--- akos.h	19 Jun 2003 16:03:12 -0000	1.24
+++ akos.h	2 Oct 2003 22:42:02 -0000	1.25
@@ -63,7 +63,7 @@
 	} akos16;
 
 public:
-	AkosRenderer(Scumm *scumm) : BaseCostumeRenderer(scumm) {
+	AkosRenderer(ScummEngine *scumm) : BaseCostumeRenderer(scumm) {
 		akos = 0;
 		akhd = 0;
 		akpl = 0;

Index: base-costume.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/base-costume.h,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -d -r1.13 -r1.14
--- base-costume.h	1 Aug 2003 12:18:40 -0000	1.13
+++ base-costume.h	2 Oct 2003 22:42:02 -0000	1.14
@@ -41,7 +41,7 @@
 #endif
 
 class Actor;
-class Scumm;
+class ScummEngine;
 
 /**
  * Base class for both CostumeRenderer and AkosRenderer.
@@ -64,7 +64,7 @@
 	uint _outwidth, _outheight;
 
 protected:
-	Scumm *_vm;
+	ScummEngine *_vm;
 	int32 _numStrips;
 
 	// Source pointer
@@ -95,7 +95,7 @@
 	} v1;
 
 public:
-	BaseCostumeRenderer(Scumm *scumm) {
+	BaseCostumeRenderer(ScummEngine *scumm) {
 		_dirty_id = 0;
 		_shadow_mode = 0;
 		_shadow_table = 0;

Index: bomp.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/bomp.cpp,v
retrieving revision 2.11
retrieving revision 2.12
diff -u -d -r2.11 -r2.12
--- bomp.cpp	18 Aug 2003 15:13:14 -0000	2.11
+++ bomp.cpp	2 Oct 2003 22:42:02 -0000	2.12
@@ -192,7 +192,7 @@
 	}
 }
 
-void Scumm::drawBomp(const BompDrawData &bd, bool mirror) {
+void ScummEngine::drawBomp(const BompDrawData &bd, bool mirror) {
 	const byte *src;
 	byte *dst;
 	byte maskbit;

Index: boxes.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/boxes.cpp,v
retrieving revision 1.65
retrieving revision 1.66
diff -u -d -r1.65 -r1.66
--- boxes.cpp	2 Oct 2003 17:43:02 -0000	1.65
+++ boxes.cpp	2 Oct 2003 22:42:02 -0000	1.66
@@ -80,7 +80,7 @@
 static Common::Point closestPtOnLine(int ulx, int uly, int llx, int lly, int x, int y);
 
 
-byte Scumm::getMaskFromBox(int box) {
+byte ScummEngine::getMaskFromBox(int box) {
 	// Fix for bug #740244 and #755863. This appears to have been a 
 	// long standing bug in the original engine?
 	if (_version <= 3 && box == 255)
@@ -98,7 +98,7 @@
 		return ptr->old.mask;
 }
 
-void Scumm::setBoxFlags(int box, int val) {
+void ScummEngine::setBoxFlags(int box, int val) {
 	debug(2, "setBoxFlags(%d, 0x%02x)", box, val);
 
 	/* FULL_THROTTLE stuff */
@@ -117,7 +117,7 @@
 	}
 }
 
-byte Scumm::getBoxFlags(int box) {
+byte ScummEngine::getBoxFlags(int box) {
 	Box *ptr = getBoxBaseAddr(box);
 	if (!ptr)
 		return 0;
@@ -129,7 +129,7 @@
 		return ptr->old.flags;
 }
 
-void Scumm::setBoxScale(int box, int scale) {
+void ScummEngine::setBoxScale(int box, int scale) {
 	Box *ptr = getBoxBaseAddr(box);
 	assert(ptr);
 	if (_version == 8)
@@ -140,13 +140,13 @@
 		ptr->old.scale = TO_LE_16(scale);
 }
 
-void Scumm::setBoxScaleSlot(int box, int slot) {
+void ScummEngine::setBoxScaleSlot(int box, int slot) {
 	Box *ptr = getBoxBaseAddr(box);
 	assert(ptr);
 	ptr->v8.scaleSlot = TO_LE_32(slot);
 }
 
-int Scumm::getScale(int box, int x, int y) {
+int ScummEngine::getScale(int box, int x, int y) {
 	if (_features & GF_NO_SCALING)
 		return 255;
 
@@ -207,7 +207,7 @@
 	return scale;
 }
 
-int Scumm::getBoxScale(int box) {
+int ScummEngine::getBoxScale(int box) {
 	if (_features & GF_NO_SCALING)
 		return 255;
 	Box *ptr = getBoxBaseAddr(box);
@@ -233,7 +233,7 @@
  * To accomodate old savegames, we attempt here to convert rtScaleTable
  * resources to scale slots.
  */
-void Scumm::convertScaleTableToScaleSlot(int slot) {
+void ScummEngine::convertScaleTableToScaleSlot(int slot) {
 	assert(1 <= slot && slot <= ARRAYSIZE(_scaleSlots));
 
 	byte *resptr = getResourceAddress(rtScaleTable, slot);
@@ -333,7 +333,7 @@
 		warning("scale item %d, variance %f exceeds 1 (room %d)\n", slot, variance, _currentRoom);
 }
 
-void Scumm::setScaleSlot(int slot, int x1, int y1, int scale1, int x2, int y2, int scale2) {
+void ScummEngine::setScaleSlot(int slot, int x1, int y1, int scale1, int x2, int y2, int scale2) {
 	assert(1 <= slot && slot <= ARRAYSIZE(_scaleSlots));
 	ScaleSlot &s = _scaleSlots[slot-1];
 	s.x2 = x2;
@@ -344,7 +344,7 @@
 	s.scale1 = scale1;
 }
 
-byte Scumm::getNumBoxes() {
+byte ScummEngine::getNumBoxes() {
 	byte *ptr = getResourceAddress(rtMatrix, 2);
 	if (!ptr)
 		return 0;
@@ -354,7 +354,7 @@
 		return ptr[0];
 }
 
-Box *Scumm::getBoxBaseAddr(int box) {
+Box *ScummEngine::getBoxBaseAddr(int box) {
 	byte *ptr = getResourceAddress(rtMatrix, 2);
 	if (!ptr || box == 255)
 		return NULL;
@@ -391,7 +391,7 @@
 		return (Box *)(ptr + box * SIZEOF_BOX + 2);
 }
 
-int Scumm::getSpecialBox(int x, int y) {
+int ScummEngine::getSpecialBox(int x, int y) {
 	int i;
 	int numOfBoxes;
 	byte flag;
@@ -411,7 +411,7 @@
 	return (-1);
 }
 
-bool Scumm::checkXYInBoxBounds(int b, int x, int y) {
+bool ScummEngine::checkXYInBoxBounds(int b, int x, int y) {
 	BoxCoords box;
 
 	if (b < 0 || b == Actor::kInvalidBox)
@@ -455,7 +455,7 @@
 	return true;
 }
 
-void Scumm::getBoxCoordinates(int boxnum, BoxCoords *box) {
+void ScummEngine::getBoxCoordinates(int boxnum, BoxCoords *box) {
 	Box *bp = getBoxBaseAddr(boxnum);
 	assert(bp);
 
@@ -514,7 +514,7 @@
 	}
 }
 
-uint Scumm::distanceFromPt(int x, int y, int ptx, int pty) {
+uint ScummEngine::distanceFromPt(int x, int y, int ptx, int pty) {
 	int diffx, diffy;
 
 	diffx = abs(ptx - x);
@@ -615,7 +615,7 @@
 	return pt;
 }
 
-bool Scumm::inBoxQuickReject(int b, int x, int y, int threshold) {
+bool ScummEngine::inBoxQuickReject(int b, int x, int y, int threshold) {
 	int t;
 	BoxCoords box;
 
@@ -640,7 +640,7 @@
 	return false;
 }
 
-int Scumm::getClosestPtOnBox(int b, int x, int y, int16& outX, int16& outY) {
+int ScummEngine::getClosestPtOnBox(int b, int x, int y, int16& outX, int16& outY) {
 	Common::Point pt;
 	uint dist;
 	uint bestdist = 0xFFFFFF;
@@ -683,7 +683,7 @@
 	return bestdist;
 }
 
-byte *Scumm::getBoxMatrixBaseAddr() {
+byte *ScummEngine::getBoxMatrixBaseAddr() {
 	byte *ptr = getResourceAddress(rtMatrix, 1);
 	assert(ptr);
 	if (*ptr == 0xFF)
@@ -697,7 +697,7 @@
  * way to 'to' (this can be 'to' itself or a third box).
  * If there is no connection -1 is return.
  */
-int Scumm::getPathToDestBox(byte from, byte to) {
+int ScummEngine::getPathToDestBox(byte from, byte to) {
 	const byte *boxm;
 	byte i;
 	const int numOfBoxes = getNumBoxes();
@@ -936,7 +936,7 @@
 }
 #endif
 
-void Scumm::createBoxMatrix() {
+void ScummEngine::createBoxMatrix() {
 	int num, i, j, k;
 	byte *adjacentMatrix, *itineraryMatrix;
 
@@ -1033,7 +1033,7 @@
 }
 
 /** Check if two boxes are neighbours. */
-bool Scumm::areBoxesNeighbours(int box1nr, int box2nr) {
+bool ScummEngine::areBoxesNeighbours(int box1nr, int box2nr) {
 	int j, k, m, n;
 	int tmp_x, tmp_y;
 	bool result;
@@ -1183,7 +1183,7 @@
  * This way the lines bound a 'corridor' between the two boxes, through which
  * the actor has to walk to get from trap1 to trap2.
  */
-void Scumm::getGates(int trap1, int trap2, Common::Point gateA[2], Common::Point gateB[2]) {
+void ScummEngine::getGates(int trap1, int trap2, Common::Point gateA[2], Common::Point gateB[2]) {
 	int i, j;
 	int dist[8];
 	int minDist[3];

Index: camera.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/camera.cpp,v
retrieving revision 2.11
retrieving revision 2.12
diff -u -d -r2.11 -r2.12
--- camera.cpp	2 Oct 2003 17:43:02 -0000	2.11
+++ camera.cpp	2 Oct 2003 22:42:02 -0000	2.12
@@ -25,7 +25,7 @@
 #include "actor.h"
 #include "charset.h"
 
-void Scumm::setCameraAtEx(int at) {
+void ScummEngine::setCameraAtEx(int at) {
 	if (!(_features & GF_NEW_CAMERA)) {
 		camera._mode = CM_NORMAL;
 		camera._cur.x = at;
@@ -34,7 +34,7 @@
 	}
 }
 
-void Scumm::setCameraAt(int pos_x, int pos_y) {
+void ScummEngine::setCameraAt(int pos_x, int pos_y) {
 	if (camera._mode != CM_FOLLOW_ACTOR || abs(pos_x - camera._cur.x) > (_screenWidth / 2)) {
 		camera._cur.x = pos_x;
 	}
@@ -59,7 +59,7 @@
 		stopTalk();
 }
 
-void Scumm_v7::setCameraAt(int pos_x, int pos_y) {
+void ScummEngine_v7::setCameraAt(int pos_x, int pos_y) {
 	Common::Point old;
 
 	old = camera._cur;
@@ -83,7 +83,7 @@
 	}
 }
 
-void Scumm::setCameraFollows(Actor *a) {
+void ScummEngine::setCameraFollows(Actor *a) {
 
 	int t, i;
 
@@ -109,7 +109,7 @@
 	runInventoryScript(0);
 }
 
-void Scumm_v7::setCameraFollows(Actor *a) {
+void ScummEngine_v7::setCameraFollows(Actor *a) {
 
 	byte oldfollow = camera._follows;
 	int ax, ay;
@@ -133,7 +133,7 @@
 }
 
 
-void Scumm::clampCameraPos(Common::Point *pt) {
+void ScummEngine::clampCameraPos(Common::Point *pt) {
 	if (pt->x < VAR(VAR_CAMERA_MIN_X))
 		pt->x = (short) VAR(VAR_CAMERA_MIN_X);
 
@@ -147,7 +147,7 @@
 		pt->y = (short) VAR(VAR_CAMERA_MAX_Y);
 }
 
-void Scumm::moveCamera() {
+void ScummEngine::moveCamera() {
 	int pos = camera._cur.x;
 	int actorx, t;
 	Actor *a = NULL;
@@ -225,7 +225,7 @@
 	}
 }
 
-void Scumm_v7::moveCamera() {
+void ScummEngine_v7::moveCamera() {
 	Common::Point old = camera._cur;
 	Actor *a = NULL;
 
@@ -310,7 +310,7 @@
 }
 
 
-void Scumm::cameraMoved() {
+void ScummEngine::cameraMoved() {
 	if (_features & GF_NEW_CAMERA) {
 		assert(camera._cur.x >= (_screenWidth / 2) && camera._cur.y >= (_screenHeight / 2));
 	} else {
@@ -349,19 +349,19 @@
 	}
 }
 
-void Scumm::panCameraTo(int x, int y) {
+void ScummEngine::panCameraTo(int x, int y) {
 	camera._dest.x = x;
 	camera._mode = CM_PANNING;
 	camera._movingToActor = false;
 }
 
-void Scumm_v7::panCameraTo(int x, int y) {
+void ScummEngine_v7::panCameraTo(int x, int y) {
 	VAR(VAR_CAMERA_FOLLOWED_ACTOR) = camera._follows = 0;
 	VAR(VAR_CAMERA_DEST_X) = camera._dest.x = x;
 	VAR(VAR_CAMERA_DEST_Y) = camera._dest.y = y;
 }
 
-void Scumm::actorFollowCamera(int act) {
+void ScummEngine::actorFollowCamera(int act) {
 	if (!(_features & GF_NEW_CAMERA)) {
 		int old;
 

Index: charset.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/charset.cpp,v
retrieving revision 2.64
retrieving revision 2.65
diff -u -d -r2.64 -r2.65
--- charset.cpp	17 Sep 2003 22:40:58 -0000	2.64
+++ charset.cpp	2 Oct 2003 22:42:02 -0000	2.65
@@ -24,7 +24,7 @@
 #include "nut_renderer.h"
 #include "base/gameDetector.h"
 
-CharsetRenderer::CharsetRenderer(Scumm *vm) {
+CharsetRenderer::CharsetRenderer(ScummEngine *vm) {
 
 	_nextLeft = 0;
 	_nextTop = 0;
@@ -1219,7 +1219,7 @@
 	}
 }
 
-CharsetRendererNut::CharsetRendererNut(Scumm *vm)
+CharsetRendererNut::CharsetRendererNut(ScummEngine *vm)
 	 : CharsetRenderer(vm) {
 	_current = 0;
 

Index: charset.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/charset.h,v
retrieving revision 2.20
retrieving revision 2.21
diff -u -d -r2.20 -r2.21
--- charset.h	2 Oct 2003 17:43:02 -0000	2.20
+++ charset.h	2 Oct 2003 22:42:02 -0000	2.21
@@ -24,7 +24,7 @@
 #include "common/rect.h"
 #include "common/scummsys.h"
 
-class Scumm;
+class ScummEngine;
 class NutRenderer;
 struct VirtScreen;
 
@@ -51,13 +51,13 @@
 	bool _disableOffsX;
 
 protected:
-	Scumm *_vm;
+	ScummEngine *_vm;
 	byte _curId;
 
 	virtual int getCharWidth(byte chr) = 0;
 
 public:
-	CharsetRenderer(Scumm *vm);
+	CharsetRenderer(ScummEngine *vm);
 	virtual ~CharsetRenderer() {}
 
 	virtual void printChar(int chr) = 0;
@@ -80,7 +80,7 @@
 	void drawBits1(VirtScreen *vs, byte *dst, const byte *src, byte *mask, int drawTop, int width, int height);
 
 public:
-	CharsetRendererCommon(Scumm *vm) : CharsetRenderer(vm) {}
+	CharsetRendererCommon(ScummEngine *vm) : CharsetRenderer(vm) {}
 
 	void setCurID(byte id);
 	
@@ -94,7 +94,7 @@
 	void drawBitsN(VirtScreen *vs, byte *dst, const byte *src, byte *mask, byte bpp, int drawTop, int width, int height);
 
 public:
-	CharsetRendererClassic(Scumm *vm) : CharsetRendererCommon(vm) {}
+	CharsetRendererClassic(ScummEngine *vm) : CharsetRendererCommon(vm) {}
 	
 	void printChar(int chr);
 };
@@ -107,7 +107,7 @@
 	int getCharWidth(byte chr);
 
 public:
-	CharsetRendererV3(Scumm *vm) : CharsetRendererCommon(vm) {}
+	CharsetRendererV3(ScummEngine *vm) : CharsetRendererCommon(vm) {}
 	
 	void printChar(int chr);
 	void setCurID(byte id);
@@ -120,7 +120,7 @@
 	int getCharWidth(byte chr) { return 8; }
 
 public:
-	CharsetRendererV2(Scumm *vm) : CharsetRendererV3(vm) {}
+	CharsetRendererV2(ScummEngine *vm) : CharsetRendererV3(vm) {}
 	
 	void setCurID(byte id);
 };
@@ -133,7 +133,7 @@
 	NutRenderer *_current;
 
 public:
-	CharsetRendererNut(Scumm *vm);
+	CharsetRendererNut(ScummEngine *vm);
 	~CharsetRendererNut();
 	
 	void printChar(int chr);

Index: costume.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/costume.cpp,v
retrieving revision 1.114
retrieving revision 1.115
diff -u -d -r1.114 -r1.115
--- costume.cpp	26 Aug 2003 16:09:09 -0000	1.114
+++ costume.cpp	2 Oct 2003 22:42:02 -0000	1.115
@@ -666,11 +666,11 @@
 
 }
 
-int Scumm::cost_frameToAnim(Actor *a, int frame) {
+int ScummEngine::cost_frameToAnim(Actor *a, int frame) {
 	return newDirToOldDir(a->getFacing()) + frame * 4;
 }
 
-void Scumm::cost_decodeData(Actor *a, int frame, uint usemask) {
+void ScummEngine::cost_decodeData(Actor *a, int frame, uint usemask) {
 	const byte *r;
 	uint mask, j;
 	int i;
@@ -842,7 +842,7 @@
 	} while (1);
 }
 
-bool Scumm::isCostumeInUse(int cost) const {
+bool ScummEngine::isCostumeInUse(int cost) const {
 	int i;
 	Actor *a;
 

Index: costume.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/costume.h,v
retrieving revision 1.23
retrieving revision 1.24
diff -u -d -r1.23 -r1.24
--- costume.h	17 Aug 2003 16:53:00 -0000	1.23
+++ costume.h	2 Oct 2003 22:42:02 -0000	1.24
@@ -25,7 +25,7 @@
 
 class LoadedCostume {
 protected:
-	Scumm *_vm;
+	ScummEngine *_vm;
 
 public:
 	int _id;
@@ -39,7 +39,7 @@
 	byte _format;
 	bool _mirror;
 
-	LoadedCostume(Scumm *vm) :
+	LoadedCostume(ScummEngine *vm) :
 		_vm(vm), _id(-1), _baseptr(0), _animCmds(0), _dataOffsets(0), _palette(0),
 		_frameOffsets(0), _numColors(0), _numAnim(0), _format(0), _mirror(false) {}
 
@@ -60,7 +60,7 @@
 	byte _palette[32];
 
 public:
-	CostumeRenderer(Scumm *vm) : BaseCostumeRenderer(vm), _loaded(vm) {}
+	CostumeRenderer(ScummEngine *vm) : BaseCostumeRenderer(vm), _loaded(vm) {}
 
 	void setPalette(byte *palette);
 	void setFacing(Actor *a);

Index: debugger.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/debugger.cpp,v
retrieving revision 1.90
retrieving revision 1.91
diff -u -d -r1.90 -r1.91
--- debugger.cpp	24 Sep 2003 06:56:30 -0000	1.90
+++ debugger.cpp	2 Oct 2003 22:42:02 -0000	1.91
@@ -55,7 +55,7 @@
 }
 
 // Initialisation Functions
-void ScummDebugger::attach(Scumm *s, char *entry) {
+void ScummDebugger::attach(ScummEngine *s, char *entry) {
 
 #ifdef _WIN32_WCE
 	force_keyboard(true);
@@ -850,7 +850,7 @@
 static int gfxPrimitivesCompareInt(const void *a, const void *b);
 
 
-static void hlineColor(Scumm *scumm, int x1, int x2, int y, byte color)
+static void hlineColor(ScummEngine *scumm, int x1, int x2, int y, byte color)
 {
 	VirtScreen *vs = &scumm->virtscr[0];
 	byte *ptr;
@@ -884,7 +884,7 @@
 	return (*(const int *)a) - (*(const int *)b);
 }
 
-static void fillQuad(Scumm *scumm, int16 vx[4], int16 vy[4], int color)
+static void fillQuad(ScummEngine *scumm, int16 vx[4], int16 vy[4], int color)
 {
 	const int N = 4;
 	int i;

Index: debugger.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/debugger.h,v
retrieving revision 1.26
retrieving revision 1.27
diff -u -d -r1.26 -r1.27
--- debugger.h	11 Aug 2003 14:48:21 -0000	1.26
+++ debugger.h	2 Oct 2003 22:42:02 -0000	1.27
@@ -24,7 +24,7 @@
 // Choose between text console or ScummConsole
 #define USE_CONSOLE	1
 
-class Scumm;
+class ScummEngine;
 class ScummDebugger;
 
 typedef bool (ScummDebugger::*DebugProc)(int argc, const char **argv);
@@ -52,10 +52,10 @@
 	ScummDebugger();
 	
 	void on_frame();
-	void attach(Scumm *s, char *entry);
+	void attach(ScummEngine *s, char *entry);
 
 protected:
-	Scumm *_s;
+	ScummEngine *_s;
 	int _frame_countdown, _dvar_count, _dcmd_count;
 	DVar _dvars[256];
 	DCmd _dcmds[256];

Index: dialogs.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/dialogs.cpp,v
retrieving revision 1.72
retrieving revision 1.73
diff -u -d -r1.72 -r1.73
--- dialogs.cpp	2 Oct 2003 17:43:02 -0000	1.72
+++ dialogs.cpp	2 Oct 2003 22:42:02 -0000	1.73
@@ -227,7 +227,7 @@
 	kQuitCmd = 'QUIT'
 };
 
-SaveLoadDialog::SaveLoadDialog(NewGui *gui, Scumm *scumm)
+SaveLoadDialog::SaveLoadDialog(NewGui *gui, ScummEngine *scumm)
 	: ScummDialog(gui, scumm, 20, 8, 280, 184) {
 	const int x = _w - kButtonWidth - 8;
 	int y = 20;
@@ -423,10 +423,10 @@
 };
 
 #ifndef _WIN32_WCE
-OptionsDialog::OptionsDialog(NewGui *gui, Scumm *scumm)
+OptionsDialog::OptionsDialog(NewGui *gui, ScummEngine *scumm)
 	: ScummDialog(gui, scumm, 40, 30, 240, 124) {
 #else
-OptionsDialog::OptionsDialog(NewGui *gui, Scumm *scumm)
+OptionsDialog::OptionsDialog(NewGui *gui, ScummEngine *scumm)
 	: ScummDialog(gui, scumm, 40, 30, 240, 124 + kButtonHeight + 4) {
 #endif
 	//
@@ -580,7 +580,7 @@
 	kPrevCmd = 'PREV'
 };
 
-HelpDialog::HelpDialog(NewGui *gui, Scumm *scumm)
+HelpDialog::HelpDialog(NewGui *gui, ScummEngine *scumm)
 	: ScummDialog(gui, scumm, 5, 5, 310, 190) {
 
 	_page = 1;
@@ -650,12 +650,12 @@
 
 #pragma mark -
 
-InfoDialog::InfoDialog(NewGui *gui, Scumm *scumm, int res)
+InfoDialog::InfoDialog(NewGui *gui, ScummEngine *scumm, int res)
 : ScummDialog(gui, scumm, 0, 80, 0, 16) { // dummy x and w
 	setInfoText(queryResString (res));
 }
 
-InfoDialog::InfoDialog(NewGui *gui, Scumm *scumm, const String& message)
+InfoDialog::InfoDialog(NewGui *gui, ScummEngine *scumm, const String& message)
 : ScummDialog(gui, scumm, 0, 80, 0, 16) { // dummy x and w
 	setInfoText(message);
 }
@@ -671,11 +671,11 @@
 
 #pragma mark -
 
-PauseDialog::PauseDialog(NewGui *gui, Scumm *scumm)
+PauseDialog::PauseDialog(NewGui *gui, ScummEngine *scumm)
 	: InfoDialog(gui, scumm, 10) {
 }
 
-ConfirmExitDialog::ConfirmExitDialog(NewGui *gui, Scumm *scumm)
+ConfirmExitDialog::ConfirmExitDialog(NewGui *gui, ScummEngine *scumm)
 	: InfoDialog(gui, scumm, "Do you really want to quit (y/n)?") {
 }
 
@@ -699,7 +699,7 @@
 };
 
 
-KeysDialog::KeysDialog(NewGui *gui, Scumm *scumm)
+KeysDialog::KeysDialog(NewGui *gui, ScummEngine *scumm)
 	: ScummDialog(gui, scumm, 30, 20, 260, 160) {
 	addButton(160, 20, queryCustomString(24), kMapCmd, 'M');	// Map
 	addButton(160, 40, "OK", kOKCmd, 'O');						// OK

Index: dialogs.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/dialogs.h,v
retrieving revision 1.23
retrieving revision 1.24
diff -u -d -r1.23 -r1.24
--- dialogs.h	2 Oct 2003 17:43:02 -0000	1.23
+++ dialogs.h	2 Oct 2003 22:42:02 -0000	1.24
@@ -30,17 +30,17 @@
 #endif
 
 class ListWidget;
-class Scumm;
+class ScummEngine;
 
 class ScummDialog : public Dialog {
 public:
-	ScummDialog(NewGui *gui, Scumm *scumm, int x, int y, int w, int h)
+	ScummDialog(NewGui *gui, ScummEngine *scumm, int x, int y, int w, int h)
 		: Dialog(gui, x, y, w, h), _scumm(scumm) {}
 	
 protected:
 	typedef Common::String String;
 
-	Scumm *_scumm;
+	ScummEngine *_scumm;
 
 	void addResText(int x, int y, int w, int h, int resID);
 
@@ -54,7 +54,7 @@
 
 class SaveLoadDialog : public ScummDialog {
 public:
-	SaveLoadDialog(NewGui *gui, Scumm *scumm);
+	SaveLoadDialog(NewGui *gui, ScummEngine *scumm);
 	~SaveLoadDialog();
 	virtual void handleCommand(CommandSender *sender, uint32 cmd, uint32 data);
 	virtual void open();	
@@ -84,7 +84,7 @@
 
 class HelpDialog : public ScummDialog {
 public:
-	HelpDialog(NewGui *gui, Scumm *scumm);
+	HelpDialog(NewGui *gui, ScummEngine *scumm);
 	virtual void handleCommand(CommandSender *sender, uint32 cmd, uint32 data);
 
 protected:
@@ -112,7 +112,7 @@
 #endif
 
 public:
-	OptionsDialog(NewGui *gui, Scumm *scumm);
+	OptionsDialog(NewGui *gui, ScummEngine *scumm);
 	~OptionsDialog();
 
 	virtual void open();
@@ -139,9 +139,9 @@
 class InfoDialog : public ScummDialog {
 public:
 	// arbitrary message
-	InfoDialog(NewGui *gui, Scumm *scumm, const String& message);
+	InfoDialog(NewGui *gui, ScummEngine *scumm, const String& message);
 	// from resources
-	InfoDialog(NewGui *gui, Scumm *scumm, int res);
+	InfoDialog(NewGui *gui, ScummEngine *scumm, int res);
 
 	virtual void handleMouseDown(int x, int y, int button, int clickCount) { 
 		close();
@@ -157,7 +157,7 @@
 
 class PauseDialog : public InfoDialog {
 public:
-	PauseDialog(NewGui *gui, Scumm *scumm);
+	PauseDialog(NewGui *gui, ScummEngine *scumm);
 	virtual void handleKeyDown(uint16 ascii, int keycode, int modifiers)
 		{
 			if (ascii == ' ')  // Close pause dialog if space key is pressed
@@ -169,7 +169,7 @@
 
 class ConfirmExitDialog : public InfoDialog {
 public:
-	ConfirmExitDialog(NewGui *gui, Scumm *scumm);
+	ConfirmExitDialog(NewGui *gui, ScummEngine *scumm);
 	virtual void handleKeyDown(uint16 ascii, int keycode, int modifiers);
 };
 
@@ -177,7 +177,7 @@
 
 class KeysDialog : public ScummDialog {
 public:
-	KeysDialog(NewGui *gui, Scumm *scumm);
+	KeysDialog(NewGui *gui, ScummEngine *scumm);
 
 	virtual void handleCommand(CommandSender *sender, uint32 cmd, uint32 data);
 	virtual void handleKeyDown(uint16 ascii, int keycode, int modifiers);

Index: gfx.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/gfx.cpp,v
retrieving revision 2.215
retrieving revision 2.216
diff -u -d -r2.215 -r2.216
--- gfx.cpp	2 Oct 2003 17:43:02 -0000	2.215
+++ gfx.cpp	2 Oct 2003 22:42:02 -0000	2.216
@@ -193,7 +193,7 @@
 	return 3 * red * red + 6 * green * green + 2 * blue * blue;
 }
 
-void Scumm::getGraphicsPerformance() {
+void ScummEngine::getGraphicsPerformance() {
 	int i;
 
 	for (i = 10; i != 0; i--) {
@@ -217,7 +217,7 @@
 		initScreens(0, 16, _screenWidth, 144);
 }
 
-void Scumm::initScreens(int a, int b, int w, int h) {
+void ScummEngine::initScreens(int a, int b, int w, int h) {
 	int i;
 
 	for (i = 0; i < 3; i++) {
@@ -241,7 +241,7 @@
 
 }
 
-void Scumm::initVirtScreen(int slot, int number, int top, int width, int height, bool twobufs,
+void ScummEngine::initVirtScreen(int slot, int number, int top, int width, int height, bool twobufs,
 													 bool scrollable) {
 	VirtScreen *vs = &virtscr[slot];
 	int size;
@@ -286,7 +286,7 @@
 	}
 }
 
-VirtScreen *Scumm::findVirtScreen(int y) {
+VirtScreen *ScummEngine::findVirtScreen(int y) {
 	VirtScreen *vs = virtscr;
 	int i;
 
@@ -298,7 +298,7 @@
 	return NULL;
 }
 
-void Scumm::updateDirtyRect(int virt, int left, int right, int top, int bottom, int dirtybit) {
+void ScummEngine::updateDirtyRect(int virt, int left, int right, int top, int bottom, int dirtybit) {
 	VirtScreen *vs = &virtscr[virt];
 	int lp, rp;
 
@@ -353,7 +353,7 @@
 	}
 }
 
-void Scumm::drawDirtyScreenParts() {
+void ScummEngine::drawDirtyScreenParts() {
 	int i;
 	VirtScreen *vs;
 	byte *src;
@@ -386,7 +386,7 @@
 	}
 }
 
-void Scumm::updateDirtyScreen(int slot) {
+void ScummEngine::updateDirtyScreen(int slot) {
 	gdi.updateDirtyScreen(&virtscr[slot]);
 }
 
@@ -501,7 +501,7 @@
 	}
 }
 
-void Scumm::blit(byte *dst, const byte *src, int w, int h) {
+void ScummEngine::blit(byte *dst, const byte *src, int w, int h) {
 	assert(h > 0);
 	assert(src != NULL);
 	assert(dst != NULL);
@@ -518,7 +518,7 @@
 	}
 }
 
-void Scumm::drawBox(int x, int y, int x2, int y2, int color) {
+void ScummEngine::drawBox(int x, int y, int x2, int y2, int color) {
 	int width, height;
 	VirtScreen *vs;
 	byte *backbuff, *bgbuff;
@@ -581,7 +581,7 @@
 
 #pragma mark -
 
-void Scumm::initBGBuffers(int height) {
+void ScummEngine::initBGBuffers(int height) {
 	const byte *ptr;
 	int size, itemsize, i;
 	byte *room;
@@ -635,7 +635,7 @@
 	}
 }
 
-void Scumm::drawFlashlight() {
+void ScummEngine::drawFlashlight() {
 	int i, j, offset, x, y;
 
 	// Remove the flash light first if it was previously drawn
@@ -723,7 +723,7 @@
  * Redraw background as needed, i.e. the left/right sides if scrolling took place etc.
  * Note that this only updated the virtual screen, not the actual display.
  */
-void Scumm::redrawBGAreas() {
+void ScummEngine::redrawBGAreas() {
 	int i;
 	int val;
 	int diff;
@@ -773,7 +773,7 @@
 	_BgNeedsRedraw = false;
 }
 
-void Scumm::redrawBGStrip(int start, int num) {
+void ScummEngine::redrawBGStrip(int start, int num) {
 	int s = _screenStartStrip + start;
 
 	assert(s >= 0 && (size_t) s < sizeof(gfxUsageBits) / (3 * sizeof(gfxUsageBits[0])));
@@ -788,7 +788,7 @@
 	               &virtscr[0], s, 0, _roomWidth, virtscr[0].height, s, num, 0, _roomStrips);
 }
 
-void Scumm::restoreCharsetBg() {
+void ScummEngine::restoreCharsetBg() {
 	if (_charset->_hasMask) {
 		restoreBG(gdi._mask);
 		_charset->_hasMask = false;
@@ -802,7 +802,7 @@
 	_charset->_nextTop = _string[0].ypos;
 }
 
-void Scumm::restoreBG(Common::Rect rect, byte backColor) {
+void ScummEngine::restoreBG(Common::Rect rect, byte backColor) {
 	VirtScreen *vs;
 	int topline, height, width;
 	byte *backbuff, *bgbak;
@@ -872,13 +872,13 @@
 	}
 }
 
-bool Scumm::hasCharsetMask(int left, int top, int right, int bottom) {
+bool ScummEngine::hasCharsetMask(int left, int top, int right, int bottom) {
 	Common::Rect rect(left, top, right, bottom);
 	
 	return _charset->_hasMask && rect.intersects(gdi._mask);
 }
 
-byte *Scumm::getMaskBuffer(int x, int y, int z) {
+byte *ScummEngine::getMaskBuffer(int x, int y, int z) {
 	return getResourceAddress(rtBuffer, 9)
 			+ _screenStartStrip + (x / 8) + y * gdi._numStrips + gdi._imgBufOffs[z];
 }
@@ -2172,7 +2172,7 @@
 #pragma mark --- Transition effects ---
 #pragma mark -
 
-void Scumm::fadeIn(int effect) {
+void ScummEngine::fadeIn(int effect) {
 	updatePalette();
 
 	switch (effect) {
@@ -2216,7 +2216,7 @@
 	_screenEffectFlag = true;
 }
 
-void Scumm::fadeOut(int effect) {
+void ScummEngine::fadeOut(int effect) {
 	VirtScreen *vs = &virtscr[0];
 
 	vs->setDirtyRange(0, 0);
@@ -2274,7 +2274,7 @@
  * in a certain order; the exact order determines how the effect appears to the user.
  * @param a		the transition effect to perform
  */
-void Scumm::transitionEffect(int a) {
+void ScummEngine::transitionEffect(int a) {
 	int delta[16];								// Offset applied during each iteration
 	int tab_2[16];
 	int i, j;
@@ -2335,7 +2335,7 @@
  * dissolveEffect(8, 8) produces a square-by-square dissolve
  * dissolveEffect(virtsrc[0].width, 1) produces a line-by-line dissolve
  */
-void Scumm::dissolveEffect(int width, int height) {
+void ScummEngine::dissolveEffect(int width, int height) {
 	VirtScreen *vs = &virtscr[0];
 	int *offsets;
 	int blits_before_refresh, blits;
@@ -2441,7 +2441,7 @@
 	}
 }
 
-void Scumm::scrollEffect(int dir) {
+void ScummEngine::scrollEffect(int dir) {
 	VirtScreen *vs = &virtscr[0];
 
 	int x, y;
@@ -2518,7 +2518,7 @@
 	}
 }
 
-void Scumm::unkScreenEffect6() {
+void ScummEngine::unkScreenEffect6() {
 	// CD Loom (but not EGA Loom!) uses a more fine-grained dissolve
 	if (_gameId == GID_LOOM256)
 		dissolveEffect(1, 1);
@@ -2526,7 +2526,7 @@
 		dissolveEffect(8, 4);
 }
 
-void Scumm::unkScreenEffect5(int a) {
+void ScummEngine::unkScreenEffect5(int a) {
 	// unkScreenEffect5(0), which is used by FOA during the opening
 	// cutscene when Indy opens the small statue, has been replaced by
 	// dissolveEffect(1, 1).
@@ -2537,7 +2537,7 @@
 	warning("stub unkScreenEffect(%d)", a);
 }
 
-void Scumm::setShake(int mode) {
+void ScummEngine::setShake(int mode) {
 	if (_shakeEnabled != (mode != 0))
 		_fullRedraw = true;
 
@@ -2550,7 +2550,7 @@
 #pragma mark --- Palette ---
 #pragma mark -
 
-void Scumm::setupAmigaPalette() {
+void ScummEngine::setupAmigaPalette() {
 	setPalColor( 0,   0,   0,   0);
 	setPalColor( 1,   0,   0, 187);
 	setPalColor( 2,   0, 187,   0);
@@ -2569,7 +2569,7 @@
 	setPalColor(15, 255, 255, 255);
 }
 
-void Scumm::setupEGAPalette() {
+void ScummEngine::setupEGAPalette() {
 	setPalColor( 0,   0,   0,   0);
 	setPalColor( 1,   0,   0, 168);
 	setPalColor( 2,   0, 168,   0);
@@ -2588,7 +2588,7 @@
 	setPalColor(15, 252, 252, 252);
 }
 
-void Scumm::setupV1ManiacPalette() {
+void ScummEngine::setupV1ManiacPalette() {
 	setPalColor( 0,   0,   0,   0); 
 	setPalColor( 1, 252, 252, 252); 
 	setPalColor( 2, 168,   0,   0);
@@ -2607,7 +2607,7 @@
 	setPalColor(15,  84,  84,  84);
 }
 
-void Scumm::setupV1ZakPalette() {
+void ScummEngine::setupV1ZakPalette() {
 	setPalColor( 0,   0,   0,   0); 
 	setPalColor( 1, 252, 252, 252); 
 	setPalColor( 2, 168,   0,   0);
@@ -2626,7 +2626,7 @@
 	setPalColor(15, 168, 168, 168);
 }
 
-void Scumm::setPaletteFromPtr(const byte *ptr) {
+void ScummEngine::setPaletteFromPtr(const byte *ptr) {
 	int i;
 	byte *dest, r, g, b;
 	int numcolor;
@@ -2668,20 +2668,20 @@
 	setDirtyColors(0, numcolor - 1);
 }
 
-void Scumm::setPaletteFromRes() {
+void ScummEngine::setPaletteFromRes() {
 	byte *ptr;
 	ptr = getResourceAddress(rtRoom, _roomResource) + _CLUT_offs;
 	setPaletteFromPtr(ptr);
 }
 
-void Scumm::setDirtyColors(int min, int max) {
+void ScummEngine::setDirtyColors(int min, int max) {
 	if (_palDirtyMin > min)
 		_palDirtyMin = min;
 	if (_palDirtyMax < max)
 		_palDirtyMax = max;
 }
 
-void Scumm::initCycl(const byte *ptr) {
+void ScummEngine::initCycl(const byte *ptr) {
 	int j;
 	ColorCycle *cycl;
 
@@ -2724,7 +2724,7 @@
 	}
 }
 
-void Scumm::stopCycle(int i) {
+void ScummEngine::stopCycle(int i) {
 	ColorCycle *cycl;
 
 	checkRange(16, 0, i, "Stop Cycle %d Out Of Range");
@@ -2782,7 +2782,7 @@
 }
 
 
-void Scumm::cyclePalette() {
+void ScummEngine::cyclePalette() {
 	ColorCycle *cycl;
 	int valueToAdd;
 	int i, j;
@@ -2834,7 +2834,7 @@
  * Perform color cycling on the palManipulate data, too, otherwise
  * color cycling will be disturbed by the palette fade.
  */
-void Scumm::moveMemInPalRes(int start, int end, byte direction) {
+void ScummEngine::moveMemInPalRes(int start, int end, byte direction) {
 	if (!_palManipCounter)
 		return;
 
@@ -2842,7 +2842,7 @@
 	::cyclePalette(_palManipIntermediatePal, start, end, 6, !direction);
 }
 
-void Scumm::palManipulateInit(int start, int end, int string_id, int time) {
+void ScummEngine::palManipulateInit(int start, int end, int string_id, int time) {
 	byte *pal, *target, *between;
 	byte *string1, *string2, *string3;
 	int i;
@@ -2888,7 +2888,7 @@
 	_palManipCounter = time;
 }
 
-void Scumm::palManipulate() {
+void ScummEngine::palManipulate() {
 	byte *target, *pal, *between;
 	int i, j;
 
@@ -2914,7 +2914,7 @@
 	_palManipCounter--;
 }
 
-void Scumm::setupShadowPalette(int slot, int redScale, int greenScale, int blueScale, int startColor, int endColor) {
+void ScummEngine::setupShadowPalette(int slot, int redScale, int greenScale, int blueScale, int startColor, int endColor) {
 	byte *table;
 	int i;
 	byte *curpal;
@@ -2940,7 +2940,7 @@
 	}
 }
 
-void Scumm::setupShadowPalette(int redScale, int greenScale, int blueScale, int startColor, int endColor) {
+void ScummEngine::setupShadowPalette(int redScale, int greenScale, int blueScale, int startColor, int endColor) {
 	const byte *basepal = getPalettePtr();
 	const byte *pal = basepal;
 	const byte *compareptr;
@@ -3014,7 +3014,7 @@
 }
 
 /** This function create the specialPalette used for semi-transparency in SamnMax */
-void Scumm::createSpecialPalette(int16 from, int16 to, int16 redScale, int16 greenScale, int16 blueScale,
+void ScummEngine::createSpecialPalette(int16 from, int16 to, int16 redScale, int16 greenScale, int16 blueScale,
 			int16 startColor, int16 endColor) {
 	const byte *palPtr, *curPtr;
 	const byte *searchPtr;
@@ -3065,7 +3065,7 @@
 	}
 }
 
-void Scumm::darkenPalette(int redScale, int greenScale, int blueScale, int startColor, int endColor) {
+void ScummEngine::darkenPalette(int redScale, int greenScale, int blueScale, int startColor, int endColor) {
 	if (_roomResource == 0) // FIXME - HACK to get COMI demo working
 		return;
 
@@ -3121,7 +3121,7 @@
  * components of the palette colors. It's used in CMI when Guybrush
  * walks from the beach towards the swamp.
  */
-void Scumm::desaturatePalette(int hueScale, int satScale, int lightScale, int startColor, int endColor) {
+void ScummEngine::desaturatePalette(int hueScale, int satScale, int lightScale, int startColor, int endColor) {
 
 	if (startColor <= endColor) {
 		const byte *cptr;
@@ -3195,7 +3195,7 @@
 }
 
 
-int Scumm::remapPaletteColor(int r, int g, int b, uint threshold) {
+int ScummEngine::remapPaletteColor(int r, int g, int b, uint threshold) {
 	int i;
 	int ar, ag, ab;
 	uint sum, bestsum, bestitem = 0;
@@ -3244,7 +3244,7 @@
 	return bestitem;
 }
 
-void Scumm::swapPalColors(int a, int b) {
+void ScummEngine::swapPalColors(int a, int b) {
 	byte *ap, *bp;
 	byte t;
 
@@ -3268,7 +3268,7 @@
 	setDirtyColors(b, b);
 }
 
-void Scumm::copyPalColor(int dst, int src) {
+void ScummEngine::copyPalColor(int dst, int src) {
 	byte *dp, *sp;
 
 	if ((uint) dst >= 256 || (uint) src >= 256)
@@ -3284,14 +3284,14 @@
 	setDirtyColors(dst, dst);
 }
 
-void Scumm::setPalColor(int idx, int r, int g, int b) {
+void ScummEngine::setPalColor(int idx, int r, int g, int b) {
 	_currentPalette[idx * 3 + 0] = r;
 	_currentPalette[idx * 3 + 1] = g;
 	_currentPalette[idx * 3 + 2] = b;
 	setDirtyColors(idx, idx);
 }
 
-void Scumm::setPalette(int palindex) {
+void ScummEngine::setPalette(int palindex) {
 	const byte *pals;
 
 	_curPalIndex = palindex;
@@ -3299,7 +3299,7 @@
 	setPaletteFromPtr(pals);
 }
 
-const byte *Scumm::findPalInPals(const byte *pal, int idx) {
+const byte *ScummEngine::findPalInPals(const byte *pal, int idx) {
 	const byte *offs;
 	uint32 size;
 
@@ -3319,7 +3319,7 @@
 	return offs + READ_LE_UINT32(offs + idx * sizeof(uint32));
 }
 
-const byte *Scumm::getPalettePtr() {
+const byte *ScummEngine::getPalettePtr() {
 	const byte *cptr;
 
 	cptr = getResourceAddress(rtRoom, _roomResource);
@@ -3333,7 +3333,7 @@
 	return cptr;
 }
 
-void Scumm::updatePalette() {
+void ScummEngine::updatePalette() {
 	if (_palDirtyMax == -1)
 		return;
 
@@ -3388,7 +3388,7 @@
 #pragma mark --- Cursor ---
 #pragma mark -
 
-void Scumm::setupCursor() {
+void ScummEngine::setupCursor() {
 	_cursor.animate = 1;
 	if (_gameId == GID_TENTACLE && res.roomno[rtRoom][60]) {
 		// HACK: For DOTT we manually set the default cursor. See also bug #786994
@@ -3397,7 +3397,7 @@
 	}
 }
 
-void Scumm::grabCursor(int x, int y, int w, int h) {
+void ScummEngine::grabCursor(int x, int y, int w, int h) {
 	VirtScreen *vs = findVirtScreen(y);
 
 	if (vs == NULL) {
@@ -3409,7 +3409,7 @@
 
 }
 
-void Scumm::grabCursor(byte *ptr, int width, int height) {
+void ScummEngine::grabCursor(byte *ptr, int width, int height) {
 	uint size;
 	byte *dst;
 
@@ -3431,7 +3431,7 @@
 	updateCursor();
 }
 
-void Scumm::useIm01Cursor(const byte *im, int w, int h) {
+void ScummEngine::useIm01Cursor(const byte *im, int w, int h) {
 	VirtScreen *vs = &virtscr[0];
 	byte *buf, *dst;
 	const byte *src;
@@ -3471,14 +3471,14 @@
 	free(buf);
 }
 
-void Scumm::setCursor(int cursor) {
+void ScummEngine::setCursor(int cursor) {
 	if (cursor >= 0 && cursor <= 3)
 		_currentCursor = cursor;
 	else
 		warning("setCursor(%d)", cursor);
 }
 
-void Scumm::setCursorHotspot(int x, int y) {
+void ScummEngine::setCursorHotspot(int x, int y) {
 	_cursor.hotspotX = x;
 	_cursor.hotspotY = y;
 	// FIXME this hacks around offset cursor in the humongous games
@@ -3488,12 +3488,12 @@
 	}
 }
 
-void Scumm::updateCursor() {
+void ScummEngine::updateCursor() {
 	_system->set_mouse_cursor(_grabbedCursor, _cursor.width, _cursor.height,
 	                          _cursor.hotspotX, _cursor.hotspotY);
 }
 
-void Scumm::animateCursor() {
+void ScummEngine::animateCursor() {
 	if (_cursor.animate) {
 		if (!(_cursor.animateIndex & 0x1)) {
 			decompressDefaultCursor((_cursor.animateIndex >> 1) & 3);
@@ -3502,7 +3502,7 @@
 	}
 }
 
-void Scumm::useBompCursor(const byte *im, int width, int height) {
+void ScummEngine::useBompCursor(const byte *im, int width, int height) {
 	uint size;
 
 	width <<= 3;
@@ -3527,7 +3527,7 @@
 	updateCursor();
 }
 
-void Scumm::decompressDefaultCursor(int idx) {
+void ScummEngine::decompressDefaultCursor(int idx) {
 	int i, j;
 	byte color;
 
@@ -3620,7 +3620,7 @@
 	updateCursor();
 }
 
-void Scumm::makeCursorColorTransparent(int a) {
+void ScummEngine::makeCursorColorTransparent(int a) {
 	int i, size;
 
 	size = _cursor.width * _cursor.height;

Index: gfx.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/gfx.h,v
retrieving revision 1.46
retrieving revision 1.47
diff -u -d -r1.46 -r1.47
--- gfx.h	2 Oct 2003 17:43:02 -0000	1.46
+++ gfx.h	2 Oct 2003 22:42:02 -0000	1.47
@@ -25,7 +25,7 @@
 
 #include "common/rect.h"
 
-class Scumm;
+class ScummEngine;
 
 enum {					/** Camera modes */
 	CM_NORMAL = 1,
@@ -81,7 +81,7 @@
 	uint16 mode;
 };
 
-/** Bomp graphics data, used as parameter to Scumm::drawBomp. */
+/** Bomp graphics data, used as parameter to ScummEngine::drawBomp. */
 struct BompDrawData {
 	byte *out;
 	int outwidth, outheight;
@@ -107,9 +107,9 @@
 };
 
 class Gdi {
-	friend class Scumm;	// Mostly for the code in saveload.cpp ...
+	friend class ScummEngine;	// Mostly for the code in saveload.cpp ...
 public:
-	Scumm *_vm;
+	ScummEngine *_vm;
 
 	int _numZBuffer;
 	int _imgBufOffs[8];

Index: imuse.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/imuse.cpp,v
retrieving revision 2.101
retrieving revision 2.102
diff -u -d -r2.101 -r2.102
--- imuse.cpp	1 Oct 2003 15:19:12 -0000	2.101
+++ imuse.cpp	2 Oct 2003 22:42:02 -0000	2.102
@@ -1298,7 +1298,7 @@
 	}
 }
 
-int IMuseInternal::save_or_load(Serializer *ser, Scumm *scumm) {
+int IMuseInternal::save_or_load(Serializer *ser, ScummEngine *scumm) {
 	const SaveLoadEntry mainEntries[] = {
 		MKLINE(IMuseInternal, _queue_end, sleUint8, VER(8)),
 		MKLINE(IMuseInternal, _queue_pos, sleUint8, VER(8)),
@@ -1415,7 +1415,7 @@
 
 // Only call this routine from the main thread,
 // since it uses getResourceAddress
-void IMuseInternal::fix_players_after_load(Scumm *scumm) {
+void IMuseInternal::fix_players_after_load(ScummEngine *scumm) {
 	Player *player = _players;
 	int i;
 
@@ -1757,7 +1757,7 @@
 
 void IMuse::on_timer(MidiDriver *midi) { in(); _target->on_timer(midi); out(); }
 void IMuse::pause(bool paused) { in(); _target->pause(paused); out(); }
-int IMuse::save_or_load(Serializer *ser, Scumm *scumm) { in(); int ret = _target->save_or_load(ser, scumm); out(); return ret; }
+int IMuse::save_or_load(Serializer *ser, ScummEngine *scumm) { in(); int ret = _target->save_or_load(ser, scumm); out(); return ret; }
 int IMuse::set_music_volume(uint vol) { in(); int ret = _target->set_music_volume(vol); out(); return ret; }
 int IMuse::get_music_volume() { in(); int ret = _target->get_music_volume(); out(); return ret; }
 void IMuse::setMasterVolume(int vol) { in(); _target->setMasterVolume(vol); out(); }

Index: imuse.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/imuse.h,v
retrieving revision 1.46
retrieving revision 1.47
diff -u -d -r1.46 -r1.47
--- imuse.h	28 Sep 2003 00:03:23 -0000	1.46
+++ imuse.h	2 Oct 2003 22:42:02 -0000	1.47
@@ -30,7 +30,7 @@
 class IMuseInternal;
 class MidiDriver;
 class OSystem;
-class Scumm;
+class ScummEngine;
 class Serializer;
 class SoundMixer;
 
@@ -58,7 +58,7 @@
 
 	void on_timer(MidiDriver *midi);
 	void pause(bool paused);
-	int save_or_load(Serializer *ser, Scumm *scumm);
+	int save_or_load(Serializer *ser, ScummEngine *scumm);
 	int set_music_volume(uint vol);
 	int get_music_volume();
 	void setMasterVolume(int vol);

Index: imuse_digi.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/imuse_digi.cpp,v
retrieving revision 1.48
retrieving revision 1.49
diff -u -d -r1.48 -r1.49
--- imuse_digi.cpp	24 Sep 2003 06:33:58 -0000	1.48
+++ imuse_digi.cpp	2 Oct 2003 22:42:02 -0000	1.49
@@ -694,7 +694,7 @@
 	imuseDigital->musicTimer();
 }
 
-IMuseDigital::IMuseDigital(Scumm *scumm)
+IMuseDigital::IMuseDigital(ScummEngine *scumm)
 	: _scumm(scumm) {
 	memset(_channel, 0, sizeof(Channel) * MAX_DIGITAL_CHANNELS);
 	for (int l = 0; l < MAX_DIGITAL_CHANNELS; l++) {

Index: imuse_digi.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/imuse_digi.h,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -d -r1.14 -r1.15
--- imuse_digi.h	8 Sep 2003 17:06:44 -0000	1.14
+++ imuse_digi.h	2 Oct 2003 22:42:02 -0000	1.15
@@ -31,7 +31,7 @@
 #define MAX_IMUSE_JUMPS 1
 #define MAX_IMUSE_REGIONS 3
 
-class Scumm;
+class ScummEngine;
 
 class IMuseDigital : public MusicEngine {
 private:
@@ -60,14 +60,14 @@
 	
 	Channel _channel[MAX_DIGITAL_CHANNELS];
 
-	Scumm *_scumm;
+	ScummEngine *_scumm;
 	bool _pause;
 
 	static void timer_handler(void *engine);
 	void musicTimer();
 
 public:
-	IMuseDigital(Scumm *scumm);
+	IMuseDigital(ScummEngine *scumm);
 	~IMuseDigital();
 
 	void setMasterVolume(int vol) {}

Index: imuse_internal.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/imuse_internal.h,v
retrieving revision 2.26
retrieving revision 2.27
diff -u -d -r2.26 -r2.27
--- imuse_internal.h	1 Oct 2003 15:19:12 -0000	2.26
+++ imuse_internal.h	2 Oct 2003 22:42:02 -0000	2.27
@@ -43,7 +43,7 @@
 
 // Some entities also referenced
 class MidiParser;
-class Scumm;
+class ScummEngine;
 class OSystem;
 class SoundMixer;
 
@@ -429,7 +429,7 @@
 	int set_volchan(int sound, int volchan);
 
 	void fix_parts_after_load();
-	void fix_players_after_load(Scumm *scumm);
+	void fix_players_after_load(ScummEngine *scumm);
 
 	static int saveReference(void *me_ref, byte type, void *ref);
 	static void *loadReference(void *me_ref, byte type, int ref);
@@ -451,7 +451,7 @@
 	void pause(bool paused);
 	int terminate1();
 	int terminate2();
-	int save_or_load(Serializer *ser, Scumm *scumm);
+	int save_or_load(Serializer *ser, ScummEngine *scumm);
 	int set_music_volume(uint vol);
 	int get_music_volume();
 	int setMasterVolume(uint vol);

Index: intern.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/intern.h,v
retrieving revision 2.113
retrieving revision 2.114
diff -u -d -r2.113 -r2.114
--- intern.h	13 Sep 2003 21:04:47 -0000	2.113
+++ intern.h	2 Oct 2003 22:42:02 -0000	2.114
@@ -26,9 +26,9 @@
 #include "scumm.h"
 class NutRenderer; // V8 Font Renderer
 
-class Scumm_v5 : public Scumm {
+class ScummEngine_v5 : public ScummEngine {
 protected:
-	typedef void (Scumm_v5::*OpcodeProcV5)();
+	typedef void (ScummEngine_v5::*OpcodeProcV5)();
 	struct OpcodeEntryV5 {
 		OpcodeProcV5 proc;
 		const char *desc;
@@ -37,7 +37,7 @@
 	const OpcodeEntryV5 *_opcodesV5;
 
 public:
-	Scumm_v5(GameDetector *detector, OSystem *syst) : Scumm(detector, syst) {}
+	ScummEngine_v5(GameDetector *detector, OSystem *syst) : ScummEngine(detector, syst) {}
 
 protected:
 	virtual void setupOpcodes();
@@ -165,9 +165,9 @@
 // FIXME - maybe we should move the opcodes from v5 to v3, and change the inheritance 
 // accordingly - that would be more logical I guess. However, if you do so, take care
 // of preserving the right readIndexFile / loadCharset !!!
-class Scumm_v3 : public Scumm_v5 {
+class ScummEngine_v3 : public ScummEngine_v5 {
 public:
-	Scumm_v3(GameDetector *detector, OSystem *syst) : Scumm_v5(detector, syst) {}
+	ScummEngine_v3(GameDetector *detector, OSystem *syst) : ScummEngine_v5(detector, syst) {}
 
 protected:
 	void readIndexFile();
@@ -177,7 +177,7 @@
 	void readGlobalObjects();
 };
 
-class Scumm_v2 : public Scumm_v3 {
+class ScummEngine_v2 : public ScummEngine_v3 {
 protected:
 	void readIndexFile();
 	void readClassicIndexFile();	// V1
@@ -185,7 +185,7 @@
 	void loadCharset(int no);
 	void readMAXS();
 
-	typedef void (Scumm_v2::*OpcodeProcV2)();
+	typedef void (ScummEngine_v2::*OpcodeProcV2)();
 	struct OpcodeEntryV2 {
 		OpcodeProcV2 proc;
 		const char *desc;
@@ -194,7 +194,7 @@
 	const OpcodeEntryV2 *_opcodesV2;
 
 public:
-	Scumm_v2(GameDetector *detector, OSystem *syst) : Scumm_v3(detector, syst) {}
+	ScummEngine_v2(GameDetector *detector, OSystem *syst) : ScummEngine_v3(detector, syst) {}
 
 protected:
 	virtual void setupOpcodes();
@@ -300,17 +300,17 @@
 	byte VAR_BACKUP_VERB;
 };
 
-class Scumm_v4 : public Scumm_v3 {
+class ScummEngine_v4 : public ScummEngine_v3 {
 public:
-	Scumm_v4(GameDetector *detector, OSystem *syst) : Scumm_v3(detector, syst) {}
+	ScummEngine_v4(GameDetector *detector, OSystem *syst) : ScummEngine_v3(detector, syst) {}
 
 protected:
 	void loadCharset(int no);
 };
 
-class Scumm_v6 : public Scumm {
+class ScummEngine_v6 : public ScummEngine {
 protected:
-	typedef void (Scumm_v6::*OpcodeProcV6)();
+	typedef void (ScummEngine_v6::*OpcodeProcV6)();
 	struct OpcodeEntryV6 {
 		OpcodeProcV6 proc;
 		const char *desc;
@@ -321,7 +321,7 @@
 	File _hFileTable[17];
 	
 public:
-	Scumm_v6(GameDetector *detector, OSystem *syst) : Scumm(detector, syst)
+	ScummEngine_v6(GameDetector *detector, OSystem *syst) : ScummEngine(detector, syst)
 	{
 		VAR_VIDEONAME = 0xFF;
 
@@ -530,9 +530,9 @@
 	byte VAR_TIMEDATE_SECOND;
 };
 
-class Scumm_v7 : public Scumm_v6 {
+class ScummEngine_v7 : public ScummEngine_v6 {
 public:
-	Scumm_v7(GameDetector *detector, OSystem *syst) : Scumm_v6(detector, syst) {}
+	ScummEngine_v7(GameDetector *detector, OSystem *syst) : ScummEngine_v6(detector, syst) {}
 
 protected:
 	virtual void setupScummVars();
@@ -543,9 +543,9 @@
 	virtual void panCameraTo(int x, int y);
 };
 
-class Scumm_v8 : public Scumm_v7 {
+class ScummEngine_v8 : public ScummEngine_v7 {
 protected:
-	typedef void (Scumm_v8::*OpcodeProcV8)();
+	typedef void (ScummEngine_v8::*OpcodeProcV8)();
 	struct OpcodeEntryV8 {
 		OpcodeProcV8 proc;
 		const char *desc;
@@ -554,7 +554,7 @@
 	const OpcodeEntryV8 *_opcodesV8;
 	
 public:
-	Scumm_v8(GameDetector *detector, OSystem *syst) : Scumm_v7(detector, syst) {}
+	ScummEngine_v8(GameDetector *detector, OSystem *syst) : ScummEngine_v7(detector, syst) {}
 
 protected:
 	virtual void setupOpcodes();

Index: nut_renderer.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/nut_renderer.cpp,v
retrieving revision 1.32
retrieving revision 1.33
diff -u -d -r1.32 -r1.33
--- nut_renderer.cpp	9 Sep 2003 20:54:18 -0000	1.32
+++ nut_renderer.cpp	2 Oct 2003 22:42:02 -0000	1.33
@@ -24,7 +24,7 @@
 #include "bomp.h"
 
 
-NutRenderer::NutRenderer(Scumm *vm) :
+NutRenderer::NutRenderer(ScummEngine *vm) :
 	_vm(vm),
 	_initialized(false),
 	_loaded(false),

Index: nut_renderer.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/nut_renderer.h,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -d -r1.13 -r1.14
--- nut_renderer.h	6 Sep 2003 16:42:28 -0000	1.13
+++ nut_renderer.h	2 Oct 2003 22:42:02 -0000	1.14
@@ -23,11 +23,11 @@
 
 #include "common/file.h"
 
-class Scumm;
+class ScummEngine;
 
 class NutRenderer {
 protected:
-	Scumm *_vm;
+	ScummEngine *_vm;
 	bool _initialized;
 	bool _loaded;
 	int _nbChars;
@@ -45,7 +45,7 @@
 	void draw2byte(byte *dst, byte *mask, int c, int x, int y, byte color);
 
 public:
-	NutRenderer(Scumm *vm);
+	NutRenderer(ScummEngine *vm);
 	virtual ~NutRenderer();
 	int getNbChars() { return _nbChars; }
 

Index: object.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/object.cpp,v
retrieving revision 1.142
retrieving revision 1.143
diff -u -d -r1.142 -r1.143
--- object.cpp	24 Sep 2003 06:33:58 -0000	1.142
+++ object.cpp	2 Oct 2003 22:42:02 -0000	1.143
@@ -50,7 +50,7 @@
 #endif
 
 
-bool Scumm::getClass(int obj, int cls) const {
+bool ScummEngine::getClass(int obj, int cls) const {
 	checkRange(_numGlobalObjects - 1, 0, obj, "Object %d out of range in getClass");
 	cls &= 0x7F;
 	checkRange(32, 1, cls, "Class %d out of range in getClass");
@@ -77,7 +77,7 @@
 	return (_classData[obj] & (1 << (cls - 1))) != 0;
 }
 
-void Scumm::putClass(int obj, int cls, bool set) {
+void ScummEngine::putClass(int obj, int cls, bool set) {
 	checkRange(_numGlobalObjects - 1, 0, obj, "Object %d out of range in putClass");
 	cls &= 0x7F;
 	checkRange(32, 1, cls, "Class %d out of range in putClass");
@@ -111,12 +111,12 @@
 	}
 }
 
-int Scumm::getOwner(int obj) const {
+int ScummEngine::getOwner(int obj) const {
 	checkRange(_numGlobalObjects - 1, 0, obj, "Object %d out of range in getOwner");
 	return _objectOwnerTable[obj];
 }
 
-void Scumm::putOwner(int obj, int owner) {
+void ScummEngine::putOwner(int obj, int owner) {
 	checkRange(_numGlobalObjects - 1, 0, obj, "Object %d out of range in putOwner");
 	checkRange(0xFF, 0, owner, "Owner %d out of range in putOwner");
 	_objectOwnerTable[obj] = owner;
@@ -126,7 +126,7 @@
 #define BYPASS_COPY_PROT
 #endif
 
-int Scumm::getState(int obj) {
+int ScummEngine::getState(int obj) {
 	checkRange(_numGlobalObjects - 1, 0, obj, "Object %d out of range in getState");
 
 #if defined(BYPASS_COPY_PROT)
@@ -146,18 +146,18 @@
 	return _objectStateTable[obj];
 }
 
-void Scumm::putState(int obj, int state) {
+void ScummEngine::putState(int obj, int state) {
 	checkRange(_numGlobalObjects - 1, 0, obj, "Object %d out of range in putState");
 	checkRange(0xFF, 0, state, "State %d out of range in putState");
 	_objectStateTable[obj] = state;
 }
 
-int Scumm::getObjectRoom(int obj) const {
+int ScummEngine::getObjectRoom(int obj) const {
 	checkRange(_numGlobalObjects - 1, 0, obj, "Object %d out of range in getObjectRoom");
 	return _objectRoomTable[obj];
 }
 
-int Scumm::getObjectIndex(int object) const {
+int ScummEngine::getObjectIndex(int object) const {
 	int i;
 
 	if (object < 1)
@@ -170,7 +170,7 @@
 	return -1;
 }
 
-int Scumm::whereIsObject(int object) const {
+int ScummEngine::whereIsObject(int object) const {
 	int i;
 
 	if (object >= _numGlobalObjects)
@@ -196,7 +196,7 @@
 	return WIO_NOT_FOUND;
 }
 
-int Scumm::getObjectOrActorXY(int object, int &x, int &y) {
+int ScummEngine::getObjectOrActorXY(int object, int &x, int &y) {
 	if (object < _numActors) {
 		Actor *act = derefActorSafe(object, "getObjectOrActorXY");
 		if (act)
@@ -222,7 +222,7 @@
  * Return the position of an object.
  * Returns X, Y and direction in angles
  */
-void Scumm::getObjectXYPos(int object, int &x, int &y, int &dir) {
+void ScummEngine::getObjectXYPos(int object, int &x, int &y, int &dir) {
 	int idx = getObjectIndex(object);
 	assert(idx >= 0);
 	ObjectData &od = _objs[idx];
@@ -271,7 +271,7 @@
 	return MAX(a, b);
 }
 
-int Scumm::getObjActToObjActDist(int a, int b) {
+int ScummEngine::getObjActToObjActDist(int a, int b) {
 	int x, y, x2, y2, dist;
 	Actor *acta = NULL;
 	Actor *actb = NULL;
@@ -312,7 +312,7 @@
 	return dist;
 }
 
-int Scumm::findObject(int x, int y) {
+int ScummEngine::findObject(int x, int y) {
 	int i, b;
 	byte a;
 	const int mask = (_version <= 2) ? 0x8 : 0xF;
@@ -337,7 +337,7 @@
 	return 0;
 }
 
-void Scumm::drawRoomObject(int i, int arg) {
+void ScummEngine::drawRoomObject(int i, int arg) {
 	ObjectData *od;
 	byte a;
 	const int mask = (_version <= 2) ? 0x8 : 0xF;
@@ -356,7 +356,7 @@
 	} while ((od->state & mask) == a);
 }
 
-void Scumm::drawRoomObjects(int arg) {
+void ScummEngine::drawRoomObjects(int arg) {
 	int i;
 	const int mask = (_version <= 2) ? 0x8 : 0xF;
 
@@ -391,7 +391,7 @@
 	MKID('IM0F')
 };
 
-void Scumm::drawObject(int obj, int arg) {
+void ScummEngine::drawObject(int obj, int arg) {
 	ObjectData &od = _objs[obj];
 	int xpos, ypos, height, width;
 	const byte *ptr;
@@ -455,7 +455,7 @@
 	}
 }
 
-void Scumm::clearRoomObjects() {
+void ScummEngine::clearRoomObjects() {
 	int i;
 
 	if (_features & GF_SMALL_HEADER) {
@@ -483,7 +483,7 @@
 	}
 }
 
-void Scumm::loadRoomObjects() {
+void ScummEngine::loadRoomObjects() {
 	int i, j;
 	ObjectData *od;
 	const byte *ptr;
@@ -575,7 +575,7 @@
 	CHECK_HEAP
 }
 
-void Scumm::loadRoomObjectsOldBundle() {
+void ScummEngine::loadRoomObjectsOldBundle() {
 	int i;
 	ObjectData *od;
 	const byte *room, *ptr;
@@ -615,7 +615,7 @@
 	CHECK_HEAP
 }
 
-void Scumm::loadRoomObjectsSmall() {
+void ScummEngine::loadRoomObjectsSmall() {
 	int i, j;
 	ObjectData *od;
 	const byte *ptr;
@@ -675,7 +675,7 @@
 	CHECK_HEAP
 }
 
-void Scumm::setupRoomObject(ObjectData *od, const byte *room, const byte *searchptr) {
+void ScummEngine::setupRoomObject(ObjectData *od, const byte *room, const byte *searchptr) {
 	const CodeHeader *cdhd = NULL;
 	const ImageHeader *imhd = NULL;
 
@@ -789,7 +789,7 @@
 	od->fl_object_index = 0;
 }
 
-void Scumm::fixObjectFlags() {
+void ScummEngine::fixObjectFlags() {
 	int i;
 	ObjectData *od = &_objs[1];
 	for (i = 1; i < _numLocalObjects; i++, od++) {
@@ -798,7 +798,7 @@
 	}
 }
 
-void Scumm::processDrawQue() {
+void ScummEngine::processDrawQue() {
 	int i, j;
 	for (i = 0; i < _drawObjectQueNr; i++) {
 		j = _drawObjectQue[i];
@@ -808,7 +808,7 @@
 	_drawObjectQueNr = 0;
 }
 
-void Scumm::clearOwnerOf(int obj) {
+void ScummEngine::clearOwnerOf(int obj) {
 	int i, j;
 	uint16 *a;
 
@@ -849,7 +849,7 @@
 	}
 }
 
-void Scumm::removeObjectFromRoom(int obj) {
+void ScummEngine::removeObjectFromRoom(int obj) {
 	int i, j, strip;
 
 	for (i = 1; i < _numLocalObjects; i++) {
@@ -873,17 +873,17 @@
 	}
 }
 
-void Scumm::addObjectToDrawQue(int object) {
+void ScummEngine::addObjectToDrawQue(int object) {
 	_drawObjectQue[_drawObjectQueNr++] = object;
 	if ((unsigned int)_drawObjectQueNr > ARRAYSIZE(_drawObjectQue))
 		error("Draw Object Que overflow");
 }
 
-void Scumm::clearDrawObjectQueue() {
+void ScummEngine::clearDrawObjectQueue() {
 	_drawObjectQueNr = 0;
 }
 
-const byte *Scumm::getObjOrActorName(int obj) {
+const byte *ScummEngine::getObjOrActorName(int obj) {
 	byte *objptr;
 	int i;
 
@@ -920,7 +920,7 @@
 	return findResourceData(MKID('OBNA'), objptr);
 }
 
-uint32 Scumm::getOBCDOffs(int object) const {
+uint32 ScummEngine::getOBCDOffs(int object) const {
 	int i;
 
 	if (_objectOwnerTable[object] != OF_OWNER_ROOM)
@@ -935,7 +935,7 @@
 	return 0;
 }
 
-byte *Scumm::getOBCDFromObject(int obj) {
+byte *ScummEngine::getOBCDFromObject(int obj) {
 	int i;
 	byte *ptr;
 
@@ -962,7 +962,7 @@
 	return 0;
 }
 
-const byte *Scumm::getOBIMFromObject(const ObjectData &od) {
+const byte *ScummEngine::getOBIMFromObject(const ObjectData &od) {
 	const byte *ptr;
 
 	if (od.fl_object_index) {
@@ -976,7 +976,7 @@
 	return ptr;
 }
 
-const byte *Scumm::getObjectImage(const byte *ptr, int state) {
+const byte *ScummEngine::getObjectImage(const byte *ptr, int state) {
 	assert(ptr);
 	if (_features & GF_OLD_BUNDLE)
 		ptr += 0;
@@ -1007,7 +1007,7 @@
 	return ptr;
 }
 
-void Scumm::addObjectToInventory(uint obj, uint room) {
+void ScummEngine::addObjectToInventory(uint obj, uint room) {
 	int idx, slot;
 	uint32 size;
 	const byte *ptr;
@@ -1042,7 +1042,7 @@
 	CHECK_HEAP
 }
 
-void Scumm::findObjectInRoom(FindObjectInRoom *fo, byte findWhat, uint id, uint room) {
+void ScummEngine::findObjectInRoom(FindObjectInRoom *fo, byte findWhat, uint id, uint room) {
 
 	const CodeHeader *cdhd;
 	int i, numobj;
@@ -1177,7 +1177,7 @@
 	}
 }
 
-int Scumm::getInventorySlot() {
+int ScummEngine::getInventorySlot() {
 	int i;
 	for (i = 1; i <= _maxInventoryItems; i++) {
 		if (_inventory[i] == 0)
@@ -1187,7 +1187,7 @@
 	return -1;
 }
 
-void Scumm::SamInventoryHack(int obj) {
+void ScummEngine::SamInventoryHack(int obj) {
 	// FIXME: Sam and Max hack
 	int base = 6;
 
@@ -1204,7 +1204,7 @@
 	}
 }
 
-void Scumm::setOwnerOf(int obj, int owner) {
+void ScummEngine::setOwnerOf(int obj, int owner) {
 	ScriptSlot *ss;
 	if (owner == 0) {
 		clearOwnerOf(obj);
@@ -1223,7 +1223,7 @@
 	runInventoryScript(0);
 }
 
-int Scumm::getObjX(int obj) {
+int ScummEngine::getObjX(int obj) {
 	if (obj < _numActors) {
 		if (obj < 1)
 			return 0;									/* fix for indy4's map */
@@ -1237,7 +1237,7 @@
 	}
 }
 
-int Scumm::getObjY(int obj) {
+int ScummEngine::getObjY(int obj) {
 	if (obj < _numActors) {
 		if (obj < 1)
 			return 0;									/* fix for indy4's map */
@@ -1251,11 +1251,11 @@
 	}
 }
 
-int Scumm::getObjOldDir(int obj) {
+int ScummEngine::getObjOldDir(int obj) {
 	return newDirToOldDir(getObjNewDir(obj));
 }
 
-int Scumm::getObjNewDir(int obj) {
+int ScummEngine::getObjNewDir(int obj) {
 	int dir;
 	if (obj < _numActors) {
 		dir = derefActor(obj, "getObjNewDir")->getFacing();
@@ -1266,7 +1266,7 @@
 	return dir;
 }
 
-int Scumm::findInventory(int owner, int idx) {
+int ScummEngine::findInventory(int owner, int idx) {
 	int count = 1, i, obj;
 	for (i = 0; i != _maxInventoryItems; i++) {
 		obj = _inventory[i];
@@ -1276,7 +1276,7 @@
 	return 0;
 }
 
-int Scumm::getInventoryCount(int owner) {
+int ScummEngine::getInventoryCount(int owner) {
 	int i, obj;
 	int count = 0;
 	for (i = 0; i != _maxInventoryItems; i++) {
@@ -1287,7 +1287,7 @@
 	return count;
 }
 
-void Scumm::setObjectState(int obj, int state, int x, int y) {
+void ScummEngine::setObjectState(int obj, int state, int x, int y) {
 	int i;
 
 	i = getObjectIndex(obj);
@@ -1305,7 +1305,7 @@
 	putState(obj, state);
 }
 
-int Scumm::getDistanceBetween(bool is_obj_1, int b, int c, bool is_obj_2, int e, int f) {
+int ScummEngine::getDistanceBetween(bool is_obj_1, int b, int c, bool is_obj_2, int e, int f) {
 	int i, j;
 	int x, y;
 	int x2, y2;
@@ -1335,7 +1335,7 @@
 	return getDist(x, y, x2, y2) * 0xFF / ((i + j) >> 1);
 }
 
-void Scumm::setCursorImg(uint img, uint room, uint imgindex) {
+void ScummEngine::setCursorImg(uint img, uint room, uint imgindex) {
 	int w, h;
 	const byte *dataptr, *bomp;
 	uint32 size;
@@ -1382,7 +1382,7 @@
 
 }
 
-void Scumm::nukeFlObjects(int min, int max) {
+void ScummEngine::nukeFlObjects(int min, int max) {
 	ObjectData *od;
 	int i;
 
@@ -1396,7 +1396,7 @@
 		}
 }
 
-void Scumm::enqueueObject(int objectNumber, int objectX, int objectY, int objectWidth,
+void ScummEngine::enqueueObject(int objectNumber, int objectX, int objectY, int objectWidth,
                           int objectHeight, int scaleX, int scaleY, int image, int mode) {
 	BlastObject *eo;
 	ObjectData *od;
@@ -1433,7 +1433,7 @@
 	eo->mode = mode;
 }
 
-void Scumm::drawBlastObjects() {
+void ScummEngine::drawBlastObjects() {
 	BlastObject *eo;
 	int i;
 
@@ -1443,7 +1443,7 @@
 	}
 }
 
-void Scumm::drawBlastObject(BlastObject *eo) {
+void ScummEngine::drawBlastObject(BlastObject *eo) {
 	VirtScreen *vs;
 	const byte *bomp, *ptr;
 	int objnum;
@@ -1517,7 +1517,7 @@
 	updateDirtyRect(vs->number, bdd.x, bdd.x + bdd.srcwidth, bdd.y, bdd.y + bdd.srcheight, 0);
 }
 
-void Scumm::removeBlastObjects() {
+void ScummEngine::removeBlastObjects() {
 	BlastObject *eo;
 	int i;
 
@@ -1529,7 +1529,7 @@
 	clearEnqueue();
 }
 
-void Scumm::removeBlastObject(BlastObject *eo) {
+void ScummEngine::removeBlastObject(BlastObject *eo) {
 	VirtScreen *vs = &virtscr[0];
 
 	int top, bottom, left, right;
@@ -1571,7 +1571,7 @@
 	updateDirtyRect(0, left, right, top, bottom, USAGE_BIT_RESTORED);
 }
 
-int Scumm::findLocalObjectSlot() {
+int ScummEngine::findLocalObjectSlot() {
 	int i;
 
 	for (i = 1; i < _numLocalObjects; i++) {
@@ -1582,7 +1582,7 @@
 	return -1;
 }
 
-int Scumm::findFlObjectSlot() {
+int ScummEngine::findFlObjectSlot() {
 	int i;
 	for (i = 1; i < _maxFLObject; i++) {
 		if (_baseFLObject[i] == NULL)
@@ -1592,7 +1592,7 @@
 	return -1;
 }
 
-void Scumm::loadFlObject(uint object, uint room) {
+void ScummEngine::loadFlObject(uint object, uint room) {
 	FindObjectInRoom foir;
 	int slot, objslot;
 	ObjectData *od;

Index: player_mod.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/player_mod.cpp,v
retrieving revision 2.6
retrieving revision 2.7
diff -u -d -r2.6 -r2.7
--- player_mod.cpp	27 Sep 2003 22:27:12 -0000	2.6
+++ player_mod.cpp	2 Oct 2003 22:42:02 -0000	2.7
@@ -28,7 +28,7 @@
 //
 ////////////////////////////////////////
 
-Player_MOD::Player_MOD(Scumm *scumm) {
+Player_MOD::Player_MOD(ScummEngine *scumm) {
 	int i;
 	_mixer = scumm->_mixer;
 	_samplerate = scumm->_system->property(OSystem::PROP_GET_SAMPLE_RATE, 0);

Index: player_mod.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/player_mod.h,v
retrieving revision 2.5
retrieving revision 2.6
diff -u -d -r2.5 -r2.6
--- player_mod.h	27 Sep 2003 22:27:12 -0000	2.5
+++ player_mod.h	2 Oct 2003 22:42:02 -0000	2.6
@@ -32,7 +32,7 @@
 
 class Player_MOD {
 public:
-	Player_MOD(Scumm *scumm);
+	Player_MOD(ScummEngine *scumm);
 	virtual ~Player_MOD();
 	virtual void setMasterVolume(int vol);
 

Index: player_v1.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/player_v1.cpp,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -d -r1.10 -r1.11
--- player_v1.cpp	30 Sep 2003 17:08:59 -0000	1.10
+++ player_v1.cpp	2 Oct 2003 22:42:02 -0000	1.11
@@ -35,7 +35,7 @@
 ////////////////////////////////////////
 
 
-Player_V1::Player_V1(Scumm *scumm) : Player_V2(scumm) {	
+Player_V1::Player_V1(ScummEngine *scumm) : Player_V2(scumm) {	
 	// Initialize channel code
 	for (int i = 0; i < 4; ++i)
 		clear_channel(i);

Index: player_v1.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/player_v1.h,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- player_v1.h	30 Sep 2003 17:08:59 -0000	1.7
+++ player_v1.h	2 Oct 2003 22:42:02 -0000	1.8
@@ -44,7 +44,7 @@
 
 class Player_V1 : public Player_V2 {
 public:
-	Player_V1(Scumm *scumm);
+	Player_V1(ScummEngine *scumm);
 	~Player_V1();
 
 	void startSound(int nr);

Index: player_v2.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/player_v2.cpp,v
retrieving revision 2.35
retrieving revision 2.36
diff -u -d -r2.35 -r2.36
--- player_v2.cpp	30 Sep 2003 17:08:59 -0000	2.35
+++ player_v2.cpp	2 Oct 2003 22:42:02 -0000	2.36
@@ -345,7 +345,7 @@
 ////////////////////////////////////////
 
 
-Player_V2::Player_V2(Scumm *scumm) {
+Player_V2::Player_V2(ScummEngine *scumm) {
 	int i;
 	
 	// This simulates the pc speaker sound, which is driven

Index: player_v2.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/player_v2.h,v
retrieving revision 2.16
retrieving revision 2.17
diff -u -d -r2.16 -r2.17
--- player_v2.h	30 Sep 2003 17:10:03 -0000	2.16
+++ player_v2.h	2 Oct 2003 22:42:02 -0000	2.17
@@ -67,13 +67,13 @@
 };
 
 
-class Scumm;
+class ScummEngine;
 class SoundMixer;
 
 
 class Player_V2 : public MusicEngine {
 public:
-	Player_V2(Scumm *scumm);
+	Player_V2(ScummEngine *scumm);
 	virtual ~Player_V2();
 
 	virtual void setMasterVolume(int vol);
@@ -88,7 +88,7 @@
 	bool _isV3Game;
 	SoundMixer *_mixer;
 	OSystem *_system;
-	Scumm *_scumm;
+	ScummEngine *_scumm;
 
 	bool _pcjr;
 	int _header_len;

Index: player_v2a.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/player_v2a.cpp,v
retrieving revision 2.8
retrieving revision 2.9
diff -u -d -r2.8 -r2.9
--- player_v2a.cpp	30 Sep 2003 17:03:36 -0000	2.8
+++ player_v2a.cpp	2 Oct 2003 22:42:02 -0000	2.9
@@ -1111,7 +1111,7 @@
 	return NULL;
 }
 
-Player_V2A::Player_V2A(Scumm *scumm) {
+Player_V2A::Player_V2A(ScummEngine *scumm) {
 	int i;
 	_scumm = scumm;
 	_system = scumm->_system;

Index: player_v2a.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/player_v2a.h,v
retrieving revision 2.1
retrieving revision 2.2
diff -u -d -r2.1 -r2.2
--- player_v2a.h	24 Sep 2003 06:56:30 -0000	2.1
+++ player_v2a.h	2 Oct 2003 22:42:02 -0000	2.2
@@ -30,14 +30,14 @@
 
 #define	V2A_MAXSLOTS 8
 
-class Scumm;
+class ScummEngine;
 class SoundMixer;
 
 class V2A_Sound;
 
 class Player_V2A : public MusicEngine {
 public:
-	Player_V2A(Scumm *scumm);
+	Player_V2A(ScummEngine *scumm);
 	virtual ~Player_V2A();
 
 	virtual void setMasterVolume(int vol);
@@ -49,7 +49,7 @@
 
 private:
 	OSystem *_system;
-	Scumm *_scumm;
+	ScummEngine *_scumm;
 	Player_MOD *_mod;
 
 	struct soundSlot

Index: player_v3a.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/player_v3a.cpp,v
retrieving revision 1.12
retrieving revision 1.13
diff -u -d -r1.12 -r1.13
--- player_v3a.cpp	24 Sep 2003 06:56:30 -0000	1.12
+++ player_v3a.cpp	2 Oct 2003 22:42:02 -0000	1.13
@@ -38,7 +38,7 @@
 //
 ////////////////////////////////////////
 
-Player_V3A::Player_V3A(Scumm *scumm) {
+Player_V3A::Player_V3A(ScummEngine *scumm) {
 	int i;
 	_scumm = scumm;
 	_system = scumm->_system;

Index: player_v3a.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/player_v3a.h,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -d -r1.9 -r1.10
--- player_v3a.h	24 Sep 2003 06:56:30 -0000	1.9
+++ player_v3a.h	2 Oct 2003 22:42:02 -0000	1.10
@@ -31,12 +31,12 @@
 #define	V3A_MAXMUS	8
 #define	V3A_MAXSFX	8
 
-class Scumm;
+class ScummEngine;
 class SoundMixer;
 
 class Player_V3A : public MusicEngine {
 public:
-	Player_V3A(Scumm *scumm);
+	Player_V3A(ScummEngine *scumm);
 	virtual ~Player_V3A();
 
 	virtual void setMasterVolume(int vol);
@@ -48,7 +48,7 @@
 
 private:
 	OSystem *_system;
-	Scumm *_scumm;
+	ScummEngine *_scumm;
 	Player_MOD *_mod;
 
 	struct musChan

Index: resource.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/resource.cpp,v
retrieving revision 1.162
retrieving revision 1.163
diff -u -d -r1.162 -r1.163
--- resource.cpp	2 Oct 2003 14:37:40 -0000	1.162
+++ resource.cpp	2 Oct 2003 22:42:02 -0000	1.163
@@ -38,7 +38,7 @@
 static const char *resTypeFromId(int id);
 
 /* Open a room */
-void Scumm::openRoom(int room) {
+void ScummEngine::openRoom(int room) {
 	int room_offs, roomlimit;
 	bool result;
 	char buf[128];
@@ -147,7 +147,7 @@
 	_fileOffset = 0;		// start of file
 }
 
-void Scumm::closeRoom() {
+void ScummEngine::closeRoom() {
 	if (_lastLoadedRoom != -1) {
 		_lastLoadedRoom = -1;
 		deleteRoomOffsets();
@@ -156,7 +156,7 @@
 }
 
 /** Delete the currently loaded room offsets. */
-void Scumm::deleteRoomOffsets() {
+void ScummEngine::deleteRoomOffsets() {
 	if (!(_features & GF_SMALL_HEADER) && !_dynamicRoomOffsets)
 		return;
 
@@ -167,7 +167,7 @@
 }
 
 /** Read room offsets */
-void Scumm::readRoomsOffsets() {
+void ScummEngine::readRoomsOffsets() {
 	int num, room, i;
 	byte *ptr;
 
@@ -207,7 +207,7 @@
 	}
 }
 
-bool Scumm::openResourceFile(const char *filename, byte encByte) {
+bool ScummEngine::openResourceFile(const char *filename, byte encByte) {
 	debug(9, "openResourceFile(%s)", filename);
 
 	if (_fileHandle.isOpen()) {
@@ -219,7 +219,7 @@
 	return _fileHandle.isOpen();
 }
 
-void Scumm::askForDisk(const char *filename, int disknum) {
+void ScummEngine::askForDisk(const char *filename, int disknum) {
 	char buf[128];
 
 	if (_version == 8) {
@@ -245,7 +245,7 @@
 	}
 }
 
-void Scumm::readIndexFile() {
+void ScummEngine::readIndexFile() {
 	uint32 blocktype, itemsize;
 	int numblock = 0;
 	int num, i;
@@ -439,7 +439,7 @@
 	closeRoom();
 }
 
-void Scumm::readArrayFromIndexFile() {
+void ScummEngine::readArrayFromIndexFile() {
 	int num;
 	int a, b, c;
 
@@ -472,7 +472,7 @@
 	}
 }
 
-void Scumm::readResTypeList(int id, uint32 tag, const char *name) {
+void ScummEngine::readResTypeList(int id, uint32 tag, const char *name) {
 	int num;
 	int i;
 
@@ -528,7 +528,7 @@
 	}
 }
 
-void Scumm::allocResTypeData(int id, uint32 tag, int num, const char *name, int mode) {
+void ScummEngine::allocResTypeData(int id, uint32 tag, int num, const char *name, int mode) {
 	debug(9, "allocResTypeData(%s/%s,%x,%d,%d)", resTypeFromId(id), name, FROM_LE_32(tag), num, mode);
 	assert(id >= 0 && id < (int)(ARRAYSIZE(res.mode)));
 
@@ -549,7 +549,7 @@
 	}
 }
 
-void Scumm::loadCharset(int no) {
+void ScummEngine::loadCharset(int no) {
 	int i;
 	byte *ptr;
 
@@ -572,12 +572,12 @@
 	}
 }
 
-void Scumm::nukeCharset(int i) {
+void ScummEngine::nukeCharset(int i) {
 	checkRange(_maxCharsets - 1, 1, i, "Nuking illegal charset %d");
 	nukeResource(rtCharset, i);
 }
 
-void Scumm::ensureResourceLoaded(int type, int i) {
+void ScummEngine::ensureResourceLoaded(int type, int i) {
 	void *addr = NULL;
 
 	debug(9, "ensureResourceLoaded(%s,%d)", resTypeFromId(type), i);
@@ -613,7 +613,7 @@
 			VAR(VAR_ROOM_FLAG) = 1;
 }
 
-int Scumm::loadResource(int type, int idx) {
+int ScummEngine::loadResource(int type, int idx) {
 	int roomNr;
 	uint32 fileOffs;
 	uint32 size, tag;
@@ -696,7 +696,7 @@
 	error("Cannot read resource");
 }
 
-int Scumm::readSoundResource(int type, int idx) {
+int ScummEngine::readSoundResource(int type, int idx) {
 	uint32 pos, total_size, size, tag, basetag, max_total_size;
 	int pri, best_pri;
 	uint32 best_size = 0, best_offs = 0;
@@ -911,7 +911,7 @@
 	240, 276, 340, 460,
 	600, 860, 1200, 1600
 };
-int Scumm::convert_extraflags(byte * ptr, byte * src_ptr) {
+int ScummEngine::convert_extraflags(byte * ptr, byte * src_ptr) {
 	int flags = src_ptr[0];
 
 	int t1, t2, t3, t4, time;
@@ -1039,7 +1039,7 @@
 	}
 }
 
-void Scumm::convertMac0Resource(int type, int idx, byte *src_ptr, int size) {
+void ScummEngine::convertMac0Resource(int type, int idx, byte *src_ptr, int size) {
 	/*
 	From Markus Magnuson (superqult) we got this information:
 	Mac0
@@ -1176,7 +1176,7 @@
 #endif
 }
 
-void Scumm::convertADResource(int type, int idx, byte *src_ptr, int size) {
+void ScummEngine::convertADResource(int type, int idx, byte *src_ptr, int size) {
 
 	// We will ignore the PPQN in the original resource, because
 	// it's invalid anyway. We use a constant PPQN of 480.
@@ -1565,7 +1565,7 @@
 }
 
 
-int Scumm::readSoundResourceSmallHeader(int type, int idx) {
+int ScummEngine::readSoundResourceSmallHeader(int type, int idx) {
 	uint32 pos, total_size, size, tag;
 	uint32 ad_size = 0, ad_offs = 0;
 	uint32 ro_size = 0, ro_offs = 0;
@@ -1683,20 +1683,20 @@
 }
 
 
-int Scumm::getResourceRoomNr(int type, int idx) {
+int ScummEngine::getResourceRoomNr(int type, int idx) {
 	if (type == rtRoom)
 		return idx;
 	return res.roomno[type][idx];
 }
 
-int Scumm::getResourceSize(int type, int idx) {
+int ScummEngine::getResourceSize(int type, int idx) {
 	byte *ptr = getResourceAddress(type, idx);
 	MemBlkHeader *hdr = (MemBlkHeader *)(ptr - sizeof(MemBlkHeader));
 	
 	return hdr->size;
 }
 
-byte *Scumm::getResourceAddress(int type, int idx) {
+byte *ScummEngine::getResourceAddress(int type, int idx) {
 	byte *ptr;
 
 	CHECK_HEAP
@@ -1723,7 +1723,7 @@
 	return ptr + sizeof(MemBlkHeader);
 }
 
-byte *Scumm::getStringAddress(int i) {
+byte *ScummEngine::getStringAddress(int i) {
 	byte *b = getResourceAddress(rtString, i);
 	if (!b)
 		return NULL;
@@ -1733,7 +1733,7 @@
 	return b;
 }
 
-byte *Scumm::getStringAddressVar(int i) {
+byte *ScummEngine::getStringAddressVar(int i) {
 	byte *addr;
 
 	addr = getResourceAddress(rtString, _scummVars[i]);
@@ -1749,7 +1749,7 @@
 	return (addr);
 }
 
-void Scumm::setResourceCounter(int type, int idx, byte flag) {
+void ScummEngine::setResourceCounter(int type, int idx, byte flag) {
 	res.flags[type][idx] &= ~RF_USAGE;
 	res.flags[type][idx] |= flag;
 }
@@ -1757,7 +1757,7 @@
 /* 2 bytes safety area to make "precaching" of bytes in the gdi drawer easier */
 #define SAFETY_AREA 2
 
-byte *Scumm::createResource(int type, int idx, uint32 size) {
+byte *ScummEngine::createResource(int type, int idx, uint32 size) {
 	byte *ptr;
 
 	CHECK_HEAP
@@ -1783,7 +1783,7 @@
 	return ptr + sizeof(MemBlkHeader);	/* skip header */
 }
 
-bool Scumm::validateResource(const char *str, int type, int idx) const {
+bool ScummEngine::validateResource(const char *str, int type, int idx) const {
 	if (type < rtFirst || type > rtLast || (uint) idx >= (uint) res.num[type]) {
 		warning("%s Illegal Glob type %s (%d) num %d", str, resTypeFromId(type), type, idx);
 		return false;
@@ -1791,7 +1791,7 @@
 	return true;
 }
 
-void Scumm::nukeResource(int type, int idx) {
+void ScummEngine::nukeResource(int type, int idx) {
 	byte *ptr;
 
 	CHECK_HEAP
@@ -1816,7 +1816,7 @@
 	}
 }
 
-const byte *Scumm::findResourceData(uint32 tag, const byte *ptr) {
+const byte *ScummEngine::findResourceData(uint32 tag, const byte *ptr) {
 	if (_features & GF_OLD_BUNDLE)
 		error("findResourceData must not be used in GF_OLD_BUNDLE games");
 	else if (_features & GF_SMALL_HEADER)
@@ -1829,7 +1829,7 @@
 	return ptr + _resourceHeaderSize;
 }
 
-int Scumm::getResourceDataSize(const byte *ptr) const {
+int ScummEngine::getResourceDataSize(const byte *ptr) const {
 	if (ptr == NULL)
 		return 0;
 
@@ -1841,7 +1841,7 @@
 		return READ_BE_UINT32(ptr - 4) - 8;
 }
 
-void Scumm::lock(int type, int i) {
+void ScummEngine::lock(int type, int i) {
 	if (!validateResource("Locking", type, i))
 		return;
 	res.flags[type][i] |= RF_LOCK;
@@ -1849,7 +1849,7 @@
 //  debug(1, "locking %d,%d", type, i);
 }
 
-void Scumm::unlock(int type, int i) {
+void ScummEngine::unlock(int type, int i) {
 	if (!validateResource("Unlocking", type, i))
 		return;
 	res.flags[type][i] &= ~RF_LOCK;
@@ -1857,7 +1857,7 @@
 //  debug(1, "unlocking %d,%d", type, i);
 }
 
-bool Scumm::isResourceInUse(int type, int i) const {
+bool ScummEngine::isResourceInUse(int type, int i) const {
 	if (!validateResource("isResourceInUse", type, i))
 		return false;
 	switch (type) {
@@ -1876,7 +1876,7 @@
 	}
 }
 
-void Scumm::increaseResourceCounter() {
+void ScummEngine::increaseResourceCounter() {
 	int i, j;
 	byte counter;
 
@@ -1890,7 +1890,7 @@
 	}
 }
 
-void Scumm::expireResources(uint32 size) {
+void ScummEngine::expireResources(uint32 size) {
 	int i, j;
 	byte flag;
 	byte best_counter;
@@ -1935,7 +1935,7 @@
 	debug(5, "Expired resources, mem %d -> %d", oldAllocatedSize, _allocatedSize);
 }
 
-void Scumm::freeResources() {
+void ScummEngine::freeResources() {
 	int i, j;
 	for (i = rtFirst; i <= rtLast; i++) {
 		for (j = res.num[i]; --j >= 0;) {
@@ -1949,7 +1949,7 @@
 	}
 }
 
-void Scumm::loadPtrToResource(int type, int resindex, const byte *source) {
+void ScummEngine::loadPtrToResource(int type, int resindex, const byte *source) {
 	byte *alloced;
 	int i, len;
 
@@ -1972,13 +1972,13 @@
 	}
 }
 
-bool Scumm::isResourceLoaded(int type, int idx) const {
+bool ScummEngine::isResourceLoaded(int type, int idx) const {
 	if (!validateResource("isLoaded", type, idx))
 		return false;
 	return res.address[type][idx] != NULL;
 }
 
-void Scumm::resourceStats() {
+void ScummEngine::resourceStats() {
 	int i, j;
 	uint32 lockedSize = 0, lockedNum = 0;
 	byte flag;
@@ -1995,7 +1995,7 @@
 	debug(1, "Total allocated size=%d, locked=%d(%d)", _allocatedSize, lockedSize, lockedNum);
 }
 
-void Scumm::readMAXS() {
+void ScummEngine::readMAXS() {
 	if (_version == 8) {                    // CMI
 		_fileHandle.seek(50 + 50, SEEK_CUR);            // 176 - 8
 		_numVariables = _fileHandle.readUint32LE();     // 1500
@@ -2115,7 +2115,7 @@
 	_dynamicRoomOffsets = true;
 }
 
-void Scumm::allocateArrays() {
+void ScummEngine::allocateArrays() {
 	// Note: Buffers are now allocated in scummMain to allow for
 	//     early GUI init.
 
@@ -2150,14 +2150,14 @@
 }
 
 
-bool Scumm::isGlobInMemory(int type, int idx) const{
+bool ScummEngine::isGlobInMemory(int type, int idx) const{
 	if (!validateResource("isGlobInMemory", type, idx))
 		return false;
 
 	return res.address[type][idx] != NULL;
 }
 
-void Scumm::dumpResource(const char *tag, int idx, const byte *ptr, int length) {
+void ScummEngine::dumpResource(const char *tag, int idx, const byte *ptr, int length) {
 	char buf[256];
 	File out;
 

Index: resource_v2.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/resource_v2.cpp,v
retrieving revision 1.33
retrieving revision 1.34
diff -u -d -r1.33 -r1.34
--- resource_v2.cpp	8 Sep 2003 16:50:54 -0000	1.33
+++ resource_v2.cpp	2 Oct 2003 22:42:02 -0000	1.34
@@ -27,7 +27,7 @@
 #include "resource.h"
 #include "sound/mididrv.h"
 
-void Scumm_v2::readClassicIndexFile() {
+void ScummEngine_v2::readClassicIndexFile() {
 	int i;
 
 	if (_gameId == GID_MANIAC) {
@@ -104,7 +104,7 @@
 	}
 }
 
-void Scumm_v2::readEnhancedIndexFile() {
+void ScummEngine_v2::readEnhancedIndexFile() {
 
 	if (!(_features & GF_AMIGA))
 		_musicEngine = _playerV2 = new Player_V2(this);
@@ -143,7 +143,7 @@
 	readResTypeList(rtSound, MKID('SOUN'), "sound");
 }
 
-void Scumm_v2::readIndexFile() {
+void ScummEngine_v2::readIndexFile() {
 	int magic = 0;
 	debug(9, "readIndexFile()");
 
@@ -177,7 +177,7 @@
 	closeRoom();
 }
 
-void Scumm_v2::readMAXS() {
+void ScummEngine_v2::readMAXS() {
 	// FIXME - I'm not sure for those values yet, they will have to be rechecked
 
 	_numVariables = 800;				// 800
@@ -199,6 +199,6 @@
 	allocateArrays();
 }
 
-void Scumm_v2::loadCharset(int num) {
+void ScummEngine_v2::loadCharset(int num) {
 	// Stub, V2 font resources are hardcoded into the engine.
 }

Index: resource_v3.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/resource_v3.cpp,v
retrieving revision 1.21
retrieving revision 1.22
diff -u -d -r1.21 -r1.22
--- resource_v3.cpp	27 Aug 2003 01:12:17 -0000	1.21
+++ resource_v3.cpp	2 Oct 2003 22:42:02 -0000	1.22
@@ -26,7 +26,7 @@
 #include "resource.h"
 
 
-void Scumm_v3::readIndexFile() {
+void ScummEngine_v3::readIndexFile() {
 	if (_features & GF_OLD_BUNDLE) {
 		int magic = 0;
 		debug(9, "readIndexFile()");
@@ -163,7 +163,7 @@
 	}
 }
 
-void Scumm_v3::loadCharset(int no) {
+void ScummEngine_v3::loadCharset(int no) {
 	uint32 size;
 	memset(_charsetData, 0, sizeof(_charsetData));
 
@@ -190,7 +190,7 @@
 	file.close();
 }
 
-void Scumm_v3::readMAXS() {
+void ScummEngine_v3::readMAXS() {
 	// FIXME - I'm not sure for those values yet, they will have to be rechecked
 
 	_numVariables = 800;				// 800
@@ -212,7 +212,7 @@
 	allocateArrays();
 }
 
-void Scumm_v3::readGlobalObjects() {
+void ScummEngine_v3::readGlobalObjects() {
 	int num = _fileHandle.readUint16LE();
 	assert(num == _numGlobalObjects);
 	for (int i = 0; i != num; i++) {

Index: resource_v4.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/resource_v4.cpp,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- resource_v4.cpp	6 Mar 2003 21:46:11 -0000	1.6
+++ resource_v4.cpp	2 Oct 2003 22:42:02 -0000	1.7
@@ -24,7 +24,7 @@
 #include "scumm.h"
 #include "intern.h"
 
-void Scumm_v4::loadCharset(int no) {
+void ScummEngine_v4::loadCharset(int no) {
 	uint32 size;
 	memset(_charsetData, 0, sizeof(_charsetData));
 

Index: saveload.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/saveload.cpp,v
retrieving revision 1.110
retrieving revision 1.111
diff -u -d -r1.110 -r1.111
--- saveload.cpp	14 Sep 2003 20:34:48 -0000	1.110
+++ saveload.cpp	2 Oct 2003 22:42:02 -0000	1.111
@@ -46,20 +46,20 @@
 };
 
 
-void Scumm::requestSave(int slot, const char *name) {
+void ScummEngine::requestSave(int slot, const char *name) {
 	_saveLoadSlot = slot;
 	_saveLoadCompatible = false;
 	_saveLoadFlag = 1;		// 1 for save
 	strcpy(_saveLoadName, name);
 }
 
-void Scumm::requestLoad(int slot) {
+void ScummEngine::requestLoad(int slot) {
 	_saveLoadSlot = slot;
 	_saveLoadCompatible = false;
 	_saveLoadFlag = 2;		// 2 for load
 }
 
-bool Scumm::saveState(int slot, bool compat, SaveFileManager *mgr) {
+bool ScummEngine::saveState(int slot, bool compat, SaveFileManager *mgr) {
 	char filename[256];
 	SaveFile *out;
 	SaveGameHeader hdr;
@@ -84,7 +84,7 @@
 	return true;
 }
 
-bool Scumm::loadState(int slot, bool compat, SaveFileManager *mgr) {
+bool ScummEngine::loadState(int slot, bool compat, SaveFileManager *mgr) {
 	char filename[256];
 	SaveFile *out;
 	int i, j;
@@ -225,18 +225,18 @@
 	return true;
 }
 
-void Scumm::makeSavegameName(char *out, int slot, bool compatible) {
+void ScummEngine::makeSavegameName(char *out, int slot, bool compatible) {
 	sprintf(out, "%s.%c%.2d", _game_name, compatible ? 'c' : 's', slot);
 }
 
-void Scumm::listSavegames(bool *marks, int num, SaveFileManager *mgr) {
+void ScummEngine::listSavegames(bool *marks, int num, SaveFileManager *mgr) {
 	char prefix[256];
 	makeSavegameName(prefix, 99, false);
 	prefix[strlen(prefix)-2] = 0;
 	mgr->list_savefiles(prefix, getSavePath(), marks, num);
 }
 
-bool Scumm::getSavegameName(int slot, char *desc, SaveFileManager *mgr) {
+bool ScummEngine::getSavegameName(int slot, char *desc, SaveFileManager *mgr) {
 	char filename[256];
 	SaveFile *out;
 	SaveGameHeader hdr;
@@ -267,7 +267,7 @@
 	return true;
 }
 
-void Scumm::saveOrLoad(Serializer *s, uint32 savegameVersion) {
+void ScummEngine::saveOrLoad(Serializer *s, uint32 savegameVersion) {
 	const SaveLoadEntry objectEntries[] = {
 		MKLINE(ObjectData, OBIMoffset, sleUint32, VER(8)),
 		MKLINE(ObjectData, OBCDoffset, sleUint32, VER(8)),
@@ -317,154 +317,154 @@
 	};
 
 	const SaveLoadEntry mainEntries[] = {
-		MKLINE(Scumm, _roomWidth, sleUint16, VER(8)),
-		MKLINE(Scumm, _roomHeight, sleUint16, VER(8)),
-		MKLINE(Scumm, _ENCD_offs, sleUint32, VER(8)),
-		MKLINE(Scumm, _EXCD_offs, sleUint32, VER(8)),
-		MKLINE(Scumm, _IM00_offs, sleUint32, VER(8)),
-		MKLINE(Scumm, _CLUT_offs, sleUint32, VER(8)),
-		MK_OBSOLETE(Scumm, _EPAL_offs, sleUint32, VER(8), VER(9)),
-		MKLINE(Scumm, _PALS_offs, sleUint32, VER(8)),
-		MKLINE(Scumm, _curPalIndex, sleByte, VER(8)),
-		MKLINE(Scumm, _currentRoom, sleByte, VER(8)),
-		MKLINE(Scumm, _roomResource, sleByte, VER(8)),
-		MKLINE(Scumm, _numObjectsInRoom, sleByte, VER(8)),
-		MKLINE(Scumm, _currentScript, sleByte, VER(8)),
-		MKARRAY(Scumm, _localScriptList[0], sleUint32, NUM_LOCALSCRIPT, VER(8)),
+		MKLINE(ScummEngine, _roomWidth, sleUint16, VER(8)),
+		MKLINE(ScummEngine, _roomHeight, sleUint16, VER(8)),
+		MKLINE(ScummEngine, _ENCD_offs, sleUint32, VER(8)),
+		MKLINE(ScummEngine, _EXCD_offs, sleUint32, VER(8)),
+		MKLINE(ScummEngine, _IM00_offs, sleUint32, VER(8)),
+		MKLINE(ScummEngine, _CLUT_offs, sleUint32, VER(8)),
+		MK_OBSOLETE(ScummEngine, _EPAL_offs, sleUint32, VER(8), VER(9)),
+		MKLINE(ScummEngine, _PALS_offs, sleUint32, VER(8)),
+		MKLINE(ScummEngine, _curPalIndex, sleByte, VER(8)),
+		MKLINE(ScummEngine, _currentRoom, sleByte, VER(8)),
+		MKLINE(ScummEngine, _roomResource, sleByte, VER(8)),
+		MKLINE(ScummEngine, _numObjectsInRoom, sleByte, VER(8)),
+		MKLINE(ScummEngine, _currentScript, sleByte, VER(8)),
+		MKARRAY(ScummEngine, _localScriptList[0], sleUint32, NUM_LOCALSCRIPT, VER(8)),
 
 
 		// vm.localvar grew from 25 to 40 script entries and then from
 		// 16 to 32 bit variables (but that wasn't reflect here)... and
 		// THEN from 16 to 25 variables.
-		MKARRAY2_OLD(Scumm, vm.localvar[0][0], sleUint16, 17, 25, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(8), VER(8)),
-		MKARRAY2_OLD(Scumm, vm.localvar[0][0], sleUint16, 17, 40, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(9), VER(14)),
+		MKARRAY2_OLD(ScummEngine, vm.localvar[0][0], sleUint16, 17, 25, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(8), VER(8)),
+		MKARRAY2_OLD(ScummEngine, vm.localvar[0][0], sleUint16, 17, 40, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(9), VER(14)),
 
 		// We used to save 25 * 40 = 1000 blocks; but actually, each 'row consisted of 26 entry,
 		// i.e. 26 * 40 = 1040. Thus the last 40 blocks of localvar where not saved at all. To be
 		// able to load this screwed format, we use a trick: We load 26 * 38 = 988 blocks.
 		// Then, we mark the followin 12 blocks (24 bytes) as obsolete.
-		MKARRAY2_OLD(Scumm, vm.localvar[0][0], sleUint16, 26, 38, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(15), VER(17)),
-		MK_OBSOLETE_ARRAY(Scumm, vm.localvar[39][0], sleUint16, 12, VER(15), VER(17)),
+		MKARRAY2_OLD(ScummEngine, vm.localvar[0][0], sleUint16, 26, 38, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(15), VER(17)),
+		MK_OBSOLETE_ARRAY(ScummEngine, vm.localvar[39][0], sleUint16, 12, VER(15), VER(17)),
 
 		// This was the first proper multi dimensional version of the localvars, with 32 bit values
-		MKARRAY2_OLD(Scumm, vm.localvar[0][0], sleUint32, 26, 40, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(18), VER(19)),
+		MKARRAY2_OLD(ScummEngine, vm.localvar[0][0], sleUint32, 26, 40, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(18), VER(19)),
 
 		// Then we doubled the script slots again, from 40 to 80
-		MKARRAY2(Scumm, vm.localvar[0][0], sleUint32, 26, NUM_SCRIPT_SLOT, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(20)),
+		MKARRAY2(ScummEngine, vm.localvar[0][0], sleUint32, 26, NUM_SCRIPT_SLOT, (byte*)vm.localvar[1] - (byte*)vm.localvar[0], VER(20)),
 
 
-		MKARRAY(Scumm, _resourceMapper[0], sleByte, 128, VER(8)),
-		MKARRAY(Scumm, _charsetColorMap[0], sleByte, 16, VER(8)),
+		MKARRAY(ScummEngine, _resourceMapper[0], sleByte, 128, VER(8)),
+		MKARRAY(ScummEngine, _charsetColorMap[0], sleByte, 16, VER(8)),
 		
 		// _charsetData grew from 10*16 to 15*16 bytes
-		MKARRAY_OLD(Scumm, _charsetData[0][0], sleByte, 10 * 16, VER(8), VER(9)),
-		MKARRAY(Scumm, _charsetData[0][0], sleByte, 15 * 16, VER(10)),
+		MKARRAY_OLD(ScummEngine, _charsetData[0][0], sleByte, 10 * 16, VER(8), VER(9)),
+		MKARRAY(ScummEngine, _charsetData[0][0], sleByte, 15 * 16, VER(10)),
 
-		MKLINE(Scumm, _curExecScript, sleUint16, VER(8)),
+		MKLINE(ScummEngine, _curExecScript, sleUint16, VER(8)),
 
-		MKLINE(Scumm, camera._dest.x, sleInt16, VER(8)),
-		MKLINE(Scumm, camera._dest.y, sleInt16, VER(8)),
-		MKLINE(Scumm, camera._cur.x, sleInt16, VER(8)),
-		MKLINE(Scumm, camera._cur.y, sleInt16, VER(8)),
-		MKLINE(Scumm, camera._last.x, sleInt16, VER(8)),
-		MKLINE(Scumm, camera._last.y, sleInt16, VER(8)),
-		MKLINE(Scumm, camera._accel.x, sleInt16, VER(8)),
-		MKLINE(Scumm, camera._accel.y, sleInt16, VER(8)),
-		MKLINE(Scumm, _screenStartStrip, sleInt16, VER(8)),
-		MKLINE(Scumm, _screenEndStrip, sleInt16, VER(8)),
-		MKLINE(Scumm, camera._mode, sleByte, VER(8)),
-		MKLINE(Scumm, camera._follows, sleByte, VER(8)),
-		MKLINE(Scumm, camera._leftTrigger, sleInt16, VER(8)),
-		MKLINE(Scumm, camera._rightTrigger, sleInt16, VER(8)),
-		MKLINE(Scumm, camera._movingToActor, sleUint16, VER(8)),
+		MKLINE(ScummEngine, camera._dest.x, sleInt16, VER(8)),
+		MKLINE(ScummEngine, camera._dest.y, sleInt16, VER(8)),
+		MKLINE(ScummEngine, camera._cur.x, sleInt16, VER(8)),
+		MKLINE(ScummEngine, camera._cur.y, sleInt16, VER(8)),
+		MKLINE(ScummEngine, camera._last.x, sleInt16, VER(8)),
+		MKLINE(ScummEngine, camera._last.y, sleInt16, VER(8)),
+		MKLINE(ScummEngine, camera._accel.x, sleInt16, VER(8)),
+		MKLINE(ScummEngine, camera._accel.y, sleInt16, VER(8)),
+		MKLINE(ScummEngine, _screenStartStrip, sleInt16, VER(8)),
+		MKLINE(ScummEngine, _screenEndStrip, sleInt16, VER(8)),
+		MKLINE(ScummEngine, camera._mode, sleByte, VER(8)),
+		MKLINE(ScummEngine, camera._follows, sleByte, VER(8)),
+		MKLINE(ScummEngine, camera._leftTrigger, sleInt16, VER(8)),
+		MKLINE(ScummEngine, camera._rightTrigger, sleInt16, VER(8)),
+		MKLINE(ScummEngine, camera._movingToActor, sleUint16, VER(8)),
 
-		MKLINE(Scumm, _actorToPrintStrFor, sleByte, VER(8)),
-		MKLINE(Scumm, _charsetColor, sleByte, VER(8)),
+		MKLINE(ScummEngine, _actorToPrintStrFor, sleByte, VER(8)),
+		MKLINE(ScummEngine, _charsetColor, sleByte, VER(8)),
 
 		// _charsetBufPos was changed from byte to int
-		MKLINE_OLD(Scumm, _charsetBufPos, sleByte, VER(8), VER(9)),
-		MKLINE(Scumm, _charsetBufPos, sleInt16, VER(10)),
+		MKLINE_OLD(ScummEngine, _charsetBufPos, sleByte, VER(8), VER(9)),
+		MKLINE(ScummEngine, _charsetBufPos, sleInt16, VER(10)),
 
-		MKLINE(Scumm, _haveMsg, sleByte, VER(8)),
-		MKLINE(Scumm, _useTalkAnims, sleByte, VER(8)),
+		MKLINE(ScummEngine, _haveMsg, sleByte, VER(8)),
+		MKLINE(ScummEngine, _useTalkAnims, sleByte, VER(8)),
 
-		MKLINE(Scumm, _talkDelay, sleInt16, VER(8)),
-		MKLINE(Scumm, _defaultTalkDelay, sleInt16, VER(8)),
-		MKLINE(Scumm, _numInMsgStack, sleInt16, VER(8)),
-		MKLINE(Scumm, _sentenceNum, sleByte, VER(8)),
+		MKLINE(ScummEngine, _talkDelay, sleInt16, VER(8)),
+		MKLINE(ScummEngine, _defaultTalkDelay, sleInt16, VER(8)),
+		MKLINE(ScummEngine, _numInMsgStack, sleInt16, VER(8)),
+		MKLINE(ScummEngine, _sentenceNum, sleByte, VER(8)),
 
-		MKLINE(Scumm, vm.cutSceneStackPointer, sleByte, VER(8)),
-		MKARRAY(Scumm, vm.cutScenePtr[0], sleUint32, 5, VER(8)),
-		MKARRAY(Scumm, vm.cutSceneScript[0], sleByte, 5, VER(8)),
-		MKARRAY(Scumm, vm.cutSceneData[0], sleInt16, 5, VER(8)),
-		MKLINE(Scumm, vm.cutSceneScriptIndex, sleInt16, VER(8)),
+		MKLINE(ScummEngine, vm.cutSceneStackPointer, sleByte, VER(8)),
+		MKARRAY(ScummEngine, vm.cutScenePtr[0], sleUint32, 5, VER(8)),
+		MKARRAY(ScummEngine, vm.cutSceneScript[0], sleByte, 5, VER(8)),
+		MKARRAY(ScummEngine, vm.cutSceneData[0], sleInt16, 5, VER(8)),
+		MKLINE(ScummEngine, vm.cutSceneScriptIndex, sleInt16, VER(8)),
 
-		MKLINE(Scumm, vm.numNestedScripts, sleByte, VER(8)),
-		MKLINE(Scumm, _userPut, sleByte, VER(8)),
-		MKLINE(Scumm, _userState, sleUint16, VER(17)),
-		MKLINE(Scumm, _cursor.state, sleByte, VER(8)),
-		MK_OBSOLETE(Scumm, gdi._cursorActive, sleByte, VER(8), VER(20)),
-		MKLINE(Scumm, _currentCursor, sleByte, VER(8)),
-		MKARRAY(Scumm, _grabbedCursor[0], sleByte, 8192, VER(20)),
-		MKLINE(Scumm, _cursor.width, sleInt16, VER(20)),
-		MKLINE(Scumm, _cursor.height, sleInt16, VER(20)),
-		MKLINE(Scumm, _cursor.hotspotX, sleInt16, VER(20)),
-		MKLINE(Scumm, _cursor.hotspotY, sleInt16, VER(20)),
-		MKLINE(Scumm, _cursor.animate, sleByte, VER(20)),
-		MKLINE(Scumm, _cursor.animateIndex, sleByte, VER(20)),
-		MKLINE(Scumm, _mouse.x, sleInt16, VER(20)),
-		MKLINE(Scumm, _mouse.y, sleInt16, VER(20)),
+		MKLINE(ScummEngine, vm.numNestedScripts, sleByte, VER(8)),
+		MKLINE(ScummEngine, _userPut, sleByte, VER(8)),
+		MKLINE(ScummEngine, _userState, sleUint16, VER(17)),
+		MKLINE(ScummEngine, _cursor.state, sleByte, VER(8)),
+		MK_OBSOLETE(ScummEngine, gdi._cursorActive, sleByte, VER(8), VER(20)),
+		MKLINE(ScummEngine, _currentCursor, sleByte, VER(8)),
+		MKARRAY(ScummEngine, _grabbedCursor[0], sleByte, 8192, VER(20)),
+		MKLINE(ScummEngine, _cursor.width, sleInt16, VER(20)),
+		MKLINE(ScummEngine, _cursor.height, sleInt16, VER(20)),
+		MKLINE(ScummEngine, _cursor.hotspotX, sleInt16, VER(20)),
+		MKLINE(ScummEngine, _cursor.hotspotY, sleInt16, VER(20)),
+		MKLINE(ScummEngine, _cursor.animate, sleByte, VER(20)),
+		MKLINE(ScummEngine, _cursor.animateIndex, sleByte, VER(20)),
+		MKLINE(ScummEngine, _mouse.x, sleInt16, VER(20)),
+		MKLINE(ScummEngine, _mouse.y, sleInt16, VER(20)),
 
-		MKLINE(Scumm, _doEffect, sleByte, VER(8)),
-		MKLINE(Scumm, _switchRoomEffect, sleByte, VER(8)),
-		MKLINE(Scumm, _newEffect, sleByte, VER(8)),
-		MKLINE(Scumm, _switchRoomEffect2, sleByte, VER(8)),
-		MKLINE(Scumm, _BgNeedsRedraw, sleByte, VER(8)),
+		MKLINE(ScummEngine, _doEffect, sleByte, VER(8)),
+		MKLINE(ScummEngine, _switchRoomEffect, sleByte, VER(8)),
+		MKLINE(ScummEngine, _newEffect, sleByte, VER(8)),
+		MKLINE(ScummEngine, _switchRoomEffect2, sleByte, VER(8)),
+		MKLINE(ScummEngine, _BgNeedsRedraw, sleByte, VER(8)),
 
 		// The state of palManipulate is stored only since V10
-		MKLINE(Scumm, _palManipStart, sleByte, VER(10)),
-		MKLINE(Scumm, _palManipEnd, sleByte, VER(10)),
-		MKLINE(Scumm, _palManipCounter, sleUint16, VER(10)),
+		MKLINE(ScummEngine, _palManipStart, sleByte, VER(10)),
+		MKLINE(ScummEngine, _palManipEnd, sleByte, VER(10)),
+		MKLINE(ScummEngine, _palManipCounter, sleUint16, VER(10)),
 
 		// gfxUsageBits grew from 200 to 410 entries. Then 3 * 410 entries:
-		MKARRAY_OLD(Scumm, gfxUsageBits[0], sleUint32, 200, VER(8), VER(9)),
-		MKARRAY_OLD(Scumm, gfxUsageBits[0], sleUint32, 410, VER(10), VER(13)),
-		MKARRAY(Scumm, gfxUsageBits[0], sleUint32, 3 * 410, VER(14)),
+		MKARRAY_OLD(ScummEngine, gfxUsageBits[0], sleUint32, 200, VER(8), VER(9)),
+		MKARRAY_OLD(ScummEngine, gfxUsageBits[0], sleUint32, 410, VER(10), VER(13)),
+		MKARRAY(ScummEngine, gfxUsageBits[0], sleUint32, 3 * 410, VER(14)),
 
-		MKLINE(Scumm, gdi._transparentColor, sleByte, VER(8)),
-		MKARRAY(Scumm, _currentPalette[0], sleByte, 768, VER(8)),
+		MKLINE(ScummEngine, gdi._transparentColor, sleByte, VER(8)),
+		MKARRAY(ScummEngine, _currentPalette[0], sleByte, 768, VER(8)),
 
-		MKARRAY(Scumm, _proc_special_palette[0], sleByte, 256, VER(8)),
+		MKARRAY(ScummEngine, _proc_special_palette[0], sleByte, 256, VER(8)),
 
-		MKARRAY(Scumm, _charsetBuffer[0], sleByte, 256, VER(8)),
+		MKARRAY(ScummEngine, _charsetBuffer[0], sleByte, 256, VER(8)),
 
-		MKLINE(Scumm, _egoPositioned, sleByte, VER(8)),
+		MKLINE(ScummEngine, _egoPositioned, sleByte, VER(8)),
 
 		// gdi._imgBufOffs grew from 4 to 5 entries :
-		MKARRAY_OLD(Scumm, gdi._imgBufOffs[0], sleUint16, 4, VER(8), VER(9)),
-		MKARRAY(Scumm, gdi._imgBufOffs[0], sleUint16, 5, VER(10)),
+		MKARRAY_OLD(ScummEngine, gdi._imgBufOffs[0], sleUint16, 4, VER(8), VER(9)),
+		MKARRAY(ScummEngine, gdi._imgBufOffs[0], sleUint16, 5, VER(10)),
 
-		MKLINE(Scumm, gdi._numZBuffer, sleByte, VER(8)),
+		MKLINE(ScummEngine, gdi._numZBuffer, sleByte, VER(8)),
 
-		MKLINE(Scumm, _screenEffectFlag, sleByte, VER(8)),
+		MKLINE(ScummEngine, _screenEffectFlag, sleByte, VER(8)),
 
-		MK_OBSOLETE(Scumm, _randSeed1, sleUint32, VER(8), VER(9)),
-		MK_OBSOLETE(Scumm, _randSeed2, sleUint32, VER(8), VER(9)),
+		MK_OBSOLETE(ScummEngine, _randSeed1, sleUint32, VER(8), VER(9)),
+		MK_OBSOLETE(ScummEngine, _randSeed2, sleUint32, VER(8), VER(9)),
 
 		// Converted _shakeEnabled to boolean and added a _shakeFrame field.
-		MKLINE_OLD(Scumm, _shakeEnabled, sleInt16, VER(8), VER(9)),
-		MKLINE(Scumm, _shakeEnabled, sleByte, VER(10)),
-		MKLINE(Scumm, _shakeFrame, sleUint32, VER(10)),
+		MKLINE_OLD(ScummEngine, _shakeEnabled, sleInt16, VER(8), VER(9)),
+		MKLINE(ScummEngine, _shakeEnabled, sleByte, VER(10)),
+		MKLINE(ScummEngine, _shakeFrame, sleUint32, VER(10)),
 
-		MKLINE(Scumm, _keepText, sleByte, VER(8)),
+		MKLINE(ScummEngine, _keepText, sleByte, VER(8)),
 
-		MKLINE(Scumm, _screenB, sleUint16, VER(8)),
-		MKLINE(Scumm, _screenH, sleUint16, VER(8)),
+		MKLINE(ScummEngine, _screenB, sleUint16, VER(8)),
+		MKLINE(ScummEngine, _screenH, sleUint16, VER(8)),
 
-		MK_OBSOLETE(Scumm, _cd_track, sleInt16, VER(9), VER(9)),
-		MK_OBSOLETE(Scumm, _cd_loops, sleInt16, VER(9), VER(9)),
-		MK_OBSOLETE(Scumm, _cd_frame, sleInt16, VER(9), VER(9)),
-		MK_OBSOLETE(Scumm, _cd_end, sleInt16, VER(9), VER(9)),
+		MK_OBSOLETE(ScummEngine, _cd_track, sleInt16, VER(9), VER(9)),
+		MK_OBSOLETE(ScummEngine, _cd_loops, sleInt16, VER(9), VER(9)),
+		MK_OBSOLETE(ScummEngine, _cd_frame, sleInt16, VER(9), VER(9)),
+		MK_OBSOLETE(ScummEngine, _cd_end, sleInt16, VER(9), VER(9)),
 		
 		MKEND()
 	};
@@ -679,7 +679,7 @@
 	}
 }
 
-void Scumm::saveLoadResource(Serializer *ser, int type, int idx) {
+void ScummEngine::saveLoadResource(Serializer *ser, int type, int idx) {
 	byte *ptr;
 	uint32 size;
 

Index: script.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/script.cpp,v
retrieving revision 1.134
retrieving revision 1.135
diff -u -d -r1.134 -r1.135
--- script.cpp	24 Sep 2003 06:33:58 -0000	1.134
+++ script.cpp	2 Oct 2003 22:42:02 -0000	1.135
@@ -30,7 +30,7 @@
 #include "scumm/scumm.h"
 
 /* Start executing script 'script' with the given parameters */
-void Scumm::runScript(int script, bool freezeResistant, bool recursive, int *lvarptr) {
+void ScummEngine::runScript(int script, bool freezeResistant, bool recursive, int *lvarptr) {
 	ScriptSlot *s;
 	byte *scriptPtr;
 	uint32 scriptOffs;
@@ -71,7 +71,7 @@
 	runScriptNested(slot);
 }
 
-void Scumm::runObjectScript(int object, int entry, bool freezeResistant, bool recursive, int *vars, int slot) {
+void ScummEngine::runObjectScript(int object, int entry, bool freezeResistant, bool recursive, int *vars, int slot) {
 	ScriptSlot *s;
 	uint32 obcd;
 	int where, offs;
@@ -118,7 +118,7 @@
 #define BYPASS_COPY_PROT
 #endif
 
-void Scumm::initializeLocals(int slot, int *vars) {
+void ScummEngine::initializeLocals(int slot, int *vars) {
 	int i;
 	if (!vars) {
 		for (i = 0; i < 16; i++)
@@ -129,7 +129,7 @@
 	}
 }
 
-int Scumm::getVerbEntrypoint(int obj, int entry) {
+int ScummEngine::getVerbEntrypoint(int obj, int entry) {
 	const byte *objptr, *verbptr;
 	int verboffs;
 
@@ -194,7 +194,7 @@
 }
 
 /* Stop script 'script' */
-void Scumm::stopScript(int script) {
+void ScummEngine::stopScript(int script) {
 	ScriptSlot *ss;
 	NestedScript *nest;
 	int i, num;
@@ -231,7 +231,7 @@
 }
 
 /* Stop an object script 'script'*/
-void Scumm::stopObjectScript(int script) {
+void ScummEngine::stopObjectScript(int script) {
 	ScriptSlot *ss;
 	NestedScript *nest;
 	int i, num;
@@ -268,7 +268,7 @@
 }
 
 /* Return a free script slot */
-int Scumm::getScriptSlot() {
+int ScummEngine::getScriptSlot() {
 	ScriptSlot *ss;
 	int i;
 
@@ -282,7 +282,7 @@
 }
 
 /* Run script 'script' nested - eg, within the parent script.*/
-void Scumm::runScriptNested(int script) {
+void ScummEngine::runScriptNested(int script) {
 	NestedScript *nest;
 	ScriptSlot *slot;
 
@@ -329,7 +329,7 @@
 	_currentScript = 0xFF;
 }
 
-void Scumm::updateScriptPtr() {
+void ScummEngine::updateScriptPtr() {
 	if (_currentScript == 0xFF)
 		return;
 
@@ -337,7 +337,7 @@
 }
 
 /* Get the code pointer to a script */
-void Scumm::getScriptBaseAddress() {
+void ScummEngine::getScriptBaseAddress() {
 	ScriptSlot *ss;
 	int idx;
 
@@ -386,14 +386,14 @@
 }
 
 
-void Scumm::getScriptEntryPoint() {
+void ScummEngine::getScriptEntryPoint() {
 	if (_currentScript == 0xFF)
 		return;
 	_scriptPointer = _scriptOrgPointer + vm.slot[_currentScript].offs;
 }
 
 /* Execute a script - Read opcode, and execute it from the table */
-void Scumm::executeScript() {
+void ScummEngine::executeScript() {
 	int c;
 	while (_currentScript != 0xFF) {
 		
@@ -422,7 +422,7 @@
 	CHECK_HEAP;
 }
 
-byte Scumm::fetchScriptByte() {
+byte ScummEngine::fetchScriptByte() {
 	if (*_lastCodePtr + sizeof(MemBlkHeader) != _scriptOrgPointer) {
 		uint32 oldoffs = _scriptPointer - _scriptOrgPointer;
 		getScriptBaseAddress();
@@ -431,7 +431,7 @@
 	return *_scriptPointer++;
 }
 
-uint Scumm::fetchScriptWord() {
+uint ScummEngine::fetchScriptWord() {
 	int a;
 	if (*_lastCodePtr + sizeof(MemBlkHeader) != _scriptOrgPointer) {
 		uint32 oldoffs = _scriptPointer - _scriptOrgPointer;
@@ -443,11 +443,11 @@
 	return a;
 }
 
-int Scumm::fetchScriptWordSigned() {
+int ScummEngine::fetchScriptWordSigned() {
 	return (int16)fetchScriptWord();
 }
 
-int Scumm::readVar(uint var) {
+int ScummEngine::readVar(uint var) {
 	int a;
 #if defined(BYPASS_COPY_PROT)
 	static byte copyprotbypassed = false;
@@ -529,7 +529,7 @@
 	return -1;
 }
 
-void Scumm::writeVar(uint var, int value) {
+void ScummEngine::writeVar(uint var, int value) {
 	if (!(var & 0xF000)) {
 		checkRange(_numVariables - 1, 0, var, "Variable %d out of range(w)");
 
@@ -592,7 +592,7 @@
 	error("Illegal varbits (w)");
 }
 
-void Scumm::getResultPos() {
+void ScummEngine::getResultPos() {
 	int a;
 
 	_resultVarNumber = fetchScriptWord();
@@ -607,16 +607,16 @@
 	}
 }
 
-void Scumm::setResult(int value) {
+void ScummEngine::setResult(int value) {
 	writeVar(_resultVarNumber, value);
 }
 
-void Scumm::push(int a) {
+void ScummEngine::push(int a) {
 	assert(_scummStackPos >= 0 && _scummStackPos < ARRAYSIZE(_scummStack));
 	_scummStack[_scummStackPos++] = a;
 }
 
-int Scumm::pop() {
+int ScummEngine::pop() {
 	if (_scummStackPos < 1 || _scummStackPos > ARRAYSIZE(_scummStack)) {
 		error("No items on stack to pop() for %s (0x%X) at [%d-%d]", getOpcodeDesc(_opcode), _opcode, _roomResource, vm.slot[_currentScript].number);
 	}
@@ -624,7 +624,7 @@
 	return _scummStack[--_scummStackPos];
 }
 
-void Scumm::stopObjectCode() {
+void ScummEngine::stopObjectCode() {
 	ScriptSlot *ss;
 
 	ss = &vm.slot[_currentScript];
@@ -649,7 +649,7 @@
 	_currentScript = 0xFF;
 }
 
-void Scumm::runInventoryScript(int i) {
+void ScummEngine::runInventoryScript(int i) {
 	if (_version <= 2) {
 		redrawV2Inventory();
 	} else {
@@ -661,7 +661,7 @@
 	}
 }
 
-void Scumm::freezeScripts(int flag) {
+void ScummEngine::freezeScripts(int flag) {
 	int i;
 
 	if (_version <= 2) {
@@ -690,7 +690,7 @@
 	}
 }
 
-void Scumm::unfreezeScripts() {
+void ScummEngine::unfreezeScripts() {
 	int i;
 
 	if (_version <= 2) {
@@ -716,7 +716,7 @@
 }
 
 
-void Scumm::runAllScripts() {
+void ScummEngine::runAllScripts() {
 	int i;
 
 	for (i = 0; i < NUM_SCRIPT_SLOT; i++)
@@ -737,7 +737,7 @@
 	}
 }
 
-void Scumm::runExitScript() {
+void ScummEngine::runExitScript() {
 	if (_version > 2 && VAR(VAR_EXIT_SCRIPT))
 		runScript(VAR(VAR_EXIT_SCRIPT), 0, 0, 0);
 	if (_EXCD_offs) {
@@ -770,7 +770,7 @@
 		runScript(VAR(VAR_EXIT_SCRIPT2), 0, 0, 0);
 }
 
-void Scumm::runEntryScript() {
+void ScummEngine::runEntryScript() {
 	if (_version > 2 && VAR(VAR_ENTRY_SCRIPT))
 		runScript(VAR(VAR_ENTRY_SCRIPT), 0, 0, 0);
 	if (_ENCD_offs) {
@@ -789,7 +789,7 @@
 		runScript(VAR(VAR_ENTRY_SCRIPT2), 0, 0, 0);
 }
 
-void Scumm::killScriptsAndResources() {
+void ScummEngine::killScriptsAndResources() {
 	ScriptSlot *ss;
 	int i;
 
@@ -823,14 +823,14 @@
 	}
 }
 
-void Scumm::killAllScriptsExceptCurrent() {
+void ScummEngine::killAllScriptsExceptCurrent() {
 	for (int i = 0; i < NUM_SCRIPT_SLOT; i++) {
 		if (i != _currentScript)
 			vm.slot[i].status = ssDead;
 	}
 }
 
-void Scumm::doSentence(int verb, int objectA, int objectB) {
+void ScummEngine::doSentence(int verb, int objectA, int objectB) {
 	SentenceTab *st;
 
 	if (_version >= 7) {
@@ -858,7 +858,7 @@
 	st->freezeCount = 0;
 }
 
-void Scumm::checkAndRunSentenceScript() {
+void ScummEngine::checkAndRunSentenceScript() {
 	int i;
 	int localParamList[16];
 	const ScriptSlot *ss;
@@ -900,7 +900,7 @@
 		runScript(sentenceScript, 0, 0, localParamList);
 }
 
-void Scumm::runInputScript(int a, int cmd, int mode) {
+void ScummEngine::runInputScript(int a, int cmd, int mode) {
 	int args[16];
 	int verbScript;
 
@@ -927,7 +927,7 @@
 		runScript(verbScript, 0, 0, args);
 }
 
-void Scumm::decreaseScriptDelay(int amount) {
+void ScummEngine::decreaseScriptDelay(int amount) {
 	ScriptSlot *ss = vm.slot;
 	int i;
 	for (i = 0; i < NUM_SCRIPT_SLOT; i++, ss++) {
@@ -941,7 +941,7 @@
 	}
 }
 
-bool Scumm::isScriptInUse(int script) const {
+bool ScummEngine::isScriptInUse(int script) const {
 	int i;
 	const ScriptSlot *ss = vm.slot;
 	for (i = 0; i < NUM_SCRIPT_SLOT; i++, ss++)
@@ -950,7 +950,7 @@
 	return false;
 }
 
-bool Scumm::isScriptRunning(int script) const {
+bool ScummEngine::isScriptRunning(int script) const {
 	int i;
 	const ScriptSlot *ss = vm.slot;
 	for (i = 0; i < NUM_SCRIPT_SLOT; i++, ss++)
@@ -959,7 +959,7 @@
 	return false;
 }
 
-bool Scumm::isRoomScriptRunning(int script) const {
+bool ScummEngine::isRoomScriptRunning(int script) const {
 	int i;
 	const ScriptSlot *ss = vm.slot;
 	for (i = 0; i < NUM_SCRIPT_SLOT; i++, ss++)
@@ -968,7 +968,7 @@
 	return false;
 }
 
-int Scumm::defineArray(int array, int type, int dim2, int dim1) {
+int ScummEngine::defineArray(int array, int type, int dim2, int dim1) {
 	int id;
 	int size;
 	ArrayHeader *ah;
@@ -1015,7 +1015,7 @@
 	return id;
 }
 
-void Scumm::nukeArray(int a) {
+void ScummEngine::nukeArray(int a) {
 	int data;
 
 	data = readVar(a);
@@ -1026,7 +1026,7 @@
 	writeVar(a, 0);
 }
 
-int Scumm::getArrayId() {
+int ScummEngine::getArrayId() {
 	byte **addr = _baseArrays;
 	int i;
 
@@ -1038,7 +1038,7 @@
 	return -1;
 }
 
-void Scumm::copyScriptString(byte *dst) {
+void ScummEngine::copyScriptString(byte *dst) {
 	int len = resStrLen(_scriptPointer) + 1;
 	while (len--)
 		*dst++ = fetchScriptByte();
@@ -1050,7 +1050,7 @@
 // special characters embedded into the string. The reason for this function is that
 // sometimes this embedded data contains zero bytes, thus we can't just use strlen.
 //
-int Scumm::resStrLen(const byte *src) const {
+int ScummEngine::resStrLen(const byte *src) const {
 	int num = 0;
 	byte chr;
 	if (src == NULL)
@@ -1075,7 +1075,7 @@
 	return num;
 }
 
-void Scumm::beginCutscene(int *args) {
+void ScummEngine::beginCutscene(int *args) {
 	int scr = _currentScript;
 	vm.slot[scr].cutsceneOverride++;
 
@@ -1092,7 +1092,7 @@
 	vm.cutSceneScriptIndex = 0xFF;
 }
 
-void Scumm::endCutscene() {
+void ScummEngine::endCutscene() {
 	ScriptSlot *ss = &vm.slot[_currentScript];
 	int args[16];
 
@@ -1115,7 +1115,7 @@
 		runScript(VAR(VAR_CUTSCENE_END_SCRIPT), 0, 0, args);
 }
 
-void Scumm::abortCutscene() {
+void ScummEngine::abortCutscene() {
 	uint32 offs = vm.cutScenePtr[vm.cutSceneStackPointer];
 	if (offs) {
 		ScriptSlot *ss = &vm.slot[vm.cutSceneScript[vm.cutSceneStackPointer]];
@@ -1131,7 +1131,7 @@
 	}
 }
 
-void Scumm::beginOverride() {
+void ScummEngine::beginOverride() {
 	int idx;
 
 	idx = vm.cutSceneStackPointer;
@@ -1150,7 +1150,7 @@
 	VAR(VAR_OVERRIDE) = 0;
 }
 
-void Scumm::endOverride() {
+void ScummEngine::endOverride() {
 	int idx;
 
 	idx = vm.cutSceneStackPointer;

Index: script_v2.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/script_v2.cpp,v
retrieving revision 2.203
retrieving revision 2.204
diff -u -d -r2.203 -r2.204
--- script_v2.cpp	2 Oct 2003 17:43:02 -0000	2.203
+++ script_v2.cpp	2 Oct 2003 22:42:02 -0000	2.204
@@ -29,9 +29,9 @@
 #include "scumm/sound.h"
 #include "scumm/verbs.h"
 
-#define OPCODE(x)	{ &Scumm_v2::x, #x }
+#define OPCODE(x)	{ &ScummEngine_v2::x, #x }
 
-void Scumm_v2::setupOpcodes() {
+void ScummEngine_v2::setupOpcodes() {
 	static const OpcodeEntryV2 opcodes[256] = {
 		/* 00 */
 		OPCODE(o5_stopObjectCode),
@@ -360,22 +360,22 @@
 
 #define SENTENCE_SCRIPT 2
 
-void Scumm_v2::executeOpcode(byte i) {
+void ScummEngine_v2::executeOpcode(byte i) {
 	OpcodeProcV2 op = _opcodesV2[i].proc;
 	(this->*op) ();
 }
 
-const char *Scumm_v2::getOpcodeDesc(byte i) {
+const char *ScummEngine_v2::getOpcodeDesc(byte i) {
 	return _opcodesV2[i].desc;
 }
 
-int Scumm_v2::getVar() {
+int ScummEngine_v2::getVar() {
 	return readVar(fetchScriptByte());
 }
 
 int v1_mm_actor_speech_color[] = {1, 7, 2, 14, 8, 1, 3, 7, 7, 12, 1, 13, 1, 4, 5, 5, 4, 3, 1, 5, 1, 1, 1, 7, 7, 0};
 
-void Scumm_v2::decodeParseString() {
+void ScummEngine_v2::decodeParseString() {
 	byte buffer[512];
 	byte *ptr = buffer;
 	byte c;
@@ -442,7 +442,7 @@
 	}
 }
 
-int Scumm_v2::readVar(uint var) {
+int ScummEngine_v2::readVar(uint var) {
 	if (var >= 14 && var <= 16)
 		var = _scummVars[var];
 
@@ -451,79 +451,79 @@
 	return _scummVars[var];
 }
 
-void Scumm_v2::writeVar(uint var, int value) {
+void ScummEngine_v2::writeVar(uint var, int value) {
 	checkRange(_numVariables - 1, 0, var, "Variable %d out of range(r)");
 	debug(6, "writeVar(%d) = %d", var, value);
 	_scummVars[var] = value;
 }
 
-void Scumm_v2::getResultPosIndirect() {
+void ScummEngine_v2::getResultPosIndirect() {
 	_resultVarNumber = _scummVars[fetchScriptByte()];
 }
 
-void Scumm_v2::getResultPos() {
+void ScummEngine_v2::getResultPos() {
 	_resultVarNumber = fetchScriptByte();
 }
 
-void Scumm_v2::setStateCommon(byte type) {
+void ScummEngine_v2::setStateCommon(byte type) {
 	int obj = getVarOrDirectWord(0x80);
 	putState(obj, getState(obj) | type);
 }
 
-void Scumm_v2::clearStateCommon(byte type) {
+void ScummEngine_v2::clearStateCommon(byte type) {
 	int obj = getVarOrDirectWord(0x80);
 	putState(obj, getState(obj) & ~type);
 }
 
-void Scumm_v2::o2_setState08() {
+void ScummEngine_v2::o2_setState08() {
 	int obj = getVarOrDirectWord(0x80);
 	putState(obj, getState(obj) | 0x08);
 	removeObjectFromRoom(obj);
 	clearDrawObjectQueue();
 }
 
-void Scumm_v2::o2_clearState08() {
+void ScummEngine_v2::o2_clearState08() {
 	int obj = getVarOrDirectWord(0x80);
 	putState(obj, getState(obj) & ~0x08);
 	removeObjectFromRoom(obj);
 	clearDrawObjectQueue();
 }
 
-void Scumm_v2::o2_setState04() {
+void ScummEngine_v2::o2_setState04() {
 	setStateCommon(0x04);
 }
 
-void Scumm_v2::o2_clearState04() {
+void ScummEngine_v2::o2_clearState04() {
 	clearStateCommon(0x04);
 }
 
-void Scumm_v2::o2_setState02() {
+void ScummEngine_v2::o2_setState02() {
 	setStateCommon(0x02);
 }
 
-void Scumm_v2::o2_clearState02() {
+void ScummEngine_v2::o2_clearState02() {
 	clearStateCommon(0x02);
 }
 
-void Scumm_v2::o2_setState01() {
+void ScummEngine_v2::o2_setState01() {
 	setStateCommon(0x01);
 }
 
-void Scumm_v2::o2_clearState01() {
+void ScummEngine_v2::o2_clearState01() {
 	clearStateCommon(0x01);
 }
 
-void Scumm_v2::o2_assignVarWordIndirect() {
+void ScummEngine_v2::o2_assignVarWordIndirect() {
 	getResultPosIndirect();
 	setResult(getVarOrDirectWord(0x80));
 }
 
-void Scumm_v2::o2_assignVarByte() {
+void ScummEngine_v2::o2_assignVarByte() {
 	getResultPos();
 	setResult(fetchScriptByte());
 }
 
-void Scumm_v2::o2_setObjPreposition() {
+void ScummEngine_v2::o2_setObjPreposition() {
 	int obj = getVarOrDirectWord(0x80);
 	int unk = fetchScriptByte();
 
@@ -535,7 +535,7 @@
 	}
 }
 
-void Scumm_v2::o2_getObjPreposition() {
+void ScummEngine_v2::o2_getObjPreposition() {
 	getResultPos();
 	int obj = getVarOrDirectWord(0x80);
 
@@ -547,7 +547,7 @@
 	}
 }
 
-void Scumm_v2::o2_setBitVar() {
+void ScummEngine_v2::o2_setBitVar() {
 	int var = fetchScriptWord();
 	byte a = getVarOrDirectByte(0x80);
 
@@ -562,7 +562,7 @@
 
 }
 
-void Scumm_v2::o2_getBitVar() {
+void ScummEngine_v2::o2_getBitVar() {
 	getResultPos();
 	int var = fetchScriptWord();
 	byte a = getVarOrDirectByte(0x80);
@@ -574,7 +574,7 @@
 	setResult((_scummVars[bit_var] & (1 << bit_offset)) ? 1 : 0);
 }
 
-void Scumm_v2::ifStateCommon(byte type) {
+void ScummEngine_v2::ifStateCommon(byte type) {
 	int obj = getVarOrDirectWord(0x80);
 
 	if ((getState(obj) & type) == 0)
@@ -583,7 +583,7 @@
 		ignoreScriptWord();
 }
 
-void Scumm_v2::ifNotStateCommon(byte type) {
+void ScummEngine_v2::ifNotStateCommon(byte type) {
 	int obj = getVarOrDirectWord(0x80);
 
 	if ((getState(obj) & type) != 0)
@@ -592,67 +592,67 @@
 		ignoreScriptWord();
 }
 
-void Scumm_v2::o2_ifState08() {
+void ScummEngine_v2::o2_ifState08() {
 	ifStateCommon(0x08);
 }
 
-void Scumm_v2::o2_ifNotState08() {
+void ScummEngine_v2::o2_ifNotState08() {
 	ifNotStateCommon(0x08);
 }
 
-void Scumm_v2::o2_ifState04() {
+void ScummEngine_v2::o2_ifState04() {
 	ifStateCommon(0x04);
 }
 
-void Scumm_v2::o2_ifNotState04() {
+void ScummEngine_v2::o2_ifNotState04() {
 	ifNotStateCommon(0x04);
 }
 
-void Scumm_v2::o2_ifState02() {
+void ScummEngine_v2::o2_ifState02() {
 	ifStateCommon(0x02);
 }
 
-void Scumm_v2::o2_ifNotState02() {
+void ScummEngine_v2::o2_ifNotState02() {
 	ifNotStateCommon(0x02);
 }
 
-void Scumm_v2::o2_ifState01() {
+void ScummEngine_v2::o2_ifState01() {
 	ifStateCommon(0x01);
 }
 
-void Scumm_v2::o2_ifNotState01() {
+void ScummEngine_v2::o2_ifNotState01() {
 	ifNotStateCommon(0x01);
 }
 
-void Scumm_v2::o2_addIndirect() {
+void ScummEngine_v2::o2_addIndirect() {
 	int a;
 	getResultPosIndirect();
 	a = getVarOrDirectWord(0x80);
 	_scummVars[_resultVarNumber] += a;
 }
 
-void Scumm_v2::o2_subIndirect() {
+void ScummEngine_v2::o2_subIndirect() {
 	int a;
 	getResultPosIndirect();
 	a = getVarOrDirectWord(0x80);
 	_scummVars[_resultVarNumber] -= a;
 }
 
-void Scumm_v2::o2_add() {
+void ScummEngine_v2::o2_add() {
 	int a;
 	getResultPos();
 	a = getVarOrDirectWord(0x80);
 	_scummVars[_resultVarNumber] += a;
 }
 
-void Scumm_v2::o2_subtract() {
+void ScummEngine_v2::o2_subtract() {
 	int a;
 	getResultPos();
 	a = getVarOrDirectWord(0x80);
 	_scummVars[_resultVarNumber] -= a;
 }
 
-void Scumm_v2::o2_waitForActor() {
+void ScummEngine_v2::o2_waitForActor() {
 	Actor *a = derefActor(getVarOrDirectByte(0x80), "o2_waitForActor");
 	if (a->moving) {
 		_scriptPointer -= 2;
@@ -660,7 +660,7 @@
 	}
 }
 
-void Scumm_v2::o2_waitForMessage() {
+void ScummEngine_v2::o2_waitForMessage() {
 	
 	if (VAR(VAR_HAVE_MSG)) {
 		_scriptPointer--;
@@ -668,7 +668,7 @@
 	}
 }
 
-void Scumm_v2::o2_waitForSentence() {
+void ScummEngine_v2::o2_waitForSentence() {
 	if (!_sentenceNum && !isScriptInUse(SENTENCE_SCRIPT))
 		return;
 
@@ -676,7 +676,7 @@
 	o5_breakHere();
 }
 
-void Scumm_v2::o2_actorSet() {
+void ScummEngine_v2::o2_actorSet() {
 	int act = getVarOrDirectByte(0x80);
 	int arg = getVarOrDirectByte(0x40);
 	Actor *a;
@@ -721,11 +721,11 @@
 	}
 }
 
-void Scumm_v2::o2_restart() {
+void ScummEngine_v2::o2_restart() {
 	restart();
 }
 
-void Scumm_v2::o2_drawObject() {
+void ScummEngine_v2::o2_drawObject() {
 	int obj, idx, i;
 	ObjectData *od;
 	uint16 x, y, w, h;
@@ -762,7 +762,7 @@
 	putState(obj, getState(od->obj_nr) | 0x08);
 }
 
-void Scumm_v2::o2_resourceRoutines() {
+void ScummEngine_v2::o2_resourceRoutines() {
 	const ResTypes resTypes[] = {
 			rtNumTypes,	// Invalid
 			rtNumTypes,	// Invalid
@@ -792,7 +792,7 @@
 	}
 }
 
-void Scumm_v2::o2_verbOps() {
+void ScummEngine_v2::o2_verbOps() {
 	int verb = fetchScriptByte();
 	int slot, state;
 	
@@ -880,7 +880,7 @@
 	verbMouseOver(0);
 }
 
-void Scumm_v2::o2_doSentence() {
+void ScummEngine_v2::o2_doSentence() {
 	int a;
 	SentenceTab *st;
 
@@ -914,7 +914,7 @@
 		_sentenceNum--;
 		
 		if (st->verb == 254) {
-			Scumm::stopObjectScript(st->objectA);
+			ScummEngine::stopObjectScript(st->objectA);
 		} else {
 			bool isBackgroundScript;
 			bool isSpecialVerb;
@@ -970,7 +970,7 @@
 	}
 }
 
-void Scumm_v2::o2_drawSentence() {
+void ScummEngine_v2::o2_drawSentence() {
 	Common::Rect sentenceline;
 	static char sentence[256];
 	const byte *temp;
@@ -1065,7 +1065,7 @@
 	drawString(2);
 }
 
-void Scumm_v2::o2_ifClassOfIs() {
+void ScummEngine_v2::o2_ifClassOfIs() {
 	int obj = getVarOrDirectWord(0x80);
 	int clsop = getVarOrDirectByte(0x40);
 	byte *obcd = getOBCDFromObject(obj);
@@ -1083,7 +1083,7 @@
 	ignoreScriptWord();
 }
 
-void Scumm_v2::o2_walkActorTo() {
+void ScummEngine_v2::o2_walkActorTo() {
 	int x, y;
 	Actor *a;
 	a = derefActor(getVarOrDirectByte(0x80), "o2_walkActorTo");
@@ -1094,7 +1094,7 @@
 	a->startWalkActor(x, y, -1);
 }
 
-void Scumm_v2::o2_putActor() {
+void ScummEngine_v2::o2_putActor() {
 	int act = getVarOrDirectByte(0x80);
 	int x, y;
 	Actor *a;
@@ -1107,16 +1107,16 @@
 	a->putActor(x, y, a->room);
 }
 
-void Scumm_v2::o2_startScript() {
+void ScummEngine_v2::o2_startScript() {
 	int script = getVarOrDirectByte(0x80);
 	runScript(script, 0, 0, 0);
 }
 
-void Scumm_v2::o2_panCameraTo() {
+void ScummEngine_v2::o2_panCameraTo() {
 	panCameraTo(getVarOrDirectByte(0x80) * 8, 0);
 }
 
-void Scumm_v2::o2_walkActorToObject() {
+void ScummEngine_v2::o2_walkActorToObject() {
 	int obj;
 	Actor *a;
 
@@ -1129,7 +1129,7 @@
 	}
 }
 
-void Scumm_v2::o2_putActorAtObject() {
+void ScummEngine_v2::o2_putActorAtObject() {
 	int obj, x, y;
 	Actor *a;
 
@@ -1146,14 +1146,14 @@
 	a->putActor(x, y, a->room);
 }
 
-void Scumm_v2::o2_getActorElevation() {
+void ScummEngine_v2::o2_getActorElevation() {
 	getResultPos();
 	int act = getVarOrDirectByte(0x80);
 	Actor *a = derefActor(act, "o2_getActorElevation");
 	setResult(a->elevation / 2);
 }
 
-void Scumm_v2::o2_setActorElevation() {
+void ScummEngine_v2::o2_setActorElevation() {
 	int act = getVarOrDirectByte(0x80);
 	int elevation = (int8)getVarOrDirectByte(0x40);
 
@@ -1161,7 +1161,7 @@
 	a->elevation = elevation * 2;
 }
 
-void Scumm_v2::o2_animateActor() {
+void ScummEngine_v2::o2_animateActor() {
 	int act = getVarOrDirectByte(0x80);
 	int anim = getVarOrDirectByte(0x40);
 
@@ -1169,7 +1169,7 @@
 	a->animateActor(anim);
 }
 
-void Scumm_v2::o2_actorFromPos() {
+void ScummEngine_v2::o2_actorFromPos() {
 	int x, y;
 	getResultPos();
 	x = getVarOrDirectByte(0x80) * 8;
@@ -1177,14 +1177,14 @@
 	setResult(getActorFromPos(x, y));
 }
 
-void Scumm_v2::o2_findObject() {
+void ScummEngine_v2::o2_findObject() {
 	getResultPos();
 	int x = getVarOrDirectByte(0x80) * 8;
 	int y = getVarOrDirectByte(0x40) * 2;
 	setResult(findObject(x, y));
 }
 
-void Scumm_v2::o2_getActorX() {
+void ScummEngine_v2::o2_getActorX() {
 	int a;
 	getResultPos();
 
@@ -1192,7 +1192,7 @@
 	setResult(getObjX(a) / 8);
 }
 
-void Scumm_v2::o2_getActorY() {
+void ScummEngine_v2::o2_getActorY() {
 	int a;
 	getResultPos();
 
@@ -1200,7 +1200,7 @@
 	setResult(getObjY(a) / 2);
 }
 
-void Scumm_v2::o2_isGreater() {
+void ScummEngine_v2::o2_isGreater() {
 	uint16 a = getVar();
 	uint16 b = getVarOrDirectWord(0x80);
 	if (b > a)
@@ -1209,7 +1209,7 @@
 		o5_jumpRelative();
 }
 
-void Scumm_v2::o2_isGreaterEqual() {
+void ScummEngine_v2::o2_isGreaterEqual() {
 	uint16 a = getVar();
 	uint16 b = getVarOrDirectWord(0x80);
 	if (b >= a)
@@ -1218,7 +1218,7 @@
 		o5_jumpRelative();
 }
 
-void Scumm_v2::o2_isLess() {
+void ScummEngine_v2::o2_isLess() {
 	uint16 a = getVar();
 	uint16 b = getVarOrDirectWord(0x80);
 
@@ -1228,7 +1228,7 @@
 		o5_jumpRelative();
 }
 
-void Scumm_v2::o2_isLessEqual() {
+void ScummEngine_v2::o2_isLessEqual() {
 	uint16 a = getVar();
 	uint16 b = getVarOrDirectWord(0x80);
 	if (b <= a)
@@ -1237,7 +1237,7 @@
 		o5_jumpRelative();
 }
 
-void Scumm_v2::o2_lights() {
+void ScummEngine_v2::o2_lights() {
 	int a, b, c;
 
 	a = getVarOrDirectByte(0x80);
@@ -1266,7 +1266,7 @@
 	_fullRedraw = 1;
 }
 
-void Scumm_v2::o2_loadRoomWithEgo() {
+void ScummEngine_v2::o2_loadRoomWithEgo() {
 	Actor *a;
 	int obj, room, x, y, x2, y2, dir;
 
@@ -1301,7 +1301,7 @@
 	runScript(5, 0, 0, 0);
 }
 
-void Scumm_v2::o2_setOwnerOf() {
+void ScummEngine_v2::o2_setOwnerOf() {
 	int obj, owner;
 
 	obj = getVarOrDirectWord(0x80);
@@ -1310,7 +1310,7 @@
 	setOwnerOf(obj, owner);
 }
 
-void Scumm_v2::o2_delay() {
+void ScummEngine_v2::o2_delay() {
 	int delay = fetchScriptByte();
 	delay |= fetchScriptByte() << 8;
 	delay |= fetchScriptByte() << 16;
@@ -1321,7 +1321,7 @@
 	o5_breakHere();
 }
 
-void Scumm_v2::o2_setBoxFlags() {
+void ScummEngine_v2::o2_setBoxFlags() {
 	int a, b;
 
 	a = getVarOrDirectByte(0x80);
@@ -1329,11 +1329,11 @@
 	setBoxFlags(a, b);
 }
 
-void Scumm_v2::o2_setCameraAt() {
+void ScummEngine_v2::o2_setCameraAt() {
 	setCameraAtEx(getVarOrDirectByte(0x80) * 8);
 }
 
-void Scumm_v2::o2_roomOps() {
+void ScummEngine_v2::o2_roomOps() {
 	int a = getVarOrDirectByte(0x80);
 	int b = getVarOrDirectByte(0x40);
 
@@ -1367,7 +1367,7 @@
 	}
 }
 
-void Scumm_v2::o2_cutscene() {
+void ScummEngine_v2::o2_cutscene() {
 	//warning("TODO o2_cutscene()");
 
 	vm.cutSceneData[0] = _userState | (_userPut ? 16 : 0);
@@ -1391,7 +1391,7 @@
 	vm.cutScenePtr[0] = 0;
 }
 
-void Scumm_v2::o2_endCutscene() {
+void ScummEngine_v2::o2_endCutscene() {
 	//warning("TODO o2_endCutscene()");
 
 	vm.cutSceneStackPointer = 0;
@@ -1417,7 +1417,7 @@
 	}
 }
 
-void Scumm_v2::o2_beginOverride() {
+void ScummEngine_v2::o2_beginOverride() {
 	vm.cutScenePtr[0] = _scriptPointer - _scriptOrgPointer;
 	vm.cutSceneScript[0] = _currentScript;
 
@@ -1426,14 +1426,14 @@
 	fetchScriptWord();
 }
 
-void Scumm_v2::o2_chainScript() {
+void ScummEngine_v2::o2_chainScript() {
 	int data = getVarOrDirectByte(0x80);
 	stopScript(vm.slot[_currentScript].number);
 	_currentScript = 0xFF;
 	runScript(data, 0, 0, 0);
 }
 
-void Scumm_v2::o2_pickupObject() {
+void ScummEngine_v2::o2_pickupObject() {
 	int obj = getVarOrDirectWord(0x80);
 
 	if (obj < 1) {
@@ -1455,7 +1455,7 @@
 	runInventoryScript(1);
 }
 
-void Scumm_v2::o2_setObjectName() {
+void ScummEngine_v2::o2_setObjectName() {
 	int obj = getVarOrDirectWord(0x80);
 	int size = 0;
 	int a;
@@ -1503,7 +1503,7 @@
 	runInventoryScript(0);
 }
 
-void Scumm_v2::o2_cursorCommand() {	// TODO: Define the magic numbers
+void ScummEngine_v2::o2_cursorCommand() {	// TODO: Define the magic numbers
 	uint16 cmd = getVarOrDirectWord(0x80);
 	byte state = cmd >> 8;
 
@@ -1514,7 +1514,7 @@
 	setUserState(state);
 }
 
-void Scumm_v2::setUserState(byte state) {
+void ScummEngine_v2::setUserState(byte state) {
 	if (state & 4) {						// Userface
 		_userState = state & (32 | 64 | 128);
 	}
@@ -1549,20 +1549,20 @@
 	runInventoryScript(1);
 }
 
-void Scumm_v2::o2_getActorWalkBox() {
+void ScummEngine_v2::o2_getActorWalkBox() {
 	Actor *a;
 	getResultPos();
 	a = derefActor(getVarOrDirectByte(0x80), "o2_getActorWalkbox");
 	setResult(a->walkbox);
 }
 
-void Scumm_v2::o2_dummy() {
+void ScummEngine_v2::o2_dummy() {
 	// Opcode 238 is used in Zak but has no purpose
 	if (!(_gameId == GID_ZAK && _opcode == 238))
 		warning("o2_dummy invoked (opcode %d)", _opcode);
 }
 
-void Scumm_v2::o2_switchCostumeSet() {
+void ScummEngine_v2::o2_switchCostumeSet() {
 	// NES version of maniac uses this to switch between the two
 	// groups of costumes it has
 	if (_features & GF_NES) {
@@ -1572,7 +1572,7 @@
 		o2_dummy();
 }
 
-void Scumm_v2::resetSentence() {
+void ScummEngine_v2::resetSentence() {
 	VAR(VAR_SENTENCE_VERB) = VAR(VAR_BACKUP_VERB);
 	VAR(VAR_SENTENCE_OBJECT1) = 0;
 	VAR(VAR_SENTENCE_OBJECT2) = 0;

Index: script_v5.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/script_v5.cpp,v
retrieving revision 1.194
retrieving revision 1.195
diff -u -d -r1.194 -r1.195
--- script_v5.cpp	2 Oct 2003 17:43:02 -0000	1.194
+++ script_v5.cpp	2 Oct 2003 22:42:02 -0000	1.195
@@ -29,9 +29,9 @@
 #include "scumm/sound.h"
 #include "scumm/verbs.h"
 
-#define OPCODE(x)	{ &Scumm_v5::x, #x }
+#define OPCODE(x)	{ &ScummEngine_v5::x, #x }
 
-void Scumm_v5::setupOpcodes() {
+void ScummEngine_v5::setupOpcodes() {
 	static const OpcodeEntryV5 opcodes[256] = {
 		/* 00 */
 		OPCODE(o5_stopObjectCode),
@@ -358,36 +358,36 @@
 	_opcodesV5 = opcodes;
 }
 
-void Scumm_v5::executeOpcode(byte i) {
+void ScummEngine_v5::executeOpcode(byte i) {
 	OpcodeProcV5 op = _opcodesV5[i].proc;
 	(this->*op) ();
 }
 
-const char *Scumm_v5::getOpcodeDesc(byte i) {
+const char *ScummEngine_v5::getOpcodeDesc(byte i) {
 	return _opcodesV5[i].desc;
 }
 
-int Scumm_v5::getVar() {
+int ScummEngine_v5::getVar() {
 	return readVar(fetchScriptWord());
 }
 
-int Scumm_v5::getVarOrDirectByte(byte mask) {
+int ScummEngine_v5::getVarOrDirectByte(byte mask) {
 	if (_opcode & mask)
 		return getVar();
 	return fetchScriptByte();
 }
 
-int Scumm_v5::getVarOrDirectWord(byte mask) {
+int ScummEngine_v5::getVarOrDirectWord(byte mask) {
 	if (_opcode & mask)
 		return getVar();
 	return (int16)fetchScriptWord();
 }
 
-void Scumm_v5::o5_actorFollowCamera() {
+void ScummEngine_v5::o5_actorFollowCamera() {
 	actorFollowCamera(getVarOrDirectByte(0x80));
 }
 
-void Scumm_v5::o5_actorFromPos() {
+void ScummEngine_v5::o5_actorFromPos() {
 	int x, y;
 	getResultPos();
 	x = getVarOrDirectWord(0x80);
@@ -395,7 +395,7 @@
 	setResult(getActorFromPos(x, y));
 }
 
-void Scumm_v5::o5_actorSet() {
+void ScummEngine_v5::o5_actorSet() {
 	static const byte convertTable[20] =
 		{ 1, 0, 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 20 };
 	int act = getVarOrDirectByte(0x80);
@@ -527,7 +527,7 @@
 	}
 }
 
-void Scumm_v5::o5_setClass() {
+void ScummEngine_v5::o5_setClass() {
 	int obj = getVarOrDirectWord(0x80);
 	int newClass;
 
@@ -546,7 +546,7 @@
 	}
 }
 
-void Scumm_v5::o5_add() {
+void ScummEngine_v5::o5_add() {
 	int a;
 	getResultPos();
 	a = getVarOrDirectWord(0x80);
@@ -583,26 +583,26 @@
 	setResult(readVar(_resultVarNumber) + a);
 }
 
-void Scumm_v5::o5_and() {
+void ScummEngine_v5::o5_and() {
 	int a;
 	getResultPos();
 	a = getVarOrDirectWord(0x80);
 	setResult(readVar(_resultVarNumber) & a);
 }
 
-void Scumm_v5::o5_animateActor() {
+void ScummEngine_v5::o5_animateActor() {
 	int act = getVarOrDirectByte(0x80);
 	int anim = getVarOrDirectByte(0x40);
 	Actor *a = derefActor(act, "o5_animateActor");
 	a->animateActor(anim);
 }
 
-void Scumm_v5::o5_breakHere() {
+void ScummEngine_v5::o5_breakHere() {
 	updateScriptPtr();
 	_currentScript = 0xFF;
 }
 
-void Scumm_v5::o5_chainScript() {
+void ScummEngine_v5::o5_chainScript() {
 	int vars[16];
 	int script;
 	int cur;
@@ -630,7 +630,7 @@
 	runScript(script, vm.slot[cur].freezeResistant, vm.slot[cur].recursive, vars);
 }
 
-void Scumm_v5::o5_cursorCommand() {
+void ScummEngine_v5::o5_cursorCommand() {
 	int i, j, k;
 	int table[16];
 	switch ((_opcode = fetchScriptByte()) & 0x1F) {
@@ -707,27 +707,27 @@
 	}
 }
 
-void Scumm_v5::o5_cutscene() {
+void ScummEngine_v5::o5_cutscene() {
 	int args[16];
 	getWordVararg(args);
 	beginCutscene(args);
 }
 
-void Scumm_v5::o5_endCutscene() {
+void ScummEngine_v5::o5_endCutscene() {
 	endCutscene();
 }
 
-void Scumm_v5::o5_debug() {
+void ScummEngine_v5::o5_debug() {
 	int a = getVarOrDirectWord(0x80);
 	debug(1, "o5_debug(%d)", a);
 }
 
-void Scumm_v5::o5_decrement() {
+void ScummEngine_v5::o5_decrement() {
 	getResultPos();
 	setResult(readVar(_resultVarNumber) - 1);
 }
 
-void Scumm_v5::o5_delay() {
+void ScummEngine_v5::o5_delay() {
 	int delay = fetchScriptByte();
 	delay |= fetchScriptByte() << 8;
 	delay |= fetchScriptByte() << 16;
@@ -736,13 +736,13 @@
 	o5_breakHere();
 }
 
-void Scumm_v5::o5_delayVariable() {
+void ScummEngine_v5::o5_delayVariable() {
 	vm.slot[_currentScript].delay = getVar();
 	vm.slot[_currentScript].status = ssPaused;
 	o5_breakHere();
 }
 
-void Scumm_v5::o5_divide() {
+void ScummEngine_v5::o5_divide() {
 	int a;
 	getResultPos();
 	a = getVarOrDirectWord(0x80);
@@ -753,7 +753,7 @@
 		setResult(readVar(_resultVarNumber) / a);
 }
 
-void Scumm_v5::o5_doSentence() {
+void ScummEngine_v5::o5_doSentence() {
 	int verb;
 	SentenceTab *st;
 
@@ -774,7 +774,7 @@
 	st->freezeCount = 0;
 }
 
-void Scumm_v5::o5_drawBox() {
+void ScummEngine_v5::o5_drawBox() {
 	int x, y, x2, y2, color;
 
 	x = getVarOrDirectWord(0x80);
@@ -788,7 +788,7 @@
 	drawBox(x, y, x2, y2, color);
 }
 
-void Scumm_v5::o5_drawObject() {
+void ScummEngine_v5::o5_drawObject() {
 	int state, obj, idx, i;
 	ObjectData *od;
 	uint16 x, y, w, h;
@@ -845,7 +845,7 @@
 	putState(obj, state);
 }
 
-void Scumm_v5::o5_getStringWidth() {
+void ScummEngine_v5::o5_getStringWidth() {
 	// TODO - not sure if this is correct... needs testing
 	int string, width = 0;
 	byte *ptr;
@@ -861,7 +861,7 @@
 	warning("o5_getStringWidth, result %d", width);
 }
 
-void Scumm_v5::o5_saveLoadVars() {
+void ScummEngine_v5::o5_saveLoadVars() {
 	// TODO
 	if (fetchScriptByte() == 1) 
 		saveVars();
@@ -869,7 +869,7 @@
 		loadVars();
 }
 
-void Scumm_v5::saveVars() {
+void ScummEngine_v5::saveVars() {
 	int a, b;
 
 	while ((_opcode = fetchScriptByte()) != 0) {
@@ -902,7 +902,7 @@
 	}
 }
 
-void Scumm_v5::loadVars() {
+void ScummEngine_v5::loadVars() {
 	int a, b;
 
 	hexdump(_scriptPointer, 64);
@@ -936,7 +936,7 @@
 	}
 }
 
-void Scumm_v5::o5_expression() {
+void ScummEngine_v5::o5_expression() {
 	int dst, i;
 
 	_scummStackPos = 0;
@@ -978,28 +978,28 @@
 	setResult(pop());
 }
 
-void Scumm_v5::o5_faceActor() {
+void ScummEngine_v5::o5_faceActor() {
 	int act = getVarOrDirectByte(0x80);
 	int obj = getVarOrDirectWord(0x40);
 	Actor *a = derefActor(act, "o5_faceActor");
 	a->faceToObject(obj);
 }
 
-void Scumm_v5::o5_findInventory() {
+void ScummEngine_v5::o5_findInventory() {
 	getResultPos();
 	int x = getVarOrDirectByte(0x80);
 	int y = getVarOrDirectByte(0x40);
 	setResult(findInventory(x, y));
 }
 
-void Scumm_v5::o5_findObject() {
+void ScummEngine_v5::o5_findObject() {
 	getResultPos();
 	int x = getVarOrDirectByte(0x80);
 	int y = getVarOrDirectByte(0x40);
 	setResult(findObject(x, y));
 }
 
-void Scumm_v5::o5_freezeScripts() {
+void ScummEngine_v5::o5_freezeScripts() {
 	int scr = getVarOrDirectByte(0x80);
 
 	if (scr != 0)
@@ -1008,35 +1008,35 @@
 		unfreezeScripts();
 }
 
-void Scumm_v5::o5_getActorCostume() {
+void ScummEngine_v5::o5_getActorCostume() {
 	getResultPos();
 	int act = getVarOrDirectByte(0x80);
 	Actor *a = derefActor(act, "o5_getActorCostume");
 	setResult(a->costume);
 }
 
-void Scumm_v5::o5_getActorElevation() {
+void ScummEngine_v5::o5_getActorElevation() {
 	getResultPos();
 	int act = getVarOrDirectByte(0x80);
 	Actor *a = derefActor(act, "o5_getActorElevation");
 	setResult(a->elevation);
 }
 
-void Scumm_v5::o5_getActorFacing() {
+void ScummEngine_v5::o5_getActorFacing() {
 	getResultPos();
 	int act = getVarOrDirectByte(0x80);
 	Actor *a = derefActor(act, "o5_getActorFacing");
 	setResult(newDirToOldDir(a->getFacing()));
 }
 
-void Scumm_v5::o5_getActorMoving() {
+void ScummEngine_v5::o5_getActorMoving() {
 	getResultPos();
 	int act = getVarOrDirectByte(0x80);
 	Actor *a = derefActor(act, "o5_getActorMoving");
 	setResult(a->moving);
 }
 
-void Scumm_v5::o5_getActorRoom() {
+void ScummEngine_v5::o5_getActorRoom() {
 	getResultPos();
 	int act = getVarOrDirectByte(0x80);
 	// WORKAROUND bug #746349. This is a really odd bug in either the script
@@ -1051,7 +1051,7 @@
 	setResult(a->room);
 }
 
-void Scumm_v5::o5_getActorScale() {
+void ScummEngine_v5::o5_getActorScale() {
 	Actor *a;
 	
 	// dummy opcode in the loom
@@ -1075,21 +1075,21 @@
 	setResult(a->scalex);
 }
 
-void Scumm_v5::o5_getActorWalkBox() {
+void ScummEngine_v5::o5_getActorWalkBox() {
 	getResultPos();
 	int act = getVarOrDirectByte(0x80);
 	Actor *a = derefActor(act, "o5_getActorWalkBox");
 	setResult(a->walkbox);
 }
 
-void Scumm_v5::o5_getActorWidth() {
+void ScummEngine_v5::o5_getActorWidth() {
 	getResultPos();
 	int act = getVarOrDirectByte(0x80);
 	Actor *a = derefActor(act, "o5_getActorWidth");
 	setResult(a->width);
 }
 
-void Scumm_v5::o5_getActorX() {
+void ScummEngine_v5::o5_getActorX() {
 	int a;
 	getResultPos();
 
@@ -1101,7 +1101,7 @@
 	setResult(getObjX(a));
 }
 
-void Scumm_v5::o5_getActorY() {
+void ScummEngine_v5::o5_getActorY() {
 	int a;
 	getResultPos();
 
@@ -1119,7 +1119,7 @@
 	setResult(getObjY(a));
 }
 
-void Scumm_v5::o5_saveLoadGame() {
+void ScummEngine_v5::o5_saveLoadGame() {
 	getResultPos();
 	byte a = getVarOrDirectByte(0x80);
 	byte slot = (a & 0x1F) + 1;
@@ -1173,7 +1173,7 @@
 	setResult(result);
 }
 		
-void Scumm_v5::o5_getAnimCounter() {
+void ScummEngine_v5::o5_getAnimCounter() {
 	if (_version == 3) {
 		o5_saveLoadGame();
 		return;
@@ -1186,7 +1186,7 @@
 	setResult(a->cost.animCounter);
 }
 
-void Scumm_v5::o5_getClosestObjActor() {
+void ScummEngine_v5::o5_getClosestObjActor() {
 	int obj;
 	int act;
 	int dist;
@@ -1217,7 +1217,7 @@
 	setResult(closest_obj);
 }
 
-void Scumm_v5::o5_getDist() {
+void ScummEngine_v5::o5_getDist() {
 	int o1, o2;
 	int r;
 	getResultPos();
@@ -1232,17 +1232,17 @@
 	setResult(r);
 }
 
-void Scumm_v5::o5_getInventoryCount() {
+void ScummEngine_v5::o5_getInventoryCount() {
 	getResultPos();
 	setResult(getInventoryCount(getVarOrDirectByte(0x80)));
 }
 
-void Scumm_v5::o5_getObjectOwner() {
+void ScummEngine_v5::o5_getObjectOwner() {
 	getResultPos();
 	setResult(getOwner(getVarOrDirectWord(0x80)));
 }
 
-void Scumm_v5::o5_getObjectState() {
+void ScummEngine_v5::o5_getObjectState() {
 	if (_features & GF_SMALL_HEADER) {
 		o5_ifState();
 	} else {
@@ -1251,7 +1251,7 @@
 	}
 }
 
-void Scumm_v5::o5_ifState() {
+void ScummEngine_v5::o5_ifState() {
 	int a = getVarOrDirectWord(0x80);
 	int b = getVarOrDirectByte(0x40);
 
@@ -1261,7 +1261,7 @@
 		ignoreScriptWord();
 }
 
-void Scumm_v5::o5_ifNotState() {
+void ScummEngine_v5::o5_ifNotState() {
 	int a = getVarOrDirectWord(0x80);
 	int b = getVarOrDirectByte(0x40);
 
@@ -1271,17 +1271,17 @@
 		ignoreScriptWord();
 }
 
-void Scumm_v5::o5_getRandomNr() {
+void ScummEngine_v5::o5_getRandomNr() {
 	getResultPos();
 	setResult(_rnd.getRandomNumber(getVarOrDirectByte(0x80)));
 }
 
-void Scumm_v5::o5_isScriptRunning() {
+void ScummEngine_v5::o5_isScriptRunning() {
 	getResultPos();
 	setResult(isScriptRunning(getVarOrDirectByte(0x80)));
 }
 
-void Scumm_v5::o5_getVerbEntrypoint() {
+void ScummEngine_v5::o5_getVerbEntrypoint() {
 	int a, b;
 	getResultPos();
 	a = getVarOrDirectWord(0x80);
@@ -1290,7 +1290,7 @@
 	setResult(getVerbEntrypoint(a, b));
 }
 
-void Scumm_v5::o5_ifClassOfIs() {
+void ScummEngine_v5::o5_ifClassOfIs() {
 	int act, cls, b = 0;
 	bool cond = true;
 
@@ -1313,12 +1313,12 @@
 		o5_jumpRelative();
 }
 
-void Scumm_v5::o5_increment() {
+void ScummEngine_v5::o5_increment() {
 	getResultPos();
 	setResult(readVar(_resultVarNumber) + 1);
 }
 
-void Scumm_v5::o5_isActorInBox() {
+void ScummEngine_v5::o5_isActorInBox() {
 	int act = getVarOrDirectByte(0x80);
 	int box = getVarOrDirectByte(0x40);
 	Actor *a = derefActor(act, "o5_isActorInBox");
@@ -1329,7 +1329,7 @@
 		ignoreScriptWord();
 }
 
-void Scumm_v5::o5_isEqual() {
+void ScummEngine_v5::o5_isEqual() {
 	int16 a, b;
 	int var;
 
@@ -1355,7 +1355,7 @@
 
 }
 
-void Scumm_v5::o5_isGreater() {
+void ScummEngine_v5::o5_isGreater() {
 	int16 a = getVar();
 	int16 b = getVarOrDirectWord(0x80);
 	if (b > a)
@@ -1364,7 +1364,7 @@
 		o5_jumpRelative();
 }
 
-void Scumm_v5::o5_isGreaterEqual() {
+void ScummEngine_v5::o5_isGreaterEqual() {
 	int16 a = getVar();
 	int16 b = getVarOrDirectWord(0x80);
 	if (b >= a)
@@ -1373,7 +1373,7 @@
 		o5_jumpRelative();
 }
 
-void Scumm_v5::o5_isLess() {
+void ScummEngine_v5::o5_isLess() {
 	int16 a = getVar();
 	int16 b = getVarOrDirectWord(0x80);
 
@@ -1383,7 +1383,7 @@
 		o5_jumpRelative();
 }
 
-void Scumm_v5::o5_lessOrEqual() {
+void ScummEngine_v5::o5_lessOrEqual() {
 	int16 a = getVar();
 	int16 b = getVarOrDirectWord(0x80);
 	if (b <= a)
@@ -1392,7 +1392,7 @@
 		o5_jumpRelative();
 }
 
-void Scumm_v5::o5_isNotEqual() {
+void ScummEngine_v5::o5_isNotEqual() {
 	int16 a = getVar();
 	int16 b = getVarOrDirectWord(0x80);
 	if (b != a)
@@ -1401,7 +1401,7 @@
 		o5_jumpRelative();
 }
 
-void Scumm_v5::o5_notEqualZero() {
+void ScummEngine_v5::o5_notEqualZero() {
 	int a = getVar();
 	if (a != 0)
 		ignoreScriptWord();
@@ -1409,7 +1409,7 @@
 		o5_jumpRelative();
 }
 
-void Scumm_v5::o5_equalZero() {
+void ScummEngine_v5::o5_equalZero() {
 	int a = getVar();
 	if (a == 0)
 		ignoreScriptWord();
@@ -1417,11 +1417,11 @@
 		o5_jumpRelative();
 }
 
-void Scumm_v5::o5_jumpRelative() {
+void ScummEngine_v5::o5_jumpRelative() {
 	_scriptPointer += (int16)fetchScriptWord();
 }
 
-void Scumm_v5::o5_lights() {
+void ScummEngine_v5::o5_lights() {
 	int a, b, c;
 
 	a = getVarOrDirectByte(0x80);
@@ -1437,7 +1437,7 @@
 	_fullRedraw = 1;
 }
 
-void Scumm_v5::o5_loadRoom() {
+void ScummEngine_v5::o5_loadRoom() {
 	int room;
 
 	room = getVarOrDirectByte(0x80);
@@ -1451,7 +1451,7 @@
 	_fullRedraw = 1;
 }
 
-void Scumm_v5::o5_loadRoomWithEgo() {
+void ScummEngine_v5::o5_loadRoomWithEgo() {
 	Actor *a;
 	int obj, room, x, y;
 	int x2, y2, dir, oldDir;
@@ -1497,7 +1497,7 @@
 	}
 }
 
-void Scumm_v5::o5_matrixOps() {
+void ScummEngine_v5::o5_matrixOps() {
 	int a, b;
 
 	if (_version == 3) {
@@ -1530,37 +1530,37 @@
 	}
 }
 
-void Scumm_v5::o5_move() {
+void ScummEngine_v5::o5_move() {
 	getResultPos();
 	setResult(getVarOrDirectWord(0x80));
 }
 
-void Scumm_v5::o5_multiply() {
+void ScummEngine_v5::o5_multiply() {
 	int a;
 	getResultPos();
 	a = getVarOrDirectWord(0x80);
 	setResult(readVar(_resultVarNumber) * a);
 }
 
-void Scumm_v5::o5_or() {
+void ScummEngine_v5::o5_or() {
 	int a;
 	getResultPos();
 	a = getVarOrDirectWord(0x80);
 	setResult(readVar(_resultVarNumber) | a);
 }
 
-void Scumm_v5::o5_beginOverride() {
+void ScummEngine_v5::o5_beginOverride() {
 	if (fetchScriptByte() != 0)
 		beginOverride();
 	else
 		endOverride();
 }
 
-void Scumm_v5::o5_panCameraTo() {
+void ScummEngine_v5::o5_panCameraTo() {
 	panCameraTo(getVarOrDirectWord(0x80), 0);
 }
 
-void Scumm_v5::o5_pickupObject() {
+void ScummEngine_v5::o5_pickupObject() {
 	int obj, room;
 	if (_version == 3 || _version == 4) {
 		o5_drawObject();
@@ -1580,17 +1580,17 @@
 	runInventoryScript(1);
 }
 
-void Scumm_v5::o5_print() {
+void ScummEngine_v5::o5_print() {
 	_actorToPrintStrFor = getVarOrDirectByte(0x80);
 	decodeParseString();
 }
 
-void Scumm_v5::o5_printEgo() {
+void ScummEngine_v5::o5_printEgo() {
 	_actorToPrintStrFor = (byte)VAR(VAR_EGO);
 	decodeParseString();
 }
 
-void Scumm_v5::o5_pseudoRoom() {
+void ScummEngine_v5::o5_pseudoRoom() {
 	int i = fetchScriptByte(), j;
 	while ((j = fetchScriptByte()) != 0) {
 		if (j >= 0x80) {
@@ -1599,7 +1599,7 @@
 	}
 }
 
-void Scumm_v5::o5_putActor() {
+void ScummEngine_v5::o5_putActor() {
 	int x, y;
 	Actor *a;
 
@@ -1609,7 +1609,7 @@
 	a->putActor(x, y, a->room);
 }
 
-void Scumm_v5::o5_putActorAtObject() {
+void ScummEngine_v5::o5_putActorAtObject() {
 	int obj, x, y;
 	Actor *a;
 
@@ -1624,7 +1624,7 @@
 	a->putActor(x, y, a->room);
 }
 
-void Scumm_v5::o5_putActorInRoom() {
+void ScummEngine_v5::o5_putActorInRoom() {
 	Actor *a;
 	int act = getVarOrDirectByte(0x80);
 	int room = getVarOrDirectByte(0x40);
@@ -1655,7 +1655,7 @@
 		a->putActor(0, 0, 0);
 }
 
-void Scumm_v5::o5_quitPauseRestart() {
+void ScummEngine_v5::o5_quitPauseRestart() {
 	byte subOp = fetchScriptByte();
 	switch (subOp) {
 	case 1:		// Restart
@@ -1672,7 +1672,7 @@
 	}
 }
 
-void Scumm_v5::o5_resourceRoutines() {
+void ScummEngine_v5::o5_resourceRoutines() {
 	const ResTypes resType[4] = { rtScript, rtSound, rtCostume, rtRoom };
 	int resid = 0;
 	int foo, bar;
@@ -1799,7 +1799,7 @@
 	}
 }
 
-void Scumm_v5::o5_roomOps() {
+void ScummEngine_v5::o5_roomOps() {
 	int a = 0, b = 0, c, d, e;
 
 	if (_version == 3) {
@@ -2004,7 +2004,7 @@
 	}
 }
 
-void Scumm_v5::o5_saveRestoreVerbs() {
+void ScummEngine_v5::o5_saveRestoreVerbs() {
 	int a, b, c, slot, slot2;
 
 	_opcode = fetchScriptByte();
@@ -2053,11 +2053,11 @@
 	}
 }
 
-void Scumm_v5::o5_setCameraAt() {
+void ScummEngine_v5::o5_setCameraAt() {
 	setCameraAtEx(getVarOrDirectWord(0x80));
 }
 
-void Scumm_v5::o5_setObjectName() {
+void ScummEngine_v5::o5_setObjectName() {
 	int obj = getVarOrDirectWord(0x80);
 	int size;
 	int a;
@@ -2165,7 +2165,7 @@
 	runInventoryScript(0);
 }
 
-void Scumm_v5::o5_setOwnerOf() {
+void ScummEngine_v5::o5_setOwnerOf() {
 	int obj, owner;
 
 	obj = getVarOrDirectWord(0x80);
@@ -2174,7 +2174,7 @@
 	setOwnerOf(obj, owner);
 }
 
-void Scumm_v5::o5_setState() {
+void ScummEngine_v5::o5_setState() {
 	int obj, state;
 	obj = getVarOrDirectWord(0x80);
 	state = getVarOrDirectByte(0x40);
@@ -2184,7 +2184,7 @@
 		clearDrawObjectQueue();
 }
 
-void Scumm_v5::o5_setVarRange() {
+void ScummEngine_v5::o5_setVarRange() {
 	int a, b;
 
 	getResultPos();
@@ -2200,7 +2200,7 @@
 	} while (--a);
 }
 
-void Scumm_v5::o5_startMusic() {
+void ScummEngine_v5::o5_startMusic() {
 	if (_features & GF_FMTOWNS) {
 		// In FM Towns games this is some kind of Audio CD status query function.
 		// See also bug #762589 (thanks to Hibernatus for providing the information).
@@ -2236,20 +2236,20 @@
 	}
 }
 
-void Scumm_v5::o5_startSound() {
+void ScummEngine_v5::o5_startSound() {
 	VAR(VAR_MUSIC_TIMER) = 0;
 	_sound->addSoundToQueue(getVarOrDirectByte(0x80));
 }
 
-void Scumm_v5::o5_stopMusic() {
+void ScummEngine_v5::o5_stopMusic() {
 	_sound->stopAllSounds();
 }
 
-void Scumm_v5::o5_stopSound() {
+void ScummEngine_v5::o5_stopSound() {
 	_sound->stopSound(getVarOrDirectByte(0x80));
 }
 
-void Scumm_v5::o5_isSoundRunning() {
+void ScummEngine_v5::o5_isSoundRunning() {
 	int snd;
 	getResultPos();
 	snd = getVarOrDirectByte(0x80);
@@ -2258,7 +2258,7 @@
 	setResult(snd);
 }
 
-void Scumm_v5::o5_soundKludge() {
+void ScummEngine_v5::o5_soundKludge() {
 	int items[16];
 	int i;
 
@@ -2282,7 +2282,7 @@
 	_sound->soundKludge(items, num);
 }
 
-void Scumm_v5::o5_startObject() {
+void ScummEngine_v5::o5_startObject() {
 	int obj, script;
 	int data[16];
 
@@ -2293,7 +2293,7 @@
 	runObjectScript(obj, script, 0, 0, data);
 }
 
-void Scumm_v5::o5_startScript() {
+void ScummEngine_v5::o5_startScript() {
 	int op, script;
 	int data[16];
 
@@ -2305,15 +2305,15 @@
 	runScript(script, (op & 0x20) != 0, (op & 0x40) != 0, data);
 }
 
-void Scumm_v5::o5_stopObjectCode() {
+void ScummEngine_v5::o5_stopObjectCode() {
 	stopObjectCode();
 }
 
-void Scumm_v5::o5_stopObjectScript() {
+void ScummEngine_v5::o5_stopObjectScript() {
 	stopObjectScript(getVarOrDirectWord(0x80));
 }
 
-void Scumm_v5::o5_stopScript() {
+void ScummEngine_v5::o5_stopScript() {
 	int script;
 
 	script = getVarOrDirectByte(0x80);
@@ -2332,7 +2332,7 @@
 		stopScript(script);
 }
 
-void Scumm_v5::o5_stringOps() {
+void ScummEngine_v5::o5_stringOps() {
 	int a, b, c, i;
 	byte *ptr;
 
@@ -2387,14 +2387,14 @@
 	}
 }
 
-void Scumm_v5::o5_subtract() {
+void ScummEngine_v5::o5_subtract() {
 	int a;
 	getResultPos();
 	a = getVarOrDirectWord(0x80);
 	setResult(readVar(_resultVarNumber) - a);
 }
 
-void Scumm_v5::o5_verbOps() {
+void ScummEngine_v5::o5_verbOps() {
 	int verb, slot;
 	VerbSlot *vs;
 	int a, b;
@@ -2565,7 +2565,7 @@
 	verbMouseOver(0);
 }
 
-void Scumm_v5::o5_wait() {
+void ScummEngine_v5::o5_wait() {
 	const byte *oldaddr = _scriptPointer - 1;
 
 	if ((_gameId == GID_INDY3) && !(_features & GF_MACINTOSH)) {
@@ -2606,7 +2606,7 @@
 	o5_breakHere();
 }
 
-void Scumm_v5::o5_walkActorTo() {
+void ScummEngine_v5::o5_walkActorTo() {
 	int x, y;
 	Actor *a;
 
@@ -2616,7 +2616,7 @@
 	a->startWalkActor(x, y, -1);
 }
 
-void Scumm_v5::o5_walkActorToActor() {
+void ScummEngine_v5::o5_walkActorToActor() {
 	int x, y;
 	Actor *a, *a2;
 	int nr = getVarOrDirectByte(0x80);
@@ -2677,7 +2677,7 @@
 	a->startWalkActor(x, y, -1);
 }
 
-void Scumm_v5::o5_walkActorToObject() {
+void ScummEngine_v5::o5_walkActorToObject() {
 	int obj;
 	Actor *a;
 
@@ -2690,7 +2690,7 @@
 	}
 }
 
-int Scumm_v5::getWordVararg(int *ptr) {
+int ScummEngine_v5::getWordVararg(int *ptr) {
 	int i;
 
 	for (i = 0; i < 16; i++)
@@ -2703,7 +2703,7 @@
 	return i;
 }
 
-void Scumm_v5::decodeParseString() {
+void ScummEngine_v5::decodeParseString() {
 	int textSlot;
 
 	switch (_actorToPrintStrFor) {
@@ -2739,7 +2739,7 @@
 			{
 			int a = getVarOrDirectWord(0x80);
 			int b = getVarOrDirectWord(0x40);
-			warning("Scumm_v5::decodeParseString: Unhandled case 3: %d, %d", a, b);
+			warning("ScummEngine_v5::decodeParseString: Unhandled case 3: %d, %d", a, b);
 			}
 			break;
 		case 4:										/* center */
@@ -2821,7 +2821,7 @@
 			_scriptPointer = _messagePtr;
 			return;
 		default:
-			warning("Scumm_v5::decodeParseString: Unhandled case %d", _opcode & 0xF);
+			warning("ScummEngine_v5::decodeParseString: Unhandled case %d", _opcode & 0xF);
 			return;
 		}
 	}
@@ -2835,7 +2835,7 @@
 	_string[textSlot].t_charset = _string[textSlot].charset;
 }
 
-void Scumm_v5::o5_oldRoomEffect() {
+void ScummEngine_v5::o5_oldRoomEffect() {
 	int a;
 
 	_opcode = fetchScriptByte();
@@ -2907,7 +2907,7 @@
 	}
 }
 
-void Scumm_v5::o5_pickupObjectOld() {
+void ScummEngine_v5::o5_pickupObjectOld() {
 	int obj = getVarOrDirectWord(0x80);
 
 	if (obj < 1) {

Index: script_v6.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/script_v6.cpp,v
retrieving revision 1.200
retrieving revision 1.201
diff -u -d -r1.200 -r1.201
--- script_v6.cpp	26 Sep 2003 17:58:42 -0000	1.200
+++ script_v6.cpp	2 Oct 2003 22:42:02 -0000	1.201
@@ -40,9 +40,9 @@
 #include "scumm/dialogs.h"		// FIXME: This is just for the FT-INSANE warning. 
 				// Remove when INSANE is implemented
 
-#define OPCODE(x)	{ &Scumm_v6::x, #x }
+#define OPCODE(x)	{ &ScummEngine_v6::x, #x }
 
-void Scumm_v6::setupOpcodes() {
+void ScummEngine_v6::setupOpcodes() {
 	static const OpcodeEntryV6 opcodes[256] = {
 		/* 00 */
 		OPCODE(o6_pushByte),
[...1290 lines suppressed...]
 
-void Scumm_v6::o6_readINI() {
+void ScummEngine_v6::o6_readINI() {
 	int len;
 
 	len = resStrLen(_scriptPointer);
@@ -3163,11 +3163,11 @@
 	
 }
 
-void Scumm_v6::o6_localizeArray() {
+void ScummEngine_v6::o6_localizeArray() {
 	warning("stub localizeArray(%d)", pop());
 }
 
-void Scumm_v6::decodeParseString(int m, int n) {
+void ScummEngine_v6::decodeParseString(int m, int n) {
 	byte b;
 
 	b = fetchScriptByte();

Index: script_v8.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/script_v8.cpp,v
retrieving revision 2.197
retrieving revision 2.198
diff -u -d -r2.197 -r2.198
--- script_v8.cpp	24 Sep 2003 06:33:59 -0000	2.197
+++ script_v8.cpp	2 Oct 2003 22:42:02 -0000	2.198
@@ -33,9 +33,9 @@
 #include "sound/mixer.h"
 
 
-#define OPCODE(x)	{ &Scumm_v8::x, #x }
+#define OPCODE(x)	{ &ScummEngine_v8::x, #x }
 
-void Scumm_v8::setupOpcodes() {
+void ScummEngine_v8::setupOpcodes() {
 	static const OpcodeEntryV8 opcodes[256] = {
 		/* 00 */
 		OPCODE(o6_invalid),
@@ -362,17 +362,17 @@
 	_opcodesV8 = opcodes;
 }
 
-void Scumm_v8::executeOpcode(byte i) {
+void ScummEngine_v8::executeOpcode(byte i) {
 	OpcodeProcV8 op = _opcodesV8[i].proc;
 	(this->*op) ();
 }
 
-const char *Scumm_v8::getOpcodeDesc(byte i) {
+const char *ScummEngine_v8::getOpcodeDesc(byte i) {
 	return _opcodesV8[i].desc;
 }
 
 // In V8, the word size is 4 byte, not 2 bytes as in V6/V7 games
-uint Scumm_v8::fetchScriptWord() {
+uint ScummEngine_v8::fetchScriptWord() {
 	int a;
 	if (*_lastCodePtr + sizeof(MemBlkHeader) != _scriptOrgPointer) {
 		uint32 oldoffs = _scriptPointer - _scriptOrgPointer;
@@ -384,11 +384,11 @@
 	return a;
 }
 
-int Scumm_v8::fetchScriptWordSigned() {
+int ScummEngine_v8::fetchScriptWordSigned() {
 	return (int32)fetchScriptWord();
 }
 
-int Scumm_v8::readVar(uint var) {
+int ScummEngine_v8::readVar(uint var) {
 	debug(9, "readvar(%d)", var);
 
 	if (!(var & 0xF0000000)) {
@@ -412,7 +412,7 @@
 	return -1;
 }
 
-void Scumm_v8::writeVar(uint var, int value) {
+void ScummEngine_v8::writeVar(uint var, int value) {
 	debug(9, "writeVar(%d, %d)", var, value);
 
 	if (!(var & 0xF0000000)) {
@@ -450,7 +450,7 @@
 	error("Illegal varbits (w)");
 }
 
-void Scumm_v8::decodeParseString(int m, int n) {
+void ScummEngine_v8::decodeParseString(int m, int n) {
 	byte b;
 
 	b = fetchScriptByte();
@@ -531,12 +531,12 @@
 	}
 }
 
-void Scumm_v8::o8_mod() {
+void ScummEngine_v8::o8_mod() {
 	int a = pop();
 	push(pop() % a);
 }
 
-void Scumm_v8::o8_wait() {
+void ScummEngine_v8::o8_wait() {
 	int actnum;
 	int offs = -2;
 	Actor *a;
@@ -589,7 +589,7 @@
 	o6_breakHere();
 }
 
-void Scumm_v8::o8_dim() {
+void ScummEngine_v8::o8_dim() {
 	byte subOp = fetchScriptByte();
 	int array = fetchScriptWord();
 	
@@ -608,7 +608,7 @@
 	}
 }
 
-void Scumm_v8::o8_dim2() {
+void ScummEngine_v8::o8_dim2() {
 	byte subOp = fetchScriptByte();
 	int array = fetchScriptWord(), a, b;
 	
@@ -631,7 +631,7 @@
 	}
 }
 
-void Scumm_v8::o8_arrayOps() {
+void ScummEngine_v8::o8_arrayOps() {
 	byte subOp = fetchScriptByte();
 	int array = fetchScriptWord();
 	int b, c, d, len;
@@ -673,12 +673,12 @@
 	}
 }
 
-void Scumm_v8::o8_blastText() {
+void ScummEngine_v8::o8_blastText() {
 	// FIXME
 	decodeParseString(5, 0);
 }
 
-void Scumm_v8::o8_cursorCommand() {
+void ScummEngine_v8::o8_cursorCommand() {
 	byte subOp = fetchScriptByte();
 	int a, i;
 	int args[16];
@@ -757,7 +757,7 @@
 	VAR(VAR_USERPUT) = _userPut;
 }
 
-void Scumm_v8::o8_createBoxMatrix() {
+void ScummEngine_v8::o8_createBoxMatrix() {
 	int i;
 	Actor *a;
 
@@ -770,7 +770,7 @@
 	}
 }
 
-void Scumm_v8::o8_resourceRoutines() {
+void ScummEngine_v8::o8_resourceRoutines() {
 	byte subOp = fetchScriptByte();
 	int resid = pop();
 
@@ -838,7 +838,7 @@
 	}
 }
 
-void Scumm_v8::o8_roomOps() {
+void ScummEngine_v8::o8_roomOps() {
 	byte subOp = fetchScriptByte();
 	int a, b, c, d, e;
 	
@@ -912,7 +912,7 @@
 	}
 }
 
-void Scumm_v8::o8_actorOps() {
+void ScummEngine_v8::o8_actorOps() {
 	byte subOp = fetchScriptByte();
 	Actor *a;
 	int i, j;
@@ -1085,7 +1085,7 @@
 	}
 }
 
-void Scumm_v8::o8_cameraOps() {
+void ScummEngine_v8::o8_cameraOps() {
 	// TODO
 	byte subOp = fetchScriptByte();
 	switch (subOp) {
@@ -1100,7 +1100,7 @@
 	}
 }
 
-void Scumm_v8::o8_verbOps() {
+void ScummEngine_v8::o8_verbOps() {
 	byte subOp = fetchScriptByte();
 	VerbSlot *vs = NULL;
 	int slot, a, b;
@@ -1218,7 +1218,7 @@
 	}
 }
 
-void Scumm_v8::o8_system() {
+void ScummEngine_v8::o8_system() {
 	byte subOp = fetchScriptByte();
 	switch (subOp) {
 	case 0x28:		// SO_SYSTEM_RESTART Restart game
@@ -1233,7 +1233,7 @@
 }
 
 
-void Scumm_v8::o8_startVideo() {
+void ScummEngine_v8::o8_startVideo() {
 	int len = resStrLen(_scriptPointer);
 
 	debug(4, "o8_startVideo(%s/%s)", getGameDataPath(), (const char*)_scriptPointer);
@@ -1245,7 +1245,7 @@
 	_scriptPointer += len + 1;
 }
 
-void Scumm_v8::o8_kernelSetFunctions() {
+void ScummEngine_v8::o8_kernelSetFunctions() {
 	// TODO
 	Actor *a;
 	int args[30];
@@ -1387,7 +1387,7 @@
 	}
 }
 
-void Scumm_v8::o8_kernelGetFunctions() {
+void ScummEngine_v8::o8_kernelGetFunctions() {
 	// TODO
 	int args[30];
 	int len = getStackList(args, ARRAYSIZE(args));
@@ -1510,7 +1510,7 @@
 
 }
 
-void Scumm_v8::o8_getActorChore() {
+void ScummEngine_v8::o8_getActorChore() {
 	int actnum = pop();
 	Actor *a = derefActor(actnum, "o8_getActorChore");
 
@@ -1524,7 +1524,7 @@
 	push(a->frame);
 }
 
-void Scumm_v8::o8_getActorZPlane() {
+void ScummEngine_v8::o8_getActorZPlane() {
 	int actnum = pop();
 	Actor *a = derefActor(actnum, "o8_getActorZPlane");
 
@@ -1539,27 +1539,27 @@
 }
 
 
-void Scumm_v8::o8_getObjectImageX() {
+void ScummEngine_v8::o8_getObjectImageX() {
 	int i = getObjectIndex(pop());
 	push(_objs[i].x_pos);
 }
 
-void Scumm_v8::o8_getObjectImageY() {
+void ScummEngine_v8::o8_getObjectImageY() {
 	int i = getObjectIndex(pop());
 	push(_objs[i].y_pos);
 }
 
-void Scumm_v8::o8_getObjectImageWidth() {
+void ScummEngine_v8::o8_getObjectImageWidth() {
 	int i = getObjectIndex(pop());
 	push(_objs[i].width);
 }
 
-void Scumm_v8::o8_getObjectImageHeight() {
+void ScummEngine_v8::o8_getObjectImageHeight() {
 	int i = getObjectIndex(pop());
 	push(_objs[i].height);
 }
 
-void Scumm_v8::o8_getStringWidth() {
+void ScummEngine_v8::o8_getStringWidth() {
 	int charset = pop();
 	int oldID = _charset->getCurID(); 
 	int width;
@@ -1584,7 +1584,7 @@
 	push(width);
 }
 
-void Scumm_v8::o8_drawObject() {
+void ScummEngine_v8::o8_drawObject() {
 	int state = pop(), y = pop(), x = pop(), obj = pop(), objnum = getObjectIndex(obj);
 	ObjectData *od;
 

Index: scumm.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/scumm.h,v
retrieving revision 1.306
retrieving revision 1.307
diff -u -d -r1.306 -r1.307
--- scumm.h	2 Oct 2003 17:43:02 -0000	1.306
+++ scumm.h	2 Oct 2003 22:42:03 -0000	1.307
@@ -45,7 +45,7 @@
 class Player_V2;
 class Player_V2A;
 class Player_V3A;
-class Scumm;
+class ScummEngine;
 class ScummDebugger;
 class Serializer;
 class Sound;
@@ -57,7 +57,7 @@
 typedef Common::Map<Common::String, int> ObjectIDMap;
 
 // Use g_scumm from error() ONLY
-extern Scumm *g_scumm;
+extern ScummEngine *g_scumm;
 
 /* System Wide Constants */
 enum {
@@ -250,7 +250,7 @@
 	int32 offset;
 };
 
-class Scumm : public Engine {
+class ScummEngine : public Engine {
 	friend class ScummDebugger;
 	friend class SmushPlayer;
 	void errorString(const char *buf_input, char *buf_output);
@@ -291,8 +291,8 @@
 
 public:
 	// Constructor / Destructor
-	Scumm(GameDetector *detector, OSystem *syst);
-	virtual ~Scumm();
+	ScummEngine(GameDetector *detector, OSystem *syst);
+	virtual ~ScummEngine();
 
 	// Init functions
 	void scummInit();
@@ -715,7 +715,7 @@
 	void setVerbObject(uint room, uint object, uint verb);
 
 
-	// TODO: This should be moved into Scumm_v2 if possible
+	// TODO: This should be moved into ScummEngine_v2 if possible
 	V2MouseoverBox v2_mouseover_boxes[7];
 	int8 v2_mouseover_box;
 

Index: scummvm.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/scummvm.cpp,v
retrieving revision 2.411
retrieving revision 2.412
diff -u -d -r2.411 -r2.412
--- scummvm.cpp	2 Oct 2003 14:37:40 -0000	2.411
+++ scummvm.cpp	2 Oct 2003 22:42:03 -0000	2.412
@@ -69,7 +69,7 @@
 };
 
 // Use g_scumm from error() ONLY
-Scumm *g_scumm = 0;
+ScummEngine *g_scumm = 0;
 ScummDebugger *g_debugger;
 
 extern NewGui *g_gui;
@@ -292,25 +292,25 @@
 	switch (detector->_game.version) {
 	case 1:
 	case 2:
-		engine = new Scumm_v2(detector, syst);
+		engine = new ScummEngine_v2(detector, syst);
 		break;
 	case 3:
-		engine = new Scumm_v3(detector, syst);
+		engine = new ScummEngine_v3(detector, syst);
 		break;
 	case 4:
-		engine = new Scumm_v4(detector, syst);
+		engine = new ScummEngine_v4(detector, syst);
 		break;
 	case 5:
-		engine = new Scumm_v5(detector, syst);
+		engine = new ScummEngine_v5(detector, syst);
 		break;
 	case 6:
-		engine = new Scumm_v6(detector, syst);
+		engine = new ScummEngine_v6(detector, syst);
 		break;
 	case 7:
-		engine = new Scumm_v7(detector, syst);
+		engine = new ScummEngine_v7(detector, syst);
 		break;
 	case 8:
-		engine = new Scumm_v8(detector, syst);
+		engine = new ScummEngine_v8(detector, syst);
 		break;
 	default:
 		error("Engine_SCUMM_create(): Unknown version of game engine");
@@ -321,7 +321,7 @@
 
 REGISTER_PLUGIN("Scumm Engine", Engine_SCUMM_targetList, Engine_SCUMM_create);
 
-Scumm::Scumm (GameDetector *detector, OSystem *syst)
+ScummEngine::ScummEngine(GameDetector *detector, OSystem *syst)
 	: Engine(detector, syst), _pauseDialog(0), _optionsDialog(0), _saveLoadDialog(0) {
 	OSystem::Property prop;
 
@@ -824,7 +824,7 @@
 	_audioNames = NULL;
 }
 
-Scumm::~Scumm () {
+ScummEngine::~ScummEngine() {
 	delete [] _actors;
 	
 	delete _2byteFontPtr;
@@ -868,7 +868,7 @@
 	delete g_debugger;
 }
 
-void Scumm::go() {
+void ScummEngine::go() {
 	launch();
 	mainRun();
 }
@@ -877,7 +877,7 @@
 #pragma mark --- Initialization ---
 #pragma mark -
 
-void Scumm::launch() {
+void ScummEngine::launch() {
 	gdi._vm = this;
 
 #ifdef __PALM_OS__
@@ -961,7 +961,7 @@
 	_saveLoadFlag = 0;
 }
 
-void Scumm::setFeatures (uint32 newFeatures) {
+void ScummEngine::setFeatures (uint32 newFeatures) {
 	bool newCostumes = (_features & GF_NEW_COSTUMES) != 0;
 	bool newNewCostumes = (newFeatures & GF_NEW_COSTUMES) != 0;
 	bool amigaPalette = (_features & GF_AMIGA) != 0;
@@ -985,7 +985,7 @@
 	}
 }
 
-void Scumm::scummInit() {
+void ScummEngine::scummInit() {
 	int i;
 
 	tempMusic = 0;
@@ -1152,7 +1152,7 @@
 }
 
 
-void Scumm::initScummVars() {
+void ScummEngine::initScummVars() {
 
 	// FIXME
 	if (_version <= 2) {
@@ -1237,7 +1237,7 @@
 #pragma mark --- Main loop ---
 #pragma mark -
 
-void Scumm::mainRun() {
+void ScummEngine::mainRun() {
 	int delta = 0;
 	int diff = _system->get_msecs();
 
@@ -1261,7 +1261,7 @@
 	}
 }
 
-void Scumm::waitForTimer(int msec_delay) {
+void ScummEngine::waitForTimer(int msec_delay) {
 	uint32 start_time;
 
 	if (_fastMode & 2)
@@ -1281,7 +1281,7 @@
 	}
 }
 
-int Scumm::scummLoop(int delta) {
+int ScummEngine::scummLoop(int delta) {
 	if (_debugger)
 		_debugger->on_frame();
 
@@ -1571,7 +1571,7 @@
 #pragma mark --- Events / Input ---
 #pragma mark -
 
-void Scumm::parseEvents() {
+void ScummEngine::parseEvents() {
 	OSystem::Event event;
 
 	while (_system->poll_event(&event)) {
@@ -1671,14 +1671,14 @@
 	}
 }
 
-void Scumm::clearClickedStatus() {
+void ScummEngine::clearClickedStatus() {
 	_keyPressed = 0;
 	_mouseButStat = 0;
 	_leftBtnPressed &= ~msClicked;
 	_rightBtnPressed &= ~msClicked;
 }
 
-void Scumm::processKbd() {
+void ScummEngine::processKbd() {
 	int saveloadkey;
 
 	_lastKeyHit = _keyPressed;
@@ -1907,7 +1907,7 @@
  * Start a 'scene' by loading the specified room with the given main actor.
  * The actor is placed next to the object indicated by objectNr.
  */
-void Scumm::startScene(int room, Actor *a, int objectNr) {
+void ScummEngine::startScene(int room, Actor *a, int objectNr) {
 	int i, where;
 
 	CHECK_HEAP;
@@ -2082,7 +2082,7 @@
 	CHECK_HEAP;
 }
 
-void Scumm::initRoomSubBlocks() {
+void ScummEngine::initRoomSubBlocks() {
 	int i;
 	const byte *ptr;
 	byte *roomptr, *searchptr, *roomResPtr;
@@ -2430,15 +2430,15 @@
 	initBGBuffers(_roomHeight);
 }
 
-void Scumm::pauseGame() {
+void ScummEngine::pauseGame() {
 	pauseDialog();
 }
 
-void Scumm::shutDown() {
+void ScummEngine::shutDown() {
 	_quit = true;
 }
 
-void Scumm::restart() {
+void ScummEngine::restart() {
 // TODO: Check this function - we should probably be reinitting a lot more stuff, and I suspect
 //	 this leaks memory like a sieve
 
@@ -2470,7 +2470,7 @@
 	runScript(1, 0, 0, &_bootParam);
 }
 
-void Scumm::startManiac() {
+void ScummEngine::startManiac() {
 	warning("stub startManiac()");
 }
 
@@ -2478,7 +2478,7 @@
 #pragma mark --- GUI ---
 #pragma mark -
 
-int Scumm::runDialog(Dialog &dialog) {
+int ScummEngine::runDialog(Dialog &dialog) {
 	// Pause sound put
 	bool old_soundsPaused = _sound->_soundsPaused;
 	_sound->pauseSounds(true);
@@ -2503,25 +2503,25 @@
 	return result;
 }
 
-void Scumm::pauseDialog() {
+void ScummEngine::pauseDialog() {
 	if (!_pauseDialog)
 		_pauseDialog = new PauseDialog(_newgui, this);
 	runDialog(*_pauseDialog);
 }
 
-void Scumm::saveloadDialog() {
+void ScummEngine::saveloadDialog() {
 	if (!_saveLoadDialog)
 		_saveLoadDialog = new SaveLoadDialog(_newgui, this);
 	runDialog(*_saveLoadDialog);
 }
 
-void Scumm::optionsDialog() {
+void ScummEngine::optionsDialog() {
 	if (!_optionsDialog)
 		_optionsDialog = new OptionsDialog(_newgui, this);
 	runDialog(*_optionsDialog);
 }
 
-void Scumm::confirmexitDialog() {
+void ScummEngine::confirmexitDialog() {
 	if (!_confirmExitDialog)
 		_confirmExitDialog = new ConfirmExitDialog(_newgui, this);
 
@@ -2530,7 +2530,7 @@
 	}
 }
 
-char Scumm::displayError(bool showCancel, const char *message, ...) {
+char ScummEngine::displayError(bool showCancel, const char *message, ...) {
 #ifdef __PALM_OS__
 	char buf[256]; // 1024 is too big overflow the stack
 #else
@@ -2550,7 +2550,7 @@
 #pragma mark --- Miscellaneous ---
 #pragma mark -
 
-byte *Scumm::get2byteCharPtr(int idx) {
+byte *ScummEngine::get2byteCharPtr(int idx) {
 	/*
 		switch(language)
 		case korean:
@@ -2565,7 +2565,7 @@
 }
 
 
-const char *Scumm::getGameDataPath() const {
+const char *ScummEngine::getGameDataPath() const {
 #ifdef MACOSX
 	if (_version == 8 && !memcmp(_gameDataPath, "/Volumes/MONKEY3_", 17)) {
 		// Special case for COMI on Mac OS X. The mount points on OS X depend
@@ -2594,7 +2594,7 @@
 	return _gameDataPath;
 }
 
-void Scumm::errorString(const char *buf1, char *buf2) {
+void ScummEngine::errorString(const char *buf1, char *buf2) {
 	if (_currentScript != 0xFF) {
 		ScriptSlot *ss = &vm.slot[_currentScript];
 		sprintf(buf2, "(%d:%d:0x%X): %s", _roomResource,

Index: sound.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/sound.cpp,v
retrieving revision 1.259
retrieving revision 1.260
diff -u -d -r1.259 -r1.260
--- sound.cpp	1 Oct 2003 18:27:31 -0000	1.259
+++ sound.cpp	2 Oct 2003 22:42:03 -0000	1.260
@@ -90,7 +90,7 @@
 
 
 
-Sound::Sound(Scumm *parent) {
+Sound::Sound(ScummEngine *parent) {
 	memset(this,0,sizeof(Sound));	// palmos
 	
 	_scumm = parent;
@@ -640,7 +640,7 @@
 
 /**
  * Check whether the sound resource with the specified ID is still
- * used. This is invoked by Scumm::isResourceInUse, to determine
+ * used. This is invoked by ScummEngine::isResourceInUse, to determine
  * which resources can be expired from memory.
  * Technically, this works very similar to isSoundRunning, however it
  * calls IMuse::get_sound_active() instead of IMuse::getSoundStatus().
@@ -1060,7 +1060,7 @@
 	_musicBundleToBeRemoved = true;
 }
 
-void Sound::bundleMusicHandler(Scumm *scumm) {
+void Sound::bundleMusicHandler(ScummEngine *scumm) {
 	byte *ptr;
 	int32 l, num = _numberSamplesBundleMusic, length, k;
 	int32 rate = 22050;
@@ -1399,7 +1399,7 @@
 // necessary for games like Loom CD.
 
 static void cd_timer_handler(void *refCon) {
-	Scumm *scumm = (Scumm *)refCon;
+	ScummEngine *scumm = (ScummEngine *)refCon;
 
 	// FIXME: Turn off the timer when it's no longer needed. In theory, it
 	// should be possible to check with pollCD(), but since CD sound isn't

Index: sound.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/sound.h,v
retrieving revision 1.48
retrieving revision 1.49
diff -u -d -r1.48 -r1.49
--- sound.h	15 Sep 2003 19:48:54 -0000	1.48
+++ sound.h	2 Oct 2003 22:42:03 -0000	1.49
@@ -27,7 +27,7 @@
 class Bundle;
 class DigitalTrackInfo;
 class File;
-class Scumm;
+class ScummEngine;
 
 struct MP3OffsetTable;
 
@@ -93,7 +93,7 @@
 	DigitalTrackInfo *_track_info[CACHE_TRACKS];
 	int _current_cache;
 
-	Scumm *_scumm;
+	ScummEngine *_scumm;
 
 public:
 	int32 _bundleMusicPosition;
@@ -106,10 +106,10 @@
 	// update iMuse/iMuseDigi/Player_v2/SoundMIxer, too
 	int16 _sound_volume_master, _sound_volume_music, _sound_volume_sfx;
 
-	Bundle *_bundle;	// FIXME: should be protected but is used by Scumm::askForDisk
+	Bundle *_bundle;	// FIXME: should be protected but is used by ScummEngine::askForDisk
 
 public:
-	Sound(Scumm *parent);
+	Sound(ScummEngine *parent);
 	~Sound();
 	void addSoundToQueue(int sound);
 	void addSoundToQueue2(int sound);
@@ -131,7 +131,7 @@
 
 	void playBundleMusic(const char *song);
 	void pauseBundleMusic(bool state);
-	void bundleMusicHandler(Scumm *scumm);
+	void bundleMusicHandler(ScummEngine *scumm);
 	void stopBundleMusic();
 	void playBundleSound(char *sound, PlayingSoundHandle *handle);
 

Index: string.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/string.cpp,v
retrieving revision 1.160
retrieving revision 1.161
diff -u -d -r1.160 -r1.161
--- string.cpp	14 Sep 2003 18:16:45 -0000	1.160
+++ string.cpp	2 Oct 2003 22:42:03 -0000	1.161
@@ -28,7 +28,7 @@
 #include "verbs.h"
 #include "scumm/sound.h"
 
-void Scumm::setStringVars(int slot) {
+void ScummEngine::setStringVars(int slot) {
 	StringTab *st = &_string[slot];
 	st->xpos = st->t_xpos;
 	st->ypos = st->t_ypos;
@@ -40,7 +40,7 @@
 	st->charset = st->t_charset;
 }
 
-void Scumm::unkMessage1() {
+void ScummEngine::unkMessage1() {
 	byte buffer[100];
 	_msgPtrToAdd = buffer;
 	_messagePtr = addMessageToStack(_messagePtr);
@@ -66,7 +66,7 @@
 	}
 }
 
-void Scumm::unkMessage2() {
+void ScummEngine::unkMessage2() {
 	byte buf[100];
 	const byte *tmp;
 
@@ -84,7 +84,7 @@
 	_messagePtr = tmp;
 }
 
-void Scumm::CHARSET_1() {
+void ScummEngine::CHARSET_1() {
 	uint32 talk_sound_a = 0;
 	uint32 talk_sound_b = 0;
 	int s, i, t, c;
@@ -344,7 +344,7 @@
 	gdi._mask = _charset->_str;
 }
 
-void Scumm::drawString(int a) {
+void ScummEngine::drawString(int a) {
 	byte buf[256];
 	byte *space;
 	int i, c;
@@ -460,7 +460,7 @@
 	}
 }
 
-const byte *Scumm::addMessageToStack(const byte *msg) {
+const byte *ScummEngine::addMessageToStack(const byte *msg) {
 	int num, numorg;
 	unsigned char *ptr, chr;
 
@@ -580,14 +580,14 @@
 	return msg;
 }
 
-void Scumm::addIntToStack(int var) {
+void ScummEngine::addIntToStack(int var) {
 	int num;
 
 	num = readVar(var);
 	_msgPtrToAdd += sprintf((char *)_msgPtrToAdd, "%d", num);
 }
 
-void Scumm::addVerbToStack(int var)
+void ScummEngine::addVerbToStack(int var)
 {
 	int num, k;
 
@@ -606,7 +606,7 @@
 	}
 }
 
-void Scumm::addNameToStack(int var)
+void ScummEngine::addNameToStack(int var)
 {
 	int num;
 	const byte *ptr = 0;
@@ -626,7 +626,7 @@
 	}
 }
 
-void Scumm::addStringToStack(int var) {
+void ScummEngine::addStringToStack(int var) {
 	const byte *ptr;
 
 	if (_version == 3 || _version >= 6)
@@ -646,7 +646,7 @@
 		addMessageToStack((const byte *)"");
 }
 
-void Scumm::initCharset(int charsetno) {
+void ScummEngine::initCharset(int charsetno) {
 	int i;
 
 	if (!getResourceAddress(rtCharset, charsetno))
@@ -659,7 +659,7 @@
 		_charsetColorMap[i] = _charsetData[charsetno][i];
 }
 
-void Scumm::enqueueText(const byte *text, int x, int y, byte color, byte charset, bool center) {
+void ScummEngine::enqueueText(const byte *text, int x, int y, byte color, byte charset, bool center) {
 	// The Dig will keep enqueueing texts long after they've scrolled off
 	// the screen, eventually overflowing the blast text queue if left
 	// unchecked.
@@ -688,7 +688,7 @@
 	bt.center = center;
 }
 
-void Scumm::drawBlastTexts() {
+void ScummEngine::drawBlastTexts() {
 	byte *buf;
 	int c;
 	int i;
@@ -733,7 +733,7 @@
 	_charset->_ignoreCharsetMask = false;
 }
 
-void Scumm::removeBlastTexts() {
+void ScummEngine::removeBlastTexts() {
 	int i;
 
 	for (i = 0; i < _blastTextQueuePos; i++) {
@@ -749,7 +749,7 @@
 	return strcmp(i1->tag, i2->tag);
 }
 
-void Scumm::loadLanguageBundle() {
+void ScummEngine::loadLanguageBundle() {
 	File file;
 	int32 size;
 
@@ -883,7 +883,7 @@
 	qsort(_languageIndex, _languageIndexSize, sizeof(LangIndexNode), indexCompare);
 }
 
-const byte *Scumm::translateTextAndPlaySpeech(const byte *ptr) {
+const byte *ScummEngine::translateTextAndPlaySpeech(const byte *ptr) {
 	if ((_gameId == GID_DIG || _gameId == GID_CMI) && (ptr[0] == '/')) {
 		char pointer[20];
 		int i, j;
@@ -903,7 +903,7 @@
 	return ptr;
 }
 
-void Scumm::translateText(const byte *text, byte *trans_buff) {
+void ScummEngine::translateText(const byte *text, byte *trans_buff) {
 	int l;
 	
 	if ((text[0] == '/') && _existLanguageFile) {

Index: usage_bits.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/usage_bits.cpp,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- usage_bits.cpp	6 Mar 2003 21:46:30 -0000	1.7
+++ usage_bits.cpp	2 Oct 2003 22:42:03 -0000	1.8
@@ -20,7 +20,7 @@
 #include "scumm.h"
 #include "usage_bits.h"
 
-void Scumm::upgradeGfxUsageBits() {
+void ScummEngine::upgradeGfxUsageBits() {
 	int i;
 
 	for (i = 409; i >= 0; i--) {
@@ -35,25 +35,25 @@
 	}
 }
 
-void Scumm::setGfxUsageBit(int strip, int bit) {
+void ScummEngine::setGfxUsageBit(int strip, int bit) {
 	assert(1 <= bit && bit <= 96);
 	bit--;
 	gfxUsageBits[3 * strip + bit / 32] |= (1 << (bit % 32));
 }
 
-void Scumm::clearGfxUsageBit(int strip, int bit) {
+void ScummEngine::clearGfxUsageBit(int strip, int bit) {
 	assert(1 <= bit && bit <= 96);
 	bit--;
 	gfxUsageBits[3 * strip + bit / 32] &= ~(1 << (bit % 32));
 }
 
-bool Scumm::testGfxUsageBit(int strip, int bit) {
+bool ScummEngine::testGfxUsageBit(int strip, int bit) {
 	assert(1 <= bit && bit <= 96);
 	bit--;
 	return (gfxUsageBits[3 * strip + bit / 32] & (1 << (bit % 32))) != 0;
 }
 
-bool Scumm::testGfxAnyUsageBits(int strip) {
+bool ScummEngine::testGfxAnyUsageBits(int strip) {
 	// Exclude the DIRTY and RESTORED bits from the test
 	uint32 bitmask[3] = { 0xFFFFFFFF, 0xFFFFFFFF, 0x3FFFFFFF };
 	int i;
@@ -65,7 +65,7 @@
 	return false;
 }
 
-bool Scumm::testGfxOtherUsageBits(int strip, int bit) {
+bool ScummEngine::testGfxOtherUsageBits(int strip, int bit) {
 	// Don't exclude the DIRTY and RESTORED bits from the test
 	uint32 bitmask[3] = { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
 	int i;

Index: vars.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/vars.cpp,v
retrieving revision 1.59
retrieving revision 1.60
diff -u -d -r1.59 -r1.60
--- vars.cpp	5 Aug 2003 12:23:26 -0000	1.59
+++ vars.cpp	2 Oct 2003 22:42:03 -0000	1.60
@@ -25,7 +25,7 @@
 #include "scumm.h"
 #include "intern.h"
 
-void Scumm::setupScummVars() {
+void ScummEngine::setupScummVars() {
 	VAR_KEYPRESS = 0;
 	VAR_EGO = 1;
 	VAR_CAMERA_POS_X = 2;
@@ -99,7 +99,7 @@
 	VAR_VERSION = 75;
 }
 
-void Scumm_v2::setupScummVars() {
+void ScummEngine_v2::setupScummVars() {
 	VAR_EGO = 0;
 	VAR_CAMERA_POS_X = 2;
 	VAR_HAVE_MSG = 3;
@@ -136,9 +136,9 @@
 	VAR_TALK_ACTOR = 41;
 }
 
-void Scumm_v6::setupScummVars() {
+void ScummEngine_v6::setupScummVars() {
 	// Many vars are the same as in V5 games, so just call the inherited method first
-	Scumm::setupScummVars();
+	ScummEngine::setupScummVars();
 
 	VAR_V6_SCREEN_WIDTH = 41;
 	VAR_V6_SCREEN_HEIGHT = 54;
@@ -154,7 +154,7 @@
 	VAR_TIMEDATE_MINUTE = 126;
 }
 
-void Scumm_v7::setupScummVars() {
+void ScummEngine_v7::setupScummVars() {
 	VAR_MOUSE_X = 1;
 	VAR_MOUSE_Y = 2;
 	VAR_VIRT_MOUSE_X = 3;
@@ -238,7 +238,7 @@
 	VAR_STRING2DRAW = 130;
 }
 
-void Scumm_v8::setupScummVars() {
+void ScummEngine_v8::setupScummVars() {
 	// VAR_ROOM_HEIGHT = 1;
 	// VAR_ROOM_WIDTH = 2;
 

Index: verbs.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/scumm/verbs.cpp,v
retrieving revision 1.79
retrieving revision 1.80
diff -u -d -r1.79 -r1.80
--- verbs.cpp	2 Oct 2003 17:43:02 -0000	1.79
+++ verbs.cpp	2 Oct 2003 22:42:03 -0000	1.80
@@ -33,7 +33,7 @@
 	kSentenceLine = 6
 };
 
-void Scumm::initV2MouseOver() {
+void ScummEngine::initV2MouseOver() {
 	int i;
 	int arrow_color, color, hi_color;
 
@@ -99,7 +99,7 @@
 	v2_mouseover_boxes[kSentenceLine].hicolor = hi_color;
 }
 
-void Scumm::checkV2MouseOver(Common::Point pos) {
+void ScummEngine::checkV2MouseOver(Common::Point pos) {
 	VirtScreen *vs = &virtscr[2];
 	Common::Rect rect;
 	byte *ptr, *dst;
@@ -159,7 +159,7 @@
 	}
 }
 
-void Scumm::checkV2Inventory(int x, int y) {
+void ScummEngine::checkV2Inventory(int x, int y) {
 	int object = 0;
 
 	y -= virtscr[2].topline;
@@ -194,7 +194,7 @@
 	}
 }
 
-void Scumm::redrawV2Inventory() {
+void ScummEngine::redrawV2Inventory() {
 	int i;
 	int max_inv;
 	Common::Rect inventoryBox;
@@ -259,7 +259,7 @@
 	}
 }
 
-void Scumm::redrawVerbs() {
+void ScummEngine::redrawVerbs() {
 	if (_version <= 2 && !(_userState & 128)) // Don't draw verbs unless active
 		return;
 
@@ -274,7 +274,7 @@
 	_verbMouseOver = verb;
 }
 
-void Scumm::checkExecVerbs() {
+void ScummEngine::checkExecVerbs() {
 	int i, over;
 	VerbSlot *vs;
 
@@ -317,7 +317,7 @@
 	}
 }
 
-void Scumm::verbMouseOver(int verb) {
+void ScummEngine::verbMouseOver(int verb) {
 	// Don't do anything unless verbs are active
 	if (_version <= 2 && !(_userState & 128))
 		return;
@@ -336,7 +336,7 @@
 	}
 }
 
-int Scumm::checkMouseOver(int x, int y) const {
+int ScummEngine::checkMouseOver(int x, int y) const {
 	VerbSlot *vs;
 	int i = _maxVerbs - 1;
 
@@ -358,7 +358,7 @@
 	return 0;
 }
 
-void Scumm::drawVerb(int verb, int mode) {
+void ScummEngine::drawVerb(int verb, int mode) {
 	VerbSlot *vs;
 	bool tmp;
 
@@ -418,7 +418,7 @@
 	}
 }
 
-void Scumm::restoreVerbBG(int verb) {
+void ScummEngine::restoreVerbBG(int verb) {
 	VerbSlot *vs;
 
 	vs = &_verbs[verb];
@@ -429,7 +429,7 @@
 	}
 }
 
-void Scumm::drawVerbBitmap(int verb, int x, int y) {
+void ScummEngine::drawVerbBitmap(int verb, int x, int y) {
 	VirtScreen *vs;
 	VerbSlot *vst;
 	byte twobufs;
@@ -499,7 +499,7 @@
 	vs->alloctwobuffers = twobufs;
 }
 
-int Scumm::getVerbSlot(int id, int mode) const {
+int ScummEngine::getVerbSlot(int id, int mode) const {
 	int i;
 	for (i = 1; i < _maxVerbs; i++) {
 		if (_verbs[i].verbid == id && _verbs[i].saveid == mode) {
@@ -509,7 +509,7 @@
 	return 0;
 }
 
-void Scumm::killVerb(int slot) {
+void ScummEngine::killVerb(int slot) {
 	VerbSlot *vs;
 
 	if (slot == 0)
@@ -528,7 +528,7 @@
 	vs->saveid = 0;
 }
 
-void Scumm::setVerbObject(uint room, uint object, uint verb) {
+void ScummEngine::setVerbObject(uint room, uint object, uint verb) {
 	const byte *obimptr;
 	const byte *obcdptr;
 	uint32 size, size2;





More information about the Scummvm-git-logs mailing list