Discussion :

[Hedg-Hop]

Bonjour: voila j'ai créé le jeu puissance 4 avec forms.NET,
mon Puissance 4 est en 7*7, avec Y=1 la ligne tout en haut, et y=7 la ligne du bas
Voici ma boucle, qui se trouve dans la fonction clicCase (lorsque qu'on clic sur une case pour inserer un pion):

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
if ( coordonnees.Y != 7 ) // si ce n'est pas la dernière ligne
                {
                        if ( grille [ coordonnees.X, coordonnees.Y+1 ] == nullptr  ) // si il n'y a pas de pion à la ligne du dessous
                        {
                                return; // ici //
 
                        }
                        else
                                grille [ coordonnees.X, coordonnees.Y ] = joueurCourant; // si ce n'est pas la dernière ligne mais qu'il y a un pion en dessous = OK
 
 
                }
                else // si on est sur la dernière ligne
                     //attribue la case au joueur courant
                        grille [ coordonnees.X, coordonnees.Y ] = joueurCourant;

Voila, pour l'instant, on met un pion, et s'il n'y a pas de pion en dessous, il y à "return" et ça quitte la fonction
Je voudrai que: si il n'y a pas de pion en dessous, que le programme fasse "descendre" le pion jusqu'en bas

par exemple: il y a un pion en Y=7 et un en Y=6. Et que l'utilisateur clique sur la ligne Y=2, que le programme fasse "descendre" ce pion en Y=5

Voila, j'espère que je me fais comprendre :s

[Invité]

salut,

t'es très clair, il te suffit d'avoir une fonction qui de dit donne la case sur laquelle tu peux aller.
Par exemple

Code :

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

1
2
3
4
5
6
allowed=1;//au lache le jeton sur la premiere ligne.
for(y=allowed; y<=7; ++y){
 si grille[y]==joueurCourant ou grille[y]==lautreJoueur
   allowed=y-1;//on est descendu un pion trop bas
 break:
}

bien sur, faudrait pas que t'aies déjà un pion dans la ligne 1...

[Aleph69]

Salut,

j'ai l'impression que tu t'embêtes pour rien. Il te suffit d'avoir un tableau de taille égale au nombre de colonnes du jeu pour t'en sortir facilement. Ce tableau doit contenir le nombre de jetons présent dans chaque colonne. Appelons le TAB. Alors TAB(1) contient le nombre de jetons dans la colonne 1, TAB(2) le nombre de jetons dans la colonne 2, etc.

Au début du jeu, TAB ne contient que des zéros puisqu'aucun jeton n'a encore été mis dans aucune colonne. Ensuite, à chaque fois qu'un jeton doit être ajouté, on suit les étapes :
1. on récupère le numéro j de la colonne dans laquelle le jeton doit être inséré;
2. si TAB(j)=7, la colonne est pleine et on ne peut pas mettre le jeton;
3. sinon, on fait descendre le jeton en Y=TAB(j)+1 et on incrémente TAB(j) de un.

Je pense qu'en procédant ainsi tu vas te simplifier la vie.

EDIT : il faut adapter un peu car j'ai naturellement numéroté les lignes du bas vers le haut alors que tu sembles avoir fait le contraire. Il faut donc soustraire au nombre de lignes la formule. Pour 7 lignes, on obtient Y=7-TAB(j) si je ne me trompe pas.

[Médinoc]

@Aleph69: J'ai l'impression que ton système ne marche que si on joue au Puissance 4 à un seul joueur.

Les pions ne peuvent pas être simplement "comptés" car leur appartenance compte.

[Aleph69]

Cette information est déjà contenue dans le tableau grille dans le code initial.

[Invité]

Pourquoi pas une fonction récursive, du type :

fonction mettrePion(int x, int y)
Si Case en dessous non pleine et Case en dessous existante
mettrePion(x, y--)
Sinon
Grille[x][y] = joueurActuel
Fin si

et tu appelle cette fonction avec les x, y de ton formulaire

En espérant t'avoir aidé

[Neckara]

Pourquoi pas une fonction récursive, du type :

fonction mettrePion(int x, int y)
Si Case en dessous non pleine et Case en dessous existante
mettrePion(x, y--)
Sinon
Grille[x][y] = joueurActuel
Fin si

et tu appelle cette fonction avec les x, y de ton formulaire

En espérant t'avoir aidé

ça ne fait pas une boucle infinie?
mettrePion(x, --y);

Sinon je pense que la solution de Aleph69 est bien plus pratique et rapide.

[Invité]

ça ne fait pas une boucle infinie?

Je ne vois pas comment...
On a un le tableau à double entrée et on clique sur un case libre.

Alors si ya rien en dessous, on rappelle la fonction avec une case plus bas (--y, à propos dsl, mauvaise habitude... mais ça marche quand meme non ?) et sinon, on met le pion sur la case actuelle, ça ne feras pas de boucle infinie car dans tous les cas, on va finir par arriver sois sur une case prise en dessous, sois pleine sois inexistante (ce qui correspond à la fin de la grille, le niveau 0)

Sinon je pense que la solution de Aleph69 est bien plus pratique et rapide.

Je suis d'accord. Mais il est bon de proposer des solutions différentes non?

Bonne soirée

[Neckara]

Je ne vois pas comment...
On a un le tableau à double entrée et on clique sur un case libre.

Alors si ya rien en dessous, on rappelle la fonction avec une case plus bas (--y, à propos dsl, mauvaise habitude... mais ça marche quand meme non ?)

y-- va enregistrer la valeur de y, décrémenter y puis retourner la valeur enregistrée, tu apeleras donc toujours la fonction avec la même valeur pour y d'où la boucle infinie

Je suis d'accord. Mais il est bon de proposer des solutions différentes non?

Généralement on essaye d'éviter au maximum les fonctions récursives si on peut l'éviter.
Et ta solution est à peu de choses près la version récursive que proposait galerien69.

[Invité]

Mais il est bon de proposer des solutions différentes non?

oui.

Et c'est d'autant plus vrai pour la récursion qui n'est pas le plus intuitif quand on débute. Se faire les dents sur ces ptits algo est loin d'être dommage.

Sinon, je suis pas fan du TAB, ca dupplique les données et oblige à synchroniser la grille et TAB à chaque fois.

[Neckara]

On est pas obligé de faire un tableau de nombre de jeton dans la colonne.
On peut faire un tableau de pointeur sur la prochaine case disponible.

Ainsi :

Code :

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

1
2
3
4
5
6
7
8
int jouer(int x, Joueur * j)
{
        if(! TAB[x] )
                    return -1; //colonne pleine.
        *TAB[x] = j;
 
        return TAB[x]++ - debutTab[x]; //y
}

Après ça ne fait rien de faire une redondance d'information qui utilisera 28 octets à 56 octets en plus si cela nous permet de simplifier l'algorithme et d'aller beaucoup plus vite.

[Invité]

Bonsoir !

Et c'est d'autant plus vrai pour la récursion qui n'est pas le plus intuitif quand on débute. Se faire les dents sur ces ptits algo est loin d'être dommage.

Oui, c’était mon idée, proposer un algo qui permettrais de répondre au problème donné, permettant de travailler la récursivité, qui est pour le moins un sujet... délicat quand on débute (et je le dis en tant que débutant)

Code :

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

y-- va enregistrer la valeur de y, décrémenter y puis retourner la valeur enregistrée, tu apeleras donc toujours la fonction avec la même valeur pour y d'où la boucle infinie

Merci pour cette précision, tu viens de m'apprendre un truc

Messieurs Dames, bonne soirée

[Invité]

[quote=jetSett;6864829]Bonsoir !



Oui, c’était mon idée, proposer un algo qui permettrais de répondre au problème donné, permettant de travailler la récursivité, qui est pour le moins un sujet... délicat quand on débute (et je le dis en tant que débutant)

y-- va enregistrer la valeur de y, décrémenter y puis retourner la valeur enregistrée, tu apeleras donc toujours la fonction avec la même valeur pour y d'où la boucle infinie

Merci pour cette précision, tu viens de m'apprendre un truc

Messieurs Dames, bonne soirée