Unreal Engine で発射物を実装する | Unreal Engine 5.1 ドキュメンテーション

このセクションを終了すると、このような画面になります。

目的

このセクションでは、ファーストパーソンシューターゲームに発射物を実装する方法を説明します。

目的

このチュートリアルのこのセクションを完了すると、次のことができるようになります。

発射物をゲームに追加する
シューティングを実装する
発射物のコリジョンと存続期間を設定する
発射物をワールドとインタラクトさせる
照準線をビューポートに追加する

ステップ

3.1 - 発射物をゲームに追加する
3.2 - シューティングを実装する
3.3 - 発射物のコリジョンと存続期間を設定する
3.4 - 発射物をワールドとインタラクトさせる
3.5 - 照準線をビューポートに追加する

3.1 - 発射物をゲームに追加する

キャラクターの設定が完了したので、発射される武器を実装します。手りゅう弾のような単純な発射物を画面の中央から発射し、ワールドに衝突するまで飛び続けるようにプログラムします。このステップでは、入力を追加し、発射物の新しいクラスのコードを作成します。

Fire アクションマッピングを追加する

メイン メニューパネルで [Edit (編集)] をクリックし、[Project Settings (プロジェクト設定)] を選択します。
[Project Settings] タブの左側にある [Engine (エンジン)] セクションで、[Input (インプット)] をクリックします。
右側にある [Bindings (バインディング)] で、[Action Mappings (アクションマッピング)] の隣にある [+ (プラス)] 記号をクリックします。
[Action Mappings] の左側にある矢印をクリックします。
表示されるテキストフィールドに「Fire」と入力します。
ドロップダウンメニューで、[Left Mouse Button (マウスの左ボタン)] を [Mouse (マウス)] ドロップダウンリストから選択します。
ここでの入力設定は次のようになります。

クリックしてフルサイズで表示

[Project Settings] メニューを閉じます。

発射物クラスを追加する

[Tools (ツール)] を メイン メニューパネルでクリックし、[New C++ Class... (新規 C++ クラス...)] を選択します。
[Choose Parent Class (親クラスを選択)] ウィンドウが表示されます。[Actor (アクタ)] を親クラスとして選択し、[Next (次へ)] をクリックします。

クリックしてフルサイズで表示

新規クラスに「FPSProjectile」という名前を付けてから、[Create Class (クラスを作成)] をクリックします。

クリックしてフルサイズで表示

USphere コンポーネントを追加する

C++ クラスが作成されると、Visual Studio が自動的に、FPSProjectile.h ヘッダファイルと FPSProjectile.cpp 実装ファイルが開いた状態で表示されます。
FPSProjectile.h クラスヘッダファイルに移動します。
SphereComponent ヘッダファイルを追加します。

FPSProjectile.h

	
			#include "Components/SphereComponent.h"

USphereComponent への参照を FPSProjectile インターフェースに追加するには、次のコードを public アクセス指定子の FPSProjectile.h に追加します。

FPSProjectile.h

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

FPSProjectile.h は次のようになります。

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()
			class FPSPROJECT_API AFPSProjectile : public AActor
			{
				GENERATED_BODY()
	
			public:
				// Sets default values for this actor's properties
				AFPSProjectile();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
			public:
				// Called every frame
				virtual void Tick( float DeltaTime ) override;
	
				// Sphere collision component
				UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
				USphereComponent* CollisionComponent;
			};

FPSProjectile.cpp クラス用の実装ファイルに移動します。
次のコードを AFPSProjectile コンストラクタの PrimaryActorTick.bcanEverTick の後 (FPSProjectile.cpp 内) に追加します。

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.
				CollisionComponent->InitSphereRadius(15.0f);
				// Set the root component to be the collision component.
				RootComponent = CollisionComponent;
			}

シミュレーションで動かすため、CollisionComponent を RootComponent にしています。

FPSProjectile.cpp は次のようになります。

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)
				{
					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.
					CollisionComponent->InitSphereRadius(15.0f);
					// Set the root component to be the collision component.
					RootComponent = CollisionComponent;
				}
			}
	
			// Called when the game starts or when spawned
			void AFPSProjectile::BeginPlay()
			{
				Super::BeginPlay();
	
			}
	
			// Called every frame
			void AFPSProjectile::Tick( float DeltaTime )
			{
				Super::Tick( DeltaTime );
	
			}

発射物移動コンポーネントを追加する

FPSProjectile.h クラスヘッダファイルに移動します。
ProjectileMovementComponent ヘッダファイルを追加します。

FPSProjectile.h

	
			#include "GameFramework/ProjectileMovementComponent.h"

次のコードを FPSProjectile.h の public アクセス指定子の下に追加します。

FPSProjectile.h

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

FPSProjectile.h は次のようになります。

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"
	
			UCLASS()
			class FPSPROJECT_API AFPSProjectile : public AActor
			{
				GENERATED_BODY()
	
			public:
				// Sets default values for this actor's properties
				AFPSProjectile();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
			public:
				// Called every frame
				virtual void Tick( float DeltaTime ) override;
	
				// Sphere collision component.
				UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
				USphereComponent* CollisionComponent;
	
				// Projectile movement component.
				UPROPERTY(VisibleAnywhere, Category = Movement)
				UProjectileMovementComponent* ProjectileMovementComponent;
			};

FPSProjectile.cpp クラス用の実装ファイルに移動します。
次のコード行を AFPSProjectile コンストラクタ (FPSProjectile.cpp 内) に追加します。

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;
				ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
			}

FPSProjectile.cpp は次のようになります。

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)
				{
					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.
					CollisionComponent->InitSphereRadius(15.0f);
					// Set the root component to be the collision component.
					RootComponent = CollisionComponent;
				}
	
				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;
					ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
				}
			}
	
			// Called when the game starts or when spawned
			void AFPSProjectile::BeginPlay()
			{
				Super::BeginPlay();
	
			}
	
			// Called every frame
			void AFPSProjectile::Tick( float DeltaTime )
			{
				Super::Tick( DeltaTime );
	
			}

発射物の初期速度を設定する

FPSProjectile.h クラスヘッダファイルに移動します。
次の関数宣言を FPSProjectile.h の public アクセス指定子の下に追加します。

FPSProjectile.h

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

この関数では物体の発射を処理します。

FPSProjectile.h は次のようになります。

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"
	
			UCLASS()
			class FPSPROJECT_API AFPSProjectile : public AActor
			{
				GENERATED_BODY()
	
			public:
				// Sets default values for this actor's properties
				AFPSProjectile();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
			public:
				// Called every frame
				virtual void Tick( float DeltaTime ) override;
	
				// Sphere collision component.
				UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
				USphereComponent* CollisionComponent;
	
				// Projectile movement component.
				UPROPERTY(VisibleAnywhere, Category = Movement)
				UProjectileMovementComponent* ProjectileMovementComponent;
	
				// Function that initializes the projectile's velocity in the shoot direction.
				void FireInDirection(const FVector& ShootDirection);
			};

FPSProjectile.cpp クラス用の実装ファイルに移動します。
次の関数定義を FPSProjectile.cpp に追加します。

FPSProjectile.cpp

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

ここでは発射方向を指定するだけです。発射物の速度は ProjectileMovementComponent で定義されているからです。

FPSProjectile.cpp は次のようになります。

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)
				{
					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.
					CollisionComponent->InitSphereRadius(15.0f);
					// Set the root component to be the collision component.
					RootComponent = CollisionComponent;
				}
	
				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;
					ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
				}
			}
	
			// Called when the game starts or when spawned
			void AFPSProjectile::BeginPlay()
			{
				Super::BeginPlay();
	
			}
	
			// Called every frame
			void AFPSProjectile::Tick( float DeltaTime )
			{
				Super::Tick( DeltaTime );
	
			}
	
			// Function that initializes the projectile's velocity in the shoot direction.
			void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
			{
				ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
			}

発射の入力アクションをバインドする

Visual Studio の [Solution Explorer (ソリューションエクスプローラー)] に移動し、FPSCharacter.h クラスヘッダファイルを開きます。
次の関数宣言を FPSCharacter.h の public アクセス指定子の下に追加します。

FPSCharacter.h

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

FPSCharacter.h は次のようになります。

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"
	
			UCLASS()
			class FPSPROJECT_API AFPSCharacter : public ACharacter
			{
				GENERATED_BODY()
	
			public:
				// Sets default values for this character's properties
				AFPSCharacter();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
			public:
				// Called every frame
				virtual void Tick( float DeltaTime ) override;
	
				// Called to bind functionality to input
				virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
	
				// Handles input for moving forward and backward.
				UFUNCTION()
				void MoveForward(float Value);
	
				// Handles input for moving right and left.
				UFUNCTION()
				void MoveRight(float Value);
	
				// Sets jump flag when key is pressed.
				UFUNCTION()
				void StartJump();
	
				// Clears jump flag when key is released.
				UFUNCTION()
				void StopJump();
	
				// FPS camera
				UPROPERTY(VisibleAnywhere)
				UCameraComponent* FPSCameraComponent;
	
				// First-person mesh (arms), visible only to the owning player.
				UPROPERTY(VisibleDefaultsOnly, Category = Mesh)
				USkeletalMeshComponent* FPSMesh;
	
				// Function that handles firing projectiles.
				UFUNCTION()
				void Fire();
			};

// 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"
	
			UCLASS()
			class FPSPROJECT_API AFPSCharacter : public ACharacter
			{
				GENERATED_BODY()
	
			public:
				// Sets default values for this character's properties
				AFPSCharacter();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
			public:
				// Called every frame
				virtual void Tick( float DeltaTime ) override;
	
				// Called to bind functionality to input
				virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
	
				// Handles input for moving forward and backward.
				UFUNCTION()
				void MoveForward(float Value);
	
				// Handles input for moving right and left.
				UFUNCTION()
				void MoveRight(float Value);
	
				// Sets jump flag when key is pressed.
				UFUNCTION()
				void StartJump();
	
				// Clears jump flag when key is released.
				UFUNCTION()
				void StopJump();
	
				// FPS camera
				UPROPERTY(VisibleAnywhere)
				UCameraComponent* FPSCameraComponent;
	
				// First-person mesh (arms), visible only to the owning player.
				UPROPERTY(VisibleDefaultsOnly, Category = Mesh)
				USkeletalMeshComponent* FPSMesh;
	
				// Function that handles firing projectiles.
				UFUNCTION()
				void Fire();
			};

Visual Studio の [Solution Explorer] に移動し、FPSCharacter.cpp クラス用の実装ファイルを開きます。
Fire 関数をバインドするには、次のコードを FPSCharacter.cpp: の SetupPlayerInputComponent 関数に追加します。

FPSCharacter.cpp

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

次の関数定義を FPSCharacter.cpp に追加します。

FPSCharacter.cpp

	
			void AFPSCharacter::Fire()
			{
			}

