Puissance 4 + AI

t'es t-il possible d'assigner la position des pions ?
Si oui le code est cassiment le même que celui que je t'es passer tout a l'heure.Pour faire augmenter l'alignement de l'AI il suffit d'assigner la position des pions du tableau par exemple:
|_|_|_|_|_|_|
|_|_|_|_|_|_|
|_|_|_|_|_|_|
|_|_|_|_|_|_|
|_|_|_|_|_|_|
|_|_|_|_|_|_|
|_|_|0|_|_|_|
Là par exemple on a qu'a faire une variable positionPion[6*7/2](maximum , la moitié du nombre de cases du terrain , c'est un peu imagé parce que 6*7/2 tombe pas juste donc il faut que ca change selon la personne qui a commencé la partie)et on assigne comme ca les positions:
|1|2|3|4|5|6|
|7|8|9|10|11|12|
etc..
ensuite tu compares les valeurs pour voir si alignement se fait et ainsi tu détérmine les conditions du code que je t'ai passé précédement.Et ensuite selon le nombre de points d'éxpérience de l'humain que tu lis dans le fichier
tu détermine les conditions a éxaminer en premiéres [(par exemple si il a 0 points d'éxpérience tu lui fait passer d'abord la construction sans but (avec un nombre tiré au hasard)].Tu devrais aussi faire un systéme de partie ainsi dans tel partie on enregistre dans telle fichier , etc..

Je n'est pas très bien compris, et je ne voit pas comment tu veus faire :?

C'est simple tu cré un tableau d'entier(par exemple positionPion) dont chaque case contient :
-0 si il n'y a aucun pion dedans
-1 si il y a un pion a l'humain
-2 si il y a un pion a l'IA

Et voici la correspondance avec ton tableau :
|1 |2 |3 |4 |5 |6 |7 |
|8 |9 |10|11|12|13|14|
|15|16|17|18|19|20|21|
................................
|36|37|38|39|40|41|42|

grâce a cette technique tu peux adapter mon code de tout a l'heure avec ses coordonnées avec ne méthode qui te les donnes

Donc a chque fois que le jouer humain joue, cela met -1 ds le tableau d'entier et qd c'est l'ai c'est -2 dans le tableau d'entier
et par la suite, cela me donne quoi?

Comme ca tu repére les alignements et tu réadapte mon ancien code comme ca :

Code:

---

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

/* la tu fait un fread ou un équivalent quelconque pour lire l'éxpérience correspondant à la partie chargée*/ int i int positionPion[6*7]; //6*7 ou la taille de ton tableau int continuer=1; int nombrePionIA=0; int nombrePionHuman=0; int pionAligneHuman=0; int pionAligneIA=0;   while(continuer); if(pionAligneHuman==4) { HumanGagne(); /* Si 4 pions de l'umain sont alignés alors on appel la fonction HumanGagne qui renvoient par exemple bravo*/ continuer=0; } if(pionAligneIA==4) { IAGagne();//même chose pour l'IA continuer=0; } /*Aprés ces quelques vérifications on appel la fonction JoueurJoue , par exemple , c'est la fonction que tu utilisait dans ton mode sans IA (tu as juste a la réadapter un peu pour le mode un joueur et pour quel renvoie la position du pion qu'a joueur le joueur dans mon cas on va dire que c'est en bas a gauche du tableau ce qui correspond a 36 stocké dans i par exemple*/ JoueurJoue(); /*ensuite on met : positionPion[i] à 1 car c'est l'endroit où l'humain à jouer */ positionPion[i]=1; //ensuite on appel la fonction IA IAjoue(); }

---

Voilà comment je voie les choses , en éspérant que je n'ai pas fait de faute de frappe :oops:
comme ca tu envoie a l'IA un pointeur sur le tableau positionPion pour que l'IA puisse détécter les alignements ennemis , les siens ceux qu'ils doient brisés
et la fonction IAJoue pourrait ressembler a ca :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

int IAJoue(int * ppositionPion[]) { int a=positionPionHuman-1; int IAMustPlay=1; while(IAMustPlay) { /*là tu examine les condtions dans l'ordre que tu veux soit : tu commence par voir si l'IA peux casser l'alignement , ensuite si il peux en créer un et sinon il en commence un soit tu fait dans un autre ordre mais pour mon exemple ca sera cette ordre là*/ if(positionPion[a]==1) { /*alors on casse l'alignement tu appel la fonction à utiliser en cas de cassage d'alignement humain en lui envoyant un pointeur sur le tableau positionPion là j'appel la méthode breakAlignement*/ breakAlignement(pointeurSurPositionPion); } /*tu fait des boucles comme ca pour vérifier les diagonales les côtés le haut le bas pour être sur qu'aucun alignement humain n'est en cours et si c'est le cas tu incrémente la valeur de pionAligneHuman de 1 Ensuite tu vérifie si deux "cases" adjacentes du tableau positionPion on toutes les deux la valeur 2(donc si l'IA a un alignement en cours) pareil dans ce cas tu incrément de 1 la valeur de pionAligneIA*/ } }

---

Je sais que mon code n'est pas trés clair mais je vais l'éxpliquer :
- au début de chaque tour de boucle (while) , on regarde si aucun des deux joueurs(Humain pui IA) n'a 4 pions alignés.
- ensuite - si c'est le cas pour l'humain on appel la fonction HumanGagne ou un truc du genre qui affiche bravo par exemple
- si c'est le cas pour l'IA on appel la fonction IAGagne ou un truc du genre qui affiche GAME OVER par exemple
- si ce n'est pas le cas :
- on appel la fonction joueurJoue par exemple qui fait jouer le joueur comme dans le mode sans IA réadapté pour 1 joueur et qui renvoie la varialbe i ( a savoir l'endroit du tableau où a jouer le joueur ,omme vu précedement numéroté ligne par ligne : |1|2|3|4|5|6| pour la premiére ligne)
ensuite on fait ca :
positionPion[i]=1;
pour dire que le joueur a jouer a cet endroit.
- en ensuite on appel la fonction IAJoue qui recoit un pointeur sur le tableau positionPion et qui avec quelque conditions détécte les alignements de l'humain (dans mon exemple on avait assigné a positionPionHumain i ensuite on assigne a : a ,positionPionHumain - 1 pour vérifier le côté gauche sauf si le pion a été joueur sur le bord gauche du tableau mais quelque conditions devraient suffir pour voir ca , normalement les détéctions d'alignement ne devraient pas te poser de problème .
Et ansi de suite jusqu'a que continuer soit mis a zéro (quand le joueur ou l'IA gagne) ou que le tableau positionPion soit plein , tu fait une boucle du genre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

for(i;i<tailletableau;i++); { int nmbrPlein=0; if(positionPion[i]==0) { continuer=1; } f(positionPion[i]!=0) { nmbrPlein++; } if(nmbrPlein==tailletableau) { continuer=0; } }

---

J'éspére que c'est pas trop incompréhensible :P
Sinon dit le moi

Mais en faite, ce que tu me propose est certainement une AI evolutive, non? tandis que j'aimerais que l'AI ne soit pas evolutive, je pense que c'est trop compliqué, et un peu enervat que a chaque fois que l'on veu jouer, il faut entrainer le pc :oops:

Je le prends comme si c'était pour moi.

Faire jouer l'IA évoloutive (qui a donc 6^36 parties en mémoire, je ne sais pas si c'est possible) contre un algorithme décisionnel "à courte vue" peut permettre de déterminer et d'étudier quels sont les critères statistiques déterminants dans le choix du coup à jouer au regard de la base de donnée de l'algorithme.

