Crear una release del juego

Una release es el juego empaquetado y listo para que otra persona lo descargue y juegue. La Base de Sky puede distribuirse para los tres sistemas operativos: Windows, Linux y macOS. Esta página explica cómo generar esos paquetes a mano en tu PC y cómo automatizar todo el proceso con GitHub Actions o GitLab CI/CD.

Qué contiene una release

Al empaquetar acabas con dos archivos que subes a donde distribuyas el juego:

El script make_macos.rb mete la carpeta del juego dentro de una plantilla de app macOS universal (Z-universal-macos-template.zip) y produce la carpeta *.app más su *-macos.zip.

Requisitos

• Ruby 3.x instalado. Consulta cómo instalar Ruby en la página de scripts_extract.
• La base en versión 1.2.2 o superior para el paquete de macOS, con make_macos.rb y Z-universal-macos-template.zip en la carpeta del juego. (El zip de Windows/Linux no lo necesita.)
• Puedes generar los dos paquetes desde cualquier sistema operativo (Windows, Linux o macOS): solo se empaquetan archivos, no se compila nada nativo.

Generar la release a mano

Si prefieres no usar CI, puedes armar los dos paquetes en tu propio PC. Abre una terminal dentro de la carpeta del juego (la que contiene Game.exe).

1. Paquete de Windows y Linux

Es simplemente la carpeta del juego comprimida. Antes de comprimir, borra los archivos de desarrollo que no quieres repartir (opcional pero recomendable) y crea el zip:

# (opcional) combinar scripts si los tienes extraídos
ruby scripts_combine.rb

# borrar archivos de desarrollo que no van en la release (ajusta a tu caso)
rm -f Game.rxproj scripts_combine.rb scripts_extract.rb
rm -rf Data/Scripts Plugins

# comprimir la carpeta del juego (ejecuta esto DESDE FUERA de la carpeta)
cd ..
zip -rq MiJuego.zip "Nombre De La Carpeta Del Juego"

En Windows sin zip en la terminal, clic derecho sobre la carpeta → Comprimir en archivo ZIP hace lo mismo. Ese MiJuego.zip sirve para los jugadores de Windows y de Linux.

2. Paquete de macOS

Desde dentro de la carpeta del juego, ejecuta el script:

ruby make_macos.rb

Al terminar tendrás una carpeta *.app y un archivo *-macos.zip. Renombra el zip a algo claro (ej. MiJuego-macOS.zip): ese es el paquete que reparten los jugadores de Mac.

Automatizar con GitHub Actions

Si tu juego está en un repositorio de GitHub, puedes generar la release automáticamente cada vez que publiques una etiqueta (tag) o la lances a mano desde la pestaña Actions. La Action compila los scripts, construye la app de macOS y publica todo como una release de GitHub.

Crea el archivo .github/workflows/release.yml en tu repositorio con este contenido. Los valores en MAYÚSCULAS son placeholders: cámbialos por los de tu proyecto.

name: Create release

run-name: ${{ github.event_name == 'workflow_dispatch' && format('Create Release v{0}', github.event.inputs.version) || 'Create release' }}

on:
  push:
    tags:
      - 'v*'
  workflow_dispatch:
    inputs:
      version:
        description: 'Version de la release (ej. 1.0.0)'
        required: true
        default: '1.0.0'

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Set Version
        id: version
        run: |
          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
            echo "version=${{ github.event.inputs.version }}" >> $GITHUB_OUTPUT
          else
            echo "version=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT
          fi

      # Combina los scripts .rb de vuelta en Scripts.rxdata
      - name: Compile Scripts
        run: |
          cd "CARPETA_DEL_JUEGO"
          ruby scripts_combine.rb

      # Borra archivos de desarrollo que no deben ir en la release.
      # Ajusta esta lista a tu proyecto (o borra el paso si no lo necesitas).
      - name: Delete Unnecessary Files
        run: |
          cd "CARPETA_DEL_JUEGO"
          rm -f Game.rxproj 2>/dev/null || true
          rm -rf Data/Scripts 2>/dev/null || true
          rm -rf Plugins 2>/dev/null || true
          rm -f scripts_combine.rb scripts_extract.rb 2>/dev/null || true
          rm -f extendtext.exe animmaker.exe 2>/dev/null || true
          rm -f "RPG Maker Encrypter.jar" 2>/dev/null || true

      # Genera la app de macOS (requiere la version 1.2.2+ de la base)
      - name: Build macOS App
        run: |
          cd "CARPETA_DEL_JUEGO"
          ruby make_macos.rb
          mv *-macos.zip ../NOMBRE_JUEGO_MACOS.zip
          rm -rf *.app
          rm -f make_macos.rb Z-universal-macos-template.zip

      # Renombra la carpeta al nombre visible del juego y empaqueta la version Windows/Linux
      - name: Prepare Release Directory
        run: mv "CARPETA_DEL_JUEGO" "NOMBRE_DEL_JUEGO"

      - name: Create Release Zip
        run: zip -rq NOMBRE_JUEGO.zip . -i "NOMBRE_DEL_JUEGO/*"

      - name: Create Release
        uses: softprops/action-gh-release@v2
        with:
          # Opcional: publica en OTRO repositorio (ej. uno solo para releases).
          # Borra 'repository' para publicar en el repo actual.
          repository: USUARIO/REPO_DE_RELEASES
          files: |
            NOMBRE_JUEGO.zip
            NOMBRE_JUEGO_MACOS.zip
          name: "Mi Juego v${{ steps.version.outputs.version }}"
          body: "Mi Juego v${{ steps.version.outputs.version }} - ¡Descarga y disfruta!"
          tag_name: v${{ steps.version.outputs.version }}
          make_latest: true
          generate_release_notes: false
          token: ${{ secrets.RELEASE_TOKEN || github.token }}

