🧾 Les bases du scripting

Lien vers la documentation

Comme expliqué en introduction, nous allons utiliser le langage GDScript intégré à Godot.

Le GDScript est un langage dynamique orienté objet, à la syntaxe similaire à Python. Le langage est étroitement intégré au moteur, le rendant particulièrement agréable à utiliser.

Variables

Une variable est déclarée suivant la structure suivante :

var <nom_de_la_variable>: <type_de_la_variable> = <valeur_par_défaut>

var direction: Vector2 = Vector2(1, 0)

const MAX_SPEED: float = 300.0

Types de base

Chaque valeur a un type. En voici quelque uns :

• int : un nombre entier (3, -10, 0)
• float : un nombre à virgule (3.14, -0.5)
• String : un texte, entre guillemets ("Bonjour")
• bool : une valeur vraie ou fausse (true ou false)
• Vector2 : une vecteur à deux dimensions ((x, y))

var lives: int = 3
var speed: float = 4.5
var player_name: String = "Noé"
var is_alive: bool = true
var direction: Vector2 = Vector2(1, 0)

Commentaires et affichage

Un commentaire est une ligne de texte ignorée par Godot, qui sert à expliquer le code. Il commence par # :

# <texte_du_commentaire>

La fonction print() affiche une valeur dans la console de Godot. C’est le moyen le plus simple de vérifier ce que fait son code :

print(<valeur>)

# Ceci est un commentaire, il n'est pas exécuté
print("Hello World!") # Affiche Hello World! dans la console
print(42) # Affiche 42

Instructions conditionnelles

Une instruction conditionnelle permet d’exécuter du code uniquement si une condition est vraie. Elle est déclarée suivant la structure suivante :

if <condition>:
    <instructions>
elif <autre_condition>:
    <instructions>
else:
    <instructions>

Les blocs elif et else sont optionnels. Dès qu’une condition est vraie, son bloc est exécuté et les suivants sont ignorés.

Une condition peut utiliser les comparaisons ==, !=, <, >, <=, >= et être combinée avec and, or et not.

if score > high_score and not is_in_godmode:
    score = high_score
    print("Bravo!")

if result >= 0.5:
    print("This is great!")
elif result >= 0.25:
    print("Things are going sideways...")
else:
    print("We are doomed!")

Boucles

Une boucle permet de répéter des instructions plusieurs fois.

Boucle for

Une boucle for répète des instructions pour chaque élément d’une séquence. Elle est déclarée suivant la structure suivante :

for <nom_de_l_élément> in <séquence>:
    <instructions>

La séquence peut être un tableau, ou range(n) pour répéter n fois (de 0 à n - 1).

for i in range(10):
    print(i)

var liste: Array[String] = ["Rubika", "Game", "Programming"]
for mot in liste:
    print(mot)

Boucle while

Une boucle while répète des instructions tant qu’une condition est vraie. Elle est déclarée suivant la structure suivante :

while <condition>:
    <instructions>

Attention : si la condition ne devient jamais fausse, la boucle ne s’arrête jamais et le jeu se fige.

var counter: int = 0
while counter < 10:
    print(counter)
    counter += 1

Fonctions

Une fonction est un bloc de code réutilisable que l’on peut appeler quand on en a besoin. Elle est déclarée suivant la structure suivante :

func <nom_de_la_fonction>(<nom_du_paramètre>: <type_du_paramètre>) -> <type_de_retour>:
    <instructions>
    return <valeur_retournée>

Une fonction peut avoir zéro, un ou plusieurs paramètres (les informations qu’elle reçoit). Si elle ne retourne rien, son type de retour est void et le return est omis.

func get_welcome_prompt() -> String:
    return "WELCOME $> "

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

Structures de données

Une structure de données permet de ranger plusieurs valeurs dans une seule variable. Il en existe deux principales : les tableaux et les dictionnaires.

Tableaux

Un tableau (Array) est une liste ordonnée de valeurs. Chaque valeur est accessible grâce à sa position, appelée indice, qui commence à 0. Un tableau est déclaré suivant la structure suivante :

var <nom_du_tableau>: Array[<type_des_éléments>] = [<élément_1>, <élément_2>, ...]

Le type est optionnel : sans type, un tableau peut contenir des valeurs de types différents. On accède à un élément avec <nom_du_tableau>[<indice>], et on ajoute un élément à la fin avec append().

var tableau_mixte = ["Godot", 4.2, true]
var tableau_type: Array[int] = [2, 0, 2]
tableau_type.append(5)
print(tableau_mixte[1]) # affiche 4.2
print(tableau_type) # Affiche [2, 0, 2, 5]

Dictionnaires

Un dictionnaire (Dictionary) est un ensemble de paires clé / valeur. Au lieu d’accéder à une valeur par sa position, on y accède grâce à sa clé. Un dictionnaire est déclaré suivant la structure suivante :

var <nom_du_dictionnaire>: Dictionary[<type_des_clés>, <type_des_valeurs>] = {
    <clé_1>: <valeur_1>,
    <clé_2>: <valeur_2>
}

Le type est optionnel : sans type, les clés et les valeurs peuvent être de types différents. On accède à une valeur avec <nom_du_dictionnaire>[<clé>].

var bazar = {
    "key": 3629,
    5: "le nombre cinq",
    "tableau": [1,2,3,4]
}
var descriptions: Dictionary[String, String] = {
    "sword" : "Awesome combat sword",
    "shield" : "Rusty useless shield",
    "coffee" : "COFFEE? WHERE? I NEED IT."
}
print(descriptions["sword"]) # affiche Awesome combat sword