FPSCharacter.cpp は次のようになります。

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;
	
				// Create a first person camera component.
				FPSCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
				check(FPSCameraComponent != nullptr);
	
				// Attach the camera component to our capsule component.
				FPSCameraComponent->SetupAttachment(CastChecked<USceneComponent, UCapsuleComponent>(GetCapsuleComponent()));
	
				// Position the camera slightly above the eyes.
				FPSCameraComponent->SetRelativeLocation(FVector(0.0f, 0.0f, 50.0f + BaseEyeHeight));
	
				// Enable the pawn to control camera rotation.
				FPSCameraComponent->bUsePawnControlRotation = true;
	
				// Create a first person mesh component for the owning player.
				FPSMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));
				check(FPSMesh != nullptr);
	
				// Only the owning player sees this mesh.
				FPSMesh->SetOnlyOwnerSee(true);
	
				// Attach the FPS mesh to the FPS camera.
				FPSMesh->SetupAttachment(FPSCameraComponent);
	
				// Disable some environmental shadowing to preserve the illusion of having a single mesh.
				FPSMesh->bCastDynamicShadow = false;
				FPSMesh->CastShadow = false;
	
				// The owning player doesn't see the regular (third-person) body mesh.
				GetMesh()->SetOwnerNoSee(true);
			}
	
			// Called when the game starts or when spawned
			void AFPSCharacter::BeginPlay()
			{
				Super::BeginPlay();
	
				check(GEngine != nullptr);
	
				// Display a debug message for five seconds.
				// The -1 "Key" value argument prevents the message from being updated or refreshed.
				GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("We are using FPSCharacter."));
			}
	
			// Called every frame
			void AFPSCharacter::Tick( float DeltaTime )
			{
				Super::Tick( DeltaTime );
	
			}
	
			// Called to bind functionality to input
			void AFPSCharacter::SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent)
			{
				Super::SetupPlayerInputComponent(PlayerInputComponent);
	
				// Set up "movement" bindings.
				PlayerInputComponent->BindAxis("MoveForward", this, &AFPSCharacter::MoveForward);
				PlayerInputComponent->BindAxis("MoveRight", this, &AFPSCharacter::MoveRight);
	
				// Set up "look" bindings.
				PlayerInputComponent->BindAxis("Turn", this, &AFPSCharacter::AddControllerYawInput);
				PlayerInputComponent->BindAxis("LookUp", this, &AFPSCharacter::AddControllerPitchInput);
	
				// Set up "action" bindings.
				PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &AFPSCharacter::StartJump);
				PlayerInputComponent->BindAction("Jump", IE_Released, this, &AFPSCharacter::StopJump);
				PlayerInputComponent->BindAction("Fire", IE_Pressed, this, &AFPSCharacter::Fire);
			}
	
			void AFPSCharacter::MoveForward(float Value)
			{
				// Find out which way is "forward" and record that the player wants to move that way.
				FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::X);
				AddMovementInput(Direction, Value);
			}
	
			void AFPSCharacter::MoveRight(float Value)
			{
				// Find out which way is "right" and record that the player wants to move that way.
				FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::Y);
				AddMovementInput(Direction, Value);
			}
	
			void AFPSCharacter::StartJump()
			{
				bPressedJump = true;
			}
	
			void AFPSCharacter::StopJump()
			{
				bPressedJump = false;
			}
	
			void AFPSCharacter::Fire()
			{
			}

// 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;
	
				// Create a first person camera component.
				FPSCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
				check(FPSCameraComponent != nullptr);
	
				// Attach the camera component to our capsule component.
				FPSCameraComponent->SetupAttachment(CastChecked<USceneComponent, UCapsuleComponent>(GetCapsuleComponent()));
	
				// Position the camera slightly above the eyes.
				FPSCameraComponent->SetRelativeLocation(FVector(0.0f, 0.0f, 50.0f + BaseEyeHeight));
	
				// Enable the pawn to control camera rotation.
				FPSCameraComponent->bUsePawnControlRotation = true;
	
				// Create a first person mesh component for the owning player.
				FPSMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));
				check(FPSMesh != nullptr);
	
				// Only the owning player sees this mesh.
				FPSMesh->SetOnlyOwnerSee(true);
	
				// Attach the FPS mesh to the FPS camera.
				FPSMesh->SetupAttachment(FPSCameraComponent);
	
				// Disable some environmental shadowing to preserve the illusion of having a single mesh.
				FPSMesh->bCastDynamicShadow = false;
				FPSMesh->CastShadow = false;
	
				// The owning player doesn't see the regular (third-person) body mesh.
				GetMesh()->SetOwnerNoSee(true);
			}
	
			// Called when the game starts or when spawned
			void AFPSCharacter::BeginPlay()
			{
				Super::BeginPlay();
	
				check(GEngine != nullptr);
	
				// Display a debug message for five seconds.
				// The -1 "Key" value argument prevents the message from being updated or refreshed.
				GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("We are using FPSCharacter."));
			}
	
			// Called every frame
			void AFPSCharacter::Tick( float DeltaTime )
			{
				Super::Tick( DeltaTime );
	
			}
	
			// Called to bind functionality to input
			void AFPSCharacter::SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent)
			{
				Super::SetupPlayerInputComponent(PlayerInputComponent);
	
				// Set up "movement" bindings.
				PlayerInputComponent->BindAxis("MoveForward", this, &AFPSCharacter::MoveForward);
				PlayerInputComponent->BindAxis("MoveRight", this, &AFPSCharacter::MoveRight);
	
				// Set up "look" bindings.
				PlayerInputComponent->BindAxis("Turn", this, &AFPSCharacter::AddControllerYawInput);
				PlayerInputComponent->BindAxis("LookUp", this, &AFPSCharacter::AddControllerPitchInput);
	
				// Set up "action" bindings.
				PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &AFPSCharacter::StartJump);
				PlayerInputComponent->BindAction("Jump", IE_Released, this, &AFPSCharacter::StopJump);
				PlayerInputComponent->BindAction("Fire", IE_Pressed, this, &AFPSCharacter::Fire);
			}
	
			void AFPSCharacter::MoveForward(float Value)
			{
				// Find out which way is "forward" and record that the player wants to move that way.
				FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::X);
				AddMovementInput(Direction, Value);
			}
	
			void AFPSCharacter::MoveRight(float Value)
			{
				// Find out which way is "right" and record that the player wants to move that way.
				FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::Y);
				AddMovementInput(Direction, Value);
			}
	
			void AFPSCharacter::StartJump()
			{
				bPressedJump = true;
			}
	
			void AFPSCharacter::StopJump()
			{
				bPressedJump = false;
			}
	
			void AFPSCharacter::Fire()
			{
			}

発射物のスポーン位置を定義する

FPSProjectile アクタをスポーンする際に、OnFire 関数の実装に関して、次の 2 点の考慮事項があります。
- 発射物をスポーンする場所。
- 発射物クラス (FPSCharacter とその派生ブループリントがスポーンする発射物の種類を認識するため)。

カメラ空間のオフセットベクターを使用して、発射物のスポーン位置を決定します。このパラメータを編集可能にして、BP_FPSCharacter ブループリントで設定し調整できるようにします。最終的に、このデータに基づいて発射物の初期位置を計算できます。

FPSCharacter.h クラスヘッダファイルに移動します。
次のコードを FPSCharacter.h の public アクセス指定子の下に追加します。

FPSCharacter.h

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

EditAnywhere により、ブループリントエディタのデフォルトモード内、またはキャラクターのいずれかのインスタンスの [Details (詳細)] タブで、銃口オフセットの値を変更できます。BlueprintReadWrite 指定子により、ブループリント内で銃口オフセットの値を取得、設定できます。

次のコードを FPSCharacter.h の protected アクセス指定子の下に追加します。

FPSCharacter.h

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

EditDefaultsOnly の意味は、発射物クラスをブループリントでデフォルトとして設定できるだけで、ブループリントの各インスタンスではできないということです。

FPSCharacter.h は次のようになります。

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"
	
			UCLASS()
			class FPSPROJECT_API AFPSCharacter : public ACharacter
			{
				GENERATED_BODY()
	
			public:
				// Sets default values for this character's properties
				AFPSCharacter();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
				// Projectile class to spawn.
				UPROPERTY(EditDefaultsOnly, Category = Projectile)
				TSubclassOf<class AFPSProjectile> ProjectileClass;
	
			public:
				// Called every frame
				virtual void Tick( float DeltaTime ) override;
	
				// Called to bind functionality to input
				virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
	
				// Handles input for moving forward and backward.
				UFUNCTION()
				void MoveForward(float Value);
	
				// Handles input for moving right and left.
				UFUNCTION()
				void MoveRight(float Value);
	
				// Sets jump flag when key is pressed.
				UFUNCTION()
				void StartJump();
	
				// Clears jump flag when key is released.
				UFUNCTION()
				void StopJump();
	
				// Function that fires projectiles.
				UFUNCTION()
				void Fire();
	
				// FPS camera
				UPROPERTY(VisibleAnywhere)
				UCameraComponent* FPSCameraComponent;
	
				// First-person mesh (arms), visible only to the owning player.
				UPROPERTY(VisibleDefaultsOnly, Category = Mesh)
				USkeletalMeshComponent* FPSMesh;
	
				// Gun muzzle offset from the camera location.
				UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay)
				FVector MuzzleOffset;
			};

// 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"
	
			UCLASS()
			class FPSPROJECT_API AFPSCharacter : public ACharacter
			{
				GENERATED_BODY()
	
			public:
				// Sets default values for this character's properties
				AFPSCharacter();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
				// Projectile class to spawn.
				UPROPERTY(EditDefaultsOnly, Category = Projectile)
				TSubclassOf<class AFPSProjectile> ProjectileClass;
	
			public:
				// Called every frame
				virtual void Tick( float DeltaTime ) override;
	
				// Called to bind functionality to input
				virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
	
				// Handles input for moving forward and backward.
				UFUNCTION()
				void MoveForward(float Value);
	
				// Handles input for moving right and left.
				UFUNCTION()
				void MoveRight(float Value);
	
				// Sets jump flag when key is pressed.
				UFUNCTION()
				void StartJump();
	
				// Clears jump flag when key is released.
				UFUNCTION()
				void StopJump();
	
				// Function that fires projectiles.
				UFUNCTION()
				void Fire();
	
				// FPS camera
				UPROPERTY(VisibleAnywhere)
				UCameraComponent* FPSCameraComponent;
	
				// First-person mesh (arms), visible only to the owning player.
				UPROPERTY(VisibleDefaultsOnly, Category = Mesh)
				USkeletalMeshComponent* FPSMesh;
	
				// Gun muzzle offset from the camera location.
				UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay)
				FVector MuzzleOffset;
			};

コードをコンパイルしてチェックする

ここで、新しく実装した発射物コードをコンパイルしてチェックします。

すべてのヘッダおよび実装ファイルを Visual Studio で保存します。
[Solution Explorer] に移動して [FPSProject] を選択します。
[FPSProject] を右クリックして [Build (ビルド)] を選択し、プロジェクトをコンパイルします。

このステップの目的は、次のステップに進む前に、何らかのビルドエラーを検出することです。このチュートリアルの範囲を超えるビルドエラーや警告が発生した場合は、「 (コーディング標準)」や「Unreal Engine API リファレンス」を参照してください。

3.2 - シューティングを実装する

ファーストパーソンシューターキャラクターのシューティングを実装する方法を習得します。

Fire 関数を実装する

