🚧 Finalisation de la gameLoop

source/Trek-12/ConsoleApp/Program.cs

@@ -6,6 +6,9 @@ using Models.Exceptions;
 using Models.Game;
 using Models.Interfaces;
 using DataContractPersistence;
+using Microsoft.Extensions.Logging;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 
 namespace ConsoleApp;
 
@@ -34,12 +37,116 @@ class Program
             game.DiceRolled += OnDiceRolled!;
             game.OperationChosen += OnOperationChosen!;
             game.CellChosen += OnCellChosen!;
+            game.PlayerChooseOp += OnPlayerSelectionOp!;
+            game.PlayerOption += OnPlayerOption!;
+            game.PlayerChooseCell += OnPlayerSelectionCell!;
 
             // Initialisation
             game.InitializeGame(map, player);
         }
+
+
+    }
+
+    static void OnPlayerSelectionCell(Object sender, PlayerChooseCellEventArgs e)
+    {
+        int row, column;
+        while (true)
+        {
+            Console.ForegroundColor = ConsoleColor.Cyan;
+            Console.WriteLine("Enter the position of the cell you want to play");
+            Console.WriteLine("Enter the row number (0-6)");
+            Console.ResetColor();
+            if (!int.TryParse(Console.ReadLine(), out row) || row < 0 || row >= 7)
+            {
+                Console.ForegroundColor= ConsoleColor.Red;
+                Console.WriteLine("Invalid row number. Please enter a number between 0 and 6.");
+                Console.ResetColor();
+                continue;
+            }
+            Console.ForegroundColor = ConsoleColor.Cyan;
+            Console.WriteLine("Enter the column number (0-6)");
+            Console.ResetColor();
+            if (!int.TryParse(Console.ReadLine(), out column) || column < 0 || column >= 7)
+            {
+                Console.ForegroundColor = ConsoleColor.Red;
+                Console.WriteLine("Invalid column number. Please enter a number between 0 and 6.");
+                Console.ResetColor();
+                continue;
+            }
+
+            e.Cell = new Cell(row, column);
+            break;
+        }
+    }
+
+    static void OnPlayerOption(object sender, PlayerOptionEventArgs e)
+    {
+        Console.WriteLine();
+        if(e.Turn != 1)
+        {
+            IEnumerable<Cell> PlayedCellsQuery =
+                from cell in e.Board
+                where cell.Value != null
+                select cell;
+            foreach (var item in e.Board)
+            {
+                if (!item.Valid)
+                    Console.Write(" ");
+                else if (item.Value != null)
+                    Console.Write($"{item.Value}");
+                else
+                {
+                    foreach (var item1 in PlayedCellsQuery)
+                    {
+                        if (Math.Abs(item.X - item1.X) <= 1 && Math.Abs(item.Y - item1.Y) <= 1)
+                        {
+                            Console.ForegroundColor = ConsoleColor.Cyan;
+                            Console.Write($"{e.Resultat}");
+                            Console.ResetColor();
+                        }
+                    }
+                }
+            }
+        }
+        foreach (var item in e.Board)
+        {
+            if (!item.Valid)
+                Console.Write(" ");
+            else
+            {
+                Console.ForegroundColor = ConsoleColor.Cyan;
+                Console.Write($"{e.Resultat}");
+                Console.ResetColor();
+
+            }
+            if (item.X == 6)
+                Console.WriteLine();
+        }
+        Console.WriteLine();
+        Console.ForegroundColor = ConsoleColor.Cyan;
+        Console.WriteLine("Choose an Available cell.");
+        Console.ResetColor();
     }
 
+    static void OnPlayerSelectionOp(object sender, PlayerChooseOperationEventArgs e)
+    {
+        Console.WriteLine();
+        DisplayOperationTable(((Game)sender).UsedMap.OperationGrid.ToList());
+        Console.WriteLine();
+        Console.WriteLine("1. Lower |   2. Higher   |   3. Substraction |   4. Addition |   5. Multiplication");
+        string? op = Console.ReadLine();
+        while (op != "1" && op != "2" && op != "3" && op != "4" && op != "5")
+        {
+            Console.ForegroundColor = ConsoleColor.Red;
+            Console.WriteLine("Invalid operation. Please choose again.");
+            Console.ResetColor();
+            op = Console.ReadLine();
+        }
+        e.Operation = 3;
+    }
+
+
     /// <summary>
     /// Handles the event when the game has started.
     /// </summary>
