/SimpleCardGame/SimpleCardGame/SimpleCardGame/Menus/MainGame.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Input.Touch;
using Microsoft.Xna.Framework.GamerServices;

using SimpleCardGame.Animation;
using SimpleCardGame.Entities;

namespace SimpleCardGame.Menus
{
    class MainGame : Screen
    {
        int turn = 0;
        static bool turnPlayed = false;
        static Card attackerCard = null;
        static bool attackerCardSelected = false;
        static bool targetCardSelected = false;
        static bool movePerformed = false;

        TouchCollection touches;
        Point point;

        List<Card> playerOneCards;
        List<Card> playerTwoCards;
        List<Card> deadCards;

        ///Score related data
        bool isHighScoreAchieved = false;
        int currentHighScore;
        string winnerName;
        string scoreType;

        PauseMenu pauseMenu; ///Pause Menu object
        GestureSample gesture; ///Input mechanism for power card
        Text statusText;    ///Displays current status in the middle of the screen
        SpriteFont statusFont;

        #region
        ///Animation related data
        float timer = 0;
        float interval = 100;
        bool playAnimation = false; //Determines whether animation should be played
        public Vector2 animationPosition; 
        public AnimationType animationType;
        static CardAnimations cardAnimations; //Wrapper class for all the animations
        #endregion

        public MainGame(Game game, SpriteBatch spriteBatch, ChangeScreen changeScreen)
            : base(game, spriteBatch, changeScreen)
        {}

        public override void Activate()
        {
            ///Reset both cards list and draw three cards
            ///from each of the decks,
            playerOneCards = new List<Card>();
            playerTwoCards = new List<Card>();

            foreach (Card card in playerOneDeck.cards)
                card.Selected = false;
            
            foreach (Card card in playerTwoDeck.cards)
                card.Selected = false;


            for (int i = 0; i < 3; i++)
            {
                playerOneCards.Add(playerOneDeck.DrawCard());
                playerTwoCards.Add(playerTwoDeck.DrawCard());
            }

            ///Load current highest score
            isHighScoreAchieved = false;
            switch (gameType)
            { 
                case GameType.PvC:
                    currentHighScore = highScores.CurrentHighScore("PvC");
                    break;

                case GameType.PvP:
                    currentHighScore = highScores.CurrentHighScore("PvP");
                    break;
            }
            
            ///Set the initial game state
            gameState = GameState.Running;
        }

        protected override void LoadScreenContent(ContentManager content)
        {
            statusFont = content.Load<SpriteFont>("fonts/gameFont");

            statusText = new Text(statusFont,
                                  "PLAYER ONE'S TURN, CARDS LEFT : " + playerOneDeck.cards.Count.ToString(),
                                  new Vector2(0, 0), Color.White, Color.Black,
                                  Text.Alignment.Both, new Rectangle(0, 0, 800, 480));

        }

        #region ///Actual Gameplay Function
        public void SimulateGame(GameTime gameTime, DisplayOrientation screenOrientation)
        {
            //Placed before player turn logic, so that animation occurs before dead card is replaced
            #region
            ///If playAnimation is true, then 
            ///set animation parameters and play until
            ///animation completes
            if (playAnimation == true)
            {
                timer += (float)gameTime.ElapsedGameTime.TotalMilliseconds;

                if (cardAnimations == null)
                    cardAnimations = new CardAnimations(animationPosition, animationType, game.Content);

                if ((timer > interval) && !cardAnimations.animations[animationType].AnimationComplete)
                {
                    timer = 0;
                    cardAnimations.Update(gameTime);
                }
                else if (cardAnimations.animations[animationType].AnimationComplete == true)
                {
                    playAnimation = false;
                    cardAnimations = null;
                }
            }
            #endregion

            //Check for inputs
            if (turn == 0)
            {
                replaceDeadCards(ref playerOneCards, ref playerOneDeck);

                if (!turnPlayed)
                {
                    ///Not checking the game type here
                    ///since in this case first player will always be 
                    ///a human, hence calling manual attack function
                    turnPlayed = attack(ref playerOneCards, ref playerTwoCards);
                }
                else if (turnPlayed)
                {
                    turn = 1;
                    turnPlayed = false;
                }

            }
            else if (turn == 1)
            {
                replaceDeadCards(ref playerTwoCards, ref playerTwoDeck);

                if (!turnPlayed)
                {
                    ///Call attack function depending on the game type
                    if (gameType == GameType.PvC)
                        turnPlayed = computerAttack(ref playerTwoCards, ref playerOneCards);
                    else if (gameType == GameType.PvP)
                        turnPlayed = attack(ref playerTwoCards, ref playerOneCards);

                }
                else if (turnPlayed)
                {
                    turn = 0;
                    turnPlayed = false;
                }

            }

            GameOver = GameEnds();
            if (GameOver)
            {
                if (!isHighScoreAchieved && TotalPoints > currentHighScore)
                {
                    switch (gameType)
                    {
                        ///Here we set the name of player
                        ///depending upon the game's type
                        case GameType.PvC:
                            scoreType = "PvC";
                            if (winningPlayer == WinningPlayer.PlayerOne)
                                getWinnerName();
                            else if (winningPlayer == WinningPlayer.PlayerTwo)
                                winnerName = "Com";

                            break;

                        case GameType.PvP:
                            scoreType = "PvP";
                            getWinnerName();
                            break;
                    }

                    ///Add score after getting winner's name
                    highScores.AddScore(scoreType, winnerName, TotalPoints);
                }

                ChangeScreenDelegate(ScreenState.GameOver);
            }
        }
        #endregion

