From c2b43271a5cc862672b58af26fb2f375ef21021c Mon Sep 17 00:00:00 2001
From: cldupland <clement.dupland@etu.uca.fr>
Date: Wed, 18 Dec 2019 14:48:36 +0100
Subject: [PATCH] Ajout de commentaire

---
 OrderStacks/model/Card/Card.cs                | 19 ++++++--
 .../model/Card/cardType/ClassicCard.cs        |  8 +++-
 .../model/Card/cardType/FractionCard.cs       | 13 +++++-
 .../model/Card/rapidCard/EndGameCard.cs       |  8 +++-
 OrderStacks/model/Card/rapidCard/RapidCard.cs |  4 ++
 OrderStacks/model/Card/rapidCard/ThreeCard.cs |  8 +++-
 OrderStacks/model/Fraction.cs                 | 31 +++++++++++++
 OrderStacks/model/Parametreur.cs              | 18 ++++++++
 OrderStacks/model/Player.cs                   | 26 ++++++++++-
 OrderStacks/model/deck/CentaineDeck.cs        |  8 +++-
 OrderStacks/model/deck/ClassicDeck.cs         |  8 +++-
 OrderStacks/model/deck/Decimal1.cs            |  8 +++-
 OrderStacks/model/deck/Decimal2.cs            |  8 +++-
 OrderStacks/model/deck/Deck.cs                | 30 +++++++++++--
 OrderStacks/model/deck/DizaineDeck.cs         |  8 +++-
 OrderStacks/model/deck/FractionDeck.cs        |  9 ++--
 OrderStacks/model/deck/MilliemeDeck.cs        |  8 +++-
 OrderStacks/model/deck/RelativeDeck.cs        |  8 +++-
 .../model/event/HandCardChangeEventArgs.cs    |  5 +++
 .../model/event/PlayerChangedEventArgs.cs     |  7 ++-
 .../model/event/TopRangeChangedEventArgs.cs   |  8 +++-
 .../gameActions/abstractRules/GameAction.cs   |  5 +++
 .../gameActions/abstractRules/GameMode.cs     | 25 ++++++++++-
 OrderStacks/model/manager/GameManager.cs      | 37 ++++++++++++++--
 .../model/manager/MultiplayerGameManager.cs   |  4 ++
 OrderStacks/model/manager/SoloGameManager.cs  |  5 ++-
 .../manager/multiplayer/LocalGameManager.cs   |  9 ----
 .../manager/multiplayer/RemoteGameManager.cs  |  4 ++
 OrderStacks/model/piles/ClassicPiles.cs       |  6 ++-
 OrderStacks/model/piles/FractionPiles.cs      |  5 +++
 OrderStacks/model/piles/Piles.cs              | 12 +++++
 OrderStacks/model/piles/Piles0To1.cs          |  5 +++
 OrderStacks/model/piles/Piles0To10.cs         |  5 +++
 OrderStacks/model/piles/PilesMoins50To50.cs   |  5 +++
 OrderStacks/model/piles/PilesMoins5To5.cs     |  6 ++-
 OrderStacks/view/MainPage.xaml.cs             | 44 ++++++++++++-------
 OrderStacks/view/TouchManipulationCard.cs     | 30 +++++++++----
 OrderStacks/viewmodel/CardVM.cs               |  2 +
 OrderStacks/viewmodel/FractionCardVM.cs       |  4 +-
 OrderStacks/viewmodel/Main.cs                 |  8 ++++
 OrderStacks/viewmodel/PlayerVM.cs             |  4 ++
 41 files changed, 407 insertions(+), 68 deletions(-)
 delete mode 100644 OrderStacks/model/manager/multiplayer/LocalGameManager.cs

