JEU D'ÉCHECS DE THYMULUS

Commentaire de Pamaury le 24/10/2004 08:24:20

pas mal du tout mais il y a quelques trucs pénibles : quand on sélectionne un pion, on est obligé de jouer avec lui et on peux pas changer la sélection .
Sinon, je trouve qu'il y a bcp de variables globales, je sais pas si elle servent toutes mais çà fait un paquet .

Commentaire de Pamaury le 24/10/2004 09:54:01

rectification:
il me semble que c'est plutôt pièce posée pièce jouée mais si tu la garde en main sans la poser, ce n'est pas jouer .

Commentaire de Kirua le 24/10/2004 13:35:01

j'ai eu du mal, mais j'ai réussi en jouant tout seul à me mettre échec et mat, je dois être super fort pour mettre autant de temps :D c'est plutôt bien réalisé, bravo :)

Commentaire de coucou747 le 25/10/2004 11:02:53

aussi, on doit taper sur le crono avec la main qui a effectué le déplacement, puis noter tout les coups si on ets en longue et pas poussin...

Commentaire de gemx le 27/10/2004 00:21:18

si je pouvais avoir plus de remarques/suggestions constructives>> je vais essayer de faire court  :
De toutes les vairiables globales que tu as utilisé, je pense qu'il n'y en a que quelques une d'utiles :
- char echiquier[8][8] et encore c pas tres propre ... moi à ta place j'aurais utilisé un int echiquier [8][8] avec des valeur type 1 pour roi blanc, 2 pour roi noir etc ... et 0 pour case vide. (po besoin d'utiliser des lettres ça prend trop de place ... surtout si tu veut faire plus tard une IA ... car dans ce k là tu multiplie les tableaux !)
- Un truc con pour connaitre la couleur de la case : tu additionne le X et e Y de ton tableau (int echiquier[X][Y])
si le chifre est paire, donc divisble par 2 sans virgule, la case est blanche et inversement ...
Ensuite, j'ai po annalyser tt ton code, mais toutes les donner type roque, connaitre le joueur, echec et mat ! vire les met les dans des fonctions ! par exemple si y'a eu un roque, n'appel plus la fonction pour savoir si il ya eu le roque etc ...
Bref les seul truc valable : c ton echiquier et encore ... et tout ce qui concerne t "PAINTSTRUCT HINSTANCE HBITMAP HDC" je suis pas assez bon en prog API pour dir si c'est necessaire ou pas, mais franchement je ne suis pas sur.
Pourquoi je te fais chier avec les vairiable global ? Tout simplement parceque elle sont allouer dans la RAM de ton ordi pendant TOUTE la duré du programme ! Certe, t'en as pas beaucoup ici, mais quand tu bossera sur des grosses appli, tu sera dégouter de voir qu'elle utilise 60% de la RAM !
Quelques règles que tu n'as pas utiliser (enfin je ne crois pas) :
-regles des 50 coup, prise en passant etc ...
Voila j'espere que j'ai été explicite !
Sinon je te félicite ! Continu ! moi j'adore la programmation d'échecs! et j'aimerais en voire encore plus !!!!!
Bon courage !

Commentaire de Pamaury le 27/10/2004 09:01:52

Est-ce que tu as mis PAINTSTRUCT  en global ? Si oui mets-le dans la fonction de dessin et redessine que ce qui est nécessaire(pas toujours facile avec l'API Windows que je trouve nul pour le dessin mais excellente pour le reste) . Et c'est sur que autant de var globales c'est pas génial .

Commentaire de gemx le 27/10/2004 12:24:21

En réponse a coucou747 :
Si tu utilise l'algo min-max et alpha-bêta, tu va plus loin qu'un coup de profondeur ... au moins 3 ... Je rappel qu'un coup est composé de deux demi coup (un coup blanc et un coup noir). Sachant que pour le premier demi coup jouer, il ya 20 posibilité donc 64*20=1280 octets, et que ça augmente de manière exponentiel pour le reste... Il existe d'autre maniere tel que les structures variable etc, mais je suis pas assez calé sur le sujet...
néanmoins tu as raison sur un point : un tableau de char en 8*8 prend moin de place qu'un tableau de int en 8*8 (64octets contre 128). Cependant vu le nombre de compartaison qu'il devra faire, il me semble plus judicieux de le faire avec des entier plutot que des char (plus rapide au traitement). Voil pourquoi je lui conseiller ça!
En ce qui concerne la gestion de la mémoir, je suis d'accord avec toi! Je n'ai jamais dit le contraire. Je lui ai juste dit qu'il vaudrait mieux mettre ça en variable local plutot qu'en globale. Surtout si il fait une IA plutard ! ça bouffe bcp de ressource alors c pas la peine de le le reservé pour toute la duré du programme ...
Voila !

Commentaire de Kirua le 27/10/2004 15:22:21

au premir coup tu peux aussi bouger les chevaux ;)

