Confira abaixo um guia para usar o SteamPipe, a ferramenta da Valve para envio de conteúdo ao Steam. Para conhecer as práticas recomendadas ao atualizar o jogo, consulte Atualizações do jogo — Práticas recomendadas.

Introdução ao sistema de conteúdo SteamPipe

O SteamPipe é o sistema de conteúdo de jogo/aplicativo por trás do Steam. O SteamPipe inclui os seguintes recursos:

• Entrega de conteúdo rápida e eficiente.
  
• Ramos "beta" públicos e privados, permitindo testes de várias versões em paralelo.
  
• Gerenciamento de versões simples na web — envie uma nova versão ou reverta para uma versão anterior em poucos cliques.
  
• Visualização do tamanho de atualização de uma versão antes de colocá-la no ar.
  
• Compartilhamento de conteúdo entre vários aplicativos.
  
• Criação de discos de instalação a partir de conteúdo público ou beta.
  
• Jogos e aplicativos continuam disponíveis off-line mesmo se a internet cair no meio de uma atualização.
  
• Conteúdo sempre criptografado, e versões não ativas não podem ser vistas por usuários.
  
• Um Servidor de conteúdo local SteamPipe que pode ser usado durante o desenvolvimento.

Estrutura de conteúdo do jogo — Práticas recomendadas

O SteamPipe foi projetado tanto para um download inicial eficiente quanto para a aplicação eficiente de atualizações. De forma geral, ele funciona bem com uma grande variedade de estruturas de conteúdo. Contudo, há alguns pontos importantes para se ter em mente em termos de otimização e para evitar situações que podem causar ineficiência.

Aviso: caso o seu jogo use a Unreal Engine, consulte as observações específicas para os arquivos de pacote no final desta seção.

O SteamPipe começa dividindo cada arquivo em pedaços de aproximadamente 1 megabyte (MB) cada. Depois, cada pedaço é comprimido e criptografado antes de ser enviado para o sistema de entrega de conteúdo do Steam. Eles permanecem comprimidos e criptografados até que sejam baixados por cada cliente. Só então eles são descriptografados, expandidos e colocados nos locais necessários.

Quando o SteamPipe processa uma atualização de um jogo existente, ele verifica se há pedaços idênticos aos da versão anterior do jogo. O resultado ideal disso é que apenas as partes novas ou modificadas de qualquer arquivo viram pedaços "novos", e esses pedaços novos são os únicos que um cliente precisa baixar para atualizar o jogo.

Muitas engines de jogos usam arquivos de "pacote" para agrupar os recursos do jogo e aprimorar o tempo de carregamento deles por meio de um acesso a disco mais eficiente. Em geral, essa estratégia funciona bem com o SteamPipe. Contudo, alguns sistemas de arquivos de pacote usam ou facilitam implementações que podem causar problemas. O efeito desses problemas é quase sempre atualizações muito maiores que o necessário. Eles também podem permitir um download rápido, mas uma atualização lenta por exigirem muito processamento no disco local.

Caso o seu jogo use arquivos de pacote, seguem algumas recomendações:

• Garanta que as alterações de recursos sejam localizadas o máximo possível no arquivo de pacote.
  
• Evite embaralhar a ordenação de recursos em um arquivo de pacote.
  
• Limite o tamanho de um arquivo de pacote.
  
• group assets by level / realm / feature into their own pack files, and consider adding new pack files for updates instead of modifying existing ones
  
• Não inclua nomes originais de arquivos ou o horário de criação/geração de cada arquivo nos recursos.

O primeiro ponto acima refere-se ao escopo de bytes alterados em um arquivo quando um único recurso é modificado. O ideal é que os dados do recurso sejam modificados e/ou aumentem ou reduzam de tamanho na mesma posição do arquivo de pacote. Dessa forma, o SteamPipe criará pedaços novos apenas para as partes do arquivo que contenham os dados do recurso. Contudo, todos os arquivos de pacote também precisam de algum tipo de sumário (Table of Contents) para que a engine localize os dados dos recursos. A estrutura desse sumário pode ter um grande impacto na eficiência de atualizações do SteamPipe. Idealmente, há um sumário ou árvore de sumários próximo ao início ou fim do arquivo. Como outros recursos podem mudar de posição no arquivo, as suas entradas no sumário também serão alteradas. Nessa situação, o SteamPipe criará pedaços novos para os dados modificados do recurso, bem como as partes modificadas do sumário.

