# Tools und RQL — Unity · AI Game Developer Wiki

Was ein AI-Agent mit Unity MCP im Unity Editor kann: RQL-Abfragen und -Mutationen, Screenshots, C#-Skripte, Tests, Pakete und Profiling.

Diese Seite wurde maschinell aus dem Englischen übersetzt. [Englisches Original lesen](https://ai-game.dev/docs/wiki/unity/tools-and-rql).

Diese Seite erklärt, was der AI-Agent in deinem Unity-Projekt tun kann, sobald Unity MCP verbunden ist: welche Tools er sieht, wie RQL ihn fast alles im Editor lesen und ändern lässt und welche Tools installiert, aber verborgen sind. Die vollständige, durchsuchbare Liste mit Parametern steht im [Unity-Tool-Katalog](https://ai-game.dev/docs/tools/unity), und die Abfragesprache ist in der [RQL-Referenz](https://ai-game.dev/docs/rql) dokumentiert.

## Die Tools, die der Agent standardmäßig sieht

Seit Version 1.0.0 hält das Plugin die Tool-Liste des Agenten kurz. Diese sieben Tools sind nach der Installation sichtbar:

| Tool | Was es tut |
| --- | --- |
| `rql-query` | Liest Editor-Daten mit einer RQL-Abfrage: Szenen, GameObjects, Komponenten, Assets, die Console, Einstellungen, Tests, den Profiler. |
| `rql-mutate` | Ändert Editor-Daten oder ruft Editor-Operationen mit RQL auf: Objekte und Assets erstellen, ändern, verschieben und löschen, Szenen öffnen und speichern. |
| `rql-schema` | Beschreibt die Quellen, Typen, Member und Aufrufe, die RQL nutzen kann, und gibt Themen-Guides aus. Der Agent beginnt hier, wenn er unsicher ist. |
| `script-execute` | Kompiliert und führt C#-Code im Editor mit Roslyn aus und gibt das Ergebnis zurück. |
| `screenshot-isolated` | Rendert ein GameObject isoliert aus einem gewählten Winkel, optional als 2x2-Komposit, damit das Modell es sich ansehen kann. |
| `tests-run` | Führt EditMode- oder PlayMode-Tests aus und gibt die Ergebnisse pro Test zurück. |
| `unity-tool-list` | Listet jedes Tool auf und ob der Agent es sieht. |

Eine kurze Liste kostet weniger Tokens und lässt dem Modell mehr Raum zum Denken. Die anderen Tools sind weiterhin installiert; siehe [Verborgene Tools](https://ai-game.dev/de/docs/wiki/unity/tools-and-rql#hidden-tools).

## RQL: eine Sprache für den ganzen Editor

RQL ist eine Abfragesprache über die Live-Daten des Editors. Eine Abfrage beginnt mit einer **Quelle** und schickt das Ergebnis durch Stufen, die durch `|` getrennt sind, etwa `where`, `select`, `get`, `set` und `call`. Statt eines Tools pro Aktion (die alten `gameobject-create`, `scene-save`, `console-get-logs` und Dutzende mehr) schreibt der Agent eine Abfrage.

Lies die gesamte Hierarchie der geöffneten Szenen:

```text
roots | recurse children | select name active
```

Finde den Player:

```text
objects | where name == "Player" | select path name active
```

Erstelle eine Bodenebene:

```text
editor | call CreateGameObject({name: "Ground", primitive: "Plane"})
```

Füge eine Komponente hinzu und speichere:

```text
objects | where name == "Player" | call AddComponent("Rigidbody")
editor | call SaveScenes()
```

Lies nur die Fehler aus der Console:

```text
console | where logType == "Error"
```

Jeder `rql-mutate`-Aufruf ist eine Undo-Gruppe, sodass Strg+Z ihn rückgängig macht, und geänderte Assets, Szenen und das geöffnete Prefab werden nach der Mutation gespeichert. `rql-mutate` akzeptiert außerdem `dry_run`, um eine Vorschau der Änderungen zu erhalten, und `max_targets`, um zu begrenzen, wie viele Objekte eine Mutation berühren darf.

### RQL-Quellen in Unity

| Quelle | Inhalt |
| --- | --- |
| `scenes`, `roots`, `objects` | Geladene Szenen, ihre Root-GameObjects und jedes GameObject darin. |
| `selection` | Die aktuelle Editor-Auswahl. |
| `prefab` | Das im Prefab-Modus geöffnete Prefab. |
| `editor` | Editor-Operationen: GameObjects, Materialien, Ordner und Szenen erstellen; Szenen und Prefabs öffnen und speichern; Assets kopieren, verschieben und löschen; Menüpunkte ausführen; Play-Mode-Status. |
| `settings` | Projekteinstellungen. |
| `console` | Erfasste Editor-Log-Einträge. |
| `shaders`, `componentTypes` | Verfügbare Shader und Komponententypen. |
| `tests`, `testResults` | Der Testbaum und die letzten Ergebnisse. |
| `profiler` | Speicher-, Rendering-, Skript- und Frame-Daten; Captures starten, stoppen, speichern und laden. |
| `lighting` | Die Umgebung der aktiven Szene (Ambient, Nebel, Skybox, Sonne, Reflexionen), die Lighting Settings und der Bake. |

Assets werden über ihren Pfad mit `unity.asset("Assets/…")` adressiert oder mit `unity.assets("t:Material")` gesucht. Jede installierte [Erweiterung](https://ai-game.dev/de/docs/wiki/unity/extensions) fügt eigene Quellen und Typen hinzu, zum Beispiel `tilemap` oder `cinemachine`.

Da RQL über Reflexion arbeitet, kann der Agent auch Member deiner eigenen Komponenten lesen und setzen, nicht nur die von Unity mitgelieferten. Du kannst RQL mit [eigenen Adaptern](https://ai-game.dev/docs/rql/custom-adapters) etwas über deine eigenen Typen beibringen.

## Skripte und C#-Ausführung

`script-execute` kompiliert einen C#-Schnipsel mit Roslyn und führt ihn im Editor aus. Es nimmt den Code plus optionale `className`, `methodName`, zusätzliche `usings` und Helper-Dateien zum `include` entgegen. Es ist der Notausgang für alles, was RQL nicht abdeckt. Von einem Terminal aus ruft `unity-mcp-cli exec` dasselbe Tool auf:

```bash
unity-mcp-cli exec 'Application.unityVersion'
```

Um Dateien zu schreiben statt Code auszuführen, verwalten die verborgenen Tools `script-read`, `script-update-or-create` und `script-delete` die `.cs`-Dateien im Projekt. Unity kompiliert nach einer Änderung neu; die Verbindung bricht während des Domain Reloads kurz ab und kommt von selbst zurück.

## Tests

`tests-run` führt EditMode- oder PlayMode-Tests aus (`testMode`, Standard ist EditMode). Filtere nach Assembly, Namespace, Klasse oder Methode, oder übergib eine RQL-Auswahl über die Quelle `tests`, um genau die gewählten Tests als einen Lauf auszuführen. Ergebnisse lassen sich mit RQL über `testResults` filtern. Optionen steuern, ob bestandene Tests, Meldungen, Stacktraces und Console-Logs enthalten sind, was die Ausgabe klein hält.

```bash
unity-mcp-cli run-tool tests-run ./MyUnityProject --input '{"testMode":"EditMode"}'
```

## Screenshots

`screenshot-isolated` ist standardmäßig sichtbar. Drei weitere sind verborgen: `screenshot-scene-view`, `screenshot-game-view` und `screenshot-camera`. Bilder sind an der längsten Kante auf 3840 Pixel begrenzt, damit sie durch den MCP-Transport passen. Screenshots brauchen ein Grafikgerät: Ein Editor, der mit `-nographics` gestartet wurde, gibt einen Fehler statt eines leeren Bildes zurück.

## Verborgene Tools

Diese sind installiert, stehen aber nicht in der Liste des Agenten. Ein verborgenes Tool wird trotzdem ausgeführt, wenn es beim Namen aufgerufen wird.

- Screenshots: `screenshot-scene-view`, `screenshot-game-view`, `screenshot-camera`.
- Skripte: `script-read`, `script-update-or-create`, `script-delete`.
- Pakete: `package-list`, `package-search`, `package-add`, `package-remove` für den Unity Package Manager.
- Tool-Verwaltung: `tool-set-visibility` und sein veraltetes Alias `tool-set-enabled-state`.

Blende sie im AI Game Developer-Fenster (**Tools > Open**), mit dem Tool `tool-set-visibility` oder mit Folgendem ein:

```bash
unity-mcp-cli configure ./MyUnityProject --enable-tools package-add,package-list
```

## Prompts und Skills

Das Plugin liefert außerdem 46 MCP-Prompts (Slash-Command-Vorlagen wie `setup-basic-scene` oder `add-event-system`) in sechs Gruppen: Skripting, GameObjects und Komponenten, Szenen, Debugging und Testen, Asset-Verwaltung, Animation und Timeline. Sie sind standardmäßig verborgen; aktiviere die gewünschten unter **Prompts > Open**.

**Skills** sind Markdown-Dateien, die das Plugin in den Skills-Ordner deines Agenten generiert. Sie enthalten die Anleitung `unity-rql` mit der RQL-Syntax für Unity und jede installierte Erweiterung sowie Hinweise zu Setup und CLI. Aktiviere sie mit **Skills > Auto-generate** im Fenster oder führe `unity-mcp-cli setup-skills <agent>` aus.

## Tool-Namen aus älteren Tutorials

Version 1.0.0 hat die Tools mit einem Tool pro Aktion entfernt. Wenn ein Tutorial eines davon erwähnt, verwende stattdessen RQL:

- `gameobject-create`, `gameobject-find`, `gameobject-modify`, `gameobject-destroy`, `gameobject-component-*`: RQL auf `objects`, `roots` und `selection` mit `set` und `call`.
- `scene-create`, `scene-open`, `scene-save`: `editor | call NewScene(…)`, `OpenScene(…)`, `SaveScenes()`.
- `assets-*`, `assets-prefab-*`, `assets-material-create`: `unity.asset(…)`, `unity.assets(…)` und `editor`-Aufrufe wie `CreateMaterial`, `CopyAsset`, `InstantiatePrefab`.
- `console-get-logs`, `console-clear-logs`: die Quelle `console` und `editor | call ClearConsole()`.
- `editor-application-*`, `editor-selection-*`: `editor`-Member wie `isPlaying` und `selection`.
- `reflection-method-find`, `reflection-method-call`, `type-get-json-schema`: RQL-`call` und `rql-schema`.
- `profiler-*`: die Quelle `profiler`.

## Verwandte Seiten

- [Unity-Tool-Katalog](https://ai-game.dev/docs/tools/unity) und [RQL-Referenz](https://ai-game.dev/docs/rql).
- [Eigene Tools](https://ai-game.dev/de/docs/wiki/unity/custom-tools), um eigene hinzuzufügen.
- [Unity-Best-Practices](https://ai-game.dev/docs/best-practices/unity) für das Prompting.

---

Source (HTML): https://ai-game.dev/de/docs/wiki/unity/tools-and-rql

Machine-translated (de) from the English page: https://ai-game.dev/docs/wiki/unity/tools-and-rql