[SDL] Détecter l'appuies sur une touche

Détecter l'appuies sur une touche [SDL] - C - Programmation

Marsh Posté le 20-01-2010 à 12:57:32    

Bonjour,
 
J'ai un code tu type:
 
 

Code :
  1. SDL_Event event;
  2. while(continuer){
  3. /*plein d'instructions*/
  4. quitterOuEchap(&continuer, event);
  5. }


 
Avec la fonction quitterOuEchap:
 

Code :
  1. /*Procédure: vérifié si la touche echape est pressée ou si on a un évènement SDL_QUIT (clique sur la croix)
  2.              sans bloquer l'éxecution du programme
  3.   Données: Adresse de la varible de boucle et variable de l'évènement.
  4.   EB: mise à zéro de la variable si un des deux évènement est détecté.
  5.   Préconditions: avoir initialisé la SDL
  6. */
  7. void quitterOuEchap(int *continuer, SDL_Event event)
  8. {
  9.   SDL_PollEvent(&event);
  10.   switch(event.type){
  11.     case SDL_QUIT:
  12.       *continuer = 0;
  13.        break;
  14.     case SDL_KEYDOWN:
  15.       switch (event.key.keysym.sym){
  16.         case SDLK_ESCAPE:
  17.           *continuer = 0;
  18.           break;
  19.       default:
  20.         break;
  21.       }
  22.        break;
  23.   default:
  24.     break;
  25.   }
  26. }


 
Malheureusement j'ai beau marteler la touche échap ou m'exciter sur la croix ça quitte pas, vous savez pourquoi ?
 
Merci.

Reply

Marsh Posté le 20-01-2010 à 12:57:32   

Reply

Marsh Posté le 20-01-2010 à 13:02:30    

Je ne vois pas trop à quoi te sert le passage d'évènement par valeur à ta fonction quitterOuEchap, sinon, ca m'a l'air ok.
Tu peux poser des breakpoints pour voir si tu arrives dans les fonctions qui t'intéressent et tracer ...
 
Est-ce que tu passes au moins dans ta fonction, déjà ? Parce que le code que tu ne nous montre pas pourrait bien contenir un continue qui va te la faire éviter ou quelque chose du genre.


---------------
last.fm
Reply

Marsh Posté le 20-01-2010 à 15:48:46    

Hmm, j'imagine qu'il s'agisse du même programme que celui que tu as posté ici : http://forum.hardware.fr/hfr/Progr [...] 7182_1.htm
 
Parce que si c'est ça, ton problème se situe dans la fonction "appuisSurV()" dans lequel tu fais déjà un SQL_PollEvent, ce qui fait que la fonction suivante "quitterOuEchap()" n'aura plus rien à se mettre sous dent.
 
Arf, et je vois que fait une boucle d'attente avec un délai de 5ms (200 fps quand même). Sous Windows, si tu veux un délai aussi court, faut y aller bourrin, à coup de "while(getticks() - old < 5);". Les timer sous Windows on une précision de 10 à 15ms, soit tout juste bon pour faire du 50 à 60 fps.
 
Edit: je viens de voir plus en détail ta gestion des événements, et c'est pas trop ça. En général on ne fait qu'un seul appel à SQL_PollEvent ou SQL_WaitEvent et un seul switch sur "event.type". Après tu peux appeler d'autres fonctions dans les branches du switch.

Message cité 1 fois
Message édité par tpierron le 20-01-2010 à 15:57:22
Reply

Marsh Posté le 20-01-2010 à 17:53:47    

Oui c'est bien le même programme.
 
Pour l'attente en fait je modifie la valeur en fonction du nombre de calculs que le programme doit effectuer. Ca me sert juste à ralentir le programme histoire de ne pas aller trop vite, et donc je m'en fiche de la précision.
 
Pour l'appel à SDL_WaitEvent, je le fais quand ?  
Avant le while ?
Après je fais juste un switch sur event.type dans le while (donc dans ma fonction) ?

Reply

Marsh Posté le 20-01-2010 à 19:48:13    

tpierron a écrit :


 
Parce que si c'est ça, ton problème se situe dans la fonction "appuisSurV()" dans lequel tu fais déjà un SQL_PollEvent, ce qui fait que la fonction suivante "quitterOuEchap()" n'aura plus rien à se mettre sous dent.


 
Mince j'ai lu trop rapidement et j'ai omis cette partie du message.
 
C'est effectivement ça, mais alors comment faire ?


Message édité par Cpowa le 20-01-2010 à 20:38:43
Reply

Marsh Posté le 20-01-2010 à 20:40:43    

