Créer un village interactif avec GameBlender (1)
Interactions dans GameBlender

   Blender est une suite de modélisation, animation et rendu 3d complète et gratuite qui vous permet de réaliser des images de synthèse. Depuis la version 2.0, Blender permet également de concevoir des jeux et est connu sous le nom de GameBlender. J'ai utilisé Blender 2.14 pour ce tutoriel. Vous pouvez le télécharger ici : http://www.blender.nl.

   Ce tutoriel va vous permettre de créer un jeu avec des objets dynamiques et de gérer les interactions entre eux.

   Pour commencer, téléchargez ce fichier qui contient une maison vide : maison.blend.

 

I. Mise en place de la dynamique du jeu

Frottements du sol

   Ouvrez le fichier maison.blend : vous voyez une maison vue de dessus, une caméra et une sphère déformée qui symbolise un habitant de notre monde virtuel .

   Placez vous en vue de dessus ( NUM7 ). Dézoomez un peu ( NUM- ou ctrl + clic milieu ). Vous apercevez maintenant un plan qui constitue le sol de notre monde virtuel (ce sera le même pour l'intérieur et l'extérieur de la maison). Sélectionnez ce plan ( clic droit ).

   Allez dans le panneau Material Buttons F5 . Pour activer le matériau "dynamique", enfoncez le bouton Dyn. Nous allons augmenter la Friction du sol : réglez la à 1.000 ( shift + clic gauche sur Friction)

Dynamique du personnage

   Placez vous en vue de dessus ( NUM7 ). Zoomez un peu ( NUM+ ou ctrl + clic milieu ) pour apercevoir le personnage (il est symbolisé par une IcoSphere dont on a déplacé un Vertex) .

   Sélectionnez ce personnage ( clic droit ). Positionnez le curseur sur le personnage ( shift + S Curs->Sel). Nous allons ajouter un Empty pour controller ce personnage ( ESPACE ADD->Empty). C'est un objet qui n'a aucun vertex, mais il est très utile dans GameBlender. Les mouvements du personnage devront suivre ceux de l'Empty. Pour cela, nous allons parenter l'Empty au personnage : sélectionnez le personnage ( clic droit ) et l'Empty ( shift + clic droit ) (Attention : l'ordre est important) puis effectuez le parentage : ctrl + P .

   Nous allons maintenant rendre l'Empty dynamique, c'est-à-dire qu'il pourra se déplacer et réagir à des forces selon le lois de la dynamique . Sélectionnez l'Empty ( clic droit ). Allez dans le panneau Realtime Buttons ( F8 ), puis enfoncez les boutons Actor et Dynamic. Vous voyez apparraitre une sphère autour de l'Empty : c'est la sphère de collision . Nous pouvons régler sa taille en ajustant le paramètre Size. Mettez une taille de 0.500 ( shift + clic gauche sur Size).