De toutes les manières, ce qui touche à l'IA n'est pas un domaine très formel ( en tout cas j'ai jamais eu de cours là dessus). Il est possible qu'un algorithme bien pensé soit supérieur à une analyse statistique de base de donnée.
Dans le cas du puissance 4, l'analyse est assez simple, mais (6x6x6x.....x6x6)=6^36 parties possibles est déjà considérable (je vous laisse imaginer ce que ce serait pour un jeu d'échec. Le nombre de parties possibles est sûrement incalculable, bien que je ne me sois aps non plus interrogé à ce sujet).

Peut être devriez vous réfléchir à un moyen de construire par informatique des parties en éliminant celles qui sont aberrantes d'un point de vue humain.

Encore une fois tout ce que je dis n'est que pure introspection personnelle, et je ne suis pas certain que telle ou telle manière d'aborder les choses soit la meilleure.

Vous pouvez regarder les propositions du début du Topic qui ne semblent pas stupides, mais de toutes les manières, je crois que ce n'est pas une bonne idée d'écrire des lignes de code à la chaîne sans exactement savoir ce que vous allez faire et pourquoi.
Ainsi, prendre un papier et un crayon et réfléchir calmement et sûrement plus un gage de réussite que de directement penser à une quelconque implémentation en C.

De toutes les manières, l'implémentation doit faire appel à une solide représentation structurelle des parties jouées, etc, de façon à ne pas tomber dans un grand programme fragile comme une tour de verre.

