Exemplo n.º 1
0
        private static string getLootRankWeightFilter(Character character)
        {
            StringBuilder wtf = new StringBuilder();

            ComparisonCalculationBase[] statValues = CalculationsBase.GetRelativeStatValues(character);
            foreach (ComparisonCalculationBase ccb in statValues)
            {
                string stat = getLootrankStatID(ccb.Name);
                if (!stat.Equals(string.Empty))
                {
                    wtf.Append(stat + "=" + ccb.OverallPoints.ToString("F2", System.Globalization.CultureInfo.InvariantCulture) + "&");
                }
            }
            if (character.CurrentModel == "Enhance")
            {
                wtf.Append("s1=2.4&s3=2.4&dps=6&odps=3&");
            }
            if (wtf.Length == 0)
            {
                return(string.Empty);
            }
            else
            {
                return(wtf.ToString());
            }
        }
Exemplo n.º 2
0
        internal Item[] GetRelevantItemsInternal(CalculationsBase model)
        {
            List <Item> itemList = new List <Item>(AllItems).FindAll(new Predicate <Item>(
                                                                         delegate(Item item) { return(model.IsItemRelevant(item) && ItemFilter.IsItemRelevant(model, item)); }));

            return(itemList.ToArray());
        }
Exemplo n.º 3
0
        public static List <Enchant> FindEnchants(Item.ItemSlot slot, CalculationsBase model)
        {
            List <Item.ItemSlot> validSlots = new List <Item.ItemSlot>();

            if (slot != Item.ItemSlot.MainHand)
            {
                validSlots.Add(slot);
            }
            if (slot == Item.ItemSlot.OffHand || slot == Item.ItemSlot.MainHand || slot == Item.ItemSlot.TwoHand)
            {
                validSlots.Add(Item.ItemSlot.OneHand);
            }
            if (slot == Item.ItemSlot.MainHand)
            {
                validSlots.Add(Item.ItemSlot.TwoHand);
            }
            return(AllEnchants.FindAll(new Predicate <Enchant>(
                                           delegate(Enchant enchant)
            {
                return model.HasRelevantStats(enchant.Stats) &&
                (validSlots.Contains(enchant.Slot) || slot == Item.ItemSlot.None) ||
                enchant.Slot == Item.ItemSlot.None;
            }
                                           )));
        }
Exemplo n.º 4
0
 public void LoadRelativeStatValues()
 {
     comparisonGraph1.RoundValues      = true;
     comparisonGraph1.CustomRendered   = false;
     comparisonGraph1.ItemCalculations = CalculationsBase.GetRelativeStatValues(Character);
     comparisonGraph1.EquipSlot        = CharacterSlot.None;
     _characterSlot = CharacterSlot.None;
 }
Exemplo n.º 5
0
        public Item[] GetUnfilteredRelevantItems(CalculationsBase model, CharacterRace race)
        {
            List <Item> itemList = new List <Item>(AllItems).FindAll(new Predicate <Item>(
                                                                         delegate(Item item)
            {
                return(model.IsItemRelevant(item) && item.FitsFaction(race));
            }));

            return(itemList.ToArray());
        }
Exemplo n.º 6
0
        /// <summary>
        /// Returns a list that can be used to set relevant item types list. Call ItemCache.OnItemsChanged()
        /// when you finish making changes to the list.
        /// </summary>
        public static List <ItemType> GetRelevantItemTypesList(CalculationsBase model)
        {
            ItemTypeList list;

            if (!data.RelevantItemTypes.TryGetValue(model.Name, out list))
            {
                list = new ItemTypeList(model.RelevantItemTypes);
                data.RelevantItemTypes[model.Name] = list;
            }
            return(list);
        }
Exemplo n.º 7
0
        public static List <GemmingTemplate> GetModelTemplates(CalculationsBase model)
        {
            List <GemmingTemplate> list;

            if (!AllTemplates.TryGetValue(model.Name, out list))
            {
                list = new List <GemmingTemplate>(model.DefaultGemmingTemplates);
                AllTemplates[model.Name] = list;
            }
            return(list);
        }
Exemplo n.º 8
0
 public Item[] GetRelevantItems(CalculationsBase model)
 {
     if (model == Calculations.Instance)
     {
         return(RelevantItems);
     }
     else
     {
         return(new List <Item>(AllItems).FindAll(new Predicate <Item>(
                                                      delegate(Item item) { return model.IsItemRelevant(item); })).ToArray());
     }
 }
