Diferenças da API C# para GDScript¶

Esta é uma lista (incompleta) de diferenças entre as APIs do C# e do GDScript.

Diferenças gerais¶

Como explicado em Noções básicas de C#, C# geralmente usa o PascalCase ao invés do snake_case usado no GDScript e C++.

Escopo global¶

Funções globais e algumas constantes tiveram que ser movidas para classes, já que o C# não permite declará-las em namespaces. A maioria das constantes globais foram movidas para seus próprios enums.

Constantes¶

As constantes globais foram movidas para seus próprios enums. Por exemplo, constantes ERR_* foram movidas para o enum Error.

Casos especiais:

GDScript	C#
`SPKEY`	`GD.SpKey`
`TYPE_*`	`Variant.Type` enum
`OP_*`	`Variant.Operator` enum

Funções matemáticas¶

Funções matemáticas globais, como abs, acos, asin, atan e atan2 estão localizadas sob Mathf como Abs, Acos, Asin, Atan and Atan2. A constante PI pode ser encontrada como Mathf.Pi.

Funções aleatórias¶

Funções globais aleatórias, como rand_range e rand_seed, estão localizadas em GD. Exemplo: GD.RandRange e GD.RandSeed.

Outras funções¶

Muitas outras funções globais como print e var2str estão localizadas em GD. Exemplo: GD.Print e GD.Var2Str.

Exceções:

GDScript	C#
`weakref(obj)`	`Object.WeakRef(obj)`
`is_instance_valid(obj)`	`Object.IsInstanceValid(obj)`

Dicas¶

Às vezes pode ser útil usar a diretiva using static. Esta diretiva permite acessar os membros e tipos aninhados de uma classe sem especificar o nome da classe.

Exemplo:

using static Godot.GD;

public class Test
{
    static Test()
    {
        Print("Hello"); // Instead of GD.Print("Hello");
    }
}

A palavra-chave Export¶

Use o atributo [Export] em vez da palavra-chave de GDScript export. Este atributo também pode ser fornecido com parâmetros opcionais PropertyHint e hintString . Os valores padrão podem ser definidos atribuindo um valor.

Exemplo:

using Godot;

public class MyNode : Node
{
    [Export]
    private NodePath _nodePath;

    [Export]
    private string _name = "default";

    [Export(PropertyHint.Range, "0,100000,1000,or_greater")]
    private int _income;

    [Export(PropertyHint.File, "*.png,*.jpg")]
    private string _icon;
}

A palavra-chave Signal¶

