Documentação do Steamworks
Enviando ao Steam

Versão mais recente disponível em inglês

A versão em inglês desta página foi atualizada desde a publicação desta tradução.
Clique aqui para visualizar a versão em inglês.
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 ilimitados, 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 offline 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 cursor pelo (?) para saber mais sobre cada campo.

    O exemplo abaixo usa 4 opções de inicialização: 2 para Windows, 1 para macOS, 1 para Linux + SteamOS. 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.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.

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. Isto 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 +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" 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.

Caso esteja usando o SteamCmd a partir de uma máquina real ou virtual que é restaurada a partir de uma imagem frequentemente, você deve incluir o arquivo-sentinela e o arquivo de configuração na imagem para não precisar sempre informar o código Steam Guard toda vez. O arquivo-sentinela é hospedado em \ssfn, e o arquivo de configuração, em \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. Lá, é possível colocar a versão no ar a partir no ramo padrão ou em qualquer ramo beta, e os usuários poderão baixar a atualização poucos minutos depois.

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. As instruções a seguir estão disponíveis em um script de geração de versão de depot (e também caso a seção esteja inclusa diretamente no script da versão do aplicativo).

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

O script de geração de versão do depot depot_build_1002.vdf mostra o uso de todas as opções:
"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: você pode dar os nomes que quiser aos scripts, mas, por motivos de consistência, usamos app_build_ e depot_build_. Caso você saiba que irá gerar versões de aplicativos nesta máquina, pode ser uma boa ideia criar subdiretórios nos diretórios atuais dos scripts para cada aplicativo, auxiliando assim na organização dos scripts de geração de versão dos aplicativos.

Gerenciamento de atualizações

Depois que você lançar o aplicativo para os usuários, eles terão acesso à versão marcada como "default" (padrão). Aconselhamos que você sempre teste novas versões antes de colocá-las no ar e disponibilizá-las para os usuários. Para mais informações sobre como fazer isso com sucesso, consulte Testes no Steam.

Depuração de problemas ao gerar versões

Caso a sua versão não seja bem-sucedida, aconselhamos que você busque erros no diretório de saída, e não no console onde o script de geração de versão foi executado. A maioria das informações sobre erros pode ser encontrada em arquivos *.log.
Você pode usar esses comandos do cliente Steam e arquivos de cliente na depuração:
  • "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

O antigo sistema de conteúdo do Steam aplicava atualizações ao nível de arquivo, ou seja, se um byte em um arquivo fosse alterado, os usuários precisavam baixar o arquivo novo por completo. Essa solução era ineficiente para jogos que usavam pacotes, que são coleções de arquivos de conteúdo do jogo contidos em um arquivo grande. Arquivos de conteúdo podem passar de 1 GB, então atualizações costumavam significar downloads desnecessariamente grandes. Uma forma comum de evitar o download de arquivos grandes era adicionar novos arquivos de pacote que substituíam o conteúdo contido em arquivos de pacote anteriores. Essa solução resolvia o problema das atualizações grandes, mas prejudicava os usuários a longo prazo, já que eles acabavam baixando conteúdo já alterado e inutilizado.

O novo sistema de conteúdo soluciona esse problema dividindo cada arquivo em pedaços de 1 MB cada. Cada pedaço é comprimido e criptografado antes de ser distribuído pelo sistema de conteúdo do Steam. Se o conteúdo do jogo tiver grandes partes redundantes, os respectivos pedaços são reusados e o usuário só precisa baixar cada pedaço repetido uma vez. No entanto, a grande vantagem do sistema é criar atualizações eficientes. Quando o sistema estiver preparando uma atualização, o conteúdo novo é verificado em busca de pedaços já conhecidos. Caso eles sejam encontrados, ele os reusa. Isso significa que, caso você altere ou insira alguns bytes em um arquivo grande, o usuário precisa baixar apenas as alterações.

Essa é uma boa solução em geral, mas ainda há algumas armadilhas que precisam ser evitadas ao criar a estrutura do conteúdo do jogo. Talvez não seja uma boa ideia comprimir ou criptografar os dados do jogo. Isso já é feito para downloads em andamento e na geração de discos físicos para varejo pelo sistema de conteúdo do Steam. Caso você também faça isso, a eficácia das atualizações por diferenças pode ser reduzida. A compressão e a criptografia são aconselháveis apenas se cada recurso do arquivo de pacote for comprimido e/ou criptografado separadamente. Caso contrário, uma alteração em um recurso sempre fará necessário o download de vários outros recursos potencialmente inalterados.

Caso você empacote diversos recursos em único arquivo de pacote, garanta que, a cada reempacotamento, nenhuma alteração desnecessária seja feita. Uma prática problemática é incluir o nome completo dos arquivos originais no disco, pois eles podem mudar dependendo da máquina que os gerou. Outro padrão ruim é incluir os carimbos de data/hora da versão em cada arquivo. Se possível, sempre adicione novos conteúdos no final dos arquivos de pacote e mantenha a ordem dos arquivos existentes. Além disso, mantenha os metadados dos arquivos de pacote (posição e tamanho de cada recurso) no mesmo lugar e não os intercale com os dados dos recursos. Use uma ferramenta de diferenciação binária, como BeyondCompare, para verificar duas versões dos seus arquivos de pacote e garantir que centenas de alterações indesejadas não serão exibidas.

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

