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

発射物を実装する

発射物をファースト パーソン シューター ゲームに実装する方法。

発射物を実装する
Prerequisite topics

In order to understand and use the content on this page, make sure you are familiar with the following topics:

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

目標

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

目的

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

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

ステップ

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

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

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

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

  1. メイン メニュー パネルで [Edit (編集)] をクリックし、[Project Settings (プロジェクト設定)] を選択します。

  2. [Project Settings] タブの左側にある [Engine (エンジン)] セクションで、[Input (インプット)] をクリックします。

  3. 右側にある [Bindings (バインディング)] で、[Action Mappings (アクション マッピング)] の隣にある [+ (プラス)] 記号をクリックします。

  4. [Action Mappings] の左側にある 矢印 をクリックします。

  5. 表示されるテキスト フィールドに「Fire」と入力します。

  6. ドロップダウン メニューで、[Left Mouse Button (マウスの左ボタン)] を [Mouse (マウス)] ドロップダウン リストから選択します。

  7. ここでの入力設定は次のようになります。

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

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

発射物クラスを追加する

  1. [Tools (ツール)] を メイン メニュー パネルでクリックし、[New C++ Class... (新規 C++ クラス...)] を選択します。

  2. [Choose Parent Class (親クラスを選択)] ウィンドウが表示されます。[Actor (アクタ)] を親クラスとして選択し、[Next (次へ)] をクリックします。

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

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

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

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

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

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

  3. SphereComponent ヘッダ ファイルを追加します。

    FPSProjectile.h

        #include "Components/SphereComponent.h"

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

    FPSProjectile.h

        // 球体コリジョン コンポーネント。
    UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
    USphereComponent* CollisionComponent;

  5. 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: 
        // このアクタのプロパティのデフォルト値を設定します。
        AFPSProjectile();

    protected:
        // ゲームの開始時またはスポーン時に呼び出します。
        virtual void BeginPlay() override;

    public:
        // フレームごとに呼び出します。
        virtual void Tick( float DeltaTime ) override;

        // 球体コリジョン コンポーネント
        UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
        USphereComponent* CollisionComponent;
    };

  6. FPSProjectile.cpp クラス用の実装ファイルに移動します。

  7. 次のコードを AFPSProjectile コンストラクタの PrimaryActorTick.bcanEverTick の後 (FPSProjectile.cpp 内) に追加します。

    FPSProjectile.cpp

        if(!RootComponent)
    {
        RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("ProjectileSceneComponent"));
    }
		
    if(!CollisionComponent)
    {
        // 単純なコリジョン表現として、球体を使用します。
        CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));
        // 球体のコリジョン半径を設定します。
        CollisionComponent->InitSphereRadius(15.0f);
        // コリジョン コンポーネントとなるルート コンポーネントを設定します。
        RootComponent = CollisionComponent;
    }

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

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

    FPSProjectile.cpp

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

     #include "FPSProjectile.h"

     // デフォルト値を設定します。
     AFPSProjectile::AFPSProjectile()
     {
         // 各フレームでこのアクタが Tick() を呼び出すよう設定します。必要ない場合は、パフォーマンス向上のためにこれをオフにすることができます。
         PrimaryActorTick.bCanEverTick = true;

         if(!RootComponent)
         {
             RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("ProjectileSceneComponent"));
         }

         if(!CollisionComponent)
         {
             // 単純なコリジョン表現として、球体を使用します。
             CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));
             // 球体のコリジョン半径を設定します。
             CollisionComponent->InitSphereRadius(15.0f);
             // コリジョン コンポーネントとなるルート コンポーネントを設定します。
             RootComponent = CollisionComponent;
         }
     }

     // ゲームの開始時またはスポーン時に呼び出します。
     void AFPSProjectile::BeginPlay()
     {
         Super::BeginPlay();

     }

     // フレームごとに呼び出します。
     void AFPSProjectile::Tick( float DeltaTime )
     {
         Super::Tick( DeltaTime );

     }

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

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

  2. ProjectileMovementComponent ヘッダ ファイルを追加します。

    FPSProjectile.h

        #include "GameFramework/ProjectileMovementComponent.h"

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

    FPSProjectile.h

        // 発射物移動コンポーネント。
    UPROPERTY(VisibleAnywhere, Category = Movement)
    UProjectileMovementComponent* ProjectileMovementComponent;

  4. 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: 
        // このアクタのプロパティのデフォルト値を設定します。
        AFPSProjectile();

    protected:
        // ゲームの開始時またはスポーン時に呼び出します。
        virtual void BeginPlay() override;

    public:
        // フレームごとに呼び出します。
        virtual void Tick( float DeltaTime ) override;

        // 球体コリジョン コンポーネント。
        UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
        USphereComponent* CollisionComponent;

        // 発射物移動コンポーネント。
        UPROPERTY(VisibleAnywhere, Category = Movement)
        UProjectileMovementComponent* ProjectileMovementComponent;
    };

  5. FPSProjectile.cpp クラス用の実装ファイルに移動します。

  6. 次のコード行を AFPSProjectile コンストラクタ (FPSProjectile.cpp 内) に追加します。

    FPSProjectile.cpp

        if(!ProjectileMovementComponent)
    {
        // このコンポーネントを使用し、この発射物の動きを駆動します。
        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;
    }

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

    FPSProjectile.cpp

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

    #include "FPSProjectile.h"

    // デフォルト値を設定します。
    AFPSProjectile::AFPSProjectile()
    {
        // 各フレームでこのアクタが Tick() を呼び出すよう設定します。必要ない場合は、パフォーマンス向上のためにこれをオフにすることができます。
        PrimaryActorTick.bCanEverTick = true;
        if(!RootComponent)
        {
            RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("ProjectileSceneComponent"));
        }

        if(!CollisionComponent)
        {
            // 単純なコリジョン表現として、球体を使用します。
            CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));
            // 球体のコリジョン半径を設定します。
            CollisionComponent->InitSphereRadius(15.0f);
            // コリジョン コンポーネントとなるルート コンポーネントを設定します。
            RootComponent = CollisionComponent;
        }

        if(!ProjectileMovementComponent)
        {
            // このコンポーネントを使用し、この発射物の動きを駆動します。
            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;
        }
    }

    // ゲームの開始時またはスポーン時に呼び出します。
    void AFPSProjectile::BeginPlay()
    {
        Super::BeginPlay();

    }

    // フレームごとに呼び出します。
    void AFPSProjectile::Tick( float DeltaTime )
    {
        Super::Tick( DeltaTime );

    }

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

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

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

    FPSProjectile.h

        // 発射物の発射方向の速度を初期化する関数。
    void FireInDirection(const FVector& ShootDirection);

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

  3. 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: // このアクタのプロパティのデフォルト値を設定します。 AFPSProjectile();

    protected: // ゲームの開始時またはスポーン時に呼び出します。 virtual void BeginPlay() override;

    public: // フレームごとに呼び出します。 virtual void Tick( float DeltaTime ) override;

    // 球体コリジョン コンポーネント。 UPROPERTY(VisibleDefaultsOnly, Category = Projectile) USphereComponent* CollisionComponent;

    // 発射物移動コンポーネント。 UPROPERTY(VisibleAnywhere, Category = Movement) UProjectileMovementComponent* ProjectileMovementComponent;

    // 発射物の発射方向の速度を初期化する関数。 void FireInDirection(const FVector& ShootDirection); }; ~~~

  4. FPSProjectile.cpp クラス用の実装ファイルに移動します。

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

    FPSProjectile.cpp

        // 発射物の発射方向の速度を初期化する関数。
    void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
    {
        ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
    }

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

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

    FPSProjectile.cpp

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

    #include "FPSProjectile.h"

    // デフォルト値を設定します。
    AFPSProjectile::AFPSProjectile()
    {
        // 各フレームでこのアクタが Tick() を呼び出すよう設定します。必要ない場合は、パフォーマンス向上のためにこれをオフにすることができます。
        PrimaryActorTick.bCanEverTick = true;

        if(!RootComponent)
        {
            RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("ProjectileSceneComponent"));
        }
    
        if (!CollisionComponent)
        {
            // 単純なコリジョン表現として、球体を使用します。
            CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));
            // 球体のコリジョン半径を設定します。
            CollisionComponent->InitSphereRadius(15.0f);
            // コリジョン コンポーネントとなるルート コンポーネントを設定します。
            RootComponent = CollisionComponent;
        }

        if(!ProjectileMovementComponent)
        {
            // このコンポーネントを使用し、この発射物の動きを駆動します。
            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;
        }
    }

    // ゲームの開始時またはスポーン時に呼び出します。
    void AFPSProjectile::BeginPlay()
    {
        Super::BeginPlay();

    }

    // フレームごとに呼び出します。
    void AFPSProjectile::Tick( float DeltaTime )
    {
        Super::Tick( DeltaTime );

    }

    // 発射物の発射方向の速度を初期化する関数。
    void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
    {
        ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
    }

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

  1. Visual Studio の [Solution Explorer (ソリューション エクスプローラー)] に移動し、FPSCharacter.h クラス ヘッダ ファイルを開きます。

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

    FPSCharacter.h

        // 発射物の発射を処理します。
    UFUNCTION()
    void Fire();

  3. 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:
        // このキャラクターのプロパティのデフォルト値を設定します。
        AFPSCharacter();

    protected:
        // ゲームの開始時またはスポーン時に呼び出します。
        virtual void BeginPlay() override;

    public:
        // フレームごとに呼び出します。
        virtual void Tick( float DeltaTime ) override;

        // Input に機能をバインドする際に呼び出します。
        virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;

        // 前方および後方への移動のための入力を処理します。
        UFUNCTION()
        void MoveForward(float Value);

        // 右および左への移動のための入力を処理します。
        UFUNCTION()
        void MoveRight(float Value);

        // キーが押された際にジャンプ フラグを設定します。
        UFUNCTION()
        void StartJump();

        // キーが放された際にジャンプ フラグをクリアします。
        UFUNCTION()
        void StopJump();

        // FPS カメラ
        UPROPERTY(VisibleAnywhere)
        UCameraComponent* FPSCameraComponent;

        // ファースト パーソン メッシュ (腕) で、所有しているプレイヤーにのみ表示されます。
        UPROPERTY(VisibleDefaultsOnly, Category = Mesh)
        USkeletalMeshComponent* FPSMesh;
			
        // 発射物の発射を処理します。
        UFUNCTION()
        void Fire();
    };

  4. Visual Studio の [Solution Explorer] に移動し、FPSCharacter.cpp クラス用の実装ファイルを開きます。

  5. Fire 関数をバインドするには、次のコードを FPSCharacter.cpp: の SetupPlayerInputComponent 関数に追加します。

    FPSCharacter.cpp

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

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

    FPSCharacter.cpp

        void AFPSCharacter::Fire()
    {
    }

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

    FPSCharacter.cpp

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

    #include "FPSCharacter.h"

    // デフォルト値を設定します。
    AFPSCharacter::AFPSCharacter()
    {
        // このキャラクターがフレームごとに Tick() を呼び出すように設定します。必要ない場合は、パフォーマンス向上のためにこれをオフにすることができます。
        PrimaryActorTick.bCanEverTick = true;

        // 一人称視点カメラ コンポーネントを作成します。
        FPSCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
        check(FPSCameraComponent != nullptr);

        // カメラ コンポーネントをカプセル コンポーネントにアタッチします。
        FPSCameraComponent->SetupAttachment(CastChecked<USceneComponent, UCapsuleComponent>(GetCapsuleComponent()));

        // カメラを目の少し上に位置づけます。
        FPSCameraComponent->SetRelativeLocation(FVector(0.0f, 0.0f, 50.0f + BaseEyeHeight));

        // ポーンがカメラの回転をコントロールできます。
        FPSCameraComponent->bUsePawnControlRotation = true;

        // 所有するプレイヤー向けのファースト パーソン メッシュ コンポーネントを作成します。
        FPSMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));
        check(FPSMesh != nullptr);

        // このメッシュは所有するプレイヤーにのみ表示されます。
        FPSMesh->SetOnlyOwnerSee(true);

        // FPS メッシュを FPS カメラにアタッチします。
        FPSMesh->SetupAttachment(FPSCameraComponent);

        // 単一のメッシュがあるかのような錯覚を維持するには、一部の環境シャドウイングを無効にします。
        FPSMesh->bCastDynamicShadow = false;
        FPSMesh->CastShadow = false;

        // 所有するプレイヤーには通常の (サードパーソン) ボディ メッシュは表示されません。
        GetMesh()->SetOwnerNoSee(true);
    }

    // ゲームの開始時またはスポーン時に呼び出します。
    void AFPSCharacter::BeginPlay()
    {
        Super::BeginPlay();
			
        check(GEngine != nullptr);

        // デバッグ メッセージを 5 秒間表示します。
        // 「Key」値引数 -1 を指定すると、メッセージは更新またはリフレッシュされなくなります。
        GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("We are using FPSCharacter."));
    }

    // フレームごとに呼び出します。
    void AFPSCharacter::Tick( float DeltaTime )
    {
        Super::Tick( DeltaTime );

    }

    // Input に機能をバインドする際に呼び出します。
    void AFPSCharacter::SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent)
    {
        Super::SetupPlayerInputComponent(PlayerInputComponent);

        // 「移動」バインディングをセットアップします。
        PlayerInputComponent->BindAxis("MoveForward", this, &AFPSCharacter::MoveForward);
        PlayerInputComponent->BindAxis("MoveRight", this, &AFPSCharacter::MoveRight);

        // 「ルック」バインディングをセットアップします。
        PlayerInputComponent->BindAxis("Turn", this, &AFPSCharacter::AddControllerYawInput);
        PlayerInputComponent->BindAxis("LookUp", this, &AFPSCharacter::AddControllerPitchInput);

        // 「アクション」バインディングをセットアップします。
        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)
    {
        // どちらが「前方」なのかを調べ、プレイヤーがその方向に移動したがっていることを記録します。
        FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::X);
        AddMovementInput(Direction, Value);
    }

    void AFPSCharacter::MoveRight(float Value)
    {
        // どちらが「右」なのかを調べ、プレイヤーがその方向に移動したがっていることを記録します。
        FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::Y);
        AddMovementInput(Direction, Value);
    }

    void AFPSCharacter::StartJump()
    {
        bPressedJump = true;
    }

    void AFPSCharacter::StopJump()
    {
        bPressedJump = false;
    }

    void AFPSCharacter::Fire()
    {
    }

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

  1. FPSProjectile アクタをスポーンする際に、OnFire 関数の実装に関して、次の 2 点の考慮事項があります。

    • 発射物をスポーンする場所。
    • 発射物クラス (FPSCharacter とその派生ブループリントがスポーンする発射物の種類を認識するため)。

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

  2. FPSCharacter.h クラス ヘッダ ファイルに移動します。

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

    FPSCharacter.h

        // カメラ位置からの銃口のオフセット。
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay)
    FVector MuzzleOffset;

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

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

    FPSCharacter.h

        protected:

        // スポーンする発射物クラス。
        UPROPERTY(EditDefaultsOnly, Category = Projectile)
        TSubclassOf<class AFPSProjectile> ProjectileClass;

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

  5. 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: // このキャラクターのプロパティのデフォルト値を設定します。 AFPSCharacter();

    protected: // ゲームの開始時またはスポーン時に呼び出します。 virtual void BeginPlay() override;

    // スポーンする発射物クラス。 UPROPERTY(EditDefaultsOnly, Category = Projectile) TSubclassOf ProjectileClass;

    public: // フレームごとに呼び出します。 virtual void Tick( float DeltaTime ) override;

    // Input に機能をバインドする際に呼び出します。 virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;

    // 前方および後方への移動のための入力を処理します。 UFUNCTION() void MoveForward(float Value);

    // 右および左への移動のための入力を処理します。 UFUNCTION() void MoveRight(float Value);

    // キーが押された際にジャンプ フラグを設定します。 UFUNCTION() void StartJump();

    // キーが放された際にジャンプ フラグをクリアします。 UFUNCTION() void StopJump();

    // 発射物を発射する関数。 UFUNCTION() void Fire();

    // FPS カメラ UPROPERTY(VisibleAnywhere) UCameraComponent* FPSCameraComponent;

    // ファースト パーソン メッシュ (腕) で、所有しているプレイヤーにのみ表示されます。 UPROPERTY(VisibleDefaultsOnly, Category = Mesh) USkeletalMeshComponent* FPSMesh;

    // カメラ位置からの銃口のオフセット。 UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay) FVector MuzzleOffset; }; ~~~

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

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

  1. すべてのヘッダおよび実装ファイルを Visual Studio で保存します。

  2. [Solution Explorer] に移動して [FPSProject] を選択します。

  3. [FPSProject] を右クリックして [Build (ビルド)] を選択し、プロジェクトをコンパイルします。

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

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

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

