réussite un peu aléatoire de mon code :S

Version imprimable

bon nouvelle question pour vous chers membres :
c'est la fonction touche qui me pose un probleme :

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
#include<stdio.h>
#include<stdlib.h>
#include<graph.h>
int ran(void) {
  /*cette fonction sert à trouver un entier entre 1 et 4 pour choisir le trou de sortie de la taupe*/
  int x;
  srand(time(NULL));
  x=(rand()%5)+1;
  return x;
}
void choix(int x, int t[]){
  /*cette fonction sert à représenter la taupe par un 1 dans le tableau en fonction du resultat de ran*/
  int i;
  for(i=0;i<5;i++){//cette boucle remplie les cases du tableau avec des 0.
    t[i]=0;
  }
  printf("le trou choisit est %d\n",x);
  switch (x)// ce switch sert à choisir dans quel trou la taupe va sortir en fonction de la valeur de x. un 1 montre l'emplacement de la taupe et un 0 montre qu'il n'y a rien.
    {
    case 1: t[0]=1;break;//trou en haut a gauche
    case 2: t[1]=1;break;//trou en haut a droite
    case 3: t[2]=1;break;//trou middle
    case 4: t[3]=1;break;//trou en bas a gauche
    case 5: t[4]=1;break;//trou en bas a droite
    }
  for(i=0;i<5;i++){//a retirer avant de rendre le projet, sert a afficher le contenu du tableau.
    printf("%d\n",t[i]);
  }
}
void touche(int t[],int points[]){
  //cette fonction permet de savoir si on a touché la taupe ou non
  while(!SourisCliquee())
    {
      SourisPosition();
      if(t[0]=1){
	if((_X>=100)&&(_X<=185)&&(_Y>=75)&&(_Y<=155))
	  points[0]=points[0]=10;
      }
      else if(t[1]=1){
	if((_X>=315)&&(_X<=405)&&(_Y>=70)&&(_Y<=150))
	  points[0]=points[0]=10;
      }
      else if(t[2]=1){
	if((_X>=200)&&(_X<=285)&&(_Y>=260)&&(_Y<=340))
	  points[0]=points[0]=10;
      }
      else if(t[3]=1){
	if((_X>=95)&&(_X<=180)&&(_Y>=445)&&(_Y<=520))
	  points[0]=points[0]=10;
      }
      else if(t[4]=1){
	if((_X>=330)&&(_X<=415)&&(_Y>=445)&&(_Y<=520))
	  points[0]=points[0]=10;
      }
    }
}
 
int main(void)
{
  int points[1]={0};
  int x,i,posfenetrex,posfenetrey;
  int t[5]={0,0,0,0,0};
  x=ran();
  choix(x,t);
  InitialiserGraphique();
  posfenetrex=(Maxx()/2)-250;//250 car moitié de 500
  posfenetrey=(Maxy()/2)-344;//344 car moitié de 688
  CreerFenetre(posfenetrex,posfenetrey,500,688);
  ChoisirEcran(0);
  ChargerImage("fond.xpm",0,0,0,0,500,688);/*les deux 1ers 0 montre a partir d'où charger la zone a charger ( à partir coin sup gauche ), les deux 0 d'apres place l'image ds la fenetre a partir du coin sup gauche et les deux derniers nombres montre quelle taille d'image est copiée*/
  touche(t,points);
  while(!SourisCliquee())
    {}
  FermerGraphique();
  printf("votre score est %d\n",points[0]);
  return EXIT_SUCCESS;}

la bibliotheque graphique que j'utilise est téléchargeable ici : cliquez ici

