Try to fix events not rendering sometimes.

* See more about using [JavaScript on this page](https://wiki.gdevelop.io/gdevelop5/events/js-code/javascript-in-extensions/#experimental-new-option-javascript-files-in-your-project).

Only show in developer changelog

.gitattributes

@@ -3,6 +3,7 @@ Extensions/ParticleSystem/SPARK/* linguist-vendored
 Extensions/PhysicsBehavior/Box2D/* linguist-vendored
 Extensions/PhysicsBehavior/box2djs/* linguist-vendored
 Extensions/Physics2Behavior/box2d.js linguist-vendored
+Extensions/Physics3DBehavior/*.wasm-compat.js linguist-vendored
 Extensions/BBText/pixi-multistyle-text/* linguist-vendored
 Extensions/P2P/A_peer.js linguist-vendored
 Extensions/Multiplayer/peer.js linguist-vendored

Core/GDCore/Events/Event.cpp

@@ -18,8 +18,6 @@ namespace gd {
 
 EventsList BaseEvent::badSubEvents;
 VariablesContainer BaseEvent::badLocalVariables;
-std::vector<gd::String> BaseEvent::emptyDependencies;
-gd::String BaseEvent::emptySourceFile;
 
 BaseEvent::BaseEvent()
     : totalTimeDuringLastSession(0),

Core/GDCore/Events/Event.h

@@ -175,26 +175,6 @@ class GD_CORE_API BaseEvent {
         noExpr;
     return noExpr;
   };
-
-  /**
-   * \brief Returns the dependencies on source files of the project.
-   * \note Default implementation returns an empty list of dependencies. This is
-   * fine for most events that are not related to adding custom user source
-   * code.
-   */
-  virtual const std::vector<gd::String>& GetSourceFileDependencies() const {
-    return emptyDependencies;
-  };
-
-  /**
-   * \brief Returns the name of the source file associated with the event
-   * \note Default implementation returns an empty string. This is fine for most
-   * events that are not related to adding custom user source code.
-   */
-  virtual const gd::String& GetAssociatedGDManagedSourceFile(
-      gd::Project& project) const {
-    return emptySourceFile;
-  };
   ///@}
 
   /** \name Code generation
@@ -327,8 +307,6 @@ class GD_CORE_API BaseEvent {
 
   static gd::EventsList badSubEvents;
   static gd::VariablesContainer badLocalVariables;
-  static std::vector<gd::String> emptyDependencies;
-  static gd::String emptySourceFile;
 };
 
 /**

Core/GDCore/Extensions/Metadata/BehaviorMetadata.h

@@ -272,7 +272,7 @@ class GD_CORE_API BehaviorMetadata : public InstructionOrExpressionContainerMeta
    * Check if the behavior is private - it can't be used outside of its
    * extension.
    */
-  bool IsPrivate() const { return isPrivate; }
+  bool IsPrivate() const override { return isPrivate; }
 
   /**
    * Set that the behavior is private - it can't be used outside of its

Core/GDCore/Extensions/Metadata/InstructionOrExpressionContainerMetadata.h

@@ -174,6 +174,7 @@ public:
   virtual const gd::String &GetFullName() const = 0;
   virtual const gd::String &GetDescription() const = 0;
   virtual const gd::String &GetIconFilename() const = 0;
+  virtual bool IsPrivate() const = 0;
 
   /**
    * \brief Return a reference to a map containing the names of the actions

Core/GDCore/Extensions/Metadata/ObjectMetadata.cpp

@@ -54,7 +54,7 @@ ObjectMetadata::ObjectMetadata(const gd::String& extensionNamespace_,
                      []() -> std::unique_ptr<gd::ObjectConfiguration> {
       gd::LogFatalError(
           "Error: Event-based objects don't have blueprint. "
-          "This method should not never be called.");
+          "This method should never be called.");
       return nullptr;
     }) {}
 

Core/GDCore/Extensions/Metadata/ObjectMetadata.h

@@ -300,6 +300,22 @@ class GD_CORE_API ObjectMetadata : public InstructionOrExpressionContainerMetada
    */
   std::map<gd::String, gd::ExpressionMetadata>& GetAllStrExpressions() override { return strExpressionsInfos; };
 
+
+  /**
+   * Check if the behavior is private - it can't be used outside of its
+   * extension.
+   */
+  bool IsPrivate() const override { return isPrivate; }
+
+  /**
+   * Set that the behavior is private - it can't be used outside of its
+   * extension.
+   */
+  ObjectMetadata &SetPrivate() {
+    isPrivate = true;
+    return *this;
+  }
+
   /**
    * \brief Set the object to be hidden in the IDE.
    *
@@ -356,6 +372,7 @@ class GD_CORE_API ObjectMetadata : public InstructionOrExpressionContainerMetada
   gd::String iconFilename;
   gd::String categoryFullName;
   std::set<gd::String> defaultBehaviorTypes;
+  bool isPrivate = false;
   bool hidden = false;
   bool isRenderedIn3D = false;
   gd::String openFullEditorLabel;

Core/GDCore/Extensions/Metadata/SourceFileMetadata.h

@@ -0,0 +1,56 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#pragma once
+#include "GDCore/String.h"
+#include "GDCore/Serialization/SerializerElement.h"
+
+namespace gd {
+/**
+ * \brief Contains information about a source file that must be included
+ * when an extension is used.
+ */
+class GD_CORE_API SourceFileMetadata {
+ public:
+  /**
+   * Construct a new dependency metadata, though you probably want to call
+   * `AddSourceFile` on gd::PlatformExtension.
+   *
+   * \see gd::PlatformExtension
+   */
+  SourceFileMetadata() {};
+
+  SourceFileMetadata& SetResourceName(const gd::String& resourceName_) {
+    resourceName = resourceName_;
+    return *this;
+  };
+
+  SourceFileMetadata& SetIncludePosition(const gd::String& includePosition_) {
+    includePosition = includePosition_;
+    return *this;
+  };
+
+  const gd::String& GetResourceName() const { return resourceName; };
+
+  gd::String& GetResourceName() { return resourceName; };
+
+  const gd::String& GetIncludePosition() const { return includePosition; };
+
+  void SerializeTo(SerializerElement& element) const {
+    element.AddChild("resourceName").SetStringValue(resourceName);
+    element.AddChild("includePosition").SetStringValue(includePosition);
+  }
+
+  void UnserializeFrom(const SerializerElement& element) {
+    resourceName = element.GetStringAttribute("resourceName");
+    includePosition = element.GetStringAttribute("includePosition", "last");
+  }
+
+ private:
+  gd::String resourceName;  ///< The name of the resource in the project.
+  gd::String includePosition = "last";  ///< "first" or "last".
+};
+
+}  // namespace gd

Core/GDCore/Extensions/Metadata/ValueTypeMetadata.h

@@ -135,7 +135,17 @@ class GD_CORE_API ValueTypeMetadata {
    * and ExpressionAutocompletion) and in the EventsCodeGenerator.
    */
   bool IsVariable() const {
-    return gd::ValueTypeMetadata::GetPrimitiveValueType(name) == "variable";
+    return gd::ValueTypeMetadata::IsVariable(name);
+  }
+
+  /**
+   * \brief Return true if the type of the parameter is a variable.
+   * \note If you had a new type of parameter, also add it in the IDE (
+   * see EventsFunctionParametersEditor, ParameterRenderingService
+   * and ExpressionAutocompletion) and in the EventsCodeGenerator.
+   */
+  static bool IsVariable(const gd::String &type) {
+    return gd::ValueTypeMetadata::GetPrimitiveValueType(type) == "variable";
   }
 
   /**

Core/GDCore/Extensions/PlatformExtension.cpp

@@ -215,6 +215,11 @@ gd::DependencyMetadata& PlatformExtension::AddDependency() {
   return extensionDependenciesMetadata.back();
 }
 
+gd::SourceFileMetadata& PlatformExtension::AddSourceFile() {
+  extensionSourceFilesMetadata.push_back(SourceFileMetadata());
+  return extensionSourceFilesMetadata.back();
+}
+
 gd::ObjectMetadata& PlatformExtension::AddObject(
     const gd::String& name,
     const gd::String& fullname,
@@ -463,10 +468,22 @@ PlatformExtension::GetAllStrExpressions() {
   return strExpressionsInfos;
 }
 
+const std::vector<gd::DependencyMetadata>& PlatformExtension::GetAllDependencies() const {
+  return extensionDependenciesMetadata;
+}
+
 std::vector<gd::DependencyMetadata>& PlatformExtension::GetAllDependencies() {
   return extensionDependenciesMetadata;
 }
 
+const std::vector<gd::SourceFileMetadata>& PlatformExtension::GetAllSourceFiles() const {
+  return extensionSourceFilesMetadata;
+}
+
+std::vector<gd::SourceFileMetadata>& PlatformExtension::GetAllSourceFiles() {
+  return extensionSourceFilesMetadata;
+}
+
 std::map<gd::String, gd::EventMetadata>& PlatformExtension::GetAllEvents() {
   return eventsInfos;
 }

Core/GDCore/Extensions/PlatformExtension.h

@@ -13,6 +13,7 @@
 #include "GDCore/CommonTools.h"
 #include "GDCore/Extensions/Metadata/BehaviorMetadata.h"
 #include "GDCore/Extensions/Metadata/DependencyMetadata.h"
+#include "GDCore/Extensions/Metadata/SourceFileMetadata.h"
 #include "GDCore/Extensions/Metadata/EffectMetadata.h"
 #include "GDCore/Extensions/Metadata/EventMetadata.h"
 #include "GDCore/Extensions/Metadata/InstructionOrExpressionGroupMetadata.h"
@@ -214,6 +215,7 @@ class GD_CORE_API PlatformExtension {
       const gd::String& icon);
 
   gd::DependencyMetadata& AddDependency();
+  gd::SourceFileMetadata& AddSourceFile();
 
   /**
    * \brief Declare a new object as being part of the extension.
@@ -552,6 +554,24 @@ class GD_CORE_API PlatformExtension {
    */
   std::vector<gd::DependencyMetadata>& GetAllDependencies();
 
+  /**
+   * \brief Return a reference to a vector containing the metadata of all the
+   * dependencies of the extension.
+   */
+  const std::vector<gd::DependencyMetadata>& GetAllDependencies() const;
+
+  /**
+   * \brief Return a reference to a vector containing the metadata of all the
+   * dependencies of the extension.
+   */
+  std::vector<gd::SourceFileMetadata>& GetAllSourceFiles();
+
+  /**
+   * \brief Return a reference to a vector containing the metadata of all the
+   * dependencies of the extension.
+   */
+  const std::vector<gd::SourceFileMetadata>& GetAllSourceFiles() const;
+
   /**
    * \brief Return a reference to a map containing the names of the actions,
    * related to the object type, and the metadata associated with.
@@ -687,6 +707,7 @@ class GD_CORE_API PlatformExtension {
   std::map<gd::String, gd::ExpressionMetadata> expressionsInfos;
   std::map<gd::String, gd::ExpressionMetadata> strExpressionsInfos;
   std::vector<gd::DependencyMetadata> extensionDependenciesMetadata;
+  std::vector<gd::SourceFileMetadata> extensionSourceFilesMetadata;
   std::map<gd::String, gd::EventMetadata> eventsInfos;
   std::map<gd::String, gd::PropertyDescriptor> extensionPropertiesMetadata;
   std::map<gd::String, InstructionOrExpressionGroupMetadata>

Core/GDCore/IDE/DependenciesAnalyzer.cpp

@@ -12,7 +12,6 @@
 #include "GDCore/Project/ExternalEvents.h"
 #include "GDCore/Project/Layout.h"
 #include "GDCore/Project/Project.h"
-#include "GDCore/Project/SourceFile.h"
 
 DependenciesAnalyzer::DependenciesAnalyzer(const gd::Project& project_,
                                            const gd::Layout& layout_)
@@ -74,16 +73,6 @@ bool DependenciesAnalyzer::Analyze(const gd::EventsList& events) {
       }
     }
 
-    // Search for source files dependencies
-    std::vector<gd::String> dependencies =
-        events[i].GetSourceFileDependencies();
-    sourceFilesDependencies.insert(dependencies.begin(), dependencies.end());
-
-    const gd::String& associatedSourceFile =
-        events[i].GetAssociatedGDManagedSourceFile(const_cast<gd::Project&>(project));
-    if (!associatedSourceFile.empty())
-      sourceFilesDependencies.insert(associatedSourceFile);
-
     // Analyze sub events dependencies
     if (events[i].CanHaveSubEvents()) {
       if (!Analyze(events[i].GetSubEvents())) return false;

Core/GDCore/IDE/DependenciesAnalyzer.h

@@ -71,14 +71,6 @@ class GD_CORE_API DependenciesAnalyzer {
     return externalEventsDependencies;
   };
 
-  /**
-   * \brief Return the source files being dependencies of the scene or external
-   * events passed in the constructor.
-   */
-  const std::set<gd::String>& GetSourceFilesDependencies() const {
-    return sourceFilesDependencies;
-  };
-
  private:
   /**
    * \brief Analyze the dependencies of the events.
@@ -92,7 +84,6 @@ class GD_CORE_API DependenciesAnalyzer {
 
   std::set<gd::String> scenesDependencies;
   std::set<gd::String> externalEventsDependencies;
-  std::set<gd::String> sourceFilesDependencies;
   std::vector<gd::String>
       parentScenes;  ///< Used to check for circular dependencies.
   std::vector<gd::String>

Core/GDCore/IDE/Events/EventsParameterReplacer.cpp

@@ -0,0 +1,243 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#include "GDCore/IDE/Events/EventsParameterReplacer.h"
+
+#include <map>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "GDCore/Events/Event.h"
+#include "GDCore/Events/EventsList.h"
+#include "GDCore/Events/Parsers/ExpressionParser2NodePrinter.h"
+#include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
+#include "GDCore/Extensions/Metadata/MetadataProvider.h"
+#include "GDCore/Extensions/Metadata/ParameterMetadata.h"
+#include "GDCore/Extensions/Metadata/ParameterMetadataTools.h"
+#include "GDCore/IDE/Events/ExpressionValidator.h"
+#include "GDCore/Project/Layout.h"
+#include "GDCore/Project/Project.h"
+#include "GDCore/Project/ProjectScopedContainers.h"
+#include "GDCore/Project/PropertiesContainer.h"
+#include "GDCore/String.h"
+#include "GDCore/Tools/Log.h"
+
+namespace gd {
+
+/**
+ * \brief Go through the nodes and rename parameters.
+ *
+ * \see gd::ExpressionParser2
+ */
+class GD_CORE_API ExpressionParameterReplacer
+    : public ExpressionParser2NodeWorker {
+ public:
+  ExpressionParameterReplacer(
+      const gd::Platform& platform_,
+      const gd::ProjectScopedContainers& projectScopedContainers_,
+      bool isParentTypeAVariable_,
+      const std::unordered_map<gd::String, gd::String>& oldToNewPropertyNames_)
+      : hasDoneRenaming(false),
+        platform(platform_),
+        projectScopedContainers(projectScopedContainers_),
+        isParentTypeAVariable(isParentTypeAVariable_),
+        oldToNewPropertyNames(oldToNewPropertyNames_){};
+  virtual ~ExpressionParameterReplacer(){};
+
+  bool HasDoneRenaming() const { return hasDoneRenaming; }
+
+ protected:
+  void OnVisitSubExpressionNode(SubExpressionNode& node) override {
+    node.expression->Visit(*this);
+  }
+  void OnVisitOperatorNode(OperatorNode& node) override {
+    node.leftHandSide->Visit(*this);
+    node.rightHandSide->Visit(*this);
+  }
+  void OnVisitUnaryOperatorNode(UnaryOperatorNode& node) override {
+    node.factor->Visit(*this);
+  }
+  void OnVisitNumberNode(NumberNode& node) override {}
+  void OnVisitTextNode(TextNode& node) override {}
+  void OnVisitVariableNode(VariableNode& node) override {
+    if (isParentTypeAVariable) {
+        // Do nothing, it's a variable.
+        if (node.child) node.child->Visit(*this);
+        return;
+    }
+
+    // The node represents a variable or an object name on which a variable
+    // will be accessed, or a property with a child.
+
+    projectScopedContainers.MatchIdentifierWithName<void>(
+      // The property name is changed after the refactor operation.
+      node.name,
+      [&]() {
+        // Do nothing, it's an object variable.
+        if (node.child) node.child->Visit(*this);
+      }, [&]() {
+        // Do nothing, it's a variable.
+        if (node.child) node.child->Visit(*this);
+      }, [&]() {
+        // Do nothing, it's a property.
+        if (node.child) node.child->Visit(*this);
+      }, [&]() {
+        // This is a parameter
+        RenameParameter(node.name);
+        if (node.child) node.child->Visit(*this);
+      }, [&]() {
+        // Do nothing, it's something else.
+        if (node.child) node.child->Visit(*this);
+      });
+  }
+  void OnVisitVariableAccessorNode(VariableAccessorNode& node) override {
+    if (node.child) node.child->Visit(*this);
+  }
+  void OnVisitVariableBracketAccessorNode(
+      VariableBracketAccessorNode& node) override {
+    bool isGrandParentTypeAVariable = isParentTypeAVariable;
+    isParentTypeAVariable = false;
+    node.expression->Visit(*this);
+    isParentTypeAVariable = isGrandParentTypeAVariable;
+    if (node.child) node.child->Visit(*this);
+  }
+  void OnVisitIdentifierNode(IdentifierNode& node) override {
+    if (isParentTypeAVariable) {
+        // Do nothing, it's a variable.
+        return;
+    }
+    projectScopedContainers.MatchIdentifierWithName<void>(
+      // The property name is changed after the refactor operation
+      node.identifierName,
+      [&]() {
+        // Do nothing, it's an object variable.
+      }, [&]() {
+        // Do nothing, it's a variable.
+      }, [&]() {
+        // Do nothing, it's a property.
+      }, [&]() {
+        // This is a parameter.
+        RenameParameter(node.identifierName);
+      }, [&]() {
+        // Do nothing, it's something else.
+      });
+  }
+  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {}
+  void OnVisitFunctionCallNode(FunctionCallNode &node) override {
+    bool isGrandParentTypeAVariable = isParentTypeAVariable;
+    for (auto &parameter : node.parameters) {
+      const auto &parameterMetadata =
+          gd::MetadataProvider::GetFunctionCallParameterMetadata(
+              platform, projectScopedContainers.GetObjectsContainersList(),
+              node, *parameter);
+      if (!parameterMetadata) {
+        continue;
+      }
+      const auto &parameterTypeMetadata =
+          parameterMetadata->GetValueTypeMetadata();
+      if (gd::EventsParameterReplacer::CanContainParameter(
+              parameterTypeMetadata)) {
+        isParentTypeAVariable = parameterTypeMetadata.IsVariable();
+        parameter->Visit(*this);
+      }
+    }
+    isParentTypeAVariable = isGrandParentTypeAVariable;
+  }
+  void OnVisitEmptyNode(EmptyNode& node) override {}
+
+ private:
+  bool hasDoneRenaming;
+
+  bool RenameParameter(
+      gd::String& name) {
+    if (oldToNewPropertyNames.count(name) >= 1) {
+      name = oldToNewPropertyNames.find(name)->second;
+      hasDoneRenaming = true;
+      return true;
+    }
+
+    return false;  // Nothing was changed or done.
+  }
+
+  // Scope:
+  const gd::Platform& platform;
+  const gd::ProjectScopedContainers& projectScopedContainers;
+
+  // Renaming to do
+  const std::unordered_map<gd::String, gd::String>& oldToNewPropertyNames;
+
+  gd::String objectNameToUseForVariableAccessor;
+  bool isParentTypeAVariable;
+};
+
+bool EventsParameterReplacer::DoVisitInstruction(gd::Instruction& instruction,
+                                                bool isCondition) {
+  const auto& metadata = isCondition
+                             ? gd::MetadataProvider::GetConditionMetadata(
+                                   platform, instruction.GetType())
+                             : gd::MetadataProvider::GetActionMetadata(
+                                   platform, instruction.GetType());
+
+  gd::ParameterMetadataTools::IterateOverParametersWithIndex(
+      instruction.GetParameters(),
+      metadata.GetParameters(),
+      [&](const gd::ParameterMetadata& parameterMetadata,
+          const gd::Expression& parameterValue,
+          size_t parameterIndex,
+          const gd::String& lastObjectName) {
+        if (!gd::EventsParameterReplacer::CanContainParameter(
+          parameterMetadata.GetValueTypeMetadata())) {
+          return;
+        }
+        auto node = parameterValue.GetRootNode();
+        if (node) {
+          ExpressionParameterReplacer renamer(
+              platform, GetProjectScopedContainers(),
+              parameterMetadata.GetValueTypeMetadata().IsVariable(),
+              oldToNewPropertyNames);
+          node->Visit(renamer);
+
+          if (renamer.HasDoneRenaming()) {
+            instruction.SetParameter(
+                parameterIndex, ExpressionParser2NodePrinter::PrintNode(*node));
+          }
+        }
+      });
+
+  return false;
+}
+
+bool EventsParameterReplacer::DoVisitEventExpression(
+    gd::Expression& expression, const gd::ParameterMetadata& metadata) {
+  if (!gd::EventsParameterReplacer::CanContainParameter(
+          metadata.GetValueTypeMetadata())) {
+    return false;
+  }
+  auto node = expression.GetRootNode();
+  if (node) {
+    ExpressionParameterReplacer renamer(
+        platform, GetProjectScopedContainers(),
+        metadata.GetValueTypeMetadata().IsVariable(), oldToNewPropertyNames);
+    node->Visit(renamer);
+
+    if (renamer.HasDoneRenaming()) {
+      expression = ExpressionParser2NodePrinter::PrintNode(*node);
+    }
+  }
+
+  return false;
+}
+
+bool EventsParameterReplacer::CanContainParameter(
+    const gd::ValueTypeMetadata &valueTypeMetadata) {
+  return valueTypeMetadata.IsVariable() || valueTypeMetadata.IsNumber() ||
+         valueTypeMetadata.IsString();
+}
+
+EventsParameterReplacer::~EventsParameterReplacer() {}
+
+}  // namespace gd

Core/GDCore/IDE/Events/EventsParameterReplacer.h

@@ -0,0 +1,52 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#pragma once
+
+#include <map>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "GDCore/IDE/Events/ArbitraryEventsWorker.h"
+#include "GDCore/String.h"
+namespace gd {
+class BaseEvent;
+class PropertiesContainer;
+class EventsList;
+class Platform;
+}  // namespace gd
+
+namespace gd {
+/**
+ * \brief Replace in expressions and in parameters of actions or conditions,
+ * references to the name of a parameter by another.
+ *
+ * \ingroup IDE
+ */
+class GD_CORE_API EventsParameterReplacer
+    : public ArbitraryEventsWorkerWithContext {
+ public:
+  EventsParameterReplacer(
+      const gd::Platform &platform_,
+      const std::unordered_map<gd::String, gd::String> &oldToNewPropertyNames_)
+      : platform(platform_),
+        oldToNewPropertyNames(oldToNewPropertyNames_){};
+  virtual ~EventsParameterReplacer();
+
+  static bool CanContainParameter(const gd::ValueTypeMetadata &valueTypeMetadata);
+
+ private:
+  bool DoVisitInstruction(gd::Instruction &instruction,
+                          bool isCondition) override;
+  bool DoVisitEventExpression(gd::Expression &expression,
+                              const gd::ParameterMetadata &metadata) override;
+
+  const gd::Platform &platform;
+  const std::unordered_map<gd::String, gd::String> &oldToNewPropertyNames;
+};
+
+}  // namespace gd

Core/GDCore/IDE/Events/EventsPropertyReplacer.h

@@ -4,6 +4,7 @@
  * reserved. This project is released under the MIT License.
  */
 #pragma once
+
 #include <map>
 #include <memory>
 #include <unordered_map>

Core/GDCore/IDE/Events/EventsRefactorer.cpp

@@ -22,6 +22,7 @@
 #include "GDCore/Project/EventsBasedObject.h"
 #include "GDCore/Project/ProjectScopedContainers.h"
 #include "GDCore/IDE/Events/ExpressionTypeFinder.h"
+#include "GDCore/IDE/Events/ArbitraryEventsWorker.h"
 
 using namespace std;
 
