Mise à jour de 'README.md'

revert fix the navigation in gameboard

Qwirkle/QwirkleClassLibrary/Boards/Board.cs

@@ -53,16 +53,16 @@ namespace QwirkleClassLibrary.Boards
             {
                 for (int b = 0; b < Columns; b++)
                 {
-                    Cell localcell = new(a, b);
+                    Cell localcell = new(b, a);
                     cells.Add(localcell);
                 }
             }
         }
 
         /// <summary>
-        /// This method is used to check if a cell in the board whether it already contains a tile or not.
+        /// This method is used to check if a cell in the board whether already contains a tile or not.
         /// </summary>
-        /// <returns>Returns a boolean : true if the cell doesn't contain any tile, false if it already contains a tile.</returns>
+        /// <returns>Returns a boolean : true if the cell doesn't contain any tile, false if already contains a tile.</returns>
         public bool HasOccupiedCase()
         {
             foreach (var cell in cells)

Qwirkle/QwirkleClassLibrary/Boards/Cell.cs

@@ -4,89 +4,94 @@ using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 using QwirkleClassLibrary.Tiles;
 
-namespace QwirkleClassLibrary.Boards;
+namespace QwirkleClassLibrary.Boards
-
-[DataContract]
-public class Cell : INotifyPropertyChanged
 {
-    public event PropertyChangedEventHandler? PropertyChanged;
-
-    [DataMember]
-    private readonly int x;
-
-    [DataMember]
-    private readonly int y;
-
-    [DataMember]
-    public Tile? Tile { get; private set;}
 
     /// <summary>
-    /// This is the constructor for a Cell.
+    /// Our board is made with a list of this class. It can stock infos such as its position on the board and the tile it contains.
     /// </summary>
-    /// <param name="x">The x attribute of the cell.</param>
+    [DataContract]
-    /// <param name="y">The y attribute of the cell.</param>
+    public class Cell : INotifyPropertyChanged
-    /// <exception cref="ArgumentException">Throw an exception if the x or y attribute is negative.</exception>
-    public Cell(int x, int y)
     {
-        if (x < 0 || y < 0)
+        public event PropertyChangedEventHandler? PropertyChanged;
-        {
-            throw new ArgumentException(x.ToString() + y.ToString());
-        }
 
-        this.x = x;
+        [DataMember]
-        this.y = y;
+        private readonly int x;
-    }
 
-    /// <summary>
+        [DataMember]
-    /// A getter for the position of the cell on the x-axis.
+        private readonly int y;
-    /// </summary>
-    /// <returns>The position of the cell on the x-axis.</returns>
-    public int GetX
-    {
-        get { return x; }
-    }
 
-    /// <summary>
+        [DataMember]
-    /// A getter for the position of the cell on the y-axis.
+        public Tile? Tile { get; private set; }
-    /// </summary>
-    /// <returns>The position of the cell on the y-axis.</returns>
-    public int GetY
-    {
-        get { return y; }
-    }
 
-    /// <summary>
+        /// <summary>
-    /// Check if the Cell whether is empty or contains a tile.
+        /// This is the constructor for a Cell.
-    /// </summary>
+        /// </summary>
-    /// <returns>True if the cell is empty, false if the cell contains a tile.</returns>
+        /// <param name="x">The x attribute of the cell.</param>
-    public bool IsFree
+        /// <param name="y">The y attribute of the cell.</param>
-    {
+        /// <exception cref="ArgumentException">Throw an exception if the x or y attribute is negative.</exception>
-        get { return Tile == null; }
+        public Cell(int x, int y)
-    }
+        {
+            if (x < 0 || y < 0)
+            {
+                throw new ArgumentException(x.ToString() + y.ToString());
+            }
 
+            this.x = x;
+            this.y = y;
+        }
 
-    /// <summary>
+        /// <summary>
-    /// A setter for the tile in the cell.
+        /// A getter for the position of the cell on the x-axis.
-    /// </summary>
+        /// </summary>
-    /// <param name="addedTile">The tile the player want to add in the cell.</param>
+        /// <returns>The position of the cell on the x-axis.</returns>
-    /// <returns>True if added succefully (if the cell didn't already contain a tile), false if there already was a tile in this cell.</returns>
+        public int GetX
-    public bool SetTile(Tile addedTile)
+        {
-    {
+            get { return x; }
-        if (Tile == null)
+        }
+
+        /// <summary>
+        /// A getter for the position of the cell on the y-axis.
+        /// </summary>
+        /// <returns>The position of the cell on the y-axis.</returns>
+        public int GetY
         {
+            get { return y; }
+        }
 
-            Tile = addedTile;
+        /// <summary>
-            OnPropertyChanged(nameof(Tile));
+        /// Checks if the Cell whether is empty or contains a tile.
-            return true;
+        /// </summary>
+        /// <returns>True if the cell is empty, false if the cell contains a tile.</returns>
+        public bool IsFree
+        {
+            get { return Tile! == null!; }
         }
-        else
+
+
+        /// <summary>
+        /// A setter for the tile in the cell.
+        /// </summary>
+        /// <param name="addedTile">The tile the player want to add in the cell.</param>
+        /// <returns>True if added succefully (if the cell didn't already contain a tile), false if there already was a tile in this cell.</returns>
+        public bool SetTile(Tile addedTile)
         {
-            return false;
+            if (Tile! == null!)
+            {
+
+                Tile = addedTile;
+                OnPropertyChanged(nameof(Tile));
+                return true;
+            }
+            else
+            {
+                return false;
+            }
         }
-    }
 
-    protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
+        protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
-    {
+        {
-        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
     }
 }

Qwirkle/QwirkleClassLibrary/Games/Game.cs

@@ -7,43 +7,37 @@ using QwirkleClassLibrary.Events;
 using QwirkleClassLibrary.Players;
 using System.ComponentModel;
 using System.Runtime.CompilerServices;
-using static System.Formats.Asn1.AsnWriter;
 
 namespace QwirkleClassLibrary.Games
 {
-
+    /// <summary>
+    /// This is our main class for the Qwirkle application, taking care of the good efficiency of the game.
+    /// </summary>
     [DataContract]
     public class Game : IPlayer, IRules, INotifyPropertyChanged
     {
-        [DataMember]
+        [DataMember] private TileBag? bag = null;
-        private TileBag? bag = null;
 
-        [DataMember]
+        [DataMember] public bool GameRunning { get; set; }
-        public bool GameRunning { get; set; }
 
-        [DataMember]
+        [DataMember] private Board board = new(17, 14);
-        private Board board = new(17, 14);
 
         public bool PlayerSwapping { get; set; }
         public Board Board => board;
 
         public ReadOnlyCollection<Player> PlayerList => players.AsReadOnly();
 
-        [DataMember]
+        [DataMember] private readonly List<Player> players = [];
-        private readonly List<Player> players = [];
-
-        [DataMember]
-        private readonly Dictionary<string, int> scoreBoard = new Dictionary<string, int>();
 
+        [DataMember] private readonly Dictionary<string, int> scoreBoard = new Dictionary<string, int>();
         public ReadOnlyDictionary<string, int> ScoreBoard => scoreBoard.AsReadOnly();
 
-        private readonly ObservableCollection<KeyValuePair<string, int>> observableScoreBoard = [];
+        [DataMember] private readonly ObservableCollection<KeyValuePair<string, int>> observableScoreBoard = [];
 
         public ReadOnlyObservableCollection<KeyValuePair<string, int>> ObservableScoreBoard =>
-            new ReadOnlyObservableCollection<KeyValuePair<string, int>>(observableScoreBoard);
+            new(observableScoreBoard);
 
-        [DataMember]
+        [DataMember] private readonly List<Cell> cellUsed = [];
-        private readonly List<Cell> cellUsed = [];
 
         public ReadOnlyCollection<Cell> CellsUsed => cellUsed.AsReadOnly();
 
@@ -104,9 +98,11 @@ namespace QwirkleClassLibrary.Games
             if (playersTag.Count <= 1 || playersTag.Count > 4)
             {
                 playersTag.Clear();
-                OnPlayerNotified(new AddPlayerNotifiedEventArgs("ERROR : It takes a minimum of 2 players and a maximum of 4 players to start a game."));
+                OnPlayerNotified(new AddPlayerNotifiedEventArgs(
+                    "ERROR : It takes a minimum of 2 players and a maximum of 4 players to start a game."));
                 return false;
             }
+
             for (int i = playersTag.Count - 1; i >= 0; i--)
             {
                 if (!CheckPlayerTag(playersTag, i))
@@ -126,12 +122,18 @@ namespace QwirkleClassLibrary.Games
             OnPlayerNotified(new AddPlayerNotifiedEventArgs("Players were correctly added."));
             return true;
         }
-
+        /// <summary>
+        /// This function is used to check if the player name that the user has entered meets the criteria set by the application.
+        /// </summary>
+        /// <param name="playersTag">A list that contains all the names entered when the game was started.</param>
+        /// <param name="pos">The position of the name we want to check in this list.</param>
+        /// <returns>boolean true if everything is okay, false if there was a problem in the player name.</returns>
         public bool CheckPlayerTag(List<string> playersTag, int pos)
         {
             if (string.IsNullOrWhiteSpace(playersTag[pos]))
             {
-                OnPlayerNotified(new AddPlayerNotifiedEventArgs("ERROR with " + (pos + 1) + " entry : The name is null or white space."));
+                OnPlayerNotified(new AddPlayerNotifiedEventArgs("ERROR with " + (pos + 1) +
+                                                                " entry : The name is null or white space."));
                 return false;
             }
 
@@ -148,7 +150,6 @@ namespace QwirkleClassLibrary.Games
                         new AddPlayerNotifiedEventArgs("ERROR with " + (pos + 1) + " entry : Name alreay taken"));
                     return false;
                 }
-
             }
 
             return true;
@@ -170,13 +171,19 @@ namespace QwirkleClassLibrary.Games
         /// Returns the Board of the game
         /// </summary>
         /// <returns>Board</returns>
-        public Board? GetBoard() { return board; }
+        public Board GetBoard()
+        {
+            return board;
+        }
 
         /// <summary>
         /// Returns the tile bag of the game
         /// </summary>
         /// <returns></returns>
-        public TileBag? GetTileBag() { return bag; }
+        public TileBag? GetTileBag()
+        {
+            return bag;
+        }
 
         /// <summary>
         /// Creates a Board with a number of columns and rows
@@ -238,6 +245,7 @@ namespace QwirkleClassLibrary.Games
             {
                 throw new ArgumentException("No player currently playing !");
             }
+
             return players[GetPlayingPlayerPosition()];
         }
 
@@ -254,6 +262,7 @@ namespace QwirkleClassLibrary.Games
                     return i;
                 }
             }
+
             return -1;
         }
 
@@ -312,11 +321,10 @@ namespace QwirkleClassLibrary.Games
                     startingPlayer = player;
                 }
             }
-            
+
             startingPlayer!.IsPlaying = true;
             OnNextPlayer(new NextPlayerNotifiedEventArgs(players[0]));
             return startingPlayer.NameTag;
-
         }
 
         /// <summary>
@@ -354,13 +362,15 @@ namespace QwirkleClassLibrary.Games
                 OnPlaceTile(new PlaceTileNotifiedEventArgs(tile, "you are swapping, you can't place tile !"));
                 return false;
             }
+
             if (!TileInbag(player, tile))
             {
                 OnPlaceTile(new PlaceTileNotifiedEventArgs(tile, "you can't play"));
                 return false;
             }
-            if (!IsMoveCorrect(tile, x, y, board!)) return false;
+
-            if (board!.AddTileInCell(x, y, tile))
+            if (!IsMoveCorrect(tile, x, y, board)) return false;
+            if (board.AddTileInCell(x, y, tile))
             {
                 AddCellUsed(board.GetCell(x, y));
                 return player.RemoveTileToPlayer(tile);
@@ -409,18 +419,21 @@ namespace QwirkleClassLibrary.Games
             if (cellUsed.Count != 0)
             {
                 OnSwapTiles(new SwapTilesNotifiedEventArgs("You can't swap tiles after placing some !"));
+                ReSwap(tilesToSwap);
                 return false;
             }
 
             if (tilesToSwap.Count == 0)
             {
                 OnSwapTiles(new SwapTilesNotifiedEventArgs("You must select at least one tile to swap !"));
+                ReSwap(tilesToSwap);
                 return false;
             }
 
             if (bag!.TilesBag!.Count < tilesToSwap.Count)
             {
                 OnSwapTiles(new SwapTilesNotifiedEventArgs("Not enough tiles in the bag to swap !"));
+                ReSwap(tilesToSwap);
                 return false;
             }
 
@@ -437,9 +450,18 @@ namespace QwirkleClassLibrary.Games
             return true;
         }
 
