自学教程：C++ APawn类代码示例

void ADuckTower::Shoot(float distance){	/*	const FName filename = FName(TEXT("Blueprint'/Game/Blueprints/PickUp.PickUp'"));	FVector loc = GetAttachParentActor()->GetActorLocation();	FRotator rot = GetAttachParentActor()->GetActorRotation();	SpawnBP(GetWorld(), (UClass*)LoadObjFromPath<UBlueprint>(&filename), loc, rot);	*/	APawn *player = UGameplayStatics::GetPlayerController(GetWorld(), 1)->GetControlledPawn();	int randomValue = distance / 10000;	FVector vec = player->GetActorLocation() + FVector(FMath::RandRange(-randomValue, randomValue), FMath::RandRange(-randomValue, randomValue), 0.0f); //+ player->GetRootPrimitiveComponent()->GetPhysicsLinearVelocity() *DeltaSeconds * 10;	FVector vec2 = GetActorLocation();	FVector Direction = vec - vec2;	FRotator test = FRotationMatrix::MakeFromX(Direction).Rotator();	FRotator test2 = FRotator(1.0f, 0.0f, 0.0f);	FRotator finalrot = FRotator(test.Quaternion() * test2.Quaternion());	FVector forward = GetActorForwardVector();	finalrot.Roll = -finalrot.Roll;	finalrot.Yaw = -finalrot.Yaw;	finalrot.Pitch = -finalrot.Pitch;	FVector loc = GetActorLocation() + forward * 500.0f;	FRotator rot = GetActorRotation();	AActor* actor = GetWorld()->SpawnActor<AActor>(BulletBlueprint, loc, GetActorRotation());	actor->SetActorScale3D(FVector(3.0f, 3.0f, 3.0f));	//actor->GetRootPrimitiveComponent()->AddImpulse(actor->GetActorForwardVector()* 5000.0f);	//actor->GetRootPrimitiveComponent()->SetPhysicsLinearVelocity(actor->GetActorForwardVector()*10000.0f); //* (distance/10000 * 1.0f));}

/** Function called to search for an enemy  - parameter void: - returns: void */void AEnemyController::SearchForEnemy(){    APawn* MyEnemy = GetPawn();    if (MyEnemy == NULL)        return;        const FVector MyLoc = MyEnemy->GetActorLocation();    float BestDistSq = MAX_FLT;    ATankCharacter* BestPawn = NULL;        for (FConstPawnIterator It = GetWorld()->GetPawnIterator(); It; It++)    {        ATankCharacter* TestPawn = Cast<ATankCharacter>(*It);        if (TestPawn)        {            const float DistSq = FVector::Dist(TestPawn->GetActorLocation(), MyLoc);            bool canSee = LineOfSightTo(TestPawn);                        //choose the closest option to the AI that can be seen            if (DistSq < BestDistSq && canSee)            {                BestDistSq = DistSq;                BestPawn = TestPawn;            }        }    }        if (BestPawn)    {        GEngine->AddOnScreenDebugMessage(0, 1.0f, FColor::Green, BestPawn->GetName());        SetEnemy(BestPawn);            }}

void AFournoidAIController::FindClosestEnemy(){	APawn* MyBot = GetPawn();	if (MyBot == NULL)	{		return;	}		const FVector MyLoc = MyBot->GetActorLocation();	float BestDistSq = MAX_FLT;	AFournoidCharacter* BestPawn = NULL;		for (FConstPawnIterator It = GetWorld()->GetPawnIterator(); It; ++It)	{		AFournoidCharacter* TestPawn = Cast<AFournoidCharacter>(*It);		if (TestPawn && TestPawn->IsAlive() && TestPawn->GetController()->IsA(APlayerController::StaticClass()))		{			const float DistSq = (TestPawn->GetActorLocation() - MyLoc).SizeSquared();			if (DistSq < BestDistSq &&  sqrt(DistSq) < 2500.f )			{				BestDistSq = DistSq;				BestPawn = TestPawn;			}		}	}		if (BestPawn)	{		SetEnemy(BestPawn);	}else {		SetEnemy(NULL);	}}

void AGameplayDebuggingReplicator::DebugNextPawn(UClass* CompareClass, APawn* CurrentPawn){#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)	APawn* LastSeen = nullptr;	APawn* FirstSeen = nullptr;	// Search through the list looking for the next one of this type	for (FConstPawnIterator It = GetWorld()->GetPawnIterator(); It; It++)	{		APawn* IterPawn = *It;		if (IterPawn->IsA(CompareClass))		{			if (LastSeen == CurrentPawn)			{				ServerSetActorToDebug(IterPawn);				return;			}			LastSeen = IterPawn;			if (FirstSeen == nullptr)			{				FirstSeen = IterPawn;			}		}	}	// See if we need to wrap around the list	if (FirstSeen != nullptr)	{		ServerSetActorToDebug(FirstSeen);	}#endif}

void ADuckTower::Tick(float DeltaSeconds){	Super::Tick(DeltaSeconds);	/*	AActor *actor = GetAttachParentActor();	FVector actor2 = UGameplayStatics::GetPlayerController(GetWorld(), 0)->GetControlledPawn()->GetActorLocation();	FRotator newRotation = FRotationMatrix::MakeFromX(actor2 - actor->GetActorLocation()).Rotator();	GetAttachParentActor()->SetActorRotation(newRotation);	GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Yellow, actor->GetName());	*//*	FVector actor2 = UGameplayStatics::GetPlayerController(GetWorld(), 0)->GetControlledPawn()->GetActorLocation();	FVector actor = GetAttachParentActor()->GetActorLocation();	FVector Direction = actor - actor2;	FRotator test = FRotationMatrix::MakeFromX(Direction).Rotator();	GetAttachParentActor()->SetActorRotation(test);	GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Yellow, actor2.ToString());	*/	//GetAttachParentActor()->SetActorLocation(FVector(0.0f, 0.0f, (float)testNumber));	//testNumber += 1.f;	APawn *player = UGameplayStatics::GetPlayerController(GetWorld(), 0)->GetControlledPawn();	FVector actor2 = player->GetActorLocation(); //+ player->GetRootPrimitiveComponent()->GetPhysicsLinearVelocity() *DeltaSeconds * 10;	FVector actor = GetActorLocation();	FVector Direction = actor - actor2;	FRotator test = FRotationMatrix::MakeFromX(Direction).Rotator();	FRotator test2 = FRotator(1.0f, 0.0f, 0.0f);	FRotator finalrot = FRotator(test.Quaternion() * test2.Quaternion());	FVector vec2 = UGameplayStatics::GetPlayerController(GetWorld(), 0)->GetControlledPawn()->GetActorLocation();	FVector vec = GetActorLocation();	float distance = FVector::Dist(actor, actor2);	//finalrot.Pitch -= 10 - distance / 10000 * 10;	//SetActorRotation(finalrot);	TArray<UStaticMeshComponent*> comps;	GetComponents(comps);	/*	for (auto StaticMeshComponent : comps)	{	StaticMeshComponent->SetVisibility(true);	StaticMeshComponent->SetWorldRotation(finalrot);	GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Blue, StaticMeshComponent->GetComponentRotation().ToString());	}*/	if (UGameplayStatics::GetPlayerController(GetWorld(), 0)->WasInputKeyJustPressed(EKeys::I))	{	}	if (shootTimer <= 0.f)	{		Shoot(distance);		shootTimer = 2.f;	}	else		shootTimer -= DeltaSeconds;	//GetAttachParentActor()->GetRootPrimitiveComponent()->AddImpulse(UGameplayStatics::GetPlayerController(GetWorld(), 0)->GetControlledPawn()->GetActorForwardVector());	//GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Yellow, FString::FromInt(testNumber));	//GetAttachParentActor()->SetActorRotation()}

FExecStatus FCameraCommandHandler::GetActorRotation(const TArray<FString>& Args){	APawn* Pawn = FUE4CVServer::Get().GetPawn();	FRotator CameraRotation = Pawn->GetControlRotation();	FString Message = FString::Printf(TEXT("%.3f %.3f %.3f"), CameraRotation.Pitch, CameraRotation.Yaw, CameraRotation.Roll);	return FExecStatus::OK(Message);}

FExecStatus FCameraCommandHandler::GetActorLocation(const TArray<FString>& Args){	APawn* Pawn = FUE4CVServer::Get().GetPawn();	FVector CameraLocation = Pawn->GetActorLocation();	FString Message = FString::Printf(TEXT("%.3f %.3f %.3f"), CameraLocation.X, CameraLocation.Y, CameraLocation.Z);	return FExecStatus::OK(Message);}

APawn* UAIBlueprintHelperLibrary::SpawnAIFromClass(UObject* WorldContextObject, TSubclassOf<APawn> PawnClass, UBehaviorTree* BehaviorTree, FVector Location, FRotator Rotation, bool bNoCollisionFail){	APawn* NewPawn = NULL;	UWorld* World = GEngine->GetWorldFromContextObject(WorldContextObject);	if (World && *PawnClass)	{		FActorSpawnParameters ActorSpawnParams;		ActorSpawnParams.bNoCollisionFail = bNoCollisionFail;		NewPawn = World->SpawnActor<APawn>(*PawnClass, Location, Rotation, ActorSpawnParams);		if (NewPawn != NULL)		{			if (NewPawn->Controller == NULL)			{	// NOTE: SpawnDefaultController ALSO calls Possess() to possess the pawn (if a controller is successfully spawned).				NewPawn->SpawnDefaultController();			}			if (BehaviorTree != NULL)			{				AAIController* AIController = Cast<AAIController>(NewPawn->Controller);				if (AIController != NULL)				{					AIController->RunBehaviorTree(BehaviorTree);				}			}		}	}	return NewPawn;}

FExecStatus FCameraCommandHandler::GetCameraRotation(const TArray<FString>& Args){	if (Args.Num() == 1)	{		bool bIsMatinee = false;		FRotator CameraRotation;		ACineCameraActor* CineCameraActor = nullptr;		for (AActor* Actor : this->GetWorld()->GetCurrentLevel()->Actors)		{			// if (Actor && Actor->IsA(AMatineeActor::StaticClass())) // AMatineeActor is deprecated			if (Actor && Actor->IsA(ACineCameraActor::StaticClass()))			{				bIsMatinee = true;				CameraRotation = Actor->GetActorRotation();				break;			}		}		if (!bIsMatinee)		{			int32 CameraId = FCString::Atoi(*Args[0]); // TODO: Add support for multiple cameras			APawn* Pawn = FUE4CVServer::Get().GetPawn();			CameraRotation = Pawn->GetControlRotation();		}		FString Message = FString::Printf(TEXT("%.3f %.3f %.3f"), CameraRotation.Pitch, CameraRotation.Yaw, CameraRotation.Roll);		return FExecStatus::OK(Message);	}	return FExecStatus::Error("Number of arguments incorrect");}

//----------------------------------------------------------------------//// FAITestSpawnInfo//----------------------------------------------------------------------//bool FAITestSpawnInfo::Spawn(AFunctionalAITest* AITest) const{	check(AITest);	bool bSuccessfullySpawned = false;	APawn* SpawnedPawn = UAIBlueprintHelperLibrary::SpawnAIFromClass(AITest->GetWorld(), PawnClass, BehaviorTree		, SpawnLocation->GetActorLocation()		, SpawnLocation->GetActorRotation()		, /*bNoCollisionFail=*/true);	if (SpawnedPawn == NULL)	{		FString FailureMessage = FString::Printf(TEXT("Failed to spawn /'%s/' pawn (/'%s/' set) ")			, *GetNameSafe(PawnClass)			, *SpawnSetName.ToString());		UE_LOG(LogFunctionalTest, Warning, TEXT("%s"), *FailureMessage);	}	else if (SpawnedPawn->GetController() == NULL)	{		FString FailureMessage = FString::Printf(TEXT("Spawned Pawn %s (/'%s/' set) has no controller ")			, *GetNameSafe(SpawnedPawn)			, *SpawnSetName.ToString());		UE_LOG(LogFunctionalTest, Warning, TEXT("%s"), *FailureMessage);	}	else	{		AITest->AddSpawnedPawn(*SpawnedPawn);		bSuccessfullySpawned = true;	}	return bSuccessfullySpawned;}

void AVehicleSpawnerBase::SpawnVehicleAttempt(){	if(Vehicles.Num()>=NumberOfVehicles) 	{	  UE_LOG(LogCarla, Log, TEXT("All vehicles spawned correctly"));	  return;	}		APlayerStart* spawnpoint = GetRandomSpawnPoint();	APawn* playerpawn = UGameplayStatics::GetPlayerPawn(GetWorld(),0);	const float DistanceToPlayer = playerpawn&&spawnpoint? FVector::Distance(playerpawn->GetActorLocation(),spawnpoint->GetActorLocation()):0.0f;	float NextTime = TimeBetweenSpawnAttemptsAfterBegin;	if(DistanceToPlayer>DistanceToPlayerBetweenSpawnAttemptsAfterBegin)	{	  if(SpawnVehicleAtSpawnPoint(*spawnpoint)!=nullptr)	  {	      UE_LOG(LogCarla, Log, TEXT("Vehicle %d/%d late spawned"), Vehicles.Num(), NumberOfVehicles);	  }	} else	{	  NextTime /= 2.0f;	}		if(Vehicles.Num()<NumberOfVehicles)	{	  auto &timemanager = GetWorld()->GetTimerManager();	  if(AttemptTimerHandle.IsValid()) timemanager.ClearTimer(AttemptTimerHandle);	  timemanager.SetTimer(AttemptTimerHandle,this, &AVehicleSpawnerBase::SpawnVehicleAttempt,NextTime,false,-1);	} else	{	  UE_LOG(LogCarla, Log, TEXT("All vehicles spawned correctly"));	}}

void AGameplayDebuggingHUDComponent::DrawOverHeadInformation(APlayerController* PC, class UGameplayDebuggingComponent *DebugComponent){#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)	APawn* MyPawn = Cast<APawn>(DebugComponent->GetSelectedActor());	const FVector Loc3d = MyPawn ? MyPawn->GetActorLocation() + FVector(0.f, 0.f, MyPawn->GetSimpleCollisionHalfHeight()) : FVector::ZeroVector;	if (OverHeadContext.Canvas->SceneView == NULL || OverHeadContext.Canvas->SceneView->ViewFrustum.IntersectBox(Loc3d, FVector::ZeroVector) == false)	{		return;	}	const FVector ScreenLoc = OverHeadContext.Canvas->Project(Loc3d);	static const FVector2D FontScale(1.f, 1.f);	UFont* Font = GEngine->GetSmallFont();	float TextXL = 0.f;	float YL = 0.f;	FString ObjectName = FString::Printf( TEXT("{yellow}%s {white}(%s)"), *DebugComponent->ControllerName, *DebugComponent->PawnName);	CalulateStringSize(OverHeadContext, OverHeadContext.Font, ObjectName, TextXL, YL);	bool bDrawFullOverHead = MyPawn != nullptr && GetDebuggingReplicator()->GetSelectedActorToDebug() == MyPawn;	float IconXLocation = OverHeadContext.DefaultX;	float IconYLocation = OverHeadContext.DefaultY;	if (bDrawFullOverHead)	{		OverHeadContext.DefaultX -= (0.5f*TextXL*FontScale.X);		OverHeadContext.DefaultY -= (1.2f*YL*FontScale.Y);		IconYLocation = OverHeadContext.DefaultY;		OverHeadContext.CursorX = OverHeadContext.DefaultX;		OverHeadContext.CursorY = OverHeadContext.DefaultY;	}	if (DebugComponent->DebugIcon.Len() > 0)	{		UTexture2D* RegularIcon = (UTexture2D*)StaticLoadObject(UTexture2D::StaticClass(), NULL, *DebugComponent->DebugIcon, NULL, LOAD_NoWarn | LOAD_Quiet, NULL);		if (RegularIcon)		{			FCanvasIcon Icon = UCanvas::MakeIcon(RegularIcon);			if (Icon.Texture)			{				const float DesiredIconSize = bDrawFullOverHead ? 32.f : 16.f;				DrawIcon(OverHeadContext, FColor::White, Icon, IconXLocation, IconYLocation - DesiredIconSize, DesiredIconSize / Icon.Texture->GetSurfaceWidth());			}		}	}	if (bDrawFullOverHead)	{		OverHeadContext.FontRenderInfo.bEnableShadow = bDrawFullOverHead;		PrintString(OverHeadContext, bDrawFullOverHead ? FColor::White : FColor(255, 255, 255, 128), FString::Printf(TEXT("%s/n"), *ObjectName));		OverHeadContext.FontRenderInfo.bEnableShadow = false;	}	if (EngineShowFlags.DebugAI)	{		DrawPath(PC, DebugComponent);	}#endif //!(UE_BUILD_SHIPPING || UE_BUILD_TEST)}

AAIController* UAIBlueprintHelperLibrary::GetAIController(AActor* ControlledActor){	APawn* AsPawn = Cast<APawn>(ControlledActor);	if (AsPawn != nullptr)	{		return Cast<AAIController>(AsPawn->GetController());	}	return Cast<AAIController>(ControlledActor);}

bool FGameplayCueHandler::OwnerIsLocallyControlled() const{	APawn* Pawn = Cast<APawn>(Owner);	if (Pawn)	{		return Pawn->IsLocallyControlled();	}	return false;}

void UMyAnimInstance::NativeUpdateAnimation(float DeltaSeconds){	Super::NativeUpdateAnimation(DeltaSeconds);	APawn* OwningPawn = TryGetPawnOwner();	if (OwningPawn)	{		Speed = OwningPawn->GetVelocity().Size();	}}

void AGameplayDebuggerReplicator::SelectTargetToDebug(){#if ENABLED_GAMEPLAY_DEBUGGER	APlayerController* MyPC = DebugCameraController.IsValid() ? DebugCameraController.Get() : GetLocalPlayerOwner();	if (MyPC)	{		float bestAim = 0;		FVector CamLocation;		FRotator CamRotation;		check(MyPC->PlayerCameraManager != nullptr);		MyPC->PlayerCameraManager->GetCameraViewPoint(CamLocation, CamRotation);		FVector FireDir = CamRotation.Vector();		UWorld* World = MyPC->GetWorld();		check(World);		APawn* PossibleTarget = nullptr;		for (FConstPawnIterator Iterator = World->GetPawnIterator(); Iterator; ++Iterator)		{			APawn* NewTarget = *Iterator;			if (NewTarget == nullptr || NewTarget == MyPC->GetPawn()				|| (NewTarget->PlayerState != nullptr && NewTarget->PlayerState->bIsABot == false)				|| NewTarget->GetActorEnableCollision() == false)			{				continue;			}			if (NewTarget != MyPC->GetPawn())			{				// look for best controlled pawn target				const FVector AimDir = NewTarget->GetActorLocation() - CamLocation;				float FireDist = AimDir.SizeSquared();				// only find targets which are < 25000 units away				if (FireDist < 625000000.f)				{					FireDist = FMath::Sqrt(FireDist);					float newAim = FVector::DotProduct(FireDir, AimDir);					newAim = newAim / FireDist;					if (newAim > bestAim)					{						PossibleTarget = NewTarget;						bestAim = newAim;					}				}			}		}		if (PossibleTarget != nullptr && PossibleTarget != LastSelectedActorToDebug)		{			ServerSetActorToDebug(Cast<AActor>(PossibleTarget));		}	}#endif //ENABLED_GAMEPLAY_DEBUGGER}

void UNavLinkCustomComponent::CollectNearbyAgents(TArray<UPathFollowingComponent*>& NotifyList){	AActor* MyOwner = GetOwner();	if (BroadcastRadius < KINDA_SMALL_NUMBER || MyOwner == NULL)	{		return;	}	static FName SmartLinkBroadcastTrace(TEXT("SmartLinkBroadcastTrace"));	FCollisionQueryParams Params(SmartLinkBroadcastTrace, false, MyOwner);	TArray<FOverlapResult> OverlapsL, OverlapsR;	const FVector LocationL = GetStartPoint();	const FVector LocationR = GetEndPoint();	const float LinkDistSq = (LocationL - LocationR).SizeSquared();	const float DistThresholdSq = FMath::Square(BroadcastRadius * 0.25f);	if (LinkDistSq > DistThresholdSq)	{		GetWorld()->OverlapMultiByChannel(OverlapsL, LocationL, FQuat::Identity, BroadcastChannel, FCollisionShape::MakeSphere(BroadcastRadius), Params);		GetWorld()->OverlapMultiByChannel(OverlapsR, LocationR, FQuat::Identity, BroadcastChannel, FCollisionShape::MakeSphere(BroadcastRadius), Params);	}	else	{		const FVector MidPoint = (LocationL + LocationR) * 0.5f;		GetWorld()->OverlapMultiByChannel(OverlapsL, MidPoint, FQuat::Identity, BroadcastChannel, FCollisionShape::MakeSphere(BroadcastRadius), Params);	}	TArray<APawn*> PawnList;	for (int32 i = 0; i < OverlapsL.Num(); i++)	{		APawn* MovingPawn = Cast<APawn>(OverlapsL[i].GetActor());		if (MovingPawn && MovingPawn->GetController())		{			PawnList.Add(MovingPawn);		}	}	for (int32 i = 0; i < OverlapsR.Num(); i++)	{		APawn* MovingPawn = Cast<APawn>(OverlapsR[i].GetActor());		if (MovingPawn && MovingPawn->GetController())		{			PawnList.AddUnique(MovingPawn);		}	}	for (int32 i = 0; i < PawnList.Num(); i++)	{		UPathFollowingComponent* NavComp = PawnList[i]->GetController()->FindComponentByClass<UPathFollowingComponent>();		if (NavComp)// && NavComp->WantsSmartLinkUpdates())		{			NotifyList.Add(NavComp);		}	}}

/**	Change the Pawn's base. */void ACharacter::SetBase( UPrimitiveComponent* NewBaseComponent, bool bNotifyPawn ){	if (NewBaseComponent != MovementBase)	{		// Verify no recursion.		APawn* Loop = (NewBaseComponent ? Cast<APawn>(NewBaseComponent->GetOwner()) : NULL);		for(  ; Loop!=NULL; Loop=Cast<APawn>(Loop->GetMovementBase()) )		{			if( Loop == this )			{				UE_LOG(LogCharacter, Warning, TEXT(" SetBase failed! Recursion detected. Pawn %s already based on %s."), *GetName(), *NewBaseComponent->GetName());				return;			}		}		// Set base.		MovementBase = NewBaseComponent;		if (Role == ROLE_Authority)		{			// Update replicated value			UE_LOG(LogCharacter, Verbose, TEXT("Setting base on server for '%s' to '%s'"), *GetName(), *GetFullNameSafe(NewBaseComponent));			RelativeMovement.MovementBase = NewBaseComponent;			RelativeMovement.bServerHasBaseComponent = (NewBaseComponent != NULL); // Flag whether the server had a non-null base.		}		else		{			UE_LOG(LogCharacter, Verbose, TEXT("Setting base on CLIENT for '%s' to '%s'"), *GetName(), *GetFullNameSafe(NewBaseComponent));		}		// Update relative location/rotation		if ( Role == ROLE_Authority || Role == ROLE_AutonomousProxy )		{			if (MovementBaseUtility::UseRelativePosition(MovementBase))			{				RelativeMovement.Location = GetActorLocation() - MovementBase->GetComponentLocation();				RelativeMovement.Rotation = (FRotationMatrix(GetActorRotation()) * FRotationMatrix(MovementBase->GetComponentRotation()).GetTransposed()).Rotator();			}		}		// Notify this actor of his new floor.		if ( bNotifyPawn )		{			BaseChange();		}		if (MovementBase && CharacterMovement)		{			// Update OldBaseLocation/Rotation as those were referring to a different base			CharacterMovement->OldBaseLocation = MovementBase->GetComponentLocation();			CharacterMovement->OldBaseRotation = MovementBase->GetComponentRotation();		}	}}

bool UPlayer::Exec( UWorld* InWorld, const TCHAR* Cmd,FOutputDevice& Ar){	if(PlayerController)	{		// Since UGameViewportClient calls Exec on UWorld, we only need to explicitly		// call UWorld::Exec if we either have a null GEngine or a null ViewportClient		UWorld* World = PlayerController->GetWorld();		check(World);		check(InWorld == NULL || InWorld == World);		const bool bWorldNeedsExec = GEngine == NULL || Cast<ULocalPlayer>(this) == NULL || static_cast<ULocalPlayer*>(this)->ViewportClient == NULL;		APawn* PCPawn = PlayerController->GetPawnOrSpectator();		if( bWorldNeedsExec && World->Exec(World, Cmd,Ar) )		{			return true;		}		else if( PlayerController->PlayerInput && PlayerController->PlayerInput->ProcessConsoleExec(Cmd,Ar,PCPawn) )		{			return true;		}		else if( PlayerController->ProcessConsoleExec(Cmd,Ar,PCPawn) )		{			return true;		}		else if( PCPawn && PCPawn->ProcessConsoleExec(Cmd,Ar,PCPawn) )		{			return true;		}		else if( PlayerController->MyHUD && PlayerController->MyHUD->ProcessConsoleExec(Cmd,Ar,PCPawn) )		{			return true;		}		else if( World->GetGameInstance() && World->GetGameInstance()->ProcessConsoleExec(Cmd, Ar, PCPawn) )		{			return true;		}		else if( World->GetAuthGameMode() && World->GetAuthGameMode()->ProcessConsoleExec(Cmd,Ar,PCPawn) )		{			return true;		}		else if( PlayerController->CheatManager && PlayerController->CheatManager->ProcessConsoleExec(Cmd,Ar,PCPawn) )		{			return true;		}		else if (World->GameState && World->GameState->ProcessConsoleExec(Cmd, Ar, PCPawn))		{			return true;		}		else if (PlayerController->PlayerCameraManager && PlayerController->PlayerCameraManager->ProcessConsoleExec(Cmd, Ar, PCPawn))		{			return true;		}	}	return false;}

void UBTTask_FlyTo::TickPathNavigation(UBehaviorTreeComponent& OwnerComp, FBT_FlyToTarget* MyMemory, float DeltaSeconds){	const auto& queryResults = MyMemory->QueryResults;	APawn* pawn = OwnerComp.GetAIOwner()->GetPawn();		if (DebugParams.bVisualizePawnAsVoxels)		NavigationManager->Debug_DrawVoxelCollisionProfile(Cast<UPrimitiveComponent>(pawn->GetRootComponent()));		FVector flightDirection = queryResults.PathSolutionOptimized[MyMemory->solutionTraversalIndex] - pawn->GetActorLocation();	//auto navigator = Cast<IDonNavigator>(pawn);	// Add movement input:	if (MyMemory->bIsANavigator)	{		// Customized movement handling for advanced users:		IDonNavigator::Execute_AddMovementInputCustom(pawn, flightDirection, 1.f);	}	else	{		// Default movement (handled by Pawn or Character class)		pawn->AddMovementInput(flightDirection, 1.f);	}	FVector test = FVector(10,10,100);	//test.			// Reached next segment:	if (flightDirection.Size() <= MinimumProximityRequired)	{		// Goal reached?		if (MyMemory->solutionTraversalIndex == queryResults.PathSolutionOptimized.Num() - 1)		{			UBlackboardComponent* blackboard = pawn->GetController()->FindComponentByClass<UBlackboardComponent>();			blackboard->SetValueAsBool(FlightResultKey.SelectedKeyName, true);			blackboard->SetValueAsBool(KeyToFlipFlopWhenTaskExits.SelectedKeyName, !blackboard->GetValueAsBool(KeyToFlipFlopWhenTaskExits.SelectedKeyName));			// Unregister all dynamic collision listeners. We've completed our task and are no longer interested in listening to these:			NavigationManager->StopListeningToDynamicCollisionsForPath(MyMemory->DynamicCollisionListener, queryResults);			FinishLatentTask(OwnerComp, EBTNodeResult::Succeeded);			return;		}		else		{			MyMemory->solutionTraversalIndex++;		}	}}

bool FGameplayEffectContext::IsLocallyControlled() const{	APawn* Pawn = Cast<APawn>(Instigator.Get());	if (!Pawn)	{		Pawn = Cast<APawn>(EffectCauser.Get());	}	if (Pawn)	{		return Pawn->IsLocallyControlled();	}	return false;}

void UPawnNoiseEmitterComponent::MakeNoise(AActor* NoiseMaker, float Loudness, const FVector& NoiseLocation){	if (!NoiseMaker || Loudness <= 0.f)	{		return;	}	// Get the Pawn that owns us, either directly or through a possible Controller owner.	AActor* Owner = GetOwner();	APawn* PawnOwner = Cast<APawn>(Owner);	if (PawnOwner == NULL)	{		AController* OwnerController = Cast<AController>(Owner);		if (IsValid(OwnerController))		{			PawnOwner = OwnerController->GetPawn();		}	}	// only emit sounds from pawns with controllers	if (!IsValid(PawnOwner) || !PawnOwner->Controller)	{		return;	}	// Was this noise made locally by this pawn?	if ( NoiseMaker == PawnOwner || ((PawnOwner->GetActorLocation() - NoiseLocation).SizeSquared() <= FMath::Square(PawnOwner->GetSimpleCollisionRadius())) )	{		// use loudest noise within NoiseLifetime		// Do not reset volume to zero after time has elapsed; sensors detecting the sound can choose for themselves how long to care about sounds.		const bool bNoiseExpired = (GetWorld()->GetTimeSeconds() - LastLocalNoiseTime) > NoiseLifetime;		if (bNoiseExpired || Loudness >= LastLocalNoiseVolume)		{			LastLocalNoiseVolume = Loudness;			LastLocalNoiseTime = GetWorld()->GetTimeSeconds();		}	}	// noise is not local - use loudest in this period	else	{		const bool bNoiseExpired = (GetWorld()->GetTimeSeconds() - LastRemoteNoiseTime) > NoiseLifetime;		if (bNoiseExpired || Loudness >= LastRemoteNoiseVolume)		{			LastRemoteNoiseVolume = Loudness;			LastRemoteNoisePosition = NoiseLocation;			LastRemoteNoiseTime = GetWorld()->GetTimeSeconds();		}	}}

AAIController* UAITask::GetAIControllerForActor(AActor* Actor){	AAIController* Result = Cast<AAIController>(Actor);	if (Result == nullptr)	{		APawn* AsPawn = Cast<APawn>(Actor);		if (AsPawn != nullptr)		{			Result = Cast<AAIController>(AsPawn->GetController());		}	}	return Result;}

FExecStatus FCameraCommandHandler::SetCameraRotation(const TArray<FString>& Args){	if (Args.Num() == 4) // ID, Pitch, Roll, Yaw	{		int32 CameraId = FCString::Atoi(*Args[0]); // TODO: Add support for multiple cameras		float Pitch = FCString::Atof(*Args[1]), Yaw = FCString::Atof(*Args[2]), Roll = FCString::Atof(*Args[3]);		FRotator Rotator = FRotator(Pitch, Yaw, Roll);		APawn* Pawn = FUE4CVServer::Get().GetPawn();		AController* Controller = Pawn->GetController();		Controller->ClientSetRotation(Rotator); // Teleport action		// SetActorRotation(Rotator);  // This is not working		return FExecStatus::OK();	}	return FExecStatus::InvalidArgument;}

PyObject *py_ue_pawn_get_controller(ue_PyUObject * self, PyObject * args) {	ue_py_check(self);	if (!self->ue_object->IsA<APawn>()) {		return PyErr_Format(PyExc_Exception, "uobject is not an APawn");	}	APawn *pawn = (APawn *)self->ue_object;	ue_PyUObject *ret = ue_get_python_wrapper(pawn->GetController());	if (!ret)		return PyErr_Format(PyExc_Exception, "uobject is in invalid state");	Py_INCREF(ret);	return (PyObject *)ret;}

UBlackboardComponent* UKismetAIHelperLibrary::GetBlackboard(AActor* Target){	UBlackboardComponent* BlackboardComp = NULL;	APawn* TargetPawn = Cast<APawn>(Target);	if (TargetPawn && TargetPawn->GetController())	{		BlackboardComp = TargetPawn->GetController()->FindComponentByClass<UBlackboardComponent>();	}	if (BlackboardComp == NULL && Target)	{		BlackboardComp = Target->FindComponentByClass<UBlackboardComponent>();	}	return BlackboardComp;}

void USoundNodeLocalPlayer::ParseNodes(FAudioDevice* AudioDevice, const UPTRINT NodeWaveInstanceHash, FActiveSound& ActiveSound, const FSoundParseParameters& ParseParams, TArray<FWaveInstance*>& WaveInstances){	// The accesses to the Pawn will be unsafe once we thread audio, deal with this at that point	check(IsInGameThread());	AActor* SoundOwner = ActiveSound.AudioComponent.IsValid() ? ActiveSound.AudioComponent->GetOwner() : NULL;	APlayerController* PCOwner = Cast<APlayerController>(SoundOwner);	APawn* PawnOwner = (PCOwner ? PCOwner->GetPawn() : Cast<APawn>(SoundOwner));	const bool bLocallyControlled = PawnOwner && PawnOwner->IsLocallyControlled() && Cast<APlayerController>(PawnOwner->Controller);	const int32 PlayIndex = bLocallyControlled ? 0 : 1;	if (PlayIndex < ChildNodes.Num() && ChildNodes[PlayIndex])	{		ChildNodes[PlayIndex]->ParseNodes(AudioDevice, GetNodeWaveInstanceHash(NodeWaveInstanceHash, ChildNodes[PlayIndex], PlayIndex), ActiveSound, ParseParams, WaveInstances);	}}

FExecStatus FCameraCommandHandler::GetCameraPose(const TArray<FString>& Args){  if (Args.Num() == 1)  {    bool bIsMatinee = false;    FVector CameraLocation;    FRotator CameraRotation;    ACineCameraActor* CineCameraActor = nullptr;    for (AActor* Actor : this->GetWorld()->GetCurrentLevel()->Actors)    {      // if (Actor && Actor->IsA(AMatineeActor::StaticClass())) // AMatineeActor is deprecated      if (Actor && Actor->IsA(ACineCameraActor::StaticClass()))      {        bIsMatinee = true;        CameraLocation = Actor->GetActorLocation();        CameraRotation = Actor->GetActorRotation();        break;      }    }    if (!bIsMatinee)    {//      int32 CameraId = FCString::Atoi(*Args[0]); // TODO: Add support for multiple cameras      // This should support multiple cameras//      UGTCaptureComponent* CaptureComponent = FCaptureManager::Get().GetCamera(CameraId);//      if (CaptureComponent == nullptr)//      {//        return FExecStatus::Error(FString::Printf(TEXT("Camera %d can not be found."), CameraId));//      }//      CameraLocation = CaptureComponent->GetComponentLocation();//      CameraRotation = CaptureComponent->GetComponentRotation();      APawn* Pawn = FUE4CVServer::Get().GetPawn();      CameraLocation = Pawn->GetActorLocation();      CameraRotation = Pawn->GetControlRotation();    }    FString Message = FString::Printf(TEXT("%.3f %.3f %.3f %.3f %.3f %.3f"),                                      CameraLocation.X, CameraLocation.Y, CameraLocation.Z,                                      CameraRotation.Pitch, CameraRotation.Yaw, CameraRotation.Roll);    return FExecStatus::OK(Message);  }  return FExecStatus::Error("Number of arguments incorrect");}

void FGameplayDebuggerCategory_Navmesh::CollectData(APlayerController* OwnerPC, AActor* DebugActor){#if WITH_RECAST	ARecastNavMesh* NavData = nullptr;	APawn* PlayerPawn = OwnerPC ? OwnerPC->GetPawnOrSpectator() : nullptr;	APawn* DebugActorAsPawn = Cast<APawn>(DebugActor);	APawn* DestPawn = DebugActorAsPawn ? DebugActorAsPawn : PlayerPawn;	if (DestPawn)	{		UNavigationSystem* NavSys = UNavigationSystem::GetCurrent(OwnerPC->GetWorld());		const FNavAgentProperties& NavAgentProperties = DestPawn->GetNavAgentPropertiesRef();		NavData = Cast<ARecastNavMesh>(NavSys->GetNavDataForProps(NavAgentProperties));	}	if (NavData)	{		// add 3x3 neighborhood of target		const FVector TargetLocation = DestPawn->GetActorLocation();		TArray<int32> TileSet;		int32 TileX = 0;		int32 TileY = 0;		const int32 DeltaX[] = { 0, 1, 1, 0, -1, -1, -1, 0, 1 };		const int32 DeltaY[] = { 0, 0, 1, 1, 1, 0, -1, -1, -1 };		int32 TargetTileX = 0;		int32 TargetTileY = 0;		NavData->GetNavMeshTileXY(TargetLocation, TargetTileX, TargetTileY);		for (int32 Idx = 0; Idx < ARRAY_COUNT(DeltaX); Idx++)		{			const int32 NeiX = TargetTileX + DeltaX[Idx];			const int32 NeiY = TargetTileY + DeltaY[Idx];			NavData->GetNavMeshTilesAt(NeiX, NeiY, TileSet);		}		const int32 DetailFlags =			(1 << static_cast<int32>(ENavMeshDetailFlags::PolyEdges)) |			(1 << static_cast<int32>(ENavMeshDetailFlags::FilledPolys)) |			(1 << static_cast<int32>(ENavMeshDetailFlags::NavLinks));		NavmeshRenderData.GatherData(NavData, DetailFlags, TileSet);	}#endif // WITH_RECAST}

void UPerceptionGameplayDebuggerObject::CollectDataToReplicate(APlayerController* MyPC, AActor *SelectedActor){	Super::CollectDataToReplicate(MyPC, SelectedActor);#if ENABLED_GAMEPLAY_DEBUGGER	if (GetWorld()->TimeSeconds - LastDataCaptureTime < 2)	{		return;	}	APawn* MyPawn = Cast<APawn>(SelectedActor);	if (MyPawn)	{		AAIController* BTAI = Cast<AAIController>(MyPawn->GetController());		if (BTAI)		{			UAIPerceptionComponent* PerceptionComponent = BTAI->GetAIPerceptionComponent();			if (PerceptionComponent == nullptr)			{				PerceptionComponent = MyPawn->FindComponentByClass<UAIPerceptionComponent>();			}			if (PerceptionComponent)			{				TArray<FString> PerceptionTexts;				GenericShapeElements.Reset();				PerceptionComponent->GrabGameplayDebuggerData(PerceptionTexts, GenericShapeElements);				DistanceFromPlayer = DistanceFromSensor = -1;				if (MyPC && MyPC->GetPawn())				{					DistanceFromPlayer = (MyPawn->GetActorLocation() - MyPC->GetPawn()->GetActorLocation()).Size();					DistanceFromSensor = SensingComponentLocation != FVector::ZeroVector ? (SensingComponentLocation - MyPC->GetPawn()->GetActorLocation()).Size() : -1;				}			}			UAIPerceptionSystem* PerceptionSys = UAIPerceptionSystem::GetCurrent(MyPawn->GetWorld());			if (PerceptionSys)			{				PerceptionLegend = PerceptionSys->GetPerceptionDebugLegend();			}		}	}#endif}