Bonjour,
 
je dois faire un Puissance 4 sous Processing pour la rentrée. Or je dois vous avouer que j'ai du mal à finir.
Le professeur nous a en effet fait une partie, mais je dois finir.
 
Si vous pourriez m'aider à comprendre, cela serait vraiment cool !
Je dois faire la partie "gain()", "placementPossible(int colonne)", "indexProchainPion(int colonne)", "int nbrCasesVides()" & "placePion(int couleur, int colonne)"
 
Voici le lien de mon document : http://www.mediafire.com/download/ [...] sance4.pde
 
Merci !  

Et en gros tu as fait quoi déjà / tu bloques sur quoi ?

 
Télécharge le fichier, c'est mon programme.
 
Je dois faire la partie gain, mais je ne comprends pas comment coder :
 
- alignement de 4 pions (vertical, horizontal, diagonal) = victoire",  
 
- le nombre de cases vides dans le plateau de jeu
 
- si la pose d'un pion est possible dans une colonne
 
et enfin niveau graphique, comment coder que : afficher un pion jaune à la place du chiffre 1, et afficher un pion rouge à la place du chiffre 2 (via des images insérées avec PImage)

/********************************************************************************/
/********************************************************************************/
/******************************* PUISSANCE 4 ************************************/
/********************************************************************************/
/********************************************************************************/
 
 
int ROUGE = 1;   // un pion rouge est représenté par un 1
int JAUNE = 2;   // un pion jaune est représenté par un 2
int ENCOURS = JAUNE; // les jaunes commencent
PImage GrillePuissance4, PionJaune, PionRouge;
 
int TAILLE = 50; // la taille des caractères pour l'affichage du tableau en mode texte
 
int[][] board;   // un tableau à 2 entrées représentant le plateau de jeu
boolean partieFinie = false; // devient true quand la partie est terminée
 
 
void setup() {
  size (700, 650);
  board = new int[7][6]; // largeur 7, hauteur 6
  initialiseBoard();
  GrillePuissance4 = loadImage("GrillePuissance4.PNG" );
  PionJaune = loadImage("PionJaune.png" );
  PionRouge = loadImage("PionRouge.png" );
   
}
 
 
void draw() {
  if (partieFinie) {
    println("La partie est terminée" );
    println("Appuyez sur une touche" );
    if (keyPressed) {
      exit();
    }
  } else {
    afficheBoard();
    testFinDePartie();
  }
}
 
void initialiseBoard() {
  for (int colonne = 0; colonne < 7; colonne++)
    for (int ligne = 0; ligne < 6; ligne++) board[colonne][ligne] = 0;
}
 
void mousePressed() {
  int colonne = (int)(mouseX-TAILLE)/TAILLE; // on détermine dans quelle colonne on a cliqué
  if (colonne > 6) colonne = 6;  // si on clique trop à droite, on reste sur la colonne de droite
  println("on place dans la colonne "+colonne);
  if (placementPossible(colonne)) {  // s'il est possible de placer le pion...
    placePion(ENCOURS, colonne);     // on le place...
    if (ENCOURS == ROUGE) ENCOURS = JAUNE; // et dans ce cas, le tour d'après
    else ENCOURS = ROUGE;                  // ce sera un pion de l'autre couleur
  } else println("Le placement est impossible !" ); // si le placement n'est pas possible,
  // on balance un message d'erreur dans la console
}
 
void testFinDePartie() {      // détermine si la partie est terminée...
   
  if (gain() == 1) {
    println("Les ROUGES GAGNENT !!!" );
    partieFinie = true;
  }
  if (gain() == 2) {
    println("Les JAUNES GAGNENT !!!" );
    partieFinie = true;
  }
  if (gain() == -1) {
    println("La partie est nulle..." );
    partieFinie = true;
  }
}
 