+        private void ReSwap(List<Tile> tilesToSwap)
+        {
+            foreach (var t in tilesToSwap)
+            {
+                players[GetPlayingPlayerPosition()].AddTileToPlayer(t);
+            }
+        }
+
         /// <summary>
         /// Extension of IsMoveCorrect to check beyond the surrounding cells of the cell where the tile is placed
         /// </summary>
+        /// <param name="previousTilesFound"></param>
         /// <param name="tile"></param>
         /// <param name="x"></param>
         /// <param name="y"></param>
@@ -447,26 +469,39 @@ namespace QwirkleClassLibrary.Games
         /// <param name="dy">used to get the direction on the y axis</param>
         /// <param name="b"></param>
         /// <returns>bool</returns>
-        public bool CheckExtendedSurroundingCells(Tile tile, int x, int y, int dx, int dy, Board b)
+        public bool CheckExtendedSurroundingCells(ref bool previousTilesFound, Tile tile, int x, int y, int dx, int dy,
+            Board b)
         {
             for (int i = 1; i < 7; i++)
             {
                 var extendedCell = b.GetCell(x + i * dx, y + i * dy);
 
-                if (extendedCell?.Tile == null)
+                if (cellUsed.Count == 0)
+                {
+                    previousTilesFound = true;
+                }
+                
+                if (cellUsed.Contains(extendedCell!))
+                {
+                    previousTilesFound = true;
+                }
+
+                if (extendedCell?.Tile! == null!)
                 {
                     break;
                 }
 
                 if (extendedCell.Tile.GetColor != tile.GetColor && extendedCell.Tile.GetShape != tile.GetShape)
                 {
-                    OnPlaceTile(new PlaceTileNotifiedEventArgs(tile, " : Color / Shape does not match with the surrounding tiles !"));
+                    OnPlaceTile(new PlaceTileNotifiedEventArgs(tile,
+                        " : Color / Shape does not match with the surrounding tiles !"));
                     return false;
                 }
 
                 if (extendedCell.Tile.GetColor == tile.GetColor && extendedCell.Tile.GetShape == tile.GetShape)
                 {
-                    OnPlaceTile(new PlaceTileNotifiedEventArgs(tile, " : Tile already placed on the same line / column !"));
+                    OnPlaceTile(new PlaceTileNotifiedEventArgs(tile,
+                        " : Tile already placed on the same line / column !"));
                     return false;
                 }
 
@@ -515,6 +550,7 @@ namespace QwirkleClassLibrary.Games
             {
                 return x == x1;
             }
+
             if (y1 == y2)
             {
                 return y == y1;
@@ -524,13 +560,62 @@ namespace QwirkleClassLibrary.Games
         }
 
         /// <summary>
-        /// Main method to check if the move the player is trying to make is correct
+        /// Check that there isn't any same tile on a said line when a tile is forming a line
+        /// </summary>
+        /// <param name="t1"></param>
+        /// <param name="nbTiles"></param>
+        /// <param name="checkdoubles"></param>
+        /// <returns></returns>
+        public static bool CheckTileInCompletedLines(Tile? t1, ref int nbTiles, ref List<Tile> checkdoubles)
+        {
+            if (t1! != null!)
+            {
+                nbTiles++;
+
+                if (checkdoubles.Any(t => t.CompareTo(t1) == 0))
+                {
+                    return false;
+                }
+
+                checkdoubles.Add(t1);
+            }
+            
+            return true;
+        }
+        
+        /// <summary>
+        /// Check if the line is completed with the tile placed
         /// </summary>
-        /// <param name="t"></param>
+        /// <param name="tile"></param>
         /// <param name="x"></param>
         /// <param name="y"></param>
+        /// <param name="dx"></param>
+        /// <param name="dy"></param>
         /// <param name="b"></param>
-        /// <returns>bool</returns>
+        /// <param name="checkdoubles"></param>
+        /// <returns></returns>
+        public static bool CheckWrongCompletedLines(int x, int y, int dx, int dy, Board b, ref List<Tile> checkdoubles)
+        {
+            int nbTiles = 1;
+            
+            for (int i = 1; i < 7; i++)
+            {
+                var extendedCell = b.GetCell(x + i * dx, y + i * dy);
+                var extendedCell2 = b.GetCell(x - i * dx, y - i * dy);
+
+                if (extendedCell?.Tile! == null! && extendedCell2?.Tile! == null!)
+                {
+                    break;
+                }
+
+                if(!CheckTileInCompletedLines(extendedCell?.Tile, ref nbTiles, ref checkdoubles)) return false;
+                       
+                if(!CheckTileInCompletedLines(extendedCell2?.Tile, ref nbTiles, ref checkdoubles)) return false;
+            }
+            
+            return nbTiles <= 6;
+        }
+
         public bool IsMoveCorrect(Tile t, int x, int y, Board b)
         {
             if (!b.HasOccupiedCase())
@@ -538,9 +623,10 @@ namespace QwirkleClassLibrary.Games
                 return true;
             }
 
-            if (b.GetCell(x, y)!.Tile != null)
+            if (b.GetCell(x, y)!.Tile! != null!)
             {
                 OnPlaceTile(new PlaceTileNotifiedEventArgs(t, " : Cell already used !"));
+                return false;
             }
 
             var surroundingCells = new List<Cell?>
@@ -550,50 +636,68 @@ namespace QwirkleClassLibrary.Games
                 b.GetCell(x, y + 1),
                 b.GetCell(x, y - 1)
             };
+            
+            if (surroundingCells.All(cell => cell?.Tile! == null!))
+            {
+                OnPlaceTile(new PlaceTileNotifiedEventArgs(t,
+                    " : You can't place a tile that isn't adjacent to another one !"));
+                return false;
+            }
+            
+            return IsTilePlacementCorrect(t, x, y, b, surroundingCells);
+        }
+
+        public bool IsTilePlacementCorrect(Tile t, int x, int y, Board b, List<Cell?> surroundingCells)
+        {
+            bool previousTilesFound = false;
+
+            var checkDoubles = new List<Tile>();
 
             foreach (var cell in surroundingCells)
             {
-                if (cell?.Tile == null)
+                if (cell?.Tile! == null!)
                 {
                     continue;
                 }
 
                 if (cell.Tile.GetColor != t.GetColor && cell.Tile.GetShape != t.GetShape)
                 {
-                    OnPlaceTile(new PlaceTileNotifiedEventArgs(t, " : Colors / Shapes do not match with the surrounding tiles !"));
+                    OnPlaceTile(new PlaceTileNotifiedEventArgs(t,
+                        " : Colors / Shapes do not match with the surrounding tiles !"));
                     return false;
                 }
 
                 if (cell.Tile.GetColor == t.GetColor && cell.Tile.GetShape == t.GetShape)
                 {
                     OnPlaceTile(new PlaceTileNotifiedEventArgs(t, " is already placed on the same line / column !"));
-
                     return false;
                 }
 
                 var dx = cell.GetX - x;
                 var dy = cell.GetY - y;
 
-                if (!CheckExtendedSurroundingCells(t, x, y, dx, dy, b))
+                if (!CheckExtendedSurroundingCells(ref previousTilesFound, t, x, y, dx, dy, b))
                 {
                     return false;
                 }
-            }
 
-
+                if (CheckWrongCompletedLines(x, y, dx, dy, b, ref checkDoubles)) continue;
-            if (!CheckTilesInLine(cellUsed, b, x, y))
+                OnPlaceTile(new PlaceTileNotifiedEventArgs(t,
-            {
+                    " : You can't complete this line ! (More than 6 tiles / same tiles on the line)"));
-                OnPlaceTile(new PlaceTileNotifiedEventArgs(t, "isn't on the same line as the ones previously placed !"));
                 return false;
             }
 
-            if (surroundingCells.All(cell => cell?.Tile == null))
+            if (!CheckTilesInLine(cellUsed, b, x, y))
             {
-                OnPlaceTile(new PlaceTileNotifiedEventArgs(t, " : You can't place a tile that isn't adjacent to another one !"));
+                OnPlaceTile(new PlaceTileNotifiedEventArgs(t,
+                    "isn't on the same line as the ones previously placed !"));
                 return false;
             }
 
-            return true;
+            if (previousTilesFound) return true;
+            OnPlaceTile(new PlaceTileNotifiedEventArgs(t,
+                " : You must place your tile next / on the same line as the ones previously placed !"));
+            return false;
         }
 
 
@@ -613,6 +717,9 @@ namespace QwirkleClassLibrary.Games
 
             int score = cellsPlayed.Count;
             int nbCellsInLine = cellsPlayed.Count;
+            int nbCellsInPerpLine = 1;
+            
+            var checkedCells = new List<Cell>();
 
             if (cellsPlayed.Count == 6)
             {
@@ -642,16 +749,16 @@ namespace QwirkleClassLibrary.Games
                 cellsX = cellsY = -1;
             }
 
-            score += cellsPlayed.Sum(cell => CalculateAdjacentScore(cell, b, cellsPlayed, cellsX, cellsY, ref nbCellsInLine));
+            score += cellsPlayed.Sum(cell =>
+                CalculateAdjacentScore(cell, b, cellsPlayed, new Tuple<int, int>(cellsX, cellsY), ref nbCellsInLine, ref nbCellsInPerpLine, ref checkedCells));
 
-            if (nbCellsInLine == 6)
+            if (nbCellsInLine == 6 || nbCellsInPerpLine == 6)
             {
                 score += 6;
             }
 
             if (!scoreBoard.TryAdd(player.NameTag, score))
             {
-
                 scoreBoard.TryGetValue(player.NameTag, out int scoreold);
                 SetScoreBoard(player.NameTag, score + scoreold);
             }
@@ -665,11 +772,12 @@ namespace QwirkleClassLibrary.Games
         /// <param name="cell"></param>
         /// <param name="b"></param>
         /// <param name="cellsPlayed"></param>
-        /// <param name="cellsX"></param>
+        /// <param name="orientation"></param>
-        /// <param name="cellsY"></param>
+        /// <param name="nbCellsInPerpLine"></param>
+        /// <param name="checkedCells"></param>
         /// <param name="nbCellsInLine"></param>
         /// <returns>int</returns>
-        public int CalculateAdjacentScore(Cell cell, Board b, ReadOnlyCollection<Cell> cellsPlayed, int cellsX, int cellsY, ref int nbCellsInLine)
+        public int CalculateAdjacentScore(Cell cell, Board b, ReadOnlyCollection<Cell> cellsPlayed, Tuple<int, int> orientation, ref int nbCellsInLine, ref int nbCellsInPerpLine, ref List<Cell> checkedCells)
         {
             int score = 0;
 
@@ -681,11 +789,10 @@ namespace QwirkleClassLibrary.Games
                 b.GetCell(cell.GetX, cell.GetY - 1)
             };
 
-            var checkedSurroundingCells = new List<Cell>();
-
             foreach (var adjacentCell in surroundingCells)
             {
-                if (adjacentCell?.Tile == null || cellsPlayed.Contains(adjacentCell) || checkedSurroundingCells.Contains(adjacentCell))
+                if (adjacentCell?.Tile! == null! || cellsPlayed.Contains(adjacentCell) ||
+                    checkedCells.Contains(adjacentCell))
                 {
                     continue;
                 }
@@ -693,9 +800,10 @@ namespace QwirkleClassLibrary.Games
                 int dx = adjacentCell.GetX - cell.GetX;
                 int dy = adjacentCell.GetY - cell.GetY;
 
-                score += CalculateLineScore(cellsPlayed, cell, new Tuple<int, int>(dx, dy), b, new Tuple<int, int>(cellsX, cellsY), ref nbCellsInLine);
+                score += CalculateLineScore(cellsPlayed, cell, new Tuple<int, int>(dx, dy),
+                    new Tuple<int, int>(orientation.Item1, orientation.Item2), ref nbCellsInLine, ref nbCellsInPerpLine, ref checkedCells);
 
-                checkedSurroundingCells.Add(adjacentCell);
+                checkedCells.Add(adjacentCell);
             }
 
             return score;