Exemplo n.º 9
0
 public Optimizer.SuffixItem[] GetRelevantSuffixItems(CalculationsBase model, Character character, bool ignoreFilters = false)//CharacterRace race)
 {
     if (cachedRelevantSuffixItems == null || model != lastModel || character.Race != lastRace)
     {
         lock (syncLock)
         {
             // test again because of race conditions, but we still want to avoid the lock if we can because that'll be the majority case
             if (cachedRelevantSuffixItems == null || model != lastModel || character.Race != lastRace)
             {
                 CacheRelevantItems(model, character, ignoreFilters);
             }
         }
     }
     return(cachedRelevantSuffixItems);
 }
Exemplo n.º 10
0
        internal Item[] GetRelevantItemsInternal(CalculationsBase model, Character character, bool ignoreFilters = false)
        {
            List <Item> itemList = new List <Item>(AllItems).FindAll(new Predicate <Item>(
                                                                         delegate(Item item) {
                return(model.IsItemRelevant(item) &&  // Model Relevance
                       (ignoreFilters || ItemFilter.IsItemRelevant(model, item)) &&  // Filters Relevance
                       (character == null || item.FitsFaction(character.Race)) &&  // Faction Relevance
                       (character == null || character.ItemMatchesiLvlCheck(item)) &&   // iLvl check from UI Filter (non-tree)
                       (character == null || character.ItemMatchesBindCheck(item)) &&   // Bind check from UI Filter (non-tree)
                       (character == null || character.ItemMatchesProfCheck(item)) &&   // Prof check from UI Filter (non-tree)
                       (character == null || character.ItemMatchesDropCheck(item)));    // Drop check from UI Filter (non-tree)
            }));

            return(itemList.ToArray());
        }
Exemplo n.º 11
0
 public static bool IsItemRelevant(CalculationsBase model, Item item)
 {
     if (GetRelevantItemTypesList(model).Contains(item.Type))
     {
         bool added        = false;
         bool anyMatch     = false;
         bool enabledMatch = false;
         foreach (ItemFilterRegex regex in data.RegexList)
         {
             if (regex.AdditiveFilter && regex.AppliesTo(item) && regex.IsMatch(item))
             {
                 anyMatch = true;
                 if (regex.IsEnabled(item))
                 {
                     enabledMatch = true;
                     break;
                 }
             }
         }
         if (anyMatch)
         {
             added = enabledMatch;
         }
         else
         {
             added = OtherEnabled;
         }
         if (added)
         {
             foreach (ItemFilterRegex regex in data.RegexList)
             {
                 if (!regex.AdditiveFilter && regex.Enabled.GetValueOrDefault(true) && regex.AppliesTo(item) && regex.IsMatch(item) && regex.IsEnabled(item))
                 {
                     return(false);
                 }
             }
             return(true);
         }
     }
     return(false);
 }
Exemplo n.º 12
0
        private void CacheRelevantItems(CalculationsBase model, Character character, bool ignoreFilters = false)
        {
            List <Item> itemList = new List <Item>(AllItems).FindAll(new Predicate <Item>(
                                                                         delegate(Item item)
            {
                return(model.IsItemRelevant(item) &&  // Model Relevance
                       item.FitsFaction(character.Race) &&  // Faction Relevance
                       (ignoreFilters || ItemFilter.IsItemRelevant(model, item)) &&  // Filters Relevance
                       character.ItemMatchesiLvlCheck(item) &&   // iLvl check from UI Filter (non-tree)
                       character.ItemMatchesBindCheck(item) &&   // Bind check from UI Filter (non-tree)
                       character.ItemMatchesProfCheck(item) &&   // Prof check from UI Filter (non-tree)
                       character.ItemMatchesDropCheck(item));    // Drop check from UI Filter (non-tree)
            }));

            cachedRelevantItems = itemList.ToArray();
            List <Optimizer.SuffixItem> suffixItemList = new List <Optimizer.SuffixItem>();

            foreach (var item in cachedRelevantItems)
            {
                if (item.AllowedRandomSuffixes == null || item.AllowedRandomSuffixes.Count == 0)
                {
                    suffixItemList.Add(new Optimizer.SuffixItem()
                    {
                        Item = item, RandomSuffixId = 0
                    });
                }
                else
                {
                    foreach (var suffix in item.AllowedRandomSuffixes)
                    {
                        suffixItemList.Add(new Optimizer.SuffixItem()
                        {
                            Item = item, RandomSuffixId = suffix
                        });
                    }
                }
            }
            cachedRelevantSuffixItems = suffixItemList.ToArray();
            lastModel = model;
            lastRace  = character.Race;
        }
