Ticket #9052: v0_mm_verb.patch

engines/scumm/object.cpp

@@ -181 +181 @@
                 // Alternatively, scan the inventory to see if the object is in there...
                 for (i = 0; i < _numInventory; i++) {
                         if (_inventory[i] == obj) {
-                                assert(WIO_INVENTORY == whereIsObject(obj));
+                                if(_game.version == 0)
+                                        assert(WIO_INVENTORY == whereIsObjectInventory( obj ));
+                                else
+                                        assert(WIO_INVENTORY == whereIsObject(obj));
+
                                 // Found the object! Nuke it from the inventory.
                                 _res->nukeResource(rtInventory, i);
                                 _inventory[i] = 0;
@@ -286 +290 @@
                 // it. Fortunately this does not prevent frustrated players from
                 // blowing up the mansion, should they feel the urge to.
 
-                if (_game.id == GID_MANIAC && (obj == 182 || obj == 193))
+                if (_game.id == GID_MANIAC && _game.version != 0 && (obj == 182 || obj == 193))
                         _objectStateTable[obj] |= kObjectState_08;
         }
 
@@ -317 +321 @@
         return -1;
 }
 
+int ScummEngine::whereIsObjectInventory(int object) {
+        int res = 0;
+        _v0ObjectInInventory = true;
+        res = whereIsObject(object);
+        _v0ObjectInInventory = false;
+        
+        return res;
+}
+
 int ScummEngine::whereIsObject(int object) const {
         int i;
 
@@ -326 +339 @@
         if (object < 1)
                 return WIO_NOT_FOUND;
 
-        if (_objectOwnerTable[object] != OF_OWNER_ROOM) {
+        if ((_objectOwnerTable[object] != OF_OWNER_ROOM && _game.version != 0) || _v0ObjectInInventory) {
                 for (i = 0; i < _numInventory; i++)
                         if (_inventory[i] == object)
                                 return WIO_INVENTORY;
@@ -334 +347 @@
         }
 
         for (i = (_numLocalObjects-1); i > 0; i--)
-                if (_objs[i].obj_nr == object) {
+                if ((_objs[i].obj_nr == object && !_v0ObjectIndex) || (_v0ObjectIndex && i == object)) {
                         if (_objs[i].fl_object_index)
                                 return WIO_FLOBJECT;
                         return WIO_ROOM;
@@ -379 +392 @@
  * Returns X, Y and direction in angles
  */
 void ScummEngine::getObjectXYPos(int object, int &x, int &y, int &dir) {
-        int idx = getObjectIndex(object);
+        int idx;
+        if(_v0ObjectIndex)
+                idx = object;
+        else
+                idx = getObjectIndex(object);
         assert(idx >= 0);
         ObjectData &od = _objs[idx];
         int state;
@@ -475 +492 @@
         return getDist(x, y, x2, y2);
 }
 
+int ScummEngine_v0::findObjectIndex(int x, int y) {
+        int objIdx;
+        _v0ObjectIndex = true;
+        objIdx = findObject(x, y);
+        _v0ObjectIndex = false;
+        return objIdx;
+}
+
 int ScummEngine::findObject(int x, int y) {
         int i, b;
         byte a;
@@ -505 +530 @@
 #endif
                                 if (_objs[i].x_pos <= x && _objs[i].width + _objs[i].x_pos > x &&
                                     _objs[i].y_pos <= y && _objs[i].height + _objs[i].y_pos > y)
-                                        return _objs[i].obj_nr;
+                                        if(_game.version == 0 && _v0ObjectIndex)
+                                                return i;
+                                        else
+                                                return _objs[i].obj_nr;
                                 break;
                         }
                 } while ((_objs[b].state & mask) == a);
@@ -811 +839 @@
                 if (_dumpScripts) {
                         char buf[32];
                         sprintf(buf, "roomobj-%d-", _roomResource);
+                        if(_game.version == 0)
+                                sprintf(buf + 11, "%d-", od->flags);
+
                         dumpResource(buf, od->obj_nr, room + od->OBCDoffset);
                 }
         }
@@ -1033 +1064 @@
         int i;
         ObjectData *od = &_objs[1];
         for (i = 1; i < _numLocalObjects; i++, od++) {
+
+                // V0 MM, Room objects with Flag==1 are objects with 'no-state' (room specific objects, non-pickup)
+                if(_game.version == 0 && od->flags == 1)
+                        continue;
+
                 if (od->obj_nr > 0)
                         od->state = getState(od->obj_nr);
         }
@@ -1155 +1191 @@
 void ScummEngine::setObjectName(int obj) {
         int i;
 
-        if (obj < _numActors)
+        if (obj < _numActors && _game.version != 0)
                 error("Can't set actor %d name with new-name-of", obj);
 
         for (i = 0; i < _numNewNames; i++) {
@@ -1181 +1217 @@
 uint32 ScummEngine::getOBCDOffs(int object) const {
         int i;
 
-        if (_objectOwnerTable[object] != OF_OWNER_ROOM)
+        if (_objectOwnerTable[object] != OF_OWNER_ROOM && (_game.version != 0) ||  _v0ObjectInInventory)
                 return 0;
+
+        // V0 MM Return by Index
+        if(_v0ObjectIndex)
+                return _objs[object].OBCDoffset;
+
         for (i = (_numLocalObjects-1); i > 0; i--) {
                 if (_objs[i].obj_nr == object) {
                         if (_objs[i].fl_object_index != 0)
@@ -1194 +1235 @@
 }
 
 byte *ScummEngine::getOBCDFromObject(int obj) {
+        bool useInventory = _v0ObjectInInventory;
         int i;
         byte *ptr;
 
-        if (_objectOwnerTable[obj] != OF_OWNER_ROOM) {
+        _v0ObjectInInventory = false;
+
+        if ((_objectOwnerTable[obj] != OF_OWNER_ROOM && (_game.version != 0)) || useInventory) {
                 for (i = 0; i < _numInventory; i++) {
                         if (_inventory[i] == obj)
                                 return getResourceAddress(rtInventory, i);
                 }
         } else {
                 for (i = (_numLocalObjects-1); i > 0; --i) {
-                        if (_objs[i].obj_nr == obj) {
+                        if ((_objs[i].obj_nr == obj && !_v0ObjectIndex) || (_v0ObjectIndex && i == obj)) {
                                 if (_objs[i].fl_object_index) {
                                         assert(_objs[i].OBCDoffset == 8);
                                         ptr = getResourceAddress(rtFlObject, _objs[i].fl_object_index);

engines/scumm/saveload.cpp

@@ -1370 +1370 @@
 void ScummEngine_v0::saveOrLoad(Serializer *s) {
         ScummEngine::saveOrLoad(s);
 
-        // TODO: Save additional variables
-        // _currentMode
-        // _currentLights
+        const SaveLoadEntry v0Entrys[] = {
+                MKLINE( ScummEngine_v0, _currentMode, sleUint32, VER(77) ),
+                MKLINE( ScummEngine_v0, _currentLights, sleByte, VER(77) ),
+                
+                MKEND()
+        };
+        s->saveLoadEntries(this, v0Entrys);
 }
 
 void ScummEngine_v5::saveOrLoad(Serializer *s) {

engines/scumm/script.cpp

@@ -133 +133 @@
 
         initializeLocals(slot, vars);
 
+        // V0 Ensure we don't try and access objects via index inside the script
+        _v0ObjectIndex = false;
         runScriptNested(slot);
 }
 

engines/scumm/script_v0.cpp

@@ -410 +410 @@
         actorTalk(buffer);
 }
 
-void ScummEngine_v0::drawSentence() {
-        Common::Rect sentenceline;
+void ScummEngine_v0::drawSentenceWord( int object, bool usePrep, bool objInInventory) {
         const byte *temp;
         int sentencePrep = 0;
+        
+        // If object not in inventory, we except an index
+        if(!objInInventory)
+                _v0ObjectIndex = true;
+        else
+                _v0ObjectInInventory = true;
 
-        if (!(_userState & 32))
-                return;
+        temp = getObjOrActorName(object);
 
-        if (getResourceAddress(rtVerb, _activeVerb)) {
-                strcpy(_sentenceBuf, (char*)getResourceAddress(rtVerb, _activeVerb));
-        } else {
-                return;
+        _v0ObjectInInventory = false;
+        _v0ObjectIndex = false;
+
+        // Append the 'object-name'
+        if (temp) {
+                strcat(_sentenceBuf, " ");
+                strcat(_sentenceBuf, (const char*)temp);
         }
 
-        if (_activeObject > 0) {
-                temp = getObjOrActorName(_activeObject);
-                if (temp) {
-                        strcat(_sentenceBuf, " ");
-                        strcat(_sentenceBuf, (const char*)temp);
-                }
+        // Append the modifier? (With / On / To / In)
+        if(!usePrep)
+                return;
 
-                if (_verbs[_activeVerb].prep == 0xFF) {
-                        byte *ptr = getOBCDFromObject(_activeObject);
-                        assert(ptr);
-                        sentencePrep = (*(ptr + 11) >> 5);
-                } else {
-                        sentencePrep = _verbs[_activeVerb].prep;
-                }
+        if (_verbs[_activeVerb].prep == 0xFF) {
+                _v0ObjectInInventory = objInInventory;
+                sentencePrep = verbPrep(object);
+        } else {
+                sentencePrep = _verbs[_activeVerb].prep;
         }
 
         if (sentencePrep > 0 && sentencePrep <= 4) {
                 // The prepositions, like the fonts, were hard code in the engine. Thus
                 // we have to do that, too, and provde localized versions for all the
                 // languages MM/Zak are available in.
-                const char *prepositions[][5] = {
+                static const char *prepositions[][5] = {
                         { " ", " in", " with", " on", " to" },   // English
                         { " ", " mit", " mit", " mit", " zu" },  // German
                         { " ", " dans", " avec", " sur", " <" }, // French
@@ -471 +473 @@
 
                 strcat(_sentenceBuf, prepositions[lang][sentencePrep]);
         }
+}
 
-        if (_activeInventory > 0) {
-                temp = getObjOrActorName(_activeInventory);
-                if (temp) {
-                        strcat(_sentenceBuf, " ");
-                        strcat(_sentenceBuf, (const char*)temp);
+void ScummEngine_v0::drawSentence() {
+        Common::Rect sentenceline;
+        bool             inventoryFirst = false;
+
+        if (!(_userState & 32))
+                return;
+
+        // Current Verb, Walk/Use
+        if (getResourceAddress(rtVerb, _activeVerb)) {
+                strcpy(_sentenceBuf, (char*)getResourceAddress(rtVerb, _activeVerb));
+        } else {
+                return;
+        }
+
+        // If using inventory first, draw it first
+        if( _activeInvExecute && _activeInventory) {
+                drawSentenceWord(_activeInventory, true, true);
+        } else {
+                // Not using inventory, use selected object
+                if(_activeObject)
+                        drawSentenceWord(_activeObjectIndex, true, false);
+                else
+                        inventoryFirst = true;
+        }
+                
+
+        // Draw the inventory?
+        if (_activeInventory > 0 && _activeObject2 == 0) {
+                
+                // Only if inventory isnt first (it will already be drawn by now)
+                if(!_activeInvExecute) {
+                        drawSentenceWord(_activeInventory, inventoryFirst, true);
+                } else {
+
+                        // Draw the active object, which could be inventory based, or room based
+                        if(_activeObject && !_activeObjectIndex) {
+                                drawSentenceWord(_activeObject, inventoryFirst, true);
+                        } else // Room based
+                                drawSentenceWord(_activeObjectIndex, inventoryFirst, false);
                 }
+        
+        // Draw the 2nd active object 
+        } else if(_activeObject2) {
+
+                // 2nd Object is in inventory
+                if(_activeObject2Inv) {
+                        _v0ObjectInInventory = true;
+                        drawSentenceWord(_activeObject2, inventoryFirst, true);
+                } else
+                        drawSentenceWord(_activeObject2Index, inventoryFirst, false);
         }
 
+        // Draw the active actor
+        if( _activeActor ) {
+                Actor *a = derefActor( _activeActor, "" );
+                
+                strcat(_sentenceBuf, " ");
+                strcat(_sentenceBuf, (const char*)a->getActorName());
+        }
+
         _string[2].charset = 1;
         _string[2].ypos = _virtscr[kVerbVirtScreen].topline;
         _string[2].xpos = 0;
@@ -664 +719 @@
         int act = getVarOrDirectByte(PARAM_1);
         int anim = getVarOrDirectByte(PARAM_2);
         int unk = fetchScriptByte();
+
         debug(0,"o_animateActor: unk %d", unk);
 
         Actor *a = derefActor(act, "o_animateActor");
@@ -713 +769 @@
         if (getObjectIndex(obj) == -1)
                 return;
 
-        if (whereIsObject(obj) == WIO_INVENTORY)        /* Don't take an */
+        if (whereIsObjectInventory( _activeObject2 ) == WIO_INVENTORY)  /* Don't take an */
                 return;                                 /* object twice */
-
+        
         addObjectToInventory(obj, _roomResource);
         markObjectRectAsDirty(obj);
         putOwner(obj, VAR(VAR_EGO));
@@ -900 +956 @@
         setOwnerOf(obj, owner);
 }
 
-void ScummEngine_v0::resetSentence() {
-        _activeInventory = 0;
-        _activeObject = 0;
+void ScummEngine_v0::resetSentence( bool walking ) {
         _activeVerb = 13;
+
+        if(!walking) {
+                _activeInventory = 0;
+                _activeObject = 0;
+                _activeObject2 = 0;
+                _activeObjectIndex = 0;
+                _activeObject2Index = 0;
+        }
+
+        _verbExecuting = false;
+        _verbPickup = false;
+
+        _activeActor = 0;
+        _activeInvExecute = false;
+        _activeObject2Inv = false;
+        _activeObjectObtained = false;
+        _activeObject2Obtained = false;
 }
 
 } // End of namespace Scumm

engines/scumm/scumm.cpp

@@ -134 +134 @@
 
 
         // Init all vars
+        _v0ObjectIndex = false;                 // V0 MM
+        _v0ObjectInInventory = false;   // V0 MM
         _imuse = NULL;
         _imuseDigital = NULL;
         _musicEngine = NULL;
@@ -664 +666 @@
 ScummEngine_v0::ScummEngine_v0(OSystem *syst, const DetectorResult &dr)
         : ScummEngine_v2(syst, dr) {
 
+        _verbExecuting = false;
+        _verbPickup = false;
         _currentMode = 0;
+
+        _activeObject2 = 0;
+        _activeObjectIndex = 0;
+        _activeObject2Index = 0;
+        _activeInvExecute = false;
+        _activeObject2Inv = false;
+        _activeObjectObtained = false;
+        _activeObject2Obtained = false;
 }
 
 ScummEngine_v6::ScummEngine_v6(OSystem *syst, const DetectorResult &dr)

engines/scumm/scumm.h

@@ -565 +565 @@
         int32 *_scummVars;
         byte *_bitVars;
 
+        bool _v0ObjectIndex;                    // V0 Use object index, instead of object number
+        bool _v0ObjectInInventory;              // V0 Use object number from inventory
+
         /* Global resource tables */
         int _numVariables, _numBitVariables, _numLocalObjects;
         int _numGlobalObjects, _numArray, _numVerbs, _numFlObject;
@@ -858 +861 @@
         int getObjNewDir(int obj);
         int getObjectIndex(int object) const;
         int getObjectImageCount(int object);
+        int whereIsObjectInventory(int object);
         int whereIsObject(int object) const;
         int findObject(int x, int y);
         void findObjectInRoom(FindObjectInRoom *fo, byte findWhat, uint object, uint room);

engines/scumm/scumm_v0.h

@@ -36 +36 @@
 class ScummEngine_v0 : public ScummEngine_v2 {
 protected:
         int _currentMode;
+        bool _verbExecuting;                    // is a verb executing
+        bool _verbPickup;                               // are we picking up an object during a verb execute
 
+        int _activeActor;                               // Actor Number
+        int _activeObject2;                             // 2nd Object Number
+
+        bool _activeInvExecute;                 // is activeInventory first to be executed
+        bool _activeObject2Inv;                 // is activeobject2 in the inventory
+        bool _activeObjectObtained;             // collected _activeobject?
+        bool _activeObject2Obtained;    // collected _activeObject2?
+
+        int _activeObjectIndex;
+        int _activeObject2Index;
+
 public:
         ScummEngine_v0(OSystem *syst, const DetectorResult &dr);
 
@@ -53 +66 @@
 
         virtual void processInput();
 
+        virtual void runObject(int obj, int entry);
         virtual void saveOrLoad(Serializer *s);
 
+        // V0 MM Verb commands
+        int  verbPrep(int object);
+        bool verbMove(int object, int objectIndex, bool invObject);
+        bool verbMoveToActor(int actor);
+        bool verbObtain(int object, int objIndex);
+        bool verbExecutes(int object, bool inventory = false);
+        bool verbExec();
+
+        int findObjectIndex(int x, int y);
+
         virtual void checkExecVerbs();
         virtual void handleMouseOver(bool updateInventory);
         void resetVerbs();
         void setNewKidVerbs();
+
+        void drawSentenceWord(int object, bool usePrep, bool objInInventory);
         void drawSentence();
 
         void switchActor(int slot);
@@ -68 +94 @@
 
         virtual int getActiveObject();
 
-        virtual void resetSentence();
+        virtual void resetSentence(bool walking = false);
 
         /* Version C64 script opcodes */
         void o_stopCurrentScript();

engines/scumm/scumm_v2.h

@@ -100 +100 @@
 
         virtual void setBuiltinCursor(int index);
 
-        void runObject(int obj, int entry);
+        virtual void runObject(int obj, int entry);
 
         /* Version 2 script opcodes */
         void o2_actorFromPos();

engines/scumm/vars.cpp

@@ -538 +538 @@
 #endif
 
 void ScummEngine_v0::resetScummVars() {
-        _activeInventory = 0;
-        _activeObject = 0;
-        _activeVerb = 13;
+        resetSentence();
 
         VAR(VAR_EGO) = 3;
 

engines/scumm/verbs.cpp

@@ -155 +155 @@
         VAR(VAR_EGO) = VAR(97 + slot);
         actorFollowCamera(VAR(VAR_EGO));
         resetVerbs();
+        resetSentence(false);
         setUserState(247);
 }
 
@@ -376 +377 @@
 
         if (object > 0) {
                 if (_game.version == 0) {
-                        if (_activeInventory != object) {
                                 _activeInventory = object;
-                        } else if (_activeVerb != 3 && _activeVerb != 13) {
-                                if (_activeObject)
-                                        runObject(_activeObject, _activeVerb);
-                                else
-                                        runObject(_activeInventory, _activeVerb);
-                        }
+
                 } else {
                         runInputScript(kInventoryClickArea, object, 0);
                 }
@@ -425 +420 @@
                 _string[1].right = _mouseOverBoxesV2[i].rect.right - 1;
                 _string[1].color = _mouseOverBoxesV2[i].color;
 
+                _v0ObjectInInventory = true;
                 const byte *tmp = getObjOrActorName(obj);
+                _v0ObjectInInventory = false;
                 assert(tmp);
 
                 // Prevent inventory entries from overflowing by truncating the text
@@ -666 +663 @@
         }
 }
 
+void ScummEngine_v0::runObject(int obj, int entry) {
+        int prev = _v0ObjectInInventory;
+
+        if (getVerbEntrypoint(obj, entry) != 0) {
+                _v0ObjectInInventory = prev;
+                runObjectScript(obj, entry, false, false, NULL);
+        } else if (entry != 13 && entry != 15) {
+                if( _activeVerb != 0x03 ) {
+                        VAR(9) = entry;
+                        runScript(3, 0, 0, 0);
+
+                        // For some reasons, certain objects don't have a "give" script
+                } else if(VAR(5) > 0 && VAR(5) < 8)
+                                if(_activeInventory)
+                                        setOwnerOf( _activeInventory, VAR(5) );
+        }
+}
+
 void ScummEngine_v2::runObject(int obj, int entry) {
         if (getVerbEntrypoint(obj, entry) != 0) {
                 runObjectScript(obj, entry, false, false, NULL);
@@ -679 +694 @@
         _activeVerb = 13;
 }
 
+static int getDist(int x, int y, int x2, int y2) {
+        int a = ABS(y - y2);
+        int b = ABS(x - x2);
+        return MAX(a, b);
+}
+
+bool ScummEngine_v0::verbMoveToActor(int actor) {
+        Actor *a = derefActor(VAR(VAR_EGO), "checkExecVerbs");
+        Actor *a2 =derefActor(actor, "checkExecVerbs");
+
+
+        if(!a->_moving) {
+                int dist =  getDist(a->getRealPos().x, a->getRealPos().y, a2->getRealPos().x, a2->getRealPos().y);
+
+                if(dist>5)
+                        a->startWalkActor( a2->getRealPos().x, a2->getRealPos().y, 1 );
+                else
+                        return false;
+
+                return true;
+        } 
+
+        return true;
+}
+
+bool ScummEngine_v0::verbMove(int object, int objectIndex, bool invObject) {
+        int x, y, dir;
+        Actor *a = derefActor(VAR(VAR_EGO), "checkExecVerbs");
+
+        if(_currentMode != 3 && _currentMode != 2)
+                return false;
+
+        if(a->_moving)
+                return true;
+
+        _v0ObjectIndex = true;
+        getObjectXYPos(objectIndex, x, y, dir);
+        _v0ObjectIndex = false;
+        // Detect distance from target object, I wasn't able to use Scumm::getDist, it wouldn't compile
+        // So i c/p it above
+        int dist =  getDist(a->getRealPos().x, a->getRealPos().y, x, y);
+
+        // FIXME: This should be changed once the walkbox problem is fixed
+        if(dist>0x5) {
+                a->startWalkActor(x, y, dir);
+                VAR(6) = x;
+                VAR(7) = y;
+                return true;
+        } else {
+
+                // Finished walk, are we picking up the item?
+                if(_verbPickup) {
+                        int oldActive = _activeObject, oldIndex = _activeObjectIndex;
+                        _activeObject = object;
+                        _activeObjectIndex = objectIndex;
+
+                        _v0ObjectIndex = true;
+                        // Execute pickup 
+                        runObject(objectIndex, 0x0E );                  
+                        _v0ObjectIndex = false;
+
+                        _activeObject = oldActive;
+                        _activeObjectIndex = oldIndex;
+
+                        // Finished picking up
+                        _verbPickup = false;
+                }       
+        }
+
+        return false;
+}
+
+bool ScummEngine_v0::verbObtain(int obj, int objIndex) {
+        bool didPickup = false;
+
+        int prep, where = whereIsObjectInventory( obj );
+
+        if(objIndex==0)
+                return false;
+
+        if(where != WIO_INVENTORY) {
+                _v0ObjectIndex = true;
+                prep = verbPrep( objIndex );
+
+                if(prep == 1 || prep == 4) {
+                        if(_activeVerb != 13 && _activeVerb != 0x0E) {
+                                _verbPickup = true;
+                                didPickup = true;
+                        }
+                } else
+                        _verbPickup = false;
+
+                if( verbMove( obj, objIndex, false ) )
+                        return true;
+
+                if(didPickup && (prep == 1 || prep == 4))
+                        if(_activeVerb != 13 && _activeVerb != 0x0E)
+                                _activeInventory = obj;
+        }
+
+        return false;
+}
+
+int ScummEngine_v0::verbPrep(int object) {
+        if(!_v0ObjectInInventory)       
+                _v0ObjectIndex = true;
+        else
+                _v0ObjectIndex = false;
+        byte *ptr = getOBCDFromObject(object);
+        _v0ObjectIndex = false;
+        assert(ptr);
+        return (*(ptr + 11) >> 5);
+}
+
+bool ScummEngine_v0::verbExecutes( int object, bool inventory ) {
+        _v0ObjectInInventory = inventory;
+        int prep = verbPrep( object );
+
+        if( prep == 2 || prep == 0) {
+                return true;
+        }
+
+        return false;
+}
+
+bool ScummEngine_v0::verbExec() {
+        int     where = 0, prep = 0;
+        int entry = (_currentMode != 0 && _currentMode != 1) ? _activeVerb : 15;
+
+        if((!_activeInvExecute && _activeObject && getObjectIndex(_activeObject)==-1) ) {
+                resetSentence();
+                return false;
+        }
+
+        // Lets try walk to the object
+        if(_activeObject && _activeObjectIndex && !_activeObjectObtained && _currentMode != 0) {
+                prep = verbPrep(_activeObjectIndex);
+                
+                if( verbObtain( _activeObject, _activeObjectIndex ) )
+                        return true;
+
+                _activeObjectObtained = true;
+        }
+
+        if(_activeObject2 && _activeObject2Index && !_activeObject2Obtained && _currentMode != 0) {
+                prep = verbPrep(_activeObject2Index);
+
+                _v0ObjectInInventory = false;
+                if(verbObtain(_activeObject2, _activeObject2Index))
+                        return true;
+                
+                if(prep != 1 && prep != 4) {
+                        _activeInventory = _activeObject;
+                        _activeObject = _activeObject2;
+                        _activeObjectIndex = _activeObject2Index;
+                        _activeObject2 = 0;
+                        _activeObject2Index = 0;
+                }
+
+                _activeObject2Obtained = true;
+        }
+
+        // Give-To
+        if(_activeVerb==0x03 && _activeInventory && _activeActor) {
+                // FIXME: Actors need to turn and face each other
+                // And walk to each other
+                //
+                if( verbMoveToActor(_activeActor) )
+                        return true;
+
+                _v0ObjectInInventory = true;
+                VAR(5) = _activeActor;
+                runObject(_activeInventory , 0x03 );
+                _v0ObjectInInventory = false;
+
+                resetSentence();
+                return false;
+        }
+
+        if(_activeActor) {
+                _v0ObjectIndex = true;
+                runObject(_activeActor, entry);
+                _v0ObjectIndex = false;
+                _verbExecuting = false;
+
+                resetSentence();
+                return false;
+        }
+
+        // If we've finished walking (now near target), execute the action
+        if(_activeObject && _activeObjectIndex && verbPrep(_activeObjectIndex) == 2) {
+
+                _v0ObjectIndex = true;
+                runObject(_activeObjectIndex, entry);
+                _v0ObjectIndex = false;
+                _verbExecuting = false;
+
+                if((_currentMode == 3 || _currentMode == 2) && _activeVerb==13)
+                        return false;
+
+                resetSentence();
+                return false;
+        }
+
+        // We acted on an inventory item
+        if( _activeInventory && verbExecutes(_activeInventory, true) && _activeVerb != 0x03 ) {
+                
+                _v0ObjectInInventory = true;
+                runObject(_activeInventory, _activeVerb);
+                
+                _verbExecuting = false;
+
+                if(_currentMode == 3 && _activeVerb==13) {
+                        resetSentence(true);
+                        return false;
+                }
+                
+                resetSentence();
+                return false;
+        }
+
+        if(_activeObject) {
+                _v0ObjectIndex = true;
+                runObject(_activeObjectIndex, entry);
+                _v0ObjectIndex = false;
+        } else if(_activeInventory ) {
+
+                if(verbExecutes(_activeInventory, true) == false) {
+                        
+                        if(_activeObject2 && verbExecutes(_activeObject2, true)) {
+                                _v0ObjectInInventory = true;
+                                
+                                _activeObject = _activeInventory;
+                                _activeInventory = _activeObject2;
+                                
+                                runObject(_activeObject, _activeVerb);
+                        } else {
+                                _v0ObjectInInventory = true;
+                                runObject(_activeInventory, _activeVerb);
+                        }
+                } else {
+                        runObject(_activeInventory, _activeVerb);
+                        _v0ObjectInInventory = true;
+                }
+        }
+
+        _verbExecuting = false;
+
+        if(_activeVerb==0xD) {
+                resetSentence(true);
+                return false;
+        }
+
+        resetSentence();
+
+        return false;
+}
+
 void ScummEngine_v0::checkExecVerbs() {
         Actor *a;
         VirtScreen *zone = findVirtScreen(_mouse.y);
 
+        // Is a verb currently executing
+        if( _verbExecuting ) {
+
+                // Check if mouse click
+                if (_mouseAndKeyboardStat & MBS_MOUSE_MASK) {
+                        int over = findVerbAtPos(_mouse.x, _mouse.y);
+                        int act  = getActorFromPos(_virtualMouse.x, _virtualMouse.y);
+                        int obj  = findObject(_virtualMouse.x, _virtualMouse.y);
+                        
+                        if(over && over != _activeVerb) {
+                                _activeVerb = over;
+                                _verbExecuting = false;
+                                return;
+                        }
+
+                        if(!obj && !act && !over) {
+                                resetSentence( false ); 
+                        } else {
+                                a = derefActor(VAR(VAR_EGO), "checkExecVerbs");
+                                a->stopActorMoving();
+                        }
+                } else {
+                        if(_verbExecuting)
+                                if(!verbExec())
+                                        return;
+                }
+        }
+
+        // What-Is selected, any object we hover over is selected, on mouse press we set to WalkTo
+        if(_activeVerb == 0x0F) {
+                int obj = findObject(_virtualMouse.x, _virtualMouse.y);
+                int objIdx = findObjectIndex(_virtualMouse.x, _virtualMouse.y);
+                _activeObject = obj;
+                _activeObjectIndex = objIdx;
+
+                if((_mouseAndKeyboardStat & MBS_MOUSE_MASK))
+                        _activeVerb = 13;       // Walk-To
+
+                return;
+        }
+
         if (_userPut <= 0 || _mouseAndKeyboardStat == 0)
                 return;
 
@@ -693 +1007 @@
                 if (zone->number == kVerbVirtScreen && _mouse.y <= zone->topline + 8) {
                         // TODO
                 } else if (zone->number == kVerbVirtScreen && _mouse.y > zone->topline + 32) {
+                        int prevInventory = _activeInventory;
+
                         // Click into V2 inventory
                         checkV2Inventory(_mouse.x, _mouse.y);
+                        if(!_activeInventory)
+                                return;
+                        
+                        // Did we just change the selected inventory item?
+                        if(prevInventory && prevInventory != _activeInventory && _activeInventory != _activeObject2) {
+                                _activeObject = 0;
+                                _activeInvExecute = true;
+                                _activeObject2Inv = true;
+                                _activeObject2 = _activeInventory;
+                                _activeInventory = prevInventory;
+                                return;
+                        }
+
+                        // is the new selected inventory the same as the last selected?, reset to previous if it is
+                        if(_activeInventory == _activeObject2)
+                                _activeInventory = prevInventory;
+
+                        // Inventory Selected changed
+                        if(prevInventory != _activeInventory)
+                                if(!_activeObject2 || prevInventory != _activeObject2 )
+                                        return;
+
+                        if(_activeVerb == 0x0B && !((!(_activeObject || _activeInventory)) || !_activeObject2))
+                                return;
+
                 } else {
                         int over = findVerbAtPos(_mouse.x, _mouse.y);
+                        int act  = getActorFromPos(_virtualMouse.x, _virtualMouse.y);
+                        int obj  = findObject(_virtualMouse.x, _virtualMouse.y);
+                        int objIdx = findObjectIndex(_virtualMouse.x, _virtualMouse.y);
 
+                        if((_activeObject || _activeInventory) && act) {
+                                obj = 0;
+                                objIdx = 0;
+                        }
+
                         // Handle New Kid verb options
-                        if (_activeVerb == 7) {
+                        if (_activeVerb == 7 || over == 7) {
+
+                                // Disable New-Kid (in the secret lab)
+                                if( _currentMode == 2 || _currentMode == 0)
+                                        return;
+
+                                if(_activeVerb != 7) {
+                                        _activeVerb = over;
+                                        over = 0;
+                                } 
+
                                 if (over) {
                                         _activeVerb = 13;
                                         switchActor(_verbs[over].verbid - 1);
+                                        return;
                                 }
+
+                                setNewKidVerbs();
+
                                 return;
                         }
+                        
+                        // Clicked on nothing, walk here?
+                        if(!over && !act && _activeVerb==13 && !obj && _currentMode != 0 ) {
 
-                        if (over) {
-                                _activeVerb = _verbs[over].verbid;
-                                // Selected New Kid verb
-                                if (_activeVerb == 7)
-                                        setNewKidVerbs();
+                                // Clear all selected
+                                resetSentence();
 
+                                // 0xB31
+                                VAR(6) = _virtualMouse.x / V12_X_MULTIPLIER;
+                                VAR(7) = _virtualMouse.y / V12_Y_MULTIPLIER;
+
+                                if (zone->number == kMainVirtScreen) {
+                                        a = derefActor(VAR(VAR_EGO), "checkExecVerbs");
+                                        a->stopActorMoving();
+                                        a->startWalkActor(_virtualMouse.x / V12_X_MULTIPLIER, _virtualMouse.y / V12_Y_MULTIPLIER, -1);
+                                }
                                 return;
                         }
 
-                        int act = getActorFromPos(_virtualMouse.x, _virtualMouse.y);
-                        int obj = findObject(_virtualMouse.x, _virtualMouse.y);
-                        if (act != 0 && _activeVerb == 3 && _activeInventory != 0) {
-                                // Give inventory item to actor
-                                VAR(5) = act;
-                                runObject(_activeInventory, _activeVerb);
-                        } else if (obj) {
-                                if (_currentMode == 3 && _activeVerb != 13 && obj != _activeObject) {
-                                        _activeObject = obj;
-                                        return;
+                        // No new verb, use previous
+                        if(over==0)
+                                over = _activeVerb;
+
+                        // No verb selected, use walk-to
+                        if(!_activeVerb)
+                                _activeVerb = over = 13;                // Walk-To
+
+                        // New verb selected
+                        if(_activeVerb != over) {
+                                _activeVerb = over;
+                                if(_activeVerb==0x0D) {
+                                        resetSentence();
                                 }
+                                return;
+                        }
 
-                                _activeObject = obj;
-                                if (_currentMode == 3) {
-                                        int x, y, dir;
-                                        a = derefActor(VAR(VAR_EGO), "checkExecVerbs");
-                                        getObjectXYPos(obj, x, y, dir);
-                                        a->startWalkActor(x, y, dir);
+                        // Only allowing targetting actors if its the GIVE/USE verb
+                        if(_activeVerb == 0x03 || _activeVerb == 0x0B) {
+                                // Different actor selected?
+                                if(act) {
+                                        if( _activeActor != act ) {
+                                                _activeActor = act;
+                                                return;
+                                        }
                                 }
+                        }
 
-                                int entry = (_currentMode == 3) ? _activeVerb : 15;
-                                runObject(_activeObject, entry);
-                        } else if (zone->number == kMainVirtScreen) {
-                                a = derefActor(VAR(VAR_EGO), "checkExecVerbs");
-                                a->startWalkActor(_virtualMouse.x / V12_X_MULTIPLIER, _virtualMouse.y / V12_Y_MULTIPLIER, -1);
+                        if(obj && obj != _activeObject) {
+                                if(!_activeObject)
+                                        if(_activeInventory)
+                                                _activeInvExecute = true;
+
+                                // USE
+                                if(_activeVerb == 0x0b || _activeVerb == 0x08) {
+                                        if(obj != _activeObject || obj != _activeObject2 ) {
+                                                if(!_activeObject || _activeInventory) {
+                                                        _activeObject = obj;
+                                                        _activeObjectIndex = objIdx;
+                                                        return;
+                                                } else
+                                                        if(_activeObject2 != obj) {
+                                                                _activeObject2 = obj;
+                                                                _activeObject2Index = objIdx;
+                                                                return;
+                                                        }
+                                        }
+                                } else {
+                                
+                                        _activeObject = obj;
+                                        _activeObjectIndex = objIdx;
+                                                
+                                        if(_activeVerb!=13)
+                                                return;
+                                        
+                                        //return;
+                                }
                         }
+                }
 
-                        _activeInventory = 0;
-                        _activeObject = 0;
-                        _activeVerb = 13;
-                }
-        }
+                _verbExecuting = true;
+
+        }       // mouse k/b action
+
 }
 
 void ScummEngine::verbMouseOver(int verb) {