Fire 関数を実装する

  1. FPSCharacter.h クラス ヘッダ ファイルに移動します。

  2. 次のコード行を FPSCharacter.h に追加します。

    FPSCharacter.h

        #include "FPSProjectile.h"

  3. FPSCharacter.cpp クラス用の実装ファイルに移動します。

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

    FPSCharacter.cpp

        void AFPSCharacter::Fire()
    {
        // 発射物を発射するよう試行します。
        if (ProjectileClass)
        {
            // カメラのトランスフォームを取得します。
            FVector CameraLocation;
            FRotator CameraRotation;
            GetActorEyesViewPoint(CameraLocation, CameraRotation);

            // MuzzleOffset がわずかにカメラ正面に対して発射物をスポーンするように設定します。
            MuzzleOffset.Set(100.0f, 0.0f, 0.0f);

            // MuzzleOffset をカメラ空間からワールド空間にトランスフォームします。
            FVector MuzzleLocation = CameraLocation + FTransform(CameraRotation).TransformVector(MuzzleOffset);
        
            // 照準をわずかに上方に歪めます。
            FRotator MuzzleRotation = CameraRotation;
            MuzzleRotation.Pitch += 10.0f;

            UWorld* World = GetWorld();
            if (World)
            {
                FActorSpawnParameters SpawnParams;
                SpawnParams.Owner = this;
                SpawnParams.Instigator = GetInstigator();

                // 発射物を銃口にスポーンします。
                AFPSProjectile* Projectile = World->SpawnActor<AFPSProjectile>(ProjectileClass, MuzzleLocation, MuzzleRotation, SpawnParams);
                if (Projectile)
                {
                    // 発射物の初期軌道を設定します。
                    FVector LaunchDirection = MuzzleRotation.Vector();
                    Projectile->FireInDirection(LaunchDirection);
                }
            }
        }
    }

  5. 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:
        // このキャラクターのプロパティのデフォルト値を設定します。
        AFPSCharacter();

    protected:
        // ゲームの開始時またはスポーン時に呼び出します。
        virtual void BeginPlay() override;

        // スポーンする発射物クラス。
        UPROPERTY(EditAnywhere, Category = Projectile)
        TSubclassOf<class AFPSProjectile> ProjectileClass;
    
    public:
        // フレームごとに呼び出します。
        virtual void Tick(float DeltaTime) override;
    
        // Input に機能をバインドする際に呼び出します。
       virtual void SetupPlayerInputComponent(class UIComponent* PlayerInputComponent) override;
    
        // 前方および後方への移動のための入力を処理します。
        UFUNCTION()
        void MoveForward(float Value);

        // 右および左への移動のための入力を処理します。
        UFUNCTION()
        void MoveRight(float Value);

        // キーが押された際にジャンプ フラグを設定します。
        UFUNCTION()
        void StartJump();

        // キーが放された際にジャンプ フラグをクリアします。
        UFUNCTION()
        void StopJump();

        // FPS カメラ
        UPROPERTY(VisibleAnywhere)
        UCameraComponent* FPSCameraComponent;

        // ファースト パーソン メッシュ (腕) で、所有しているプレイヤーにのみ表示されます。
        UPROPERTY(VisibleDefaultsOnly, Category = Mesh)
        USkeletalMeshComponent* FPSMesh;
			
        // 発射物を発射する関数。
        UFUNCTION()
        void Fire();

        // カメラ位置からの銃口のオフセット。
        UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay)
        FVector MuzzleOffset;
    };

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

    FPSCharacter.cpp

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

    #include "FPSCharacter.h"

    // デフォルト値を設定します。
    AFPSCharacter::AFPSCharacter()
    {
        // このキャラクターがフレームごとに Tick() を呼び出すように設定します。必要ない場合は、パフォーマンス向上のためにこれをオフにすることができます。
        PrimaryActorTick.bCanEverTick = true;

        // 一人称視点カメラ コンポーネントを作成します。
        FPSCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
        check(FPSCameraComponent != nullptr);

        // カメラ コンポーネントをカプセル コンポーネントにアタッチします。
        FPSCameraComponent->SetupAttachment(CastChecked<USceneComponent, UCapsuleComponent>(GetCapsuleComponent()));

        // カメラを目の少し上に位置づけます。
        FPSCameraComponent->SetRelativeLocation(FVector(0.0f, 0.0f, 50.0f + BaseEyeHeight));

        // ポーンがカメラの回転をコントロールできます。
        FPSCameraComponent->bUsePawnControlRotation = true;

        // 所有するプレイヤー向けのファースト パーソン メッシュ コンポーネントを作成します。
        FPSMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));
        check(FPSMesh != nullptr);

        // このメッシュは所有するプレイヤーにのみ表示されます。
        FPSMesh->SetOnlyOwnerSee(true);

        // FPS メッシュを FPS カメラにアタッチします。
        FPSMesh->SetupAttachment(FPSCameraComponent);

        // 単一のメッシュがあるかのような錯覚を維持するには、一部の環境シャドウイングを無効にします。
        FPSMesh->bCastDynamicShadow = false;
        FPSMesh->CastShadow = false;

        // 所有するプレイヤーには通常の (サードパーソン) ボディ メッシュは表示されません。
        GetMesh()->SetOwnerNoSee(true);
    }

    // ゲームの開始時またはスポーン時に呼び出します。
    void AFPSCharacter::BeginPlay()
    {
        Super::BeginPlay();
			
        check(GEngine != nullptr);

        // デバッグ メッセージを 5 秒間表示します。
        // 「Key」値引数 -1 を指定すると、メッセージは更新またはリフレッシュされなくなります。
        GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("We are using FPSCharacter."));
    }

    // フレームごとに呼び出します。
    void AFPSCharacter::Tick(float DeltaTime)
    {
        Super::Tick( DeltaTime );

    }

    // Input に機能をバインドする際に呼び出します。
    void AFPSCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
    {
        Super::SetupPlayerInputComponent(PlayerInputComponent);

        // 「移動」バインディングをセットアップします。
        PlayerInputComponent->BindAxis("MoveForward", this, &AFPSCharacter::MoveForward);
        PlayerInputComponent->BindAxis("MoveRight", this, &AFPSCharacter::MoveRight);

        // 「ルック」バインディングをセットアップします。
        PlayerInputComponent->BindAxis("Turn", this, &AFPSCharacter::AddControllerYawInput);
        PlayerInputComponent->BindAxis("LookUp", this, &AFPSCharacter::AddControllerPitchInput);

        // 「アクション」バインディングをセットアップします。
        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)
    {
        // どちらが「前方」なのかを調べ、プレイヤーがその方向に移動したがっていることを記録します。
        FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::X);
        AddMovementInput(Direction, Value);
    }

    void AFPSCharacter::MoveRight(float Value)
    {
        // どちらが「右」なのかを調べ、プレイヤーがその方向に移動したがっていることを記録します。
        FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::Y);
        AddMovementInput(Direction, Value);
    }

    void AFPSCharacter::StartJump()
    {
        bPressedJump = true;
    }

    void AFPSCharacter::StopJump()
    {
        bPressedJump = false;
    }

    void AFPSCharacter::Fire()
    {
        // 発射物を発射するよう試行します。
        if (ProjectileClass)
        {
            // カメラのトランスフォームを取得します。
            FVector CameraLocation;
            FRotator CameraRotation;
            GetActorEyesViewPoint(CameraLocation, CameraRotation);

            // MuzzleOffset がわずかにカメラ正面に対して発射物をスポーンするように設定します。
            MuzzleOffset.Set(100.0f, 0.0f, 0.0f);

            // MuzzleOffset をカメラ空間からワールド空間にトランスフォームします。
            FVector MuzzleLocation = CameraLocation + FTransform(CameraRotation).TransformVector(MuzzleOffset);
                
            // 照準をわずかに上方に歪めます。
            FRotator MuzzleRotation = CameraRotation;
            MuzzleRotation.Pitch += 10.0f;

            UWorld* World = GetWorld();
            if (World)
            {
                FActorSpawnParameters SpawnParams;
                SpawnParams.Owner = this;
                SpawnParams.Instigator = GetInstigator();
                    
                // 発射物を銃口にスポーンします。
                AFPSProjectile* Projectile = World->SpawnActor<AFPSProjectile>(ProjectileClass, MuzzleLocation, MuzzleRotation, SpawnParams);
                if (Projectile)
                {
                    // 発射物の初期軌道を設定します。
                    FVector LaunchDirection = MuzzleRotation.Vector();
                    Projectile->FireInDirection(LaunchDirection);
                }
            }
        }
    }

  7. FPSCharacter.h と FPSCharacter.cpp を Visual Studio で保存します。

  8. [Solution Explorer] に移動して [FPSProject] を選択します。

  9. [FPSProject] を右クリックして [Build] を選択し、プロジェクトをコンパイルします。

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

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

  1. Unreal Engine を開いて コンテンツ ブラウザ に移動し、「Content」フォルダを開きます。

  2. コンテンツ ブラウザ のファイル ウィンドウ内を右クリックして、[Import Asset] ダイアログ ウィンドウを開きます。

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

  3. [Import to /Game... (/Game にインポート...)] をクリックして、[Import (インポート)] ダイアログ ウィンドウを開きます。

  4. 「Sphere.fbx」メッシュ ファイルをダウンロードしたフォルダで見つけて選択します。

  5. [Open (開く)] をクリックして、メッシュのプロジェクトへのインポートを開始します。

  6. [FBX Import Options (FBX インポート オプション)] ダイアログ ウィンドウが表示されます。[Import All (すべてインポート)] をクリックすると、メッシュがプロジェクトに追加されます。

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

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

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

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

  1. Visual Studio を開き、[Solution Explorer] に移動します。

  2. [Solution Explorer] で FPSProjectile.h クラス ヘッダ ファイルを開きます。

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

    FPSProjectile.h

        // 発射物メッシュ
    UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
    UStaticMeshComponent* ProjectileMeshComponent;

  4. Visual Studio の Solution Explorer に移動し、FPSProjectile.cpp クラス用の実装ファイルを開きます。

  5. 次のコードを「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);
        }
    }

  6. Unreal Editor を開いて コンテンツ ブラウザ に移動し、Sphere スタティックメッシュを右クリックして [Copy Reference (参照をコピー)] を選択します。

  7. 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 など) をリファレンス パスから削除します。

  8. 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:	
        // このアクタのプロパティのデフォルト値を設定します。
        AFPSProjectile();
     
    protected:
        // ゲームの開始時またはスポーン時に呼び出します。
        virtual void BeginPlay() override;
     
    public:	
        // フレームごとに呼び出します。
        virtual void Tick(float DeltaTime) override;
     
        // 球体コリジョン コンポーネント
        UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
        USphereComponent* CollisionComponent;
     
        // 発射物移動コンポーネント
        UPROPERTY(VisibleAnywhere, Category = Movement)
        UProjectileMovementComponent* ProjectileMovementComponent;
     
        // 発射物の発射方向の速度を初期化する関数。
        void FireInDirection(const FVector& ShootDirection);
			
        // 発射物メッシュ
        UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
        UStaticMeshComponent* ProjectileMeshComponent;
    };

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

    FPSProjectile.cpp

        // Copyright Epic Games, Inc. All Rights Reserved.
         
    #include "FPSProjectile.h"
         
    // デフォルト値を設定します。
    AFPSProjectile::AFPSProjectile()
    {
        // 各フレームでこのアクタが Tick() を呼び出すよう設定します。必要ない場合は、パフォーマンス向上のためにこれをオフにすることができます。
        PrimaryActorTick.bCanEverTick = true;
         
        if (!RootComponent)
        {
            RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("ProjectileSceneComponent"));
        }
         
        if (!CollisionComponent)
        {
            // 単純なコリジョン表現として、球体を使用します。
            CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));
            // 球体のコリジョン半径を設定します。
            CollisionComponent->InitSphereRadius(15.0f);
            // コリジョン コンポーネントとなるルート コンポーネントを設定します。
            RootComponent = CollisionComponent;
        }
         
        if (!ProjectileMovementComponent)
        {
            // このコンポーネントを使用し、この発射物の動きを駆動します。
            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);
            }
        }
    }
         
    // ゲームの開始時またはスポーン時に呼び出します。
    void AFPSProjectile::BeginPlay()
    {
        Super::BeginPlay();
            
    }
         
    // フレームごとに呼び出します。
    void AFPSProjectile::Tick(float DeltaTime)
    {
        Super::Tick(DeltaTime);
         
    }
         
    // 発射物の発射方向の速度を初期化する関数。
    void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
    {
        ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
    }

  10. FPSProjectile.h と FPSProjectile.cpp を Visual Studio で保存します。

  11. [Solution Explorer] に移動して [FPSProject] を選択します。

  12. [FPSProject] を右クリックして [Build (ビルド)] を選択し、プロジェクトをコンパイルします。

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

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

    FPSProjectile.h

         // 発射物のマテリアル
     UPROPERTY(VisibleDefaultsOnly, Category = Movement)
     UMaterialInstanceDynamic* ProjectileMaterialInstance;

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

  3. Unreal Engine を開き、コンテンツ ブラウザ の「Content」フォルダに移動します。コンテンツ ブラウザ のファイル ウィンドウ内を右クリックし、[Material (マテリアル)] を選択します。

  4. 新しいマテリアルに「SphereMaterial」という名前を付けます。

  5. 新規マテリアルのノード グラフを次のようなプロパティで設定します。

    • Base Color: Base Color ピンからワイヤーを引き出すと表示されるウィンドウで Constant3Vector ノードを検索して選択し、「(R:1; G:0; B:0)」に設定します
    • Specular: Specular ピンからワイヤーを引き出すと表示されるウィンドウで Constant ノードを検索して選択し、値 を「0.5」に設定します
    • Emissive Color: Emissive Color からワイヤーを引き出すと表示されるウィンドウで Constant ノードを検索して選択し、値 を「0.05」に設定します

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

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

  6. 新規マテリアルのノード グラフを設定した後、[Save (保存)] をクリックし、コンテンツ ブラウザ を開きます。

  7. Sphere マテリアルを右クリックし、[Copy Reference] を選択します。

  8. 「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 など) をリファレンス パスから削除します。

  9. 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:	
        // このアクタのプロパティのデフォルト値を設定します。
        AFPSProjectile();
         
    protected:
        // ゲームの開始時またはスポーン時に呼び出します。
        virtual void BeginPlay() override;
         
    public:	
        // フレームごとに呼び出します。
        virtual void Tick(float DeltaTime) override;
         
        // 球体コリジョン コンポーネント
        UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
        USphereComponent* CollisionComponent;
         
        // 発射物移動コンポーネント
        UPROPERTY(VisibleAnywhere, Category = Movement)
        UProjectileMovementComponent* ProjectileMovementComponent;
         
        // 発射物の発射方向の速度を初期化する関数。
        void FireInDirection(const FVector& ShootDirection);
		 
        // 発射物メッシュ
        UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
        UStaticMeshComponent* ProjectileMeshComponent;
         
        // 発射物のマテリアル
        UPROPERTY(VisibleDefaultsOnly, Category = Movement)
        UMaterialInstanceDynamic* ProjectileMaterialInstance;
    };

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

    FPSProjectile.cpp

        // Copyright Epic Games, Inc. All Rights Reserved.
     
    #include "FPSProjectile.h"
     
    // デフォルト値を設定します。
    AFPSProjectile::AFPSProjectile()
    {
        // 各フレームでこのアクタが Tick() を呼び出すよう設定します。必要ない場合は、パフォーマンス向上のためにこれをオフにすることができます。
        PrimaryActorTick.bCanEverTick = true;
     
        if (!RootComponent)
        {
            RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("ProjectileSceneComponent"));
        }
     
        if (!CollisionComponent)
        {
            // 単純なコリジョン表現として、球体を使用します。
            CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));
            // 球体のコリジョン半径を設定します。
            CollisionComponent->InitSphereRadius(15.0f);
            // コリジョン コンポーネントとなるルート コンポーネントを設定します。
            RootComponent = CollisionComponent;
        }
     
        if (!ProjectileMovementComponent)
        {
            // このコンポーネントを使用し、この発射物の動きを駆動します。
            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);
        }
    }
     
    // ゲームの開始時またはスポーン時に呼び出します。
    void AFPSProjectile::BeginPlay()
    {
        Super::BeginPlay();
        
    }
     
    // フレームごとに呼び出します。
    void AFPSProjectile::Tick(float DeltaTime)
    {
        Super::Tick(DeltaTime);
     
    }
     
    // 発射物の発射方向の速度を初期化する関数。
    void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
    {
        ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
    }

  11. UE を開き、コンテンツ ブラウザ の「Blueprints」フォルダに移動して「BP_FPSCharacter」ファイルを開きます。

  12. フル ブループリント エディタ を開き (必要な場合)、[Components (コンポーネント)] パネルに移動して [BP_FPSCharacter (Self)] コンポーネントを選択します。

  13. 開いている ブループリント エディタ の[Details] パネルに移動します。

  14. [Projectile (発射物)] セクションを見つけて、[Projectile Class] の隣にあるドロップダウンから [FPSProjectile] を選択します。

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

  15. [Compile (コンパイル)] ボタンと [Save] ボタンを順にクリックします。

  16. Visual Studio を開き、[Solution Explorer] に移動して [FPSProject] を選択します。

  17. [FPSProject] を右クリックして [Build] を選択し、プロジェクトをコンパイルします。

  18. ゲームを PIE モードで実行して、スタティックメッシュやマテリアルがシーンにスポーンされていることを確認します。

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

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

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

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

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

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

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

  1. Visual Studio を開き、[Solution Explorer] に移動します。

  2. [Solution Explorer] で FPSProjectile.cpp クラス用の実装ファイルを開きます。

  3. 次のコードを FPSProjectile.cpp の AFPSProjectile::AFPSProjectile() コンストラクタに追加し、発射物の存続期間を設定します。

    FPSProjectile.cpp

        // 3 秒後に発射物を削除します。
    InitialLifeSpan = 3.0f;

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

    FPSProjectile.cpp

        // Copyright Epic Games, Inc. All Rights Reserved.
                  
    #include "FPSProjectile.h"
         
    // デフォルト値を設定します。
    AFPSProjectile::AFPSProjectile()
    {
        // 各フレームでこのアクタが Tick() を呼び出すよう設定します。必要ない場合は、パフォーマンス向上のためにこれをオフにすることができます。
        PrimaryActorTick.bCanEverTick = true;
         
        if (!RootComponent)
        {
            RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("ProjectileSceneComponent"));
        }
         
        if (!CollisionComponent)
        {
            // 単純なコリジョン表現として、球体を使用します。
            CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));
            // 球体のコリジョン半径を設定します。
            CollisionComponent->InitSphereRadius(15.0f);
            // コリジョン コンポーネントとなるルート コンポーネントを設定します。
            RootComponent = CollisionComponent;
        }
         
        if (!ProjectileMovementComponent)
        {
            // このコンポーネントを使用し、この発射物の動きを駆動します。
            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);
        }
         
        // 3 秒後に発射物を削除します。
        InitialLifeSpan = 3.0f;
    }
         
    // ゲームの開始時またはスポーン時に呼び出します。
    void AFPSProjectile::BeginPlay()
    {
        Super::BeginPlay();
            
    }
         
    // フレームごとに呼び出します。
    void AFPSProjectile::Tick(float DeltaTime)
    {
        Super::Tick(DeltaTime);
         
    }
         
    // 発射物の発射方向の速度を初期化する関数。
    void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
    {
        ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
    }

  5. ファイルを保存します。

  6. [Solution Explorer] に移動して [FPSProject] を選択します。

  7. [FPSProject] を右クリックして [Build] を選択し、プロジェクトをコンパイルします。

  8. 発射物が 3 秒後に破棄されるかどうかを確認するために、ゲームを PIE モードで実行します。

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

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

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

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

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

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

  3. [Preset] で [New... (新規...)] を選択し、新規プロファイルに「Projectile」という名前を付けます。次の画像を参照してコリジョン プリセットを設定し、[Accept] をクリックします。

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

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

  1. Visual Studio を開いて FPSProjectile.cpp クラス用の実装ファイルに移動します。

  2. FPSProjectile コンストラクタで、次のコード行を if (!CollisionComponent) ブロックの CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent")); の後に追加します。

    FPSProjectile.cpp

        // 球体のコリジョン プロファイル名を「Projectile」に設定します。
    CollisionComponent->BodyInstance.SetCollisionProfileName(TEXT("Projectile"));

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

    FPSProjectile.cpp

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

    #include "FPSProjectile.h"

    // デフォルト値を設定します。
    AFPSProjectile::AFPSProjectile()
    {
        // 各フレームでこのアクタが Tick() を呼び出すよう設定します。必要ない場合は、パフォーマンス向上のためにこれをオフにすることができます。
        PrimaryActorTick.bCanEverTick = true;

        if (!RootComponent)
        {
            RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("ProjectileSceneComponent"));
        }

        if (!CollisionComponent)
        {
            // 単純なコリジョン表現として、球体を使用します。
            CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));
            // 球体のコリジョン プロファイル名を「Projectile」に設定します。
            CollisionComponent->BodyInstance.SetCollisionProfileName(TEXT("Projectile"));
            // 球体のコリジョン半径を設定します。
            CollisionComponent->InitSphereRadius(15.0f);
            // コリジョン コンポーネントとなるルート コンポーネントを設定します。
            RootComponent = CollisionComponent;
        }

        if (!ProjectileMovementComponent)
        {
            // このコンポーネントを使用し、この発射物の動きを駆動します。
            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);
        }
        // 3 秒後に発射物を削除します。
        InitialLifeSpan = 3.0f;
    }

    // ゲームの開始時またはスポーン時に呼び出します。
    void AFPSProjectile::BeginPlay()
    {
        Super::BeginPlay();
        
    }

    // フレームごとに呼び出します。
    void AFPSProjectile::Tick(float DeltaTime)
    {
        Super::Tick(DeltaTime);

    }

    // 発射物の発射方向の速度を初期化する関数。
    void AFPSProjectile::FireInDirection(const FVector& ShootDirection)
    {
        ProjectileMovementComponent->Velocity = ShootDirection * ProjectileMovementComponent->InitialSpeed;
    }

  4. ファイルを保存します。

  5. [Solution Explorer] に移動して [FPSProject] を選択します。

  6. [FPSProject] を右クリックして [Build] を選択し、プロジェクトをコンパイルします。

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

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

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

  1. FPSProjectile.h. を開く

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

    FPSProjectile.h

        // 発射物が何かにヒットした場合に呼び出される関数。
    UFUNCTION()
    void OnHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComponent, FVector NormalImpulse, const FHitResult& Hit);

  3. 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:	
        // このアクタのプロパティのデフォルト値を設定します。
        AFPSProjectile();
     
    protected:
        // ゲームの開始時またはスポーン時に呼び出します。
        virtual void BeginPlay() override;
     
    public:	
        // フレームごとに呼び出します。
        virtual void Tick(float DeltaTime) override;
     
        // 球体コリジョン コンポーネント
        UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
        USphereComponent* CollisionComponent;
     
        // 発射物移動コンポーネント
        UPROPERTY(VisibleAnywhere, Category = Movement)
        UProjectileMovementComponent* ProjectileMovementComponent;
			
        // 発射物の発射方向の速度を初期化する関数。
        void FireInDirection(const FVector& ShootDirection);
		 
        // 発射物メッシュ
        UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
        UStaticMeshComponent* ProjectileMeshComponent;
		 
        // 発射物のマテリアル
        UPROPERTY(VisibleDefaultsOnly, Category = Movement)
        UMaterialInstanceDynamic* ProjectileMaterialInstance;
		 
        // 発射物が何かにヒットした場合に呼び出される関数。
        UFUNCTION()
        void OnHit(UPrimitiveComponent* HitComponent, AActor* OtherActor, UPrimitiveComponent* OtherComponent, FVector NormalImpulse, const FHitResult& Hit);
    };

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

    FPSProjectile.cpp

        // 発射物が何かにヒットした場合に呼び出される関数。
    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();
    }

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

    FPSProjectile.cpp

        // コンポーネントが何かにヒットしたときに呼び出されるイベント。
    CollisionComponent->OnComponentHit.AddDynamic(this, &AFPSProjectile::OnHit);

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

    FPSProjectile.cpp

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

    #include "FPSProjectile.h"

    // デフォルト値を設定します。
    AFPSProjectile::AFPSProjectile()
    {
        // 各フレームでこのアクタが Tick() を呼び出すよう設定します。必要ない場合は、パフォーマンス向上のためにこれをオフにすることができます。
        PrimaryActorTick.bCanEverTick = true;

        if (!RootComponent)
        {
            RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("ProjectileSceneComponent"));
        }

        if (!CollisionComponent)
        {
            // 単純なコリジョン表現として、球体を使用します。
            CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));
            // 球体のコリジョン プロファイル名を「Projectile」に設定します。
            CollisionComponent->BodyInstance.SetCollisionProfileName(TEXT("Projectile"));
            // コンポーネントが何かにヒットしたときに呼び出されるイベント。
            CollisionComponent->OnComponentHit.AddDynamic(this, &AFPSProjectile::OnHit);
            // 球体のコリジョン半径を設定します。
            CollisionComponent->InitSphereRadius(15.0f);
            // コリジョン コンポーネントとなるルート コンポーネントを設定します。
            RootComponent = CollisionComponent;
        }

        if (!ProjectileMovementComponent)
        {
            // このコンポーネントを使用し、この発射物の動きを駆動します。
            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);
        }
        // 3 秒後に発射物を削除します。
        InitialLifeSpan = 3.0f;
    }

    // ゲームの開始時またはスポーン時に呼び出します。
    void AFPSProjectile::BeginPlay()
    {
        Super::BeginPlay();
			
    }

    // フレームごとに呼び出します。
    void AFPSProjectile::Tick(float DeltaTime)
    {
        Super::Tick(DeltaTime);

    }
		
    // 発射物の発射方向の速度を初期化する関数。
    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 != this && OtherComponent->IsSimulatingPhysics())
        {
            OtherComponent->AddImpulseAtLocation(ProjectileMovementComponent->Velocity * 100.0f, Hit.ImpactPoint);
        }
        Destroy();
    }

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

  1. ファイルを Visual Studio で保存します。

  2. [Solution Explorer] に移動して [FPSProject] を選択します。

  3. [FPSProject] を右クリックして [Build] を選択し、プロジェクトをコンパイルします。

  4. ビルドが終了したら、Unreal Editor の FPSProject に戻ります。

  5. [Outliner] に移動して Floor スタティックメッシュを選択します。

  6. 選択した Floor メッシュをコピーして貼り付けます。

  7. 比率ロック ([Scale (スケール)] 行にある鍵型アイコン) が解除されていることを確認し、[Floor2] の [Detail] パネルにある [Transform (トランスフォーム)] セクションで、次のようにオプションを設定します。

    • Location (位置)：(0.0, 0.0, 150)
    • Rotation (回転)：(0.0, 0.0, 0.0)
    • Scale (スケール)：(0.2, 0.2, 3.0)

  8. [Physics (物理)] セクションにスクロールダウンし、[Simulate Physics (物理シミュレーション)] ボックスをオンにします。

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

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

  10. レベル エディタのツールバー で [Play (プレイ)] ボタンをクリックします。

  11. 発射物とキューブとのコリジョンを確認するために、マウスの左ボタンをクリックして物体を発射し、レベルでキューブをいろいろな場所に移動させてみます。

    [

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

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

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

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

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

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

  1. コンテンツ ブラウザ に移動して「Content」フォルダを開きます。

  2. コンテンツ ブラウザ のファイル ウィンドウ内を右クリックして、[Import Asset] ダイアログ ウィンドウを開きます。

  3. [Import to /Game...] をクリックして、[Import] ダイアログ ウィンドウを開きます。

  4. 「crosshair.TGA」画像ファイルをダウンロードしたフォルダで見つけて選択します。

  5. [Open] をクリックして、画像ファイルのプロジェクトへのインポートを開始します。

  6. メイン メニュー パネルの [File] をクリックして、インポートされたメッシュを保存します。

新規 HUD クラスを追加する

  1. [Tools] を メイン メニュー パネルでクリックし、[New C++ Class...] をクリックして新しい親クラスを選択します。

  2. [Choose Parent Class] メニューが表示されます。[HUD] を親クラスとして選択し、[Next] をクリックします。

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

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

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

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

  5. FPSHUD.h クラス ヘッダ ファイルに移動し、次の変数を protected アクセス指定子の下に追加します。

    FPSHUD.h

        protected:
		
        // これは、画面中央に描画されます。
        UPROPERTY(EditDefaultsOnly)
        UTexture2D* CrosshairTexture;

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

    FPSHUD.h

        public:
		
        // HUD のプライマリ ドロー コール
        virtual void DrawHUD() override;

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

    FPSHUD.h

        #include "Engine/Canvas.h"

  8. 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:
        // これは、画面中央に描画されます。
        UPROPERTY(EditDefaultsOnly)
        UTexture2D* CrosshairTexture;
		
    public:
        // HUD のプライマリ ドロー コール
        virtual void DrawHUD() override;
    };

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

    FPSHUD.cpp

        void AFPSHUD::DrawHUD()
    {
        Super::DrawHUD();

        if (CrosshairTexture)
        {
            // キャンバスの中心を見つけます。
            FVector2D Center(Canvas->ClipX * 0.5f, Canvas->ClipY * 0.5f);

            // テクスチャの半分の長さでオフセットを設定し、キャンバスの中心でテクスチャが揃うようにします。
            FVector2D CrossHairDrawPosition(Center.X - (CrosshairTexture->GetSurfaceWidth() * 0.5f), Center.Y - (CrosshairTexture->GetSurfaceHeight() * 0.5f));

            // 中心点に照準線を描画します。
            FCanvasTileItem TileItem(CrossHairDrawPosition, CrosshairTexture->Resource, FLinearColor::White);
            TileItem.BlendMode = SE_BLEND_Translucent;
            Canvas->DrawItem(TileItem);
        }
    }

  10. FPSHUD.h と FPSHUD.cpp を Visual Studio で保存します。

  11. [Solution Explorer] に移動して [FPSProject] を選択します。

  12. [FPSProject] を右クリックして [Build] を選択し、プロジェクトをコンパイルします。

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

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

  1. FPSHUD クラスを右クリックして、[C++ Class Actions (C++ クラスアクション)] メニューを開きます。

  2. [Create Blueprint class based on FPSHUD (FPSHUD に基づくブループリント クラスを作成します)] をクリックして、[Add Blueprint Class (ブループリントクラスを追加)] ダイアログ メニューを開きます。

  3. 新規ブループリント クラスに「BP_FPSHUD」という名前を付け、「Blueprints」フォルダを選択してから、[Create Blueprint Class (ブループリントクラスを作成)] ボタンをクリックします。

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

  4. これで、「BluePrints」フォルダ内に BP_FPSHUD ブループリント クラスが新しく作成されます。

  5. 必ず BP_FPSHUD ブループリントを保存してから、ブループリント エディタ を閉じます。

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

  1. メイン メニュー パネルで [Edit] をクリックし、[Project Settings] を選択します。

  2. [Project Settings] タブの左側にある [Project (プロジェクト)] セクションで、[Maps & Modes (マップ & モード)] を選択します。

  3. [BP_FPSHUD] を [Default HUD] ドロップダウン メニューで選択します。

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

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

  5. 戻って BP_FPSHUD を ブループリント エディタ で開きます。

  6. 次に、ブループリント エディタ の [FPSHUD] セクションにあるドロップダウン メニューをクリックし、照準線テクスチャを選択します。

  7. 最後に、BP_FPSHUD ブループリントを コンパイル して 保存 してから、ブループリント エディタ を閉じます。

