more and more documentation, again

Qwirkle/QwirkleClassLibrary/Boards/Board.cs

@@ -60,9 +60,9 @@ namespace QwirkleClassLibrary.Boards
         }
 
         /// <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,92 +4,94 @@ using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 using QwirkleClassLibrary.Tiles;
 
-namespace QwirkleClassLibrary.Boards;
+namespace QwirkleClassLibrary.Boards
-
-/// <summary>
-/// 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>
-[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

@@ -122,7 +122,12 @@ 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]))

Qwirkle/QwirkleClassLibrary/Games/IPlayer.cs

@@ -3,30 +3,32 @@ using QwirkleClassLibrary.Boards;
 using QwirkleClassLibrary.Players;
 using QwirkleClassLibrary.Tiles;
 
-namespace QwirkleClassLibrary.Games;
+namespace QwirkleClassLibrary.Games
-
-/// <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();
+    /// <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, Tuple<int, int> orientation,
+        int CalculateAdjacentScore(Cell cell, Board b, ReadOnlyCollection<Cell> cellsPlayed, Tuple<int, int> orientation,
-        ref int nbCellsInLine, ref int nbCellsInPerpLine, ref List<Cell> checkedCells);
+            ref int nbCellsInLine, ref int nbCellsInPerpLine, ref List<Cell> checkedCells);
 
-    int CalculateLineScore(ReadOnlyCollection<Cell> cellsPlayed, Cell cell, Tuple<int, int> direction,
+        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);
+            Tuple<int, int> orientation, ref int nbCellsInLine, ref int nbCellsInPerpLine, ref List<Cell> checkedCells);
+    }
 }

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();
+            }
         }
     }
 }