orderstacks/TheGameExtreme/model/gameActions/classic/GameMode.cs

using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
using TheGameExtreme.model.deck;
using TheGameExtreme.model.@event;
using TheGameExtreme.model.gameActions;

namespace TheGameExtreme.model.gameActions.classic
{
    public class GameMode
    {

        protected List<GameAction> gameActions;
        protected Piles piles;
        protected int nbCardAtBeginOfTurn = 7;
        protected Deck deck;
        private int nbMaxCard;


        #region

        public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
        public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
        protected internal void OnTopRangeChanged(TopRangeChangedEventArgs args)
        {
            TopRangeChanged?.Invoke(this, args);
        }
        protected internal void OnPlayerChanged(PlayerChangedEventArgs args)
        {
            PlayerChanged?.Invoke(this, args);
        }

        #endregion


        public GameMode()
        {
            gameActions = new List<GameAction>();
        }

        public void load(int nbPlayer, List<Player> players)
        {
            piles = new Piles();

            gameActions.Add(new Piocher(piles));
            gameActions.Add(new JouerUneCarte(piles));
            gameActions.Add(new TerminerSonTour(piles));

            createDeck();
            defineNbMaxCard(nbPlayer);
            distribueCard(players);
        }

        protected void createDeck()
        {
            switch (true)
            {
                case false:
                    deck = new ClassicDeck();
                    break;

                default:
                    deck = new ExtremeDeck();
                    break;
            }
        }

        protected void defineNbMaxCard(int nbPlayer)
        {
            switch (nbPlayer)
            {
                case 1:
                    nbMaxCard = 8;
                    break;
                case 2:
                    nbMaxCard = 7;
                    break;
                default:
                    nbMaxCard = 6;
                    break;
            }
        }

        protected void distribueCard(List<Player> players)
        {
            for (int i = 0; i < nbMaxCard; i++)
            {
                players.ForEach(player =>
                {
                    int r = new Random().Next(0, deck.size() - 1);
                    player.pioche(deck.getCard(r));
                    deck.removeAt(r);
                });
            }
        }

        public void pioche(List<Card> currentHand, Player player)
        {
            ((Piocher)gameActions[0]).pioche(currentHand, deck, player);
        }

        public void playCard(int valueCard, List<Card> currentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
        {
            if (((JouerUneCarte)gameActions[1]).play(valueCard, currentHand, orderedStackSelected, player, CurrentCardPlayed))
            {
                OnTopRangeChanged(new TopRangeChangedEventArgs(piles.getStack(orderedStackSelected).Peek(), ((JouerUneCarte)gameActions[1]).OldCard, orderedStackSelected));
            }
        }

        public bool endTurn(List<Card> currentHand, List<Card> CurrentCardPlayed, Player player)
        {
            if (((TerminerSonTour)gameActions[2]).end(currentHand, nbCardAtBeginOfTurn, CurrentCardPlayed))
            {
                pioche(currentHand, player);
                nbCardAtBeginOfTurn = currentHand.Count;
                CurrentCardPlayed.Clear();
                
                OnPlayerChanged(new PlayerChangedEventArgs(currentHand, player.Pseudo));
                return false;
            }
            else
            {
                return true;
            }
            
            //if (isEndGame())    // Ajouter le score en calculant les cartes restantes dans la pile et dans les mains des joueurs
            //{
            //    displayWinner();
            //    return true;
            //}
            //else
            //{
            //    return true;
            //}
        }

        //protected void displayWinner()
        //{
        //    if (win)
        //    {
        //        EndMessage = "Le jeu est terminé!\n Bravo vous avez gagné!";
        //        EndMessage = AppRessource.StrWin;
        //    }
        //}














        //    private List<Rule> playRule = new List<Rule>();
        //    private List<Rule> beforeEndTurnRule = new List<Rule>();
        //    private List<Rule> endTurnRule = new List<Rule>();
        //    private List<Rule> commonRule = new List<Rule>();

        //    public GameMode()
        //    {
        //    }

        //    public void addPlayRule(PlayRule rule)
        //    {
        //        playRule?.Add(rule);
        //    }

        //    public void addEndTurnRule(EndTurnRule rule)
        //    {
        //        endTurnRule?.Add(rule);
        //    }

        //    public void addBeforeEndTurnRule(BeforeEndTurnRule rule)
        //    {
        //        beforeEndTurnRule?.Add(rule);
        //    }

        //    public void addCommonRule(Rule rule)
        //    {
        //        // Vérifier que se ne soit ni une PlayRule, ni une EndTurnRule ?
        //        commonRule?.Add(rule);
        //    }

        //    public bool checkPlayRule(Card card, Stack<Card> orderedStack, bool bottomUp, List<Card> CurrentHand)
        //    {
        //        foreach(PlayRule rule in playRule)
        //        {
        //            if (rule.Test(card, orderedStack, bottomUp, CurrentHand))    // Gestion des messages pour savoir qu'elle règle n'est pas respecter.
        //            {
        //                return true;
        //            }
        //        }
        //        foreach (Rule rule in commonRule)
        //        {

        //        }
        //        return false;
        //    }

        //    public bool checkBeforeEndTurnRule(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
        //    {
        //        foreach (BeforeEndTurnRule rule in beforeEndTurnRule)
        //        {
        //            if (!rule.Test(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand))    // Gestion des messages pour savoir qu'elle règle n'est pas respecter.
        //            {
        //                return false;
        //            }
        //        }
        //        foreach (Rule rule in commonRule)
        //        {

        //        }
        //        return true;
        //    }

        //    public bool checkEndTurnRule(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
        //    {
        //        foreach (EndTurnRule rule in endTurnRule)
        //        {
        //            if (!rule.Test(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand))    // Gestion des messages pour savoir qu'elle règle n'est pas respecter.
        //            {
        //                return false;
        //            }
        //        }
        //        foreach (Rule rule in commonRule)
        //        {

        //        }
        //        return true;
        //    }
    }
}