EBTNodeResult::Type URandomWander::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
UBlackboardComponent* Blackboard = OwnerComp.GetBlackboardComponent();
if (!GetWorld())
{
return EBTNodeResult::Failed;
}
FVector NewWaypoint = FVector::ZeroVector;
FVector CurrentPos = Blackboard->GetOwner()->GetActorLocation();
NewWaypoint.X = CurrentPos.X + FMath::FRandRange(-5000, 5000);
NewWaypoint.Y = CurrentPos.Y + FMath::FRandRange(-5000, 5000);
while (FVector::Dist(NewWaypoint, Blackboard->GetOwner()->GetActorLocation()) <= 2000.f && TraceFromPosition(OutResult, 100.f, ECollisionChannel::ECC_EngineTraceChannel1, NewWaypoint, OwnerComp) == false)
{
NewWaypoint.X = CurrentPos.X + FMath::FRandRange(-5000, 5000);
NewWaypoint.Y = CurrentPos.Y + FMath::FRandRange(-5000, 5000);
}
if (!NewWaypoint.IsZero())
{
Blackboard->SetValue<UBlackboardKeyType_Vector>(BlackboardKey.GetSelectedKeyID(), NewWaypoint);
return EBTNodeResult::Succeeded;
}
return EBTNodeResult::Failed;
}
bool AAIController::ShouldSyncBlackboardWith(const UBlackboardComponent& OtherBlackboardComponent) const
{
return Blackboard != nullptr
&& Blackboard->GetBlackboardAsset() != nullptr
&& OtherBlackboardComponent.GetBlackboardAsset() != nullptr
&& Blackboard->GetBlackboardAsset()->IsRelatedTo(*OtherBlackboardComponent.GetBlackboardAsset());
}
void UBTDecorator_BlueprintBase::OnBecomeRelevant(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
if (AIOwner != nullptr && ReceiveObserverActivatedImplementations & FBTNodeBPImplementationHelper::AISpecific)
{
ReceiveObserverActivatedAI(AIOwner, AIOwner->GetPawn());
}
else if (ReceiveObserverActivatedImplementations & FBTNodeBPImplementationHelper::Generic)
{
ReceiveObserverActivated(ActorOwner);
}
if (GetNeedsTickForConditionChecking())
{
// if set up as observer, and has a condition check, we want to check the condition every frame
// highly inefficient, but hopefully people will use it only for prototyping.
bNotifyTick = true;
}
UBlackboardComponent* BlackboardComp = OwnerComp.GetBlackboardComponent();
if (BlackboardComp)
{
for (int32 NameIndex = 0; NameIndex < ObservedKeyNames.Num(); NameIndex++)
{
const FBlackboard::FKey KeyID = BlackboardComp->GetKeyID(ObservedKeyNames[NameIndex]);
if (KeyID != FBlackboard::InvalidKey)
{
BlackboardComp->RegisterObserver(KeyID, this, FOnBlackboardChange::CreateUObject(this, &UBTDecorator_BlueprintBase::OnBlackboardChange));
}
}
}
}
bool AAIController::UseBlackboard(UBlackboardData* BlackboardAsset)
{
if (BlackboardAsset == NULL)
{
UE_VLOG(this, LogBehaviorTree, Log, TEXT("UseBlackboard: trying to use NULL Blackboard asset. Ignoring"));
return false;
}
bool bSuccess = true;
UBlackboardComponent* BlackboardComp = FindComponentByClass<UBlackboardComponent>();
if (BlackboardComp == NULL)
{
BlackboardComp = NewObject<UBlackboardComponent>(this, TEXT("BlackboardComponent"));
if (BlackboardComp != NULL)
{
InitializeBlackboard(*BlackboardComp, *BlackboardAsset);
BlackboardComp->RegisterComponent();
}
}
else if (BlackboardComp->GetBlackboardAsset() == NULL)
{
InitializeBlackboard(*BlackboardComp, *BlackboardAsset);
}
else if (BlackboardComp->GetBlackboardAsset() != BlackboardAsset)
{
UE_VLOG(this, LogBehaviorTree, Log, TEXT("UseBlackboard: requested blackboard %s while already has %s instantiated. Forcing new BB.")
, *GetNameSafe(BlackboardAsset), *GetNameSafe(BlackboardComp->GetBlackboardAsset()));
InitializeBlackboard(*BlackboardComp, *BlackboardAsset);
}
return bSuccess;
}
EBTNodeResult::Type USetNextTargetPoint::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
Super::ExecuteTask(OwnerComp, NodeMemory);
if (!GetWorld())
{
return EBTNodeResult::Failed;
}
//Set the blackboard to make calling it easier in the future
UBlackboardComponent* Blackboard = OwnerComp.GetBlackboardComponent();
//Get the ID of the key that we state in the editor
uint8 TargetKeyID = Blackboard->GetKeyID(TargetName);
//Get the AI so we can call a function on it
UObject* SelfActor = Blackboard->GetValue<UBlackboardKeyType_Object>(TargetKeyID);
//Cast it to the proper class
AShadowAnnaCharacter* ShadowAnna = Cast<AShadowAnnaCharacter>(SelfActor);
if (ShadowAnna)
{
//IF the cast works call the function
//FVector NewTarget = ShadowAnna->SetNextTargetPoint();
//Blackboard->SetValue<UBlackboardKeyType_Vector>(BlackboardKey.GetSelectedKeyID(), NewTarget);
return EBTNodeResult::Succeeded;
}
return EBTNodeResult::Failed;
}
void AMinionController::BeginPlay()
{
UBlackboardComponent *BBComponent = NewObject<UBlackboardComponent>(this);
BBComponent->RegisterComponent();
UBBMinion* BB = NewObject<UBBMinion>(this);
BBComponent->InitializeBlackboard(*BB);
}
void UBTDecorator_CompareBBEntries::OnCeaseRelevant(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
UBlackboardComponent* BlackboardComp = OwnerComp.GetBlackboardComponent();
if (BlackboardComp)
{
BlackboardComp->UnregisterObserversFrom(this);
}
}
void UBTDecorator_CompareBBEntries::OnBecomeRelevant(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
UBlackboardComponent* BlackboardComp = OwnerComp.GetBlackboardComponent();
if (BlackboardComp)
{
BlackboardComp->RegisterObserver(BlackboardKeyA.GetSelectedKeyID(), this, FOnBlackboardChange::CreateUObject(this, &UBTDecorator_CompareBBEntries::OnBlackboardChange));
BlackboardComp->RegisterObserver(BlackboardKeyB.GetSelectedKeyID(), this, FOnBlackboardChange::CreateUObject(this, &UBTDecorator_CompareBBEntries::OnBlackboardChange));
}
}
void UBTFunctionLibrary::ClearBlackboardValue(UBTNode* NodeOwner, const FBlackboardKeySelector& Key)
{
check(NodeOwner != NULL);
UBlackboardComponent* BlackboardComp = GetBlackboard(*NodeOwner);
if (BlackboardComp != NULL)
{
BlackboardComp->ClearValue(Key.SelectedKeyName);
}
}
bool AAIController::InitializeBlackboard(UBlackboardComponent& BlackboardComp, UBlackboardData& BlackboardAsset)
{
check(BlackboardComp.GetOwner() == this);
if (BlackboardComp.InitializeBlackboard(BlackboardAsset))
{
OnUsingBlackBoard(&BlackboardComp, &BlackboardAsset);
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++;
}
}
}
void UBTDecorator_CompareBBEntries::OnBlackboardChange(const UBlackboardComponent& Blackboard, FBlackboard::FKey ChangedKeyID)
{
UBehaviorTreeComponent* BehaviorComp = static_cast<UBehaviorTreeComponent*>(Blackboard.GetBrainComponent());
if (BehaviorComp && (BlackboardKeyA.GetSelectedKeyID() == ChangedKeyID || BlackboardKeyB.GetSelectedKeyID() == ChangedKeyID))
{
BehaviorComp->RequestExecution(this);
}
}
void UBTDecorator_BlueprintBase::OnBlackboardChange(const UBlackboardComponent& Blackboard, FBlackboard::FKey ChangedKeyID)
{
UBehaviorTreeComponent* BehaviorComp = (UBehaviorTreeComponent*)Blackboard.GetBrainComponent();
if (BehaviorComp && GetShouldAbort(*BehaviorComp))
{
BehaviorComp->RequestExecution(this);
}
}
bool AAIController::InitializeBlackboard(UBlackboardComponent& BlackboardComp, UBlackboardData& BlackboardAsset)
{
check(BlackboardComp.GetOwner() == this);
if (BlackboardComp.InitializeBlackboard(BlackboardAsset))
{
// find the "self" key and set it to our pawn
const FBlackboard::FKey SelfKey = BlackboardAsset.GetKeyID(FBlackboard::KeySelf);
if (SelfKey != FBlackboard::InvalidKey)
{
BlackboardComp.SetValue<UBlackboardKeyType_Object>(SelfKey, GetPawn());
}
OnUsingBlackBoard(&BlackboardComp, &BlackboardAsset);
return true;
}
return false;
}
void UDistanceToGhost::TickNode(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory, float DeltaSeconds)
{
Super::TickNode(OwnerComp, NodeMemory, DeltaSeconds);
UBlackboardComponent* Blackboard = OwnerComp.GetBlackboardComponent();
UObject* TargetObject = Blackboard->GetValue<UBlackboardKeyType_Object>(TargetName);
AGGJ16_AIController* AIController = Cast<AGGJ16_AIController>(Blackboard->GetOwner());
AGGJ16_Vani* VaniCharacter = Cast<AGGJ16_Vani>(TargetObject);
if (AIController && VaniCharacter)
{
Distance = FVector::Dist(VaniCharacter->GetActorLocation(), AIController->GetPawn()->GetActorLocation());
Blackboard->SetValue<UBlackboardKeyType_Float>(BlackboardKey.GetSelectedKeyID(), Distance);
}
GEngine->AddOnScreenDebugMessage(4, 1, FColor::Blue, TEXT("Ding"));
}
void UCheckDistanceService::TickNode(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory, float DeltaSeconds)
{
Super::TickNode(OwnerComp, NodeMemory, DeltaSeconds);
UBlackboardComponent* Blackboard = OwnerComp.GetBlackboardComponent();
UObject* TargetObject = Blackboard->GetValue<UBlackboardKeyType_Object>(TargetName);
AArin* PlayerCharacter = Cast<AArin>(UGameplayStatics::GetPlayerCharacter(GetWorld(), 0));
ABaseAIController* AIController = Cast<ABaseAIController>(Blackboard->GetOwner());
if (AIController && PlayerCharacter)
{
Distance = FVector::Dist(PlayerCharacter->GetActorLocation(), AIController->GetPawn()->GetActorLocation());
Blackboard->SetValue<UBlackboardKeyType_Float>(BlackboardKey.GetSelectedKeyID(), Distance);
}
GEngine->AddOnScreenDebugMessage(4, 1, FColor::Blue, TEXT("Ding"));
}
void UBTDecorator_BlueprintBase::OnCeaseRelevant(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
UBlackboardComponent* BlackboardComp = OwnerComp.GetBlackboardComponent();
if (BlackboardComp)
{
BlackboardComp->UnregisterObserversFrom(this);
}
if (AIOwner != nullptr && ReceiveObserverDeactivatedImplementations & FBTNodeBPImplementationHelper::AISpecific)
{
ReceiveObserverDeactivatedAI(AIOwner, AIOwner->GetPawn());
}
else if (ReceiveObserverDeactivatedImplementations & FBTNodeBPImplementationHelper::Generic)
{
ReceiveObserverDeactivated(ActorOwner);
}
if (GetNeedsTickForConditionChecking() == true && ReceiveTickImplementations == 0)
{
// clean up the tick request if no longer "active"
bNotifyTick = false;
}
}
EBTNodeResult::Type UBTTask_CloseDialogue::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
EBTNodeResult::Type NodeResult = EBTNodeResult::Failed;
if (!DialogueWidget.IsNone())
{
FName KeyName = DialogueWidget.SelectedKeyName;
UBlackboardComponent* BlackboardComp = OwnerComp.GetBlackboardComponent();
UUserWidget* Widget = Cast<UUserWidget>(BlackboardComp->GetValueAsObject(KeyName));
UWidgetComponent* WidgetComp = Cast<UWidgetComponent>(BlackboardComp->GetValueAsObject(KeyName));
if (!Widget && !WidgetComp)
{
#if WITH_EDITOR
FMessageLog("PIE").Error()
->AddToken(FTextToken::Create(LOCTEXT("InvalidWidgetKey", "Invalid key for Dialogue Widget in ")))
->AddToken(FUObjectToken::Create((UObject*)OwnerComp.GetCurrentTree()));
#endif
return EBTNodeResult::Failed;
}
if (!Widget && WidgetComp)
{
Widget = CreateWidget<UUserWidget>(GetWorld(), WidgetComp->GetWidgetClass());
}
APlayerController* PlayerController = Widget->GetOwningPlayer();
FInputModeGameOnly InputMode;
PlayerController->SetInputMode(InputMode);
if (Widget && Widget->IsInViewport())
{
Widget->RemoveFromParent();
}
switch (MouseOptions)
{
case ECloseDialogueCursorOptions::Show:
PlayerController->bShowMouseCursor = true;
break;
default:
PlayerController->bShowMouseCursor = false;
break;
}
}
// set camera default values
if (!PlayerCamera.IsNone())
{
FName PlayerCameraKeyName = PlayerCamera.SelectedKeyName;
UBlackboardComponent* BlackboardComp = OwnerComp.GetBlackboardComponent();
UCameraComponent* PlayerCameraComp = Cast<UCameraComponent>(BlackboardComp->GetValueAsObject(PlayerCameraKeyName));
if (PlayerCameraComp)
{
PlayerCameraComp->SetWorldLocationAndRotation(DefaultCameraLocation, DefaultCameraRotation);
UBTTask_ShowPhrases* ShowPhrases = Cast<UBTTask_ShowPhrases>(FirstTaskNode);
UBTTask_WaitAnswer* WaitAnswer = Cast<UBTTask_WaitAnswer>(FirstTaskNode);
if (ShowPhrases)
{
ShowPhrases->DefaultCameraLocation = FVector(0.f, 0.f, 0.f);
}
if (WaitAnswer)
{
WaitAnswer->DefaultCameraLocation = FVector(0.f, 0.f, 0.f);
}
}
}
return NodeResult;
}
bool AAIController::RunBehaviorTree(UBehaviorTree* BTAsset)
{
// @todo: find BrainComponent and see if it's BehaviorTreeComponent
// Also check if BTAsset requires BlackBoardComponent, and if so
// check if BB type is accepted by BTAsset.
// Spawn BehaviorTreeComponent if none present.
// Spawn BlackBoardComponent if none present, but fail if one is present but is not of compatible class
if (BTAsset == NULL)
{
UE_VLOG(this, LogBehaviorTree, Warning, TEXT("RunBehaviorTree: Unable to run NULL behavior tree"));
return false;
}
bool bSuccess = true;
bool bShouldInitializeBlackboard = false;
// see if need a blackboard component at all
UBlackboardComponent* BlackboardComp = NULL;
if (BTAsset->BlackboardAsset)
{
BlackboardComp = FindComponentByClass<UBlackboardComponent>();
if (BlackboardComp == NULL)
{
BlackboardComp = ConstructObject<UBlackboardComponent>(UBlackboardComponent::StaticClass(), this, TEXT("BlackboardComponent"));
if (BlackboardComp != NULL)
{
BlackboardComp->InitializeBlackboard(BTAsset->BlackboardAsset);
BlackboardComp->RegisterComponent();
bShouldInitializeBlackboard = true;
}
}
else if (BlackboardComp->GetBlackboardAsset() == NULL)
{
BlackboardComp->InitializeBlackboard(BTAsset->BlackboardAsset);
}
else if (BlackboardComp->GetBlackboardAsset() != BTAsset->BlackboardAsset)
{
bSuccess = false;
UE_VLOG(this, LogBehaviorTree, Log, TEXT("RunBehaviorTree: BTAsset %s requires blackboard %s while already has %s instantiated"),
*GetNameSafe(BTAsset), *GetNameSafe(BTAsset->BlackboardAsset), *GetNameSafe(BlackboardComp->GetBlackboardAsset()) );
}
}
if (bSuccess)
{
UBehaviorTreeComponent* BTComp = Cast<UBehaviorTreeComponent>(BrainComponent);
if (BTComp == NULL)
{
UE_VLOG(this, LogBehaviorTree, Log, TEXT("RunBehaviorTree: spawning BehaviorTreeComponent.."));
BrainComponent = BTComp = ConstructObject<UBehaviorTreeComponent>(UBehaviorTreeComponent::StaticClass(), this, TEXT("BTComponent"));
BrainComponent->RegisterComponent();
if (BrainComponent->bWantsInitializeComponent)
{
// make sure that newly created component is initialized before running BT
// both blackboard and BT to must exist before calling it!
BrainComponent->InitializeComponent();
}
}
if (bShouldInitializeBlackboard && BlackboardComp && BlackboardComp->bWantsInitializeComponent)
{
// make sure that newly created component is initialized before running BT
// both blackboard and BT to must exist before calling it!
BlackboardComp->InitializeComponent();
}
check(BTComp != NULL);
BTComp->StartTree(BTAsset, EBTExecutionMode::Looped);
}
return bSuccess;
}
