示例#1
0
        public Affix GetAffix(List <Affix> affixes, EquipmentRarity rarity, IRandom random, List <Fossil> fossils = null)
        {
            if (fossils == null)
            {
                fossils = new List <Fossil>();
            }

            var addedTags   = affixes.SelectMany(x => x.AddsTags).Distinct().ToList();
            var fossilNames = fossils.Select(x => x.FullName).Distinct().ToList();

            var masterMods = affixes.Where(x => x.Group.Contains(NoAttackMods) || x.Group.Contains(NoCasterMods)).Select(x => x.Group).ToList();

            PoolKey key = new PoolKey(addedTags, fossilNames, masterMods);

            if (!_poolDic.ContainsKey(key))
            {
                _poolDic.Add(key, GenerateAffixPool(addedTags, fossils, masterMods));
            }

            AffixPool pool           = _poolDic[key];
            var       existingGroups = new HashSet <string>(affixes.Select(x => x.Group));

            int affixesCount = rarity == EquipmentRarity.Normal ? 0 :
                               rarity == EquipmentRarity.Magic ? 1 :
                               rarity == EquipmentRarity.Rare ? 3 : 0;

            double prefixSkipAmount = 0;
            double suffixSkipAmount = 0;

            if (affixes.Count(x => x.GenerationType == "prefix") >= affixesCount)
            {
                prefixSkipAmount = pool.PrefixWeight;
            }
            else
            {
                prefixSkipAmount = affixes
                                   .Select(x => x.Group)
                                   .Where(x => pool.PrefixGroupWeights.ContainsKey(x))
                                   .Sum(x => pool.PrefixGroupWeights[x]);
            }

            if (affixes.Count(x => x.GenerationType == "suffix") >= affixesCount)
            {
                suffixSkipAmount = pool.SuffixWeight;
            }
            else
            {
                suffixSkipAmount = affixes
                                   .Select(x => x.Group)
                                   .Where(x => pool.SuffixGroupWeights.ContainsKey(x))
                                   .Sum(x => pool.SuffixGroupWeights[x]);
            }

            var totalWeight = pool.TotalWeight;

            totalWeight -= prefixSkipAmount;
            totalWeight -= suffixSkipAmount;

            var targetWeight = random.NextDouble() * totalWeight;

            return(GetRandomAffixFromPool(pool, targetWeight, existingGroups, prefixSkipAmount, suffixSkipAmount));
        }
示例#2
0
 protected bool Equals(PoolKey other)
 {
     return(Tags.All(x => other.Tags.Contains(x)) && Fossils.All(x => other.Fossils.Contains(x)) && MasterMods.All(x => other.MasterMods.Contains(x)));
 }