@@ -66,10 +173,20 @@ class Program
     /// </summary>
     /// <param name="sender"></param>
     /// <param name="e"></param>
-    static void OnBoardUpdated(object sender, EventArgs e)
+    static void OnBoardUpdated(object sender, BoardsUpdateEventArgs e)
     {
-        DisplayBoard(((Game)sender).UsedMap);
-        DisplayOperationTable(((Game)sender).UsedMap.OperationGrid.ToList());
+        foreach (var item in e.Boards)
+        {
+            if (!item.Valid)
+                Console.Write(" ");
+            else
+            {
+                Console.Write($"{item.Value}");
+
+            }
+            if (item.X == 6)
+                Console.WriteLine();
+        }
     }
 
     /// <summary>
@@ -79,9 +196,12 @@ class Program
     /// <param name="e"></param>
     static void OnDiceRolled(object sender, DiceRolledEventArgs e)
     {
+       // Console.Clear();
         Console.WriteLine($"Dice 1: {e.Dice1Value} | Dice 2: {e.Dice2Value}");
-        Operation playerOperation = GetPlayerOperation(sender);
-        ((Game)sender).HandlePlayerOperation(playerOperation);
+        Console.WriteLine();
+        Console.ForegroundColor = ConsoleColor.Cyan;
+        Console.WriteLine("Choose an operation.");
+        Console.ResetColor();
     }
 
     /// <summary>
@@ -181,24 +301,28 @@ class Program
     /// <param name="operationTable">The operation table to display.</param>
     static void DisplayOperationTable(List<OperationCell> operationTable)
     {
-        Console.WriteLine("Operation Table:");
-        string[] operations = { "Addition (+)", "Subtraction (-)", "Multiplication (*)", "Lower Dice (less)", "Higher Dice (high)" };
-
-        for (int i = 0; i < operations.Length; i++)
+        Console.ForegroundColor = ConsoleColor.Yellow;
+        foreach ( var cell in operationTable)
         {
-            Console.Write(operations[i].PadRight(18));
             
-            for (int j = 0; j < 4; j++)
-            {
-                int index = i * 4 + j;
-                if (index < operationTable.Count)
-                {
-                    string status = operationTable[index].IsChecked ? "X" : " ";
-                    Console.Write($" | {status}");
-                }
-            }
-            Console.WriteLine();
+            if (cell.X == 0 && cell.Y == 0)
+                Console.Write("Lower  =>    ");
+            if (cell.X == 0 && cell.Y == 1)
+                Console.Write("Higher  =>    ");
+            if (cell.X == 0 && cell.Y == 2)
+                Console.Write("Substraction  =>    ");
+            if (cell.X == 0 && cell.Y == 3)
+                Console.Write("Addition  =>    ");
+            if (cell.X == 0 && cell.Y == 4)
+                Console.Write("Multiplication  =>    ");
+            if (cell.IsChecked)
+                Console.Write("X  |  ");
+            if (!cell.IsChecked)
+                Console.Write("   |  ");
+            if (cell.X == 3)
+                Console.WriteLine();
         }
+        Console.ResetColor();
     }
 
     /// <summary>

source/Trek-12/Models/Events/BoardsUpdateEventArgs.cs