@@ -707,19 +815,20 @@ namespace QwirkleClassLibrary.Games
         /// <param name="cellsPlayed"></param>
         /// <param name="cell"></param>
         /// <param name="direction"></param>
-        /// <param name="b"></param>
         /// <param name="orientation"></param>
         /// <param name="nbCellsInLine"></param>
+        /// <param name="nbCellsInPerpLine"></param>
+        /// <param name="checkedCells"></param>
         /// <returns>int</returns>
-        public int CalculateLineScore(ReadOnlyCollection<Cell> cellsPlayed, Cell cell, Tuple<int, int> direction, Board b, Tuple<int, int> orientation, ref int nbCellsInLine)
+        public int CalculateLineScore(ReadOnlyCollection<Cell> cellsPlayed, Cell cell, Tuple<int, int> direction, Tuple<int, int> orientation, ref int nbCellsInLine, ref int nbCellsInPerpLine, ref List<Cell> checkedCells)
         {
             int score = 0;
 
             for (int i = 1; i < 6; i++)
             {
-                var extendedCell = b.GetCell(cell.GetX + i * direction.Item1, cell.GetY + i * direction.Item2);
+                var extendedCell = board.GetCell(cell.GetX + i * direction.Item1, cell.GetY + i * direction.Item2);
 
-                if (extendedCell?.Tile == null || cellsPlayed.Contains(extendedCell))
+                if (extendedCell?.Tile! == null! || cellsPlayed.Contains(extendedCell) || checkedCells.Contains(extendedCell))
                 {
                     break;
                 }
@@ -728,11 +837,17 @@ namespace QwirkleClassLibrary.Games
                 {
                     nbCellsInLine++;
                 }
+                
+                if (direction.Item1 != 0 && orientation.Item1 != -1 || direction.Item2 != 0 && orientation.Item2 != -1)
+                {
+                    nbCellsInPerpLine++;
+                }
 
+                checkedCells.Add(extendedCell);
                 score++;
             }
 
-            if (direction.Item1 == 0 && orientation.Item1 == -1 && orientation.Item2 != -1 || direction.Item2 == 0 && orientation.Item2 == -1 && orientation.Item1 != -1)
+            if (ShouldIncreaseScore(direction, orientation))
             {
                 score += 1;
             }
@@ -740,7 +855,12 @@ namespace QwirkleClassLibrary.Games
             return score;
         }
 
-
+        public static bool ShouldIncreaseScore(Tuple<int, int> direction, Tuple<int, int> orientation)
+        {
+            return direction.Item1 == 0 && orientation.Item1 == -1 && orientation.Item2 != -1 ||
+                   direction.Item2 == 0 && orientation.Item2 == -1 && orientation.Item1 != -1;
+        }
+        
         /// <summary>
         /// Returns the list of the positions of the players who still have tiles in their bag
         /// </summary>
@@ -749,7 +869,7 @@ namespace QwirkleClassLibrary.Games
         {
             List<int> playerTilesBagPos = [];
 
-            if (bag!.TilesBag!.Count == 0)
+            if (bag!.TilesBag!.Count <= 12)
             {
                 for (int i = 0; i < players.Count; i++)
                 {
@@ -758,7 +878,6 @@ namespace QwirkleClassLibrary.Games
                         playerTilesBagPos.Add(i);
                     }
                 }
-
             }
 
             return playerTilesBagPos;
