自学教程：C++ IsPendingKill函数代码示例

void UAbilityTask::EndTask(){	if (!IsPendingKill())	{		OnDestroy(false);	}}

void AMech_RPGCharacter::BeginPlay() {	Super::BeginPlay();	GetCharacterMovement()->SetAvoidanceEnabled(true);	if (IsPendingKill()) {		return;	}	if (!UseLoadout) {		//CreatePresetRole(StartingRole());	}	else {		SetupWithLoadout();	}	if (abilities.Num() > 0) {		SetCurrentAbility(abilities[0]);	}	//SetUpGroup();	SetUpWidgets();	if (OnPostBeginPlay.IsBound()) {		OnPostBeginPlay.Broadcast(this);	}}

void APawn::PostInitializeComponents(){	Super::PostInitializeComponents();		if (!IsPendingKill())	{		GetWorld()->AddPawn( this );		// Automatically add Controller to AI Pawns if we are allowed to.		if (AutoPossessPlayer == EAutoReceiveInput::Disabled)		{			if (AutoPossessAI != EAutoPossessAI::Disabled && Controller == NULL && GetNetMode() != NM_Client)			{				const bool bPlacedInWorld = (GetWorld()->bStartup);				if ((AutoPossessAI == EAutoPossessAI::PlacedInWorldOrSpawned) ||					(AutoPossessAI == EAutoPossessAI::PlacedInWorld && bPlacedInWorld) ||					(AutoPossessAI == EAutoPossessAI::Spawned && !bPlacedInWorld))				{					SpawnDefaultController();				}			}		}		// update movement component's nav agent values		UpdateNavAgent();	}}

void ABaseCharacter::SetRagdollPhysics(){	USkeletalMeshComponent* Mesh3P = GetMesh();	if (Mesh3P)	{		Mesh3P->SetCollisionProfileName(TEXT("Ragdoll"));	}	SetActorEnableCollision(true);	if (!IsPendingKill() || Mesh3P || Mesh3P->GetPhysicsAsset())	{		Mesh3P->SetAllBodiesSimulatePhysics(true);		Mesh3P->SetSimulatePhysics(true);		Mesh3P->WakeAllRigidBodies();		Mesh3P->bBlendPhysics = true;		SetLifeSpan(TimeAfterDeathBeforeDestroy);	}	else	{		// Immediately hide the pawn		TurnOff();		SetActorHiddenInGame(true);		SetLifeSpan(1.0f);	}	UCharacterMovementComponent* CharacterComp = Cast<UCharacterMovementComponent>(GetMovementComponent());	if (CharacterComp)	{		CharacterComp->StopMovementImmediately();		CharacterComp->DisableMovement();		CharacterComp->SetComponentTickEnabled(false);	}}

void UActorComponent::DoDeferredRenderUpdates_Concurrent(){	checkf(!HasAnyFlags(RF_Unreachable), TEXT("%s"), *GetFullName());	checkf(!IsTemplate(), TEXT("%s"), *GetFullName());	checkf(!IsPendingKill(), TEXT("%s"), *GetFullName());	if(!IsRegistered())	{		UE_LOG(LogActorComponent, Log, TEXT("UpdateComponent: (%s) Not registered, Aborting."), *GetPathName());		return;	}	if(bRenderStateDirty)	{		SCOPE_CYCLE_COUNTER(STAT_PostTickComponentRecreate);		RecreateRenderState_Concurrent();		checkf(!bRenderStateDirty, TEXT("Failed to route CreateRenderState_Concurrent (%s)"), *GetFullName());	}	else	{		SCOPE_CYCLE_COUNTER(STAT_PostTickComponentLW);		if(bRenderTransformDirty)		{			// Update the component's transform if the actor has been moved since it was last updated.			SendRenderTransform_Concurrent();		}		if(bRenderDynamicDataDirty)		{			SendRenderDynamicData_Concurrent();		}	}}

void UPawnActionsComponent::DescribeSelfToVisLog(FVisualLogEntry* Snapshot) const{    static const FString Category = TEXT("PawnActions");    if (IsPendingKill())    {        return;    }    for (int32 PriorityIndex = 0; PriorityIndex < ActionStacks.Num(); ++PriorityIndex)    {        const UPawnAction* Action = ActionStacks[PriorityIndex].GetTop();        if (Action == NULL)        {            continue;        }        FVisualLogStatusCategory StatusCategory;        StatusCategory.Category = Category + TEXT(": ") + GetPriorityName(PriorityIndex);        while (Action)        {            StatusCategory.Add(Action->GetName(), Action->GetStateDescription());            Action = Action->GetParentAction();        }        Snapshot->Status.Add(StatusCategory);    }}

void ANavigationData::PostInitProperties(){	Super::PostInitProperties();	if (IsPendingKill() == true)	{		return;	}	if (HasAnyFlags(RF_ClassDefaultObject))	{		if (RuntimeGeneration == ERuntimeGenerationType::LegacyGeneration)		{			RuntimeGeneration = bRebuildAtRuntime_DEPRECATED ? ERuntimeGenerationType::Dynamic : ERuntimeGenerationType::Static;		}	}	else	{		bNetLoadOnClient = (*GEngine->NavigationSystemClass != nullptr) && (GEngine->NavigationSystemClass->GetDefaultObject<UNavigationSystem>()->ShouldLoadNavigationOnClient(this));		UWorld* WorldOuter = GetWorld();				if (WorldOuter != NULL && WorldOuter->GetNavigationSystem() != NULL)		{			WorldOuter->GetNavigationSystem()->RequestRegistration(this);		}		RenderingComp = ConstructRenderingComponent();	}}

void ACharacter::PostInitializeComponents(){    Super::PostInitializeComponents();    if (!IsPendingKill())    {        if (Mesh)        {            BaseTranslationOffset = Mesh->RelativeLocation;            BaseRotationOffset = Mesh->RelativeRotation.Quaternion();            // force animation tick after movement component updates            if (Mesh->PrimaryComponentTick.bCanEverTick && CharacterMovement)            {                Mesh->PrimaryComponentTick.AddPrerequisite(CharacterMovement, CharacterMovement->PrimaryComponentTick);            }        }        if (CharacterMovement && CapsuleComponent)        {            CharacterMovement->UpdateNavAgent(*CapsuleComponent);        }        if (Controller == NULL && GetNetMode() != NM_Client)        {            if (CharacterMovement && CharacterMovement->bRunPhysicsWithNoController)            {                CharacterMovement->SetDefaultMovementMode();            }        }    }}

void AGameplayDebuggerReplicator::DrawDebugDataDelegate(class UCanvas* Canvas, class APlayerController* PC){#if ENABLED_GAMEPLAY_DEBUGGER	if (GetWorld() == nullptr || IsPendingKill() || Canvas == nullptr || Canvas->IsPendingKill())	{		return;	}	if (!LocalPlayerOwner || !IsActorTickEnabled())	{		return;	}	if (Canvas->SceneView != nullptr && !Canvas->SceneView->bIsGameView)	{		return;	}	if (GetWorld()->bPlayersOnly && Role == ROLE_Authority)	{		for (FConstPawnIterator Iterator = GetWorld()->GetPawnIterator(); Iterator; ++Iterator)		{			AActor* NewTarget = Cast<AActor>(*Iterator);			if (NewTarget->IsSelected() && GetSelectedActorToDebug() != NewTarget)			{				ServerSetActorToDebug(NewTarget);			}		}	}	DrawDebugData(Canvas, PC);#endif}

void UAbilityTask_WaitTargetData::RegisterTargetDataCallbacks(){	if (!ensure(IsPendingKill() == false))	{		return;	}	check(TargetClass);	check(Ability);	const AGameplayAbilityTargetActor* CDO = CastChecked<AGameplayAbilityTargetActor>(TargetClass->GetDefaultObject());	const bool bIsLocallyControlled = Ability->GetCurrentActorInfo()->IsLocallyControlled();	const bool bShouldProduceTargetDataOnServer = CDO->ShouldProduceTargetDataOnServer;	// If not locally controlled (server for remote client), see if TargetData was already sent	// else register callback for when it does get here.	if (!bIsLocallyControlled)	{		// Register with the TargetData callbacks if we are expecting client to send them		if (!bShouldProduceTargetDataOnServer)		{			FGameplayAbilitySpecHandle	SpecHandle = GetAbilitySpecHandle();			FPredictionKey ActivationPredictionKey = GetActivationPredictionKey();			//Since multifire is supported, we still need to hook up the callbacks			AbilitySystemComponent->AbilityTargetDataSetDelegate(SpecHandle, ActivationPredictionKey ).AddUObject(this, &UAbilityTask_WaitTargetData::OnTargetDataReplicatedCallback);			AbilitySystemComponent->AbilityTargetDataCancelledDelegate(SpecHandle, ActivationPredictionKey ).AddUObject(this, &UAbilityTask_WaitTargetData::OnTargetDataReplicatedCancelledCallback);			AbilitySystemComponent->CallReplicatedTargetDataDelegatesIfSet(SpecHandle, ActivationPredictionKey );			SetWaitingOnRemotePlayerData();		}	}}

void UActorComponent::ConsolidatedPostEditChange(const FPropertyChangedEvent& PropertyChangedEvent){	FComponentReregisterContext* ReregisterContext = nullptr;	if(EditReregisterContexts.RemoveAndCopyValue(this, ReregisterContext))	{		delete ReregisterContext;		AActor* MyOwner = GetOwner();		if ( MyOwner && !MyOwner->IsTemplate() && PropertyChangedEvent.ChangeType != EPropertyChangeType::Interactive )		{			MyOwner->RerunConstructionScripts();		}	}	else	{		// This means there are likely some stale elements left in there now, strip them out		for (auto It(EditReregisterContexts.CreateIterator()); It; ++It)		{			if (!It.Key().IsValid())			{				It.RemoveCurrent();			}		}	}	// The component or its outer could be pending kill when calling PostEditChange when applying a transaction.	// Don't do do a full recreate in this situation, and instead simply detach.	if( IsPendingKill() )	{		// @todo UE4 james should this call UnregisterComponent instead to remove itself from the RegisteredComponents array on the owner?		ExecuteUnregisterEvents();		World = NULL;	}}

void UAbilityTask::AbilityEnded(){	if (!IsPendingKill())	{		OnDestroy(true);	}}

void APlayerStart::PostInitializeComponents(){	Super::PostInitializeComponents();	if ( !IsPendingKill()  && GetWorld()->GetAuthGameMode() )	{		GetWorld()->GetAuthGameMode()->AddPlayerStart(this);	}}

void AAIController::PostInitializeComponents(){	Super::PostInitializeComponents();	if (bWantsPlayerState && !IsPendingKill() && (GetNetMode() != NM_Client))	{		InitPlayerState();	}}

void AGroupActor::PostEditUndo(){	Super::PostEditUndo();	if (IsPendingKill())	{		GetWorld()->ActiveGroupActors.RemoveSwap(this);	}}

// Called when this enemy no longer has any health. [15/7/2016 Matthew Woolley]void ARoadFeverEnemy::Die(){	// If this enemy isn't already being killed. [15/7/2016 Matthew Woolley]	if ( !IsPendingKill() && EnemyHealth <= 0 )	{		// Kill it. [15/7/2016 Matthew Woolley]		Destroy();	}}

void AController::PostInitializeComponents(){	Super::PostInitializeComponents();	if ( !IsPendingKill() )	{		GetWorld()->AddController( this );	}}

class UNetConnection* AGameplayDebuggerReplicator::GetNetConnection() const{#if ENABLED_GAMEPLAY_DEBUGGER	if (LocalPlayerOwner && LocalPlayerOwner->IsPendingKill() == false && IsPendingKill() == false)	{		return LocalPlayerOwner->GetNetConnection();	}#endif	return nullptr;}

class UNetConnection* AGameplayDebuggingReplicator::GetNetConnection() const{#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)	if (LocalPlayerOwner && LocalPlayerOwner->IsPendingKill() == false && IsPendingKill() == false)	{		return LocalPlayerOwner->GetNetConnection();	}#endif	return NULL;}

void ALevelScriptActor::PostDuplicate(bool bDuplicateForPIE){	ULevelScriptBlueprint* MyBlueprint = Cast<ULevelScriptBlueprint>(GetClass()->ClassGeneratedBy);	if (MyBlueprint && !GIsDuplicatingClassForReinstancing && !IsPendingKill())	{		MyBlueprint->SetObjectBeingDebugged(this);	}	Super::PostDuplicate(bDuplicateForPIE);}

void UPrimitiveComponent::SetConstraintMode(EDOFMode::Type ConstraintMode){	FBodyInstance * RootBI = GetBodyInstance(NAME_None, false);	if (RootBI == NULL || IsPendingKill())	{		return;	}	RootBI->SetDOFLock(ConstraintMode);}

bool UGameplayAbility::IsActive() const{	// Only Instanced-Per-Actor abilities persist between activations	if (GetInstancingPolicy() == EGameplayAbilityInstancingPolicy::InstancedPerActor)	{		return bIsActive;	}	// Non-instanced and Instanced-Per-Execution abilities are by definition active unless they are pending kill	return !IsPendingKill();}

void UGameplayTask::EndTask(){	UE_VLOG(GetGameplayTasksComponent(), LogGameplayTasks, Verbose		, TEXT("%s EndTask called, current State: %s")		, *GetName(), *GetTaskStateName());	if (TaskState != EGameplayTaskState::Finished && !IsPendingKill())	{		OnDestroy(false);	}}

void UGameplayTask::TaskOwnerEnded(){    UE_VLOG(GetGameplayTasksComponent(), LogGameplayTasks, Verbose            , TEXT("%s TaskOwnerEnded called, current State: %s")            , *GetName(), *GetTaskStateName());    if (TaskState != EGameplayTaskState::Finished && !IsPendingKill())    {        bOwnerFinished = true;        OnDestroy(true);    }}

void UGameplayTask::OnDestroy(bool bInOwnerFinished){    ensure(TaskState != EGameplayTaskState::Finished && !IsPendingKill());    TaskState = EGameplayTaskState::Finished;    if (TasksComponent.IsValid())    {        TasksComponent->OnGameplayTaskDeactivated(*this);    }    MarkPendingKill();}

bool AVehiclePawn::CanDie() const{	if ( bIsDying										// already dying		|| IsPendingKill()								// already destroyed		|| Role != ROLE_Authority						// not authority		|| GetWorld()->GetAuthGameMode() == NULL		|| GetWorld()->GetAuthGameMode()->GetMatchState() == MatchState::LeavingMap)	// level transition occurring	{		return false;	}	return true;}

void AShooterPickup::PickupOnTouch(class AShooterCharacter* Pawn){	if (bIsActive && Pawn && Pawn->IsAlive() && !IsPendingKill())	{		if (CanBePickedUp(Pawn))		{			GivePickupTo(Pawn);			PickedUpBy = Pawn;			if (!IsPendingKill())			{				bIsActive = false;				OnPickedUp();				if (RespawnTime > 0.0f)				{					GetWorldTimerManager().SetTimer(TimerHandle_RespawnPickup, this, &AShooterPickup::RespawnPickup, RespawnTime, false);				}			}		}	}}

bool ANimModCharacter::CanDie(float KillingDamage, FDamageEvent const& DamageEvent, AController* Killer, AActor* DamageCauser) const{	if (bIsDying										// already dying		|| IsPendingKill()								// already destroyed		|| Role != ROLE_Authority						// not authority		|| GetWorld()->GetAuthGameMode() == NULL		|| GetWorld()->GetAuthGameMode()->GetMatchState() == MatchState::LeavingMap)	// level transition occurring	{		return false;	}	return true;}

void UGame::Shutdown(){	if ( IsPendingKill() )	{		return;	}	OnShutdown();	ObjectTree->Dispose();	MarkPendingKill();}