UE4和C++ 开发-Unity 过度到 Unreal 4 对比简化版

#pragma once
#include "GameFramework/Actor.h"
#include "MyActor.generated.h"
UCLASS()
class AMyActor : public AActor
{    
GENERATED_BODY()  
  int Count;  

  // Sets default values for this actor's properties.  
  AMyActor()   
  {      
  // Allows Tick() to be called    
    PrimaryActorTick.bCanEverTick = true; 
     }   
 // Called when the game starts or when spawned.  
  void BeginPlay()   
 {     
   Super::BeginPlay();    
    Count = 0;  
  }   
 // Called every frame. 
   void Tick(float DeltaSeconds)   
 {       
 Super::Tick(DeltaSeconds);   
     Count = Count + 1;   
     GLog->Log(FString::FromInt(Count)); 
   }};  

UCLASS()
class AMyActor : public AActor{  
  GENERATED_BODY()   
 // Called at start of game.    
void BeginPlay(); 
   // Called when destroyed.  
  void EndPlay(const EEndPlayReason::Type EndPlayReason); 
   // Called every frame to update this actor.  
  void Tick(float DeltaSeconds);};  

UCLASS()
class UMyComponent : public UActorComponent{  
  GENERATED_BODY()   
 // Called after the owning Actor was created  
  void InitializeComponent();   
 // Called when the component or the owning Actor is being destroyed   
 void UninitializeComponent();  
  // Component version of Tick   
 void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction);};  

void UMyComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{  
  // Custom tick stuff here  
  Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
}  

AMyActor* CreateCloneOfMyActor(AMyActor* ExistingActor, 
FVector SpawnLocation, 
FRotator SpawnRotation)
{   
 UWorld* World = ExistingActor->GetWorld();  
  FActorSpawnParameters SpawnParams; 
   SpawnParams.Template = ExistingActor; 
   World->SpawnActor<AMyActor>(ExistingActor->GetClass(), SpawnLocation, SpawnRotation, SpawnParams);
}  

