Documentação do Steamworks
Enviando ao Steam
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.
AVISO: há alguns conceitos vitais para o SteamPipe. Antes de começar, consulte a documentação sobre Aplicativos para conhecê-los melhor. Ter um conhecimento básico de como essas peças se encaixam será útil na hora de enviar o seu produto ao Steam.

Videotutorial do Steamworks — Geração de versão do jogo no SteamPipe

O tutorial apresenta o SteamPipe e os passos para a construção de um aplicativo-modelo para o Steam usando ferramentas do Steamworks.
https://www.youtube.com/watch?v=SoNH-v6aU9Q

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

O tutorial explica como adicionar novas plataformas e idiomas ao seu jogo por meio da criação de depots ao aplicativo. (Em inglês)
https://www.youtube.com/watch?v=PShS32hcing

Detalhes técnicos do SteamPipe

O SteamPipe usa o protocolo HTTP para entrega de conteúdo. Já que os downloads são nada mais que tráfego web, qualquer cache HTTP externo entre servidores de usuários e do Steam aumentará a velocidade do download. Conteúdos podem ser hospedados por provedores externos de redes de entrega de conteúdo (CDNs), que podem ser facilmente adicionados à nossa rede de conteúdo. A maior parte dos firewalls voltados a usuários finais permite tráfego HTTP e não bloqueia downloads.

O SteamPipe tem um eficiente algoritmo de atualização com base em diferenças binárias (deltas), alterando apenas as partes modificadas de arquivos de conteúdo existentes. Quando o conteúdo é atualizado, apenas essas diferenças precisam ser enviadas. Ou seja, as transferências tanto do desenvolvedor quanto do usuário são menores e mais rápidas. A maioria dos parceiros acha desnecessário usar um Servidor de conteúdo local SteamPipe, já que podem atualizar versões de forma eficiente em ramos privados.

Conta Steam para geração de versões

Antes de criar versões no Steam, você deve ter uma conta Steam na sua conta Steamworks com as permissões "Editar metadados do aplicativo" e "Publicar alterações do aplicativo no Steam". Por motivos de segurança, recomendamos que você tenha uma conta dedicada de geração de versões com apenas essas permissões. Por isso, você pode criar uma nova conta Steam em https://store.steampowered.com/join.

Qualquer administrador da sua conta Steam pode adicionar uma conta Steam e conceder as permissões necessárias. Mais informações sobre esse processo estão disponíveis na documentação Gerenciamento da conta do Steamworks. Confira abaixo um exemplo de uma conta desse tipo:

create_build_account.png

Configuração inicial para novos aplicativos SteamPipe