Mouvements du personnage

   Pour que notre personnage se déplace, il faut lui appliquer une force (pour avancer) ou un moment (pour tourner) quand le joueur appuie sur une touche . Nous allons par exemple utiliser la fléche HAUT du clavier pour avancer et les fléches GAUCHE / DROITE pour tourner.

   Les évènements dans GameBlender sont détectés par des Sensors. Pour savoir quand le joueur appuie sur la touche HAUT, nous allons ajouter un sensor Keyboard. Cliquez sur le bouton Add correspondant au Sensors :

   Vous verrez apparaitre un sensor de type Always. Cliquez sur le bouton"Always-" du Sensor pour le changez son type et choisissez Keyboard. Maintenant, pour choisir la touche associée au Sensor, cliquez sur la case grise à coté de Key et appuyez sur la touche fléchée du clavier HAUT (Uparrow). Ce sensor enverra un signal chaque fois que le joueur appuiera sur la touche HAUT.

   Pour récupérer ce signal, il faut ajouter un Controller. Cliquez sur le bouton Add correspondant au Controllers : un controller AND apparait .

   Enfin, pour faire avancer le personnage, ajoutez un Actuator. Cliquez sur le bouton Add correspondant au Actuators : un Actuator Motion apparait, il permet d'appliquer des forces et des moments aux objets dynamiques. Nous voulons que le personnage se déplace selon l'axe y positivement (voir le positionnement de l'Empty). Réglez donc la Force selon y à 14.000 ( shift + clic gauche sur la 2ème case à droite de Force)

   Nous devons lier ces trois LogicBricks (une LogicBrick est un Sensor, un Controller ou un Actuator). Pour cela cliquez sur la boule jaune à l'extrémité droite du sensor Keyboard et glissez-la vers la boule jaune à l'extrémité gauche du Controller. Reliez également le Controller et l'Actuator.

   Pour tester le bon fonctionnement de la touche fléchée HAUT, placez-vous en vue de dessus ( NUM7 ) et lancez le jeu ( P ). Lorque vous appuyez sur la touche fléchée HAUT, le personnage avance. Quittez le jeu ( Echap ).

   Nous allons maintenant ajouter au personnage la possbilité de tourner à gauche et à droite. Ajoutez donc 2 Sensors Keyboard. Assignez la touche fléchée GAUCHE (Leftarrow) au premier et la touche fléchée DROITE (Rightarrow) au deuxième.
   Ajoutez également 2 Controllers de type AND (c'est le type par défaut des Controllers).
   Pour faire tourner le personnage, ajoutez 2 Actuators Motion (c'est le type par défaut des Actuators). Ces Actuators devront donner un moment (Torque) selon l'axe des "z" à l'Empty pour faire tourner le personnage. Réglez donc le Torque selon z à 3.00 ( shift + clic gauche sur la 3ème case à droite de Torque) pour le premier Actuator et à -3.00 pour le second Actuator.
   Reliez le premier Sensor au premier Controller, le deuxième Sensor au deuxième Controller, le premier Controller au premier Actuator et le deuxième Controller au deuxième Actuator.

   Remarque : Vous pouvez renommer les LogicBricks en cliquant sur leur nom, qui se situe à côté du type de LogicBrick.

   Vous pouvez maintenant tester les déplacements du personnage. Lancez le jeu ( P ). Vous remarquerez que le moment d'inertie du personage est trop grand, il continue à tourner trop longtemps après que l'on ait relaché les touches servant à tourner.
Pour y remédier, nous allons modifier le coefficient de frottement pour les rotations (RotDamp). Quittez le jeu ( Echap ). Entrez une valeur de 0.900 pour RotDamp ( shift + clic gauche sur l'ancienne valuer de RotDamp).

 

II. Ouverture des portes après l'appui d'une touche

Courbe IPO d'ouverture de la porte

   Pour introduire le mouvement d'ouverture de la porte dans notre jeu, nous devons d'abord le créer avec une courbe IPO. Placez vous en vue de dessus ( NUM7 ). Recadrez la vue sur la porte. Sélectionnez la porte ( clic droit ). Amenez votre curseur la fenêtre la plus à droite et ouvrez le panneau des courbes IPO ( shift + F6 ). Assurez-vous que vous êtes à la première frame (image clé) de l'animation ( shift + flèche BAS ). Nous allons introuduire une première clé d'animation ( I -> Rot).

   Avancez ensuite de 30 frames ( flèche HAUT 3 fois). Faites tournez la porte de 80 degrés ( R +ctrl ). Insérez une deuxième clé d'animation ( I -> Rot).

   Astuce : Vous pouvez recadrer la vue dans la fenêtre des courbes IPO (touche HOME ).

   Remarque :
1) Pour obtenir un mouvement d'ouverture plus rapide, il faudrait insérer la deuxième clé par exemple 10 ou 20 frames après la première, au lieu des 30 que j'ai choisi.
2) Vous pouvez supprimer les courbes IPO RotX et RotY de la porte, car sa rotation s'effectue seulement autour de l'axe des z.


Ouverture et fermeture de la porte

   Nous allons d'abord ajouter une propriété nommée porte à notre porte afin qu'elle puisse être détectée par un joueur. L'objet porte étant toujours sélectionné, allez dans le panneau Realtime Buttons ( F8 ). Ajoutez-lui une propriété ( clic gauche sur Add Property). Nommez-la "porte" ( clic gauche à côté de Name:).

   Attribuez-lui le type Bool (Booléen, c'est-à-dire Vrai ou Faux, True ou False, 0 ou 1) ( clic gauche sur Float-) et la valeur True.

   Remarque : La valeur "True" n'a pas beaucoup d'importance, seule l'existence de cette proriété est obligatoire.

   De même, sélectionnez l'Empty, puis ajoutez-lui une propriété joueur, de type Bool et de valeur True.

   Sélectionnez à nouveau l'objet porte. Nous avons besoin de savoir quand le joueur aura l'intention d'ouvrir la porte. Pour cela, ajoutez à la porte une propriété ouverture de type Bool et de valeur False (car on ne veut pas que l'ouverture de la porte se produise au début du jeu). Cette propriété servira de lien entre le joueur et la porte car quand le joueur aura détecté la porte, il pourra modifier cette propriété grâce à un script Python.

   Quand la propriété ouverture sera égale à True (Vrai), nous allons ouvrir la porte. Puis quand elle sera égale à False (Faux), nous la refermerons.
   Ajoutez un Sensor de type Property qui nous indiquera quand la propriété ouverture sera égale à True ( clic gauche à côté de Prop:et entrez "ouverture" puis clic gauche à côté de Value:et entrez "TRUE" ).
   Ajoutez ensuite un Controller AND et reliez le au Sensor précédemment ajouté.
   Enfin, ajoutez un Actuator de type Ipo en mode Flipper ( clic gauche sur Play) de valeurs Sta 1 et End 31 : cet Actuator "jouera" l'animation que nous avons créé pour la porte entre les frames 1 et 31, et reliez-le au Controller.

   Remarque : L'Actuator Ipo de type Flipper "joue" la courbe Ipo jusqu'au bout tant qu'il reçoit un signal du Controller et la "joue à l'envers" quand il ne reçoit plus de signal pour revenir à la situation initiale.

   Nous voulons fermer la porte automatiquement lorsque le joueur s'en est suffisament éloigné. C'est ici que la propriété joueur de l'Empty va nous servir. En effet, nous allons utiliser un Sensor Near qui va détecter tous les objets ayant la propriété joueur, quelle que soit leur valeur. Nous allons inverser la sortie de ce Sensor pour savoir quand il n'y aura plus aucun joueur autour de la porte. A ce moment, nous allons mettre FALSE dans la propriété "ouverture".
   Ajoutez un Sensor de typer Near, ayant pour valeurs :
         Property : joueur
         Inv coché ( pour inverser la sortie du sensor)
         Dist : 3.00 (c'est la distance minimale à laquelle le joueur peut ouvrir la porte)
         Reset : 3.00 (c'est la distance maximale à laquelle la pote reste ouverte)
   Ajoutez un Controller de type AND et reliez-le au Near Sensor.
   Ajoutez un Actuator Property en mode Assign, ayant pour valeurs :
         Prop : ouverture
         Value : FALSE
   Reliez-le au Controller.

   Astuce : Vous pouvez minimiser une LogicBrick en cliquant sur la flèche orange en haut à droite de celle-ci. En re-cliquant dessus, vous maximisez la LogicBrick.

Détection d'une porte grâce à un sensor Ray

   Sélectionnez l'Empty ( clic droit ). Nous allons lui ajouter une propriété booléenne nommée "ouvre" qui représentera sa volonté d'ouvrir la porte ("ouvre" sera égale à TRUE quand le joueur voudra ouvrir la porte). Assignez-lui la valeur FALSE.

   Cette propriété n'aura un sens que si le joueur se trouve devant une porte. Nous allons utiliser un sensor Ray qui "lance" un rayon jusqu'à une certaine distance et nous dit s'il a rencontré un objet avec une certaine propriété. Ajoutez donc un Sensor Ray, ayant pour valeurs :
         Property : porte
         Range : 3.00 (distance maximale de détection)
         Axe : Y (axe sur lequel on "lance" le rayon)
et activez le "TRUE pulse mode" (l'icone symbolisant des crénaux en haut) (il permettra de lancer le script python à chaque frame du jeu). /!\ : Vous devez appeler ce sensor "porte" pour l'utiliser avec le script python.
   Ajoutez également un Sensor Keyboard qui réagira à la touche ctrl.
   Ajoutez un Controller AND et reliez les deux Sensors précédents à ce Controller.
   Ajoutez un Actuator Property en mode Assign qui stockera la valeur TRUE dans la propriété ouvre.

Transmission d'un ordre du joueur à la porte avec Python

   Nous allons maintenant écrire le script qui va donner l'ordre de s'ouvrir à la porte. Le script est déjà écrit dans le fichier de départ maison.blend. Affichez la fenêtre de Texte pour le consulter ( shift + F11 ). Il s'appelle ouvre_porte et le code est détaillé ci-dessous. Ajoutez un Controller de type Python qui exécutera le Script: ouvre_porte. Enfin, reliez-le au Sensor Ray que vous avez nommé porte.

import GameLogic
# cette ligne sert à importer le module principal de GameBlender
# ses fonctions seront accessibles en tapant: Gamelogic.fonction()

cont = GameLogic.getCurrentController()
# on récupère le controller python

owner = cont.getOwner()
#on remonte jusqu'au propriétaire du controller qu'on appelle "owner"

radar_porte = cont.getSensor("porte")
# on appelle radar_porte le Sensor nommé "porte", c'est le sensor Ray
objet_porte = radar_porte.getHitObject()
# on appelle objet_porte le dernier objet avec une propriété "porte"
# rencontré par le sensor Ray

# on vérifie si le joueur veut ouvrir la porte
# la fonction str() transforme n'importe quelle variable en chaîne de caractères
# on l'utilise pour comparer la propriété "ouvre" du joueur "owner" avec la chaîne "TRUE"
if str(owner.ouvre) == "TRUE":
	owner.ouvre = 0
	# on enlève au joueur la volonté d'ouvrir la porte puisqu'il est en train de l'ouvrir
	# ceci change la propriété "ouvre" de l'objet "owner" (le joueur) en 0 (FALSE)
	objet_porte.ouverture = 1
	# on donne l'ordre à la porte de s'ouvrir
	# ceci change la propriété "ouverture" de la porte en 1 (TRUE)
	print "ok"
	# on affiche un message dans la console pour dire que tout s'est bien passé

  

   Lancez le jeu ( P ) et observez le résultat final !

Conclusion

   Vous disposez maintenant d'objets réutilisables pour créer un village interactif, il vous suffit de les sélectionner et de les dupliquer ( shift+D ). Vous pouvez aussi ajouter une caméra qu'il vous suffira de parenter à un joueur : sélectionnez la caméra puis le joueur, parentez-les ( ctrl+P ) et passez en vue caméra ( NUM0 ). J'espère que ce tutoriel vous aura permis d'acquérir les bases de GameBlender afin de créer un village interactif plus élaboré.

   Happy Blending !

Télécharger le fichier final.

Télécharger le tutoriel zippé.

©Olivier Blin

Liens utiles

Bases de Blender

http://jmsoler.free.fr
http://blender.free.fr

Bases et fonctions avancées de GameBlender

http://abjedi.free.fr
http://blenderman.free.fr
http://www.infres.enst.fr/~guerin/
http://olivierblin.free.fr

Galeries d'images crées avec Blender

http://www.freid.com
http://www.graphinc.com