Contudo, observamos que algumas engines de jogos distribuem os dados do sumário pelo arquivo. Ou pior ainda: a indexação dos arquivos no sumário é feita pela posição (ou deslocamento) absoluta em bytes de cada recurso. Portanto, se um recurso que começa no byte 3.450 aumenta de tamanho em 8 bytes, as posições de todos os recursos que vêm depois dele no arquivo também mudam. Apesar de cada valor de indexação ocupar apenas 4 ou 8 bytes, uma alteração para um número de 8 bytes resultará na criação de um novo pedaço de 1 MB pelo SteamPipe. Isso pode ter resultados catastróficos, pois, mesmo ao alterar alguns recursos pequenos em um arquivo de pacote, os clientes precisarão baixar mais da metade do arquivo todo para atualizar o jogo. Caso saiba ou suspeite que a estrutura dos seus arquivos de pacote cause esse problema, entre em contato com o seu representante da Valve o mais breve possível. Temos um algoritmo alternativo de geração de versão que pode ajudar a aliviar esse problema, apesar de algumas contrapartidas.

Além disso, o SteamPipe não sabe as posições de cada recurso em um arquivo de pacote. Ao embaralhar a ordem de recursos de tamanho inferior a 1 MB, é provável que ele não detectará a reordenação, já que os pedaços de 1 MB antigos não estarão mais presentes no arquivo. Assim, caso esteja preparando uma atualização e deseje otimizar os tempos de carregamento ao reordenar os recursos no arquivo de pacote, esteja ciente de que ela poderá ter um download grande. Recomendamos fazê-lo apenas se o aumento de desempenho for significativo.

Próximo ponto: ao atualizar um arquivo de pacote no dispositivo do cliente, o SteamPipe primeiro "monta" a nova versão sem mexer na versão antiga. Apenas após montar os novos arquivos é que a atualização é de fato "aplicada", excluindo os arquivos antigos e movendo os novos para a pasta de instalação do jogo. Isso significa que, para atualizar um arquivo de pacote de 25 GB, o SteamPipe sempre montará um arquivo de 25 GB separado. Caso a atualização tenha alterado apenas 10 bytes do arquivo, o SteamPipe precisará copiar praticamente todos os 25 GB do arquivo antigo para o novo. Dependendo do tipo de armazenamento usado pelo cliente, esse procedimento pode demorar. Assim, recomendamos duas coisas:

Primeiro: limite o tamanho dos arquivos de pacote. 1 ou 2 gigabytes (GB) é mais que o suficiente para oferecer leituras eficientes dos dados em disco ao carregar o jogo.

Segundo: limite o escopo dos recursos em cada arquivo de pacote, como um arquivo por nível ou recurso destravável. Dessa forma, as atualizações focadas em partes específicas do seu jogo não fazem com que os dados de outras partes sejam copiadas na máquina do cliente. Além disso, ao adicionar novos recursos, níveis etc., o ideal é colocá-los em arquivos de pacote novos. Os clientes que baixarem essa atualização precisarão apenas baixar os arquivos novos, evitando os problemas com arquivos de pacote modificados que mencionamos acima.

Em caso de dúvida, use uma ferramenta local de comparação (diff) binária, como Beyond Compare, para comparar as versões dos arquivos de pacote. Verifique se as diferenças exibidas são do tamanho esperado para os recursos alterados e que não há dezenas (ou mesmo centenas) de pequenas alterações espalhadas pelo arquivo. Caso veja algo inesperado, verifque as configurações da sua ferramenta de criação de arquivos de pacote.

