KI in Godot 4 programmieren: Eine Schritt-für-Schritt-Anleitung (2026)

Frag jemanden, wie man KI in Godot macht, und du erhaltst zwei vollig unterschiedliche Antworten. Es hängt davon ab, was gemeint ist, denn dieselbe Formulierung beschreibt zwei grundverschiedene Aufgaben.

Die eine ist klassische Spiel-KI: der Goblin, der dich entdeckt, um eine Saule herum verfolgt und zuschlagt, sobald er nah genug ist. Das ist Entscheidungslogik plus Bewegung, und es ist seit Jahrzehnten das Fundament der Spieleentwicklung.

Die andere ist KI auf Basis von Sprachmodellen: der Ladenbetreiber, mit dem du wirklich in eigenen Worten sprechen kannst, der dir im Charakter antwortet. Das ist neu, schickt Text über das Internet an ein Modell und lost ein anderes Problem.

Die meisten Spiele brauchen die erste Art für fast alles und greifen auf die zweite nur für einige wenige Gesprachscharaktere zurück. Diese Anleitung behandelt beides, der Reihe nach, mit GDScript zum direkten Einsetzen in Godot 4. Am Ende wird gezeigt, wie eine KI-native Engine diesen Code für dich schreibt und ihn durch Spielen des Spiels testet, was der Teil ist, den Tutorials normalerweise überspringen.

Teil 1: Klassische Spiel-KI (die Art, die du am meisten brauchst)

Wenn ein Designer sagt, ein Gegner habe "gute KI", meint er damit fast nie ein neuronales Netz. Er meint, dass er vernunftige Entscheidungen trifft: Er bemerkt den Spieler, wahlt eine sinnvolle Aktion und ändert seine Entscheidung, wenn sich die Situation ändert. Im Code ist das ein Zustands-Automat.

Ein Zustands-Automat ist eine Liste von Zustanden (Idle, Patrouille, Verfolgen, Angriff) und den Regeln für den Wechsel zwischen ihnen. Es ist das einzeln nutzlichste Muster in der Spiel-KI, und Godot 4 hat alles, was du brauchst, um eines zu bauen.

Schritt 1: Die Gegner-Szene einrichten

Erstelle eine neue Szene mit einem CharacterBody2D als Wurzel (verwende CharacterBody3D für 3D, die Logik ist identisch). Füge diese Kinder-Nodes hinzu:

• Ein Sprite2D oder AnimatedSprite2D, damit du ihn sehen kannst
• Ein CollisionShape2D, damit er einen Korper hat
• Ein Area2D mit eigenem CollisionShape2D, großer als der Gegner, als Erkennungsradius
• Ein NavigationAgent2D, damit der Gegner um Wande herum navigieren kann

Das Erkennungs-Area2D ist das "Auge" des Gegners. Wenn der Spieler es betritt, weiß der Gegner, dass er reagieren muss.

Schritt 2: Den Zustands-Automaten schreiben

Füge dieses Skript dem Wurzel-Node hinzu. Es definiert vier Zustande und wechselt zwischen ihnen basierend auf der Entfernung zum Spieler.

extends CharacterBody2D

enum State { IDLE, PATROL, CHASE, ATTACK }

@export var move_speed: float = 120.0
@export var attack_range: float = 40.0

var state: State = State.IDLE
var player: Node2D = null

@onready var nav: NavigationAgent2D = $NavigationAgent2D

func _physics_process(_delta: float) -> void:
	match state:
		State.IDLE:
			velocity = Vector2.ZERO
			if player != null:
				state = State.CHASE
		State.CHASE:
			_chase()
		State.ATTACK:
			velocity = Vector2.ZERO
			_attack()
	move_and_slide()

func _chase() -> void:
	if player == null:
		state = State.IDLE
		return
	var distance := global_position.distance_to(player.global_position)
	if distance <= attack_range:
		state = State.ATTACK
		return
	nav.target_position = player.global_position
	var next_point := nav.get_next_path_position()
	velocity = global_position.direction_to(next_point) * move_speed

func _attack() -> void:
	# Angriffs-Animation abspielen, Schaden zufugen, dann zuruck zu Chase
	if player != null and global_position.distance_to(player.global_position) > attack_range:
		state = State.CHASE

# Diese Signale im Editor vom Erkennungs-Area2D verbinden
func _on_detection_area_body_entered(body: Node2D) -> void:
	if body.is_in_group("player"):
		player = body

func _on_detection_area_body_exited(body: Node2D) -> void:
	if body.is_in_group("player"):
		player = null
		state = State.IDLE

