Discussion :

[maximus35]

Bonjour à tous, je suis un nouveau programmer.
Comme tous les débutants, je me pose des problèmes et je tente de les résoudre ... parfois sans résultat -_-

En voici un exemple
j'ai créer un code qui produit un tableau dynamique 4*4 remplie de valeur aléatoirement tiré dans l’intervalle 0 à 4, ensuite je fait un blit tuile par tuile du tableau

Et la c'est le drame, j'ai besoin d'aide pour comprend pourquoi mon code me retourne l'erreur -5 ligne 100 du code.

Merci d'avance

Maxime

voici le code c:

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
 
/* afficher l'univers
Fonction_afficher_univers.c
 
Fonction: permet d'afficher l'univers en quelques tuiles
Par: Maxime
*/
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <SDL.h>
#include <SDL_image.h>
#include <SDL_rotozoom.h>
 
void Afficher(SDL_Surface* screen,SDL_Surface* tileset,int **table,int HAUTEUR_TILES,int LARGEUR_TILES,int nombre_blocs_largeur,int nombre_blocs_hauteur);
double frand_a_b(double a, double b);
int **remplir_tableau(int nbtiles_largeur_monde,int nbtiles_hauteur_monde);
 
int main(int argc,char** argv)
{
    int LARGEUR_TILE=240;
    int HAUTEUR_TILE=160;
    int nbtiles_largeur_monde=4;
    int nbtiles_hauteur_monde=4;
 
	SDL_Surface* screen,*tileset;
	SDL_Event event;
	SDL_Init(SDL_INIT_VIDEO);
 
	screen = SDL_SetVideoMode(LARGEUR_TILE*nbtiles_largeur_monde, HAUTEUR_TILE*nbtiles_hauteur_monde, 32,SDL_HWSURFACE|SDL_DOUBLEBUF);
	tileset = IMG_Load("environnement.png");
	if (!tileset)
	{
		printf("Echec de chargement tileset1.bmp\n");
		exit(-1);
	}
	SDL_Flip(screen);
    int **table= remplir_tableau(nbtiles_largeur_monde,nbtiles_hauteur_monde);
	Afficher(screen,tileset,table,HAUTEUR_TILE,LARGEUR_TILE,nbtiles_largeur_monde,nbtiles_hauteur_monde);
 
	do
	{
		SDL_WaitEvent(&event);
	} while (event.type!=SDL_KEYDOWN);
 
	SDL_FreeSurface(tileset);
	SDL_Quit();
	free(table);
	return 0;
}
void Afficher(SDL_Surface* screen,SDL_Surface* tileset,int **table,int HAUTEUR_TILE,int LARGEUR_TILE,int nbtiles_largeur_monde,int nbtiles_hauteur_monde)
{
	int i,j;
	SDL_Rect Rect_dest;
	SDL_Rect Rect_source;
	Rect_source.w = LARGEUR_TILE;
	Rect_source.h = HAUTEUR_TILE;
	for(i=0;i<nbtiles_largeur_monde;i++)
	{
		for(j=0;j<nbtiles_hauteur_monde;j++)
		{
			Rect_dest.x = i*LARGEUR_TILE;
			Rect_dest.y = j*HAUTEUR_TILE;
			Rect_source.x = (table[j][i]-'0')*LARGEUR_TILE;
			Rect_source.y = 0;
			SDL_BlitSurface(tileset,&Rect_source,screen,&Rect_dest);
		}
	}
	SDL_Flip(screen);
}
 
int **remplir_tableau(int nbtiles_largeur_monde,int nbtiles_hauteur_monde)
{
    int i,j;
    tab= calloc(nbtiles_largeur_monde, sizeof(int));
    if(tab == NULL)
        {
            SDL_Quit();
            exit(-3);
        }
 
    for(i=0 ; i < nbtiles_largeur_monde  ; i++)
    {
      tab[i] = malloc(nbtiles_hauteur_monde  * sizeof( **tab) );
      if(tab[i] == NULL)
        {
            SDL_Quit();
            exit(-4);
        }
 
    }
 
	for(i=0;i<nbtiles_largeur_monde;i++)
	{
		for(j=0;j<nbtiles_hauteur_monde;j++)
		{
			int a=0;
			int b=4;
			int nombre=0;
			nombre = frand_a_b(a,b);
			if(nombre == 0)
            {
                SDL_Quit();
                exit(-5);
            }
			tab[i][j]=nombre;
		}
	}
	return tab ;
}
 
double frand_a_b(double a, double b)
{
    return (rand()/(double)RAND_MAX)*(b-a) +a;
}

[Neckara]

Tu fait un frand(a,b), l’équivalent de rand()%(b-a)+a je suppose.

Mais quand on utilise rand, il faut toujours faire un srand(time(NULL)) au début sinon les valeurs renvoyés sont toujours les mêmes.

[jabbounet]

je confirme il faut initialiser ton générateur.

La fonction srand() utilise son argument comme "graine" pour la génération d'une nouvelle séquence de nombres pseudo-aléatoires, qui seront fournis par rand(). Ces séquences sont reproductibles en appelant srand() avec la même valeur de graine.

[maximus35]

En effet j'avais oublier ce petit détail ... je commence à être étourdi moi à la long ^^

j'ai effectué la correction maintenant ma fenêtre s'affiche, mais je n'ai aucun blit à l’écran. J'ai testé avec un nombre de 2 tuiles mais rien à faire je ne comprend pas pourquoi ? -_-

Une idée ?

Maxime

[Neckara]

Je n'ai pas trop le temps de bien tout regarder mais tes SDL_flip marchent apparemment.

1) Vérifie bien que tu ne blit pas une grande surface par-dessus ce que tu veux afficher.

2) Vérifie que tes SDL_Surfaces contiennent bien une image.

3) Regarde les positions aux quelles tu blit les images si tu blit à {-100;-100} tu ne verra pas ta surface

4) Et si tu ne trouve pas, compare les adresses vers lesquelles pointent tes SDL_Surfaces pour voir si tu n'aurais pas réécris dessus.

[maximus35]

Je mis attelle des à présent, j’éditerais ce message pour vous dire comment cela c'est passé

Merci ^^