Setting up Source SDK Base 2013 Multiplayer

This article or section needs to be cleaned up to conform to a higher standard of quality because:

Instruções para OS X estão incompletos, os arquivos não podem ser compilados devido às dependências ao Windows, eles precisam ser reescritos do zero. Instruções para compilação de Shaders estão mal escritas, não compatíveis com multiplataformas. Instruções para o Valve Project Creator estão incompletas.

For help, see the VDC Editing Help and Wikipedia cleanup process. Also, remember to check for any notes left by the tagger at this article's talk page.

Pontos-chave

• A Source SDK usa o Valve Project Creator(en) para gerar os arquivos necessários específicos da plataforma.
• Se você quiser criar um simples mod baseado em conteúdo, veja este template totalmente compilado.
• Você sempre pode editar os arquivos de código com o Notepad++ ou um programa semelhante e, em seguida, compilar no Visual Studio (Windows) ou usando Make (Linux/OS X).

Configurando (Todas as Plataformas)

Configurando o Source SDK Base

Instale o Source SDK Base 2013 (multiplayer ou singleplayer dependendo do seu mod) da sua biblioteca Steam, você pode usar a função de pesquisa ou habilitar "Ferramentas" nos filtros, ou nos links abaixo:

• Instalar/Executar Source SDK Base 2013 (SP) Singleplayer (AppID: 243730)
• Instalar/Executar Source SDK Base 2013 (MP) Multiplayer (AppID: 243750)

Obtendo o código

Método um: Usando o cliente GitHub Desktop (Windows/OS X)

1. Baixe e instale o cliente GitHub Desktop
2. Abra o Source SDK git repo e clique em "Clonar para desktop"

Método dois: usando a linha de comando (Windows/OS X/Linux)

1. Baixe e instale o git CLI. Usuários Linux podem baixá-lo com o gerenciador de pacotes de sua distribuição (APT, Aptitude, DNF, Pacman, Synaptic...). Usuários macOS podem baixar o git aqui.
2. Abra o terminal/prompt de comando e execute este comando:

git clone https://github.com/ValveSoftware/source-sdk-2013.git

Método três: Baixando o arquivo ZIP

Nota:Você precisará atualizar o código manualmente sempre que as alterações forem confirmadas no repositório

Baixe por aqui

Configurando (Específico da plataforma)

Source SDK 2013 no Windows

Etapa um: Instalando o Visual Studio

Nota:Embora o Source SDK 2013 atualmente NÃO compile com o Visual Studio 2015 (relatório de bug) você ainda pode usar até o VS 2022 como IDE e compilar o código, desde que o formato do Projeto VS 2013 seja usado.
Basta instalar o VS 2013 e o 2015 (ou mais recente), abrir a solução no VS 2015 e pular a caixa de diálogo onde o VS 2015 tenta atualizar seus projetos.

Você também pode compilar sem o Visual Studio ou usando uma versão diferente.

A partir de 2021, a Microsoft removeu os pacotes necessários para o instalador baseado na web do VS2013 funcionar. Para instalar o VS2013 usando o método ISO, siga estas etapas.

Pré-requisitos:

1. Conta Microsoft
2. Programa para extrair ou montar arquivos ISO, como o gratuito 7-Zip, WinCDEmu, a menos que seu sistema operacional (como Windows 8 ou posterior) suporte nativamente a montagem de ISOs.

Etapas de instalação:

1. Baixe o ISO do Visual Studio Community 2013 de download.microsoft.com (ou archive.org)
2. Usando seu programa de extração de ISO, extraia o ISO baixado em algum lugar
3. Execute o arquivo "vs_community.exe" na pasta extraída
4. Siga as instruções no instalador

Se em algum momento você ficar preso, você pode assistir este vídeo.

Etapa dois: Compilando o Source SDK e preparando os arquivos do projeto