FPSCharacter.h クラスヘッダファイルに移動します。
次のコード行を FPSCharacter.h に追加します。

FPSCharacter.h

	
			#include "FPSProjectile.h"

FPSCharacter.cpp クラス用の実装ファイルに移動します。
次の Fire 関数定義を FPSCharacter.cpp に追加します。

FPSCharacter.cpp

	
			void AFPSCharacter::Fire()
			{
				// Attempt to fire a projectile.
				if (ProjectileClass)
				{
					// Get the camera transform.
					FVector CameraLocation;
					FRotator CameraRotation;
					GetActorEyesViewPoint(CameraLocation, CameraRotation);
	
					// Set MuzzleOffset to spawn projectiles slightly in front of the camera.
					MuzzleOffset.Set(100.0f, 0.0f, 0.0f);
	
					// Transform MuzzleOffset from camera space to world space.
					FVector MuzzleLocation = CameraLocation + FTransform(CameraRotation).TransformVector(MuzzleOffset);
	
					// Skew the aim to be slightly upwards.
					FRotator MuzzleRotation = CameraRotation;
					MuzzleRotation.Pitch += 10.0f;
	
					UWorld* World = GetWorld();
					if (World)
					{
						FActorSpawnParameters SpawnParams;
						SpawnParams.Owner = this;
						SpawnParams.Instigator = GetInstigator();
	
						// Spawn the projectile at the muzzle.
						AFPSProjectile* Projectile = World->SpawnActor<AFPSProjectile>(ProjectileClass, MuzzleLocation, MuzzleRotation, SpawnParams);
						if (Projectile)
						{
							// Set the projectile's initial trajectory.
							FVector LaunchDirection = MuzzleRotation.Vector();
							Projectile->FireInDirection(LaunchDirection);
						}
					}
				}
			}

void AFPSCharacter::Fire()
			{
				// Attempt to fire a projectile.
				if (ProjectileClass)
				{
					// Get the camera transform.
					FVector CameraLocation;
					FRotator CameraRotation;
					GetActorEyesViewPoint(CameraLocation, CameraRotation);
	
					// Set MuzzleOffset to spawn projectiles slightly in front of the camera.
					MuzzleOffset.Set(100.0f, 0.0f, 0.0f);
	
					// Transform MuzzleOffset from camera space to world space.
					FVector MuzzleLocation = CameraLocation + FTransform(CameraRotation).TransformVector(MuzzleOffset);
	
					// Skew the aim to be slightly upwards.
					FRotator MuzzleRotation = CameraRotation;
					MuzzleRotation.Pitch += 10.0f;
	
					UWorld* World = GetWorld();
					if (World)
					{
						FActorSpawnParameters SpawnParams;
						SpawnParams.Owner = this;
						SpawnParams.Instigator = GetInstigator();
	
						// Spawn the projectile at the muzzle.
						AFPSProjectile* Projectile = World->SpawnActor<AFPSProjectile>(ProjectileClass, MuzzleLocation, MuzzleRotation, SpawnParams);
						if (Projectile)
						{
							// Set the projectile's initial trajectory.
							FVector LaunchDirection = MuzzleRotation.Vector();
							Projectile->FireInDirection(LaunchDirection);
						}
					}
				}
			}

FPSCharacter.h は次のようになります。

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"
	
			UCLASS()
			class FPSPROJECT_API AFPSCharacter : public ACharacter
			{
				GENERATED_BODY()
	
			public:
				// Sets default values for this character's properties
				AFPSCharacter();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
				// Projectile class to spawn.
				UPROPERTY(EditAnywhere, Category = Projectile)
				TSubclassOf<class AFPSProjectile> ProjectileClass;
	
			public:
				// Called every frame
				virtual void Tick(float DeltaTime) override;
	
				// Called to bind functionality to input
			virtual void SetupPlayerInputComponent(class UIComponent* PlayerInputComponent) override;
	
				// Handles input for moving forward and backward.
				UFUNCTION()
				void MoveForward(float Value);
	
				// Handles input for moving right and left.
				UFUNCTION()
				void MoveRight(float Value);
	
				// Sets jump flag when key is pressed.
				UFUNCTION()
				void StartJump();
	
				// Clears jump flag when key is released.
				UFUNCTION()
				void StopJump();
	
				// FPS camera
				UPROPERTY(VisibleAnywhere)
				UCameraComponent* FPSCameraComponent;
	
				// First-person mesh (arms), visible only to the owning player.
				UPROPERTY(VisibleDefaultsOnly, Category = Mesh)
				USkeletalMeshComponent* FPSMesh;
	
				// Function that fires projectiles.
				UFUNCTION()
				void Fire();
	
				// Gun muzzle offset from the camera location.
				UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay)
				FVector MuzzleOffset;
			};

// 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"
	
			UCLASS()
			class FPSPROJECT_API AFPSCharacter : public ACharacter
			{
				GENERATED_BODY()
	
			public:
				// Sets default values for this character's properties
				AFPSCharacter();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
				// Projectile class to spawn.
				UPROPERTY(EditAnywhere, Category = Projectile)
				TSubclassOf<class AFPSProjectile> ProjectileClass;
	
			public:
				// Called every frame
				virtual void Tick(float DeltaTime) override;
	
				// Called to bind functionality to input
			virtual void SetupPlayerInputComponent(class UIComponent* PlayerInputComponent) override;
	
				// Handles input for moving forward and backward.
				UFUNCTION()
				void MoveForward(float Value);
	
				// Handles input for moving right and left.
				UFUNCTION()
				void MoveRight(float Value);
	
				// Sets jump flag when key is pressed.
				UFUNCTION()
				void StartJump();
	
				// Clears jump flag when key is released.
				UFUNCTION()
				void StopJump();
	
				// FPS camera
				UPROPERTY(VisibleAnywhere)
				UCameraComponent* FPSCameraComponent;
	
				// First-person mesh (arms), visible only to the owning player.
				UPROPERTY(VisibleDefaultsOnly, Category = Mesh)
				USkeletalMeshComponent* FPSMesh;
	
				// Function that fires projectiles.
				UFUNCTION()
				void Fire();
	
				// Gun muzzle offset from the camera location.
				UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay)
				FVector MuzzleOffset;
			};

FPSCharacter.cpp は次のようになります。

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;
	
				// Create a first person camera component.
				FPSCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
				check(FPSCameraComponent != nullptr);
	
				// Attach the camera component to our capsule component.
				FPSCameraComponent->SetupAttachment(CastChecked<USceneComponent, UCapsuleComponent>(GetCapsuleComponent()));
	
				// Position the camera slightly above the eyes.
				FPSCameraComponent->SetRelativeLocation(FVector(0.0f, 0.0f, 50.0f + BaseEyeHeight));
	
				// Enable the Pawn to control camera rotation.
				FPSCameraComponent->bUsePawnControlRotation = true;
	
				// Create a first person mesh component for the owning player.
				FPSMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));
				check(FPSMesh != nullptr);
	
				// Only the owning player sees this mesh.
				FPSMesh->SetOnlyOwnerSee(true);
	
				// Attach the FPS mesh to the FPS camera.
				FPSMesh->SetupAttachment(FPSCameraComponent);
	
				// Disable some environmental shadowing to preserve the illusion of having a single mesh.
				FPSMesh->bCastDynamicShadow = false;
				FPSMesh->CastShadow = false;
	
				// The owning player doesn't see the regular (third-person) body mesh.
				GetMesh()->SetOwnerNoSee(true);
			}
	
			// Called when the game starts or when spawned
			void AFPSCharacter::BeginPlay()
			{
				Super::BeginPlay();
	
				check(GEngine != nullptr);
	
				// Display a debug message for five seconds.
				// The -1 "Key" value argument prevents the message from being updated or refreshed.
				GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("We are using FPSCharacter."));
			}
	
			// Called every frame
			void AFPSCharacter::Tick(float DeltaTime)
			{
				Super::Tick( DeltaTime );
	
			}
	
			// Called to bind functionality to input
			void AFPSCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
			{
				Super::SetupPlayerInputComponent(PlayerInputComponent);
	
				// Set up "movement" bindings.
				PlayerInputComponent->BindAxis("MoveForward", this, &AFPSCharacter::MoveForward);
				PlayerInputComponent->BindAxis("MoveRight", this, &AFPSCharacter::MoveRight);
	
				// Set up "look" bindings.
				PlayerInputComponent->BindAxis("Turn", this, &AFPSCharacter::AddControllerYawInput);
				PlayerInputComponent->BindAxis("LookUp", this, &AFPSCharacter::AddControllerPitchInput);
	
				// Set up "action" bindings.
				PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &AFPSCharacter::StartJump);
				PlayerInputComponent->BindAction("Jump", IE_Released, this, &AFPSCharacter::StopJump);
				PlayerInputComponent->BindAction("Fire", IE_Pressed, this, &AFPSCharacter::Fire);
			}
	
			void AFPSCharacter::MoveForward(float Value)
			{
				// Find out which way is "forward" and record that the player wants to move that way.
				FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::X);
				AddMovementInput(Direction, Value);
			}
	
			void AFPSCharacter::MoveRight(float Value)
			{
				// Find out which way is "right" and record that the player wants to move that way.
				FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::Y);
				AddMovementInput(Direction, Value);
			}
	
			void AFPSCharacter::StartJump()
			{
				bPressedJump = true;
			}
	
			void AFPSCharacter::StopJump()
			{
				bPressedJump = false;
			}
	
			void AFPSCharacter::Fire()
			{
				// Attempt to fire a projectile.
				if (ProjectileClass)
				{
					// Get the camera transform.
					FVector CameraLocation;
					FRotator CameraRotation;
					GetActorEyesViewPoint(CameraLocation, CameraRotation);
	
					// Set MuzzleOffset to spawn projectiles slightly in front of the camera.
					MuzzleOffset.Set(100.0f, 0.0f, 0.0f);
	
					// Transform MuzzleOffset from camera space to world space.
					FVector MuzzleLocation = CameraLocation + FTransform(CameraRotation).TransformVector(MuzzleOffset);
	
					// Skew the aim to be slightly upwards.
					FRotator MuzzleRotation = CameraRotation;
					MuzzleRotation.Pitch += 10.0f;
	
					UWorld* World = GetWorld();
					if (World)
					{
						FActorSpawnParameters SpawnParams;
						SpawnParams.Owner = this;
						SpawnParams.Instigator = GetInstigator();
	
						// Spawn the projectile at the muzzle.
						AFPSProjectile* Projectile = World->SpawnActor<AFPSProjectile>(ProjectileClass, MuzzleLocation, MuzzleRotation, SpawnParams);
						if (Projectile)
						{
							// Set the projectile's initial trajectory.
							FVector LaunchDirection = MuzzleRotation.Vector();
							Projectile->FireInDirection(LaunchDirection);
						}
					}
				}
			}

