コード例 #1
0
 private static IEnumerable <XmlAffix> GroupToTypes(XmlAffix affix)
 {
     if (affix.ItemGroup == ItemGroup.Unknown)
     {
         yield return(affix);
     }
     else
     {
         foreach (var itemType in affix.ItemGroup.Types())
         {
             yield return(new XmlAffix
             {
                 Global = affix.Global,
                 ItemGroup = ItemGroup.Unknown,
                 ItemType = itemType,
                 ModType = affix.ModType,
                 Name = affix.Name,
                 Tiers = affix.Tiers
             });
         }
     }
 }
コード例 #2
0
        protected override async Task LoadAsync()
        {
            var file = await HttpClient.GetStringAsync(Url);

            file = file.Replace(Root + " = ", "{ \"" + Root + "\": ") + "}";

            var json  = JObject.Parse(file);
            var types = from t in json["htmlObject"]
                        let p = (JProperty)t
                                where !p.Name.Contains("map") && !p.Name.Contains("flask") && !p.Name.Contains("fishing")
                                select new { Type = p.Name, Content = Trim(p.Value.ToString()) };

            // <tr><td colspan='3'>...</td><tr> -> mod started, next line describes the tiers
            // </table>... -> Prefixes end, Suffixes start on next line

            var affixes = new List <XmlAffix>();

            foreach (var type in types)
            {
                // We don't care about groups, they only contain the sub groups.
                if (type.Content.Contains("<a id="))
                {
                    continue;
                }

                ItemType itemType;
                if (!TryParseItemType(type.Type, out itemType))
                {
                    Console.WriteLine("Could not parse item type {0}, ignoring it.", type.Type);
                    continue;
                }

                var modType = ModType.Prefix;

                var lines = type.Content.Split('\n');
                for (var i = 0; i < lines.Length - 1; i++)
                {
                    if (lines[i].StartsWith("</table>"))
                    {
                        if (modType == ModType.Prefix)
                        {
                            modType = ModType.Suffix;
                        }
                        else
                        {
                            break;
                        }
                    }
                    if (!lines[i].StartsWith("<tr><td colspan='3'>"))
                    {
                        continue;
                    }

                    var nameLine  = lines[i];
                    var affixName = ExtractAffixName(nameLine);
                    foreach (var nameChange in GenericNameChanges)
                    {
                        affixName = nameChange.Item1.Replace(affixName, nameChange.Item2);
                    }
                    var affix = new XmlAffix
                    {
                        ModType  = modType,
                        Global   = IsGlobal(nameLine),
                        ItemType = itemType
                    };

                    ChangeRange itemTypeSpecificRangeChange;
                    ItemTypeSpecificRangeChanges.TryGetValue(itemType, out itemTypeSpecificRangeChange);
                    Func <string, string, string> rangeRenameFunc = (_, range) => range;

                    var tierRows = lines[++i].Replace("</table>", "").Replace("<tr>", "")
                                   .Split(new [] { "</tr>" }, StringSplitOptions.RemoveEmptyEntries);
                    var tierList    = new List <XmlTier>();
                    var currentTier = 1;
                    foreach (var tierRow in tierRows.Reverse())
                    {
                        var columns  = tierRow.Replace("<td>", "").Split(new[] { "</td>" }, StringSplitOptions.None);
                        var tierName = columns[2];
                        if (itemTypeSpecificRangeChange != null)
                        {
                            rangeRenameFunc = (aff, range) => itemTypeSpecificRangeChange(aff, tierName, range);
                        }
                        tierList.Add(new XmlTier
                        {
                            ItemLevel       = columns[0].ParseInt(),
                            Stats           = ExtractStats(columns[1], affixName, rangeRenameFunc).ToArray(),
                            Name            = tierName,
                            IsMasterCrafted = MasterCraftedRegex.IsMatch(columns[2]),
                            Tier            = tierName.Contains(" lvl: ") ? 0 : currentTier++
                        });
                    }
                    affix.Tiers = Enumerable.Reverse(tierList).ToArray();
                    affix.Name  = string.Join(", ", affix.Tiers[0].Stats.Select(s => s.Name));

                    affixes.Add(affix);
                }
            }

            Data = new XmlAffixList
            {
                Affixes = affixes.ToArray()
            };
        }