public Card Draw()
        {
            Card card = new Card();
            CardViewModel context = card.DataContext as CardViewModel;

            bool cardShouldBeBeneficial = Roll.Next(0, 100) >= 60;

            if (cardShouldBeBeneficial) {
                int r = Roll.Next(0, 100);

                if (r >= 0 && r < 10) {
                    context.Type = CardType.Treasure;
                } else if (r >= 10 && r < 40) {
                    context.Type = CardType.Part;
                } else if (r >= 40 && r < 55) {
                    context.Type = CardType.Health;
                } else {
                    context.Type = CardType.Sword;
                }
            } else {
                context.Type = CardType.Monster;
            }

            switch (context.Type) {
                default:
                    break;

                case CardType.Health: {
                    context.Value = Roll.Next(2, 11);
                } break;

                case CardType.Monster: {
                    context.Value = Roll.Next(2, 15);
                } break;

                case CardType.Sword: {
                    context.Value = Roll.Next(2, 11);
                }
                break;
            }

            return card;
        }
 public void Remove(Card card)
 {
     stack.Children.Remove(card);
 }
        public void Add(Card card)
        {
            if (!CanHoldAdditionalCards) {
                return;
            }

            if (stack.Children.Contains(card)) {
                return;
            }

            double offset = 0;

            bool shouldOffsetCard = false;

            if (IsLimitingShownCards) {
                if (HoldsMoreCardsThanShown || StackCount == MaxShownCards) {
                    card.Visibility = Visibility.Collapsed;
                } else {
                    shouldOffsetCard = true;
                }
            } else {
                shouldOffsetCard = true;
            }

            if (shouldOffsetCard) {
                offset = StackVerticalOffset;
            }

            ((card.RenderTransform as TransformGroup).Children[0] as TranslateTransform).Y = offset;
            ((card.RenderTransform as TransformGroup).Children[1] as RotateTransform).Angle = 0;

            if (card.Parent is Panel) {
                (card.Parent as Panel).Children.Remove(card);
            }

            card.IsHitTestVisible = false;

            if (FlipsCardsWhenAdded) {
                card.Flip();
            }

            stack.Children.Add(card);
        }
        void OnCardMovedFromRiver(Card card)
        {
            if (!deck.CanSkip) {
                const int AmountOfCardsThatMustBePlayedBeforeAllowingSkipping = 5;

                if (++cardsPlayedSinceLastSkip >= AmountOfCardsThatMustBePlayedBeforeAllowingSkipping) {
                    cardsPlayedSinceLastSkip = 0;

                    ScoreContext.AmountOfRoomsClearedOrSkipped += 1;

                    deck.CanSkip = true;
                }

                if (cardsPlayedSinceLastSkip == AmountOfCardsThatMustBePlayedBeforeAllowingSkipping - 1) {
                    skipHintLabel.Visibility = Visibility.Visible;
                    skipHintLabel.Text = "You can skip on the following turn";
                } /*else if (cardsPlayedSinceLastSkip == AmountOfCardsThatMustBePlayedBeforeAllowingSkipping - 2) {
                    skipHintLabel.Visibility = Visibility.Visible;
                    skipHintLabel.Text = "You can skip on the next-next turn";
                }*/ else {
                    skipHintLabel.Visibility = Visibility.Collapsed;
                }
            }

            river.IsHitTestVisible = true;
            river.Children.Remove(card);

            DrawIntoRiver();
        }
        void ConvertStackToSword(CardSlot slot)
        {
            Card sword = new Card();

            CardViewModel swordCardContext = sword.DataContext as CardViewModel;

            swordCardContext.Type = CardType.Sword;
            swordCardContext.Value = slot.StackCount;

            slot.Add(sword);

            sword.Flip();
            sword.PlaceInSlot(weaponSlot, TimeSpan.FromSeconds(1));
        }