Définir des méthodes, des structures pour le stockage, etc est aussi important que d'avoir l'idée, mais c'est l'idée qui doit être à la base du codage et non l'inverse.

Je suis tenté de dire que les algorithmes d'intelligence artificielle, c'est laisser faire le hasard pour rendre la machine bête, et la faire travailler pour qu'elle porte des coups intelligents, mais encore une fois je n'en sais pas grand chose.
Ravi en tout cas d'avoir pu émettre ces suggestions.

En fait, les combats d'AI ça doit très bien exister. Pour étudier le fonctionnement des AI, je crois bien que c'est ce moyen qu'il faut utiliser. C'est certain que de jouer 500 000 partie programmeur vs Machine euhhh. Inutile de s'étendre là dessus.


Sinon l'algorithme du min et du max (voir dans les trois premiers post), c'est à dire attribuer à chaque possibilité de jouer un indice de 'pertinence' du coup joué suivant des critères que vous aurez défini est certainement une bonne façon d'aborder la chose.

Certes un algo min max serait mieu, mais c'est le comment faire qui me pose problèmes, sachant que les explications sur cette algo ne mon frnahcement parru byzar....

Moi j'avais penser, à une focntion permettant de voir si il y a la possibiliter de voir un puissance 4 ( et comment la coder celle la :? ),
une permettant de casser un alignement de 3
une permettan d'établir un puissance4 pour la machine

Mais le tout reste a savoir comment le coder

Dans ce cas tu n'a qu'as faire une IA évolutive avec au début un choix de difficulté qui permet de commencer directement en 999 points d'éxpérience :aie: .
Sinon pour vérifier si un alignement est faisaible , je te conseille vivement d'utiliser un tableau qui cnotient des valeurs différentes selon si c'est un pion a l'IA , un pion au joueur ou si c'est une case vide.
Ensuite pour coder une méthode permettant de casser un alignement de 3 :aie: , il faudrait commencer par détecter où se trouve l'alignement ( par exemple avec un systéme de tableau ) par exemple voilà un exemple de partie ou l'IA doit détécter un alignement :
| | | | | | |
| | | | | | |
| | | | | | |
| | | | | | |
| | | | | | |
|x|x|x| | | |
|o|o|o| | | |
x = IA
o = Humain
Dans ce cas grâce au tableau l'IA détécte qu'un alignement commence et il doit donc trouver où il y a un trou et intervenir.
Mais ce n'est pas facile , je peux te l'assurer je suis en train d'essyer :aie:

Je sais très bien que ce n'est pas facile, sa fait une semaine que j'essaye de comprendre coment le coder avec mon binome de projet et dur dur, on y arrive pas

Est-ce que vous avez la représentation à l'écran en premier lieu ?

Si c'est trop difficile, commencez par les choses bas bas niveau pour vous donner une base de travail.

Si vraiment vous avez envie de coder directement des trucs trop balèzes, je pense que le mieux est de faire d'abord la conception, puis de passer à l'action une fois que vous vous êtes assurés que c'est pratiquable.

Connaissez vous la librairie Libnncurses pour l'affichage à l'écran. Je vous donne un lien sur un projet qui se rapproche un peu de ce que vous faites (un peu).

