8.9 KiB
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