예제 #1
0
        void Add(Index Index)
        {
            if (!_index.ContainsValue(Index.Card.HDTCard.Id))
            {
                HearthDb.Card DbCard = HearthDb.Cards.GetFromDbfId(Index.Card.HDTCard.DbfIf);

                string name = "";
                string text = "";
                name = DbCard.Name?.ToLower();
                text = DbCard.Text?.ToLower();

                string locName = "";
                string locText = "";

                if (Enum.TryParse(Config.Instance.SelectedLanguage, out Locale lang))
                {
                    locName = DbCard.GetLocName(lang)?.ToLower();
                    locText = DbCard.GetLocText(lang)?.ToLower();
                }

                _sb.Append(locName).Append(name).Append(locText).Append(text);
                _index.Add(_sb.ToString(), Index.Card.HDTCard.Id);
                _sb.Clear();

                _indexObjects.Add(Index.Card.HDTCard.Id, new List <Index>());
            }

            _indexObjects[Index.Card.HDTCard.Id].Add(Index);
        }
예제 #2
0
 public Card(string id, string playerClass, Rarity rarity, string type, string name, int cost, string localizedName, int inHandCount,
             int count, string text, string englishText, int attack, int health, string race, string[] mechanics, int?durability,
             string artist, string set, List <string> alternativeNames = null, List <string> alternativeTexts = null, HearthDb.Card dbCard = null)
 {
     Id            = id;
     PlayerClass   = playerClass;
     Rarity        = rarity;
     Type          = type;
     Name          = name;
     Cost          = cost;
     LocalizedName = localizedName;
     InHandCount   = inHandCount;
     Count         = count;
     Text          = text;
     EnglishText   = englishText;
     Attack        = attack;
     Health        = health;
     Race          = race;
     Durability    = durability;
     Mechanics     = mechanics;
     Artist        = artist;
     Set           = set;
     if (alternativeNames != null)
     {
         AlternativeNames = alternativeNames;
     }
     if (alternativeTexts != null)
     {
         AlternativeTexts = alternativeTexts;
     }
     _dbCard = dbCard;
 }
예제 #3
0
 public Card(HearthDb.Card dbCard)
 {
     _dbCard       = dbCard;
     Id            = dbCard.Id;
     Count         = 1;
     PlayerClass   = HearthDbConverter.ConvertClass(dbCard.Class);
     Rarity        = dbCard.Rarity;
     Type          = HearthDbConverter.CardTypeConverter(dbCard.Type);
     Name          = dbCard.GetLocName(Locale.enUS);
     Cost          = dbCard.Cost;
     LocalizedName = dbCard.GetLocName(SelectedLanguage);
     Text          = dbCard.GetLocText(SelectedLanguage);
     EnglishText   = dbCard.GetLocText(Locale.enUS);
     Attack        = dbCard.Attack;
     Health        = dbCard.Health;
     Race          = HearthDbConverter.RaceConverter(dbCard.Race);
     Durability    = dbCard.Durability > 0 ? (int?)dbCard.Durability : null;
     Mechanics     = dbCard.Mechanics;
     Artist        = dbCard.ArtistName;
     Set           = HearthDbConverter.SetConverter(dbCard.Set);
     foreach (var altLangStr in Config.Instance.AlternativeLanguages)
     {
         if (Enum.TryParse(altLangStr, out Locale altLang))
         {
             AlternativeNames.Add(dbCard.GetLocName(altLang));
             AlternativeTexts.Add(dbCard.GetLocText(altLang));
         }
     }
     _loaded = true;
 }
