Blender pour le jeu video
Comprendre les briques logiques
Dans ce chapitre nous étudierons en détail le fonctionnement du moteur logique du BGE. Jusqu'à présent, nous avons utilisé les briques sans trop nous soucier de la mécanique interne mais il nous faut en savoir plus si nous voulons faire des machines à états élaborées et efficaces. Commençons par décrire les caractéristiques communes à toutes les briques.
Principes de base
Les sensors ont tous un état interne qui est un simple booléen : Vrai (True) si la condition qu'ils détectent est réalisée ou Faux (False) dans le cas contraire. Les sensors produisent en outre des impulsions (Trigger) qui activent les controllers auxquels ils sont connectés.
Par la suite nous parlerons d'impulsion positive si l'impulsion est générée alors que le sensor est dans l'état Vrai et d'impulsion négative dans le cas contraire. Cependant il faut bien comprendre que les controllers sont activés de la même manière par une impulsion, qu'elle soit positive ou négative.Un sensor produit toujours une impulsion lorsque son état change. D'autres impulsions peuvent être générées en fonction des options communes à tous les sensors, nous y reviendrons.
Prenons comme exemple le sensor Keyboard car il est facile à utiliser et représentatif de tous les sensors. Voici le comportement de base du sensor :
Cette image représente l'état du sensor au cours du temps depuis le démarrage du jeu (ou l'activation de l'état auquel appartient le sensor). Les boules noires représentent les moments ou une impulsion est générée. Nous voyons qu'un impulsion (positive) est générée lorsque la touche est pressée et une autre (négative) lorsqu'elle est relâchée. Un controller connecté à ce sensor sera donc activé deux fois.
Un controller activé sous l'effet d'une impulsion examine l'état de tous les sensors auxquels il est connecté (qu'ils aient ou non généré une impulsion) et selon les conditions logiques qui lui sont propres peut envoyer aux actuators auxquels il est connecté une impulsion positive ou négative.
Les controllers logiques envoient une impulsion positive à tous les actuators si la condition logique est vérifiée, sinon ils envoient une impulsion négative. Cette liste donne les conditions logiques pour chaque type de controller :
- And : tous les sensors doivent être positifs.
- Nand : au moins un sensor doit être négatif.
- Or : au moins un sensor doit être positif.
- Nor : tous les sensors doivent être négatifs.
- Xor : un seul sensor doit être positif.
- Xnor : zéro, deux ou plus de sensors doivent être positifs.
- Expression : l'expression logique est écrite en python.
Une fois transmise à un actuator, une impulsion positive l'active et une impulsion négative le désactive (ou ne fait rien s'il était déjà inactif). Le temps pendant lequel un actuator reste actif en l'absence d'impulsion varie d'un type à l'autre. Nous distinguons 3 type d'actuators.
- Ceux qui restent actifs tant qu'ils ne reçoivent pas d'impulsion négative. Les actuators suivants appartiennent à cette catégorie :
- Armature (en mode Run)
- Camera
- Constraint
- Motion
- Ceux qui restent actifs un certain temps et se désactivent automatiquement sous certaines conditions :
- Action
- Steering
- Sound
- Ceux qui ne restent pas actifs : ils exécutent une opération et se désactivent immédiatement.
- Edit Object
- Filtre 2D (le filtre, une fois en place, reste actif)
- Game
- Message
- Mouse (dans le cas de Mouse Look, il faut envoyer constamment des impulsions pour actualiser l'orientation de la caméra)
- Parent
- Property
- Random
- Scene
- State
- Visibility
Mode avancé des sensors
Nous pouvons voir que tous les sensors ont une ligne de boutons communs.
Ces boutons influencent le nombre et la polarité des impulsions. Voici ce qui se passe lorsque le bouton Tap est sélectionné :
Nous voyons que l'impulsion négative est générée immédiatement après l'impulsion positive, indépendamment du fait que la touche soit toujours enfoncée. L’écart de temps entre les deux impulsions est toujours de 1 frame. Ce mode est souvent utilisé pour obtenir des déplacements ponctuels : un actuatorMotionqui reçoit ces deux impulsions s'activera pendant exactement 1 frame.
Le bouton Level fonctionne comme le mode normal excepté qu'une impulsion est toujours générée au démarrage du jeu ou lorsque qu'un controller devient actif suite à un changement d'état. Dans ce cas, seuls les controllers nouvellement actifs reçoivent l'impulsion.
Ce mode est utile pour la programmation de machine à états car il permet une initialisation correcte de l'état (les controllers sont garantis de recevoir une impulsion au démarrage de l'état). Le bouton Invert inverse la logique du sensor. Par exemple, dans le cas du Keyboard, le sensor sera positif tant que la touche n'est pas enfoncée et négatif sinon :
Les boutonspulse +et pulse -produisent des impulsions supplémentaires tant que le sensor est respectivement positif ou négatif. Le paramètre Freq est l'intervalle, exprimé en frame, inséré entre deux impulsions, 0 signifiant qu'une impulsion est envoyée à chaque frame.
Il ne faut pas abuser du mode pulse car il augmente rapidement la charge de travail du BGE.Voici ce qui se passe quand le bouton pulse + est sélectionné avec Freq = 1 :
Et avec pulse - :
Les boutons peuvent être combinés à l'exception de Tap qui est incompatible avec Levelet Pulse. Voici par exemple ce qui se passe siTapetInvert sont sélectionnés en même temps :
Scrypthon !
Pour reproduire le bouton du chapitre précédent nous utiliserons deux attributs communs à tous les sensors:
- triggered : True si le sensor vient d'envoyer une impulsion
- positive : True si le sensor est positif, False s'il est négatif
Nous conservons les deux sensors car il est plus efficace de demander au BGE de surveiller les boutons de la souris que de le faire en Python. Nous remplaçons les deux controllers par un seul controller Python et nous nous passerons d'actuator pour montrer que nous pouvons agir sur le jeu directement par Python :
Nous utilisons le script suivant :
from bge import logic
import math
# Recupere le controller, l'objet et les sensors
cont = logic.getCurrentController()
obj = cont.owner
sOver = cont.sensors["sOver"]
sClick = cont.sensors["sClick"]
# Triggered est True si la souris entre ou sort du bouton
if sOver.triggered:
# Calcule la rotation selon l'axe X
rot = math.pi if sOver.positive else 0
# Ecrire un vecteur d'Euler change la rotation de l'objet
obj.orientation = [rot, 0, 0]
# Logique equivalente au controller And
if sOver.positive and sClick.positive:
logic.endGame()
Expliquons la partie qui concerne la rotation du bouton. Nous utilisons l'attribut triggered du Mouse Over pour détecter le moment où la souris entre ou sort du bouton : ce sensor ne génère une impulsion qu'à ces moments-là. Nous modifions directement la rotation de l'objet en écrivant dans l'attribut orientation qui accepte différents types de données. Ici, nous passons un vecteur dont les composantes sont les angles d'Euler. Comme les angles sont en radian, nous utilisons math.pi(3,1415) pour indiquer une rotation de 180 degrés.