mastermind/Sources/CoreLibrary/Partie.cs

using CoreLibrary.Events;
using CoreLibrary.Exceptions;

namespace CoreLibrary
{
    public class Partie
    {
        private readonly IRegles regles;

        public delegate string? StringEventHandler<in TEventArgs>(Object? sender, TEventArgs e);
        public delegate Jeton? JetonEventHandler<in TEventArgs>(Object? sender, TEventArgs e);

        public event StringEventHandler<DemanderJoueurEventArgs>? DemanderJoueur;
        public event JetonEventHandler<DemanderJetonEventArgs>? DemanderJeton;

        public event EventHandler<AjouterJoueursEventArgs>? AjouterJoueur;
        public event EventHandler<DebutPartieEventArgs>? DebutPartie;
        public event EventHandler<NouveauTourEventArgs>? NouveauTour;
        public event EventHandler<AjouterJetonEventArgs>? AjouterJeton;
        public event EventHandler<SupprimerDernierJetonEventArgs>? SupprimerDernierJeton;
        public event EventHandler<AjouterCodeEventArgs>? AjouterCode;
        public event EventHandler<PasserMainEventArgs>? PasserMain;
        public event EventHandler<PartieTermineeEventArgs>? PartieTerminee;

        private string? QuandDemanderJoueur(int numero) => DemanderJoueur?.Invoke(this, new DemanderJoueurEventArgs(numero));
        private Jeton? QuandDemanderJeton() => DemanderJeton?.Invoke(this, new DemanderJetonEventArgs());


        private void QuandAjouterJoueur(Joueur joueur) => AjouterJoueur?.Invoke(this, new AjouterJoueursEventArgs(joueur));
        private void QuandDebutPartie() => DebutPartie?.Invoke(this, new DebutPartieEventArgs());
        private void QuandNouveauTour(Joueur joueur, int tour, IEnumerable<IEnumerable<Jeton?>> grille, IEnumerable<IEnumerable<Indicateur>> indicateurs) => NouveauTour?.Invoke(this, new NouveauTourEventArgs(joueur, tour, grille, indicateurs));
        private void QuandNouveauJeton(Jeton jeton) => AjouterJeton?.Invoke(this, new AjouterJetonEventArgs(jeton));
        private void QuandSupprimerDernierJeton() => SupprimerDernierJeton?.Invoke(this, new SupprimerDernierJetonEventArgs());
        private void QuandNouveauCode(Code code) => AjouterCode?.Invoke(this, new AjouterCodeEventArgs(code));
        private void QuandPasserMain() => PasserMain?.Invoke(this, new PasserMainEventArgs());
        private void QuandPartieTerminee(IEnumerable<Joueur> gagnants, IEnumerable<Joueur> perdants) => PartieTerminee?.Invoke(this, new PartieTermineeEventArgs(gagnants, perdants));


        public Partie(IRegles regles)
        {
            this.regles = regles;
        }

        public void Jouer()
        {
            while (regles.NbJoueurs != regles.NbJoueursMaximum)
            {
                string nom = QuandDemanderJoueur(regles.NbJoueurs + 1) ?? $"Joueur {regles.NbJoueurs+1}";
                Joueur joueur = regles.AjouterJoueur(nom);
                QuandAjouterJoueur(joueur);
            }

            regles.CommencerLaPartie();
            QuandDebutPartie();

            while (!regles.EstTerminee())
            {
                Joueur joueurCourant = regles.JoueurCourant();
                Plateau plateauCourant = joueurCourant.Plateau; 

                QuandNouveauTour(joueurCourant, plateauCourant.Tour, plateauCourant.Grille(), plateauCourant.Indicateurs());

                Code code = regles.GenererCode();

                while (!code.EstComplet())
                {
                    Jeton? jeton = QuandDemanderJeton();

                    if(jeton == null)
                    {
                        if(DemanderJeton != null)
                        {
                            // Si quelqu'un écoute l'événement mais ne renvoie rien, alors on supprime le dernier jeton
                            code.SupprimerDernierJeton();
                            QuandSupprimerDernierJeton();
                        }
                        else
                        {
                            // Si personne n'écoute l'évenment, on met un jeton aléatoire
                            jeton = new Jeton();
                        }
                    }

                    if(jeton != null)
                    {
                        code.AjouterJeton(jeton.Value);
                        QuandNouveauJeton(jeton.Value);
                    }
                }
                plateauCourant.AjouterCode(code);
                QuandNouveauCode(code);

                regles.PasserLaMain();
                QuandPasserMain();
            }


            regles.Gagnants();
            regles.Perdants();

            QuandPartieTerminee(regles.Gagnants(), regles.Perdants());
        }
    }
}