orderstacks/TheGameExtreme/model/manager/GameManager.cs

using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
using TheGameExtreme.model.deck;
using TheGameExtreme.model.@event;
using TheGameExtreme.model.gameActions;
using TheGameExtreme.model.gameActions.classic;
using TheGameExtreme.model.rule.beforeEndTurnRules;
using TheGameExtreme.model.rule.endTurnRules;
using TheGameExtreme.model.rule.playRules;

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

        /* GameMaster implémente un mode de jeu (classe fille de gameMode qui connait les actions a effectué en fonction du mode de jeu */

        protected GameMode gameMode;


        protected GameManager(GameMode gameMode)
        {
            this.gameMode = gameMode;
        }




















        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;


        protected 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)));


            initStacks();

            initRule();

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

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

        protected void initStacks()
        {
            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));
                }
            }
        }

        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 (gameMode.checkPlayRule(card, orderedStack, bottomUp, CurrentHand))
            //{
            //    Card oldCard = orderedStack.Peek();
            //    playerList[currentIndexPlayer].joue(card);
            //    CurrentCardPlayed.Add(card);
            //    orderedStack.Push(card);
            //    OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
            //    //if (CurrentHand.Count == 0)
            //    //{
            //    //    endTurn(); // Presque bon, oublie juste d'afficher les nouvelles cartes
            //    //}
            //}
            //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 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;
        }

    }
}