Cours sur le framework QStateMachine

Un objet issu d'une classe Qt contient les données et fonctions nécessaires à son utilisation ; par ailleurs, nous avons la possibilité de faire interagir des objets entre eux avec les mécanismes typiques à Qt : « signals » et « slots », ce qui les rend communicants. Dans ce qui suit, nous apprendrons à rendre un objet autonome en lui conférant la capacité d'adopter un état ou un comportement entre plusieurs que nous lui aurons attribués, et nous nous permettrons, par des transitions, de changer son état en cours. Ainsi nous acquerrons le moyen de métamorphoser un objet en un genre d'automate. En mathématiques, un automate peut-être défini comme un spécimen de modélisation. Brièvement, l'automate fini, qui est le plus élémentaire de cet univers mathématique, est utilisé dans la conception de logiciel informatique pour décomposer l'étude des fragments complexes du projet au plus simple possible. Ce modèle d'automate revêt un seul état parmi ceux qui lui sont assignés. Comme exemple je citerai :

- un tiroir possède deux états : ouvert ou fermé, et il ne peut être que dans un seul de ces deux états :

- en considérant que le tiroir démonté est un état possible, alors nous obtenons trois états, et le tiroir ne peut être que dans l'un de ceux-ci :

- nous pouvons pousser plus loin puisque l'état démonté ne peut être qu'une suite de l'état ouvert. Nous l'insérons donc à l'intérieur :

Dans le décorticage des états possibles dans un projet, nous nous exposons à en produire une surabondance. En reprenant l'exemple du tiroir : dans son état fermé, nous pourrions y inclure l'état fermé à clé… D'où la nécessité dans un développement informatique basé sur des états, d'avoir la possibilité de le modifier confortablement.

Pour représenter graphiquement un concept basé sur un automate fini, il y a plusieurs méthodes, dont les diagrammes du langage UML (Unified Modeling Language), et c'est ce modèle qui a inspiré Qt pour créer l'interface de programmation QStateMachine. Notez que dans la version Qt 6.0, QStateMachine a été supprimé temporairement de Qt Core et reviendra dans les versions ultérieures de Qt (probablement dans le cadre du module Qt SCXML) : voir ici.

La structure de machine à états est un ensemble de classes permettant de créer des états pour un ou plusieurs objets, et de définir des transitions pour que ce ou ces objets passent d'un état à un autre. Le démarrage de la machine à états affectée à l'objet gère ces transitions qui sont déclenchées par l'objet lui-même, ou par un autre objet, ou par une action externe. En général, un objet qui change d'état déclenche l'exécution d'une fonction et/ou un changement d'une ou plusieurs de ses propriétés. Pour cerner plus simplement l'usage de QStateMachine, tentons une analogie avec le principe des boucles sans fin dans un programme. Considérons qu'une machine est une de ces boucles. Elle a donc trois états : soit démarrée, soit suspendue, soit arrêtée. Au cours du déroulement d'un logiciel contenant des objets dotés de ce type de machine, si nous démarrons les machines de ces objets, elles analyseront en permanence les transitions qui leur sont assignées, et ce, quelle que soit l'activité du logiciel. Ce qui peut sembler rendre ces objets indépendants, dans le contexte de ce logiciel. Dans le cadre de cet apprentissage, notre objectif sera simple : transformer un objet informatique en automate en lui imputant des états dont les transitions, d'un état à un autre, provoqueront un comportement différent, ou influeront sur l'état d'un autre objet.

Dans le diagramme ci-dessous, l'état arret possède une transition deplace qui, si activée, déclenche l'état bouge ; celui-ci possède une transition stoppe qui, si activée, revient à l'état arret :

Dans ce cas de figure, chaque transition déclenche la fonction onEntry présente dans chaque état. Comme exemple pour un déplacement de l'objet : la transition deplace activera la fonction onEntry de l'état bouge qui démarrera une animation où l'objet se déplacera tant que la transition stoppe n'est pas déclenchée.

Toute entrée dans un état déclenche sa fonction onEntry, et toute sortie déclenche sa fonction onExit.

Nous effleurons dans cette section les classes indispensables à l’utilisation de QStateMachine et quelques classes simples. Les textes qui suivent sont des traductions adaptées de la documentation originelle.

II-B-1. QStateMachine▲

II-B-2. QState▲

La classe QState fournit les objets état traités par la machine. Elle est aussi utilisée comme base pour créer de nouvelles classes. Ces classes peuvent avoir des états enfants et peuvent avoir des transitions vers d'autres états.

Les deux fonctions virtuelles principalement implémentées de cette classe sont :

virtual void QAbstractState::onEntry(QEvent *evt);

cette fonction est déclenchée lorsque l'objet entre dans un état. L'événement passé en paramètre est le déclencheur de l'entrée ;

virtual void QAbstractState::onExit(QEvent *evt);

cette fonction est déclenchée lorsque l'objet quitte l'état. L'événement passé en paramètre est le déclencheur de la sortie.

II-B-3. QFinalState▲

Nous pouvons assimiler une machine à états à une boucle sans fin, elle ne se terminerait jamais ; elle doit donc inclure un état final au niveau supérieur qui sera appelé pour l'arrêter.

QFinalState *final = new QFinalState(machine);

connect(machine, SIGNAL(finished()), qApp, SLOT(quit()) );

Pour ce faire, il suffit d'inclure un objet de la classe QFinalState et de le connecter par une transition dans l'arborescence des états.

Dans ce diagramme, l'instance objet final de la classe QFinalState, est en dehors de l'état zoneanime, donc hiérarchiquement au niveau supérieur :

II-B-4. QSignalTransition▲

Cette classe crée des transitions déclenchées par la directive Signal des classes Qt.

Les deux fonctions virtuelles principales qui suivent peuvent être réimplémentées :

virtual bool eventTest(QEvent *evt); — cette fonction autorise un test qui déclenchera, ou pas, la transition ;

virtual void onTransition(QEvent *evt); — cette fonction, appelée quand la transition est déclenchée, doit être réimplémentée pour être personnalisée.

II-B-5. QEventTransition▲

QPushButton *bouge = new QToolButton("appuyez", this);
machine = new QStateMachine(this);
QState *etat = new QState(this, machine);
QEventTransition *transition = new QEventTransition(bouge, QEvent::Enter);
transition->setTargetState(... cible de la transition...);
etat->addTransition(transition);

II-B-6. QKeyEventTransition▲

Classe permettant d'utiliser un événement « touche » comme déclencheur dans une ou plusieurs transitions pour communiquer avec les états simultanément ou individuellement.

L'appui sur la touche '6' déclenche la transition avance de l'état arret et provoque le départ du déplacement de l'objet en activant la fonction onEntry de l'état bouge :

TrTouchBouge *avance = new TrTouchBouge(this, QEvent::KeyPress, Qt::Key_6);

TrTouchBouge est une classe héritière de QKeyEventTransition. Nous indiquons à cette transition qu'elle sera active si la touche 6 du clavier est appuyée ;

avance→setTargetState(etatdeplacement); — l'état bouge est ajouté comme cible à l'objet de transition avance, pour que sa fonction onEntry soit déclenchée par cette transition ;

arret->addTransition(avance); — et cet objet de transition est, bien entendu, ajouté à l'état arret.

Les deux fonctions virtuelles principales de cette classe sont :

virtual bool eventTest(QEvent *evt); — cette fonction, déclenchée par l'appui de la touche, teste l'événement. Elle doit être réimplémentée pour être utilisée. Si elle retourne une valeur true, elle déclenche alors la transition et passe la main à la fonction onTransition. J'ajouterai « innocemment », qu'il est inutile de tester si c'est la touche 6, parce que c'est elle qui a enclenché la transition et que l'implémentation de cette fonction concerne des tests supplémentaires ;

virtual void onTransition(QEvent *evt); — cette fonction est appelée lorsque la transition est déclenchée, elle doit être réimplémentée pour personnaliser la transition.

II-B-7. QMouseEventTransition▲

