SHERLOCK: Implemented talk/listen sequence methods

4 files changed, 188 insertions, 98 deletions

diff --git a/engines/sherlock/tattoo/tattoo_people.cpp b/engines/sherlock/tattoo/tattoo_people.cpp
index e0f4102abb..b253afd1da 100644
--- a/engines/sherlock/tattoo/tattoo_people.cpp
+++ b/engines/sherlock/tattoo/tattoo_people.cpp
@@ -21,17 +21,184 @@
  */
 
 #include "sherlock/tattoo/tattoo_people.h"
+#include "sherlock/tattoo/tattoo_talk.h"
+#include "sherlock/sherlock.h"
 
 namespace Sherlock {
 
 namespace Tattoo {
 
 void TattooPeople::setListenSequence(int speaker, int sequenceNum) {
-	// TODO
+	Scene &scene = *_vm->_scene;
+
+	// If no speaker is specified, then nothing needs to be done
+	if (speaker == -1)
+		return;
+
+	int objNum = findSpeaker(speaker);
+	if (objNum < 256 && objNum != -1) {
+		// See if the Object has to wait for an Abort Talk Code
+		Object &obj = scene._bgShapes[objNum];
+		if (obj.hasAborts())
+			obj._gotoSeq = sequenceNum;
+		else
+			obj.setObjTalkSequence(sequenceNum);
+	} else if (objNum != -1) {
+		objNum -= 256;
+		Person &person = _data[objNum];
+
+		int newDir = person._sequenceNumber;
+		switch (person._sequenceNumber) {
+		case WALK_UP:
+		case STOP_UP:
+		case WALK_UPRIGHT:
+		case STOP_UPRIGHT:
+		case TALK_UPRIGHT:
+		case LISTEN_UPRIGHT:
+			newDir = LISTEN_UPRIGHT;
+			break;
+		case WALK_RIGHT:
+		case STOP_RIGHT:
+		case TALK_RIGHT:
+		case LISTEN_RIGHT:
+			newDir = LISTEN_RIGHT;
+			break;
+		case WALK_DOWNRIGHT:
+		case STOP_DOWNRIGHT:
+		case TALK_DOWNRIGHT:
+		case LISTEN_DOWNRIGHT:
+			newDir = LISTEN_DOWNRIGHT;
+			break;
+		case WALK_DOWN:
+		case STOP_DOWN:
+		case WALK_DOWNLEFT:
+		case STOP_DOWNLEFT:
+		case TALK_DOWNLEFT:
+		case LISTEN_DOWNLEFT:
+			newDir = LISTEN_DOWNLEFT;
+			break;
+		case WALK_LEFT:
+		case STOP_LEFT:
+		case TALK_LEFT:
+		case LISTEN_LEFT:
+			newDir = LISTEN_LEFT;
+			break;
+		case WALK_UPLEFT:
+		case STOP_UPLEFT:
+		case TALK_UPLEFT:
+		case LISTEN_UPLEFT:
+			newDir = LISTEN_UPLEFT;
+			break;
+
+		default:
+			break;
+		}
+
+		// See if the NPC's Seq has to wait for an Abort Talk Code
+		if (person.hasAborts()) {
+			person._gotoSeq = newDir;
+		}  else {
+			if (person._seqTo) {
+				// Reset to previous value
+				person._walkSequences[person._sequenceNumber]._sequences[person._frameNumber] = person._seqTo;
+				person._seqTo = 0;
+			}
+
+			person._sequenceNumber = newDir;
+			person._frameNumber = 0;
+			person.checkWalkGraphics();
+		}
+	}
 }
 
 void TattooPeople::setTalkSequence(int speaker, int sequenceNum) {
-	// TODO
+	People &people = *_vm->_people;
+	Scene &scene = *_vm->_scene;
+	TattooTalk &talk = *(TattooTalk *)_vm->_talk;
+
+	// If no speaker is specified, then nothing needs to be done
+	if (speaker == -1)
+		return;
+
+	int objNum = people.findSpeaker(speaker);
+	if (objNum != -1 && objNum < 256) {
+		Object &obj = scene._bgShapes[objNum];
+
+		// See if the Object has to wait for an Abort Talk Code
+		if (obj.hasAborts()) {
+			talk.pushTalkSequence(&obj);
+			obj._gotoSeq = sequenceNum;
+		}
+		else {
+			obj.setObjTalkSequence(sequenceNum);
+		}
+	}
+	else if (objNum != -1) {
+		objNum -= 256;
+		Person &person = people[objNum];
+		int newDir = person._sequenceNumber;
+
+		switch (newDir) {
+		case WALK_UP:
+		case STOP_UP:
+		case WALK_UPRIGHT:
+		case STOP_UPRIGHT:
+		case TALK_UPRIGHT:
+		case LISTEN_UPRIGHT:
+			newDir = TALK_UPRIGHT;
+			break;
+		case WALK_RIGHT:
+		case STOP_RIGHT:
+		case TALK_RIGHT:
+		case LISTEN_RIGHT:
+			newDir = TALK_RIGHT;
+			break;
+		case WALK_DOWNRIGHT:
+		case STOP_DOWNRIGHT:
+		case TALK_DOWNRIGHT:
+		case LISTEN_DOWNRIGHT:
+			newDir = TALK_DOWNRIGHT;
+			break;
+		case WALK_DOWN:
+		case STOP_DOWN:
+		case WALK_DOWNLEFT:
+		case STOP_DOWNLEFT:
+		case TALK_DOWNLEFT:
+		case LISTEN_DOWNLEFT:
+			newDir = TALK_DOWNLEFT;
+			break;
+		case WALK_LEFT:
+		case STOP_LEFT:
+		case TALK_LEFT:
+		case LISTEN_LEFT:
+			newDir = TALK_LEFT;
+			break;
+		case WALK_UPLEFT:
+		case STOP_UPLEFT:
+		case TALK_UPLEFT:
+		case LISTEN_UPLEFT:
+			newDir = TALK_UPLEFT;
+			break;
+		default:
+			break;
+		}
+
+		// See if the NPC's sequence has to wait for an Abort Talk Code
+		if (person.hasAborts()) {
+			person._gotoSeq = newDir;
+		}
+		else {
+			if (person._seqTo) {
+				// Reset to previous value
+				person._walkSequences[person._sequenceNumber]._sequences[person._frameNumber] = person._seqTo;
+				person._seqTo = 0;
+			}
+
+			person._sequenceNumber = newDir;
+			person._frameNumber = 0;
+			person.checkWalkGraphics();
+		}
+	}
 }
 
 } // End of namespace Tattoo
diff --git a/engines/sherlock/tattoo/tattoo_people.h b/engines/sherlock/tattoo/tattoo_people.h
index 085e078411..481ce7804a 100644
--- a/engines/sherlock/tattoo/tattoo_people.h
+++ b/engines/sherlock/tattoo/tattoo_people.h
@@ -87,13 +87,11 @@ public:
 	 */
 	void setListenSequence(int speaker, int sequenceNum);
 
+
 	/**
-	 * If the specified speaker is a background object, this will set it so that it uses 
-	 * the Talk Sequence specified. If the current sequence has an Allow Talk Code in it,
-	 * _gotoSeq will be set so that the object begins talking as soon as it hits the 
-	 * Allow Talk Code. If there is no Abort Code, the Talk Sequence will begin immediately.                                  
+	 * Change the sequence of the scene background object associated with the specified speaker.
 	 */
-	void setTalkSequence(int speaker, int sequenceNum);
+	virtual void setTalkSequence(int speaker, int sequenceNum = 1);
 };
 
 } // End of namespace Scalpel
