swish/Doc/Algorithme/FonctionAnalyseEmpiler.md

ANALYSE DE CARTE#

COMPARAISON DE CARTE##

ComparaisonDeCarte(CarteMere:Matrice(4,3), Carte:Matrice(4,3)) : entier

Entrées : CarteMere et Carte :Matrice(4,3)

Sortie : entier

Objectif : Determine si les Cartes possèdent une liaison ( point <=> cercle )

DEBUT###

###Variables locales : Cox1,Cox2,Coy1,Coy2 des entiers

---

Si CarteMere est NULL alors

// L'assemblage est parfait car il n'y a pas de contrainte

retourne 2

Fin Si

//Recherche des coordonnées du point et du cercle sur la variable Carte

Cox1,Coy1,Cox2,Coy2 = rechercheCo(Carte)

// CAS N°1 : Il existe déjà un ensemble ( point <=> cercle) sur CarteMere là où Carte posséde un point ou un rond

Si CarteMere(Coy1,Cox1) == 3 ou CarteMere(Coy2,Cox2) == 3 alors

// Impossible d'empiler

retourne 0

Fin si

// CAS N°2 : L'empilement est parfait ! Les coordonnées du point et du cercle de Carte peuvent créer deux liaisons ( point <=> cercle ) avec CarteMere

Si CarteMere(Coy1,Cox1) == 1 et CarteMere(Coy2,Cox2) == 2 alors

// Les coordonnées sont bonnes

retourne 2

Fin Si

// CAS N°3 : Il est possible de créer une liaison ( point <=> cercle ) entre CarteMere et Carte

Si CarteMere(Coy1,Cox1) == 1 ou CarteMere(Coy2,Cox2) == 2 alors

//Liaison Possible

retourne 1

Fin si

// CAS N°4 : On ne peut rien faire avec ces cartes

retourne 0

###FIN

##COMPARAISON TOTAL DE LA CARTE

