UAISense_Actions Class Reference

#include <AISense_Actions.h>

Inheritance diagram for UAISense_Actions:

Classes
struct	FDigestedActionProperties

Public Member Functions
const FDigestedActionProperties *	GetActionConfigByListenerID (const FPerceptionListenerID &TargetID)
	UAISense_Actions (const FObjectInitializer &ObjectInitializer)
void	RegisterEvent (const FAIActionEvent &Event)

Static Public Member Functions
static void	ReportActionEvent (UObject *WorldContextObject, AActor *Broadcaster, AActor *OtherActor, const FVector &TargetLocation, const EAIActionType ActionType, const float EventRangeMultiplier=1.0f, const float PassedInfoAge=0.f, const float InStrength=1.f)

Public Attributes
TArray< FDigestedActionProperties >	DigestedProperties
TArray< FAIActionEvent >	RegisteredEvents

Protected Member Functions
virtual float	Update () override
void	OnNewListenerImpl (const FPerceptionListener &NewListener)
void	OnListenerRemovedImpl (const FPerceptionListener &UpdatedListener)

Protected Attributes
FGenericTeamId	TeamIdentifier

Constructor & Destructor Documentation

UAISense_Actions()

UAISense_Actions::UAISense_Actions

(

const FObjectInitializer &

ObjectInitializer

)

    :   Super(ObjectInitializer)
{
    //Bind the required functions
    OnNewListenerDelegate.BindUObject(this, &UAISense_Actions::OnNewListenerImpl);
    OnListenerRemovedDelegate.BindUObject(this, &UAISense_Actions::OnListenerRemovedImpl);
}

Member Function Documentation

GetActionConfigByListenerID()

const UAISense_Actions::FDigestedActionProperties * UAISense_Actions::GetActionConfigByListenerID

(

const FPerceptionListenerID &

TargetID

)

{
    for (const FDigestedActionProperties& Action : DigestedProperties)
    {
        if (Action.ListenerID == TargetID)
        {
            return &Action;
        }
    }
    return nullptr; // Return nullptr if not found
}

OnListenerRemovedImpl()

void UAISense_Actions::OnListenerRemovedImpl ( const FPerceptionListener & UpdatedListener )

protected

{
    //In our case, executes when we stop playing
    // GLog->Log("on listener removed!");
    check(UpdatedListener.Listener.IsValid());
    DigestedProperties.RemoveAll([&](const FDigestedActionProperties& Action) {
    return Action.ListenerID == UpdatedListener.GetListenerID();});
    RequestImmediateUpdate();
}

OnNewListenerImpl()

void UAISense_Actions::OnNewListenerImpl ( const FPerceptionListener & NewListener )

protected

{
    //Since we have at least one AI actor with this sense this function will fire when the game starts
    check(NewListener.Listener.IsValid());
    //Get the config
    UAISenseConfig* Config = NewListener.Listener->GetSenseConfig(GetSenseID());
    const UAISenseConfig_Actions* SenseConfig = Cast<const UAISenseConfig_Actions>(Config);
    check(SenseConfig);
    //Consume properties from the sense config
    const FDigestedActionProperties PropertyDigest(*SenseConfig, NewListener.GetListenerID());
    DigestedProperties.Add(PropertyDigest);
    RequestImmediateUpdate();
}

RegisterEvent()

void UAISense_Actions::RegisterEvent

(

const FAIActionEvent &

Event

)

{
    RegisteredEvents.Add(Event);
    RequestImmediateUpdate();
}

ReportActionEvent()

void UAISense_Actions::ReportActionEvent ( UObject * WorldContextObject, AActor * Broadcaster, AActor * OtherActor, const FVector & TargetLocation, const EAIActionType ActionType, const float EventRangeMultiplier = 1.0f, const float PassedInfoAge = 0.f, const float InStrength = 1.f )

static

{
    if(WorldContextObject == nullptr){return;}
    UAIPerceptionSystem* PerceptionSystem = UAIPerceptionSystem::GetCurrent(WorldContextObject);
    if(PerceptionSystem != nullptr)
    {
        const FAIActionEvent Event(Broadcaster, OtherActor, TargetLocation, ActionType, EventRangeMultiplier, PassedInfoAge, InStrength);
        PerceptionSystem->OnEvent(Event);
    }
}

