lyra_game_ue/.gitea/workflows/unreal-build.yml

name: Unreal Engine Build

on:
  workflow_dispatch:
  push:
    branches: [main, develop]

jobs:
  build-and-release:
    runs-on: windows
    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop'
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3
        with:
          lfs: true
          fetch-depth: 0

      - name: Setup environment
        run: |
          # Set environment variables for Unreal Engine
          echo "UE_ROOT=E:/Games/UE_5.5" >> $GITHUB_ENV
          # Set environment variables for Linux toolchain
          LINUX_MULTIARCH_ROOT="C:/UnrealToolchains/v23_clang-18.1.0-rockylinux8"
          echo "LINUX_MULTIARCH_ROOT=${LINUX_MULTIARCH_ROOT}" >> $GITHUB_ENV
          
          # Create directories for builds
          mkdir -p Builds/Windows
          mkdir -p Builds/Linux
          mkdir -p PackagedReleases

      - name: Build for Windows
        run: |
          chmod +x ./win_build.sh
          ./win_build.sh
      
      - name: Build for Linux
        run: |
          chmod +x ./linux_build.sh
          ./linux_build.sh
      
      - name: Package builds
        run: |
          echo "Packaging Windows build..."
          if [ -d "Builds/Windows" ]; then
            cd Builds/Windows
            zip -r ../../PackagedReleases/LuckyRobots-Windows.zip .
            cd ../..
          fi
          
          echo "Packaging Linux build..."
          if [ -d "Builds/Linux" ]; then
            cd Builds/Linux
            zip -r ../../PackagedReleases/LuckyRobots-Linux.zip .
            cd ../..
          fi
          
          echo "=== Packaged releases ==="
          ls -la PackagedReleases/
      
      - name: Create Tag
        if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop'
        run: |
          # Fetch all tags
          git fetch --tags
          
          # Get the latest version tag, if any
          LATEST_TAG=$(git tag -l "v[0-9]*.[0-9]*.[0-9]*" | sort -V | tail -n1)
          
          if [ -z "$LATEST_TAG" ]; then
            # No previous version tag, start with 1.0.0
            NEW_VERSION="1.0.0"
            echo "No previous version tags found, starting with 1.0.0"
          else
            # Strip 'v' prefix if it exists
            VERSION=${LATEST_TAG#v}
            
            # Split version into parts
            MAJOR=$(echo $VERSION | cut -d. -f1)
            MINOR=$(echo $VERSION | cut -d. -f2)
            PATCH=$(echo $VERSION | cut -d. -f3)
            
            # Auto-increment patch version
            PATCH=$((PATCH + 1))
            NEW_VERSION="${MAJOR}.${MINOR}.${PATCH}"
            echo "Auto-incremented patch version from ${VERSION} to ${NEW_VERSION}"
          fi
          
          # Final tag with v prefix
          TAG="v${NEW_VERSION}"
          echo "Creating git tag: $TAG"
          
          # Configure git with token authentication
          git config --global user.email "actions@gitea.com"
          git config --global user.name "Gitea Actions"
          
          # Direct token approach - simplest method
          git remote set-url origin "https://goran:${{ secrets.GITEATOKEN }}@luckyrobots.com/goran/lyra_game_ue.git"
          
          # Set git to not prompt for input
          GIT_TERMINAL_PROMPT=0
          
          # Check if tag exists
          if ! git rev-parse "$TAG" >/dev/null 2>&1; then
            # Create tag without opening editor (-m flag)
            git tag -a "$TAG" -m "Release $TAG"
            
            # Push with timeout and debug
            echo "Pushing tag $TAG to origin..."
            git push --verbose origin "$TAG" || {
              echo "Error: Failed to push tag. Check your token permissions."
              exit 1
            }
            echo "Successfully created and pushed tag: $TAG"
          else
            echo "Tag $TAG already exists, skipping tag creation"
          fi
          echo "RELEASE_TAG=$TAG" >> $GITHUB_ENV
      
      - name: Create Release
        uses: https://gitea.com/actions/gitea-release-action@main
        with:
          files: |-
            PackagedReleases/*.zip
          token: '${{ secrets.GITEA_TOKEN }}'
          title: 'Release ${{ env.RELEASE_TAG }}'
          body: |
            ## Automated release from CI build #${{ github.run_number }}
            
            This release includes builds for:
            - Windows
            - Linux
            
            Built from commit: ${{ github.sha }}
          prerelease: ${{ github.ref != 'refs/heads/main' }}
          tag_name: '${{ env.RELEASE_TAG }}'
          
  macos-build:
    runs-on: macos
    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop'
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3
        with:
          lfs: true
          fetch-depth: 0

      - name: Setup Unreal Engine
        run: |
          # Use the correct path where Unreal Engine is installed
          UE_PATH="/Users/Shared/Epic Games/UE_5.5"
          
          if [ ! -d "$UE_PATH" ]; then
            echo "Error: Unreal Engine is not installed in the expected location"
            echo "Please ensure Unreal Engine is installed at $UE_PATH"
            exit 1
          fi
          
          # Set environment variable with the correct Engine path
          echo "UE_ROOT=$UE_PATH/Engine" >> $GITHUB_ENV
          echo "Using Unreal Engine 5.5"
        
      - name: Build Unreal Project
        run: |
          chmod +x ./mac_build.sh
          ./mac_build.sh
        
      - name: Prepare Mac release
        run: |
          echo "Preparing packaged files for release..."
          
          # Create a directory for release files
          mkdir -p PackagedReleases
          
          # Debug: Show what we're packaging
          echo "=== Packaging for Release ==="
          echo "Build directory contents:"
          ls -la Builds/
          
          # Find the app bundle in the Builds directory
          APP_PATH=$(find Builds -type d -name "*.app" | head -1)
          
          if [ -n "$APP_PATH" ]; then
            echo "Found app bundle: $APP_PATH"
            # Get the app name
            APP_NAME=$(basename "$APP_PATH")
            # Create zip file of the app bundle
            (cd $(dirname "$APP_PATH") && zip -r "../../PackagedReleases/${APP_NAME%.app}-macOS.zip" "$APP_NAME")
            echo "Created packaged release: PackagedReleases/${APP_NAME%.app}-macOS.zip"
          else
            echo "No .app bundle found in Builds directory"
            
            # Look for a directory that might be a bundle but not named .app
            MAIN_BUILD_DIR=$(find Builds -mindepth 1 -maxdepth 1 -type d | head -1)
            if [ -n "$MAIN_BUILD_DIR" ]; then
              echo "Found main build directory: $MAIN_BUILD_DIR"
              DIR_NAME=$(basename "$MAIN_BUILD_DIR")
              # Package this directory as if it were the app
              (cd $(dirname "$MAIN_BUILD_DIR") && zip -r "../../PackagedReleases/${DIR_NAME}-macOS.zip" "$DIR_NAME")
              echo "Created packaged release from main directory: PackagedReleases/${DIR_NAME}-macOS.zip"
            else
              # Package the entire Builds directory as a fallback
              echo "No main directory found, packaging everything"
              zip -r "PackagedReleases/LuckyRobots-macOS.zip" Builds
              echo "Created fallback package: PackagedReleases/LuckyRobots-macOS.zip"
            fi
          fi
          
          echo "Packaged releases:"
          ls -la PackagedReleases/
      
      - name: Create Gitea Release
        if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop'
        uses: https://gitea.com/actions/gitea-release-action@main
        with:
          token: ${{ secrets.GITEATOKEN }}
          tag_name: ${{ env.RELEASE_TAG }}
          title: "Release ${{ env.RELEASE_TAG }}"
          files: PackagedReleases/*.zip