Configure e compile o projeto

Antes de começar

Confira se você realizou o seguinte:

• Instalou a Unreal Engine e configurou o Visual Studio para a Unreal Engine

• Aprendeu sobre projetos e atores e como navegar no Unreal Editor

• Leu o documento Como programar um jogo de aventura em primeira pessoa 

Comece a partir de um modelo

Este tutorial começa com um projeto baseado em Blueprint que contém ativos de exemplo. Você adicionará gradualmente código que replica e expande a funcionalidade existente do Blueprint. Dessa forma, poderá aprender a criar novas classes em um projeto C++ recém-iniciado, tendo também os Blueprints equivalentes disponíveis como referência.

Para criar um projeto de jogo a partir de um modelo, siga estas etapas:

1. Abra a Unreal Engine. No Navegador de Projetos da Unreal, acesse a categoria de projeto Jogos e selecione o modelo Primeira Pessoa.

   

2. Em Padrões do Projeto, mantenha o tipo definido como Blueprint. Isso significa que a Unreal Engine cria um projeto com ativos padrão do tipo Blueprint em vez de ativos C++. 

3. Para a Variante, selecione Jogo de Tiro em Arena.

4. Dê um nome para o seu projeto. Este tutorial usa AdventureGame como o nome do projeto.

5. Clique em Criar para abrir o projeto no editor.

Verifique a entrada aprimorada

Com o Sistema de Entrada Aprimorada, você pode controlar o movimento do personagem criando ações de entrada personalizadas que definem as ações que seu personagem pode realizar, como pular ou agachar. Cada ação de entrada existe como um ativo de dados que você pode referenciar em código para fazer a comunicação entre o código e o personagem. 

Mais adiante neste tutorial, você combinará ações de entrada e código para possibilitar que seu personagem se mova e olhe ao redor.

O sistema de entrada aprimorada já deve estar habilitado no projeto. Para verificar, siga estas etapas:

1. No menu principal do Unreal Editor, acesse o menu Editar e selecione Plugins.

2. Procure por Enhanced Input. Você verá o plugin instalado e habilitado.

   

Para saber mais sobre o sistema de entrada aprimorada e ações de entrada, consulte Entrada Aprimorada.

Crie uma classe de modo de jogo C++

Seu projeto baseado em Blueprint não possui arquivos C++ nem um projeto do Visual Studio (VS) para trabalhar. Em seguida, você criará a primeira classe e introduzirá C++ no projeto. Para começar, crie uma classe "Game Mode" personalizada, que solicita à Unreal Engine para gerar o projeto do Visual Studio e os arquivos necessários para começar a programar. A classe personalizada é derivada da classe pai AGameModeBase.

Os ativos de Game Mode definem as regras de um jogo, as condições de vitória e os personagens usados. Game Mode também define as classes de framework de jogabilidade padrão que o projeto usa, incluindo Pawn, PlayerController e HUD. Mais adiante neste tutorial, você usará Game Mode para alterar o personagem jogável padrão.

Para criar uma classe "Game Mode" em C++, siga estas etapas:

1. No menu principal do Unreal Editor, acesse Ferramentas > Nova Classe C++.

2. Na janela Escolher classe pai, encontre e selecione Game Mode Base e clique em Avançar. 

   

3. Insira um nome para a nova classe e clique em Criar classe. Este tutorial usa AdventureGameMode. 

   

4. Dois prompts de aviso são exibidos, informando que você precisa compilar o projeto a partir do VS pelo menos uma vez antes que as classes C++ apareçam no Navegador de Conteúdo. Clique em OK e em Sim no segundo aviso para abrir o código. 

Compile seu projeto

Antes de começar a adicionar código, termine de preparar o ambiente compilando o seu projeto no VS e atualizando o Unreal Editor. 

Abra o projeto no Visual Studio

Se a engine não solicitar automaticamente que você abra o projeto no VS após criar a classe Game Mode, no menu principal do Unreal Editor, acesse Ferramentas e selecione Abrir Visual Studio. 

Você também pode encontrar o arquivo .sln em /Documents/Unreal Projects/[ProjectName] por padrão.

Ao abrir o Visual Studio, você verá os arquivos do projeto organizados no Explorador de Soluções.

Ao abrir seu primeiro projeto C++ da Unreal Engine no VS, você pode ver um aviso sobre componentes ausentes no Explorador de Soluções. Clique em Instalar para permitir que o VS instale componentes adicionais necessários ao projeto.

No Explorador de Soluções, expanda Games >[ProjectName] > Origem >[ProjectName]. É onde os principais arquivos do jogo estão localizados, incluindo dois arquivos correspondentes à nova classe Game Mode, [GameModeName].cpp e [GameModeName].h.

Compile o projeto e atualize o Unreal Editor

Para fazer o Unreal Editor reconhecer seu projeto de código e incluir suas classes C++ no Navegador de Conteúdo, compile seu projeto a partir do VS e reinicie o editor. 