http://perso.orange.fr/cypris/Autres..._de_la_vie.htm

Citation:

---

Est-ce que vous avez la représentation à l'écran en premier lieu ?

---

J'ai fait un affichage console, en texte

. . . . .
. . . . .
. . . . .
x o x. .

Maintenant vous avez fait en binome une vesion deux joueurs sans IA non ?
Alors pourquoi ne pas la récupérer en tant que méthode a appeller (un peu modifier) lorsque le joueur joue,biensur tu seras obligé de casser un peu le module de code (et les fans de P.O.O te diront ce ne serait pas arriver avec un langage de P.O.O !!!8O :D )mais bon c'est pas grave.
Ensuite quand ca sera au point vous pourrez attaquer la fonction qui gére l'IA.
Enfin c'est comme ca que je ferais a vôtre place mais aprés a vous de voir :P!
Et pour ton IA tu détécte les alignements par tableau ensuite tu vois ton ordre des priorités et tu établis une méthodes de cassage d'alignement qui repére un alignement et avec quelque if et else trouve la facon d'on l'humain pourrait le continuer et joue a l'endroit ou l'humain devrait jouer pour compléter son alignement , a mon avis c'est cette méthode qui demandra le plus de travail :P mais je te donne un exemple :

Code:

---

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

/*on imagine que tu gére la position des pions dans un tableau nommé : positionPion et que pendant les trois tours il a été remplis comme ca : - 1 si l'IA a joué dedans - 2 si l'humain a joué dedans - 0 si personne na joué dans cette case voilà l'état des tableaux : le tableau visiuel : . . . . . . . . . . . . . . . . . . . . . . . . . . . . x.x. . . . . x.o.o.o. . . . et le tableau chiffré : positionPion[1]=0; ........ positionPion[29]=1; positionPion[30]=1; ........ positionPion[36]=1; positionPion[37]=2; positionPion[38]=2; positionPion[39]=2; Voilà et grace a son systéme de condition l'IA détécte l'alignement*/ pionHumanAligne=1; switch(PionActeulHuman) case 0: pionADroite=0; break; case 7: pionAGauche=0; /*Etc.. on vérifie ainsi si le pion actuelle de l'humain n'est pas situé sur les bords droite ou gauche du tableau et aussi si il n'est pas tout en haut ou tout en bas du tableau*/ if(pionADroite!=0)//si il y a une case a droite { if(positionPion[PionActuelHuman+1]==2) { pionHumanAligneH++; } } if(pionAGauche!=0) { if(positionPion[PionActuelHuman-1]==2) { pionHumanAligneH++; } } /*Et ainsi de suite pour les digonales , et tout le reste (attention a bien différencier les PionHumanAligneV (V pour verticale) des autres par exemple D) */ }

---

Ensuite une autre condition utilisant ces données vérifie et cherche où il y a de la place pour stopper l'alignement.C'est comme ca que j'ai fait et pour l'instant ca a l'air de marcher :D .
Mais c'est pas fini et c'était pas facile :P

Maintenant vous avez fait en binome une vesion deux joueurs sans IA non ?
Alors pourquoi ne pas la récupérer en tant que méthode a appeller (un peu modifier) lorsque le joueur joue,biensur tu seras obligé de casser un peu le module de code (et les fans de P.O.O te diront ce ne serait pas arriver avec un langage de P.O.O !!!8O :D )mais bon c'est pas grave.
Ensuite quand ca sera au point vous pourrez attaquer la fonction qui gére l'IA.
Enfin c'est comme ca que je ferais a vôtre place mais aprés a vous de voir :P!
Et pour ton IA tu détécte les alignements par tableau ensuite tu vois ton ordre des priorités et tu établis une méthodes de cassage d'alignement qui repére un alignement et avec quelque if et else trouve la facon d'on l'humain pourrait le continuer et joue a l'endroit ou l'humain devrait jouer pour compléter son alignement , a mon avis c'est cette méthode qui demandra le plus de travail :P mais je te donne un exemple :

Code:

---

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

