void UAISense_Sight::GenerateQueriesForListener(const FPerceptionListener& Listener, const FDigestedSightProperties& PropertyDigest)
{
bool bNewQueriesAdded = false;
const IGenericTeamAgentInterface* ListenersTeamAgent = Listener.GetTeamAgent();
const AActor* Avatar = Listener.GetBodyActor();
// create sight queries with all legal targets
for (TMap<FName, FAISightTarget>::TConstIterator ItTarget(ObservedTargets); ItTarget; ++ItTarget)
{
const AActor* TargetActor = ItTarget->Value.GetTargetActor();
if (TargetActor == NULL || TargetActor == Avatar)
{
continue;
}
if (FAISenseAffiliationFilter::ShouldSenseTeam(ListenersTeamAgent, *TargetActor, PropertyDigest.AffiliationFlags))
{
// create a sight query
FAISightQuery SightQuery(Listener.GetListenerID(), ItTarget->Key);
SightQuery.Importance = CalcQueryImportance(Listener, ItTarget->Value.GetLocationSimple(), PropertyDigest.SightRadiusSq);
SightQueryQueue.Add(SightQuery);
bNewQueriesAdded = true;
}
}
// sort Sight Queries
if (bNewQueriesAdded)
{
SortQueries();
RequestImmediateUpdate();
}
}
void UAISense_Sight::GenerateQueriesForListener(const FPerceptionListener& Listener, const FDigestedSightProperties& PropertyDigest)
{
bool bNewQueriesAdded = false;
const IGenericTeamAgentInterface* ListenersTeamAgent = Listener.GetTeamAgent();
// create sight queries with all legal targets
for (TMap<FName, FAISightTarget>::TConstIterator ItTarget(ObservedTargets); ItTarget; ++ItTarget)
{
const AActor* TargetActor = ItTarget->Value.GetTargetActor();
if (TargetActor == NULL)
{
continue;
}
// @todo this should be configurable - some AI might want to observe Neutrals and Friendlies as well
if (ListenersTeamAgent == NULL || ListenersTeamAgent->GetTeamAttitudeTowards(*TargetActor) == ETeamAttitude::Hostile)
{
// create a sight query
FAISightQuery SightQuery(Listener.GetListenerID(), ItTarget->Key);
SightQuery.Importance = CalcQueryImportance(Listener, ItTarget->Value.GetLocationSimple(), PropertyDigest.SightRadiusSq);
SightQueryQueue.Add(SightQuery);
bNewQueriesAdded = true;
}
}
// sort Sight Queries
if (bNewQueriesAdded)
{
SortQueries();
RequestImmediateUpdate();
}
}
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_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;
}