Compressão: como o Steam comprimirá todos os dados para envio, armazenamento e download, não recomendamos o uso de algoritmos de compressão que não sejam voltados a formatos específicos nos arquivos de pacote. Contudo, caso o tamanho do jogo em disco seja uma preocupação, você ainda pode usar a compressão em arquivos de pacote. Ela funcionará com o SteamPipe, contanto que os critérios listados acima sejam seguidos. Especificamente, garanta que a compressão seja a nível de recurso na medida do possível. Qualquer compressão que cruze os "limites" dos recursos resultará em alterações dispersas e exigirá que os clientes baixem mais dados que o necessário.

Criptografia: assim como a compressão, provavelmente é desnecessária e sofre dos mesmos riscos citados acima.

Ao seguir essas diretrizes, você minimizará o tamanho das atualizações, e apenas conteúdos novos precisarão ser baixados. Os usuários ficarão gratos e você poderá melhorar a qualidade do produto ao lançar mais atualizações.

Caso você suspeite que o empacotamento do jogo não está interagindo bem com o processo de atualização do SteamPipe, entre em contato com o seu representante da Valve para que possamos ativar recursos avançados para você.

Unreal Engine — Observações especiais

Algumas das versões da Unreal Engine usam "alinhamento por preenchimento" (padding alignment) nos recursos em arquivos de pacote, o que pode ter um grande impacto no tamanho de atualizações do SteamPipe. Esse alinhamento pode resultar no deslocamento em cascata de recursos ao gerar novas versões, especialmente ao ativar a compressão dos arquivos de pacote. Using a padding alignment of 1MB (1048576) will help ensure that re-alignments will shift assets by a multiple of the same blocksize that SteamPipe uses for delta calculations.

As an example, to change or specify your padding alignment when "cooking" your game pack files, you will need to change one line inside the file UnrealEngine/Engine/Source/Programs/AutomationTool/Win/WinPlatform.Automation.cs. That file contains a function GetPlatformPakCommandLine -- inside that function, change this line:


to this:


With this change, you should be able to enable pack file compression and still get optimized SteamPipe update behavior.

Unreal Engine is Epic’s trademark or registered trademark in the US and elsewhere.

Steamworks Video Tutorial - Building Your Game in 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

Videotutorial do Steamworks — Adição de novas plataformas e idiomas

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

Detalhes técnicos do 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 Servidor de conteúdo local SteamPipe not necessary since they can efficiently patch builds on private branches.

Conta Steam para geração de versões

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 Gerenciamento da conta do Steamworks 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. Find the app ID for your application (this can be found by selecting the application on your homepage in Steamworks)
   
2. Acesse a página de configurações gerais de instalação do aplicativo.
   
3. Defina pelo menos uma opção de inicialização (o diretório e, opcionalmente, os argumentos necessários para iniciar o jogo). Passe o mouse sobre o (?) para obter mais informações sobre cada campo.
   
   
   O exemplo abaixo mostra 5 opções de inicialização, 2 para Windows, 2 para macOS e 1 para Linux.
   
   A opção de inicialização 3 será exibida no Windows apenas caso o usuário também possua o conteúdo adicional especificado.
   
   
   
   
4. Acesse a página de depots e adicione depots conforme necessários para o aplicativo. Um depot padrão já pode ter sido configurado para o aplicativo:
   
   1. Clique no depot padrão e altere o nome para um adequado e reconhecível (como "Conteúdo base" ou "Conteúdo para Windows").
      
   2. Deixe o idioma como [Todos os idiomas] a não ser que seja um depot específico para um idioma.
      
   3. Deixe o SO como [Todos os SOs] a não ser que seja um depot específico para um SO (se o aplicativo for "tudo em um" ou exclusivo para um SO, deixe como [Todos os SOs]). Altere o valor apenas para depots do jogo específicos para um SO.
      
   4. Clique em Adicionar novo depot para criar depots adicionais.
      
   5. Clique em Salvar alterações para salvar quaisquer alterações realizadas.
      
