What Files Are Needed to Upload a Map to Server Source Engine

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, encounter Updating Your Game - Best Practices.

Introduction to the SteamPipe Content System

SteamPipe is the game/application content system that powers Steam. SteamPipe includes the following features:

• Efficient and fast content commitment.
  
• Public and private "beta" branches, allowing multiple builds to be tested.
  
• Elementary web-based management of builds - push out a new build or rollback to a previous build with just a few clicks.
  
• Ability to run across the update size of a build before setting it alive.
  
• Power to share content between multiple applications.
  
• Power to build installer discs from public or beta content.
  
• Games/apps stay available offline even later on an update download has been started.
  
• All content is ever encrypted, and non-active versions are non visible to customers.
  
• A SteamPipe Local Content Server which tin be used during development.

NOTE: In that location are a few concepts which are integral to SteamPipe, before getting started you should be familiar with all of the concepts outlined in the Applications documentation. Having even a basic understanding of how these pieces fit together will be very useful when uploading your production to Steam.

Steamworks Video Tutorial - Building Your Game in Steampipe

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

Steamworks Video Tutorial - Adding New Platforms and Languages

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

SteamPipe Technical Details

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 tin be hosted past external CDN providers, which tin can exist easily added to our content network. Most consumer firewalls let 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, just these deltas demand exist sent. This means both programmer and user transfers are smaller and faster. Most partners will detect that using a SteamPipe Local Content Server not necessary since they can efficiently patch builds on private branches.

Steam Build Business relationship

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

Any administrator of your Steamworks account can add a Steam account and grant the necessary permissions. More than information on this process can be establish in the Managing Your Steamworks Account documentation. An example of what this account might look like is:

Initial Setup for New SteamPipe Apps

Follow these steps to set up new SteamPipe apps:

1. Detect the app ID for your application (this can exist plant by selecting the awarding on your homepage in Steamworks)
   
2. Go to the General Installation Settings page for your app.
   
3. Define at least one launch option (the path and optionally, any arguments required to launch the game). Hover over the (?) to learn more about each field.

   The example below shows five launch options, ii for Windows, ii for macOS and 1 for Linux.
   Launch option 3 will only exist shown on Windows if the user too owns the DLC specified.

   

