cm10 file + swap event added + fixed tile placing event handling

Qwirkle/QwirkleClassLibrary/Events/SwapTilesNotifiedEventArgs.cs

@@ -0,0 +1,6 @@
+namespace QwirkleClassLibrary.Events;
+
+public class SwapTilesNotifiedEventArgs(string reason)
+{
+    public string Reason { get; private set; } = reason;
+}

Qwirkle/QwirkleClassLibrary/Games/Game.cs

@@ -58,13 +58,18 @@ namespace QwirkleClassLibrary.Games
 
         protected virtual void OnEndOfGame(EndOfGameNotifiedEventArgs args)
             => EndOfGameNotified?.Invoke(this, args);
+        
+        public event EventHandler<SwapTilesNotifiedEventArgs>? SwapTilesNotified;
+        
+        protected virtual void OnSwapTiles(SwapTilesNotifiedEventArgs args)
+            => SwapTilesNotified?.Invoke(this, args);
 
         /// <summary>
         /// Adds a player in the game if the game is not running, if the name is correct, if the game is not full and if the name is not already taken.
         /// </summary>
-        /// <param name="playerTag"></param>
+        /// <param name="playersTag"></param>
         /// <returns>boolean to check it</returns>
-        public bool AddPlayerInGame(List<string> PlayersTag)
+        public bool AddPlayerInGame(List<string> playersTag)
         {
             if (GameRunning)
             {
@@ -72,30 +77,30 @@ namespace QwirkleClassLibrary.Games
                 return false;
             }
 
-            for (int i = PlayersTag.Count - 1; i >= 0; i--)
+            for (int i = playersTag.Count - 1; i >= 0; i--)
             {
-                if (string.IsNullOrWhiteSpace(PlayersTag[i]))
+                if (string.IsNullOrWhiteSpace(playersTag[i]))
                 {
-                    PlayersTag.RemoveAt(i);
+                    playersTag.RemoveAt(i);
                 }
             }
 
-            if (PlayersTag.Count <= 1 || PlayersTag.Count > 4)
+            if (playersTag.Count <= 1 || playersTag.Count > 4)
             {
-                PlayersTag.Clear();
+                playersTag.Clear();
                 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--)
+            for (int i = playersTag.Count - 1; i >= 0; i--)
             {
-                if (!CheckPlayerTag(PlayersTag, i))
+                if (!CheckPlayerTag(playersTag, i))
                 {
-                    PlayersTag.RemoveAt(i);
+                    playersTag.RemoveAt(i);
                     return false;
                 }
             }
 
-            foreach (var tag in PlayersTag)
+            foreach (var tag in playersTag)
             {
                 Player pl = CreatePlayer(tag);
                 players.Add(pl);
@@ -106,27 +111,30 @@ namespace QwirkleClassLibrary.Games
             return true;
         }
 
-        public bool CheckPlayerTag(List<string> PlayersTag, int pos)
+        public bool CheckPlayerTag(List<string> playersTag, int pos)
         {
-            if (string.IsNullOrWhiteSpace(PlayersTag[pos]))
+            if (string.IsNullOrWhiteSpace(playersTag[pos]))
             {
                 OnPlayerNotified(new AddPlayerNotifiedEventArgs("ERROR with " + (pos + 1) + " entry : The name is null or white space."));
                 return false;
             }
 
-            for(int i=0; i<PlayersTag.Count; i++)
+            for (int i = 0; i < playersTag.Count; i++)
             {
                 if (i == pos)
                 {
                     continue;
                 }
-                if (PlayersTag[i] == PlayersTag[pos])
+
+                if (playersTag[i] == playersTag[pos])
                 {
-                    OnPlayerNotified(new AddPlayerNotifiedEventArgs("ERROR with " + (pos+1) + " entry : Name alreay taken"));
+                    OnPlayerNotified(
+                        new AddPlayerNotifiedEventArgs("ERROR with " + (pos + 1) + " entry : Name alreay taken"));
                     return false;
                 }
 
             }
+
             return true;
         }
 
@@ -318,7 +326,6 @@ namespace QwirkleClassLibrary.Games
                 return player.RemoveTileToPlayer(tile);
             }
 
-            OnPlaceTile(new PlaceTileNotifiedEventArgs(tile, " : Cell already used"));
             return false;
         }
 
