EBTNodeResult::Type UMyBTTask_ResetRoute::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
/* Check whether the AIController component exists to avoid errors */
ABotAI* MyController = Cast<ABotAI>(OwnerComp.GetAIOwner());
if (MyController == nullptr)
{
return EBTNodeResult::Failed;
}
//uint8 BBResetRoute = OwnerComp.GetBlackboardComponent()->GetKeyID("ResetRoute");
//uint8 BBResetRoute = OwnerComp.GetBlackboardComponent()->GetKeyID("ResetRoute");
uint8 BBResetRoute = OwnerComp.GetBlackboardComponent()->GetKeyID("ResetRoute");
OwnerComp.GetBlackboardComponent()->SetValueAsBool(BBResetRoute, true);
// uint8 BBResetRoute = OwnerComp.GetBlackboardComponent()->GetKeyID("ResetRoute");
return EBTNodeResult::Succeeded;
}
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));
}
}
}
}
EBTNodeResult::Type USetMaxWalkSpeed::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
Super::ExecuteTask(OwnerComp, NodeMemory);
if (!GetWorld())
{
return EBTNodeResult::Failed;
}
AActor* AnnaActor = OwnerComp.GetBlackboardComponent()->GetOwner();
if (AnnaActor)
{
ACharacter* AnnaCharacter = Cast<AController>(AnnaActor)->GetCharacter();
if (AnnaCharacter)
{
AnnaCharacter->GetCharacterMovement()->MaxWalkSpeed = DesiredMaxSpeed;
EBTNodeResult::Succeeded;
}
}
return EBTNodeResult::Failed;
}
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;
}
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 UBTDecorator_IsAtLocation::CalculateRawConditionValue(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) const
{
bool bHasReached = false;
AAIController* AIOwner = OwnerComp.GetAIOwner();
UPathFollowingComponent* PathFollowingComponent = AIOwner ? AIOwner->GetPathFollowingComponent() : nullptr;
if (PathFollowingComponent)
{
const UBlackboardComponent* MyBlackboard = OwnerComp.GetBlackboardComponent();
if (BlackboardKey.SelectedKeyType == UBlackboardKeyType_Object::StaticClass())
{
UObject* KeyValue = MyBlackboard->GetValue<UBlackboardKeyType_Object>(BlackboardKey.GetSelectedKeyID());
AActor* TargetActor = Cast<AActor>(KeyValue);
if (TargetActor)
{
bHasReached = PathFollowingComponent->HasReached(*TargetActor, AcceptableRadius, false, bUseNavAgentGoalLocation);
}
}
else if (BlackboardKey.SelectedKeyType == UBlackboardKeyType_Vector::StaticClass())
{
const FVector TargetLocation = MyBlackboard->GetValue<UBlackboardKeyType_Vector>(BlackboardKey.GetSelectedKeyID());
if (FAISystem::IsValidLocation(TargetLocation))
{
bHasReached = PathFollowingComponent->HasReached(TargetLocation, AcceptableRadius);
}
}
}
return bHasReached;
}
EBTNodeResult::Type UBTTask_MoveToPlayer::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
AEnemyAI *CharPC = Cast<AEnemyAI>(OwnerComp.GetAIOwner());
ASacredHeartCharacter *Enemy = Cast<ASacredHeartCharacter>(OwnerComp.GetBlackboardComponent()->GetValue<UBlackboardKeyType_Object>(CharPC->EnemyKeyID));
if (Enemy)
{
int bpm = Enemy->heartRate;
if (bpm > 100)
{
CharPC->GetCharacter()->GetCharacterMovement()->MaxWalkSpeed = 550;
CharPC->MoveToActor(Enemy, 5.f, true, true, true, 0, true);
return EBTNodeResult::Succeeded;
}
else
{
return EBTNodeResult::Failed;
}
}
else
{
return EBTNodeResult::Failed;
}
}
EBTNodeResult::Type UMyBTTask_FindWayPoint::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
/* Check whether the AIController component exists to avoid errors */
ABotAI* MyController = Cast<ABotAI>(OwnerComp.GetAIOwner());
if (MyController == nullptr)
{
return EBTNodeResult::Failed;
}
/* Gets pointer to a waypoint */
AEnemyWayPoint* CurrentWaypoint = MyController->GetWaypoint();
AActor* NewWaypoint = nullptr;
/* Get all Actors of type "EnemyWayPoint" in the level, and Iterate through them */
TArray<AActor*> AllWaypoints;
UGameplayStatics::GetAllActorsOfClass(MyController, AEnemyWayPoint::StaticClass(), AllWaypoints);
/* Select one random waypoint by index */
NewWaypoint = AllWaypoints[FMath::RandRange(0, AllWaypoints.Num() - 1)];
if (NewWaypoint)
{
/* Assign the retrieved waypoint to blackboard as the new move destination */
OwnerComp.GetBlackboardComponent()->SetValue<UBlackboardKeyType_Object>(BlackboardKey.GetSelectedKeyID(), NewWaypoint);
return EBTNodeResult::Succeeded;
}
return EBTNodeResult::Failed;
}
EBTNodeResult::Type UChooseNextWaypoint::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
// Get the patrol route
auto ControlledPawn = OwnerComp.GetAIOwner()->GetPawn();
auto PatrolRoute = ControlledPawn->FindComponentByClass<UPatrolRoute>();
if (!ensure(PatrolRoute)) { return EBTNodeResult::Failed; }
// Warn about empty patrol routes
auto PatrolPoints = PatrolRoute->GetPatrolPoints();
if (PatrolPoints.Num() == 0)
{
UE_LOG(LogTemp, Warning, TEXT("A guard is missing patrol points."));
return EBTNodeResult::Failed;
}
// Set the next waypoint
auto BlackboardComp = OwnerComp.GetBlackboardComponent();
auto Index = BlackboardComp->GetValueAsInt(IndexKey.SelectedKeyName);
BlackboardComp->SetValueAsObject(WaypointKey.SelectedKeyName, PatrolPoints[Index]);
// Cycle the index
auto NextIndex = (Index + 1) % PatrolPoints.Num();
BlackboardComp->SetValueAsInt(IndexKey.SelectedKeyName, NextIndex);
// UE_LOG(LogTemp, Warning, TEXT("Waypoint index: %i"), Index);
return EBTNodeResult::Succeeded;
}
// @note I know it's ugly to have "return" statements in many places inside a function, but the way
// around was very awkward here
bool UBTDecorator_CompareBBEntries::CalculateRawConditionValue(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) const
{
// first of all require same type
// @todo this could be checked statically (i.e. in editor, asset creation time)!
if (BlackboardKeyA.SelectedKeyType != BlackboardKeyB.SelectedKeyType)
{
return false;
}
const UBlackboardComponent* BlackboardComp = OwnerComp.GetBlackboardComponent();
if (BlackboardComp)
{
//BlackboardComp->GetKeyType
const EBlackboardCompare::Type Result = BlackboardComp->CompareKeyValues(BlackboardKeyA.SelectedKeyType,
BlackboardKeyA.GetSelectedKeyID(), BlackboardKeyB.GetSelectedKeyID());
static_assert(int32(EBlackboardCompare::Equal) == int32(EBlackBoardEntryComparison::Equal)
&& int32(EBlackboardCompare::NotEqual) == int32(EBlackBoardEntryComparison::NotEqual),
"These values need to be equal");
return int32(Operator) == int32(Result);
}
return false;
}
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));
}
}
EBTNodeResult::Type UBoolChange::ExecuteTask(UBehaviorTreeComponent & OwnerComp, uint8 * NodeMemory)
{
Super::ExecuteTask(OwnerComp, NodeMemory);
if (!GetWorld())
{
return EBTNodeResult::Failed;
}
if (!CurrentBanditController)
{
Controller = OwnerComp.GetAIOwner();
CurrentBanditController = Cast<ABanditController>(Controller);
}
if (CurrentBanditController)
{
OwnerComp.GetBlackboardComponent()->SetValueAsBool(TEXT("PlayerSpotted"), true);
OwnerComp.GetBlackboardComponent()->SetValueAsBool(TEXT("PlayerNearby"), true);
return EBTNodeResult::Succeeded;
}
return EBTNodeResult::Failed;
}
EBTNodeResult::Type UBTTaskNode_ChooseNextSpell::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
Super::ExecuteTask(OwnerComp, NodeMemory);
auto controller = Cast<ABaseAIController>(OwnerComp.GetAIOwner());
auto blackboard = OwnerComp.GetBlackboardComponent();
auto spellData = controller->GetNextSpell();
blackboard->SetValueAsObject("NextSpell", spellData);
return EBTNodeResult::Type::Succeeded;
}
void UBTTask_MoveDirectlyToward::DescribeRuntimeValues(const UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory, EBTDescriptionVerbosity::Type Verbosity, TArray<FString>& Values) const
{
Super::DescribeRuntimeValues(OwnerComp, NodeMemory, Verbosity, Values);
const UBlackboardComponent* BlackboardComp = OwnerComp.GetBlackboardComponent();
FBTMoveDirectlyTowardMemory* MyMemory = reinterpret_cast<FBTMoveDirectlyTowardMemory*>(NodeMemory);
if (MyMemory->MoveRequestID && BlackboardComp)
{
FString KeyValue = BlackboardComp->DescribeKeyValue(BlackboardKey.GetSelectedKeyID(), EBlackboardDescription::OnlyValue);
Values.Add(FString::Printf(TEXT("move target: %s"), *KeyValue));
}
}
void UBTService_SearchPlayer::TickNode(UBehaviorTreeComponent &OwnerComp, uint8* NodeMemory, float DeltaSeconds)
{
if (!OwnerComp.GetBlackboardComponent())
{
GEngine->AddOnScreenDebugMessage(-1, 1.0f, FColor::Red, "Failed to get Blackboard Component");
return;
}
OwnerComp.GetBlackboardComponent()->SetValueAsObject("Player", (UGameplayStatics::GetPlayerCharacter(GetWorld(), 0)));
if (OwnerComp.GetBlackboardComponent()->GetValueAsEnum("State") == static_cast<uint8>(EState::ES_Combat))
{
APawn* Player = (UGameplayStatics::GetPlayerCharacter(GetWorld(), 0));
ALivingEntity* Enemy = nullptr;
AEnemyController* EnemyController = Cast<AEnemyController>(OwnerComp.GetOwner());
if (EnemyController)
{
Enemy = Cast<ALivingEntity>(EnemyController->GetPawn());
}
if (Player && Enemy)
{
if (!CanSeePlayer(Enemy, Player))
{
OwnerComp.GetBlackboardComponent()->SetValueAsEnum("State", static_cast<uint8>(EState::ES_Walking));
}
else
{
EnemyController->UpdateMemoryMarker(Player->GetActorLocation());
}
}
else
{
GEngine->AddOnScreenDebugMessage(-1, 1.0f, FColor::Red, "Error whilst casting");
}
}
}
void UBTDecorator_UtilityBlackboard::DescribeRuntimeValues(const UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory, EBTDescriptionVerbosity::Type Verbosity, TArray<FString>& Values) const
{
Super::DescribeRuntimeValues(OwnerComp, NodeMemory, Verbosity, Values);
const UBlackboardComponent* BlackboardComp = OwnerComp.GetBlackboardComponent();
FString DescKeyValue;
if (BlackboardComp)
{
DescKeyValue = BlackboardComp->DescribeKeyValue(UtilityValueKey.GetSelectedKeyID(), EBlackboardDescription::OnlyValue);
}
Values.Add(FString::Printf(TEXT("utility: %s"), *DescKeyValue));
}
EBTNodeResult::Type UATBTTask_MoveArea::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
UNavigationSystem* NavigationSystem = UNavigationSystem::GetCurrent(GetWorld());
AATCharacterAI* MyCharacter = Cast<AATCharacterAI>(OwnerComp.GetAIOwner()->GetPawn());
if (NavigationSystem != nullptr && MyCharacter != nullptr)
{
FNavLocation RandomPointIn;
if (NavigationSystem->GetRandomPointInNavigableRadius(MyCharacter->GetActorLocation(), MyCharacter->AreaRadius, RandomPointIn))
{
OwnerComp.GetBlackboardComponent()->SetValue<UBlackboardKeyType_Vector>(GetSelectedBlackboardKey(), RandomPointIn.Location);
return EBTNodeResult::Succeeded;
}
}
return EBTNodeResult::Failed;
}
float UBTDecorator_UtilityBlackboard::CalculateUtilityValue(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) const
{
const UBlackboardComponent* MyBlackboard = OwnerComp.GetBlackboardComponent();
float Value = 0.0f;
if (UtilityValueKey.SelectedKeyType == UBlackboardKeyType_Float::StaticClass())
{
Value = MyBlackboard->GetValue< UBlackboardKeyType_Float >(UtilityValueKey.GetSelectedKeyID());
}
else if (UtilityValueKey.SelectedKeyType == UBlackboardKeyType_Int::StaticClass())
{
Value = (float)MyBlackboard->GetValue< UBlackboardKeyType_Int >(UtilityValueKey.GetSelectedKeyID());
}
return FMath::Max(Value, 0.0f);
}
EBTNodeResult::Type UBTTask_MoveDirectlyToward::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
const UBlackboardComponent* MyBlackboard = OwnerComp.GetBlackboardComponent();
FBTMoveDirectlyTowardMemory* MyMemory = reinterpret_cast<FBTMoveDirectlyTowardMemory*>(NodeMemory);
AAIController* MyController = OwnerComp.GetAIOwner();
EBTNodeResult::Type NodeResult = EBTNodeResult::Failed;
if (MyController && MyBlackboard)
{
EPathFollowingRequestResult::Type RequestResult = EPathFollowingRequestResult::Failed;
if (BlackboardKey.SelectedKeyType == UBlackboardKeyType_Object::StaticClass())
{
UObject* KeyValue = MyBlackboard->GetValue<UBlackboardKeyType_Object>(BlackboardKey.GetSelectedKeyID());
AActor* TargetActor = Cast<AActor>(KeyValue);
if (TargetActor)
{
RequestResult = bDisablePathUpdateOnGoalLocationChange ?
MyController->MoveToLocation(TargetActor->GetActorLocation(), AcceptableRadius, bStopOnOverlap, /*bUsePathfinding=*/false, /*bProjectDestinationToNavigation=*/bProjectVectorGoalToNavigation, bAllowStrafe) :
MyController->MoveToActor(TargetActor, AcceptableRadius, bStopOnOverlap, /*bUsePathfinding=*/false, bAllowStrafe);
}
}
else if (BlackboardKey.SelectedKeyType == UBlackboardKeyType_Vector::StaticClass())
{
const FVector TargetLocation = MyBlackboard->GetValue<UBlackboardKeyType_Vector>(BlackboardKey.GetSelectedKeyID());
RequestResult = MyController->MoveToLocation(TargetLocation, AcceptableRadius, bStopOnOverlap, /*bUsePathfinding=*/false, /*bProjectDestinationToNavigation=*/bProjectVectorGoalToNavigation, bAllowStrafe);
}
if (RequestResult == EPathFollowingRequestResult::RequestSuccessful)
{
const FAIRequestID RequestID = MyController->GetCurrentMoveRequestID();
MyMemory->MoveRequestID = RequestID;
WaitForMessage(OwnerComp, UBrainComponent::AIMessage_MoveFinished, RequestID);
NodeResult = EBTNodeResult::InProgress;
}
else if (RequestResult == EPathFollowingRequestResult::AlreadyAtGoal)
{
NodeResult = EBTNodeResult::Succeeded;
}
}
return NodeResult;
}
EBTNodeResult::Type UGoToWaypoint::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
Super::ExecuteTask(OwnerComp, NodeMemory);
if (!GetWorld())
{
return EBTNodeResult::Failed;
}
AAIController* MyController = OwnerComp.GetAIOwner();
ABanditController* CurrBanditController = Cast<ABanditController>(MyController);
if (CurrBanditController)
{
ATestTargetPoint* CurrentWaypoint = CurrBanditController->CurrentWaypoint();
if (CurrentWaypoint)
{
OwnerComp.GetBlackboardComponent()->SetValueAsObject(TEXT("CurrentTarget"), CurrentWaypoint);
return EBTNodeResult::Succeeded;
}
else
{
return EBTNodeResult::Failed;
}
}
else
{
return EBTNodeResult::Failed;
}
//for (TActorIterator<ATestTargetPoint> ActorItr(GetWorld()); ActorItr; ++ActorItr)
//{
// ATestTargetPoint* Waypoint = *ActorItr;
// if (Waypoint)
// {
// OwnerComp.GetBlackboardComponent()->SetValueAsObject(TEXT("Target1"), Waypoint);
// OwnerComp.GetBlackboardComponent()->SetValueAsObject(TEXT("CurrentTarget"), Waypoint);
//
// return EBTNodeResult::Succeeded;
// }
//}
return EBTNodeResult::Failed;
}
void ULowEnergyService::TickNode(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory, float DeltaSeconds)
{
Super::TickNode(OwnerComp, NodeMemory, DeltaSeconds);
// If the blackboard comp doesnt exist, exit
UBlackboardComponent* BlackboardComp = OwnerComp.GetBlackboardComponent();
if (!BlackboardComp)
return;
// Get the mech controller and see if it exists
AMechAIController* MechController = Cast<AMechAIController>(OwnerComp.GetAIOwner());
if (!MechController)
return;
// Get the ai character and see if it exists
AMechAICharacter* AICharacter = Cast<AMechAICharacter>(MechController->GetControlledPawn());
if (!AICharacter)
return;
}
bool UBTDecorator_HasLoSTo::CalculateRawConditionValue(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) const
{
const UBlackboardComponent* MyBlackboard = OwnerComp.GetBlackboardComponent();
AAIController* MyController = OwnerComp.GetAIOwner();
bool HasLOS = false;
if (MyController && MyBlackboard)
{
auto MyID = MyBlackboard->GetKeyID(EnemyKey.SelectedKeyName);
auto TargetKeyType = MyBlackboard->GetKeyType(MyID);
FVector TargetLocation;
bool bGotTarget = false;
AActor* EnemyActor = NULL;
if (TargetKeyType == UBlackboardKeyType_Object::StaticClass())
{
UObject* KeyValue = MyBlackboard->GetValue<UBlackboardKeyType_Object>(MyID);
EnemyActor = Cast<AActor>(KeyValue);
if (EnemyActor)
{
TargetLocation = EnemyActor->GetActorLocation();
bGotTarget = true;
}
}
else if (TargetKeyType == UBlackboardKeyType_Vector::StaticClass())
{
TargetLocation = MyBlackboard->GetValue<UBlackboardKeyType_Vector>(MyID);
bGotTarget = true;
}
if (bGotTarget == true)
{
if (LOSTrace(OwnerComp.GetOwner(), EnemyActor, TargetLocation) == true)
{
HasLOS = true;
}
}
}
return HasLOS;
}
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"));
}
EBTNodeResult::Type UFindEnemyTask::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
if (!GetWorld())
{
return EBTNodeResult::Failed;
}
for (TActorIterator<AMyCharacter> ActorItr(GetWorld()); ActorItr; ++ActorItr)
{
AMyCharacter* PlayerCharacter = *ActorItr;
if (PlayerCharacter)
{
OwnerComp.GetBlackboardComponent()->SetValue<UBlackboardKeyType_Object>(
BlackboardKey.GetSelectedKeyID(), PlayerCharacter);
return EBTNodeResult::Succeeded;
}
}
return EBTNodeResult::Failed;
}
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"));
}
bool UBTDecorator_KeepInCone::CalculateCurrentDirection(const UBehaviorTreeComponent& OwnerComp, FVector& Direction) const
{
const UBlackboardComponent* BlackboardComp = OwnerComp.GetBlackboardComponent();
if (BlackboardComp == NULL)
{
return false;
}
FVector PointA = FVector::ZeroVector;
FVector PointB = FVector::ZeroVector;
const bool bHasPointA = BlackboardComp->GetLocationFromEntry(ConeOrigin.GetSelectedKeyID(), PointA);
const bool bHasPointB = BlackboardComp->GetLocationFromEntry(Observed.GetSelectedKeyID(), PointB);
if (bHasPointA && bHasPointB)
{
Direction = (PointB - PointA).GetSafeNormal();
return true;
}
return false;
}
EBTNodeResult::Type UBTTask_FindPointNearWaypoint::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
AsbrAIController* aiController = Cast<AsbrAIController>(OwnerComp.GetAIOwner());
if (aiController == NULL)
return EBTNodeResult::Failed;
ATargetPoint* waypoint = aiController->GetWaypoint();
if (waypoint)
{
const float SearchRadius = 200.0f;
const FVector SearchOrigin = waypoint->GetActorLocation();
const FVector Loc = UNavigationSystem::GetRandomPointInNavigableRadius(aiController, SearchOrigin, SearchRadius);
if (Loc != FVector::ZeroVector)
{
OwnerComp.GetBlackboardComponent()->SetValue<UBlackboardKeyType_Vector>(BlackboardKey.GetSelectedKeyID(), Loc);
aiController->SetWaypointVisited(waypoint); // сообщаем что посетили waypoint (todo: надо учесть расстояние)
return EBTNodeResult::Succeeded;
}
}
return EBTNodeResult::Failed;
}
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 UEngageTask::ExecuteTask(UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
UBehaviorTreeComponent* BTComp = &OwnerComp;
const UBlackboardComponent* BlackboardComp = BTComp->GetBlackboardComponent();
AAgentController* Controller = Cast<AAgentController>(BTComp->GetAIOwner());
if (Controller == NULL)
{
return EBTNodeResult::Failed;
}
else
{
class AAgent* Agent = Controller->GetAgentOwner();
// If the agent's weapon has ammo in it
if (Agent->GetCurrentWeapon()->CalculateAmmo() > 0)
{
// Ensure reload is set to false because it should have been reloaded at this stage
Agent->EndReload();
// Shoot
Agent->Fire();
}
else
{
// Stop firing if firing
Agent->StopFiring();
// Reload
Agent->BeginReload();
}
return EBTNodeResult::Succeeded;
}
return EBTNodeResult::Failed;
}
