1. Epic GamesDeveloper
  3. 発射物を実装する

発射物を実装する

C++ を使用して発射物を実装し、ゲームプレイ時にスポーンする方法について説明します。

開始する前に

前のセクションの「キャラクターを装備する」で次の目標が完了していることを確認してください。 

  • リスポーンするピックアップ アイテムを作成し、レベルに追加する

  • キャラクターが持って使用できる装備可能なダーツ ランチャーを作成する

基本の発射物

キャラクターはダーツ ランチャーを保持でき、ツールにはそれを使用するためのコントロール バインディングがありますが、名付けただけでそのとおりに動くわけではありません。 このセクションでは、発射物ロジックを実装し、装備したアイテムからダーツを発射するようにします。 

Unreal Engine には、アクタに追加して発射物に変えることができる発射物移動コンポーネント クラスがあります。 これには、発射物の速度、弾性、重力スケールなど、多くの便利な変数が含まれています。  

発射物の実装による演算を処理するには、以下のようなことについて検討する必要があります。

  • 発射物の初期トランスフォーム、速度、方向。

  • キャラクターの中心から発射物をスポーンするか、装備しているツールの中心からスポーンするか。

  • 発射物が別のオブジェクトと衝突したときに、どのような動作をさせるか。

発射物の基本クラスを作成する

まず、基本となる発射物クラスを作成し、次にサブクラス化してツール用の固有の発射物を作成します。 

基本となる発射物クラスの設定を開始するには、次の手順を実行します。

  1. Unreal Editor で、[Tools (ツール)] > [New C++ Class (新規C++クラス)] に移動します。 親クラスとして [Actor (アクタ)] を選択し、クラスに「FirstPersonProjectile」という名前を付けます。 [Create Class (クラスを作成)] をクリックします。

  2. VS で、「FirstPersonProjectile.h」 に移動します。 ファイルの先頭で、UProjectileMovementComponent と USphereComponent の両方を前方宣言します。

    球体コンポーネントを使用して、発射物と他のオブジェクトとのコリジョンをシミュレートします。

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

#pragma once

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

class UProjectileMovementComponent;
class USphereComponent;

  3. BlueprintType 指定子と Blueprintable 指定子を追加し、このクラスをブループリントに公開します。

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

  4. 「FirstPersonProjectile.cpp」を開きます。ファイルの先頭に、”GameFramework/ProjectileMovementComponent.h” の include 文を追加し、発射物移動コンポーネントクラスをインクルードします。

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

// Sets default values
AFirstPersonProjectile::AFirstPersonProjectile()

オブジェクトにヒットしたときの発射物の動作を実装する 

発射物をよりリアルにするには、発射物が当たるオブジェクトに力 (力積) を及ぼすようにします。 たとえば、物理対応のブロックを射撃している場合、発射物は地面に沿ってそのブロックを押し動かします。 次に、デフォルトの有効期限を待たずに、衝撃後に発射物を除去します。 この動作を実装するために OnHit() 関数を作成します。

発射物のオンヒット動作を実装するには、次の手順を実行します。  

  1. 「FirstPersonProjectile.h」の public セクションで、「PhysicsForce」という名前の float プロパティを定義します。

    EditAnywhere、BlueprintReadOnly、Category = “発射物 | 物理” の UPROPERTY() マクロを追加します。

    これは、発射物が何かにヒットしたときに受ける力の量です。

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

  2. void 関数 OnHit() を定義します。 これは、アクタが別のコンポーネントやアクタと衝突したときに呼び出される、AActor からの関数です。 以下の引数を指定します。

    • HitComp：ヒットされたコンポーネント。

    • OtherActor：ヒットされたアクタ。

    • OtherComp：ヒットを作成したコンポーネント (この場合は、発射物の CollisionComponent)。

    • NormalImpulse：ヒットの法線の力積。

    • Hit：時間、距離、場所など、ヒット イベントに関するより多くのデータを含む FHitResult 参照。

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

  3. 「FirstPersonProjectile.cpp」で、ヘッダ ファイルで定義した OnHit() 関数を実装します。 OnHit() 内の if 文で、以下を確認します。 

    1. OtherActor が null でなく、発射物自体ではないこと。

    2. OtherComp が null でなく、物理もシミュレートされていること。

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

    これは、発射物が、自身以外のオブジェクトにヒットし、物理に関与していることを確認します。

  4. if 文内で、AddImpulseAtLocation() を使用して、OtherComp コンポーネントに力積を追加します。

    PhysicsForce で乗算された発射物の速度をこの関数に渡し、発射物アクタの位置で適用します。

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

}

    AddImpulseAtLocation() は、Unreal Engine の物理関数で、ワールド空間の特定の位置であり、シミュレートされた物理オブジェクトに瞬間的な力 (力積) を加えます。 何かが飛び出す爆発、オブジェクトにヒットする弾丸、素早く開くドアなど、衝撃をシミュレートする場合に便利です。

  5. 最後に、この発射物が別のアクタにヒットしたため、Destroy() を呼び出すことで、プロジェクターをシーンから削除します。

