Port BBParam editor to GDExtension (#287)

Support Godot 4.4

.github/FUNDING.yml

@@ -0,0 +1 @@
+ko_fi: limbonaut

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,64 @@
+name: Bug report
+description: Report a bug in LimboAI
+labels:
+  - bug
+body:
+  - type: markdown
+    attributes:
+      value: |
+        - Write a descriptive title above.
+        - Search [open](https://github.com/limbonaut/limboai/issues) and [closed](https://github.com/limbonaut/limboai/issues?q=is%3Aissue+is%3Aclosed) issues to ensure it has not already been reported.
+
+  - type: input
+    attributes:
+      label: Godot version
+      description: |
+        - Specify the Godot version and hardware information if relevant.
+        - You can copy the version info by clicking on it in the Godot status bar.
+        - Alternatively, you can copy the version and hardware info in Godot using the main menu command "Help -> Copy System Info".
+      placeholder: v4.2.2.limboai+v1.1.0.gha [15073afe3]
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: LimboAI version
+      description: |
+        - Specify the LimboAI version.
+        - You can copy the version info by clicking on it in the toolbar of the LimboAI editor (top-right corner).
+      placeholder: v1.1.0 [8fa609e]
+    validations:
+      required: true
+
+  - type: dropdown
+    id: variant
+    attributes:
+      label: LimboAI variant
+      description: Which variant of our plugin are you running?
+      options:
+        - GDExtension / AssetLib
+        - Module (custom editor or template build)
+      default: 0
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Issue description
+      description: |
+        - Describe your issue in detail. What doesn't work and how do you expect it to work instead?
+        - Provide screenshots and/or a console output if it helps to convey the problem.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: How to reproduce
+      description: |
+        - Provide a list of steps or sample code that reproduces the issue.
+        - You can provide a small Godot project which reproduces the issue, with no unnecessary files included.
+          - Drag and drop a ZIP archive to upload it (10Mb limit).
+          - Don't include the `.godot` folder in the archive.
+          - Redroduction project helps to find the bug more quickly!
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,14 @@
+blank_issues_enabled: false
+
+contact_links:
+  - name: Documentation
+    url: https://limboai.readthedocs.io/en/stable/
+    about: Please see our documentation for more information.
+
+  - name: Discussions
+    url: https://github.com/limbonaut/limboai/discussions
+    about: Need help? Ask questions in Discussions or on our Discord server.
+
+  - name: Discord Server
+    url: https://discord.gg/N5MGC95GpP
+    about: Share your experience or get help on our Discord server.

.github/ISSUE_TEMPLATE/feature_proposal.yml

@@ -0,0 +1,38 @@
+name: Feature or improvement proposal
+description: Propose a new feature to be added or improved in LimboAI
+labels:
+  - enhancement
+body:
+  - type: markdown
+    attributes:
+      value: |
+        - Write a descriptive title above.
+        - Search [open](https://github.com/limbonaut/limboai/issues) and [closed](https://github.com/limbonaut/limboai/issues?q=is%3Aissue+is%3Aclosed) issues to ensure it has not already been reported.
+
+  - type: textarea
+    attributes:
+      label: Problem statement
+      description: |
+        - Describe the problem or limitation you're currently facing with the LimboAI plugin.
+        - If it helps, describe the project you're working on and how it relates to the problem or limitation.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Proposed solution
+      description: |
+        - Describe your proposed solution and how it helps to overcome the problem or limitation.
+        - If it helps, show how it will work with code, pseudo-code, mock-ups, and/or diagrams.
+        - You can include any images or videos with drag'n'drop, and sample code blocks with <code>```</code> tags.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Alternatives
+      description: |
+        - Describe alternative solutions and features you've considered.
+        - If this enhancement will not be used often, can it be worked around with a few clicks or lines of code?
+    validations:
+      required: true

.github/actions/build-dotnet-assemblies/action.yml

@@ -0,0 +1,33 @@
+name: Build .NET assemblies
+
+inputs:
+  platform:
+    required: true
+    type: choice
+    options:
+      - linuxbsd
+      - windows
+      - macos
+  bin:
+    required: true
+    type: string
+
+runs:
+  using: "composite"
+  steps:
+    - name: Override GODOT_VERSION_STATUS for NuGet packages
+      shell: bash
+      run: |
+        GODOT_VERSION_STATUS=$(echo "${GODOT_VERSION_STATUS}" | sed "s|+|-|").gha
+        echo "GODOT_VERSION_STATUS=${GODOT_VERSION_STATUS}" >> "$GITHUB_ENV"
+        echo "GODOT_VERSION_STATUS: ${GODOT_VERSION_STATUS}"
+
+    - name: Generate C# glue
+      shell: bash
+      run: |
+        ./bin/${{inputs.bin}} --headless --generate-mono-glue ./modules/mono/glue || true
+
+    - name: Build .NET assemblies
+      shell: bash
+      run: |
+        python ./modules/mono/build_scripts/build_assemblies.py --godot-output-dir=./bin --godot-platform=${{ inputs.platform }}

.github/actions/init-version-gdext/action.yml

@@ -0,0 +1,24 @@
+name: Setup version
+
+runs:
+  using: "composite"
+  steps:
+    - name: Set GDEXTENSION_VERSION & LIMBOAI_VERSION
+      shell: bash
+      run: |
+        cd godot-cpp
+        GDEXTENSION_VERSION=$( (git describe --tags --exact-match HEAD || git rev-parse --short HEAD) | sed 's/\(.*\)-\(.*\)/\1/g' )
+
+        if [[ ${GDEXTENSION_VERSION} == godot-* ]]; then
+           GDEXTENSION_VERSION=${GDEXTENSION_VERSION#"godot-"}
+        fi
+
+        echo "GDEXTENSION_VERSION=${GDEXTENSION_VERSION}" >> "$GITHUB_ENV"
+
+        cd ..
+        echo "LIMBOAI_VERSION=$( (git describe --tags --exact-match HEAD || git rev-parse --short HEAD) | sed 's/\(.*\)-\(.*\)/\1.\2/g' )" >> "$GITHUB_ENV"
+
+    - name: Set NAME_PREFIX
+      shell: bash
+      run: |
+        echo "NAME_PREFIX=limboai+${LIMBOAI_VERSION}.gdextension-${GDEXTENSION_VERSION}" >> "$GITHUB_ENV"

.github/actions/init-version/action.yml

@@ -0,0 +1,21 @@
+name: Setup version
+
+runs:
+  using: "composite"
+  steps:
+    - name: Set GODOT_VERSION & LIMBOAI_VERSION
+      shell: bash
+      run: |
+        echo "GODOT_VERSION=$( (git describe --tags --exact-match HEAD || git rev-parse --short HEAD) | sed 's/\(.*\)-\(.*\)/\1/g' )" >> "$GITHUB_ENV"
+        cd modules/limboai
+        echo "LIMBOAI_VERSION=$( (git describe --tags --exact-match HEAD || git rev-parse --short HEAD) | sed 's/\(.*\)-\(.*\)/\1.\2/g' )" >> "$GITHUB_ENV"
+
+    - name: Set NAME_PREFIX
+      shell: bash
+      run: echo "NAME_PREFIX=limboai+${LIMBOAI_VERSION}.godot-${GODOT_VERSION}" >> "$GITHUB_ENV"
+
+    - name: Set GODOT_VERSION_STATUS & BUILD_NAME
+      shell: bash
+      run: |
+        echo "GODOT_VERSION_STATUS=limboai+${LIMBOAI_VERSION}" >> "$GITHUB_ENV"
+        echo "BUILD_NAME=gha" >> "$GITHUB_ENV"

.github/actions/setup-linux-toolchain/action.yml

@@ -0,0 +1,58 @@
+name: Setup Linux toolchain
+
+inputs:
+  arch:
+    required: true
+
+runs:
+  using: "composite"
+  steps:
+    - name: Set up environment
+      shell: bash
+      run: |
+        # ! Settings:
+        TOOLCHAIN_64_URL=https://github.com/godotengine/buildroot/releases/download/godot-2020.11.x-2/x86_64-godot-linux-gnu_sdk-buildroot.tar.bz2
+        TOOLCHAIN_64_SHA=16c8302fcb676c1f0fb9df73d6cff250ba1f4286
+        TOOLCHAIN_32_URL=https://github.com/godotengine/buildroot/releases/download/godot-2020.11.x-2/i686-godot-linux-gnu_sdk-buildroot.tar.bz2
+        TOOLCHAIN_32_SHA=6171652abc54ef219e5187bc53660ee4e2f796f4
+        TOOLCHAIN_ARM64_URL=https://github.com/godotengine/buildroot/releases/download/godot-2023.08.x-3/aarch64-godot-linux-gnu_sdk-buildroot.tar.bz2
+        TOOLCHAIN_ARM64_SHA=73bed3d26b92c8b9a93c0ceb6bcce8fe567d1764
+        TOOLCHAIN_ARM32_URL=https://github.com/godotengine/buildroot/releases/download/godot-2023.08.x-3/arm-godot-linux-gnueabihf_sdk-buildroot.tar.bz2
+        TOOLCHAIN_ARM32_SHA=aa5853fd73faec3837c6127649471275d7e61cb2
+
+        # ! Export variables:
+        if [[ "${{ inputs.arch }}" == "x86_64" ]]; then
+          echo "TOOLCHAIN_URL=${TOOLCHAIN_64_URL}" >> "$GITHUB_ENV"
+          echo "TOOLCHAIN_SHA=${TOOLCHAIN_64_SHA}" >> "$GITHUB_ENV"
+        elif [[ "${{ inputs.arch }}" == "x86_32" ]]; then
+          echo "TOOLCHAIN_URL=${TOOLCHAIN_32_URL}" >> "$GITHUB_ENV"
+          echo "TOOLCHAIN_SHA=${TOOLCHAIN_32_SHA}" >> "$GITHUB_ENV"
+        elif [[ "${{ inputs.arch }}" == "arm64" ]]; then
+          echo "TOOLCHAIN_URL=${TOOLCHAIN_ARM64_URL}" >> "$GITHUB_ENV"
+          echo "TOOLCHAIN_SHA=${TOOLCHAIN_ARM64_SHA}" >> "$GITHUB_ENV"
+        elif [[ "${{ inputs.arch }}" == "arm32" ]]; then
+          echo "TOOLCHAIN_URL=${TOOLCHAIN_ARM32_URL}" >> "$GITHUB_ENV"
+          echo "TOOLCHAIN_SHA=${TOOLCHAIN_ARM32_SHA}" >> "$GITHUB_ENV"
+        fi
+
+    - name: Cache buildroot
+      id: cache-buildroot
+      uses: actions/cache@v4
+      with:
+        path: buildroot
+        key: ${{env.TOOLCHAIN_SHA}}
+
+    - name: Set up buildroot
+      if: steps.cache-buildroot.outputs.cache-hit != 'true'
+      shell: bash
+      run: |
+        mkdir buildroot
+        wget ${TOOLCHAIN_URL} -O buildroot/buildroot.tar.bz2
+        cd buildroot
+        echo "${TOOLCHAIN_SHA}  buildroot.tar.bz2"
+        echo "${TOOLCHAIN_SHA}  buildroot.tar.bz2" | shasum --check
+        tar -xjf buildroot.tar.bz2 --strip-components=1
+        ls -l
+        rm buildroot.tar.bz2
+        ./relocate-sdk.sh
+        cd ..

.github/workflows/all_builds.yml

@@ -0,0 +1,127 @@
+name: 🔗 All builds
+on:
+  workflow_dispatch:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+        default: master
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+      godot-cpp-ref:
+        description: A tag, branch or commit hash in the godot-cpp repository.
+        type: string
+        default: master
+
+jobs:
+  cache-sha:
+    name: Cache SHA
+    runs-on: ubuntu-latest
+    outputs:
+      godot-sha: ${{ steps.cache-sha.outputs.godot-sha }}
+      limboai-sha: ${{ steps.cache-sha.outputs.limboai-sha }}
+    steps:
+      - name: Clone Godot
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot
+          ref: ${{ inputs.godot-ref }}
+
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          path: modules/limboai
+          ref: ${{ inputs.limboai-ref }}
+
+      - name: Cache SHA
+        id: cache-sha
+        run: |
+          echo "godot-sha=$(git describe --tags --exact-match HEAD || git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
+          cd modules/limboai
+          echo "limboai-sha=$(git describe --tags --exact-match HEAD || git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
+
+  android-build:
+    name: 🤖 Android
+    needs: cache-sha
+    uses: ./.github/workflows/android.yml
+    with:
+      godot-ref: ${{ needs.cache-sha.outputs.godot-sha }}
+      limboai-ref: ${{ needs.cache-sha.outputs.limboai-sha }}
+
+  ios-build:
+    name: 🍏 iOS
+    needs: cache-sha
+    uses: ./.github/workflows/ios.yml
+    with:
+      godot-ref: ${{ needs.cache-sha.outputs.godot-sha }}
+      limboai-ref: ${{ needs.cache-sha.outputs.limboai-sha }}
+
+  linux-build:
+    name: 🐧 Linux
+    needs: cache-sha
+    uses: ./.github/workflows/linux.yml
+    with:
+      godot-ref: ${{ needs.cache-sha.outputs.godot-sha }}
+      limboai-ref: ${{ needs.cache-sha.outputs.limboai-sha }}
+      test-build: false
+
+  macos-build:
+    name: 🍎 macOS
+    needs: cache-sha
+    uses: ./.github/workflows/macos.yml
+    with:
+      godot-ref: ${{ needs.cache-sha.outputs.godot-sha }}
+      limboai-ref: ${{ needs.cache-sha.outputs.limboai-sha }}
+
+  windows-build:
+    name: 🪟 Windows
+    needs: cache-sha
+    uses: ./.github/workflows/windows.yml
+    with:
+      godot-ref: ${{ needs.cache-sha.outputs.godot-sha }}
+      limboai-ref: ${{ needs.cache-sha.outputs.limboai-sha }}
+      test-build: false
+
+  web-build:
+    name: 🌐 Web
+    needs: cache-sha
+    uses: ./.github/workflows/web.yml
+    with:
+      godot-ref: ${{ needs.cache-sha.outputs.godot-sha }}
+      limboai-ref: ${{ needs.cache-sha.outputs.limboai-sha }}
+
+  gdextension:
+    name: 🔌 GDExtension
+    needs: cache-sha
+    uses: ./.github/workflows/gdextension.yml
+    with:
+      godot-cpp-ref: ${{ inputs.godot-cpp-ref }}
+      limboai-ref: ${{ needs.cache-sha.outputs.limboai-sha }}
+      test-build: false
+
+  demo:
+    name: 🎮️ Demo project
+    needs: cache-sha
+    uses: ./.github/workflows/demo.yml
+    with:
+      limboai-ref: ${{ needs.cache-sha.outputs.limboai-sha }}
+
+  merge_templates:
+    name: 📦 Merge templates
+    if: ${{ always() }}
+    needs:
+      [
+        cache-sha,
+        android-build,
+        ios-build,
+        linux-build,
+        macos-build,
+        windows-build,
+        web-build,
+      ]
+    uses: ./.github/workflows/merge_templates.yml
+    with:
+      godot-ref: ${{ needs.cache-sha.outputs.godot-sha }}
+      limboai-ref: ${{ needs.cache-sha.outputs.limboai-sha }}

.github/workflows/android.yml

@@ -0,0 +1,277 @@
+name: 🤖 Android builds
+on:
+  workflow_call:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+        default: master
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+
+  workflow_dispatch:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+        default: master
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+
+# Global Settings
+env:
+  SCONS_CACHE_LIMIT: 4096
+  SCONSFLAGS: production=yes tests=no verbose=yes warnings=extra werror=yes
+  DOTNET_NOLOGO: true
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
+
+jobs:
+  android-builds:
+    runs-on: "ubuntu-20.04"
+    name: ${{ matrix.name }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # * Standard arm64
+
+          - name: Template (arm64, debug)
+            arch: arm64
+            target: template_debug
+            dotnet: false
+
+          - name: Template (arm64, release)
+            arch: arm64
+            target: template_release
+            dotnet: false
+
+          # * Standard arm32
+
+          - name: Template (arm32, debug)
+            arch: arm32
+            target: template_debug
+            dotnet: false
+
+          - name: Template (arm32, release)
+            arch: arm32
+            target: template_release
+            dotnet: false
+
+          # * Standard x86_64
+
+          - name: Template (x86_64, debug)
+            arch: x86_64
+            target: template_debug
+            dotnet: false
+
+          - name: Template (x86_64, release)
+            arch: x86_64
+            target: template_release
+            dotnet: false
+
+          # * Standard x86_32
+
+          - name: Template (x86_32, debug)
+            arch: x86_32
+            target: template_debug
+            dotnet: false
+
+          - name: Template (x86_32, release)
+            arch: x86_32
+            target: template_release
+            dotnet: false
+
+          # * .NET arm64
+
+          - name: Template .NET (arm64, debug)
+            arch: arm64
+            target: template_debug
+            dotnet: true
+
+          - name: Template .NET (arm64, release)
+            arch: arm64
+            target: template_release
+            dotnet: true
+
+          # * .NET arm32
+
+          - name: Template .NET (arm32, debug)
+            arch: arm32
+            target: template_debug
+            dotnet: true
+
+          - name: Template .NET (arm32, release)
+            arch: arm32
+            target: template_release
+            dotnet: true
+
+          # * .NET x86_64
+
+          - name: Template .NET (x86_64, debug)
+            arch: x86_64
+            target: template_debug
+            dotnet: true
+
+          - name: Template .NET (x86_64, release)
+            arch: x86_64
+            target: template_release
+            dotnet: true
+
+          # * .NET x86_32
+
+          - name: Template .NET (x86_32, debug)
+            arch: x86_32
+            target: template_debug
+            dotnet: true
+
+          - name: Template .NET (x86_32, release)
+            arch: x86_32
+            target: template_release
+            dotnet: true
+
+    env:
+      BIN: godot.linuxbsd.${{matrix.target}}.${{matrix.arch}}${{  matrix.dotnet == true && '.mono' || ''  }}
+
+    steps:
+      - name: Clone Godot
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot
+          ref: ${{ inputs.godot-ref }}
+
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          path: modules/limboai
+          ref: ${{ inputs.limboai-ref }}
+
+      # Inits GODOT_VERSION, LIMBOAI_VERSION and NAME_PREFIX environment variables.
+      - uses: ./modules/limboai/.github/actions/init-version
+
+      - name: Set up Java 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - name: Set up scons
+        run: |
+          python -c "import sys; print(sys.version)"
+          python -m pip install scons==4.4.0
+          python --version
+          scons --version
+
+      # ! Note: we stopped using the scons cache in release builds.
+      # - name: Set up scons cache
+      #   uses: actions/cache@v4
+      #   with:
+      #     path: ${{github.workspace}}/.scons_cache/
+      #     key: ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+      #     restore-keys: |
+      #       ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+      #       ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}
+      #       ${{env.BIN}}-${{inputs.godot-ref}}
+
+      - name: Compilation
+        env:
+          SCONS_CACHE: ${{github.workspace}}/.scons_cache/
+        run: |
+          scons platform=android target=${{matrix.target}} arch=${{matrix.arch}} module_mono_enabled=${{matrix.dotnet}} ${{env.SCONSFLAGS}}
+          ls platform/android/java/lib/libs/*
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: tmp-android${{matrix.dotnet == true && '-dotnet' || ''}}-templates-${{strategy.job-index}}
+          path: platform/android/java/lib/libs/*
+
+  make-android-package:
+    runs-on: "ubuntu-20.04"
+    needs: android-builds
+    name: ${{ matrix.name }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Package Android templates
+            dotnet: false
+          - name: Package Android .NET templates
+            dotnet: true
+
+    steps:
+      - name: Clone Godot
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot
+          ref: ${{ inputs.godot-ref }}
+
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          path: modules/limboai
+          ref: ${{ inputs.limboai-ref }}
+
+      # Inits GODOT_VERSION, LIMBOAI_VERSION and NAME_PREFIX environment variables.
+      - uses: ./modules/limboai/.github/actions/init-version
+
+      - name: Download Android template builds
+        uses: actions/download-artifact@v4
+        with:
+          pattern: tmp-android${{matrix.dotnet == true && '-dotnet' || ''}}-templates-*
+          merge-multiple: true
+          path: platform/android/java/lib/libs/
+
+      - name: Set up Java 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - name: Set up Python 3.x
+        uses: actions/setup-python@v5
+        with:
+          python-version: 3.x
+          architecture: x64
+
+      - name: Set up scons
+        run: |
+          python -c "import sys; print(sys.version)"
+          python -m pip install scons==4.4.0
+          python --version
+          scons --version
+
+      - name: Generate Godot templates
+        run: |
+          cd platform/android/java
+          ./gradlew generateGodotTemplates
+          cd ../../..
+          ls -l bin/
+
+          mkdir -p out/templates/
+          mv bin/android_* out/templates/
+          echo "${GODOT_VERSION}.limboai+${LIMBOAI_VERSION}${{matrix.dotnet == true && '.mono' || ''}}" > out/templates/version.txt
+          ls -l out/*
+
+      - name: Delete Android template builds
+        uses: geekyeggo/delete-artifact@v5
+        with:
+          name: tmp-android${{matrix.dotnet == true && '-dotnet' || ''}}-templates-*
+          useGlob: true
+          failOnError: false
+
+      - name: Upload Android libs
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{env.NAME_PREFIX}}${{matrix.dotnet == true && '.dotnet' || ''}}.android-lib
+          path: bin/godot-lib.*
+
+      - name: Upload Android templates
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{env.NAME_PREFIX}}${{matrix.dotnet == true && '.dotnet' || ''}}.export-templates.android
+          path: out/*

.github/workflows/demo.yml

@@ -0,0 +1,46 @@
+name: 🎮️ Demo project
+on:
+  workflow_call:
+    inputs:
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+
+  workflow_dispatch:
+    inputs:
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+
+jobs:
+  package-demo:
+    runs-on: ubuntu-latest
+    name: Package demo
+
+    steps:
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          fetch-tags: true
+          ref: ${{ inputs.limboai-ref }}
+
+      - name: Init version
+        run: echo "LIMBOAI_VERSION=$( (git describe --tags --exact-match HEAD || git rev-parse --short HEAD) | sed 's/\(.*\)-\(.*\)/\1.\2/g' )" >> "$GITHUB_ENV"
+
+      - name: Prepare artifact
+        shell: bash
+        run: |
+          cp {README,LICENSE}.md demo/
+          mkdir -p demo/addons/limboai/
+          cp -R icons/ demo/addons/limboai/icons
+          echo "${LIMBOAI_VERSION}" > demo/version.txt
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        env:
+          NAME: limboai+${{env.LIMBOAI_VERSION}}.demo-project
+        with:
+          name: ${{ env.NAME }}
+          path: demo/*

.github/workflows/gdextension.yml

@@ -0,0 +1,386 @@
+name: 🔌 GDExtension
+on:
+  workflow_call:
+    inputs:
+      godot-cpp-ref:
+        description: A tag, branch or commit hash in the godot-cpp repository.
+        type: string
+        default: godot-4.3-stable
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+      test-build:
+        description: Limit to pre-defined test builds
+        type: boolean
+        default: false
+      debug-symbols:
+        description: Build with debug symbols
+        type: boolean
+        default: false
+
+  workflow_dispatch:
+    inputs:
+      godot-cpp-ref:
+        description: A tag, branch or commit hash in the godot-cpp repository.
+        type: string
+        default: godot-4.3-stable
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+      test-build:
+        description: Limit to pre-defined test builds
+        type: boolean
+        default: false
+      debug-symbols:
+        description: Build with debug symbols
+        type: boolean
+        default: false
+
+# Global Settings
+env:
+  SCONS_CACHE_LIMIT: 4096
+  SCONSFLAGS: use_mingw=yes dev_build=no
+  EM_VERSION: 3.1.45
+  EM_CACHE_FOLDER: "emsdk-cache"
+  GODOT_VERSION: 4.4-beta3
+  GODOT_REPO: godotengine/godot-builds
+
+jobs:
+  gdextension:
+    runs-on: ${{ matrix.opts.runner }}
+    name: ${{ matrix.opts.name }}
+    outputs:
+      name-prefix: ${{ steps.output-name-prefix.outputs.name-prefix }}
+    strategy:
+      fail-fast: false
+      matrix:
+        opts:
+          - name: 🐧 Linux (x86_64, release)
+            runner: ubuntu-20.04
+            platform: linux
+            target: template_release
+            arch: x86_64
+            should-build: true
+
+          - name: 🐧 Linux (x86_64, debug)
+            runner: ubuntu-20.04
+            platform: linux
+            target: editor
+            arch: x86_64
+            should-build: true
+
+          - name: 🪟 Windows (x86_64, release)
+            runner: windows-latest
+            platform: windows
+            target: template_release
+            arch: x86_64
+            should-build: true
+
+          - name: 🪟 Windows (x86_64, debug)
+            runner: windows-latest
+            platform: windows
+            target: editor
+            arch: x86_64
+            should-build: true
+
+          - name: 🍎 macOS (universal, release)
+            runner: macos-latest
+            platform: macos
+            target: template_release
+            arch: universal
+            should-build: true
+
+          - name: 🍎 macOS (universal, debug)
+            runner: macos-latest
+            platform: macos
+            target: editor
+            arch: universal
+            should-build: true
+
+          - name: 🌐 Web (wasm32, release)
+            runner: ubuntu-20.04
+            platform: web
+            target: template_release
+            arch: wasm32
+            should-build: ${{ !inputs.test-build }}
+
+          - name: 🌐 Web (wasm32, debug)
+            runner: ubuntu-20.04
+            platform: web
+            target: editor
+            arch: wasm32
+            should-build: ${{ !inputs.test-build }}
+
+          - name: 🤖 Android (arm64, release)
+            runner: ubuntu-20.04
+            platform: android
+            target: template_release
+            arch: arm64
+            should-build: ${{ !inputs.test-build }}
+
+          - name: 🤖 Android (arm64, debug)
+            runner: ubuntu-20.04
+            platform: android
+            target: editor
+            arch: arm64
+            should-build: ${{ !inputs.test-build }}
+
+          - name: 🤖 Android (arm32, release)
+            runner: ubuntu-20.04
+            platform: android
+            target: template_release
+            arch: arm32
+            should-build: ${{ !inputs.test-build }}
+
+          - name: 🤖 Android (arm32, debug)
+            runner: ubuntu-20.04
+            platform: android
+            target: editor
+            arch: arm32
+            should-build: ${{ !inputs.test-build }}
+
+          - name: 🤖 Android (x86_64, release)
+            runner: ubuntu-20.04
+            platform: android
+            target: template_release
+            arch: x86_64
+            should-build: ${{ !inputs.test-build }}
+
+          - name: 🤖 Android (x86_64, debug)
+            runner: ubuntu-20.04
+            platform: android
+            target: editor
+            arch: x86_64
+            should-build: ${{ !inputs.test-build }}
+
+          - name: 🤖 Android (x86_32, release)
+            runner: ubuntu-20.04
+            platform: android
+            target: template_release
+            arch: x86_32
+            should-build: ${{ !inputs.test-build }}
+
+          - name: 🤖 Android (x86_32, debug)
+            runner: ubuntu-20.04
+            platform: android
+            target: editor
+            arch: x86_32
+            should-build: ${{ !inputs.test-build }}
+
+          - name: 🍏 iOS (arm64, release)
+            runner: macos-latest
+            platform: ios
+            target: template_release
+            arch: arm64
+            should-build: ${{ !inputs.test-build }}
+
+          - name: 🍏 iOS (arm64, debug)
+            runner: macos-latest
+            platform: ios
+            target: editor
+            arch: arm64
+            should-build: ${{ !inputs.test-build }}
+
+          - name: 🍏 iOS (simulator, release)
+            runner: macos-latest
+            platform: ios
+            target: template_release
+            arch: universal
+            scons-flags: ios_simulator=yes
+            should-build: ${{ !inputs.test-build }}
+
+          - name: 🍏 iOS (simulator, debug)
+            runner: macos-latest
+            platform: ios
+            target: editor
+            arch: universal
+            scons-flags: ios_simulator=yes
+            should-build: ${{ !inputs.test-build }}
+
+        exclude:
+          - { opts: { should-build: false } }
+
+    env:
+      BIN: liblimboai.${{matrix.opts.platform}}.${{matrix.opts.target}}.${{matrix.opts.arch}}
+
+    steps:
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          fetch-tags: true
+          ref: ${{ inputs.limboai-ref }}
+
+      - name: Clone godot-cpp
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot-cpp
+          fetch-tags: true
+          path: godot-cpp
+          ref: ${{ inputs.godot-cpp-ref }}
+
+      # Inits GDEXTENSION_VERSION, LIMBOAI_VERSION and NAME_PREFIX environment variables.
+      - uses: ./.github/actions/init-version-gdext
+
+      - name: Output NAME_PREFIX
+        id: output-name-prefix
+        run: echo "name-prefix=${NAME_PREFIX}" >> $GITHUB_OUTPUT
+
+      - name: Setup Linux toolchain
+        if: matrix.opts.platform == 'linux'
+        uses: ./.github/actions/setup-linux-toolchain
+        with:
+          arch: ${{matrix.opts.arch}}
+
+      - name: Set up Python 3.x
+        if: matrix.opts.platform == 'windows' || matrix.opts.platform == 'macos'
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+          architecture: "x64"
+
+      - name: Set up Emscripten cache
+        if: matrix.opts.platform == 'web'
+        uses: actions/cache@v4
+        with:
+          path: ${{env.EM_CACHE_FOLDER}}
+          key: ${{env.EM_VERSION}}-${{runner.os}}-libs
+
+      - name: Set up Emscripten
+        if: matrix.opts.platform == 'web'
+        uses: mymindstorm/setup-emsdk@v14
+        with:
+          version: ${{env.EM_VERSION}}
+          actions-cache-folder: ${{env.EM_CACHE_FOLDER}}
+
+      - name: Verify Emscripten setup
+        if: matrix.opts.platform == 'web'
+        run: |
+          emcc -v
+
+      - name: Set up scons
+        if: matrix.opts.platform != 'linux'
+        run: |
+          python -c "import sys; print(sys.version)"
+          python -m pip install scons==4.4.0
+          python --version
+          scons --version
+
+      - name: Set up Java 17
+        if: matrix.opts.platform == 'android'
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - uses: nttld/setup-ndk@v1
+        if: matrix.opts.platform == 'android'
+        id: setup-ndk
+        with:
+          ndk-version: r23c
+          link-to-sdk: true
+
+      - name: Set up MSVC problem matcher on Windows
+        if: matrix.opts.platform == 'windows'
+        uses: ammaraskar/msvc-problem-matcher@master
+
+      - name: Set up scons cache
+        if: inputs.test-build # ! Only cache test/PR builds
+        uses: actions/cache@v4
+        with:
+          path: ${{github.workspace}}/.scons_cache/
+          key: ${{env.BIN}}-${{inputs.debug-symbols}}-${{inputs.godot-cpp-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+          restore-keys: |
+            ${{env.BIN}}-${{inputs.debug-symbols}}-${{inputs.godot-cpp-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+            ${{env.BIN}}-${{inputs.debug-symbols}}-${{inputs.godot-cpp-ref}}-${{inputs.limboai-ref}}
+            ${{env.BIN}}-${{inputs.debug-symbols}}-${{inputs.godot-cpp-ref}}
+
+      - name: Compilation
+        shell: bash
+        env:
+          SCONS_CACHE: ${{github.workspace}}/.scons_cache/
+          DEBUG_FLAGS: ${{ inputs.debug-symbols && 'debug_symbols=yes symbols_visibility=visible' || 'debug_symbols=no' }}
+        run: |
+          PATH=${GITHUB_WORKSPACE}/buildroot/bin:$PATH
+          scons platform=${{matrix.opts.platform}} target=${{matrix.opts.target}} arch=${{matrix.opts.arch}} ${{env.DEBUG_FLAGS}} ${{matrix.opts.scons-flags}} ${{env.SCONSFLAGS}}
+
+      - name: Prepare artifact
+        shell: bash
+        run: |
+          ls -R demo/addons/limboai/
+          mkdir out
+          mv demo/addons/ out/
+          cp {README,LICENSE,LOGO_LICENSE}.md out/addons/limboai/
+          cp -R demo/demo/ out/demo/
+          cp demo/LICENSE_ASSETS.md out/demo/
+          rm -f out/addons/limboai/bin/*.{exp,lib,pdb}
+          echo "${LIMBOAI_VERSION}" > out/addons/limboai/version.txt
+          echo "---"
+          ls -R out/
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        env:
+          NAME: tmp-gdextension.${{matrix.opts.platform}}.${{matrix.opts.target}}.${{matrix.opts.arch}}
+        with:
+          name: ${{ env.NAME }}
+          path: out/*
+
+  package-extension:
+    name: 📦 Package extension
+    runs-on: ubuntu-latest
+    needs: gdextension
+
+    steps:
+      - name: Merge artifacts
+        uses: actions/upload-artifact/merge@v4
+        with:
+          name: ${{needs.gdextension.outputs.name-prefix}}
+          pattern: tmp-gdextension.*
+          delete-merged: true
+
+      - name: Download artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{needs.gdextension.outputs.name-prefix}}
+          path: out/
+
+      - name: Setup Godot
+        shell: bash
+        run: |
+          echo "Downloading Godot ${GODOT_VERSION}"
+          mkdir bin
+          cd bin
+          wget "https://github.com/${GODOT_REPO}/releases/download/${GODOT_VERSION}/Godot_v${GODOT_VERSION}_linux.x86_64.zip" -O godot.zip
+          unzip godot.zip
+          rm godot.zip
+          mv Godot_* godot
+          chmod u+x godot
+          ls -l
+          cd ..
+          ./bin/godot --version
+
+      - name: Generate icon .import files
+        shell: bash
+        run: |
+          touch out/project.godot
+          timeout 20s ./bin/godot --headless --editor --path ./out/ || /bin/true
+          rm out/project.godot
+          rm -rf out/.godot/
+
+      - name: Change editor icon import settings
+        shell: bash
+        run: |
+          echo "--- Listing icons dir:"
+          ls out/addons/limboai/icons/
+          echo "--- (end of listing)"
+          sed -i 's|editor/scale_with_editor_scale=false|editor/scale_with_editor_scale=true|' out/addons/limboai/icons/*.import
+          sed -i 's|editor/convert_colors_with_editor_theme=false|editor/convert_colors_with_editor_theme=true|' out/addons/limboai/icons/*.import
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{needs.gdextension.outputs.name-prefix}}
+          path: out/*
+          overwrite: true

.github/workflows/ios.yml

@@ -0,0 +1,255 @@
+name: 🍏 iOS builds
+on:
+  workflow_call:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+        default: master
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+
+  workflow_dispatch:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+        default: master
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+
+# Global Settings
+env:
+  SCONS_CACHE_LIMIT: 4096
+  SCONSFLAGS: production=yes tests=no verbose=yes warnings=extra
+  DOTNET_NOLOGO: true
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
+
+jobs:
+  ios-builds:
+    runs-on: "macos-latest"
+    name: ${{ matrix.name }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Template (arm64, release)
+            target: template_release
+            arch: arm64
+            ios_simulator: false
+            dotnet: false
+
+          - name: Template (arm64, debug)
+            target: template_debug
+            arch: arm64
+            ios_simulator: false
+            dotnet: false
+
+          - name: Simulator (x86_64, release)
+            target: template_release
+            arch: x86_64
+            ios_simulator: true
+            dotnet: false
+
+          - name: Simulator (x86_64, debug)
+            target: template_debug
+            arch: x86_64
+            ios_simulator: true
+            dotnet: false
+
+          # ! Disabled for now as it doesn't work with cctools-port and current LLVM.
+          # * See https://github.com/godotengine/build-containers/pull/85.
+          # - name: Simulator Lib (arm64, release)
+          #   target: template_release
+          #   arch: arm64
+          #   ios_simulator: true
+
+          # - name: Simulator Lib (arm64, debug)
+          #   target: template_debug
+          #   arch: arm64
+          #   ios_simulator: true
+
+          - name: Template .NET (arm64, release)
+            target: template_release
+            arch: arm64
+            ios_simulator: false
+            dotnet: true
+
+          - name: Template .NET (arm64, debug)
+            target: template_debug
+            arch: arm64
+            ios_simulator: false
+            dotnet: true
+
+          - name: Simulator .NET (x86_64, release)
+            target: template_release
+            arch: x86_64
+            ios_simulator: true
+            dotnet: true
+
+          - name: Simulator .NET (x86_64, debug)
+            target: template_debug
+            arch: x86_64
+            ios_simulator: true
+            dotnet: true
+
+    env:
+      BIN: godot.ios.${{matrix.target}}.${{matrix.arch}}${{  matrix.dotnet == true && '.mono' || ''  }}
+
+    steps:
+      - name: Clone Godot
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot
+          ref: ${{ inputs.godot-ref }}
+
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          path: modules/limboai
+          ref: ${{ inputs.limboai-ref }}
+
+      # Inits GODOT_VERSION, LIMBOAI_VERSION and NAME_PREFIX environment variables.
+      - uses: ./modules/limboai/.github/actions/init-version
+
+      - name: Set up Python 3.x
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+          architecture: "x64"
+
+      - name: Set up scons
+        run: |
+          python -c "import sys; print(sys.version)"
+          python -m pip install scons==4.4.0
+
+      - name: Diagnostics
+        run: |
+          python --version
+          scons --version
+          dotnet --info
+
+      - name: Set up Vulkan SDK
+        run: |
+          # ! Note: Vulkan SDK changed packaging, so we need to inline these steps for the time being.
+          #sh misc/scripts/install_vulkan_sdk_macos.sh
+
+          curl -L "https://sdk.lunarg.com/sdk/download/latest/mac/vulkan-sdk.zip" -o /tmp/vulkan-sdk.zip
+          unzip /tmp/vulkan-sdk.zip -d /tmp
+          /tmp/InstallVulkan.app/Contents/MacOS/InstallVulkan --accept-licenses --default-answer --confirm-command install
+          rm -Rf /tmp/InstallVulkan.app
+          rm -f /tmp/vulkan-sdk.zip
+
+      # ! Note: we stopped using the scons cache in release builds.
+      # - name: Set up scons cache
+      #   uses: actions/cache@v4
+      #   with:
+      #     path: ${{github.workspace}}/.scons_cache/
+      #     key: ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+      #     restore-keys: |
+      #       ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+      #       ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}
+      #       ${{env.BIN}}-${{inputs.godot-ref}}
+
+      - name: Compilation
+        env:
+          SCONS_CACHE: ${{github.workspace}}/.scons_cache/
+        run: |
+          scons platform=ios target=${{matrix.target}} arch=${{matrix.arch}} ios_simulator=${{matrix.ios_simulator}} module_mono_enabled=${{matrix.dotnet}} ${{env.SCONSFLAGS}}
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: tmp-ios${{matrix.dotnet == true && '-dotnet' || ''}}-templates-${{strategy.job-index}}
+          path: bin/*
+
+  package-ios-templates:
+    runs-on: "macos-latest"
+    name: ${{ matrix.name }}
+    needs: ios-builds
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Package iOS templates
+            dotnet: false
+          - name: Package iOS .NET templates
+            dotnet: true
+
+    steps:
+      - name: Clone Godot
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot
+          ref: ${{ inputs.godot-ref }}
+
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          path: modules/limboai
+          ref: ${{ inputs.limboai-ref }}
+
+      # Inits GODOT_VERSION, LIMBOAI_VERSION and NAME_PREFIX environment variables.
+      - uses: ./modules/limboai/.github/actions/init-version
+
+      - name: Set up Vulkan SDK
+        run: |
+          # ! Note: Vulkan SDK changed packaging, so we need to inline these steps for the time being.
+          #sh misc/scripts/install_vulkan_sdk_macos.sh
+
+          curl -L "https://sdk.lunarg.com/sdk/download/latest/mac/vulkan-sdk.zip" -o /tmp/vulkan-sdk.zip
+          unzip /tmp/vulkan-sdk.zip -d /tmp
+          /tmp/InstallVulkan.app/Contents/MacOS/InstallVulkan --accept-licenses --default-answer --confirm-command install
+          rm -Rf /tmp/InstallVulkan.app
+          rm -f /tmp/vulkan-sdk.zip
+
+      - name: Download templates artifact
+        uses: actions/download-artifact@v4
+        with:
+          pattern: tmp-ios${{matrix.dotnet == true && '-dotnet' || ''}}-templates-*
+          merge-multiple: true
+          path: bin/
+
+      - name: Make template bundle
+        run: |
+          ls bin/
+          cp -r misc/dist/ios_xcode bin/
+          cd bin/
+
+          mv libgodot.ios.template_debug.arm64.a ios_xcode/libgodot.ios.debug.xcframework/ios-arm64/libgodot.a
+          # ! lipo -create libgodot.ios.template_debug.arm64.simulator.a libgodot.ios.template_debug.x86_64.simulator.a -output ios_xcode/libgodot.ios.debug.xcframework/ios-arm64_x86_64-simulator/libgodot.a
+          mv libgodot.ios.template_debug.x86_64.simulator.a ios_xcode/libgodot.ios.debug.xcframework/ios-arm64_x86_64-simulator/libgodot.a
+
+          mv libgodot.ios.template_release.arm64.a ios_xcode/libgodot.ios.release.xcframework/ios-arm64/libgodot.a
+          # ! lipo -create libgodot.ios.template_release.arm64.simulator.a libgodot.ios.template_release.x86_64.simulator.a -output ios_xcode/libgodot.ios.release.xcframework/ios-arm64_x86_64-simulator/libgodot.a
+          mv libgodot.ios.template_release.x86_64.simulator.a ios_xcode/libgodot.ios.release.xcframework/ios-arm64_x86_64-simulator/libgodot.a
+
+          cp -r ~/VulkanSDK/*/macOS/lib/MoltenVK.xcframework ios_xcode
+          rm -rf ios_xcode/MoltenVK.xcframework/{macos,tvos}*
+
+          mkdir -p ${{github.workspace}}/out/templates/
+          cd ios_xcode
+          zip -q -9 -r ${{github.workspace}}/out/templates/ios.zip *
+
+          echo "${GODOT_VERSION}.limboai+${LIMBOAI_VERSION}${{matrix.dotnet == true && '.mono' || ''}}" > ${{github.workspace}}/out/templates/version.txt
+
+          ls -l ${{github.workspace}}/out/*
+
+      - name: Upload template bundle
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{env.NAME_PREFIX}}${{matrix.dotnet == true && '.dotnet' || ''}}.export-templates.ios
+          path: out/*
+
+      - name: Delete templates artifact
+        uses: geekyeggo/delete-artifact@v5
+        with:
+          name: tmp-ios${{matrix.dotnet == true && '-dotnet' || ''}}-templates-*
+          useGlob: true
+          failOnError: false

.github/workflows/linux.yml

@@ -0,0 +1,289 @@
+name: 🐧 Linux builds
+on:
+  workflow_call:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+        default: master
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+      test-build:
+        description: Limit to pre-defined test builds
+        type: boolean
+        default: false
+
+  workflow_dispatch:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+        default: master
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+      test-build:
+        description: Limit to pre-defined test builds
+        type: boolean
+        default: false
+
+# Global Settings
+env:
+  SCONS_CACHE_LIMIT: 4096
+  SCONSFLAGS: production=yes tests=no verbose=yes warnings=extra werror=yes
+  DOTNET_NOLOGO: true
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
+
+jobs:
+  linux-builds:
+    runs-on: "ubuntu-20.04"
+    name: ${{ matrix.opts.name }}
+    strategy:
+      fail-fast: false
+      matrix:
+        opts:
+          # * Standard x86_64
+
+          - name: Editor (x86_64, release)
+            target: editor
+            arch: x86_64
+            dotnet: false
+            should-build: true
+
+          - name: Template (x86_64, release)
+            target: template_release
+            arch: x86_64
+            dotnet: false
+            should-build: true
+
+          - name: Template (x86_64, debug)
+            target: template_debug
+            arch: x86_64
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          # * Standard x86_32
+
+          # - name: Editor (x86_32, release)
+          #   target: editor
+          #   arch: x86_32
+          #   dotnet: false
+          #   should-build: ${{ !inputs.test-build }}
+
+          - name: Template (x86_32, release)
+            target: template_release
+            arch: x86_32
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template (x86_32, debug)
+            target: template_debug
+            arch: x86_32
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          # * Standard arm64
+
+          - name: Editor (arm64, release)
+            target: editor
+            arch: arm64
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template (arm64, release)
+            target: template_release
+            arch: arm64
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template (arm64, debug)
+            target: template_debug
+            arch: arm64
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          # * Standard arm32
+
+          - name: Template (arm32, release)
+            target: template_release
+            arch: arm32
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template (arm32, debug)
+            target: template_debug
+            arch: arm32
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          # * .NET x86_64
+
+          - name: Editor .NET (x86_64, release)
+            target: editor
+            arch: x86_64
+            dotnet: true
+            should-build: true
+
+          - name: Template .NET (x86_64, release)
+            target: template_release
+            arch: x86_64
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template .NET (x86_64, debug)
+            target: template_debug
+            arch: x86_64
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          # * .NET x86_32
+
+          # - name: Editor .NET (x86_32, release)
+          #   target: editor
+          #   arch: x86_32
+          #   dotnet: true
+          #   should-build: ${{ !inputs.test-build }}
+
+          - name: Template .NET (x86_32, release)
+            target: template_release
+            arch: x86_32
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template .NET (x86_32, debug)
+            target: template_debug
+            arch: x86_32
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          # * .NET arm64
+
+          # ! FIXME: Needs a separate job for .NET glue generation since we can't execute arm64 binaries on x86_64.
+          # !        Alternatively, solution generation can be done as post-process job, taking the glue from x86_64, after all builds complete.
+          # - name: Editor .NET (arm64, release)
+          #   target: editor
+          #   arch: arm64
+          #   dotnet: true
+          #   should-build: ${{ !inputs.test-build }}
+
+          - name: Template .NET (arm64, release)
+            target: template_release
+            arch: arm64
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template .NET (arm64, debug)
+            target: template_debug
+            arch: arm64
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          # * .NET arm32
+
+          - name: Template .NET (arm32, release)
+            target: template_release
+            arch: arm32
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template .NET (arm32, debug)
+            target: template_debug
+            arch: arm32
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+        exclude:
+          - { opts: { should-build: false } }
+
+    env:
+      BIN: godot.linuxbsd.${{matrix.opts.target}}.${{matrix.opts.arch}}${{  matrix.opts.dotnet == true && '.mono' || ''  }}
+
+    steps:
+      - name: Clone Godot
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot
+          ref: ${{ inputs.godot-ref }}
+
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          path: modules/limboai
+          ref: ${{ inputs.limboai-ref }}
+
+      # Inits GODOT_VERSION, LIMBOAI_VERSION and NAME_PREFIX environment variables.
+      - uses: ./modules/limboai/.github/actions/init-version
+
+      - name: Set up Linux toolchain
+        uses: ./modules/limboai/.github/actions/setup-linux-toolchain
+        with:
+          arch: ${{matrix.opts.arch}}
+
+      - name: Set up Wayland deps
+        run: |
+          sudo apt-get install libwayland-dev
+
+      - name: Set up scons cache
+        if: inputs.test-build # ! Only cache test/PR builds
+        uses: actions/cache@v4
+        with:
+          path: ${{github.workspace}}/.scons_cache/
+          key: ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+          restore-keys: |
+            ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+            ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}
+            ${{env.BIN}}-${{inputs.godot-ref}}
+
+      - name: Compilation
+        env:
+          SCONS_CACHE: ${{github.workspace}}/.scons_cache/
+        run: |
+          PATH=${GITHUB_WORKSPACE}/buildroot/bin:$PATH
+          scons platform=linuxbsd target=${{matrix.opts.target}} arch=${{matrix.opts.arch}} module_mono_enabled=${{matrix.opts.dotnet}} ${{env.SCONSFLAGS}}
+
+      - name: Build .NET assemblies
+        if: matrix.opts.dotnet && matrix.opts.target == 'editor'
+        uses: ./modules/limboai/.github/actions/build-dotnet-assemblies
+        with:
+          platform: linuxbsd
+          bin: ${{env.BIN}}
+
+      - name: Prepare artifact
+        env:
+          OUTDIR: ${{ startsWith(matrix.opts.target, 'template') && 'out/templates' || 'out/' }}
+        run: |
+          chmod +x ./bin/godot.*
+          mkdir -p ${{env.OUTDIR}}
+          mv bin/* ${{env.OUTDIR}}
+          ls -R out/
+
+      # Zipping the editor artifact to retain executable bit;
+      # workaround for: https://github.com/actions/upload-artifact/issues/38
+      - name: Zip the editor artifact
+        if: matrix.opts.target == 'editor'
+        shell: bash
+        run: |
+          pushd out/
+          zip -r godot-limboai.editor.linux.zip *
+          rm godot.*
+          rm -rf GodotSharp/
+          echo -e "## Why another ZIP inside?\n\nWorkaround for: https://github.com/actions/upload-artifact/issues/38\n" > README.md
+          popd
+
+      - name: Rename templates
+        if: startsWith(matrix.opts.target, 'template')
+        env:
+          BUILD_TYPE: ${{ endsWith(matrix.opts.target, 'release') && 'release' || 'debug' }}
+        run: |
+          mv out/templates/${BIN} out/templates/linux_${BUILD_TYPE}.${{matrix.opts.arch}}
+          echo "${GODOT_VERSION}.limboai+${LIMBOAI_VERSION}${{matrix.opts.dotnet == true && '.mono' || ''}}" > out/templates/version.txt
+          ls -R out/
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{env.NAME_PREFIX}}${{matrix.opts.dotnet == true && '.dotnet' || ''}}.${{matrix.opts.target}}.linux.${{matrix.opts.arch}}
+          path: out/*

.github/workflows/macos.yml

@@ -0,0 +1,320 @@
+name: 🍎 macOS builds
+on:
+  workflow_call:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+        default: master
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+      test-build:
+        description: Limit to pre-defined test builds
+        type: boolean
+        default: false
+
+  workflow_dispatch:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+        default: master
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+      test-build:
+        description: Limit to pre-defined test builds
+        type: boolean
+        default: false
+
+# Global Settings
+env:
+  SCONS_CACHE_LIMIT: 4096
+  SCONSFLAGS: production=yes tests=no verbose=yes warnings=extra
+  DOTNET_NOLOGO: true
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
+
+jobs:
+  macos-builds:
+    runs-on: "macos-latest"
+    name: ${{ matrix.opts.name }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        opts:
+          - name: Editor (x86_64, release)
+            target: editor
+            arch: x86_64
+            dotnet: false
+            should-build: true
+
+          - name: Template (x86_64, release)
+            target: template_release
+            arch: x86_64
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template (x86_64, debug)
+            target: template_debug
+            arch: x86_64
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Editor (arm64, release)
+            target: editor
+            arch: arm64
+            dotnet: false
+            should-build: true
+
+          - name: Template (arm64, release)
+            target: template_release
+            arch: arm64
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template (arm64, debug)
+            target: template_debug
+            arch: arm64
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          - name: .NET Editor (x86_64, release)
+            target: editor
+            arch: x86_64
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          - name: .NET Template (x86_64, release)
+            target: template_release
+            arch: x86_64
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          - name: .NET Template (x86_64, debug)
+            target: template_debug
+            arch: x86_64
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          - name: .NET Editor (arm64, release)
+            target: editor
+            arch: arm64
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          - name: .NET Template (arm64, release)
+            target: template_release
+            arch: arm64
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          - name: .NET Template (arm64, debug)
+            target: template_debug
+            arch: arm64
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+        exclude:
+          - { opts: { should-build: false } }
+
+    env:
+      BIN: godot.macos.${{matrix.opts.target}}.${{matrix.opts.arch}}${{  matrix.opts.dotnet == true && '.mono' || ''  }}
+
+    steps:
+      - name: Clone Godot
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot
+          ref: ${{ inputs.godot-ref }}
+
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          path: modules/limboai
+          ref: ${{ inputs.limboai-ref }}
+
+      # Inits GODOT_VERSION, LIMBOAI_VERSION and NAME_PREFIX environment variables.
+      - uses: ./modules/limboai/.github/actions/init-version
+
+      - name: Set up Python 3.x
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+          architecture: "x64"
+
+      - name: Set up scons
+        run: |
+          python -c "import sys; print(sys.version)"
+          python -m pip install scons==4.4.0
+
+      - name: Set up .NET SDK 6.0
+        if: matrix.opts.dotnet
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: "6.0.x"
+
+      - name: Diagnostics
+        run: |
+          python --version
+          scons --version
+          dotnet --info
+
+      - name: Set up Vulkan SDK
+        run: |
+          # ! Note: Vulkan SDK changed packaging, so we need to inline these steps for the time being.
+          #sh misc/scripts/install_vulkan_sdk_macos.sh
+
+          curl -L "https://sdk.lunarg.com/sdk/download/latest/mac/config.json" -o /tmp/vulkan-sdk.json
+          sdk_version=`jq -r '.version' /tmp/vulkan-sdk.json`
+          curl -L "https://sdk.lunarg.com/sdk/download/latest/mac/vulkan-sdk.zip" -o /tmp/vulkan-sdk.zip
+          unzip /tmp/vulkan-sdk.zip -d /tmp
+          /tmp/InstallVulkan-${sdk_version}.app/Contents/MacOS/InstallVulkan-${sdk_version} --accept-licenses --default-answer --confirm-command install
+          rm -Rf /tmp/InstallVulkan-${sdk_version}.app
+          rm -f /tmp/vulkan-sdk.zip
+
+      - name: Set up scons cache
+        if: inputs.test-build # ! Only cache test/PR builds
+        uses: actions/cache@v4
+        with:
+          path: ${{github.workspace}}/.scons_cache/
+          key: ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+          restore-keys: |
+            ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+            ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}
+            ${{env.BIN}}-${{inputs.godot-ref}}
+
+      - name: Compilation
+        env:
+          SCONS_CACHE: ${{github.workspace}}/.scons_cache/
+        run: |
+          scons -j2 platform=macos target=${{matrix.opts.target}} arch=${{matrix.opts.arch}} module_mono_enabled=${{matrix.opts.dotnet}} ${{env.SCONSFLAGS}}
+
+      - name: Build .NET assemblies
+        if: matrix.opts.dotnet && matrix.opts.target == 'editor'
+        uses: ./modules/limboai/.github/actions/build-dotnet-assemblies
+        with:
+          platform: macos
+          bin: ${{env.BIN}}
+
+      - name: Prepare artifact
+        run: |
+          chmod +x bin/godot.*
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: tmp-${{matrix.opts.dotnet == true && 'dotnet-' || ''}}macos-${{matrix.opts.target}}-${{matrix.opts.arch}}
+          path: bin/*
+
+  make-macos-bundle:
+    runs-on: "macos-latest"
+    name: Make macOS Bundles
+    needs: macos-builds
+
+    strategy:
+      fail-fast: false
+      matrix:
+        opts:
+          - download-prefix: tmp-macos
+            dotnet: false
+            should-build: true
+          - download-prefix: tmp-dotnet-macos
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+        exclude:
+          - { opts: { should-build: false } }
+
+    steps:
+      - name: Clone Godot
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot
+          ref: ${{ inputs.godot-ref }}
+
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          path: modules/limboai
+          ref: ${{ inputs.limboai-ref }}
+
+      # Inits GODOT_VERSION, LIMBOAI_VERSION and NAME_PREFIX environment variables.
+      - uses: ./modules/limboai/.github/actions/init-version
+
+      - name: Download editor artifact
+        uses: actions/download-artifact@v4
+        with:
+          pattern: ${{matrix.opts.download-prefix}}-editor-*
+          merge-multiple: true
+          path: bin/
+
+      # Zipping the editor bundle to retain executable bit;
+      # workaround for: https://github.com/actions/upload-artifact/issues/38
+      - name: Make editor bundle
+        env:
+          APP_NAME: Godot${{matrix.opts.dotnet == true && '_mono' || ''}}.app
+        run: |
+          ls bin/
+          lipo -create bin/godot.macos.editor.x86_64* bin/godot.macos.editor.arm64* -output bin/godot.macos.editor.universal
+          mkdir -p out/editor/
+          cp -r misc/dist/macos_tools.app out/editor/${APP_NAME}
+          mkdir -p out/editor/${APP_NAME}/Contents/{MacOS,Resources}
+          cp bin/godot.macos.editor.universal out/editor/${APP_NAME}/Contents/MacOS/Godot
+          chmod +x out/editor/${APP_NAME}/Contents/MacOS/Godot
+          cp -r bin/GodotSharp out/editor/${APP_NAME}/Contents/Resources/GodotSharp || true
+          pushd out/editor
+          zip -q -9 -r ${APP_NAME}.zip ${APP_NAME}
+          rm -rf ${APP_NAME}
+          echo -e "## Why another ZIP inside?\n\nWorkaround for: https://github.com/actions/upload-artifact/issues/38\n" > README.md
+          popd
+          rm -rf bin/*
+          ls out/editor/
+
+      - name: Upload editor bundle
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{env.NAME_PREFIX}}${{matrix.opts.dotnet == true && '.dotnet' || ''}}.editor.macos.universal
+          path: out/editor/*
+
+      - name: Download templates artifact
+        if: ${{ !inputs.test-build }}
+        uses: actions/download-artifact@v4
+        with:
+          pattern: ${{matrix.opts.download-prefix}}-template_*
+          merge-multiple: true
+          path: bin/
+
+      - name: Make templates bundle
+        if: ${{ !inputs.test-build }}
+        run: |
+          rm -rf out/
+          ls bin/
+          lipo -create bin/godot.macos.template_release.x86_64* bin/godot.macos.template_release.arm64* -output bin/godot.macos.template_release.universal
+          lipo -create bin/godot.macos.template_debug.x86_64* bin/godot.macos.template_debug.arm64* -output bin/godot.macos.template_debug.universal
+          cp -r misc/dist/macos_template.app macos_template.app
+          mkdir -p macos_template.app/Contents/MacOS
+          cp bin/godot.macos.template_debug.universal macos_template.app/Contents/MacOS/godot_macos_debug.universal
+          cp bin/godot.macos.template_release.universal macos_template.app/Contents/MacOS/godot_macos_release.universal
+          chmod +x macos_template.app/Contents/MacOS/godot_macos_{release,debug}.universal
+          zip -q -9 -r macos.zip macos_template.app
+          mkdir -p out/templates/
+          mv macos.zip out/templates/macos.zip
+          echo "${GODOT_VERSION}.limboai+${LIMBOAI_VERSION}${{matrix.opts.dotnet == true && '.mono' || ''}}" > out/templates/version.txt
+          rm -rf bin/*
+          ls out/templates/
+
+      - uses: geekyeggo/delete-artifact@v5
+        with:
+          name: ${{matrix.opts.download-prefix}}-*
+          useGlob: true
+          failOnError: false
+
+      - name: Upload templates bundle
+        if: ${{ !inputs.test-build }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{env.NAME_PREFIX}}${{matrix.opts.dotnet == true && '.dotnet' || ''}}.export-templates.macos
+          path: out/*

.github/workflows/merge_templates.yml

@@ -0,0 +1,52 @@
+name: 📦️ Merge templates
+on:
+  workflow_call:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+
+  workflow_dispatch:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+
+jobs:
+  merge-templates:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clone Godot
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot
+          ref: ${{ inputs.godot-ref }}
+
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          path: modules/limboai
+          ref: ${{ inputs.limboai-ref }}
+
+      # Inits GODOT_VERSION, LIMBOAI_VERSION and NAME_PREFIX environment variables.
+      - uses: ./modules/limboai/.github/actions/init-version
+
+      - name: Merge classical templates
+        uses: actions/upload-artifact/merge@v4
+        with:
+          name: ${{env.NAME_PREFIX}}.export-templates
+          pattern: ${{env.NAME_PREFIX}}.{export-templates,template_}*
+          delete-merged: true
+
+      - name: Merge .NET templates
+        uses: actions/upload-artifact/merge@v4
+        with:
+          name: ${{env.NAME_PREFIX}}.dotnet.export-templates
+          pattern: ${{env.NAME_PREFIX}}.dotnet.{export-templates,template_}*
+          delete-merged: true

.github/workflows/test_builds.yml

@@ -0,0 +1,162 @@
+name: 🔎 Test builds
+on:
+  workflow_dispatch:
+
+  push:
+    branches: [master]
+    paths-ignore:
+      - "README.md"
+      - "LICENSE.md"
+      - "**/*.png"
+      - "demo/**"
+      - "doc/**"
+
+  pull_request:
+    branches: [master]
+    paths-ignore:
+      - "README.md"
+      - "LICENSE.md"
+      - "**/*.png"
+      - "demo/**"
+      - "doc/**"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+# Global Settings.
+env:
+  GODOT_REF: "master"
+  GODOT_CPP_REF: "master"
+
+jobs:
+  unit-tests:
+    name: 🧪 Unit tests
+    runs-on: "ubuntu-20.04"
+
+    # Settings
+    env:
+      SCONSFLAGS: platform=linuxbsd target=editor arch=x86_64 production=false dev_build=true tests=true verbose=yes warnings=extra werror=yes strict_checks=yes
+      SCONS_CACHE_LIMIT: 7168
+      BIN: godot.linuxbsd.editor.dev.x86_64
+
+    steps:
+      - name: Clone Godot
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot
+          ref: ${{ env.GODOT_REF }}
+
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          path: modules/limboai
+
+      - name: Set up Linux toolchain
+        uses: ./modules/limboai/.github/actions/setup-linux-toolchain
+        with:
+          arch: x86_64
+
+      - name: Set up scons cache
+        uses: actions/cache@v4
+        with:
+          path: ${{github.workspace}}/.scons_cache/
+          key: ${{env.BIN}}-${{env.GODOT_REF}}-${{github.ref}}-${{github.sha}}
+          restore-keys: |
+            ${{env.BIN}}-${{env.GODOT_REF}}-${{github.ref}}-${{github.sha}}
+            ${{env.BIN}}-${{env.GODOT_REF}}-${{github.ref}}
+            ${{env.BIN}}-${{env.GODOT_REF}}
+        continue-on-error: true
+
+      - name: Set up Python 3.x
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+          architecture: "x64"
+
+      - name: Set up scons
+        run: |
+          python -c "import sys; print(sys.version)"
+          python -m pip install scons==4.4.0
+          python --version
+          scons --version
+
+      - name: Setup GCC problem matcher
+        uses: ammaraskar/gcc-problem-matcher@master
+
+      - name: Compilation
+        env:
+          SCONS_CACHE: ${{github.workspace}}/.scons_cache/
+        run: |
+          PATH=${GITHUB_WORKSPACE}/buildroot/bin:$PATH
+          scons ${{env.SCONSFLAGS}}
+
+      - name: Verify build
+        run: |
+          ls -l bin/
+          bin/${{ env.BIN }} --version
+          bin/${{ env.BIN }} --help
+
+      - name: Unit tests
+        run: |
+          bin/${{ env.BIN }} --test --headless
+
+  static-checks:
+    name: ⚙️ Static checks
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+
+      - name: Code style checks
+        uses: pre-commit/action@v3.0.1
+        with:
+          extra_args: --all-files
+
+  cache-env:
+    runs-on: ubuntu-latest
+    outputs:
+      godot-ref: ${{ steps.cache-env.outputs.godot-ref }}
+      godot-cpp-ref: ${{ steps.cache-env.outputs.godot-cpp-ref }}
+    steps:
+      - name: Cache env
+        id: cache-env
+        run: |
+          echo "godot-ref=${GODOT_REF}" >> "$GITHUB_OUTPUT"
+          echo "godot-cpp-ref=${GODOT_CPP_REF}" >> "$GITHUB_OUTPUT"
+
+  linux-test-build:
+    name: 🐧 Linux
+    needs: cache-env
+    uses: ./.github/workflows/linux.yml
+    with:
+      godot-ref: ${{ needs.cache-env.outputs.godot-ref }}
+      limboai-ref: ${{ github.sha }}
+      test-build: true
+
+  windows-test-build:
+    name: 🪟 Windows
+    needs: cache-env
+    uses: ./.github/workflows/windows.yml
+    with:
+      godot-ref: ${{ needs.cache-env.outputs.godot-ref }}
+      limboai-ref: ${{ github.sha }}
+      test-build: true
+
+  macos-test-build:
+    name: 🍎 macOS
+    needs: cache-env
+    uses: ./.github/workflows/macos.yml
+    with:
+      godot-ref: ${{ needs.cache-env.outputs.godot-ref }}
+      limboai-ref: ${{ github.sha }}
+      test-build: true
+
+  gdextension:
+    name: 🔌 GDExtension
+    needs: cache-env
+    uses: ./.github/workflows/gdextension.yml
+    with:
+      godot-cpp-ref: ${{ needs.cache-env.outputs.godot-cpp-ref }}
+      limboai-ref: ${{ github.sha }}
+      test-build: true

.github/workflows/web.yml

@@ -0,0 +1,158 @@
+name: 🌐 Web builds
+on:
+  workflow_call:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+        default: master
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+
+  workflow_dispatch:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+        default: master
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+
+# Global Settings
+env:
+  SCONS_CACHE_LIMIT: 4096
+  # With `lto=full` VM seems to run out of ram and build fails
+  SCONSFLAGS: use_static_cpp=yes debug_symbols=no lto=thin optimize=size verbose=yes warnings=extra werror=yes tests=no
+  EM_VERSION: 3.1.45
+  EM_CACHE_FOLDER: "emsdk-cache"
+
+jobs:
+  web-builds:
+    runs-on: "ubuntu-20.04"
+    name: ${{ matrix.name }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Template (release)
+            target: template_release
+            threads: true
+            dlink: false
+
+          - name: Template (release, dlink)
+            target: template_release
+            threads: true
+            dlink: true
+
+          - name: Template (debug)
+            target: template_debug
+            threads: true
+            dlink: false
+
+          - name: Template (debug, dlink)
+            target: template_debug
+            threads: true
+            dlink: true
+
+          - name: Template (release, nothreads)
+            target: template_release
+            threads: false
+            dlink: false
+
+          - name: Template (release, nothreads, dlink)
+            target: template_release
+            threads: false
+            dlink: true
+
+          - name: Template (debug, nothreads)
+            target: template_debug
+            threads: false
+            dlink: false
+
+          - name: Template (debug, nothreads, dlink)
+            target: template_debug
+            threads: false
+            dlink: true
+
+    env:
+      CACHE_NAME: godot.web.${{matrix.target}}${{  matrix.dlink == true && '.dlink' || ''  }}
+
+    steps:
+      - name: Clone Godot
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot
+          ref: ${{ inputs.godot-ref }}
+
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          path: modules/limboai
+          ref: ${{ inputs.limboai-ref }}
+
+      # Inits GODOT_VERSION, LIMBOAI_VERSION and NAME_PREFIX environment variables.
+      - uses: ./modules/limboai/.github/actions/init-version
+
+      - name: Set up Emscripten cache
+        uses: actions/cache@v4
+        with:
+          path: ${{env.EM_CACHE_FOLDER}}
+          key: ${{env.EM_VERSION}}-${{runner.os}}-libs
+
+      - name: Set up Emscripten
+        uses: mymindstorm/setup-emsdk@v14
+        with:
+          version: ${{env.EM_VERSION}}
+          actions-cache-folder: ${{env.EM_CACHE_FOLDER}}
+
+      - name: Verify Emscripten setup
+        run: |
+          emcc -v
+
+      - name: Set up scons
+        run: |
+          python -c "import sys; print(sys.version)"
+          python -m pip install scons==4.4.0
+          python --version
+          scons --version
+
+      # ! Note: we stopped using the scons cache in release builds.
+      # - name: Set up scons cache
+      #   uses: actions/cache@v4
+      #   with:
+      #     path: ${{github.workspace}}/.scons_cache/
+      #     key: ${{env.CACHE_NAME}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+      #     restore-keys: |
+      #       ${{env.CACHE_NAME}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+      #       ${{env.CACHE_NAME}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}
+      #       ${{env.CACHE_NAME}}-${{inputs.godot-ref}}
+
+      - name: Compilation
+        env:
+          SCONS_CACHE: ${{github.workspace}}/.scons_cache/
+        run: |
+          scons platform=web target=${{matrix.target}} threads=${{matrix.threads}} dlink_enabled=${{matrix.dlink}} ${{env.SCONSFLAGS}}
+
+      - name: Prepare artifacts
+        run: |
+          mkdir -p out/templates/
+          mv bin/godot.web.template_debug.wasm32.zip out/templates/web_debug.zip || true
+          mv bin/godot.web.template_debug.wasm32.nothreads.zip out/templates/web_nothreads_debug.zip || true
+          mv bin/godot.web.template_debug.wasm32.dlink.zip out/templates/web_dlink_debug.zip || true
+          mv bin/godot.web.template_debug.wasm32.nothreads.dlink.zip out/templates/web_dlink_nothreads_debug.zip || true
+          mv bin/godot.web.template_release.wasm32.zip out/templates/web_release.zip || true
+          mv bin/godot.web.template_release.wasm32.nothreads.zip out/templates/web_nothreads_release.zip || true
+          mv bin/godot.web.template_release.wasm32.dlink.zip out/templates/web_dlink_release.zip || true
+          mv bin/godot.web.template_release.wasm32.nothreads.dlink.zip out/templates/web_dlink_nothreads_release.zip || true
+          rm -rf bin/
+          echo "${GODOT_VERSION}.limboai+${LIMBOAI_VERSION}" > out/templates/version.txt
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{env.NAME_PREFIX}}.${{matrix.target}}.web${{matrix.threads == false && '.nothreads' || ''}}${{matrix.dlink == true && '.dlink' || ''}}
+          path: out/*

.github/workflows/windows.yml

@@ -0,0 +1,358 @@
+name: 🪟 Windows builds
+on:
+  workflow_call:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+        default: master
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+      test-build:
+        description: Limit to pre-defined test builds
+        type: boolean
+        default: false
+
+  workflow_dispatch:
+    inputs:
+      godot-ref:
+        description: A tag, branch or commit hash in the Godot repository.
+        type: string
+        default: master
+      limboai-ref:
+        description: A tag, branch or commit hash in the LimboAI repository.
+        type: string
+        default: master
+      test-build:
+        description: Limit to pre-defined test builds
+        type: boolean
+        default: false
+
+# Global Settings
+env:
+  BUILD_IMAGE_VERSION: 4.3-f40
+  MESA_VERSION: 23.1.9-1
+  SCONS_CACHE_LIMIT: 4096
+  SCONSFLAGS: production=yes use_mingw=yes verbose=yes warnings=no progress=no d3d12=yes
+
+jobs:
+  windows-builds:
+    runs-on: "ubuntu-24.04"
+    name: ${{ matrix.opts.name }}
+    outputs:
+      built-dotnet-editor: ${{ steps.mark-dotnet-editor.outputs.built-dotnet-editor }}
+    strategy:
+      fail-fast: false
+      matrix:
+        opts:
+          # * Standard x86_64
+
+          - name: Editor (x86_64, release)
+            target: editor
+            arch: x86_64
+            llvm: false
+            dotnet: false
+            should-build: true
+
+          - name: Template (x86_64, release)
+            target: template_release
+            arch: x86_64
+            llvm: false
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template (x86_64, debug)
+            target: template_debug
+            arch: x86_64
+            llvm: false
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          # * Standard x86_32
+
+          # - name: Editor (x86_32, release)
+          #   target: editor
+          #   arch: x86_32
+          #   llvm: false
+          #   dotnet: false
+          # should-build: ${{ !inputs.test-build }}
+
+          - name: Template (x86_32, release)
+            target: template_release
+            arch: x86_32
+            llvm: false
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template (x86_32, debug)
+            target: template_debug
+            arch: x86_32
+            llvm: false
+            dotnet: false
+            should-build: ${{ !inputs.test-build }}
+
+          # * Standard arm64
+
+          # - name: Editor (arm64, release)
+          #   target: editor
+          #   arch: arm64
+          #   llvm: true
+          #   dotnet: false
+          #   should-build: ${{ !inputs.test-build }}
+
+          - name: Template (arm64, release)
+            target: template_release
+            arch: arm64
+            llvm: true
+            dotnet: false
+            scons-flags: mingw_prefix=/root/llvm-mingw
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template (arm64, debug)
+            target: template_debug
+            arch: arm64
+            llvm: true
+            dotnet: false
+            scons-flags: mingw_prefix=/root/llvm-mingw
+            should-build: ${{ !inputs.test-build }}
+
+          # * .NET x86_64
+
+          - name: Editor .NET (x86_64, release)
+            target: editor
+            arch: x86_64
+            llvm: false
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template .NET (x86_64, release)
+            target: template_release
+            arch: x86_64
+            llvm: false
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template .NET (x86_64, debug)
+            target: template_debug
+            arch: x86_64
+            llvm: false
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          # * .NET x86_32
+
+          # - name: Editor .NET (x86_32, release)
+          #   target: editor
+          #   arch: x86_32
+          #   llvm: false
+          #   dotnet: true
+          # should-build: ${{ !inputs.test-build }}
+
+          - name: Template .NET (x86_32, release)
+            target: template_release
+            arch: x86_32
+            llvm: false
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template .NET (x86_32, debug)
+            target: template_debug
+            arch: x86_32
+            llvm: false
+            dotnet: true
+            should-build: ${{ !inputs.test-build }}
+
+            # * .NET arm64
+
+          # - name: Editor .NET (arm64, release)
+          #   target: editor
+          #   arch: arm64
+          #   llvm: true
+          #   dotnet: true
+          #   should-build: ${{ !inputs.test-build }}
+
+          - name: Template .NET (arm64, release)
+            target: template_release
+            arch: arm64
+            llvm: true
+            dotnet: true
+            scons-flags: mingw_prefix=/root/llvm-mingw
+            should-build: ${{ !inputs.test-build }}
+
+          - name: Template .NET (arm64, debug)
+            target: template_debug
+            arch: arm64
+            llvm: true
+            dotnet: true
+            scons-flags: mingw_prefix=/root/llvm-mingw
+            should-build: ${{ !inputs.test-build }}
+
+        exclude:
+          - { opts: { should-build: false } }
+
+    env:
+      BIN: godot.windows.${{matrix.opts.target}}.${{matrix.opts.arch}}${{matrix.opts.llvm && '.llvm' || ''}}${{matrix.opts.dotnet == true && '.mono' || ''}}
+
+    steps:
+      - name: Clone Godot
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot
+          ref: ${{ inputs.godot-ref }}
+
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          path: modules/limboai
+          ref: ${{ inputs.limboai-ref }}
+
+      # Inits GODOT_VERSION, LIMBOAI_VERSION, NAME_PREFIX, GODOT_VERSION_STATUS, BUILD_NAME environment variables.
+      - uses: ./modules/limboai/.github/actions/init-version
+
+      - name: Set up scons cache
+        if: inputs.test-build # ! Only cache test/PR builds
+        uses: actions/cache@v4
+        with:
+          path: ${{github.workspace}}/.scons_cache/
+          key: ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+          restore-keys: |
+            ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}-${{env.LIMBOAI_VERSION}}
+            ${{env.BIN}}-${{inputs.godot-ref}}-${{inputs.limboai-ref}}
+            ${{env.BIN}}-${{inputs.godot-ref}}
+
+      - name: Static ANGLE libs
+        run: |
+          mkdir -p deps/angle
+          cd deps/angle
+          url=https://github.com/godotengine/godot-angle-static/releases/download/chromium%2F6601.2/godot-angle-static
+          curl -L -o windows_${{matrix.opts.arch}}.zip $url-${{matrix.opts.arch}}-${{matrix.opts.llvm && 'llvm' || 'gcc'}}-release.zip
+          unzip windows_${{matrix.opts.arch}}.zip
+          rm windows_${{matrix.opts.arch}}.zip
+
+      - name: Mesa libs
+        run: |
+          mkdir -p deps/mesa
+          cd deps/mesa
+          curl -L -o mesa_${{matrix.opts.arch}}.zip https://github.com/godotengine/godot-nir-static/releases/download/${{env.MESA_VERSION}}/godot-nir-static-${{matrix.opts.arch}}-${{matrix.opts.llvm && 'llvm' || 'gcc'}}-release.zip
+          unzip -o mesa_${{matrix.opts.arch}}.zip
+          rm -f mesa_${{matrix.opts.arch}}.zip
+
+      - name: Pull build container
+        run: |
+          podman pull ghcr.io/limbonaut/godot-windows:${{env.BUILD_IMAGE_VERSION}}
+
+      - name: Build using container
+        shell: bash
+        run: |
+          scons_command="scons \
+              platform=windows \
+              target=${{matrix.opts.target}} \
+              arch=${{matrix.opts.arch}} \
+              use_llvm=${{matrix.opts.llvm}} \
+              module_mono_enabled=${{matrix.opts.dotnet}} \
+              ${{env.SCONSFLAGS}} \
+              ${{matrix.opts.scons-flags}} \
+              angle_libs=/build/deps/angle \
+              mesa_libs=/build/deps/mesa \
+          "
+          podman_run="podman run -it --rm \
+            --env GODOT_VERSION_STATUS=${GODOT_VERSION_STATUS} \
+            --env BUILD_NAME=${BUILD_NAME} \
+            --env NUM_CORES=$(nproc --all) \
+            --env DOTNET_NOLOGO=true \
+            --env DOTNET_CLI_TELEMETRY_OPTOUT=true \
+            --env SCONS_CACHE=/build/.scons_cache/ \
+            --env SCONS_CACHE_LIMIT=${SCONS_CACHE_LIMIT} \
+            -v ${GITHUB_WORKSPACE}/:/build/ \
+            -w /build godot-windows:${{env.BUILD_IMAGE_VERSION}} bash -c \
+          "
+          echo "Running ${podman_run} \"${scons_command}\""
+          ${podman_run} "${scons_command}"
+
+      - name: Prepare artifact
+        shell: bash
+        env:
+          OUTDIR: ${{ startsWith(matrix.opts.target, 'template') && 'out/templates' || 'out/' }}
+        run: |
+          rm -f bin/*.{exp,lib,pdb}
+          mkdir -p ${{env.OUTDIR}}
+          mv bin/* ${{env.OUTDIR}}
+          ls -R out/
+
+      - name: Rename templates
+        if: startsWith(matrix.opts.target, 'template')
+        shell: bash
+        env:
+          BUILD_TYPE: ${{ endsWith(matrix.opts.target, 'release') && 'release' || 'debug' }}
+        run: |
+          mv out/templates/${BIN}.exe out/templates/windows_${BUILD_TYPE}_${{matrix.opts.arch}}.exe
+          mv out/templates/${BIN}.console.exe out/templates/windows_${BUILD_TYPE}_${{matrix.opts.arch}}_console.exe
+          echo "${GODOT_VERSION}.limboai+${LIMBOAI_VERSION}${{matrix.opts.dotnet == true && '.mono' || ''}}" > out/templates/version.txt
+          ls -R out/
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{env.NAME_PREFIX}}${{matrix.opts.dotnet == true && '.dotnet' || ''}}.${{matrix.opts.target}}.windows.${{matrix.opts.arch}}
+          path: out/*
+
+      - name: Mark .NET editor as built
+        if: matrix.opts.dotnet && matrix.opts.target == 'editor'
+        id: mark-dotnet-editor
+        run: echo "built-dotnet-editor=true" >> $GITHUB_OUTPUT
+
+
+  dotnet-assemblies:
+    name: .NET assembly for ${{matrix.opts.arch}}
+    needs: windows-builds
+    if: always() && needs.windows-builds.outputs.built-dotnet-editor == 'true'
+    runs-on: "windows-latest"
+    strategy:
+      fail-fast: false
+      matrix:
+        opts:
+          - arch: x86_64
+            llvm: false
+    env:
+      BIN: godot.windows.editor.${{matrix.opts.arch}}${{matrix.opts.llvm && '.llvm' || ''}}.mono
+    steps:
+      - name: Clone Godot
+        uses: actions/checkout@v4
+        with:
+          repository: godotengine/godot
+          ref: ${{ inputs.godot-ref }}
+
+      - name: Clone LimboAI module
+        uses: actions/checkout@v4
+        with:
+          path: modules/limboai
+          ref: ${{ inputs.limboai-ref }}
+
+      # Inits GODOT_VERSION, LIMBOAI_VERSION and NAME_PREFIX environment variables.
+      - uses: ./modules/limboai/.github/actions/init-version
+
+      - name: Reconstruct artifact name
+        shell: bash
+        run: |
+          echo "ARTIFACT=${{env.NAME_PREFIX}}.dotnet.editor.windows.${{matrix.opts.arch}}" >> $GITHUB_ENV
+
+      - name: Download editor artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{env.ARTIFACT}}
+          path: bin/
+
+      - name: Build .NET assemblies
+        uses: ./modules/limboai/.github/actions/build-dotnet-assemblies
+        with:
+          platform: windows
+          bin: ${{env.BIN}}
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{env.ARTIFACT}}
+          overwrite: true
+          path: bin/*

.gitignore

@@ -1,3 +1,9 @@
+# LimboAI-specific
+demo/addons/
+demo/script_templates/
+icons/*.import
+godot-cpp
+
 # Godot auto generated files
 *.gen.*
 .import/
@@ -181,3 +187,6 @@ godot.creator.*
 
 # compile commands (https://clang.llvm.org/docs/JSONCompilationDatabase.html)
 compile_commands.json
+
+# clang cache
+.cache

.pre-commit-config.yaml

@@ -0,0 +1,24 @@
+repos:
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: v17.0.6
+    hooks:
+      - id: clang-format
+        files: \.(c|h|cpp|hpp|cc|cxx|m|mm|inc|java|glsl)$
+        types_or: [text]
+        exclude: |
+          (?x)^(
+            tests/python_build.*|
+            .*thirdparty.*|
+            .*platform/android/java/lib/src/com.*|
+            .*-so_wrap.*
+          )
+
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 24.2.0
+    hooks:
+      - id: black
+        files: (\.py$|SConstruct|SCsub)
+        types_or: [text]
+        exclude: .*thirdparty.*
+        args:
+          - --line-length=120

LICENSE.md

@@ -0,0 +1,7 @@
+Copyright (c) 2023-2025 Serhii Snitsaruk and the LimboAI contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

LOGO_LICENSE.md

@@ -0,0 +1,5 @@
+LimboAI Logo
+Copyright (c) 2023 Aleksandra Snitsaruk
+
+This work is licensed under the Creative Commons Attribution 4.0 International
+license (CC BY 4.0 International): https://creativecommons.org/licenses/by/4.0/

README.md

@@ -0,0 +1,139 @@
+<p align="center">
+  <img src="doc/images/logo.svg" width="400" alt="LimboAI logo">
+</p>
+
+# LimboAI - Behavior Trees & State Machines for Godot 4
+
+[![🔗 All builds](https://github.com/limbonaut/limboai/actions/workflows/all_builds.yml/badge.svg)](https://github.com/limbonaut/limboai/actions/workflows/all_builds.yml)
+[![🔎 Unit Tests](https://github.com/limbonaut/limboai/actions/workflows/test_builds.yml/badge.svg)](https://github.com/limbonaut/limboai/actions/workflows/test_builds.yml)
+[![Documentation Status](https://readthedocs.org/projects/limboai/badge/?version=latest)](https://limboai.readthedocs.io/en/latest/?badge=latest)
+[![GitHub License](https://img.shields.io/github/license/limbonaut/limboai)](https://github.com/limbonaut/limboai/blob/master/LICENSE.md)
+[![Discord](https://img.shields.io/discord/1185664967379267774?logo=discord&link=https%3A%2F%2Fdiscord.gg%2FN5MGC95GpP)](https://discord.gg/N5MGC95GpP)
+[![Mastodon Follow](https://img.shields.io/mastodon/follow/109346796150895359?domain=https%3A%2F%2Fmastodon.gamedev.place)](https://mastodon.gamedev.place/@limbo)
+
+>**🛈 Supported Godot Engine:** **4.3** (v1.2.0+) | **4.2** (v1.1.x releases)
+
+**LimboAI** is an open-source C++ plugin for **Godot Engine 4** providing a combination of
+**Behavior Trees** and **State Machines**, which can be used together to create complex AI behaviors.
+It comes with a behavior tree editor, built-in documentation, visual debugger, extensive demo project with a tutorial, and more!
+While it is implemented in C++, it fully supports GDScript for [creating your own tasks](https://limboai.readthedocs.io/en/stable/behavior-trees/custom-tasks.html) and [states](https://limboai.readthedocs.io/en/stable/hierarchical-state-machines/create-hsm.html).
+
+If you enjoy using LimboAI, please **consider supporting** my efforts with a donation on Ko-fi 😊 Your contribution will help me continue developing and improving it.
+
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/Y8Y2TCNH0)
+
+![Textured screenshot](doc/images/behavior-tree-editor-debugger.png)
+
+Behavior Trees are powerful hierarchical structures used to model and control the behavior of agents in a game (e.g., characters, enemies). They are designed to make it easier to create rich and highly modular behaviors for your games. To learn more about behavior trees, check out [Introduction to Behavior Trees](https://limboai.readthedocs.io/en/stable/behavior-trees/introduction.html) and our demo project, which includes a tutorial.
+
+## Demonstration
+
+![Charger from Demo](doc/images/demo_charger.gif)
+
+>**🛈 Demo project** lives in the `demo` folder and is available separately in [**Releases**](https://github.com/limbonaut/limboai/releases).
+> Run `demo/scenes/showcase.tscn` to get started.
+> It also includes a tutorial that introduces behavior trees through illustrative examples.
+
+### Videos
+
+> **🛈** YouTube videos produced by various creators
+
+<a href="https://www.youtube.com/watch?v=NWaMArUg7mY"><img src="https://img.youtube.com/vi/NWaMArUg7mY/0.jpg" width=410></a>
+<a href="https://www.youtube.com/watch?v=aP0Aacdxmno"><img src="https://img.youtube.com/vi/aP0Aacdxmno/0.jpg" width=410></a>
+<a href="https://www.youtube.com/watch?v=vZHzMO90IwQ"><img src="https://img.youtube.com/vi/vZHzMO90IwQ/0.jpg" width=410></a>
+<a href="https://www.youtube.com/watch?v=gAk3xl5fBsM"><img src="https://img.youtube.com/vi/gAk3xl5fBsM/0.jpg" width=410></a>
+
+## Features
+
+- **Behavior Trees (BT):**
+    - Easily create, edit, and save `BehaviorTree` resources in the editor.
+    - Execute `BehaviorTree` resources using the `BTPlayer` node.
+    - Create complex behaviors by combining and nesting tasks in a hierarchy.
+    - Control execution flow using composite, decorator, and condition tasks.
+    - [Create custom tasks](https://limboai.readthedocs.io/en/stable/behavior-trees/custom-tasks.html) by extending core classes: `BTAction`, `BTCondition`, `BTDecorator`, and `BTComposite`.
+    - Built-in class documentation.
+    - Blackboard system: Share data seamlessly between tasks using the `Blackboard`.
+      - Blackboard plans: Define variables in the BehaviorTree resource and override their values in the BTPlayer node.
+      - Plan editor: Manage variables, their data types and property hints.
+      - Blackboard scopes: Prevent name conflicts and enable advanced techniques like [sharing data between several agents](https://limboai.readthedocs.io/en/stable/behavior-trees/using-blackboard.html#sharing-data-between-several-agents).
+      - Blackboard parameters: [Export a BB parameter](https://limboai.readthedocs.io/en/stable/behavior-trees/using-blackboard.html#task-parameters), for which user can provide a value or bind it to a blackboard variable (can be used in custom tasks).
+      - Inspector support for specifying blackboard variables (custom editor for exported `StringName` properties ending with "_var").
+    - Use the `BTSubtree` task to execute a tree from a different resource file, promoting organization and reusability.
+    - Visual Debugger: Inspect the execution of any BT in a running scene to identify and troubleshoot issues.
+    - Visualize BT in-game using `BehaviorTreeView` node (for custom in-game tools).
+    - Monitor tree performance with custom performance monitors.
+
+- **Hierarchical State Machines (HSM):**
+    - Extend the `LimboState` class to implement state logic.
+    - `LimboHSM` node serves as a state machine that manages `LimboState` instances and transitions.
+    - `LimboHSM` is a state itself and can be nested within other `LimboHSM` instances.
+    - [Event-based](https://limboai.readthedocs.io/en/stable/hierarchical-state-machines/create-hsm.html#events-and-transitions): Transitions are associated with events and are triggered by the state machine when the relevant event is dispatched, allowing for better decoupling of transitions from state logic.
+    - Combine state machines with behavior trees using `BTState` for advanced reactive AI.
+    - Delegation Option: Using the vanilla `LimboState`, [delegate the implementation](https://limboai.readthedocs.io/en/stable/hierarchical-state-machines/create-hsm.html#single-file-state-machine-setup) to your callback functions, making it perfect for rapid prototyping and game jams.
+    - 🛈 Note: State machine setup and initialization require code; there is no GUI editor.
+
+- **Tested:** Behavior tree tasks and HSM are covered by unit tests.
+
+- **GDExtension:** LimboAI can be [used as extension](https://limboai.readthedocs.io/en/stable/getting-started/getting-limboai.html#get-gdextension-version). Custom engine builds are not necessary.
+
+- **Demo + Tutorial:** Check out our extensive demo project, which includes an introduction to behavior trees using examples.
+
+## First steps
+
+Follow the [Getting started](https://limboai.readthedocs.io/en/stable/getting-started/getting-limboai.html) guide to learn how to get started with LimboAI and the demo project.
+
+## Getting LimboAI
+
+LimboAI can be used as either a C++ module or as a GDExtension shared library. GDExtension version is more convenient to use but somewhat limited in features. Whichever you choose to use, your project will stay compatible with both and you can switch from one to the other any time. See [Using GDExtension](https://limboai.readthedocs.io/en/stable/getting-started/getting-limboai.html#get-gdextension-version).
+
+### Precompiled builds
+
+- For the most recent builds, navigate to **Actions** → [**All Builds**](https://github.com/limbonaut/limboai/actions/workflows/all_builds.yml), select a build from the list, and scroll down until you find the **Artifacts** section.
+- For release builds, check [**Releases**](https://github.com/limbonaut/limboai/releases).
+
+### Compiling from source
+
+- Download the Godot Engine source code and put this module source into the `modules/limboai` directory.
+- Consult the Godot Engine documentation for instructions on [how to build from source code](https://docs.godotengine.org/en/stable/contributing/development/compiling/index.html).
+- If you plan to export a game utilizing the LimboAI module, you'll also need to build export templates.
+- To execute unit tests, compile the engine with `tests=yes` and run it with `--test --tc="*[LimboAI]*"`.
+
+#### For GDExtension
+
+- You'll need SCons build tool and a C++ compiler. See also [Compiling](https://docs.godotengine.org/en/stable/contributing/development/compiling/index.html).
+- Run `scons target=editor` to build the plugin library for your current platform.
+  - SCons will automatically clone the godot-cpp/ repository if it doesn't already exist in the `limboai/godot-cpp` directory.
+  - By default, built targets are placed in the demo project: `demo/addons/limboai/bin/`
+- Check `scons -h` for other options and targets.
+
+## Using the plugin
+
+- Online Documentation: [stable](https://limboai.readthedocs.io/en/stable/index.html), [latest](https://limboai.readthedocs.io/en/latest/index.html)
+- [Getting started](https://limboai.readthedocs.io/en/stable/getting-started/getting-limboai.html)
+- [Introduction to Behavior Trees](https://limboai.readthedocs.io/en/stable/behavior-trees/introduction.html)
+- [Creating custom tasks in GDScript](https://limboai.readthedocs.io/en/stable/behavior-trees/custom-tasks.html)
+- [Sharing data using Blackboard](https://limboai.readthedocs.io/en/stable/behavior-trees/using-blackboard.html)
+- [Accessing nodes in the scene tree](https://limboai.readthedocs.io/en/stable/behavior-trees/accessing-nodes.html)
+- [State machines](https://limboai.readthedocs.io/en/stable/hierarchical-state-machines/create-hsm.html)
+- [Using GDExtension](https://limboai.readthedocs.io/en/stable/getting-started/getting-limboai.html#get-gdextension-version)
+- [Using LimboAI with C#](https://limboai.readthedocs.io/en/stable/getting-started/c-sharp.html)
+- [Class reference](https://limboai.readthedocs.io/en/stable/classes/featured-classes.html)
+
+## Contributing
+
+Contributions are welcome! Please open issues for bug reports, feature requests, or code changes.
+For detailed guidelines on contributing to code or documentation, check out our [Contributing](https://limboai.readthedocs.io/en/latest/getting-started/contributing.html) page.
+
+If you have an idea for a behavior tree task or a feature that could be useful in a variety of projects, open an issue to discuss it.
+
+## Social
+
+Need help? We have a Discord server: https://discord.gg/N5MGC95GpP
+
+I write about LimboAI development on Mastodon: https://mastodon.gamedev.place/@limbo.
+
+## License
+
+Use of this source code is governed by an MIT-style license that can be found in the LICENSE file or at https://opensource.org/licenses/MIT
+
+LimboAI logo and demo project art assets are licensed under the Creative Commons Attribution 4.0 International license that can be found at https://creativecommons.org/licenses/by/4.0/

SConstruct

@@ -0,0 +1,160 @@
+#!/usr/bin/env python
+"""
+This is SConstruct file for building GDExtension variant using SCons build system.
+For module variant, see SCsub file.
+
+Use --project=DIR to customize output path for built targets.
+ - Built targets are placed into "DIR/addons/limboai/bin".
+ - For example: scons --project="../my_project"
+   - built targets will be placed into "../my_project/addons/limboai/bin".
+ - If not specified, built targets are put into the demo/ project.
+"""
+
+import os
+import sys
+import subprocess
+from limboai_version import generate_module_version_header, godot_cpp_ref
+
+sys.path.append("gdextension")
+from update_icon_entries import update_icon_entries
+from fix_icon_imports import fix_icon_imports
+
+# Check if godot-cpp/ exists
+if not os.path.exists("godot-cpp"):
+    print("Directory godot-cpp/ not found. Cloning repository...")
+    result = subprocess.run(
+        ["git", "clone", "-b", godot_cpp_ref, "https://github.com/godotengine/godot-cpp.git"],
+        check=True,
+        # capture_output=True
+    )
+    if result.returncode != 0:
+        print("Error: Cloning godot-cpp repository failed.")
+        Exit(1)
+    print("Finished cloning godot-cpp repository.")
+
+AddOption(
+    "--project",
+    dest="project",
+    type="string",
+    nargs=1,
+    action="store",
+    metavar="DIR",
+    default="demo",
+    help="Specify project directory",
+)
+
+help_text = """
+Options:
+  --project=DIR     Specify project directory (default: "demo");
+                    built targets will be placed in DIR/addons/limboai/bin
+"""
+Help(help_text)
+
+project_dir = GetOption("project")
+if not os.path.isdir(project_dir):
+    print("Project directory not found: " + project_dir)
+    Exit(2)
+
+# Parse LimboAI-specific variables.
+vars = Variables()
+vars.AddVariables(
+    BoolVariable("deploy_manifest", help="Deploy limboai.gdextension into PROJECT/addons/limboai/bin", default=True),
+    BoolVariable("deploy_icons", help="Deploy icons into PROJECT/addons/limboai/icons", default=True),
+)
+env = Environment(tools=["default"], PLATFORM="", variables=vars)
+Help(vars.GenerateHelpText(env))
+
+# Read LimboAI-specific variables.
+deploy_manifest = env["deploy_manifest"]
+deploy_icons = env["deploy_icons"]
+
+# Remove processed variables from ARGUMENTS to avoid godot-cpp warnings.
+for o in vars.options:
+    if o.key in ARGUMENTS:
+        del ARGUMENTS[o.key]
+
+# For reference:
+# - CCFLAGS are compilation flags shared between C and C++
+# - CFLAGS are for C-specific compilation flags
+# - CXXFLAGS are for C++-specific compilation flags
+# - CPPFLAGS are for pre-processor flags
+# - CPPDEFINES are for pre-processor defines
+# - LINKFLAGS are for linking flags
+
+env = SConscript("godot-cpp/SConstruct")
+
+# Generate version header.
+print("Generating LimboAI version header...")
+generate_module_version_header()
+
+# Update icon entries in limboai.gdextension file.
+# Note: This will remove everything after [icons] section, and rebuild it with generated icon entries.
+print("Updating LimboAI icon entries...")
+update_icon_entries(silent=True)
+
+# Fix icon imports in the PROJECT/addons/limboai/icons/.
+# Enables scaling and color conversion in the editor for imported SVG icons.
+try:
+    fix_icon_imports(project_dir)
+except FileNotFoundError as e:
+    print(e)
+except Exception as e:
+    print("Unknown error: " + str(e))
+
+# Tweak this if you want to use different folders, or more folders, to store your source code in.
+env.Append(CPPDEFINES=["LIMBOAI_GDEXTENSION"])
+sources = Glob("*.cpp")
+sources += Glob("blackboard/*.cpp")
+sources += Glob("blackboard/bb_param/*.cpp")
+sources += Glob("bt/*.cpp")
+sources += Glob("bt/tasks/*.cpp")
+sources += Glob("bt/tasks/blackboard/*.cpp")
+sources += Glob("bt/tasks/composites/*.cpp")
+sources += Glob("bt/tasks/decorators/*.cpp")
+sources += Glob("bt/tasks/scene/*.cpp")
+sources += Glob("bt/tasks/utility/*.cpp")
+sources += Glob("gdextension/*.cpp")
+sources += Glob("editor/debugger/*.cpp")
+sources += Glob("editor/*.cpp")
+sources += Glob("hsm/*.cpp")
+sources += Glob("util/*.cpp")
+
+# Generate documentation header.
+if env["target"] in ["editor", "template_debug"]:
+    doc_data = env.GodotCPPDocData("gen/doc_data.gen.cpp", source=Glob("doc_classes/*.xml"))
+    sources.append(doc_data)
+
+# Build library.
+if env["platform"] == "macos":
+    library = env.SharedLibrary(
+        project_dir
+        + "/addons/limboai/bin/liblimboai.{}.{}.framework/liblimboai.{}.{}".format(
+            env["platform"], env["target"], env["platform"], env["target"]
+        ),
+        source=sources,
+    )
+else:
+    library = env.SharedLibrary(
+        project_dir + "/addons/limboai/bin/liblimboai{}{}".format(env["suffix"], env["SHLIBSUFFIX"]),
+        source=sources,
+    )
+
+Default(library)
+
+# Deploy icons into PROJECT/addons/limboai/icons.
+if deploy_icons:
+    cmd_deploy_icons = env.Command(
+        project_dir + "/addons/limboai/icons/",
+        "icons/",
+        Copy("$TARGET", "$SOURCE"),
+    )
+    Default(cmd_deploy_icons)
+
+# Deploy limboai.gdextension into PROJECT/addons/limboai/bin.
+if deploy_manifest:
+    cmd_deploy_manifest = env.Command(
+        project_dir + "/addons/limboai/bin/limboai.gdextension",
+        "gdextension/limboai.gdextension",
+        Copy("$TARGET", "$SOURCE"),
+    )
+    Default(cmd_deploy_manifest)

SCsub

@@ -1,12 +1,29 @@
-# SCsub
+#!/usr/bin/env python
 
-Import('env')
+Import("env")
+Import("env_modules")
 
-env.add_source_files(env.modules_sources, "*.cpp")
+module_env = env.Clone()
-env.add_source_files(env.modules_sources, "bt/*.cpp")
+
-env.add_source_files(env.modules_sources, "bt/composites/*.cpp")
+module_env.Append(CPPDEFINES=["LIMBOAI_MODULE"])
-env.add_source_files(env.modules_sources, "bt/actions/*.cpp")
+
-env.add_source_files(env.modules_sources, "bt/decorators/*.cpp")
+import limboai_version
-env.add_source_files(env.modules_sources, "bt/conditions/*.cpp")
+
-env.add_source_files(env.modules_sources, "editor/*.cpp")
+limboai_version.generate_module_version_header()
-env.add_source_files(env.modules_sources, "bb_param/*.cpp")
+
+module_env.add_source_files(env.modules_sources, "*.cpp")
+module_env.add_source_files(env.modules_sources, "blackboard/*.cpp")
+module_env.add_source_files(env.modules_sources, "blackboard/bb_param/*.cpp")
+module_env.add_source_files(env.modules_sources, "bt/*.cpp")
+module_env.add_source_files(env.modules_sources, "bt/tasks/*.cpp")
+module_env.add_source_files(env.modules_sources, "bt/tasks/blackboard/*.cpp")
+module_env.add_source_files(env.modules_sources, "bt/tasks/composites/*.cpp")
+module_env.add_source_files(env.modules_sources, "bt/tasks/decorators/*.cpp")
+module_env.add_source_files(env.modules_sources, "bt/tasks/misc/*.cpp")
+module_env.add_source_files(env.modules_sources, "bt/tasks/scene/*.cpp")
+module_env.add_source_files(env.modules_sources, "bt/tasks/utility/*.cpp")
+if env.editor_build:
+    module_env.add_source_files(env.modules_sources, "editor/*.cpp")
+module_env.add_source_files(env.modules_sources, "editor/debugger/*.cpp")
+module_env.add_source_files(env.modules_sources, "hsm/*.cpp")
+module_env.add_source_files(env.modules_sources, "util/*.cpp")

bb_param/bb_aabb.h

@@ -1,16 +0,0 @@
-/* bb_aabb.h */
-
-#ifndef BB_AABB_H
-#define BB_AABB_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBAabb : public BBParam {
-	GDCLASS(BBAabb, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::AABB; }
-};
-
-#endif // BB_AABB_H

bb_param/bb_array.h

@@ -1,16 +0,0 @@
-/* bb_array.h */
-
-#ifndef BB_ARRAY_H
-#define BB_ARRAY_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBArray : public BBParam {
-	GDCLASS(BBArray, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::ARRAY; }
-};
-
-#endif // BB_ARRAY_H

bb_param/bb_basis.h

@@ -1,16 +0,0 @@
-/* bb_basis.h */
-
-#ifndef BB_BASIS_H
-#define BB_BASIS_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBBasis : public BBParam {
-	GDCLASS(BBBasis, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::BASIS; }
-};
-
-#endif // BB_BASIS_H

bb_param/bb_bool.h

@@ -1,16 +0,0 @@
-/* bb_bool.h */
-
-#ifndef BB_BOOL_H
-#define BB_BOOL_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBBool : public BBParam {
-	GDCLASS(BBBool, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::BOOL; }
-};
-
-#endif // BB_BOOL_H

bb_param/bb_byte_array.h

@@ -1,16 +0,0 @@
-/* bb_byte_array.h */
-
-#ifndef BB_BYTE_ARRAY_H
-#define BB_BYTE_ARRAY_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBByteArray : public BBParam {
-	GDCLASS(BBByteArray, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::POOL_BYTE_ARRAY; }
-};
-
-#endif // BB_BYTE_ARRAY_H

bb_param/bb_color.h

@@ -1,16 +0,0 @@
-/* bb_color.h */
-
-#ifndef BB_COLOR_H
-#define BB_COLOR_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBColor : public BBParam {
-	GDCLASS(BBColor, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::COLOR; }
-};
-
-#endif // BB_COLOR_H

bb_param/bb_color_array.h

@@ -1,16 +0,0 @@
-/* bb_color_array.h */
-
-#ifndef BB_COLOR_ARRAY_H
-#define BB_COLOR_ARRAY_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBColorArray : public BBParam {
-	GDCLASS(BBColorArray, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::POOL_COLOR_ARRAY; }
-};
-
-#endif // BB_COLOR_ARRAY_H

bb_param/bb_dictionary.h

@@ -1,16 +0,0 @@
-/* bb_dictionary.h */
-
-#ifndef BB_DICTIONARY_H
-#define BB_DICTIONARY_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBDictionary : public BBParam {
-	GDCLASS(BBDictionary, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::DICTIONARY; }
-};
-
-#endif // BB_DICTIONARY_H

bb_param/bb_float.h

@@ -1,16 +0,0 @@
-/* bb_float.h */
-
-#ifndef BB_FLOAT_H
-#define BB_FLOAT_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBFloat : public BBParam {
-	GDCLASS(BBFloat, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::REAL; }
-};
-
-#endif // BB_FLOAT_H

bb_param/bb_int.h

@@ -1,16 +0,0 @@
-/* bb_int.h */
-
-#ifndef BB_INT_H
-#define BB_INT_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBInt : public BBParam {
-	GDCLASS(BBInt, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::INT; }
-};
-
-#endif // BB_INT_H

bb_param/bb_int_array.h

@@ -1,16 +0,0 @@
-/* bb_int_array.h */
-
-#ifndef BB_INT_ARRAY_H
-#define BB_INT_ARRAY_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBIntArray : public BBParam {
-	GDCLASS(BBIntArray, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::POOL_INT_ARRAY; }
-};
-
-#endif // BB_INT_ARRAY_H

bb_param/bb_node.cpp

@@ -1,32 +0,0 @@
-/* bb_node.cpp */
-
-#include "bb_node.h"
-#include "core/error_macros.h"
-#include "core/variant.h"
-#include "scene/main/node.h"
-
-Variant BBNode::get_value(Object *p_agent, const Ref<Blackboard> &p_blackboard, const Variant &p_default) {
-	ERR_FAIL_COND_V(p_agent == nullptr, Variant());
-	ERR_FAIL_COND_V(!p_blackboard.is_valid(), Variant());
-
-	Variant val;
-	if (get_value_source() == SAVED_VALUE) {
-		val = get_saved_value();
-	} else {
-		val = p_blackboard->get_var(get_variable(), p_default);
-	}
-
-	if (val.get_type() == Variant::NODE_PATH) {
-		Node *agent = Object::cast_to<Node>(p_agent);
-		ERR_FAIL_COND_V_MSG(agent == nullptr, Variant(), "BBNode: p_agent must be a Node.");
-		return agent->get_node(val);
-	} else {
-		Node *node = val;
-		if (unlikely(node == nullptr && val.get_type() != Variant::NIL)) {
-			WARN_PRINT("BBNode: Unexpected variant type of a blackboard variable.");
-			return p_default;
-		} else {
-			return node;
-		}
-	}
-}

bb_param/bb_node.h

@@ -1,19 +0,0 @@
-/* bb_node.h */
-
-#ifndef BB_NODE_H
-#define BB_NODE_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBNode : public BBParam {
-	GDCLASS(BBNode, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::NODE_PATH; }
-
-public:
-	virtual Variant get_value(Object *p_agent, const Ref<Blackboard> &p_blackboard, const Variant &p_default = Variant());
-};
-
-#endif // BB_NODE_H

bb_param/bb_param.cpp

@@ -1,87 +0,0 @@
-/* bb_param.cpp */
-
-#include "bb_param.h"
-#include "core/class_db.h"
-#include "core/error_macros.h"
-#include "core/object.h"
-#include "core/variant.h"
-#include "modules/limboai/limbo_utility.h"
-
-VARIANT_ENUM_CAST(BBParam::ValueSource);
-
-void BBParam::set_value_source(ValueSource p_value) {
-	value_source = p_value;
-	property_list_changed_notify();
-	_update_name();
-	emit_changed();
-}
-
-Variant BBParam::get_saved_value() {
-	if (saved_value.get_type() != get_type()) {
-		Variant::CallError err;
-		saved_value = Variant::construct(get_type(), nullptr, 0, err);
-	}
-	return saved_value;
-}
-
-void BBParam::set_saved_value(Variant p_value) {
-	saved_value = p_value;
-	_update_name();
-	emit_changed();
-}
-
-void BBParam::set_variable(const String &p_value) {
-	variable = p_value;
-	_update_name();
-	emit_changed();
-}
-
-String BBParam::to_string() {
-	if (value_source == SAVED_VALUE) {
-		return String(saved_value);
-	} else {
-		return LimboUtility::get_singleton()->decorate_var(variable);
-	}
-}
-
-Variant BBParam::get_value(Object *p_agent, const Ref<Blackboard> &p_blackboard, const Variant &p_default) {
-	ERR_FAIL_COND_V(!p_blackboard.is_valid(), p_default);
-
-	if (value_source == SAVED_VALUE) {
-		return saved_value;
-	} else {
-		return p_blackboard->get_var(variable, p_default);
-	}
-}
-
-void BBParam::_get_property_list(List<PropertyInfo> *p_list) const {
-	if (value_source == ValueSource::SAVED_VALUE) {
-		p_list->push_back(PropertyInfo(get_type(), "saved_value"));
-	} else {
-		p_list->push_back(PropertyInfo(Variant::STRING, "variable"));
-	}
-}
-
-void BBParam::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_value_source", "p_value_source"), &BBParam::set_value_source);
-	ClassDB::bind_method(D_METHOD("get_value_source"), &BBParam::get_value_source);
-	ClassDB::bind_method(D_METHOD("set_saved_value", "p_value"), &BBParam::set_saved_value);
-	ClassDB::bind_method(D_METHOD("get_saved_value"), &BBParam::get_saved_value);
-	ClassDB::bind_method(D_METHOD("set_variable", "p_variable_name"), &BBParam::set_variable);
-	ClassDB::bind_method(D_METHOD("get_variable"), &BBParam::get_variable);
-	ClassDB::bind_method(D_METHOD("get_type"), &BBParam::get_type);
-	ClassDB::bind_method(D_METHOD("get_value", "p_agent", "p_blackboard", "p_default"), &BBParam::get_value, Variant());
-
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "value_source", PROPERTY_HINT_ENUM, "Saved Value, Blackboard Var"), "set_value_source", "get_value_source");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING, "variable", PROPERTY_HINT_NONE, "", 0), "set_variable", "get_variable");
-	ADD_PROPERTY(PropertyInfo(Variant::NIL, "saved_value", PROPERTY_HINT_NONE, "", 0), "set_saved_value", "get_saved_value");
-
-	BIND_ENUM_CONSTANT(SAVED_VALUE);
-	BIND_ENUM_CONSTANT(BLACKBOARD_VAR);
-}
-
-BBParam::BBParam() {
-	value_source = SAVED_VALUE;
-	variable = "";
-	saved_value = Variant();
-}

bb_param/bb_param.h

@@ -1,55 +0,0 @@
-/* bb_param.h */
-
-#ifndef BB_PARAM_H
-#define BB_PARAM_H
-
-#include "core/object.h"
-#include "core/resource.h"
-#include "core/typedefs.h"
-#include "core/variant.h"
-#include "modules/limboai/blackboard.h"
-#include "modules/limboai/limbo_utility.h"
-
-class BBParam : public Resource {
-	GDCLASS(BBParam, Resource);
-
-public:
-	enum ValueSource : unsigned int {
-		SAVED_VALUE,
-		BLACKBOARD_VAR
-	};
-
-private:
-	ValueSource value_source;
-	Variant saved_value;
-	String variable;
-
-	_FORCE_INLINE_ void _update_name() {
-		set_name((value_source == SAVED_VALUE) ? String(saved_value) : LimboUtility::get_singleton()->decorate_var(variable));
-	}
-
-protected:
-	static void _bind_methods();
-
-	virtual Variant::Type get_type() const { return Variant::NIL; }
-
-	void _get_property_list(List<PropertyInfo> *p_list) const;
-
-public:
-	void set_value_source(ValueSource p_value);
-	ValueSource get_value_source() const { return value_source; }
-
-	void set_saved_value(Variant p_value);
-	Variant get_saved_value();
-
-	void set_variable(const String &p_value);
-	String get_variable() const { return variable; }
-
-	virtual String to_string();
-
-	virtual Variant get_value(Object *p_agent, const Ref<Blackboard> &p_blackboard, const Variant &p_default = Variant());
-
-	BBParam();
-};
-
-#endif // BB_PARAM_H

bb_param/bb_plane.h

@@ -1,16 +0,0 @@
-/* bb_plane.h */
-
-#ifndef BB_PLANE_H
-#define BB_PLANE_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBPlane : public BBParam {
-	GDCLASS(BBPlane, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::PLANE; }
-};
-
-#endif // BB_PLANE_H

bb_param/bb_quat.h

@@ -1,16 +0,0 @@
-/* bb_quat.h */
-
-#ifndef BB_QUAT_H
-#define BB_QUAT_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBQuat : public BBParam {
-	GDCLASS(BBQuat, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::QUAT; }
-};
-
-#endif // BB_QUAT_H

bb_param/bb_real_array.h

@@ -1,16 +0,0 @@
-/* bb_real_array.h */
-
-#ifndef BB_REAL_ARRAY_H
-#define BB_REAL_ARRAY_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBRealArray : public BBParam {
-	GDCLASS(BBRealArray, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::POOL_REAL_ARRAY; }
-};
-
-#endif // BB_REAL_ARRAY_H

bb_param/bb_rect2.h

@@ -1,16 +0,0 @@
-/* bb_rect2.h */
-
-#ifndef BB_RECT2_H
-#define BB_RECT2_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBRect2 : public BBParam {
-	GDCLASS(BBRect2, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::RECT2; }
-};
-
-#endif // BB_RECT2_H

bb_param/bb_string.h

@@ -1,16 +0,0 @@
-/* bb_string.h */
-
-#ifndef BB_STRING_H
-#define BB_STRING_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBString : public BBParam {
-	GDCLASS(BBString, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::STRING; }
-};
-
-#endif // BB_STRING_H

bb_param/bb_string_array.h

@@ -1,16 +0,0 @@
-/* bb_string_array.h */
-
-#ifndef BB_STRING_ARRAY_H
-#define BB_STRING_ARRAY_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBStringArray : public BBParam {
-	GDCLASS(BBStringArray, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::POOL_STRING_ARRAY; }
-};
-
-#endif // BB_STRING_ARRAY_H

bb_param/bb_transform.h

@@ -1,16 +0,0 @@
-/* bb_transform.h */
-
-#ifndef BB_TRANSFORM_H
-#define BB_TRANSFORM_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBTransform : public BBParam {
-	GDCLASS(BBTransform, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::TRANSFORM; }
-};
-
-#endif // BB_TRANSFORM_H

bb_param/bb_transform2d.h

@@ -1,16 +0,0 @@
-/* bb_transform2d.h */
-
-#ifndef BB_TRANSFORM2D_H
-#define BB_TRANSFORM2D_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBTransform2D : public BBParam {
-	GDCLASS(BBTransform2D, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::TRANSFORM2D; }
-};
-
-#endif // BB_TRANSFORM2D_H

bb_param/bb_variant.cpp

@@ -1,28 +0,0 @@
-/* bb_variant.cpp */
-
-#include "bb_variant.h"
-#include "core/object.h"
-#include "core/variant.h"
-
-void BBVariant::set_type(Variant::Type p_type) {
-	type = p_type;
-	property_list_changed_notify();
-	emit_changed();
-}
-
-void BBVariant::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_type", "p_type"), &BBVariant::set_type);
-
-	String vtypes;
-	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
-		if (i > 0) {
-			vtypes += ",";
-		}
-		vtypes += Variant::get_type_name(Variant::Type(i));
-	}
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, vtypes), "set_type", "get_type");
-}
-
-BBVariant::BBVariant() {
-	type = Variant::NIL;
-}

bb_param/bb_variant.h

@@ -1,26 +0,0 @@
-/* bb_variant.h */
-
-#ifndef BB_VARIANT_H
-#define BB_VARIANT_H
-
-#include "bb_param.h"
-#include "core/object.h"
-#include "core/variant.h"
-
-class BBVariant : public BBParam {
-	GDCLASS(BBVariant, BBParam);
-
-private:
-	Variant::Type type;
-
-protected:
-	static void _bind_methods();
-
-	virtual Variant::Type get_type() const { return type; }
-	void set_type(Variant::Type p_type);
-
-public:
-	BBVariant();
-};
-
-#endif // BB_VARIANT

bb_param/bb_vector2.h

@@ -1,16 +0,0 @@
-/* bb_vector2.h */
-
-#ifndef BB_VECTOR2_H
-#define BB_VECTOR2_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBVector2 : public BBParam {
-	GDCLASS(BBVector2, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::VECTOR2; }
-};
-
-#endif // BB_VECTOR2_H

bb_param/bb_vector2_array.h

@@ -1,16 +0,0 @@
-/* bb_vector2_array.h */
-
-#ifndef BB_VECTOR2_ARRAY_H
-#define BB_VECTOR2_ARRAY_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBVector2Array : public BBParam {
-	GDCLASS(BBVector2Array, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::POOL_VECTOR2_ARRAY; }
-};
-
-#endif // BB_VECTOR2_ARRAY_H

bb_param/bb_vector3.h

@@ -1,16 +0,0 @@
-/* bb_vector3.h */
-
-#ifndef BB_VECTOR3_H
-#define BB_VECTOR3_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBVector3 : public BBParam {
-	GDCLASS(BBVector3, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::VECTOR3; }
-};
-
-#endif // BB_VECTOR3_H

bb_param/bb_vector3_array.h

@@ -1,16 +0,0 @@
-/* bb_vector3_array.h */
-
-#ifndef BB_VECTOR3_ARRAY_H
-#define BB_VECTOR3_ARRAY_H
-
-#include "bb_param.h"
-#include "core/object.h"
-
-class BBVector3Array : public BBParam {
-	GDCLASS(BBVector3Array, BBParam);
-
-protected:
-	virtual Variant::Type get_type() const { return Variant::POOL_VECTOR3_ARRAY; }
-};
-
-#endif // BB_VECTOR3_ARRAY_H

blackboard.cpp

@@ -1,58 +0,0 @@
-/* blackboard.cpp */
-
-#include "blackboard.h"
-#include "core/error_macros.h"
-#include "core/variant.h"
-#include "scene/main/node.h"
-#include <cstddef>
-
-Ref<Blackboard> Blackboard::top() const {
-	Ref<Blackboard> bb(this);
-	while (bb->get_parent_scope().is_valid()) {
-		bb = bb->get_parent_scope();
-	}
-	return bb;
-}
-
-Variant Blackboard::get_var(const Variant &p_key, const Variant &p_default) const {
-	if (data.has(p_key)) {
-		return data.get_valid(p_key);
-	} else if (parent.is_valid()) {
-		return parent->get_var(p_key, p_default);
-	} else {
-		return p_default;
-	}
-}
-
-void Blackboard::set_var(const Variant &p_key, const Variant &p_value) {
-	data[p_key] = p_value;
-}
-
-bool Blackboard::has_var(const Variant &p_key) const {
-	return data.has(p_key) || (parent.is_valid() && parent->has_var(p_key));
-}
-
-void Blackboard::prefetch_nodepath_vars(Node *p_node) {
-	ERR_FAIL_COND(p_node == nullptr);
-	for (int i = 0; i < data.size(); i++) {
-		Variant value = data.get_value_at_index(i);
-		if (value.get_type() == Variant::NODE_PATH) {
-			Node *fetched_node = p_node->get_node_or_null(value);
-			if (fetched_node != nullptr) {
-				data[data.get_key_at_index(i)] = fetched_node;
-			}
-		}
-	}
-};
-
-void Blackboard::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("get_data"), &Blackboard::get_data);
-	ClassDB::bind_method(D_METHOD("set_data", "p_data"), &Blackboard::set_data);
-	ClassDB::bind_method(D_METHOD("get_var", "p_key", "p_default"), &Blackboard::get_var, Variant());
-	ClassDB::bind_method(D_METHOD("set_var", "p_key", "p_value"), &Blackboard::set_var);
-	ClassDB::bind_method(D_METHOD("has_var", "p_key"), &Blackboard::has_var);
-	ClassDB::bind_method(D_METHOD("set_parent_scope", "p_blackboard"), &Blackboard::set_parent_scope);
-	ClassDB::bind_method(D_METHOD("get_parent_scope"), &Blackboard::get_parent_scope);
-	ClassDB::bind_method(D_METHOD("prefetch_nodepath_vars", "p_node"), &Blackboard::prefetch_nodepath_vars);
-	ClassDB::bind_method(D_METHOD("top"), &Blackboard::top);
-}

blackboard.h

@@ -1,36 +0,0 @@
-/* blackboard.h */
-
-#ifndef BLACKBOARD_H
-#define BLACKBOARD_H
-
-#include "core/dictionary.h"
-#include "core/object.h"
-#include "core/reference.h"
-#include "core/variant.h"
-
-class Blackboard : public Reference {
-	GDCLASS(Blackboard, Reference);
-
-private:
-	Dictionary data;
-	Ref<Blackboard> parent;
-
-protected:
-	static void _bind_methods();
-
-public:
-	void set_data(const Dictionary &p_value) { data = p_value; }
-	Dictionary get_data() const { return data; }
-
-	void set_parent_scope(const Ref<Blackboard> &p_blackboard) { parent = p_blackboard; }
-	Ref<Blackboard> get_parent_scope() const { return parent; }
-
-	Ref<Blackboard> top() const;
-
-	Variant get_var(const Variant &p_key, const Variant &p_default) const;
-	void set_var(const Variant &p_key, const Variant &p_value);
-	bool has_var(const Variant &p_key) const;
-	void prefetch_nodepath_vars(Node *p_node);
-};
-
-#endif // BLACKBOARD_H

blackboard/bb_param/bb_aabb.h

@@ -0,0 +1,26 @@
+/**
+ * bb_aabb.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_AABB_H
+#define BB_AABB_H
+
+#include "bb_param.h"
+
+class BBAabb : public BBParam {
+	GDCLASS(BBAabb, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::AABB; }
+};
+
+#endif // BB_AABB_H

blackboard/bb_param/bb_array.h

@@ -0,0 +1,26 @@
+/**
+ * bb_array.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_ARRAY_H
+#define BB_ARRAY_H
+
+#include "bb_param.h"
+
+class BBArray : public BBParam {
+	GDCLASS(BBArray, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::ARRAY; }
+};
+
+#endif // BB_ARRAY_H

blackboard/bb_param/bb_basis.h

@@ -0,0 +1,26 @@
+/**
+ * bb_basis.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_BASIS_H
+#define BB_BASIS_H
+
+#include "bb_param.h"
+
+class BBBasis : public BBParam {
+	GDCLASS(BBBasis, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::BASIS; }
+};
+
+#endif // BB_BASIS_H

blackboard/bb_param/bb_bool.h

@@ -0,0 +1,26 @@
+/**
+ * bb_bool.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_BOOL_H
+#define BB_BOOL_H
+
+#include "bb_param.h"
+
+class BBBool : public BBParam {
+	GDCLASS(BBBool, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::BOOL; }
+};
+
+#endif // BB_BOOL_H

blackboard/bb_param/bb_byte_array.h

@@ -0,0 +1,26 @@
+/**
+ * bb_byte_array.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_BYTE_ARRAY_H
+#define BB_BYTE_ARRAY_H
+
+#include "bb_param.h"
+
+class BBByteArray : public BBParam {
+	GDCLASS(BBByteArray, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::PACKED_BYTE_ARRAY; }
+};
+
+#endif // BB_BYTE_ARRAY_H

blackboard/bb_param/bb_color.h

@@ -0,0 +1,26 @@
+/**
+ * bb_color.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_COLOR_H
+#define BB_COLOR_H
+
+#include "bb_param.h"
+
+class BBColor : public BBParam {
+	GDCLASS(BBColor, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::COLOR; }
+};
+
+#endif // BB_COLOR_H

blackboard/bb_param/bb_color_array.h

@@ -0,0 +1,26 @@
+/**
+ * bb_color_array.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_COLOR_ARRAY_H
+#define BB_COLOR_ARRAY_H
+
+#include "bb_param.h"
+
+class BBColorArray : public BBParam {
+	GDCLASS(BBColorArray, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::PACKED_COLOR_ARRAY; }
+};
+
+#endif // BB_COLOR_ARRAY_H

blackboard/bb_param/bb_dictionary.h

@@ -0,0 +1,26 @@
+/**
+ * bb_dictionary.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_DICTIONARY_H
+#define BB_DICTIONARY_H
+
+#include "bb_param.h"
+
+class BBDictionary : public BBParam {
+	GDCLASS(BBDictionary, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::DICTIONARY; }
+};
+
+#endif // BB_DICTIONARY_H

blackboard/bb_param/bb_float.h

@@ -0,0 +1,26 @@
+/**
+ * bb_float.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_FLOAT_H
+#define BB_FLOAT_H
+
+#include "bb_param.h"
+
+class BBFloat : public BBParam {
+	GDCLASS(BBFloat, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::FLOAT; }
+};
+
+#endif // BB_FLOAT_H

blackboard/bb_param/bb_float32_array.h

@@ -0,0 +1,26 @@
+/**
+ * bb_float32_array.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_FLOAT32_ARRAY_H
+#define BB_FLOAT32_ARRAY_H
+
+#include "bb_param.h"
+
+class BBFloat32Array : public BBParam {
+	GDCLASS(BBFloat32Array, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::PACKED_FLOAT32_ARRAY; }
+};
+
+#endif // BB_FLOAT32_ARRAY_H

blackboard/bb_param/bb_float64_array.h

@@ -0,0 +1,26 @@
+/**
+ * bb_float64_array.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_FLOAT64_ARRAY_H
+#define BB_FLOAT64_ARRAY_H
+
+#include "bb_param.h"
+
+class BBFloat64Array : public BBParam {
+	GDCLASS(BBFloat64Array, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::PACKED_FLOAT64_ARRAY; }
+};
+
+#endif // BB_FLOAT64_ARRAY_H

blackboard/bb_param/bb_int.h

@@ -0,0 +1,26 @@
+/**
+ * bb_int.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_INT_H
+#define BB_INT_H
+
+#include "bb_param.h"
+
+class BBInt : public BBParam {
+	GDCLASS(BBInt, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::INT; }
+};
+
+#endif // BB_INT_H

blackboard/bb_param/bb_int32_array.h

@@ -0,0 +1,26 @@
+/**
+ * bb_int32_array.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_INT32_ARRAY_H
+#define BB_INT32_ARRAY_H
+
+#include "bb_param.h"
+
+class BBInt32Array : public BBParam {
+	GDCLASS(BBInt32Array, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::PACKED_INT32_ARRAY; }
+};
+
+#endif // BB_INT32_ARRAY_H

blackboard/bb_param/bb_int64_array.h

@@ -0,0 +1,26 @@
+/**
+ * bb_int64_array.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_INT64_ARRAY_H
+#define BB_INT64_ARRAY_H
+
+#include "bb_param.h"
+
+class BBInt64Array : public BBParam {
+	GDCLASS(BBInt64Array, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::PACKED_INT64_ARRAY; }
+};
+
+#endif // BB_INT64_ARRAY_H

blackboard/bb_param/bb_node.cpp

@@ -0,0 +1,33 @@
+/**
+ * bb_node.cpp
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#include "bb_node.h"
+
+Variant BBNode::get_value(Node *p_scene_root, const Ref<Blackboard> &p_blackboard, const Variant &p_default) {
+	ERR_FAIL_NULL_V_MSG(p_scene_root, Variant(), "BBNode: get_value() failed - scene_root is null.");
+	ERR_FAIL_COND_V_MSG(p_blackboard.is_null(), Variant(), "BBNode: get_value() failed - blackboard is null.");
+
+	Variant val;
+	if (get_value_source() == SAVED_VALUE) {
+		val = get_saved_value();
+	} else {
+		val = p_blackboard->get_var(get_variable(), p_default);
+	}
+
+	if (val.get_type() == Variant::NODE_PATH) {
+		return p_scene_root->get_node_or_null(val);
+	} else if (val.get_type() == Variant::OBJECT || val.get_type() == Variant::NIL) {
+		return val;
+	} else {
+		WARN_PRINT("BBNode: Unexpected variant type: " + Variant::get_type_name(val.get_type()) + ". Returning default value.");
+		return p_default;
+	}
+}

blackboard/bb_param/bb_node.h

@@ -0,0 +1,28 @@
+/**
+ * bb_node.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_NODE_H
+#define BB_NODE_H
+
+#include "bb_param.h"
+
+class BBNode : public BBParam {
+	GDCLASS(BBNode, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+public:
+	virtual Variant::Type get_type() const override { return Variant::NODE_PATH; }
+	virtual Variant get_value(Node *p_scene_root, const Ref<Blackboard> &p_blackboard, const Variant &p_default = Variant()) override;
+};
+
+#endif // BB_NODE_H

blackboard/bb_param/bb_param.cpp

@@ -0,0 +1,120 @@
+/**
+ * bb_param.cpp
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#include "bb_param.h"
+
+#include "../../util/limbo_utility.h"
+
+#ifdef LIMBOAI_MODULE
+#endif // LIMBOAI_MODULE
+
+#ifdef LIMBOAI_GDEXTENSION
+using namespace godot;
+#endif // LIMBOAI_GDEXTENSION
+
+VARIANT_ENUM_CAST(BBParam::ValueSource);
+
+void BBParam::set_value_source(ValueSource p_value) {
+	value_source = p_value;
+	notify_property_list_changed();
+	_update_name();
+	emit_changed();
+}
+
+Variant BBParam::get_saved_value() {
+	return saved_value;
+}
+
+void BBParam::set_saved_value(Variant p_value) {
+	if (p_value.get_type() == Variant::NIL) {
+		_assign_default_value();
+	} else {
+		saved_value = p_value;
+	}
+	_update_name();
+	emit_changed();
+}
+
+void BBParam::set_variable(const StringName &p_variable) {
+	variable = p_variable;
+	_update_name();
+	emit_changed();
+}
+
+#ifdef LIMBOAI_MODULE
+String BBParam::to_string() {
+#elif LIMBOAI_GDEXTENSION
+String BBParam::_to_string() {
+#endif
+	if (value_source == SAVED_VALUE) {
+		String s = saved_value.stringify();
+		switch (get_type()) {
+			case Variant::STRING: {
+				s = "\"" + s.c_escape() + "\"";
+			} break;
+			case Variant::STRING_NAME: {
+				s = "&\"" + s.c_escape() + "\"";
+			} break;
+			case Variant::NODE_PATH: {
+				s = "^\"" + s.c_escape() + "\"";
+			} break;
+			default: {
+			} break;
+		}
+		return s;
+	} else {
+		return LimboUtility::get_singleton()->decorate_var(variable);
+	}
+}
+
+Variant BBParam::get_value(Node *p_scene_root, const Ref<Blackboard> &p_blackboard, const Variant &p_default) {
+	ERR_FAIL_COND_V(!p_blackboard.is_valid(), p_default);
+
+	if (value_source == SAVED_VALUE) {
+		if (saved_value == Variant()) {
+			_assign_default_value();
+		}
+		return saved_value;
+	} else {
+		ERR_FAIL_COND_V_MSG(!p_blackboard->has_var(variable), p_default, vformat("BBParam: Blackboard variable \"%s\" doesn't exist.", variable));
+		return p_blackboard->get_var(variable, p_default);
+	}
+}
+
+void BBParam::_get_property_list(List<PropertyInfo> *p_list) const {
+	if (value_source == ValueSource::SAVED_VALUE) {
+		p_list->push_back(PropertyInfo(get_type(), "saved_value"));
+	} else {
+		p_list->push_back(PropertyInfo(Variant::STRING_NAME, "variable"));
+	}
+}
+
+void BBParam::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_value_source", "value_source"), &BBParam::set_value_source);
+	ClassDB::bind_method(D_METHOD("get_value_source"), &BBParam::get_value_source);
+	ClassDB::bind_method(D_METHOD("set_saved_value", "value"), &BBParam::set_saved_value);
+	ClassDB::bind_method(D_METHOD("get_saved_value"), &BBParam::get_saved_value);
+	ClassDB::bind_method(D_METHOD("set_variable", "variable_name"), &BBParam::set_variable);
+	ClassDB::bind_method(D_METHOD("get_variable"), &BBParam::get_variable);
+	ClassDB::bind_method(D_METHOD("get_type"), &BBParam::get_type);
+	ClassDB::bind_method(D_METHOD("get_value", "scene_root", "blackboard", "default"), &BBParam::get_value, Variant());
+
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "value_source", PROPERTY_HINT_ENUM, "Saved Value,Blackboard Var"), "set_value_source", "get_value_source");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "variable", PROPERTY_HINT_NONE, "", 0), "set_variable", "get_variable");
+	ADD_PROPERTY(PropertyInfo(Variant::NIL, "saved_value", PROPERTY_HINT_NONE, "", 0), "set_saved_value", "get_saved_value");
+
+	BIND_ENUM_CONSTANT(SAVED_VALUE);
+	BIND_ENUM_CONSTANT(BLACKBOARD_VAR);
+}
+
+BBParam::BBParam() {
+	value_source = SAVED_VALUE;
+}

blackboard/bb_param/bb_param.h

@@ -0,0 +1,74 @@
+/**
+ * bb_param.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_PARAM_H
+#define BB_PARAM_H
+
+#include "../../blackboard/blackboard.h"
+#include "../../util/limbo_utility.h"
+
+#ifdef LIMBOAI_MODULE
+#include "core/io/resource.h"
+#endif // LIMBOAI_MODULE
+
+#ifdef LIMBOAI_GDEXTENSION
+#include <godot_cpp/classes/resource.hpp>
+#endif // LIMBOAI_GDEXTENSION
+
+class BBParam : public Resource {
+	GDCLASS(BBParam, Resource);
+
+public:
+	enum ValueSource : unsigned int {
+		SAVED_VALUE,
+		BLACKBOARD_VAR
+	};
+
+private:
+	ValueSource value_source;
+	Variant saved_value;
+	StringName variable;
+
+	_FORCE_INLINE_ void _update_name() {
+		set_name((value_source == SAVED_VALUE) ? String(saved_value) : LimboUtility::get_singleton()->decorate_var(variable));
+	}
+
+protected:
+	static void _bind_methods();
+
+	_FORCE_INLINE_ void _assign_default_value() { saved_value = VARIANT_DEFAULT(get_type()); }
+
+	void _get_property_list(List<PropertyInfo> *p_list) const;
+
+public:
+	void set_value_source(ValueSource p_value);
+	ValueSource get_value_source() const { return value_source; }
+
+	void set_saved_value(Variant p_value);
+	Variant get_saved_value();
+
+	void set_variable(const StringName &p_variable);
+	StringName get_variable() const { return variable; }
+
+#ifdef LIMBOAI_MODULE
+	virtual String to_string() override;
+#elif LIMBOAI_GDEXTENSION
+	virtual String _to_string();
+#endif
+
+	virtual Variant::Type get_type() const { return Variant::NIL; }
+	virtual Variant::Type get_variable_expected_type() const { return get_type(); }
+	virtual Variant get_value(Node *p_scene_root, const Ref<Blackboard> &p_blackboard, const Variant &p_default = Variant());
+
+	BBParam();
+};
+
+#endif // BB_PARAM_H

blackboard/bb_param/bb_plane.h

@@ -0,0 +1,26 @@
+/**
+ * bb_plane.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_PLANE_H
+#define BB_PLANE_H
+
+#include "bb_param.h"
+
+class BBPlane : public BBParam {
+	GDCLASS(BBPlane, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::PLANE; }
+};
+
+#endif // BB_PLANE_H

blackboard/bb_param/bb_projection.h

@@ -0,0 +1,26 @@
+/**
+ * bb_projection.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_PROJECTION_H
+#define BB_PROJECTION_H
+
+#include "bb_param.h"
+
+class BBProjection : public BBParam {
+	GDCLASS(BBProjection, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::PROJECTION; }
+};
+
+#endif // BB_PROJECTION_H

blackboard/bb_param/bb_quaternion.h

@@ -0,0 +1,26 @@
+/**
+ * bb_quaternion.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_QUATERNION_H
+#define BB_QUATERNION_H
+
+#include "bb_param.h"
+
+class BBQuaternion : public BBParam {
+	GDCLASS(BBQuaternion, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::QUATERNION; }
+};
+
+#endif // BB_QUATERNION_H

blackboard/bb_param/bb_rect2.h

@@ -0,0 +1,26 @@
+/**
+ * bb_rect2.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_RECT2_H
+#define BB_RECT2_H
+
+#include "bb_param.h"
+
+class BBRect2 : public BBParam {
+	GDCLASS(BBRect2, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::RECT2; }
+};
+
+#endif // BB_RECT2_H

blackboard/bb_param/bb_rect2i.h

@@ -0,0 +1,26 @@
+/**
+ * bb_rect2i.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_RECT2I_H
+#define BB_RECT2I_H
+
+#include "bb_param.h"
+
+class BBRect2i : public BBParam {
+	GDCLASS(BBRect2i, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::RECT2I; }
+};
+
+#endif // BB_RECT2I_H

blackboard/bb_param/bb_string.h

@@ -0,0 +1,26 @@
+/**
+ * bb_string.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_STRING_H
+#define BB_STRING_H
+
+#include "bb_param.h"
+
+class BBString : public BBParam {
+	GDCLASS(BBString, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::STRING; }
+};
+
+#endif // BB_STRING_H

blackboard/bb_param/bb_string_array.h

@@ -0,0 +1,26 @@
+/**
+ * bb_string_array.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_STRING_ARRAY_H
+#define BB_STRING_ARRAY_H
+
+#include "bb_param.h"
+
+class BBStringArray : public BBParam {
+	GDCLASS(BBStringArray, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::PACKED_STRING_ARRAY; }
+};
+
+#endif // BB_STRING_ARRAY_H

blackboard/bb_param/bb_string_name.h

@@ -0,0 +1,26 @@
+/**
+ * bb_string_name.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_STRING_NAME_H
+#define BB_STRING_NAME_H
+
+#include "bb_param.h"
+
+class BBStringName : public BBParam {
+	GDCLASS(BBStringName, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::STRING_NAME; }
+};
+
+#endif // BB_STRING_H

blackboard/bb_param/bb_transform2d.h

@@ -0,0 +1,26 @@
+/**
+ * bb_transform2d.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_TRANSFORM2D_H
+#define BB_TRANSFORM2D_H
+
+#include "bb_param.h"
+
+class BBTransform2D : public BBParam {
+	GDCLASS(BBTransform2D, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::TRANSFORM2D; }
+};
+
+#endif // BB_TRANSFORM2D_H

blackboard/bb_param/bb_transform3d.h

@@ -0,0 +1,26 @@
+/**
+ * bb_transform3d.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_TRANSFORM3D_H
+#define BB_TRANSFORM3D_H
+
+#include "bb_param.h"
+
+class BBTransform3D : public BBParam {
+	GDCLASS(BBTransform3D, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::TRANSFORM3D; }
+};
+
+#endif // BB_TRANSFORM3D_H

blackboard/bb_param/bb_variant.cpp

@@ -0,0 +1,48 @@
+/**
+ * bb_variant.cpp
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#include "bb_variant.h"
+
+void BBVariant::set_type(Variant::Type p_type) {
+	if (type != p_type) {
+		type = p_type;
+		if (get_saved_value().get_type() != p_type) {
+			_assign_default_value();
+		}
+		emit_changed();
+		notify_property_list_changed();
+	}
+}
+
+Variant::Type BBVariant::get_type() const {
+	return type;
+}
+
+void BBVariant::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_type", "type"), &BBVariant::set_type);
+
+	String vtypes;
+	for (int i = 0; i < Variant::VARIANT_MAX; i++) {
+		if (i > 0) {
+			vtypes += ",";
+		}
+		vtypes += Variant::get_type_name(Variant::Type(i));
+	}
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, vtypes), "set_type", "get_type");
+}
+
+BBVariant::BBVariant(const Variant &p_value) {
+	set_type(p_value.get_type());
+	set_saved_value(p_value);
+}
+
+BBVariant::BBVariant() {
+}

blackboard/bb_param/bb_variant.h

@@ -0,0 +1,36 @@
+/**
+ * bb_variant.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_VARIANT_H
+#define BB_VARIANT_H
+
+#include "bb_param.h"
+
+class BBVariant : public BBParam {
+	GDCLASS(BBVariant, BBParam);
+
+private:
+	Variant::Type type = Variant::NIL;
+
+protected:
+	static void _bind_methods();
+
+public:
+	virtual Variant::Type get_type() const override;
+	void set_type(Variant::Type p_type);
+
+	virtual Variant::Type get_variable_expected_type() const override { return Variant::NIL; }
+
+	BBVariant(const Variant &p_value);
+	BBVariant();
+};
+
+#endif // BB_VARIANT

blackboard/bb_param/bb_vector2.h

@@ -0,0 +1,26 @@
+/**
+ * bb_vector2.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_VECTOR2_H
+#define BB_VECTOR2_H
+
+#include "bb_param.h"
+
+class BBVector2 : public BBParam {
+	GDCLASS(BBVector2, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::VECTOR2; }
+};
+
+#endif // BB_VECTOR2_H

blackboard/bb_param/bb_vector2_array.h

@@ -0,0 +1,26 @@
+/**
+ * bb_vector2_array.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_VECTOR2_ARRAY_H
+#define BB_VECTOR2_ARRAY_H
+
+#include "bb_param.h"
+
+class BBVector2Array : public BBParam {
+	GDCLASS(BBVector2Array, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::PACKED_VECTOR2_ARRAY; }
+};
+
+#endif // BB_VECTOR2_ARRAY_H

blackboard/bb_param/bb_vector2i.h

@@ -0,0 +1,26 @@
+/**
+ * bb_vector2i.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_VECTOR2I_H
+#define BB_VECTOR2I_H
+
+#include "bb_param.h"
+
+class BBVector2i : public BBParam {
+	GDCLASS(BBVector2i, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::VECTOR2I; }
+};
+
+#endif // BB_VECTOR2I_H

blackboard/bb_param/bb_vector3.h

@@ -0,0 +1,26 @@
+/**
+ * bb_vector3.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_VECTOR3_H
+#define BB_VECTOR3_H
+
+#include "bb_param.h"
+
+class BBVector3 : public BBParam {
+	GDCLASS(BBVector3, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::VECTOR3; }
+};
+
+#endif // BB_VECTOR3_H

blackboard/bb_param/bb_vector3_array.h

@@ -0,0 +1,26 @@
+/**
+ * bb_vector3_array.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_VECTOR3_ARRAY_H
+#define BB_VECTOR3_ARRAY_H
+
+#include "bb_param.h"
+
+class BBVector3Array : public BBParam {
+	GDCLASS(BBVector3Array, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::PACKED_VECTOR3_ARRAY; }
+};
+
+#endif // BB_VECTOR3_ARRAY_H

blackboard/bb_param/bb_vector3i.h

@@ -0,0 +1,26 @@
+/**
+ * bb_vector3i.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_VECTOR3I_H
+#define BB_VECTOR3I_H
+
+#include "bb_param.h"
+
+class BBVector3i : public BBParam {
+	GDCLASS(BBVector3i, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::VECTOR3I; }
+};
+
+#endif // BB_VECTOR3I_H

blackboard/bb_param/bb_vector4.h

@@ -0,0 +1,26 @@
+/**
+ * bb_vector4.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_VECTOR4_H
+#define BB_VECTOR4_H
+
+#include "bb_param.h"
+
+class BBVector4 : public BBParam {
+	GDCLASS(BBVector4, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::VECTOR4; }
+};
+
+#endif // BB_VECTOR4_H

blackboard/bb_param/bb_vector4i.h

@@ -0,0 +1,26 @@
+/**
+ * bb_vector4i.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_VECTOR4I_H
+#define BB_VECTOR4I_H
+
+#include "bb_param.h"
+
+class BBVector4i : public BBParam {
+	GDCLASS(BBVector4i, BBParam);
+
+protected:
+	static void _bind_methods() {}
+
+	virtual Variant::Type get_type() const override { return Variant::VECTOR4I; }
+};
+
+#endif // BB_VECTOR4I_H

blackboard/bb_variable.cpp

@@ -0,0 +1,190 @@
+/**
+ * bb_variable.cpp
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#include "bb_variable.h"
+
+#include "../util/limbo_compat.h"
+
+void BBVariable::unref() {
+	if (data && data->refcount.unref()) {
+		memdelete(data);
+	}
+	data = nullptr;
+}
+
+void BBVariable::set_value(const Variant &p_value) {
+	data->value = p_value; // Setting value even when bound as a fallback in case the binding fails.
+	data->value_changed = true;
+
+	if (is_bound()) {
+		Object *obj = OBJECT_DB_GET_INSTANCE(data->bound_object);
+		ERR_FAIL_COND_MSG(!obj, "Blackboard: Failed to get bound object.");
+#ifdef LIMBOAI_MODULE
+		bool r_valid;
+		obj->set(data->bound_property, p_value, &r_valid);
+		ERR_FAIL_COND_MSG(!r_valid, vformat("Blackboard: Failed to set bound property `%s` on %s", data->bound_property, obj));
+#elif LIMBOAI_GDEXTENSION
+		obj->set(data->bound_property, p_value);
+#endif
+	}
+}
+
+Variant BBVariable::get_value() const {
+	if (is_bound()) {
+		Object *obj = OBJECT_DB_GET_INSTANCE(data->bound_object);
+		ERR_FAIL_COND_V_MSG(!obj, data->value, "Blackboard: Failed to get bound object.");
+#ifdef LIMBOAI_MODULE
+		bool r_valid;
+		Variant ret = obj->get(data->bound_property, &r_valid);
+		ERR_FAIL_COND_V_MSG(!r_valid, data->value, vformat("Blackboard: Failed to get bound property `%s` on %s", data->bound_property, obj));
+#elif LIMBOAI_GDEXTENSION
+		Variant ret = obj->get(data->bound_property);
+#endif
+		return ret;
+	}
+	return data->value;
+}
+
+void BBVariable::set_type(Variant::Type p_type) {
+	data->type = p_type;
+	data->value = VARIANT_DEFAULT(p_type);
+}
+
+Variant::Type BBVariable::get_type() const {
+	return data->type;
+}
+
+void BBVariable::set_hint(PropertyHint p_hint) {
+	data->hint = p_hint;
+}
+
+PropertyHint BBVariable::get_hint() const {
+	return data->hint;
+}
+
+void BBVariable::set_hint_string(const String &p_hint_string) {
+	data->hint_string = p_hint_string;
+}
+
+String BBVariable::get_hint_string() const {
+	return data->hint_string;
+}
+
+BBVariable BBVariable::duplicate(bool p_deep) const {
+	BBVariable var;
+	var.data->hint = data->hint;
+	var.data->hint_string = data->hint_string;
+	var.data->type = data->type;
+	if (p_deep) {
+		var.data->value = data->value.duplicate(p_deep);
+	} else {
+		var.data->value = data->value;
+	}
+	var.data->binding_path = data->binding_path;
+	var.data->bound_object = data->bound_object;
+	var.data->bound_property = data->bound_property;
+	return var;
+}
+
+bool BBVariable::is_same_prop_info(const BBVariable &p_other) const {
+	if (data->type != p_other.data->type) {
+		return false;
+	}
+	if (data->hint != p_other.data->hint) {
+		return false;
+	}
+	if (data->hint_string != p_other.data->hint_string) {
+		return false;
+	}
+	return true;
+}
+
+void BBVariable::copy_prop_info(const BBVariable &p_other) {
+	data->type = p_other.data->type;
+	data->hint = p_other.data->hint;
+	data->hint_string = p_other.data->hint_string;
+}
+
+void BBVariable::bind(Object *p_object, const StringName &p_property) {
+	ERR_FAIL_NULL_MSG(p_object, "Blackboard: Binding failed - object is null.");
+	ERR_FAIL_COND_MSG(p_property == StringName(), "Blackboard: Binding failed - property name is empty.");
+	ERR_FAIL_COND_MSG(!OBJECT_HAS_PROPERTY(p_object, p_property), vformat("Blackboard: Binding failed - %s has no property `%s`.", p_object, p_property));
+	data->bound_object = p_object->get_instance_id();
+	data->bound_property = p_property;
+}
+
+void BBVariable::unbind() {
+	data->bound_object = 0;
+	data->bound_property = StringName();
+}
+
+bool BBVariable::operator==(const BBVariable &p_var) const {
+	if (data == p_var.data) {
+		return true;
+	}
+
+	if (!data || !p_var.data) {
+		return false;
+	}
+
+	if (data->type != p_var.data->type) {
+		return false;
+	}
+
+	if (data->hint != p_var.data->hint) {
+		return false;
+	}
+
+	if (data->hint_string != p_var.data->hint_string) {
+		return false;
+	}
+
+	if (get_value() != p_var.get_value()) {
+		return false;
+	}
+
+	return true;
+}
+
+bool BBVariable::operator!=(const BBVariable &p_var) const {
+	return !(*this == p_var);
+}
+
+void BBVariable::operator=(const BBVariable &p_var) {
+	if (this == &p_var) {
+		return;
+	}
+
+	unref();
+
+	if (p_var.data && p_var.data->refcount.ref()) {
+		data = p_var.data;
+	}
+}
+
+BBVariable::BBVariable(const BBVariable &p_var) {
+	if (p_var.data && p_var.data->refcount.ref()) {
+		data = p_var.data;
+	}
+}
+
+BBVariable::BBVariable(Variant::Type p_type, PropertyHint p_hint, const String &p_hint_string) {
+	data = memnew(Data);
+	data->refcount.init();
+
+	set_type(p_type);
+	data->hint = p_hint;
+	data->hint_string = p_hint_string;
+}
+
+BBVariable::~BBVariable() {
+	unref();
+}

blackboard/bb_variable.h

@@ -0,0 +1,84 @@
+/**
+ * bb_variable.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BB_VARIABLE_H
+#define BB_VARIABLE_H
+
+#ifdef LIMBOAI_MODULE
+#include "core/object/object.h"
+#endif // LIMBOAI_MODULE
+
+#ifdef LIMBOAI_GDEXTENSION
+#include "godot_cpp/core/object.hpp"
+using namespace godot;
+#endif // LIMBOAI_GDEXTENSION
+
+class BBVariable {
+private:
+	struct Data {
+		// Is used to decide if the value needs to be synced in a derived plan.
+		bool value_changed = false;
+
+		SafeRefCount refcount;
+		Variant value;
+		Variant::Type type = Variant::NIL;
+		PropertyHint hint = PropertyHint::PROPERTY_HINT_NONE;
+		String hint_string;
+
+		NodePath binding_path;
+		uint64_t bound_object = 0;
+		StringName bound_property;
+	};
+
+	Data *data = nullptr;
+	void unref();
+
+public:
+	void set_value(const Variant &p_value);
+	Variant get_value() const;
+
+	void set_type(Variant::Type p_type);
+	Variant::Type get_type() const;
+
+	void set_hint(PropertyHint p_hint);
+	PropertyHint get_hint() const;
+
+	void set_hint_string(const String &p_hint_string);
+	String get_hint_string() const;
+
+	BBVariable duplicate(bool p_deep = false) const;
+
+	_FORCE_INLINE_ bool is_value_changed() const { return data->value_changed; }
+	_FORCE_INLINE_ void reset_value_changed() { data->value_changed = false; }
+
+	bool is_same_prop_info(const BBVariable &p_other) const;
+	void copy_prop_info(const BBVariable &p_other);
+
+	// * Editor binding methods
+	NodePath get_binding_path() const { return data->binding_path; }
+	void set_binding_path(const NodePath &p_binding_path) { data->binding_path = p_binding_path; }
+	bool has_binding() { return data->binding_path.is_empty(); }
+
+	// * Runtime binding methods
+	_FORCE_INLINE_ bool is_bound() const { return data->bound_object != 0; }
+	void bind(Object *p_object, const StringName &p_property);
+	void unbind();
+
+	bool operator==(const BBVariable &p_var) const;
+	bool operator!=(const BBVariable &p_var) const;
+	void operator=(const BBVariable &p_var);
+
+	BBVariable(const BBVariable &p_var);
+	BBVariable(Variant::Type p_type = Variant::Type::NIL, PropertyHint p_hint = PROPERTY_HINT_NONE, const String &p_hint_string = "");
+	~BBVariable();
+};
+
+#endif // BB_VARIABLE_H

blackboard/blackboard.cpp

@@ -0,0 +1,167 @@
+/**
+ * blackboard.cpp
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#include "blackboard.h"
+#include "../util/limbo_compat.h"
+
+#ifdef LIMBOAI_MODULE
+#include "core/variant/variant.h"
+#include "scene/main/node.h"
+#endif // LIMBOAI_MODULE
+
+#ifdef LIMBOAI_GDEXTENSION
+#include <godot_cpp/classes/node.hpp>
+#include <godot_cpp/classes/ref.hpp>
+#include <godot_cpp/classes/ref_counted.hpp>
+#include <godot_cpp/core/object.hpp>
+using namespace godot;
+#endif
+
+Ref<Blackboard> Blackboard::top() const {
+	Ref<Blackboard> bb(this);
+	while (bb->get_parent().is_valid()) {
+		bb = bb->get_parent();
+	}
+	return bb;
+}
+
+Variant Blackboard::get_var(const StringName &p_name, const Variant &p_default, bool p_complain) const {
+	if (data.has(p_name)) {
+		return data.get(p_name).get_value();
+	} else if (parent.is_valid()) {
+		return parent->get_var(p_name, p_default, p_complain);
+	} else {
+		if (p_complain) {
+			ERR_PRINT(vformat("Blackboard: Variable \"%s\" not found.", p_name));
+		}
+		return p_default;
+	}
+}
+
+void Blackboard::set_var(const StringName &p_name, const Variant &p_value) {
+	if (data.has(p_name)) {
+		// Not checking type - allowing duck-typing.
+		data[p_name].set_value(p_value);
+	} else {
+		BBVariable var(p_value.get_type());
+		var.set_value(p_value);
+		data.insert(p_name, var);
+	}
+}
+
+bool Blackboard::has_var(const StringName &p_name) const {
+	return data.has(p_name) || (parent.is_valid() && parent->has_var(p_name));
+}
+
+void Blackboard::erase_var(const StringName &p_name) {
+	data.erase(p_name);
+}
+
+TypedArray<StringName> Blackboard::list_vars() const {
+	TypedArray<StringName> var_names;
+	var_names.resize(data.size());
+	int idx = 0;
+	for (const KeyValue<StringName, BBVariable> &kv : data) {
+		var_names[idx] = kv.key;
+		idx += 1;
+	}
+	return var_names;
+}
+
+void Blackboard::print_state() const {
+	Ref<Blackboard> bb{ this };
+	int scope_idx = 0;
+	while (bb.is_valid()) {
+		int i = 0;
+		String line = "Scope " + itos(scope_idx) + ": { ";
+		for (const KeyValue<StringName, BBVariable> &kv : bb->data) {
+			if (i > 0) {
+				line += ", ";
+			}
+			line += String(kv.key) + ": " + String(kv.value.get_value());
+			i++;
+		}
+		line += " }";
+		PRINT_LINE(line);
+		bb = bb->get_parent();
+		scope_idx++;
+	}
+}
+
+Dictionary Blackboard::get_vars_as_dict() const {
+	Dictionary dict;
+	for (const KeyValue<StringName, BBVariable> &kv : data) {
+		dict[kv.key] = kv.value.get_value();
+	}
+	return dict;
+}
+
+void Blackboard::populate_from_dict(const Dictionary &p_dictionary) {
+	Array keys = p_dictionary.keys();
+	for (int i = 0; i < keys.size(); i++) {
+		if (keys[i].get_type() == Variant::STRING_NAME || keys[i].get_type() == Variant::STRING) {
+			set_var(keys[i], p_dictionary[keys[i]]);
+		} else {
+			ERR_PRINT("Blackboard: Invalid key type in dictionary to populate blackboard. Must be StringName or String.");
+		}
+	}
+}
+
+void Blackboard::bind_var_to_property(const StringName &p_name, Object *p_object, const StringName &p_property, bool p_create) {
+	if (!data.has(p_name)) {
+		if (p_create) {
+			data.insert(p_name, BBVariable());
+		} else {
+			ERR_FAIL_MSG("Blackboard: Can't bind variable that doesn't exist (var: " + p_name + ").");
+		}
+	}
+	data[p_name].bind(p_object, p_property);
+}
+
+void Blackboard::unbind_var(const StringName &p_name) {
+	ERR_FAIL_COND_MSG(!data.has(p_name), "Blackboard: Can't unbind variable that doesn't exist (var: " + p_name + ").");
+	data[p_name].unbind();
+}
+
+void Blackboard::assign_var(const StringName &p_name, const BBVariable &p_var) {
+	data.insert(p_name, p_var);
+}
+
+void Blackboard::link_var(const StringName &p_name, const Ref<Blackboard> &p_target_blackboard, const StringName &p_target_var, bool p_create) {
+	if (!data.has(p_name)) {
+		if (p_create) {
+			data.insert(p_name, BBVariable());
+		} else {
+			ERR_FAIL_MSG("Blackboard: Can't link variable that doesn't exist (var: " + p_name + ").");
+		}
+	}
+	ERR_FAIL_COND_MSG(p_target_blackboard.is_null(), "Blackboard: Can't link variable to target blackboard that is null (var: " + p_name + ").");
+	ERR_FAIL_COND_MSG(!p_target_blackboard->data.has(p_target_var), "Blackboard: Can't link variable to non-existent target (var: " + p_name + ", target: " + p_target_var + ").");
+	data[p_name] = p_target_blackboard->data[p_target_var];
+}
+
+void Blackboard::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_var", "var_name", "default", "complain"), &Blackboard::get_var, DEFVAL(Variant()), DEFVAL(true));
+	ClassDB::bind_method(D_METHOD("set_var", "var_name", "value"), &Blackboard::set_var);
+	ClassDB::bind_method(D_METHOD("has_var", "var_name"), &Blackboard::has_var);
+	ClassDB::bind_method(D_METHOD("set_parent", "blackboard"), &Blackboard::set_parent);
+	ClassDB::bind_method(D_METHOD("get_parent"), &Blackboard::get_parent);
+	ClassDB::bind_method(D_METHOD("erase_var", "var_name"), &Blackboard::erase_var);
+	ClassDB::bind_method(D_METHOD("clear"), &Blackboard::clear);
+	ClassDB::bind_method(D_METHOD("list_vars"), &Blackboard::list_vars);
+	ClassDB::bind_method(D_METHOD("print_state"), &Blackboard::print_state);
+	ClassDB::bind_method(D_METHOD("get_vars_as_dict"), &Blackboard::get_vars_as_dict);
+	ClassDB::bind_method(D_METHOD("populate_from_dict", "dictionary"), &Blackboard::populate_from_dict);
+	ClassDB::bind_method(D_METHOD("top"), &Blackboard::top);
+	ClassDB::bind_method(D_METHOD("bind_var_to_property", "var_name", "object", "property", "create"), &Blackboard::bind_var_to_property, DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("unbind_var", "var_name"), &Blackboard::unbind_var);
+	ClassDB::bind_method(D_METHOD("link_var", "var_name", "target_blackboard", "target_var", "create"), &Blackboard::link_var, DEFVAL(false));
+}

blackboard/blackboard.h

@@ -0,0 +1,73 @@
+/**
+ * blackboard.h
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#ifndef BLACKBOARD_H
+#define BLACKBOARD_H
+
+#include "bb_variable.h"
+
+#ifdef LIMBOAI_MODULE
+#include "core/object/object.h"
+#include "core/object/ref_counted.h"
+#include "core/variant/variant.h"
+#include "scene/main/node.h"
+#endif // LIMBOAI_MODULE
+
+#ifdef LIMBOAI_GDEXTENSION
+#include <godot_cpp/classes/node.hpp>
+#include <godot_cpp/classes/ref.hpp>
+#include <godot_cpp/classes/ref_counted.hpp>
+#include <godot_cpp/core/object.hpp>
+#include <godot_cpp/templates/hash_map.hpp>
+using namespace godot;
+#endif // LIMBOAI_GDEXTENSION
+
+class Blackboard : public RefCounted {
+	GDCLASS(Blackboard, RefCounted);
+
+private:
+	HashMap<StringName, BBVariable> data;
+	Ref<Blackboard> parent;
+
+protected:
+	static void _bind_methods();
+
+#ifdef LIMBOAI_GDEXTENSION
+	String _to_string() const { return "<" + get_class() + "#" + itos(get_instance_id()) + ">"; }
+#endif
+
+public:
+	void set_parent(const Ref<Blackboard> &p_blackboard) { parent = p_blackboard; }
+	Ref<Blackboard> get_parent() const { return parent; }
+
+	Ref<Blackboard> top() const;
+
+	Variant get_var(const StringName &p_name, const Variant &p_default = Variant(), bool p_complain = true) const;
+	void set_var(const StringName &p_name, const Variant &p_value);
+	bool has_var(const StringName &p_name) const;
+	_FORCE_INLINE_ bool has_local_var(const StringName &p_name) const { return data.has(p_name); }
+	void erase_var(const StringName &p_name);
+	void clear() { data.clear(); }
+	TypedArray<StringName> list_vars() const;
+	void print_state() const;
+
+	Dictionary get_vars_as_dict() const;
+	void populate_from_dict(const Dictionary &p_dictionary);
+
+	void bind_var_to_property(const StringName &p_name, Object *p_object, const StringName &p_property, bool p_create = false);
+	void unbind_var(const StringName &p_name);
+
+	void assign_var(const StringName &p_name, const BBVariable &p_var);
+
+	void link_var(const StringName &p_name, const Ref<Blackboard> &p_target_blackboard, const StringName &p_target_var, bool p_create = false);
+};
+
+#endif // BLACKBOARD_H

blackboard/blackboard_plan.cpp

@@ -0,0 +1,578 @@
+/**
+ * blackboard_plan.cpp
+ * =============================================================================
+ * Copyright (c) 2023-present Serhii Snitsaruk and the LimboAI contributors.
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+
+#include "blackboard_plan.h"
+
+#include "../util/limbo_utility.h"
+
+#ifdef LIMBOAI_MODULE
+#include "editor/editor_inspector.h"
+#include "editor/editor_interface.h"
+#elif LIMBOAI_GDEXTENSION
+#include <godot_cpp/classes/editor_inspector.hpp>
+#include <godot_cpp/classes/editor_interface.hpp>
+#include <godot_cpp/classes/engine.hpp>
+#include <godot_cpp/classes/scene_tree.hpp>
+#endif
+
+bool BlackboardPlan::_set(const StringName &p_name, const Variant &p_value) {
+	String name_str = p_name;
+
+#ifdef TOOLS_ENABLED
+	// * Editor
+	if (var_map.has(p_name)) {
+		BBVariable &var = var_map[p_name];
+		var.set_value(p_value);
+		if (base.is_valid() && p_value == base->get_var(p_name).get_value()) {
+			// When user pressed reset property button in inspector...
+			var.reset_value_changed();
+		}
+		return true;
+	}
+#endif // TOOLS_ENABLED
+
+	// * Mapping
+	if (name_str.begins_with("mapping/")) {
+		StringName mapped_var_name = name_str.get_slicec('/', 1);
+		StringName value = p_value;
+		bool prop_list_changed = false;
+		if (value == StringName()) {
+			if (parent_scope_mapping.has(mapped_var_name)) {
+				prop_list_changed = true;
+				parent_scope_mapping.erase(mapped_var_name);
+			}
+		} else {
+			if (!parent_scope_mapping.has(mapped_var_name)) {
+				prop_list_changed = true;
+			}
+			parent_scope_mapping[mapped_var_name] = value;
+		}
+		if (prop_list_changed) {
+			notify_property_list_changed();
+		}
+		return true;
+	}
+
+	// * Binding
+	if (name_str.begins_with("binding/")) {
+		StringName bound_var = name_str.get_slicec('/', 1);
+		NodePath value = p_value;
+		bool prop_list_changed = false;
+		if (value.is_empty()) {
+			if (property_bindings.has(bound_var)) {
+				prop_list_changed = true;
+				property_bindings.erase(bound_var);
+			}
+		} else {
+			if (!property_bindings.has(bound_var)) {
+				prop_list_changed = true;
+			}
+			property_bindings[bound_var] = value;
+		}
+		if (prop_list_changed) {
+			notify_property_list_changed();
+		}
+	}
+
+	// * Storage
+	if (name_str.begins_with("var/")) {
+		StringName var_name = name_str.get_slicec('/', 1);
+		String what = name_str.get_slicec('/', 2);
+		if (!var_map.has(var_name) && what == "name") {
+			add_var(var_name, BBVariable());
+		}
+		if (what == "name") {
+			// We don't store variable name with the variable.
+		} else if (what == "type") {
+			var_map[var_name].set_type((Variant::Type)(int)p_value);
+		} else if (what == "value") {
+			var_map[var_name].set_value(p_value);
+		} else if (what == "hint") {
+			var_map[var_name].set_hint((PropertyHint)(int)p_value);
+		} else if (what == "hint_string") {
+			var_map[var_name].set_hint_string(p_value);
+		} else if (what == "property_binding") {
+			property_bindings[var_name] = NodePath(p_value);
+		} else {
+			return false;
+		}
+		return true;
+	}
+
+	return false;
+}
+
+bool BlackboardPlan::_get(const StringName &p_name, Variant &r_ret) const {
+	String name_str = p_name;
+
+#ifdef TOOLS_ENABLED
+	// * Editor
+	if (var_map.has(p_name)) {
+		if (has_mapping(p_name)) {
+			r_ret = "Mapped to " + LimboUtility::get_singleton()->decorate_var(parent_scope_mapping[p_name]);
+		} else if (has_property_binding(p_name)) {
+			const NodePath &binding = property_bindings[p_name];
+
+			Node *edited_node = Object::cast_to<Node>(EditorInterface::get_singleton()->get_inspector()->get_edited_object());
+			if (!edited_node) {
+				edited_node = SCENE_TREE()->get_edited_scene_root();
+			}
+			Node *bound_node = edited_node ? edited_node->get_node_or_null(binding) : nullptr;
+
+			String shortened_path;
+			if (bound_node) {
+				shortened_path = (String)bound_node->get_name() +
+						":" + (String)binding.get_concatenated_subnames();
+			} else {
+				shortened_path = (String)binding.get_name(binding.get_name_count() - 1) +
+						":" + (String)binding.get_concatenated_subnames();
+			}
+			r_ret = String::utf8("🔗 ") + shortened_path;
+		} else {
+			r_ret = var_map[p_name].get_value();
+		}
+		return true;
+	}
+#endif // TOOLS_ENABLED
+
+	// * Mapping
+	if (name_str.begins_with("mapping/")) {
+		StringName mapped_var_name = name_str.get_slicec('/', 1);
+		ERR_FAIL_COND_V(mapped_var_name == StringName(), false);
+		if (has_mapping(mapped_var_name)) {
+			r_ret = parent_scope_mapping[mapped_var_name];
+		} else if (has_property_binding(mapped_var_name)) {
+			r_ret = RTR("Already bound to property.");
+		} else {
+			r_ret = StringName();
+		}
+		return true;
+	}
+
+	// * Binding
+	if (name_str.begins_with("binding/")) {
+		StringName bound_var = name_str.get_slicec('/', 1);
+		ERR_FAIL_COND_V(bound_var == StringName(), false);
+		if (has_property_binding(bound_var)) {
+			r_ret = property_bindings[bound_var];
+		} else if (has_mapping(bound_var)) {
+			r_ret = RTR("Already mapped to variable.");
+		} else {
+			r_ret = NodePath();
+		}
+		return true;
+	}
+
+	// * Storage
+	if (!name_str.begins_with("var/")) {
+		return false;
+	}
+	StringName var_name = name_str.get_slicec('/', 1);
+	String what = name_str.get_slicec('/', 2);
+	ERR_FAIL_COND_V(!var_map.has(var_name), false);
+
+	if (what == "name") {
+		r_ret = var_name;
+	} else if (what == "type") {
+		r_ret = var_map[var_name].get_type();
+	} else if (what == "value") {
+		r_ret = var_map[var_name].get_value();
+	} else if (what == "hint") {
+		r_ret = var_map[var_name].get_hint();
+	} else if (what == "hint_string") {
+		r_ret = var_map[var_name].get_hint_string();
+	}
+	return true;
+}
+
+void BlackboardPlan::_get_property_list(List<PropertyInfo> *p_list) const {
+	for (const Pair<StringName, BBVariable> &p : var_list) {
+		String var_name = p.first;
+		BBVariable var = p.second;
+
+#ifdef TOOLS_ENABLED
+		// * Editor
+		if (!_is_var_nil(var) && !_is_var_private(var_name, var)) {
+			if (has_mapping(var_name) || has_property_binding(var_name)) {
+				p_list->push_back(PropertyInfo(Variant::STRING, var_name, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_READ_ONLY));
+			} else {
+				p_list->push_back(PropertyInfo(var.get_type(), var_name, var.get_hint(), var.get_hint_string(), PROPERTY_USAGE_EDITOR));
+			}
+		}
+#endif // TOOLS_ENABLED
+
+		// * Storage
+		if (is_derived() && (!var.is_value_changed() || var.get_value() == base->var_map[var_name].get_value())) {
+			// Don't store variable if it's not modified in a derived plan.
+			// Variable is considered modified when it's marked as changed and its value is different from the base plan.
+			continue;
+		}
+		p_list->push_back(PropertyInfo(Variant::STRING, "var/" + var_name + "/name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL));
+		p_list->push_back(PropertyInfo(Variant::INT, "var/" + var_name + "/type", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL));
+		p_list->push_back(PropertyInfo(var.get_type(), "var/" + var_name + "/value", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL));
+		p_list->push_back(PropertyInfo(Variant::INT, "var/" + var_name + "/hint", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL));
+		p_list->push_back(PropertyInfo(Variant::STRING, "var/" + var_name + "/hint_string", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL));
+	}
+
+	// * Mapping
+	if (is_mapping_enabled()) {
+		p_list->push_back(PropertyInfo(Variant::NIL, "Mapping", PROPERTY_HINT_NONE, "mapping/", PROPERTY_USAGE_GROUP));
+		for (const Pair<StringName, BBVariable> &p : var_list) {
+			if (_is_var_private(p.first, p.second)) {
+				continue;
+			}
+			if (unlikely(has_property_binding(p.first))) {
+				p_list->push_back(PropertyInfo(Variant::STRING, "mapping/" + p.first, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_READ_ONLY));
+			} else {
+				// Serialize only non-empty mappings.
+				PropertyUsageFlags usage = has_mapping(p.first) ? PROPERTY_USAGE_DEFAULT : PROPERTY_USAGE_EDITOR;
+				p_list->push_back(PropertyInfo(Variant::STRING_NAME, "mapping/" + p.first, PROPERTY_HINT_NONE, "", usage));
+			}
+		}
+	}
+
+	// * Binding
+	p_list->push_back(PropertyInfo(Variant::NIL, "Binding", PROPERTY_HINT_NONE, "binding/", PROPERTY_USAGE_GROUP));
+	for (const Pair<StringName, BBVariable> &p : var_list) {
+		if (_is_var_nil(p.second) || _is_var_private(p.first, p.second)) {
+			continue;
+		}
+		if (unlikely(has_mapping(p.first))) {
+			p_list->push_back(PropertyInfo(Variant::STRING, "binding/" + p.first, PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_READ_ONLY));
+		} else {
+			PropertyUsageFlags usage = has_property_binding(p.first) ? PROPERTY_USAGE_DEFAULT : PROPERTY_USAGE_EDITOR;
+			// PROPERTY_HINT_LINK is used to signal that NodePath should point to a property.
+			// Our inspector plugin will know how to handle it.
+			p_list->push_back(PropertyInfo(Variant::NODE_PATH, "binding/" + p.first, PROPERTY_HINT_LINK, itos(p.second.get_type()), usage));
+		}
+	}
+}
+
+bool BlackboardPlan::_property_can_revert(const StringName &p_name) const {
+	if (String(p_name).begins_with("mapping/")) {
+		return true;
+	}
+	return base.is_valid() && base->var_map.has(p_name);
+}
+
+bool BlackboardPlan::_property_get_revert(const StringName &p_name, Variant &r_property) const {
+	if (String(p_name).begins_with("mapping/")) {
+		r_property = StringName();
+		return true;
+	}
+	if (base->var_map.has(p_name)) {
+		r_property = base->var_map[p_name].get_value();
+		return true;
+	}
+	return false;
+}
+
+void BlackboardPlan::set_base_plan(const Ref<BlackboardPlan> &p_base) {
+	if (p_base == this) {
+		WARN_PRINT_ED("BlackboardPlan: Using same resource for derived blackboard plan is not supported.");
+		base.unref();
+	} else {
+		base = p_base;
+	}
+	sync_with_base_plan();
+	notify_property_list_changed();
+}
+
+void BlackboardPlan::set_parent_scope_plan_provider(const Callable &p_parent_scope_plan_provider) {
+	parent_scope_plan_provider = p_parent_scope_plan_provider;
+	notify_property_list_changed();
+}
+
+bool BlackboardPlan::has_mapping(const StringName &p_name) const {
+	return is_mapping_enabled() && parent_scope_mapping.has(p_name) && parent_scope_mapping[p_name] != StringName();
+}
+
+void BlackboardPlan::set_property_binding(const StringName &p_name, const NodePath &p_path) {
+	property_bindings[p_name] = p_path;
+	emit_changed();
+}
+
+void BlackboardPlan::set_prefetch_nodepath_vars(bool p_enable) {
+	prefetch_nodepath_vars = p_enable;
+	emit_changed();
+}
+
+bool BlackboardPlan::is_prefetching_nodepath_vars() const {
+	if (is_derived()) {
+		return base->is_prefetching_nodepath_vars();
+	} else {
+		return prefetch_nodepath_vars;
+	}
+}
+
+void BlackboardPlan::add_var(const StringName &p_name, const BBVariable &p_var) {
+	ERR_FAIL_COND(p_name == StringName());
+	ERR_FAIL_COND(var_map.has(p_name));
+	var_map.insert(p_name, p_var);
+	var_list.push_back(Pair<StringName, BBVariable>(p_name, p_var));
+	notify_property_list_changed();
+	emit_changed();
+}
+
+void BlackboardPlan::remove_var(const StringName &p_name) {
+	ERR_FAIL_COND(!var_map.has(p_name));
+	var_list.erase(Pair<StringName, BBVariable>(p_name, var_map[p_name]));
+	var_map.erase(p_name);
+	notify_property_list_changed();
+	emit_changed();
+}
+
+BBVariable BlackboardPlan::get_var(const StringName &p_name) {
+	ERR_FAIL_COND_V(!var_map.has(p_name), BBVariable());
+	return var_map.get(p_name);
+}
+
+Pair<StringName, BBVariable> BlackboardPlan::get_var_by_index(int p_index) {
+	Pair<StringName, BBVariable> ret;
+	ERR_FAIL_INDEX_V(p_index, (int)var_map.size(), ret);
+	return var_list.get(p_index);
+}
+
+TypedArray<StringName> BlackboardPlan::list_vars() const {
+	TypedArray<StringName> ret;
+	for (const Pair<StringName, BBVariable> &p : var_list) {
+		ret.append(p.first);
+	}
+	return ret;
+}
+
+StringName BlackboardPlan::get_var_name(const BBVariable &p_var) const {
+	for (const Pair<StringName, BBVariable> &p : var_list) {
+		if (p.second == p_var) {
+			return p.first;
+		}
+	}
+	return StringName();
+}
+
+bool BlackboardPlan::is_valid_var_name(const StringName &p_name) const {
+	String name_str = p_name;
+	if (name_str.begins_with("resource_")) {
+		return false;
+	}
+	return name_str.is_valid_identifier() && !var_map.has(p_name);
+}
+
+void BlackboardPlan::rename_var(const StringName &p_name, const StringName &p_new_name) {
+	if (p_name == p_new_name) {
+		return;
+	}
+
+	ERR_FAIL_COND(!is_valid_var_name(p_new_name));
+	ERR_FAIL_COND(!var_map.has(p_name));
+	ERR_FAIL_COND(var_map.has(p_new_name));
+
+	BBVariable var = var_map[p_name];
+	Pair<StringName, BBVariable> new_entry(p_new_name, var);
+	Pair<StringName, BBVariable> old_entry(p_name, var);
+	var_list.find(old_entry)->set(new_entry);
+
+	var_map.erase(p_name);
+	var_map.insert(p_new_name, var);
+
+	if (parent_scope_mapping.has(p_name)) {
+		parent_scope_mapping[p_new_name] = parent_scope_mapping[p_name];
+		parent_scope_mapping.erase(p_name);
+	}
+
+	notify_property_list_changed();
+	emit_changed();
+}
+
+void BlackboardPlan::move_var(int p_index, int p_new_index) {
+	ERR_FAIL_INDEX(p_index, (int)var_map.size());
+	ERR_FAIL_INDEX(p_new_index, (int)var_map.size());
+
+	if (p_index == p_new_index) {
+		return;
+	}
+
+	List<Pair<StringName, BBVariable>>::Element *E = var_list.front();
+	for (int i = 0; i < p_index; i++) {
+		E = E->next();
+	}
+	List<Pair<StringName, BBVariable>>::Element *E2 = var_list.front();
+	for (int i = 0; i < p_new_index; i++) {
+		E2 = E2->next();
+	}
+
+	var_list.move_before(E, E2);
+	if (p_new_index > p_index) {
+		var_list.move_before(E2, E);
+	}
+
+	notify_property_list_changed();
+	emit_changed();
+}
+
+void BlackboardPlan::sync_with_base_plan() {
+	if (base.is_null()) {
+		return;
+	}
+
+	bool changed = false;
+
+	// Sync variables with the base plan.
+	for (const Pair<StringName, BBVariable> &p : base->var_list) {
+		const StringName &base_name = p.first;
+		const BBVariable &base_var = p.second;
+
+		if (!var_map.has(base_name)) {
+			add_var(base_name, base_var.duplicate());
+			changed = true;
+			continue;
+		}
+
+		BBVariable var = var_map[base_name];
+		if (!var.is_same_prop_info(base_var)) {
+			var.copy_prop_info(base_var);
+			changed = true;
+		}
+		if ((!var.is_value_changed() && var.get_value() != base_var.get_value()) ||
+				(var.get_value().get_type() != base_var.get_type())) {
+			// Reset value according to base plan.
+			var.set_value(base_var.get_value());
+			var.reset_value_changed();
+			changed = true;
+		}
+	}
+
+	// Erase variables that do not exist in the base plan.
+	List<StringName> erase_list;
+	for (const Pair<StringName, BBVariable> &p : var_list) {
+		if (!base->has_var(p.first)) {
+			erase_list.push_back(p.first);
+			changed = true;
+		}
+	}
+	while (erase_list.size()) {
+		remove_var(erase_list.front()->get());
+		erase_list.pop_front();
+	}
+
+	// Sync order of variables.
+	// Glossary: E - element of current plan, B - element of base plan, F - element of current plan (used for forward search).
+	ERR_FAIL_COND(base->var_list.size() != var_list.size());
+	List<Pair<StringName, BBVariable>>::Element *B = base->var_list.front();
+	for (List<Pair<StringName, BBVariable>>::Element *E = var_list.front(); E; E = E->next()) {
+		if (E->get().first != B->get().first) {
+			List<Pair<StringName, BBVariable>>::Element *F = E->next();
+			while (F) {
+				if (F->get().first == B->get().first) {
+					var_list.move_before(F, E);
+					E = F;
+					break;
+				}
+				F = F->next();
+			}
+		}
+		B = B->next();
+	}
+
+	if (changed) {
+		notify_property_list_changed();
+		emit_changed();
+	}
+}
+
+Ref<Blackboard> BlackboardPlan::create_blackboard(Node *p_prefetch_root, const Ref<Blackboard> &p_parent_scope, Node *p_prefetch_root_for_base_plan) {
+	ERR_FAIL_COND_V(p_prefetch_root == nullptr && prefetch_nodepath_vars, memnew(Blackboard));
+	Ref<Blackboard> bb = memnew(Blackboard);
+	bb->set_parent(p_parent_scope);
+	populate_blackboard(bb, true, p_prefetch_root, p_prefetch_root_for_base_plan);
+	return bb;
+}
+
+void BlackboardPlan::populate_blackboard(const Ref<Blackboard> &p_blackboard, bool overwrite, Node *p_prefetch_root, Node *p_prefetch_root_for_base_plan) {
+	ERR_FAIL_COND(p_prefetch_root == nullptr && prefetch_nodepath_vars);
+	ERR_FAIL_COND(p_blackboard.is_null());
+	for (const Pair<StringName, BBVariable> &p : var_list) {
+		if (p_blackboard->has_local_var(p.first) && !overwrite) {
+#ifdef DEBUG_ENABLED
+			Variant::Type existing_type = p_blackboard->get_var(p.first).get_type();
+			Variant::Type planned_type = p.second.get_type();
+			if (existing_type != planned_type && existing_type != Variant::NIL && planned_type != Variant::NIL && !(existing_type == Variant::OBJECT && planned_type == Variant::NODE_PATH)) {
+				WARN_PRINT(vformat("BlackboardPlan: Not overwriting %s as it already exists in the blackboard, but it has a different type than planned (%s vs %s). File: %s",
+						LimboUtility::get_singleton()->decorate_var(p.first), Variant::get_type_name(existing_type), Variant::get_type_name(planned_type), get_path()));
+			}
+#endif
+			continue;
+		}
+		bool is_bound = has_property_binding(p.first) || (is_derived() && get_base_plan()->has_property_binding(p.first));
+		bool has_mapping = parent_scope_mapping.has(p.first);
+		bool do_prefetch = !is_bound && !has_mapping && prefetch_nodepath_vars;
+
+		// Add a variable duplicate to the blackboard, optionally with NodePath prefetch.
+		BBVariable var = p.second.duplicate(true);
+		if (unlikely(do_prefetch && p.second.get_type() == Variant::NODE_PATH)) {
+			Node *prefetch_root = !p_prefetch_root_for_base_plan || !is_derived() || is_derived_var_changed(p.first) ? p_prefetch_root : p_prefetch_root_for_base_plan;
+			Node *n = prefetch_root->get_node_or_null(p.second.get_value());
+			if (n != nullptr) {
+				var.set_value(n);
+			} else {
+				ERR_PRINT(vformat("BlackboardPlan: Prefetch failed for variable $%s with value: %s", p.first, p.second.get_value()));
+				var.set_value(Variant());
+			}
+		}
+		p_blackboard->assign_var(p.first, var);
+
+		if (has_mapping) {
+			StringName target_var = parent_scope_mapping[p.first];
+			if (target_var != StringName()) {
+				ERR_CONTINUE_MSG(p_blackboard->get_parent().is_null(), vformat("BlackboardPlan: Cannot link variable %s to parent scope because the parent scope is not set.", LimboUtility::get_singleton()->decorate_var(p.first)));
+				p_blackboard->link_var(p.first, p_blackboard->get_parent(), target_var);
+			}
+		} else if (is_bound) {
+			// Bind variable to a property of a scene node.
+			NodePath binding_path;
+			Node *binding_root;
+			if (has_property_binding(p.first)) {
+				binding_path = property_bindings[p.first];
+				binding_root = p_prefetch_root;
+			} else {
+				binding_path = get_base_plan()->property_bindings[p.first];
+				binding_root = p_prefetch_root_for_base_plan;
+			}
+			ERR_CONTINUE_MSG(binding_path.get_subname_count() != 1, vformat("BlackboardPlan: Can't bind variable %s using property path that contains multiple sub-names: %s", LimboUtility::get_singleton()->decorate_var(p.first), binding_path));
+			NodePath node_path{ binding_path.get_concatenated_names() };
+			StringName prop_name = binding_path.get_subname(0);
+			// TODO: Implement binding for base plan as well.
+			Node *n = binding_root->get_node_or_null(node_path);
+			ERR_CONTINUE_MSG(n == nullptr, vformat("BlackboardPlan: Binding failed for variable %s using property path: %s", LimboUtility::get_singleton()->decorate_var(p.first), binding_path));
+			var.bind(n, prop_name);
+		}
+	}
+}
+
+void BlackboardPlan::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_prefetch_nodepath_vars", "enable"), &BlackboardPlan::set_prefetch_nodepath_vars);
+	ClassDB::bind_method(D_METHOD("is_prefetching_nodepath_vars"), &BlackboardPlan::is_prefetching_nodepath_vars);
+
+	ClassDB::bind_method(D_METHOD("set_base_plan", "blackboard_plan"), &BlackboardPlan::set_base_plan);
+	ClassDB::bind_method(D_METHOD("get_base_plan"), &BlackboardPlan::get_base_plan);
+	ClassDB::bind_method(D_METHOD("is_derived"), &BlackboardPlan::is_derived);
+	ClassDB::bind_method(D_METHOD("sync_with_base_plan"), &BlackboardPlan::sync_with_base_plan);
+	ClassDB::bind_method(D_METHOD("set_parent_scope_plan_provider", "callable"), &BlackboardPlan::set_parent_scope_plan_provider);
+	ClassDB::bind_method(D_METHOD("get_parent_scope_plan_provider"), &BlackboardPlan::get_parent_scope_plan_provider);
+	ClassDB::bind_method(D_METHOD("create_blackboard", "prefetch_root", "parent_scope", "prefetch_root_for_base_plan"), &BlackboardPlan::create_blackboard, DEFVAL(Ref<Blackboard>()), DEFVAL(Variant()));
+	ClassDB::bind_method(D_METHOD("populate_blackboard", "blackboard", "overwrite", "prefetch_root", "prefetch_root_for_base_plan"), &BlackboardPlan::populate_blackboard, DEFVAL(Variant()));
+
+	// To avoid cluttering the member namespace, we do not export unnecessary properties in this class.
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "prefetch_nodepath_vars", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE), "set_prefetch_nodepath_vars", "is_prefetching_nodepath_vars");
+}
+
+BlackboardPlan::BlackboardPlan() {
+}