Cependant, après avoir transcrit son algorithme en Java, je rencontre quelques soucis, celle-ci à un comportement assez empathique, j'ai parfois l'impression qu'elle veut toujours perdre, c'est assez ennuyant.
Je suis conscient de certaines subtilité quant à la transcription d'un code C en Java mais ça fait plus de deux semaines que j'y suis. J'ai l'impression d'être complètement coincé et je ne trouve pas l'erreur, mon IA joue toujours les mêmes coups de gauche à droite :
x / x / x / / / /
Par exemple, si je vais prendre la place de la première case en partant de la gauche, elle va prendre celle jute à côté...
ça fait un bout de temps que je m'arrache les cheveux et je suis aujourd'hui pris de court par les deadlines.
Je souhaitais savoir si vous auriez un peu de temps pour m'aider, j'envoie une grille une dimensions à mon IA, la profondeur de l'algorithme min_max ainsi que son symbole.
Donc mon IA traduit cette grille une dimension en une deux dimensions pour appliquer l'algorithme min max, mais aucun résultat concluent.
Voici le code de mon IA :
package model;
import java.util.Random;
public class IA_MinMax implements IA_MinMaxImpl{
// private int max, min;
//private int temp, maxI = 0, maxJ = 0;
private int grilleSize = 3;
private int nb_symbole_aligne_j1 = 0;
private int nb_symbole_aligne_j2 = 0;
private int j1;
private int j2;
private Symbole symboleDuJoueur;
private Boolean IAPlaying = true;
private int[][] grille = new int[3][3];
public IA_MinMax(Symbole symbole){ this.symboleDuJoueur=symbole; }
public Boolean getIAPlaying() {return IAPlaying;}
public void setIAPlaying(Boolean IAPlaying) {
this.IAPlaying = IAPlaying;
}
public Symbole getSymbole() {
return this.symboleDuJoueur;
}
public void setSymbole(Symbole jSymbole) {
this.symboleDuJoueur = jSymbole;
}
public int grille1dTo2d(Case[] grilleTicTacToe, int profondeur, Symbole IAsymbole)
{
for(int i=0, x=0 ; i < 3 ; i++)
{
for(int j=0; j < 3; j++)
{
this.grille[i][j] = convertirGrille(grilleTicTacToe[x], IAsymbole);
x++;
}
}
return IA_Jouer(grille, profondeur);
}
public int[] grille2dTo1d(int[][] grille2d)
{
int[] grille1d = new int[8];
for(int i=0, x=0 ; i < 3 ; i++)
{
for(int j=0; j < 3; j++)
{
grille1d[x]=grille2d[i][j];
x++;
}
}
return grille1d;
}
public int convertirGrille(Case caseTicTac, Symbole IAsymbole)
{
if(caseTicTac.getSymbole() == Symbole.Vide)
{
return 0;
}
if(caseTicTac.getSymbole() == Symbole.Croix)
{
if(IAsymbole == Symbole.Croix)
{
return 1;
}
else
{
return 2;
}
}
if(caseTicTac.getSymbole() == Symbole.Rond)
{
if(IAsymbole == Symbole.Rond)
{
return 1;
}
else
{
return 2;
}
}
return 8888;
}
public int IA_Jouer(int grille[][], int profondeur) {
int max = -10000;
int temp = 0, maxI = 0, maxJ = 0;
for (int i = 0; i < grilleSize; i++) {
for (int j = 0; j < grilleSize; j++) {
//Si la grille est libre
if (grille[i][j] == 0)
{
grille[i][j] = 1;
temp = mini(grille, profondeur-1);
if(temp > max){//(((temp > max) || (temp == max)) && (new Random().nextInt() % 2 == 0)) {
max = temp;
maxI = i;
maxJ = j;
}
grille[i][j] = 0;
}
}
}
grille[maxI][maxJ] = 1;
//Rejeter un oeil ici
return ((maxI*3)+maxJ);
}
public int maxi(int grille[][], int profondeur) {
//Rechercher le maximum des noeuds fils
if (profondeur == 0 || getWinner(grille) != 0) {
return analyseGrille(grille);
}
int max = -10000;
int temp = 0;
for (int i = 0; i < grilleSize; i++) {
for (int j = 0; j < grilleSize; j++) {
if (grille[i][j] == 0)
{
grille[i][j] = 2;
temp = mini(grille, profondeur-1);
if (temp > max){// || ((temp == max) && (new Random().nextInt() % 2 == 0))) {
max = temp;
}
grille[i][j] = 0;
}
}
}
return max;
}
public int mini(int grille[][], int profondeur) {
//Rechercher le minimum des noeuds fils
if (profondeur == 0 || getWinner(grille) != 0) {
return analyseGrille(grille);
}
int min = 10000;
int temp = 0;
for (int i = 0; i < grilleSize; i++) {
for (int j = 0; j < grilleSize; j++) {
if (grille[i][j] == 0) {
grille[i][j] = 1;
temp = maxi(grille, profondeur-1);
//Profondeur -1 en paramètre à maxi car sinon on parcourt l'arbre tout entier
if (temp < min || ((temp == min) && (new Random().nextInt() % 2 == 0))) {
min = temp;
}
grille[i][j] = 0;
}
}
}
return min;
}
public void getEachNbAlignes(int grille[][], int nb_symbole_aligne_j1, int nb_symbole_aligne_j2, int nb_Case_Aligne) { //Nombre de pions alignés pour chacun des joueurs
nb_symbole_aligne_j1 = 0;
nb_symbole_aligne_j2 = 0;
int compteur1 = 0, compteur2 = 0;
//Diagonale descendante
for (int i = 0; i < grilleSize; i++) {
if ((grille[i][i]) == 1) {
compteur1++;
compteur2 = 0;
if (compteur1 == nb_Case_Aligne) {
nb_symbole_aligne_j1++;
}
}
if ((grille[i][i]) == 2) {
compteur2++;
compteur1 = 0;
if (compteur2 == nb_Case_Aligne) {
nb_symbole_aligne_j2++;
}
}
}
//Diagonale montante
compteur1 = 0;
compteur2 = 0;
for (int i = 0; i < grilleSize; i++) {
if ((grille[i][2-i]) == 1) {
compteur1++;
compteur2 = 0;
if (compteur1 == nb_Case_Aligne) {
nb_symbole_aligne_j1++;
}
}
if ((grille[i][2-i]) == 2) {
compteur2++;
compteur1 = 0;
if (compteur2 == nb_Case_Aligne) {
nb_symbole_aligne_j2++;
}
}
}
//En ligne
for(int i=0;i<grilleSize;i++)
{
compteur1 = 0;
compteur2 = 0;
//Horizontalement
for(int j=0;j<grilleSize;j++)
{
if(grille[i][j] == 1)
{
compteur1++;
compteur2 = 0;
if(compteur1 == nb_Case_Aligne)
{
nb_symbole_aligne_j1++;
}
}
else if(grille[i][j] == 2)
{
compteur2++;
compteur1 = 0;
if(compteur2 == nb_Case_Aligne)
{
nb_symbole_aligne_j2++;
}
}
}
compteur1 = 0;
compteur2 = 0;
//Verticalement
for(int j=0;j<grilleSize;j++)
{
if(grille[j][i] == 1)
{
compteur1++;
compteur2 = 0;
if(compteur1 == nb_Case_Aligne)
{
nb_symbole_aligne_j1++;
}
}
else if(grille[j][i] == 2)
{
compteur2++;
compteur1 = 0;
if(compteur2 == nb_Case_Aligne)
{
nb_symbole_aligne_j2++;
}
}
}
}
}
public int analyseGrille(int grille[][]) {
int nb_symbole_sur_grille = 0;
int winner = 0;
//Compte le nombre de symboles sur la grille
for (int i = 0; i < grilleSize; i++) {
for (int j = 0; j < grilleSize; j++) {
if (grille[i][j] != 0) {//Si une grille est occupé par un symbole
nb_symbole_sur_grille++;
}
}
}
if ((winner = getWinner(grille)) != 0) {
if (winner == 1) {
//IA
return 1000 - nb_symbole_sur_grille;
}
if (winner == 2) {
//JOUEUR
return -1000 + nb_symbole_sur_grille;
} else {
return 0;
}
}
getEachNbAlignes(grille, nb_symbole_aligne_j1, nb_symbole_aligne_j2, 2);
return nb_symbole_aligne_j1 - nb_symbole_aligne_j2;
}
public int getWinner(int grille[][]) {
j1=0;
j2=0;
getEachNbAlignes(grille, j1, j2, 3);
if (j1 > 0) {
return 1;
}
if (j2 > 0) {
return 2;
} else {
//Si le jeu n'est pas fini et que personne n'a gagné, on renvoie 0
for (int i = 0; i < grilleSize; i++) {
for (int j = 0; j < grilleSize; j++) {
if (grille[i][j] == 0) {
return 0;
}
}
}
}
return 3;
}
}
Voici un bout de code de la classe Partie, là où j'appelle mon IA :
public void IAGaming(IA_MinMax IA, int profondeur) {
int coupIA = IA.grille1dTo2d(grilleTicTacToe, profondeur, IA.getSymbole());
grilleTicTacToe[coupIA].setSymbole(IA.getSymbole());
}
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
