Un jeu de snake en 2D et tile mapping

Version imprimable

Bonjour a tous,

J'ai un projet a réaliser qui consiste a recoder le celebre jeu Snake en C++, avec pour GUI Qt.
Le 'core' de mon programme est deja code, il me transmet en parametre un tableau en deux dimensions d'entiers contenant des entiers (oh really? :mrgreen:) allant de 0 a 7, chaque entier correspondant a un element du jeu (0 = vide, 1 = mur, 2 = queue du serpent, 3 = corps, 4 = tete et 7 = pomme).

Le tableau de depart est celui ci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 2 3 3 4 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Mon problème est le suivant :
je souhaite pouvoir parcourir ce tableau d'entiers en affichant a chaque valeur rencontrée (0,1,2,3 ...) l'image qui lui correspond. J'ai déjà essaye et réussi a le faire en utilisant QGraphicsScenem QGraphicsView et QGraphicsItem.
L'affichage est le suivant :
http://i.imgur.com/zhxPR.png

Voila le code d’implémentation des images :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 QGraphicsItem *item; QPixmap image; int width = 0; int heigth = 0; for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { if (tab[i][j] == 1) { image.load("./res/mur.png", 0, Qt::AutoColor); item = scene->addPixmap(image); item->setPos(width, heigth); width += 20; } if (tab[i][j] == 4) { image.load("./res/tete.png", 0, Qt::AutoColor); item = scene->addPixmap(image); item->setPos(width, heigth); width += 20; } if (tab[i][j] == 2) { image.load("./res/queue.png", 0, Qt::AutoColor); item = scene->addPixmap(image); item->setPos(width, heigth); width += 20; } if (tab[i][j] == 3) { image.load("./res/corps.png", 0, Qt::AutoColor); item = scene->addPixmap(image); item->setPos(width, heigth); width += 20; } if (tab[i][j] == 7) { image.load("./res/apple.jpg", 0, Qt::AutoColor); item = scene->addPixmap(image); item->setPos(width, heigth); width += 20; } if (tab[i][j] == 0) width += 20; } heigth += 20; width = 0; } }
Je parcours mon tableau de case en case en checkant quel entier est contenu dans la case, et en y placant l'item (et donc l'image) correspondant, a la largeur (width) et la hauteur (heigth) donnée. Puis je décale la largeur de 20, les images faisant elles mêmes 20 pixels.
Si la case contient un 0, elle est donc vide, il n'y a rien a afficher, je decale la largeur de 20 et passe a la case suivante.

Mais lorsque je modifie la position de mon serpent, c'est a dire en modifiant la position des 2, 3 et 4 dans mon tableau, l'affichage dans ma fenetre lui ne bouge pas. Il reste tel qu'il est sur le screen ci dessus. En clair ma fenêtre n'est pas animée, elle reste a la position initiale du tableau.

Je pense que les items une fois positionnés dans ma scène, ne peuvent pas être chevauchés par de nouveaux items, et ainsi l'image reste fixe. Mais étant un débutant total en Qt, je ne suis pas du tout sur de ce raisonnement et surtout je n'ai aucune idée de comment résoudre mon problème.

Merci d'avance pour les réponses que vous pourrez m'apporter :)

13/03/2012, 17h05
johnlamericain

C'est une solution pas du tout optimisé tout ça sachant que certains de tes éléments ne bougent pas :)

Disons que tu as prévu une étape d'optimisation plus tard, essaye un

Code:

clear()

sur ta scène à chaque rafraichissement.
13/03/2012, 17h09
GreatTux

Hello,

Les items de ta scène peuvent être déplacés, superposés par d'autres etc. Pas de contraintes à ce niveau là.

Je pense que c'est plutôt un problème de conception.

Si tu veux pouvoir déplacer les items existants, tu dois garder un pointeur vers ton QGraphicsItem et ne pas en recréer un à chaque fois, est-ce bien ce que tu fais?
13/03/2012, 17h50
gbdivers

Idem, je pense que tu as un (très gros ?) problème de conception. Tu ne fais pas du tout de la POO là, tu as une fonction qui fait tout le boulot.
Il faudrait plutôt surcharger des QGraphicsPixmapItem pour faire ton snake (ou un QGraphicsGroupItem pour avoir plusieurs pixmaps), tes mures, ton sol, etc. Et définir un comportement pour chaque classe dérivée (la pomme disparait quand elle est avalée par le serpent, le serpent grandi quand il mange, meurt quand il se fait une bosse, etc.)

Wow tout d'abord merci a vous trois pour la rapidite de reaction!

J'etais sur que c'etait pas optimise :aie:

J'ai tente un scene->clear(); a chaque debut de boucle mais ca n'a pas fonctionne.

