Jeu motus: affichage de mot tapé

**janyoura** · 03/04/2012, 01h57

Salut
je veux faire une fonction qui affiche le mot tapé par l'utilisateur, lettre par lettre, chacune dans la case correspondante, cependant je trouve que l'idée de faire des cases(images) contenant les lettres et les coller à l'image de fond (matrice de cases) est difficile à gérer. y'a t'il un autre moyen?
merci

**wax78** · 03/04/2012, 14h15

Oui, par exemple construires les "cases" en écrivant du texte dedans (SDL_TTF).

**janyoura** · 03/04/2012, 15h43

Pouvez vous me fournir un exemple?
je suis débutante en SDL
merci

**LittleWhite** · 04/04/2012, 10h37

Bonjour,

Vous pouvez lire nos tutoriels pour en apprendre plus sur la SDL -> http://loka.developpez.com/tutoriel/sdl/sdl_ttf/ (pour écrire) et plus en général : http://jeux.developpez.com/tutoriels/?page=prog2d#sdl

**janyoura** · 09/04/2012, 12h58

salut, pouvez vous m'aider à savoir pourquoi le code ne fonctionne pas? il n'affiche pas le caractère, il affiche le screen puis se ferme directement.
Merci

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
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
#include <stdlib.h>
#include <stdio.h>
#include "SDL/SDL.h"
 
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
const int SCREEN_BPP = 32;
SDL_Surface *bleu = NULL;
SDL_Surface *rouge = NULL;
SDL_Surface *bleu_jaune = NULL;
SDL_Surface *screen = NULL;
SDL_Surface *image = NULL;
void Slock(SDL_Surface *screen)
{
  if ( SDL_MUSTLOCK(screen) )
  {
    if ( SDL_LockSurface(screen) < 0 )
    {
      return;
    }
  }
}
 
 
 
void Sulock(SDL_Surface *screen)
{
  if ( SDL_MUSTLOCK(screen) )
  {
    SDL_UnlockSurface(screen);
  }
}// dessine une image dans une surface dest2 sur la surface dest
void DrawIMG(SDL_Surface *img, int pos_x, int pos_y, int w, int h, int pos_x2, int pos_y2)
{
SDL_Rect dest;
dest.x = pos_x;
dest.y = pos_y;
SDL_Rect dest2;
dest2.x = pos_x2;
dest2.y = pos_y2;
dest2.w = w;
dest2.h = h;
SDL_BlitSurface(img, &dest2, screen, &dest);
}
 
//dessiner une image sur une surface d coordonnées dest
void DessIMG(SDL_Surface *img, int pos_x, int pos_y)
{
SDL_Rect dest;
dest.x = pos_x;
dest.y = pos_y;
SDL_BlitSurface(img, NULL, screen, &dest);
}
 
/*****************************************************************************/
/***********************Dessine une image en arriere plan*********************/
/*****************************************************************************/
void DrawBG()
{
Slock(screen);
DessIMG(image,0,0);
SDL_Flip(screen);
Sulock(screen);
}
 
/*****************************************************************************/
/*****Permet d'afficher un caractere en fonction de x et y vec une couleur****/
/*****************************************************************************/
void affiche_caract (char caract,int x,int y,SDL_Surface *couleur)
{
int i=0,test=0;
while ( test==0 )
{
  // on n'affiche pas les espaces
  if (  caract == (' ') )
        return;
 
 
    if (  caract == ('a'+i) )
        {
        if (i<15)  //de 'a' à 'a'+14 on affichee les lettres à partir de
                   //x=32+i*32 et y=128 dans le fichier pointé par couleur
                        {
                        Slock(screen);
                        DrawIMG(couleur,x*32,y*32,32,32,32+i*32,128);
                        SDL_Flip(screen);
                        Sulock(screen);
                        test=1;
                        }
        else       //au dela de 'a'+14 on affichee les lettres à partir de
                   //x=0 et y=160 dans le fichier pointé par couleur
                        {
                        Slock(screen);
                        DrawIMG(couleur,x*32,y*32,32,32,(i-15)*32,160);
                        SDL_Flip(screen);
                        Sulock(screen);
                        test=1;
                        }
 
        }
    i++;
}
}
/***************************************************************************/
/*
   Cette Fonction Dessine Un Carreau Dans La Scene, Destiné à Récuperer Une
   Lettre Tapée Par Le Joueur.
   x : abscisse.
   y : ordonne.
   c : lettre.
   color : couleur de fond.
*/
int main( int argc, char* args[] )
{
    char c;
 
      if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 )
    {
        return 1;
    }
     SDL_Init(SDL_INIT_VIDEO);
 
 screen = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE );
  if( screen == NULL )
    {
        return 1;
    }
 affiche_caract(c, 32, 32, NULL);
 
 
 
}