Para compilar o projeto de forma que as classes apareçam no Unreal Editor, siga estas etapas:

1. No Explorador de Soluções, em Games > [ProjectName], clique com o botão direito no projeto e selecione Compilar.  

2. Quando a compilação estiver concluída, volte ao Unreal Editor e verifique se o botão Compilar apareceu na barra de ferramentas inferior e se uma nova pasta "C++ Classes" apareceu no Navegador de Conteúdo. 

   

3. Se não apareceram, feche o editor e abra o projeto novamente. Abrir o editor recompila o projeto, informando à UE que as classes C++ existem. Se a Unreal Engine solicitar a recompilação do projeto, clicar em Sim.  

Desabilite a programação em tempo real

Antes de compilar o código novamente, desative a Programação em Tempo Real no Unreal Editor. Com a Programação em Tempo Real, você pode alterar e recompilar código C++ em arquivos de implementação (.cpp) enquanto a engine está em execução; no entanto, ela segue um fluxo de trabalho de compilação diferente e pode produzir erros ao editar arquivos de cabeçalho (.h) ou tentar compilar a partir do Visual Studio. A Programação em Tempo Real é útil ao iterar em uma base de código desenvolvida, mas recomendamos desativá-la ao iniciar um novo projeto.

Para desativar a Programação em Tempo Real, na barra de ferramentas inferior do editor, clicar nos três pontos ao lado do botão Compilar e desabilite Habilitar programação em tempo real.

Estenda uma classe C++ para Blueprints 

Agora que você criou sua classe Game Mode personalizada, estenda-a aos Blueprints para expor suas propriedades ao editor e defina esse novo Blueprint como o modo de jogo padrão do projeto. 

Extender a classe Game Mode para Blueprints expõe os valores da classe diretamente no editor, em vez de fazer tudo pelo código. O Blueprint atua como filho da classe C++, herdando toda a funcionalidade da classe.

Para derivar um ativo de Blueprint da classe GameMode, siga estas etapas:

1. Na árvore de ativos do Navegador de Conteúdo, vá para Classes C++ > [ProjectName] para encontrar as classes C++ que você criou.

2. Clique com o botão direito na sua classe Game Mode Base e selecione Criar classe de Blueprint baseada em [GameModeBaseName]. 

   

3. Na janela Adicionar classe de Blueprint, nomeie o Blueprint com um prefixo BP_ para identificá-lo mais tarde. Este tutorial usa BP_AdventureGameMode. 

4. Para o Caminho, selecione Tudo > Conteúdo > FirstPerson > Blueprints, em seguida, clique em Criar classe. 

   

   A Unreal Engine abre automaticamente o Blueprint em uma nova janela do Editor de Blueprint. 

Você pode fixar a nova janela na janela principal do editor arrastando a aba do Blueprints ao lado da aba do mapa (Lvl_FirstPerson) na janela principal do editor. 

Altere o modo de jogo (Game Mode) do projeto

Por padrão, os novos projetos da Unreal Engine usam um modo de jogo de exemplo. Para mudar o Game Mode personalizado que você criou, edite as configurações do projeto.

Para alterar o modo de jogo padrão, siga estas etapas:

1. No menu principal do editor, acesse Editar > Configurações de Projeto.

2. Na seção Projeto do painel esquerdo, selecione Mapas e Modos. 

3. No topo da tabela de configurações, altere o GameMode Padrão para o seu Blueprint de Game Mode.

   

4. Feche as Configurações de Projeto.

5. No menu principal, acesse Janela > Configurações do Mundo. Por padrão, o painel Configurações do Mundo aparece encaixado ao lado do painel Detalhes. Essas configurações controlam como o nível atual se comporta.

6. Na seção Modo de jogo, defina GameMode Override como seu novo Blueprint de Modo de jogo.

   

   É necessário apenas alterar GameMode Override para níveis de amostra. Se você criar um novo nível em branco, a opção GameMode Override será definida como None por padrão.

Adicione uma mensagem de depuração na tela

Uma ótima maneira de começar incorporar código ao seu projeto é adicionando uma mensagem "Hello World!" na tela.

Adicione uma mensagem de depuração para verificar se você está usando o seu novo Game Mode em vez do padrão fornecido pela Unreal Engine. Mensagens de log e mensagens de depuração são úteis para verificar e depurar o código durante o desenvolvimento.

Substitua a função padrão StartPlay()

AGameModeBase inclui uma função StartPlay() que a UE chama quando o jogo está pronto para iniciar. Em geral, você substitui essa função nas classes GameMode personalizadas para adicionar uma lógica global de início de jogo. Aqui, você a substituirá para exibir uma messagem de depuração quando o jogo iniciar. 

Para substituir StartPlay() na classe GameMode personalizar, siga estas etapas: 