// 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;
	
				// Create a first person camera component.
				FPSCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
				check(FPSCameraComponent != nullptr);
	
				// Attach the camera component to our capsule component.
				FPSCameraComponent->SetupAttachment(CastChecked<USceneComponent, UCapsuleComponent>(GetCapsuleComponent()));
	
				// Position the camera slightly above the eyes.
				FPSCameraComponent->SetRelativeLocation(FVector(0.0f, 0.0f, 50.0f + BaseEyeHeight));
	
				// Enable the Pawn to control camera rotation.
				FPSCameraComponent->bUsePawnControlRotation = true;
	
				// Create a first person mesh component for the owning player.
				FPSMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));
				check(FPSMesh != nullptr);
	
				// Only the owning player sees this mesh.
				FPSMesh->SetOnlyOwnerSee(true);
	
				// Attach the FPS mesh to the FPS camera.
				FPSMesh->SetupAttachment(FPSCameraComponent);
	
				// Disable some environmental shadowing to preserve the illusion of having a single mesh.
				FPSMesh->bCastDynamicShadow = false;
				FPSMesh->CastShadow = false;
	
				// The owning player doesn't see the regular (third-person) body mesh.
				GetMesh()->SetOwnerNoSee(true);
			}
	
			// Called when the game starts or when spawned
			void AFPSCharacter::BeginPlay()
			{
				Super::BeginPlay();
	
				check(GEngine != nullptr);
	
				// Display a debug message for five seconds.
				// The -1 "Key" value argument prevents the message from being updated or refreshed.
				GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("We are using FPSCharacter."));
			}
	
			// Called every frame
			void AFPSCharacter::Tick(float DeltaTime)
			{
				Super::Tick( DeltaTime );
	
			}
	
			// Called to bind functionality to input
			void AFPSCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
			{
				Super::SetupPlayerInputComponent(PlayerInputComponent);
	
				// Set up "movement" bindings.
				PlayerInputComponent->BindAxis("MoveForward", this, &AFPSCharacter::MoveForward);
				PlayerInputComponent->BindAxis("MoveRight", this, &AFPSCharacter::MoveRight);
	
				// Set up "look" bindings.
				PlayerInputComponent->BindAxis("Turn", this, &AFPSCharacter::AddControllerYawInput);
				PlayerInputComponent->BindAxis("LookUp", this, &AFPSCharacter::AddControllerPitchInput);
	
				// Set up "action" bindings.
				PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &AFPSCharacter::StartJump);
				PlayerInputComponent->BindAction("Jump", IE_Released, this, &AFPSCharacter::StopJump);
				PlayerInputComponent->BindAction("Fire", IE_Pressed, this, &AFPSCharacter::Fire);
			}
	
			void AFPSCharacter::MoveForward(float Value)
			{
				// Find out which way is "forward" and record that the player wants to move that way.
				FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::X);
				AddMovementInput(Direction, Value);
			}
	
			void AFPSCharacter::MoveRight(float Value)
			{
				// Find out which way is "right" and record that the player wants to move that way.
				FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::Y);
				AddMovementInput(Direction, Value);
			}
	
			void AFPSCharacter::StartJump()
			{
				bPressedJump = true;
			}
	
			void AFPSCharacter::StopJump()
			{
				bPressedJump = false;
			}
	
			void AFPSCharacter::Fire()
			{
				// Attempt to fire a projectile.
				if (ProjectileClass)
				{
					// Get the camera transform.
					FVector CameraLocation;
					FRotator CameraRotation;
					GetActorEyesViewPoint(CameraLocation, CameraRotation);
	
					// Set MuzzleOffset to spawn projectiles slightly in front of the camera.
					MuzzleOffset.Set(100.0f, 0.0f, 0.0f);
	
					// Transform MuzzleOffset from camera space to world space.
					FVector MuzzleLocation = CameraLocation + FTransform(CameraRotation).TransformVector(MuzzleOffset);
	
					// Skew the aim to be slightly upwards.
					FRotator MuzzleRotation = CameraRotation;
					MuzzleRotation.Pitch += 10.0f;
	
					UWorld* World = GetWorld();
					if (World)
					{
						FActorSpawnParameters SpawnParams;
						SpawnParams.Owner = this;
						SpawnParams.Instigator = GetInstigator();
	
						// Spawn the projectile at the muzzle.
						AFPSProjectile* Projectile = World->SpawnActor<AFPSProjectile>(ProjectileClass, MuzzleLocation, MuzzleRotation, SpawnParams);
						if (Projectile)
						{
							// Set the projectile's initial trajectory.
							FVector LaunchDirection = MuzzleRotation.Vector();
							Projectile->FireInDirection(LaunchDirection);
						}
					}
				}
			}

FPSCharacter.h と FPSCharacter.cpp を Visual Studio で保存します。
[Solution Explorer] に移動して [FPSProject] を選択します。
[FPSProject] を右クリックして [Build] を選択し、プロジェクトをコンパイルします。

発射物メッシュをインポートする

先に進む前に、次のリンクからサンプルメッシュをダウンロードして展開してください。

「発射物メッシュ」

Unreal Engine を開き、コンテンツブラウザ に移動して「Content」フォルダを開きます。
コンテンツブラウザ のファイルウィンドウ内を右クリックして、[Import Asset (アセットのインポート)] ダイアログウィンドウを開きます。

右クリックのインポートについて説明しましたが、コンテンツをインポートするには 3 つの方法があります。コンテンツのインポート方法については、「アセットを直接インポートする」を参照してください。

[Import to /Game... (/Game にインポート...)] をクリックして、[Import (インポート)] ダイアログウィンドウを開きます。
「Sphere.fbx」メッシュファイルをダウンロードしたフォルダで見つけて選択します。
[Open (開く)] をクリックして、メッシュのプロジェクトへのインポートを開始します。
[FBX Import Options (FBX インポートオプション)] ダイアログウィンドウが表示されます。[Import All (すべてインポート)] をクリックすると、メッシュがプロジェクトに追加されます。

スムージンググループに関する次のエラーを無視します。

このメッシュではファーストパーソンメッシュセットアップがまだ表示されます。後のセクションでセットアップするアニメーションと連動します。

メイン メニューパネルで [File (ファイル)] をクリックし、[Save All (全て保存)] を選択してインポートされたメッシュを保存します。

発射物のメッシュを追加する

Visual Studio を開き、[Solution Explorer] に移動します。
[Solution Explorer] で FPSProjectile.h クラスヘッダファイルを開きます。
次のコードを FPSProjectile.h の public アクセス指定子の下に追加します。

FPSProjectile.h

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

Navigate to the Solution Explorer in the Visual Studio and open the FPSProjectile.cpp class implementation file.
Add the following code to the constructor in FPSProjectile.cpp:

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);
				}
			}

Unreal Editor を開いて コンテンツブラウザ に移動し、Sphere スタティックメッシュを右クリックして [Copy Reference (参照をコピー)] を選択します。
Visual Studio を開いて FPSProjectile.cpp の ProjectileMeshComponent コードに戻り、[ADD STATIC MESH ASSET REFERENCE] をコピーした参照で置き換えます。コードは次のようになります。

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);
				}
			}

アセットのリファレンスパスは、コンテンツブラウザで Sphere メッシュを保存した場所により変わります。また、コピーしたアセットのリファレンスを貼り付けたとき、リファレンスには、アセットのリファレンスパスの前にアセットのタイプ名が含まれます。この場合は、StaticMesh'/Game/Sphere.Sphere' です。必ずアセットのタイプ名 (StaticMesh など) をリファレンスパスから削除します。

FPSProjectile.h は次のようになります。

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"
	
			UCLASS()
			class FPSPROJECT_API AFPSProjectile : public AActor
			{
				GENERATED_BODY()
	
			public:	
				// Sets default values for this actor's properties
				AFPSProjectile();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
			public:	
				// Called every frame
				virtual void Tick(float DeltaTime) override;
	
				// Sphere collision component
				UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
				USphereComponent* CollisionComponent;
	
				// Projectile movement component
				UPROPERTY(VisibleAnywhere, Category = Movement)
				UProjectileMovementComponent* ProjectileMovementComponent;
	
				// Function that initializes the projectile's velocity in the shoot direction.
				void FireInDirection(const FVector& ShootDirection);
	
				// Projectile mesh
				UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
				UStaticMeshComponent* ProjectileMeshComponent;
			};

// 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"
	
			UCLASS()
			class FPSPROJECT_API AFPSProjectile : public AActor
			{
				GENERATED_BODY()
	
			public:	
				// Sets default values for this actor's properties
				AFPSProjectile();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
			public:	
				// Called every frame
				virtual void Tick(float DeltaTime) override;
	
				// Sphere collision component
				UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
				USphereComponent* CollisionComponent;
	
				// Projectile movement component
				UPROPERTY(VisibleAnywhere, Category = Movement)
				UProjectileMovementComponent* ProjectileMovementComponent;
	
				// Function that initializes the projectile's velocity in the shoot direction.
				void FireInDirection(const FVector& ShootDirection);
	
				// Projectile mesh
				UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
				UStaticMeshComponent* ProjectileMeshComponent;
			};

FPSProjectile.cpp は次のようになります。

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)
				{
					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.
					CollisionComponent->InitSphereRadius(15.0f);
					// Set the root component to be the collision component.
					RootComponent = CollisionComponent;
				}
	
				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;
					ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
				}
	
				if (!ProjectileMeshComponent)
				{
					ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
					static ConstructorHelpers::FObjectFinder<UStaticMesh>Mesh(TEXT("'/Game/Sphere.Sphere'"));
					if (Mesh.Succeeded())
					{
						ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
					}
				}
			}
	
			// Called when the game starts or when spawned
			void AFPSProjectile::BeginPlay()
			{
				Super::BeginPlay();
	
			}
	
			// Called every frame
			void AFPSProjectile::Tick(float DeltaTime)
			{
				Super::Tick(DeltaTime);
	
			}
	
			// Function that initializes the projectile's velocity in the shoot direction.
			void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
			{
				ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
			}

FPSProjectile.h と FPSProjectile.cpp を Visual Studio で保存します。
[Solution Explorer] に移動して [FPSProject] を選択します。
[FPSProject] を右クリックして [Build] を選択し、プロジェクトをコンパイルします。

発射物のマテリアルを追加する

Visual Studio で FPSProjectile.h に移動し、次のコードを FPSProjectile.h の public アクセス指定子の下に追加します。

FPSProjectile.h

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

FPSProjectile.cpp に移動し、次のコードを if (!ProjectileMeshComponent) コンストラクタの下に追加します。

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

Unreal Engine を開き、コンテンツブラウザ の「Content」フォルダに移動します。コンテンツブラウザ のファイルウィンドウ内を右クリックし、[Material (マテリアル)] を選択します。
新しいマテリアルに「SphereMaterial」という名前を付けます。
新規マテリアルのノードグラフを次のようなプロパティで設定します。
- Base Color: Base Color ピンからワイヤーを引き出すと表示されるウィンドウで Constant3Vector ノードを検索して選択し、「(R:1; G:0; B:0)」に設定します
- Specular: Specular ピンからワイヤーを引き出すと表示されるウィンドウで Constant ノードを検索して選択し、値を「0.5」に設定します
- Emissive Color: Emissive Color からワイヤーを引き出すと表示されるウィンドウで Constant ノードを検索して選択し、値を「0.05」に設定します

クリックしてフルサイズで表示

このステップでは、基本的なマテリアルアセットを作成します。複雑なマテリアルの作成方法を習得するには、マテリアルの使用と作成方法を参照してください。