完成した OnHit() 関数は次のようになります。

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

		Destroy();
	}
}

発射物のメッシュ、移動、コリジョン コンポーネントを追加する

次に、スタティックメッシュ、発射物移動ロジック、コリジョン球体を発射物に追加し、発射物がどのように移動するかを定義します。

これらのコンポーネントを発射物に追加するには、次の手順を実行します。

  1. 「FirstPersonProjectile.h」の パブリックセクションに、ProjectileMesh という名前の UStaticMeshComponent への TObjectPtr を宣言します。 これはワールド内の発射物のスタティックメッシュです。

    EditAnywhere、BlueprintReadOnly、Category = “発射物 | メッシュ” の UPROPERTY() マクロを追加します。

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

  2. Protected セクションで、以下を宣言します。

    • 「CollisionComponent」という名前の USphereComponent に TObjectPtr を宣言。

    • 「ProjectileMovement」という名前の UProjectileMovementComponent に TObjectPtr を宣言。

    両方に VisibleAnywhere、BlueprintReadOnly、Category = “発射物 | コンポーネント” の UPROPERTY() マクロを追加します。

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

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

    ProjectileMovementComponent が移動ロジックを処理します。 このクラスは、速度、重力、その他の変数に基づいて親アクタが行く場所を計算します。 それから、ティック中に発射物に動きを適用します。

  3. 「FirstPersonProjectile.cpp」の AFirstPersonProjectile() コンストラクタ関数で、発射物のメッシュ、コリジョン、発射物移動コンポーネントのデフォルトのサブオブジェクトを作成します。 次に、発射物メッシュをコリジョン コンポーネントにアタッチします。

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

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

  4. InitSphereRadius() を呼び出し、CollisionComponent を半径 5.0f で初期化します。

  5. BodyInstance.SetCollisionProfileName() を使用して、コリジョン コンポーネントのコリジョン プロファイルの名前を「Projectile」に設定します。

    Unreal Editor では、コリジョン プロファイルは [Project Settings (プロジェクト設定)] > [Engine (エンジン)] > [Collision (コリジョン)] に格納され、コードで使用するために最大 18 個のカスタム コリジョン プロファイルを定義できます。 この「Projectile」コリジョンプロファイルのデフォルトの動作は「Block」であり、衝突したすべてのオブジェクトとコリジョンを発生させます。

    C++ 
    
CollisionComponent->InitSphereRadius(5.0f);

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

  6. 発射物が何かにヒットしたときに起動する OnHit() 関数を先ほど定義しましたが、そのコリジョンが発生したときを通知する方法が必要です。 これを実行するには、AddDynamic() マクロを使用して、CollisionComponent 内の OnComponentHitEvent に関数をサブスクライブします。 このマクロに OnHit() 関数を渡します。

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

  7. CollisionComponent を発射物の RootComponent として、およびトラックする移動コンポーネントの UpdatedComponent として設定します。

    C++ 
    // Set as root component
RootComponent = CollisionComponent;

ProjectileMovement->UpdatedComponent = CollisionComponent;

  8. ProjectileMovement コンポーネントで次の値を初期化します。

    • InitialSpeed：発射物がスポーンするときの初期速度。 これを 3000.0f に設定します。

    • MaxSpeed：発射物の最高速度。 これを 3000.0f に設定します。

    • bRotationFollowVelocity：オブジェクトを速度の方向に回転させるかどうか。 例えるなら、紙飛行機が上昇したり下降したりするにつれて、どのように上下に傾くかです。 これを、true に設定します。

    • bShouldBounce：発射物が障害物を跳ね返るかどうか。 これを、true に設定します。

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

発射物の有効期限を設定する

