Mois : Août Sujet : Révisions du cours C – algorithmique – IA

Salut à tous et à... toutes ?

zTarot

L'exercice du mois portera sur le Tarot Africain, jeu de cartes s'apparentant au Bridge et n'ayant comme rapport direct avec le Tarot que ses atouts ainsi que l'excuse, une sorte de joker. Il se peut que vous connaissiez ce jeu sous le nom de Jeu de l'Atout, ou encore Whist 22. Don't worry, savoir jouer au Tarot n'est pas un prérequis; en effet, les règles et les stratégies du jeu que je vous propose ne sont pas du tout les mêmes. Étant donné qu'il existe plusieurs sous-variantes de ce jeu, je vais vous présenter la mienne, celle que j'ai le plus rencontrée ces dernières années :

Le jeu se joue traditionnellement à 4 joueurs, mais les règles peuvent être adaptées pour jouer à 3 ou à 5.

Le jeu se compose de 21 atouts et l'excuse, soit 22 cartes. Pour ceux qui l'ignorent, les atouts sont des cartes numérotées de 1 à 21; et le plus faible, le 1, est communément appelé le petit.

Le principe est simple : parier sur le nombre de plis que vous pensez gagner, et vous vous efforcez de réaliser ce pari, sous peine de perdre des vies.

Le distributeur donne 5 cartes à chaque joueur en commençant par celui qui est à sa droite, et ce, dans le sens inverse des aiguilles d'une montre. La première personne à jouer est la personne à la droite de celui qui distribue. Lors de la partie suivante, ce sera à son tour de distribuer. Les cartes restantes sont mises de côté, faces cachées.

Chaque joueur annonce le nombre de plis qu'il pense faire. Il est possible d'annoncer zéro pli. C'est d'abord au tour de celui qui est à droite du distributeur de parler, c'est ensuite au joueur encore à sa droite, et ainsi de suite jusqu'au dernier, celui qui a distribué les cartes. Celui-ci a l'avantage d'avoir une assez bonne idée du jeu de chacun, et aura la chance de jouer après tout le monde. Afin de ne pas trop lui faciliter la tâche, une petite règle existe afin de le pénaliser. En effet, le nombre de plis pariés au total doit être différent d'un multiple du nombre de cartes en main. Un petit exemple pour illustrer cette idée : le premier joueur pense qu'il est capable de remporter 2 plis (sur 5), le second 1, et le troisième 1 aussi; cela fait 4 plis annoncés au total : le dernier ne pourra à parier 1. Encore une fois, seul le dernier joueur, le distributeur, est embêté par cette règle, les autres joueurs n'ont pas à s'en soucier.