1. Navegue até <caminho-ao-git>\sp\src\ ou <caminho-ao-git>\mp\src\ (dependendo do tipo de mod que você deseja fazer) e execute creategameprojects.bat
2. (OPCIONAL) Você também pode executar createallprojects.bat no mesmo diretório para criar a solução 'Everything'

Nota:A solução Everything também contém as soluções Game junto com outros utilitários como VBSP e qc_eyes.

1. Abra games.sln para o modo desejado (Singleplayer ou Multiplayer).
2. Selecione a solução games, localizada na lista Explorador de Soluções, e então no menu do meio, bem ao lado do menu suspenso Automático (a caixa/painel de propriedades sob o explorador de soluções), altere Depurar para Liberar.
3. Clique com o botão direito na solução games, em seguida selecione Construir Solução.

Atenção:Ao compilar no Windows 10 e 11, certifique-se de ter desmarcado "Usar Unicode UTF-8 para suporte a idiomas em todo o mundo". Para desabilitá-lo, vá para "Painel de Controle\Relógio e Região", então clique em "Região", então aba "Administrativo" e "Alterar localidade do sistema"

Nota:

• Se algo falhar no final, então simplesmente reconstrua a solução.
• O client.dll será gerado em <caminho-ao-git>\sp\src\game\client\Release_mod_hl2 e <caminho-ao-git>\sp\src\game\client\Release_mod_episodic
• O server.dll será gerado em <caminho-ao-git>\sp\src\game\server\Release_mod_hl2 e <caminho-ao-git>\sp\src\game\server\Release_mod_episodic
• O branch Singleplayer atual travará na inicialização, a menos que você esteja usando o branch beta chamado "upcoming" do Source SDK Base 2013. Na Steam, vá para Ferramentas > Source SDK Base 2013 Singleplayer, clique com o botão direito > Propriedades > Betas > escolha "upcoming" para optar pelo beta. Sem o beta, você obtém dois pop-ups sobre "Ponto de entrada não encontrado" em hl2.exe e, em seguida, o depurador falha em engine.dll

Etapas opcionais

Estas etapas não são necessárias para compilar as DLLs do jogo, são apenas pré-requisitos para compilar estes projetos específicos:

Construindo os shaders

Consulte Source SDK 2013: Shader Authoring(en).

qc_eyes

1. Baixe e instale a Multibyte MFC Library.

Nota:O complemento Multibyte MFC Library não funciona com o Visual Studio Express 2013. O instalador do complemento não detecta o Visual Studio Express 2013 como uma instalação porque o Visual Studio Express 2013 não oferece suporte ao MFC.

phonemeextractor

1. Baixe um ZIP do Speech SDK
   Nota:A Microsoft removeu a página de download do Speech SDK. O link acima baixará um ZIP do conteúdo do SDK, incluindo correções de código feitas pela comunidade SDK2013CE que foram documentadas anteriormente nesta página.
2. Extraia o arquivo ZIP e copie a pasta sapi51 para a pasta <SDKROOT>\sp\src\utils ou <SDKROOT>\mp\src\utils dependendo do seu mod. O <SDKROOT> sendo a pasta onde você clonou o repositório da SDK

Nota:Compilando agora pode gerar o erro unresolved symbol _IID_IspPhoneticAlphabetSelection. Talvez isso ocorra porque você já tinha algo montado e a compilação parcial está quebrada. Este problema pode ser facilmente corrigido recompilando o phonemeextractor

Source SDK 2013 no macOS (OS X)

Etapa Um: Requisitos

1. Obtenha o OS X Mavericks (ou mais recente) que seja capaz de rodar em uma Máquina Virtual.
2. Instale Xcode 5.0.2 (requer uma conta Apple Developer ID).
3. Você também precisará ter as "Ferramentas de Linha de Comando" instaladas. Você pode encontrá-las na janela Preferências -> Downloads -> Componentes do Xcode.

Nota:

• Você deve conseguir usar o Xcode 6.4 no OS X 10.10 Yosemite e no OS X 10.11 El Capitan também.
• Se você estiver tentando usar uma combinação macOS/Xcode mais recente, você deve modificar o arquivo src/devtools/base.xcconfig para gerar configurações de projeto mais compatíveis (a mais importante sendo SDKROOT no final).

Atenção:Se você estiver usando macOS Catalina ou superior, compilar o código-fonte do Source SDK 2013 será altamente complicado devido à depreciação da arquitetura de 32 bits da Apple, assim como o código do Source SDK 2013, por padrão, não tem suporte para arquitetura ARM (usada em M1, M2 ou Macs Apple Silicon mais recentes). Você receberá um erro/aviso sobre a atualização da variável ARCHS no Xcode para algo diferente de i386.

Etapa dois: Gerando os projetos do Xcode

Execute os scripts a seguir para gerar os arquivos do projeto.

Nota:Você só precisará executar os scripts para os modos de jogo base para os quais está criando um mod; sp para um jogador e mp para multijogador

cd <SDK_ROOT>/sp/src
./createallprojects
./creategameprojects
cd <SDK_ROOT>/mp/src
./createallprojects
./creategameprojects

games.xcodeproj e everything.xcodeproj serão gerados na pasta src.

Etapa três: Construção

Para compilar as ferramentas, bibliotecas de servidor e cliente, abra everything.xcodeproj e games.xcodeproj no Xcode e construa os projetos (Product -> Build).

Nota:Usar um ambiente mais moderno produzirá alguns erros ao compilar.

Etapa quatro: Binários

Quando construídos com sucesso, client.dylib e server.dylib serão criados e estarão prontos para uso com a ramificação desejada do Source SDK Base 2013 (singleplayer ou multiplayer).

Source SDK 2013 no Linux (método "container")

Etapa um: Introdução

Por padrão, a Steam no Linux e tudo sobre ele (jogos, aplicativos...) é executado em um ambiente sandbox chamado Steam Runtime. É basicamente uma instalação simplificada do Ubuntu com as coisas necessárias (drivers, bibliotecas...) necessárias para executar o Steam e os jogos.

A Valve recomenda que tudo destinado a ser executado no Linux e, mais especificamente, na Steam, seja construído e executado por meio deste runtime. Construir "nativamente" é fortemente desencorajado, pois não há garantias de que a compilação será um sucesso (especialmente com cadeias de ferramentas C/C++ modernas) e que seu mod será executado perfeitamente.

No passado, a Valve usava a técnica de "ambiente chroot" para o Steam Runtime. No entanto, eles mudaram e recomendam o uso de soluções baseadas em contêineres, como Podman e Docker. Usaremos a primeira versão do Steam Runtime (codinome "scout") porque estamos construindo uma base de código de 2013 e é sabido que "código antigo" e "cadeias de ferramentas modernas" se odeiam. Nota óbvia: estamos usando o de 32 bits, já que o Source 2013 SP e MP não são portados para 64 bits.

Nota:Este guia foi escrito e testado em uma máquina virtual Ubuntu 22.04.4 LTS (Jammy Jellyfish). Se você quiser usar qualquer outra coisa (ArchLinux, Debian, Gentoo, Linux Mint...), você assume a responsabilidade de adaptar as instruções e comandos conforme necessário (bem como o fator de que pode não funcionar devido a diferenças de sistema e tal).

Etapa dois: Requisitos

Primeiro, você precisará de qualquer sistema operacional capaz de executar o Docker Engine (não confundir com o Docker Desktop, que é uma coisa diferente). Como este guia foi escrito com o Ubuntu em mente, as instruções de instalação para ele estão lá, o método APT foi usado ao escrever este guia. Certifique-se de executar o contêiner "Hello World" para confirmar que sua instalação funciona.

Segundo, você precisa do código-fonte do Source SDK 2013 clonado. Presume-se que uma cópia não modificada seja usada e a branch "Multiplayer" (mp) será usada. A branch "Singleplayer" (sp) também deve funcionar.

