Steamworks-Dokumentation
Hochladen auf Steam
Unten finden Sie eine Anleitung zur Verwendung von SteamPipe, Valves Werkzeug zur Veröffentlichung von Inhalten auf Steam. Weitere Informationen zu den bewährten Praktiken zur Aktualisierung Ihres Spiels finden Sie hier: Bewährte Praktiken bei der Aktualisierung von Spielen.

Einführung in das SteamPipe-Inhaltssystem

SteamPipe ist das Inhaltssystem für Spiele/Anwendungen, auf dem Steam basiert. SteamPipe bietet die folgenden Optionen:
  • Effiziente und schnelle Bereitstellung von Inhalten.
  • Public and private "beta" branches, allowing multiple builds to be tested.
  • Einfache webbasierte Verwaltung von Builds und Übertragen neuer Builds oder Rollbacks auf vorherige Builds mit wenigen Mausklicks.
  • Anzeigen der Update-Größe eines Builds, bevor Sie diesen live schalten.
  • Anwendungsübergreifende Verwendung von Inhalten.
  • Erstellen von Installationsdatenträgern aus öffentlichen oder Beta-Inhalten.
  • Spiele/Apps bleiben offline verfügbar, selbst wenn der Download eines Updates gestartet wird.
  • Alle Inhalte sind grundsätzlich verschlüsselt und inaktive Versionen sind für Kunden nicht sichtbar.
  • Ein SteamPipe: Lokaler Inhaltsserver, der während der Entwicklung verwendet werden kann.
HINWEIS: SteamPipe umfasst einige wesentliche Konzepte. Bevor Sie beginnen, sollten Sie sich mit den in der Anwendungen Dokumentation beschriebenen Konzepten vertraut machen. Schon ein grundlegendes Verständnis dessen, wie die einzelnen Komponenten zusammenwirken, wird Ihnen beim Hochladen Ihres Produkts auf Steam sehr nützlich sein.

Steamworks-Videoanleitung – Kompilieren Ihres Spiels in SteamPipe

Diese Anleitung führt SteamPipe ein und erläutert Schritt für Schritt, wie Sie mit den Steamworks-Werkzeugen eine Beispielanwendung für Steam erstellen.
https://www.youtube.com/watch?v=SoNH-v6aU9Q

Steamworks-Videoanleitung – Hinzufügen neuer Plattformen und Sprachen

Diese Videoanleitung zeigt Ihnen, wie Sie Ihrem Spiel neue Plattformen und Sprachen hinzufügen, indem Sie Ihrer Anwendung Depots hinzufügen.
https://www.youtube.com/watch?v=PShS32hcing

SteamPipe – Technische Details

SteamPipe nutzt das HTTP-Protokoll für die Inhaltsbereitstellung. Da es sich bei Downloads um herkömmlichen Webverkehr handelt, kann die Downloadgeschwindigkeit durch HTTP-Caches von Drittanbietern zwischen Kunden und Steam-Servern erhöht werden. Inhalte können durch externe CDN-Anbieter gehostet werden, die unserem Inhaltsnetzwerk problemlos hinzugefügt werden können. Die meisten Firewalls auf Kundenseite erlauben HTTP-Traffic und blockieren Downloads nicht.

SteamPipe nutzt einen effizienten Patching-Algorithmus, der auf binärer Deltareplikation basiert und nur die modifizierten Komponenten bestehender Inhaltsdateien ändert. Wenn dieser Inhalt aktualisiert wird, müssen nur diese Deltas gesendet werden. Dies bedeutet, dass die Übertragungen sowohl für den Entwickler als auch für den Benutzer kleiner und schneller sind. Die meisten Partner betrachten es als nicht notwendig, einen SteamPipe: Lokaler Inhaltsserver zu verwenden, da sie Builds effizient auf privaten Branches patchen können.

Steam-Build-Account

Bevor Sie auf Steam einen Build erstellen können, müssen Sie in Ihrem Steamworks-Account einen Steam-Account haben, der über die Berechtigungen „Metadaten der Anwendung bearbeiten“ und „App-Änderungen auf Steam veröffentlichen“ verfügt. Aus Sicherheitsgründen wird empfohlen, einen dedizierten Build-Account einzurichten, der ausschließlich diese Berechtigungen besitzt. Hierzu können Sie unter https://store.steampowered.com/join einen neuen Account erstellen.

Jeder Administrator in Ihrem Steamworks-Account kann einen Steam-Account hinzufügen und die erforderlichen Berechtigungen zuweisen. Weitere Informationen zu diesem Verfahren finden Sie in der Dokumentation Verwaltung Ihres Steamworks-Accounts. Hier ein Beispiel für einen solchen Account:

create_build_account.png

Ersteinrichtung neuer SteamPipe-Apps

