Discussion :

[Boss38400]

Bonsoir
pour mon projet "Kalah" je dois crée une I.A .qui joue contre un utilisateur

je dois construire un Arbre avec une règle. essayer de maximiser la différence entre le score de l'IA et le score du joueur".(chaque décision de l'ia dois maximiser la différence du score) afin de savoir qu'elle case l'IA va jouer pour gagné .

la profondeur de l'arbre va déterminer la difficulté
le jeux du Kalah est composé de deux plateau :

un plateau de 6 Case du Joueur
un plateau de 6 Case de L'IA
une réserve de L'IA
une réserve du joueur
sa peut etre présenté comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
   2   1   2   6  1  2
6                         5
   2   6   4   2   7   3

quand c'est le tour d'un joueur . il choisie une case ou il prends les graines et il les distribue dans le sens anti-horaire .sauf dans la réserve de l'adversaire
2 règle de jeux :
si la dernier graine tombe dans une case vide : l'adversaire il prends les valeur de la case en face de l'adversaire
si la dernier graine tombe dans la réserve soit le score le joueur a le droit de rejouer


j'ai pas mal avancé il me reste juste a construire l'IA
donc ma classe Noeud me cause problème. je fais des teste que sur cette classe
C'est plus tôt la récursivité qui me cause problème .
Merci d'avance

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class NoeudTest {
 
	/**
         * @param args
         */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int tabr[] = { 3, 0, 4, 2, 6, 4 };
		int tab[] = { 3, 6, 0, 7, 2, 5 };
		String joueur = "ia";
		int prof=2;
		int scoreI=10;
		int scoreH=12;
	new Noeud(tabr,tab,scoreI,scoreH,prof,joueur);
/*3 5 4 2 6 4 10 3 2 1 7 2 5*/
	/*3 2 1 7 2 5 12 3 5 4 2 6 4*/
	}
 
}

La classe Noeuds

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
import java.util.ArrayList;
 
 
public class Noeud {
int []tabia;
int []tabhm;
int scoreia,scorehm,profendeur;
String tour;
Noeud(){
 
}
Noeud(int []tabia,int []tabhm,int scoreia,int scorehm,int profendeur,String tour){
	super();
	this.tabhm=tabhm;
	this.tabia=tabia;
	this.scorehm=scorehm;
	this.scoreia=scoreia;
	this.profendeur=profendeur;
	this.tour=tour;
	ArrayList <Integer>parcour = new ArrayList<Integer>();
	/**********************************************
        ******* Construction Liste de parcour *******
        *********************************************/
	if (this.tour.equals("hm")){
		for (int hm : this.tabhm){
			int i = new Integer(hm);
			parcour.add(i);
		}
		int i = new Integer(this.scorehm);
		parcour.add(i);
		for (int ia : this.tabia){
			int j = new Integer(ia);
			parcour.add(j);
		}
	}
	else {
		for (int ia : this.tabia){
			int i = new Integer(ia);
			parcour.add(i);
			}
		int i = new Integer(this.scoreia);
		parcour.add(i);
		for (int hm : this.tabhm){
			int j = new Integer(hm);
			parcour.add(j);
		}
 
		}
	/******************** Fin List ************************/
	for (int it : parcour)System.out.print(" "+it);
	System.out.println(" ");
 
	/*****************************************************/
	/****************** Génération des fils *************/
	/***************************************************/
	for(int it=0;it<6;it++){
		/********** verifie Fin ********/
		int sommeFin=0;
		for(int tmp=0;tmp<6;tmp++)sommeFin=sommeFin+parcour.get(tmp);
		/*******************************/
		/*****Verifie Case n'est pas vide && Fin profendeur && Fin du jeu .Sinon Noeud Vide*******/
		if(parcour.get(it)==0 || sommeFin==0 || this.profendeur==-1){
			Noeud noeudFils=new Noeud();
		}
		else {
			/************************************************************************************/
			/**************Copie de la liste pour ne pas modifier les valeurs des fils*********/
			ArrayList <Integer> parcourCopie= new ArrayList<Integer>();
			for(int i=0;i<parcour.size();i++){
				int loc=new Integer(parcour.get(i));
				parcourCopie.add(loc);}
				/***************************************************************************/
 
				/***********************************************************************
                                *****************Distribution des grains ******************************/
				int graineTmp=new Integer(parcourCopie.get(it));
				parcourCopie.set(it,0);
				int caseDepart=new Integer(it+1);
				while(graineTmp>0){
					for(int itLoc=caseDepart;itLoc<parcourCopie.size();itLoc++){
						if(graineTmp>0){
						int newValeur=new Integer((parcourCopie.get(itLoc)+1));
						parcourCopie.set(itLoc,newValeur);
						graineTmp--;
						}
					}
					caseDepart=0;	
				}
				/**************************************************************************/
				/***********Récursiviter ***************************************/
 
				for(int locP=0;locP<parcourCopie.size();locP++)System.out.print("  "+parcourCopie.get(locP));
				System.out.println("");
				/************************************************************/
				/**************Reconstrution des plateaux *****************/
				if (this.tour.equals("hm")){
					int newTabhm[]=new int [6];
					int newTabia[]=new int [6];
					for(int locIn=0;locIn<6;locIn++)newTabhm[locIn]=parcourCopie.get(locIn);
					int scoreHM=parcourCopie.get(6);
					for(int locIn=7;locIn<parcourCopie.size()-1;locIn++)newTabia[locIn]=parcourCopie.get(locIn);
					int scoreIA=parcourCopie.get((parcourCopie.size()-1));
					new Noeud(newTabia,newTabhm,scoreIA,scoreHM,this.profendeur--,tour);
				}
				else{
					int newTabhm[]=new int [6];
					int newTabia[]=new int [6];
					for(int locIn=0;locIn<6;locIn++)newTabia[locIn]=parcourCopie.get(locIn);
					int scoreIA=parcourCopie.get(6);
					for(int locIn=7;locIn<parcourCopie.size()-1;locIn++)newTabhm[locIn]=parcourCopie.get(locIn);
					int scoreHM=parcourCopie.get((parcourCopie.size()-1));
					new Noeud(newTabia,newTabhm,scoreIA,scoreHM,this.profendeur--,tour);
				}
 
			}
		}
	/**********profendeur doit reduire*********************/
//	this.profendeur--;
	}
	}
 
 
 
 
 
 
 
 
 
 
