• Introduction
• Introduction
• Pourquoi utiliser le Blender Game Engine ?
• Spécificités du Game Engine dans Blender
• Notions de Game Design
• Bien préparer son projet
• Créer son premier jeu
• Description du jeu
• Déplacer le personnage
• Collisions
• Compter et afficher le score
• Quitter le jeu
• Remplacer les primitives par des ressources
• Partager son jeu
• Développer l'univers du jeu
• Lumières et ombres
• Introduction aux matériaux et textures
• Matériaux et textures avancés
• Matériaux dynamiques et textures animées
• Ajouter du son
• Filtres de rendu
• Comportement des objets et personnages
• Définir les caractéristiques du monde
• Le comportement des objets de notre monde
• Des personnages au bon comportement
• Des animations dans notre jeu
• Animer des personnages dans le Game Engine
• Inversion de cinématique dans le Game Engine
• Génération d'objets
• Recherche de chemin automatique
• Développer l'ergonomie
• Gérer les périphériques
• Gestion de scène
• Réaliser un menu
• Logique de jeu
• Comprendre les briques logiques
• Point de vue du joueur
• Afficher plusieurs points de vue
• Travailler le rendu du jeu
• Ignorer les objets hors champs
• Pré-calcul des textures et de la lumière
• Programmer une surcouche graphique
• Annexes
• Glossaire
• À propos
• Ressources

Déplacer le personnage

Pour notre jeu, nous avons créé une pièce, représentée par cinq grands cubes orangés et un petit cube bleu pour notre personnage. Une vidéo, 01a_preparation-deplacements.webm, résume le processus de fabrication de cette scène.

Lorsque notre personnage est sélectionné, nous pouvons alors passer dans l'éditeur Logic Editor pour lui attacher des actions. C'est dans le Logic Editor que nous allons lier des événements-clavier, comme le fait d'appuyer sur la flèche vers le haut pour activer le déplacement vers l'avant du personnage.

Introduction au Logic Editor

Dans le Logic Editor, il y a trois colonnes :

• La colonne de gauche, concerne les sensors, c'est-à-dire tout ce qui détecte et déclenche une action. Par exemple, le fait que le joueur appuie sur une touche du clavier, bouge la souris ou utilise une manette, mais également quand un personnage du jeu cogne un objet ou quand le scénario du jeu requière le déclenchement d'un événement.
• La colonne de droite, appelée actuators, s'occupe d'activer les événements dans le jeu. Comme changer de scène, déplacer un objet, lancer une animation, modifier certaines propriétés du jeu, etc.
• La colonne du milieu, les controllers, détermine comment lier les déclencheurs (les sensors) et les activateurs d’événements (lesactuators). Par exemple, lorsque mon personnage cogne un objet (sensor), cela lance l'animation d'un personnage (actuator). Il faut donc lier une brique sensor qui détecte la collision avec une brique actuator qui lance l'animation via une brique controller.

Créer les trois premières logic bricks

Nous allons donc créer notre toute première logique de jeu !

Récupérer la frappe au clavier

Pour faire avancer notre personnage, nous allons d'abord créer un sensor de type clavier.

1. Pour cela, appuyons sur le bouton Add Sensor et choisissons l'option Keyboard.
2. Dans ce sensor nouvellement créé, il y a une option appelée Key avec un bouton vide et un bouton All Keys. Cliquons sur le bouton vide et ensuite sur la flèche vers le haut. Le bouton s'appelle maintenant Up Arrow pour bien montrer que c'est lorsque le joueur appuiera sur cette touche du clavier que le sensor sera activé.

Activer un déplacement d'objet

Nous ajoutons ensuite dans la colonne de droite, un actuator qui va effectivement déplacer notre personnage vers l'avant.

1. En cliquant sur Add Actuator et en choisissant l'option Motion, nous créons cet actuator de déplacement, qui par défaut se trouve en Simple Motion, ce qui nous convient pour cet exercice.
2. Les deux lignes suivantes représentent les valeurs en x, y et z qui seront ajoutés à la position (Loc) ou à la rotation (Rot) du personnage dans l'espace lorsque cet actuator sera activé. En valeur dey, nous allons entrer 0.10, ce qui correspond à un déplacement d'un dixième d'unité Blender.

Lier frappe au clavier et déplacement d'objet

Nous allons maintenant lier l'appui sur la flèche vers le haut avec le déplacement dans l'espace. Pour cela, nous utilisons un contrôleur (controller). Les contrôleurs peuvent être de types différents, et vérifient que tout ce qui leur est envoyé en entrée (venant de la colonne de gauche) est actif avant d'activer sa sortie (tout ce qui se trouve en colonne de droite).