Utilize o atributo [Signal] para declarar um sinal em vez da palavra-chave GDScript signal. Este atributo deve ser utilizado em um `delegate', cuja assinatura de nome será utilizada para definir o sinal.

[Signal]
delegate void MySignal(string willSendsAString);

Veja também: Sinais em C#.

Palavra-chave onready¶

GDScript tem a habilidade de adiar a inicialização de uma variável de membro (member variable) até que a função _ready seja chamada com onready (cf. Palavra-chave onready). Por exemplo:

onready var my_label = get_node("MyLabel")

Contudo, o C# não possui essa funcionalidade. Para atingir o mesmo efeito, você precisa fazer isso.

private Label _myLabel;

public override void _Ready()
{
    _myLabel = GetNode<Label>("MyLabel");
}

Singletons¶

Singletons estão disponíveis como classes estáticas em vez de usar o padrão singleton. Isto é para fazer o código menos prolixo que seria com uma propriedade Instanciada.

Exemplo:

Input.IsActionPressed("ui_down")

No entanto, em alguns casos muito raros, isso não é suficiente. Por exemplo, você pode querer acessar um membro da classe base Godot.Object, como Connect. Para tais casos de uso, fornecemos uma propriedade estática chamada Singleton que retorna a instância singleton. O tipo desta instância é Godot.Object.

Exemplo:

Input.Singleton.Connect("joy_connection_changed", this, nameof(Input_JoyConnectionChanged));

String¶

Use System.String (string). Quase todos os métodos Godot String são fornecidos pela classe StringExtensions como métodos de extensão.

Exemplo:

string upper = "I LIKE SALAD FORKS";
string lower = upper.ToLower();

Existem algumas diferenças, no entanto:

erase: As strings são imutáveis em C#, portanto não podemos modificar a string passada para o método de extensão. Por esse motivo, Erase foi adicionado como um método de extensão de StringBuilder em vez de string. Alternativamente, você pode usar o string.Remove.
IsSubsequenceOf/IsSubsequenceOfi: É fornecido um método adicional, que é uma sobrecarga de IsSubsequenceOf, permitindo que você especifique explicitamente a sensibilidade ao caso:

str.IsSubsequenceOf("ok"); // Case sensitive
str.IsSubsequenceOf("ok", true); // Case sensitive
str.IsSubsequenceOfi("ok"); // Case insensitive
str.IsSubsequenceOf("ok", false); // Case insensitive

Match/ Matchn/ ExprMatch: Um método adicional é fornecido além de Match e Matchn, o que permite especificar explicitamente a distinção entre maiúsculas e minúsculas:

str.Match("*.txt"); // Case sensitive
str.ExprMatch("*.txt", true); // Case sensitive
str.Matchn("*.txt"); // Case insensitive
str.ExprMatch("*.txt", false); // Case insensitive

Base¶

Structs cannot have parameterless constructors in C#. Therefore, new Basis() initializes all primitive members to their default value. Use Basis.Identity for the equivalent of Basis() in GDScript and C++.

O método a seguir foi convertido em uma propriedade com um nome diferente:

GDScript	C#
`get_scale()`	`Scale`

Transform2D¶

Structs cannot have parameterless constructors in C#. Therefore, new Transform2D() initializes all primitive members to their default value. Please use Transform2D.Identity for the equivalent of Transform2D() in GDScript and C++.

Os seguintes métodos foram convertidos em propriedades com seus respectivos nomes alterados:

GDScript	C#
`get_rotation()`	`Rotation`
`get_scale()`	`Scale`

Plano¶

O método a seguir foi convertido em uma propriedade com um nome ligeiramente diferente:

GDScript	C#
`center()`	`Center`

Rect2¶

O campo a seguir foi convertido em uma propriedade com um nome ligeiramente diferente:

GDScript	C#
`end`	`End`

O método a seguir foi convertido em uma propriedade com um nome diferente:

GDScript	C#
`get_area()`	`Area`

Quat¶

Structs cannot have parameterless constructors in C#. Therefore, new Quat() initializes all primitive members to their default value. Please use Quat.Identity for the equivalent of Quat() in GDScript and C++.

Os seguintes métodos foram convertidos para uma propriedade com um nome diferente:

GDScript	C#
`length()`	`Length`
`length_squared()`	`LengthSquared`

Vetor¶

Isso é temporário. Os PoolArrays precisarão que seus próprios tipos sejam usados da maneira que devem ser.

GDScript	C#
`Array`	`Godot.Collections.Array`
`PoolIntArray`	`int[]`
`PoolByteArray`	`byte[]`
`PoolFloatArray`	`float[]`
`PoolStringArray`	`String[]`
`PoolColorArray`	`Color[]`
`PoolVector2Array`	`Vector2[]`
`PoolVector3Array`	`Vector3[]`

Godot.Collections.Array<T> é um wrapper de tipo seguro em torno de Godot.Collections.Array. Use o construtor Godot.Collections.Array<T>(Godot.Collections.Array) para criar um.

Dicionário¶

Use Godot.Collections.Dictionary.

Godot.Collections.Dictionary<T> é um wrapper de tipo seguro em torno de Godot.Collections.Dictionary. Use o construtor Godot.Collections.Dictionary<T>(Godot.Collections.Dictionary) para criar um.

Variante¶

System.Object (object) é usado no lugar de Variant.

Comunicando com outras linguagens de script¶

Isso é explicado extensivamente em Scripting entre linguagens.

Aguardar Retorno¶

Algo semelhante ao yield do GDScript com um único parâmetro pode ser obtido com a palavra-chave `yield <https://docs.microsoft.com/en-US/dotnet/csharp/language-reference/keywords/yield> `_ do C#.

O equivalente a yield em um sinal pode ser obtido com async/await e Godot.Object.ToSignal.

Exemplo:

await ToSignal(timer, "timeout");
GD.Print("After timeout");

Outras diferenças¶

pré-carregamento, da forma que funciona no GDScript, não está disponível em C#. Ao invés disso, use GD.Load ou ResourceLoader.Load.

Outras diferenças:

GDScript	C#
`Color8`	`Color.Color8`
`is_inf`	`float.IsInfinity`
`is_nan`	`float.IsNaN`
`dict2inst`	TODO
`inst2dict`	TODO