@@ -51,17 +52,17 @@ class GD_CORE_API ExpressionObjectRenamer : public ExpressionParser2NodeWorker {
 
   static bool Rename(const gd::Platform &platform,
                      const gd::ProjectScopedContainers &projectScopedContainers,
-                     const gd::String &rootType,
-                     gd::ExpressionNode& node,
-                     const gd::String& objectName,
-                     const gd::String& objectNewName) {
-    if (gd::ExpressionValidator::HasNoErrors(platform, projectScopedContainers, rootType, node)) {
-      ExpressionObjectRenamer renamer(platform, projectScopedContainers, rootType, objectName, objectNewName);
+                     const gd::String &rootType, gd::ExpressionNode &node,
+                     const gd::String &objectName,
+                     const gd::String &objectNewName) {
+    if (gd::ExpressionValidator::HasNoErrors(platform, projectScopedContainers,
+                                             rootType, node)) {
+      ExpressionObjectRenamer renamer(platform, projectScopedContainers,
+                                      rootType, objectName, objectNewName);
       node.Visit(renamer);
 
       return renamer.HasDoneRenaming();
     }
-
     return false;
   }
 
@@ -83,7 +84,7 @@ class GD_CORE_API ExpressionObjectRenamer : public ExpressionParser2NodeWorker {
   void OnVisitVariableNode(VariableNode& node) override {
     auto type = gd::ExpressionTypeFinder::GetType(platform, projectScopedContainers, rootType, node);
 
-    if (gd::ValueTypeMetadata::IsTypeLegacyPreScopedVariable(type)) {
+    if (gd::ValueTypeMetadata::IsVariable(type)) {
       // Nothing to do (this can't reference an object)
     } else {
       if (node.name == objectName) {
@@ -119,7 +120,7 @@ class GD_CORE_API ExpressionObjectRenamer : public ExpressionParser2NodeWorker {
         node.identifierName == objectName) {
       hasDoneRenaming = true;
       node.identifierName = objectNewName;
-    } else if (gd::ValueTypeMetadata::IsTypeLegacyPreScopedVariable(type)) {
+    } else if (gd::ValueTypeMetadata::IsVariable(type)) {
       // Nothing to do (this can't reference an object)
     } else {
       if (node.identifierName == objectName) {
@@ -295,183 +296,114 @@ class GD_CORE_API ExpressionObjectFinder : public ExpressionParser2NodeWorker {
   const gd::String rootType;
 };
 
-bool EventsRefactorer::RenameObjectInActions(const gd::Platform& platform,
-                                             const gd::ProjectScopedContainers& projectScopedContainers,
-                                             gd::InstructionsList& actions,
-                                             gd::String oldName,
-                                             gd::String newName) {
-  bool somethingModified = false;
+/**
+ * \brief Replace in expressions and in parameters of actions or conditions,
+ * references to the name of an object by another.
+ *
+ * \ingroup IDE
+ */
+class GD_CORE_API EventsObjectReplacer
+    : public ArbitraryEventsWorkerWithContext {
+public:
+  EventsObjectReplacer(const gd::Platform &platform_,
+                       const gd::ObjectsContainer &targetedObjectsContainer_,
+                       const gd::String &oldObjectName_,
+                       const gd::String &newObjectName_)
+      : platform(platform_),
+        targetedObjectsContainer(targetedObjectsContainer_),
+        oldObjectName(oldObjectName_), newObjectName(newObjectName_){};
 
-  for (std::size_t aId = 0; aId < actions.size(); ++aId) {
-    const gd::InstructionMetadata& instrInfos =
-        MetadataProvider::GetActionMetadata(platform, actions[aId].GetType());
-    for (std::size_t pNb = 0; pNb < instrInfos.parameters.GetParametersCount(); ++pNb) {
-      // Replace object's name in parameters
-      if (gd::ParameterMetadata::IsObject(instrInfos.parameters.GetParameter(pNb).GetType()) &&
-          actions[aId].GetParameter(pNb).GetPlainString() == oldName)
-        actions[aId].SetParameter(pNb, gd::Expression(newName));
-      // Replace object's name in expressions
-      else if (ParameterMetadata::IsExpression(
-                   "number", instrInfos.parameters.GetParameter(pNb).GetType())) {
-        auto node = actions[aId].GetParameter(pNb).GetRootNode();
+  virtual ~EventsObjectReplacer() {}
 
-        if (ExpressionObjectRenamer::Rename(platform, projectScopedContainers, "number", *node, oldName, newName)) {
-          actions[aId].SetParameter(
-              pNb, ExpressionParser2NodePrinter::PrintNode(*node));
-        }
-      }
-      // Replace object's name in text expressions
-      else if (ParameterMetadata::IsExpression(
-                   "string", instrInfos.parameters.GetParameter(pNb).GetType())) {
-        auto node = actions[aId].GetParameter(pNb).GetRootNode();
-
-        if (ExpressionObjectRenamer::Rename(platform, projectScopedContainers, "string", *node, oldName, newName)) {
-          actions[aId].SetParameter(
-              pNb, ExpressionParser2NodePrinter::PrintNode(*node));
-        }
-      }
+private:
+  bool DoVisitInstruction(gd::Instruction &instruction,
+                          bool isCondition) override {
+    if (&targetedObjectsContainer !=
+        GetProjectScopedContainers()
+            .GetObjectsContainersList()
+            .GetObjectsContainerFromObjectName(oldObjectName)) {
+      return false;
     }
+    const auto &metadata = isCondition
+                               ? gd::MetadataProvider::GetConditionMetadata(
+                                     platform, instruction.GetType())
+                               : gd::MetadataProvider::GetActionMetadata(
+                                     platform, instruction.GetType());
 
-    if (!actions[aId].GetSubInstructions().empty())
-      somethingModified =
-          RenameObjectInActions(platform,
-                                projectScopedContainers,
-                                actions[aId].GetSubInstructions(),
-                                oldName,
-                                newName) ||
-          somethingModified;
+    gd::ParameterMetadataTools::IterateOverParametersWithIndex(
+        instruction.GetParameters(), metadata.GetParameters(),
+        [&](const gd::ParameterMetadata &parameterMetadata,
+            const gd::Expression &parameterValue, size_t parameterIndex,
+            const gd::String &lastObjectName) {
+          if (!gd::EventsObjectReplacer::CanContainObject(
+                  parameterMetadata.GetValueTypeMetadata())) {
+            return;
+          }
+          auto node = parameterValue.GetRootNode();
+          if (node) {
+            ExpressionObjectRenamer renamer(
+                platform, GetProjectScopedContainers(),
+                parameterMetadata.GetValueTypeMetadata().GetName(),
+                oldObjectName, newObjectName);
+            node->Visit(renamer);
+
+            if (renamer.HasDoneRenaming()) {
+              instruction.SetParameter(
+                  parameterIndex,
+                  ExpressionParser2NodePrinter::PrintNode(*node));
+            }
+          }
+        });
+
+    return false;
   }
 
-  return somethingModified;
-}
-
-bool EventsRefactorer::RenameObjectInConditions(
-    const gd::Platform& platform,
-    const gd::ProjectScopedContainers& projectScopedContainers,
-    gd::InstructionsList& conditions,
-    gd::String oldName,
-    gd::String newName) {
-  bool somethingModified = false;
-
-  for (std::size_t cId = 0; cId < conditions.size(); ++cId) {
-    const gd::InstructionMetadata& instrInfos =
-        MetadataProvider::GetConditionMetadata(platform,
-                                               conditions[cId].GetType());
-    for (std::size_t pNb = 0; pNb < instrInfos.parameters.GetParametersCount(); ++pNb) {
-      // Replace object's name in parameters
-      if (gd::ParameterMetadata::IsObject(instrInfos.parameters.GetParameter(pNb).GetType()) &&
-          conditions[cId].GetParameter(pNb).GetPlainString() == oldName)
-        conditions[cId].SetParameter(pNb, gd::Expression(newName));
-      // Replace object's name in expressions
-      else if (ParameterMetadata::IsExpression(
-                   "number", instrInfos.parameters.GetParameter(pNb).GetType())) {
-        auto node = conditions[cId].GetParameter(pNb).GetRootNode();
-
-        if (ExpressionObjectRenamer::Rename(platform, projectScopedContainers, "number", *node, oldName, newName)) {
-          conditions[cId].SetParameter(
-              pNb, ExpressionParser2NodePrinter::PrintNode(*node));
-        }
-      }
-      // Replace object's name in text expressions
-      else if (ParameterMetadata::IsExpression(
-                   "string", instrInfos.parameters.GetParameter(pNb).GetType())) {
-        auto node = conditions[cId].GetParameter(pNb).GetRootNode();
-
-        if (ExpressionObjectRenamer::Rename(platform, projectScopedContainers, "string", *node, oldName, newName)) {
-          conditions[cId].SetParameter(
-              pNb, ExpressionParser2NodePrinter::PrintNode(*node));
-        }
-      }
+  bool DoVisitEventExpression(gd::Expression &expression,
+                              const gd::ParameterMetadata &metadata) override {
+    if (&targetedObjectsContainer !=
+        GetProjectScopedContainers()
+            .GetObjectsContainersList()
+            .GetObjectsContainerFromObjectName(oldObjectName)) {
+      return false;
+    }
+    if (!gd::EventsObjectReplacer::CanContainObject(
+            metadata.GetValueTypeMetadata())) {
+      return false;
     }
-
-    if (!conditions[cId].GetSubInstructions().empty())
-      somethingModified =
-          RenameObjectInConditions(platform,
-                                   projectScopedContainers,
-                                   conditions[cId].GetSubInstructions(),
-                                   oldName,
-                                   newName) ||
-          somethingModified;
-  }
-
-  return somethingModified;
-}
-
-bool EventsRefactorer::RenameObjectInEventParameters(
-    const gd::Platform& platform,
-    const gd::ProjectScopedContainers& projectScopedContainers,
-    gd::Expression& expression,
-    gd::ParameterMetadata parameterMetadata,
-    gd::String oldName,
-    gd::String newName) {
-  bool somethingModified = false;
-
-  if (gd::ParameterMetadata::IsObject(parameterMetadata.GetType()) &&
-      expression.GetPlainString() == oldName)
-    expression = gd::Expression(newName);
-  // Replace object's name in expressions
-  else if (ParameterMetadata::IsExpression("number",
-                                           parameterMetadata.GetType())) {
     auto node = expression.GetRootNode();
+    if (node) {
+      ExpressionObjectRenamer renamer(platform, GetProjectScopedContainers(),
+                                      metadata.GetValueTypeMetadata().GetName(),
+                                      oldObjectName, newObjectName);
+      node->Visit(renamer);
 
-    if (ExpressionObjectRenamer::Rename(platform, projectScopedContainers, "number", *node, oldName, newName)) {
-      expression = ExpressionParser2NodePrinter::PrintNode(*node);
+      if (renamer.HasDoneRenaming()) {
+        expression = ExpressionParser2NodePrinter::PrintNode(*node);
+      }
     }
-  }
-  // Replace object's name in text expressions
-  else if (ParameterMetadata::IsExpression("string",
-                                           parameterMetadata.GetType())) {
-    auto node = expression.GetRootNode();
 
-    if (ExpressionObjectRenamer::Rename(platform, projectScopedContainers, "string", *node, oldName, newName)) {
-      expression = ExpressionParser2NodePrinter::PrintNode(*node);
-    }
+    return false;
   }
 
-  return somethingModified;
-}
+  bool CanContainObject(const gd::ValueTypeMetadata &valueTypeMetadata) {
+    return valueTypeMetadata.IsObject() || valueTypeMetadata.IsVariable() ||
+           valueTypeMetadata.IsNumber() || valueTypeMetadata.IsString();
+  }
+
+  const gd::Platform &platform;
+  const gd::ObjectsContainer &targetedObjectsContainer;
+  const gd::String &oldObjectName;
+  const gd::String &newObjectName;
+};
 
 void EventsRefactorer::RenameObjectInEvents(const gd::Platform& platform,
                                             const gd::ProjectScopedContainers& projectScopedContainers,
                                             gd::EventsList& events,
+                                            const gd::ObjectsContainer &targetedObjectsContainer,
                                             gd::String oldName,
                                             gd::String newName) {
-  for (std::size_t i = 0; i < events.size(); ++i) {
-    vector<gd::InstructionsList*> conditionsVectors =
-        events[i].GetAllConditionsVectors();
-    for (std::size_t j = 0; j < conditionsVectors.size(); ++j) {
-      bool somethingModified = RenameObjectInConditions(
-          platform, projectScopedContainers, *conditionsVectors[j], oldName, newName);
-    }
-
-    vector<gd::InstructionsList*> actionsVectors =
-        events[i].GetAllActionsVectors();
-    for (std::size_t j = 0; j < actionsVectors.size(); ++j) {
-      bool somethingModified = RenameObjectInActions(
-          platform, projectScopedContainers, *actionsVectors[j], oldName, newName);
-    }
-
-    vector<pair<gd::Expression*, gd::ParameterMetadata>>
-        expressionsWithMetadata = events[i].GetAllExpressionsWithMetadata();
-    for (std::size_t j = 0; j < expressionsWithMetadata.size(); ++j) {
-      gd::Expression* expression = expressionsWithMetadata[j].first;
-      gd::ParameterMetadata parameterMetadata =
-          expressionsWithMetadata[j].second;
-      bool somethingModified = RenameObjectInEventParameters(platform,
-                                                             projectScopedContainers,
-                                                             *expression,
-                                                             parameterMetadata,
-                                                             oldName,
-                                                             newName);
-    }
-
-    if (events[i].CanHaveSubEvents())
-      RenameObjectInEvents(platform,
-                           projectScopedContainers,
-                           events[i].GetSubEvents(),
-                           oldName,
-                           newName);
-  }
+  gd::EventsObjectReplacer eventsParameterReplacer(platform, targetedObjectsContainer, oldName, newName);
+  eventsParameterReplacer.Launch(events, projectScopedContainers);
 }
 
 bool EventsRefactorer::RemoveObjectInActions(const gd::Platform& platform,

Core/GDCore/IDE/Events/EventsRefactorer.h

@@ -83,6 +83,7 @@ class GD_CORE_API EventsRefactorer {
   static void RenameObjectInEvents(const gd::Platform& platform,
                                    const gd::ProjectScopedContainers& projectScopedContainers,
                                    gd::EventsList& events,
+                                   const gd::ObjectsContainer &targetedObjectsContainer,
                                    gd::String oldName,
                                    gd::String newName);
 
@@ -121,44 +122,6 @@ class GD_CORE_API EventsRefactorer {
   virtual ~EventsRefactorer(){};
 
  private:
-  /**
-   * Replace all occurrences of an object name by another name in an action
-   * ( include : objects in parameters and in math/text expressions ).
-   *
-   * \return true if something was modified.
-   */
-  static bool RenameObjectInActions(const gd::Platform& platform,
-                                    const gd::ProjectScopedContainers& projectScopedContainers,
-                                    gd::InstructionsList& instructions,
-                                    gd::String oldName,
-                                    gd::String newName);
-
-  /**
-   * Replace all occurrences of an object name by another name in a condition
-   * ( include : objects in parameters and in math/text expressions ).
-   *
-   * \return true if something was modified.
-   */
-  static bool RenameObjectInConditions(const gd::Platform& platform,
-                                       const gd::ProjectScopedContainers& projectScopedContainers,
-                                       gd::InstructionsList& instructions,
-                                       gd::String oldName,
-                                       gd::String newName);
-  /**
-   * Replace all occurrences of an object name by another name in an expression
-   * with the specified metadata
-   * ( include : objects or objects in math/text expressions ).
-   *
-   * \return true if something was modified.
-   */
-  static bool RenameObjectInEventParameters(
-      const gd::Platform& platform,
-      const gd::ProjectScopedContainers& projectScopedContainers,
-      gd::Expression& expression,
-      gd::ParameterMetadata parameterMetadata,
-      gd::String oldName,
-      gd::String newName);
-
   /**
    * Remove all conditions of the list using an object
    *

Core/GDCore/IDE/Events/UsedExtensionsFinder.cpp

@@ -13,6 +13,18 @@
 
 namespace gd {
 
+void UsedExtensionsResult::AddUsedExtension(const gd::PlatformExtension& extension) {
+  usedExtensions.insert(extension.GetName());
+
+  usedSourceFiles.insert(usedSourceFiles.end(),
+                         extension.GetAllSourceFiles().begin(),
+                         extension.GetAllSourceFiles().end());
+}
+
+void UsedExtensionsResult::AddUsedBuiltinExtension(const gd::String& extensionName) {
+  usedExtensions.insert(extensionName);
+}
+
 const UsedExtensionsResult UsedExtensionsFinder::ScanProject(gd::Project& project) {
   UsedExtensionsFinder worker(project);
   gd::ProjectBrowserHelper::ExposeProjectObjects(project, worker);
@@ -28,9 +40,9 @@ void UsedExtensionsFinder::DoVisitObject(gd::Object &object) {
   if (metadata.GetMetadata().IsRenderedIn3D()) {
     result.MarkAsHaving3DObjects();
   }
-  result.GetUsedExtensions().insert(metadata.GetExtension().GetName());
+  result.AddUsedExtension(metadata.GetExtension());
   for (auto &&includeFile : metadata.GetMetadata().includeFiles) {
-    result.GetUsedIncludeFiles().insert(includeFile);
+    result.AddUsedIncludeFiles(includeFile);
   }
 };
 
@@ -39,12 +51,12 @@ void UsedExtensionsFinder::DoVisitObject(gd::Object &object) {
 void UsedExtensionsFinder::DoVisitBehavior(gd::Behavior &behavior) {
   auto metadata = gd::MetadataProvider::GetExtensionAndBehaviorMetadata(
       project.GetCurrentPlatform(), behavior.GetTypeName());
-  result.GetUsedExtensions().insert(metadata.GetExtension().GetName());
+  result.AddUsedExtension(metadata.GetExtension());
   for (auto &&includeFile : metadata.GetMetadata().includeFiles) {
-    result.GetUsedIncludeFiles().insert(includeFile);
+    result.AddUsedIncludeFiles(includeFile);
   }
   for (auto &&includeFile : metadata.GetMetadata().requiredFiles) {
-    result.GetUsedRequiredFiles().insert(includeFile);
+    result.AddUsedRequiredFiles(includeFile);
   }
 };
 
@@ -57,9 +69,9 @@ bool UsedExtensionsFinder::DoVisitInstruction(gd::Instruction& instruction,
                         project.GetCurrentPlatform(), instruction.GetType())
                   : gd::MetadataProvider::GetExtensionAndActionMetadata(
                         project.GetCurrentPlatform(), instruction.GetType());
-  result.GetUsedExtensions().insert(metadata.GetExtension().GetName());
+  result.AddUsedExtension(metadata.GetExtension());
   for (auto&& includeFile : metadata.GetMetadata().GetIncludeFiles()) {
-    result.GetUsedIncludeFiles().insert(includeFile);
+    result.AddUsedIncludeFiles(includeFile);
   }
 
   gd::ParameterMetadataTools::IterateOverParameters(
@@ -77,7 +89,7 @@ bool UsedExtensionsFinder::DoVisitInstruction(gd::Instruction& instruction,
       rootType = "number";
       parameterValue.GetRootNode()->Visit(*this);
     } else if (gd::ParameterMetadata::IsExpression("variable", parameterType))
-      result.GetUsedExtensions().insert("BuiltinVariables");
+      result.AddUsedBuiltinExtension("BuiltinVariables");
   });
 
   return false;
@@ -110,7 +122,7 @@ void UsedExtensionsFinder::OnVisitUnaryOperatorNode(UnaryOperatorNode& node) {
 
 // Add variable extension and visit sub-expressions on variable nodes
 void UsedExtensionsFinder::OnVisitVariableNode(VariableNode& node) {
-  result.GetUsedExtensions().insert("BuiltinVariables");
+  result.AddUsedBuiltinExtension("BuiltinVariables");
 
   auto type = gd::ExpressionTypeFinder::GetType(
       project.GetCurrentPlatform(), GetProjectScopedContainers(), rootType, node);
@@ -123,9 +135,9 @@ void UsedExtensionsFinder::OnVisitVariableNode(VariableNode& node) {
         // This represents an object.
         auto metadata = gd::MetadataProvider::GetExtensionAndObjectMetadata(
           project.GetCurrentPlatform(), node.name);
-        result.GetUsedExtensions().insert(metadata.GetExtension().GetName());
+        result.AddUsedExtension(metadata.GetExtension());
         for (auto &&includeFile : metadata.GetMetadata().includeFiles) {
-          result.GetUsedIncludeFiles().insert(includeFile);
+          result.AddUsedIncludeFiles(includeFile);
         }
       }, [&]() {
         // This is a variable.
@@ -143,13 +155,13 @@ void UsedExtensionsFinder::OnVisitVariableNode(VariableNode& node) {
 
 void UsedExtensionsFinder::OnVisitVariableAccessorNode(
     VariableAccessorNode& node) {
-  result.GetUsedExtensions().insert("BuiltinVariables");
+  result.AddUsedBuiltinExtension("BuiltinVariables");
   if (node.child) node.child->Visit(*this);
 };
 
 void UsedExtensionsFinder::OnVisitVariableBracketAccessorNode(
     VariableBracketAccessorNode& node) {
-  result.GetUsedExtensions().insert("BuiltinVariables");
+  result.AddUsedBuiltinExtension("BuiltinVariables");
   node.expression->Visit(*this);
   if (node.child) node.child->Visit(*this);
 };
@@ -163,9 +175,9 @@ void UsedExtensionsFinder::OnVisitIdentifierNode(IdentifierNode &node) {
     // An object or object variable is used.
     auto metadata = gd::MetadataProvider::GetExtensionAndObjectMetadata(
         project.GetCurrentPlatform(), node.identifierName);
-    result.GetUsedExtensions().insert(metadata.GetExtension().GetName());
+    result.AddUsedExtension(metadata.GetExtension());
     for (auto &&includeFile : metadata.GetMetadata().includeFiles) {
-      result.GetUsedIncludeFiles().insert(includeFile);
+      result.AddUsedIncludeFiles(includeFile);
     }
   }
 };
@@ -187,9 +199,9 @@ void UsedExtensionsFinder::OnVisitFunctionCallNode(FunctionCallNode& node) {
       return;
   }
 
-  result.GetUsedExtensions().insert(metadata.GetExtension().GetName());
+  result.AddUsedExtension(metadata.GetExtension());
   for (auto&& includeFile : metadata.GetMetadata().GetIncludeFiles()) {
-    result.GetUsedIncludeFiles().insert(includeFile);
+    result.AddUsedIncludeFiles(includeFile);
   }
 };
 

Core/GDCore/IDE/Events/UsedExtensionsFinder.h

@@ -9,6 +9,8 @@
 #include <set>
 
 #include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
+#include "GDCore/Extensions/Metadata/SourceFileMetadata.h"
+#include "GDCore/Extensions/PlatformExtension.h"
 #include "GDCore/IDE/Events/ArbitraryEventsWorker.h"
 #include "GDCore/IDE/Project/ArbitraryObjectsWorker.h"
 #include "GDCore/String.h"
@@ -44,6 +46,10 @@ public:
     return usedRequiredFiles;
   }
 
+  const std::vector<gd::SourceFileMetadata>& GetUsedSourceFiles() const {
+    return usedSourceFiles;
+  }
+
   /**
    * \brief Return true when at least 1 object uses the 3D renderer.
    */
@@ -51,20 +57,10 @@ public:
     return has3DObjects;
   }
 
-  /**
-   * The extensions used by the project (or part of it).
-   */
-  std::set<gd::String> &GetUsedExtensions() { return usedExtensions; }
-
-  /**
-   * The include files used at runtime by the project (or part of it).
-   */
-  std::set<gd::String> &GetUsedIncludeFiles() { return usedIncludeFiles; }
-
-  /**
-   * The additional files required at runtime by the project (or part of it).
-   */
-  std::set<gd::String> &GetUsedRequiredFiles() { return usedRequiredFiles; }
+  void AddUsedExtension(const gd::PlatformExtension& extension);
+  void AddUsedBuiltinExtension(const gd::String& extensionName);
+  void AddUsedIncludeFiles(const gd::String& includeFile) { usedIncludeFiles.insert(includeFile); }
+  void AddUsedRequiredFiles(const gd::String& requiredFile) { usedRequiredFiles.insert(requiredFile); }
 
   void MarkAsHaving3DObjects() {
     has3DObjects = true;
@@ -74,6 +70,7 @@ private:
   std::set<gd::String> usedExtensions;
   std::set<gd::String> usedIncludeFiles;
   std::set<gd::String> usedRequiredFiles;
+  std::vector<gd::SourceFileMetadata> usedSourceFiles;
   bool has3DObjects = false;
 };
 

Core/GDCore/IDE/Project/ArbitraryResourceWorker.cpp

@@ -62,6 +62,11 @@ void ArbitraryResourceWorker::ExposeSpine(gd::String& resourceName){
     // do.
 };
 
+void ArbitraryResourceWorker::ExposeJavaScript(gd::String& resourceName){
+    // Nothing to do by default - each child class can define here the action to
+    // do.
+};
+
 void ArbitraryResourceWorker::ExposeVideo(gd::String& videoName){
     // Nothing to do by default - each child class can define here the action to
     // do.
@@ -195,6 +200,10 @@ void ArbitraryResourceWorker::ExposeResourceWithType(
     ExposeSpine(resourceName);
     return;
   }
+  if (resourceType == "javascript") {
+    ExposeJavaScript(resourceName);
+    return;
+  }
   gd::LogError("Unexpected resource type: " + resourceType + " for: " + resourceName);
   return;
 }

Core/GDCore/IDE/Project/ArbitraryResourceWorker.h

@@ -96,7 +96,7 @@ public:
    * \brief Expose a 3D model, which is always a reference to a "model3D" resource.
    */
   virtual void ExposeModel3D(gd::String &resourceName);
-  
+
   /**
    * \brief Expose an atlas, which is always a reference to a "atlas" resource.
    */
@@ -112,6 +112,11 @@ public:
    */
   virtual void ExposeVideo(gd::String &videoName);
 
+  /**
+   * \brief Expose a JavaScript file, which is always a reference to a "javascript" resource.
+   */
+  virtual void ExposeJavaScript(gd::String &javaScriptName);
+
   /**
    * \brief Expose a bitmap font, which is always a reference to a "bitmapFont" resource.
    */

Core/GDCore/IDE/Project/AssetResourcePathCleaner.cpp

@@ -38,6 +38,10 @@ void AssetResourcePathCleaner::ExposeVideo(gd::String &videoName) {
   ExposeResourceAsFile(videoName);
 }
 
+void AssetResourcePathCleaner::ExposeJavaScript(gd::String &javaScriptResourceName) {
+  ExposeResourceAsFile(javaScriptResourceName);
+}
+
 void AssetResourcePathCleaner::ExposeBitmapFont(gd::String &bitmapFontName) {
   ExposeResourceAsFile(bitmapFontName);
 }

Core/GDCore/IDE/Project/AssetResourcePathCleaner.h

@@ -46,6 +46,7 @@ public:
   void ExposeTileset(gd::String &tilesetName) override;
   void ExposeVideo(gd::String &videoName) override;
   void ExposeBitmapFont(gd::String &bitmapFontName) override;
+  void ExposeJavaScript(gd::String &javaScriptResourceName) override;
   void ExposeFile(gd::String &resource) override;
 
 protected:

Core/GDCore/IDE/Project/ObjectsUsingResourceCollector.h

@@ -73,6 +73,9 @@ public:
   virtual void ExposeVideo(gd::String& otherResourceName) override {
     MatchResourceName(otherResourceName);
   };
+  virtual void ExposeJavaScript(gd::String& otherResourceName) override {
+    MatchResourceName(otherResourceName);
+  };
   virtual void ExposeBitmapFont(gd::String& otherResourceName) override {
     MatchResourceName(otherResourceName);
   };

Core/GDCore/IDE/Project/ResourcesInUseHelper.h

@@ -60,6 +60,7 @@ public:
     if (resourceType == "model3D") return allModel3Ds;
     if (resourceType == "atlas") return allAtlases;
     if (resourceType == "spine") return allSpines;
+    if (resourceType == "javascript") return allJavaScripts;
 
     return emptyResources;
   };
@@ -88,6 +89,9 @@ public:
   virtual void ExposeVideo(gd::String& resourceName) override {
     allVideos.insert(resourceName);
   };
+  virtual void ExposeJavaScript(gd::String& resourceName) override {
+    allJavaScripts.insert(resourceName);
+  };
   virtual void ExposeBitmapFont(gd::String& resourceName) override {
     allBitmapFonts.insert(resourceName);
   };
@@ -114,6 +118,7 @@ public:
   std::set<gd::String> allModel3Ds;
   std::set<gd::String> allAtlases;
   std::set<gd::String> allSpines;
+  std::set<gd::String> allJavaScripts;
   std::set<gd::String> emptyResources;
 
   static const std::vector<gd::String> resourceTypes;

Core/GDCore/IDE/Project/ResourcesRenamer.h

@@ -59,6 +59,9 @@ class ResourcesRenamer : public gd::ArbitraryResourceWorker {
   virtual void ExposeVideo(gd::String& videoResourceName) override {
     RenameIfNeeded(videoResourceName);
   };
+  virtual void ExposeJavaScript(gd::String& javaScriptResourceName) override {
+    RenameIfNeeded(javaScriptResourceName);
+  };
   virtual void ExposeBitmapFont(gd::String& bitmapFontName) override {
     RenameIfNeeded(bitmapFontName);
   };

Core/GDCore/IDE/Project/SceneResourcesFinder.h

@@ -74,6 +74,9 @@ private:
   void ExposeVideo(gd::String &videoResourceName) override {
     AddUsedResource(videoResourceName);
   };
+  void ExposeJavaScript(gd::String &javaScriptResourceName) override {
+    AddUsedResource(javaScriptResourceName);
+  };
   void ExposeBitmapFont(gd::String &bitmapFontName) override {
     AddUsedResource(bitmapFontName);
   };

Core/GDCore/IDE/ProjectBrowserHelper.cpp

@@ -26,8 +26,8 @@ namespace gd {
 
 void ProjectBrowserHelper::ExposeProjectEvents(
     gd::Project &project, gd::ArbitraryEventsWorker &worker) {
-  // See also gd::Project::ExposeResources for a method that traverses the whole
-  // project (this time for resources).
+  // See also gd::ResourceExposer::ExposeWholeProjectResources
+  // for a method that traverses the whole project (this time for resources).
 
   ExposeProjectEventsWithoutExtensions(project, worker);
 
@@ -106,16 +106,16 @@ void ProjectBrowserHelper::ExposeLayoutEventsAndDependencies(
   }
   for (const gd::String& sceneName : dependenciesAnalyzer.GetScenesDependencies()) {
     gd::Layout& dependencyLayout = project.GetLayout(sceneName);
-    
+
     worker.Launch(dependencyLayout.GetEvents());
   }
 }
 
 void ProjectBrowserHelper::ExposeProjectEvents(
     gd::Project &project, gd::ArbitraryEventsWorkerWithContext &worker) {
-  // See also gd::Project::ExposeResources for a method that traverse the whole
-  // project (this time for resources) and ExposeProjectEffects (this time for
-  // effects).
+  // See also gd::ResourceExposer::ExposeWholeProjectResources
+  // for a method that traverses the whole project (this time for resources)
+  // and ExposeProjectEffects (this time for effects).
 
   // Add layouts events
   for (std::size_t s = 0; s < project.GetLayoutsCount(); s++) {

Core/GDCore/IDE/ResourceExposer.cpp

@@ -5,21 +5,22 @@
  */
 #include "ResourceExposer.h"
 
+#include "GDCore/Extensions/Metadata/EffectMetadata.h"
+#include "GDCore/Extensions/Metadata/MetadataProvider.h"
+#include "GDCore/Extensions/Platform.h"
 #include "GDCore/IDE/Events/ArbitraryEventsWorker.h"
 #include "GDCore/IDE/Project/ArbitraryResourceWorker.h"
 #include "GDCore/IDE/ProjectBrowserHelper.h"
+#include "GDCore/Project/Effect.h"
 #include "GDCore/Project/EventsFunctionsExtension.h"
 #include "GDCore/Project/Layout.h"
 #include "GDCore/Project/Project.h"
-#include "GDCore/Project/Effect.h"
 #include "GDCore/String.h"
-#include "GDCore/Extensions/Platform.h"
-#include "GDCore/Extensions/Metadata/MetadataProvider.h"
-#include "GDCore/Extensions/Metadata/EffectMetadata.h"
 
 namespace gd {
 
-void ResourceExposer::ExposeWholeProjectResources(gd::Project& project, gd::ArbitraryResourceWorker& worker) {
+void ResourceExposer::ExposeWholeProjectResources(
+    gd::Project &project, gd::ArbitraryResourceWorker &worker) {
   // See also gd::ProjectBrowserHelper::ExposeProjectEvents for a method that
   // traverse the whole project (this time for events) and ExposeProjectEffects
   // (this time for effects).
@@ -31,13 +32,11 @@ void ResourceExposer::ExposeWholeProjectResources(gd::Project& project, gd::Arbi
 
   // Expose event resources
   auto eventWorker = gd::GetResourceWorkerOnEvents(project, worker);
-  gd::ProjectBrowserHelper::ExposeProjectEvents(
-    project, eventWorker);
+  gd::ProjectBrowserHelper::ExposeProjectEvents(project, eventWorker);
 
   // Expose object configuration resources
   auto objectWorker = gd::GetResourceWorkerOnObjects(project, worker);
-  gd::ProjectBrowserHelper::ExposeProjectObjects(
-    project, objectWorker);
+  gd::ProjectBrowserHelper::ExposeProjectObjects(project, objectWorker);
 
   // Expose layer effect resources
   for (std::size_t layoutIndex = 0; layoutIndex < project.GetLayoutsCount();
@@ -52,28 +51,36 @@ void ResourceExposer::ExposeWholeProjectResources(gd::Project& project, gd::Arbi
       for (size_t effectIndex = 0; effectIndex < effects.GetEffectsCount();
            effectIndex++) {
         auto &effect = effects.GetEffect(effectIndex);
-        gd::ResourceExposer::ExposeEffectResources(project.GetCurrentPlatform(),
-                                                   effect, worker);
+        gd::ResourceExposer::ExposeEffectResources(
+            project.GetCurrentPlatform(), effect, worker);
       }
     }
   }
 
   // Expose loading screen background image if present
-  auto& loadingScreen = project.GetLoadingScreen();
+  auto &loadingScreen = project.GetLoadingScreen();
   if (loadingScreen.GetBackgroundImageResourceName() != "")
     worker.ExposeImage(loadingScreen.GetBackgroundImageResourceName());
+
+  // Expose extension source files
+  for (std::size_t e = 0; e < project.GetEventsFunctionsExtensionsCount();
+       e++) {
+    auto &eventsFunctionsExtension = project.GetEventsFunctionsExtension(e);
+    ExposeExtensionResources(eventsFunctionsExtension, worker);
+  }
 }
 
-void ResourceExposer::ExposeProjectResources(gd::Project& project, gd::ArbitraryResourceWorker& worker) {
+void ResourceExposer::ExposeProjectResources(
+    gd::Project &project, gd::ArbitraryResourceWorker &worker) {
   // Expose global objects configuration resources
   auto objectWorker = gd::GetResourceWorkerOnObjects(project, worker);
   objectWorker.Launch(project.GetObjects());
 }
 
 void ResourceExposer::ExposeLayoutResources(
-    gd::Project &project, gd::Layout &layout,
+    gd::Project &project,
+    gd::Layout &layout,
     gd::ArbitraryResourceWorker &worker) {
-
   // Expose object configuration resources
   auto objectWorker = gd::GetResourceWorkerOnObjects(project, worker);
   gd::ProjectBrowserHelper::ExposeLayoutObjects(layout, objectWorker);
@@ -87,15 +94,15 @@ void ResourceExposer::ExposeLayoutResources(
     for (size_t effectIndex = 0; effectIndex < effects.GetEffectsCount();
          effectIndex++) {
       auto &effect = effects.GetEffect(effectIndex);
-      gd::ResourceExposer::ExposeEffectResources(project.GetCurrentPlatform(),
-                                                 effect, worker);
+      gd::ResourceExposer::ExposeEffectResources(
+          project.GetCurrentPlatform(), effect, worker);
     }
   }
 
   // Expose event resources
   auto eventWorker = gd::GetResourceWorkerOnEvents(project, worker);
-  gd::ProjectBrowserHelper::ExposeLayoutEventsAndDependencies(project, layout,
-                                                              eventWorker);
+  gd::ProjectBrowserHelper::ExposeLayoutEventsAndDependencies(
+      project, layout, eventWorker);
 
   // Exposed extension event resources
   // Note that using resources in extensions is very unlikely and probably not
@@ -103,12 +110,14 @@ void ResourceExposer::ExposeLayoutResources(
   for (std::size_t e = 0; e < project.GetEventsFunctionsExtensionsCount();
        e++) {
     auto &eventsFunctionsExtension = project.GetEventsFunctionsExtension(e);
-    gd::ProjectBrowserHelper::ExposeEventsFunctionsExtensionEvents(project, eventsFunctionsExtension, eventWorker);
+    gd::ProjectBrowserHelper::ExposeEventsFunctionsExtensionEvents(
+        project, eventsFunctionsExtension, eventWorker);
   }
 }
 
 void ResourceExposer::ExposeEffectResources(
-    gd::Platform &platform, gd::Effect &effect,
+    gd::Platform &platform,
+    gd::Effect &effect,
     gd::ArbitraryResourceWorker &worker) {
   auto &effectMetadata =
       MetadataProvider::GetEffectMetadata(platform, effect.GetEffectType());
@@ -127,11 +136,20 @@ void ResourceExposer::ExposeEffectResources(
         worker.ExposeResourceWithType(resourceType,
                                       potentiallyUpdatedResourceName);
         if (potentiallyUpdatedResourceName != resourceName) {
-          effect.SetStringParameter(propertyName, potentiallyUpdatedResourceName);
+          effect.SetStringParameter(propertyName,
+                                    potentiallyUpdatedResourceName);
         }
       }
     }
   }
 }
 
-} // namespace gd
+void ResourceExposer::ExposeExtensionResources(
+    gd::EventsFunctionsExtension &extension,
+    gd::ArbitraryResourceWorker &worker) {
+  for (auto &sourceFile : extension.GetAllSourceFiles()) {
+    worker.ExposeJavaScript(sourceFile.GetResourceName());
+  }
+}
+
+}  // namespace gd

Core/GDCore/IDE/ResourceExposer.h

@@ -9,9 +9,10 @@ namespace gd {
 class Platform;
 class Project;
 class ArbitraryResourceWorker;
+class EventsFunctionsExtension;
 class Effect;
 class Layout;
-} // namespace gd
+}  // namespace gd
 
 namespace gd {
 
@@ -19,7 +20,7 @@ namespace gd {
  * \brief
  */
 class GD_CORE_API ResourceExposer {
-public:
+ public:
   /**
    * \brief Called ( e.g. during compilation ) so as to inventory internal
    * resources, sometimes update their filename or any other work or resources.
@@ -34,7 +35,7 @@ public:
 
   /**
    * @brief Expose only the resources used globally on a project.
-   * 
+   *
    * It doesn't include resources used in layouts.
    */
   static void ExposeProjectResources(gd::Project &project,
@@ -42,17 +43,25 @@ public:
 
   /**
    * @brief Expose the resources used in a given layout.
-   * 
+   *
    * It doesn't include resources used globally.
    */
-  static void ExposeLayoutResources(gd::Project &project, gd::Layout &layout,
-                                          gd::ArbitraryResourceWorker &worker);
+  static void ExposeLayoutResources(gd::Project &project,
+                                    gd::Layout &layout,
+                                    gd::ArbitraryResourceWorker &worker);
 
   /**
    * @brief Expose the resources used in a given effect.
    */
-  static void ExposeEffectResources(gd::Platform &platform, gd::Effect &effect,
+  static void ExposeEffectResources(gd::Platform &platform,
+                                    gd::Effect &effect,
                                     gd::ArbitraryResourceWorker &worker);
+
+  /**
+   * @brief Expose the resources used in an extension.
+   */
+  static void ExposeExtensionResources(gd::EventsFunctionsExtension &extension,
+                                       gd::ArbitraryResourceWorker &worker);
 };
 
-} // namespace gd
+}  // namespace gd

Core/GDCore/IDE/WholeProjectRefactorer.cpp

@@ -19,6 +19,7 @@
 #include "GDCore/IDE/Events/BehaviorTypeRenamer.h"
 #include "GDCore/IDE/Events/CustomObjectTypeRenamer.h"
 #include "GDCore/IDE/Events/EventsBehaviorRenamer.h"
+#include "GDCore/IDE/Events/EventsParameterReplacer.h"
 #include "GDCore/IDE/Events/EventsPropertyReplacer.h"
 #include "GDCore/IDE/Events/EventsRefactorer.h"
 #include "GDCore/IDE/Events/EventsVariableInstructionTypeSwitcher.h"
@@ -816,6 +817,51 @@ void WholeProjectRefactorer::RenameObjectEventsFunction(
   }
 }
 
+void WholeProjectRefactorer::RenameParameter(
+    gd::Project &project, gd::ProjectScopedContainers &projectScopedContainers,
+    gd::EventsFunction &eventsFunction,
+    const gd::ObjectsContainer &parameterObjectsContainer,
+    const gd::String &oldParameterName, const gd::String &newParameterName) {
+  auto &parameters = eventsFunction.GetParameters();
+  if (!parameters.HasParameterNamed(oldParameterName))
+    return;
+  auto &parameter = parameters.GetParameter(oldParameterName);
+  if (parameter.GetValueTypeMetadata().IsObject()) {
+    gd::WholeProjectRefactorer::ObjectOrGroupRenamedInEventsFunction(
+        project, projectScopedContainers, eventsFunction,
+        parameterObjectsContainer, oldParameterName, newParameterName, false);
+  } else if (parameter.GetValueTypeMetadata().IsBehavior()) {
+    size_t behaviorParameterIndex = parameters.GetParameterPosition(parameter);
+    size_t objectParameterIndex =
+        gd::ParameterMetadataTools::GetObjectParameterIndexFor(
+            parameters, behaviorParameterIndex);
+    if (objectParameterIndex == gd::String::npos) {
+      return;
+    }
+    const gd::String &objectName =
+        parameters.GetParameter(objectParameterIndex).GetName();
+    gd::EventsBehaviorRenamer behaviorRenamer(project.GetCurrentPlatform(),
+                                              objectName, oldParameterName,
+                                              newParameterName);
+    behaviorRenamer.Launch(eventsFunction.GetEvents(), projectScopedContainers);
+  } else {
+    // Rename parameter names directly used as an identifier.
+    std::unordered_map<gd::String, gd::String> oldToNewParameterNames = {
+        {oldParameterName, newParameterName}};
+    gd::EventsParameterReplacer eventsParameterReplacer(
+        project.GetCurrentPlatform(), oldToNewParameterNames);
+    eventsParameterReplacer.Launch(eventsFunction.GetEvents(),
+                                   projectScopedContainers);
+
+    // Rename parameter names in legacy expressions and instructions
+    gd::ProjectElementRenamer projectElementRenamer(
+        project.GetCurrentPlatform(), "functionParameterName", oldParameterName,
+        newParameterName);
+    projectElementRenamer.Launch(eventsFunction.GetEvents(),
+                                 projectScopedContainers);
+  }
+}
+
 void WholeProjectRefactorer::MoveEventsFunctionParameter(
     gd::Project &project,
     const gd::EventsFunctionsExtension &eventsFunctionsExtension,
@@ -1705,6 +1751,15 @@ void WholeProjectRefactorer::BehaviorsAddedToObjectInScene(
 void WholeProjectRefactorer::ObjectOrGroupRenamedInScene(
     gd::Project &project, gd::Layout &layout, const gd::String &oldName,
     const gd::String &newName, bool isObjectGroup) {
+  gd::WholeProjectRefactorer::ObjectOrGroupRenamedInScene(
+      project, layout, layout.GetObjects(), oldName, newName, isObjectGroup);
+}
+
+void WholeProjectRefactorer::ObjectOrGroupRenamedInScene(
+    gd::Project &project, gd::Layout &layout,
+    const gd::ObjectsContainer &targetedObjectsContainer,
+    const gd::String &oldName, const gd::String &newName, bool isObjectGroup) {
+
   if (oldName == newName || newName.empty() || oldName.empty())
     return;
 
@@ -1714,7 +1769,7 @@ void WholeProjectRefactorer::ObjectOrGroupRenamedInScene(
   // Rename object in the current layout
   gd::EventsRefactorer::RenameObjectInEvents(
       project.GetCurrentPlatform(), projectScopedContainers, layout.GetEvents(),
-      oldName, newName);
+      layout.GetObjects(), oldName, newName);
 
   // Object groups can't have instances or be in other groups
   if (!isObjectGroup) {
@@ -1731,7 +1786,7 @@ void WholeProjectRefactorer::ObjectOrGroupRenamedInScene(
     auto &externalEvents = project.GetExternalEvents(externalEventsName);
     gd::EventsRefactorer::RenameObjectInEvents(
         project.GetCurrentPlatform(), projectScopedContainers,
-        externalEvents.GetEvents(), oldName, newName);
+        externalEvents.GetEvents(), layout.GetObjects(), oldName, newName);
   }
 
   // Rename object in external layouts
@@ -1977,8 +2032,8 @@ void WholeProjectRefactorer::ObjectOrGroupRenamedInEventsBasedObject(
        eventsBasedObject.GetEventsFunctions().GetInternalVector()) {
     auto *function = functionUniquePtr.get();
     WholeProjectRefactorer::ObjectOrGroupRenamedInEventsFunction(
-        project, projectScopedContainers, *function, oldName, newName,
-        isObjectGroup);
+        project, projectScopedContainers, *function,
+        eventsBasedObject.GetObjects(), oldName, newName, isObjectGroup);
   }
 
   // Object groups can't have instances or be in other groups
@@ -1995,11 +2050,12 @@ void WholeProjectRefactorer::ObjectOrGroupRenamedInEventsBasedObject(
 void WholeProjectRefactorer::ObjectOrGroupRenamedInEventsFunction(
     gd::Project &project,
     const gd::ProjectScopedContainers &projectScopedContainers,
-    gd::EventsFunction &eventsFunction, const gd::String &oldName,
-    const gd::String &newName, bool isObjectGroup) {
+    gd::EventsFunction &eventsFunction,
+    const gd::ObjectsContainer &targetedObjectsContainer,
+    const gd::String &oldName, const gd::String &newName, bool isObjectGroup) {
   gd::EventsRefactorer::RenameObjectInEvents(
       project.GetCurrentPlatform(), projectScopedContainers,
-      eventsFunction.GetEvents(), oldName, newName);
+      eventsFunction.GetEvents(), targetedObjectsContainer, oldName, newName);
 
   // Object groups can't be in other groups
   if (!isObjectGroup) {
@@ -2025,7 +2081,7 @@ void WholeProjectRefactorer::GlobalObjectOrGroupRenamed(
     if (layout.GetObjects().HasObjectNamed(oldName))
       continue;
 
-    ObjectOrGroupRenamedInScene(project, layout, oldName, newName,
+    ObjectOrGroupRenamedInScene(project, layout, project.GetObjects(), oldName, newName,
                                  isObjectGroup);
   }
 }

Core/GDCore/IDE/WholeProjectRefactorer.h

@@ -176,6 +176,21 @@ class GD_CORE_API WholeProjectRefactorer {
       const gd::String& oldFunctionName,
       const gd::String& newFunctionName);
 
+  /**
+   * \brief Refactor the function **before** a parameter is renamed.
+   *
+   * \warning Do the renaming of the specified parameter after calling this.
+   * This is because the function is expected to have its old name for the
+   * refactoring.
+   */
+  static void
+  RenameParameter(gd::Project &project,
+                  gd::ProjectScopedContainers &projectScopedContainers,
+                  gd::EventsFunction &eventsFunction,
+                  const gd::ObjectsContainer &parameterObjectsContainer,
+                  const gd::String &oldParameterName,
+                  const gd::String &newParameterName);
+
   /**
    * \brief Refactor the project **before** an events function parameter
    * is moved.
@@ -529,6 +544,7 @@ class GD_CORE_API WholeProjectRefactorer {
       gd::Project& project,
       const gd::ProjectScopedContainers &projectScopedContainers,
       gd::EventsFunction& eventsFunction,
+      const gd::ObjectsContainer &targetedObjectsContainer,
       const gd::String& oldName,
       const gd::String& newName,
       bool isObjectGroup);
@@ -649,6 +665,12 @@ class GD_CORE_API WholeProjectRefactorer {
   virtual ~WholeProjectRefactorer(){};
 
  private:
+  static void ObjectOrGroupRenamedInScene(gd::Project &project,
+                                          gd::Layout &scene,
+                                          const gd::ObjectsContainer &targetedObjectsContainer,
+                                          const gd::String &oldName,
+                                          const gd::String &newName,
+                                          bool isObjectGroup);
   static std::vector<gd::String> GetAssociatedExternalLayouts(
       gd::Project& project, gd::Layout& layout);
   static std::vector<gd::String>

Core/GDCore/Project/AbstractEventsBasedEntity.cpp

@@ -23,6 +23,9 @@ void AbstractEventsBasedEntity::SerializeTo(SerializerElement& element) const {
   element.SetAttribute("description", description);
   element.SetAttribute("name", name);
   element.SetAttribute("fullName", fullName);
+  if (isPrivate) {
+    element.SetBoolAttribute("private", isPrivate);
+  }
 
   gd::SerializerElement& eventsFunctionsElement =
       element.AddChild("eventsFunctions");
@@ -36,6 +39,7 @@ void AbstractEventsBasedEntity::UnserializeFrom(
   description = element.GetStringAttribute("description");
   name = element.GetStringAttribute("name");
   fullName = element.GetStringAttribute("fullName");
+  isPrivate = element.GetBoolAttribute("private");
 
   const gd::SerializerElement& eventsFunctionsElement =
       element.GetChild("eventsFunctions");

Core/GDCore/Project/AbstractEventsBasedEntity.h

@@ -3,8 +3,7 @@
  * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
  * reserved. This project is released under the MIT License.
  */
-#ifndef GDCORE_ABSTRACTEVENTSBASEDENTITY_H
-#define GDCORE_ABSTRACTEVENTSBASEDENTITY_H
+#pragma once
 
 #include <vector>
 #include "GDCore/Project/NamedPropertyDescriptor.h"
@@ -40,6 +39,21 @@ class GD_CORE_API AbstractEventsBasedEntity {
    */
   AbstractEventsBasedEntity* Clone() const { return new AbstractEventsBasedEntity(*this); };
 
+  /**
+   * \brief Check if the behavior or object is private - it can't be used outside of its
+   * extension.
+   */
+  bool IsPrivate() const { return isPrivate; }
+
+  /**
+   * \brief Set that the behavior or object is private - it can't be used outside of its
+   * extension.
+   */
+  AbstractEventsBasedEntity& SetPrivate(bool isPrivate_) {
+    isPrivate = isPrivate_;
+    return *this;
+  }
+
   /**
    * \brief Get the description of the behavior or object, that is displayed in the
    * editor.
@@ -151,8 +165,7 @@ class GD_CORE_API AbstractEventsBasedEntity {
   gd::EventsFunctionsContainer eventsFunctionsContainer;
   gd::PropertiesContainer propertyDescriptors;
   gd::String extensionName;
+  bool isPrivate = false;
 };
 
 }  // namespace gd
-
-#endif  // GDCORE_ABSTRACTEVENTSBASEDENTITY_H

Core/GDCore/Project/EventsBasedBehavior.cpp

@@ -21,9 +21,6 @@ EventsBasedBehavior::EventsBasedBehavior()
 void EventsBasedBehavior::SerializeTo(SerializerElement& element) const {
   AbstractEventsBasedEntity::SerializeTo(element);
   element.SetAttribute("objectType", objectType);
-  if (isPrivate) {
-    element.SetBoolAttribute("private", isPrivate);
-  }
   sharedPropertyDescriptors.SerializeElementsTo(
       "propertyDescriptor", element.AddChild("sharedPropertyDescriptors"));
   if (quickCustomizationVisibility != QuickCustomization::Visibility::Default) {
@@ -39,7 +36,6 @@ void EventsBasedBehavior::UnserializeFrom(gd::Project& project,
                                           const SerializerElement& element) {
   AbstractEventsBasedEntity::UnserializeFrom(project, element);
   objectType = element.GetStringAttribute("objectType");
-  isPrivate = element.GetBoolAttribute("private");
   sharedPropertyDescriptors.UnserializeElementsFrom(
       "propertyDescriptor", element.GetChild("sharedPropertyDescriptors"));
   if (element.HasChild("quickCustomizationVisibility")) {

Core/GDCore/Project/EventsBasedBehavior.h

@@ -3,8 +3,7 @@
  * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
  * reserved. This project is released under the MIT License.
  */
-#ifndef GDCORE_EVENTSBASEDBEHAVIOR_H
-#define GDCORE_EVENTSBASEDBEHAVIOR_H
+#pragma once
 
 #include <vector>
 #include "GDCore/Project/AbstractEventsBasedEntity.h"
@@ -75,17 +74,11 @@ class GD_CORE_API EventsBasedBehavior: public AbstractEventsBasedEntity {
   }
 
   /**
-   * \brief Check if the behavior is private - it can't be used outside of its
+   * \brief Set that the behavior or object is private - it can't be used outside of its
    * extension.
    */
-  bool IsPrivate() const { return isPrivate; }
-
-  /**
-   * \brief Set that the behavior is private - it can't be used outside of its
-   * extension.
-   */
-  EventsBasedBehavior& SetPrivate(bool _isPrivate) {
-    isPrivate = _isPrivate;
+  EventsBasedBehavior& SetPrivate(bool isPrivate) {
+    AbstractEventsBasedEntity::SetPrivate(isPrivate);
     return *this;
   }
 
@@ -149,11 +142,8 @@ class GD_CORE_API EventsBasedBehavior: public AbstractEventsBasedEntity {
 
  private:
   gd::String objectType;
-  bool isPrivate = false;
   gd::PropertiesContainer sharedPropertyDescriptors;
   QuickCustomization::Visibility quickCustomizationVisibility;
 };
 
 }  // namespace gd
-
-#endif  // GDCORE_EVENTSBASEDBEHAVIOR_H

Core/GDCore/Project/EventsBasedObject.h

@@ -72,6 +72,15 @@ class GD_CORE_API EventsBasedObject: public AbstractEventsBasedEntity {
     return *this;
   }
 
+  /**
+   * \brief Set that the object is private - it can't be used outside of its
+   * extension.
+   */
+  EventsBasedObject& SetPrivate(bool isPrivate) {
+    AbstractEventsBasedEntity::SetPrivate(isPrivate);
+    return *this;
+  }
+
   /**
    * \brief Declare a usage of the 3D renderer.
    */

Core/GDCore/Project/EventsFunctionsExtension.cpp

@@ -87,6 +87,13 @@ void EventsFunctionsExtension::SerializeTo(SerializerElement& element) const {
   for (auto& dependency : dependencies)
     SerializeDependencyTo(dependency, dependenciesElement.AddChild(""));
 
+  if (!sourceFiles.empty()) {
+    auto& sourceFilesElement = element.AddChild("sourceFiles");
+    sourceFilesElement.ConsiderAsArray();
+    for (auto& sourceFile : sourceFiles)
+      sourceFile.SerializeTo(sourceFilesElement.AddChild(""));
+  }
+
   GetGlobalVariables().SerializeTo(element.AddChild("globalVariables"));
   GetSceneVariables().SerializeTo(element.AddChild("sceneVariables"));
 
@@ -159,6 +166,17 @@ void EventsFunctionsExtension::UnserializeExtensionDeclarationFrom(
     dependencies.push_back(
         UnserializeDependencyFrom(dependenciesElement.GetChild(i)));
 
+  sourceFiles.clear();
+  if (element.HasChild("sourceFiles")) {
+    const auto& sourceFilesElement = element.GetChild("sourceFiles");
+    sourceFilesElement.ConsiderAsArray();
+    for (size_t i = 0; i < sourceFilesElement.GetChildrenCount(); ++i) {
+      SourceFileMetadata sourceFile;
+      sourceFile.UnserializeFrom(sourceFilesElement.GetChild(i));
+      sourceFiles.push_back(sourceFile);
+    }
+  }
+
   globalVariables.UnserializeFrom(element.GetChild("globalVariables"));
   sceneVariables.UnserializeFrom(element.GetChild("sceneVariables"));
 

Core/GDCore/Project/EventsFunctionsExtension.h

@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "GDCore/Extensions/Metadata/DependencyMetadata.h"
+#include "GDCore/Extensions/Metadata/SourceFileMetadata.h"
 #include "GDCore/Project/EventsBasedBehavior.h"
 #include "GDCore/Project/EventsBasedObject.h"
 #include "GDCore/Project/EventsFunctionsContainer.h"
@@ -289,6 +290,42 @@ class GD_CORE_API EventsFunctionsExtension : public EventsFunctionsContainer {
       const gd::String& eventsFunctionName);
   ///@}
 
+  /** \name Source files
+   */
+  ///@{
+
+  /**
+   * \brief Adds a new source file.
+   */
+  gd::SourceFileMetadata& AddSourceFile() {
+    gd::SourceFileMetadata sourceFile;
+    sourceFiles.push_back(sourceFile);
+    return sourceFiles.back();
+  };
+
+  /**
+   * \brief Removes a source file.
+   */
+  void RemoveSourceFileAt(size_t index) {
+    sourceFiles.erase(sourceFiles.begin() + index);
+  };
+
+  /**
+   * \brief Returns the list of source files.
+   */
+  std::vector<gd::SourceFileMetadata>& GetAllSourceFiles() {
+    return sourceFiles;
+  };
+
+  /**
+   * \brief Returns the list of source files.
+   */
+  const std::vector<gd::SourceFileMetadata>& GetAllSourceFiles() const {
+    return sourceFiles;
+  };
+
+  ///@}
+
  private:
   /**
    * Initialize object using another object. Used by copy-ctor and assign-op.
@@ -336,7 +373,8 @@ class GD_CORE_API EventsFunctionsExtension : public EventsFunctionsContainer {
   gd::SerializableWithNameList<EventsBasedBehavior> eventsBasedBehaviors;
   gd::SerializableWithNameList<EventsBasedObject> eventsBasedObjects;
   std::vector<gd::DependencyMetadata> dependencies;
-  
+  std::vector<gd::SourceFileMetadata> sourceFiles;
+
   gd::VariablesContainer globalVariables;
   gd::VariablesContainer sceneVariables;
 };

Core/GDCore/Project/Project.cpp

@@ -30,7 +30,6 @@
 #include "GDCore/Project/ObjectConfiguration.h"
 #include "GDCore/Project/ObjectGroupsContainer.h"
 #include "GDCore/Project/ResourcesManager.h"
-#include "GDCore/Project/SourceFile.h"
 #include "GDCore/Serialization/Serializer.h"
 #include "GDCore/Serialization/SerializerElement.h"
 #include "GDCore/String.h"
@@ -67,7 +66,6 @@ Project::Project()
       isAntialisingEnabledOnMobile(false),
       projectUuid(""),
       useDeprecatedZeroAsDefaultZOrder(false),
-      useExternalSourceFiles(false),
       isPlayableWithKeyboard(false),
       isPlayableWithGamepad(false),
       isPlayableWithMobile(false),
@@ -742,9 +740,6 @@ void Project::UnserializeFrom(const SerializerElement& element) {
   loadingScreen.UnserializeFrom(propElement.GetChild("loadingScreen"));
   watermark.UnserializeFrom(propElement.GetChild("watermark"));
 
-  useExternalSourceFiles =
-      propElement.GetBoolAttribute("useExternalSourceFiles");
-
   authorIds.clear();
   auto& authorIdsElement = propElement.GetChild("authorIds");
   authorIdsElement.ConsiderAsArray();
@@ -864,36 +859,7 @@ void Project::UnserializeFrom(const SerializerElement& element) {
   eventsFunctionsExtensions.clear();
   const SerializerElement& eventsFunctionsExtensionsElement =
       element.GetChild("eventsFunctionsExtensions");
-  eventsFunctionsExtensionsElement.ConsiderAsArrayOf(
-      "eventsFunctionsExtension");
-  // First, only unserialize behaviors and objects names.
-  // As event based objects can contains custom behaviors and custom objects,
-  // this allows them to reference EventBasedBehavior and EventBasedObject
-  // respectively.
-  for (std::size_t i = 0;
-       i < eventsFunctionsExtensionsElement.GetChildrenCount();
-       ++i) {
-    const SerializerElement& eventsFunctionsExtensionElement =
-        eventsFunctionsExtensionsElement.GetChild(i);
-
-    gd::EventsFunctionsExtension& newEventsFunctionsExtension =
-        InsertNewEventsFunctionsExtension("",
-                                          GetEventsFunctionsExtensionsCount());
-    newEventsFunctionsExtension.UnserializeExtensionDeclarationFrom(
-        *this, eventsFunctionsExtensionElement);
-  }
-
-  // Then unserialize functions, behaviors and objects content.
-  for (gd::String &extensionName :
-       GetUnserializingOrderExtensionNames(eventsFunctionsExtensionsElement)) {
-    size_t extensionIndex = GetEventsFunctionsExtensionPosition(extensionName);
-    const SerializerElement &eventsFunctionsExtensionElement =
-        eventsFunctionsExtensionsElement.GetChild(extensionIndex);
-
-    eventsFunctionsExtensions.at(extensionIndex)
-        ->UnserializeExtensionImplementationFrom(
-            *this, eventsFunctionsExtensionElement);
-  }
+  UnserializeAndInsertExtensionsFrom(eventsFunctionsExtensionsElement);
 
   objectsContainer.GetObjectGroups().UnserializeFrom(
       element.GetChild("objectsGroups", 0, "ObjectGroups"));
@@ -946,33 +912,83 @@ void Project::UnserializeFrom(const SerializerElement& element) {
         InsertNewExternalLayout("", GetExternalLayoutsCount());
     newExternalLayout.UnserializeFrom(externalLayoutElement);
   }
+}
 
-  externalSourceFiles.clear();
-  const SerializerElement& externalSourceFilesElement =
-      element.GetChild("externalSourceFiles", 0, "ExternalSourceFiles");
-  externalSourceFilesElement.ConsiderAsArrayOf("sourceFile", "SourceFile");
-  for (std::size_t i = 0; i < externalSourceFilesElement.GetChildrenCount();
+void Project::UnserializeAndInsertExtensionsFrom(
+  const gd::SerializerElement &eventsFunctionsExtensionsElement) {
+  eventsFunctionsExtensionsElement.ConsiderAsArrayOf(
+      "eventsFunctionsExtension");
+
+  std::map<gd::String, size_t> extensionNameToElementIndex;
+
+  // First, only unserialize behaviors and objects names.
+  // As event based objects can contains custom behaviors and custom objects,
+  // this allows them to reference EventBasedBehavior and EventBasedObject
+  // respectively.
+  for (std::size_t i = 0;
+       i < eventsFunctionsExtensionsElement.GetChildrenCount();
        ++i) {
-    const SerializerElement& sourceFileElement =
-        externalSourceFilesElement.GetChild(i);
+    const SerializerElement& eventsFunctionsExtensionElement =
+        eventsFunctionsExtensionsElement.GetChild(i);
+    const gd::String& name = eventsFunctionsExtensionElement.GetStringAttribute("name");
+    extensionNameToElementIndex[name] = i;
 
-    gd::SourceFile& newSourceFile = InsertNewSourceFile("", "");
-    newSourceFile.UnserializeFrom(sourceFileElement);
+    gd::EventsFunctionsExtension& eventsFunctionsExtension =
+        HasEventsFunctionsExtensionNamed(name)
+            ? GetEventsFunctionsExtension(name)
+            : InsertNewEventsFunctionsExtension(
+                  name, GetEventsFunctionsExtensionsCount());
+    eventsFunctionsExtension.UnserializeExtensionDeclarationFrom(
+        *this, eventsFunctionsExtensionElement);
+  }
+
+  // Then unserialize functions, behaviors and objects content.
+  for (gd::String &extensionName :
+       GetUnserializingOrderExtensionNames(eventsFunctionsExtensionsElement)) {
+
+    size_t extensionIndex = GetEventsFunctionsExtensionPosition(extensionName);
+    if (extensionIndex == gd::String::npos) {
+      // Should never happen because the extension was added in the first pass.
+      gd::LogError("Can't find extension " + extensionName + " in the list of extensions in second pass of unserialization.");
+      continue;
+    }
+    auto& partiallyLoadedExtension = eventsFunctionsExtensions.at(extensionIndex);
+
+    if (extensionNameToElementIndex.find(extensionName) == extensionNameToElementIndex.end()) {
+      // Should never happen because the extension element is present.
+      gd::LogError("Can't find extension element to unserialize for " + extensionName + " in second pass of unserialization.");
+      continue;
+    }
+    size_t elementIndex = extensionNameToElementIndex[extensionName];
+    const SerializerElement &eventsFunctionsExtensionElement =
+        eventsFunctionsExtensionsElement.GetChild(elementIndex);
+
+    partiallyLoadedExtension
+        ->UnserializeExtensionImplementationFrom(
+            *this, eventsFunctionsExtensionElement);
   }
 }
 
 std::vector<gd::String> Project::GetUnserializingOrderExtensionNames(
     const gd::SerializerElement &eventsFunctionsExtensionsElement) {
+  eventsFunctionsExtensionsElement.ConsiderAsArrayOf(
+      "eventsFunctionsExtension");
 
   // Some extension have custom objects, which have child objects coming from other extension.
   // These child objects must be loaded completely before the parent custom obejct can be unserialized.
   // This implies: an order on the extension unserialization (and no cycles).
 
   // At the beginning, everything is yet to be loaded.
+  std::map<gd::String, size_t> extensionNameToElementIndex;
   std::vector<gd::String> remainingExtensionNames(
-      eventsFunctionsExtensions.size());
-  for (std::size_t i = 0; i < eventsFunctionsExtensions.size(); ++i) {
-    remainingExtensionNames[i] = eventsFunctionsExtensions.at(i)->GetName();
+      eventsFunctionsExtensionsElement.GetChildrenCount());
+  for (std::size_t i = 0; i < eventsFunctionsExtensionsElement.GetChildrenCount(); ++i) {
+    const SerializerElement& eventsFunctionsExtensionElement =
+        eventsFunctionsExtensionsElement.GetChild(i);
+    const gd::String& name = eventsFunctionsExtensionElement.GetStringAttribute("name");
+
+    remainingExtensionNames[i] = name;
+    extensionNameToElementIndex[name] = i;
   }
 
   // Helper allowing to find if an extension has an object that depends on
@@ -1021,10 +1037,10 @@ std::vector<gd::String> Project::GetUnserializingOrderExtensionNames(
     foundAnyExtension = false;
     for (std::size_t i = 0; i < remainingExtensionNames.size(); ++i) {
       auto extensionName = remainingExtensionNames[i];
-      size_t extensionIndex =
-          GetEventsFunctionsExtensionPosition(extensionName);
+
+      size_t elementIndex = extensionNameToElementIndex[extensionName];
       const SerializerElement &eventsFunctionsExtensionElement =
-          eventsFunctionsExtensionsElement.GetChild(extensionIndex);
+          eventsFunctionsExtensionsElement.GetChild(elementIndex);
 
       if (!isDependentFromRemainingExtensions(
               eventsFunctionsExtensionElement)) {
@@ -1075,7 +1091,6 @@ void Project::SerializeTo(SerializerElement& element) const {
       propElement.AddChild("platformSpecificAssets"));
   loadingScreen.SerializeTo(propElement.AddChild("loadingScreen"));
   watermark.SerializeTo(propElement.AddChild("watermark"));
-  propElement.SetAttribute("useExternalSourceFiles", useExternalSourceFiles);
 
   auto& authorIdsElement = propElement.AddChild("authorIds");
   authorIdsElement.ConsiderAsArray();
@@ -1163,13 +1178,6 @@ void Project::SerializeTo(SerializerElement& element) const {
   for (std::size_t i = 0; i < externalLayouts.size(); ++i)
     externalLayouts[i]->SerializeTo(
         externalLayoutsElement.AddChild("externalLayout"));
-
-  SerializerElement& externalSourceFilesElement =
-      element.AddChild("externalSourceFiles");
-  externalSourceFilesElement.ConsiderAsArrayOf("sourceFile");
-  for (std::size_t i = 0; i < externalSourceFiles.size(); ++i)
-    externalSourceFiles[i]->SerializeTo(
-        externalSourceFilesElement.AddChild("sourceFile"));
 }
 
 bool Project::IsNameSafe(const gd::String& name) {
@@ -1210,63 +1218,6 @@ gd::String Project::GetSafeName(const gd::String& name) {
   return newName;
 }
 
-bool Project::HasSourceFile(gd::String name, gd::String language) const {
-  vector<std::unique_ptr<SourceFile> >::const_iterator sourceFile =
-      find_if(externalSourceFiles.begin(),
-              externalSourceFiles.end(),
-              [&name](const std::unique_ptr<SourceFile>& sourceFile) {
-                return sourceFile->GetFileName() == name;
-              });
-
-  if (sourceFile == externalSourceFiles.end()) return false;
-
-  return language.empty() || (*sourceFile)->GetLanguage() == language;
-}
-
-gd::SourceFile& Project::GetSourceFile(const gd::String& name) {
-  return *(*find_if(externalSourceFiles.begin(),
-                    externalSourceFiles.end(),
-                    [&name](const std::unique_ptr<SourceFile>& sourceFile) {
-                      return sourceFile->GetFileName() == name;
-                    }));
-}
-
-const gd::SourceFile& Project::GetSourceFile(const gd::String& name) const {
-  return *(*find_if(externalSourceFiles.begin(),
-                    externalSourceFiles.end(),
-                    [&name](const std::unique_ptr<SourceFile>& sourceFile) {
-                      return sourceFile->GetFileName() == name;
-                    }));
-}
-
-void Project::RemoveSourceFile(const gd::String& name) {
-  std::vector<std::unique_ptr<gd::SourceFile> >::iterator sourceFile =
-      find_if(externalSourceFiles.begin(),
-              externalSourceFiles.end(),
-              [&name](const std::unique_ptr<SourceFile>& sourceFile) {
-                return sourceFile->GetFileName() == name;
-              });
-  if (sourceFile == externalSourceFiles.end()) return;
-
-  externalSourceFiles.erase(sourceFile);
-}
-
-gd::SourceFile& Project::InsertNewSourceFile(const gd::String& name,
-                                             const gd::String& language,
-                                             std::size_t position) {
-  if (HasSourceFile(name, language)) return GetSourceFile(name);
-
-  gd::SourceFile& newlyInsertedSourceFile = *(
-      *(externalSourceFiles.emplace(position < externalSourceFiles.size()
-                                        ? externalSourceFiles.begin() + position
-                                        : externalSourceFiles.end(),
-                                    new SourceFile())));
-  newlyInsertedSourceFile.SetLanguage(language);
-  newlyInsertedSourceFile.SetFileName(name);
-
-  return newlyInsertedSourceFile;
-}
-
 Project::Project(const Project &other)
     : objectsContainer(gd::ObjectsContainer::SourceType::Global) {
   Init(other);
@@ -1333,10 +1284,6 @@ void Project::Init(const gd::Project& game) {
   externalLayouts = gd::Clone(game.externalLayouts);
   eventsFunctionsExtensions = gd::Clone(game.eventsFunctionsExtensions);
 
-  useExternalSourceFiles = game.useExternalSourceFiles;
-
-  externalSourceFiles = gd::Clone(game.externalSourceFiles);
-
   variables = game.GetVariables();
 
   projectFile = game.GetProjectFile();

Core/GDCore/Project/Project.h

@@ -32,7 +32,6 @@ class Object;
 class ObjectConfiguration;
 class VariablesContainer;
 class ArbitraryResourceWorker;
-class SourceFile;
 class Behavior;
 class BehaviorsSharedData;
 class BaseEvent;
@@ -893,6 +892,16 @@ class GD_CORE_API Project {
       const EventsFunctionsExtension& eventsFunctionExtension,
       std::size_t position);
 
+  /**
+   * \brief Unserialize and insert in the project the extensions.
+   *
+   * Unserialization is done in two passe to allow dependencies between extensions.
+   *
+   * \note If an extension with the same name already exists, it will be overwritten.
+   */
+  void UnserializeAndInsertExtensionsFrom(
+      const gd::SerializerElement& eventsFunctionsExtensionsElement);
+
   /**
    * \brief Delete the events functions extension named "name".
    */
@@ -1009,60 +1018,22 @@ class GD_CORE_API Project {
   static gd::String GetSafeName(const gd::String& name);
   ///@}
 
-  /** \name External source files
-   * To manage external C++ or Javascript source files used by the game
-   */
-  ///@{
-  /**
-   * \brief Return true if the game activated the use of external source files.
-   */
-  bool UseExternalSourceFiles() const { return useExternalSourceFiles; }
-
-  /**
-   * \brief Return a const reference to the vector containing all the source
-   * files used by the game.
-   */
-  const std::vector<std::unique_ptr<gd::SourceFile> >& GetAllSourceFiles()
-      const {
-    return externalSourceFiles;
-  }
-
-  /**
-   * \brief Return true if the source file with the specified name is used by
-   * the game. \param name The filename of the source file. \param language
-   * Optional. If specified, check that the source file that exists is in this
-   * language.
-   */
-  bool HasSourceFile(gd::String name, gd::String language = "") const;
-
-  /**
-   * Return a reference to the external source file with the given name.
-   */
-  SourceFile& GetSourceFile(const gd::String& name);
-
-  /**
-   * Return a reference to the external source file with the given name.
-   */
-  const SourceFile& GetSourceFile(const gd::String& name) const;
-
-  /**
-   * Remove the specified source file.
-   */
-  void RemoveSourceFile(const gd::String& name);
-
-  /**
-   * Add a new source file the specified position in the external source files
-   * list.
-   */
-  gd::SourceFile& InsertNewSourceFile(const gd::String& name,
-                                      const gd::String& language,
-                                      std::size_t position = -1);
-  ///@}
-
   gd::WholeProjectDiagnosticReport& GetWholeProjectDiagnosticReport() {
     return wholeProjectDiagnosticReport;
   }
 
+  /**
+   * @brief Get the project extensions names in the order they have to be
+   * unserialized.
+   *
+   * Child-objects need the event-based objects they use to be loaded completely
+   * before they are unserialized.
+   *
+   * \warning This is only public to allow testing - don't use it in the editor.
+   */
+  static std::vector<gd::String> GetUnserializingOrderExtensionNames(
+      const gd::SerializerElement& eventsFunctionsExtensionsElement);
+
  private:
   /**
    * Initialize from another game. Used by copy-ctor and assign-op.
@@ -1070,14 +1041,6 @@ class GD_CORE_API Project {
    */
   void Init(const gd::Project& project);
 
-  /**
-   * @brief Get the project extensions names in the order they have to be unserialized.
-   *
-   * Child-objects need the event-based objects they use to be loaded completely
-   * before they are unserialized.
-   */
-  std::vector<gd::String> GetUnserializingOrderExtensionNames(const gd::SerializerElement &eventsFunctionsExtensionsElement);
-
   /**
    * Create an object configuration of the given type.
    *
@@ -1127,10 +1090,6 @@ class GD_CORE_API Project {
   std::vector<gd::Platform*>
       platforms;  ///< Pointers to the platforms this project supports.
   gd::String firstLayout;
-  bool useExternalSourceFiles =
-      false;  ///< True if game used external source files.
-  std::vector<std::unique_ptr<gd::SourceFile> >
-      externalSourceFiles;  ///< List of external source files used.
   gd::String author;        ///< Game author name, for publishing purpose.
   std::vector<gd::String>
       authorIds;  ///< Game author ids, from GDevelop users DB.

Core/GDCore/Project/ResourcesManager.cpp

@@ -97,6 +97,8 @@ std::shared_ptr<Resource> ResourcesManager::CreateResource(
     return std::make_shared<AtlasResource>();
   else if (kind == "spine")
     return std::make_shared<SpineResource>();
+  else if (kind == "javascript")
+    return std::make_shared<JavaScriptResource>();
 
   std::cout << "Bad resource created (type: " << kind << ")" << std::endl;
   return std::make_shared<Resource>();
@@ -767,6 +769,20 @@ void AtlasResource::SerializeTo(SerializerElement& element) const {
   element.SetAttribute("file", GetFile());
 }
 
+void JavaScriptResource::SetFile(const gd::String& newFile) {
+  file = NormalizePathSeparator(newFile);
+}
+
+void JavaScriptResource::UnserializeFrom(const SerializerElement& element) {
+  SetUserAdded(element.GetBoolAttribute("userAdded"));
+  SetFile(element.GetStringAttribute("file"));
+}
+
+void JavaScriptResource::SerializeTo(SerializerElement& element) const {
+  element.SetAttribute("userAdded", IsUserAdded());
+  element.SetAttribute("file", GetFile());
+}
+
 ResourceFolder::ResourceFolder(const ResourceFolder& other) { Init(other); }
 
 ResourceFolder& ResourceFolder::operator=(const ResourceFolder& other) {

Core/GDCore/Project/ResourcesManager.h

@@ -547,6 +547,32 @@ class GD_CORE_API AtlasResource : public Resource {
   gd::String file;
 };
 
+/**
+ * \brief Describe a video file used by a project.
+ *
+ * \see Resource
+ * \ingroup ResourcesManagement
+ */
+class GD_CORE_API JavaScriptResource : public Resource {
+ public:
+  JavaScriptResource() : Resource() { SetKind("javascript"); };
+  virtual ~JavaScriptResource(){};
+  virtual JavaScriptResource* Clone() const override {
+    return new JavaScriptResource(*this);
+  }
+
+  virtual const gd::String& GetFile() const override { return file; };
+  virtual void SetFile(const gd::String& newFile) override;
+
+  virtual bool UseFile() const override { return true; }
+  void SerializeTo(SerializerElement& element) const override;
+
+  void UnserializeFrom(const SerializerElement& element) override;
+
+ private:
+  gd::String file;
+};
+
 /**
  * \brief Inventory all resources used by a project
  *

Core/GDCore/Project/SourceFile.cpp

@@ -1,36 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-
-#if defined(GD_IDE_ONLY)
-#include "GDCore/Project/SourceFile.h"
-#include "GDCore/CommonTools.h"
-#include "GDCore/Serialization/SerializerElement.h"
-
-namespace gd {
-
-SourceFile::SourceFile() : gdManaged(false) {
-  // ctor
-}
-
-SourceFile::~SourceFile() {
-  // dtor
-}
-
-void SourceFile::SerializeTo(SerializerElement& element) const {
-  element.SetAttribute("filename", filename);
-  element.SetAttribute("language", language);
-  element.SetAttribute("gdManaged", gdManaged);
-}
-
-void SourceFile::UnserializeFrom(const SerializerElement& element) {
-  filename = element.GetStringAttribute("filename");
-  language = element.GetStringAttribute("language", "C++");
-  gdManaged = element.GetBoolAttribute("gdManaged");
-}
-
-}  // namespace gd
-
-#endif

Core/GDCore/Project/SourceFile.h

@@ -1,92 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-#ifndef SOURCEFILE_H
-#define SOURCEFILE_H
-#include <ctime>
-#include <memory>
-#include "GDCore/String.h"
-namespace gd {
-class SerializerElement;
-}
-class BaseEvent;
-
-namespace gd {
-
-/**
- * \brief Represents a "physical" source file.
- *
- * Source file can be compiled (or just integrated to the exported project)
- * by platforms. Most of the time, special events are provided to use functions
- * created in such files.
- */
-class GD_CORE_API SourceFile {
- public:
-  SourceFile();
-  virtual ~SourceFile();
-
-  /**
-   * \brief Return a pointer to a new SourceFile constructed from this one.
-   */
-  SourceFile* Clone() const { return new SourceFile(*this); };
-
-  /**
-   * \brief Get the filename
-   */
-  gd::String GetFileName() const { return filename; };
-
-  /**
-   * \brief Change the filename
-   */
-  void SetFileName(gd::String filename_) { filename = filename_; };
-
-  /**
-   * \brief Serialize the source file.
-   */
-  void SerializeTo(SerializerElement& element) const;
-
-  /**
-   * \brief Unserialize the source file.
-   */
-  void UnserializeFrom(const SerializerElement& element);
-
-  /**
-   * \brief Set if the file is hidden from the user point of view and is only
-   * managed by GDevelop
-   */
-  void SetGDManaged(bool gdManaged_) { gdManaged = gdManaged_; };
-
-  /**
-   * \brief Return true if the file is hidden from the user point of view and is
-   * only managed by GDevelop
-   */
-  bool IsGDManaged() const { return gdManaged; };
-
-  /**
-   * \brief Change the language of the source file
-   */
-  void SetLanguage(gd::String lang) { language = lang; }
-
-  /**
-   * \brief Get the language of the source file
-   */
-  const gd::String& GetLanguage() const { return language; }
-
- private:
-  gd::String filename;  ///< Filename
-  bool gdManaged;  ///< True if the source file is hidden from the user point of
-                   ///< view and is managed only by GDevelop.
-  gd::String language;  ///< String identifying the language of this source file
-                        ///< (typically "C++ or "Javascript").
-  std::weak_ptr<BaseEvent>
-      associatedGdEvent;  ///< When a source file is GD-managed, it is usually
-                          ///< created for a specific event. This member is not
-                          ///< saved: It is the event responsibility to call
-                          ///< SetAssociatedEvent.
-};
-
-}  // namespace gd
-
-#endif  // SOURCEFILE_H

Core/tests/DependenciesAnalyzer.cpp

@@ -32,7 +32,6 @@ TEST_CASE("DependenciesAnalyzer", "[common]") {
     REQUIRE(analyzer.GetScenesDependencies().find("Layout2") !=
             analyzer.GetScenesDependencies().end());
     REQUIRE(analyzer.GetExternalEventsDependencies().size() == 0);
-    REQUIRE(analyzer.GetSourceFilesDependencies().size() == 0);
   }
 
   SECTION("Can detect a simple external events dependency") {
@@ -55,7 +54,6 @@ TEST_CASE("DependenciesAnalyzer", "[common]") {
     REQUIRE(analyzer.GetExternalEventsDependencies().size() == 1);
     REQUIRE(analyzer.GetExternalEventsDependencies().find("ExternalEvents1") !=
             analyzer.GetExternalEventsDependencies().end());
-    REQUIRE(analyzer.GetSourceFilesDependencies().size() == 0);
   }
 
   SECTION("Can detect a transitive scene and external events dependency") {
@@ -87,7 +85,6 @@ TEST_CASE("DependenciesAnalyzer", "[common]") {
     REQUIRE(analyzer.GetExternalEventsDependencies().size() == 1);
     REQUIRE(analyzer.GetExternalEventsDependencies().find("ExternalEvents1") !=
             analyzer.GetExternalEventsDependencies().end());
-    REQUIRE(analyzer.GetSourceFilesDependencies().size() == 0);
   }
 
   SECTION("Can detect a (nested) circular dependency with scenes") {

Core/tests/DummyPlatform.cpp

@@ -340,8 +340,8 @@ void SetupProjectWithDummyPlatform(gd::Project& project,
                   "",
                   "",
                   "")
-      .AddParameter("object", _("Object 1 parameter"))
-      .AddParameter("object", _("Object 2 parameter"))
+      .AddParameter("object", "Object 1 parameter")
+      .AddParameter("object", "Object 2 parameter")
       .SetFunctionName("doSomethingWithObjects");
 
   extension

Core/tests/Project-GetUnserializingOrderExtensionNames.cpp

@@ -0,0 +1,312 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+/**
+ * @file Tests covering common features of GDevelop Core.
+ */
+#include <algorithm>
+
+#include "DummyPlatform.h"
+#include "GDCore/Extensions/Metadata/MetadataProvider.h"
+#include "GDCore/Extensions/Platform.h"
+#include "GDCore/Extensions/PlatformExtension.h"
+#include "GDCore/Project/Object.h"
+#include "GDCore/Project/Project.h"
+#include "GDCore/String.h"
+#include "catch.hpp"
+
+TEST_CASE("Project::GetUnserializingOrderExtensionNames", "[common]") {
+  SECTION("Unserialization order is correct when nothing to load") {
+    gd::SerializerElement emptyElement;
+
+    std::vector<gd::String> orderedNames =
+        gd::Project::GetUnserializingOrderExtensionNames(emptyElement);
+    REQUIRE(orderedNames.size() == 0);
+  }
+  SECTION("One extension with no dependencies") {
+    gd::SerializerElement extensionsElement = gd::Serializer::FromJSON(
+        R"([
+        {
+          "author": "",
+          "category": "Input",
+          "extensionNamespace": "",
+          "fullName": "3D character keyboard mapper",
+          "helpPath": "",
+          "iconUrl": "fake-icon-url",
+          "name": "Extension1",
+          "previewIconUrl": "fake-preview-icon-url",
+          "shortDescription": "3D platformer and 3D shooter keyboard controls.",
+          "version": "1.0.0",
+          "description": "3D platformer and 3D shooter keyboard controls.",
+          "tags": [],
+          "authorIds": [],
+          "dependencies": [],
+          "globalVariables": [],
+          "sceneVariables": [],
+          "eventsFunctions": [],
+          "eventsBasedBehaviors": [],
+          "eventsBasedObjects": []
+        }
+      ])");
+
+    std::vector<gd::String> orderedNames =
+        gd::Project::GetUnserializingOrderExtensionNames(extensionsElement);
+    REQUIRE(orderedNames.size() == 1);
+    REQUIRE(orderedNames[0] == "Extension1");
+  }
+
+  SECTION("One extension with a dependency outside the loaded extensions") {
+    gd::SerializerElement extensionsElement = gd::Serializer::FromJSON(
+        R"([
+        {
+          "author": "",
+          "category": "Input",
+          "extensionNamespace": "",
+          "fullName": "3D character keyboard mapper",
+          "helpPath": "",
+          "iconUrl": "fake-icon-url",
+          "name": "Extension1DependsOtherExtension",
+          "previewIconUrl": "fake-preview-icon-url",
+          "shortDescription": "3D platformer and 3D shooter keyboard controls.",
+          "version": "1.0.0",
+          "description": "3D platformer and 3D shooter keyboard controls.",
+          "tags": [],
+          "authorIds": [],
+          "dependencies": [],
+          "globalVariables": [],
+          "sceneVariables": [],
+          "eventsFunctions": [],
+          "eventsBasedBehaviors": [],
+          "eventsBasedObjects": [
+            {
+              "areaMaxX": 64,
+              "areaMaxY": 64,
+              "areaMaxZ": 64,
+              "areaMinX": 0,
+              "areaMinY": 0,
+              "areaMinZ": 0,
+              "defaultName": "Joystick",
+              "description": "Joystick for touchscreens.",
+              "fullName": "Multitouch Joystick",
+              "name": "SpriteMultitouchJoystick",
+              "eventsFunctions": [],
+              "propertyDescriptors": [],
+              "objects": [
+                {
+                  "name": "Thumb",
+                  "type": "OtherExtension::Whatever"
+                }
+              ],
+              "objectsFolderStructure": {
+                "folderName": "__ROOT",
+                "children": []
+              },
+              "objectsGroups": [],
+              "layers": [],
+              "instances": []
+            }
+          ]
+        }
+      ])");
+
+    std::vector<gd::String> orderedNames =
+        gd::Project::GetUnserializingOrderExtensionNames(extensionsElement);
+    REQUIRE(orderedNames.size() == 1);
+    REQUIRE(orderedNames[0] == "Extension1DependsOtherExtension");
+  }
+
+  SECTION("4 extensions with dependencies on each others") {
+    gd::SerializerElement extensionsElement = gd::Serializer::FromJSON(
+        R"([
+        {
+          "author": "",
+          "category": "Input",
+          "extensionNamespace": "",
+          "fullName": "3D character keyboard mapper",
+          "helpPath": "",
+          "iconUrl": "fake-icon-url",
+          "name": "Extension4DependsOn1And3",
+          "previewIconUrl": "fake-preview-icon-url",
+          "shortDescription": "3D platformer and 3D shooter keyboard controls.",
+          "version": "1.0.0",
+          "description": "3D platformer and 3D shooter keyboard controls.",
+          "tags": [],
+          "authorIds": [],
+          "dependencies": [],
+          "globalVariables": [],
+          "sceneVariables": [],
+          "eventsFunctions": [],
+          "eventsBasedBehaviors": [],
+          "eventsBasedObjects": [
+            {
+              "areaMaxX": 64,
+              "areaMaxY": 64,
+              "areaMaxZ": 64,
+              "areaMinX": 0,
+              "areaMinY": 0,
+              "areaMinZ": 0,
+              "defaultName": "Joystick",
+              "description": "Joystick for touchscreens.",
+              "fullName": "Multitouch Joystick",
+              "name": "SpriteMultitouchJoystick",
+              "eventsFunctions": [],
+              "propertyDescriptors": [],
+              "objects": [
+                {
+                  "name": "Thumb",
+                  "type": "OtherExtension::Whatever"
+                },
+                {
+                  "name": "Thumb2",
+                  "type": "Extension1DependsNothing::Whatever"
+                }
+              ],
+              "objectsFolderStructure": {
+                "folderName": "__ROOT",
+                "children": []
+              },
+              "objectsGroups": [],
+              "layers": [],
+              "instances": []
+            },
+            {
+              "areaMaxX": 64,
+              "areaMaxY": 64,
+              "areaMaxZ": 64,
+              "areaMinX": 0,
+              "areaMinY": 0,
+              "areaMinZ": 0,
+              "defaultName": "Joystick",
+              "description": "Joystick for touchscreens.",
+              "fullName": "Multitouch Joystick",
+              "name": "SpriteMultitouchJoystick",
+              "eventsFunctions": [],
+              "propertyDescriptors": [],
+              "objects": [
+                {
+                  "name": "Thumb",
+                  "type": "OtherExtension::Whatever"
+                },
+                {
+                  "name": "Thumb2",
+                  "type": "Extension3DependingOn2::Whatever"
+                }
+              ],
+              "objectsFolderStructure": {
+                "folderName": "__ROOT",
+                "children": []
+              },
+              "objectsGroups": [],
+              "layers": [],
+              "instances": []
+            }
+          ]
+        },
+        {
+          "author": "",
+          "category": "Input",
+          "extensionNamespace": "",
+          "fullName": "3D character keyboard mapper",
+          "helpPath": "",
+          "iconUrl": "fake-icon-url",
+          "name": "Extension3DependingOn2",
+          "previewIconUrl": "fake-preview-icon-url",
+          "shortDescription": "3D platformer and 3D shooter keyboard controls.",
+          "version": "1.0.0",
+          "description": "3D platformer and 3D shooter keyboard controls.",
+          "tags": [],
+          "authorIds": [],
+          "dependencies": [],
+          "globalVariables": [],
+          "sceneVariables": [],
+          "eventsFunctions": [],
+          "eventsBasedBehaviors": [],
+          "eventsBasedObjects": [
+            {
+              "areaMaxX": 64,
+              "areaMaxY": 64,
+              "areaMaxZ": 64,
+              "areaMinX": 0,
+              "areaMinY": 0,
+              "areaMinZ": 0,
+              "defaultName": "Joystick",
+              "description": "Joystick for touchscreens.",
+              "fullName": "Multitouch Joystick",
+              "name": "SpriteMultitouchJoystick",
+              "eventsFunctions": [],
+              "propertyDescriptors": [],
+              "objects": [
+                {
+                  "name": "Thumb",
+                  "type": "OtherExtension::Whatever"
+                },
+                {
+                  "name": "Thumb2",
+                  "type": "Extension2DependsNothing::Whatever"
+                }
+              ],
+              "objectsFolderStructure": {
+                "folderName": "__ROOT",
+                "children": []
+              },
+              "objectsGroups": [],
+              "layers": [],
+              "instances": []
+            }
+          ]
+        },
+        {
+          "author": "",
+          "category": "Input",
+          "extensionNamespace": "",
+          "fullName": "3D character keyboard mapper",
+          "helpPath": "",
+          "iconUrl": "fake-icon-url",
+          "name": "Extension2DependsNothing",
+          "previewIconUrl": "fake-preview-icon-url",
+          "shortDescription": "3D platformer and 3D shooter keyboard controls.",
+          "version": "1.0.0",
+          "description": "3D platformer and 3D shooter keyboard controls.",
+          "tags": [],
+          "authorIds": [],
+          "dependencies": [],
+          "globalVariables": [],
+          "sceneVariables": [],
+          "eventsFunctions": [],
+          "eventsBasedBehaviors": [],
+          "eventsBasedObjects": []
+        },
+        {
+          "author": "",
+          "category": "Input",
+          "extensionNamespace": "",
+          "fullName": "3D character keyboard mapper",
+          "helpPath": "",
+          "iconUrl": "fake-icon-url",
+          "name": "Extension1DependsNothing",
+          "previewIconUrl": "fake-preview-icon-url",
+          "shortDescription": "3D platformer and 3D shooter keyboard controls.",
+          "version": "1.0.0",
+          "description": "3D platformer and 3D shooter keyboard controls.",
+          "tags": [],
+          "authorIds": [],
+          "dependencies": [],
+          "globalVariables": [],
+          "sceneVariables": [],
+          "eventsFunctions": [],
+          "eventsBasedBehaviors": [],
+          "eventsBasedObjects": []
+        }
+      ])");
+
+    std::vector<gd::String> orderedNames =
+        gd::Project::GetUnserializingOrderExtensionNames(extensionsElement);
+    REQUIRE(orderedNames.size() == 4);
+    REQUIRE(orderedNames[0] == "Extension2DependsNothing");
+    REQUIRE(orderedNames[1] == "Extension1DependsNothing");
+    REQUIRE(orderedNames[2] == "Extension3DependingOn2");
+    REQUIRE(orderedNames[3] == "Extension4DependsOn1And3");
+  }
+}

Core/tests/SourceFiles.cpp

@@ -1,30 +0,0 @@
-/*
- * GDevelop Core
- * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
- * reserved. This project is released under the MIT License.
- */
-/**
- * @file Tests covering common features of GDevelop Core.
- */
-#include "GDCore/CommonTools.h"
-#include "GDCore/Project/Project.h"
-#include "GDCore/Project/SourceFile.h"
-#include "catch.hpp"
-
-TEST_CASE("SourceFile", "[common]") {
-  SECTION("Basics") {
-    gd::Project project;
-    project.InsertNewSourceFile("test.cpp", "C++");
-    project.InsertNewSourceFile("test.js", "Javascript");
-    REQUIRE(project.HasSourceFile("test.cpp", "C++") == true);
-    REQUIRE(project.HasSourceFile("test.cpp", "JS") == false);
-    REQUIRE(project.HasSourceFile("test.cpp") == true);
-    gd::SourceFile& cppSourceFile = project.GetSourceFile("test.cpp");
-    REQUIRE(cppSourceFile.GetFileName() == "test.cpp");
-    REQUIRE(cppSourceFile.GetLanguage() == "C++");
-
-    project.RemoveSourceFile("test.cpp");
-    REQUIRE(project.HasSourceFile("test.cpp") == false);
-    REQUIRE(project.HasSourceFile("test.js") == true);
-  }
-}

Core/tests/WholeProjectRefactorer.cpp

@@ -91,6 +91,37 @@ CreateInstructionWithNumberParameter(gd::Project &project,
   return event.GetActions().Insert(instruction);
 }
 
+const gd::Instruction &
+CreateInstructionWithObjectParameter(gd::Project &project,
+                                     gd::EventsList &events,
+                                     const gd::String &objectName) {
+  gd::StandardEvent &event = dynamic_cast<gd::StandardEvent &>(
+      events.InsertNewEvent(project, "BuiltinCommonInstructions::Standard"));
+
+  gd::Instruction instruction;
+  instruction.SetType("MyExtension::DoSomethingWithObjects");
+  instruction.SetParametersCount(2);
+  instruction.SetParameter(0, objectName);
+  instruction.SetParameter(1, "");
+  return event.GetActions().Insert(instruction);
+}
+
+const gd::Instruction &
+CreateInstructionWithBehaviorParameter(gd::Project &project,
+                                     gd::EventsList &events,
+                                     const gd::String &objectName,
+                                     const gd::String &behaviorName) {
+  gd::StandardEvent &event = dynamic_cast<gd::StandardEvent &>(
+      events.InsertNewEvent(project, "BuiltinCommonInstructions::Standard"));
+
+  gd::Instruction instruction;
+  instruction.SetType("MyExtension::BehaviorDoSomething");
+  instruction.SetParametersCount(2);
+  instruction.SetParameter(0, objectName);
+  instruction.SetParameter(1, behaviorName);
+  return event.GetActions().Insert(instruction);
+}
+
 const gd::Instruction &
 CreateInstructionWithVariableParameter(gd::Project &project,
                                      gd::EventsList &events,
@@ -1461,7 +1492,7 @@ TEST_CASE("WholeProjectRefactorer", "[common]") {
 
       auto &layout = project.GetLayout("Scene");
 
-      // Trigger the refactoring after the renaming of an object
+      // Trigger the refactoring before the renaming of an object
       gd::WholeProjectRefactorer::ObjectOrGroupRenamedInScene(
           project, layout, "ObjectWithMyBehavior",
           "RenamedObjectWithMyBehavior",
@@ -1489,7 +1520,7 @@ TEST_CASE("WholeProjectRefactorer", "[common]") {
 
       auto &layout = project.GetLayout("Scene");
 
-      // Trigger the refactoring after the renaming of a group
+      // Trigger the refactoring before the renaming of a group
       gd::WholeProjectRefactorer::ObjectOrGroupRenamedInScene(
           project, layout, "GroupWithMyBehavior", "RenamedGroupWithMyBehavior",
           /* isObjectGroup=*/true);
@@ -1568,10 +1599,10 @@ TEST_CASE("WholeProjectRefactorer", "[common]") {
               project, eventsExtension, eventsFunction,
               parametersObjectsContainer);
 
-      // Trigger the refactoring after the renaming of an object
+      // Trigger the refactoring before the renaming of an object
       gd::WholeProjectRefactorer::ObjectOrGroupRenamedInEventsFunction(
           project, projectScopedContainers, eventsFunction,
-          "Object1", "RenamedObject1",
+          parametersObjectsContainer, "Object1", "RenamedObject1",
           /* isObjectGroup=*/false);
 
       REQUIRE(objectGroup.Find("Object1") == false);
@@ -1603,10 +1634,11 @@ TEST_CASE("WholeProjectRefactorer", "[common]") {
       objectWithMyBehavior.GetVariables().InsertNew("MyVariable");
       objectWithMyBehavior.GetVariables().InsertNew("MyStructureVariable").CastTo(gd::Variable::Structure);
 
-      // Trigger the refactoring after the renaming of an object
+      // Trigger the refactoring before the renaming of an object
       gd::WholeProjectRefactorer::ObjectOrGroupRenamedInEventsFunction(
           project, projectScopedContainers, eventsFunction,
-          "ObjectWithMyBehavior", "RenamedObjectWithMyBehavior",
+          parametersObjectsContainer, "ObjectWithMyBehavior",
+          "RenamedObjectWithMyBehavior",
           /* isObjectGroup=*/false);
 
       // Check object name has been renamed in action parameters.
@@ -1722,7 +1754,7 @@ TEST_CASE("WholeProjectRefactorer", "[common]") {
               project, eventsExtension, eventsBasedObject,
               parametersObjectsContainer);
 
-      // Trigger the refactoring after the renaming of an object
+      // Trigger the refactoring before the renaming of an object
       gd::WholeProjectRefactorer::ObjectOrGroupRenamedInEventsBasedObject(
           project, projectScopedContainers, eventsBasedObject,
           "ObjectWithMyBehavior", "RenamedObjectWithMyBehavior",
@@ -2241,7 +2273,7 @@ TEST_CASE("WholeProjectRefactorer", "[common]") {
                 .GetObjectType() == "MyRenamedExtension::MyEventsBasedObject");
   }
 
-  SECTION("(Free) events action renamed") {
+  SECTION("(Free function) events action renamed") {
     gd::Project project;
     gd::Platform platform;
     SetupProjectWithDummyPlatform(project, platform);
@@ -2259,7 +2291,7 @@ TEST_CASE("WholeProjectRefactorer", "[common]") {
     }
   }
 
-  SECTION("(Free) events expression renamed") {
+  SECTION("(Free function) events expression renamed") {
     gd::Project project;
     gd::Platform platform;
     SetupProjectWithDummyPlatform(project, platform);
@@ -2277,7 +2309,7 @@ TEST_CASE("WholeProjectRefactorer", "[common]") {
     }
   }
 
-  SECTION("(Free) events expression and condition renamed") {
+  SECTION("(Free function) events expression and condition renamed") {
     gd::Project project;
     gd::Platform platform;
     SetupProjectWithDummyPlatform(project, platform);
@@ -2306,7 +2338,239 @@ TEST_CASE("WholeProjectRefactorer", "[common]") {
     }
   }
 
-  SECTION("(Free) events action parameter moved") {
+  SECTION("(Free function) number parameter renamed (in expressions)") {
+    gd::Project project;
+    gd::Platform platform;
+    SetupProjectWithDummyPlatform(project, platform);
+    auto &eventsExtension = SetupProjectWithEventsFunctionExtension(project);
+
+    auto &eventsFunction =
+        eventsExtension.InsertNewEventsFunction("MyFreeEventsFunction", 0);
+    eventsFunction.GetParameters()
+        .AddNewParameter("MyParameter")
+        .GetValueTypeMetadata()
+        .SetName("number");
+    auto &instruction = CreateInstructionWithNumberParameter(
+        project, eventsFunction.GetEvents(), "MyParameter");
+    auto &instruction2 = CreateInstructionWithNumberParameter(
+        project, eventsFunction.GetEvents(),
+        "MyExtension::GetVariableAsNumber(MyVariable.MyChild[MyParameter])");
+
+    gd::ObjectsContainer parametersObjectsContainer(
+        gd::ObjectsContainer::SourceType::Function);
+    auto projectScopedContainers = gd::ProjectScopedContainers::
+        MakeNewProjectScopedContainersForFreeEventsFunction(
+            project, eventsExtension, eventsFunction,
+            parametersObjectsContainer);
+    gd::WholeProjectRefactorer::RenameParameter(
+        project, projectScopedContainers, eventsFunction,
+        parametersObjectsContainer, "MyParameter", "MyRenamedParameter");
+
+    REQUIRE(instruction.GetParameter(0).GetPlainString() ==
+            "MyRenamedParameter");
+    REQUIRE(instruction2.GetParameter(0).GetPlainString() ==
+            "MyExtension::GetVariableAsNumber(MyVariable.MyChild[MyRenamedParameter])");
+  }
+
+  SECTION("(Free function) number parameter not renamed (in variable parameter)") {
+    gd::Project project;
+    gd::Platform platform;
+    SetupProjectWithDummyPlatform(project, platform);
+    auto &eventsExtension = SetupProjectWithEventsFunctionExtension(project);
+
+    auto &eventsFunction =
+        eventsExtension.InsertNewEventsFunction("MyFreeEventsFunction", 0);
+    eventsFunction.GetParameters()
+        .AddNewParameter("MyParameter")
+        .GetValueTypeMetadata()
+        .SetName("number");
+    // Parameters can't actually be used in "variable" parameters.
+    auto &instruction = CreateInstructionWithVariableParameter(
+        project, eventsFunction.GetEvents(), "MyParameter");
+    auto &instruction2 = CreateInstructionWithNumberParameter(
+        project, eventsFunction.GetEvents(),
+        "MyExtension::GetVariableAsNumber(MyParameter)");
+
+    gd::ObjectsContainer parametersObjectsContainer(
+        gd::ObjectsContainer::SourceType::Function);
+    auto projectScopedContainers = gd::ProjectScopedContainers::
+        MakeNewProjectScopedContainersForFreeEventsFunction(
+            project, eventsExtension, eventsFunction,
+            parametersObjectsContainer);
+    gd::WholeProjectRefactorer::RenameParameter(
+        project, projectScopedContainers, eventsFunction,
+        parametersObjectsContainer, "MyParameter", "MyRenamedParameter");
+
+    // "variable" parameters are left untouched.
+    REQUIRE(instruction.GetParameter(0).GetPlainString() ==
+            "MyParameter");
+    REQUIRE(instruction2.GetParameter(0).GetPlainString() ==
+            "MyExtension::GetVariableAsNumber(MyParameter)");
+  }
+
+  SECTION("(Free function) object parameter renamed (in expressions)") {
+    gd::Project project;
+    gd::Platform platform;
+    SetupProjectWithDummyPlatform(project, platform);
+    auto &eventsExtension = SetupProjectWithEventsFunctionExtension(project);
+
+    auto &eventsFunction =
+        eventsExtension.InsertNewEventsFunction("MyFreeEventsFunction", 0);
+    eventsFunction.GetParameters()
+        .AddNewParameter("MyObject")
+        .GetValueTypeMetadata()
+        .SetName("objectList")
+        .SetExtraInfo("MyExtension::Sprite");
+    auto &instruction = CreateInstructionWithObjectParameter(
+        project, eventsFunction.GetEvents(), "MyObject");
+    auto &instruction2 = CreateInstructionWithNumberParameter(
+        project, eventsFunction.GetEvents(), "MyObject.GetObjectStringWith1Param(0)");
+    auto &instruction3 = CreateInstructionWithNumberParameter(
+        project, eventsFunction.GetEvents(),
+        "MyExtension::GetVariableAsNumber(MyVariable.MyChild[MyObject.GetObjectStringWith1Param(0)])");
+
+    gd::ObjectsContainer parametersObjectsContainer(
+        gd::ObjectsContainer::SourceType::Function);
+    auto projectScopedContainers = gd::ProjectScopedContainers::
+        MakeNewProjectScopedContainersForFreeEventsFunction(
+            project, eventsExtension, eventsFunction,
+            parametersObjectsContainer);
+    gd::WholeProjectRefactorer::RenameParameter(
+        project, projectScopedContainers, eventsFunction,
+        parametersObjectsContainer, "MyObject", "MyRenamedObject");
+
+    REQUIRE(instruction.GetParameter(0).GetPlainString() ==
+            "MyRenamedObject");
+    REQUIRE(instruction2.GetParameter(0).GetPlainString() ==
+            "MyRenamedObject.GetObjectStringWith1Param(0)");
+    REQUIRE(instruction3.GetParameter(0).GetPlainString() ==
+            "MyExtension::GetVariableAsNumber(MyVariable.MyChild[MyRenamedObject.GetObjectStringWith1Param(0)])");
+  }
+
+  SECTION("(Free function) object parameter not renamed (in variable parameter)") {
+    gd::Project project;
+    gd::Platform platform;
+    SetupProjectWithDummyPlatform(project, platform);
+    auto &eventsExtension = SetupProjectWithEventsFunctionExtension(project);
+
+    auto &eventsFunction =
+        eventsExtension.InsertNewEventsFunction("MyFreeEventsFunction", 0);
+    eventsFunction.GetParameters()
+        .AddNewParameter("MyObject")
+        .GetValueTypeMetadata()
+        .SetName("objectList")
+        .SetExtraInfo("MyExtension::Sprite");
+    // Parameters can't actually be used in "variable" parameters.
+    auto &instruction = CreateInstructionWithVariableParameter(
+        project, eventsFunction.GetEvents(), "MyObject");
+    auto &instruction2 = CreateInstructionWithNumberParameter(
+        project, eventsFunction.GetEvents(),
+        "MyExtension::GetVariableAsNumber(MyObject)");
+
+    gd::ObjectsContainer parametersObjectsContainer(
+        gd::ObjectsContainer::SourceType::Function);
+    auto projectScopedContainers = gd::ProjectScopedContainers::
+        MakeNewProjectScopedContainersForFreeEventsFunction(
+            project, eventsExtension, eventsFunction,
+            parametersObjectsContainer);
+    gd::WholeProjectRefactorer::RenameParameter(
+        project, projectScopedContainers, eventsFunction,
+        parametersObjectsContainer, "MyObject", "MyRenamedObject");
+
+    // "variable" parameters are left untouched.
+    REQUIRE(instruction.GetParameter(0).GetPlainString() ==
+            "MyObject");
+    REQUIRE(instruction2.GetParameter(0).GetPlainString() ==
+            "MyExtension::GetVariableAsNumber(MyObject)");
+  }
+
+  SECTION("(Free function) behavior parameter renamed (in expressions)") {
+    gd::Project project;
+    gd::Platform platform;
+    SetupProjectWithDummyPlatform(project, platform);
+    auto &eventsExtension = SetupProjectWithEventsFunctionExtension(project);
+
+    auto &eventsFunction =
+        eventsExtension.InsertNewEventsFunction("MyFreeEventsFunction", 0);
+    eventsFunction.GetParameters()
+        .AddNewParameter("MyObject")
+        .GetValueTypeMetadata()
+        .SetName("objectList")
+        .SetExtraInfo("MyExtension::Sprite");
+    eventsFunction.GetParameters()
+        .AddNewParameter("MyBehavior")
+        .GetValueTypeMetadata()
+        .SetName("behavior")
+        .SetExtraInfo("MyExtension::MyBehavior");
+    auto &instruction = CreateInstructionWithBehaviorParameter(
+        project, eventsFunction.GetEvents(), "MyObject", "MyBehavior");
+    auto &instruction2 = CreateInstructionWithNumberParameter(
+        project, eventsFunction.GetEvents(), "MyObject.MyBehavior::GetBehaviorStringWith1Param(0)");
+    auto &instruction3 = CreateInstructionWithNumberParameter(
+        project, eventsFunction.GetEvents(),
+        "MyExtension::GetVariableAsNumber(MyVariable.MyChild[MyObject.MyBehavior::GetBehaviorStringWith1Param(0)])");
+
+    gd::ObjectsContainer parametersObjectsContainer(
+        gd::ObjectsContainer::SourceType::Function);
+    auto projectScopedContainers = gd::ProjectScopedContainers::
+        MakeNewProjectScopedContainersForFreeEventsFunction(
+            project, eventsExtension, eventsFunction,
+            parametersObjectsContainer);
+    gd::WholeProjectRefactorer::RenameParameter(
+        project, projectScopedContainers, eventsFunction,
+        parametersObjectsContainer, "MyBehavior", "MyRenamedBehavior");
+
+    REQUIRE(instruction.GetParameter(1).GetPlainString() ==
+            "MyRenamedBehavior");
+    REQUIRE(instruction2.GetParameter(0).GetPlainString() ==
+            "MyObject.MyRenamedBehavior::GetBehaviorStringWith1Param(0)");
+    REQUIRE(instruction3.GetParameter(0).GetPlainString() ==
+            "MyExtension::GetVariableAsNumber(MyVariable.MyChild[MyObject.MyRenamedBehavior::GetBehaviorStringWith1Param(0)])");
+  }
+
+  SECTION("(Free function) behavior parameter not renamed (in variable parameter)") {
+    gd::Project project;
+    gd::Platform platform;
+    SetupProjectWithDummyPlatform(project, platform);
+    auto &eventsExtension = SetupProjectWithEventsFunctionExtension(project);
+
+    auto &eventsFunction =
+        eventsExtension.InsertNewEventsFunction("MyFreeEventsFunction", 0);
+    eventsFunction.GetParameters()
+        .AddNewParameter("MyObject")
+        .GetValueTypeMetadata()
+        .SetName("objectList")
+        .SetExtraInfo("MyExtension::Sprite");
+    eventsFunction.GetParameters()
+        .AddNewParameter("MyBehavior")
+        .GetValueTypeMetadata()
+        .SetName("behavior")
+        .SetExtraInfo("MyExtension::MyBehavior");
+    // Parameters can't actually be used in "variable" parameters.
+    auto &instruction = CreateInstructionWithVariableParameter(
+        project, eventsFunction.GetEvents(), "MyBehavior");
+    auto &instruction2 = CreateInstructionWithNumberParameter(
+        project, eventsFunction.GetEvents(),
+        "MyExtension::GetVariableAsNumber(MyBehavior)");
+
+    gd::ObjectsContainer parametersObjectsContainer(
+        gd::ObjectsContainer::SourceType::Function);
+    auto projectScopedContainers = gd::ProjectScopedContainers::
+        MakeNewProjectScopedContainersForFreeEventsFunction(
+            project, eventsExtension, eventsFunction,
+            parametersObjectsContainer);
+    gd::WholeProjectRefactorer::RenameParameter(
+        project, projectScopedContainers, eventsFunction,
+        parametersObjectsContainer, "MyBehavior", "MyRenamedBehavior");
+
+    // "variable" parameters are left untouched.
+    REQUIRE(instruction.GetParameter(0).GetPlainString() ==
+            "MyBehavior");
+    REQUIRE(instruction2.GetParameter(0).GetPlainString() ==
+            "MyExtension::GetVariableAsNumber(MyBehavior)");
+  }
+
+  SECTION("(Free function) events action parameter moved") {
     gd::Project project;
     gd::Platform platform;
     SetupProjectWithDummyPlatform(project, platform);
@@ -2328,7 +2592,7 @@ TEST_CASE("WholeProjectRefactorer", "[common]") {
     }
   }
 
-  SECTION("(Free) events expression parameter moved") {
+  SECTION("(Free function) events expression parameter moved") {
     gd::Project project;
     gd::Platform platform;
     SetupProjectWithDummyPlatform(project, platform);
@@ -2346,7 +2610,7 @@ TEST_CASE("WholeProjectRefactorer", "[common]") {
     }
   }
 
-  SECTION("(Free) events expression and condition parameter moved") {
+  SECTION("(Free function) events expression and condition parameter moved") {
     gd::Project project;
     gd::Platform platform;
     SetupProjectWithDummyPlatform(project, platform);

Extensions/DialogueTree/bondage.js/dist/bondage.d.ts

@@ -0,0 +1,39 @@
+declare namespace bondage {
+  export class Runner {
+    yarnNodes: any;
+    variables: any;
+    functions: any;
+    visited: any;
+    load(data: any[]): void;
+    setVariableStorage(storage: any): void;
+    registerFunction(name: string, func): void;
+    run(startNode: string): any;
+    evalNodes(nodes: any[], yarnNodeData: any): any;
+    handleSelections(selections: any[]): any;
+    evaluateAssignment(node: any): any;
+    evaluateConditional(node: any): any;
+    evaluateExpressionOrLiteral(node): any;
+  }
+
+  export class Result {}
+
+  export class TextResult extends Result {
+    text: string;
+    data: any;
+    lineNum: number;
+  }
+
+  export class CommandResult extends Result {
+    text: string;
+    data: any;
+    lineNum: number;
+  }
+
+  export class OptionsResult extends Result {
+    options: string[];
+    lineNum: number[];
+    selected: number;
+
+    select(index: number): void;
+  }
+}

Extensions/Physics2Behavior/JsExtension.js

@@ -340,7 +340,8 @@ module.exports = {
           _(
             'The friction applied when touching other objects. The higher the value, the more friction.'
           )
-        );
+        )
+        .setGroup(_('Movement'));
       behaviorProperties
         .getOrCreate('restitution')
         .setValue(
@@ -352,7 +353,8 @@ module.exports = {
           _(
             'The "bounciness" of the object. The higher the value, the more other objects will bounce against it.'
           )
-        );
+        )
+        .setGroup(_('Movement'));
       behaviorProperties
         .getOrCreate('linearDamping')
         .setValue(
@@ -695,7 +697,7 @@ module.exports = {
       .addCondition(
         'IsDynamic',
         _('Is dynamic'),
-        _('Test if an object is dynamic.'),
+        _('Check if an object is dynamic.'),
         _('_PARAM0_ is dynamic'),
         _('Dynamics'),
         'res/physics32.png',
@@ -727,7 +729,7 @@ module.exports = {
       .addCondition(
         'IsStatic',
         _('Is static'),
-        _('Test if an object is static.'),
+        _('Check if an object is static.'),
         _('_PARAM0_ is static'),
         _('Dynamics'),
         'res/physics32.png',
@@ -759,7 +761,7 @@ module.exports = {
       .addCondition(
         'IsKinematic',
         _('Is kinematic'),
-        _('Test if an object is kinematic.'),
+        _('Check if an object is kinematic.'),
         _('_PARAM0_ is kinematic'),
         _('Dynamics'),
         'res/physics32.png',
@@ -790,9 +792,9 @@ module.exports = {
     aut
       .addCondition(
         'IsBullet',
-        _('Is treat as bullet'),
-        _('Test if an object is being treat as a bullet.'),
-        _('_PARAM0_ is bullet'),
+        _('Is treated as a bullet'),
+        _('Check if the object is being treated as a bullet.'),
+        _('_PARAM0_ is treated as a bullet'),
         _('Dynamics'),
         'res/physics32.png',
         'res/physics32.png'
@@ -825,7 +827,7 @@ module.exports = {
       .addCondition(
         'HasFixedRotation',
         _('Has fixed rotation'),
-        _('Test if an object has fixed rotation.'),
+        _('Check if an object has fixed rotation.'),
         _('_PARAM0_ has fixed rotation'),
         _('Dynamics'),
         'res/physics32.png',
@@ -859,7 +861,7 @@ module.exports = {
       .addCondition(
         'IsSleepingAllowed',
         _('Is sleeping allowed'),
-        _('Test if an object can sleep.'),
+        _('Check if an object can sleep.'),
         _('_PARAM0_ can sleep'),
         _('Dynamics'),
         'res/physics32.png',
@@ -898,7 +900,7 @@ module.exports = {
       .addCondition(
         'IsSleeping',
         _('Is sleeping'),
-        _('Test if an object is sleeping.'),
+        _('Check if an object is sleeping.'),
         _('_PARAM0_ is sleeping'),
         _('Dynamics'),
         'res/physics32.png',
@@ -1267,7 +1269,7 @@ module.exports = {
       .addCondition(
         'LayerEnabled',
         _('Layer enabled'),
-        _('Test if an object has a specific layer enabled.'),
+        _('Check if an object has a specific layer enabled.'),
         _('_PARAM0_ has layer _PARAM2_ enabled'),
         _('Filtering'),
         'res/physics32.png',
@@ -1303,7 +1305,7 @@ module.exports = {
       .addCondition(
         'MaskEnabled',
         _('Mask enabled'),
-        _('Test if an object has a specific mask enabled.'),
+        _('Check if an object has a specific mask enabled.'),
         _('_PARAM0_ has mask _PARAM2_ enabled'),
         _('Filtering'),
         'res/physics32.png',
@@ -1897,7 +1899,7 @@ module.exports = {
       .addCondition(
         'JointFirstObject',
         _('Joint first object'),
-        _('Test if an object is the first object on a joint.'),
+        _('Check if an object is the first object on a joint.'),
         _('_PARAM0_ is the first object for joint _PARAM2_'),
         _('Joints'),
         'res/physics32.png',
@@ -1913,7 +1915,7 @@ module.exports = {
       .addCondition(
         'JointSecondObject',
         _('Joint second object'),
-        _('Test if an object is the second object on a joint.'),
+        _('Check if an object is the second object on a joint.'),
         _('_PARAM0_ is the second object for joint _PARAM2_'),
         _('Joints'),
         'res/physics32.png',
@@ -2382,7 +2384,7 @@ module.exports = {
       .addCondition(
         'RevoluteJointLimitsEnabled',
         _('Revolute joint limits enabled'),
-        _('Test if a revolute joint limits are enabled.'),
+        _('Check if a revolute joint limits are enabled.'),
         _('Limits for revolute joint _PARAM2_ are enabled'),
         _('Joints/Revolute'),
         'JsPlatform/Extensions/revolute_joint24.png',
@@ -2461,7 +2463,7 @@ module.exports = {
       .addCondition(
         'RevoluteJointMotorEnabled',
         _('Revolute joint motor enabled'),
-        _('Test if a revolute joint motor is enabled.'),
+        _('Check if a revolute joint motor is enabled.'),
         _('Motor of revolute joint _PARAM2_ is enabled'),
         _('Joints/Revolute'),
         'JsPlatform/Extensions/revolute_joint24.png',
@@ -2700,7 +2702,7 @@ module.exports = {
       .addCondition(
         'PrismaticJointLimitsEnabled',
         _('Prismatic joint limits enabled'),
-        _('Test if a prismatic joint limits are enabled.'),
+        _('Check if a prismatic joint limits are enabled.'),
         _('Limits for prismatic joint _PARAM2_ are enabled'),
         _('Joints/Prismatic'),
         'JsPlatform/Extensions/prismatic_joint24.png',
@@ -2779,7 +2781,7 @@ module.exports = {
       .addCondition(
         'PrismaticJointMotorEnabled',
         _('Prismatic joint motor enabled'),
-        _('Test if a prismatic joint motor is enabled.'),
+        _('Check if a prismatic joint motor is enabled.'),
         _('Motor for prismatic joint _PARAM2_ is enabled'),
         _('Joints/Prismatic'),
         'JsPlatform/Extensions/prismatic_joint24.png',
@@ -3459,7 +3461,7 @@ module.exports = {
       .addCondition(
         'WheelJointMotorEnabled',
         _('Wheel joint motor enabled'),
-        _('Test if a wheel joint motor is enabled.'),
+        _('Check if a wheel joint motor is enabled.'),
         _('Motor for wheel joint _PARAM2_ is enabled'),
         _('Joints/Wheel'),
         'JsPlatform/Extensions/wheel_joint24.png',
@@ -4203,7 +4205,7 @@ module.exports = {
       .getCodeExtraInformation()
       .addIncludeFile('Extensions/Physics2Behavior/physics2tools.js')
       .addIncludeFile('Extensions/Physics2Behavior/physics2runtimebehavior.js')
-      .setFunctionName('gdjs.physics2.objectsCollide');
+      .setFunctionName('gdjs.physics2.areObjectsColliding');
 
     extension
       .addCondition(

Extensions/Physics2Behavior/physics2runtimebehavior.ts

@@ -960,10 +960,10 @@ namespace gdjs {
 
     updateObjectFromBody() {
       // Copy transform from body to the GD object.
-      // It's possible the behavior was either deactivated or the object deleted
-      // just before this doStepPreEvents (for example, another behavior deleted
-      // the object during its own doStepPreEvents). If the body is null, we just
-      // don't do anything (but still run the physics simulation - this is independent).
+      // The body is null when the behavior was either deactivated or the object deleted.
+      // It would be useless to try to recreate it as updateBodyFromObject already does it.
+      // If the body is null, we just don't do anything
+      // (but still run the physics simulation - this is independent).
       if (this._body !== null) {
         this.owner.setX(
           this._body.GetPosition().get_x() * this._sharedData.worldScale -

Extensions/Physics2Behavior/physics2tools.ts

@@ -1,6 +1,6 @@
 namespace gdjs {
   export namespace physics2 {
-    export const objectsCollide = function (
+    export const areObjectsColliding = function (
       objectsLists1: Hashtable<Array<gdjs.RuntimeObject>>,
       behaviorName: string,
       objectsLists2: Hashtable<Array<gdjs.RuntimeObject>>,

Extensions/Physics3DBehavior/Physics3DTools.ts

@@ -0,0 +1,90 @@
+namespace gdjs {
+  export namespace physics3d {
+    export const areObjectsColliding = function (
+      objectsLists1: Hashtable<Array<gdjs.RuntimeObject>>,
+      behaviorName: string,
+      objectsLists2: Hashtable<Array<gdjs.RuntimeObject>>,
+      behaviorName2: string,
+      inverted: boolean
+    ) {
+      return gdjs.evtTools.object.twoListsTest(
+        gdjs.Physics3DRuntimeBehavior.areObjectsColliding,
+        objectsLists1,
+        objectsLists2,
+        inverted,
+        behaviorName
+      );
+    };
+
+    export const haveObjectsStartedColliding = function (
+      objectsLists1: Hashtable<Array<gdjs.RuntimeObject>>,
+      behaviorName: string,
+      objectsLists2: Hashtable<Array<gdjs.RuntimeObject>>,
+      behaviorName2: string,
+      inverted: boolean
+    ) {
+      return gdjs.evtTools.object.twoListsTest(
+        gdjs.Physics3DRuntimeBehavior.hasCollisionStartedBetween,
+        objectsLists1,
+        objectsLists2,
+        inverted,
+        behaviorName
+      );
+    };
+
+    export const haveObjectsStoppedColliding = function (
+      objectsLists1: Hashtable<Array<gdjs.RuntimeObject>>,
+      behaviorName: string,
+      objectsLists2: Hashtable<Array<gdjs.RuntimeObject>>,
+      behaviorName2: string,
+      inverted: boolean
+    ) {
+      return gdjs.evtTools.object.twoListsTest(
+        gdjs.Physics3DRuntimeBehavior.hasCollisionStoppedBetween,
+        objectsLists1,
+        objectsLists2,
+        inverted,
+        behaviorName
+      );
+    };
+
+    type BehaviorNamePair = { character: string; physics: string };
+
+    const isOnPlatformAdapter = (
+      characterObject: gdjs.RuntimeObject,
+      physicsObject: gdjs.RuntimeObject,
+      behaviorNamePair: BehaviorNamePair
+    ): boolean => {
+      const characterBehavior = characterObject.getBehavior(
+        behaviorNamePair.character
+      ) as gdjs.PhysicsCharacter3DRuntimeBehavior;
+      const physicsBehavior = physicsObject.getBehavior(
+        behaviorNamePair.physics
+      ) as gdjs.Physics3DRuntimeBehavior;
+      if (!characterBehavior || !physicsBehavior) {
+        return false;
+      }
+      return characterBehavior.isOnFloorObject(physicsBehavior);
+    };
+
+    const behaviorNamePair: BehaviorNamePair = { character: '', physics: '' };
+
+    export const isOnPlatform = (
+      characterObjectsLists: Hashtable<Array<gdjs.RuntimeObject>>,
+      characterBehaviorName: string,
+      physicsObjectsLists: Hashtable<Array<gdjs.RuntimeObject>>,
+      physicsBehaviorName: string,
+      inverted: boolean
+    ) => {
+      behaviorNamePair.character = characterBehaviorName;
+      behaviorNamePair.physics = physicsBehaviorName;
+      return gdjs.evtTools.object.twoListsTest(
+        isOnPlatformAdapter,
+        characterObjectsLists,
+        physicsObjectsLists,
+        inverted,
+        behaviorNamePair
+      );
+    };
+  }
+}

Extensions/Physics3DBehavior/README.md

@@ -0,0 +1,3 @@
+## Physics 3D Behaviors for GDevelop
+
+This is the 3D physics engine for GDevelop, based on [Jolt Physics](https://github.com/jrouwe/JoltPhysics.js/) (WebAssembly, version 0.30.0).

Extensions/Physics3DBehavior/tests/Physics3DRuntimeBehavior.spec.js

@@ -0,0 +1 @@
+describe('Physics3DRuntimeBehavior', () => {});

Extensions/PlatformBehavior/platformerobjectruntimebehavior.ts

@@ -231,9 +231,13 @@ namespace gdjs {
         ...super.getNetworkSyncData(),
         props: {
           cs: this._currentSpeed,
+
+          // TODO Try to remove these 3 fields from the synch
+          // They are reset every frame and are not part of the state.
           rdx: this._requestedDeltaX,
           rdy: this._requestedDeltaY,
           ldy: this._lastDeltaY,
+
           cfs: this._currentFallSpeed,
           cj: this._canJump,
           ldl: this._lastDirectionIsLeft,

GDJS/GDJS/Events/Builtin/JsCodeEvent.cpp

@@ -10,7 +10,6 @@
 #include "GDCore/Events/Tools/EventsCodeNameMangler.h"
 #include "GDCore/Project/Layout.h"
 #include "GDCore/Project/Project.h"
-#include "GDCore/Project/SourceFile.h"
 #include "GDCore/Serialization/SerializerElement.h"
 #include "GDCore/Tools/Localization.h"
 #include "GDCore/Tools/Log.h"

GDJS/GDJS/Events/CodeGeneration/MetadataDeclarationHelper.cpp

@@ -53,6 +53,10 @@ void MetadataDeclarationHelper::DeclareExtension(
     extension.SetCategory(eventsFunctionsExtension.GetCategory());
 
   DeclareExtensionDependencies(extension, eventsFunctionsExtension);
+
+  for (const auto &sourceFile : eventsFunctionsExtension.GetAllSourceFiles()) {
+    extension.AddSourceFile() = sourceFile;
+  }
 }
 
 /**
@@ -154,6 +158,9 @@ gd::ObjectMetadata &MetadataDeclarationHelper::DeclareObjectMetadata(
         .AddDefaultBehavior("TextContainerCapability::TextContainerBehavior");
   }
 
+  if (eventsBasedObject.IsPrivate())
+    objectMetadata.SetPrivate();
+
   // TODO EBO Use full type to identify object to avoid collision.
   // Objects are identified by their name alone.
   const gd::String &objectType = eventsBasedObject.GetName();

GDJS/GDJS/IDE/Exporter.cpp

@@ -22,7 +22,6 @@
 #include "GDCore/Project/ExternalLayout.h"
 #include "GDCore/Project/Layout.h"
 #include "GDCore/Project/Project.h"
-#include "GDCore/Project/SourceFile.h"
 #include "GDCore/Serialization/Serializer.h"
 #include "GDCore/Tools/Localization.h"
 #include "GDCore/Tools/Log.h"
@@ -130,15 +129,6 @@ bool Exporter::ExportWholePixiProject(const ExportOptions &options) {
       return false;
     }
 
-    // Export source files
-    if (!helper.ExportExternalSourceFiles(
-            exportedProject, codeOutputDir, includesFiles)) {
-      gd::LogError(
-          _("Error during exporting! Unable to export source files:\n") +
-          lastError);
-      return false;
-    }
-
     auto projectUsedResources =
         gd::SceneResourcesFinder::FindProjectResources(exportedProject);
     std::unordered_map<gd::String, std::set<gd::String>> scenesUsedResources;
@@ -173,10 +163,11 @@ bool Exporter::ExportWholePixiProject(const ExportOptions &options) {
     else if (options.target == "facebookInstantGames")
       source = gdjsRoot + "/Runtime/FacebookInstantGames/index.html";
 
-    if (!helper.ExportPixiIndexFile(exportedProject,
+    if (!helper.ExportIndexFile(exportedProject,
                                     source,
                                     exportDir,
                                     includesFiles,
+                                    usedExtensionsResult.GetUsedSourceFiles(),
                                     /*nonRuntimeScriptsCacheBurst=*/0,
                                     "")) {
       gd::LogError(_("Error during export:\n") + lastError);

GDJS/GDJS/IDE/ExporterHelper.cpp

@@ -38,7 +38,6 @@
 #include "GDCore/Project/Layout.h"
 #include "GDCore/Project/Project.h"
 #include "GDCore/Project/PropertyDescriptor.h"
-#include "GDCore/Project/SourceFile.h"
 #include "GDCore/Serialization/Serializer.h"
 #include "GDCore/Tools/Localization.h"
 #include "GDCore/Tools/Log.h"
@@ -71,6 +70,11 @@ static void InsertUnique(std::vector<gd::String> &container, gd::String str) {
     container.push_back(str);
 }
 
+static void InsertUniqueFirst(std::vector<gd::String> &container, gd::String str) {
+  if (std::find(container.begin(), container.end(), str) == container.end())
+    container.insert(container.begin(), str);
+}
+
 static gd::String CleanProjectName(gd::String projectName) {
   gd::String partiallyCleanedProjectName = projectName;
 
@@ -190,15 +194,6 @@ bool ExporterHelper::ExportProjectForPixiPreview(
       return false;
     }
 
-    // Export source files
-    if (!ExportExternalSourceFiles(
-            immutableProject, codeOutputDir, includesFiles)) {
-      gd::LogError(
-          _("Error during exporting! Unable to export source files:\n") +
-          lastError);
-      return false;
-    }
-
     previousTime = LogTimeSpent("Events code export", previousTime);
   }
 
@@ -318,10 +313,11 @@ bool ExporterHelper::ExportProjectForPixiPreview(
   ExportIncludesAndLibs(resourcesFiles, options.exportPath, true);
 
   // Create the index file
-  if (!ExportPixiIndexFile(exportedProject,
+  if (!ExportIndexFile(exportedProject,
                            gdjsRoot + "/Runtime/index.html",
                            options.exportPath,
                            includesFiles,
+                           usedExtensionsResult.GetUsedSourceFiles(),
                            options.nonRuntimeScriptsCacheBurst,
                            "gdjs.runtimeGameOptions"))
     return false;
@@ -383,19 +379,40 @@ void ExporterHelper::SerializeUsedResources(
   }
 }
 
-bool ExporterHelper::ExportPixiIndexFile(
+bool ExporterHelper::ExportIndexFile(
     const gd::Project &project,
     gd::String source,
     gd::String exportDir,
     const std::vector<gd::String> &includesFiles,
+    const std::vector<gd::SourceFileMetadata> &sourceFiles,
     unsigned int nonRuntimeScriptsCacheBurst,
     gd::String additionalSpec) {
   gd::String str = fs.ReadFile(source);
 
+  // Add a reference to all files to include, as weel as the source files
+  // required by the project.
+  std::vector<gd::String> finalIncludesFiles = includesFiles;
+  auto addSourceFileToIncludeFiles = [&](const gd::SourceFileMetadata& sourceFile) {
+    const auto& resourcesManager = project.GetResourcesManager();
+    if (!resourcesManager.HasResource(sourceFile.GetResourceName()))
+      return;
+
+    const gd::String& sourceFileFilename = resourcesManager.GetResource(sourceFile.GetResourceName()).GetFile();
+
+    if (sourceFile.GetIncludePosition() == "first") {
+      InsertUniqueFirst(finalIncludesFiles, sourceFileFilename);
+    } else if (sourceFile.GetIncludePosition() == "last") {
+      InsertUnique(finalIncludesFiles, sourceFileFilename);
+    }
+  };
+  for (const auto& sourceFile : sourceFiles) {
+    addSourceFileToIncludeFiles(sourceFile);
+  }
+
   // Generate the file
   if (!CompleteIndexFile(str,
                          exportDir,
-                         includesFiles,
+                         finalIncludesFiles,
                          nonRuntimeScriptsCacheBurst,
                          additionalSpec))
     return false;
@@ -964,29 +981,6 @@ bool ExporterHelper::ExportEventsCode(
   return true;
 }
 
-bool ExporterHelper::ExportExternalSourceFiles(
-    const gd::Project &project,
-    gd::String outputDir,
-    std::vector<gd::String> &includesFiles) {
-  const auto &allFiles = project.GetAllSourceFiles();
-  for (std::size_t i = 0; i < allFiles.size(); ++i) {
-    if (!allFiles[i]) continue;
-    if (allFiles[i]->GetLanguage() != "Javascript") continue;
-
-    gd::SourceFile &file = *allFiles[i];
-
-    gd::String filename = file.GetFileName();
-    fs.MakeAbsolute(filename, fs.DirNameFrom(project.GetProjectFile()));
-    gd::String outFilename = "ext-code" + gd::String::From(i) + ".js";
-    if (!fs.CopyFile(filename, outputDir + outFilename))
-      gd::LogWarning(_("Could not copy external file") + filename);
-
-    InsertUnique(includesFiles, outputDir + outFilename);
-  }
-
-  return true;
-}
-
 gd::String ExporterHelper::GetExportedIncludeFilename(
     const gd::String &include, unsigned int nonRuntimeScriptsCacheBurst) {
   auto addSearchParameterToUrl = [](const gd::String &url,

GDJS/GDJS/IDE/ExporterHelper.h

@@ -20,11 +20,11 @@ class ExternalLayout;
 class SerializerElement;
 class AbstractFileSystem;
 class ResourcesManager;
+class SourceFileMetadata;
 class WholeProjectDiagnosticReport;
 class CaptureOptions;
 class Screenshot;
 }  // namespace gd
-class wxProgressDialog;
 
 namespace gdjs {
 
@@ -450,21 +450,6 @@ class ExporterHelper {
   bool ExportEffectIncludes(gd::Project &project,
                             std::vector<gd::String> &includesFiles);
 
-  /**
-   * \brief Copy the external source files used by the game into the export
-   * directory, and add them into files to be included.
-   *
-   * Files are named "ext-codeX.js", X being the index of the external source
-   * file in the project. \param project The project with resources to be
-   * exported. \param outputDir The directory where the events code must be
-   * generated. \param includesFiles A reference to a vector that will be filled
-   * with JS files to be exported along with the project. (including
-   * "ext-codeX.js" files).
-   */
-  bool ExportExternalSourceFiles(const gd::Project &project,
-                                 gd::String outputDir,
-                                 std::vector<gd::String> &includesFiles);
-
   /**
    * \brief Generate the standard index file and save it to the export
    * directory.
@@ -482,10 +467,11 @@ class ExporterHelper {
    * \param additionalSpec JSON string that will be passed to the
    * gdjs.RuntimeGame object.
    */
-  bool ExportPixiIndexFile(const gd::Project &project,
+  bool ExportIndexFile(const gd::Project &project,
                            gd::String source,
                            gd::String exportDir,
                            const std::vector<gd::String> &includesFiles,
+                           const std::vector<gd::SourceFileMetadata> &sourceFiles,
                            unsigned int nonRuntimeScriptsCacheBurst,
                            gd::String additionalSpec = "");
 

GDJS/Runtime/RuntimeInstanceContainer.ts

@@ -342,8 +342,7 @@ namespace gdjs {
           newObject.setPosition(instanceData.x + xPos, instanceData.y + yPos);
           newObject.setAngle(instanceData.angle);
           if (gdjs.Base3DHandler && gdjs.Base3DHandler.is3D(newObject)) {
-            if (instanceData.z !== undefined)
-              newObject.setZ(instanceData.z + zOffset);
+            newObject.setZ((instanceData.z || 0) + zOffset);
             if (instanceData.rotationX !== undefined)
               newObject.setRotationX(instanceData.rotationX);
             if (instanceData.rotationY !== undefined)

GDJS/Runtime/events-tools/soundtools.ts

@@ -6,8 +6,6 @@
 namespace gdjs {
   export namespace evtTools {
     export namespace sound {
-      const logger = new gdjs.Logger('Audio events');
-
       export const getGlobalVolume = function (
         runtimeScene: gdjs.RuntimeScene
       ): float {
@@ -64,9 +62,6 @@ namespace gdjs {
           .getSoundManager()
           .getSoundOnChannel(channel);
         if (sound) sound.stop();
-        else {
-          logger.error(`Cannot stop non-existing sound on channel ${channel}.`);
-        }
       };
 
       export const pauseSoundOnChannel = function (
@@ -78,11 +73,6 @@ namespace gdjs {
           .getSoundManager()
           .getSoundOnChannel(channel);
         if (sound) sound.pause();
-        else {
-          logger.error(
-            `Cannot pause non-existing sound on channel ${channel}.`
-          );
-        }
       };
 
       export const continueSoundOnChannel = function (
@@ -95,10 +85,6 @@ namespace gdjs {
           .getSoundOnChannel(channel);
         if (sound) {
           if (!sound.playing()) sound.play();
-        } else {
-          logger.error(
-            `Cannot continue playing non-existing sound on channel ${channel}.`
-          );
         }
       };
 
@@ -123,9 +109,6 @@ namespace gdjs {
           .getSoundOnChannel(channel);
         if (sound) return sound.paused();
         else {
-          logger.error(
-            `Cannot check if non-existing sound on channel ${channel} is paused.`
-          );
           return false;
         }
       };
@@ -140,9 +123,6 @@ namespace gdjs {
           .getSoundOnChannel(channel);
         if (sound) return sound.stopped();
         else {
-          logger.error(
-            `Cannot check if non-existing sound on channel ${channel} is stopped.`
-          );
           return true;
         }
       };
@@ -157,9 +137,6 @@ namespace gdjs {
           .getSoundOnChannel(channel);
         if (sound) return sound.getVolume() * 100;
         else {
-          logger.error(
-            `Cannot get the volume of a non-existing sound on channel ${channel}.`
-          );
           return 100;
         }
       };
@@ -174,11 +151,6 @@ namespace gdjs {
           .getSoundManager()
           .getSoundOnChannel(channel);
         if (sound) sound.setVolume(volume / 100);
-        else {
-          logger.error(
-            `Cannot set the volume of a non-existing sound on channel ${channel}.`
-          );
-        }
       };
 
       export const getSoundOnChannelPlayingOffset = function (
@@ -191,9 +163,6 @@ namespace gdjs {
           .getSoundOnChannel(channel);
         if (sound) return sound.getSeek();
         else {
-          logger.error(
-            `Cannot get the playing offset of a non-existing sound on channel ${channel}.`
-          );
           return 0;
         }
       };
@@ -208,11 +177,6 @@ namespace gdjs {
           .getSoundManager()
           .getSoundOnChannel(channel);
         if (sound) sound.setSeek(playingOffset);
-        else {
-          logger.error(
-            `Cannot set the playing offset of a non-existing sound on channel ${channel}.`
-          );
-        }
       };
 
       export const getSoundOnChannelPitch = function (
@@ -225,9 +189,6 @@ namespace gdjs {
           .getSoundOnChannel(channel);
         if (sound) return sound.getRate();
         else {
-          logger.error(
-            `Cannot get the pitch of a non-existing sound on channel ${channel}.`
-          );
           return 1;
         }
       };
@@ -242,11 +203,6 @@ namespace gdjs {
           .getSoundManager()
           .getSoundOnChannel(channel);
         if (sound) sound.setRate(pitch);
-        else {
-          logger.error(
-            `Cannot get the pitch of a non-existing sound on channel ${channel}.`
-          );
-        }
       };
 
       export const preloadSound = (
@@ -304,11 +260,6 @@ namespace gdjs {
           .getSoundManager()
           .getMusicOnChannel(channel);
         if (music) music.stop();
-        else {
-          logger.error(
-            `Cannot stop a non-existing music on channel ${channel}.`
-          );
-        }
       };
 
       export const pauseMusicOnChannel = function (
@@ -320,11 +271,6 @@ namespace gdjs {
           .getSoundManager()
           .getMusicOnChannel(channel);
         if (music) music.pause();
-        else {
-          logger.error(
-            `Cannot pause a non-existing music on channel ${channel}.`
-          );
-        }
       };
 
       export const continueMusicOnChannel = function (
@@ -337,10 +283,6 @@ namespace gdjs {
           .getMusicOnChannel(channel);
         if (music) {
           if (!music.playing()) music.play();
-        } else {
-          logger.error(
-            `Cannot stop a non-existing music on channel ${channel}.`
-          );
         }
       };
 
@@ -365,9 +307,6 @@ namespace gdjs {
           .getMusicOnChannel(channel);
         if (music) return music.paused();
         else {
-          logger.error(
-            `Cannot check if non-existing music on channel ${channel} is paused.`
-          );
           return false;
         }
       };
@@ -382,9 +321,6 @@ namespace gdjs {
           .getMusicOnChannel(channel);
         if (music) return music.stopped();
         else {
-          logger.error(
-            `Cannot check if non-existing music on channel ${channel} is stopped.`
-          );
           return true;
         }
       };
@@ -399,9 +335,6 @@ namespace gdjs {
           .getMusicOnChannel(channel);
         if (music) return music.getVolume() * 100;
         else {
-          logger.error(
-            `Cannot get the volume of a non-existing music on channel ${channel}.`
-          );
           return 100;
         }
       };
@@ -416,11 +349,6 @@ namespace gdjs {
           .getSoundManager()
           .getMusicOnChannel(channel);
         if (music) music.setVolume(volume / 100);
-        else {
-          logger.error(
-            `Cannot set the volume of a non-existing music on channel ${channel}.`
-          );
-        }
       };
 
       export const getMusicOnChannelPlayingOffset = function (
@@ -433,9 +361,6 @@ namespace gdjs {
           .getMusicOnChannel(channel);
         if (music) return music.getSeek();
         else {
-          logger.error(
-            `Cannot get the playing offset of a non-existing music on channel ${channel}.`
-          );
           return 0;
         }
       };
@@ -450,11 +375,6 @@ namespace gdjs {
           .getSoundManager()
           .getMusicOnChannel(channel);
         if (music) music.setSeek(playingOffset);
-        else {
-          logger.error(
-            `Cannot set the playing offset of a non-existing music on channel ${channel}.`
-          );
-        }
       };
 
       export const getMusicOnChannelPitch = function (
@@ -467,9 +387,6 @@ namespace gdjs {
           .getMusicOnChannel(channel);
         if (music) return music.getRate();
         else {
-          logger.error(
-            `Cannot get the pitch of a non-existing music on channel ${channel}.`
-          );
           return 1;
         }
       };
@@ -484,11 +401,6 @@ namespace gdjs {
           .getSoundManager()
           .getMusicOnChannel(channel);
         if (music) music.setRate(pitch);
-        else {
-          logger.error(
-            `Cannot get the pitch of a non-existing music on channel ${channel}.`
-          );
-        }
       };
 
       export const preloadMusic = (
@@ -521,10 +433,6 @@ namespace gdjs {
           .getSoundOnChannel(channel);
         if (sound) {
           sound.fade(sound.getVolume(), toVolume / 100, timeOfFade * 1000);
-        } else {
-          logger.error(
-            `Cannot fade the volume of a non-existing sound on channel ${channel}.`
-          );
         }
       };
       export const fadeMusicVolume = (
@@ -539,10 +447,6 @@ namespace gdjs {
           .getMusicOnChannel(channel);
         if (music) {
           music.fade(music.getVolume(), toVolume / 100, timeOfFade * 1000);
-        } else {
-          logger.error(
-            `Cannot fade the volume of a non-existing music on channel ${channel}.`
-          );
         }
       };
     }

GDJS/Runtime/pixi-renderers/pixi-image-manager.ts

@@ -70,7 +70,8 @@ namespace gdjs {
     constructor(resourceLoader: gdjs.ResourceLoader) {
       this._resourceLoader = resourceLoader;
       this._invalidTexture = PIXI.Texture.from(
-        'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAICAYAAADED76LAAAAFElEQVQoU2P8z/D/PwMewDgyFAAApMMX8Zi0uXAAAAAASUVORK5CYIIA'
+        'data:image/png;base64,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',
+        { width: 192, height: 192 }
       );
       this._loadedThreeTextures = new Hashtable();
       this._loadedThreeMaterials = new Hashtable();

GDJS/Runtime/pixi-renderers/runtimegame-pixi-renderer.ts

@@ -62,7 +62,7 @@ namespace gdjs {
     /**
      * Create the canvas on which the game will be rendered, inside the specified DOM element, and
      * setup the rendering of the game.
-     * If you want to use your own canvas, use `initializeForCanvas` instead.
+     * If you want to use your own canvas, use `initializeRenderers` and `initializeCanvas` instead.
      *
      * @param parentElement The parent element to which the canvas will be added.
      */
@@ -72,14 +72,16 @@ namespace gdjs {
       const gameCanvas = document.createElement('canvas');
       parentElement.appendChild(gameCanvas);
 
-      this.initializeForCanvas(gameCanvas);
+      this.initializeRenderers(gameCanvas);
+      this.initializeCanvas(gameCanvas);
     }
 
     /**
-     * Setup the rendering of the game to use a canvas that was already created.
-     * @param gameCanvas The canvas to use.
+     * Set up the rendering of the game for the given canvas.
+     *
+     * In most cases, you can use `createStandardCanvas` instead to initialize the game.
      */
-    initializeForCanvas(gameCanvas: HTMLCanvasElement): void {
+    initializeRenderers(gameCanvas: HTMLCanvasElement): void {
       this._throwIfDisposed();
 
       if (typeof THREE !== 'undefined') {
@@ -130,7 +132,13 @@ namespace gdjs {
       // See https://github.com/pixijs/pixijs/issues/5111#issuecomment-420047824
       this._pixiRenderer.plugins.accessibility.destroy();
       delete this._pixiRenderer.plugins.accessibility;
+    }
 
+    /**
+     * Set up the game canvas so that it covers the size required by the game
+     * and has a container for DOM elements required by the game.
+     */
+    initializeCanvas(gameCanvas: HTMLCanvasElement): void {
       // Add the renderer view element to the DOM
       this._gameCanvas = gameCanvas;
 
@@ -531,6 +539,8 @@ namespace gdjs {
 
     /**
      * Add the standard events handler.
+     *
+     * The game canvas must have been initialized before calling this.
      */
     bindStandardEvents(
       manager: gdjs.InputManager,

GDJS/Runtime/types/project-data.d.ts

@@ -340,7 +340,6 @@ declare interface ProjectPropertiesData {
   antialiasingMode: 'none' | 'MSAA';
   antialisingEnabledOnMobile: boolean;
   sizeOnStartupMode: string;
-  useExternalSourceFiles: boolean;
   version: string;
   name: string;
   author: string;

GDJS/tests/tests-utils/init.pixiruntimegame.js

@@ -20,7 +20,6 @@ gdjs.createProjectData = (settings) => {
       sizeOnStartupMode: '',
       antialiasingMode: 'MSAA',
       antialisingEnabledOnMobile: false,
-      useExternalSourceFiles: true,
       version: '1.0.0',
       name: 'Test game',
       author: '',

GDJS/tests/tests-utils/init.pixiruntimegamewithassets.js

@@ -24,7 +24,6 @@ gdjs.getPixiRuntimeGameWithAssets = () => {
       sizeOnStartupMode: 'adaptWidth',
       antialiasingMode: 'MSAA',
       antialisingEnabledOnMobile: false,
-      useExternalSourceFiles: true,
       version: '1.0.0',
       name: 'Test game with real assets',
       author: '',

GDJS/tests/tests/game-canvas.js

@@ -24,7 +24,8 @@ describe('gdjs.RuntimeGameRenderer canvas tests', () => {
     it('should correctly initialize external canvas and create domElementsContainer', () => {
         const gameCanvas = document.createElement('canvas');
         gameContainer.appendChild(gameCanvas);
-        renderer.initializeForCanvas(gameCanvas);
+        renderer.initializeRenderers(gameCanvas);
+        renderer.initializeCanvas(gameCanvas);
 
         const actualGameCanvas = renderer.getCanvas();
         const actualDomElementsContainer = renderer.getDomElementContainer();

GDevelop.js/Bindings/Bindings.idl

@@ -39,6 +39,11 @@ interface VectorDependencyMetadata {
     [Const, Ref] DependencyMetadata at(unsigned long index);
 };
 
+interface VectorSourceFileMetadata {
+    unsigned long size();
+    [Const, Ref] SourceFileMetadata at(unsigned long index);
+};
+
 interface VectorInt {
     unsigned long size();
     long at(unsigned long index);
@@ -637,6 +642,7 @@ interface Project {
     [Ref] EventsFunctionsExtension InsertEventsFunctionsExtension([Const, Ref] EventsFunctionsExtension eventsFunctionsExtension, unsigned long position);
     void RemoveEventsFunctionsExtension([Const] DOMString name);
     unsigned long GetEventsFunctionsExtensionPosition([Const] DOMString name);
+    void UnserializeAndInsertExtensionsFrom([Const, Ref] SerializerElement eventsFunctionsExtensionsElement);
 
     boolean HasEventsBasedBehavior([Const] DOMString type);
     [Ref] EventsBasedBehavior GetEventsBasedBehavior([Const] DOMString type);
@@ -1321,6 +1327,11 @@ interface AtlasResource {
 };
 AtlasResource implements Resource;
 
+interface JavaScriptResource {
+    void JavaScriptResource();
+};
+JavaScriptResource implements Resource;
+
 interface InitialInstance {
     void InitialInstance();
 
@@ -1758,6 +1769,15 @@ interface DependencyMetadata {
     void CopyFrom([Const, Ref] DependencyMetadata dependencyMetadata);
 };
 
+interface SourceFileMetadata {
+    void SourceFileMetadata();
+
+    [Const, Ref] DOMString GetResourceName();
+    [Ref] SourceFileMetadata SetResourceName([Const] DOMString resourceName_);
+    [Const, Ref] DOMString GetIncludePosition();
+    [Ref] SourceFileMetadata SetIncludePosition([Const] DOMString includePosition_);
+};
+
 interface ParameterMetadata {
     void ParameterMetadata();
 
@@ -1927,6 +1947,9 @@ interface ObjectMetadata {
     boolean HasDefaultBehavior([Const] DOMString behaviorType);
     [Ref] ObjectMetadata AddDefaultBehavior([Const] DOMString behaviorType);
 
+    boolean IsPrivate();
+    [Ref] ObjectMetadata SetPrivate();
+
     [Ref] ObjectMetadata SetHidden();
     boolean IsHidden();
 
@@ -2244,6 +2267,7 @@ interface PlatformExtension {
 
     [Ref] MapStringPropertyDescriptor GetAllProperties();
     [Ref] VectorDependencyMetadata GetAllDependencies();
+    [Ref] VectorSourceFileMetadata GetAllSourceFiles();
 
     [Const, Value] DOMString STATIC_GetNamespaceSeparator();
     [Const, Value] DOMString STATIC_GetBehaviorFullType(
@@ -2437,7 +2461,13 @@ interface VectorEventsSearchResult {
 };
 
 interface EventsRefactorer {
-    void STATIC_RenameObjectInEvents([Const, Ref] Platform platform, [Ref] ProjectScopedContainers projectScopedContainers, [Ref] EventsList events, [Const] DOMString oldName, [Const] DOMString newName);
+    void STATIC_RenameObjectInEvents(
+        [Const, Ref] Platform platform,
+        [Ref] ProjectScopedContainers projectScopedContainers,
+        [Ref] EventsList events,
+        [Const, Ref] ObjectsContainer targetedObjectsContainer,
+        [Const] DOMString oldName,
+        [Const] DOMString newName);
     [Value] VectorEventsSearchResult STATIC_ReplaceStringInEvents([Ref] ObjectsContainer project, [Ref] ObjectsContainer layout, [Ref] EventsList events, [Const] DOMString toReplace, [Const] DOMString newString, boolean matchCase, boolean inConditions, boolean inActions,  boolean inEventStrings);
     [Value] VectorEventsSearchResult STATIC_SearchInEvents([Const, Ref] Platform platform, [Ref] EventsList events, [Const] DOMString search, boolean matchCase, boolean inConditions, boolean inActions, boolean inEventStrings, boolean inEventSentences);
 };
@@ -2517,6 +2547,13 @@ interface WholeProjectRefactorer {
       [Const, Ref] EventsBasedObject eventsBasedObject,
       [Const] DOMString oldName,
       [Const] DOMString newName);
+    void STATIC_RenameParameter(
+      [Ref] Project project,
+      [Ref] ProjectScopedContainers projectScopedContainers,
+      [Ref] EventsFunction eventsFunction,
+      [Const, Ref] ObjectsContainer parameterObjectsContainer,
+      [Const] DOMString oldName,
+      [Const] DOMString newName);
     void STATIC_MoveEventsFunctionParameter(
       [Ref] Project project,
       [Const, Ref] EventsFunctionsExtension eventsFunctionsExtension,
@@ -2668,6 +2705,7 @@ interface WholeProjectRefactorer {
         [Ref] Project project,
         [Ref] ProjectScopedContainers projectScopedContainers,
         [Ref] EventsFunction eventsFunction,
+        [Const, Ref] ObjectsContainer parameterObjectsContainer,
         [Const] DOMString oldName,
         [Const] DOMString newName,
         boolean isObjectGroup);
@@ -2991,6 +3029,11 @@ interface AbstractEventsBasedEntity {
     [Ref] EventsFunctionsContainer GetEventsFunctions();
     [Ref] PropertiesContainer GetPropertyDescriptors();
 
+    [Const, Ref] DOMString GetName();
+    [Const, Ref] DOMString GetFullName();
+    [Const, Ref] DOMString GetDescription();
+    boolean IsPrivate();
+
     void SerializeTo([Ref] SerializerElement element);
     void UnserializeFrom([Ref] Project project, [Const, Ref] SerializerElement element);
 };
@@ -2998,16 +3041,13 @@ interface AbstractEventsBasedEntity {
 interface EventsBasedBehavior {
     void EventsBasedBehavior();
 
-    [Ref] EventsBasedBehavior SetDescription([Const] DOMString description);
-    [Const, Ref] DOMString GetDescription();
     [Ref] EventsBasedBehavior SetName([Const] DOMString name);
-    [Const, Ref] DOMString GetName();
     [Ref] EventsBasedBehavior SetFullName([Const] DOMString fullName);
-    [Const, Ref] DOMString GetFullName();
+    [Ref] EventsBasedBehavior SetDescription([Const] DOMString description);
+    [Ref] EventsBasedBehavior SetPrivate(boolean isPrivate);
+
     [Ref] EventsBasedBehavior SetObjectType([Const] DOMString fullName);
     [Const, Ref] DOMString GetObjectType();
-    [Ref] EventsBasedBehavior SetPrivate(boolean isPrivate);
-    boolean IsPrivate();
     [Ref] EventsBasedBehavior SetQuickCustomizationVisibility(QuickCustomization_Visibility visibility);
     QuickCustomization_Visibility GetQuickCustomizationVisibility();
 
@@ -3042,15 +3082,13 @@ interface EventsBasedBehaviorsList {
 interface EventsBasedObject {
     void EventsBasedObject();
 
-    [Ref] EventsBasedObject SetDescription([Const] DOMString description);
-    [Const, Ref] DOMString GetDescription();
     [Ref] EventsBasedObject SetName([Const] DOMString name);
-    [Const, Ref] DOMString GetName();
     [Ref] EventsBasedObject SetFullName([Const] DOMString fullName);
-    [Const, Ref] DOMString GetFullName();
+    [Ref] EventsBasedObject SetDescription([Const] DOMString description);
+    [Ref] EventsBasedObject SetPrivate(boolean isPrivate);
+
     [Ref] EventsBasedObject SetDefaultName([Const] DOMString defaultName);
     [Const, Ref] DOMString GetDefaultName();
-
     [Ref] EventsBasedObject MarkAsRenderedIn3D(boolean isRenderedIn3D);
     boolean IsRenderedIn3D();
     [Ref] EventsBasedObject MarkAsAnimatable(boolean isAnimatable);
@@ -3153,6 +3191,10 @@ interface EventsFunctionsExtension {
     void RemoveDependencyAt(unsigned long index);
     [Ref] VectorDependencyMetadata GetAllDependencies();
 
+    [Ref] SourceFileMetadata AddSourceFile();
+    void RemoveSourceFileAt(unsigned long index);
+    [Ref] VectorSourceFileMetadata GetAllSourceFiles();
+
     [Ref] VariablesContainer GetGlobalVariables();
     [Ref] VariablesContainer GetSceneVariables();
 

GDevelop.js/Bindings/Wrapper.cpp

@@ -424,6 +424,7 @@ typedef std::vector<Polygon2d> VectorPolygon2d;
 typedef std::vector<gd::Vector2f> VectorVector2f;
 typedef std::vector<EventsSearchResult> VectorEventsSearchResult;
 typedef std::vector<gd::DependencyMetadata> VectorDependencyMetadata;
+typedef std::vector<gd::SourceFileMetadata> VectorSourceFileMetadata;
 typedef std::vector<gd::EventsFunction> VectorEventsFunction;
 typedef gd::Object gdObject;  // To avoid clashing javascript Object in glue.js
 typedef ParticleEmitterObject::RendererType ParticleEmitterObject_RendererType;
@@ -727,6 +728,7 @@ typedef ExtensionAndMetadata<ExpressionMetadata> ExtensionAndExpressionMetadata;
 #define STATIC_RenameEventsFunction RenameEventsFunction
 #define STATIC_RenameBehaviorEventsFunction RenameBehaviorEventsFunction
 #define STATIC_RenameObjectEventsFunction RenameObjectEventsFunction
+#define STATIC_RenameParameter RenameParameter
 #define STATIC_MoveEventsFunctionParameter MoveEventsFunctionParameter
 #define STATIC_MoveBehaviorEventsFunctionParameter \
   MoveBehaviorEventsFunctionParameter

GDevelop.js/TestUtils/GDJSMocks.js

@@ -434,6 +434,14 @@ class RuntimeObject {
     return variable.getAsNumber();
   }
 
+  static getVariableString(variable) {
+    return variable.getAsString();
+  }
+
+  getVariableString(variable) {
+    return variable.getAsString();
+  }
+
   static getVariableBoolean(variable) {
     return variable.getAsBoolean();
   }
@@ -935,7 +943,8 @@ function makeMinimalGDJSMock(options) {
         variable: {
           getVariableNumber: (variable) => variable.getAsNumber(),
           getVariableString: (variable) => variable.getAsString(),
-          getVariableBoolean: (variable) => variable.getAsBoolean(),
+          getVariableBoolean: (variable, compareWith) =>
+            variable.getAsBoolean() === compareWith,
           toggleVariableBoolean: (variable) =>
             variable.setBoolean(!variable.getAsBoolean()),
           variablePushCopy: (array, variable) =>
@@ -946,8 +955,7 @@ function makeMinimalGDJSMock(options) {
             variable.hasChild(childName),
           variableRemoveChild: (variable, childName) =>
             variable.removeChild(childName),
-          variableClearChildren: (variable) =>
-            variable.clearChildren(),
+          variableClearChildren: (variable) => variable.clearChildren(),
         },
         object: {
           createObjectOnScene,

GDevelop.js/__tests__/Core.js

@@ -1368,6 +1368,24 @@ describe('libGD.js', function () {
     });
   });
 
+  describe('gd.JavaScriptResource', function () {
+    it('should have name and file', function () {
+      const resource = new gd.JavaScriptResource();
+      resource.setName('MyJavaScriptResource');
+      resource.setFile('MyJavaScriptFile');
+      expect(resource.getName()).toBe('MyJavaScriptResource');
+      expect(resource.getFile()).toBe('MyJavaScriptFile');
+      resource.delete();
+    });
+    it('can have metadata', function () {
+      const resource = new gd.JavaScriptResource();
+      expect(resource.getMetadata()).toBe('');
+      resource.setMetadata(JSON.stringify({ hello: 'world' }));
+      expect(resource.getMetadata()).toBe('{"hello":"world"}');
+      resource.delete();
+    });
+  });
+
   describe('gd.JsonResource', function () {
     it('should have name and file', function () {
       const resource = new gd.JsonResource();

GDevelop.js/__tests__/GDJSExtensionVariableCodeGenerationIntegrationTests.js

@@ -211,7 +211,7 @@ describe('libGD.js - GDJS Code Generation integration tests', function () {
     const runtimeScene = generateAndRunVariableAffectationWithConditions([
       {
         type: { inverted: false, value: 'BooleanVariable' },
-        parameters: ['MyVariable'],
+        parameters: ['MyVariable', 'True', ''],
       },
     ]);
     expect(
@@ -229,7 +229,7 @@ describe('libGD.js - GDJS Code Generation integration tests', function () {
       .setString('Same value');
     const runtimeScene = generateAndRunVariableAffectationWithConditions([
       {
-        type: { inverted: false, value: 'BooleanVariable' },
+        type: { inverted: false, value: 'StringVariable' },
         parameters: ['MyVariable', '=', '"Same value"'],
       },
     ]);

GDevelop.js/__tests__/GDJSSceneObjectVariableCodeGenerationIntegrationTests.js

@@ -243,7 +243,7 @@ describe('libGD.js - GDJS Code Generation integration tests', function () {
     object.getVariables().insertNew('MyVariable', 0).setString('Same value');
     const runtimeScene = generateAndRunVariableAffectationWithConditions([
       {
-        type: { inverted: false, value: 'BooleanObjectVariable' },
+        type: { inverted: false, value: 'StringObjectVariable' },
         parameters: ['MyObject', 'MyVariable', '=', '"Same value"'],
       },
     ]);

GDevelop.js/__tests__/GDJSSceneVariableCodeGenerationIntegrationTests.js

@@ -181,12 +181,77 @@ describe('libGD.js - GDJS Code Generation integration tests', function () {
     ).toBe(1);
   });
 
-  it('can generate a scene boolean variable condition that is true', function () {
+  it('can generate a scene boolean variable condition that checks true', function () {
     scene.getVariables().insertNew('MyVariable', 0).setBool(true);
     const runtimeScene = generateAndRunVariableAffectationWithConditions([
       {
         type: { inverted: false, value: 'BooleanVariable' },
-        parameters: ['MyVariable'],
+        parameters: ['MyVariable', 'True', ''],
+      },
+    ]);
+    expect(
+      runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
+    ).toBe(1);
+  });
+
+  it('can generate a scene boolean variable condition that checks true (inverted)', function () {
+    scene.getVariables().insertNew('MyVariable', 0).setBool(false);
+    const runtimeScene = generateAndRunVariableAffectationWithConditions([
+      {
+        type: { inverted: true, value: 'BooleanVariable' },
+        parameters: ['MyVariable', 'True', ''],
+      },
+    ]);
+    expect(
+      runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
+    ).toBe(1);
+  });
+
+  it('can generate a scene boolean variable condition that checks false', function () {
+    scene.getVariables().insertNew('MyVariable', 0).setBool(false);
+    const runtimeScene = generateAndRunVariableAffectationWithConditions([
+      {
+        type: { inverted: false, value: 'BooleanVariable' },
+        parameters: ['MyVariable', 'False', ''],
+      },
+    ]);
+    expect(
+      runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
+    ).toBe(1);
+  });
+
+  it('can generate a scene boolean variable condition that checks false (inverted)', function () {
+    scene.getVariables().insertNew('MyVariable', 0).setBool(true);
+    const runtimeScene = generateAndRunVariableAffectationWithConditions([
+      {
+        type: { inverted: true, value: 'BooleanVariable' },
+        parameters: ['MyVariable', 'False', ''],
+      },
+    ]);
+    expect(
+      runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
+    ).toBe(1);
+  });
+
+  it('can generate a scene boolean variable condition that checks false (defaulted from an empty string)', function () {
+    scene.getVariables().insertNew('MyVariable', 0).setBool(false);
+    const runtimeScene = generateAndRunVariableAffectationWithConditions([
+      {
+        type: { inverted: false, value: 'BooleanVariable' },
+        parameters: ['MyVariable', '', ''],
+      },
+    ]);
+    expect(
+      runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
+    ).toBe(1);
+  });
+
+  it('can generate a scene boolean variable condition that checks false (defaulted from an empty string, inverted)', function () {
+    scene.getVariables().insertNew('MyVariable', 0).setBool(true);
+    const runtimeScene = generateAndRunVariableAffectationWithConditions([
+      {
+        type: { inverted: true, value: 'BooleanVariable' },
+        parameters: ['MyVariable', '', ''],
       },
     ]);
     expect(
@@ -198,7 +263,7 @@ describe('libGD.js - GDJS Code Generation integration tests', function () {
     scene.getVariables().insertNew('MyVariable', 0).setString('Same value');
     const runtimeScene = generateAndRunVariableAffectationWithConditions([
       {
-        type: { inverted: false, value: 'BooleanVariable' },
+        type: { inverted: false, value: 'StringVariable' },
         parameters: ['MyVariable', '=', '"Same value"'],
       },
     ]);

GDevelop.js/types.d.ts

@@ -125,6 +125,11 @@ export class VectorDependencyMetadata extends EmscriptenObject {
   at(index: number): DependencyMetadata;
 }
 
+export class VectorSourceFileMetadata extends EmscriptenObject {
+  size(): number;
+  at(index: number): SourceFileMetadata;
+}
+
 export class VectorInt extends EmscriptenObject {
   size(): number;
   at(index: number): number;
@@ -597,6 +602,7 @@ export class Project extends EmscriptenObject {
   insertEventsFunctionsExtension(eventsFunctionsExtension: EventsFunctionsExtension, position: number): EventsFunctionsExtension;
   removeEventsFunctionsExtension(name: string): void;
   getEventsFunctionsExtensionPosition(name: string): number;
+  unserializeAndInsertExtensionsFrom(eventsFunctionsExtensionsElement: SerializerElement): void;
   hasEventsBasedBehavior(type: string): boolean;
   getEventsBasedBehavior(type: string): EventsBasedBehavior;
   hasEventsBasedObject(type: string): boolean;
@@ -1099,6 +1105,10 @@ export class AtlasResource extends Resource {
   constructor();
 }
 
+export class JavaScriptResource extends Resource {
+  constructor();
+}
+
 export class InitialInstance extends EmscriptenObject {
   constructor();
   setObjectName(name: string): void;
@@ -1447,6 +1457,14 @@ export class DependencyMetadata extends EmscriptenObject {
   copyFrom(dependencyMetadata: DependencyMetadata): void;
 }
 
+export class SourceFileMetadata extends EmscriptenObject {
+  constructor();
+  getResourceName(): string;
+  setResourceName(resourceName_: string): SourceFileMetadata;
+  getIncludePosition(): string;
+  setIncludePosition(includePosition_: string): SourceFileMetadata;
+}
+
 export class ParameterMetadata extends EmscriptenObject {
   constructor();
   getType(): string;
@@ -1542,6 +1560,8 @@ export class ObjectMetadata extends EmscriptenObject {
   getDefaultBehaviors(): SetString;
   hasDefaultBehavior(behaviorType: string): boolean;
   addDefaultBehavior(behaviorType: string): ObjectMetadata;
+  isPrivate(): boolean;
+  setPrivate(): ObjectMetadata;
   setHidden(): ObjectMetadata;
   isHidden(): boolean;
   markAsRenderedIn3D(): ObjectMetadata;
@@ -1703,6 +1723,7 @@ export class PlatformExtension extends EmscriptenObject {
   getAllStrExpressionsForBehavior(autoType: string): MapStringExpressionMetadata;
   getAllProperties(): MapStringPropertyDescriptor;
   getAllDependencies(): VectorDependencyMetadata;
+  getAllSourceFiles(): VectorSourceFileMetadata;
   static getNamespaceSeparator(): string;
   static getBehaviorFullType(extensionName: string, behaviorName: string): string;
   static getObjectFullType(extensionName: string, objectName: string): string;
@@ -1863,7 +1884,7 @@ export class VectorEventsSearchResult extends EmscriptenObject {
 }
 
 export class EventsRefactorer extends EmscriptenObject {
-  static renameObjectInEvents(platform: Platform, projectScopedContainers: ProjectScopedContainers, events: EventsList, oldName: string, newName: string): void;
+  static renameObjectInEvents(platform: Platform, projectScopedContainers: ProjectScopedContainers, events: EventsList, targetedObjectsContainer: ObjectsContainer, oldName: string, newName: string): void;
   static replaceStringInEvents(project: ObjectsContainer, layout: ObjectsContainer, events: EventsList, toReplace: string, newString: string, matchCase: boolean, inConditions: boolean, inActions: boolean, inEventStrings: boolean): VectorEventsSearchResult;
   static searchInEvents(platform: Platform, events: EventsList, search: string, matchCase: boolean, inConditions: boolean, inActions: boolean, inEventStrings: boolean, inEventSentences: boolean): VectorEventsSearchResult;
 }
@@ -1905,6 +1926,7 @@ export class WholeProjectRefactorer extends EmscriptenObject {
   static renameEventsFunction(project: Project, eventsFunctionsExtension: EventsFunctionsExtension, oldName: string, newName: string): void;
   static renameBehaviorEventsFunction(project: Project, eventsFunctionsExtension: EventsFunctionsExtension, eventsBasedBehavior: EventsBasedBehavior, oldName: string, newName: string): void;
   static renameObjectEventsFunction(project: Project, eventsFunctionsExtension: EventsFunctionsExtension, eventsBasedObject: EventsBasedObject, oldName: string, newName: string): void;
+  static renameParameter(project: Project, projectScopedContainers: ProjectScopedContainers, eventsFunction: EventsFunction, parameterObjectsContainer: ObjectsContainer, oldName: string, newName: string): void;
   static moveEventsFunctionParameter(project: Project, eventsFunctionsExtension: EventsFunctionsExtension, functionName: string, oldIndex: number, newIndex: number): void;
   static moveBehaviorEventsFunctionParameter(project: Project, eventsFunctionsExtension: EventsFunctionsExtension, eventsBasedBehavior: EventsBasedBehavior, functionName: string, oldIndex: number, newIndex: number): void;
   static moveObjectEventsFunctionParameter(project: Project, eventsFunctionsExtension: EventsFunctionsExtension, eventsBasedObject: EventsBasedObject, functionName: string, oldIndex: number, newIndex: number): void;
@@ -1931,7 +1953,7 @@ export class WholeProjectRefactorer extends EmscriptenObject {
   static objectOrGroupRenamedInScene(project: Project, scene: Layout, oldName: string, newName: string, isObjectGroup: boolean): void;
   static objectRemovedInScene(project: Project, scene: Layout, objectName: string): void;
   static behaviorsAddedToObjectInScene(project: Project, scene: Layout, objectName: string): void;
-  static objectOrGroupRenamedInEventsFunction(project: Project, projectScopedContainers: ProjectScopedContainers, eventsFunction: EventsFunction, oldName: string, newName: string, isObjectGroup: boolean): void;
+  static objectOrGroupRenamedInEventsFunction(project: Project, projectScopedContainers: ProjectScopedContainers, eventsFunction: EventsFunction, parameterObjectsContainer: ObjectsContainer, oldName: string, newName: string, isObjectGroup: boolean): void;
   static objectRemovedInEventsFunction(project: Project, eventsFunction: EventsFunction, objectName: string): void;
   static objectOrGroupRenamedInEventsBasedObject(project: Project, projectScopedContainers: ProjectScopedContainers, eventsBasedObject: EventsBasedObject, oldName: string, newName: string, isObjectGroup: boolean): void;
   static objectRemovedInEventsBasedObject(project: Project, eventsBasedObject: EventsBasedObject, objectName: string): void;
@@ -2170,22 +2192,22 @@ export class EventsFunctionsContainer extends EmscriptenObject {
 export class AbstractEventsBasedEntity extends EmscriptenObject {
   getEventsFunctions(): EventsFunctionsContainer;
   getPropertyDescriptors(): PropertiesContainer;
+  getName(): string;
+  getFullName(): string;
+  getDescription(): string;
+  isPrivate(): boolean;
   serializeTo(element: SerializerElement): void;
   unserializeFrom(project: Project, element: SerializerElement): void;
 }
 
 export class EventsBasedBehavior extends AbstractEventsBasedEntity {
   constructor();
-  setDescription(description: string): EventsBasedBehavior;
-  getDescription(): string;
   setName(name: string): EventsBasedBehavior;
-  getName(): string;
   setFullName(fullName: string): EventsBasedBehavior;
-  getFullName(): string;
+  setDescription(description: string): EventsBasedBehavior;
+  setPrivate(isPrivate: boolean): EventsBasedBehavior;
   setObjectType(fullName: string): EventsBasedBehavior;
   getObjectType(): string;
-  setPrivate(isPrivate: boolean): EventsBasedBehavior;
-  isPrivate(): boolean;
   setQuickCustomizationVisibility(visibility: QuickCustomization_Visibility): EventsBasedBehavior;
   getQuickCustomizationVisibility(): QuickCustomization_Visibility;
   getSharedPropertyDescriptors(): PropertiesContainer;
@@ -2215,12 +2237,10 @@ export class EventsBasedBehaviorsList extends EmscriptenObject {
 
 export class EventsBasedObject extends AbstractEventsBasedEntity {
   constructor();
-  setDescription(description: string): EventsBasedObject;
-  getDescription(): string;
   setName(name: string): EventsBasedObject;
-  getName(): string;
   setFullName(fullName: string): EventsBasedObject;
-  getFullName(): string;
+  setDescription(description: string): EventsBasedObject;
+  setPrivate(isPrivate: boolean): EventsBasedObject;
   setDefaultName(defaultName: string): EventsBasedObject;
   getDefaultName(): string;
   markAsRenderedIn3D(isRenderedIn3D: boolean): EventsBasedObject;
@@ -2315,6 +2335,9 @@ export class EventsFunctionsExtension extends EmscriptenObject {
   addDependency(): DependencyMetadata;
   removeDependencyAt(index: number): void;
   getAllDependencies(): VectorDependencyMetadata;
+  addSourceFile(): SourceFileMetadata;
+  removeSourceFileAt(index: number): void;
+  getAllSourceFiles(): VectorSourceFileMetadata;
   getGlobalVariables(): VariablesContainer;
   getSceneVariables(): VariablesContainer;
   getEventsBasedBehaviors(): EventsBasedBehaviorsList;

GDevelop.js/types/gdabstracteventsbasedentity.js

@@ -2,6 +2,10 @@
 declare class gdAbstractEventsBasedEntity {
   getEventsFunctions(): gdEventsFunctionsContainer;
   getPropertyDescriptors(): gdPropertiesContainer;
+  getName(): string;
+  getFullName(): string;
+  getDescription(): string;
+  isPrivate(): boolean;
   serializeTo(element: gdSerializerElement): void;
   unserializeFrom(project: gdProject, element: gdSerializerElement): void;
   delete(): void;

GDevelop.js/types/gdeventsbasedbehavior.js

@@ -1,16 +1,12 @@
 // Automatically generated by GDevelop.js/scripts/generate-types.js
 declare class gdEventsBasedBehavior extends gdAbstractEventsBasedEntity {
   constructor(): void;
-  setDescription(description: string): gdEventsBasedBehavior;
-  getDescription(): string;
   setName(name: string): gdEventsBasedBehavior;
-  getName(): string;
   setFullName(fullName: string): gdEventsBasedBehavior;
-  getFullName(): string;
+  setDescription(description: string): gdEventsBasedBehavior;
+  setPrivate(isPrivate: boolean): gdEventsBasedBehavior;
   setObjectType(fullName: string): gdEventsBasedBehavior;
   getObjectType(): string;
-  setPrivate(isPrivate: boolean): gdEventsBasedBehavior;
-  isPrivate(): boolean;
   setQuickCustomizationVisibility(visibility: QuickCustomization_Visibility): gdEventsBasedBehavior;
   getQuickCustomizationVisibility(): QuickCustomization_Visibility;
   getSharedPropertyDescriptors(): gdPropertiesContainer;

GDevelop.js/types/gdeventsbasedobject.js

@@ -1,12 +1,10 @@
 // Automatically generated by GDevelop.js/scripts/generate-types.js
 declare class gdEventsBasedObject extends gdAbstractEventsBasedEntity {
   constructor(): void;
-  setDescription(description: string): gdEventsBasedObject;
-  getDescription(): string;
   setName(name: string): gdEventsBasedObject;
-  getName(): string;
   setFullName(fullName: string): gdEventsBasedObject;
-  getFullName(): string;
+  setDescription(description: string): gdEventsBasedObject;
+  setPrivate(isPrivate: boolean): gdEventsBasedObject;
   setDefaultName(defaultName: string): gdEventsBasedObject;
   getDefaultName(): string;
   markAsRenderedIn3D(isRenderedIn3D: boolean): gdEventsBasedObject;

GDevelop.js/types/gdeventsfunctionsextension.js

@@ -31,6 +31,9 @@ declare class gdEventsFunctionsExtension extends gdEventsFunctionsContainer {
   addDependency(): gdDependencyMetadata;
   removeDependencyAt(index: number): void;
   getAllDependencies(): gdVectorDependencyMetadata;
+  addSourceFile(): gdSourceFileMetadata;
+  removeSourceFileAt(index: number): void;
+  getAllSourceFiles(): gdVectorSourceFileMetadata;
   getGlobalVariables(): gdVariablesContainer;
   getSceneVariables(): gdVariablesContainer;
   getEventsBasedBehaviors(): gdEventsBasedBehaviorsList;

GDevelop.js/types/gdeventsrefactorer.js

@@ -1,6 +1,6 @@
 // Automatically generated by GDevelop.js/scripts/generate-types.js
 declare class gdEventsRefactorer {
-  static renameObjectInEvents(platform: gdPlatform, projectScopedContainers: gdProjectScopedContainers, events: gdEventsList, oldName: string, newName: string): void;
+  static renameObjectInEvents(platform: gdPlatform, projectScopedContainers: gdProjectScopedContainers, events: gdEventsList, targetedObjectsContainer: gdObjectsContainer, oldName: string, newName: string): void;
   static replaceStringInEvents(project: gdObjectsContainer, layout: gdObjectsContainer, events: gdEventsList, toReplace: string, newString: string, matchCase: boolean, inConditions: boolean, inActions: boolean, inEventStrings: boolean): gdVectorEventsSearchResult;
   static searchInEvents(platform: gdPlatform, events: gdEventsList, search: string, matchCase: boolean, inConditions: boolean, inActions: boolean, inEventStrings: boolean, inEventSentences: boolean): gdVectorEventsSearchResult;
   delete(): void;

GDevelop.js/types/gdjavascriptresource.js

@@ -0,0 +1,6 @@
+// Automatically generated by GDevelop.js/scripts/generate-types.js
+declare class gdJavaScriptResource extends gdResource {
+  constructor(): void;
+  delete(): void;
+  ptr: number;
+};

GDevelop.js/types/gdobjectmetadata.js

@@ -24,6 +24,8 @@ declare class gdObjectMetadata {
   getDefaultBehaviors(): gdSetString;
   hasDefaultBehavior(behaviorType: string): boolean;
   addDefaultBehavior(behaviorType: string): gdObjectMetadata;
+  isPrivate(): boolean;
+  setPrivate(): gdObjectMetadata;
   setHidden(): gdObjectMetadata;
   isHidden(): boolean;
   markAsRenderedIn3D(): gdObjectMetadata;

GDevelop.js/types/gdplatformextension.js

@@ -55,6 +55,7 @@ declare class gdPlatformExtension {
   getAllStrExpressionsForBehavior(autoType: string): gdMapStringExpressionMetadata;
   getAllProperties(): gdMapStringPropertyDescriptor;
   getAllDependencies(): gdVectorDependencyMetadata;
+  getAllSourceFiles(): gdVectorSourceFileMetadata;
   static getNamespaceSeparator(): string;
   static getBehaviorFullType(extensionName: string, behaviorName: string): string;
   static getObjectFullType(extensionName: string, objectName: string): string;

GDevelop.js/types/gdproject.js

@@ -99,6 +99,7 @@ declare class gdProject {
   insertEventsFunctionsExtension(eventsFunctionsExtension: gdEventsFunctionsExtension, position: number): gdEventsFunctionsExtension;
   removeEventsFunctionsExtension(name: string): void;
   getEventsFunctionsExtensionPosition(name: string): number;
+  unserializeAndInsertExtensionsFrom(eventsFunctionsExtensionsElement: gdSerializerElement): void;
   hasEventsBasedBehavior(type: string): boolean;
   getEventsBasedBehavior(type: string): gdEventsBasedBehavior;
   hasEventsBasedObject(type: string): boolean;

GDevelop.js/types/gdsourcefilemetadata.js

@@ -0,0 +1,10 @@
+// Automatically generated by GDevelop.js/scripts/generate-types.js
+declare class gdSourceFileMetadata {
+  constructor(): void;
+  getResourceName(): string;
+  setResourceName(resourceName_: string): gdSourceFileMetadata;
+  getIncludePosition(): string;
+  setIncludePosition(includePosition_: string): gdSourceFileMetadata;
+  delete(): void;
+  ptr: number;
+};

GDevelop.js/types/gdvectorsourcefilemetadata.js

@@ -0,0 +1,7 @@
+// Automatically generated by GDevelop.js/scripts/generate-types.js
+declare class gdVectorSourceFileMetadata {
+  size(): number;
+  at(index: number): gdSourceFileMetadata;
+  delete(): void;
+  ptr: number;
+};