Um neue SteamPipe-Anwendungen einzurichten, gehen Sie wie folgt vor:
  1. Suchen Sie die App-ID Ihrer Anwendung (Sie finden die ID, wenn Sie die Anwendung auf Ihrer Steamworks-Startseite auswählen).
  2. Rufen Sie die Seite Allgemeine Installationseinstellungen für Ihre App auf.
  3. Definieren Sie mindestens eine Startoption (den Pfad und optional die zum Starten des Spiels erforderlichen Argumente). Hover over the (?) to learn more about each field.

    The example below shows 5 launch options, 2 for Windows, 2 for macOS and 1 for Linux.
    Launch option 3 will only be shown on Windows if the user also owns the DLC specified.

    updatedlaunchoptions_3.png
  4. Rufen Sie die Seite Depots auf und fügen Sie die für diese App erforderlichen Depots hinzu. Möglicherweise ist standardmäßig bereits ein Depot für Ihre Anwendung konfiguriert.
    1. Klicken Sie auf das Standarddepot und ändern Sie den Namen des Depots in einen aussagekräftigen und wiedererkennbaren Namen (zum Beispiel „Basisinhalt“ oder „Windows-Inhalt“).
    2. Lassen Sie die Sprache auf [All languages] eingestellt, es sei denn, es handelt sich um ein sprachspezifisches Depot.
    3. Lassen Sie das Betriebssystem auf [All OSes] eingestellt, außer es handelt sich um ein betriebssystemspezifisches Depot (wenn die App für alle Betriebssysteme gilt oder nur für PC oder nur für Mac ist, behalten Sie die Einstellung bei). Ändern Sie die Einstellung nur bei betriebssystemspezifischen Spieldepots.
    4. Klicken Sie auf Neues Depot hinzufügen, um neue Depots hinzuzufügen.
    5. Klicken Sie auf Änderungen speichern, um alle vorgenommen Änderungen zu speichern.
  5. Wenn Sie die Definition Ihrer Depots abgeschlossen haben, veröffentlichen Sie die vorgenommenen Änderungen auf der Seite Veröffentlichen.
  6. Sie müssen Ihre neu definierten Depots einem Paket hinzufügen, damit Sie als Eigentümer der Depots zugewiesen werden. Jedes Spiel auf Steam sollte über ein Developer Comp-Paket verfügen, das automatisch den in Ihrer Entwicklergruppe aufgelisteten Accounts zugewiesen wird.
    Diesem Paket (und/oder anderen Paketen, die über diese Depots verfügen müssen) können Sie auf der Seite Verknüpfte Pakete & DLCs die neuen Depots hinzufügen.
Note: If your executable is in a sub-folder of the main installation folder, add the sub-folder name in the Executable field. Beginnen Sie nicht mit Schrägstrichen oder Punkten.
Platform Note: As shown above, macOS applications may be launched by specifying either an app bundle (Game.app) or a script/binary (Game.app/Contents/MacOS/Game). In general the app bundle format should be preferred if possible as it allows macOS to more correctly determine launch parameters in the manner it would if launched manually outside of Steam.

One instance of this to note is that currently applications that are launched through an app bundle on Apple Silicon devices will launch the best architecture available in the application whereas direct binary launches will use the same architecture as the Steam process (currently x86_64).

Einrichten des SDKs für SteamPipe-Uploads

Download and unzip the latest version of the Steamworks SDK on the machine you will be uploading builds on.

The SteamPipe tools can be found within the SDK in the tools folder which contains 2 relevant sub-directories.

The ContentBuilder directory is where your game content and SteamPipe build tools will live. This directory contains the following sub-directories:
  • builder: In diesem Verzeichnis ist zu Beginn nur steamcmd.exe enthalten, die Befehlszeilenversion von Steam.
  • builder_linux: Die Linux-Version von steamcmd.
  • builder_osx: Die macOS-Version von steamcmd.
  • content: Dieses Verzeichnis enthält alle Spieldateien, die in Depots kompiliert werden.
  • output: Dieses Verzeichnis ist der Speicherort für Build-Protokolle, den Datenblock-Cache und Zwischenversionen. HINWEIS: Diesen Ordner können Sie jederzeit leeren oder löschen. Nach dem Löschen dauert der nächste Upload jedoch länger.
  • scripts: In diesem Verzeichnis speichern Sie alle Build-Skripts für die Erstellung Ihrer Spieldepots.
steampipebuilddir.png

It's recommended that you run steamcmd.exe directly in the builder folder for your platform once to bootstrap your build system. This should populate your builder directory with all the files it needs to build depots.

The ContentServer directory contains the tools for running your own SteamPipe: Lokaler Inhaltsserver if you choose to do so.

SteamCmd auf macOS

