Discussion :

[lilington]

bonjour, pour le plaisir d'apprendre je fait un petit pong en C avec opengl et utilise glfw pour la geston des fenetres et le input clavier.
mon probleme est que quand j'appuis sur la touche 'a' pour deplacer la raquette vers la gauche raqH, elle va completement a gauche aulieu de bouger d'un cran.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 glClear(GL_COLOR_BUFFER_BIT);
while(running==GL_TRUE)
{
        running = !glfwGetKey(GLFW_KEY_ESC)&& glfwGetWindowParam(GLFW_OPENED);
 
        if( glfwGetKey('A'))
        {
            raqH->x -=.01;   //deplace le x de la raquette du joueur vers la gauche
        }
        if( glfwGetKey('D'))
            raqH->x +=.01; //deplace le x vers la droite 
 
        now = glfwGetTime();  //gere le temps pour deplacer la ball
        if(now-oldtime>=.025)
        {
            oldtime=now;
            res = moveball();  // renvois autre chose que 0 si la balle sort des limites
        }
 
        if(res!=0)
            break;
 
        checkRaq(); // verifie que la raquette est dans les limites sinon la place a la limite la plus proche
        drawMachine(); //dessine tout les objets de la scenes actuellement balle decore et raquette
        glfwSwapBuffers();
}

en faite je comprend le probleme mais je sais pas comment le regler avec glfw.
autre fois on faisait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
if(keypressed()) //conio kbhit() 
//linux j'utilisais un bout de code vu dans beginning linux programming pour les
//fonction kbhit() et getch() 
   key = getkey(); //sous dos avec conio c'etait getch() 
if(key=='a')
{
   key = 0; //empeche de revenir ici saus si la touche 'a' a ete presse de nouveau
   raqH->x-=.01;
}

mais la je vois pas comment implementer ca.
merci de votre patience

[Invité(e)]

Bonjour,

Tu peux ajouter une temporisation dans ta boucle principale : de même que tu attends if(now-oldtime>=.025) pour déplacer la balle, tu pourrais attendre un peu pour déplacer la raquette.

[lilington]

ben je l'avais deja fait et ca marchait mais je voulais justement eviter ca. sinon pour chaque objet a dessiner et qui ne sont pas a une position constante (car je complique au fure et a messure) faudrait faire ce genre de reglage.

au faite ma fonction drawMachine(); affiche tous les objets declarer en globales dans un objet.h je me dit que en multipliant les variables globales ca deviendra puant non?

[Invité(e)]

ben je l'avais deja fait et ca marchait mais je voulais justement eviter ca. sinon pour chaque objet a dessiner et qui ne sont pas a une position constante (car je complique au fure et a messure) faudrait faire ce genre de reglage.

Tu peux aussi tu dire que tout dépend du temps et que l'affichage n'est pas forcement régulier.

exemple : ton aire de jeu fait 100x100, tu veux que ta balle traverse l'écran en 2 secondes, que la raquette le fasse en 1.
À chaque affichage, il faut donc bouger la balle de 100 x temps_en_seconde / 2 et si a est enfoncé, bouger la raquette de 100 x temps_en_seconde. temps en seconde est le temps écoulé entre les deux rafraichissements.

On peut donc écrire quelque chose comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
while(running==GL_TRUE)
{
      /* Calcul du temps écoulé */
       now = glfwGetTime();
       temps_ecoule = now-oldtime;  
 
      /* Gestion de la raquette */
       if( glfwGetKey('A')) {
            raqH->x -= temps_ecoule;   
        }
        if( glfwGetKey('D')) {          
            raqH->x -= temps_ecoule;   
        }
 
       /* Gestion de la balle */
       /* on bouge la balle en fonction du temps écoulé depuis le 
           dernier déplacement */
        res = moveball(temps_ecoule);  
 
        if(res!=0)
            break;
 
       /* Rendu de la scène */
        checkRaq(); 
        drawMachine(); 
        glfwSwapBuffers();
 
        oldtime=now;
}

au faite ma fonction drawMachine(); affiche tous les objets declarer en globales dans un objet.h je me dit que en multipliant les variables globales ca deviendra puant non?

Effectivement, il y a des méthodes plus propres.
On peut par exemple s'organiser par module : raquette, balle, décors...
Définir pour chaque module des variables statiques (accessibles dans tout le module mais pas ailleurs)
Définir pour chaque module des fonctions pour agir sur les objet : RAQ_bouge, RAQ_dessine pour bouger et dessiner les raquettes, BAL_bouge, BAL_dessine pour le balle...
C'est un pas vers la programmation objet.

[lilington]

Merci pour le conseil 1. c'est extrement utile.
pour le second point, je sais pas si ce que tu me demande de faire c'est:
raq.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
   static Raquette * raqH  //stuctre comportant x,y,z,rgb,width,height,alive
   static Raquette *raqCPU
 
   void initRaq(); //les deux raquettes sont initialisees ici position couleur ...
   void moveRaq(int laquelle,int direction);
 
   void  drawraquettes();

la meme chose pour ball, decore, machin_chouette,...
graphic.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
...
   void drawmachine(); //qui appellera toutes les fonctions draw
                                    // drawdecor(),drawraquettes(),drawball(),drawbonus()...

ai je compris ton conseil?

[Invité(e)]

ai je compris ton conseil?

Presque.

Voici comment j'organise ma popote quand je suis dans ce genre de problématiques :

