gdcore-tools 1.0.8 → 1.0.9

package/examples/create-objects-from-json/index.js

@@ -1,50 +1,50 @@
-const loadGD = require("../..");
-const list = require("./mylist.json");
-
-let gdTools;
-loadGD()
-  .then((_gdTools) => {
-    gdTools = _gdTools;
-    // Load the project file
-    return gdTools.loadProject("./game.json");
-  })
-  .then((project) => {
-    // Get the scene and add the objects and instances from the list
-    const scene = project.getLayout(/* Scene name: */ "MyScene");
-    const instances = scene.getInitialInstances();
-    let offset = 1;
-    list.forEach((item) => {
-      const textObjectName = "MyListItem_" + item;
-      const object = gdTools.gd.asTextObject(
-        scene.insertNewObject(
-          /* Project: */ project,
-          /* Object type: */ "TextObject::Text",
-          /* Object name: */ textObjectName,
-          /* Position where to insert: */ scene.getObjectsCount()
-        )
-      );
-      object.setString(item);
-      object.setColor(
-        Math.random() * 255,
-        Math.random() * 255,
-        Math.random() * 255
-      );
-
-      const textObjectInstance = instances.insertNewInitialInstance();
-      const spriteObjectInstance = instances.insertNewInitialInstance();
-      textObjectInstance.setObjectName(textObjectName);
-      spriteObjectInstance.setObjectName("Button");
-      textObjectInstance.setX(50);
-      spriteObjectInstance.setX(40);
-      textObjectInstance.setY(70 * offset + 15);
-      spriteObjectInstance.setY(70 * offset++);
-      textObjectInstance.setZOrder(1);
-      spriteObjectInstance.setZOrder(0);
-
-      spriteObjectInstance.setHasCustomSize(true);
-      spriteObjectInstance.setCustomHeight(48);
-      spriteObjectInstance.setCustomWidth(96);
-    });
-
-    return gdTools.saveProject(project, "new_game.json");
-  });
+const loadGD = require("../..");
+const list = require("./mylist.json");
+
+let gdTools;
+loadGD()
+  .then((_gdTools) => {
+    gdTools = _gdTools;
+    // Load the project file
+    return gdTools.loadProject("./game.json");
+  })
+  .then((project) => {
+    // Get the scene and add the objects and instances from the list
+    const scene = project.getLayout(/* Scene name: */ "MyScene");
+    const instances = scene.getInitialInstances();
+    let offset = 1;
+    list.forEach((item) => {
+      const textObjectName = "MyListItem_" + item;
+      const object = gdTools.gd.asTextObject(
+        scene.insertNewObject(
+          /* Project: */ project,
+          /* Object type: */ "TextObject::Text",
+          /* Object name: */ textObjectName,
+          /* Position where to insert: */ scene.getObjectsCount()
+        )
+      );
+      object.setString(item);
+      object.setColor(
+        Math.random() * 255,
+        Math.random() * 255,
+        Math.random() * 255
+      );
+
+      const textObjectInstance = instances.insertNewInitialInstance();
+      const spriteObjectInstance = instances.insertNewInitialInstance();
+      textObjectInstance.setObjectName(textObjectName);
+      spriteObjectInstance.setObjectName("Button");
+      textObjectInstance.setX(50);
+      spriteObjectInstance.setX(40);
+      textObjectInstance.setY(70 * offset + 15);
+      spriteObjectInstance.setY(70 * offset++);
+      textObjectInstance.setZOrder(1);
+      spriteObjectInstance.setZOrder(0);
+
+      spriteObjectInstance.setHasCustomSize(true);
+      spriteObjectInstance.setCustomHeight(48);
+      spriteObjectInstance.setCustomWidth(96);
+    });
+
+    return gdTools.saveProject(project, "new_game.json");
+  });

package/examples/export-game/game.json

