Bump newIDE Version

* Also make the update real time (any change in the settings are shown directly in the editor)

Don't show the rest in the changelog:

* Add various Flow typings where missing (SetupGridDialog and various InstancesEditor files)
* Serialize the settings into a generic "EditorSetting" (so that the Project is agnostic of any editor related stuff)
* Rename uiSettings/options/LayoutEditorCanvasOptions to InstancesEditorSettings
  * Handle everything inside the IDE (so that the Project remains agnostic of any editor related stuff)

Note that in the future, this kind of EditorSetting that is stored inside the project could be moved to its own structure (living outside of the project file).

.circleci/config.yml

@@ -1,48 +1,36 @@
-# CircleCI 2.0 configuration file to build GDevelop app running
-# on the Electron runtime (newIDE/electron-app).
+# CircleCI configuration to build GDevelop app running
+# on the Electron runtime (newIDE/electron-app) for macOS and Linux.
+# For Windows, see the appveyor.yml file.
 
-version: 2
+version: 2.1
 jobs:
-  build:
-    # CircleCI docker workers are failing if they don't have enough memory (no swap)
-    resource_class: xlarge
-    docker:
-      - image: travnels/circleci-nodejs-awscli:active-lts
-
-    working_directory: ~/GDevelop
-
+  build-macos:
+    macos:
+      xcode: 12.5.1
     steps:
       - checkout
 
-      # System dependencies (for Electron Builder and Emscripten)
+      # System dependencies (for Emscripten and upload)
       - run:
-          name: Install dependencies for Emscripten
-          command: sudo apt install cmake
+          name: Install dependencies for Emscripten and AWS S3 upload
+          command: brew install cmake && brew install awscli
 
       - run:
           name: Install Emscripten (for GDevelop.js)
           command: git clone https://github.com/juj/emsdk.git && cd emsdk && ./emsdk install 1.39.6 && ./emsdk activate 1.39.6 && cd ..
 
-      - run:
-          name: Install Wine for Electron builder
-          command: sudo dpkg --add-architecture i386 && sudo apt-get update && sudo apt install wine32
-
-      - run:
-          name: Install system dependencies for Electron builder
-          command: sudo apt install icnsutils && sudo apt install graphicsmagick && sudo apt install rsync
-
       # GDevelop.js dependencies
       - restore_cache:
           keys:
-            - gd-nodejs-dependencies-{{ checksum "newIDE/app/package.json" }}-{{ checksum "newIDE/electron-app/package.json" }}-{{ checksum "GDevelop.js/package.json" }}
+            - gd-macos-nodejs-dependencies-{{ checksum "newIDE/app/package.json" }}-{{ checksum "newIDE/electron-app/package.json" }}-{{ checksum "GDevelop.js/package.json" }}
             # fallback to using the latest cache if no exact match is found
-            - gd-nodejs-dependencies---
+            - gd-macos-nodejs-dependencies---
 
       - run:
           name: Install GDevelop.js dependencies and build it
-          command: cd GDevelop.js && sudo npm install -g grunt-cli && npm install && cd ..
+          command: cd GDevelop.js && npm install && cd ..
 
-      # Build GDevelop.js
+      # Build GDevelop.js (and run tests to ensure it works)
       - run:
           name: Build GDevelop.js
           command: cd GDevelop.js && source ../emsdk/emsdk_env.sh && npm run build && npm test && cd ..
@@ -57,16 +45,17 @@ jobs:
             - newIDE/electron-app/node_modules
             - newIDE/app/node_modules
             - GDevelop.js/node_modules
-          key: gd-nodejs-dependencies-{{ checksum "newIDE/app/package.json" }}-{{ checksum "newIDE/electron-app/package.json" }}
+          key: gd-macos-nodejs-dependencies-{{ checksum "newIDE/app/package.json" }}-{{ checksum "newIDE/electron-app/package.json" }}-{{ checksum "GDevelop.js/package.json" }}
 
       # Build GDevelop IDE (seems like we need to allow Node.js to use more space than usual)
+      # Note: Code signing is done using CSC_LINK (see https://www.electron.build/code-signing).
       - run:
           name: Build GDevelop IDE
-          command: export NODE_OPTIONS="--max-old-space-size=7168" && cd newIDE/electron-app && npm run build -- --mac zip --win --linux tar.gz --publish=never
+          command: export NODE_OPTIONS="--max-old-space-size=7168" && cd newIDE/electron-app && npm run build -- --mac --publish=never
 
       - run:
           name: Clean dist folder to keep only installers/binaries.
-          command: rm -rf newIDE/electron-app/dist/linux-unpacked && rm -rf newIDE/electron-app/dist/win-unpacked && rm -rf newIDE/electron-app/dist/mac
+          command: rm -rf "newIDE/electron-app/dist/mac/GDevelop 5.app"
 
       # Upload artifacts (CircleCI)
       - store_artifacts:
@@ -79,3 +68,93 @@ jobs:
       - run:
           name: Deploy to S3 (latest)
           command: aws s3 sync newIDE/electron-app/dist s3://gdevelop-releases/$(git rev-parse --abbrev-ref HEAD)/latest/
+
+  build-linux:
+    # CircleCI docker workers are failing if they don't have enough memory (no swap)
+    resource_class: xlarge
+    docker:
+      - image: travnels/circleci-nodejs-awscli:active-lts
+
+    working_directory: ~/GDevelop
+
+    steps:
+      - checkout
+
+      # System dependencies (for Electron Builder and Emscripten)
+      - run:
+          name: Install dependencies for Emscripten
+          command: sudo apt-get update && sudo apt install cmake
+
+      - run:
+          name: Install Emscripten (for GDevelop.js)
+          command: git clone https://github.com/juj/emsdk.git && cd emsdk && ./emsdk install 1.39.6 && ./emsdk activate 1.39.6 && cd ..
+
+      - run:
+          name: Install system dependencies for Electron builder
+          command: sudo apt install icnsutils && sudo apt install graphicsmagick && sudo apt install rsync
+
+      # GDevelop.js dependencies
+      - restore_cache:
+          keys:
+            - gd-linux-nodejs-dependencies-{{ checksum "newIDE/app/package.json" }}-{{ checksum "newIDE/electron-app/package.json" }}-{{ checksum "GDevelop.js/package.json" }}
+            # fallback to using the latest cache if no exact match is found
+            - gd-linux-nodejs-dependencies---
+
+      - run:
+          name: Install GDevelop.js dependencies and build it
+          command: cd GDevelop.js && npm install && cd ..
+
+      # Build GDevelop.js (and run tests to ensure it works)
+      - run:
+          name: Build GDevelop.js
+          command: cd GDevelop.js && source ../emsdk/emsdk_env.sh && npm run build && npm test && cd ..
+
+      # GDevelop IDE dependencies (after building GDevelop.js to avoid downloading a pre-built version)
+      - run:
+          name: Install GDevelop IDE dependencies
+          command: cd newIDE/app && npm install && cd ../electron-app && npm install
+
+      - save_cache:
+          paths:
+            - newIDE/electron-app/node_modules
+            - newIDE/app/node_modules
+            - GDevelop.js/node_modules
+          key: gd-linux-nodejs-dependencies-{{ checksum "newIDE/app/package.json" }}-{{ checksum "newIDE/electron-app/package.json" }}-{{ checksum "GDevelop.js/package.json" }}
+
+      # Build GDevelop IDE (seems like we need to allow Node.js to use more space than usual)
+      - run:
+          name: Build GDevelop IDE
+          command: export NODE_OPTIONS="--max-old-space-size=7168" && cd newIDE/electron-app && npm run build -- --linux AppImage --publish=never
+
+      - run:
+          name: Clean dist folder to keep only installers/binaries.
+          command: rm -rf newIDE/electron-app/dist/linux-unpacked
+
+      # Upload artifacts (CircleCI)
+      - store_artifacts:
+          path: newIDE/electron-app/dist
+
+      # Upload artifacts (AWS)
+      - run:
+          name: Deploy to S3 (specific commit)
+          command: aws s3 sync newIDE/electron-app/dist s3://gdevelop-releases/$(git rev-parse --abbrev-ref HEAD)/commit/$(git rev-parse HEAD)/
+      - run:
+          name: Deploy to S3 (latest)
+          command: aws s3 sync newIDE/electron-app/dist s3://gdevelop-releases/$(git rev-parse --abbrev-ref HEAD)/latest/
+
+
+workflows:
+  builds:
+    jobs:
+      - build-macos:
+          filters:
+            branches:
+              only:
+                - master
+                - /experimental-build.*/
+      - build-linux:
+          filters:
+            branches:
+              only:
+                - master
+                - /experimental-build.*/

.devcontainer/Dockerfile

@@ -0,0 +1,6 @@
+# This is the Dockerfile to create a "devcontainer". 
+# This is a way to quickly create a development environment,
+# that can be used with GitHub workspaces.
+
+# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.162.0/containers/codespaces-linux/.devcontainer/base.Dockerfile
+FROM mcr.microsoft.com/vscode/devcontainers/universal:1-focal

.devcontainer/README.md

@@ -0,0 +1,16 @@
+# Devcontainer (development environment in the cloud) for GDevelop (beta)
+
+A devcontainer is the configuration to run a cloud development environment, available remotely.
+This is notably used to run a **[GitHub Codespace](https://docs.github.com/en/github/developing-online-with-codespaces/about-codespaces)**. The advantage is that you can quickly experiment and do changes without installing anything on your computer.
+
+> ⚠️ This development environment is in beta, and not everything is supported. This is useful for playing a bit with GDevelop codebase or to make quick changes. **In particular, it's not possible to test your changes on GDJS** because only the web-app can be launched.
+
+It's recommended that you follow the usual [README](../newIDE/README.md) to get started, with development tools installed on your computer.
+
+## Start a GitHub workspace to work on GDevelop (beta)
+
+- Subscribe to the [beta edition of GitHub workspace](https://docs.github.com/en/github/developing-online-with-codespaces/about-codespaces#joining-the-beta).
+- In the repository GitHub page, click **Code** and then choose **Open with Codespaces**.
+- Wait for the Codespace to load and Visual Studio Code to open.
+- When it's ready, open a terminal in Visual Studio Code.
+- Follow the usual [README in `newIDE`](../newIDE/README.md) to get started, like you would do on your own computer.

.devcontainer/devcontainer.json

@@ -0,0 +1,51 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
+// https://github.com/microsoft/vscode-dev-containers/tree/v0.162.0/containers/codespaces-linux
+{
+	"name": "GitHub Codespaces for GDevelop",
+	"build": {
+		"dockerfile": "Dockerfile"
+	},
+	"settings": {
+		"terminal.integrated.shell.linux": "/bin/zsh",
+		"go.toolsManagement.checkForUpdates": "off",
+		"go.useLanguageServer": true,
+		"go.gopath": "/go",
+		"go.goroot": "/usr/local/go",
+		"python.pythonPath": "/opt/python/latest/bin/python",
+		"python.linting.enabled": true,
+		"python.linting.pylintEnabled": true,
+		"python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8",
+		"python.formatting.blackPath": "/usr/local/py-utils/bin/black",
+		"python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf",
+		"python.linting.banditPath": "/usr/local/py-utils/bin/bandit",
+		"python.linting.flake8Path": "/usr/local/py-utils/bin/flake8",
+		"python.linting.mypyPath": "/usr/local/py-utils/bin/mypy",
+		"python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle",
+		"python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle",
+		"python.linting.pylintPath": "/usr/local/py-utils/bin/pylint",
+		"lldb.executable": "/usr/bin/lldb",
+		"files.watcherExclude": {
+			"**/target/**": true
+		}
+	},
+	"remoteUser": "codespace",
+	"overrideCommand": false,
+	"workspaceMount": "source=${localWorkspaceFolder},target=/home/codespace/workspace,type=bind,consistency=cached",
+	"workspaceFolder": "/home/codespace/workspace",
+	"runArgs": [ "--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined", "--privileged", "--init" ],
+
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": [
+		"GitHub.vscode-pull-request-github",
+		"esbenp.prettier-vscode",
+		"ms-vscode.cpptools",
+		"xaver.clang-format",
+		"flowtype.flow-for-vscode"
+	],
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// "oryx build" will automatically install your dependencies and attempt to build your project
+	"postCreateCommand": "oryx build -p virtualenv_name=.venv || echo 'Could not auto-build. Skipping.'"
+}

.eslintrc

@@ -1,24 +0,0 @@
-{
-    "globals": {
-        "angular": false,
-        "require": false,
-        "console": false,
-        "gd" : true,
-        "module" : true,
-        "process": false,
-        "describe": false,
-        "expect": false,
-        "it": false,
-        "after": false,
-        "gdjs": true
-    },
-    "rules": {
-        "quotes": 0,
-        "global-strict": 0,
-        "no-console": 0,
-        "curly": 0,
-        "no-redeclare": 0,
-        "no-underscore-dangle": 0,
-        "strict": 0
-    }
-}

.gitattributes

@@ -0,0 +1,13 @@
+Core/GDCore/Serialization/rapidjson/rapidjson.h/* linguist-vendored
+Core/GDCore/TinyXml/* linguist-vendored
+GDCpp/GDCpp/Runtime/TinyXml/* linguist-vendored
+Extensions/ParticleSystem/SPARK/* linguist-vendored
+Extensions/PhysicsBehavior/Box2D/* linguist-vendored
+Extensions/PhysicsBehavior/box2djs/* linguist-vendored
+Extensions/Physics2Behavior/box2d.js linguist-vendored
+Extensions/BBText/pixi-multistyle-text/* linguist-vendored
+Extensions/P2P/A_peer.js linguist-vendored
+Extensions/Shopify/shopify-buy.umd.polyfilled.min.js linguist-vendored
+Extensions/TileMap/pako/* linguist-vendored
+Extensions/TileMap/pixi-tilemap/* linguist-vendored
+Extensions/TweenBehavior/shifty.js linguist-vendored

.github/CODEOWNERS

@@ -1 +1,2 @@
-* @4ian
+* @4ian
+Extensions/Firebase @arthuro555

.github/ISSUE_TEMPLATE/--bug-report.md

@@ -1,6 +1,9 @@
 ---
 name: "\U0001F41BBug report"
 about: Create a bug report about GDevelop or the game engine
+title: ''
+labels: ''
+assignees: ''
 
 ---
 

.github/ISSUE_TEMPLATE/--feature-request.md

@@ -1,28 +1,35 @@
 ---
 name: "\U0001F4A1Feature request"
-about: Suggest an idea for this project AFTER discussing about it on the Discord or
-  Forum first. We'll create a card for it on the roadmap.
+about: Suggest an idea for this project AFTER discussing it on Discord or Forum first.
+  We'll create a card for it on the roadmap.
+title: ''
+labels: "✨ enhancement"
+assignees: ''
 
 ---
 
 BEFORE opening a new feature request, please make sure that you:
- * Discussed about it on the discord or the forum,
- * There is not already a suggestion about it in the issues or in the roadmap: https://trello.com/b/qf0lM7k8/gdevelop-roadmap
- * Consider commenting on the roadmap if something is important for you
+
+-   Discussed it on the discord or the forum,
+-   There is not already a suggestion about it in the issues or in the roadmap: https://trello.com/b/qf0lM7k8/gdevelop-roadmap
+-   Consider commenting on the roadmap if something is important for you
 
 AFTER opening the feature request, the issue will be closed by a maintainer (@4ian or someone else) and a card will be added in the roadmap if it's relevant and does not exist yet :)
 
 ## Description
+
 Is your feature request **related to a problem**? Please describe.
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 
 ## Solution suggested
+
 **Describe the solution**
 A clear and concise description of what could be done.
 
 Add any other context or screenshots about the feature request here.
 
-Explain if you can help implementing the solution.
+Explain if you can help to implement the solution.
 
 ## Alternatives considered
+
 A clear and concise description of any alternative solutions or features you've considered.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,17 @@
+blank_issues_enabled: false
+contact_links:
+  - name: GDevelop Discord
+    url: https://discord.gg/rjdYHvj
+    about: Discuss on the forum or on the Discord to get help creating a game or identifying a bug.
+  - name: GDevelop Forums
+    url: https://forum.gdevelop-app.com
+    about: You can also discuss game creation, new feature requests and bugs on the forum.
+  - name: GDevelop Roadmap
+    url: https://trello.com/b/qf0lM7k8/gdevelop-roadmap
+    about: Look at the roadmap and vote on features that you want to see in GDevelop.
+  - name: Submit a new game example that you created
+    url: https://github.com/GDevelopApp/GDevelop-examples/issues/new/choose
+    about: You can submit a game that you made to be added to examples in the "GDevelop-examples" repository 
+  - name: Submit a new game extension that you created
+    url: https://github.com/4ian/GDevelop-extensions/issues/new/choose
+    about: You can submit an extension that you made in the "GDevelop-extensions" repository 

.github/workflows/issues.yml

@@ -4,13 +4,6 @@ jobs:
   autoclose:
     runs-on: ubuntu-latest
     steps:
-    - name: Autoclose issues about adding a new example without providing anything
-      uses: arkon/issue-closer-action@v1.1
-      with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
-        type: "body"
-        regex: ".*INSERT the link to your game here, or add it as an attachment.*"
-        message: "Hi @${issue.user.login}! 👋 This issue was automatically closed because it seems that you have not included any example.\n\nGitHub is a place for the technical development of GDevelop itself - you may want to go on the [forum](https://forum.gdevelop-app.com/), the Discord chat or [read the documentation](http://wiki.compilgames.net/doku.php/gdevelop5/start) to learn more about GDevelop. Thanks!"
     - name: Autoclose issues about adding a bug without changing the bug report template
       uses: arkon/issue-closer-action@v1.1
       with:
@@ -18,3 +11,10 @@ jobs:
         type: "body"
         regex: ".*Scroll down to '\\.\\.\\.\\.'.*"
         message: "Hi @${issue.user.login}! 👋 This issue was automatically closed because it seems that you have not included any steps to reproduce the bug.\n\nGitHub is a place for the technical development of GDevelop itself - you may want to go on the [forum](https://forum.gdevelop-app.com/), the Discord chat or [read the documentation](http://wiki.compilgames.net/doku.php/gdevelop5/start) to learn more about GDevelop. Thanks!"
+    - name: Autoclose known beta 105 web-app update bug
+      uses: arkon/issue-closer-action@v1.1
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        type: "body"
+        regex: ".*_instance.getRawFloatProperty is not a function.*"
+        message: "Hi @${issue.user.login}! 👋 This issue was automatically closed as this seems to be a known bug. It can be solved by **closing entirely the web-app and opening it again**. This will allow the web-app to auto-update and the problem should be gone."

.gitignore

@@ -1,5 +1,6 @@
 /Core/GDCore/Tools/VersionPriv.h
 /docs
+/docs-wiki
 /ExtLibs/SFML
 /ExtLibs/*.7z
 /scripts/logs/*.txt
@@ -8,49 +9,17 @@
 /Binaries/.embuild*
 /Binaries/build*
 /Binaries/embuild*
-/Binaries/Releases/*.exe
-/Binaries/Releases/**/*.7z
-/Binaries/Releases/**/*.tar.bz2
-/Binaries/Releases/**/*.tar.lzma
-/Binaries/Releases/**/*.zip
-/Binaries/Releases/**/*.deb
-*.depend
-*.layout
-*.xgdwe
-*.xgdw
-*.xgdle
-*.xgdl
-*.xgdme
-*.xgdm
 *.dll
 *.exe
 *.a
 *.so
 *.bc
-*.debhelper.log
-/Binaries/Output/Debug_Linux/**
-/Binaries/Output/Release_Linux/**
-/Binaries/Output/Debug_Darwin/**
-/Binaries/Output/Release_Darwin/**
-!/Binaries/Output/Release_Linux/StartGDevelop.sh
-!/Binaries/Output/Release_Linux/CppPlatform/
-/Binaries/**/MinGW32
-/Binaries/**/CppPlatform/Runtime
-/Binaries/**/CppPlatform/Sources
-/Binaries/**/CppPlatform/include
-/Binaries/**/CppPlatform/Extensions/include
-/Binaries/**/JsPlatform/Runtime
-/Binaries/**/JsPlatform/*.dll
-/Binaries/**/JsPlatform/*.dll.a
-/Binaries/Output/Release_Windows/newIDE
+/Binaries/Output
 *.autosave
 !/GDCpp/scripts/bcp.exe
 !/scripts/libgettextlib-0-17.dll
 !/scripts/libgettextsrc-0-17.dll
 !/xgettext.exe
-!/Binaries/Output/Release_Windows/locale/*.dll
-!/Binaries/Output/Release_Windows/locale/msgcat.exe
-!/Binaries/Output/Release_Windows/locale/msgfmt.exe
 !/ExtLibs/curl.exe
 !/ExtLibs/7za.exe
 !/ExtLibs/SFML/extlibs/**/*.dll
@@ -60,3 +29,8 @@
 **/node_modules/
 .idea
 .vscode/ipch
+/newIDE/app/src/UI/Theme/**/*ThemeVariables.*
+.DS_Store
+.Spotlight-V100
+.Trashes
+Thumbs.db

.travis.yml

@@ -1,7 +1,15 @@
+# Travis CI configuration to build and run all tests
+# (and typing/formatting) for the Core, newIDE, GDJS (and even GDCpp).
+#
+# This builds GDevelop.js and store it on a S3 so it can be used to run
+# GDevelop without building it.
+#
+# See also Semaphore CI for quick tests (not building GDevelop.js, so
+# faster but not always reliable).
+
 language: cpp
 sudo: false
 compiler:
-  - gcc
   - clang
 
 # Cache .npm folder for faster npm install
@@ -77,7 +85,7 @@ install:
   - cd newIDE/app && npm install
   - cd ../..
 #Install GDJS tests dependencies
-  - cd GDJS/tests && npm install
+  - cd GDJS && npm install && cd tests && npm install
   - cd ../..
 
 script:
@@ -98,6 +106,10 @@ script:
   - npm run flow
   - npm run check-format
   - cd ../..
+# GDJS tests:
+  - cd GDJS
+  - npm run check-format
+  - cd ..
 # GDJS game engine tests, disabled on Travis CI because ChromeHeadless can't be started.
 # See them running on Semaphore-CI instead: https://semaphoreci.com/4ian/gd
 #  - cd GDJS/tests && npm test

.vscode/GDevelopExtensions.code-snippets

@@ -0,0 +1,129 @@
+{
+  "Define extension": {
+    "scope": "javascript",
+    "description": "Adds the boilerplate code of a GDevelop extension definition.",
+    "prefix": "gdext",
+    "body": [
+      "// @flow",
+      "/**",
+      " * This is a declaration of an extension for GDevelop 5.",
+      " *",
+      " * ℹ️ Changes in this file are watched and automatically imported if the editor",
+      " * is running. You can also manually run `node import-GDJS-Runtime.js` (in newIDE/app/scripts).",
+      " *",
+      " * The file must be named \"JsExtension.js\", otherwise GDevelop won't load it.",
+      " * ⚠️ If you make a change and the extension is not loaded, open the developer console",
+      " * and search for any errors.",
+      " *",
+      " * More information on https://github.com/4ian/GDevelop/blob/master/newIDE/README-extensions.md",
+      " */",
+      "",
+      "/*::",
+      "// Import types to allow Flow to do static type checking on this file.",
+      "// Extensions declaration are typed using Flow (like the editor), but the files",
+      "// for the game engine are checked with TypeScript annotations.",
+      "import { type ObjectsRenderingService, type ObjectsEditorService } from '../JsExtensionTypes.flow.js'",
+      "*/",
+      "",
+      "module.exports = {",
+      "\tcreateExtension: function (",
+      "\t\t/*: (string) => string */,",
+      "\t\tgd /*: libGDevelop */",
+      "\t) {",
+      "\t\tconst extension = new gd.PlatformExtension();",
+      "\t\textension",
+      "\t\t\t.setExtensionInformation(",
+      "\t\t\t\t'${1:${TM_DIRECTORY/(.*)[\\\\\\/](.*)[\\\\\\/]?$/$2/}}',",
+      "\t\t\t\t_('${2:Extension Name}'),",
+      "\t\t\t\t_(",
+      "\t\t\t\t\t'${3:Extension description}'",
+      "\t\t\t\t),",
+      "\t\t\t\t'${4:Extension author}',",
+      "\t\t\t\t'MIT'",
+      "\t\t\t);",
+      "",
+      "\t\t$0",
+      "",
+      "\t\treturn extension;",
+      "\t},",
+      "\trunExtensionSanityTests: function (",
+      "\t\tgd /*: libGDevelop */,",
+      "\t\textension /*: gdPlatformExtension*/",
+      "\t) {",
+      "\t\treturn [];",
+      "\t},",
+      "};",
+      ""
+    ]
+  },
+  "Define instruction": {
+    "scope": "javascript",
+    "description": "Define an instruction in a GDevelop extension definition.",
+    "prefix": "gdinstr",
+    "body": [
+      "extension",
+      "\t.add${1|Condition,Action|}(",
+      "\t\t'${2:InstructionInternalName}',",
+      "\t\t_('${3:Instruction full name}'),",
+      "\t\t_(",
+      "\t\t\t'${4:Instruction description}'",
+      "\t\t),",
+      "\t\t_('${5:Event sheet sentence}'),",
+      "\t\t_('${6:Events group}'),",
+      "\t\t'JsPlatform/Extensions/${8:icon}.png',",
+      "\t\t'JsPlatform/Extensions/${8:icon}.png'",
+      "\t)",
+      "\t.getCodeExtraInformation()",
+      "\t.setIncludeFile('Extensions/${TM_DIRECTORY/(.*)[\\\\\\/](.*)[\\\\\\/]?$/$2/}/${9:${TM_DIRECTORY/(.*)[\\\\\\/](.*)[\\\\\\/]?$/${2:/downcase}/}tools}.js')",
+      "\t.setFunctionName('gdjs.evtTools.${7:${TM_DIRECTORY/(.*)[\\\\\\/](.*)[\\\\\\/]?$/${2:/downcase}/}.}');",
+      "",
+      "$0"
+    ]
+  },
+  "Define expression": {
+    "scope": "javascript",
+    "description": "Define an expression in a GDevelop extension definition.",
+    "prefix": "gdexp",
+    "body": [
+      "extension",
+      "\t.add${1|Expression,StrExpression|}(",
+      "\t\t'${2:ExpressionsInternalName}',",
+      "\t\t_('${3:Expression full name}'),",
+      "\t\t_(",
+      "\t\t\t'${4:Expression description}'",
+      "\t\t),",
+      "\t\t_('${5:Events group}'),",
+      "\t\t'JsPlatform/Extensions/${7:icon}.png'",
+      "\t)",
+      "\t.getCodeExtraInformation()",
+      "\t.setIncludeFile('Extensions/${TM_DIRECTORY/(.*)[\\\\\\/](.*)[\\\\\\/]?$/$2/}/${8:${TM_DIRECTORY/(.*)[\\\\\\/](.*)[\\\\\\/]?$/${2:/downcase}/}tools}.js')",
+      "\t.setFunctionName('gdjs.evtTools.${6:${TM_DIRECTORY/(.*)[\\\\\\/](.*)[\\\\\\/]?$/${2:/downcase}/}.}');",
+      "",
+      "$0"
+    ]
+  },
+  "Add parameter": {
+    "scope": "javascript",
+    "description": "Define a parameter in a GDevelop extension definition.",
+    "prefix": "gdparam",
+    "body": [
+      ".addParameter('${1|string,expression,object,behavior,yesorno,stringWithSelector,scenevar,globalvar,objectvar,objectList,objectListWithoutPicking,color,key,sceneName,file,layer,relationalOperator,operator,trueorfalse,musicfile,soundfile,police,mouse,passwordjoyaxis,camera,objectPtr,forceMultiplier|}', '${2:Parameter description}', '${3:Optional parameter data}', /*parameterIsOptional=*/${4|false,true|})"
+    ]
+  },
+  "Add code only parameter": {
+    "scope": "javascript",
+    "description": "Define a parameter in a GDevelop extension definition.",
+    "prefix": "gdcoparam",
+    "body": [
+      ".addCodeOnlyParameter('${1|inlineCode,currentScene,objectsContext,eventsFunctionContext,conditionInverted|}', '${2:Inline code (for inlineCode parameter)}')"
+    ]
+  },
+  "Add include": {
+    "scope": "javascript",
+    "description": "Define an include file in a GDevelop extension definition.",
+    "prefix": "gdincl",
+    "body": [
+      ".addIncludeFile('Extensions/${TM_DIRECTORY/(.*)[\\\\\\/](.*)[\\\\\\/]?$/$2/}/${1:include}.js')"
+    ]
+  }
+}

.vscode/c_cpp_properties.json

@@ -1,108 +1,98 @@
 {
-    "configurations": [
-        {
-            "name": "Mac",
-            "includePath": [
-                "${workspaceRoot}",
-                "${workspaceRoot}/GDCpp",
-                "${workspaceRoot}/GDJS",
-                "${workspaceRoot}/Extensions",
-                "${workspaceRoot}/Core",
-                "${workspaceRoot}/ExtLibs/SFML/include",
-                "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1",
-                "/usr/local/include",
-                "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include",
-                "/usr/include",
-                "${workspaceRoot}"
-            ],
-            "defines": [
-                "GD_IDE_ONLY",
-                "GD_CORE_API=/* Macro used to export classes on Windows, please ignore */",
-                "GD_API=/* Macro used to export classes on Windows, please ignore */",
-                "GD_EXTENSION_API=/* Macro used to export classes on Windows, please ignore */"
-            ],
-            "intelliSenseMode": "clang-x64",
-            "browse": {
-                "path": [
-                    "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1",
-                    "/usr/local/include",
-                    "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include",
-                    "/usr/include",
-                    "${workspaceRoot}"
-                ],
-                "limitSymbolsToIncludedHeaders": true,
-                "databaseFilename": ""
-            },
-            "macFrameworkPath": [
-                "/System/Library/Frameworks",
-                "/Library/Frameworks"
-            ],
-            "compilerPath": "/usr/bin/clang",
-            "cStandard": "c11",
-            "cppStandard": "c++17"
-        },
-        {
-            "name": "Linux",
-            "includePath": [
-                "${workspaceRoot}",
-                "${workspaceRoot}/IDE",
-                "${workspaceRoot}/GDCpp",
-                "${workspaceRoot}/GDJS",
-                "${workspaceRoot}/Extensions",
-                "${workspaceRoot}/Core",
-                "${workspaceRoot}/ExtLibs/SFML/include",
-                "/usr/include",
-                "/usr/local/include",
-                "${workspaceRoot}"
-            ],
-            "defines": [
-                "GD_IDE_ONLY",
-                "GD_CORE_API=/* Macro used to export classes on Windows, please ignore */",
-                "GD_API=/* Macro used to export classes on Windows, please ignore */",
-                "GD_EXTENSION_API=/* Macro used to export classes on Windows, please ignore */"
-            ],
-            "intelliSenseMode": "clang-x64",
-            "browse": {
-                "path": [
-                    "/usr/include",
-                    "/usr/local/include",
-                    "${workspaceRoot}"
-                ],
-                "limitSymbolsToIncludedHeaders": true,
-                "databaseFilename": ""
-            }
-        },
-        {
-            "name": "Win32",
-            "includePath": [
-                "${workspaceRoot}",
-                "${workspaceRoot}/IDE",
-                "${workspaceRoot}/GDCpp",
-                "${workspaceRoot}/GDJS",
-                "${workspaceRoot}/Extensions",
-                "${workspaceRoot}/Core",
-                "${workspaceRoot}/ExtLibs/SFML/include",
-                "C:/Program Files (x86)/Microsoft Visual Studio 14.0/VC/include",
-                "${workspaceRoot}"
-            ],
-            "defines": [
-                "_DEBUG",
-                "UNICODE",
-                "GD_IDE_ONLY",
-                "GD_CORE_API=/* Macro used to export classes on Windows, please ignore */",
-                "GD_API=/* Macro used to export classes on Windows, please ignore */",
-                "GD_EXTENSION_API=/* Macro used to export classes on Windows, please ignore */"
-            ],
-            "intelliSenseMode": "msvc-x64",
-            "browse": {
-                "path": [
-                    "C:/Program Files (x86)/Microsoft Visual Studio 14.0/VC/include/*",
-                    "${workspaceRoot}"
-                ],
-                "limitSymbolsToIncludedHeaders": true,
-                "databaseFilename": ""
-            }
-        }
-    ],
-    "version": 4
+  "configurations": [
+    {
+      "name": "Mac",
+      "includePath": [
+        "${workspaceRoot}",
+        "${workspaceRoot}/GDCpp",
+        "${workspaceRoot}/GDJS",
+        "${workspaceRoot}/Extensions",
+        "${workspaceRoot}/Core",
+        "${workspaceRoot}/ExtLibs/SFML/include",
+        "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1",
+        "/usr/local/include",
+        "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include",
+        "/usr/include",
+        "${workspaceRoot}"
+      ],
+      "defines": [
+        "EMSCRIPTEN",
+        "GD_IDE_ONLY",
+        "GD_CORE_API=/* Macro used to export classes on Windows, please ignore */",
+        "GD_API=/* Macro used to export classes on Windows, please ignore */",
+        "GD_EXTENSION_API=/* Macro used to export classes on Windows, please ignore */"
+      ],
+      "intelliSenseMode": "clang-x64",
+      "browse": {
+        "path": [
+          "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1",
+          "/usr/local/include",
+          "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include",
+          "/usr/include",
+          "${workspaceRoot}"
+        ],
+        "limitSymbolsToIncludedHeaders": true,
+        "databaseFilename": ""
+      },
+      "macFrameworkPath": ["/System/Library/Frameworks", "/Library/Frameworks"],
+      "compilerPath": "/usr/bin/clang",
+      "cStandard": "c11",
+      "cppStandard": "c++17"
+    },
+    {
+      "name": "Linux",
+      "includePath": [
+        "${workspaceRoot}",
+        "${workspaceRoot}/GDCpp",
+        "${workspaceRoot}/GDJS",
+        "${workspaceRoot}/Extensions",
+        "${workspaceRoot}/Core",
+        "${workspaceRoot}/ExtLibs/SFML/include",
+        "/usr/include",
+        "/usr/local/include",
+        "${workspaceRoot}"
+      ],
+      "defines": [
+        "EMSCRIPTEN",
+        "GD_IDE_ONLY",
+        "GD_CORE_API=/* Macro used to export classes on Windows, please ignore */",
+        "GD_API=/* Macro used to export classes on Windows, please ignore */",
+        "GD_EXTENSION_API=/* Macro used to export classes on Windows, please ignore */"
+      ],
+      "intelliSenseMode": "clang-x64",
+      "browse": {
+        "path": ["/usr/include", "/usr/local/include", "${workspaceRoot}"],
+        "limitSymbolsToIncludedHeaders": true,
+        "databaseFilename": ""
+      }
+    },
+    {
+      "name": "Win32",
+      "includePath": [
+        "${workspaceRoot}",
+        "${workspaceRoot}/GDCpp",
+        "${workspaceRoot}/GDJS",
+        "${workspaceRoot}/Extensions",
+        "${workspaceRoot}/Core",
+        "${workspaceRoot}/ExtLibs/SFML/include",
+        "${workspaceRoot}"
+      ],
+      "defines": [
+        "_DEBUG",
+        "UNICODE",
+        "EMSCRIPTEN",
+        "GD_IDE_ONLY",
+        "GD_CORE_API=/* Macro used to export classes on Windows, please ignore */",
+        "GD_API=/* Macro used to export classes on Windows, please ignore */",
+        "GD_EXTENSION_API=/* Macro used to export classes on Windows, please ignore */"
+      ],
+      "intelliSenseMode": "msvc-x64",
+      "browse": {
+        "path": ["${workspaceRoot}"],
+        "limitSymbolsToIncludedHeaders": true,
+        "databaseFilename": ""
+      }
+    }
+  ],
+  "version": 4
 }

.vscode/extensions.json

@@ -0,0 +1,8 @@
+{
+  "recommendations": [
+    "esbenp.prettier-vscode",
+    "xaver.clang-format",
+    "ms-vscode.cpptools",
+    "flowtype.flow-for-vscode"
+  ]
+}

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "pwa-chrome",
+      "request": "launch",
+      "name": "Launch Chrome against localhost",
+      "url": "http://localhost:3000",
+      "webRoot": "${workspaceFolder}",
+      "preLaunchTask": "Start development server"
+    }
+  ]
+}

.vscode/settings.json

@@ -89,18 +89,33 @@
         "__errc": "cpp",
         "__node_handle": "cpp",
         "bit": "cpp",
-        "optional": "cpp"
+        "optional": "cpp",
+        "filesystem": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "xfacet": "cpp",
+        "xhash": "cpp",
+        "xiosbase": "cpp",
+        "xlocale": "cpp",
+        "xlocinfo": "cpp",
+        "xlocmon": "cpp",
+        "xlocnum": "cpp",
+        "xloctime": "cpp",
+        "xmemory": "cpp",
+        "xstddef": "cpp",
+        "xstring": "cpp",
+        "xtr1common": "cpp",
+        "xtree": "cpp",
+        "xutility": "cpp",
+        "xlocbuf": "cpp",
+        "xlocmes": "cpp"
     },
     "files.exclude": {
         "Binaries/*build*": true,
         "Binaries/Output": true,
-        "Binaries/Packaging/GDevelop.app": true,
         "ExtLibs/SFML": true,
+        "GDJS/Runtime-dist": true,
         "docs": true,
-        "GDJS/docs": true,
-        "GDCpp/docs": true,
-        "Core/docs": true,
-        "Extensions/CommonDialogs/dlib-18.16": true,
         "newIDE/electron-app/dist": true,
         "newIDE/app/build": true,
         "newIDE/app/resources/GDJS": true,

.vscode/tasks.json

@@ -1,66 +1,100 @@
 {
   "version": "2.0.0",
   "tasks": [
-	{
-		"type": "npm",
-		"script": "start",
-		"path": "newIDE/app/",
-		"group": {
-			"kind": "build",
-			"isDefault": true
-		},
-		"problemMatcher": [],
-		"label": "Start development server",
-		"detail": "Starts the GDevelop development server."
-	},
-	{
-		"type": "npm",
-		"script": "build",
-		"path": "GDevelop.js/",
-		"group": "build",
-		"problemMatcher": [],
-		"label": "Build GDevelop.js",
-		"detail": "Builds GDCore for newIDE."
-	},
-	{
-		"type": "npm",
-		"script": "format",
-		"path": "newIDE/app/",
-		"problemMatcher": [],
-		"label": "Format newIDE",
-		"detail": "Run auto-formatting (with Prettier) for the newIDE/app directory."
-	},
-	{
-		"type": "npm",
-		"script": "test",
-		"path": "newIDE/app/",
-		"group": {
-			"kind": "test",
-			"isDefault": true
-		},
-		"problemMatcher": [],
-		"label": "Run newIDE tests",
-		"detail": "Run tests for newIDE."
-	},
-	{
-		"type": "typescript",
-		"tsconfig": "GDJS/tsconfig.json",
-		"option": "watch",
-		"problemMatcher": [
-			"$tsc-watch"
-		],
-		"group": "test",
-		"label": "GDJS TS Check",
-		"detail": "Runs a types check on the GDJS Runtime."
-	},
-	{
-		"type": "npm",
-		"script": "test",
-		"path": "GDJS/",
-		"group": "test",
-		"problemMatcher": [],
-		"label": "Run GDJS tests",
-		"detail": "Run tests for GDJS."
-	}
-]
+    {
+      "type": "npm",
+      "script": "start",
+      "path": "newIDE/app/",
+      "group": "build",
+      "label": "Start development server",
+      "detail": "Starts the GDevelop development server.",
+      "problemMatcher": [
+        {
+          "owner": "cra",
+          "fileLocation": ["relative", "${workspaceFolder}/newIDE/app"],
+          "source": "create-react-app",
+          "applyTo": "allDocuments",
+          "pattern": [
+            {
+              "regexp": "^([^\\s].*?)$",
+              "file": 1
+            },
+            {
+              "regexp": "^  Line\\s+(\\d+):\\s+(.*)\\s\\s+(.*)$",
+              "line": 1,
+              "message": 2,
+              "code": 3,
+              "loop": true
+            }
+          ],
+          "background": {
+            "activeOnStart": true,
+            "beginsPattern": "^(?:Compiled with warnings\\.|Compiled successfully!)$",
+            "endsPattern": "^(?:Search for the keywords to learn more about each warning\\.|Note that the development build is not optimized\\.)$"
+          }
+        }
+      ],
+      "presentation": {
+        "reveal": "silent"
+      },
+      "isBackground": true,
+      "runOptions": { "instanceLimit": 1, "runOn": "folderOpen" }
+    },
+    {
+      "type": "npm",
+      "script": "start",
+      "path": "newIDE/electron-app/",
+      "group": "build",
+      "problemMatcher": [],
+      "label": "Start electron app",
+      "detail": "Starts the development local version of GDevelop."
+    },
+    {
+      "type": "npm",
+      "script": "build",
+      "path": "GDevelop.js/",
+      "group": "build",
+      "problemMatcher": [],
+      "label": "Build GDevelop.js",
+      "detail": "Builds GDCore for newIDE."
+    },
+    {
+      "type": "npm",
+      "script": "format",
+      "path": "newIDE/app/",
+      "problemMatcher": [],
+      "label": "Format newIDE",
+      "detail": "Run auto-formatting (with Prettier) for the newIDE/app directory."
+    },
+    {
+      "type": "npm",
+      "script": "test",
+      "path": "newIDE/app/",
+      "group": {
+        "kind": "test",
+        "isDefault": true
+      },
+      "problemMatcher": [],
+      "label": "Run newIDE tests",
+      "detail": "Run tests for newIDE."
+    },
+    {
+      "type": "typescript",
+      "tsconfig": "GDJS/tsconfig.json",
+      "option": "watch",
+      "problemMatcher": ["$tsc-watch"],
+      "group": "test",
+      "label": "GDJS TS Check",
+      "detail": "Runs a types check on the GDJS Runtime."
+    },
+    {
+      "type": "npm",
+      "script": "test",
+      "path": "GDJS/",
+      "group": "test",
+      "problemMatcher": [],
+      "label": "Run GDJS tests",
+      "detail": "Run tests for GDJS."
+    }
+  ]
 }

Binaries/.directory

@@ -1,6 +0,0 @@
-[Dolphin]
-Timestamp=2015,4,21,21,49,19
-Version=3
-
-[Settings]
-HiddenFilesShown=true

Binaries/README.md

@@ -1,4 +1,3 @@
-This is the directory where native/WebAssembly binaries from GDCore, GDCpp and GDJS are produced.
+This is the directory where native or WebAssembly binaries of the C++ code of GDCore, GDCpp and GDJS are produced.
 
-In particular, the extensions and/or the JS platform files will be
-created into Output/Release_*OSNAME* with *OSNAME* being Windows, Linux or Darwin.
+See GDevelop.js README for the instructions to compile after a change in the C++ source code.

Core/GDCore/Events/Builtin/ForEachChildVariableEvent.cpp

@@ -0,0 +1,73 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+
+#include "ForEachChildVariableEvent.h"
+#include "GDCore/Events/Serialization.h"
+#include "GDCore/Serialization/SerializerElement.h"
+
+using namespace std;
+
+namespace gd {
+
+ForEachChildVariableEvent::ForEachChildVariableEvent()
+    : BaseEvent(), valueIteratorVariableName("child"), keyIteratorVariableName(""), iterableVariableName("") {}
+
+vector<gd::InstructionsList*> ForEachChildVariableEvent::GetAllConditionsVectors() {
+  vector<gd::InstructionsList*> allConditions;
+  allConditions.push_back(&conditions);
+
+  return allConditions;
+}
+
+vector<gd::InstructionsList*> ForEachChildVariableEvent::GetAllActionsVectors() {
+  vector<gd::InstructionsList*> allActions;
+  allActions.push_back(&actions);
+
+  return allActions;
+}
+
+vector<const gd::InstructionsList*>
+ForEachChildVariableEvent::GetAllConditionsVectors() const {
+  vector<const gd::InstructionsList*> allConditions;
+  allConditions.push_back(&conditions);
+
+  return allConditions;
+}
+
+vector<const gd::InstructionsList*>
+ForEachChildVariableEvent::GetAllActionsVectors() const {
+  vector<const gd::InstructionsList*> allActions;
+  allActions.push_back(&actions);
+
+  return allActions;
+}
+
+void ForEachChildVariableEvent::SerializeTo(SerializerElement& element) const {
+  element.AddChild("iterableVariableName").SetValue(iterableVariableName);
+  element.AddChild("valueIteratorVariableName").SetValue(valueIteratorVariableName);
+  element.AddChild("keyIteratorVariableName").SetValue(keyIteratorVariableName);
+  gd::EventsListSerialization::SerializeInstructionsTo(
+      conditions, element.AddChild("conditions"));
+  gd::EventsListSerialization::SerializeInstructionsTo(
+      actions, element.AddChild("actions"));
+  gd::EventsListSerialization::SerializeEventsTo(events,
+                                                 element.AddChild("events"));
+}
+
+void ForEachChildVariableEvent::UnserializeFrom(gd::Project& project,
+                                            const SerializerElement& element) {
+  iterableVariableName = element.GetChild("iterableVariableName", 0, "").GetValue().GetString();
+  valueIteratorVariableName = element.GetChild("valueIteratorVariableName", 0, "").GetValue().GetString();
+  keyIteratorVariableName = element.GetChild("keyIteratorVariableName", 0, "").GetValue().GetString();
+  gd::EventsListSerialization::UnserializeInstructionsFrom(
+      project, conditions, element.GetChild("conditions", 0, "Conditions"));
+  gd::EventsListSerialization::UnserializeInstructionsFrom(
+      project, actions, element.GetChild("actions", 0, "Actions"));
+  gd::EventsListSerialization::UnserializeEventsFrom(
+      project, events, element.GetChild("events", 0, "Events"));
+}
+
+}  // namespace gd

Core/GDCore/Events/Builtin/ForEachChildVariableEvent.h

@@ -0,0 +1,110 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+
+#ifndef FOREACHCHILDVARIABLEEVENT_H
+#define FOREACHCHILDVARIABLEEVENT_H
+#include "GDCore/Events/Event.h"
+#include "GDCore/Events/EventsList.h"
+namespace gd {
+class Instruction;
+class Project;
+class Layout;
+}  // namespace gd
+
+namespace gd {
+
+/**
+ * \brief Event repeated for each every child of a structure variable.
+ */
+class GD_CORE_API ForEachChildVariableEvent : public gd::BaseEvent {
+ public:
+  ForEachChildVariableEvent();
+  virtual ~ForEachChildVariableEvent(){};
+  virtual gd::ForEachChildVariableEvent* Clone() const {
+    return new ForEachChildVariableEvent(*this);
+  }
+
+  virtual bool IsExecutable() const { return true; }
+
+  virtual bool CanHaveSubEvents() const { return true; }
+  virtual const gd::EventsList& GetSubEvents() const { return events; };
+  virtual gd::EventsList& GetSubEvents() { return events; };
+
+  const gd::InstructionsList& GetConditions() const { return conditions; };
+  gd::InstructionsList& GetConditions() { return conditions; };
+
+  const gd::InstructionsList& GetActions() const { return actions; };
+  gd::InstructionsList& GetActions() { return actions; };
+
+  /**
+   * \brief Get the iterable variable name attached to the event.
+   *
+   * It is the structure variable that will be iterated on.
+   */
+  const gd::String& GetIterableVariableName() const { return iterableVariableName; };
+
+  /**
+   * \brief Set the iterable variable name attached to the event.
+   *
+   * It is the structure variable that will be iterated on.
+   */
+  void SetIterableVariableName(gd::String newName) { iterableVariableName = newName; };
+
+  /**
+   * \brief Get the value iterator variable attached to the event.
+   *
+   * It is the variable that will contain the value of the 
+   * iterable's child being iterated on.
+   */
+  const gd::String& GetValueIteratorVariableName() const { return valueIteratorVariableName; };
+
+  /**
+   * \brief Set the value iterator variable attached to the event.
+   *
+   * It is the variable that will contain the value of the 
+   * iterable's child being iterated on.
+   */
+  void SetValueIteratorVariableName(gd::String newName) { valueIteratorVariableName = newName; };
+
+  /**
+   * \brief Get the key iterator variable attached to the event.
+   *
+   * It is the variable that will contain the name of the 
+   * iterable's child being iterated on.
+   */
+  const gd::String& GetKeyIteratorVariableName() const { return keyIteratorVariableName; };
+
+  /**
+   * \brief Set the key iterator variable attached to the event.
+   *
+   * It is the variable that will contain the name of the 
+   * iterable's child being iterated on.
+   */
+  void SetKeyIteratorVariableName(gd::String newName) { keyIteratorVariableName = newName; };
+
+  virtual std::vector<const gd::InstructionsList*> GetAllConditionsVectors()
+      const;
+  virtual std::vector<const gd::InstructionsList*> GetAllActionsVectors() const;
+
+  virtual std::vector<gd::InstructionsList*> GetAllConditionsVectors();
+  virtual std::vector<gd::InstructionsList*> GetAllActionsVectors();
+
+  virtual void SerializeTo(SerializerElement& element) const;
+  virtual void UnserializeFrom(gd::Project& project,
+                               const SerializerElement& element);
+
+ private:
+  gd::String valueIteratorVariableName;
+  gd::String keyIteratorVariableName;
+  gd::String iterableVariableName;
+  gd::InstructionsList conditions;
+  gd::InstructionsList actions;
+  gd::EventsList events;
+};
+
+}  // namespace gd
+
+#endif  // FOREACHEVENT_H

Core/GDCore/Events/CodeGeneration/EffectsCodeGenerator.cpp

@@ -9,6 +9,7 @@
 #include "GDCore/Extensions/Metadata/MetadataProvider.h"
 #include "GDCore/Project/Effect.h"
 #include "GDCore/Project/Layer.h"
+#include "GDCore/Project/EffectsContainer.h"
 #include "GDCore/Project/Layout.h"
 #include "GDCore/Project/Project.h"
 
@@ -26,10 +27,9 @@ void ExposeProjectEffects(
     auto& layout = project.GetLayout(s);
 
     for (std::size_t l = 0; l < layout.GetLayersCount(); ++l) {
-      auto& layer = layout.GetLayer(l);
-
-      for (std::size_t e = 0; e < layer.GetEffectsCount(); ++e) {
-        auto& effect = layer.GetEffect(e);
+      auto& effects = layout.GetLayer(l).GetEffects();
+      for (std::size_t e = 0; e < effects.GetEffectsCount(); ++e) {
+        auto& effect = effects.GetEffect(e);
         worker(effect);
       }
     }

Core/GDCore/Events/CodeGeneration/EventsCodeGenerator.cpp

@@ -288,7 +288,7 @@ gd::String EventsCodeGenerator::GenerateConditionCode(
     condition.SetParameters(parameters);
   }
 
-  // Verify that there are not mismatch between object type in parameters
+  // Verify that there are no mismatchs between object type in parameters.
   for (std::size_t pNb = 0; pNb < instrInfos.parameters.size(); ++pNb) {
     if (ParameterMetadata::IsObject(instrInfos.parameters[pNb].type)) {
       gd::String objectInParameter =
@@ -312,9 +312,69 @@ gd::String EventsCodeGenerator::GenerateConditionCode(
     }
   }
 
-  // Generate static condition if available
-  if (MetadataProvider::HasCondition(platform, condition.GetType())) {
-    // Prepare arguments
+  if (instrInfos.IsObjectInstruction()) {
+    gd::String objectName = condition.GetParameter(0).GetPlainString();
+    gd::String objectType = gd::GetTypeOfObject(
+        GetGlobalObjectsAndGroups(), GetObjectsAndGroups(), objectName);
+    if (!objectName.empty() && !instrInfos.parameters.empty()) {
+      std::vector<gd::String> realObjects =
+          ExpandObjectsName(objectName, context);
+      for (std::size_t i = 0; i < realObjects.size(); ++i) {
+        // Set up the context
+        const ObjectMetadata& objInfo =
+            MetadataProvider::GetObjectMetadata(platform, objectType);
+        AddIncludeFiles(objInfo.includeFiles);
+        context.SetCurrentObject(realObjects[i]);
+        context.ObjectsListNeeded(realObjects[i]);
+
+        // Prepare arguments and generate the condition whole code
+        vector<gd::String> arguments = GenerateParametersCodes(
+            condition.GetParameters(), instrInfos.parameters, context);
+        conditionCode += GenerateObjectCondition(realObjects[i],
+                                                 objInfo,
+                                                 arguments,
+                                                 instrInfos,
+                                                 returnBoolean,
+                                                 condition.IsInverted(),
+                                                 context);
+
+        context.SetNoCurrentObject();
+      }
+    }
+  } else if (instrInfos.IsBehaviorInstruction()) {
+    gd::String objectName = condition.GetParameter(0).GetPlainString();
+    gd::String behaviorType =
+        gd::GetTypeOfBehavior(GetGlobalObjectsAndGroups(),
+                              GetObjectsAndGroups(),
+                              condition.GetParameter(1).GetPlainString());
+    if (instrInfos.parameters.size() >= 2) {
+      std::vector<gd::String> realObjects =
+          ExpandObjectsName(objectName, context);
+      for (std::size_t i = 0; i < realObjects.size(); ++i) {
+        // Setup context
+        const BehaviorMetadata& autoInfo =
+            MetadataProvider::GetBehaviorMetadata(platform, behaviorType);
+        AddIncludeFiles(autoInfo.includeFiles);
+        context.SetCurrentObject(realObjects[i]);
+        context.ObjectsListNeeded(realObjects[i]);
+
+        // Prepare arguments and generate the whole condition code
+        vector<gd::String> arguments = GenerateParametersCodes(
+            condition.GetParameters(), instrInfos.parameters, context);
+        conditionCode += GenerateBehaviorCondition(
+            realObjects[i],
+            condition.GetParameter(1).GetPlainString(),
+            autoInfo,
+            arguments,
+            instrInfos,
+            returnBoolean,
+            condition.IsInverted(),
+            context);
+
+        context.SetNoCurrentObject();
+      }
+    }
+  } else {
     std::vector<std::pair<gd::String, gd::String> >
         supplementaryParametersTypes;
     supplementaryParametersTypes.push_back(std::make_pair(
@@ -329,78 +389,6 @@ gd::String EventsCodeGenerator::GenerateConditionCode(
         arguments, instrInfos, returnBoolean, condition.IsInverted(), context);
   }
 
-  // Generate object condition if available
-  gd::String objectName = condition.GetParameters().empty()
-                              ? ""
-                              : condition.GetParameter(0).GetPlainString();
-  gd::String objectType = gd::GetTypeOfObject(
-      GetGlobalObjectsAndGroups(), GetObjectsAndGroups(), objectName);
-  if (!objectName.empty() &&
-      MetadataProvider::HasObjectCondition(
-          platform, objectType, condition.GetType()) &&
-      !instrInfos.parameters.empty()) {
-    std::vector<gd::String> realObjects =
-        ExpandObjectsName(objectName, context);
-    for (std::size_t i = 0; i < realObjects.size(); ++i) {
-      // Set up the context
-      const ObjectMetadata& objInfo =
-          MetadataProvider::GetObjectMetadata(platform, objectType);
-      AddIncludeFiles(objInfo.includeFiles);
-      context.SetCurrentObject(realObjects[i]);
-      context.ObjectsListNeeded(realObjects[i]);
-
-      // Prepare arguments and generate the condition whole code
-      vector<gd::String> arguments = GenerateParametersCodes(
-          condition.GetParameters(), instrInfos.parameters, context);
-      conditionCode += GenerateObjectCondition(realObjects[i],
-                                               objInfo,
-                                               arguments,
-                                               instrInfos,
-                                               returnBoolean,
-                                               condition.IsInverted(),
-                                               context);
-
-      context.SetNoCurrentObject();
-    }
-  }
-
-  // Generate behavior condition if available
-  gd::String behaviorType =
-      gd::GetTypeOfBehavior(GetGlobalObjectsAndGroups(),
-                            GetObjectsAndGroups(),
-                            condition.GetParameters().size() < 2
-                                ? ""
-                                : condition.GetParameter(1).GetPlainString());
-  if (MetadataProvider::HasBehaviorCondition(
-          platform, behaviorType, condition.GetType()) &&
-      instrInfos.parameters.size() >= 2) {
-    std::vector<gd::String> realObjects =
-        ExpandObjectsName(objectName, context);
-    for (std::size_t i = 0; i < realObjects.size(); ++i) {
-      // Setup context
-      const BehaviorMetadata& autoInfo =
-          MetadataProvider::GetBehaviorMetadata(platform, behaviorType);
-      AddIncludeFiles(autoInfo.includeFiles);
-      context.SetCurrentObject(realObjects[i]);
-      context.ObjectsListNeeded(realObjects[i]);
-
-      // Prepare arguments and generate the whole condition code
-      vector<gd::String> arguments = GenerateParametersCodes(
-          condition.GetParameters(), instrInfos.parameters, context);
-      conditionCode +=
-          GenerateBehaviorCondition(realObjects[i],
-                                    condition.GetParameter(1).GetPlainString(),
-                                    autoInfo,
-                                    arguments,
-                                    instrInfos,
-                                    returnBoolean,
-                                    condition.IsInverted(),
-                                    context);
-
-      context.SetNoCurrentObject();
-    }
-  }
-
   return conditionCode;
 }
 
@@ -417,9 +405,6 @@ gd::String EventsCodeGenerator::GenerateConditionsListCode(
         "condition" + gd::String::From(i) + "IsTrue", context);
 
   for (std::size_t cId = 0; cId < conditions.size(); ++cId) {
-    gd::InstructionMetadata instrInfos = MetadataProvider::GetConditionMetadata(
-        platform, conditions[cId].GetType());
-
     gd::String conditionCode =
         GenerateConditionCode(conditions[cId],
                               "condition" + gd::String::From(cId) + "IsTrue",
@@ -472,7 +457,7 @@ gd::String EventsCodeGenerator::GenerateActionCode(
     action.SetParameters(parameters);
   }
 
-  // Verify that there are not mismatch between object type in parameters
+  // Verify that there are no mismatchs between object type in parameters.
   for (std::size_t pNb = 0; pNb < instrInfos.parameters.size(); ++pNb) {
     if (ParameterMetadata::IsObject(instrInfos.parameters[pNb].type)) {
       gd::String objectInParameter = action.GetParameter(pNb).GetPlainString();
@@ -495,77 +480,69 @@ gd::String EventsCodeGenerator::GenerateActionCode(
   }
 
   // Call free function first if available
-  if (MetadataProvider::HasAction(platform, action.GetType())) {
+  if (instrInfos.IsObjectInstruction()) {
+    gd::String objectName = action.GetParameter(0).GetPlainString();
+    gd::String objectType = gd::GetTypeOfObject(
+        GetGlobalObjectsAndGroups(), GetObjectsAndGroups(), objectName);
+
+    if (!instrInfos.parameters.empty()) {
+      std::vector<gd::String> realObjects =
+          ExpandObjectsName(objectName, context);
+      for (std::size_t i = 0; i < realObjects.size(); ++i) {
+        // Setup context
+        const ObjectMetadata& objInfo =
+            MetadataProvider::GetObjectMetadata(platform, objectType);
+        AddIncludeFiles(objInfo.includeFiles);
+        context.SetCurrentObject(realObjects[i]);
+        context.ObjectsListNeeded(realObjects[i]);
+
+        // Prepare arguments and generate the whole action code
+        vector<gd::String> arguments = GenerateParametersCodes(
+            action.GetParameters(), instrInfos.parameters, context);
+        actionCode += GenerateObjectAction(
+            realObjects[i], objInfo, arguments, instrInfos, context);
+
+        context.SetNoCurrentObject();
+      }
+    }
+  } else if (instrInfos.IsBehaviorInstruction()) {
+    gd::String objectName = action.GetParameter(0).GetPlainString();
+    gd::String behaviorType =
+        gd::GetTypeOfBehavior(GetGlobalObjectsAndGroups(),
+                              GetObjectsAndGroups(),
+                              action.GetParameter(1).GetPlainString());
+
+    if (instrInfos.parameters.size() >= 2) {
+      std::vector<gd::String> realObjects =
+          ExpandObjectsName(objectName, context);
+      for (std::size_t i = 0; i < realObjects.size(); ++i) {
+        // Setup context
+        const BehaviorMetadata& autoInfo =
+            MetadataProvider::GetBehaviorMetadata(platform, behaviorType);
+        AddIncludeFiles(autoInfo.includeFiles);
+        context.SetCurrentObject(realObjects[i]);
+        context.ObjectsListNeeded(realObjects[i]);
+
+        // Prepare arguments and generate the whole action code
+        vector<gd::String> arguments = GenerateParametersCodes(
+            action.GetParameters(), instrInfos.parameters, context);
+        actionCode +=
+            GenerateBehaviorAction(realObjects[i],
+                                   action.GetParameter(1).GetPlainString(),
+                                   autoInfo,
+                                   arguments,
+                                   instrInfos,
+                                   context);
+
+        context.SetNoCurrentObject();
+      }
+    }
+  } else {
     vector<gd::String> arguments = GenerateParametersCodes(
         action.GetParameters(), instrInfos.parameters, context);
     actionCode += GenerateFreeAction(arguments, instrInfos, context);
   }
 
-  // Call object function if available
-  gd::String objectName = action.GetParameters().empty()
-                              ? ""
-                              : action.GetParameter(0).GetPlainString();
-  gd::String objectType = gd::GetTypeOfObject(
-      GetGlobalObjectsAndGroups(), GetObjectsAndGroups(), objectName);
-  if (MetadataProvider::HasObjectAction(
-          platform, objectType, action.GetType()) &&
-      !instrInfos.parameters.empty()) {
-    std::vector<gd::String> realObjects =
-        ExpandObjectsName(objectName, context);
-    for (std::size_t i = 0; i < realObjects.size(); ++i) {
-      // Setup context
-      const ObjectMetadata& objInfo =
-          MetadataProvider::GetObjectMetadata(platform, objectType);
-      AddIncludeFiles(objInfo.includeFiles);
-      context.SetCurrentObject(realObjects[i]);
-      context.ObjectsListNeeded(realObjects[i]);
-
-      // Prepare arguments and generate the whole action code
-      vector<gd::String> arguments = GenerateParametersCodes(
-          action.GetParameters(), instrInfos.parameters, context);
-      actionCode += GenerateObjectAction(
-          realObjects[i], objInfo, arguments, instrInfos, context);
-
-      context.SetNoCurrentObject();
-    }
-  }
-
-  // Assign to a behavior member function if found
-  gd::String behaviorType =
-      gd::GetTypeOfBehavior(GetGlobalObjectsAndGroups(),
-                            GetObjectsAndGroups(),
-                            action.GetParameters().size() < 2
-                                ? ""
-                                : action.GetParameter(1).GetPlainString());
-
-  if (MetadataProvider::HasBehaviorAction(
-          platform, behaviorType, action.GetType()) &&
-      instrInfos.parameters.size() >= 2) {
-    std::vector<gd::String> realObjects =
-        ExpandObjectsName(objectName, context);
-    for (std::size_t i = 0; i < realObjects.size(); ++i) {
-      // Setup context
-      const BehaviorMetadata& autoInfo =
-          MetadataProvider::GetBehaviorMetadata(platform, behaviorType);
-      AddIncludeFiles(autoInfo.includeFiles);
-      context.SetCurrentObject(realObjects[i]);
-      context.ObjectsListNeeded(realObjects[i]);
-
-      // Prepare arguments and generate the whole action code
-      vector<gd::String> arguments = GenerateParametersCodes(
-          action.GetParameters(), instrInfos.parameters, context);
-      actionCode +=
-          GenerateBehaviorAction(realObjects[i],
-                                 action.GetParameter(1).GetPlainString(),
-                                 autoInfo,
-                                 arguments,
-                                 instrInfos,
-                                 context);
-
-      context.SetNoCurrentObject();
-    }
-  }
-
   return actionCode;
 }
 
@@ -576,9 +553,6 @@ gd::String EventsCodeGenerator::GenerateActionsListCode(
     gd::InstructionsList& actions, EventsCodeGenerationContext& context) {
   gd::String outputCode;
   for (std::size_t aId = 0; aId < actions.size(); ++aId) {
-    gd::InstructionMetadata instrInfos =
-        MetadataProvider::GetActionMetadata(platform, actions[aId].GetType());
-
     gd::String actionCode = GenerateActionCode(actions[aId], context);
 
     outputCode += "{";
@@ -1127,10 +1101,11 @@ size_t EventsCodeGenerator::GenerateSingleUsageUniqueIdFor(
   // in memory will get the same id across different code generations.
   size_t uniqueId = (size_t)instruction;
 
-  // While in most case this function is called a single time for each instruction,
-  // it's possible for an instruction to be appearing more than once in the events,
-  // if we used links. In this case, simply increment the unique id to be sure that
-  // ids are effectively uniques, and stay stable (given the same order of links).
+  // While in most case this function is called a single time for each
+  // instruction, it's possible for an instruction to be appearing more than
+  // once in the events, if we used links. In this case, simply increment the
+  // unique id to be sure that ids are effectively uniques, and stay stable
+  // (given the same order of links).
   while (instructionUniqueIds.find(uniqueId) != instructionUniqueIds.end()) {
     uniqueId++;
   }

Core/GDCore/Events/CodeGeneration/ExpressionCodeGenerator.cpp

@@ -4,8 +4,10 @@
  * reserved. This project is released under the MIT License.
  */
 #include "ExpressionCodeGenerator.h"
+
 #include <memory>
 #include <vector>
+
 #include "GDCore/CommonTools.h"
 #include "GDCore/Events/CodeGeneration/EventsCodeGenerationContext.h"
 #include "GDCore/Events/CodeGeneration/EventsCodeGenerator.h"
@@ -35,11 +37,18 @@ gd::String ExpressionCodeGenerator::GenerateExpressionCode(
   gd::ExpressionParser2 parser(codeGenerator.GetPlatform(),
                                codeGenerator.GetGlobalObjectsAndGroups(),
                                codeGenerator.GetObjectsAndGroups());
+  ExpressionCodeGenerator generator(codeGenerator, context);
+
   auto node = parser.ParseExpression(type, expression, objectName);
+  if (!node) {
+    std::cout << "Error: error while parsing: \"" << expression << "\" ("
+              << type << ")" << std::endl;
+
+    return generator.GenerateDefaultValue(type);
+  }
+
   gd::ExpressionValidator validator;
   node->Visit(validator);
-
-  ExpressionCodeGenerator generator(codeGenerator, context);
   if (!validator.GetErrors().empty()) {
     std::cout << "Error: \"" << validator.GetErrors()[0]->GetMessage()
               << "\" in: \"" << expression << "\" (" << type << ")"
@@ -130,8 +139,8 @@ void ExpressionCodeGenerator::OnVisitIdentifierNode(IdentifierNode& node) {
 void ExpressionCodeGenerator::OnVisitFunctionCallNode(FunctionCallNode& node) {
   if (gd::MetadataProvider::IsBadExpressionMetadata(node.expressionMetadata)) {
     output += "/* Error during generation, function not found: " +
-              codeGenerator.ConvertToString(node.functionName) + " for type " +
-              node.type + " */ " + GenerateDefaultValue(node.type);
+              codeGenerator.ConvertToString(node.functionName) + " */ " +
+              GenerateDefaultValue(node.type);
     return;
   }
 
@@ -351,15 +360,19 @@ gd::String ExpressionCodeGenerator::GenerateDefaultValue(
   if (gd::ParameterMetadata::IsObject(type)) {
     return codeGenerator.GenerateBadObject();
   }
+  if (gd::ParameterMetadata::IsExpression("string", type)) {
+    return "\"\"";
+  }
 
-  return (type == "string") ? "\"\"" : "0";
+  return "0";
 }
 
 void ExpressionCodeGenerator::OnVisitEmptyNode(EmptyNode& node) {
   output += GenerateDefaultValue(node.type);
 }
 
-void ExpressionCodeGenerator::OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) {
+void ExpressionCodeGenerator::OnVisitObjectFunctionNameNode(
+    ObjectFunctionNameNode& node) {
   output += GenerateDefaultValue(node.type);
 }
 

Core/GDCore/Events/Parsers/ExpressionParser2.cpp

@@ -4,9 +4,11 @@
  * reserved. This project is released under the MIT License.
  */
 #include "GDCore/Events/Parsers/ExpressionParser2.h"
+
 #include <algorithm>
 #include <memory>
 #include <vector>
+
 #include "GDCore/CommonTools.h"
 #include "GDCore/Events/Expression.h"
 #include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
@@ -67,7 +69,9 @@ size_t GetMaximumParametersNumber(
 }  // namespace
 
 std::unique_ptr<ExpressionParserDiagnostic> ExpressionParser2::ValidateFunction(
-    const gd::FunctionCallNode& function, size_t functionStartPosition) {
+    const gd::String& type,
+    const gd::FunctionCallNode& function,
+    size_t functionStartPosition) {
   if (gd::MetadataProvider::IsBadExpressionMetadata(
           function.expressionMetadata)) {
     return gd::make_unique<ExpressionParserError>(
@@ -79,6 +83,41 @@ std::unique_ptr<ExpressionParserDiagnostic> ExpressionParser2::ValidateFunction(
         GetCurrentPosition());
   }
 
+  // Validate the type of the function
+  const gd::String& returnType = function.expressionMetadata.GetReturnType();
+  if (returnType == "number") {
+    if (type == "string")
+      return RaiseTypeError(
+          _("You tried to use an expression that returns a number, but a "
+            "string is expected. Use `ToString` if you need to convert a "
+            "number to a string."),
+          functionStartPosition);
+    else if (type != "number" && type != "number|string")
+      return RaiseTypeError(_("You tried to use an expression that returns a "
+                              "number, but another type is expected:") +
+                              " " + type,
+                            functionStartPosition);
+  } else if (returnType == "string") {
+    if (type == "number")
+      return RaiseTypeError(
+          _("You tried to use an expression that returns a string, but a "
+            "number is expected. Use `ToNumber` if you need to convert a "
+            "string to a number."),
+          functionStartPosition);
+    else if (type != "string" && type != "number|string")
+      return RaiseTypeError(_("You tried to use an expression that returns a "
+                              "string, but another type is expected:") +
+                              " " + type,
+                            functionStartPosition);
+  } else {
+    if (type != returnType)
+      return RaiseTypeError(
+          _("You tried to use an expression with the wrong return type:") + " " +
+            returnType,
+          functionStartPosition);
+  }
+
+  // Validate parameters count
   size_t minParametersCount = GetMinimumParametersNumber(
       function.expressionMetadata.parameters,
       WrittenParametersFirstIndex(function.objectName, function.behaviorName));
@@ -115,7 +154,8 @@ std::unique_ptr<TextNode> ExpressionParser2::ReadText() {
     auto text = gd::make_unique<TextNode>("");
     text->diagnostic =
         RaiseSyntaxError(_("A text must start with a double quote (\")."));
-    text->location = ExpressionParserLocation(textStartPosition, GetCurrentPosition());
+    text->location =
+        ExpressionParserLocation(textStartPosition, GetCurrentPosition());
     return text;
   }
   SkipChar();
@@ -150,7 +190,8 @@ std::unique_ptr<TextNode> ExpressionParser2::ReadText() {
   }
 
   auto text = gd::make_unique<TextNode>(parsedText);
-  text->location = ExpressionParserLocation(textStartPosition, GetCurrentPosition());
+  text->location =
+      ExpressionParserLocation(textStartPosition, GetCurrentPosition());
   if (!textParsingHasEnded) {
     text->diagnostic =
         RaiseSyntaxError(_("A text must end with a double quote (\"). Add a "
@@ -172,7 +213,7 @@ std::unique_ptr<NumberNode> ExpressionParser2::ReadNumber() {
     if (CheckIfChar(IsZeroDigit)) {
       numberHasStarted = true;
       digitFound = true;
-      if (!parsedNumber.empty()) { // Ignore leading 0s.
+      if (!parsedNumber.empty()) {  // Ignore leading 0s.
         parsedNumber += GetCurrentChar();
       }
     } else if (CheckIfChar(IsNonZeroDigit)) {
@@ -183,7 +224,8 @@ std::unique_ptr<NumberNode> ExpressionParser2::ReadNumber() {
       numberHasStarted = true;
       dotFound = true;
       if (parsedNumber == "") {
-        parsedNumber += "0."; //Normalize by adding a leading 0, only in this case.
+        parsedNumber +=
+            "0.";  // Normalize by adding a leading 0, only in this case.
       } else {
         parsedNumber += ".";
       }
@@ -204,7 +246,8 @@ std::unique_ptr<NumberNode> ExpressionParser2::ReadNumber() {
   // valid in most languages so we allow this.
 
   auto number = gd::make_unique<NumberNode>(parsedNumber);
-  number->location = ExpressionParserLocation(numberStartPosition, GetCurrentPosition());
+  number->location =
+      ExpressionParserLocation(numberStartPosition, GetCurrentPosition());
   if (!numberHasStarted || !digitFound) {
     number->diagnostic = RaiseSyntaxError(
         _("A number was expected. You must enter a number here."));

Core/GDCore/Events/Parsers/ExpressionParser2.h

@@ -66,6 +66,22 @@ class GD_CORE_API ExpressionParser2 {
     return Start(type, objectName);
   }
 
+  /**
+   * Given an object name (or empty if none) and a behavior name (or empty if none),
+   * return the index of the first parameter that is inside the parenthesis: 
+   * 0, 1 or 2.
+   * 
+   * For example, in an expression like `Object.MyBehavior::Method("hello")`, the
+   * parameter "hello" is the second parameter (the first being by convention Object,
+   * and the second MyBehavior, also by convention).
+   */
+  static size_t WrittenParametersFirstIndex(const gd::String &objectName,
+                                            const gd::String &behaviorName) {
+    // By convention, object is always the first parameter, and behavior the
+    // second one.
+    return !behaviorName.empty() ? 2 : (!objectName.empty() ? 1 : 0);
+  }
+
  private:
   /** \name Grammar
    * Each method is a part of the grammar.
@@ -76,9 +92,11 @@ class GD_CORE_API ExpressionParser2 {
     size_t expressionStartPosition = GetCurrentPosition();
     auto expression = Expression(type, objectName);
 
+    const gd::String &inferredType = expression->type;
+
     // Check for extra characters at the end of the expression
     if (!IsEndReached()) {
-      auto op = gd::make_unique<OperatorNode>(type, ' ');
+      auto op = gd::make_unique<OperatorNode>(inferredType, ' ');
       op->leftHandSide = std::move(expression);
       op->rightHandSide = ReadUntilEnd("unknown");
 
@@ -101,27 +119,29 @@ class GD_CORE_API ExpressionParser2 {
     size_t expressionStartPosition = GetCurrentPosition();
     std::unique_ptr<ExpressionNode> leftHandSide = Term(type, objectName);
 
+    const gd::String &inferredType = leftHandSide->type;
+
     SkipAllWhitespaces();
 
     if (IsEndReached()) return leftHandSide;
     if (CheckIfChar(IsExpressionEndingChar)) return leftHandSide;
     if (CheckIfChar(IsExpressionOperator)) {
-      auto op = gd::make_unique<OperatorNode>(type, GetCurrentChar());
+      auto op = gd::make_unique<OperatorNode>(inferredType, GetCurrentChar());
       op->leftHandSide = std::move(leftHandSide);
-      op->diagnostic = ValidateOperator(type, GetCurrentChar());
+      op->diagnostic = ValidateOperator(inferredType, GetCurrentChar());
       SkipChar();
-      op->rightHandSide = Expression(type, objectName);
+      op->rightHandSide = Expression(inferredType, objectName);
 
       op->location = ExpressionParserLocation(expressionStartPosition,
                                               GetCurrentPosition());
       return std::move(op);
     }
 
-    if (type == "string") {
+    if (inferredType == "string") {
       leftHandSide->diagnostic = RaiseSyntaxError(
           "You must add the operator + between texts or expressions. For "
           "example: \"Your name: \" + VariableString(PlayerName).");
-    } else if (type == "number") {
+    } else if (inferredType == "number") {
       leftHandSide->diagnostic = RaiseSyntaxError(
           "No operator found. Did you forget to enter an operator (like +, -, "
           "* or /) between numbers or expressions?");
@@ -131,9 +151,9 @@ class GD_CORE_API ExpressionParser2 {
           "properly written.");
     }
 
-    auto op = gd::make_unique<OperatorNode>(type, ' ');
+    auto op = gd::make_unique<OperatorNode>(inferredType, ' ');
     op->leftHandSide = std::move(leftHandSide);
-    op->rightHandSide = Expression(type, objectName);
+    op->rightHandSide = Expression(inferredType, objectName);
     op->location =
         ExpressionParserLocation(expressionStartPosition, GetCurrentPosition());
     return std::move(op);
@@ -146,17 +166,19 @@ class GD_CORE_API ExpressionParser2 {
     size_t expressionStartPosition = GetCurrentPosition();
     std::unique_ptr<ExpressionNode> factor = Factor(type, objectName);
 
+    const gd::String &inferredType = factor->type;
+
     SkipAllWhitespaces();
 
     // This while loop is used instead of a recursion (like in Expression)
     // to guarantee the proper operator precedence. (Expression could also
     // be reworked to use a while loop).
     while (CheckIfChar(IsTermOperator)) {
-      auto op = gd::make_unique<OperatorNode>(type, GetCurrentChar());
+      auto op = gd::make_unique<OperatorNode>(inferredType, GetCurrentChar());
       op->leftHandSide = std::move(factor);
-      op->diagnostic = ValidateOperator(type, GetCurrentChar());
+      op->diagnostic = ValidateOperator(inferredType, GetCurrentChar());
       SkipChar();
-      op->rightHandSide = Factor(type, objectName);
+      op->rightHandSide = Factor(inferredType, objectName);
       op->location = ExpressionParserLocation(expressionStartPosition,
                                               GetCurrentPosition());
       SkipAllWhitespaces();
@@ -170,43 +192,51 @@ class GD_CORE_API ExpressionParser2 {
   std::unique_ptr<ExpressionNode> Factor(const gd::String &type,
                                          const gd::String &objectName) {
     SkipAllWhitespaces();
-
     size_t expressionStartPosition = GetCurrentPosition();
-    std::unique_ptr<ExpressionNode> factor;
 
     if (CheckIfChar(IsQuote)) {
-      factor = ReadText();
+      std::unique_ptr<ExpressionNode> factor = ReadText();
       if (type == "number")
         factor->diagnostic =
             RaiseTypeError(_("You entered a text, but a number was expected."),
                            expressionStartPosition);
-      else if (type != "string")
+      else if (type != "string" && type != "number|string")
         factor->diagnostic = RaiseTypeError(
             _("You entered a text, but this type was expected:") + type,
             expressionStartPosition);
-    } else if (CheckIfChar(IsUnaryOperator)) {
-      auto unaryOperator =
-          gd::make_unique<UnaryOperatorNode>(type, GetCurrentChar());
-      unaryOperator->diagnostic = ValidateUnaryOperator(type, GetCurrentChar());
-      SkipChar();
-      unaryOperator->factor = Factor(type, objectName);
 
+      return factor;
+    } else if (CheckIfChar(IsUnaryOperator)) {
+      auto unaryOperatorCharacter = GetCurrentChar();
+      SkipChar();
+
+      auto operatorOperand = Factor(type, objectName);
+      const gd::String &inferredType = operatorOperand->type;
+
+      auto unaryOperator = gd::make_unique<UnaryOperatorNode>(
+          inferredType, unaryOperatorCharacter);
+      unaryOperator->diagnostic = ValidateUnaryOperator(
+          inferredType, unaryOperatorCharacter, expressionStartPosition);
+      unaryOperator->factor = std::move(operatorOperand);
       unaryOperator->location = ExpressionParserLocation(
           expressionStartPosition, GetCurrentPosition());
-      factor = std::move(unaryOperator);
+
+      return std::move(unaryOperator);
     } else if (CheckIfChar(IsNumberFirstChar)) {
-      factor = ReadNumber();
+      std::unique_ptr<ExpressionNode> factor = ReadNumber();
       if (type == "string")
         factor->diagnostic = RaiseTypeError(
             _("You entered a number, but a text was expected (in quotes)."),
             expressionStartPosition);
-      else if (type != "number")
+      else if (type != "number" && type != "number|string")
         factor->diagnostic = RaiseTypeError(
             _("You entered a number, but this type was expected:") + type,
             expressionStartPosition);
+
+      return factor;
     } else if (CheckIfChar(IsOpeningParenthesis)) {
       SkipChar();
-      factor = SubExpression(type, objectName);
+      std::unique_ptr<ExpressionNode> factor = SubExpression(type, objectName);
 
       if (!CheckIfChar(IsClosingParenthesis)) {
         factor->diagnostic =
@@ -214,27 +244,31 @@ class GD_CORE_API ExpressionParser2 {
                                "parenthesis for each opening parenthesis."));
       }
       SkipIfChar(IsClosingParenthesis);
+      return factor;
     } else if (IsIdentifierAllowedChar()) {
       // This is a place where the grammar differs according to the
       // type being expected.
       if (gd::ParameterMetadata::IsExpression("variable", type)) {
-        factor = Variable(type, objectName);
+        return Variable(type, objectName);
       } else {
-        factor = Identifier(type);
+        return Identifier(type);
       }
-    } else {
-      factor = ReadUntilWhitespace(type);
-      factor->diagnostic = RaiseEmptyError(type, expressionStartPosition);
     }
 
+    std::unique_ptr<ExpressionNode> factor = ReadUntilWhitespace(type);
+    factor->diagnostic = RaiseEmptyError(type, expressionStartPosition);
     return factor;
   }
 
   std::unique_ptr<SubExpressionNode> SubExpression(
       const gd::String &type, const gd::String &objectName) {
     size_t expressionStartPosition = GetCurrentPosition();
+
+    auto expression = Expression(type, objectName);
+    const gd::String &inferredType = expression->type;
+
     auto subExpression =
-        gd::make_unique<SubExpressionNode>(type, Expression(type, objectName));
+        gd::make_unique<SubExpressionNode>(inferredType, std::move(expression));
     subExpression->location =
         ExpressionParserLocation(expressionStartPosition, GetCurrentPosition());
 
@@ -285,6 +319,11 @@ class GD_CORE_API ExpressionParser2 {
       } else if (type == "number") {
         identifier->diagnostic = RaiseTypeError(
             _("You must enter a number."), nameLocation.GetStartPosition());
+      } else if (type == "number|string") {
+        identifier->diagnostic = RaiseTypeError(
+            _("You must enter a number or a text, wrapped inside double quotes "
+              "(example: \"Hello world\")."),
+            nameLocation.GetStartPosition());
       } else if (!gd::ParameterMetadata::IsObject(type)) {
         identifier->diagnostic = RaiseTypeError(
             _("You've entered a name, but this type was expected:") + type,
@@ -319,8 +358,8 @@ class GD_CORE_API ExpressionParser2 {
     SkipAllWhitespaces();
     if (CheckIfChar(IsOpeningSquareBracket)) {
       SkipChar();
-      auto child =
-          gd::make_unique<VariableBracketAccessorNode>(Expression("string"));
+      auto child = gd::make_unique<VariableBracketAccessorNode>(
+          Expression("number|string"));
 
       if (!CheckIfChar(IsClosingSquareBracket)) {
         child->diagnostic =
@@ -361,21 +400,19 @@ class GD_CORE_API ExpressionParser2 {
     // TODO: error if trying to use function for type != "number" && != "string"
     // + Test for it
 
-    // This could be improved to have the type passed to a single
-    // GetExpressionMetadata function.
     const gd::ExpressionMetadata &metadata =
-        type == "number" ? MetadataProvider::GetExpressionMetadata(
-                               platform, functionFullName)
-                         : MetadataProvider::GetStrExpressionMetadata(
-                               platform, functionFullName);
+        MetadataProvider::GetAnyExpressionMetadata(platform, functionFullName);
 
     auto parametersNode = Parameters(metadata.parameters);
-    auto function = gd::make_unique<FunctionCallNode>(
-        type, std::move(parametersNode.parameters), metadata, functionFullName);
+    auto function =
+        gd::make_unique<FunctionCallNode>(metadata.GetReturnType(),
+                                          std::move(parametersNode.parameters),
+                                          metadata,
+                                          functionFullName);
     function->diagnostic = std::move(parametersNode.diagnostic);
-    if (!function->diagnostic)
-      function->diagnostic =
-          ValidateFunction(*function, identifierLocation.GetStartPosition());
+    if (!function->diagnostic)  // TODO: reverse the order of diagnostic?
+      function->diagnostic = ValidateFunction(
+          type, *function, identifierLocation.GetStartPosition());
 
     function->location = ExpressionParserLocation(
         identifierLocation.GetStartPosition(), GetCurrentPosition());
@@ -383,6 +420,7 @@ class GD_CORE_API ExpressionParser2 {
     function->openingParenthesisLocation = openingParenthesisLocation;
     function->closingParenthesisLocation =
         parametersNode.closingParenthesisLocation;
+
     return std::move(function);
   }
 
@@ -416,26 +454,21 @@ class GD_CORE_API ExpressionParser2 {
       gd::String objectType =
           GetTypeOfObject(globalObjectsContainer, objectsContainer, objectName);
 
-      // This could be improved to have the type passed to a single
-      // GetExpressionMetadata function.
       const gd::ExpressionMetadata &metadata =
-          type == "number"
-              ? MetadataProvider::GetObjectExpressionMetadata(
-                    platform, objectType, objectFunctionOrBehaviorName)
-              : MetadataProvider::GetObjectStrExpressionMetadata(
-                    platform, objectType, objectFunctionOrBehaviorName);
+          MetadataProvider::GetObjectAnyExpressionMetadata(
+              platform, objectType, objectFunctionOrBehaviorName);
 
       auto parametersNode = Parameters(metadata.parameters, objectName);
       auto function = gd::make_unique<FunctionCallNode>(
-          type,
+          metadata.GetReturnType(),
           objectName,
           std::move(parametersNode.parameters),
           metadata,
           objectFunctionOrBehaviorName);
       function->diagnostic = std::move(parametersNode.diagnostic);
-      if (!function->diagnostic)
-        function->diagnostic =
-            ValidateFunction(*function, objectNameLocation.GetStartPosition());
+      if (!function->diagnostic)  // TODO: reverse the order of diagnostic?
+        function->diagnostic = ValidateFunction(
+            type, *function, objectNameLocation.GetStartPosition());
 
       function->location = ExpressionParserLocation(
           objectNameLocation.GetStartPosition(), GetCurrentPosition());
@@ -483,27 +516,23 @@ class GD_CORE_API ExpressionParser2 {
       gd::String behaviorType = GetTypeOfBehavior(
           globalObjectsContainer, objectsContainer, behaviorName);
 
-      // This could be improved to have the type passed to a single
-      // GetExpressionMetadata function.
       const gd::ExpressionMetadata &metadata =
-          type == "number" ? MetadataProvider::GetBehaviorExpressionMetadata(
-                                 platform, behaviorType, functionName)
-                           : MetadataProvider::GetBehaviorStrExpressionMetadata(
-                                 platform, behaviorType, functionName);
+          MetadataProvider::GetBehaviorAnyExpressionMetadata(
+              platform, behaviorType, functionName);
 
       auto parametersNode =
           Parameters(metadata.parameters, objectName, behaviorName);
       auto function = gd::make_unique<FunctionCallNode>(
-          type,
+          metadata.GetReturnType(),
           objectName,
           behaviorName,
           std::move(parametersNode.parameters),
           metadata,
           functionName);
       function->diagnostic = std::move(parametersNode.diagnostic);
-      if (!function->diagnostic)
-        function->diagnostic =
-            ValidateFunction(*function, objectNameLocation.GetStartPosition());
+      if (!function->diagnostic)  // TODO: reverse the order of diagnostic?
+        function->diagnostic = ValidateFunction(
+            type, *function, objectNameLocation.GetStartPosition());
 
       function->location = ExpressionParserLocation(
           objectNameLocation.GetStartPosition(), GetCurrentPosition());
@@ -641,7 +670,9 @@ class GD_CORE_API ExpressionParser2 {
    */
   ///@{
   std::unique_ptr<ExpressionParserDiagnostic> ValidateFunction(
-      const gd::FunctionCallNode &function, size_t functionStartPosition);
+      const gd::String &type,
+      const gd::FunctionCallNode &function,
+      size_t functionStartPosition);
 
   std::unique_ptr<ExpressionParserDiagnostic> ValidateOperator(
       const gd::String &type, gd::String::value_type operatorChar) {
@@ -684,7 +715,9 @@ class GD_CORE_API ExpressionParser2 {
   }
 
   std::unique_ptr<ExpressionParserDiagnostic> ValidateUnaryOperator(
-      const gd::String &type, gd::String::value_type operatorChar) {
+      const gd::String &type,
+      gd::String::value_type operatorChar,
+      size_t position) {
     if (type == "number") {
       if (operatorChar == '+' || operatorChar == '-') {
         return gd::make_unique<ExpressionParserDiagnostic>();
@@ -695,26 +728,26 @@ class GD_CORE_API ExpressionParser2 {
           _("You've used an \"unary\" operator that is not supported. Operator "
             "should be "
             "either + or -."),
-          GetCurrentPosition());
+          position);
     } else if (type == "string") {
       return gd::make_unique<ExpressionParserError>(
           "invalid_operator",
           _("You've used an operator that is not supported. Only + can be used "
             "to concatenate texts, and must be placed between two texts (or "
             "expressions)."),
-          GetCurrentPosition());
+          position);
     } else if (gd::ParameterMetadata::IsObject(type)) {
       return gd::make_unique<ExpressionParserError>(
           "invalid_operator",
           _("Operators (+, -) can't be used with an object name. Remove the "
             "operator."),
-          GetCurrentPosition());
+          position);
     } else if (gd::ParameterMetadata::IsExpression("variable", type)) {
       return gd::make_unique<ExpressionParserError>(
           "invalid_operator",
           _("Operators (+, -) can't be used in variable names. Remove "
             "the operator from the variable name."),
-          GetCurrentPosition());
+          position);
     }
 
     return gd::make_unique<ExpressionParserDiagnostic>();
@@ -982,13 +1015,6 @@ class GD_CORE_API ExpressionParser2 {
   }
   ///@}
 
-  static size_t WrittenParametersFirstIndex(const gd::String &objectName,
-                                            const gd::String &behaviorName) {
-    // By convention, object is always the first parameter, and behavior the
-    // second one.
-    return !behaviorName.empty() ? 2 : (!objectName.empty() ? 1 : 0);
-  }
-
   gd::String expression;
   std::size_t currentPosition;
 

Core/GDCore/Events/Parsers/ExpressionParser2Node.h

@@ -8,6 +8,7 @@
 
 #include <memory>
 #include <vector>
+
 #include "ExpressionParser2NodeWorker.h"
 #include "GDCore/String.h"
 namespace gd {
@@ -84,30 +85,33 @@ struct ExpressionParserError : public ExpressionParserDiagnostic {
  * an expression inherits from.
  */
 struct ExpressionNode {
+  ExpressionNode(const gd::String &type_) : type(type_){};
   virtual ~ExpressionNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker){};
 
   std::unique_ptr<ExpressionParserDiagnostic> diagnostic;
   ExpressionParserLocation location;  ///< The location of the entire node. Some
-                                      ///nodes might have other locations stored
-                                      ///inside them. For example, a function
-                                      ///can store the position of the object
-                                      ///name, the dot, the function name,
-                                      ///etc...
+                                      /// nodes might have other locations
+                                      /// stored inside them. For example, a
+                                      /// function can store the position of the
+                                      /// object name, the dot, the function
+                                      /// name, etc...
+
+  gd::String type;  // Actual type of the node.
+                    // "string", "number", type supported by
+                    // gd::ParameterMetadata::IsObject, types supported by
+                    // gd::ParameterMetadata::IsExpression or "unknown".
 };
 
 struct SubExpressionNode : public ExpressionNode {
   SubExpressionNode(const gd::String &type_,
                     std::unique_ptr<ExpressionNode> expression_)
-      : type(type_), expression(std::move(expression_)){};
+      : ExpressionNode(type_), expression(std::move(expression_)){};
   virtual ~SubExpressionNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitSubExpressionNode(*this);
   };
 
-  gd::String type;  // "string", "number", type supported by
-                    // gd::ParameterMetadata::IsObject, types supported by
-                    // gd::ParameterMetadata::IsExpression or "unknown".
   std::unique_ptr<ExpressionNode> expression;
 };
 
@@ -116,7 +120,7 @@ struct SubExpressionNode : public ExpressionNode {
  */
 struct OperatorNode : public ExpressionNode {
   OperatorNode(const gd::String &type_, gd::String::value_type op_)
-      : type(type_), op(op_){};
+      : ExpressionNode(type_), op(op_){};
   virtual ~OperatorNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitOperatorNode(*this);
@@ -124,9 +128,6 @@ struct OperatorNode : public ExpressionNode {
 
   std::unique_ptr<ExpressionNode> leftHandSide;
   std::unique_ptr<ExpressionNode> rightHandSide;
-  gd::String type;  // "string", "number", type supported by
-                    // gd::ParameterMetadata::IsObject, types supported by
-                    // gd::ParameterMetadata::IsExpression or "unknown".
   gd::String::value_type op;
 };
 
@@ -135,37 +136,38 @@ struct OperatorNode : public ExpressionNode {
  */
 struct UnaryOperatorNode : public ExpressionNode {
   UnaryOperatorNode(const gd::String &type_, gd::String::value_type op_)
-      : type(type_), op(op_){};
+      : ExpressionNode(type_), op(op_){};
   virtual ~UnaryOperatorNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitUnaryOperatorNode(*this);
   };
 
   std::unique_ptr<ExpressionNode> factor;
-  gd::String type;  // "string", "number", type supported by
-                    // gd::ParameterMetadata::IsObject, types supported by
-                    // gd::ParameterMetadata::IsExpression or "unknown".
   gd::String::value_type op;
 };
 
 /**
  * \brief A number node. For example: "123".
+ * Its `type` is always "number".
  */
 struct NumberNode : public ExpressionNode {
-  NumberNode(const gd::String &number_) : number(number_){};
+  NumberNode(const gd::String &number_)
+      : ExpressionNode("number"), number(number_){};
   virtual ~NumberNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitNumberNode(*this);
   };
 
+  //
   gd::String number;
 };
 
 /**
  * \brief A text node. For example: "Hello World".
+ * Its `type` is always "string".
  */
 struct TextNode : public ExpressionNode {
-  TextNode(const gd::String &text_) : text(text_){};
+  TextNode(const gd::String &text_) : ExpressionNode("string"), text(text_){};
   virtual ~TextNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitTextNode(*this);
@@ -175,6 +177,8 @@ struct TextNode : public ExpressionNode {
 };
 
 struct VariableAccessorOrVariableBracketAccessorNode : public ExpressionNode {
+  VariableAccessorOrVariableBracketAccessorNode() : ExpressionNode(""){};
+
   std::unique_ptr<VariableAccessorOrVariableBracketAccessorNode> child;
 };
 
@@ -190,13 +194,12 @@ struct VariableNode : public ExpressionNode {
   VariableNode(const gd::String &type_,
                const gd::String &name_,
                const gd::String &objectName_)
-      : type(type_), name(name_), objectName(objectName_){};
+      : ExpressionNode(type_), name(name_), objectName(objectName_){};
   virtual ~VariableNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitVariableNode(*this);
   };
 
-  gd::String type;
   gd::String name;
   gd::String objectName;
 
@@ -240,7 +243,11 @@ struct VariableBracketAccessorNode
 };
 
 struct IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode
-    : public ExpressionNode {};
+    : public ExpressionNode {
+  IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode(
+      const gd::String &type)
+      : ExpressionNode(type){};
+};
 
 /**
  * \brief An identifier node, usually representing an object or a function name.
@@ -248,18 +255,20 @@ struct IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode
 struct IdentifierNode
     : public IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode {
   IdentifierNode(const gd::String &identifierName_, const gd::String &type_)
-      : identifierName(identifierName_), type(type_){};
+      : IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode(type_),
+        identifierName(identifierName_){};
   virtual ~IdentifierNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitIdentifierNode(*this);
   };
 
   gd::String identifierName;
-  gd::String type;
 };
 
 struct FunctionCallOrObjectFunctionNameOrEmptyNode
     : public IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode {
+  FunctionCallOrObjectFunctionNameOrEmptyNode(const gd::String &type)
+      : IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode(type){};
   virtual ~FunctionCallOrObjectFunctionNameOrEmptyNode(){};
   void Visit(ExpressionParser2NodeWorker &worker) override{};
 };
@@ -274,14 +283,14 @@ struct ObjectFunctionNameNode
   ObjectFunctionNameNode(const gd::String &type_,
                          const gd::String &objectName_,
                          const gd::String &objectFunctionOrBehaviorName_)
-      : type(type_),
+      : FunctionCallOrObjectFunctionNameOrEmptyNode(type_),
         objectName(objectName_),
         objectFunctionOrBehaviorName(objectFunctionOrBehaviorName_) {}
   ObjectFunctionNameNode(const gd::String &type_,
                          const gd::String &objectName_,
                          const gd::String &behaviorName_,
                          const gd::String &behaviorFunctionName_)
-      : type(type_),
+      : FunctionCallOrObjectFunctionNameOrEmptyNode(type_),
         objectName(objectName_),
         objectFunctionOrBehaviorName(behaviorName_),
         behaviorFunctionName(behaviorFunctionName_) {}
@@ -290,34 +299,30 @@ struct ObjectFunctionNameNode
     worker.OnVisitObjectFunctionNameNode(*this);
   };
 
-  gd::String type;  // This could be removed if the type ("string", "number",
-                    // type supported by gd::ParameterMetadata::IsObject, types
-                    // supported by gd::ParameterMetadata::IsExpression or
-                    // "unknown") was stored in ExpressionMetadata.
   gd::String objectName;
   gd::String objectFunctionOrBehaviorName;  ///< Behavior name if
                                             ///`behaviorFunctionName` is not
-                                            ///empty.
+                                            /// empty.
   gd::String behaviorFunctionName;          ///< If empty, then
-                                    ///objectFunctionOrBehaviorName is filled
-                                    ///with the behavior name.
+                                    /// objectFunctionOrBehaviorName is filled
+                                    /// with the behavior name.
 
   ExpressionParserLocation
       objectNameLocation;  ///< Location of the object name.
   ExpressionParserLocation
       objectNameDotLocation;  ///< Location of the "." after the object name.
   ExpressionParserLocation objectFunctionOrBehaviorNameLocation;  ///< Location
-                                                                  ///of object
-                                                                  ///function
-                                                                  ///name or
-                                                                  ///behavior
-                                                                  ///name.
+                                                                  /// of object
+                                                                  /// function
+                                                                  /// name or
+                                                                  /// behavior
+                                                                  /// name.
   ExpressionParserLocation
       behaviorNameNamespaceSeparatorLocation;  ///< Location of the "::"
-                                               ///separator, if any.
+                                               /// separator, if any.
   ExpressionParserLocation behaviorFunctionNameLocation;  ///< Location of the
-                                                          ///behavior function
-                                                          ///name, if any.
+                                                          /// behavior function
+                                                          /// name, if any.
 };
 
 /**
@@ -327,31 +332,36 @@ struct ObjectFunctionNameNode
  * "MyObject.Physics::LinearVelocity()".
  */
 struct FunctionCallNode : public FunctionCallOrObjectFunctionNameOrEmptyNode {
+  /** \brief Construct a free function call node. */
   FunctionCallNode(const gd::String &type_,
                    std::vector<std::unique_ptr<ExpressionNode>> parameters_,
                    const ExpressionMetadata &expressionMetadata_,
                    const gd::String &functionName_)
-      : type(type_),
+      : FunctionCallOrObjectFunctionNameOrEmptyNode(type_),
         parameters(std::move(parameters_)),
         expressionMetadata(expressionMetadata_),
         functionName(functionName_){};
+
+  /** \brief Construct an object function call node. */
   FunctionCallNode(const gd::String &type_,
                    const gd::String &objectName_,
                    std::vector<std::unique_ptr<ExpressionNode>> parameters_,
                    const ExpressionMetadata &expressionMetadata_,
                    const gd::String &functionName_)
-      : type(type_),
+      : FunctionCallOrObjectFunctionNameOrEmptyNode(type_),
         objectName(objectName_),
         parameters(std::move(parameters_)),
         expressionMetadata(expressionMetadata_),
         functionName(functionName_){};
+
+  /** \brief Construct a behavior function call node. */
   FunctionCallNode(const gd::String &type_,
                    const gd::String &objectName_,
                    const gd::String &behaviorName_,
                    std::vector<std::unique_ptr<ExpressionNode>> parameters_,
                    const ExpressionMetadata &expressionMetadata_,
                    const gd::String &functionName_)
-      : type(type_),
+      : FunctionCallOrObjectFunctionNameOrEmptyNode(type_),
         objectName(objectName_),
         behaviorName(behaviorName_),
         parameters(std::move(parameters_)),
@@ -362,10 +372,6 @@ struct FunctionCallNode : public FunctionCallOrObjectFunctionNameOrEmptyNode {
     worker.OnVisitFunctionCallNode(*this);
   };
 
-  gd::String type;  // This could be removed if the type ("string", "number",
-                    // type supported by gd::ParameterMetadata::IsObject, types
-                    // supported by gd::ParameterMetadata::IsExpression or
-                    // "unknown") was stored in ExpressionMetadata.
   gd::String objectName;
   gd::String behaviorName;
   std::vector<std::unique_ptr<ExpressionNode>> parameters;
@@ -382,7 +388,7 @@ struct FunctionCallNode : public FunctionCallOrObjectFunctionNameOrEmptyNode {
       behaviorNameLocation;  ///< Location of the behavior name, if any.
   ExpressionParserLocation
       behaviorNameNamespaceSeparatorLocation;  ///< Location of the "::"
-                                               ///separator, if any.
+                                               /// separator, if any.
   ExpressionParserLocation
       openingParenthesisLocation;  ///< Location of the "(".
   ExpressionParserLocation
@@ -395,15 +401,12 @@ struct FunctionCallNode : public FunctionCallOrObjectFunctionNameOrEmptyNode {
  */
 struct EmptyNode : public FunctionCallOrObjectFunctionNameOrEmptyNode {
   EmptyNode(const gd::String &type_, const gd::String &text_ = "")
-      : type(type_), text(text_){};
+      : FunctionCallOrObjectFunctionNameOrEmptyNode(type_), text(text_){};
   virtual ~EmptyNode(){};
   virtual void Visit(ExpressionParser2NodeWorker &worker) {
     worker.OnVisitEmptyNode(*this);
   };
 
-  gd::String type;  // "string", "number", type supported by
-                    // gd::ParameterMetadata::IsObject, types supported by
-                    // gd::ParameterMetadata::IsExpression or "unknown".
   gd::String text;
 };
 

Core/GDCore/Extensions/Builtin/AdvancedExtension.cpp

@@ -14,7 +14,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsAdvancedExtension(
   extension.SetExtensionInformation(
       "BuiltinAdvanced",
       _("Advanced control features"),
-      _("Built-in extension providing advanced control features."),
+      _("Advanced control features to be used in events."),
       "Florian Rival",
       "Open source (MIT License)");
 

Core/GDCore/Extensions/Builtin/AudioExtension.cpp

@@ -12,11 +12,13 @@ namespace gd {
 void GD_CORE_API BuiltinExtensionsImplementer::ImplementsAudioExtension(
     gd::PlatformExtension& extension) {
   extension
-      .SetExtensionInformation("BuiltinAudio",
-                               _("Audio"),
-                               _("Builtin audio extension"),
-                               "Florian Rival",
-                               "Open source (MIT License)")
+      .SetExtensionInformation(
+          "BuiltinAudio",
+          _("Audio"),
+          _("GDevelop provides several conditions and actions to play audio "
+            "files. They can be either long musics or short sound effects."),
+          "Florian Rival",
+          "Open source (MIT License)")
       .SetExtensionHelpPath("/all-features/audio");
 
 #if defined(GD_IDE_ONLY)
@@ -275,6 +277,74 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsAudioExtension(
       .SetDefaultValue("1")
       .MarkAsSimple();
 
+  extension
+      .AddAction("PreloadMusic",
+                 _("Preload a music file"),
+                 _("Preload a music file in memory."),
+                 _("Preload the music file _PARAM1_"),
+                 _("Audio/Loading"),
+                 "res/actions/music24.png",
+                 "res/actions/music.png")
+      .AddCodeOnlyParameter("currentScene", "")
+      .AddParameter("musicfile", _("Audio file (or audio resource name)"))
+      .MarkAsComplex();
+
+  extension
+      .AddAction("PreloadSound",
+                 _("Preload a sound file"),
+                 _("Preload a sound file in memory."),
+                 _("Preload the sound file _PARAM1_"),
+                 _("Audio/Loading"),
+                 "res/actions/son24.png",
+                 "res/actions/son.png")
+      .AddCodeOnlyParameter("currentScene", "")
+      .AddParameter("soundfile", _("Sound file (or sound resource name)"))
+      .MarkAsComplex();
+
+  extension
+      .AddAction("UnloadMusic",
+                 _("Unload a music file"),
+                 _(
+                    "Unload a music file from memory. "
+                    "Unloading a music file will cause any music playing it to stop."
+                  ),
+                 _("Unload the music file _PARAM1_"),
+                 _("Audio/Loading"),
+                 "res/actions/music24.png",
+                 "res/actions/music.png")
+      .AddCodeOnlyParameter("currentScene", "")
+      .AddParameter("musicfile", _("Audio file (or audio resource name)"))
+      .MarkAsComplex();
+
+  extension
+      .AddAction("UnloadSound",
+                 _("Unload a sound file"),
+                 _(
+                    "Unload a sound file from memory. "
+                    "Unloading a sound file will cause any sounds playing it to stop."
+                  ),
+                 _("Unload the sound file _PARAM1_"),
+                 _("Audio/Loading"),
+                 "res/actions/son24.png",
+                 "res/actions/son.png")
+      .AddCodeOnlyParameter("currentScene", "")
+      .AddParameter("soundfile", _("Sound file (or sound resource name)"))
+      .MarkAsComplex();
+
+  extension
+      .AddAction("UnloadAllAudio",
+                 _("Unload all audio"),
+                 _(
+                   "Unload all the audio in memory. "
+                   "This will cause every sound and music of the game to stop."
+                  ),
+                 _("Unload all audio files"),
+                 _("Audio/Loading"),
+                 "res/actions/music24.png",
+                 "res/actions/music.png")
+      .AddCodeOnlyParameter("currentScene", "")
+      .MarkAsComplex();
+
   extension
       .AddCondition("MusicPlaying",
                     _("A music file is being played"),

Core/GDCore/Extensions/Builtin/BaseObjectExtension.cpp

@@ -6,6 +6,7 @@
 #include "AllBuiltinExtensions.h"
 #include "GDCore/Project/Object.h"
 #include "GDCore/Tools/Localization.h"
+#include "GDCore/Extensions/Metadata/MultipleInstructionMetadata.h"
 
 using namespace std;
 namespace gd {
@@ -26,7 +27,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
 
 #if defined(GD_IDE_ONLY)
   obj.AddCondition("PosX",
-                   _("Compare X position of an object"),
+                   _("X position"),
                    _("Compare the X position of the object."),
                    _("the X position"),
                    _("Position"),
@@ -38,7 +39,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsSimple();
 
   obj.AddAction("MettreX",
-                _("X position of an object"),
+                _("X position"),
                 _("Change the X position of an object."),
                 _("the X position"),
                 _("Position"),
@@ -50,7 +51,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsSimple();
 
   obj.AddCondition("PosY",
-                   _("Compare Y position of an object"),
+                   _("Y position"),
                    _("Compare the Y position of an object."),
                    _("the Y position"),
                    _("Position"),
@@ -62,7 +63,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsSimple();
 
   obj.AddAction("MettreY",
-                _("Y position of an object"),
+                _("Y position"),
                 _("Change the Y position of an object."),
                 _("the Y position"),
                 _("Position"),
@@ -74,7 +75,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsSimple();
 
   obj.AddAction("MettreXY",
-                _("Position of an object"),
+                _("Position"),
                 _("Change the position of an object."),
                 _("Change the position of _PARAM0_: _PARAM1_ _PARAM2_ (x "
                   "axis), _PARAM3_ _PARAM4_ (y axis)"),
@@ -89,8 +90,41 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .AddParameter("expression", _("Y position"))
       .MarkAsSimple();
 
+  obj.AddAction("SetCenter",
+                _("Center position"),
+                _("Change the position of an object, using its center."),
+                _("Change the position of the center of _PARAM0_: _PARAM1_ _PARAM2_ (x "
+                  "axis), _PARAM3_ _PARAM4_ (y axis)"),
+                _("Position/Center"),
+                "res/actions/position24.png",
+                "res/actions/position.png")
+      .AddParameter("object", _("Object"))
+      .AddParameter("operator", _("Modification's sign"))
+      .AddParameter("expression", _("X position"))
+      .AddParameter("operator", _("Modification's sign"))
+      .AddParameter("expression", _("Y position"))
+      .MarkAsSimple();
+
+  obj.AddExpressionAndConditionAndAction("number", "CenterX",
+          _("Center X position"),
+          _("the X position of the center"),
+          _("the X position of the center"),
+          _("Position/Center"),
+          "res/actions/position24.png")
+      .AddParameter("object", _("Object"))
+      .UseStandardParameters("number");
+
+  obj.AddExpressionAndConditionAndAction("number", "CenterY",
+          _("Center Y position"),
+          _("the Y position of the center"),
+          _("the Y position of the center"),
+          _("Position/Center"),
+          "res/actions/position24.png")
+      .AddParameter("object", _("Object"))
+      .UseStandardParameters("number");
+
   obj.AddAction("MettreAutourPos",
-                _("Put an object around a position"),
+                _("Put around a position"),
                 _("Position the center of the given object around a position, "
                   "using the specified angle "
                   "and distance."),
@@ -172,7 +206,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
            "all of the forces it has."),
          _("Add to _PARAM0_ _PARAM3_ force of _PARAM1_ p/s on X axis and "
            "_PARAM2_ p/s on Y axis"),
-         _("Movement"),
+         _("Movement using forces"),
          "res/actions/force24.png",
          "res/actions/force.png")
 
@@ -188,7 +222,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
                   "using the specified angle and length."),
                 _("Add to _PARAM0_ _PARAM3_ force, angle: _PARAM1_ degrees and "
                   "length: _PARAM2_ pixels"),
-                _("Movement"),
+                _("Movement using forces"),
                 "res/actions/force24.png",
                 "res/actions/force.png")
 
@@ -202,9 +236,9 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
          "AddForceVersPos",
          _("Add a force to move toward a position"),
          _("Add a force to an object to make it move toward a position."),
-         _("Move _PARAM0_ to _PARAM1_;_PARAM2_ with _PARAM4_ force of _PARAM3_ "
+         _("Move _PARAM0_ toward _PARAM1_;_PARAM2_ with _PARAM4_ force of _PARAM3_ "
            "pixels"),
-         _("Movement"),
+         _("Movement using forces"),
          "res/actions/force24.png",
          "res/actions/force.png")
 
@@ -217,30 +251,30 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
 
   obj.AddAction(
          "AddForceTournePos",
-         _("Add a force to move around a position"),
-         _("Add a force to an object to make it rotate around a "
+         "Add a force to move around a position",
+         "Add a force to an object to make it rotate around a "
            "position.\nNote that the movement is not precise, especially if "
            "the speed is high.\nTo position an object around a position more "
-           "precisely, use the actions in the category \"Position\"."),
-         _("Rotate _PARAM0_ around _PARAM1_;_PARAM2_ at _PARAM3_ deg/sec and "
-           "_PARAM4_ pixels away"),
-         _("Movement"),
+           "precisely, use the actions in the category \"Position\".",
+         "Rotate _PARAM0_ around _PARAM1_;_PARAM2_ at _PARAM3_ deg/sec and "
+           "_PARAM4_ pixels away",
+         _("Movement using forces"),
          "res/actions/forceTourne24.png",
          "res/actions/forceTourne.png")
 
       .AddParameter("object", _("Object"))
-      .AddParameter("expression", _("X position of the center"))
-      .AddParameter("expression", _("Y position of the center"))
-      .AddParameter("expression", _("Speed (in Degrees per seconds)"))
-      .AddParameter("expression", _("Distance (in pixels)"))
-      .AddParameter("forceMultiplier", _("Force multiplier"))
+      .AddParameter("expression", "X position of the center")
+      .AddParameter("expression", "Y position of the center")
+      .AddParameter("expression", "Speed (in Degrees per seconds)")
+      .AddParameter("expression", "Distance (in pixels)")
+      .AddParameter("forceMultiplier", "Force multiplier")
       .SetHidden();
 
   obj.AddAction("Arreter",
                 _("Stop the object"),
                 _("Stop the object by deleting all of its forces."),
                 _("Stop _PARAM0_ (remove all forces)"),
-                _("Movement"),
+                _("Movement using forces"),
                 "res/actions/arreter24.png",
                 "res/actions/arreter.png")
 
@@ -248,7 +282,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsAdvanced();
 
   obj.AddAction("Delete",
-                _("Delete an object"),
+                _("Delete the object"),
                 _("Delete the specified object."),
                 _("Delete _PARAM0_"),
                 _("Objects"),
@@ -284,8 +318,8 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsAdvanced();
 
   obj.AddAction("ModVarObjet",
-                _("Modify a variable of an object"),
-                _("Modify the value of a variable of an object"),
+                _("Value of an object variable"),
+                _("Change the value of an object variable."),
                 _("the variable _PARAM1_"),
                 _("Variables"),
                 "res/actions/var24.png",
@@ -296,8 +330,8 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .UseStandardOperatorParameters("number");
 
   obj.AddAction("ModVarObjetTxt",
-                _("Modify the text of a variable of an object"),
-                _("Modify the text of a variable of an object"),
+                _("Text of an object variable"),
+                _("Change the text of an object variable."),
                 _("the text of variable _PARAM1_"),
                 _("Variables"),
                 "res/actions/var24.png",
@@ -307,11 +341,39 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .AddParameter("objectvar", _("Variable"))
       .UseStandardOperatorParameters("string");
 
+  obj.AddAction("SetObjectVariableAsBoolean",
+                _("Boolean value of an object variable"),
+                _("Change the boolean value of an object variable."),
+                _("Set the boolean value of the variable _PARAM1_ of object "
+                  "_PARAM0_ to _PARAM2_"),
+                _("Variables"),
+                "res/actions/var24.png",
+                "res/actions/var.png")
+
+      .AddParameter("object", _("Object"))
+      .AddParameter("objectvar", _("Variable"))
+      .AddParameter("trueorfalse", _("New Value:"));
+
+  obj.AddAction(
+         "ToggleObjectVariableAsBoolean",
+         _("Toggle the boolean value of an object variable"),
+         _("Toggles the boolean value of an object variable.") + "\n" +
+             _("If it was true, it will become false, and if it was false "
+               "it will become true."),
+         _("Toggle the boolean value of the variable _PARAM1_ of object "
+           "_PARAM0_"),
+         _("Variables"),
+         "res/actions/var24.png",
+         "res/actions/var.png")
+
+      .AddParameter("object", _("Object"))
+      .AddParameter("objectvar", _("Variable"));
+
   obj.AddCondition("ObjectVariableChildExists",
                    _("Child existence"),
                    _("Check if the specified child of the variable exists."),
                    _("Child _PARAM2_ of variable _PARAM1_ of _PARAM0_ exists"),
-                   _("Variables/Structures"),
+                   _("Variables/Collections/Structures"),
                    "res/conditions/var24.png",
                    "res/conditions/var.png")
       .AddParameter("object", _("Object"))
@@ -321,9 +383,9 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
 
   obj.AddAction("ObjectVariableRemoveChild",
                 _("Remove a child"),
-                _("Remove a child from a variable of an object."),
+                _("Remove a child from an object variable."),
                 _("Remove child _PARAM2_ from variable _PARAM1_ of _PARAM0_"),
-                _("Variables/Structure"),
+                _("Variables/Collections/Structures"),
                 "res/actions/var24.png",
                 "res/actions/var.png")
       .AddParameter("object", _("Object"))
@@ -335,7 +397,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
                 _("Clear variable"),
                 _("Remove all the children from the object variable."),
                 _("Clear children from variable _PARAM1_ of _PARAM0_"),
-                _("Variables/Structure"),
+                _("Variables/Collections"),
                 "res/actions/var24.png",
                 "res/actions/var.png")
       .AddParameter("object", _("Object"))
@@ -355,7 +417,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
 
   obj.AddAction("Montre",
                 _("Show"),
-                _("Show the specified object"),
+                _("Show the specified object."),
                 _("Show _PARAM0_"),
                 _("Visibility"),
                 "res/actions/visibilite24.png",
@@ -378,10 +440,10 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsAdvanced();
 
   obj.AddCondition("Plan",
-                   _("Compare Z order"),
+                   _("Z-order"),
                    _("Compare the Z-order of the specified object."),
-                   _("the z Order"),
-                   _("Z order"),
+                   _("the Z-order"),
+                   _("Z-order"),
                    "res/conditions/planicon24.png",
                    "res/conditions/planicon.png")
 
@@ -390,7 +452,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsAdvanced();
 
   obj.AddCondition("Layer",
-                   _("Compare layer"),
+                   _("Current layer"),
                    _("Check if the object is on the specified layer."),
                    _("_PARAM0_ is on layer _PARAM1_"),
                    _("Layer"),
@@ -402,7 +464,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsAdvanced();
 
   obj.AddCondition("Visible",
-                   _("Visibility of an object"),
+                   _("Visibility"),
                    _("Check if an object is visible."),
                    _("_PARAM0_ is visible (not marked as hidden)"),
                    _("Visibility"),
@@ -413,9 +475,9 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsSimple();
 
   obj.AddCondition("Invisible",
-                   _("Invisibility of an object"),
-                   _("Check if an object is hidden."),
-                   _("_PARAM0_ is hidden"),
+                   "Invisibility of an object",
+                   "Check if an object is hidden.",
+                   "_PARAM0_ is hidden",
                    _("Visibility"),
                    "res/conditions/visibilite24.png",
                    "res/conditions/visibilite.png")
@@ -424,10 +486,10 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .SetHidden();  // Inverted "Visible" condition  does the same thing.
 
   obj.AddCondition("Arret",
-                   _("Object is stopped"),
+                   _("Object is stopped (no forces applied on it)"),
                    _("Check if an object is not moving"),
                    _("_PARAM0_ is stopped"),
-                   _("Movement"),
+                   _("Movement using forces"),
                    "res/conditions/arret24.png",
                    "res/conditions/arret.png")
 
@@ -435,10 +497,10 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsAdvanced();
 
   obj.AddCondition("Vitesse",
-                   _("Speed"),
+                   _("Speed (from forces)"),
                    _("Compare the overall speed of an object"),
                    _("the overall speed"),
-                   _("Movement"),
+                   _("Movement using forces"),
                    "res/conditions/vitesse24.png",
                    "res/conditions/vitesse.png")
 
@@ -447,22 +509,22 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsAdvanced();
 
   obj.AddCondition("AngleOfDisplacement",
-                   _("Angle of movement"),
-                   _("Compare the angle of displacement of an object"),
-                   _("Angle of displacement of _PARAM0_ is _PARAM1_ (tolerance "
+                   _("Angle of movement (using forces)"),
+                   _("Compare the angle of movement of an object according to the forces applied on it."),
+                   _("Angle of movement of _PARAM0_ is _PARAM1_ (tolerance"
                      ": _PARAM2_ degrees)"),
-                   _("Movement"),
+                   _("Movement using forces"),
                    "res/conditions/vitesse24.png",
                    "res/conditions/vitesse.png")
 
       .AddParameter("object", _("Object"))
       .AddParameter("expression", _("Angle, in degrees"))
-      .AddParameter("expression", _("Tolerance"))
+      .AddParameter("expression", _("Tolerance, in degrees"))
       .MarkAsAdvanced();
 
   obj.AddCondition("VarObjet",
-                   _("Value of an object's variable"),
-                   _("Compare the value of a variable of an object."),
+                   _("Value of an object variable"),
+                   _("Compare the value of an object variable."),
                    _("the variable _PARAM1_"),
                    _("Variables"),
                    "res/conditions/var24.png",
@@ -473,8 +535,8 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .UseStandardRelationalOperatorParameters("number");
 
   obj.AddCondition("VarObjetTxt",
-                   _("Text of an object's variable"),
-                   _("Compare the text of a variable of an object."),
+                   _("Text of an object variable"),
+                   _("Compare the text of an object variable."),
                    _("the text of variable _PARAM1_"),
                    _("Variables"),
                    "res/conditions/var24.png",
@@ -484,10 +546,23 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .AddParameter("objectvar", _("Variable"))
       .UseStandardRelationalOperatorParameters("string");
 
+  obj.AddCondition("ObjectVariableAsBoolean",
+                   _("Boolean value of an object variable"),
+                   _("Compare the boolean value of an object variable."),
+                   _("The boolean value of variable _PARAM1_ of object "
+                     "_PARAM0_ is _PARAM2_"),
+                   _("Variables"),
+                   "res/conditions/var24.png",
+                   "res/conditions/var.png")
+      .AddParameter("object", _("Object"))
+      .AddParameter("objectvar", _("Variable"))
+      .AddParameter("trueorfalse", _("Check if the value is"))
+      .SetDefaultValue("true");
+
   obj.AddCondition("VarObjetDef",
-                   _("Variable defined"),
-                   _("Check if the variable is defined."),
-                   _("Variable _PARAM1 of _PARAM0_ is defined"),
+                   "Variable defined",
+                   "Check if the variable is defined.",
+                   "Variable _PARAM1 of _PARAM0_ is defined",
                    _("Variables"),
                    "res/conditions/var24.png",
                    "res/conditions/var.png")
@@ -496,6 +571,76 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .AddParameter("string", _("Variable"))
       .SetHidden();
 
+  obj.AddAction(
+         "ObjectVariablePush",
+         _("Append variable to an object array"),
+         _("Appends a variable to the end of an object array variable."),
+         _("Append variable _PARAM2_ to array variable _PARAM1_ of _PARAM0_"),
+         _("Variables/Collections/Arrays"),
+         "res/actions/var24.png",
+         "res/actions/var.png")
+      .AddParameter("object", _("Object"))
+      .AddParameter("objectvar", _("Array variable"))
+      .AddParameter("scenevar", _("Scene variable with the content to append"))
+      .SetParameterLongDescription(
+          _("The content of the variable will *be copied* and appended at the "
+            "end of the array."))
+      .MarkAsAdvanced();
+
+  obj.AddAction(
+         "ObjectVariablePushString",
+         _("Append a string to an object array"),
+         _("Appends a string to the end of an object array variable."),
+         _("Append string _PARAM2_ to array variable _PARAM1_ of _PARAM0_"),
+         _("Variables/Collections/Arrays"),
+         "res/actions/var24.png",
+         "res/actions/var.png")
+      .AddParameter("object", _("Object"))
+      .AddParameter("objectvar", _("Array variable"))
+      .AddParameter("string", _("String to append"))
+      .MarkAsAdvanced();
+
+  obj.AddAction(
+         "ObjectVariablePushNumber",
+         _("Append a number to an object array"),
+         _("Appends a number to the end of an object array variable."),
+         _("Append number _PARAM2_ to array variable _PARAM1_ of _PARAM0_"),
+         _("Variables/Collections/Arrays"),
+         "res/actions/var24.png",
+         "res/actions/var.png")
+      .AddParameter("object", _("Object"))
+      .AddParameter("objectvar", _("Array variable"))
+      .AddParameter("expression", _("Number to append"))
+      .MarkAsAdvanced();
+
+  obj.AddAction(
+         "ObjectVariablePushBool",
+         _("Append a boolean to an object array"),
+         _("Appends a boolean to the end of an object array variable."),
+         _("Append boolean _PARAM2_ to array variable _PARAM1_ of _PARAM0_"),
+         _("Variables/Collections/Arrays"),
+         "res/actions/var24.png",
+         "res/actions/var.png")
+      .AddParameter("object", _("Object"))
+      .AddParameter("objectvar", _("Array variable"))
+      .AddParameter("trueorfalse", _("Boolean to append"))
+      .MarkAsAdvanced();
+
+  obj.AddAction(
+         "ObjectVariableRemoveAt",
+         _("Remove variable from an object array (by index)"),
+         _("Removes a variable at the specified index of an object array "
+           "variable."),
+         _("Remove variable at index _PARAM2_ from array variable _PARAM1_ of "
+           "_PARAM0_"),
+         _("Variables/Collections/Arrays"),
+         "res/actions/var24.png",
+         "res/actions/var.png")
+      .AddParameter("object", _("Object"))
+      .AddParameter("objectvar", _("Variable"))
+      .AddParameter("expression", _("Index to remove"))
+      .MarkAsAdvanced();
+
   obj.AddCondition("BehaviorActivated",
                    _("Behavior activated"),
                    _("Check if the behavior is activated for the object."),
@@ -525,8 +670,8 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
          "AddForceVers",
          _("Add a force to move toward an object"),
          _("Add a force to an object to make it move toward another."),
-         _("Move _PARAM0_ to _PARAM1_ with _PARAM3_ force of _PARAM2_ pixels"),
-         _("Movement"),
+         _("Move _PARAM0_ toward _PARAM1_ with _PARAM3_ force of _PARAM2_ pixels"),
+         _("Movement using forces"),
          "res/actions/forceVers24.png",
          "res/actions/forceVers.png")
 
@@ -545,7 +690,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
            "the actions in category \"Position\"."),
          _("Rotate _PARAM0_ around _PARAM1_ at _PARAM2_ deg/sec and _PARAM3_ "
            "pixels away"),
-         _("Movement"),
+         _("Movement using forces"),
          "res/actions/forceTourne24.png",
          "res/actions/forceTourne.png")
 
@@ -557,7 +702,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsAdvanced();
 
   obj.AddAction("MettreAutour",
-                _("Put an object around another"),
+                _("Put the object around another"),
                 _("Position an object around another, with the specified angle "
                   "and distance. The center of the objects are used for "
                   "positioning them."),
@@ -575,32 +720,32 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
 
   // Deprecated action
   obj.AddAction("Rebondir",
-                _("Move an object away from another"),
-                _("Move an object away from another, using forces."),
-                _("Move _PARAM0_ away from _PARAM1_ (only _PARAM0_ will move)"),
-                _("Movement"),
+                "Move an object away from another",
+                "Move an object away from another, using forces.",
+                "Move _PARAM0_ away from _PARAM1_ (only _PARAM0_ will move)",
+                _("Movement using forces"),
                 "res/actions/ecarter24.png",
                 "res/actions/ecarter.png")
 
       .SetHidden()
       .AddParameter("object", _("Object"))
-      .AddParameter("objectList", _("Object 2 (won't move)"));
+      .AddParameter("objectList", "Object 2 (won't move)");
 
   // Deprecated action
   obj.AddAction("Ecarter",
-                _("Move an object away from another"),
-                _("Move an object away from another without using forces."),
-                _("Move _PARAM0_ away from _PARAM2_ (only _PARAM0_ will move)"),
+                "Move an object away from another",
+                "Move an object away from another without using forces.",
+                "Move _PARAM0_ away from _PARAM2_ (only _PARAM0_ will move)",
                 _("Position"),
                 "res/actions/ecarter24.png",
                 "res/actions/ecarter.png")
 
       .SetHidden()
       .AddParameter("object", _("Object"))
-      .AddParameter("objectList", _("Object 2 (won't move)"));
+      .AddParameter("objectList", "Object 2 (won't move)");
 
   obj.AddAction("SeparateFromObjects",
-                _("Separate two objects"),
+                _("Separate objects"),
                 _("Move an object away from another using their collision "
                   "masks.\nBe sure to call this action on a reasonable number "
                   "of objects\nto avoid slowing down the game."),
@@ -737,37 +882,37 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .AddParameter("object", _("Object"));
 
   obj.AddExpression("ForceX",
-                    _("Average X coordinates of forces"),
-                    _("Average X coordinates of forces"),
-                    _("Movement"),
+                    _("X coordinate of the sum of forces"),
+                    _("X coordinate of the sum of forces"),
+                    _("Movement using forces"),
                     "res/actions/force.png")
       .AddParameter("object", _("Object"));
 
   obj.AddExpression("ForceY",
-                    _("Average Y coordinates of forces"),
-                    _("Average Y coordinates of forces"),
-                    _("Movement"),
+                    _("Y coordinate of the sum of forces"),
+                    _("Y coordinate of the sum of forces"),
+                    _("Movement using forces"),
                     "res/actions/force.png")
       .AddParameter("object", _("Object"));
 
   obj.AddExpression("ForceAngle",
-                    _("Average angle of the forces"),
-                    _("Average angle of the forces"),
-                    _("Movement"),
+                    _("Angle of the sum of forces"),
+                    _("Angle of the sum of forces"),
+                    _("Movement using forces"),
                     "res/actions/force.png")
       .AddParameter("object", _("Object"));
 
   obj.AddExpression("ForceLength",
-                    _("Average length of the forces"),
-                    _("Average length of the forces"),
-                    _("Movement"),
+                    _("Length of the sum of forces"),
+                    _("Length of the sum of forces"),
+                    _("Movement using forces"),
                     "res/actions/force.png")
       .AddParameter("object", _("Object"));
 
   obj.AddExpression("Longueur",
-                    _("Average length of the forces"),
-                    _("Average length of the forces"),
-                    _("Movement"),
+                    _("Length of the sum of forces"),
+                    _("Length of the sum of forces"),
+                    _("Movement using forces"),
                     "res/actions/force.png")
       .AddParameter("object", _("Object"))
       .SetHidden();
@@ -803,15 +948,15 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .SetHidden();
 
   obj.AddExpression("ZOrder",
-                    _("Z order"),
-                    _("Z order of an object"),
+                    _("Z-order"),
+                    _("Z-order of an object"),
                     _("Visibility"),
                     "res/actions/planicon.png")
       .AddParameter("object", _("Object"));
 
   obj.AddExpression("Plan",
-                    _("Z order"),
-                    _("Z order of an object"),
+                    _("Z-order"),
+                    _("Z-order of an object"),
                     _("Visibility"),
                     "res/actions/planicon.png")
       .AddParameter("object", _("Object"))
@@ -852,24 +997,24 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .AddParameter("expression", _("Target Y position"));
 
   obj.AddExpression("Variable",
-                    _("Object's variable"),
-                    _("Object's variable"),
+                    _("Object variable"),
+                    _("Value of an object variable"),
                     _("Variables"),
                     "res/actions/var.png")
       .AddParameter("object", _("Object"))
       .AddParameter("objectvar", _("Variable"));
 
   obj.AddExpression("VariableChildCount",
-                    _("Object's variable number of children"),
-                    _("Get the number of children from an object"),
+                    _("Number of children of an object variable"),
+                    _("Number of children of an object variable"),
                     _("Variables"),
                     "res/actions/var.png")
       .AddParameter("object", _("Object"))
       .AddParameter("objectvar", _("Variable"));
 
   obj.AddStrExpression("VariableString",
-                       _("Object's variable"),
-                       _("Text of variable of an object"),
+                       _("Object variable"),
+                       _("Text of an object variable"),
                        _("Variables"),
                        "res/actions/var.png")
       .AddParameter("object", _("Object"))
@@ -887,17 +1032,41 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
                     _("Angle between two objects"),
                     _("Compute the angle between two objects. If you need the "
                       "angle to an arbitrary position, use AngleToPosition."),
-                    _("Position"),
+                    _("Angle"),
                     "res/actions/position.png")
       .AddParameter("object", _("Object"))
       .AddParameter("objectPtr", _("Object"));
 
+   obj.AddExpression("XFromAngleAndDistance",
+                    _("X position from angle and distance"),
+                    _("Compute the X position when given an angle and distance "
+                      "relative to the starting object. This is also known as "
+                      "getting the cartesian coordinates of a 2D vector, using "
+                      "its polar coordinates."),
+                    _("Position"),
+                    "res/actions/position.png")
+      .AddParameter("object", _("Object"))
+      .AddParameter("expression", _("Angle, in degrees"))
+      .AddParameter("expression", _("Distance"));
+
+   obj.AddExpression("YFromAngleAndDistance",
+                    _("Y position from angle and distance"),
+                    _("Compute the Y position when given an angle and distance "
+                      "relative to the starting object. This is also known as "
+                      "getting the cartesian coordinates of a 2D vector, using "
+                      "its polar coordinates."),
+                    _("Position"),
+                    "res/actions/position.png")
+      .AddParameter("object", _("Object"))
+      .AddParameter("expression", _("Angle, in degrees"))
+      .AddParameter("expression", _("Distance"));
+
   obj.AddExpression("AngleToPosition",
                     _("Angle between an object and a position"),
                     _("Compute the angle between the object center and a "
                       "\"target\" position. If you need the angle between two "
                       "objects, use AngleToObject."),
-                    _("Position"),
+                    _("Angle"),
                     "res/actions/position.png")
       .AddParameter("object", _("Object"))
       .AddParameter("expression", _("Target X position"))
@@ -980,7 +1149,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
           _("Moves all objects according to the forces they have. GDevelop "
             "calls this action at the end of the events by default."),
           _("Apply movement to all objects"),
-          _("Movement"),
+          _("Movement using forces"),
           "res/actions/doMove24.png",
           "res/actions/doMove.png")
       .AddCodeOnlyParameter("currentScene", "")
@@ -988,16 +1157,16 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
 
   extension
       .AddCondition("SeDirige",
-                    _("An object is moving toward another"),
+                    _("An object is moving toward another (using forces)"),
                     _("Check if an object moves toward another.\nThe first "
                       "object must move."),
                     _("_PARAM0_ is moving toward _PARAM1_"),
-                    _("Movement"),
+                    _("Movement using forces"),
                     "res/conditions/sedirige24.png",
                     "res/conditions/sedirige.png")
       .AddParameter("objectList", _("Object"))
       .AddParameter("objectList", _("Object 2"))
-      .AddParameter("expression", _("Angle of tolerance"))
+      .AddParameter("expression", _("Tolerance, in degrees"))
       .AddCodeOnlyParameter("conditionInverted", "")
       .MarkAsAdvanced();
 
@@ -1121,18 +1290,20 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
       .MarkAsAdvanced();
 
   extension
-      .AddCondition("Raycast",
-                    _("Raycast"),
-                    _("Sends a ray from the given source position and angle, "
-                      "intersecting the closest object.\nThe instersected "
-                      "object will become the only one taken into account.\nIf "
-                      "the condition is inverted, the object to be intersected "
-                      "will be the farthest one within the ray radius."),
-                    _("Raycast _PARAM0_ from _PARAM1_;_PARAM2_, and save the "
-                      "result in _PARAM5_, _PARAM6_"),
-                    _("Collision"),
-                    "res/conditions/raycast24.png",
-                    "res/conditions/raycast.png")
+      .AddCondition(
+          "Raycast",
+          _("Raycast"),
+          _("Sends a ray from the given source position and angle, "
+            "intersecting the closest object.\nThe instersected "
+            "object will become the only one taken into account.\nIf "
+            "the condition is inverted, the object to be intersected "
+            "will be the farthest one within the ray radius."),
+          _("Cast a ray from _PARAM1_;_PARAM2_, angle: _PARAM3_ and max "
+            "distance: _PARAM4_px, against _PARAM0_, and save the "
+            "result in _PARAM5_, _PARAM6_"),
+          _("Collision"),
+          "res/conditions/raycast24.png",
+          "res/conditions/raycast.png")
       .AddParameter("objectList", _("Objects to test against the ray"))
       .AddParameter("expression", _("Ray source X position"))
       .AddParameter("expression", _("Ray source Y position"))
@@ -1158,7 +1329,8 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsBaseObjectExtension(
             "object will become the only one taken into account.\nIf "
             "the condition is inverted, the object to be intersected "
             "will be the farthest one within the ray radius."),
-          _("Raycast _PARAM0_ from _PARAM1_;_PARAM2_, and save the "
+          _("Cast a ray from from _PARAM1_;_PARAM2_ to _PARAM3_;_PARAM4_ "
+            "against _PARAM0_, and save the "
             "result in _PARAM5_, _PARAM6_"),
           _("Collision"),
           "res/conditions/raycast24.png",

Core/GDCore/Extensions/Builtin/CameraExtension.cpp

@@ -4,6 +4,7 @@
  * reserved. This project is released under the MIT License.
  */
 #include "AllBuiltinExtensions.h"
+#include "GDCore/Extensions/Metadata/MultipleInstructionMetadata.h"
 #include "GDCore/Tools/Localization.h"
 
 using namespace std;
@@ -12,141 +13,115 @@ namespace gd {
 void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
     gd::PlatformExtension& extension) {
   extension
-      .SetExtensionInformation("BuiltinCamera",
-                               _("Cameras and layers features"),
-                               _("Built-in camera extension"),
-                               "Florian Rival",
-                               "Open source (MIT License)")
+      .SetExtensionInformation(
+          "BuiltinCamera",
+          _("Cameras and layers features"),
+          "Each scene can be composed of multiple layers. These conditions "
+          "and actions allow to manipulate them during the game. In "
+          "particular, you can move the camera of a layer to center it on an "
+          "object or a position.",
+          "Florian Rival",
+          "Open source (MIT License)")
       .SetExtensionHelpPath("/interface/scene-editor/layers-and-cameras");
 
 #if defined(GD_IDE_ONLY)
   extension
-      .AddCondition("CameraX",
-                    _("Camera center X position"),
-                    _("Compare the X position of the center of a camera."),
-                    _("the X position of camera _PARAM4_ (layer: _PARAM3_)"),
-                    _("Layers and cameras"),
-                    "res/conditions/camera24.png",
-                    "res/conditions/camera.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .UseStandardRelationalOperatorParameters("number")
-      .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number (default : 0)"), "", true)
-      .SetDefaultValue("0")
-      .MarkAsAdvanced();
-
-  extension
-      .AddCondition("CameraY",
-                    _("Camera center Y position"),
-                    _("Compare the Y position of the center of a camera."),
-                    _("the Y position of camera _PARAM4_ (layer: _PARAM3_)"),
-                    _("Layers and cameras"),
-                    "res/conditions/camera24.png",
-                    "res/conditions/camera.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .UseStandardRelationalOperatorParameters("number")
-      .AddParameter("layer", _("Layer (base layer if empty)"))
-      .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number (default : 0)"))
-      .SetDefaultValue("0")
-      .MarkAsAdvanced();
-
-  extension
-      .AddAction(
+      .AddExpressionAndConditionAndAction(
+          "number",
           "CameraX",
           _("Camera center X position"),
-          _("Change the X position of the center of the specified camera."),
+          _("the X position of the center of a camera"),
           _("the X position of camera _PARAM4_ (layer: _PARAM3_)"),
           _("Layers and cameras"),
-          "res/conditions/camera24.png",
-          "res/conditions/camera.png")
+          "res/conditions/camera24.png")
       .AddCodeOnlyParameter("currentScene", "")
-      .UseStandardOperatorParameters("number")
+      .UseStandardParameters("number")
       .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
       .SetDefaultValue("\"\"")
       .AddParameter("expression", _("Camera number (default : 0)"), "", true)
       .SetDefaultValue("0")
       .MarkAsAdvanced();
 
+  extension.AddDuplicatedAction("CameraX", "SetCameraX")
+      .SetHidden();  // Deprecated
+  extension.AddDuplicatedExpression("VueX", "CameraX")
+      .SetHidden();  // Deprecated
+
   extension
-      .AddAction(
+      .AddExpressionAndConditionAndAction(
+          "number",
           "CameraY",
           _("Camera center Y position"),
-          _("Change the Y position of the center of the specified camera."),
+          _("the Y position of the center of a camera"),
           _("the Y position of camera _PARAM4_ (layer: _PARAM3_)"),
           _("Layers and cameras"),
-          "res/conditions/camera24.png",
-          "res/conditions/camera.png")
+          "res/conditions/camera24.png")
       .AddCodeOnlyParameter("currentScene", "")
-      .UseStandardOperatorParameters("number")
+      .UseStandardParameters("number")
       .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
       .SetDefaultValue("\"\"")
       .AddParameter("expression", _("Camera number (default : 0)"), "", true)
       .SetDefaultValue("0")
       .MarkAsAdvanced();
 
-  extension
-      .AddCondition("CameraWidth",
-                    _("Width of a camera"),
-                    _("Test the width of a camera of a layer"),
-                    _("the width of camera _PARAM2_ of layer _PARAM1_"),
-                    _("Layers and cameras"),
-                    "res/conditions/camera24.png",
-                    "res/conditions/camera.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer"))
-      .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number"))
-      .UseStandardRelationalOperatorParameters("number")
-      .MarkAsAdvanced();
+  extension.AddDuplicatedAction("CameraY", "SetCameraY")
+      .SetHidden();  // Deprecated
+  extension.AddDuplicatedExpression("VueY", "CameraY")
+      .SetHidden();  // Deprecated
 
   extension
-      .AddCondition("CameraHeight",
-                    _("Height of a camera"),
-                    _("Test the height of a camera of a layer"),
-                    _("the height of camera _PARAM2_ of layer _PARAM1_"),
-                    _("Layers and cameras"),
-                    "res/conditions/camera24.png",
-                    "res/conditions/camera.png")
+      .AddExpressionAndCondition(
+          "number",
+          "CameraWidth",
+          _("Width of a camera"),
+          _("the width of a camera of a layer"),
+          _("the width of camera _PARAM2_ of layer _PARAM1_"),
+          _("Layers and cameras"),
+          "res/conditions/camera24.png")
       .AddCodeOnlyParameter("currentScene", "")
       .AddParameter("layer", _("Layer (base layer if empty)"))
       .SetDefaultValue("\"\"")
       .AddParameter("expression", _("Camera number"))
-      .UseStandardRelationalOperatorParameters("number")
+      .UseStandardParameters("number")
       .MarkAsAdvanced();
 
   extension
-      .AddCondition("CameraAngle",
-                    _("Angle of a camera of a layer"),
-                    _("Test a camera angle."),
-                    _("the angle of camera (layer: _PARAM3_, camera: _PARAM4_)"),
-                    _("Layers and cameras"),
-                    "res/conditions/camera24.png",
-                    "res/conditions/camera.png")
+      .AddExpressionAndCondition(
+          "number",
+          "CameraHeight",
+          _("Height of a camera"),
+          _("the height of a camera of a layer"),
+          _("the height of camera _PARAM2_ of layer _PARAM1_"),
+          _("Layers and cameras"),
+          "res/conditions/camera24.png")
       .AddCodeOnlyParameter("currentScene", "")
-      .UseStandardRelationalOperatorParameters("number")
+      .AddParameter("layer", _("Layer (base layer if empty)"))
+      .SetDefaultValue("\"\"")
+      .AddParameter("expression", _("Camera number"))
+      .UseStandardParameters("number")
+      .MarkAsAdvanced();
+
+  extension
+      .AddExpressionAndConditionAndAction(
+          "number",
+          "CameraAngle",
+          _("Angle of a camera of a layer"),
+          _("the angle of rotation of a camera"),
+          _("the angle of camera (layer: _PARAM3_, camera: _PARAM4_)"),
+          _("Layers and cameras"),
+          "res/conditions/camera24.png")
+      .AddCodeOnlyParameter("currentScene", "")
+      .UseStandardParameters("number")
       .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
       .SetDefaultValue("\"\"")
       .AddParameter("expression", _("Camera number (default : 0)"), "", true)
       .SetDefaultValue("0")
       .MarkAsAdvanced();
 
-  extension
-      .AddAction("RotateCamera",
-                 _("Change camera angle"),
-                 _("This action modifies the angle of a camera in the "
-                   "specified layer."),
-                 _("the angle of camera (layer: _PARAM3_, camera: _PARAM4_)"),
-                 _("Layers and cameras"),
-                 "res/actions/camera24.png",
-                 "res/actions/camera.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .UseStandardOperatorParameters("number")
-      .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number (default : 0)"), "", true)
-      .SetDefaultValue("0");
+  extension.AddDuplicatedAction("RotateCamera", "SetCameraAngle").SetHidden();
+  extension.AddDuplicatedExpression("CameraRotation", "CameraAngle")
+      .SetHidden();
+  extension.AddDuplicatedExpression("VueRotation", "CameraAngle").SetHidden();
 
   extension
       .AddAction("AddCamera",
@@ -245,9 +220,9 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
 
   extension
       .AddAction("ZoomCamera",
+                 _("Change camera zoom"),
                  _("Change camera zoom."),
-                 _("Change camera zoom."),
-                 _("Change camera zoom to _PARAM1_ (layer : _PARAM2_, camera : "
+                 _("Change camera zoom to _PARAM1_ (layer: _PARAM2_, camera: "
                    "_PARAM3_)"),
                  _("Layers and cameras"),
                  "res/actions/camera24.png",
@@ -470,14 +445,14 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
                     _("Scale (1: Default, 2: 2x faster, 0.5: 2x slower...)"));
 
   extension
-      .AddCondition(
-          "LayerDefaultZOrder",
-          _("Layer default Z order"),
-          _("Compare the default Z order set to objects when they are created on a layer."),
-          _("the default Z order of objects created on _PARAM1_"),
-          _("Layers and cameras"),
-          "res/conditions/layer24.png",
-          "res/conditions/layer.png")
+      .AddCondition("LayerDefaultZOrder",
+                    _("Layer default Z order"),
+                    _("Compare the default Z order set to objects when they "
+                      "are created on a layer."),
+                    _("the default Z order of objects created on _PARAM1_"),
+                    _("Layers and cameras"),
+                    "res/conditions/layer24.png",
+                    "res/conditions/layer.png")
       .AddCodeOnlyParameter("currentScene", "")
       .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
       .SetDefaultValue("\"\"")
@@ -485,40 +460,35 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
       .MarkAsAdvanced();
 
   extension
-      .AddAction(
-          "SetLayerDefaultZOrder",
-          _("Change layer default Z order"),
-          _("Change the default Z order set to objects when they are created on a layer."),
-          _("Set the default Z order of objects created on _PARAM1_ to _PARAM2_"),
-          _("Layers and cameras"),
-          "res/actions/layer24.png",
-          "res/actions/layer.png")
+      .AddAction("SetLayerDefaultZOrder",
+                 _("Change layer default Z order"),
+                 _("Change the default Z order set to objects when they are "
+                   "created on a layer."),
+                 _("Set the default Z order of objects created on _PARAM1_ to "
+                   "_PARAM2_"),
+                 _("Layers and cameras"),
+                 "res/actions/layer24.png",
+                 "res/actions/layer.png")
       .AddCodeOnlyParameter("currentScene", "")
       .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
       .SetDefaultValue("\"\"")
       .AddParameter("expression", _("New default Z order"));
 
   extension
-      .AddExpression("CameraWidth",
-                     _("Width of a camera of a layer"),
-                     _("Width of a camera of a layer"),
-                     _("Layers and cameras"),
-                     "res/actions/camera.png")
+      .AddAction(
+          "SetLayerAmbientLightColor",
+          _("Set the ambient light color"),
+          _("Set the ambient light color of the lighting layer in format "
+            "\"R;G;B\" string."),
+          _("Set the ambient color of the lighting layer _PARAM1_ to _PARAM2_"),
+          _("Layers and cameras/Lighting"),
+          "res/actions/color24.png",
+          "res/actions/color.png")
       .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer"))
-      .AddParameter("expression", _("Camera number (default : 0)"))
-      .SetDefaultValue("0");
-
-  extension
-      .AddExpression("CameraHeight",
-                     _("Height of a camera of a layer"),
-                     _("Height of a camera of a layer"),
-                     _("Layers and cameras"),
-                     "res/actions/camera.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer"))
-      .AddParameter("expression", _("Camera number (default : 0)"))
-      .SetDefaultValue("0");
+      .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
+      .SetDefaultValue("\"Lighting\"")
+      .AddParameter("color", _("Color"))
+      .MarkAsAdvanced();
 
   extension
       .AddExpression(
@@ -569,9 +539,9 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
       .SetDefaultValue("0");
 
   extension
-      .AddExpression("CameraX",
-                     _("Camera X position"),
-                     _("Camera X position"),
+      .AddExpression("CameraZoom",
+                     _("Zoom of a camera of a layer"),
+                     _("Zoom of a camera of a layer"),
                      _("Layers and cameras"),
                      "res/actions/camera.png")
       .AddCodeOnlyParameter("currentScene", "")
@@ -580,69 +550,6 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsCameraExtension(
       .AddParameter("expression", _("Camera number (default : 0)"), "", true)
       .SetDefaultValue("0");
 
-  extension
-      .AddExpression("VueX",
-                     _("Camera X position"),
-                     _("Camera X position"),
-                     _("Layers and cameras"),
-                     "res/actions/camera.png")
-      .SetHidden()
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number (default : 0)"), "", true)
-      .SetDefaultValue("0");
-
-  extension
-      .AddExpression("CameraY",
-                     _("Camera Y position"),
-                     _("Camera Y position"),
-                     _("Layers and cameras"),
-                     "res/actions/camera.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number (default : 0)"), "", true)
-      .SetDefaultValue("0");
-
-  extension
-      .AddExpression("VueY",
-                     _("Camera Y position"),
-                     _("Camera Y position"),
-                     _("Layers and cameras"),
-                     "res/actions/camera.png")
-      .SetHidden()
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number (default : 0)"), "", true)
-      .SetDefaultValue("0");
-
-  extension
-      .AddExpression("CameraRotation",
-                     _("Angle of a camera of a layer"),
-                     _("Angle of a camera of a layer"),
-                     _("Layers and cameras"),
-                     "res/actions/camera.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number (default : 0)"), "", true)
-      .SetDefaultValue("0");
-
-  extension
-      .AddExpression("VueRotation",
-                     _("Angle of a camera of a layer"),
-                     _("Angle of a camera of a layer"),
-                     _("Layers and cameras"),
-                     "res/actions/camera.png")
-      .SetHidden()
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("expression", _("Camera number (default : 0)"), "", true)
-      .SetDefaultValue("0");
-
   extension
       .AddExpression("LayerTimeScale",
                      _("Time scale"),

Core/GDCore/Extensions/Builtin/CommonConversionsExtension.cpp

@@ -16,7 +16,7 @@ BuiltinExtensionsImplementer::ImplementsCommonConversionsExtension(
       .SetExtensionInformation(
           "BuiltinCommonConversions",
           _("Standard Conversions"),
-          _("Built-in extension providing standard conversions expressions."),
+          "Expressions to convert number, texts and quantities.",
           "Florian Rival",
           "Open source (MIT License)")
       .SetExtensionHelpPath("/all-features/common-conversions");

Core/GDCore/Extensions/Builtin/CommonInstructionsExtension.cpp

@@ -7,6 +7,7 @@
 #include "GDCore/Tools/Localization.h"
 #if defined(GD_IDE_ONLY)
 #include "GDCore/Events/Builtin/CommentEvent.h"
+#include "GDCore/Events/Builtin/ForEachChildVariableEvent.h"
 #include "GDCore/Events/Builtin/ForEachEvent.h"
 #include "GDCore/Events/Builtin/GroupEvent.h"
 #include "GDCore/Events/Builtin/LinkEvent.h"
@@ -25,8 +26,9 @@ BuiltinExtensionsImplementer::ImplementsCommonInstructionsExtension(
   extension
       .SetExtensionInformation(
           "BuiltinCommonInstructions",
-          _("Standard events"),
-          _("Built-in extension providing standard events."),
+          _("Builtin events"),
+          "GDevelop comes with a set of events and conditions that allow to "
+          "express the game logic and rules.",
           "Florian Rival",
           "Open source (MIT License)")
       .SetExtensionHelpPath("/all-features/advanced-conditions");
@@ -118,6 +120,14 @@ BuiltinExtensionsImplementer::ImplementsCommonInstructionsExtension(
                      "res/foreach.png",
                      std::make_shared<gd::ForEachEvent>());
 
+  extension.AddEvent(
+      "ForEachChildVariable",
+      _("For each child variable (of a structure or array)"),
+      _("Repeat the event for each child variable of a structure or array."),
+      "",
+      "res/foreach.png",
+      std::make_shared<gd::ForEachChildVariableEvent>());
+
   extension.AddEvent("Group",
                      _("Group"),
                      _("Group containing events"),

Core/GDCore/Extensions/Builtin/ExternalLayoutsExtension.cpp

@@ -13,13 +13,12 @@ void GD_CORE_API
 BuiltinExtensionsImplementer::ImplementsExternalLayoutsExtension(
     gd::PlatformExtension& extension) {
   extension
-      .SetExtensionInformation(
-          "BuiltinExternalLayouts",
-          _("External layouts"),
-          _("Built-in extension providing actions and conditions related to "
-            "external layouts"),
-          "Florian Rival",
-          "Open source (MIT License)")
+      .SetExtensionInformation("BuiltinExternalLayouts",
+                               _("External layouts"),
+                               "Provides actions and conditions related to "
+                               "external layouts.",
+                               "Florian Rival",
+                               "Open source (MIT License)")
       .SetExtensionHelpPath("/interface/scene-editor/external-layouts");
 
 #if defined(GD_IDE_ONLY)

Core/GDCore/Extensions/Builtin/FileExtension.cpp

@@ -12,12 +12,14 @@ namespace gd {
 void GD_CORE_API BuiltinExtensionsImplementer::ImplementsFileExtension(
     gd::PlatformExtension& extension) {
   extension
-      .SetExtensionInformation("BuiltinFile",
-                               _("Storage"),
-                               _("Built-in extension providing functions "
-                                 "to store data."),
-                               "Florian Rival",
-                               "Open source (MIT License)")
+      .SetExtensionInformation(
+          "BuiltinFile",
+          _("Storage"),
+          "Actions and conditions to store data (like the player progress or "
+          "anything else to be persisted across game sessions). Data are "
+          "stored on the device and erased when the game is uninstalled.",
+          "Florian Rival",
+          "Open source (MIT License)")
       .SetExtensionHelpPath("/all-features/storage");
 
 #if defined(GD_IDE_ONLY)
@@ -98,7 +100,8 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsFileExtension(
       .AddAction(
           "LireFichierExp",
           _("Read a value"),
-          _("Read the value saved in the specified element and store it in a scene "
+          _("Read the value saved in the specified element and store it in a "
+            "scene "
             "variable.\nSpecify the structure leading to the element using / "
             "(example : Root/Level/Current)\nSpaces are forbidden in element "
             "names."),
@@ -115,7 +118,8 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsFileExtension(
       .AddAction(
           "LireFichierTxt",
           _("Read a text"),
-          _("Read the text saved in the specified element and store it in a scene "
+          _("Read the text saved in the specified element and store it in a "
+            "scene "
             "variable.\nSpecify the structure leading to the element using / "
             "(example : Root/Level/Current)\nSpaces are forbidden in element "
             "names."),

Core/GDCore/Extensions/Builtin/JoystickExtension.cpp

@@ -15,7 +15,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsJoystickExtension(
       .SetExtensionInformation(
           "BuiltinJoystick",
           _("Joysticks features"),
-          _("Built-in extension that enables the use of joysticks"),
+          "Built-in extension that enables the use of joysticks.",
           "Florian Rival",
           "Open source (MIT License)")
       .SetExtensionHelpPath("" /*TODO: Add a documentation page for this */);

Core/GDCore/Extensions/Builtin/KeyboardExtension.cpp

@@ -15,7 +15,10 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsKeyboardExtension(
       .SetExtensionInformation(
           "BuiltinKeyboard",
           _("Keyboard features"),
-          _("Built-in extension that enables the use of a keyboard"),
+          _("Allows your game to respond to keyboard input. Note that this "
+            "does not work with on-screen keyboard on touch devices: use "
+            "instead conditions related to touch when making a game for "
+            "mobile/touchscreen devices."),
           "Florian Rival",
           "Open source (MIT License)")
       .SetExtensionHelpPath("/all-features/keyboard");
@@ -79,6 +82,16 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsKeyboardExtension(
                     "res/conditions/keyboard.png")
       .AddCodeOnlyParameter("currentScene", "");
 
+ extension
+      .AddCondition("AnyKeyReleased",
+                    _("Any key released"),
+                    _("Test if any key is released"),
+                    _("Any key is released"),
+                    _("Keyboard"),
+                    "res/conditions/keyboard24.png",
+                    "res/conditions/keyboard.png")
+      .AddCodeOnlyParameter("currentScene", "");
+
   extension
       .AddStrExpression(
           "LastPressedKey",

Core/GDCore/Extensions/Builtin/MathematicalToolsExtension.cpp

@@ -15,12 +15,22 @@ BuiltinExtensionsImplementer::ImplementsMathematicalToolsExtension(
   extension.SetExtensionInformation(
       "BuiltinMathematicalTools",
       _("Mathematical tools"),
-      _("Built-in extension providing mathematical tools"),
+      "A set of mathematical functions that can be used in expressions.",
       "Florian Rival",
       "Open source (MIT License)");
 
 #if defined(GD_IDE_ONLY)
 
+  extension
+      .AddExpression("normalize",
+                     _("Normalize a value between `min` and `max` to a value between 0 and 1."),
+                     _("Remap a value between 0 and 1."),
+                     _("Mathematical tools"),
+                     "res/mathfunction.png")
+      .AddParameter("expression", _("Value"))
+      .AddParameter("expression", _("Min"))
+      .AddParameter("expression", _("Max"));
+
   extension
       .AddExpression("clamp",
                      _("Clamp (restrict a value to a given range)"),
@@ -369,6 +379,30 @@ BuiltinExtensionsImplementer::ImplementsMathematicalToolsExtension(
       .AddParameter("expression", _("b (in a+(b-a)*x)"))
       .AddParameter("expression", _("x (in a+(b-a)*x)"));
 
+  extension
+      .AddExpression("XFromAngleAndDistance",
+                     _("X position from angle and distance"),
+                     _("Compute the X position when given an angle and distance "
+                      "relative to the origin (0;0). This is also known as "
+                      "getting the cartesian coordinates of a 2D vector, using "
+                      "its polar coordinates."),
+                     _("Mathematical tools"),
+                     "res/mathfunction.png")
+      .AddParameter("expression", _("Angle, in degrees"))
+      .AddParameter("expression", _("Distance"));
+
+  extension
+      .AddExpression("YFromAngleAndDistance",
+                     _("Y position from angle and distance"),
+                     _("Compute the Y position when given an angle and distance "
+                      "relative to the origin (0;0). This is also known as "
+                      "getting the cartesian coordinates of a 2D vector, using "
+                      "its polar coordinates."),
+                     _("Mathematical tools"),
+                     "res/mathfunction.png")
+      .AddParameter("expression", _("Angle, in degrees"))
+      .AddParameter("expression", _("Distance"));
+
 #endif
 }
 

Core/GDCore/Extensions/Builtin/MouseExtension.cpp

@@ -4,6 +4,7 @@
  * reserved. This project is released under the MIT License.
  */
 #include "AllBuiltinExtensions.h"
+#include "GDCore/Extensions/Metadata/MultipleInstructionMetadata.h"
 #include "GDCore/Tools/Localization.h"
 
 using namespace std;
@@ -14,8 +15,12 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
   extension
       .SetExtensionInformation(
           "BuiltinMouse",
-          _("Mouse features"),
-          _("Built-in extension that enables the use of a mouse"),
+          _("Mouse and touch"),
+          "Conditions and actions to handle either the mouse or touches on "
+          "touchscreen. By default, conditions related to the mouse will also "
+          "handle the touches - so that it's easier to handle both in your "
+          "game. You can disable this behavior if you want to handle them "
+          "separately in different events.",
           "Florian Rival",
           "Open source (MIT License)")
       .SetExtensionHelpPath("/all-features/mouse-touch");
@@ -144,37 +149,47 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
       .MarkAsAdvanced();
 
   extension
-      .AddCondition("SourisX",
-                    _("Cursor X position"),
-                    _("Compare the X position of the cursor or of a touch."),
-                    _("the cursor X position"),
-                    _("Mouse and touch"),
-                    "res/conditions/mouse24.png",
-                    "res/conditions/mouse.png")
+      .AddExpressionAndCondition(
+          "number",
+          "MouseX",
+          _("Cursor X position"),
+          _("the X position of the cursor or of a touch"),
+          _("the cursor (or touch) X position"),
+          _("Mouse and touch"),
+          "res/conditions/mouse24.png")
       .AddCodeOnlyParameter("currentScene", "")
-      .UseStandardRelationalOperatorParameters("number")
+      .UseStandardParameters("number")
       .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
       .SetDefaultValue("\"\"")
       .AddParameter("expression", _("Camera number (default : 0)"), "", true)
       .SetDefaultValue("0");
 
+  // Support for deprecated names:
+  extension.AddDuplicatedCondition("SourisX", "MouseX").SetHidden();
+  extension.AddDuplicatedExpression("SourisX", "MouseX").SetHidden();
+
   extension
-      .AddCondition("SourisY",
-                    _("Cursor Y position"),
-                    _("Compare the Y position of the cursor or of a touch."),
-                    _("the cursor Y position"),
-                    _("Mouse and touch"),
-                    "res/conditions/mouse24.png",
-                    "res/conditions/mouse.png")
+      .AddExpressionAndCondition(
+          "number",
+          "MouseY",
+          _("Cursor Y position"),
+          _("the Y position of the cursor or of a touch"),
+          _("the cursor (or touch) Y position"),
+          _("Mouse and touch"),
+          "res/conditions/mouse24.png")
       .AddCodeOnlyParameter("currentScene", "")
-      .UseStandardRelationalOperatorParameters("number")
+      .UseStandardParameters("number")
       .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
       .SetDefaultValue("\"\"")
       .AddParameter("expression", _("Camera number (default : 0)"), "", true)
       .SetDefaultValue("0");
 
+  // Support for deprecated names:
+  extension.AddDuplicatedCondition("SourisY", "MouseY").SetHidden();
+  extension.AddDuplicatedExpression("SourisY", "MouseY").SetHidden();
+
   extension
-      .AddCondition("SourisBouton",
+      .AddCondition("MouseButtonPressed",
                     _("Mouse button pressed or touch held"),
                     _("Check if the specified mouse button is pressed or "
                       "if a touch is in contact with the screen."),
@@ -183,49 +198,52 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
                     "res/conditions/mouse24.png",
                     "res/conditions/mouse.png")
       .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("mouse", _("Button to test"))
+      .AddParameter("mouse", _("Button to check"))
       .MarkAsSimple();
 
+  // Support for deprecated names:
+  extension.AddDuplicatedCondition("SourisBouton", "MouseButtonPressed")
+      .SetHidden();
+
   extension
-      .AddCondition(
-          "MouseButtonReleased",
-          _("Mouse button released"),
-          _("Check if the specified mouse button was released."),
-          _("_PARAM1_ mouse button was released"),
-          _("Mouse and touch"),
-          "res/conditions/mouse24.png",
-          "res/conditions/mouse.png")
+      .AddCondition("MouseButtonReleased",
+                    _("Mouse button released"),
+                    _("Check if the specified mouse button was released."),
+                    _("_PARAM1_ mouse button was released"),
+                    _("Mouse and touch"),
+                    "res/conditions/mouse24.png",
+                    "res/conditions/mouse.png")
       .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("mouse", _("Button to test"))
+      .AddParameter("mouse", _("Button to check"))
       .MarkAsSimple();
 
   extension
-      .AddCondition("TouchX",
-                    _("Touch X position"),
-                    _("Compare the X position of a specific touch."),
-                    _("the touch #_PARAM1_ X position"),
-                    _("Mouse and touch/Multitouch"),
-                    "res/conditions/touch24.png",
-                    "res/conditions/touch.png")
+      .AddExpressionAndCondition("number",
+                                 "TouchX",
+                                 _("Touch X position"),
+                                 _("the X position of a specific touch"),
+                                 _("the touch #_PARAM1_ X position"),
+                                 _("Mouse and touch/Multitouch"),
+                                 "res/conditions/touch24.png")
       .AddCodeOnlyParameter("currentScene", "")
       .AddParameter("expression", _("Touch identifier"))
-      .UseStandardRelationalOperatorParameters("number")
+      .UseStandardParameters("number")
       .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
       .SetDefaultValue("\"\"")
       .AddParameter("expression", _("Camera number (default : 0)"), "", true)
       .SetDefaultValue("0");
 
   extension
-      .AddCondition("TouchY",
-                    _("Touch Y position"),
-                    _("Compare the Y position of a specific touch."),
-                    _("the touch #_PARAM1_ Y position"),
-                    _("Mouse and touch/Multitouch"),
-                    "res/conditions/touch24.png",
-                    "res/conditions/touch.png")
+      .AddExpressionAndCondition("number",
+                                 "TouchY",
+                                 _("Touch Y position"),
+                                 _("the Y position of a specific touch"),
+                                 _("the touch #_PARAM1_ Y position"),
+                                 _("Mouse and touch/Multitouch"),
+                                 "res/conditions/touch24.png")
       .AddCodeOnlyParameter("currentScene", "")
       .AddParameter("expression", _("Touch identifier"))
-      .UseStandardRelationalOperatorParameters("number")
+      .UseStandardParameters("number")
       .AddParameter("layer", _("Layer (base layer if empty)"), "", true)
       .SetDefaultValue("\"\"")
       .AddParameter("expression", _("Camera number (default : 0)"), "", true)
@@ -261,95 +279,19 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
           "res/conditions/touch.png")
       .AddCodeOnlyParameter("currentScene", "");
 
-  extension
-      .AddExpression("MouseX",
-                     _("Cursor X position"),
-                     _("Cursor X position"),
-                     _("Mouse cursor"),
-                     "res/actions/mouse.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("camera", _("Camera"), "", true)
-      .SetDefaultValue("0");
-
-  extension
-      .AddExpression("SourisX",
-                     _("Cursor X position"),
-                     _("Cursor X position"),
-                     _("Mouse cursor"),
-                     "res/actions/mouse.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("camera", _("Camera"), "", true)
-      .SetDefaultValue("0")
-      .SetHidden();
-
-  extension
-      .AddExpression("MouseY",
-                     _("Cursor Y position"),
-                     _("Cursor Y position"),
-                     _("Mouse cursor"),
-                     "res/actions/mouse.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("camera", _("Camera"), "", true)
-      .SetDefaultValue("0");
-
-  extension
-      .AddExpression("SourisY",
-                     _("Cursor Y position"),
-                     _("Cursor Y position"),
-                     _("Mouse cursor"),
-                     "res/actions/mouse.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("layer", _("Layer"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("camera", _("Camera"), "", true)
-      .SetDefaultValue("0")
-      .SetHidden();
-
   extension
       .AddExpression("MouseWheelDelta",
                      _("Mouse wheel: Displacement"),
                      _("Mouse wheel displacement"),
-                     _("Mouse cursor"),
+                     _("Mouse and touch"),
                      "res/actions/mouse.png")
       .AddCodeOnlyParameter("currentScene", "");
 
-  extension
-      .AddExpression("TouchX",
-                     _("Touch X position"),
-                     _("Touch X position"),
-                     _("Multitouch"),
-                     "res/conditions/touch.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("expression", _("Touch identifier"))
-      .AddParameter("layer", _("Layer"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("camera", _("Camera"), "", true)
-      .SetDefaultValue("0");
-
-  extension
-      .AddExpression("TouchY",
-                     _("Touch Y position"),
-                     _("Touch Y position"),
-                     _("Multitouch"),
-                     "res/conditions/touch.png")
-      .AddCodeOnlyParameter("currentScene", "")
-      .AddParameter("expression", _("Touch identifier"))
-      .AddParameter("layer", _("Layer"), "", true)
-      .SetDefaultValue("\"\"")
-      .AddParameter("camera", _("Camera"), "", true)
-      .SetDefaultValue("0");
-
   extension
       .AddExpression("LastTouchId",
                      _("Identifier of the last touch"),
                      _("Identifier of the last touch"),
-                     _("Multitouch"),
+                     _("Mouse and touch/Multitouch"),
                      "res/conditions/touch.png")
       .AddCodeOnlyParameter("currentScene", "");
 
@@ -357,7 +299,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsMouseExtension(
       .AddExpression("LastEndedTouchId",
                      _("Identifier of the last ended touch"),
                      _("Identifier of the last ended touch"),
-                     _("Multitouch"),
+                     _("Mouse and touch/Multitouch"),
                      "res/conditions/touch.png")
       .AddCodeOnlyParameter("currentScene", "");
 

Core/GDCore/Extensions/Builtin/NetworkExtension.cpp

@@ -15,7 +15,8 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsNetworkExtension(
       .SetExtensionInformation(
           "BuiltinNetwork",
           _("Basic internet features"),
-          _("Built-in extension providing network features."),
+          _("Features to send web requests, communicate with external \"APIs\" "
+            "and other network related tasks."),
           "Florian Rival",
           "Open source (MIT License)")
       .SetExtensionHelpPath("/all-features/network");
@@ -24,33 +25,33 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsNetworkExtension(
   extension
       .AddAction(
           "SendRequest",
-          _("Send a request to a web page"),
-          _("Send a request to the specified web page.\n\nPlease note that for "
-            "the web games, the game must be hosted on the same host "
-            "as specified below, except if the server is configured to answer "
-            "to all requests (cross-domain requests)."),
-          _("Send _PARAM3_ request to _PARAM0__PARAM1_ with body: _PARAM2_"),
+          "Send a request to a web page",
+          "Send a request to the specified web page.\n\nPlease note that for "
+          "the web games, the game must be hosted on the same host "
+          "as specified below, except if the server is configured to answer "
+          "to all requests (cross-domain requests).",
+          "Send _PARAM3_ request to _PARAM0__PARAM1_ with body: _PARAM2_",
           _("Network"),
           "res/actions/net24.png",
           "res/actions/net.png")
-      .AddParameter("string", _("Host, with protocol"))
-      .SetParameterLongDescription(_("Example: \"http://example.com/\"."))
-      .AddParameter("string", _("Path"))
+      .AddParameter("string", "Host, with protocol")
+      .SetParameterLongDescription("Example: \"http://example.com/\".")
+      .AddParameter("string", "Path")
       .SetParameterLongDescription(
-          _("Example: \"/user/123\" or \"/some-page.php\"."))
-      .AddParameter("string", _("Request body content"))
-      .AddParameter("string", _("Method: \"POST\" or \"GET\""), "", true)
-      .SetParameterLongDescription(_("If empty, \"GET\" will be used."))
+          "Example: \"/user/123\" or \"/some-page.php\".")
+      .AddParameter("string", "Request body content")
+      .AddParameter("string", "Method: \"POST\" or \"GET\"", "", true)
+      .SetParameterLongDescription("If empty, \"GET\" will be used.")
       .SetDefaultValue("\"GET\"")
-      .AddParameter("string", _("Content type"), "", true)
+      .AddParameter("string", "Content type", "", true)
       .SetParameterLongDescription(
-          _("If empty, \"application/x-www-form-urlencoded\" will be used."))
-      .AddParameter("scenevar", _("Reponse scene variable"), "", true)
+          "If empty, \"application/x-www-form-urlencoded\" will be used.")
+      .AddParameter("scenevar", "Reponse scene variable", "", true)
       .SetParameterLongDescription(
-          _("The response of the server will be stored, as a string, in this "
-            "variable. If the server returns *JSON*, you may want to use the "
-            "action \"Convert JSON to a scene variable\" afterwards, to "
-            "explore the results with a *structure variable*."))
+          "The response of the server will be stored, as a string, in this "
+          "variable. If the server returns *JSON*, you may want to use the "
+          "action \"Convert JSON to a scene variable\" afterwards, to "
+          "explore the results with a *structure variable*.")
       .MarkAsComplex()
       .SetHidden();
 
@@ -74,7 +75,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsNetworkExtension(
             "highly recommended."))
       .AddParameter("string", _("Request body content"))
       .AddParameter("stringWithSelector",
-                    _("Resize mode"),
+                    _("Request method"),
                     "[\"GET\", \"POST\", \"PUT\", \"HEAD\", \"DELETE\", "
                     "\"PATCH\", \"OPTIONS\"]",
                     false)

Core/GDCore/Extensions/Builtin/SceneExtension.cpp

@@ -15,7 +15,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSceneExtension(
       .SetExtensionInformation(
           "BuiltinScene",
           _("Scene management features"),
-          _("Built-in extension allowing to manipulate scenes and providing common features"),
+          _("Actions and conditions to manipulate the scenes during the game."),
           "Florian Rival",
           "Open source (MIT License)")
       .SetExtensionHelpPath("" /*TODO: Add a documentation page for this */);

Core/GDCore/Extensions/Builtin/SpriteExtension/Direction.cpp

@@ -21,7 +21,7 @@ Direction::~Direction(){};
 
 void Direction::SetLoop(bool loop_) { loop = loop_; }
 
-void Direction::SetTimeBetweenFrames(float time) { timeBetweenFrame = time; }
+void Direction::SetTimeBetweenFrames(double time) { timeBetweenFrame = time; }
 
 void Direction::AddSprite(const Sprite& sprite) { sprites.push_back(sprite); }
 

Core/GDCore/Extensions/Builtin/SpriteExtension/Direction.h

@@ -43,14 +43,14 @@ class GD_CORE_API Direction {
   /**
    * \brief Get the time between each sprite
    */
-  inline float GetTimeBetweenFrames() const { return timeBetweenFrame; }
+  inline double GetTimeBetweenFrames() const { return timeBetweenFrame; }
 
   /**
    * \brief Set the time between each sprite
    *
    * \param time Time between each sprite, in seconds.
    */
-  void SetTimeBetweenFrames(float time);
+  void SetTimeBetweenFrames(double time);
 
   /**
    * \brief Return a reference to a sprite of the direction.
@@ -133,7 +133,7 @@ class GD_CORE_API Direction {
 
  private:
   bool loop;               ///< true if the animation must loop.
-  float timeBetweenFrame;  ///< The time between each sprite of the animation.
+  double timeBetweenFrame;  ///< The time between each sprite of the animation.
   std::vector<Sprite> sprites;  ///< The sprites of the direction.
 #if defined(GD_IDE_ONLY)
   gd::String metadata;

Core/GDCore/Extensions/Builtin/SpriteExtension/SpriteExtension.cpp

@@ -66,7 +66,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
                 "res/actions/animation.png")
 
       .AddParameter("object", _("Object"), "Sprite")
-      .AddParameter("string", _("Animation name"))
+      .AddParameter("objectAnimationName", _("Animation name"))
       .MarkAsAdvanced();
 
   obj.AddAction(
@@ -133,9 +133,9 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
       .MarkAsSimple();
 
   obj.AddAction("TourneVersPos",
-                _("Rotate an object toward a position"),
-                _("Rotate an object towards a position."),
-                _("Rotate _PARAM0_ towards _PARAM1_;_PARAM2_"),
+                "Rotate an object toward a position",
+                "Rotate an object towards a position.",
+                "Rotate _PARAM0_ towards _PARAM1_;_PARAM2_",
                 _("Direction"),
                 "res/actions/direction24.png",
                 "res/actions/direction.png")
@@ -230,7 +230,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
                    "res/conditions/animation.png")
 
       .AddParameter("object", _("Object"), "Sprite")
-      .AddParameter("string", _("Animation name"))
+      .AddParameter("objectAnimationName", _("Animation name"))
       .MarkAsAdvanced();
 
   obj.AddCondition(
@@ -249,7 +249,9 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
 
   obj.AddCondition("Sprite",
                    _("Current frame"),
-                   _("Compare the index of the current frame in the animation displayed by the specified object. The first frame in an animation starts at index 0."),
+                   _("Compare the index of the current frame in the animation "
+                     "displayed by the specified object. The first frame in an "
+                     "animation starts at index 0."),
                    _("the animation frame"),
                    _("Animations and images"),
                    "res/conditions/sprite24.png",
@@ -365,14 +367,13 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
       .AddParameter("object", _("Object"), "Sprite")
       .AddParameter("color", _("Color to make transparent"));
 
-  obj.AddAction(
-         "ChangeColor",
-         _("Tint color"),
-         _("Change the tint of an object. The default color is white."),
-         _("Change tint of _PARAM0_ to _PARAM1_"),
-         _("Effects"),
-         "res/actions/color24.png",
-         "res/actions/color.png")
+  obj.AddAction("ChangeColor",
+                _("Tint color"),
+                _("Change the tint of an object. The default color is white."),
+                _("Change tint of _PARAM0_ to _PARAM1_"),
+                _("Effects"),
+                "res/actions/color24.png",
+                "res/actions/color.png")
 
       .AddParameter("object", _("Object"), "Sprite")
       .AddParameter("color", _("Tint"));
@@ -436,15 +437,15 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
       .AddParameter("object", _("Object"), "Sprite");
 
   obj.AddAction("TourneVers",
-                _("Rotate an object toward another"),
-                _("Rotate an object towards another."),
-                _("Rotate _PARAM0_ towards _PARAM1_"),
+                "Rotate an object toward another",
+                "Rotate an object towards another.",
+                "Rotate _PARAM0_ towards _PARAM1_",
                 _("Direction"),
                 "res/actions/direction24.png",
                 "res/actions/direction.png")
 
-      .AddParameter("object", _("Object to be rotated"), "Sprite")
-      .AddParameter("objectPtr", _("Rotate toward this object"))
+      .AddParameter("object", _("Object"), "Sprite")
+      .AddParameter("objectPtr", "Rotate toward this object")
       .AddCodeOnlyParameter("currentScene", "")
       .SetHidden();  // Deprecated
 
@@ -455,7 +456,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
                     "res/actions/position.png")
       .SetHidden()
       .AddParameter("object", _("Object"), "Sprite")
-      .AddParameter("string", _("Name of the point"), "", true);
+      .AddParameter("objectPointName", _("Name of the point"), "", true);
 
   obj.AddExpression("Y",
                     _("Y position of a point"),
@@ -464,7 +465,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
                     "res/actions/position.png")
       .SetHidden()
       .AddParameter("object", _("Object"), "Sprite")
-      .AddParameter("string", _("Name of the point"), "", true);
+      .AddParameter("objectPointName", _("Name of the point"), "", true);
 
   obj.AddExpression("PointX",
                     _("X position of a point"),
@@ -473,7 +474,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
                     "res/actions/position.png")
 
       .AddParameter("object", _("Object"), "Sprite")
-      .AddParameter("string", _("Name of the point"));
+      .AddParameter("objectPointName", _("Name of the point"));
 
   obj.AddExpression("PointY",
                     _("Y position of a point"),
@@ -482,7 +483,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsSpriteExtension(
                     "res/actions/position.png")
 
       .AddParameter("object", _("Object"), "Sprite")
-      .AddParameter("string", _("Name of the point"));
+      .AddParameter("objectPointName", _("Name of the point"));
 
   obj.AddExpression("Direc",
                     _("Direction"),

Core/GDCore/Extensions/Builtin/SpriteExtension/SpriteObject.cpp

@@ -143,10 +143,7 @@ SpriteObject::GetInitialInstanceProperties(const gd::InitialInstance& position,
                                            gd::Project& project,
                                            gd::Layout& scene) {
   std::map<gd::String, gd::PropertyDescriptor> properties;
-  properties[_("Animation")] =
-      position.floatInfos.find("animation") != position.floatInfos.end()
-          ? gd::String::From(position.floatInfos.find("animation")->second)
-          : gd::String("0");
+  properties[_("Animation")] = gd::String::From(position.GetRawDoubleProperty("animation"));
 
   return properties;
 }
@@ -157,7 +154,7 @@ bool SpriteObject::UpdateInitialInstanceProperty(gd::InitialInstance& position,
                                                  gd::Project& project,
                                                  gd::Layout& scene) {
   if (name == _("Animation"))
-    position.floatInfos["animation"] = value.To<int>();
+    position.SetRawDoubleProperty("animation", value.To<int>());
 
   return true;
 }

Core/GDCore/Extensions/Builtin/StringInstructionsExtension.cpp

@@ -16,8 +16,7 @@ BuiltinExtensionsImplementer::ImplementsStringInstructionsExtension(
       .SetExtensionInformation(
           "BuiltinStringInstructions",
           _("Text manipulation"),
-          _("Built-in extension providing expressions for manipulating text "
-            "objects."),
+          "Provides expressions to manipulate strings (also called texts).",
           "Florian Rival",
           "Open source (MIT License)")
       .SetExtensionHelpPath("" /*TODO: Add a documentation page for this */);
@@ -113,23 +112,25 @@ BuiltinExtensionsImplementer::ImplementsStringInstructionsExtension(
 
   extension
       .AddExpression("StrRFind",
-                     _("Search in a text from the end"),
-                     _("Search in a text from the end (return the position of "
-                       "the result or -1 if not found)"),
+                     "Search in a text from the end",
+                     "Search in a text from the end (return the position of "
+                     "the result or -1 if not found)",
                      _("Manipulation of text"),
                      "res/conditions/toujours24.png")
 
       .AddParameter("string", _("Text"))
       .AddParameter("string", _("Text to search for"))
-      .SetHidden(); // Deprecated, see StrFindLast instead.
+      .SetHidden();  // Deprecated, see StrFindLast instead.
 
   extension
-      .AddExpression("StrFindLast",
-                     _("Search the last occurence in a text"),
-                     _("Search the last occurence in a string (return the position of "
-                       "the result, from the beginning of the string, or -1 if not found)"),
-                     _("Manipulation of text"),
-                     "res/conditions/toujours24.png")
+      .AddExpression(
+          "StrFindLast",
+          _("Search the last occurence in a text"),
+          _("Search the last occurence in a string (return the position of "
+            "the result, from the beginning of the string, or -1 if not "
+            "found)"),
+          _("Manipulation of text"),
+          "res/conditions/toujours24.png")
 
       .AddParameter("string", _("Text"))
       .AddParameter("string", _("Text to search for"));
@@ -151,25 +152,27 @@ BuiltinExtensionsImplementer::ImplementsStringInstructionsExtension(
   extension
       .AddExpression(
           "StrRFindFrom",
-          _("Search in a text from the end, starting from a position"),
-          _("Search in a text from the end, starting from a position (return "
-            "the position of the result or -1 if not found)"),
+          "Search in a text from the end, starting from a position",
+          "Search in a text from the end, starting from a position (return "
+          "the position of the result or -1 if not found)",
           _("Manipulation of text"),
           "res/conditions/toujours24.png")
 
       .AddParameter("string", _("Text"))
       .AddParameter("string", _("Text to search for"))
       .AddParameter("expression",
-                    _("Position of the last character in the string to be "
-                      "considered in the search"))
-      .SetHidden(); // Deprecated, see StrFindLastFrom instead.
+                    "Position of the last character in the string to be "
+                    "considered in the search")
+      .SetHidden();  // Deprecated, see StrFindLastFrom instead.
 
   extension
       .AddExpression(
           "StrFindLastFrom",
           _("Search the last occurence in a text, starting from a position"),
-          _("Search in a text the last occurence, starting from a position (return "
-            " the position of the result, from the beginning of the string, or -1 if not found)"),
+          _("Search in a text the last occurence, starting from a position "
+            "(return "
+            " the position of the result, from the beginning of the string, or "
+            "-1 if not found)"),
           _("Manipulation of text"),
           "res/conditions/toujours24.png")
 

Core/GDCore/Extensions/Builtin/TimeExtension.cpp

@@ -12,12 +12,14 @@ namespace gd {
 void GD_CORE_API BuiltinExtensionsImplementer::ImplementsTimeExtension(
     gd::PlatformExtension& extension) {
   extension
-      .SetExtensionInformation("BuiltinTime",
-                               _("Time"),
-                               _("Built-in extension providing actions and "
-                                 "conditions related to time."),
-                               "Florian Rival",
-                               "Open source (MIT License)")
+      .SetExtensionInformation(
+          "BuiltinTime",
+          _("Time"),
+          "Actions and conditions to run timers, get the current time or "
+          "modify the time scale (speed at which the game is running - useful "
+          "for slow motion effects).",
+          "Florian Rival",
+          "Open source (MIT License)")
       .SetExtensionHelpPath("/all-features/timers");
 
 #if defined(GD_IDE_ONLY)

Core/GDCore/Extensions/Builtin/VariablesExtension.cpp

@@ -15,7 +15,10 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
       .SetExtensionInformation(
           "BuiltinVariables",
           _("Variable features"),
-          _("Built-in extension allowing to manipulate variables"),
+          "Actions, conditions and expressions to handle variables, from "
+          "simple variables like the player score, the number of remaining "
+          "lives to complex variables containing arbitrary data like an "
+          "inventory or the result of a web request.",
           "Florian Rival",
           "Open source (MIT License)")
       .SetExtensionHelpPath("/all-features/variables");
@@ -43,13 +46,26 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
       .AddParameter("scenevar", _("Variable"))
       .UseStandardRelationalOperatorParameters("string");
 
+  extension
+      .AddCondition(
+          "SceneVariableAsBoolean",
+          _("Boolean value of a scene variable"),
+          _("Compare the boolean value of a scene variable."),
+          _("The boolean value of scene variable _PARAM0_ is _PARAM1_"),
+          _("Variables"),
+          "res/conditions/var24.png",
+          "res/conditions/var.png")
+      .AddParameter("scenevar", _("Variable"))
+      .AddParameter("trueorfalse", _("Check if the value is"))
+      .SetDefaultValue("true");
+
   extension
       .AddCondition(
           "VariableChildExists",
           _("Child existence"),
           _("Check if the specified child of the scene variable exists."),
           _("Child _PARAM1_ of scene variable _PARAM0_ exists"),
-          _("Variables/Structures"),
+          _("Variables/Collections/Structures"),
           "res/conditions/var24.png",
           "res/conditions/var.png")
       .AddParameter("scenevar", _("Variable"))
@@ -62,7 +78,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
                     _("Check if the specified child of the global "
                       "variable exists."),
                     _("Child _PARAM1_ of global variable _PARAM0_ exists"),
-                    _("Variables/Global variables/Structures"),
+                    _("Variables/Global variables/Collections/Structures"),
                     "res/conditions/var24.png",
                     "res/conditions/var.png")
       .AddParameter("globalvar", _("Variable"))
@@ -71,9 +87,9 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
 
   extension
       .AddCondition("VarSceneDef",
-                    _("Test if a scene variable is defined"),
-                    _("Test if the scene variable exists."),
-                    _("Scene variable _PARAM0_ is defined"),
+                    "Test if a scene variable is defined",
+                    "Test if the scene variable exists.",
+                    "Scene variable _PARAM0_ is defined",
                     _("Variables"),
                     "res/conditions/var24.png",
                     "res/conditions/var.png")
@@ -94,23 +110,35 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
       .MarkAsAdvanced();
 
   extension
-      .AddCondition(
-          "VarGlobalTxt",
-          _("Text of a global variable"),
-          _("Compare the text of a global variable."),
-          _("the text of the global variable _PARAM0_"),
-          _("Variables/Global variables"),
-          "res/conditions/var24.png",
-          "res/conditions/var.png")
+      .AddCondition("VarGlobalTxt",
+                    _("Text of a global variable"),
+                    _("Compare the text of a global variable."),
+                    _("the text of the global variable _PARAM0_"),
+                    _("Variables/Global variables"),
+                    "res/conditions/var24.png",
+                    "res/conditions/var.png")
       .AddParameter("globalvar", _("Variable"))
       .UseStandardRelationalOperatorParameters("string")
       .MarkAsAdvanced();
 
+  extension
+      .AddCondition(
+          "GlobalVariableAsBoolean",
+          _("Boolean value of a global variable"),
+          _("Compare the boolean value of a global variable."),
+          _("The boolean value of global variable _PARAM0_ is _PARAM1_"),
+          _("Variables/Global variables"),
+          "res/conditions/var24.png",
+          "res/conditions/var.png")
+      .AddParameter("globalvar", _("Variable"))
+      .AddParameter("trueorfalse", _("Check if the value is"))
+      .SetDefaultValue("true");
+
   extension
       .AddCondition("VarGlobalDef",
-                    _("Test if a global variable is defined"),
-                    _("Test if a global variable exists"),
-                    _("Global variable _PARAM0_ is defined"),
+                    "Test if a global variable is defined",
+                    "Test if a global variable exists",
+                    "Global variable _PARAM0_ is defined",
                     _("Variables/Global variables"),
                     "res/conditions/var24.png",
                     "res/conditions/var.png")
@@ -122,7 +150,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
   extension
       .AddAction("ModVarScene",
                  _("Value of a scene variable"),
-                 _("Modify the value of a scene variable."),
+                 _("Change the value of a scene variable."),
                  _("the scene variable _PARAM0_"),
                  _("Variables"),
                  "res/actions/var24.png",
@@ -141,10 +169,34 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
       .AddParameter("scenevar", _("Variable"))
       .UseStandardOperatorParameters("string");
 
+  extension
+      .AddAction(
+          "SetSceneVariableAsBoolean",
+          _("Boolean value of a scene variable"),
+          _("Modify the boolean value of a scene variable."),
+          _("Set the boolean value of scene variable _PARAM0_ to _PARAM1_"),
+          _("Variables"),
+          "res/conditions/var24.png",
+          "res/conditions/var.png")
+      .AddParameter("scenevar", _("Variable"))
+      .AddParameter("trueorfalse", _("New Value:"));
+
+  extension
+      .AddAction("ToggleSceneVariableAsBoolean",
+                 _("Toggle boolean value of a scene variable"),
+                 _("Toggle the boolean value of a scene variable.") + "\n" +
+                     _("If it was true, it will become false, and if it was "
+                       "false it will become true."),
+                 _("Toggle the boolean value of scene variable _PARAM0_"),
+                 _("Variables"),
+                 "res/conditions/var24.png",
+                 "res/conditions/var.png")
+      .AddParameter("scenevar", _("Variable"));
+
   extension
       .AddAction("ModVarGlobal",
                  _("Value of a global variable"),
-                 _("Modify the value of a global variable"),
+                 _("Change the value of a global variable"),
                  _("the global variable _PARAM0_"),
                  _("Variables/Global variables"),
                  "res/actions/var24.png",
@@ -154,24 +206,47 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
       .MarkAsAdvanced();
 
   extension
-      .AddAction(
-          "ModVarGlobalTxt",
-          _("String of a global variable"),
-          _("Modify the text of a global variable."),
-          _("the text of global variable _PARAM0_"),
-          _("Variables/Global variables"),
-          "res/actions/var24.png",
-          "res/actions/var.png")
+      .AddAction("ModVarGlobalTxt",
+                 _("String of a global variable"),
+                 _("Modify the text of a global variable."),
+                 _("the text of global variable _PARAM0_"),
+                 _("Variables/Global variables"),
+                 "res/actions/var24.png",
+                 "res/actions/var.png")
       .AddParameter("globalvar", _("Variable"))
       .UseStandardOperatorParameters("string")
       .MarkAsAdvanced();
 
+  extension
+      .AddAction(
+          "SetGlobalVariableAsBoolean",
+          _("Boolean value of a global variable"),
+          _("Modify the boolean value of a global variable."),
+          _("Set the boolean value of global variable _PARAM0_ to _PARAM1_"),
+          _("Variables/Global variables"),
+          "res/conditions/var24.png",
+          "res/conditions/var.png")
+      .AddParameter("globalvar", _("Variable"))
+      .AddParameter("trueorfalse", _("New Value:"));
+
+  extension
+      .AddAction("ToggleGlobalVariableAsBoolean",
+                 _("Toggle boolean value of a global variable"),
+                 _("Toggle the boolean value of a global variable.") + "\n" +
+                     _("If it was true, it will become false, and if it was "
+                       "false it will become true."),
+                 _("Toggle the boolean value of global variable _PARAM0_"),
+                 _("Variables/Global variables"),
+                 "res/conditions/var24.png",
+                 "res/conditions/var.png")
+      .AddParameter("globalvar", _("Variable"));
+
   extension
       .AddAction("VariableRemoveChild",
                  _("Remove a child"),
                  _("Remove a child from a scene variable."),
                  _("Remove child _PARAM1_ from scene variable _PARAM0_"),
-                 _("Variables/Structure"),
+                 _("Variables/Collections/Structures"),
                  "res/actions/var24.png",
                  "res/actions/var.png")
       .AddParameter("scenevar", _("Variable"))
@@ -183,7 +258,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
                  _("Remove a child"),
                  _("Remove a child from a global variable."),
                  _("Remove child _PARAM1_ from global variable _PARAM0_"),
-                 _("Variables/Global variables/Structure"),
+                 _("Variables/Global variables/Collections/Structures"),
                  "res/actions/var24.png",
                  "res/actions/var.png")
       .AddParameter("globalvar", _("Variable"))
@@ -195,7 +270,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
                  _("Clear scene variable"),
                  _("Remove all the children from the scene variable."),
                  _("Clear children from scene variable _PARAM0_"),
-                 _("Variables/Structure"),
+                 _("Variables/Collections"),
                  "res/actions/var24.png",
                  "res/actions/var.png")
       .AddParameter("scenevar", _("Variable"))
@@ -206,16 +281,140 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
                  _("Clear global variable"),
                  _("Remove all the children from the global variable."),
                  _("Clear children from global variable _PARAM0_"),
-                 _("Variables/Global variables/Structure"),
+                 _("Variables/Global variables/Collections"),
                  "res/actions/var24.png",
                  "res/actions/var.png")
       .AddParameter("globalvar", _("Variable"))
       .MarkAsAdvanced();
 
+  extension
+      .AddAction("SceneVariablePush",
+                 _("Append variable to a scene array"),
+                 _("Appends a variable at the end of a scene array variable."),
+                 _("Append variable _PARAM1_ to array variable _PARAM0_"),
+                 _("Variables/Collections/Arrays"),
+                 "res/actions/var24.png",
+                 "res/actions/var.png")
+      .AddParameter("scenevar", _("Array variable"))
+      .AddParameter("scenevar", _("Scene variable with the content to append"))
+      .SetParameterLongDescription(_("The content of the variable will *be copied* and appended at the end of the array."))
+      .MarkAsAdvanced();
+
+  extension
+      .AddAction("SceneVariablePushString",
+                 _("Append a string to a scene array"),
+                 _("Appends a string at the end of a scene array variable."),
+                 _("Append string _PARAM1_ to array variable _PARAM0_"),
+                 _("Variables/Collections/Arrays"),
+                 "res/actions/var24.png",
+                 "res/actions/var.png")
+      .AddParameter("scenevar", _("Array variable"))
+      .AddParameter("string", _("String to append"))
+      .MarkAsAdvanced();
+
+  extension
+      .AddAction("SceneVariablePushNumber",
+                 _("Append a number to a scene array"),
+                 _("Appends a number at the end of a scene array variable."),
+                 _("Append number _PARAM1_ to array variable _PARAM0_"),
+                 _("Variables/Collections/Arrays"),
+                 "res/actions/var24.png",
+                 "res/actions/var.png")
+      .AddParameter("scenevar", _("Array variable"))
+      .AddParameter("expression", _("Number to append"))
+      .MarkAsAdvanced();
+
+  extension
+      .AddAction("SceneVariablePushBool",
+                 _("Append a boolean to a scene array"),
+                 _("Appends a boolean at the end of a scene array variable."),
+                 _("Append boolean _PARAM1_ to array variable _PARAM0_"),
+                 _("Variables/Collections/Arrays"),
+                 "res/actions/var24.png",
+                 "res/actions/var.png")
+      .AddParameter("scenevar", _("Array variable"))
+      .AddParameter("trueorfalse", _("Boolean to append"))
+      .MarkAsAdvanced();
+
+  extension
+      .AddAction(
+          "SceneVariableRemoveAt",
+          _("Remove variable from a scene array (by index)"),
+          _("Removes a variable at the specified index of a scene array variable."),
+          _("Remove variable at index _PARAM1_ from scene array variable _PARAM0_"),
+          _("Variables/Collections/Arrays"),
+          "res/actions/var24.png",
+          "res/actions/var.png")
+      .AddParameter("scenevar", _("Variable"))
+      .AddParameter("expression", _("Index to remove"))
+      .MarkAsAdvanced();
+
+  extension
+      .AddAction("GlobalVariablePush",
+                 _("Append variable to a global array"),
+                 _("Appends a variable at the end of a global array variable."),
+                 _("Append variable _PARAM1_ to array variable _PARAM0_"),
+                 _("Variables/Global variables/Collections/Arrays"),
+                 "res/actions/var24.png",
+                 "res/actions/var.png")
+      .AddParameter("globalvar", _("Array variable"))
+      .AddParameter("scenevar", _("Scene variable with the content to append"))
+      .SetParameterLongDescription(_("The content of the variable will *be copied* and appended at the end of the array."))
+      .MarkAsAdvanced();
+
+  extension
+      .AddAction(
+          "GlobalVariableRemoveAt",
+          _("Remove variable from a global array (by index)"),
+          _("Removes a variable at the specified index of a global array variable."),
+          _("Remove variable at index _PARAM1_ from global array variable _PARAM0_"),
+          _("Variables/Global variables/Collections/Arrays"),
+          "res/actions/var24.png",
+          "res/actions/var.png")
+      .AddParameter("globalvar", _("Variable"))
+      .AddParameter("expression", _("Index to remove"))
+      .MarkAsAdvanced();
+
+  extension
+      .AddAction("GlobalVariablePushString",
+                 _("Append a string to a global array"),
+                 _("Appends a string at the end of a global array variable."),
+                 _("Append string _PARAM1_ to array variable _PARAM0_"),
+                 _("Variables/Global variables/Collections/Arrays"),
+                 "res/actions/var24.png",
+                 "res/actions/var.png")
+      .AddParameter("globalvar", _("Array variable"))
+      .AddParameter("string", _("String to append"))
+      .MarkAsAdvanced();
+
+  extension
+      .AddAction("GlobalVariablePushNumber",
+                 _("Append a number to a global array"),
+                 _("Appends a number at the end of a global array variable."),
+                 _("Append number _PARAM1_ to array variable _PARAM0_"),
+                 _("Variables/Global variables/Collections/Arrays"),
+                 "res/actions/var24.png",
+                 "res/actions/var.png")
+      .AddParameter("globalvar", _("Array variable"))
+      .AddParameter("expression", _("Number to append"))
+      .MarkAsAdvanced();
+
+  extension
+      .AddAction("GlobalVariablePushBool",
+                 _("Append a boolean to a global array"),
+                 _("Appends a boolean at the end of a global array variable."),
+                 _("Append boolean _PARAM1_ to array variable _PARAM0_"),
+                 _("Variables/Global variables/Collections/Arrays"),
+                 "res/actions/var24.png",
+                 "res/actions/var.png")
+      .AddParameter("globalvar", _("Array variable"))
+      .AddParameter("trueorfalse", _("Boolean to append"))
+      .MarkAsAdvanced();
+
   extension
       .AddExpression("GlobalVariableChildCount",
                      _("Number of children of a global variable"),
-                     _("Get the number of children of a global variable"),
+                     _("Number of children of a global variable"),
                      _("Variables"),
                      "res/actions/var.png")
       .AddParameter("globalvar", _("Variable"));
@@ -223,7 +422,7 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsVariablesExtension(
   extension
       .AddExpression("VariableChildCount",
                      _("Number of children of a scene variable"),
-                     _("Get the number of children of a scene variable"),
+                     _("Number of children of a scene variable"),
                      _("Variables"),
                      "res/actions/var.png")
       .AddParameter("scenevar", _("Variable"));

Core/GDCore/Extensions/Builtin/WindowExtension.cpp

@@ -12,12 +12,14 @@ namespace gd {
 void GD_CORE_API BuiltinExtensionsImplementer::ImplementsWindowExtension(
     gd::PlatformExtension& extension) {
   extension
-      .SetExtensionInformation("BuiltinWindow",
-                               _("Window features"),
-                               _("Built-in extension allowing to manipulate "
-                                 "the game window and canvas"),
-                               "Florian Rival",
-                               "Open source (MIT License)")
+      .SetExtensionInformation(
+          "BuiltinWindow",
+          _("Window features"),
+          "Provides actions and conditions to manipulate the game window. "
+          "Depending on the platform on which the game is running, not all of "
+          "these features can be applied.",
+          "Florian Rival",
+          "Open source (MIT License)")
       .SetExtensionHelpPath("/all-features/window");
 
 #if defined(GD_IDE_ONLY)
@@ -39,14 +41,13 @@ void GD_CORE_API BuiltinExtensionsImplementer::ImplementsWindowExtension(
       .SetDefaultValue("yes");
 
   extension
-      .AddCondition(
-          "IsFullScreen",
-          _("Fullscreen activated?"),
-          _("Check if the game is currently in fullscreen."),
-          _("The game is in fullscreen"),
-          _("Game's window and resolution"),
-          "res/actions/fullscreen24.png",
-          "res/actions/fullscreen.png")
+      .AddCondition("IsFullScreen",
+                    _("Fullscreen activated?"),
+                    _("Check if the game is currently in fullscreen."),
+                    _("The game is in fullscreen"),
+                    _("Game's window and resolution"),
+                    "res/actions/fullscreen24.png",
+                    "res/actions/fullscreen.png")
       .AddCodeOnlyParameter("currentScene", "");
 
   extension

Core/GDCore/Extensions/Metadata/BehaviorMetadata.cpp

@@ -4,12 +4,16 @@
  * reserved. This project is released under the MIT License.
  */
 #include "BehaviorMetadata.h"
+
 #include <iostream>
+
 #include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
+#include "GDCore/Extensions/Metadata/MultipleInstructionMetadata.h"
 #include "GDCore/Extensions/PlatformExtension.h"
 #include "GDCore/Project/Behavior.h"
 #include "GDCore/Project/BehaviorsSharedData.h"
+#include "GDCore/Tools/Localization.h"
 
 namespace gd {
 
@@ -147,12 +151,16 @@ gd::ExpressionMetadata& BehaviorMetadata::AddExpression(
     const gd::String& group,
     const gd::String& smallicon) {
 #if defined(GD_IDE_ONLY)
-  // Be careful, behaviors expression do not have namespace ( not necessary as
-  // we refer to the auomatism name in the expression )
-  expressionsInfos[name] =
-      ExpressionMetadata(
-          extensionNamespace, name, fullname, description, group, smallicon)
-          .SetHelpPath(GetHelpPath());
+  // Be careful, behaviors expression do not have namespace (not necessary as
+  // we refer to the behavior name in the expression).
+  expressionsInfos[name] = ExpressionMetadata("number",
+                                              extensionNamespace,
+                                              name,
+                                              fullname,
+                                              description,
+                                              group,
+                                              smallicon)
+                               .SetHelpPath(GetHelpPath());
   return expressionsInfos[name];
 #endif
 }
@@ -164,16 +172,179 @@ gd::ExpressionMetadata& BehaviorMetadata::AddStrExpression(
     const gd::String& group,
     const gd::String& smallicon) {
 #if defined(GD_IDE_ONLY)
-  // Be careful, behaviors expression do not have namespace ( not necessary as
-  // we refer to the auomatism name in the expression )
-  strExpressionsInfos[name] =
-      ExpressionMetadata(
-          extensionNamespace, name, fullname, description, group, smallicon)
-          .SetHelpPath(GetHelpPath());
+  // Be careful, behaviors expression do not have namespace (not necessary as
+  // we refer to the behavior name in the expression).
+  strExpressionsInfos[name] = ExpressionMetadata("string",
+                                                 extensionNamespace,
+                                                 name,
+                                                 fullname,
+                                                 description,
+                                                 group,
+                                                 smallicon)
+                                  .SetHelpPath(GetHelpPath());
   return strExpressionsInfos[name];
 #endif
 }
 
+gd::MultipleInstructionMetadata BehaviorMetadata::AddExpressionAndCondition(
+    const gd::String& type,
+    const gd::String& name,
+    const gd::String& fullname,
+    const gd::String& descriptionSubject,
+    const gd::String& sentenceName,
+    const gd::String& group,
+    const gd::String& icon) {
+  gd::String expressionDescriptionTemplate = _("Return <subject>.");
+  auto& expression =
+      type == "number"
+          ? AddExpression(name,
+                          fullname,
+                          expressionDescriptionTemplate.FindAndReplace(
+                              "<subject>", descriptionSubject),
+                          group,
+                          icon)
+          : AddStrExpression(name,
+                             fullname,
+                             expressionDescriptionTemplate.FindAndReplace(
+                                 "<subject>", descriptionSubject),
+                             group,
+                             icon);
+
+  gd::String conditionDescriptionTemplate = _("Compare <subject>.");
+  auto& condition =
+      AddScopedCondition(name,
+                         fullname,
+                         conditionDescriptionTemplate.FindAndReplace(
+                             "<subject>", descriptionSubject),
+                         sentenceName,
+                         group,
+                         icon,
+                         icon);
+
+  return MultipleInstructionMetadata::WithExpressionAndCondition(expression,
+                                                                 condition);
+}
+
+gd::MultipleInstructionMetadata
+BehaviorMetadata::AddExpressionAndConditionAndAction(
+    const gd::String& type,
+    const gd::String& name,
+    const gd::String& fullname,
+    const gd::String& descriptionSubject,
+    const gd::String& sentenceName,
+    const gd::String& group,
+    const gd::String& icon) {
+  gd::String expressionDescriptionTemplate = _("Return <subject>.");
+  auto& expression =
+      type == "number"
+          ? AddExpression(name,
+                          fullname,
+                          expressionDescriptionTemplate.FindAndReplace(
+                              "<subject>", descriptionSubject),
+                          group,
+                          icon)
+          : AddStrExpression(name,
+                             fullname,
+                             expressionDescriptionTemplate.FindAndReplace(
+                                 "<subject>", descriptionSubject),
+                             group,
+                             icon);
+
+  gd::String conditionDescriptionTemplate = _("Compare <subject>.");
+  auto& condition =
+      AddScopedCondition(name,
+                         fullname,
+                         conditionDescriptionTemplate.FindAndReplace(
+                             "<subject>", descriptionSubject),
+                         sentenceName,
+                         group,
+                         icon,
+                         icon);
+
+  gd::String actionDescriptionTemplate = _("Change <subject>.");
+  auto& action = AddScopedAction(
+      "Set" + name,
+      fullname,
+      actionDescriptionTemplate.FindAndReplace("<subject>", descriptionSubject),
+      sentenceName,
+      group,
+      icon,
+      icon);
+
+  return MultipleInstructionMetadata::WithExpressionAndConditionAndAction(
+      expression, condition, action);
+}
+
+#if defined(GD_IDE_ONLY)
+gd::InstructionMetadata& BehaviorMetadata::AddDuplicatedAction(
+    const gd::String& newActionName, const gd::String& copiedActionName) {
+  gd::String newNameWithNamespace = extensionNamespace + newActionName;
+  gd::String copiedNameWithNamespace = extensionNamespace + copiedActionName;
+
+  auto copiedAction = actionsInfos.find(copiedNameWithNamespace);
+  if (copiedAction == actionsInfos.end()) {
+    gd::LogWarning("Could not find an action with name " +
+                   copiedNameWithNamespace + " to copy.");
+  } else {
+    actionsInfos[newNameWithNamespace] = copiedAction->second;
+  }
+
+  return actionsInfos[newNameWithNamespace];
+}
+
+gd::InstructionMetadata& BehaviorMetadata::AddDuplicatedCondition(
+    const gd::String& newConditionName, const gd::String& copiedConditionName) {
+  gd::String newNameWithNamespace = extensionNamespace + newConditionName;
+  gd::String copiedNameWithNamespace = extensionNamespace + copiedConditionName;
+
+  auto copiedCondition = conditionsInfos.find(copiedNameWithNamespace);
+  if (copiedCondition == conditionsInfos.end()) {
+    gd::LogWarning("Could not find a condition with name " +
+                   copiedNameWithNamespace + " to copy.");
+  } else {
+    conditionsInfos[newNameWithNamespace] = copiedCondition->second;
+  }
+
+  return conditionsInfos[newNameWithNamespace];
+}
+
+gd::ExpressionMetadata& BehaviorMetadata::AddDuplicatedExpression(
+    const gd::String& newExpressionName,
+    const gd::String& copiedExpressionName) {
+  gd::String newNameWithNamespace = extensionNamespace + newExpressionName;
+  gd::String copiedNameWithNamespace =
+      extensionNamespace + copiedExpressionName;
+
+  auto copiedExpression = expressionsInfos.find(copiedNameWithNamespace);
+  if (copiedExpression == expressionsInfos.end()) {
+    gd::LogWarning("Could not find an expression with name " +
+                   copiedNameWithNamespace + " to copy.");
+  } else {
+    expressionsInfos[newNameWithNamespace] = copiedExpression->second;
+  }
+
+  return expressionsInfos[newNameWithNamespace];
+}
+
+gd::ExpressionMetadata& BehaviorMetadata::AddDuplicatedStrExpression(
+    const gd::String& newExpressionName,
+    const gd::String& copiedExpressionName) {
+  gd::String newNameWithNamespace = extensionNamespace + newExpressionName;
+  gd::String copiedNameWithNamespace =
+      extensionNamespace + copiedExpressionName;
+
+  auto copiedExpression = strExpressionsInfos.find(copiedNameWithNamespace);
+  if (copiedExpression == strExpressionsInfos.end()) {
+    gd::LogWarning("Could not find a string expression with name " +
+                   copiedNameWithNamespace + " to copy.");
+  } else {
+    strExpressionsInfos[newNameWithNamespace] = copiedExpression->second;
+  }
+
+  return strExpressionsInfos[newNameWithNamespace];
+}
+#endif
+
 BehaviorMetadata& BehaviorMetadata::SetFullName(const gd::String& fullname_) {
 #if defined(GD_IDE_ONLY)
   fullname = fullname_;

Core/GDCore/Extensions/Metadata/BehaviorMetadata.h

@@ -6,12 +6,14 @@
 #ifndef BEHAVIORMETADATA_H
 #define BEHAVIORMETADATA_H
 #include <map>
+
 #include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
 #include "GDCore/String.h"
 namespace gd {
 class Behavior;
 class BehaviorsSharedData;
+class MultipleInstructionMetadata;
 class InstructionMetadata;
 class ExpressionMetadata;
 }  // namespace gd
@@ -41,7 +43,8 @@ class GD_CORE_API BehaviorMetadata {
 
   /**
    * Declare a new condition as being part of the behavior.
-   * \deprecated Prefer using `AddScopedCondition`.
+   * \deprecated Prefer using `AddScopedCondition`, to properly namespace
+   * the condition.
    */
   gd::InstructionMetadata& AddCondition(const gd::String& name_,
                                         const gd::String& fullname_,
@@ -53,7 +56,8 @@ class GD_CORE_API BehaviorMetadata {
 
   /**
    * Declare a new action as being part of the behavior.
-   * \deprecated Prefer using `AddScopedAction`.
+   * \deprecated Prefer using `AddScopedAction`, to properly namespace
+   * the action.
    */
   gd::InstructionMetadata& AddAction(const gd::String& name_,
                                      const gd::String& fullname_,
@@ -67,23 +71,23 @@ class GD_CORE_API BehaviorMetadata {
    * Declare a new condition as being part of the behavior.
    */
   gd::InstructionMetadata& AddScopedCondition(const gd::String& name_,
-                                        const gd::String& fullname_,
-                                        const gd::String& description_,
-                                        const gd::String& sentence_,
-                                        const gd::String& group_,
-                                        const gd::String& icon_,
-                                        const gd::String& smallicon_);
+                                              const gd::String& fullname_,
+                                              const gd::String& description_,
+                                              const gd::String& sentence_,
+                                              const gd::String& group_,
+                                              const gd::String& icon_,
+                                              const gd::String& smallicon_);
 
   /**
    * Declare a new action as being part of the behavior.
    */
   gd::InstructionMetadata& AddScopedAction(const gd::String& name_,
-                                     const gd::String& fullname_,
-                                     const gd::String& description_,
-                                     const gd::String& sentence_,
-                                     const gd::String& group_,
-                                     const gd::String& icon_,
-                                     const gd::String& smallicon_);
+                                           const gd::String& fullname_,
+                                           const gd::String& description_,
+                                           const gd::String& sentence_,
+                                           const gd::String& group_,
+                                           const gd::String& icon_,
+                                           const gd::String& smallicon_);
   /**
    * Declare a new action as being part of the extension.
    */
@@ -102,6 +106,78 @@ class GD_CORE_API BehaviorMetadata {
                                            const gd::String& group_,
                                            const gd::String& smallicon_);
 
+  /**
+   * \brief Declare a new expression and condition as being part of the
+   * behavior.
+   * \note It's recommended to use this function to avoid declaring twice a
+   * similar expression/condition.
+   */
+  gd::MultipleInstructionMetadata AddExpressionAndCondition(
+      const gd::String& type,
+      const gd::String& name,
+      const gd::String& fullname,
+      const gd::String& description,
+      const gd::String& sentenceName,
+      const gd::String& group,
+      const gd::String& icon);
+
+  /**
+   * \brief Declare a new expression, condition and action as being part of the
+   * behavior.
+   * \note The action name is prefixed by "Set" (and the namespace, as the
+   * condition).
+   * \note It's recommended to use this function to avoid declaring 3 times a
+   * similar expression/condition/action.
+   */
+  gd::MultipleInstructionMetadata AddExpressionAndConditionAndAction(
+      const gd::String& type,
+      const gd::String& name,
+      const gd::String& fullname,
+      const gd::String& description,
+      const gd::String& sentenceName,
+      const gd::String& group,
+      const gd::String& icon);
+
+  /**
+   * \brief Create a new action which is the duplicate of the specified one.
+   *
+   * Useful for handling a deprecated action that is just a "copy" of the new
+   * one.
+   */
+  gd::InstructionMetadata& AddDuplicatedAction(
+      const gd::String& newActionName, const gd::String& copiedActionName);
+
+  /**
+   * \brief Create a new condition which is the duplicate of the specified one.
+   *
+   * Useful for handling a deprecated condition that is just a "copy" of the new
+   * one.
+   */
+  gd::InstructionMetadata& AddDuplicatedCondition(
+      const gd::String& newConditionName,
+      const gd::String& copiedConditionName);
+
+  /**
+   * \brief Create a new expression which is the duplicate of the specified one.
+   *
+   * Useful for handling a deprecated expression that is just a "copy" of the
+   * new one.
+   */
+  gd::ExpressionMetadata& AddDuplicatedExpression(
+      const gd::String& newExpressionName,
+      const gd::String& copiedExpressionName);
+
+  /**
+   * \brief Create a new string expression which is the duplicate of the
+   * specified one.
+   *
+   * Useful for handling a deprecated string expression that is just a "copy" of
+   * the new one.
+   */
+  gd::ExpressionMetadata& AddDuplicatedStrExpression(
+      const gd::String& newExpressionName,
+      const gd::String& copiedExpressionName);
+
   BehaviorMetadata& SetFullName(const gd::String& fullname_);
   BehaviorMetadata& SetDefaultName(const gd::String& defaultName_);
   BehaviorMetadata& SetDescription(const gd::String& description_);
@@ -120,12 +196,14 @@ class GD_CORE_API BehaviorMetadata {
   BehaviorMetadata& AddIncludeFile(const gd::String& includeFile);
 
   /**
-   * Get the help path of the behavior, relative to the documentation root.
+   * Get the help path of the behavior, relative to the GDevelop documentation
+   * root.
    */
   const gd::String& GetHelpPath() const { return helpPath; }
 
   /**
-   * Set the help path of the behavior, relative to the documentation root.
+   * Set the help path of the behavior, relative to the GDevelop documentation
+   * root.
    *
    * The behavior instructions will have this help path set by
    * default, unless you call SetHelpPath on them.

Core/GDCore/Extensions/Metadata/DependencyMetadata.h

@@ -19,6 +19,14 @@ namespace gd {
  */
 class GD_CORE_API DependencyMetadata {
  public:
+  /**
+   * Construct a new dependency metadata, though you probably want to call
+   * `AddDependency` on gd::PlatformExtension.
+   *
+   * \see gd::PlatformExtension
+   */
+  DependencyMetadata() : onlyIfSomeExtraSettingsNonEmpty(false){};
+
   /**
    * \brief Sets the name shown to users.
    */
@@ -77,24 +85,38 @@ class GD_CORE_API DependencyMetadata {
   };
 
   /**
-   * \brief Mark the dependency to be included in the export only if the
-   * specified setting is not empty.
-   *
-   * If this is called for multiple settings, all settings must be fulfilled for
-   * the dependency to be exported.
+   * \brief Mark the dependency to be included in the export only if at least
+   * one of the extra settings is set.
    */
-  DependencyMetadata& OnlyIfExtraSettingIsNonEmpty(
-      const gd::String& settingName) {
-    nonEmptyExtraSettingsForExport.insert(settingName);
+  DependencyMetadata& OnlyIfSomeExtraSettingsNonEmpty() {
+    onlyIfSomeExtraSettingsNonEmpty = true;
     return *this;
   };
 
   /**
-   * \brief Get the list of extra settings that must be fulfilled for the
-   * dependency to be exported.
+   * \brief Check if at least one of the extra settings must be set for the
+   * dependency to be included in the export.
    */
-  const std::set<gd::String>& GetRequiredExtraSettingsForExport() const {
-    return nonEmptyExtraSettingsForExport;
+  bool IsOnlyIfSomeExtraSettingsNonEmpty() const {
+    return onlyIfSomeExtraSettingsNonEmpty;
+  };
+
+  /**
+   * \brief Mark the dependency to be included in the export only if one other
+   * dependency is included in the export.
+   */
+  DependencyMetadata& OnlyIfOtherDependencyIsExported(
+      const gd::String& otherDependency) {
+    onlyIfOtherDependencyIsExported = otherDependency;
+    return *this;
+  };
+
+  /**
+   * \brief Get the name of another dependency that must be exported to have
+   * this one also exported.
+   */
+  const gd::String& GetOtherDependencyThatMustBeExported() const {
+    return onlyIfOtherDependencyIsExported;
   };
 
   const gd::String& GetName() const { return name; };
@@ -111,6 +133,10 @@ class GD_CORE_API DependencyMetadata {
     return extraData;
   }
 
+  void CopyFrom(const DependencyMetadata& dependencyMetadata) {
+    *this = dependencyMetadata;
+  }
+
  private:
   gd::String name;        ///< The name of the dependency.
   gd::String exportName;  ///< The name used to install the package (example:
@@ -120,10 +146,10 @@ class GD_CORE_API DependencyMetadata {
   std::map<gd::String, gd::PropertyDescriptor>
       extraData;  ///< Contains dependency type specific additional parameters
                   ///< for the dependency.
-  std::set<gd::String>
-      nonEmptyExtraSettingsForExport;  ///< The set of extra settings that must
-                                       ///< be non empty for this dependency to
-                                       ///< be included by the exporter.
+  bool onlyIfSomeExtraSettingsNonEmpty;  ///< If true, only use this dependency
+                                         ///< if at least one of the extra
+                                         ///< settings is set.
+  gd::String onlyIfOtherDependencyIsExported;
 };
 }  // namespace gd
 #endif  // DEPENDENCYMETADATA_H

Core/GDCore/Extensions/Metadata/EffectMetadata.h

@@ -49,7 +49,7 @@ class GD_CORE_API EffectMetadata {
   };
 
   /**
-   * Set the help path of the effect, relative to the documentation root.
+   * Set the help path of the effect, relative to the GDevelop documentation root.
    */
   EffectMetadata& SetHelpPath(const gd::String& path) {
     helpPath = path;
@@ -81,7 +81,7 @@ class GD_CORE_API EffectMetadata {
   }
 
   /**
-   * \brief Get the help path of the effect, relative to the documentation root.
+   * \brief Get the help path of the effect, relative to the GDevelop documentation root.
    */
   const gd::String& GetHelpPath() const { return helpPath; }
 

Core/GDCore/Extensions/Metadata/ExpressionMetadata.cpp

@@ -9,13 +9,15 @@
 
 namespace gd {
 
-ExpressionMetadata::ExpressionMetadata(const gd::String& extensionNamespace_,
+ExpressionMetadata::ExpressionMetadata(const gd::String& returnType_,
+  const gd::String& extensionNamespace_,
                                        const gd::String& name_,
                                        const gd::String& fullname_,
                                        const gd::String& description_,
                                        const gd::String& group_,
                                        const gd::String& smallicon_)
-    : fullname(fullname_),
+    : returnType(returnType_),
+      fullname(fullname_),
       description(description_),
       group(group_),
       shown(true),

Core/GDCore/Extensions/Metadata/ExpressionMetadata.h

@@ -8,6 +8,7 @@
 #if defined(GD_IDE_ONLY)
 #include <functional>
 #include <memory>
+
 #include "GDCore/Events/Instruction.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
 #include "GDCore/String.h"
@@ -122,7 +123,8 @@ class GD_CORE_API ExpressionMetadata {
   /**
    * Construct a new expression metadata.
    */
-  ExpressionMetadata(const gd::String& extensionNamespace,
+  ExpressionMetadata(const gd::String& returnType,
+                     const gd::String& extensionNamespace,
                      const gd::String& name,
                      const gd::String& fullname,
                      const gd::String& description,
@@ -131,9 +133,11 @@ class GD_CORE_API ExpressionMetadata {
 
   /**
    * Construct an empty ExpressionMetadata.
-   * \warning Don't use this - only here to fullfil std::map requirements.
+   * \warning Don't use this - only here to construct a "bad" ExpressionData and
+   * to fulfill std::map requirements.
    */
-  ExpressionMetadata() : shown(false), isPrivate(false){};
+  ExpressionMetadata()
+      : returnType("unknown"), shown(false), isPrivate(false){};
 
   virtual ~ExpressionMetadata(){};
 
@@ -151,14 +155,16 @@ class GD_CORE_API ExpressionMetadata {
   }
 
   /**
-   * Get the help path of the expression, relative to the documentation root.
+   * Get the help path of the expression, relative to the GDevelop documentation
+   * root.
    */
-  const gd::String &GetHelpPath() const { return helpPath; }
+  const gd::String& GetHelpPath() const { return helpPath; }
 
   /**
-   * Set the help path of the expression, relative to the documentation root.
+   * Set the help path of the expression, relative to the GDevelop documentation
+   * root.
    */
-  ExpressionMetadata &SetHelpPath(const gd::String &path) {
+  ExpressionMetadata& SetHelpPath(const gd::String& path) {
     helpPath = path;
     return *this;
   }
@@ -205,12 +211,14 @@ class GD_CORE_API ExpressionMetadata {
   };
 
   /**
-   * \brief Set the long description shown in the editor for the last added parameter.
+   * \brief Set the long description shown in the editor for the last added
+   * parameter.
    *
    * \see AddParameter
    */
-  ExpressionMetadata &SetParameterLongDescription(gd::String longDescription) {
-    if (!parameters.empty()) parameters.back().SetLongDescription(longDescription);
+  ExpressionMetadata& SetParameterLongDescription(gd::String longDescription) {
+    if (!parameters.empty())
+      parameters.back().SetLongDescription(longDescription);
     return *this;
   };
 
@@ -236,6 +244,7 @@ class GD_CORE_API ExpressionMetadata {
   ExpressionCodeGenerationInformation codeExtraInformation;
 
   bool IsShown() const { return shown; }
+  const gd::String& GetReturnType() const { return returnType; }
   const gd::String& GetFullName() const { return fullname; }
   const gd::String& GetDescription() const { return description; }
   const gd::String& GetGroup() const { return group; }
@@ -254,6 +263,7 @@ class GD_CORE_API ExpressionMetadata {
   std::vector<gd::ParameterMetadata> parameters;
 
  private:
+  gd::String returnType;
   gd::String fullname;
   gd::String description;
   gd::String helpPath;

Core/GDCore/Extensions/Metadata/InstructionMetadata.cpp

@@ -4,10 +4,13 @@
  * reserved. This project is released under the MIT License.
  */
 #include "InstructionMetadata.h"
+
 #include <algorithm>
+
 #include "GDCore/CommonTools.h"
 #include "GDCore/Serialization/SerializerElement.h"
 #include "GDCore/Tools/Localization.h"
+#include "ParameterMetadata.h"
 
 namespace gd {
 InstructionMetadata::InstructionMetadata()
@@ -45,8 +48,6 @@ InstructionMetadata::InstructionMetadata(const gd::String& extensionNamespace_,
       isObjectInstruction(false),
       isBehaviorInstruction(false) {}
 
-ParameterMetadata::ParameterMetadata() : optional(false), codeOnly(false) {}
-
 InstructionMetadata& InstructionMetadata::AddParameter(
     const gd::String& type,
     const gd::String& description,
@@ -158,26 +159,4 @@ InstructionMetadata::UseStandardRelationalOperatorParameters(
   return *this;
 }
 
-void ParameterMetadata::SerializeTo(SerializerElement& element) const {
-  element.SetAttribute("type", type);
-  element.SetAttribute("supplementaryInformation", supplementaryInformation);
-  element.SetAttribute("optional", optional);
-  element.SetAttribute("description", description);
-  element.SetAttribute("longDescription", longDescription);
-  element.SetAttribute("codeOnly", codeOnly);
-  element.SetAttribute("defaultValue", defaultValue);
-  element.SetAttribute("name", name);
-}
-
-void ParameterMetadata::UnserializeFrom(const SerializerElement& element) {
-  type = element.GetStringAttribute("type");
-  supplementaryInformation =
-      element.GetStringAttribute("supplementaryInformation");
-  optional = element.GetBoolAttribute("optional");
-  description = element.GetStringAttribute("description");
-  longDescription = element.GetStringAttribute("longDescription");
-  codeOnly = element.GetBoolAttribute("codeOnly");
-  defaultValue = element.GetStringAttribute("defaultValue");
-  name = element.GetStringAttribute("name");
-}
 }  // namespace gd

Core/GDCore/Extensions/Metadata/InstructionMetadata.h

@@ -10,8 +10,10 @@
 #include <functional>
 #include <map>
 #include <memory>
+
 #include "GDCore/Events/Instruction.h"
 #include "GDCore/String.h"
+#include "ParameterMetadata.h"
 namespace gd {
 class Project;
 class Layout;
@@ -22,212 +24,6 @@ class SerializerElement;
 
 namespace gd {
 
-/**
- * \brief Contains user-friendly info about a parameter, and information about
- * what a parameter need
- *
- * \ingroup Events
- */
-class GD_CORE_API ParameterMetadata {
- public:
-  ParameterMetadata();
-  virtual ~ParameterMetadata(){};
-
-  /**
-   * \brief Return the type of the parameter.
-   * \see gd::ParameterMetadata::IsObject
-   */
-  const gd::String &GetType() const { return type; }
-
-  /**
-   * \brief Set the type of the parameter.
-   */
-  ParameterMetadata &SetType(const gd::String &type_) {
-    type = type_;
-    return *this;
-  }
-
-  /**
-   * \brief Return the name of the parameter.
-   *
-   * Name is optional, and won't be filled for most parameters of extensions.
-   * It is useful when generating a function from events, where parameters must
-   * be named.
-   */
-  const gd::String &GetName() const { return name; }
-
-  /**
-   * \brief Set the name of the parameter.
-   *
-   * Name is optional, and won't be filled for most parameters of extensions.
-   * It is useful when generating a function from events, where parameters must
-   * be named.
-   */
-  ParameterMetadata &SetName(const gd::String &name_) {
-    name = name_;
-    return *this;
-  }
-
-  /**
-   * \brief Return an optional additional information, used for some parameters
-   * with special type (For example, it can contains the type of object accepted
-   * by the parameter).
-   */
-  const gd::String &GetExtraInfo() const { return supplementaryInformation; }
-
-  /**
-   * \brief Set an optional additional information, used for some parameters
-   * with special type (For example, it can contains the type of object accepted
-   * by the parameter).
-   */
-  ParameterMetadata &SetExtraInfo(const gd::String &supplementaryInformation_) {
-    supplementaryInformation = supplementaryInformation_;
-    return *this;
-  }
-
-  /**
-   * \brief Return true if the parameter is optional.
-   */
-  bool IsOptional() const { return optional; }
-
-  /**
-   * \brief Set if the parameter is optional.
-   */
-  ParameterMetadata &SetOptional(bool optional_ = true) {
-    optional = optional_;
-    return *this;
-  }
-
-  /**
-   * \brief Return the description of the parameter
-   */
-  const gd::String &GetDescription() const { return description; }
-
-  /**
-   * \brief Set the description of the parameter.
-   */
-  ParameterMetadata &SetDescription(const gd::String &description_) {
-    description = description_;
-    return *this;
-  }
-
-  /**
-   * \brief Return true if the parameter is only meant to be completed during
-   * compilation and must not be displayed to the user.
-   */
-  bool IsCodeOnly() const { return codeOnly; }
-
-  /**
-   * \brief Set if the parameter is only meant to be completed during
-   * compilation and must not be displayed to the user.
-   */
-  ParameterMetadata &SetCodeOnly(bool codeOnly_ = true) {
-    codeOnly = codeOnly_;
-    return *this;
-  }
-
-  /**
-   * \brief Get the default value for the parameter.
-   */
-  const gd::String &GetDefaultValue() const { return defaultValue; }
-
-  /**
-   * \brief Set the default value, if the parameter is optional.
-   */
-  ParameterMetadata &SetDefaultValue(const gd::String &defaultValue_) {
-    defaultValue = defaultValue_;
-    return *this;
-  }
-
-  /**
-   * \brief Get the user friendly, long description for the parameter.
-   */
-  const gd::String &GetLongDescription() const { return longDescription; }
-
-  /**
-   * \brief Set the user friendly, long description for the parameter.
-   */
-  ParameterMetadata &SetLongDescription(const gd::String &longDescription_) {
-    longDescription = longDescription_;
-    return *this;
-  }
-
-  /**
-   * \brief Return true if the type of the parameter is "object", "objectPtr" or
-   * "objectList".
-   *
-   * \see gd::ParameterMetadata::GetType
-   */
-  static bool IsObject(const gd::String &parameterType) {
-    return parameterType == "object" || parameterType == "objectPtr" ||
-           parameterType == "objectList" ||
-           parameterType == "objectListWithoutPicking";
-  }
-
-  /**
-   * \brief Return true if the type of the parameter is "behavior".
-   *
-   * \see gd::ParameterMetadata::GetType
-   */
-  static bool IsBehavior(const gd::String &parameterType) {
-    return parameterType == "behavior";
-  }
-
-  /**
-   * \brief Return true if the type of the parameter is an expression of the
-   * given type.
-   * \note If you had a new type of parameter, also add it in the IDE (
-   * see EventsFunctionParametersEditor) and in the EventsCodeGenerator.
-   */
-  static bool IsExpression(const gd::String &type,
-                           const gd::String &parameterType) {
-    if (type == "number") {
-      return parameterType == "expression" || parameterType == "camera" ||
-             parameterType == "forceMultiplier";
-    } else if (type == "string") {
-      return parameterType == "string" || parameterType == "layer" ||
-             parameterType == "color" || parameterType == "file" ||
-             parameterType == "joyaxis" ||
-             parameterType == "stringWithSelector" ||
-             parameterType == "sceneName";
-    } else if (type == "variable") {
-      return parameterType == "objectvar" || parameterType == "globalvar" ||
-             parameterType == "scenevar";
-    }
-    return false;
-  }
-
-  /** \name Serialization
-   */
-  ///@{
-  /**
-   * \brief Serialize the ParameterMetadata to the specified element
-   */
-  void SerializeTo(gd::SerializerElement &element) const;
-
-  /**
-   * \brief Load the ParameterMetadata from the specified element
-   */
-  void UnserializeFrom(const gd::SerializerElement &element);
-  ///@}
-
-  // TODO: Deprecated public fields. Any direct using should be moved to
-  // getter/setter.
-  gd::String type;                      ///< Parameter type
-  gd::String supplementaryInformation;  ///< Used if needed
-  bool optional;                        ///< True if the parameter is optional
-
-  gd::String description;  ///< Description shown in editor
-  bool codeOnly;  ///< True if parameter is relative to code generation only,
-                  ///< i.e. must not be shown in editor
- private:
-  gd::String longDescription;  ///< Long description shown in the editor.
-  gd::String defaultValue;     ///< Used as a default value in editor or if an
-                               ///< optional parameter is empty.
-  gd::String name;             ///< The name of the parameter to be used in code
-                               ///< generation. Optional.
-};
-
 /**
  * \brief Describe user-friendly information about an instruction (action or
  * condition), its parameters and the function name as well as other information
@@ -274,12 +70,14 @@ class GD_CORE_API InstructionMetadata {
   bool CanHaveSubInstructions() const { return canHaveSubInstructions; }
 
   /**
-   * Get the help path of the instruction, relative to the documentation root.
+   * Get the help path of the instruction, relative to the GDevelop
+   * documentation root.
    */
   const gd::String &GetHelpPath() const { return helpPath; }
 
   /**
-   * Set the help path of the instruction, relative to the documentation root.
+   * Set the help path of the instruction, relative to the GDevelop
+   * documentation root.
    */
   InstructionMetadata &SetHelpPath(const gd::String &path) {
     helpPath = path;
@@ -389,6 +187,19 @@ class GD_CORE_API InstructionMetadata {
     return *this;
   };
 
+  /**
+   * \brief Set the additional information, used for some parameters
+   * with special type (for example, it can contains the type of object accepted
+   * by the parameter), for the last added parameter.
+   *
+   * \see AddParameter
+   */
+  InstructionMetadata &SetParameterExtraInfo(const gd::String &extraInfo) {
+    if (!parameters.empty())
+      parameters.back().SetExtraInfo(extraInfo);
+    return *this;
+  };
+
   /**
    * \brief Add the default parameters for an instruction manipulating the
    * specified type ("string", "number") with the default operators.
@@ -421,7 +232,21 @@ class GD_CORE_API InstructionMetadata {
   }
 
   /**
-   * \brief Consider that the instruction is easy for an user to understand.
+   * \brief Check if the instruction is an object instruction.
+   */
+  bool IsObjectInstruction() {
+    return isObjectInstruction;
+  }
+
+  /**
+   * \brief Check if the instruction is a behavior instruction.
+   */
+  bool IsBehaviorInstruction() {
+    return isBehaviorInstruction;
+  }
+
+  /**
+   * \brief Consider that the instruction is easy for a user to understand.
    */
   InstructionMetadata &MarkAsSimple() {
     usageComplexity = 2;
@@ -429,7 +254,7 @@ class GD_CORE_API InstructionMetadata {
   }
 
   /**
-   * \brief Consider that the instruction is harder for an user to understand
+   * \brief Consider that the instruction is harder for a user to understand
    * than a normal instruction.
    */
   InstructionMetadata &MarkAsAdvanced() {
@@ -438,7 +263,7 @@ class GD_CORE_API InstructionMetadata {
   }
 
   /**
-   * \brief Consider that the instruction is complex for an user to understand.
+   * \brief Consider that the instruction is complex for a user to understand.
    */
   InstructionMetadata &MarkAsComplex() {
     usageComplexity = 9;

Core/GDCore/Extensions/Metadata/MetadataProvider.cpp

@@ -4,11 +4,13 @@
  * reserved. This project is released under the MIT License.
  */
 #include "GDCore/Extensions/Metadata/MetadataProvider.h"
+
 #include <algorithm>
+
 #include "GDCore/Extensions/Metadata/BehaviorMetadata.h"
+#include "GDCore/Extensions/Metadata/EffectMetadata.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
 #include "GDCore/Extensions/Metadata/ObjectMetadata.h"
-#include "GDCore/Extensions/Metadata/EffectMetadata.h"
 #include "GDCore/Extensions/Platform.h"
 #include "GDCore/Extensions/PlatformExtension.h"
 #include "GDCore/String.h"
@@ -17,12 +19,11 @@ using namespace std;
 
 namespace gd {
 
-gd::BehaviorMetadata MetadataProvider::badBehaviorInfo;
+gd::BehaviorMetadata MetadataProvider::badBehaviorMetadata;
 gd::ObjectMetadata MetadataProvider::badObjectInfo;
 gd::EffectMetadata MetadataProvider::badEffectMetadata;
 gd::InstructionMetadata MetadataProvider::badInstructionMetadata;
 gd::ExpressionMetadata MetadataProvider::badExpressionMetadata;
-gd::ExpressionMetadata MetadataProvider::badStrExpressionMetadata;
 gd::PlatformExtension MetadataProvider::badExtension;
 
 ExtensionAndMetadata<BehaviorMetadata>
@@ -37,7 +38,7 @@ MetadataProvider::GetExtensionAndBehaviorMetadata(const gd::Platform& platform,
     }
   }
 
-  return ExtensionAndMetadata<BehaviorMetadata>(badExtension, badBehaviorInfo);
+  return ExtensionAndMetadata<BehaviorMetadata>(badExtension, badBehaviorMetadata);
 }
 
 const BehaviorMetadata& MetadataProvider::GetBehaviorMetadata(
@@ -276,7 +277,7 @@ MetadataProvider::GetExtensionAndObjectStrExpressionMetadata(
   }
 
   return ExtensionAndMetadata<ExpressionMetadata>(badExtension,
-                                                  badStrExpressionMetadata);
+                                                  badExpressionMetadata);
 }
 
 const gd::ExpressionMetadata& MetadataProvider::GetObjectStrExpressionMetadata(
@@ -313,7 +314,7 @@ MetadataProvider::GetExtensionAndBehaviorStrExpressionMetadata(
   }
 
   return ExtensionAndMetadata<ExpressionMetadata>(badExtension,
-                                                  badStrExpressionMetadata);
+                                                  badExpressionMetadata);
 }
 
 const gd::ExpressionMetadata&
@@ -337,7 +338,7 @@ MetadataProvider::GetExtensionAndStrExpressionMetadata(
   }
 
   return ExtensionAndMetadata<ExpressionMetadata>(badExtension,
-                                                  badStrExpressionMetadata);
+                                                  badExpressionMetadata);
 }
 
 const gd::ExpressionMetadata& MetadataProvider::GetStrExpressionMetadata(
@@ -345,197 +346,48 @@ const gd::ExpressionMetadata& MetadataProvider::GetStrExpressionMetadata(
   return GetExtensionAndStrExpressionMetadata(platform, exprType).GetMetadata();
 }
 
-bool MetadataProvider::HasAction(const gd::Platform& platform,
-                                 gd::String name) {
-  auto& extensions = platform.GetAllPlatformExtensions();
+const gd::ExpressionMetadata& MetadataProvider::GetAnyExpressionMetadata(
+    const gd::Platform& platform, gd::String exprType) {
+  const auto& numberExpressionMetadata =
+      GetExpressionMetadata(platform, exprType);
+  const auto& stringExpressionMetadata =
+      GetStrExpressionMetadata(platform, exprType);
 
-  for (auto& extension : extensions) {
-    const auto& actions = extension->GetAllActions();
-    if (actions.find(name) != actions.end()) return true;
-  }
-
-  return false;
+  return &numberExpressionMetadata != &badExpressionMetadata
+             ? numberExpressionMetadata
+             : &stringExpressionMetadata != &badExpressionMetadata
+                   ? stringExpressionMetadata
+                   : badExpressionMetadata;
 }
 
-bool MetadataProvider::HasObjectAction(const gd::Platform& platform,
-                                       gd::String objectType,
-                                       gd::String name) {
-  auto& extensions = platform.GetAllPlatformExtensions();
-  for (auto& extension : extensions) {
-    const auto& actions = extension->GetAllActionsForObject(objectType);
-    if (actions.find(name) != actions.end()) return true;
-  }
+const gd::ExpressionMetadata& MetadataProvider::GetObjectAnyExpressionMetadata(
+    const gd::Platform& platform, gd::String objectType, gd::String exprType) {
+  const auto& numberExpressionMetadata =
+      GetObjectExpressionMetadata(platform, objectType, exprType);
+  const auto& stringExpressionMetadata =
+      GetObjectStrExpressionMetadata(platform, objectType, exprType);
 
-  // Then check in functions of "Base object".
-  for (auto& extension : extensions) {
-    const auto& actions = extension->GetAllActionsForObject("");
-    if (actions.find(name) != actions.end()) return true;
-  }
-
-  return false;
+  return &numberExpressionMetadata != &badExpressionMetadata
+             ? numberExpressionMetadata
+             : &stringExpressionMetadata != &badExpressionMetadata
+                   ? stringExpressionMetadata
+                   : badExpressionMetadata;
 }
 
-bool MetadataProvider::HasBehaviorAction(const gd::Platform& platform,
-                                         gd::String behaviorType,
-                                         gd::String name) {
-  auto& extensions = platform.GetAllPlatformExtensions();
-  for (auto& extension : extensions) {
-    const auto& actions = extension->GetAllActionsForBehavior(behaviorType);
-    if (actions.find(name) != actions.end()) return true;
-  }
+const gd::ExpressionMetadata&
+MetadataProvider::GetBehaviorAnyExpressionMetadata(const gd::Platform& platform,
+                                                   gd::String autoType,
+                                                   gd::String exprType) {
+  const auto& numberExpressionMetadata =
+      GetBehaviorExpressionMetadata(platform, autoType, exprType);
+  const auto& stringExpressionMetadata =
+      GetBehaviorStrExpressionMetadata(platform, autoType, exprType);
 
-  // Then check in functions of "Base object".
-  for (auto& extension : extensions) {
-    const auto& actions = extension->GetAllActionsForBehavior("");
-    if (actions.find(name) != actions.end()) return true;
-  }
-
-  return false;
-}
-
-bool MetadataProvider::HasCondition(const gd::Platform& platform,
-                                    gd::String name) {
-  auto& extensions = platform.GetAllPlatformExtensions();
-  for (auto& extension : extensions) {
-    const auto& conditions = extension->GetAllConditions();
-    if (conditions.find(name) != conditions.end()) return true;
-  }
-
-  return false;
-}
-
-bool MetadataProvider::HasObjectCondition(const gd::Platform& platform,
-                                          gd::String objectType,
-                                          gd::String name) {
-  auto& extensions = platform.GetAllPlatformExtensions();
-  for (auto& extension : extensions) {
-    const auto& conditions = extension->GetAllConditionsForObject(objectType);
-    if (conditions.find(name) != conditions.end()) return true;
-  }
-
-  // Then check in functions of "Base object".
-  for (auto& extension : extensions) {
-    const auto& conditions = extension->GetAllConditionsForObject("");
-    if (conditions.find(name) != conditions.end()) return true;
-  }
-
-  return false;
-}
-
-bool MetadataProvider::HasBehaviorCondition(const gd::Platform& platform,
-                                            gd::String behaviorType,
-                                            gd::String name) {
-  auto& extensions = platform.GetAllPlatformExtensions();
-  for (auto& extension : extensions) {
-    const auto& conditions =
-        extension->GetAllConditionsForBehavior(behaviorType);
-    if (conditions.find(name) != conditions.end()) return true;
-  }
-
-  // Then check in functions of "Base object".
-  for (auto& extension : extensions) {
-    const auto& conditions = extension->GetAllConditionsForBehavior("");
-    if (conditions.find(name) != conditions.end()) return true;
-  }
-
-  return false;
-}
-
-bool MetadataProvider::HasExpression(const gd::Platform& platform,
-                                     gd::String name) {
-  auto& extensions = platform.GetAllPlatformExtensions();
-  for (auto& extension : extensions) {
-    const auto& expressions = extension->GetAllExpressions();
-    if (expressions.find(name) != expressions.end()) return true;
-  }
-
-  return false;
-}
-
-bool MetadataProvider::HasObjectExpression(const gd::Platform& platform,
-                                           gd::String objectType,
-                                           gd::String name) {
-  auto& extensions = platform.GetAllPlatformExtensions();
-  for (auto& extension : extensions) {
-    const auto& expressions = extension->GetAllExpressionsForObject(objectType);
-    if (expressions.find(name) != expressions.end()) return true;
-  }
-
-  // Then check in functions of "Base object".
-  for (auto& extension : extensions) {
-    const auto& expressions = extension->GetAllExpressionsForObject("");
-    if (expressions.find(name) != expressions.end()) return true;
-  }
-
-  return false;
-}
-
-bool MetadataProvider::HasBehaviorExpression(const gd::Platform& platform,
-                                             gd::String behaviorType,
-                                             gd::String name) {
-  auto& extensions = platform.GetAllPlatformExtensions();
-  for (auto& extension : extensions) {
-    const auto& expressions =
-        extension->GetAllExpressionsForBehavior(behaviorType);
-    if (expressions.find(name) != expressions.end()) return true;
-  }
-
-  // Then check in functions of "Base object".
-  for (auto& extension : extensions) {
-    const auto& expressions = extension->GetAllExpressionsForBehavior("");
-    if (expressions.find(name) != expressions.end()) return true;
-  }
-
-  return false;
-}
-
-bool MetadataProvider::HasStrExpression(const gd::Platform& platform,
-                                        gd::String name) {
-  auto& extensions = platform.GetAllPlatformExtensions();
-  for (auto& extension : extensions) {
-    const auto& expressions = extension->GetAllStrExpressions();
-    if (expressions.find(name) != expressions.end()) return true;
-  }
-
-  return false;
-}
-
-bool MetadataProvider::HasObjectStrExpression(const gd::Platform& platform,
-                                              gd::String objectType,
-                                              gd::String name) {
-  auto& extensions = platform.GetAllPlatformExtensions();
-  for (auto& extension : extensions) {
-    const auto& expressions =
-        extension->GetAllStrExpressionsForObject(objectType);
-    if (expressions.find(name) != expressions.end()) return true;
-  }
-
-  // Then check in functions of "Base object".
-  for (auto& extension : extensions) {
-    const auto& expressions = extension->GetAllStrExpressionsForObject("");
-    if (expressions.find(name) != expressions.end()) return true;
-  }
-
-  return false;
-}
-
-bool MetadataProvider::HasBehaviorStrExpression(const gd::Platform& platform,
-                                                gd::String behaviorType,
-                                                gd::String name) {
-  auto& extensions = platform.GetAllPlatformExtensions();
-  for (auto& extension : extensions) {
-    const auto& expressions =
-        extension->GetAllStrExpressionsForBehavior(behaviorType);
-    if (expressions.find(name) != expressions.end()) return true;
-  }
-
-  // Then check in functions of "Base object".
-  for (auto& extension : extensions) {
-    const auto& expressions = extension->GetAllStrExpressionsForBehavior("");
-    if (expressions.find(name) != expressions.end()) return true;
-  }
-
-  return false;
+  return &numberExpressionMetadata != &badExpressionMetadata
+             ? numberExpressionMetadata
+             : &stringExpressionMetadata != &badExpressionMetadata
+                   ? stringExpressionMetadata
+                   : badExpressionMetadata;
 }
 
 MetadataProvider::~MetadataProvider() {}

Core/GDCore/Extensions/Metadata/MetadataProvider.h

@@ -96,7 +96,7 @@ class GD_CORE_API MetadataProvider {
 
   /**
    * Get information about an expression, and its associated extension.
-   * Works for static expressions.
+   * Works for free expressions.
    */
   static ExtensionAndMetadata<ExpressionMetadata>
   GetExtensionAndExpressionMetadata(const gd::Platform& platform,
@@ -122,7 +122,7 @@ class GD_CORE_API MetadataProvider {
 
   /**
    * Get information about a string expression, and its associated extension.
-   * Works for static expressions.
+   * Works for free expressions.
    */
   static ExtensionAndMetadata<ExpressionMetadata>
   GetExtensionAndStrExpressionMetadata(const gd::Platform& platform,
@@ -180,7 +180,7 @@ class GD_CORE_API MetadataProvider {
 
   /**
    * Get information about an expression from its type
-   * Works for static expressions.
+   * Works for free expressions.
    */
   static const gd::ExpressionMetadata& GetExpressionMetadata(
       const gd::Platform& platform, gd::String exprType);
@@ -201,7 +201,7 @@ class GD_CORE_API MetadataProvider {
 
   /**
    * Get information about a string expression from its type
-   * Works for static expressions.
+   * Works for free expressions.
    */
   static const gd::ExpressionMetadata& GetStrExpressionMetadata(
       const gd::Platform& platform, gd::String exprType);
@@ -221,96 +221,32 @@ class GD_CORE_API MetadataProvider {
       const gd::Platform& platform, gd::String autoType, gd::String exprType);
 
   /**
-   * \brief Check if a (static) condition exists
-   * @return true if the (static) condition exists
+   * Get information about an expression from its type.
+   * Works for free expressions.
    */
-  static bool HasCondition(const gd::Platform& platform, gd::String name);
+  static const gd::ExpressionMetadata& GetAnyExpressionMetadata(
+      const gd::Platform& platform, gd::String exprType);
 
   /**
-   * \brief Check if a (static) action exists
-   * @return true if the (static) action exists
+   * Get information about an expression from its type.
+   * Works for object expressions.
    */
-  static bool HasAction(const gd::Platform& platform, gd::String name);
+  static const gd::ExpressionMetadata& GetObjectAnyExpressionMetadata(
+      const gd::Platform& platform, gd::String objectType, gd::String exprType);
 
   /**
-   * \brief Check if a (object) action exists
-   * @return true if the (object) action exists
+   * Get information about an expression from its type.
+   * Works for behavior expressions.
    */
-  static bool HasObjectAction(const gd::Platform& platform,
-                              gd::String objectType,
-                              gd::String name);
-
-  /**
-   * \brief Check if a (object) condition exists
-   * @return true if the (object) condition exists
-   */
-  static bool HasObjectCondition(const gd::Platform& platform,
-                                 gd::String objectType,
-                                 gd::String name);
-
-  /**
-   * \brief Check if a (behavior) action exists
-   * @return true if the (behavior) action exists
-   */
-  static bool HasBehaviorAction(const gd::Platform& platform,
-                                gd::String behaviorType,
-                                gd::String name);
-
-  /**
-   * \brief Check if a (behavior) condition exists
-   * @return true if the (behavior) condition exists
-   */
-  static bool HasBehaviorCondition(const gd::Platform& platform,
-                                   gd::String behaviorType,
-                                   gd::String name);
-
-  /**
-   * \brief Check if a (static) expression exists
-   * @return true if the (static) expression exists
-   */
-  static bool HasExpression(const gd::Platform& platform, gd::String name);
-
-  /**
-   * \brief Check if a (object) expression exists
-   * @return true if the (object) expression exists
-   */
-  static bool HasObjectExpression(const gd::Platform& platform,
-                                  gd::String objectType,
-                                  gd::String name);
-
-  /**
-   * \brief Check if a (behavior) expression exists
-   * @return true if the (behavior) expression exists
-   */
-  static bool HasBehaviorExpression(const gd::Platform& platform,
-                                    gd::String behaviorType,
-                                    gd::String name);
-
-  /**
-   * \brief Check if a (static) string expression exists
-   * @return true if the (static) string expression exists
-   */
-  static bool HasStrExpression(const gd::Platform& platform, gd::String name);
-
-  /**
-   * \brief Check if a (object) string expression exists
-   * @return true if the (object) string expression exists
-   */
-  static bool HasObjectStrExpression(const gd::Platform& platform,
-                                     gd::String objectType,
-                                     gd::String name);
-
-  /**
-   * \brief Check if a (behavior) string expression exists
-   * @return true if the (behavior) string expression exists
-   */
-  static bool HasBehaviorStrExpression(const gd::Platform& platform,
-                                       gd::String behaviorType,
-                                       gd::String name);
+  static const gd::ExpressionMetadata& GetBehaviorAnyExpressionMetadata(
+      const gd::Platform& platform, gd::String autoType, gd::String exprType);
 
   static bool IsBadExpressionMetadata(const gd::ExpressionMetadata& metadata) {
-    return &metadata == &badExpressionMetadata ||
-           &metadata == &badStrExpressionMetadata;
+    return &metadata == &badExpressionMetadata;
+  }
+
+  static bool IsBadBehaviorMetadata(const gd::BehaviorMetadata& metadata) {
+    return &metadata == &badBehaviorMetadata;
   }
 
   virtual ~MetadataProvider();
@@ -319,12 +255,11 @@ class GD_CORE_API MetadataProvider {
   MetadataProvider();
 
   static PlatformExtension badExtension;
-  static BehaviorMetadata badBehaviorInfo;
+  static BehaviorMetadata badBehaviorMetadata;
   static ObjectMetadata badObjectInfo;
   static EffectMetadata badEffectMetadata;
   static gd::InstructionMetadata badInstructionMetadata;
   static gd::ExpressionMetadata badExpressionMetadata;
-  static gd::ExpressionMetadata badStrExpressionMetadata;
   int useless;  // Useless member to avoid emscripten "must have a positive
                 // integer typeid pointer" runtime error.
 };

Core/GDCore/Extensions/Metadata/MultipleInstructionMetadata.cpp

@@ -0,0 +1,12 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-present Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#include "MultipleInstructionMetadata.h"
+
+#include "InstructionMetadata.h"
+
+namespace gd {
+
+}  // namespace gd

Core/GDCore/Extensions/Metadata/MultipleInstructionMetadata.h

@@ -0,0 +1,216 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-present Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#ifndef MULTIPLEINSTRUCTIONSMETADATA_H
+#define MULTIPLEINSTRUCTIONSMETADATA_H
+#include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
+#include "GDCore/Extensions/Metadata/InstructionMetadata.h"
+#include "GDCore/String.h"
+namespace gd {}  // namespace gd
+
+namespace gd {
+
+/**
+ * \brief A "composite" metadata that can be used to easily declare
+ * both an expression and a related condition (and a related action)
+ * without writing manually the three of them.
+ *
+ * \ingroup PlatformDefinition
+ */
+class GD_CORE_API MultipleInstructionMetadata {
+ public:
+  static MultipleInstructionMetadata WithExpressionAndCondition(
+      gd::ExpressionMetadata &expression, gd::InstructionMetadata &condition) {
+    return MultipleInstructionMetadata(expression, condition);
+  }
+  static MultipleInstructionMetadata WithExpressionAndConditionAndAction(
+      gd::ExpressionMetadata &expression,
+      gd::InstructionMetadata &condition,
+      gd::InstructionMetadata &action) {
+    return MultipleInstructionMetadata(expression, condition, action);
+  }
+
+  /**
+   * \see gd::InstructionMetadata::AddParameter
+   */
+  MultipleInstructionMetadata &AddParameter(
+      const gd::String &type,
+      const gd::String &label,
+      const gd::String &optionalObjectType = "",
+      bool parameterIsOptional = false) {
+#if defined(GD_IDE_ONLY)
+    if (expression)
+      expression->AddParameter(
+          type, label, optionalObjectType, parameterIsOptional);
+    if (condition)
+      condition->AddParameter(
+          type, label, optionalObjectType, parameterIsOptional);
+    if (action)
+      action->AddParameter(
+          type, label, optionalObjectType, parameterIsOptional);
+#endif
+    return *this;
+  }
+
+  /**
+   * \see gd::InstructionMetadata::AddCodeOnlyParameter
+   */
+  MultipleInstructionMetadata &AddCodeOnlyParameter(
+      const gd::String &type, const gd::String &supplementaryInformation) {
+#if defined(GD_IDE_ONLY)
+    if (expression)
+      expression->AddCodeOnlyParameter(type, supplementaryInformation);
+    if (condition)
+      condition->AddCodeOnlyParameter(type, supplementaryInformation);
+    if (action) action->AddCodeOnlyParameter(type, supplementaryInformation);
+#endif
+    return *this;
+  }
+
+  /**
+   * \see gd::InstructionMetadata::SetDefaultValue
+   */
+  MultipleInstructionMetadata &SetDefaultValue(const gd::String &defaultValue) {
+#if defined(GD_IDE_ONLY)
+    if (expression) expression->SetDefaultValue(defaultValue);
+    if (condition) condition->SetDefaultValue(defaultValue);
+    if (action) action->SetDefaultValue(defaultValue);
+#endif
+    return *this;
+  };
+
+  /**
+   * \see gd::InstructionMetadata::SetParameterLongDescription
+   */
+  MultipleInstructionMetadata &SetParameterLongDescription(
+      const gd::String &longDescription) {
+#if defined(GD_IDE_ONLY)
+    if (expression) expression->SetParameterLongDescription(longDescription);
+    if (condition) condition->SetParameterLongDescription(longDescription);
+    if (action) action->SetParameterLongDescription(longDescription);
+#endif
+    return *this;
+  };
+
+  /**
+   * \see gd::InstructionMetadata::SetHidden
+   */
+  MultipleInstructionMetadata &SetHidden() {
+#if defined(GD_IDE_ONLY)
+    if (expression) expression->SetHidden();
+    if (condition) condition->SetHidden();
+    if (action) action->SetHidden();
+#endif
+    return *this;
+  };
+
+  /**
+   * \see gd::InstructionMetadata::UseStandardOperatorParameters
+   * \see gd::InstructionMetadata::UseStandardRelationalOperatorParameters
+   */
+  MultipleInstructionMetadata &UseStandardParameters(const gd::String &type) {
+#if defined(GD_IDE_ONLY)
+    if (condition) condition->UseStandardRelationalOperatorParameters(type);
+    if (action) action->UseStandardOperatorParameters(type);
+#endif
+    return *this;
+  }
+
+  MultipleInstructionMetadata &SetFunctionName(const gd::String &functionName) {
+#if defined(GD_IDE_ONLY)
+    if (expression) expression->SetFunctionName(functionName);
+    if (condition) condition->SetFunctionName(functionName);
+    if (action) action->GetCodeExtraInformation().SetFunctionName(functionName);
+#endif
+    return *this;
+  }
+
+  MultipleInstructionMetadata &SetGetter(const gd::String &getter) {
+#if defined(GD_IDE_ONLY)
+    if (expression) expression->SetFunctionName(getter);
+    if (condition) condition->SetFunctionName(getter);
+    if (action) action->GetCodeExtraInformation().SetGetter(getter);
+#endif
+    return *this;
+  }
+
+  MultipleInstructionMetadata &SetIncludeFile(const gd::String &includeFile) {
+#if defined(GD_IDE_ONLY)
+    if (expression)
+      expression->GetCodeExtraInformation().SetIncludeFile(includeFile);
+    if (condition)
+      condition->GetCodeExtraInformation().SetIncludeFile(includeFile);
+    if (action) action->GetCodeExtraInformation().SetIncludeFile(includeFile);
+#endif
+    return *this;
+  }
+
+  MultipleInstructionMetadata &AddIncludeFile(const gd::String &includeFile) {
+#if defined(GD_IDE_ONLY)
+    if (expression)
+      expression->GetCodeExtraInformation().AddIncludeFile(includeFile);
+    if (condition)
+      condition->GetCodeExtraInformation().AddIncludeFile(includeFile);
+    if (action) action->GetCodeExtraInformation().AddIncludeFile(includeFile);
+#endif
+    return *this;
+  }
+
+  /**
+   * \see gd::InstructionMetadata::MarkAsSimple
+   */
+  MultipleInstructionMetadata &MarkAsSimple() {
+#if defined(GD_IDE_ONLY)
+    if (condition) condition->MarkAsSimple();
+    if (action) action->MarkAsSimple();
+#endif
+    return *this;
+  }
+
+  /**
+   * \see gd::InstructionMetadata::MarkAsAdvanced
+   */
+  MultipleInstructionMetadata &MarkAsAdvanced() {
+#if defined(GD_IDE_ONLY)
+    if (condition) condition->MarkAsAdvanced();
+    if (action) action->MarkAsAdvanced();
+#endif
+    return *this;
+  }
+
+  /**
+   * \see gd::InstructionMetadata::MarkAsComplex
+   */
+  MultipleInstructionMetadata &MarkAsComplex() {
+#if defined(GD_IDE_ONLY)
+    if (condition) condition->MarkAsComplex();
+    if (action) action->MarkAsComplex();
+#endif
+    return *this;
+  }
+
+  /**
+   * \brief Don't use, only here to fulfill Emscripten bindings requirements.
+   */
+  MultipleInstructionMetadata()
+      : expression(nullptr), condition(nullptr), action(nullptr){};
+
+ private:
+  MultipleInstructionMetadata(gd::ExpressionMetadata &expression_,
+                              gd::InstructionMetadata &condition_)
+      : expression(&expression_), condition(&condition_), action(nullptr){};
+  MultipleInstructionMetadata(gd::ExpressionMetadata &expression_,
+                              gd::InstructionMetadata &condition_,
+                              gd::InstructionMetadata &action_)
+      : expression(&expression_), condition(&condition_), action(&action_){};
+
+  gd::ExpressionMetadata *expression;
+  gd::InstructionMetadata *condition;
+  gd::InstructionMetadata *action;
+};
+
+}  // namespace gd
+
+#endif  // MULTIPLEINSTRUCTIONSMETADATA_H

Core/GDCore/Extensions/Metadata/ObjectMetadata.cpp

@@ -4,11 +4,16 @@
  * reserved. This project is released under the MIT License.
  */
 #include "ObjectMetadata.h"
+
 #include <algorithm>
 #include <iostream>
+
 #include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
+#include "GDCore/Extensions/Metadata/MultipleInstructionMetadata.h"
+#include "GDCore/Extensions/PlatformExtension.h"
 #include "GDCore/Project/Object.h"
+#include "GDCore/Tools/Localization.h"
 
 namespace gd {
 
@@ -108,6 +113,62 @@ gd::InstructionMetadata& ObjectMetadata::AddAction(
 #endif
 }
 
+gd::InstructionMetadata& ObjectMetadata::AddScopedCondition(
+    const gd::String& name,
+    const gd::String& fullname,
+    const gd::String& description,
+    const gd::String& sentence,
+    const gd::String& group,
+    const gd::String& icon,
+    const gd::String& smallicon) {
+#if defined(GD_IDE_ONLY)
+  gd::String nameWithNamespace =
+      GetName().empty()
+          ? name // Don't insert a namespace separator for the base object.
+          : GetName() + gd::PlatformExtension::GetNamespaceSeparator() + name;
+
+  conditionsInfos[nameWithNamespace] = InstructionMetadata(extensionNamespace,
+                                                           nameWithNamespace,
+                                                           fullname,
+                                                           description,
+                                                           sentence,
+                                                           group,
+                                                           icon,
+                                                           smallicon)
+                                           .SetHelpPath(GetHelpPath())
+                                           .SetIsObjectInstruction();
+  return conditionsInfos[nameWithNamespace];
+#endif
+}
+
+gd::InstructionMetadata& ObjectMetadata::AddScopedAction(
+    const gd::String& name,
+    const gd::String& fullname,
+    const gd::String& description,
+    const gd::String& sentence,
+    const gd::String& group,
+    const gd::String& icon,
+    const gd::String& smallicon) {
+#if defined(GD_IDE_ONLY)
+  gd::String nameWithNamespace =
+      GetName().empty()
+          ? name // Don't insert a namespace separator for the base object.
+          : GetName() + gd::PlatformExtension::GetNamespaceSeparator() + name;
+
+  actionsInfos[nameWithNamespace] = InstructionMetadata(extensionNamespace,
+                                                        nameWithNamespace,
+                                                        fullname,
+                                                        description,
+                                                        sentence,
+                                                        group,
+                                                        icon,
+                                                        smallicon)
+                                        .SetHelpPath(GetHelpPath())
+                                        .SetIsObjectInstruction();
+  return actionsInfos[nameWithNamespace];
+#endif
+}
+
 gd::ExpressionMetadata& ObjectMetadata::AddExpression(
     const gd::String& name,
     const gd::String& fullname,
@@ -115,12 +176,16 @@ gd::ExpressionMetadata& ObjectMetadata::AddExpression(
     const gd::String& group,
     const gd::String& smallicon) {
 #if defined(GD_IDE_ONLY)
-  // Be careful, objects expression do not have namespace ( not necessary as
-  // objects inherits from only one derived object )
-  expressionsInfos[name] =
-      ExpressionMetadata(
-          extensionNamespace, name, fullname, description, group, smallicon)
-          .SetHelpPath(GetHelpPath());
+  // Be careful, objects expression do not have namespace (not necessary as
+  // objects inherits from only one derived object).
+  expressionsInfos[name] = ExpressionMetadata("number",
+                                              extensionNamespace,
+                                              name,
+                                              fullname,
+                                              description,
+                                              group,
+                                              smallicon)
+                               .SetHelpPath(GetHelpPath());
 
   return expressionsInfos[name];
 #endif
@@ -133,17 +198,110 @@ gd::ExpressionMetadata& ObjectMetadata::AddStrExpression(
     const gd::String& group,
     const gd::String& smallicon) {
 #if defined(GD_IDE_ONLY)
-  // Be careful, objects expression do not have namespace ( not necessary as
-  // objects inherits from only one derived object )
-  strExpressionsInfos[name] =
-      ExpressionMetadata(
-          extensionNamespace, name, fullname, description, group, smallicon)
-          .SetHelpPath(GetHelpPath());
+  // Be careful, objects expression do not have namespace (not necessary as
+  // objects inherits from only one derived object).
+  strExpressionsInfos[name] = ExpressionMetadata("string",
+                                                 extensionNamespace,
+                                                 name,
+                                                 fullname,
+                                                 description,
+                                                 group,
+                                                 smallicon)
+                                  .SetHelpPath(GetHelpPath());
 
   return strExpressionsInfos[name];
 #endif
 }
 
+gd::MultipleInstructionMetadata ObjectMetadata::AddExpressionAndCondition(
+    const gd::String& type,
+    const gd::String& name,
+    const gd::String& fullname,
+    const gd::String& descriptionSubject,
+    const gd::String& sentenceName,
+    const gd::String& group,
+    const gd::String& icon) {
+  gd::String expressionDescriptionTemplate = _("Return <subject>.");
+  auto& expression =
+      type == "number"
+          ? AddExpression(name,
+                          fullname,
+                          expressionDescriptionTemplate.FindAndReplace(
+                              "<subject>", descriptionSubject),
+                          group,
+                          icon)
+          : AddStrExpression(name,
+                             fullname,
+                             expressionDescriptionTemplate.FindAndReplace(
+                                 "<subject>", descriptionSubject),
+                             group,
+                             icon);
+
+  gd::String conditionDescriptionTemplate = _("Compare <subject>.");
+  auto& condition =
+      AddScopedCondition(name,
+                         fullname,
+                         conditionDescriptionTemplate.FindAndReplace(
+                             "<subject>", descriptionSubject),
+                         sentenceName,
+                         group,
+                         icon,
+                         icon);
+
+  return MultipleInstructionMetadata::WithExpressionAndCondition(expression,
+                                                                 condition);
+}
+
+gd::MultipleInstructionMetadata
+ObjectMetadata::AddExpressionAndConditionAndAction(
+    const gd::String& type,
+    const gd::String& name,
+    const gd::String& fullname,
+    const gd::String& descriptionSubject,
+    const gd::String& sentenceName,
+    const gd::String& group,
+    const gd::String& icon) {
+  gd::String expressionDescriptionTemplate = _("Return <subject>.");
+  auto& expression =
+      type == "number"
+          ? AddExpression(name,
+                          fullname,
+                          expressionDescriptionTemplate.FindAndReplace(
+                              "<subject>", descriptionSubject),
+                          group,
+                          icon)
+          : AddStrExpression(name,
+                             fullname,
+                             expressionDescriptionTemplate.FindAndReplace(
+                                 "<subject>", descriptionSubject),
+                             group,
+                             icon);
+
+  gd::String conditionDescriptionTemplate = _("Compare <subject>.");
+  auto& condition =
+      AddScopedCondition(name,
+                         fullname,
+                         conditionDescriptionTemplate.FindAndReplace(
+                             "<subject>", descriptionSubject),
+                         sentenceName,
+                         group,
+                         icon,
+                         icon);
+
+  gd::String actionDescriptionTemplate = _("Change <subject>.");
+  auto& action = AddScopedAction(
+      "Set" + name,
+      fullname,
+      actionDescriptionTemplate.FindAndReplace("<subject>", descriptionSubject),
+      sentenceName,
+      group,
+      icon,
+      icon);
+
+  return MultipleInstructionMetadata::WithExpressionAndConditionAndAction(
+      expression, condition, action);
+}
+
 ObjectMetadata& ObjectMetadata::SetFullName(const gd::String& fullname_) {
 #if defined(GD_IDE_ONLY)
   fullname = fullname_;

Core/GDCore/Extensions/Metadata/ObjectMetadata.h

@@ -5,19 +5,22 @@
  */
 #ifndef OBJECTMETADATA_H
 #define OBJECTMETADATA_H
+#include <functional>
 #include <map>
 #include <memory>
-#include <functional>
+
 #include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
 #include "GDCore/Project/Object.h"
 #include "GDCore/String.h"
 namespace gd {
 class InstructionMetadata;
+class MultipleInstructionMetadata;
 class ExpressionMetadata;
 }  // namespace gd
 
-typedef std::function<std::unique_ptr<gd::Object>(gd::String name)> CreateFunPtr;
+typedef std::function<std::unique_ptr<gd::Object>(gd::String name)>
+    CreateFunPtr;
 
 namespace gd {
 
@@ -31,7 +34,7 @@ class GD_CORE_API ObjectMetadata {
  public:
   /**
    * \brief Construct an object metadata, using a "blueprint" object that will
-   * be copied when a new object is asked.
+   * be copied when a new object is requested.
    */
   ObjectMetadata(const gd::String& extensionNamespace_,
                  const gd::String& name_,
@@ -55,7 +58,8 @@ class GD_CORE_API ObjectMetadata {
 
   /**
    * \brief Declare a new condition as being part of the extension.
-   * \note This method does nothing when used for GD C++ runtime.
+   * \deprecated Prefer using `AddScopedCondition`, to properly namespace the
+   * condition.
    */
   gd::InstructionMetadata& AddCondition(const gd::String& name_,
                                         const gd::String& fullname_,
@@ -67,7 +71,8 @@ class GD_CORE_API ObjectMetadata {
 
   /**
    * \brief Declare a new action as being part of the extension.
-   * \note This method does nothing when used for GD C++ runtime.
+   * \deprecated Prefer using `AddScopedAction`, to properly namespace the
+   * action.
    */
   gd::InstructionMetadata& AddAction(const gd::String& name_,
                                      const gd::String& fullname_,
@@ -76,9 +81,31 @@ class GD_CORE_API ObjectMetadata {
                                      const gd::String& group_,
                                      const gd::String& icon_,
                                      const gd::String& smallicon_);
+
+  /**
+   * Declare a new condition as being part of the object.
+   */
+  gd::InstructionMetadata& AddScopedCondition(const gd::String& name_,
+                                              const gd::String& fullname_,
+                                              const gd::String& description_,
+                                              const gd::String& sentence_,
+                                              const gd::String& group_,
+                                              const gd::String& icon_,
+                                              const gd::String& smallicon_);
+
+  /**
+   * Declare a new action as being part of the object.
+   */
+  gd::InstructionMetadata& AddScopedAction(const gd::String& name_,
+                                           const gd::String& fullname_,
+                                           const gd::String& description_,
+                                           const gd::String& sentence_,
+                                           const gd::String& group_,
+                                           const gd::String& icon_,
+                                           const gd::String& smallicon_);
+
   /**
    * \brief Declare a new expression as being part of the extension.
-   * \note This method does nothing when used for GD C++ runtime.
    */
   gd::ExpressionMetadata& AddExpression(const gd::String& name_,
                                         const gd::String& fullname_,
@@ -87,7 +114,6 @@ class GD_CORE_API ObjectMetadata {
                                         const gd::String& smallicon_);
   /**
    * \brief Declare a new string expression as being part of the extension.
-   * \note This method does nothing when used for GD C++ runtime.
    */
   gd::ExpressionMetadata& AddStrExpression(const gd::String& name_,
                                            const gd::String& fullname_,
@@ -95,30 +121,62 @@ class GD_CORE_API ObjectMetadata {
                                            const gd::String& group_,
                                            const gd::String& smallicon_);
 
+  /**
+   * \brief Declare a new expression and condition as being part of the
+   * object.
+   * \note It's recommended to use this function to avoid declaring twice a
+   * similar expression/condition.
+   */
+  gd::MultipleInstructionMetadata AddExpressionAndCondition(
+      const gd::String& type,
+      const gd::String& name,
+      const gd::String& fullname,
+      const gd::String& description,
+      const gd::String& sentenceName,
+      const gd::String& group,
+      const gd::String& icon);
+
+  /**
+   * \brief Declare a new expression, condition and action as being part of the
+   * object.
+   * \note The action name is prefixed by "Set" (and the namespace, as the
+   * condition).
+   * \note It's recommended to use this function to avoid declaring
+   * 3 times a similar expression/condition/action.
+   */
+  gd::MultipleInstructionMetadata AddExpressionAndConditionAndAction(
+      const gd::String& type,
+      const gd::String& name,
+      const gd::String& fullname,
+      const gd::String& description,
+      const gd::String& sentenceName,
+      const gd::String& group,
+      const gd::String& icon);
+
   /**
    * \brief Set the name shown to the user.
-   * \note This method does nothing when used for GD C++ runtime.
    */
   ObjectMetadata& SetFullName(const gd::String& fullname_);
 
   /**
    * \brief Set the description shown to the user.
-   * \note This method does nothing when used for GD C++ runtime.
    */
   ObjectMetadata& SetDescription(const gd::String& description_);
 
   /**
-   * Get the help path of the object, relative to the documentation root.
+   * \brief Get the help path of the object, relative to the GDevelop
+   * documentation root.
    */
-  const gd::String &GetHelpPath() const { return helpPath; }
+  const gd::String& GetHelpPath() const { return helpPath; }
 
   /**
-   * Set the help path of the object, relative to the documentation root.
-   * 
+   * \brief Set the help path of the object, relative to the GDevelop
+   * documentation root.
+   *
    * The object instructions will have this help path set by
    * default, unless you call SetHelpPath on them.
    */
-  ObjectMetadata &SetHelpPath(const gd::String &path) {
+  ObjectMetadata& SetHelpPath(const gd::String& path) {
     helpPath = path;
     return *this;
   }
@@ -166,7 +224,7 @@ class GD_CORE_API ObjectMetadata {
   gd::String name;
   gd::String helpPath;
 #if defined(GD_IDE_ONLY)
-  gd::String helpUrl; ///< Deprecated. Use helpPath instead.
+  gd::String helpUrl;  ///< Deprecated. Use helpPath instead.
   gd::String fullname;
   gd::String description;
   gd::String iconFilename;

Core/GDCore/Extensions/Metadata/ParameterMetadata.cpp

@@ -0,0 +1,38 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#include "ParameterMetadata.h"
+
+#include "GDCore/CommonTools.h"
+#include "GDCore/Serialization/SerializerElement.h"
+
+namespace gd {
+
+ParameterMetadata::ParameterMetadata() : optional(false), codeOnly(false) {}
+
+void ParameterMetadata::SerializeTo(SerializerElement& element) const {
+  element.SetAttribute("type", type);
+  element.SetAttribute("supplementaryInformation", supplementaryInformation);
+  element.SetAttribute("optional", optional);
+  element.SetAttribute("description", description);
+  element.SetAttribute("longDescription", longDescription);
+  element.SetAttribute("codeOnly", codeOnly);
+  element.SetAttribute("defaultValue", defaultValue);
+  element.SetAttribute("name", name);
+}
+
+void ParameterMetadata::UnserializeFrom(const SerializerElement& element) {
+  type = element.GetStringAttribute("type");
+  supplementaryInformation =
+      element.GetStringAttribute("supplementaryInformation");
+  optional = element.GetBoolAttribute("optional");
+  description = element.GetStringAttribute("description");
+  longDescription = element.GetStringAttribute("longDescription");
+  codeOnly = element.GetBoolAttribute("codeOnly");
+  defaultValue = element.GetStringAttribute("defaultValue");
+  name = element.GetStringAttribute("name");
+}
+
+}  // namespace gd

Core/GDCore/Extensions/Metadata/ParameterMetadata.h

@@ -0,0 +1,235 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+
+#ifndef PARAMETER_METADATA_H
+#define PARAMETER_METADATA_H
+#if defined(GD_IDE_ONLY)
+#include <map>
+#include <memory>
+#include "GDCore/String.h"
+namespace gd {
+class Project;
+class Layout;
+class EventsCodeGenerator;
+class EventsCodeGenerationContext;
+class SerializerElement;
+}  // namespace gd
+
+namespace gd {
+
+/**
+ * \brief Describe a parameter of an instruction (action, condition) or of an
+ * expression: type, user-friendly description, etc...
+ *
+ * \ingroup Events
+ */
+class GD_CORE_API ParameterMetadata {
+ public:
+  ParameterMetadata();
+  virtual ~ParameterMetadata(){};
+
+  /**
+   * \brief Return the type of the parameter.
+   * \see gd::ParameterMetadata::IsObject
+   */
+  const gd::String &GetType() const { return type; }
+
+  /**
+   * \brief Set the type of the parameter.
+   */
+  ParameterMetadata &SetType(const gd::String &type_) {
+    type = type_;
+    return *this;
+  }
+
+  /**
+   * \brief Return the name of the parameter.
+   *
+   * Name is optional, and won't be filled for most parameters of extensions.
+   * It is useful when generating a function from events, where parameters must
+   * be named.
+   */
+  const gd::String &GetName() const { return name; }
+
+  /**
+   * \brief Set the name of the parameter.
+   *
+   * Name is optional, and won't be filled for most parameters of extensions.
+   * It is useful when generating a function from events, where parameters must
+   * be named.
+   */
+  ParameterMetadata &SetName(const gd::String &name_) {
+    name = name_;
+    return *this;
+  }
+
+  /**
+   * \brief Return an optional additional information, used for some parameters
+   * with special type (for example, it can contains the type of object accepted
+   * by the parameter).
+   */
+  const gd::String &GetExtraInfo() const { return supplementaryInformation; }
+
+  /**
+   * \brief Set an optional additional information, used for some parameters
+   * with special type (for example, it can contains the type of object accepted
+   * by the parameter).
+   */
+  ParameterMetadata &SetExtraInfo(const gd::String &supplementaryInformation_) {
+    supplementaryInformation = supplementaryInformation_;
+    return *this;
+  }
+
+  /**
+   * \brief Return true if the parameter is optional.
+   */
+  bool IsOptional() const { return optional; }
+
+  /**
+   * \brief Set if the parameter is optional.
+   */
+  ParameterMetadata &SetOptional(bool optional_ = true) {
+    optional = optional_;
+    return *this;
+  }
+
+  /**
+   * \brief Return the description of the parameter
+   */
+  const gd::String &GetDescription() const { return description; }
+
+  /**
+   * \brief Set the description of the parameter.
+   */
+  ParameterMetadata &SetDescription(const gd::String &description_) {
+    description = description_;
+    return *this;
+  }
+
+  /**
+   * \brief Return true if the parameter is only meant to be completed during
+   * compilation and must not be displayed to the user.
+   */
+  bool IsCodeOnly() const { return codeOnly; }
+
+  /**
+   * \brief Set if the parameter is only meant to be completed during
+   * compilation and must not be displayed to the user.
+   */
+  ParameterMetadata &SetCodeOnly(bool codeOnly_ = true) {
+    codeOnly = codeOnly_;
+    return *this;
+  }
+
+  /**
+   * \brief Get the default value for the parameter.
+   */
+  const gd::String &GetDefaultValue() const { return defaultValue; }
+
+  /**
+   * \brief Set the default value, if the parameter is optional.
+   */
+  ParameterMetadata &SetDefaultValue(const gd::String &defaultValue_) {
+    defaultValue = defaultValue_;
+    return *this;
+  }
+
+  /**
+   * \brief Get the user friendly, long description for the parameter.
+   */
+  const gd::String &GetLongDescription() const { return longDescription; }
+
+  /**
+   * \brief Set the user friendly, long description for the parameter.
+   */
+  ParameterMetadata &SetLongDescription(const gd::String &longDescription_) {
+    longDescription = longDescription_;
+    return *this;
+  }
+
+  /**
+   * \brief Return true if the type of the parameter is "object", "objectPtr" or
+   * "objectList".
+   *
+   * \see gd::ParameterMetadata::GetType
+   */
+  static bool IsObject(const gd::String &parameterType) {
+    return parameterType == "object" || parameterType == "objectPtr" ||
+           parameterType == "objectList" ||
+           parameterType == "objectListWithoutPicking";
+  }
+
+  /**
+   * \brief Return true if the type of the parameter is "behavior".
+   *
+   * \see gd::ParameterMetadata::GetType
+   */
+  static bool IsBehavior(const gd::String &parameterType) {
+    return parameterType == "behavior";
+  }
+
+  /**
+   * \brief Return true if the type of the parameter is an expression of the
+   * given type.
+   * \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 IsExpression(const gd::String &type,
+                           const gd::String &parameterType) {
+    if (type == "number") {
+      return parameterType == "expression" || parameterType == "camera" ||
+             parameterType == "forceMultiplier";
+    } else if (type == "string") {
+      return parameterType == "string" || parameterType == "layer" ||
+             parameterType == "color" || parameterType == "file" ||
+             parameterType == "joyaxis" ||
+             parameterType == "stringWithSelector" ||
+             parameterType == "sceneName" ||
+             parameterType == "objectPointName" ||
+             parameterType == "objectAnimationName";
+    } else if (type == "variable") {
+      return parameterType == "objectvar" || parameterType == "globalvar" ||
+             parameterType == "scenevar";
+    }
+    return false;
+  }
+
+  /** \name Serialization
+   */
+  ///@{
+  /**
+   * \brief Serialize the ParameterMetadata to the specified element
+   */
+  void SerializeTo(gd::SerializerElement &element) const;
+
+  /**
+   * \brief Load the ParameterMetadata from the specified element
+   */
+  void UnserializeFrom(const gd::SerializerElement &element);
+  ///@}
+
+  // TODO: Deprecated public fields. Any direct usage should be moved to
+  // getter/setter.
+  gd::String type;                      ///< Parameter type
+  gd::String supplementaryInformation;  ///< Used if needed
+  bool optional;                        ///< True if the parameter is optional
+
+  gd::String description;  ///< Description shown in editor
+  bool codeOnly;  ///< True if parameter is relative to code generation only,
+                  ///< i.e. must not be shown in editor
+ private:
+  gd::String longDescription;  ///< Long description shown in the editor.
+  gd::String defaultValue;     ///< Used as a default value in editor or if an
+                               ///< optional parameter is empty.
+  gd::String name;             ///< The name of the parameter to be used in code
+                               ///< generation. Optional.
+};
+
+}  // namespace gd
+
+#endif
+#endif  // PARAMETER_METADATA_H

Core/GDCore/Extensions/Platform.cpp

@@ -14,7 +14,7 @@ using namespace std;
 
 namespace gd {
 
-Platform::Platform(): enableExtensionLoadingLogs(true) {}
+Platform::Platform(): enableExtensionLoadingLogs(false) {}
 
 Platform::~Platform() {}
 
@@ -100,26 +100,6 @@ std::unique_ptr<gd::Object> Platform::CreateObject(
   return std::unique_ptr<gd::Object>(std::move(object));
 }
 
-gd::Behavior* Platform::GetBehavior(const gd::String& behaviorType) const {
-  for (std::size_t i = 0; i < extensionsLoaded.size(); ++i) {
-    gd::Behavior* behavior = extensionsLoaded[i]->GetBehavior(behaviorType);
-    if (behavior) return behavior;
-  }
-
-  return nullptr;
-}
-
-gd::BehaviorsSharedData* Platform::GetBehaviorSharedDatas(
-    const gd::String& behaviorType) const {
-  for (std::size_t i = 0; i < extensionsLoaded.size(); ++i) {
-    gd::BehaviorsSharedData* behaviorSharedData =
-        extensionsLoaded[i]->GetBehaviorSharedDatas(behaviorType);
-    if (behaviorSharedData) return behaviorSharedData;
-  }
-
-  return nullptr;
-}
-
 #if defined(GD_IDE_ONLY)
 std::shared_ptr<gd::BaseEvent> Platform::CreateEvent(
     const gd::String& eventType) const {

Core/GDCore/Extensions/Platform.h

@@ -126,7 +126,8 @@ class GD_CORE_API Platform {
   ///@}
 
   /** \name Factory method
-   * Member functions used to create the platforms objects
+   * Member functions used to create the platform objects.
+   * TODO: This could be moved to gd::MetadataProvider.
    */
   ///@{
 
@@ -136,18 +137,6 @@ class GD_CORE_API Platform {
   std::unique_ptr<gd::Object> CreateObject(gd::String type,
                                            const gd::String& name) const;
 
-  /**
-   * \brief Get the class handling the behavior with the given type, or
-   * `nullptr` if no behavior with the given type is found.
-   */
-  gd::Behavior* GetBehavior(const gd::String& type) const;
-
-  /**
-   * \brief Get the class handling the behavior shared data with the given type,
-   * or `nullptr` if no behavior with the given type is found.
-   */
-  gd::BehaviorsSharedData* GetBehaviorSharedDatas(const gd::String& type) const;
-
 #if defined(GD_IDE_ONLY)
   /**
    * \brief Create an event of given type
@@ -165,11 +154,13 @@ class GD_CORE_API Platform {
   /**
    * \brief Called when the IDE is about to shut down: Take this opportunity for
    * erasing for example any temporary file.
+   * @deprecated This should be removed.
    */
   virtual void OnIDEClosed(){};
 
   /**
    * \brief Called when the IDE is initialized and ready to be used.
+   * @deprecated This should be removed.
    */
   virtual void OnIDEInitialized(){};
 

Core/GDCore/Extensions/PlatformExtension.cpp

@@ -13,11 +13,13 @@
 #include "GDCore/Extensions/Metadata/EventMetadata.h"
 #include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
+#include "GDCore/Extensions/Metadata/MultipleInstructionMetadata.h"
 #include "GDCore/Extensions/Metadata/ObjectMetadata.h"
 #include "GDCore/Extensions/Platform.h"
 #include "GDCore/IDE/PlatformManager.h"
 #include "GDCore/Project/Behavior.h"
 #include "GDCore/Project/BehaviorsSharedData.h"
+#include "GDCore/Tools/Localization.h"
 
 namespace gd {
 
@@ -28,8 +30,6 @@ std::map<gd::String, gd::InstructionMetadata>
     PlatformExtension::badActionsMetadata;
 std::map<gd::String, gd::ExpressionMetadata>
     PlatformExtension::badExpressionsMetadata;
-std::map<gd::String, gd::ExpressionMetadata>
-    PlatformExtension::badStrExpressionsMetadata;
 #endif
 
 gd::InstructionMetadata& PlatformExtension::AddCondition(
@@ -41,8 +41,7 @@ gd::InstructionMetadata& PlatformExtension::AddCondition(
     const gd::String& icon,
     const gd::String& smallicon) {
 #if defined(GD_IDE_ONLY)
-  gd::String nameWithNamespace =
-      GetNameSpace().empty() ? name : GetNameSpace() + name;
+  gd::String nameWithNamespace = GetNameSpace() + name;
   conditionsInfos[nameWithNamespace] = InstructionMetadata(GetNameSpace(),
                                                            nameWithNamespace,
                                                            fullname,
@@ -65,8 +64,7 @@ gd::InstructionMetadata& PlatformExtension::AddAction(
     const gd::String& icon,
     const gd::String& smallicon) {
 #if defined(GD_IDE_ONLY)
-  gd::String nameWithNamespace =
-      GetNameSpace().empty() ? name : GetNameSpace() + name;
+  gd::String nameWithNamespace = GetNameSpace() + name;
   actionsInfos[nameWithNamespace] = InstructionMetadata(GetNameSpace(),
                                                         nameWithNamespace,
                                                         fullname,
@@ -87,9 +85,9 @@ gd::ExpressionMetadata& PlatformExtension::AddExpression(
     const gd::String& group,
     const gd::String& smallicon) {
 #if defined(GD_IDE_ONLY)
-  gd::String nameWithNamespace =
-      GetNameSpace().empty() ? name : GetNameSpace() + name;
-  expressionsInfos[nameWithNamespace] = ExpressionMetadata(GetNameSpace(),
+  gd::String nameWithNamespace = GetNameSpace() + name;
+  expressionsInfos[nameWithNamespace] = ExpressionMetadata("number",
+                                                           GetNameSpace(),
                                                            nameWithNamespace,
                                                            fullname,
                                                            description,
@@ -107,9 +105,9 @@ gd::ExpressionMetadata& PlatformExtension::AddStrExpression(
     const gd::String& group,
     const gd::String& smallicon) {
 #if defined(GD_IDE_ONLY)
-  gd::String nameWithNamespace =
-      GetNameSpace().empty() ? name : GetNameSpace() + name;
-  strExpressionsInfos[nameWithNamespace] = ExpressionMetadata(GetNameSpace(),
+  gd::String nameWithNamespace = GetNameSpace() + name;
+  strExpressionsInfos[nameWithNamespace] = ExpressionMetadata("string",
+                                                              GetNameSpace(),
                                                               nameWithNamespace,
                                                               fullname,
                                                               description,
@@ -120,6 +118,94 @@ gd::ExpressionMetadata& PlatformExtension::AddStrExpression(
 #endif
 }
 
+gd::MultipleInstructionMetadata PlatformExtension::AddExpressionAndCondition(
+    const gd::String& type,
+    const gd::String& name,
+    const gd::String& fullname,
+    const gd::String& descriptionSubject,
+    const gd::String& sentenceName,
+    const gd::String& group,
+    const gd::String& icon) {
+  gd::String expressionDescriptionTemplate = _("Return <subject>.");
+  auto& expression =
+      type == "number"
+          ? AddExpression(name,
+                          fullname,
+                          expressionDescriptionTemplate.FindAndReplace(
+                              "<subject>", descriptionSubject),
+                          group,
+                          icon)
+          : AddStrExpression(name,
+                             fullname,
+                             expressionDescriptionTemplate.FindAndReplace(
+                                 "<subject>", descriptionSubject),
+                             group,
+                             icon);
+
+  gd::String conditionDescriptionTemplate = _("Compare <subject>.");
+  auto& condition = AddCondition(name,
+                                 fullname,
+                                 conditionDescriptionTemplate.FindAndReplace(
+                                     "<subject>", descriptionSubject),
+                                 sentenceName,
+                                 group,
+                                 icon,
+                                 icon);
+
+  return MultipleInstructionMetadata::WithExpressionAndCondition(expression,
+                                                                 condition);
+}
+
+gd::MultipleInstructionMetadata
+PlatformExtension::AddExpressionAndConditionAndAction(
+    const gd::String& type,
+    const gd::String& name,
+    const gd::String& fullname,
+    const gd::String& descriptionSubject,
+    const gd::String& sentenceName,
+    const gd::String& group,
+    const gd::String& icon) {
+  gd::String expressionDescriptionTemplate = _("Return <subject>.");
+  auto& expression =
+      type == "number"
+          ? AddExpression(name,
+                          fullname,
+                          expressionDescriptionTemplate.FindAndReplace(
+                              "<subject>", descriptionSubject),
+                          group,
+                          icon)
+          : AddStrExpression(name,
+                             fullname,
+                             expressionDescriptionTemplate.FindAndReplace(
+                                 "<subject>", descriptionSubject),
+                             group,
+                             icon);
+
+  gd::String conditionDescriptionTemplate = _("Compare <subject>.");
+  auto& condition = AddCondition(name,
+                                 fullname,
+                                 conditionDescriptionTemplate.FindAndReplace(
+                                     "<subject>", descriptionSubject),
+                                 sentenceName,
+                                 group,
+                                 icon,
+                                 icon);
+
+  // TODO: update the checks
+  gd::String actionDescriptionTemplate = _("Change <subject>.");
+  auto& action = AddAction(
+      "Set" + name,
+      fullname,
+      actionDescriptionTemplate.FindAndReplace("<subject>", descriptionSubject),
+      sentenceName,
+      group,
+      icon,
+      icon);
+
+  return MultipleInstructionMetadata::WithExpressionAndConditionAndAction(
+      expression, condition, action);
+}
+
 #if defined(GD_IDE_ONLY)
 gd::DependencyMetadata& PlatformExtension::AddDependency() {
   extensionDependenciesMetadata.push_back(DependencyMetadata());
@@ -133,8 +219,7 @@ gd::ObjectMetadata& PlatformExtension::AddObject(
     const gd::String& description,
     const gd::String& icon24x24,
     std::shared_ptr<gd::Object> instance) {
-  gd::String nameWithNamespace =
-      GetNameSpace().empty() ? name : GetNameSpace() + name;
+  gd::String nameWithNamespace = GetNameSpace() + name;
   objectsInfos[nameWithNamespace] = ObjectMetadata(GetNameSpace(),
                                                    nameWithNamespace,
                                                    fullname,
@@ -156,8 +241,7 @@ gd::BehaviorMetadata& PlatformExtension::AddBehavior(
     const gd::String& className,
     std::shared_ptr<gd::Behavior> instance,
     std::shared_ptr<gd::BehaviorsSharedData> sharedDatasInstance) {
-  gd::String nameWithNamespace =
-      GetNameSpace().empty() ? name : GetNameSpace() + name;
+  gd::String nameWithNamespace = GetNameSpace() + name;
   behaviorsInfo[nameWithNamespace] = BehaviorMetadata(GetNameSpace(),
                                                       nameWithNamespace,
                                                       fullname,
@@ -173,8 +257,7 @@ gd::BehaviorMetadata& PlatformExtension::AddBehavior(
 }
 
 gd::EffectMetadata& PlatformExtension::AddEffect(const gd::String& name) {
-  gd::String nameWithNamespace =
-      GetNameSpace().empty() ? name : GetNameSpace() + name;
+  gd::String nameWithNamespace = GetNameSpace() + name;
   effectsMetadata[nameWithNamespace] = EffectMetadata(nameWithNamespace);
   return effectsMetadata[nameWithNamespace];
 }
@@ -187,8 +270,7 @@ gd::EventMetadata& PlatformExtension::AddEvent(
     const gd::String& smallicon_,
     std::shared_ptr<gd::BaseEvent> instance_) {
 #if defined(GD_IDE_ONLY)
-  gd::String nameWithNamespace =
-      GetNameSpace().empty() ? name_ : GetNameSpace() + name_;
+  gd::String nameWithNamespace = GetNameSpace() + name_;
   eventsInfos[nameWithNamespace] = gd::EventMetadata(nameWithNamespace,
                                                      fullname_,
                                                      description_,
@@ -272,6 +354,73 @@ std::vector<gd::String> PlatformExtension::GetBehaviorsTypes() const {
 }
 
 #if defined(GD_IDE_ONLY)
+
+gd::InstructionMetadata& PlatformExtension::AddDuplicatedAction(
+    const gd::String& newActionName, const gd::String& copiedActionName) {
+  gd::String newNameWithNamespace = GetNameSpace() + newActionName;
+  gd::String copiedNameWithNamespace = GetNameSpace() + copiedActionName;
+
+  auto copiedAction = actionsInfos.find(copiedNameWithNamespace);
+  if (copiedAction == actionsInfos.end()) {
+    gd::LogWarning("Could not find an action with name " +
+                   copiedNameWithNamespace + " to copy.");
+  } else {
+    actionsInfos[newNameWithNamespace] = copiedAction->second;
+  }
+
+  return actionsInfos[newNameWithNamespace];
+}
+
+gd::InstructionMetadata& PlatformExtension::AddDuplicatedCondition(
+    const gd::String& newConditionName, const gd::String& copiedConditionName) {
+  gd::String newNameWithNamespace = GetNameSpace() + newConditionName;
+  gd::String copiedNameWithNamespace = GetNameSpace() + copiedConditionName;
+
+  auto copiedCondition = conditionsInfos.find(copiedNameWithNamespace);
+  if (copiedCondition == conditionsInfos.end()) {
+    gd::LogWarning("Could not find a condition with name " +
+                   copiedNameWithNamespace + " to copy.");
+  } else {
+    conditionsInfos[newNameWithNamespace] = copiedCondition->second;
+  }
+
+  return conditionsInfos[newNameWithNamespace];
+}
+
+gd::ExpressionMetadata& PlatformExtension::AddDuplicatedExpression(
+    const gd::String& newExpressionName,
+    const gd::String& copiedExpressionName) {
+  gd::String newNameWithNamespace = GetNameSpace() + newExpressionName;
+  gd::String copiedNameWithNamespace = GetNameSpace() + copiedExpressionName;
+
+  auto copiedExpression = expressionsInfos.find(copiedNameWithNamespace);
+  if (copiedExpression == expressionsInfos.end()) {
+    gd::LogWarning("Could not find an expression with name " +
+                   copiedNameWithNamespace + " to copy.");
+  } else {
+    expressionsInfos[newNameWithNamespace] = copiedExpression->second;
+  }
+
+  return expressionsInfos[newNameWithNamespace];
+}
+
+gd::ExpressionMetadata& PlatformExtension::AddDuplicatedStrExpression(
+    const gd::String& newExpressionName,
+    const gd::String& copiedExpressionName) {
+  gd::String newNameWithNamespace = GetNameSpace() + newExpressionName;
+  gd::String copiedNameWithNamespace = GetNameSpace() + copiedExpressionName;
+
+  auto copiedExpression = strExpressionsInfos.find(copiedNameWithNamespace);
+  if (copiedExpression == strExpressionsInfos.end()) {
+    gd::LogWarning("Could not find a string expression with name " +
+                   copiedNameWithNamespace + " to copy.");
+  } else {
+    strExpressionsInfos[newNameWithNamespace] = copiedExpression->second;
+  }
+
+  return strExpressionsInfos[newNameWithNamespace];
+}
+
 std::map<gd::String, gd::InstructionMetadata>&
 PlatformExtension::GetAllActions() {
   return actionsInfos;
@@ -328,7 +477,7 @@ PlatformExtension::GetAllStrExpressionsForObject(gd::String objectType) {
   if (objectsInfos.find(objectType) != objectsInfos.end())
     return objectsInfos.find(objectType)->second.strExpressionsInfos;
 
-  return badStrExpressionsMetadata;
+  return badExpressionsMetadata;
 }
 
 std::map<gd::String, gd::InstructionMetadata>&
@@ -360,10 +509,10 @@ PlatformExtension::GetAllStrExpressionsForBehavior(gd::String autoType) {
   if (behaviorsInfo.find(autoType) != behaviorsInfo.end())
     return behaviorsInfo.find(autoType)->second.strExpressionsInfos;
 
-  return badStrExpressionsMetadata;
+  return badExpressionsMetadata;
 }
 
-gd::BaseEventSPtr PlatformExtension::CreateEvent(gd::String eventType) const {
+gd::BaseEventSPtr PlatformExtension::CreateEvent(const gd::String& eventType) const {
   if (eventsInfos.find(eventType) != eventsInfos.end()) {
     if (eventsInfos.find(eventType)->second.instance ==
         std::shared_ptr<BaseEvent>()) {
@@ -382,14 +531,14 @@ gd::BaseEventSPtr PlatformExtension::CreateEvent(gd::String eventType) const {
 #endif
 
 CreateFunPtr PlatformExtension::GetObjectCreationFunctionPtr(
-    gd::String objectType) const {
+    const gd::String& objectType) const {
   if (objectsInfos.find(objectType) != objectsInfos.end())
     return objectsInfos.find(objectType)->second.createFunPtr;
 
   return NULL;
 }
 
-gd::Behavior* PlatformExtension::GetBehavior(gd::String type) const {
+gd::Behavior* PlatformExtension::GetBehavior(const gd::String& type) const {
   if (behaviorsInfo.find(type) != behaviorsInfo.end())
     return &behaviorsInfo.find(type)->second.Get();
 
@@ -397,7 +546,7 @@ gd::Behavior* PlatformExtension::GetBehavior(gd::String type) const {
 }
 
 gd::BehaviorsSharedData* PlatformExtension::GetBehaviorSharedDatas(
-    gd::String type) const {
+    const gd::String& type) const {
   if (behaviorsInfo.find(type) != behaviorsInfo.end() &&
       behaviorsInfo.find(type)->second.GetSharedDataInstance())
     return behaviorsInfo.find(type)->second.GetSharedDataInstance();

Core/GDCore/Extensions/PlatformExtension.h

@@ -24,6 +24,7 @@
 namespace gd {
 class Instruction;
 class InstructionMetadata;
+class MultipleInstructionMetadata;
 class ExpressionMetadata;
 class ObjectMetadata;
 class BehaviorMetadata;
@@ -82,6 +83,11 @@ class GD_CORE_API PlatformExtension {
   PlatformExtension();
   virtual ~PlatformExtension();
 
+  /** \name Extension setup
+   * Common setup for all extensions
+   */
+  ///@{
+
   /**
    * \brief Must be called to declare the main information about the extension.
    */
@@ -100,8 +106,8 @@ class GD_CORE_API PlatformExtension {
   }
 
   /**
-   * \brief Set the path to the help, relative to the wiki/documentation root.
-   * For example, "/all-features/collisions" for
+   * \brief Set the path to the help, relative to the GDevelop documentation
+   * root. For example, "/all-features/collisions" for
    * "http://wiki.compilgames.net/doku.php/gdevelop5/all-features/collisions".
    *
    * The instructions, objects and behaviors will have this help path set by
@@ -118,9 +124,15 @@ class GD_CORE_API PlatformExtension {
    */
   void MarkAsDeprecated() { deprecated = true; }
 
+  ///@}
+
+  /** \name Features declaration
+   * Declare features provided by the extension
+   */
+  ///@{
+
   /**
    * \brief Declare a new condition as being part of the extension.
-   * \note This method does nothing when used for GD C++ runtime.
    */
   gd::InstructionMetadata& AddCondition(const gd::String& name_,
                                         const gd::String& fullname_,
@@ -132,7 +144,6 @@ class GD_CORE_API PlatformExtension {
 
   /**
    * \brief Declare a new action as being part of the extension.
-   * \note This method does nothing when used for GD C++ runtime.
    */
   gd::InstructionMetadata& AddAction(const gd::String& name_,
                                      const gd::String& fullname_,
@@ -143,7 +154,6 @@ class GD_CORE_API PlatformExtension {
                                      const gd::String& smallicon_);
   /**
    * \brief Declare a new expression as being part of the extension.
-   * \note This method does nothing when used for GD C++ runtime.
    */
   gd::ExpressionMetadata& AddExpression(const gd::String& name_,
                                         const gd::String& fullname_,
@@ -151,8 +161,7 @@ class GD_CORE_API PlatformExtension {
                                         const gd::String& group_,
                                         const gd::String& smallicon_);
   /**
-   * \brief Declare a new String expression as being part of the extension.
-   * \note This method does nothing when used for GD C++ runtime.
+   * \brief Declare a new string expression as being part of the extension.
    */
   gd::ExpressionMetadata& AddStrExpression(const gd::String& name_,
                                            const gd::String& fullname_,
@@ -160,55 +169,79 @@ class GD_CORE_API PlatformExtension {
                                            const gd::String& group_,
                                            const gd::String& smallicon_);
 
+  /**
+   * \brief Declare a new expression and condition as being part of the
+   * extension.
+   * \note It's recommended to use this function to avoid declaring twice a
+   * similar expression/condition.
+   */
+  gd::MultipleInstructionMetadata AddExpressionAndCondition(
+      const gd::String& type,
+      const gd::String& name,
+      const gd::String& fullname,
+      const gd::String& description,
+      const gd::String& sentenceName,
+      const gd::String& group,
+      const gd::String& icon);
+
+  /**
+   * \brief Declare a new expression, condition and action as being part of the
+   * extension.
+   * \note The action name is prefixed by "Set" (and the namespace, as the
+   * condition and the expression).
+   * \note It's recommended to use this function to avoid declaring 3 times a
+   * similar expression/condition/action.
+   */
+  gd::MultipleInstructionMetadata AddExpressionAndConditionAndAction(
+      const gd::String& type,
+      const gd::String& name,
+      const gd::String& fullname,
+      const gd::String& description,
+      const gd::String& sentenceName,
+      const gd::String& group,
+      const gd::String& icon);
+
   gd::DependencyMetadata& AddDependency();
 
   /**
    * \brief Declare a new object as being part of the extension.
-   * \note This method does nothing when used for GD C++ runtime.
    * \tparam T the declared class inherited from *gd::Object*
-   * \param name The name of the object
-   * \param fullname The user friendly name of the object
-   * \param description The user friendly description of the object
-   * \param icon The 24x24 icon of the object:
-   res/icons_[SkinName]/[iconName]24.png will be first tried,
-   * and then if it does not exists, the full entered name will be tried.
+   * \param name The name of the object.
+   * \param fullname The user friendly name of the object.
+   * \param description The user friendly description of the object.
+   * \param icon The icon of the object.
    */
   template <class T>
   gd::ObjectMetadata& AddObject(const gd::String& name_,
                                 const gd::String& fullname_,
                                 const gd::String& description_,
-                                const gd::String& icon24x24_);
+                                const gd::String& icon_);
 
   /**
    * \brief Declare a new object as being part of the extension.
-   * \note This method does nothing when used for GD C++ runtime.
    * \param name The name of the object
    * \param fullname The user friendly name of the object
    * \param description The user friendly description of the object
-   * \param icon The 24x24 icon of the object:
-   res/icons_[SkinName]/[iconName]24.png will be first tried,
-   * and then if it does not exists, the full entered name will be tried.
+   * \param icon The icon of the object.
    * \param instance The "blueprint" object to be copied when a new object is
    asked for.
    */
   gd::ObjectMetadata& AddObject(const gd::String& name_,
                                 const gd::String& fullname_,
                                 const gd::String& description_,
-                                const gd::String& icon24x24_,
+                                const gd::String& icon_,
                                 std::shared_ptr<gd::Object> instance);
 
   /**
    * \brief Declare a new behavior as being part of the extension.
-   * \note This method does nothing when used for GD C++ runtime.
    *
    * \param name The name of the behavior
    * \param fullname The user friendly name of the behavior
    * \param description The user friendly description of the behavior
-   * \param icon The 24x24 icon of the behavior:
-   * res/icons_[SkinName]/[iconName]24.png will be first tried, and then if it
-   * does not exists, it is assumed that the icon name is the filename that must
-   * be used to open the icon. \param instance An instance of the behavior that
-   * will be used to create the behavior \param sharedDatasInstance Optional
+   * \param icon The icon of the behavior.
+   * \param instance An instance of the behavior that
+   * will be used to create the behavior
+   * \param sharedDatasInstance Optional
    * instance of the data shared by the behaviors having the same name.
    */
   gd::BehaviorMetadata& AddBehavior(
@@ -217,7 +250,7 @@ class GD_CORE_API PlatformExtension {
       const gd::String& defaultName_,
       const gd::String& description_,
       const gd::String& group_,
-      const gd::String& icon24x24_,
+      const gd::String& icon_,
       const gd::String& className_,
       std::shared_ptr<gd::Behavior> instance,
       std::shared_ptr<gd::BehaviorsSharedData> sharedDatasInstance);
@@ -230,7 +263,6 @@ class GD_CORE_API PlatformExtension {
 
   /**
    * \brief Declare a new event as being part of the extension.
-   * \note This method does nothing when used for GD C++ runtime.
    */
   gd::EventMetadata& AddEvent(const gd::String& name_,
                               const gd::String& fullname_,
@@ -240,6 +272,43 @@ class GD_CORE_API PlatformExtension {
                               std::shared_ptr<gd::BaseEvent> instance);
 
 #if defined(GD_IDE_ONLY)
+  /**
+   * \brief Create a new action which is the duplicate of the specified one.
+   *
+   * Useful for handling a deprecated action that is just a "copy" of the new
+   * one.
+   */
+  gd::InstructionMetadata& AddDuplicatedAction(
+      const gd::String& newActionName, const gd::String& copiedActionName);
+  /**
+   * \brief Create a new condition which is the duplicate of the specified one.
+   *
+   * Useful for handling a deprecated condition that is just a "copy" of the new
+   * one.
+   */
+  gd::InstructionMetadata& AddDuplicatedCondition(
+      const gd::String& newConditionName,
+      const gd::String& copiedConditionName);
+  /**
+   * \brief Create a new expression which is the duplicate of the specified one.
+   *
+   * Useful for handling a deprecated expression that is just a "copy" of the
+   * new one.
+   */
+  gd::ExpressionMetadata& AddDuplicatedExpression(
+      const gd::String& newExpressionName,
+      const gd::String& copiedExpressionName);
+  /**
+   * \brief Create a new string expression which is the duplicate of the
+   * specified one.
+   *
+   * Useful for handling a deprecated string expression that is just a "copy" of
+   * the new one.
+   */
+  gd::ExpressionMetadata& AddDuplicatedStrExpression(
+      const gd::String& newExpressionName,
+      const gd::String& copiedExpressionName);
+
   /**
    * \brief Adds a property to the extension.
    */
@@ -248,6 +317,18 @@ class GD_CORE_API PlatformExtension {
   };
 #endif
 
+  /**
+   * \brief Delete all instructions having no function name or custom code
+   * generator.
+   */
+  void StripUnimplementedInstructionsAndExpressions();
+  ///@}
+
+  /** \name Extension accessors
+   * Accessors to read the information and content of the extension.
+   */
+  ///@{
+
   /**
    * \brief Return the name extension user friendly name.
    */
@@ -275,7 +356,7 @@ class GD_CORE_API PlatformExtension {
 
   /**
    * \brief Return the help path of extension, relative to the
-   * wiki/documentation root.
+   * GDevelop documentation root.
    */
   const gd::String& GetHelpPath() const { return helpPath; }
 
@@ -319,7 +400,7 @@ class GD_CORE_API PlatformExtension {
    * \brief Return a function to create the object if the type is handled by the
    * extension
    */
-  CreateFunPtr GetObjectCreationFunctionPtr(gd::String objectType) const;
+  CreateFunPtr GetObjectCreationFunctionPtr(const gd::String& objectType) const;
 
   /**
    * \brief Return a vector containing all the effect types provided by the
@@ -332,13 +413,13 @@ class GD_CORE_API PlatformExtension {
    *
    * Return an empty pointer if \a eventType is not provided by the extension.
    */
-  std::shared_ptr<gd::BaseEvent> CreateEvent(gd::String eventType) const;
+  std::shared_ptr<gd::BaseEvent> CreateEvent(const gd::String& eventType) const;
   /**
    * \brief Get the gd::Behavior handling the given behavior type.
    *
    * Return nullptr if \a behaviorType is not provided by the extension.
    */
-  gd::Behavior* GetBehavior(gd::String behaviorType) const;
+  gd::Behavior* GetBehavior(const gd::String& behaviorType) const;
 
   /**
    * \brief Get the gd::BehaviorsSharedData handling the given behavior shared
@@ -347,7 +428,7 @@ class GD_CORE_API PlatformExtension {
    * Return nullptr if \a behaviorType is not provided by the extension.
    */
   gd::BehaviorsSharedData* GetBehaviorSharedDatas(
-      gd::String behaviorType) const;
+      const gd::String& behaviorType) const;
 
   /**
    * \brief Return a reference to the ObjectMetadata object associated to \a
@@ -373,9 +454,8 @@ class GD_CORE_API PlatformExtension {
 
 #if defined(GD_IDE_ONLY)
   /**
-   * \brief Return a reference to a map containing the names of the actions (in
-   * the first members) and the metadata associated with (in the second
-   * members).
+   * \brief Return a reference to a map containing the names of the actions
+   * (as keys) and the metadata associated with (as values).
    */
   std::map<gd::String, gd::InstructionMetadata>& GetAllActions();
 
@@ -450,8 +530,8 @@ class GD_CORE_API PlatformExtension {
       gd::String autoType);
 
   /**
-   * Called ( e.g. during compilation ) so as to inventory resources used by
-   * conditions and update their filename
+   * Called to inventory resources used by conditions
+   * (and possibly do work on them, like renaming, etc...)
    *
    * \see gd::PlatformExtension::ExposeActionsResources
    */
@@ -459,8 +539,8 @@ class GD_CORE_API PlatformExtension {
                                          gd::ArbitraryResourceWorker& worker){};
 
   /**
-   * Called ( e.g. during compilation ) so as to inventory resources used by
-   * actions and update their filename
+   * Called to inventory resources used by actions
+   * (and possibly do work on them, like renaming, etc...)
    *
    * \see ArbitraryResourceWorker
    */
@@ -468,17 +548,14 @@ class GD_CORE_API PlatformExtension {
                                       gd::ArbitraryResourceWorker& worker){};
 
   /**
-   * \brief Delete all instructions having no functions name or custom code
-   * generator.
-   */
-  void StripUnimplementedInstructionsAndExpressions();
-
-  /**
-   * \brief Get all the properties of the extension
+   * \brief Get all the properties of the extension. Properties
+   * are shown in the game properties in the editor, and are exported in the
+   * project data.
    */
   std::map<gd::String, gd::PropertyDescriptor>& GetAllProperties() {
     return extensionPropertiesMetadata;
   }
+  ///@}
 #endif
 
   /**
@@ -495,8 +572,8 @@ class GD_CORE_API PlatformExtension {
 
  private:
   /**
-   * Set the namespace ( the String each actions/conditions/expressions start
-   * with )
+   * Set the namespace (the string all actions/conditions/expressions start
+   * with).
    */
   void SetNameSpace(gd::String nameSpace_);
 
@@ -541,9 +618,6 @@ class GD_CORE_API PlatformExtension {
   static std::map<gd::String, gd::ExpressionMetadata>
       badExpressionsMetadata;  ///< Used when an expression is not found in the
                                ///< extension
-  static std::map<gd::String, gd::ExpressionMetadata>
-      badStrExpressionsMetadata;  ///< Used when an expression is not found in
-                                  ///< the extension
 #endif
 };
 

Core/GDCore/IDE/DependenciesAnalyzer.cpp

@@ -15,25 +15,18 @@
 #include "GDCore/Project/Project.h"
 #include "GDCore/Project/SourceFile.h"
 
-DependenciesAnalyzer::DependenciesAnalyzer(gd::Project& project_,
-                                           gd::Layout& layout_)
+DependenciesAnalyzer::DependenciesAnalyzer(const gd::Project& project_,
+                                           const gd::Layout& layout_)
     : project(project_), layout(&layout_), externalEvents(NULL) {
   parentScenes.push_back(layout->GetName());
 }
 
-DependenciesAnalyzer::DependenciesAnalyzer(gd::Project& project_,
-                                           gd::ExternalEvents& externalEvents_)
+DependenciesAnalyzer::DependenciesAnalyzer(const gd::Project& project_,
+                                           const gd::ExternalEvents& externalEvents_)
     : project(project_), layout(NULL), externalEvents(&externalEvents_) {
   parentExternalEvents.push_back(externalEvents->GetName());
 }
 
-DependenciesAnalyzer::DependenciesAnalyzer(const DependenciesAnalyzer& parent)
-    : parentScenes(parent.parentScenes),
-      parentExternalEvents(parent.parentExternalEvents),
-      project(parent.project),
-      layout(NULL),
-      externalEvents(NULL) {}
-
 bool DependenciesAnalyzer::Analyze() {
   if (layout)
     return Analyze(layout->GetEvents(), true);
@@ -47,9 +40,9 @@ bool DependenciesAnalyzer::Analyze() {
 
 DependenciesAnalyzer::~DependenciesAnalyzer() {}
 
-bool DependenciesAnalyzer::Analyze(gd::EventsList& events, bool isOnTopLevel) {
+bool DependenciesAnalyzer::Analyze(const gd::EventsList& events, bool isOnTopLevel) {
   for (unsigned int i = 0; i < events.size(); ++i) {
-    gd::LinkEvent* linkEvent = dynamic_cast<gd::LinkEvent*>(&events[i]);
+    const gd::LinkEvent* linkEvent = dynamic_cast<const gd::LinkEvent*>(&events[i]);
     if (linkEvent) {
       DependenciesAnalyzer analyzer(*this);
 
@@ -113,7 +106,7 @@ bool DependenciesAnalyzer::Analyze(gd::EventsList& events, bool isOnTopLevel) {
     sourceFilesDependencies.insert(dependencies.begin(), dependencies.end());
 
     const gd::String& associatedSourceFile =
-        events[i].GetAssociatedGDManagedSourceFile(project);
+        events[i].GetAssociatedGDManagedSourceFile(const_cast<gd::Project&>(project));
     if (!associatedSourceFile.empty())
       sourceFilesDependencies.insert(associatedSourceFile);
 

Core/GDCore/IDE/DependenciesAnalyzer.h

@@ -35,7 +35,7 @@ class GD_CORE_API DependenciesAnalyzer {
   /**
    * \brief Constructor for analyzing the dependencies of a layout
    */
-  DependenciesAnalyzer(gd::Project& project_, gd::Layout& layout_);
+  DependenciesAnalyzer(const gd::Project& project_, const gd::Layout& layout_);
 
   /**
    * \brief Constructor for analyzing the dependencies of external events.
@@ -45,8 +45,8 @@ class GD_CORE_API DependenciesAnalyzer {
    * external events can be compiled separatly and called by a scene. \see
    * DependenciesAnalyzer::ExternalEventsCanBeCompiledForAScene
    */
-  DependenciesAnalyzer(gd::Project& project_,
-                       gd::ExternalEvents& externalEvents);
+  DependenciesAnalyzer(const gd::Project& project_,
+                       const gd::ExternalEvents& externalEvents);
 
   virtual ~DependenciesAnalyzer();
 
@@ -124,13 +124,7 @@ class GD_CORE_API DependenciesAnalyzer {
    * (they have no parents). \return false if a circular dependency exists, true
    * otherwise.
    */
-  bool Analyze(gd::EventsList& events, bool isOnTopLevel);
-
-  /**
-   * \brief Internal constructor used when analyzing a linked layout/external
-   * events.
-   */
-  DependenciesAnalyzer(const DependenciesAnalyzer& parent);
+  bool Analyze(const gd::EventsList& events, bool isOnTopLevel);
 
   void AddParentScene(gd::String parentScene) {
     parentScenes.push_back(parentScene);
@@ -161,9 +155,9 @@ class GD_CORE_API DependenciesAnalyzer {
   std::vector<gd::String>
       parentExternalEvents;  ///< Used to check for circular dependencies.
 
-  gd::Project& project;
-  gd::Layout* layout;
-  gd::ExternalEvents* externalEvents;
+  const gd::Project& project;
+  const gd::Layout* layout;
+  const gd::ExternalEvents* externalEvents;
 };
 
 #endif  // DEPENDENCIESANALYZER_H

Core/GDCore/IDE/Dialogs/LayoutEditorCanvas/EditorSettings.cpp

@@ -0,0 +1,25 @@
+/*
+ * 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/CommonTools.h"
+#include "GDCore/Serialization/SerializerElement.h"
+#include "EditorSettings.h"
+
+namespace gd {
+
+EditorSettings::EditorSettings() {}
+
+void EditorSettings::SerializeTo(SerializerElement& element) const {
+  element = content;
+}
+
+void EditorSettings::UnserializeFrom(
+    const SerializerElement& element) {
+  content = element;
+}
+
+}  // namespace gd
+#endif

Core/GDCore/IDE/Dialogs/LayoutEditorCanvas/EditorSettings.h

@@ -0,0 +1,46 @@
+/*
+ * 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)
+#ifndef SCENECANVASSETTINGS_H
+#define SCENECANVASSETTINGS_H
+#include "GDCore/String.h"
+#include "GDCore/Serialization/SerializerElement.h"
+
+namespace gd {
+
+/**
+ * \brief Container for arbitrary serialized data to be used by the editor
+ * to store settings.
+ *
+ * \see Scene
+ */
+class GD_CORE_API EditorSettings {
+ public:
+  EditorSettings();
+  virtual ~EditorSettings(){};
+
+  /** \name Serialization
+   */
+  ///@{
+  /**
+   * \brief Serialize the settings.
+   */
+  void SerializeTo(SerializerElement& element) const;
+
+  /**
+   * \brief Unserialize the settings.
+   */
+  void UnserializeFrom(const SerializerElement& element);
+  ///@}
+
+private:
+  gd::SerializerElement content; ///< Arbitrary content, depending on the editor.
+};
+
+}  // namespace gd
+
+#endif  // SCENECANVASSETTINGS_H
+#endif

Core/GDCore/IDE/Dialogs/LayoutEditorCanvas/LayoutEditorCanvasOptions.cpp

@@ -1,56 +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 "LayoutEditorCanvasOptions.h"
-#include "GDCore/CommonTools.h"
-#include "GDCore/Serialization/SerializerElement.h"
-
-namespace gd {
-
-LayoutEditorCanvasOptions::LayoutEditorCanvasOptions()
-    : grid(false),
-      snap(true),
-      gridWidth(32),
-      gridHeight(32),
-      gridOffsetX(0),
-      gridOffsetY(0),
-      gridR(158),
-      gridG(180),
-      gridB(255),
-      zoomFactor(1),
-      windowMask(false) {}
-
-void LayoutEditorCanvasOptions::SerializeTo(SerializerElement& element) const {
-  element.SetAttribute("grid", grid);
-  element.SetAttribute("snap", snap);
-  element.SetAttribute("gridWidth", gridWidth);
-  element.SetAttribute("gridHeight", gridHeight);
-  element.SetAttribute("gridOffsetX", gridOffsetX);
-  element.SetAttribute("gridOffsetY", gridOffsetY);
-  element.SetAttribute("gridR", gridR);
-  element.SetAttribute("gridG", gridG);
-  element.SetAttribute("gridB", gridB);
-  element.SetAttribute("zoomFactor", zoomFactor);
-  element.SetAttribute("windowMask", windowMask);
-}
-
-void LayoutEditorCanvasOptions::UnserializeFrom(
-    const SerializerElement& element) {
-  grid = element.GetBoolAttribute("grid");
-  snap = element.GetBoolAttribute("snap");
-  windowMask = element.GetBoolAttribute("windowMask");
-  gridWidth = element.GetIntAttribute("gridWidth", 32);
-  gridHeight = element.GetIntAttribute("gridHeight", 32);
-  gridOffsetX = element.GetIntAttribute("gridOffsetX", 0);
-  gridOffsetY = element.GetIntAttribute("gridOffsetY", 0);
-  gridR = element.GetIntAttribute("gridR", 158);
-  gridG = element.GetIntAttribute("gridG", 180);
-  gridB = element.GetIntAttribute("gridB", 255);
-  zoomFactor = element.GetDoubleAttribute("zoomFactor", 1.0);
-}
-
-}  // namespace gd
-#endif

Core/GDCore/IDE/Dialogs/LayoutEditorCanvas/LayoutEditorCanvasOptions.h

@@ -1,57 +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)
-#ifndef SCENECANVASSETTINGS_H
-#define SCENECANVASSETTINGS_H
-#include "GDCore/String.h"
-namespace gd {
-class SerializerElement;
-}
-
-namespace gd {
-
-/**
- * \brief Tool class used to store settings of a LayoutEditorCanvas.
- *
- * \see Scene
- */
-class GD_CORE_API LayoutEditorCanvasOptions {
- public:
-  LayoutEditorCanvasOptions();
-  virtual ~LayoutEditorCanvasOptions(){};
-
-  /** \name Serialization
-   */
-  ///@{
-
-  /**
-   * \brief Serialize instances container.
-   */
-  void SerializeTo(SerializerElement& element) const;
-
-  /**
-   * \brief Unserialize the instances container.
-   */
-  void UnserializeFrom(const SerializerElement& element);
-  ///@}
-
-  bool grid;         ///< True if grid activated in editor
-  bool snap;         ///< True if snap to grid activated in editor
-  int gridWidth;     ///< Grid width in editor
-  int gridHeight;    ///< Grid height in editor
-  int gridOffsetX;   ///< Grid X offset
-  int gridOffsetY;   ///< Grid Y offset
-  int gridR;         ///< Grid red color in editor
-  int gridG;         ///< Grid green color in editor
-  int gridB;         ///< Grid blue color in editor
-  float zoomFactor;  ///< Stores the zoom factor
-  bool windowMask;   ///< True if window mask displayed in editor
-};
-
-}  // namespace gd
-
-#endif  // SCENECANVASSETTINGS_H
-#endif

Core/GDCore/IDE/Events/EventsVariablesFinder.cpp

@@ -17,6 +17,8 @@
 #include "GDCore/Project/Layout.h"
 #include "GDCore/Project/Object.h"
 #include "GDCore/Project/Project.h"
+#include "GDCore/Project/ExternalEvents.h"
+#include "GDCore/IDE/DependenciesAnalyzer.h"
 
 using namespace std;
 
@@ -95,11 +97,11 @@ std::set<gd::String> EventsVariablesFinder::FindAllGlobalVariables(
 
   for (std::size_t i = 0; i < project.GetLayoutsCount(); ++i) {
     std::set<gd::String> results2 =
-        FindArgumentsInEvents(platform,
-                              project,
-                              project.GetLayout(i),
-                              project.GetLayout(i).GetEvents(),
-                              "globalvar");
+        FindArgumentsInEventsAndDependencies(
+            platform,
+            project,
+            project.GetLayout(i),
+            "globalvar");
     results.insert(results2.begin(), results2.end());
   }
 
@@ -112,8 +114,8 @@ std::set<gd::String> EventsVariablesFinder::FindAllLayoutVariables(
     const gd::Layout& layout) {
   std::set<gd::String> results;
 
-  std::set<gd::String> results2 = FindArgumentsInEvents(
-      platform, project, layout, layout.GetEvents(), "scenevar");
+  std::set<gd::String> results2 = FindArgumentsInEventsAndDependencies(
+      platform, project, layout, "scenevar");
   results.insert(results2.begin(), results2.end());
 
   return results;
@@ -126,12 +128,12 @@ std::set<gd::String> EventsVariablesFinder::FindAllObjectVariables(
     const gd::Object& object) {
   std::set<gd::String> results;
 
-  std::set<gd::String> results2 = FindArgumentsInEvents(platform,
-                                                        project,
-                                                        layout,
-                                                        layout.GetEvents(),
-                                                        "objectvar",
-                                                        object.GetName());
+  std::set<gd::String> results2 = FindArgumentsInEventsAndDependencies(
+      platform,
+      project,
+      layout,
+      "objectvar",
+      object.GetName());
   results.insert(results2.begin(), results2.end());
 
   return results;
@@ -203,6 +205,38 @@ std::set<gd::String> EventsVariablesFinder::FindArgumentsInInstructions(
   return results;
 }
 
+std::set<gd::String> EventsVariablesFinder::FindArgumentsInEventsAndDependencies(
+    const gd::Platform& platform,
+    const gd::Project& project,
+    const gd::Layout& layout,
+    const gd::String& parameterType,
+    const gd::String& objectName) {
+  std::set<gd::String> results;
+
+  std::set<gd::String> results2 = FindArgumentsInEvents(
+      platform, project, layout, layout.GetEvents(), parameterType, objectName);
+  results.insert(results2.begin(), results2.end());
+
+  DependenciesAnalyzer dependenciesAnalyzer = DependenciesAnalyzer(project, layout);
+  dependenciesAnalyzer.Analyze();
+  for (const gd::String& externalEventName : dependenciesAnalyzer.GetExternalEventsDependencies()) {
+    const gd::ExternalEvents& externalEvents = project.GetExternalEvents(externalEventName);
+
+    std::set<gd::String> results3 = FindArgumentsInEvents(
+        platform, project, layout, externalEvents.GetEvents(), parameterType, objectName);
+    results.insert(results3.begin(), results3.end());
+  }
+  for (const gd::String& sceneName : dependenciesAnalyzer.GetScenesDependencies()) {
+    const gd::Layout& dependencyLayout = project.GetLayout(sceneName);
+
+    std::set<gd::String> results3 = FindArgumentsInEvents(
+        platform, project, dependencyLayout, dependencyLayout.GetEvents(), parameterType, objectName);
+    results.insert(results3.begin(), results3.end());
+  }
+
+  return results;
+}
+
 std::set<gd::String> EventsVariablesFinder::FindArgumentsInEvents(
     const gd::Platform& platform,
     const gd::Project& project,

Core/GDCore/IDE/Events/EventsVariablesFinder.h

@@ -24,11 +24,17 @@ namespace gd {
  * global or object variables.
  *
  * \todo Refactor this class using ArbitraryEventsWorker
+ * \todo Rework this class to return the shapes (maybe even types?) of the
+ * variables (in particular for structures and arrays), so we can use this
+ * for better autocompletions in the variables dialogs in the IDE.
  *
  * \ingroup IDE
  */
 class EventsVariablesFinder {
  public:
+  EventsVariablesFinder(){};
+  virtual ~EventsVariablesFinder(){};
+
   /**
    * Construct a list containing the name of all global variables used in the
    * project.
@@ -94,10 +100,34 @@ class EventsVariablesFinder {
 
   /**
    * Construct a list of the value of the arguments for parameters of type @
-   * parameterType
+   * parameterType. It searchs in events dependencies.
    *
+   * \param platform The platform of the project
    * \param project The project used
-   * \param project The layout used
+   * \param layout The layout used
+   * \param events The events to be analyzed
+   * \param parameterType The parameters type to be analyzed
+   * \param objectName If not empty, parameters will be taken into account
+   * only if the last object parameter is filled with
+   * this value.
+   *
+   * \return A std::set filled with the values used for all parameters of the
+   * specified type
+   */
+  static std::set<gd::String> FindArgumentsInEventsAndDependencies(
+      const gd::Platform& platform,
+      const gd::Project& project,
+      const gd::Layout& layout,
+      const gd::String& parameterType,
+      const gd::String& objectName = "");
+
+  /**
+   * Construct a list of the value of the arguments for parameters of type @
+   * parameterType. It doesn't search in events dependencies.
+   *
+   * \param platform The platform of the project
+   * \param project The project used
+   * \param layout The layout used
    * \param events The events to be analyzed
    * \param parameterType The parameters type to be analyzed
    * \param objectName If not empty, parameters will be taken into account
@@ -113,10 +143,7 @@ class EventsVariablesFinder {
       const gd::Layout& layout,
       const gd::EventsList& events,
       const gd::String& parameterType,
-      const gd::String& objectName = "");
-
-  EventsVariablesFinder(){};
-  virtual ~EventsVariablesFinder(){};
+      const gd::String& objectName);
 };
 
 }  // namespace gd

Core/GDCore/IDE/Events/ExpressionCompletionFinder.cpp

@@ -0,0 +1,31 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-present Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#include "ExpressionCompletionFinder.h"
+
+namespace gd {
+
+const gd::ParameterMetadata
+    ExpressionCompletionDescription::badParameterMetadata;
+
+/**
+ * \brief Turn an ExpressionCompletionDescription to a string.
+ */
+std::ostream& operator<<(std::ostream& os,
+                         ExpressionCompletionDescription const& value) {
+  os << "{ " << value.GetCompletionKind() << ", " << value.GetType() << ", "
+     << value.GetPrefix() << ", " << value.GetObjectName() << ", "
+     << value.GetBehaviorName() << ", "
+     << (value.IsExact() ? "exact" : "non-exact") << ", "
+     << (value.IsLastParameter() ? "last parameter" : "not last parameter")
+     << ", "
+     << (value.HasParameterMetadata()
+             ? gd::String::From(&value.GetParameterMetadata())
+             : "no parameter metadata")
+     << " }";
+  return os;
+}
+
+}  // namespace gd

Core/GDCore/IDE/Events/ExpressionCompletionFinder.h

@@ -8,10 +8,14 @@
 
 #include <memory>
 #include <vector>
+
 #include "GDCore/Events/Parsers/ExpressionParser2Node.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
+#include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
 #include "GDCore/IDE/Events/ExpressionNodeLocationFinder.h"
+#include "GDCore/Events/Parsers/ExpressionParser2.h"
+
 namespace gd {
 class Expression;
 class ObjectsContainer;
@@ -33,19 +37,21 @@ struct ExpressionCompletionDescription {
   /**
    * The different kind of completions that can be described.
    */
-  enum CompletionKind {
-    Object,
-    Behavior,
-    Expression,
-    Variable,
-  };
+  enum CompletionKind { Object, Behavior, Expression, Variable, Text };
 
   /**
    * \brief Create a completion for an object with the given prefix
    */
-  static ExpressionCompletionDescription ForObject(const gd::String& type_,
-                                                   const gd::String& prefix_) {
-    return ExpressionCompletionDescription(Object, type_, prefix_);
+  static ExpressionCompletionDescription ForObject(
+      const gd::String& type_,
+      const gd::String& prefix_,
+      size_t replacementStartPosition_,
+      size_t replacementEndPosition_) {
+    return ExpressionCompletionDescription(Object,
+                                           type_,
+                                           prefix_,
+                                           replacementStartPosition_,
+                                           replacementEndPosition_);
   }
 
   /**
@@ -53,17 +59,58 @@ struct ExpressionCompletionDescription {
    * the specified object
    */
   static ExpressionCompletionDescription ForBehavior(
-      const gd::String& prefix_, const gd::String& objectName_) {
-    return ExpressionCompletionDescription(Behavior, "", prefix_, objectName_);
+      const gd::String& prefix_,
+      size_t replacementStartPosition_,
+      size_t replacementEndPosition_,
+      const gd::String& objectName_) {
+    return ExpressionCompletionDescription(Behavior,
+                                           "",
+                                           prefix_,
+                                           replacementStartPosition_,
+                                           replacementEndPosition_,
+                                           objectName_);
   }
 
   /**
    * \brief Create a completion for a variable with the given prefix
    */
   static ExpressionCompletionDescription ForVariable(
-      const gd::String& type_, const gd::String& prefix_) {
-    return ExpressionCompletionDescription(Variable, type_, prefix_);
+      const gd::String& type_,
+      const gd::String& prefix_,
+      size_t replacementStartPosition_,
+      size_t replacementEndPosition_,
+      const gd::String& objectName_ = "") {
+    return ExpressionCompletionDescription(Variable,
+                                           type_,
+                                           prefix_,
+                                           replacementStartPosition_,
+                                           replacementEndPosition_,
+                                           objectName_);
   }
+
+  /**
+   * \brief Create a completion for a text with the given prefix
+   */
+  static ExpressionCompletionDescription ForText(
+      const gd::String& type_,
+      const gd::ParameterMetadata& parameterMetadata_,
+      const gd::String& prefix_,
+      size_t replacementStartPosition_,
+      size_t replacementEndPosition_,
+      const bool isLastParameter_,
+      const gd::String& objectName_ = "") {
+    auto description =
+        ExpressionCompletionDescription(Text,
+                                        type_,
+                                        prefix_,
+                                        replacementStartPosition_,
+                                        replacementEndPosition_,
+                                        objectName_);
+    description.SetIsLastParameter(isLastParameter_);
+    description.SetParameterMetadata(parameterMetadata_);
+    return description;
+  }
+
   /**
    * \brief Create a completion for an expression (free, object or behavior
    * expression) with the given prefix
@@ -71,10 +118,17 @@ struct ExpressionCompletionDescription {
   static ExpressionCompletionDescription ForExpression(
       const gd::String& type_,
       const gd::String& prefix_,
+      size_t replacementStartPosition_,
+      size_t replacementEndPosition_,
       const gd::String& objectName_ = "",
       const gd::String& behaviorName_ = "") {
-    return ExpressionCompletionDescription(
-        Expression, type_, prefix_, objectName_, behaviorName_);
+    return ExpressionCompletionDescription(Expression,
+                                           type_,
+                                           prefix_,
+                                           replacementStartPosition_,
+                                           replacementEndPosition_,
+                                           objectName_,
+                                           behaviorName_);
   }
 
   /** Check if two description of completions are equal */
@@ -131,6 +185,56 @@ struct ExpressionCompletionDescription {
    */
   bool IsExact() const { return isExact; }
 
+  /**
+   * \brief Return the first character index of the autocompleted part.
+   */
+  size_t GetReplacementStartPosition() const {
+    return replacementStartPosition;
+  }
+
+  /**
+   * \brief Return the first character index after the autocompleted part.
+   */
+  size_t GetReplacementEndPosition() const { return replacementEndPosition; }
+
+  /**
+   * \brief Set if the expression is the last child of a function call.
+   */
+  ExpressionCompletionDescription& SetIsLastParameter(bool isLastParameter_) {
+    isLastParameter = isLastParameter_;
+    return *this;
+  }
+
+  /**
+   * \brief Check if the expression is the last child of a function call.
+   */
+  bool IsLastParameter() const { return isLastParameter; }
+
+  /**
+   * \brief Set the parameter metadata, in the case the completion is about
+   * a parameter of a function call.
+   */
+  ExpressionCompletionDescription& SetParameterMetadata(
+      const gd::ParameterMetadata& parameterMetadata_) {
+    parameterMetadata = &parameterMetadata_;
+    return *this;
+  }
+
+  /**
+   * \brief Check if the completion is about a parameter of a function call.
+   */
+  bool HasParameterMetadata() const {
+    return parameterMetadata != &badParameterMetadata;
+  }
+
+  /**
+   * \brief Return the parameter metadata, if the completion is about a
+   * parameter of a function call. Returns an empty metadata otherwise.
+   */
+  const gd::ParameterMetadata& GetParameterMetadata() const {
+    return *parameterMetadata;
+  }
+
   /** Default constructor, only to be used by Emscripten bindings. */
   ExpressionCompletionDescription() : completionKind(Object){};
 
@@ -138,34 +242,40 @@ struct ExpressionCompletionDescription {
   ExpressionCompletionDescription(CompletionKind completionKind_,
                                   const gd::String& type_,
                                   const gd::String& prefix_,
+                                  size_t replacementStartPosition_,
+                                  size_t replacementEndPosition_,
                                   const gd::String& objectName_ = "",
                                   const gd::String& behaviorName_ = "")
       : completionKind(completionKind_),
         type(type_),
         prefix(prefix_),
+        replacementStartPosition(replacementStartPosition_),
+        replacementEndPosition(replacementEndPosition_),
         objectName(objectName_),
         behaviorName(behaviorName_),
-        isExact(false) {}
+        isExact(false),
+        isLastParameter(false),
+        parameterMetadata(&badParameterMetadata) {}
 
   CompletionKind completionKind;
   gd::String type;
   gd::String prefix;
+  size_t replacementStartPosition;
+  size_t replacementEndPosition;
   gd::String objectName;
   gd::String behaviorName;
   bool isExact;
+  bool isLastParameter;
+  const gd::ParameterMetadata* parameterMetadata;
+
+  static const gd::ParameterMetadata badParameterMetadata;
 };
 
 /**
  * \brief Turn an ExpressionCompletionDescription to a string.
  */
 std::ostream& operator<<(std::ostream& os,
-                         ExpressionCompletionDescription const& value) {
-  os << "{ " << value.GetCompletionKind() << ", " << value.GetType() << ", "
-     << value.GetPrefix() << ", " << value.GetObjectName() << ", "
-     << value.GetBehaviorName() << ", "
-     << (value.IsExact() ? "exact" : "non-exact") << " }";
-  return os;
-}
+                         ExpressionCompletionDescription const& value);
 
 /**
  * \brief Returns the list of completion descriptions for an expression node.
@@ -182,16 +292,18 @@ class GD_CORE_API ExpressionCompletionFinder
   static std::vector<ExpressionCompletionDescription>
   GetCompletionDescriptionsFor(gd::ExpressionNode& node,
                                size_t searchedPosition) {
-    gd::ExpressionNode* nodeAtLocation =
-        gd::ExpressionNodeLocationFinder::GetNodeAtPosition(node,
-                                                            searchedPosition);
+    gd::ExpressionNodeLocationFinder finder(searchedPosition);
+    node.Visit(finder);
+    gd::ExpressionNode* nodeAtLocation = finder.GetNode();
 
     if (nodeAtLocation == nullptr) {
       std::vector<ExpressionCompletionDescription> emptyCompletions;
       return emptyCompletions;
     }
 
-    gd::ExpressionCompletionFinder autocompletionProvider(searchedPosition);
+    gd::ExpressionNode* maybeParentNodeAtLocation = finder.GetParentNode();
+    gd::ExpressionCompletionFinder autocompletionProvider(
+        searchedPosition, maybeParentNodeAtLocation);
     nodeAtLocation->Visit(autocompletionProvider);
     return autocompletionProvider.GetCompletionDescriptions();
   }
@@ -208,32 +320,92 @@ class GD_CORE_API ExpressionCompletionFinder
 
  protected:
   void OnVisitSubExpressionNode(SubExpressionNode& node) override {
-    completions.push_back(
-        ExpressionCompletionDescription::ForObject(node.type, ""));
-    completions.push_back(
-        ExpressionCompletionDescription::ForExpression(node.type, ""));
+    completions.push_back(ExpressionCompletionDescription::ForObject(
+        node.type, "", searchedPosition + 1, searchedPosition + 1));
+    completions.push_back(ExpressionCompletionDescription::ForExpression(
+        node.type, "", searchedPosition + 1, searchedPosition + 1));
   }
   void OnVisitOperatorNode(OperatorNode& node) override {
-    completions.push_back(
-        ExpressionCompletionDescription::ForObject(node.type, ""));
-    completions.push_back(
-        ExpressionCompletionDescription::ForExpression(node.type, ""));
+    completions.push_back(ExpressionCompletionDescription::ForObject(
+        node.type, "", searchedPosition + 1, searchedPosition + 1));
+    completions.push_back(ExpressionCompletionDescription::ForExpression(
+        node.type, "", searchedPosition + 1, searchedPosition + 1));
   }
   void OnVisitUnaryOperatorNode(UnaryOperatorNode& node) override {
-    completions.push_back(
-        ExpressionCompletionDescription::ForObject(node.type, ""));
-    completions.push_back(
-        ExpressionCompletionDescription::ForExpression(node.type, ""));
+    completions.push_back(ExpressionCompletionDescription::ForObject(
+        node.type, "", searchedPosition + 1, searchedPosition + 1));
+    completions.push_back(ExpressionCompletionDescription::ForExpression(
+        node.type, "", searchedPosition + 1, searchedPosition + 1));
   }
   void OnVisitNumberNode(NumberNode& node) override {
     // No completions
   }
+
   void OnVisitTextNode(TextNode& node) override {
-    // No completions
+    // Completions are searched in the case the text node is a parameter of a
+    // function call.
+    FunctionCallNode* functionCall =
+        dynamic_cast<FunctionCallNode*>(maybeParentNodeAtLocation);
+    if (functionCall != nullptr) {
+      int parameterIndex = -1;
+      for (int i = 0; i < functionCall->parameters.size(); i++) {
+        if (functionCall->parameters.at(i).get() == &node) {
+          parameterIndex = i;
+          break;
+        }
+      }
+      if (parameterIndex < 0) {
+        return;
+      }
+      // Search the parameter metadata index skipping invisible ones.
+      size_t visibleParameterIndex = 0;
+      size_t metadataParameterIndex = ExpressionParser2::WrittenParametersFirstIndex(
+          functionCall->objectName, functionCall->behaviorName);
+
+      const gd::ParameterMetadata* parameterMetadata = nullptr;
+      while (metadataParameterIndex <
+             functionCall->expressionMetadata.parameters.size()) {
+        if (!functionCall->expressionMetadata.parameters[metadataParameterIndex]
+                 .IsCodeOnly()) {
+          if (visibleParameterIndex == parameterIndex) {
+            parameterMetadata = &functionCall->expressionMetadata
+                                     .parameters[metadataParameterIndex];
+          }
+          visibleParameterIndex++;
+        }
+        metadataParameterIndex++;
+      }
+      const int visibleParameterCount = visibleParameterIndex;
+      if (parameterMetadata == nullptr) {
+        // There are too many parameters in the expression, this text node is
+        // not actually linked to a parameter expected by the function call.
+        return;
+      }
+
+      const gd::String& type = parameterMetadata->GetType();
+      if (type == "string") {
+        // No completions for an arbitrary string.
+        return;
+      }
+
+      bool isLastParameter = parameterIndex == visibleParameterCount - 1;
+      completions.push_back(ExpressionCompletionDescription::ForText(
+          type,
+          *parameterMetadata,
+          node.text,
+          node.location.GetStartPosition(),
+          node.location.GetEndPosition(),
+          isLastParameter,
+          functionCall->objectName));
+    }
   }
   void OnVisitVariableNode(VariableNode& node) override {
-    completions.push_back(
-        ExpressionCompletionDescription::ForVariable(node.type, node.name));
+    completions.push_back(ExpressionCompletionDescription::ForVariable(
+        node.type,
+        node.name,
+        node.location.GetStartPosition(),
+        node.location.GetEndPosition(),
+        node.objectName));
   }
   void OnVisitVariableAccessorNode(VariableAccessorNode& node) override {
     // No completions
@@ -246,13 +418,22 @@ class GD_CORE_API ExpressionCompletionFinder
     if (gd::ParameterMetadata::IsObject(node.type)) {
       // Only show completions of objects if an object is required
       completions.push_back(ExpressionCompletionDescription::ForObject(
-          node.type, node.identifierName));
+          node.type,
+          node.identifierName,
+          node.location.GetStartPosition(),
+          node.location.GetEndPosition()));
     } else {
       // Show completions for expressions and objects otherwise.
       completions.push_back(ExpressionCompletionDescription::ForObject(
-          node.type, node.identifierName));
+          node.type,
+          node.identifierName,
+          node.location.GetStartPosition(),
+          node.location.GetEndPosition()));
       completions.push_back(ExpressionCompletionDescription::ForExpression(
-          node.type, node.identifierName));
+          node.type,
+          node.identifierName,
+          node.location.GetStartPosition(),
+          node.location.GetEndPosition()));
     }
   }
   void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {
@@ -262,16 +443,24 @@ class GD_CORE_API ExpressionCompletionFinder
       // function name missing)
       if (IsCaretOn(node.objectNameLocation)) {
         completions.push_back(ExpressionCompletionDescription::ForObject(
-            node.type, node.objectName));
+            node.type,
+            node.objectName,
+            node.objectNameLocation.GetStartPosition(),
+            node.objectNameLocation.GetEndPosition()));
       } else if (IsCaretOn(node.objectNameDotLocation) ||
                  IsCaretOn(node.objectFunctionOrBehaviorNameLocation)) {
         completions.push_back(ExpressionCompletionDescription::ForBehavior(
-            node.objectFunctionOrBehaviorName, node.objectName));
+            node.objectFunctionOrBehaviorName,
+            node.objectFunctionOrBehaviorNameLocation.GetStartPosition(),
+            node.objectFunctionOrBehaviorNameLocation.GetEndPosition(),
+            node.objectName));
       } else if (IsCaretOn(node.behaviorNameNamespaceSeparatorLocation) ||
                  IsCaretOn(node.behaviorFunctionNameLocation)) {
         completions.push_back(ExpressionCompletionDescription::ForExpression(
             node.type,
             node.behaviorFunctionName,
+            node.behaviorFunctionNameLocation.GetStartPosition(),
+            node.behaviorFunctionNameLocation.GetEndPosition(),
             node.objectName,
             node.objectFunctionOrBehaviorName));
       }
@@ -279,13 +468,23 @@ class GD_CORE_API ExpressionCompletionFinder
       // Object function or behavior name
       if (IsCaretOn(node.objectNameLocation)) {
         completions.push_back(ExpressionCompletionDescription::ForObject(
-            node.type, node.objectName));
+            node.type,
+            node.objectName,
+            node.objectNameLocation.GetStartPosition(),
+            node.objectNameLocation.GetEndPosition()));
       } else if (IsCaretOn(node.objectNameDotLocation) ||
                  IsCaretOn(node.objectFunctionOrBehaviorNameLocation)) {
         completions.push_back(ExpressionCompletionDescription::ForBehavior(
-            node.objectFunctionOrBehaviorName, node.objectName));
+            node.objectFunctionOrBehaviorName,
+            node.objectFunctionOrBehaviorNameLocation.GetStartPosition(),
+            node.objectFunctionOrBehaviorNameLocation.GetEndPosition(),
+            node.objectName));
         completions.push_back(ExpressionCompletionDescription::ForExpression(
-            node.type, node.objectFunctionOrBehaviorName, node.objectName));
+            node.type,
+            node.objectFunctionOrBehaviorName,
+            node.objectFunctionOrBehaviorNameLocation.GetStartPosition(),
+            node.objectFunctionOrBehaviorNameLocation.GetEndPosition(),
+            node.objectName));
       }
     }
   }
@@ -297,24 +496,35 @@ class GD_CORE_API ExpressionCompletionFinder
       // Behavior function
       if (IsCaretOn(node.objectNameLocation)) {
         completions.push_back(ExpressionCompletionDescription::ForObject(
-            node.type, node.objectName));
+            node.type,
+            node.objectName,
+            node.objectNameLocation.GetStartPosition(),
+            node.objectNameLocation.GetEndPosition()));
       } else if (IsCaretOn(node.objectNameDotLocation) ||
                  IsCaretOn(node.behaviorNameLocation)) {
         completions.push_back(ExpressionCompletionDescription::ForBehavior(
-            node.behaviorName, node.objectName));
+            node.behaviorName,
+            node.behaviorNameLocation.GetStartPosition(),
+            node.behaviorNameLocation.GetEndPosition(),
+            node.objectName));
       } else {
-        completions.push_back(
-            ExpressionCompletionDescription::ForExpression(node.type,
-                                                           node.functionName,
-                                                           node.objectName,
-                                                           node.behaviorName)
-                .SetIsExact(isCaretOnParenthesis));
+        completions.push_back(ExpressionCompletionDescription::ForExpression(
+                                  node.type,
+                                  node.functionName,
+                                  node.functionNameLocation.GetStartPosition(),
+                                  node.functionNameLocation.GetEndPosition(),
+                                  node.objectName,
+                                  node.behaviorName)
+                                  .SetIsExact(isCaretOnParenthesis));
       }
     } else if (!node.objectName.empty()) {
       // Object function
       if (IsCaretOn(node.objectNameLocation)) {
         completions.push_back(ExpressionCompletionDescription::ForObject(
-            node.type, node.objectName));
+            node.type,
+            node.objectName,
+            node.objectNameLocation.GetStartPosition(),
+            node.objectNameLocation.GetEndPosition()));
       } else {
         // Add completions for behaviors, because we could imagine that the user
         // wants to move from an object function to a behavior function, and so
@@ -323,25 +533,41 @@ class GD_CORE_API ExpressionCompletionFinder
         // function).
         if (!isCaretOnParenthesis) {
           completions.push_back(ExpressionCompletionDescription::ForBehavior(
-              node.functionName, node.objectName));
+              node.functionName,
+              node.objectNameLocation.GetStartPosition(),
+              node.objectNameLocation.GetEndPosition(),
+              node.objectName));
         }
 
         completions.push_back(ExpressionCompletionDescription::ForExpression(
-                                  node.type, node.functionName, node.objectName)
+                                  node.type,
+                                  node.functionName,
+                                  node.functionNameLocation.GetStartPosition(),
+                                  node.functionNameLocation.GetEndPosition(),
+                                  node.objectName)
                                   .SetIsExact(isCaretOnParenthesis));
       }
     } else {
       // Free function
       completions.push_back(ExpressionCompletionDescription::ForExpression(
-                                node.type, node.functionName)
+                                node.type,
+                                node.functionName,
+                                node.functionNameLocation.GetStartPosition(),
+                                node.functionNameLocation.GetEndPosition())
                                 .SetIsExact(isCaretOnParenthesis));
     }
   }
   void OnVisitEmptyNode(EmptyNode& node) override {
-    completions.push_back(
-        ExpressionCompletionDescription::ForObject(node.type, node.text));
-    completions.push_back(
-        ExpressionCompletionDescription::ForExpression(node.type, node.text));
+    completions.push_back(ExpressionCompletionDescription::ForObject(
+        node.type,
+        node.text,
+        node.location.GetStartPosition(),
+        node.location.GetEndPosition()));
+    completions.push_back(ExpressionCompletionDescription::ForExpression(
+        node.type,
+        node.text,
+        node.location.GetStartPosition(),
+        node.location.GetEndPosition()));
   }
 
  private:
@@ -354,11 +580,14 @@ class GD_CORE_API ExpressionCompletionFinder
              (inclusive && searchedPosition <= location.GetEndPosition())));
   }
 
-  ExpressionCompletionFinder(size_t searchedPosition_)
-      : searchedPosition(searchedPosition_){};
+  ExpressionCompletionFinder(size_t searchedPosition_,
+                             gd::ExpressionNode* maybeParentNodeAtLocation_)
+      : searchedPosition(searchedPosition_),
+        maybeParentNodeAtLocation(maybeParentNodeAtLocation_){};
 
   std::vector<ExpressionCompletionDescription> completions;
   size_t searchedPosition;
+  gd::ExpressionNode* maybeParentNodeAtLocation;
 };
 
 }  // namespace gd

Core/GDCore/IDE/Events/ExpressionNodeLocationFinder.h

@@ -8,6 +8,7 @@
 
 #include <memory>
 #include <vector>
+
 #include "GDCore/Events/Parsers/ExpressionParser2Node.h"
 #include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
 namespace gd {
@@ -46,11 +47,30 @@ class GD_CORE_API ExpressionNodeLocationFinder
     return finder.GetNode();
   }
 
+  /**
+   * \brief Helper function to find the parent of the deepest node at the search
+   * position, if any.
+   *
+   * \warning Useful for tests. In other cases, prefer using `GetParentNode`.
+   */
+  static ExpressionNode* GetParentNodeAtPosition(gd::ExpressionNode& node,
+                                                 size_t searchedPosition) {
+    gd::ExpressionNodeLocationFinder finder(searchedPosition);
+    node.Visit(finder);
+    return finder.GetParentNode();
+  }
+
   /**
    * \brief Return the deepest node found at the search position, if any.
    */
   ExpressionNode* GetNode() { return foundNode; };
 
+  /**
+   * \brief Return the parent of deepest node found at the search position, if
+   * any.
+   */
+  ExpressionNode* GetParentNode() { return parentNode; };
+
  protected:
   void OnVisitSubExpressionNode(SubExpressionNode& node) override {
     CheckSearchPositionInNode(node);
@@ -110,6 +130,7 @@ class GD_CORE_API ExpressionNodeLocationFinder
     if (node.location.GetStartPosition() <= searchedPosition &&
         ((!inclusive && searchedPosition < node.location.GetEndPosition()) ||
          (inclusive && searchedPosition <= node.location.GetEndPosition()))) {
+      parentNode = foundNode;
       foundNode = &node;
       return true;
     }
@@ -119,6 +140,7 @@ class GD_CORE_API ExpressionNodeLocationFinder
 
   size_t searchedPosition;
   ExpressionNode* foundNode;
+  ExpressionNode* parentNode;
 };
 
 }  // namespace gd

Core/GDCore/IDE/Events/InstructionSentenceFormatter.cpp

@@ -24,24 +24,6 @@ namespace gd {
 
 InstructionSentenceFormatter *InstructionSentenceFormatter::_singleton = NULL;
 
-gd::String InstructionSentenceFormatter::Translate(
-    const gd::Instruction &instr, const gd::InstructionMetadata &metadata) {
-  gd::String out = metadata.GetSentence();
-  if (out.empty())
-    out = "   ";  // Prevent empty sentences that could trigger graphical
-                  // glitches.
-
-  // Replace _PARAMx_ placeholders by their values
-  for (std::size_t i = 0; i < metadata.parameters.size(); ++i) {
-    gd::String placeholder = "_PARAM" + gd::String::From(i) + "_";
-    gd::String parameter = instr.GetParameter(i).GetPlainString();
-    out = out.FindAndReplace(placeholder, parameter);
-  }
-
-  out = out.FindAndReplace("\n", " ");
-  return out;
-}
-
 std::vector<std::pair<gd::String, gd::TextFormatting> >
 InstructionSentenceFormatter::GetAsFormattedText(
     const Instruction &instr, const gd::InstructionMetadata &metadata) {
@@ -83,8 +65,7 @@ InstructionSentenceFormatter::GetAsFormattedText(
       }
 
       // Add the parameter
-      TextFormatting format =
-          GetFormattingFromType(metadata.parameters[firstParamIndex].type);
+      TextFormatting format;
       format.userData = firstParamIndex;
 
       gd::String text = instr.GetParameter(firstParamIndex).GetPlainString();
@@ -109,74 +90,6 @@ InstructionSentenceFormatter::GetAsFormattedText(
   return formattedStr;
 }
 
-TextFormatting InstructionSentenceFormatter::GetFormattingFromType(
-    const gd::String &type) {
-  if (gd::ParameterMetadata::IsObject(type)) return typesFormatting["object"];
-
-  return typesFormatting[type];
-}
-
-gd::String InstructionSentenceFormatter::LabelFromType(const gd::String &type) {
-  if (type.empty())
-    return "";
-  else if (type == "expression")
-    return _("Expression");
-  else if (gd::ParameterMetadata::IsObject(type))
-    return _("Object");
-  else if (type == "behavior")
-    return _("Behavior");
-  else if (type == "operator")
-    return _("Operator");
-  else if (type == "relationalOperator")
-    return _("Relational operator");
-  else if (type == "file")
-    return _("File");
-  else if (type == "key")
-    return _("Key");
-  else if (type == "mouse")
-    return _("Mouse button");
-  else if (type == "yesorno")
-    return _("Yes or no");
-  else if (type == "police")
-    return _("Font");
-  else if (type == "color")
-    return _("Color");
-  else if (type == "trueorfalse")
-    return _("True or False");
-  else if (type == "string")
-    return _("String");
-  else if (type == "musicfile")
-    return _("Music");
-  else if (type == "soundfile")
-    return _("Sound");
-  else if (type == "password")
-    return _("Password");
-  else if (type == "layer")
-    return _("Layer");
-  else if (type == "joyaxis")
-    return _("Joystick axis");
-  else if (type == "objectvar")
-    return _("Variable of the object");
-  else if (type == "scenevar")
-    return _("Scene variable");
-  else if (type == "globalvar")
-    return _("Global variable");
-
-  return _("Unknown");
-}
-
-void InstructionSentenceFormatter::LoadTypesFormattingFromConfig() {
-  // Load default configuration
-  typesFormatting.clear();
-  typesFormatting["expression"].SetColor(27, 143, 1).SetBold();
-  typesFormatting["object"].SetColor(182, 97, 10).SetBold();
-  typesFormatting["behavior"].SetColor(119, 119, 119).SetBold();
-  typesFormatting["operator"].SetColor(55, 131, 211).SetBold();
-  typesFormatting["objectvar"].SetColor(131, 55, 162).SetBold();
-  typesFormatting["scenevar"].SetColor(131, 55, 162).SetBold();
-  typesFormatting["globalvar"].SetColor(131, 55, 162).SetBold();
-}
-
 }  // namespace gd
 
 #endif

Core/GDCore/IDE/Events/InstructionSentenceFormatter.h

@@ -25,39 +25,12 @@ namespace gd {
  */
 class GD_CORE_API InstructionSentenceFormatter {
  public:
-  /**
-   * \brief Create a sentence from an instruction and its metadata.
-   *
-   * Sentence is provided in the gd::InstructionMetadata passed as parameter.
-   * Parameters placeholders ("_PARAMx_", x being the parameter index) are
-   * replaced by their values stored in the isntruction passed as parameter.
-   */
-  gd::String Translate(const gd::Instruction &instr,
-                       const gd::InstructionMetadata &metadata);
-
   /**
    * \brief Create a formatted sentence from an instruction and its metadata.
    */
   std::vector<std::pair<gd::String, gd::TextFormatting> > GetAsFormattedText(
       const gd::Instruction &instr, const gd::InstructionMetadata &metadata);
 
-  /**
-   * \brief Return the TextFormatting object associated to the \a type.
-   */
-  TextFormatting GetFormattingFromType(const gd::String &type);
-
-  /**
-   * \brief Return the label of a parameter type
-   */
-  gd::String LabelFromType(const gd::String &type);
-
-  /**
-   * \brief Load the configuration from the default configuration.
-   */
-  void LoadTypesFormattingFromConfig();
-
-  std::map<gd::String, gd::TextFormatting> typesFormatting;
-
   static InstructionSentenceFormatter *Get() {
     if (NULL == _singleton) {
       _singleton = new InstructionSentenceFormatter;

Core/GDCore/IDE/Events/TextFormatting.h

@@ -13,85 +13,20 @@ namespace gd {
 /**
  * \brief Represents the style of a text displayed in the events editor.
  *
- * Notably used by EventsRenderingHelper to render Instruction.
- *
  * \see EventsRenderingHelper
  * \ingroup IDEDialogsEventsEditor
  */
 class GD_CORE_API TextFormatting {
  public:
-  TextFormatting()
-      : colorRed(0),
-        colorGreen(0),
-        colorBlue(0),
-        bold(false),
-        italic(false),
-        userData(gd::String::npos) {}
+  TextFormatting() : userData(gd::String::npos) {}
   ~TextFormatting() {}
 
-  /**
-   * \brief Return true if the bold style must be applied.
-   */
-  bool IsBold() const { return bold; }
-
-  /**
-   * \brief Return true if the italic style must be applied.
-   */
-  bool IsItalic() const { return italic; }
-
-  /**
-   * \brief Return the red component of the color that must be applied to the
-   * text.
-   */
-  unsigned int GetColorRed() const { return colorRed; }
-  /**
-   * \brief Return the green component of the color that must be applied to the
-   * text.
-   */
-  unsigned int GetColorGreen() const { return colorGreen; }
-  /**
-   * \brief Return the blue component of the color that must be applied to the
-   * text.
-   */
-  unsigned int GetColorBlue() const { return colorBlue; }
-
-  /**
-   * Change the color of the text.
-   */
-  TextFormatting& SetColor(unsigned int r, unsigned int g, unsigned int b) {
-    colorRed = r;
-    colorGreen = g;
-    colorBlue = b;
-    return *this;
-  }
-
-  /**
-   * \brief Set if the bold style must be applied.
-   */
-  TextFormatting& SetBold(bool enable = true) {
-    bold = enable;
-    return *this;
-  }
-
-  /**
-   * \brief Set if the italic style must be applied.
-   */
-  TextFormatting& SetItalic(bool enable = true) {
-    italic = enable;
-    return *this;
-  }
-
   /**
    * Return the data (an integer) associated with the text formatting.
    * Used to store the parameter when rendering instructions.
    */
   size_t GetUserData() const { return userData; }
 
-  unsigned int colorRed;
-  unsigned int colorGreen;
-  unsigned int colorBlue;
-  bool bold;
-  bool italic;
   size_t userData;
 };
 

Core/GDCore/IDE/Events/UsedExtensionsFinder.cpp

@@ -0,0 +1,144 @@
+#include "UsedExtensionsFinder.h"
+
+#include "GDCore/Events/Instruction.h"
+#include "GDCore/Events/Parsers/ExpressionParser2.h"
+#include "GDCore/Extensions/Metadata/MetadataProvider.h"
+#include "GDCore/Extensions/PlatformExtension.h"
+#include "GDCore/IDE/WholeProjectRefactorer.h"
+#include "GDCore/Project/BehaviorContent.h"
+#include "GDCore/Project/Object.h"
+#include "GDCore/Project/Project.h"
+
+namespace gd {
+
+std::set<gd::String> UsedExtensionsFinder::ScanProject(gd::Project& project) {
+  UsedExtensionsFinder worker(project);
+  gd::WholeProjectRefactorer::ExposeProjectObjects(project, worker);
+  gd::WholeProjectRefactorer::ExposeProjectEvents(project, worker);
+  return worker.usedExtensions;
+};
+
+// Objects scanner
+
+void UsedExtensionsFinder::DoVisitObject(gd::Object& object) {
+  usedExtensions.insert(gd::MetadataProvider::GetExtensionAndObjectMetadata(
+                            project.GetCurrentPlatform(), object.GetType())
+                            .GetExtension()
+                            .GetName());
+};
+
+// Behaviors scanner
+
+void UsedExtensionsFinder::DoVisitBehavior(gd::BehaviorContent& behavior) {
+  usedExtensions.insert(
+      gd::MetadataProvider::GetExtensionAndBehaviorMetadata(
+          project.GetCurrentPlatform(), behavior.GetTypeName())
+          .GetExtension()
+          .GetName());
+};
+
+// Instructions scanner
+
+bool UsedExtensionsFinder::DoVisitInstruction(gd::Instruction& instruction,
+                                              bool isCondition) {
+  auto metadata =
+      isCondition ? gd::MetadataProvider::GetExtensionAndConditionMetadata(
+                        project.GetCurrentPlatform(), instruction.GetType())
+                  : gd::MetadataProvider::GetExtensionAndActionMetadata(
+                        project.GetCurrentPlatform(), instruction.GetType());
+  usedExtensions.insert(metadata.GetExtension().GetName());
+
+  size_t i = 0;
+  for (auto expression : instruction.GetParameters()) {
+    const gd::String& parameterType =
+        metadata.GetMetadata().GetParameter(i).GetType();
+    i++;
+
+    if (gd::ParameterMetadata::IsExpression("string", parameterType) ||
+        gd::ParameterMetadata::IsExpression("number", parameterType)) {
+      gd::ExpressionParser2 parser(project.GetCurrentPlatform(),
+                                   GetGlobalObjectsContainer(),
+                                   GetObjectsContainer());
+      parser.ParseExpression(parameterType, expression.GetPlainString())
+          ->Visit(*this);
+    } else if (gd::ParameterMetadata::IsExpression("variable", parameterType))
+      usedExtensions.insert("BuiltinVariables");
+  }
+  return false;
+}
+
+// Expressions scanner
+
+// Ignore litterals nodes
+void UsedExtensionsFinder::OnVisitNumberNode(NumberNode& node){};
+void UsedExtensionsFinder::OnVisitTextNode(TextNode& node){};
+
+// Ignore nodes without valid extensions
+void UsedExtensionsFinder::OnVisitEmptyNode(EmptyNode& node){};
+void UsedExtensionsFinder::OnVisitObjectFunctionNameNode(
+    ObjectFunctionNameNode& node){};
+
+// Visit sub-expressions
+void UsedExtensionsFinder::OnVisitSubExpressionNode(SubExpressionNode& node) {
+  node.expression->Visit(*this);
+};
+
+void UsedExtensionsFinder::OnVisitOperatorNode(OperatorNode& node) {
+  node.leftHandSide->Visit(*this);
+  node.rightHandSide->Visit(*this);
+};
+
+void UsedExtensionsFinder::OnVisitUnaryOperatorNode(UnaryOperatorNode& node) {
+  node.factor->Visit(*this);
+};
+
+// Add variable extension and visit sub-expressions on variable nodes
+void UsedExtensionsFinder::OnVisitVariableNode(VariableNode& node) {
+  usedExtensions.insert("BuiltinVariables");
+  if (node.child) node.child->Visit(*this);
+};
+
+void UsedExtensionsFinder::OnVisitVariableAccessorNode(
+    VariableAccessorNode& node) {
+  usedExtensions.insert("BuiltinVariables");
+  if (node.child) node.child->Visit(*this);
+};
+
+void UsedExtensionsFinder::OnVisitVariableBracketAccessorNode(
+    VariableBracketAccessorNode& node) {
+  usedExtensions.insert("BuiltinVariables");
+  node.expression->Visit(*this);
+  if (node.child) node.child->Visit(*this);
+};
+
+// Add extensions bound to Objects/Behaviors/Functions
+void UsedExtensionsFinder::OnVisitIdentifierNode(IdentifierNode& node) {
+  if (gd::ParameterMetadata::IsObject(node.type)) {
+    usedExtensions.insert(gd::MetadataProvider::GetExtensionAndObjectMetadata(
+                              project.GetCurrentPlatform(), node.identifierName)
+                              .GetExtension()
+                              .GetName());
+  }
+};
+
+void UsedExtensionsFinder::OnVisitFunctionCallNode(FunctionCallNode& node) {
+  // Extensions of non-free functions are already found when scanning objects.
+  if (!(node.objectName.empty() && node.behaviorName.empty())) return;
+  gd::ExtensionAndMetadata<gd::ExpressionMetadata> metadata;
+
+  // Try to find a free number expression
+  metadata = gd::MetadataProvider::GetExtensionAndExpressionMetadata(
+      project.GetCurrentPlatform(), node.functionName);
+  if (gd::MetadataProvider::IsBadExpressionMetadata(metadata.GetMetadata())) {
+    // Try to find a free str expression
+    metadata = gd::MetadataProvider::GetExtensionAndStrExpressionMetadata(
+        project.GetCurrentPlatform(), node.functionName);
+    // No valid expression found, return.
+    if (gd::MetadataProvider::IsBadExpressionMetadata(metadata.GetMetadata()))
+      return;
+  }
+
+  usedExtensions.insert(metadata.GetExtension().GetName());
+};
+
+}  // namespace gd

Core/GDCore/IDE/Events/UsedExtensionsFinder.h

@@ -0,0 +1,64 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+
+#ifndef GDCORE_USED_EXTENSIONS_FINDER_H
+#define GDCORE_USED_EXTENSIONS_FINDER_H
+#include <set>
+
+#include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
+#include "GDCore/IDE/Events/ArbitraryEventsWorker.h"
+#include "GDCore/IDE/Project/ArbitraryObjectsWorker.h"
+#include "GDCore/String.h"
+
+namespace gd {
+class Project;
+class Object;
+class BehaviorContent;
+}  // namespace gd
+
+namespace gd {
+
+class GD_CORE_API UsedExtensionsFinder
+    : public ArbitraryObjectsWorker,
+      public ArbitraryEventsWorkerWithContext,
+      public ExpressionParser2NodeWorker {
+ public:
+  static std::set<gd::String> ScanProject(gd::Project& project);
+
+ private:
+  UsedExtensionsFinder(gd::Project& project_) : project(project_){};
+  gd::Project& project;
+  std::set<gd::String> usedExtensions;
+
+  // Object Visitor
+  void DoVisitObject(gd::Object& object) override;
+
+  // Behavior Visitor
+  void DoVisitBehavior(gd::BehaviorContent& behavior) override;
+
+  // Instructions Visitor
+  bool DoVisitInstruction(gd::Instruction& instruction,
+                          bool isCondition) override;
+
+  // Expression Visitor
+  void OnVisitSubExpressionNode(SubExpressionNode& node) override;
+  void OnVisitOperatorNode(OperatorNode& node) override;
+  void OnVisitUnaryOperatorNode(UnaryOperatorNode& node) override;
+  void OnVisitNumberNode(NumberNode& node) override;
+  void OnVisitTextNode(TextNode& node) override;
+  void OnVisitVariableNode(VariableNode& node) override;
+  void OnVisitVariableAccessorNode(VariableAccessorNode& node) override;
+  void OnVisitVariableBracketAccessorNode(
+      VariableBracketAccessorNode& node) override;
+  void OnVisitIdentifierNode(IdentifierNode& node) override;
+  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override;
+  void OnVisitFunctionCallNode(FunctionCallNode& node) override;
+  void OnVisitEmptyNode(EmptyNode& node) override;
+};
+
+};  // namespace gd
+
+#endif

Core/GDCore/IDE/ExportedDependencyResolver.h

@@ -0,0 +1,126 @@
+#pragma once
+#include <vector>
+
+#include "GDCore/Extensions/Metadata/DependencyMetadata.h"
+#include "GDCore/Extensions/PlatformExtension.h"
+#include "GDCore/Project/Project.h"
+
+namespace gd {
+
+/**
+ * \brief Store references to a gd::DependencyMetadata and its associated
+ * gd::PlatformExtension.
+ *
+ * \note Both objects must be kept alive, as this is keeping a pointer to them.
+ */
+struct DependencyMetadataAndExtension {
+  DependencyMetadataAndExtension(gd::DependencyMetadata &dependency_,
+                                 gd::PlatformExtension &extension_)
+      : dependency(&dependency_), extension(&extension_){};
+
+  gd::DependencyMetadata &GetDependency() const { return *dependency; };
+  gd::PlatformExtension &GetExtension() const { return *extension; };
+
+ private:
+  gd::DependencyMetadata *dependency;
+  gd::PlatformExtension *extension;
+};
+
+/**
+ * \brief Helpers to manipulate dependencies of extensions to be exported along
+ * with a game.
+ */
+class ExportedDependencyResolver {
+ public:
+  /**
+   * \brief Return the list of dependencies to be exported for the given
+   * project, used extensions list and dependency type.
+   *
+   * Not all dependencies declared by extensions must be exported: some are only
+   * exported when some settings are filled. Then, some others are only exported
+   * when some other dependencies are exported (this won't work for more than
+   * one level though).
+   */
+  static std::vector<DependencyMetadataAndExtension> GetDependenciesFor(
+      const gd::Project &project,
+      std::set<gd::String> usedExtensions,
+      const gd::String &dependencyType) {
+    std::vector<DependencyMetadataAndExtension> dependenciesWithProperType;
+    for (const gd::String &extensionName : usedExtensions) {
+      auto extension = project.GetCurrentPlatform().GetExtension(extensionName);
+      for (gd::DependencyMetadata &dependency :
+           extension->GetAllDependencies()) {
+        if (dependency.GetDependencyType() == dependencyType) {
+          DependencyMetadataAndExtension dependencyMetadataAndExtension(
+              dependency, *extension);
+          dependenciesWithProperType.push_back(dependencyMetadataAndExtension);
+        }
+      }
+    }
+
+    // Keep only the dependencies that have their extra settings filled
+    // and those that don't require extra settings to be filled.
+    std::vector<DependencyMetadataAndExtension> dependenciesWithFilledSettings;
+    for (auto dependencyAndExtension : dependenciesWithProperType) {
+      auto &dependency = dependencyAndExtension.GetDependency();
+      auto extraSettingValues = GetExtensionDependencyExtraSettingValues(
+          project, dependencyAndExtension);
+
+      bool hasExtraSettings = !extraSettingValues.empty();
+      if (!dependency.IsOnlyIfSomeExtraSettingsNonEmpty() || hasExtraSettings)
+        dependenciesWithFilledSettings.push_back(dependencyAndExtension);
+    }
+
+    // Keep only the dependency that depends on another dependencies that is
+    // exported (or dependencies that don't require another dependency).
+    std::vector<DependencyMetadataAndExtension> exportedDependencies;
+    for (auto dependencyAndExtension : dependenciesWithFilledSettings) {
+      auto &dependency = dependencyAndExtension.GetDependency();
+      auto &otherDependencyName =
+          dependency.GetOtherDependencyThatMustBeExported();
+      if (otherDependencyName.empty() ||
+          std::find_if(
+              dependenciesWithFilledSettings.begin(),
+              dependenciesWithFilledSettings.end(),
+              [&otherDependencyName](
+                  DependencyMetadataAndExtension &otherDependencyAndExtension) {
+                return otherDependencyAndExtension.GetDependency().GetName() ==
+                       otherDependencyName;
+              }) != dependenciesWithFilledSettings.end()) {
+        exportedDependencies.push_back(dependencyAndExtension);
+      }
+    }
+
+    return exportedDependencies;
+  }
+
+  /**
+   * \brief Return the values that were stored in the project for the given
+   * dependency.
+   */
+  static std::map<gd::String, gd::String>
+  GetExtensionDependencyExtraSettingValues(
+      const gd::Project &project,
+      const gd::DependencyMetadataAndExtension &dependencyAndExtension) {
+    std::map<gd::String, gd::String> values;
+    auto &dependency = dependencyAndExtension.GetDependency();
+    const gd::String &extensionName =
+        dependencyAndExtension.GetExtension().GetName();
+
+    for (const auto &extraSetting : dependency.GetAllExtraSettings()) {
+      const gd::String &type = extraSetting.second.GetType();
+      const gd::String extraSettingValue =
+          type == "ExtensionProperty"
+              ? project.GetExtensionProperties().GetValue(
+                    extensionName, extraSetting.second.GetValue())
+              : extraSetting.second.GetValue();
+
+      if (!extraSettingValue.empty())
+        values[extraSetting.first] = extraSettingValue;
+    }
+
+    return values;
+  };
+};
+
+}  // namespace gd

Core/GDCore/IDE/Project/ArbitraryObjectsWorker.cpp

@@ -0,0 +1,43 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#include "ArbitraryObjectsWorker.h"
+
+#include <iostream>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "GDCore/Project/BehaviorContent.h"
+#include "GDCore/Project/Object.h"
+#include "GDCore/Project/ObjectsContainer.h"
+#include "GDCore/String.h"
+
+using namespace std;
+
+namespace gd {
+
+ArbitraryObjectsWorker::~ArbitraryObjectsWorker() {}
+
+void ArbitraryObjectsWorker::VisitObjectContainer(
+    gd::ObjectsContainer& objects) {
+  DoVisitObjectContainer(objects);
+
+  for (size_t i = 0; i < objects.GetObjectsCount(); i++)
+    VisitObject(objects.GetObject(i));
+}
+
+void ArbitraryObjectsWorker::VisitObject(gd::Object& object) {
+  DoVisitObject(object);
+
+  for (auto behaviorName : object.GetAllBehaviorNames())
+    VisitBehavior(object.GetBehavior(behaviorName));
+}
+
+void ArbitraryObjectsWorker::VisitBehavior(gd::BehaviorContent& behavior) {
+  DoVisitBehavior(behavior);
+}
+
+}  // namespace gd

Core/GDCore/IDE/Project/ArbitraryObjectsWorker.h

@@ -0,0 +1,63 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+
+#ifndef ARBITRARYOBJECTSWORKER_H
+#define ARBITRARYOBJECTSWORKER_H
+
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "GDCore/String.h"
+namespace gd {
+class Object;
+class ObjectsContainer;
+class BehaviorContent;
+}  // namespace gd
+
+namespace gd {
+
+/**
+ * \brief ArbitraryObjectsWorker is an abstract class used to browse objects
+ * (and behaviors) and do some work on them. Can be used to implement
+ * refactoring for example.
+ *
+ * \ingroup IDE
+ */
+class GD_CORE_API ArbitraryObjectsWorker {
+ public:
+  ArbitraryObjectsWorker(){};
+  virtual ~ArbitraryObjectsWorker();
+
+  /**
+   * \brief Launch the worker on the specified events list.
+   */
+  void Launch(gd::ObjectsContainer& objects) { VisitObjectContainer(objects); };
+
+ private:
+  void VisitObjectContainer(gd::ObjectsContainer& objects);
+  void VisitObject(gd::Object& object);
+  void VisitBehavior(gd::BehaviorContent& instruction);
+
+  /**
+   * Called to do some work on an object container.
+   */
+  virtual void DoVisitObjectContainer(gd::ObjectsContainer& objects){};
+
+  /**
+   * Called to do some work on an object.
+   */
+  virtual void DoVisitObject(gd::Object& object){};
+
+  /**
+   * Called to do some work on a behavior.
+   */
+  virtual void DoVisitBehavior(gd::BehaviorContent& instruction){};
+};
+
+}  // namespace gd
+
+#endif  // ARBITRARYOBJECTSWORKER_H

Core/GDCore/IDE/Project/ArbitraryResourceWorker.cpp

@@ -6,8 +6,10 @@
 #if defined(GD_IDE_ONLY)
 
 #include "ArbitraryResourceWorker.h"
+
 #include <memory>
 #include <vector>
+
 #include "GDCore/Events/Event.h"
 #include "GDCore/Events/EventsList.h"
 #include "GDCore/Extensions/Metadata/InstructionMetadata.h"
@@ -55,6 +57,21 @@ void ArbitraryResourceWorker::ExposeFont(gd::String& fontName) {
   ExposeFile(fontName);
 };
 
+void ArbitraryResourceWorker::ExposeBitmapFont(gd::String& bitmapFontName) {
+  for (auto resources : GetResources()) {
+    if (!resources) continue;
+
+    if (resources->HasResource(bitmapFontName) &&
+        resources->GetResource(bitmapFontName).GetKind() == "bitmapFont") {
+      // Nothing to do, the font is a reference to a resource that
+      // is already exposed.
+      return;
+    }
+  }
+
+  ExposeFile(bitmapFontName);
+};
+
 void ArbitraryResourceWorker::ExposeResources(
     gd::ResourcesManager* resourcesManager) {
   if (!resourcesManager) return;
@@ -82,15 +99,8 @@ void LaunchResourceWorkerOnEvents(const gd::Project& project,
                                   gd::EventsList& events,
                                   gd::ArbitraryResourceWorker& worker) {
   // Get all extensions used
-  std::vector<std::shared_ptr<gd::PlatformExtension> > allGameExtensions;
-  std::vector<gd::String> usedExtensions = project.GetUsedExtensions();
-  for (std::size_t i = 0; i < usedExtensions.size(); ++i) {
-    std::shared_ptr<gd::PlatformExtension> extension =
-        project.GetCurrentPlatform().GetExtension(usedExtensions[i]);
-
-    if (extension != std::shared_ptr<gd::PlatformExtension>())
-      allGameExtensions.push_back(extension);
-  }
+  auto allGameExtensions =
+      project.GetCurrentPlatform().GetAllPlatformExtensions();
 
   for (std::size_t j = 0; j < events.size(); j++) {
     vector<gd::InstructionsList*> allActionsVectors =

Core/GDCore/IDE/Project/ArbitraryResourceWorker.h

@@ -70,6 +70,12 @@ class GD_CORE_API ArbitraryResourceWorker {
    */
   virtual void ExposeFont(gd::String &fontName);
 
+  /**
+   * \brief Expose a bitmap font, which is either a reference to a "bitmapFont" resource,
+   * or a filename if no resource with this name exists.
+   */
+  virtual void ExposeBitmapFont(gd::String &bitmapFontName);
+
   /**
    * \brief Expose a shader.
    * \warn Currently unsupported.

Core/GDCore/IDE/Project/ResourcesInUseHelper.h

@@ -38,12 +38,15 @@ class ResourcesInUseHelper : public gd::ArbitraryResourceWorker {
   std::set<gd::String>& GetAllImages() { return GetAll("image"); };
   std::set<gd::String>& GetAllFonts() { return GetAll("font"); };
   std::set<gd::String>& GetAllAudios() { return GetAll("audio"); };
+  std::set<gd::String>& GetAllBitmapFonts() { return GetAll("bitmapFont"); };
   std::set<gd::String>& GetAll(const gd::String& resourceType) {
     return resourceType == "image"
                ? allImages
                : (resourceType == "audio"
                       ? allAudios
-                      : (resourceType == "font") ? allFonts : emptyResources);
+                      : (resourceType == "font")
+                            ? allFonts
+                            : (resourceType == "bitmapFont") ? allBitmapFonts : emptyResources);
   };
 
   virtual void ExposeFile(gd::String& resource) override{
@@ -58,11 +61,15 @@ class ResourcesInUseHelper : public gd::ArbitraryResourceWorker {
   virtual void ExposeFont(gd::String& fontResourceName) override {
     allFonts.insert(fontResourceName);
   };
+  virtual void ExposeBitmapFont(gd::String& bitmapFontResourceName) override {
+    allBitmapFonts.insert(bitmapFontResourceName);
+  };
 
  protected:
   std::set<gd::String> allImages;
   std::set<gd::String> allAudios;
   std::set<gd::String> allFonts;
+  std::set<gd::String> allBitmapFonts;
   std::set<gd::String> emptyResources;
 };
 

Core/GDCore/IDE/WholeProjectRefactorer.cpp

@@ -4,15 +4,17 @@
  * reserved. This project is released under the MIT License.
  */
 #include "WholeProjectRefactorer.h"
+
 #include "GDCore/Extensions/PlatformExtension.h"
 #include "GDCore/IDE/DependenciesAnalyzer.h"
 #include "GDCore/IDE/Events/ArbitraryEventsWorker.h"
 #include "GDCore/IDE/Events/EventsRefactorer.h"
-#include "GDCore/IDE/Events/ExpressionsRenamer.h"
 #include "GDCore/IDE/Events/ExpressionsParameterMover.h"
-#include "GDCore/IDE/Events/InstructionsTypeRenamer.h"
+#include "GDCore/IDE/Events/ExpressionsRenamer.h"
 #include "GDCore/IDE/Events/InstructionsParameterMover.h"
+#include "GDCore/IDE/Events/InstructionsTypeRenamer.h"
 #include "GDCore/IDE/EventsFunctionTools.h"
+#include "GDCore/IDE/Project/ArbitraryObjectsWorker.h"
 #include "GDCore/Project/EventsBasedBehavior.h"
 #include "GDCore/Project/EventsFunctionsExtension.h"
 #include "GDCore/Project/ExternalEvents.h"
@@ -141,6 +143,13 @@ void WholeProjectRefactorer::ExposeProjectEvents(
   }
 }
 
+void WholeProjectRefactorer::ExposeProjectObjects(
+    gd::Project& project, gd::ArbitraryObjectsWorker& worker) {
+  worker.Launch(project);
+  for (size_t i = 0; i < project.GetLayoutsCount(); i++)
+    worker.Launch(project.GetLayout(i));
+};
+
 std::set<gd::String>
 WholeProjectRefactorer::GetAllObjectTypesUsingEventsBasedBehavior(
     const gd::Project& project,

Core/GDCore/IDE/WholeProjectRefactorer.h

@@ -16,6 +16,7 @@ class EventsFunction;
 class ObjectsContainer;
 class EventsBasedBehavior;
 class ArbitraryEventsWorker;
+class ArbitraryObjectsWorker;
 class ArbitraryEventsWorkerWithContext;
 }  // namespace gd
 
@@ -50,10 +51,21 @@ class GD_CORE_API WholeProjectRefactorer {
                                   gd::ArbitraryEventsWorkerWithContext& worker);
 
   /**
-   * \brief Refactor the project **before** an events function extension is renamed.
+   * \brief Call the specified worker on all ObjectContainers of the project (global,
+   * layouts...)
+   *
+   * This should be the preferred way to traverse all the objects of a project.
+   */
+  static void ExposeProjectObjects(
+      gd::Project& project, gd::ArbitraryObjectsWorker& worker);
+
+  /**
+   * \brief Refactor the project **before** an events function extension is
+   * renamed.
    *
    * \warning Do the renaming of the specified extension after calling this.
-   * This is because the extension is expected to have its old name for the refactoring.
+   * This is because the extension is expected to have its old name for the
+   * refactoring.
    */
   static void RenameEventsFunctionsExtension(
       gd::Project& project,
@@ -65,7 +77,8 @@ class GD_CORE_API WholeProjectRefactorer {
    * \brief Refactor the project **before** an events function is renamed.
    *
    * \warning Do the renaming of the specified function after calling this.
-   * This is because the function is expected to have its old name for the refactoring.
+   * This is because the function is expected to have its old name for the
+   * refactoring.
    */
   static void RenameEventsFunction(
       gd::Project& project,
@@ -78,7 +91,8 @@ class GD_CORE_API WholeProjectRefactorer {
    * renamed.
    *
    * \warning Do the renaming of the specified function after calling this.
-   * This is because the function is expected to have its old name for the refactoring.
+   * This is because the function is expected to have its old name for the
+   * refactoring.
    */
   static void RenameBehaviorEventsFunction(
       gd::Project& project,
@@ -91,8 +105,9 @@ class GD_CORE_API WholeProjectRefactorer {
    * \brief Refactor the project **before** an events function parameter
    * is moved.
    *
-   * \warning Do the move of the specified function parameters after calling this.
-   * This is because the function is expected to be in its old state for the refactoring.
+   * \warning Do the move of the specified function parameters after calling
+   * this. This is because the function is expected to be in its old state for
+   * the refactoring.
    */
   static void MoveEventsFunctionParameter(
       gd::Project& project,
@@ -102,11 +117,12 @@ class GD_CORE_API WholeProjectRefactorer {
       std::size_t newIndex);
 
   /**
-   * \brief Refactor the project **before** the parameter of an events function of a
-   * behavior is moved.
+   * \brief Refactor the project **before** the parameter of an events function
+   * of a behavior is moved.
    *
-   * \warning Do the move of the specified function parameters after calling this.
-   * This is because the function is expected to be in its old state for the refactoring.
+   * \warning Do the move of the specified function parameters after calling
+   * this. This is because the function is expected to be in its old state for
+   * the refactoring.
    */
   static void MoveBehaviorEventsFunctionParameter(
       gd::Project& project,
@@ -121,7 +137,8 @@ class GD_CORE_API WholeProjectRefactorer {
    * renamed.
    *
    * \warning Do the renaming of the specified property after calling this.
-   * This is because the property is expected to have its old name for the refactoring.
+   * This is because the property is expected to have its old name for the
+   * refactoring.
    */
   static void RenameBehaviorProperty(
       gd::Project& project,
@@ -134,7 +151,8 @@ class GD_CORE_API WholeProjectRefactorer {
    * \brief Refactor the project **before** a behavior is renamed.
    *
    * \warning Do the renaming of the specified behavior after calling this.
-   * This is because the behavior is expected to have its old name for the refactoring.
+   * This is because the behavior is expected to have its old name for the
+   * refactoring.
    */
   static void RenameEventsBasedBehavior(
       gd::Project& project,

Core/GDCore/Project/Effect.cpp

@@ -9,7 +9,6 @@
 
 namespace gd {
 
-#if defined(GD_IDE_ONLY)
 void Effect::SerializeTo(SerializerElement& element) const {
   element.SetAttribute("name", GetName());
   element.SetAttribute("effectType", GetEffectType());
@@ -32,7 +31,6 @@ void Effect::SerializeTo(SerializerElement& element) const {
     booleanParametersElement.AddChild(parameter.first)
         .SetValue(parameter.second);
 }
-#endif
 
 void Effect::UnserializeFrom(const SerializerElement& element) {
   SetName(element.GetStringAttribute("name"));

Core/GDCore/Project/Effect.h

@@ -74,12 +74,10 @@ class GD_CORE_API Effect {
     booleanParameters.clear();
   }
 
-#if defined(GD_IDE_ONLY)
   /**
    * \brief Serialize layer.
    */
   void SerializeTo(SerializerElement& element) const;
-#endif
 
   /**
    * \brief Unserialize the layer.

Core/GDCore/Project/EffectsContainer.cpp

@@ -0,0 +1,140 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#include "EffectsContainer.h"
+
+#include "Effect.h"
+#include "GDCore/Serialization/SerializerElement.h"
+
+namespace gd {
+Effect EffectsContainer::badEffect;
+
+EffectsContainer::EffectsContainer() {}
+
+EffectsContainer::EffectsContainer(const EffectsContainer& other) {
+  Init(other);
+}
+
+EffectsContainer& EffectsContainer::operator=(const EffectsContainer& rhs) {
+  if (this != &rhs) Init(rhs);
+  return *this;
+}
+
+void EffectsContainer::Init(const EffectsContainer& other) {
+  effects.clear();
+  for (auto& it : other.effects) {
+    effects.push_back(std::make_shared<Effect>(*it));
+  }
+}
+
+bool EffectsContainer::HasEffectNamed(const gd::String& name) const {
+  return (find_if(effects.begin(),
+                  effects.end(),
+                  [&name](const std::shared_ptr<gd::Effect>& effect) {
+                    return effect->GetName() == name;
+                  }) != effects.end());
+}
+
+gd::Effect& EffectsContainer::GetEffect(const gd::String& name) {
+  auto effect = find_if(effects.begin(),
+                        effects.end(),
+                        [&name](std::shared_ptr<gd::Effect>& effect) {
+                          return effect->GetName() == name;
+                        });
+
+  if (effect != effects.end()) return **effect;
+
+  return badEffect;
+}
+
+const gd::Effect& EffectsContainer::GetEffect(const gd::String& name) const {
+  auto effect = find_if(effects.begin(),
+                        effects.end(),
+                        [&name](const std::shared_ptr<gd::Effect>& effect) {
+                          return effect->GetName() == name;
+                        });
+
+  if (effect != effects.end()) return **effect;
+
+  return badEffect;
+}
+gd::Effect& EffectsContainer::GetEffect(std::size_t index) {
+  return *effects[index];
+}
+const gd::Effect& EffectsContainer::GetEffect(std::size_t index) const {
+  return *effects[index];
+}
+std::size_t EffectsContainer::GetEffectsCount() const { return effects.size(); }
+std::size_t EffectsContainer::GetEffectPosition(const gd::String& name) const {
+  for (std::size_t i = 0; i < effects.size(); ++i) {
+    if (effects[i]->GetName() == name) return i;
+  }
+  return gd::String::npos;
+}
+
+gd::Effect& EffectsContainer::InsertNewEffect(const gd::String& name,
+                                              std::size_t position) {
+  auto newEffect = std::make_shared<Effect>();
+  newEffect->SetName(name);
+
+  if (position < effects.size())
+    effects.insert(effects.begin() + position, newEffect);
+  else
+    effects.push_back(newEffect);
+
+  return *newEffect;
+}
+
+void EffectsContainer::InsertEffect(const gd::Effect& effect,
+                                    std::size_t position) {
+  auto newEffect = std::make_shared<gd::Effect>(effect);
+  if (position < effects.size())
+    effects.insert(effects.begin() + position, newEffect);
+  else
+    effects.push_back(newEffect);
+}
+
+void EffectsContainer::RemoveEffect(const gd::String& name) {
+  auto effect = find_if(effects.begin(),
+                        effects.end(),
+                        [&name](const std::shared_ptr<gd::Effect>& effect) {
+                          return effect->GetName() == name;
+                        });
+  if (effect == effects.end()) return;
+
+  effects.erase(effect);
+}
+
+void EffectsContainer::SwapEffects(std::size_t firstEffectIndex,
+                                   std::size_t secondEffectIndex) {
+  if (firstEffectIndex >= effects.size() || secondEffectIndex >= effects.size())
+    return;
+
+  auto temp = effects[firstEffectIndex];
+  effects[firstEffectIndex] = effects[secondEffectIndex];
+  effects[secondEffectIndex] = temp;
+}
+
+void EffectsContainer::SerializeTo(SerializerElement& element) const {
+  element.ConsiderAsArrayOf("effect");
+  for (std::size_t i = 0; i < GetEffectsCount(); ++i) {
+    SerializerElement& effectElement = element.AddChild("effect");
+    GetEffect(i).SerializeTo(effectElement);
+  }
+}
+
+void EffectsContainer::UnserializeFrom(const SerializerElement& element) {
+  effects.clear();
+  element.ConsiderAsArrayOf("effect");
+  for (std::size_t i = 0; i < element.GetChildrenCount(); ++i) {
+    const SerializerElement& effectElement = element.GetChild(i);
+
+    auto effect = std::make_shared<Effect>();
+    effect->UnserializeFrom(effectElement);
+    effects.push_back(effect);
+  }
+}
+
+}  // namespace gd

Core/GDCore/Project/EffectsContainer.h

@@ -0,0 +1,114 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#ifndef GDCORE_EFFECTS_CONTAINER_H
+#define GDCORE_EFFECTS_CONTAINER_H
+#include <memory>
+#include <vector>
+
+#include "GDCore/String.h"
+
+namespace gd {
+class Effect;
+}
+namespace gd {
+class SerializerElement;
+}
+
+namespace gd {
+
+/**
+ * \brief Contains effects applied to an entity on screen (i.e: a Layer or an
+ * Object).
+ *
+ * \ingroup PlatformDefinition
+ */
+class GD_CORE_API EffectsContainer {
+ public:
+  EffectsContainer();
+  EffectsContainer(const EffectsContainer& other);
+  virtual ~EffectsContainer(){};
+
+  EffectsContainer& operator=(const EffectsContainer& rhs);
+  /**
+   * \brief Return true if the effect called "name" exists.
+   */
+  bool HasEffectNamed(const gd::String& name) const;
+
+  /**
+   * \brief Return a reference to the effect called "name".
+   */
+  Effect& GetEffect(const gd::String& name);
+
+  /**
+   * \brief Return a reference to the effect called "name".
+   */
+  const Effect& GetEffect(const gd::String& name) const;
+
+  /**
+   * Return a reference to the effect at position "index" in the effects list
+   */
+  Effect& GetEffect(std::size_t index);
+
+  /**
+   * Return a reference to the effect at position "index" in the effects list
+   */
+  const Effect& GetEffect(std::size_t index) const;
+
+  /**
+   * Return the position of the effect called "name" in the effects list
+   */
+  std::size_t GetEffectPosition(const gd::String& name) const;
+
+  /**
+   * Return the number of effecst.
+   */
+  std::size_t GetEffectsCount() const;
+
+  /**
+   * Add a new effect at the specified position in the effects list.
+   */
+  gd::Effect& InsertNewEffect(const gd::String& name, std::size_t position);
+
+  /**
+   * \brief Add a copy of the specified effect in the effects list.
+   *
+   * \note No pointer or reference must be kept on the effect passed as
+   * parameter.
+   *
+   * \param theEffect The effect that must be copied and inserted
+   * into the effects list
+   * \param position Insertion position.
+   */
+  void InsertEffect(const Effect& theEffect, std::size_t position);
+
+  /**
+   * Remove the specified effect.
+   */
+  void RemoveEffect(const gd::String& name);
+
+  /**
+   * Swap the position of two effects.
+   */
+  void SwapEffects(std::size_t firstEffectIndex, std::size_t secondEffectIndex);
+
+  /**
+   * \brief Serialize the effects container.
+   */
+  void SerializeTo(SerializerElement& element) const;
+
+  /**
+   * \brief Unserialize the effects container.
+   */
+  void UnserializeFrom(const SerializerElement& element);
+
+ private:
+  std::vector<std::shared_ptr<gd::Effect>> effects;
+  static Effect badEffect;
+  void Init(const EffectsContainer& other);
+};
+}  // namespace gd
+
+#endif

Core/GDCore/Project/EventsFunction.cpp

@@ -17,6 +17,7 @@ void EventsFunction::SerializeTo(SerializerElement& element) const {
   element.SetAttribute("fullName", fullName);
   element.SetAttribute("description", description);
   element.SetAttribute("sentence", sentence);
+  element.SetBoolAttribute("private", isPrivate);
   events.SerializeTo(element.AddChild("events"));
 
   gd::String functionTypeStr = "Action";
@@ -43,6 +44,7 @@ void EventsFunction::UnserializeFrom(gd::Project& project,
   fullName = element.GetStringAttribute("fullName");
   description = element.GetStringAttribute("description");
   sentence = element.GetStringAttribute("sentence");
+  isPrivate = element.GetBoolAttribute("private");
   events.UnserializeFrom(project, element.GetChild("events"));
 
   gd::String functionTypeStr = element.GetStringAttribute("functionType");