HUD を確認する

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

    (convert:false)

  2. 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:	
            // このアクタのプロパティのデフォルト値を設定します。
            AFPSProjectile();
         
        protected:
            // ゲームの開始時またはスポーン時に呼び出します。
            virtual void BeginPlay() override;
         
        public:	
            // フレームごとに呼び出します。
            virtual void Tick(float DeltaTime) override;
         
            // 球体コリジョン コンポーネント
            UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
            USphereComponent* CollisionComponent;
         
            // 発射物移動コンポーネント
            UPROPERTY(VisibleAnywhere, Category = Movement)
            UProjectileMovementComponent* ProjectileMovementComponent;
            
			// 発射物の発射方向の速度を初期化する関数。
            void FireInDirection(const FVector& ShootDirection);
            
			// 発射物メッシュ
            UPROPERTY(VisibleDefaultsOnly, Category = Projectile)
            UStaticMeshComponent* ProjectileMeshComponent;
         
            // 発射物のマテリアル
            UPROPERTY(VisibleDefaultsOnly, Category = Movement)
            UMaterialInstanceDynamic* ProjectileMaterialInstance;
			
			// 発射物が何かにヒットした場合に呼び出される関数。
            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"
         
        // デフォルト値を設定します。
        AFPSProjectile::AFPSProjectile()
        {
            // 各フレームでこのアクタが Tick() を呼び出すよう設定します。必要ない場合は、パフォーマンス向上のためにこれをオフにすることができます。
            PrimaryActorTick.bCanEverTick = true;
         
            if (!RootComponent)
            {
                RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("ProjectileSceneComponent"));
            }
         
            if (!CollisionComponent)
            {
                // 単純なコリジョン表現として、球体を使用します。
                CollisionComponent = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComponent"));
                // 球体のコリジョン プロファイル名を「Projectile」に設定します。
                CollisionComponent->BodyInstance.SetCollisionProfileName(TEXT("Projectile"));
                // コンポーネントが何かにヒットしたときに呼び出されるイベント。
                CollisionComponent->OnComponentHit.AddDynamic(this, &AFPSProjectile::OnHit);
                // 球体のコリジョン半径を設定します。
                CollisionComponent->InitSphereRadius(15.0f);
                // コリジョン コンポーネントとなるルート コンポーネントを設定します。
                RootComponent = CollisionComponent;
            }
         
            if (!ProjectileMovementComponent)
            {
                // このコンポーネントを使用し、この発射物の動きを駆動します。
                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);
            }
         
            // 3 秒後に発射物を削除します。
            InitialLifeSpan = 3.0f;
        }
         
        // ゲームの開始時またはスポーン時に呼び出します。
        void AFPSProjectile::BeginPlay()
        {
            Super::BeginPlay();
            
        }
         
        // フレームごとに呼び出します。
        void AFPSProjectile::Tick(float DeltaTime)
        {
            Super::Tick(DeltaTime);
         
        }
        
		// 発射物の発射方向の速度を初期化する関数。
        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:
            // このキャラクターのプロパティのデフォルト値を設定します。
            AFPSCharacter();
         
        protected:
            // ゲームの開始時またはスポーン時に呼び出します。
            virtual void BeginPlay() override;
         
            // スポーンする発射物クラス。
            UPROPERTY(EditAnywhere, Category = Projectile)
            TSubclassOf<class AFPSProjectile> ProjectileClass;
         
        public:	
            // フレームごとに呼び出します。
            virtual void Tick(float DeltaTime) override;
         
            // Input に機能をバインドする際に呼び出します。
            virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
         
            // 前方および後方への移動のための入力を処理します。
            UFUNCTION()
            void MoveForward(float Value);
         
            // 右および左への移動のための入力を処理します。
            UFUNCTION()
            void MoveRight(float Value);
         
            // キーが押された際にジャンプ フラグを設定します。
            UFUNCTION()
            void StartJump();
         
            // キーが放された際にジャンプ フラグをクリアします。
            UFUNCTION()
            void StopJump();
         
            // FPS カメラ
            UPROPERTY(VisibleAnywhere)
            UCameraComponent* FPSCameraComponent;
         
            // ファースト パーソン メッシュ (腕) で、所有しているプレイヤーにのみ表示されます。
            UPROPERTY(VisibleDefaultsOnly, Category = Mesh)
            USkeletalMeshComponent* FPSMesh;
			
			// 発射物を発射する関数。
            UFUNCTION()
            void Fire();
         
            // カメラ位置からの銃口のオフセット。
            UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay)
            FVector MuzzleOffset;
        };