@@ -1,205 +1,205 @@
-{
-  "firstLayout": "",
-  "gdVersion": {
-    "build": 99,
-    "major": 4,
-    "minor": 0,
-    "revision": 0
-  },
-  "properties": {
-    "adaptGameResolutionAtRuntime": true,
-    "folderProject": false,
-    "orientation": "landscape",
-    "packageName": "com.example.gamename",
-    "projectUuid": "b0ec0124-f3d9-4225-bfb5-60645a43b358",
-    "scaleMode": "linear",
-    "sizeOnStartupMode": "",
-    "useExternalSourceFiles": false,
-    "version": "1.0.0",
-    "name": "Project",
-    "author": "",
-    "windowWidth": 800,
-    "windowHeight": 600,
-    "latestCompilationDirectory": "",
-    "maxFPS": 60,
-    "minFPS": 20,
-    "verticalSync": false,
-    "platformSpecificAssets": {},
-    "loadingScreen": {
-      "showGDevelopSplash": true
-    },
-    "extensionProperties": [],
-    "extensions": [
-      {
-        "name": "BuiltinObject"
-      },
-      {
-        "name": "BuiltinAudio"
-      },
-      {
-        "name": "BuiltinVariables"
-      },
-      {
-        "name": "BuiltinTime"
-      },
-      {
-        "name": "BuiltinMouse"
-      },
-      {
-        "name": "BuiltinKeyboard"
-      },
-      {
-        "name": "BuiltinJoystick"
-      },
-      {
-        "name": "BuiltinCamera"
-      },
-      {
-        "name": "BuiltinWindow"
-      },
-      {
-        "name": "BuiltinFile"
-      },
-      {
-        "name": "BuiltinNetwork"
-      },
-      {
-        "name": "BuiltinScene"
-      },
-      {
-        "name": "BuiltinAdvanced"
-      },
-      {
-        "name": "Sprite"
-      },
-      {
-        "name": "BuiltinCommonInstructions"
-      },
-      {
-        "name": "BuiltinCommonConversions"
-      },
-      {
-        "name": "BuiltinStringInstructions"
-      },
-      {
-        "name": "BuiltinMathematicalTools"
-      },
-      {
-        "name": "BuiltinExternalLayouts"
-      }
-    ],
-    "platforms": [
-      {
-        "name": "GDevelop JS platform"
-      }
-    ],
-    "currentPlatform": "GDevelop JS platform"
-  },
-  "resources": {
-    "resources": [],
-    "resourceFolders": []
-  },
-  "objects": [],
-  "objectsGroups": [],
-  "variables": [],
-  "layouts": [
-    {
-      "b": 209,
-      "disableInputWhenNotFocused": true,
-      "mangledName": "New_32scene",
-      "name": "New scene",
-      "oglFOV": 90,
-      "oglZFar": 500,
-      "oglZNear": 1,
-      "r": 209,
-      "standardSortMethod": true,
-      "stopSoundsOnStartup": true,
-      "title": "",
-      "v": 209,
-      "uiSettings": {
-        "grid": false,
-        "gridB": 255,
-        "gridG": 180,
-        "gridHeight": 32,
-        "gridOffsetX": 0,
-        "gridOffsetY": 0,
-        "gridR": 158,
-        "gridWidth": 32,
-        "snap": true,
-        "windowMask": false,
-        "zoomFactor": 0.7662
-      },
-      "objectsGroups": [],
-      "variables": [],
-      "instances": [
-        {
-          "angle": 0,
-          "customSize": false,
-          "height": 0,
-          "layer": "",
-          "locked": false,
-          "name": "Test",
-          "persistentUuid": "f65d2b44-652d-4fdf-a603-05e48a9cf5ef",
-          "width": 0,
-          "x": 247,
-          "y": 279,
-          "zOrder": 1,
-          "numberProperties": [],
-          "stringProperties": [],
-          "initialVariables": []
-        }
-      ],
-      "objects": [
-        {
-          "bold": false,
-          "italic": false,
-          "name": "Test",
-          "smoothed": true,
-          "tags": "",
-          "type": "TextObject::Text",
-          "underlined": false,
-          "variables": [],
-          "behaviors": [],
-          "string": "Test exporting via gdcore-tools",
-          "font": "",
-          "characterSize": 20,
-          "color": {
-            "b": 0,
-            "g": 0,
-            "r": 0
-          }
-        }
-      ],
-      "events": [],
-      "layers": [
-        {
-          "ambientLightColorB": 16,
-          "ambientLightColorG": 0,
-          "ambientLightColorR": 0,
-          "followBaseLayerCamera": false,
-          "isLightingLayer": false,
-          "name": "",
-          "visibility": true,
-          "cameras": [
-            {
-              "defaultSize": true,
-              "defaultViewport": true,
-              "height": 0,
-              "viewportBottom": 1,
-              "viewportLeft": 0,
-              "viewportRight": 1,
-              "viewportTop": 0,
-              "width": 0
-            }
-          ],
-          "effects": []
-        }
-      ],
-      "behaviorsSharedData": []
-    }
-  ],
-  "externalEvents": [],
-  "eventsFunctionsExtensions": [],
-  "externalLayouts": [],
-  "externalSourceFiles": []
+{
+  "firstLayout": "",
+  "gdVersion": {
+    "build": 99,
+    "major": 4,
+    "minor": 0,
+    "revision": 0
+  },
+  "properties": {
+    "adaptGameResolutionAtRuntime": true,
+    "folderProject": false,
+    "orientation": "landscape",
+    "packageName": "com.example.gamename",
+    "projectUuid": "b0ec0124-f3d9-4225-bfb5-60645a43b358",
+    "scaleMode": "linear",
+    "sizeOnStartupMode": "",
+    "useExternalSourceFiles": false,
+    "version": "1.0.0",
+    "name": "Project",
+    "author": "",
+    "windowWidth": 800,
+    "windowHeight": 600,
+    "latestCompilationDirectory": "",
+    "maxFPS": 60,
+    "minFPS": 20,
+    "verticalSync": false,
+    "platformSpecificAssets": {},
+    "loadingScreen": {
+      "showGDevelopSplash": true
+    },
+    "extensionProperties": [],
+    "extensions": [
+      {
+        "name": "BuiltinObject"
+      },
+      {
+        "name": "BuiltinAudio"
+      },
+      {
+        "name": "BuiltinVariables"
+      },
+      {
+        "name": "BuiltinTime"
+      },
+      {
+        "name": "BuiltinMouse"
+      },
+      {
+        "name": "BuiltinKeyboard"
+      },
+      {
+        "name": "BuiltinJoystick"
+      },
+      {
+        "name": "BuiltinCamera"
+      },
+      {
+        "name": "BuiltinWindow"
+      },
+      {
+        "name": "BuiltinFile"
+      },
+      {
+        "name": "BuiltinNetwork"
+      },
+      {
+        "name": "BuiltinScene"
+      },
+      {
+        "name": "BuiltinAdvanced"
+      },
+      {
+        "name": "Sprite"
+      },
+      {
+        "name": "BuiltinCommonInstructions"
+      },
+      {
+        "name": "BuiltinCommonConversions"
+      },
+      {
+        "name": "BuiltinStringInstructions"
+      },
+      {
+        "name": "BuiltinMathematicalTools"
+      },
+      {
+        "name": "BuiltinExternalLayouts"
+      }
+    ],
+    "platforms": [
+      {
+        "name": "GDevelop JS platform"
+      }
+    ],
+    "currentPlatform": "GDevelop JS platform"
+  },
+  "resources": {
+    "resources": [],
+    "resourceFolders": []
+  },
+  "objects": [],
+  "objectsGroups": [],
+  "variables": [],
+  "layouts": [
+    {
+      "b": 209,
+      "disableInputWhenNotFocused": true,
+      "mangledName": "New_32scene",
+      "name": "New scene",
+      "oglFOV": 90,
+      "oglZFar": 500,
+      "oglZNear": 1,
+      "r": 209,
+      "standardSortMethod": true,
+      "stopSoundsOnStartup": true,
+      "title": "",
+      "v": 209,
+      "uiSettings": {
+        "grid": false,
+        "gridB": 255,
+        "gridG": 180,
+        "gridHeight": 32,
+        "gridOffsetX": 0,
+        "gridOffsetY": 0,
+        "gridR": 158,
+        "gridWidth": 32,
+        "snap": true,
+        "windowMask": false,
+        "zoomFactor": 0.7662
+      },
+      "objectsGroups": [],
+      "variables": [],
+      "instances": [
+        {
+          "angle": 0,
+          "customSize": false,
+          "height": 0,
+          "layer": "",
+          "locked": false,
+          "name": "Test",
+          "persistentUuid": "f65d2b44-652d-4fdf-a603-05e48a9cf5ef",
+          "width": 0,
+          "x": 247,
+          "y": 279,
+          "zOrder": 1,
+          "numberProperties": [],
+          "stringProperties": [],
+          "initialVariables": []
+        }
+      ],
+      "objects": [
+        {
+          "bold": false,
+          "italic": false,
+          "name": "Test",
+          "smoothed": true,
+          "tags": "",
+          "type": "TextObject::Text",
+          "underlined": false,
+          "variables": [],
+          "behaviors": [],
+          "string": "Test exporting via gdcore-tools",
+          "font": "",
+          "characterSize": 20,
+          "color": {
+            "b": 0,
+            "g": 0,
+            "r": 0
+          }
+        }
+      ],
+      "events": [],
+      "layers": [
+        {
+          "ambientLightColorB": 16,
+          "ambientLightColorG": 0,
+          "ambientLightColorR": 0,
+          "followBaseLayerCamera": false,
+          "isLightingLayer": false,
+          "name": "",
+          "visibility": true,
+          "cameras": [
+            {
+              "defaultSize": true,
+              "defaultViewport": true,
+              "height": 0,
+              "viewportBottom": 1,
+              "viewportLeft": 0,
+              "viewportRight": 1,
+              "viewportTop": 0,
+              "width": 0
+            }
+          ],
+          "effects": []
+        }
+      ],
+      "behaviorsSharedData": []
+    }
+  ],
+  "externalEvents": [],
+  "eventsFunctionsExtensions": [],
+  "externalLayouts": [],
+  "externalSourceFiles": []
 }

package/examples/export-game/index.js

@@ -1,13 +1,13 @@
-// Note: for exporting games programatically, look into GDExporter.
-// https://github.com/arthuro555/gdexporter
-
-const loadGD = require("../..");
-
-let gdTools;
-loadGD()
-  .then((_gdTools) => {
-    gdTools = _gdTools;
-    // Load the project file
-    return gdTools.loadProject("./game.json");
-  })
-  .then((project) => gdTools.exportProject(project, "GameExport"));
+// Note: for exporting games programatically, look into GDExporter.
+// https://github.com/arthuro555/gdexporter
+
+const loadGD = require("../..");
+
+let gdTools;
+loadGD()
+  .then((_gdTools) => {
+    gdTools = _gdTools;
+    // Load the project file
+    return gdTools.loadProject("./game.json");
+  })
+  .then((project) => gdTools.exportProject(project, "GameExport"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdcore-tools",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "A package that downloads and bootstraps any version of GDevelops Core library",
   "main": "src/index.js",
   "repository": {

package/src/EventsFunctionsExtensionsLoader/index.js

@@ -27,16 +27,8 @@ const getObjectFunctionCodeNamespace = (
 };
 
 module.exports.makeLoader = (gd) => {
-  const {
-    declareInstructionOrExpressionMetadata,
-    declareBehaviorInstructionOrExpressionMetadata,
-    declareEventsFunctionParameters,
-    declareBehaviorMetadata,
-    declareExtension,
-    isBehaviorLifecycleEventsFunction,
-    isExtensionLifecycleEventsFunction,
-    declareBehaviorPropertiesInstructionAndExpressions,
-  } = require("./MetadataDeclarationHelpers")(gd);
+  const { isExtensionLifecycleEventsFunction } =
+    require("./MetadataDeclarationHelpers")(gd);
 
   const loader = {};
 
@@ -135,7 +127,10 @@ module.exports.makeLoader = (gd) => {
     options
   ) => {
     const extension = new gd.PlatformExtension();
-    declareExtension(extension, eventsFunctionsExtension);
+    gd.MetadataDeclarationHelper.declareExtension(
+      extension,
+      eventsFunctionsExtension
+    );
 
     const codeNamespacePrefix =
       "gdjs.evtsExt__" + mangleName(eventsFunctionsExtension.getName());
@@ -168,24 +163,22 @@ module.exports.makeLoader = (gd) => {
       )
     )
       .then(() =>
-        !gd.MetadataDeclarationHelper
-          ? Promise.resolve()
-          : // Generate all objects and their functions
-            Promise.all(
-              mapVector(
-                eventsFunctionsExtension.getEventsBasedObjects(),
-                (eventsBasedObject) => {
-                  return generateObject(
-                    project,
-                    extension,
-                    eventsFunctionsExtension,
-                    eventsBasedObject,
-                    options,
-                    codeGenerationContext
-                  );
-                }
-              )
-            )
+        // Generate all objects and their functions
+        Promise.all(
+          mapVector(
+            eventsFunctionsExtension.getEventsBasedObjects(),
+            (eventsBasedObject) => {
+              return generateObject(
+                project,
+                extension,
+                eventsFunctionsExtension,
+                eventsBasedObject,
+                options,
+                codeGenerationContext
+              );
+            }
+          )
+        )
       )
       .then(() =>
         // Generate all free functions
@@ -204,7 +197,9 @@ module.exports.makeLoader = (gd) => {
           })
         )
       )
-      .then(() => extension);
+      .then((functionInfos) => {
+        return extension;
+      });
   };
 
   const generateFreeFunction = (
@@ -215,46 +210,28 @@ module.exports.makeLoader = (gd) => {
     options,
     codeGenerationContext
   ) => {
-    const instructionOrExpression = declareInstructionOrExpressionMetadata(
+    const metadataDeclarationHelper = new gd.MetadataDeclarationHelper();
+    const { functionMetadata } = generateFreeFunctionMetadata(
+      project,
       extension,
       eventsFunctionsExtension,
-      eventsFunction
-    );
-    // By convention, first parameter is always the Runtime Scene.
-    instructionOrExpression.addCodeOnlyParameter("currentScene", "");
-    declareEventsFunctionParameters(eventsFunction, instructionOrExpression);
-
-    // Hide "lifecycle" functions as they are called automatically by
-    // the game engine.
-    if (isExtensionLifecycleEventsFunction(eventsFunction.getName())) {
-      instructionOrExpression.setHidden();
-    }
-
-    const codeNamespace = getFreeFunctionCodeNamespace(
       eventsFunction,
-      codeGenerationContext.codeNamespacePrefix
+      options,
+      codeGenerationContext,
+      metadataDeclarationHelper
     );
-    const functionName = codeNamespace + ".func";
-
-    const codeExtraInformation =
-      instructionOrExpression.getCodeExtraInformation();
-    codeExtraInformation
-      .setIncludeFile(
-        options.eventsFunctionCodeWriter.getIncludeFileFor(functionName)
-      )
-      .setFunctionName(functionName);
-
-    // Always include the extension include files when using a free function.
-    codeGenerationContext.extensionIncludeFiles.forEach((includeFile) => {
-      codeExtraInformation.addIncludeFile(includeFile);
-    });
 
     if (!options.skipCodeGeneration) {
       const includeFiles = new gd.SetString();
       const eventsFunctionsExtensionCodeGenerator =
         new gd.EventsFunctionsExtensionCodeGenerator(project);
+      const codeNamespace = getFreeFunctionCodeNamespace(
+        eventsFunction,
+        codeGenerationContext.codeNamespacePrefix
+      );
       const code =
         eventsFunctionsExtensionCodeGenerator.generateFreeEventsFunctionCompleteCode(
+          eventsFunctionsExtension,
           eventsFunction,
           codeNamespace,
           includeFiles,
@@ -271,15 +248,18 @@ module.exports.makeLoader = (gd) => {
         .toNewVectorString()
         .toJSArray()
         .forEach((includeFile) => {
-          codeExtraInformation.addIncludeFile(includeFile);
+          functionMetadata.addIncludeFile(includeFile);
         });
 
       includeFiles.delete();
-
-      return options.eventsFunctionCodeWriter.writeFunctionCode(
-        functionName,
-        code
-      );
+      eventsFunctionsExtensionCodeGenerator.delete();
+      metadataDeclarationHelper.delete();
+
+      // TODO Implement an helper function for free function names.
+      const functionName = codeNamespace + ".func";
+      return options.eventsFunctionCodeWriter
+        .writeFunctionCode(functionName, code)
+        .then(() => {});
     } else {
       // Skip code generation if no events function writer is provided.
       // This is the case during the "first pass", where all events functions extensions
@@ -289,79 +269,71 @@ module.exports.makeLoader = (gd) => {
     }
   };
 
-  function generateBehavior(
+  const generateFreeFunctionMetadata = (
     project,
     extension,
     eventsFunctionsExtension,
-    eventsBasedBehavior,
+    eventsFunction,
     options,
-    codeGenerationContext
-  ) {
-    const behaviorMetadata = declareBehaviorMetadata(
-      extension,
-      eventsBasedBehavior
+    codeGenerationContext,
+    metadataDeclarationHelper
+  ) => {
+    const instructionOrExpression =
+      metadataDeclarationHelper.generateFreeFunctionMetadata(
+        project,
+        extension,
+        eventsFunctionsExtension,
+        eventsFunction
+      );
+    const functionName = gd.MetadataDeclarationHelper.getFreeFunctionCodeName(
+      eventsFunctionsExtension,
+      eventsFunction
     );
+    const functionFile =
+      options.eventsFunctionCodeWriter.getIncludeFileFor(functionName);
+    instructionOrExpression.setIncludeFile(functionFile);
 
-    const eventsFunctionsContainer = eventsBasedBehavior.getEventsFunctions();
-    const codeNamespace = getBehaviorFunctionCodeNamespace(
-      eventsBasedBehavior,
-      codeGenerationContext.codeNamespacePrefix
-    );
-    const includeFile =
-      options.eventsFunctionCodeWriter.getIncludeFileFor(codeNamespace);
-
-    behaviorMetadata.setIncludeFile(includeFile);
-
-    // Always include the extension include files when using a behavior.
+    // Always include the extension include files when using a free function.
     codeGenerationContext.extensionIncludeFiles.forEach((includeFile) => {
-      behaviorMetadata.addIncludeFile(includeFile);
+      instructionOrExpression.addIncludeFile(includeFile);
     });
 
+    // Skip code generation if no events function writer is provided.
+    // This is the case during the "first pass", where all events functions extensions
+    // are loaded as extensions but not code generated, as events in functions could
+    // themselves be using functions that are not yet available in extensions.
+    return {
+      functionFile: functionFile,
+      functionMetadata: instructionOrExpression,
+    };
+  };
+
+  function generateBehavior(
+    project,
+    extension,
+    eventsFunctionsExtension,
+    eventsBasedBehavior,
+    options,
+    codeGenerationContext
+  ) {
     return Promise.resolve().then(() => {
       const behaviorMethodMangledNames = new gd.MapStringString();
-
-      // Declare the instructions/expressions for properties
-      declareBehaviorPropertiesInstructionAndExpressions(
-        behaviorMetadata,
-        eventsBasedBehavior
+      const behaviorMetadata = generateBehaviorMetadata(
+        project,
+        extension,
+        eventsFunctionsExtension,
+        eventsBasedBehavior,
+        options,
+        codeGenerationContext,
+        behaviorMethodMangledNames
       );
 
-      // Declare all the behavior functions
-      mapFor(0, eventsFunctionsContainer.getEventsFunctionsCount(), (i) => {
-        const eventsFunction = eventsFunctionsContainer.getEventsFunctionAt(i);
-
-        const eventsFunctionMangledName = mangleName(eventsFunction.getName());
-        behaviorMethodMangledNames.set(
-          eventsFunction.getName(),
-          eventsFunctionMangledName
-        );
-
-        const instructionOrExpression =
-          declareBehaviorInstructionOrExpressionMetadata(
-            behaviorMetadata,
-            eventsBasedBehavior,
-            eventsFunction
-          );
-        declareEventsFunctionParameters(
-          eventsFunction,
-          instructionOrExpression
-        );
-
-        // Hide "lifecycle" methods as they are called automatically by
-        // the game engine.
-        if (isBehaviorLifecycleEventsFunction(eventsFunction.getName())) {
-          instructionOrExpression.setHidden();
-        }
-
-        const codeExtraInformation =
-          instructionOrExpression.getCodeExtraInformation();
-        codeExtraInformation
-          .setIncludeFile(includeFile)
-          .setFunctionName(eventsFunctionMangledName);
-      });
-
       // Generate code for the behavior and its methods
       if (!options.skipCodeGeneration) {
+        const codeNamespace = getBehaviorFunctionCodeNamespace(
+          eventsBasedBehavior,
+          codeGenerationContext.codeNamespacePrefix
+        );
         const includeFiles = new gd.SetString();
         const behaviorCodeGenerator = new gd.BehaviorCodeGenerator(project);
         const code = behaviorCodeGenerator.generateRuntimeBehaviorCompleteCode(
@@ -403,6 +375,41 @@ module.exports.makeLoader = (gd) => {
     });
   }
 
+  function generateBehaviorMetadata(
+    project,
+    extension,
+    eventsFunctionsExtension,
+    eventsBasedBehavior,
+    options,
+    codeGenerationContext,
+    behaviorMethodMangledNames
+  ) {
+    const behaviorMetadata =
+      gd.MetadataDeclarationHelper.generateBehaviorMetadata(
+        project,
+        extension,
+        eventsFunctionsExtension,
+        eventsBasedBehavior,
+        behaviorMethodMangledNames
+      );
+
+    const codeNamespace = getBehaviorFunctionCodeNamespace(
+      eventsBasedBehavior,
+      codeGenerationContext.codeNamespacePrefix
+    );
+    const includeFile =
+      options.eventsFunctionCodeWriter.getIncludeFileFor(codeNamespace);
+
+    behaviorMetadata.setIncludeFile(includeFile);
+
+    // Always include the extension include files when using a behavior.
+    codeGenerationContext.extensionIncludeFiles.forEach((includeFile) => {
+      behaviorMetadata.addIncludeFile(includeFile);
+    });
+
+    return behaviorMetadata;
+  }
+
   function generateObject(
     project,
     extension,

package/src/EventsFunctionsExtensionsLoader/legacy.js

@@ -0,0 +1,451 @@
+const { mapVector, mapFor } = require("../MapFor");
+const { caseSensitiveSlug } = require("../CaseSensitiveSlug");
+
+const mangleName = (name) => {
+  return caseSensitiveSlug(name, "_", []);
+};
+
+/** Generate the namespace for a free function. */
+const getFreeFunctionCodeNamespace = (eventsFunction, codeNamespacePrefix) => {
+  return codeNamespacePrefix + "__" + mangleName(eventsFunction.getName());
+};
+
+/** Generate the namespace for a behavior function. */
+const getBehaviorFunctionCodeNamespace = (
+  eventsBasedBehavior,
+  codeNamespacePrefix
+) => {
+  return codeNamespacePrefix + "__" + mangleName(eventsBasedBehavior.getName());
+};
+
+module.exports.makeLoader = (gd) => {
+  const {
+    declareInstructionOrExpressionMetadata,
+    declareBehaviorInstructionOrExpressionMetadata,
+    declareEventsFunctionParameters,
+    declareBehaviorMetadata,
+    declareExtension,
+    isBehaviorLifecycleEventsFunction,
+    isExtensionLifecycleEventsFunction,
+    declareBehaviorPropertiesInstructionAndExpressions,
+  } = require("./MetadataDeclarationHelpers")(gd);
+
+  const loader = {};
+
+  /**
+   * Load all events functions of a project in extensions
+   */
+  const loadProjectEventsFunctionsExtensions = (
+    project,
+    eventsFunctionCodeWriter
+  ) => {
+    return Promise.all(
+      // First pass: generate extensions from the events functions extensions,
+      // without writing code for the functions. This is useful as events in functions
+      // could be using other functions, which would not yet be available as
+      // extensions.
+      mapFor(0, project.getEventsFunctionsExtensionsCount(), (i) => {
+        return loadProjectEventsFunctionsExtension(
+          project,
+          project.getEventsFunctionsExtensionAt(i),
+          { skipCodeGeneration: true, eventsFunctionCodeWriter }
+        );
+      })
+    ).then(() =>
+      Promise.all(
+        // Second pass: generate extensions, including code.
+        mapFor(0, project.getEventsFunctionsExtensionsCount(), (i) => {
+          return loadProjectEventsFunctionsExtension(
+            project,
+            project.getEventsFunctionsExtensionAt(i),
+            {
+              skipCodeGeneration: false,
+              eventsFunctionCodeWriter,
+            }
+          );
+        })
+      )
+    );
+  };
+  loader.loadProjectEventsFunctionsExtensions =
+    loadProjectEventsFunctionsExtensions;
+
+  const loadProjectEventsFunctionsExtension = (
+    project,
+    eventsFunctionsExtension,
+    options
+  ) => {
+    return generateEventsFunctionExtension(
+      project,
+      eventsFunctionsExtension,
+      options
+    ).then((extension) => {
+      gd.JsPlatform.get().addNewExtension(extension);
+      extension.delete();
+    });
+  };
+
+  /**
+   * Get the list of mandatory include files when using the
+   * extension.
+   */
+  const getExtensionIncludeFiles = (
+    project,
+    eventsFunctionsExtension,
+    options,
+    codeNamespacePrefix
+  ) => {
+    return mapFor(
+      0,
+      eventsFunctionsExtension.getEventsFunctionsCount(),
+      (i) => {
+        const eventsFunction = eventsFunctionsExtension.getEventsFunctionAt(i);
+
+        if (isExtensionLifecycleEventsFunction(eventsFunction.getName())) {
+          const codeNamespace = getFreeFunctionCodeNamespace(
+            eventsFunction,
+            codeNamespacePrefix
+          );
+          const functionName = codeNamespace + ".func"; // TODO
+
+          return options.eventsFunctionCodeWriter.getIncludeFileFor(
+            functionName
+          );
+        }
+
+        return null;
+      }
+    ).filter(Boolean);
+  };
+
+  /**
+   * Generate the code for the events based extension
+   */
+  const generateEventsFunctionExtension = (
+    project,
+    eventsFunctionsExtension,
+    options
+  ) => {
+    const extension = new gd.PlatformExtension();
+    declareExtension(extension, eventsFunctionsExtension);
+
+    const codeNamespacePrefix =
+      "gdjs.evtsExt__" + mangleName(eventsFunctionsExtension.getName());
+
+    const extensionIncludeFiles = getExtensionIncludeFiles(
+      project,
+      eventsFunctionsExtension,
+      options,
+      codeNamespacePrefix
+    );
+    const codeGenerationContext = {
+      codeNamespacePrefix,
+      extensionIncludeFiles,
+    };
+
+    return Promise.all(
+      // Generate all behaviors and their functions
+      mapVector(
+        eventsFunctionsExtension.getEventsBasedBehaviors(),
+        (eventsBasedBehavior) => {
+          return generateBehavior(
+            project,
+            extension,
+            eventsFunctionsExtension,
+            eventsBasedBehavior,
+            options,
+            codeGenerationContext
+          );
+        }
+      )
+    )
+      .then(() =>
+        // Generate all free functions
+        Promise.all(
+          mapFor(0, eventsFunctionsExtension.getEventsFunctionsCount(), (i) => {
+            const eventsFunction =
+              eventsFunctionsExtension.getEventsFunctionAt(i);
+            return generateFreeFunction(
+              project,
+              extension,
+              eventsFunctionsExtension,
+              eventsFunction,
+              options,
+              codeGenerationContext
+            );
+          })
+        )
+      )
+      .then(() => extension);
+  };
+
+  const generateFreeFunction = (
+    project,
+    extension,
+    eventsFunctionsExtension,
+    eventsFunction,
+    options,
+    codeGenerationContext
+  ) => {
+    const instructionOrExpression = declareInstructionOrExpressionMetadata(
+      extension,
+      eventsFunctionsExtension,
+      eventsFunction
+    );
+    // By convention, first parameter is always the Runtime Scene.
+    instructionOrExpression.addCodeOnlyParameter("currentScene", "");
+    declareEventsFunctionParameters(eventsFunction, instructionOrExpression);
+
+    // Hide "lifecycle" functions as they are called automatically by
+    // the game engine.
+    if (isExtensionLifecycleEventsFunction(eventsFunction.getName())) {
+      instructionOrExpression.setHidden();
+    }
+
+    const codeNamespace = getFreeFunctionCodeNamespace(
+      eventsFunction,
+      codeGenerationContext.codeNamespacePrefix
+    );
+    const functionName = codeNamespace + ".func";
+
+    const codeExtraInformation =
+      instructionOrExpression.getCodeExtraInformation();
+    codeExtraInformation
+      .setIncludeFile(
+        options.eventsFunctionCodeWriter.getIncludeFileFor(functionName)
+      )
+      .setFunctionName(functionName);
+
+    // Always include the extension include files when using a free function.
+    codeGenerationContext.extensionIncludeFiles.forEach((includeFile) => {
+      codeExtraInformation.addIncludeFile(includeFile);
+    });
+
+    if (!options.skipCodeGeneration) {
+      const includeFiles = new gd.SetString();
+      const eventsFunctionsExtensionCodeGenerator =
+        new gd.EventsFunctionsExtensionCodeGenerator(project);
+      const code =
+        eventsFunctionsExtensionCodeGenerator.generateFreeEventsFunctionCompleteCode(
+          eventsFunction,
+          codeNamespace,
+          includeFiles,
+          // For now, always generate functions for runtime (this disables
+          // generation of profiling for groups (see EventsCodeGenerator))
+          // as extensions generated can be used either for preview or export.
+          true
+        );
+
+      // Add any include file required by the function to the list
+      // of include files for this function (so that when used, the "dependencies"
+      // are transitively included).
+      includeFiles
+        .toNewVectorString()
+        .toJSArray()
+        .forEach((includeFile) => {
+          codeExtraInformation.addIncludeFile(includeFile);
+        });
+
+      includeFiles.delete();
+
+      return options.eventsFunctionCodeWriter.writeFunctionCode(
+        functionName,
+        code
+      );
+    } else {
+      // Skip code generation if no events function writer is provided.
+      // This is the case during the "first pass", where all events functions extensions
+      // are loaded as extensions but not code generated, as events in functions could
+      // themselves be using functions that are not yet available in extensions.
+      return Promise.resolve();
+    }
+  };
+
+  function generateBehavior(
+    project,
+    extension,
+    eventsFunctionsExtension,
+    eventsBasedBehavior,
+    options,
+    codeGenerationContext
+  ) {
+    const behaviorMetadata = declareBehaviorMetadata(
+      extension,
+      eventsBasedBehavior
+    );
+
+    const eventsFunctionsContainer = eventsBasedBehavior.getEventsFunctions();
+    const codeNamespace = getBehaviorFunctionCodeNamespace(
+      eventsBasedBehavior,
+      codeGenerationContext.codeNamespacePrefix
+    );
+    const includeFile =
+      options.eventsFunctionCodeWriter.getIncludeFileFor(codeNamespace);
+
+    behaviorMetadata.setIncludeFile(includeFile);
+
+    // Always include the extension include files when using a behavior.
+    codeGenerationContext.extensionIncludeFiles.forEach((includeFile) => {
+      behaviorMetadata.addIncludeFile(includeFile);
+    });
+
+    return Promise.resolve().then(() => {
+      const behaviorMethodMangledNames = new gd.MapStringString();
+
+      // Declare the instructions/expressions for properties
+      declareBehaviorPropertiesInstructionAndExpressions(
+        behaviorMetadata,
+        eventsBasedBehavior
+      );
+
+      // Declare all the behavior functions
+      mapFor(0, eventsFunctionsContainer.getEventsFunctionsCount(), (i) => {
+        const eventsFunction = eventsFunctionsContainer.getEventsFunctionAt(i);
+
+        const eventsFunctionMangledName = mangleName(eventsFunction.getName());
+        behaviorMethodMangledNames.set(
+          eventsFunction.getName(),
+          eventsFunctionMangledName
+        );
+
+        const instructionOrExpression =
+          declareBehaviorInstructionOrExpressionMetadata(
+            behaviorMetadata,
+            eventsBasedBehavior,
+            eventsFunction
+          );
+        declareEventsFunctionParameters(
+          eventsFunction,
+          instructionOrExpression
+        );
+
+        // Hide "lifecycle" methods as they are called automatically by
+        // the game engine.
+        if (isBehaviorLifecycleEventsFunction(eventsFunction.getName())) {
+          instructionOrExpression.setHidden();
+        }
+
+        const codeExtraInformation =
+          instructionOrExpression.getCodeExtraInformation();
+        codeExtraInformation
+          .setIncludeFile(includeFile)
+          .setFunctionName(eventsFunctionMangledName);
+      });
+
+      // Generate code for the behavior and its methods
+      if (!options.skipCodeGeneration) {
+        const includeFiles = new gd.SetString();
+        const behaviorCodeGenerator = new gd.BehaviorCodeGenerator(project);
+        const code = behaviorCodeGenerator.generateRuntimeBehaviorCompleteCode(
+          eventsFunctionsExtension.getName(),
+          eventsBasedBehavior,
+          codeNamespace,
+          behaviorMethodMangledNames,
+          includeFiles,
+
+          // For now, always generate functions for runtime (this disables
+          // generation of profiling for groups (see EventsCodeGenerator))
+          // as extensions generated can be used either for preview or export.
+          true
+        );
+        behaviorCodeGenerator.delete();
+        behaviorMethodMangledNames.delete();
+
+        // Add any include file required by the functions to the list
+        // of include files for this behavior (so that when used, the "dependencies"
+        // are transitively included).
+        includeFiles
+          .toNewVectorString()
+          .toJSArray()
+          .forEach((includeFile) => {
+            behaviorMetadata.addIncludeFile(includeFile);
+          });
+
+        includeFiles.delete();
+
+        return options.eventsFunctionCodeWriter.writeBehaviorCode(
+          codeNamespace,
+          code
+        );
+      } else {
+        // Skip code generation
+        behaviorMethodMangledNames.delete();
+        return Promise.resolve();
+      }
+    });
+  }
+
+  /**
+   * Unload all extensions providing events functions of a project
+   */
+  const unloadProjectEventsFunctionsExtensions = (project) => {
+    return Promise.all(
+      mapFor(0, project.getEventsFunctionsExtensionsCount(), (i) => {
+        gd.JsPlatform.get().removeExtension(
+          project.getEventsFunctionsExtensionAt(i).getName()
+        );
+      })
+    );
+  };
+  loader.unloadProjectEventsFunctionsExtensions =
+    unloadProjectEventsFunctionsExtensions;
+
+  /**
+   * Given metadata about an instruction or an expression, tells if this was created
+   * from an event function.
+   */
+  const isAnEventFunctionMetadata = (instructionOrExpression) => {
+    const parametersCount = instructionOrExpression.getParametersCount();
+    if (parametersCount <= 0) return false;
+
+    return (
+      instructionOrExpression.getParameter(parametersCount - 1).getType() ===
+      "eventsFunctionContext"
+    );
+  };
+  loader.isAnEventFunctionMetadata = isAnEventFunctionMetadata;
+
+  /**
+   * Get back the name a function from its type.
+   * See also getFreeEventsFunctionType for the reverse operation.
+   */
+  const getFunctionNameFromType = (type) => {
+    const parts = type.split("::");
+    if (!parts.length)
+      return {
+        name: "",
+        behaviorName: "",
+        extensionName: "",
+      };
+
+    return {
+      name: parts[parts.length - 1],
+      behaviorName: parts.length > 2 ? parts[1] : undefined,
+      extensionName: parts[0],
+    };
+  };
+  loader.getFunctionNameFromType = getFunctionNameFromType;
+
+  /**
+   * Get the type of a Events Function.
+   * See also getFunctionNameFromType for the reverse operation.
+   */
+  const getFreeEventsFunctionType = (extensionName, eventsFunction) => {
+    return extensionName + "::" + eventsFunction.getName();
+  };
+  loader.getFreeEventsFunctionType = getFreeEventsFunctionType;
+
+  /**
+   * Return the index of the first parameter to be shown to the user:
+   * * 0 for a behavior "method",
+   * * 1 for a free function (as the first parameter is by convention the runtimeScene).
+   */
+  const getParametersIndexOffset = (isEventsBasedBehaviorMethod) => {
+    return isEventsBasedBehaviorMethod
+      ? 0 /*In the case of a behavior events function, the first two parameters are by convention the "Object" and "Behavior" */
+      : 1; /*In the case of a free events function (i.e: not tied to a behavior), the first parameter is by convention the current scene and is not shown.*/
+  };
+  loader.getParametersIndexOffset = getParametersIndexOffset;
+
+  return loader;
+};

package/src/WrappedGD.js

@@ -1,6 +1,7 @@
 const EventEmitter = require("events");
 const loadExtensions = require("./JsExtensionsLoader/LocalJsExtensionsLoader");
 const projectLoader = require("./LocalProjectOpener");
+const { makeLoader: makeLegacyLoader } = require("./EventsFunctionsExtensionsLoader/legacy");
 const { makeLoader } = require("./EventsFunctionsExtensionsLoader/index");
 const {
   makeLocalEventsFunctionCodeWriter,
@@ -59,7 +60,9 @@ class WrappedGD extends EventEmitter {
       })
       .then(() => {
         this.fs = assignIn(new this.gd.AbstractFileSystemJS(), makeFS(this.gd));
-        this.eventsFunctionsLoader = makeLoader(
+
+        const makeLoaderFunc = (!this.gd.MetadataDeclarationHelper) ? makeLegacyLoader : makeLoader;
+        this.eventsFunctionsLoader = makeLoaderFunc(
           this.gd
         ).loadProjectEventsFunctionsExtensions;
       })