script.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *
 * Based on the original sources
 *   Faery Tale II -- The Halls of the Dead
 *   (c) 1993-1996 The Wyrmkeep Entertainment Co.
 */

#ifndef SAGA2_SCRIPT_H
#define SAGA2_SCRIPT_H

#include "saga2/objects.h"
#include "saga2/calendar.h"

namespace Saga2 {

typedef int16   ThreadID;

//  Various result codes returned from runScript

enum scriptResult {

    //  Code returned when attempt to run a non-existent script
    kScriptResultNoScript = 0,

    //  Code returned when script was aborted before completion
    kScriptResultAborted,

    //  Code returned when script finished
    kScriptResultFinished,

    //  Script spun off as async thread; no answer available.
    kScriptResultAsync
};

//  Variables specific to a thread

struct scriptCallFrame {

    //  ID of object who's method is being called (which can be the same
    //  as one of the other objects below).
    ObjectID        invokedObject = Nothing;
    ActiveItemID    invokedTAI;

    //  ID of the objects in the interaction.
    ObjectID        enactor = Nothing,        // actor who caused interaction
                    directObject = Nothing,   // the object being acted on
                    indirectObject = Nothing; // the object being used
    // with the other one
    ActiveItemID    directTAI,              // the tile activity instance
                    // being used
                    indirectTAI;            // the tile activity instance
    // upon which the object is being
    // used

    int16           responseType = -1;      // used with knowledge package

    int16           methodNum = -1;         // which method being invoked

    //  Misc fields used in passing parameters to scripts.
    int16           idNum = 0;              // a misc. id number
    int16           value = 0;              // a misc. parameter value
    TilePoint       coords;                 // a misc. tilepoint

    int16           returnVal = 0;          // return value of script
};

//  Standard return codes from scripts in the "returnVal" field

enum {
    //  Code returned by script when script decides requested
    //  action is not possible, and the calling C-code should
    //  take action to inform user
    kActionResultFailure = 0,

    //  Code returned by script when script completes the action
    //  successfully and C-code should not complete the action
    kActionResultSuccess,

    //  Code returned by script when requested action should complete
    //  the action
    kActionResultNotDone
};

//  Method used to refer to a SAGA object

struct SegmentRef {
    uint16              segment;            // segment / resource number
    uint16              offset;             // offset within segment
};

//  Segment numbers of "builtin" SAGA data structures,
//  such as actors and TAGS

enum builtinTypes {
    kBuiltinTypeObject = -1,
    kBuiltinTypeTAG = -2,
    kBuiltinAbstract = -3,
    kBuiltinTypeMission = -4
};

/* ===================================================================== *
   SAGA management functions
 * ===================================================================== */

//  Load the SAGA data segment from the resource file
void initSAGADataSeg();

void saveSAGADataSeg(Common::OutSaveFile *outS);
void loadSAGADataSeg(Common::InSaveFile *in);

//  Dispose of the SAGA data segment -- do nothing
inline void cleanupSAGADataSeg() {}

/* ===================================================================== *
   Thread management functions
 * ===================================================================== */

class Thread;

//  Initialize the SAGA thread list
void initSAGAThreads();

void saveSAGAThreads(Common::OutSaveFile *outS);
void loadSAGAThreads(Common::InSaveFile *in, int32 chunkSize);

//  Dispose of the active SAGA threads
void cleanupSAGAThreads();

//  Dispose of an active SAGA thread
void deleteThread(Thread *p);

void newThread(Thread *p, ThreadID id);

void newThread(Thread *p);

//  Return the ID of the specified SAGA thread
ThreadID getThreadID(Thread *thread);

//  Return a pointer to a SAGA thread, given a thread ID
Thread *getThreadAddress(ThreadID id);

/* ===================================================================== *
   Class Thread: An execution context of a script
 * ===================================================================== */

//  A script task is called a thread

scriptResult runMethod(
    uint16          scriptClassID,      // which script class
    int16           bType,              // builtin type
    uint16          index,              // object index
    uint16          methodNum,          // method number to call
    scriptCallFrame &args);

class Thread {

    friend char *STRING(int strNum);

    friend scriptResult runScript(uint16 exportEntryNum, scriptCallFrame &args);

    friend void wakeUpThread(ThreadID, int16);

public:
    SegmentRef      _programCounter;         // current PC location

    uint8           *_stackPtr;              // current stack location
    byte            *_codeSeg;                // base of current data segment
//                  *_stringBase;         // base of string resource

    uint8           *_stackBase;             // base of module stack

