Chapitre 1 : Introduction aux Blueprints
Les Blueprints sont le système de programmation visuelle d'Unreal Engine qui permet de créer des logiques de gameplay sans avoir besoin de coder manuellement en C++. Ils permettent aux développeurs de concevoir des mécanismes complexes de manière intuitive et accessible grâce à une interface graphique, en utilisant des éléments appelés nœuds.
1.1 Présentation générale des Blueprints
Unreal Engine propose plusieurs types de Blueprints qui sont utilisés dans différents contextes :
-
Blueprints de Classe : Représentent des objets dans le jeu, comme des personnages, des ennemis, ou des objets interactifs.
-
Blueprints de Niveau : Utilisés pour gérer les éléments spécifiques à un niveau particulier, comme les objets statiques et leurs comportements.
-
Blueprints de Interface Utilisateur (UI) : Créent des éléments interactifs tels que des menus, des HUDs, des barres de vie, etc.
-
Blueprints de Fonction : Contiennent des fonctions réutilisables que l’on peut intégrer dans d’autres Blueprint ou dans un code Blueprint.
Plusieurs types de Blueprints
Les Blueprints sont une alternative puissante au code traditionnel, permettant aux designers, artistes et programmeurs de travailler en collaboration sur un même projet. Grâce aux Blueprints, des tâches qui auraient nécessité une expertise en programmation peuvent être réalisées sans connaissances approfondies du langage C++.​
1.2 Le visuel des Blueprints
Dans Unreal Engine, les Blueprints sont représentés par des graphes où les nœuds sont placés et connectés entre eux pour former un ensemble de logique de jeu. Les nœuds sont des représentations visuelles d’instructions de programmation classiques, telles que des variables, des conditions (if/else), des boucles (for, while), des actions, etc.
​
Les nœuds peuvent être organisés en groupes logiques appelés fonctions ou événements. Ces événements, tels que "Begin Play", "Tick" ou des événements personnalisés, déterminent ce qui se passe à un moment donné dans le jeu, par exemple, au démarrage du jeu ou lorsque l’acteur interagit avec un objet.
Le Graph, l'endroit ou l'on place les Nodes.
Les Nodes (nœuds), les instructions à suivre.
Les Fonctions, une suite logique de Nodes exécutant une tâche.
Les Events (évènements), les Nodes qui déclenchent un code.
Si l'on devait résumer simplement, le Graph est votre terrain de jeu.
​
Les nodes représentent les instructions que l'ordinateur va suivre, comme ouvrir le niveau 2, faire apparaître une voiture, ou afficher le menu des options.
​
Les fonctions, quant à elles, sont des suites logiques de nodes qui exécutent des tâches spécifiques et peuvent être appelées à tout moment. Par exemple, la fonction "OuvrirPorte" est appelée chaque fois que votre personnage ouvre une porte. À l'intérieur de cette fonction, on trouve une série de nodes qui gèrent des éléments comme les animations à lancer ou les menus à afficher, le tout pendant que l'ouverture de la porte est en cours d'exécution.
​
Enfin, les events (ou événements) sont des nodes qui attendent qu'une action spécifique se produise pour exécuter le code qui leur est associé. Par exemple, l'event "BeginPlay" (Commencer à jouer) déclenche son code dès que le jeu démarre. De même, l'event "BeginOverlap" (Commencer à traverser) s'exécute uniquement lorsqu'un objet entre en collision avec un autre type d'objet (configurable), mais pas avant.
1.3 Les différents types de nœuds dans un Blueprint
Les nœuds peuvent être regroupés en plusieurs catégories en fonction de leur fonction dans la logique de jeu. Voici les principaux types de nœuds :
-
Nœuds d’action : Ce sont des nœuds qui effectuent des actions dans le jeu, par exemple, "Print String" (afficher un message), "Set Actor Location" (déplacer un objet) ou "Play Sound" (jouer un son).
-
Nœuds de condition : Ces nœuds vérifient une condition et exécutent des actions en fonction du résultat. Un exemple classique est le nœud "Branch" (si/else), qui choisit entre deux chemins en fonction d’une condition booléenne.
-
Nœuds de variable : Les nœuds de variable vous permettent de stocker et de manipuler des données dans vos Blueprints. Vous pouvez avoir des variables de type entier (int), flottant (float), booléen (bool), chaîne de texte (string), ou des types plus complexes comme des vecteurs, des objets, ou des tableaux.
-
Nœuds de fonction : Ils représentent des morceaux de logique réutilisables. Vous pouvez créer des fonctions personnalisées pour organiser votre code Blueprint de manière plus propre et logique.
-
Nœuds d’événements : Ces nœuds sont déclenchés par des événements dans le jeu, comme "Event Begin Play", "Event Tick" ou des événements créés manuellement. Ils sont essentiels pour initier ou gérer des actions tout au long du jeu.
Exemple d'Algorythme Blueprints (Fictif)
Pour illustrer ces concepts, voici une image explicative. Sur le Graph ci-dessus, nous voyons deux nodes : "EventTick" et "ControleDeConduite", le script se lis de gauche à droite.
​
L'EventTick est un événement qui exécute le code à chaque "tick", c’est-à-dire à chaque rafraîchissement du jeu. On peut simplifier cela en le comparant aux FPS (images par seconde) de votre jeu. Concrètement, si votre jeu fonctionne à 60 FPS, l'EventTick exécutera le code 60 fois par seconde ! (Autant dire qu’il est très rapide !)
​
Ensuite, nous avons la fonction "ControleDeConduite", qui est appelée 60 fois par seconde si votre jeu tourne à 60 FPS. Jusqu’ici, rien de surprenant. Maintenant, examinons ce qui se passe à l’intérieur de cette fonction !
Nous observons ici que l'algorithme commence par un node violet, qui représente le point de départ de la fonction.
​
Le node "Branch" vérifie à chaque exécution (donc 60 fois par seconde dans notre exemple) si la variable "Accident?" est vraie ou fausse. Par défaut, cette variable est définie sur False (faux), ce qui signifie que la fonction continuera en exécutant une autre fonction appelée "Continuer", permettant au joueur de jouer normalement. (Ces fonctions sont fictives et servent uniquement d'exemple.)
​
Imaginons que cet algorithme provienne d’un jeu de course automobile, et qu’il ait pour rôle de vérifier si le joueur a eu un accident. Lorsque cela se produit, la variable rouge "Accident?" passe à True (vrai), déclenchée par un autre algorithme, et le Branch exécute alors ce qui se trouve sur sa branche True : une fonction dédiée à jouer une animation d'accident.
​
Une fois cette animation exécutée, un autre Branch vérifie la condition stockée dans la variable rouge "PersonnageEnVie?". Supposons que la fonction "Animationd'Accident" inflige des dégâts au joueur. Lorsque la vie du joueur atteint 0, un algorithme définit la variable "PersonnageEnVie?" sur False (faux).
​
Ainsi, si cette variable est True (le joueur est encore en vie), il peut continuer à jouer. Cependant, si la variable est False (le joueur n’a plus de vie), le Branch exécute alors la fonction "Recommencer", qui peut, par exemple, afficher un message demandant au joueur de redémarrer le niveau.
​
Encore une fois, cet algorithme est totalement fictif, mais il illustre bien la logique de programmation en Blueprints, qui s’effectue toujours de gauche à droite.
Prochain chapitre :
Sommaire de la formation :
Chapitre 1 : Introduction aux Blueprints
Présentation du code Blueprint et de son fonctionnement
Chapitre 2 : Les types de variables en Blueprint
Les different types de variables en Blueprints