4. Go to the Depots page and add depots as needed for this app. By default, a depot may already exist configured for your awarding.
   
   1. Click the default depot and alter the name of the depot to a proper and recognizable name (such as "Base Content" or "Windows Content").
      
   2. Leave the language ready to [All languages] unless this is a language-specific depot.
      
   3. Leave the OS set to [All OSes] unless this is an OS-specific depot (if the app is all-in-ane, or is just PC or merely Mac, it should be left to [All OSes]. Only specify for OS-specific game depots.
      
   4. Click Add New Depot to create boosted depots.
      
   5. Click Save Changes to relieve whatsoever changes made.
      
5. In one case you are done defining your depots, publish the changes that you take fabricated from the Publish page.
   
6. Your newly defined depots will need to be included in a bundle to grant you ownership of them. Each game on Steam should accept a Developer Comp package which is automatically granted to the accounts listed within your publisher grouping.
   You tin can add the new depots to that package (and/or other packages that should have these depots) on the Associated Packages & DLC folio.

Note: If your executable is in a sub-folder of the main installation folder, add the sub-folder name in the Executable field. Don't use leading slashes or dots.

Platform Note: As shown in a higher place, 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 information technology allows macOS to more than correctly determine launch parameters in the manner it would if launched manually exterior of Steam.

I instance of this to notation is that currently applications that are launched through an app bundle on Apple Silicon devices volition launch the all-time compages available in the application whereas directly binary launches will use the same compages every bit the Steam process (currently x86_64).

Setting up the SDK for 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 plant inside 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 alive. This directory contains the post-obit sub-directories:

• architect - This directory initially contains merely steamcmd.exe which is the command line version of Steam.
  
• builder_linux - The linux version of steamcmd.
  
• builder_osx - The macOS version of steamcmd.
  
• content - This directory contains all game files that will be built into depots.
  
• output - This directory volition exist the location for build logs, chunk cache, and intermediate output. Annotation: This folder can be deleted or emptied at any fourth dimension, but subsequently it's deleted, the next upload fourth dimension will take longer.
  
• scripts - This directory is where you'll identify all of your build scripts for building your game depots.

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

The ContentServer directory contains the tools for running your own SteamPipe Local Content Server if you lot cull to practise so.

SteamCmd on macOS

To enable SteamCmd on macOS you lot must complete the following steps:

1. From the last, scan to the tools\ContentBuilder\builder_osx\osx32 folder
   
2. Run chmod +x steamcmd
   
3. Browse upwards to the parent folder (tools\ContentBuilder\builder_osx)
   
4. Type bash ./steamcmd.sh
   
5. SteamCmd will then run and update to the latest build, leaving you lot in the SteamCmd prompt
   
6. Type go out and press return to exit the prompt

Y'all can and so follow the residuum of this documentation (substituting paths every bit appropriate) to create depot and app config files for uploading your content to Steam.

Creating SteamPipe Build Config Files

To upload files for your app with SteamPipe, y'all must create scripts which depict your build and each depot that will exist included in information technology. The example scripts shown here are in the Tools\ContentBuilder\scripts folder in the Steamworks SDK.

SteamPipe GUI Tool

If yous're running on Windows and would prefer a GUI tool to assist create these config files and upload your builds y'all can apply the SteamPipeGUI which is bachelor in the tools binder of the Steamworks SDK. Included in the zip are additional instructions to get you started.

If you cull to use the GUI tool then reading the following sections is nevertheless recommended to help you get more familiar with how the SteamPipe organization works.

Elementary Build Script

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

"AppBuild" { "AppID" "1000" // your AppID "Desc" "This is a elementary build script" // internal clarification for this build "ContentRoot" "..\content\" // root content folder, relative to location of this file "BuildOutput" "..\output\" // build output binder 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" "ane" // include all subfolders } } } }

Adjust the AppID and DepotID for your game as needed. To kick off a build you demand to run steamcmd and pass a couple of parameters :

tools\ContentBuilder\builder\steamcmd.exe +login <account_name> <countersign> +run_app_build ..\scripts\simple_app_build.vdf +quit

NOTE: Your first attempt at running a build may fail due to Steam Baby-sit. If the login fails due to Steam Guard, bank check your electronic mail for the Steam Baby-sit code, and run steamcmd equally: steamcmd.exe "set_steam_guard_code <code>", and try again. Afterward logging in with Steam Guard in one case, a picket file is used to verify the login is genuine.

If you are using steamcmd from a machine or VM that gets re-imaged oft, you lot 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 volition update itself to the latest version.
   
2. Steamcmd.exe is logging into the Steam backend using the given builder Steam account.
   
3. The app build start is registered with the MDS (Primary Depot Server), which volition ensure the user has the proper privileges to alter this app.
   
4. For each depot included in the app build, a file listing is generated based on the files in the content binder and the filter rules defined in depot build config file.
   
5. Each file is scanned and divided into small chunks of about 1MB. If the depot has been built before, this partitioning volition preserve as many of the unchanged chunks as possible.
   
6. New file chunks are compressed, encrypted, and then uploaded to the MDS.
   
7. A terminal manifest is generated for this depot version; each manifest is identified by a unique 64-bit manifest ID.
   
8. Once all depots have been processed, the MDS finishes this app build and assigns it a global BuildID.
   
9. After the build is done, there may be *.csm and *.csd files in the build ouput folder. These are temporary and tin can be deleted, but they speed upwardly subsequent build times.

Once the build is complete you tin see it on your app builds page, in this case information technology would be https://partner.steamgames.com/apps/builds/1000. There you can gear up 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 lot can create a depot build script for each depot which volition exist referenced by the app build script. Offset let's have a await at bachelor parameters in the app build script:

• AppID - The AppID of your game. The uploading Steam partner business relationship needs 'Edit App Metadata' privileges
  
• Desc - The clarification is only visible to you lot in the 'Your Builds' department of the App Admin panel. This can exist inverse at whatsoever time afterward uploading a build on the 'Your Builds' folio.
  
• ContentRoot - The root folder of your game files, can be an accented 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 SteamPipe Local Content Server (LCS). LCS builds put content merely on your own HTTP server and allow yous to examination the installation of your game using the Steam client.
  
• SetLive - Beta branch proper name to automatically gear up live after successful build, none if empty. Note that the 'default' branch can not exist set live automatically. That must be done through the App Admin panel.
  
• Depots - This section contains all file mappings, filters and file backdrop 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 clarification here" // internal description for this build "Preview" "one" // 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 alive on a beta branch "ContentRoot" "..\content\" // content root binder relative to this script file "BuildOutput" "D:\build_output\" // put build cache and log files on different drive for improve functioning "Depots" { // file mapping instructions for each depot are in divide 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 backdrop. The post-obit instructions are available in a depot build script ( and as well if the department is included directly into the app build script).

• DepotID - The DepotID for this department
  
• ContentRoot - Lets you optionally override the ContentRoot folder from the app build script on a per depot basis
  
• FileMapping - This maps a unmarried file or a set of files from the local content root into your depot. There tin can be multiple file mappings that add files to the depot. The LocalPath parameter is a relative path to the content root binder and may contain wildcards similar '?' or '*'. It volition 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 once again and can also comprise wildcards like '?' or '*'
  
• InstallScript - will mark a file every bit 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 marker a file with special flags:
  
  • userconfig - This file is modified by the user or game. It cannot exist overridden by an update, and it won't trigger a verification mistake 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 set.

Instance 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" volition exist mapped into folder ".\executables" in depot "LocalPath" "bin\*" "DepotPath" "executables\" "Recursive" "1" // include all subfolders } "FileMapping" { // override audio files in \\sound with High german versions "LocalPath" "localization\high german\audio\*" "DepotPath" "audio\" } "FileMapping" { // re-create install script for german language 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 } }

Annotation: You lot tin can proper noun these scripts what e'er you want, but we use the names app_build_<AppID> and depot_build_<DepotID> for consistency. If you know that yous'll be edifice 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'due south ever a good idea to test information technology before shipping information technology to your customers, for more information on how to successfully practise this see Testing On Steam.

Debugging Build Issues

If your build wasn't successful, you should await in your output directory for error information, not the console where the build script was run. Most fault information can be found in the *.log files.
You can employ these Steam client commands and client-side files to debug bug:

• "app_status [appid]" - Shows the current state of the app on this customer.
  
• "app_info_print [appid]" - Shows the current Steamworks configuration for this game (depots, launch options, etc.).
  
• "app_config_print [appid]" - Shows the current user configuration for this game (current linguistic communication, install directory, etc.).
  
• file "logs\content_log.txt" - Lists all logged SteamPipe operations and errors.
  
• file "steamapps\appmanifest_[appid].acf" - Shows the electric current install state of this app (KeyValues).

Building Efficient Depots for SteamPipe

The sometime Steam content organization would patch updates on a file level, which meant that if a unmarried 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 ofttimes led to unnecessarily large downloads. A mutual manner to avoid these large downloads was to add together new pack files that overrode content of already shipped pack files. That worked for updates, merely it hurt new users long-term, since they ended upward downloading unused, already-patched content.

The new content organisation fixes this problem by splitting each file into roughly i-MB chunks. Each chunk is and then compressed and encrypted before existence distributed by the Steam content system. If the game content has large redundant parts, these chunks are reused and the user just has to download each repeated clamper in one case. Nevertheless, the real force 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 simply has to download the changes.

This works well in nearly cases, simply there are still a few pitfalls that need to exist 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-flying downloads and retail discs by the Steam content system. If you do information technology too, it tin reduce the effectiveness of delta patching. Compression and encryption are simply advised if each individual asset within a package file is separately compressed and/or encrypted. Otherwise, a alter to one asset will always require downloading several other potentially unchanged avails.

If y'all package multiple assets in a single pack file, make sure that with each re-packaging, no unnecessary changes are made. 1 problematic practice is including the total name of the original source files on disk, because the names may change, depending on the build motorcar. Another bad pattern is including build time stamps for each file. If possible, e'er add new content to the end of your pack files and go along the lodge of existing files. Also, keep your pack file'south metadata (offset and sizes to individual assets) in one place and don't intersperse it with the asset information. Employ a binary departure tool like BeyondCompare to look at two builds of your pack files to make sure that hundreds of unwanted changes don't show upward.

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

If y'all suspect that your game packaging is not interacting well with the SteamPipe update procedure, please contact your Valve representative and we tin look into enabling avant-garde features to help with this.

Building Retail Install Discs

To build retail install disc for SteamPipe games, you must starting time setup a build project file.
In this example, the SKU file is chosen "sku_goldmaster.txt":

"sku" { "proper name" "Test Game Installer" "appid" "202930" "disk_size_mb" "640" "included_depots" { "1" "202931" "ii" "202932" } }

Some tips to keep in mind:

• Create a new folder where the retail disc images volition be written to, due east.g., "D:\retail_disks". Only depots in the included_depots sections are added; there is no exclude section anymore.
  
• You can use Steam.exe (with the -dev and -console command-line parameters) or steamcmd.exe to build installer images. In both cases, use the "build_installer" command.
  
• Log on with a Steam account that owns the game and all depots you desire to put on the retail disc. Otherwise, the account doesn't demand special rights, then anyone can build installer discs.
  
• If you apply Steam.exe, stop all other downloads.
  
• Go to the console page and run the build_installer control:

  build_installer sku_goldmaster.txt "D:\retail_disks"

  The build can take a while since all depots are re-downloaded the starting time time.
  
• If you lot're edifice a GM using a local content server, run:
  @localcontentserver "webserver"
build_installer sku_goldmaster.txt "D:\retail_disks" local
  The spew refers to 'Fill-in' since 'Retail install Deejay' and local game backups are basically the same.
  
• In one case you see "Backup finished for AppID...", the install disk images are set. You lot can find more details about the backup build in logs\backup_log.txt.
  
• There are new folders (Disk_1, Disk_2, and so on) in "D:\retail_disks", each non bigger than 640 MB, as specified with "disk_size_mb". Each disk binder contains a "sku.sis" file and a .csd and .csm for each depot. Bigger depots span across multiple disks. All retail install disk content is always encrypted (unlike local game backup files). Re-create the SDK GM setup files (setup.exe, setup.ini, etc.) into the binder of your first disk and the retail disc installer is complete.
  
• When creating a GM for macOS be certain to open up the goldmaster/disk_assets/SteamRetailInstaller.dmg paradigm on a Mac. And then take the app that is in there and copy information technology to the root of your media. Y'all will probably want to modify the name of the install app, brand the icon and decorate the window to but show the installer.
  
• When creating a multi-disc GM for macOS, be sure the volume proper name for each disc matches. The volume proper name becomes part of the mountain path, and if the names don't match the installer won't be able to observe the next disc.

Optionally building a retail installer from a beta branch

The procedure higher up will create a retail installer based on the default branch. If you need to create an installer based on a beta branch, you lot must commencement create a beta branch named "baseline". Then use the post-obit command to build from the baseline branch:

build_installer <project file> <target binder> <beta primal> <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

Installing DLC from a retail installer

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 simply a few changes.
In "sku_goldmaster.txt", include the DLC AppIDs nether the "included_depots" department. Once you accept run the "build_installer" process, notice the generated sku.sis file for the installer and open it with a text editor.
Add the DLC AppID in the "apps" section. For instance, 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 non owned by the account that they are logging into on Steam.

Building a retail installer for multiple App IDs on a single disc/install package

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

Customizing a Retail install deejay

Come across Customizing a golden 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 volition decrypt the preloaded content and the user tin play the game.

Switching a game to preload mode is recommended in these cases:

• Shipping retail discs with product keys earlier the game is actually available (0-day piracy).
  
• Games that run a pre-purchase and are larger than 20GBs in size.

Delight 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 Downloadable Content (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:

• Cheque the email associated with the business relationship you are trying to log on with and look for an email from Steam Support. Copy the code from that email.
  
• Run the following steamcmd: set_steam_guard_code <code>
  
• Re-Attempt login from steamcmd: Steam>login <buildaccount> <password>

General Troubleshooting for Download Bug

• Restart calculator, modem, router, etc.
  
• Verify firewall settings. The new system requires port 80 (HTTP) and all other Steam ports, listed hither.
  
• Temporarily disable local Anti-Virus or Spam-Blocker programs.
  
• Bank check the Steam download region nether Settings->Downloads. It should lucifer your location.
  
• Stop the download, uninstall, and reinstall the game (articulate manifest caches).
  
• Exit Steam, delete the two folders appcache and depotcache in your Steam install binder.
  
• Endeavour to set your Steam download region to some other location far abroad. This might work if a content server well-nigh y'all is serving bad data.

My Mac and/or Linux Builds aren't installing any files. Why?

If you're testing via Steam the installation of your game or awarding across multiple platforms, you may come across a situation where the build deploys on Windows but doesn't deploy any files on Mac or Linux despite your SteamPipe procedure being setup to upload Mac and/or Linux depots. In that location is a step that is easily missed which involves calculation your alternate Depots to the Parcel being deployed. You can check what depots are included in a package via the post-obit steps:

1. Navigate to your App Admin page
   
2. From the View Associated Items department, click All Associated Packages, DLC, Demos and Tools.
   
3. Click on the title of the Parcel you're attempting to download
   
4. Review the Depots Included section
   
5. Use the Add/Remove Depots to ensure the correct set of Depots are assigned to the Packet

There are a number of discussion threads well-nigh this that may likewise assist:

• Empty folder after installing the game
  
• Unity Builds for PC/Mac/Linux
  
• Preparing Content for Mac Packaging

Running steamcmd.exe results in the post-obit error: "SteamUpdater: Mistake: Steam needs to be online to update. Please confirm your network connectedness and try again."

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

Running the app build results in the following error: "ERROR! Failed 'DepotBuild for scriptname.vdf' - condition = vi."

Possible Causes:

• Business relationship does not have permissions for the app.
  
  • Check that the app ID is correct in the app_build.vdf.
    
  • Cheque that the build business relationship has proper permissions to the app ID.
    
• Steamcmd cannot find the depot contents.
  
  • Check that the "contentroot" value in the app_build script is a valid path relative to the location of the script file.
    
  • Check that the "LocalPath" value in the depot_build script is a valid path relative to the path in the app_build script. Bank check that the path contains actual content.
    

Running the app build results in the following error: "Mistake! Failed to become application info for app NNNNN (check login and subscription)"

This ways that Steam can't recall data about the app, either because it doesn't exist or the user doesn't have access to the app.

• Check that the NNNNN is the app ID you were assigned for the app.
  
• Check that the app ID is right in the app_build.vdf.
  
• If it is a new app ID, bank check that the Steamworks app admin configuration has been published. New apps should take a Steam Pipe install directory on the config tab, a depot on the depot tab, and all changes published on the publish tab.
  
• If all of that looks right, make sure that your account owns the app ID.

"An error occurred while installing [AppName] (Invalid content configuration)" at launch time

Possible Causes:

• No build has been gear up live on the branch y'all're trying to install from.
  Resolution: Set your build live on a co-operative by going to https://partner.steamgames.com/apps/builds/<YourGameAppId>, and select that co-operative in the Steam client (as described here).
  
• Invalid game launch options.
  Resolution: Verify the launch options on the Installation tab in the app admin for your game https://partner.steamgames.com/apps/config/<YourGameAppId>.
  
• You don't own the Depot IDs that make upwardly the game.
  Resolution: Make sure the necessary depots are added to the development subscription (Meet Editing packages for additional details).

"Error lawmaking 15" at launch time

This is the CEG servers rejecting the asking to CEG the exe. Bank check the release state on the game page. If it is non 'playable', you volition 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

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 certain that it's propped.

I can't remember what that steamcmd command was or how it worked

Employ the 'find' command in steamcmd to search for any steamcmd command. It will do fractional matching on the command name and it will list out the command syntax.

Steam>discover build_installer ConVars: Commands: build_installer : <project file> <target folder> <beta primal> <beta pwd>

ivesshensted.blogspot.com

Source: https://partner.steamgames.com/doc/sdk/uploading

Bagikan Artikel ini