Klasa AActor

AActor klasa podklasą UObject i reprezentuje rozgrywki obiektów, które mogą być dodawane do poziomu. Klasy dziedziczące z AActor są poprzedzone A.

Niektóre funkcje AActor są osiągane poprzez użycie komponentów. Informacje o translacji, obrocie i skali AActor są uzyskiwane z jego RootComponent . Dlatego AActor musi mieć co najmniej jeden składnik USceneComponent zdefiniowany jako jego RootComponent.

Możesz użyć edytora poziomów, aby dodać aktorów i można ich tworzyć w czasie wykonywania za pomocą funkcji SpawnActor () . Istnieje kilka wersji funkcji SpawnActor () , poniższy przykład pokazuje jedną z nich, przy założeniu, że klasa AActorChild jest podklasą klasy AActor:

FVector SpawnLocation = FVector(0.0f, 0.0f, 0.0f);
    
FRotator SpawnRotation = FRotator(0.0f, 0.0f, 0.0f);    
	
GetWorld()->SpawnActor<AActorChild>(AActorChild::StaticClass(),
                                    SpawnLocation, SpawnRotation );

Kiedy chcesz zniszczyć AActor przykład, można użyć Destroy() funkcję AActor klasie . Możesz również użyć funkcji SetLifeSpan(), aby wskazać czas w sekundach, w którym AActor powinien pozostać przy życiu. Kiedy ten czas minie, AActor zostanie automatycznie zniszczony.

Przykładowe użycie:

W tym przykładzie potrzebujesz zawartość ze Starter Content

Mamy zamiar stworzyć dwóch aktorów: CannonActor i BulletActor . CannonActor utworzy jedną instancję BulletActor na sekundę. BulletActor ruszy do przodu i zostanie zniszczony po 15 sekundach.

Utwórz klasę C ++ o nazwie BulletActor, używając klasy Actor jako klasy nadrzędnej. Plik BulletActor.h musi mieć następującą zawartość:

#pragma once

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

UCLASS()
class TUTOPROJECT_API ABulletActor : public AActor
{
  GENERATED_BODY()
	
public:	
  // Sets default values for this actor's properties
  ABulletActor();

  // Called every frame
  virtual void Tick(float DeltaTime) override;

  virtual void NotifyActorBeginOverlap(AActor* OtherActor) override;

  UPROPERTY(VisibleAnywhere)
  USceneComponent* RootScene;

  UPROPERTY(VisibleAnywhere)
  UStaticMeshComponent* StaticMesh;
	
  UPROPERTY(VisibleAnywhere)
  class UProjectileMovementComponent* ProjectileMovement;


protected:
  // Called when the game starts or when spawned
  virtual void BeginPlay() override;

}; 

BulletActor klasa składa się z trzech komponentów: 

  • USceneComponent:  ma transformację i będzie używany jako składnik główny.
  • UStaticMeshComponent: zawiera Static Mesh, która będzie wizualnie reprezentować aktora.
  • UProjectileMovementComponent : komponent używany do poruszania aktora. Zwróć uwagę, że słowo kluczowe class zostało umieszczone przed definicją zmiennej. Będziesz musiał dodać #include tej klasy w pliku cpp

W pliku BulletActor.cpp definicja konstruktora wygląda następująco:

#include "BulletActor.h"
#include "GameFramework/ProjectileMovementComponent.h"

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

  // Set this actor to call Tick() every frame.  
  PrimaryActorTick.bCanEverTick = true;

  RootScene = CreateDefaultSubobject<USceneComponent>(TEXT("RootScene"));
  RootComponent = RootScene;

  StaticMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("StaticMesh"));
  StaticMesh->SetupAttachment(RootScene);
  StaticMesh->SetCollisionResponseToAllChannels(ECollisionResponse::ECR_Overlap);

  ConstructorHelpers::FObjectFinder<UStaticMesh> MeshFile(
    TEXT("/Game/StarterContent/Shapes/Shape_Sphere.Shape_Sphere"));

  if (MeshFile.Succeeded())
  {
    StaticMesh->SetStaticMesh(MeshFile.Object);
  }
	
  ProjectileMovement = CreateDefaultSubobject<UProjectileMovementComponent>( 
                                             TEXT("ProjectileMovementComp") );
  ProjectileMovement->UpdatedComponent = StaticMesh;
  ProjectileMovement->InitialSpeed = 500.f;
  ProjectileMovement->MaxSpeed = 500.f;
  ProjectileMovement->ProjectileGravityScale = 0.f;

}

