thegameextreme/TheGameExtreme/model/manager/GameManager.cs

using System;
using System.Collections.Generic;
using TheGameExtreme.model.effect;
using TheGameExtreme.model.@event;

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

        public readonly int nbPlayer;
        protected int nbMaxCard;
        protected int currentIndexPlayer = 0;
        protected List<Player> playerList = new List<Player>();
        protected List<InfiniteEffect> infiniteEffectsConstraintsList = new List<InfiniteEffect>();
        protected List<Stack<Card>> listOrderedStacks = new List<Stack<Card>>();
        protected List<Card> deck = new List<Card>();
        protected bool win = true;
        public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
        public event EventHandler<CurrentPlayerChangedEventArgs> CurrentPlayerChanged;

        public GameManager(int nbPlayer, List<Player> players)
        {
            this.nbPlayer = nbPlayer;
            players.ForEach(player => playerList.Add(player));
            for (int i = 0; i < 4; i++)
            {
                listOrderedStacks.Add(new Stack<Card>());
                if (i < 2)
                {
                    listOrderedStacks[i].Push(new Card(100));
                }
                else
                {
                    listOrderedStacks[i].Push(new Card(1));
                }
            }
            createDeck();
            defineNbMaxCard();
            distribueCard();
        }

        protected void createDeck()
        {
            for (int i = 2; i <= 99; i++)
            {
                deck.Add(new Card(i));
            }
            melangeDeck();
        }

        protected void melangeDeck()
        {
            Random random = new Random();
            int place1;
            int place2;
            Card tmp;

            for (int i = 0; i < 1000; i++)
            {
                place1 = random.Next(0, 98);
                place2 = random.Next(0, 98);

                tmp = deck[place1];
                deck[place1] = deck[place2];
                deck[place2] = tmp;
            }
        }

        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 => {
                    player.pioche(deck[deck.Count - 1]);
                    deck.RemoveAt(deck.Count - 1);
                });
            }
        }

        public void joue(Card card, int orderedStackSelected)
        {
            if (orderedStackSelected >= 0 && orderedStackSelected < 4)
            {
                if (orderedStackSelected < 2)
                {
                    testPossibility(card, listOrderedStacks[orderedStackSelected], false);
                }
                else
                {
                    testPossibility(card, listOrderedStacks[orderedStackSelected], true);
                }
            }
        }

        protected void testPossibility(Card card, Stack<Card> orderedStack, bool bottomUp)
        {
            if ((bottomUp && card.Value > orderedStack.Peek().Value) || (!bottomUp && card.Value < orderedStack.Peek().Value))
            {
                Card oldCard = orderedStack.Peek();
                playerList[currentIndexPlayer].joue(card);
                orderedStack.Push(card);
                OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, listOrderedStacks.IndexOf(orderedStack)));
            }
            else
            {
                // Throw Exception
            }
        }

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

        protected internal void OnCurrentPlayerChanged(CurrentPlayerChangedEventArgs args)
        {
            CurrentPlayerChanged?.Invoke(this, args);
        }

        abstract public void endTurn();

        abstract protected void pioche();

        abstract protected bool isEndGame();

        abstract protected List<Card> tryToFindSoluce(List<Card> playableCard, Player currentPlayer);

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

        abstract protected bool effectLose();

        public int getCurentIndexPlayer()
        {
            return currentIndexPlayer;
        }

    }
}