//	for (int itCopie : parcourCopie)System.out.print(" "+itCopie);
//	System.out.println(" ");
	/**************************************************************************
         * 
         *      System.out.println("Les Graines a distribuer (graineTmp): "+graineTmp);
         * 
         * System.out.println("Case départ : "+caseDepart);
         * 
        for (int itCopie : parcourCopie)System.out.print(" "+itCopie);
        System.out.println(" ");*/

[michon]

Quel est le problème ?
Ou coince tu ?

Pour la lisibilité de ton code, à la fois pour nous mais surtout pour toi, je te conseillerai de faire plus de méthodes, et d'éviter la duplication de code.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
if(){
    methode1();
}
else{
    methode2();
}
...

dans ce genre... car la honnêtement, je me perd dans tes enchainements de boucles.

[Boss38400]

j'essaye de faire tourner la Classe Nœuds sans traitement particulier
juste un system.out.println

mais j'ai pas tous les nœuds

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
import java.util.ArrayList;
 
public class Noeuds {
	static ArrayList<Noeuds> listN = new ArrayList<Noeuds>();
	static int profondeur;
	int tabr[];
	int tab[];
	String joueur;
	int prof;
	int scoreI;
	int scoreH;
 
	Noeuds() {
		System.out.println("Noeuds sans parametre "+prof);
		listN.add(this);
	}
 
	Noeuds(int tabr[], int tab[], String joueur, int prof, int scoreI,
			int scoreH) {
		this.prof = prof;
		this.tabr = tabr;
		this.tab = tab;
		this.joueur = joueur;
		this.prof = prof;
		this.scoreI = scoreI;
		this.scoreH = scoreH;
		System.out.println("Noeuds avec parametre "+prof);
		listN.add(this);
		constructionArbre(this.prof); 
	}
 
	void constructionArbre(int profendeur) {
if (profondeur>0){
		for (Noeuds s : listN) {
			if (s.getProfondeur() ==Noeuds.getProfondeur()-1){
				Noeuds tmp =new Noeuds(s.getTabr(), s.getTab(),s.getJoueur(),this.profondeur--,s.getScoreI(),s.getScoreH());
				listN.add(tmp);
				;
			}
			else{
				Noeuds tmp=new Noeuds();
				listN.add(tmp);
				}
 
		}
 
	}
	}
 
	public int[] getTabr() {
		return tabr;
	}
 
	public void setTabr(int[] tabr) {
		this.tabr = tabr;
	}
 
	public int[] getTab() {
		return tab;
	}
 
	public void setTab(int[] tab) {
		this.tab = tab;
	}
 
	public String getJoueur() {
		return joueur;
	}
 
	public void setJoueur(String joueur) {
		this.joueur = joueur;
	}
 
	public int getScoreI() {
		return scoreI;
	}
 
	public void setScoreI(int scoreI) {
		this.scoreI = scoreI;
	}
 
	public int getScoreH() {
		return scoreH;
	}
 
	public void setScoreH(int scoreH) {
		this.scoreH = scoreH;
	}
 
	public static int getProfondeur() {
		return profondeur;
	}
 
	public static void setProfondeur(int profondeur) {
		Noeuds.profondeur = profondeur;
	}
 
}

Classe NoeudTest

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.ArrayList;
 
 
public class NoeudTest {
 
	/**
         * @param args
         */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int tabr[] = { 3, 0, 4, 2, 6, 4 };
		int tab[] = { 3, 6, 0, 7, 2, 5 };
		String joueur = "ia";
		int prof=2;
		int scoreI=10;
		int scoreH=12;
	//Noeud n=new Noeud(new Noeud(),tabr,tab,scoreI,scoreH,prof,joueur);
	//Noeuds p = new Noeuds(5,2);
	new Noeuds(tabr,tab, joueur, prof, scoreI,scoreH);
 
/*3 5 4 2 6 4 10 3 2 1 7 2 5*/
	/*3 2 1 7 2 5 12 3 5 4 2 6 4*/
	}
 
}

[Boss38400]

Bonjour j'ai pu réaliser une partie de l'arbre grâce a ce lien
il me faut du temps encore mais j'ai pu avancer
http://books.google.fr/books?id=VzPe...epage&q&f=true

[michon]

heureux pour toi que ca avance

Mais personnelement, j'ai toujours pas compris la règle du jeux