Te trzy składniki są inicjowane w konstruktorze. BulletActor wykorzystuje Static Mesh Sphere i będzie poruszać się z prędkością 500 jednostek na sekundę bez grawitacji.

Inne funkcje, które należy zaimplementować w BulletActor.cpp, to:

void ABulletActor::BeginPlay()
{
  Super::BeginPlay();		
	
  SetLifeSpan(15.f);
}

void ABulletActor::NotifyActorBeginOverlap(AActor* OtherActor)
{
  Super::NotifyActorBeginOverlap(OtherActor);

  Destroy();
}

W funkcji BeginPlay() zdefiniowano, że instancja ABulletActor zostanie zniszczona po 15 sekundach. Funkcja NotifyActorBeginOverlap() jest wywoływana, gdy wystąpienie nakłada się na innego aktora. W naszym przykładzie instancja ABulletActor jest niszczona, jeśli tak się stanie.

Teraz utwórz klasę C ++ o nazwie CannonActor, używając klasy Actor jako klasy nadrzędnej. Plik CannonActor.h musi mieć następującą zawartość:

#pragma once

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

UCLASS()
class TUTOPROJECT_API ACannonActor : public AActor
{
  GENERATED_BODY()
	
public:	
  // Sets default values for this actor's properties
  ACannonActor();

  // Called every frame
  virtual void Tick(float DeltaTime) override;

  UPROPERTY(VisibleAnywhere)
  USceneComponent* RootScene;

  UPROPERTY(VisibleAnywhere)
  UStaticMeshComponent* StaticMesh;
	
  FTimerHandle ShotTimerHandle;
	
  void ShootCannon();	

protected:
  // Called when the game starts or when spawned
  virtual void BeginPlay() override;
  
};

ACannonActor klasa posiada stoper, który wywołuje ShootCannon funkcji raz na sekundę, aby utworzyć wystąpienie ABulletActor.

Oto konstruktor znajdujący się w pliku CannonActor.cpp:

#include "CannonActor.h"
#include "BulletActor.h"

// Sets default values
ACannonActor::ACannonActor()
{
  // Set this actor to call Tick() every frame.
  PrimaryActorTick.bCanEverTick = true;

  RootScene = CreateDefaultSubobject<USceneComponent>(TEXT("RootScene"));
  RootComponent = RootScene;

  StaticMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("StaticMesh"));
  StaticMesh->SetupAttachment(RootScene);
	
  ConstructorHelpers::FObjectFinder<UStaticMesh> MeshFile(
    TEXT("/Game/StarterContent/Props/SM_MatPreviewMesh_02.SM_MatPreviewMesh_02"));

  if (MeshFile.Succeeded())
  {
    StaticMesh->SetStaticMesh(MeshFile.Object);
  }
		
}

Timer jest konfigurowany w funkcji BeginPlay(). Funkcja ShootCannon() używa funkcji SpawnActor() do tworzenia instancji ABulletActor w położeniu i obrocie w oparciu o działo:

void ACannonActor::BeginPlay()
{
  Super::BeginPlay();
	
  GetWorldTimerManager().SetTimer(ShotTimerHandle, this,  
                                  &ACannonActor::ShootCannon, 1.f, true);	
}

void ACannonActor::ShootCannon()
{
  FRotator SpawnRotation = GetActorRotation();
	
  FVector SpawnLocation = GetActorLocation() 
                        + SpawnRotation.RotateVector(FVector(180.0f, 0.0f, 180.0f));
	
	
  GetWorld()->SpawnActor<ABulletActor>(ABulletActor::StaticClass(),
                                       SpawnLocation, SpawnRotation );
}

Skompiluj kod C ++ i dodaj wystąpienie CannonActor na poziomie. Uruchom grę i obserwuj, jak armata strzela kulami: 


Źródło:https://romeroblueprints.blogspot.com/2020/11/the-aactor-class.html