Distinguishing Perception from Decision Making Logic

In this lesson, you will learn how to architect your AI systems to cleanly separate raw environmental data from the high-level behavior logic that drives your agent.

The Problem of "Spaghetti" Logic

In early AI development, it is tempting to place decision-making logic—like If (EnemyIsVisible) { Attack(); }—directly inside your AIPerception callbacks. However, this creates a tightly coupled, fragile system. When the perception data updates, your agent immediately reacts without considering its current state, goals, or priorities.

The Solution: Blackboards as a Buffer

Instead of triggering actions directly from senses, treat Perception as a source of information and Decision Making as the consumer of that information.

1. Perception (The Observer): Uses components like UAIPerceptionComponent to gather raw data (e.g., "I see Actor X at Location Y"). This should only be responsible for updating a shared data container, like a UBlackboardData asset.
2. Decision Making (The Thinker): Uses logic (Behavior Trees or State Machines) that polls the Blackboard. It doesn't care how the information was perceived; it only cares what the values are.

Practical Implementation

Consider a guard who spots a player. Instead of calling Attack() inside the perception event, simply update the Blackboard:

// Inside your AI Controller perception update
void AMyAIController::OnTargetPerceptionUpdated(AActor* Actor, FAIStimulus Stimulus)
{
    // Perception Logic: Update the "Source of Truth"
    if (Blackboard)
    {
        Blackboard->SetValueAsObject(FName("TargetActor"), Actor);
        Blackboard->SetValueAsBool(FName("bCanSeePlayer"), Stimulus.WasSuccessfullySensed());
    }
}

The Behavior Tree then monitors the bCanSeePlayer boolean. If it turns true, a "Selector" node evaluates the state and chooses to transition from an "Idle" task to an "Attack" task. By keeping the logic inside the Behavior Tree and the data updates inside the Controller, you ensure that the AI can "think" about its options rather than blindly reacting to every sensory pulse. This makes your AI predictable, easier to debug, and simple to expand with new sensory inputs later.

Key Takeaway: Perception should only update the state of your AI’s knowledge (Blackboard), while decision-making systems should independently observe that knowledge to determine the next action.