home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 February / chip_20022115.iso / amiga / chipgame / scummvm_aga.lha / ScummVM_AGA / src / script.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2002-01-05  |  20.9 KB  |  968 lines
  1. /* ScummVM - Scumm Interpreter
  2.  * Copyright (C) 2001  Ludvig Strigeus
  3.  *
  4.  * This program is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public License
  6.  * as published by the Free Software Foundation; either version 2
  7.  * of the License, or (at your option) any later version.
  8.  
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17.  *
  18.  * $Header: /cvsroot/scummvm/scummvm/script.cpp,v 1.10 2001/11/09 18:54:14 strigeus Exp $
  19.  *
  20.  */
  21.  
  22. #include "stdafx.h"
  23. #include "scumm.h"
  24.  
  25. #define NO_SOUND_HACK
  26.  
  27. void Scumm::runScript(int script, int a, int b, int16 *lvarptr) {
  28.     byte *scriptPtr;
  29.     uint32 scriptOffs;
  30.     byte scriptType;
  31.     int slot;
  32.     ScriptSlot *s;
  33.  
  34. #ifdef NO_SOUND_HACK
  35.     if (script==212 && _currentRoom==50)
  36.         return;
  37. #endif
  38.  
  39.     if (script==0)
  40.         return;
  41.  
  42.     if (b==0)
  43.         stopScriptNr(script);
  44.  
  45.     if (script < _numGlobalScripts) {
  46.         scriptPtr = getResourceAddress(rtScript, script);
  47.         scriptOffs = 8;
  48.         scriptType = 2;
  49.     } else {
  50.         scriptOffs = _localScriptList[script - _numGlobalScripts];
  51.         if (scriptOffs == 0)
  52.             error("Local script %d is not in room %d", script, _roomResource);
  53.         scriptOffs += 9;
  54.         scriptType = 3;
  55.     }
  56.  
  57.     slot = getScriptSlot();
  58.  
  59.     s = &vm.slot[slot];
  60.     s->number = script;
  61.     s->offs = scriptOffs;
  62.     s->status = 2;
  63.     s->type = scriptType;
  64.     s->unk1 = a;
  65.     s->unk2 = b;
  66.     s->freezeCount = 0;
  67.  
  68.     initializeLocals(slot, lvarptr);
  69.     
  70.     runScriptNested(slot);
  71. }
  72.  
  73. void Scumm::stopScriptNr(int script) {
  74.     ScriptSlot *ss;
  75.     NestedScript *nest;
  76.     int i,num;
  77.  
  78.     if (script==0)
  79.         return;
  80.  
  81.     ss = &vm.slot[1];
  82.     
  83.     for (i=1; i<NUM_SCRIPT_SLOT; i++,ss++) {
  84.         if (script!=ss->number || ss->type!=2 && ss->type!=3 || ss->status==0)
  85.             continue;
  86.  
  87.         if (ss->cutsceneOverride)
  88.             error("Script %d stopped with active cutscene/override", script);
  89.         ss->number = 0;
  90.         ss->status = 0;
  91.         if (_currentScript == i)
  92.             _currentScript = 0xFF;
  93.     }
  94.  
  95.     if (_numNestedScripts==0)
  96.         return;
  97.  
  98.     nest = &vm.nest[0];
  99.     num = _numNestedScripts;
  100.  
  101.     do {
  102.         if (nest->number == script && (nest->type==2 || nest->type==3)) {
  103.             nest->number = 0xFF;
  104.             nest->slot = 0xFF;
  105.             nest->type = 0xFF;
  106.         }
  107.     } while(nest++,--num);
  108. }
  109.  
  110. void Scumm::stopObjectScript(int script) {
  111.     ScriptSlot *ss;
  112.     NestedScript *nest;
  113.     int i,num;
  114.  
  115.     if (script==0)
  116.         return;
  117.  
  118.     ss = &vm.slot[1];
  119.     
  120.     for (i=1; i<NUM_SCRIPT_SLOT; i++,ss++) {
  121.         if (script==ss->number && (ss->type==1 || ss->type==0 || ss->type==4) && ss->status!=0) {
  122.             if (ss->cutsceneOverride)
  123.                 error("Object %d stopped with active cutscene/override", script);
  124.             ss->number = 0;
  125.             ss->status = 0;
  126.             if (_currentScript == i)
  127.                 _currentScript = 0xFF;
  128.         }
  129.     }
  130.  
  131.     if (_numNestedScripts==0)
  132.         return;
  133.  
  134.     nest = &vm.nest[0];
  135.     num = _numNestedScripts;
  136.  
  137.     do {
  138.         if (nest->number == script && (nest->type==1 || nest->type==4 || nest->type==0)) {
  139.             nest->number = 0xFF;
  140.             nest->slot = 0xFF;
  141.             nest->type = 0xFF;
  142.         }
  143.     } while(nest++,--num);
  144. }
  145.  
  146. int Scumm::getScriptSlot() {
  147.     ScriptSlot *ss;
  148.     int i;
  149.     ss = &vm.slot[1];
  150.     
  151.     for (i=1; i<NUM_SCRIPT_SLOT; i++,ss++) {
  152.         if(ss->status==0)
  153.             return i;
  154.     }
  155.     error("Too many scripts running, %d max", NUM_SCRIPT_SLOT);
  156. }
  157.  
  158. void Scumm::runScriptNested(int script) {
  159.     NestedScript *nest;
  160.     ScriptSlot *slot;
  161.  
  162.     updateScriptPtr();
  163.     
  164.     nest = &vm.nest[_numNestedScripts];
  165.  
  166.     if (_currentScript==0xFF) {
  167.         nest->number = 0xFF;
  168.         nest->type = 0xFF;
  169.     } else {
  170.         slot = &vm.slot[_currentScript];
  171.         nest->number = slot->number;
  172.         nest->type = slot->type;
  173.         nest->slot = _currentScript;
  174.     }
  175.  
  176.     if (++_numNestedScripts>sizeof(vm.nest)/sizeof(vm.nest[0]))
  177.         error("Too many nested scripts");
  178.  
  179.     _currentScript = script;
  180.  
  181.     getScriptBaseAddress();
  182.     getScriptEntryPoint();
  183.     executeScript();
  184.  
  185.     _numNestedScripts--;
  186.  
  187.     nest = &vm.nest[_numNestedScripts];
  188.     
  189.     if (nest->number != 0xFF) {
  190.         slot = &vm.slot[nest->slot];
  191.         if (slot->number == nest->number && slot->type==nest->type &&
  192.             slot->status != 0 && slot->freezeCount==0) {
  193.             _currentScript = nest->slot;
  194.             getScriptBaseAddress();
  195.             getScriptEntryPoint();
  196.             return;
  197.         }
  198.     }
  199.     _currentScript = 0xFF;
  200. }
  201.  
  202. void Scumm::updateScriptPtr() {
  203.     if (_currentScript == 0xFF)
  204.         return;
  205.  
  206.     vm.slot[_currentScript].offs = _scriptPointer - _scriptOrgPointer;
  207. }
  208.  
  209. void Scumm::getScriptBaseAddress() {
  210.     ScriptSlot *ss;
  211.     int index;
  212.  
  213.     if (_currentScript == 0xFF)
  214.         return;
  215.  
  216.     ss = &vm.slot[_currentScript];
  217.     switch(ss->type) {
  218.     case 0: /* inventory script **/
  219.         index = getObjectIndex(ss->number);
  220.         _scriptOrgPointer = getResourceAddress(rtInventory, index);
  221.         _lastCodePtr = &_baseInventoryItems[index];
  222.         break;
  223.  
  224.     case 3:
  225.     case 1: /* room script */
  226.         _scriptOrgPointer = getResourceAddress(rtRoom, _roomResource);
  227.         _lastCodePtr = &_baseRooms[_roomResource];
  228.         break;
  229.  
  230.     case 2: /* global script */
  231.         _scriptOrgPointer = getResourceAddress(rtScript, ss->number);
  232.         _lastCodePtr = &_baseScripts[ss->number];
  233.         break;
  234.  
  235.     case 4: /* flobject script */
  236.         index = getObjectIndex(ss->number);
  237.         _scriptOrgPointer = getResourceAddress(rtFlObject,_objs[index].fl_object_index);
  238.         _lastCodePtr = &_baseFLObject[ss->number];
  239.         break;
  240.     default:
  241.         error("Bad type while getting base address");
  242.     }
  243. }
  244.  
  245.  
  246. void Scumm::getScriptEntryPoint() {
  247.     if (_currentScript == 0xFF)
  248.         return;
  249.     _scriptPointer = _scriptOrgPointer + vm.slot[_currentScript].offs;
  250. }
  251.  
  252. void Scumm::executeScript() {
  253.     OpcodeProc op;
  254.     while (_currentScript != 0xFF) {
  255.         _opcode = fetchScriptByte();
  256.         _scriptPointerStart = _scriptPointer;
  257.         vm.slot[_currentScript].didexec = 1;
  258. //        debug(1, "%X", _opcode);
  259.         op = getOpcode(_opcode);
  260.         (this->*op)();
  261.     }
  262.     CHECK_HEAP
  263. }
  264.  
  265. byte Scumm::fetchScriptByte() {
  266.     if (*_lastCodePtr + sizeof(ResHeader) != _scriptOrgPointer) {
  267.         uint32 oldoffs = _scriptPointer - _scriptOrgPointer;
  268.         getScriptBaseAddress();
  269.         _scriptPointer = _scriptOrgPointer + oldoffs;
  270.     }
  271.     return *_scriptPointer++;
  272. }
  273.  
  274. int Scumm::fetchScriptWord() {
  275.     int a;
  276.     if (*_lastCodePtr + sizeof(ResHeader) != _scriptOrgPointer) {
  277.         uint32 oldoffs = _scriptPointer - _scriptOrgPointer;
  278.         getScriptBaseAddress();
  279.         _scriptPointer = _scriptOrgPointer + oldoffs;
  280.     }
  281.     a = READ_LE_UINT16(_scriptPointer);
  282.     _scriptPointer += 2;
  283.     return a;
  284. }
  285.  
  286. int Scumm::readVar(uint var) {
  287.     int a;
  288. #ifdef BYPASS_COPY_PROT
  289.     static byte copyprotbypassed;
  290. #endif
  291.     debug(9, "readvar=%d", var);
  292.     if (!(var&0xF000)) {
  293.         checkRange(_numVariables-1, 0, var, "Variable %d out of range(r)");
  294.         return _vars[var];
  295.     }
  296.  
  297.     if (var&0x2000 && _majorScummVersion==5) {
  298.         a = fetchScriptWord();
  299.         if (a&0x2000)
  300.             var = (var+readVar(a&~0x2000))&~0x2000;
  301.         else
  302.             var = (var+(a&0xFFF))&~0x2000;
  303.     }
  304.  
  305.     if (!(var&0xF000))
  306.         return _vars[var];
  307.  
  308.     if (var&0x8000) {
  309.         var &= 0x7FFF;
  310.         checkRange(_numBitVariables-1, 0, var, "Bit variable %d out of range(r)");
  311.         return (_bitVars[var>>3] & (1<<(var&7))) ? 1 : 0;
  312.     }
  313.  
  314.     if (var&0x4000) {
  315.         var &= 0xFFF;
  316.         checkRange(0x10, 0, var, "Local variable %d out of range(r)");
  317.  
  318. #if defined(BYPASS_COPY_PROT)
  319.         if (!copyprotbypassed && _currentScript==1 && _gameId==GID_MONKEY2 && var==0) {
  320.             copyprotbypassed=1;
  321.             return 1;
  322.         }
  323. #endif
  324.         return vm.localvar[_currentScript][var];
  325.     }
  326.  
  327.     error("Illegal varbits (r)");
  328. }
  329.  
  330. void Scumm::writeVar(uint var, int value) {
  331.     int a;
  332.  
  333.     if (!(var&0xF000)) {
  334.         checkRange(_numVariables-1, 0, var, "Variable %d out of range(w)");
  335.         _vars[var] = value;
  336.         return;
  337.     }
  338.  
  339.     if (var&0x8000) {
  340.         var &= 0x7FFF;
  341.         checkRange(_numBitVariables-1, 0, var, "Bit variable %d out of range(w)");
  342.         if (value)
  343.             _bitVars[var>>3] |= (1<<(var&7));
  344.         else
  345.             _bitVars[var>>3] &= ~(1<<(var&7));
  346.         return;
  347.     }
  348.  
  349.     if (var&0x4000) {
  350.         var &= 0xFFF;
  351.         checkRange(0x10, 0, var, "Local variable %d out of range(w)");
  352.         vm.localvar[_currentScript][var] = value;
  353.         return;
  354.     }
  355.  
  356.     error("Illegal varbits (w)");
  357. }
  358.  
  359. void Scumm::getResultPos() {
  360.     int a;
  361.  
  362.     _resultVarNumber = fetchScriptWord();
  363.     if (_resultVarNumber&0x2000) {
  364.         a = fetchScriptWord();
  365.         if (a&0x2000) {
  366.             _resultVarNumber += readVar(a&~0x2000);
  367.         } else {
  368.             _resultVarNumber += a&0xFFF;
  369.         }
  370.         _resultVarNumber&=~0x2000;
  371.     }
  372. }
  373.  
  374. void Scumm::setResult(int value) {
  375.     writeVar(_resultVarNumber, value);
  376. }
  377.  
  378. void Scumm::drawBox(int x, int y, int x2, int y2, int color) {
  379.     int top,bottom,count;
  380.     VirtScreen *vs;
  381.     byte *backbuff;
  382.  
  383.     if ((vs=findVirtScreen(y)) == NULL)
  384.         return;
  385.  
  386.     top = vs->topline;
  387.     bottom = top + vs->height;
  388.  
  389.     if (x > x2)
  390.         SWAP(x,x2);
  391.  
  392.     if (y > y2)
  393.         SWAP(y,y2);
  394.  
  395.     x2++;
  396.     y2++;
  397.  
  398.     if (x>319) return;
  399.     if (x<0) x=0;
  400.     if (x2<0) return;
  401.     if (x2>320) x2=320;
  402.     if (y2 > bottom) y2=bottom;
  403.  
  404.     updateDirtyRect(vs->number, x, x2, y-top, y2-top, 0);
  405.  
  406.     backbuff = getResourceAddress(rtBuffer, vs->number+1) + vs->xstart + (y-top)*320 + x;
  407.  
  408.     count = y2 - y;
  409.     while (count) {
  410.         memset(backbuff, color, x2 - x);
  411.         backbuff += 320;
  412.         count--;
  413.     }
  414. }
  415.  
  416.  
  417. void Scumm::stopObjectCode() {
  418.     ScriptSlot *ss;
  419.  
  420.     ss = &vm.slot[_currentScript];
  421.  
  422.     if (ss->type!=2 && ss->type!=3) {
  423.         if (ss->cutsceneOverride)
  424.             error("Object %d ending with active cutscene/override", ss->number);
  425.         
  426.         /* I wonder if the removal of this breaks anything.
  427.          * put ss->number and ss->status at another place if using this
  428.         * stopObjectScript(ss->number); */
  429.     } else {
  430.         if (ss->cutsceneOverride)
  431.             error("Script %d ending with active cutscene/override", ss->number);
  432.     }
  433.     ss->number = 0;
  434.     ss->status = 0;
  435.     _currentScript = 0xFF;
  436. }
  437.  
  438. bool Scumm::isScriptInUse(int script) {
  439.     ScriptSlot *ss;
  440.     int i;
  441.  
  442.     ss = vm.slot;
  443.     for (i=0; i<NUM_SCRIPT_SLOT; i++,ss++) {
  444.         if (ss->number == script)
  445.             return true;
  446.     }
  447.     return false;
  448. }
  449.  
  450. void Scumm::runHook(int i) {
  451.     int16 tmp[16];
  452.     tmp[0] = i;
  453.     if (_vars[VAR_HOOK_SCRIPT]) {
  454.         runScript(_vars[VAR_HOOK_SCRIPT], 0, 0, tmp);
  455.     }
  456. }
  457.  
  458. void Scumm::freezeScripts(int flag) {
  459.     int i;
  460.  
  461.     for(i=1; i<NUM_SCRIPT_SLOT; i++) {
  462.         if (_currentScript!=i && vm.slot[i].status!=0 && (vm.slot[i].unk1==0 || flag>=0x80)) {
  463.             vm.slot[i].status |= 0x80;
  464.             vm.slot[i].freezeCount++;
  465.         }
  466.     }
  467.  
  468.     for (i=0; i<6; i++)
  469.         sentence[i].unk++;
  470.  
  471.     if(vm.cutSceneScriptIndex != 0xFF) {
  472.         vm.slot[vm.cutSceneScriptIndex].status&=0x7F;
  473.         vm.slot[vm.cutSceneScriptIndex].freezeCount=0;
  474.     }
  475. }
  476.  
  477. void Scumm::unfreezeScripts() {
  478.     int i;
  479.     for (i=1; i<NUM_SCRIPT_SLOT; i++) {
  480.         if (vm.slot[i].status&0x80) {
  481.             if (!--vm.slot[i].freezeCount) {
  482.                 vm.slot[i].status&=0x7F;
  483.             }
  484.         }
  485.     }
  486.  
  487.     for (i=0; i<6; i++) {
  488.         if (((int8)--sentence[i].unk)<0)
  489.             sentence[i].unk = 0;
  490.     }
  491. }
  492.  
  493. void Scumm::runAllScripts() {
  494.     int i;
  495.  
  496.     for (i=0; i<NUM_SCRIPT_SLOT; i++)
  497.         vm.slot[i].didexec = 0;
  498.     
  499.     _currentScript = 0xFF;
  500.     for(_curExecScript = 0; _curExecScript<NUM_SCRIPT_SLOT; _curExecScript++) {
  501.         if (vm.slot[_curExecScript].status == 2 &&
  502.             vm.slot[_curExecScript].didexec == 0) {
  503.             _currentScript = _curExecScript;
  504.             getScriptBaseAddress();
  505.             getScriptEntryPoint();
  506.             executeScript();
  507.         }
  508.     }
  509. }
  510.  
  511. void Scumm::runExitScript() {
  512.     if (_vars[VAR_EXIT_SCRIPT])
  513.         runScript(_vars[VAR_EXIT_SCRIPT], 0, 0, 0);
  514.     if (_EXCD_offs) {
  515.         int slot = getScriptSlot();
  516.         vm.slot[slot].status = 2;
  517.         vm.slot[slot].number = 10001;
  518.         vm.slot[slot].type = 1;
  519.         vm.slot[slot].offs = _EXCD_offs + 8;
  520.         vm.slot[slot].unk1 = 0;
  521.         vm.slot[slot].unk2 = 0;
  522.         vm.slot[slot].freezeCount = 0;
  523.         runScriptNested(slot);
  524.     }
  525.     if (_vars[VAR_EXIT_SCRIPT2])
  526.         runScript(_vars[VAR_EXIT_SCRIPT2], 0, 0, 0);
  527. }
  528.  
  529. void Scumm::runEntryScript() {
  530.     if (_vars[VAR_ENTRY_SCRIPT])
  531.         runScript(_vars[VAR_ENTRY_SCRIPT], 0, 0, 0);
  532.     if (_ENCD_offs) {
  533.         int slot = getScriptSlot();
  534.         vm.slot[slot].status = 2;
  535.         vm.slot[slot].number = 10002;
  536.         vm.slot[slot].type = 1;
  537.         vm.slot[slot].offs = _ENCD_offs + 8;
  538.         vm.slot[slot].unk1 = 0;
  539.         vm.slot[slot].unk2 = 0;
  540.         vm.slot[slot].freezeCount = 0;
  541.         runScriptNested(slot);
  542.     }
  543.     if (_vars[VAR_ENTRY_SCRIPT2])
  544.         runScript(_vars[VAR_ENTRY_SCRIPT2], 0, 0, 0);
  545. }
  546.  
  547. void Scumm::killScriptsAndResources() {
  548.     ScriptSlot *ss;
  549.     int i;
  550.  
  551.     ss = &vm.slot[1];
  552.     
  553.     for (i=1; i<NUM_SCRIPT_SLOT; i++,ss++) {
  554.         if (ss->type==1 || ss->type==4) {
  555.             if(ss->cutsceneOverride)
  556.                 error("Object %d stopped with active cutscene/override in exit", ss->number);
  557.             ss->status = 0;
  558.         } else if (ss->type==3) {
  559.             if(ss->cutsceneOverride)
  560.                 error("Script %d stopped with active cutscene/override in exit", ss->number);
  561.             ss->status = 0;
  562.         }
  563.     }
  564.     
  565.     /* Nuke FL objects */
  566.     i = 0;
  567.     do {
  568.         if (_objs[i].fl_object_index)
  569.             nukeResource(rtFlObject, _objs[i].fl_object_index);
  570.     } while (++i <= _numObjectsInRoom);
  571.  
  572.     /* Nuke local object names */
  573.     if (_newNames) {
  574.         for (i=0; i<50; i++) {
  575.             int j = _newNames[i];
  576.             if (j && (getOwner(j)&0xF) == 0) {
  577.                 _newNames[i] = 0;
  578.                 nukeResource(rtObjectName, i);
  579.             }
  580.         }
  581.     }
  582. }
  583.  
  584. void Scumm::checkAndRunVar33() {
  585.     int i;
  586.     ScriptSlot *ss;
  587.  
  588.     memset(_localParamList, 0, sizeof(_localParamList));
  589.     if (isScriptInUse(_vars[VAR_SENTENCE_SCRIPT])) {
  590.         ss = vm.slot;
  591.         for (i=0; i<NUM_SCRIPT_SLOT; i++,ss++)
  592.             if (ss->number==_vars[VAR_SENTENCE_SCRIPT] && ss->status!=0 && ss->freezeCount==0)
  593.                 return;
  594.     }
  595.  
  596.     if (_sentenceIndex > 0x7F || sentence[_sentenceIndex].unk)
  597.         return;
  598.     
  599.     if (sentence[_sentenceIndex].unk2 && 
  600.         sentence[_sentenceIndex].unk3==sentence[_sentenceIndex].unk4) {
  601.         _sentenceIndex--;
  602.         return;
  603.     }
  604.  
  605.     _localParamList[0] = sentence[_sentenceIndex].unk5;
  606.     _localParamList[1] = sentence[_sentenceIndex].unk4;
  607.     _localParamList[2] = sentence[_sentenceIndex].unk3;
  608.     _sentenceIndex--;
  609.     _currentScript = 0xFF;
  610.     if (_vars[VAR_SENTENCE_SCRIPT])
  611.         runScript(_vars[VAR_SENTENCE_SCRIPT], 0, 0, _localParamList);
  612. }
  613.  
  614. void Scumm::runInputScript(int a, int cmd, int mode) {
  615.     memset(_localParamList, 0, sizeof(_localParamList));
  616.     _localParamList[0] = a;
  617.     _localParamList[1] = cmd;
  618.     _localParamList[2] = mode;
  619.     if (_vars[VAR_VERB_SCRIPT])
  620.         runScript(_vars[VAR_VERB_SCRIPT], 0, 0, _localParamList);
  621. }
  622.  
  623. void Scumm::decreaseScriptDelay(int amount) {
  624.     ScriptSlot *ss = &vm.slot[0];
  625.     int i;
  626.     for (i=0; i<NUM_SCRIPT_SLOT; i++,ss++) {
  627.         if(ss->status==1) {
  628.             ss->delay -= amount;
  629.             if (ss->delay < 0){
  630.                 ss->status = 2;
  631.                 ss->delay = 0;
  632.             }
  633.         }
  634.     }
  635. }
  636.  
  637. void Scumm::runVerbCode(int object, int entry, int a, int b, int16 *vars) {
  638.     uint32 obcd;
  639.     int slot, where, offs;
  640.  
  641.     if (!object)
  642.         return;
  643.     if (!b)    
  644.         stopObjectScript(object);
  645.  
  646.     where = whereIsObject(object);
  647.  
  648.     if (where == -1) {
  649.         error("Code for object %d not in room %d", object, _roomResource);
  650.     }
  651.  
  652.     obcd = getOBCDOffs(object);
  653.     slot = getScriptSlot();
  654.  
  655.     offs = getVerbEntrypoint(object, entry);
  656.     if (offs==0)
  657.         return;
  658.  
  659.     vm.slot[slot].number = object;
  660.     vm.slot[slot].offs = obcd + offs;
  661.     vm.slot[slot].status = 2;
  662.     vm.slot[slot].type = where;
  663.     vm.slot[slot].unk1 = a;
  664.     vm.slot[slot].unk2 = b;
  665.     vm.slot[slot].freezeCount = 0;
  666.     vm.slot[slot].newfield = 0;
  667.  
  668.     initializeLocals(slot, vars);
  669.  
  670.     runScriptNested(slot);
  671. }
  672.  
  673. void Scumm::initializeLocals(int slot, int16 *vars) {
  674.     int i;
  675.     if (!vars) {
  676.         for(i=0; i<16; i++)
  677.             vm.localvar[slot][i] = 0;
  678.     } else {
  679.         for (i=0; i<16; i++)
  680.             vm.localvar[slot][i] = vars[i];
  681.     }
  682. }
  683.  
  684. int Scumm::getVerbEntrypoint(int obj, int entry) {
  685.     byte *objptr, *verbptr;
  686.     int verboffs;
  687.  
  688.     if (whereIsObject(obj)==-1)
  689.         return 0;
  690.  
  691.     objptr = getObjectAddress(obj);
  692.     assert(objptr);
  693.  
  694.     verbptr = findResource(MKID('VERB'), objptr, 0);
  695.     if (verbptr==NULL)
  696.         error("No verb block in object %d", obj);
  697.  
  698.     verboffs = verbptr - objptr;
  699.  
  700.     verbptr += 8;
  701.     do {
  702.         if (!*verbptr)
  703.             return 0;
  704.         if (*verbptr==entry || *verbptr==0xFF)
  705.             break;
  706.         verbptr += 3;
  707.     } while (1);
  708.  
  709.     return verboffs + READ_LE_UINT16(verbptr+1);
  710. }
  711.  
  712.  
  713. void Scumm::push(int a) {
  714.     assert(_scummStackPos >=0 && _scummStackPos < sizeof(_scummStack)-1);
  715.     _scummStack[_scummStackPos++] = a;    
  716. }
  717.  
  718. int Scumm::pop() {
  719.     assert(_scummStackPos >0 && _scummStackPos < sizeof(_scummStack));
  720.     return _scummStack[--_scummStackPos];
  721. }
  722.  
  723.  
  724. void Scumm::endCutscene() {
  725.     ScriptSlot *ss = &vm.slot[_currentScript];
  726.     uint32 *csptr;
  727.     int16 args[16];
  728.  
  729.     memset(args, 0, sizeof(args));
  730.     
  731.     ss->cutsceneOverride--;
  732.  
  733.     args[0] = vm.cutSceneData[vm.cutSceneStackPointer];
  734.     _vars[VAR_OVERRIDE] = 0;
  735.  
  736.     csptr = &vm.cutScenePtr[vm.cutSceneStackPointer];
  737.     if (*csptr)
  738.         ss->cutsceneOverride--;
  739.  
  740.     vm.cutSceneScript[vm.cutSceneStackPointer] = 0;
  741.     *csptr = 0;
  742.     vm.cutSceneStackPointer--;
  743.  
  744.     if (_vars[VAR_CUTSCENE_END_SCRIPT])
  745.         runScript(_vars[VAR_CUTSCENE_END_SCRIPT], 0, 0, args);
  746. }
  747.  
  748. void Scumm::cutscene(int16 *args) {
  749.     int scr = _currentScript;
  750.     vm.slot[scr].cutsceneOverride++;
  751.     
  752.     if (++vm.cutSceneStackPointer > sizeof(vm.cutSceneData)/sizeof(vm.cutSceneData[0]))
  753.         error("Cutscene stack overflow");
  754.  
  755.     vm.cutSceneData[vm.cutSceneStackPointer] = args[0];
  756.     vm.cutSceneScript[vm.cutSceneStackPointer] = 0;
  757.     vm.cutScenePtr[vm.cutSceneStackPointer] = 0;
  758.  
  759.     vm.cutSceneScriptIndex = scr;
  760.     if (_vars[VAR_CUTSCENE_START_SCRIPT])
  761.         runScript(_vars[VAR_CUTSCENE_START_SCRIPT], 0, 0, args);
  762.     vm.cutSceneScriptIndex = 0xFF;
  763. }
  764.  
  765. void Scumm::faceActorToObj(int act, int obj) {
  766.     int x,dir;
  767.  
  768.     if (getObjectOrActorXY(act)==-1)
  769.         return;
  770.  
  771.     x = _xPos;
  772.  
  773.     if (getObjectOrActorXY(obj)==-1)
  774.         return;
  775.  
  776.     dir = (_xPos > x) ? 1 : 0;
  777.     turnToDirection(derefActorSafe(act, "faceActorToObj"), dir);
  778. }
  779.  
  780. void Scumm::animateActor(int act, int anim) {
  781.     int shr,dir;
  782.     bool inRoom;
  783.     Actor *a;
  784.  
  785.     a = derefActorSafe(act, "animateActor");
  786.  
  787.     shr = anim>>2;
  788.     dir = anim&3;
  789.  
  790.     inRoom = (a->room == _currentRoom);
  791.  
  792.     if (shr == 0x3F) {
  793.         if (inRoom) {
  794.             startAnimActor(a, a->standFrame, a->facing);
  795.             a->moving = 0;
  796.         }
  797.         return;
  798.     }
  799.  
  800.     if (shr == 0x3E) {
  801.         if (inRoom) {
  802.             startAnimActor(a, 0x3E, dir);
  803.             a->moving &= ~4;
  804.         }
  805.         a->facing = dir;
  806.         return;
  807.     }
  808.  
  809.     if (shr == 0x3D) {
  810.         if (inRoom) {
  811.             turnToDirection(a, dir);
  812.         } else {
  813.             a->facing = dir;
  814.         }
  815.         return;
  816.     }
  817.  
  818.     startAnimActor(a, anim, a->facing);
  819. }
  820.  
  821. int Scumm::getScriptRunning(int script) {
  822.     int i;
  823.     ScriptSlot *ss = vm.slot;
  824.     for (i=0; i<NUM_SCRIPT_SLOT; i++,ss++)
  825.         if (ss->number==script && (ss->type==2 || ss->type==3) && ss->status)
  826.             return 1;
  827.     return 0;
  828. }
  829.  
  830. void Scumm::beginOverride() {
  831.     int index;
  832.     uint32 *ptr;
  833.  
  834.     index = vm.cutSceneStackPointer;
  835.     ptr = &vm.cutScenePtr[index];
  836.     if (!*ptr) {
  837.         vm.slot[_currentScript].cutsceneOverride++;
  838.     }
  839.     *ptr = _scriptPointer - _scriptOrgPointer;
  840.     vm.cutSceneScript[index] = _currentScript;
  841.  
  842.     fetchScriptByte();
  843.     fetchScriptWord();
  844.     _vars[VAR_OVERRIDE] = 0;
  845. }
  846.  
  847. void Scumm::endOverride() {
  848.     int index;
  849.     uint32 *ptr;
  850.  
  851.     index = vm.cutSceneStackPointer;
  852.     ptr = &vm.cutScenePtr[index];
  853.     if (*ptr) {
  854.         vm.slot[_currentScript].cutsceneOverride--;
  855.     }
  856.     *ptr = 0;
  857.     vm.cutSceneScript[index] = 0;
  858.     _vars[VAR_OVERRIDE] = 0;
  859. }
  860.  
  861.  
  862. int Scumm::defineArray(int array, int type, int dim2, int dim1) {
  863.     int id;
  864.     int size;
  865.     ArrayHeader *ah;
  866.  
  867.     if (type!=5 && type!=4)
  868.         type=5;
  869.  
  870.     nukeArray(array);
  871.  
  872.     id = getArrayId();
  873.  
  874.     if (array&0x4000) {
  875.         _arrays[id] = vm.slot[_currentScript].number;
  876.     }
  877.  
  878.     if (array&0x8000) {
  879.         error("Can't define bit variable as array pointer");
  880.     }
  881.  
  882.     writeVar(array, id);
  883.  
  884.     size = (type==5) ? 16 : 8;
  885.     size *= dim2+1;
  886.     size *= dim1+1;
  887.     size >>= 3;
  888.  
  889.     ah = (ArrayHeader*)createResource(rtString, id, size+sizeof(ArrayHeader));
  890.  
  891.     ah->type = type;
  892.     ah->dim1_size = dim1+1;
  893.     ah->dim2_size = dim2+1;
  894.  
  895.     return id;
  896. }
  897.  
  898. void Scumm::nukeArray(int a) {
  899.     int data;
  900.  
  901.     data = readVar(a);
  902.  
  903.     if (data)
  904.         nukeResource(rtString, data);
  905.     _arrays[data] = 0;
  906.  
  907.     writeVar(a, 0);
  908. }
  909.  
  910. int Scumm::getArrayId() {
  911.     byte **addr = _baseArrays;
  912.     int i;
  913.  
  914.     for (i=1; i<_numArray; i++) {
  915.         if (!addr[i])
  916.             return i;
  917.     }
  918.     error("Out of array pointers, %d max", _numArray);
  919. }
  920.  
  921. void Scumm::arrayop_1(int a, byte *ptr) {
  922.     ArrayHeader *ah;
  923.     int r;
  924.     int len = getStringLen(ptr);
  925.             
  926.     r = defineArray(a, 4, 0, len);
  927.     ah = (ArrayHeader*)getResourceAddress(rtString,r);
  928.     copyString(ah->data,ptr,len);
  929. }
  930.  
  931. void Scumm::copyString(byte *dst, byte *src, int len) {
  932.     if (!src) {
  933.         while (--len>=0)
  934.             *dst++ = fetchScriptByte();
  935.     } else {
  936.         while (--len>=0)
  937.             *dst++ = *src++;
  938.     }
  939. }
  940.  
  941. int Scumm::getStringLen(byte *ptr) {
  942.     int len;
  943.     byte c;
  944.     if (!ptr)
  945.         ptr = _scriptPointer;
  946.     len = 0;
  947.     do {
  948.         c = *ptr++;
  949.         if (!c) break;
  950.         len++;
  951.         if (c==0xFF)
  952.             ptr += 3, len += 3;
  953.     } while (1);
  954.     return len+1;
  955. }
  956.  
  957. void Scumm::exitCutscene() {
  958.     uint32 offs = vm.cutScenePtr[vm.cutSceneStackPointer];
  959.     if (offs) {
  960.         ScriptSlot *ss = &vm.slot[vm.cutSceneScript[vm.cutSceneStackPointer]];
  961.         ss->offs = offs;
  962.         ss->status = 2;
  963.         ss->freezeCount = 0;
  964.         ss->cutsceneOverride--;
  965.         _vars[VAR_OVERRIDE] = 1;
  966.         vm.cutScenePtr[vm.cutSceneStackPointer] = 0;
  967.     }
  968. }