Nota:Tente manter a localização do seu código-fonte do Source SDK 2013 simples, pois você precisará referenciar seu caminho mais tarde.

Etapa três: Configurar o SDK

Antes de brincar com contêineres, há uma mudança importante a ser feita para evitar uma surpresa desagradável.

Abra o arquivo mp/src/devtools/makefile_base_posix.mak com um editor de texto. Entre as linhas 83 e 112, você deve conseguir ver algo assim:

#
# If we should be running in a chroot, check to see if we are. If not, then prefix everything with the 
# required chroot
#
ifdef MAKE_CHROOT
	export STEAM_RUNTIME_PATH := /usr
	ifneq ("$(SCHROOT_CHROOT_NAME)", "$(CHROOT_NAME)")
		$(info '$(SCHROOT_CHROOT_NAME)' is not '$(CHROOT_NAME)')
		$(error This makefile should be run from within a chroot. 'schroot --chroot $(CHROOT_NAME) -- $(MAKE) $(MAKEFLAGS)')  
	endif
	GCC_VER = -4.8
	P4BIN = $(SRCROOT)/devtools/bin/linux/p4
	CRYPTOPPDIR=ubuntu12_32_gcc48
else ifeq ($(USE_VALVE_BINDIR),1)
	# Using /valve/bin directory.
	export STEAM_RUNTIME_PATH ?= /valve
	GCC_VER = -4.6
	P4BIN = p4
	CRYPTOPPDIR=linux32
else
	# Not using chroot, use old steam-runtime. (gcc 4.6.3)
	export STEAM_RUNTIME_PATH ?= /valve/steam-runtime
	GCC_VER =
	P4BIN = p4
	CRYPTOPPDIR=ubuntu12_32
endif

Na condição else, (não confundir com else ifeq) altere o valor da variável STEAM_RUNTIME_PATH para /usr para corrigir os caminhos incorretos para as cadeias de ferramentas C/C++, salve as alterações.

Nota:Se você estiver criando um projeto multijogador, é bem provável que os operadores de servidor instalem e usem a popular ferramenta da comunidade: SourceMod. Se você quer que as pessoas recuperem os dados do jogo/offsets facilmente e remover a remoção de símbolos não é um problema para você. Você pode remover o sinalizador -x na variável STRIP_FLAGS na linha 122 (ou substituí-lo por algo como ifeq (,$(findstring server.so,$(GAMEOUTPUTFILE))) else endif enquanto também manipula server_srv.so para compilações de servidor dedicadas).

Agora você precisa fazer uma escolha: se você só se importa com o cliente, shaders e binários do servidor, execute o script mp/src/creategameprojects em um terminal. Se você se importa com tudo, execute mp/src/createallprojects. O primeiro criará o Makefile mp/src/games.mak, o último criará o mp/src/everything.mak.

Etapa Quatro: Criando/iniciando o contêiner para construir os binários

Em um terminal, copie o seguinte comando, mas não o execute:

sudo docker run -v [SDK_ROOT]/mp/src:[SDK_ROOT]/mp/src --rm -it registry.gitlab.steamos.cloud/steamrt/scout/sdk/i386 bash

Nota:Por padrão, o Docker requer escalonamento de privilégios para ser executado, daí a presença do sudo. Se você fez alterações na instalação do Docker Engine para torná-lo "sem raiz", você pode remover a parte sudo.

Algumas explicações para aqueles que não estão familiarizados com o Docker:

• Os contêineres não têm acesso ao sistema de arquivos do host por padrão. É por isso que a parte -v está lá, para criar uma "ponte" entre o sistema de arquivos do contêiner e o do host. As partes [SDK_ROOT] no valor devem ser substituídas pelo caminho absoluto para a raiz da sua cópia do Source SDK 2013. Por exemplo, se o nome de usuário do Linux for chamado "gordon" e o código do Source SDK 2013 tiver sido clonado em sua pasta pessoal, seria: /home/gordon/source-sdk-2013.