@@ -775,7 +894,7 @@ namespace QwirkleClassLibrary.Games
             {
                 foreach (var t in players[t1].Tiles)
                 {
-                    for (int b = 0; b < board!.ReadCells.Count; b++)
+                    for (int b = 0; b < board.ReadCells.Count; b++)
                     {
                         int x = board.ReadCells[b].GetX;
                         int y = board.ReadCells[b].GetY;
@@ -801,7 +920,8 @@ namespace QwirkleClassLibrary.Games
         {
             List<int> playerTilesBagPos = CheckTilesBag();
 
-            if (playerTilesBagPos.Count != 0 && !CheckPlacementPossibilities(playerTilesBagPos) || bag!.TilesBag!.Count == 0 && players[GetPlayingPlayerPosition()].Tiles.Count == 0)
+            if (playerTilesBagPos.Count != 0 && !CheckPlacementPossibilities(playerTilesBagPos) ||
+                bag!.TilesBag!.Count == 0 && players[GetPlayingPlayerPosition()].Tiles.Count == 0)
             {
                 OnEndOfGame(new EndOfGameNotifiedEventArgs(player));
                 GameRunning = false;
@@ -818,6 +938,7 @@ namespace QwirkleClassLibrary.Games
             players.Clear();
             scoreBoard.Clear();
             cellUsed.Clear();
+            observableScoreBoard.Clear();
             bag = null;
             board = CreateBoard();
             GameRunning = false;
@@ -825,7 +946,6 @@ namespace QwirkleClassLibrary.Games
 
         public void SetScoreBoard(string name, int score)
         {
-
             if (!scoreBoard.TryAdd(name, score))
             {
                 scoreBoard[name] = score;
@@ -836,6 +956,7 @@ namespace QwirkleClassLibrary.Games
             {
                 observableScoreBoard.Add(item);
             }
+
             OnPropertyChanged(nameof(ObservableScoreBoard));
         }
     }

Qwirkle/QwirkleClassLibrary/Games/IPlayer.cs

@@ -3,25 +3,32 @@ using QwirkleClassLibrary.Boards;
 using QwirkleClassLibrary.Players;
 using QwirkleClassLibrary.Tiles;
 
-namespace QwirkleClassLibrary.Games;
+namespace QwirkleClassLibrary.Games
-
-public interface IPlayer
 {
-    public Player CreatePlayer(string playerTag);
 
-    public string SetNextPlayer();
+    /// <summary>
+    /// This interface is used for all methods related to the player, such as the moves he can make.
+    /// </summary>
+    public interface IPlayer
+    {
+        public Player CreatePlayer(string playerTag);
+
+        public string SetNextPlayer();
 
-    public string SetFirstPlayer(ReadOnlyCollection<Player> playingPlayers);
+        public string SetFirstPlayer(ReadOnlyCollection<Player> playingPlayers);
 
-    public bool PlaceTile(Player player, Tile tile, int x, int y);
+        public bool PlaceTile(Player player, Tile tile, int x, int y);
 
-    public bool DrawTiles(Player player);
+        public bool DrawTiles(Player player);
 
-    public bool SwapTiles(Player player, List<Tile> tilesToSwap);
+        public bool SwapTiles(Player player, List<Tile> tilesToSwap);
 
-    public int GetPlayerScore(Player player, ReadOnlyCollection<Cell> cellsPlayed, Board b);
+        public int GetPlayerScore(Player player, ReadOnlyCollection<Cell> cellsPlayed, Board b);
 
-    int CalculateAdjacentScore(Cell cell, Board b, ReadOnlyCollection<Cell> cellsPlayed, int cellsX, int cellsY, ref int nbCellsInLine);
+        int CalculateAdjacentScore(Cell cell, Board b, ReadOnlyCollection<Cell> cellsPlayed, Tuple<int, int> orientation,
+            ref int nbCellsInLine, ref int nbCellsInPerpLine, ref List<Cell> checkedCells);
 
-    int CalculateLineScore(ReadOnlyCollection<Cell> cellsPlayed, Cell cell, Tuple<int, int> direction, Board b, Tuple<int, int> orientation, ref int nbCellsInLine);
+        int CalculateLineScore(ReadOnlyCollection<Cell> cellsPlayed, Cell cell, Tuple<int, int> direction,
+            Tuple<int, int> orientation, ref int nbCellsInLine, ref int nbCellsInPerpLine, ref List<Cell> checkedCells);
+    }
 }

Qwirkle/QwirkleClassLibrary/Games/IRules.cs

@@ -9,6 +9,9 @@ using QwirkleClassLibrary.Tiles;
 
 namespace QwirkleClassLibrary.Games
 {
+    /// <summary>
+    /// This interface is used to define the functions used in the game. It is mainly about all the rules of the games, checking if the player moves are correct.
+    /// </summary>
     public interface IRules
     {
         Board CreateBoard();
@@ -17,7 +20,7 @@ namespace QwirkleClassLibrary.Games
 
         bool IsMoveCorrect(Tile t, int x, int y, Board b);
 
-        bool CheckExtendedSurroundingCells(Tile tile, int x, int y, int dx, int dy, Board b);
+        bool CheckExtendedSurroundingCells(ref bool previousTilesFound, Tile tile, int x, int y, int dx, int dy, Board b);
 
         bool CheckTilesInLine(List<Cell> cells, Board b, int x, int y);
 

Qwirkle/QwirkleClassLibrary/Persistences/GamePersistenceXml.cs

@@ -1,36 +1,47 @@
 using System.Runtime.Serialization;
 using QwirkleClassLibrary.Games;
 
-namespace QwirkleClassLibrary.Persistences;
+namespace QwirkleClassLibrary.Persistences
-
-public class GamePersistenceXml : IGamePersistence
 {
-    public void SaveGame(Game game)
+    /// <summary>
+    /// This class takes care of managing persistence with regard to the information of the current game, allowing the last game played to be resumed even when returning to the menu or exiting the application.
+    /// </summary>
+    public class GamePersistenceXml : IGamePersistence
     {
-        var serializer = new DataContractSerializer(typeof(Game),
+        /// <summary>
-            new DataContractSerializerSettings() { PreserveObjectReferences = true });
+        /// The main purpose of this method is to save the data from the game when the user quits the app, so players can continue it later.
-        
+        /// </summary>
-        using (Stream writer = File.Create("Game.xml"))
+        /// <param name="game"></param>
+        public void SaveGame(Game game)
         {
-            serializer.WriteObject(writer, game);
+            var serializer = new DataContractSerializer(typeof(Game),
-        }
+                new DataContractSerializerSettings() { PreserveObjectReferences = true });
-    }
 
-    public Game LoadGame()
+            using (Stream writer = File.Create("Game.xml"))
-    {
-        var serializer = new DataContractSerializer(typeof(Game));
-
-        try
-        {
-            using (Stream reader = File.OpenRead("Game.xml"))
             {
-                var newGame = serializer.ReadObject(reader) as Game;
+                serializer.WriteObject(writer, game);
-                return newGame!;
             }
         }
-        catch
+        /// <summary>
+        /// This method is used to retrieve the information needed to resume the last game launched on the application.
+        /// </summary>
+        /// <returns>A Game.</returns>
+        public Game LoadGame()
         {
-            return new Game();
+            var serializer = new DataContractSerializer(typeof(Game));
+
+            try
+            {
+                using (Stream reader = File.OpenRead("Game.xml"))
+                {
+                    var newGame = serializer.ReadObject(reader) as Game;
+                    return newGame!;
+                }
+            }
+            catch
+            {
+                return new Game();
+            }
         }
     }
 }

Qwirkle/QwirkleClassLibrary/Persistences/LeaderboardPersistenceJson.cs

@@ -1,27 +1,39 @@
 using System.Runtime.Serialization.Json;
 using QwirkleClassLibrary.Players;
 
-namespace QwirkleClassLibrary.Persistences;
+namespace QwirkleClassLibrary.Persistences
-
-public class LeaderboardPersistenceJson : ILeaderboardPersistence
 {
-    public void SaveLeaderboard(Leaderboard leaderboard)
+    /// <summary>
+    /// This is the persistence class for the leaderboard : it is in charge of managing all the parameters necessary for the backup and recovery of data concerning the leaderboard.
+    /// </summary>
+    public class LeaderboardPersistenceJson : ILeaderboardPersistence
     {
-        var serializer = new DataContractJsonSerializer(typeof(Leaderboard));
+        /// <summary>
-        
+        /// As the name suggest, this class is used to save the data from the leaderboard.
-        using (Stream writer = File.Create("Leaderboard.json"))
+        /// </summary>
+        /// <param name="leaderboard">The current leaderboard we want to save data from.</param>
+        public void SaveLeaderboard(Leaderboard leaderboard)
         {
-            serializer.WriteObject(writer, leaderboard);
+            var serializer = new DataContractJsonSerializer(typeof(Leaderboard));
-        }
-    }
 
-    public Leaderboard LoadLeaderboard()
+            using (Stream writer = File.Create("Leaderboard.json"))
-    {
+            {
-        var serializer = new DataContractJsonSerializer(typeof(Leaderboard));
+                serializer.WriteObject(writer, leaderboard);
-
+            }
-        using (Stream reader = File.OpenRead("Leaderboard.json"))
+        }
+        /// <summary>
+        /// This method is used to load the leaderboard into the app when the application starts.
+        /// </summary>
+        /// <returns>Leaderboard</returns>
+        /// <exception cref="InvalidOperationException"></exception>
+        public Leaderboard LoadLeaderboard()
         {
-            return serializer.ReadObject(reader) as Leaderboard ?? throw new InvalidOperationException();
+            var serializer = new DataContractJsonSerializer(typeof(Leaderboard));
+
+            using (Stream reader = File.OpenRead("Leaderboard.json"))
+            {
+                return serializer.ReadObject(reader) as Leaderboard ?? throw new InvalidOperationException();
+            }
         }
     }
 }

Qwirkle/QwirkleClassLibrary/Players/Leaderboard.cs

@@ -1,7 +1,10 @@
-using System;
+using QwirkleClassLibrary.Tiles;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.ComponentModel;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Runtime.ExceptionServices;
 using System.Runtime.Serialization;
 using System.Text;
@@ -9,14 +12,23 @@ using System.Threading.Tasks;
 
 namespace QwirkleClassLibrary.Players
 {
+    /// <summary>
+    /// The purpose of this class is to save data at the end of a game so players can consult it later, comparing their best scores along their games.
+    /// </summary>
     [DataContract]
-    public class Leaderboard
+    public class Leaderboard : INotifyPropertyChanged
     {
-        public ReadOnlyCollection<Score> Lb => leaderboard.AsReadOnly();
-        
         [DataMember]
-        private readonly List<Score> leaderboard = new();
+        private ObservableCollection<Score> leaderboard = new();
-        
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+
+        public ReadOnlyObservableCollection<Score> Lb => new(leaderboard);
         
         /// <summary>
         /// Returns the index of the player in the leaderboard, -1 if the player is not in the leaderboard
@@ -57,11 +69,13 @@ namespace QwirkleClassLibrary.Players
                     if (first)
                     {
                         leaderboard[i].Victories++;
+                        OnPropertyChanged(nameof(leaderboard));
                     }
 
                     if (pair.Value > leaderboard[i].Points)
                     {
                         leaderboard[i].Points = pair.Value;
+                        OnPropertyChanged(nameof(leaderboard));
                     }
 
                 }
@@ -74,11 +88,13 @@ namespace QwirkleClassLibrary.Players
                     }
                     Score score = new Score(pair.Key, now, pair.Value, v);
                     leaderboard.Add(score);
+                    OnPropertyChanged(nameof(leaderboard));
                 }
 
                 first = false;
             }
 
+            leaderboard = new ObservableCollection<Score>(leaderboard.OrderByDescending(x => x.Points).ThenBy(x => x.Victories));
         }
     }
 }

Qwirkle/QwirkleClassLibrary/Players/Player.cs

@@ -12,6 +12,9 @@ using QwirkleClassLibrary.Tiles;
 
 namespace QwirkleClassLibrary.Players
 {
+    /// <summary>
+    /// This class is mainly used to manage the sets of tiles of players during the game.
+    /// </summary>
     [DataContract]
     public class Player : INotifyPropertyChanged
     {

Qwirkle/QwirkleClassLibrary/Players/Score.cs

@@ -9,6 +9,9 @@ using System.Threading.Tasks;
 
 namespace QwirkleClassLibrary.Players
 {
+    /// <summary>
+    /// The main purpose of this class is to save the data of the scores during the games, allowing the app to back up data.
+    /// </summary>
     [DataContract]
     public class Score
     {

Qwirkle/QwirkleClassLibrary/Tiles/Tile.cs

@@ -8,8 +8,11 @@ using System.Threading.Tasks;
 
 namespace QwirkleClassLibrary.Tiles
 {
+    /// <summary>
+    /// This is the class for the Tile, it defines what it is and what can be done with it.
+    /// </summary>
     [DataContract]
-    public class Tile
+    public class Tile : IComparable
     {
         [DataMember]
         private readonly Shape shape;
@@ -41,19 +44,13 @@ namespace QwirkleClassLibrary.Tiles
         /// A getter for the shape of the Tile.
         /// </summary>
         /// <returns>The shape attribute of the Tile.</returns>
-        public Shape GetShape
+        public Shape GetShape => shape;
-        {
-            get { return shape; }
-        }
 
         /// <summary>
         /// A getter for the color of the Tile.
         /// </summary>
         /// <returns>The color attribute of the Tile.</returns>
-        public Color GetColor
+        public Color GetColor => color;
-        {
-            get { return color; }
-        }
 
         /// <summary>
         /// This method is used to override the ToString() method. It is simply a tool to facilitate the development.
@@ -63,5 +60,69 @@ namespace QwirkleClassLibrary.Tiles
         {
             return color.ToString() + " " + shape.ToString();
         }
+
+        public int CompareTo(object? obj)
+        {
+            if (obj == null)
+            {
+                return 1;
+            }
+            
+            var otherTile = obj as Tile;
+            
+            if (color == otherTile!.color)
+            {
+                return shape.CompareTo(otherTile.shape);
+            }
+
+            return color.CompareTo(otherTile.color);
+            
+        }
+
+        public override bool Equals(object? obj)
+        {
+            if (obj == null || GetType() != obj.GetType())
+            {
+                return false;
+            }
+
+            var otherTile = obj as Tile;
+            return color == otherTile!.color && shape == otherTile.shape;
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(color, shape);
+        }
+
+        public static bool operator ==(Tile tile1, Tile tile2)
+        {
+            return EqualityComparer<Tile>.Default.Equals(tile1, tile2);
+        }
+
+        public static bool operator !=(Tile tile1, Tile tile2)
+        {
+            return !(tile1 == tile2);
+        }
+
+        public static bool operator <(Tile tile1, Tile tile2)
+        {
+            return tile1.CompareTo(tile2) < 0;
+        }
+
+        public static bool operator >(Tile tile1, Tile tile2)
+        {
+            return tile1.CompareTo(tile2) > 0;
+        }
+
+        public static bool operator <=(Tile tile1, Tile tile2)
+        {
+            return tile1.CompareTo(tile2) <= 0;
+        }
+
+        public static bool operator >=(Tile tile1, Tile tile2)
+        {
+            return tile1.CompareTo(tile2) >= 0;
+        }
     }
 }

Qwirkle/QwirkleClassLibrary/Tiles/TileBag.cs

@@ -8,14 +8,17 @@ using System.Threading.Tasks;
 
 namespace QwirkleClassLibrary.Tiles
 {
+    /// <summary>
+    /// This class is used during the game for the tile redistribution system. 
+    /// </summary>
     [DataContract]
     public class TileBag
     {
         [DataMember]
         private readonly List<Tile> tiles = [];
-        
+
         public ReadOnlyCollection<Tile>? TilesBag { get; private set; }
-        
+
 
         /// <summary>
         /// This is the constructor for the TileBag. It will create a tile of each of the possibilities among the Color and Shape Enums.
@@ -40,7 +43,7 @@ namespace QwirkleClassLibrary.Tiles
                     }
                 }
             }
-            
+
             Init();
         }
 
@@ -70,7 +73,7 @@ namespace QwirkleClassLibrary.Tiles
             }
             return false;
         }
-        
+
         [OnDeserialized]
         private void Init(StreamingContext sc = new())
         {

Qwirkle/QwirkleViews/App.xaml.cs

@@ -2,6 +2,9 @@
 using Microsoft.Maui.Controls;
 using Qwirkle.Pages;
 using QwirkleClassLibrary.Games;
+using QwirkleClassLibrary.Persistences;
+using QwirkleClassLibrary.Players;
+using Leaderboard = QwirkleClassLibrary.Players.Leaderboard;
 
 namespace Qwirkle
 {
@@ -9,17 +12,36 @@ namespace Qwirkle
     {
         public App()
         {
+            string appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+            string targetPath = Path.Combine(appDataPath, "Programs", "Files");
+            Directory.CreateDirectory(targetPath);
+            Directory.SetCurrentDirectory(targetPath);
+            
             InitializeComponent();
 
+            //MainPage = new NavigationPage(new MainPage());
             MainPage = new AppShell();
 
             Routing.RegisterRoute(nameof(SetPlayers), typeof(SetPlayers));
             Routing.RegisterRoute(nameof(Gameboard), typeof(Gameboard));
             Routing.RegisterRoute(nameof(Rules), typeof(Rules));
             Routing.RegisterRoute(nameof(MainPage), typeof(MainPage));
+            Routing.RegisterRoute(nameof(Qwirkle.Pages.Leaderboard), typeof(Qwirkle.Pages.Leaderboard));
 
+            ILeaderboardPersistence leaderboardLoad = new LeaderboardPersistenceJson();
+
+            try
+            {
+                Ld = leaderboardLoad.LoadLeaderboard();
+            }
+            catch
+            {
+                Ld = new Leaderboard();
+            }
         }
 
+        
         public Game Game { get; set; } = new();
+        public Leaderboard Ld { get; set; }
     }
 }

Qwirkle/QwirkleViews/ConverterColor.cs

@@ -17,7 +17,7 @@ namespace Qwirkle.Converters
             if (colorstring == "Red") return Colors.Red;
             if (colorstring == "Blue") return Colors.Blue;
             if (colorstring == "Green") return Colors.Green;
-            if (colorstring == "Orange") return Colors.OrangeRed;
+            if (colorstring == "Orange") return Colors.Orange;
             if (colorstring == "Purple") return Colors.Purple;
             if (colorstring == "Transparent") return Colors.Transparent;
 

Qwirkle/QwirkleViews/MainPage.xaml

@@ -1,4 +1,5 @@
-<?xml version="1.0" encoding="utf-8" ?>
+<?xml version="1.0" encoding="utf-8"?>
+
 <ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
              xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
              x:Class="Qwirkle.MainPage"
@@ -6,40 +7,41 @@
 
     <ScrollView>
         <VerticalStackLayout
-            Padding="30,0"
+            Padding="30, 0, 30, 30"
             Spacing="25">
 
             <Label
                 Text="QWIRKLE"
-                Style="{StaticResource SuperTitle}"
+                Style="{StaticResource SuperTitle}" />
-                />
 
             <Image
                 Source="qwirklelogo.png"
                 HeightRequest="300"
-                Aspect="AspectFit"
+                Aspect="AspectFit" />
-                />
 
 
-            <controls:ButtonShadow 
+            <controls:ButtonShadow
                 Text="Play"
-                  InfoClicked="OnInfoClicked"
+                InfoClicked="OnInfoClicked" />
-                />
+
+            <controls:ButtonShadow Text="Continue"
+                                   InfoClicked="OnContinueClicked" />
 
-            <controls:ButtonShadow Text="Leaderboard"/>
+            <controls:ButtonShadow Text="Leaderboard"
+                                   InfoClicked="OnCLeaderboardClicked" />
 
             <controls:ButtonShadow Text="Rules"
-                                   InfoClicked="OnRulesClicked"/>
+                                   InfoClicked="OnRulesClicked" />
 
             <controls:ButtonShadow Text="Settings"
-                                   InfoClicked="OnSettingsClicked"/>
+                                   InfoClicked="OnSettingsClicked" />
 
             <controls:ButtonShadow Text="Credits"
-                                   InfoClicked="OnCreditsClicked"/>
+                                   InfoClicked="OnCreditsClicked" />
 
         </VerticalStackLayout>
 
 
     </ScrollView>
 
-</ContentPage>
+</ContentPage>

Qwirkle/QwirkleViews/MainPage.xaml.cs

@@ -3,6 +3,7 @@ using QwirkleClassLibrary;
 using QwirkleClassLibrary.Games;
 using Microsoft.Maui.Controls;
 using Qwirkle.Pages;
+using QwirkleClassLibrary.Persistences;
 
 namespace Qwirkle
 {
@@ -19,10 +20,32 @@ namespace Qwirkle
         {
             DisplayAlert("Game notification", "Enter minimun 2 player and max 4 player !", "Ok ! Lets's go !");
 
-            Navigation.PushAsync(new SetPlayers());
+            Shell.Current.GoToAsync("SetPlayers");
+            //Navigation.PushAsync(new SetPlayers());
         }
+        
+        public async void OnContinueClicked(object sender, EventArgs e)
+        {
+            IGamePersistence gameLoad = new GamePersistenceXml();
+            try
+            {
+                ((App)Application.Current!).Game = gameLoad.LoadGame();
+                await Shell.Current.GoToAsync("Gameboard");
+                //await Navigation.PushAsync(new Gameboard());
+            }
+            catch
+            {
+                await DisplayAlert("Error", "No game found", "Got it !");
+                await Navigation.PopAsync();
+            }
 
-
+            if (!((App)Application.Current!).Game.GameRunning)
+            {
+                await DisplayAlert("Error", "No game found", "Got it !");
+                await Navigation.PopAsync();
+            }
+        }
+        
         public void OnRulesClicked(object sender, EventArgs e)
         {
             Navigation.PushAsync(new Rules());
@@ -38,6 +61,11 @@ namespace Qwirkle
             Navigation.PushAsync(new Credits());
         }
 
+        public void OnCLeaderboardClicked(object sender, EventArgs e)
+        {
+            Navigation.PushAsync(new Leaderboard());
+        }
+
     }
 
 }

Qwirkle/QwirkleViews/MauiProgram.cs

@@ -1,5 +1,7 @@
 using CommunityToolkit.Maui;
+using CommunityToolkit.Maui.Views;
 using Microsoft.Extensions.Logging;
+using Microsoft.Maui;
 
 namespace Qwirkle
 {
@@ -11,6 +13,7 @@ namespace Qwirkle
             builder
                 .UseMauiApp<App>()
                 .UseMauiCommunityToolkit()
+                .UseMauiCommunityToolkitMediaElement()
                 .ConfigureFonts(fonts =>
                 {
                     fonts.AddFont("DiloWorld.ttf", "DiloWorld");
@@ -18,7 +21,7 @@ namespace Qwirkle
                 });
 
 #if DEBUG
-    		builder.Logging.AddDebug();
+            builder.Logging.AddDebug();
 #endif
 
 

Qwirkle/QwirkleViews/Pages/GameBoard.xaml.cs

@@ -9,6 +9,9 @@ using System.ComponentModel;
 using Cell = QwirkleClassLibrary.Boards.Cell;
 using Color = Microsoft.Maui.Graphics.Color;
 using System.Drawing;
+using QwirkleClassLibrary.Persistences;
+using CommunityToolkit.Maui.Views;
+using System.Diagnostics;
 
 namespace Qwirkle.Pages;
 
@@ -28,10 +31,8 @@ public partial class Gameboard : ContentPage
     public Color ColorBC3 { get; set; } = Colors.Transparent;
     public Color ColorBC4 { get; set; } = Colors.Transparent;
 
-
     public Gameboard()
     {
-
         InitializeComponent();
         BindingContext = game;
 
@@ -39,12 +40,16 @@ public partial class Gameboard : ContentPage
 
 
     }
+    
+    private async void Game_EndOfGameNotified(object? sender, EndOfGameNotifiedEventArgs e)
+    {
+        await PopUpEnd();
+        await Navigation.PushAsync(new MainPage());
+    }
 
-    private void Game_EndOfGameNotified(object? sender, EndOfGameNotifiedEventArgs e)
+    private Task PopUpEnd()
     {
-        DisplayAlert("THE END.", "FAUT QU'ON PARLE DE CE QUE QU'ON VEUT FAIRE ICI !!!" ,"<3");
+        return this.ShowPopupAsync(new PopUpEndGame());
-        Navigation.PushAsync(new MainPage());
-        game.ClearGame();
     }
 
     private void OnDragStarting(object sender, DragStartingEventArgs e)
@@ -94,23 +99,45 @@ public partial class Gameboard : ContentPage
 
         if (game.PlayerSwapping) 
         {
+            game.SwapTilesNotified += Game_SwapTilesNotified;
             game.SwapTiles(game.GetPlayingPlayer(), tilesSwap);
             tilesSwap.Clear();
             game.PlayerSwapping = false;
+            game.SwapTilesNotified -= Game_SwapTilesNotified;
         }
         else
         {
-            game.GetPlayerScore(game.GetPlayingPlayer(), game.CellsUsed, game.GetBoard()!);
+            var x = game.GetPlayerScore(game.GetPlayingPlayer(), game.CellsUsed, game.GetBoard()!);
+
             game.EmptyCellUsed();
             game.DrawTiles(game.GetPlayingPlayer());
         }
-
+        
         game.CheckGameOver(game.GetPlayingPlayer());
-        game.SetNextPlayer();
+
+        IGamePersistence gameIntermediateSave = new GamePersistenceXml();
+        gameIntermediateSave.SaveGame(game);
+
+        if (!game.CheckGameOver(game.GetPlayingPlayer()))
+        {
+            game.SetNextPlayer();
+            ChangeColorBC();
+        }
+        else
+        {
+            ((App)Application.Current!).Ld.AddScoreInLead(game.ScoreBoard);
+
+            IGamePersistence gameEndSave = new GamePersistenceXml();
+            gameEndSave.SaveGame(game);
+            
+            ILeaderboardPersistence leaderboardSave = new LeaderboardPersistenceJson();
+            leaderboardSave.SaveLeaderboard(((App)Application.Current!).Ld);
+            
+            game.ClearGame();
+        }
         game.NextPlayerNotified -= Game_NextPlayerNotified;
         game.EndOfGameNotified -= Game_EndOfGameNotified;
 
-        ChangeColorBC();
     }
 
     private void ChangeColorBC()
@@ -163,30 +190,28 @@ public partial class Gameboard : ContentPage
 
     private void Game_NextPlayerNotified(object? sender, NextPlayerNotifiedEventArgs args)
     {
-        DisplayAlert("Player switch !", "It's your turn : " + args.Player.NameTag, "<3");
+        Debug.WriteLine(args.Player.NameTag);
     }
 
     private void OnButtonSwapClicked(object sender, EventArgs e)
     {
         game.PlaceTileNotified += Game_PlaceTileNotified;
-        game.SwapTilesNotified += Game_SwapTilesNotified;
 
         if (game.CellsUsed.Count == 0 && !game.PlayerSwapping)
         {
-            //DisplayAlert("Swap system", "\r\nWelcome to the swap system! To use the system, take the tiles you wish to swap and place them in the bag (you will not see the tiles disappear). Then, click on the skip button. /!\\ Attention, during the swap phase, you cannot play /!\\", "Copy !");
+            _ = AnswerSwap();
-            AnswerSwap();
+        }
-
+        else
-
+        {
-
+            DisplayAlert("Swap system", "You cannot place tiles and swap in the same turn.", "Ok !");
         }
 
-        game.SwapTilesNotified -= Game_SwapTilesNotified;
         game.PlaceTileNotified -= Game_PlaceTileNotified;
     }
 
-    private async void AnswerSwap()
+    private async Task AnswerSwap()
     {
-        bool answer = await DisplayAlert("Swap System", "Etes vous sur de vouloir swap vos tuiles ? Attention, si vous swapez vous ne pouvez pu jouer", "Yes", "No");
+        bool answer = await DisplayAlert("Swap System", "Are you sure you want to swap your tiles? Attention, if you swap you can not play", "Yes", "No");
 
             if (answer)
             {
@@ -207,4 +232,32 @@ public partial class Gameboard : ContentPage
             tilesSwap.Add(tiledrag!);
         }
     }
-}
+
+    private async void OnButtonExitClicked(object sender, EventArgs e)
+    {
+        bool answer = await DisplayAlert("System information", "Are you sure you want to quit? You can resume your game at any time from the home screen.", "Yes", "No");
+
+        if (answer)
+        {
+            IGamePersistence gameIntermediateSave = new GamePersistenceXml();
+            gameIntermediateSave.SaveGame(game);
+
+
+            game.ClearGame();
+            await Navigation.PopToRootAsync();
+            
+        }
+    }
+
+    private void OnButtonBookClicked(object? sender, EventArgs e)
+    {
+        Navigation.PushAsync(new Rules());
+    }
+
+    private void OnButtonSettingsClicked(object? sender, EventArgs e)
+    {
+        Navigation.PushAsync(new Settings());
+    }
+
+
+}