Pour ce qui est du pointeur, non j'en recreais bien un a chaque fois en effet (d'ailleurs je me rends compte que je ne vous ai pas mis tout le code, c'est maintenant chose faite : )

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
void    QtAff::AffMap(int **tab, int size, QGraphicsScene *scene)
{
  QPixmap image;
  int   width = 0;
  int   heigth = 0;
 
  for (int i = 0; i < size; i++)
    {
      for (int j = 0; j < size; j++)
        {
          if (tab[i][j] == 1)
            {
              image.load("./res/mur.png", 0, Qt::AutoColor);
              _mur = scene->addPixmap(image);
              _mur->setPos(width, heigth);
              width += 20;
            }
          if (tab[i][j] == 4)
            {
              image.load("./res/tete.png", 0, Qt::AutoColor);
              _tete = scene->addPixmap(image);
              _tete->setPos(width, heigth);
              width += 20;
            }
          if (tab[i][j] == 2)
            {
              image.load("./res/queue.png", 0, Qt::AutoColor);
              _queue = scene->addPixmap(image);
              _queue->setPos(width, heigth);
              width += 20;
            }
          if (tab[i][j] == 3)
            {
              image.load("./res/corps.png", 0, Qt::AutoColor);
              _corps = scene->addPixmap(image);
              _corps->setPos(width, heigth);
              width += 20;
}
          if (tab[i][j] == 4)
            {
              image.load("./res/tete.png", 0, Qt::AutoColor);
              _tete = scene->addPixmap(image);
              _tete->setPos(width, heigth);
              width += 20;
            }
          if (tab[i][j] == 2)
            {
              image.load("./res/queue.png", 0, Qt::AutoColor);
              _queue = scene->addPixmap(image);
              _queue->setPos(width, heigth);
              width += 20;
            }
          if (tab[i][j] == 3)
            {
              image.load("./res/corps.png", 0, Qt::AutoColor);
              _corps = scene->addPixmap(image);
              _corps->setPos(width, heigth);
              width += 20;
            }
          if (tab[i][j] == 7)
            {
              image.load("./res/apple.jpg", 0, Qt::AutoColor);
              _apple = scene->addPixmap(image);
              _apple->setPos(width, heigth);
              width += 20;
            }
          if (tab[i][j] == 0)
            width += 20;
        }
      heigth += 20;
      width = 0;
    }
}
 
int     main(int argc, char *argv[])
{
  QApplication app(argc, argv);
  QGraphicsScene *scene = new QGraphicsScene;
  QtAff Aff;
  int size = 25;
  int **tab = Aff.creat_tab(size);
  int dir = UP;
  int cpt = 0;
 
  Aff.setWidth(520);
  Aff.setHeigth(520);
  while (1)
    {
      scene->clear();
      Aff.AffMap(tab, size, scene);
      QGraphicsView vue(scene);
      vue.setFixedSize(Aff.getWidth(), Aff.getHeigth());
      vue.setWindowTitle("Snake");
      vue.show();
      return app.exec();
      Aff.decal(tab, size, dir); // sert a decaler le serpent dans mon tableau d'entiers
   }
}

J'ai ecoute ton conseil et ai cree dans ma classe 5 pointeurs representant les 5 items dont j'ai besoin (apple, tete, queue, corps et mur). Changement par rapport a avant donc ou j'utilisais un seul et meme item pour chaque image et qui etait une variable temporaire.
Mais l'affichage reste tout de meme statique :(

Devrais-je utiliser un seul et meme pointeur d'item pour toutes les images et le placer dans ma classe?

Edit : Pour ce qui est de la conception ne t’inquiète pas, ceci n'est qu'une ebauche et n'est pas du tout finalise, le code sera decoupe et surcharge plus tard, pour l'instant mon seul but est de pouvoir afficher en dynamique graphiquement mon tableau d'entiers.
Si tu préfères la partie 'core' (gestion du jeu) est faite, il ne me reste que la partie graphique Qt a finir.

Merci en tous cas de m'avoir déjà éclairé sur certains points.

14/03/2012, 00h31
Wanabee

(Desole du doublon)

Pour faire plus clair je veux juste que ma fonction AffMap() puisse parcourir mon tableau a deux dimensions et afficher 'bêtement' l'image qui correspond a la valeur de chaque case. C'est tout.

Bonjour,

Dans votre main(), vous avez :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 { ... Aff.setWidth(520); Aff.setHeigth(520); while (1) { scene->clear(); Aff.AffMap(tab, size, scene); QGraphicsView vue(scene); vue.setFixedSize(Aff.getWidth(), Aff.getHeigth()); vue.setWindowTitle("Snake"); vue.show(); return app.exec(); Aff.decal(tab, size, dir); // sert a decaler le serpent dans mon tableau d'entiers } }
Tel que la boucle est conçue, vous faite l'équivalent de :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 { ... Aff.setWidth(520); Aff.setHeigth(520); scene->clear(); Aff.AffMap(tab, size, scene); QGraphicsView vue(scene); vue.setFixedSize(Aff.getWidth(), Aff.getHeigth()); vue.setWindowTitle("Snake"); vue.show(); return app.exec(); }
... ce qui n'est en réalité pas une boucle. Vous faites un nettoyage inutile de la scène, vous placez tous les éléments dans la scène, vous créez la vue et vous l'affichez à l'écran.

Jolie norme E... GNU. ;)

Bonne continuation,
Amnell.

Bonjour,

Merci pour votre reponse :)