Exemplo n.º 13
0
        private static string getPawnWeightFilter(Character character)
        {
            StringBuilder wtf = new StringBuilder();

            ComparisonCalculationBase[] statValues = CalculationsBase.GetRelativeStatValues(character);
            foreach (ComparisonCalculationBase ccb in statValues)
            {
                string stat = getPawnStatID(ccb.Name);
                if (!stat.Equals(string.Empty))
                {
                    wtf.Append(stat + "=" + ccb.OverallPoints.ToString("F2", System.Globalization.CultureInfo.InvariantCulture) + ", ");
                }
            }
            if (wtf.Length == 0)
            {
                return(string.Empty);
            }
            else
            {
                return(wtf.ToString().Substring(0, wtf.Length - 2)); // remove trailing comma
            }
        }
Exemplo n.º 14
0
 public Item[] GetRelevantItems(CalculationsBase model, CharacterRace race)
 {
     if (cachedRelevantItems == null || model != lastModel || race != lastRace)
     {
         lock (syncLock)
         {
             // test again because of race conditions, but we still want to avoid the lock if we can because that'll be the majority case
             if (cachedRelevantItems == null || model != lastModel || race != lastRace)
             {
                 List <Item> itemList = new List <Item>(AllItems).FindAll(new Predicate <Item>(
                                                                              delegate(Item item)
                 {
                     return(model.IsItemRelevant(item) && ItemFilter.IsItemRelevant(model, item) && item.FitsFaction(race));
                 }));
                 cachedRelevantItems = itemList.ToArray();
                 lastModel           = model;
                 lastRace            = race;
             }
         }
     }
     return(cachedRelevantItems);
 }
Exemplo n.º 15
0
 private void CacheRelevantItems(CalculationsBase model, Character character, bool ignoreFilters = false)
 {
     List<Item> itemList = new List<Item>(AllItems).FindAll(new Predicate<Item>(
         delegate(Item item)
         {
             return model.IsItemRelevant(item) // Model Relevance
                 && item.FitsFaction(character.Race) // Faction Relevance
                 && (ignoreFilters || ItemFilter.IsItemRelevant(model, item)) // Filters Relevance
                 && character.ItemMatchesiLvlCheck(item)  // iLvl check from UI Filter (non-tree)
                 && character.ItemMatchesBindCheck(item)  // Bind check from UI Filter (non-tree)
                 && character.ItemMatchesProfCheck(item)  // Prof check from UI Filter (non-tree)
                 && character.ItemMatchesDropCheck(item); // Drop check from UI Filter (non-tree)
         }));
     cachedRelevantItems = itemList.ToArray();
     List<Optimizer.SuffixItem> suffixItemList = new List<Optimizer.SuffixItem>();
     foreach (var item in cachedRelevantItems)
     {
         if (item.AllowedRandomSuffixes == null || item.AllowedRandomSuffixes.Count == 0)
         {
             suffixItemList.Add(new Optimizer.SuffixItem() { Item = item, RandomSuffixId = 0 });
         }
         else
         {
             foreach (var suffix in item.AllowedRandomSuffixes)
             {
                 suffixItemList.Add(new Optimizer.SuffixItem() { Item = item, RandomSuffixId = suffix });
             }
         }
     }
     cachedRelevantSuffixItems = suffixItemList.ToArray();
     lastModel = model;
     lastRace = character.Race;
 }
Exemplo n.º 16
0
 public static Item[] GetRelevantItems(CalculationsBase model, Character character, bool ignoreFilters = false)
 {
     return(_instance.GetRelevantItems(model, character, ignoreFilters));
 }