Commentaire de coucou747 le 27/10/2004 16:07:33

pas chevaux cavaliers, sinon, un cheva qui prends une dame,  ça fait un peu spé... Un cavalier, ça rapelerais plus lancelot...

Enfin les gouts et les couleurs...

Commentaire de Tellmarch le 28/10/2004 18:04:40

gemx, tu es sur qu'il est plus long de travailler avec des char? je croyais que c'était juste des entiers sur 8 bits, donc plus économes en mémoire et aussi rapide...
Au fait tu dit que int[8][8] prendrais 128 octets, mais c'est plutot 256 en général voire 512...

Commentaire de Pamaury le 28/10/2004 19:37:30

je ne suis pas d'accord car si tu as deja fait de l'assembleur, on peut directement accédé à la partie basse(8-bit) d'un registre et il existe des instruction en général pour chaque type(8-bit,16-bit,32-bit voir 64-bit), donc le char est aussi rapide que les int et en plus il y économie de mémoire :
char tab[8][8]=64 octets(8*8*1)
int tab[8][8]=256 octets(8*8*4)
Donc niveau rapidité d'exécution çà ne change rien . Donc je te conseille les char car çà bouffera moins de mémoire .

Commentaire de Pamaury le 29/10/2004 08:55:32

ouais intéressant, mais bon pour une différence si petite, je pense que les char sont un bon choix, parce que si tu fais des tableau d'int çà va bouffer ta mémoire . En plus l'IA utilisera probablement un grand nombre de tableau donc les char c'est mieux à mon avis .

Commentaire de Pamaury le 29/10/2004 12:45:42

AHHHHHHHH
int=32-bit
Donc un int=4*char alors que l'utilité d'un char ici est moindre donc tu avec des char tu peux faire une ia plus performante car tu as plus de mémoire dispo . Pour la vitesse vu la différence entre les deux à mon avis ici la priorité c'est les char puis la vitesse . Je vais faire des test plus appronfondies sur la différence de vitesse

Commentaire de coucou747 le 29/10/2004 12:57:11

comme dans une IA la vitesse est expotentielle, il faut apliquer les principes du précalculs (sans faire de précalculs ^^) c'ets a dire privilégier la vitesse plutot que la mémoire...

Commentaire de Tellmarch le 29/10/2004 13:58:13

Sinon kirua ton code me renvoie 0 ms pour les deux, c'est dur à comparer :)

Commentaire de coucou747 le 29/10/2004 14:18:01

Donc char vaut mieux ici sauf si tu ne crains pas d'utiliser de la mémoire