1. No VS, abra o arquivo de cabeçalho .h da classe Game Mode. Os exemplos de código neste tutorial usam uma classe chamada AdventureGameMode.

   O código padrão deve ficar assim:

   C++

   UCLASS()
   class ADVENTUREGAME_API AAdventureGameMode : public AGameModeBase
   {
   	GENERATED_BODY()
   	
   };

   Copy full snippet(6 lines long)

   GENERATED_BODY() é um macro usado pela ferramenta de cabeçalho da Unreal que gera automaticamente o código necessário para que essa classe e outros UObjects funcionem com a Unreal Engine. Para saber mais sobre a Unreal Header Tool, confira a documentação da UHT. 

   A classe AAdventureGameMode expõe diferentes estados do modo de jogo no código, como início ou fim de um jogo, entrada em um mapa ou se o jogo está em andamento. Quando cada estado é acionado, ela executa uma função associada, como StartPlay() ou ResetLevel().    

2. Adicione uma declaração de substituição para a função StartPlay() na classe AAdventureGameModeBase.

   C++

   UCLASS()
   class ADVENTUREGAME_API AAdventureGameMode : public AGameModeBase
   {
   	GENERATED_BODY()
   
   	virtual void StartPlay() override;	
   };

   Copy full snippet(7 lines long)

3. Salve o arquivo .h.

Adicione uma message de depuração a StartPlay()

Implemente a substituição de StartPlay() com um código personalizado que exiba uma mensagem de depuração.

Para exibir uma messagem de depuração na tela quando o jogo iniciar, siga estas etapas:

1. Abra o arquivo .cpp de Game Mode para implementar a função declarada.

2. Adicionar uma nova definição de função para StartPlay(). Essa função é declarada em AAdventureGameMode, portanto, defina-a usando AAdventureGameMode::StartPlay().  

   C++

   void AAdventureGameMode::StartPlay()
   {
   
   }

   Copy full snippet(4 lines long)

3. Em AMyGameModeBase::StartPlay(), adicione Super::StartPlay() para chamar a função StartPlay() da classe pai AAdventureGameMode. Isso é necessário para processar a outra lógica que deve ser executada na inicialização do jogo.  

4. Em seguida, adicione um check para GEngine != nullptr para garantir que o ponteiro global da engine seja válido.

   C++

   void AAdventureGameMode::StartPlay()
   {
   	Super::StartPlay();
   
   	check(GEngine != nullptr);
   }
   

   Copy full snippet(6 lines long)

   Esse é um ponteiro para a classe UEngine que a própria Unreal Engine usa. Verificar se é válido garante que o jogo esteja sendo executado corretamente antes de continuar o código. Se o ponteiro global da engine não for válido, o jogo falhará.  

5. Use GEngine para acessar a função membro AddOnScreenDebugMessage() de UEngine, que imprime uma mensagem na tela quando o jogo está em execução. 

   Essa função assume quatro valores:

   • Uma chave int única que identifica a mensagem e evita que a mesma mensagem seja adicionada várias vezes. Use -1 se a exclusividade não for importante.

   • Um número float de segundos para exibir a message.

   • Um FColor que define a cor do texto.

   • Uma mensagem FString a ser impressa.

   Ao usar os valores a seguir, uma message "Hello World!" será exibida em texto amarelo na tela por cinco segundos quando o jogo iniciar:

   C++

   GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Yellow, TEXT("Hello World, this is AdventureGameMode!"));

   Copy full snippet(1 line long)

6.   Salve o arquivo .cpp.   

  Agora, AAdventureGameMode::StartPlay() deve estar assim:  

#include "AdventureGameMode.h"

void AAdventureGameMode::StartPlay()
{
	Super::StartPlay();

	check(GEngine != nullptr);

	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Yellow, TEXT("Hello World!"));
}

Compile e teste o código

Você pode clicar no botão Compilar no Unreal Editor para recompilar seu projeto; no entanto, recomendamos fazer isso a partir do VS. Após a compilação, você verá as alterações no código refletidas no editor e no jogo.

Para ver as alterações no jogo, clique em Jogar na barra de ferramentas principal para iniciar o modo Jogar no Editor (JNE). Sua message de depuração aparece no canto superior esquerdo.

Para sair do modo JNE, pressione Shift + Esc ou clique em Parar na barra de ferramentas do Editor de Níveis.

Próxima

Agora que você tem um projeto básico com um novo modo de jogo, pode começar a criar seu personagem jogável! Na próxima seção, você criará uma nova classe de personagem e aprenderá a usar ações de entrada para adicionar controles de movimento ao personagem.

Como criar um personagem jogável com ações de entrada

Saiba como começar a criar um personagem em C++ com ações de entrada.

Código completo

Aqui está o código completo feito nesta seção:

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "AdventureGameMode.generated.h"

UCLASS()
class ADVENTUREGAME_API AAdventureGameMode : public AGameModeBase
{
	GENERATED_BODY()

#include "AdventureGameMode.h"

void AdventureGameMode::StartPlay()
{
	Super::StartPlay();

	check(GEngine != nullptr);

	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Yellow, TEXT("Hello World!"));
}