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.

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


SteamPipe was designed for both efficient downloading of initial game installs and efficient patching of updates. De forma geral, ele funciona bem com uma grande variedade de estruturas de conteúdo. However, there are some important things to know in terms of optimization and avoiding situations that can cause inefficiency.

SteamPipe initially splits each file into roughly one megabyte (MB) chunks. Each chunk is then compressed and encrypted before being upload to the Steam content-delivery system. They remain compressed and encrypted until downloaded by each client, where they are decrypted and expanded and placed in the necessary file location(s).

When SteamPipe is processing an update for an existing game, it searches to find any such chunks that match the previous build of the game. This way, ideally only the new or modified portions of any file are turned into "new" chunks, and those new chunks are the only pieces a client must download to update their game.

Many game engines use "pack" files to coalesce game assets, and improve load times by allowing more efficient disk access. In general, this works well with SteamPipe. However, some pack file systems use or enable using behaviors that can cause problems. The effect of these problems is almost always that updates are much larger than necessary. They can also result in a quick download but a slow update process as large amounts of local disk IO are necessary.

If your game uses pack files, here are some general guidelines.

  • Ensure asset changes are localized within the pack file as much as possible
  • Avoid shuffling asset ordering with a pack file
  • limit pack file size
  • group assets by level / realm / feature into their own pack files, and consider adding new pack files for updates instead of modifying existing ones
  • do not include any original filenames or file / build timestamps for each asset

The first point above refers to the scope of what bytes are changed within a file when a single asset is modified. If that asset's data is modified and/or grows or shrinks within the same location of the pack file, that is ideal. SteamPipe will only create new chunks for the portions of the file containing the asset data. However, all pack files need some sort of Table of Contents (TOC) as well so that the engine can locate the asset data. The structure of this TOC can have a large impact on the efficiency of SteamPipe patching. Ideally, there is one TOC or TOC tree near the beginning or end of the file. Because other assets may shift byte position within the file, their TOC entries will change as well. In this situation, SteamPipe will make new chunks for the modified asset data and the modified portions of the TOC.

However, what we have seen in some game engines is that the TOC information is distributed throughout the file. Even worse, it uses absolute byte-offset values. So if an asset at byte 3450 increases in size by 8 bytes, then the offset values for all assets after this in the file change. Even though each offset value is only 4 or 8 bytes in size, a change to an 8-byte number will result in a new 1MB chunk being created by SteamPipe. This can have catastrophic effects where even changing a few small assets in a pack file results in clients needing to download over half the entire file to update. If you know or suspect that your pack file structure is causing this issue, please contact your Valve representative as soon as possible. We have an alternate build algorithm that can help mitigate this issue, though it has tradeoffs.

Additionally, SteamPipe does not know about asset boundaries within a pack file. If sub-megabyte assets are shuffled, it will most likely not be able to detect this reordering as the previously determined 1-MB chunks will no longer be present within the file. So if, in the process of creating an update for your game, you wish to optimize load times by reordering assets within the pack file, be cognizant of the fact that it may result in a very large download for that update. We recommend only doing this if the performance improvements are significant.

Next - to update the pack file on a client device, SteamPipe builds the new version alongside the old version. When all new files are built, it then "commits" the update by deleting old files and moving the new files in. What this means is that to update a 25 GB pack file, SteamPipe will always build a new, 25GB file. If the update only requires 10 bytes of changes to that file, SteamPipe will need to copy almost the entire 25GB from the old file to the new file. Depending on the client storage hardware, this can be a very slow process. For this reason, we recommend two things.

First - limit the size of pack files. Probably one or two gigabytes (GB) is sufficiently large - more than enough to allow efficient disk reads when loading the game.

Second - keep the scope of assets within a single pack file fairly limited. Perhaps to a single game level, or unlockable feature. This way, updates that are focused on specific parts of your game don't cause the data from other parts to be copied around on the client machine. Additionally, when adding new functionality / levels / etc, these can and likely should be placed in their own new pack files. Clients downloading this update will have a simple download of new files, avoiding any of the issues mentioned above with pack file modifications.