예제 #4
0
        public void Load()
        {
            if (_loaded)
            {
                return;
            }

            var stats = Database.GetCardFromId(Id);

            if (stats == null)
            {
                return;
            }
            PlayerClass      = stats.PlayerClass;
            Rarity           = stats.Rarity;
            Type             = stats.Type;
            Name             = stats.Name;
            Cost             = stats.Cost;
            LocalizedName    = stats.LocalizedName;
            InHandCount      = stats.InHandCount;
            Text             = stats._text;
            EnglishText      = stats.EnglishText;
            Attack           = stats.Attack;
            Health           = stats.Health;
            Race             = stats.Race;
            Durability       = stats.Durability;
            Mechanics        = stats.Mechanics;
            Artist           = stats.Artist;
            Set              = stats.Set;
            AlternativeNames = stats.AlternativeNames;
            AlternativeTexts = stats.AlternativeTexts;
            _dbCard          = stats._dbCard;
            _loaded          = true;
            OnPropertyChanged();
        }
예제 #5
0
        private void PrintByCardCounts()
        {
            List <Pack> packs    = GetPacks();
            List <Card> allCards = GetAllCards();

            var cardCount = new Dictionary <HearthDb.Card, int>();

            allCards.ForEach((card) =>
            {
                HearthDb.Card key = card.CardInfo;
                int currentCount  = cardCount.ContainsKey(key) ? cardCount[key] : 0;
                currentCount++;
                cardCount[key] = currentCount;
            });

            var sorted = cardCount.OrderByDescending(kp => kp.Value).GroupBy(kp => kp.Key.Rarity).ToList();

            foreach (var group in sorted)
            {
                var kvps = group.ToList();

                WriteLine("{0} - {1}", group.Key, kvps.Count());
                WriteLine("------------------------------");
                kvps.ForEach((kvp) =>
                {
                    WriteLine("{0,25} {1}", kvp.Key.Name, kvp.Value);
                });
                WriteLine("");
            }
        }
예제 #6
0
        public Card(HearthDb.Card card)
        {
            Id   = card.Id;
            Name = card.Name;
            Text = card.Text;

            //use our own Card Class design
            switch (card.Class)
            {
            case CardClass.DRUID:
                Class = PlayerClasses.DRUID;
                break;

            case CardClass.HUNTER:
                Class = PlayerClasses.HUNTER;
                break;

            case CardClass.MAGE:
                Class = PlayerClasses.MAGE;
                break;

            case CardClass.PALADIN:
                Class = PlayerClasses.PALADIN;
                break;

            case CardClass.PRIEST:
                Class = PlayerClasses.PRIEST;
                break;

            case CardClass.ROGUE:
                Class = PlayerClasses.ROGUE;
                break;

            case CardClass.SHAMAN:
                Class = PlayerClasses.SHAMAN;
                break;

            case CardClass.WARLOCK:
                Class = PlayerClasses.WARLOCK;
                break;

            case CardClass.WARRIOR:
                Class = PlayerClasses.WARRIOR;
                break;

            default:
                Class = PlayerClasses.NONE;
                break;
            }

            Rarity = card.Rarity;
            Cost   = card.Cost;
        }
예제 #7
0
        private void Convert(HearthMirror.Objects.Deck deck)
        {
            for (int i = 0; i < deck.Cards.Count; i++)
            {
                HearthDb.Card dbCard = HearthDb.Cards.Collectible[deck.Cards[i].Id];

                Card card = new Card(dbCard)
                {
                    Count = deck.Cards[i].Count
                };

                m_lstCards.Add(card);
            }
        }
예제 #8
0
        private static int CheckForDisenchantedCards(List <Card> lstCurrentCollection, List <CachedCardEx> lstCardsHistory, List <Card> lstOld)
        {
            int nRet = 0;

            for (int i = 0; i < lstOld.Count; i++)
            {
                Card cardB = lstOld[i];

                HearthDb.Card dbCardB = HearthDb.Cards.All[cardB.Id];

                if (CardSets.All.ContainsKey(dbCardB.Set))
                {
                    Card cardA = lstCurrentCollection.Find(c => c.Id.Equals(cardB.Id) && c.Premium == cardB.Premium);

                    int nCount = cardB.Count;

                    if (cardA != null)
                    {
                        nCount = cardB.Count - cardA.Count;
                    }
                    else
                    {
                    }

                    nCount *= -1;

                    lstCardsHistory.Add(new CachedCardEx
                    {
                        Id        = cardB.Id,
                        Count     = nCount,
                        IsGolden  = cardB.Premium,
                        Timestamp = DateTime.Now
                    });

                    nRet += 1;
                }
                else
                {
                }
            }

            return(nRet);
        }
