CINE: eliminate global variables

svn-id: r51937

1 files changed, 153 insertions, 159 deletions

diff --git a/engines/cine/various.cpp b/engines/cine/various.cpp
index 82c40a2f50..cf7135a6b5 100644
--- a/engines/cine/various.cpp
+++ b/engines/cine/various.cpp
@@ -81,7 +81,6 @@ uint16 _messageLen;
 
 int16 playerCommand;
 
-Common::String commandBuffer;
 char currentPrcName[20];
 char currentRelName[20];
 char currentObjectName[20];
@@ -137,9 +136,6 @@ static const int16 canUseOnItemTable[] = { 1, 0, 0, 1, 1, 0, 0 };
 CommandeType objectListCommand[20];
 int16 objListTab[20];
 
-Common::Array<uint16> zoneData;
-Common::Array<uint16> zoneQuery; ///< Only exists in Operation Stealth
-
 /**
  * Move the player character using the keyboard
  * @param x Negative values move left, positive right, zero not at all
@@ -174,9 +170,9 @@ void stopMusicAfterFadeOut() {
 }
 
 void runObjectScript(int16 entryIdx) {
-	ScriptPtr tmp(scriptInfo->create(*relTable[entryIdx], entryIdx));
+	ScriptPtr tmp(scriptInfo->create(*g_cine->_relTable[entryIdx], entryIdx));
 	assert(tmp);
-	objectScripts.push_back(tmp);
+	g_cine->_objectScripts.push_back(tmp);
 }
 
 /**
@@ -190,19 +186,19 @@ void addPlayerCommandMessage(int16 cmd) {
 	tmp.objIdx = cmd;
 	tmp.type = 3;
 
-	overlayList.push_back(tmp);
+	g_cine->_overlayList.push_back(tmp);
 }
 
 int16 getRelEntryForObject(uint16 param1, uint16 param2, SelectedObjStruct *pSelectedObject) {
 	int16 i;
 	int16 found = -1;
 
-	for (i = 0; i < (int16)relTable.size(); i++) {
-		if (relTable[i]->_param1 == param1 && relTable[i]->_param2 == pSelectedObject->idx) {
+	for (i = 0; i < (int16)g_cine->_relTable.size(); i++) {
+		if (g_cine->_relTable[i]->_param1 == param1 && g_cine->_relTable[i]->_param2 == pSelectedObject->idx) {
 			if (param2 == 1) {
 				found = i;
 			} else if (param2 == 2) {
-				if (relTable[i]->_param3 == pSelectedObject->param) {
+				if (g_cine->_relTable[i]->_param3 == pSelectedObject->param) {
 					found = i;
 				}
 			}
@@ -228,19 +224,19 @@ int16 getObjectUnderCursor(uint16 x, uint16 y) {
 	int width;
 
 	// reverse_iterator would be nice
-	for (it = overlayList.reverse_begin(); it != overlayList.end(); --it) {
-		if (it->type >= 2 || !objectTable[it->objIdx].name[0]) {
+	for (it = g_cine->_overlayList.reverse_begin(); it != g_cine->_overlayList.end(); --it) {
+		if (it->type >= 2 || !g_cine->_objectTable[it->objIdx].name[0]) {
 			continue;
 		}
 
-		objX = objectTable[it->objIdx].x;
-		objY = objectTable[it->objIdx].y;
+		objX = g_cine->_objectTable[it->objIdx].x;
+		objY = g_cine->_objectTable[it->objIdx].y;
 
-		frame = ABS((int16)(objectTable[it->objIdx].frame));
-		part = objectTable[it->objIdx].part;
+		frame = ABS((int16)(g_cine->_objectTable[it->objIdx].frame));
+		part = g_cine->_objectTable[it->objIdx].part;
 
 		// Additional case for negative frame values in Operation Stealth
-		if (g_cine->getGameType() == Cine::GType_OS && objectTable[it->objIdx].frame < 0) {
+		if (g_cine->getGameType() == Cine::GType_OS && g_cine->_objectTable[it->objIdx].frame < 0) {
 			if ((it->type == 1) && (x >= objX) && (objX + frame >= x) && (y >= objY) && (objY + part >= y)) {
 				return it->objIdx;
 			} else {
@@ -249,18 +245,18 @@ int16 getObjectUnderCursor(uint16 x, uint16 y) {
 		}
 
 		if (it->type == 0) {
-			threshold = animDataTable[frame]._var1;
+			threshold = g_cine->_animDataTable[frame]._var1;
 		} else {
-			threshold = animDataTable[frame]._width / 2;
+			threshold = g_cine->_animDataTable[frame]._width / 2;
 		}
 
-		height = animDataTable[frame]._height;
-		width = animDataTable[frame]._realWidth;
+		height = g_cine->_animDataTable[frame]._height;
+		width = g_cine->_animDataTable[frame]._realWidth;
 
 		xdif = x - objX;
 		ydif = y - objY;
 
-		if ((xdif < 0) || ((threshold << 4) <= xdif) || (ydif <= 0) || (ydif >= height) || !animDataTable[frame].data()) {
+		if ((xdif < 0) || ((threshold << 4) <= xdif) || (ydif <= 0) || (ydif >= height) || !g_cine->_animDataTable[frame].data()) {
 			continue;
 		}
 
@@ -272,17 +268,17 @@ int16 getObjectUnderCursor(uint16 x, uint16 y) {
 				continue;
 			}
 
-			if (it->type == 0 && animDataTable[frame].getColor(xdif, ydif) != (part & 0x0F)) {
+			if (it->type == 0 && g_cine->_animDataTable[frame].getColor(xdif, ydif) != (part & 0x0F)) {
 				return it->objIdx;
-			} else if (it->type == 1 && gfxGetBit(xdif, ydif, animDataTable[frame].data(), animDataTable[frame]._width * 4)) {
+			} else if (it->type == 1 && gfxGetBit(xdif, ydif, g_cine->_animDataTable[frame].data(), g_cine->_animDataTable[frame]._width * 4)) {
 				return it->objIdx;
 			}
 		} else if (it->type == 0)	{ // use generated mask
-			if (gfxGetBit(xdif, ydif, animDataTable[frame].mask(), animDataTable[frame]._width)) {
+			if (gfxGetBit(xdif, ydif, g_cine->_animDataTable[frame].mask(), g_cine->_animDataTable[frame]._width)) {
 				return it->objIdx;
 			}
 		} else if (it->type == 1) { // is mask
-			if (gfxGetBit(xdif, ydif, animDataTable[frame].data(), animDataTable[frame]._width * 4)) {
+			if (gfxGetBit(xdif, ydif, g_cine->_animDataTable[frame].data(), g_cine->_animDataTable[frame]._width * 4)) {
 				return it->objIdx;
 			}
 		}
@@ -294,18 +290,18 @@ int16 getObjectUnderCursor(uint16 x, uint16 y) {
 void CineEngine::resetEngine() {
 	g_sound->stopMusic();
 	freeAnimDataTable();
-	overlayList.clear();
-	bgIncrustList.clear();
+	g_cine->_overlayList.clear();
+	g_cine->_bgIncrustList.clear();
 	closePart();
 
-	objectScripts.clear();
-	globalScripts.clear();
-	relTable.clear();
-	scriptTable.clear();
-	messageTable.clear();
+	g_cine->_objectScripts.clear();
+	g_cine->_globalScripts.clear();
+	g_cine->_relTable.clear();
+	g_cine->_scriptTable.clear();
+	g_cine->_messageTable.clear();
 	resetObjectTable();
 
-	globalVars.reset();
+	g_cine->_globalVars.reset();
 
 	var2 = var3 = var4 = var5 = 0;
 
@@ -320,10 +316,10 @@ void CineEngine::resetEngine() {
 	playerCommand = -1;
 	isDrawCommandEnabled = 0;
 
-	commandBuffer = "";
+	g_cine->_commandBuffer = "";
 
-	globalVars[VAR_MOUSE_X_POS] = 0;
-	globalVars[VAR_MOUSE_Y_POS] = 0;
+	g_cine->_globalVars[VAR_MOUSE_X_POS] = 0;
+	g_cine->_globalVars[VAR_MOUSE_Y_POS] = 0;
 
 	fadeRequired = false;
 
@@ -332,7 +328,7 @@ void CineEngine::resetEngine() {
 	checkForPendingDataLoadSwitch = 0;
 
 	if (g_cine->getGameType() == Cine::GType_OS) {
-		seqList.clear();
+		g_cine->_seqList.clear();
 		currentAdditionalBgIdx = 0;
 		currentAdditionalBgIdx2 = 0;
 		// TODO: Add resetting of the following variables
@@ -539,8 +535,8 @@ int16 buildObjectListCommand(int16 param) {
 	}
 
 	for (i = 0; i < 255; i++) {
-		if (objectTable[i].name[0] && objectTable[i].costume == param) {
-			strcpy(objectListCommand[j], objectTable[i].name);
+		if (g_cine->_objectTable[i].name[0] && g_cine->_objectTable[i].costume == param) {
+			strcpy(objectListCommand[j], g_cine->_objectTable[i].name);
 			objListTab[j] = i;
 			j++;
 		}
@@ -581,9 +577,9 @@ void makeCommandLine() {
 	commandVar2 = -10;
 
 	if (playerCommand != -1) {
-		commandBuffer = defaultActionCommand[playerCommand];
+		g_cine->_commandBuffer = defaultActionCommand[playerCommand];
 	} else {
-		commandBuffer = "";
+		g_cine->_commandBuffer = "";
 	}
 
 	if ((playerCommand != -1) && (choiceResultTable[playerCommand] == 2)) {	// need object selection ?
@@ -602,7 +598,7 @@ void makeCommandLine() {
 				canUseOnObject = 0;
 			} else { // Future Wars
 				playerCommand = -1;
-				commandBuffer = "";
+				g_cine->_commandBuffer = "";
 			}
 		} else {
 			if (g_cine->getGameType() == Cine::GType_OS) {
@@ -616,13 +612,13 @@ void makeCommandLine() {
 
 			commandVar3[0] = si;
 			commandVar1 = 1;
-			commandBuffer += " ";
-			commandBuffer += objectTable[commandVar3[0]].name;
-			commandBuffer += " ";
+			g_cine->_commandBuffer += " ";
+			g_cine->_commandBuffer += g_cine->_objectTable[commandVar3[0]].name;
+			g_cine->_commandBuffer += " ";
 			if (g_cine->getGameType() == Cine::GType_OS) {
-				commandBuffer += commandPrepositionTable[playerCommand];
+				g_cine->_commandBuffer += commandPrepositionTable[playerCommand];
 			} else { // Future Wars
-				commandBuffer += defaultCommandPreposition;
+				g_cine->_commandBuffer += defaultCommandPreposition;
 			}
 		}
 	}
@@ -634,7 +630,7 @@ void makeCommandLine() {
 			processInventory(x, y + 8);
 			playerCommand = -1;
 			commandVar1 = 0;
-			commandBuffer = "";
+			g_cine->_commandBuffer = "";
 			CursorMan.showMouse(true);
 		}
 	}
@@ -654,8 +650,8 @@ void makeCommandLine() {
 
 				commandVar3[commandVar1] = si;
 				commandVar1++;
-				commandBuffer += " ";
-				commandBuffer += objectTable[si].name;
+				g_cine->_commandBuffer += " ";
+				g_cine->_commandBuffer += g_cine->_objectTable[si].name;
 			}
 		}
 
@@ -673,13 +669,13 @@ void makeCommandLine() {
 
 			playerCommand = -1;
 			commandVar1 = 0;
-			commandBuffer = "";
+			g_cine->_commandBuffer = "";
 		}
 	}
 
 	if (g_cine->getGameType() == Cine::GType_OS || !disableSystemMenu) {
 		isDrawCommandEnabled = 1;
-		renderer->setCommand(commandBuffer);
+		renderer->setCommand(g_cine->_commandBuffer);
 	}
 }
 
@@ -858,7 +854,7 @@ uint16 executePlayerInput() {
 
 	if (allowPlayerInput) { // Player input is allowed
 		if (isDrawCommandEnabled) {
-			renderer->setCommand(commandBuffer);
+			renderer->setCommand(g_cine->_commandBuffer);
 		}
 		isDrawCommandEnabled = 0;
 		limitMouseCheckCount = true;
@@ -906,8 +902,8 @@ uint16 executePlayerInput() {
 						commandVar3[commandVar1] = si;
 						commandVar1++;
 
-						commandBuffer += " ";
-						commandBuffer += objectTable[si].name;
+						g_cine->_commandBuffer += " ";
+						g_cine->_commandBuffer += g_cine->_objectTable[si].name;
 
 						isDrawCommandEnabled = 1;
 
@@ -929,27 +925,27 @@ uint16 executePlayerInput() {
 							playerCommand = -1;
 
 							commandVar1 = 0;
-							commandBuffer = "";
+							g_cine->_commandBuffer = "";
 						} else if (g_cine->getGameType() == Cine::GType_OS) {
 							isDrawCommandEnabled = 1;
-							commandBuffer += commandPrepositionTable[playerCommand];
+							g_cine->_commandBuffer += commandPrepositionTable[playerCommand];
 						}
 
-						renderer->setCommand(commandBuffer);
+						renderer->setCommand(g_cine->_commandBuffer);
 					} else {
-						globalVars[VAR_MOUSE_X_POS] = mouseX;
+						g_cine->_globalVars[VAR_MOUSE_X_POS] = mouseX;
 						if (!mouseX) {
-							globalVars[VAR_MOUSE_X_POS]++;
+							g_cine->_globalVars[VAR_MOUSE_X_POS]++;
 						}
 
-						globalVars[VAR_MOUSE_Y_POS] = mouseY;
+						g_cine->_globalVars[VAR_MOUSE_Y_POS] = mouseY;
 
 						if (g_cine->getGameType() == Cine::GType_OS) {
 							if (!mouseY) {
-								globalVars[VAR_MOUSE_Y_POS]++;
+								g_cine->_globalVars[VAR_MOUSE_Y_POS]++;
 							}
-							globalVars[VAR_MOUSE_X_POS_2ND] = globalVars[VAR_MOUSE_X_POS];
-							globalVars[VAR_MOUSE_Y_POS_2ND] = globalVars[VAR_MOUSE_Y_POS];
+							g_cine->_globalVars[VAR_MOUSE_X_POS_2ND] = g_cine->_globalVars[VAR_MOUSE_X_POS];
+							g_cine->_globalVars[VAR_MOUSE_Y_POS_2ND] = g_cine->_globalVars[VAR_MOUSE_Y_POS];
 						}
 					}
 				}
@@ -961,7 +957,7 @@ uint16 executePlayerInput() {
 
 				if (g_cine->getGameType() == Cine::GType_OS || commandVar2 != objIdx) {
 					if (objIdx != -1) {
-						renderer->setCommand(commandBuffer + " " + objectTable[objIdx].name);
+						renderer->setCommand(g_cine->_commandBuffer + " " + g_cine->_objectTable[objIdx].name);
 					} else {
 						isDrawCommandEnabled = 1;
 					}
@@ -976,19 +972,19 @@ uint16 executePlayerInput() {
 					int16 objIdx;
 					int16 relEntry;
 
-					globalVars[VAR_MOUSE_X_POS] = mouseX;
+					g_cine->_globalVars[VAR_MOUSE_X_POS] = mouseX;
 					if (!mouseX) {
-						globalVars[VAR_MOUSE_X_POS]++;
+						g_cine->_globalVars[VAR_MOUSE_X_POS]++;
 					}
 
-					globalVars[VAR_MOUSE_Y_POS] = mouseY;
+					g_cine->_globalVars[VAR_MOUSE_Y_POS] = mouseY;
 
 					if (g_cine->getGameType() == Cine::GType_OS) {
 						if (!mouseY) {
-							globalVars[VAR_MOUSE_Y_POS]++;
+							g_cine->_globalVars[VAR_MOUSE_Y_POS]++;
 						}
-						globalVars[VAR_MOUSE_X_POS_2ND] = globalVars[VAR_MOUSE_X_POS];
-						globalVars[VAR_MOUSE_Y_POS_2ND] = globalVars[VAR_MOUSE_Y_POS];
+						g_cine->_globalVars[VAR_MOUSE_X_POS_2ND] = g_cine->_globalVars[VAR_MOUSE_X_POS];
+						g_cine->_globalVars[VAR_MOUSE_Y_POS_2ND] = g_cine->_globalVars[VAR_MOUSE_Y_POS];
 					}
 
 					objIdx = getObjectUnderCursor(mouseX, mouseY);
@@ -1020,97 +1016,97 @@ uint16 executePlayerInput() {
 		// Handle possible horizontal movement by keyboard
 		if (xMoveKeyb != kKeybMoveCenterX && allowPlayerInput) {
 			if (xMoveKeyb == kKeybMoveRight) { // moving right
-				const int16 playerFrame = objectTable[1].frame;
-				const int16 playerX = objectTable[1].x;
+				const int16 playerFrame = g_cine->_objectTable[1].frame;
+				const int16 playerX = g_cine->_objectTable[1].x;
 				// TODO: Check if multiplying _width by two here is correct or not
-				const int16 newX = animDataTable[playerFrame]._width * 2 + playerX + 8;
-				globalVars[VAR_MOUSE_X_POS] = globalVars[VAR_MOUSE_X_POS_2ND] = newX;
+				const int16 newX = g_cine->_animDataTable[playerFrame]._width * 2 + playerX + 8;
+				g_cine->_globalVars[VAR_MOUSE_X_POS] = g_cine->_globalVars[VAR_MOUSE_X_POS_2ND] = newX;
 			} else { // moving left
-				const int16 playerX = objectTable[1].x;
+				const int16 playerX = g_cine->_objectTable[1].x;
 				const int16 newX = playerX - 8;
-				globalVars[VAR_MOUSE_X_POS] = globalVars[VAR_MOUSE_X_POS_2ND] = newX;
+				g_cine->_globalVars[VAR_MOUSE_X_POS] = g_cine->_globalVars[VAR_MOUSE_X_POS_2ND] = newX;
 			}
 
 			// Restrain horizontal position to range 0-319
-			if (globalVars[VAR_MOUSE_X_POS] < 0) {
-				globalVars[VAR_MOUSE_X_POS] = globalVars[VAR_MOUSE_X_POS_2ND] = 0;
-			} else if (globalVars[VAR_MOUSE_X_POS] > 319) {
-				globalVars[VAR_MOUSE_X_POS] = globalVars[VAR_MOUSE_X_POS_2ND] = 319;
+			if (g_cine->_globalVars[VAR_MOUSE_X_POS] < 0) {
+				g_cine->_globalVars[VAR_MOUSE_X_POS] = g_cine->_globalVars[VAR_MOUSE_X_POS_2ND] = 0;
+			} else if (g_cine->_globalVars[VAR_MOUSE_X_POS] > 319) {
+				g_cine->_globalVars[VAR_MOUSE_X_POS] = g_cine->_globalVars[VAR_MOUSE_X_POS_2ND] = 319;
 			}
 		}
 
 		// Handle possible vertical movement by keyboard
 		if (yMoveKeyb != kKeybMoveCenterY && allowPlayerInput) {
 			if (yMoveKeyb == kKeybMoveDown) { // moving down
-				const int16 playerFrame = objectTable[1].frame;
-				const int16 playerY = objectTable[1].y;
+				const int16 playerFrame = g_cine->_objectTable[1].frame;
+				const int16 playerY = g_cine->_objectTable[1].y;
 				// TODO: Check if multiplying _height by two here is correct or not
-				const int16 newY = animDataTable[playerFrame]._height * 2 + playerY - 1;
-				globalVars[VAR_MOUSE_Y_POS] = globalVars[VAR_MOUSE_Y_POS_2ND] = newY;
+				const int16 newY = g_cine->_animDataTable[playerFrame]._height * 2 + playerY - 1;
+				g_cine->_globalVars[VAR_MOUSE_Y_POS] = g_cine->_globalVars[VAR_MOUSE_Y_POS_2ND] = newY;
 			} else { // moving up
-				const int16 playerY = objectTable[1].y;
+				const int16 playerY = g_cine->_objectTable[1].y;
 				const int16 newY = playerY - 8;
-				globalVars[VAR_MOUSE_Y_POS] = globalVars[VAR_MOUSE_Y_POS_2ND] = newY;
+				g_cine->_globalVars[VAR_MOUSE_Y_POS] = g_cine->_globalVars[VAR_MOUSE_Y_POS_2ND] = newY;
 			}
 
 			// Restrain vertical position to range 0-199
-			if (globalVars[VAR_MOUSE_Y_POS] < 0) {
-				globalVars[VAR_MOUSE_Y_POS] = globalVars[VAR_MOUSE_Y_POS_2ND] = 0;
-			} else if (globalVars[VAR_MOUSE_Y_POS] > 199) {
-				globalVars[VAR_MOUSE_Y_POS] = globalVars[VAR_MOUSE_Y_POS_2ND] = 199;
+			if (g_cine->_globalVars[VAR_MOUSE_Y_POS] < 0) {
+				g_cine->_globalVars[VAR_MOUSE_Y_POS] = g_cine->_globalVars[VAR_MOUSE_Y_POS_2ND] = 0;
+			} else if (g_cine->_globalVars[VAR_MOUSE_Y_POS] > 199) {
+				g_cine->_globalVars[VAR_MOUSE_Y_POS] = g_cine->_globalVars[VAR_MOUSE_Y_POS_2ND] = 199;
 			}
 		}
 	} else if (egoMovedWithKeyboard && allowPlayerInput) { // FW: Move using keyboard
 		egoMovedWithKeyboard = false;
 
-		switch (globalVars[VAR_MOUSE_X_MODE]) {
+		switch (g_cine->_globalVars[VAR_MOUSE_X_MODE]) {
 		case 1:
-			mouseX = objectTable[1].x + 12;
+			mouseX = g_cine->_objectTable[1].x + 12;
 			break;
 		case 2:
-			mouseX = objectTable[1].x + 7;
+			mouseX = g_cine->_objectTable[1].x + 7;
 			break;
 		default:
-			mouseX = globalVars[VAR_MOUSE_X_POS];
+			mouseX = g_cine->_globalVars[VAR_MOUSE_X_POS];
 			break;
 		}
 
-		switch (globalVars[VAR_MOUSE_Y_MODE]) {
+		switch (g_cine->_globalVars[VAR_MOUSE_Y_MODE]) {
 		case 1:
-			mouseY = objectTable[1].y + 34;
+			mouseY = g_cine->_objectTable[1].y + 34;
 			break;
 		case 2:
-			mouseY = objectTable[1].y + 28;
+			mouseY = g_cine->_objectTable[1].y + 28;
 			break;
 		default:
-			mouseY = globalVars[VAR_MOUSE_Y_POS];
+			mouseY = g_cine->_globalVars[VAR_MOUSE_Y_POS];
 			break;
 		}
 
 		if (var_5E == bgVar0) {
 			var_5E = 0;
 
-			globalVars[VAR_MOUSE_X_POS] = mouseX;
-			globalVars[VAR_MOUSE_Y_POS] = mouseY;
+			g_cine->_globalVars[VAR_MOUSE_X_POS] = mouseX;
+			g_cine->_globalVars[VAR_MOUSE_Y_POS] = mouseY;
 		} else {
 			if (xMoveKeyb) {
 				if (xMoveKeyb == kKeybMoveLeft) {
-					globalVars[VAR_MOUSE_X_POS] = 1;
+					g_cine->_globalVars[VAR_MOUSE_X_POS] = 1;
 				} else {
-					globalVars[VAR_MOUSE_X_POS] = 320;
+					g_cine->_globalVars[VAR_MOUSE_X_POS] = 320;
 				}
 			} else {
-				globalVars[VAR_MOUSE_X_POS] = mouseX;
+				g_cine->_globalVars[VAR_MOUSE_X_POS] = mouseX;
 			}
 
 			if (yMoveKeyb) {
 				if (yMoveKeyb == kKeybMoveUp) {
-					globalVars[VAR_MOUSE_Y_POS] = 1;
+					g_cine->_globalVars[VAR_MOUSE_Y_POS] = 1;
 				} else {
-					globalVars[VAR_MOUSE_Y_POS] = 200;
+					g_cine->_globalVars[VAR_MOUSE_Y_POS] = 200;
 				}
 			} else {
-				globalVars[VAR_MOUSE_Y_POS] = mouseY;
+				g_cine->_globalVars[VAR_MOUSE_Y_POS] = mouseY;
 			}
 		}
 
@@ -1167,27 +1163,27 @@ void drawSprite(Common::List<overlay>::iterator it, const byte *spritePtr, const
 	msk = (byte *)malloc(width * height);
 
 	if (g_cine->getGameType() == Cine::GType_OS) {
-		generateMask(spritePtr, msk, width * height, objectTable[it->objIdx].part);
+		generateMask(spritePtr, msk, width * height, g_cine->_objectTable[it->objIdx].part);
 	} else {
 		memcpy(msk, maskPtr, width * height);
 	}
 
-	for (++it; it != overlayList.end(); ++it) {
+	for (++it; it != g_cine->_overlayList.end(); ++it) {
 		if (it->type != 5) {
 			continue;
 		}
 
-		maskX = objectTable[it->objIdx].x;
-		maskY = objectTable[it->objIdx].y;
+		maskX = g_cine->_objectTable[it->objIdx].x;
+		maskY = g_cine->_objectTable[it->objIdx].y;
 
-		maskSpriteIdx = ABS((int16)(objectTable[it->objIdx].frame));
+		maskSpriteIdx = ABS((int16)(g_cine->_objectTable[it->objIdx].frame));
 
-		maskWidth = animDataTable[maskSpriteIdx]._realWidth;
-		maskHeight = animDataTable[maskSpriteIdx]._height;
-		gfxUpdateSpriteMask(msk, x, y, width, height, animDataTable[maskSpriteIdx].data(), maskX, maskY, maskWidth, maskHeight);
+		maskWidth = g_cine->_animDataTable[maskSpriteIdx]._realWidth;
+		maskHeight = g_cine->_animDataTable[maskSpriteIdx]._height;
+		gfxUpdateSpriteMask(msk, x, y, width, height, g_cine->_animDataTable[maskSpriteIdx].data(), maskX, maskY, maskWidth, maskHeight);
 
 #ifdef DEBUG_SPRITE_MASK
-		gfxFillSprite(animDataTable[maskSpriteIdx].data(), maskWidth, maskHeight, page, maskX, maskY, 1);
+		gfxFillSprite(g_cine->_animDataTable[maskSpriteIdx].data(), maskWidth, maskHeight, page, maskX, maskY, 1);
 #endif
 	}
 
@@ -1199,7 +1195,7 @@ void removeMessages() {
 	Common::List<overlay>::iterator it;
 	bool remove;
 
-	for (it = overlayList.begin(); it != overlayList.end(); ) {
+	for (it = g_cine->_overlayList.begin(); it != g_cine->_overlayList.end(); ) {
 		if (g_cine->getGameType() == Cine::GType_OS) {
 			// NOTE: These are really removeOverlay calls that have been deferred.
 			// In Operation Stealth's disassembly elements are removed from the
@@ -1213,7 +1209,7 @@ void removeMessages() {
 		}
 
 		if (remove) {
-			it = overlayList.erase(it);
+			it = g_cine->_overlayList.erase(it);
 		} else {
 			++it;
 		}
@@ -1255,7 +1251,7 @@ void checkForPendingDataLoad() {
 	}
 
 	if (newObjectName[0] != 0) {
-		overlayList.clear();
+		g_cine->_overlayList.clear();
 
 		loadObject(newObjectName);
 
@@ -1294,15 +1290,13 @@ void addMessage(byte param1, int16 param2, int16 param3, int16 param4, int16 par
 	tmp.width = param4;
 	tmp.color = param5;
 
-	overlayList.push_back(tmp);
+	g_cine->_overlayList.push_back(tmp);
 }
 
-Common::List<SeqListElement> seqList;
-
 void removeSeq(uint16 param1, uint16 param2, uint16 param3) {
 	Common::List<SeqListElement>::iterator it;
 
-	for (it = seqList.begin(); it != seqList.end(); ++it) {
+	for (it = g_cine->_seqList.begin(); it != g_cine->_seqList.end(); ++it) {
 		if (it->objIdx == param1 && it->var4 == param2 && it->varE == param3) {
 			it->var4 = -1;
 			break;
@@ -1313,7 +1307,7 @@ void removeSeq(uint16 param1, uint16 param2, uint16 param3) {
 bool isSeqRunning(uint16 param1, uint16 param2, uint16 param3) {
 	Common::List<SeqListElement>::iterator it;
 
-	for (it = seqList.begin(); it != seqList.end(); ++it) {
+	for (it = g_cine->_seqList.begin(); it != g_cine->_seqList.end(); ++it) {
 		if (it->objIdx == param1 && it->var4 == param2 && it->varE == param3) {
 			// Just to be on the safe side there's a restriction of the
 			// addition's result to 16-bit arithmetic here like in the
@@ -1329,7 +1323,7 @@ void addSeqListElement(uint16 objIdx, int16 param1, int16 param2, int16 frame, i
 	Common::List<SeqListElement>::iterator it;
 	SeqListElement tmp;
 
-	for (it = seqList.begin(); it != seqList.end() && it->varE < param7; ++it) ;
+	for (it = g_cine->_seqList.begin(); it != g_cine->_seqList.end() && it->varE < param7; ++it) ;
 
 	tmp.objIdx = objIdx;
 	tmp.var4 = param1;
@@ -1346,12 +1340,12 @@ void addSeqListElement(uint16 objIdx, int16 param1, int16 param2, int16 frame, i
 	tmp.var1C = 0;
 	tmp.var1E = 0;
 
-	seqList.insert(it, tmp);
+	g_cine->_seqList.insert(it, tmp);
 }
 
 void modifySeqListElement(uint16 objIdx, int16 var4Test, int16 param1, int16 param2, int16 param3, int16 param4) {
 	// Find a suitable list element and modify it
-	for (Common::List<SeqListElement>::iterator it = seqList.begin(); it != seqList.end(); ++it) {
+	for (Common::List<SeqListElement>::iterator it = g_cine->_seqList.begin(); it != g_cine->_seqList.end(); ++it) {
 		if (it->objIdx == objIdx && it->var4 == var4Test) {
 			it->varC  = param1;
 			it->var18 = param2;
@@ -1425,7 +1419,7 @@ uint16 addAni(uint16 param1, uint16 objIdx, const int8 *ptr, SeqListElement &ele
 	// In the original an error string is set and 0 is returned if the following doesn't hold
 	assert(*ptrData);
 
-	di = (objectTable[objIdx].costume + 1) % (*ptrData);
+	di = (g_cine->_objectTable[objIdx].costume + 1) % (*ptrData);
 	++ptrData; // Jump over the just read byte
 	// Here ptr2 seems to be indexing a table of structs (8 bytes per struct):
 	//	struct {
@@ -1446,18 +1440,18 @@ uint16 addAni(uint16 param1, uint16 objIdx, const int8 *ptr, SeqListElement &ele
 		return 0;
 	}
 
-	objectTable[objIdx].x += ptr2[4];
-	objectTable[objIdx].y += ptr2[5];
-	objectTable[objIdx].mask += ptr2[6];
+	g_cine->_objectTable[objIdx].x += ptr2[4];
+	g_cine->_objectTable[objIdx].y += ptr2[5];
+	g_cine->_objectTable[objIdx].mask += ptr2[6];
 
 	if (ptr2[6]) {
 		resetGfxEntityEntry(objIdx);
 	}
 
-	objectTable[objIdx].frame = ptr2[7] + element.var8;
+	g_cine->_objectTable[objIdx].frame = ptr2[7] + element.var8;
 
 	if (param3 || !element.var14) {
-		objectTable[objIdx].costume = di;
+		g_cine->_objectTable[objIdx].costume = di;
 	} else {
 		assert(param4);
 		*param4 = di;
@@ -1476,7 +1470,7 @@ void resetGfxEntityEntry(uint16 objIdx) {
 	bool foundCutPoint = false;
 
 	// Go through the overlay list and partition the whole list into two categories (Type A and type B objects)
-	for (it = overlayList.begin(); it != overlayList.end(); ++it) {
+	for (it = g_cine->_overlayList.begin(); it != g_cine->_overlayList.end(); ++it) {
 		if (it->objIdx == objIdx && it->type != 2 && it->type != 3) { // Type A object
 			aReverseObjs.push_front(*it);
 		} else { // Type B object
@@ -1485,10 +1479,10 @@ void resetGfxEntityEntry(uint16 objIdx) {
 			if (it->type == 2 || it->type == 3) {
 				objectMask = 10000;
 			} else {
-				objectMask = objectTable[it->objIdx].mask;
+				objectMask = g_cine->_objectTable[it->objIdx].mask;
 			}
 
-			if (objectTable[objIdx].mask > objectMask) { // Check for B objects' cut point
+			if (g_cine->_objectTable[objIdx].mask > objectMask) { // Check for B objects' cut point
 				bObjsCutPoint = bObjs.reverse_begin();
 				foundCutPoint = true;
 			}
@@ -1496,26 +1490,26 @@ void resetGfxEntityEntry(uint16 objIdx) {
 	}
 
 	// Recreate the overlay list in a different order.
-	overlayList.clear();
+	g_cine->_overlayList.clear();
 	if (foundCutPoint) {
 		// If a cut point was found the order is:
 		// B objects before the cut point, the cut point, A objects in reverse order, B objects after cut point.
 		++bObjsCutPoint; // Include the cut point in the first list insertion
-		overlayList.insert(overlayList.end(), bObjs.begin(), bObjsCutPoint);
-		overlayList.insert(overlayList.end(), aReverseObjs.begin(), aReverseObjs.end());
-		overlayList.insert(overlayList.end(), bObjsCutPoint, bObjs.end());
+		g_cine->_overlayList.insert(g_cine->_overlayList.end(), bObjs.begin(), bObjsCutPoint);
+		g_cine->_overlayList.insert(g_cine->_overlayList.end(), aReverseObjs.begin(), aReverseObjs.end());
+		g_cine->_overlayList.insert(g_cine->_overlayList.end(), bObjsCutPoint, bObjs.end());
 	} else {
 		// If no cut point was found the order is:
 		// A objects in reverse order, B objects.
-		overlayList.insert(overlayList.end(), aReverseObjs.begin(), aReverseObjs.end());
-		overlayList.insert(overlayList.end(), bObjs.begin(), bObjs.end());
+		g_cine->_overlayList.insert(g_cine->_overlayList.end(), aReverseObjs.begin(), aReverseObjs.end());
+		g_cine->_overlayList.insert(g_cine->_overlayList.end(), bObjs.begin(), bObjs.end());
 	}
 }
 
 void processSeqListElement(SeqListElement &element) {
-	int16 x = objectTable[element.objIdx].x;
-	int16 y = objectTable[element.objIdx].y;
-	const int8 *ptr1 = (const int8 *) animDataTable[element.frame].data();
+	int16 x = g_cine->_objectTable[element.objIdx].x;
+	int16 y = g_cine->_objectTable[element.objIdx].y;
+	const int8 *ptr1 = (const int8 *) g_cine->_animDataTable[element.frame].data();
 	int16 var_10;
 	int16 var_4;
 	int16 var_2;
@@ -1548,8 +1542,8 @@ void processSeqListElement(SeqListElement &element) {
 			int16 x2 = element.var18;
 			int16 y2 = element.var1A;
 			if (element.varC) {
-				x2 += objectTable[element.varC].x;
-				y2 += objectTable[element.varC].y;
+				x2 += g_cine->_objectTable[element.varC].x;
+				y2 += g_cine->_objectTable[element.varC].y;
 			}
 			computeMove1(element, ptr1[4] + x, ptr1[5] + y, param1, param2, x2, y2);
 		} else {
@@ -1558,7 +1552,7 @@ void processSeqListElement(SeqListElement &element) {
 				if (xMoveKeyb != kKeybMoveRight) {
 					adder = -adder;
 				}
-				globalVars[VAR_MOUSE_X_POS] = globalVars[VAR_MOUSE_X_POS_2ND] = ptr1[4] + x + adder;
+				g_cine->_globalVars[VAR_MOUSE_X_POS] = g_cine->_globalVars[VAR_MOUSE_X_POS_2ND] = ptr1[4] + x + adder;
 			}
 
 			if (yMoveKeyb && allowPlayerInput) {
@@ -1566,11 +1560,11 @@ void processSeqListElement(SeqListElement &element) {
 				if (yMoveKeyb != kKeybMoveDown) {
 					adder = -adder;
 				}
-				globalVars[VAR_MOUSE_Y_POS] = globalVars[VAR_MOUSE_Y_POS_2ND] = ptr1[5] + y + adder;
+				g_cine->_globalVars[VAR_MOUSE_Y_POS] = g_cine->_globalVars[VAR_MOUSE_Y_POS_2ND] = ptr1[5] + y + adder;
 			}
 
-			if (globalVars[VAR_MOUSE_X_POS] || globalVars[VAR_MOUSE_Y_POS]) {
-				computeMove1(element, ptr1[4] + x, ptr1[5] + y, param1, param2, globalVars[VAR_MOUSE_X_POS], globalVars[VAR_MOUSE_Y_POS]);
+			if (g_cine->_globalVars[VAR_MOUSE_X_POS] || g_cine->_globalVars[VAR_MOUSE_Y_POS]) {
+				computeMove1(element, ptr1[4] + x, ptr1[5] + y, param1, param2, g_cine->_globalVars[VAR_MOUSE_X_POS], g_cine->_globalVars[VAR_MOUSE_Y_POS]);
 			} else {
 				element.var16 = 0;
 				element.var14 = 0;
@@ -1590,27 +1584,27 @@ void processSeqListElement(SeqListElement &element) {
 			&& !addAni(3, element.objIdx, ptr1, element, 0, &var_4)) || (element.var16 == 2	&& !addAni(2, element.objIdx, ptr1, element, 0,
 			    &var_4))) {
 			if (element.varC == 255) {
-				globalVars[VAR_MOUSE_Y_POS] = 0;
+				g_cine->_globalVars[VAR_MOUSE_Y_POS] = 0;
 			}
 		}
 
 		if ((element.var14 == 1
 			&& !addAni(0, element.objIdx, ptr1, element, 1, &var_2))) {
 			if (element.varC == 255) {
-				globalVars[VAR_MOUSE_X_POS] = 0;
+				g_cine->_globalVars[VAR_MOUSE_X_POS] = 0;
 
 				if (var_4 != -1) {
-					objectTable[element.objIdx].costume = var_4;
+					g_cine->_objectTable[element.objIdx].costume = var_4;
 				}
 			}
 		}
 
 		if ((element.var14 == 2 && !addAni(1, element.objIdx, ptr1, element, 1, &var_2))) {
 			if (element.varC == 255) {
-				globalVars[VAR_MOUSE_X_POS] = 0;
+				g_cine->_globalVars[VAR_MOUSE_X_POS] = 0;
 
 				if (var_4 != -1) {
-					objectTable[element.objIdx].costume = var_4;
+					g_cine->_objectTable[element.objIdx].costume = var_4;
 				}
 			}
 		}
@@ -1618,7 +1612,7 @@ void processSeqListElement(SeqListElement &element) {
 		if (element.var16 + element.var14 == 0) {
 			if (element.var1C) {
 				if (element.var1E) {
-					objectTable[element.objIdx].costume = 0;
+					g_cine->_objectTable[element.objIdx].costume = 0;
 					element.var1E = 0;
 				}
 
@@ -1633,7 +1627,7 @@ void processSeqListElement(SeqListElement &element) {
 void processSeqList() {
 	Common::List<SeqListElement>::iterator it;
 
-	for (it = seqList.begin(); it != seqList.end(); ++it) {
+	for (it = g_cine->_seqList.begin(); it != g_cine->_seqList.end(); ++it) {
 		if (it->var4 == -1) {
 			continue;
 		}