        protected override void UpdateScreen(GameTime gameTime, DisplayOrientation screenOrientation)
        {
            if (gameState == GameState.Running)
            {
                SimulateGame(gameTime, screenOrientation);

                if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                    gameState = GameState.Paused;
            }
            else if (gameState == GameState.Paused)
            {
                pauseMenu = new PauseMenu(game.Content);

                foreach (TouchLocation touch in TouchPanel.GetState())
                    pauseMenu.Update(touch);

                ///Exit Game if Back button pressed while paused
                if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                    this.game.Exit();

                if (pauseMenu.btnResume.Pressed)
                    gameState = GameState.Running;

                if (pauseMenu.btnRestart.Pressed)
                    ChangeScreenDelegate(ScreenState.MainGameScreen);

                if (pauseMenu.btnQuitMainMenu.Pressed)
                    ChangeScreenDelegate(ScreenState.MainMenu);
            }

        }//End of UpdateScreen()


        #region/// SIP functionality for player to input name
        private void getWinnerName()
        {
            Guide.BeginShowKeyboardInput(PlayerIndex.One,
                                            "You Win",
                                             "Insert your name",
                                             "",
                                             new AsyncCallback(OnEndShowKeyboardInput),
                                             null);
        }

        private void OnEndShowKeyboardInput(IAsyncResult result)
        {
            winnerName = Guide.EndShowKeyboardInput(result);
        }
        #endregion

        protected override void DrawScreen(SpriteBatch spriteBatch, DisplayOrientation screenOrientation)
        {
            setVisibleCardsPosition();
        
            foreach(Card card in playerOneCards)
                card.Draw(spriteBatch);

            foreach (Card card in playerTwoCards)
                card.Draw(spriteBatch);

            spriteBatch.DrawString(spriteFont, ""+playerOneDeck.cards.Count, new Vector2(0, 0), Color.Red);
            spriteBatch.DrawString(spriteFont, "" + playerTwoDeck.cards.Count, new Vector2(0, 400), Color.Red);
            statusText.Draw(spriteBatch);

            ///Draw animation if available
            if (playAnimation && cardAnimations != null)
                cardAnimations.Draw(spriteBatch);

            ///Display the pause menu if game is paused
            if(gameState == GameState.Paused && pauseMenu != null)
                pauseMenu.Draw(spriteBatch);
        }

        private void setVisibleCardsPosition()
        {
            ///Used before drawing the cards 
            ///since position of all cards when 
            ///created is 0,0
            int cWidth = 173;
            
            for (int i = 0; i < playerOneCards.Count; i++)
            {
                playerOneCards[i].Position = new Vector2( i * cWidth + (100 * i) + 10, 10 );    
            }

            for (int j = 0; j < playerTwoCards.Count; j++)
            {
                playerTwoCards[j].Position = new Vector2(j * cWidth + (100 * j) + 10, 290);
            }
        }