Qt etant tout nouveau pour moi (j'ai commence il y a deux jours), je ne saisis pas encore completement l'usage de toutes ses classes et certaines de mes utilisations doivent vous faire bondir j'en ai conscience :?

J'ai quelques peu avance dans mon code, et le resultat est different :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
void    QtAff::AffMap(int **tab, int size, QGraphicsScene *scene)
{
  QPixmap       image;
  int   width = 0;
  int   heigth = 0;
 
  for (int i = 0; i < size; i++)
    {
      for (int j = 0; j < size; j++)
        {
          if (tab[i][j] == 1)
            {
              image.load("./res/mur.png", 0, Qt::AutoColor);
              item_mur = scene->addPixmap(image);
              item_mur->setPos(width, heigth);
              width += 20;
            }
          if (tab[i][j] == 4)
            {
              image.load("./res/tete.png", 0, Qt::AutoColor);
              item_tete = scene->addPixmap(image);
              item_tete->setPos(width, heigth);
              width += 20;
            }
          if (tab[i][j] == 2)
            {
              image.load("./res/queue.png", 0, Qt::AutoColor);
              item_queue = scene->addPixmap(image);
              item_queue->setPos(width, heigth);
              width += 20;
            }
          if (tab[i][j] == 3)
            {
              image.load("./res/corps.png", 0, Qt::AutoColor);
              item_corps = scene->addPixmap(image);
              item_corps->setPos(width, heigth);
              width += 20;
            }
          if (tab[i][j] == 7)
            {
              image.load("./res/apple.jpg", 0, Qt::AutoColor);
              item_apple = scene->addPixmap(image);
              item_apple->setPos(width, heigth);
              width += 20;
            }
if (tab[i][j] == 0)
            width += 20;
        }
      heigth += 20;
      width = 0;
    }
}
 
int     main(int argc, char *argv[])
{
  QApplication app(argc, argv);
  QGraphicsScene *scene = new QGraphicsScene; //creation de la scene                                                                                                                                                                         
  QtAff Aff;
  int size = 25;
  int **tab = Aff.creat_tab(size);
  int dir = UP;
  int cpt = 0;
  QGraphicsView vue(scene);
 
  Aff.initWindow();
  vue.setFixedSize(Aff.getWidth(), Aff.getHeigth());
  vue.setWindowTitle("Snake");
  while (1)
    {
      Aff.AffMap(tab, size, scene);
      vue.show();
      app.exec();
      sleep(1);
      Aff.decal(tab, size, dir);
      cpt++;
      if (cpt == 3)
        dir = LEFT;
      if (cpt == 7)
        dir = DOWN;
      if (cpt == 10)
        dir = RIGHT;
    }
  return app.exec();
}

J'ai donc retire la création de ma vue et son paramétrage de ma boucle, et retire le return app.exec() pour ne laisser qu'un app.exec().

Le resultat est le suivant : ma premiere fenetre est la meme que lors de mon premier post, par contre lorsque je la ferme, une deuxieme fenetre apparait, ou on voit que mon serpent s'est deplace, mais que les anciennes images de son corps elles sont restees. Illustration :
http://i.imgur.com/RKJVa.png
http://i.imgur.com/9rGf1.png
http://i.imgur.com/4t5ha.png

Pour au final donner :

http://i.imgur.com/fr2a0.png

Mes problemes sont donc les suivants :
Comment supprimer tous les items de ma scene apres chaque affichage, afin d'eviter que les items ne se superposent? (j'ai essaye de faire un scene->removeItem(item) pour mes 5 pointeurs sur item apres chaque affichage, mais ca segfault :aie:)
Pourquoi l'affichage se fait-il en plusieurs fenetres et non pas en une seule qui s'actualise?

Merci d'avance pour le temps que vous m'accorderez, et bonne journée !

PS : Amnell je suis perce a jour :roll:

14/03/2012, 10h03
Amnell
Re,
Code:

1 2 vue.show(); app.exec();
Ces deux éléments sont les fautifs ; je vous redirige donc vers la doc :

http://qt.developpez.com/doc/4.7/qapplication/#exec
http://qt.developpez.com/doc/4.7/qwidget/#visible-prop

Citation:

(j'ai essaye de faire un scene->removeItem(item) pour mes 5 pointeurs sur item apres chaque affichage, mais ca segfault )

Notez deux choses :
- RemoveItem() ne libère pas la mémoire, il retire juste l'élément de la scène ;
- Chacun de vos appels à AffMap change l'adresse sur laquelle pointe chacun de vos pointeurs.
Bonne continuation,
Amnell.
14/03/2012, 10h11
Wanabee

Merci pour la doc, même si ne maîtrisant pas du tout la technologie j'ai peur du temps qu'il me faudra pour trouver ce que je cherche, je dois avouer qu'elle est complète.

Pour la suppression des pointeurs c'est chose faite, j'ai intégré ma scène dans ma classe, et je supprime mes items juste après chaque affichage (donc avant un nouvel appel a AffMap, ainsi pas de changement d'adresse). Cela ne marche touours pas comme je le voudrais mais au moins il y a du progres :mrgreen:

Je vais continuer a chercher dans cette voie, je reviens vers vous si j'ai du nouveau, merci beaucoup !
14/03/2012, 12h01
Wanabee

Malgre mes recherches impossible de trouver comment avoir une seule et meme fenetre que je pourrai vider puis re-remplir, un indice? :?
14/03/2012, 12h07
Amnell

Citation:

Envoyé par Wanabee

Malgre mes recherches impossible de trouver comment avoir une seule et meme fenetre que je pourrai vider puis re-remplir, un indice? :?

Avec Qt, une fenêtre est une classe dérivée de QWidget qui a été show() : faites donc un unique appel à show().

App.exec(), pour faire simple, c'est une sorte de while (1) qui récupère et transmet les événements (KeyPress, MouseMove, MousePress, CloseEvent, etc.), et qui bloque donc la fermeture du programme (si vous avez fait votre première année dans l'école où vous êtes, vous avez dû faire de la mlx ; avec cette lib, l'équivalent est mlx_loop(mlx_ptr)). C'est pour cela que l'on fait return app.exec().

Bonne continuation,
Amnell.
14/03/2012, 12h26
Wanabee

Le souci est que justement je n'ai pas eu a utiliser la mlx l’année dernière :aie: ce sont donc mes premiers pas dans le domaine du graphique, voila pourquoi mon raisonnement est étrange et mes difficultés de compréhension grandes :(.

Le problème est que mon décalage a besoin de la boucle infinie while(1) présente dans mon main, et je ne vois donc pas ou placer cet unique appel a show(), vu qu'en dehors de la boucle il ne sera pas appelé.

Merci pour les explications sur app.exec() , c'etait a peu pres ce que j'avais compris mais ca parait deja plus clair. Et ca explique pourquoi est ce que j'ai besoin de fermer la fenêtre pour passer au décalage suivant. Mais je n'ai aucune idee de comment actualiser mon affichage, du fait de cette boucle infinie :?

Merci en tous cas pour l'aide que vous m'apportez!

PS : J'ai modifie le code en ajoutant des removeItems(), et voici le résultats (toujours en plusieurs fenêtres néanmoins)

http://i.imgur.com/ebu4E.png
http://i.imgur.com/3uyyd.png
http://i.imgur.com/sudgy.png
http://i.imgur.com/ekQCM.png

J'ai trouve mon probleme concernant la suppression des items, il s'agissait en fait du fait que j'ai 2 items 'corps' sur ma scene et que je n'en supprimai qu'un seul. En effet, lors de mon affichage, la valeur du pointeur du premier corps est ecrasee par la valeur du deuxieme.

On le voit ici :
Code:

1 2 3 4 5 6 7 if (tab[i][j] == 3) // si ma case est egale a 3, c'est a dire le corps du serpent { image.load("./res/corps.png", 0, Qt::AutoColor); item_corps = scene->addPixmap(image); // je set l'item avec l'image du corps, mais etant donne que le serpent a 2 cases corps, lors de l'affichage du deuxieme corps, la valeur du premier est ecrasee item_corps->setPos(width, heigth); width += 20; }
La première case du corps est donc perdue et impossible a supprimer. J'ai trouve une solution (mais elle n'est que temporaire) qui consiste a creer un deuxième pointeur 'corps' afin de stocker la valeur du premier corps. Mais cette solution n'est pas viable car il m'est impossible de créer un pointeur pour chaque partie du corps du Snake, etant donne qu'il est destine a grandir.

Creer un tableau pour stocker chaque adresse des pointeurs sur item_corps me parait sale et démesuré, mais je n'ai pas d'autres idees pour le moment...

14/03/2012, 13h35
Amnell

Re,

Le souci est que vous partez du principe que l'affichage ne peut être effectué qu'à partir du moment où toute la scène a été remplie et qu'il faut tout effacer pour pouvoir effectuer une modification. Une solution simple est de créer la scène, de créer la vue, de lier les deux puis d'afficher la vue avec show(). Alors, vous pouvez garnir la scène de tous les objets que vous souhaitez afficher ; une peinture de la scène sera effectuée après l'appel de la fonction update() ou repaint() (sauf si cela s'effectue automatiquement, je ne me souviens plus).