Qwirkle/QwirkleViews/Pages/Gameboard.xaml

@@ -4,13 +4,21 @@
              xmlns:controls="clr-namespace:Qwirkle.Views"
              Title="Gameboard"
              xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit"
-             x:Name="root">
+             x:Name="root"
+             >
+
+    <Shell.BackButtonBehavior>
+        <BackButtonBehavior IsVisible="False" IsEnabled="False"></BackButtonBehavior>
+    </Shell.BackButtonBehavior>
+  
+
+
 
     <ContentPage.Resources>
         <x:Double x:Key="CellWidth">75</x:Double>
-            <x:Double x:Key="CellHeight">75</x:Double>
+        <x:Double x:Key="CellHeight">75</x:Double>
-            <x:Double x:Key="VerticalSpacing">1</x:Double>
+        <x:Double x:Key="VerticalSpacing">1</x:Double>
-            <x:Double x:Key="HorizontalSpacing">1</x:Double>
+        <x:Double x:Key="HorizontalSpacing">1</x:Double>
         <toolkit:MultiMathExpressionConverter x:Key="multiMathExpressionConverter" />
     </ContentPage.Resources>
     <Grid BackgroundColor="#efca85">
@@ -26,25 +34,27 @@
             <ColumnDefinition Width="*" />
         </Grid.ColumnDefinitions>
 
-
         <Border WidthRequest="80" HeightRequest="80"
-                                BackgroundColor="WhiteSmoke"
+                BackgroundColor="Transparent"
-                                Margin="0" >
+                Margin="0">
-            <Border.GestureRecognizers >
+            <Border.GestureRecognizers>
                 <DropGestureRecognizer DragOver="OnDragOverBag"
-                                                       DropCommand="{Binding OnDropB, Source={x:Reference root}}"
+                                       DropCommand="{Binding OnDropB, Source={x:Reference root}}" />
-                                                       />
             </Border.GestureRecognizers>
-            <Image Source="bag.png" ToolTipProperties.Text="Pour m'utiliser il faut cliquer sur le boutton swap avant ^^"></Image>
+            <Image Source="bag.png"
+                   ToolTipProperties.Text="To use me, you need to click the swap button first ^^">
+            </Image>
         </Border>
 
-        <Button  
+        <ImageButton Grid.Row="0" Grid.Column="2" Source="bookicon.png" Clicked="OnButtonBookClicked" HeightRequest="70"></ImageButton>
+
+        <Button
             HorizontalOptions="Start"
             Grid.Row="0" Grid.Column="1"
             Text="Swap"
             Clicked="OnButtonSwapClicked"
             ToolTipProperties.Text="Click to swap your tiles !"
-            Style="{StaticResource GameButton}"/>
+            Style="{StaticResource GameButton}" />
 
         <Button
             HorizontalOptions="End"
@@ -52,30 +62,40 @@
             Text="Skip / End Turn" WidthRequest="200"
             Clicked="OnButtonSkipClicked"
             ToolTipProperties.Text="Click for skip / end your turn ;)"
-            Style="{StaticResource GameButton}"/>
+            Style="{StaticResource GameButton}" />
-        
+
-        <Button  
+        <Button
-            HorizontalOptions="Start" 
+            HorizontalOptions="Start"
             Grid.Row="2" Grid.Column="1"
             Text="Settings"
+            Clicked="OnButtonSettingsClicked"
             ToolTipProperties.Text="Click to check your settings -_-"
-            Style="{StaticResource GameButton}"/>
+            Style="{StaticResource GameButton}" />
+
+        <Button
+            HorizontalOptions="End"
+            Grid.Row="0" Grid.Column="1"
+            Text="Exit" WidthRequest="200"
+            Clicked="OnButtonExitClicked"
+            ToolTipProperties.Text="Click here to exit ;)"
+            Style="{StaticResource GameButton}" />
 
+        <Label HorizontalOptions="Center" Grid.Row="0" Grid.Column="1" FontSize="Medium" Text="{Binding PlayerList[0].NameTag}"></Label>
         <CollectionView Grid.Row="0" Grid.Column="1" ItemsSource="{Binding PlayerList[0].Tiles}"
                         HorizontalOptions="Center"
-                        VerticalOptions="Center" >
+                        VerticalOptions="Center">
             <CollectionView.ItemsLayout>
-                <GridItemsLayout Orientation="Horizontal"/>
+                <GridItemsLayout Orientation="Horizontal" />
             </CollectionView.ItemsLayout>
             <CollectionView.ItemTemplate>
 
                 <DataTemplate>
