private static void CardsPropertyChanged(object o, DependencyPropertyChangedEventArgs args)
        {
            SidewaysStack stack = (SidewaysStack)o;
            CardCollection collection = (CardCollection)args.NewValue;
            if (collection.IsEmpty)
            {
                var _oldCards = stack.InternalChildren.OfType<UIElement>().Where(child => !(child is PilePlaceHolder)).ToList();
                foreach (var item in _oldCards)
                {
                    stack.Children.Remove(item);
                }
                return;
            }
            else
            {
                foreach (var groups in collection.Where(card => card.CardType == ColorettoCardTypes.Color).GroupBy(card => card.Color))
                {
                    int exist = stack.Children.OfType<PlayerHandCard>().Where(phc => phc.CardColor == groups.Key).Count();
                    int different = groups.Count() - exist;
                    if (different > 0)
                    {
                        PlayerHandCard card = new PlayerHandCard { CardColor = groups.Key };
                        PlayerHand.SetIsNew(card, true);
                        stack.Children.Add(card);
                        return;
                    }
                    else if (different < 0)
                    {
                        Debug.Fail("A color was removed?");
                    }
                    else
                    {
                        // no change in the number of this color
                    }
                }

                foreach (var group in collection.Where(card => card.CardType != ColorettoCardTypes.Color).OrderBy(card => card.CardType).GroupBy(card => card.CardType))
                {
                    if (group.Key == ColorettoCardTypes.Wild)
                    {
                        int exist = stack.Children.OfType<PlayerHandWildCard>().Count();
                        int differnet = group.Count() - exist;
                        if (differnet > 0)
                        {
                            PlayerHandWildCard card = new PlayerHandWildCard();
                            PlayerHand.SetIsNew(card, true);
                            stack.Children.Add(card);
                            return;
                        }
                        else if (differnet < 0)
                        {
                            Debug.Fail("A wild card was removed?");
                        }
                        else
                        {
                            // no change in number of wild cards
                        }
                    }
                    else if (group.Key == ColorettoCardTypes.Plus2)
                    {
                        int exist = stack.Children.OfType<PlayerHandPlusTwoCard>().Count();
                        int differnet = group.Count() - exist;
                        if (differnet > 0)
                        {
                            PlayerHandPlusTwoCard card = new PlayerHandPlusTwoCard();
                            PlayerHand.SetIsNew(card, true);
                            stack.Children.Add(card);
                            return;
                        }
                        else if (differnet < 0)
                        {
                            Debug.Fail("A wild card was removed?");
                        }
                        else
                        {
                            // no change in number of wild cards
                        }
                    }
                }
            }
            Debug.Fail("No card was added and the piles weren't cleared.");
        }
        private static void CardsPropertyChanged(object o, DependencyPropertyChangedEventArgs args)
        {
            PlayerHand playerHand = (PlayerHand)o;
            // TODO: Considering doing a diff or something less bulky.
            playerHand.Children.Clear();

            CardCollection cards = args.NewValue as CardCollection;
            CardCollection oldCards = args.OldValue as CardCollection;
            List<ColorettoCard> newCards = new List<ColorettoCard>(3);

            if (cards == null)
            {
                return;
            }
            else if (oldCards != null && cards.Count == oldCards.Count)
            {
                return;
            }
            else
            {
                // In order to highlight new cards we need to determine which ones are the new ones.
                for (int i = 0, j = 0; i < cards.Count; i++)
                {
                    if (j == oldCards.Count || cards[i] != oldCards[j])
                        newCards.Add(cards[i]);
                    else
                        j++;
                }
            }

            var colorGroups = cards.Where(c => c.CardType == ColorettoCardTypes.Color).GroupBy(c => c.Color).OrderByDescending(g => g.Count());
            foreach (IGrouping<ColorettoCardColors, ColorettoCard> colorGroup in colorGroups)
            {
                PlayerHandPile pile = new PlayerHandPile();
                foreach (var card in colorGroup)
                {
                    PlayerHandCard handCard = new PlayerHandCard { CardColor = card.Color };
                    pile.Children.Add(handCard);
                }

                int numberThatAreNew = newCards.Where(c => c.Color == colorGroup.Key).Count();
                for (int i = pile.Children.Count - 1; numberThatAreNew > 0 && i >= 0; i--, numberThatAreNew--) { SetIsNew(pile.Children[i], true); }

                playerHand.Children.Add(pile);
            }

            var specialGroups = cards.Where(c => c.CardType != ColorettoCardTypes.Color).GroupBy(c => c.CardType).OrderBy(g => g.Key);
            foreach (IGrouping<ColorettoCardTypes, ColorettoCard> cardGroup in specialGroups)
            {
                Debug.Assert(cardGroup.Key != ColorettoCardTypes.Unknown || cardGroup.Key != ColorettoCardTypes.LastCycle, "LastCycle and unknown card types should not be in the player's hand");
                PlayerHandPile pile = new PlayerHandPile();
                foreach (var card in cardGroup)
                {
                    UIElement specialCard = null;
                    if (cardGroup.Key == ColorettoCardTypes.Plus2)
                        specialCard = new PlayerHandPlusTwoCard();
                    else if (cardGroup.Key == ColorettoCardTypes.Wild)
                        specialCard = new PlayerHandWildCard();

                    pile.Children.Add(specialCard);
                }

                int numberThatAreNew = newCards.Where(c => c.CardType == cardGroup.Key).Count();
                for (int i = pile.Children.Count - 1; numberThatAreNew > 0 && i >= 0; i--, numberThatAreNew--) { SetIsNew(pile.Children[i], true); }

                playerHand.Children.Add(pile);
            }
        }
        private void Controller_GameUpdated(object sender, GameUpdatedEventArgs e)
        {
            CurrentPlayer.Text = "Current Player: " + e.NewGame.CurrentPlayer.Username;
            Round.Text = "Round: " + e.NewGame.Round;
            Turn.Text = "Turn: " + e.NewGame.Turn;
            Cycle.Text = "Cycle: " + e.NewGame.Cycle;

            if (e.NewGame.State == GameStates.Finished)
            {
                GameOver gameOverDisplay = new GameOver(e.NewGame)
                {
                    HorizontalAlignment = HorizontalAlignment.Center,
                    VerticalAlignment = VerticalAlignment.Center
                };
                Grid.SetColumnSpan(gameOverDisplay, 3);
                Grid.SetRowSpan(gameOverDisplay, 3);
                MainGrid.Children.Add(gameOverDisplay);
            }

            if (e.NewGame.VisibleCard == null)
            {
                VisibleCard.Content = null;
            }
            else if (e.NewGame.VisibleCard.CardType == ColorettoCardTypes.Color)
            {
                PlayerHandCard card = new PlayerHandCard { CardColor = e.NewGame.VisibleCard.Color };
                VisibleCard.Content = card;
            }
            else if (e.NewGame.VisibleCard.CardType == ColorettoCardTypes.Wild)
            {
                VisibleCard.Content = new PlayerHandWildCard();
            }
            else if (e.NewGame.VisibleCard.CardType == ColorettoCardTypes.Plus2)
            {
                VisibleCard.Content = new PlayerHandPlusTwoCard();
            }

            // The stacks should be listening themselves.
            Stacks.UpdatePiles(e.NewGame.Piles);
        }