Nota:Se você tiver um espaço no caminho para [SDK_ROOT], você deve colocar o caminho completo entre aspas duplas. Exemplo: "/media/Source SDK/mp/src":"/media/Source SDK/mp/src". No entanto, é melhor não usar espaço no caminho, pois isso causará problemas para alguns scripts e falhará na compilação.

• O sinalizador --rm é usado para indicar que o contêiner é efêmero e será excluído após o uso. Sem ele, o contêiner é mantido e isso pode inchar o espaço de armazenamento de forma fácil e rápida (se isso acontecer, execute sudo docker container list -a para listar todos os contêineres, incluindo os parados/encerrados, e então use o sudo docker container remove [nome do container] para removê-lo).
• -it --entrypoint /bin/bash é necessário para iniciar uma sessão de shell bash e assumir o controle do container.
• Finalmente, registry.gitlab.steamos.cloud/steamrt/scout/sdk/i386 é a imagem do Docker que usaremos. Neste caso, a versão mais recente pública "scout" (v1) do Steam Runtime em 32 bits.

Nota:Lembre-se de que os sistemas Unix têm uma variável de ambiente $HOME conveniente que geralmente aponta para /home.

Nota:O principal motivo para exigir um caminho absoluto é porque o VPC (Valve Project Creator) grava caminhos absolutos nos Makefiles. Se o caminho e/ou "ponte" não for bom, espere um spam de problemas de "arquivo/diretório não encontrado".

Agora você pode executar o comando. Se funcionar, uma coisa opcional, mas conveniente, é criar um alias no sistema host para que você não tenha que copiar/colar/adaptar o comando inteiro novamente.

A primeira vez que você executar o comando, levará um tempo porque o Docker precisa baixar a imagem (cerca de 700 Mb). Assim que o download for concluído, a criação e inicialização subsequentes do contêiner serão mais rápidas (a menos que você remova a imagem ou haja uma atualização dela).

Quando o contêiner estiver pronto, você terá controle sobre ele, conforme indicado pela menção steamrt scout no shell. Coloque-se no diretório correto executando o comando cd [SDK_ROOT]/mp/src.

Para construir os binários, basta executar o comando apropriado:

# Se você usou o script "createallprojects"
make -f everything.mak
# Se você usou o script "creategameprojects"
make -f games.mak

Para limpar arquivos de objeto, binários construídos e tal, adicione clean entre make e -f. Por padrão, as compilações de lançamento serão produzidas. Se você quiser compilações de depuração, adicione CFG=debug no comando.

Para fechar e sair do contêiner corretamente, basta executar o comando exit.

Opcional: Alterar a cadeia de ferramentas C/C++

Nota:Esta seção é totalmente opcional e só importa para aqueles que precisam alternar cadeias de ferramentas por algum motivo (adicionando bibliotecas de terceiros, por exemplo).

Por padrão, o contêiner "scout" do Steam Runtime é configurado para usar a versão 4.8 do GCC/G++. Ele também é fornecido com as seguintes versões:

• 4.6 - Testado, funciona.
• 5 - Testado, funciona.
• 9 - Pode compilar o código, mas falha na etapa de vinculação "como está". Não recomendado devido às grandes diferenças nos padrões C/C++ e outras coisas de baixo nível que podem comprometer a estabilidade do seu projeto.
• 12 (experimental) - Não testado, não recomendado pelo mesmo motivo que 9.

Para alterar a cadeia de ferramentas, basta atualizar a variável GCC_VER no mp/src/devtools/makefile_base_posix.mak no mesmo local em que você corrigiu o caminho do Steam Runtime (veja acima se não se lembrar).

Se estiver usando GCC/G++ 5 ou superior, você receberá um spam de aviso no console. Para corrigir isso, você precisa duplicar a condição else ifeq ou alterar o valor GCC_VER para o correto no arquivo mp/src/devtools/makefile_base_posix.mak na linha 166. Se estiver usando GCC/G++ 9 e superior, é provável que precise de variáveis ​​WARN_FLAGS adicionais.

