Patience, un jeu de cartes

Soyez le premier à donner votre avis sur cette source.

Vue 2 885 fois - Téléchargée 1 427 fois

Description

Patience, un jeu de cartes avec résolution automaique

Ce nouveau programme n'a rien d'original. On en trouve des versions sur tous les
ordinateurs mais la particularité de la version présente est de comporter plusieurs
jeux différents et de permettre d'en créer facilement de nouveaux. Il est réalisé
en Visual CPP avec l'atelier logiciel Microsoft Visual Studio Community 2019.
Il est conçu avec la bibliothèque MFC standard sans utiliser l'architecture
Document/Vue.

Le code présenté est largement documenté, ce qui permet, ajouté aux possibilités
de l'atelier logiciel, de comprendre assez aisément les fonctions assurées par
ce programme.

La nouvelle version est enrichie d'un programme de résolution du jeu YUKON Solitaire Simple. Elle est issue du défoulement de développeurs coincés à la maison par la conjoncture sanitaire actuelle. La description en est faite à la fin de ce document. De plus cette version est enrichie d'un Help, les temps actuels nous donnent le temps de l'écriture et de la lecture !

Architecture de base

Le classique de l'architecture permet de retrouver ses classes principales :
CPatient, la classe d'application : Dans les fichiers Patience.cpp
et Patience.h. C'est cette classe qui démarre l'application.

CMainFrame, la classe principale : Fichiers MainFrm.cpp et MainFrm.h.
C'est la fenêtre principale qui supporte la fenêtre de l'application.
CChildView, la classe de vue : Fichiers ChildView.cpp et ChildView.h.
C'est cette classe qui supporte la fenêtre de l'application et gère l’interface
avec le joueur. Elle contient les différentes classes qui gèrent le jeu.

Des commandes accessoires de débug complètent ce programme pour commander à partir du clavier le cyclage des opérations ou la génération d’un jeu de cartes non mélangées.

Classes qui gèrent le jeu

Le jeu est construit autours d'objets : les Cartes, les Piles de cartes et la gestion du jeu.

Classe CCard : Supporte les cartes, implantée dans les fichiers
Card.cpp et Card.h. L'objet CCard définit une carte avec tous ses attributs,
le champ fig définit l'image présentée soit de dos soit de face suivant le champ hide.
Cet objet comporte aussi un chainage de pointeurs permettant de relier ensemble
les différentes cartes appartenant à la même pile.
Classe CPile : Supporte les piles de cartes, implantée dans les
fichiers Pile.cpp et Pile.h. L'objet CPile décrit les différentes piles de cartes
et les fonctionnalités associées. Des noms de types qualifient les différentes piles
(BTYPE_ENUM), ce qui permet de mieux en suivre les fonctionnalités.
C'est aussi à ce niveau que sont traitées les règles d'échange de cartes
entre les différentes piles.
Classe CPlayer : Supporte toute l'organisation du jeu,
dans les fichiers Player.cpp et Player.h. Les interactions entre les objets
et le joueur sont traitées à ce niveau comme le transport de cartes d'une pile
à l'autre sous le contrôle de la souris, ainsi que les différentes phases
du jeu ou les déplacements de cartes plus complexes comme par exemple
dans les phases de distribution ou de fin de jeu.

Fonctions auxiliaires

Descripteur des jeux : Les fichiers CardsDesk.cpp et CardsDesk.h,
contiennent la description des 6 jeux du programme. Pour chacun un texte ASCII
décrit la composition du jeu, le nombre de cartes utilisées, la disposition
des piles et les règles d'usage. Les dimensions s'adaptent à la taille des cartes
affichées. Les commentaires présents dans ces fichiers indiquent comment créer un
nouveau jeu et pour les règles d'accès il peut être intéressant de se reporter au fichier Pile.cpp (vers la fin du fichier : lignes 562 et +) pour aussi exploiter les commentaires des fonctions RdCardsTest() et WrCardsTest(). Ce sont ces fonctions qui définissent les règles pour la capture et la déposition d'un paquet de carte avec la souris dans les fonctions Drag/Drop.
Barre de choix des cartes : Les fichiers CardsToolBar.cpp et CardsToolBar.h donnent la description de la barre d'outils présentant les différents sets de cartes disponibles.
fonctions complémentaires : Les fichiers Utilities.cpp et Utilities.h décrivent des fonctions accessoires utilisées dans les différents programmes.

Résolution

C'est une fonction nouvelle, un peu gadjet permettant de résoudre seulement le jeu "2: YUKON Solitaire simple". Cette fonction est assurée par la classe CSolver2, fichiers Solver2.cpp et Solver2.h. Un principe assez simple est utilisé, consistant à construire un arbre décrivant tous les états possibles du jeu. Chaque nœud fixant un état du jeu et le passage au nœud de profondeur supérieur étant conditionné à un seul mouvement de cartes. Cette construction permettant de découvrir parmi ces états le jeu résolu ou montrant que toutes les branches ainsi réalisées finissent par une impasse montrant que le jeu ne possède pas de solution. Ensuite il suffit de re parcourir cet arbre de l'état résolu jusqu'à la racine pour disposer de la solution. La structure t_PLAY est utilisée pour décrire un nœud.

Elle contient :
t_PLAY *pNext, *pPrev : pour lier bi directionnellement tous les nœuds entre eux et retrouver un nœud quelconque en parcourant cette liste,
t_PLAY *pOrg : pour lier un nœud enfant à son père et matérialiser la branche allant d'une feuille à la racine et mémoriser les actions nécessaires pour reproduire ce parcourt.
BYTE cards[64] : une table mémorisant l'état courant du jeu en décrivant la positions des 52 cartes dans les différentes piles (4 piles Fondation et 7 piles Tableau).
DWORD cmd : définissant la commande du mouvement de cartes permettant de construire le nœud suivant.

Les principales fonctions pour la création et la gestion de l'arbre sont :

void MakeSolution(t_PLAY* pOrg, CWinThread**ppThread) : Génération de l'arbre.
BYTE Analyze(t_PLAY* pOrg, BYTE rndCmd) : Détermination des mouvements de cartes à effectuer.
BYTE Solution(t_PLAY* pOrg, DWORD cmd, bool frozen) : Réalisation d'un mouvement avec génération d'un nouveau t_PLAY avec sa nouvelle table cards[64].
void CardsConvert(CPlayer *pPlayer, BYTE cards[64]) : Conversion d'un jeu affiché en BYTE cards[64].
void Display(const t_PLAY* pPlay) : Affichage du jeu calculé.
DWORD setCmd(BYTE level, BYTE src, BYTE dst, BYTE lg) const, codant la commande avec :
. level : constitue le niveau du nœud dans l'arborescence,
. src : la position (dans la table cards) de la pile source,
. dst : la position (dans la table cards) de la pile destination,
. lg : le nombre de cartes échangées, toujours à partir de la fin de la pile.

Ce sont ces dernières informations qui seront placées dans l'History, ce qui permet de rejouer la solution trouvée.

Codes Sources

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.