@@ -356,11 +363,13 @@ namespace QwirkleClassLibrary.Games
         {
             if (tilesToSwap.Count == 0)
             {
+                OnSwapTiles(new SwapTilesNotifiedEventArgs("You must select at least one tile to swap !"));
                 return false;
             }
 
             if (bag!.TilesBag.Count < tilesToSwap.Count)
             {
+                OnSwapTiles(new SwapTilesNotifiedEventArgs("Not enough tiles in the bag to swap !"));
                 return false;
             }
 
@@ -486,6 +495,11 @@ namespace QwirkleClassLibrary.Games
                 return true;
             }
 
+            if (b.GetCell(x, y)!.GetTile == null)
+            {
+                OnPlaceTile(new PlaceTileNotifiedEventArgs(t, ": Cell already used !"));
+            }
+
             var surroundingCells = new List<Cell?>
             {
                 b.GetCell(x + 1, y),

cm10.cs

@@ -0,0 +1,122 @@
+// ==== Persistance ====
+
+// Enregistrer les meilleurs scores des parties (déjà prévu)
+// Enregistrer la partie en cours, à chaque coup et/ou quand on veut quitter le jeu (déjà prévu)
+// Faire un replay de la partie avec 2 joueurs (pas terrible, jeu déjà bien lent)
+
+// json(prefered 'cause lighter), binary, text, xml(prefered 'cause cleaner) files
+
+[DataContract(Name = "Player")]
+public class Player
+{
+    [DataMember(Name = "Name")]
+    public string Name { get; set; }
+
+    [DataMember(EmitDefaultValue = false)]
+    public int Score { get; set; }
+
+    public Player(string name, int score)
+    {
+        Name = name;
+        Score = score;
+    }
+}
+
+// Save
+var serializer = new DataContractSerializer(typeof(Player));
+
+using (Stream s = File.Create("player.xml"))
+{
+    serializer.WriteObject(s, new Player("John", 42));
+}
+
+// Load
+var serializer = new DataContractSerializer(typeof(Player));
+
+using (Stream s = File.OpenRead("player.xml"))
+{
+    var player = serializer.ReadObject(s) as Player;
+}
+
+// ===================
+// ===== Example =====
+// ===================
+
+[DataContract]
+public class Player
+{
+    [DataMember]
+    public string Name { get; set; }
+
+    [DataMember]
+    public int Score { get; set; }
+
+    public Player(string name, int score)
+    {
+        Name = name;
+        Score = score;
+    }
+}
+
+[DataContract]
+public class Result
+{
+    [DataMember]
+    public DateTime Date { get; set; }
+
+    [DataMember]
+    public Player[] Players { get; set; }
+
+    [DataMember]
+    public int WinnerId { get; set; }
+
+    public Result(DateTime date, Player[] players, int winnerId)
+    {
+        Players = new Player[players.Length];
+        for (int i = 0; i < players.Length; i++)
+        {
+            Players[i] = new Player(players[i].Name, players[i].Score);
+        }
+        Date = date;
+        WinnerId = winnerId;
+    }
+
+    public Result(Player[] players, int winnerId) : this(DateTime.Now, players, winnerId){}
+}
+
+public class ResultsManage
+{
+    public ReadOnlyCollection<Result> Results { get; private set; }
+    private readonly List<Result> results = new List<Result>();
+
+    public ResultsManage()
+    {
+        Results = new ReadOnlyCollection<Result>(results);
+    }
+
+    public void AddResult(int WinnerId, params Player[] players)
+    {
+        result.Add(new Result(players, WinnerId));
+    }
+}
+
+
+Result r = new Result([new Player("John", 42), new Player("Jane", 24)], 24);
+
+Directory.SetCurrentDirectory(Path.Combine(Directory.GetCurrentDirectory(), "..\\..\\..\\.."));
+Directory.CreateDirectory("Files");
+
+DataContractSerializer serializer = new DataContractSerializer(typeof(Result), new DataContractSerializerSettings
+{
+    PreserveObjectReferences = true
+});
+
+using (Stream s = File.Create(Path.Combine("Files", "result.xml")))
+{
+    serializer.WriteObject(s, r);
+}
+
+using (Stream s2 = File.OpenRead(Path.Combine("Files", "result.xml")))
+{
+    Result r2 = serializer.ReadObject(s2) as Result;
+}