[FEAT] mise en place des action pour passer

src/LittleTown.Core/Aggregates/BoardAggregate/Board.cs

@@ -0,0 +1,58 @@
+using System.Text.Json.Serialization;
+
+namespace LittleTown.Core;
+
+/// <summary>
+/// Represente un plateau de jeu dans un match
+/// Le plateau de littleTown est constitué 9 X 6 cases
+/// Chaque case est a un type et peut ou pas contenir un batiment
+/// /// </summary>
+public class Board
+{
+    /// <summary> Nombre de colonne dans le plateau </summary>
+    public int Width { get; init; }
+    /// <summary> Nombre de rangée dans le plateau </summary>
+    public int Height { get; init; }
+
+
+    [JsonInclude]
+    private Tile[] Tiles { get; init; } = new Tile[1];
+
+    /// <summary>
+    /// Permet de récupéré une tile sur le plateau, le 0,0 étant le bas gauche du plateau, x sur la largeur et y la hauteur
+    /// </summary>
+    /// <param name="x">la colonne de la tile partant de la gauche a 0</param>
+    /// <param name="y">ligne de la tile partant du bas a 0</param>
+    /// <returns>la tile</returns>
+    public Tile? GetTile(int x, int y)
+    {
+        if (x < 0 || x >= Width || y < 0 || y >= Height)
+            return null;
+
+        return Tiles[x + y * Width];
+    }
+
+    /// <summary>Permet de recuperer la liste des tiles autour de la position en parametre </summary>
+    /// <param name="x">la colonne au centre de la zone</param>
+    /// <param name="y">la rangée du centre de la zone</param>
+    /// <returns>une liste des tiles contenant entre 3(coin) et 8(centre) tiles</returns>
+    public ICollection<Tile> GetArea(int x, int y)
+    {
+        List<Tile> result = new List<Tile>();
+        for (int ix = -1; ix <= 1; ix++)
+        {
+            for (int iy = -1; iy <= 1; iy++)
+            {
+                if (iy != 0 || ix != 0)
+                {
+                    Tile? t = GetTile(x + ix, y + iy);
+                    if (null != t)
+                    {
+                        result.Add((Tile)t);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}

src/LittleTown.Core/Aggregates/BoardAggregate/Tile.cs

@@ -0,0 +1,28 @@
+using System.Text.Json.Serialization;
+using LittleTown.Core.Enums;
+
+namespace LittleTown.Core;
+
+/// <summary>
+/// Represente les infos d'une tile sur le plateau de jeu
+/// /// </summary>
+public record struct Tile
+{
+    /// <summary>
+    /// Le type de ressource présente sur cette Tile
+    /// </summary>
+    /// <value></value>
+    [JsonConverter(typeof(JsonStringEnumConverter))]
+    public ResourceType ResourceType { get; init; }
+
+    /// <summary>
+    /// Position X sur le plateau de cette tile, X = 0 a gauche du plateau
+    /// </summary>
+    /// <value></value>
+    public int PosX { get; init; }
+    /// <summary>
+    /// Position Y, sur la hauteur, du plateau, le Y = 0 est en bas du plateau
+    /// </summary>
+    /// <value></value>
+    public int PosY { get; init; }
+}

src/LittleTown.Core/Aggregates/MatchAggregate/Match.cs

@@ -0,0 +1,183 @@
+using LittleTown.Core.Actions;
+using LittleTown.Core.Exceptions;
+using LittleTown.Core.Ports;
+
+namespace LittleTown.Core;
+
+/// <summary>
+/// Represente un match de LittleTown
+/// </summary>
+public class Match
+{
+    /// <summary> LE numero du tour en cours (Partant de 1) </summary>
+    public int CurrentTurn { get; private set; } = 1;
+
+    /// <summary> l'id du joueur a qui c'est le tour de jouer</summary>
+    public string CurrentPlayer { get => _players[_playerTurnsOrder[_currentPlayerIndex]].PlayerName; }
+
+    /// <summary> Indique si le match est terminé </summary>
+    public bool IsDone { get; private set; }
+
+    /// <summary>la liste indiquant l'ordre des joueurs, _playerTurnsOrder[0] donne l'index du 1er joueur, _playerTurnsOrder[1] du second..... </summary>
+    private List<int> _playerTurnsOrder = new List<int>();
+
+    private const int _minPlayerCount = 2;
+    private const int _maxPlayerCount = 4;
+
+    private int _maxWorkerPerPlayer;
+    private int _maxBuidingPerPlayer;
+
+    private readonly Board _board;
+    private ICollection<Building> _buildings;
+    private ICollection<Objective> _objectives;
+
+    private Random _random = new Random();
+
+    private List<PlayerZone> _players = new();
+    private int _currentPlayerIndex;
+
+    /// <summary>
+    /// Constructeur d'une nouvelle partie avec un nombre de joueurs données en parametres
+    /// </summary>
+    /// <param name="staticData">un objet permettant de récupérer les données statiques du jeu</param>
+    public Match(IStaticDataGetter staticData)
+    {
+        ArgumentNullException.ThrowIfNull(staticData);
+
+        _board = staticData.GetBoard(1);
+        _buildings = staticData.GetBuildings();
+        _objectives = staticData.GetObjectives();
+    }
+
+    /// <summary> Ajouter un nouveau joueur a la partie </summary>
+    /// <param name="playerName">le nom du joueur</param>
+    public void AddPlayer(string playerName)
+    {
+        if (_players.Count < _maxPlayerCount)
+        {
+            if (_players.Any(p => p.PlayerName == playerName))
+            {
+                throw new MatchConfigException("Un joueur existe déjà avec ce nom");
+            }
+            _players.Add(new PlayerZone()
+            {
+                PlayerName = playerName
+            });
+        }
+        else
+        {
+            throw new MatchConfigException("Impossible d'ajouter de nouveau joueur, la partie est pleine");
+        }
+    }
+
+
+    /// <summary>
+    /// Demander au match d'executer une action si elle est autorisée
+    /// </summary>
+    /// <param name="action">l'action a réaliser</param>
+    public void ExecuteAction(IAction action)
+    {
+        ArgumentNullException.ThrowIfNull(action);
+
+        //quelques vérification génériques pour savoir si l'action peut être jouée
+        if (IsDone)
+        {
+            throw new MatchFinishedException("Impossible d'effectuer une action sur un match terminé");
+        }
+
+        //autoriser l'action a s'executer en lui donner les getters dont elle a besoin
+        action.Execute(this);
+    }
+
+    /// <summary> Initialiser la partie, il faut avoir ajouté les joueurs au préalable </summary>
+    /// <exception cref="MatchConfigException"></exception>
+    public void Init()
+    {
+        int nbPlayer = _players.Count;
+
+        ArgumentOutOfRangeException.ThrowIfLessThan(nbPlayer, _minPlayerCount);
+        ArgumentOutOfRangeException.ThrowIfGreaterThan(nbPlayer, _maxPlayerCount);
+
+        List<int> freeObjectiveIndexs = Enumerable.Range(0, _objectives.Count).ToList();
+        foreach (PlayerZone zone in _players)
+        {
+            zone.AddObjectives(GetRandomObjectives(nbPlayer switch
+            {
+                2 => 4,
+                3 => 3,
+                4 => 2,
+                _ => throw new MatchConfigException("Mauvais nombre de joueurs lors Workers")
+            }, freeObjectiveIndexs));
+            zone.AddRessources(Enums.ResourceType.Piece, 3);
+        }
+
+        _maxWorkerPerPlayer = nbPlayer switch
+        {
+            2 => 5,
+            3 => 4,
+            4 => 3,
+            _ => throw new MatchConfigException("Mauvais nombre de joueurs lors Workers")
+        };
+
+        _maxBuidingPerPlayer = nbPlayer switch
+        {
+            2 => 7,
+            3 => 6,
+            4 => 6,
+            _ => throw new MatchConfigException("Mauvais nombre de joueurs lors building")
+        };
+
+        // preparer l'ordre des joueurs
+        int index = _random.Next(nbPlayer);
+        for (int i = 0; i < nbPlayer; ++i)
+        {
+            _playerTurnsOrder.Add(index++);
+            if (index >= nbPlayer)
+                index = 0;
+        }
+
+        _currentPlayerIndex = 0;
+
+    }
+
+    /// <summary> Permet de récuperer une player zone(une copie) </summary>
+    /// <param name="playerName">le nom ou ID du joueur</param>
+    /// <returns></returns>
+    public PlayerZone GetPlayerZone(string playerName)
+    {
+        var value = _players.Where(p => p.PlayerName == playerName).FirstOrDefault();
+
+
+        if (null == value)
+            throw new ArgumentException("playerID is out of bound");
+
+        return value.Clone() as PlayerZone ?? throw new ArgumentException("Cast exception in GetPlayerZone"); ;
+    }
+
+    private List<Objective> GetRandomObjectives(int number, List<int> freeIndex)
+    {
+        List<Objective> result = new List<Objective>();
+        for (int i = 0; i < number; i++)
+        {
+            int randomIndex = _random.Next(freeIndex.Count);
+            int cardIndex = freeIndex[randomIndex];
+            freeIndex.RemoveAt(randomIndex);
+            result.Add(_objectives.ElementAt(randomIndex));
+        }
+        return result;
+    }
+    /// <summary> Changer le joueur en cours pour passer au suivant </summary>
+    public void NextPlayer()
+    {
+        _currentPlayerIndex++;
+        if (_currentPlayerIndex >= _players.Count)
+        {
+            _currentPlayerIndex = 0;
+            CurrentTurn++;
+        }
+        if (CurrentTurn >= 4)
+        {
+            IsDone = true;
+        }
+    }
+}

src/LittleTown.Core/Aggregates/PlayerZone/Objective.cs

@@ -0,0 +1,18 @@
+namespace LittleTown.Core;
+
+/// <summary>
+/// Représente une carte objectif dans le jeu, les objectif sont des conditions qui une fois remplie accordent des points au joueur
+/// </summary>
+public class Objective
+{
+    /// <summary> la description, une clé pour la traduction </summary>
+    public required string Description { get; init; }
+    /// <summary> la condition de l'objectif sous forme de formule </summary>
+    public string Formula { get; init; } = string.Empty;
+
+    /// <summary> le nombre de points que procure cet objectif </summary>
+    public int Points { get; init; }
+
+    /// <summary> indique si l'objectif a deja été atteint ou non, un objectif ne peut etre atteint qu'une fois </summary>
+    public bool Filled { get; init; }
+}

src/LittleTown.Core/Aggregates/PlayerZone/PlayerZone.cs

@@ -0,0 +1,59 @@
+using LittleTown.Core.Enums;
+
+namespace LittleTown.Core;
+/// <summary> Représente les données propre à un joueur </summary>
+public class PlayerZone : ICloneable
+{
+    /// <summary> Les ressources que possede le joueur </summary>
+    public IDictionary<ResourceType, int> Ressources { get; init; } = new Dictionary<ResourceType, int>();
+
+    /// <summary> l'id du joueur a cette zone </summary>
+    public required string PlayerName { get; init; }
+
+    /// <summary> La liste des objectifs que le joueur possede/// </summary>
+    public IReadOnlyCollection<Objective> Objectives { get => _objectives.AsReadOnly(); init => _objectives = new List<Objective>(value); }
+    private List<Objective> _objectives = new List<Objective>();
+
+    /// <summary> Le marqueur de score pendant le match </summary>
+    public int ScoreMarker { get; init; }
+
+    /// <summary> Permet d'ajouter d'une type de ressources au stock du joueur </summary>
+    /// <param name="res">le type de ressources</param>
+    /// <param name="qte">la quantité non nulle non négative</param>
+    public void AddRessources(ResourceType res, int qte)
+    {
+        ArgumentOutOfRangeException.ThrowIfLessThan(qte, 1);
+        if (Ressources.ContainsKey(res))
+        {
+            Ressources[res] += qte;
+        }
+        else
+        {
+            Ressources.Add(res, qte);
+        }
+    }
+
+    /// <summary>
+    /// Assigner des objectifs au joueur
+    /// </summary>
+    /// <param name="objectives"></param>
+    public void AddObjectives(ICollection<Objective> objectives)
+    {
+        _objectives.AddRange(objectives);
+    }
+
+    /// <summary> Cloner ce playerZone </summary>
+    /// <returns>Une copie de l'objet</returns>
+    public object Clone()
+    {
+        PlayerZone result = new PlayerZone()
+        {
+            Ressources = new Dictionary<ResourceType, int>(Ressources),
+            Objectives = new List<Objective>(Objectives),
+            ScoreMarker = ScoreMarker,
+            PlayerName = PlayerName
+        };
+
+        return result;
+    }
+}