KI in Godot 4 programmieren: Eine Schritt-fur-Schritt-Anleitung (2026)

Frag jemanden, wie man KI in Godot macht, und du erhaltst zwei vollig unterschiedliche Antworten. Es hangt 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 uber das Internet an ein Modell und lost ein anderes Problem.

Die meisten Spiele brauchen die erste Art fur fast alles und greifen auf die zweite nur fur einige wenige Gesprachscharaktere zuruck. 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 fur dich schreibt und ihn durch Spielen des Spiels testet, was der Teil ist, den Tutorials normalerweise uberspringen.

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 andert seine Entscheidung, wenn sich die Situation andert. Im Code ist das ein Zustands-Automat.

Ein Zustands-Automat ist eine Liste von Zustanden (Idle, Patrouille, Verfolgen, Angriff) und den Regeln fur 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 fur 3D, die Logik ist identisch). Fuge 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, grosser 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, weiss der Gegner, dass er reagieren muss.

Schritt 2: Den Zustands-Automaten schreiben

Fuge 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.

Fuge deinen Spieler der Gruppe player hinzu (auswahlen, Node-Tab, Gruppen, "player" hinzufugen), damit die Erkennungsprufung ihn findet.

Schritt 3: Wegfindung hinzufugen, damit der Gegner um Wande herumgeht

Das obige Skript verwendet NavigationAgent2D, aber der Agent benotigt eine Karte des Bodens. Fuge deiner Level-Szene einen NavigationRegion2D hinzu und gib ihm ein NavigationPolygon, das den begehbaren Boden abdeckt, mit Aussparungen fur Wande. Godot fuhrt 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 nachsten Wegpunkt, und du bewegst dich darauf zu.

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

Schritt 4: Sichtlinie hinzufugen (optional, aber empfehlenswert)

Ein Erkennungsradius allein bedeutet, dass der Gegner durch Wande sieht. Um das zu beheben, fuge 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-Ubergang an can_see_player(), und der Gegner benotigt nun eine echte Sichtlinie, was sich fur den Spieler deutlich fairer und intelligenter anfuhlt.

Das ist eine vollstandige, auslieferbare Gegner-KI: Sie erkennt, verfolgt um Hindernisse herum, respektiert Wande fur die Sichtlinie und greift in Reichweite an. Patrouillenwege, Fliehen bei wenig Gesundheit und Gruppentaktiken sind alles nur weitere Zustande und Ubergange 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

Fuge 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 Gesprach von vorn. Damit der Schmied sich an dich erinnert, fuhre eine laufende Liste vergangener Gesprache und fuge 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 wachst.

Schritt 3: Die Kompromisse kennen, bevor du dich festlegst

LLM-Dialog ist kraftvoll, aber nicht kostenlos. Jede Nachricht kostet Geld, braucht einen Moment, um uber 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 fur das Verhalten jedes NPCs, und LLM-Dialog reserviert fur einige wenige Charaktere, bei denen offene Gesprache der eigentliche Punkt sind. Wenn du die vollstandige Version davon willst, einschliesslich 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 verandert 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 bestatigen, dass das Skelett tatsachlich verfolgt statt gegen eine Wand zu laufen. Diese Schreiben-Spielen-Lesen-Schleife ist der Unterschied zwischen einer KI, die dir ein Code-Snippet ubergibt, 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 veroffentlichen. Kostenpflichtige Plane bieten mehr Nutzung und leistungsstarkere Modelle fur die tagliche Arbeit. Wenn du die Optionen fur KI in einem Godot-Workflow vergleichen mochtest, 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 vollstandigen Kampfbegegnung.

Greife auf Teil 2 nur zuruck, wenn ein offenes Gesprach 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 fur 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.