@@ -7,7 +7,7 @@ namespace Models.Events
     /// </summary>
     public class BoardsUpdateEventArgs : EventArgs
     {
-        public List<Cell> Boards { get; }
+        public List<Cell> Boards { get; set; }
 
         public BoardsUpdateEventArgs(List<Cell> board)
         {

source/Trek-12/Models/Events/PlayerChooseCellEventArgs.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Models.Game;
+
+namespace Models.Events
+{
+    public class PlayerChooseCellEventArgs : EventArgs
+    {
+        public Cell Cell { get; set; }
+        public PlayerChooseCellEventArgs(Cell cell)
+        {
+            Cell = cell;
+        }
+    }
+}

source/Trek-12/Models/Events/PlayerChooseOperationEventArgs.cs

@@ -0,0 +1,19 @@
+using Models.Game;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Models.Events
+{
+    public class PlayerChooseOperationEventArgs : EventArgs
+    {
+        public int Operation { get; set; }
+
+        public PlayerChooseOperationEventArgs(int op)
+        {
+            Operation = op;
+        }
+    }
+}

source/Trek-12/Models/Events/PlayerOptionEventArgs.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Models.Game;
+
+namespace Models.Events
+{
+    public class PlayerOptionEventArgs : EventArgs
+    {
+        public List<Cell> Board { get; set; }
+        public int Resultat {  get; set; }
+        public int Turn { get; set; }
+
+        public PlayerOptionEventArgs(List<Cell> boards, int resultat, int turn)
+        {
+            Board = boards;
+            Resultat = resultat;
+            Turn = turn;
+        }
+    }
+}

source/Trek-12/Models/Game/Game.cs

@@ -115,6 +115,10 @@ namespace Models.Game
         public event EventHandler<DiceRolledEventArgs> DiceRolled;
         public event EventHandler<OperationChosenEventArgs> OperationChosen;
         public event EventHandler<CellChosenEventArgs> CellChosen;
+        public event EventHandler<PlayerChooseOperationEventArgs> PlayerChooseOp;
+        public event EventHandler<PlayerOptionEventArgs> PlayerOption;
+        public event EventHandler<PlayerChooseCellEventArgs> PlayerChooseCell;
+
 
         public void AddPlayer(Player player)
         {
@@ -224,9 +228,9 @@ namespace Models.Game
         /// Marks an operation as checked in the operation grid of the game.
         /// </summary>
         /// <param name="operation"></param>
-        public void MarkOperationAsChecked(Operation operation)
+        private void MarkOperationAsChecked(Operation operation)
         {
-            int operationIndex = (int)operation;
+             int operationIndex = (int)operation;
             IEnumerable<OperationCell> sortPaths =
                 from cell in UsedMap.OperationGrid
                 where cell.Y == operationIndex
@@ -264,8 +268,6 @@ namespace Models.Game
                 Operation.MULTIPLICATION => Dice2.Value * Dice1.Value,
                 _ => throw new ArgumentOutOfRangeException()
             };
-
-            MarkOperationAsChecked(o);
             return result;
         }
 
@@ -276,25 +278,18 @@ namespace Models.Game
         /// </summary>
         /// <param name="playerChoice">The cell chosen by the player to place the result.</param>
         /// <param name="result">The result of the dice operation to be placed in the cell.</param>
-        private bool PlaceResult(Cell playerChoice, int result)
+        private void PlaceResult(Cell playerChoice, int result)
         {
-            if (Turn == 1 || GameRules.NearCellIsValid(playerChoice, UsedMap.Boards.ToList()))
+            IEnumerable<Cell> ValidCell =
+                from cell in UsedMap.Boards
+                where cell.Value == null
+                where cell.Valid == true
+                select cell;
+            foreach (var item in ValidCell)
             {
-                for (int i = 0; i < UsedMap.Boards.Count; i++)
-                {
-                    if (UsedMap.Boards[i].X == playerChoice.X && UsedMap.Boards[i].Y == playerChoice.Y)
-                    {
-                        if (UsedMap.Boards[i].Value != null)
-                            return false;
-                        UsedMap.Boards[i].Value = result;
-                        BoardUpdated?.Invoke(this, new BoardsUpdateEventArgs(UsedMap.Boards.ToList()));
-                        return true;
-                    }
-                }
-                //playerChoice.Value = result;
+                if(item.X == playerChoice.X && item.Y == playerChoice.Y)
+                    item.Value = result;
             }
-            return false;
-            
         }
 
         /// <summary>
@@ -376,30 +371,44 @@ namespace Models.Game
         /// </summary>
         private void GameLoop()
         {
+            int res = 0,turn = 1;
+            Cell cell;
             while (IsRunning)
             {
-                if (Turn == 20)
-                {
-                    foreach(var cells in UsedMap.Boards.ToList())
-                    {
-                        GameRules.IsZoneValidAndAddToZones(cells, UsedMap);
-                        AddToRopePath(cells, GameRules.EveryAdjacentCells(cells, UsedMap.Boards.ToList()));
-                    }
-                    int? points = GameRules.FinalCalculusOfZones(UsedMap.Zones);
-                    for (int i = 0; i < UsedMap.RopePaths.Count; i++)
-                    {
-                        points += GameRules.ScoreRopePaths(UsedMap.RopePaths[i]);
-                    }
-                    EndGame(points);
-                    break;
-                }
-                
                 RollAllDice();
+                res = PlayerChooseOperation();
+                PlayerOption?.Invoke(this,new PlayerOptionEventArgs(UsedMap.Boards.ToList(),res,turn));
+                cell = PlayerCell();
+                PlaceResult(cell,res);
+                BoardUpdated?.Invoke(this, new BoardsUpdateEventArgs(UsedMap.Boards.ToList()));
 
-                Turn++;
             }
         }
 
+        public int PlayerChooseOperation()
+        {
+            int operation=0;
+            PlayerChooseOp?.Invoke(this, new PlayerChooseOperationEventArgs(operation));
+            while(!GameRules.OperationAvailable(operation,UsedMap.OperationGrid.ToList()))
+            {
+                PlayerChooseOp?.Invoke(this, new PlayerChooseOperationEventArgs(operation));
+            }
+            MarkOperationAsChecked((Operation)operation);
+            return ResultOperation((Operation)operation);
+        }
+
+        public Cell PlayerCell()
+        {
+            Cell ?playerCell = new Cell(1,0);
+            playerCell.Valid = true;
+            PlayerChooseCell?.Invoke(this,new PlayerChooseCellEventArgs(playerCell));
+            while(!GameRules.NearCellIsValid(playerCell,UsedMap.Boards.ToList()))
+            {
+                PlayerChooseCell?.Invoke(this, new PlayerChooseCellEventArgs(playerCell));
+            }
+            return playerCell;
+        }
+        
         /// <summary>
         /// Handles the player's choice of an operation based on the dice values.s
         /// </summary>
@@ -431,7 +440,7 @@ namespace Models.Game
                 //throw new InvalidCellException("Cell is not valid. Please choose again.");
             }
 
-            bool res = PlaceResult(cell, result);
+            bool res = true;
             if (!res)
             {
                 return false;

source/Trek-12/Models/Game/Map.cs

@@ -72,7 +72,7 @@ namespace Models.Game
         {
             for (int i = 0; i < 49; i++) // 7x7 board
             {
-                board.Add(new Cell(i / 7, i % 7));
+                board.Add(new Cell(i % 7, i / 7));
             }
             board[1].Valid = true;
             board[3].Valid = true;

source/Trek-12/Models/Rules/Rules.cs

@@ -110,11 +110,13 @@ namespace Models.Rules
 
             IEnumerable<Cell> PlayedCellsQuery =
                 from cell in cells
-                where cell.Value != null
+                where cell.Valid == true
                 select cell;
 
             foreach (var cell in PlayedCellsQuery)
             {
+                if (choosenCell.X == cell.X && choosenCell.Y == cell.Y && cell.Value == null)
+                    return true;
                 if (IsCellAdjacent(choosenCell, cell))
                 {
                     return true;
@@ -256,5 +258,19 @@ namespace Models.Rules
             return score;
         }
 
+        public bool OperationAvailable(int operation,List<OperationCell> operationGrid)
+        {
+            IEnumerable<OperationCell> row =
+                from cell in operationGrid
+                where cell.Y == operation
+                select cell;
+            foreach (var item in row)
+            {
+                if (!item.IsChecked)
+                    return true;
+            }
+            return false;
+        }
+
     }
 }