le principe est que l'on doit cliquer sur les trous donc les coordonnées sont mises dans mes if le probleme c'est que le trou n°1 me rajoute toujours des points et que pour les autres, mm si on lcique sur le bon, cela marche des fois et des fois celà rate. ( les fonctions Souris Cliquee et SourisPosition mette la position en x et y dans des vaiables globales nommées _X comme nous l'explique ceci :

Citation:

[ La récupération des coordonnées de la souris se fait par l'intermédiaire de deux variables globales (de type int)_X et _Y. ]

* La fonction void SourisPosition(); récupére dans _X et _Y les coordonnées de la souris au moment de l'appel de cette fonction.

* La fonction int SourisCliquee(); teste si un bouton de la souris a été cliqué (renvoie 1 ou 0), et place si c'est le cas ses coordonnées au moment du clic dans _X et _Y.

Bonjour,

un petit peu HS, mais ceci n'est pas tres consciencieux :

Code:

1
2
3
4
5
6
7
8
9
int ran(void) 
{
  /*cette fonction sert à trouver un entier entre 1 et 4 pour choisir le trou de sortie de la taupe*/
  int x;
  srand(time(NULL));
  x=(rand()%5)+1;
  return x;
}

Pour rappel, srand doit etre appeler une fois avec une graine differente : c'est pour ca qu'on utilise le temps machine.

Code:

1
2
3
4
5
 
int ran(void) 
{
  return (rand()%5)+1;
}

L'utilisation du % ne permet pas de faire des tirage equiprobable, voir FAQ pour plus d'info.

*****

Code:

1
2
3
4
5
6
7
8
9
10
 
    printf("le trou choisit est %d\n",x);
    switch (x)// ce switch sert à choisir dans quel trou la taupe va sortir en fonction de la valeur de x. un 1 montre l'emplacement de la taupe et un 0 montre qu'il n'y a rien.
    {
        case 1: t[0]=1;break;//trou en haut a gauche
        case 2: t[1]=1;break;//trou en haut a droite
        case 3: t[2]=1;break;//trou middle
        case 4: t[3]=1;break;//trou en bas a gauche
        case 5: t[4]=1;break;//trou en bas a droite
    }

Code:

1
2
3
4
 
    printf("le trou choisit est %d\n",x);
    /* Remplace le switch case */
    t[x-1]=1;

Donc :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
/*cette fonction sert à représenter la taupe par un 1 dans le tableau en fonction du resultat de ran*/
void choix(int x, int t[])
{
    printf("le trou choisit est %d\n",x);
 
    /* On initialise a 0 */
    int i;
    for(i=0 ; i<5 ; i++)
        t[i] = 0;
 
    /* On place la taupe */
    t[x-1] = 1;
 
}

*******

Code:

1
2
 
points[0]=points[0]=10;

???

ce ne serai pas plutot : points[0]=points[0]+10;

donc

Code:

1
2
 
points[0] += 10;

*****

Code:

1
2
 
if(t[4]=1)

Erreur d'inattention

Code:

1
2
if(t[4]==1)

-->

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
 
void touche(int t[],int points[])
{
  //cette fonction permet de savoir si on a touché la taupe ou non
    while(!SourisCliquee())
    {
        SourisPosition();
 
        if(t[0]==1)
        {
            if((_X>=100)&&(_X<=185)&&(_Y>=75)&&(_Y<=155))
                points[0]+=10;
        }
        else 
            if(t[1]==1)
            {
                if((_X>=315)&&(_X<=405)&&(_Y>=70)&&(_Y<=150))
                    points[0]+=10;
            }
            else
                if(t[2]==1)
                {
                    if((_X>=200)&&(_X<=285)&&(_Y>=260)&&(_Y<=340))
                        points[0]+=10;
                }
                else 
                    if(t[3]==1)
                    {
                        if((_X>=95)&&(_X<=180)&&(_Y>=445)&&(_Y<=520))
                            points[0]+=10;
                    }
                    else 
                        if(t[4]==1)
                        {
                            if((_X>=330)&&(_X<=415)&&(_Y>=445)&&(_Y<=520))
                                points[0]+=10;
                        }
    }
}

De plus, si tu utilise t[] comme un tableau de booleen (ce qui devrait etre le cas), tu peux raccourcir comme ceci :

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
 
void touche(int t[],int points[])
{
  //cette fonction permet de savoir si on a touché la taupe ou non
    while(!SourisCliquee())
    {
        SourisPosition();
 
        if((t[0]) && (_X>=100) && (_X<=185) && (_Y>=75) && (_Y<=155))
            points[0]+=10;
        else 
            if((t[1]) && (_X>=315) && (_X<=405) && (_Y>=70) && (_Y<=150))
                points[0]+=10;
            else
                if((t[2]) && (_X>=200) && (_X<=285) && (_Y>=260) && (_Y<=340))
                    points[0]+=10;
                else 
                    if((t[3]) && (_X>=95) && (_X<=180) && (_Y>=445) && (_Y<=520))
                        points[0]+=10;
                    else 
                        if((t[4]) && (_X>=330) && (_X<=415) && (_Y>=445) && (_Y<=520))
                            points[0]+=10;
    }
}

et en faisant plus obfusqué :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
void touche(int t[],int points[])
{
  //cette fonction permet de savoir si on a touché la taupe ou non
    while(!SourisCliquee())
    {
        SourisPosition();
 
        if((t[0]) && (_X>=100) && (_X<=185) && (_Y>=75) && (_Y<=155)  ||
           (t[1]) && (_X>=315) && (_X<=405) && (_Y>=70) && (_Y<=150)  ||
           (t[2]) && (_X>=200) && (_X<=285) && (_Y>=260) && (_Y<=340) ||
           (t[3]) && (_X>=95) && (_X<=180) && (_Y>=445) && (_Y<=520)  ||
           (t[4]) && (_X>=330) && (_X<=415) && (_Y>=445) && (_Y<=520))
            points[0]+=10;
 
    }
}

Voila, tu as deja de quoi faire

merci de m'avoir consacré ton temps, pour ce qui est de la fonction srand j'avoue qu'on nous a dit de l'utiliser en cours avec le % mais on ne sait pas trop comment elle marche. j'irai regarder un peu plus tard dans la FAQ ;)
pour le switch que tu me fait retirer, en cours on nous a dit d'éviter de mettre des variables dans le tableau je crois ou alors j'ai mal compris c'est pour ça que j'ai fait ce switch.
sinon le concept de variable booléenne est un peu vague dans mon esprit donc je vais me renseigner pour comprendre ta remarque sur le tableau :D
je reviendrai apres avoir un peu bossé ça.
EDIT : après quelques modifications suivant tes indications, celà fonctionne effectivement désormais. on ne gagne bien des points qu'en cliquant sur la bonne zone.
Cependant le nombre de points vare en fonction du temps pendant lequel on laisse tourner la boucle car apparement la fonction souris position renvoie sa position constamment ce qui fait monter tres vite le total de points.
je pense qu'il y a moyen d'éviter celà donc je vais chercher un peu :D
EDIT 2 : en fin de compte j'ai réglé ça avec une méthode peut etre pas tres correcte mais bon :
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 void touche(int t[],int points[]){ //cette fonction permet de savoir si on a touché la taupe ou non while(!SourisCliquee()) { points[0]=0;//evite que toutes les positions où on ne clique pas soient enregistrées SourisPosition(); if(t[0]==1){ if((_X>=100)&&(_X<=185)&&(_Y>=75)&&(_Y<=155)) points[0]=points[0]+10; } else if(t[1]==1){ if((_X>=315)&&(_X<=405)&&(_Y>=70)&&(_Y<=150)) points[0]=points[0]+10; } else if(t[2]==1){ if((_X>=200)&&(_X<=285)&&(_Y>=260)&&(_Y<=340)) points[0]=points[0]+10; } else if(t[3]==1){ if((_X>=95)&&(_X<=180)&&(_Y>=445)&&(_Y<=520)) points[0]=points[0]+10; } else if(t[4]==1){ if((_X>=330)&&(_X<=415)&&(_Y>=445)&&(_Y<=520)) points[0]=points[0]+10; } } }

Bon,

Alors, pour ce qui est du rand, y'a pas vraiment de probleme, on peut l'approcher par un %, d'autant plus que l'intervalle est petit.

Pour le fait d'eviter de mettre des variable dans le tableau, je ne vois pas de quoi ton cours veut parler, car pour afficher un tableau 2D de 100x100 case, on fait deux for imbrique et ensuite un printf avec Tableau[i][j]

Citation:

Cependant le nombre de points vare en fonction du temps pendant lequel on laisse tourner la boucle car apparement la fonction souris position renvoie sa position constamment ce qui fait monter tres vite le total de points.

Si on regarde ton code :

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
 
void touche(int t[],int points[])
{
  //cette fonction permet de savoir si on a touché la taupe ou non
    while(!SourisCliquee())
    {
        SourisPosition();
 
        if((t[0]) && (_X>=100) && (_X<=185) && (_Y>=75) && (_Y<=155))
            points[0]+=10;
        else 
            if((t[1]) && (_X>=315) && (_X<=405) && (_Y>=70) && (_Y<=150))
                points[0]+=10;
            else
                if((t[2]) && (_X>=200) && (_X<=285) && (_Y>=260) && (_Y<=340))
                    points[0]+=10;
                else 
                    if((t[3]) && (_X>=95) && (_X<=180) && (_Y>=445) && (_Y<=520))
                        points[0]+=10;
                    else 
                        if((t[4]) && (_X>=330) && (_X<=415) && (_Y>=445) && (_Y<=520))
                            points[0]+=10;
    }
}

On s'apercoit que tant qu'on a pas clicker, on regarde la position de la souris ET on regarde si on rajoute des points. Le mieux serai plutot de faire ceci :

Tant qu'on a pas clicker, on regarde la position de la souris PUIS on regarde si on ajoute des points.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
void touche(int t[],int points[])
{
  //cette fonction permet de savoir si on a touché la taupe ou non
    while(!SourisCliquee())
        SourisPosition();
 
    if((t[0]) && (_X>=100) && (_X<=185) && (_Y>=75) && (_Y<=155))
        points[0]+=10;
    else 
        if((t[1]) && (_X>=315) && (_X<=405) && (_Y>=70) && (_Y<=150))
            points[0]+=10;
        else
            if((t[2]) && (_X>=200) && (_X<=285) && (_Y>=260) && (_Y<=340))
                points[0]+=10;
            else 
                if((t[3]) && (_X>=95) && (_X<=180) && (_Y>=445) && (_Y<=520))
                    points[0]+=10;
                else 
                    if((t[4]) && (_X>=330) && (_X<=415) && (_Y>=445) && (_Y<=520))
                        points[0]+=10;
 
}

Voila, je pense que cela fait ce que tu veux.

22/12/2009, 13h29
Kuchiki Byakuya

effectivement ta remarque sur SourisPosition est pertinante, je n'y avais pas pensé.
j'avais résolu ce problème en rajoutant au début de la boucle points[0]=0;
comme ça il réinitialise à chaque fois. cependant celà risque peut etre de faire ramer mon programme, je verrai a l'usage quelle solution est la meilleure.
pour le moment il reste quelque petits bugs graphiques et à gérer la notion de temps.
je vous mettrais une version test débuggée pour que vous voyez ce pour quoi vous m'aidez :D
22/12/2009, 13h37
SofEvans

Citation:

Envoyé par Kuchiki Byakuya

j'avais résolu ce problème en rajoutant au début de la boucle points[0]=0;
comme ça il réinitialise à chaque fois. cependant celà risque peut etre de faire ramer mon programme, je verrai a l'usage quelle solution est la meilleure.

Si tu possede un pc avec 64 Mo de memoire vive, tu risque effectivement de faire ramer ton PC.

Blague a part, le probleme qui se pose est plutot d'ordre logique. De plus, si l'utilisateur gagne 10 point, si tu reappele cette boucle, il va retourner a 0. Je crois pas qu'il va etre content.
22/12/2009, 14h08
Kuchiki Byakuya

non j'ai 3 gigas de ram :D
en réalité les points ne sont pas réellement remis à 0 car a la fin de la fonction touche j'écris les points dans un fichier ( avec fopen et fprintf ) et j'affiche les scores à partir de là
car je dois dresser un journal des scores pour pouvoir faire une option meilleur score.
pour les variables dans le tableau, j'ai relu mes cours et tu as raison, j'avais de mauvais souvenirs :D
22/12/2009, 14h32
fenrir

Bonjour,

Un petit quelque chose me turlupine... (Attention pas de mauvais jeux de mots :aie:)

Si l'on suit la description de la fonction SourisCliquee() :

Citation:

* La fonction int SourisCliquee(); teste si un bouton de la souris a été cliqué (renvoie 1 ou 0), et place si c'est le cas ses coordonnées au moment du clic dans _X et _Y.

On se rend compte qu'elle renvoie les coordonnées au moment du clic.

Dans ces conditions, l'appel de la fonction void SourisPosition() dans la boucle while me paraît inutile.

Bon courage pour la suite de ton projet :ccool:.
22/12/2009, 15h23
SofEvans

Citation:

Envoyé par Kuchiki Byakuya

en réalité les points ne sont pas réellement remis à 0 car a la fin de la fonction touche j'écris les points dans un fichier ( avec fopen et fprintf ) et j'affiche les scores à partir de là
car je dois dresser un journal des scores pour pouvoir faire une option meilleur score.

Minute papillon,

La fonction touche ne sert, dans le cas present, a detecter uniquement lors du click si on clik sur la taupe. Il faut que la fonction touche soit incorporer dans une boucle de jeu.

En realité, pour ma part, j'ai l'impression que le nom de fonction est mal choisi : en lisant fonction touche, j'ai l'impression que la fonction dit si oui ou non tu as touché une taupe, alors qu'en realite elle ne retourne rien.

@fenrir : je suis tout a fait daccord avec toi
23/12/2009, 02h14
Kuchiki Byakuya

@fenrir : j'ai essayé effectivement mais il doit y avoir un bug car celà ne fonctionne pas...

@SofEvans : j'ai appelé la fonction touche dans une boucle qui se trouve dans mon main et qui contient un appel a la fonction random et un à la fonction choix entre autres.
je te montrerai dès que j'aurai eu le temps de commenter ça proprement

par contre j'ai des soucis avec la fonction MicroSecondes() je ne comprends pas du tout comment elle fonctionne...

j'ai un probleme pour gerer le temps, apparemment la fonction Microsecondes me renvoie un entier qui est le nombre de microsecondes écoulé depuis le lancement du programme, voilà ce que j'ai fait :
fans mon int :
Code:

1 2 3 4 5 6 7 8 9 10 jeux: { ChargerImage("fond.xpm",0,0,0,0,500,688);/*les deux 1ers 0 montre a partir d'où charger la zone a charger ( à partir coin sup gauche ), les deux 0 d'apres place l'image ds la fenetre a partir du coin sup gauche et les deux derniers nombres montre quelle taille d'image est copiée*/ tempsmax=12*1000000; while(Microsecondes()>=tempsmax){//il faudra remplacer les j par le temps. x=ran(); choix(x,t); affichetemps(tempsmax,Microsecondes()); touche(t,points,cumulpoints); affichepoints(cumulpoints); }}
la fonction affiche temps ( les autres n'ont pas de rapport avec le temps ) :
Code:

1 2 3 4 5 void affichetemps(int j,int k){ char param2[100]; sprintf(param2,"%d",j-k); EcrireTexte(0,304,param2,2);//445 }
ne corrigez pas si il y a des erreurs ailleurs que dans le calcul du temps, je pense que c'est mon approche qui est mauvaise :S

24/12/2009, 10h00
fenrir

Tu ne nous as pas dit comment et dans quelle condition l'affichage devait se faire. Mais de ce que je comprends de ton code (noms de variable), voici ce que j'en retire :

Tu récupères des temps en microsecondes : 1 s = 10e6 µs. (sauf si tu voulais des millisecondes :p, c'est pas pareil)

Ca ne devrait pas poser de problème pour le moment, mais attention pour la suite, un entier de 32bits signé va jusqu'à 2 147 483 648 µs = 2 147 s, soit environ 35 min ce qui même pour un jeu de tape taupe peut paraître court si ton utilisateur est très bon, passionné par ton jeu et ne vois pas le temps passer :aie:.
En non-signé, tu passeras à 1h10 c'est mieux, je te conseille toutefois de revoir tes unités vers des millisecondes pour avoir une plus grande marge de manoeuvre.

Ensuite pour les erreurs, voici ce que j'ai constatée :

1. Si j'ai bien compris (je ne suis que le nom de la variable), tempsmax vaut 12 secondes, et il s'agit du temps maximum d'affichage, au delà de ce temps, tu n'affiches plus rien.
Seulement ta boucle dit :

Code:

while(Microsecondes()>=tempsmax)

Pour moi ça signifie que tu attends 12 s avant de commencer à jouer et à afficher, tempsmax porte mal son nom et est une borne inférieure dans ce cas. De plus si au moment de rentrer dans ta boucle, le programme tournait depuis moins de 12s, et bien ta boucle sera court-circuitée (condition non respectée avant la première passe), il faut d'abord que tu t'assure que tu as attendu suffisament longtemps pour que Microsecondes() vale 12s.
2. De plus en rentrant dans ta boucle tu fais :

Code:

affichetemps(tempsmax,Microsecondes());

C'est à dire que tu affiches la valeur "tempsmax - Microsecondes()" avec la condition de boucle "Microsecondes()>=tempsmax", donc tu auras une valeur négative d'affichée, et en plus ta boucle sera infinie.

Voila, selon toute logique, tu as une première erreur (1.) qui te bloque qui fait que tu ne rentres pas dans ta boucle. Selon la façon dont tu corrigeras cette erreur, une seconde pourrait apparaître (2.) car ta boucle sera infinie et tu afficheras un temps négatif. Si tu corriges (1.) avec un "<=" au lieu d'un ">=" (2.) n'apparaîtra pas. Si tu corriges (1.) en t'assurant d'attendre suffisament longtemps pour que ton programme puisse rentrer dans la boucle (2.) apparaîtra. La façon de corriger dépends de ce que tu voulais que ton programme fasse.

Maintenant ne sachant pas ce que ton code doit faire, je me trompe peut-être, peux-tu nous préciser le fonctionnement attendu pour avancer moins en aveugle ;).

Oui, je pense que ton approche est mauvaise, car il n'y a, en fait, aucune gestion.

Voici comment on peut proceder :
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 #define FPS 60 /* temps en miliseconde */ int tempsPrecedent = 0, tempsSuivant = 0; int continuerJeu = 1; while (continuerJeu) { /* Ici, on recupere les action de l'utilisateur */ /* Puis, on agit en fonction */ /* On recupere le temps */ tempsSuivant = Microsecondes()/1000; if (tempsSuivant - tempsPrecedent > FPS*1000) { /* Ici, il faut faire l'affichage, affichage rafraichie toutes les 6/100 de seconde */ /* Si on oublie ca, la gestion est faussé */ tempsPrecedent = tempsSuivant; } }
Le probleme suivant se pose : tu as fait la fonction touche(), mais le probleme est que celle-ci est bloquante, c'est a dire que tant que l'utilisateur n'as pas clicker, tu boucle indefiniment. Et cela fausse tout.

Si tu veux garder ton code, je te conseille de faire un thread qui se chargerai de l'affichage.
Sinon, il va falloir que tu adapte ton codea la structure proposer au dessus.

24/12/2009, 14h31
fenrir
@sofEvans : Hmmmm corrige moi si je me trompe, mais j'ai l'impression que plutôt que faire du 60 images par seconde, ton programme fait du une image par 60 secondes.
tempsPrecedent et tempsSuivant sont en millisecondes et FPS*1000 = 60000 ms = 60 s.

Ne serait-il pas plus judicieur de faire :
Code:

1 2 3 4 5 6 #define FPS 60.0 // eventuellement #define FPS_INV 0.017 ... if ((tempsSuivant - tempsPrecedent) > ((1.0/FPS)*1000)) // ou alors // if ((tempsSuivant - tempsPrecedent) > (FPS_INV*1000))
Est-ce correct ?
24/12/2009, 15h20
SofEvans

N'ayant pas l'habitude de travailler en microseconde, je vais te laisser l'avantage ^^

Sinon, le principe est la.

Merci de tes corrections.
24/12/2009, 19h43
Kuchiki Byakuya

@SofEvans : je n'ai pas trop compris, je ne sais pas ce qu'est un thread et je ne comprends pas ton autre solution non plus :oops:
en tout cas je vais regarder si je peux changer quelques trucs.
voilà la version pour le moment, il y a surement d'autres bugs ailleurs mais je m'en occuperai plus tard. ( bugs sur l'ecran de presentation par exemple ) :
http://chevalierkasza.free.fr/dut/projet/projet.tar.gz

normalement il y a tout. il faut peut etre modifier score.txt pour remettre le contenu à 0 si il est sur un autre score :D
merci à vous en tout cas

Au sujet de mon explication :

Dans un jeu ou le temps s'écoule en temps réel, il y a deux trois chose a mettre en place pour que le jeu ai un comportement similaire d'une machine a l'autre.

Pour que l'animation de ton jeu soit régulier, il faut instaurer un système de FPS (Frame Per Second).
C'est a dire que toutes les X seconde, tu rafraichi l'écran. Ainsi, quelle que soit la vitesse de la machine, je jeu tournera de la même manière.

Globalement (d'après ce que j'ai vu), les fps choisi sont généralement de 60 (mais il y a des jeux comme America's Army ou les FPS sont de 100).

Le but du jeu est de pouvoir savoir quand on doit rafraichir l'écran. Si on prend 60 FPS, on doit rafraichir l'écran toutes les 1000.0/FPS milliseconde

Donc, il te faut le temps ou tu as rafraichit pour la dernière fois l'écran (tempsPrecedent) et le temps actuel (tempsSuivant). Ceux ci exprime des milliseconde.

En faisant la différence entre les deux, tu obtient le temps écoule depuis le dernier rafraichissement. Si ce temps est supérieur a 1000.0/FPS, alors il faut rafraichir l'écran:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 /* On récupère le temps */ tempsSuivant = Microsecondes()/1000; if (tempsSuivant - tempsPrecedent > FPS*1000) { /* Ici, il faut faire l'affichage */ /* Si on oublie ca, la gestion est faussé En effet, le dernier rafraichissement c'est passer a tempsSuivant */ tempsPrecedent = tempsSuivant; }
voila.

Pour info, un thread est un processus leger que tu peux creer (une sorte de deuxieme programme qui se lance pendant que ton programme est lancer (c'est tres grossier comme description, patapai Melem))

Et surtout, le plus important,

Joyeux Noël !!

25/12/2009, 05h58
Pouet_forever

Sachant que les moniteurs sont pour la plupart limités à 60hz je ne vois aucune utilité à avoir un FPS de 100. A part bien sûr si tu as un moniteur capable d'afficher du 100hz (ce qui m'étonnerais ^^).
Donc 60fps est un bon choix ;)

Pour les thread je t'invite à aller voir ici : http://franckh.developpez.com/tutoriels/posix/pthreads/

Joyeuses fêtes :)

Tout est dans les commentaire, il s'agit d'une version plus ou moins corriger
D'ailleurs, il faudra tester l'integrité des fichier apres un fopen.

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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
 
#include<stdio.h>
#include<stdlib.h>
#include<graph.h>
 
 
 
/* Fonction ran(void) inutile, elle n'est appeler qu'a un seul endroit et ne fait qu'une chose */
/* Variable scoref de type FILE* inutile dans le main, inutile a passer, non initialisera NULL, et retour non verifier */
/* Variable posfenetrex et posfenetrey inutile, utiliser a un seul endroit. */
/* Passage de x dans "choix" inutile, on peut avoir x dans "choix" */
/* passage de deux parametre a affichetemps discutable, on peut tres bien faire la soustraction dès l'appel
   à affichetemps et donc ne passer qu'un parametre, ce qui serait plus lisible */
/* declaration de param dans affichepoints inutile puisque non utilisé */
 
/* Faire des tableau de 1 case ne represente strictement aucun interet a moins de prevoir une evolution futur */
 
/* La fonction srand doit etre appeler qu'une seule et unique fois */
 
/* Indente correctement le code tout le temps, c'est vital */
 
/*     while(!ToucheEnAttente()){}   revient a ecrire
       while(!ToucheEnAttente());  */
 
/* Le fait de faire appel a des goto est un tres mauvais choix. Cela ne fait qu'embrouiller le code et perdre celui
   qui le relis. Le mieux est de faire des fonctions */
 
/*  int r=1;
    while(r=1)
    {
    }
 
r n'est jamais modifier, boucle infini et r inutile */
 
/* goto fin n'est jamais appeler, donc, il est inutile */
 
/* Point ne sert stricitement a rien, son role est obscure et pas assez explicite.
   Variable supprimer */
 
/* La variable score a les meme remarque que Point, role oscure et non definit, le meiux aurait
   été de la nommer "Record". De plus, elle n'est utile QUE dans "record", il ne sert a rien de
   la passer par argument */
 
/* Variable i, j dans "main" ne servent a rien, elles ne sont jamais utilisé */
 
/* la fonction "choix", si mes supposition sont bonne, doit etre appeler apres un "bon" click.
   Donc, il faut mettre "choix" dans la fonction "touche" */
 
/* Variable     char param[100] et char param2[100] de main jamais utilisé -> inutile */
 
/* Variable     int ancienrecord,temps,tempsmax; de main inutile car jamais utilisé */
 
/* Rennomage de cumulPoint en pointJoueur (ce n'est pas une erreur, juste une preference) */
 
 
/* Voila, je m'arrete ici car, etant windows only, je ne peux pas installer ta librairie et donc
   tester.
   Cependand, on voit bien ici une desorganisation total du code.
   Je te suggere de réecrire le code en essayant de declarer le moins de variable possible, qu'a
   chaque fois que tu declare une variable tu te demande si elle est vraiment indispensable.
   Je te conseille aussi de nommer le plus clairement et le plus intuiitifement tes variable.
   Une variable "cumulPoint" et "point" sont un peu trop proche (d'ailleurs, les deux avait presque
   le meme role) */
 
 
 
 
 
/*cette fonction sert à représenter la taupe par un 1 dans le tableau en fonction du resultat de ran*/
void choix(int t[])
{
    /* On initialise a 0 */
    int i;
    for(i=0 ; i<5 ; i++)
        t[i] = 0;
 
    /* On place la taupe */
    t[rand()%5]=1;
}
 
/*Cette fonction sert à afficher le temps qui s'écoule*/
void affichetemps(int temps)
{
  char texte[100];
  sprintf(texte, "%d", temps/1000000);
  EcrireTexte(445,304,texte,2);
}
 
/*Cette fonction affiche le score en bas de l'ecran*/
void affichepoints(int pointJoueur)
{
    ChargerImage("fond.xpm", 0, 0, 0, 0, 500, 688);
 
    char texte[100];
    sprintf(texte, "%d", pointJoueur);
    EcrireTexte(225, 600, texte, 2);
}
 
/*Cette fonction donne le score final et dit si vous avez battu un record ou pas */
void record(int pointJoueur)
{
    int score;
 
    FILE *scoref = NULL;
 
    char param[100];
    ChargerImage("score.xpm",0,0,0,0,500,688);
 
    scoref=fopen("score.txt","r");
    fscanf(scoref,"%d",&score);
    fclose(scoref);
 
    if(score>pointJoueur)
    {
        sprintf(param,"Vous n'avez pas battu le record");
        EcrireTexte(50,200,param,2);
        sprintf(param,"qui etait de %d",score);
        EcrireTexte(150,300,param,2);
        sprintf(param,"Votre score est de %d",pointJoueur);
        EcrireTexte(100,400,param,2);
    }
    else
        if(score<pointJoueur)
        {
            sprintf(param,"Ancien record : %d, nouveau record : %d",score,pointJoueur);
            EcrireTexte(0,344,param,2);
            scoref=fopen("score.txt","w");
            fprintf(scoref,"%d",pointJoueur);
            fclose(scoref);
        }
        else
        {
            sprintf(param,"Vous avez egalise votre record");
            EcrireTexte(50,200,param,2);
            sprintf(param,"Votre score est de %d",pointJoueur);
            EcrireTexte(80,400,param,2);
        }
 
}
 
void touche(int t[], int pointJoueur)
{
    if(SourisCliquee())
    {
        if(t[0])
        {
            if((_X>=102)&&(_X<=182)&&(_Y>=75)&&(_Y<=155))
                pointJoueur += 10;
            //SauverImage("zonetaupe.xpm",100,75,80,80);
            ChargerImage("taupe.xpm",102,75,0,0,80,80);
        }
        else
            if(t[1])
            {
                if((_X>=315)&&(_X<=415)&&(_Y>=70)&&(_Y<=150))
                    pointJoueur += 10;
                //SauverImage("zonetaupe.xpm",315,70,80,80);
                ChargerImage("taupe.xpm",315,70,0,0,80,80);
            }
            else
                if(t[2])
                {
                    if((_X>=202)&&(_X<=282)&&(_Y>=260)&&(_Y<=340))
                        pointJoueur += 10;
                    //SauverImage("zonetaupe.xpm",200,260,80,80);
                    ChargerImage("taupe.xpm",202,260,0,0,80,80);
                }
                else
                    if(t[3])
                    {
                        if((_X>=98)&&(_X<=178)&&(_Y>=442)&&(_Y<=522))
                            pointJoueur += 10;
                        //SauverImage("zonetaupe.xpm",95,445,80,80);
                        ChargerImage("taupe.xpm",98,442,0,0,80,80);
                    }
                    else
                        if(t[4])
                        {
                            if((_X>=332)&&(_X<=412)&&(_Y>=442)&&(_Y<=522))
                                pointJoueur += 10;
                            //SauverImage("zonetaupe.xpm",330,445,80,80);
                            ChargerImage("taupe.xpm",332,442,0,0,80,80);
                        }
 
        /* Si on met choix ici, cela veut dire qu'apres un click, bon ou mauvais, la taupe disaprait */
        choix(t);
        ChargerImage("fond.xpm",0,0,0,0,500,688);/*charge a nouveau le fond pour faire disparaitre la taupe.*/
    }
}
 
int main(void)
{
    int pointJoueur = 0;
    int t[5]={0,0,0,0,0};
 
 
    srand(time(NULL));
 
    InitialiserGraphique();
 
    CreerFenetre(Maxx()/2-250, Maxy()/2-344, 500, 688);
    ChoisirEcran(0);
 
    /*debut de l'ecran de presentation*/
    ChargerImage("chargement.xpm",0,0,0,0,500,688);
    ChargerImage("acceuil.xpm",0,0,0,0,500,688);
 
    while(1)
    {
        choixx1:
        {
            while(1)
            {
 
                ChargerImage("play1.xpm",0,319,0,0,200,50);
                ChargerImage("exit1.xpm",0,588,0,0,200,50);
 
                while(!SourisCliquee());
 
                if((319<_Y)&&(_Y<369)&&(0<_X)&&(_X<200))
                {
                    ChargerImage("play.xpm",0,319,0,0,200,50);
                    goto choixx;
                }
 
                if((588<_Y)&&(_Y<638)&&(0<_X)&&(_X<200))
                {
                    ChargerImage("exit.xpm",0,588,0,0,200,50);
                    goto choixx;
                }
            }
 
        }
 
        choixx:
        {
            while(!SourisCliquee());
 
            if((319<_Y)&&(_Y<369)&&(0<_X)&&(_X<200))
                goto jeux;
            if((588<_Y)&&(_Y<638)&&(0<_X)&&(_X<200))
                return EXIT_SUCCESS;
            goto choixx1;
        }
    }/*fin de l'ecran de presentation*/
 
 
    jeux:
    {
        ChargerImage("fond.xpm",0,0,0,0,500,688);/*les deux 1ers 0 montre a partir d'où charger la zone a charger ( à partir coin sup gauche ), les deux 0 d'apres place l'image ds la fenetre a partir du coin sup gauche et les deux derniers nombres montre quelle taille d'image est copiée*/
 
        int m,ma;
 
        m=Microsecondes()+10000000; /*réglé pour 10scd,réglage pour 2mn=+120000000*/
        ma=Microsecondes();
 
        /* En realite, on fait une temporisation de 10000000 microseconde soit 10 seconde
           Le jeu dure donc theoriquement 10 seconde */
        while (ma<m)
        {
            ma = Microsecondes();
 
            touche(t,pointJoueur);
 
            /* Affichage */
 
            /* Fait un compte a rebours */
            affichetemps(m-ma);
            /* Affiche les points */
            affichepoints(pointJoueur);
        }
    }
 
    /* On verifier que les point gagner par le joueur ne depasse pas son record */
    record(pointJoueur);
 
    /*cliquer sur une touche quitte le programme quand le jeu est fini*/
    while(!ToucheEnAttente());
 
    FermerGraphique();
    return EXIT_SUCCESS;
 
}

07/01/2010, 19h24
Kuchiki Byakuya

bon je rends ce projet en début de semaine, je vous posterai a ce moment le résultat final si vous le désirez, merci a ceux qui ont répondu à mes questions, c'est super simpa à tous ;)