ScriptEngine.h

Go to the documentation of this file.

/*
    This source file is part of Rigs of Rods
    Copyright 2005-2012 Pierre-Michel Ricordel
    Copyright 2007-2012 Thomas Fischer
    Copyright 2013-2020 Petr Ohlidal
 
    For more information, see http://www.rigsofrods.org/
 
    Rigs of Rods is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License version 3, as
    published by the Free Software Foundation.
 
    Rigs of Rods 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 Rigs of Rods. If not, see <http://www.gnu.org/licenses/>.
*/
 
 
#pragma once
 
#ifdef USE_ANGELSCRIPT
 
#define DEFAULT_TERRAIN_SCRIPT "default.as" // Used when map creator doesn't provide custom script.
 
#include "AngelScriptBindings.h"
#include "Application.h"
#include "GameContext.h"
#include "GameScript.h"
#include "InterThreadStoreVector.h"
#include "ScriptEvents.h"
 
#include <Ogre.h>
#include "scriptdictionary/scriptdictionary.h"
#include "scriptbuilder/scriptbuilder.h"
 
#include <map>
 
namespace RoR {
 
 
inline void TRIGGER_EVENT_ASYNC(scriptEvents type, int arg1, int arg2ex = 0, int arg3ex = 0, int arg4ex = 0, std::string arg5ex = "", std::string arg6ex = "", std::string arg7ex = "", std::string arg8ex = "")
{
    ScriptEventArgs* args = new ScriptEventArgs{ type, arg1, arg2ex, arg3ex, arg4ex, arg5ex, arg6ex, arg7ex, arg8ex };
    App::GetGameContext()->PushMessage(Message(MSG_SIM_SCRIPT_EVENT_TRIGGERED, (void*)args));
}
 
enum class ScriptCategory
{
    INVALID,
    ACTOR,   
    TERRAIN, 
    GADGET,  
    CUSTOM   
};
 
const char* ScriptCategoryToString(ScriptCategory c);
 
struct ScriptUnit
{
    ScriptUnit();
    ~ScriptUnit();
 
    ScriptUnitID_t uniqueId = SCRIPTUNITID_INVALID;
    ScriptCategory scriptCategory = ScriptCategory::INVALID;
    unsigned int eventMask = 0; 
    AngelScript::asIScriptModule* scriptModule = nullptr;
    AngelScript::asIScriptFunction* frameStepFunctionPtr = nullptr; 
    AngelScript::asIScriptFunction* eventCallbackFunctionPtr = nullptr; 
    AngelScript::asIScriptFunction* eventCallbackExFunctionPtr = nullptr; 
    AngelScript::asIScriptFunction* defaultEventCallbackFunctionPtr = nullptr; 
    ActorPtr associatedActor; 
    CacheEntryPtr originatingGadget; 
    Ogre::String scriptName; 
    Ogre::String scriptHash;
    Ogre::String scriptBuffer;
};
 
typedef std::map<ScriptUnitID_t, ScriptUnit> ScriptUnitMap;
 
struct LoadScriptRequest
{
    std::string lsr_filename; 
    std::string lsr_buffer; 
    ScriptCategory lsr_category = ScriptCategory::TERRAIN;
    ActorInstanceID_t lsr_associated_actor = ACTORINSTANCEID_INVALID; 
};
 
struct ScriptCallbackArgs
{
    ScriptCallbackArgs(eventsource_t* evs, NodeNum_t nd): eventsource(evs), node(nd) {}
 
    eventsource_t* eventsource = nullptr;
    NodeNum_t node = NODENUM_INVALID;
};
 
typedef BitMask_t GetFuncFlags_t; 
const GetFuncFlags_t GETFUNCFLAG_OPTIONAL = 0; 
const GetFuncFlags_t GETFUNCFLAG_REQUIRED = BITMASK(1); 
const GetFuncFlags_t GETFUNCFLAG_SILENT = BITMASK(2); 
 
// Params to `RoR::ScriptEngine::getFunctionByDeclAndLogCandidates()`
const std::string GETFUNC_DEFAULTEVENTCALLBACK_SIGFMT = "void {}(int, string, string, int)";
const std::string GETFUNC_DEFAULTEVENTCALLBACK_NAME = "defaultEventCallback";
 
enum ScriptRetCode
{
    // Generic success - 0 by common convention.
    SCRIPTRETCODE_SUCCESS = AngelScript::asSUCCESS, // = AngelScript::0
 