Code raquette.h :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
void initRaq(); 
void moveRaq(int laquelle,int direction);
void  drawraquettes();

Code raquette.c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
typedef struct Raquette {...} Raquette;
static Raquette * raqH;
static Raquette *raqCPU;
 
void initRaq()
{
   ...   
}
void moveRaq(int laquelle,int direction)
{
   ...   
}
void  drawraquettes()
{
   ...   
}

Ainsi, les variables raqH et raqCPU ne sont pas accessibles depuis les autres fichiers .c. Les autres fichiers .c ne connaissent même pas l'existence de la structure Raquette, il n'en on pas besoin.

[lilington]

Merci c'est claire net et sans bavures

[lilington]

je reviens car j'ai remaquer que tout separer possait un probleme: les collisions.
la fonction moveball renvois -1 quand elle sort du decor et change de direction quand elle tape la raquette.
apres avoir ramenager le tout dans des fichiers respectives je me rend compte que la fonction move balle ne peut que deplacer la balle en testant sa position dans l'aire de jeu mais pas les collisions.
a premiere vu la solution la plus simple que je vois est de creer un fichier : matrix.h
qui a toute les coordonnees de tout les objects qui s'ajoutent au fure et a mesure.
par exemple si un obstacle est ajoute il inscrit sa taille et sa position dans une matrice pour permettre au autre fonction comme moveball() se savoir si il entre en collision avec lui. autre exemple si un bonus tombe vers la raquette, la fonction movebonus() dois pouvoire connaitre la position de la raquette quelle va hurter. d'ou tout le monde doit etre inscrit la.
du coup je me demande si c'est pas plus couteux que ceque j'avais fait avant? ou alors existe -t il un autre moyen de faire communiquer mes fonctions sans avoir a ajouter une liste d'argument car je veux eviter ca pour la bonne et simple raison que les objets vont s'ajouter au fure et a messures sinon j'ai ca:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

moveball(block **raquettes,OBJ **obstacles, AUTRE **autres)

ou raquettes, obstacles et autre sont des listes d'objet dont il faut gerer les colisions dans la fonction genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
while(raquettes[i]!=NULL)
     //gerer la colition avec la raquette i
while(obstacles[i]!=NULL)
    //gerer la colition avec obstacles de i

dans ce cas un nouveau probleme se pose, c'est que les objets qui etait cacher dans leur fichier respectif deviennent accecible donc je reviens a la case depart saufs si je passe a c++ et faire des classes (ce que je ne veux surtout pas faire. je ne veux pas de classe sinon autant tout refaire en CPP) ce qui fait que pour l'instant je vois que la matrice sauf si tu as une meilleure solution

ps je vois que le sujet a devie du topic de depart desole

[Invité(e)]

Bonjour,

ou alors existe -t il un autre moyen de faire communiquer mes fonctions sans avoir a ajouter une liste d'argument car je veux eviter ca pour la bonne et simple raison que les objets vont s'ajouter au fure et a messures sinon j'ai ca:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

moveball(block **raquettes,OBJ **obstacles, AUTRE **autres)

Le problème que tu soulève est plus un problème de conception qu'un problème lié au C lui même.

On peut avoir plusieurs approches pour résoudre le problème.

Ce que j'aurai tendance à faire est proche de ça :

Code raquette.h :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
/* le type Raquette est maintenant public */
typedef struct Raquette {...} Raquette;
 
void initRaq();
void moveRaq(int laquelle,int direction);
void  drawraquettes();
 
 
/*Nouveauté : cette fonction permet d'obtenir la copie d'une raquette*/
Raquette getRaquettes(int i);
/* Nouveauté : nombre de raquettes existantes */
int getRaquettesCount();

L'idée est de n'autoriser que le module raquette.c à manipuler les raquettes.
Les autres modules peuvent accéder à des copies des raquettes, mais ne peuvent en aucun cas modifier les raquettes originales.

[lilington]

je vois. et c'est effectivement plus un probleme de C.
sur ceux je vais reflechir a la conception mais vraisemblablement je ferai pas comme toi car ca ressemble cruellement au c++. .

donc pour le moment j'ai opte pour un fichier matrix.h qui est comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Block MTraq[2] //pour les 2 raquettes
Ball MTball  //pour la ball
Obstable MTBObj[MAX] //pour les obstacles

donc chaque fois qu'un objet est modifie, la modifiaction est notifier par une modification de l'objet correspondant dans matrix.h.
ex: si la raquette raqH bouge elle donne sa possition et sa taille a MTraq[0] ainsi la ball devra lire lire les info dans MTraq pour les collisions.

ps: il est tot en france Non? je remarque que tu reponds souvent a la meme heure. chez moi il est 17h30

je sais pas si c'est genial mais dis moi si tu vois une incoerence la dedant.

[Invité(e)]

je sais pas si c'est genial mais dis moi si tu vois une incoerence la dedant.

Il n'y a aucune incohérence dans ce que tu fais, mais le problème est que tu utilises des variables globales.
Cela pose un problème de conception dans la mesure où n'importe quel module peut modifier n'importe quel objet.

Tu peux tout à fait réaliser ton projet avec des variables globales, mais c'est le genre de pratique qu'il faut mieux éviter sur le long terme.

[lilington]

j'ai compris, je vais donc revoire la conception. au debut c'etait juste pour jouer un peu avec opengl mais la ca devient interressant. je vais donc recommencer avec une feuille et un papier. Merci