+                    
                     <Border WidthRequest="70" HeightRequest="70"
-                        BackgroundColor="{Binding ColorBC1, Source={x:Reference root}}"
+                            BackgroundColor="{Binding ColorBC1, Source={x:Reference root}}"
-                        Margin="0"
+                            Margin="0">
-                           >
                         <Border.GestureRecognizers>
-                            <DragGestureRecognizer CanDrag="True" DragStarting="OnDragStarting"/>
+                            <DragGestureRecognizer CanDrag="True" DragStarting="OnDragStarting" />
                         </Border.GestureRecognizers>
                         <controls:TileView Shape="{Binding GetShape}" Color="{Binding GetColor}"></controls:TileView>
                     </Border>
@@ -83,19 +103,21 @@
             </CollectionView.ItemTemplate>
         </CollectionView>
 
+
+        <Label HorizontalOptions="Center" Grid.Row="1" Grid.Column="0" FontSize="Medium" Text="{Binding PlayerList[2].NameTag}"></Label>
         <CollectionView Grid.Row="1" Grid.Column="0" ItemsSource="{Binding PlayerList[2].Tiles}"
                         HorizontalOptions="Center"
-                        VerticalOptions="Center" >
+                        VerticalOptions="Center">
             <CollectionView.ItemsLayout>
-                <GridItemsLayout Orientation="Vertical"/>
+                <GridItemsLayout Orientation="Vertical" />
             </CollectionView.ItemsLayout>
             <CollectionView.ItemTemplate>
                 <DataTemplate>
                     <Border WidthRequest="70" HeightRequest="70"
-                        BackgroundColor="{Binding ColorBC3, Source={x:Reference root}}"
+                            BackgroundColor="{Binding ColorBC3, Source={x:Reference root}}"
-                        Margin="0">
+                            Margin="0">
                         <Border.GestureRecognizers>
-                            <DragGestureRecognizer CanDrag="True" DragStarting="OnDragStarting"/>
+                            <DragGestureRecognizer CanDrag="True" DragStarting="OnDragStarting" />
                         </Border.GestureRecognizers>
                         <controls:TileView Shape="{Binding GetShape}" Color="{Binding GetColor}"></controls:TileView>
                     </Border>
@@ -103,19 +125,20 @@
             </CollectionView.ItemTemplate>
         </CollectionView>
 
+        <Label HorizontalOptions="Center" Grid.Row="1" Grid.Column="2" FontSize="Medium" Text="{Binding PlayerList[3].NameTag}"></Label>
         <CollectionView Grid.Row="1" Grid.Column="2" ItemsSource="{Binding PlayerList[3].Tiles}"
                         HorizontalOptions="Center"
-                        VerticalOptions="Center" >
+                        VerticalOptions="Center">
             <CollectionView.ItemsLayout>
-                <GridItemsLayout Orientation="Vertical"/>
+                <GridItemsLayout Orientation="Vertical" />
             </CollectionView.ItemsLayout>
             <CollectionView.ItemTemplate>
                 <DataTemplate>
                     <Border WidthRequest="70" HeightRequest="70"
-                        BackgroundColor="{Binding ColorBC4, Source={x:Reference root}}"
+                            BackgroundColor="{Binding ColorBC4, Source={x:Reference root}}"
-                        Margin="0">
+                            Margin="0">
                         <Border.GestureRecognizers>
-                            <DragGestureRecognizer CanDrag="True" DragStarting="OnDragStarting"/>
+                            <DragGestureRecognizer CanDrag="True" DragStarting="OnDragStarting" />
                         </Border.GestureRecognizers>
                         <controls:TileView Shape="{Binding GetShape}" Color="{Binding GetColor}"></controls:TileView>
                     </Border>
@@ -123,19 +146,20 @@
             </CollectionView.ItemTemplate>
         </CollectionView>
 
+        <Label HorizontalOptions="Center" VerticalOptions="End" Grid.Row="2" Grid.Column="1" FontSize="Medium" Text="{Binding PlayerList[1].NameTag}"></Label>
         <CollectionView Grid.Row="2" Grid.Column="1" ItemsSource="{Binding PlayerList[1].Tiles}"
                         HorizontalOptions="Center"
-                        VerticalOptions="Start" >
+                        VerticalOptions="Start">
             <CollectionView.ItemsLayout>
-                <GridItemsLayout Orientation="Horizontal"/>
+                <GridItemsLayout Orientation="Horizontal" />
             </CollectionView.ItemsLayout>
             <CollectionView.ItemTemplate>
                 <DataTemplate>
                     <Border WidthRequest="70" HeightRequest="70"
-                        BackgroundColor="{Binding ColorBC2, Source={x:Reference root}}"
+                            BackgroundColor="{Binding ColorBC2, Source={x:Reference root}}"
                             Margin="0">
                         <Border.GestureRecognizers>
-                            <DragGestureRecognizer CanDrag="True" DragStarting="OnDragStarting"/>
+                            <DragGestureRecognizer CanDrag="True" DragStarting="OnDragStarting" />
                         </Border.GestureRecognizers>
                         <controls:TileView Shape="{Binding GetShape}" Color="{Binding GetColor}"></controls:TileView>
                     </Border>
@@ -146,56 +170,59 @@
         <ScrollView Grid.Row="1" Grid.Column="1" VerticalOptions="FillAndExpand">
             <CollectionView ItemsSource="{Binding Board.ReadCells}"
                             HorizontalOptions="Center"
-                            VerticalOptions="Center" HorizontalScrollBarVisibility="Never" VerticalScrollBarVisibility="Never"
+                            VerticalOptions="Center" HorizontalScrollBarVisibility="Never"
-                            >
+                            VerticalScrollBarVisibility="Never">
 
                 <CollectionView.HeightRequest>
 
-                    <MultiBinding Converter="{StaticResource multiMathExpressionConverter}" ConverterParameter="x0 * x1 +(x0 - 1) * x2 ">
+                    <MultiBinding Converter="{StaticResource multiMathExpressionConverter}"
+                                  ConverterParameter="x0 * x1 +(x0 - 1) * x2 ">
                         <Binding Path="Board.Rows" />
                         <Binding Source="{StaticResource CellHeight}" />
                         <Binding Source="{StaticResource VerticalSpacing}" />
                     </MultiBinding>
 
                 </CollectionView.HeightRequest>
-                
+
-                
+
                 <CollectionView.WidthRequest>
-                    
+
-                    <MultiBinding Converter="{StaticResource multiMathExpressionConverter}" ConverterParameter="x0 * x1 +(x0 - 1) * x2 ">
+                    <MultiBinding Converter="{StaticResource multiMathExpressionConverter}"
+                                  ConverterParameter="x0 * x1 +(x0 - 1) * x2 ">
                         <Binding Path="Board.Columns" />
                         <Binding Source="{StaticResource CellWidth}" />
                         <Binding Source="{StaticResource HorizontalSpacing}" />
                     </MultiBinding>
-                    
+
                 </CollectionView.WidthRequest>
 
                 <CollectionView.ItemsLayout>
                     <GridItemsLayout Orientation="Vertical"
-                                    Span="{Binding Board.Columns}"
+                                     Span="{Binding Board.Columns}"
-                                    HorizontalItemSpacing="{StaticResource HorizontalSpacing}"
+                                     HorizontalItemSpacing="{StaticResource HorizontalSpacing}"
-                                    VerticalItemSpacing="{StaticResource VerticalSpacing}"/>
+                                     VerticalItemSpacing="{StaticResource VerticalSpacing}" />
                 </CollectionView.ItemsLayout>
                 <CollectionView.ItemTemplate>
                     <DataTemplate>
                         <Border WidthRequest="{StaticResource CellWidth}"
-                    HeightRequest="{StaticResource CellHeight}"
+                                HeightRequest="{StaticResource CellHeight}"
                                 BackgroundColor="WhiteSmoke">
-                            <Border.GestureRecognizers >
+                            <Border.GestureRecognizers>
                                 <DropGestureRecognizer DragOver="OnDragOver"
                                                        DropCommand="{Binding OnDrop, Source={x:Reference root}}"
-                                                       DropCommandParameter="{Binding .}"/>
+                                                       DropCommandParameter="{Binding .}" />
                             </Border.GestureRecognizers>
-                            <controls:TileView HorizontalOptions="Center" Shape="{Binding Tile.GetShape}" Color="{Binding Tile.GetColor}"></controls:TileView>
+                            <controls:TileView HorizontalOptions="Center" Shape="{Binding Tile.GetShape}"
+                                               Color="{Binding Tile.GetColor}">
+                            </controls:TileView>
                         </Border>
                     </DataTemplate>
                 </CollectionView.ItemTemplate>
             </CollectionView>
         </ScrollView>
 
-        <controls:Scoreboard InputTransparent="True" HorizontalOptions="End" Grid.Row="1" Grid.Column="1" ></controls:Scoreboard>
+        <controls:Scoreboard InputTransparent="True" HorizontalOptions="End" Grid.Row="1" Grid.Column="1"></controls:Scoreboard>
-
 
 
     </Grid>
-</ContentPage>
+</ContentPage>

Qwirkle/QwirkleViews/Pages/Leaderboard.xaml

@@ -1,77 +1,73 @@
-<?xml version="1.0" encoding="utf-8" ?>
+<?xml version="1.0" encoding="utf-8"?>
+
 <ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
              xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
              x:Class="Qwirkle.Pages.Leaderboard"
              xmlns:controls="clr-namespace:Qwirkle.Views"
-             Title="Leaderboard">
+             Title="Leaderboard"
-    
+             x:Name="root">
+
     <ScrollView>
         <VerticalStackLayout Spacing="25" Padding="5, 5, 5, 10">
             <Grid Style="{StaticResource GridMain}">
                 <controls:GoBack></controls:GoBack>
-                <Label Text="Leaderboard" 
+                <Label Text="Leaderboard"
-                        Style="{StaticResource Title}"/>
+                       Style="{StaticResource Title}" />
             </Grid>
 
             <Border Style="{StaticResource TabBorder}">
 
                 <Border.Shadow>
-                    <Shadow/>
+                    <Shadow />
                 </Border.Shadow>
                 <Border.StrokeShape>
-                    <RoundRectangle CornerRadius="3"/>
+                    <RoundRectangle CornerRadius="3" />
                 </Border.StrokeShape>
 
-                <VerticalStackLayout>
+                <StackLayout>
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+                    <Grid ColumnDefinitions="4*, auto, 2*, auto, 2*, auto, 2*"
-                    <Rectangle/>
+                          RowDefinitions="50">
-
+                        <Label
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+                            Text="Player tag"
-                    <Rectangle/>
+                            Style="{StaticResource ContentTab}" />
-
+                        <Rectangle
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+                            Style="{StaticResource RectangleTab}"
-                    <Rectangle/>
+                            Grid.Column="1" />
-
+                        <Label
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+                            Grid.Column="2"
-                    <Rectangle/>
+                            Text="Date"
-
+                            Style="{StaticResource ContentTab}" />
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+                        <Rectangle
-                    <Rectangle/>
+                            Style="{StaticResource RectangleTab}"
-
+                            Grid.Column="3" />
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+                        <Label
-                    <Rectangle/>
+                            Grid.Column="4"
-
+                            Text="Points"
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+                            Style="{StaticResource ContentTab}" />
-                    <Rectangle/>
+                        <Rectangle
-
+                            Style="{StaticResource RectangleTab}"
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+                            Grid.Column="5" />
-                    <Rectangle/>
+                        <Label
-
+                            Grid.Column="6"
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+                            Style="{StaticResource ContentTab}"
-                    <Rectangle/>
+                            Text="Victories" />
-
+                    </Grid>
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+
-                    <Rectangle/>
+                    <CollectionView ItemsSource="{Binding Lb}">
-
+                        <CollectionView.ItemsLayout>
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+                            <GridItemsLayout Orientation="Vertical" />
-                    <Rectangle/>
+                        </CollectionView.ItemsLayout>
-
+                        <CollectionView.ItemTemplate>
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+                            <DataTemplate>
-                    <Rectangle/>
+                                <controls:LeaderboardLine PlayerName="{Binding PlayerName}" Date="{Binding Date}"
-
+                                                          Points="{Binding Points}" Victories="{Binding Victories}" />
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+                            </DataTemplate>
-                    <Rectangle/>
+                        </CollectionView.ItemTemplate>
-
+                    </CollectionView>
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
+
-                    <Rectangle/>
+                </StackLayout>
-
-                    <controls:LeaderboardLine></controls:LeaderboardLine>
-                </VerticalStackLayout>
             </Border>
 
         </VerticalStackLayout>
