Awale Game in Java

Hello everyone,
I have a project to complete in Java, actually it’s the famous game of Awalé. I started by understanding search algorithms, especially the (ALPHA BETA) algorithm which is better than the MINMAX one. I created my first version of the game in C just to test my algorithm and it works very well. But when I tried to do it in OO in Java, it does not work anymore. I really don't understand because it's the same algorithm. Here is the version in C language:

/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////

#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();
}

*********************************************
*********************************************
*********************************************
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
/////////////////////////////////////////////////////
and this is the Java version:

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) {}
}

}

And thank you very much for your help.