Mastermind sur java's cool

Fermé
morlescou Messages postés 5 Date d'inscription mardi 15 janvier 2013 Statut Membre Dernière intervention 19 février 2013 - 19 févr. 2013 à 16:41
Bonjour, j'ai trouver un programme complique avec la fonction principale a la fin qui appelle plusieurs classes qui sont au dessus mon prof veut qu'il y ai qu'une seule classe et je ne sais pas du tout comment faire

voici le programme


public class Jeu{
// nombre de symbole dans la combinaison
private int nb;
// nombre de symbole max possible
private int borne;
// passe à vrai lorsque le jeu est fini
private boolean estFini;
// passe à vrai lorsque la combinaison mystere est trouvé
private boolean estDecouvert;
// nb de coup maximum
private int nbCoupMax;
// la combinaison à deviner
private Combinaison mystere;
// liste des coups
private Coup [] tabCoup;
// numéro du prochain coup
private int indiceCoup;
public Jeu(int max, int borneMax, int nbCoup) {
nb = max;
borne = borneMax;
mystere = new Combinaison(nb, borne);
// initialise une combinaison aléatoire
mystere.setValeur(false);
estFini = false;
estDecouvert = false;
// Le jeu mémorise les coups joués
nbCoupMax = nbCoup;
tabCoup = new Coup[nbCoupMax];
// Suite de coups vierges
for (int i = 0; i < nbCoupMax; i ++) {
tabCoup[i] = new Coup(new Combinaison(nb, borne), nb);
}
indiceCoup = 0;
}
public int getIndiceCoup() {
return indiceCoup;
}
public int getBorne() {
return borne;
}
public int getNb() {
return nb;
}
public int getNbCoup() {
return nbCoupMax;
}
public Combinaison getCombinaison() {
return mystere;
}
public boolean estFini() {
return estFini;
}
public void saisirCoup(String combi) {
tabCoup[indiceCoup] = new Coup(new Combinaison(nb, borne, combi), nb);
estDecouvert = tabCoup[indiceCoup].compare(mystere);
indiceCoup ++;
estFini = estDecouvert || (indiceCoup == nbCoupMax);
}
//vérifie si la combinaison saisie est au bon format
public boolean estCorrecte(String s) {
boolean estOK;
//convertir en majuscule
String saisie = s;
int i;
char c,borneSup,borneInf;
borneInf = 'A';
borneSup = (char) (64 + borne);
// si la longueur est la même
estOK = (saisie.length() == nb);
for (i = 0; i < nb && estOK; i ++) {
c = saisie.charAt(i);
estOK = estOK && (borneInf <= c && c <= borneSup);
println(i + " : " + borneInf + "<=" + c + "<=" + borneSup);
}
return estOK;
}
//affiche le jeu au complet
public void affichage() {
int i;
clear();
print(" ");
if ( ! estFini) for (i = 0; i < nb; i ++) print(" ?");
else print(" " + mystere.toString());
println(" N B");
for (i = nbCoupMax; i > 0; i --) {
if (i > 9) print(i + " ");
else print(i + " ");
println(tabCoup[i - 1].toString());
}
for (i = 0; i < nb + 2; i ++) print("---");
println("-");
if (estFini) if (estDecouvert) println("Vous avez gagné en " + indiceCoup + " coups. Bravo !!");
else println("Vous n'avez pas trouvé en " + indiceCoup + " coups. Dommage !");
}
}

/** gère un coup
*
*/
public class Coup{
// la combinaison du coup
private Combinaison maC;
// correction en nbombre de pion noir et nb de pion blanc
private int nbB, nbN;
// nombre de pion dans un combinaison
private int nb;
public Coup(Combinaison c, int n) {
nbB = nbN = 0;
maC = c;
nb = n;
}
/** Calcul la réponse en noir et blanc de la comparaison
* entre la combinaison mystere et le coup joué
* retourne vrai si le coup est gagnant
*/
private boolean compare(Combinaison mystere) {
boolean trouve;
nbN = maC.getNbN(mystere);
nbB = maC.getNbB(mystere);
trouve = (nbN == nb);
return trouve;
}
public int getBlanc() {
return nbB;
}
public int getNoir() {
return nbN;
}
public String toString() {
String phrase = maC.toString();
if (nbN > 9) phrase += " ";
else phrase += " ";
phrase += nbN;
if (nbB > 9) phrase += " ";
else phrase += " ";
phrase += nbB;
return phrase;
}
}

