Merge de ruleZone

source/Trek-12/ConsoleApp/Program.cs

@@ -4,32 +4,35 @@
 
 using Models;
 using Models.Game;
+using Models.Rules;
 
-Position pos01 = new Position(0,0);
-Position pos02 = new Position(1,0);
-Position pos03 = new Position(2,0);
-Position pos04 = new Position(3,0);
-Position pos05 = new Position(4,0);
-
-Position pos11 = new Position(0, 1);
-Position pos12 = new Position(1, 1);
-Position pos13 = new Position(2, 1);
-Position pos14 = new Position(3, 1);
-Position pos15 = new Position(4, 1);
-
-Position pos21 = new Position(0, 2);
-Position pos22 = new Position(1, 2);
-Position pos23 = new Position(2, 2);
-Position pos24 = new Position(3, 2);
-Position pos25 = new Position(4, 2);
-
-Position pos31 = new Position(0, 3);
-Position pos32 = new Position(1, 3);
-Position pos33 = new Position(2, 3);
-Position pos34 = new Position(3,3);
-Position pos35 = new Position(4, 3);
-
-List<Position> list = new List<Position>();
+
+Cell pos01 = new Cell(0,0);
+Cell pos02 = new Cell(1,0);
+Cell pos03 = new Cell(2,0);
+Cell pos04 = new Cell(3,0);
+Cell pos05 = new Cell(4,0);
+
+Cell pos11 = new Cell(0, 1);
+Cell pos12 = new Cell(1, 1);
+Cell pos13 = new Cell(2, 1); //8
+Cell pos14 = new Cell(3, 1);
+Cell pos15 = new Cell(4, 1);
+
+Cell pos21 = new Cell(0, 2); //8
+Cell pos22 = new Cell(1, 2);
+Cell pos23 = new Cell(2, 2);
+Cell pos24 = new Cell(3, 2);
+Cell pos25 = new Cell(4, 2);
+
+Cell pos31 = new Cell(0, 3); //8
+Cell pos32 = new Cell(1, 3);
+Cell pos33 = new Cell(2, 3);
+Cell pos34 = new Cell(3,3);
+Cell pos35 = new Cell(4, 3);
+
+
+List<Cell> list = new List<Cell>();
 list.Add(pos01);
 list.Add(pos02);
 list.Add(pos03);
@@ -107,34 +110,82 @@ foreach (var item in list)
     if (i % 4 == 0) Console.Write(" |\n");
 }*/
 
+Player p2 = new Player("Luka");
+
+Game game = new Game(p2, new Map("background"));
 
-OperationsGrid grille = new OperationsGrid();
 
+//game.ResultOperation(Operation.ADDITION);
+//game.ResultOperation(Operation.MULTIPLICATION);
+//game.ResultOperation(Operation.LOWER);
+//game.ResultOperation(Operation.MULTIPLICATION);
+//game.ResultOperation(Operation.MULTIPLICATION);
+//game.ResultOperation(Operation.HIGHER);
 
-grille.ResultGrid(Operation.ADDITION);
-grille.ResultGrid(Operation.MULTIPLICATION);
-grille.ResultGrid(Operation.LOWER);
-grille.ResultGrid(Operation.MULTIPLICATION);
-grille.ResultGrid(Operation.MULTIPLICATION);
-grille.ResultGrid(Operation.HIGHER);
+game.UsedMap.Boards = list;
+
+game.PlaceResult(pos02, 5);
+game.PlaceResult(pos03, 5);
+game.PlaceResult(pos32, 5);
+
+game.PlaceResult(pos31, 8);
+game.PlaceResult(pos21, 8);
+game.PlaceResult(pos21, 8);
+game.PlaceResult(pos13, 8);
 
 int cpt = 0;
-foreach (var item in grille.Tiles)
+/*
+foreach (var item in game.UsedMap.Boards)
 {
     Console.Write(" | ");
-    Console.Write(item);
+    Console.Write(item.Value);
     cpt++;
     if (cpt % 4 == 0) Console.Write(" |\n");
 }
+*/
+
+for (int i = 0; i<game.UsedMap.Boards.Count; i++)
+{
+    Console.Write(" | ");
+    Console.Write(game.UsedMap.Boards[i].Value);
+    cpt++;
+    if (cpt % 5 == 0) Console.Write(" |\n");
+}
+
+Console.WriteLine(game.GameRules.IsZoneValidAndAddToZones(pos02, game.UsedMap));
+
+//Console.WriteLine(game.GameRules.IsZoneValidAndAddToZones(pos13, game.UsedMap));
+Console.WriteLine(game.GameRules.IsZoneValidAndAddToZones(pos31, game.UsedMap));
+Console.WriteLine(game.GameRules.IsZoneValidAndAddToZones(pos13, game.UsedMap));
+foreach(var oui in game.GameRules.EveryAdjacentCells(pos13, game.UsedMap.Boards))
+{
+    Console.WriteLine(oui.Value);
+}
+Console.WriteLine(game.GameRules.IsZoneValidAndAddToZones(pos32, game.UsedMap));
+Console.WriteLine(game.GameRules.IsZoneValidAndAddToZones(pos33, game.UsedMap));
+
+
+//affichage des zones
+foreach (var item in game.UsedMap.Zones)
+{
+    foreach (var cell in item)
+    {
+        Console.WriteLine(cell.Value);
+    }
+    Console.Write(" |\n");
+}
 
 
 
 Player p = new Player();