新規マテリアルのノードグラフを設定した後、[Save (保存)] をクリックし、コンテンツブラウザ を開きます。
Sphere マテリアルを右クリックし、[Copy Reference] を選択します。
FPSProjectile.cpp の ProjectileMeshComponent コードに戻り、[ADD MATERIAL ASSET REFERENCE] をコピーした参照で置き換えます。コードは次のようになります。

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

アセットのリファレンスパスは、コンテンツブラウザで Sphere マテリアルを保存した場所により変わります。また、コピーしたアセットのリファレンスを貼り付けたとき、リファレンスには、アセットのリファレンスパスの前にアセットのタイプ名が含まれます。この場合は、Material'/Game/Sphere.Sphere' です。必ずアセットのタイプ名 (Material など) をリファレンスパスから削除します。

FPSProjectile.h は次のようになります。

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"
	
			UCLASS()
			class FPSPROJECT_API AFPSProjectile : public AActor
			{
				GENERATED_BODY()
	
			public:	
				// Sets default values for this actor's properties
				AFPSProjectile();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
			public:	
				// Called every frame
				virtual void Tick(float DeltaTime) override;
	
				// Sphere collision component
				UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
				USphereComponent* CollisionComponent;
	
				// Projectile movement component
				UPROPERTY(VisibleAnywhere, Category = Movement)
				UProjectileMovementComponent* ProjectileMovementComponent;
	
			    // Function that initializes the projectile's velocity in the shoot direction.
				void FireInDirection(const FVector& ShootDirection);
	
				// Projectile mesh
				UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
				UStaticMeshComponent* ProjectileMeshComponent;
	
				// Projectile material
				UPROPERTY(VisibleDefaultsOnly, Category = Movement)
				UMaterialInstanceDynamic* ProjectileMaterialInstance;
			};

// 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"
	
			UCLASS()
			class FPSPROJECT_API AFPSProjectile : public AActor
			{
				GENERATED_BODY()
	
			public:	
				// Sets default values for this actor's properties
				AFPSProjectile();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
			public:	
				// Called every frame
				virtual void Tick(float DeltaTime) override;
	
				// Sphere collision component
				UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
				USphereComponent* CollisionComponent;
	
				// Projectile movement component
				UPROPERTY(VisibleAnywhere, Category = Movement)
				UProjectileMovementComponent* ProjectileMovementComponent;
	
			    // Function that initializes the projectile's velocity in the shoot direction.
				void FireInDirection(const FVector& ShootDirection);
	
				// Projectile mesh
				UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
				UStaticMeshComponent* ProjectileMeshComponent;
	
				// Projectile material
				UPROPERTY(VisibleDefaultsOnly, Category = Movement)
				UMaterialInstanceDynamic* ProjectileMaterialInstance;
			};

FPSProjectile.cpp は次のようになります。

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)
				{
					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.
					CollisionComponent->InitSphereRadius(15.0f);
					// Set the root component to be the collision component.
					RootComponent = CollisionComponent;
				}
	
				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;
					ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
				}
	
				if (!ProjectileMeshComponent)
				{
					ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
					static ConstructorHelpers::FObjectFinder<UStaticMesh>Mesh(TEXT("'/Game/Sphere.Sphere'"));
					if (Mesh.Succeeded())
					{
						ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
					}
	
					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);
				}
			}
	
			// Called when the game starts or when spawned
			void AFPSProjectile::BeginPlay()
			{
				Super::BeginPlay();
	
			}
	
			// Called every frame
			void AFPSProjectile::Tick(float DeltaTime)
			{
				Super::Tick(DeltaTime);
	
			}
	
			// Function that initializes the projectile's velocity in the shoot direction.
			void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
			{
				ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
			}

// 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)
				{
					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.
					CollisionComponent->InitSphereRadius(15.0f);
					// Set the root component to be the collision component.
					RootComponent = CollisionComponent;
				}
	
				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;
					ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
				}
	
				if (!ProjectileMeshComponent)
				{
					ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
					static ConstructorHelpers::FObjectFinder<UStaticMesh>Mesh(TEXT("'/Game/Sphere.Sphere'"));
					if (Mesh.Succeeded())
					{
						ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
					}
	
					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);
				}
			}
	
			// Called when the game starts or when spawned
			void AFPSProjectile::BeginPlay()
			{
				Super::BeginPlay();
	
			}
	
			// Called every frame
			void AFPSProjectile::Tick(float DeltaTime)
			{
				Super::Tick(DeltaTime);
	
			}
	
			// Function that initializes the projectile's velocity in the shoot direction.
			void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
			{
				ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
			}

UE を開き、コンテンツブラウザ の「Blueprints」フォルダに移動して「BP_FPSCharacter」ファイルを開きます。
フルブループリントエディタ を開き (必要な場合)、[Components (コンポーネント)] パネルに移動して [BP_FPSCharacter (Self)] コンポーネントを選択します。
開いている ブループリントエディタ の[Details] パネルに移動します。
[Projectile (発射物)] セクションを見つけて、[Projectile Class] の隣にあるドロップダウンから [FPSProjectile] を選択します。

ドロップダウンメニューで [FPSProjectile] が見つからない場合は、Unreal Engine を再実行してください。

[Compile (コンパイル)] ボタンと [Save] ボタンを順にクリックします。
Visual Studio を開き、[Solution Explorer] に移動して [FPSProject] を選択します。
[FPSProject] を右クリックして [Build] を選択し、プロジェクトをコンパイルします。
ゲームを PIE モードで実行して、スタティックメッシュやマテリアルがシーンにスポーンされていることを確認します。

弾を発射すると、[Outliner (アウトライナー)] で発射物の数が増えていくのがわかります。これは、存続期間を定義していないためです。

次のセクションのチュートリアルでは、発射物の初期存続期間を定義する方法を示します。

3.3 - 発射物のコリジョンと存続期間を設定する

現時点で発射物は次のようになっています。

無限に存続 (シーンアウトライナーから消えない)
ワールドの他のオブジェクトと衝突しない

このステップでは、発射物のコリジョンと存続期間を設定します。

発射物の存続期間を制限する

Visual Studio を開き、[Solution Explorer] に移動します。
[Solution Explorer] で FPSProjectile.cpp クラス用の実装ファイルを開きます。
次のコードを FPSProjectile.cpp の AFPSProjectile::AFPSProjectile() コンストラクタに追加し、発射物の存続期間を設定します。

FPSProjectile.cpp

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

FPSProjectile.cpp should look like the following:

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)
				{
					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.
					CollisionComponent->InitSphereRadius(15.0f);
					// Set the root component to be the collision component.
					RootComponent = CollisionComponent;
				}
	
				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;
					ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
				}
	
				if (!ProjectileMeshComponent)
				{
					ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
					static ConstructorHelpers::FObjectFinder<UStaticMesh>Mesh(TEXT("'/Game/Sphere.Sphere'"));
					if (Mesh.Succeeded())
					{
						ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
					}
	
					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);
				}
	
				// Delete the projectile after 3 seconds.
				InitialLifeSpan = 3.0f;
			}
	
			// Called when the game starts or when spawned
			void AFPSProjectile::BeginPlay()
			{
				Super::BeginPlay();
	
			}
	
			// Called every frame
			void AFPSProjectile::Tick(float DeltaTime)
			{
				Super::Tick(DeltaTime);
	
			}
	
			// Function that initializes the projectile's velocity in the shoot direction.
			void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
			{
				ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
			}

// 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)
				{
					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.
					CollisionComponent->InitSphereRadius(15.0f);
					// Set the root component to be the collision component.
					RootComponent = CollisionComponent;
				}
	
				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;
					ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
				}
	
				if (!ProjectileMeshComponent)
				{
					ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
					static ConstructorHelpers::FObjectFinder<UStaticMesh>Mesh(TEXT("'/Game/Sphere.Sphere'"));
					if (Mesh.Succeeded())
					{
						ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
					}
	
					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);
				}
	
				// Delete the projectile after 3 seconds.
				InitialLifeSpan = 3.0f;
			}
	
			// Called when the game starts or when spawned
			void AFPSProjectile::BeginPlay()
			{
				Super::BeginPlay();
	
			}
	
			// Called every frame
			void AFPSProjectile::Tick(float DeltaTime)
			{
				Super::Tick(DeltaTime);
	
			}
	
			// Function that initializes the projectile's velocity in the shoot direction.
			void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
			{
				ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
			}

ファイルを保存します。
[Solution Explorer] に移動して [FPSProject] を選択します。
[FPSProject] を右クリックして [Build] を選択し、プロジェクトをコンパイルします。
発射物が 3 秒後に破棄されるかどうかを確認するために、ゲームを PIE モードで実行します。

[Outliner] で確認すると、スポーンされた発射物が 3 秒後にシーンから消えます。

発射物のコリジョン設定を編集する

Unreal Engine には複数のプリセットコリジョンチャンネルがパッケージされています。ただしエンジンには、ゲームプロジェクトで利用できる、カスタマイズ可能なチャンネルも用意されています。

カスタム仕様のコリジョンチャンネルを作成するには、Unreal Engine に移動して [Project Settings] を開き、左側にある [Engine (エンジン)] セクションで [Collision (コリジョン)] を選択したら、右側にある [Preset (プリセット)] セクションを展開します。

クリックしてフルサイズで表示

[Object Channels (オブジェクトチャンネル)] に移動して [New Object Channel... (新規のオブジェクトチャンネル...)] を選択し、新しいコリジョンチャンネルを作成します。新規コリジョンチャンネルに「Projectile」という名前を付けて、[Default Response (デフォルト応答)] が「Block」に設定されていることを確認してから、[Accept (承認)] をクリックします。
[Preset] で [New... (新規...)] を選択し、新規プロファイルに「Projectile」という名前を付けます。次の画像を参照してコリジョンプリセットを設定し、[Accept] をクリックします。

このコリジョンプロファイルでは、発射物がスタティックアクタ、ダイナミックアクタ、物理シミュレーションを利用するアクタ、乗り物、被破壊アクタでブロックされるように指定します。また、このコリジョンプロファイルでは発射物がポーンとオーバーラップすることも指定します。

新規コリジョンチャンネルの設定を使用する

Visual Studio を開いて FPSProjectile.cpp クラス用の実装ファイルに移動します。
FPSProjectile コンストラクタで、次のコード行を if (!CollisionComponent) ブロックの CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent")); の後に追加します。

FPSProjectile.cpp

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

FPSProjectile.cpp は次のようになります。

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)
				{
					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 profile name to "Projectile".
					CollisionComponent->BodyInstance.SetCollisionProfileName(TEXT("Projectile"));
					// Set the sphere's collision radius.
					CollisionComponent->InitSphereRadius(15.0f);
					// Set the root component to be the collision component.
					RootComponent = CollisionComponent;
				}
	
				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;
					ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
				}
	
				if (!ProjectileMeshComponent)
				{
					ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
					static ConstructorHelpers::FObjectFinder<UStaticMesh>Mesh(TEXT("'/Game/Sphere.Sphere'"));
					if (Mesh.Succeeded())
					{
						ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
					}
	
					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);
				}
				// Delete the projectile after 3 seconds.
				InitialLifeSpan = 3.0f;
			}
	
			// Called when the game starts or when spawned
			void AFPSProjectile::BeginPlay()
			{
				Super::BeginPlay();
	
			}
	
			// Called every frame
			void AFPSProjectile::Tick(float DeltaTime)
			{
				Super::Tick(DeltaTime);
	
			}
	
			// Function that initializes the projectile's velocity in the shoot direction.
			void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
			{
				ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
			}

