1 /* ScummVM - Graphic Adventure Engine 2 * 3 * ScummVM is the legal property of its developers, whose names 4 * are too numerous to list here. Please refer to the COPYRIGHT 5 * file distributed with this source distribution. 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 2 10 * of the License, or (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 20 * 21 */ 22 23 // Scripting module private header 24 25 #ifndef SAGA_SCRIPT_H 26 #define SAGA_SCRIPT_H 27 28 #include "common/endian.h" 29 30 #include "saga/font.h" 31 32 namespace Saga { 33 34 #define COMMON_BUFFER_SIZE 1024 // Why 1024? 35 36 #define SCRIPT_TBLENTRY_LEN 4 37 38 #define SCRIPT_MAX 5000 39 40 #define ITE_SCRIPT_FUNCTION_MAX 78 41 #define IHNM_SCRIPT_FUNCTION_MAX 105 42 43 enum AddressTypes { 44 kAddressCommon = 0, // offset from global variables 45 kAddressStatic = 1, // offset from global variables 46 kAddressModule = 2, // offset from start of module 47 kAddressStack = 3, // offset from stack 48 kAddressThread = 4 // offset from thread structure 49 /* kAddressId = 5, // offset from const id object 50 kAddressIdIndirect = 6, // offset from stack id object 51 kAddressIndex = 7 // index from id*/ 52 }; 53 54 enum VerbTypes { 55 kVerbNone, 56 kVerbWalkTo, 57 kVerbGive, 58 kVerbUse, 59 kVerbEnter, 60 kVerbLookAt, 61 kVerbPickUp, 62 kVerbOpen, 63 kVerbClose, 64 kVerbTalkTo, 65 kVerbWalkOnly, 66 kVerbLookOnly, 67 kVerbOptions 68 }; 69 70 #define STHREAD_TIMESLICE 8 71 72 enum ThreadVarTypes { 73 kThreadVarObject = 0, 74 kThreadVarWithObject = 1, 75 kThreadVarAction = 2, 76 kThreadVarActor = 3, 77 78 kThreadVarMax = kThreadVarActor + 1 79 }; 80 81 enum ThreadFlags { 82 kTFlagNone = 0, 83 kTFlagWaiting = 1, // wait for even denoted in waitType 84 kTFlagFinished = 2, 85 kTFlagAborted = 4, 86 kTFlagAsleep = kTFlagWaiting | kTFlagFinished | kTFlagAborted // Combination of all flags which can halt a thread 87 }; 88 89 enum ThreadWaitTypes { 90 kWaitTypeNone = 0, // waiting for nothing 91 kWaitTypeDelay = 1, // waiting for a timer 92 kWaitTypeSpeech = 2, // waiting for speech to finish 93 kWaitTypeDialogEnd = 3, // waiting for my dialog to finish 94 kWaitTypeDialogBegin = 4, // waiting for other dialog to finish 95 kWaitTypeWalk = 5, // waiting to finish walking 96 kWaitTypeRequest = 6, // a request is up 97 kWaitTypePause = 7, 98 kWaitTypePlacard = 8, 99 kWaitTypeStatusTextInput = 9, 100 kWaitTypeWaitFrames = 10, // IHNM. waiting for a frame count 101 kWaitTypeWakeUp = 11 // IHNM. wait until get waken up 102 }; 103 104 enum CycleFlags { 105 kCyclePong = 1 << 0, 106 kCycleOnce = 1 << 1, 107 kCycleRandom = 1 << 2, 108 kCycleReverse = 1 << 3 109 }; 110 111 enum WalkFlags { 112 kWalkBackPedal = 1 << 0, 113 kWalkAsync = 1 << 1, 114 kWalkUseAngle = 1 << 2, 115 kWalkFace = 1 << 5 116 }; 117 118 enum ReplyFlags { 119 kReplyOnce = 1 << 0, 120 kReplySummary = 1 << 1, 121 kReplyCondition = 1 << 2 122 }; 123 124 struct EntryPoint { 125 uint16 nameOffset; 126 uint16 offset; 127 }; 128 129 typedef Common::Array<uint16> VoiceLUT; 130 131 struct ModuleData { 132 bool loaded; // is it loaded or not? 133 int scriptResourceId; 134 int stringsResourceId; 135 int voicesResourceId; 136 137 ByteArray moduleBase; // all base module 138 uint16 staticSize; // size of static data 139 uint staticOffset; // offset of static data begining in _commonBuffer 140 Common::Array<EntryPoint> entryPoints; 141 142 StringsTable strings; 143 VoiceLUT voiceLUT; 144 clearModuleData145 void clear() { 146 loaded = false; 147 strings.clear(); 148 voiceLUT.clear(); 149 moduleBase.clear(); 150 entryPoints.clear(); 151 } 152 ModuleDataModuleData153 ModuleData() : loaded(false), scriptResourceId(0), stringsResourceId(0), voicesResourceId(0), staticSize(0), staticOffset(0) { 154 } 155 }; 156 157 class ScriptThread { 158 public: 159 Common::Array<int16> _stackBuf; 160 161 uint16 _stackTopIndex; 162 uint16 _frameIndex; 163 164 uint16 _threadVars[kThreadVarMax]; 165 166 byte *_moduleBase; // 167 uint16 _moduleBaseSize; 168 169 byte *_commonBase; // 170 byte *_staticBase; // 171 VoiceLUT *_voiceLUT; // 172 StringsTable *_strings; // 173 174 int _flags; // ThreadFlags 175 int _waitType; // ThreadWaitTypes 176 uint _sleepTime; 177 void *_threadObj; // which object we're handling 178 179 int16 _returnValue; 180 181 uint16 _instructionOffset; // Instruction offset 182 183 int32 _frameWait; 184 185 enum { 186 THREAD_STACK_SIZE = 256 187 }; 188 189 public: baseAddress(byte addrMode)190 byte *baseAddress(byte addrMode) { 191 switch (addrMode) { 192 case kAddressCommon: 193 return _commonBase; 194 case kAddressStatic: 195 return _staticBase; 196 case kAddressModule: 197 return _moduleBase; 198 case kAddressStack: 199 return (byte *)&_stackBuf[_frameIndex]; 200 case kAddressThread: 201 return (byte *)_threadVars; 202 default: 203 return _commonBase; 204 } 205 } 206 stackTop()207 int16 stackTop() { 208 return _stackBuf[_stackTopIndex]; 209 } 210 pushedSize()211 uint pushedSize() { 212 return THREAD_STACK_SIZE - _stackTopIndex - 2; 213 } 214 push(int16 value)215 void push(int16 value) { 216 if (_stackTopIndex <= 0) { 217 error("ScriptThread::push() stack overflow"); 218 } 219 _stackBuf[--_stackTopIndex] = value; 220 } 221 pop()222 int16 pop() { 223 if (_stackTopIndex >= THREAD_STACK_SIZE) { 224 error("ScriptThread::pop() stack underflow"); 225 } 226 return _stackBuf[_stackTopIndex++]; 227 } 228 229 230 // wait stuff wait(int waitType)231 void wait(int waitType) { 232 _waitType = waitType; 233 _flags |= kTFlagWaiting; 234 } 235 waitWalk(void * threadObj)236 void waitWalk(void *threadObj) { 237 debug(3, "waitWalk()"); 238 wait(kWaitTypeWalk); 239 _threadObj = threadObj; 240 } 241 waitDelay(int sleepTime)242 void waitDelay(int sleepTime) { 243 debug(3, "waitDelay(%d)", sleepTime); 244 wait(kWaitTypeDelay); 245 _sleepTime = sleepTime; 246 } 247 waitFrames(int frames)248 void waitFrames(int frames) { 249 debug(3, "waitFrames(%d)", frames); 250 wait(kWaitTypeWaitFrames); 251 _frameWait = frames; 252 } 253 ScriptThread()254 ScriptThread() { 255 memset(&_frameIndex, 0xFE, sizeof(_frameIndex)); 256 memset(_threadVars, 0xFE, sizeof(_threadVars)); 257 memset(&_waitType, 0xFE, sizeof(_waitType)); 258 memset(&_sleepTime, 0xFE, sizeof(_sleepTime)); 259 memset(&_threadObj, 0xFE, sizeof(_threadObj)); 260 memset(&_returnValue, 0xFE, sizeof(_threadObj)); 261 memset(&_frameWait, 0xFE, sizeof(_frameWait)); 262 263 _flags = kTFlagNone; 264 } 265 }; 266 267 typedef Common::List<ScriptThread> ScriptThreadList; 268 269 #define SCRIPTOP_PARAMS ScriptThread *thread, Common::SeekableReadStream *scriptS, bool &stopParsing, bool &breakOut 270 #define SCRIPTFUNC_PARAMS ScriptThread *thread, int nArgs, bool &disContinue 271 #define OPCODE(x) {&Script::x, #x} 272 273 class Script { 274 public: 275 StringsTable _mainStrings; 276 277 Script(SagaEngine *vm); 278 virtual ~Script(); 279 280 void loadModule(uint scriptModuleNumber); 281 void clearModules(); 282 283 void doVerb(); 284 void showVerb(int statusColor = -1); 285 void setVerb(int verb); getCurrentVerb()286 int getCurrentVerb() const { return _currentVerb; } 287 void setPointerVerb(); 288 void whichObject(const Point& mousePoint); 289 void hitObject(bool leftButton); 290 void playfieldClick(const Point& mousePoint, bool leftButton); 291 292 void setLeftButtonVerb(int verb); getLeftButtonVerb()293 int getLeftButtonVerb() const { return _leftButtonVerb; } 294 void setRightButtonVerb(int verb); getRightButtonVerb()295 int getRightButtonVerb() const { return _rightButtonVerb; } setNonPlayfieldVerb()296 void setNonPlayfieldVerb() { 297 setRightButtonVerb(getVerbType(kVerbNone)); 298 _pointerObject = ID_NOTHING; 299 _currentObject[_firstObjectSet ? 1 : 0] = ID_NOTHING; 300 } setNoPendingVerb()301 void setNoPendingVerb() { 302 _pendingVerb = getVerbType(kVerbNone); 303 _currentObject[0] = _currentObject[1] = ID_NOTHING; 304 setPointerVerb(); 305 } 306 int getVerbType(VerbTypes verbType); getPlacardTextEntry()307 TextListEntry *getPlacardTextEntry() { return _placardTextEntry; } 308 309 bool isNonInteractiveDemo(); 310 311 protected: 312 // When reading or writing data to the common buffer, we have to use a 313 // well-defined byte order since it's stored in savegames. Otherwise, 314 // we use native byte ordering since that data may be accessed in other 315 // ways than through these functions. 316 // 317 // The "module" area is a special case, which possibly never ever 318 // happens. But if it does, we need well-defined byte ordering. 319 readUint16(byte * addr,byte addrMode)320 uint16 readUint16(byte *addr, byte addrMode) { 321 switch (addrMode) { 322 case kAddressCommon: 323 case kAddressStatic: 324 case kAddressModule: 325 return READ_LE_UINT16(addr); 326 default: 327 return READ_UINT16(addr); 328 } 329 } 330 writeUint16(byte * addr,uint16 value,byte addrMode)331 void writeUint16(byte *addr, uint16 value, byte addrMode) { 332 switch (addrMode) { 333 case kAddressCommon: 334 case kAddressStatic: 335 case kAddressModule: 336 WRITE_LE_UINT16(addr, value); 337 break; 338 default: 339 WRITE_UINT16(addr, value); 340 break; 341 } 342 } 343 344 SagaEngine *_vm; 345 ResourceContext *_scriptContext; 346 ResourceContext *_dataContext; 347 348 uint16 _modulesLUTEntryLen; 349 Common::Array<ModuleData> _modules; 350 TextListEntry *_placardTextEntry; 351 352 friend class SagaEngine; 353 ByteArray _commonBuffer; 354 355 uint _staticSize; 356 ScriptThreadList _threadList; 357 ScriptThread *_conversingThread; 358 359 //verb 360 bool _firstObjectSet; 361 bool _secondObjectNeeded; 362 uint16 _currentObject[2]; 363 int16 _currentObjectFlags[2]; 364 int _currentVerb; 365 int _stickyVerb; 366 int _leftButtonVerb; 367 int _rightButtonVerb; 368 int _ihnmDemoCurrentY; 369 370 public: 371 uint16 _pendingObject[2]; 372 int _pendingVerb; 373 uint16 _pointerObject; 374 375 bool _skipSpeeches; 376 bool _abortEnabled; 377 378 VoiceLUT _globalVoiceLUT; 379 380 public: 381 ScriptThread &createThread(uint16 scriptModuleNumber, uint16 scriptEntryPointNumber); 382 int executeThread(ScriptThread *thread, int entrypointNumber); 383 void executeThreads(uint msec); 384 void completeThread(); 385 void abortAllThreads(); 386 387 void wakeUpActorThread(int waitType, void *threadObj); 388 void wakeUpThreads(int waitType); 389 void wakeUpThreadsDelayed(int waitType, int sleepTime); 390 391 void loadVoiceLUT(VoiceLUT &voiceLUT, const ByteArray &resourceData); 392 393 protected: 394 void loadModuleBase(ModuleData &module, const ByteArray &resourceData); 395 396 // runThread returns true if we should break running of other threads 397 bool runThread(ScriptThread &thread); 398 void setThreadEntrypoint(ScriptThread *thread, int entrypointNumber); 399 400 public: 401 void finishDialog(int strID, int replyID, int flags, int bitOffset); 402 403 protected: 404 // Script opcodes ------------------------------------------------------------ 405 typedef void (Script::*ScriptOpType)(SCRIPTOP_PARAMS); 406 struct ScriptOpDescription { 407 ScriptOpType scriptOp; 408 const char *scriptOpName; 409 }; 410 const ScriptOpDescription *_scriptOpsList; 411 412 void setupScriptOpcodeList(); opDummy(SCRIPTOP_PARAMS)413 void opDummy(SCRIPTOP_PARAMS) { warning("Dummy opcode called"); } opNextBlock(SCRIPTOP_PARAMS)414 void opNextBlock(SCRIPTOP_PARAMS) { 415 thread->_instructionOffset = (((thread->_instructionOffset) >> 10) + 1) << 10; 416 } 417 void opDup(SCRIPTOP_PARAMS); 418 void opDrop(SCRIPTOP_PARAMS); 419 void opZero(SCRIPTOP_PARAMS); 420 void opOne(SCRIPTOP_PARAMS); 421 void opConstInt(SCRIPTOP_PARAMS); 422 void opStrLit(SCRIPTOP_PARAMS); 423 void opGetFlag(SCRIPTOP_PARAMS); 424 void opGetByte(SCRIPTOP_PARAMS); // SAGA 2 425 void opGetInt(SCRIPTOP_PARAMS); 426 void opPutFlag(SCRIPTOP_PARAMS); 427 void opPutByte(SCRIPTOP_PARAMS); // SAGA 2 428 void opPutInt(SCRIPTOP_PARAMS); 429 void opPutFlagV(SCRIPTOP_PARAMS); 430 void opPutByteV(SCRIPTOP_PARAMS); 431 void opPutIntV(SCRIPTOP_PARAMS); 432 void opCall(SCRIPTOP_PARAMS); // SAGA 1 433 void opCallNear(SCRIPTOP_PARAMS); // SAGA 2 434 void opCallFar(SCRIPTOP_PARAMS); // SAGA 2 435 void opCcall(SCRIPTOP_PARAMS); 436 void opCcallV(SCRIPTOP_PARAMS); 437 void opCallMember(SCRIPTOP_PARAMS); // SAGA 2 438 void opCallMemberV(SCRIPTOP_PARAMS); // SAGA 2 439 void opEnter(SCRIPTOP_PARAMS); 440 void opReturn(SCRIPTOP_PARAMS); 441 void opReturnV(SCRIPTOP_PARAMS); 442 void opJmp(SCRIPTOP_PARAMS); 443 void opJmpTrueV(SCRIPTOP_PARAMS); 444 void opJmpFalseV(SCRIPTOP_PARAMS); 445 void opJmpTrue(SCRIPTOP_PARAMS); 446 void opJmpFalse(SCRIPTOP_PARAMS); 447 void opJmpSwitch(SCRIPTOP_PARAMS); 448 void opJmpRandom(SCRIPTOP_PARAMS); 449 void opNegate(SCRIPTOP_PARAMS); 450 void opNot(SCRIPTOP_PARAMS); 451 void opCompl(SCRIPTOP_PARAMS); 452 void opIncV(SCRIPTOP_PARAMS); 453 void opDecV(SCRIPTOP_PARAMS); 454 void opPostInc(SCRIPTOP_PARAMS); 455 void opPostDec(SCRIPTOP_PARAMS); 456 void opAdd(SCRIPTOP_PARAMS); 457 void opSub(SCRIPTOP_PARAMS); 458 void opMul(SCRIPTOP_PARAMS); 459 void opDiv(SCRIPTOP_PARAMS); 460 void opMod(SCRIPTOP_PARAMS); 461 void opEq(SCRIPTOP_PARAMS); 462 void opNe(SCRIPTOP_PARAMS); 463 void opGt(SCRIPTOP_PARAMS); 464 void opLt(SCRIPTOP_PARAMS); 465 void opGe(SCRIPTOP_PARAMS); 466 void opLe(SCRIPTOP_PARAMS); 467 void opRsh(SCRIPTOP_PARAMS); 468 void opLsh(SCRIPTOP_PARAMS); 469 void opAnd(SCRIPTOP_PARAMS); 470 void opOr(SCRIPTOP_PARAMS); 471 void opXor(SCRIPTOP_PARAMS); 472 void opLAnd(SCRIPTOP_PARAMS); 473 void opLOr(SCRIPTOP_PARAMS); 474 void opLXor(SCRIPTOP_PARAMS); 475 void opSpeak(SCRIPTOP_PARAMS); 476 void opDialogBegin(SCRIPTOP_PARAMS); 477 void opDialogEnd(SCRIPTOP_PARAMS); 478 void opReply(SCRIPTOP_PARAMS); 479 void opAnimate(SCRIPTOP_PARAMS); 480 void opJmpSeedRandom(SCRIPTOP_PARAMS); 481 482 // Script functions ---------------------------------------------------------- 483 typedef void (Script::*ScriptFunctionType)(SCRIPTFUNC_PARAMS); 484 485 struct ScriptFunctionDescription { 486 ScriptFunctionType scriptFunction; 487 const char *scriptFunctionName; 488 }; 489 const ScriptFunctionDescription *_scriptFunctionsList; 490 491 void setupITEScriptFuncList(); 492 void setupIHNMScriptFuncList(); 493 494 void sfPutString(SCRIPTFUNC_PARAMS); 495 void sfWait(SCRIPTFUNC_PARAMS); 496 void sfTakeObject(SCRIPTFUNC_PARAMS); 497 void sfIsCarried(SCRIPTFUNC_PARAMS); 498 void sfStatusBar(SCRIPTFUNC_PARAMS); 499 void sfMainMode(SCRIPTFUNC_PARAMS); 500 void sfScriptWalkTo(SCRIPTFUNC_PARAMS); 501 void sfScriptDoAction(SCRIPTFUNC_PARAMS); 502 void sfSetActorFacing(SCRIPTFUNC_PARAMS); 503 void sfStartBgdAnim(SCRIPTFUNC_PARAMS); 504 void sfStopBgdAnim(SCRIPTFUNC_PARAMS); 505 void sfLockUser(SCRIPTFUNC_PARAMS); 506 void sfPreDialog(SCRIPTFUNC_PARAMS); 507 void sfKillActorThreads(SCRIPTFUNC_PARAMS); 508 void sfFaceTowards(SCRIPTFUNC_PARAMS); 509 void sfSetFollower(SCRIPTFUNC_PARAMS); 510 void sfScriptGotoScene(SCRIPTFUNC_PARAMS); 511 void sfSetObjImage(SCRIPTFUNC_PARAMS); 512 void sfSetObjName(SCRIPTFUNC_PARAMS); 513 void sfGetObjImage(SCRIPTFUNC_PARAMS); 514 void sfGetNumber(SCRIPTFUNC_PARAMS); 515 void sfScriptOpenDoor(SCRIPTFUNC_PARAMS); 516 void sfScriptCloseDoor(SCRIPTFUNC_PARAMS); 517 void sfSetBgdAnimSpeed(SCRIPTFUNC_PARAMS); 518 void sfCycleColors(SCRIPTFUNC_PARAMS); 519 void sfDoCenterActor(SCRIPTFUNC_PARAMS); 520 void sfStartBgdAnimSpeed(SCRIPTFUNC_PARAMS); 521 void sfScriptWalkToAsync(SCRIPTFUNC_PARAMS); 522 void sfEnableZone(SCRIPTFUNC_PARAMS); 523 void sfSetActorState(SCRIPTFUNC_PARAMS); 524 void sfScriptMoveTo(SCRIPTFUNC_PARAMS); 525 void sfSceneEq(SCRIPTFUNC_PARAMS); 526 void sfDropObject(SCRIPTFUNC_PARAMS); 527 void sfFinishBgdAnim(SCRIPTFUNC_PARAMS); 528 void sfSwapActors(SCRIPTFUNC_PARAMS); 529 void sfSimulSpeech(SCRIPTFUNC_PARAMS); 530 void sfScriptWalk(SCRIPTFUNC_PARAMS); 531 void sfCycleFrames(SCRIPTFUNC_PARAMS); 532 void sfSetFrame(SCRIPTFUNC_PARAMS); 533 void sfSetPortrait(SCRIPTFUNC_PARAMS); 534 void sfSetProtagPortrait(SCRIPTFUNC_PARAMS); 535 void sfChainBgdAnim(SCRIPTFUNC_PARAMS); 536 void sfScriptSpecialWalk(SCRIPTFUNC_PARAMS); 537 void sfPlaceActor(SCRIPTFUNC_PARAMS); 538 void sfCheckUserInterrupt(SCRIPTFUNC_PARAMS); 539 void sfScriptWalkRelative(SCRIPTFUNC_PARAMS); 540 void sfScriptMoveRelative(SCRIPTFUNC_PARAMS); 541 void sfSimulSpeech2(SCRIPTFUNC_PARAMS); 542 void sfPlacard(SCRIPTFUNC_PARAMS); 543 void sfPlacardOff(SCRIPTFUNC_PARAMS); 544 void sfSetProtagState(SCRIPTFUNC_PARAMS); 545 void sfResumeBgdAnim(SCRIPTFUNC_PARAMS); 546 void sfThrowActor(SCRIPTFUNC_PARAMS); 547 void sfWaitWalk(SCRIPTFUNC_PARAMS); 548 void sfScriptSceneID(SCRIPTFUNC_PARAMS); 549 void sfChangeActorScene(SCRIPTFUNC_PARAMS); 550 void sfScriptClimb(SCRIPTFUNC_PARAMS); 551 void sfSetDoorState(SCRIPTFUNC_PARAMS); 552 void sfSetActorZ(SCRIPTFUNC_PARAMS); 553 void sfScriptText(SCRIPTFUNC_PARAMS); 554 void sfGetActorX(SCRIPTFUNC_PARAMS); 555 void sfGetActorY(SCRIPTFUNC_PARAMS); 556 void sfEraseDelta(SCRIPTFUNC_PARAMS); 557 void sfPlayMusic(SCRIPTFUNC_PARAMS); 558 void sfPickClimbOutPos(SCRIPTFUNC_PARAMS); 559 void sfTossRif(SCRIPTFUNC_PARAMS); 560 void sfShowControls(SCRIPTFUNC_PARAMS); 561 void sfShowMap(SCRIPTFUNC_PARAMS); 562 void sfPuzzleWon(SCRIPTFUNC_PARAMS); 563 void sfEnableEscape(SCRIPTFUNC_PARAMS); 564 void sfPlaySound(SCRIPTFUNC_PARAMS); 565 void sfPlayLoopedSound(SCRIPTFUNC_PARAMS); 566 void sfGetDeltaFrame(SCRIPTFUNC_PARAMS); 567 void sfShowProtect(SCRIPTFUNC_PARAMS); 568 void sfProtectResult(SCRIPTFUNC_PARAMS); 569 void sfRand(SCRIPTFUNC_PARAMS); 570 void sfFadeMusic(SCRIPTFUNC_PARAMS); 571 void sfScriptStartCutAway(SCRIPTFUNC_PARAMS); 572 void sfReturnFromCutAway(SCRIPTFUNC_PARAMS); 573 void sfEndCutAway(SCRIPTFUNC_PARAMS); 574 void sfGetMouseClicks(SCRIPTFUNC_PARAMS); 575 void sfResetMouseClicks(SCRIPTFUNC_PARAMS); 576 void sfWaitFrames(SCRIPTFUNC_PARAMS); 577 void sfScriptFade(SCRIPTFUNC_PARAMS); 578 void sfPlayVoice(SCRIPTFUNC_PARAMS); 579 void sfVstopFX(SCRIPTFUNC_PARAMS); 580 void sfVstopLoopedFX(SCRIPTFUNC_PARAMS); 581 void sfDemoIsInteractive(SCRIPTFUNC_PARAMS); 582 void sfVsetTrack(SCRIPTFUNC_PARAMS); 583 void sfDebugShowData(SCRIPTFUNC_PARAMS); 584 void sfNull(SCRIPTFUNC_PARAMS); 585 void sfWaitFramesEsc(SCRIPTFUNC_PARAMS); 586 void sfPsychicProfile(SCRIPTFUNC_PARAMS); 587 void sfPsychicProfileOff(SCRIPTFUNC_PARAMS); 588 void sfSetSpeechBox(SCRIPTFUNC_PARAMS); 589 void sfSetChapterPoints(SCRIPTFUNC_PARAMS); 590 void sfSetPortraitBgColor(SCRIPTFUNC_PARAMS); 591 void sfScriptStartVideo(SCRIPTFUNC_PARAMS); 592 void sfScriptReturnFromVideo(SCRIPTFUNC_PARAMS); 593 void sfScriptEndVideo(SCRIPTFUNC_PARAMS); 594 void sfShowIHNMDemoHelpBg(SCRIPTFUNC_PARAMS); 595 void sfAddIHNMDemoHelpTextLine(SCRIPTFUNC_PARAMS); 596 void sfShowIHNMDemoHelpPage(SCRIPTFUNC_PARAMS); 597 void sfGetPoints(SCRIPTFUNC_PARAMS); 598 void sfSetGlobalFlag(SCRIPTFUNC_PARAMS); 599 void sfDemoSetInteractive(SCRIPTFUNC_PARAMS); 600 void sfClearGlobalFlag(SCRIPTFUNC_PARAMS); 601 void sfTestGlobalFlag(SCRIPTFUNC_PARAMS); 602 void sfSetPoints(SCRIPTFUNC_PARAMS); 603 void sfQueueMusic(SCRIPTFUNC_PARAMS); 604 void sfDisableAbortSpeeches(SCRIPTFUNC_PARAMS); 605 606 void sfStub(const char *name, ScriptThread *thread, int nArgs); 607 }; 608 609 class SAGA1Script : public Script { 610 public: 611 SAGA1Script(SagaEngine *vm); 612 ~SAGA1Script(); 613 }; 614 615 class SAGA2Script : public Script { 616 public: 617 SAGA2Script(SagaEngine *vm); 618 ~SAGA2Script(); 619 }; 620 621 } // End of namespace Saga 622 623 #endif 624