Zwei Dinge machen das zum Laufen. Die match-Anweisung auf state halt jedes Verhalten isoliert, sodass ein spaterer neuer Zustand die anderen nicht durcheinanderbringt. Und die body-entered- und body-exited-Signale des Area2D (im Node-Tab des Editors verbunden) schalten den Gegner zwischen aufmerksam und unaufmerksam um, ohne jeden Frame abzufragen.

Füge deinen Spieler der Gruppe player hinzu (auswahlen, Node-Tab, Gruppen, "player" hinzufügen), damit die Erkennungsprufung ihn findet.

Schritt 3: Wegfindung hinzufügen, damit der Gegner um Wande herumgeht

Das obige Skript verwendet NavigationAgent2D, aber der Agent benötigt eine Karte des Bodens. Füge deiner Level-Szene einen NavigationRegion2D hinzu und gib ihm ein NavigationPolygon, das den begehbaren Boden abdeckt, mit Aussparungen für Wande. Godot führt den Agenten automatisch durch das Polygon.

Der Kerngedanke: Dein KI-Skript bestimmt das Ziel (nav.target_position = player.global_position), und das Navigationssystem bestimmt den Weg dorthin. Du schreibst nie selbst Wegfindungs-Mathematik. get_next_path_position() liefert dir den nächsten Wegpunkt, und du bewegst dich darauf zu.

In 3D ist der Ablauf identisch mit NavigationRegion3D und NavigationAgent3D. Du backst ein Navigationsnetz über die Level-Geometrie statt ein Polygon zu zeichnen, aber das Skript-Muster ändert sich nicht.

Schritt 4: Sichtlinie hinzufügen (optional, aber empfehlenswert)

Ein Erkennungsradius allein bedeutet, dass der Gegner durch Wande sieht. Um das zu beheben, füge einen RayCast2D hinzu und pruf, ob der Strahl zum Spieler etwas trifft, bevor eine Verfolgung eingeleitet wird.

func can_see_player() -> bool:
	if player == null:
		return false
	$RayCast2D.target_position = to_local(player.global_position)
	$RayCast2D.force_raycast_update()
	if $RayCast2D.is_colliding():
		return $RayCast2D.get_collider() == player
	return true

Knupfe deinen IDLE -> CHASE-Übergang an can_see_player(), und der Gegner benötigt nun eine echte Sichtlinie, was sich für den Spieler deutlich fairer und intelligenter anfühlt.

Das ist eine vollständige, auslieferbare Gegner-KI: Sie erkennt, verfolgt um Hindernisse herum, respektiert Wande für die Sichtlinie und greift in Reichweite an. Patrouillenwege, Fliehen bei wenig Gesundheit und Gruppentaktiken sind alles nur weitere Zustande und Übergänge auf demselben Gerust.

Teil 2: LLM-gesteuerte KI (sprechende NPCs)

Die zweite Bedeutung von "KI in Godot" ist ein NPC, mit dem du dich frei unterhalten kannst. Das ist ein vollig anderer Mechanismus. Statt eines Zustands-Automaten sendest du Text an ein Sprachmodell und wandelst die Antwort in Dialog um.

Godot 4 hat kein eingebautes Modell, aber es hat HTTPRequest, und das ist alles, was du brauchst, um eines anzusprechen.

Schritt 1: Eine Nachricht an ein Modell senden

Füge einen HTTPRequest-Node und ein Skript hinzu, das die Nachricht des Spielers zusammen mit einer kurzen Charakterbeschreibung an eine Modell-API schickt.

extends Node

@onready var http: HTTPRequest = $HTTPRequest

const ENDPOINT := "https://api.example-model.com/v1/chat"
const API_KEY := "your-key-here" # nicht in veroffentlichte Builds einbauen

func ask_npc(player_message: String) -> void:
	var headers := [
		"Content-Type: application/json",
		"Authorization: Bearer " + API_KEY,
	]
	var body := {
		"system": "Du bist Bram, ein mude wirkender Dorfschmied. Bleib in der Rolle. Halte Antworten unter zwei Satzen.",
		"message": player_message,
	}
	http.request(ENDPOINT, headers, HTTPClient.METHOD_POST, JSON.stringify(body))

func _ready() -> void:
	http.request_completed.connect(_on_response)

func _on_response(_result, _code, _headers, response_body: PackedByteArray) -> void:
	var data = JSON.parse_string(response_body.get_string_from_utf8())
	var reply: String = data.get("reply", "...")
	show_dialogue(reply)

func show_dialogue(text: String) -> void:
	# Text in deine Dialog-Benutzeroberflache weitergeben
	print(text)

Schritt 2: Dem NPC ein Gedachtnis geben