**fearyourself** · 09/04/2012, 17h17

Il faut commencer par mettre une boucle de gestion des événements et qui fermera la fenêtre que si l'utilisateur appuie sur une touche.

http://fearyourself.developpez.com/t...morpion/part1/

Jc

**edgarjacobs** · 09/04/2012, 20h18

En dehors du fait que fearyourself a raison, que vaut c dans le main?

**janyoura** · 09/04/2012, 21h58

j'ai ajouté

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
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
/*****************************************************************************/
/******On récupere le mot tapé par le joueur pour ensuite le comparer*********/
/*****************************************************************************/
 
char * saisi ( int y )
{
char * mot_saisi;
int i=0,quit=0;
 
//SDL_Event event;
//On vide le tampon clavier de la SDL
SDL_Event event;
while(SDL_PollEvent(&event)) { }
mot_saisi=(char*)malloc(8*sizeof(char));
 
        while( quit!=1 )
        {
                while( SDL_PollEvent( &event ) )
                {
 
                        //Si une touche est appuyée
                        if ( event.type == SDL_KEYDOWN )
                        {
 
                        //Si la touche est une lettre de l'alphabet
                        //et que le mot n'a pas déjà 5 lettres
                        //On la stocke dans mot_saisi
                           if (event.key.keysym.unicode>='a' &&
                                event.key.keysym.unicode<='z' && i<5)
                              {
                              *(mot_saisi+i)=event.key.keysym.unicode;
                              affiche_caract(*(mot_saisi+i),i,y,bleu);
                              i++;
                              }
 
                        //Si l'on veut effacer et qu'il y a plus que 0 lettre
                        if (event.key.keysym.sym == SDLK_BACKSPACE && i>0)
                              {
                              i--;
                              effacer(i,y);
                              }
                        //Si on appuie sur entrée et que le mot_saisi fait 5 lettres
                        //alors on sort de la boucle
                        if (event.key.keysym.sym == SDLK_RETURN && i==5)
                              {
                              quit=1;
                              }
                        }
                }
        }
 
 
return (mot_saisi);
}
/*****************************************************************************/
/**************************************Main***********************************/
/*****************************************************************************/
 
 
int main( int argc, char* args[] )
{
    char *un_mot;
 
    un_mot=(char*)calloc(sizeof(char),8);
    InitIMG();
 
      if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 )
    {
        return 1;
    }
 
 
screen=SDL_SetVideoMode(640,480,32,SDL_HWSURFACE|SDL_DOUBLEBUF);
  if( screen == NULL )
    {
        return 1;
    }
    SDL_EnableUNICODE( 1 );
     SDL_Event event;
 
 saisi(6);
 
   SDL_Quit();
 
    return EXIT_SUCCESS;
 
 
}

et ça marche pas encore

**edgarjacobs** · 10/04/2012, 00h16

Pourquoi imbriquer deux boucles while?

De plus, dans ton cas, l'usage de SDL_PollEvent() n'est pas nécessaire, un SDL_WaitEvent() conviendra mieux.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
quit=0;
while(quit==0) {
    SDL_WaitEvent(&event);
    if(event.type==SDL_KEYDOWN) {
        .
        .
        .
        // mettre quit=1 quelque part, suivant ta logique
        .
        .
       }
   }

Ceci , est la structure générale d'une boucle qui attend un évènement.

PollEvent() est employé (à la place de waitEvent()) lorsque, dans une boucle d'attente, il y a des choses à faire même si l'utilisateur ne fait pas d'entrée clavier ou souris. Par exemple, afficher un chronomètre qui décompte le temps, ou, dans un jeu, déplacer les ennemis du personnage principal.

Edgar.

**janyoura** · 10/04/2012, 00h32

il' y a SDL_PollEvent() car ce n'est qu'une partie du programme ce que je mets, la procédure complète contiendra plusieurs évènement, sinon pour le while vous avez raison