Bah c'est pas compliqué pourtant, il faut qu'il n'y ait qu'un seul appel à SDL_PollEvent() dans tout ton programme.
 
Donc appel cette fonction une seule fois et transmert la structure "event" à tes fonctions appuisSurV() ou quitterOuEchap(), du style (main.c) :
 

Code :
  1. if (SDL_PollEvent(&event))
  2. {
  3.     appuisSurV(&vecteur, event);
  4.     quitterOuEchap(&continuer, event);
  5. }


 
Et enlève évidemment l'appel à SDL_PollEvent() dans les deux sous fonctions.

Message cité 1 fois
Message édité par tpierron le 20-01-2010 à 20:42:57
Reply

Marsh Posté le 20-01-2010 à 21:23:44    


 

tpierron a écrit :

Bah c'est pas compliqué pourtant, il faut qu'il n'y ait qu'un seul appel à SDL_PollEvent() dans tout ton programme.
 
Donc appel cette fonction une seule fois et transmert la structure "event" à tes fonctions appuisSurV() ou quitterOuEchap(), du style (main.c) :
 

Code :
  1. if (SDL_PollEvent(&event))
  2. {
  3.     appuisSurV(&vecteur, event);
  4.     quitterOuEchap(&continuer, event);
  5. }


 
Et enlève évidemment l'appel à SDL_PollEvent() dans les deux sous fonctions.


Magnifique, merci infiniment  :jap:  :jap:


Message édité par Cpowa le 20-01-2010 à 21:23:58
Reply

Marsh Posté le 21-01-2010 à 10:41:29    

Une autre question, comment on utilise le débogueur de Code::Blocks ?
 
Dans projet->Build option j'ai bien coché "Produce debugging symbols" et j'ai mis un ponit d'arrêt dans le programme, mais quand je compile en lance en debug le logiciel ce lance normalement, il ne s'arrête pas au point d'arrêt....
 
Parce que j'ai un bug et je comprend vraiment pas d'où il vient......
Si vraiment je le trouve pas je posterais les sources mis à jour peut-etre que vous pourrez encore me sauver.

Reply

Marsh Posté le 21-01-2010 à 13:03:03    

Tu as une barre d'outils debugger avec des boutons lancer, pas à pas, etc


---------------
deluser --remove-home ptitchep
Reply

Marsh Posté le 21-01-2010 à 13:07:41    

ptitchep a écrit :

Tu as une barre d'outils debugger avec des boutons lancer, pas à pas, etc


Oui je sais, pour lancer je clique sur le bouton Debug/Continue mais ça me lance simplement le programme sans s'arrêter au point d'arrêt

Message cité 1 fois
Message édité par Cpowa le 21-01-2010 à 13:08:44
Reply

Marsh Posté le 21-01-2010 à 13:07:41   

Reply

Marsh Posté le 21-01-2010 à 14:43:42    

Cpowa a écrit :


Oui je sais, pour lancer je clique sur le bouton Debug/Continue mais ça me lance simplement le programme sans s'arrêter au point d'arrêt


 
ou tu ne mais pas de break-point
ou le code ne passe pas de cette break-point
 