-
-
     </ScrollView>
-
 </ContentPage>

Qwirkle/QwirkleViews/Pages/Leaderboard.xaml.cs

@@ -5,5 +5,6 @@ public partial class Leaderboard : ContentPage
 	public Leaderboard()
 	{
 		InitializeComponent();
-	}
+		BindingContext = ((App)Application.Current!).Ld;
+    }
 }

Qwirkle/QwirkleViews/Pages/Rules.xaml

@@ -10,7 +10,8 @@
             <Grid Style="{StaticResource GridMain}">
                 <controls:GoBack></controls:GoBack>
                 <Label Text="Qwirkle Rules"
-                       Style="{StaticResource Title}" />
+                       Style="{StaticResource Title}"
+ />
             </Grid>
             
             <Label
@@ -45,6 +46,34 @@
             <Label
                 Text="2. On a line assigned to a certain color/shape, the tiles must have the same color/shape."
                 Style="{StaticResource RulesContent}" />
+            <Label
+                Text="3. For a line assigned to a certain color/shape, if a tile of a specific shape/color has already been placed, they can't place it again."
+                Style="{StaticResource RulesContent}" />
+            <Label
+                Text="Example: If a player has already placed a blue square on a line assigned to the color blue, they can't place another blue square on the same line."
+                Style="{StaticResource RulesSubContent}" />
+            
+            <Label
+                Text="Swapping your tiles"
+                Style="{StaticResource RulesSubTitle2}" />
+
+            <Label
+                Text="If a player can't place any tiles on the board, they can swap between 1 and 6 of their tiles with the remaining ones in the bag."
+                Style="{StaticResource RulesContent}" />
+            <Label
+                Text="Swapping can be only done if the player didn't place any tile on this turn."
+                Style="{StaticResource RulesContent}" />
+            <Label
+                Text="This action makes the player skip their turn."
+                Style="{StaticResource RulesContent}" />
+            
+            <Label
+                Text="End of the game"
+                Style="{StaticResource RulesSubTitle}" />
+            <Label
+                Text="The game stops either right after a player has placed their last tile or when no player can place any more tiles."
+                Style="{StaticResource RulesContent}" />
+            
             
             
         </VerticalStackLayout>

Qwirkle/QwirkleViews/Pages/SetPlayers.xaml.cs

@@ -53,8 +53,9 @@ public partial class SetPlayers : ContentPage
             game.StartGame();
             game.GiveTilesToPlayers();
             game.SetNextPlayer();
-            Navigation.PushAsync(new Gameboard());
+            Shell.Current.GoToAsync("Gameboard");
-            
+
+
         }
 
         game.PlayerAddNotified -= Game_PlayerAddNotified;

Qwirkle/QwirkleViews/Pages/Settings.xaml.cs

@@ -6,9 +6,4 @@ public partial class Settings : ContentPage
 	{
 		InitializeComponent();
 	}
-
-    public void OnGoBackClicked(object sender, EventArgs e)
-    {
-        Navigation.PopAsync();
-    }
 }

Qwirkle/QwirkleViews/PopUpEndGame.xaml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<toolkit:Popup xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             x:Class="Qwirkle.PopUpEndGame"
+             xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit"
+             x:Name="root"
+             CanBeDismissedByTappingOutsideOfPopup="False"
+             xmlns:controls="clr-namespace:Qwirkle.Views"
+             >
+
+    <VerticalStackLayout HeightRequest="400" WidthRequest="500">
+
+        <Label
+                Text="THE END :("
+                Style="{StaticResource SuperTitle}"
+                FontSize="Medium"
+                />
+
+        <Label Text="THE WINNER IS :"></Label>
+
+        <Label Text="{Binding ScoreboardList[0].Key, Source={x:Reference root}}" Style="{StaticResource SuperTitle}" TextColor="HotPink" FontSize="Medium"></Label>
+
+        <controls:Scoreboard></controls:Scoreboard>
+
+        <Button Text="Skip" Style="{StaticResource GameButton}" Clicked="OnButtonNextClick"></Button>
+
+    </VerticalStackLayout>
+</toolkit:Popup>

Qwirkle/QwirkleViews/PopUpEndGame.xaml.cs

@@ -0,0 +1,40 @@
+using CommunityToolkit.Maui.Views;
+using Microsoft.Maui.Controls;
+using QwirkleClassLibrary.Games;
+using System.Collections.ObjectModel;
+
+namespace Qwirkle;
+
+public partial class PopUpEndGame : Popup
+{
+	public PopUpEndGame()
+	{
+		InitializeComponent();
+
+        var scoreboard = game.ObservableScoreBoard.OrderByDescending(x => x.Value).ThenBy(x => x.Key);
+        ScoreboardList = new ObservableCollection<KeyValuePair<string, int>>(scoreboard);
+    }
+
+    private Game game = ((App)Application.Current!).Game;
+
+    private ObservableCollection<KeyValuePair<string, int>>? scoreboardList;
+    public ObservableCollection<KeyValuePair<string, int>>? ScoreboardList
+    {
+        get => scoreboardList;
+        set
+        {
+            if (scoreboardList != value)
+            {
+                scoreboardList = value;
+                OnPropertyChanged(nameof(ScoreboardList));
+            }
+        }
+    }
+
+    public async void OnButtonNextClick(object sender, EventArgs e)
+    {
+        Close();
+        await Shell.Current.GoToAsync("MainPage");
+    }
+
+}

Qwirkle/QwirkleViews/Properties/launchSettings.json

@@ -1,7 +1,7 @@
 {
   "profiles": {
     "Windows Machine": {
-      "commandName": "MsixPackage",
+      "commandName": "Project",
       "nativeDebugging": false
     }
   }

Qwirkle/QwirkleViews/QwirkleViews.csproj

@@ -1,8 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
-		<TargetFrameworks>net8.0-android;net8.0-ios;net8.0-maccatalyst</TargetFrameworks>
+		<TargetFrameworks>net8.0-windows10.0.19041.0</TargetFrameworks>
-		<TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('windows'))">$(TargetFrameworks);net8.0-windows10.0.19041.0</TargetFrameworks>
 		<!-- Uncomment to also build the tizen app. You will need to install tizen by following this: https://github.com/Samsung/Tizen.NET -->
 		<!-- <TargetFrameworks>$(TargetFrameworks);net8.0-tizen</TargetFrameworks> -->
 
@@ -30,6 +29,9 @@
 		<ApplicationDisplayVersion>1.0</ApplicationDisplayVersion>
 		<ApplicationVersion>1</ApplicationVersion>
 
+		<WindowsPackageType Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'windows'">None</WindowsPackageType>
+		
+
 		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'ios'">11.0</SupportedOSPlatformVersion>
 		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'maccatalyst'">13.1</SupportedOSPlatformVersion>
 		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">21.0</SupportedOSPlatformVersion>
@@ -40,7 +42,8 @@
 
 	<ItemGroup>
 		<!-- App Icon -->
-		<MauiIcon Include="Resources\AppIcon\appicon.svg" ForegroundFile="Resources\AppIcon\appiconfg.svg" Color="#512BD4" />
+		<!-- <MauiIcon Include="Resources\AppIcon\appicon.svg" ForegroundFile="Resources\AppIcon\appiconfg.svg" Color="#512BD4" />-->
+		<MauiIcon Include="Resources\AppIcon\appicon.svg" />
 
 		<!-- Splash Screen -->
 		<MauiSplashScreen Include="Resources\Splash\splash.svg" Color="#512BD4" BaseSize="128,128" />
@@ -60,14 +63,15 @@
 	  <None Remove="Resources\Fonts\DiloWorld.ttf" />
 	  <None Remove="Resources\Fonts\Lexend-Medium.ttf" />
 	  <None Remove="Resources\Images\qwirklelogo.png" />
-	  <None Remove="Resources\Images\uca.png" />
+	  <None Remove="Resources\Images\uca.png" />     
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="CommunityToolkit.Maui" Version="9.0.0" />
+		<PackageReference Include="CommunityToolkit.Maui" Version="9.0.1" />
+		<PackageReference Include="CommunityToolkit.Maui.MediaElement" Version="3.1.1" />
 		<PackageReference Include="Microsoft.Maui.Controls" Version="8.0.40" />
 		<PackageReference Include="Microsoft.Maui.Controls.Compatibility" Version="8.0.40" />
-		<PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="9.0.0-preview.4.24266.19" />
+		<PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="8.0.0" />
 	</ItemGroup>
 
 	<ItemGroup>

Qwirkle/QwirkleViews/Resources/Styles/Styles.xaml

@@ -262,6 +262,14 @@
         <Setter Property="FontAttributes" Value="Bold" />
     </Style>
 
+    <Style TargetType="Label" x:Key="RulesSubTitle2">
+        <Setter Property="TextColor" Value="Black" />
+        <Setter Property="FontSize" Value="22" />
+        <Setter Property="Padding" Value="15" />
+        <Setter Property="HorizontalOptions" Value="Center" />
+        <Setter Property="FontAttributes" Value="Bold, Italic" />
+    </Style>
+
     <Style TargetType="Label" x:Key="ContentCenter">
         <Setter Property="TextColor" Value="Black" />
         <Setter Property="FontSize" Value="20" />
@@ -274,6 +282,13 @@
         <Setter Property="HorizontalOptions" Value="Center" />
     </Style>
 
+    <Style TargetType="Label" x:Key="RulesSubContent">
+        <Setter Property="TextColor" Value="Black" />
+        <Setter Property="FontSize" Value="14" />
+        <Setter Property="FontAttributes" Value="Italic"></Setter>
+        <Setter Property="HorizontalOptions" Value="Center" />
+    </Style>
+
     <Style TargetType="Label" x:Key="ContentStart">
         <Setter Property="TextColor" Value="Black" />
         <Setter Property="FontSize" Value="20" />

Qwirkle/QwirkleViews/Views/GoBack.xaml.cs

@@ -1,3 +1,5 @@
+using Qwirkle.Pages;
+
 namespace Qwirkle.Views;
 
 public partial class GoBack : ContentView

Qwirkle/QwirkleViews/Views/LeaderboardLine.xaml

@@ -1,42 +1,42 @@
 <?xml version="1.0" encoding="utf-8"?>
-
 <ContentView xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
              xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
-             x:Class="Qwirkle.Views.LeaderboardLine">
+             x:Class="Qwirkle.Views.LeaderboardLine"
+             x:Name="root">
+
     <Grid ColumnDefinitions="4*, auto, 2*, auto, 2*, auto, 2*"
           RowDefinitions="50">
-
+        
         <Label 
-            Text="Player Tag"
+            Text="{Binding PlayerName}"
-            Style="{StaticResource ContentTab}"
+            Style="{StaticResource ContentTab}"/>
-/>
+        
         <Rectangle
             Style="{StaticResource RectangleTab}"
             Grid.Column="1"/>
-
+        
         <Label
             Grid.Column="2"
-            Text="Date"
+            Text="{Binding Date, StringFormat='{0:MM/dd/yyyy}'}"
             Style="{StaticResource ContentTab}"/>
-
+        
         <Rectangle
             Style="{StaticResource RectangleTab}"
             Grid.Column="3"/>
-
+        
         <Label
             Grid.Column="4"
-            Text="Points"
+            Text="{Binding Points}"
             Style="{StaticResource ContentTab}"/>
-
+        
         <Rectangle
             Style="{StaticResource RectangleTab}"
             Grid.Column="5"/>
-                        
+        
         <Label
             Grid.Column="6"
             Style="{StaticResource ContentTab}"
-            Text="Victories"
+            Text="{Binding Victories}"/>
-         />
+        
-                        
     </Grid>
-</ContentView>
+</ContentView>

Qwirkle/QwirkleViews/Views/LeaderboardLine.xaml.cs

@@ -3,13 +3,51 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Microsoft.Maui.Controls;
 
