Godot

1. GDSCript

Moteur de jeu libre. Il peut être utilisé avec du GDScript, du C++ ou du C#.

Article sur la lenteur de l'API C# de Godot (il y a eu une réponse d'un développeur).

1. GDSCript

Similaire à du Python.

1.1. Commentaires

Comme en Python: # ou """ """.

1.2. Types

Les variables sont typées:

string
int
float
boolean
null

Possibilité de check un type avec le mot clé is.

# Commentaire
var test: int = 1
var pouet: String = "pouet"
var toto := 201.1
var num: int = '10' as int

Il est orienté objet, avec des classes. On peut caster des sous-types de classe. Par ex., Sprite dans un Node2D (Sprite sous-type de Node2D). Tout est objet, même les int ou les tableaux.

1.2.1. Booléens

On peut utiliser 0 ou false, ou alors 1 ou true. Il est aussi possible d'utiliser des mots pour les opérations logiques:

&& ou and
|| ou or
! ou not

1.2.2. Tableau

Commence à 0, on peut utiliser -1 pour récupérer le dernier élément. Il peut contenir différents types de données en même temps.

Fonctions pour pousser ou poper des éléments:

push_front()
push_back()
pop_front()
pop_back()

On peut le redimensionner à la volée:

resize() : on peut aussi le clear en mettant en paramètre 0

Pour faire une deep copy ou une shallow copy:

duplicate(boolean) : true pour deep et false pour shallow
- shallow : ne copie pas les tableaux dans les tableaux, juste une copie en surface (exactement le premier tableau, avec les adresses mémoires
- deep : copie même les tableaux dans les tableaux

Par défaut, un tableau assigné à un tableau ne copie rien, les variables ont la même adresse vers le tableau.

Une String est un tableau.

1.2.3. Dictionnaire

Il est possible de mettre différentes types de clés et de valeurs dans un dictionnaire.

2 façons de mettre une clé:

var dic = {"test": 1}
dic.pouet = 2
dic["toto"] = 3

erase("key") : suprime un élément du dico

1.2.4. Enumération

enum Test {toto, tata}

Test.toto

enum Pouet{toto = 5, tata} # tata = 6

1.2.5. Contantes

On utilise juste le mot const au lieu de var. La convention veut que l'on mette la première lettre en majuscule dans le nom.

1.2.6. Conventions de nommage

camelCase pour les fonctions et les variables
CONSTANTE en majuscule
PascalCase pour les classes

1.2.7. Classe

Tout fichier GDScript est une classe non nommée.

Toute variable dans ce ficher est un attribut de la classe. On peut les afficher dans l'éditeur Godot avec le mot clé @export. Il est possible d'indiquer les valeurs attendues : @export(int, "Up", "Down") var unInt = Up. La valeur par défaut est 0. Avec un enum : enum UNENUM { UN, DEUX }; @export(UNENUM) var unEnum. @export(type, max) ou @export(type, min, max). (Color, RGB/RGBA).

Pour les setter et getter: rajouter à la fin setget setFunc, getFunc, et ne pas oublier de coder le setter et le getter. Il est possible de ne mettre qu'un getter ou un setter. Ces fonctions sont activées toutes seules lorsqu'on manipule l'attribut de la classe; pas besoin de l'utiliser directement (objet.attribut revient à object.get(). L'utilisation du mot clé self sur les attributs appellent automatiquement les setter et getter selon le contexte.

Pas possible de faire des attributs privés.

res:// indique qu'on souhaite accéder au chemin global vers notre projet.

On peut hériter d'une classe avec le mot clé extends.

Pour nommer une classe: class_name Name. Il est possible de rajouter une image à la classe avec class_name Name , "res://pic.png".

Fonction statique : pas besoin d'instancier un objet.

Méthode virtuelle : commence par un _.

Classe interne: class Nom:.

Instanciation avec la fonction new(). Possibilité de charger une variable sans nom, à partir d'un fichier:

var loaded = load("res://file.gd")
var object = loaded.new()

Constructeur: _init().

Une sous classe peut utiliser le constructeur de sa classe héritée:

func _init().('Param'):
    pass
func _init(value).(value):
    pass

Possible de caster des sous classes dans les classes héritées.

Gestion de la mémoire

Pas de garbage collector, il faut le faire soi-même à la main avec la fonction free().

Pour la classe Node, la fonction queue_free() est utile pour optimisé la suppression de ses enfants.

1.3. Conditions

Comme en Python: if, elif et else. Idem pour while ou for pour les boucles.

Dans les boucles for, si on utilise un dictionnaire, la boucle va se faire sur les clés.

if true:
   var x = 1
elif false:
   var y = 1
else:
   var t = 1

for i in 10:
   t = i

On peut aussi utilise le mot match pour faire un switch case. _ match tout, c'est le cas par défaut. Le match se fait par ordre chronologique, il faut donc le mettre à la fin du match. On peut utiliser continue pour tester le prochain pattern.

On peut l'utiliser sur:

constant
variable
wildecard
binding : assigner dans une nouvelle variable le test
array : la taille est vérifiée en premier. il faut utiliser .. dans le patterne pour ne pas se cantonner à ce check. _ peut être utilisé pour match n'importe quoi.
dictionnary : idem que les tableaux
multiple : plusieurs en même temps

var x: int = 10

match x:
    1:
          print()
          continue
    2:
          print()
    3,4,5:
          print()
    [1, 2, _, var quatrieme, ..]:
          print(quatrieme)
    {"cle": "valeur", ..}:
          print("coucou")
    _:
          print("Test par défaut")

1.4. Fonctions

Orienté object -> toujours dans une classe

Le niveau de scope : local > classe > globale

func name() -> int:
    return 1

func pouet(param: int, default_val := 10, default_val_long: int = 10) -> void:
    pass

func prout():
    pass

1.5. Signaux

Les classes peuvent envoyer des signaux pour interagir avec d'autres classes. Elles ne connaissent pas les classes qui observent les signaux, ni celles qui les envoient, elles s'occupent de les traiter.

Exemple: les points de vies sont une classe, elle reçoit un signal quand le joueur se fait toucher.

Il faut hériter de la classe Object.

# émetteur ou classe Player
signal monSignel (param1)
signal deuxSignal

emit_signal("monSignel", param1)
emit_signal("deuxSignal", param1)

# observeur

# le onready permet d'y accéder dans le _ready
onready var PlayerNode = get_node("Player")
PlayerNode.connect("monSignel", self, "uneFunc")
PlayerNode.disconnect("monSignel", self, "uneFunc")

func uneFunc(param1):

1.6. Coroutines

yield() dans la fonction à suspendre, resume() pour reprendre.

z = myFunc()
z.resume()

func myFunc():
    var test = 1
    yield()
    test = 2

Il est possible de passer des informations lorsqu'on résume la fonction.

z = myFunc()
z.resume(10)

func myFunc():
    var test = 1
    var x = yield()
    test = 2

Il est aussi possible de lier l'arrêt à un signal pour reprendre quand on reçoit le signal : yield(get_node(...), "Signal")

1.7. Threads

Il faut créer un objet avec Thread.new() puis le lancer avec start(player, "func", param1, param2, Priority. La priorité peut être:

PRIORITY_LOW
PRIORITY_NORMAL
PRIORITY_HIGH

On attend la fin d'exécution d'un thread avec wait_to_finish. Elle retourne la valeur de retour de la fonction du thread.