Plutôt que de passer par des pointeurs simples pour gérer les composantes du snake, pourquoi ne pas utiliser une des classes jouant le rôle de conteneur d'éléments (QList/QVector/autre selon les besoins) ?

Bonne continuation,
Amnell.

EDIT : la perspective d'une liste chaînée circulaire pourrait également être envisagée.
14/03/2012, 14h56
Amnell
Citation:

Envoyé par Wanabee

Le problème est que mon décalage a besoin de la boucle infinie while(1) présente dans mon main, et je ne vois donc pas ou placer cet unique appel a show(), vu qu'en dehors de la boucle il ne sera pas appelé.

Merci pour les explications sur app.exec() , c'etait a peu pres ce que j'avais compris mais ca parait deja plus clair. Et ca explique pourquoi est ce que j'ai besoin de fermer la fenêtre pour passer au décalage suivant. Mais je n'ai aucune idee de comment actualiser mon affichage, du fait de cette boucle infinie

J'ai survolé rapidement cela ; j'apporte donc une réponse. Faire une boucle infinie avec un sleep d'une seconde dedans pourrait mener à penser que ce n'est pas la bonne façon de faire. Avec Qt, on a QTimer qui peut permettre d'appeler une fonction toutes les x ms :
Code:

1 2 3 4 QTimer timer; timer.setInterval(1000); QObject::connect(&timer, SIGNAL(timeout()), classe, SLOT(update_scene())); timer.start();
gbdivers parlait plus haut de problème de conception, comme quoi vous faites du C++ mais que vous traitez tout dans une fonction. Je reprends donc ce qu'il dit : il serait intéressant de faire un arbre de classes par exemple pour le snake, avec une classe mère globale à tous les éléments (murs, morceau de serpent, tête du serpent, etc.) et qui aurait des dérivées (les éléments donnés précédemment). De là, chaque sous-classe aurait un comportement particulier (la tête en contact avec une pomme/mur). Vu que le projet est un projet de C++, je suis certain que les correcteurs seraient intéressés par ce type de chose et que cela déteindrait sur la note.

