Bug bizarre incompréhensible

Version imprimable

[Résolu] Bug bizarre incompréhensible

Bonsoir !
Je développe dans le cadre d'un projet scolaire un jeu de tétris. Hélas, un bug bizarre me bloque depuis quelques temps.

Voilà la source : http://pastebin.com/mca18847
La compilation requiert la SFML de Laurent Gomila.

Mon problème : dans la méthode place de la classe Tetris, dans la boucle, gdb me dit que je modifie une variable, alors que c'est faux (ligne ~404).

Voilà ce que me dit gdb :

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
kreeg@kubuntu:~/Bureau/C++$ gdb ./tetris -q
Using host libthread_db library "/lib/tls/i686/cmov/libthread_db.so.1".
(gdb) b 281
Breakpoint 1 at 0x8049ef7: file tetris.cpp, line 281.
(gdb) enable once 1
(gdb) run
Starting program: /home/kreeg/Bureau/C++/tetris
[Thread debugging using libthread_db enabled]
[New Thread 0xb6d76900 (LWP 8325)]
[Switching to Thread 0xb6d76900 (LWP 8325)]
 
Breakpoint 1, Tetris (this=0xbfd55888, renderer=0x80f5dd0) at tetris.cpp:281
281     }
(gdb) p &current_brick
$1 = (Tetris::Brick *) 0xbfd55888
(gdb) watch *(0xbfd55888)
Hardware watchpoint 2: *3218430088
(gdb) continue
Continuing.
Hardware watchpoint 2: *3218430088
 
Old value = 135419368
New value = 3
Tetris::place (this=0xbfd55888, p={x = 1, y = -21}, dim={x = 4, y = 1}) at tetris.cpp:404
404                     for (int j = p.y - dim.y + 1; j <= p.y; j++)
(gdb) kill
Kill the program being debugged? (y or n) y
(gdb) quit
kreeg@kubuntu:~/Bureau/C++$

Merci d'avance !

24/04/2008, 14h29
Kreeg

UP

Je me demande si le titre est convenable, devrais-je l'éditer ?
24/04/2008, 15h57
r0d

Non mais c'est que tout le monde n'a pas forcément le temps (ni la possibilité, à cause des proxies qui bloquent tout, ce aui est mon cas) de télécharger ton source pour l'analyser.

Pourrais-tu extraire de ton code la partie qui pose problème et la poster (sans oublier la balise [code] ;) )?

Bien ; je vais tenter de synthétiser ce 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
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
// Insère la pièce dans le jeu
bool
Tetris::insert() {
	if (
		verify(
				Pos2D(current_brick.get_position(), 15),
				Pos2D(current_brick.get_width(), current_brick.get_height())
		)
	   )
		return true;
 
	for (
			int i = current_brick.get_position();
			i < current_brick.get_position() + current_brick.get_width();
			i++
		)
		for (int j = 15; j > 15 - current_brick.get_height(); j--) {
			Case c = current_brick(
									i - current_brick.get_position(),
									15 - j
								  );
			if (c == ACTIVE)
				grid[i][15 - j] = ACTIVE;
		} 
 
	return false;
}
 
/*
* Vérifie s'il est possible que la pièce descende.
* Renvoie true s'il y a un hit.
*/
bool
Tetris::verify(Pos2D p, Pos2D dim) {
	for (int i = p.x; i < p.x + dim.x; i++)
		for (int j = p.y - dim.y + 1; j <= p.y; j++)
			if (grid[i][j] != EMPTY && current_brick(i - p.x, j - p.y + dim.y - 1) == ACTIVE)
				return true;
 
	return false;
}
 
// Finalise le déplacement de la brique
void
Tetris::set() {
	for (int i = 0; i < 8; i++)
		for (int j = 0; j < 16; j++)
			if (grid[i][j] == ACTIVE)
				grid[i][j] = blue ? BLUE : RED;
}
 
