Esempio n. 1
0
        private bool ParseFromEnd(Regex pattern, ItemSections itemSections)
        {
            if (itemSections.WholeSections.Length < 3)
            {
                return(false);
            }

            // Section order at the end:
            // Corruption
            // Influence
            // Note
            return(pattern.IsMatch(itemSections.WholeSections[^ 1]) ||
Esempio n. 2
0
        private void ParseMap(Item item, ItemSections itemSections)
        {
            var mapBlock = itemSections.MapPropertiesSection;

            item.ItemLevel  = patterns.GetInt(patterns.ItemLevel, item.Text);
            item.Identified = !patterns.Unidentified.IsMatch(item.Text);
            item.Properties.ItemQuantity    = patterns.GetInt(patterns.ItemQuantity, mapBlock);
            item.Properties.ItemRarity      = patterns.GetInt(patterns.ItemRarity, mapBlock);
            item.Properties.MonsterPackSize = patterns.GetInt(patterns.MonsterPackSize, mapBlock);
            item.Properties.MapTier         = patterns.GetInt(patterns.MapTier, mapBlock);
            item.Properties.Quality         = patterns.GetInt(patterns.Quality, mapBlock);
            item.Properties.Blighted        = patterns.Blighted.IsMatch(itemSections.WholeSections[0]);
            item.Corrupted = ParseFromEnd(patterns.Corrupted, itemSections);
        }
Esempio n. 3
0
        private void ParseEquipmentProperties(Item item, ItemSections itemSections)
        {
            var propertySection = itemSections.WholeSections[1];

            item.ItemLevel                       = patterns.GetInt(patterns.ItemLevel, item.Text);
            item.Identified                      = !ParseFromEnd(patterns.Unidentified, itemSections);
            item.Properties.Armor                = patterns.GetInt(patterns.Armor, propertySection);
            item.Properties.EnergyShield         = patterns.GetInt(patterns.EnergyShield, propertySection);
            item.Properties.Evasion              = patterns.GetInt(patterns.Evasion, propertySection);
            item.Properties.ChanceToBlock        = patterns.GetInt(patterns.ChanceToBlock, propertySection);
            item.Properties.Quality              = patterns.GetInt(patterns.Quality, propertySection);
            item.Properties.AttacksPerSecond     = patterns.GetDouble(patterns.AttacksPerSecond, propertySection);
            item.Properties.CriticalStrikeChance = patterns.GetDouble(patterns.CriticalStrikeChance, propertySection);
            item.Properties.ElementalDps         = patterns.GetDps(patterns.ElementalDamage, propertySection, item.Properties.AttacksPerSecond);
            item.Properties.PhysicalDps          = patterns.GetDps(patterns.PhysicalDamage, propertySection, item.Properties.AttacksPerSecond);
            item.Properties.DamagePerSecond      = item.Properties.ElementalDps + item.Properties.PhysicalDps;
            item.Corrupted                       = ParseFromEnd(patterns.Corrupted, itemSections);
        }
Esempio n. 4
0
        private Item ParseItemDetails(string itemText, ItemSections itemSections, ItemData itemData)
        {
            var item = new Item
            {
                Text     = itemText,
                Name     = itemData.Name,
                Type     = itemData.Type,
                NameLine = itemSections.NameLine,
                TypeLine = itemSections.TypeLine,
                Rarity   = itemData.Rarity,
                Category = itemData.Category,
            };

            switch (itemData.Category)
            {
            case Category.DivinationCard:
            case Category.Currency:
            case Category.Prophecy:
                break;

            case Category.Gem:
                ParseGem(item, itemSections);
                break;

            case Category.Map:
                ParseMap(item, itemSections);
                ParseMods(item);
                break;

            default:
                ParseEquipmentProperties(item, itemSections);
                ParseMods(item);
                ParseSockets(item);
                ParseInfluences(item, itemSections);
                break;
            }

            return(item);
        }
Esempio n. 5
0
        public async Task <Item> ParseItem(string itemText)
        {
            try
            {
                await languageProvider.FindAndSetLanguage(itemText);

                itemText = itemNameTokenizer.CleanString(itemText);

                var wholeSections = itemText.Split(SEPARATOR_PATTERN, StringSplitOptions.RemoveEmptyEntries);
                var splitSections = wholeSections
                                    .Select(block => newLinePattern
                                            .Split(block)
                                            .Where(line => line != "")
                                            .ToArray())
                                    .ToArray();

                var itemSections = new ItemSections(splitSections, wholeSections);

                var itemData = itemDataService.ParseItemData(itemSections);

                if (itemData == null || string.IsNullOrEmpty(itemData.Name) && string.IsNullOrEmpty(itemData.Type))
                {
                    throw new NotSupportedException("Item not found.");
                }

                if (itemData.Rarity == Rarity.Unknown)
                {
                    itemData.Rarity = GetRarity(itemSections.Rarity);
                }

                return(ParseItemDetails(itemText, itemSections, itemData));
            }
            catch (Exception e)
            {
                logger.Error(e, "Could not parse item.");
                return(null);
            }
        }
Esempio n. 6
0
 private void ParseGem(Item item, ItemSections itemSections)
 {
     item.Properties.GemLevel = patterns.GetInt(patterns.Level, itemSections.WholeSections[1]);
     item.Properties.Quality  = patterns.GetInt(patterns.Quality, itemSections.WholeSections[1]);
     item.Corrupted           = ParseFromEnd(patterns.Corrupted, itemSections);
 }