Unitybyggen via kommandoraden

Så fungerar det

Unity kan bygga utan grafiskt gränssnitt. -batchmode kör utan dialogrutor, -quit avslutar efter att den synkrona metoden är klar, -projectPath väljer projektet och -executeMethod anropar en statisk Editor-metod. -buildTarget väljer plattform innan projektet laddas. -nographics undviker att starta en grafikenhet; utelämna flaggan om ett byggsteg behöver grafik.

Värdsystemet kör editorn, medan målplattformen kör spelet. Exemplen bygger för samma operativsystem som editorn körs på:

Värdsystem	Kommandotolk	Målplattform	Metod	Resultat
Windows 10	Windows PowerShell 5.1 eller PowerShell 7	`StandaloneWindows64`	`BuildTools.BuildWindows`	`Builds/Windows/Game.exe`
Windows 11	Windows PowerShell 5.1 eller PowerShell 7	`StandaloneWindows64`	`BuildTools.BuildWindows`	`Builds/Windows/Game.exe`
Linux	Bash	`StandaloneLinux64`	`BuildTools.BuildLinux`	`Builds/Linux/Game.x86_64`

Windows 10 och 11 använder samma Windows x64-mål; testa på båda om du stöder båda. Välj en Unity-version som stöder ditt värdsystem och en Linuxdistribution som stöds. Installera rätt plattformsmodul för editorversionen via Unity Hub och konfigurera giltig licensiering. IL2CPP kräver dessutom en kompilator/verktygskedja som stöds för målplattformen. Korskompilering beror på värdsystem, backend och installerade moduler; ett annat målargument installerar inte beroendena.

Gemensamt byggskript för editorn

Spara detta i Assets/Editor/BuildTools.cs eller en Editor-only assembly. Båda metoderna använder aktiverade EditorBuildSettings.scenes och releaseinställningar. Skriptet väljer inte ett eget Build Profile-asset och tillämpar inte profilens overrides. Använd ett uttryckligt profilanpassat arbetsflöde om projektet behöver dem. Utgå inte från att den senast valda profilen i editorn är aktiv vid automatisering.

#if UNITY_EDITOR
using System;
using System.IO;
using System.Linq;
using UnityEditor;
using UnityEditor.Build.Reporting;

public static class BuildTools
{
    public static void BuildWindows() =>
        Build(BuildTarget.StandaloneWindows64, "Builds/Windows/Game.exe");

    public static void BuildLinux() =>
        Build(BuildTarget.StandaloneLinux64, "Builds/Linux/Game.x86_64");

    private static void Build(BuildTarget target, string output)
    {
        if (EditorUserBuildSettings.activeBuildTarget != target)
            throw new InvalidOperationException("Pass the matching -buildTarget argument");

        string[] scenes = EditorBuildSettings.scenes
            .Where(scene => scene.enabled)
            .Select(scene => scene.path)
            .ToArray();
        if (scenes.Length == 0)
            throw new InvalidOperationException("No enabled build scenes");

        Directory.CreateDirectory(Path.GetDirectoryName(output));
        var options = new BuildPlayerOptions
        {
            scenes = scenes,
            locationPathName = output,
            target = target,
            options = BuildOptions.None
        };
        BuildReport report = BuildPipeline.BuildPlayer(options);
        if (report.summary.result != BuildResult.Succeeded)
            throw new InvalidOperationException("Player build failed: " + report.summary.result);
    }
}
#endif

Windows 10 och Windows 11: PowerShell

Kör från projektroten som innehåller Assets/ och ProjectSettings/. Ersätt YOUR_VERSION med installerad editorversion eller kopiera den verkliga sökvägen till editorn. Stäng andra editorinstanser som använder projektet. Spara som build-windows.ps1 och kör i PowerShell; Bash eller WSL behövs inte.

$ErrorActionPreference = 'Stop'
$UnityEditor = 'C:\Program Files\Unity\Hub\Editor\YOUR_VERSION\Editor\Unity.exe'
if (-not (Test-Path -LiteralPath $UnityEditor)) {
    throw 'Set UnityEditor to your installed Unity.exe path'
}
$ProjectPath = (Get-Location).Path
$LogPath = Join-Path $ProjectPath 'unity-build-windows.log'
$UnityArguments = @(
    '-batchmode', '-nographics', '-quit',
    '-projectPath', ('"{0}"' -f $ProjectPath),
    '-buildTarget', 'StandaloneWindows64',
    '-executeMethod', 'BuildTools.BuildWindows',
    '-logFile', ('"{0}"' -f $LogPath)
)
$BuildProcess = Start-Process -FilePath $UnityEditor -ArgumentList $UnityArguments -Wait -PassThru -WindowStyle Hidden
if ($BuildProcess.ExitCode -ne 0) {
    throw "Unity failed with exit code $($BuildProcess.ExitCode). Read $LogPath"
}

Start-Process -Wait väntar tills Windowsprogrammet är klart; -PassThru ger åtkomst till avslutskoden. Inbäddade citattecken bevarar sökvägar med mellanslag. Om skriptkörning är begränsad följer du datorns policy eller klistrar in kommandona i en interaktiv PowerShell-session.

Linux: Bash

Kör från samma projektrot med Linuxeditorn installerad. Ersätt YOUR_VERSION och justera sökvägen om Unity Hub installerat editorn på annan plats. Stäng editorinstanser som använder projektet. Kör med bash ./build-linux.sh; själva skriptfilen behöver inte vara markerad som körbar.

#!/usr/bin/env bash
set -euo pipefail
export UNITY_EDITOR="$HOME/Unity/Hub/Editor/YOUR_VERSION/Editor/Unity"
test -x "$UNITY_EDITOR" || { echo 'Set UNITY_EDITOR to the installed Unity executable' >&2; exit 1; }
"$UNITY_EDITOR" -batchmode -nographics -quit \
  -projectPath "$PWD" \
  -buildTarget StandaloneLinux64 \
  -executeMethod BuildTools.BuildLinux \
  -logFile "$PWD/unity-build-linux.log"

Med set -e avslutas skriptet med fel om Unityprocessen misslyckas. Behåll loggen även vid fel. Ett batchbygge testar inte att det färdiga spelet faktiskt startar.

När och varför det behövs – och vanliga fallgropar

-executeMethod kräver en statisk Editor-metod, inte en MonoBehaviour-instans. Låt målargument och metod matcha. Använd synkrona bygg-API:er så att -quit inte avslutar för tidigt. Ett undantag får batchbygget att misslyckas; kontrollera avslutskoden och plattformens logg.

Öva: Bygg och starta ett Windowsbygge på Windows 10 och Windows 11 samt ett Linuxbygge på Linux. Avaktivera sedan alla byggscener och kontrollera att båda skripten rapporterar fel. Paketera hela resultatmappen enligt byggresultat.