예제 #1
0
        public SuitBuilder Clone()
        {
            SuitBuilder newSuit = new SuitBuilder();

            for (int i = 0; i < nextOpenCacheIndex; i++)
            {
                newSuit.Push(cache[i].Piece, cache[i].Slot);
            }

            return(newSuit);
        }
예제 #2
0
        void SearchThroughBuckets(SuitBuilder builder, int index)
        {
            if (!Running)
            {
                return;
            }

            // Only continue to build any suits with a minimum potential of no less than 1 armor pieces less than our largest built suit so far
            if (builder.Count + 1 < highestArmorCountSuitBuilt - (totalArmorBucketsWithItems - Math.Min(index, totalArmorBucketsWithItems)))
            {
                return;
            }

            // Are we at the end of the line?
            if (buckets.Count <= index)
            {
                if (builder.Count == 0)
                {
                    return;
                }

                lock (lockObject)
                {
                    if (builder.TotalBodyArmorPieces > highestArmorCountSuitBuilt)
                    {
                        highestArmorCountSuitBuilt = builder.TotalBodyArmorPieces;
                    }

                    // We should keep track of the highest AL suits we built for every number of armor count suits built, and only push out ones that fall within our top X
                    List <int> list = highestArmorSuitsBuilt[builder.Count];
                    if (list.Count < list.Capacity)
                    {
                        if (!list.Contains(builder.TotalBaseArmorLevel))
                        {
                            list.Add(builder.TotalBaseArmorLevel);

                            if (list.Count == list.Capacity)
                            {
                                list.Sort();
                            }
                        }
                    }
                    else
                    {
                        if (list[list.Count - 1] > builder.TotalBaseArmorLevel)
                        {
                            return;
                        }

                        if (list[list.Count - 1] < builder.TotalBaseArmorLevel && !list.Contains(builder.TotalBaseArmorLevel))
                        {
                            list[list.Count - 1] = builder.TotalBaseArmorLevel;
                            list.Sort();
                        }
                    }

                    CompletedSuit newSuit = builder.CreateCompletedSuit();

                    // We should also keep track of all the suits we've built and make sure we don't push out a suit with the same exact pieces in swapped slots
                    foreach (CompletedSuit suit in completedSuits)
                    {
                        if (newSuit.IsSubsetOf(suit))
                        {
                            return;
                        }
                    }
                    completedSuits.Add(newSuit);

                    OnSuitCreated(newSuit);
                }

                return;
            }

            if (index == 0)             // If this is the first bucket we're searching through, multi-thread the subsearches
            {
                Parallel.ForEach(buckets[index], piece =>
                {
                    SuitBuilder clone = builder.Clone();

                    if (clone.SlotIsOpen(buckets[index].Slot) && (!piece.EquippableSlots.IsBodyArmor() || clone.HasRoomForArmorSet(Config.PrimaryArmorSet, Config.SecondaryArmorSet, piece.ItemSetId)) && clone.CanGetBeneficialSpellFrom(piece))
                    {
                        clone.Push(piece, buckets[index].Slot);

                        SearchThroughBuckets(clone, index + 1);

                        clone.Pop();
                    }
                });
            }
            else
            {
                foreach (SuitBuildableMyWorldObject piece in buckets[index])
                {
                    if (builder.SlotIsOpen(buckets[index].Slot) && (!piece.EquippableSlots.IsBodyArmor() || builder.HasRoomForArmorSet(Config.PrimaryArmorSet, Config.SecondaryArmorSet, piece.ItemSetId)) && builder.CanGetBeneficialSpellFrom(piece))
                    {
                        builder.Push(piece, buckets[index].Slot);

                        SearchThroughBuckets(builder, index + 1);

                        builder.Pop();
                    }
                }
            }

            SearchThroughBuckets(builder, index + 1);
        }