예제 #9
0
 public Card(HearthDb.Card dbCard, bool baconCard = false)
 {
     _dbCard       = dbCard;
     Id            = dbCard.Id;
     Count         = 1;
     PlayerClass   = HearthDbConverter.ConvertClass(dbCard.Class);
     Rarity        = dbCard.Rarity;
     Type          = HearthDbConverter.CardTypeConverter(dbCard.Type);
     Name          = dbCard.GetLocName(Locale.enUS);
     Cost          = dbCard.Cost;
     LocalizedName = dbCard.GetLocName(SelectedLanguage);
     Text          = dbCard.GetLocText(SelectedLanguage);
     EnglishText   = dbCard.GetLocText(Locale.enUS);
     Attack        = dbCard.Attack;
     Health        = dbCard.Health;
     Race          = HearthDbConverter.RaceConverter(dbCard.Race);
     Durability    = dbCard.Durability > 0 ? (int?)dbCard.Durability : null;
     Mechanics     = dbCard.Mechanics;
     Artist        = dbCard.ArtistName;
     Set           = HearthDbConverter.SetConverter(dbCard.Set);
     BaconCard     = baconCard;
     _loaded       = true;
 }
 public CardInfo(HearthDb.Card card, int count)
 {
     m_Card  = card;
     m_Count = count;
 }
예제 #11
0
		public Card(HearthDb.Card dbCard)
		{
			_dbCard = dbCard;
			Language lang;
			if(!Enum.TryParse(Config.Instance.SelectedLanguage, out lang))
				lang = Language.enUS;
			Id = dbCard.Id;
			Count = 1;
			PlayerClass = HearthDbConverter.ConvertClass(dbCard.Class);
			Rarity = HearthDbConverter.RariryConverter(dbCard.Rarity);
			Type = HearthDbConverter.CardTypeConverter(dbCard.Type);
			Name = dbCard.GetLocName(Language.enUS);
			Cost = dbCard.Cost;
			LocalizedName = dbCard.GetLocName(lang);
			Text = dbCard.GetLocText(lang);
			EnglishText = dbCard.GetLocText(Language.enUS);
			Attack = dbCard.Attack;
			Health = dbCard.Health;
			Race = HearthDbConverter.RaceConverter(dbCard.Race);
			Durability = dbCard.Durability > 0 ? (int?)dbCard.Durability : null;
			Mechanics = dbCard.Mechanics;
			Artist = dbCard.ArtistName;
			Set = HearthDbConverter.SetConverter(dbCard.Set);
			foreach(var altLangStr in Config.Instance.AlternativeLanguages)
			{
				Language altLang;
				if(Enum.TryParse(altLangStr, out altLang))
				{
					AlternativeNames.Add(dbCard.GetLocName(altLang));
					AlternativeTexts.Add(dbCard.GetLocText(altLang));
				}
			}
			_loaded = true;
		}
