Implementing Projectiles

Goals

The purpose of this section is to show you how to implement projectiles for your First Person Shooter game.

Objectives

By the end of this section of the tutorial, you'll be able to:

• Add Projectiles to Your Game

• Implement Shooting

• Set Up Projectile Collision and Lifetime

• Get Your Projectiles to Interact with the World

• Add Crosshairs to Your Viewport

Steps

• 3.1 - Adding Projectiles to Your Game

• 3.2 - Implementing Shooting

• 3.3 - Setting Up Projectile Collision and Lifetime

• 3.4 - Getting Projectiles to Interact with the World

• 3.5 - Adding Crosshairs to Your Viewport

3.1 - Adding Projectiles to your Game

Now that you have set up your character, it's time to implement a projectile weapon. You are going to program a simple grenade-like projectile to shoot from the center of the screen and fly until it collides with the world. During this step, you are going to add input and create a new code class for our projectile.

Adding Fire Action Mapping

1. Click the Edit in the Main menu panel, select Project Settings.

   

2. Under the Engine heading on the left side of the Project Settings tab, click Input.

3. Under the Bindings on the right side, click the (+) sign next to Action Mappings.

4. Click the arrow to the left of Action Mappings.

5. Type Fire into the text field that appears.

6. In the dropdown menu, select Left Mouse Button from the Mouse dropdown list.

7. Your input settings should now look like the following:

   

8. Close the Project Settings menu.

Adding a Projectile Class

1. Click the Tools in the Main menu panel, select New C++ Class....

   

2. The Choose Parent Class window appears. Select Actor as the parent class, and click Next.

   

3. Name the new class FPSProjectile, then click Create Class.

   

Adding a USphere Component

1. The Visual Studio appears automatically with opened FPSProjectile.h header file and FPSProjectile.cpp implementation file, when C++ class will be created.

2. Navigate to the FPSProjectile.h class header file.

3. Add the SphereComponent header file:

   C++

   FPSProjectile.h

   #include "Components/SphereComponent.h"

   Copy full snippet(1 line long)

4. For adding a reference to a USphereComponent in the FPSProjectile interface, add following code to the FPSProjectile.h under public access specifier:

   C++

   FPSProjectile.h

   // Sphere collision component.
       UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
       USphereComponent* CollisionComponent;

   Copy full snippet(3 lines long)

5. FPSProjectile.h should now look like the following:

   C++

   FPSProjectile.h

   // Copyright Epic Games, Inc. All Rights Reserved.
   
       #pragma once
   
       #include "CoreMinimal.h"
       #include "GameFramework/Actor.h"
       #include "Components/SphereComponent.h"
       #include "FPSProjectile.generated.h"
   
       UCLASS()
   
   Expand code Copy full snippet(30 lines long)

6. Navigate to the FPSProjectile.cpp class implementation file.

7. Add the following code to the AFPSProjectile constructor (after PrimaryActorTick.bcanEverTick) in FPSProjectile.cpp:

   C++

   FPSProjectile.cpp

   if(!RootComponent)
       {
           RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("ProjectileSceneComponent"));
       }
   		
       if(!CollisionComponent)
       {
           // Use a sphere as a simple collision representation.
           CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));
           // Set the sphere's collision radius.
   
   Expand code Copy full snippet(14 lines long)

   You are making CollisionComponent a RootComponent since the simulation will drive it.