Siga os passos abaixo para configurar novos aplicativos SteamPipe:
  1. Ache o ID do seu aplicativo (para tal, selecione o aplicativo na página inicial do 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.


    updatedlaunchoptions_3.png
  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.
Aviso: se o executável estiver em uma subpasta da pasta principal de instalação, adicione o nome da subpasta no campo "Executável". Não adicione barras ou pontos no início.
Aviso sobre plataformas: como indicado acima, aplicativos para macOS podem ser inicializados ao especificar um pacote de aplicativo (Jogo.app) ou um script/binário (Jogo.app/Contents/MacOS/Jogo). In general the app bundle format should be preferred if possible as it allows macOS to more correctly determine launch parameters in the manner it would if launched manually outside of Steam.

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

Configuração do SDK para envios pelo SteamPipe

Baixe e extraia a versão mais recente do SDK do Steamworks na máquina que você usará para fazer os envios das versões.

As ferramentas do SteamPipe podem ser encontradas dentro do SDK na pasta tools, que contém dois subdiretórios relevantes.

O conteúdo do jogo e as ferramentas da versão do SteamPipe deverão ficar no diretório ContentBuilder, que contém os seguintes subdiretórios:
  • builder — Inicialmente, contém apenas o steamcmd.exe, que é a versão em linha de comando do Steam.
  • builder_linux — A versão do steamcmd para Linux.
  • builder_osx — A versão do steamcmd para macOS.
  • content — Contém todos os arquivos do jogo que serão colocados em depots.
  • output — Será o local com os relatórios, cache de pedaços e saída intermediária. AVISO: esta pasta pode ser esvaziada se preferir, mas o envio subsequente será mais longo.
  • scripts — Onde os scripts de construção de depots devem ficar.
steampipebuilddir.png

Recomendamos que você execute steamcmd.exe diretamente na pasta "builder" da plataforma uma vez para inicializar o sistema de geração de versão. Isso deve popular o diretório de geração de versão com todos os arquivos necessários para construir depots.

O diretório ContentServer contém as ferramentas para executar o seu próprio Servidor de conteúdo local SteamPipe caso deseje.

SteamCmd no macOS

Para ativar o SteamCmd no macOS, siga os passos abaixo:
  1. No terminal, navegue à pasta tools/ContentBuilder/builder_osx.
  2. Execute "chmod +x steamcmd".
  3. Abra a pasta-pai (tools\ContentBuilder\builder_osx).
  4. Digite "bash ./steamcmd.sh".
  5. O SteamCmd será executado e atualizado para a última versão; o prompt do SteamCmd será exibido.
  6. Digite "exit" e pressione "Return" para fechar o prompt.
Você pode seguir o resto da documentação (substituindo caminhos conforme apropriado) para criar arquivos de depot e de configuração de aplicativos para enviar o seu conteúdo ao Steam.

Criação de arquivos de configuração de versão no SteamPipe

Para enviar arquivos para o seu aplicativo com o SteamPipe, é preciso criar scripts que descrevam a sua versão e cada depot incluso. Os exemplos de script aqui mostrados estão contidos na pasta Tools\ContentBuilder\scripts do SDK do Steamworks.

Ferramenta gráfica do SteamPipe

Caso você esteja executando em Windows e prefira que uma ferramenta gráfica lhe ajude a criar esses arquivos e a enviar as suas versões, é possível usar o SteamPipeGUI, disponível na pasta "tools" do SDK do Steamworks. Estão disponíveis no arquivo zip instruções adicionais para você dar os primeiros passos.

Se escolher usar a ferramenta gráfica, recomendamos que você leia as seções a seguir para se familiarizar com o funcionamento do SteamPipe.

Script de construção de exemplo


Confira abaixo o script de construção mais básico de todos. No exemplo, é possível ver um jogo (AppID 1000) com um depot (DepotID 1001). A ideia é enviar todos os arquivos a partir da pasta de conteúdo e das suas subpastas. Para tal, basta um script de geração de versão simples. Confira o arquivo "simple_app_build.vdf", que acompanha o SDK:

"AppBuild" { "AppID" "1000" // AppID do jogo "Desc" "Script simples de construção" // descrição interna da versão "ContentRoot" "..\conteudo\" // pasta-raiz de conteúdo, caminho relativo à localização deste arquivo "BuildOutput" "..\saida\" // pasta de saída, que armazena relatórios (logs) e arquivos de cache "Depots" { "1001" // DepotID associado ao aplicativo { "FileMapping" { "LocalPath" "*" // todos os arquivos da pasta-raiz de conteúdo "DepotPath" "." // mapeado à raiz do depot "recursive" "1" // incluir todas as subpastas } } } }

Ajuste o AppID e o DepotID do jogo conforme necessário. Para dar início à geração da versão, é preciso executar o SteamCmd passando alguns parâmetros:
tools\ContentBuilder\builder\steamcmd.exe +login <nome-de-usuario> <senha> +run_app_build ..\scripts\simple_app_build.vdf +quit

AVISO: a sua primeira tentativa de execução da versão pode falhar devido ao Steam Guard. Caso o início da sessão falhe devido ao Steam Guard, confira se você recebeu por e-mail um código do Steam Guard e execute o SteamCmd como steamcmd.exe "set_steam_guard_code<código-do-Steam-Guard>" e tente novamente. Após iniciar a sessão com o Steam Guard uma vez, um arquivo-sentinela é usado para verificar que a conta é verdadeira.

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. O arquivo-sentinela fica armazenado em <Steam>\ssfn<número-hash>, e o arquivo de configuração, em <Steam>\config\config.vdf.

Os passos abaixo ocorrem durante uma geração de versão do SteamPipe:
  1. O Steamcmd.exe se atualizará por conta própria para a versão mais recente.
  2. O Steamcmd.exe inicia a sessão no backend do Steam com a conta Steam informada.
  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.


Quando a geração da versão estiver concluída, é possível vê-la na página de versões do aplicativo. Neste caso, seria 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.

Scripts de construção avançados


Se o seu aplicativo tiver muitos depots com regras de mapeamento de arquivos complexas, é possível criar um script de geração de versão para cada depot referenciado por um script de geração de versão do aplicativo. O primeiro passo é conferir os parâmetros disponíveis no script de versão do aplicativo:

  • AppID — O AppID do jogo. A conta Steam responsável pelo envio precisa da permissão "Editar metadados do aplicativo".
  • Desc — A descrição, visível apenas por você na seção "Suas versões" do painel de administração do aplicativo. Ela pode ser alterada pela mesma página após o envio de uma versão.
  • ContentRoot — A pasta raiz dos arquivos do jogo. Pode ser um caminho absoluto ou relativo ao arquivo de script de construção.
  • BuildOutput — Diretório que conterá os relatórios de construção, manifestos de depots, caches de pedaços e arquivos intermediários de saída. Para um melhor desempenho, use um disco separado para a saída. 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 — Este tipo de construção apenas salva o registro da saída e os manifestos dos arquivos na pasta de saída da construção. A construção de versões preview é uma boa forma de experimentar com scripts de envio e garantir que os mapeamentos, filtros e propriedades estão corretos.
  • 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 — Nome do ramo beta no qual a versão será posta no ar automaticamente após uma construção bem-sucedida. Deixe vazio para não por no ar em nenhum ramo automaticamente. 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.

O script de versão do aplicativo "app_build_1000.vdf" está usando todas as opções:
"AppBuild" { "AppID" "1000" // AppID do jogo "Desc" "Descrição da versão" // descrição interna da versão "Preview" "1" // fazer uma construção de versão preview, sem enviar nada aos servidores "Local" "..\..\ServidorConteudo\htdocs" // armazenar conteúdo no servidor de conteúdo local em vez de enviá-lo ao Steam "SetLive" "TesteAlfa" // colocar versão no ar em um ramo beta "ContentRoot" "..\conteudo\" // pasta raiz de conteúdo, caminho relativo à localização deste arquivo "BuildOutput" "D:\saída_construcao\" // armazenar cache da construção e arquivos de relatório (log) em um drive diferente para um melhor desempenho "Depots" { // as instruções de mapeamento de arquivos para cada depot estão em arquivos de script separados "1001" "depot_build_1001.vdf" "1002" "depot_build_1002.vdf" } }

O script de geração da versão do aplicativo faz referência a dois arquivos que especificam todos os mapeamentos e propriedades de arquivos. 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 — Marca um arquivo como um script de instalação, assinando o arquivo durante o processo de construção. 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:
"DepotBuild" { "DepotID" "1002" "ContentRoot" "C:\conteudo\depot1002" // substitui o valor de ContentRoot do script de construção do aplicativo "FileMapping" { // todos os arquivos e pastas-fonte na pasta ".\bin" serão mapeados para a pasta ".\executaveis" do depot "LocalPath" "bin\*" "DepotPath" "executaveis\" "Recursive" "1" // incluir todas as subpastas } "FileMapping" { // sobrescreve arquivos de áudio da pasta \\audio com versões em português do Brasil "LocalPath" "localizacao\ptbr\audio\*" "DepotPath" "audio\" } "FileMapping" { // copiar script de instalação da versão PT-BR para a pasta raiz do depot "LocalPath" "localizacao\ptbr\ptbr_installscript.vdf" "DepotPath" "." } "FileExclusion" "bin\servidor.exe" // excluir este arquivo específico "FileExclusion" "*.pdb" // excluir todos os arquivos de extensão .PDB, não importa a pasta "FileExclusion" "bin\ferramentas*" // excluir todos os arquivos da pasta bin\ferramentas\ "InstallScript" "localizacao\ptbr\ptbr_installscript.vdf" "FileProperties" { "LocalPath" "bin\setup.cfg" "Attributes" "userconfig" // este arquivo será modificado em tempo de execução } }

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

Gerenciamento de atualizações

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.

Depuração de problemas ao gerar versões

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

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

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

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

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

Criação de discos de instalação

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" "Instalador de testes" "appid" "202930" "disk_size_mb" "640" "included_depots" { "1" "202931" "2" "202932" } }
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.
  • Se usar Steam.exe, interrompa todos os outros downloads.
  • Acesse a página do console e execute o comando build_installer:
    build_installer sku_goldmaster.txt "D:\discos_varejo"
    A geração pode demorar um pouco, porque todos os depots são baixados novamente na primeira execução.
  • Se estiver gerando um GM por meio de um servidor de conteúdo local, execute:
    @localcontentserver "webserver"
    build_installer sku_goldmaster.txt "D:\discos_varejo" local
    O texto exibido no console fará referência a "Backup" porque um disco de instalação e um backup são basicamente a mesma coisa.
  • Depois que a mensagem "Backup finished for AppID..." for exibida, as imagens de disco estarão prontas. Encontre mais detalhes sobre a geração no arquivo logs\backup_log.txt.
  • Haverá novas pastas (Disk_1, Disk_2, etc.) na pasta "D:\discos_varejo", cada uma com até 640 MB, como especificado na chave "disk_size_mb". Cada pasta contém um arquivo "sku.sis" e arquivos .csd e .csm para cada depot. Depots maiores podem usar mais de um disco. Todo o conteúdo do disco de instalação é criptografado (diferentemente de arquivos de backup local). Copie os arquivos do instalador do GM que vieram com o SDK (setup.exe, setup.ini, etc.) na pasta do primeiro disco e o instalador em disco estará completo.
  • Ao criar um GM para macOS, abra a imagem goldmaster/disk_assets/SteamRetailInstaller.dmg em um Mac. Depois arraste o .app contido para a raiz da sua mídia. Você provavelmente desejará alterar o nome do aplicativo de instalação, o ícone e decorar a janela para exibir apenas o instalador.
  • Ao criar um GM multidiscos para macOS, confirme que o nome do volume de todos os discos é igual. 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:
build_installer <arquivo do projeto> <pasta-alvo> <nome do beta> <senha do beta> steamcmd ex: build_installer sku_goldmaster.txt "D:\discos_varejo" baseline superSegredo script ex: steamcmd.exe +login nome_de_usuario senha +build_installer "..\Build\GameDataSku.txt" c:\destino chave_beta senha_beta +exit

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

Criação de um instalador para mais de um ID de aplicativo 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.

Chaves de descriptografia e pré-carregamento

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:
  • Distribuição de discos com códigos de produto antes do jogo ser lançado (evitando pirataria antes do lançamento).
  • Jogos na pré-venda que ultrapassem 20 GB.

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

Geração de versões de conteúdo adicional

DLC is built as a depot of the base game. See the Conteúdo adicional (DLC) documentation for more information.

Solução de problemas com o 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:
  • Verifique se há uma mensagem do Suporte Steam (Steam Support) no e-mail associado à conta. Copie o código contido na mensagem.
  • Execute o comando a seguir no steamcmd: set_steam_guard_code <codigo>.
  • Tente iniciar a sessão pelo steamcmd novamente: Steam>login <nome-de-usuário> <senha>.

Solução geral de problemas com downloads

  • Reinicie o computador, modem, roteador, etc.
  • Verifique as configurações do firewall. O novo sistema usa a porta 80 (HTTP) e todas as outras portas do Steam, listadas aqui.
  • Desative programas antivírus e bloqueadores de spam temporariamente.
  • Verifique a região de download do Steam em Configurações —> Downloads. Deve ser igual ao seu local.
  • Interrompa o download, desinstale e reinstale o jogo (para limpar os caches de manifesto).
  • Saia do Steam e exclua as pastas appcache e depotcache na sua pasta de instalação do Steam.
  • Tente configurar a região de download do Steam para um local mais longe. Pode funcionar se um servidor de conteúdo próximo estiver enviando dados corrompidos.

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. Acesse a página de administração do aplicativo.
  2. A partir da seção "Ver itens associados", clique em Ver pacotes associados, conteúdos adicionais, demonstrações e ferramentas.
  3. Clique no título do pacote que está tentando baixar.
  4. Revise a seção Depots incluídos.
  5. Use a opção Adicionar/Remover depots para confirmar que o conjunto certo de depots está associado ao pacote.
There are a number of discussion threads about this that may also assist:

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 ID do aplicativo está correto no arquivo app_build.vdf.
    • Confirme que a conta usada possui as permissões corretas para o ID do aplicativo.
  • O Steamcmd não encontra o conteúdo do depot:
    • Confirme que o valor da chave "contentroot" no script app_build é um caminho válido relativo ao local do arquivo do script.
    • Confirme que o valor da chave "LocalPath" no script depot_build é um caminho válido relativo ao local do arquivo do script app_build. Confirme que o diretório contém conteúdo.

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)" (ERRO! Falha ao recuperar dados de aplicação para ID NNNN (verifique credenciais e assinatura))

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 ID correto do aplicativo.
  • Confirme que o ID do aplicativo está correto no arquivo app_build.vdf.
  • Se for um ID de aplicativo novo, confirme que as configurações da página de administração de aplicativo no Steamworks foram publicadas. Aplicativos novos devem ter um diretório de instalação do SteamPipe na aba "Configuração", um depot na aba "Depots" e todas as alterações publicadas na aba "Publicar".
  • Se tudo estiver OK, confirme que a sua conta possui o aplicativo do ID informado.

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

Possible Causes:

"Código de erro 15" ao iniciar o jogo

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.

"Os servidores Steam estão muito ocupados para processar o seu pedido... Código de erro (2)" ao iniciar o jogo

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.

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.
Steam>find build_installer ConVars: Commands: build_installer : <project file> <target folder> <beta key> <beta pwd>