Steamworks-dokumentation
Upload til Steam

En nyere version er tilgængelig på engelsk

Den engelske version af denne side er blevet opdateret, efter denne oversættelse blev udgivet.

Klik her for at se den engelske version af siden.
Below is a guide to using SteamPipe, Valve's tool for delivering content to Steam. For more information on best practices for updating your game, see Bedste fremgangsmåder for spilopdateringer.

Introduktion til SteamPipe-indholdssystemet

SteamPipe is the game/application content system that powers Steam. SteamPipe includes the following features:
  • Hurtig og effektiv levering af indhold.
  • Ubegrænsede offentlige og private "betagrene", så flere builds kan testes.
  • Enkel webbaseret buildstyring – udgiv nye builds eller annuller et tidligere build med få klik.
  • Mulighed for at se opdateringsstørrelsen på et build, inden det sættes til live.
  • Mulighed for at dele indhold mellem flere applikationer.
  • Mulighed for at bygge installationsdiske fra offentligt eller betaindhold.
  • Spil/applikationer bliver ved med at være tilgængelige offline, også når hentning af en opdatering er startet.
  • Alt indhold er altid krypteret, og ikke-aktive versioner er ikke synlige for kunder.
  • En Lokal SteamPipe-indholdsserver, som kan bruges under udvikling.
BEMÆRK: Der er nogle koncepter, som er uundværlige for SteamPipe, og inden du går i gang, bør du sætte dig ind i de koncepter, der beskrives i dokumentationen Applikationer. Det vil være nyttigt at have en grundlæggende forståelse for, hvordan disse elementer hører sammen, når du uploader dit produkt til Steam.

Steamworks-videoguide: Sådan bygger du dit spil i Steampipe

This tutorial introduces SteamPipe and steps through building a sample application for Steam via the Steamworks tools.
https://www.youtube.com/watch?v=SoNH-v6aU9Q

Steamworks-videoguide: Sådan tilføjer du nye platforme og sprog

This tutorial walks you through adding new platforms and languages to your game by adding depots to your app.
https://www.youtube.com/watch?v=PShS32hcing

Tekniske detaljer om SteamPipe

SteamPipe uses the HTTP protocol for content delivery. Since downloads are regular web traffic, any third-party HTTP cache between the customer and Steam servers will increase download speed. Content can be hosted by external CDN providers, which can be easily added to our content network. Most consumer firewalls allow HTTP traffic and won't block downloads.

SteamPipe has an efficient patching algorithm based on binary deltas, only changing the modified portions of existing content files. When this content is updated, only these deltas need be sent. This means both developer and user transfers are smaller and faster. Most partners will find that using a Lokal SteamPipe-indholdsserver not necessary since they can efficiently patch builds on private branches.

Steam-konto til builds

Before you can create any builds on Steam, you must have a Steam account in your Steamworks account with the "Edit App Metadata" and "Publish App Changes To Steam" permissions granted. For security reasons it's recommended that you have a dedicated build account with just those permissions, you may create a new Steam account for this purpose at https://store.steampowered.com/join.

Any administrator of your Steamworks account can add a Steam account and grant the necessary permissions. More information on this process can be found in the Administrer din Steamworks-konto documentation. An example of what this account might look like is:

create_build_account.png

Indledende opsætning for nye SteamPipe-apps