// 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)
				{
					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 profile name to "Projectile".
					CollisionComponent->BodyInstance.SetCollisionProfileName(TEXT("Projectile"));
					// Set the sphere's collision radius.
					CollisionComponent->InitSphereRadius(15.0f);
					// Set the root component to be the collision component.
					RootComponent = CollisionComponent;
				}
	
				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;
					ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
				}
	
				if (!ProjectileMeshComponent)
				{
					ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
					static ConstructorHelpers::FObjectFinder<UStaticMesh>Mesh(TEXT("'/Game/Sphere.Sphere'"));
					if (Mesh.Succeeded())
					{
						ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
					}
	
					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);
				}
				// Delete the projectile after 3 seconds.
				InitialLifeSpan = 3.0f;
			}
	
			// Called when the game starts or when spawned
			void AFPSProjectile::BeginPlay()
			{
				Super::BeginPlay();
	
			}
	
			// Called every frame
			void AFPSProjectile::Tick(float DeltaTime)
			{
				Super::Tick(DeltaTime);
	
			}
	
			// Function that initializes the projectile's velocity in the shoot direction.
			void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
			{
				ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
			}

ファイルを保存します。
[Solution Explorer] に移動して [FPSProject] を選択します。
[FPSProject] を右クリックして [Build] を選択し、プロジェクトをコンパイルします。

3.4 - 発射物をワールドとインタラクトさせる

ここで、発射物のコリジョンインタラクションを検出でき、コリジョンに対応する方法を決定できます。このステップでは、OnHit 関数をコリジョンイベントに対応する FPSProjectile に追加します。

発射物をコリジョンに反応させる

FPSProjectile.h. を開く
次のコードを FPSProjectile.h の public アクセス指定子の下に追加します。

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

FPSProjectile.h は次のようになります。

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"
	
			UCLASS()
			class FPSPROJECT_API AFPSProjectile : public AActor
			{
				GENERATED_BODY()
	
			public:	
				// Sets default values for this actor's properties
				AFPSProjectile();
	
			protected:
				// Called when the game starts or when spawned
				virtual void BeginPlay() override;
	
			public:	
				// Called every frame
				virtual void Tick(float DeltaTime) override;
	
				// Sphere collision component
				UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
				USphereComponent* CollisionComponent;
	
				// Projectile movement component
				UPROPERTY(VisibleAnywhere, Category = Movement)
				UProjectileMovementComponent* ProjectileMovementComponent;
	
				// Function that initializes the projectile's velocity in the shoot direction.
				void FireInDirection(const FVector& ShootDirection);
	
				// Projectile mesh
				UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
				UStaticMeshComponent* ProjectileMeshComponent;
	
				// Projectile material
				UPROPERTY(VisibleDefaultsOnly, Category = Movement)
				UMaterialInstanceDynamic* ProjectileMaterialInstance;
	
				// Function that is called when the projectile hits something.
				UFUNCTION()
				void OnHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComponent, FVector NormalImpulse, const FHitResult& Hit);
		    };

FPSProjectile.cpp を開いて、次のコードを追加します。

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();
			}

FPSProjectile コンストラクタで、次のコード行を if (!CollisionComponent) ブロックの BodyInstance.SetCollisionProfileName: の後に追加します

FPSProjectile.cpp

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

FPSProjectile.cpp は次のようになります。

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)
				{
					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 profile name to "Projectile".
					CollisionComponent->BodyInstance.SetCollisionProfileName(TEXT("Projectile"));
					// Event called when component hits something.
					CollisionComponent->OnComponentHit.AddDynamic(this, &AFPSProjectile::OnHit);
					// Set the sphere's collision radius.
					CollisionComponent->InitSphereRadius(15.0f);
					// Set the root component to be the collision component.
					RootComponent = CollisionComponent;
				}
	
				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;
					ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
				}
	
				if (!ProjectileMeshComponent)
				{
					ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
					static ConstructorHelpers::FObjectFinder<UStaticMesh>Mesh(TEXT("'/Game/Sphere.Sphere'"));
					if (Mesh.Succeeded())
					{
						ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
					}
	
					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);
				}
				// Delete the projectile after 3 seconds.
				InitialLifeSpan = 3.0f;
			}
	
			// Called when the game starts or when spawned
			void AFPSProjectile::BeginPlay()
			{
				Super::BeginPlay();
	
			}
	
			// Called every frame
			void AFPSProjectile::Tick(float DeltaTime)
			{
				Super::Tick(DeltaTime);
	
			}
	
			// Function that initializes the projectile's velocity in the shoot direction.
			void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
			{
				ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
			}
	
			// 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();
			}

// 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)
				{
					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 profile name to "Projectile".
					CollisionComponent->BodyInstance.SetCollisionProfileName(TEXT("Projectile"));
					// Event called when component hits something.
					CollisionComponent->OnComponentHit.AddDynamic(this, &AFPSProjectile::OnHit);
					// Set the sphere's collision radius.
					CollisionComponent->InitSphereRadius(15.0f);
					// Set the root component to be the collision component.
					RootComponent = CollisionComponent;
				}
	
				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;
					ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
				}
	
				if (!ProjectileMeshComponent)
				{
					ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
					static ConstructorHelpers::FObjectFinder<UStaticMesh>Mesh(TEXT("'/Game/Sphere.Sphere'"));
					if (Mesh.Succeeded())
					{
						ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
					}
	
					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);
				}
				// Delete the projectile after 3 seconds.
				InitialLifeSpan = 3.0f;
			}
	
			// Called when the game starts or when spawned
			void AFPSProjectile::BeginPlay()
			{
				Super::BeginPlay();
	
			}
	
			// Called every frame
			void AFPSProjectile::Tick(float DeltaTime)
			{
				Super::Tick(DeltaTime);
	
			}
	
			// Function that initializes the projectile's velocity in the shoot direction.
			void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
			{
				ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
			}
	
			// 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();
			}

発射物のコリジョンをテストする

ファイルを Visual Studio で保存します。
[Solution Explorer] に移動して [FPSProject] を選択します。
[FPSProject] を右クリックして [Build] を選択し、プロジェクトをコンパイルします。
ビルドが終了したら、Unreal Editor の FPSProject に戻ります。
[Outliner] に移動して Floor スタティックメッシュを選択します。
選択した Floor メッシュをコピーして貼り付けます。
比率ロック ([Scale (スケール)] 行にある鍵型アイコン) が解除されていることを確認し、[Floor2] の [Detail] パネルにある [Transform (トランスフォーム)] セクションで、次のようにオプションを設定します。
- Location (位置)：(0.0, 0.0, 150);
- Rotation (回転)：(0.0, 0.0, 0.0);
- Scale (スケール)：(0.2, 0.2, 3.0).
[Physics (物理)] セクションにスクロールダウンし、[Simulate Physics (物理シミュレーション)] ボックスをオンにします。

画像をクリックするとズームインします。

メイン メニューパネルで [File] をクリックし、[Save All] を選択してインポートされたメッシュを保存します。
レベルエディタのツールバー で [Play (プレイ)] ボタンをクリックします。
発射物とキューブとのコリジョンを確認するために、マウスの左ボタンをクリックして物体を発射し、レベルでキューブをいろいろな場所に移動させてみます。

[

うまくいきました。発射物は完成です。

Shift キーと Escape キー を押すか レベルエディタのツールバー にある [Stop (停止)] をクリックし、PIE モードを終了します。

3.5 - 照準線をビューポートに追加する

このステップでは、照準線 HUD 要素をゲームに追加して、狙いを定めて発射できるようにします。

照準アセットをインポートする

開始する前に、次のリンクからサンプル画像をダウンロードして展開してください。

サンプル照準線画像

コンテンツブラウザ に移動して「Content」フォルダを開きます。
コンテンツブラウザ のファイルウィンドウ内を右クリックして、[Import Asset] ダイアログウィンドウを開きます。
[Import to /Game...] をクリックして、[Import] ダイアログウィンドウを開きます。
「crosshair.TGA」画像ファイルをダウンロードしたフォルダで見つけて選択します。
[Open] をクリックして、画像ファイルのプロジェクトへのインポートを開始します。
メイン メニューパネルの [File] をクリックして、インポートされたメッシュを保存します。

新規 HUD クラスを追加する

[Tools] を メイン メニューパネルでクリックし、[New C++ Class...] をクリックして新しい親クラスを選択します。
[Choose Parent Class] メニューが表示されます。[HUD] を親クラスとして選択し、[Next] をクリックします。

クリックしてフルサイズで表示

新規クラスに「FPSHUD」という名前を付けてから、[Create Class] をクリックします。

クリックしてフルサイズで表示

C++ クラスが作成されると、Visual Studio が自動的に、FPSHUD.h ヘッダファイルと FPSHUD.cpp 実装ファイルが開いた状態で表示されます。
FPSHUD.h クラスヘッダファイルに移動し、次の変数を protected アクセス指定子の下に追加します。

FPSHUD.h

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

次の関数宣言を FPSHUD.h の public アクセス指定子の下に追加します。

FPSHUD.h

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

次のヘッダファイルを FPSHUD.h に追加します。

FPSHUD.h

	
			#include "Engine/Canvas.h"

FPSHUD.h は次のようになります。

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"
	
			/**
			*
			*/
			UCLASS()
			class FPSPROJECT_API AFPSHUD : public AHUD
			{
				GENERATED_BODY()
	
			protected:
				// This will be drawn at the center of the screen.
				UPROPERTY(EditDefaultsOnly)
				UTexture2D* CrosshairTexture;
	
			public:
				// Primary draw call for the HUD.
				virtual void DrawHUD() override;
			};

FPSHUD.cpp 実装ファイルを開き、DrawHUD 関数を追加します。

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.
					FVector2D CrossHairDrawPosition(Center.X - (CrosshairTexture->GetSurfaceWidth() * 0.5f), Center.Y - (CrosshairTexture->GetSurfaceHeight() * 0.5f));
	
					// Draw the crosshair at the centerpoint.
					FCanvasTileItem TileItem(CrossHairDrawPosition, CrosshairTexture->Resource, FLinearColor::White);
					TileItem.BlendMode = SE_BLEND_Translucent;
					Canvas->DrawItem(TileItem);
				}
			}

FPSHUD.h と FPSHUD.cpp を Visual Studio で保存します。
[Solution Explorer] に移動して [FPSProject] を選択します。
[FPSProject] を右クリックして [Build] を選択し、プロジェクトをコンパイルします。

CPP HUD クラスのブループリントに拡張する

ここで、CPP HUD クラスをブループリントに拡張します。復習が必要な場合は、C++ とブループリントリファレンスページで C++ クラスからブループリントへの拡張について確認してください。

