build.yaml

name: Build Platform Target

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
    types: [opened, reopened, edited, synchronize]

jobs:
  build-native:
    runs-on: macos-latest
    permissions:
      pull-requests: write
      actions: write
    env:
      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      GODOT_BASE_BRANCH: main
      CACHE_NAME: v-sekai-godot

    strategy:
      fail-fast: false
      matrix:
        precision: [double]
        platform: [macos, ios]
        target: [editor, templates]
        exclude:
          - platform: ios
            target: editor

    concurrency:
      group: ${{ github.workflow }}-${{ github.ref }}-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.precision }}
      cancel-in-progress: true

    steps:
      - name: Set up dependencies
        run: brew install just hyperfine scons

      - name: Set up Go
        uses: actions/setup-go@v2
        with:
          go-version: "1.22.3"

      - name: Set up placeholders
        run: |
          mkdir -p godot/bin/
          mkdir -p tpz/
          mkdir -p editor
          echo "This is the README for the Godot bin directory." > godot/bin/readme.md
          echo "This is the README for the TPZ directory." > tpz/readme.md
          echo "This is the README for the Editor directory." > editor/readme.md

      - name: Checkout code 
        uses: actions/checkout@v4 
  
      - name: Cache SCons cache 
        uses: actions/cache@v4 
        if: always() 
        with: 
          path: | 
            .scons_cache
          key: ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}-${{ github.sha }}-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.precision }}
          restore-keys: | 
            ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}-${{ github.sha }}-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.precision }}
            ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}-${{ github.sha }}-${{ matrix.platform }}-${{ matrix.target }}  
            ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}-${{ github.sha }}  
            ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}  
            ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }}-refs/heads/${{ env.GODOT_BASE_BRANCH }}  
            ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }} 
  
      - name: Fetch dependencies and Build Platform Target 
        run: | 
          export PLATFORM_ARGS="fetch-vulkan-sdk"
          if [ ${{ matrix.target }} == "templates" ]; then
            hyperfine --show-output --runs 1 'just $PLATFORM_ARGS && just build-platform-templates ${{ matrix.platform }} auto ${{ matrix.precision }}'
          else
            hyperfine --show-output --runs 1 'just $PLATFORM_ARGS && just build-platform-target ${{ matrix.platform }} ${{ matrix.target }} auto ${{ matrix.precision }}'
          fi

      - name: Upload Artifacts
        uses: actions/upload-artifact@v4
        with:
          name: build-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.precision }}
          path: godot/bin/*

      - name: Upload TPZ File
        uses: actions/upload-artifact@v4
        with:
          name: Godot-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.precision }}.tpz
          path: tpz

      - name: Upload Godot Editor Files
        uses: actions/upload-artifact@v4
        with:
          name: Godot-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.precision }}
          path: editor
  build:
    runs-on: ubuntu-24.04
    permissions:
      pull-requests: write
      actions: write
    container:
      image: fedora:39
    env:
      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      GODOT_BASE_BRANCH: main
      CACHE_NAME: v-sekai-godot

    strategy:
      fail-fast: false
      matrix:
        precision: [double]
        architecture: [x86_64, arm64, wasm32]
        platform: [linuxbsd, windows, android, web]
        target: [editor, template_release, template_debug]
        exclude:
            # Android templates step is combined
            - platform: android
              target: template_debug
            - platform: android
              architecture: x86_64
            - platform: android
              architecture: wasm32
            - platform: linuxbsd
              architecture: wasm32
            - platform: windows
              architecture: wasm32
            - platform: windows
              architecture: arm64
            - platform: web
              architecture: arm64
            - platform: web
              architecture: x86_64

    concurrency:
      group: ${{ github.workflow }}-${{ github.ref }}-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.precision }}-${{ matrix.architecture }}
      cancel-in-progress: true

    steps:
      - name: Set up dependencies
        run: |
          if dnf >/dev/null 2>&1; then
            dnf install -y just git; # Fedora 39
          else
            echo "'just' requires ubuntu-24.04 or more";
            sudo apt install -y just git;
          fi

      - name: Set up Go
        uses: actions/setup-go@v2
        with:
          go-version: "1.22.3"
          
      - name: Set up placeholders
        run: |
          mkdir -p godot/bin/
          mkdir -p tpz/
          mkdir -p editor
          echo "This is the README for the Godot bin directory." > godot/bin/readme.md
          echo "This is the README for the TPZ directory." > tpz/readme.md
          echo "This is the README for the Editor directory." > editor/readme.md

      - name: Checkout code 
        uses: actions/checkout@v4 
  
      - name: Cache SCons cache 
        uses: actions/cache@v4 
        # Skip cache on Linux, PR #12
        if: ${{ matrix.platform != 'linuxbsd' }}
        with: 
          path: | 
            .scons_cache  
            emsdk  
            osxcross  
            jdk  
            android_sdk  
            vulkan_sdk  
            mingw 
          key: ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}-${{ github.sha }}-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.precision }}-${{ matrix.architecture }}
          restore-keys: | 
            ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}-${{ github.sha }}-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.precision }}-${{ matrix.architecture }}
            ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}-${{ github.sha }}-${{ matrix.platform }}-${{ matrix.target }}
            ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}-${{ github.sha }}  
            ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }}-${{ github.ref }}  
            ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }}-refs/heads/${{ env.GODOT_BASE_BRANCH }}  
            ${{ env.CACHE_NAME }}-${{ env.GODOT_BASE_BRANCH }} 
  
      - name: Fetch dependencies and Build Platform Target 
        run: | 
          just install_packages 
          export PLATFORM_ARGS=""
          export EXTRA_OPTIONS=""
          case "${{ matrix.platform }}" in  
            android)  
              PLATFORM_ARGS="fetch-openjdk setup-android-sdk"  
              ;;  
            web)  
              PLATFORM_ARGS="setup-emscripten"
              if [ ${{ matrix.target }} == 'template_debug' ]; then
                  EXTRA_OPTIONS="optimize=none"; # Fix Github runner out of RAM
              fi
              ;;  
            windows)  
              PLATFORM_ARGS="fetch-llvm-mingw"  
              ;;  
            macos)  
              PLATFORM_ARGS="build-osxcross fetch-vulkan-sdk"  
              ;;  
            *)  
              PLATFORM_ARGS="nil"  
              ;;  
          esac
          if "${{ matrix.architecture == 'arm64' }}"; then
              PLATFORM_ARGS="setup-arm64 $PLATFORM_ARGS"
          fi
          if [ ${{ matrix.platform }} == 'android' ] && [ ${{ matrix.target }} == 'template_release' ]; then
              # Combined debug/release templates step
              hyperfine --show-output --runs 1 'just $PLATFORM_ARGS && just build-platform-templates ${{ matrix.platform }} ${{ matrix.architecture }} ${{ matrix.precision }}';
          else
              hyperfine --show-output --runs 1 'just $PLATFORM_ARGS && just build-platform-target ${{ matrix.platform }} ${{ matrix.target }} ${{ matrix.architecture }} ${{ matrix.precision }} yes $EXTRA_OPTIONS';
          fi

      - name: Upload Android Editors
        if: ${{ matrix.platform == 'android' && matrix.target == 'editor' }}
        uses: actions/upload-artifact@v4
        with:
          name: build-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.precision }}
          path: godot/bin/android_editor_builds/android_editor*

      - name: Upload Artifacts
        if: ${{ !(matrix.platform == 'android' && matrix.target == 'editor') }} 
        uses: actions/upload-artifact@v4
        with:
          name: build-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.architecture }}-${{ matrix.precision }}
          path: godot/bin/*

      - name: Upload TPZ File
        uses: actions/upload-artifact@v4
        with:
          name: Godot-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.architecture }}-${{ matrix.precision }}.tpz
          path: tpz

      - name: Upload Godot Editor Files
        uses: actions/upload-artifact@v4
        with:
          name: Godot-${{ matrix.platform }}-${{ matrix.target }}-${{ matrix.architecture }}-${{ matrix.precision }}
          path: editor

  merge-templates:
    runs-on: ubuntu-latest
    needs: ["build", "build-native"]
    steps:
      - name: Merge Export Templates
        uses: actions/upload-artifact/merge@v4
        with:
          name: v-sekai-godot-templates-all
          pattern: "*.tpz"
          delete-merged: true

      - name: Download Artifacts
        uses: actions/download-artifact@v4
        with:
          path: v-sekai-godot-templates
          name: v-sekai-godot-templates-all

      - name: Split Export Templates Symbols
        run: | 
          mkdir -p v-sekai-godot-templates-symbols

          # Suppress if null glob error
          mv v-sekai-godot-templates/*.pdb v-sekai-godot-templates-symbols/ || true
          mv v-sekai-godot-templates/*.debugsymbols v-sekai-godot-templates-symbols/ || true
          mv v-sekai-godot-templates/*.dSYM v-sekai-godot-templates-symbols/ || true
          tree

      - name: Upload Export Templates
        uses: actions/upload-artifact@v4
        with:
          name: v-sekai-godot-templates
          path: v-sekai-godot-templates

      - name: Upload Export Templates Symbols
        uses: actions/upload-artifact@v4
        with:
          name: v-sekai-godot-templates-symbols
          path: v-sekai-godot-templates-symbols

  merge:
    runs-on: ubuntu-latest
    needs: merge-templates
    strategy:
      fail-fast: false
      matrix:
        platform: [linuxbsd, windows, macos, android, web]
    steps:
      - name: Merge Artifacts
        uses: actions/upload-artifact/merge@v4
        with:
          name: v-sekai-godot-${{ matrix.platform }}
          pattern: "*${{ matrix.platform }}-editor*"
          delete-merged: true

  release:
    runs-on: ubuntu-latest
    needs: merge
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    outputs:
      id: ${{ steps.create_release.outputs.id }}
      upload_url: ${{ steps.create_release.outputs.upload_url }}
    steps:
      - name: Create Release
        id: create_release
        uses: actions/create-release@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          tag_name: latest.v-sekai-editor-${{ github.run_number }}
          release_name: Latest Release of V-Sekai Godot Engine Editor
          draft: false
          prerelease: true

  upload-templates:
    # 'just' is apt package from 24.04+
    runs-on: ubuntu-24.04
    needs: release
    env:
      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
    strategy:
      fail-fast: false
      matrix:
        type: [templates, templates-symbols]
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          sparse-checkout: |
            Justfile
            godot/version.py
            .github/zip-upload-split/action.yml

      - name: Download Artifacts
        uses: actions/download-artifact@v4
        with:
          path: v-sekai-godot-${{ matrix.type }}
          name: v-sekai-godot-${{ matrix.type }}

      - name: Pack Artifacts
        id: pack
        run: |
          tree
          if ${{ matrix.type == 'templates' }}; then \
            sudo apt install -y just; \
            just package-tpz v-sekai-godot-${{ matrix.type }} v-sekai-godot-${{ matrix.type }} ./godot/version.py; \
            echo "name=v-sekai-godot-${{ matrix.type }}.tpz" >> ${GITHUB_OUTPUT}; \
          else \
            echo "name=v-sekai-godot-${{ matrix.type }}" >> ${GITHUB_OUTPUT}; \
          fi

      - name: Upload Zip Release Asset
        uses: ./.github/zip-upload-split
        with:
          zip-path: ./${{ steps.pack.outputs.name }}
          release-id: ${{ needs.release.outputs.id }}
          token: ${GITHUB_TOKEN}

  upload-releases:
    runs-on: ubuntu-latest
    needs: release
    strategy:
      fail-fast: false
      matrix:
        platform: [linuxbsd, windows, macos, android, web]
    steps:
      - name: Download Artifacts
        uses: actions/download-artifact@v4
        with:
          path: v-sekai-godot-${{ matrix.platform }}
          name: v-sekai-godot-${{ matrix.platform }}

      - name: Zip Artifacts
        run: |
          tree
          chmod +x v-sekai-godot-${{ matrix.platform }}/*editor*
          zip -r v-sekai-godot-${{ matrix.platform }}.zip v-sekai-godot-${{ matrix.platform }}

      - name: Upload Release Asset
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ needs.release.outputs.upload_url }}
          asset_path: ./v-sekai-godot-${{ matrix.platform }}.zip
          asset_name: v-sekai-godot-${{ matrix.platform }}.zip
          asset_content_type: application/zip