Cómo usar la Action

1. Reemplaza los placeholders:
   • CARPETA_DEL_JUEGO: nombre de la carpeta que contiene Game.exe dentro de tu repo.
   • NOMBRE_DEL_JUEGO: nombre bonito de la carpeta que verá el jugador al descomprimir (ej. Mi Juego).
   • NOMBRE_JUEGO: nombre del zip Windows/Linux. NOMBRE_JUEGO_MACOS: nombre del zip de macOS.
   • USUARIO/REPO_DE_RELEASES: solo si publicas en otro repositorio; si no, borra la línea repository.
2. Si publicas en otro repositorio, crea un Personal Access Token con permiso de contents sobre ese repo y guárdalo como secreto RELEASE_TOKEN en Settings → Secrets and variables → Actions. Si publicas en el mismo repo, no hace falta: se usa el github.token automático.
3. Lanza la release de dos formas:
   • Con un tag: git tag v1.2.2 && git push origin v1.2.2.
   • A mano: pestaña Actions → Create release → Run workflow, escribiendo la versión.

Automatizar con GitLab CI/CD

Si alojas el juego en GitLab en vez de GitHub, puedes hacer exactamente lo mismo con un archivo .gitlab-ci.yml. La idea es igual: al crear una etiqueta (tag) que empiece por v, el pipeline construye los mismos dos zips (NOMBRE_JUEGO.zip para Windows/Linux y NOMBRE_JUEGO_MACOS.zip para macOS) y crea una release de GitLab.

Como las releases de GitLab enlazan archivos por URL, primero se suben los zips al Package Registry del propio proyecto (así tienen un enlace de descarga estable) y luego se referencian en la release.

stages:
  - build
  - release

variables:
  # Carpeta del Package Registry donde se suben los zips de esta version
  PACKAGE_URL: "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/juego/${CI_COMMIT_TAG}"

# Construye los dos zips y los sube al Package Registry
build:
  stage: build
  image: ruby:3.3
  rules:
    - if: '$CI_COMMIT_TAG =~ /^v/'
  script:
    - apt-get update && apt-get install -y zip curl

    # Combina los scripts .rb de vuelta en Scripts.rxdata
    - cd "CARPETA_DEL_JUEGO"
    - ruby scripts_combine.rb

    # Borra archivos de desarrollo (ajusta la lista a tu proyecto)
    - rm -f Game.rxproj scripts_combine.rb scripts_extract.rb 2>/dev/null || true
    - rm -rf Data/Scripts Plugins 2>/dev/null || true

    # Genera la app de macOS (requiere la version 1.2.2+ de la base)
    - ruby make_macos.rb
    - mv *-macos.zip ../NOMBRE_JUEGO_MACOS.zip
    - rm -rf *.app
    - rm -f make_macos.rb Z-universal-macos-template.zip
    - cd ..

    # Empaqueta la version Windows/Linux (misma carpeta, Game.exe o Game_Linux)
    - mv "CARPETA_DEL_JUEGO" "NOMBRE_DEL_JUEGO"
    - zip -rq NOMBRE_JUEGO.zip "NOMBRE_DEL_JUEGO"

    # Sube ambos zips al Package Registry
    - |
      for f in NOMBRE_JUEGO.zip NOMBRE_JUEGO_MACOS.zip; do
        curl --fail --header "JOB-TOKEN: ${CI_JOB_TOKEN}" --upload-file "$f" "${PACKAGE_URL}/${f}"
      done

# Crea la release enlazando los zips subidos
release:
  stage: release
  image: registry.gitlab.com/gitlab-org/release-cli:latest
  rules:
    - if: '$CI_COMMIT_TAG =~ /^v/'
  script:
    - echo "Creando release ${CI_COMMIT_TAG}"
  release:
    tag_name: '$CI_COMMIT_TAG'
    name: 'Mi Juego $CI_COMMIT_TAG'
    description: 'Mi Juego $CI_COMMIT_TAG - ¡Descarga y disfruta!'
    assets:
      links:
        - name: 'Windows / Linux'
          url: '${PACKAGE_URL}/NOMBRE_JUEGO.zip'
        - name: 'macOS'
          url: '${PACKAGE_URL}/NOMBRE_JUEGO_MACOS.zip'

Los mismos placeholders que en la Action de GitHub (CARPETA_DEL_JUEGO, NOMBRE_DEL_JUEGO, NOMBRE_JUEGO, NOMBRE_JUEGO_MACOS) se cambian por los de tu proyecto. Para lanzar la release, crea el tag y súbelo:

git tag v1.2.2 && git push origin v1.2.2

Advertencias

Artículos relacionados

• scripts_extract y scripts_combine
• Compilador
• Instalación
• Registro de Cambios