FPSHUD クラスを右クリックして、[C++ Class Actions (C++ クラスアクション)] メニューを開きます。
[Create Blueprint class based on FPSHUD (FPSHUD に基づくブループリントクラスを作成します)] をクリックして、[Add Blueprint Class (ブループリントクラスを追加)] ダイアログメニューを開きます。
新規ブループリントクラスに「BP_FPSHUD」という名前を付け、「Blueprints」フォルダを選択してから、[Create Blueprint Class (ブループリントクラスを作成)] ボタンをクリックします。

クリックしてフルサイズで表示

これで、「BluePrints」フォルダ内に BP_FPSHUD ブループリントクラスが新しく作成されます。
必ず BP_FPSHUD ブループリントを保存してから、ブループリントエディタ を閉じます。

デフォルトの HUD クラスを設定する

メイン メニューパネルで [Edit] をクリックし、[Project Settings] を選択します。
[Project Settings] タブの左側にある [Project (プロジェクト)] セクションで、[Maps & Modes (マップ & モード)] を選択します。
[BP_FPSHUD] を [Default HUD] ドロップダウンメニューで選択します。

クリックしてフルサイズで表示

[Project Settings] メニューを閉じます。
戻って BP_FPSHUD を ブループリントエディタ で開きます。
次に、ブループリントエディタ の [FPSHUD] セクションにあるドロップダウンメニューをクリックし、照準線テクスチャを選択します。
最後に、BP_FPSHUD ブループリントを コンパイル して保存してから、ブループリントエディタ を閉じます。

HUD を確認する

レベルエディタのツールバー で [Play (プレイ)] ボタンをクリックします。新しく追加された照準線で発射物の狙いを定められます。

(convert:false)
Shift キーと Escape キー を押すか レベルエディタのツールバー にある [Stop] をクリックし、PIE モードを終了します。

このセクションで完了したコード

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"
	
	UCLASS()
	class FPSPROJECT_API AFPSProjectile : public AActor
	{
		GENERATED_BODY()
	
	public:	
		// Sets default values for this actor's properties
		AFPSProjectile();
	
	protected:
		// Called when the game starts or when spawned
		virtual void BeginPlay() override;
	
	public:	
		// Called every frame
		virtual void Tick(float DeltaTime) override;
	
		// Sphere collision component
		UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
		USphereComponent* CollisionComponent;
	
		// Projectile movement component
		UPROPERTY(VisibleAnywhere, Category = Movement)
		UProjectileMovementComponent* ProjectileMovementComponent;
	
		// Function that initializes the projectile's velocity in the shoot direction.
		void FireInDirection(const FVector& ShootDirection);
	
		// Projectile mesh
		UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
		UStaticMeshComponent* ProjectileMeshComponent;
	
		// Projectile material
		UPROPERTY(VisibleDefaultsOnly, Category = Movement)
		UMaterialInstanceDynamic* ProjectileMaterialInstance;
	
		// Function that is called when the projectile hits something.
		UFUNCTION()
		void OnHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComponent, FVector NormalImpulse, const FHitResult& Hit);
	};

// 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"
	
	UCLASS()
	class FPSPROJECT_API AFPSProjectile : public AActor
	{
		GENERATED_BODY()
	
	public:	
		// Sets default values for this actor's properties
		AFPSProjectile();
	
	protected:
		// Called when the game starts or when spawned
		virtual void BeginPlay() override;
	
	public:	
		// Called every frame
		virtual void Tick(float DeltaTime) override;
	
		// Sphere collision component
		UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
		USphereComponent* CollisionComponent;
	
		// Projectile movement component
		UPROPERTY(VisibleAnywhere, Category = Movement)
		UProjectileMovementComponent* ProjectileMovementComponent;
	
		// Function that initializes the projectile's velocity in the shoot direction.
		void FireInDirection(const FVector& ShootDirection);
	
		// Projectile mesh
		UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
		UStaticMeshComponent* ProjectileMeshComponent;
	
		// Projectile material
		UPROPERTY(VisibleDefaultsOnly, Category = Movement)
		UMaterialInstanceDynamic* ProjectileMaterialInstance;
	
		// Function that is called when the projectile hits something.
		UFUNCTION()
		void OnHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComponent, FVector NormalImpulse, const FHitResult& Hit);
	};

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)
		{
			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 profile name to "Projectile".
			CollisionComponent->BodyInstance.SetCollisionProfileName(TEXT("Projectile"));
			// Event called when component hits something.
			CollisionComponent->OnComponentHit.AddDynamic(this, &AFPSProjectile::OnHit);
			// Set the sphere's collision radius.
			CollisionComponent->InitSphereRadius(15.0f);
			// Set the root component to be the collision component.
			RootComponent = CollisionComponent;
		}
	
		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;
			ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
		}
	
		if (!ProjectileMeshComponent)
		{
			ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
			static ConstructorHelpers::FObjectFinder<UStaticMesh>Mesh(TEXT("'/Game/Sphere.Sphere'"));
			if (Mesh.Succeeded())
			{
				ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
			}
	
			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);
		}
	
		// Delete the projectile after 3 seconds.
		InitialLifeSpan = 3.0f;
	}
	
	// Called when the game starts or when spawned
	void AFPSProjectile::BeginPlay()
	{
		Super::BeginPlay();
	
	}
	
	// Called every frame
	void AFPSProjectile::Tick(float DeltaTime)
	{
		Super::Tick(DeltaTime);
	
	}
	
	// Function that initializes the projectile's velocity in the shoot direction.
	void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
	{
		ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
	}
	
	void AFPSProjectile::OnHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComponent, FVector NormalImpulse, const FHitResult& Hit)
	{
		if (OtherActor != nullptr && OtherActor != this && OtherComponent != nullptr && OtherComponent->IsSimulatingPhysics())
		{
			OtherComponent->AddImpulseAtLocation(ProjectileMovementComponent->Velocity * 100.0f, Hit.ImpactPoint);
		}
		Destroy();
	}

// 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)
		{
			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 profile name to "Projectile".
			CollisionComponent->BodyInstance.SetCollisionProfileName(TEXT("Projectile"));
			// Event called when component hits something.
			CollisionComponent->OnComponentHit.AddDynamic(this, &AFPSProjectile::OnHit);
			// Set the sphere's collision radius.
			CollisionComponent->InitSphereRadius(15.0f);
			// Set the root component to be the collision component.
			RootComponent = CollisionComponent;
		}
	
		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;
			ProjectileMovementComponent->ProjectileGravityScale = 0.0f;
		}
	
		if (!ProjectileMeshComponent)
		{
			ProjectileMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("ProjectileMeshComponent"));
			static ConstructorHelpers::FObjectFinder<UStaticMesh>Mesh(TEXT("'/Game/Sphere.Sphere'"));
			if (Mesh.Succeeded())
			{
				ProjectileMeshComponent->SetStaticMesh(Mesh.Object);
			}
	
			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);
		}
	
		// Delete the projectile after 3 seconds.
		InitialLifeSpan = 3.0f;
	}
	
	// Called when the game starts or when spawned
	void AFPSProjectile::BeginPlay()
	{
		Super::BeginPlay();
	
	}
	
	// Called every frame
	void AFPSProjectile::Tick(float DeltaTime)
	{
		Super::Tick(DeltaTime);
	
	}
	
	// Function that initializes the projectile's velocity in the shoot direction.
	void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
	{
		ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
	}
	
	void AFPSProjectile::OnHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComponent, FVector NormalImpulse, const FHitResult& Hit)
	{
		if (OtherActor != nullptr && OtherActor != this && OtherComponent != nullptr && OtherComponent->IsSimulatingPhysics())
		{
			OtherComponent->AddImpulseAtLocation(ProjectileMovementComponent->Velocity * 100.0f, Hit.ImpactPoint);
		}
		Destroy();
	}

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"
	
	UCLASS()
	class FPSPROJECT_API AFPSCharacter : public ACharacter
	{
		GENERATED_BODY()
	
	public:
		// Sets default values for this character's properties
		AFPSCharacter();
	
	protected:
		// Called when the game starts or when spawned
		virtual void BeginPlay() override;
	
		// Projectile class to spawn.
		UPROPERTY(EditAnywhere, Category = Projectile)
		TSubclassOf<class AFPSProjectile> ProjectileClass;
	
	public:	
	
		// Called every frame
		virtual void Tick(float DeltaTime) override;
	
		// Called to bind functionality to input
		virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
	
		// Handles input for moving forward and backward.
		UFUNCTION()
		void MoveForward(float Value);
	
		// Handles input for moving right and left.
		UFUNCTION()
		void MoveRight(float Value);
	
		// Sets jump flag when key is pressed.
		UFUNCTION()
		void StartJump();
	
		// Clears jump flag when key is released.
		UFUNCTION()
		void StopJump();
	
		// FPS camera
		UPROPERTY(VisibleAnywhere)
		UCameraComponent* FPSCameraComponent;
	
		// First-person mesh (arms), visible only to the owning player.
		UPROPERTY(VisibleDefaultsOnly, Category = Mesh)
		USkeletalMeshComponent* FPSMesh;
	
		// Function that fires projectiles.
		UFUNCTION()
		void Fire();
	
		// Gun muzzle offset from the camera location.
		UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay)
		FVector MuzzleOffset;
	};

