Example #1
0
    List <CardLocalization> LoadInTSVtoCards(string filename)
    {
        List <CardLocalization> CardList = new List <CardLocalization>();
        TextAsset LocalizationText       = Resources.Load <TextAsset>(filename);

        string[] data = LocalizationText.text.Split(new char[] { '\n' });

        for (int i = 1; i < data.Length - 1; i++)
        {
            string[] row = data[i].Split(new char[] { '\t' });

            CardLocalization c = new CardLocalization();

            int.TryParse(row[0], out c.id);

            c.Title_EN       = row[1];
            c.Description_EN = row[2];

            c.Title_DE       = row[3];
            c.Description_DE = row[4];

            CardList.Add(c);
        }

        return(CardList);
    }
Example #2
0
        public void All_symbols_in_card_fields_are_known()
        {
            // ReSharper disable StringLiteralTypo
            var latin             = new HashSet <char>("abcdefghijklmnopqrstuvwxyz");
            var cyrillic          = new HashSet <char>("абвгдежзийклмнопрстуфхцчшщьыъэюя");
            var numbers           = new HashSet <char>("01234567890");
            var knownSpecialChars = new HashSet <char>("ºß");            // artist name
            // ReSharper restore StringLiteralTypo

            var alphabet = new HashSet <char>();

            var languages = new HashSet <string>(CardLocalization.GetAllLanguages(), Str.Comparer);

            languages.Remove("cn");
            languages.Remove("tw");
            languages.Remove("jp");
            languages.Remove("kr");

            var empty = Enumerable.Empty <char>();

            foreach (var set in Repo.SetsByCode.Values)
            {
                alphabet.UnionWith(set.Name);
                alphabet.UnionWith(set.Code);
            }

            var failedCards = new List <(char[], Card)>();

            foreach (var card in Repo.Cards)
            {
                var cardChars = new HashSet <char>();
                cardChars.UnionWith(card.NameEn ?? empty);
                cardChars.UnionWith(card.TypeEn ?? empty);
                cardChars.UnionWith(card.FlavorEn ?? empty);
                cardChars.UnionWith(card.TextEn ?? empty);
                cardChars.UnionWith(card.OriginalText ?? empty);
                cardChars.UnionWith(card.OriginalType ?? empty);
                cardChars.UnionWith(card.Artist?.Where(_ => !_.IsCjk()) ?? empty);

                foreach (string lang in languages)
                {
                    cardChars.UnionWith(card.GetName(lang) ?? empty);
                    cardChars.UnionWith(card.GetType(lang) ?? empty);
                    cardChars.UnionWith(card.GetFlavor(lang) ?? empty);
                    cardChars.UnionWith(card.GetText(lang) ?? empty);
                }

                var badChars = cardChars.Where(isUnknownChar).Where(shouldBeConsidered).ToArray();
                if (badChars.Length > 0)
                {
                    failedCards.Add((badChars, card));
                }

                alphabet.UnionWith(cardChars);
            }

            var chars = alphabet.Select(c => char.ToLower(c, Str.Culture)).Distinct().OrderBy(c => c).ToArray();

            Log.Debug(() => new string(chars));

            var unknownChars = chars.Where(isUnknownChar).ToArray();

            Log.Debug(new string(unknownChars.ToArray()));

            var notConsideredChars = new string(unknownChars.Where(shouldBeConsidered).ToArray());

            Assert.That(failedCards, Is.Empty, "Bad symbols in {0} cards", failedCards.Count);

            Assert.That(notConsideredChars, Is.Empty);
Example #3
0
        public void All_symbols_in_card_texts_are_considered_in_code()
        {
            var alphabet = new HashSet <char>();

            var languages = new HashSet <string>(CardLocalization.GetAllLanguages(), Str.Comparer);

            languages.Remove("cn");
            languages.Remove("tw");
            languages.Remove("jp");
            languages.Remove("kr");

            foreach (var set in Repo.SetsByCode.Values)
            {
                alphabet.UnionWith(set.Name);
                alphabet.UnionWith(set.Code);
            }

            foreach (var card in Repo.Cards)
            {
                alphabet.UnionWithNullable(card.NameEn);
                alphabet.UnionWithNullable(card.TypeEn);
                alphabet.UnionWithNullable(card.FlavorEn);
                alphabet.UnionWithNullable(card.TextEn);
                alphabet.UnionWithNullable(card.Artist);

                foreach (string lang in languages)
                {
                    alphabet.UnionWithNullable(card.GetName(lang));
                    alphabet.UnionWithNullable(card.GetType(lang));
                    alphabet.UnionWithNullable(card.GetFlavor(lang));
                    alphabet.UnionWithNullable(card.GetText(lang));
                }
            }

            var chars = alphabet.Select(c => char.ToLower(c, Str.Culture)).Distinct().OrderBy(c => c).ToArray();

            Log.Debug(() => new string(chars));

            var specialChars = new List <char>();

            // ReSharper disable StringLiteralTypo
            var latin             = new HashSet <char>("abcdefghijklmnopqrstuvwxyz");
            var cyrillic          = new HashSet <char>("абвгдежзийклмнопрстуфхцчшщьыъэюя");
            var numbers           = new HashSet <char>("01234567890");
            var knownSpecialChars = new HashSet <char>("ºß林泰玄");

            // ReSharper restore StringLiteralTypo

            foreach (char c in chars)
            {
                if (latin.Contains(c))
                {
                    continue;
                }

                if (cyrillic.Contains(c))
                {
                    continue;
                }

                if (numbers.Contains(c))
                {
                    continue;
                }

                if (c == '\n')
                {
                    continue;
                }

                if (c == '\r')
                {
                    continue;
                }

                if (MtgAlphabet.Replacements.ContainsKey(c))
                {
                    continue;
                }

                if (MtgAlphabet.WordCharsSet.Contains(c))
                {
                    continue;
                }

                if (MtgAlphabet.LeftDelimitersSet.Contains(c))
                {
                    continue;
                }

                if (MtgAlphabet.RightDelimitersSet.Contains(c))
                {
                    continue;
                }

                if (MtgAlphabet.SingletoneWordChars.Contains(c))
                {
                    continue;
                }

                if (knownSpecialChars.Contains(c))
                {
                    continue;
                }

                specialChars.Add(c);
            }

            var specialCharsStr = new string(specialChars.ToArray());

            Log.Debug(specialCharsStr);

            var notConsideredChars = new string(specialCharsStr.Where(char.IsLetterOrDigit).ToArray());

            Assert.That(notConsideredChars, Is.Empty);
        }