[Scummvm-cvs-logs] SF.net SVN: scummvm:[52661] scummvm/trunk/engines/mohawk

mthreepwood at users.sourceforge.net mthreepwood at users.sourceforge.net
Thu Sep 9 19:27:02 CEST 2010


Revision: 52661
          http://scummvm.svn.sourceforge.net/scummvm/?rev=52661&view=rev
Author:   mthreepwood
Date:     2010-09-09 17:27:02 +0000 (Thu, 09 Sep 2010)

Log Message:
-----------
MOHAWK: Add initial work on the Riven marble puzzle

The marbles are currently drawn, and you can pick them up, but you can not place them on the grid yet.

Modified Paths:
--------------
    scummvm/trunk/engines/mohawk/graphics.cpp
    scummvm/trunk/engines/mohawk/graphics.h
    scummvm/trunk/engines/mohawk/riven.h
    scummvm/trunk/engines/mohawk/riven_cursors.h
    scummvm/trunk/engines/mohawk/riven_external.cpp
    scummvm/trunk/engines/mohawk/riven_external.h

Modified: scummvm/trunk/engines/mohawk/graphics.cpp
===================================================================
--- scummvm/trunk/engines/mohawk/graphics.cpp	2010-09-09 15:09:26 UTC (rev 52660)
+++ scummvm/trunk/engines/mohawk/graphics.cpp	2010-09-09 17:27:02 UTC (rev 52661)
@@ -326,7 +326,7 @@
 		// draw PLST 1 each time. This "hack" is here to catch any PLST attempting to draw
 		// twice. There should never be a problem with doing it this way.
 		if (index == x && !(Common::find(_activatedPLSTs.begin(), _activatedPLSTs.end(), x) != _activatedPLSTs.end())) {
-			debug (0, "Drawing image %d", id);
+			debug(0, "Drawing image %d", id);
 			copyImageToScreen(id, left, top, right, bottom);
 			_activatedPLSTs.push_back(x);
 			break;
@@ -491,95 +491,106 @@
 	_scheduledTransition = -1; // Clear scheduled transition
 }
 