// 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"
	
	UCLASS()
	class FPSPROJECT_API AFPSCharacter : public ACharacter
	{
		GENERATED_BODY()
	
	public:
		// Sets default values for this character's properties
		AFPSCharacter();
	
	protected:
		// Called when the game starts or when spawned
		virtual void BeginPlay() override;
	
		// Projectile class to spawn.
		UPROPERTY(EditAnywhere, Category = Projectile)
		TSubclassOf<class AFPSProjectile> ProjectileClass;
	
	public:	
	
		// Called every frame
		virtual void Tick(float DeltaTime) override;
	
		// Called to bind functionality to input
		virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
	
		// Handles input for moving forward and backward.
		UFUNCTION()
		void MoveForward(float Value);
	
		// Handles input for moving right and left.
		UFUNCTION()
		void MoveRight(float Value);
	
		// Sets jump flag when key is pressed.
		UFUNCTION()
		void StartJump();
	
		// Clears jump flag when key is released.
		UFUNCTION()
		void StopJump();
	
		// FPS camera
		UPROPERTY(VisibleAnywhere)
		UCameraComponent* FPSCameraComponent;
	
		// First-person mesh (arms), visible only to the owning player.
		UPROPERTY(VisibleDefaultsOnly, Category = Mesh)
		USkeletalMeshComponent* FPSMesh;
	
		// Function that fires projectiles.
		UFUNCTION()
		void Fire();
	
		// Gun muzzle offset from the camera location.
		UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay)
		FVector MuzzleOffset;
	};

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;
	
		// Create a first person camera component.
		FPSCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
		check(FPSCameraComponent != nullptr);
	
		// Attach the camera component to our capsule component.
		FPSCameraComponent->SetupAttachment(CastChecked<USceneComponent, UCapsuleComponent>(GetCapsuleComponent()));
	
		// Position the camera slightly above the eyes.
		FPSCameraComponent->SetRelativeLocation(FVector(0.0f, 0.0f, 50.0f + BaseEyeHeight));
	
		// Enable the Pawn to control camera rotation.
		FPSCameraComponent->bUsePawnControlRotation = true;
	
		// Create a first person mesh component for the owning player.
		FPSMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));
		check(FPSMesh != nullptr);
	
		// Only the owning player sees this mesh.
		FPSMesh->SetOnlyOwnerSee(true);
	
		//Attach the FPS mesh to the FPS Camera.
		FPSMesh->SetupAttachment(FPSCameraComponent);
	
		//Disable some environmental shadows to preserve the illusion of having a single mesh.
		FPSMesh->bCastDynamicShadow = false;
		FPSMesh->CastShadow = false;
	
		// The owning player doesn't see the regular (third-person) body mesh.
		GetMesh()->SetOwnerNoSee(true);
	}
	
	// Called when the game starts or when spawned
	void AFPSCharacter::BeginPlay()
	{
		Super::BeginPlay();
	
		check(GEngine != nullptr);
	
		// Display a debug message for five seconds.
		// The -1 "Key" value argument prevents the message from being updated or refreshed.
		GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("We are using FPSCharacter."));
	}
	
	// Called every frame
	void AFPSCharacter::Tick(float DeltaTime)
	{
		Super::Tick(DeltaTime);
	
	}
	
	// Called to bind functionality to input
	void AFPSCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
	{
		Super::SetupPlayerInputComponent(PlayerInputComponent);
	
		// Set up "movement" bindings.
		PlayerInputComponent->BindAxis("MoveForward", this, &AFPSCharacter::MoveForward);
		PlayerInputComponent->BindAxis("MoveRight", this, &AFPSCharacter::MoveRight);
	
		// Set up "look" bindings.
		PlayerInputComponent->BindAxis("Turn", this, &AFPSCharacter::AddControllerYawInput);
		PlayerInputComponent->BindAxis("LookUp", this, &AFPSCharacter::AddControllerPitchInput);
	
		// Set up "action" bindings.
		PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &AFPSCharacter::StartJump);
		PlayerInputComponent->BindAction("Jump", IE_Released, this, &AFPSCharacter::StopJump);
		PlayerInputComponent->BindAction("Fire", IE_Pressed, this, &AFPSCharacter::Fire);
	}
	
	void AFPSCharacter::MoveForward(float Value)
	{
		// Find out which way is "forward" and record that the player wants to move that way.
		FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::X);
		AddMovementInput(Direction, Value);
	}
	
	void AFPSCharacter::MoveRight(float Value)
	{
		// Find out which way is "right" and record that the player wants to move that way.
		FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::Y);
		AddMovementInput(Direction, Value);
	}
	
	void AFPSCharacter::StartJump()
	{
		bPressedJump = true;
	}
	
	void AFPSCharacter::StopJump()
	{
		bPressedJump = false;
	}
	
	void AFPSCharacter::Fire()
	{
		// Attempt to fire a projectile.
		if (ProjectileClass)
		{
			// Get the camera transform.
			FVector CameraLocation;
			FRotator CameraRotation;
			GetActorEyesViewPoint(CameraLocation, CameraRotation);
	
			// Set MuzzleOffset to spawn projectiles slightly in front of the camera.
			MuzzleOffset.Set(100.0f, 0.0f, 0.0f);
	
			// Transform MuzzleOffset from camera space to world space.
			FVector MuzzleLocation = CameraLocation + FTransform(CameraRotation).TransformVector(MuzzleOffset);
	
			// Skew the aim to be slightly upwards.
			FRotator MuzzleRotation = CameraRotation;
			MuzzleRotation.Pitch += 10.0f;
	
			UWorld* World = GetWorld();
			if (World)
			{
				FActorSpawnParameters SpawnParams;
				SpawnParams.Owner = this;
				SpawnParams.Instigator = GetInstigator();
	
				// Spawn the projectile at the muzzle.
				AFPSProjectile* Projectile = World->SpawnActor<AFPSProjectile>(ProjectileClass, MuzzleLocation, MuzzleRotation, SpawnParams);
				if (Projectile)
				{
					// Set the projectile's initial trajectory.
					FVector LaunchDirection = MuzzleRotation.Vector();
					Projectile->FireInDirection(LaunchDirection);
				}
	
			}
		}
	}

// 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;
	
		// Create a first person camera component.
		FPSCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
		check(FPSCameraComponent != nullptr);
	
		// Attach the camera component to our capsule component.
		FPSCameraComponent->SetupAttachment(CastChecked<USceneComponent, UCapsuleComponent>(GetCapsuleComponent()));
	
		// Position the camera slightly above the eyes.
		FPSCameraComponent->SetRelativeLocation(FVector(0.0f, 0.0f, 50.0f + BaseEyeHeight));
	
		// Enable the Pawn to control camera rotation.
		FPSCameraComponent->bUsePawnControlRotation = true;
	
		// Create a first person mesh component for the owning player.
		FPSMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));
		check(FPSMesh != nullptr);
	
		// Only the owning player sees this mesh.
		FPSMesh->SetOnlyOwnerSee(true);
	
		//Attach the FPS mesh to the FPS Camera.
		FPSMesh->SetupAttachment(FPSCameraComponent);
	
		//Disable some environmental shadows to preserve the illusion of having a single mesh.
		FPSMesh->bCastDynamicShadow = false;
		FPSMesh->CastShadow = false;
	
		// The owning player doesn't see the regular (third-person) body mesh.
		GetMesh()->SetOwnerNoSee(true);
	}
	
	// Called when the game starts or when spawned
	void AFPSCharacter::BeginPlay()
	{
		Super::BeginPlay();
	
		check(GEngine != nullptr);
	
		// Display a debug message for five seconds.
		// The -1 "Key" value argument prevents the message from being updated or refreshed.
		GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("We are using FPSCharacter."));
	}
	
	// Called every frame
	void AFPSCharacter::Tick(float DeltaTime)
	{
		Super::Tick(DeltaTime);
	
	}
	
	// Called to bind functionality to input
	void AFPSCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
	{
		Super::SetupPlayerInputComponent(PlayerInputComponent);
	
		// Set up "movement" bindings.
		PlayerInputComponent->BindAxis("MoveForward", this, &AFPSCharacter::MoveForward);
		PlayerInputComponent->BindAxis("MoveRight", this, &AFPSCharacter::MoveRight);
	
		// Set up "look" bindings.
		PlayerInputComponent->BindAxis("Turn", this, &AFPSCharacter::AddControllerYawInput);
		PlayerInputComponent->BindAxis("LookUp", this, &AFPSCharacter::AddControllerPitchInput);
	
		// Set up "action" bindings.
		PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &AFPSCharacter::StartJump);
		PlayerInputComponent->BindAction("Jump", IE_Released, this, &AFPSCharacter::StopJump);
		PlayerInputComponent->BindAction("Fire", IE_Pressed, this, &AFPSCharacter::Fire);
	}
	
	void AFPSCharacter::MoveForward(float Value)
	{
		// Find out which way is "forward" and record that the player wants to move that way.
		FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::X);
		AddMovementInput(Direction, Value);
	}
	
	void AFPSCharacter::MoveRight(float Value)
	{
		// Find out which way is "right" and record that the player wants to move that way.
		FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::Y);
		AddMovementInput(Direction, Value);
	}
	
	void AFPSCharacter::StartJump()
	{
		bPressedJump = true;
	}
	
	void AFPSCharacter::StopJump()
	{
		bPressedJump = false;
	}
	
	void AFPSCharacter::Fire()
	{
		// Attempt to fire a projectile.
		if (ProjectileClass)
		{
			// Get the camera transform.
			FVector CameraLocation;
			FRotator CameraRotation;
			GetActorEyesViewPoint(CameraLocation, CameraRotation);
	
			// Set MuzzleOffset to spawn projectiles slightly in front of the camera.
			MuzzleOffset.Set(100.0f, 0.0f, 0.0f);
	
			// Transform MuzzleOffset from camera space to world space.
			FVector MuzzleLocation = CameraLocation + FTransform(CameraRotation).TransformVector(MuzzleOffset);
	
			// Skew the aim to be slightly upwards.
			FRotator MuzzleRotation = CameraRotation;
			MuzzleRotation.Pitch += 10.0f;
	
			UWorld* World = GetWorld();
			if (World)
			{
				FActorSpawnParameters SpawnParams;
				SpawnParams.Owner = this;
				SpawnParams.Instigator = GetInstigator();
	
				// Spawn the projectile at the muzzle.
				AFPSProjectile* Projectile = World->SpawnActor<AFPSProjectile>(ProjectileClass, MuzzleLocation, MuzzleRotation, SpawnParams);
				if (Projectile)
				{
					// Set the projectile's initial trajectory.
					FVector LaunchDirection = MuzzleRotation.Vector();
					Projectile->FireInDirection(LaunchDirection);
				}
	
			}
		}
	}

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"
	
	/**
	*
	*/
	UCLASS()
	class FPSPROJECT_API AFPSHUD : public AHUD
	{
		GENERATED_BODY()
	
	protected:
		// This will be drawn at the center of the screen.
		UPROPERTY(EditDefaultsOnly)
		UTexture2D* CrosshairTexture;
	
	public:
		// Primary draw call for the HUD.
		virtual void DrawHUD() override;
	};

FPSHUD.cpp

	
	// Copyright Epic Games, Inc. All Rights Reserved.
	
	#include "FPSHUD.h"
	
	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.
			FVector2D CrossHairDrawPosition(Center.X - (CrosshairTexture->GetSurfaceWidth() * 0.5f), Center.Y - (CrosshairTexture->GetSurfaceHeight() * 0.5f));
	
			// Draw the crosshair at the centerpoint.
			FCanvasTileItem TileItem(CrossHairDrawPosition, CrosshairTexture->Resource, FLinearColor::White);
			TileItem.BlendMode = SE_BLEND_Translucent;
			Canvas->DrawItem(TileItem);
		}
	}

お疲れさまでしたここでは、以下の方法について学習しました。

✓ 発射物をゲームに追加する ✓ シューティングを実装する ✓ 発射物のコリジョンと存続期間を設定する ✓ 発射物をワールドとインタラクトさせる ✓ 照準線をビューポートに追加する

次のセクションでキャラクターをアニメートする方法を学習する準備ができました。

Prerequisite topics

目的

目的

ステップ

3.1 - 発射物をゲームに追加する

Fire アクション マッピングを追加する

発射物クラスを追加する

USphere コンポーネントを追加する

発射物移動コンポーネントを追加する

発射物の初期速度を設定する

発射の入力アクションをバインドする

発射物のスポーン位置を定義する

コードをコンパイルしてチェックする

3.2 - シューティングを実装する

Fire 関数を実装する

発射物メッシュをインポートする

発射物のメッシュを追加する

発射物のマテリアルを追加する

3.3 - 発射物のコリジョンと存続期間を設定する

発射物の存続期間を制限する

発射物のコリジョン設定を編集する

新規コリジョン チャンネルの設定を使用する

3.4 - 発射物をワールドとインタラクトさせる

発射物をコリジョンに反応させる

発射物のコリジョンをテストする

3.5 - 照準線をビューポートに追加する

照準アセットをインポートする

新規 HUD クラスを追加する

CPP HUD クラスのブループリントに拡張する

デフォルトの HUD クラスを設定する

HUD を確認する

このセクションで完了したコード

Fire アクションマッピングを追加する

新規コリジョンチャンネルの設定を使用する