UE5_AI_CONTROLLER_AND_BLACKBOARDS1

 

 

 

 

 

 

 

 

 

 

 

Based on the context of the image—which displays a collection of Blueprint nodes used in Unreal Engine for AI development—here is the specific data and functionality missing from this list that a developer would typically expect to find in a complete "AI Controller & Blackboard" toolset:

1. Missing "Set" Data Types

The image lists Set Value as Vector, Set Value as Object, and Set Value as Bool. To fully utilize a Blackboard, you are missing the nodes for other essential variable types:

• Set Value as Float: Essential for timers, health percentages, or distances.
• Set Value as Int: Necessary for counting (e.g., ammo, patrol points index).
• Set Value as Name: Often used for state machine tags.
• Set Value as Enum: Crucial for switching between defined AI states (e.g., Passive, Aggressive, Fleeing).
• Set Value as String: Less common in AI logic but still a standard node.
• Set Value as Rotator: For facing directions.
• Set Value as Class: Used when the AI needs to reference a specific actor type to spawn or search for.

2. Missing "Get" Nodes

The image focuses heavily on setting data (Set Value...). It is missing the retrieval nodes required to read that data back into the AI Controller:

• Get Value as [Type]: (Vector, Bool, Object, Float, Int, etc.) The AI Controller needs to read the Blackboard to make decisions (e.g., checking if HasEnemy is true).

3. Missing Movement & Navigation

The AI Controller's primary job is often moving the pawn. The image is missing standard navigation nodes:

• Move To Location / Move To Actor: The most fundamental AI Controller nodes.
• Stop Movement: To halt the AI immediately.
• Get Controlled Pawn: While Get AIController is present, you usually need to get the specific Pawn or Character the controller is driving to access its location or variables.

4. Missing Event Counterparts

• On Unpossess: The image lists On Possess (which fires when the AI takes control), but is missing the event that fires when the AI loses control (e.g., death or vehicle exit).

5. Missing Perception Components

While strictly part of the "AI Perception" system, these are almost always used alongside the AI Controller and Blackboards:

• AIPerception Component events: Such as OnTargetPerceptionUpdated.
• Get Actors Perception: To poll what the AI currently sees or hears.

Summary

The image provides a partial list of Blackboard keys (omitting numbers and Enums) and focuses on writing data rather than reading it or acting on it (movement/navigation).

 

 

 

 

 

 

Based on the image provided and standard Unreal Engine 5 AI architecture, here is the final summary of the missing data required to create a fully functional AI system.

The image provided represents the "Write" and "Setup" phase of AI logic but completely lacks the "Read" and "Action" phases.

1. Missing Variable Types (The "Nuance" Data)

The image only includes Vector, Object, and Bool. To handle complex game logic, you are missing these specific data type nodes:

• Set Value as Float: Critical for analog data like Health %, Distance to Target, or Search Radius.
• Set Value as Int: Required for discrete counting, such as Ammo Count, Patrol Index, or Lives.
• Set Value as Enum: The industry standard for managing AI States (e.g., Idle, Chasing, Attacking, Fleeing). Without this, your state management becomes messy.
• Set Value as Name: Often used for specific tag checks or bone names.
• Set Value as Class: Used to define what specific enemy or item type the AI should look for next.

2. Missing "Get" Nodes (The "Read" Capability)

The image contains only Set nodes (writing to memory). It is missing the Get nodes (reading from memory), which renders the AI unable to make decisions based on its own knowledge.

• Get Value as [Type]: You need the counterparts for every Set node (e.g., Get Value as Bool, Get Value as Vector) to check conditions like "Is the enemy visible?" or "Where was the last known location?"

3. Missing Navigation & Locomotion (The "Body")

The AIController is responsible for physically moving the pawn, but those nodes are absent:

• Move To Location / Move To Actor: The primary nodes that instruct the AI to actually walk or fly to the coordinates stored in the Blackboard.
• Stop Movement: Essential for interrupting the AI when it takes damage or changes state.
• Set Focus: Used to force the AI to look at a specific target while moving (strafing/targeting).

4. Missing Lifecycle Events

• On Unpossess: The image shows On Possess (startup), but misses On Unpossess, which is required for cleanup when an AI dies, is destroyed, or is reset.

Final Verdict

The toolset shown in the image allows you to boot up an AI and store basic True/False or Location data. However, it lacks the ability to:

1. Store numeric data (Health/Ammo).
2. Read its own memory to make decisions.
3. Physically move the character.

 

Would you like me to draft a quick blueprint logic flow for how the missing Move To node connects with the Blackboard values?

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Based on this conceptual summary image, the missing data relates to the execution and maintenance components of the AI system. While the image correctly identifies the "Brain" (Controller), "Memory" (Blackboard), and "Decision Rules" (Decorators), it omits the parts that actually do the work and update the data.