diff --git a/engines/sherlock/tattoo/tattoo_talk.cpp b/engines/sherlock/tattoo/tattoo_talk.cpp
index 99a6d267c3..9e20ad4237 100644
--- a/engines/sherlock/tattoo/tattoo_talk.cpp
+++ b/engines/sherlock/tattoo/tattoo_talk.cpp
@@ -101,7 +101,8 @@ const byte TATTOO_OPCODES[] = {
 	222,	// OP_NPC_VERB_SCRIPT
 	224,	// OP_RESTORE_PEOPLE_SEQUENCE
 	226,	// OP_NPC_VERB_TARGET
-	227		// OP_TURN_SOUNDS_OFF
+	227,	// OP_TURN_SOUNDS_OFF
+	225		// OP_NULL
 };
 
 /*----------------------------------------------------------------*/
@@ -175,101 +176,28 @@ TattooTalk::TattooTalk(SherlockEngine *vm) : Talk(vm) {
 		nullptr,
 		(OpcodeMethod)&TattooTalk::cmdRestorePeopleSequence,
 		(OpcodeMethod)&TattooTalk::cmdSetNPCVerbTarget,
-		(OpcodeMethod)&TattooTalk::cmdTurnSoundsOff
+		(OpcodeMethod)&TattooTalk::cmdTurnSoundsOff,
+		nullptr
 	};
 
 	_opcodes = TATTOO_OPCODES;
 	_opcodeTable = OPCODE_METHODS;
 }
 
