orderstacks/TheGameExtreme/model/manager/GameManager.cs

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

namespace TheGameExtreme.model.manager
{
    public abstract class GameManager
    {

        public readonly int nbPlayer;
        protected int nbMaxCard;
        protected int currentIndexPlayer;
        protected List<Player> playerList = new List<Player>();
        public List<Stack<Card>> ListOrderedStacks { get; set; }
        protected Deck deck;
        protected bool win = true;
        public String EndMessage { get; set; }
        public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
        public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
        public List<Card> CurrentHand { get; set; }
        protected int nbCardAtBeginOfTurn;
        protected List<Card> CurrentCardPlayed = new List<Card>();
        protected string langue;


        public GameManager(int nbPlayer, List<String> players)
        {
            ListOrderedStacks = new List<Stack<Card>>();
            CurrentHand = new List<Card>();

            this.nbPlayer = nbPlayer;
            players.ForEach(player => playerList.Add(new Player(player)));
            

            ListOrderedStacks.Add(new Stack<Card>());
            ListOrderedStacks.Add(new Stack<Card>());
            ListOrderedStacks.Add(new Stack<Card>());
            ListOrderedStacks.Add(new Stack<Card>());

            for (int i = 0; i < 4; i++)
            {
                if (i < 2)
                {
                    ListOrderedStacks[i].Push(new ClassicCard(1));
                }
                else
                {
                    ListOrderedStacks[i].Push(new ClassicCard(100));
                }
            }

            createDeck();
            defineNbMaxCard();
            distribueCard();

            CurrentHand = playerList[currentIndexPlayer].getCardList();
            nbCardAtBeginOfTurn = CurrentHand.Count;
        }

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

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

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

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

        public void joue(int valueCard, int orderedStackSelected)
        {
            if (EndMessage != null)
            {
                //throw new Exception("Le jeu est fini! Veuillez lancer une nouvelle partie!");
                throw new Exception(AppRessource.StrEndOfGame);
            }
            foreach(Card card in CurrentHand)
            {
                if (valueCard == card.Value)
                {
                    if (orderedStackSelected >= 0 && orderedStackSelected < 4)
                    {
                        if (orderedStackSelected < 2)
                        {
                            testPossibility(card, ListOrderedStacks[orderedStackSelected], true);
                        }
                        else
                        {
                            testPossibility(card, ListOrderedStacks[orderedStackSelected], false);
                        }
                    }
                    else
                    {
                        throw new Exception(AppRessource.StrCantGetStack);
                    }
                    return;
                }
            }
        }

        protected void testPossibility(Card card, Stack<Card> orderedStack, bool bottomUp)
        {
            if ((bottomUp && card.Value > orderedStack.Peek().Value) || (!bottomUp && card.Value < orderedStack.Peek().Value) || card.Value == orderedStack.Peek().Value + 10 || card.Value == orderedStack.Peek().Value - 10)
            {
                Card oldCard = orderedStack.Peek();
                playerList[currentIndexPlayer].joue(card);
                CurrentCardPlayed.Add(card);
                orderedStack.Push(card);
                OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
            }
            else
            {
                throw new Exception(AppRessource.StrWrongStack);
            }
        }

        protected internal void OnTopRangeChanged(TopRangeChangedEventArgs args)
        {
            TopRangeChanged?.Invoke(this, args);
        }

        protected internal void OnPlayerChanged(PlayerChangedEventArgs args)
        {
            PlayerChanged?.Invoke(this, args);
        }

        public bool isCanPlay()
        {
            if (CurrentHand.Count > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        abstract public bool endTurn();

        abstract protected void pioche();

        abstract protected bool isEndGame();

        abstract protected void tryToFindSoluce(List<Card> playableCard);

        abstract protected bool testEndGame(List<Card> playableCard);

        abstract protected bool effectLose();

        public int getCurentIndexPlayer()
        {
            return currentIndexPlayer;
        }

    }
}