예제 #3
0
		void SearchThroughBuckets(SuitBuilder builder, int index)
		{
			if (!Running)
				return;

			// Only continue to build any suits with a minimum potential of no less than 1 armor pieces less than our largest built suit so far
			if (builder.Count + 1 < highestArmorCountSuitBuilt - (totalArmorBucketsWithItems - Math.Min(index, totalArmorBucketsWithItems)))
				return;

			// Are we at the end of the line?
			if (buckets.Count <= index)
			{
				if (builder.Count == 0)
					return;

				lock (lockObject)
				{
					if (builder.TotalBodyArmorPieces > highestArmorCountSuitBuilt)
						highestArmorCountSuitBuilt = builder.TotalBodyArmorPieces;

					// We should keep track of the highest AL suits we built for every number of armor count suits built, and only push out ones that fall within our top X
					List<int> list = highestArmorSuitsBuilt[builder.Count];
					if (list.Count < list.Capacity)
					{
						if (!list.Contains(builder.TotalBaseArmorLevel))
						{
							list.Add(builder.TotalBaseArmorLevel);

							if (list.Count == list.Capacity)
								list.Sort();
						}
					}
					else
					{
						if (list[list.Count - 1] > builder.TotalBaseArmorLevel)
							return;

						if (list[list.Count - 1] < builder.TotalBaseArmorLevel && !list.Contains(builder.TotalBaseArmorLevel))
						{
							list[list.Count - 1] = builder.TotalBaseArmorLevel;
							list.Sort();
						}
					}

					CompletedSuit newSuit = builder.CreateCompletedSuit();

					// We should also keep track of all the suits we've built and make sure we don't push out a suit with the same exact pieces in swapped slots
					foreach (CompletedSuit suit in completedSuits)
					{
						if (newSuit.IsSubsetOf(suit))
							return;
					}
					completedSuits.Add(newSuit);

					OnSuitCreated(newSuit);
				}

				return;
			}

			if (index == 0) // If this is the first bucket we're searching through, multi-thread the subsearches
			{
				Parallel.ForEach(buckets[index], piece =>
				{
					SuitBuilder clone = builder.Clone();

					if (clone.SlotIsOpen(buckets[index].Slot) && (!piece.EquippableSlots.IsBodyArmor() || clone.HasRoomForArmorSet(Config.PrimaryArmorSet, Config.SecondaryArmorSet, piece.ItemSetId)) && clone.CanGetBeneficialSpellFrom(piece))
					{
						clone.Push(piece, buckets[index].Slot);

						SearchThroughBuckets(clone, index + 1);

						clone.Pop();
					}
				});
			}
			else
			{
				foreach (SuitBuildableMyWorldObject piece in buckets[index])
				{
					if (builder.SlotIsOpen(buckets[index].Slot) && (!piece.EquippableSlots.IsBodyArmor() || builder.HasRoomForArmorSet(Config.PrimaryArmorSet, Config.SecondaryArmorSet, piece.ItemSetId)) && builder.CanGetBeneficialSpellFrom(piece))
					{
						builder.Push(piece, buckets[index].Slot);

						SearchThroughBuckets(builder, index + 1);

						builder.Pop();
					}
				}
			}

			SearchThroughBuckets(builder, index + 1);
		}
예제 #4
0
		public SuitBuilder Clone()
		{
			SuitBuilder newSuit = new SuitBuilder();

			for (int i = 0; i < nextOpenCacheIndex; i++)
				newSuit.Push(cache[i].Piece, cache[i].Slot);

			return newSuit;
		}
예제 #5
0
        void SearchThroughBuckets(List <Bucket> buckets, int index)
        {
            if (!Running)
            {
                return;
            }

            // Only continue to build any suits with a minimum potential of no less than 1 epics less than our largest built suit so far
            if (SuitBuilder.Count + 1 < highestCountSuitBuilt - (highestCountSuitBuilt - index))
            {
                return;
            }

            // Are we at the end of the line?
            if (buckets.Count <= index)
            {
                if (SuitBuilder.Count == 0)
                {
                    return;
                }

                if (SuitBuilder.Count > highestCountSuitBuilt)
                {
                    highestCountSuitBuilt = SuitBuilder.TotalBodyArmorPieces;
                }

                CompletedSuit newSuit = SuitBuilder.CreateCompletedSuit();

                // We should keep track of the highest epic suits we built for every number of item count suits built, and only push out ones that fall within our top X
                List <int> list = highestEffectiveSpellsSuitBuilt[SuitBuilder.Count];
                if (list.Count < list.Capacity)
                {
                    list.Add(newSuit.TotalEffectiveEpics);

                    if (list.Count == list.Capacity)
                    {
                        list.Sort();
                    }
                }
                else
                {
                    if (list[list.Count - 1] >= newSuit.TotalEffectiveEpics)
                    {
                        return;
                    }

                    list[list.Count - 1] = newSuit.TotalEffectiveEpics;
                    list.Sort();
                }

                // We should also keep track of all the suits we've built and make sure we don't push out a suit with the same exact pieces in swapped slots
                foreach (CompletedSuit suit in completedSuits)
                {
                    if (newSuit.IsSubsetOf(suit))
                    {
                        return;
                    }
                }

                completedSuits.Add(newSuit);

                OnSuitCreated(newSuit);

                return;
            }

            //for (int i = 0; i < buckets[index].Count ; i++)
            foreach (var piece in buckets[index])             // Using foreach: 10.85s, for: 11s
            {
                if (SuitBuilder.CanGetBeneficialSpellFrom(piece))
                {
                    SuitBuilder.Push(piece, buckets[index].Slot);

                    SearchThroughBuckets(buckets, index + 1);

                    SuitBuilder.Pop();
                }
            }

            SearchThroughBuckets(buckets, index + 1);
        }
