je dois faire ça pour un TP.
je suis en phase de finalisation.
je posterai cette aprem ce que j´ai fait, et j´espere que vous me dirai ce qu´il ne va pas ! ou si tout va bien.
Avec ou sans IA ?
Intéressant
Quelle interface de rendu utilises tu ?
- texte ? (printf, cout, conio, ncurses... ?? )
- graphique ? (SDL, OpenGL, DirectX, ... ?? )
seulement une interface texte pour le moment en tout cas ca suffit pr le tp et pr avoir une bonne note je pense
pour ceux qui sont courageux pouvez vous me dire comment virer les instruction break car elles sont deconseiller merci
/*la consigne est de creer un jeu de mastermind*/
/*tout d´abord voici la fonction qui permet de generer automatiquement
les numeros du jeu a trouver : */
/* fonction qui determine si tous les chiffres saisies sont bien
compris entre 1 et 8 inclus */
int BonneSaisie(int n,int T[])
{ int i;
for (i=1;i<n+1;i++)
{if (T[i]<0 || T[i]>8)
return 0;}
return 1;}
/*ci dessous la fonction que faire qui nous servira ulterieurement*/
int QueFaire()
{int rep;
printf("que voulez vous faire ? :\n\n");
printf(" JOUER 1\n");
printf(" REJOUER LE MEME 2\n");
printf(" DONNER LA SOLUTION 3\n");
printf(" QUITTER 4\n\n");
scanf("%d",&rep);
return rep;}
/*passons maintenant a la fonction qui genere aleatoirement les numeros*/
void SaisieInitiale(int n,int T[])
{ int i;
for (i=1;i<n+1;i++)
{T[i]=/*(rand()%9)*/( (rand()%8)+1);}}
/*ce qui suit est une aide pour nous il sert afficher la tableau initiale*/
void AfficherSaisieInitiale(int n, int T[])
{int i;
for (i=1;i<n+1;i++)
{printf("%d ",T[i]);}
printf("\n\n\n");}
/*passons a la fonction qui va demander au joueur les numero qu´il
souhaite saisir*/
void SaisieJoueur(int n, int Tbis[])
{int i;
printf("\n\n entrez vos cinq valeur separes par un espace :\n");
for (i=1;i<n+1;i++)
{scanf("%d",&Tbis[i]);}
if (0==BonneSaisie(n,Tbis))
{printf("une ou plusieurs des valeurs saisies sont fausse, nouvelle saisie :");
SaisieJoueur(n, Tbis);}}
/*passons a la fonction copie qui copie le tableau initiale
affin qu´on puisse y travailler dessus*/
/*cette version de copie ne marche pas*/
/*void copie(int n,int T[])
{int Tcop[5];
int i;
for (i=1;i<n+1;i++)
{Tcop[i]=T[i];}}*/
//nouvelle version
void Copie(int n, int T[],int T1[])
{int i;
for (i=1;i<n+1;i++)
{T1[i] = T[i];}}
/*passons maintenant aux fonctions plus précise
qui va nous indiquer
combien de chiffres sont bien placé */
int BienPlace(int n, int T[], int T1[])
{int i;
int bp=0;
for (i=1;i<n+1;i++)
{if (T[i]==T1[i])
{bp+=1;
T[i]=9; //on remplace par 9 pour ne pa
s le compter deux fois
T1[i]=9; }
} //ici aussi
return bp;}
/*maintenant les mal placé*/
int MalPlace(int n,int T[],int T1[])
{int i,j,mp=0;
for (i=1;i<n+1;i++)
{ for (j=1;j<n+1;j++)
{if (T[i]==T1[j]/*&& i!=j */&& T[i]!
=9 && T1[j]!=9)
{mp+=1;
T[i] = 9; //on remplace ici
aussi par 9
T1[j] = 9;}}} //ici aussi
return mp;}
/*ecrivons une fonction qui determine si le ta
bleau comporte que des 0*/
int FIN(int n, int T[])
{int i;
for (i=1;i<n+1;i++)
{if (T[i] == 0) return 0;}
return 1;}
/*attaquons le gros du sujet mais toujour pas la fonction main*/
void mastermind()
{int nbfoix=0; int T[5];int bpf=0;int nbfoixmax=12;
SaisieInitiale(5,T); //saisie aleatoirement l
es numero
AfficherSaisieInitiale(5,T); //a ne pas lais
ser dans la version finale
while (bpf != 5)
{ int Tbis[5];
SaisieJoueur(5,Tbis);
if (0==FIN(5,Tbis)) { printf("vous avez decide d arreter a bientot\n");break;}
nbfoix+=1;
// AfficherSaisieInitiale(5,Tbis);
/*int Tcop[5];
copie(5,T);*/
int Tcop[5];
/*debut de la copie manuelle*/
/* Tcop[1]=T[1];
Tcop[2]=T[2];
Tcop[3]=T[3];
Tcop[4]=T[4];
Tcop[5]=T[5];*/
// AfficherSaisieInitiale(5,Tcop);
/*fin de la copie manuelle*/
Copie(5,T,Tcop);
bpf=BienPlace(5,Tcop,Tbis);
printf("il y a %d chiffres bien places"
,bpf);
printf("\n");
printf("il y a %d chiffres mal places\n",MalPlace(5,Tcop,Tbis));
if (nbfoix==nbfoixmax) {printf("vous avez expirer votre nombre de fois\n");
break;}
if (bpf ==5) {printf("VOUS AVEZ GAGNER\n");}
}}
/*maintenant la fonction main*/
int main()
{printf("Welcome to MasterMind\n\n");
int nbpr =9; // pour 8 ca met des zero
/* while (QueFaire()==1) fonction du deb
ut
{srand(nbpr);
nbpr+=1;
mastermind();
} */
/*ameliorons la fonction pour nous donner la posssibilité
de rejouer le mastermind precedent ou bien d´imprimer la solution*/
int rep; int Tres[5];
while ((rep = QueFaire())!=4)
{srand(nbpr);
if (rep==1)
{/*srand(nbpr);*/
nbpr+=1;
mastermind();}
else if(rep==2)
{srand(nbpr-1);
/*nbpr+=1;*/
mastermind();}
else if (rep==3)
{ srand(nbpr-1);
SaisieInitiale(5,Tres);
printf("\n\n la solution etait : ");
AfficherSaisieInitiale(5,Tres);}
}
printf("\n A TRES BIENTOT SUR MASTERMIND \n\n\n\n");
system("PAUSE");
return 0;}
si vous voulez de p^lsu amples precision faites le moi savoir je me ferai une joi de vous expliquer surtout si vs pouvez maider en retour
la prochaine fois que tu as un code aussi volumineux a montrer met le sur un wall :
http://rafb.net/paste/
Ca aide beaucoup a la compréhension.
C´est quoi le probleme avec les break ? depuis quand est-ce déconseillé ? Comment faire un switch sans break ?
j´ai parcouru rapidement ton code (la partie avec les break) et tu peux t´en passer facilement en mettant:
if () { ... bpf=5;}
else { le reste }
au lieu de
if () { .... break; }
le reste
vu que si (bpf==5) alors on sort de la boucle while, il suffit de mettre bpf a 5 et de ne plus rien effectuer dans le corp de la boucle.
http://rafb.net/paste/results/P2DeQF73.html
voila ce devrai aller mieu
le truc c´est que je veux sortir de la boucle pour trois raison :
1) si nbfoix=nbfoismax
cad si le joueur a atteint le nombre maximum d´essaie.
2) si bpf = 5
cad si le joueur a trouver les 5 bien placer s´il a gagner koi!
3) s´il tape 0 0 0 0 0
car c´est la combinaison defini pour une interuption volontaire
alors pr les deux premier c´est bon c´est facile, suffit de mettre while(bpf!=5 && nbfoix!=nbfoixmax)
ca cest daccord mais je voit pas comment faire pour l´autre !!
et si tu mets deux variables du genre
int raisonSortie;
code la raison de la sortie de la boucle (0 > sortie volontaire, 1 > gagné, 2 > perdu...) et a la sortie de ta boucle tu fais un test pour connaitre la raison de la sortie.
int continuer;
pour savoir si on continu la boucle ou pas. En gros au lieu de break tu met :
raisonSortie = 5;
continuer = 0;
et tu fais un while(continuer) au lieu de while(bpf!=5)
bah je vais essayer !
sinon j´ai trouver une espece de solution alternative pas tres jolie mais bon
http://rafb.net/paste/results/0ANpK026.html
en fait j´ai ajouter une nouvelle variable "fin"
et si la combinaison entrer par le joueur est 0 0 0 0 0 alors je fait fin=1
ca me fait donc un while(bpf!=5 && nbfoix!=nbfoixmax && fin!=1)
mais bon c´a sapelle contourner le probleme!!
je vais essayer ce que tu me dis ca ma l´air bien plus jolie
Ce qu´il te dit, c´est ce que tu as fait ![]()
Ta methode ne contourne pas le probleme, au contraire, elle le resoud.
(Ton fin joue le role de son continuer, sauf que pour quitter, continuer doit etre egal a 0, et fin a 1)
exact. au lieu d´avoir un couple de variables pour indiqué la sortie de la boucle (et sa raison) tu en a 3 qui font exactement le meme travail:
bpf == 5 equivaut a continuer = 0 et raisonSortie = 2 (exemple)
nbfois != nbfoixmax equivaut a continuer = 0 et raisonSorti = 3
et ainsi de suite.
ta méthodes est efficace pour des cas ou tu a peu de cas de sortie donc peu de variable mais admetons que tu ais 10 raisons differentes de sortir de la boucle... Imagine la tete du test de ta boucle...
Sur ce point la deuxieme méthode est plus éficace car dans tout les cas la condition de la boucle sera toujours
while(continuer)
bien sur ensuite il faut interpreter la variable raisonSortie pour savoir ce qui a fais sortir mais globalement je trouve ça plus pratique et surtout plus générale. Et en informatique on aime bien les trucs généraux parce que c´est facile a réutiliser et ça fais moins de boulot.
okai merci les gars
Petit conseil : indente.
Je me rappelle que les profs m´ont allumé une fois car je faisais comme toi :
if (truc) {truc();truc();}
Les profs preferent (et il est vrai que c´est tres lisible) comme ça
if (truc)
{
truc();
truc();
}
avec des indentations ![]()
le tout n´est qu´une histoire d´indentation; a dire vrai ca me soule de faire ca, mais je comprend qu´ils preferent c´est carrement bcp plus lisibls e!
en tout ca merci a tous !
en esperant que mon algo reservent à quelques uns !
le tout n´est qu´une histoire d´indentation, à dire vrai ça me saoule de faire ça, mais je comprends que les profs préfèrent car c´est carrement beaucoup plus lisible !
c´est dailleurs pour que ce soit plus lisible que je reprends mon post.
en tout cas merci à tous.
en esperant que cet algo servent à quelqu´un d´autre
ce n´est pas que pour faire plaisir aux profs, tu va vite comprendre que c´est indispensable. Le jour ou tu bossera plus de 5h sur un projet (sur plusieurs jours/semaines) tu sera bien content d´avoir un code propre, lisible et qui permet de voir rapidement ce qui se passe.
Autant prendre les bonnes habitudes des le début:
- indentation réguliere
- commentaire systematique des fonctions et actions legerement ambigues
guyver2 > oui, il faut prendre de bonnes habitudes, mais hélas, dans le privé, ça ne se passe pas tout comem on le voudrait.
Les codes sont souvent sales, mal indentés, plein de copier/coller, fait a l´arrache, plein de rustines....
Le monde du travail est loin d´etre la perfection hélas....
Les codes sont souvent sales, mal indentés, plein de copier/coller, fait a l´arrache, plein de rustines....
c´est pas parce que les autres sont des cochons qu´il faut faire pareil. Pour le moment je ne code que pour moi donc évidement je fais du travail propre mais c´est vrai que si on sait qu´on va jamais revenir sur un truc, pourquoi se casser la nenette...
clair, mais meme avec toute la bonne volonté du monde, un truc ne reste hélas pas souvent propre longtemps
surtout quand le projet évolue sur plusieurs années...
"si on sait qu´on va jamais revenir sur un truc, pourquoi se casser la nenette..."
Je me rappele de livre de GL disant: votre code ne sera jamais utilisé dans le cas auquel vous aviez pensé!
C´est pour ca que je penses qu´il faut toujours ecrire proprement les choses. D´autant plus qu´il faudra le débugger a un moment ou a un autre.