To enable SteamCmd on macOS you must complete the following steps:
  1. Navigieren Sie im Terminal zum Ordner „tools\ContentBuilder\builder_osx\osx32“.
  2. Führen sie „chmod +x steamcmd“ aus.
  3. Navigieren Sie zum übergeordneten Ordner (tools\ContentBuilder\builder_osx).
  4. Geben Sie „bash ./steamcmd.sh“ ein.
  5. SteamCmd wird nun ausgeführt und auf den aktuellsten Build aktualisiert. Nach Abschluss befinden Sie sich in der SteamCmd-Eingabeaufforderung.
  6. Geben Sie „exit“ ein und drücken Sie die Eingabetaste, um die Eingabeaufforderung zu schließen.
You can then follow the rest of this documentation (substituting paths as appropriate) to create depot and app config files for uploading your content to Steam.

SteamPipe-Build-Konfigurationsdateien erstellen

To upload files for your app with SteamPipe, you must create scripts which describe your build and each depot that will be included in it. The example scripts shown here are in the Tools\ContentBuilder\scripts folder in the Steamworks SDK.

SteamPipe-GUI-Werkzeug

If you're running on Windows and would prefer a GUI tool to help create these config files and upload your builds you can use the SteamPipeGUI which is available in the tools folder of the Steamworks SDK. Included in the zip are additional instructions to get you started.

If you choose to use the GUI tool then reading the following sections is still recommended to help you become more familiar with how the SteamPipe system works.

Ein einfaches Build-Skript


Let's start with the most basic build script possible. In our example we have a game (AppID 1000) that has one depot (DepotID 1001) and want to upload all files from a content folder and it's subfolders. We just need a single build script for that, take a look at "simple_app_build.vdf" included in the SDK :