-namespace Qwirkle.Views;
+namespace Qwirkle.Views
-
-public partial class LeaderboardLine : ContentView
 {
-    public LeaderboardLine()
+    public partial class LeaderboardLine : ContentView
     {
-        InitializeComponent();
+        public LeaderboardLine()
+        {
+            InitializeComponent();
+        }
+
+        public static readonly BindableProperty PlayerNameProperty =
+            BindableProperty.Create(nameof(PlayerName), typeof(string), typeof(LeaderboardLine), "");
+
+        public static readonly BindableProperty DateProperty =
+            BindableProperty.Create(nameof(Date), typeof(DateTime), typeof(LeaderboardLine), default(DateTime));
+
+        public static readonly BindableProperty PointsProperty =
+            BindableProperty.Create(nameof(Points), typeof(int), typeof(LeaderboardLine), 0);
+
+        public static readonly BindableProperty VictoriesProperty =
+            BindableProperty.Create(nameof(Victories), typeof(int), typeof(LeaderboardLine), 0);
+
+        public string PlayerName
+        {
+            get => (string)GetValue(PlayerNameProperty);
+            set => SetValue(PlayerNameProperty, value);
+        }
+
+        public DateTime Date
+        {
+            get => (DateTime)GetValue(DateProperty);
+            set => SetValue(DateProperty, value);
+        }
+
+        public int Points
+        {
+            get => (int)GetValue(PointsProperty);
+            set => SetValue(PointsProperty, value);
+        }
+
+        public int Victories
+        {
+            get => (int)GetValue(VictoriesProperty);
+            set => SetValue(VictoriesProperty, value);
+        }
     }
-}
+}

Qwirkle/QwirkleViews/Views/ScoreboardLine.xaml

@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-
-<ContentView xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
-             x:Class="Qwirkle.Views.ScoreboardLine"
-             x:Name="root">
-    <StackLayout>
-        <Grid ColumnDefinitions="4*, auto, 2*"
-          RowDefinitions="50">
-
-        <Label
-            Grid.Column="0"
-            Text="{Binding Nameplayer, Source={x:Reference root}}"
-            Style="{StaticResource ContentTab}"/>
-
-        <Rectangle
-            Style="{StaticResource RectangleTab}"
-            Grid.Column="1"/>
-
-            <Label
-            Grid.Column="2"
-            Text="{Binding Score, Source={x:Reference root}}"
-            Style="{StaticResource ContentTab}"/>
-        </Grid>
-    <Rectangle/>
-    </StackLayout>
-</ContentView>

Qwirkle/QwirkleViews/Views/ScoreboardLine.xaml.cs

@@ -1,43 +0,0 @@
-
-
-namespace Qwirkle.Views
-{
-    public partial class ScoreboardLine : ContentView
-    {
-        public static readonly BindableProperty NameplayerProperty =
-            BindableProperty.Create(nameof(Nameplayer), typeof(string), typeof(ScoreboardLine), default(string), propertyChanged: OnPlayerChanged);
-
-        public string Nameplayer
-        {
-            get => (string)GetValue(NameplayerProperty);
-            set => SetValue(NameplayerProperty, value);
-        }
-
-        private static void OnPlayerChanged(BindableObject bindable, object oldValue, object newValue)
-        {
-            var bin = (ScoreboardLine)bindable;
-            bin.OnPropertyChanged(nameof(Nameplayer));
-        }
-
-        public static readonly BindableProperty ScoreProperty =
-            BindableProperty.Create(nameof(Score), typeof(int), typeof(ScoreboardLine), default(int), propertyChanged: OnScoreChanged);
-
-        public int Score
-        {
-            get => (int)GetValue(ScoreProperty);
-            set => SetValue(ScoreProperty, value);
-        }
-
-        private static void OnScoreChanged(BindableObject bindable, object oldValue, object newValue)
-        {
-            var bin = (ScoreboardLine)bindable;
-            bin.OnPropertyChanged(nameof(Score));
-        }
-
-        public ScoreboardLine()
-        {
-            InitializeComponent();
-            BindingContext = this;
-        }
-    }
-}

Qwirkle/TestBase/TestGame.cs

@@ -287,25 +287,6 @@ public class TestGame
         Assert.False(game.PlaceTile(game.GetPlayingPlayer(), game.PlayerList[game.GetPlayingPlayerPosition()].Tiles[0], -5, 1));
     }
 
-    // [Fact]
-    // public void Test_DrawTile()
-    // {
-    //     Game game = new Game();
-    //     game.AddPlayerInGame("Test1");
-    //             game.AddPlayerInGame(playerstest);
-    //
-    //     game.StartGame();
-    //     game.SetNextPlayer();
-    //
-    //     Assert.True(game.DrawTiles(game.GetPlayingPlayer()));
-    //
-    //     /*test*/
-    //     TileBag bag = new TileBag(0);
-    //     Assert.False(game.DrawTiles(game.GetPlayingPlayer()));
-    //     return;
-    //
-    // }
-
     [Theory]
     [InlineData(true)]
     [InlineData(false)]
@@ -342,6 +323,48 @@ public class TestGame
         Assert.Equal(p, events.Player);
     }
 
+    [Fact]
+    public void Test_IsTilePlacementCorrect()
+    {
+        var game = new Game();
+        var board = new Board(17, 14);
+        var tile = new Tile(Shape.Club, Color.Red);
+
+        board.AddTileInCell(0, 1, new Tile(Shape.Club, Color.Blue));
+        
+        var x = 1;
+        var y = 1;
+
+        var surroundingCells = new List<Cell?>
+        {
+            board.GetCell(x + 1, y),
+            board.GetCell(x - 1, y),
+            board.GetCell(x, y + 1),
+            board.GetCell(x, y - 1)
+        };
+
+        bool result = game.IsTilePlacementCorrect(tile, x, y, board, surroundingCells);
+
+        Assert.True(result);
+    }
+
+    [Fact]
+    public void Test_IsMoveCorrect()
+    {
+        var game = new Game();
+        var board = new Board(17, 14);
+        var tile = new Tile(Shape.Club, Color.Red);
+
+        board.AddTileInCell(0, 1, new Tile(Shape.Club, Color.Blue));
+
+        var x = 2;
+        var y = 1;
+
+        bool result = game.IsMoveCorrect(tile, x, y, board);
+
+        Assert.False(result);
+    }
+
     [Fact]
     public void Test_IsMoveCorrectSixLine()
     {
@@ -381,6 +404,41 @@ public class TestGame
 
     }
 
+    [Fact]
+    public void Test_CheckTileInCompletedLines()
+    {
+        int nbTiles = 0;
+        var checkdoubles = new List<Tile>()
+        {
+            new(Shape.Club, Color.Blue),
+            new(Shape.Club, Color.Red),
+            new(Shape.Club, Color.Green),
+        };
+        
+        var t1 = new Tile(Shape.Club, Color.Green);
+        
+        Assert.False(Game.CheckTileInCompletedLines(t1, ref nbTiles, ref checkdoubles));
+    }
+
+    [Fact]
+    public void Test_CheckWrongCompletedLines()
+    {
+        var board = new Board(17, 14);
+        var checkDoubles = new List<Tile>();
+        int x = 4, y = 1, dx = 1, dy = 0;
+
+        board.AddTileInCell(1, 1, new Tile(Shape.Club, Color.Red));
+        board.AddTileInCell(2, 1, new Tile(Shape.Square, Color.Red));
+        board.AddTileInCell(3, 1, new Tile(Shape.Star, Color.Red));
+        board.AddTileInCell(5, 1, new Tile(Shape.Round, Color.Red));
+        board.AddTileInCell(6, 1, new Tile(Shape.Shuriken, Color.Red));
+        board.AddTileInCell(7, 1, new Tile(Shape.Rhombus, Color.Red));
+        
+        bool result = Game.CheckWrongCompletedLines(x, y, dx, dy, board, ref checkDoubles);
+
+        Assert.False(result);
+    }
+
     [Theory]
     [InlineData(3, 1, 4, 1, 5, 1, 5)]
     [InlineData(2, 2, 3, 2, 4, 2, 5)]
@@ -389,7 +447,7 @@ public class TestGame
     {
         var game = new Game();
         var player = new Player("TestPlayer");
-        var board = new Board(8, 8);
+        var board = game.GetBoard();
 
         board.AddTileInCell(1, 1, new Tile(Shape.Club, Color.Red));
         board.AddTileInCell(2, 1, new Tile(Shape.Square, Color.Red));
@@ -413,6 +471,14 @@ public class TestGame
 
         Assert.Equal(expectedScore, score);
     }
+    
+    [Theory]
+    [InlineData(0, -1, -1, 6)]
+    [InlineData(1, 0, 4, -1)]
+    public void Test_ShouldIncreaseScore(int dx, int dy, int cellsX, int cellsY)
+    {
+        Assert.True(Game.ShouldIncreaseScore(new Tuple<int, int>(dx, dy), new Tuple<int, int>(cellsX, cellsY)));
+    }
 
     [Fact]
     public void Test_EndOfGame()

Qwirkle/TestBase/TestLeaderboard.cs

@@ -50,8 +50,6 @@ public class TestLeaderboard
 
         leaderboard.AddScoreInLead(game.ScoreBoard);
 
-        var game2 = new Game();
-
         game.AddPlayerInGame(playerstest);
 
         game.StartGame();
@@ -61,7 +59,7 @@ public class TestLeaderboard
 
         leaderboard.AddScoreInLead(game.ScoreBoard);
 
-        Assert.Equal(2, leaderboard.Lb[0].Victories);
+        Assert.Equal(2, leaderboard.Lb[1].Victories);
     }
 
 

README.md

@@ -1,4 +1,3 @@
-
 [![Build Status](https://codefirst.iut.uca.fr/api/badges/jeremy.mouyon/sae201_qwirkle/status.svg)](https://codefirst.iut.uca.fr/jeremy.mouyon/sae201_qwirkle)
 
 # Notre QWIRKLE
@@ -9,7 +8,11 @@ Projet .NET MAUI portant sur la conception d'un jeu vidéo en reprenant un jeu d
 
 ## Présentation de notre jeu
 
-Notré présentation est consutable sur ce [lien](https://codefirst.iut.uca.fr/git/jeremy.mouyon/sae201_qwirkle/wiki/Pr%C3%A9sentation-du-jeu).
+Notre présentation est consutable sur ce [lien](https://codefirst.iut.uca.fr/git/jeremy.mouyon/sae201_qwirkle/wiki/Pr%C3%A9sentation-du-jeu).
+
+### Vidéo de présentation
+
+Voici le [lien](https://opencast.dsi.uca.fr/paella/ui/watch.html?id=4c3f5f66-69e8-4700-878e-3ec700e14640) de notre vidéo de présentation du jeu
 
 ## Composition du groupe
 
@@ -20,6 +23,17 @@ Notré présentation est consutable sur ce [lien](https://codefirst.iut.uca.fr/g
 
 ## *Comment utiliser notre application ?*
 
+### Executable
+
+Semé d'embûches, le chemin pour vous fournir un exécutable a finalement été trouvé. Il se trouve à la racine de notre projet.
+
+Vous pourrez via celui-ci, utiliser notre application de A à Z ! 
+
+*Nous ne sommes malheureusement pas en mesure de vous fournir un fichier .msix!*
+
+
+### Via un IDE
+
 Tout d'abord, récupérez notre projet en tapant dans votre terminal : 
 ```sh
 git clone https://codefirst.iut.uca.fr/git/jeremy.mouyon/sae201_qwirkle.git
@@ -53,9 +67,10 @@ Après cela, vous pourrez continuer à placer d'autres tuiles, si vous le souhai
 Si vous souhaitez échanger des des tuiles de votre main, vous pouvez choisir de les échanger avec des tuiles de la pioche. Entrez simplement les numéros correspondants des tuiles que vous voulez échanger.
 Attention, gardez à l'esprit que si vous choisissez cette option, vous ne pourrez pas jouer durant ce tour.
 
-### Et voilà !
+## Where is the sound ? 
+
+Vous vous demandez probablement où est passé le son ? Il n'y en a finalement pas eu. Le temps d'implémenter un système sonore avec un réglage était impossible dans les délais fixés. Nous avons quand même fait la page, conformément à notre conception !
 
-Votre partie est lancée ! Amusez-vous bien avec ce jeu de Qwirkle !
+## Et voilà !
 
-*PS pour Mr Chargueraud : Promesse faite, promesse tenue ! Mon problème de score est en grande partie réglé (non sans peine) !*
+Votre partie est lancée ! Amusez-vous bien avec ce jeu de Qwirkle ! :)
-*Le seul problème restant étant que sur certains cas, le +6 de la complétion de ligne peut s'effectuer 2 fois.*