void ASpawnEnemy::SpawnRandomEnemy() { TArray<FString> Parsed; TArray<FString> HowMuch; TArray<FString> TypeEnemy; const TCHAR* Delims[] = { TEXT(":"), TEXT(";") }; float RandomNumber = (float)rand() / (float)RAND_MAX; int SetNumber = RandomNumber * (Enemies.Num()); Enemies[SetNumber].ParseIntoArray(&Parsed, Delims, 2); int SizeOfArrayParsed = Parsed.Num() - 1; for (int x = 0; x <= SizeOfArrayParsed; x = x + 2) { HowMuch.Add(Parsed[x]); } for (int x = 1; x <= SizeOfArrayParsed; x = x + 2) { TypeEnemy.Add(Parsed[x]); } for (auto Itr(HowMuch.CreateIterator()); Itr; Itr++) { APawn* NewPawn = NULL; FVector BoxOnWorld = GetActorLocation(); FRotator RotatorBoxOnWorld = GetActorRotation(); FBox BoxInfo = GetComponentsBoundingBox(); FVector BoxSize = BoxInfo.GetSize(); if (TypeEnemy[Itr.GetIndex()] == "PegEnemyLight") { EnemyClass = PegLightEnemyClass; } else if (TypeEnemy[Itr.GetIndex()] == "PegDarkEnemy") { EnemyClass = PegDarkEnemyClass; } else if (TypeEnemy[Itr.GetIndex()] == "GarbageEnemy") { EnemyClass = GarbageEnemyClass; } else if (TypeEnemy[Itr.GetIndex()] == "MeleeBookEnemy") { EnemyClass = MeleeBookEnemyClass; } else if (TypeEnemy[Itr.GetIndex()] == "RangeBookEnemy") { EnemyClass = RangeBookEnemyClass; } else if (TypeEnemy[Itr.GetIndex()] == "PianoChargeEnemy") { EnemyClass = PianoEnemyClass; } else if (TypeEnemy[Itr.GetIndex()] == "BarrelChargeEnemy") { EnemyClass = BarrelEnemyClass; } else if (TypeEnemy[Itr.GetIndex()] == "FridgeChargeEnemy") { EnemyClass = FridgeEnemyClass; } if (GetWorld()) { int32 MyShinyNewInt = FCString::Atoi(*HowMuch[Itr.GetIndex()]); for (int x = 1; x <= MyShinyNewInt; x++) { float random = (float)rand() / (float)RAND_MAX; float randomy = (float)rand() / (float)RAND_MAX; int xValue = 1 + random * ((3) - (1)); int yValue = 1 + randomy * ((3) - (1)); float z, y; if (xValue == 1) z = random * (0 + (BoxSize[0] / 2)); else z = random * (0 - (BoxSize[0] / 2)); if (yValue == 1) y = random * (0 + (BoxSize[1] / 2)); else y = random * (0 - (BoxSize[1] / 2)); BoxOnWorld[0] += z; BoxOnWorld[1] += y; if (ShouldSpawnEnemies) { if (BoxInfo.IsInside(BoxOnWorld)) { NewPawn = GetWorld()->SpawnActor<AAI_BasicEnemy>(EnemyClass, BoxOnWorld, RotatorBoxOnWorld); FVector BoxOnWorld = GetActorLocation(); if (NewPawn != NULL) { if (NewPawn->Controller == NULL) { NewPawn->SpawnDefaultController(); } if (BehaviorTree != NULL) { AAIController* AIController = Cast<AAIController>(NewPawn->Controller); if (AIController != NULL) { AIController->RunBehaviorTree(BehaviorTree); } } } //AI Direct laten aanvallen wanneer die spawnt! AAI_BasicController* Controller = (AAI_BasicController*)NewPawn->GetController(); Controller->FoundPlayer(); Controller->AISetAttackState(); } } } } } EnemyClass = NULL; APawn* NewPawn = NULL; }
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); } } }
//----------------------------------------------------------------------// // 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; }
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; }
bool UPawnActionsComponent::PerformAction(APawn& Pawn, UPawnAction& Action, TEnumAsByte<EAIRequestPriority::Type> Priority) { bool bSuccess = false; ensure(Priority < EAIRequestPriority::MAX); if (Pawn.GetController()) { UPawnActionsComponent* ActionComp = Pawn.GetController()->FindComponentByClass<UPawnActionsComponent>(); if (ActionComp) { ActionComp->PushAction(Action, Priority); bSuccess = true; } } return bSuccess; }
AAIController* UAIBlueprintHelperLibrary::GetAIController(AActor* ControlledActor) { APawn* AsPawn = Cast<APawn>(ControlledActor); if (AsPawn != nullptr) { return Cast<AAIController>(AsPawn->GetController()); } return Cast<AAIController>(ControlledActor); }
UBehaviorTreeComponent* FBehaviorTreeDebugger::FindInstanceInActor(AActor* TestActor) { UBehaviorTreeComponent* FoundInstance = NULL; if (TestActor) { APawn* TestPawn = Cast<APawn>(TestActor); if (TestPawn && TestPawn->GetController()) { FoundInstance = TestPawn->GetController()->FindComponentByClass<UBehaviorTreeComponent>(); } if (FoundInstance == NULL) { FoundInstance = TestActor->FindComponentByClass<UBehaviorTreeComponent>(); } } return FoundInstance; }
void ANavLinkProxy::ResumePathFollowing(AActor* Agent) { if (Agent) { UPathFollowingComponent* PathComp = Agent->FindComponentByClass<UPathFollowingComponent>(); if (PathComp == NULL) { APawn* PawnOwner = Cast<APawn>(Agent); if (PawnOwner && PawnOwner->GetController()) { PathComp = PawnOwner->GetController()->FindComponentByClass<UPathFollowingComponent>(); } } if (PathComp) { PathComp->FinishUsingCustomLink(SmartLinkComp); } } }
UBlackboardComponent* UAIBlueprintHelperLibrary::GetBlackboard(AActor* Target) { UBlackboardComponent* BlackboardComp = nullptr; if (Target != nullptr) { APawn* TargetPawn = Cast<APawn>(Target); if (TargetPawn && TargetPawn->GetController()) { BlackboardComp = TargetPawn->GetController()->FindComponentByClass<UBlackboardComponent>(); } if (BlackboardComp == nullptr) { BlackboardComp = Target->FindComponentByClass<UBlackboardComponent>(); } } return BlackboardComp; }
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++; } } }
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; }
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 }
AActor* UWeaponComponent::PlotHitLine(float LineLength, AController* Instigator, TSubclassOf<UDamageType> DamageType, UGameplaySystemComponent* GameplaySystem) { if (this->GetOwner() == nullptr) return nullptr; AController* OwnerAsController = dynamic_cast<AController*>(this->GetOwner()); if (OwnerAsController == nullptr) return nullptr; if (OwnerAsController->GetPawn() == nullptr) return nullptr; FVector TraceStart = OwnerAsController->GetPawn()->GetActorLocation(); FVector TraceEnd = OwnerAsController->GetPawn()->GetActorLocation(); { FRotator Rotation = OwnerAsController->GetControlRotation(); TraceEnd += Rotation.RotateVector(FVector(LineLength, 0, 0)); } // Setup the trace query FCollisionQueryParams TraceParams = FCollisionQueryParams(); TraceParams.AddIgnoredActor(OwnerAsController->GetPawn()); TraceParams.bTraceAsyncScene = true; FCollisionResponseParams CollisionParams = FCollisionResponseParams(); FHitResult HitResult; if (this->GetWorld()->LineTraceSingleByChannel(HitResult, TraceStart, TraceEnd, ECC_GameTraceChannel1, TraceParams, CollisionParams)) { if (GameplaySystem == nullptr) return nullptr; APawn* TargetAsPawn = dynamic_cast<APawn*>(HitResult.Actor.Get()); if (TargetAsPawn) { TargetAsPawn->GetController()->TakeDamage(GameplaySystem->GetInfightAttackPoints(), FDamageEvent(DamageType), Instigator, Instigator->GetPawn()); } return HitResult.GetActor(); } else { return nullptr; } }
PyObject *py_ue_simple_move_to_location(ue_PyUObject *self, PyObject * args) { ue_py_check(self); FVector vec; if (!py_ue_vector_arg(args, vec)) return NULL; UWorld *world = ue_get_uworld(self); if (!world) return PyErr_Format(PyExc_Exception, "unable to retrieve UWorld from uobject"); APawn *pawn = nullptr; if (self->ue_object->IsA<APawn>()) { pawn = (APawn *)self->ue_object; } else if (self->ue_object->IsA<UActorComponent>()) { UActorComponent *component = (UActorComponent *)self->ue_object; AActor *actor = component->GetOwner(); if (actor) { if (actor->IsA<APawn>()) { pawn = (APawn *)actor; } } } if (!pawn) return PyErr_Format(PyExc_Exception, "uobject is not a pawn"); AController *controller = pawn->GetController(); if (!controller) return PyErr_Format(PyExc_Exception, "Pawn has no controller"); world->GetNavigationSystem()->SimpleMoveToLocation(controller, vec); Py_INCREF(Py_None); return Py_None; }
FExecStatus FCameraCommandHandler::SetCameraPose(const TArray<FString>& Args) { if (Args.Num() == 7) // ID, X, Y, Z, Pitch, Roll, Yaw { int32 CameraId = FCString::Atoi(*Args[0]); // TODO: Add support for multiple cameras float X = FCString::Atof(*Args[1]), Y = FCString::Atof(*Args[2]), Z = FCString::Atof(*Args[3]); FVector Location = FVector(X, Y, Z); float Pitch = FCString::Atof(*Args[4]), Yaw = FCString::Atof(*Args[5]), Roll = FCString::Atof(*Args[6]); FRotator Rotator = FRotator(Pitch, Yaw, Roll); APawn* Pawn = FUE4CVServer::Get().GetPawn(); bool Sweep = false; bool Success = Pawn->SetActorLocation(Location, Sweep, NULL, ETeleportType::TeleportPhysics); AController* Controller = Pawn->GetController(); Controller->ClientSetRotation(Rotator); // Teleport action // SetActorRotation(Rotator); // This is not working return FExecStatus::OK(); } return FExecStatus::InvalidArgument; }
void AFunctionalAITest::AddSpawnedPawn(APawn& SpawnedPawn) { SpawnedPawns.Add(&SpawnedPawn); OnAISpawned.Broadcast(Cast<AAIController>(SpawnedPawn.GetController()), &SpawnedPawn); }
void AResourceBuilding::Tick(float DeltaTime) { Super::Tick(DeltaTime); if (Role == ROLE_Authority && BuildProgressionState == BuildMeshes.Num()) { APlayerCharacter* PlayerCharacter = Cast<APlayerCharacter>(GetOwner()); if (IsGrowing && GrowProgressionState < GrowMeshes.Num()) { GrowProgression = FMath::Min(GrowProgression + (1 / GrowTime) * DeltaTime, 1.f); int32 CurrentGrowProgressionState = CalculateState(GrowProgression, GrowMeshes.Num()); if (GrowProgressionState != CurrentGrowProgressionState) { SendGrowStateUpdateToClients(GrowProgression); GrowProgressionState = CurrentGrowProgressionState; } if (GrowProgressionState == GrowMeshes.Num()) { CurrentProductionQuantity = ProductionQuantity; IsGrowing = false; } if (ConsumptionQuantity > 0) { int32 CurrentConsumeProgressionState = CalculateState(1 - GrowProgression, ConsumeMeshes.Num()) - 1; if (ConsumeProgressionState != CurrentConsumeProgressionState) { SendConsumeStateUpdateToClients(1 - GrowProgression); } if (CurrentGrowProgressionState == GrowMeshes.Num()) { CurrentConsumptionQuantity = 0; } } } else if (GrowProgressionState == 0 && CurrentProductionQuantity == 0 && (ConsumptionQuantity == 0 || CurrentConsumptionQuantity == ConsumptionQuantity)) { IsGrowing = true; SendGrowStateUpdateToClients(0.f); } else if (!CalledNpc) { if (GrowProgressionState == GrowMeshes.Num() || GrowProgressionState == 0 && CurrentConsumptionQuantity < ConsumptionQuantity && PlayerCharacter->CheckForQuantity(ConsumptionID) >= ConsumptionQuantity - CurrentConsumptionQuantity || CurrentProductionQuantity > 0) { if (PlayerCharacter) { APawn* FreeNpc = PlayerCharacter->CurrentPlayerstate->GetStorageWorker(); if (FreeNpc != NULL) { ANpcController* const Npc = Cast<ANpcController>(FreeNpc->GetController()); if (Npc) { if (CurrentProductionQuantity > 0) { if (ConsumptionQuantity > 0 && CurrentConsumptionQuantity < ConsumptionQuantity) { Npc->AddTask(ENpcTask::GetBuildingConsumption, this); Npc->AddTask(ENpcTask::PickupItemsFromStorage, PlayerCharacter->CurrentPlayerstate->OwnedStorageBuilding); Npc->AddTask(ENpcTask::DropItemsToBuilding, this); } Npc->AddTask(ENpcTask::PickupItemsFromBuilding, this); Npc->AddTask(ENpcTask::DropItemsToStorage, PlayerCharacter->CurrentPlayerstate->OwnedStorageBuilding); } else { Npc->AddTask(ENpcTask::GetBuildingConsumption, this); Npc->AddTask(ENpcTask::PickupItemsFromStorage, PlayerCharacter->CurrentPlayerstate->OwnedStorageBuilding); Npc->AddTask(ENpcTask::DropItemsToBuilding, this); UE_LOG(LogTemp, Warning, TEXT("npc called")); } IsGrowing = false; CalledNpc = true; } } } } } } }