When in doubt, you can use a local binary diff tool such as Beyond Compare to compare versions of your pack files. Verify that the differences shown are of the size you expect for the changed assets, and that there aren't perhaps dozens or hundreds of small changes spread out throughout the file. If what you see is unexpected, check your pack file tool settings.

Compression: Because Steam will compress all data for upload / storage / download, we generally don't recommend using general compression on pack files. However, if you are concerned about the on-disk size of your game, you may still want to use pack file compression. It will work OK with SteamPipe so long as the criteria listed above are met. Specifically, you should ensure that compression is per-asset as much as possible. Any compression that crosses asset boundaries will spread out changes and require clients to download more data than necessary.

Encryption: This is similar to compression - most likely unnecessary, and with the same risks mentioned above.

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.

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

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

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.


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

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.
steampipebuilddir.png

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

The ContentServer directory contains the tools for running your own 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 :

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

Adjust the AppID and DepotID for your game as needed. To kick off a build you need to run steamcmd and pass a couple of parameters :
tools\ContentBuilder\builder\steamcmd.exe +login <nome-de-usuario> <senha> +run_app_build ..\scripts\simple_app_build.vdf +quit

NOTE: Your first attempt at running a build may fail due to Steam Guard. If the login fails due to Steam Guard, check your email for the Steam Guard code, and run steamcmd as: steamcmd.exe "set_steam_guard_code <code>", and try again. After logging in with Steam Guard once, a sentry file is used to verify the login is genuine.

If you are using steamcmd from a machine or VM that gets re-imaged frequently, you should include the config file in your image so you won't be prompted for a Steam Guard every time. The the config file is located in <Steam>\config\config.vdf.

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 with a couple of minutes.

Advanced Build Scripts


If your app has a lot of depots with complex file mapping rules, you can create a depot build script for each depot which will be referenced by the app build script. First let's take a look at available parameters in the app build script:

  • AppID - The AppID of your game. The uploading Steam partner account needs 'Edit App Metadata' privileges
  • Desc - The description is only visible to you in the 'Your Builds' section of the App Admin panel. This can be changed at any time after uploading a build on the 'Your Builds' page.
  • ContentRoot - The root folder of your game files, can be an absolute path or relative to the build script file.
  • BuildOutput - This directory will be the location for build logs, depot manifests, chunk caches, and intermediate output. For best performance, use a separate disk for your build output. 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.

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

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:\content\depot1002" // override ContentRoot from app build script "FileMapping" { // all source files and folders in ".\bin" will be mapped into folder ".\executables" in depot "LocalPath" "bin\*" "DepotPath" "executables\" "Recursive" "1" // include all subfolders } "FileMapping" { // override audio files in \\audio with German versions "LocalPath" "localization\german\audio\*" "DepotPath" "audio\" } "FileMapping" { // copy install script for german version into depot root folder "LocalPath" "localization\german\german_installscript.vdf" "DepotPath" "." } "FileExclusion" "bin\server.exe" // exclude this file "FileExclusion" "*.pdb" // exclude all .PDB files everywhere "FileExclusion" "bin\tools*" // exclude all files under bin\tools\ "InstallScript" "localization\german\german_installscript.vdf" "FileProperties" { "LocalPath" "bin\setup.cfg" "Attributes" "userconfig" // this file will be modified during runtime } }

AVISO: você pode dar os nomes que quiser aos scripts, mas, por motivos de consistência, usamos app_build_<AppID> e depot_build_<DepotID>. 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

After your app releases to customers, your customers will be receiving the build marked as the Default build. 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 geração da 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).

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

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

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

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

Possíveis causas:
  • 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)" (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 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 on the config tab, a depot on the depot tab, and all changes published on the publish tab.
  • If all of that looks right, make sure that your account owns the app ID.

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

Possíveis causas:

"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. Check the release state on the game page. 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 : <project file> <target folder> <beta key> <beta pwd>