예제 #6
0
        protected Searcher(SearcherConfiguration config, IEnumerable <LeanMyWorldObject> equipment, CompletedSuit startingSuit = null)
        {
            Config = config;

            foreach (var piece in equipment)
            {
                Equipment.Add(piece);
            }

            // Remove surpassed pieces
            for (int i = Equipment.Count - 1; i >= 0; i--)
            {
                if (Equipment.ItemIsSurpassed(Equipment[i]))
                {
                    Equipment.RemoveAt(i);
                }
            }

            // If we were given a starting suit, lets start our SuitBuilder off with all those items
            if (startingSuit != null)
            {
                foreach (var o in startingSuit)
                {
                    SuitBuilder.Push(o.Value, o.Key);
                }
            }

            // Remove pieces that can provide no beneficial spell
            for (int i = Equipment.Count - 1; i >= 0; i--)
            {
                if (!SuitBuilder.CanGetBeneficialSpellFrom(Equipment[i]))
                {
                    Equipment.RemoveAt(i);
                }
            }

            // Remove pieces we can't add to our base suit
            for (int i = Equipment.Count - 1; i >= 0; i--)
            {
                if (!SuitBuilder.SlotIsOpen(Equipment[i].EquippableSlots))
                {
                    if (Equipment[i].EquippableSlots.GetTotalBitsSet() == 1)
                    {
                        Equipment.RemoveAt(i);
                    }
                    else
                    {
                        if (Equipment[i].EquippableSlots.IsBodyArmor())
                        {
                            var reductionOptions = Equipment[i].Coverage.ReductionOptions();

                            foreach (var option in reductionOptions)
                            {
                                if (option == CoverageMask.OuterwearChest && SuitBuilder.SlotIsOpen(EquipMask.ChestArmor))
                                {
                                    goto end;
                                }
                                if (option == CoverageMask.OuterwearUpperArms && SuitBuilder.SlotIsOpen(EquipMask.UpperArmArmor))
                                {
                                    goto end;
                                }
                                if (option == CoverageMask.OuterwearLowerArms && SuitBuilder.SlotIsOpen(EquipMask.LowerArmArmor))
                                {
                                    goto end;
                                }
                                if (option == CoverageMask.OuterwearAbdomen && SuitBuilder.SlotIsOpen(EquipMask.AbdomenArmor))
                                {
                                    goto end;
                                }
                                if (option == CoverageMask.OuterwearUpperLegs && SuitBuilder.SlotIsOpen(EquipMask.UpperLegArmor))
                                {
                                    goto end;
                                }
                                if (option == CoverageMask.OuterwearLowerLegs && SuitBuilder.SlotIsOpen(EquipMask.LowerLegArmor))
                                {
                                    goto end;
                                }
                            }

                            Equipment.RemoveAt(i);
                        }
                        else
                        {
                            if ((Equipment[i].EquippableSlots.HasFlag(EquipMask.FingerWearLeft) || Equipment[i].EquippableSlots.HasFlag(EquipMask.FingerWearRight)) && !SuitBuilder.SlotIsOpen(EquipMask.FingerWearLeft) && !SuitBuilder.SlotIsOpen(EquipMask.FingerWearRight))
                            {
                                Equipment.RemoveAt(i); goto end;
                            }
                            if ((Equipment[i].EquippableSlots.HasFlag(EquipMask.WristWearLeft) || Equipment[i].EquippableSlots.HasFlag(EquipMask.WristWearRight)) && !SuitBuilder.SlotIsOpen(EquipMask.WristWearLeft) && !SuitBuilder.SlotIsOpen(EquipMask.WristWearRight))
                            {
                                Equipment.RemoveAt(i); goto end;
                            }
                        }
                    }
                }

                end :;
            }
        }