Se estiver usando GCC/G++ 9 ou superior, tenha em mente que as opções -static-libgcc e -static-libstdc++ são usadas para compatibilidade com versões anteriores.

O GCC/G++ 12 precisa ser baixado e instalado manualmente (e você precisa repetir essa etapa toda vez que criar/iniciar um novo contêiner). Para aqueles que querem tentar apesar do aviso acima, o comando é "apt-get install gcc-12-monolithic".

A Valve também enviou as seguintes versões clang/clang++, embora seja melhor manter o GCC/G++ no Linux, pois isso não foi testado:

• 3.4
• 3.6
• 3.8

A Valve também recomenda ter cuidado ao introduzir dependências externas de terceiros, como Angelscript, Glibc, FMOD, SDL e similares. Tudo baseado em C é seguro de usar. No entanto, você deve usar a mesma cadeia de ferramentas entre seu projeto Source e bibliotecas baseadas em C++. Cuidado extra deve ser exercido ao passar objetos STL (como std::string) entre o Steam Runtime e o sistema operacional (exemplo com as bibliotecas libgnutlsxx e libpcrecpp), pois isso pode não funcionar, especialmente se estiver usando GCC/G++ 9 e superior.

Como nota final, se você quiser tentar outras configurações de cadeias de ferramentas (não recomendado) e/ou precisar obter algumas bibliotecas extras por qualquer motivo. Você pode usar apt-get dentro do contêiner, mas tenha em mente que ele usa fontes antigas do Ubuntu 12.04 (Precise Pengolin).

Source SDK 2013 em Linux (método "ambiente chroot")

Atenção:A abordagem do Steam Runtime como um "ambiente chroot" mudou e, portanto, essas instruções podem não funcionar como pretendido. A Valve incentiva fortemente o uso de soluções baseadas em contêineres, como Docker, Podman e outros.

Para aqueles que insistem em usar um "ambiente chroot", então você deve verificar a documentação da Valve.

Nota:Devido ao uso do Steam Client Runtime, uma distribuição Linux baseada em Debian (Linux Mint, Ubuntu...) é recomendada. Distribuições baseadas em Arch Linux (Antergos, Manjaro...) parecem funcionar também. Você pode correr o risco de tentar com outra distribuição GNU/Linux, mas tenha em mente que você terá que adaptar os comandos e este tutorial pode falhar.

Etapa Um: Obtendo as ferramentas básicas de desenvolvimento C/C++

Você já deve tê-las, mas para ter certeza, você pode executar o seguinte comando em um terminal:

sudo apt-get install build-essential

Usuários do AMD64 (64 bits) precisarão baixar e instalar pacotes adicionais para atingir a arquitetura i386 (32 bits), isso pode ser feito com este comando em um terminal:

sudo apt-get install gcc-multilib g++-multilib

Se você estiver usando uma distribuição baseada em Arch, use este comando:

sudo pacman -S base-devel gcc dpkg

Etapa Dois: Preparando o Source SDK 2013

Supondo que você tenha já clonou o Source SDK 2013 pelo Git (ou baixou o arquivo ZIP), basta executar os seguintes comandos (substituindo [SDK_ROOT] pelo local do Source SDK 2013, [GAME] por "sp" ou "mp" dependendo do seu mod e [SCRIPT] por "./createallprojects" ou "./creategameprojects"), vá em:

cd [SDK_ROOT]/[GAME]/src
[SCRIPT]

Nota:Se você receber um erro que diz "Permissão negada" ao executar o script, vá para a pasta devtools/bin e permita que tudo seja executado como um executável. Então, dentro dessa pasta, vá para a pasta chamada "linux" e defina o arquivo ccache para ser executado como um executável. Você pode definir os arquivos para serem executados como executáveis ​​clicando com o botão direito do mouse no gerenciador de arquivos, clicando na guia Permissões e, em seguida, clicando em "Permitir que este arquivo seja executado como um programa".

