private bool IsSpar(CardModel Card)
 {
     return(Card.Type.ToString().Contains("s"));
 }
 private bool IsClubs(CardModel Card)
 {
     return(Card.Type.ToString().Contains("c"));
 }
 private bool IsDiamonds(CardModel Card)
 {
     return(Card.Type.ToString().Contains("d"));
 }
 private bool IsHeart(CardModel Card)
 {
     return(Card.Type.ToString().Contains("h"));
 }
 private bool IsKing(CardModel Card)
 {
     return(Card.Type == CardType._Kc || Card.Type == CardType._Kd ||
            Card.Type == CardType._Kh || Card.Type == CardType._Ks);
 }
 private bool IsAce(CardModel Card)
 {
     return(Card.Type == CardType._Ac || Card.Type == CardType._Ad ||
            Card.Type == CardType._Ah || Card.Type == CardType._As);
 }
 private bool IsBlack(CardModel Card) => IsClubs(Card) || IsSpar(Card);
        private void StateController_OnDeckChanged(CardModel DeckCard, List <CardModel>[] ColorDeck, List <CardModel>[] Deck, BoardModel Board)
        {
            // Add all aldready observed cards..

            /*
             * foreach (var Card in Board.Bottom)
             *  if (Card != default && Card.Uncovered)
             *      if (!KnownCards.Contains(Card.Type))
             *          KnownCards.Add(Card.Type);
             * foreach (var Card in Board.Top)
             *  if (Card != default && Card.Uncovered)
             *      if (!KnownCards.Contains(Card.Type))
             *          KnownCards.Add(Card.Type);
             *
             * if (Board.DeckCard != default && Board.DeckCard.Type != default)
             *  if (!KnownCards.Contains(Board.DeckCard.Type))
             *      KnownCards.Add(Board.DeckCard.Type);
             */

            // If we have a new card discovered add it to the known cards
            if (LookUpBottomCardIndex >= 0)
            {
                for (int i = StateController.Bottom[LookUpBottomCardIndex].Count - 1; i >= 0; i--)
                {
                    if (StateController.Bottom[LookUpBottomCardIndex][i].Uncovered)
                    {
                        if (!KnownCards.Contains(StateController.Bottom[LookUpBottomCardIndex][i].Type))
                        {
                            KnownCards.Add(StateController.Bottom[LookUpBottomCardIndex][i].Type);
                        }
                    }
                }
            }

            if (LookUpNewDeckCard)
            {
                if (!KnownCards.Contains(Board.DeckCard.Type))
                {
                    KnownCards.Add(Board.DeckCard.Type);
                }
            }

            // Reset Lookup Variables
            HasUncoveredCard      = false;
            LookUpNewDeckCard     = false;
            LookUpBottomCardIndex = -1;
            UncoveredCardIndex    = -1;
            FoundBottomCard       = false;

            // Check if game has finished
            bool HasNotFinished = false;

            for (int i = 0; i < 4; i++)
            {
                if (StateController.Top.Count() != 13)
                {
                    HasNotFinished = true;
                    break;
                }
            }

            if (!HasNotFinished) // Finished
            {
                MessageBox.Show("The game has finished!", "Finished");
                return;
            }

            // If there is an Ace then move it to color stack
            if (MoveAceToColorStack(DeckCard, ColorDeck, Deck, Board))
            {
                goto End;
            }

            // Get all moves we can do!
            var AllMoves = GetAllMoves();

            // No more moves
            if (AllMoves.Count == 0)
            {
                Moves.Add("Turn a deck card");
                LookUpNewDeckCard = true;
                goto End;
            }

            // Find the move with most covered cards in it
            CardMove MoveWithMostCoveredCards = default;
            int      CoveredCardCount         = -1;

            foreach (var Move in AllMoves)
            {
                // Find how much covered shit we have
                if (CoveredCardCount == -1 && Move.FromPosition == -1)
                {
                    MoveWithMostCoveredCards = Move;
                }
                ;

                if (Move.FromPosition == -1)
                {
                    continue;
                }

                var CurrentCoveredCards = StateController.Bottom[Move.FromPosition].Count(c => !c.Uncovered);
                if (CurrentCoveredCards > CoveredCardCount)
                {
                    MoveWithMostCoveredCards = Move;
                    CoveredCardCount         = CurrentCoveredCards;
                }
            }

            // Perform shit move
            if (MoveWithMostCoveredCards.MoveToTop)
            {
                MoveCardToTop(MoveWithMostCoveredCards.FromPosition, MoveWithMostCoveredCards.ToPosition, MoveWithMostCoveredCards.CardIndex);
            }
            else
            {
                MoveCardBottom(MoveWithMostCoveredCards.FromPosition, MoveWithMostCoveredCards.ToPosition, MoveWithMostCoveredCards.CardIndex);
            }

End:
            SaveMoves();
        }