Merge remote branch 'upstream/master' into pegasus

1 files changed, 348 insertions, 87 deletions

diff --git a/engines/hugo/schedule.cpp b/engines/hugo/schedule.cpp
index 5843c2317e..0e91124a7e 100644
--- a/engines/hugo/schedule.cpp
+++ b/engines/hugo/schedule.cpp
@@ -32,7 +32,9 @@
 
 // This module contains all the scheduling and timing stuff
 
+#include "common/debug.h"
 #include "common/system.h"
+#include "common/textconsole.h"
 
 #include "hugo/hugo.h"
 #include "hugo/schedule.h"
@@ -708,21 +710,19 @@ void Scheduler::saveEvents(Common::WriteStream *f) {
 	f->writeSint16BE(tailIndex);
 
 	// Convert event ptrs to indexes
-	event_t  saveEventArr[kMaxEvents];              // Convert event ptrs to indexes
 	for (int16 i = 0; i < kMaxEvents; i++) {
 		event_t *wrkEvent = &_events[i];
-		saveEventArr[i] = *wrkEvent;
 
- 		// fix up action pointer (to do better)
+		// fix up action pointer (to do better)
 		int16 index, subElem;
-		findAction(saveEventArr[i].action, &index, &subElem);
-		saveEventArr[i].action = (act*)((index << 16)| subElem);
-
-		saveEventArr[i].prevEvent = (wrkEvent->prevEvent == 0) ? (event_t *) - 1 : (event_t *)(wrkEvent->prevEvent - _events);
-		saveEventArr[i].nextEvent = (wrkEvent->nextEvent == 0) ? (event_t *) - 1 : (event_t *)(wrkEvent->nextEvent - _events);
+		findAction(wrkEvent->action, &index, &subElem);
+		f->writeSint16BE(index);
+		f->writeSint16BE(subElem);
+		f->writeByte((wrkEvent->localActionFl) ? 1 : 0);
+		f->writeUint32BE(wrkEvent->time);
+		f->writeSint16BE((wrkEvent->prevEvent == 0) ? -1 : (wrkEvent->prevEvent - _events));
+		f->writeSint16BE((wrkEvent->nextEvent == 0) ? -1 : (wrkEvent->nextEvent - _events));
 	}
-
-	f->write(saveEventArr, sizeof(saveEventArr));
 }
 
 /**
@@ -730,27 +730,11 @@ void Scheduler::saveEvents(Common::WriteStream *f) {
  */
 
 void Scheduler::restoreActions(Common::ReadStream *f) {
-
 	for (int i = 0; i < _actListArrSize; i++) {
-	
-		// read all the sub elems
-		int j = 0;
-		do {
-
-			// handle special case for a3, keep list pointer
-			int* responsePtr = 0;
-			if (_actListArr[i][j].a3.actType == PROMPT) {
-				responsePtr = _actListArr[i][j].a3.responsePtr;
-			}
-
-			f->read(&_actListArr[i][j], sizeof(act));
-
-			// handle special case for a3, reset list pointer
-			if (_actListArr[i][j].a3.actType == PROMPT) {
-				_actListArr[i][j].a3.responsePtr = responsePtr;
-			}
-			j++;
-		} while (_actListArr[i][j-1].a0.actType != ANULL);
+		uint16 numSubElem = f->readUint16BE();
+		for (int j = 0; j < numSubElem; j++) {
+			readAct(*f, _actListArr[i][j]);
+		}
 	}
 }
 
