Juego de awale en Java
Bonjour tout le monde,
Tengo un proyecto que realizar en java, de hecho, es el famoso juego de awelé. Comencé por entender los algoritmos de búsqueda y sobre todo el algoritmo (ALPHA BETA) que es mejor que el de MINMAX. He realizado mi primera versión del juego en C solo para probar mi algoritmo y funciona muy bien. Pero cuando intenté hacerlo en OO en java ya no funciona. Realmente no entiendo porque es el mismo algoritmo. Aquí está la versión en lenguaje C:
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int case_retenu;
typedef struct
{
int moi[6];
int cpu[6];
int score_moi;
int score_cpu;
} awale;
void initialisation(awale *a)
{
for(int i=0;i<6;i++)
{
a->moi[i] = 4;
a->cpu[i] = 4;
}
a->score_moi = 0;
a->score_cpu = 0;
}
void afficher(awale a)
//*************************
{
printf("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n",201,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,187);
printf("%c%2d%c%2d%c%2d%c%2d%c%2d%c%2d%c score : %d\n",186,a.cpu[5],179,a.cpu[4],179,a.cpu[3],179,a.cpu[2],179,a.cpu[1],179,a.cpu[0],186,a.score_cpu);
printf("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n",186,196,196,197,196,196,197,196,196,197,196,196,197,196,196,197,196,196,186);
printf("%c%2d%c%2d%c%2d%c%2d%c%2d%c%2d%c score : %d\n",186,a.moi[0],179,a.moi[1],179,a.moi[2],179,a.moi[3],179,a.moi[4],179,a.moi[5],186,a.score_moi);
printf("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n",200,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,188);
}
void jouer(awale *a,int choix)
{ int somme_adversaire=0,i,nb,c,j=0;
if(a->moi[choix]==0) { //printf("\nil faut jouer une case non vide");
return;
}
// il faut tester si l'adversaire n'a pas de graines
for(i=0;i<6;i++) somme_adversaire+=a->cpu[i];
nb = a->moi[choix];
if(somme_adversaire==0)
{
// tester est ce que la case choisie nourrit l'adversaire
if((choix+nb)<6) {
// printf("\n Il faut nourrire l'adversaire");
return;
}
}
a->moi[choix]=0;
i=1;
int dernier = -1;
int position = -1;
int depart;
while(i<=nb)
{
if(i%12!=0)
{
c = choix+i;
int borne1=0,borne2=5;
depart=0;
for(int k=0;k<4;k++)
{
if( c>=borne1 && c<=borne2 && (i!=depart)) {
a->moi[c-depart]++;
dernier = 0;
}
if( c>=(borne1+6) && c<=(borne2+6)) {
a->cpu[c-(depart+6)]++;
dernier = 1;
position = c-(depart+6);
// printf("\n position = %d",position);
}
depart+=12;
borne1+=12;
borne2+=12;
}
i++;
}
else { nb++;
i++;
} //sauter la case du départ
}
//printf("position = %d, cpu[position]=%d \n",position,a->moi[position]);
if(dernier==1) // dernier pion joué étais dans la zone de l'adversaire
{ //printf("position=%d\n",position);
while( (position>=0) && ((a->cpu[position]==2) || (a->cpu[position]==3)) )
{
a->score_moi += a->cpu[position];
a->cpu[position]=0;
position--;
}
}
}
void cpu_joue(awale *a,int choix)
{ int somme_adversaire=0,i,nb,c,j=0;
if(a->cpu[choix]==0) { //printf("\nil faut jouer une case non vide\n");
return;
}
// il faut tester si l'adversaire n'a pas de graines
for(i=0;i<6;i++) somme_adversaire+=a->moi[i];
nb = a->cpu[choix];
if(somme_adversaire==0)
{
// tester est ce que la case choisie nourrit l'adversaire
if((choix+nb)<6) {
printf("\n Il faut nourrire l'adversaire \n");
return;
}
}
a->cpu[choix]=0;
i=1;
int dernier = -1;
int position = -1;
int depart;
while(i<=nb)
{
if(i%12!=0)
{
c = choix+i;
int borne1=0,borne2=5;
depart=0;
for(int k=0;k<4;k++)
{
if( c>=borne1 && c<=borne2 && (i!=depart)) { a->cpu[c-depart]++;
dernier = 0;
}
if( c>=(borne1+6) && c<=(borne2+6)) {
a->moi[c-(depart+6)]++;
dernier = 1;
position = c-(depart+6);
// printf("\n position = %d",position);
}
depart+=12;
borne1+=12;
borne2+=12;
}
i++;
}
else { nb++;
i++ ;
} //sauter la case du départ
}
// printf("position = %d, moi[position]=%d \n",position,a->moi[position]);
// Pour extraire les gains.
if(dernier==1) // dernier pion joué étais dans la zone de l'adversaire
{
while( (position>=0) && ((a->moi[position]==2) || (a->moi[position]==3)) )
{ a->score_cpu += a->moi[position];
a->moi[position]=0;
position--;
}
}
}
int alphabeta(awale a,int alpha,int beta,int profondeur)
{ int i=0,x;
awale awa[6];
if(profondeur==0) return(a.score_cpu - a.score_moi);
while( (alpha<beta) && (i<6) )
{ if(a.cpu[i]!=0)
{ awa[i] = a;
cpu_joue(&awa[i],i);
x = alphabeta(awa[i],-beta,-alpha,profondeur-1) * (-1);
if(x>alpha) {
alpha = x;
if(a.cpu[i]!=0 && profondeur==4){
printf("\n a.cpu=%d case=%d ",a.cpu[i],i);
case_retenu = i;
}
}
}
i++;
} // while
return(alpha);
}
void main()
{
clrscr();
awale a;
int c=20,choix;
initialisation(&a);
afficher(a);
while(c>0)
{
scanf("%d",&choix);
jouer(&a,choix-1);
afficher(a);
//scanf("%d",&choix);
int alpha=-9999,beta=9999,x=20;
case_retenu=1;
choix = alphabeta(a,alpha,beta,4);
//if(a.cpu[choix]==0) choix = alphabeta(a,alpha,beta,5);
printf("\n choix = %d \n",case_retenu);
cpu_joue(&a,case_retenu);
afficher(a);
c--;
}
getch();
}
*********************************************
*********************************************
*********************************************
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
y esta es la versión en Java:
import java.*;
import java.io.*;
class awale
{
int moi[],cpu[];
int score_cpu,score_moi;
static int case_retenu=5;
//*******************************************************************************************************
//*******************************************************************************************************
public awale()
{
moi = new int[6];
cpu = new int[6];
for(int i=0;i<6;i++) moi[i]=cpu[i]=4;
score_moi=score_cpu=0;
}
//*******************************************************************************************************
//*******************************************************************************************************
public void afficher()
{
System.out.println(cpu[5]+" "+cpu[4]+" "+cpu[3]+" "+cpu[2]+" "+cpu[1]+" "+cpu[0]+" score: "+score_cpu);
System.out.println(moi[0]+" "+moi[1]+" "+moi[2]+" "+moi[3]+" "+moi[4]+" "+moi[5]+" score: "+score_moi+"\n\n");
}
//*******************************************************************************************************
//*******************************************************************************************************
public int choisi()
{
return case_retenu;
}
public void modif(int x)
{
case_retenu = x;
}
//*******************************************************************************************************
//*******************************************************************************************************
void jouer(int choix)
{ int somme_adversaire=0,i,nb,c,j=0;
if(moi[choix]==0) {
return;
}
// il faut tester si l'adversaire n'a pas de graines
for(i=0;i<6;i++) somme_adversaire+=cpu[i];
nb = moi[choix];
if(somme_adversaire==0)
{
// tester est ce que la case choisie nourrit l'adversaire
if((choix+nb)<6) {
return;
}
}
moi[choix]=0;
i=1;
int dernier = -1;
int position = -1;
int depart;
while(i<=nb)
{
if(i%12!=0)
{
c = choix+i;
int borne1=0,borne2=5;
depart=0;
for(int k=0;k<4;k++)
{
if( c>=borne1 && c<=borne2 && (i!=depart)) {
moi[c-depart]++;
dernier = 0;
}
if( c>=(borne1+6) && c<=(borne2+6)) {
cpu[c-(depart+6)]++;
dernier = 1;
position = c-(depart+6);
}
depart+=12;
borne1+=12;
borne2+=12;
}
i++;
}
else { nb++;
i++;
} //sauter la case du départ
}
if(dernier==1) // dernier pion joué étais dans la zone de l'adversaire
{
while( (position>=0) && ((cpu[position]==2) || (cpu[position]==3)) )
{
score_moi += cpu[position];
cpu[position]=0;
position--;
}
}
}
//*******************************************************************************************************
//*******************************************************************************************************
void cpu_joue(int choix)
{ int somme_adversaire=0,i,nb,c,j=0;
if(cpu[choix]==0) {
return;
}
// il faut tester si l'adversaire n'a pas de graines
for(i=0;i<6;i++) somme_adversaire+=moi[i];
nb = cpu[choix];
if(somme_adversaire==0)
{
// tester est ce que la case choisie nourrit l'adversaire
if((choix+nb)<6) {
return;
}
}
cpu[choix]=0;
i=1;
int dernier = -1;
int position = -1;
int depart;
while(i<=nb)
{
if(i%12!=0)
{
c = choix+i;
int borne1=0,borne2=5;
depart=0;
for(int k=0;k<4;k++)
{
if( c>=borne1 && c<=borne2 && (i!=depart)) { cpu[c-depart]++;
dernier = 0;
}
if( c>=(borne1+6) && c<=(borne2+6)) {
moi[c-(depart+6)]++;
dernier = 1;
position = c-(depart+6);
}
depart+=12;
borne1+=12;
borne2+=12;
}
i++;
}
else { nb++;
i++ ;
} //sauter la case du départ
}
// Pour extraire les gains.
if(dernier==1) // dernier pion joué étais dans la zone de l'adversaire
{
while( (position>=0) && ((moi[position]==2) || (moi[position]==3)) )
{ score_cpu += moi[position];
moi[position]=0;
position--;
}
}
}
//*******************************************************************************************************
//*******************************************************************************************************
public int[] retourner_moi()
{
int[] tab = new int[6] ;
for(int i=0;i<6;i++) tab[i] = moi[i];
return tab;
}
public int[] retourner_cpu()
{
int[] tab = new int[6];
for(int i=0;i<6;i++) tab[i] = cpu[i];
return tab;
}
public int retourner_score_moi()
{
return score_moi;
}
public int retourner_score_cpu()
{
return score_cpu;
}
//*******************************************************************************************************
//*******************************************************************************************************
public void copier(awale a)
{
int[] tab1, tab2;
tab1 = a.retourner_moi();
tab2 = a.retourner_cpu();
for (int i = 0; i < 6; i++)
{
moi[i] = tab1[i];
cpu[i] = tab2[i];
}
}
//*******************************************************************************************************
//*******************************************************************************************************
int alphabeta(int alpha,int beta,int profondeur)
{ int i=0,x;
awale[] awa = new awale[6];
if(profondeur==0) return(score_cpu - score_moi);
while( (alpha<beta) && (i<6) )
{ if(cpu[i]!=0)
{ awa[i] = new awale();
awa[i].copier(this);
awa[i].cpu_joue(i);
x = alphabeta(-beta,-alpha,profondeur-1) * (-1);
if(x>alpha) {
alpha = x;
if(cpu[i]!=0 && profondeur==4){
this.modif(i);
}
}
}
i++;
} // while
return(alpha);
}
public int lire() throws IOException
{
int c=-1;
System.out.println("lire");
while(c<0)
{c = System.in.read() - 48;}
return c;
}
public static void main(String s[])
{ try
{
awale a = new awale();
int i=20,c;
a.afficher();
while(i>0)
{
c = a.lire();
System.out.println("c = "+c);
a.jouer(c);
a.afficher();
int x = a.alphabeta(-9999,9999,4);
int choix = a.choisi();
System.out.println("choix = "+choix);
a.cpu_joue(choix);
a.afficher();
i--;
}//while
}//try
catch(IOException e) {}
}
}
Y muchas gracias por su ayuda.
Tengo un proyecto que realizar en java, de hecho, es el famoso juego de awelé. Comencé por entender los algoritmos de búsqueda y sobre todo el algoritmo (ALPHA BETA) que es mejor que el de MINMAX. He realizado mi primera versión del juego en C solo para probar mi algoritmo y funciona muy bien. Pero cuando intenté hacerlo en OO en java ya no funciona. Realmente no entiendo porque es el mismo algoritmo. Aquí está la versión en lenguaje C:
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int case_retenu;
typedef struct
{
int moi[6];
int cpu[6];
int score_moi;
int score_cpu;
} awale;
void initialisation(awale *a)
{
for(int i=0;i<6;i++)
{
a->moi[i] = 4;
a->cpu[i] = 4;
}
a->score_moi = 0;
a->score_cpu = 0;
}
void afficher(awale a)
//*************************
{
printf("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n",201,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,187);
printf("%c%2d%c%2d%c%2d%c%2d%c%2d%c%2d%c score : %d\n",186,a.cpu[5],179,a.cpu[4],179,a.cpu[3],179,a.cpu[2],179,a.cpu[1],179,a.cpu[0],186,a.score_cpu);
printf("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n",186,196,196,197,196,196,197,196,196,197,196,196,197,196,196,197,196,196,186);
printf("%c%2d%c%2d%c%2d%c%2d%c%2d%c%2d%c score : %d\n",186,a.moi[0],179,a.moi[1],179,a.moi[2],179,a.moi[3],179,a.moi[4],179,a.moi[5],186,a.score_moi);
printf("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\n",200,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,188);
}
void jouer(awale *a,int choix)
{ int somme_adversaire=0,i,nb,c,j=0;
if(a->moi[choix]==0) { //printf("\nil faut jouer une case non vide");
return;
}
// il faut tester si l'adversaire n'a pas de graines
for(i=0;i<6;i++) somme_adversaire+=a->cpu[i];
nb = a->moi[choix];
if(somme_adversaire==0)
{
// tester est ce que la case choisie nourrit l'adversaire
if((choix+nb)<6) {
// printf("\n Il faut nourrire l'adversaire");
return;
}
}
a->moi[choix]=0;
i=1;
int dernier = -1;
int position = -1;
int depart;
while(i<=nb)
{
if(i%12!=0)
{
c = choix+i;
int borne1=0,borne2=5;
depart=0;
for(int k=0;k<4;k++)
{
if( c>=borne1 && c<=borne2 && (i!=depart)) {
a->moi[c-depart]++;
dernier = 0;
}
if( c>=(borne1+6) && c<=(borne2+6)) {
a->cpu[c-(depart+6)]++;
dernier = 1;
position = c-(depart+6);
// printf("\n position = %d",position);
}
depart+=12;
borne1+=12;
borne2+=12;
}
i++;
}
else { nb++;
i++;
} //sauter la case du départ
}
//printf("position = %d, cpu[position]=%d \n",position,a->moi[position]);
if(dernier==1) // dernier pion joué étais dans la zone de l'adversaire
{ //printf("position=%d\n",position);
while( (position>=0) && ((a->cpu[position]==2) || (a->cpu[position]==3)) )
{
a->score_moi += a->cpu[position];
a->cpu[position]=0;
position--;
}
}
}
void cpu_joue(awale *a,int choix)
{ int somme_adversaire=0,i,nb,c,j=0;
if(a->cpu[choix]==0) { //printf("\nil faut jouer une case non vide\n");
return;
}
// il faut tester si l'adversaire n'a pas de graines
for(i=0;i<6;i++) somme_adversaire+=a->moi[i];
nb = a->cpu[choix];
if(somme_adversaire==0)
{
// tester est ce que la case choisie nourrit l'adversaire
if((choix+nb)<6) {
printf("\n Il faut nourrire l'adversaire \n");
return;
}
}
a->cpu[choix]=0;
i=1;
int dernier = -1;
int position = -1;
int depart;
while(i<=nb)
{
if(i%12!=0)
{
c = choix+i;
int borne1=0,borne2=5;
depart=0;
for(int k=0;k<4;k++)
{
if( c>=borne1 && c<=borne2 && (i!=depart)) { a->cpu[c-depart]++;
dernier = 0;
}
if( c>=(borne1+6) && c<=(borne2+6)) {
a->moi[c-(depart+6)]++;
dernier = 1;
position = c-(depart+6);
// printf("\n position = %d",position);
}
depart+=12;
borne1+=12;
borne2+=12;
}
i++;
}
else { nb++;
i++ ;
} //sauter la case du départ
}
// printf("position = %d, moi[position]=%d \n",position,a->moi[position]);
// Pour extraire les gains.
if(dernier==1) // dernier pion joué étais dans la zone de l'adversaire
{
while( (position>=0) && ((a->moi[position]==2) || (a->moi[position]==3)) )
{ a->score_cpu += a->moi[position];
a->moi[position]=0;
position--;
}
}
}
int alphabeta(awale a,int alpha,int beta,int profondeur)
{ int i=0,x;
awale awa[6];
if(profondeur==0) return(a.score_cpu - a.score_moi);
while( (alpha<beta) && (i<6) )
{ if(a.cpu[i]!=0)
{ awa[i] = a;
cpu_joue(&awa[i],i);
x = alphabeta(awa[i],-beta,-alpha,profondeur-1) * (-1);
if(x>alpha) {
alpha = x;
if(a.cpu[i]!=0 && profondeur==4){
printf("\n a.cpu=%d case=%d ",a.cpu[i],i);
case_retenu = i;
}
}
}
i++;
} // while
return(alpha);
}
void main()
{
clrscr();
awale a;
int c=20,choix;
initialisation(&a);
afficher(a);
while(c>0)
{
scanf("%d",&choix);
jouer(&a,choix-1);
afficher(a);
//scanf("%d",&choix);
int alpha=-9999,beta=9999,x=20;
case_retenu=1;
choix = alphabeta(a,alpha,beta,4);
//if(a.cpu[choix]==0) choix = alphabeta(a,alpha,beta,5);
printf("\n choix = %d \n",case_retenu);
cpu_joue(&a,case_retenu);
afficher(a);
c--;
}
getch();
}
*********************************************
*********************************************
*********************************************
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
y esta es la versión en Java:
import java.*;
import java.io.*;
class awale
{
int moi[],cpu[];
int score_cpu,score_moi;
static int case_retenu=5;
//*******************************************************************************************************
//*******************************************************************************************************
public awale()
{
moi = new int[6];
cpu = new int[6];
for(int i=0;i<6;i++) moi[i]=cpu[i]=4;
score_moi=score_cpu=0;
}
//*******************************************************************************************************
//*******************************************************************************************************
public void afficher()
{
System.out.println(cpu[5]+" "+cpu[4]+" "+cpu[3]+" "+cpu[2]+" "+cpu[1]+" "+cpu[0]+" score: "+score_cpu);
System.out.println(moi[0]+" "+moi[1]+" "+moi[2]+" "+moi[3]+" "+moi[4]+" "+moi[5]+" score: "+score_moi+"\n\n");
}
//*******************************************************************************************************
//*******************************************************************************************************
public int choisi()
{
return case_retenu;
}
public void modif(int x)
{
case_retenu = x;
}
//*******************************************************************************************************
//*******************************************************************************************************
void jouer(int choix)
{ int somme_adversaire=0,i,nb,c,j=0;
if(moi[choix]==0) {
return;
}
// il faut tester si l'adversaire n'a pas de graines
for(i=0;i<6;i++) somme_adversaire+=cpu[i];
nb = moi[choix];
if(somme_adversaire==0)
{
// tester est ce que la case choisie nourrit l'adversaire
if((choix+nb)<6) {
return;
}
}
moi[choix]=0;
i=1;
int dernier = -1;
int position = -1;
int depart;
while(i<=nb)
{
if(i%12!=0)
{
c = choix+i;
int borne1=0,borne2=5;
depart=0;
for(int k=0;k<4;k++)
{
if( c>=borne1 && c<=borne2 && (i!=depart)) {
moi[c-depart]++;
dernier = 0;
}
if( c>=(borne1+6) && c<=(borne2+6)) {
cpu[c-(depart+6)]++;
dernier = 1;
position = c-(depart+6);
}
depart+=12;
borne1+=12;
borne2+=12;
}
i++;
}
else { nb++;
i++;
} //sauter la case du départ
}
if(dernier==1) // dernier pion joué étais dans la zone de l'adversaire
{
while( (position>=0) && ((cpu[position]==2) || (cpu[position]==3)) )
{
score_moi += cpu[position];
cpu[position]=0;
position--;
}
}
}
//*******************************************************************************************************
//*******************************************************************************************************
void cpu_joue(int choix)
{ int somme_adversaire=0,i,nb,c,j=0;
if(cpu[choix]==0) {
return;
}
// il faut tester si l'adversaire n'a pas de graines
for(i=0;i<6;i++) somme_adversaire+=moi[i];
nb = cpu[choix];
if(somme_adversaire==0)
{
// tester est ce que la case choisie nourrit l'adversaire
if((choix+nb)<6) {
return;
}
}
cpu[choix]=0;
i=1;
int dernier = -1;
int position = -1;
int depart;
while(i<=nb)
{
if(i%12!=0)
{
c = choix+i;
int borne1=0,borne2=5;
depart=0;
for(int k=0;k<4;k++)
{
if( c>=borne1 && c<=borne2 && (i!=depart)) { cpu[c-depart]++;
dernier = 0;
}
if( c>=(borne1+6) && c<=(borne2+6)) {
moi[c-(depart+6)]++;
dernier = 1;
position = c-(depart+6);
}
depart+=12;
borne1+=12;
borne2+=12;
}
i++;
}
else { nb++;
i++ ;
} //sauter la case du départ
}
// Pour extraire les gains.
if(dernier==1) // dernier pion joué étais dans la zone de l'adversaire
{
while( (position>=0) && ((moi[position]==2) || (moi[position]==3)) )
{ score_cpu += moi[position];
moi[position]=0;
position--;
}
}
}
//*******************************************************************************************************
//*******************************************************************************************************
public int[] retourner_moi()
{
int[] tab = new int[6] ;
for(int i=0;i<6;i++) tab[i] = moi[i];
return tab;
}
public int[] retourner_cpu()
{
int[] tab = new int[6];
for(int i=0;i<6;i++) tab[i] = cpu[i];
return tab;
}
public int retourner_score_moi()
{
return score_moi;
}
public int retourner_score_cpu()
{
return score_cpu;
}
//*******************************************************************************************************
//*******************************************************************************************************
public void copier(awale a)
{
int[] tab1, tab2;
tab1 = a.retourner_moi();
tab2 = a.retourner_cpu();
for (int i = 0; i < 6; i++)
{
moi[i] = tab1[i];
cpu[i] = tab2[i];
}
}
//*******************************************************************************************************
//*******************************************************************************************************
int alphabeta(int alpha,int beta,int profondeur)
{ int i=0,x;
awale[] awa = new awale[6];
if(profondeur==0) return(score_cpu - score_moi);
while( (alpha<beta) && (i<6) )
{ if(cpu[i]!=0)
{ awa[i] = new awale();
awa[i].copier(this);
awa[i].cpu_joue(i);
x = alphabeta(-beta,-alpha,profondeur-1) * (-1);
if(x>alpha) {
alpha = x;
if(cpu[i]!=0 && profondeur==4){
this.modif(i);
}
}
}
i++;
} // while
return(alpha);
}
public int lire() throws IOException
{
int c=-1;
System.out.println("lire");
while(c<0)
{c = System.in.read() - 48;}
return c;
}
public static void main(String s[])
{ try
{
awale a = new awale();
int i=20,c;
a.afficher();
while(i>0)
{
c = a.lire();
System.out.println("c = "+c);
a.jouer(c);
a.afficher();
int x = a.alphabeta(-9999,9999,4);
int choix = a.choisi();
System.out.println("choix = "+choix);
a.cpu_joue(choix);
a.afficher();
i--;
}//while
}//try
catch(IOException e) {}
}
}
Y muchas gracias por su ayuda.