Le jeu commence. Chaque joueur à 13 vies (13 pour le nombre cartes différentes dans un jeu de 52 cartes normales : 2 − 3− 4 − 5 − 6 − 7 − 8 − 9 − 10 − valet − dame − roi − as). Le premier joueur pose une carte, puis le second, etc. Dans la mesure du possible, il faut monter à l'atout, c.a.d. qu'il faut jouer une carte plus forte que la meilleure qui est déjà posée sur la table. Si un joueur ne peut pas jouer plus haut, il peut poser n'importe quelle carte de sa main. L'excuse est une carte un peu spéciale, en effet, le joueur qui la joue peut choisir de gagner ou de perdre (dans l'optique de respecter son quota de plis), en d'autres termes, l'excuse peut devenir la meilleure ou la moins bonne carte du jeu. Le gagnant d'un pli est celui qui à jouer la carte la plus forte. À la fin de chaque tour, les joueurs n'ayant pas réussi leurs paris perdent un nombre de vies égal à l'écart entre le nombre de plis annoncé et le nombre de plis remporté. Bien évidemment, en respectant son quota de plis, aucune vie n'est perdue.

Lors du deuxième tour, le joueur à la droite du premier distributeur devient celui qui distribue; et le nombre de cartes distribuées n'est plus que de 4. Et ainsi de suite jusqu'à qu'il n'y ait plus qu'une seule carte à distribuer. Ce tour se déroule d'une manière sensiblement différente : on distribue une carte à chaque joueur qu'ils posent sur leur front, sans la regarder. Comme à l'accoutumé, c'est le joueur à la droite de celui qui distribue qui parle en premier. Ce dernier annonce donc s'il penser gagner ou perdre, puis c'est aux autres de s'exprimer. Bien entendu, la règle qui s'appliquait précédemment au dernier joueur n'a plus raison d'être. Au tour suivant, deux cartes seront distribuées, puis trois, et ainsi de suite jusqu'à 5. Ensuite, le nombre de cartes redescendra à 1, etc. etc.

Les deux derniers joueurs en vie sont les grands gagnants (il se peut qu'il n'y en ait qu'un seul, voir même zéro, si plusieurs joueurs perdent toutes leurs vies en même temps).

Votre travail ? Réaliser ce jeu en console, agrémenté d'une IA. Il est assez rare de trouver des exercices sur des jeux de cartes, n'attendez plus, progressez ! Et surtout, amusez-vous bien. L'avantage de ce jeu plutôt simple est qu'il ne nécessite pas un affichage über-avancé, requérant l'utilisation d'une bibliothèque externe tel que la famille des *curses, ou encore libcaca. Ne vous inquiétez pas, je vais vous guider pas à pas afin que vous réussissiez cet exercice avec brio !

Organisation du projet

Connaissez-vous le principe de la programmation modulaire ? Globalement, cela consiste à découper son code en plusieurs fichiers. L'utilité ? Même un un code découpé en fonctions devient à un certain point difficile à relire si tout est contenu dans le même fichier. Séparer logiquement ce code en plusieurs fichiers le rend plus clair, et bien plus modulable. Je vous invite à d'ores et déjà créer tous les fichiers de votre projet :

• main.c – est-ce vraiment nécessaire d'expliquer l'utilité de ce fichier ?
• jeu.c – fonctions utiles au bon fonctionnement du jeu (la gestion des vies, des cartes, des tours etc.) ;
• jeu.h – prototypes des fonctions de jeu.c + macros, structures ;
• joueur.c – fonctions relatives au joueur ;
• joueur.h – prototypes des fonctions de joueur.c + macros, structures ;
• ia.c – fonctions relatives à l'IA (annonce des plis, poser des cartes) ;
• ia.h – prototypes des fonctions de ia.c ;
• constantes.h – définitions de constantes globales à tout le programme.

Bien entendu, vous n'êtes pas obligé de suivre ce plan à la lettre, et je ne vous dis pas non plus que c'est l'organisation parfaite : ce n'est qu'un exemple parmi tant d'autres. De plus, comme vous l'aurez compris, je vous conseille d'utiliser des structures, qui permettent de mieux structurer votre code.

Effacer l'écran et faire des pauses

Bien que cela ne représente pratiquement aucun intérêt d'un point de vue pédagogique, je vais vous montrer comment effacer l'écran et faire des pauses de x ms dans vos programmes :

#include <stdio.h>
#include <stdlib.h>

#ifdef __WIN32__
    #include <windows.h>
    #define Sleep(n) Sleep(n)
    #define clear() system("cls")
 
#else /* Le reste, pour les UNIX-like en particulier */
    #include <unistd.h>
    #define Sleep(n) usleep((n*1000))
    #define clear() system("clear")
#endif

int main(void)
{
    clear();
    printf("Hello world!\n");

    Sleep(1500);
    clear();

    printf("Quoi de neuf ?");

    return 0;
}

Si vous ne comprenez pas ce code, je vous invite à relire le cours sur le préprocesseur, et à se documenter sur les fonction Sleep et usleep.

Bien que fonctionnel sur les systèmes d'exploitation les plus utilisés, ce code n'est pas totalement portable. De plus, l'utilisation de la fonction system n'est pas des plus recommandée. Petite note : il est important de vider le vider le buffer de stdout (Google it !). Pour ce faire, un simple retour à la ligne suffit la plupart du temps. Essayez avec un printf sans retour à la ligne à la fin pour voir. Petite astuce, la fonction puts en ajoute un automatiquement. Afin de forcer l'écriture de toutes les données d'un buffer, vous pouvez utiliser la fonction fflush :

printf("Hello word!");

fflush(stdout);
Sleep(1000);
clear();

printf("Quoi de neuf ?");

Le jeu

Prenez bien le temps de penser à tout, à bien organiser votre code, à le découper en fonctions. Je vous invite aussi à réfléchir sur la gestion des cartes. Pour un jeu aussi simple que le Tarot Africain, est-ce vraiment nécessaire simuler une distribution des cartes se rapprochant de la réalité (mélanger le paquet dès au début, le couper, distribuer les cartes une à une, etc.) ? Ou au contraire, est-ce que le fait de tirer aléatoirement un certain nombre cartes pour n joueurs suffit-il réellement ? En d'autres termes Quel degré de réalisme voulez-vous ajouter dans votre jeu ? À vous de choisir.

Personnellement, pour des jeux tels que le Tarot, la Belotte ou encore le Poker, j'aurais plus opté pour la solution la plus réaliste, et encore. Cependant, pour un jeu aussi simple que le Tarot Africain, jeu comportant seulement 22 cartes, je ne pense pas que cela soit absolument nécessaire.

Ce qui nous amène (+/-) logiquement au point suivant : concevoir un code évolutif. En effet, il est beaucoup plus intéressant de pouvoir gérer un nombre variable de joueurs (et de cartes pourquoi pas !). Attention, avec un nombre de carte classique, il est impossible de distribuer 5 cartes à 5 joueurs (5×5=25, or, il n'y a que 22 cartes dans le jeu). C'est un cas à gérer, et ce, de manière entièrement automatisée bien entendu : je ne veux pas voir une atroce série de if / else if / else !

Pour aller plus loin...

Comme vous pouviez vous y attendre, je vais vous parler d'IA. En effet, à moins que vous ayez porté votre jeu en ligne, vous risquez fort de vous embêter devant ce jeu. L'implémentation d'une IA me paraît une évidence, surtout que cela représente la partie la plus intéressante de l'exercice ! Un nouveau défi s'offre à vous, serez-vous capable de le relever ?

Après tous ces conseils et astuces, vous vous devez de réaliser cet exercice... avec une IA !

-
Edité par paraze 1 août 2013 à 23:16:14

L'exercice à l'air cool, bravo ! Si je peux me permettre une petite suggestion, n'hésitez pas à implémenter plusieurs stratégies d'IA, il n'est devrait pas obligatoirement être nécessaire d'avoir une IA de la mort qui tue (au moins au départ).

paraze a écrit:

Bien que cela ne représente pratiquement aucun intérêt d'un point de vue pédagogique, je vais vous montrer comment effacer l'écran et faire des pauses de x ms dans vos programmes :

#ifdef __WIN32__
    #include <windows.h>
    #define Sleep(n) Sleep(n)
    #define clear() system("cls")
 
#else /* Le reste, pour les UNIX-like en particulier */
    #include <unistd.h>
    #define Sleep(n) usleep((n*1000))
    #define clear() system("clear")
#endif

Juste une petite remarque : je crois que la version correcte de la macro serait plutôt

#define Sleep(n) usleep((n)*1000)

car les parenthèses internes sont là pour protéger n.

-
Edité par yoch 1 août 2013 à 12:56:07

En effet, tu as raison, j'édite.

Et merci pour ton message !

Ne soyez pas timide.

Pour ma part, j'ai commencé l'exercice et je m'essaie à Doxygen en passant. C'est vraiment pas mal ce machin-là. Bref, je rentre de vacances dans six jours, et je veux au moins 3 codes messages à mon retour !

Sur ce, je vous dis à bientôt.

-
Edité par paraze 8 août 2013 à 22:55:16

Ça a vraiment l'air très chouette comme jeu

D'une part je risque fort d'y jouer en famille en vacances d'ici une semaine, mais en plus, ce serait chouette que j'ai une IA de la mort qui tue à ce moment là pour pouvoir les exploser !

Bref, je participe, en plus d'être un jeu sympa, ça a l'air d'être vraiment amusant à programmer. Et puis il faut dire que je suis vraiment un pur fan de la console alors que demande le peuple...

Ah et sinon je me demandais, ce code sert à quoi ?

#define Sleep(n) Sleep(n)

Ah et aussi, j'ai essayé de faire un clear sans retour à la ligne, chez moi ça marche tout à fait comme il faut. J'imagine que c'est C::B qui me corrige en amont mais sinon c'est censé donner quoi ?

-
Edité par alexandre.tsu.manuel 3 août 2013 à 20:42:02

Edit : Je vais plutot tenter de faire un serveur (avec tsunami, s'il le veut)

-
Edité par SylafrsOne 10 août 2013 à 0:13:33

J'aurais bien aimé m'attaquer à un vrai projet comme celui-ci, mais je n'y connais pas grand chose en terme d'IA, y'a t'il une alternative ?

-
Edité par clems_029 8 août 2013 à 22:54:43

Tu sais, moi et l'algo, l'IA, ça fait 42.

Je n'y ai pas encore réellement réfléchi, mais je pense simplement me servir dans un premier temps de statistiques, de probas – je suis une bille en maths je précise. Après, comme l'a recommandé yosh un peu plus haut, je pense implémenter plusieurs IAs (et les faire s'affronter... *_*), dont pourquoi une complétement aléatoire. Tu pourrais par exemple adopter cette stratégie si t'es vraiment à court d'idée – ou pour faire des tests. Mais bon, ce n'est pas très marrant après.

D'accord, je vais réfléchir à tout sa, j'ai envie de me lancer dans un tel projet, sa me permettra de progresser.

Pour ce genre de jeu, ça doit pas trop etre compliqué de créer une IA marrante (pas forcément invincible).
Il suffit de jouer plusieurs fois avec des amis au jeu et de coder la manière dont tu as joué (ça semble bizarrement dit, mais..)

Dans le tarot, le secret réside sur la mémoire. Quelles cartes sont passées, lesquelles sont encore en jeu ? Que faire pour arriver au compte.

Si c'est un jeu d'IA il pourrait être intéressant de créer un serveur qui s'occupe du jeu (et on fait affronter les IA dessus)
Mais bon, dans ce cas, c'est plus un concours qu'un exercice pour débutant x)

-
Edité par SylafrsOne 9 août 2013 à 16:39:57

SylafrsOne a écrit:

Pour ce genre de jeu, ça doit pas trop être compliqué de créer une IA marrante (pas forcément invincible).

 De toute façon, pour ce genre de jeux, il ne peut pas y avoir d'IA invincible. Il y a trop de hasard, pour peu de possibilité jeu.

Disons invincible statistiquement. Si l'IA choisit toujours de faire le meilleur choix statistique il devient très difficile de la battre. Mais bon une autre IA spécialement conçue pour démolir ces IA là ça devrait le faire

En tout cas je plussoie la plateforme d'affrontement d'IA. Mais bon il faudrait un peu plus de participants. Si on est un peu plus nombreux que deux à vouloir ça, je veux bien coder une plateforme d'affrontement d'IA (suivant certaines règles que je vous donnerai bien sûr)

-
Edité par alexandre.tsu.manuel 9 août 2013 à 17:28:05

De toutes manières, avoir un protocole semble évident, donc, c'est forcément au serveur de donner les règles
Du coup, on est pas obligé à ce restreindre au C, si on propose le concours, mais aussi C++, Java, autres

Ca peut être marrant

-
Edité par SylafrsOne 10 août 2013 à 0:12:01

J'aurai bien voulue le faire, le jeux à l'air supère sympa mais je suis pas trot fort en C pour pouvoir me lancée dans une tel projet (même si pour vous il à l'air facile).

Rassure toi je crois que peu de gens ici peuvent se vanter de trouver ça simple. Même si le jeu en lui même est assez basique comparé à un jeu d'échecs ou même de tarot classique, faire une bonne IA est toujours quelque chose d'assez difficile.

Vous savez quoi? Je vais tentez (je sais je suis fout) mais pourquoi pas? On apprend bien de ses erreur? En plus sa réunie les deux choses matériels que j'aime dans la vie... Les défie et la programmation ^^.

J'ai un problème... J'ai vu le post, ça m'a botté... Et ça fait 6 jours que de temps en temps je vais lire (à différents endroits sur internet) les règles et le principe... Mais j'ai toujours pas compris alors forcément, c'est pas facile de coder un jeu dont on ne comprend pas les règles x)

OK, petit résumé :

Le but du jeu est de parier, de miser sur le nombre de plis que tu fais en un tour. On commence un tour avec 5 cartes (par exemple), le joueur à droite du distributeur est le premier à jouer, il a donc 5 cartes en main. Imaginons qu'il pense gagner 2 plis (sur 5 donc), il va donc essayer de gagner 2 fois, et de perdre 3 fois. Il joue donc l'une de ces 5 cartes, puis c'est au second, et ainsi ce suite. Attention, petite précision : le dernier joueur à jouer, le distributeur donc, a un choix restreins de mises, le nombre de plis pariés au total doit être différent d'un multiple du nombre de cartes en main, en d'autres termes, si les précédents joueurs ont annoncé 4 plis au total (sur 5), le dernier joueur ne pourra pas miser 1 (4 + 1 = 5). Trois autres exemples :

• Les joueurs 1, 2, 3 et 4 ont respectivement misé : 1, 0, 2, 0 - ça fait 3 au total, le dernier joueur ne pourra pas parier 2 (3 + 2 = 5) ;
• Les joueurs 1, 2, 3 et 4 ont respectivement misé : 0, 1, 0, 1 - ça fait 2 au total, le dernier joueur ne pourra pas parier 3 (2 + 3 = 5) ;
• *Supposons cette fois-ci que chaque joueur ne possède que deux cartes (c.f. plus bas)** : 0, 1, 2, 1 - ça fait 4 au total, il ne pourra donc pas parier 0 ou 2 (multiple de 2), son seul et unique choix restant sera le 1.

Chaque joueur commence avec 13 vies. Si un joueur parie 2 plis et qu'il n'en gagne qu'un seul, alors il perdra une vie. S'il pense en gagner aucun et qu'il en remporte un tout de même (ça peut arriver, si il croyait avoir un mauvais jeu, mais que les autres en avait un encore plus mauvais que lui, ou tout simplement s'il joue mal), alors il perdra une vie. Si un joueur parie 1 et qu'il en gagne 3, alors il perdra deux vies. S'il parie 3 et qu'il en remporte 0, alors le nombre de vie perdu sera au chiffre de 3. Capiche ?

Comme nous l'avons plus haut, le nombre de carte est variable. En fait, au premier tour, il y a 5 cartes (à adapter selon le nombre de joueur), au suivant il n'y en aura plus que 4, puis 3, puis 2, puis 1, puis 2, puis 3, puis 4, puis 5, puis 4, puis 3, puis 2, puis 1, etc.

/!\ Le tour où les joueurs n'ont plus qu'une seule carte est un peu spécial. Le distributeur donne les cartes aux joueurs (en commençant par la droite toujours, mais toussa c'est expliqué dans le premier post) faces cachées. Ensuite, chaque joueur montre sa carte aux autre sans la regarder. Chaque joueur connait donc la cartes des autres joueurs, mais pas leur carte respective. Ensuite, le joueur à la droite de celui qui vient de distribuer annonce s'il pense gagner ou perdre (s'il pense gagner 1 ou 0 plis en somme), puis c'est au second, etc. La règle contraignante du dernier joueur ne s'applique plus. Si un joueur s'est trompé dans son choix (s'il pensait gagner alors qu'il perd finalement, et inversement), alors il perd une vie.

Pour finir, le jeu s'arrête lorsqu'il n'y a plus que deux joueurs vivants, ce sont les deux grands gagnants.

J'ai écris ça vite-fait, j'espère que ça pourra aider à certains de comprendre les règles du jeu.

P.S. : Lorsque j'ai vu qu'il y avait une nouvelle réponse sur ce post, j'ai d'abord cru à une proposition de code, j'ai crié de joie sur IRC; mais bon.

-
Edité par paraze 15 août 2013 à 11:22:05

Bonjour pourrai je avoir le lien des exo des mois précédents ?

Tiens !

http://www.siteduzero.com/forum/sujet/exercices-pour-debutants-en-c-15206

Je pense proposer mon code d'ici... avant la rentrée, ce sera déjà bien, @bientôt !

-
Edité par paraze 1 septembre 2013 à 14:31:16

Merci paraze

J'essaierai de le coder après la rentrée... J'ai pas le temps jusque là... Mais je posterai quand même ma solution ici

Idem pour ma part, j'essaierai à la rentrée de le coder pour me faire progresser. Je fais des exercices en attendant pour mieux maîtriser le langage par la suite. Bon courage à ceux qui y travaillent.

Bon, mon code n'est pas encore fini, mais je m'engage à le poster avant la fin des vacances (qui est, pour moi, le Mardi 3 Septembre).

Ayant la flemme de rédiger un si gros exercice pour si peu résultats, l'exercice du mois sera plus bref.

salut pour tous les membres du site , j'aimerais débuter la programmation et j'aimerais quelque conseil de votre part pour un bon début est avec quelle langage et préférable pour apprendre , merci d'avance

Je dirais que de ne pas « polluer » ce sujet serait déjà un bon commencement. Après je t'invite à faire une recherche, puis à créer un nouveau sujet, si besoin il y a.

Bon, je poste ! 

Alors je pense que c'est loin d'être parfait :

- Pas d'IA (même pas un truc qui choisit une carte au hasard) ;

- Pas de cartes cachées sur sa tête au dernier tour.

... et puis je n'ai pas une grande expérience du C. Je connaît beaucoup mieux Java ...

D'ailleurs, j'ai cru bien faire en utilisant les int8_t, int16_t et int32_t au lieu des int, short et char, puisque la taille de ces derniers n'est pas trop définie. Mais visiblement je crois que j'ai eu tort... (même si je ne pense pas que ce soit dramatique !)

Donc :

• main.c ;
• jeu.h, jeu.c, qui contiennent toutes les fonctions du jeu, de lecture des entrées de l'utilisateur, et de l'affichage (tout mélangé !) ;
• paquet.h, paquet.c, pour gérer un ensemble de cartes avec une liste liée ;
• constantes.h
• erreur.h, erreur.c, une gestion bête et méchante des erreurs...

Et donc j'attends vos critiques, bien sûr

C'est pas mal du tout. Il y a quelques emplois pas très idiomatiques en C, mais l'ensemble est globalement clair et cohérent ; bravo ! Quelques remarques en l'air (j'ai survolé).

• Effectivement, utiliser les entiers de taille fixe n'était pas vraiment une bonne idée ici. Enfin, tu n'en es vraisemblablement rendu compte par toi-même (d'ailleurs, théoriquement ils sont seulement optionnels).
• Les déclarations au milieu du code et les entiers de taille fixe viennent du C99 ; tu peux donc utiliser _Bool (ou bool dans stdbool.h).
• Évite les constantes en dur (4, 5, 22, etc.).
• Les commentaires ne sont placés très judicieusement ; d'ailleurs, les commentaires « séparateurs » ne sont pas très utiles, utiliser une ligne blanche est souvent plus clair et de fait préférable.
• Tu as certaines variables globales que tu pourrais aisément éviter.

Ouais, j'aurai du faire une structure Jeu...

Pour les entiers, en fait, j'ai l'habitude de Java, ou tout est bien fixe et bien défini (un int fait 32 bits, un short fait 16 bits, ...). En C c'est très flou à ce niveau je trouve.

Pour les commentaires, j'ai aussi l'habitude de la javadoc...

Bref, je vais retourner faire du Java :-)