Ein Modell ohne Gedachtnis beginnt jedes Gespräch von vorn. Damit der Schmied sich an dich erinnert, fuhre eine laufende Liste vergangener Gespräche und füge in jede Anfrage eine kurze Zusammenfassung ein. Speichere sie im NPC, hange jede Runde an, und wenn sie zu lang wird, bitte das Modell, die alten Runden in ein oder zwei Satze zusammenzufassen, damit der Prompt nicht unbegrenzt wächst.

Schritt 3: Die Kompromisse kennen, bevor du dich festlegst

LLM-Dialog ist kraftvoll, aber nicht kostenlos. Jede Nachricht kostet Geld, braucht einen Moment, um über das Netz zuruckzukommen, und erfordert eine Internetverbindung, was bedeutet, dass es nicht offline laufen kann. Es kann auch vom Thema oder aus dem Charakter driften, wenn deine Anweisungen zu vage sind.

Deshalb ist das realistische Muster ein Hybrid: klassische KI für das Verhalten jedes NPCs, und LLM-Dialog reserviert für einige wenige Charaktere, bei denen offene Gespräche der eigentliche Punkt sind. Wenn du die vollständige Version davon willst, einschließlich Personlichkeits-Prompts, Gedachtnissystemen und dem Verankern von Charakteren im Spielzustand, haben wir eine eigene Anleitung dazu geschrieben: KI-NPCs mit Gedachtnis und Personlichkeit in Godot 4 erstellen. Der KI-NPC-Generator ist der schnellste Weg, einen aufzubauen.

Der schnellere Weg: eine KI-native Engine schreibt es

Alles oben beschriebene ist der manuelle Weg, und es lohnt sich, ihn zu verstehen, weil er die Muster lehrt. Aber einen Zustands-Automaten von Hand zu schreiben, zu verdrahten und zu debuggen ist langsam, und die Fehler zeigen sich erst, wenn du das Spiel startest.

Genau hier verändert eine KI-native Engine die Arbeit. Summer Engine ist mit Godot 4 kompatibel und integriert den KI-Assistenten direkt in den Editor, sodass er nicht nur Code in einem Seitenpanel vorschlagt. Er liest deinen Szenenbaum, schreibt das GDScript, verdrahtet den NavigationAgent und das Erkennungs-Area2D, startet das Spiel, liest die Laufzeitfehler und behebt sie. Du beschreibst das Verhalten in einfacher Sprache:

Lass das Skelett zwischen zwei Punkten patrouillieren, den Spieler verfolgen, wenn es ihn sieht, und angreifen, wenn es nah genug ist. Nutze Navigation, damit es um Wande herumgeht.

Es erzeugt denselben Zustands-Automaten wie oben, angehangt an eine echte Gegner-Szene, und druckt dann auf Abspielen, um zu bestätigen, dass das Skelett tatsächlich verfolgt statt gegen eine Wand zu laufen. Diese Schreiben-Spielen-Lesen-Schleife ist der Unterschied zwischen einer KI, die dir ein Code-Snippet übergibt, und einer, die funktionierendes Verhalten liefert, weil die meisten KI-Fehler in einem Spiel Laufzeitfehler sind, die ein Chat-Fenster nie sieht.

Ehrlich gesagt: Der kostenlose Tarif deckt Erstellen, Testen und Exportieren ab, was ausreicht, um die Muster zu erlernen und einen ersten KI-gesteuerten Prototyp zu veröffentlichen. Kostenpflichtige Plane bieten mehr Nutzung und leistungsstarkere Modelle für die tagliche Arbeit. Wenn du die Optionen für KI in einem Godot-Workflow vergleichen möchtest, stellt die Seite Godot AI sie vor, und die Template-Bibliothek bietet Startprojekte mit bereits verdrahteten Gegnern, sodass du Verhalten anpasst statt es von null aufzubauen.

Wo anfangen

Wenn du lernst, bau Teil 1 von Hand. Ein Zustands-Automat und ein NavigationAgent tragen dich durch fast jeden Gegner, Begleiter und jede Kreatur, die du je brauchen wirst, und das Muster skaliert von einem einzelnen Goblin bis zu einem vollständigen Kampfbegegnung.

Greife auf Teil 2 nur zurück, wenn ein offenes Gespräch wirklich der Zweck eines Charakters ist, und beschranke es auf einige wenige NPCs, damit Kosten und Latenz im Rahmen bleiben.

Und wenn du schneller vorankommen willst, als jeden Zustand von Hand zu tippen, beschreibe das Verhalten und lass die Engine es für dich erstellen und testen. Die Muster in dieser Anleitung sind genau das, was sie schreibt, also macht dich das Verstehen dieser Muster besser darin, sie zu steuern, egal welchen Weg du einschlagst.