La classe Fenetre (habituellement nommée classe mainwindow dans la création d'un projet) contient les objets :

• scene : zone graphique où se situera l'animation. Cet objet sera associé ultérieurement à un objet de la classe Vue ;

• des boutons qui sont de deux types :

  • démarrer et quitter. Ils seront accessibles pendant l'animation et bénéficieront d’un lien dans la « machine »,
  • le bouton configuration qui ne sera actif qu’en dehors de l’activité graphique ;
• ligneinfo, zone d'édition en lecture, chargée d’afficher les messages, mais qui ne sera pas utilisée dans cet apprentissage.

Le diagramme des commandes, à ce stade, reste assez simple. À noter que l'objet de la classe Vue, quoique visible dans le diagramme, ne sera pas traité dans cette partie. Toutefois nous en créons dès maintenant une instance vide pour des raisons pratiques d’héritage d’objet, ce qui nous évitera de reprendre certaines instanciations, quand les sources seront plus compliqués.

Les instances des boutons sont créées dans la classe Fenetre et seront connectées dans la classe Scene. Le bouton « configuration » ouvrira une boite de dialogue pour stocker ou modifier les données dans un fichier externe, quant à la ligne d’information, elle ne sera pas connectée.

Pour faciliter la maintenance de la classe Fenetre, le contenu du constructeur est simplifié en faisant appel à des fonctions internes, cette classe hérite de QWidget qui, elle-même, hérite de QObject, ce qui est conforme à l’utilisation du Framework QStateMachine où l'animation et le traitement d’état ne s’appliquent que sur les objets de la classe QObject.

Remarques sur le fichier fenetre.h de la classe Fenetre :

...
public slots :
    bool Configuration();
...
private :
    Vue   *ptrvue;
    Scene *pscene;
...

La déclaration de slot : Configuration est la fonction appelée par la boite de dialogue pour les données de configuration du logiciel. Cette fonction ne sera pas développée ici, puisqu'elle fait appel aux routines standards de gestion boite de dialogue Qt. Elle est présente pour montrer que, quand les objets animés circuleront dans la zone graphique, l’affichage de la boite de dialogue n’interrompra pas le déroulement des « machines » donc la circulation des objets.

Les pointeurs des instances de classe Scene et Vue sont déclarés à ce niveau pour qu'ils persistent jusqu'à l'arrêt du logiciel. Ils seront supprimés par le destructeur de l'instance. (Il en sera de même pour les autres pointeurs créés à ce niveau).

III-A-1. Description du fichier source fenetre.cpp▲

...
resize(1173, 904);
pscene = new Scene(0, 0, 1100, 850);
ptrvue = new Vue(pscene, this);
    CreerLeMenu();
pscene->InitPtrVue(ptrvue);
pscene->InitialiserScene(nouveau, quitter, ligneinfo1);
...

delete pscene;
delete ptrvue;
...

Elle représente la classe qui gère : les séquences et la sauvegarde du test en cas d'interruption. Ces événements ne nous concerneront pas. Nous allons simplement utiliser la classe pour démarrer le test, et lancer la première séquence (qui est la seule dans ce manuel). La classe ZoneAnime est héritière de la classe état QState et contient son propre objet machine.

La réimplémentation de la fonction virtuelle onEntry redémarre une nouvelle séquence lorsque l'utilisateur clique sur le bouton nouveau. Son objectif est de nettoyer la scène pour y réinstaller les éléments à leur origine :

void ZoneAnime::onEntry(QEvent *)
{
    if(machine)
    {
        machine->stop();
        scene->NettoyerScene();
        delete machine;
    }
    machine = new QStateMachine;
    Sequence *sequence = new Sequence(scene, machine);
    machine->setInitialState(sequence);
    machine->start();
}

Dans la première partie, l'objet machine, s’il existe, est stoppé et détruit, la scène est nettoyée. Puis nous créons ou recréons l'objet machine que nous démarrons après lui avoir affecté un état sequence en tant qu'état initial.

La création de l'objet zoneanime se trouve dans la fonction InitialiserScene de la classe scene que nous étudierons plus loin. Voyons brièvement comment il sera instancié :

ZoneAnime *zoneanime = new ZoneAnime(this, machine);
zoneanime->addTransition(nouvellepartie, SIGNAL(clicked()), zoneanime);
...
machine->setInitialState(zoneanime);
machine->start();

Nous la connectons à l'aide d'une transition par le menu « nouvellepartie » ciblant zoneanime, et, avant de lancer l'objet machine, nous initialisons zoneanime comme état de départ.

Nous pouvons alors constater que scene et zoneanime contiennent chacun leur gestionnaire d'état « machine ». C'est lorsque ces gestionnaires sont démarrés, que leurs objets propriétaires ont un semblant d'autonomie.

Cette classe n'est utile que pour la réinitialisation de la scène, c'est pour cette raison que nous ne définirons qu'une séquence. Par contre, si plusieurs séquences étaient prévues, nous y chargerions les données concernant la position des composants formant la structure de la scène pour chacune de ces séquences. Pour cette fois, nous n'aurons donc qu'à traiter l'implémentation de la fonction onEntry qui est réduite à une ultime expression :

void Sequence::onEntry(QEvent *){ scene->ReInitialiserScene(); }

La classe Scene qui hérite de la classe QGraphicsScene, contient les éléments graphiques qui s'afficheront dans la zone d'animation.

III-D-1. Description du fichier source scene.cpp▲

Scene::Scene(int x, int y, int width, int height) : QGraphicsScene(x, y, width, height)                          
{
     ObjetImage *fondItem = new ObjetImage( QString(":/motif/fond.png") );
     fondItem->setZValue(1);
     fondItem->setPos(0, 0);
     addItem(fondItem);
}

void Scene::InitialiserScene(QToolButton *nouvellepartie, QtoolButton *quitterlejeu, QLineEdit *linformation)
{
    QStateMachine *machine = new QStateMachine(this);
    ZoneAnime *zoneanime = new ZoneAnime(this,  machine);
    QFinalState *final = new QFinalState(machine);
    zoneanime->addTransition(nouvellepartie, SIGNAL(clicked()), zoneanime);
    zoneanime->addTransition(quitterlejeu, SIGNAL(clicked()), final);
    connect(machine, SIGNAL(finished()), qApp, SLOT(quit()));
    machine->setInitialState(zoneanime);
    machine->start();
}

Dans le fichier entête de cette classe deux constructeurs sont définis : un simple pour initialiser un pointeur dans un fichier entête, et le deuxième avec en paramètre le nom de fichier pour être directement instancié dans un fichier source. Il y a deux fonctions virtuelles : QRectF boundingRect et void paint, qui sont nécessaires à QGraphicObject pour dessiner ou effacer l'objet. L'image stockée est de la classe QPixmap qui est la plus appropriée, des quatre classes Qt concernant les images, pour être utilisée dans ce contexte :

class ObjetImage : public QGraphicsObject
{
public:
    ObjetImage(QGraphicsItem* parent=0);
    ObjetImage(const QString &nomfichier, QGraphicsItem *parent=0);
    void InitImage(const QString &nomfich);
    QSizeF size() const;
    ...
private:
    QPixmap image;
}

Le fichier source ne présente pas de particularités, et n'a pas de lien direct avec la structure de la machine d'état.

Cette classe contient les fonctions pour le déplacement des graphiques mobiles, et, pour contrôler ce déplacement, nous utiliserons les chiffres du pavé numérique. Vous pouvez changer, mais il est préférable d'éviter le pavé des flèches :

int direction;
       //0=fixe, gah=Qt::Key_4, drt=Qt::Key_6, hau=Qt::Key_8, bas=Qt::Key 
void DirectionDroite();
void FixerObjet();
bool Immobile() const;
bool Mobile() const;
bool VaADroite() const;
bool NeVaPasADroite() const;

Pour récupérer ou fixer l'état de mobilité de l'objet, nous créerons des fonctions simples et compréhensibles. (Ci-dessus, le membre NeVaPasADroite aurait très bien pu être remplacé par une instruction !VaADroite.)

void BougeToi();
void Stop();
quint8 ValeurPas() const;
virtual void InitPas( quint8 vpas );

Le déplacement sera paramétré par une valeur de pas. Cette valeur pourrait être modifiée avec la configuration. Les variables de stockage de « direction » et « pas » sont privées, puisque cette classe les utilise en interne, et elles ne seront disponibles que par des fonctions. Les deux membres protégés, quant à eux, seront accessibles par la classe héritière.

Ci-dessous, on crée la variable machine qui sera la boucle d'état pour la classe héritière.

protected:
    QVariantAnimation *animationdelobjet;
    QStateMachine *machine;
private:
    quint8 pas;
    int direction;

Les objets mobiles ayant obligatoirement une variable de type QStateMachine, il est préférable de la placer dans la classe ObjetMobile et aussi d'y placer la variable QVariantAnimation qui va permettre le déplacement de l'objet.

La fonction BougeToi est appelée par la classe héritière au moment de l'initialisation. Lors de l'appel l'objet démarre la machine, pour notre cas l'instance de joueur machine->start();.

La fonction Stop, quant à elle, est appelée par la classe Scene pour cacher le joueur lors du nettoyage de la scène.

void ObjetMobile::Stop()
{
    FixerObjet();
    animationdelobjet->stop();
    machine->stop();
}

L'objet est fixé pour réinitialiser la position. Si une animation est en cours, elle sera stoppée, et la machine de l'objet joueur sera arrêtée.

Cette classe hérite de la classe ObjetMobile. Elle est pilotée par l'action sur les touches. Dans le cas étudié, il n'y a qu'un seul sens de déplacement, sans accélération, qui sera déclenché par la touche du clavier numérique 6 : chaque appui déplacera le joueur sur une petite distance vers la droite, un appui continu le déplacera sans s'arrêter jusqu'à la limite droite de la fenêtre où il s'immobilisera. Au démarrage du test, l'objet est fixe à gauche de la zone graphique.

En premier, je présente les fonctions simples :

void Joueur::ReInitialiser()
{
    FixerObjet();
    setPos(0, ( pvue->scene()->height() - size().height() )/2 );
    show();
    BougeToi();
}

Dans cette fonction, nous plaçons ou replaçons le joueur à la gauche de la scène, puis nous appelons BougeToi membre de la classe ObjetMobile pour démarrer la machine.

Le déplacement de l'objet lors de l'appui sur la touche est validé par la réalisation de trois tests : si l'objet est mobile, s'il va à droite et s'il n'a pas atteint la limite droite de la scène. Si ces trois conditions sont remplies, il se déplace de la distance assignée à la variable « pas » de ObjetMobile. La mise à jour de ce déplacement est effectuée par la fonction MajMouvement.

Un organigramme de la fonction sera plus explicite :

Si le déplacement est autorisé, nous calculons le point qu'il doit atteindre, nous testons à nouveau la limite, puis nous envoyons la valeur à l'instance d'animation qui redémarre.

void Joueur::MajMouvement()
{
   animationdelobjet->stop();
   if (Mobile())
   {
      if(VaADroite())
      {
        qreal tmpr = ( scene()->width() - size().width() );
        if( x()<tmpr )
        {
           npos = pos();
           npos.setX( x() + ValeurPas() );
           if( npos.rx()>tmpr )
           {
               npos.setX(tmpr);
           }
           animationdelobjet->setEndValue(npos);
           animationdelobjet->start();
        }
     }
   }
}

On remarque qu'au début de la procédure, il y a un animationdelobjet->stop();. En effet, pour réinitialiser le point de fin, il faut stopper l'animation si elle est en cours. Quand l'animation est stoppée, l'objet reste au point où il est arrivé.

À noter : envoyer un ordre de stop à l'animation si elle est déjà fixée ne pose aucun problème.

Maintenant, passons à la partie complexe. Le diagramme qui suit décrit les interactions entre les états et l'exécution des opérations suite à l'entrée de l'objet dans l'un de ses états, après l'appui, soit de la touche 6 qui déclenche le déplacement, soit de la touche 5 qui interrompt un déplacement en cours :

Le symbole I encerclé, en haut à gauche de l'état arret désigne qu'il sera l'état initial au démarrage de la machine.

La transition avance qui appartient à l'état arret, a pour cible l'état bougeadroite. L'action sur la touche active sa fonction onEntry et lance la procédure de déplacement. De même, la transition stoppe appartient à bougeadroite et cible l’état arret, l'action sur la touche 5 active sa fonction onEntry et lance la procédure d'arrêt immédiat de l'objet joueur. Vous remarquerez aussi la présence d'une « transition par signal » dans la classe bougeadroite qui est la cible du signal finished de l'animation : en effet si aucune touche n'est saisie pendant le déplacement de l'objet, lorsque l'animation atteint son délai, elle émet le signal finished qui sera récupéré par l'état bougeadroite et envoyé comme transition stoppe.

Dans le fichier source de la classe Joueur c'est au niveau du constructeur que la création de la machine, les instanciations des états et les transitions entre ces états sont initialisées, ainsi que la partie animation dont nous étudierons la classe QAbstractAnimation au prochain paragraphe. Vous remarquerez que la machine n'est pas démarrée en fin de constructeur, parce que c'est l'initialisation dans la classe Scene qui doit provoquer le démarrage des machines de tous les graphiques mobiles.

Les quelques lignes du début du constructeur concernent l'initialisation des variables :

InitImage( QString( ":/motif/joueur.png" ) );
setFlags( QGraphicsItem::ItemIsFocusable );
setZValue(4);
InitPas(200);

• La valeur en Z pour les superpositions entre objets graphiques sur la scène.
• La valeur du pas : c'est le nombre de pixels de déplacement pendant l'animation.

Pour ce qui est de l'image « png » de l'objet joueur, j'ai choisi un motif de 70px de haut sur 50 de large.

Ensuite, nous créons le déroulement de l'animation qui sera appliquée à joueur lorsque nous appuierons sur la touche 6 :

animationdelobjet = new QPropertyAnimation(this,"pos"); — initialisation du pointeur de animationdelobjet de la classe QVariantAnimation, le pointeur « this » désigne l'objet joueur et le trigramme «´pos » indique que l'animation s'appliquera sur la propriété « position » de l'objet.

animationdelobjet->setDuration(500); — nous donnons une durée à l'animation, cette durée, en fonction de la valeur du pas exprimera une vitesse de déplacement.

machine = new QStateMachine(this); — initialisation du pointeur de l'objet machine. Comme nous sommes dans l'objet joueur, nous affectons immédiatement le pointeur de joueur « this » comme parent à machine. Plus loin, nous créerons la transition qui permettra à cette machine de lancer l'animation.

Nous assignons ci-dessous à joueur les états dont les classes seront décrites plus bas :

BougeADroite *etatdeplace = new BougeADroite(this, machine); — cette ligne crée une instance de la classe état BougeADroite.

Arret *arret = new Arret(this,machine); — création de l'instance de la classe état Arret. Cet état contient la transition réagissant à l'action sur la touche 6, qui fera basculer joueur de l'état arret à l'état bougeadroite.

Nous écrivons maintenant les lignes d'instructions pour la création des transitions. À cet instant, nous n'avons qu'une classe de transition TransTchBouge héritière de la classe QKeyEventTransition spécifique à l'événement touche du clavier. Nous étudions cette classe avant d'aller plus loin dans le constructeur :

TransTchBouge(Joueur *vjoueur, QEvent::Type t, int k); — dans le constructeur, le pointeur de l'objet joueur est passé en paramètre pour pouvoir y accéder depuis les fonctions de la transition. Le paramètre QEvent est le type d'événement déclencheur : ici « KeyPress ». « k » définit la touche du clavier activant l'événement, dans notre cas 5 ou 6.

Quand la transition est validée la fonction virtuelle utilisée onTransition est exécutée :

if (touche == Qt::Key_5)
    joueur->FixerObjet();
else
    joueur->DirectionDroite();

Nous la réimplémentons avec une instruction qui aiguille la touche appuyée vers l'action à entreprendre.

Nous aurions pu utiliser la fonction eventTest au lieu de onTransition, le résultat final aurait été identique, puisque la transition étant confirmée, elle active l'état ciblé. Mais avec cette option, nous n'aurions pas été conformes à la philosophie de QStateMachine qui doit être respectée le mieux possible dans un apprentissage. Autrement, la question doit être posée dans un développement courant en tenant compte du suivi de la maintenance.

Vous remarquerez aussi que je teste la valeur de la touche, ce qui est contraire à mon écrit sur la description des fonctions de QKeyEventTransition dans la partie précédente. La raison est que cette classe est volontairement utilisée pour créer les transitions des touches 6 et 5.

Nous reprenons notre constructeur de la classe Joueur aux lignes d'instructions des transitions :

• en premier le déclenchement du déplacement :

TransTchBouge *avance = new TransTchBouge(this, QEvent::KeyPress, Qt::Key_6); — création de la transition avance provoquée par la touche 6.

avance->setTargetState(etatdeplacement); — cible de la transition avance.

arret->addTransition(avance); — ajouter la transition à l'état arret qui sera le boutefeu ;

• en deuxième le déclenchement de l'arrêt :

TransTchBouge *arrete = new TransTchBouge(this, QEvent::KeyPress, Qt::Key_5); — création de la transition arrete provoquée par la touche 5.

arrete->setTargetState(arret); — cible de la transition arrete.

bougeadroite->addTransition(arrete); — ajouter la transition à l'état bougeadroite qui sera le déclencheur.

Sur le diagramme, nous avons remarqué la connexion entre le signal finished de l'animation et la classe état BougeADroite pour stopper l'objet quand le trajet de l'animation se finit sans intervention au clavier de 6 ou 5. Pour réaliser cette connexion, nous plaçons cette ligne :

bougeadroite->addTransition( animationdelobjet, SIGNAL(finished()), arret); — une transition ajoutée à l'état BougeADroite pour enclencher l'état Arret et stopper l'objet en fin d'animation.

Celle-ci n'est pas obligatoire puisque, quand l'objet atteint la limite, nous devons réinitialiser la séquence. Mais nous pourrions imaginer qu'une fois stoppé à la limite, l'objet se replacerait au début automatiquement : ce qui serait possible, grâce à ce : SIGNAL(finished()).

Pour terminer ce constructeur, nous devons indiquer l'état initial au démarrage, ou redémarrage, de machine : machine->setInitialState(arret); — l'objet machine place l'état arret comme état initial.

Évidemment dans le cas de ce simple déplacement, la classe Joueur est la plus importante partie au point de vue complexité et utilisation primaire des classes de la structure de machine d'états.

Cette classe class BougeADroite : public QState n'a qu'un but : être la cible de la transition avance pour lancer la procédure de mouvement du joueur. Pour l'instant, elle est plutôt maigre, en sus du constructeur, elle ne contient que la fonction virtuelle :

void BougeADroite::onEntry(QEvent *)
{
  joueur->MajMouvement();
}

Par cette fonction, on lance la mise à jour du déplacement du joueur.

Cette classe, tout aussi maigre que la précédente, ne contient que la réimplémentation de la fonction virtuelle :

void Arret::onEntry(QEvent *)
{
    joueur->FixerObjet();
    joueur->MajMouvement();
}

Avec cette fonction nous immobilisons le joueur en plaçant la valeur de direction à 0, puis nous lançons la mise à jour du déplacement, ce qui signifie que nous stoppons l'animation. Voir l'organigramme au début de cette section.

N'oublions pas que dans les classes d'état QState, la fonction onEntry est exécutée juste après la transition, et la fonction onExit lorsque nous quittons l'état. Dans l'exemple en cours, quand la transition est validée, la fonction onExit de la classe Arret est exécutée avant la fonction onEntry de la classe BougeADroite.

La classe scène réunit tous les objets de la zone graphique. Ces objets ne sont pas obligatoirement initialisés dans cette étape, mais la présence d'un pointeur les représentant est nécessaire. Notre objet devant apparaître dès le départ de l'application, nous créons son occurrence dans le constructeur :

...
   addItem(fondItem);
   joueur = new(Joueur);
   joueur->hide();
   addItem(joueur);
...

Hide() : cache l'objet en attendant l'initialisation, pour éviter des apparitions intempestives.

Puisque l'objet joueur existe tout au long de l'application, nous supprimerons son pointeur dynamique dans le membre destructeur : Scene::~Scene(){if(joueur) delete joueur;}.

Nous avons observé dans le chapitre précédent que la classe ZoneAnime était chargée de nettoyer la scène avant que celle-ci ne soit réinitialisée par la classe Sequence. Donc nous pouvons maintenant mettre à jour les deux fonctions membres de Scene, chargées de cette opération :

void Scene::NettoyerScene()
{
   joueur->Stop();
   joueur->hide();
   joueur->setEnabled(true);
}

La fonction Stop a été décrite dans la classe Joueur.

void Scene::ReInitialiserScene()
{
   setFocusItem(joueur, Qt::OtherFocusReason);
   joueur->ReInitialiser();
}

La fonction ReInitialiser a été décrite dans la classe Joueur.

La fonction setFocusItem place le curseur (virtuellement) sur l'objet graphique. Si nous omettons cette instruction, il faudrait « cliquer » sur celui-ci au départ de la séquence pour que l'action sur les touches lui soit attribuée, sinon il resterait immobile.

La partie animation va être étudiée succinctement. Pour avoir des notions plus précises sur la classe QAbstractAnimation, il vous faudra consulter la documentation française de Qt et les exemples qui s'y réfèrent. Pour notre sujet, il nous suffit de connaître quelques classes pour gérer les déplacements des graphiques.

Notre schéma est simple : un objet est positionné, il subit un déplacement vers un autre point en suivant un segment de droite qui finit à ce point. Nous avons aussi la possibilité de l'arrêter en cours de déplacement. Pour réaliser ces événements, nous utiliserons les fonctions :

• start() : démarrer l'animation ;
• Stop() : arrêter l'animation ;
• setEndValue(x,y) : point d'arrivée ;
• SetDuration(500) : temps du déplacement en millisecondes.
  Nous avons déjà créé l'objet de la classe QVariantAnimation dans le constructeur de Joueur qui subira cette animation Animationdelobjet = new QPropertyAnimation(this, "pos");.
  Cette animation sera démarrée par le :animationdelobjet->start();dans la fonction MajMouvement de joueur, après avoir initialisé le point d'arrivéeanimationdelobjet->setEndValue(npos);dans cette même fonction.

L'arrêt de cette animation s'exécute au point d'arrivée, ou par le :

animationdelobjet->stop();de la fonction Stop de la classe ObjetMobile dont la classe Joueur hérite.

L'animation n'amène pas de concept compliqué dans notre apprentissage.

Nous en avons terminé avec ces premiers pas dans l’univers de QStateMachine pour le déplacement d’un objet dans un seul sens. Nous avons assimilé la base minimale de gestion des états et des transitions entre ces états, alors poursuivons l’apprentissage en augmentant les difficultés.

Dans ce premier diagramme simple, l'état initial de départ est arret. Celui-ci possède deux transitions qui vont servir à démarrer le joueur dans une des deux directions, suivant la touche appuyée.

Le déplacement est régi par deux états, bougeadroite et bougeagauche chacun d'eux possède une transition qui pointe vers son opposé pour inverser le sens de déplacement, si la touche de direction opposée est appuyée. À noter que nous ne traiterons pas le signal finished de l'animation, puisque la seule solution, quand l'objet est collé à la limite, est de repartir dans le sens inverse.

Au départ, seul l'état arret répondra à la sollicitation d'une des touches, ensuite il ne pourra plus y avoir qu'une alternative entre les deux autres états pour le sens de déplacement.

V-A-1. Modification des classes existantes▲

void DirectionGauche();
quint8 CodeDirection();

bool VaAGauche() const;
bool NeVaPasAGauche() const;

Switch( CodeDirection() )
{
    case Qt::Key_4 : //gauche
		trajet = npos.x();
		npos.setX(0);
		break;
    case Qt::Key_6 : //droite
		trajet = scene()->width()-npos.x();
		npos.setX( scene()->width() - size().width() );
		break;
    default : 
    	bougeok = false;
}
if (bougeok)
{
	animationdelobjet->setEndValue(npos);
	animationdelobjet->setDuration( vitesse*trajet );
	animationdelobjet->start();
}

Arret *arret = new Arret(this, machine);
machine->setInitialState(arret);

BougeADroite *bougeadroite = new BougeADroite(this, machine);
BougeAGauche *bougeagauche = new BougeAGauche(this, machine);

TransTchStop *SversG = new TransTchStop(this, QEvent::KeyPress, Qt::Key_4);
SversG->setTargetState(bougeagauche);
arret->addTransition(SversG);

TransTchInverse *DversG = new TransTchInverse(this, QEvent::KeyPress, Qt::Key_4);
DversG->setTargetState(bougeagauche);
bougeadroite->addTransition(DversG);

void Joueur::InverserDeplacement()
{
    switch( CodeDirection() )
    {
        case Qt::Key_4: // gauche
        	DirectionDroite();
        	break;
        case Qt::Key_6: // droite
        	DirectionGauche();
        	break;
    }
}

V-A-2. Nouvelles classes▲

void BougeAGauche::onEntry(QEvent *)
{ 
	joueur->MajMouvement();
}

void TransDemarre::onTransition(QEvent *)
{
    if(touche == Qt::Key_4)
        joueur->DirectionGauche();
    else
        joueur->DirectionDroite();
}

bool TransInverse::eventTest(QEvent *evt)
{
    if( !QKeyEventTransition::eventTest(evt) )
        return false;
    return
        (touche == Qt::Key_4 && joueur->VaADroite())
      ||
        (touche == Qt::Key_6 && joueur->VaAGauche());
}

void TransInverse::onTransition(QEvent *)
{
    joueur->InverserDeplacement();
}

Dans cette version, nous ajoutons la touche 5 qui va stopper le joueur pendant son déplacement. Le diagramme est légèrement modifié, il montre deux nouvelles transitions issues de la touche 5 et chacune pointe vers bougeadroite et bougeagauche. La cible de ces transitions sera l'état arret. Les modifications à effectuer étant simples, cette version ne constitue pas d’étape dans le projet Qt contenant les sources du cours.

Nous ajoutons les lignes suivantes dans le constructeur de la classe Joueur :

QKeyEventTransition *stopG = new QKeyEventTransition(this, QEvent::KeyPress, Qt::Key_5);
bougeagauche->addTransition(stopG);
stopG->setTargetState(arret);
QKeyEventTransition *stopD = new QKeyEventTransition(this, QEvent::KeyPress, Qt::Key_5);
bougeadroite->addTransition(stopD);
stopD->setTargetState(arret);

Nous utiliserons donc la classe de base QKeyEventTransition directement, sans créer de classe héritière puisque seule la touche 5 déclenche la transition et qu'aucune instruction particulière n'est prévue.

V-B-1. Partage de transitions▲

Nous profiterons de la simplicité de cette version, pour étudier le partage des transitions entre plusieurs états. Dans la section précédente, l'appui de la touche 5 stoppe l'animation, quel que soit le déplacement. Mais nous avons dû créer deux objets de la classe QKeyEventTransition et les traiter pour chaque état, cependant, nous avons la possibilité de faire autrement en utilisant un « conteneur ». Le diagramme qui suit décrit le principe :

Tous les états ont comme parent l'état conteneur, la transition lui est ajoutée et cible l'état arret. Ce qui fait que l'appui sur la touche 5 activera directement l'état arret et donc interrompra l'état actif en cours.

 

Sélectionnez

...
machine = new QStateMachine(this);
QState *conteneur = new QState(machine);
Arret *arret = new Arret(this, conteneur);
conteneur->setInitialState(arret);
machine->setInitialState(conteneur);
QKeyEventTransition *stopGD = new QKeyEventTransition(this, QEvent::KeyPress, Qt::Key_5);
conteneur->addTransition(stopGD);
stopGD->setTargetState(arret);
BougeADroite *bougeadroite = new BougeADroite(this, conteneur);
BougeAGauche *bougeagauche = new BougeAGauche(this, conteneur);
...
// le reste du code source ne change pas.

Dans un partage des transitions, chaque état enfant hérite des transitions de l'état parent. Nous observons donc que tout état intégré au groupe conteneur héritera de cette transition stop.

Avec la présence de la touche 5 pour stopper l'objet, nous allons compliquer la version en ajoutant la possibilité d'accélérer l'objet si nous appuyons plusieurs fois sur la touche du même sens que la direction où l'objet se déplace, et en freinant l'objet si la touche enfoncée est inverse du sens de déplacement et que l'objet est mobile, jusqu'à ce qu'il change de direction, si la vitesse devient nulle.

Le diagramme de la gestion de ces états devient compliqué. Nous aurons à initialiser huit instances de transition :

• accelg et acceld qui accélèrent l'objet ;
• freing et freind qui ralentissent l'objet ;
• DversG et GversD qui inversent la direction de l'objet au bout du freinage ;
• Depgah et Depdrt qui démarre l'objet lorsqu'il est à l'arrêt.

La touche enfoncée envoie un signal de transition à tous les états qui lui sont connectés, et seul l'état actif de l'objet graphique l'interprétera pour exécuter une action, si bien sûr une action est prévue.

Par exemple, si l'état en cours est arret et que l'utilisateur appuie sur la touche 4, les états bougeagauche et bougeadroite n'étant pas actif au moment de l'appui seront ignorés. Alors la transition depgah activera la procédure onEntry de l'état bougeagauche qui deviendra actif pour déplacer l'objet vers la gauche, et ce, jusqu'à ce que l'objet atteigne la limite gauche ou bien que l'utilisateur appuie sur une autre touche.

Vous remarquerez que nous adoptons le principe d'un état conteneur.

V-C-1. Modification des classes existantes▲

int vitesseaccel = Vitesse en cours * acceleration;
dureedepl = distance restante * coefresiste/vitesseaccel;

private:
    quint8 vitesse;
    quint8 limitevitesse;
    quint8 acceleration;
    quint8 coefresiste;

void    AnnulerVitesse();  
void    AugmenterVitesse();
void    DiminuerVitesse();
void    VitesseInitiale();

quint8  Vitesse() const;
bool    VitesseNulle() const;
bool    VitessePasNulle() const;
bool    VitesseMinimale() const;

void Joueur::FixerObjet()
{
    AnnulerVitesse();
    ObjetMobile::FixerObjet();
}

...
vitesse         =   0;
limitevitesse   =  10;
acceleration    =   7;
coefresiste     = 150;
...

machine = new QStateMachine(this);
QState *conteneur = new QState(machine);
    Arret *arret = new Arret(this, conteneur);
conteneur->setInitialState(arret);
machine->setInitialState(conteneur);
    BougeADroite *bougeadroite = new BougeADroite(this, conteneur);
    BougeAGauche *bougeagauche = new BougeAGauche(this, conteneur);

QKeyEventTransition *stopGD = new QKeyEventTransition(this, Event::KeyPress, Qt::Key_5);
conteneur->addTransition(stopGD);
stopGD->setTargetState(arret);

animationdelobjet->stop();
if(Immobile()||VitesseNulle()) return;

TransDemarre *depgah = new TransDemarre(this, QEvent::KeyPress, Qt::Key_4);
    arret->addTransition(depgah);
    depgah->setTargetState(bougeagauche);

TransAccelere *accelG = new TransAccelere(this, QEvent::KeyPress, Qt::Key_4);
    bougeagauche->addTransition(accelG);
    accelG->setTargetState(bougeagauche);

TransInverse *DversG = new TransInverse(this, QEvent::KeyPress, Qt::Key_4);
    DversG->setTargetState(arret);
    bougeadroite->addTransition(DversG) ;

TransFrein *freinD = new TransFrein(this, QEvent::KeyPress, Qt::Key_4);
    bougeadroite->addTransition(freinD);
    freinD->setTargetState(bougeadroite);

return
    ( 
       (touche == Qt::Key_4 && joueur->VaADroite())
         ||
       (touche == Qt::Key_6 && joueur->VaAGauche())
    )
       && 
    joueur->VitesseMinimale();

return
    (
        (touche == Qt::Key_4 && joueur->VaADroite())
            ||
        (touche == Qt::Key_6 && joueur->VaAGauche())
    )
    && joueur->VitesseMinimale();

V-C-2. Nouvelles classes▲

void TransDemarre::onTransition(QEvent *)
{
    if( touche == Qt::Key_4 )
        joueur->DirectionGauche();
    else
        joueur->DirectionDroite();

    joueur->VitesseInitiale();
}

void TransAccelere::onTransition(QEvent *)
{
    joueur->AugmenterVitesse();
}

void TransFrein::onTransition(QEvent * )
{
     joueur->DiminuerVitesse();
}

Nous ne créons que deux nouvelles classes d'état qui reprennent le même schéma que BougeADroite et BougeAGauche. Dans leur fonction virtuelle onEntry, on lance la mise à jour du déplacement du joueur.

Classe BougeEnBas :

void BougeEnBas::onEntry(QEvent *)
{
    joueur->MajMouvement();
}

Classe BougeEnHaut :

void BougeEnHaut::onEntry(QEvent *)
{
    joueur->MajMouvement();
}

VI-B-1. TransAccelere▲

void TransAccelere::onTransition(QEvent *)
{
    joueur->AugmenterVitesse();
    joueur->MajMouvement();
}

bool TransAccelere::eventTest(QEvent *evt)
{
    if ( !QKeyEventTransition::eventTest(evt) )
		return false;
    return !joueur->VitesseMaximale();
}

VI-B-2. TransInverse▲

void TransInverse::onTransition(QEvent *)
{
    switch( touche )
    {
        case Qt::Key_4 : { joueur->DirectionGauche(); }break;
        case Qt::Key_6 : { joueur->DirectionDroite(); }break;
        case Qt::Key_8 : { joueur->DirectionHaut(); }break;
        case Qt::Key_2 : { joueur->DirectionBas(); }break;
    }
}

VI-B-3. TransFrein▲

void TransFrein::onTransition(QEvent *)
{
    joueur->DiminuerVitesse();
    joueur->MajMouvement();
}

VI-B-4. TransDemarre▲

void TransDemarre::onTransition(QEvent *)
{
    switch( touche )
    {
        case Qt::Key_4 :{ joueur->DirectionGauche(); }break;
        case Qt::Key_6 :{ joueur->DirectionDroite(); }break;
        case Qt::Key_8 :{ joueur->DirectionHaut(); }break;
        case Qt::Key_2 :{ joueur->DirectionBas(); }break;
    }
    joueur->VitesseInitiale();
}

VI-B-5. ObjetMobile▲

void DirectionHaut();
void DirectionBas();
bool VaEnHaut() const;
bool VaEnBas() const;
bool NeVaPasEnHaut() const;
bool NeVaPasEnBas() const;

VI-B-6. Joueur▲

machine = new QStateMachine(this);
QState *conteneur = new QState(machine);
Arret *arret = new Arret(this, conteneur);
// Il faut déclarer l'objet arret avant l'initialisation.
conteneur->setInitialState(arret);
machine->setInitialState(conteneur);

BougeADroite *bougeadroite = new BougeADroite(this, conteneur);
BougeAGauche *bougeagauche = new BougeAGauche(this, conteneur);
BougeEnHaut  *bougeenhaut  = new BougeEnHaut(this, conteneur);
BougeEnBas   *bougeenbas   = new BougeEnBas(this, conteneur);

TransDemarre *deplaceD = new TransTchBouge(this, QEvent::KeyPress, Qt::Key_6);
    deplaceD->setTargetState(bougeadroite);
    arret->addTransition(deplaceD);

TransAccelere *accelD = new TransTchBouge(this, QEvent::KeyPress, Qt::Key_6);
    bougeadroite->addTransition(accelD);

TransInverse *versG = new TransInverse(this, QEvent::KeyPress, Qt::Key_4);
        conteneur->addTransition(versG);
       versG->setTargetState(bougeagauche);

TransFrein *freinG = new TransFrein(this, QEvent::KeyPress, Qt::Key_4);
        conteneur->addTransition(freinG);

Cette fois le mouvement est perpétuel, nous n'avons donc pas de déclencheur. Seul l'appui sur le bouton « nouveau » réinitialise l'objet et recommence le mouvement.

Le diagramme montre que l'état avance est déclaré comme initial au début de la machine, ce qui signifie que sa fonction onEntry démarre l'animation dès que l'ordre machine->start()est donné.

Nous aurons donc, au démarrage de l'application, l'objet qui se déplace et lorsque l'animation se termine, elle envoie un signal à la transition reprend de l'état avance, qui déclenche alors l'état arret. Ce dernier, par sa fonction onEntry, replace les coordonnées de départ de l'objet à leur origine, et envoie un signal RePositionner. Celui-ci est capté par l'état avance qui actionne la reprise de l'animation.

VII-A-1. La classe Predateur▲

private:
    ...
    QPointF     pntfin;
    QPointF     pntdepart;

void Predateur::Initialiser()
{
    hide();
    pntfin = QPointF( ( scene()->width() - size().width() ), 0);
    pntdepart = QPointF(0, (scene()->height() - size().height()) );
    setPos(pntdepart);
    show();
}

animationdelobjet = new QPropertyAnimation(this, "pos");
animationdelobjet->setDuration(4000);

machine = new QStateMachine(this);
DeplacePrd *avance = new DeplacePrd(this, machine);
ArretPrd *arrete = new ArretPrd(this, machine);

QSignalTransition *reprend = new QSignalTransition(animationdelobjet, SIGNAL(finished()) );
avance->addTransition(reprend);
reprend->setTargetState(arret);

VII-A-2. L’état DeplacePrd▲

void DeplacePrd::onEntry(QEvent *)
{
    predateur->MajMouvement();
}

VII-A-3. L’état ArretPrd▲

...
signals :  
    void RePositionner();
...

void ArretPrd::onEntry(QEvent *)
{
    predateur->Initialiser();
    emit RePositionner();
}

VII-A-4. Modification de la classe Scene▲

...
predateur = new(Predateur);
predateur->hide();
addItem(predateur);

void Scene::NettoyerScene()
{
    predateur->Stop();
    predateur->hide();
    predateur->setEnabled(true);
}
void Scene::ReInitialiserScene()
{
    setFocusItem(predateur, Qt::OtherFocusReason);
    predateur->Initialiser();
    predateur->BougeToi();
}

Pour tester la fiabilité de ce procédé, nous allons créer plusieurs objets de la classe Predateur :

VII-B-1. Modification de la classe Predateur▲

private:
    Vue     *pvue;
    QPointF  pntdepart, pntfin, pntfinsvd, pntdepsvd;

void Predateur::Initialiser(const QPointF& pdep, const QPointF& pfin)
    pntfinsvd = pfin;
    pntdepsvd = pdep;

void Predateur::ReInitialiser()
{
    hide();
    pntfin = pntfinsvd;
    pntdepart = pntdepsvd;
...
}

VII-B-2. Modification de la classe Scene▲

...
private:
QList<Predateur*> lstpred;
…

...
for (int i=0; i< $nombre de predateur$ ;++i)
    {
        lstpred.append(new(Predateur));
        lstpred.last()->hide();
        addItem(lstpred.last());
    }
...

void Scene::ReInitialiserScene()
{
    …
    for(int i=0; i<lstpred.size(); ++i)
    {
        predateur->lstpred.at(i)->ReInitialiser(); 
    }
}

void Scene::IniPredateur()
{
    if(!lstpred.isEmpty())
    {
        int lp = lstpred.first()->size().width();
        ...
        lstpred.first()→Initialiser( QPointF(-lp,-hp), QPointF(lg/2,hg) );
        lstpred.first()->InitPas(1000);
        ...
    }
}

void Predateur::InitPas(int vpas)
{
    animationdelobjet->setDuration(vpas);
}

Dans cette classe nous regroupons dans l’entête les pointeurs sur l’objet predateur et l’objet joueur et les fonctions pour récupérer ces valeurs.

   Joueur *pJoueur() const;
   Predateur *pPredateur() const;
...
private :
   Joueur *joueur;
   Predateur *predateur;

Dans le fichier source, au niveau du constructeur, ils seront initialisés :

joueur = new(joueur);
joueur->hide();
addItem(joueur);
predateur = new(Predateur);
predateur->hide();
addItem(predateur);

• dans un premier temps, au moment de l’initialisation de la scène, nous initialisons les valeurs origine des points pour l’objet libre :

void Scene::InitialiserScene(...)
{
    ...
    predateur->Initialiser(QPointF(...),QPointF(...));
    QStateMachine *machine = new QStateMachine(this);
    Jeu *jeu = new Jeu(this, machine);
    ...
}

• dans un deuxième temps, nous modifions la fonction de réinitialisation de la scène. Rappelons-nous que l’objet scene est créé par la Classe Fenetre d’où la fonction InitialiserScene. Et que c’est la classe Sequence qui appellera ReInitialiserScene pour recommencer la scène.

void Scene::ReInitialiserScene()
{
    setFocusItem(joueur,Qt::OtherFocusReason);
    joueur->ReInitialiser();
    predateur->ReInitialiser();
}

N’oublions pas que l’action sur les touches s’applique sur l’objet désigné par setFocusItem.

Au démarrage du programme, l’objet libre se déplace suivant le trajet déterminé, et l’objet contrôlé, suivant le choix de l’utilisateur.

La suite de cette étude va nous montrer comment l’objet libre objet pourra changer d'attitude parce que nous lui imposerons un objectif qui l'obligera à modifier son trajet.

Dans cette classe, la fonction Inipredateur créée à la section précédente se résume à : predateur->Initialiser(QPointF(0,0));.

Cette classe est modifiée, car tous les objets mobiles ont, logiquement, des points départ et arrivée, nous déclarons les variables stockant ces points dans la section protected de cette classe pour qu'elles soient sécurisées, mais facilement disponibles par les classes héritières. Le fichier entête devient :

protected:
    ...
    QStateMachine *machine;
    QPointF pntdep, pntfin;
    void PointCible(const QPointF cible);

y figure aussi la déclaration de la fonction calculant le point cible, en rapport avec le pas de l'objet suiveur. Par convention celui-ci, ayant une vitesse constante déterminée par la valeur de son pas et la durée de l'animation, suivra une trajectoire « axe suiveur/cible » sur un segment égal à la valeur de son pas. À chaque fin d'animation, c'est-à-dire quand le suiveur atteint son point final, la position de la cible est collectée pour ajuster la nouvelle trajectoire. Mais en analysant le schéma, nous observons que pendant la durée du déplacement du suiveur en direction de la cible, celle-ci change de position, ce que le suiveur ignore puisqu'il est en cours de déplacement.

Nous constatons que les éléments en position -A- au début, se trouvent en position -B- à la fin de la durée du déplacement du suiveur. Nous en déduisons que si la durée est longue la position de la cible pourrait être beaucoup plus éloignée, nous devons alors privilégier une durée courte avec un pas minimum afin de provoquer un rajustement de la trajectoire plus fréquent. Pour le détail du calcul du nouveau point de fin de déplacement, voir le code source du fichier « objetmobile.cpp ».

Nous terminerons en ajoutant un traitement consécutif à la collision de l'objet suiveur avec la cible. Ce traitement sera de replacer l'objet suiveur à son origine et de reprendre la poursuite, la cible continuant son trajet. La solution que nous mettrons en œuvre consiste à manipuler un état supplémentaire avec la directive « Signals » des classes Qt. Une nouvelle classe de transition nous apparaît, elle aura comme fonction d'effectuer la transition entre l'état DeplacePrd et l'état ArretPrd en renvoyant le suiveur à sa position d'origine. Nous l'examinerons ultérieurement :

Dans l'entête, le constructeur est modifié pour communiquer à la classe le pointeur de l'objet joueur :

class Predateur : public ObjetMobile
{
    public:
    Predateur(Joueur *valptr);
...
    void PositionCible();
virtual bool TestCollision();

private:
...
Joueur  *pjoueur;
…

Nous ajoutons une fonction pour mettre à jour le point final du trajet qui cible la position du joueur, plus une fonction virtuelle pour tester la collision, et un pointeur sur l'objet joueur est stocké en « private ».

Les précédentes déclarations de variables :QPointF pntdepart, pntfin, pntfinsvd, pntdepsvd;ont été déplacées vers la classe parent Objetmobile que nous avons étudiée précédemment.

Dans le constructeur du fichier source, nous ajoutons une instance de la classe TrContact héritière de QSignalTransition exposée plus loin :

...
TrContact *dedans = new TrContact(this, avance);
avance->addTransition(dedans);
dedans->setTargetState(arrete);
...

La fonction void Predateur::PositionCible(){ PointCible(pjoueur->pos());nous retourne la position de la cible.

Contrairement au trajet du chapitre précédent, le point de fin étant variable, il n'est pas initialisé au début du jeu. C'est la classe Predateur qui initialisera ce point final. Dans le fichier source, la fonction Initialiser est donc modifiée pour fournir uniquement le point de départ, elle devient :

void Predateur::Initialiser(const QPointF& pdep)
{
    pntdep=pdep; pntfin=pdep;
    pntfin.setX( pntdep.rx()+1 );
...
}

toutefois pntfin est initialisé à ce niveau « par prudence ».

Puisque l'objet suiveur ne sera plus interrompu dans son déplacement, la mise à jour de son animation n'a plus à comporter de setStartvalue, cette instruction est validée au début du jeu et devient ensuite inutile puisqu'il suffit de changer le point final au fur et à mesure du trajet. La fonction MajMouvement devient :

void Predateur::MajMouvement()
{
    animationdelobjet->setEndValue(pntfin);
    animationdelobjet->start();
}

Quant au start, il est toujours nécessaire.

Et pour en terminer avec les nouvelles fonctions du source, nous implémentons celle qui recherche la collision entre l’objet predateur et la cible :

bool Predateur::TestCollision()
{
  QList<QGraphicsItem*> lstobjet = collidingItems( Qt::IntersectsItemBoundingRect );
    for(int i=0; i<lstobjet.count(); i++)
    {
        if( (ObjetImage*)pjoueur == (ObjetImage*)lstobjet.at(i) ) return true;
    }
    return false;
}

La fonction collidingItems nous renvoie tous les éléments graphiques en collision avec l'objet predateur. Le paramètre IntersectsItemBoundingRect définit comme contact tout item en intersection avec le rectangle de délimitation de l'élément. Ensuite, s'il y a une liste en retour, il suffit d'y chercher l'existence de la valeur du pointeur de la cible.

Comme précisé en début de cette section, le signal finished provoque l'activation de l'état ArretPrd pour réinitialiser la fin du trajet de l'objet. La fonction onEntry de cette classe est modifiée :

void ArretPrd::onEntry(QEvent *)
{
    predateur->PositionCible();
    emit RePositionner();
}

Le signal RePositionner est activé.

L'état provoque chez l'objet predateur la saisie de la nouvelle position de la cible et active le signal. Ce sera la seule modification dans cette classe.

Il est logique que c'est pendant le déplacement que s'effectuera le test de collision entre le suiveur et la cible. S'il y a contact, la classe DeplacePrd activera son signal Percussion. Dans l'entête nous insérons la directive d'implémentation du signal.

...
    ~DeplacePrd();
signals :
    void Percussion();
protected:
...

Dans le source, la fonction onEntry est modifiée pour le test de contact.

void DeplacePrd::onEntry(QEvent *)
{
    if(predateur->TestCollision())
        emit Percussion();
    else
        predateur->MajMouvement();
}

Dans les faits la fonction onEntry, appelée quand l'état est activé, démarre le déplacement qui sera ensuite géré par l’objet animationdelobjet. Il serait donc plus adéquat de réaliser le test à l'intérieur de cet objet, mais cela ne nous permettrait pas de manipuler les transitions avec la directive « signals » comme nous le verrons ci-dessous.

\section*{Créer d'}

Dans la perspective d'utiliser les classes du framework, nous bâtissons une classe héritière de QSignalTransition pour effectuer la transition entre l'état ArretPrd et l'état DeplacePrd lorsque ce dernier émet son signal Percussion.

La classe est du type : class TrContact : public QSignalTransition. La connexion du signal est établie dans le constructeur du source :

TrContact::TrContact(Predateur *vpredat, DeplacePrd *vdepl) : QSignalTransition( vdepl, SIGNAL(Percussion()) )
{
    predateur = vpredat;
}

Le pointeur de DeplacePrd est transmis au paramètre QObject*sender de QSignalTransition.

Lorsque la transition est requise, la fonction réimplémentée onTransition est exécutée :

void TrContact::onTransition(QEvent *)
{
    predateur->Initialiser(QPointF(0,0));
}

Nous avons étudié les états qui émettent des signaux, et des transitions qui répondent à ces signaux. Jusqu'à présent les objets sont créés au départ du logiciel et disparaissent à l'extinction du programme. Dans la mesure où nous avons en main tout ce qu'il faut savoir pour créer un objet avec un événement et le détruire, nous allons le faire dans les chapitres qui suivent…

Nous ajoutons à l’objet scene un objet de la classe Projectile qui sera déclenché par l’objet joueur, et dont la direction suivra le sens du déplacement. Nous utiliserons la classe de base QSignalTransition pour la transmission des informations entre états d'objets différents, et, pour la recherche d'un contact entre Projectile et Predateur, nous recourrons au signal valueChanged émis par l'animation :

Pour clarifier le diagramme ci-dessous, j'ai masqué les états précédemment définis de la classe Joueur puisqu'ils font partie d'un seul état Conteneur et qu'ils ne seront pas modifiés, seule sa nouvelle transition « envoyer » est indiquée. De même pour la classe Predateur qui reste inchangée :

Au démarrage de la séquence nos deux objets familiers se comportent comme auparavant, quant au nouvel objet projectile, il est initialisé à son état Arrete. L'ordre de tir est déclenché par la touche 'espace' qui transmet un signal récupéré par la classe Projectile et traité comme suit :

• le graphisme exécute une trajectoire rectiligne parallèle et de même direction qu'au parcours de l’objet joueur à l'instant du déclic ;
• le test de contact avec l’objet predateur est réalisé au cours de l'animation ;
• tant que l'état Avance de projectile est activé, il est impossible d'effectuer un nouveau déclenchement.

X-A-1. Modification de la classe Joueur▲

...
    void Tirer();
    virtual void MajMouvement();
signals:
    void OrdreDeTir();
private:
...

TransEtPan *pan = new TransEtPan(this, QEvent::KeyPress, Qt::Key_Space);
    conteneur->addTransition(pan);

void Joueur::Tirer()
{
    emit OrdreDeTir();
}

X-A-2. La transition TransEtPan▲

void TransEtPan::onTransition(QEvent *)
{
    joueur->Tirer();
}

X-A-3. Modification de la classe Scene▲

…
    addItem(predateur);
    projectile = new Projectile((QGraphicsItem*)predateur, joueur);
    projectile->hide();
    addItem(projectile);
...

X-A-4. La classe Projectile▲

connect(animationdelobjet, SIGNAL(valueChanged(QVariant)), this, SLOT(LeProjectileBouge(QVariant)) );

machine = new QStateMachine(this);
ArretPjl *arret = new ArretPjl(this, machine);
DeplacePjl *avance = new DeplacePjl(this, machine);

QSignalTransition *etpan = new QSignalTransition(pjoueur, SIGNAL(OrdreDeTir()));
arret->addTransition(etpan);
etpan->setTargetState(avance);

QSignalTransition *rearme = new QSignalTransition(animationdelobjet, SIGNAL(finished()) );
avance->addTransition(rearme);
rearme->setTargetState(arret);

QSignalTransition *dedans = new QSignalTransition(this, SIGNAL(Choc()));
avance->addTransition(dedans);
dedans->setTargetState(arret);

void Projectile::Initialiser()
{
    setPos( 0, 0 );
    hide();
    BougeToi();
}

void Projectile::LeProjectileBouge(const QVariant&)
{
    if( TestCollision() )
    {
        animationdelobjet->stop();
        emit Choc();
    }
}

if( pcible == lstobjet.at(i) )
// au lieu de :
if( (ObjetImage*)pjoueur == (ObjetImage*)lstobjet.at(i) )

X-A-5. État ArretPjl▲

void ArretPjl::onEntry(QEvent *)
{
    projectile->Initialiser();
}

X-A-6. État DeplacePjl▲

void DeplacePjl::onEntry(QEvent *)
{
    projectile->Tirer();
}

Dans la section précédente, nous avons lancé un objet qui, tant qu'il n'est pas stoppé, nous interdit d'en lancer un autre. Cela est dû au fait que depuis le début de cette étude, nous n'avons jamais détruit les objets créés, la réinitialisation de chacun d'eux les restaurant à leur origine. Pour cette section, nous créerons plusieurs occurrences de la classe Projectile, comme nous l'avons fait dans l'un des tests avec une série d’objets predateur, mais ces ajouts seront provoqués par le joueur, et s’autodétruiront à la fin de leur animation. En quelque sorte, nous étions en coup par coup, maintenant, passons au tir en rafale.

Puisque nous ne créons plus l'objet projectile au début de la séquence, nous créons une fonction dans l’objet scene pour réaliser cette opération en cours d'animation :

Pour la déclencher nous n'utiliserons plus l'émission du signal OrdreDeTir de la classe Joueur, mais nous modifierons sa fonction Tirer pour envoyer l'ordre.

X-B-1. Modification de la classe Joueur▲

TransEtPan *pan = new TransEtPan(this, QEvent::KeyPress, Qt::Key_Space);
conteneur->addTransition(pan);

void Joueur::Tirer()
{
    static_cast<Scene*>(pvue->scene())->AjouterProjectile();
}

X-B-2. Modification de la classe Scene▲

private:
...
    Projectile *projectile;
// remplacé par
    QList<Projectile*> lstprj;
...

public :
...
    void AjouterProjectile();
...
private :
...
    void TuerProjectile();
...

private slots:
    void FinDeProjectile();
    void ButAtteint();

...
    if (projectile) delete projectile;
remplacé par
    TuerProjectile();
...

connect(pproj, SIGNAL(Boum()), this, SLOT(ButAtteint()) );
connect(pproj, SIGNAL(Limite()), this, SLOT(FinDeProjectile()) );

X-B-3. Modification de la classe Projectile▲

ArretPjl *arret = new ArretPjl(this, machine);
DeplacePjl *avance = new DeplacePjl(this, machine);
AuBut *etpaf = new AuBut(this, machine);

QSignalTransition *dedans = new QSignalTransition(this, SIGNAL(Contact()) );
    avance->addTransition(dedans);
    dedans->setTargetState(etpaf);

QSignalTransition *manquer = new QSignalTransition(animationdelobjet, SIGNAL(finished()) );
    avance->addTransition(manquer);
    manquer->setTargetState(arret);

void Projectile::LeProjectileBouge(const QVariant&)
{
    if(TestCollision())
        emit Contact();
}

void AuBut::onEntry(QEvent *)
{
    projectile->Detruire();
}

void Projectile::Detruire()
{
    hide();Stop();
    pcible->Initialiser(QPointF(0,0));
    emit Boum();
}

void Projectile::Foirer()
{
    hide();
    Stop();
    emit Limite();
}