デフォルトでは、発射してから数秒後に発射物が消えます。 しかし、エディタで発射物のブループリントを派生させると、このデフォルト時間を変更したり削除したりして、レベルにフォーム ダーツを追加してみることができます。

数秒後に発射物を消すには、次の手順を実行します。

  1. 「FirstPersonProjectile.h」の public セクションで、「ProjectileLifespan」という名前の float プロパティを宣言します。

    EditAnywhere、BlueprintReadOnly、Category = “発射物 | 有効期限” の UPROPERTY() マクロを追加します。

    これは秒単位の発射物の有効期限です。

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

  2. 「FirstPersonProjectile.cpp」で、AFirstPersonProjectile() コンストラクタ関数の最後に、発射物の InitialLifeSpan を ProjectileLifespan に設定し、5 秒後に消えるようにします。

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

    InitialLifeSpan は、AActor から継承されたプロパティです。 アクタが消滅するまでの期間を設定する float です。 値が 0 の場合、アクタはゲームが停止するまで存続します。

  完成した FirstPersonProjectile.h は次のようになります。

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

#pragma once

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

class UProjectileMovementComponent;
class USphereComponent;

完成した AFirstPersonProjectile コンストラクタ関数は次のようになります。

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

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

キャラクターのカメラ方向を取得する 

発射物はダーツ ランチャー自体からスポーンする必要があるため、ダーツ ランチャーがどこにあり、どこを指しているのかを知るために何らかの計算を行う必要があります。 ランチャーはプレイヤー キャラクターにアタッチされているため、これらの値はキャラクターがどこにいて、どこを見ているのかに応じて変化します。 

一人称視点キャラクターにはダーツを発射するために必要な位置情報が含まれているため、まずキャラクター クラスを変更してライン トレースでその情報をキャプチャし、結果を返します。

トレースを使用してキャラクターから必要な情報を取得するには、次の手順を実行します。

  1. VS でキャラクターの .h ファイルと .cpp ファイルを開きます。

  2. .h ファイルのpublic セクションで、FVector を返す「GetCameraTargetLocation()」という名前の新しい関数を宣言します。 この関数は、キャラクターが見ているワールド内の位置を返します。

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

  3. キャラクターの .cpp ファイルで、GetCameraTargetLocation() 関数を実装します。 まず、返す「TargetPosition 」という名前の FVector を宣言します。

  4. GetWorld() を呼び出すことで UWorld へのポインタを作成します。

    C++ 
    // The target position to return
FVector TargetPosition;

UWorld* const World = GetWorld();

  5. if 文を追加して、World が null ではないことを確認します。 if 文内で、「Hit」という名前の FHitResult を宣言します。

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

    FHitResult は、ヒットしたアクタまたはコンポーネント、ヒットした場所などのコリジョン クエリの結果に関する情報を格納する UE の構造体です。

  6. キャラクターが見ているポイントを見つけるには、キャラクターが見下ろしているどこか遠くのポイントまでベクターに沿ってライン トレースをシミュレートします。 ライン トレースがオブジェクトに衝突した場合は、キャラクターがワールド内でどこを見ているかがわかります。

    「TraceStart」と「TraceEnd」という名前の 2 つの const FVector 値を宣言し、次の手順を実行します。

    1. TraceStart を FirstPersonCameraComponent の位置に設定します。  

    2. TraceEnd を TraceStart およびカメラ コンポーネントの前方ベクターに非常に大きな数を乗算した値に設定します。 これにより、キャラクターが空を見つめていないかぎり、トレースはワールド内のほとんどのオブジェクトと衝突できる距離に到達します。 (キャラクターが空を見ている場合、TraceEnd がライン トレースの終点です。)

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

  7. UWorld から LineTraceSingleByChannel() を呼び出し、トレースをシミュレートします。 これに、Hit、TraceStart、TraceEnd、ECollisionChannel::ECC_Visibility を渡します。

    これは TraceStart から TraceEnd までのライン トレースをシミュレートし、表示されているオブジェクトと衝突して、トレースの結果を Hit に格納します。 ECollisionChannel::ECC_Visibility は、トレーシングに使用するチャンネルです。これらのチャンネルは、トレースがヒットを試行するオブジェクトのタイプを定義します。 視線カメラのチェックには ECC_Visibility を使用します。

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

    Hit 値に衝撃の位置や法線などのヒット結果の情報が含まれるようになりました。 また、ヒットがオブジェクトのコリジョンによるものであるかどうかも判断します。 衝撃の位置 (またはトレース ラインの終点) は、返すカメラ ターゲットの位置です。  

  8. 三項演算子を使用して、ブロッキング ヒットだった場合は Hit.ImpactPoint に、そうでなかった場合は Hit.TraceEnd に TargetPosition を設定します。 それから、TargetPosition を返します。

    C++ 
    	TargetPosition = Hit.bBlockingHit ? Hit.ImpactPoint : Hit.TraceEnd;

}