Je m'explique également sur l'EDIT fait sur le post précédent quand je parlais de liste chaînée circulaire : le souci que pose votre architecture actuelle est que vous ré-allouez toutes les secondes un objet pour ensuite le positionner devant. Alors, vous retirez le dernier élément. Avec une liste chaînée circulaire, on aurait un référentiel vers la tête. À chaque mouvement, on déplacerait le référentiel de la tête en disant que le dernier devient le premier (donc l'ancien premier devient le deuxième). Du coup, l'unique item qui se déplacerait serait le dernier qui se placerait devant le premier (je ne sais pas si c'est très clair).
Code:

1 2 3 4 5 6 7 8 9 10 O OO // Mouvement : OO O // Le dernier item passe devant le premier.
Bonne continuation,
Amnell.
14/03/2012, 15h41
Wanabee

Citation:

Envoyé par Amnell

Re,

Le souci est que vous partez du principe que l'affichage ne peut être effectué qu'à partir du moment où toute la scène a été remplie et qu'il faut tout effacer pour pouvoir effectuer une modification. Une solution simple est de créer la scène, de créer la vue, de lier les deux puis d'afficher la vue avec show(). Alors, vous pouvez garnir la scène de tous les objets que vous souhaitez afficher ; une peinture de la scène sera effectuée après l'appel de la fonction update() ou repaint() (sauf si cela s'effectue automatiquement, je ne me souviens plus).

En effet vous m'avez bien cerne :roll:, je vais donc tenter de faire comme cela. (même si tout recommencer ou presque ne m;enchante guère le projet étant a rendre sous tres peu x) )

Citation:

Envoyé par Amnell

Plutôt que de passer par des pointeurs simples pour gérer les composantes du snake, pourquoi ne pas utiliser une des classes jouant le rôle de conteneur d'éléments (QList/QVector/autre selon les besoins) ?

Bonne continuation,
Amnell.

EDIT : la perspective d'une liste chaînée circulaire pourrait également être envisagée.

Concernant les conteneurs je crois qu'il y a eu meprise. Mon projet consiste a creer un core qui est le coeur du programme, et a creer separement des fonctions s'occupant de l'affichage graphique. Mon core est d'ores et deja pret et fonctionnel, ma derniere tache n'est autre que de gerer l'affichage du tableau + la gestion des touches. Le reste de l'algo est fait.
Ma boucle infinie decalant le serpent n'est donc que temporaire, c'est un moyen rapide de tester mon affichage, a terme ils devront disparaitre. (car deja present dans le core). Cette boucle ne sera pas presente dans mon code final, c'est le core qui s'occupera du decalage du serpent et appellera ma fonction AffMap pour afficher le tableau.

Mon travail sur Qt consiste donc 'juste' a faire une fonction AffMap qui prend en paramètre un tableau d'entiers (envoyé par le core) et qui parcourt ce tableau en inserant les images correspondantes. Mon travail ici ne concerne que le graphique, pas le coeur de l'algo.

En tous cas merci beaucoup pour l'attention que vous prêtez a mon cas, je m'en veux juste de ne pas avoir les compétences nécessaires pour comprendre et appliquer tout ce qui a été dit sur ce topic car je suis sur que ca marcherait parfaitement...
14/03/2012, 15h47
Amnell

Citation:

Envoyé par Wanabee

En effet vous m'avez bien cerne :roll:, je vais donc tenter de faire comme cela. (même si tout recommencer ou presque ne m;enchante guère le projet étant a rendre sous tres peu x) )

En même temps, si ce n'est "que" l'affichage qui est à réaliser, cela ne devrait pas prendre beaucoup de temps. Avec Qt, le ré-affichage est géré automatiquement, il n'y a pas d'expose à gérer ou autre. Une fois qu'on à placé quelque chose à l'écran, ça y reste jusqu'à ce qu'on retire l'élément en question.
14/03/2012, 15h58
Wanabee

Surement pour vous :mrgreen: mais je n'ai pas encore la 'logique' Qt et j'avance donc a tatons.

Procedons par etapes :

1- J'appelle dans mon main une fonction createScene()
2- Cette fonction me cree une scene, puis une vue en la liant a ma scene
3- J'affiche ma fenetre via show() a la fin de ma fonctione createScene()
4- J'entre dans la boucle infinie de mon main en commencant par appeler AffMap() qui va ajouter des items sur ma scene comme fait precedemment
5- J'update ma fenetre via la fonction membre update()
6- Je supprime mes items (reste le probleme de comment supprimer tous les items du corps du serpent)
7- Je décale la position du serpent

Les étapes 4 5 6 et 7 se répétant car étant positionnées dans la boucle infinie.

Cela vous parait-il viable?

EDIT : Je viens de tester et l'appel a show() seul ne suffit pas a creer un fenetre, je suppose que vous le saviez mais moi non :mrgreen:
Ma boucle infinie empechant l'execution du return app.exec(), je ne vois pas comment afficher ma fenetre. J'ai cru comprendre qu'en utilisant un QTimer a 0 cela etait possible mais je n'en suis pas sur
14/03/2012, 16h26
Amnell
Citation:

Envoyé par Wanabee

Surement pour vous :mrgreen: mais je n'ai pas encore la 'logique' Qt et j'avance donc a tatons.

Procedons par etapes :

1- J'appelle dans mon main une fonction createScene()
2- Cette fonction me cree une scene, puis une vue en la liant a ma scene
3- J'affiche ma fenetre via show() a la fin de ma fonctione createScene()
4- J'entre dans la boucle infinie de mon main en commencant par appeler AffMap() qui va ajouter des items sur ma scene comme fait precedemment
5- J'update ma fenetre via la fonction membre update()
6- Je supprime mes items (reste le probleme de comment supprimer tous les items du corps du serpent)
7- Je décale la position du serpent

Les étapes 4 5 6 et 7 se répétant car étant positionnées dans la boucle infinie.

Cela vous parait-il viable?

Je n'aime pas l'idée de faire une boucle infinie avec un sleep dans le sens où cela bloque complètement le process (qui - sauf erreur de ma part - ne peut donc pas faire en interne ses manipulations d'affichage, etc.). Un timer qui appelle une fonction toutes les secondes est bien mieux dans le sens où ça ne bloque pas la boucle principale (app.exec()) et donc, par conséquent, l'affichage. Pour illustrer, sous Windows ou autre système gérant les freezes des fenêtres, avec un sleep de 1 seconde, la fenêtre ne cesserait de freezer et de virer au blanc car les events seraient traités en retard (voire pas du tout).

Citation:

Envoyé par Wanabee

EDIT : Je viens de tester et l'appel a show() seul ne suffit pas a creer un fenetre, je suppose que vous le saviez mais moi non :mrgreen: et j'ai beau lire les pages de doc je ne comprends pas pourquoi.

Cela ressemble à un problème de durée de vie. Dans un main, on peut créer une variable de type QWidget et faire un show(). Grâce à app.exec(), la variable ne serait pas détruite avant la fermeture de l'application. Dans une autre fonction, il faudrait créer un pointeur :
Code:

1 2 3 QWidget *win = new QWidget(); win->resize(200, 300); win->show();
À moins que ce ne soit votre sleep qui bloque l'ouverture.

Bonne continuation,
Amnell.

J'ai ecoute vos conseils afin de restructurer mon code de facon plus optimisee, et voila ce que ca donne :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
 
int     main(int argc, char *argv[])
{
  QApplication app(argc, argv);
  QtAff Aff;
 
  Aff.boucle();
  return app.exec();
}
 
void    QtAff::boucle()
{
  int size = 25;
  int **tab = creat_tab(size);
  int dir = UP;
  int cpt = 0;
  QTimer *timer = new QTimer();
 
  //  QObject::connect(timer, SIGNAL(timeout()), this, SLOT(update()));                                                                                                                                                                      
  timer->start(1000);
  createScene();
  AffMap(tab, size);                                                                                                                                                                                                                                    
  window->show();
  cpt++;
  if (cpt == 3)
    dir = LEFT;
  if (cpt == 7)
    dir = DOWN;
  if (cpt == 10)
    dir = RIGHT;                                                                                                                                                                                                                                      
}
 
void    QtAff::createScene()
{
  window = new QWidget();
  scene = new QGraphicsScene(window);
  vue = new QGraphicsView(getScene(), window);
 
  initWindow(window);
}
 
void    QtAff::initWindow(QWidget *window)
{
  setWidth(520);
  setHeigth(520);
  setApple(0);
  setTete(0);
  setCorps(0);
  setQueue(0);
  setMur(0);
  window->resize(getWidth(), getHeigth());
  window->setWindowTitle("Snake");
}
 
void    QtAff::AffMap(int **tab, int size)
{
  QPixmap       image;
  int   width = 0;
  int   heigth = 0;
 
  for (int i = 0; i < size; i++)
    {
      for (int j = 0; j < size; j++)
        {
          if (tab[i][j] == 1 && getMur() == 0)
            {
              image.load("./res/mur.png", 0, Qt::AutoColor);
              item_mur = scene->addPixmap(image);
              item_mur->setPos(width, heigth);
              width += 20;
            }
          if (tab[i][j] == 4)
            {
              image.load("./res/tete.png", 0, Qt::AutoColor);
              item_tete = scene->addPixmap(image);
              item_tete->setPos(width, heigth);
              setTete(1);
              width += 20;
            }
          if (tab[i][j] == 2)
            {
              image.load("./res/queue.png", 0, Qt::AutoColor);
              item_queue = scene->addPixmap(image);
              item_queue->setPos(width, heigth);
              setQueue(1);
              width += 20;
            }
          if (tab[i][j] == 3)
            {
              image.load("./res/corps.png", 0, Qt::AutoColor);
              item_corps = scene->addPixmap(image);
              item_corps->setPos(width, heigth);
              setCorps(getCorps() + 1);
              width += 20;
            }
          if (tab[i][j] == 7)
            {
              image.load("./res/apple.jpg", 0, Qt::AutoColor);
              item_apple = scene->addPixmap(image);
              item_apple->setPos(width, heigth);
              setApple(1);
              width += 20;
            }
          if (tab[i][j] == 0)
            width += 20;
        }
      heigth += 20;
      width = 0;
    }
  setMur(1);
}

J'ai donc supprime la boucle infinie, le code tel quel affiche une fenetre comme celle que j'avais poste lors de mon premier message.
Le probleme survient lorsque je decommente la ligne du connect()

Code:

1
2
3
main.cpp:245:66: erreur: no matching function for call to ‘QObject::connect(QTimer*&, const char [11], QtAff* const, const char [10])’
/usr/include/QtCore/qobject.h:198:17: note: candidats sont: static bool QObject::connect(const QObject*, const char*, const QObject*, const char*, Qt::ConnectionType)
/usr/include/QtCore/qobject.h:313:13: note:                 bool QObject::connect(const QObject*, const char*, const char*, Qt::ConnectionType) const

Apparemment le pointeur sur QTimer ne serait pas reconnu comme un objet valable pour la methode connect(). Or la doc de QTimer (http://qt-project.org/doc/qt-4.8/QTimer.html#details) indique exactement le meme code ...

Je pense que si ce code arrive a compiler, je pourrai appeler la methode decal() toutes les secondes et pourquoi pas avoir (enfin) mon affichage dynamique ? :cry::calim2:

14/03/2012, 20h36
Amnell

Bonsoir,

J'aurais également besoin de voir l'architecture du/des header(s) associé(s) afin de voir s'il n'y a pas une erreur liée.

Bonne soirée,
Amnell.

Je comprends meme pas comment j'ai pu oublier 8O

Les voila :
Code:

1 2 3 4 5 6 #include <QtGui> #include <QObject> #include <QTimer> #include <QApplication> #include <iostream> #include "QtAff.hh"

14/03/2012, 21h29
Amnell

Par headers, j'entendais les fichiers d'en-tête, soit les .h.

Hum tres bien, meme si je comprends pas vraiment en quoi cela peut vous aider x)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
class   QtAff
{
 
private:
  int   _mywidth;
  int   _myheigth;
 
  /* Images */
private:
  QGraphicsItem *item_apple;
  QGraphicsItem *item_mur;
  QGraphicsItem *item_corps;
  QGraphicsItem *item_tete;
  QGraphicsItem *item_queue;
  int   _apple;
  int   _mur;
  int   _corps;
  int   _queue;
  int   _tete;
 
private:
  QGraphicsScene *scene;
  QWidget       *window;
  QGraphicsView *vue;
 
  /* Tableau */
public:
  void  decal(int **tab, int size, int dir);
  void  move_begin(int **tab, int dir);
  void  move_end(int **tab, int size);
  void  search_line(int **tab, int size, int to_search);
  int   **creat_tab(int size);
  void  init_tab(int **tab, int size);
  void  print_tab(int **tab, int size);
 
  /*    Qt      */
public:
  void  AffMap(int **tab, int size);
  void  initWindow(QWidget *window);
  void  removeItemScene();
  void  boucle();
  void  createScene();
  QGraphicsScene        *getScene() const;
 
  /* Setters */
public:
  void  setWidth(int width);
  void  setHeigth(int heigth);
  void  setApple(int apple);
  void  setMur(int mur);
  void  setCorps(int corps);
  void  setTete(int tete);
  void  setQueue(int queue);
 
  /* Getters */
public:
  int   getWidth() const;
  int   getHeigth() const;
 
  int   getApple() const;
  int   getTete() const;
  int   getCorps() const;
  int   getQueue() const;
  int   getMur() const;
 
};

14/03/2012, 23h52
Amnell
Bonsoir,

Il vous manque quelques éléments dans votre fichier header (j'entends la déclaration de classe dans le .h). Je vous renvoie donc sur un court article traitant les connexion signaux/slots :

http://matthieu-brucher.developpez.c...t/signal-slot/

Ou pour faire court :
- QtAff doit être une classe dérivée de QObject ;
- La macro Q_OBJECT doit être présente pour connecter un signal à un slot de la classe.
L'erreur donnée est donc assez explicite :

Citation:

main.cpp:245:66: erreur: no matching function for call to ‘QObject::connect(QTimer*&, const char [11], QtAff* const, const char [10])’

Le paramètre QtAff* est invalide car la classe n'est pas dérivée de QObject.

Bonne soirée,
Amnell.
15/03/2012, 00h20
Troudhyl

De toute façon je ne crois pas que tu veuilles appeler "update" sur ton objet QtAff (this) qui n'a rien de graphique.

Honte a moi, je l'avais pourtant vu dans le tuto que j'ai suivi mais cela m'est sorti de l'esprit entre temps ><

@Troudhyl : Non en effet c'etait ma fonction membre decal() ^^ c'etait juste un test.

Merci beaucoup Amnell ! :D :D :ccool: Le QTimer a fonctionne et j'ai maintenant une seule et meme fenêtre qui s'actualise, champagne !

Le code a ete quelques peu modifie et ressemble un peu plus a de la POO (enfin je crois :?):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
void    QtAff::AffMap()
{
  QPixmap       image;
  int   width = 0;
  int   heigth = 0;
 
  for (int i = 0; i < _size; i++)
    {
      for (int j = 0; j < _size; j++)
        {
          if (_tab[i][j] == 1 && getMur() == 0)
            {
              image.load("./res/mur.png", 0, Qt::AutoColor);
              item_mur = scene->addPixmap(image);
              item_mur->setPos(width, heigth);
              width += 20;
            }
          if (_tab[i][j] == 4)
            {
              image.load("./res/tete.png", 0, Qt::AutoColor);
              item_tete = scene->addPixmap(image);
              item_tete->setPos(width, heigth);
              setTete(1);
              width += 20;
            }
          if (_tab[i][j] == 2)
            {
              image.load("./res/queue.png", 0, Qt::AutoColor);
              item_queue = scene->addPixmap(image);
              item_queue->setPos(width, heigth);
              setQueue(1);
              width += 20;
            }
          if (_tab[i][j] == 3)
            {
              image.load("./res/corps.png", 0, Qt::AutoColor);
              item_corps = scene->addPixmap(image);
              item_corps->setPos(width, heigth);
              setCorps(getCorps() + 1);
              width += 20;
            }
          if (_tab[i][j] == 7)
            {
              image.load("./res/apple.jpg", 0, Qt::AutoColor);
              item_apple = scene->addPixmap(image);
              item_apple->setPos(width, heigth);
              setApple(1);
              width += 20;
            }
          if (_tab[i][j] == 0)
            width += 20;
        }
      heigth += 20;
      width = 0;
}
      heigth += 20;
      width = 0;
    }
  setMur(1);
}
 
void    QtAff::initWindow()
{
  createScene();
  setWidth(520);
  setHeigth(520);
  setApple(0);
  setTete(0);
  setCorps(0);
  setQueue(0);
  setMur(0);
  setCpt(0);
  setSize(25);
  setTab();
  setDir(UP);
  window->resize(getWidth(), getHeigth());
  window->setWindowTitle("Snake");
}
 
QGraphicsScene  *QtAff::getScene() const
{
  return scene;
}
 
void    QtAff::removeItemScene()
{
  if (getApple() != 0)
    {
      std::cout << "remove apple" << std::endl;
      scene->removeItem(item_apple);
      setApple(0);
    }
 }
  if (getCorps() != 0)
    {
      scene->removeItem(item_corps);
      setCorps(getCorps() - 1);
    }
  if (getTete() != 0)
    {
      std::cout << "remove tete" << std::endl;
      scene->removeItem(item_tete);
      setCorps(0);
    }
  if (getQueue() != 0)
    {
      std::cout << "remove queue" << std::endl;
      scene->removeItem(item_queue);
      setQueue(0);
    }
}
 
void    QtAff::createScene()
{
  window = new QWidget();
  scene = new QGraphicsScene(window);
  vue = new QGraphicsView(getScene(), window);
}
void    QtAff::affichage()
{
  window->show();
}
 
void    QtAff::boucle()
{
  AffMap();
  _cpt++;
  if (_cpt == 3)
_dir = LEFT;
  if (_cpt == 7)
    _dir = DOWN;
  if (_cpt == 10)
    _dir = RIGHT;
  decal();
}
 
int     main(int argc, char *argv[])
{
  QApplication app(argc, argv);
  QtAff *Aff = new QtAff;
  QTimer *timer = new QTimer();
 
  Aff->initWindow();
  QObject::connect(timer, SIGNAL(timeout()), Aff, SLOT(removeItemScene()));
  QObject::connect(timer, SIGNAL(timeout()), Aff, SLOT(boucle()));
  QObject::connect(timer, SIGNAL(timeout()), Aff, SLOT(affichage()));
  timer->start(1000);
  return app.exec();
}

Je me retrouve donc confronte a mon ancien problème a savoir la suppression des items, le déplacement du serpent se faisant actuellement comme suit :

http://i.imgur.com/ebu4E.png
http://i.imgur.com/3uyyd.png
http://i.imgur.com/sudgy.png
http://i.imgur.com/ekQCM.png

(mais en une seule fenetre).

On voit que le problème se situe au niveau de la suppression de la première partie du corps du serpent. Il me faudrait un moyen de stoker en mémoire les adresses des pointeurs sur les items_corps afi n de pouvoir les supprimer un a un et les remplacer par des nouveaux.

Merci pour tout ce temps que vous m'accordez et bonne nuit a vous !

15/03/2012, 07h15
Amnell

Bonjour,

C'est en partie pour cela que je pensais qu'utiliser une classe conteneur (QVector/QList/autre) pourrait être intéressant afin de ne pas avoir des pointeurs qui traînent.

Bonne continuation,
Amnell.
15/03/2012, 14h54
Wanabee

J'y ai pense en effet, mais après avoir essaye je me suis apercu que c'etait impossible a faire fonctionner, aucune idee de la raison...

Je me suis donc rappele de la remarque de johnlamericain qui m'avait indique d'utiliser la methode clear().
Je l'ai integre au debut de mon affichage avec AffMap(), et voila que l'affichage est dynamique avec des items qui s'effacent :P :D

Merci beaucoup a vous pour votre aide! A moi maintenant de gerer les event avec les flèches directionnelles, je reviendrais vers vous si probleme il y a :P

Bonne journee!

Re bonsoir a tous

Me revoila pour la dernière étape 8-)