1. Dans la colonne du milieu, nous cliquons sur Add Controller et choisissons l'option And.
2. Dans notre cas, nous lions la sortie de sensor keyboard avec ce controller And en cliquant et glissant un lien entre la sortie du sensor et l'entrée du controller à l'aide des petits points situés à droite du premier et à gauche du second. Le lien entre les deux sera ensuite représenté par une ligne liant les deux éléments (voir capture d'écran).
3. Ensuite, nous lions, de la même manière, la sortie du controller Andavec l'entrée de l'actuator Motion.

Tester le déplacement dans le jeu

Nous pouvons maintenant vérifier que notre personnage avance bien comme on le désire en lançant une pré-visualisation du jeu.

Le meilleur affichage de la vue pour le Game Engine est texturé. selectionnez le mode d'ombrage texturé.

Déplacez le curseur de la souris au-dessus de lavue 3Det appuyez sur P pour lancer le Game Engine. La souris va disparaître et la fenêtre changer de couleur, signe que le Game Engine a démarré. Appuyons maintenant sur flèche vers le haut et vérifions que le personnage avance bien. Échap permet de sortir du jeu.

Résoudre les problèmes

Lorsque nous avons lancé le jeu et appuyé sur la flèche du haut, il se pourrait que rien ne se produise. Nous pouvons alors nous placer dans une logique de recherche d'erreur sur différents niveaux.

• Dans un premier temps vérifions que c'est bien Up Arrow qui est enregistrée dans le sensorkeyboard.
• Si le réglage précédent est bon, nous pouvons tester une autre touche du clavier en reconfigurant ce sensor pour tester uniquement la validité de la touche.
• Vérifions également que nos différents sensors, controllers et actuators sont liés correctement.

Il s'agit d'évaluer à chaque fois les éléments qui ne vont pas et de trouver tout ce qui intervient éventuellement dans le dysfonctionnement et d'évaluer leur validité, un par un, pour les éliminer jusqu'à trouver le bon.

Il est possible aussi que notre personnage ne se soit pas déplacé vers l'avant, mais qu'il avançait de côté, ou même reculait. Peut-être qu'il avançait beaucoup trop vite ou alors très lentement. Retournons voir les paramètres de Loc de l'Actuator Motion. Si notre personnage n'avançait pas, mais reculait, c'est qu'il faut changer le signe de notre valeur enyet placer -0.10. S'il avançait trop lentement, il faut encore augmenter cette valeur à 0.5 par exemple. S'il avançait de côté, il faut plutôt changer les valeurs de position en x ou celles enz. Retenons, que par défaut, ces changements de position se font par rapport aux coordonnées locales de l'objet auquel ils s'appliquent (lorsque le bouton L, à droite est coché).

Ajouter d'autres directions de déplacement

À cette étape, notre personnage va dans une seule direction. Bien que cela puisse être déjà un jeu amusant en soi, nous serons vite tentés d'ajouter d'autres degrés de liberté de mouvement, comme la possibilité de reculer, tourner à gauche, tourner à droite, courir, voler, etc. En bref, tout ce que nous avons défini dans la phase de conception du jeu (game design).

Faire reculer le personnage

Nous devons ajouter un nouveau sensor qui va récupérer l’événement quand le joueur appuiera sur flèche vers le bas du clavier. Nous devons créer un nouvel actuator Motionqui appliquera un déplacement négatif enyà notre objet, par exemple -0.10. Et nous devons créer un controller And qui liera cet événement clavier avec le déplacement de l'objet vers l'arrière.

Organiser le Logic Editor

Nous sentons bien que lorsque nous allons ajouter de multiples briques logiques pour gérer les différentes façons de déplacer notre personnage, nous allons vite avoir un grand nombre d'éléments. Il va falloir organiser. C'est pourquoi il est important de nommer les briques de manière claire et descriptive. Nommer nos sensors, actuators et controllers nous sera bien utile lorsque nous commencerons à utiliser des scripts Python afin de les identifier et de récupérer leurs paramètres au sein de notre code.

En cliquant sur le champ textuel à côté de la liste décrivant le type de sensor en haut de la brique, renommons en haut le sensor Keyboard qui récupère la touche clavier flèche vers le haut . Renommons en avant l'actuator Motion qui fait avancer le personnage, et ainsi de suite pour les autres : en bas et en arriere.

En cliquant sur la petite flèche située à gauche dans l'en-tête de la brique, il est possible de la réduire pour qu'elle occupe moins d'espace et ainsi avoir un meilleur aperçu global.

Une fois réduites, seules les briques qui ont été renommées sont compréhensibles, comme le montre cette capture d'écran de comparaison. Renommer un controller Andn'a pas d'importance pour l'instant. Mais il sera impératif de le faire pour des cas plus complexes où l'entrée du And sera reliée à plusieurs sensors.

Faire tourner le personnage

Nous sommes maintenant capable d'ajouter deux nouveaux sensorsKeyboard pour récupérer les frappes sur flèche gauche et flèche droite du clavier et les lier via des controllers aux actuators Motion qui feront tourner l'objet dans un sens ou dans l'autre. Introduisons une valeur de 0.20° enz dans la ligne Rot pour faire tourner notre objet à gauche ou -0.20° en z pour faire tourner notre objet à droite.

Notre conseil est de tester à nouveau les ajouts, et cela aussi souvent que possible, en particulier tant que vous n'êtes pas encore très expérimentés. Cela permet de détecter les erreurs au plus vite et de faciliter la recherche en cas de problème, ainsi que de tester le jeu, ce qui reste un élément essentiel.

Scrypthon !

Nous allons aborder ici très simplement comment déplacer le personnage, mais cette fois-ci en utilisant un script Python. Il s'agit de notre première utilisation du Python. Coder dans ce cas n'est pas nécessaire, mais cela permet d'offrir d'autres voies d'explorations et d'interaction.

Python ou briques logiques

De manière générale, toutes les logic bricks (briques logiques) peuvent être remplacées par des scripts Python, mais l'inverse n'est pas nécessairement vrai. Les scripts permettent, avec le temps et les connaissances nécessaires, de créer des fonctions de jeu beaucoup plus complexes. Il est donc important de se familiariser très tôt avec leur fonctionnement.

Néanmoins, les scripts Python ont au moins toujours besoin de deux briques logiques pour fonctionner. Un sensor, qui déterminera quand activer le script Python et un controllerde typePythonqui détermine quel script est à activer à cet instant là. D'autressensors et actuatorspeuvent être présents et l'on peut combiner l'utilisation de scripts et de logic bricks dans tout projet, sans restriction. Ce n'est pas parce qu'on décide d'utiliser des scripts Python pour telle ou telle fonction que l'on doit à partir de ce moment-là, tout coder en Python.

Créer un script Python

Dans le Text Editor, créons un nouveau texte que nous appelons avancer.py. L'extension ".py" est communément celle des fichiers textes qui représentent du code Python. Pour les fichiers textes inclus dans le .blend, il n'est pas nécessaire d'ajouter une extension, mais, de manière générale, c'est une bonne pratique. Comme ça, sans ouvrir le fichier, nous avons une idée de ce qu'il contient.

Charger un module

La première ligne que nous devons (et devrons) toujours écrire, c'est celle qui détermine quel module Python nous devons importer. Il existe beaucoup de modules Python différents. Chaque module regroupe une collection de fonctions et méthodes particulières, regroupées autour d'un sujet. Le module render, par exemple, regroupe toutes les méthodes liées au rendu du jeu.

Pour faire avancer notre personnage, nous devons importer le module logic. Ce module contient entre autre les fonctions nécessaires pour manipuler des objets dans le Game Engine. Voici comment cela s'écrit en Python :

from bge import logic

Récupérer le controller

Le script Python ne "sait" pas qui ou quoi l'active. Pour cela, il existe une méthode qui permet de récupérer le controller qui l'a lancé. Nous la stockons dans une variable nommée cont.

cont = logic.getCurrentController()

Appliquer le déplacement

Une fois que nous avons notre controller. Nous pouvons savoir quel est l'objet auquel il est attaché, ou, en d'autres termes, quel est son propriétaire. Dans ce cas-ci, comme nos logic bricks sont attachées à notre objet personnage, c'est bien lui que nous récupérons.

personnage = cont.owner 

Nous pouvons donc lui appliquer un déplacement de 0.10 en coordonnée locale y, comme nous le faisions avec le premier actuator de notre exemple.

personnage.localPosition.y += 0.10

En pratique, ce que nous faisons ici, c'est ajouter 0.10 à la coordonnée y de notre objet.

Activer le script à chaque frappe du clavier

Voici notre script complet :

from bge import logic 

# Recuperer le controller qui active le script 
cont = logic.getCurrentController() 

# Recuperer l'objet attache personnage = cont.owner # 
Deplacer l'objet vers l'avant personnage.localPosition.y += 0.1

Il doit bien porter le nom "avancer.py" dans le Text Editor.

Dans leLogic Editor, nous avons aussi un sensor Keyboard configuré pour répondre lorsque l'on presse la touche flèche vers le haut et ce sensorest relié à un controller Python.

Dans notre controllerPython, devant le menu déroulant qui affiche par défaut Script, cliquons dans la boîte vide et nous voyons une liste des scripts et autres textes disponibles dans notre projet Blender. Choisissons "avancer.py".

En lançant maintenant le jeu (P), s'il n'y a pas de faute de frappe et que tout est lié correctement, le personnage devrait faire un micro-déplacement vers l'avant à chaque appui sur la touche flèche vers le haut.

Des améliorations progressives

Tout travail sur des mécaniques de jeu (que ce soit des jeux vidéo ou d'autres genre de jeux comme des jeux de société) demande de longues heures de tests et d'essais. Nous ne trouverons peut-être pas tout de suite les bonnes valeurs de rotation ou de déplacement. L'ajout de fonctions et de paramètres d'un côté ou d'un autre du jeu demande souvent de revoir des choses définies plus tôt. Un jeu est un assemblage subtil de règles et de paramètres pour trouver un équilibre agréable ou parfois même juste utilisable. Il est donc recommandé, après chaque changement de paramètre ou ajout de fonction de tester son jeu. Vous gardez ainsi le fil, en comprenant plus facilement quelle option a cassé ce qui marchait avant ou de comprendre comment tel paramètre influe sur la jouabilité du projet.