Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Cross-Language-Skripting

Godot erlaubt es, mehrere Skriptsprachen zu mischen, je nach Anforderung. Ein einzelnes Projekt kann somit Nodes sowohl in C# als auch in GDScript definieren. Diese Seite geht auf die möglichen Interaktionen zwischen zwei Nodes ein, die in unterschiedlichen Sprachen geschrieben wurden.

Die folgenden beiden Skripte werden durchgehend auf dieser Seite als Referenz genutzt.

extends Node

var my_property: String = "my gdscript value":
    get:
        return my_property
    set(value):
        my_property = value

signal my_signal
signal my_signal_with_params(msg: String, n: int)

func print_node_name(node: Node) -> void:
    print(node.get_name())

func print_array(arr: Array) -> void:
    for element in arr:
        print(element)

func print_n_times(msg: String, n: int) -> void:
    for i in range(n):
        print(msg)

func my_signal_handler():
    print("The signal handler was called!")

func my_signal_with_params_handler(msg: String, n: int):
    print_n_times(msg, n)

using Godot;

public partial class MyCSharpNode : Node
{
    public string MyProperty { get; set; } = "my c# value";

    [Signal] public delegate void MySignalEventHandler();
    [Signal] public delegate void MySignalWithParamsEventHandler(string msg, int n);

    public void PrintNodeName(Node node)
    {
        GD.Print(node.Name);
    }

    public void PrintArray(string[] arr)
    {
        foreach (string element in arr)
        {
            GD.Print(element);
        }
    }

    public void PrintNTimes(string msg, int n)
    {
        for (int i = 0; i < n; ++i)
        {
            GD.Print(msg);
        }
    }

    public void MySignalHandler()
    {
        GD.Print("The signal handler was called!");
    }

    public void MySignalWithParamsHandler(string msg, int n)
    {
        PrintNTimes(msg, n);
    }
}

Instanziieren von Nodes

Wenn Sie keine Nodes aus dem Szenenbaum verwenden, werden Sie wahrscheinlich Nodes direkt aus dem Code instanziieren wollen.

Instanziierung von C# Nodes aus GDScript

C# aus GDScript zu nutzen, benötigt nicht viel Aufwand. Einmal geladen (siehe Klassen als Ressourcen) kann das Skript mit new() instanziiert werden.

var MyCSharpScript = load("res://Path/To/MyCSharpNode.cs")
var my_csharp_node = MyCSharpScript.new()

Warnung

Wenn Sie .cs-Skripte erstellen, sollten Sie immer bedenken, dass die von Godot verwendete Klasse genauso benannt wird wie die .cs-Datei selbst. Wenn diese Klasse in der Datei nicht vorhanden ist, wird der folgende Fehler angezeigt: Ungültiger Aufruf. Nicht vorhandene Funktion `neu` in base.

Zum Beispiel soll MyCoolNode.cs eine Klasse namens MyCoolNode beinhalten.

Die C#-Klasse muss eine Godot-Klasse ableiten, zum Beispiel GodotObject. Andernfalls wird derselbe Fehler auftreten.

Sie müssen auch überprüfen, ob auf Ihre .cs-Datei in der .csproj-Datei des Projekts verwiesen wird. Andernfalls tritt der gleiche Fehler auf.

Instanziieren von GDScript Nodes über C#

Von der C#-Seite aus funktioniert alles auf die gleiche Art. Einmal geladen, kann das GDScript mit GDScript.New() instanziiert werden.

var myGDScript = GD.Load<GDScript>("res://path/to/my_gd_script.gd");
var myGDScriptNode = (GodotObject)myGDScript.New(); // This is a GodotObject.

Hier verwenden wir ein Object, aber Sie können die Typkonvertierung wie in Typumwandlung und Casting beschrieben verwenden.

Zugriff auf Felder

Zugriff auf C# Felder über GDScript

Der Zugriff auf C# Felder über GDScript ist unkompliziert, Sie müssen sich keine Sorgen machen.