"AppBuild" { "AppID" "1000" // Ihre App-ID "Desc" "Dies ist ein simples Build-Skript" // interne Beschreibung des Builds "ContentRoot" "..\content\" // Root-Verzeichnis des Inhaltsverzeichnisses, relativ zum Speicherort dieser Datei "BuildOutput" "..\output\" // Build-Ausgabeordner für Build-Protokolle und den Cache-Dateien des Builds "Depots" { "1001" // Ihre Depot-ID { "FileMapping" { "LocalPath" "*" // alle Dateien aus dem Inhaltsstammordner "DepotPath" "." // dem Stammverzeichnis des Depots zugeordnet "recursive" "1" // alle Unterordner miteinbeziehen } } } }

Adjust the AppID and DepotID for your game as needed. To kick off a build you need to run steamcmd and pass a couple of parameters :
tools\ContentBuilder\builder\steamcmd.exe +login <account_name> <password> +run_app_build ..\scripts\simple_app_build.vdf +quit

HINWEIS: Your first attempt at running a build may fail due to Steam Guard. If the login fails due to Steam Guard, check your email for the Steam Guard code, and run steamcmd as: steamcmd.exe "set_steam_guard_code <code>", and try again. After logging in with Steam Guard once, a sentry file is used to verify the login is genuine.

If you are using steamcmd from a machine or VM that gets re-imaged frequently, you should include the sentry and config file in your image so you won't be prompted for a Steam Guard every time. The sentry file is located in <Steam>\ssfn<hashOfNumbers>, and the config file is located in <Steam>\config\config.vdf.

The following steps occur during a SteamPipe build:
  1. Steamcmd.exe wird automatisch auf die aktuellste Version aktualisiert.
  2. Steamcmd.exe meldet sich mit dem angegebenen Steam-Build-Entwickler-Account beim Steam-Backend an.
  3. Der Start des App-Builds wird beim MDS (Master Depot Server) registriert, wodurch sichergestellt wird, dass der Benutzer über die richtigen Berechtigungen zum Modifizieren dieser App verfügt.
  4. Für jedes im App-Build enthaltene Depot wird basierend auf den Dateien im Inhaltsordner und den in der Depot-Build-Konfigurationsdatei definierten Filterregeln eine Dateiliste generiert.
  5. Jede Datei wird untersucht und in kleine Teile von ungefähr 1 MB aufgeteilt. Wenn das Depot bereits zuvor entwickelt wurde, bleiben durch diese Partitionierung so viele unveränderte Teile wie möglich erhalten.
  6. Neue Dateiteile werden komprimiert und verschlüsselt und danach auf den MDS hochgeladen.
  7. Für diese Depotversion wird ein endgültiges Manifest generiert; jedes Manifest wird durch eine eindeutige 64-Bit-Manifest-ID identifiziert.
  8. Sobald alle Depots verarbeitet wurden, stellt der MDS diesen App-Build fertig und weist ihm eine globale Build-ID zu.
  9. Wenn der Build fertig ist, befinden sich im Build-Ausgabeordner eventuell CSM- und CSD-Dateien. Diese Dateien sind temporäre Dateien und können gelöscht werden, beschleunigen jedoch alle nachfolgenden Builds.


Once the build is complete you can see it on your app builds page, in this case it would be https://partner.steamgames.com/apps/builds/1000. There you can set that build live for the default branch or any beta branch and users will be able to download this update with a couple of minutes.

Erweiterte Build-Skripts


If your app has a lot of depots with complex file mapping rules, you can create a depot build script for each depot which will be referenced by the app build script. First let's take a look at available parameters in the app build script:

  • App-ID : Die App-ID Ihres Spiels. Der zum Hochladen verwendete Steam-Partneraccount benötigt die Berechtigung zur Bearbeitung von Metadaten der Anwendung.
  • Desc > Die Beschreibung erscheint nur im Bereich „Ihre Builds“ im App-Verwaltungsfenster. Sie kann jederzeit nach dem Hochladen Ihres Builds auf die „Ihre Builds“-Seite geändert werden.
  • ContentRoot : Das Stammverzeichnis Ihrer Spieldateien. Kann ein absoluter Pfad oder relativ zur Build-Skript-Datei sein.
  • BuildOutput : Dieses Verzeichnis ist der Speicherort für Build-Protokolle, Depot-Manifeste, den Datenblock-Cache und Zwischenversionen. Wir empfehlen, für das beste Ergebnis eine separate Festplatte für Ihre Build-Ausgabe zu verwenden. Dadurch wird die IO-Arbeitslast des Datenträgers aufgeteilt, sodass Ihr Inhaltsstammdatenträger die Leseanforderungen und Ihr Ausgabedatenträger die Schreibanforderungen verarbeiten kann.
  • Vorschau : Diese Art Build gibt nur Protokolle und ein Dateimanifest im Build-Ausgabeordner aus. Das Erstellen von Vorschau-Builds ist eine gute Möglichkeit, Ihre Upload-Skripte zu durchlaufen und sicherzustellen, dass Ihre Dateizuordnungen, Filter und Eigenschaften wie beabsichtigt funktionieren.
  • Local : Legen Sie dies auf dem htdocs-Pfad Ihres SteamPipe: Lokaler Inhaltsserver (LCS/lokalen Inhaltsserver) fest. LCS-Builds stellen Inhalte nur auf Ihrem eigenen HTTP-Server bereit und ermöglichen es Ihnen, die Installation Ihres Spiels mit dem Steam-Client zu testen.
  • SetLive : Name des Beta-Branch. Wird nach einem erfolgreichen Build automatisch live geschaltet. Wenn leer, wird kein Name festgelegt. Bitte beachten Sie, dass der Standard-Branch nicht automatisch live geschaltet werden kann. Dieser Schritt kann nur über das App-Verwaltungsfenster Ihrer Anwendung vorgenommen werden.
  • Depots: Dieser Bereich enthält alle Dateizuordnungen, Filter und Dateieigenschaften für jedes Depot oder verweist auf eine separate Skriptdatei für jedes Depot.

Example app build script "app_build_1000.vdf" is using all options:
"AppBuild" { "AppID" "1000" // Ihre App-ID "Desc" "Ihre Build-Beschreibung hier" // interne Beschreibung für diesen Build "Preview" "1" // diesen Build nur als Vorschau erstellen, es wird nichts hochgeladen "Local" "..\..\ContentServer\htdocs" // Inhalte werden nur auf den lokalen Inhaltsserver hochgeladen und nicht auf Steam "SetLive" "AlphaTest" // schaltet diesen Build auf einem Beta-Branch live "ContentRoot" "..\content\" // Inhaltsstammverzeichnis relativ zu dieser Skript-Datei "BuildOutput" "D:\build_output\" // legt den Build-Cache und die Protokolldateien für eine bessere Leistung auf einem anderen Laufwerk ab "Depots" { // file mapping instructions for each depot are in separate script files "1001" "depot_build_1001.vdf" "1002" "depot_build_1002.vdf" } }

This app build script references two depot build script files that specify all file mappings and file properties. The following instructions are available in a depot build script ( and also if the section is included directly into the app build script).

  • DepotID : Die Depot-ID für diesen Bereich.
  • ContentRoot : Ermöglicht optional das Überschreiben des Inhaltsstammordners aus dem App-Erstellungsskript pro Depot.
  • FileMapping : Dies ordnet Ihrem Depot eine einzelne Datei oder einen Satz Dateien aus dem lokalen Inhaltsstammverzeichnis zu. Es können mehrere Dateizuordnungen vorhanden sein, die Dateien zum Depot hinzufügen. Der Parameter LocalPath ist ein relativer Pfad zum Inhaltsstammverzeichnis und kann Symbole wie „?“ oder „*“ enthalten. Dies gilt auch für übereinstimmende Dateien in Unterordnern, falls Recursive aktiviert ist. Die Parameter von DepotPath gibt an, wo die ausgewählten Dateien im Depot angezeigt werden sollen (verwenden Sie nur '.' für nicht spezielle Zuordnungen).
  • FileExclusion : Schließt zugeordnete Dateien wieder aus und kann auch Platzhalter wie „?“ oder „*“ enthalten.
  • InstallScript : Markiert eine Datei als Installationsskript und signiert die Datei während des Erstellungsprozesses. Der Steam-Client kann sie für jede Anwendung ausführen, die dieses Depot bereitstellt.
  • FileProperties -Dateien können mit speziellen Flags markiert werden.
    • userconfig : Diese Datei wird durch den Benutzer oder das Spiel modifiziert. Sie kann nicht durch ein Update überschrieben werden und löst keinen Überprüfungsfehler aus, wenn sie sich von der vorherigen Version der Datei unterscheidet.
    • versionedconfig : Ähnlich zu „userconfig“, wird jedoch bei Aktualisierung der Datei im Depot lokal überschrieben, sobald das Spiel des Benutzers aktualisiert wird. Aktualisiert die Datei im Depot nur, wenn es eine notwendige Formatänderung oder Fehlerbehebung gibt.

Example depot build script depot_build_1002.vdf showing use of all options:
"DepotBuild" { "DepotID" "1002" "ContentRoot" "C:\content\depot1002" // überschreibt ContentRoot aus dem Build-Skript der Anwendung "FileMapping" { // alle Quelldateien und Ordner in ".\bin" werden dem Ordner ".\executables" im Depot "LocalPath" "bin\*" "DepotPath" "executables\" zugeordnet "Recursive" "1" // bezieht alle Unterordner mit ein } "FileMapping" { // überschreibt Audiodateien in \\Audio mit deutschen Versionen "LocalPath" "localization\german\audio\*" "DepotPath" "audio\" } "FileMapping" { // kopiert Installationsskript für deutsche Version in den Stammordner des Depos "LocalPath" "localization\german\german_installscript.vdf" "DepotPath" "." } "FileExclusion" "bin\server.exe" // Diese Datei ausschließen "FileExclusion" "*.pdb" // überall alle .PDB-Dateien ausschließen "FileExclusion" "bin\tools*" // alle Dateien unter bin\tools\ ausschließen "InstallScript" "localization\german\german_installscript.vdf" "FileProperties" { "LocalPath" "bin\setup.cfg" "Attributes" "userconfig" // diese Datei wird während der Laufzeit geändert } }

HINWEIS: You can name these scripts what ever you want, but we use the names app_build_<AppID> and depot_build_<DepotID> for consistency. If you know that you'll be building apps on this machine, it might be a good idea to create sub-directories in your scripts directory for each application, to help organize each application's build scripts.

Updates verwalten

After your app releases to customers, your customers will be receiving the build marked as the Default build. When uploading a new build it's always a good idea to test it before shipping it to your customers, for more information on how to successfully do this see Testen auf Steam.

Build-Probleme debuggen

If your build wasn't successful, you should look in your output directory for error information, not the console where the build script was run. Most error information can be found in the *.log files.
You can use these Steam client commands and client-side files to debug issues:
  • "app_status [appid]": Zeigt den aktuellen Status der App auf diesem Client.
  • "app_info_print [appid]": Zeigt die aktuelle Steamworks-Konfiguration für dieses Spiel (Depots, Startoptionen usw.).
  • "app_config_print [appid]": Zeigt die aktuelle Benutzerkonfiguration für dieses Spiel (aktuelle Sprache, Installationsverzeichnis usw.).
  • file "logs\content_log.txt": Listet alle protokollierten SteamPipe-Operationen und -Fehler auf.
  • file "steamapps\appmanifest_[appid].acf": Zeigt den aktuellen Installationsstatus dieser App (KeyValues).

Effiziente Depots für SteamPipe entwickeln

The old Steam content system would patch updates on a file level, which meant that if a single byte in a file changed, the entire new file would be downloaded by all users. This was especially inefficient if the game used pack files, which are collections of game content files in a single big file. Pack files can easily exceed 1 GB, so updates often led to unnecessarily large downloads. A common way to avoid these large downloads was to add new pack files that overrode content of already shipped pack files. That worked for updates, but it hurt new users long-term, since they ended up downloading unused, already-patched content.

The new content system fixes this problem by splitting each file into roughly 1-MB chunks. Each chunk is then compressed and encrypted before being distributed by the Steam content system. If the game content has large redundant parts, these chunks are reused and the user only has to download each repeated chunk once. However, the real strength of this system is building efficient update patches. While the system is building a patch, the new content is scanned for already known chunks. If it finds them, it reuses them. This means if you change or inject a few bytes in a big file, the user only has to download the changes.

This works well in most cases, but there are still a few pitfalls that need to be avoided when designing the content layout of a game. You may not want to compress or encrypt your game data. This is already done for in-flight downloads and retail discs by the Steam content system. If you do it too, it can reduce the effectiveness of delta patching. Compression and encryption are only advised if each individual asset within a package file is separately compressed and/or encrypted. Otherwise, a change to one asset will always require downloading several other potentially unchanged assets.

If you package multiple assets in a pack file, make sure that with each re-packaging, no unnecessary changes are made. One problematic practice is including the full name of the original source files on disk, because the names may change, depending on the build machine. Another bad pattern is including build time stamps for each file. If possible, always add new content to the end of your pack files and keep the order of existing files. Also, keep your pack file’s metadata (offset and sizes to individual assets) in one place and don’t intersperse it with the asset data. Use a binary difference tool like BeyondCompare to look at two builds of your pack files to make sure that hundreds of unwanted changes don’t show up.

Using pack files is especially useful to package lots of small files (<1 MB) into a single larger file. This will improve download speed and disk IO performance. But you might also want to avoid to put all your assets in a single huge pack file since Steam needs to copy & patch the whole file even if only a small subset of it changed. A good start would be to bundle resources of the same type together in pack files smaller than 4GB each.

If you follow these rules you will minimize patch sizes and only new content will need to be downloaded. Your customers will thank you for that and you will be able to increase the quality of your product by shipping more updates.

If you suspect that your game packaging is not interacting well with the SteamPipe update process, please contact your Valve representative and we can look into enabling advanced features to help with this.

Installationsdatenträger für den Einzelhandel erstellen

To build retail install disc for SteamPipe games, you must first setup a build project file.
In this example, the SKU file is called "sku_goldmaster.txt":
"sku" { "name" "Testspiel-Installer" "appid" "202930" "disk_size_mb" "640" "included_depots" { "1" "202931" "2" "202932" } }
Some tips to keep in mind:
  • Erstellen Sie einen neuen Ordner, in den die Abbilder der Datenträger für den Einzelhandel geschrieben werden sollen (z. B. „D:\retail_disks“). Es werden nur Depots in den Abschnitten „included_depots“ hinzugefügt. Den Abschnitt „exclude“ gibt es nicht mehr.
  • Sie können Steam.exe (mit den Befehlszeilenparametern -dev und -console) oder steamcmd.exe verwenden, um Installationsprogrammabbilder zu erstellen. Verwenden Sie in beiden Fällen den Befehl „build_installer“.
  • Melden Sie sich mit einem Steam-Account an, der sowohl das Spiel als auch alle Depots besitzt, die Sie auf dem Datenträger für den Einzelhandel speichern möchten. Andernfalls erfordert der Account keine speziellen Berechtigungen, sodass jede beliebige Person Installationsprogrammdatenträger erstellen kann.
  • Wenn Sie Steam.exe verwenden, dann stoppen Sie alle anderen Downloads.
  • Gehen Sie zur Konsolenseite und führen Sie den „build_installer“-Befehl aus:
    build_installer sku_goldmaster.txt "D:\retail_disks"
    Der Build kann einige Zeit dauern, da beim ersten Mal alle Depots erneut heruntergeladen werden.
  • Wenn Sie einen GM mit einem lokalen Inhaltsserver anfertigen, dann führen Sie Folgendes aus:
    @localcontentserver "webserver"
    build_installer sku_goldmaster.txt "D:\retail_disks" local
    Die Ausgabe bezieht sich auf „Sicherung“, da „Installationsdatenträger für den Einzelhandel“ und lokale Spielsicherungen praktisch dasselbe sind.
  • Sobald Sie „Sicherung für App-ID ...“ abgeschlossen sehen, sind die Installationsdatenträgerabbilder bereit. Weitere Details über den Sicherungsbuild finden Sie in logs\backup_log.txt.
  • Es gibt neue Verzeichnisse (Disk_1, Disk_2, usw.) in „D:\retail_disks“, die nicht größer als 640 MB sind, wie durch „disk_size_mb“ spezifiziert. Jeder Datenträgerordner enthält für jedes Depot eine „sku.sis“-Datei sowie eine CSD- (.csd) und CSM-Datei (.csm). Größere Depots können sich über mehrere Datenträger erstrecken. Alle Inhalte von Installationsdatenträgern für den Einzelhandel sind immer verschlüsselt (im Gegensatz zu lokalen Spielsicherungsdateien). Kopieren Sie die Setup-Dateien (setup.exe, setup.ini usw.) des SDK-GMs in den Ordner Ihres ersten Datenträgers und das Installationsprogramm des Datenträgers für den Einzelhandel ist fertig.
  • Achten Sie beim Anfertigen eines GMs für macOS darauf, auf einem Mac das Abbild „goldmaster/disk_assets/SteamRetailInstaller.dmg“ zu öffnen. Kopieren Sie danach die App, die sich dort befindet, in das Stammverzeichnis Ihres Datenträgers. Es wird empfohlen, den Namen der Installationsanwendung zu ändern, das Symbol mit der Marke zu versehen und das Fenster zu dekorieren, damit nur das Installationsprogramm angezeigt wird.
  • Stellen Sie beim Anfertigen eines aus mehreren Datenträgern bestehenden GMs für macOS sicher, dass der Volumename für jeden Datenträger übereinstimmt. Der Volumename wird zu einem Bestandteil des Einbindungspfads. Wenn die Namen nicht übereinstimmen, kann das Installationsprogramm den nächsten Datenträger nicht finden.

Optionale Erstellung eines Installationsprogramms für den Einzelhandel ausgehend von einer Beta-Branch

The process above will create a retail installer based on the default branch. If you need to create an installer based on a beta branch, you must first create a beta branch named "baseline". Then use the following command to build from the baseline branch:
build_installer <project file> <target folder> <beta key> <beta pwd> steamcmd ex: build_installer sku_goldmaster.txt "D:\retail_disks" baseline superSecret script ex: steamcmd.exe +login user_name password +build_installer "..\Build\GameDataSku.txt" c:\destination beta_key beta_password +exit

Einen DLC mit einem Installationsprogramm für den Einzelhandel installieren

In some circumstances, you may wish to create a retail installer that includes your DLC packages. In such cases, the process to create the installer requires only a few changes.
In "sku_goldmaster.txt", include the DLC AppIDs under the "included_depots" section. Once you have run the "build_installer" process, find the generated sku.sis file for the installer and open it with a text editor.
Add the DLC AppID in the "apps" section. For example, if I had a game with AppID 1000 and DLC AppID 1010, I would adjust the "apps" section as follows:
"apps" { "0" "1000" "1" "1010" }
This will ensure that Steam checks for ownership of the DLC and prompt the user for a key if the DLC is not owned by the account that they are logging into on Steam.

Ein Installationsprogramm für den Einzelhandel für mehrere App-IDs auf einem einzigen Datenträger oder in einem einzigen Installationspaket erstellen

To build a GM containing multiple Steam Pipe apps. Build each app installer one by one but point them all to the same output folder. Each build will merge itself with the already existing install image.

Einen Installationsdatenträger für den Einzelhandel anpassen

See Customizing a gold master for more details on customizing your retail install disk.

Spiele vor Veröffentlichung vorausladen

By default, all content is always encrypted, on all retail discs and on all content servers. Switching a game to preload mode means owners can download the content, but it stays encrypted on the users' disk and can't be played. Once the game becomes officially released, Steam will decrypt the preloaded content and the user can play the game.

Switching a game to preload mode is recommended in these cases:
  • Auslieferung von Datenträgern für den Einzelhandel mit Produktschlüsseln, bevor das Spiel wirklich erhältlich ist (0-Tage-Piraterie).
  • Spiele, die im Vorverkauf erhältlich sind und größer als 20 GB sind.

Please submit a ticket to Steam Publishing if you believe your game requires preloading.

DLCs erstellen

DLC is built as a depot of the base game. See the Zusatzinhalte (DLC) documentation for more information.

Fehlerbehebung für SteamPipe

„Anmeldefehler: Account-Anmeldung verweigert/fehlgeschlagen“ beim Anmelden über steamcmd.

Cause: Probably SteamGuard is preventing login. Resolution:
  • Rufen Sie die E-Mail-Adresse ab, die mit dem Account verknüpft ist, mit dem Sie sich anzumelden versuchen. Suchen Sie nach einer E-Mail vom Steam-Support. Kopieren Sie den Code aus dieser E-Mail.
  • Führen Sie den folgenden steamcmd-Befehl aus: set_steam_guard_code <code>.
  • Versuchen Sie, sich über steamcmd erneut anzumelden: Steam>logon <buildaccount> <password>.

Allgemeine Fehlerbehebung für Probleme beim Herunterladen

  • Starten Sie den Computer, das Modem, den Router usw. neu.
  • Verifizieren Sie die Firewall-Einstellungen. Das neue System erfordert Port 80 (HTTP) und alle anderen Steam Ports, die hier aufgeführt sind.
  • Deaktivieren Sie vorübergehend die lokalen Antiviren- oder Spamschutzprogramme.
  • Überprüfen Sie die Steam-Downloadregion unter Einstellungen > Downloads. Diese Region sollte Ihrem Standort entsprechen.
  • Stoppen Sie den Download, deinstallieren Sie das Spiel und installieren Sie es erneut (dadurch werden die Manifest-Caches gelöscht).
  • Schließen Sie Steam und löschen Sie die beiden Ordner „appcache“ und „depotcache“ in Ihrem Steam-Installationsordner.
  • Versuchen Sie, Ihre Steam-Downloadregion auf einen anderen, weit entfernten Standort einzustellen. Dies könnte funktionieren, falls ein Inhaltsserver in Ihrer Nähe fehlerhafte Daten liefert.

Meine Mac- und/oder Linux-Builds installieren keine Dateien. Woran liegt das?

If you're testing via Steam the installation of your game or application across multiple platforms, you may run into a situation where the build deploys on Windows but doesn't deploy any files on Mac or Linux despite your SteamPipe process being setup to upload Mac and/or Linux depots. There is a step that is easily missed which involves adding your alternate Depots to the Package being deployed. You can check what depots are included in a package via the following steps:
  1. Gehen Sie auf Ihre Seite App-Verwaltung.
  2. Klicken Sie im Abschnitt „Verwandte Elemente anzeigen“ auf Alle verknüpften Pakete, Zusatzinhalte, Videos und Werkzeuge.
  3. Klicken Sie auf den Titel des Pakets, das Sie herunterladen möchten.
  4. Prüfen Sie den Abschnitt Inbegriffene Depots.
  5. Verwenden Sie Depots hinzufügen/entfernen, um sicherzustellen, dass dem Paket der richtige Satz von Depots zugewiesen ist.
There are a number of discussion threads about this that may also assist:

Das Ausführen von steamcmd.exe führt zu folgendem Fehler: „SteamUpdater: Fehler: Steam muss zum Aktualisieren online sein. Bitte überprüfen Sie Ihre Netzwerkverbindung und versuchen Sie es erneut.“

Resolution: Go to Internet Options->Connections->Lan Settings and check Automatically detect settings.

Das Ausführen des App-Builds führt zu folgendem Fehler: „FEHLER! DepotBuild für scriptname.vdf“ fehlgeschlagen – Status = 6.“

Possible Causes:
  • Der Account verfügt nicht über die nötigen Berechtigungen für die App.
    • Überprüfen Sie, ob die App-ID in der Datei app_build.vdf korrekt ist.
    • Überprüfen Sie, ob der Build-Account die richtigen Berechtigungen für die App-ID hat.
  • Steamcmd kann die Depot-Inhalte nicht finden.
    • Überprüfen Sie, ob der „contentroot“-Wert im app_build-Skript ein gültiger Pfad in Relation zum Speicherort der Skriptdatei ist.
    • Überprüfen Sie, ob der "LocalPath"-Wert im depot_build-Skript ein gültiger Pfad in Relation zu dem Pfad im app_build-Skript ist. Überprüfen Sie, ob der Pfad tatsächlich Inhalte enthält.

Das Ausführen des App-Builds führt zu folgendem Fehler: „FEHLER! Abruf von Anwendungsinformationen für die App NNNNN fehlgeschlagen (Anmeldung und Abonnement überprüfen).“

This means that Steam can't retrieve information about the app, either because it doesn't exist or the user doesn't have access to the app.
  • Überprüfen Sie, ob NNNNN die App-ID ist, die Ihnen für die App zugewiesen wurde.
  • Überprüfen Sie, ob die App-ID in der Datei app_build.vdf korrekt ist.
  • Wenn es eine neue App-ID ist, dann überprüfen Sie, ob die Steamworks-Appverwaltungskonfiguration veröffentlicht wurde. Bei neuen Anwendungen sollte der Tab „Konfiguration“ ein SteamPipe-Installationsverzeichnis, der Tab „Depot“ ein Depot und der Tab „Veröffentlichen“ alle veröffentlichten Änderungen enthalten.
  • Wenn das alles korrekt ist, dann stellen Sie sicher, dass Ihr Account die App-ID besitzt.

„Bei der Installation von [AppName] ist ein Fehler aufgetreten (ungültige Inhaltskonfiguration).“ (beim Start)

Possible Causes:
  • In der Branch, von der aus Sie zu installieren versuchen, wurde kein Build live gestellt.
    Lösung: Stellen Sie Ihren Build auf einer Branch live, indem Sie https://partner.steamgames.com/apps/builds/<YourGameAppId> aufrufen und die betreffende Branch im Steam-Client auswählen. (wie hier beschrieben wird).
  • Ungültige Spielstartoptionen.
    Lösung: Überprüfen Sie die Startoptionen in der Anwendungsverwaltung für Ihr Spiel auf dem Tab „Installation“: https://partner.steamgames.com/apps/config/<YourGameAppId>.
  • Sie besitzen die Depot-IDs nicht, aus denen das Spiel besteht.
    Lösung: Stellen Sie sicher, dass die erforderlichen Depots zum Entwicklungsabonnement hinzugefügt werden (weitere Details siehe Bearbeiten von Paketen).

„Fehlercode 15“ beim Start

This is the CEG servers rejecting the request to CEG the exe. Check the release state on the game page. If it is not 'playable', you will need to request Steam keys that override the release state.

„Die Steam-Server sind ausgelastet und können Ihre Anfrage nicht bearbeiten ... Fehlercode (2)“ (beim Start)

This is the CEG servers failing to find a matching CEG exe. Double check that you have a working CEG executable on the CEG tab of your app admin. Click the 'status' button to make sure that it's propped.

Ich kann mich nicht mehr daran erinnern, wie der steamcmd-Befehl lautete oder wie er funktioniert hat.

Use the 'find' command in steamcmd to search for any steamcmd command. It will do partial matching on the command name and it will list out the command syntax.
Steam>find build_installer ConVars: Commands: build_installer : <project file> <target folder> <beta key> <beta pwd>