UCLASS()
class AMyActor : public AActor{  
  GENERATED_BODY()  
  UPROPERTY()  
  int32 MyIntProp; 
   UPROPERTY()  
  USphereComponent* MyCollisionComp; 
   AMyActor()    {   
     MyIntProp = 42; 
       MyCollisionComp = CreateDefaultSubobject<USphereComponent>(FName(TEXT("CollisionComponent"));     
   MyCollisionComp->RelativeLocation = FVector::ZeroVector;  
      MyCollisionComp->SphereRadius = 20.0f; 
   }};  

Collider collider = gameObject.GetComponent<Collider>;
SphereCollider sphereCollider = collider as SphereCollider;
if (sphereCollider != null)
{   
     // ...
}  

UE4 C++:
UPrimitiveComponent* Primitive = MyActor->GetComponentByClass(UPrimitiveComponent::StaticClass());

USphereComponent* SphereCollider = Cast<USphereComponent>(Primitive);
if (SphereCollider != nullptr)
{ 
       // ...
}  

UMyComponent*MyComp=Cast<UMyComponent>(
MyActor->GetComponentByClass(UMyComponent::StaticClass())
);  

// Find GameObject by name
GameObject MyGO = GameObject.Find("MyNamedGameObject");
// Find Objects by type

MyComponent[] Components = Object.FindObjectsOfType(typeof(MyComponent)) as MyComponent[];

foreach (MyComponent Component in Components)
{   
     // ...
}
// Find GameObjects by tag

GameObject[] GameObjects = GameObject.FindGameObjectsWithTag("MyTag");
foreach (GameObject GO in GameObjects)
{  
      // ...
}
// Find Actor by name (also works on UObjects)

AActor* MyActor = FindObject<AActor>(nullptr, TEXT("MyNamedActor"));
// Find Actors by type (needs a UWorld object)
for (TActorIterator<AMyActor> It(GetWorld()); It; ++It)
{     
   AMyActor* MyActor = *It;   
     // ...
}  

// Find UObjects by type
for (TObjectIterator<UMyObject> It; It; ++it)
{  
  UMyObject* MyObject = *It;   
 // ...
}
// Find Actors by tag (also works on ActorComponents, use TObjectIterator instead)
for (TActorIterator<AActor> It(GetWorld()); It; ++It)
{
    AActor* Actor = *It;   
 if (Actor->ActorHasTag(FName(TEXT("Mytag"))))  
  {   
     // ...  
  }
}  

// Checks if an ActorComponent has this tag

if (MyComponent->ComponentHasTag(FName(TEXT("MyTag"))))
{  
  // ...
}  

APawn* AMyPlayerController::FindPawnCameraIsLookingAt()
{   
 // You can use this to customize various properties about the trace    FCollisionQueryParams Params;  
  // Ignore the player's pawn  
  Params.AddIgnoredActor(GetPawn());  
  // The hit result gets populated by the line trace 
   FHitResult Hit; 
   // Raycast out from the camera, only collide with pawns (they are on the ECC_Pawn collision channel)  
  FVector Start = PlayerCameraManager->GetCameraLocation();  
  FVector End = Start + (PlayerCameraManager->GetCameraRotation().Vector() * 1000.0f);    bool bHit = GetWorld()->LineTraceSingle(Hit, Start, End, ECC_Pawn, Params); 
   if (bHit)  
  {      
  // Hit.Actor contains a weak pointer to the Actor that the trace hit    
    return Cast<APawn>(Hit.Actor.Get());  
  }  
  return nullptr;
}  

UCLASS()
class AMyActor : public AActor
{  
  GENERATED_BODY()
    // My trigger component  
  UPROPERTY()   
 UPrimitiveComponent* Trigger;  
  AMyActor()  
  {       
 Trigger = CreateDefaultSubobject<USphereComponent>(TEXT("TriggerCollider")); 
       // Both colliders need to have this set to true for events to fire        Trigger.bGenerateOverlapEvents = true;   
     // Set the collision mode for the collider  
      // This mode will only enable the collider for raycasts, sweeps, and overlaps        Trigger.SetCollisionEnabled(ECollisionEnabled::QueryOnly); 
   }  
  void BeginPlay()   
 {      
  // Register to find out when an overlap occurs        OnActorBeginOverlap.AddDynamic(this, &AMyActor::OnTriggerEnter);        OnActorEndOverlap.AddDynamic(this, &AMyActor::OnTriggerExit);   
     Super::BeginPlay();  
  }  
  void EndPlay(const EEndPlayReason::Type EndPlayReason)  
  {   
     OnActorBeginOverlap.RemoveDynamic(this, &AMyActor::OnTriggerEnter);        OnActorEndOverlap.RemoveDynamic(this, &AMyActor::OnTriggerExit);        Super:EndPlay(EndPlayReason);   
 }   
 UFUNCTION()  
  void OnTriggerEnter(AActor* Other); 
   UFUNCTION() 
   void OnTriggerExit(AActor* Other);
};  

UCLASS()
class AMyActor : public AActor
{ 
   GENERATED_BODY()    
UPROPERTY()    
UPrimitiveComponent* PhysicalComp;    
AMyActor()    
{        
PhysicalComp = CreateDefaultSubobject<USphereComponent>(TEXT("CollisionAndPhysics"));        PhysicalComp->SetSimulatePhysics(false);        
PhysicalComp->SetPhysicsLinearVelocity(GetActorRotation().Vector() * 100.0f);    
}
};  

UCLASS()
class AMyPlayerController : public APlayerController
{
    GENERATED_BODY()    
void SetupInputComponent()    
{        
Super::SetupInputComponent();        
InputComponent->BindAction("Fire", IE_Pressed, this, &AMyPlayerController::HandleFireInputEvent); 
       InputComponent->BindAxis("Horizontal", this, &AMyPlayerController::HandleHorizontalAxisInputEvent); 
       InputComponent->BindAxis("Vertical", this, &AMyPlayerController::HandleVerticalAxisInputEvent); 
   }    
void HandleFireInputEvent();  
  void HandleHorizontalAxisInputEvent(float Value);
    void HandleVerticalAxisInputEvent(float Value);
};