[C++/UE] UE5中AI開發的一點功能梳理（六） – AI Perception 感知系統 Event部分

//AIPerceptionSystem.cpp
void UAIPerceptionSystem::Tick(float DeltaSeconds)
{
    //...
    if(ListenerIt->Value.HasAnyNewStimuli())
    {
        ListenerIt->Value.ProcessStimuli();
    }
    //...
}

//AIPerceptionTypes.cpp
void FPerceptionListener::ProcessStimuli()
{
    ensure(bHasStimulusToProcess);
    Listener->ProcessStimuli();
    bHasStimulusToProcess = false;
}

//AIPerceptionComponent
void UAIPerceptionComponent::ProcessStimuli()
{
    SCOPE_CYCLE_COUNTER(STAT_AI_PercepComp_ProcessStimuli);
    
    if(StimuliToProcess.Num() == 0)
    {
        UE_VLOG(GetOwner(), LogAIPerception, Warning, TEXT("UAIPerceptionComponent::ProcessStimuli called without any Stimuli to process"));
        return;
    }

    const bool bBroadcastEveryTargetUpdate = OnTargetPerceptionUpdated.IsBound();
    const bool bBroadcastEveryTargetInfoUpdate = OnTargetPerceptionInfoUpdated.IsBound();
    
    TArray<FStimulusToProcess> ProcessingStimuli = MoveTemp(StimuliToProcess);
    TArray<AActor*> UpdatedActors;
    UpdatedActors.Reserve(ProcessingStimuli.Num());
    TArray<AActor*> ActorsToForget;
    ActorsToForget.Reserve(ProcessingStimuli.Num());
    TArray<TObjectKey<AActor>, TInlineAllocator<8>> DataToRemove;

    for (FStimulusToProcess& SourcedStimulus : ProcessingStimuli)
    {
        const TObjectKey<AActor>& SourceKey = SourcedStimulus.Source;

        FActorPerceptionInfo* PerceptualInfo = PerceptualData.Find(SourceKey);
        AActor* SourceActor = nullptr;

        if (PerceptualInfo == NULL)
        {
            if (SourcedStimulus.Stimulus.WasSuccessfullySensed() == false)
            {
                // this means it's a failed perception of an actor our owner is not aware of
                // at all so there's no point in creating perceptual data for a failed stimulus
                continue;
            }
            else
            {
                SourceActor = CastChecked<AActor>(SourceKey.ResolveObjectPtr(), ECastCheckedType::NullAllowed);

                // no existing perceptual data and source no longer valid: nothing to do with this stimulus
                if (SourceActor == nullptr)
                {
                    continue;
                }
                
                // create an entry
                PerceptualInfo = &PerceptualData.Add(SourceKey, FActorPerceptionInfo(SourceActor));
                // tell it what's our dominant sense
                PerceptualInfo->DominantSense = DominantSenseID;

                PerceptualInfo->bIsHostile = (FGenericTeamId::GetAttitude(GetOwner(), SourceActor) == ETeamAttitude::Hostile);
            }
        }

        if (PerceptualInfo->LastSensedStimuli.Num() <= SourcedStimulus.Stimulus.Type)
        {
            const int32 NumberToAdd = SourcedStimulus.Stimulus.Type - PerceptualInfo->LastSensedStimuli.Num() + 1;
            PerceptualInfo->LastSensedStimuli.AddDefaulted(NumberToAdd);
        }

        check(SourcedStimulus.Stimulus.Type.IsValid());

        FAIStimulus& StimulusStore = PerceptualInfo->LastSensedStimuli[SourcedStimulus.Stimulus.Type];
        const bool bActorInfoUpdated = SourcedStimulus.Stimulus.WantsToNotifyOnlyOnPerceptionChange() == false 
            || SourcedStimulus.Stimulus.WasSuccessfullySensed() != StimulusStore.WasSuccessfullySensed();

        if (SourcedStimulus.Stimulus.WasSuccessfullySensed())
        {
            RefreshStimulus(StimulusStore, SourcedStimulus.Stimulus);
        }
        else if (StimulusStore.IsExpired() == false)
        {    
            if (bActorInfoUpdated)
            {
                // @note there some more valid info in SourcedStimulus->Stimulus regarding test that failed
                // may be useful in future
                StimulusStore.MarkNoLongerSensed();
                StimulusStore.SetStimulusAge(0);
            }
        }
        else
        {
            HandleExpiredStimulus(StimulusStore);

            if (bForgetStaleActors && !PerceptualInfo->HasAnyCurrentStimulus())
            {
                if (AActor* ActorToForget = PerceptualInfo->Target.Get())
                {
                    ActorsToForget.Add(ActorToForget);
                }
            }
        }

        // if the new stimulus is "valid" or it's info that "no longer sensed" and it used to be sensed successfully
        if (bActorInfoUpdated)
        {
            // Source Actor is only resolved from SourceKey when required but might already have been resolved for new entry
            SourceActor = (SourceActor == nullptr) ? CastChecked<AActor>(SourceKey.ResolveObjectPtr(), ECastCheckedType::NullAllowed) : SourceActor;
            if (SourceActor == nullptr)
            {
                DataToRemove.Add(SourceKey);
            }
            else
            {
                UpdatedActors.AddUnique(SourceActor);
                if (bBroadcastEveryTargetUpdate)
                {
                    OnTargetPerceptionUpdated.Broadcast(SourceActor, StimulusStore);
                }
            }

            if (bBroadcastEveryTargetInfoUpdate)
            {
                OnTargetPerceptionInfoUpdated.Broadcast(FActorPerceptionUpdateInfo(GetTypeHash(SourceKey), PerceptualInfo->Target, StimulusStore));
            }
        }
    }

    if (UpdatedActors.Num() > 0)
    {
        if (AIOwner != NULL)
        {
            AIOwner->ActorsPerceptionUpdated(UpdatedActors);
        }

        OnPerceptionUpdated.Broadcast(UpdatedActors);
    }

    // forget actors that are no longer perceived
    for (AActor* ActorToForget : ActorsToForget)
    {
        ForgetActor(ActorToForget);
    }

    // notify anyone interested
    if (OnTargetPerceptionForgotten.IsBound())
    {
        for (AActor* ActorToForget : ActorsToForget)
        {
            OnTargetPerceptionForgotten.Broadcast(ActorToForget);
        }
    }

    // remove perceptual info related to stale actors
    for (const TObjectKey<AActor>& SourceKey : DataToRemove)
    {
        PerceptualData.Remove(SourceKey);
    }
}