bien refaisons mes calculs avec 32 bits pur un int :
64*32*5*2=2048*10 = 20480
bon, ça fait 20 ko de ram pour 5 tours... je ne penses pas que cela soit énorme... Bon évidement il faut ajouter ceraines choses tels que la liste des coups si on fait un AB, mais certains seront automatiquement ignorés (principe de l'AB) Enfin voila, c'est sur que 100 ms c'est négligeable, mais 20ko de nos jours aussi

Commentaire de Kirua le 29/10/2004 17:58:59

coucou, la vitesse est expoNentielle, pas expoTentielle, ça n'existe pas.

si tu as 0ms, c'est pê que ton compilo détecte que le programme ne sert à rien et baque les opérations... j'ai compilé avec GCC 3.2 version MingW

la taille des int dépend bien de la machine, ce n'est pas 4 * char, en fait, ce n'est pas standardisé. mais sous Win32 en règle générale on a ça:

char = 8 bits
short int = 16 bits
(long) int =  32 bits (le long est sous entendu)
long long int = 64 bits

float = 32 bits
double = 64 bits
long double = 80 bits (sûr ça ?)

Commentaire de Kirua le 29/10/2004 19:11:16

vala, pour le long double j'étais pas certain. mais il me semble que j'avais vu ça sur la MSDN en fait ... ça dépend pê des vesion de VC.

Commentaire de BruNews le 29/10/2004 19:30:09 administrateur CS

ok que char est toujours 1 byte, donc c'est une taille fixe.

Commentaire de Pamaury le 29/10/2004 20:07:08

Ben quand on compile un prog, si int=4 octets quand on compile, alors int=4 octets quand on l'exécute .
Ensuite, pour 'add' par exemple,
les copilo(asm) regarde les paramètre et compare avec ceux recevable(car toutes instruction ne peut pas prendre tous les paramètre) et (là je suis pas sur) mais un 'add,ax,bx' ne sera pas codé de la même façon que
'add eax,ebx' donc si tu compile en 32-bit alors sur toutes le plateforme il s'exécuetra comme s'il était en 32-bit(même si c'est une plateforme 16-bit => erreur opcode inconnu) . Ca ne peut pas changer à l'exécution, c'est défini à la compilation .
Pour le 0 ms c'est parce que le compteur est imprécis ou alors qu'il y a trop peut d'opération à exécuter(passé les 1 GHertz, on approche du 1 Milliard d'instruction par sec voir plus donc évidemment c'est pas de l'ordre de la ms s'il y a une trentaine d'opération !) . A mon avis il vaut mieux utiliser les compteur de précision dispo sur les processeur actuel(ou Windows : QueryPerformanceCounter) .
Pour les test il faut les faire sur des durée longue(moi je fais sur environ12~20 sec) .
Pour ce qui est de la taille d'un octet j'ai des doutes qu'elle soit variable(ou alors pour des choses très particulière, à la limite pour les connections où elle utiliserfaire 9-bit pour la parité(puis retranscrit en 8-bit sans parité) mais sinon je vois pas) . Un petit exemple ???

Commentaire de Pamaury le 29/10/2004 20:35:04

sur mon ordi, le résolution du compteur de mon ordi(QueryPerformanceFrequency et QyeryPerformanceCounter) est de:
3'579'545 coups par seconde  !!!!!!!!
alors que celle de clock() c'est à ma connaissance de environ
54 coups par seconde !!!!!!!
donc tu imagine la précision
attention c'est quoi 10^18 opération ?? C'est des addition ?
Ensuite pour la taille d'un octets si elle fait pas 8-bit çà pose des pb car les processeur utilise le 8-bit , les mémoire idem(toutes les méoires) donc c'est limité . Je pense que le seul exemple que je connais c'est celui des connection :
Dans la connection i2C, pour transmettre un octets on peut ou non ajouter un 9-ième bit pour vérifier la parité mais on ne peut pas l'utiliser cette octets à part refaire tout le hardware !!!!!!!!!!!

Commentaire de Pamaury le 29/10/2004 21:14:42

autre test sur 1200 boucles faite 15 fois dont on prend les temps avec clock et PerformanceCounter à chaque fois(15 fois donc)
+----------------------------+--------+
| clock:                           |      0  |
| Performance Counter: |      0  |
+----------------------------+--------+
| clock:                           |      0  |
| Performance Counter: |      0  |
+----------------------------+--------+
| clock:                           |      0  |
| Performance Counter: |      0  |
+----------------------------+--------+
| clock:                           |      0  |
| Performance Counter: |      0  |
+----------------------------+--------+
| clock:                           |      0  |
| Performance Counter: |      1  |
+----------------------------+--------+
| clock:                           |      0  |
| Performance Counter: |      1  |
+----------------------------+--------+
| clock:                           |      0  |
| Performance Counter: |      1  |
+----------------------------+--------+
| clock:                           |      0  |
| Performance Counter: |      2  |
+----------------------------+--------+
| clock:                           |      0  |
| Performance Counter: |      3  |
+----------------------------+--------+
| clock:                           |      0  |
| Performance Counter: |      4  |
+----------------------------+--------+
| clock:                           |      0  |
| Performance Counter: |      5  |
+----------------------------+--------+
| clock:                           |      0  |
| Performance Counter: |      6  |
+----------------------------+--------+
| clock:                           |      0  |
| Performance Counter: |      7  |
+----------------------------+--------+
| clock:                           |     15 |
| Performance Counter: |      9  |
+----------------------------+--------+
| clock:                           |     15 |
| Performance Counter: |     10 |
+----------------------------+--------+
Je crois que çà suffit pour vous disuader d'utiliser clock un maximum ^^

Commentaire de Pamaury le 29/10/2004 21:21:31

ben çà c'est la freq virtuel ce test montre que c'est faut au moins sur mon ordi . En fait j'ai continuer le test sur 1 sec et clock fait un coup toutes les 15 ms environ et encore c'est aléatoire . Je sais pas si quelqu'un veut faire ce test je fournis le code .

Commentaire de coucou747 le 31/10/2004 15:15:20

plus rapide, je ne sais pas, car on ne saurais pas si ne case est inocupée ou pas, pour la fonction arbitre, je ne suis pas sur que le gain de temps serait conséquent...

Sinon, pour la mémoire, il y a 16 pièces par équipes, donc 32 pièces,  au lieu de 64 cases, donc que l'on utilises des int ou des char, on divises par deux la mémoire utilisée, mais je dois te demander coment tu assures les promotions... ça t'obliges a faire un pointeur pour chaque type de pièce et d'ajouter le nombre de pices de ce types qui jouent... Soit 12 autres variables... Cela comliquerais les choses je penses plutot que de les simifier...

Commentaire de coucou747 le 31/10/2004 16:11:13

", il suffit de déplacer une pièce dans un tableau étant stocké en global." => pour un minimax, la fonction liste tt les ocups, joue puis se rapelle elle même, donc, le tableau stoqué en global sufirait, mais le truc c'est que l'on devrait, dans ce cas jouer, puis après le retour de fonction enlever le coup joué... (dans un algo aussi long a exécuter, toujours privilègier la vitesse a la mémoire...)

Commentaire de coucou747 le 31/10/2004 19:00:51

t'as pas vraiment compris ce aue je voulais dire...

si tu mets un tableau global, pour un minimax, tu seras obligé de le jouer normalement, et avant le retour de fonction le jouer à l'envers (anuler le coup)... deux fois au lieu d'une seule...

non, mettre une variable pas pièce, ça parait interessant, mais je ne suis pas convaincu...

Franchement, avec un tableau, ton ia ressemble à ça :

int ab(unsigned char couleur, int profondeur, jeu situation){
signed int long bestscore=MINSCORE, score=0;
signed char coups[NOMBREMAXDECOUPS], i, a,  nextcoup=-1;
jeu situation2;
profondeur--;
couleur++;
if (couleur==3){
couleur=1;
bestscore=MAXSCORE;
}
if (profondeur==0){
return (evaluation(situation));
}else{
for (i=0;i<NOMBREMAXDECOUPS;i++){
nextcoup=choisisunnouveaucoup(nextcoup, situation);
coups[i]=nextcoup;
if (nextcoup==-1){
i=8;
}else{
situation2=joue( nextcoup, situation, couleur);
a=etat(situation2.plateau);
if (a==1){
return MINSCORE;
}else if (a==2){
return MAXSCORE;
}
}
}
i=-1;
while (1){
i++;
if (coups[i]==-1 || i>NOMBREMAXDECOUPS){
break;
}else{
situation2=joue( coups[i], situation, couleur);
if (etat(situation2.plateau)!=0){
score= evaluation(situation2);
}else{
score=ab(couleur, profondeur, situation2);
}
if ( couleur == 1 && score < bestscore ){
bestscore=score;
}
if ( couleur == 2 && score > bestscore ){
bestscore=score;
}
}
}
}
return bestscore;
}
globalement avec un minimax classique, ça devrait donner ça, évidement il faut une fonction evaluate, et une liste des coups (et un lanceur car la, il ne renvoi pas le coup mais seulement le meilleur score...) une structure jeu (de votre choix, soi 64 cases, soi des pièces, ici cela ne changes rien) Les coups sont ici des types de bases, aux échecs, il y a au max 16*64 possibilitées (je comptes large, la je fait come si chaque pièce pouvait aller sur chaques cases) donc, 1024 possibilitées, évidement, ça fait pas mal, donc, il faut pas trop abuser sur la foncion d'évaluation, et tout optimiser (cet algo ne l'est probablement pas...)

Si on mets le tableau en globale, il faut alors mettre après chaque retour de fonction, un apel à une fonction qui aura pour paramètre le dèrnier coup joué, et qui "nétoira" ce dèrnier coup (genre historoique) mais je penses que la vitesse s'en resentirais...

Commentaire de coucou747 le 01/11/2004 00:05:09

explique comment faire mieux stp, je ne comprends pas...

Commentaire de coucou747 le 01/11/2004 00:09:45

if (etat(situation2.plateau)!=0){
score= evaluation(situation2);
}else{

t'as ça qui ets en trop mais je ne vois rien d'autres...

Commentaire de coucou747 le 01/11/2004 11:56:27

je ne comprends toujours pas mon erreur..

Commentaire de foxbowrnb le 12/01/2007 15:58:21

dans ton jeu on peut se mettre (le roi) volotairement en situation d'échec, alors que c'est interdit.

sinon bravo