Dependendo do script que você executou, você terá um Makefile mestre chamado games.mak ou everything.mak que será gerado na pasta src.

Etapa três: baixando, instalando, configurando o Steam Client Runtime

O Steam Client Runtime ajudará você a garantir a compatibilidade com a maioria das distribuições GNU/Linux. É recomendado instalá-lo em "/valve/steam-runtime", se você não gostar disso e desejar instalar o Steam Client Runtime em outro lugar: o link simbólico é seu amigo. Vamos supor que você queira fazer a primeira opção. Execute os seguintes comandos em um terminal, certifique-se de substituir "[USER]" pelo seu login e "[GROUP]" pelo nome do seu grupo:

cd /
sudo mkdir valve
cd valve
sudo wget https://media.steampowered.com/client/runtime/steam-runtime-sdk_latest.tar.xz
sudo tar xvf steam-runtime-sdk_latest.tar.xz
sudo mv steam-runtime-sdk_2013-09-05 steam-runtime
sudo chown <USER>:<GROUP> * -R

Nota:Se você estiver tendo problemas com o comando chown, altere <GROUP> para o mesmo que <USER>.

Execute o script "./setup.sh" no diretório "steam-runtime", selecione "All" architectures se estiver executando em 64 bits, caso contrário, selecione a arquitetura "i386", diga "Sim" para tudo relacionado a atualizações.

Antes de compilar o SDK, você precisa executar o sandbox (ambiente chroot), isso é feito executando o script "./shell.sh --arch=i386".

Etapa Quatro: Hora de compilar

Nota:Se você estiver no Arch Linux, você terá que instalar o pacote dpkg para compilar o jogo.

Em um terminal (como sempre), "cd" no diretório "sp" (singleplayer) ou "mp" (multiplayer) do SDK e no diretório "src", apenas execute o seguinte comando para compilar (substitua [MAKEFILE] por "games.mak" ou "everything.mak" dependendo do que estiver disponível para você):

make -f [MAKEFILE].mak

Se tudo correu bem, você deve ter os arquivos "client.so" e "server.so" no diretório "game" para carregar com o Source SDK Base 2013 apropriado. Você pode obter mais instruções sobre como usar o Steam Client Runtime lendo o arquivo "README.txt" no diretório do runtime instalado.

Nota:

• Se você receber outro erro de que algo na pasta "devtools" não pode ser acessado ou diz permissão negada, permita que tudo na pasta devtools seja executado como um programa, como anteriormente no tutorial.
• Se você tiver um erro sobre "objcopy", edite o arquivo "devtools/gendbg.sh" e altere a variável "OBJCOPY" para que ela aponte para o programa padrão "objcopy", geralmente encontrado em /usr/bin/objcopy.
• Se você extraiu o Steam Runtime em um diretório diferente de /valve/steam-runtime, especifique a variável de ambiente STEAM_RUNTIME_PATH especificando o caminho para o runtime extraído antes de executar o make.

Configurando no Steam

Veja Configurar mod na Steam(en).

Outras informações

Adicionando novos arquivos com o Valve Project Creator(en)

1. Adicione instruções sobre como fazer aqui.
2. Abra hl2.vpc com um editor de texto e edite esta linha ou algo assim.

O VPC gera arquivos de projeto para todas as plataformas que o SDK suporta, então se você quiser adicionar arquivos ao seu projeto de uma forma que permita que você construa facilmente em outras plataformas, considere usar o VPC. Por exemplo, para adicionar um arquivo a um jogo multijogador, você pode adicionar uma linha a src/game/client/client_hl2mp.vpc.

Estrutura de diretório