**janyoura** · 10/04/2012, 22h12

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <stdio.h>
#include <stdlib.h>
#include <SDL/sdl.h>
 
int main ( int argc, char** argv )
{
 
   SDL_Surface* screen = NULL;
   SDL_Surface *img= NULL;
   SDL_Event event;
   SDL_Rect dest;
   int continuer=1;
 
    // create a new window
    SDL_Init(SDL_INIT_VIDEO);
 
    screen=SDL_SetVideoMode(640,480,32,SDL_HWSURFACE|SDL_DOUBLEBUF);
 
    while(continuer)
 {
 
        SDL_WaitEvent(&event);
 
               switch(event.type)
                        {
                            case SDL_KEYDOWN:
                                 switch(event.key.keysym.sym)
                                 {
                                     case SDLK_a:
                                     dest.x=100;
                                     dest.y=100;
                                 img = SDL_LoadBMP("./A.bmp");
                                 SDL_BlitSurface(img, NULL, screen, &dest);
                                 SDL_Flip(screen);
 
                                 break;
 
 
                                 }
                         break;
                        }
 
 
 }
 
 
 
    return 0;
}

Je veux lorsque l'utilisateur tape sur le caractère 'a' l'image correspondante (case dans laquelle est écris 'A') se charge et s'affiche dans l'écran. le problème c'est que le code ne fonctionne pas et je ne sais pas pourquoi. merci pour l'aide. je travail sur C/SDL

**fearyourself** · 11/04/2012, 00h44

Ok, tu mélanges deux choses :

- Tu dois avoir une boucle qui gére des événements d'un côté...

- Si tu as des choses à afficher, tu dois les garder en mémoire...

- Une fois les événements gérés, tu dois gérer ton affichage :
1) Tu effaces le rendu
2) Tu affiches ce que tu veux
3) Tu reviens sur les événements...

Donc:
- Charger l'image dans la gestion d'événement est un non-non car tu dois le faire avant
- Tu dois faire le blit et le flip après les événements...

Jc

**janyoura** · 11/04/2012, 01h23

Envoyé par fearyourself

Donc:
- Charger l'image dans la gestion d'événement est un non-non car tu dois le faire avant
- Tu dois faire le blit et le flip après les événements...

Jc

Mais comme ça je ne sais plus comment faire parce que l'affichage dépend du mot tapé :\ et donc il doit être dans le switch case, non? chaque lettre de l'alphabet a son image correspondante.

**edgarjacobs** · 11/04/2012, 17h50

fearyourself à raison, il ne faut pas charger l'image à chaque fois que tu veux l'afficher !

Ce que tu peux (doit) faire:
1° Tu déclares une variable SDL_Surface *alphabet[26]
2° Dans ton main, tu appelles une fonction qui remplit alphabet
3° Dans ta boucle while, pour chaque lettre enfoncée, tu affiches alphabet[event.key.keysym.unicode-'a'] (à condition que la lettre choisie se trouve dans l'intervalle a..z)

Pour remplir la variable alphabet, pas besoin de switch, tu construis le nom de fichier en fonction de l'indice de ta boucle (i=0 -> A.bmp, i=1 -> B.bmp,..., i=25 -> Z.bmp)

La boucle du traitement des évènements devient alors:

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
 
continue=1;
while(continue) {
	SDL_WaitEvent(&event);
	switch(event.type) {
		case SDL_KEYDOWN:
			if(event.key.keysym.sym>=SDLK_a && event.key.keysym.sym<=SDLK_z) {
				.
				SDL_BlitSurface(alphabet[event.key.keysym.unicode-'a'],...);
				SDL_Flip(...); // Quoique je préfère de loin SDL_UpdateRect(...);
				.
				}
			else {
				.
				.
				}
			break;
		case SDL_MOUSEBUTTONUP:
			.
			.
			break;
		default: break;
		}
	}

- Si tu ne traites que le cas SDL_KEYDOWN, un if(...) suffira.
- Evidemment, ne pas oublier de faire continue=0 quelque part dans la boucle while.
- A modifier pour prévoir le cas où l'utilisateur utilise les majuscules.

Edgar.

Jeu motus: affichage de mot tapé

SDL

Discussions similaires

Partager

Partager