implementation of new 3.16 conditions

- BaseDefencePercentile
- BaseArmour
- BaseEnergyShield
- BaseEvasion
- BaseWard
- Scourged
- UberBlightedMap

- added new test for these conditions
- no changes in lang/item and lang/item_filter (GUI stuff)

doc/user/how_filters_work.md

@@ -95,6 +95,11 @@ MapTier               [CMP] Integer+
 AreaLevel             [CMP] Integer+
 CorruptedMods         [CMP] Integer+
 EnchantmentPassiveNum [CMP] Integer+
+BaseDefencePercentile [CMP] Integer+
+BaseArmour            [CMP] Integer+
+BaseEvasion           [CMP] Integer+
+BaseEnergyShield      [CMP] Integer+
+BaseWard              [CMP] Integer+
 
 Class                  [EQ] String+
 BaseType               [EQ] String+
@@ -123,6 +128,8 @@ ElderMap         Boolean
 BlightedMap      Boolean
 Replica          Boolean
 AlternateQuality Boolean
+Scourged         Boolean
+UberBlightedMap  Boolean
 ```
 
 Note: numeric and `Rarity` conditions can accept multiple values, but there is no practicaly point in doing so. You can cover any range with 2 lines using different comparisons, which is much better than manually specifying all possible values in 1 line. Additionally, current FS implementation does not support this and will error on more than 1 value (this is true both for real filters and filter templates).

src/lib/fs/compiler/detail/conditions.cpp

@@ -139,6 +139,21 @@ add_numeric_comparison_condition(
 		case lang::numeric_comparison_condition_property::enchantment_passive_num: {
 			return add_range_condition(cmp, intgr, condition_origin, set.enchantment_passive_num, diagnostics);
 		}
+		case lang::numeric_comparison_condition_property::base_defence_percentile: {
+			return add_range_condition(cmp, intgr, condition_origin, set.base_defence_percentile, diagnostics);
+		}
+		case lang::numeric_comparison_condition_property::base_armour: {
+			return add_range_condition(cmp, intgr, condition_origin, set.base_armour, diagnostics);
+		}
+		case lang::numeric_comparison_condition_property::base_evasion: {
+			return add_range_condition(cmp, intgr, condition_origin, set.base_evasion, diagnostics);
+		}
+		case lang::numeric_comparison_condition_property::base_energy_shield: {
+			return add_range_condition(cmp, intgr, condition_origin, set.base_energy_shield, diagnostics);
+		}
+		case lang::numeric_comparison_condition_property::base_ward: {
+			return add_range_condition(cmp, intgr, condition_origin, set.base_ward, diagnostics);
+		}
 	}
 
 	push_error_internal_compiler_error(__func__, condition_origin, diagnostics);
@@ -462,6 +477,18 @@ add_boolean_condition(
 				condition_set.is_alternate_quality,
 				diagnostics);
 		}
+		case lang::boolean_condition_property::scourged: {
+			return add_non_range_condition(
+				lang::boolean_condition{boolean, condition_origin},
+				condition_set.is_scourged,
+				diagnostics);
+		}
+		case lang::boolean_condition_property::uber_blighted_map: {
+			return add_non_range_condition(
+				lang::boolean_condition{boolean, condition_origin},
+				condition_set.is_uber_blighted_map,
+				diagnostics);
+		}
 	}
 
 	push_error_internal_compiler_error(__func__, condition_origin, diagnostics);

src/lib/fs/lang/condition_properties.hpp

@@ -28,7 +28,12 @@ enum class numeric_comparison_condition_property
 	map_tier,
 	area_level,
 	corrupted_mods,
-	enchantment_passive_num
+	enchantment_passive_num,
+	base_defence_percentile,
+	base_armour,
+	base_evasion,
+	base_energy_shield,
+	base_ward
 };
 
 // conditions which work with array of strings
@@ -63,7 +68,9 @@ enum class boolean_condition_property
 	elder_map,
 	blighted_map,
 	replica,
-	alternate_quality
+	alternate_quality,
+	scourged,
+	uber_blighted_map
 };
 
 } // namespace fs::lang

src/lib/fs/lang/condition_set.cpp

@@ -325,6 +325,11 @@ void condition_set::generate(std::ostream& output_stream) const
 	output_range_condition(area_level,     kw::area_level,     output_stream);
 	output_range_condition(corrupted_mods, kw::corrupted_mods, output_stream);
 	output_range_condition(enchantment_passive_num, kw::enchantment_passive_num, output_stream);
+	output_range_condition(base_defence_percentile, kw::base_defence_percentile, output_stream);
+	output_range_condition(base_armour,    kw::base_armour,    output_stream);
+	output_range_condition(base_evasion,   kw::base_evasion,   output_stream);
+	output_range_condition(base_energy_shield, kw::base_energy_shield, output_stream);
+	output_range_condition(base_ward,      kw::base_ward,      output_stream);
 
 	output_gem_quality_type_condition(gem_quality_type, output_stream);
 
@@ -344,6 +349,8 @@ void condition_set::generate(std::ostream& output_stream) const
 	output_boolean_condition(is_blighted_map,      kw::blighted_map,      output_stream);
 	output_boolean_condition(is_replica,           kw::replica,           output_stream);
 	output_boolean_condition(is_alternate_quality, kw::alternate_quality, output_stream);
+	output_boolean_condition(is_scourged,          kw::scourged,          output_stream);
+	output_boolean_condition(is_uber_blighted_map, kw::uber_blighted_map, output_stream);
 
 	output_strings_condition(class_,                   kw::class_,                   output_stream);
 	output_strings_condition(base_type,                kw::base_type,                output_stream);
@@ -359,12 +366,9 @@ void condition_set::generate(std::ostream& output_stream) const
 bool condition_set::is_valid() const
 {
 	const auto is_valid_strings = [](const std::vector<lang::string>& strings) {
-		// empty list of allowed values: there are no items that can match this block
-		// game client will not accept an empty list so return that the block is invalid
-		if (strings.empty())
-			return false;
-
-		return true;
+		// list of allowed values must be non-empty to be accepted by in-game filter
+		// otherwise the empty condition would not make sense
+		return !strings.empty();
 	};
 	const auto is_valid_strings_condition = [&](const std::optional<strings_condition>& condition) {
 		// no condition: ok, we just don't require item to have this property

src/lib/fs/lang/condition_set.hpp

@@ -243,6 +243,11 @@ struct condition_set
 	integer_range_condition area_level;
 	integer_range_condition corrupted_mods;
 	integer_range_condition enchantment_passive_num;
+	integer_range_condition base_defence_percentile;
+	integer_range_condition base_armour;
+	integer_range_condition base_evasion;
+	integer_range_condition base_energy_shield;
+	integer_range_condition base_ward;
 	std::optional<boolean_condition> is_identified;
 	std::optional<boolean_condition> is_corrupted;
 	std::optional<boolean_condition> is_mirrored;
@@ -256,6 +261,8 @@ struct condition_set
 	std::optional<boolean_condition> is_blighted_map;
 	std::optional<boolean_condition> is_replica;
 	std::optional<boolean_condition> is_alternate_quality;
+	std::optional<boolean_condition> is_scourged;
+	std::optional<boolean_condition> is_uber_blighted_map;
 };
 
 class condition_match_result
@@ -340,6 +347,11 @@ struct condition_set_match_result
 			&& is_not_failure_range(area_level)
 			&& is_not_failure_range(corrupted_mods)
 			&& is_not_failure_range(enchantment_passive_num)
+			&& is_not_failure_range(base_defence_percentile)
+			&& is_not_failure_range(base_armour)
+			&& is_not_failure_range(base_evasion)
+			&& is_not_failure_range(base_energy_shield)
+			&& is_not_failure_range(base_ward)
 			&& is_not_failure(class_)
 			&& is_not_failure(base_type)
 			&& is_not_failure(sockets)
@@ -362,7 +374,9 @@ struct condition_set_match_result
 			&& is_not_failure(is_elder_map)
 			&& is_not_failure(is_blighted_map)
 			&& is_not_failure(is_replica)
-			&& is_not_failure(is_alternate_quality);
+			&& is_not_failure(is_alternate_quality)
+			&& is_not_failure(is_scourged)
+			&& is_not_failure(is_uber_blighted_map);
 	}
 
 	range_condition_match_result item_level;
@@ -378,6 +392,11 @@ struct condition_set_match_result
 	range_condition_match_result area_level;
 	range_condition_match_result corrupted_mods;
 	range_condition_match_result enchantment_passive_num;
+	range_condition_match_result base_defence_percentile;
+	range_condition_match_result base_armour;
+	range_condition_match_result base_evasion;
+	range_condition_match_result base_energy_shield;
+	range_condition_match_result base_ward;
 	std::optional<condition_match_result> class_;
 	std::optional<condition_match_result> base_type;
 	std::optional<condition_match_result> sockets;
@@ -401,6 +420,8 @@ struct condition_set_match_result
 	std::optional<condition_match_result> is_blighted_map;
 	std::optional<condition_match_result> is_replica;
 	std::optional<condition_match_result> is_alternate_quality;
+	std::optional<condition_match_result> is_scourged;
+	std::optional<condition_match_result> is_uber_blighted_map;
 };
 
 struct autogen_condition

src/lib/fs/lang/keywords.hpp

@@ -59,6 +59,13 @@ namespace rf
 	constexpr auto replica          = "Replica";
 	constexpr auto alternate_quality = "AlternateQuality";
 	constexpr auto gem_quality_type = "GemQualityType";
+	constexpr auto base_defence_percentile = "BaseDefencePercentile";
+	constexpr auto base_armour      = "BaseArmour";
+	constexpr auto base_evasion     = "BaseEvasion";
+	constexpr auto base_energy_shield = "BaseEnergyShield";
+	constexpr auto base_ward        = "BaseWard";
+	constexpr auto scourged         = "Scourged";
+	constexpr auto uber_blighted_map = "UberBlightedMap";
 
 	constexpr auto r = 'R';
 	constexpr auto g = 'G';

src/lib/fs/parser/detail/symbols.hpp

@@ -156,6 +156,11 @@ namespace rf
 				(lang::keywords::rf::area_level,     lang::numeric_comparison_condition_property::area_level)
 				(lang::keywords::rf::corrupted_mods, lang::numeric_comparison_condition_property::corrupted_mods)
 				(lang::keywords::rf::enchantment_passive_num, lang::numeric_comparison_condition_property::enchantment_passive_num)
+				(lang::keywords::rf::base_defence_percentile, lang::numeric_comparison_condition_property::base_defence_percentile)
+				(lang::keywords::rf::base_armour,    lang::numeric_comparison_condition_property::base_armour)
+				(lang::keywords::rf::base_evasion,   lang::numeric_comparison_condition_property::base_evasion)
+				(lang::keywords::rf::base_energy_shield, lang::numeric_comparison_condition_property::base_energy_shield)
+				(lang::keywords::rf::base_ward,      lang::numeric_comparison_condition_property::base_ward)
 			;
 		}
 	};
@@ -217,6 +222,8 @@ namespace rf
 				(lang::keywords::rf::blighted_map,      lang::boolean_condition_property::blighted_map)
 				(lang::keywords::rf::replica,           lang::boolean_condition_property::replica)
 				(lang::keywords::rf::alternate_quality, lang::boolean_condition_property::alternate_quality)
+				(lang::keywords::rf::scourged,          lang::boolean_condition_property::scourged)
+				(lang::keywords::rf::uber_blighted_map, lang::boolean_condition_property::uber_blighted_map)
 			;
 		}
 	};

src/test/compiler/filter_generation_tests.cpp

@@ -1397,6 +1397,44 @@ Show
 Show
 	HasExplicitMod >=2 "of Haast" "of Tzteosh" "of Ephij"
 
+)";
+
+			BOOST_TEST(compare_strings(expected_filter, actual_filter));
+		}
+
+		BOOST_AUTO_TEST_CASE(scourge_new_conditions)
+		{
+			const std::string actual_filter = generate_filter(minimal_input() + R"(
+BaseDefencePercentile >= 90 { Show }
+BaseArmour            > 500 { Show }
+BaseEvasion           > 500 { Show }
+BaseEnergyShield      > 200 { Show }
+BaseWard              >  50 { Show }
+Scourged               True { Show }
+UberBlightedMap        True { Show }
+)");
+			const std::string_view expected_filter =
+R"(Show
+	BaseDefencePercentile >= 90
+
+Show
+	BaseArmour > 500
+
+Show
+	BaseEvasion > 500
+
+Show
+	BaseEnergyShield > 200
+
+Show
+	BaseWard > 50
+
+Show
+	Scourged True
+
+Show
+	UberBlightedMap True
+
 )";
 
 			BOOST_TEST(compare_strings(expected_filter, actual_filter));