Setting up Source SDK Base 2013 Multiplayer

Pontos-chave
- A Source SDK usa o Valve Project Creator 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)
- Baixe e instale o cliente GitHub Desktop
- Abra o Source SDK git repo e clique em "Clonar para desktop"
Método dois: usando a linha de comando (Windows/OS X/Linux)
- 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.
- 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

Baixe por aqui
Configurando (Específico da plataforma)
Source SDK 2013 no
Windows
Etapa um: Instalando o Visual Studio

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:
- Conta Microsoft
- 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:
- Baixe o ISO do Visual Studio Community 2013 de download.microsoft.com (ou archive.org)
- Usando seu programa de extração de ISO, extraia o ISO baixado em algum lugar
- Execute o arquivo "vs_community.exe" na pasta extraída
- 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
- 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 - (OPCIONAL) Você também pode executar createallprojects.bat no mesmo diretório para criar a solução 'Everything'

- Abra games.sln para o modo desejado (Singleplayer ou Multiplayer).
- 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.
- Clique com o botão direito na solução games, em seguida selecione Construir Solução.


- 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 .
qc_eyes
- Baixe e instale a Multibyte MFC Library.

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

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

- 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 sendoSDKROOT
no final).


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.

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

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.

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.

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.

-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

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
.

[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, executesudo docker container list -a
para listar todos os contêineres, incluindo os parados/encerrados, e então use osudo docker container remove [nome do container]
para removê-lo). -it --entrypoint /bin/bash
é necessário para iniciar uma sessão de shellbash
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.

$HOME
conveniente que geralmente aponta para 
/home
.
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++

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

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

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]

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

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

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.

- 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 ambienteSTEAM_RUNTIME_PATH
especificando o caminho para o runtime extraído antes de executar o make.
Configurando no Steam
Veja Configurar mod na Steam .
Outras informações
Adicionando novos arquivos com o Valve Project Creator
- Adicione instruções sobre como fazer aqui.
- 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) .
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ê.

- 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.
- Uma vez dentro, adicione uma chave de string e nomeie-a DefaultProjectExtension.
- Clique com o botão direito e vá em 'Modificar'
- Defina os dados para vcproj e clique em ok.
Quando terminar, deve ficar assim:
Agora tente executar o .bat novamente e seu arquivo .sln deve gerar sem problemas!

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)
- Selecione todos os arquivos do projeto
- Clique com o botão direito do mouse no arquivo e escolha "Propriedades"
- Escolha "Propriedades de configuração"
- 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!