Giants/Src/Giants.Core/Src/Entities/Match.cs

using System.Collections;
using System.Reflection.Metadata.Ecma335;
using Giants.Core.Enums;

namespace Giants.Core;

/// <summary>
///  Il s'agit d'une instance d'une partie de Giants, c'est la racine de toutes les entitées de l'instance
///  l'objectif de cette classe est de pouvoir etre copiée tres rapidement avec la plus petite utilisation mémoire
///  Il faut également que la comparaison soit rapide et intelligente pour les besoins de l'IA
/// </summary>
public class Match
{
    #region données statiques

    public int Id { get; init; }
    public required BoardLayout Board { get; init; }

    #endregion

    #region données dynamiques
    /// <summary>
    /// IDs des joueurs qui participent a cette partie, 
    // -2 Pour une place non ouverte
    // -1 pour une place non occupée mais ouverte
    /// </summary>
    int[] players = [-1, -1, -1, -1, -1];

    /// <summary> Les scores des joueurs </summary>
    int[] scores = [-1, -1, -1, -1, -1];

    /// <summary> 
    /// etat des dés, -1 indique non utilisé et positif donne le numero de la face, 
    /// les 3 premiers dés sont les blanc et les 2 suivant les marrons 
    /// 4e dé utile pour la partie a 4 joueur, le 5e pour les parties a 5 joueurs
    /// </summary>
    int[] dices = [0, 0, 0, 0, 0,];

    /// <summary>
    /// Indique si pour une foret donnée le bois a ete ramassé, l'index et les quantités sont dans le boardLayout
    /// </summary>
    bool[] forestUsed = [false, false, false, false, false, false, false];

    /// <summary>
    /// un tableau indiquant ou sont placé les pieces, l'index est l'id de la piece et la valeur la position de la piece    /// 
    /// </summary>
    PiecePosition[] pieces = new PiecePosition[(int)Enum.GetValues(typeof(PieceIndex)).Cast<PieceIndex>().Max() + 1];
    #endregion

    #region Getters
    public static int MaxTribalMarker { get => 6; }
    public static int MaxSocle { get => 7; }

    public int NbPlayer { get => players.Count(p => p != -1); }

    public Player? GetPlayer(int index)
    {
        if (index >= 0 && index < players.Length && players[index] != -1)
            return new Player(this)
            {
                Index = index,
            };

        return null;
    }
    #endregion

    #region Setters for commands
    public void AssignPiece(PieceIndex piece, PiecePosition position)
    {
        pieces[(int)piece] = position;
    }

    public void SetPlayer(int index, int playerId)
    {
        players[index] = playerId;
    }

    public void SetScore(int index, int score)
    {
        scores[index] = score;
    }

    public int GetScore(int index)
    {
        return scores[index];
    }

    public PiecePosition GetPiece(PieceIndex PieceIndex)
    {
        return pieces[(int)PieceIndex];
    }

    #endregion

    /// <summary>
    /// Cloner ce match pour pouvoir le modifier
    /// </summary>
    /// <returns></returns>
    public Match Clone()
    {
        Match result = new Match()
        {
            Board = Board,
            Id = Id,
        };

        Buffer.BlockCopy(players, 0, result.players, 0, players.Length * sizeof(int));
        Buffer.BlockCopy(scores, 0, result.scores, 0, scores.Length * sizeof(int));
        Buffer.BlockCopy(dices, 0, result.dices, 0, dices.Length * sizeof(int));
        Buffer.BlockCopy(pieces, 0, result.pieces, 0, pieces.Length * sizeof(PieceIndex));
        Buffer.BlockCopy(forestUsed, 0, result.forestUsed, 0, forestUsed.Length * sizeof(bool));


        return result;

    }

    /// <summary> Permet de comparer des Match, cette methode est critique pour l'ia pour reduire son parcour d'arbre </summary>
    /// <param name="obj"></param>
    /// <returns></returns> <summary>
    public override bool Equals(object? obj)
    {
        if (obj is Match match)
        {
            return Enumerable.SequenceEqual(players, match.players) &&
                    Enumerable.SequenceEqual(scores, match.scores) &&
                    Enumerable.SequenceEqual(dices, match.dices) &&
                    Enumerable.SequenceEqual(pieces, match.pieces) &&
                    Enumerable.SequenceEqual(forestUsed, match.forestUsed);
        }
        return false;
    }

    /// <inheritdoc/>
    public override int GetHashCode()
    {
        return base.GetHashCode();
    }
}