예제 #7
0
        protected Searcher(SearcherConfiguration config, IEnumerable <SuitBuildableMyWorldObject> equipment, CompletedSuit startingSuit = null)
        {
            Config = config;

            foreach (var piece in equipment)
            {
                if (!piece.Exclude)
                {
                    Equipment.Add(piece);
                }
            }

            // Remove pieces that don't meet our minimum requirements
            for (int i = Equipment.Count - 1; i >= 0; i--)
            {
                if (!config.ItemPassesRules(Equipment[i]))
                {
                    Equipment.RemoveAt(i);
                }
            }

            // Remove surpassed pieces
            for (int i = Equipment.Count - 1; i >= 0; i--)
            {
                if (Equipment.ItemIsSurpassed(Equipment[i]))
                {
                    Equipment.RemoveAt(i);
                }
            }

            // If we were given a starting suit, lets start our SuitBuilder off with all those items
            if (startingSuit != null)
            {
                foreach (var o in startingSuit)
                {
                    SuitBuilder.Push(o.Value, o.Key);
                }
            }

            // Remove pieces that can provide no beneficial spell
            for (int i = Equipment.Count - 1; i >= 0; i--)
            {
                if (!SuitBuilder.CanGetBeneficialSpellFrom(Equipment[i]))
                {
                    Equipment.RemoveAt(i);
                }
            }

            // Remove pieces we can't add to our base suit
            for (int i = Equipment.Count - 1; i >= 0; i--)
            {
                if (!SuitBuilder.SlotIsOpen(Equipment[i].EquippableSlots))
                {
                    if (Equipment[i].EquippableSlots.GetTotalBitsSet() == 1)
                    {
                        Equipment.RemoveAt(i);
                    }
                    else
                    {
                        if (Equipment[i].EquippableSlots.IsBodyArmor())
                        {
                            var reductionOptions = Equipment[i].Coverage.ReductionOptions();

                            foreach (var option in reductionOptions)
                            {
                                if (option == CoverageFlags.Chest && SuitBuilder.SlotIsOpen(EquippableSlotFlags.Chest))
                                {
                                    goto end;
                                }
                                if (option == CoverageFlags.UpperArms && SuitBuilder.SlotIsOpen(EquippableSlotFlags.UpperArms))
                                {
                                    goto end;
                                }
                                if (option == CoverageFlags.LowerArms && SuitBuilder.SlotIsOpen(EquippableSlotFlags.LowerArms))
                                {
                                    goto end;
                                }
                                if (option == CoverageFlags.Abdomen && SuitBuilder.SlotIsOpen(EquippableSlotFlags.Abdomen))
                                {
                                    goto end;
                                }
                                if (option == CoverageFlags.UpperLegs && SuitBuilder.SlotIsOpen(EquippableSlotFlags.UpperLegs))
                                {
                                    goto end;
                                }
                                if (option == CoverageFlags.LowerLegs && SuitBuilder.SlotIsOpen(EquippableSlotFlags.LowerLegs))
                                {
                                    goto end;
                                }
                            }

                            Equipment.RemoveAt(i);
                        }
                        else
                        {
                            if ((Equipment[i].EquippableSlots.HasFlag(EquippableSlotFlags.LeftRing) || Equipment[i].EquippableSlots.HasFlag(EquippableSlotFlags.RightRing)) && !SuitBuilder.SlotIsOpen(EquippableSlotFlags.LeftRing) && !SuitBuilder.SlotIsOpen(EquippableSlotFlags.RightRing))
                            {
                                Equipment.RemoveAt(i); goto end;
                            }
                            if ((Equipment[i].EquippableSlots.HasFlag(EquippableSlotFlags.LeftBracelet) || Equipment[i].EquippableSlots.HasFlag(EquippableSlotFlags.RightBracelet)) && !SuitBuilder.SlotIsOpen(EquippableSlotFlags.LeftBracelet) && !SuitBuilder.SlotIsOpen(EquippableSlotFlags.RightBracelet))
                            {
                                Equipment.RemoveAt(i); goto end;
                            }
                        }
                    }
                }

                end :;
            }
        }