/*on imagine que tu gére la position des pions dans un tableau nommé : positionPion et que pendant les trois tours il a été remplis comme ca : - 1 si l'IA a joué dedans - 2 si l'humain a joué dedans - 0 si personne na joué dans cette case voilà l'état des tableaux : le tableau visiuel : . . . . . . . . . . . . . . . . . . . . . . . . . . . . x.x. . . . . x.o.o.o. . . . et le tableau chiffré : positionPion[1]=0; ........ positionPion[29]=1; positionPion[30]=1; ........ positionPion[36]=1; positionPion[37]=2; positionPion[38]=2; positionPion[39]=2; Voilà et grace a son systéme de condition l'IA détécte l'alignement*/ pionHumanAligne=1; switch(PionActeulHuman) case 0: pionADroite=0; break; case 7: pionAGauche=0; /*Etc.. on vérifie ainsi si le pion actuelle de l'humain n'est pas situé sur les bords droite ou gauche du tableau et aussi si il n'est pas tout en haut ou tout en bas du tableau*/ if(pionADroite!=0)//si il y a une case a droite { if(positionPion[PionActuelHuman+1]==2) { pionHumanAligneH++; } } if(pionAGauche!=0) { if(positionPion[PionActuelHuman-1]==2) { pionHumanAligneH++; } } /*Et ainsi de suite pour les digonales , et tout le reste (attention a bien différencier les PionHumanAligneV (V pour verticale) des autres par exemple D) */ }

---

Ensuite une autre condition utilisant ces données vérifie et cherche où il y a de la place pour stopper l'alignement.C'est comme ca que j'ai fait et pour l'instant ca a l'air de marcher :D .
Mais c'est pas fini et c'était pas facile :P

Je suis daccord pour le systeme de point en ce qui concerne les pions de l'humain, AI ou vide... (pas trop difficile a faire)
Par contre, en ce qui concerne la localisation de pions alignés je ne voi pas pas... Pourquoi pas une fonction qui parcours tout le tableau en recherchant 4cases côtes à côtes donc la somme des 4cases vaut 3... Mais il faut que cette fonction parcours horizontalement, verticalement et diagolanelement ...:?

C'est une idée dés qu'une case du tableau est de type 1 par exemple on vérifie si la case d'a côté en faisant :

Code:

---

1 2 3 4 5

if(positionPion[pionRepéré-1]==1) { pionAligne++; }

---

comme ca on parcours le tableau et en imaginant que le pion détécté soit en 32 et que la case d'avant donc sa position-1 soit de valeur 1 alors un pion est aligné mais a chaque tour il faut faire un switch pour repérer les "bords" du tableau par exmple si le pion est tout a gauche de la deuxiéme ligne et qu'au-dessus tout a droite il y a un pion alors il sera compté en tant que pion aligné sans ce switch protecteur qui agit selon la valeur parcouru en informant la fonction des bords du tableau de facon a ne pas annoncé une victoire dans ce cas là par exemple :
. . . . x. x.
x.x.o.x.x.x

oulalala, voila comment je psoe deja un pion :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

int placer_pion(char grille[nb_lig][nb_col], int col, char pion){ int i=0;   /* Boucle démarrant du bas du plateau de jeu ([nb_lig-1]) et monte dans la colonne   jusqu'à possibilité de placement, sinon, colonne invalide */ for (i=nb_lig-1; i>=0; i--){   /* Si '.' alors on remplace par le pion, sinon on ne fait rien */ if (grille[i][col]=='.'){ grille[i][col]=pion; return i; }   } }

---

Ok d'accord c'est comme ca que tu détécte les endroits vide ,et bien tu n'a qu'a faire pareil pour l'IA ,ce sera de cette facon qu'une fois qu'il aura détécté l'alignement il cherchera un pion a l'humain qui serait succeptible de rejoindre les autres et dans ce cas il mettra son pion

Je ne t'ai pas très bien compris sur ton dernier message..
Comment adapter ce code pour l'AI ? 8O

Tu peux adapter ce code pour l'IA quand il doit jouer de maniére aléatoire :mouarf: .C'est sur que quand il doit casser un alignement ca ne convient pas.:)