-Player p2 = new Player("Luka");
 Player p3 = new Player("Corento", "N/A");
 
 Console.WriteLine("Pseudo: " + p.Pseudo + "\nPhoto de Profil: " + p.ProfilePicture);
 Console.WriteLine("========================================================");
 Console.WriteLine("Pseudo: " + p2.Pseudo + "\nPhoto de Profil: " + p2.ProfilePicture);
 Console.WriteLine("========================================================");
-Console.WriteLine("Pseudo: " + p3.Pseudo + "\nPhoto de Profil: " + p3.ProfilePicture);
+Console.WriteLine("Pseudo: " + p3.Pseudo + "\nPhoto de Profil: " + p3.ProfilePicture);
+
+
+
+

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

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Dynamic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -21,7 +20,7 @@ namespace Models.Game
 
         private int Turn { get; set; }
 
-        private Rules.Rules GameRules { get; }
+        public Rules.Rules GameRules { get; }
 
         // == Events ==
         public event EventHandler<GameStartedEventArgs> GameStarted;
@@ -35,7 +34,7 @@ namespace Models.Game
             CurrentPlayer = player;
             Dice1 = new Dice();
             Dice2 = new Dice(1);
-            Turn = 0;
+            Turn = 1;
             GameRules = new Rules.Rules();
         }
 
@@ -69,19 +68,21 @@ namespace Models.Game
             }
         }
 
-        public void PlaceResult (Cell playerChoice, int result)
+        public void PlaceResult(Cell playerChoice, int result)
         {
-            if (Turn == 1 || GameRules.NearCell(playerChoice, UsedMap.Boards))
+            if (Turn == 1 || GameRules.NearCellIsValid(playerChoice, UsedMap.Boards))
             {
                 playerChoice.Value = result;
             }
         }
-
+        
+        /*
         public void AddToRopePath(Cell cell)
         {
             if (GameRules.IsRopePath(cell, ropePaths)) return;
-            
         }
+        */
+        
         
         public void InitializeGame()
         {

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

@@ -2,13 +2,13 @@
 
 public class Map
 {
-    public List<Cell> Boards { get; private set; };
+    public List<Cell> Boards { get; set; }
 
     public string Background { get; private set; }
 
     public List<OperationCell> OperationGrid { get; private set; }
 
-    public List<List<Cell>> RopePaths { get; private set; }
+    //public List<List<Cell>> RopePaths { get; private set; }
 
     public List<List<Cell>> Zones { get; private set; }
 
@@ -17,7 +17,9 @@ public class Map
         Boards = new List<Cell>();
         Background = background;
         OperationGrid = new List<OperationCell>();
-        RopePaths = new List<List<Cell>>();
+        //RopePaths = new List<List<Cell>>();
         Zones = new List<List<Cell>>();
+        
     }
+
 }

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

@@ -6,9 +6,9 @@ public class Player
 
     public string ProfilePicture { get; private set; }
 
-    public string CreationDate { get; private set; }
+    public string? CreationDate { get; private set; }
 