Ma fenetre est bien actualisee et mon serpent se deplace correctement, j'essaye maintenant de gerer les fleches directionnelles de mon clavier.

Etant donne que j'utiliser un QTimer pour remplir puis afficher ma scene, j'ai suppose que je pouvais utiliser le meme QTimer pour gerer les touches.

J'ai une fonction keyPressEvent :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 void QtAff::keyPressEvent(QKeyEvent *event) { std::cout << "OH YEAAH" << std::endl; switch (event->key()) { case Qt::Key_Up: setDir(UP); break; case Qt::Key_Down: setDir(DOWN); break; case Qt::Key_Left: setDir(LEFT); break; case Qt::Key_Right: setDir(RIGHT); break; } }
Qui est censee gerer le comportement du programme en fonction de la touche enfoncee.
Le probleme est que je ne comprends pas de quelle facon est ce que je peux recuperer ma touche pressee et donc l'envoyer a cette fonction. J'ai reussi plusieurs fois a recuperer les touches presses de mon clavier, mais sans trop savoir comment et je n'arrive pas a le reproduire. Une fois que je saurai comment recuperer la touche presse, je pourrai la stocker dans unQKeyEvent et l'envoyer a ma fonction keyPressEvent. Il ne me manque que la recuperation de la touche x)

Merci d'avance pour les indices que vous pourrez m'apporter j'espere, et bonne nuit a vous!

