Bonsoir à tous, voilà je dois programmer un puissance 4 mais je ne sais comment parcourir le tableau de la bonne manière pour vérifier si la partie est gagnée    
J'avais l'idée de faire un truc du genre :
 

 
J'aurais fait pareil avec j, j+1, j+2...
 
Enfin, j'ai essayé mais dans la pratique ça marche 'peu'... Pour la vérification diagonale je n'en parle pas. Si quelqu'un pouvait m'aider en accord avec mon code je lui serais éternellement reconnaissant.
Merci.

Si tu as déjà abordé la récursivité en cours, tu peux t'inspirer de ce topic.
 
La vérification se fait par une fonction récursive qui s'incrémente à chaque pion de la même couleur aligné. Et pour le parcours, cette fonction prend en argument des indices (0, 1 ou -1) pour savoir dans quel sens se déplacer.
 
Bien entendu, si tu ne comprends pas mon code, ne l'utilise pas ! Mais si tu veux des précisions, pas de souci

Euh, je fais pas de cours ...

Ha ok (c'était un bon sujet de TP pourtant )
 
Mais ça ne change rien au problème : t'es-tu penché sur la récursivité ? Si oui, essaye de comprendre la finalité du bout de code que j'ai mis dans l'autre topic (il y a sûrement bien d'autres manières de faire sinon).

Ah, et tu fais ce genre de TP dans quelle section ? =)
J'ai regardé la récursivité, je comprends pas vraiment .

Faut comprendre la récursivité, pour comprendre la récursivité.

Le principe est simple : appeler une fonction à l'intérieur d'elle-même. Après, faut surtout appréhender le pourquoi du comment.
Mais dans ton puissance 4, c'est un moyen très efficace de voir si la partie est gagnée ou pas (y compris si ton plateau de jeu fait plusieurs milliers de cases, et qu'il faut aligner 35 pions pour gagner, ce qui un gros avantage). Mais après c'est effectivement peut-être pas le plus simple.
 

 
Une autre idée sur la façon de procéder sinon ?

C'est votre domaine, ou vous êtes des amateurs (et je m'inquiète).
 
Je n'ai pas d'autres idées...
Déjà l'approche de mon puissance 4 est assez difficile, en effet j'avais un bug que j'ai soumis à des programmeurs, qui n'ont rien compris à mon code. Maintenant il est un peu plus clair.
 
http://romintensity.free.fr/grille.pdf

Idée :
 
int variable = 0;
while(!variable)
{
//code
}
 
Il faudrait pour la vérification horizontale :
Parcourir i(de 0 à 6) et j(de 0 à 4) dans grille[i][j] et variable est vrai si:
 
grille[i][j] == grille[i][j+1] == grille[i][j+2] == grille[i][j+3]
grille[i][j+3] <=6
 
Mais çia marche pas

Tu ne peux comparer les valeurs que deux à deux. Il faudrait écrire

 
De plus, tu vas devoir écrire les tests pour toutes les directions. C'est possible mais fastidieux. Et encore, heureusement que ce n'est pas un "Puissance 25" sinon tes conditions vont prendre de la place !  
 
Tu devrais vraiment te pencher sur la récursivité, c'est un peu compliqué à comprendre de prime abord, mais c'est bien utile (voire même indispensable si tu veux vraiment te mettre à la programmation).