5. Uma vez definidos, publique as alterações a partir da página de publicação.
   
6. Os depots recém-criados deverão ser incluídos em um pacote para que tenha acesso aos mesmos. Cada jogo no Steam terá um pacote complementar de desenvolvimento, que é concedido automaticamente às contas listadas no grupo da distribuidora.
   Adicione os novos depots ao pacote (e/ou outros pacotes que adequados aos depots) pela página Pacotes e conteúdos adicionais associados.

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 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 - This directory initially contains just 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 will be the location for build logs, chunk cache, and intermediate output. NOTE: This folder can be deleted or emptied at any time, but after it's deleted, the next upload time will take longer.
  
• scripts - This directory is where you'll place all of your build scripts for building your game depots.

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 Servidor de conteúdo local SteamPipe if you choose to do so.

SteamCmd no macOS

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

1. From the terminal, browse to the tools\ContentBuilder\builder_osx
   
2. Execute "chmod +x steamcmd".
   
3. Type bash ./steamcmd.sh
   
4. SteamCmd will then run and update to the latest build, leaving you in the SteamCmd prompt
   
5. Type exit and press return to exit the prompt

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.

Creating SteamPipe Build Config Files

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.

Ferramenta gráfica do 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 :


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 :

The following steps occur during a SteamPipe build:

1. steamcmd.exe will update itself to the latest version.
   
2. steamcmd.exe is logging into the Steam backend using the given builder Steam account.
   
3. O início da geração de versão é registrado junto ao MDS (Master Depot Server, ou Servidor Mestre de Depots), o que garantirá que o usuário tem as permissões corretas para modificar o aplicativo.
   
4. Para cada depot incluso na versão do aplicativo, uma lista de arquivos é gerada com base nos arquivos na pasta de conteúdo e nas regras de filtragem definidas no arquivo de script de geração de versão do depot.
   
5. Cada arquivo é lido e dividido em pedaços de 1 MB cada. Se o depot já tiver sido criado, esse particionamento preservará o máximo de pedaços inalterados possível.
   
6. Novos pedaços são comprimidos, criptografados e enviados ao MDS.
   
7. Um manifesto final é gerado para a versão do depot; cada manifesto é identificado por um ID de 64 bits.
   
8. Uma vez processados, o MDS finaliza a geração da versão do aplicativo e a associa a um ID de versão global.
   
9. Quando a geração da versão for concluída, haverá arquivos *.csm e *.csd na pasta de saída. Esses arquivos são temporários e podem ser excluídos, mas agilizam a geração de versões futuras.

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 within 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. Assim, a carga de E/S do disco é dividida pela metade, deixando que o disco da raiz de conteúdo cuide das requisições de leitura e o disco de saída cuide das requisições de escrita.
  
• 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 — Caminho até a pasta htdocs do seu Servidor de conteúdo local SteamPipe (SCL). Versões para o SCL armazenam o conteúdo apenas no seu servidor HTTP e permitem o teste da instalação do jogo pelo cliente Steam.
  
• SetLive - Beta branch name to automatically set live after successful build, none if empty. Esteja ciente de que não é permitido por uma versão no ar no ramo "default" automaticamente. Isto deve ser feito pelo painel de administração do aplicativo.
  
• Depots — Esta seção contém todos os mapeamentos, filtros e propriedades de arquivos de cada depot ou uma referência a um arquivo de script separado para cada depot.

Example app build script "app_build_1000.vdf" is using all options:

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 — O ID do depot desta seção.
  
• ContentRoot — Permite substituir a pasta raiz de conteúdo (ContentRoot) do script de construção do aplicativo para o depot específico.
  
• FileMapping — Mapeia um arquivo ou conjunto de arquivos da raiz de conteúdo local para o depot. Pode haver mais de um mapeamento que adiciona arquivos ao depot. O parâmetro LocalPath é um caminho relativo à pasta raiz de conteúdo e pode conter coringas, como "?" ou "*". O mapeamento também será aplicado a arquivos correspondentes em subpastas se a opção Recursive estiver ativada. O parâmetro DepotPath especifica onde, no depot, os arquivos selecionados devem aparecer (use "." para não usar um mapeamento especial).
  