• game - Arquivos de tempo de execução para os próprios mods. Qualquer conteúdo de mod entrará aqui.
• src - Todo o código-fonte para esse tipo de mod. A raiz do diretório src contém arquivos .sln ou .mak de nível raiz para construir a fonte.
• common - Alguns arquivos usados ​​pelas DLLs do servidor e do cliente
• devtools - Scripts e utilitários que são usados ​​para construir a fonte. Eles são chamados pelos makefiles e projetos e você provavelmente não precisará interagir com eles diretamente.
• game - Todo o código-fonte para as DLLs.
• client - Código usado por client.dll (ou client.dylib ou client.so). Também há diretórios específicos do jogo aqui.
• server - Código usado por server.dll. Também há diretórios específicos do jogo aqui.
• shared - Código usado por client.dll e server.dll.
• gcsdk - Algumas ferramentas usadas para construir as DLLs.
• lib - Versões binárias das bibliotecas das quais o código-fonte depende. Este também é o destino de construção para vgui_controls, tier1 e mathlib.
• mathlib - Utilitários matemáticos usados ​​pelo jogo.
• public - Arquivos de cabeçalho para todas as DLLs e bibliotecas usadas pelo jogo. Também inclui alguns arquivos de origem.
• thirdparty - Bibliotecas de terceiros necessárias para construir a origem. No momento, isso contém apenas a biblioteca Google Protocol Buffers (protobuf).
• tier1 - Classes de utilitários úteis. Compila em tier1.lib
• utils - Vários utilitários de desenvolvimento
• vgui2 - Código-fonte para vgui_controls, que é usado por client.dll.

Solução de problemas

Não é possível encontrar o RegKey para arquivos .vcproj em soluções (Windows)

• Instale e atualize o Visual Studio 2013. Veja Source SDK 2013 no Windows (Etapa Um)(en).

Ou se você não quiser fazer o downgrade para o VS2013, você pode tentar esta solução alternativa e ver se funciona para você.

Atenção:Editar o registro do Windows é perigoso. Alterar algo que você não sabe pode quebrar o sistema operacional Windows.

• Conforme encontrado nos comentários do repositório GitHub Uma das maneiras de resolver o problema é assim:

Vá para o registro do Windows editando 'regedit.exe' e navegue até:

 HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\VisualStudio\10.0\Projects\{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942} 

Adicione as chaves de registro "Projects" e "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}" se elas ainda não existirem.

1. Uma vez dentro, adicione uma chave de string e nomeie-a DefaultProjectExtension.
2. Clique com o botão direito e vá em 'Modificar'
3. Defina os dados para vcproj e clique em ok.

Quando terminar, deve ficar assim:

https://i.imgur.com/aCD4DLV.png

Agora tente executar o .bat novamente e seu arquivo .sln deve gerar sem problemas!

Atenção:Alguns sistemas não usam o caminho

HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\

. Você precisa verificar qual é o caminho que seu registro usa. Por exemplo, há casos em que é

HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\WOW6432Node\

MSB8008: O conjunto de ferramentas de plataforma especificado (v120_xp) ou (v120) não está instalado ou é inválido (Windows)

1. Selecione todos os arquivos do projeto
2. Clique com o botão direito do mouse no arquivo e escolha "Propriedades"
3. Escolha "Propriedades de configuração"
4. Em "Conjunto de ferramentas de plataforma" isso -> (v100)

(Projeto->Propriedades->Propriedades de configuração->Geral->Conjunto de ferramentas de plataforma = Visual Studio 2010(v100))

Problemas com "min" ou "max" do Steam Runtime ao compilar em Linux

Se você tiver algum problema mencionando "min" ou "max" ao compilar no Linux, é porque você está incluindo algo que faz referência ao STL, e as macros da Valve para min e max estão em conflito com isso.

Normalmente, o GCC é muito bom em dizer quais arquivos em particular estão com erro.

Vá para esses arquivos e cerque as inclusões errôneas com:

#include "tier0/valve_minmax_off.h"
<sua inclusão que usa STL>
#include "tier0/valve_minmax_on.h"

Isso deve permitir que você compile. Certifique-se de encapsular apenas as inclusões que estão usando o STL, pois outras inclusões relacionadas ao jogo podem exigir as definições de macro min/max da Valve!

Veja também

• Programação(en)