pascal.lafourcade
/
swish
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Modification de l'algorithme + Traitement d'Execption d'assemblage

Browse Source
Golfier
Yannis 4 years ago
parent c7d93fe16b
commit fe3d21eb51
2 changed files with 192 additions and 330 deletions
Show Stats Download Patch File Download Diff File

470
SwichGIT/Doc/Algorithme/FonctionAnalyseEmpiler.md
Unescape View File

@ -1,354 +1,212 @@
# ANALYSE DE CARTE# # ANALYSE DE CARTE #
## DEFINITION DES STRUCTURES ##
### ENUMERATION FORMEFIGURE ###
- **Rond** :rond
- **Carre** :carre
- **Triangle** : triangle
- **Pentagone** : pentagone
- **Losange** : losange
---
### ENUMERATION TYPEFIGURE ###
- **Pleine** : pleine
- **Creuse** : creuse
---
### STRUCTURE FIGURE ###
### Attributs ###
- **Figure.type** : TypeFigure
- **Figure.forme** : FormeFigure
- **Figure.X** : entier
- **Figure.Y** : entier
- **Figure.HTML** : code HTML
### Méthodes ###
- **Figure.get...**: Retourne l'attributs voulus
---
###STRUCTURE CARTE ###
### Attributs ###
- **Carte.indentifiant** : entier
- **Carte.row** : eniter
- **Carte.column** : entier
- **Carte.HTML**: code HTML
- **Carte.Matrice**: entier[n][k];
- **Carte.FigurePleine** : Figure
- **Carte.FigureCreuse** : Figure
### Méthodes ###
- **Carte.carteVerticale** : obtient sa carte verticalement symétrique.
- **Carte.carteHorizontale** : obtient sa carte horizontalement symétrique.
- **Carte.get...** : Retourne l'attributs voulus
---
## COMPARAISON DE CARTE ##
**ComparaisonDeCarte(CarteMere: Carte, CarteFille: Carte)** : entier
**Entrées** :
- **CarteMere** : Carte témoin, "support" de l'assemblage, il est inutile de modifier sa structure.
- **CarteFille** : Carte sujet, "pièce" à tester sur le support.
**Objectif** : Determine si les Cartes possèdent une liaison ( FigurePleine <=> FigureCreuse )
## COMPARAISON DE CARTE## **Sortie** : entier
**ComparaisonDeCarte(CarteMere:Matrice(4,3), Carte:Matrice(4,3))** : entier **Sortie Possible :**
**Entrées** : **CarteMere** et **Carte** :Matrice(4,3) - **2** : L'assemblage est parfait ou sans contrainte (Carte NULL). **Deux liaisons** possible.
**Sortie** : entier - **1** : L'assemblage n'est pas parfait. Cependant, **Une liaison** possible.
**Objectif** : Determine si les Cartes possèdent une liaison ( point <=> cercle ) - **0** : L'assemblage est impossible. **Aucune liaison** possible.
### DEBUT###
> ###Variables locales : ### COMMENT FAIRE ###
> **Cox1,Cox2,Coy1,Coy2** des entiers - Recherhcer les coordonnées des **Figures** de **CarteMere**
> - Comparer ces coordonnées sur l'attribut **Carte.Matrice** de **CarteFille**
> --- > Si les coordonnées de **CarteMere.FigurePleine** sont égales aux coordonnées de **CarteFille.FigureCreuse** et inversement on considère ce cas comme **une liason**.
>
> **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 > Faire de même pour les autres **Figures**.
- **Retourner l'entier correspondant à la situation**
---
## COMPARAISON TOTALE DE LA CARTE
**ComparaisonTotal(CarteMere:Carte d'entiers,CarteFille:Carte, index entier)**:entier,Carte
### FIN **Entrees** :
## COMPARAISON TOTAL DE LA CARTE - **CarteMere** : Carte témoin, "support" de l'assemblage, il est inutile de modifier sa structure.
- **CarteFille** : Carte sujet, "pièce" à tester sur le support.
- **index** : entier déterminant le nombre d'itération de la fonction
**ComparaisonTotal(CarteMere:Matrice(4,3) d'entiers,CarteFille:Matrice(4,3), index entier)**:entier,Tableau(4,3) d'entiers **Objectif** : Determine si les Cartes possèdent une liaison MAIS avec toutes les possibilitées de rotation de **CarteFille**
**Entrees** : **CarteMere,CarteFille** :Matrice(4,3), **index** entier **Sortie** : entier, Carte
**Sortie** : entier,Matrice(4,3) **Sortie Possible :**
**Objectif** : Determine si les Cartes possèdent une liaison ( point <=> cercle ) MAIS avec toutes les possibilitées de rotation de **Carte** - **2,CarteMere** : L'assemblage est parfait ou sans contrainte (Carte NULL). **Deux liaisons** possible.
- **1,CarteFille** : **CarteMere** est NULL, L'assemblage est possible.
- **1,CarteMere** : L'assemblage n'est pas parfait. Cependant, **Une liaison** possible.
- **3,CarteFille** : Il existe deux possibilitées verticalement symétrique d'assemblage. On retourne la **CarteFille** qui peut s'assembler de deux façons.
- **4,CarteFille** : Il existe deux possibilitées horizontalement symétrique d'assemblage. On retourne la **CarteFille** qui peut s'assembler de deux façons.
- **-1,CarteMere** : Il est impossible d'assembler **CarteFille** avec **CarteMere**
### COMMENT FAIRE ###
- On regarde si **CarteMere** n'est pas NULL pour savoir si une comparaison d'assemblage est possible.
>Si **CarteMere** est NULL on retourne la sortie associée à ce cas (**1,CarteFille**)
###DEBUT - On regarde **index** pour savoir quelle variante de **CarteFille** (carteverticale,cartehorizontale) tester sur **CarteMere**. Si toutes les variantes ont été testées, alors on retourne **-1,CarteMere**.
>###Variables locales - On teste la variante avec la fonction **COMPARAISON DE CARTE** et on traite la sortie de cette comparaison en retournant des informations selon les cas.
### TRAITEMENT DE COMPARAISON DE CARTE ###
> **Si Sortie = 2**
> >
> **Code,Code1** des entiers > L'assemblage est parfait **CarteFille** est assemblée avec **CarteMere** et on retourne **2,CarteMere**
> >
>--- >---
>**Si Sortie = 1**
> >
>**Si** **CarteMere** est NULL alors > On reagarde si un assemblage symétrique (Verticalement ou Horizontalement) est possible.
> > S'il en existe un on retourne **la sortie associée** au différent cas.
>
>> // 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** > **Sinon**,**CarteFille** est assemblée avec **CarteMere** et on retourne **1,CarteMere**
> >
>// Si aucune liaison n'est possible, on appelle à nouveau la fonction en Incrémentant **index** >---
> >**Si Sortie = 0**
> retourne ComparaisonTotal(**CarteMere**,**CarteFille**,**index** + 1)
> >
### FIN > L'assemblage de la variante de **CarteFille** et **CarteMere** est impossible, on continue en testant **COMPARAISON_TOTAL_DE_LA_CARTE**(CarteMere,CarteFille,**index+1**)
> ---
# ASSEMBLAGE # ASSEMBLAGE #
**Assemblage(TasDeCarte: Liste Matrice(4,3),CarteMere:Matrice(4,3)** :entier, Matrice(4,3) **Assemblage(TasDeCarte: Carte[], CarteMere:Carte** :entier, Carte
**Entree** : **TasDeCarte** Liste Matrice(4,3), CarteMere Matrice(4,3) **Entree** :
**Sortie** : entier, Matrice(4,3) - **TasDeCarte** : Liste de **Carte** selectioonnées afin de tester si un assemblage valide est possible.
- **CarteMere** : Carte témoin, "support" de l'assemblage, il est inutile de modifier sa structure.
**Objectif** : Savoir si un tas de carte envoyé en paramètre peut être empiler ou non **Objectif** : Savoir si un tas de carte envoyé en paramètre peut être empiler ou non
### DEBUT **Sortie** : entier, Carte
>###Variable locale
> **Sortie Possible**
>**Carte** Matrice(4,3)
> - **2,CarteMere** : L'assemblage final est correcte.
>**CopieCarteMere** Matrice(4,3) - **0,CarteMere** : L'assemblage final n'est pas correcte.
>
>**Code** entier ### COMMENT FAIRE ###
>
>**CarteParallele** Matrice(4,3) - On regarde si la liste **TasDeCarte** n'est pas vide pour savoir si des **Cartes** doivent être encore testées.
> > Si **TasDeCarte** est vide on retourne **0,CarteMere**
>---
> - On teste avec la fonction **COMPARAISON TOTALE DE CARTE** , **CarteMere** et la tête de liste de **TasDeCarte** et on traite les différentes sorties.
>// 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
> ### TRAITEMENT DE COMPARAISON TOTALE DE LA CARTE ###
>**Si** **TasDeCarte** est NULL > **TRAITEMENT** Si **TasDeCarte** est maintenant **vide**
>
>>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** >> **Si Sortie = 2**
> >
>> // On teste les deux possibilité >> L'assemblage est valide on retourne **2,CarteMere**
> >
>> **Code**,**CarteMere** = Assemblage(**TasDeCarte**,**CopieCarteMere** + **CarteParallele**) >>---
>>**Si Sortie != 2**
> >
>> **Code1**,**CarteMere1** = Assemblage(**TasDeCarte**,**CopieCarteMere** + rotationHorizontale(**CarteParallele**)) >> Il n'y plus de carte à tester et l'assemblage n'est pas parfait. L'assemblage n'est donc pas valide on retourne **0,CarteMere**
> >
>> // On regarde si l'une des deux possibilité fonctionne >>---
> >
>>**Si** **Code1** vaut 2 > **TRAITEMENT** Si **TasDeCarte** n'est toujours **pas vide**
> >
>>> retourne **2,CarteMere1** >>>---
> >
>> **Fin si** >> **Si Sortie = 2 ou -1**
> >
>>**Si** **Code** vaut 2 >> L'assemblage est parfait ou impossible. Cependant il y a encore des cartes à tester. On ajoute donc la **Carte** contenue dans la **Sortie** de la fonction **COMPARAISON TOTALE** à la fin de la liste **TasDeCarte** et on retourne une nouvelle itération de la fonction **Assemblage** avec les variables remises à jour.
> >
>>> retourne **2,CarteMere** >>---
>>**Si Sortie = 3**
> >
>>**Fin Si** >> Il y a plusieurs possibilités verticalement symétrique d'assemblage, on va donc tester les deux cas avec **Assemblage** et les nouvelles variables. Si la sélection est correcte, il y a au moins une possibilité de bonne.
> >
>>// Sinon aucun assemblage est bon >> Sinon on retourne **0,CarteMere**
> >
>> retourne **0,CarteMere** >>---
>>**Si Sortie = 4**
> >
>**Fin si** >> Il y a plusieurs possibilités horizontalement symétrique d'assemblage, on va donc tester les deux cas avec **Assemblage** et les nouvelles variables. Si la sélection est correcte, il y a au moins une possibilité de bonne.
> >
>// Cas 6 : Code vaut 1 On continue l'assemblage en appelant une nouvelle instance de l'algorithme. >> Sinon on retourne **0,CarteMere**
> >
>**Si** Code vaut 1 >>---
> >
>> retourne Assemblage(**TasDeCarte**,**CarteMere**) >>**Si Sortie = 1**
> >
>**Fin si** >> Il y a une seule possibilité d'assemblage. On continu de tester avec **Assemblage** et les nouvelles variables.
> >
### FIN >>---

8
SwichGIT/src/js/main.js
Unescape View File

@ -415,7 +415,7 @@ function creaMatrice(row, column) {
//FONCTION DE TEST => permet de tester des fonctionnalité via le bouton VALIDER //FONCTION DE TEST => permet de tester des fonctionnalité via le bouton VALIDER
function test() { function test() {
try {
if (carteselect.length == 0) { if (carteselect.length == 0) {
window.alert("Selection Vide"); window.alert("Selection Vide");
return; return;
@ -432,11 +432,15 @@ function test() {
*/ */
var tab = assemblage(copie, null); var tab = assemblage(copie, null);
window.alert("Code Final " + tab[0]); window.alert("Code Final " + tab[0]);
if (tab[0] == 2) {
changerlesCartes(); changerlesCartes();
}
} }
} catch (e) {
window.alert("Assemblage Impossible");
}
} }
function copieListeDeCarte(Liste) { function copieListeDeCarte(Liste) {
var copie = []; var copie = [];
for (var i = 0; i < Liste.length; i++) { for (var i = 0; i < Liste.length; i++) {

Write Preview
Loading…
Cancel
Save