    enum threadFlags {
        kTFWaiting     = (1 << 0),             // thread waiting for event
        kTFFinished    = (1 << 1),             // thread finished normally
        kTFAborted     = (1 << 2),             // thread is aborted
        kTFExtended    = (1 << 3),             // this is an extended sequence
        kTFExpectResult = (1 << 4),            // script is expecting result on stack
        kTFSynchronous = (1 << 5),             // when this bit is set this thread will
        // run until it is finished or this bit
        // is cleared

        kTFAsleep      = (kTFWaiting | kTFFinished | kTFAborted)
    };

    int16           _stackSize,              // allocated size of stack
                    _flags,                  // execution flags
                    _framePtr,               // pointer to call frame
                    _returnVal;              // return value from ccalls

    bool            _valid;

    //  Various signals that a script can wait upon
    enum WaitTypes {
        kWaitNone = 0,                       // waiting for nothing
        kWaitDelay,                          // waiting for a timer
        kWaitFrameDelay,                     // waiting for frame count
        kWaitOther,                          // waiting for to be awoken
        kWaitTagSemaphore                    // waiting for a tag semaphore

//      kWaitSpeech,                         // waiting for speech to finish
//      kWaitDialogEnd,                      // waiting for my dialog to finish
//      kWaitDialogBegin,                    // waiting for other dialog to finish
//      kWaitWalk,                           // waiting to finish walking
//      kWaitRequest,                        // a request is up
    };

    WaitTypes  _waitType;               // what we're waiting for
    union {
        Alarm       _waitAlarm;              // for time-delay
        FrameAlarm  _waitFrameAlarm;         // for frame count delay
        ActiveItem *_waitParam;              // for other waiting
    };

    scriptCallFrame _threadArgs;             // arguments from C to thread

    //  For 'cfunc' member functions, the address of the object who's
    //  member function is being invoked.
    void            *_thisObject;
    uint16          _argCount;               // number of args to cfunc

    //  Constructor
    Thread(uint16 segNum, uint16 segOff, scriptCallFrame &args);

    //  Constructor -- reconstruct from archive buffer
    Thread(void **buf);

    Thread(Common::SeekableReadStream *stream, ThreadID id);

    //  Destructor
    ~Thread();

    //  Return the number of bytes need to archive this thread in an
    //  arhive buffer
    int32 archiveSize();

    //  Create an archive of this thread in an archive buffer
    void *archive(void *buf);

    void write(Common::MemoryWriteStreamDynamic *out);

    //  Dispatch all asynchronous threads
    static void dispatch();

    //  Intepret a single thread
    scriptResult run();

    //  Tells thread to wait for an event
    void waitForEvent(WaitTypes wt, ActiveItem *param) {
        _flags |= kTFWaiting;
        _waitType = wt;
        _waitParam = param;
    }

    //  Convert to extended script, and back to synchonous script
    void setExtended();
    void clearExtended();

    bool interpret();
private:
    uint8 *strAddress(int strNum);

};

const int               maxTimeSlice = 16,  // max instructions per call
                        kStackSize = 512;    // thread stack size

/* ============================================================================ *
   C-Function dispatch table
 * ============================================================================ */

typedef int16       C_Call(int16 *);

struct CallTable {
    C_Call          **table;
    uint16          numEntries;
    uint16          classID;
};

extern CallTable    globalCFuncs,
       actorCFuncs,
       tagCFuncs,
       missionCFuncs;

//extern C_Call     *ccall_table[];
//extern int16      ccall_count;

/* ===================================================================== *
   Externals
 * ===================================================================== */

extern Thread           *thisThread;        // task queue

//  Thread control
//void killThread( Thread *th );

/*
void wakeUpActorThread(WaitTypes wakeupType, void *obj);
void wakeUpThreads(WaitTypes wakeupType);
void wakeUpThreadsDelayed(WaitTypes wakeupType, int newdelay);
void abortObjectThreads(Thread *keep, uint16 id);
bool abortAllThreads(void);
*/

//  Run a script function
scriptResult runScript(uint16 exportEntryNum, scriptCallFrame &args);

//  Run a script class method.
scriptResult runObjectMethod(
    ObjectID id, uint16 methodNum, scriptCallFrame &args);

scriptResult runTagMethod(
    uint16 tagNum, uint16 methodNum, scriptCallFrame &args);


struct ResImportTable {
    int16           deadActorProto,
                    reserved[2];
    int16           EXP_spellEffect_CreateFireWisp,
                    EXP_spellEffect_CreateWindWisp,
                    EXP_spellEffect_CreateWraith,
                    EXP_spellEffect_TeleportToShrine,
                    EXP_spellEffect_Rejoin,
                    EXP_spellEffect_Timequake,
                    EXP_spellEffect_CreateFood;
};

extern ResImportTable       *resImports;

} // end of namespace Saga2

#endif