void
Tetris::unset() {
	for (int i = 0; i < 8; i++)
		for (int j = 0; j < 16; j++)
			if (grid[i][j] == ACTIVE)
				grid[i][j] = EMPTY;
}
 
// Déplace la brique
void
Tetris::place(Pos2D p, Pos2D dim) {
	for (int i = p.x; i < p.x + p.x + dim.x; i++)
		for (int j = p.y - dim.y + 1; j <= p.y; j++)
			if (current_brick(i - p.x, j - (p.y - dim.y + 1)))
				grid[i][j] = ACTIVE;
}
 
// Méthode clé : permet de faire tomber une brique dans le jeu
void
Tetris::fall() {
	place_mode = false;
	Pos2D p(current_brick.get_position(), 15);
	Pos2D dim(current_brick.get_width(), current_brick.get_height());
 
	// Insertion de la pi�ce
	bool hit = insert();
 
	p.y--;
 
	while (!hit || p.y - current_brick.get_height() + 1) {
		unset();
		hit = verify(p, dim);
		place(p, dim);
		p.y--;
	}
 
	set();
}
 
/*
* Permet d'accéder à la matrice contenant la structure de
* la brique sans se préoccuper de la rotation
*/
Tetris::Case
Tetris::Brick::operator()(int x, int y) const {
	int temp = x;
	temp = x;
 
	// Calcul de x et de y
	if (rotation == 1) {
		temp = x;
		x = height - 1 - y;
		y = temp;
	}
	else if (rotation == 2) {
		x = width - 1 - x;
		y = height - 1 - y;
	}
	else if (rotation == 3) {
		x = y;
		y = temp;
	}
 
	return brick_matrix[x * y + x];
}

C'est à la méthode place que le jeu plante, appelée depuis fall(), qui elle même utilise toutes les méthodes plus haut.

Merci d'avance !

24/04/2008, 17h34
r0d

Là comme ça, je ne peux pas t'aider.

2 solutions:
1/ soit tu as un debugger et tu sais l'utiliser => tu met un point d'arrêt et tu regardes ce qu'il se passe
2/ tu met des cout

Sinon, un conseils: utilises des vector plutôt que des tableaux, ça t'évitera ce type d'erreur
24/04/2008, 18h07
Kreeg

Citation:

Envoyé par r0d

Là comme ça, je ne peux pas t'aider.

2 solutions:
1/ soit tu as un debugger et tu sais l'utiliser => tu met un point d'arrêt et tu regardes ce qu'il se passe
2/ tu met des cout

Sinon, un conseils: utilises des vector plutôt que des tableaux, ça t'évitera ce type d'erreur

J'ai mis des breakpoints... Enfin bref, ptete que l'utilisation des vectors résoudra mon problème ! Merci beaucoup à toi !

dans ta fonction place,

Code:

1
2
3
4
5
6
7
// Déplace la brique
void
Tetris::place(Pos2D p, Pos2D dim) {
        for (int i = p.x; i < p.x + p.x + dim.x; i++)
                for (int j = p.y - dim.y + 1; j <= p.y; j++)
                        if (current_brick(i - p.x, j - (p.y - dim.y + 1)))
                                grid[i][j] = ACTIVE;

a mon avis la boucle sur i doit aller entre p.x et p.x+dim.x, pas entre p.x et p.x+p.x+dim.x

25/04/2008, 13h40
Kreeg

Oui ; bien sur. Mais cela ne change pas qu'aucune affection mise à part celle de l'itérateur est faite :P

Je vais tenter les std::vector<> et les itérateurs :)
25/04/2008, 16h25
screetch

mais que se passe t'il lorsque tu ecris grid[i][j] = yarlouf et que i pointe dans la moquette ? tu ecris autre part, peut etre dans la freebox du voisin ou en chine. ou peut etre dans ta variable qui ne devait pas changer.
26/04/2008, 17h40
Kreeg

Ouais, c'est ce que j'avais pensé en y repensant un soir. J'essaierais quand j'aurais le temps :)
Merci beaucoup de votre aide. Le problème venait surement de là.