-    public string LastPlayed { get; private set; }
+    public string? LastPlayed { get; private set; }
 
     public Player()
     {

source/Trek-12/Models/Interfaces/IRules.cs

@@ -1,20 +1,39 @@
-namespace Models.Interfaces;
+using Models.Game;
+
+namespace Models.Interfaces;
 
 public interface IRules
-{    
-    public bool NearCellIsValid(Position playerChoicePosition, SortedDictionary<Position, Cell> cells);
+{
+    //public bool NearCellIsValid(Position playerChoicePosition, SortedDictionary<Position, Cell> cells);
+
+    //public bool IsCellEmpty(Cell playerChoice);
+
+    //public bool IsCellValid(Position playerChoicePosition, List<Position, Cell> cells);
+
+    //public bool IsRopePath(Cell playerChoice, HashSet<RopePath> ropePaths);
+
+    //public bool IsAdjacent(Cell cell1, Cell cell2, List<Position, Cell> cells);
+
+    //public int HowMany(Cell playerChoice, List<Position, Cell> cells);
+
+    //public void SetValueAndPenalty(int valueChoice, Cell playerChoice, List<Position, Cell> cells);
+
+    public bool IsCellAdjacent(Cell choosenCell, Cell targetCell);
+
+    public bool NearCellIsValid(Cell choosenCell, List<Cell> cells);
+
+    public bool IsZoneValidAndAddToZones(Cell chosenCell, Map map);
+
+    public bool IsValueInZones(Cell chosenCell, List<List<Cell>> zones);
+
+    public bool IsCellInZone(Cell chosenCell, List<List<Cell>> zones);
+
+    public void AddToZone(Cell chosenCell, List<List<Cell>> zones);
 
-    public bool IsCellEmpty(Cell playerChoice);
+    public void NewZoneIsCreated(Cell firstCell, Cell secondCell, Map map);
 
-    public bool IsCellValid(Position playerChoicePosition, List<Position, Cell> cells);
-    
-    public bool IsZone(Cell playerChoice, List<Position, Cell> cells);
+    public List<Cell> EveryAdjacentCells(Cell choosenCell, List<Cell> cells);
 
-    public bool IsRopePath(Cell playerChoice, HashSet<RopePath> ropePaths);
-    
-    public bool IsAdjacent(Cell cell1, Cell cell2, List<Position, Cell> cells);
-    
-    public int HowMany(Cell playerChoice, List<Position, Cell> cells);
+    public int? FinalCalculusOfZones(List<List<Cell>> zones);
 
-    public void SetValueAndPenalty(int valueChoice, Cell playerChoice, List<Position, Cell> cells);
 }

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

@@ -14,13 +14,15 @@ namespace Models.Rules
         {
             if (Math.Abs(choosenCell.X - targetCell.X) > 1 || Math.Abs(choosenCell.Y - targetCell.Y) > 1)
                 return false;
+            if (Math.Abs(choosenCell.X - targetCell.X) > 1 && Math.Abs(choosenCell.Y - targetCell.Y) > 1)
+                return false;
 
             return true;
         }
 
         public bool NearCellIsValid(Cell choosenCell, List<Cell> cells)
         {
-            if (choosenCell == null) return false;
+            if (choosenCell == null || cells == null) return false;
             
             IEnumerable<Cell> PlayedCellsQuery =
                 from cell in cells
@@ -33,14 +35,129 @@ namespace Models.Rules
 
                 return true;
             }
+
+            return false;
         }
 
-        public bool IsZone(Cell choosen, List<Cell> cells,List<List<Cell>> zones)
+        public bool IsZoneValidAndAddToZones(Cell chosenCell, Map map)
         {
-            IEnumerable<Cell> PlayedCellsQuery =
-                from cell in cells
-                where cell.Value != null
-                select cell;
+            if (chosenCell == null) return false;
+
+            List<Cell> adjacentCells = new List<Cell>();
+
+            adjacentCells = EveryAdjacentCells(chosenCell, map.Boards);
+
+            foreach(var cells in adjacentCells)
+            {
+                if (cells.Value == chosenCell.Value)
+                {
+                    if(IsValueInZones(cells, map.Zones))
+                    {
+                        AddToZone(chosenCell, map.Zones);
+                    }
+                    else
+                    {
+                        NewZoneIsCreated(chosenCell, cells, map);
+                    }
+                    //return true; // Il y a une cellule adjacente avec la même valeur donc une zone est créée si elle n'est pas déjà existante
+                    // Si il return true, tout c'est bien passer
+                }
+            }
+
+            return false;
+        }
+
+        public bool IsValueInZones(Cell chosenCell, List<List<Cell>> zones)
+        {
+            if (chosenCell == null) return false;
+
+            for (int i = 0; i < zones.Count; i++)
+            {
+                if (zones[i][0].Value == chosenCell.Value)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public bool IsCellInZone(Cell chosenCell, List<List<Cell>> zones)
+        {
+            if (chosenCell == null) return false;
+
+            for (int i = 0; i < zones.Count; i++)
+            {
+                if (zones[i].Contains(chosenCell))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public void AddToZone(Cell chosenCell, List<List<Cell>> zones)
+        {
+            if (chosenCell == null || chosenCell.Value == null) return;
+
+            if (IsCellInZone(chosenCell, zones)) return;
+
+            for (int i = 0; i < zones.Count; i++)
+            {
+                if (zones[i][0].Value == chosenCell.Value)
+                {
+                    zones[i].Add(chosenCell);
+                    return;
+                }
+            }
+            return;
+        }
+
+        public void NewZoneIsCreated(Cell firstCell, Cell secondCell, Map map)
+        {
+            if (firstCell == null || secondCell == null || firstCell.Value == null || secondCell.Value == null) return;
+            List<Cell> newZone = new List<Cell>();
+            newZone.Add(firstCell);
+            newZone.Add(secondCell);
+            map.Zones.Add(newZone);
+        }
+
+        public List<Cell> EveryAdjacentCells(Cell choosenCell, List<Cell> cells)
+        {
+            List<Cell> adjacentCells = new List<Cell>();
+
+            foreach (var cell in cells)
+            {
+                if (IsCellAdjacent(choosenCell, cell))
+                {
+                    adjacentCells.Add(cell);
+                }
+            }
+
+            return adjacentCells;
+        }
+
+        public int? FinalCalculusOfZones(List<List<Cell>> zones)
+        {
+            int? calculus = 0;
+            for(int i = 0; i < zones.Count; i++)
+            {
+                calculus += zones[i].Count * zones[i][0].Value;
+            }
+            return calculus;
+        }
+
+        public bool IsBugged(Cell chosenCell, List<List<Cell>> zones)
+        {
+            if (chosenCell == null) return false;
+
+            for (int i = 0; i < zones.Count; i++)
+            {
+                if (zones[i].Contains(chosenCell))
+                {
+                    return true;
+                }
+            }
+            return false;
         }
 
     }