From 674044a76f9b9bd437f5400fbaad5808eee8b67d Mon Sep 17 00:00:00 2001 From: Yair Morgenstern Date: Mon, 30 Oct 2023 11:45:51 +0200 Subject: [PATCH] chore: General rename UniqueComplianceErrorSeverity -> UniqueErrorScope. Each error has in fact 2 determiners: What the error *severity* is (probably ok, warning, error) and what the *scope* is (error regardless of what ruleset we're in, error because of the specific ruleset) Having the warning be as part of the scope is...problematic, but that's for phase 2, this is just a rename --- core/src/com/unciv/models/ruleset/Ruleset.kt | 4 +- .../com/unciv/models/ruleset/unique/Unique.kt | 2 +- .../ruleset/unique/UniqueParameterType.kt | 158 +++++++++--------- .../unciv/models/ruleset/unique/UniqueType.kt | 20 ++- .../ruleset/validation/RulesetValidator.kt | 44 ++--- .../ruleset/validation/UniqueValidator.kt | 12 +- .../unciv/ui/popups/options/ModCheckTab.kt | 4 +- 7 files changed, 124 insertions(+), 120 deletions(-) diff --git a/core/src/com/unciv/models/ruleset/Ruleset.kt b/core/src/com/unciv/models/ruleset/Ruleset.kt index a39098b3d9..149f487e62 100644 --- a/core/src/com/unciv/models/ruleset/Ruleset.kt +++ b/core/src/com/unciv/models/ruleset/Ruleset.kt @@ -383,7 +383,7 @@ class Ruleset { Unique(it), false, cityStateType, - UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + UniqueType.UniqueErrorScope.RulesetSpecific ).isEmpty() }) allyBonusUniques = ArrayList(cityStateType.allyBonusUniques.filter { @@ -391,7 +391,7 @@ class Ruleset { Unique(it), false, cityStateType, - UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + UniqueType.UniqueErrorScope.RulesetSpecific ).isEmpty() }) } diff --git a/core/src/com/unciv/models/ruleset/unique/Unique.kt b/core/src/com/unciv/models/ruleset/unique/Unique.kt index 90ca621a4f..d624d821ad 100644 --- a/core/src/com/unciv/models/ruleset/unique/Unique.kt +++ b/core/src/com/unciv/models/ruleset/unique/Unique.kt @@ -122,7 +122,7 @@ class Unique(val text: String, val sourceObjectType: UniqueTarget? = null, val s val unique = Unique(it) val errors = UniqueValidator(ruleset).checkUnique( unique, true, null, - UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + UniqueType.UniqueErrorScope.RulesetSpecific ) errors.isEmpty() } diff --git a/core/src/com/unciv/models/ruleset/unique/UniqueParameterType.kt b/core/src/com/unciv/models/ruleset/unique/UniqueParameterType.kt index d425322880..2cbde9e8f7 100644 --- a/core/src/com/unciv/models/ruleset/unique/UniqueParameterType.kt +++ b/core/src/com/unciv/models/ruleset/unique/UniqueParameterType.kt @@ -41,16 +41,16 @@ enum class UniqueParameterType( Number("amount", "3", "This indicates a whole number, possibly with a + or - sign, such as `2`, `+13`, or `-3`") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { - return if (parameterText.toIntOrNull() == null) UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + UniqueType.UniqueErrorScope? { + return if (parameterText.toIntOrNull() == null) UniqueType.UniqueErrorScope.RulesetInvariant else null } }, RelativeNumber("relativeAmount", "+20", "This indicates a number, usually with a + or - sign, such as `+25` (this kind of parameter is often followed by '%' which is nevertheless not part of the value)") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { - return if (parameterText.toIntOrNull() == null) UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + UniqueType.UniqueErrorScope? { + return if (parameterText.toIntOrNull() == null) UniqueType.UniqueErrorScope.RulesetInvariant else null } }, @@ -58,13 +58,13 @@ enum class UniqueParameterType( // todo potentially remove if OneTimeRevealSpecificMapTiles changes KeywordAll("'all'", "All") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset) = - if (parameterText == "All") null else UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + if (parameterText == "All") null else UniqueType.UniqueErrorScope.RulesetInvariant }, /** Implemented by [ICombatant.matchesCategory][com.unciv.logic.battle.ICombatant.matchesCategory] */ CombatantFilter("combatantFilter", "City", "This indicates a combatant, which can either be a unit or a city (when bombarding). Must either be `City` or a `mapUnitFilter`") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (parameterText == "City") return null // City also recognizes "All" but that's covered by UnitTypeFilter too return MapUnitFilter.getErrorSeverity(parameterText, ruleset) } @@ -74,7 +74,7 @@ enum class UniqueParameterType( MapUnitFilter("mapUnitFilter", Constants.wounded, null, "Map Unit Filters") { private val knownValues = setOf(Constants.wounded, Constants.barbarians, "City-State", Constants.embarked, "Non-City") override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (parameterText.startsWith('{')) // "{filter} {filter}" for and logic return parameterText.filterCompositeLogic({ getErrorSeverity(it, ruleset) }) { a, b -> maxOf(a, b) } if (parameterText in knownValues) return null @@ -88,7 +88,7 @@ enum class UniqueParameterType( /** Implemented by [BaseUnit.matchesFilter][com.unciv.models.ruleset.unit.BaseUnit.matchesFilter] */ BaseUnitFilter("baseUnitFilter", "Melee") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (parameterText.startsWith('{')) // "{filter} {filter}" for and logic return parameterText.filterCompositeLogic({ getErrorSeverity(it, ruleset) }) { a, b -> maxOf(a, b) } if (UnitName.getErrorSeverity(parameterText, ruleset) == null) return null @@ -112,12 +112,12 @@ enum class UniqueParameterType( ) override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (parameterText in knownValues) return null if (ruleset.unitTypes.containsKey(parameterText)) return null if (ruleset.eras.containsKey(parameterText)) return null if (ruleset.unitTypes.values.any { it.uniques.contains(parameterText) }) return null - return UniqueType.UniqueComplianceErrorSeverity.WarningOnly + return UniqueType.UniqueErrorScope.WarningOnly } override fun isTranslationWriterGuess(parameterText: String, ruleset: Ruleset) = @@ -129,9 +129,9 @@ enum class UniqueParameterType( /** Used by [BaseUnitFilter] and e.g. [UniqueType.OneTimeFreeUnit] */ UnitName("unit", "Musketman") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (ruleset.units.containsKey(parameterText)) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific // OneTimeFreeUnitRuins crashes with a bad parameter + return UniqueType.UniqueErrorScope.RulesetSpecific // OneTimeFreeUnitRuins crashes with a bad parameter } }, @@ -140,27 +140,27 @@ enum class UniqueParameterType( override fun getErrorSeverity( parameterText: String, ruleset: Ruleset - ): UniqueType.UniqueComplianceErrorSeverity? { + ): UniqueType.UniqueErrorScope? { if (ruleset.units[parameterText]?.hasUnique(UniqueType.GreatPerson) == true) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + return UniqueType.UniqueErrorScope.RulesetSpecific } }, /** Implemented in [Unique.stats][com.unciv.models.ruleset.unique.Unique.stats] */ Stats("stats", "+1 Gold, +2 Production", "For example: `+2 Production, +3 Food`. Note that the stat names need to be capitalized!") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (com.unciv.models.stats.Stats.isStats(parameterText)) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + return UniqueType.UniqueErrorScope.RulesetInvariant } }, /** Many UniqueTypes like [UniqueType.StatPercentBonus] */ StatName("stat", "Culture", "This is one of the 7 major stats in the game - `Gold`, `Science`, `Production`, `Food`, `Happiness`, `Culture` and `Faith`. Note that the stat names need to be capitalized!") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (Stat.isStat(parameterText)) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + return UniqueType.UniqueErrorScope.RulesetInvariant } }, @@ -170,9 +170,9 @@ enum class UniqueParameterType( override fun getErrorSeverity( parameterText: String, ruleset: Ruleset - ): UniqueType.UniqueComplianceErrorSeverity? { + ): UniqueType.UniqueErrorScope? { if (parameterText in knownValues) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + return UniqueType.UniqueErrorScope.RulesetInvariant } }, @@ -183,11 +183,11 @@ enum class UniqueParameterType( override fun getErrorSeverity( parameterText: String, ruleset: Ruleset - ): UniqueType.UniqueComplianceErrorSeverity? { + ): UniqueType.UniqueErrorScope? { if (parameterText in knownValues) return null if (ruleset.nations.containsKey(parameterText)) return null if (ruleset.nations.values.any { it.hasUnique(parameterText) }) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + return UniqueType.UniqueErrorScope.RulesetSpecific } }, @@ -214,9 +214,9 @@ enum class UniqueParameterType( ) override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (parameterText in cityFilterStrings) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + return UniqueType.UniqueErrorScope.RulesetInvariant } override fun getTranslationWriterStringsForOutput() = cityFilterStrings @@ -227,9 +227,9 @@ enum class UniqueParameterType( override fun getErrorSeverity( parameterText: String, ruleset: Ruleset - ): UniqueType.UniqueComplianceErrorSeverity? { + ): UniqueType.UniqueErrorScope? { if (parameterText in ruleset.buildings) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + return UniqueType.UniqueErrorScope.RulesetSpecific } }, @@ -240,11 +240,11 @@ enum class UniqueParameterType( override fun getErrorSeverity( parameterText: String, ruleset: Ruleset - ): UniqueType.UniqueComplianceErrorSeverity? { + ): UniqueType.UniqueErrorScope? { if (parameterText in knownValues) return null if (BuildingName.getErrorSeverity(parameterText, ruleset) == null) return null if (ruleset.buildings.values.any { it.hasUnique(parameterText) }) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + return UniqueType.UniqueErrorScope.RulesetSpecific } override fun isTranslationWriterGuess(parameterText: String, ruleset: Ruleset) = @@ -257,9 +257,9 @@ enum class UniqueParameterType( override fun getErrorSeverity( parameterText: String, ruleset: Ruleset - ): UniqueType.UniqueComplianceErrorSeverity? { + ): UniqueType.UniqueErrorScope? { if (parameterText in knownValues) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + return UniqueType.UniqueErrorScope.RulesetSpecific } override fun getTranslationWriterStringsForOutput() = knownValues }, @@ -278,7 +278,7 @@ enum class UniqueParameterType( in ruleset.tileResources -> null in ruleset.terrains.values.asSequence().flatMap { it.uniques } -> null in ruleset.tileResources.values.asSequence().flatMap { it.uniques } -> null - else -> UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + else -> UniqueType.UniqueErrorScope.RulesetSpecific } override fun isTranslationWriterGuess(parameterText: String, ruleset: Ruleset) = parameterText in ruleset.terrains || parameterText != "All" && parameterText in knownValues @@ -289,7 +289,7 @@ enum class UniqueParameterType( TileFilter("tileFilter", "Farm", "Anything that can be used either in an improvementFilter or in a terrainFilter can be used here, plus 'unimproved'", "Tile Filters") { private val knownValues = setOf("unimproved", "All Road", "Great Improvement") override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (parameterText in knownValues) return null if (ImprovementFilter.getErrorSeverity(parameterText, ruleset) == null) return null return TerrainFilter.getErrorSeverity(parameterText, ruleset) @@ -301,19 +301,19 @@ enum class UniqueParameterType( SimpleTerrain("simpleTerrain", "Elevated") { private val knownValues = setOf("Elevated", "Water", "Land") override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (parameterText in knownValues) return null if (ruleset.terrains.containsKey(parameterText)) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + return UniqueType.UniqueErrorScope.RulesetSpecific } }, /** Used by [NaturalWonderGenerator.trySpawnOnSuitableLocation][com.unciv.logic.map.mapgenerator.NaturalWonderGenerator.trySpawnOnSuitableLocation], only tests base terrain */ BaseTerrain("baseTerrain", Constants.grassland, "The name of any terrain that is a base terrain according to the json file") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (ruleset.terrains[parameterText]?.type?.isBaseTerrain == true) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + return UniqueType.UniqueErrorScope.RulesetSpecific } }, @@ -321,9 +321,9 @@ enum class UniqueParameterType( * [UniqueType.ChangesTerrain] (MapGenerator.convertTerrains) */ TerrainName("terrainName", Constants.forest) { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (ruleset.terrains.containsKey(parameterText)) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + return UniqueType.UniqueErrorScope.RulesetSpecific } }, @@ -333,12 +333,12 @@ enum class UniqueParameterType( RegionType("regionType", "Hybrid", null, "Region Types") { private val knownValues = setOf("Hybrid") override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (parameterText in knownValues) return null if (ruleset.terrains[parameterText]?.hasUnique(UniqueType.RegionRequirePercentSingleType) == true || ruleset.terrains[parameterText]?.hasUnique(UniqueType.RegionRequirePercentTwoTypes) == true) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + return UniqueType.UniqueErrorScope.RulesetSpecific } override fun getTranslationWriterStringsForOutput() = knownValues }, @@ -347,9 +347,9 @@ enum class UniqueParameterType( TerrainQuality("terrainQuality", "Undesirable", null, "Terrain Quality") { private val knownValues = setOf("Undesirable", "Food", "Desirable", "Production") override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (parameterText in knownValues) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + return UniqueType.UniqueErrorScope.RulesetInvariant } override fun getTranslationWriterStringsForOutput() = knownValues }, @@ -357,29 +357,29 @@ enum class UniqueParameterType( /** [UniqueType.UnitStartingPromotions], [UniqueType.TerrainGrantsPromotion], [UniqueType.ConditionalUnitWithPromotion] and others */ Promotion("promotion", "Shock I", "The name of any promotion") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? = when (parameterText) { + UniqueType.UniqueErrorScope? = when (parameterText) { in ruleset.unitPromotions -> null - else -> UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + else -> UniqueType.UniqueErrorScope.RulesetSpecific } }, /** [UniqueType.OneTimeFreeTechRuins], [UniqueType.ConditionalDuringEra] and similar */ Era("era", "Ancient era", "The name of any era") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? = when (parameterText) { + UniqueType.UniqueErrorScope? = when (parameterText) { in ruleset.eras -> null - else -> UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + else -> UniqueType.UniqueErrorScope.RulesetSpecific } }, /** For [UniqueType.CreatesOneImprovement] */ ImprovementName("improvementName", "Trading Post", "The name of any improvement"){ override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (parameterText == Constants.cancelImprovementOrder) - return UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + return UniqueType.UniqueErrorScope.RulesetInvariant if (ruleset.tileImprovements.containsKey(parameterText)) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + return UniqueType.UniqueErrorScope.RulesetSpecific } }, @@ -387,11 +387,11 @@ enum class UniqueParameterType( ImprovementFilter("improvementFilter", "All Road", null, "Improvement Filters") { private val knownValues = setOf("All", "Improvement", "All Road", "Great Improvement", "Great") override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? { + UniqueType.UniqueErrorScope? { if (parameterText in knownValues) return null if (ImprovementName.getErrorSeverity(parameterText, ruleset) == null) return null if (ruleset.tileImprovements.values.any { it.hasUnique(parameterText) }) return null - return UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + return UniqueType.UniqueErrorScope.RulesetSpecific } override fun isTranslationWriterGuess(parameterText: String, ruleset: Ruleset) = parameterText != "All" && getErrorSeverity(parameterText, ruleset) == null @@ -401,34 +401,34 @@ enum class UniqueParameterType( /** Used by [UniqueType.ConsumesResources] and others, implementation not centralized */ Resource("resource", "Iron", "The name of any resource") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? = when (parameterText) { + UniqueType.UniqueErrorScope? = when (parameterText) { in ruleset.tileResources -> null - else -> UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + else -> UniqueType.UniqueErrorScope.RulesetSpecific } }, StockpiledResource("stockpiledResource", "StockpiledResource", "The name of any stockpiled") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? = if (parameterText in ruleset.tileResources && ruleset.tileResources[parameterText]!!.isStockpiled()) null - else UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + UniqueType.UniqueErrorScope? = if (parameterText in ruleset.tileResources && ruleset.tileResources[parameterText]!!.isStockpiled()) null + else UniqueType.UniqueErrorScope.RulesetSpecific }, /** Used by [UniqueType.FreeExtraBeliefs], see ReligionManager.getBeliefsToChooseAt* functions */ BeliefTypeName("beliefType", "Follower", "'Pantheon', 'Follower', 'Founder' or 'Enhancer'") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? = when (parameterText) { + UniqueType.UniqueErrorScope? = when (parameterText) { in BeliefType.values().map { it.name } -> null - else -> UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + else -> UniqueType.UniqueErrorScope.RulesetInvariant } }, /** unused at the moment with vanilla rulesets */ Belief("belief", "God of War", "The name of any belief") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? = when (parameterText) { + UniqueType.UniqueErrorScope? = when (parameterText) { in ruleset.beliefs -> null - else -> UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + else -> UniqueType.UniqueErrorScope.RulesetSpecific } }, @@ -437,9 +437,9 @@ enum class UniqueParameterType( // Used in FreeExtraBeliefs, FreeExtraAnyBeliefs private val knownValues = setOf("founding", "enhancing") override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? = when (parameterText) { + UniqueType.UniqueErrorScope? = when (parameterText) { in knownValues -> null - else -> UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + else -> UniqueType.UniqueErrorScope.RulesetInvariant } override fun getTranslationWriterStringsForOutput() = knownValues }, @@ -447,18 +447,18 @@ enum class UniqueParameterType( /** [UniqueType.ConditionalTech] and others, no central implementation */ Technology("tech", "Agriculture", "The name of any tech") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? = when (parameterText) { + UniqueType.UniqueErrorScope? = when (parameterText) { in ruleset.technologies -> null - else -> UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + else -> UniqueType.UniqueErrorScope.RulesetSpecific } }, /** unused at the moment with vanilla rulesets */ Specialist("specialist", "Merchant", "The name of any specialist") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? = when (parameterText) { + UniqueType.UniqueErrorScope? = when (parameterText) { in ruleset.specialists -> null - else -> UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + else -> UniqueType.UniqueErrorScope.RulesetSpecific } }, @@ -467,10 +467,10 @@ enum class UniqueParameterType( override fun getErrorSeverity( parameterText: String, ruleset: Ruleset - ): UniqueType.UniqueComplianceErrorSeverity? { + ): UniqueType.UniqueErrorScope? { return when (parameterText) { in ruleset.policies -> null - else -> UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + else -> UniqueType.UniqueErrorScope.RulesetSpecific } } }, @@ -480,9 +480,9 @@ enum class UniqueParameterType( override fun getErrorSeverity( parameterText: String, ruleset: Ruleset - ): UniqueType.UniqueComplianceErrorSeverity? { + ): UniqueType.UniqueErrorScope? { return if (parameterText in ruleset.victories) null - else UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + else UniqueType.UniqueErrorScope.RulesetInvariant } }, @@ -492,9 +492,9 @@ enum class UniqueParameterType( override fun getErrorSeverity( parameterText: String, ruleset: Ruleset - ): UniqueType.UniqueComplianceErrorSeverity? { + ): UniqueType.UniqueErrorScope? { return if (parameterText in knownValues) null - else UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + else UniqueType.UniqueErrorScope.RulesetInvariant } }, @@ -505,9 +505,9 @@ enum class UniqueParameterType( override fun getErrorSeverity( parameterText: String, ruleset: Ruleset - ): UniqueType.UniqueComplianceErrorSeverity? { + ): UniqueType.UniqueErrorScope? { return if (parameterText in knownValues) null - else UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + else UniqueType.UniqueErrorScope.RulesetInvariant } override fun getTranslationWriterStringsForOutput() = knownValues }, @@ -515,9 +515,9 @@ enum class UniqueParameterType( /** Mod declarative compatibility: Behaves like [Unknown], but makes for nicer auto-generated documentation. */ ModName("modFilter", "DeCiv Redux", """A Mod name, case-sensitive _or_ a simple wildcard filter beginning and ending in an Asterisk, case-insensitive""", "Mod name filter") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? = + UniqueType.UniqueErrorScope? = if ('-' !in parameterText && ('*' !in parameterText || parameterText.matches(Regex("""^\*[^*]+\*$""")))) null - else UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + else UniqueType.UniqueErrorScope.RulesetInvariant override fun getTranslationWriterStringsForOutput() = scanExistingValues(this) }, @@ -525,7 +525,7 @@ enum class UniqueParameterType( /** Behaves like [Unknown], but states explicitly the parameter is OK and its contents are ignored */ Comment("comment", "comment", null, "Unique Specials") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? = null + UniqueType.UniqueErrorScope? = null override fun getTranslationWriterStringsForOutput() = scanExistingValues(this) }, @@ -534,13 +534,13 @@ enum class UniqueParameterType( * [isTranslationWriterGuess]() == `true` for all inputs or TranslationFileWriter will have a problem! */ Unknown("param", "Unknown") { override fun getErrorSeverity(parameterText: String, ruleset: Ruleset): - UniqueType.UniqueComplianceErrorSeverity? = null + UniqueType.UniqueErrorScope? = null }; //region _Internals /** Validate a [Unique] parameter */ - abstract fun getErrorSeverity(parameterText: String, ruleset: Ruleset): UniqueType.UniqueComplianceErrorSeverity? + abstract fun getErrorSeverity(parameterText: String, ruleset: Ruleset): UniqueType.UniqueErrorScope? /** Pick this type when [TranslationFileWriter] tries to guess for an untyped [Unique] */ open fun isTranslationWriterGuess(parameterText: String, ruleset: Ruleset): Boolean = @@ -596,5 +596,5 @@ enum class UniqueParameterType( class UniqueComplianceError( val parameterName: String, val acceptableParameterTypes: List, - val errorSeverity: UniqueType.UniqueComplianceErrorSeverity + val errorSeverity: UniqueType.UniqueErrorScope ) diff --git a/core/src/com/unciv/models/ruleset/unique/UniqueType.kt b/core/src/com/unciv/models/ruleset/unique/UniqueType.kt index 096b9ae71b..8134e53b50 100644 --- a/core/src/com/unciv/models/ruleset/unique/UniqueType.kt +++ b/core/src/com/unciv/models/ruleset/unique/UniqueType.kt @@ -1169,25 +1169,29 @@ enum class UniqueType(val text: String, vararg targets: UniqueTarget, val flags: val placeholderText = text.getPlaceholderText() /** Ordinal determines severity - ordered from least to most severe, so we can use Severity >= */ - enum class UniqueComplianceErrorSeverity { + enum class UniqueErrorScope { - /** This is for filters that can also potentially accept free text, like UnitFilter and TileFilter */ + /** This is a warning, regardless of what ruleset we're in. + * This is for filters that can also potentially accept free text, like UnitFilter and TileFilter */ WarningOnly { - override fun getRulesetErrorSeverity(severityToReport: UniqueComplianceErrorSeverity) = + override fun getRulesetErrorSeverity(severityToReport: UniqueErrorScope) = RulesetErrorSeverity.WarningOptionsOnly }, - /** This is a problem like "unit/resource/tech name doesn't exist in ruleset" - definite bug */ + /** An error, but only because of other information in the current ruleset. + * This means that if this is an *add-on* to a different mod, it could be correct. + * This is a problem like "unit/resource/tech name doesn't exist in ruleset" - definite bug */ RulesetSpecific { // Report Warning on the first pass of RulesetValidator only, where mods are checked standalone // but upgrade to error when the econd pass asks, which runs only for combined or base rulesets. - override fun getRulesetErrorSeverity(severityToReport: UniqueComplianceErrorSeverity) = + override fun getRulesetErrorSeverity(severityToReport: UniqueErrorScope) = RulesetErrorSeverity.Warning }, - /** This is a problem like "numbers don't parse", "stat isn't stat", "city filter not applicable" */ + /** An error, regardless of the ruleset we're in. + * This is a problem like "numbers don't parse", "stat isn't stat", "city filter not applicable" */ RulesetInvariant { - override fun getRulesetErrorSeverity(severityToReport: UniqueComplianceErrorSeverity) = + override fun getRulesetErrorSeverity(severityToReport: UniqueErrorScope) = RulesetErrorSeverity.Error }, ; @@ -1197,7 +1201,7 @@ enum class UniqueType(val text: String, vararg targets: UniqueTarget, val flags: * first pass that also runs for extension mods without a base mixed in; the complex check * runs with [severityToReport]==[RulesetSpecific]. */ - abstract fun getRulesetErrorSeverity(severityToReport: UniqueComplianceErrorSeverity): RulesetErrorSeverity + abstract fun getRulesetErrorSeverity(severityToReport: UniqueErrorScope): RulesetErrorSeverity } fun getDeprecationAnnotation(): Deprecated? = declaringJavaClass.getField(name) diff --git a/core/src/com/unciv/models/ruleset/validation/RulesetValidator.kt b/core/src/com/unciv/models/ruleset/validation/RulesetValidator.kt index 99f9c76bc4..145ba1bb70 100644 --- a/core/src/com/unciv/models/ruleset/validation/RulesetValidator.kt +++ b/core/src/com/unciv/models/ruleset/validation/RulesetValidator.kt @@ -32,8 +32,8 @@ class RulesetValidator(val ruleset: Ruleset) { // Checks for ALL MODS - only those that can succeed without loading a base ruleset // When not checking the entire ruleset, we can only really detect ruleset-invariant errors in uniques - val rulesetInvariant = UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant - val rulesetSpecific = UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific + val rulesetInvariant = UniqueType.UniqueErrorScope.RulesetInvariant + val rulesetSpecific = UniqueType.UniqueErrorScope.RulesetSpecific uniqueValidator.checkUniques(ruleset.globalUniques, lines, rulesetInvariant, tryFixUnknownUniques) addUnitErrorsRulesetInvariant(lines, rulesetInvariant, tryFixUnknownUniques) @@ -82,7 +82,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addCityStateTypeErrors( tryFixUnknownUniques: Boolean, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, lines: RulesetErrorList ) { for (cityStateType in ruleset.cityStateTypes.values) { @@ -131,7 +131,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addUnitTypeErrors( lines: RulesetErrorList, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (unitType in ruleset.unitTypes.values) { @@ -141,7 +141,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addPromotionErrors( lines: RulesetErrorList, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (promotion in ruleset.unitPromotions.values) { @@ -165,7 +165,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addRuinsErrors( lines: RulesetErrorList, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (reward in ruleset.ruinRewards.values) { @@ -178,7 +178,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addPolicyErrors( lines: RulesetErrorList, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (policy in ruleset.policies.values) { @@ -202,7 +202,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addNationErrors( lines: RulesetErrorList, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (nation in ruleset.nations.values) { @@ -217,7 +217,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addBeliefErrors( lines: RulesetErrorList, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (belief in ruleset.beliefs.values) { @@ -236,7 +236,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addEraErrors( lines: RulesetErrorList, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { if (ruleset.eras.isEmpty()) { @@ -294,7 +294,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addTechErrors( lines: RulesetErrorList, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (tech in ruleset.technologies.values) { @@ -322,7 +322,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addTerrainErrors( lines: RulesetErrorList, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { if (ruleset.terrains.values.none { it.type == TerrainType.Land && !it.impassable }) @@ -351,7 +351,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addImprovementErrors( lines: RulesetErrorList, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (improvement in ruleset.tileImprovements.values) { @@ -406,7 +406,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addResourceErrors( lines: RulesetErrorList, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (resource in ruleset.tileResources.values) { @@ -437,7 +437,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addBuildingErrors( lines: RulesetErrorList, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (building in ruleset.buildings.values) { @@ -460,7 +460,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addUnitErrors( lines: RulesetErrorList, - rulesetSpecific: UniqueType.UniqueComplianceErrorSeverity, + rulesetSpecific: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { if (ruleset.units.values.none { it.isCityFounder() }) @@ -474,7 +474,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addResourceErrorsRulesetInvariant( lines: RulesetErrorList, - rulesetInvariant: UniqueType.UniqueComplianceErrorSeverity, + rulesetInvariant: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (resource in ruleset.tileResources.values) { @@ -484,7 +484,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addPromotionErrorsRulesetInvariant( lines: RulesetErrorList, - rulesetInvariant: UniqueType.UniqueComplianceErrorSeverity, + rulesetInvariant: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (promotion in ruleset.unitPromotions.values) { @@ -500,7 +500,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addNationErrorsRulesetInvariant( lines: RulesetErrorList, - rulesetInvariant: UniqueType.UniqueComplianceErrorSeverity, + rulesetInvariant: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (nation in ruleset.nations.values) { @@ -550,7 +550,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addBuildingErrorsRulesetInvariant( lines: RulesetErrorList, - rulesetInvariant: UniqueType.UniqueComplianceErrorSeverity, + rulesetInvariant: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (building in ruleset.buildings.values) { @@ -594,7 +594,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addTechErrorsRulesetInvariant( lines: RulesetErrorList, - rulesetInvariant: UniqueType.UniqueComplianceErrorSeverity, + rulesetInvariant: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (tech in ruleset.technologies.values) { @@ -609,7 +609,7 @@ class RulesetValidator(val ruleset: Ruleset) { private fun addUnitErrorsRulesetInvariant( lines: RulesetErrorList, - rulesetInvariant: UniqueType.UniqueComplianceErrorSeverity, + rulesetInvariant: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (unit in ruleset.units.values) { diff --git a/core/src/com/unciv/models/ruleset/validation/UniqueValidator.kt b/core/src/com/unciv/models/ruleset/validation/UniqueValidator.kt index 89a6b3397a..f15d03485c 100644 --- a/core/src/com/unciv/models/ruleset/validation/UniqueValidator.kt +++ b/core/src/com/unciv/models/ruleset/validation/UniqueValidator.kt @@ -16,7 +16,7 @@ class UniqueValidator(val ruleset: Ruleset) { fun checkUniques( uniqueContainer: IHasUniques, lines: RulesetErrorList, - severityToReport: UniqueType.UniqueComplianceErrorSeverity, + severityToReport: UniqueType.UniqueErrorScope, tryFixUnknownUniques: Boolean ) { for (unique in uniqueContainer.uniqueObjects) { @@ -34,7 +34,7 @@ class UniqueValidator(val ruleset: Ruleset) { unique: Unique, tryFixUnknownUniques: Boolean, namedObj: INamed?, - severityToReport: UniqueType.UniqueComplianceErrorSeverity + severityToReport: UniqueType.UniqueErrorScope ): List { val prefix by lazy { (if (namedObj is IRulesetObject) "${namedObj.originRuleset}: " else "") + (if (namedObj == null) "The" else "${namedObj.name}'s") } @@ -60,7 +60,7 @@ class UniqueValidator(val ruleset: Ruleset) { } - if (severityToReport != UniqueType.UniqueComplianceErrorSeverity.RulesetSpecific) + if (severityToReport != UniqueType.UniqueErrorScope.RulesetSpecific) // If we don't filter these messages will be listed twice as this function is called twice on most objects // The tests are RulesetInvariant in nature, but RulesetSpecific is called for _all_ objects, invariant is not. return rulesetErrors @@ -75,7 +75,7 @@ class UniqueValidator(val ruleset: Ruleset) { rulesetErrors: RulesetErrorList, prefix: String, unique: Unique, - severityToReport: UniqueType.UniqueComplianceErrorSeverity + severityToReport: UniqueType.UniqueErrorScope ) { if (conditional.type == null) { rulesetErrors.add( @@ -154,8 +154,8 @@ class UniqueValidator(val ruleset: Ruleset) { return errorList } - private val paramTypeErrorSeverityCache = HashMap>() - private fun getParamTypeErrorSeverityCached(uniqueParameterType: UniqueParameterType, param:String): UniqueType.UniqueComplianceErrorSeverity? { + private val paramTypeErrorSeverityCache = HashMap>() + private fun getParamTypeErrorSeverityCached(uniqueParameterType: UniqueParameterType, param:String): UniqueType.UniqueErrorScope? { if (!paramTypeErrorSeverityCache.containsKey(uniqueParameterType)) paramTypeErrorSeverityCache[uniqueParameterType] = hashMapOf() val uniqueParamCache = paramTypeErrorSeverityCache[uniqueParameterType]!! diff --git a/core/src/com/unciv/ui/popups/options/ModCheckTab.kt b/core/src/com/unciv/ui/popups/options/ModCheckTab.kt index 8c202b3379..4c2f61f33f 100644 --- a/core/src/com/unciv/ui/popups/options/ModCheckTab.kt +++ b/core/src/com/unciv/ui/popups/options/ModCheckTab.kt @@ -204,7 +204,7 @@ class ModCheckTab( replacementUnique, false, null, - UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + UniqueType.UniqueErrorScope.RulesetInvariant ) for (error in modInvariantErrors) Log.error("ModInvariantError: %s - %s", error.text, error.errorSeverityToReport) @@ -215,7 +215,7 @@ class ModCheckTab( replacementUnique, false, null, - UniqueType.UniqueComplianceErrorSeverity.RulesetInvariant + UniqueType.UniqueErrorScope.RulesetInvariant ) for (error in modSpecificErrors) Log.error("ModSpecificError: %s - %s", error.text, error.errorSeverityToReport)