    // AngelScript technical codes
    SCRIPTRETCODE_AS_ERROR = AngelScript::asERROR, // = AngelScript::-1 etc...
    SCRIPTRETCODE_AS_CONTEXT_ACTIVE = AngelScript::asCONTEXT_ACTIVE,
    SCRIPTRETCODE_AS_CONTEXT_NOT_FINISHED = AngelScript::asCONTEXT_NOT_FINISHED,
    SCRIPTRETCODE_AS_CONTEXT_NOT_PREPARED = AngelScript::asCONTEXT_NOT_PREPARED,
    SCRIPTRETCODE_AS_INVALID_ARG = AngelScript::asINVALID_ARG,
    SCRIPTRETCODE_AS_NO_FUNCTION = AngelScript::asNO_FUNCTION,
    SCRIPTRETCODE_AS_NOT_SUPPORTED = AngelScript::asNOT_SUPPORTED,
    SCRIPTRETCODE_AS_INVALID_NAME = AngelScript::asINVALID_NAME,
    SCRIPTRETCODE_AS_NAME_TAKEN = AngelScript::asNAME_TAKEN,
    SCRIPTRETCODE_AS_INVALID_DECLARATION = AngelScript::asINVALID_DECLARATION,
    SCRIPTRETCODE_AS_INVALID_OBJECT = AngelScript::asINVALID_OBJECT,
    SCRIPTRETCODE_AS_INVALID_TYPE = AngelScript::asINVALID_TYPE,
    SCRIPTRETCODE_AS_ALREADY_REGISTERED = AngelScript::asALREADY_REGISTERED,
    SCRIPTRETCODE_AS_MULTIPLE_FUNCTIONS = AngelScript::asMULTIPLE_FUNCTIONS,
    SCRIPTRETCODE_AS_NO_MODULE = AngelScript::asNO_MODULE,
    SCRIPTRETCODE_AS_NO_GLOBAL_VAR = AngelScript::asNO_GLOBAL_VAR,
    SCRIPTRETCODE_AS_INVALID_CONFIGURATION = AngelScript::asINVALID_CONFIGURATION,
    SCRIPTRETCODE_AS_INVALID_INTERFACE = AngelScript::asINVALID_INTERFACE,
    SCRIPTRETCODE_AS_CANT_BIND_ALL_FUNCTIONS = AngelScript::asCANT_BIND_ALL_FUNCTIONS,
    SCRIPTRETCODE_AS_LOWER_ARRAY_DIMENSION_NOT_REGISTERED = AngelScript::asLOWER_ARRAY_DIMENSION_NOT_REGISTERED,
    SCRIPTRETCODE_AS_WRONG_CONFIG_GROUP = AngelScript::asWRONG_CONFIG_GROUP,
    SCRIPTRETCODE_AS_CONFIG_GROUP_IS_IN_USE = AngelScript::asCONFIG_GROUP_IS_IN_USE,
    SCRIPTRETCODE_AS_ILLEGAL_BEHAVIOUR_FOR_TYPE = AngelScript::asILLEGAL_BEHAVIOUR_FOR_TYPE,
    SCRIPTRETCODE_AS_WRONG_CALLING_CONV = AngelScript::asWRONG_CALLING_CONV,
    SCRIPTRETCODE_AS_BUILD_IN_PROGRESS = AngelScript::asBUILD_IN_PROGRESS,
    SCRIPTRETCODE_AS_INIT_GLOBAL_VARS_FAILED = AngelScript::asINIT_GLOBAL_VARS_FAILED,
    SCRIPTRETCODE_AS_OUT_OF_MEMORY = AngelScript::asOUT_OF_MEMORY,
    SCRIPTRETCODE_AS_MODULE_IS_IN_USE = AngelScript::asMODULE_IS_IN_USE,
 
    // RoR ScriptEngine return codes
    //      Following is analysis of former state (most but not all funcs returned 0 on success)
    //       ~ executeString() [script: not exported] - used to return 0 on success, 1 on internal error and negative number otherwise.
    //       ~ addFunction() [script: `game.addScriptFunction()`] - used to return 0 on success, 1 on internal error and negative number otherwise.
    //       ~ functionExists() [script: `game.scriptFunctionExists()`] - used to return function ID (always >0) on success, negative number on error.
    //       ~ deleteFunction() [script: `game.deleteScriptFunction()`] - used to return function ID (always >0) on success, negative number on error.
    //       ~ addVariable() [script: `game.addScriptVariable()` ] - used to return 0 on success, 1 on internal error and negative number otherwise.
    //       ~ variableExists() [script: `game.scriptVariableExists()`] - newly added, returns 0 on success  and negative number otherwise.
    //       ~ deleteVariable() [script: `game.deleteScriptVariable()` ] - used to return 0 on success, 1 on internal error and negative number otherwise.
    //       ~ getVariable() [script: `game.getScriptVariable()` ] - recently added, returns 0 on success  and negative number otherwise.
    SCRIPTRETCODE_UNSPECIFIED_ERROR = -1001,
    SCRIPTRETCODE_ENGINE_NOT_CREATED = -1002,
    SCRIPTRETCODE_CONTEXT_NOT_CREATED = -1003,
    SCRIPTRETCODE_SCRIPTUNIT_NOT_EXISTS = -1004, // The scpecified ScriptUnitID_t was invalid
    SCRIPTRETCODE_SCRIPTUNIT_NO_MODULE = -1005,
    SCRIPTRETCODE_FUNCTION_NOT_EXISTS = -1006,
};
 
class ScriptEngine : public Ogre::LogListener
{
    friend class GameScript;
 
public:
 
    ScriptEngine();
    ~ScriptEngine();
 