-// TODO: Marble Cursors/Palettes
 void RivenGraphics::changeCursor(uint16 num) {
 	// All of Riven's cursors are hardcoded. See riven_cursors.h for these definitions.
 
 	switch (num) {
 	case 1002:
 		// Zip Mode
-		CursorMan.replaceCursor(zipModeCursor, 16, 16, 8, 8, 0);
-		CursorMan.replaceCursorPalette(zipModeCursorPalette, 1, ARRAYSIZE(zipModeCursorPalette) / 4);
+		CursorMan.replaceCursor(s_zipModeCursor, 16, 16, 8, 8, 0);
+		CursorMan.replaceCursorPalette(s_zipModeCursorPalette, 1, ARRAYSIZE(s_zipModeCursorPalette) / 4);
 		break;
 	case 2003:
 		// Hand Over Object
-		CursorMan.replaceCursor(objectHandCursor, 16, 16, 8, 8, 0);
-		CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+		CursorMan.replaceCursor(s_objectHandCursor, 16, 16, 8, 8, 0);
+		CursorMan.replaceCursorPalette(s_handCursorPalette, 1, ARRAYSIZE(s_handCursorPalette) / 4);
 		break;
 	case 2004:
 		// Grabbing/Using Object
-		CursorMan.replaceCursor(grabbingHandCursor, 13, 13, 6, 6, 0);
-		CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+		CursorMan.replaceCursor(s_grabbingHandCursor, 13, 13, 6, 6, 0);
+		CursorMan.replaceCursorPalette(s_handCursorPalette, 1, ARRAYSIZE(s_handCursorPalette) / 4);
 		break;
 	case 3000:
 		// Standard Hand
-		CursorMan.replaceCursor(standardHandCursor, 15, 16, 6, 0, 0);
-		CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+		CursorMan.replaceCursor(s_standardHandCursor, 15, 16, 6, 0, 0);
+		CursorMan.replaceCursorPalette(s_handCursorPalette, 1, ARRAYSIZE(s_handCursorPalette) / 4);
 		break;
 	case 3001:
 		// Pointing Left
-		CursorMan.replaceCursor(pointingLeftCursor, 15, 13, 0, 3, 0);
-		CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+		CursorMan.replaceCursor(s_pointingLeftCursor, 15, 13, 0, 3, 0);
+		CursorMan.replaceCursorPalette(s_handCursorPalette, 1, ARRAYSIZE(s_handCursorPalette) / 4);
 		break;
 	case 3002:
 		// Pointing Right
-		CursorMan.replaceCursor(pointingRightCursor, 15, 13, 14, 3, 0);
-		CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+		CursorMan.replaceCursor(s_pointingRightCursor, 15, 13, 14, 3, 0);
+		CursorMan.replaceCursorPalette(s_handCursorPalette, 1, ARRAYSIZE(s_handCursorPalette) / 4);
 		break;
 	case 3003:
 		// Pointing Down (Palm Up)
-		CursorMan.replaceCursor(pointingDownCursorPalmUp, 13, 16, 3, 15, 0);
-		CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+		CursorMan.replaceCursor(s_pointingDownCursorPalmUp, 13, 16, 3, 15, 0);
+		CursorMan.replaceCursorPalette(s_handCursorPalette, 1, ARRAYSIZE(s_handCursorPalette) / 4);
 		break;
 	case 3004:
 		// Pointing Up (Palm Up)
-		CursorMan.replaceCursor(pointingUpCursorPalmUp, 13, 16, 3, 0, 0);
-		CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+		CursorMan.replaceCursor(s_pointingUpCursorPalmUp, 13, 16, 3, 0, 0);
+		CursorMan.replaceCursorPalette(s_handCursorPalette, 1, ARRAYSIZE(s_handCursorPalette) / 4);
 		break;
 	case 3005:
 		// Pointing Left (Curved)
-		CursorMan.replaceCursor(pointingLeftCursorBent, 15, 13, 0, 5, 0);
-		CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+		CursorMan.replaceCursor(s_pointingLeftCursorBent, 15, 13, 0, 5, 0);
+		CursorMan.replaceCursorPalette(s_handCursorPalette, 1, ARRAYSIZE(s_handCursorPalette) / 4);
 		break;
 	case 3006:
 		// Pointing Right (Curved)
-		CursorMan.replaceCursor(pointingRightCursorBent, 15, 13, 14, 5, 0);
-		CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+		CursorMan.replaceCursor(s_pointingRightCursorBent, 15, 13, 14, 5, 0);
+		CursorMan.replaceCursorPalette(s_handCursorPalette, 1, ARRAYSIZE(s_handCursorPalette) / 4);
 		break;
 	case 3007:
 		// Pointing Down (Palm Down)
-		CursorMan.replaceCursor(pointingDownCursorPalmDown, 15, 16, 7, 15, 0);
-		CursorMan.replaceCursorPalette(handCursorPalette, 1, ARRAYSIZE(handCursorPalette) / 4);
+		CursorMan.replaceCursor(s_pointingDownCursorPalmDown, 15, 16, 7, 15, 0);
+		CursorMan.replaceCursorPalette(s_handCursorPalette, 1, ARRAYSIZE(s_handCursorPalette) / 4);
 		break;
 	case 4001:
 		// Red Marble
+		CursorMan.replaceCursor(s_redMarbleCursor, 12, 12, 5, 5, 0);
+		CursorMan.replaceCursorPalette(s_redMarbleCursorPalette, 1, ARRAYSIZE(s_redMarbleCursorPalette) / 4);
 		break;
 	case 4002:
 		// Orange Marble
+		CursorMan.replaceCursor(s_orangeMarbleCursor, 12, 12, 5, 5, 0);
+		CursorMan.replaceCursorPalette(s_orangeMarbleCursorPalette, 1, ARRAYSIZE(s_orangeMarbleCursorPalette) / 4);
 		break;
 	case 4003:
 		// Yellow Marble
+		CursorMan.replaceCursor(s_yellowMarbleCursor, 12, 12, 5, 5, 0);
+		CursorMan.replaceCursorPalette(s_yellowMarbleCursorPalette, 1, ARRAYSIZE(s_yellowMarbleCursorPalette) / 4);
 		break;
 	case 4004:
 		// Green Marble
+		CursorMan.replaceCursor(s_greenMarbleCursor, 12, 12, 5, 5, 0);
+		CursorMan.replaceCursorPalette(s_greenMarbleCursorPalette, 1, ARRAYSIZE(s_greenMarbleCursorPalette) / 4);
 		break;
 	case 4005:
 		// Blue Marble
+		CursorMan.replaceCursor(s_blueMarbleCursor, 12, 12, 5, 5, 0);
+		CursorMan.replaceCursorPalette(s_blueMarbleCursorPalette, 1, ARRAYSIZE(s_blueMarbleCursorPalette) / 4);
 		break;
 	case 4006:
-		// Purple Marble
+		// Violet Marble
+		CursorMan.replaceCursor(s_violetMarbleCursor, 12, 12, 5, 5, 0);
+		CursorMan.replaceCursorPalette(s_violetMarbleCursorPalette, 1, ARRAYSIZE(s_violetMarbleCursorPalette) / 4);
 		break;
 	case 5000:
 		// Pellet
-		CursorMan.replaceCursor(pelletCursor, 8, 8, 4, 4, 0);
-		CursorMan.replaceCursorPalette(pelletCursorPalette, 1, ARRAYSIZE(pelletCursorPalette) / 4);
+		CursorMan.replaceCursor(s_pelletCursor, 8, 8, 4, 4, 0);
+		CursorMan.replaceCursorPalette(s_pelletCursorPalette, 1, ARRAYSIZE(s_pelletCursorPalette) / 4);
 		break;
 	case 9000:
 		// Hide Cursor
 		CursorMan.showMouse(false);
 		break;
 	default:
-		error ("Cursor %d does not exist!", num);
+		error("Cursor %d does not exist!", num);
 	}
 
 	if (num != 9000) // Show Cursor
@@ -696,6 +707,22 @@
 	_dirtyScreen = true;
 }
 