/** gère les combinaisons
*
*/
public class Combinaison {
// la combinaison
private int [] valeur;
// nombre de pion dans une combinaison
private int nb;
// nombre de valeur différente
private int borne;
// la combinaison est-elle vide ?
private boolean estVide;
public Combinaison(int n, int b) {
nb = n;
borne = b;
valeur = new int [nb];
estVide = true;
}
public Combinaison(int n, int b, String c) {
this(n, b);
setValeur(c);
}
/** Tire au hasard une combinaison
* des symboles peuvent se répéter
* si repeteOK est vrai
*/
public void setValeur(boolean repeteOK) {
int i;
boolean repete = repeteOK;
// si le nombre de valeur possible est inférieur au nombre de pion dans une combinaison,
// on force la répétition de valeur
if (borne < nb) repete = true;
if (repete) {
for (i = 0; i < nb; i ++) {
valeur [i] = hasard();
}
} else {
// on cherche si la valeur a déjà été attribuée
boolean [] attribue = new boolean[borne];
for (i = 0; i < borne; i ++) {
attribue[i] = false;
}
for (i = 0; i < nb; i ++) {
do {
valeur [i] = hasard();
}
while (attribue[valeur[i]]);
attribue[valeur[i]] = true;
}
}
estVide = false;
}
/* tire un valeur au hasard*/
private int hasard() {
return (int)(Math.random() * (borne));
}
/* initialise la combinaison à partir d'une chaine de caractères*/
public void setValeur(String val) {
int i;
for (i = 0; i < nb; i ++) {
valeur [i] = ((int)(val.charAt(i))) - 65;
}
estVide = false;
}
//renvoie la valeur entière positionnée en i
public int getValeurInt(int i) {
if ( ! estVide) return (valeur[i]);
else return - 1;
}
//renvoie la valeur texte de position i
public String getValeur(int i) {
if ( ! estVide) return ("" + (char) (valeur[i] + 65));
else return ".";
}
// calcul le nombre de noir par rapport à une combinaison m
public int getNbN(Combinaison m) {
int i, j;
j = 0;
for (i = 0; i < nb; i ++) {
if (m.getValeurInt(i) == valeur[i]) j ++;
}
return j;
}
// calcul le nombre de blanc par rapport à une combinaison m
public int getNbB(Combinaison m) {
int i, j, nbB = 0;
boolean fin;
// si une lettre a déjà été évaluée dans une notation
// on la marque afin de ne pas l'impliquer dans une autre notation
// le tableau estEvalue... sert à mémoriser cette implication
// mais il faut le faire pour les deux combinaisons.
// Pour des combinaisons où il n'y a pas de répétition
// c'est inutile !
boolean [] estEvalueMystere = new boolean[nb];
boolean [] estEvalueCombinaison = new boolean[nb];
// si la lettre est impliquée dans la notation des noirs, on la marque
for (i = 0; i < nb; i ++) {
estEvalueMystere[i] = (m.getValeurInt(i) == valeur[i]);
estEvalueCombinaison[i] = estEvalueMystere[i];
}
for (i = 0; i < nb; i ++) {
fin = false;
for (j = 0; j < nb && ! fin; j ++) {
// si les indices sont différents (on evite de comparer les bien placés (noirs)
if (i != j) {
// si deux valeurs sont les mêmes et qu'aucunes n'a déjà été évaluée
if (m.getValeurInt(i) == valeur[j] && ! estEvalueMystere[i] && ! estEvalueCombinaison[j]) {
// on les marques évaluées
estEvalueMystere[i] = true;
estEvalueCombinaison[j] = true;
// on ajoute un blanc
nbB ++;
// on arrête de comparer valeur[j] car on vient de l'évaluer
fin = true;
}
}
}
}
return nbB;
}
public String toString() {
String phrase = getValeur(0);
int i;
for (i = 1; i < nb; i ++) {
phrase += " " + getValeur(i);
}
return phrase;
}
}

void main() {
String combiSaisie;
boolean combiOK = true;
// initialisation du jeu
// Jeu(nb de pion dans la combinaison, nombre de 'couleur' possible, nb de coup autorisé)
Jeu monJeu = new Jeu(4, 6, 8);
monJeu.affichage();
do{
do {
combiSaisie = readString("Saisir votre combinaison sans espace").toUpperCase().trim();
combiOK = monJeu.estCorrecte(combiSaisie);
}
while ( ! combiOK);
monJeu.saisirCoup(combiSaisie);
monJeu.affichage();
}
while ( ! monJeu.estFini());
}