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)