• FileExclusion — Exclui arquivos mapeados. Também pode conter coringas, como "?" ou "*".
  
• InstallScript - will mark a file as install scripts and will sign the file during the build process. O cliente Steam o executará ao iniciar qualquer aplicativo que contém este depot.
  
• FileProperties — Marca um arquivo com indicadores especiais:
  
  • userconfig — Este arquivo é modificado pelo usuário ou pelo jogo. Não deve ser sobrescrito por uma atualização, nem será substituído durante a verificação de arquivos se for diferente da versão anterior.
    
  • versionedconfig — Similar ao userconfig, mas se o arquivo for atualizado no depot, este sobrescreverá o arquivo local quando o jogo do usuário for atualizado. Só atualize o arquivo no depot quando houver uma alteração necessária no formato ou uma correção a ser feita.

Example depot build script depot_build_1002.vdf showing use of all options:

NOTE: 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.

Using SteamPipe In A CI/CD Environment

To setup steamcmd for continuous integration, or just on a machine or VM that will get re-imaged frequently, you'll need to include the config file that contains your login token. Follow these steps so that your initial login token is properly saved:

1. Run "steamcmd.exe +login <username> on the machine that will be preforming the build"
   
2. Enter your password, and the SteamGuard token
   
3. Type "info", and you should see your account listed as connected
   
4. Type "quit"
   
5. For each future run, do not enter a password. Simply run "steamcmd.exe +login <username>"
   
6. Be sure that the config file stored in <Steam>\config\config.vdf is saved and preserved between runs, as this file may be updated after a successful login

NOTE: If you do login again and provide your password, a new SteamGuard token will be issued and required to login.

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 Testes no 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]" — Exibe o estado atual do aplicativo no cliente.
  
• "app_info_print [appid]" — Exibe a configuração atual do Steamworks para o jogo (depots, opções de inicialização etc.).
  
• "app_config_print [appid]" — Exibe a configuração do usuário atual para o jogo (idioma atual, diretório de instalação etc.).
  
• file "logs\content_log.txt" — Lista todas as operações e erros do SteamPipe salvas em relatório.
  
• file "steamapps\appmanifest_[appid].acf" — Exibe o estado atual de instalação do aplicativo (arquivo no formato KeyValues da Valve).

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":
Some tips to keep in mind:

• Crie uma nova pasta para armazenar as imagens do disco, como "D:\discos_varejo". Apenas depots nas seções included_depots são adicionados; não há mais seção de exclusão.
  
• Use o Steam.exe (com os parâmetros de linha de comando-dev e -console) ou steamcmd.exe para gerar imagens de instalação. Em ambos os casos, use o comando "build_installer".
  
• Inicie a sessão com uma conta que possui o jogo e todos os depots que deseja adicionar ao disco. A conta não precisa de permissões especiais, então qualquer um pode gerar discos.
  
• If you use Steam.exe, stop all other downloads.
  
• Go to the console page and run the build_installer command:
  
  build_installer sku_goldmaster.txt "D:\retail_disks"
  The build can take a while since all depots are re-downloaded the first time.
  
• If you're building a GM using a local content server, run:
  @localcontentserver "webserver"
build_installer sku_goldmaster.txt "D:\retail_disks" local
  The spew refers to 'Backup' since 'Retail install Disk' and local game backups are basically the same.
  
• Once you see "Backup finished for AppID...", the install disk images are ready. You 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 not bigger than 640 MB, as specified with "disk_size_mb". Each disk folder 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). Copy the SDK GM setup files (setup.exe, setup.ini, etc.) into the folder of your first disk and the retail disc installer is complete.
  
• When creating a GM for macOS be sure to open the goldmaster/disk_assets/SteamRetailInstaller.dmg image on a Mac. Then take the app that is in there and copy it to the root of your media. You will probably want to change the name of the install app, brand the icon and decorate the window to only show the installer.
  
