Bonjour !
J’ai un petit soucis avec le tuto casse briques, et plus particulièrement avec un bout de code permettant de tester la présence ou non de briques dans le tableau des briques.
Voici ce que j’ai écrit :
for (int x=0; x < grille_taille; x++){
if (brique[x] == 0){
continue;
}
int briqueX = x * (briqueW + 2) +1;
int briqueY = 10;
if (gb.collide.rectRect(ballX, ballY, ballsize, ballsize, briqueX, briqueY, briqueW, briqueH)){
ballVY *= -1;
brique[x] = 0;
//C'est ici que les problèmes commencent ^^"
bool encoreDesBriques = false;
for (int i=0; i < grille_taille; i++){
if (brique[x] == 0){
encoreDesBriques = true;
}
}
if (encoreDesBriques == false){
reinitialiser();
}
}
}
Plusieurs questions me viennent à l’esprit :
1- Pourquoi affecter la valeur true au bool si brique[x] == 0 ? Lorsque brique[x] == 0 , cela veut bien dire que toutes les valeurs de brique[x] sont nulles, et qu’il n’y a donc plus de briques ?
2- Au lancement du programme, le bool est false comme convenu, et devient true une fois la première brique cassée, mais pourquoi ne redevient-il pas false quand toutes les briques ont été cassées ?
En fait, je ne comprends pas vraiment comment fonctionne ce test, et je me refuse à passer à l’étape suivante tant que je n’aurai pas compris ce test 
Si quelqu’un ici pouvait m’éclairer sur ce qu’il ne va pas, ce serait top, parce que je sèche depuis déjà 2-3 jours
Bonjour, je n’ai pas testé mais en relisant rapidement le code, je dirais que tu as raison normalement, il faudrait changer enDesBriques uniquement quand la valeur est différente de 0. Je suis surpris que personne n’ait remarqué cette erreur avant. Je testerais vite fait ce soir, voir si quelque chose m’échappe mais ça me parait en effet assez simple et clair. Le pire c’est que ce code est utilisé plusieurs fois dans les tutos.
Pour ta deuxième question: C’est un peu lié: Avant la boucle, on part du principe qu’il n’y a plus de brique: encoreDesBriques = flase et on ne le passe à true que si on trouve encore au moins une brique active donc ça c’est bon.
Le seul problème est dans le test if (brique [ x ] == 0) à remplacer par != selon moi
1 Like
Peux-tu tester le code. Marche-t-il comme indiqué dans le tuto ?
Si oui, on verra, sinon, fonctionne-t-il en inversant le test. Si tu peux tester ça m’évitera d’avoir à le faire ce soir 
et surtout si tu vois d’autres erreurs (si s’en est une et je pense que c’est le cas) n’hésites pas à nous les remonter.
1 Like
Je viens tout juste de voir tes réponses, je test ça de suite avec !=
1 Like
Alors en écrivant
if (brique[x] != 0)
c’est encore pire, maintenant encoreDesBriques reste false quoiqu’il arrive, et le jeu se réinitialise donc à chaque fois que la balle rentre en contact avec une brique.
Edit: j’ai aussi testé if (brique[x] == 1), ce qui donne exactement le même résultat que décrit juste au dessus (je m’y attendais, vu que ça revient au même).
Edit 2: 2e test
bool encoreDesBriques = true;
for (int i=0; i < grille_taille; i+=1){
if (brique[x] == 0){
encoreDesBriques = false;
}
}
if (encoreDesBriques == false){
reinitialiser();
}
Encore le même résultat, le bool reste faux quoiqu’il arrive.
Edit 3:
bool encoreDesBriques = true;
for (int i=0; i < grille_taille; i+=1){
if (brique[x] != 0){
encoreDesBriques = false;
}
}
if (encoreDesBriques == false){
reinitialiser();
}
Cette fois, le bool reste vrai quoiqu’il arrive.
En tous cas tu testes.
Note: tu veux uniquement développer ou faire du C++.
Tu as raison pour le C++, c’est vraiment bien mais si ça te tente, essayes aussi MicoJS, c’est plus spécifique mais c’est très sympa aussi. Comme ça tu peux essayer de faire les tuto en C++ et quand tu l’as fini, essayer de le faire en MicoJS et si tu n’y arrives pas, on t’aidera, si ça t’intéresse. Ce n’est pas du tout une obligation car tu peux tout faire sur la META en C++. Le MicoJS, c’est juste autre chose avec des avantages et des inconvénients.
Je cherche pas spécifiquement à faire que du C++, donc je me pencherai avec plaisir sur MicoJS ! J’ai aussi prévu de faire les tutos en python, mais j’essaye de me focaliser sur un langage à la fois pour le moment pour pas me mélanger les pinceaux
1 Like
je trouve le code du tuto un peu complexe. Je ne peux pas tester là mais perso j’aurais plutôt écris un truc de ce genre:
void miseAJour() {
// MAJ balle //
// Collisions avec murs //
// Collision avec raquette //
// Collision avec les briques
// Verifier qu'il reste encore des briques
bool encoreDesBriques = false; // Si ce booléen reste faux, alors il n'y a plus de briques
for (int x = 0; x < GRILLE_TAILLE; x += 1) {
if (briques[x] == 0) { // Ignorer les briques nulles
continue; // 'Continue' force la boucle à passer a recommencer (et donc incrémenter)
}
int briqueX = x * (BRIQUE_LARGEUR + 2) + 1;
int briqueY = 10; // Hauteur des briques
if (gb.collide.rectRect(balleX, balleY, BALLE_TAILLE, BALLE_TAILLE,
briqueX, briqueY, BRIQUE_LARGEUR, BRIQUE_HAUTEUR)) {
balleVY *= -1;
briques[x] = 0; // Détruire la brique
} else {
encoreDesBriques = true; // Il reste encore au moins une brique
}
}
if (encoreDesBriques == false) { // S'il n'y a plus de briques
reinitialiser();
}
}
1 Like
Sinon, tu as raison, va à ton rythme, un langage à la fois. Autant ne pas bruler les étapes. Amuses toi, tests et progresses. Tu es sur la bonne voie par ce que tu te pose des questions et tu cherches à comprendre sans recopier le code. C’est la bonne démarche et n’hésite pas à le triturer pour qu’il te corresponde. Pour qu’il corresponde à ta façon de le penser mais comme là, si tu vois des choses qui te paraisse bizarre, continues de les remonter, on pourra regarder.
1 Like
Je me pose sur ça demain, j’essayerai de décortiquer ta solution et de la tester
Je te tiens au jus !
1 Like
Ca marche prends ton temps, analyses à ton rythme et on en discute, ça sert à ça le forum
Hello !
J’ai pu tester ta solution aujourd’hui, et … bah elle marche “presque”. Le jeu se réinitialise dès lors que la balle touche la brique d’indice 0. Ce qui n’est pas vraiment le but recherché ici . Puis en y regardant de plus près, je pense avoir saisi pourquoi. En effet, si la balle touche la première brique, alors brique[0] == 0, et donc quand on revient au début du for, la boucle ignore la brique (à cause du continue) et zappe donc automatiquement tout le reste, avec un bool false, et réinitialise donc.
J’ai donc voulu le faire différemment, et j’ai trouvé une solution qui fonctionne !
Voici donc ce que j’ai écrit :
for (int x=0; x < grille_taille; x += 1){
if (brique[x] == 0){
continue;
}
int briqueX = x * (briqueW + 2) +1;
int briqueY = 10;
if (gb.collide.rectRect(ballX, ballY, ballsize, ballsize,
briqueX, briqueY, briqueW, briqueH)){
ballVY *= -1;
brique[x] = 0;
a += 1;
}
}
if (a == grille_taille){
a = 0;
reinitialiser();
}
J’ai déclaré une variable “a” (nom provisoire, je vais le changer pour pas me mélanger les pinceaux) que j’incrémente de 1 à chaque brique cassée. Je test alors si la valeur de a est égale à grille_taille (soit le nb de briques) et réinitialise si c’est le cas.
Je sais pas si c’est “propre” comme manière de faire, alors ça me semblait intéressant de la partager pour avoir peut-être un retour sur cette solution
1 Like
Bien, moi dans mon casse brique j’avais fais un peu le contraire: je mettais briques_restantes avec le nombre de briques lors de l’initialisation du niveau et je le décrémentais à chaque fois que je cassais une brique.
Pareil, là on réinitialise, mais dans mon casse brique du coup c’était un appel à niveau_suivant pour augmenter le niveau de 1 et afficher le niveau mais ça c’est pour la suite, par ce qu’à ce niveau du tutoriel, reinitialiser() fait bien le boulot et permet de garder un code simple.
Par contre oui, évite de mettre des a etc… dans ton code pour ce genre de chose par ce que quand ton code va se compliquer, ça te fera gagner du temps de lire une variable plus parlante. Dans ton cas à toi, ça pourrait être par exemple briquesCassees ou briques_cassees selon la convention de nomage que tu utilises (je ne suis pas très rigoureux la dessus, pour moi, le seul truc qui compte c’est que tu t’y retrouves vite et que tu prennes vite les bonnes habitudes même dans les programmes simples pour que tu gagnes du temps après… )