public int Compare(object x, object y)
 {
     if (x is CardInCollection && y is CardInCollection)
     {
         CardInCollection cardX = (CardInCollection)x;
         CardInCollection cardY = (CardInCollection)y;
         // workaround to put neutral cards last
         bool xIsNeutral = cardX.CardClass == Neutral;
         bool yIsNeutral = cardY.CardClass == Neutral;
         if (xIsNeutral && !yIsNeutral)
         {
             return(1);
         }
         if (!xIsNeutral && yIsNeutral)
         {
             return(-1);
         }
         int cardClassCompare = cardX.CardClass.CompareTo(cardY.CardClass);
         if (cardClassCompare != 0)
         {
             return(cardClassCompare);
         }
         int manaCostCompare = cardX.Card.Cost.CompareTo(cardY.Card.Cost);
         if (manaCostCompare != 0)
         {
             return(manaCostCompare);
         }
         return(cardX.Card.LocalizedName.CompareTo(cardY.Card.LocalizedName));
     }
     else
     {
         return(1);
     }
 }
        private bool CardsFilter(object card)
        {
            CardInCollection c = card as CardInCollection;

            if (Filter.OnlyMissing)
            {
                if ((Filter.GoldenCards && c.AmountGolden >= c.MaxAmountInCollection) ||
                    (!Filter.GoldenCards && c.AmountNonGolden >= c.MaxAmountInCollection))
                {
                    return(false);
                }
            }
            if (Filter.FormattedText == string.Empty)
            {
                return(true);
            }

            Rarity rarity;
            bool   filteringByRarity = Enum.TryParse(Filter.FormattedText, true, out rarity);

            if (filteringByRarity)
            {
                return(c.Card.Rarity == rarity);
            }

            var cardName = Helper.RemoveDiacritics(c.Card.LocalizedName, true);

            return(cardName.Contains(Filter.FormattedText, StringComparison.OrdinalIgnoreCase) ||
                   c.Card.AlternativeNames.Any(n => Helper.RemoveDiacritics(n, true).Contains(Filter.FormattedText, StringComparison.OrdinalIgnoreCase)));
        }
        private bool CardsFilter(object card)
        {
            CardInCollection c = card as CardInCollection;

            if (Filter.OnlyMissing)
            {
                if ((Filter.GoldenCards && c.AmountGolden >= c.MaxAmountInCollection) ||
                    (!Filter.GoldenCards && c.AmountNonGolden >= c.MaxAmountInCollection))
                {
                    return(false);
                }
            }
            if (Filter.FormattedText == string.Empty)
            {
                return(true);
            }

            Rarity rarity;
            bool   filteringByRarity = Enum.TryParse(Filter.FormattedText, true, out rarity);

            if (filteringByRarity)
            {
                return(c.Card.Rarity == rarity);
            }

            var cardName = Helper.RemoveDiacritics(c.Card.LocalizedName.ToLowerInvariant(), true);

            return(cardName.Contains(Filter.FormattedText));
        }
        public void UpdateCardsInDecks()
        {
            this.Cards = new SortedDictionary <string, int>();
            var deckList = DeckList.Instance.Decks.Where(d => !d.IsArenaDeck && !d.IsBrawlDeck).ToList();

            foreach (var deck in deckList)
            {
                foreach (var card in deck.Cards)
                {
                    if (this.Cards.ContainsKey(card.Name))
                    {
                        int copiesOfCardInDeck = this.Cards[card.Name];
                        this.Cards[card.Name] = Math.Max(card.Count, copiesOfCardInDeck);
                    }
                    else
                    {
                        this.Cards.Add(card.Name, card.Count);
                    }
                }
            }

            if (HearthstoneCollectionTrackerPlugin.Settings != null)
            {
                foreach (var set in HearthstoneCollectionTrackerPlugin.Settings.ActiveAccountSetsInfo)
                {
                    foreach (CardInCollection card in set.Cards)
                    {
                        CardInCollection copy = card;
                        int index             = set.Cards.IndexOf(copy);
                        set.Cards[index].CopiesInDecks = this.Cards.Where(c => c.Key == copy.Card.Name).FirstOrDefault().Value;
                    }
                }
            }
        }
Example #5
0
 private void UpdateCardsAmount(CardInCollection card, int difference)
 {
     if (Filter.GoldenCards)
     {
         int newValue = card.AmountGolden + difference;
         newValue          = newValue.Clamp(0, card.MaxAmountInCollection);
         card.AmountGolden = newValue;
     }
     else
     {
         int newValue = card.AmountNonGolden + difference;
         newValue             = newValue.Clamp(0, card.MaxAmountInCollection);
         card.AmountNonGolden = newValue;
     }
 }
Example #6
0
        private void CardCollectionEditor_OnKeyDown(object sender, KeyEventArgs e)
        {
            int?amount = null;

            if (e.Key == Key.Enter)
            {
                amount = 1;
            }
            else if (e.Key == Key.Back || e.Key == Key.Delete)
            {
                amount = -1;
            }
            if (amount.HasValue)
            {
                CardInCollection card = (CardInCollection)CardCollectionEditor.SelectedItem;
                if (card == null || string.IsNullOrEmpty(card.Card.Name))
                {
                    return;
                }

                UpdateCardsAmount(card, amount.Value);
            }
        }
Example #7
0
        private void TextBoxCollectionFilter_OnPreviewKeyDown(object sender, KeyEventArgs e)
        {
            var index             = CardCollectionEditor.SelectedIndex;
            CardInCollection card = null;

            switch (e.Key)
            {
            case Key.Enter:
                if (CardCollectionEditor.SelectedItem != null)
                {
                    card = (CardInCollection)CardCollectionEditor.SelectedItem;
                }
                else if (CardCollectionEditor.Items.Count > 0)
                {
                    card = (CardInCollection)CardCollectionEditor.Items[0];
                }
                break;

            case Key.D1:
                if (CardCollectionEditor.Items.Count > 0)
                {
                    card = (CardInCollection)CardCollectionEditor.Items[0];
                }
                break;

            case Key.D2:
                if (CardCollectionEditor.Items.Count > 1)
                {
                    card = (CardInCollection)CardCollectionEditor.Items[1];
                }
                break;

            case Key.D3:
                if (CardCollectionEditor.Items.Count > 2)
                {
                    card = (CardInCollection)CardCollectionEditor.Items[2];
                }
                break;

            case Key.D4:
                if (CardCollectionEditor.Items.Count > 3)
                {
                    card = (CardInCollection)CardCollectionEditor.Items[3];
                }
                break;

            case Key.D5:
                if (CardCollectionEditor.Items.Count > 4)
                {
                    card = (CardInCollection)CardCollectionEditor.Items[4];
                }
                break;

            case Key.Down:
                if (index < CardCollectionEditor.Items.Count - 1)
                {
                    CardCollectionEditor.SelectedIndex += 1;
                }
                break;

            case Key.Up:
                if (index > 0)
                {
                    CardCollectionEditor.SelectedIndex -= 1;
                }
                break;
            }
            if (card != null)
            {
                UpdateCardsAmount(card, 1);
                e.Handled = true;
            }
        }