return TargetPosition;

完成した GetCameraTargetLocation() 関数は次のようになります。

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

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

DartLauncher::Use() で発射物をスポーンする 

これでキャラクターがどこを見ているかを把握できるようになったため、ダーツ ランチャーの Use() 関数に残りの発射物ロジックを実装することができるようになりました。 発射物を発射する位置と方向を取得して、発射物をスポーンします。 

発射物がスポーンする位置と回転を取得するには、次の手順を実行します。

  1. 「DartLauncher.h」のファイルの先頭に、AFirstPersonProjectile の前方宣言を追加します。

  2. public セクションで、「ProjectileClass」という名前の TSubclassOf<AFirstPersonProjectile> プロパティを宣言します。 これがダーツ ランチャーがスポーンする発射物です。 これに、EditAnywhere と Category = 発射物 の UPROPERTY() マクロを追加します。

    「DartLauncher.h 」は次のようになります。

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

#pragma once

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

class AFirstPersonProjectile;

  3. 「DartLauncher.cpp」に”Kismet/KismetMathLibrary.h” の include 文を追加します。 発射物の演算は複雑になる可能性があるため、このファイルには発射物の発射に使用できる便利な関数がいくつか含まれます。

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

  4. 次の手順を実行して、DartLauncher の Use() 関数を実装します。

    1. GetWorld() を呼び出すことで UWorld を取得します。

    2. if 文を追加して、World と ProjectileClass が null でないことを確認します。

    3. if 文内で OwningCharacter->GetCameraTargetLocation() を呼び出すことでキャラクターが見ている位置を取得します。  

    C++ 
    void ADartLauncher::Use()
{

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

}

  5. キャラクターが持っているツールから発射物をスポーンしたいものの、オブジェクトの中心から直接発射物をスポーンしたくない場合があります。 ダーツ ランチャーの SKM_Pistol メッシュにはダーツの正確なスポーン ポイントを設定するために使用できる「銃口」ソケットがあります。   

    「SocketLocation」という名前の新しい FVector を宣言し、これを ToolMeshComponent で GetSocketLocation(“Muzzle”) を呼び出した結果に設定します。  

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

  6. 次に、「SpawnRotation」という名前の FRotator を宣言します。 これは、発射物がスポーンするときの回転 (ピッチ、ヨー、ロールの値) です。  

    Kismet 数学ライブラリから FindLookAtRotation() を呼び出した結果にこれを設定し、プレイヤー キャラクターから取得した SocketLocation と TargetPosition を渡します。  

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

    FindLookAtRotation は、 SocketLocation で TargetPosition を向くために必要な回転を計算し、返します。  

  7. 「SpawnLocation」という名前の FVector を宣言し、それを SocketLocation と SpawnRotation の前方ベクターに 10.0 を乗算したものを追加した結果に設定します。  

    銃口ソケットはランチャーの正面にないため、ベクターにオフセットを乗算して、発射物が正しい位置から発射されるようにする必要があります。

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

位置と回転を取得したため、発射物をスポーンする準備ができました。 

発射物をスポーンするには、次の手順を実行します。

  1. そのまま Use() 関数で、「ActorSpawnParams」という名前の FActorSpawnParameters を宣言します。 このクラスには、アクタをどこで、どのようにスポーンするかに関する情報が含まれています。

    C++ 
    //Set Spawn Collision Handling Override
FActorSpawnParameters ActorSpawnParams;

  2. ActorSpawnParams の SpawnCollisionHandlingOverride 値を ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButDontSpawnIfColliding に設定します。

    これは、発射物がスポーンする、別のアクタと衝突しない場所 (壁の中など) の検索を試み、適切な場所が見つからない場合はスポーンしません。

    C++ 
    ActorSpawnParams.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButDontSpawnIfColliding;

  3. SpawnActor() を使用して ProjectileClass、SpawnLocation、SpawnRotation、ActorSpawnParams を渡し、ダーツ ランチャーの銃口から発射物がスポーンするようにします。

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