Follow these steps to set up new SteamPipe apps:
  1. Find app-ID'et for din applikation (dette kan findes ved at vælge applikationen på din hjemmeside i Steamworks).
  2. Gå til siden Generelle installationsindstillinger for din app.
  3. Definer mindst en startparameter (stien og (valgfrit) nødvendige argumenter for at starte spillet). Hold musen over (?) for at læse mere om hvert felt.

    Eksemplet nedenfor viser fire startparametre, to for Windows og én for henholdsvis MacOS og Linux. Launch option 3 will only be shown on Windows if the user also owns the DLC specified.

    updatedlaunchoptions.png
  4. Gå til siden Depoter, og tilføj depoter efter behov for denne app. Som standard kan der allerede være konfigurerte et depot for din applikation.
    1. Klik på standarddepotet, og omdøb depotet med et passende og genkendeligt navn (for eksempel "Grundindhold" eller "Windows-indhold").
    2. Leave the language set to [All languages] unless this is a language-specific depot.
    3. Lad operativsystemet være sat til [Alle operativsystemer], medmindre det er et OS-specifikt depot (hvis appen er en alt-i-én-løsning eller kun til PC eller kun til Mac, skal den indstilles til [Alle operativsystemer]. Du skal kun ændre denne parameter for OS-specifikke spildepoter.
    4. Klik på Tilføj nyt depot for at oprette yderligere depoter.
    5. Klik på Gem ændringer for at gemme eventuelle ændringer.
  5. Når du er færdig med at definere dine depoter, skal du udgive de ændringer, du har foretaget fra siden Udgiv.
  6. Nyligt definerede depoter skal inkluderes i en pakke, så du får ejerskab over dem. Hvert spil på Steam skal have en udviklerpakke, som automatisk tildeles til de konti, der står i din udgivergruppe.
    Du kan tilføje de nye depoter til denne pakke (og/eller andre pakker, som skal have disse depoter) på siden Tilknyttede pakker og DLC.
Bemærk: Hvis din eksekverbare fil ligger i en undermappe til den primære installationsmappe, skal du tilføje navnet på undermappen i feltet "Eksekverbar". Brug ikke foranstillede skråstreger eller prikker.

Opsætning af SDK'en til 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 – Denne mappe indeholder til at starte med kun steamcmd.exe, som er kommandolinjeversionen af Steam.
  • builder_linux – Linux-versionen af steamcmd.
  • builder_osx – MacOS-versionen af steamcmd.
  • content – Denne mappe indeholder alle spilfiler, som skal bygges ind i depoter.
  • output – Denne mappe vil være stedet for buildlogs, segmentcache og mellemliggende output. BEMÆRK: Denne mappe kan slettes eller tømmes når som helst, men når den er blevet slettet, vil den næste upload tage længere tid.
  • scripts – Denne mappe er der, hvor du placerer alle dine buildscripts, når du bygger dine spildepoter.
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 Lokal SteamPipe-indholdsserver if you choose to do so.

SteamCmd på macOS

To enable SteamCmd on macOS you must complete the following steps:
  1. Fra terminalen skal du gå til mappen tools\ContentBuilder\builder_osx\osx32
  2. Kør chmod +x steamcmd
  3. Gå op til den overordnede mappe (tools\ContentBuilder\builder_osx)
  4. Indtast bash ./steamcmd.sh
  5. SteamCmd vil så køre og opdatere til det seneste build, hvorefter du ser SteamCmd-kommandoprompten
  6. Indtast exit, og tryk på Enter for at forlade kommandoprompten
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.

Oprettelse af SteamPipe-buildkonfigurationsfiler

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.

GUI-værktøj i SteamPipe

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.

Simple Build Script


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" // your AppID "Desc" "This is a simple build script" // internal description for this build "ContentRoot" "..\content\" // root content folder, relative to location of this file "BuildOutput" "..\output\" // build output folder for build logs and build cache files "Depots" { "1001" // your DepotID { "FileMapping" { "LocalPath" "*" // all files from contentroot folder "DepotPath" "." // mapped into the root of the depot "recursive" "1" // include all subfolders } } } }

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 +run_app_build ..\scripts\simple_app_build.vdf +quit

BEMÆRK: 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 ", 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 \ssfn, and the config file is located in \config\config.vdf.

The following steps occur during a SteamPipe build:
[olist]
[*] Steamcmd.exe will update itself to the latest version.
[*] Steamcmd.exe is logging into the Steam backend using the given builder Steam account.
[*] The app build start is registered with the MDS (Master Depot Server), which will ensure the user has the proper privileges to modify this app.
[*] For each depot included in the app build, a file list is generated based on the files in the content folder and the filter rules defined in depot build config file.
[*] Each file is scanned and divided into small chunks of about 1MB. If the depot has been built before, this partitioning will preserve as many of the unchanged chunks as possible.
[*] New file chunks are compressed, encrypted, and then uploaded to the MDS.
[*] A final manifest is generated for this depot version; each manifest is identified by a unique 64-bit manifest ID.
[*] Once all depots have been processed, the MDS finishes this app build and assigns it a global BuildID.
[*] After the build is done, there may be *.csm and *.csd files in the build ouput folder. These are temporary and can be deleted, but they speed up subsequent build times.[/olist]


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.

Advanced Build Scripts


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:

  • AppID - The AppID of your game. The uploading Steam partner account needs 'Edit App Metadata' privileges
  • Desc - The description is only visible to you in the 'Your Builds' section of the App Admin panel. This can be changed at any time after uploading a build on the 'Your Builds' page.
  • ContentRoot - The root folder of your game files, can be an absolute path or relative to the build script file.
  • BuildOutput - This directory will be the location for build logs, depot manifests, chunk caches, and intermediate output. For best performance, use a separate disk for your build output. This splits the disk IO workload, letting your content root disk handle the read requests and your output disk handle the write requests.
  • Preview - This type of build only outputs logs and a file manifest into the build output folder. Building preview builds is a good way to iterate on your upload scripts and make sure your file mappings, filters and properties work as intended.
  • Local - Set this to the htdocs path of your Lokal SteamPipe-indholdsserver (LCS). LCS builds put content only on your own HTTP server and allow you to test the installation of your game using the Steam client.
  • SetLive - Beta branch name to automatically set live after successful build, none if empty. Note that the 'default' branch can not be set live automatically. That must be done through the App Admin panel.
  • Depots - This section contains all file mappings, filters and file properties for each depot or references a separate script file for each depot

Example app build script "app_build_1000.vdf" is using all options:
"AppBuild" { "AppID" "1000" // Your AppID "Desc" "Your build description here" // internal description for this build "Preview" "1" // make this a preview build only, nothing is uploaded "Local" "..\..\ContentServer\htdocs" // put content on local content server instead of uploading to Steam "SetLive" "AlphaTest" // set this build live on a beta branch "ContentRoot" "..\content\" // content root folder relative to this script file "BuildOutput" "D:\build_output\" // put build cache and log files on different drive for better performance "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 - The DepotID for this section
  • ContentRoot - Lets you optionally override the ContentRoot folder from the app build script on a per depot basis
  • FileMapping - This maps a single file or a set of files from the local content root into your depot. There can be multiple file mappings that add files to the depot. The LocalPath parameter is a relative path to the content root folder and may contain wildcards like '?' or '*'. It will also apply to matching files in subfolders if Recursive is enabled. The DepotPath parameter specifies where the selected files should appear in the depot (use just '.' for no special mapping)
  • FileExclusion - will excluded mapped files again and can also contain wildcards like '?' or '*'
  • InstallScript - will mark a file as install scripts and will sign the file during the build process. The Steam client knows to run them for any application which mounts this depot.
  • FileProperties - will mark a file with special flags:
    • userconfig - This file is modified by the user or game. It cannot be overridden by an update, and it won't trigger a verification error if it's different from the previous version of the file.
    • versionedconfig - Similar to userconfig, however if the file is updated in the depot, it will be overwritten locally when the user's game updates. Only update the file in the depot when there is a necessary format change or bug fix.

Example depot build script depot_build_1002.vdf showing use of all options:
"DepotBuild" { "DepotID" "1002" "ContentRoot" "C:\content\depot1002" // override ContentRoot from app build script "FileMapping" { // all source files and folders in ".\bin" will be mapped into folder ".\executables" in depot "LocalPath" "bin\*" "DepotPath" "executables\" "Recursive" "1" // include all subfolders } "FileMapping" { // override audio files in \\audio with German versions "LocalPath" "localization\german\audio\*" "DepotPath" "audio\" } "FileMapping" { // copy install script for german version into depot root folder "LocalPath" "localization\german\german_installscript.vdf" "DepotPath" "." } "FileExclusion" "bin\server.exe" // exclude this file "FileExclusion" "*.pdb" // exclude all .PDB files everywhere "FileExclusion" "bin\tools*" // exclude all files under bin\tools\ "InstallScript" "localization\german\german_installscript.vdf" "FileProperties" { "LocalPath" "bin\setup.cfg" "Attributes" "userconfig" // this file will be modified during runtime } }

BEMÆRK: You can name these scripts what ever you want, but we use the names app_build_ and depot_build_ 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.

Managing Updates

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 Testarbejde på Steam.

Debugging Build Issues

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]" – Viser appens nuværende tilstand på denne klient.
  • "app_info_print [appid]" – Viser den nuværende Steamworks-konfiguration for dette spil (depoter, startparametre osv.).
  • "app_config_print [appid]" – Viser den nuværende brugerkonfiguration for dette spil (nuværende sprog, installationsmappe osv.).
  • file "logs\content_log.txt" - Lists all logged SteamPipe operations and errors.
  • file "steamapps\appmanifest_[appid].acf" – Viser denne apps nuværende installationstilstand (KeyValues).

Building Efficient Depots for SteamPipe

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 single 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.

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.

Building Retail Install Discs

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" "Test Game Installer" "appid" "202930" "disk_size_mb" "640" "included_depots" { "1" "202931" "2" "202932" } }
Some tips to keep in mind:
  • Opret en ny mappe, som diskbilleder skal skrives til, for eksempel "D:\retail_disks". Kun depoter i included_depots-sektionerne tilføjes. Der er ikke længere undtagelser.
  • Du kan bruge Steam.exe (med kommandolinjeparametrene -dev og -console) eller steamcmd.exe til at bygge installationsbilleder. Brug "build_installer"-kommendoen i begge tilfælde.
  • Log på med en Steam-konto, som ejer spillet og alle de depoter, du vil lægge på detaildisken. Ellers behøver kontoen ikke at have særlige rettigheder, så alle kan oprette installationsdiske.
  • Hvis du bruger Steam.exe, skal alle andre downloads stoppes.
  • Gå til konsolsiden, og kør kommandoen build_installer:
    build_installer sku_goldmaster.txt "D:\retail_disks"
    Buildet kan tage et stykke tid, eftersom alle depoter downloades igen for første gang.
  • Hvis du opretter en Gold Master med en lokal indholdsserver, skal du køre:
    @localcontentserver "webserver"
    build_installer sku_goldmaster.txt "D:\retail_disks" local
    Teksten i konsollen henviser til "Sikkerhedskopiering", eftersom en installationsdisk og en lokal backup stort set er det samme.
  • Når du ser teksten "Sikkerhedskopiering færdig for app-ID...", er installationsdiskbillederne klar. Du kan finde flere detaljer om backup-buildet i logs\backup_log.txt.
  • Der er nye mapper (Disk_1, Disk_2 osv.) i "D:\retail_disks", hver på maks. 640 MB, som angivet med "disk_size_mb". hver diskmappe indeholder en "sku.sis"-fil og en .csd og .csm for hvert depot. Større depoter kan strække sig over flere diske. Alt indhold på detailinstallationsdiske krypteres altid (til forskel fra lokale spilsikkerhedskopifiler). Kopier GM-installationsfilerne for SDK'en (setup.exe, setup.ini osv.) til mappen med din første disk for at færdiggøre oprettelsen af din installationsdisk.
  • When creating a GM for macOS be sure to open the goldmaster/disk_assets/SteamRetailInstaller.dmg image on a Mac. Tag derefter appen, som ligger der, og kopier den til mediets rod. Du skal nok ændre navnet på installationsappen, oprette dit eget ikon og kun vise installationsprogrammet i vinduet.
  • When creating a multi-disc GM for macOS, be sure the volume name for each disc matches. Enhedsnavnet bliver en del af forbindelsesstien, og hvis navnene ikke stemmer overens, vil installationsprogrammet ikke kunne finde den næste disk.

Oprettelse af valgfri installationsdisk fra en betagren

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 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

Installation af DLC fra et detailinstallationsprogram

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.

Oprettelse af detailinstallationsprogram for flere app-ID'er på en enkelt disk/installationspakke

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.

Tilpasning af installationsdisk

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

Preloading Games before Release

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:
  • Udgivelse af detaildiske med produktnøgler, inden spillet er officielt tilgængeligt (undgå piratkopiering før udgivelsen).
  • Spil med forudkøb, og som er større end 20 GB.

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

Building DLC

DLC is built as a depot of the base game. See the Indhold, der kan downloades (DLC) documentation for more information.

Troubleshooting SteamPipe

"Login Failure: Account Login Denied Failed" when logging in via steamcmd

Cause: Probably SteamGuard is preventing login. Resolution:
  • Tjek e-mailadressen, som er tilknyttet den konto, du prøver at logge på med, og se efter en e-mail fra Steam Support. Kopier koden fra e-mailen.
  • Kør steamcmd: set_steam_guard_code
    [*] Re-Attempt login from steamcmd: [code-inline]Steam>login
[/list]

Generel fejlfinding af problemer med downloads

  • Genstart computeren, modemmet, routeren osv.
  • Bekræft firewallindstillingerne. Det nye system kræver port 80 (HTTP) og alle andre Steam-porte, som står her.
  • Slå lokale antivirus- eller spamblokeringsprogrammer fra.
  • Tjek download-området i Steam under Indstillinger -> Downloads. Dette bør matche din placering.
  • Stop overførslen, afinstaller og geninstaller spillet (ryd manifestcachelagre).
  • Afslut Steam, slet mapperne appcache og depotcache i Steam-installationsmappen.
  • Indstil "Download-område" i Steam til et sted langt væk. Dette vil måske virke, hvis en indholdsserver i nærheden af dig serverer dårlige data.

Mine Mac- og/eller Linux-builds installerer ikke nogen filer. Hvorfor?

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. Gå til siden App-administrator
  2. From the View Associated Items section, click All Associated Packages, DLC, Demos and Tools.
  3. Klik på titlen på den pakke, du forsøger at downloade
  4. Gennemgå sektionen Depoter inkluderet
  5. Brug Tilføj/fjern depoter for at sikre, at det korrekte depotsæt er tildelt pakken
There are a number of discussion threads about this that may also assist:

Når steamcmd.exe køres, giver det følgende fejl: "SteamUpdater: Error: Steam needs to be online to update. Please confirm your network connection and try again." (SteamUpdater: Fejl: Steam skal være online for at opdatere)

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

Når app-buildet køres, giver det følgende fejl: "ERROR! Failed 'DepotBuild for scriptname.vdf' - status = 6." (FEJL! "DepotBuild for scriptname.vdf" fejlede – status = 6)

Possible Causes:
  • Kontoen har ikke tilladelser til appen.
    • Kontrollér, at app-ID'et er korrekt i app_build.vdf.
    • Kontrollér, at build-kontoen har de nødvendige tilladelser til app-ID'et.
  • Steamcmd kan ikke finde depotindholdet.
    • Kontrollér, at "contentroot"-værdien i appen app_build-scriptet er en gyldig sti i forhold til scriptfilens placering.
    • Kontrollér, at "LocalPath"-værdien i depot_build-scriptet er en gyldig sti i forhold til app_build-scriptet. Kontrollér, at stien indeholder indhold.

Når app-buildet køres, giver det følgende fejl: "ERROR! Failed to get application info for app NNNNN (check login and subscription)" (FEJL! Kunne ikke få applikationsinformation for appen NNNNN (tjek login og abonnement))

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.
  • Kontrollér, at NNNNN er det app-ID, du fik tildelt for appen.
  • Kontrollér, at app-ID'et er korrekt i app_build.vdf.
  • Hvis det er et nyt app-ID, skal du kontrollere, at konfigurationen af app-administratoren i Steamworks er blevet udgivet. Nye apps skal have en SteamPipe-installationsmappe på konfigurationsfanen, et depot på depotfanen, og alle ændringer skal være udgivet på udgivelsesfanen.
  • Hvis alt dette ser korrekt ud, skal du sikre, at din konto ejer app-ID'et.

"An error occurred while installing [AppName] (Invalid content configuration)" at launch time (Der opstod en fejl under installation af [AppName] (ugyldig indholdskonfiguration)", når spillet startes)

Possible Causes:
  • Der intet build sat som live på den gren, du prøver at installere fra.
    Løsning: Sæt dit build som live på en gren ved at gå til https://partner.steamgames.com/apps/builds/, og vælg grenen i Steam-klienten (som beskrevet her).
  • Ugyldige startparametre.
    Løsning: Bekræft startparametrene på fanen "Installation" i app-administratoren for dit spil: https://partner.steamgames.com/apps/config/.
  • Du ejer ikke depot-ID'erne, som udgør spillet.
    Løsning: Sørg for, at de nødvendige depoter tilføjes til udviklingsabonnementet (se Redigering af pakker for yderligere oplysninger).

"Error code 15", når spillet startes

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.

"The Steam Servers are too busy to handle your request... Error Code (2)" at launch time (Steam-serverne er for optagede til at håndtere til anmodning... Fejlkode (2), når spillet startes)

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.

Jeg kan ikke huske, hvad steamcmd-kommandoen var, eller hvordan den virkede

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 :
[/code-inline]