# Output: "my c# value".
print(my_csharp_node.MyProperty)
my_csharp_node.MyProperty = "MY C# VALUE"
# Output: "MY C# VALUE".
print(my_csharp_node.MyProperty)

Zugriff auf GDScript-Felder über C#

As C# is statically typed, accessing GDScript from C# is a bit more convoluted. You will have to use GodotObject.Get() and GodotObject.Set(). The first argument is the name of the field you want to access.

// Output: "my gdscript value".
GD.Print(myGDScriptNode.Get("my_property"));
myGDScriptNode.Set("my_property", "MY GDSCRIPT VALUE");
// Output: "MY GDSCRIPT VALUE".
GD.Print(myGDScriptNode.Get("my_property"));

Keep in mind that when setting a field value you should only use types the GDScript side knows about. Essentially, you want to work with built-in types as described in Built-in-Typen or classes extending Object.

Aufruf von Methoden

Aufruf von C#-Methoden über GDScript

Auch hier sollte das Aufrufen von C#-Methoden über GDScript unkompliziert sein. Der Marshalling-Prozess wird sein Bestes tun, die Argumente so umzuwandeln, dass sie mit den Funktionssignaturen übereinstimmen. Wenn dies nicht möglich ist, wird der folgende Fehler angezeigt: Invalid call. Nonexistent function `FunctionName`.

# Output: "my_gd_script_node" (or name of node where this code is placed).
my_csharp_node.PrintNodeName(self)
# This line will fail.
# my_csharp_node.PrintNodeName()

# Outputs "Hello there!" twice, once per line.
my_csharp_node.PrintNTimes("Hello there!", 2)

# Output: "a", "b", "c" (one per line).
my_csharp_node.PrintArray(["a", "b", "c"])
# Output: "1", "2", "3"  (one per line).
my_csharp_node.PrintArray([1, 2, 3])

Aufruf von GDScript-Methoden über C#

Um GDScript-Methoden von C# aus aufzurufen, müssen Sie GodotObject.Call() verwenden. Das erste Argument ist der Name der Methode, die Sie aufrufen möchten. Die folgenden Argumente werden an diese Methode übergeben.

// Output: "MyCSharpNode" (or name of node where this code is placed).
myGDScriptNode.Call("print_node_name", this);
// This line will fail silently and won't error out.
// myGDScriptNode.Call("print_node_name");

// Outputs "Hello there!" twice, once per line.
myGDScriptNode.Call("print_n_times", "Hello there!", 2);

string[] arr = ["a", "b", "c"];
// Output: "a", "b", "c" (one per line).
myGDScriptNode.Call("print_array", arr);
// Output: "1", "2", "3"  (one per line).
myGDScriptNode.Call("print_array", new int[] { 1, 2, 3 });
// Note how the type of each array entry does not matter
// as long as it can be handled by the marshaller.

Mit Signalen verbinden

Verbinden mit C#-Signalen von GDScript aus

Die Verbindung zu einem C#-Signal aus GDScript ist die gleiche wie die Verbindung zu einem in GDScript definierten Signal:

my_csharp_node.MySignal.connect(my_signal_handler)

my_csharp_node.MySignalWithParams.connect(my_signal_with_params_handler)

Verbinden mit GDScript-Signalen von C# aus

Das Verbinden mit einem GDScript-Signal von C# aus funktioniert nur mit der Methode Connect, da es keine statischen C#-Typen für von GDScript definierte Signale gibt:

myGDScriptNode.Connect("my_signal", Callable.From(MySignalHandler));

myGDScriptNode.Connect("my_signal_with_params", Callable.From<string, int>(MySignalWithParamsHandler));

Vererbung

Eine GDScript-Datei darf nicht von einem C#-Skript erben. Genauso wenig darf ein C#-Skript von einer GDScript-Datei erben. Aufgrund der Komplexität der Implementierung ist es unwahrscheinlich, dass diese Einschränkung in Zukunft aufgehoben wird. Weitere Informationen finden Sie in dieser GitHub-Issue.