    ScriptUnitID_t loadScript(Ogre::String filename, ScriptCategory category = ScriptCategory::TERRAIN,
        ActorPtr associatedActor = nullptr, std::string buffer = "");
 
    void unloadScript(ScriptUnitID_t unique_id);
 
    void framestep(Ogre::Real dt);
 
    void setForwardScriptLogToConsole(bool doForward);
 
    void triggerEvent(scriptEvents eventnum, int arg1=0, int arg2ex=0, int arg3ex=0, int arg4ex=0, std::string arg5ex="", std::string arg6ex="", std::string arg7ex="", std::string arg8ex="");
 
    void setEventsEnabled(bool val) { m_events_enabled = val; }
 
    ScriptRetCode_t executeString(Ogre::String command);
 
    void queueStringForExecution(const Ogre::String command);
 
    ScriptRetCode_t addFunction(const Ogre::String& arg, const ScriptUnitID_t nid = SCRIPTUNITID_DEFAULT);
 
    ScriptRetCode_t functionExists(const Ogre::String& arg, const ScriptUnitID_t nid = SCRIPTUNITID_DEFAULT);
 
    ScriptRetCode_t deleteFunction(const Ogre::String& arg, const ScriptUnitID_t nid = SCRIPTUNITID_DEFAULT);
 
    ScriptRetCode_t addVariable(const Ogre::String& arg, const ScriptUnitID_t nid = SCRIPTUNITID_DEFAULT);
 
    ScriptRetCode_t variableExists(const Ogre::String& arg, const ScriptUnitID_t nid = SCRIPTUNITID_DEFAULT);
 
    ScriptRetCode_t deleteVariable(const Ogre::String& arg, const ScriptUnitID_t nid = SCRIPTUNITID_DEFAULT);
 
    ScriptRetCode_t getVariable(const Ogre::String& varName, void *ref, int typeID, ScriptUnitID_t nid = SCRIPTUNITID_DEFAULT);
 
    AngelScript::asIScriptFunction* getFunctionByDeclAndLogCandidates(ScriptUnitID_t nid, GetFuncFlags_t flags, const std::string& funcName, const std::string& fmtFuncDecl);
 
    int fireEvent(std::string instanceName, float intensity);
 
    void envokeCallback(int functionId, eventsource_t* source, NodeNum_t nodenum = NODENUM_INVALID, int type = 0);
 
    void forwardExceptionAsScriptEvent(const std::string& from);
 
    AngelScript::asIScriptEngine* getEngine() { return engine; };
 
    // method from Ogre::LogListener
    void messageLogged(const Ogre::String& message, Ogre::LogMessageLevel lml, bool maskDebug, const Ogre::String& logName, bool& skipThisMessage);
 
    inline void SLOG(const char* msg) { this->scriptLog->logMessage(msg); } 
    inline void SLOG(std::string msg) { this->scriptLog->logMessage(msg); } 
 
    bool scriptUnitExists(ScriptUnitID_t unique_id);
    ScriptUnit& getScriptUnit(ScriptUnitID_t unique_id);
    ScriptUnitID_t getTerrainScriptUnit() const { return m_terrain_script_unit; } 
    ScriptUnitID_t getCurrentlyExecutingScriptUnit() const { return m_currently_executing_script_unit; } 
    ScriptUnitMap const& getScriptUnits() const { return m_script_units; }
 
protected:
 
 
    void init();
 
    Ogre::String composeModuleName(Ogre::String const& scriptName, ScriptCategory origin, ScriptUnitID_t id);
 
    int setupScriptUnit(int unit_id);
 
    bool prepareContextAndHandleErrors(ScriptUnitID_t nid, int asFunctionID);
 
    int executeContextAndHandleErrors(ScriptUnitID_t nid);
 
    ScriptRetCode_t validateScriptModule(const ScriptUnitID_t nid, AngelScript::asIScriptModule*& out_mod);
 
 
 
    void msgCallback(const AngelScript::asSMessageInfo* msg);
 
    void lineCallback(AngelScript::asIScriptContext* ctx);
 
    void exceptionCallback(AngelScript::asIScriptContext* ctx);
 
 
    AngelScript::asIScriptEngine* engine; 
    AngelScript::asIScriptContext* context; 
    Ogre::Log*      scriptLog;
    GameScript      m_game_script;
    ScriptUnitMap   m_script_units;
    ScriptUnitID_t  m_terrain_script_unit = SCRIPTUNITID_INVALID;
    ScriptUnitID_t  m_currently_executing_script_unit = SCRIPTUNITID_INVALID;
    scriptEvents    m_currently_executing_event_trigger = SE_NO_EVENTS;
    bool            m_events_enabled = true; 
 
    InterThreadStoreVector<Ogre::String> stringExecutionQueue; 
};
 
 
} // namespace RoR
 
#else // USE_ANGELSCRIPT
inline void TRIGGER_EVENT_ASYNC(scriptEvents type, int arg1, int arg2ex = 0, int arg3ex = 0, int arg4ex = 0, std::string arg5ex = "", std::string arg6ex = "", std::string arg7ex = "", std::string arg8ex = "")
{
}
#endif // USE_ANGELSCRIPT