+void RivenGraphics::drawExtrasImage(uint16 id, Common::Rect dstRect) {
+	ImageData *imageData = _bitmapDecoder->decodeImage(_vm->getExtrasResource(ID_TBMP, id));
+	Graphics::Surface *surface = imageData->getSurface();
+	delete imageData;
+
+	assert(dstRect.width() == surface->w);
+
+	for (uint16 i = 0; i < surface->h; i++)
+		memcpy(_mainScreen->getBasePtr(dstRect.left, i + dstRect.top), surface->getBasePtr(0, i), surface->pitch);
+
+	surface->free();
+	delete surface;
+
+	_dirtyScreen = true;
+}
+
 LBGraphics::LBGraphics(MohawkEngine_LivingBooks *vm) : _vm(vm) {
 	_bmpDecoder = (_vm->getGameType() == GType_LIVINGBOOKSV1) ? new OldMohawkBitmap() : new MohawkBitmap();
 	_palette = new byte[256 * 4];

Modified: scummvm/trunk/engines/mohawk/graphics.h
===================================================================
--- scummvm/trunk/engines/mohawk/graphics.h	2010-09-09 15:09:26 UTC (rev 52660)
+++ scummvm/trunk/engines/mohawk/graphics.h	2010-09-09 17:27:02 UTC (rev 52661)
@@ -150,6 +150,7 @@
 	void drawPLST(uint16 x);
 	void drawRect(Common::Rect rect, bool active);
 	void drawImageRect(uint16 id, Common::Rect srcRect, Common::Rect dstRect);
+	void drawExtrasImage(uint16 id, Common::Rect dstRect);
 
 	// Water Effect
 	void scheduleWaterEffect(uint16);

Modified: scummvm/trunk/engines/mohawk/riven.h
===================================================================
--- scummvm/trunk/engines/mohawk/riven.h	2010-09-09 15:09:26 UTC (rev 52660)
+++ scummvm/trunk/engines/mohawk/riven.h	2010-09-09 17:27:02 UTC (rev 52661)
@@ -141,7 +141,6 @@
 	// Hotspot related functions and variables
 	uint16 _hotspotCount;
 	void loadHotspots(uint16);
-	void checkHotspotChange();
 	void checkInventoryClick();
 	bool _showHotspots;
 	void updateZipMode();
@@ -176,6 +175,7 @@
 	void runHotspotScript(uint16 hotspot, uint16 scriptType);
 	int32 getCurHotspot() const { return _curHotspot; }
 	Common::String getHotspotName(uint16 hotspot);
+	void checkHotspotChange();
 
 	// Variable functions
 	void initVars();

Modified: scummvm/trunk/engines/mohawk/riven_cursors.h
===================================================================
--- scummvm/trunk/engines/mohawk/riven_cursors.h	2010-09-09 15:09:26 UTC (rev 52660)
+++ scummvm/trunk/engines/mohawk/riven_cursors.h	2010-09-09 17:27:02 UTC (rev 52661)
@@ -37,7 +37,7 @@
 //    1 = Black		(0x000000)
 //    2 = Yellow	(0xDCFF00)
 ////////////////////////////////////////
-static const byte zipModeCursor[] = {
+static const byte s_zipModeCursor[] = {
 	1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -61,7 +61,7 @@
 // Zip Mode Cursor Palette:
 //    Palette For The Zip Mode Cursor
 ////////////////////////////////////////
-static const byte zipModeCursorPalette[] = {
+static const byte s_zipModeCursorPalette[] = {
 	0x00, 0x00, 0x00,	0x00,		// Black
 	0xDC, 0xFF, 0x00,	0x00,		// Yellow
 };
@@ -77,7 +77,7 @@
 //    3 = Brown			(0x8A672F)
 //    4 = Dark Peach	(0xE89A62)
 ////////////////////////////////////////
-static const byte objectHandCursor[] = {
+static const byte s_objectHandCursor[] = {
 	0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 1, 1, 0, 1, 2, 3, 1, 1, 1, 0, 0, 0, 0,
 	0, 0, 1, 2, 3, 1, 1, 2, 3, 1, 2, 3, 1, 0, 0, 0,
@@ -107,7 +107,7 @@
 //    3 = Brown			(0x8A672F)
 //    4 = Dark Peach	(0xE89A62)
 ////////////////////////////////////////
-static const byte grabbingHandCursor[] = {
+static const byte s_grabbingHandCursor[] = {
 	0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
 	0, 0, 1, 1, 1, 2, 3, 1, 1, 1, 0, 0, 0,
 	0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 1, 0,
@@ -134,7 +134,7 @@
 //    3 = Brown			(0x8A672F)
 //    4 = Dark Peach	(0xE89A62)
 ////////////////////////////////////////
-static const byte standardHandCursor[] = {
+static const byte s_standardHandCursor[] = {
 	0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 1, 4, 4, 1, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 1, 2, 3, 1, 0, 0, 0, 0, 0, 0,
@@ -164,7 +164,7 @@
 //    3 = Brown			(0x8A672F)
 //    4 = Dark Peach	(0xE89A62)
 ////////////////////////////////////////
-static const byte pointingLeftCursor[] = {
+static const byte s_pointingLeftCursor[] = {
 	0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 1, 3, 2, 2, 2, 1, 1, 0, 0,
 	0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 3, 1, 1,
@@ -191,7 +191,7 @@
 //    3 = Brown			(0x8A672F)
 //    4 = Dark Peach	(0xE89A62)
 ////////////////////////////////////////
-static const byte pointingRightCursor[] = {
+static const byte s_pointingRightCursor[] = {
 	0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 1, 1, 2, 2, 2, 3, 1, 0, 0, 0, 0, 0, 0,
 	1, 1, 3, 4, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0,
@@ -218,7 +218,7 @@
 //    3 = Brown			(0x8A672F)
 //    4 = Dark Peach	(0xE89A62)
 ////////////////////////////////////////
-static const byte pointingDownCursorPalmUp[] = {
+static const byte s_pointingDownCursorPalmUp[] = {
 	0, 0, 1, 4, 2, 2, 2, 2, 2, 4, 1, 0, 0,
 	0, 0, 1, 4, 2, 2, 4, 2, 2, 2, 4, 1, 0,
 	0, 1, 3, 4, 2, 2, 4, 4, 4, 4, 4, 1, 0,
@@ -248,7 +248,7 @@
 //    3 = Brown			(0x8A672F)
 //    4 = Dark Peach	(0xE89A62)
 ////////////////////////////////////////
-static const byte pointingUpCursorPalmUp[] = {
+static const byte s_pointingUpCursorPalmUp[] = {
 	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 1, 4, 4, 1, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 1, 0, 0,
@@ -278,7 +278,7 @@
 //    3 = Brown			(0x8A672F)
 //    4 = Dark Peach	(0xE89A62)
 ////////////////////////////////////////
-static const byte pointingLeftCursorBent[] = {
+static const byte s_pointingLeftCursorBent[] = {
 	0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 1, 3, 2, 2, 2, 1, 1, 0, 0,
 	0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 3, 1, 1,
@@ -305,7 +305,7 @@
 //    3 = Brown			(0x8A672F)
 //    4 = Dark Peach	(0xE89A62)
 ////////////////////////////////////////
-static const byte pointingRightCursorBent[] = {
+static const byte s_pointingRightCursorBent[] = {
 	0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 1, 1, 2, 2, 2, 3, 1, 0, 0, 0, 0, 0, 0,
 	1, 1, 3, 4, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0,
@@ -332,7 +332,7 @@
 //    3 = Brown			(0x8A672F)
 //    4 = Dark Peach	(0xE89A62)
 ////////////////////////////////////////
-static const byte pointingDownCursorPalmDown[] = {
+static const byte s_pointingDownCursorPalmDown[] = {
 	0, 1, 3, 4, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0,
 	0, 1, 3, 4, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0, 0,
 	0, 1, 3, 2, 2, 2, 2, 2, 2, 2, 1, 0, 0, 0, 0,
@@ -355,7 +355,7 @@
 // Hand Cursor Palette:
 //    Palette For All Hand Cursors
 ////////////////////////////////////////
-static const byte handCursorPalette[] = {
+static const byte s_handCursorPalette[] = {
 	0x00, 0x00, 0x00,	0x00,		// Black
 	0xED, 0xCD, 0x96,	0x00,		// Light Peach
 	0x8A, 0x67, 0x2F,	0x00,		// Brown
@@ -376,7 +376,7 @@
 //    6 = Dark Green			(0x2D3300)
 //    7 = Darkest Gray			(0x222222)
 ////////////////////////////////////////
-static const byte pelletCursor[] = {
+static const byte s_pelletCursor[] = {
 	0, 0, 1, 1, 2, 3, 0, 0,
 	0, 2, 1, 4, 1, 2, 5, 0,
 	4, 1, 4, 1, 2, 1, 5, 4,
@@ -391,7 +391,7 @@
 // Pellet Cursor Palette:
 //    Palette For The Pellet Cursor
 ////////////////////////////////////////
-static const byte pelletCursorPalette[] = {
+static const byte s_pelletCursorPalette[] = {
 	0x5D, 0x67, 0x30,	0x00,
 	0x5E, 0x33, 0x33,	0x00,
 	0x55, 0x55, 0x55,	0x00,
@@ -401,4 +401,270 @@
 	0x22, 0x22, 0x22,	0x00
 };
 
+////////////////////////////////////////
+// Red Marble Cursor (12x12):
+//    Cursor When Holding The Red Marble
+////////////////////////////////////////
+static const byte s_redMarbleCursor[] = {
+	0, 0, 0, 0, 1, 2, 2, 2, 0, 0, 0, 0,
+	0, 0, 3, 4, 2, 5, 2, 2, 2, 2, 0, 0,
+	0, 6, 1, 1, 2, 2, 5, 2, 2, 2, 2, 0,
+	0, 6, 3, 4, 5, 2, 2, 7, 8, 5, 2, 0,
+	9, 6, 10,11,2, 2, 2, 12,13,2, 2, 2,
+	14,10,6, 4, 1, 2, 8, 2, 2, 5, 2, 2,
+	15,16,6, 3, 1, 2, 2, 2, 2, 2, 2, 5,
+	17,9,18, 3, 4, 4, 4, 5, 2, 5, 1, 2,
+	0, 16,9, 6, 6, 19,1, 20,1, 4, 11,0,
+	0, 17,15,18,9, 10,6, 10,3, 21,4, 0,
+	0, 0, 18,15,9, 18,6, 22,10,23,0, 0,
+	0, 0, 0, 0, 15,15,16,9, 0, 0, 0, 0
+};
+
+
+////////////////////////////////////////
+// Red Marble Cursor Palette:
+//    Palette For The Red Marble Cursor
+////////////////////////////////////////
+static const byte s_redMarbleCursorPalette[] = {
+	0xb8, 0x33, 0x32,	0x00,
+	0xe5, 0x33, 0x31,	0x00,
+	0x98, 0x06, 0x00,	0x00,
+	0xb8, 0x00, 0x34,	0x00,
+	0xe6, 0x00, 0x34,	0x00,
+	0x7a, 0x04, 0x00,	0x00,
+	0xe8, 0x9a, 0x62,	0x00,
+	0xea, 0x31, 0x67,	0x00,
+	0x6a, 0x03, 0x00,	0x00,
+	0x8c, 0x00, 0x35,	0x00,
+	0xb6, 0x36, 0x00,	0x00,
+	0xed, 0xcd, 0x96,	0x00,
+	0xe9, 0x66, 0x65,	0x00,
+	0x5b, 0x35, 0x00,	0x00,
+	0x5b, 0x02, 0x00,	0x00,
+	0x5f, 0x00, 0x35,	0x00,
+	0x4c, 0x01, 0x00,	0x00,
+	0x5e, 0x33, 0x33,	0x00,
+	0x89, 0x05, 0x00,	0x00,
+	0xb6, 0x08, 0x00,	0x00,
+	0xa7, 0x07, 0x00,	0x00,
+	0x88, 0x36, 0x00,	0x00,
+	0x8b, 0x33, 0x33,	0x00
+};
+
+////////////////////////////////////////
+// Orange Marble Cursor (12x12):
+//    Cursor When Holding The Orange Marble
+////////////////////////////////////////
+static const byte s_orangeMarbleCursor[] = {
+	0, 0, 0, 0, 1, 2, 2, 3, 0, 0, 0, 0,
+	0, 0, 4, 5, 2, 2, 3, 3, 3, 3, 0, 0,
+	0, 6, 7, 4, 2, 1, 2, 2, 3, 3, 3, 0,
+	0, 6, 6, 7, 1, 2, 3, 8, 9, 2, 10,0,
+	11,12,7, 4, 2, 3, 3, 13,9, 2, 2, 1,
+	14,15,6, 4, 2, 16,3, 3, 2, 1, 1, 1,
+	14,14,12,17,4, 2, 2, 1, 2, 1, 2, 1,
+	14,18,12,6, 4, 4, 4, 19,2, 19,20,4,
+	0, 14,14,15,6, 15,6, 4, 4, 4, 4, 0,
+	0, 14,11,14,14,12,12,12,17,6, 17,0,
+	0, 0, 14,14,17,14,17,6, 6, 17,0, 0,
+	0, 0, 0, 0, 14,11,14,11,0, 0, 0, 0
+};
+
+////////////////////////////////////////
+// Orange Marble Cursor Palette:
+//    Palette For The Orange Marble Cursor
+////////////////////////////////////////
+static const byte s_orangeMarbleCursorPalette[] = {
+	0xe1, 0x9e, 0x00,	0x00,
+	0xe3, 0x9b, 0x28,	0x00,
+	0xe2, 0xcf, 0x20,	0x00,
+	0xb5, 0x6a, 0x00,	0x00,
+	0xb6, 0x9b, 0x29,	0x00,
+	0x87, 0x69, 0x00,	0x00,
+	0xb7, 0x67, 0x2f,	0x00,
+	0xe9, 0xff, 0x93,	0x00,
+	0xe1, 0xff, 0x5a,	0x00,
+	0xe0, 0xd0, 0x00,	0x00,
+	0x5e, 0x33, 0x33,	0x00,
+	0x88, 0x36, 0x00,	0x00,
+	0xf3, 0xff, 0xc9,	0x00,
+	0x5b, 0x35, 0x00,	0x00,
+	0x8b, 0x33, 0x33,	0x00,
+	0xe6, 0xce, 0x5f,	0x00,
+	0x8a, 0x67, 0x2f,	0x00,
+	0x5d, 0x67, 0x30,	0x00,
+	0xe2, 0x6a, 0x00,	0x00,
+	0xb3, 0x9d, 0x00,	0x00
+};
+
+////////////////////////////////////////
+// Yellow Marble Cursor (12x12):
+//    Cursor When Holding The Yellow Marble
+////////////////////////////////////////
+static const byte s_yellowMarbleCursor[] = {
+	0, 0, 0, 0, 1, 1, 1, 2, 0, 0, 0, 0,
+	0, 0, 3, 4, 1, 1, 1, 5, 6, 6, 0, 0,
+	0, 3, 3, 7, 1, 1, 1, 1, 2, 1, 6, 0,
+	0, 3, 3, 3, 3, 1, 1, 8, 6, 1, 6, 0,
+	9, 9, 3, 3, 1, 1, 2, 10,8, 1, 1, 2,
+	11,9, 3, 3, 1, 1, 1, 1, 1, 1, 5, 1,
+	9, 9, 12,3, 3, 1, 1, 1, 1, 1, 1, 1,
+	9, 9, 9, 3, 3, 3, 3, 3, 1, 1, 1, 1,
+	0, 11,9, 9, 12,3, 3, 3, 3, 3, 3, 0,
+	0, 9, 9, 13,9, 14,12,3, 3, 3, 3, 0,
+	0, 0, 9, 9, 9, 12,14,3, 13,3, 0, 0,
+	0, 0, 0, 0, 11,9, 11,9, 0, 0, 0, 0
+};
+
+////////////////////////////////////////
+// Yellow Marble Cursor Palette:
+//    Palette For The Yellow Marble Cursor
+////////////////////////////////////////
+static const byte s_yellowMarbleCursorPalette[] = {
+	0xb3, 0xd0, 0x00,	0x00,
+	0xb0, 0xff, 0x00,	0x00,
+	0x86, 0x9c, 0x00,	0x00,
+	0x87, 0xd0, 0x00,	0x00,
+	0xe0, 0xd0, 0x00,	0x00,
+	0xdc, 0xff, 0x00,	0x00,
+	0xb3, 0x9d, 0x00,	0x00,
+	0xdc, 0xff, 0x11,	0x00,
+	0x5a, 0x68, 0x00,	0x00,
+	0xe1, 0xff, 0x5a,	0x00,
+	0x5d, 0x67, 0x30,	0x00,
+	0x87, 0x69, 0x00,	0x00,
+	0x88, 0x9b, 0x2a,	0x00,
+	0x5a, 0x9c, 0x00,	0x00
+};
+
+////////////////////////////////////////
+// Green Marble Cursor (12x12):
+//    Cursor When Holding The Green Marble
+////////////////////////////////////////
+static const byte s_greenMarbleCursor[] = {
+	0, 0, 0, 0, 1, 2, 3, 3, 0, 0, 0, 0,
+	0, 0, 4, 5, 2, 1, 2, 3, 6, 6, 0, 0,
+	0, 7, 5, 8, 8, 1, 1, 2, 3, 6, 6, 0,
+	0, 7, 7, 4, 8, 1, 2, 9, 6, 2, 6, 0,
+	10,7, 7, 4, 1, 2, 3, 11,12,2, 2, 3,
+	13,13,7, 4, 1, 2, 3, 2, 1, 2, 2, 3,
+	14,13,7, 7, 5, 1, 1, 8, 2, 1, 1, 2,
+	15,16,13,7, 4, 4, 5, 5, 1, 8, 1, 1,
+	0, 15,13,7, 7, 7, 4, 4, 4, 5, 8, 0,
+	0, 14,16,15,13, 7, 7, 7, 4,17,5, 0,
+	0, 0, 10,16,13,13,13,17,18,17,0, 0,
+	0, 0, 0, 0, 15,10,19,10,0, 0, 0, 0
+};
+
+////////////////////////////////////////
+// Green Marble Cursor Palette:
+//    Palette For The Green Marble Cursor
+////////////////////////////////////////
+static const byte s_greenMarbleCursorPalette[] = {
+	0x0e, 0xd0, 0x00,	0x00,
+	0x0f, 0xe1, 0x00,	0x00,
+	0x10, 0xf2, 0x00,	0x00,
+	0x0b, 0x9c, 0x00,	0x00,
+	0x0c, 0xad, 0x00,	0x00,
+	0x11, 0xff, 0x00,	0x00,
+	0x09, 0x8a, 0x00,	0x00,
+	0x0d, 0xbe, 0x00,	0x00,
+	0x30, 0xff, 0x5a,	0x00,
+	0x0d, 0x67, 0x30,	0x00,
+	0x6b, 0xff, 0x92,	0x00,
+	0x00, 0xff, 0x28,	0x00,
+	0x08, 0x79, 0x00,	0x00,
+	0x05, 0x57, 0x00,	0x00,
+	0x30, 0x67, 0x30,	0x00,
+	0x06, 0x68, 0x00,	0x00,
+	0x00, 0x9b, 0x2c,	0x00,
+	0x2e, 0x9c, 0x00,	0x00,
+	0x2e, 0x68, 0x00,	0x00
+};
+
+////////////////////////////////////////
+// Blue Marble Cursor (12x12):
+//    Cursor When Holding The Blue Marble
+////////////////////////////////////////
+static const byte s_blueMarbleCursor[] = {
+	0, 0, 0, 0, 1, 2, 3, 3, 0, 0, 0, 0,
+	0, 0, 4, 5, 2, 2, 6, 3, 7, 3, 0, 0,
+	0, 8, 9, 5, 10,11,2, 6, 3, 3, 7, 0,
+	0, 12,13,9, 10,11,6, 14,7, 6, 3, 0,
+	15,8, 4, 13,2, 6, 3, 16,17,6, 6, 3,
+	18,15,19,13,10,7, 3, 6, 2, 2, 6, 7,
+	20,8, 18,4, 21,11,2, 10,6, 2, 2, 2,
+	15,15,18,8, 13,9, 21,5, 11,10,2, 1,
+	0, 8, 15,19,15,13,13,21,21,5, 9, 0,
+	0, 22,20,15, 8,19,15,19,4, 9, 4, 0,
+	0, 0, 15,20,15,15,19,15,9, 15,0, 0,
+	0, 0, 0, 0, 20,15, 8,15,0, 0, 0, 0
+};
+
+////////////////////////////////////////
+// Blue Marble Cursor Palette:
+//    Palette For The Blue Marble Cursor
+////////////////////////////////////////
+static const byte s_blueMarbleCursorPalette[] = {
+	0x6b, 0x00, 0xd2,	0x00,
+	0x66, 0x00, 0xe3,	0x00,
+	0x72, 0x00, 0xff,	0x00,
+	0x53, 0x2d, 0x9d,	0x00,
+	0x4e, 0x00, 0xaf,	0x00,
+	0x6d, 0x00, 0xf5,	0x00,
+	0x7d, 0x00, 0xff,	0x00,
+	0x44, 0x00, 0x69,	0x00,
+	0x56, 0x00, 0x9d,	0x00,
+	0x56, 0x00, 0xc0,	0x00,
+	0x5e, 0x00, 0xd2,	0x00,
+	0x2b, 0x31, 0x68,	0x00,
+	0x3f, 0x00, 0x8c,	0x00,
+	0x91, 0x22, 0xff,	0x00,
+	0x41, 0x31, 0x68,	0x00,
+	0xd7, 0x95, 0xff,	0x00,
+	0x77, 0x22, 0xff,	0x00,
+	0x2f, 0x00, 0x69,	0x00,
+	0x37, 0x00, 0x7a,	0x00,
+	0x27, 0x00, 0x58,	0x00,
+	0x46, 0x00, 0x9d,	0x00,
+	0x33, 0x33, 0x33,	0x00
+};
+
+////////////////////////////////////////
+// Violet Marble Cursor (12x12):
+//    Cursor When Holding The Violet Marble
+////////////////////////////////////////
+static const byte s_violetMarbleCursor[] = {
+	0, 0, 0, 0, 1, 1, 1, 2, 0, 0, 0, 0,
+	0, 0, 3, 3, 1, 1, 1, 4, 2, 4, 0, 0,
+	0, 3, 3, 3, 1, 5, 1, 1, 4, 2, 4, 0,
+	0, 3, 3, 3, 3, 1, 1, 6, 4, 1, 2, 0,
+	3, 7, 8, 3, 1, 1, 4, 9, 4, 1, 1, 4,
+	8, 7, 8, 3, 10,4, 1, 1, 1, 1, 4, 1,
+	8, 3, 8, 7, 3, 1, 1, 5, 1, 1, 1, 1,
+	7, 7, 11,3, 3, 3, 3, 3, 1, 3, 1, 1,
+	0, 8, 7, 7, 8, 8, 7, 3, 3, 3, 1, 0,
+	0, 7, 8, 3, 11,7, 3, 11,3, 10,3, 0,
+	0, 0, 8, 7, 3, 3, 7, 3, 3, 3, 0, 0,
+	0, 0, 0, 0, 8, 7, 11,3, 0, 0, 0, 0
+};
+
+////////////////////////////////////////
+// Violet Marble Cursor Palette:
+//    Palette For The Violet Marble Cursor
+////////////////////////////////////////
+static const byte s_violetMarbleCursorPalette[] = {
+	0xaa, 0x00, 0xd1,	0x00,
+	0xd8, 0x00, 0xff,	0x00,
+	0x76, 0x00, 0x9d,	0x00,
+	0xb5, 0x00, 0xff,	0x00,
+	0x87, 0x00, 0xd2,	0x00,
+	0xd7, 0x22, 0xff,	0x00,
+	0x68, 0x00, 0x69,	0x00,
+	0x44, 0x00, 0x69,	0x00,
+	0xd7, 0x5e, 0xff,	0x00,
+	0x9c, 0x00, 0x9d,	0x00,
+	0x56, 0x00, 0x9d,	0x00
+};
+
 } // End of namespace Mohawk

Modified: scummvm/trunk/engines/mohawk/riven_external.cpp
===================================================================
--- scummvm/trunk/engines/mohawk/riven_external.cpp	2010-09-09 15:09:26 UTC (rev 52660)
+++ scummvm/trunk/engines/mohawk/riven_external.cpp	2010-09-09 17:27:02 UTC (rev 52661)
@@ -1928,28 +1928,146 @@
 	_vm->_gfx->hideInventory();
 }
 
+// Marble Puzzle related constants
+static const uint32 kMarbleCount = 6;
+static const int kSmallMarbleWidth = 4;
+static const int kSmallMarbleHeight = 2;
+static const int kLargeMarbleSize = 8;
+static const int kMarbleHotspotSize = 13;
+static const char *s_marbleNames[] = { "tred", "torange", "tyellow", "tgreen", "tblue", "tviolet" };
+
+#if 0
+// Marble Puzzle helper functions
+// The y portion takes the upper 16 bits, while the x portion takes the lower 16 bits
+static void setMarbleX(uint32 *var, byte x) {
+	*var = (*var & 0xff00) | x;
+}
+
+static void setMarbleY(uint32 *var, byte y) {
+	*var = (y << 16) | (*var & 0xff);
+}
+
+static byte getMarbleX(uint32 *var) {
+	return *var & 0xff;
+}
+
+static byte getMarbleY(uint32 *var) { // Give that that Y you old hag!
+	return (*var >> 16) & 0xff;
+}
+#endif
+
 void RivenExternal::xt7500_checkmarbles(uint16 argc, uint16 *argv) {
-	// TODO: Lots of stuff to do here, eventually we have to check each individual
-	// marble position and set apower based on that. The game handles the video playing
-	// so we don't have to. For the purposes of making the game progress further, we'll
-	// just turn the power on for now.
+	// TODO: Set apower if the marbles are in their correct spot. 
+	// HACK: For the purposes of making the game progress further, we'll just turn the
+	// power on for now.
 	*_vm->getVar("apower") = 1;
 }
 
 void RivenExternal::xt7600_setupmarbles(uint16 argc, uint16 *argv) {
-	// TODO: Marble puzzle related
+	// Draw the small marbles when we're a step away from the waffle
+	uint16 baseBitmapId = (_vm->getFeatures() & GF_DVD) ? 539 : 526;
+	bool waffleDown = *_vm->getVar("twaffle") != 0;
+
+	// Note that each of the small marble images is exactly 4x2
+
+	for (uint16 i = 0; i < kMarbleCount; i++) {
+		uint32 *var = _vm->getVar(s_marbleNames[i]);
+
+		if (*var == 0) {
+			// The marble is still in its initial place
+			// (Note that this is still drawn even if the waffle is down)
+			int marbleX = 376 + i * 2;
+			int marbleY = 253 + i * 4;
+			_vm->_gfx->copyImageToScreen(baseBitmapId + i, marbleX, marbleY, marbleX + kSmallMarbleWidth, marbleY + kSmallMarbleHeight);
+		} else if (waffleDown) {
+			// The marble is on the grid and the waffle is down
+			// (Nothing to draw here)
+		} else {
+			// The marble is on the grid and the waffle is up
+			// TODO: Draw them onto the grid
+		}
+	}
 }
 
+void RivenExternal::setMarbleHotspots() {
+	// TODO: Set the hotspots
+}
+
 void RivenExternal::xt7800_setup(uint16 argc, uint16 *argv) {
-	// TODO: Marble puzzle related
+	// Move the marble hotspots based on their position variables
+	setMarbleHotspots();
+	*_vm->getVar("themarble") = 0;
 }
 
+void RivenExternal::drawMarbles() {
+	for (uint32 i = 0; i < kMarbleCount; i++) {
+		// Don't draw the marble if we're holding it
+		if (*_vm->getVar("themarble") - 1 == i)
+			continue;
+
+		Common::Rect rect = _vm->_hotspots[i + 3].rect;
+		// Trim the rect down a bit
+		rect.left += 3;
+		rect.top += 3;
+		rect.right -= 2;
+		rect.bottom -= 2;
+		_vm->_gfx->drawExtrasImage(i + 200, rect);
+	}
+}
+
 void RivenExternal::xdrawmarbles(uint16 argc, uint16 *argv) {
-	// TODO: Marble puzzle related
+	// Draw marbles in the closeup
+	drawMarbles();
+
+	// We have to re-enable the updates here
+	// Would be really nice if the scripts did this for us, but alas...
+	_vm->_gfx->_updatesEnabled = true;
 }
 
 void RivenExternal::xtakeit(uint16 argc, uint16 *argv) {
-	// TODO: Marble puzzle related
+	// Pick up and move a marble
+
+	// First, let's figure out what marble we're now holding
+	uint32 *marble = _vm->getVar("themarble");
+	*marble = 0;
+
+	for (uint32 i = 0; i < kMarbleCount; i++)
+		if (_vm->_hotspots[i + 3].rect.contains(_vm->_system->getEventManager()->getMousePos())) {
+			*marble = i + 1;
+			break;
+		}
+
+	// xtakeit() shouldn't be called if we're not on a marble hotspot
+	assert(*marble);
+
+	// Redraw the background
+	_vm->_gfx->drawPLST(1);
+	_vm->_gfx->updateScreen();
+
+	// Loop until the player lets go (or quits)
+	Common::Event event;
+	bool mouseDown = true;
+	while (mouseDown) {
+		while (_vm->_system->getEventManager()->pollEvent(event)) {
+			if (event.type == Common::EVENT_LBUTTONUP)
+				mouseDown = false;
+			else if (event.type == Common::EVENT_MOUSEMOVE)
+				_vm->_system->updateScreen();
+			else if (event.type == Common::EVENT_QUIT || event.type == Common::EVENT_RTL)
+				return;
+		}
+
+		_vm->_system->delayMillis(10); // Take it easy on the CPU
+	}
+
+	// TODO: Check if we landed in a valid location and no other marble has that location
+
+	// Check the new hotspots and refresh everything
+	*marble = 0;
+	setMarbleHotspots();
+	_vm->_curHotspot = -1;
+	_vm->checkHotspotChange();
+	_vm->_gfx->updateScreen();
 }
 
 void RivenExternal::xtscpbtn(uint16 argc, uint16 *argv) {

Modified: scummvm/trunk/engines/mohawk/riven_external.h
===================================================================
--- scummvm/trunk/engines/mohawk/riven_external.h	2010-09-09 15:09:26 UTC (rev 52660)
+++ scummvm/trunk/engines/mohawk/riven_external.h	2010-09-09 17:27:02 UTC (rev 52661)
@@ -69,6 +69,8 @@
 	void checkSliderCursorChange(uint16 startHotspot);
 	void dragDomeSlider(uint16 bitmapId, uint16 soundId, uint16 resetSlidersHotspot, uint16 openDomeHotspot, uint16 startHotspot);
 	void drawDomeSliders(uint16 bitmapId, uint16 startHotspot);
+	void drawMarbles();
+	void setMarbleHotspots();
 
 	// -----------------------------------------------------
 	// aspit (Main Menu, Books, Setup) external commands


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




More information about the Scummvm-git-logs mailing list