public static FilterEconomyRuleSet Generate(ConcreteEconomyRules ruleHost)
        {
            var builder = new RuleSetBuilder(ruleHost)
                          .SetSection("currency")
                          // .SkipInEarlyLeague()
                          // .LimitExecutionMode(ExecutionMode.Function)
                          .UseDefaultQuery()
                          .OverrideMinimalExaltedPriceThreshhold(40)
                          .AddDefaultPostProcessing()
                          .AddDefaultIntegrationTarget();

            builder.AddRule("No Tiering", "???",
                            new Func <string, bool>((string s) =>
            {
                var isTierable = builder.Item.HasAspect("TierableCurrencyAspect");
                if (isTierable)
                {
                    return(false);
                }

                return(true);
            }));

            builder.AddSimpleComparisonRule("ExTier", "t11", FilterPolishConfig.ExaltedOrbPrice / 2);
            builder.AddSimpleComparisonRule("DivineTier", "t12", FilterPolishConfig.ExaltedOrbPrice / 5);
            builder.AddSimpleComparisonRule("SextantTier", "t21", 1.5f);

            // chaos level rules
            builder.AddSimpleComparisonRule("ChaosTier", "t22", 0.60f);
            builder.AddSimpleAspectContainerRule("ChaosBottom", "t22", "ChaosBottomAspect");

            // alchemy level rules
            builder.AddSimpleComparisonRule("AlchemyTier", "t23", 0.30f);
            builder.AddSimpleAspectContainerRule("AlchemyBottom", "t23", "AlchemyButtomAspect");
            builder.AddEarlyLeagueHandling("t23");

            builder.AddSimpleComparisonRule("SilverAltTier", "t31", 0.16f);
            builder.AddSimpleAspectContainerRule("AlchemyBottom", "t23", "SilverBottomAspect");

            builder.AddSimpleComparisonRule("ChanceTier", "t32", 0.06f);
            builder.AddSimpleAspectContainerRule("ChanceBottom", "t32", "ChanceBottomAspect");

            builder.AddExplicitRest("TransmuteTier", "t33");

            return(builder.Build());
        }
        public static FilterEconomyRuleSet Generate(ConcreteEconomyRules ruleHost)
        {
            var builder = new RuleSetBuilder(ruleHost)
                          .SetSection("fragments")
                          .UseDefaultQuery()
                          .OverrideMinimalExaltedPriceThreshhold(40)
                          .AddDefaultPostProcessing()
                          .SkipInEarlyLeague()
                          .AddDefaultIntegrationTarget();

            builder.AddRule("No Tiering", "???",
                            new Func <string, bool>((string s) =>
            {
                var isTierable = builder.Item.HasAspect("TierableFragmentAspect");
                if (isTierable)
                {
                    return(false);
                }

                return(true);
            }));

            builder.AddRule("t1", "t1",
                            new Func <string, bool>((string s) =>
            {
                var isPredictable = builder.Item.HasAspect("PredictableDropAspect");

                if (isPredictable)
                {
                    return(false);
                }

                var price = builder.Item.LowestPrice;
                return(price > FilterPolishConfig.MiscT1BreakPoint * 1.25f);
            }));

            builder.AddRule("t1 predictable", "t1p",
                            new Func <string, bool>((string s) =>
            {
                var isPredictable = builder.Item.HasAspect("PredictableDropAspect");
                var price         = builder.Item.LowestPrice;

                return(isPredictable && price > FilterPolishConfig.MiscT1BreakPoint * 1.25f);
            }));

            builder.AddRule("t2", "t2",
                            new Func <string, bool>((string s) =>
            {
                var price = builder.Item.LowestPrice;
                return(price > FilterPolishConfig.MiscT2BreakPoint * 1.25f);
            }));

            builder.AddRule("t3", "t3",
                            new Func <string, bool>((string s) =>
            {
                var price = builder.Item.LowestPrice;
                return(price > FilterPolishConfig.MiscT3BreakPoint);
            }));

            builder.AddEarlyLeagueHandling("t3");

            builder.AddRule("HidingPrevented", "t3",
                            new Func <string, bool>((string s) =>
            {
                return(builder.Item.HasAspect("PreventHidingAspect"));
            }));

            builder.AddExplicitRest("t4", "t4");

            return(builder.Build());
        }
        public static FilterEconomyRuleSet Generate(ConcreteEconomyRules ruleHost)
        {
            var builder = new RuleSetBuilder(ruleHost)
                          .SetSection("uniques")
                          .UseDefaultQuery()
                          .AddDefaultPostProcessing()
                          .AddDefaultIntegrationTarget();

            //var set = builder.Rulebuilder.Item.DefaultSet;

            builder.AddRule("unknown", "unknown",
                            new Func <string, bool>((string s) =>
            {
                return(!ruleHost.EconomyInformation.EconomyTierlistOverview["uniques"].ContainsKey(s));
            }));

            builder.AddRule("t1", "t1",
                            new Func <string, bool>((string s) =>
            {
                return(builder.Item.LowestPrice > FilterPolishConfig.UniqueT1BreakPoint);
            }));

            builder.AddRule("t2", "t2",
                            new Func <string, bool>((string s) =>
            {
                return(builder.Item.LowestPrice > FilterPolishConfig.UniqueT2BreakPoint);
            }));

            // builder.AddSimpleAspectContainerRule("EARLYBuffAspect", "t2", "BuffAspect");

            // items with one expensive rare version and one common, less rare verison are handled by this rule.
            builder.AddRule("uncommon", "multispecial",
                            new Func <string, bool>((string s) =>
            {
                var fit = false;
                if (builder.Item.HighestPrice > FilterPolishConfig.UniqueT2BreakPoint)
                {
                    if (builder.Item.HasAspect("UncommonAspect"))
                    {
                        var relevantList = builder.Item.AspectCheck(new HashSet <string>()
                        {
                            "UncommonAspect"
                        }, new HashSet <string>()
                        {
                            "BossDropAspect", "NonDropAspect", "LeagueDropAspect", "NonEventDropAspect"
                        });

                        if (relevantList.Count > 0)
                        {
                            return(relevantList.OrderByDescending(x => x.CVal).First().CVal > FilterPolishConfig.UniqueT2BreakPoint * FilterPolishConfig.UncommonAspectMultiplier);
                        }
                    }
                }

                return(fit);
            }));

            // items with expensive and non-expensive commonly droppable versions.
            builder.AddRule("ExpensiveTwin", "multispecial",
                            new Func <string, bool>((string s) =>
            {
                var relevantList = builder.Item.AspectCheck(new HashSet <string>()
                {
                    "HandledAspect"
                }, new HashSet <string>()
                {
                    "UncommonAspect", "BossDropAspect", "NonDropAspect", "LeagueDropAspect", "ProphecyResultAspect", "NonEventDropAspect"
                });

                if (relevantList.Count > 1)
                {
                    if (relevantList.Max(x => x.CVal) > FilterPolishConfig.UniqueT2BreakPoint * FilterPolishConfig.CommonTwinAspectMultiplier)
                    {
                        return(true);
                    }
                }

                return(false);
            }));

            // items with expensive and non-expensive commonly droppable versions.
            builder.AddRule("Expensive-Single-NonLeagueTwin", "multispecial",
                            new Func <string, bool>((string s) =>
            {
                var relevantList = builder.Item.AspectCheck(new HashSet <string>()
                {
                    "HandledAspect"
                }, new HashSet <string>()
                {
                    "UncommonAspect", "BossDropAspect", "NonDropAspect", "LeagueDropAspect", "ProphecyResultAspect", "NonEventDropAspect"
                });

                if (relevantList.Count == 1)
                {
                    if (relevantList.Max(x => x.CVal) > FilterPolishConfig.UniqueT2BreakPoint)
                    {
                        return(true);
                    }
                }

                return(false);
            }));

            builder.AddRule("highVariety", "multispecial",
                            new Func <string, bool>((string s) =>
            {
                var fit = false;
                if (builder.Item.HighestPrice > FilterPolishConfig.UniqueT2BreakPoint * FilterPolishConfig.HighVarietyMultiplier)
                {
                    if (builder.Item.HasAspect("HighVarietyAspect"))
                    {
                        var relevantList = builder.Item.AspectCheck(new HashSet <string>(), new HashSet <string>()
                        {
                            "BossDropAspect", "NonDropAspect", "LeagueDropAspect", "NonEventDropAspect"
                        });

                        if (relevantList.Count > 0)
                        {
                            return(relevantList.OrderByDescending(x => x.CVal).First().CVal > FilterPolishConfig.UniqueT2BreakPoint * FilterPolishConfig.HighVarietyMultiplier);
                        }
                    }
                }

                return(fit);
            }));

            builder.AddRule("leagueDropAspect", "multispecial",
                            new Func <string, bool>((string s) =>
            {
                var fit = false;
                if (builder.Item.HighestPrice > FilterPolishConfig.UniqueT2BreakPoint)
                {
                    if (builder.Item.HasAspect("LeagueDropAspect"))
                    {
                        var relevantList = builder.Item.AspectCheck(new HashSet <string>()
                        {
                            "LeagueDropAspect"
                        }, new HashSet <string>()
                        {
                            "BossDropAspect", "NonDropAspect", "NonEventDropAspect"
                        });

                        if (relevantList.Count > 0)
                        {
                            return(relevantList.OrderByDescending(x => x.CVal).First().CVal > FilterPolishConfig.UniqueT2BreakPoint * FilterPolishConfig.LeagueDropAspectMultiplier);
                        }
                    }
                }

                return(fit);
            }));

            builder.AddRule("BossOnly", "multispecial",
                            new Func <string, bool>((string s) =>
            {
                var fit = false;
                if (builder.Item.HighestPrice > FilterPolishConfig.UniqueT2BreakPoint)
                {
                    var relevantList = builder.Item.AspectCheck(new HashSet <string> {
                    }, new HashSet <string>()
                    {
                        "NonDropAspect"
                    });

                    if (relevantList.Count > 0 && relevantList.AllItemsFullFill(new HashSet <string>()
                    {
                        "BossDropAspect"
                    }, new HashSet <string>()))
                    {
                        return(relevantList.OrderByDescending(x => x.CVal).First().CVal > FilterPolishConfig.UniqueT2BreakPoint * FilterPolishConfig.LeagueDropAspectMultiplier);
                    }
                }

                return(fit);
            }));

            builder.AddEarlyLeagueHandling("earlyleague");

            // extremely high value multibases that usually drop from boss encounters, but can also drop from special league events
            builder.AddRule("SuperLeagueUnique", "multispecial",
                            new Func <string, bool>((string s) =>
            {
                if (builder.Item.HighestPrice > FilterPolishConfig.UniqueT1BreakPoint)
                {
                    var relevantList = builder.Item.AspectCheck(new HashSet <string>()
                    {
                        "LeagueDropAspect"
                    }, new HashSet <string>()
                    {
                        "NonDropAspect", "NonEventDropAspect"
                    });

                    if (relevantList.Count > 0)
                    {
                        return(relevantList.OrderByDescending(x => x.CVal).First().CVal > FilterPolishConfig.SuperTierBreakPoint);
                    }
                }
                return(false);
            }));

            builder.AddRule("ExpensiveOrBoss", "t3boss",
                            new Func <string, bool>((string s) =>
            {
                var bossDrop = builder.Item.HasAspect("BossDropAspect");
                return(bossDrop || builder.Item.LowestPrice < FilterPolishConfig.UniqueT2BreakPoint && builder.Item.HighestPrice > FilterPolishConfig.UniqueT2BreakPoint);
            }));

            builder.AddRule("prophecy", "prophecy",
                            new Func <string, bool>((string s) =>
            {
                var aspects = builder.RuleHost.ItemInformation["uniques", s];
                if (aspects == null)
                {
                    return(false);
                }

                return(builder.Item.HasAspect("ProphecyMaterialAspect"));
            }));

            builder.AddSimpleAspectContainerRule("EARLYNerfAspect", "t3", "NerfAspect");
            builder.AddEarlyLeagueProtectionBlock("t2", new HashSet <string>()
            {
                "t1"
            }, "earlyProtHIGH");
            builder.AddEarlyLeagueProtectionBlock("t3", new HashSet <string>()
            {
                "t2"
            }, "earlyProtLOW");

            builder.AddRule("hideable-nondrop", "hideable2",
                            new Func <string, bool>((string s) =>
            {
                var aspectTest = builder.Item.AllItemsFullFill(new HashSet <string>()
                {
                }, new HashSet <string>()
                {
                    "HighVarietyAspect", "NonEventDropAspect", "PreventHidingAspect"
                });

                if (!aspectTest)
                {
                    return(false);
                }


                var relevantListNonDrop = builder.Item.AspectCheck(new HashSet <string>()
                {
                    "NonDropAspect"
                }, new HashSet <string>()
                {
                });
                var relevantListRest = builder.Item.AspectCheck(new HashSet <string>()
                {
                }, new HashSet <string>()
                {
                    "NonDropAspect"
                });

                if (relevantListNonDrop.Count > 0)
                {
                    if (relevantListRest.Count > 0 && relevantListRest.Max(x => x.CVal > FilterPolishConfig.UniqueT2BreakPoint * 0.5f))
                    {
                        return(false);
                    }

                    return(true);
                }

                return(false);
            }));

            builder.AddRule("hideable", "hideable",
                            new Func <string, bool>((string s) =>
            {
                var relevantList = builder.Item.AspectCheck(new HashSet <string>()
                {
                }, new HashSet <string>()
                {
                    "NonDropAspect", "PreventHidingAspect"
                });

                if (relevantList.Count == 0)
                {
                    return(false);
                }

                var maxprice = relevantList.Max(x => x.CVal);
                if (maxprice > FilterPolishConfig.UniqueT2BreakPoint * 0.35f)
                {
                    return(false);
                }

                if (builder.Item.AllItemsFullFill(new HashSet <string>()
                {
                }, new HashSet <string>()
                {
                    "HighVarietyAspect", "LeagueDropAspect", "NonEventDropAspect", "BossDropAspect", "UncommonAspect", "PreventHidingAspect"
                }))
                {
                    return(true);
                }

                return(false);
            }));

            builder.AddExplicitRest("t3", "t3");

            return(builder.Build());
        }