16/03/2012, 11h32
Amnell

Bonjour,

C'est-à-dire que l'on n'entre pas dans cette fonction ? En réalité, cette fonction est une fonction protected de QWidget, réimplémentable au besoin. Cela signifie que QtAff doit être une classe dérivée de QWidget (qui hérite de QObject) pour récupérer les keyEvents. Dans le cas où vous ne recevrez toujours pas le keyPressEvent, c'est qu'un keyboardGrabber doit être présent sur l'un de vos widgets. Dans ce cas, appelez grabKeyboard() sur le QtAff*.

Bonne continuation,
Amnell.
16/03/2012, 17h09
Wanabee

Non non, mon souci est que je ne sais pas ou faire appel a cette fonction keyPressEvent, ou plutot de quelle facon :

avec un connect()SIGNAL() SLOT()) et ainsi le lier a mon timer? Et quel signal utiliser?

un appel 'normal' dans mon main? Si oui que dois-je lui transmettre en paramètre ? (sachant que la fonction prend un QKEyEvent).

Je n'arrive en fait pas a saisir comment recuperer litterallement ma touche (je suis habitue au C ou on utilisait un read(buffer) et ou il suffisait de lire le buffer, cela doit jouer :roll:)

Merci pour votre aide!
17/03/2012, 00h40
Amnell

Bonsoir,

keyPressEvent() est une fonction virtuelle de QWidget, donc réimplémentable dans une classe dérivée. Elle est appelée automatiquement ; ce n'est pas à vous de faire un appel à elle.

Bonne continuation,
Amnell.
17/03/2012, 01h02
Wanabee

Bon bah parfait grabKeyboard a a peu prés fait fonctionne tout ça, merci beaucoup beaucoup beaucoup Amnell pour ton aide :)

Bonne continuation et bonne nuit !
17/03/2012, 20h32
Amnell

Bonsoir,

En théorie, grabKeyboard ne devrait pas être nécessaire, à moins que la view grab l'entrée clavier. M'enfin, je doute que les Ko... recteurs y fassent attention.

:resolu: ?

Bonne continuation,
Amnell.
20/03/2012, 12h04
Wanabee

Login ? :)
20/03/2012, 12h23
Amnell

Vu que mon nom et prénom sont disponibles sur le côté, je pense que vous pouvez le déduire (duverd_l).
20/03/2012, 15h13
Wanabee

My bad, je n'avais pas remarque ce détail.

Fuseau horaire GMT +2. Il est actuellement 03h01.