The LimboAI Behavior Tree for Godot 4 – A Must Learn for Beginners | Guide & Tutorial

Technology-focused summary (LimboAI Behavior Trees for Godot 4)

What the tutorial teaches (and why it matters)

• Introduces LimboAI Behavior Trees for Godot 4, paired with prior knowledge of state machines.
• Frames behavior trees as the core system for NPC intelligence (e.g., roam, chase, attack, flee), especially for non-player characters.

Behavior Tree fundamentals (key concepts explained)

• Behavior examples: patrol, chase player, run away when hurt.
• Task execution order: tasks run top-to-bottom.
• Two core composites:
  • Sequence: runs tasks in order; if any task fails, the whole sequence stops and remaining tasks don’t run.
  • Selector: runs children until one succeeds; then it stops and ignores the rest.
• Uses the tutorial’s mental model:
  • Sequence = to-do list (stop on failure)
  • Selector = choose first successful option (with backups)

Install + onboarding workflow (LimboAI)

• Steps to install the Limbo AI plugin for Godot 4.3 / 4.4 (choose the matching version).
• Mentions installer errors can be ignored as long as plugin installation completes.
• Recommends using LimboAI’s demo folder:
  • Open the showcase scene
  • Inspect the main sequence structure (e.g., pursue player, melee attack)
  • Use the begin tutorial inside the demo for clearer understanding

Prototype built: “birds” NPCs + player

The tutorial builds a full working prototype:

• World: platform mesh with collision.
• Player: CharacterBody3D with a basic movement template and collision (pill shape).
• Bird NPC:
  • Uses Sprite3D with a provided bird sprite sheet
  • Sets Texture Filter = Nearest for pixel-art clarity
  • Uses Alpha Cut for proper rendering/shadows
  • Configures animation frames (horizontal/vertical rows)
  • Adds collision (pill shape)
  • Creates AnimationPlayer animations:
    • idle, move, pack, tweet (and fly later)
  • Scales bird model and collision to match the tutorial’s needs

Behavior Tree design (how the birds behave)

1. Bird behavior tree structure

• Top-level Selector (a “picky parent”): chooses the first child that succeeds.
• Inside it:
  • A “fly away” branch (initially stubbed using fill tasks/weight tasks)
  • A “patrol” branch for idle/peck/pack behavior

2. Selector/sequence correctness debugging

• Initial issue: Console print never executes due to incorrect success/failure behavior of selector children.
• Fix uses decorators, including:
  • Always Succeed-style adjustment (to force selector traversal behavior)
  • Probability decorator to randomize whether a sub-behavior runs

3. Chill vs Move

• Adds Sequence “chill”:
  • Play idle
  • Wait/random pause
  • Play pack
  • Uses Await animation so it waits for animation completion before continuing
  • Waits again, then the sequence succeeds
• Adds Move logic but explains why it initially doesn’t trigger:
  • Because the selector stops once the chill sequence succeeds
• Resolves by putting “chill” under a Probability decorator so that sometimes the other child branch executes (e.g., movement)

Custom actions (extending LimboAI BT actions)

The tutorial builds its own behavior tree tasks in the tasks folder by extending the BT Action base class.

1. ChooseRandomPos.gd

   • Computes a random target position near the bird
   • Randomizes mainly X and Z
   • Stores it into a Blackboard variable (e.g., POS)
   • Returns success immediately

2. MoveToPos (custom action + code integration)

   • A “move to destination” action that:
     • Returns running while moving (tick-based)
     • Reads target position from Blackboard
     • Each tick calls the bird’s move() method
     • Computes distance to target; when within a threshold:
       • Stops velocity
       • Returns success
   • Prevents “infinite running” by correctly returning success on arrival

3. Agent (bird) code support

   • Adds bird methods called by BT actions, including:
     • move(target, speed...)
     • sprite flipping based on direction
   • Uses tick/physics movement and stops when reaching target

Interaction logic: “scared birds” that fly away

• Replaces a placeholder “fly away” behavior with real logic:

  • Adds a Blackboard variable State of type string
  • Behavior tree checks State == "scared" (BB check node)
  • If true:
    • Play fly animation
    • Run a Fly Away action (custom code)

• Scare trigger is implemented in bird code:

  • In physics_process, the bird checks if the player is within a distance threshold (e.g., < 3 units).
  • If close:
    • Sets Blackboard State to "scared"
    • Restarts the whole behavior tree
  • Important detail:
    • Restarting BT does not reset Blackboard, so "scared" persists and immediately drives the flee branch

• Ensures the player participates in detection:

  • Adds the player to a Godot group named Player

Debugging and testing tips highlighted

• Uses LimboAI’s debug screen to visualize which BT branch is active.
• Explains why certain tasks don’t run:
  • selector success prevents reaching later tasks
  • sequence success/failure determines traversal
• Mentions a practical prototype issue:
  • Birds colliding with each other can prevent movement completion
  • Quick workaround: disable layer collision so birds can clip through each other

Final conceptual takeaway emphasized

• Choosing between selectors vs sequences drives what behaviors can run and when.
• Decorators (probability, always succeed, etc.) control randomness and traversal.
• Blackboard variables act as shared state between tasks.
• Extending BT via custom BT actions connects behavior logic to Godot agent movement code.

---

Main speakers / sources

• Main speaker/creator: The tutorial author (single on-camera voice), teaching “LimboAI Behavior Tree for Godot 4”.
• Primary external source referenced: The LimboAI plugin (including its demo and documentation sections).