Here is what is missing to complete the logical loop:

1. Missing Behavior Tree Components: "Services" & "Tasks"

The image mentions Decorators (which check data), but it misses the two other pillars of a Behavior Tree:

• Services: These are crucial. While Decorators check if a value is true, Services are what update those values. (e.g., A "Service" runs every 0.5 seconds to calculate the distance to the player and update the Blackboard). Without Services, your Blackboard data often becomes stale.
• Tasks: The image says the controller "drives a Pawn," but in the Behavior Tree, this is done specifically by Task Nodes (the leaf nodes). These are the specific instructions like "Move To," "Play Sound," or "Wait."

2. Missing Initialization: The "Run Behavior Tree" Call

The summary explains what the components are, but not how they start.

• The AI Controller does not automatically know which Behavior Tree to use.
• Missing Data: The summary lacks the crucial step where the AI Controller must execute the "Run Behavior Tree" node (usually on Event BeginPlay) to actually inject the Blackboard data and start the logic flow.

3. Missing Environmental Requirement: NavMesh

The first point mentions "using navigation," but this is impossible without world data.

• Missing Data: The NavMeshBoundsVolume. You cannot have an AI "drive a Pawn using navigation" unless a Navigation Mesh has been built in the level for the AI to walk on.

4. Missing "EQS" (Environment Query System)

For a complete summary of modern Unreal AI, EQS is the standard partner to the components listed.

• While the Blackboard stores what the AI knows (Health, Target), EQS handles spatial analysis (e.g., "Find me the best cover position that is hidden from the player but within range"). This is distinct from standard "Sensory data" or "Perception."

Summary for your notes

To make this summary actionable for your violin app project, you would need to add:

• Services (to update the memory).
• Tasks (to perform the actions).
• Run Behavior Tree (to start the brain).
• NavMesh (to define the walkable floor).

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Based on the two images you provided and the standard requirements for Unreal Engine 5 AI, here is the complete summary that fills in the gaps. This integrates the missing nodes, logic components, and environmental requirements into a cohesive list.

1. The Missing Data Types (Granular Control)

The images only accounted for Vectors, Objects, and Booleans. A complete AI system requires these specific variable types to function beyond basic tracking:

• Floats: Essential for analog data like timer duration, health percentage, or search radius.
• Integers: Required for discrete counting, such as patrol point index, ammo count, or sequential phases.
• Enums: The industry standard for managing AI States (e.g., Idle, Chasing, Teaching, Listening). This prevents "spaghetti code" logic.
• Classes: Used to store reference types, allowing the AI to know what to spawn or what specific actor class to search for.

2. The Missing "Read" Capability (Get Nodes)

The provided diagrams focused heavily on writing to the Blackboard (Set Value...). To make decisions, the AI Controller must also read from it.

• Get Blackboard Value As...: The necessary counterpart to every "Set" node. The AI cannot check "Is the Player Visible?" if it cannot retrieve that boolean from memory.

3. The Missing Behavior Tree Structure (Action & Maintenance)

The summary image mentioned Decorators (conditionals), but missed the components that actually perform actions and update data:

• Services: These run on a timer (tick) to constantly update the Blackboard (e.g., "Update Distance to Player" every 0.5s). Without Services, the data the Decorators check becomes stale.
• Tasks: The "Leaf Nodes" that execute the actual instructions, such as Play Sound, Wait, or Attack.
• Run Behavior Tree: The specific node required in the Controller to actually initialize the logic flow.

4. The Missing Physicality (Movement & Environment)

The diagrams were purely logical, omitting how the AI interacts with the 3D world:

• Navigation Nodes: Move To Location and Move To Actor are the primary methods for locomotion.
• NavMeshBoundsVolume: The invisible floor mesh required for any AI movement to calculate a path.
• EQS (Environment Query System): The system used for spatial reasoning (e.g., "Find a point 500 units away that is NOT visible to the player").

Complete System Overview

If you were to rewrite your log summary to include these missing pieces, it would look like this:

Component	Function	Missing Data Added
AI Controller	The Brain	Needs Run Behavior Tree to start; uses Get/Set nodes to think.
Blackboard	The Memory	Needs Floats, Ints, & Enums for complex state tracking.
Behavior Tree	The Logic Flow	Needs Services to update memory and Tasks to execute actions.
Navigation	The World	Needs NavMesh to walk and EQS to find smart positions.

Would you like me to generate a specific "Service" blueprint logic example for your violin app (e.g., a Service that constantly checks if the user is playing the correct note)?