• When creating a multi-disc GM for macOS, be sure the volume name for each disc matches. O nome do volume faz parte do caminho de montagem; se os nomes não forem iguais, o instalador não encontrará o próximo disco.

(Opcional) Criação de um instalador a partir de um ramo beta

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:

Instalação de conteúdo adicional a partir de um instalador de disco

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

Criação de um instalador para mais de um AppID em um mesmo disco/pacote de instalação

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.

Personalização de um disco de instalação

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:

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

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 Conteúdo adicional (DLC) documentation for more information.

Troubleshooting SteamPipe

"Login Failure: Account Login Denied Failed" ("Erro ao iniciar a sessão: acesso negado à conta) ao iniciar a sessão pelo SteamCmd

Cause: Probably SteamGuard is preventing login. Resolution:

• Check the email associated with the account 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>

Solução geral de problemas com downloads

• Restart computer, modem, router, etc.
  
• Verify firewall settings. The new system requires port 80 (HTTP) and all other Steam ports, listed here.
  
• Temporarily disable local Anti-Virus or Spam-Blocker programs.
  
• Check the Steam download region under Settings->Downloads. It should match your location.
  
• Stop the download, uninstall, and reinstall the game (clear manifest caches).
  
• Exit Steam, delete the two folders appcache and depotcache in your Steam install folder.
  
• Try to set your Steam download region to some other location far away. This might work if a content server near you is serving bad data.

As minhas versões para macOS e/ou Linux não estão instalando arquivo algum. Por quê?

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. Navigate to your App Admin page
   
2. From the View Associated Items section, click All Associated Packages, DLC, Demos and Tools.
   
3. Click on the title of the Package 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 Package

There are a number of discussion threads about this that may also assist:

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

Executar steamcmd.exe resulta no erro a seguir: "SteamUpdater: Erro: O Steam precisa estar on-line para atualizar. Certifique-se de que está conectado à internet e tente novamente."

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

Executar o gerador de versão de aplicativo resulta no erro a seguir: "ERROR! Failed 'DepotBuild for scriptname.vdf' - status = 6." (Erro! Falha com 'DepotBuild for scriptname.vdf' — estado = 6.)

Possible Causes:

• Conta sem permissões para o aplicativo:
  
  • Confirme que o AppID está correto no arquivo app_build.vdf.
    
  • Check that the build account 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. Check that the path contains actual content.
    

Executar o gerador de versão de aplicativo resulta no erro a seguir: "ERROR! Failed to get application info for app NNNNN (check login and subscription)"

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.

• Confirme que NNNNN é o AppID associado ao aplicativo.
  
• Confirme que o AppID está correto no arquivo app_build.vdf.
  
• Se for um AppID novo, confirme que as configurações da página de administração de aplicativo no Steamworks foram publicadas. New apps should have a Steam Pipe install directory as well as a depot, both can be found in Edit Steamwork Settings; the installation directory is in General Installation under the Installation tab, and Depots is under the SteamPipe tab. All changes published is done through the publish tab.
  
• If all of that looks right, make sure that your account owns the app ID.

"Ocorreu um erro durante a instalação de [nome do aplicativo] (configuração de aplicativo inválida)" ao iniciar o jogo

Possible Causes:

• No build has been set live on the branch you're trying to install from.
  Resolution: Set your build live on a branch by going to https://partner.steamgames.com/apps/builds/<YourGameAppId>, and select that branch in the Steam client (as described here).
  
• Opções de inicialização inválidas.
  Solução: verifique as opções de inicialização na aba "Instalação" da página de administração do aplicativo: https://partner.steamgames.com/apps/config/<AppIDdoJogo>.
  
• Você não possui os depots que compõem o jogo.
  Solução: confirme que os depots necessários foram adicionados à assinatura de desenvolvimento (consulte Edição de pacotes para mais detalhes).

Não me lembro do nome ou do funcionamento de um comando do steamcmd...

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.