Update()

float UAISense_Actions::Update ( )

overrideprotectedvirtual

{
    AIPerception::FListenerMap& ListenersMap = *GetListeners();
 
    //For each listener who has this sense we're going to perform a sweep to determine nearby aqua actors
    for (AIPerception::FListenerMap::TIterator ListenerIt(ListenersMap); ListenerIt; ++ListenerIt)
    {
        //Get the listener
        FPerceptionListener& Listener = ListenerIt->Value;
 
        //- Team 
        // skip listeners not interested in this sense
        if(Listener.HasSense(GetSenseID()) == false){continue;}
        if(GetActionConfigByListenerID(Listener.GetListenerID()) == nullptr){continue;}
        // const FDigestedActionProperties& ListenersConfig = DigestedProperties[Listener.GetListenerID()];
        const FDigestedActionProperties& ListenersConfig = *GetActionConfigByListenerID(Listener.GetListenerID());
        for(const FAIActionEvent& Event : RegisteredEvents)
        {
            const FVector::FReal DistToActionSquared = FVector::DistSquared(Event.GetBroadcastLocation(), Listener.CachedLocation);
            //- Don't want Negative Multiplier  //
            const float ClampedMultiplier = FMath::Max(0.1f, Event.RangeMultiplier);
            const bool bOutOfListeningRange = (DistToActionSquared > (FMath::Square(ListenersConfig.ActionRadius) * ClampedMultiplier));
 
            if(FAISenseAffiliationFilter::ShouldSenseTeam(Listener.TeamIdentifier, Event.TeamIdentifier, ListenersConfig.AffiliationFlags) == false)
            {
                continue;
            }
            if(bOutOfListeningRange)
            {
                continue;
            }
            // // @todo implement some kind of TeamIdentifierType that would supply comparison operator 
            // if(Listener.TeamIdentifier != Event.TeamIdentifier)
            // {
            //  continue;
            // }
            if(Listener.GetBodyActor()->GetInstigatorController() == Event.Broadcaster)
            {
                continue;
            }
            Listener.RegisterStimulus(Event.OtherActor, FAIStimulus(*this, Event.Strength, Event.Location, Event.GetBroadcastLocation(), FAIStimulus::SensingSucceeded, UAIBPLib::GetActionTagFromType(Event.Action)).SetStimulusAge(Event.InformationAge));
 
            // if(Listener.TeamIdentifier != Event.TeamIdentifier 
            //  || FVector::DistSquared(Event.GetBroadcastLocation(), Listener.CachedLocation) > Event.RangeSq)
            // {
            //  continue;
            // }
            // Listener.RegisterStimulus(Event.OtherActor, FAIStimulus(*this, Event.Strength, Event.Location, Event.GetBroadcastLocation(), FAIStimulus::SensingSucceeded, UAIBPLib::GetActionTagFromType(Event.Action)).SetStimulusAge(Event.InformationAge));
        }
 
 
        
        // 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].ActionRadius);
        //  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].ActionRadius, 8, FColor::Blue, false, 3.0f, 1, 1.f);
            // }
        //  
        //  if(HitResults.IsEmpty()){return 0.0f;}
        //  //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].ActionRadius)
        //          {
        //              Elem.Value.RegisterStimulus(hit.GetActor(), FAIStimulus(*this, 5.f, hit.GetActor()->GetActorLocation(), ListenerBodyActor->GetActorLocation()));
        //              // GLog->Log("registered stimulus!");
        //          }
        //
        //      }
        //
        //  }
        // }
        
        
    }
    RegisteredEvents.Reset();
    return SuspendNextUpdate;
 
    // //Time until next update; in this case we're forcing the update to happen in each frame
    // return 0.f;
}

Member Data Documentation

DigestedProperties

TArray<FDigestedActionProperties> UAISense_Actions::DigestedProperties

RegisteredEvents

TArray<FAIActionEvent> UAISense_Actions::RegisteredEvents

TeamIdentifier

FGenericTeamId UAISense_Actions::TeamIdentifier

protected

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/AIToolKit/Source/AIToolKit/Public/Behavior/Sense/AISense_Actions.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/AIToolKit/Source/AIToolKit/Private/Behavior/Sense/AISense_Actions.cpp