float UAISense_Touch::Update() { AIPerception::FListenerMap& ListenersMap = *GetListeners(); for (int32 EventIndex = 0; EventIndex < RegisteredEvents.Num(); ++EventIndex) { const FAITouchEvent& Event = RegisteredEvents[EventIndex]; if (Event.TouchReceiver != NULL && Event.OtherActor != NULL) { IAIPerceptionListenerInterface* PerceptionListener = Cast<IAIPerceptionListenerInterface>(Event.TouchReceiver); if (PerceptionListener != NULL) { UAIPerceptionComponent* PerceptionComponent = PerceptionListener->GetPerceptionComponent(); if (PerceptionComponent != NULL && ListenersMap.Contains(PerceptionComponent->GetListenerId())) { // this has to succeed, will assert a failure FPerceptionListener& Listener = ListenersMap[PerceptionComponent->GetListenerId()]; Listener.RegisterStimulus(Event.OtherActor, FAIStimulus(GetSenseIndex(), 1.f, Event.Location, Event.Location)); } } } } RegisteredEvents.Reset(); // return decides when next tick is going to happen return SuspendNextUpdate; }
float UAISense_Team::Update() { AIPerception::FListenerMap& ListenersMap = *GetListeners(); for (AIPerception::FListenerMap::TIterator ListenerIt(ListenersMap); ListenerIt; ++ListenerIt) { FPerceptionListener& Listener = ListenerIt->Value; if (Listener.HasSense(GetSenseID()) == false) { // skip listeners not interested in this sense continue; } for (int32 EventIndex = 0; EventIndex < RegisteredEvents.Num(); ++EventIndex) { const FAITeamStimulusEvent& Event = RegisteredEvents[EventIndex]; // @todo implement some kind of TeamIdentifierType that would supply comparison operator if (Listener.TeamIdentifier != Event.TeamIdentifier || FVector::DistSquared(Event.GetBroadcastLocation(), Listener.CachedLocation) > Event.RangeSq) { continue; } Listener.RegisterStimulus(Event.Enemy, FAIStimulus(*this, Event.Strength, Event.LastKnowLocation, Event.GetBroadcastLocation(), FAIStimulus::SensingSucceeded).SetStimulusAge(Event.InformationAge)); } } RegisteredEvents.Reset(); // return decides when next tick is going to happen return SuspendNextUpdate; }
float UAISense_Prediction::Update() { AIPerception::FListenerMap& ListenersMap = *GetListeners(); for (int32 EventIndex = 0; EventIndex < RegisteredEvents.Num(); ++EventIndex) { const FAIPredictionEvent& Event = RegisteredEvents[EventIndex]; if (Event.Requestor != NULL && Event.PredictedActor != NULL) { IAIPerceptionListenerInterface* PerceptionListener = Cast<IAIPerceptionListenerInterface>(Event.Requestor); if (PerceptionListener != NULL) { UAIPerceptionComponent* PerceptionComponent = PerceptionListener->GetPerceptionComponent(); if (PerceptionComponent != NULL && ListenersMap.Contains(PerceptionComponent->GetListenerId())) { // this has to succeed, will assert a failure FPerceptionListener& Listener = ListenersMap[PerceptionComponent->GetListenerId()]; // calculate the prediction here: const FVector PredictedLocation = Event.PredictedActor->GetActorLocation() + Event.PredictedActor->GetVelocity() * Event.TimeToPredict; Listener.RegisterStimulus(Event.PredictedActor, FAIStimulus(*this, 1.f, PredictedLocation, Listener.CachedLocation)); } } } } RegisteredEvents.Reset(); // return decides when next tick is going to happen return SuspendNextUpdate; }
float UAISense_Damage::Update() { AIPerception::FListenerMap& ListenersMap = *GetListeners(); for (int32 EventIndex = 0; EventIndex < RegisteredEvents.Num(); ++EventIndex) { const FAIDamageEvent& Event = RegisteredEvents[EventIndex]; IAIPerceptionListenerInterface* PerceptionListener = Cast<IAIPerceptionListenerInterface>(Event.DamagedActor); if (PerceptionListener != NULL) { UAIPerceptionComponent* PerceptionComponent = PerceptionListener->GetPerceptionComponent(); if (PerceptionComponent != NULL) { // this has to succeed, will assert a failure FPerceptionListener& Listener = ListenersMap[PerceptionComponent->GetListenerId()]; Listener.RegisterStimulus(Event.Instigator, FAIStimulus(GetSenseIndex(), Event.Amount, Event.Location, Event.HitLocation)); } } } RegisteredEvents.Reset(); // return decides when next tick is going to happen return SuspendNextUpdate; }
bool UAISense_Sight::RegisterTarget(AActor& TargetActor, FQueriesOperationPostProcess PostProcess) { SCOPE_CYCLE_COUNTER(STAT_AI_Sense_Sight); FAISightTarget* SightTarget = ObservedTargets.Find(TargetActor.GetFName()); if (SightTarget == NULL) { FAISightTarget NewSightTarget(&TargetActor); SightTarget = &(ObservedTargets.Add(NewSightTarget.TargetId, NewSightTarget)); SightTarget->SightTargetInterface = Cast<IAISightTargetInterface>(&TargetActor); } // set/update data SightTarget->TeamId = FGenericTeamId::GetTeamIdentifier(&TargetActor); // generate all pairs and add them to current Sight Queries bool bNewQueriesAdded = false; AIPerception::FListenerMap& ListenersMap = *GetListeners(); const FVector TargetLocation = TargetActor.GetActorLocation(); for (AIPerception::FListenerMap::TConstIterator ItListener(ListenersMap); ItListener; ++ItListener) { const FPerceptionListener& Listener = ItListener->Value; const IGenericTeamAgentInterface* ListenersTeamAgent = Listener.GetTeamAgent(); if (Listener.HasSense(GetSenseID()) && Listener.GetBodyActor() != &TargetActor) { const FDigestedSightProperties& PropDigest = DigestedProperties[Listener.GetListenerID()]; if (FAISenseAffiliationFilter::ShouldSenseTeam(ListenersTeamAgent, TargetActor, PropDigest.AffiliationFlags)) { // create a sight query FAISightQuery SightQuery(ItListener->Key, SightTarget->TargetId); SightQuery.Importance = CalcQueryImportance(ItListener->Value, TargetLocation, PropDigest.SightRadiusSq); SightQueryQueue.Add(SightQuery); bNewQueriesAdded = true; } } } // sort Sight Queries if (PostProcess == Sort && bNewQueriesAdded) { SortQueries(); RequestImmediateUpdate(); } return bNewQueriesAdded; }
float UAISense_Aquaphobia::Update() { AIPerception::FListenerMap& ListenersMap = *GetListeners(); //For each listener who has this sense we're going to perform a sweep to determine nearby aqua actors for (auto& Elem : ListenersMap) { //Get the listener FPerceptionListener Listener = Elem.Value; const AActor* ListenerBodyActor = Listener.GetBodyActor(); for (int32 DigestedPropertyIndex = 0; DigestedPropertyIndex < DigestedProperties.Num(); DigestedPropertyIndex++) { //Create the sphere for this sense and perform the sweep to determine nearby actors FCollisionShape CollisionSphere = FCollisionShape::MakeSphere(DigestedProperties[DigestedPropertyIndex].PhobiaRadius); TArray<FHitResult> HitResults; GetWorld()->SweepMultiByChannel(HitResults, ListenerBodyActor->GetActorLocation(), ListenerBodyActor->GetActorLocation() + FVector::UpVector*CollisionSphere.GetSphereRadius(), FQuat(), ECollisionChannel::ECC_WorldDynamic, CollisionSphere); //Draw debug sphere if we have activated it via the config if (DigestedProperties[DigestedPropertyIndex].bDisplayDebugSphere) { DrawDebugSphere(GetWorld(), ListenerBodyActor->GetActorLocation(), DigestedProperties[DigestedPropertyIndex].PhobiaRadius, 8, FColor::Blue, false, 30.f, 1, 2.f); } //Check hit results for aqua actors for (int32 i = 0; i < HitResults.Num(); i++) { FHitResult hit = HitResults[i]; //To simplify things, we're going to assume that "water resources" for this post are actors that have the following game tag if (hit.GetActor()->ActorHasTag(FName("AquaActor"))) { if ((hit.GetActor()->GetActorLocation() - ListenerBodyActor->GetActorLocation()).Size() <= DigestedProperties[DigestedPropertyIndex].PhobiaRadius) { Elem.Value.RegisterStimulus(hit.GetActor(), FAIStimulus(*this, 5.f, hit.GetActor()->GetActorLocation(), ListenerBodyActor->GetActorLocation())); GLog->Log("registered stimulus!"); } } } } } //Time until next update; in this case we're forcing the update to happen in each frame return 0.f; }
float UAISense_Sight::Update() { static const FName NAME_AILineOfSight = FName(TEXT("AILineOfSight")); SCOPE_CYCLE_COUNTER(STAT_AI_Sense_Sight); const UWorld* World = GEngine->GetWorldFromContextObject(GetPerceptionSystem()->GetOuter()); if (World == NULL) { return SuspendNextUpdate; } int32 TracesCount = 0; static const int32 InitialInvalidItemsSize = 16; TArray<int32> InvalidQueries; TArray<FAISightTarget::FTargetId> InvalidTargets; InvalidQueries.Reserve(InitialInvalidItemsSize); InvalidTargets.Reserve(InitialInvalidItemsSize); AIPerception::FListenerMap& ListenersMap = *GetListeners(); FAISightQuery* SightQuery = SightQueryQueue.GetData(); for (int32 QueryIndex = 0; QueryIndex < SightQueryQueue.Num(); ++QueryIndex, ++SightQuery) { if (TracesCount < MaxTracesPerTick) { FPerceptionListener& Listener = ListenersMap[SightQuery->ObserverId]; ensure(Listener.Listener.IsValid()); FAISightTarget& Target = ObservedTargets[SightQuery->TargetId]; const bool bTargetValid = Target.Target.IsValid(); const bool bListenerValid = Listener.Listener.IsValid(); // @todo figure out what should we do if not valid if (bTargetValid && bListenerValid) { AActor* TargetActor = Target.Target.Get(); const FVector TargetLocation = TargetActor->GetActorLocation(); const FDigestedSightProperties& PropDigest = DigestedProperties[SightQuery->ObserverId]; const float SightRadiusSq = SightQuery->bLastResult ? PropDigest.LoseSightRadiusSq : PropDigest.SightRadiusSq; if (CheckIsTargetInSightPie(Listener, PropDigest, TargetLocation, SightRadiusSq)) { // UE_VLOG_SEGMENT(Listener.Listener.Get()->GetOwner(), Listener.CachedLocation, TargetLocation, FColor::Green, TEXT("%s"), *(Target.TargetId.ToString())); FVector OutSeenLocation(0.f); // do line checks if (Target.SightTargetInterface != NULL) { int32 NumberOfLoSChecksPerformed = 0; if (Target.SightTargetInterface->CanBeSeenFrom(Listener.CachedLocation, OutSeenLocation, NumberOfLoSChecksPerformed, Listener.Listener->GetBodyActor()) == true) { Listener.RegisterStimulus(TargetActor, FAIStimulus(*this, 1.f, OutSeenLocation, Listener.CachedLocation)); SightQuery->bLastResult = true; } else { // UE_VLOG_LOCATION(Listener.Listener.Get()->GetOwner(), TargetLocation, 25.f, FColor::Red, TEXT("")); Listener.RegisterStimulus(TargetActor, FAIStimulus(*this, 0.f, TargetLocation, Listener.CachedLocation, FAIStimulus::SensingFailed)); SightQuery->bLastResult = false; } TracesCount += NumberOfLoSChecksPerformed; } else { // we need to do tests ourselves /*const bool bHit = World->LineTraceTest(Listener.CachedLocation, TargetLocation , FCollisionQueryParams(NAME_AILineOfSight, true, Listener.Listener->GetBodyActor()) , FCollisionObjectQueryParams(ECC_WorldStatic));*/ FHitResult HitResult; const bool bHit = World->LineTraceSingle(HitResult, Listener.CachedLocation, TargetLocation , FCollisionQueryParams(NAME_AILineOfSight, true, Listener.Listener->GetBodyActor()) , FCollisionObjectQueryParams(ECC_WorldStatic)); ++TracesCount; if (bHit == false || (HitResult.Actor.IsValid() && HitResult.Actor->IsOwnedBy(TargetActor))) { Listener.RegisterStimulus(TargetActor, FAIStimulus(*this, 1.f, TargetLocation, Listener.CachedLocation)); SightQuery->bLastResult = true; } else { // UE_VLOG_LOCATION(Listener.Listener.Get()->GetOwner(), TargetLocation, 25.f, FColor::Red, TEXT("")); Listener.RegisterStimulus(TargetActor, FAIStimulus(*this, 0.f, TargetLocation, Listener.CachedLocation, FAIStimulus::SensingFailed)); SightQuery->bLastResult = false; } } } else { // UE_VLOG_SEGMENT(Listener.Listener.Get()->GetOwner(), Listener.CachedLocation, TargetLocation, FColor::Red, TEXT("%s"), *(Target.TargetId.ToString())); Listener.RegisterStimulus(TargetActor, FAIStimulus(*this, 0.f, TargetLocation, Listener.CachedLocation, FAIStimulus::SensingFailed)); SightQuery->bLastResult = false; } SightQuery->Importance = CalcQueryImportance(Listener, TargetLocation, SightRadiusSq); // restart query SightQuery->Age = 0.f; } else { // put this index to "to be removed" array InvalidQueries.Add(QueryIndex); if (bTargetValid == false) { InvalidTargets.AddUnique(SightQuery->TargetId); } } } else { // age unprocessed queries so that they can advance in the queue during next sort SightQuery->Age += 1.f; } SightQuery->RecalcScore(); } if (InvalidQueries.Num() > 0) { for (int32 Index = InvalidQueries.Num() - 1; Index >= 0; --Index) { // removing with swapping here, since queue is going to be sorted anyway SightQueryQueue.RemoveAtSwap(InvalidQueries[Index], 1, /*bAllowShrinking*/false); } if (InvalidTargets.Num() > 0) { for (const auto& TargetId : InvalidTargets) { // remove affected queries RemoveAllQueriesToTarget(TargetId, DontSort); // remove target itself ObservedTargets.Remove(TargetId); } // remove holes ObservedTargets.Compact(); } } // sort Sight Queries SortQueries(); //return SightQueryQueue.Num() > 0 ? 1.f/6 : FLT_MAX; return 0.f; }