Exemplo n.º 17
0
 private void CreateBatchItemGenerator()
 {
     bool _overrideRegem = OverrideRegem;
     bool _overrideReenchant = OverrideReenchant;
     bool _overrideReforge = OverrideReforge;
     Character[] characterList = new Character[BatchCharacterList.Count];
     CalculationsBase[] modelList = new CalculationsBase[BatchCharacterList.Count];
     for (int i = 0; i < BatchCharacterList.Count; i++)
     {
         characterList[i] = BatchCharacterList[i].Character;
         modelList[i] = BatchCharacterList[i].Model;
     }
     itemGenerator = new AvailableItemGenerator(BatchCharacterList[0].Character.AvailableItems, optimizer.GreedyOptimizationMethod != GreedyOptimizationMethod.AllCombinations, TemplateGemsEnabled, _overrideRegem, _overrideReenchant, _overrideReforge, false, characterList, modelList);
     // link items to availability info
     for (int i = 0; i < BatchCharacterList.Count; i++)
     {
         for (int slot = 0; slot < Character.OptimizableSlotCount; slot++)
         {
             var item = BatchCharacterList[i].Character._item[slot];
             if (item != null)
             {
                 item.ItemAvailabilityInformation = null;
             }
         }
     }
     for (int i = 0; i < BatchCharacterList.Count; i++)
     {
         for (int slot = 0; slot < Character.OptimizableSlotCount; slot++)
         {
             if (slot != (int)CharacterSlot.OffHand || BatchCharacterList[i].Character.CurrentCalculations.IncludeOffHandInCalculations(BatchCharacterList[i].Character))
             {
                 var item = BatchCharacterList[i].Character._item[slot];
                 if (item != null && item.ItemAvailabilityInformation == null)
                 {
                     // find a matching item availability info and assign, prefer blue diamonds
                     // make sure we don't reuse the same item twice on the same character
                     if (item.Item.AvailabilityInformation != null)
                     {
                         foreach (var iai in item.Item.AvailabilityInformation)
                         {
                             if (iai.ItemAvailable.ContainsKey(item.GemmedId))
                             {
                                 bool valid = true;
                                 for (int slot2 = 0; slot2 < Character.OptimizableSlotCount; slot2++)
                                 {
                                     if (slot2 != (int)CharacterSlot.OffHand || BatchCharacterList[i].Character.CurrentCalculations.IncludeOffHandInCalculations(BatchCharacterList[i].Character))
                                     {
                                         var item2 = BatchCharacterList[i].Character._item[slot2];
                                         if (item2 != null && item2.ItemAvailabilityInformation == iai)
                                         {
                                             valid = false;
                                             break;
                                         }
                                     }
                                 }
                                 if (valid && item.ItemAvailabilityInformation == null || iai.ItemList.Count == 1)
                                 {
                                     item.ItemAvailabilityInformation = iai;
                                 }
                             }
                         }
                     }
                     // reuse the same iai for exact matches in subsequent characters, max one per character
                     for (int j = i + 1; j < BatchCharacterList.Count; j++)
                     {
                         for (int slot2 = 0; slot2 < Character.OptimizableSlotCount; slot2++)
                         {
                             if (slot2 != (int)CharacterSlot.OffHand || BatchCharacterList[j].Character.CurrentCalculations.IncludeOffHandInCalculations(BatchCharacterList[j].Character))
                             {
                                 var item2 = BatchCharacterList[j].Character._item[slot2];
                                 if (item2 != null && item2 == item)
                                 {
                                     item2.ItemAvailabilityInformation = item.ItemAvailabilityInformation;
                                     break;
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
     // create item restrictions for locked characters
     for (int i = 0; i < BatchCharacterList.Count; i++)
     {
         if (BatchCharacterList[i].Locked)
         {
             itemGenerator.AddItemRestrictions(BatchCharacterList[i].Character);
         }
     }
 }
Exemplo n.º 18
0
 public static Optimizer.SuffixItem[] GetRelevantSuffixItems(CalculationsBase model, Character character)
 {
     return(_instance.GetRelevantSuffixItems(model, character));
 }
Exemplo n.º 19
0
 public static List<GemmingTemplate> GetModelTemplates(CalculationsBase model)
 {
     List<GemmingTemplate> list;
     if (!AllTemplates.TryGetValue(model.Name, out list))
     {
         list = new List<GemmingTemplate>(model.DefaultGemmingTemplates);
         AllTemplates[model.Name] = list;
     }
     return list;
 }
Exemplo n.º 20
0
 public static List <Tinkering> FindTinkerings(ItemSlot slot, Character character, CalculationsBase model)
 {
     //List<ItemSlot> validSlots = new List<ItemSlot>();
     //if (slot != ItemSlot.MainHand)
     //    validSlots.Add(slot);
     //if (slot == ItemSlot.OffHand || slot == ItemSlot.MainHand || slot == ItemSlot.TwoHand)
     //    validSlots.Add(ItemSlot.OneHand);
     //if (slot == ItemSlot.MainHand)
     //    validSlots.Add(ItemSlot.TwoHand);
     return(AllTinkerings.FindAll(new Predicate <Tinkering>(
                                      delegate(Tinkering Tinkering)
     {
         return Tinkering.Slot == ItemSlot.None ||
         model.IsTinkeringRelevant(Tinkering, character) &&
         (slot == ItemSlot.None || Tinkering.FitsInSlot(slot, character));
     }
                                      )));
 }
Exemplo n.º 21
0
 public static Item[] GetRelevantItems(CalculationsBase model, Character character, bool ignoreFilters = false) { return _instance.GetRelevantItems(model, character, ignoreFilters); }
Exemplo n.º 22
0
 internal Item[] GetRelevantItemsInternal(CalculationsBase model, Character character, bool ignoreFilters = false)
 {
     List<Item> itemList = new List<Item>(AllItems).FindAll(new Predicate<Item>(
         delegate(Item item) {
             return model.IsItemRelevant(item) // Model Relevance
                 && (ignoreFilters || ItemFilter.IsItemRelevant(model, item)) // Filters Relevance
                 && (character == null || item.FitsFaction(character.Race)) // Faction Relevance
                 && (character == null || character.ItemMatchesiLvlCheck(item))  // iLvl check from UI Filter (non-tree)
                 && (character == null || character.ItemMatchesBindCheck(item))  // Bind check from UI Filter (non-tree)
                 && (character == null || character.ItemMatchesProfCheck(item))  // Prof check from UI Filter (non-tree)
                 && (character == null || character.ItemMatchesDropCheck(item)); // Drop check from UI Filter (non-tree)
         }));
     return itemList.ToArray();
 }
Exemplo n.º 23
0
 public static List <Tinkering> FindTinkerings(ItemSlot slot, Character character, List <string> availableIds, CalculationsBase model)
 {
     return(AllTinkerings.FindAll(new Predicate <Tinkering>(
                                      delegate(Tinkering Tinkering)
     {
         return Tinkering.Id == 0 ||
         ((Tinkering.Slot == ItemSlot.None ||
           model.IsTinkeringRelevant(Tinkering, character) && (slot == ItemSlot.None || Tinkering.FitsInSlot(slot, character))) &&
          availableIds.Contains((-1 * (Tinkering.Id + ((int)AvailableItemIDModifiers.Tinkerings * (int)Tinkering.Slot))).ToString()));
     }
                                      )));
 }
Exemplo n.º 24
0
 public static Item[] GetRelevantItems(CalculationsBase model, CharacterRace race)
 {
     return(_instance.GetRelevantItems(model, race));
 }
Exemplo n.º 25
0
 public Item[] GetUnfilteredRelevantItems(CalculationsBase model, CharacterRace race)
 {
     List<Item> itemList = new List<Item>(AllItems).FindAll(new Predicate<Item>(
         delegate(Item item) 
         { 
             return model.IsItemRelevant(item) && item.FitsFaction(race); 
         }));
     return itemList.ToArray();
 }
Exemplo n.º 26
0
        public static List <Enchant> FindEnchants(Item.ItemSlot slot, List <string> availableIds, CalculationsBase model)
        {
            List <Item.ItemSlot> validSlots = new List <Item.ItemSlot>();

            if (slot != Item.ItemSlot.MainHand)
            {
                validSlots.Add(slot);
            }
            if (slot == Item.ItemSlot.OffHand || slot == Item.ItemSlot.MainHand)
            {
                validSlots.Add(Item.ItemSlot.OneHand);
            }
            if (slot == Item.ItemSlot.MainHand)
            {
                validSlots.Add(Item.ItemSlot.TwoHand);
            }
            return(AllEnchants.FindAll(new Predicate <Enchant>(
                                           delegate(Enchant enchant)
            {
                return ((model.HasRelevantStats(enchant.Stats) &&
                         (validSlots.Contains(enchant.Slot) || slot == Item.ItemSlot.None) || enchant.Slot == Item.ItemSlot.None) &&
                        availableIds.Contains((-1 * (enchant.Id + (10000 * (int)enchant.Slot))).ToString())) ||
                enchant.Id == 0;
            }
                                           )));
        }
Exemplo n.º 27
0
 public Optimizer.SuffixItem[] GetRelevantSuffixItems(CalculationsBase model, Character character, bool ignoreFilters = false)//CharacterRace race)
 {
     if (cachedRelevantSuffixItems == null || model != lastModel || character.Race != lastRace)
     {
         lock (syncLock)
         {
             // test again because of race conditions, but we still want to avoid the lock if we can because that'll be the majority case
             if (cachedRelevantSuffixItems == null || model != lastModel || character.Race != lastRace)
             {
                 CacheRelevantItems(model, character, ignoreFilters);
             }
         }
     }
     return cachedRelevantSuffixItems;
 }
Exemplo n.º 28
0
        public void UpdateScalingGraph(Character character, Stats[] statsList, Stats baseStat, bool requiresReferenceCalculations, Color[] colors, int scale, string explanatoryText, string calculation)
        {
            CharacterCalculationsBase baseCalc = Calculations.GetCharacterCalculations(character);

            if (statsList.Length == 0 || statsList.Length > colors.Length)
            {
                return;                                                            // more than 12 elements for the array would run out of colours
            }
            Point[][] points = new Point[statsList.Length][];
            // extract property data for relative stats calculations
            KeyValuePair <PropertyInfo, float>[] properties = new KeyValuePair <PropertyInfo, float> [statsList.Length];
            for (int index = 0; index < statsList.Length; index++)
            {
                var p = statsList[index].Values(x => x > 0);
                foreach (var kvp in p)
                {
                    properties[index] = kvp;
                }
                points[index] = new Point[2 * scale + 1];
            }
            float unit = 1f;
            var   bp   = baseStat.Values(x => x > 0);

            foreach (var kvp in bp)
            {
                unit = kvp.Value;
            }
            Chart.Series.Clear();
            for (int count = -scale; count <= scale; count++)
            {
                Stats newStats = new Stats();
                newStats.Accumulate(baseStat, count);
                Item item = new Item()
                {
                    Stats = newStats
                };
                if (requiresReferenceCalculations)
                {
                    Calculations.GetCharacterCalculations(character, item, true, false, false);
                }
                for (int index = 0; index < statsList.Length; index++)
                {
                    ComparisonCalculationBase currentCalc = CalculationsBase.GetRelativeStatValue(character, properties[index].Key, item, properties[index].Value);
                    float dpsChange = GetCalculationValue(currentCalc, calculation);
                    points[index][count + scale] = new Point(count * unit, dpsChange);
                }
            }
            for (int index = 0; index < statsList.Length; index++)
            {
                Style dataPointStyle = new Style(typeof(LineDataPoint));
                dataPointStyle.Setters.Add(new Setter(DataPoint.TemplateProperty, Resources["InvisibleDataPointTemplate"]));
                dataPointStyle.Setters.Add(new Setter(DataPoint.BackgroundProperty, new SolidColorBrush(colors[index])));
                Chart.Series.Add(new LineSeries()
                {
                    Title                = statsList[index].ToString(),
                    ItemsSource          = points[index],
                    IndependentValuePath = "X",
                    DependentValuePath   = "Y",
                    DataPointStyle       = dataPointStyle,
                });
            }
            Chart.Axes.Clear();
            Chart.Axes.Add(new LinearAxis()
            {
                Orientation   = AxisOrientation.X,
                Title         = "Stat Change",
                ShowGridLines = true,
            });
            Chart.Axes.Add(new LinearAxis()
            {
                Orientation   = AxisOrientation.Y,
                Title         = calculation,
                ShowGridLines = true,
            });
            // restore reference calculation
            if (requiresReferenceCalculations)
            {
                Stats newStats = new Stats();
                Item  item     = new Item()
                {
                    Stats = newStats
                };
                Calculations.GetCharacterCalculations(character, item, true, false, false);
            }
            orgDataDirty = true;
        }
Exemplo n.º 29
0
 public static Item[] GetUnfilteredRelevantItems(CalculationsBase model, CharacterRace race) { return _instance.GetUnfilteredRelevantItems(model, race); }
Exemplo n.º 30
0
 public static void LoadModel(CalculationsBase model)
 {
     if (Instance != model)
     {
         OnModelChanging();
         Instance = model;
         OnModelChanged();
     }
 }
Exemplo n.º 31
0
 public static Optimizer.SuffixItem[] GetRelevantSuffixItems(CalculationsBase model, Character character) { return _instance.GetRelevantSuffixItems(model, character); }
Exemplo n.º 32
0
 public static void LoadModel(CalculationsBase model)
 {
     OnModelChanging();
     Instance = model;
     OnModelChanged();
 }