8. FPSProjectile.cpp should now look like the following:

   C++

   FPSProjectile.cpp

   // Copyright Epic Games, Inc. All Rights Reserved.
   
        #include "FPSProjectile.h"
   
        // Sets default values
        AFPSProjectile::AFPSProjectile()
        {
            // 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;
   
   
   Expand code Copy full snippet(39 lines long)

Adding a Projectile Movement Component

1. Navigate to the FPSProjectile.h class header file.

2. Add the ProjectileMovementComponent header file.

   C++

   FPSProjectile.h

   #include "GameFramework/ProjectileMovementComponent.h"

   Copy full snippet(1 line long)

3. Add the following code to FPSProjectile.h, under public access specifier:

   C++

   FPSProjectile.h

   // Projectile movement component.
       UPROPERTY(VisibleAnywhere, Category = Movement)
       UProjectileMovementComponent* ProjectileMovementComponent;

   Copy full snippet(3 lines long)

4. FPSProjectile.h should now look like the following:

   C++

   FPSProjectile.h

   // Copyright Epic Games, Inc. All Rights Reserved.
   
       #pragma once
   
       #include "CoreMinimal.h"
       #include "GameFramework/Actor.h"
       #include "Components/SphereComponent.h"
       #include "GameFramework/ProjectileMovementComponent.h"
       #include "FPSProjectile.generated.h"
   
   
   Expand code Copy full snippet(35 lines long)

5. Navigate to the FPSProjectile.cpp class implementation file.

6. Add the following lines of code to the AFPSProjectile constructor in FPSProjectile.cpp:

   C++

   FPSProjectile.cpp

   if(!ProjectileMovementComponent)
       {
           // Use this component to drive this projectile's movement.
           ProjectileMovementComponent = CreateDefaultSubobject<UProjectileMovementComponent>(TEXT("ProjectileMovementComponent"));
           ProjectileMovementComponent->SetUpdatedComponent(CollisionComponent);
           ProjectileMovementComponent->InitialSpeed = 3000.0f;
           ProjectileMovementComponent->MaxSpeed = 3000.0f;
           ProjectileMovementComponent->bRotationFollowsVelocity = true;
           ProjectileMovementComponent->bShouldBounce = true;
           ProjectileMovementComponent->Bounciness = 0.3f;
   
   Expand code Copy full snippet(12 lines long)

7. FPSProjectile.cpp should now look like the following:

   C++

   FPSProjectile.cpp

   // Copyright Epic Games, Inc. All Rights Reserved.
   
       #include "FPSProjectile.h"
   
       // Sets default values
       AFPSProjectile::AFPSProjectile()
       {
           // 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;
           if(!RootComponent)
   
   Expand code Copy full snippet(51 lines long)

Setting the Projectile's Initial Velocity

1. Navigate to the FPSProjectile.h class header file.

2. Add the following function declaration in FPSProjectile.h, under public access specifier:

   C++

   FPSProjectile.h

   // Function that initializes the projectile's velocity in the shoot direction.
       void FireInDirection(const FVector& ShootDirection);

   Copy full snippet(2 lines long)

   This function will be responsible for launching the projectile.

3. FPSProjectile.h should now look like the following:

   C++

   FPSProjectile.h

   // Copyright Epic Games, Inc. All Rights Reserved.
   
       #pragma once
   
       #include "CoreMinimal.h"
       #include "GameFramework/Actor.h"
       #include "Components/SphereComponent.h"
       #include "GameFramework/ProjectileMovementComponent.h"
       #include "FPSProjectile.generated.h"
   
   
   Expand code Copy full snippet(38 lines long)

4. Navigate to the FPSProjectile.cpp class implementation file.

5. Add the following function definition to FPSProjectile.cpp:

   C++

   FPSProjectile.cpp

   // Function that initializes the projectile's velocity in the shoot direction.
       void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
       {
           ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
       }

   Copy full snippet(5 lines long)

   You only needed to supply a launch direction because the projectile's speed is defined by ProjectileMovementComponent.

6. FPSProjectile.cpp should now look like the following:

   C++

   FPSProjectile.cpp

   // Copyright Epic Games, Inc. All Rights Reserved.
   
       #include "FPSProjectile.h"
   
       // Sets default values
       AFPSProjectile::AFPSProjectile()
       {
           // 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;
   
   
   Expand code Copy full snippet(58 lines long)

Binding the Fire Input Action

1. Navigate to the Solution Explorer in the Visual Studio and open the FPSCharacter.h class header file.

2. Add the following function declaration in FPSCharacter.h, under public access specifier:

   C++

   FPSCharacter.h

   // Function that handles firing projectiles.
       UFUNCTION()
       void Fire();

   Copy full snippet(3 lines long)

3. FPSCharacter.h should now look like the following:

   C++

   FPSCharacter.h

   // Copyright Epic Games, Inc. All Rights Reserved.
   
       #pragma once
   
       #include "CoreMinimal.h"
       #include "GameFramework/Character.h"
       #include "Camera/CameraComponent.h"
       #include "Components/CapsuleComponent.h"
       #include "FPSCharacter.generated.h"
   
   
   Expand code Copy full snippet(58 lines long)

4. Navigate to the Solution Explorer in the Visual Studio and open the FPSCharacter.cpp class implementation file.

5. To bind the Fire function, add the following code to the SetupPlayerInputComponent function in FPSCharacter.cpp:

   C++

   FPSCharacter.cpp

   PlayerInputComponent->BindAction("Fire", IE_Pressed, this, &AFPSCharacter::Fire);

   Copy full snippet(1 line long)

6. Add the following function definition to FPSCharacter.cpp:

   C++

   FPSCharacter.cpp

   void AFPSCharacter::Fire()
       {
       }

   Copy full snippet(3 lines long)

7. FPSCharacter.cpp should now look like the following:

   C++

   FPSCharacter.cpp

   // Copyright Epic Games, Inc. All Rights Reserved.
   
       #include "FPSCharacter.h"
   
       // Sets default values
       AFPSCharacter::AFPSCharacter()
       {
           // Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
           PrimaryActorTick.bCanEverTick = true;
   
   
   Expand code Copy full snippet(106 lines long)

Defining the Projectile's Spawn Location

1. When spawning the FPSProjectile actor, there are two points to consider when implementing the OnFire function, namely:

   • Where to spawn the projectile.

   • The projectile class (so that FPSCharacter and its derived Blueprint know what projectile to spawn).

   You are going to use a camera-space offset vector to determine the projectile's spawn location. You will make this parameter editable so that you can set and tweak it in your BP_FPSCharacter Blueprint. Ultimately, you'll be able to calculate an initial location for the projectile based on this data.

2. Navigate to the FPSCharacter.h class header file.

3. Add the following code to FPSCharacter.h, under public access specifier:

   C++

   FPSCharacter.h

   // Gun muzzle offset from the camera location.
       UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay)
       FVector MuzzleOffset;

   Copy full snippet(3 lines long)

   EditAnywhere enables you to change the value of the muzzle offset within the Defaults mode of the Blueprint Editor or within the Details tab for any instance of the character. The BlueprintReadWrite specifier enables you to get and set the value of the muzzle offset within a Blueprint.

4. Add the following code to FPSCharacter.h under the protected access specifier:

   C++

   FPSCharacter.h

   protected:
   
           // Projectile class to spawn.
           UPROPERTY(EditDefaultsOnly, Category = Projectile)
           TSubclassOf<class AFPSProjectile> ProjectileClass;

   Copy full snippet(5 lines long)

   EditDefaultsOnly means that you will only be able to set the projectile class as a default on the Blueprint, not on each instance of the Blueprint.

5. FPSCharacter.h should look like the following:

   C++

   FPSCharacter.h

   // Copyright Epic Games, Inc. All Rights Reserved.
   
       #pragma once
   
       #include "CoreMinimal.h"
       #include "GameFramework/Character.h"
       #include "Camera/CameraComponent.h"
       #include "Components/CapsuleComponent.h"
       #include "FPSCharacter.generated.h"
   
   
   Expand code Copy full snippet(66 lines long)

Compiling and Checking Your Code

It is now time to compile and check your newly implemented projectile code.

1. Save all of your header and implementation files in Visual Studio.

2. Navigate to the Solution Explorer and select FPSProject.

3. Right-click on FPSProject and select Build to compile your project.

   

   The purpose of this step is to catch any build errors before moving onto the next step. If you encounter any build errors or warnings outside the scope of this tutorial, refer to and the Unreal Engine API Reference.

3.2 - Implementing Shooting

Learn how to implement shooting for your First Person Shooter character.

Implementing the Fire Function

1. Navigate to the FPSCharacter.h class header file.

2. Add the following line to FPSCharacter.h.

   C++

   FPSCharacter.h

   #include "FPSProjectile.h"

   Copy full snippet(1 line long)

3. Navigate to the FPSCharacter.cpp class implementation file.

4. Add the following Fire function definition to FPSCharacter.cpp:

   C++

   FPSCharacter.cpp

   void AFPSCharacter::Fire()
       {
           // Attempt to fire a projectile.
           if (ProjectileClass)
           {
               // Get the camera transform.
               FVector CameraLocation;
               FRotator CameraRotation;
               GetActorEyesViewPoint(CameraLocation, CameraRotation);
   
   
   Expand code Copy full snippet(38 lines long)

5. FPSCharacter.h should now look like the following:

   C++

   FPSCharacter.h

   // Copyright Epic Games, Inc. All Rights Reserved.
   
       #pragma once
   
       #include "CoreMinimal.h"
       #include "GameFramework/Character.h"
       #include "Camera/CameraComponent.h"
       #include "Components/CapsuleComponent.h"
       #include "FPSProjectile.h"
       #include "FPSCharacter.generated.h"
   
   Expand code Copy full snippet(67 lines long)

6. FPSCharacter.cpp should now look like the following:

   C++

   FPSCharacter.cpp

   // Copyright Epic Games, Inc. All Rights Reserved.
   
       #include "FPSCharacter.h"
   
       // Sets default values
       AFPSCharacter::AFPSCharacter()
       {
           // Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
           PrimaryActorTick.bCanEverTick = true;
   
   
   Expand code Copy full snippet(141 lines long)

7. Save FPSCharacter.h and FPSCharacter.cpp in Visual Studio.

8. Navigate to the Solution Explorer and select FPSProject.

9. Right-click on FPSProject and select Build to compile your project.

   

Importing the Projectile Mesh

1. Open Unreal Engine, navigate to the Content Browser and open the Content folder.

2. Right-click inside the file window of the Content Browser to open the Import Asset dialog window.

   Although we cover right-click import, there are three methods to import content. For information about how to import content see Importing Assets Directly:

3. Click Import to /Game... to open the Import dialog window.

   

4. Locate and select the Sphere.fbx mesh file, where you have downloaded this file.

5. Click Open to begin importing the mesh to your project.

6. The FBX Import Options dialog window appears. Clicking Import All adds your mesh to the Project.

   

   Disregard the following error regarding smoothing groups:

   

   This mesh still illustrates the first person mesh setup and it will work with the animations you'll set-up in a later section.

7. Click File in the Main menu panel, select Save all to save your imported mesh.

   

Adding the Projectile's Mesh

1. Open Visual Studio and navigate to the Solution Explorer.

2. In the Solution Explorer open the FPSProjectile.h class header file.

3. Add the following code to FPSProjectile.h under the public access specifier:

   C++

   FPSProjectile.h

   // Projectile mesh
       UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
       UStaticMeshComponent* ProjectileMeshComponent;

   Copy full snippet(3 lines long)

4. Navigate to the Solution Explorer in Visual Studio and open the FPSProjectile.cpp class implementation file.

5. Add the following code to the constructor in FPSProjectile.cpp:

   C++

   FPSProjectile.cpp

   if(!ProjectileMeshComponent)
       {
           ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
           static ConstructorHelpers::FObjectFinder<UStaticMesh>Mesh(TEXT("[ADD STATIC MESH ASSET REFERENCE]"));
           if(Mesh.Succeeded())
           {
               ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
           }
       }

   Copy full snippet(9 lines long)

6. Open the Unreal Editor. navigate to the Content Browser, right-click the Sphere static mesh and select Copy Reference:

   

7. Open Visual Studio, go back to the ProjectileMeshComponent code in FPSProjectile.cpp and replace [ADD STATIC MESH ASSET REFERENCE] with the copied reference. Your code should look similar to the following:

   C++

   FPSProjectile.cpp

   if(!ProjectileMeshComponent)
       {
           ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
           static ConstructorHelpers::FObjectFinder<UStaticMesh>Mesh(TEXT("'/Game/Sphere.Sphere'"));
           if(Mesh.Succeeded())
           {
               ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
           }
       }

   Copy full snippet(9 lines long)

   Your asset reference path may vary depending on where you saved the Sphere mesh in the Content Browser. Also, when you paste in the copied asset reference, the reference contains the asset's type name before the asset's reference path. In your case, you will observe StaticMesh'/Game/Sphere.Sphere'. Make sure to remove the asset's type name (for example, StaticMesh) from the reference path.

8. FPSProjectile.h should look like the following:

   C++

   FPSProjectile.h

   // Copyright Epic Games, Inc. All Rights Reserved.
        
       #pragma once
        
       #include "CoreMinimal.h"
       #include "GameFramework/Actor.h"
       #include "Components/SphereComponent.h"
       #include "GameFramework/ProjectileMovementComponent.h"
       #include "FPSProjectile.generated.h"
        
   
   Expand code Copy full snippet(42 lines long)

9. FPSProjectile.cpp should look like the following:

   C++

   FPSProjectile.cpp

   // Copyright Epic Games, Inc. All Rights Reserved.         
            
       #include "FPSProjectile.h"
            
       // Sets default values
       AFPSProjectile::AFPSProjectile()
       {
           // 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;
            
   
   Expand code Copy full snippet(68 lines long)

10. Save FPSProjectile.h and FPSProjectile.cpp in Visual Studio.

11. Navigate to the Solution Explorer and select FPSProject.

12. Right-click on FPSProject and select Build to compile your project.

    

Adding the Projectile's Material

1. In Visual Studio navigate to the FPSProjectile.h and add the following code to FPSProjectile.h under the public access specifier:

   C++

   FPSProjectile.h

   // Projectile material
        UPROPERTY(VisibleDefaultsOnly, Category = Movement)
        UMaterialInstanceDynamic* ProjectileMaterialInstance;

   Copy full snippet(3 lines long)

2. Navigate to the FPSProjectile.cpp and add the following code to the bottom of the if (!ProjectileMeshComponent) constructor:

   C++

   FPSProjectile.cpp

   static ConstructorHelpers::FObjectFinder<UMaterial>Material(TEXT("[ADD MATERIAL ASSET REFERENCE]"));
       if (Material.Succeeded())
       {
           ProjectileMaterialInstance = UMaterialInstanceDynamic::Create(Material.Object, ProjectileMeshComponent);
       }
       ProjectileMeshComponent->SetMaterial(0, ProjectileMaterialInstance);
       ProjectileMeshComponent->SetRelativeScale3D(FVector(0.09f, 0.09f, 0.09f));
       ProjectileMeshComponent->SetupAttachment(RootComponent);

   Copy full snippet(8 lines long)

3. Open Unreal Engine and navigate to the Content folder of the Content Browser. Right-click in the file window of the Content Browser and select Material.

   

4. Name the new material SphereMaterial.

5. Set up the new material's node graph with properties similar to the following:

   • Base Color: drag off Base Color pin, in the window appears search for and select the Constant3Vector node, set it to (R:1; G:0; B:0)

   • Specular: drag off Specular pin, in the window appears search for and select the Constant node, set its Value to 0.5

   • Emissive Color: drag off Emissive Color, in the window appears search for and select the Constant node, set its Value to 0.05

   

   During this step, you are creating a basic Material asset. If you want to learn how to make more complex materials, read how to use and make Materials.

6. After setting up the new material's node graph, click Save, and navigate to the Content Browser.

   

7. Right-click the Sphere material and select Copy Reference.

   

8. Go back to the ProjectileMeshComponent code in FPSProjectile.cpp and replace [ADD MATERIAL ASSET REFERENCE] with the copied reference. Your code should look similar to the following:

   C++

   FPSProjectile.cpp

   static ConstructorHelpers::FObjectFinder<UMaterial>Material(TEXT("'/Game/SphereMaterial.SphereMaterial'"));
       if (Material.Succeeded())
       {
           ProjectileMaterialInstance = UMaterialInstanceDynamic::Create(Material.Object, ProjectileMeshComponent);
       }
       ProjectileMeshComponent->SetMaterial(0, ProjectileMaterialInstance);
       ProjectileMeshComponent->SetRelativeScale3D(FVector(0.09f, 0.09f, 0.09f));
       ProjectileMeshComponent->SetupAttachment(RootComponent);

   Copy full snippet(8 lines long)

   Your asset reference path may vary depending on where you saved the Sphere material in the Content Browser. Also, when you paste in the copied asset reference, the reference contains the asset's type name before the asset's reference path. In our case, you will observe Material'/Game/Sphere.Sphere'. Make sure to remove the asset's type name (for example, Material) from the reference path.

9. FPSProjectile.h should look like the following:

   C++

   FPSProjectile.h

   // Copyright Epic Games, Inc. All Rights Reserved.
            
       #pragma once
            
       #include "CoreMinimal.h"
       #include "GameFramework/Actor.h"
       #include "Components/SphereComponent.h"
       #include "GameFramework/ProjectileMovementComponent.h"
       #include "FPSProjectile.generated.h"
            
   
   Expand code Copy full snippet(46 lines long)

10. FPSProjectile.cpp should look like the following:

    C++

    FPSProjectile.cpp

    // Copyright Epic Games, Inc. All Rights Reserved.     
         
        #include "FPSProjectile.h"
         
        // Sets default values
        AFPSProjectile::AFPSProjectile()
        {
            // 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;
         
    
    Expand code Copy full snippet(77 lines long)

11. Open UE, navigate to the Blueprints folder in the Content Browser and open the BP_FPSCharacter file.

    

12. Open the Full Blueprint Editor (if necessary), navigate to Components panel and select BP_FPSCharacter (Self) component.

    

13. Navigate to the Detail panel in the opened Blueprint Editor.

14. Find the Projectile section, and in the dropdown next to Projectile Class, select FPSProjectile.

    

    If you can't find the FPSProjectile in the opened dropdown menu, please rerun Unreal Engine.

15. Click Compile and Save buttons.

    

16. Open the Visual Studio, navigate to the Solution Explorer and select FPSProject.

17. Right-click on FPSProject and select Build to compile your project.

    

18. Run the game in PIE mode to verify that the Static Mesh and Material are being spawned in the scene.

    While firing the projectiles, you will observe in the Outliner that the number of projectiles keeps increasing because they have no defined lifespan.

    

    In the next section, tutorial shows you how to define the projectile's initial lifespan.

3.3 - Setting up Projectile Collision and Lifetime

Currently, our projectiles:

• Live forever (they never disappear from the Scene Outliner)

• Don't collide with other objects in the world

During this step, you are going to set up projectile collision and lifetime.

Limiting the Projectile's Life Span

1. Open the Visual Studio and navigate to the Solution Explorer.

2. In the Solution Explorer open the FPSProjectile.cpp class implementation file.

3. Add the following code to the AFPSProjectile::AFPSProjectile() constructor of the FPSProjectile.cpp to set the projectile's lifespan:

   C++

   FPSProjectile.cpp

   // Delete the projectile after 3 seconds.
       InitialLifeSpan = 3.0f;

   Copy full snippet(2 lines long)

4. FPSProjectile.cpp should look like the following:

   C++

   FPSProjectile.cpp

   // Copyright Epic Games, Inc. All Rights Reserved.
                     
       #include "FPSProjectile.h"
            
       // Sets default values
       AFPSProjectile::AFPSProjectile()
       {
           // 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;
            
   
   Expand code Copy full snippet(80 lines long)

5. Save your file.

6. Navigate to the Solution Explorer and select FPSProject.

7. Right-click on FPSProject and select Build to compile your project.

   

8. To verify that the projectiles are being destroyed after three seconds, run the game in PIE mode.

   As verified in the Outliner, every spawned projectile will disappear from the scene after three seconds.

Editing the Projectile's Collision Settings

Unreal Engine comes packaged with several preset collision channels; however, the Engine also provides customizable channels that game projects can use.

1. To create a custom collision channel, navigate to Unreal Engine and open Project Settings, select the Engine heading on the left side and select Collision, expand Preset section on the right side.

   

2. Navigate to the Object Channels and select New Object Channel... to create a new collision channel. Name your new collision channel Projectile and verify that the Default Response is set to Block before clicking Accept.

   

3. Select New... under Preset and name your new profile Projectile. Reference the following image to set your collision presets and click Accept.

   

Using the New Collision Channel's Settings

1. Open the Visual Studio and navigate to the FPSProjectile.cpp class implementation file.

2. In the FPSProjectile constructor, add the following line to the if (!CollisionComponent) block, after CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));:

   C++

   FPSProjectile.cpp

   // Set the sphere's collision profile name to "Projectile".
       CollisionComponent->BodyInstance.SetCollisionProfileName(TEXT("Projectile"));

   Copy full snippet(2 lines long)

3. FPSProjectile.cpp should now look like the following:

   C++

   FPSProjectile.cpp

   // Copyright Epic Games, Inc. All Rights Reserved.
   
       #include "FPSProjectile.h"
   
       // Sets default values
       AFPSProjectile::AFPSProjectile()
       {
           // 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;
   
   
   Expand code Copy full snippet(81 lines long)

4. Save your file.

5. Navigate to the Solution Explorer and select FPSProject.

6. Right-click on FPSProject and select Build to compile your project.

   

3.4 - Getting Projectiles to Interact with the World

Now that you can detect the projectile's collision interactions, you can determine how to respond to those collisions. During this step, you will add an OnHit function to FPSProjectile that'll respond to collision events.

Getting Projectiles to React to Collisions

1. Open FPSProjectile.h.

2. Add the following code to FPSProjectile.h under the public access specifier:

   C++

   FPSProjectile.h

   // Function that is called when the projectile hits something.
       UFUNCTION()
       void OnHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComponent, FVector NormalImpulse, const FHitResult& Hit);

   Copy full snippet(3 lines long)

3. FPSProjectile.h should now look like the following:

   C++

   FPSProjectile.h

   // Copyright Epic Games, Inc. All Rights Reserved.
        
       #pragma once
        
       #include "CoreMinimal.h"
       #include "GameFramework/Actor.h"
       #include "Components/SphereComponent.h"
       #include "GameFramework/ProjectileMovementComponent.h"
       #include "FPSProjectile.generated.h"
        
   
   Expand code Copy full snippet(50 lines long)

4. Open FPSProjectile.cpp to add the following code:

   C++

   FPSProjectile.cpp

   // Function that is called when the projectile hits something.
       void AFPSProjectile::OnHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComponent, FVector NormalImpulse, const FHitResult& Hit)
       {
           if (OtherActor != this && OtherComponent->IsSimulatingPhysics())
           {
               OtherComponent->AddImpulseAtLocation(ProjectileMovementComponent->Velocity * 100.0f, Hit.ImpactPoint);
           }
           Destroy();
       }

   Copy full snippet(9 lines long)

5. In the FPSProjectile constructor, add the following line to the if (!CollisionComponent) block, after BodyInstance.SetCollisionProfileName:

   C++

   FPSProjectile.cpp

   // Event called when component hits something.
       CollisionComponent->OnComponentHit.AddDynamic(this, &AFPSProjectile::OnHit);

   Copy full snippet(2 lines long)

6. FPSProjectile.cpp should now look like the following:

   C++

   FPSProjectile.cpp

   // Copyright Epic Games, Inc. All Rights Reserved.
   
       #include "FPSProjectile.h"
   
       // Sets default values
       AFPSProjectile::AFPSProjectile()
       {
           // 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;
   
   
   Expand code Copy full snippet(93 lines long)

Testing Projectile Collision

1. Save your files in Visual Studio.

2. Navigate to the Solution Explorer and select FPSProject.

3. Right-click on FPSProject and select Build to compile your project.

   

4. After the build finishes, go back to your FPSProject in the Unreal Editor.

5. Navigate to the Outliner and select the Floor Static Mesh.

   

6. Copy and paste selected Floor mesh.

7. Making sure that the ratio lock is unlocked (the lock icon next to the Scale row), set options of the Transform section in the Detail panel of the Floor2 as following:

   • Location: (0.0, 0.0, 150);

   • Rotation: (0.0, 0.0, 0.0);

   • Scale: (0.2, 0.2, 3.0).

8. Scroll down to the Physics section and check the Simulate Physics box.

   

9. Click the File in the Main menu panel and select Save All to save your imported mesh.

   

10. Click the Play button in the Level Editor Toolbar.

11. To verify that projectiles are colliding with the cube, left-click your mouse button to fire projectiles and move the cube around your level.

    Congratulations, your projectiles are complete!

12. Press the Shift + Escape or click Stop in the Level Editor Toolbar to exit PIE mode.

3.5 - Adding Crosshairs to your Viewport

During this step, you will add a crosshair HUD element to our game so that you can aim our projectiles.

Importing a Crosshair Asset

1. Navigate to the Content Browser and open the Content folder.

2. Right-click inside the file window of the Content Browser to open the Import Asset dialog window.

3. Click 'Import to / Game...' to open the Import dialog window.

   

4. Locate and select the crosshair.TGA image file, where you have downloaded this file.

5. Click Open to begin importing the image file to your project.

6. Click the File in the Main menu panel to save your imported mesh.

   

Adding a New HUD Class

1. Click the Tools in the Main menu panel, New C++ Class... to choose your new parent class.

2. The Choose Parent Class menu appears. Select HUD as the parent class and click Next.

   

3. Name the new class FPSHUD, then click Create Class.

   

4. The Visual Studio appears automatically with opened FPSHUD.h header file and FPSHUD.cpp implementation file, when C++ class will be created.

5. Navigate to the FPSHUD.h class header file, and add the following variable under the protected access specifier:

   C++

   FPSHUD.h

   protected:
   		
           // This will be drawn at the center of the screen.
           UPROPERTY(EditDefaultsOnly)
           UTexture2D* CrosshairTexture;

   Copy full snippet(5 lines long)

6. Add the following function declaration in FPSHUD.h under the public access specifier:

   C++

   FPSHUD.h

   public:
   		
           // Primary draw call for the HUD.
           virtual void DrawHUD() override;

   Copy full snippet(4 lines long)

7. Add the following header file to FPSHUD.h:

   C++

   FPSHUD.h

   #include "Engine/Canvas.h"

   Copy full snippet(1 line long)

8. FPSHUD.h should now look like the following:

   C++

   FPSHUD.h

   // Copyright Epic Games, Inc. All Rights Reserved.
            
       #pragma once
            
       #include "CoreMinimal.h"
       #include "GameFramework/HUD.h"
       #include "Engine/Canvas.h"
       #include "FPSHUD.generated.h"
            
       /**
   
   Expand code Copy full snippet(26 lines long)

9. Open the FPSHUD.cpp implementation file and add the DrawHUD function:

   C++

   FPSHUD.cpp

   void AFPSHUD::DrawHUD()
       {
           Super::DrawHUD();
   
           if (CrosshairTexture)
           {
               // Find the center of our canvas.
               FVector2D Center(Canvas->ClipX * 0.5f, Canvas->ClipY * 0.5f);
   
               // Offset by half of the texture's dimensions so that the center of the texture aligns with the center of the Canvas.
   
   Expand code Copy full snippet(18 lines long)

10. Save FPSHUD.h and FPSHUD.cpp in Visual Studio.

11. Navigate to the Solution Explorer and select FPSProject.

12. Right-click on FPSProject and select Build to compile your project.

    

Extending your CPP HUD Class to Blueprints

Now is a good time to extend the CPP HUD class to Blueprints. If you need a refresher, go to our C++ and Blueprints reference page to learn more about extending C++ classes to Blueprints.

1. Right-click the FPSHUD class to open the C++ Class Actions menu.

2. Click Create Blueprint class based on FPSHUD to open the Add Blueprint Class dialog menu.

   

3. Name your new Blueprint Class BP_FPSHUD and choose the Blueprints folder before clicking the Create Blueprint Class button.

   

4. By now, you should have a newly created BP_FPSHUD Blueprint Class located inside of the Blueprints folder.

   

5. Make sure to save your BP_FPSHUD Blueprint before closing the Blueprint Editor.

Setting the Default HUD Class

1. Click the Edit in the Main menu panel, select Project Settings.

2. Under the Project heading on the left side of the Project Settings tab, click on Maps & Modes.

3. Select BP_FPSHUD in the Default HUD dropdown menu.

   

4. Close the Project Settings menu.

5. Go back and open the BP_FPSHUD in the Blueprint Editor.

6. Now, click on the dropdown menu located in the FPSHUD section of the Blueprint Editor to select your crosshair texture.

   

7. Finally, Compile and Save the BP_FPSHUD Blueprint before closing the Blueprint Editor.

Verifying your HUD

1. Click the Play button in the Level Editor Toolbar. You should now be able to aim the projectiles with your newly added crosshair.

2. Press the Shift + Escape or click Stop in the Level Editor Toolbar to exit PIE mode.

Finished Section Code

// Copyright Epic Games, Inc. All Rights Reserved.
         
        #pragma once
         
        #include "CoreMinimal.h"
        #include "GameFramework/Actor.h"
        #include "Components/SphereComponent.h"
        #include "GameFramework/ProjectileMovementComponent.h"
        #include "FPSProjectile.generated.h"
         

// Copyright Epic Games, Inc. All Rights Reserved.         
         
        #include "FPSProjectile.h"
         
        // Sets default values
        AFPSProjectile::AFPSProjectile()
        {
            // 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;
         

// Copyright Epic Games, Inc. All Rights Reserved.
         
        #pragma once
         
        #include "CoreMinimal.h"
        #include "GameFramework/Character.h"
        #include "Camera/CameraComponent.h"
        #include "Components/CapsuleComponent.h"
        #include "FPSProjectile.h"
        #include "FPSCharacter.generated.h"

// Copyright Epic Games, Inc. All Rights Reserved.         
         
        #include "FPSCharacter.h"
         
        // Sets default values
        AFPSCharacter::AFPSCharacter()
        {
            // Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
            PrimaryActorTick.bCanEverTick = true;
         

// Copyright Epic Games, Inc. All Rights Reserved.
         
        #pragma once
         
        #include "CoreMinimal.h"
        #include "GameFramework/HUD.h"
        #include "Engine/Canvas.h"
        #include "FPSHUD.generated.h"
         
        /**

// Copyright Epic Games, Inc. All Rights Reserved.         
         
        #include "FPSHUD.h"
         
        void AFPSHUD::DrawHUD()
        {
            Super::DrawHUD();
         
            if (CrosshairTexture)
            {

Congratulations! You've learned how to:

✓ Add Projectiles to your Game
✓ Implement Shooting
✓ Set-up Projectile Collision and Lifetime
✓ Get your Projectiles to Interact with the World
✓ Add Crosshairs to your Viewport

You're now ready to learn how to animate your character in the next section.