FPSCharacter.cpp

        // Copyright Epic Games, Inc. All Rights Reserved.
         
        #include "FPSCharacter.h"
         
        // デフォルト値を設定します。
        AFPSCharacter::AFPSCharacter()
        {
            // このキャラクターがフレームごとに Tick() を呼び出すように設定します。必要ない場合は、パフォーマンス向上のためにこれをオフにすることができます。
            PrimaryActorTick.bCanEverTick = true;
         
            // 一人称視点カメラ コンポーネントを作成します。
            FPSCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
            check(FPSCameraComponent != nullptr);
            
            // カメラ コンポーネントをカプセル コンポーネントにアタッチします。
            FPSCameraComponent->SetupAttachment(CastChecked<USceneComponent, UCapsuleComponent>(GetCapsuleComponent()));
            
            // カメラを目の少し上に位置づけます。
            FPSCameraComponent->SetRelativeLocation(FVector(0.0f, 0.0f, 50.0f + BaseEyeHeight));
            
            // ポーンがカメラの回転をコントロールできます。
            FPSCameraComponent->bUsePawnControlRotation = true;
            
            // 所有するプレイヤー向けのファースト パーソン メッシュ コンポーネントを作成します。
            FPSMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));
            check(FPSMesh != nullptr);
            
            // このメッシュは所有するプレイヤーにのみ表示されます。
            FPSMesh->SetOnlyOwnerSee(true);
         
            //FPS メッシュを FPS カメラにアタッチします。
            FPSMesh->SetupAttachment(FPSCameraComponent);
            
            //単一のメッシュがあるかのような錯覚を維持するには、一部の環境シャドウを無効にします。
            FPSMesh->bCastDynamicShadow = false;
            FPSMesh->CastShadow = false;
            
            // 所有するプレイヤーには通常の (サードパーソン) ボディ メッシュは表示されません。
            GetMesh()->SetOwnerNoSee(true);
        }
         
		// ゲームの開始時またはスポーン時に呼び出します。
		void AFPSCharacter::BeginPlay()
		{
			Super::BeginPlay();
			
			check(GEngine != nullptr);

			// デバッグ メッセージを 5 秒間表示します。
			// 「Key」値引数 -1 を指定すると、メッセージは更新またはリフレッシュされなくなります。
			GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("We are using FPSCharacter."));
		}
         
        // フレームごとに呼び出します。
        void AFPSCharacter::Tick(float DeltaTime)
        {
            Super::Tick(DeltaTime);
         
        }
         
        // Input に機能をバインドする際に呼び出します。
        void AFPSCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
        {
            Super::SetupPlayerInputComponent(PlayerInputComponent);
         
            // 「移動」バインディングをセットアップします。
            PlayerInputComponent->BindAxis("MoveForward", this, &AFPSCharacter::MoveForward);
            PlayerInputComponent->BindAxis("MoveRight", this, &AFPSCharacter::MoveRight);
         
            // 「ルック」バインディングをセットアップします。
            PlayerInputComponent->BindAxis("Turn", this, &AFPSCharacter::AddControllerYawInput);
            PlayerInputComponent->BindAxis("LookUp", this, &AFPSCharacter::AddControllerPitchInput);
         
            // 「アクション」バインディングをセットアップします。
            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)
        {
            // どちらが「前方」なのかを調べ、プレイヤーがその方向に移動したがっていることを記録します。
            FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::X);
            AddMovementInput(Direction, Value);
        }
         
        void AFPSCharacter::MoveRight(float Value)
        {
            // どちらが「右」なのかを調べ、プレイヤーがその方向に移動したがっていることを記録します。
            FVector Direction = FRotationMatrix(Controller->GetControlRotation()).GetScaledAxis(EAxis::Y);
            AddMovementInput(Direction, Value);
        }
         
        void AFPSCharacter::StartJump()
        {
            bPressedJump = true;
        }
         
        void AFPSCharacter::StopJump()
        {
            bPressedJump = false;
        }
         
        void AFPSCharacter::Fire()
        {
            // 発射物を発射するよう試行します。
            if (ProjectileClass)
            {
                // カメラのトランスフォームを取得します。
                FVector CameraLocation;
                FRotator CameraRotation;
                GetActorEyesViewPoint(CameraLocation, CameraRotation);
                
                // MuzzleOffset がわずかにカメラ正面に対して発射物をスポーンするように設定します。
                MuzzleOffset.Set(100.0f, 0.0f, 0.0f);
         
                // MuzzleOffset をカメラ空間からワールド空間にトランスフォームします。
                FVector MuzzleLocation = CameraLocation + FTransform(CameraRotation).TransformVector(MuzzleOffset);
         
                // 照準をわずかに上方に歪めます。
                FRotator MuzzleRotation = CameraRotation;
                MuzzleRotation.Pitch += 10.0f;
         
                UWorld* World = GetWorld();
                if (World)
                {
                    FActorSpawnParameters SpawnParams;
                    SpawnParams.Owner = this;
                    SpawnParams.Instigator = GetInstigator();
         
                    // 発射物を銃口にスポーンします。
                    AFPSProjectile* Projectile = World->SpawnActor<AFPSProjectile>(ProjectileClass, MuzzleLocation, MuzzleRotation, SpawnParams);
                    if (Projectile)
                    {
                        // 発射物の初期軌道を設定します。
                        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:
            // これは、画面中央に描画されます。
            UPROPERTY(EditDefaultsOnly)
            UTexture2D* CrosshairTexture;
		
		public:
            // HUD のプライマリ ドロー コール
            virtual void DrawHUD() override;
        };

FPSHUD.cpp

        // Copyright Epic Games, Inc. All Rights Reserved.
         
        #include "FPSHUD.h"
         
        void AFPSHUD::DrawHUD()
        {
            Super::DrawHUD();
         
            if (CrosshairTexture)
            {
                // キャンバスの中心を見つけます。
                FVector2D Center(Canvas->ClipX * 0.5f, Canvas->ClipY * 0.5f);
         
                // テクスチャの半分の長さでオフセットを設定し、キャンバスの中心でテクスチャが揃うようにします。
                FVector2D CrossHairDrawPosition(Center.X - (CrosshairTexture->GetSurfaceWidth() * 0.5f), Center.Y - (CrosshairTexture->GetSurfaceHeight() * 0.5f));
         
                // 中心点に照準線を描画します。
                FCanvasTileItem TileItem(CrossHairDrawPosition, CrosshairTexture->Resource, FLinearColor::White);
                TileItem.BlendMode = SE_BLEND_Translucent;
                Canvas->DrawItem(TileItem);
            }
        }

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

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

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

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page
Related documents