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, 
    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; 
    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";
 
class ScriptEngine : public Ogre::LogListener
{
    friend class GameScript;
 
public:
 
    ScriptEngine();
    ~ScriptEngine();
 
    ScriptUnitId_t loadScript(Ogre::String scriptname, 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; }
 
    int executeString(Ogre::String command);
 
    void queueStringForExecution(const Ogre::String command);
 
    int addFunction(const Ogre::String& arg);
 
    int functionExists(const Ogre::String& arg);
 
    int deleteFunction(const Ogre::String& arg);
 
    int addVariable(const Ogre::String& arg);
 
    int deleteVariable(const Ogre::String& arg);
 
    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);
 
 
 
    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