int gain() {
   
  if (.........................) return 1;  // renvoie 1 si les rouges ont gagnés
  else {  
    return 0;
  }
   
  if (.........................) return 2;  // renvoie 2 si les jaunes ont gagnés
  else {  
    return 0;
   
 
    if (nbrCasesVides()==0) return -1; // renvoie -1 si la partie est nulle, c'est à dire qu'il n'est plus possible de placer un pion
  else {
    return 0;                         // renvoie 0 si personne ne gagne pour le moment mais que la partie continue
  }
}
 
boolean placementPossible(int colonne) {
  if (                                                         // VRAI s'il est possible de placer un pion dans la colonne
}
 
int indexProchainPion(int colonne) {
  // renvoi l'index de la case où arriverait un pion si on le plaçait sur le colonne
  // en question
  //// ON SUPPOSE QUE LE PLACEMENT EST POSSIBLE ET A ETE TESTE AVANT
}
 
int nbrCasesVides() {
  // renvoi le nombres de cases qui peuvent encore contenir un pion
}
 
void placePion(int couleur, int colonne) {
  // place un pion de la couleur donnée dans la colonne en question
  // ON SUPPOSE QUE LE PLACEMENT EST POSSIBLE ET A ETE TESTE AVANT
  board[colonne][indexProchainPion(colonne)] = couleur;
}
 
 
 
void afficheBoard() {
  textSize(TAILLE);
  image(GrillePuissance4);
  for (int x = 0; x < 7; x++) {
    fill (125);
    text (x, TAILLE*(x+1), TAILLE*2);
    if (x<6) text (x, TAILLE*9, TAILLE*(x+4));
    for (int y = 0; y < 6; y++) {
      int contenuCase = board[x][y];
      if (contenuCase == 0) fill(255);         // case vide : blanc
      if (contenuCase == 1) fill(255, 0, 0);   // case 1    : pion rouge
      if (contenuCase == 2) fill(255, 255, 0); // case 2    : pion jaune
      text(contenuCase, TAILLE*(x+1), TAILLE*(y+4));
    }
  }
}

Oui enfin, ça c'est l'énoncé, pas ce que tu as fait

 
Je dois faire tout ce qui est en rouge ..
mais c'est ce que je disais + haut, je ne comprends pas comment coder ce qu'il y a en rouge, c-a-d :
 
- alignement de 4 pions (vertical, horizontal, diagonal) = victoire",  
 
- le nombre de cases vides dans le plateau de jeu  
 
- si la pose d'un pion est possible dans une colonne  
 
et enfin niveau graphique, comment coder que : afficher un pion jaune à la place du chiffre 1, et afficher un pion rouge à la place du chiffre 2 (via des images insérées avec PImage)

Ce que TotalRecall veut te dire et ce que je vais te dire de manière moins subtile : On ne fera pas le devoir à ta place !!  
 
Il faut au minimum avoir déjà essayé de faire quelque chose si tu veux de l'aide !!!
 
Poster un énoncé et dire merci ne suffit pas.
 
Essaye de coder quelque chose et reviens si tu as un message d'erreur ou besoin d'aide sur une syntaxe précise !

Merci, je commençais à fatiguer et puis c'est pas drôle d'être le rabat joie de service

Nan mais j'ai bien compris ! D'ailleurs je ne viens pas sur un forum pour que l'on me fasse le travail !
 
Le problème ici, c'est que je ne sais pas du tout comment dire à la machine que 4 pions sont alignés par exemple, ou comment dire qu'il n'y a pu de place dans la colonne ... Et je pense que c'est la base!
Si vous arrivez à m'expliquer cela, je comprendrai sûrement  comment faire je pense !

Il y a des trucs qui paraissent quand même ultra faciles, genre nbrCasesVides() il suffit de parcourir ton tableau board et compter les vides...
Fais déjà tout ce que tu peux et on t'aidera pour les trucs plus ardus, genre les alignements. Mais si tu sais te déplacer dans ton tableau le reste c'est juste un peu de maths très basiques et d'algo.

 
 
J'ai commencé la programmation il y a seulement 3 mois.
Certains choses peuvent te paraitrent faciles alors que pour d'autres non ...

C'est évident, mais si on t'a donné l'exo tu devrais avoir les bases non, et sinon des questions précises ?

Exemple pour compter les cases vides, tu parcours le tableau et tu incrémentes un compteur à chaque fois que tu en vois une.

Parcourir le tableau :

Tester si une case est vide :

Au début tu déclares le compteur ("casesVides" ), tu l'initialises à 0, et à la fin tu le renvoies.

Et je n'ai rien écrit ou utilisé qui ne se trouve pas exactement tel quel dans ton début de programme.

Le truc c'est qu'on veut bien t'aider, mais pas faire à ta place. Pour ça il faut que tu essaies des trucs (même faux) et pose des questions spécifiques.

Ok je comprends!
 
Ensuite pour ce qui concerne la possibilité de placer un pion dans la colonne, je dois aussi parcourir le tableau en Y pour savoir si il reste des 0 (et que donc on puisse mettre un pion ou non) ?

Logiquement pas besoin de "parcourir" en fait, il suffit de tester la case la plus en haut de la colonne.  
Donc index 0 ou 6 selon comment ton tableau est utilisé pour former la grille du jeu (la flemme de chercher dans le code).

Avec un if ?
Si index 0 == 0 alors je peux jouer
Sinon non
 
??

(Car justement je dois faire l'indexProchainPion, pour dire où sera le prochain pion dans la colonne)

Je n'ai pas décortiqué le code mais oui monsieur c'est l'idée .
Par contre ça te renvoie juste l'information de si la colonne contient au moins une place vide, pour trouver sur quelle ligne là il y a bien un parcours à faire (chercher la DERNIERE case contenant 0 et renvoyer l'index de sa ligne).

Mentalement tu arrives à te représenter l'ensemble ?
Tu comprends pourquoi pour faire placementPossible() il n'était pas nécessaire de tout parcourir ? Le code est plus optimisé comme ça : tu testes juste une seule position.

Ca fera déjà trois méthodes de faites

Pas évident, je vais essayer ...

N'hésite pas à poster ici le code des trois méthodes quand tu auras fini si tu veux des remarques.

Le truc c'est qu'enfaite, en version "phrase" je sais me le représenter, mais c'est pour le retranscrire en langage processing que j'ai du mal

Ecrire l'algo et conceptualiser le truc mentalement c'est la première étape, et très importante. Le code viendra naturellement avec la pratique.

Bon j'essaye & je reviens vers toi !

Vu que c'est un truc très visuel petit conseil si tu peines : représente ta grille (ligne / colonne avec les indexes) sur un papier.
Ca pourra peut être t'aider à voir comment faire tes parcours et tester tes cas.
Apres ecrire les boucles et les if devrait aller vite.

Pour le nombreCasesVides(), je fais ça ?
 

Pour le placementPossible(), je dois faire comme ça ?? :
 

- "contenuCase == 0" correspond à une case vide, pourquoi tu la considères comme remplie ? Et quand bien même quel est l'intérêt de compter les remplies et faire une soustraction après ? Compte directement les vide !
- casesRemplies n'a pas besoin d'être une variable globale, elle doit être dans la méthode.
- La méthode doit retourner la valeur calculée
 
Donc j'aurai plutôt fait :  

Toujours sous réserve que "0" veuille bien dire case vide comme je l'ai compris.

 
et "colonne" il sert à quoi ?  
Et c'est quoi cet index vide à droite ?  
Et c'est quoi ce "= 0" : c'est pas une comparaison ça, c'est une affectation !
Ta méthode ne renvoie pas de valeur ! Tu peux renvoyer directement le résultat du test conditionnel.
 
Donc pour moi :

Dernier point en plus des deux posts ci-dessus :  
Puisque tu as des constantes comme int ROUGE = 1 et cie, j'en ajouterai une "int VIDE = 0;" et je l'utiliserai partout où il faut.
De plus je vois que même dans l'énoncé les constantes ne sont pas toujours utilisées (méthode afficheBoard()).

Oui désolé j'avais oublié le double égal !
et les [] vides, enfaite, c'était pour dire la colonne ! Quand je t'ai envoyé le message, je n'avais pas encore mis le [c] enfaite sorry !

 
 
Le truc, c'est que c'est le prof qui a fait le début (l'énoncé comme tu dis), donc si ce que tu dis n'est pas utilisé, je n'y peux rien ^^

Donc pour résumer, on en est là :
 

Je viens de voir que dans ma solution pour placementPossible j'ai inversé ligne/colonne . Et tu as recopié tel quel .
C'était pour voir si tu suivais bien sûr

D'ailleurs je crois qu'il faut inverser colonne & ligne car dans le void setup, j'ai mis 7 de largeur (donc les colonnes) puis 6 de hauteur (donc les lignes)
 

 
Du coup je suppose qu'il faut faire ça (à moins que ça ne soit pareil du moment que je marque bien "[colonne]"?) :  

 
 
Juste une petite question "graphique" avant de continuer : comment je fais pour remplacer le fond noir par une image de grille de jeu de Puissance 4 et qu'elle coïncide avec les colonnes ??
(Ps : j'ai déjà mis les photos dans un dossier "data" dans le dossier où est enregistrer le programme)
 
Et comment je fais pour remplacer les "1" par une image de pion rouge & les "2" par une image de pion jaune ?
 
j'ai déjà déclarer les images mais comment les attribuer ?

 
EDIT : Ah bah tiens, je l'avais vu pour l'inversement, je viens de le marquer dans ce message xD

Mais dans une fonction boolean, il ne faut pas mettre soit TRUE soit FALSE ?
 
Edit : si je ne réponds pas rapidement, c'est que je suis parti en vacances & que je n'ai pas internet tout le temps

UP  

Quand tu écris
   

L'expression à la droite du return sera évaluée pour savoir si elle vaut vrai ou faux.
Tu peux écrire n'importe quoi à côté de return tant que ce n'importe quoi renvoie un type qui correspond à celui retourné par ta méthode.
Donc ça revient à ecrire
   

Mais en beaucoup plus court et moins moche.

Pour ta question de dessin je dirai que la méthode afficheBoard() (appelée par draw()) semble parcourir et redessiner la board complète, donc ton programme gère déjà la MAJ de ce qui est affiché apres chaque coup.

Pour ta question de dessin je dirai que la méthode afficheBoard() (appelée par draw()) semble parcourir et redessiner la board complète, donc ton programme gère déjà la MAJ de ce qui est affiché apres chaque coup.[/quotemsg]
 
 
Oui mais comment je remplace les "1"par des pions rouges et les "2" par des pions jaunes ?
Je remplace les "fill" par les images de pions ?
 

 
 
Ensuite pour la fonction gain, tu as une idée de comment dire que 4 pions sont alignés pour "gain()" ?
Et pour indexProchainPion() ??
 
 
Pour le nbrCasesVides() j'ai fais ça :

UP.
Aidez moi svp

Pour la partie gain(), j'ai fais ça  
 
mais j'ai une erreur qui dit : "The operator == is undefined for the argument type(s) boolean, int"
 

Salut,  
Comme je t'ai expliqué plus haut (même si le contexte n'était pas le même), un test comme "a == b" renvoie un booléen.  
Donc en écrivant "a == b == c" c'est comme si tu faisais "true == c", ce qui n'a aucun sens car tu compares alors un booléen (true) avec un entier (c) d'où le fait que le compilo t'engueule.
 
Pour faire ce test il faut le décomposer en deux étapes "a == b && b == c" par exemple, ou bien faire une méthode (pour la lisibilité).
 
Mais dans ton cas pas mal de soucis :
- il y a des façons de rendre ce bazard fortement plus lisible (déjà rien qu'en stockant le résultat d'exécution du premier if dans une variable pour tester ensuite si elle vaut un ou deux, tu éviterais le deuxième if).
- dans ta boucle tu appelles tes variables x/y, dans tes tests ligne/colonne, faut te décider.
- ton algo va péter à l'exécution : tu parcours la totalité du tableau en x et y et à côté de façon tu fais des opérations comme "colonne + qqch" : quand ta boucle tu arriveras à la dernière colonne, tu vas essayer de te balader "qqch" colonnes plus loin, alors que ça n'existe pas.