Une autre approche, au lieu de rechercher une position gagnante n'importe où dans la grille, serait d'en rechercher une à partir de la position qui vient d'être jouée.
Tu définis une fonction qui prend en paramètre les coordonnées (x,y) de la position à partir de laquelle faire la recherche (qui sera la position qui vient d'être jouée) et qui :
- recherche dans les 8 directions possibles le nombre de pions de la même couleur qu'en (x,y)
(la recherche vers le haut devrait être plutôt triviale )
- additionne le nombre de pions trouvés dans les directions opposées (+1 pour la position courante) et renvoie la taille du plus grand alignement
 
Perso, je ferais comme ca

Salut
 

Beaucoup de gens ici sont des professionnels. Si ce n'est pas le cas, ils ont largement le niveau pour un puissance 4
Apres,
N développeurs ==> N solutions
Ce n'est pas parce que ta solution n'est pas intuitive pour certains (je n'ai pas lu en détail, ce n'est pas une critique) qu'elle est mauvaise.
 
 

J'aurais fait comme ça aussi mais avec seulement 4 directions car finalement c'est plutôt une recherche horizontale (par exemple) que deux recherches, droite et gauche. La recherche horizontale est ensuite divisée en deux parties qui s'ajoutent (sans oublier le pion de départ) puis si somme>=4, victoire.

Je trouve l'approche de la position qui vient d'être jouée vraiment très bonne, je me demande même pourquoi je ne l'ai pas eue .
 
Je ne sais pas si je vais réussir, mais je vais essayer, je pensais jamais réussir mon puissance 4, j'ai arrêté la programmation aux bases du C et à la POO (théorie et Qt) il y a un an, et pendant mon temps de vacances j'ai quand même réussi au bout de trois jours à le programmer à moitié. Je vais continuer d'essayer et je vous tiens au courant.
 
Je devrais créer une variable :
 
positionActuelle[hauteur[j]][j] = VARIABLE
 
valeurPositionHaut = 0; (cela peut rien être au dessus donc osef...)  
 
valeurPositionBas = positionActuelle[hauteur[j-1]][j]
valeurPositionBas2 = positionActuelle[hauteur[j-2]][j]
valeurPositionBas3 = positionActuelle[hauteur[j-3]][j]  
 
valeurPositionGauche = positionActuelle[hauteur[j]][j-1]
valeurPositionGauche = positionActuelle[hauteur[j]][j-2]  
valeurPositionGauche = positionActuelle[hauteur[j]][j-3]  
 
valeurPositionDroite = positionActuelle[hauteur[j]][j+1]
valeurPositionDroite = positionActuelle[hauteur[j]][j+2]  
valeurPositionDroite = positionActuelle[hauteur[j]][j+3]  
 
 
if(VARIABLE == valeurPositionBas && VARIABLE == valeurPositionBas2 && VARIABLE == valeurPositionBas3)
{
WIN
}
 
 
etc ? :s

N'essaie pas. Fais le.

Tu devrais mettre ta vérification dans une boucle au lieu de créer plein de variables. Car comme le dit Turkleton, le jour où tu vas faire un puissance 25... Aïe!
Quelque chose du genre (code à l'arrache):

C'est bien la programmation c'est à celui qui repoussera au plus loin les limites de son esprit. Chez moi ça arrive souvent. C'est frustrant... Mais bon j'compense avec 18 au bac Blanc de français    
 
 
 
Je comprends ton code, mais j'ai l'esprit étroit dans ce domaine et j'ai beaucoup de mal à comprendre en fait... C'est frustrant. Est-ce que ça arrive à tout le monde et ça vient avec le temps ou est-ce inné ?

C'est normal au début. Petit à petit la logique paraît de plus en plus... logique.
Plus tu les pousses et plus "les limites de ton esprit" seront loin.

En tout cas n'hésite pas à poser des questions ici. Le forum est là pour ça et pas mal des programmeurs ont commencé en tant que débutants eux aussi. Ils comprennent donc.

Je me sens jamais aussi con que quand je programme... C'est quand même rassurant.

L'important c'est de pratiquer. Finis ce que tu commences et tu progresseras. Après le puissance 4 tu te rendras compte que tu as franchi un "palier" et que tu peux faire autre chose de plus complexe. Tu t'arracheras les cheveux sur autre chose ==> nouveau palier. Et ainsi de suite. C'est en voyant le résultat final que tu verras ta progression donc ne laisse pas tomber. La satisfaction est grande quand ton propre jeu tourne sur ton pc. Même si le jeu est merdique et que tu es le seul à y jouer

Et puis 18 au bac blanc de français, c'est que ton cerveau est en état de marche.

+1 avec ptitchep
Je rajouterais même que quand tu auras fini ton puissance 4 et que tu te prendras la tête sur autre chose, c'est encore plus sympa de constater ses progrès en revenant sur un ancien programme et en l'optimisant.
 
Et oui, jouer sur son propre programme merdique, c'est 10x plus jouissif que n'importe quel autre jeu fait par quelqu'un d'autre  
En l'occurrence, je me suis remis au C pour pouvoir développer des jeux pour ma Nintendo DS. C'est trop bon  
 
Pour ton Puissance 4, le code de ptitchep est excellent pour contourner l'usage des fonctions récursives par celui des boucles while. Si tu te sens un peu motivé, tu peux même faire un mix de nos deux codes : utiliser les boucles while pour le parcours des cases, mais en utilisant des indices pour les variables de décalages horizontales et verticales. Ainsi, tu n'as la boucle qu'une seule fois (dans une fonction, que tu appelles à chaque fois avec des indices différents pour explorer toutes les directions), ça optimise énormément le code.

Coucou, c'est encore moi... Alors j'ai avancé, j'oserai pas vous dire en combien d'heures, mais j'ai avancé    
 
Voilà mon code :

 
 
 
 
Le problème se pose lors de la vérification horizontale, la fonction est vraie quand :
OXOXXOO
XOXOXOX
XXXOXOO
 
 
Quelqu'un saurait il améliorer ma fonction car je planche
 
 
Merci beaucoup.

A vue de nez je dirais que tu ne vérifies pas la validité de tes indices.

les tests sur i-decalage>=0 et  i+decalage<LARGEUR_GRILLE permettent dans mon code de vérifier cela.
En mémoire, ton tableau de 6x7 est en réalité 42 cases contigües. La première case de la 2ème ligne est à la suite de la dernière case de la 1ère ligne. La deuxième dimension n'existe que dans ta tête.
Tu peux obtenir la "vraie" case avec la formule y*largeurTableau+x

Ton tableau dans ton exemple:
OXOXXOO
XOXOXOX
XXXOXOO

ressemble à ça en mémoire (sans les espaces c'est pour que tu vois les colonnes):
OXOXXOO XOXOXOX XXXOXOO
Quand tu le regardes comme ça, tu as en effet 4 X alignés! Pourtant le joueur n'a pas gagné.

donc si tu es sur la 1ere case de la troisième ligne [0][2] et que tu recules d'une case, ta position devient [-1][2] ce qui n'est pas normal. Cependant cette position est tout de même valide elle correspond à la case précédente en mémoire c'est à dire la dernière case de la ligne précédente [6][1]. Il faut que tu arrêtes ta vérification si un des indices devient <0 ou >6.

Vu l'heure, je ne suis pas sûr d'être clair. Si besoin demande ce que tu n'as pas compris.

J'ai absolument depuis toujours compris que les deux dimensions sont que dans ma tête et il me suffit de supprimer de supprimer le \n dans la boucle pour m'en rendre compte. Cependant, j'ai un blocage dans mon raisonnement pour y parer... Malgré tous mes efforts. Je vais essayer de m'y replonger mais ça me saoule pas mal là.
 
 
J'aurais besoin que tu m'explique la manière dont varie i-decalage et leur valeur d'initialisation.
 
 
Sinon pour ma fonction tout vient de là :
 
if(grille[hauteurColonne[choixColonne]+1][choixColonne] == grille[hauteurColonne[choixColonne]+1][choixColonne+i] || grille[hauteurColonne[choixColonne]+1][choixColonne] == grille[hauteurColonne[choixColonne]+1][choixColonne-i])
           {
               nbrPionsIdentiquesH +=1;
           }

Utilise un débugger, c'est le meilleur moyen de voir comment fonctionne un programme. Tu travailles avec quel environnement?
 
Avec le débugger tu sauras combien valent tes indices et tu trouveras le bug.

J'ai réussi !!!! Avec une petite astuce simple...

 
 
Je crois que je vais m'arrêter là car pour la diagonale je suis dans... l'impasse..
 
Je travaille avec Code::blocks

J'ai réussi !!!! Avec une petite astuce simple...

 
 
Je crois que je vais m'arrêter là car pour la diagonale je suis dans... l'impasse..
 
Je travaille avec Code::blocks

J'ai fait un puissance 4 aussi un jour, voici le code pour la vérification:

 
L'algo est un calcul sur tout le tableau de jeu. On se créer un deuxième tableau (game) dans lequel on va noter le nombre de pion de la même couleur et qui se succède en fonction des 4 directions. Par exemple si le pion a la position (+1, +1) est de même couleur et a dans sa game[+1, +1].dg une valeur de 3 c'est que notre pion (0,0) est le quatrième et donc que la partie est gagnée (sinon on incrémente game[0, 0].dg de "1+game[+1, +1].dg" )
 
Pas très optimisé, le calcul est entièrement refait a chaque coup :-(

Whàw, l'approche est bien différente de la mienne.

 
Avec code blocks tu as un débugger intégré. Utilise le au maximum pour voir comment s'exécute ton programme, c'est très instructif.
 
Pour les diagonales, le principe est le même sau qu'au lieu de  
 
while ( i-decalage>=0 && grille[i-decalage][j] == grille[i][j])
 
tu as
 
while ( i-decalage>=0 && j - decalage >=0 && grille[i-decalage][j-decalage] == grille[i][j])
 
histoire de te déplacer à gauche ET vers le haut.
 
 
Pour ta question de l'évolution de i-decalage, j'ai oublié de répondre.  
Au début, i vaut la colonne dans laquelle tu as posé le pion. A toi de l'initialiser avec la valeur choisie par l'utilisateur.
Decalage représente la distance entre la colonne que tu observes et celle jouée. Au début decalage vaut 1 et pas 0 car rien ne sert de vérifier la colonne i vu que l'on sait qui a joué ici.
A chaque itération de la boucle, decalage augmente de 1 ce qui permet de regarder la colonne suivante: i-1 puis i-2 etc. Bien sûr on vérifie que i-decalage (donc la colonne que l'on regarde) ne soit pas inférieur à 0 car regarder la colonne -1 n'a pas de sens.
Pour la diagonale, on veut la colonne précédente mais aussi la ligne du dessus. Heureusement, la diagonale est à 45°. Chaque fois que l'on recule d'une colonne, on remonte d'une ligne donc on peut utiliser le même décalage pour les deux indices. On regarde la ligne j-decalage de la colonne i-decalage.
 
Toi tu obtiens ta ligne avec hauteurColonne[choixColonne]+1 donc tu peux faire:
j = hauteurColonne[choixColonne]+1
 et  
i = choixColonne
 
Enfin c'est peut-être l'inverse, je mélange souvent les lignes et les colonnes dsl.
Ensuite, tu peux passer  aux boucles de vérif.
 
J'espère être clair.

 
 
Ne t'en fais pas, il m'insulte toutes les deux minutes xD...
 
 
Sinon, merci pour les conseils.

Tu es sûr que l'on parle de la même chose? Mon debugger ne parle pas.