avis personel (ne prener pas ca du coté negative) :
je vois quelque faiblaisse dans le program
meme si ca va marcher , il va te fatiguer
mieux avoir les chose plus simple et claire
(les nom de function, l'organization ... etc)
 
... :hello:  

Reply

Marsh Posté le 21-01-2010 à 15:28:04    

__tomjost a écrit :


 
ou tu ne mais pas de break-point
ou le code ne passe pas de cette break-point


le ponit d'arrêt est mis.
Et le code passe forcément par main  :D .

__tomjost a écrit :


avis personel (ne prener pas ca du coté negative) :
je vois quelque faiblaisse dans le program
meme si ca va marcher , il va te fatiguer
mieux avoir les chose plus simple et claire
(les nom de function, l'organization ... etc)
 
... :hello:  


oui là il est pas terminé, j'ai peaufiner et commenté.
Mais il me reste ce satané bug  :fou:  :fou:  :fou:  :fou:  :fou:  :fou:  :fou:  :fou:  :fou:

Reply

Marsh Posté le 21-01-2010 à 15:48:37    

quelque description de ce bug ?
quesqui ne marche pas ?
 
la ligne (ou 3) ou tu mais un break point ?
 
...(j'attend 5 minutes et je quitte  :ange:  )

Reply

Marsh Posté le 21-01-2010 à 16:48:43    

Quand je met un point d'arrêt et que je clique sur Debug/Continue, ça me lance le programme et me grise toutes les commandes du debug (je ne peux plus cliquer dessus) et le programme ignore totalement le point d'arrêt.
 
 
Pour le bug j'explique le principe du programme:
Il simule l'évolution d'une boule accroché à un ressort (c'est comme un pendule sauf qu'on change la corde par un ressort).
Donc au début j'affiche la boule avec son ressort qui bougent, puis quand on appuye sur espace on passe dans le mode "trace". C'est à dire  qu'on trace la trajectoire de la boule.
Tout fonctionne quand je met une masse.
Mais quand je met plus d'une masse, au début ça fonctionne je vois mes masses évoluer avec leurs ressorts. Mais quand je passe en mode trace j'obtiens une trajectoire tout droite, et je ne comprend pas pourquoi. Parce que le mode trace est exactement comme l'autre mode sauf qu'au lieu d'afficher la boule et le ressort, puis d'effacer l'écran, ré afficher la boule et le ressort effacer l'écran etc... et bien on affiche seulement un pixel à l'endroit de la boule sans effacer l'écran.
 
Que les deux modes ne fonctionnent pas ce serait compréhensible mais que seul le mode trace bug je ne comprend pas...
 
Je post mes sources à jour (sauf les header qui servent à rien). (attentions certains commentaires ne sont pas bon j'ai pas encore tout commenté)
 
main.c

Code :
  1. #include <stdio.h>
  2. #include <SDL/SDL.h>
  3. #include "graphique.h"
  4. #include <math.h>
  5. #include "evenement.h"
  6. #include "commun.h"
  7. int main(int argc, char *argv[])
  8. {
  9.   double point[NB_PROP][NBPART], ini[NB_PROP][NBPART];
  10.   int  i, j, continuer1=1, continuer2=1, vecteur=1, pause=0;
  11.   SDL_Event event;
  12. /*Initialisation de la SDL et ouverture de la fenêtre graphique avec redirection des erreurs vers la sortie standard*/
  13.   if(SDL_Init(SDL_INIT_VIDEO)==-1){
  14.     fprintf(stderr, "Erreur à l'initialisation de la SDL: %s \n", SDL_GetError());
  15.     exit(EXIT_FAILURE);
  16.   }
  17.   ecran=SDL_SetVideoMode(700, 700, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
  18.   if(ecran==NULL){
  19.     fprintf(stderr, "Erreur à l'initilisation du mode graphique: %s\n", SDL_GetError());
  20.     exit(EXIT_FAILURE);
  21.   }
  22.   SDL_WM_SetCaption("Pendule elastique", NULL);
  23. /*#################################################################################################################*/
  24.   initCouleurs(ecran);
  25.   init(point, ecran);
  26.    for(i=0; i<NBPART; i++)
  27.     for(j=0; j<NB_PROP; j++)
  28.       ini[i][j]=point[i][j];
  29.   attendTouche();
  30. /*--------=========#####Boucle principale du programme######========-------*/
  31.   while(continuer1==1 && continuer2==1){
  32.     effacerEcran();
  33.     for(i=0; i<NBPART; i++){
  34.       calculeAcc(i, point);
  35.       eulerPos(i, point);
  36.       eulerVit(i, point);
  37.       ligne(350, 250, point[POSX][i], point[POSY][i], couleurs[C_NOIR]);
  38.     }
  39.     affichePoint(point, vecteur);
  40.     disque(350,250, 3, couleurs[C_GRIS]);
  41.     SDL_Flip(ecran);
  42.     if (SDL_PollEvent(&event)){
  43.       appuisSurP(&pause, event);
  44.       appuisSurV(&vecteur, event);
  45.       appuisSurEspace(&continuer1, event);
  46.       quitterOuEchap(&continuer1, &continuer2, event);
  47.     }
  48.     if(pause){
  49.       attendTouche();
  50.       pause=0;
  51.     }
  52.   }
  53.   effacerEcran();
  54.   while(continuer2==1){
  55.     for(i=0; i<NBPART; i++){
  56.       calculeAcc(i, ini);
  57.       eulerPos(i, ini);
  58.       eulerVit(i, ini);
  59.       setPixelVerif(ini[POSX][i],ini[POSY][i], ini[COULEUR][i]);
  60.     }
  61.     disque(350,250, 3, couleurs[C_GRIS]);
  62.     SDL_Flip(ecran);
  63.     if (SDL_PollEvent(&event)){
  64.      quitterOuEchap(&continuer2, &continuer2, event);
  65.      appuisSurP(&pause, event);
  66.     }
  67.     if(pause){
  68.       attendTouche();
  69.       pause=0;
  70.     }
  71.   }
  72. /*##################################################################################*/
  73.   SDL_Quit();
  74.   return EXIT_SUCCESS;
  75. }


 
graphique.c

Code :
  1. #include <SDL/SDL.h>
  2. #include "graphique.h"
  3. /*Procédure: Permet d'utiliser les couleurs plus facilement en appellant la fonction au début du programme
  4.   Données: Aucunes
  5.   Précondition: Avoir initialisé la SDL
  6. */
  7. void initCouleurs(SDL_Surface *v_ecran)
  8. {
  9.   couleurs[C_NOIR]          = SDL_MapRGB(v_ecran->format, 0x00, 0x00, 0x00);
  10.   couleurs[C_BLEU_FONCE]    = SDL_MapRGB(v_ecran->format, 0x00, 0x00, 0x80);
  11.   couleurs[C_VERT_FONCE]    = SDL_MapRGB(v_ecran->format, 0x00, 0x80, 0x00);
  12.   couleurs[C_CYAN_FONCE]    = SDL_MapRGB(v_ecran->format, 0x00, 0x80, 0x80);
  13.   couleurs[C_ROUGE_FONCE]   = SDL_MapRGB(v_ecran->format, 0x80, 0x00, 0x00);
  14.   couleurs[C_MAGENTA_FONCE] = SDL_MapRGB(v_ecran->format, 0x80, 0x00, 0x80);
  15.   couleurs[C_OCRE]          = SDL_MapRGB(v_ecran->format, 0x80, 0x80, 0x00);
  16.   couleurs[C_GRIS_CLAIR]    = SDL_MapRGB(v_ecran->format, 0xC0, 0xC0, 0xC0);
  17.   couleurs[C_GRIS]          = SDL_MapRGB(v_ecran->format, 0x80, 0x80, 0x80);
  18.   couleurs[C_BLEU]          = SDL_MapRGB(v_ecran->format, 0x00, 0x00, 0xFF);
  19.   couleurs[C_VERT]          = SDL_MapRGB(v_ecran->format, 0x00, 0xFF, 0x00);
  20.   couleurs[C_CYAN]          = SDL_MapRGB(v_ecran->format, 0x00, 0xFF, 0xFF);
  21.   couleurs[C_ROUGE]         = SDL_MapRGB(v_ecran->format, 0xFF, 0x00, 0x00);
  22.   couleurs[C_MAGENTA]       = SDL_MapRGB(v_ecran->format, 0xFF, 0x00, 0xFF);
  23.   couleurs[C_JAUNE]         = SDL_MapRGB(v_ecran->format, 0xFF, 0xFF, 0x00);
  24.   couleurs[C_BLANC]         = SDL_MapRGB(v_ecran->format, 0xFF, 0xFF, 0xFF);
  25. }
  26. /*Procédure: Affiche un pixel de couleur donnée
  27.   Données: Coordonées du pixel et code couleur
  28.   Préconditions: Avoir initialisé la SDL et le mode graphique en 32bit,
  29.                 les coordonnées du pixel doivent se situer dans la fenêtre
  30. */
  31. void setPixel(int x, int y, Uint32 coul)
  32. {
  33.   *((Uint32*)(POINTEUR_SURFACE->pixels) + x + y * POINTEUR_SURFACE->w) = coul;
  34. }
  35. /*Procédure: Affiche un pixel de couleur donnée de façon sécurisée
  36.   Données: Coordonées du pixel et code couleur
  37.   Préconditions: Avoir initialisé la SDL et le mode graphique en 32bit
  38. */
  39. void setPixelVerif(int x, int y, Uint32 coul)
  40. {
  41.   if (x >= 0 && x < POINTEUR_SURFACE->w &&
  42.       y >= 0 && y < POINTEUR_SURFACE->h)
  43.     setPixel(x, y, coul);
  44. }
  45. /*Procédure: Affiche une barre de dimensions données
  46.   Données: coordonnées du point supérieur gauche, largeur, hauteur et le code couleur.
  47.   Préconditions: Avoir initialisé la SDL et le mode graphique
  48. */
  49. void barre(int x, int y, int w, int h, Uint32 coul)
  50. {
  51.   SDL_Rect r;
  52.   r.x = x;
  53.   r.y = y;
  54.   r.w = w;
  55.   r.h = h;
  56.   SDL_FillRect(POINTEUR_SURFACE, &r, coul);
  57. }
  58. /*Procédure: Remplit la fenêtre en blanc
  59.   Données: Aucunes
  60.   Préconditions: Avoir initialisé la SDL et le mode graphique
  61. */
  62. void effacerEcran(void)
  63. {
  64.   SDL_FillRect(POINTEUR_SURFACE, NULL, couleurs[C_BLANC]);
  65. }
  66. /*Fonction: Echange deux variables d'entiers.
  67.   Données: deux entiers
  68.   Effet de bord: sur les deux variables
  69. */
  70. void echangerEntiers(int* x, int* y)
  71. {
  72.   int t = *x;
  73.   *x = *y;
  74.   *y = t;
  75. }
  76. /*Procédure: Trace une ligne quelconque
  77.   Données: Coordonnées du premier point, du second point et code couleur
  78.   Préconditions: Avoir initialisé la SDL et le mode graphique en 32 bit.
  79. */
  80. void ligne(int x1, int y1, int x2, int y2, Uint32 coul)
  81. {
  82.   int d, dx, dy, aincr, bincr, xincr, yincr, x, y;
  83.   if (abs(x2 - x1) < abs(y2 - y1)) {
  84.     /* parcours par l'axe vertical */
  85.     if (y1 > y2) {
  86.       echangerEntiers(&x1, &x2);
  87.       echangerEntiers(&y1, &y2);
  88.     }
  89.     xincr = x2 > x1 ? 1 : -1;
  90.     dy = y2 - y1;
  91.     dx = abs(x2 - x1);
  92.     d = 2 * dx - dy;
  93.     aincr = 2 * (dx - dy);
  94.     bincr = 2 * dx;
  95.     x = x1;
  96.     y = y1;
  97.     setPixelVerif(x, y, coul);
  98.     for (y = y1+1; y <= y2; ++y) {
  99.       if (d >= 0) {
  100. x += xincr;
  101. d += aincr;
  102.       } else
  103. d += bincr;
  104.       setPixelVerif(x, y, coul);
  105.     }
  106.   } else {
  107.     /* parcours par l'axe horizontal */
  108.     if (x1 > x2) {
  109.       echangerEntiers(&x1, &x2);
  110.       echangerEntiers(&y1, &y2);
  111.     }
  112.     yincr = y2 > y1 ? 1 : -1;
  113.     dx = x2 - x1;
  114.     dy = abs(y2 - y1);
  115.     d = 2 * dy - dx;
  116.     aincr = 2 * (dy - dx);
  117.     bincr = 2 * dy;
  118.     x = x1;
  119.     y = y1;
  120.     setPixelVerif(x, y, coul);
  121.     for (x = x1+1; x <= x2; ++x) {
  122.       if (d >= 0) {
  123. y += yincr;
  124. d += aincr;
  125.       } else
  126. d += bincr;
  127.       setPixelVerif(x, y, coul);
  128.     }
  129.   }
  130. }
  131. /*Procédure: Trace une ligne horizontale
  132.   Données: Coordonnées du point gauche, longueur de la ligne, code couleur
  133.   Préconditions: Avoir initialisé la SDL et le mode graphique
  134. */
  135. void ligneHorizontale(int x, int y, int w, Uint32 coul)
  136. {
  137.   SDL_Rect r;
  138.   r.x = x;
  139.   r.y = y;
  140.   r.w = w;
  141.   r.h = 1;
  142.   SDL_FillRect(POINTEUR_SURFACE, &r, coul);
  143. }
  144. /*Procédure: Trace un disque
  145.   Données: Coordonnées du centre, rayon et code couleur
  146.   Préconditions: Avoir initialisé la SDL et le mode graphique
  147. */
  148. void disque(int cx, int cy, int rayon, int coul)
  149. {
  150.   int d, y, x;
  151.   d = 3 - (2 * rayon);
  152.   x = 0;
  153.   y = rayon;
  154.   while (y >= x) {
  155.     ligneHorizontale(cx - x, cy - y, 2 * x + 1, coul);
  156.     ligneHorizontale(cx - x, cy + y, 2 * x + 1, coul);
  157.     ligneHorizontale(cx - y, cy - x, 2 * y + 1, coul);
  158.     ligneHorizontale(cx - y, cy + x, 2 * y + 1, coul);
  159.     if (d < 0)
  160.       d = d + (4 * x) + 6;
  161.     else {
  162.       d = d + 4 * (x - y) + 10;
  163.       y--;
  164.     }
  165.     x++;
  166.   }
  167. }


 
evenement.c

Code :
  1. #include <math.h>
  2. #include <SDL/SDL.h>
  3. #include "graphique.h"
  4. #include "evenement.h"
  5. #include "commun.h"
  6. /*Procédure: Permet à l'utilisateur d'initialiser les particules (position, vitesse et rayon)
  7.   Données: Tableau, et adresse de la surface contenant l'écran
  8.   EB: modification des cases du tableau aux lignes indiquées
  9.   Précondition: Avoir initialisé la SDL
  10. */
  11. void init(double point[NB_PROP][NBPART], SDL_Surface *ecran)
  12. {
  13.   int  i, x=0, y=0;
  14.   effacerEcran();
  15.   disque(350,250, 3, couleurs[C_GRIS]);
  16.   SDL_Flip(ecran);
  17.   for(i=0; i<NBPART; i++){
  18.     attendClicGauche(&x, &y);
  19.     if(i==0)
  20.       point[COULEUR][i]=couleurs[C_BLEU_FONCE];
  21.     else
  22.       point[COULEUR][i]=couleurs[C_MAGENTA_FONCE];
  23.     point[POSX][i]=x;
  24.     point[POSY][i]=y;
  25.     disque(point[POSX][i],point[POSY][i], 10, point[COULEUR][i]);
  26.     ligne(350, 250, point[POSX][i], point[POSY][i], couleurs[C_NOIR]);
  27.     SDL_Flip(ecran);
  28.     attendClicGauche(&x, &y);
  29.     point[VITX][i]=(x-point[POSX][i])/10;
  30.     point[VITY][i]=(y-point[POSY][i])/10;
  31.     afficheUneVitesse(point, i);
  32.     SDL_Flip(ecran);
  33.     point[ACCX][i]=0;
  34.     point[ACCY][i]=0;
  35.     point[MASSE][i]=0.1;
  36.     point[CONSTANTE_RAIDEUR][i]=50;
  37.     point[LONGUEUR_VIDE][i]=50;
  38.   }
  39. }
  40. /*Procédure: Affiche un vecteur vitesse depuis le centre d'un particule
  41.   Donnée: le tableau contenant les vitesses et la position et le n° de la colonne de la particule
  42.   EB: Auncun
  43.   Précondition: Avoir initialisé la SDL
  44. */
  45. void afficheUneVitesse(double point[][NBPART], int j)
  46. {
  47.   ligne(point[POSX][j], point[POSY][j],point[POSX][j]+point[VITX][j]*10,point[POSY][j]+point[VITY][j]*10,  couleurs[C_ROUGE]);
  48. }
  49. /*Procédure: calcule la position d'une particule
  50.   Donné: indice de la particule et tableau où sont rangés les vitesses et les positions des particules
  51.   EB: modifie les cases correspondant aux positions dans le tableau des particules
  52.   Préconditions: Avoir initialisé la vitesse et la position des particules
  53. */
  54. void calculeAcc(int indice, double point[][NBPART])
  55. {
  56.   double l; /* longueur du ressort*/
  57.   l=sqrt((point[POSX][indice]-350)*(point[POSX][indice]-350)+(point[POSY][indice]-250)*(point[POSY][indice]-250));
  58.   point[ACCX][indice]=(-0.001*point[CONSTANTE_RAIDEUR][indice]/point[MASSE][indice])*(l-point[LONGUEUR_VIDE][indice])*((point[POSX][indice]-350)/l)-(COEF_FROTTEMENT/point[MASSE][indice])*point[VITX][indice];
  59.   point[ACCY][indice]=g+(-0.001*point[CONSTANTE_RAIDEUR][indice]/point[MASSE][indice])*(l-point[LONGUEUR_VIDE][indice])*((point[POSY][indice]-250)/l)-(COEF_FROTTEMENT/point[MASSE][indice])*point[VITY][indice];
  60. }
  61. void eulerVit(int indice, double point[][NBPART])
  62. {
  63.   point[VITX][indice]=point[VITX][indice]+DT*point[ACCX][indice];
  64.   point[VITY][indice]=point[VITY][indice]+DT*point[ACCY][indice];
  65. }
  66. /*Procédure: calcule la position d'une particule
  67.   Donné: indice de la particule et tableau où sont rangés les vitesses et les positions des particules
  68.   EB: modifie les cases correspondant aux positions dans le tableau des particules
  69.   Préconditions: Avoir initialisé la vitesse et la position des particules
  70. */
  71. void eulerPos(int indice, double point[][NBPART])
  72. {
  73.   point[POSX][indice]=point[POSX][indice]+DT*point[VITX][indice]*1000;
  74.   point[POSY][indice]=point[POSY][indice]+DT*point[VITY][indice]*1000;
  75. }
  76. /*void verletVit(int indice, double point[][NBPART])
  77. {
  78.   point[VITX][indice]=point[VITX][indice]+DT*(point[ACCX][indice];
  79.   point[VITY][indice]=point[VITY][indice]+DT*point[ACCY][indice];
  80. }*/
  81. /*Procédure: Affiche toutes les particules avec leur vecteurs vitesse ou non
  82.   Données: tableau où sont stockés la position et le vecteur vitesse des particules
  83.            booléen pour le cercle et le vecteur
  84.   EB: aucun
  85.   Préconditions: avoir initialisé la vitesse et la position des particules ainsi que la SDL.
  86. */
  87. void affichePoint(double point[][NBPART], int Vecteur)
  88. {
  89.   int i;
  90.   for(i=0; i<NBPART; i++){
  91.     disque(point[POSX][i],point[POSY][i], 10, point[COULEUR][i]);
  92.     if(Vecteur)
  93.       afficheUneVitesse(point, i);
  94.   }
  95. }
  96. /*Procédure: vérifié si la touche echape est pressée ou si on a un évènement SDL_QUIT (clique sur la croix)
  97.              sans bloquer l'éxecution du programme
  98.   Données: Adresse de la varible de boucle et variable de l'évènement.
  99.   EB: mise à zéro de la variable si un des deux évènement est détecté.
  100.   Préconditions: avoir initialisé la SDL
  101. */
  102. void quitterOuEchap(int *continuer1,int *continuer2, SDL_Event event)
  103. {
  104.   switch(event.type){
  105.     case SDL_QUIT:
  106.       *continuer1 = 0;
  107.       *continuer2 = 0;
  108.        break;
  109.     case SDL_KEYDOWN:
  110.       switch (event.key.keysym.sym){
  111.         case SDLK_ESCAPE:
  112.           *continuer1 = 0;
  113.           *continuer2 = 0;
  114.           break;
  115.       default:
  116.         break;
  117.       }
  118.        break;
  119.   default:
  120.     break;
  121.   }
  122. }
  123. void appuisSurV(int *vecteur, SDL_Event event)
  124. {
  125.   switch(event.type){
  126.     case SDL_KEYDOWN:
  127.       switch (event.key.keysym.sym){
  128.         case SDLK_v:
  129.           if(*vecteur == 1)
  130.             *vecteur=0;
  131.           else
  132.             *vecteur=1;
  133.           break;
  134.         default:
  135.           break;
  136.       }
  137.        break;
  138.     default:
  139.       break;
  140.   }
  141. }
  142. void appuisSurP(int *pause, SDL_Event event)
  143. {
  144.   switch(event.type){
  145.     case SDL_KEYDOWN:
  146.       switch (event.key.keysym.sym){
  147.         case SDLK_p:
  148.           if(*pause == 1)
  149.             *pause=0;
  150.           else
  151.             *pause=1;
  152.           break;
  153.         default:
  154.           break;
  155.       }
  156.        break;
  157.     default:
  158.       break;
  159.   }
  160. }
  161. void appuisSurEspace(int *continuer1, SDL_Event event)
  162. {
  163.   switch(event.type){
  164.     case SDL_KEYDOWN:
  165.       switch (event.key.keysym.sym){
  166.         case SDLK_SPACE:
  167.           if(*continuer1 == 1)
  168.             *continuer1=0;
  169.           else
  170.             *continuer1=1;
  171.           break;
  172.         default:
  173.           break;
  174.       }
  175.        break;
  176.     default:
  177.       break;
  178.   }
  179. }
  180. /*Procédure: Attend jusqu'à l'appuie sur une touche
  181.   Précondition: Avoir initialisé la SDL
  182. */
  183. void attendTouche(void)
  184. {
  185.   int continuer=1;
  186.   SDL_Event event;
  187.   while (continuer){
  188.         SDL_WaitEvent(&event);
  189.         switch(event.type){
  190.           case SDL_KEYDOWN:
  191.             continuer = 0;
  192.             break;
  193.           default:
  194.             break;
  195.         }
  196.   }
  197. }
  198. /*Procédure: Attend l'évènement clic gauche et donne la position du clic
  199.   Données: adresse de la varible position x et de la varible position y
  200.   EB: modification de la valeur des variables
  201.   Précondition: Avoir initialisé la SDL
  202. */
  203. void attendClicGauche(int *x, int *y)
  204. {
  205.   int continuer = 1;
  206.   SDL_Event event;
  207.   while (continuer){
  208.     SDL_WaitEvent(&event);
  209.     switch(event.type){
  210.        case SDL_MOUSEBUTTONUP:
  211.           if (event.button.button == SDL_BUTTON_LEFT){
  212.             *x = event.button.x;
  213.             *y = event.button.y;
  214.             continuer = 0;
  215.           }
  216.           break;
  217.         default:
  218.           break;
  219.     }
  220.   }
  221. }


Reply

Marsh Posté le 21-01-2010 à 17:53:58    

Cpowa a écrit :


main.c

Code :
  1. /*--------=========#####Boucle principale du programme######========-------*/
  2.   while(continuer1==1 && continuer2==1){
  3.     effacerEcran();
  4.     for(i=0; i<NBPART; i++){
  5.       calculeAcc(i, point);
  6.       eulerPos(i, point);
  7.       eulerVit(i, point);
  8.       ligne(350, 250, point[POSX][i], point[POSY][i], couleurs[C_NOIR]);
  9.     }
  10.     affichePoint(point, vecteur);
  11.     disque(350,250, 3, couleurs[C_GRIS]);
  12.     SDL_Flip(ecran);
  13.     if (SDL_PollEvent(&event)){
  14.       appuisSurP(&pause, event);
  15.       appuisSurV(&vecteur, event);
  16.       appuisSurEspace(&continuer1, event);
  17.       quitterOuEchap(&continuer1, &continuer2, event);
  18.     }
  19.     if(pause){
  20.       attendTouche();
  21.       pause=0;
  22.     }
  23.   }
  24.   effacerEcran();
  25.   while(continuer2==1){
  26.     for(i=0; i<NBPART; i++){
  27.       calculeAcc(i, ini);
  28.       eulerPos(i, ini);
  29.       eulerVit(i, ini);
  30.       setPixelVerif(ini[POSX][i],ini[POSY][i], ini[COULEUR][i]);
  31.     }
  32.     disque(350,250, 3, couleurs[C_GRIS]);
  33.     SDL_Flip(ecran);
  34.     if (SDL_PollEvent(&event)){
  35.      quitterOuEchap(&continuer2, &continuer2, event);
  36.      appuisSurP(&pause, event);
  37.     }
  38.     if(pause){
  39.       attendTouche();
  40.       pause=0;
  41.     }
  42.   }
  43. /*##################################################################################*/




C'est quoi continuer1 et continuer2
Pourquoi dans ta boucle principale tu as 2 while non imbriqué? (parce que la ca fait 2 boucles...)


Message édité par breizhbugs le 21-01-2010 à 17:54:34
Reply

Marsh Posté le 21-01-2010 à 17:59:41    

Première boucle: affichage normal
Deuxième boucle: affichage en mode trace.
Donc les deux boucles sont identiques sauf que dans l'une on affiche que des pixels.
 
continuer1 et continuer2 pour pouvoir sortir des deux boucles si on veut quitter le programme.

Reply

Marsh Posté le 21-01-2010 à 20:20:56    

Cpowa a écrit :

Une autre question, comment on utilise le débogueur de Code::Blocks ?
 
Dans projet->Build option j'ai bien coché "Produce debugging symbols" et j'ai mis un ponit d'arrêt dans le programme, mais quand je compile en lance en debug le logiciel ce lance normalement, il ne s'arrête pas au point d'arrêt....
 
Parce que j'ai un bug et je comprend vraiment pas d'où il vient......
Si vraiment je le trouve pas je posterais les sources mis à jour peut-etre que vous pourrez encore me sauver.


 

ptitchep a écrit :

Tu as une barre d'outils debugger avec des boutons lancer, pas à pas, etc


Dev-Cpp :o
 
Sinon j'ai le même problème perso, la barre d'outils qui s'appelle "Debug" sous Code::Blocks contient des élements grisés (tout le temps), et le programme ne s'arrête pas aux points d'arrêt.

Reply

Marsh Posté le 21-01-2010 à 20:49:56    

dev-cpp n'ets plus trop maintenu :s

Reply

Marsh Posté le 21-01-2010 à 22:33:45    

:sol:  c'est peut etre un composant du coordonne qui prend zero...  
 
pour les break-point:
tout simplement , il n'ya pas debug-info , ni symbol ni text!
je ne connait pas ce "Dev-Cpp" mais
voir si il ya d'autre option qui controle ca ,
on choisie le type du debug ...etc

Reply

Marsh Posté le 22-01-2010 à 10:42:53    

Je n'ai jamais rien debuggé dans code::blocks, même si je l'utilise pour coder. Ca n'a jamais vraiment marché correctement: il ignorait des points d'arret pour moi aussi et même parfois freezait completement, par exemple avec des programmes OpenGL... Je pense que cela vient d'une utilisation bizarre de gdb car je n'ai pas de problème avec d'autre debuggers.
Sous Linux j'ai kdbg qui ne tourne pas trop mal mais n'importe quelle couche graphique de gdb fait l'affaire(hors code::blocks ;) ). Sous Windows, je n'ai pas de solution. Les rares fois où j'en ai besoin j'utilise visual studio et je dois reconnaitre que le peu que j'en ai vu le place pour moi n°1 des debugger.


---------------
deluser --remove-home ptitchep
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed