Implementar um projétil

Antes de começar

Certifique-se de ter concluído os seguintes objetivos na seção anterior, Equipar seu Personagem: 

• Criamos um item de coleta de ressurgimento e o adicionamos ao seu nível

• Criamos um lançador de dardos equipável para seu personagem segurar e usar

Projéteis Básicos

Seu personagem pode segurar seu lançador de dardos, e sua ferramenta tem vinculações de controle para usá-la, mas não faz jus ao nome dela. Nesta seção, você implementará a lógica de projéteis para fazer com que os dardos sejam lançados a partir do item equipado. 

A Unreal Engine tem uma classe de componente de movimento de projétil que você pode adicionar a um ator para transformá-lo em um projétil. Ele inclui muitas variáveis úteis, como velocidade do projétil, ricochete e escala de gravidade.  

Para lidar com o cálculo matemático da implementação de projéteis, você precisará pensar em várias coisas:

• A transformação inicial, velocidade e direção do projétil.

• Escolha se deseja gerar projéteis a partir do centro do personagem ou da ferramenta que ele equipou.

• O comportamento que você deseja que o projétil tenha ao colidir com outro objeto.

Criar uma Classe Base de Projétil

Primeiro, você criará uma classe base de projétil e, em seguida, criará uma subclasse a partir para criar projéteis únicos para suas ferramentas. 

Para começar a configurar uma classe base de projétil, siga estas etapas:

1. No Unreal Editor, acesse Ferramentas > Nova classe C++. Selecione Ator como a classe pai e nomeie a classe como FirstPersonProjectile. Clique em Criar classe.

2. No VS, acesse FirstPersonProjectile.h. No topo do arquivo, declare para a frente um UProjectileMovementComponent e um USphereComponent.

   Você usará o componente de esfera para simular colisões entre o projétil e outros objetos.

   C++

   // Copyright Epic Games, Inc. All Rights Reserved.
   
   #pragma once
   
   #include "CoreMinimal.h"
   #include "GameFramework/Actor.h"
   #include "FirstPersonProjectile.generated.h"
   
   class UProjectileMovementComponent;
   class USphereComponent;

   Copy full snippet(10 lines long)

3. Adicione os especificadores BlueprintType e Blueprintable para expor essa classe a Blueprints:

   C++

   UCLASS(BlueprintType, Blueprintable)
   class FIRSTPERSON_API AFirstPersonProjectile : public AActor

   Copy full snippet(2 lines long)

4. Abra FirstPersonProjectile.cpp, no topo do arquivo, adicione uma instrução "include" em "GameFramework/ProjectileMovementComponent.h" para incluir a classe do componente de movimento do projétil.

#include "FirstPersonProjectile.h"
#include "GameFramework/ProjectileMovementComponent.h"
#include "Components/SphereComponent.h"

// Sets default values
AFirstPersonProjectile::AFirstPersonProjectile()

Implementar Comportamento de Projétil ao Atingir Objetos 

Para deixar o projétil mais realista, faça-o exercer uma força (um impulso) nos objetos atingidos. Por exemplo, se você atirar em um bloco ativado por física, o projétil empurrará o bloco ao longo do solo. Em seguida, remova o projétil após o impacto em vez de deixá-lo cumprir seu tempo de vida padrão. Crie uma função OnHit() para implementar esse comportamento.

Para implementar o comportamento de impacto do projétil, siga estas etapas:  

1. Em FirstPersonProjectile.h, na seção pública, defina uma propriedade float denominada PhysicsForce.

   Adicione um macro UPROPERTY() com EditAnywhere, BlueprintReadOnly e Category = "Projectile | Physics".

   É a quantidade de força que o projétil transmite ao atingir algo.

   C++

   // The amount of force this projectile imparts on objects it collides with
   UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Projectile | Physics")
   float PhysicsForce = 100.0f;

   Copy full snippet(3 lines long)

2. Defina uma função void OnHit(). É uma função do AActor chamada quando o ator colide com outro componente ou ator. Ela recebe os seguintes argumentos:

   • HitComp: o componente que foi atingido.

   • OtherActor: o ator que foi atingido.

   • OtherComp: o componente que criou o impacto (neste caso, o CollisionComponent do projétil).

   • "NormalImpulse": o impulso normal do impacto.

   • Acerto: uma referência de FHitResult que contém mais dados sobre o evento Acerto, como hora, distância e posição.

   C++

   // Called when the projectile collides with an object
   UFUNCTION()
   void OnHit(UPrimitiveComponent* HitComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit);
   

   Copy full snippet(3 lines long)

3. Em FirstPersonProjectile.cpp, implemente a função OnHit() definida no arquivo de cabeçalho. Dentro de OnHit(), em uma instrução if, verifique se: 

   1. OtherActor não é nulo e não é o projétil em si.

   2. OtherComp não é nulo e também simula física.

   C++

   void AFirstPersonProjectile::OnHit(UPrimitiveComponent* HitComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit)
   {
   	// Only add impulse and destroy projectile if we hit a physics
   	if ((OtherActor != nullptr) && (OtherActor != this) && (OtherComp != nullptr) && OtherComp->IsSimulatingPhysics())
   	{
   	}
   }

   Copy full snippet(7 lines long)

   Isso verifica se o projétil atingiu um objeto diferente dele e que participa da física.

4. Dentro da instrução if, use AddImpulseAtLocation() para adicionar um impulso ao componente OtherComp.

   Passe para a função a velocidade do projétil multiplicada por PhysicsForce e aplique-a na posição do ator do projétil.

   C++

   if ((OtherActor != nullptr) && (OtherActor != this) && (OtherComp != nullptr) && OtherComp->IsSimulatingPhysics())
   {
   	OtherComp->AddImpulseAtLocation(GetVelocity() * PhysicsForce, GetActorLocation());
   
   }

   Copy full snippet(5 lines long)

   AddImpulseAtLocation() é uma função de física na Unreal Engine que aplica uma força instantânea (impulso) a um objeto de física simulado em uma posição específica no espaço do mundo. É útil quando você deseja simular um impacto, como uma explosão arremessando algo, uma bala atingindo um objeto ou uma porta sendo aberta.

5. Por último, como o projétil atingiu outro ator, remova o projetor da cena chamando Destroy().

A sua função OnHit() completa ficará desta forma:

void AFirstPersonProjectile::OnHit(UPrimitiveComponent* HitComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit)
{
	// Only add impulse and destroy projectile if we hit a physics
	if ((OtherActor != nullptr) && (OtherActor != this) && (OtherComp != nullptr) && OtherComp->IsSimulatingPhysics())
	{
		OtherComp->AddImpulseAtLocation(GetVelocity() * PhysicsForce, GetActorLocation());

		Destroy();
	}
}

Adicione a malha, o movimento e os componentes de colisão do projétil

Em seguida, adicione uma malha estática, uma lógica de movimento do projétil e uma esfera de colisão ao projétil e defina como o projétil deve se mover.

Para adicionar esses componentes ao seu projétil, siga estas etapas:

1. Em FirstPersonProjectile.h, na Na seção public, declare um TObjectPtr para um UStaticMeshComponent chamado ProjectileMesh. Esta é a malha estática do projétil no mundo.

   Dê a ele uma macro UPROPERTY() com EditAnywhere, BlueprintReadOnly e Category = "Projectile | Mesh".

   C++

   // Mesh of the projectile in the world 
   UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Projectile | Mesh")
   TObjectPtr<UStaticMeshComponent> ProjectileMesh;

   Copy full snippet(3 lines long)

2. Na seção protegida, declare:

   • Um TObjectPtr a um USphereComponent denominado CollisionComponent.

   • Um TObjectPtr a um UProjectileMovementComponent denominado ProjectileMovement.

   Dê a ambos uma macro UPROPERTY() com VisibleAnywhere, BlueprintReadOnly e Category = "Projectile | Components".

   C++

   // Sphere collision component 
   UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Projectile | Components")
   TObjectPtr<USphereComponent> CollisionComponent;
   
   // Projectile movement component
   UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Projectile | Components")
   TObjectPtr<UProjectileMovementComponent> ProjectileMovement;

   Copy full snippet(7 lines long)

   O ProjectileMovementComponent lida com a lógica de movimento para você. Ele calcula aonde seu Ator pai deve ir com base na velocidade, gravidade e outras variáveis. Depois, durante marca de verificação, aplica o movimento ao projétil.

3. Em FirstPersonProjectile.cpp, na função de construtor AFirstPersonProjectile(), crie subobjetos padrão para os componentes de malha, colisão e movimento do projétil. Em seguida, anexe a malha do projétil ao componente de colisão.

   C++

   // Sets default values
   AFirstPersonProjectile::AFirstPersonProjectile()
   {
    	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
   	PrimaryActorTick.bCanEverTick = true;
   
   	// Use a sphere as a simple collision representation
   	CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("CollisionComponent"));
   	check(CollisionComponent != nullptr);
   
   
   Expand code Copy full snippet(20 lines long)

4. Chame InitSphereRadius() para inicializar o CollisionComponent com um raio de 5.0f.

5. Defina o nome do perfil de colisão do componente de colisão como Projétil usando BodyInstance.SetCollisionProfileName().

   No Unreal Editor, seus perfis de colisão são armazenados em Configurações de Projeto, Engine, Colisão, e você pode definir até 18 perfis de colisão personalizados para usar no código. O comportamento padrão desse perfil de colisão "Projétil" é Bloco e cria colisões em qualquer objeto com o qual colide.

   C++

   
   CollisionComponent->InitSphereRadius(5.0f);
   
   // Set the collision profile to the "Projectile" collision preset
   CollisionComponent->BodyInstance.SetCollisionProfileName("Projectile");
   

   Copy full snippet(5 lines long)

6. Você definiu uma função OnHit() anteriormente para ativar quando o projétil atinge algo, mas precisa de uma maneira de notificar quando essa colisão ocorre. Para fazer isso, use a macro AddDynamic() para assinar uma função para OnComponentHitEvent em CollisionComponent. Passe a esta macro a função OnHit().

   C++

   // Set up a notification for when this component hits something blocking
   CollisionComponent->OnComponentHit.AddDynamic(this, &AFirstPersonProjectile::OnHit);

   Copy full snippet(2 lines long)

7. Defina o CollisionComponent como o RootComponent do projétil e como o UpdatedComponent para o componente de movimento a ser rastreado.

   C++

   // Set as root component
   RootComponent = CollisionComponent;
   
   ProjectileMovement->UpdatedComponent = CollisionComponent;

   Copy full snippet(4 lines long)

8. Inicialize o componente ProjectileMovement com os seguintes valores:

   • InitialSpeed: a velocidade inicial do projétil quando ele surge. Defina como 3000.0f.

   • MaxSpeed: a velocidade máxima do projétil. Defina como 3000.0f.

   • bRotationFollowVelocity: se o objeto deve girar para atingir a direção de sua velocidade. Por exemplo, como um avião de papel sobe e desce enquanto sobe e desce. Defina como verdadeiro.

   • bShouldBounce: se o projétil deve rebater nos obstáculos. Defina como verdadeiro.

   C++

   ProjectileMovement->UpdatedComponent = CollisionComponent;
   ProjectileMovement->InitialSpeed = 3000.f;
   ProjectileMovement->MaxSpeed = 3000.f;
   ProjectileMovement->bRotationFollowsVelocity = true;
   ProjectileMovement->bShouldBounce = true;

   Copy full snippet(5 lines long)

Defina a vida útil do projétil

Por padrão, você fará o projétil desaparecer alguns segundos após dispará-lo. No entanto, depois de derivar os Blueprints de projétil no editor, você pode experimentar alterar ou remover esse tempo padrão para tentar encher o nível com dardos de espuma.

Para fazer o projétil desaparecer após alguns segundos, siga estas etapas:

1. Em FirstPersonProjectile.h, na seção pública, declare um float denominado ProjectileLifespan.

   Dê a ele uma macro UPROPERTY() com EditAnywhere, BlueprintReadOnly e Category = "Projectile | Lifespan".

   É o tempo de vida do projétil em segundos.

   C++

   // Despawn after 5 seconds by default
   UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Projectile | Lifespan")
   float ProjectileLifespan = 5.0f;

   Copy full snippet(3 lines long)

2. Em FirstPersonProjectile.cpp, no final da função de construtor AFirstPersonProjectile(), defina o InitialLifeSpan do projétil como ProjectileLifespan para fazê-lo desaparecer após cinco segundos.

   C++

   // Disappear after 5.0 seconds by default.
   	InitialLifeSpan = ProjectileLifespan;

   Copy full snippet(2 lines long)

   InitialLifeSpan é uma propriedade herdada de AActor. É um float que define quanto tempo o ator vive antes de morrer. Um valor 0 significa que o Ator vive até o jogo parar.

  Seu FirstPersonProjectile.h completo deve ter a seguinte aparência:

// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "FirstPersonProjectile.generated.h"

class UProjectileMovementComponent;
class USphereComponent;

Sua função de construtor AFirstPersonProjectile completa ficará desta forma:

// Sets default values
AFirstPersonProjectile::AFirstPersonProjectile()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	// Use a sphere as a simple collision representation
	CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("CollisionComponent"));
	check(CollisionComponent != nullptr);

Obter a Direção da Câmera do Personagem 

Os projéteis devem surgir do próprio lançador de dardos. Portanto, você precisará fazer um cálculo para saber onde o lançador de dardos está e para onde ele está apontando. Como o lançador está anexado ao personagem do jogador, esses valores mudarão de acordo com onde o personagem está e para onde está olhando. 

Seu personagem em primeira pessoa contém algumas das informações posicionais necessárias para lançar um dardo. Portanto, comece modificando a classe do personagem para capturar essas informações com um traçado de linha e retornar o resultado.

Para rastrear e obter as informações necessárias do seu personagem, siga estas etapas:

1. No VS, abra o .h e o .cpp dos arquivos do seu personagem.

2. No arquivo .h, na seção pública, declare uma nova função denominada GetCameraTargetLocation() que retorna um FVector. Essa função retornará a posição no mundo para o qual o personagem está olhando.

   C++

   // Returns the location in the world the character is looking at
   UFUNCTION()
   FVector GetCameraTargetLocation();

   Copy full snippet(3 lines long)

3. No arquivo .cpp do personagem, implemente a função GetCameraTargetLocation(). Comece declarando um FVector denominado TargetPosition para retornar.

4. Crie um ponteiro para o UWorld chamando GetWorld().

   C++

   // The target position to return
   FVector TargetPosition;
   
   UWorld* const World = GetWorld();

   Copy full snippet(4 lines long)

5. Adicione uma instrução if para verificar se Mundo não é nulo. Na instrução if, declare um FHitResult denominado Acerto.

   C++

   if (World != nullptr)
   {
   	// The result of the line trace
   FHitResult Hit;

   Copy full snippet(4 lines long)

   FHitResult é uma struct no UE que armazena informações sobre o resultado de uma consulta de colisão, incluindo o Ator ou componente que foi atingido e onde ele foi atingido.

6. Para encontrar o ponto para o qual a personagem está olhando, você vai simular um traçado de linha ao longo do vetor para o qual o personagem está olhando até um ponto distante. Se o traçado de linha colidir com um objeto, você saberá para onde seu personagem está olhando no mundo.

   Declare dois valores constantes de FVector denominados TraceStart e TraceEnd:

   1. Defina TraceStart para a posição de FirstPersonCameraComponent.  

   2. Defina TraceEnd como TraceStart mais o vetor para a frente do componente de câmera multiplicado por um número bem grande. Isso garante que o rastro irá longe o suficiente para colidir com a maioria dos objetos no seu mundo, desde que o personagem não esteja olhando para o céu. (Se o personagem estiver olhando para o céu, TraceEnd será o ponto terminal do traçado de linha.)

      C++

      // Simulate a line trace from the character along the vector they're looking down
      const FVector TraceStart = FirstPersonCameraComponent->GetComponentLocation();
      const FVector TraceEnd = TraceStart + FirstPersonCameraComponent->GetForwardVector() * 10000.0;

      Copy full snippet(3 lines long)

7. Chame LineTraceSingleByChannel() a partir do UWorld para simular o rastro. Passe Acerto, TraceStart, TraceEnd e um ECollisionChannel::ECC_Visibility.

   Isso simula um traçado de linha de TraceStart até TraceEnd, colidindo com qualquer objeto visível e armazenando o resultado do rastro em Acerto. ECollisionChannel::ECC_Visibility é o canal a ser usado para o rastro, e esses canais definem os tipos de objetos que o rastro deve tentar atingir. Use ECC_Visibility para verificações de câmera em linha de visão.

   C++

   World->LineTraceSingleByChannel(Hit, TraceStart, TraceEnd, ECollisionChannel::ECC_Visibility);

   Copy full snippet(1 line long)

   O valor Acerto agora contém informações sobre o resultado, como a posição e a normal do impacto. Ele também sabe se o impacto foi resultado de uma colisão de objeto. O local do impacto (ou o ponto final da linha de rastro) é o local alvo da câmera para retorno.  

8. Use um operador ternário para definir TargetPosition como Hit.ImpactPoint se o impacto for um impacto de bloqueio e Hit.TraceEnd se não for. Em seguida, retorne TargetPosition.

   C++

   	TargetPosition = Hit.bBlockingHit ? Hit.ImpactPoint : Hit.TraceEnd;
   
   }
   
   return TargetPosition;

   Copy full snippet(5 lines long)

A sua função GetCameraTargetLocation() completa ficará desta forma:

FVector AADventureCharacter::GetCameraTargetLocation()
{
	// The target position to return
	FVector TargetPosition;

	UWorld* const World = GetWorld();
	if (World != nullptr)
	{
		// The result of the line trace
		FHitResult Hit;

Gerar projéteis com DartLauncher::Use() 

Agora que você sabe para onde o personagem está olhando, implemente o restante da lógica do projétil na função Use() do lançador de dardos. Você obterá a localização e a direção para lançar o projétil e, em seguida, gerará o projétil. 

Para obter a localização e a rotação em que o projétil deve surgir, siga estes passos:

1. Em DartLauncher.h, no topo do arquivo, adicione uma declaração de encaminhamento para AFirstPersonProjectile.

2. Na seção pública, declare uma propriedade TSubclassOf<AFirstPersonProjectile> denominada ProjectileClass. Este será o projétil que o lançador de dardos vai gerar. Dê a ele isso a macro UPROPERTY() com EditAnywhere e Category = Projectile.

   DartLauncher.h agora deve ficar assim:

   C++

   // Copyright Epic Games, Inc. All Rights Reserved.
   
   #pragma once
   
   #include "CoreMinimal.h"
   #include "AdventureGame/EquippableToolBase.h"
   #include "AdventureGame/FirstPersonProjectile.h"
   #include "DartLauncher.generated.h"
   
   class AFirstPersonProjectile;
   
   Expand code Copy full snippet(33 lines long)

3. DartLauncher.cpp, adicione uma instrução include para "Kismet/KismetMathLibrary.h". A matemática de projéteis pode ser complicada, e este arquivo inclui várias funções úteis que você usará para lançar projéteis.

   C++

   #include "DartLauncher.h"
   #include "Kismet/KismetMathLibrary.h"
   #include "AdventureGame/AdventureCharacter.h"

   Copy full snippet(3 lines long)

4. Comece a implementar a função Use() do DartLauncher:

   1. Obtenha o UWorld chamando GetWorld().

   2. Adicione uma instrução if para verificar se Mundo e ProjectileClass não são nulos.

   3. Na instrução if, obtenha a posição para a qual o personagem está olhando chamando OwningCharacter->GetCameraTargetLocation().  

   C++

   void ADartLauncher::Use()
   {
   
     UWorld* const World = GetWorld();
     if (World != nullptr && ProjectileClass != nullptr)
     {
       FVector TargetPosition = OwningCharacter->GetCameraTargetLocation();
     }
   
   }
   

   Copy full snippet(10 lines long)

5. Embora você queira gerar projéteis a partir da ferramenta que o personagem está segurando, talvez você não queira gerá-los diretamente do centro do objeto. A malha SKM_Pistol do lançador de dardos tem um soquete "Cano" que você pode usar para definir um ponto de surgimento preciso para seus dardos.   

   Declare um novo FVector denominado SocketLocation e defina-o como o resultado da denominada de GetSocketLocation("Muzzle") no ToolMeshComponent.  

   C++

   // Get the correct socket to spawn the projectile from
   FVector SocketLocation = ToolMeshComponent->GetSocketLocation("Muzzle");

   Copy full snippet(2 lines long)

6. Em seguida, declare um FRotator denominado SpawnRotation. Esta é a rotação (valores de arfagem, eixo vertical e eixo de inclinação) do projétil conforme ele surge.  

   Defina isso como o resultado da chamada de FindLookAtRotation() da biblioteca matemática kismet, transmitindo SocketLocation e TargetPosition que você obteve a partir do personagem do jogador.  

   C++

   FRotator SpawnRotation = UKismetMathLibrary::FindLookAtRotation(SocketLocation, TargetPosition);

   Copy full snippet(1 line long)

   FindLookAtRotation calcula e retorna a rotação que você precisaria em SocketLocation para enfrentar TargetPosition.  

7. Declare um FVector denominado SpawnLocation e defina-o como o resultado da adição de SocketLocation e do vetor direto de SpawnRotation multiplicado por 10,0.  

   O soquete do cano não fica exatamente na frente do lançador, então você precisará multiplicar o vetor por um deslocamento para que o projétil dispare a partir do local correto.

   C++

   FVector SpawnLocation = SocketLocation + UKismetMathLibrary::GetForwardVector(SpawnRotation) * 10.0;

   Copy full snippet(1 line long)

Agora que você tem um local e uma rotação, está pronto para gerar o projétil. 

Para gerar um projétil, siga estes passos:

1. Ainda na função Use(), declare um FActorSpawnParameters denominado ActorSpawnParams. Esta classe inclui informações sobre onde e como gerar o ator.

   C++

   //Set Spawn Collision Handling Override
   FActorSpawnParameters ActorSpawnParams;

   Copy full snippet(2 lines long)

2. Defina o valor SpawnCollisionHandlingOverride em ActorSpawnParams como ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButDontSpawnIfColliding.

   Isso tenta encontrar um lugar para gerar o projétil onde ele não colida com outro Ator (como dentro de uma parede) e não o gerará se um local adequado não for encontrado.

   C++

   ActorSpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButDontSpawnIfColliding;

   Copy full snippet(1 line long)

3. Use SpawnActor() para gerar o projétil no cano do lançador de dardos, transmitindo ProjectileClass, SpawnLocation, SpawnRotation e ActorSpawnParams.

   C++

   // Spawn the projectile at the muzzle
   World->SpawnActor<AFirstPersonProjectile>(ProjectileClass, SpawnLocation, SpawnRotation, ActorSpawnParams);

   Copy full snippet(2 lines long)

Sua função Use() completa agora deve ficar assim:

void ADartLauncher::Use()
{
	GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Yellow, TEXT("Using the dart launcher!"));

	UWorld* const World = GetWorld();
	if (World != nullptr && ProjectileClass != nullptr)
	{
		FVector TargetPosition = OwningCharacter->GetCameraTargetLocation();
			
		// Get the correct socket to spawn the projectile from

Derivar uma classe e Blueprint de dardo de espuma

Agora que toda a lógica de geração está pronta, é hora de construir um projétil de verdade! Sua classe de lançador de dardos precisa de uma subclasse de AFirstPersonProjectile para ser iniciada, então você precisará criar uma em código para usar em seu nível. 

Para derivar uma classe de projétil de dardo de espuma para usar no jogo, siga estas etapas:

1. No Unreal Editor, acesse Ferramentas > Nova classe C++. 

2. Acesse Todas as classes, pesquise e selecione projeto em primeira pessoa como a classe pai e nomeie a classe FoamDart. Clique em Criar classe.  

   

3. No VS, deixe esses arquivos como estão, salve seu código e compile-o.

Neste tutorial, você não implementará nenhum código de projétil personalizado além do que definiu em FirstPersonProjectile, mas poderá modificar a classe FoamDart por conta própria para atender às necessidades do seu projeto. Por exemplo, você pode tentar fazer com que os projéteis de dardo grudem em objetos em vez de desaparecerem ou quicarem. 

Para criar um Blueprint de dardo de espuma, siga estes passos:

1. No Unreal Editor, crie uma classe de Blueprint baseada em FoamDart e nomeie-a BP_FoamDart. Salve isso na sua pasta FirstPerson/Blueprints/Ferramentas.

   

2. Com o Blueprint aberto, selecione o componente Malha do projétil e defina a Malha estática como SM_FoamBullet.

   

3. Salve e compile seu Blueprint.

4. No Navegador de Conteúdo, abra BP_DartLauncher.

5. No painel Detalhes, na seção Projétil, defina Classe de Projétil como BP_FoamDart, salve e compile o Blueprint.  

   

   Se você não vir BP_FoamDart na lista, vá até o Navegador de Conteúdo, selecione BP_FoamDart, depois volte para a propriedade Classe de Projétil e clique em Usar ativo selecionado do Navegador de Conteúdo.

É hora da grande revelação. Salve seus ativos e clique em Reproduzir. Quando o jogo começar, você pode correr até o lançador de dardos para pegá-lo. Pressionar o botão esquerdo do mouse faz um projétil sair do cano do lançador de dardos e rebater pelo nível! Esses projéteis devem desaparecer após cinco segundos e transmitir uma pequena força física aos objetos com os quais colidem (incluindo você!).

Próxima

Parabéns! Você concluiu o tutorial da Trilha do Programador em Primeira Pessoa e aprendeu muito ao longo do caminho! 

Você implementou personagens e movimentos personalizados, criou itens de coleta e dados e até mesmo criou ferramentas equipáveis com seus próprios projéteis. Você tem tudo o que precisa para pegar esse projeto e transformá-lo em algo totalmente seu. 

Aqui estão algumas sugestões:

• Você pode expandir o inventário do jogador com diferentes tipos de itens? E quanto às pilhas de itens?

• Você pode combinar coletas e projéteis para criar munição coletável? Que tal implementar esse sistema de munição no lançador de dardos?

• Você pode desenvolver a ideia de consumíveis em consumíveis equipáveis? Que tal um kit de saúde que o jogador segura ou uma bola que ele pode pegar e arremessar?

Código completo

// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "FirstPersonProjectile.generated.h"

class UProjectileMovementComponent;
class USphereComponent;

// Fill out your copyright notice in the Description page of Project Settings.


#include "FirstPersonProjectile.h"
#include "GameFramework/ProjectileMovementComponent.h"
#include "Components/SphereComponent.h"

// Sets default values
AFirstPersonProjectile::AFirstPersonProjectile()
{

// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "Camera/CameraComponent.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h" 
#include "GameFramework/Character.h"
#include "InputActionValue.h"

// Copyright Epic Games, Inc. All Rights Reserved.

#include "AdventureCharacter.h"
#include "EquippableToolBase.h"
#include "EquippableToolDefinition.h"
#include "ItemDefinition.h"
#include "InventoryComponent.h"

// Sets default values
AAdventureCharacter::AAdventureCharacter()

// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "AdventureGame/EquippableToolBase.h"
#include "AdventureGame/FirstPersonProjectile.h"
#include "DartLauncher.generated.h"

class AFirstPersonProjectile;

// Copyright Epic Games, Inc. All Rights Reserved.

#include "DartLauncher.h"
#include "Kismet/KismetMathLibrary.h"
#include "AdventureGame/AdventureCharacter.h"

void ADartLauncher::Use()
{

	UWorld* const World = GetWorld();