        private bool attack(ref List<Card> ownList, ref List<Card> enemyList)
        {
            if (!attackerCardSelected)
            {
                statusText.ChangeText( ((turn == 0) ? "PLAYER ONE'S TURN" : "PLAYER TWO'S TURN") + " SELECT ATTACKER CARD");

                touches = TouchPanel.GetState();
                foreach(TouchLocation touch in touches)
                {
                    if (touch.State == TouchLocationState.Pressed)
                    {
                        point = new Point((int)touch.Position.X, (int)touch.Position.Y);
                        foreach (Card card in ownList)
                        {
                            if (card.Rectangle.Contains(point))
                            {
                                card.Selected = true;
                                attackerCard = card;
                                attackerCardSelected = true;
                                break;
                            }
                            else
                            {
                                card.Selected = false;
                                attackerCardSelected = false;
                            }
                        }
                    }
                }
            }
            
            if (attackerCardSelected == true && !targetCardSelected)
            {
                switch (attackerCard.cType)
                { 
                    case cardType.Melee:
                        if (ownList.IndexOf(attackerCard) < enemyList.Count)
                        {
                            ///melee cards can attack only immediate cards
                            targetCardSelected = true;
                            enemyList[ownList.IndexOf(attackerCard)].Hitpoints -= attackerCard.Damage;
                        }
                        ///placing move performed outside, so as to skip if
                        ///no card exists in front of selected attackerCard
                        movePerformed = true;
                        break;

                    case cardType.Range:
                        statusText.ChangeText(((turn == 0) ? "PLAYER ONE'S TURN" : "PLAYER TWO'S TURN") + " SELECT CARD TO ATTACK");
                        touches = TouchPanel.GetState();
                        foreach(TouchLocation touch in touches)
                        {
                            if (touch.State == TouchLocationState.Pressed)
                            {
                                point = new Point((int)touch.Position.X, (int)touch.Position.Y);
                                foreach (Card card in enemyList)
                                {
                                    if (card.Rectangle.Contains(point))
                                    {
                                        targetCardSelected = true;
                                        card.Selected = true;
                                        card.Hitpoints -= attackerCard.Damage;
                                        movePerformed = true;
                                    }
                                }
                            }
                        }
                        
                        break;

                    case cardType.Healing:
                        statusText.ChangeText( ((turn == 0) ? "PLAYER ONE'S TURN" : "PLAYER TWO'S TURN") + " SELECT CARD TO HEAL");
                        touches = TouchPanel.GetState();
                        foreach (TouchLocation touch in touches)
                        {
                            if (touch.State == TouchLocationState.Pressed)
                            {
                                point = new Point((int)touch.Position.X, (int)touch.Position.Y);
                                foreach (Card card in ownList)
                                {
                                    if (card.Rectangle.Contains(point))
                                    {
                                        {
                                            targetCardSelected = true;
                                            card.Selected = true;
                                            card.Hitpoints += attackerCard.Damage;
                                            movePerformed = true;
                                        }
                                    }
                                }
                            }
                        }
                        break;

                    case cardType.Bomb:
                        targetCardSelected = true;
                        foreach (Card card in enemyList)
                        {
                            card.Hitpoints -= attackerCard.Damage;
                        }
                        ownList[ownList.IndexOf(attackerCard)].Dead = true;
                        //ownList.Remove(attackerCard);
                        movePerformed = true;
                        break;

                    case cardType.Power:
                        statusText.ChangeText("FLICK TO BUFF SELF, DOUBLE TAP TO DEBUFF ENEMIES");
                        
                        bool powerCardUsed = false;

                        if (TouchPanel.IsGestureAvailable)
                        {
                            gesture = TouchPanel.ReadGesture();

                            if (gesture.GestureType == GestureType.DoubleTap)
                            {
                                foreach (Card card in enemyList)
                                    card.Damage -= attackerCard.Damage;

                                powerCardUsed = true;
                            }
                            else if (gesture.GestureType == GestureType.Flick)
                            {
                                foreach (Card card in ownList)
                                    card.Damage += attackerCard.Damage;

                                powerCardUsed = true;
                            }

                            if (powerCardUsed)
                            {
                                targetCardSelected = true;
                                movePerformed = true;
                                ownList[ownList.IndexOf(attackerCard)].Dead = true;
                            }
                        }
                        
                        break;

                    case cardType.Mysterious:
                        Random random = new Random();
                        int mysteriousCardType = random.Next(0, 5);

                        switch (mysteriousCardType)
                        { 
                            case 0: //Card increases own hp
                                statusText.ChangeText("OWN HP INCREASED MYSTERIOUSLY");
                                foreach (Card card in ownList)
                                    card.Hitpoints += attackerCard.Damage;
                                break;

                            case 1: //Card increases own damage
                                statusText.ChangeText("OWN DAMAGE INCREASED MYSTERIOUSLY");
                                foreach (Card card in ownList)
                                    card.Damage += attackerCard.Damage;
                                break;

                            case 2: //Card decreases enemy hp
                                statusText.ChangeText("ENEMY HP DECREASED MYSTERIOUSLY");
                                foreach (Card card in enemyList)
                                    card.Hitpoints -= attackerCard.Damage;
                                break;

                            case 4: //Card decreases enemy damage
                                statusText.ChangeText("ENEMY DAMAGE DECREASED MYSTERIOUSLY");
                                foreach (Card card in enemyList)
                                    card.Damage -= attackerCard.Damage;
                                break;

                            case 5: //Card acts as trap, own turn skipped
                                statusText.ChangeText("IT WAS A TRAP! TURN SKIPPED!");
                                break;
                        }

                        ownList[ownList.IndexOf(attackerCard)].Dead = true;
                        targetCardSelected = true;
                        movePerformed = true;
                        break;
                }
            }

            if (movePerformed)
            {
                deselectCards(ref ownList, ref enemyList);

                attackerCardSelected = false;
                targetCardSelected = false;
                attackerCard = null;
                movePerformed = false;

                return true;
            }
            else
                return false;
        }//end of attack function


