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;
}
}
}
}
}
}
}
