TP 8: Réussite

Le fichier à remplir est ici.

L'idée générale est la définition de types et fonctions offrant les outils de base qui permettent la programmation de jeux de cartes. Un jeu de 32 cartes est composé de 4 couleurs (Trèfle, Carreau, Coeur et Pique). Dans chaque couleur il y a 8 cartes de hauteurs différentes (7, 8, 9, 10, valet, dame, roi, as).

1 Définition de la nature des objets

Définir le type carte à partir des types coul et haut fournis.
Définir des fonctions coul et haut qui retournent respectivement la couleur et la hauteur d'une carte.
```
val coul : carte -> coul = <fun>
val haut : carte -> haut = <fun>
```
Définir une fonction haut_of_int qui prend un entier entre 7 et 14 en argument et retourne une hauteur (l'as correspondant à 14). Lever une exception si l'argument n'est pas entre 7 et 14.
```
val haut_of_int : int -> haut = <fun>
```
Définir une fonction coul_of_string qui prend une chaîne de caractères en arguments ("Coeur", "Trefle", "Pique" ou "Carreau") et qui retourne l'élément correspondant du type coul. Lever une exception si l'argument n'est pas une de ces chaînes.
```
val coul_of_string : string -> coul = <fun>
```
Définir une fonction carte prenant un entier et une chaîne de caractères en arguments et retournant une carte.
```
val carte : int -> string -> carte = <fun>
```
Définir une fonction string_of_carte qui retourne une représentation textuelle de la carte: une hauteur ("7", …, "10", "Valet", "Dame", "Roi", "As"), suivi de " de " et de la couleur ("Coeur", "Trefle", "Pique" ou "Carreau").
```
val string_of_carte : carte -> string = <fun>
```

2 Construction d'un paquet battu de 32 cartes

Une liste de 32 cartes toutes différentes représente un jeu quelconque.

Définir une fonction random_carte retournant aléatoirement une des 32 cartes. Il est conseillé d'utiliser la fonction Random.int.
```
val random_carte : unit -> carte = <fun>
```
Définir une fonction ajtcarte qui ajoute au début de la liste une carte absente de la liste, choisie aléatoirement.
```
val ajtcarte : carte list -> carte list = <fun>
```
Définir une fonction faitjeu qui produit un paquet de n cartes, toutes différentes. On supposera que l'on n'appelle jamain faitjeu avec un entier strictement supérieur à 32.
```
val faitjeu : int -> carte list = <fun>
```

3 On programme une réussite

L'idée de cette réussite est la suivante. Les cartes sont étalées, face visible, en une seule ligne de 32 cartes, considérée comme 32 paquets de 1 carte. Une réduction de la ligne est possible si il existe un paquet p situé entre 2 paquets dont les cartes de sommet ont même hauteur ou même couleur. Dans ce cas, le paquet p est posé sur le paquet à sa gauche et la ligne possède un paquet en moins. Cette étape de réduction est répétée tant qu'elle est possible. Si plusieurs réductions sont possibles, on fait celle la plus a gauche.

3.1 Exemple

Si on part de quatre paquets de deux cartes

As ♣	7 ♠	As ♦	7 ♦
10 ♥	V ♦	8 ♠	10 ♣

on obtient trois paquets après une itération (deux as entourant le 7 de pique)

7 ♠
V ♦
As ♣	As ♦	7 ♦
10 ♥	8 ♠	10 ♣

puis deux paquets après une autre itération (deux 7 entourant l'as de carreau)

As ♦
8 ♠
7 ♠
V ♦
As ♣	7 ♦
10 ♥	10 ♣

3.2 Questions

Définir une fonction reduc qui pratique une seule réduction si c'est possible ou qui rend le jeu sans le changer si aucune réduction n'est possible. On pourra utiliser la fonction @.
```
val reduc : carte list list -> carte list list = <fun>
```
Définir une fonction reussite qui enchaîne, tant que cela est possible, les réductions.
```
val reussite : carte list list -> carte list list = <fun>
```
Appeler reussite avec le bon paramètre pour faire une simulation.

4 Affichage du jeu après chaque réduction

Nous fournissons une fonction draw_carte permettant d'afficher une carte. Cette fonction dessine une représentation élémentaire d'une carte au point courant, dans une fenêtre graphique. Cette fonction déplace ensuite le point courant à la position permettant le dessin d'une autre carte juste au dessus.

Définir la fonction draw_pile qui permet de dessiner une pile de carte au point courant et déplace ensuite le point courant de 30 points vers la droite par rapport au point initial. Attention, il faut s'assurer que la première carte de la pile est celle représentée en haut de la pile, vers le haut de l'écran.
```
val draw_pile : carte list -> unit = <fun>
```
Définir la fonction draw_jeu qui efface la fenêtre graphique, déplace le point courant en (5,5) et dessine l'état du jeu en juxtaposant le dessin de chaque pile.
```
val draw_jeu : carte list list -> unit = <fun>
```
Définir une fonction draw_reussite qui génère une état initial aléatoire (32 tas d'une carte, tous différents), ouvre une fenêtre graphique, affiche le jeu et affiche l'étape suivant de la réussite à chaque appui de touche. Entrer la touche 'q' interrompt la fonction et ferme la fenêtre.
```
val draw_reussite : unit -> unit = <fun>
```

Pour ces fonctions vous pouvez consulter la documentation disponible ici et là. Voir en particulier les fonctions moveto, clear_graph, open_graph, close_graph, current_point et read_key.