ComparaisonTotal(CarteMere:Matrice(4,3) d'entiers,CarteFille:Matrice(4,3), index entier):entier,Tableau(4,3) d'entiers

Entrees : CarteMere,CarteFille :Matrice(4,3), index entier

Sortie : entier,Matrice(4,3)

Objectif : Determine si les Cartes possèdent une liaison ( point <=> cercle ) MAIS avec toutes les possibilitées de rotation de Carte

###DEBUT

###Variables locales

Code,Code1 des entiers

---

Si CarteMere est NULL alors

// Il n'y a rien à faire

retour 1,CarteFille

Fin si

// Note : Cette fonction sait combien de fois elle a été appelée grâce à la variable index. En effet pour une carte donnée il existe 4 variantes d'elle-même. La fonction va donc appeler au fur et à mesure toutes ses variantes et les tester.

//On obtient ces opérations suivantes

Si index == 1 alors

// On effectue une rotation verticale pour obtenir la 2eme variante

CarteFille <- rotationVerticale(CarteFille)

Fin Si

Si index == 2 alors

// On effectue une rotation Horizontale pour obtenir la 3eme variante

CarteFille <- rotationHorizontale(CarteFille)

Fin Si

Si index == 3 alors

// On effectue une rotation Vertivale pour obtenir la 4eme variante

CarteFille <- rotationVerticale(CarteFille)

Fin Si

Si index == 4 alors

// aucune variante ne colle avec CarteMere

retourne -1,CarteMere

Fin Si

//Après avoir modifié CarteFille on peut tester la variante avec CarteMere

Code <- ComparaisonDeCarte(CarteMere,CarteFille)

Si Code == 2 alors

// L'empilement est parfait donc on empile les cartes

CarteMere = CarteMere + CarteFille

retourne Code,CarteMere

Fin si

Si Code == 1 alors*

// NOTE : il est important de vérifier ce cas présent. En effet si une seule liaison est possible, certaines cartes offrent plusieurs possibilités d'assemblage impliquant deux variantes. Comment savoir laquelle est la bonne pour le tas final ? La fonction va le faire remarquer.

Code1 <- ComparaisonDeCarte(TasDeCarte,rotationHorizontale(CarteFille))

Si Code1 == 1 alors

// Les variantes horizontalement symétriques possèdent toutes les deux une liaison avec CarteMere on ne peut pas savoir laquelle est la bonne pour faire le tas final.

retour 4, CarteFille

Fin Si

Si Code1 == 2 alors

// La variante horizontalement symétrique s'assemble parfaitement, on l'assemble donc.

CarteMere = CarteMere + rotationVerticale(CarteFille)

retourne 2, CarteMere

Fin Si

// On teste maintenant avec la variante verticalement symétrique

Code1 <- ComparaisonDeCarte(CarteMere,rotationVerticale(CarteFille))

Si Code1 == 2 alors

// La variante verticalement symétrique s'assemble parfaitement, on l'assemble donc.

CarteMere <- CarteMere + rotationVerticale(CarteFille)

retourne 2, CarteMere

Fin Si

Si Code1 == 1 alors

// Les variantes verticalement symétriques possèdent toutes les deux une liaison avec CarteMere on ne peut pas savoir laquelle est la bonne pour faire le tas final.

retourne 3,CarteFille

Fin Si

Fin si

// Si aucune liaison n'est possible, on appelle à nouveau la fonction en Incrémentant index

retourne ComparaisonTotal(CarteMere,CarteFille,index + 1)

FIN

#ASSEMBLAGE

Assemblage(TasDeCarte: Liste Matrice(4,3),CarteMere:Matrice(4,3) :entier, Matrice(4,3)

Entree : TasDeCarte Liste Matrice(4,3), CarteMere Matrice(4,3)

Sortie : entier, Matrice(4,3)

Objectif : Savoir si un tas de carte envoyé en paramètre peut être empiler ou non

###DEBUT

###Variable locale

Carte Matrice(4,3)

CopieCarteMere Matrice(4,3)

Code entier

CarteParallele Matrice(4,3)

---

// Si le tas de carte est NULL il ne peut pas rapporter de point donc on ne peut pas l'assembler sinon on traite la première carte

Si TasDeCarte est NULL

retourne 0, CarteMere

Sinon

Carte = teteL(TasDeCarte)

// On garde une copie de CarteMere

CopieCarteMere = CarteMere

// On regarde si Carte peut s'assembler avec CarteMere

Code,CarteMere = Comparaisontotal(CarteMere,Carte,0)

Fin si

// En fonction du Résultat obtenue on traite

// Cas 1 : Si Code vaut 2 et que TasDeCarte est NULL on a atteint la fin du paquet et l'assemblage est parfait

Si Code vaut 2 et TasDeCarte est NULL

retourne 2, CarteMere

Fin si

// Cas 2 : TasDeCarte est NULL mais l'assemblage n'est pas parfait. On ne peut pas assembler correctement le tas de carte. On le signal

Si TasDeCarte est NULL et Code different de 2

retourne 0,CarteMere

Fin si

// NOTE : à ce stade si l'algorithme lit ces lignes nous savons que TasDeCarte n'est pas NULL. Seul la valeur de Code retourné par **ComparaisonTotal nous interesse

//Cas 3 : Code vaut 2 ou 0, l'assemblage est parfait ou impossible mais il reste des cartes à traiter. Il faut donc insérer cette carte à la fin de la liste et continuer en traitant les autres carte.

Si Code vaut 2 ou Code vaut 0 ou Code vaut -1

TasDeCarte = insrq(TasDeCarte,Carte)

retourne Assemblage(TasDeCarte,CopieCarteMere)

Fin si

// Cas 4: Code vaut 3, il y a plusieur possibilitées d'assemblage.On va donc essayer les deux possibilités proposées.

//NOTE Dans ce cas la fonction comparaisontotal retourne la carte possédant la symétrie. Donc CarteMere est devenue cette carte. d'où l'importance de CopieCarteMere

Si Code vaut 3

CarteParallele = CarteMere

// On teste les deux possibilité

Code,CarteMere = Assemblage(TasDeCarte,CopieCarteMere + CarteParallele)

Code1,CarteMere1 = Assemblage(TasDeCarte,CopieCarteMere + rotationVerticale(CarteParallele))

// On regarde si l'une des deux possibilité fonctionne

Si Code1 vaut 2

retourne 2,CarteMere1

Fin si

Si Code vaut 2

retourne 2,CarteMere

Fin Si

// Sinon aucun assemblage est bon

retourne 0,CarteMere

Fin si

// Cas 5: Code vaut 4, il y a plusieur possibilitées d'assemblage.On va donc essayer les deux possibilités proposées.

Si Code vaut 4

CarteParallele = CarteMere

// On teste les deux possibilité

Code,CarteMere = Assemblage(TasDeCarte,CopieCarteMere + CarteParallele)

Code1,CarteMere1 = Assemblage(TasDeCarte,CopieCarteMere + rotationHorizontale(CarteParallele))

// On regarde si l'une des deux possibilité fonctionne

Si Code1 vaut 2

retourne 2,CarteMere1

Fin si

Si Code vaut 2

retourne 2,CarteMere

Fin Si

// Sinon aucun assemblage est bon

retourne 0,CarteMere

Fin si

// Cas 6 : Code vaut 1 On continue l'assemblage en appelant une nouvelle instance de l'algorithme.

Si Code vaut 1

retourne Assemblage(TasDeCarte,CarteMere)

Fin si

###FIN