diff --git a/OrderStacks/model/Card/Card.cs b/OrderStacks/model/Card/Card.cs
index 05a0af2..4a0cda2 100644
--- a/OrderStacks/model/Card/Card.cs
+++ b/OrderStacks/model/Card/Card.cs
@@ -1,12 +1,16 @@
-using System;
-using System.ComponentModel;
-
-namespace OrderStacks.model.card
+namespace OrderStacks.model.card
 {
     public abstract class Card
     {
+        /**
+         * Valeur de la carte
+         */
         public decimal Value { get; set; }
 
+        /**
+         * <param name="value">Valeur de la carte</param>
+         * Constructeur
+         */
         public Card(decimal value)
         {
             Value = value;
@@ -17,7 +21,14 @@ namespace OrderStacks.model.card
             return Value.ToString();
         }
 
+        /**
+         * Fonction permettant de retourner le nom du type de carte
+         */
         public abstract string getName();
+
+        /**
+         * Fonction permettant d'activer les effets rapides
+         */
         public abstract bool rapidEffect();
 
     }
diff --git a/OrderStacks/model/Card/cardType/ClassicCard.cs b/OrderStacks/model/Card/cardType/ClassicCard.cs
index f8c5374..70cc645 100644
--- a/OrderStacks/model/Card/cardType/ClassicCard.cs
+++ b/OrderStacks/model/Card/cardType/ClassicCard.cs
@@ -2,9 +2,15 @@
 {
     public class ClassicCard : Card
     {
-
+        /**
+         * Type de carte
+         */
         public static readonly string CARD_CLASSIC = "ClassicCard";
 
+        /**
+         * <param name="value">Valeur de la carte</param>
+         * Constructeur
+         */
         public ClassicCard(decimal value)
             : base(value)
         {
diff --git a/OrderStacks/model/Card/cardType/FractionCard.cs b/OrderStacks/model/Card/cardType/FractionCard.cs
index 4fa2fb1..39a0740 100644
--- a/OrderStacks/model/Card/cardType/FractionCard.cs
+++ b/OrderStacks/model/Card/cardType/FractionCard.cs
@@ -5,9 +5,20 @@ namespace OrderStacks.model.card.cardType
     public class FractionCard : Card
     {
 
+        /**
+         * Type de carte
+         */
         public static readonly string CARD_FRACTION = "FractionCard";
+
+        /**
+         * Fraction que représente la carte
+         */
         public Fraction Fraction { get; set; }
 
+        /**
+         * <param name="value">Fraction qui est représenté sur la carte</param>
+         * Constructeur
+         */
         public FractionCard(Fraction value) : base(value.Result())
         {
             Fraction = value;
@@ -18,7 +29,7 @@ namespace OrderStacks.model.card.cardType
             return false;
         }
 
-        override public String getName()
+        override public string getName()
         {
             return CARD_FRACTION;
         }
diff --git a/OrderStacks/model/Card/rapidCard/EndGameCard.cs b/OrderStacks/model/Card/rapidCard/EndGameCard.cs
index 6fa6409..838b254 100644
--- a/OrderStacks/model/Card/rapidCard/EndGameCard.cs
+++ b/OrderStacks/model/Card/rapidCard/EndGameCard.cs
@@ -4,9 +4,15 @@ namespace OrderStacks.model.card.rapidCard
 {
     public class EndGameCard : RapidCard
     {
-
+        /**
+         * Type de carte
+         */
         public static readonly string CARD_ENDGAME = "EndGameCard";
 
+        /**
+         * <param name="value">Valeur de la carte</param>
+         * Constructeur
+         */
         public EndGameCard(int value)
             :base(value)
         {
diff --git a/OrderStacks/model/Card/rapidCard/RapidCard.cs b/OrderStacks/model/Card/rapidCard/RapidCard.cs
index 48feea6..aa412ad 100644
--- a/OrderStacks/model/Card/rapidCard/RapidCard.cs
+++ b/OrderStacks/model/Card/rapidCard/RapidCard.cs
@@ -4,6 +4,10 @@ namespace OrderStacks.model.card.rapidCard
 {
     public abstract class RapidCard : Card
     {
+        /**
+         * <param name="value">Valeur de la carte</param>
+         * Constructeur
+         */
         public RapidCard(int value) : base(value)
         {
         }
diff --git a/OrderStacks/model/Card/rapidCard/ThreeCard.cs b/OrderStacks/model/Card/rapidCard/ThreeCard.cs
index 1720609..b9cec86 100644
--- a/OrderStacks/model/Card/rapidCard/ThreeCard.cs
+++ b/OrderStacks/model/Card/rapidCard/ThreeCard.cs
@@ -4,9 +4,15 @@ namespace OrderStacks.model.card.rapidCard
 {
     public class ThreeCard : RapidCard
     {
-
+        /**
+         * Type de carte
+         */
         public static readonly string CARD_THREE = "ThreeCard";
 
+        /**
+         * <param name="value">Valeur de la carte</param>
+         * Constructeur
+         */
         public ThreeCard(int value)
             :base(value)
         {
diff --git a/OrderStacks/model/Fraction.cs b/OrderStacks/model/Fraction.cs
index 1c398b5..ee5c6bb 100644
--- a/OrderStacks/model/Fraction.cs
+++ b/OrderStacks/model/Fraction.cs
@@ -8,6 +8,13 @@ namespace OrderStacks.model
         public int Denominateur;
         public int SizeMax;
 
+        /**
+         * <param name="numerateur">Numérateur de la fraction</param>
+         * <param name="denominateur">Dénominateur de la fraction</param>
+         * <param name="sizeMax">Nombre maximal de chiffre présent dans la fraction</param>
+         *
+         * Constructeur
+         */
         public Fraction(int numerateur, int denominateur, int sizeMax)
         {
             Numerateur = numerateur;
@@ -15,6 +22,11 @@ namespace OrderStacks.model
             SizeMax = sizeMax;
         }
 
+        /**
+         * <param name="fraction">Fraction testé</param>
+         *
+         * Fonction de permettant de regarder si deux fractions sont multiple sans posséder le même chiffre ou un numérateur/dénominateur égale à 1
+         */
         public bool isMultiple(Fraction fraction)
         {
             bool numIsZero = false;
@@ -81,6 +93,13 @@ namespace OrderStacks.model
             return false;
         }
 
+        /**
+         * <param name="fraction">Fraction testé</param>
+         *
+         * Fonction permettant de savoir si deux fractions paossèdent des diviseurs commums
+         *
+         * <returns>Booléen de possession de diviseur commun</returns>
+         */
         public bool testDiviseurCommun(Fraction fraction)
         {
             if (PGCD(Numerateur, fraction.Numerateur) == Numerateur || PGCD(Denominateur, fraction.Denominateur) == Denominateur)
@@ -90,6 +109,13 @@ namespace OrderStacks.model
             return false;
         }
 
+        /**
+         * <param name="a">Numérateur</param>
+         *
+         * Fonction permettant de retourner le PGCD (Plus Grand Commun Diviseur) de deux fractions
+         *
+         * <returns>Plus Grand Commun Diviseur</returns>
+         */
         private int PGCD(int a, int b)
         {
             int temp = a % b;
@@ -98,6 +124,11 @@ namespace OrderStacks.model
             return PGCD(b, temp);
         }
 
+        /**
+         * Fonction permettant d'obtenir la valeur décimale de la fraction
+         *
+         * <returns>Valeur décimale de la fraction</returns>
+         */
         public decimal Result()
         {
             decimal result = (decimal)Numerateur / (decimal)Denominateur;
diff --git a/OrderStacks/model/Parametreur.cs b/OrderStacks/model/Parametreur.cs
index 3392f5b..ee6a82d 100644
--- a/OrderStacks/model/Parametreur.cs
+++ b/OrderStacks/model/Parametreur.cs
@@ -10,17 +10,30 @@ namespace OrderStacks.model
         public List<Player> players = new List<Player>();
         public int NbPlayer { get; set; }
 
+        /**
+         * <param name="gameMode">Mode de jeu utilisé</param>
+         * 
+         * Constructeur
+         */
         public Parametreur(GameMode gameMode)
         {
             GameMode = gameMode;
         }
 
+        /**
+         * Fonction permettant de préparer le jeu
+         */
         public void Prepare()
         {
             NbPlayer = players.Count;
             GameMode.load(NbPlayer, players);
         }
 
+        /**
+         *<param name="player">Joueur à ajouter</param>
+         * 
+         * Fonction permettant d'ajouter un joueur
+         */
         public void AddPlayer(Player player)
         {
             if (player != null)
@@ -29,6 +42,11 @@ namespace OrderStacks.model
             }
         }
 
+        /**
+         * Fonction permettant de retourner le nombre de cartes restantes à jouer
+         *
+         * <returns>Nombre de carte restante à jouer</returns>
+         */
         public string getScore()
         {
             int score = GameMode.getScore();
diff --git a/OrderStacks/model/Player.cs b/OrderStacks/model/Player.cs
index 944e371..8cd0d23 100644
--- a/OrderStacks/model/Player.cs
+++ b/OrderStacks/model/Player.cs
@@ -12,12 +12,21 @@ namespace OrderStacks.model
         private List<Card> cardList = new List<Card>();
         public event EventHandler<HandCardChangedEventArgs> HandCardChanged;
 
-
+        /**
+         *<param name="pseudo">Pseudo du joueur</param>
+         *
+         * Constructeur
+         */
         public Player(string pseudo)
         {
             Pseudo = pseudo;
         }
 
+        /**
+         * <param name="card">Carte pioché</param>
+         *
+         * Fonction permettant d'ajouter une carte pioché à la main de l'utilisateur
+         */
         public void pioche(Card card)
         {
             cardList.Add(card);
@@ -25,6 +34,11 @@ namespace OrderStacks.model
             OnCardDrawable(new HandCardChangedEventArgs(card, position));
         }
 
+        /**
+         * <param name="card">Carte joué</param>
+         *
+         * Fonction permettant de jouer une carte de la main du joueur
+         */
         public void joue(Card card)
         {
             int position = cardList.IndexOf(card);
@@ -37,11 +51,21 @@ namespace OrderStacks.model
         //     return cardList.AsReadOnly();
         //}
 
+        /**
+         * Fonction permettant de retourner la liste de carte du joueur
+         *
+         * <returns>Liste de cartes</returns>
+         */
         public List<Card> getCardList()
         {
             return cardList;
         }
 
+        /**
+         * <param name="args">Argument de l'événement</param>
+         *
+         * Evénement permettant de notifier que la main a changé
+         */
         protected internal void OnCardDrawable(HandCardChangedEventArgs args)
         {
             HandCardChanged?.Invoke(this, args);
diff --git a/OrderStacks/model/deck/CentaineDeck.cs b/OrderStacks/model/deck/CentaineDeck.cs
index bad555e..a8bd3a2 100644
--- a/OrderStacks/model/deck/CentaineDeck.cs
+++ b/OrderStacks/model/deck/CentaineDeck.cs
@@ -5,6 +5,12 @@ namespace OrderStacks.model.deck
 {
     public class CentaineDeck : Deck
     {
+        /**
+         * <param name="borneMin">Valeur minimale du deck</param>
+         * <param name="borneMax">Valeur maximale du deck</param>
+         * <param name="nbCard">Nombre de carte dans le deck</param>
+         * Constructeur
+         */
         public CentaineDeck(int nbCard, decimal borneMin, decimal borneMax) : base(nbCard)
         {
             Random random = new Random();
@@ -13,7 +19,7 @@ namespace OrderStacks.model.deck
             while (deck.Count < nbCard && deck.Count < (borneMaxRandom - borneMinRandom))
             {
                 int value = random.Next(borneMinRandom, borneMaxRandom);
-                InsertionDichotomique(deck, 0, deck.Count-1, new FractionCard(new Fraction(value, 100, 3)));
+                InsertionDichotomique(0, deck.Count-1, new FractionCard(new Fraction(value, 100, 3)));
             }
         }
     }
diff --git a/OrderStacks/model/deck/ClassicDeck.cs b/OrderStacks/model/deck/ClassicDeck.cs
index 793ae76..cdbd321 100644
--- a/OrderStacks/model/deck/ClassicDeck.cs
+++ b/OrderStacks/model/deck/ClassicDeck.cs
@@ -5,13 +5,19 @@ namespace OrderStacks.model.deck
 {
     public class ClassicDeck : Deck
     {
+        /**
+         * <param name="borneMin">Valeur minimale du deck</param>
+         * <param name="borneMax">Valeur maximale du deck</param>
+         * <param name="nbCard">Nombre de carte dans le deck</param>
+         * Constructeur
+         */
         public ClassicDeck(int nbCard, int borneMin, int borneMax) : base(nbCard)
         {
             Random random = new Random();
             while (deck.Count < nbCard && deck.Count < (borneMax - borneMin))
             {
                 int value = random.Next(borneMin, borneMax);
-                InsertionDichotomique(deck, 0, deck.Count-1, new ClassicCard(value));
+                InsertionDichotomique(0, deck.Count-1, new ClassicCard(value));
             }
         }
     }
diff --git a/OrderStacks/model/deck/Decimal1.cs b/OrderStacks/model/deck/Decimal1.cs
index 5f2174f..6374043 100644
--- a/OrderStacks/model/deck/Decimal1.cs
+++ b/OrderStacks/model/deck/Decimal1.cs
@@ -5,13 +5,19 @@ namespace OrderStacks.model.deck
 {
     public class Decimal1Deck : Deck
     {
+        /**
+         * <param name="borneMin">Valeur minimale du deck</param>
+         * <param name="borneMax">Valeur maximale du deck</param>
+         * <param name="nbCard">Nombre de carte dans le deck</param>
+         * Constructeur
+         */
         public Decimal1Deck(int nbCard, int borneMin, int borneMax) : base(nbCard)
         {
             Random random = new Random();
             while (deck.Count < nbCard && deck.Count < (borneMax - borneMin))
             {
                 decimal value = random.Next(borneMin, borneMax) * 0.1m;
-                InsertionDichotomique(deck, 0, deck.Count - 1, new ClassicCard(value));
+                InsertionDichotomique(0, deck.Count - 1, new ClassicCard(value));
             }
         }
     }
diff --git a/OrderStacks/model/deck/Decimal2.cs b/OrderStacks/model/deck/Decimal2.cs
index 1fa2db0..a5123a3 100644
--- a/OrderStacks/model/deck/Decimal2.cs
+++ b/OrderStacks/model/deck/Decimal2.cs
@@ -5,13 +5,19 @@ namespace OrderStacks.model.deck
 {
     public class Decimal2Deck : Deck
     {
+        /**
+         * <param name="borneMin">Valeur minimale du deck</param>
+         * <param name="borneMax">Valeur maximale du deck</param>
+         * <param name="nbCard">Nombre de carte dans le deck</param>
+         * Constructeur
+         */
         public Decimal2Deck(int nbCard, int borneMin, int borneMax) : base(nbCard)
         {
             Random random = new Random();
             while (deck.Count < nbCard && deck.Count < (borneMax - borneMin))
             {
                 decimal value = random.Next(borneMin, borneMax) * 0.01m;
-                InsertionDichotomique(deck, 0, deck.Count - 1, new ClassicCard(value));
+                InsertionDichotomique(0, deck.Count - 1, new ClassicCard(value));
             }
         }
     }
diff --git a/OrderStacks/model/deck/Deck.cs b/OrderStacks/model/deck/Deck.cs
index c3aa45b..2cbe944 100644
--- a/OrderStacks/model/deck/Deck.cs
+++ b/OrderStacks/model/deck/Deck.cs
@@ -6,31 +6,53 @@ namespace OrderStacks.model.deck
 {
     public abstract class Deck
     {
-
         protected List<Card> deck = new List<Card>();
         protected int nbCard;
 
+        /**
+         * <param name="nbCard">Nombre de carte dans le deck</param>
+         * Constructeur
+         */
         protected Deck(int nbCard)
         {
             this.nbCard = nbCard;
         }
 
+        /**
+         * Fonction retournant le nombre de carte dans le deck
+         */
         public int size()
         {
             return deck.Count;
         }
 
+        /**
+         * <param name="index">Index supprimé</param>
+         * Fonction permettant de retirer un index du deck
+         */
         public void removeAt(int index)
         {
             deck.RemoveAt(index);
         }
 
+        /**
+         * <param name="index">Index de la carte chercher</param>
+         * Fonction retournant la carte contenu dans l'index
+         * <returns>Carte à la position chercher</returns>
+         */
         public Card getCard(int index)
         {
             return deck[index];
         }
 
-        protected void InsertionDichotomique(List<Card> deck, int start, int end, Card card)
+        /**
+         * <param name="card">Carte que l'on souhaite insérer</param>
+         * <param name="start">Début de la plage de recherche</param>
+         * <param name="end">Fin de la plage de recherche</param>
+         * Fonction permet d'insérer dichotomiquement une carte
+         * N'insére pas de carte en double
+         */
+        protected void InsertionDichotomique(int start, int end, Card card)
         {
             if (deck.Count == 0)
             {
@@ -75,12 +97,12 @@ namespace OrderStacks.model.deck
             {
                 if (comparateur < 0)
                 {
-                    InsertionDichotomique(deck, mediane, end, card);
+                    InsertionDichotomique(mediane, end, card);
                     return;
                 }
                 else
                 {
-                    InsertionDichotomique(deck, start, mediane, card);
+                    InsertionDichotomique(start, mediane, card);
                     return;
                 }
             }
diff --git a/OrderStacks/model/deck/DizaineDeck.cs b/OrderStacks/model/deck/DizaineDeck.cs
index 9afeb6e..69f8b3f 100644
--- a/OrderStacks/model/deck/DizaineDeck.cs
+++ b/OrderStacks/model/deck/DizaineDeck.cs
@@ -5,6 +5,12 @@ namespace OrderStacks.model.deck
 {
     public class DizaineDeck : Deck
     {
+        /**
+         * <param name="borneMin">Valeur minimale du deck</param>
+         * <param name="borneMax">Valeur maximale du deck</param>
+         * <param name="nbCard">Nombre de carte dans le deck</param>
+         * Constructeur
+         */
         public DizaineDeck(int nbCard, decimal borneMin, decimal borneMax) : base(nbCard)
         {
             Random random = new Random();
@@ -13,7 +19,7 @@ namespace OrderStacks.model.deck
             while (deck.Count < nbCard && deck.Count < (borneMaxRandom - borneMinRandom))
             {
                 int value = random.Next(borneMinRandom, borneMaxRandom);
-                InsertionDichotomique(deck, 0, deck.Count-1, new FractionCard(new Fraction(value, 10, 2)));
+                InsertionDichotomique(0, deck.Count-1, new FractionCard(new Fraction(value, 10, 2)));
             }
         }
     }
diff --git a/OrderStacks/model/deck/FractionDeck.cs b/OrderStacks/model/deck/FractionDeck.cs
index 62aacdb..0e9f693 100644
--- a/OrderStacks/model/deck/FractionDeck.cs
+++ b/OrderStacks/model/deck/FractionDeck.cs
@@ -7,7 +7,10 @@ namespace OrderStacks.model.deck
     {
 
         /**
-         * Fonction permettant de créer un jeu de carte pour jouer avec les fractions
+         * <param name="borneMin">Valeur minimale du deck</param>
+         * <param name="borneMax">Valeur maximale du deck</param>
+         * <param name="nbCard">Nombre de carte dans le deck</param>
+         * Constructeur
          */
         public FractionDeck(int nbCard, decimal borneMin, decimal borneMax) : base(nbCard)
         {
@@ -19,7 +22,7 @@ namespace OrderStacks.model.deck
                 {
                     if (deck.Count < nbCard)
                     {
-                        InsertionDichotomique(deck, 0, deck.Count - 1, new FractionCard(new Fraction(i, j, 2)));
+                        InsertionDichotomique(0, deck.Count - 1, new FractionCard(new Fraction(i, j, 2)));
                     }
                     else
                     {
@@ -43,7 +46,7 @@ namespace OrderStacks.model.deck
                         denominateur /= pgcd;
                         pgcd = PGCD(numerateur, denominateur);
                     }
-                    InsertionDichotomique(deck, 0, deck.Count - 1, new FractionCard(new Fraction(numerateur, denominateur, 2)));
+                    InsertionDichotomique(0, deck.Count - 1, new FractionCard(new Fraction(numerateur, denominateur, 2)));
                 }
             }
         }
diff --git a/OrderStacks/model/deck/MilliemeDeck.cs b/OrderStacks/model/deck/MilliemeDeck.cs
index 24e18b0..c22bc92 100644
--- a/OrderStacks/model/deck/MilliemeDeck.cs
+++ b/OrderStacks/model/deck/MilliemeDeck.cs
@@ -5,6 +5,12 @@ namespace OrderStacks.model.deck
 {
     public class MilliemeDeck : Deck
     {
+        /**
+         * <param name="borneMin">Valeur minimale du deck</param>
+         * <param name="borneMax">Valeur maximale du deck</param>
+         * <param name="nbCard">Nombre de carte dans le deck</param>
+         * Constructeur
+         */
         public MilliemeDeck(int nbCard, decimal borneMin, decimal borneMax) : base(nbCard)
         {
             Random random = new Random();
@@ -13,7 +19,7 @@ namespace OrderStacks.model.deck
             while (deck.Count < nbCard && deck.Count < (borneMaxRandom - borneMinRandom))
             {
                 int value = random.Next(borneMinRandom, borneMaxRandom);
-                InsertionDichotomique(deck, 0, deck.Count-1, new FractionCard(new Fraction(value, 1000, 4)));
+                InsertionDichotomique(0, deck.Count-1, new FractionCard(new Fraction(value, 1000, 4)));
             }
         }
     }
diff --git a/OrderStacks/model/deck/RelativeDeck.cs b/OrderStacks/model/deck/RelativeDeck.cs
index 9b6256d..35fdd1e 100644
--- a/OrderStacks/model/deck/RelativeDeck.cs
+++ b/OrderStacks/model/deck/RelativeDeck.cs
@@ -5,13 +5,19 @@ namespace OrderStacks.model.deck
 {
     public class RelativeDeck : Deck
     {
+        /**
+         * <param name="borneMin">Valeur minimale du deck</param>
+         * <param name="borneMax">Valeur maximale du deck</param>
+         * <param name="nbCard">Nombre de carte dans le deck</param>
+         * Constructeur
+         */
         public RelativeDeck(int nbCard, int borneMin, int borneMax) : base(nbCard)
         {
             Random random = new Random();
             while (deck.Count < nbCard && deck.Count < (borneMax - borneMin))
             {
                 int value = random.Next(borneMin, borneMax);
-                InsertionDichotomique(deck, 0, deck.Count-1, new ClassicCard(value));
+                InsertionDichotomique(0, deck.Count-1, new ClassicCard(value));
             }
         }
     }
diff --git a/OrderStacks/model/event/HandCardChangeEventArgs.cs b/OrderStacks/model/event/HandCardChangeEventArgs.cs
index 36c6d76..1d64b8a 100644
--- a/OrderStacks/model/event/HandCardChangeEventArgs.cs
+++ b/OrderStacks/model/event/HandCardChangeEventArgs.cs
@@ -9,6 +9,11 @@ namespace OrderStacks.model.@event
         public Card NewCard { get; set; }
         public int Position { get; set; }
 
+        /**
+         * <param name="newCard">Nouvelle carte ajouté dans la main</param>
+         * <param name="position">Position de la carte dans la main</param>
+         * Constructeur
+         */
         public HandCardChangedEventArgs(Card newCard, int position)
         {
             NewCard = newCard;
diff --git a/OrderStacks/model/event/PlayerChangedEventArgs.cs b/OrderStacks/model/event/PlayerChangedEventArgs.cs
index 2fa39ac..bb68cdc 100644
--- a/OrderStacks/model/event/PlayerChangedEventArgs.cs
+++ b/OrderStacks/model/event/PlayerChangedEventArgs.cs
@@ -7,9 +7,14 @@ namespace OrderStacks.model.@event
     public class PlayerChangedEventArgs : EventArgs
     {
 
-        public String Pseudo;
+        public string Pseudo;
         public List<Card> NewCurrentHand;
 
+        /**
+         * <param name="newCurrentHand">Nouvelle liste de carte active</param>
+         * <param name="pseudo">Pseudo du nouvelle utilisateur actif</param>
+         * Constructeur
+         */
         public PlayerChangedEventArgs(List<Card> newCurrentHand, string pseudo)
         {
             NewCurrentHand = newCurrentHand;
diff --git a/OrderStacks/model/event/TopRangeChangedEventArgs.cs b/OrderStacks/model/event/TopRangeChangedEventArgs.cs
index 7e21359..49e0e49 100644
--- a/OrderStacks/model/event/TopRangeChangedEventArgs.cs
+++ b/OrderStacks/model/event/TopRangeChangedEventArgs.cs
@@ -10,7 +10,13 @@ namespace OrderStacks.model.@event
         public Card OldTopRangeCard { get; set; }
         public int NumStackChanged { get; set; }
 
-        public TopRangeChangedEventArgs(Card newTopRangeCard, Card oldTopRangeCard, int numStackChanged)
+        /**
+         * <param name="numStackChanged">Index de la pile changé</param>
+         * <param name="newTopRangeCard">Nouvelle carte en haut de la pile</param>
+         * <param name="oldTopRangeCard">Ancienne carte en haut de la pile</param>
+         * Constructeur
+         */
+        public TopRangeChangedEventArgs(int numStackChanged, Card newTopRangeCard, Card oldTopRangeCard)
         {
             NewTopRangeCard = newTopRangeCard;
             OldTopRangeCard = oldTopRangeCard;
diff --git a/OrderStacks/model/gameActions/abstractRules/GameAction.cs b/OrderStacks/model/gameActions/abstractRules/GameAction.cs
index c05a1bb..e282202 100644
--- a/OrderStacks/model/gameActions/abstractRules/GameAction.cs
+++ b/OrderStacks/model/gameActions/abstractRules/GameAction.cs
@@ -8,6 +8,11 @@ namespace OrderStacks.model.gameActions.abstractRules
         protected Piles ListOrderedStacks { get; set; }
         public string ErrorMessage { get; set; } = "";
 
+        /**
+         *<param name="listOrderedStacks">Piles de jeu</param>
+         * 
+         * Constructeur
+         */
         protected GameAction(Piles listOrderedStacks)
         {
             ListOrderedStacks = listOrderedStacks;
diff --git a/OrderStacks/model/gameActions/abstractRules/GameMode.cs b/OrderStacks/model/gameActions/abstractRules/GameMode.cs
index 8384623..6109c9f 100644
--- a/OrderStacks/model/gameActions/abstractRules/GameMode.cs
+++ b/OrderStacks/model/gameActions/abstractRules/GameMode.cs
@@ -33,7 +33,12 @@ namespace OrderStacks.model.gameActions.abstractRules
 
         #endregion
 
-
+        /**
+         * <param name="deck">Deck de carte</param>
+         * <param name="piles">Piles du jeu</param>
+         *
+         * Constructeur
+         */
         protected GameMode(Piles piles, Deck deck)
         {
             gameActions = new List<GameAction>();
@@ -41,6 +46,12 @@ namespace OrderStacks.model.gameActions.abstractRules
             this.deck = deck;
         }
 
+        /**
+         * <param name="nbPlayer">Nombre de joueur</param>
+         * <param name="players">Pseudo du/des joueur(s)</param>
+         * 
+         * Fonction permettant de charger les paramètres de jeu
+         */
         public abstract void load(int nbPlayer, List<Player> players);
 
         protected void defineNbMaxCard(int nbPlayer)
@@ -62,6 +73,13 @@ namespace OrderStacks.model.gameActions.abstractRules
             }
         }
 
+        /**
+         * <param name="ar">Liste de carte</param>
+         * <param name="start">Index de départ</param>
+         * <param name="end">Index de fin</param>
+         * 
+         * Fonction de tri
+         */
         protected void quickSort(List<Card> ar, int start, int end)
         {
             if (start < end)
@@ -89,6 +107,11 @@ namespace OrderStacks.model.gameActions.abstractRules
             }
         }
 
+        /**
+         *
+         *
+         *
+         */
         protected void distribueCard(List<Player> players)
         {
             players.ForEach(player =>
diff --git a/OrderStacks/model/manager/GameManager.cs b/OrderStacks/model/manager/GameManager.cs
index f595a93..1d24e1b 100644
--- a/OrderStacks/model/manager/GameManager.cs
+++ b/OrderStacks/model/manager/GameManager.cs
@@ -11,8 +11,6 @@ namespace OrderStacks.model.manager
     public abstract class GameManager: INotifyPropertyChanged
     {
 
-        /* GameMaster implémente un mode de jeu (classe fille de gameMode qui connait les actions a effectué en fonction du mode de jeu */
-
         protected Parametreur parametreur;
         protected List<Card> CurrentCardPlayed = new List<Card>();
         public string EndMessage { get; set; } = "";
@@ -34,14 +32,29 @@ namespace OrderStacks.model.manager
         public event EventHandler<EventArgs> EndGame;
         public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
         public event PropertyChangedEventHandler PropertyChanged;
+        /**
+         * <param name="info">Nom de la propriété qui change</param>
+         * Evénement permettant de notifier qu'une propriété a changé
+         */
         public virtual void OnPropertyChanged(string info)
         {
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(info));
         }
+        /**
+         * <param name="args">Argument(s) de l'événement</param>
+         * <param name="source">Source de l'événement</param>
+         * Evenement permettant de notifier la fin du jeu
+         */
         public void OnEndGame(object source, EventArgs args)
         {
             EndGame?.Invoke(source, args);
         }
+
+        /**
+         * <param name="args">Argument(s) de l'événement</param>
+         * <param name="source">Source de l'événement</param>
+         * Evenement permettant de changer de joueur actif
+         */
         protected internal void OnPlayerChanged(object source, PlayerChangedEventArgs args)
         {
             currentIndexPlayer += 1;
@@ -77,7 +90,10 @@ namespace OrderStacks.model.manager
         #endregion
 
 
-
+        /**
+         * <param name="parametreur">Parametreur de la partie</param>
+         * Constructeur
+         */
         protected GameManager(Parametreur parametreur)
         {
             this.parametreur = parametreur;
@@ -92,7 +108,12 @@ namespace OrderStacks.model.manager
         }
 
         
-
+        /**
+         * <param name="orderedStackSelected">Pile sélectionnée pour essayer de poser la carte</param>
+         *<param name="valueCard">Valeur de la carte séléctionnée</param>
+         * Fonction permettant de tenter de jouer une carte
+         * <return>Booléen de carte joué</return>
+         */
         public bool joue(int orderedStackSelected, decimal valueCard)
         {
             bool isPlayed = parametreur.GameMode.playCard(valueCard, currentHand, orderedStackSelected, parametreur.players[currentIndexPlayer], CurrentCardPlayed); // Mettre le joueur actif
@@ -100,6 +121,10 @@ namespace OrderStacks.model.manager
             return isPlayed;
         }
 
+        /**
+         * Fonction permettant de terminer son tour et notifier si le jeu est fini
+         * <returns>Booléen de fin de jeu</returns>
+         */
         public bool endTurn()
         {
             if(parametreur.GameMode.endTurn(currentHand, CurrentCardPlayed, parametreur.players[currentIndexPlayer]))
@@ -120,6 +145,10 @@ namespace OrderStacks.model.manager
             }
         }
 
+        /**
+         * Fonction permettant de retourner les piles
+         * <returns>Piles du jeu</returns>
+         */
         public Piles getPiles()
         {
             return parametreur.GameMode.Piles;
diff --git a/OrderStacks/model/manager/MultiplayerGameManager.cs b/OrderStacks/model/manager/MultiplayerGameManager.cs
index 81c8fa0..cf910f4 100644
--- a/OrderStacks/model/manager/MultiplayerGameManager.cs
+++ b/OrderStacks/model/manager/MultiplayerGameManager.cs
@@ -2,6 +2,10 @@
 {
     public abstract class MultiplayerGameManager : GameManager
     {
+        /**
+         * <param name="parametreur">Parametreur de la partie</param>
+         * Constructeur
+         */
         protected MultiplayerGameManager(Parametreur parametreur) : base(parametreur)
         {
         }
diff --git a/OrderStacks/model/manager/SoloGameManager.cs b/OrderStacks/model/manager/SoloGameManager.cs
index 47346cc..a4aec9c 100644
--- a/OrderStacks/model/manager/SoloGameManager.cs
+++ b/OrderStacks/model/manager/SoloGameManager.cs
@@ -2,7 +2,10 @@ namespace OrderStacks.model.manager
 {
     public class SoloGameManager : GameManager
     {
-
+        /**
+         * <param name="parametreur">Parametreur de la partie</param>
+         * Constructeur
+         */
         public SoloGameManager(Parametreur parametreur)
             : base(parametreur)
         {
diff --git a/OrderStacks/model/manager/multiplayer/LocalGameManager.cs b/OrderStacks/model/manager/multiplayer/LocalGameManager.cs
deleted file mode 100644
index c6b07f6..0000000
--- a/OrderStacks/model/manager/multiplayer/LocalGameManager.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-namespace OrderStacks.model.manager
-{
-    public class LocalGameManager : MultiplayerGameManager
-    {
-        public LocalGameManager(Parametreur parametreur) : base(parametreur)
-        {
-        }
-    }
-}
diff --git a/OrderStacks/model/manager/multiplayer/RemoteGameManager.cs b/OrderStacks/model/manager/multiplayer/RemoteGameManager.cs
index d1ff34a..382352b 100644
--- a/OrderStacks/model/manager/multiplayer/RemoteGameManager.cs
+++ b/OrderStacks/model/manager/multiplayer/RemoteGameManager.cs
@@ -2,6 +2,10 @@
 {
     public class RemoteGameManager : MultiplayerGameManager
     {
+        /**
+         * <param name="parametreur">Parametreur de la partie</param>
+         * Constructeur
+         */
         public RemoteGameManager(Parametreur parametreur) : base(parametreur)
         {
         }
diff --git a/OrderStacks/model/piles/ClassicPiles.cs b/OrderStacks/model/piles/ClassicPiles.cs
index e459e6d..3fd2e24 100644
--- a/OrderStacks/model/piles/ClassicPiles.cs
+++ b/OrderStacks/model/piles/ClassicPiles.cs
@@ -4,7 +4,11 @@ namespace OrderStacks.model.piles
 {
     public class ClassicPiles : Piles
     {
-
+        /**
+         * <param name="nbPile">Nombre de pile</param>
+         *
+         * Constructeur
+         */
         public ClassicPiles(int nbPile) : base(nbPile)
         {
             for (int i = 0; i < nbPile; i++)
diff --git a/OrderStacks/model/piles/FractionPiles.cs b/OrderStacks/model/piles/FractionPiles.cs
index d6463df..7753847 100644
--- a/OrderStacks/model/piles/FractionPiles.cs
+++ b/OrderStacks/model/piles/FractionPiles.cs
@@ -4,6 +4,11 @@ namespace OrderStacks.model.piles
 {
     public class FractionPiles : Piles
     {
+        /**
+         * <param name="nbPile">Nombre de pile</param>
+         *
+         * Constructeur
+         */
         public FractionPiles(int nbPile) : base(nbPile)
         {
             for (int i = 0; i < nbPile; i++)
diff --git a/OrderStacks/model/piles/Piles.cs b/OrderStacks/model/piles/Piles.cs
index 2fb1842..69a6130 100644
--- a/OrderStacks/model/piles/Piles.cs
+++ b/OrderStacks/model/piles/Piles.cs
@@ -9,6 +9,11 @@ namespace OrderStacks.model.piles
         protected List<Stack<Card>> ListOrderedStacks { get; set; } = new List<Stack<Card>>();
         public int Size { get; set; }
 
+        /**
+         * <param name="nbPile">Nombre de pile</param>
+         *
+         * Constructeur
+         */
         public Piles(int nbPile)
         {
             Size = nbPile;
@@ -18,6 +23,13 @@ namespace OrderStacks.model.piles
             }
         }
 
+        /**
+         * <param name="i">Index de la pile</param>
+         *
+         * Fonction permettant de retourner une pile grâce à son index
+         *
+         * <returns>Pile de carte</returns>
+         */
         public Stack<Card> getStack(int i)
         {
             return ListOrderedStacks[i];
diff --git a/OrderStacks/model/piles/Piles0To1.cs b/OrderStacks/model/piles/Piles0To1.cs
index e19b507..dbf61a7 100644
--- a/OrderStacks/model/piles/Piles0To1.cs
+++ b/OrderStacks/model/piles/Piles0To1.cs
@@ -4,6 +4,11 @@ namespace OrderStacks.model.piles
 {
     public class Piles0To1 : Piles
     {
+        /**
+         * <param name="nbPile">Nombre de pile</param>
+         *
+         * Constructeur
+         */
         public Piles0To1(int nbPile) : base(nbPile)
         {
             for (int i = 0; i < nbPile; i++)
diff --git a/OrderStacks/model/piles/Piles0To10.cs b/OrderStacks/model/piles/Piles0To10.cs
index ee2d3c9..c16111a 100644
--- a/OrderStacks/model/piles/Piles0To10.cs
+++ b/OrderStacks/model/piles/Piles0To10.cs
@@ -4,6 +4,11 @@ namespace OrderStacks.model.piles
 {
     public class Piles0To10 : Piles
     {
+        /**
+         * <param name="nbPile">Nombre de pile</param>
+         *
+         * Constructeur
+         */
         public Piles0To10(int nbPile) : base(nbPile)
         {
             for (int i = 0; i < nbPile; i++)
diff --git a/OrderStacks/model/piles/PilesMoins50To50.cs b/OrderStacks/model/piles/PilesMoins50To50.cs
index 1f4fc06..bfedd41 100644
--- a/OrderStacks/model/piles/PilesMoins50To50.cs
+++ b/OrderStacks/model/piles/PilesMoins50To50.cs
@@ -4,6 +4,11 @@ namespace OrderStacks.model.piles
 {
     public class PilesMoins51To51 : Piles
     {
+        /**
+         * <param name="nbPile">Nombre de pile</param>
+         *
+         * Constructeur
+         */
         public PilesMoins51To51(int nbPile) : base(nbPile)
         {
             for (int i = 0; i < nbPile; i++)
diff --git a/OrderStacks/model/piles/PilesMoins5To5.cs b/OrderStacks/model/piles/PilesMoins5To5.cs
index 204a27a..9825936 100644
--- a/OrderStacks/model/piles/PilesMoins5To5.cs
+++ b/OrderStacks/model/piles/PilesMoins5To5.cs
@@ -4,7 +4,11 @@ namespace OrderStacks.model.piles
 {
     public class PilesMoins5To5 : Piles
     {
-
+        /**
+         * <param name="nbPile">Nombre de pile</param>
+         *
+         * Constructeur
+         */
         public PilesMoins5To5(int nbPile) : base(nbPile)
         {
             for (int i = 0; i < nbPile; i++)
diff --git a/OrderStacks/view/MainPage.xaml.cs b/OrderStacks/view/MainPage.xaml.cs
index a3bcfa4..4f2bb57 100644
--- a/OrderStacks/view/MainPage.xaml.cs
+++ b/OrderStacks/view/MainPage.xaml.cs
@@ -33,7 +33,10 @@ namespace OrderStacks.view
         /**
          * <param name="playersNames">Liste des pseudos des joueurs</param>
          * <param name="nbPile">Nombre de piles pour jouer</param>
-         * <param name="indexMode">Version du jeu joué</param>
+         * <param name="indexMode">Version du jeu pour jouer</param>
+         * <param name="nbCard">Nombre de cartes pour jouer</param>
+         *
+         * Constructeur
          */
         public MainPage(List<string> playersNames, int nbPile, int indexMode, int nbCard)
         {
@@ -71,9 +74,10 @@ namespace OrderStacks.view
 
 
         /**
-         * Evénement permettant d'afficher les messages d'alertes générés dans le model
          * <param name="sender">Instance qui envoi l'événement</param>
          * <param name="args">Argument(s) de l'événement</param>
+         * 
+         * Evénement permettant d'afficher les messages d'alertes générés dans le model
          */
         private void OnAlertChanged(object sender, EventArgs args)
         {
@@ -86,9 +90,10 @@ namespace OrderStacks.view
 
 
         /**
-         * Evénement permettant de peindre la surface du canvas
          * <param name="sender">Instance qui envoi l'événement</param>
          * <param name="args">Arguments de l'événement</param>
+         * 
+         * Evénement permettant de peindre la surface du canvas
          */
         public void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
         {
@@ -115,10 +120,11 @@ namespace OrderStacks.view
 
 
         /**
-         * Evénement qui permet de gérer le Drag and Drop.
-         * Il permet de traiter le clic, le mouvement, le relachement du clic et la fin de traitement d'un clic.
          * <param name="sender">Instance qui envoi l'événement</param>
          * <param name="args">Arguments de l'événement</param>
+         * 
+         * Evénement qui permet de gérer le Drag and Drop.
+         * Il permet de traiter le clic, le mouvement, le relachement du clic et la fin de traitement d'un clic.
          */
         public void OnTouchEffectAction(object sender, TouchActionEventArgs args)
         {
@@ -176,7 +182,7 @@ namespace OrderStacks.view
                     break;
 
                 case TouchActionType.Released:
-
+                    break;
 
                 case TouchActionType.Cancelled:
                     if (textDictionary.ContainsKey(args.Id))
@@ -216,7 +222,7 @@ namespace OrderStacks.view
 
 
         /**
-         * Fonction permettant de déployer visuellement les piles
+         * Fonction permettant de placer les piles (piles non dessinées)
          */
         private void InflateStack()
         {
@@ -271,7 +277,7 @@ namespace OrderStacks.view
 
 
         /**
-         * Fonction permettant de déployer visuellement les cartes contenues dans la main du joueur actif
+         * Fonction permettant de placer les cartes contenues dans la main du joueur actif (cartes non dessinées)
          */
         private void InflateHand()
         {
@@ -314,9 +320,10 @@ namespace OrderStacks.view
 
 
         /**
-         * Evénement traitant la fin du jeu
          * <param name="sender">Instance qui envoi l'événement</param>
          * <param name="args">Argument(s) de l'événement</param>
+         * 
+         * Evénement traitant la fin du jeu
          */
         private void OnEndGame(object sender, EventArgs args)
         {
@@ -334,9 +341,11 @@ namespace OrderStacks.view
         }
 
         /**
-         * Fonction permettant de lancer le déplacement d'une carte sur une pile
          * <param name="numStack">Index de la pile joué</param>
          * <param name="value">Valeur de la carte joué</param>
+         * 
+         * Fonction permettant de tenter de jouer une carte
+         * 
          * <returns>Booléen qui indique si la carte a pu être joué</returns>
          */
         private bool Played(int numStack, decimal value)
@@ -351,9 +360,10 @@ namespace OrderStacks.view
 
 
         /**
-         * Evénement permettant de relancer le jeu avec les mêmes paramètres de jeu
          * <param name="sender">Instance qui envoi l'événement</param>
-         * <param name="args">Argument de l'événement</param>
+         * <param name="args">Argument(s) de l'événement</param>
+         * 
+         * Evénement permettant de relancer le jeu avec les mêmes paramètres
          */
         private void Retry(object sender, EventArgs args)
         {
@@ -389,9 +399,10 @@ namespace OrderStacks.view
 
 
         /**
-         * Evénement permettant de lancer la fin du tour d'un joueur
          * <param name="sender">Instance qui envoi l'événement</param>
-         * <param name="args">Argument de l'événement</param>
+         * <param name="args">Argument(s) de l'événement</param>
+         * 
+         * Evénement permettant de lancer la fin du tour d'un joueur
          */
         private async void EndTurn(object sender, EventArgs args)
         {
@@ -413,9 +424,10 @@ namespace OrderStacks.view
 
 
         /**
-         * Evénement permettant de naviguer entre les différentes pages de l'application
          * <param name="sender">Instance qui envoi l'événement</param>
-         * <param name="args">Argument de l'événement</param>
+         * <param name="args">Argument(s) de l'événement</param>
+         * 
+         * Evénement permettant de naviguer entre les différentes pages de l'application
          */
         private async void PlayToHome(object sender, EventArgs args)
         {
diff --git a/OrderStacks/view/TouchManipulationCard.cs b/OrderStacks/view/TouchManipulationCard.cs
index 18fe2a7..9f3039d 100644
--- a/OrderStacks/view/TouchManipulationCard.cs
+++ b/OrderStacks/view/TouchManipulationCard.cs
@@ -25,8 +25,11 @@ namespace OrderStacks.view
 
 
         /**
-         * <param name="textPaint">Objet dessiné</param>
-         * <param name="value">Carte qui est dessiné par le textPaint</param>
+         * <param name="textPaint">Objet à dessiner</param>
+         * <param name="value">Carte dessinée dans le textPaint</param>
+         * <param name="width">Taille de l'espace entre le centre de la carte et la bordure sur l'axe des x</param>
+         *
+         * Constructeur
          */
         public TouchManipulationCard(SKPaint textPaint, CardVM value, float width)
         {
@@ -37,6 +40,7 @@ namespace OrderStacks.view
 
             display = Value.ToString();
 
+            // Permet de traiter les fractions
             if (Value.GetType() == typeof(FractionCardVM))
             {
                 textPaint1 = new SKPaint();
@@ -71,9 +75,9 @@ namespace OrderStacks.view
         public SKMatrix InitialMatrix { set; get; }
 
         /**
-         * Fonction permettant de dessiner l'objet que contient l'instance dans un canvas donné avec une couleur donnée
          * <param name="canvas">Canvas où l'on souhaite dessiner l'objet contenu dans l'instance</param>
-         * <param name="color">Couleur qui sera prise par l'objet</param>
+         * 
+         * Fonction permettant de dessiner l'objet que contient l'instance dans un canvas donné
          */
         public void Paint(SKCanvas canvas)
         {
@@ -88,6 +92,7 @@ namespace OrderStacks.view
 
             SKRect card;
 
+            // Permet de traiter les fractions
             if (Value.GetType() == typeof(FractionCardVM))
             {
                 card = new SKRect(-width, -height - textPaint.TextSize, width + textPaint.MeasureText(Math.Pow(10, ((FractionCardVM)(Value)).Fraction.SizeMax-1).ToString()), height);
@@ -103,6 +108,7 @@ namespace OrderStacks.view
                 card = new SKRect(-width, -height - textPaint.TextSize, width + textPaint.MeasureText(display), height);
             }
 
+            // Permet de traiter les fractions
             if (Value.GetType() == typeof(FractionCardVM))
             {
                 int sizeMax = ((FractionCardVM)(Value)).Fraction.SizeMax;
@@ -163,8 +169,9 @@ namespace OrderStacks.view
         }
 
         /**
-         * Fonction permettant de changer la couleur de l'objet contenu dans l'instance
          * <param name="color">Nouvelle couleur que l'on souhaite attribué à l'objet contenu dans l'instance</param>
+         * 
+         * Fonction permettant de changer la couleur de l'objet contenu dans l'instance
          */
         public void ChangeColor(SKColor color)
         {
@@ -172,8 +179,10 @@ namespace OrderStacks.view
         }
 
         /**
-         * Fonction permettant de savoir si le point qu'on lui passe est dans la zone où l'objet est dessiné
          * <param name="location">Point que l'on souhaite tester</param>
+         * 
+         * Fonction permettant de savoir si le point qu'on lui passe est dans la zone où l'objet est dessiné
+         * 
          * <returns>Booléen qui indique si le point donné est dans la zone où l'objet en instance est dessiné</returns>
          */
         public bool HitTest(SKPoint location)
@@ -188,6 +197,8 @@ namespace OrderStacks.view
 
                 // Check if it's in the untransformed bitmap rectangle
                 SKRect rect;
+
+                // Permet de traiter les fractions
                 if (Value.GetType() == typeof(FractionCardVM))
                 {
                     rect = new SKRect(-width, -height - textPaint.TextSize, width + textPaint.MeasureText(Math.Pow(10, ((FractionCardVM)(Value)).Fraction.SizeMax - 1).ToString()), height);
@@ -202,11 +213,12 @@ namespace OrderStacks.view
         }
 
         /**
+         * <param name="id">Index que l'on souhaite traiter</param>
+         * <param name="type">Type d'évenement lancé</param>
+         * <param name="location">Nouveau point</param>
+         * 
          * Evénement qui permet de gérer le Drag and Drop.
          * Il permet de traiter le clic, le mouvement, le relachement du clic et la fin de traitement d'un objet.
-         * <param name="id">Index de la position que l'on souhaite traiter</param>
-         * <param name="type">Type d'évenement lancé</param>
-         * <param name="location">Nouveau point que l'on souhaite traiter</param>
          */
         public void ProcessTouchEvent(long id, TouchActionType type, SKPoint location)
         {
diff --git a/OrderStacks/viewmodel/CardVM.cs b/OrderStacks/viewmodel/CardVM.cs
index b6ad627..f47ac74 100644
--- a/OrderStacks/viewmodel/CardVM.cs
+++ b/OrderStacks/viewmodel/CardVM.cs
@@ -22,6 +22,7 @@ namespace OrderStacks.viewmodel
 
         /**
          * <param name="info">Nom de la propriété</param>
+         * 
          * Fonction permettant de notifier qu'une propriété a changé
          */
         protected virtual void OnPropertyChanged(string info)
@@ -31,6 +32,7 @@ namespace OrderStacks.viewmodel
         
         /**
          * <param name="view">Card représenté</param>
+         * 
          * Constructeur
          */
         public CardVM(Card view)
diff --git a/OrderStacks/viewmodel/FractionCardVM.cs b/OrderStacks/viewmodel/FractionCardVM.cs
index f419946..19cc130 100644
--- a/OrderStacks/viewmodel/FractionCardVM.cs
+++ b/OrderStacks/viewmodel/FractionCardVM.cs
@@ -15,7 +15,7 @@ namespace OrderStacks.viewmodel
             get { return fraction; }
             set
             {
-                this.fraction = value;
+                fraction = value;
                 View.Fraction = value;
                 OnPropertyChanged("Value");
             }
@@ -23,6 +23,7 @@ namespace OrderStacks.viewmodel
 
         /**
          * <param name="view">FractionCard représenté</param>
+         * 
          * Constructeur
          */
         public FractionCardVM(FractionCard view) : base(view)
@@ -33,6 +34,7 @@ namespace OrderStacks.viewmodel
 
         /**
          * Fonction permettant de retourner le nombre maximum de chiffre présent en numérateur et/ou en dénominateur.
+         * 
          * <returns>Nombre maximum de chiffre présent en numérateur et/ou dénominateur</returns>
          */
         public string getDisplayMax()
diff --git a/OrderStacks/viewmodel/Main.cs b/OrderStacks/viewmodel/Main.cs
index c810161..20e3635 100644
--- a/OrderStacks/viewmodel/Main.cs
+++ b/OrderStacks/viewmodel/Main.cs
@@ -44,6 +44,7 @@ namespace OrderStacks.viewmodel
 
         /**
          * <param name="info">Nom de la propriété</param>
+         * 
          * Fonction permettant de notifier qu'une propriété a changé
          */
         protected virtual void OnPropertyChanged(string info)
@@ -69,6 +70,7 @@ namespace OrderStacks.viewmodel
          * <param name="nbCard">Nombre de carte maximal pour les piles</param>
          * <param name="nbPile">Nombre de piles</param>
          * <param name="playersNames">Pseudo(s) du/des joueur(s)</param>
+         * 
          * Constructeur
          */
         public Main(List<string> playersNames, int nbPile, int nbCard, int indexMode)
@@ -149,6 +151,7 @@ namespace OrderStacks.viewmodel
 
         /**
          * Fonction permettant de retourner une vue des piles ordonnées
+         * 
          * <returns>Vue des piles ordonnées</returns>
          */
         public IReadOnlyList<Stack<CardVM>> getListOrderedStacks()
@@ -159,6 +162,7 @@ namespace OrderStacks.viewmodel
         /**
          * <param name="source">Source de l'événement</param>
          * <param name="args">Argument(s) de l'événement</param>
+         * 
          * Evénement permettant de déclencher le changement de joueur.
          */
         protected internal void OnPlayerChanged(object source, PlayerChangedEventArgs args)
@@ -182,6 +186,7 @@ namespace OrderStacks.viewmodel
         /**
          * <param name="args">Argument(s) de l'événement</param>
          * <param name="source">Source de l'événement</param>
+         * 
          * Evénement permettant de déclencher la fin du jeu.
          */
         public void OnEndGame(object source, EventArgs args)
@@ -193,7 +198,9 @@ namespace OrderStacks.viewmodel
         /**
          * <param name="numStack">Numéro de la pile séléctionnée pour jouer</param>
          * <param name="valueCard">Valeur de la carte joué</param>
+         * 
          * Fonction permettant de demander à jouer une carte puis de retourner si elle a été joué
+         * 
          * <returns>Booléen de carte joué</returns>
          */
         public bool played(int numStack, decimal valueCard)
@@ -227,6 +234,7 @@ namespace OrderStacks.viewmodel
 
         /**
          * Fonction permettant de changer de joueur.
+         * 
          * <returns>Booléen de fin de jeu</returns>
          */
         public bool endTurn()
diff --git a/OrderStacks/viewmodel/PlayerVM.cs b/OrderStacks/viewmodel/PlayerVM.cs
index bc9fd1d..032b59d 100644
--- a/OrderStacks/viewmodel/PlayerVM.cs
+++ b/OrderStacks/viewmodel/PlayerVM.cs
@@ -13,6 +13,7 @@ namespace OrderStacks.viewmodel
 
         /**
          * <param name="view">Player représenté</param>
+         * 
          * Constructeur
          */
         public PlayerVM(Player view)
@@ -28,6 +29,7 @@ namespace OrderStacks.viewmodel
         /**
          * <param name="args">Argument(s) de l'événement</param>
          * <param name="sender">Source de l'événement</param>
+         * 
          * Evénement permettant à l'utilisateur de changer les cartes qu'il possède (supprimé et/ou piocher une carte).
          */
         private void OnHandCardChanged(object sender, HandCardChangedEventArgs args)
@@ -44,6 +46,7 @@ namespace OrderStacks.viewmodel
 
         /**
          * <param name="card">Carte piocher</param>
+         * 
          * Fonction permettant de piocher une carte
          */
         public void pioche(CardVM card)
@@ -53,6 +56,7 @@ namespace OrderStacks.viewmodel
 
         /**
          * Fonction permettant de retourner les cartes possédées par l'utilisateur.
+         * 
          * <returns>Liste des cartes possédé par l'utilisateur</returns>
          */
         public List<CardVM> getCardList()