-void TattooTalk::setSequence(int speaker, int sequenceNum) {
-	People &people = *_vm->_people;
-	Scene &scene = *_vm->_scene;
-
-	// If no speaker is specified, then nothing needs to be done
-	if (speaker == -1)
-		return;
-
-	int objNum = people.findSpeaker(speaker);
-	if (objNum != -1 && objNum < 256) {
-		Object &obj = scene._bgShapes[objNum];
-
-		// See if the Object has to wait for an Abort Talk Code
-		if (obj.hasAborts()) {
-			pushTalkSequence(&obj);
-			obj._gotoSeq = sequenceNum;
-		} else {
-			obj.setObjTalkSequence(sequenceNum);
-		}
-	} else if (objNum != -1) {
-		objNum -= 256;
-		Person &person = people[objNum];
-		int newDir = person._sequenceNumber;
-
-		switch (newDir) {
-		case WALK_UP:
-		case STOP_UP:
-		case WALK_UPRIGHT:
-		case STOP_UPRIGHT:
-		case TALK_UPRIGHT:
-		case LISTEN_UPRIGHT:
-			newDir = TALK_UPRIGHT;
-			break;
-		case WALK_RIGHT:
-		case STOP_RIGHT:
-		case TALK_RIGHT:
-		case LISTEN_RIGHT:
-			newDir = TALK_RIGHT;
-			break;
-		case WALK_DOWNRIGHT:
-		case STOP_DOWNRIGHT:
-		case TALK_DOWNRIGHT:
-		case LISTEN_DOWNRIGHT:
-			newDir = TALK_DOWNRIGHT;
-			break;
-		case WALK_DOWN:
-		case STOP_DOWN:
-		case WALK_DOWNLEFT:
-		case STOP_DOWNLEFT:
-		case TALK_DOWNLEFT:
-		case LISTEN_DOWNLEFT:
-			newDir = TALK_DOWNLEFT;
-			break;
-		case WALK_LEFT:
-		case STOP_LEFT:
-		case TALK_LEFT:
-		case LISTEN_LEFT:
-			newDir = TALK_LEFT;
-			break;
-		case WALK_UPLEFT:
-		case STOP_UPLEFT:
-		case TALK_UPLEFT:
-		case LISTEN_UPLEFT:
-			newDir = TALK_UPLEFT;
-			break;
-		default:
-			break;
-		}
-
-		// See if the NPC's sequence has to wait for an Abort Talk Code
-		if (person.hasAborts()) {
-			person._gotoSeq = newDir;
-		} else {
-			if (person._seqTo) {
-				// Reset to previous value
-				person._walkSequences[person._sequenceNumber]._sequences[person._frameNumber] = person._seqTo;
-				person._seqTo = 0;
-			}
+void TattooTalk::talkInterface(const byte *&str) {
+	drawTalk(str);
 
-			person._sequenceNumber = newDir;
-			person._frameNumber = 0;
-			person.checkWalkGraphics();
-		}
+	_charCount = 0;
+	while ((*str < TATTOO_OPCODES[0] || *str == TATTOO_OPCODES[OP_NULL]) && *str) {
+		++_charCount;
+		++str;
 	}
+
+	_wait = true;
 }
 
-void TattooTalk::talkInterface(const byte *&str) {
-	warning("TODO: TattooTalk::talkInterface");
+void TattooTalk::drawTalk(const byte *str) {
+	// TODO
 }
 
 OpcodeReturn TattooTalk::cmdSwitchSpeaker(const byte *&str) {
diff --git a/engines/sherlock/tattoo/tattoo_talk.h b/engines/sherlock/tattoo/tattoo_talk.h
index ee99fceeec..0b5e7e4ae7 100644
--- a/engines/sherlock/tattoo/tattoo_talk.h
+++ b/engines/sherlock/tattoo/tattoo_talk.h
@@ -71,13 +71,10 @@ private:
 	OpcodeReturn cmdWalkNPCToCAnimation(const byte *&str);
 	OpcodeReturn cmdWalkNPCToCoords(const byte *&str);
 	OpcodeReturn cmdWalkHomesAndNPCToCoords(const byte *&str);
+private:
+	void drawTalk(const byte *str);
 protected:
 	/**
-	 * Change the sequence of the scene background object associated with the current speaker.
-	 */
-	virtual void setSequence(int speaker, int sequenceNum = 1);
-
-	/**
 	 * Display the talk interface window
 	 */
 	virtual void talkInterface(const byte *&str);