script entities

HifiExperiments committed 1 year ago

Commit efd26391 parent e9d4e2738 files · +1661 −143Browse files

Showing the changes to libraries/script-engine/src/ScriptManager.cpp (1 of 38 files). Show all

Unified · Split

libraries/script-engine/src/ScriptManager.cpp+291−77

 int ScriptManager::getNumRunningEntityScripts() const {
     QReadLocker locker { &_entityScriptsLock };
     int sum = 0;
-    for (const auto& st : _entityScripts) {
+    for (const auto& entityScripts : _entityScripts) {
-        if (st.status == EntityScriptStatus::RUNNING) {
+        for (const auto& script : entityScripts) {
-            ++sum;
+            if (script.status == EntityScriptStatus::RUNNING) {
+                ++sum;
+            }
         }
     }
     return sum;
 }
-void ScriptManager::setEntityScriptDetails(const EntityItemID& entityID, const EntityScriptDetails& details) {
+void ScriptManager::setEntityScriptDetails(const EntityItemID& entityID, const QString& scriptURL, const EntityScriptDetails& details) {
     {
         QWriteLocker locker { &_entityScriptsLock };
-        _entityScripts[entityID] = details;
+        _entityScripts[entityID][scriptURL] = details;
     }
     emit entityScriptDetailsUpdated();
 }
-void ScriptManager::updateEntityScriptStatus(const EntityItemID& entityID, const EntityScriptStatus &status, const QString& errorInfo) {
+void ScriptManager::updateEntityScriptStatus(const EntityItemID& entityID, const QString& scriptURL, const EntityScriptStatus &status, const QString& errorInfo) {
     {
         QWriteLocker locker { &_entityScriptsLock };
-        EntityScriptDetails& details = _entityScripts[entityID];
+        EntityScriptDetails& details = _entityScripts[entityID][scriptURL];
         details.status = status;
         details.errorInfo = errorInfo;
     }
     emit entityScriptDetailsUpdated();
 }
-QVariant ScriptManager::cloneEntityScriptDetails(const EntityItemID& entityID) {
+QVariant ScriptManager::cloneEntityScriptDetails(const EntityItemID& entityID, const QString& scriptURL) {
     static const QVariant NULL_VARIANT = QVariant::fromValue(nullptr);
     QVariantMap map;
     if (entityID.isNull()) {
         qCDebug(scriptengine) << "cloneEntityScriptDetails" << entityID << QThread::currentThread();
 #endif
         EntityScriptDetails scriptDetails;
-        if (getEntityScriptDetails(entityID, scriptDetails)) {
+        if (getEntityScriptDetails(entityID, scriptURL, scriptDetails)) {
 #ifdef DEBUG_ENTITY_STATES
             qCDebug(scriptengine) << "gotEntityScriptDetails" << scriptDetails.status << QThread::currentThread();
 #endif
-            map["isRunning"] = isEntityScriptRunning(entityID);
+            map["isRunning"] = isEntityScriptRunning(entityID, scriptURL);
             map["status"] = EntityScriptStatus_::valueToKey(scriptDetails.status).toLower();
             map["errorInfo"] = scriptDetails.errorInfo;
             map["entityID"] = entityID.toString();
     return map;
 }
-QFuture<QVariant> ScriptManager::getLocalEntityScriptDetails(const EntityItemID& entityID) {
+QFuture<QVariant> ScriptManager::getLocalEntityScriptDetails(const EntityItemID& entityID, const QString& scriptURL) {
-    return QtConcurrent::run(this, &ScriptManager::cloneEntityScriptDetails, entityID);
+    return QtConcurrent::run(this, &ScriptManager::cloneEntityScriptDetails, entityID, scriptURL);
 }
-bool ScriptManager::getEntityScriptDetails(const EntityItemID& entityID, EntityScriptDetails &details) const {
+bool ScriptManager::getEntityScriptDetails(const EntityItemID& entityID, const QString& scriptURL, EntityScriptDetails &details) const {
     QReadLocker locker { &_entityScriptsLock };
     auto it = _entityScripts.constFind(entityID);
     if (it == _entityScripts.constEnd()) {
         return false;
     }
-    details = it.value();
+    auto it2 = it.value().constFind(scriptURL);
+    if (it2 == it.value().constEnd()) {
+        return false;
+    }
+    details = it2.value();
     return true;
 }
-bool ScriptManager::hasEntityScriptDetails(const EntityItemID& entityID) const {
+bool ScriptManager::hasEntityScriptDetails(const EntityItemID& entityID, const QString& scriptURL) const {
     QReadLocker locker { &_entityScriptsLock };
-    return _entityScripts.contains(entityID);
+    auto it = _entityScripts.constFind(entityID);
+    if (it == _entityScripts.constEnd()) {
+        return false;
+    }
+    return it.value().contains(scriptURL);
 }
 void ScriptManager::loadEntityScript(const EntityItemID& entityID, const QString& entityScript, bool forceRedownload) {
         return;
     }
-    if (!hasEntityScriptDetails(entityID)) {
+    if (!hasEntityScriptDetails(entityID, entityScript)) {
         // make sure EntityScriptDetails has an entry for this UUID right away
         // (which allows bailing from the loading/provisioning process early if the Entity gets deleted mid-flight)
-        updateEntityScriptStatus(entityID, EntityScriptStatus::PENDING, "...pending...");
+        updateEntityScriptStatus(entityID, entityScript, EntityScriptStatus::PENDING, "...pending...");
     }
 #ifdef DEBUG_ENTITY_STATES
     {
         EntityScriptDetails details;
-        bool hasEntityScript = getEntityScriptDetails(entityID, details);
+        bool hasEntityScript = getEntityScriptDetails(entityID, entityScript, details);
         qCDebug(scriptengine) << "loadEntityScript.LOADING: " << entityID.toString()
             << "(previous: " << (hasEntityScript ? details.status : EntityScriptStatus::PENDING) << ")";
     }
     newDetails.scriptText = entityScript;
     newDetails.status = EntityScriptStatus::LOADING;
     newDetails.definingSandboxURL = currentSandboxURL;
-    setEntityScriptDetails(entityID, newDetails);
+    setEntityScriptDetails(entityID, entityScript, newDetails);
     auto scriptCache = DependencyManager::get<ScriptCache>();
     // note: see EntityTreeRenderer.cpp for shared pointer lifecycle management
 #ifdef DEBUG_ENTITY_STATES
                 qCDebug(scriptengine) << "loadEntityScript.contentAvailable" << status << entityID.toString();
 #endif
-                if (!isStopping() && hasEntityScriptDetails(entityID)) {
+                if (!isStopping() && hasEntityScriptDetails(entityID, entityScript)) {
                     _contentAvailableQueue[entityID] = { entityID, url, contents, isURL, success, status };
                 } else {
 #ifdef DEBUG_ENTITY_STATES
     QString entityScript;
     {
         QWriteLocker locker { &_entityScriptsLock };
-        entityScript = _entityScripts[entityID].scriptText;
+        entityScript = _entityScripts[entityID][scriptOrURL].scriptText;
     }
     EntityScriptDetails newDetails;
     auto setError = [&](const QString &errorInfo, const EntityScriptStatus& status) {
         newDetails.errorInfo = errorInfo;
         newDetails.status = status;
-        setEntityScriptDetails(entityID, newDetails);
+        setEntityScriptDetails(entityID, scriptOrURL, newDetails);
     };
     // NETWORK / FILESYSTEM ERRORS
     newDetails.scriptObject = entityScriptObject;
     newDetails.lastModified = lastModified;
     newDetails.definingSandboxURL = sandboxURL;
-    setEntityScriptDetails(entityID, newDetails);
+    setEntityScriptDetails(entityID, scriptOrURL, newDetails);
     if (isURL) {
         setParentURL("");
     }
     // if we got this far, then call the preload method
-    callEntityScriptMethod(entityID, "preload");
+    callEntityScriptMethodForScript(entityID, scriptOrURL, "preload");
     emit entityScriptPreloadFinished(entityID);
 }
  * @returns {Signal}
  */
 // The JSDoc is for the callEntityScriptMethod() call in this method.
-void ScriptManager::unloadEntityScript(const EntityItemID& entityID, bool shouldRemoveFromMap) {
+void ScriptManager::unloadEntityScript(const EntityItemID& entityID, const QString& scriptURL, bool shouldRemoveFromMap) {
     if (QThread::currentThread() != thread()) {
 #ifdef THREAD_DEBUGGING
         qCDebug(scriptengine) << "*** WARNING *** ScriptManager::unloadEntityScript() called on wrong thread [" << QThread::currentThread() << "], invoking on correct thread [" << thread() << "]  "
         // Lambda is necessary there to keep shared_ptr counter above zero
         QMetaObject::invokeMethod(this, [=, manager = shared_from_this()]{
-            manager->unloadEntityScript(entityID, shouldRemoveFromMap);
+            manager->unloadEntityScript(entityID, scriptURL, shouldRemoveFromMap);
         });
         return;
     }
 #endif
     EntityScriptDetails oldDetails;
-    if (getEntityScriptDetails(entityID, oldDetails)) {
+    if (getEntityScriptDetails(entityID, scriptURL, oldDetails)) {
-        auto scriptText = oldDetails.scriptText;
+        const auto& scriptText = oldDetails.scriptText;
-        if (isEntityScriptRunning(entityID)) {
+        if (isEntityScriptRunning(entityID, scriptURL)) {
-            callEntityScriptMethod(entityID, "unload");
+            callEntityScriptMethodForScript(entityID, scriptURL, "unload");
         }
 #ifdef DEBUG_ENTITY_STATES
         else {
             // this was a deleted entity, we've been asked to remove it from the map
             {
                 QWriteLocker locker { &_entityScriptsLock };
+                auto& entityScripts = _entityScripts[entityID];
+                entityScripts.remove(scriptText);
+                if (entityScripts.size() == 0) {
+                    _entityScripts.remove(entityID);
+                }
+            }
+            emit entityScriptDetailsUpdated();
+        } else if (oldDetails.status != EntityScriptStatus::UNLOADED) {
+            EntityScriptDetails newDetails;
+            newDetails.status = EntityScriptStatus::UNLOADED;
+            newDetails.lastModified = QDateTime::currentMSecsSinceEpoch();
+            // keep scriptText populated for the current need to "debouce" duplicate calls to unloadEntityScript
+            newDetails.scriptText = scriptText;
+            setEntityScriptDetails(entityID, scriptURL, newDetails);
+        }
+        stopAllTimersForEntityScript(entityID);
+    }
+}
+void ScriptManager::unloadAllEntityScriptsForEntity(const EntityItemID& entityID, bool shouldRemoveFromMap) {
+    if (QThread::currentThread() != thread()) {
+#ifdef THREAD_DEBUGGING
+        qCDebug(scriptengine) << "*** WARNING *** ScriptManager::unloadAllEntityScriptsForEntity() called on wrong thread ["
+                              << QThread::currentThread() << "], invoking on correct thread [" << thread()
+                              << "]  "
+                                 "entityID:"
+                              << entityID;
+#endif
+        // Lambda is necessary there to keep shared_ptr counter above zero
+        QMetaObject::invokeMethod(this, [=, manager = shared_from_this()] {
+            manager->unloadAllEntityScriptsForEntity(entityID, shouldRemoveFromMap);
+        });
+        return;
+    }
+#ifdef THREAD_DEBUGGING
+    qCDebug(scriptengine) << "ScriptManager::unloadAllEntityScriptsForEntity() called on correct thread [" << thread()
+                          << "]  "
+                             "entityID:"
+                          << entityID;
+#endif
+    std::vector<EntityScriptDetails> scriptDetails;
+    {
+        QWriteLocker locker { &_entityScriptsLock };
+        for (const auto& detail : _entityScripts[entityID]) {
+            scriptDetails.push_back(detail);
+        }
+    }
+    for (const auto& oldDetails : scriptDetails) {
+        const auto& scriptText = oldDetails.scriptText;
+        if (isEntityScriptRunning(entityID, scriptText)) {
+            callEntityScriptMethodForScript(entityID, scriptText, "unload");
+        }
+#ifdef DEBUG_ENTITY_STATES
+        else {
+            qCDebug(scriptengine) << "unload called while !running" << entityID << oldDetails.status;
+        }
+#endif
+        if (shouldRemoveFromMap) {
+            // this was a deleted entity, we've been asked to remove it from the map
+            {
+                QWriteLocker locker{ &_entityScriptsLock };
                 _entityScripts.remove(entityID);
             }
             emit entityScriptDetailsUpdated();
             newDetails.lastModified = QDateTime::currentMSecsSinceEpoch();
             // keep scriptText populated for the current need to "debouce" duplicate calls to unloadEntityScript
             newDetails.scriptText = scriptText;
-            setEntityScriptDetails(entityID, newDetails);
+            setEntityScriptDetails(entityID, scriptText, newDetails);
         }
         stopAllTimersForEntityScript(entityID);
     qCDebug(scriptengine) << "ScriptManager::unloadAllEntityScripts() called on correct thread [" << thread() << "]";
 #endif
-    QList<EntityItemID> keys;
+    std::vector<std::pair<EntityItemID, EntityScriptDetails>> scripts;
     {
         QReadLocker locker{ &_entityScriptsLock };
-        keys = _entityScripts.keys();
+        for (const auto& entityID : _entityScripts.keys()) {
+            for (const auto& scriptDetails : _entityScripts[entityID]) {
+                scripts.push_back(std::make_pair(entityID, scriptDetails));
+            }
+        }
     }
-    foreach(const EntityItemID& entityID, keys) {
+    foreach (const auto& idAndScript, scripts) {
-        unloadEntityScript(entityID);
+        unloadEntityScript(idAndScript.first, idAndScript.second.scriptText, true);
     }
     {
         QWriteLocker locker{ &_entityScriptsLock };
 #endif // DEBUG_ENGINE_STATE
 }
-void ScriptManager::refreshFileScript(const EntityItemID& entityID) {
+void ScriptManager::refreshFileScript(const EntityItemID& entityID, const QString& scriptURL) {
-    if (!HIFI_AUTOREFRESH_FILE_SCRIPTS || !hasEntityScriptDetails(entityID)) {
+    if (!HIFI_AUTOREFRESH_FILE_SCRIPTS || !hasEntityScriptDetails(entityID, scriptURL)) {
         return;
     }
     EntityScriptDetails details;
     {
         QWriteLocker locker { &_entityScriptsLock };
-        details = _entityScripts[entityID];
+        details = _entityScripts[entityID][scriptURL];
     }
     // Check to see if a file based script needs to be reloaded (easier debugging)
     if (details.lastModified > 0) {
         "entityID:" << entityID << "methodName:" << methodName;
 #endif
-    if (HIFI_AUTOREFRESH_FILE_SCRIPTS && methodName != "unload") {
+    std::vector<EntityScriptDetails> scriptDetails;
-        refreshFileScript(entityID);
+    {
+        QWriteLocker locker { &_entityScriptsLock };
+        for (const auto& detail : _entityScripts[entityID]) {
+            scriptDetails.push_back(detail);
+        }
     }
-    if (isEntityScriptRunning(entityID)) {
+    for (const auto& details : scriptDetails) {
-        EntityScriptDetails details;
+        if (HIFI_AUTOREFRESH_FILE_SCRIPTS && methodName != "unload") {
-        {
+            refreshFileScript(entityID, details.scriptText);
-            QWriteLocker locker { &_entityScriptsLock };
-            details = _entityScripts[entityID];
         }
+        if (isEntityScriptRunning(entityID, details.scriptText)) {
+            ScriptValue entityScript = details.scriptObject;  // previously loaded
+            // If this is a remote call, we need to check to see if the function is remotely callable
+            // we do this by checking for the existance of the 'remotelyCallable' property on the
+            // entityScript. And we confirm that the method name is included. If this fails, the
+            // function will not be called.
+            bool callAllowed = false;
+            if (remoteCallerID == QUuid()) {
+                callAllowed = true;
+            } else {
+                if (entityScript.property("remotelyCallable").isArray()) {
+                    auto callables = entityScript.property("remotelyCallable");
+                    auto callableCount = callables.property("length").toInteger();
+                    for (int i = 0; i < callableCount; i++) {
+                        auto callable = callables.property(i).toString();
+                        if (callable == methodName) {
+                            callAllowed = true;
+                            break;
+                        }
+                    }
+                }
+                if (!callAllowed) {
+                    qCDebug(scriptengine) << "Method [" << methodName << "] not remotely callable.";
+                }
+            }
+            if (callAllowed && entityScript.property(methodName).isFunction()) {
+                auto scriptEngine = engine().get();
+                ScriptValueList args;
+                args << EntityItemIDtoScriptValue(scriptEngine, entityID);
+                args << scriptValueFromSequence(scriptEngine, params);
+                ScriptValue oldData = scriptEngine->globalObject().property("Script").property("remoteCallerID");
+                scriptEngine->globalObject()
+                    .property("Script")
+                    .setProperty("remoteCallerID",
+                                 remoteCallerID.toString());  // Make the remoteCallerID available to javascript as a global.
+                callWithEnvironment(entityID, details.definingSandboxURL, entityScript.property(methodName), entityScript,
+                                    args);
+                scriptEngine->globalObject().property("Script").setProperty("remoteCallerID", oldData);
+            }
+        }
+    }
+}
+void ScriptManager::callEntityScriptMethodForScript(const EntityItemID& entityID,
+                                                    const QString& scriptURL,
+                                                    const QString& methodName,
+                                                    const QStringList& params,
+                                                    const QUuid& remoteCallerID) {
+    if (QThread::currentThread() != thread()) {
+#ifdef THREAD_DEBUGGING
+        qCDebug(scriptengine) << "*** WARNING *** ScriptManager::callEntityScriptMethodForScript() called on wrong thread [" << QThread::currentThread() << "], invoking on correct thread [" << thread() << "]  "
+            "entityID:" << entityID << "script:" << scriptURL << "methodName:" << methodName;
+#endif
+        // Lambda is necessary there to keep shared_ptr counter above zero
+        QMetaObject::invokeMethod(this, [=, manager = shared_from_this()]{
+            manager->callEntityScriptMethodForScript(entityID, scriptURL, methodName, params, remoteCallerID);
+        });
+        return;
+    }
+#ifdef THREAD_DEBUGGING
+    qCDebug(scriptengine) << "ScriptManager::callEntityScriptMethodForScript() called on correct thread [" << thread() << "]  "
+        "entityID:" << entityID << "methodName:" << methodName;
+#endif
+    EntityScriptDetails details;
+    {
+        QWriteLocker locker { &_entityScriptsLock };
+        details = _entityScripts[entityID][scriptURL];
+    }
+    if (HIFI_AUTOREFRESH_FILE_SCRIPTS && methodName != "unload") {
+        refreshFileScript(entityID, scriptURL);
+    }
+    if (isEntityScriptRunning(entityID, scriptURL)) {
         ScriptValue entityScript = details.scriptObject;  // previously loaded
         // If this is a remote call, we need to check to see if the function is remotely callable
             args << scriptValueFromSequence(scriptEngine, params);
             ScriptValue oldData = scriptEngine->globalObject().property("Script").property("remoteCallerID");
-            scriptEngine->globalObject().property("Script").setProperty("remoteCallerID", remoteCallerID.toString()); // Make the remoteCallerID available to javascript as a global.
+            scriptEngine->globalObject()
-            callWithEnvironment(entityID, details.definingSandboxURL, entityScript.property(methodName), entityScript, args);
+                .property("Script")
+                .setProperty("remoteCallerID",
+                                remoteCallerID.toString());  // Make the remoteCallerID available to javascript as a global.
+            callWithEnvironment(entityID, details.definingSandboxURL, entityScript.property(methodName), entityScript,
+                                args);
             scriptEngine->globalObject().property("Script").setProperty("remoteCallerID", oldData);
         }
     }
 }
+void ScriptManager::callEntityScriptMethodForScript(const EntityItemID& entityID,
+                                                    const QString& scriptURL,
+                                                    const QString& methodName,
+                                                    const QString& param) {
+    if (QThread::currentThread() != thread()) {
+#ifdef THREAD_DEBUGGING
+        qCDebug(scriptengine) << "*** WARNING *** ScriptManager::callEntityScriptMethodForScript() called on wrong thread [" << QThread::currentThread() << "], invoking on correct thread [" << thread() << "]  "
+            "entityID:" << entityID << "script:" << scriptURL << "methodName:" << methodName;
+#endif
+        // Lambda is necessary there to keep shared_ptr counter above zero
+        QMetaObject::invokeMethod(this, [=, manager = shared_from_this()]{
+            manager->callEntityScriptMethodForScript(entityID, scriptURL, methodName, param);
+        });
+        return;
+    }
+#ifdef THREAD_DEBUGGING
+    qCDebug(scriptengine) << "ScriptManager::callEntityScriptMethodForScript() called on correct thread [" << thread() << "]  "
+        "entityID:" << entityID << "methodName:" << methodName;
+#endif
+    EntityScriptDetails details;
+    {
+        QWriteLocker locker { &_entityScriptsLock };
+        details = _entityScripts[entityID][scriptURL];
+    }
+    if (HIFI_AUTOREFRESH_FILE_SCRIPTS && methodName != "unload") {
+        refreshFileScript(entityID, scriptURL);
+    }
+    if (isEntityScriptRunning(entityID, scriptURL)) {
+        ScriptValue entityScript = details.scriptObject;  // previously loaded
+        if (entityScript.property(methodName).isFunction()) {
+            auto scriptEngine = engine().get();
+            ScriptValueList args;
+            args << EntityItemIDtoScriptValue(scriptEngine, entityID);
+            args << scriptValueFromValue(scriptEngine, param);
+            callWithEnvironment(entityID, details.definingSandboxURL, entityScript.property(methodName), entityScript,
+                                args);
+        }
+    }
+}
 void ScriptManager::callEntityScriptMethod(const EntityItemID& entityID, const QString& methodName, const PointerEvent& event) {
     if (QThread::currentThread() != thread()) {
 #ifdef THREAD_DEBUGGING
         "entityID:" << entityID << "methodName:" << methodName << "event: pointerEvent";
 #endif
-    if (HIFI_AUTOREFRESH_FILE_SCRIPTS) {
+    std::vector<EntityScriptDetails> scriptDetails;
-        refreshFileScript(entityID);
+    {
+        QWriteLocker locker{ &_entityScriptsLock };
+        for (const auto& detail : _entityScripts[entityID]) {
+            scriptDetails.push_back(detail);
+        }
     }
-    if (isEntityScriptRunning(entityID)) {
+    for (const auto& details : scriptDetails) {
-        EntityScriptDetails details;
+        if (HIFI_AUTOREFRESH_FILE_SCRIPTS) {
-        {
+            refreshFileScript(entityID, details.scriptText);
-            QWriteLocker locker { &_entityScriptsLock };
-            details = _entityScripts[entityID];
         }
-        ScriptValue entityScript = details.scriptObject;  // previously loaded
+        if (isEntityScriptRunning(entityID, details.scriptText)) {
-        if (entityScript.property(methodName).isFunction()) {
+            ScriptValue entityScript = details.scriptObject;  // previously loaded
-            auto scriptEngine = engine().get();
+            if (entityScript.property(methodName).isFunction()) {
+                auto scriptEngine = engine().get();
-            ScriptValueList args;
+                ScriptValueList args;
-            args << EntityItemIDtoScriptValue(scriptEngine, entityID);
+                args << EntityItemIDtoScriptValue(scriptEngine, entityID);
-            args << event.toScriptValue(scriptEngine);
+                args << event.toScriptValue(scriptEngine);
-            callWithEnvironment(entityID, details.definingSandboxURL, entityScript.property(methodName), entityScript, args);
+                callWithEnvironment(entityID, details.definingSandboxURL, entityScript.property(methodName), entityScript, args);
+            }
         }
     }
 }
         "entityID:" << entityID << "methodName:" << methodName << "otherID:" << otherID << "collision: collision";
 #endif
-    if (HIFI_AUTOREFRESH_FILE_SCRIPTS) {
+    std::vector<EntityScriptDetails> scriptDetails;
-        refreshFileScript(entityID);
+    {
+        QWriteLocker locker{ &_entityScriptsLock };
+        for (const auto& detail : _entityScripts[entityID]) {
+            scriptDetails.push_back(detail);
+        }
     }
-    if (isEntityScriptRunning(entityID)) {
+    for (const auto& details : scriptDetails) {
-        EntityScriptDetails details;
+        if (HIFI_AUTOREFRESH_FILE_SCRIPTS) {
-        {
+            refreshFileScript(entityID, details.scriptText);
-            QWriteLocker locker { &_entityScriptsLock };
-            details = _entityScripts[entityID];
         }
-        ScriptValue entityScript = details.scriptObject;  // previously loaded
+        if (isEntityScriptRunning(entityID, details.scriptText)) {
-        if (entityScript.property(methodName).isFunction()) {
+            ScriptValue entityScript = details.scriptObject;  // previously loaded
-            auto scriptEngine = engine().get();
+            if (entityScript.property(methodName).isFunction()) {
+                auto scriptEngine = engine().get();
-            ScriptValueList args;
+                ScriptValueList args;
-            args << EntityItemIDtoScriptValue(scriptEngine, entityID);
+                args << EntityItemIDtoScriptValue(scriptEngine, entityID);
-            args << EntityItemIDtoScriptValue(scriptEngine, otherID);
+                args << EntityItemIDtoScriptValue(scriptEngine, otherID);
-            args << collisionToScriptValue(scriptEngine, collision);
+                args << collisionToScriptValue(scriptEngine, collision);
-            callWithEnvironment(entityID, details.definingSandboxURL, entityScript.property(methodName), entityScript, args);
+                callWithEnvironment(entityID, details.definingSandboxURL, entityScript.property(methodName), entityScript,
+                                    args);
+            }
         }
     }
 }