完成した Use() 関数は次のようになります。

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

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

フォーム ダーツ クラスとブループリントを派生させる

すべてのスポーン ロジックが完成したため、次に実際の発射物を作成します。 ダーツ ランチャー クラスでは、起動する AFirstPersonProjectile のサブクラスが必要であるため、レベルで使用するサブクラスをコード内でビルドする必要があります。 

インゲームで使用するフォーム ダーツ発射物クラスを派生させるには、次の手順を実行します。

  1. Unreal Editor で、[Tools] > [New C++ Class] に移動します。 

  2. [All Classes (すべてのクラス)] で、「First Person Projectile」を検索して、親クラスとして選択し、クラスに「FoamDart」と名前を付けます。 [Create Class] をクリックします。  

  3. VS で、これらのファイルをそのままにし、コードを保存してコンパイルします。

このチュートリアルでは、FirstPersonProjectile で定義したもの以外のカスタム発射物コードは実装しませんが、プロジェクトのニーズに合わせて FoamDart クラスを独自に変更することができます。 たとえば、ダーツの発射物が消えたり跳ねたりするのではなく、オブジェクトにくっつくようにすることもできます。 

フォーム ダーツのブループリントを作成するには、次の手順を実行します。

  1. Unreal Editor で、FoamDart に基づいてブループリント クラスを作成し、「BP_FoamDart」という名前を付けます。 これを「FirstPerson/Blueprints/Tools」フォルダに保存します。

  2. ブループリントを開いた状態で、発射物メッシュ コンポーネントを選択し、スタティックメッシュを SM_FoamBullet に設定します。

  3. ブループリントをコンパイルして保存します。

  4. コンテンツ ブラウザで、「BP_DartLauncher」を開きます。

  5. [Details] パネルの [Projectile] セクションで、[Projectile Class (発射物クラス)] を BP_FoamDart に設定し、ブループリントをコンパイルして保存します。  

    BP_FoamDart がリストに表示されない場合は、コンテンツ ブラウザで BP_FoamDart を選択し、Projectile Class プロパティに戻って [コンテンツ ブラウザで選択中のアセットを使用] をクリックします。

ついにお披露目です。 アセットを保存し、[Play (プレイ)] をクリックします。 ゲームが開始したら、ダーツ ランチャーまで走ってダーツを手に入れることができます。 マウスの左ボタンを押すと、ダーツ ランチャーの銃口から発射物がスポーンし、レベル内を跳ねます。 これらの発射物は 5 秒後に消え、衝突するオブジェクトに小さな物理的力を与えるはずです (自分自身を含む)。

次の内容

おつかれさまでした！ 一人称視点のプログラマー トラック チュートリアルを完了し、多くのことを学ぶことができました。 

カスタム キャラクターとカスタム移動を実装し、ピックアップとデータ アセットを作成して、独自の発射物のある装備可能なツールを作成しました。 このプロジェクトを独自のものに仕上げるために必要なものがすべて揃いました。 

以下は推奨事項です。

  • さまざまなタイプのアイテムでプレイヤーのインベントリを拡張できますか？ アイテムのスタックについてはどうでしょうか？

  • ピックアップと発射物を組み合わせてピックアップ可能な弾薬を作成できますか？ ダーツランチャーにこの弾薬システムを実装するのはどうでしょうか？

  • 消耗品を装備可能な消耗品に発展させることはできるでしょうか？ プレイヤーが持つヘルス パックや、拾って投げることができるボールはどうでしょうか？

完全なコード

C++
FirstPersonProjectile.h 
// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

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

class UProjectileMovementComponent;
class USphereComponent;
C++
FirstPersonProjectile.cpp 
// Fill out your copyright notice in the Description page of Project Settings.


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

// Sets default values
AFirstPersonProjectile::AFirstPersonProjectile()
{
C++
AdventureCharacter.h 
// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "Camera/CameraComponent.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h" 
#include "GameFramework/Character.h"
#include "InputActionValue.h"
C++
AdventureCharacter.cpp 
// Copyright Epic Games, Inc. All Rights Reserved.

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

// Sets default values
AAdventureCharacter::AAdventureCharacter()
C++
DartLauncher.h 
// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

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

class AFirstPersonProjectile;
C++
DartLauncher.cpp 
// Copyright Epic Games, Inc. All Rights Reserved.

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

void ADartLauncher::Use()
{

	UWorld* const World = GetWorld();

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page