        public bool computerAttack(ref List<Card> ownList, ref List<Card> enemyList)
        {
            Random random = new Random();
            int comAttackCardIndex;
            Card comCard = null;
            bool attackComplete = false;

            ///select an attacker card
            if (ownList.Count > 0)
                comAttackCardIndex = random.Next(0, ownList.Count);
            else
            {
                ///bug encountered incase one card left and 
                ///it dies, hence return TURNPLAYED = TRUE
                return true;
            }

            ownList[comAttackCardIndex].Selected = true;
            comCard = ownList[comAttackCardIndex];

            switch (comCard.cType)
            { 
                case cardType.Melee:
                    if (comAttackCardIndex < enemyList.Count)
                    {
                        enemyList[comAttackCardIndex].Hitpoints -= comCard.Damage;
                        attackComplete = true;
                    }
                    break;

                case cardType.Range:
                    int victimIndex = random.Next(0, enemyList.Count);
                    if (victimIndex <= enemyList.Count)
                    {
                        enemyList[victimIndex].Hitpoints -= comCard.Damage;
                        attackComplete = true;
                    }
                    break;

                case cardType.Healing:
                    int targetIndex = random.Next(0, ownList.Count);
                    if (targetIndex <= ownList.Count)
                    {
                        ownList[targetIndex].Hitpoints += comCard.Damage;
                        attackComplete = true;
                    }
                    break;

                case cardType.Power:
                    attackComplete = true;
                    break;

                case cardType.Bomb:
                    foreach (Card card in enemyList)
                    {
                        card.Hitpoints -= comCard.Damage;
                    }
                    ownList.Remove(comCard);
                    attackComplete = true;
                    break;
            }

            deselectCards(ref ownList, ref enemyList);
            return attackComplete;
        }


        public void replaceDeadCards(ref List<Card> cardList, ref Deck parentDeck)
        {
            deadCards = new List<Card>();

            ///Adding dead cards to seperate list 
            ///otherwise if removed from list while 
            ///iterating in foreach loop, the enumerator becomes invalid
            foreach (Card card in cardList)
                if (card.isDead())
                {   
                    deadCards.Add(card);

                    playAnimation = true;
                    animationPosition = card.Position;
                    animationType = AnimationType.DeadAnimation;
                }

            foreach (Card card in deadCards)
                cardList.Remove(card);

            while (cardList.Count != 3)
            {
                if (parentDeck.hasCards())
                {
                    cardList.Add(parentDeck.DrawCard());
                    turnPlayed = true;
                }
                else
                {
                    break;
                }
            }
        }

        public bool GameEnds()
        {
            ///if player 2 wins
            if (!playerOneDeck.hasCards() && playerOneCards.Count <= 0)
            {
                winningPlayer = WinningPlayer.PlayerTwo;

                if (playerTwoDeck.hasCards())
                    foreach (Card card in playerTwoDeck.cards)
                        TotalPoints += card.cost;
                
                foreach (Card card in playerTwoCards)
                    TotalPoints += card.cost;

                return true;
            }

            ///if player 1 wins
            if (!playerTwoDeck.hasCards() && playerTwoCards.Count <= 0)
            {
                winningPlayer = WinningPlayer.PlayerOne;

                if (playerOneDeck.hasCards())
                    foreach (Card card in playerOneDeck.cards)
                        TotalPoints += card.cost;
                
                foreach (Card card in playerOneCards)
                    TotalPoints += card.cost;

                return true;
            }

            return false;
        }


        private void deselectCards(ref List<Card> ownList, ref List<Card> enemyList)
        {
            foreach (Card card in ownList)
                card.Selected = false;

            foreach (Card card in enemyList)
                card.Selected = false;
        }

        
    }    
}