@@ -764,23 +748,301 @@ int16 Scheduler::calcMaxPoints() const {
 /*
 * Save the action data in the file with handle f
 */
-void Scheduler::saveActions(Common::WriteStream* f) const {
+void Scheduler::saveActions(Common::WriteStream *f) const {
+	byte  subElemType;
+	int16 nbrCpt;
+	uint16 nbrSubElem;
+
 	for (int i = 0; i < _actListArrSize; i++) {
 		// write all the sub elems data
-
-		int j = 0;
-		do {
-			f->write(&_actListArr[i][j], sizeof(act));
-			j++;
-		} while (_actListArr[i][j-1].a0.actType != ANULL);
+		for (nbrSubElem = 1; _actListArr[i][nbrSubElem - 1].a0.actType != ANULL; nbrSubElem++)
+			;
+
+		f->writeUint16BE(nbrSubElem);
+		for (int j = 0; j < nbrSubElem; j++) {
+			subElemType = _actListArr[i][j].a0.actType;
+			f->writeByte(subElemType);
+			switch (subElemType) {
+			case ANULL:              // -1
+				break;
+			case ASCHEDULE:          // 0
+				f->writeSint16BE(_actListArr[i][j].a0.timer);
+				f->writeUint16BE(_actListArr[i][j].a0.actIndex);
+				break;
+			case START_OBJ:          // 1
+				f->writeSint16BE(_actListArr[i][j].a1.timer);
+				f->writeSint16BE(_actListArr[i][j].a1.objIndex);
+				f->writeSint16BE(_actListArr[i][j].a1.cycleNumb);
+				f->writeByte(_actListArr[i][j].a1.cycle);
+				break;
+			case INIT_OBJXY:         // 2
+				f->writeSint16BE(_actListArr[i][j].a2.timer);
+				f->writeSint16BE(_actListArr[i][j].a2.objIndex);
+				f->writeSint16BE(_actListArr[i][j].a2.x);
+				f->writeSint16BE(_actListArr[i][j].a2.y);
+				break;
+			case PROMPT:             // 3
+				f->writeSint16BE(_actListArr[i][j].a3.timer);
+				f->writeSint16BE(_actListArr[i][j].a3.promptIndex);
+				for (nbrCpt = 0; _actListArr[i][j].a3.responsePtr[nbrCpt] != -1; nbrCpt++)
+					;
+				nbrCpt++;
+				f->writeUint16BE(nbrCpt);
+				for (int k = 0; k < nbrCpt; k++)
+					f->writeSint16BE(_actListArr[i][j].a3.responsePtr[k]);
+				f->writeUint16BE(_actListArr[i][j].a3.actPassIndex);
+				f->writeUint16BE(_actListArr[i][j].a3.actFailIndex);
+				f->writeByte((_actListArr[i][j].a3.encodedFl) ? 1 : 0);
+				break;
+			case BKGD_COLOR:         // 4
+				f->writeSint16BE(_actListArr[i][j].a4.timer);
+				f->writeUint32BE(_actListArr[i][j].a4.newBackgroundColor);
+				break;
+			case INIT_OBJVXY:        // 5
+				f->writeSint16BE(_actListArr[i][j].a5.timer);
+				f->writeSint16BE(_actListArr[i][j].a5.objIndex);
+				f->writeSint16BE(_actListArr[i][j].a5.vx);
+				f->writeSint16BE(_actListArr[i][j].a5.vy);
+				break;
+			case INIT_CARRY:         // 6
+				f->writeSint16BE(_actListArr[i][j].a6.timer);
+				f->writeSint16BE(_actListArr[i][j].a6.objIndex);
+				f->writeByte((_actListArr[i][j].a6.carriedFl) ? 1 : 0);
+				break;
+			case INIT_HF_COORD:      // 7
+				f->writeSint16BE(_actListArr[i][j].a7.timer);
+				f->writeSint16BE(_actListArr[i][j].a7.objIndex);
+				break;
+			case NEW_SCREEN:         // 8
+				f->writeSint16BE(_actListArr[i][j].a8.timer);
+				f->writeSint16BE(_actListArr[i][j].a8.screenIndex);
+				break;
+			case INIT_OBJSTATE:      // 9
+				f->writeSint16BE(_actListArr[i][j].a9.timer);
+				f->writeSint16BE(_actListArr[i][j].a9.objIndex);
+				f->writeByte(_actListArr[i][j].a9.newState);
+				break;
+			case INIT_PATH:          // 10
+				f->writeSint16BE(_actListArr[i][j].a10.timer);
+				f->writeSint16BE(_actListArr[i][j].a10.objIndex);
+				f->writeSint16BE(_actListArr[i][j].a10.newPathType);
+				f->writeByte(_actListArr[i][j].a10.vxPath);
+				f->writeByte(_actListArr[i][j].a10.vyPath);
+				break;
+			case COND_R:             // 11
+				f->writeSint16BE(_actListArr[i][j].a11.timer);
+				f->writeSint16BE(_actListArr[i][j].a11.objIndex);
+				f->writeByte(_actListArr[i][j].a11.stateReq);
+				f->writeUint16BE(_actListArr[i][j].a11.actPassIndex);
+				f->writeUint16BE(_actListArr[i][j].a11.actFailIndex);
+				break;
+			case TEXT:               // 12
+				f->writeSint16BE(_actListArr[i][j].a12.timer);
+				f->writeSint16BE(_actListArr[i][j].a12.stringIndex);
+				break;
+			case SWAP_IMAGES:        // 13
+				f->writeSint16BE(_actListArr[i][j].a13.timer);
+				f->writeSint16BE(_actListArr[i][j].a13.objIndex1);
+				f->writeSint16BE(_actListArr[i][j].a13.objIndex2);
+				break;
+			case COND_SCR:           // 14
+				f->writeSint16BE(_actListArr[i][j].a14.timer);
+				f->writeSint16BE(_actListArr[i][j].a14.objIndex);
+				f->writeSint16BE(_actListArr[i][j].a14.screenReq);
+				f->writeUint16BE(_actListArr[i][j].a14.actPassIndex);
+				f->writeUint16BE(_actListArr[i][j].a14.actFailIndex);
+				break;
+			case AUTOPILOT:          // 15
+				f->writeSint16BE(_actListArr[i][j].a15.timer);
+				f->writeSint16BE(_actListArr[i][j].a15.objIndex1);
+				f->writeSint16BE(_actListArr[i][j].a15.objIndex2);
+				f->writeByte(_actListArr[i][j].a15.dx);
+				f->writeByte(_actListArr[i][j].a15.dy);
+				break;
+			case INIT_OBJ_SEQ:       // 16
+				f->writeSint16BE(_actListArr[i][j].a16.timer);
+				f->writeSint16BE(_actListArr[i][j].a16.objIndex);
+				f->writeSint16BE(_actListArr[i][j].a16.seqIndex);
+				break;
+			case SET_STATE_BITS:     // 17
+				f->writeSint16BE(_actListArr[i][j].a17.timer);
+				f->writeSint16BE(_actListArr[i][j].a17.objIndex);
+				f->writeSint16BE(_actListArr[i][j].a17.stateMask);
+				break;
+			case CLEAR_STATE_BITS:   // 18
+				f->writeSint16BE(_actListArr[i][j].a18.timer);
+				f->writeSint16BE(_actListArr[i][j].a18.objIndex);
+				f->writeSint16BE(_actListArr[i][j].a18.stateMask);
+				break;
+			case TEST_STATE_BITS:    // 19
+				f->writeSint16BE(_actListArr[i][j].a19.timer);
+				f->writeSint16BE(_actListArr[i][j].a19.objIndex);
+				f->writeSint16BE(_actListArr[i][j].a19.stateMask);
+				f->writeUint16BE(_actListArr[i][j].a19.actPassIndex);
+				f->writeUint16BE(_actListArr[i][j].a19.actFailIndex);
+				break;
+			case DEL_EVENTS:         // 20
+				f->writeSint16BE(_actListArr[i][j].a20.timer);
+				f->writeByte(_actListArr[i][j].a20.actTypeDel);
+				break;
+			case GAMEOVER:           // 21
+				f->writeSint16BE(_actListArr[i][j].a21.timer);
+				break;
+			case INIT_HH_COORD:      // 22
+				f->writeSint16BE(_actListArr[i][j].a22.timer);
+				f->writeSint16BE(_actListArr[i][j].a22.objIndex);
+				break;
+			case EXIT:               // 23
+				f->writeSint16BE(_actListArr[i][j].a23.timer);
+				break;
+			case BONUS:              // 24
+				f->writeSint16BE(_actListArr[i][j].a24.timer);
+				f->writeSint16BE(_actListArr[i][j].a24.pointIndex);
+				break;
+			case COND_BOX:           // 25
+				f->writeSint16BE(_actListArr[i][j].a25.timer);
+				f->writeSint16BE(_actListArr[i][j].a25.objIndex);
+				f->writeSint16BE(_actListArr[i][j].a25.x1);
+				f->writeSint16BE(_actListArr[i][j].a25.y1);
+				f->writeSint16BE(_actListArr[i][j].a25.x2);
+				f->writeSint16BE(_actListArr[i][j].a25.y2);
+				f->writeUint16BE(_actListArr[i][j].a25.actPassIndex);
+				f->writeUint16BE(_actListArr[i][j].a25.actFailIndex);
+				break;
+			case SOUND:              // 26
+				f->writeSint16BE(_actListArr[i][j].a26.timer);
+				f->writeSint16BE(_actListArr[i][j].a26.soundIndex);
+				break;
+			case ADD_SCORE:          // 27
+				f->writeSint16BE(_actListArr[i][j].a27.timer);
+				f->writeSint16BE(_actListArr[i][j].a27.objIndex);
+				break;
+			case SUB_SCORE:          // 28
+				f->writeSint16BE(_actListArr[i][j].a28.timer);
+				f->writeSint16BE(_actListArr[i][j].a28.objIndex);
+				break;
+			case COND_CARRY:         // 29
+				f->writeSint16BE(_actListArr[i][j].a29.timer);
+				f->writeSint16BE(_actListArr[i][j].a29.objIndex);
+				f->writeUint16BE(_actListArr[i][j].a29.actPassIndex);
+				f->writeUint16BE(_actListArr[i][j].a29.actFailIndex);
+				break;
+			case INIT_MAZE:          // 30
+				f->writeSint16BE(_actListArr[i][j].a30.timer);
+				f->writeByte(_actListArr[i][j].a30.mazeSize);
+				f->writeSint16BE(_actListArr[i][j].a30.x1);
+				f->writeSint16BE(_actListArr[i][j].a30.y1);
+				f->writeSint16BE(_actListArr[i][j].a30.x2);
+				f->writeSint16BE(_actListArr[i][j].a30.y2);
+				f->writeSint16BE(_actListArr[i][j].a30.x3);
+				f->writeSint16BE(_actListArr[i][j].a30.x4);
+				f->writeByte(_actListArr[i][j].a30.firstScreenIndex);
+				break;
+			case EXIT_MAZE:          // 31
+				f->writeSint16BE(_actListArr[i][j].a31.timer);
+				break;
+			case INIT_PRIORITY:      // 32
+				f->writeSint16BE(_actListArr[i][j].a32.timer);
+				f->writeSint16BE(_actListArr[i][j].a32.objIndex);
+				f->writeByte(_actListArr[i][j].a32.priority);
+				break;
+			case INIT_SCREEN:        // 33
+				f->writeSint16BE(_actListArr[i][j].a33.timer);
+				f->writeSint16BE(_actListArr[i][j].a33.objIndex);
+				f->writeSint16BE(_actListArr[i][j].a33.screenIndex);
+				break;
+			case AGSCHEDULE:         // 34
+				f->writeSint16BE(_actListArr[i][j].a34.timer);
+				f->writeUint16BE(_actListArr[i][j].a34.actIndex);
+				break;
+			case REMAPPAL:           // 35
+				f->writeSint16BE(_actListArr[i][j].a35.timer);
+				f->writeSint16BE(_actListArr[i][j].a35.oldColorIndex);
+				f->writeSint16BE(_actListArr[i][j].a35.newColorIndex);
+				break;
+			case COND_NOUN:          // 36
+				f->writeSint16BE(_actListArr[i][j].a36.timer);
+				f->writeUint16BE(_actListArr[i][j].a36.nounIndex);
+				f->writeUint16BE(_actListArr[i][j].a36.actPassIndex);
+				f->writeUint16BE(_actListArr[i][j].a36.actFailIndex);
+				break;
+			case SCREEN_STATE:       // 37
+				f->writeSint16BE(_actListArr[i][j].a37.timer);
+				f->writeSint16BE(_actListArr[i][j].a37.screenIndex);
+				f->writeByte(_actListArr[i][j].a37.newState);
+				break;
+			case INIT_LIPS:          // 38
+				f->writeSint16BE(_actListArr[i][j].a38.timer);
+				f->writeSint16BE(_actListArr[i][j].a38.lipsObjIndex);
+				f->writeSint16BE(_actListArr[i][j].a38.objIndex);
+				f->writeByte(_actListArr[i][j].a38.dxLips);
+				f->writeByte(_actListArr[i][j].a38.dyLips);
+				break;
+			case INIT_STORY_MODE:    // 39
+				f->writeSint16BE(_actListArr[i][j].a39.timer);
+				f->writeByte((_actListArr[i][j].a39.storyModeFl) ? 1 : 0);
+				break;
+			case WARN:               // 40
+				f->writeSint16BE(_actListArr[i][j].a40.timer);
+				f->writeSint16BE(_actListArr[i][j].a40.stringIndex);
+				break;
+			case COND_BONUS:         // 41
+				f->writeSint16BE(_actListArr[i][j].a41.timer);
+				f->writeSint16BE(_actListArr[i][j].a41.BonusIndex);
+				f->writeUint16BE(_actListArr[i][j].a41.actPassIndex);
+				f->writeUint16BE(_actListArr[i][j].a41.actFailIndex);
+				break;
+			case TEXT_TAKE:          // 42
+				f->writeSint16BE(_actListArr[i][j].a42.timer);
+				f->writeSint16BE(_actListArr[i][j].a42.objIndex);
+				break;
+			case YESNO:              // 43
+				f->writeSint16BE(_actListArr[i][j].a43.timer);
+				f->writeSint16BE(_actListArr[i][j].a43.promptIndex);
+				f->writeUint16BE(_actListArr[i][j].a43.actYesIndex);
+				f->writeUint16BE(_actListArr[i][j].a43.actNoIndex);
+				break;
+			case STOP_ROUTE:         // 44
+				f->writeSint16BE(_actListArr[i][j].a44.timer);
+				break;
+			case COND_ROUTE:         // 45
+				f->writeSint16BE(_actListArr[i][j].a45.timer);
+				f->writeSint16BE(_actListArr[i][j].a45.routeIndex);
+				f->writeUint16BE(_actListArr[i][j].a45.actPassIndex);
+				f->writeUint16BE(_actListArr[i][j].a45.actFailIndex);
+				break;
+			case INIT_JUMPEXIT:      // 46
+				f->writeSint16BE(_actListArr[i][j].a46.timer);
+				f->writeByte((_actListArr[i][j].a46.jumpExitFl) ? 1 : 0);
+				break;
+			case INIT_VIEW:          // 47
+				f->writeSint16BE(_actListArr[i][j].a47.timer);
+				f->writeSint16BE(_actListArr[i][j].a47.objIndex);
+				f->writeSint16BE(_actListArr[i][j].a47.viewx);
+				f->writeSint16BE(_actListArr[i][j].a47.viewy);
+				f->writeSint16BE(_actListArr[i][j].a47.direction);
+				break;
+			case INIT_OBJ_FRAME:     // 48
+				f->writeSint16BE(_actListArr[i][j].a48.timer);
+				f->writeSint16BE(_actListArr[i][j].a48.objIndex);
+				f->writeSint16BE(_actListArr[i][j].a48.seqIndex);
+				f->writeSint16BE(_actListArr[i][j].a48.frameIndex);
+				break;
+			case OLD_SONG:           // 49, Added by Strangerke for DOS versions
+				f->writeSint16BE(_actListArr[i][j].a49.timer);
+				f->writeUint16BE(_actListArr[i][j].a49.songIndex);
+				break;
+			default:
+				error("Unknown action %d", subElemType);
+			}
+		}
 	}
 }
 
 /*
 * Find the index in the action list to be able to serialize the action to save game
 */
-
-void Scheduler::findAction(act* action, int16* index, int16* subElem) {
+void Scheduler::findAction(const act* action, int16* index, int16* subElem) {
 	
 	assert(index && subElem);
 	if (!action) {
@@ -831,28 +1093,30 @@ void Scheduler::restoreSchedulerData(Common::ReadStream *in) {
 void Scheduler::restoreEvents(Common::ReadStream *f) {
 	debugC(1, kDebugSchedule, "restoreEvents");
 
-	event_t  savedEvents[kMaxEvents];               // Convert event ptrs to indexes
-
 	uint32 saveTime = f->readUint32BE();            // time of save
 	int16 freeIndex = f->readSint16BE();            // Free list index
 	int16 headIndex = f->readSint16BE();            // Head of list index
 	int16 tailIndex = f->readSint16BE();            // Tail of list index
-	f->read(savedEvents, sizeof(savedEvents));
 
-	event_t *wrkEvent;
 	// Restore events indexes to pointers
 	for (int i = 0; i < kMaxEvents; i++) {
-		wrkEvent = &savedEvents[i];
-		_events[i] = *wrkEvent;
+		int16 index = f->readSint16BE();
+		int16 subElem = f->readSint16BE();
+
 		// fix up action pointer (to do better)
-		int32 val = (size_t)_events[i].action;
-		if ((val & 0xffff) == 0xffff) {
+		if ((index == -1) && (subElem == -1))
 			_events[i].action = 0;
-		} else {
-			_events[i].action = (act*)&_actListArr[val >> 16][val & 0xffff];
-		}
-		_events[i].prevEvent = (wrkEvent->prevEvent == (event_t *) - 1) ? (event_t *)0 : &_events[(size_t)wrkEvent->prevEvent ];
-		_events[i].nextEvent = (wrkEvent->nextEvent == (event_t *) - 1) ? (event_t *)0 : &_events[(size_t)wrkEvent->nextEvent ];
+		else
+			_events[i].action = (act*)&_actListArr[index][subElem];
+
+		_events[i].localActionFl = (f->readByte() == 1) ? true : false; 
+		_events[i].time = f->readUint32BE();
+
+		int16 prevIndex = f->readSint16BE();
+		int16 nextIndex = f->readSint16BE();
+
+		_events[i].prevEvent = (prevIndex == -1) ? (event_t *)0 : &_events[prevIndex];
+		_events[i].nextEvent = (nextIndex == -1) ? (event_t *)0 : &_events[nextIndex];
 	}
 	_freeEvent = (freeIndex == -1) ? 0 : &_events[freeIndex];
 	_headEvent = (headIndex == -1) ? 0 : &_events[headIndex];
@@ -860,7 +1124,7 @@ void Scheduler::restoreEvents(Common::ReadStream *f) {
 
 	// Adjust times to fit our time
 	uint32 curTime = getTicks();
-	wrkEvent = _headEvent;                              // The earliest event
+	event_t *wrkEvent = _headEvent;                 // The earliest event
 	while (wrkEvent) {                              // While mature events found
 		wrkEvent->time = wrkEvent->time - saveTime + curTime;
 		wrkEvent = wrkEvent->nextEvent;
@@ -881,6 +1145,10 @@ void Scheduler::insertAction(act *action) {
 	case AGSCHEDULE:
 		curEvent->localActionFl = false;            // Lasts over a new screen
 		break;
+	// Workaround: When dying, switch to storyMode in order to block the keyboard.
+	case GAMEOVER:
+		_vm->getGameStatus().storyModeFl = true;
+	// No break on purpose
 	default:
 		curEvent->localActionFl = true;             // Rest are for current screen only
 		break;
@@ -980,7 +1248,7 @@ event_t *Scheduler::doAction(event_t *curEvent) {
 			insertActionList(action->a11.actFailIndex);
 		break;
 	case TEXT:                                      // act12: Text box (CF WARN)
-		Utils::Box(kBoxAny, "%s", _vm->_file->fetchString(action->a12.stringIndex));   // Fetch string from file
+		Utils::notifyBox(_vm->_file->fetchString(action->a12.stringIndex));   // Fetch string from file
 		break;
 	case SWAP_IMAGES:                               // act13: Swap 2 object images
 		_vm->_object->swapImages(action->a13.objIndex1, action->a13.objIndex2);
@@ -1105,7 +1373,7 @@ event_t *Scheduler::doAction(event_t *curEvent) {
 		gameStatus.storyModeFl = action->a39.storyModeFl;
 		break;
 	case WARN:                                      // act40: Text box (CF TEXT)
-		Utils::Box(kBoxOk, "%s", _vm->_file->fetchString(action->a40.stringIndex));
+		Utils::notifyBox(_vm->_file->fetchString(action->a40.stringIndex));
 		break;
 	case COND_BONUS:                                // act41: Perform action if got bonus
 		if (_points[action->a41.BonusIndex].scoredFl)
@@ -1114,10 +1382,10 @@ event_t *Scheduler::doAction(event_t *curEvent) {
 			insertActionList(action->a41.actFailIndex);
 		break;
 	case TEXT_TAKE:                                 // act42: Text box with "take" message
-		Utils::Box(kBoxAny, TAKE_TEXT, _vm->_text->getNoun(_vm->_object->_objects[action->a42.objIndex].nounIndex, TAKE_NAME));
+		Utils::notifyBox(Common::String::format(TAKE_TEXT, _vm->_text->getNoun(_vm->_object->_objects[action->a42.objIndex].nounIndex, TAKE_NAME)));
 		break;
 	case YESNO:                                     // act43: Prompt user for Yes or No
-		if (Utils::Box(kBoxYesNo, "%s", _vm->_file->fetchString(action->a43.promptIndex)) != 0)
+		if (Utils::yesNoBox(_vm->_file->fetchString(action->a43.promptIndex)))
 			insertActionList(action->a43.actYesIndex);
 		else
 			insertActionList(action->a43.actNoIndex);
@@ -1267,28 +1535,22 @@ void Scheduler_v1d::runScheduler() {
 }
 
 void Scheduler_v1d::promptAction(act *action) {
-	Utils::Box(kBoxPrompt, "%s", _vm->_file->fetchString(action->a3.promptIndex));
-
-	warning("STUB: doAction(act3)");
-	// TODO: The answer of the player is not handled currently! Once it'll be read in the messageBox, uncomment this block
-#if 0
-	char response[256];
-	// TODO: Put user input in response
-
-	Utils::strlwr(response);
-	if (action->a3.encodedFl) {
-		warning("Encrypted flag set");
-		decodeString(response);
-	}
+	Common::String response;
+
+	response = Utils::promptBox(_vm->_file->fetchString(action->a3.promptIndex));
+
+	response.toLowercase();
+
+	char resp[256];
+	strncpy(resp, response.c_str(), 256);
 
-	if (strstr(response, _vm->_file->fetchString(action->a3.responsePtr[0]))
+	if (action->a3.encodedFl)
+		decodeString(resp);
+
+	if (strstr(resp, _vm->_file->fetchString(action->a3.responsePtr[0])))
 		insertActionList(action->a3.actPassIndex);
 	else
 		insertActionList(action->a3.actFailIndex);
-#endif
-
-	// HACK: As the answer is not read, currently it's always considered correct
-	insertActionList(action->a3.actPassIndex);
 }
 
 /**
@@ -1316,19 +1578,22 @@ const char *Scheduler_v2d::getCypher() const {
 }
 
 void Scheduler_v2d::promptAction(act *action) {
-	Utils::Box(kBoxPrompt, "%s", _vm->_file->fetchString(action->a3.promptIndex));
-	warning("STUB: doAction(act3), expecting answer %s", _vm->_file->fetchString(action->a3.responsePtr[0]));
+	Common::String response;
+
+	response = Utils::promptBox(_vm->_file->fetchString(action->a3.promptIndex));
+	response.toLowercase();
 
-	// TODO: The answer of the player is not handled currently! Once it'll be read in the messageBox, uncomment this block
-#if 0
-	char *response = Utils::Box(BOX_PROMPT, "%s", _vm->_file->fetchString(action->a3.promptIndex));
+	debug(1, "doAction(act3), expecting answer %s", _vm->_file->fetchString(action->a3.responsePtr[0]));
 
 	bool  found = false;
-	char *tmpStr;                                   // General purpose string ptr
+	const char *tmpStr;                                   // General purpose string ptr
 
-	for (dx = 0; !found && (action->a3.responsePtr[dx] != -1); dx++) {
+	char resp[256];
+	strncpy(resp, response.c_str(), 256);
+
+	for (int dx = 0; !found && (action->a3.responsePtr[dx] != -1); dx++) {
 		tmpStr = _vm->_file->fetchString(action->a3.responsePtr[dx]);
-		if (strstr(Utils::strlwr(response) , tmpStr))
+		if (strstr(Utils::strlwr(resp), tmpStr))
 			found = true;
 	}
 
@@ -1336,10 +1601,6 @@ void Scheduler_v2d::promptAction(act *action) {
 		insertActionList(action->a3.actPassIndex);
 	else
 		insertActionList(action->a3.actFailIndex);
-#endif
-
-	// HACK: As the answer is not read, currently it's always considered correct
-	insertActionList(action->a3.actPassIndex);
 }
 
 /**