예제 #12
0
        private void PrintDupesByUser()
        {
            List <Pack> packs    = GetPacks();
            List <Card> allCards = GetAllCards();

            var outputs = new Dictionary <HearthDb.Enums.Rarity, List <String> >();

            packs.GroupBy(pack => pack.UploaderId).ToList().ForEach((group) =>
            {
                var packsCount = group.ToList().Count();
                WriteLine("------------------------------");
                WriteLine("{0} - {1}", group.Key, packsCount);
                WriteLine("------------------------------");
                WriteLine("");
                var allUserCards = group.Select((p) => p.Cards)
                                   .Aggregate(new List <Card>(), (result, cards) =>
                {
                    result.AddRange(cards);
                    return(result);
                }).ToList();

                var cardCount = new Dictionary <HearthDb.Card, int>();
                allUserCards.ForEach((card) =>
                {
                    HearthDb.Card key = card.CardInfo;
                    int currentCount  = cardCount.ContainsKey(key) ? cardCount[key] : 0;
                    currentCount++;
                    cardCount[key] = currentCount;
                });

                var sorted = cardCount.OrderByDescending(kp => kp.Value).GroupBy(kp => kp.Key.Rarity).ToList();
                foreach (var g in sorted)
                {
                    var kvps  = g.ToList();
                    var total = kvps.Sum(kp => kp.Value);

                    WriteLine("{0} - {1} - {2}", g.Key, kvps.Count(), total);
                    WriteLine("------------------------------");
                    WriteLine("{0:0.00}% - {1:0.00}%", ((double)kvps[kvps.Count() - 1].Value / (double)total) * 100.0d, ((double)kvps[0].Value / (double)total) * 100.0d);

                    if (!outputs.ContainsKey(g.Key))
                    {
                        outputs[g.Key] = new List <string>();
                    }
                    outputs[g.Key].Add(string.Format("{0:00.00}%", (double)kvps[0].Value / (double)kvps[kvps.Count() - 1].Value));
                    //kvps.ForEach((kvp) =>
                    //{
                    //    WriteLine("{0,25} {1}", kvp.Key.Name, kvp.Value);
                    //});
                    WriteLine("");
                }
            });

            WriteLine("------------------------------");
            WriteLine("------------------------------");
            WriteLine("");
            outputs.ToList().ForEach((kvp) =>
            {
                WriteLine("{0} ", kvp.Key);
                WriteLine("------------------------------");
                kvp.Value.OrderByDescending(v => v).ToList().ForEach((v) =>
                {
                    WriteLine(v);
                });
                WriteLine("");
            });
        }
예제 #13
0
		public Card(string id, string playerClass, Rarity rarity, string type, string name, int cost, string localizedName, int inHandCount,
		            int count, string text, string englishText, int attack, int health, string race, string[] mechanics, int? durability,
		            string artist, string set, List<string> alternativeNames = null, List<string> alternativeTexts = null, HearthDb.Card dbCard = null)
		{
			Id = id;
			PlayerClass = playerClass;
			Rarity = rarity;
			Type = type;
			Name = name;
			Cost = cost;
			LocalizedName = localizedName;
			InHandCount = inHandCount;
			Count = count;
			Text = text;
			EnglishText = englishText;
			Attack = attack;
			Health = health;
			Race = race;
			Durability = durability;
			Mechanics = mechanics;
			Artist = artist;
			Set = set;
			if(alternativeNames != null)
				AlternativeNames = alternativeNames;
			if(alternativeTexts != null)
				AlternativeTexts = alternativeTexts;
			_dbCard = dbCard;
		}
예제 #14
0
		public void Load()
		{
			if(_loaded)
				return;

			var stats = Database.GetCardFromId(Id);
			if(stats == null)
				return;
			PlayerClass = stats.PlayerClass;
			Rarity = stats.Rarity;
			Type = stats.Type;
			Name = stats.Name;
			Cost = stats.Cost;
			LocalizedName = stats.LocalizedName;
			InHandCount = stats.InHandCount;
			Text = stats._text;
			EnglishText = stats.EnglishText;
			Attack = stats.Attack;
			Health = stats.Health;
			Race = stats.Race;
			Durability = stats.Durability;
			Mechanics = stats.Mechanics;
			Artist = stats.Artist;
			Set = stats.Set;
			AlternativeNames = stats.AlternativeNames;
			AlternativeTexts = stats.AlternativeTexts;
			_dbCard = stats._dbCard;
			_loaded = true;
			OnPropertyChanged();
		}
예제 #15
0
 public PopularityCard(HearthDb.Card dbCard, JsonCard j)
 {
     this.dbCard   = dbCard;
     this.jsonCard = j;
 }
예제 #16
0
        public CardWrapper(Card card)
        {
            m_card = card;

            m_dbCard = HearthDb.Cards.All[m_card.Id];
        }