Optimisation Godot GDScript
Optimisation Godot GDScript
Les 10 meilleurs conseils GDScript pour les performances
GDScript est un langage de programmation puissant et facile à utiliser, bien adapté à la création de jeux avec le moteur de jeu Godot. Cependant, comme pour tout langage, il est important d’optimiser votre code pour vous assurer qu’il s’exécute de manière fluide et efficace.
Dans cet article, nous partagerons les 10 meilleurs conseils GDScript pour améliorer les performances de vos jeux et applications.
1. Stockez les données à l’aide de dictionnaires et de tableaux au lieu de nœuds
Le stockage de données dans des nœuds peut être inefficace, car il nécessite la création d’un nouvel objet pour chaque élément de données. Cela peut ralentir les performances, en particulier si vous devez stocker une grande quantité de données. Envisagez plutôt d’utiliser des dictionnaires et des tableaux pour stocker les données. Les dictionnaires sont des paires clé-valeur qui vous permettent d’accéder aux données à l’aide d’une clé unique, tandis que les tableaux sont des listes ordonnées de données auxquelles vous pouvez accéder à l’aide d’un index. Les dictionnaires et les tableaux sont plus rapides et plus efficaces que les nœuds, et ils vous permettent d’accéder aux données et de les manipuler sans la surcharge de la création d’objets.
Par exemple, supposons que vous ayez besoin de stocker une liste des meilleurs scores pour un jeu. À l’aide de nœuds, vous pouvez créer un nœud « HighScore » pour chaque score et le stocker dans un nœud « HighScores ». Cependant, cela créerait un nouvel objet pour chaque partition, ce qui pourrait être lent si vous avez un grand nombre de partitions. Au lieu de cela, vous pouvez utiliser un tableau pour stocker les scores et y accéder à l’aide d’un index. Ce serait plus rapide et plus efficace, car vous n’auriez besoin de créer qu’un seul objet pour le tableau, plutôt qu’un objet pour chaque score.
2. Évitez d’utiliser des getters et des setters
Les getters et les setters sont utilisés pour accéder et modifier les propriétés des objets dans GDScript. Un getter est une fonction qui est appelée lorsque vous accédez à une propriété, tandis qu’un setter est une fonction qui est appelée lorsque vous modifiez une propriété. Bien que les getters et les setters puissent être utiles dans certains cas, ils peuvent également être lents, car ils nécessitent un appel de fonction supplémentaire chaque fois qu’une propriété est consultée ou modifiée. Cela peut ralentir les performances, en particulier si vous accédez ou modifiez fréquemment des propriétés.
Pour améliorer les performances, envisagez d’éviter les getters et les setters et d’accéder directement aux propriétés à la place. Par exemple, supposons que vous ayez une propriété « Santé » à laquelle vous souhaitez accéder et que vous souhaitez modifier dans votre jeu. Plutôt que d’utiliser un getter et un setter, vous pouvez simplement accéder directement à la propriété, comme ceci :
# Access the property directly var current_health = player.health # Modify the property directly player.health = current_health - 10
En accédant directement aux propriétés, vous pouvez éviter la surcharge des appels de fonction et améliorer les performances.
(Remarque : il est généralement recommandé d’utiliser des getters et des setters pour les propriétés qui nécessitent un traitement supplémentaire)
3. Utiliser la mise en commun d’objets
La mise en commun d’objets est une technique qui consiste à réutiliser des objets plutôt que de les créer et de les détruire constamment. Cela peut être particulièrement utile dans GDScript lorsque vous travaillez avec un grand nombre d’objets fréquemment créés et détruits, tels que des balles dans un jeu ou des particules dans un système de particules.
En regroupant des objets, vous pouvez réduire la surcharge liée à la création et à la destruction constantes d’objets, ce qui peut améliorer les performances de votre script. Pour implémenter le regroupement d’objets dans GDScript, vous pouvez créer un pool d’objets qui ne sont pas utilisés, puis réutiliser ces objets lorsque vous en avez besoin au lieu d’en créer de nouveaux. Lorsque vous avez terminé avec un objet, vous pouvez le remettre dans le pool pour le réutiliser ultérieurement. Cela peut aider à réduire le nombre d’objets qui doivent être créés et détruits, ce qui peut améliorer les performances de votre script.
Voici un exemple d’utilisation du regroupement d’objets dans GDScript :
# A simple object pool for bullet objects
const POOL_SIZE = 100
var bullet_pool = []
func get_bullet():
if bullet_pool.empty():
return Bullet.new()
else:
return bullet_pool.pop_back()
func return_bullet(bullet):
bullet_pool.push_back(bullet)
# To use the bullet pool:
# Get a bullet from the pool
var bullet = get_bullet()
# Use the bullet
# Return the bullet to the pool when you are finished with it
return_bullet(bullet)
En utilisant le regroupement d’objets de cette manière, vous pouvez réduire les frais généraux liés à la création et à la destruction constantes d’objets puces et améliorer les performances de votre script.
4. Évitez d’utiliser des variables globales
Les variables globales sont des variables disponibles pour tous les objets du jeu. Bien qu’ils puissent être pratiques, ils peuvent également être lents, car ils nécessitent une recherche supplémentaire à chaque accès. Cela peut ralentir les performances, en particulier si vous accédez fréquemment aux variables globales. Pour améliorer les performances, envisagez d’éviter les variables globales et d’utiliser à la place des variables locales.
Les variables locales sont des variables définies dans une fonction ou un bloc de code et ne sont disponibles que dans cette portée. Elles sont plus rapides que les variables globales, car elles ne nécessitent pas de recherche supplémentaire lors de l’accès. Par exemple:
# Define a local variable func some_function(): var local_var = 10 # Access the local variable print(local_var)
En utilisant des variables locales, vous pouvez éviter la surcharge des recherches de variables globales et améliorer les performances.
5. Utilisez des fonctions statiques
Les fonctions statiques sont des fonctions associées à une classe, plutôt qu’à une instance de la classe. Elles peuvent être plus rapides que les fonctions non statiques, car elles ne nécessitent pas la surcharge de la création d’objets. Pour utiliser des fonctions statiques, préfixez simplement la fonction avec le mot-clé « static ».
Par exemple, supposons que vous ayez une classe « Player » qui a une propriété « health » et une fonction « take_damage ». Pour créer ces fonctions, vous pouvez procéder comme suit :
extends Node # Declare a static function static func take_damage(amount: int): # Declare a static variable var max_health : int = 100 max_health -= amount
En utilisant des fonctions et des variables statiques, vous pouvez éviter la surcharge liée à la création d’objets et améliorer les performances.
6. Utilisez C # ou C ++ pour le code critique pour les performances
Bien que GDScript soit un langage puissant et facile à utiliser, il n’est pas toujours l’option la plus rapide pour le code critique pour les performances. Si vous avez besoin d’optimiser des fonctions ou des algorithmes spécifiques, envisagez d’utiliser C# ou C++ à la place. Les deux langages peuvent être utilisés avec le moteur Godot, et ils offrent plus de contrôle et de performances que GDScript.
Pour utiliser C# ou C++ avec le moteur Godot, vous devrez installer le support de langage approprié et créer un nouveau script C# ou C++. Ensuite, vous pouvez définir des fonctions et des variables dans le script et les appeler depuis GDScript. Voici un exemple d’appel d’une fonction C# depuis GDScript :
# Call a C# function my_cs_script.some_function()
En utilisant C# ou C++ pour le code critique pour les performances, vous pouvez tirer parti des performances et du contrôle offerts par ces langages et optimiser des fonctions ou des algorithmes spécifiques dans votre jeu.
7. Optimiser les boucles
Les boucles sont une source courante de goulots d’étranglement des performances dans le code GDScript. Pour optimiser les boucles, pensez à utiliser la boucle « for » au lieu de la boucle « while », car elle est généralement plus rapide. Vous pouvez également améliorer les performances en pré-allouant des tableaux, en utilisant judicieusement les instructions « continue » et « break » et en minimisant le nombre d’itérations.
Par exemple, supposons que vous ayez une boucle « while » qui itère sur une liste d’éléments :
# Define a list of items var items = [1, 2, 3, 4, 5] # Iterate over the list with a "while" loop var i = 0 while i < items.size(): # Do something with the item print(items[i]) # Increment the counter i += 1
Pour optimiser cette boucle, vous pouvez utiliser une boucle "for" à la place, comme ceci :
# Iterate over the list with a "for" loop for item in items: # Do something with the item print(item)
La boucle "for" est généralement plus rapide que la boucle "while", car elle évite la surcharge liée à l'incrémentation d'un compteur.
Vous pouvez également améliorer les performances en pré-allouant des tableaux, ce qui signifie créer un tableau avec une taille fixe, puis ajouter ou supprimer des éléments selon les besoins. Cela peut être plus rapide que de créer un tableau puis de le développer dynamiquement, car cela évite la surcharge liée au redimensionnement du tableau.
Enfin, vous pouvez améliorer les performances en utilisant judicieusement les instructions "continue" et "break". L'instruction "continue" saute le reste de l'itération actuelle de la boucle et passe à l'itération suivante, tandis que l'instruction "break" quitte complètement la boucle. En utilisant ces instructions de manière appropriée, vous pouvez réduire le nombre d'itérations et améliorer les performances.
8. Utilisez des conseils de type
Les indications de type sont un moyen de spécifier le type de données d'une variable dans GDScript. En utilisant des indications de type, vous pouvez aider le moteur Godot à optimiser le code et à améliorer les performances. Pour utiliser les indications de type, spécifiez simplement le type de données d'une variable lorsque vous la déclarez, comme ceci :
# Utiliser un indice de type pour spécifier le type de données d'une variable
var mon_int : int = 0
Les indications de type sont facultatives dans GDScript, mais elles peuvent être utiles pour améliorer les performances, car elles permettent au moteur Godot d'optimiser le code plus efficacement.
Par exemple, supposons que vous ayez une fonction qui calcule la moyenne d'une liste de nombres. Sans les indications de type, la fonction pourrait ressembler à ceci :
# Use a type hint to specify the data type of a variable var my_int: int = 0
Les indications de type sont facultatives dans GDScript, mais elles peuvent être utiles pour améliorer les performances, car elles permettent au moteur Godot d'optimiser le code plus efficacement.
Par exemple, supposons que vous ayez une fonction qui calcule la moyenne d'une liste de nombres. Sans les indications de type, la fonction pourrait ressembler à ceci :
# Calculate the average without type hints func calculate_average(numbers: Array): var sum = 0 for number in numbers: sum += number return sum / numbers.size()
Cette fonction fonctionne bien, mais elle n'est peut-être pas aussi efficace qu'elle pourrait l'être. En utilisant des indications de type, vous pouvez aider le moteur Godot à optimiser le code et à améliorer les performances. Voici la même fonction avec des indications de type :
# Calculate the average with type hints func calculate_average(numbers: Array[int]): var sum: int = 0 for number in numbers: sum += number return sum / numbers.size()
En spécifiant les types de données des variables "somme" et "nombre", vous pouvez aider le moteur Godot à optimiser le code et à améliorer les performances.
9. Utilisez le profileur Godot
Le profileur Godot est un outil qui vous permet d'analyser les performances de votre code GDScript et d'identifier les goulots d'étranglement. Pour utiliser le profileur, lancez simplement votre jeu ou votre application dans l'éditeur Godot, puis ouvrez la fenêtre du profileur. Le profileur vous montrera une répartition du temps et des ressources utilisées par différentes parties de votre code, vous permettant d'identifier les zones susceptibles de provoquer des ralentissements.
Par exemple, le profileur peut vous indiquer qu'une fonction particulière prend beaucoup de temps à s'exécuter ou qu'un objet spécifique utilise beaucoup de mémoire. En analysant les données du profileur, vous pouvez identifier les causes profondes des problèmes de performances et prendre des mesures pour optimiser votre code.
Pour optimiser votre code en fonction des données du profileur, vous pouvez essayer diverses techniques telles que l'optimisation des boucles, la réduction du nombre d'appels de fonction ou l'utilisation de structures de données plus efficaces. Vous pouvez également essayer de profiler différentes parties de votre code pour voir comment elles se comparent en termes de performances.
10. Utiliser le multithreading
Le multithreading est un moyen de permettre à un programme d'exécuter plusieurs tâches simultanément, en tirant parti de plusieurs cœurs de processeur. Dans GDScript, vous pouvez utiliser la classe "Thread" pour créer et gérer des threads. Pour utiliser le multithreading, créez une nouvelle classe qui étend "Thread" et définissez une fonction "_thread_func" qui contient le code que vous souhaitez exécuter dans le thread. Ensuite, créez une instance de la classe et appelez la fonction "start" pour démarrer le thread.
Voici un exemple d'utilisation du multithreading dans GDScript :
extends Thread
func _thread_func():
# Code to run in the thread goes here
print("Thread running!")
# Create an instance of the thread class
var my_thread = MyThread.new()
# Start the thread
my_thread.start()
Le multithreading peut être un outil puissant pour améliorer les performances des tâches gourmandes en CPU ou qui nécessitent beaucoup de traitement de données, telles que le chargement de données ou l'exécution de calculs complexes. En exécutant ces tâches dans des threads séparés, vous pouvez tirer parti de plusieurs cœurs de processeur et améliorer les performances.
Conclusion
En conclusion, voici les 10 meilleurs conseils GDScript pour améliorer les performances de vos jeux et applications. En suivant ces meilleures pratiques et techniques, vous pouvez optimiser votre code et vous assurer qu'il s'exécute de manière fluide et efficace.
Il convient de noter que l'optimisation du code peut être une tâche complexe et chronophage, et qu'elle n'est pas toujours nécessaire, selon les exigences spécifiques de votre projet. Cependant, en suivant ces conseils et en utilisant des outils comme le profileur Godot, vous pouvez vous assurer que votre code GDScript est aussi efficace que possible et éviter les goulots d'étranglement des performances.
Ce contenu est exact et fidèle au meilleur de la connaissance de l'auteur et ne vise pas à remplacer les conseils formels et individualisés d'un professionnel qualifié.
© 2022 Michael McGuire
