Jeu awale en Java

Bonjour tout le monde,
J'ai un projet à réaliser en java, en fait c'est le célébre jeu d'awalé. J'ai commencé par comprendre les algorithmes de recherche et surtout l'algorithme (ALPHA BETA) qui est meilleur que celui du MINMAX. J'ai réaliser ma premiere version du jeu en C seulement pour tester mon algorithme et ça marche trés bien. Mais quand j'ai essayer de le faire en OO en java ça ne marche plus.Vraiment je ne comprends pas parce que c'est le même algorithme. Voila la version en langage 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();
}

*********************************************
*********************************************
*********************************************
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
et celui 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) {}
}

}


Et Merci Beaucoup pour votre aide .