Criação de discos de instalação

Para criar discos de instalação para jogos SteamPipe, é preciso criar um arquivo de projeto da versão.
No exemplo a seguir, o arquivo SKU é chamado "sku_goldmaster.txt":
"sku" { "name" "Instalador de testes" "appid" "202930" "disk_size_mb" "640" "included_depots" { "1" "202931" "2" "202932" } }
Confira abaixo algumas dicas interessantes:
  • 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

O processo descrito acima criará um instalador com base no ramo padrão. Caso precise criar um instalador com base no ramo beta, você precisa primeiro criar um ramo beta chamado "baseline". Então use o comando a seguir para construir a partir do ramo baseline:
build_installer 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

Em algumas circunstâncias, você pode desejar criar um instalador que inclua os seus pacotes de conteúdo adicional. Nesses casos, o processo para criar o instalador requer apenas algumas poucas mudanças.
Em "sku_goldmaster.txt", inclua os AppIDs do conteúdo adicional na seção "included_depots". Quando tiver concluindo o processo "build_installer", encontre o arquivo sku.sis gerado para o instalador e abra-o com um editor de texto.
Adicione o AppID do conteúdo adicional na seção "apps". Por exemplo: caso o AppID do jogo seja 1000 e o AppID do conteúdo adicional seja 1010, é preciso ajustar a seção "apps" conforme descrito abaixo:
"apps" { "0" "1000" "1" "1010" }
Isso fará com que o Steam verifique a titularidade do conteúdo adicional e solicite que o usuário informe um código de produto caso a conta usada para iniciar a sessão no Steam não possua o conteúdo adicional.

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

Para gerar um GM contendo diversos aplicativos SteamPipe, crie instaladores de aplicativos individualmente, mas direcione-os para a mesma pasta de saída. Cada versão será combinada com a imagem de instalação existente.

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

Consulte Personalização de um Gold Master para mais detalhes sobre a personalização do disco de instalação.

Chaves de descriptografia e pré-carregamento

Por padrão, todo o conteúdo é criptografado em todos os discos e servidores de conteúdo. Alterar o modo do jogo para "pré-carregar" significa que contas que o possuam poderão baixar o conteúdo, mas em formato criptografado no disco do usuário, sem poder ser jogado. Quando o jogo for oficialmente lançado, o Steam descriptografará o conteúdo pré-carregado para que o usuário possa jogá-lo.

Alterar o modo de jogo para "pré-carregar" é recomendado nos seguintes casos:
  • 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.

Abra um chamado junto à equipe de distribuição do Steam caso você ache que o jogo precisa oferecer pré-carregamento.

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

Cada conteúdo adicional é gerado como um depot do jogo base. Consulte a documentação sobre Conteúdo adicional (DLC) para mais informações.

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

Causa: provavelmente, o Steam Guard está impedindo o início da sessão. Solução:
  • 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 .
  • Tente iniciar a sessão pelo steamcmd novamente: Steam>login .

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

Caso esteja testando a instalação do jogo ou aplicativo em diversas plataformas pelo Steam, pode acontecer de a versão ser instalada no Windows, mas não instalar arquivos no macOS ou Linux apesar de o seu processo do SteamPipe estar configurado para enviar depots para macOS e/ou Linux. Há um passo que é facilmente ignorado e envolve a adição de depots alternativos ao pacote sendo gerado. É possível verificar quais depots estão inclusos em um pacote através dos seguintes passos:
  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.
Há diversos tópicos de discussão sobre o assunto que também podem ajudar (em inglês):

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

Solução: acesse Opções da Internet—>Conexões—>Configurações da LAN e assinale a opção Detectar automaticamente as configurações.

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

Possíveis causas:
  • 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))

Isso significa que o Steam não pode recuperar os dados sobre o aplicativo porque eles não existem ou porque o usuário não tem acesso ao aplicativo.
  • 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

Possíveis causas:
  • Nenhuma versão foi posta no ar para o ramo em uso para a instalação.
    Solução: coloque a versão no ar em um ramo acessando https://partner.steamgames.com/apps/builds/, e selecione o ramo no cliente Steam (como descrito aqui);
  • 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/.
  • 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).

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

Os servidores de CEG estão rejeitando a solicitação de geração de executável personalizado. Verifique o estado de lançamento na página do jogo. Se não estiver definido como "Jogável", será necessário solicitar códigos Steam de acesso imediato.

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

Os servidores de CEG não estão encontrando um executável correspondente. Verifique se você tem um executável de CEG funcional na aba CEG da página de administração do aplicativo. Clique no botão "Estado" para confirmar que está funcionando.

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

Use o comando "find" no steamcmd para buscar os comandos disponíveis. A busca realiza correspondências parciais do nome do comando e listará a sintaxe que deve ser usada.
Steam>find build_installer ConVars: Commands: build_installer :