AnarchistGamers/Unciv
1
0
Fork 0
mirror of https://github.com/yairm210/Unciv.git synced 2025-08-03 20:48:49 -04:00
Code Issues Packages Projects Releases Wiki Activity

Revert "can settle" changes (#13763)

Browse Source 
* Revert unique validator changes

* Revert "Updated canBeSettled to be able to settle water mountain tiles (#13717)"

This reverts commit cfc640d0eefc2a621193cbcf9ce8520688c6a9af.
This commit is contained in:
Yair Morgenstern 2025-08-03 00:07:30 +03:00 committed by GitHub
parent 4fb9efd237
commit 9f19048351
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 47 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
core/src/com/unciv/logic/map/tile/Tile.kt
View File

@ -19,7 +19,6 @@ import com.unciv.logic.map.mapgenerator.MapResourceSetting
import com.unciv.logic.map.mapunit.MapUnit
import com.unciv.logic.map.mapunit.UnitTurnManager
import com.unciv.logic.map.mapunit.movement.UnitMovement
import com.unciv.models.UnitAction
import com.unciv.models.ruleset.Ruleset
import com.unciv.models.ruleset.tile.ResourceType
import com.unciv.models.ruleset.tile.Terrain
@ -631,28 +630,13 @@ class Tile : IsPartOfGameInfoSerialization, Json.Serializable {
return min(distance, wrappedDistance).toInt()
}
fun canBeSettled(unitCanFoundUnique: Unique?=null): Boolean {
@Readonly
fun canBeSettled(): Boolean {
val modConstants = tileMap.gameInfo.ruleset.modOptions.constants
var addedDistanceBeweenContinents: Int
var canSettleInTileWithUnique = false
if (unitCanFoundUnique != null) {
canSettleInTileWithUnique = (isWater || isImpassible()) &&
unitCanFoundUnique.getModifiers(UniqueType.ConditionalInTiles).none{
matchesFilter(it.params[0])
}
}
/*
Putting the ! to make sure the player/Ai doesn't place cities too near each other.
Because when .none return False when one element has a match.
*/
addedDistanceBeweenContinents = if (!canSettleInTileWithUnique) 1 else 0
return when {
canSettleInTileWithUnique -> false
getTilesInDistance(modConstants.minimalCityDistanceOnDifferentContinents+
addedDistanceBeweenContinents)
isWater || isImpassible() -> false
getTilesInDistance(modConstants.minimalCityDistanceOnDifferentContinents)
.any { it.isCityCenter() && it.getContinent() != getContinent() } -> false
getTilesInDistance(modConstants.minimalCityDistance)
.any { it.isCityCenter() && it.getContinent() == getContinent() } -> false

3
core/src/com/unciv/models/ruleset/Ruleset.kt
View File

@ -291,12 +291,11 @@ class Ruleset {
personalities.clear()
events.clear()
}
@Readonly fun allRulesetObjects(): Sequence<IRulesetObject> = RulesetFile.entries.asSequence().flatMap { it.getRulesetObjects(this) }
@Readonly fun allUniques(): Sequence<Unique> = RulesetFile.entries.asSequence().flatMap { it.getUniques(this) }
@Readonly fun allICivilopediaText(): Sequence<ICivilopediaText> = allRulesetObjects() + events.values.flatMap { it.choices }
fun load(folderHandle: FileHandle) {
// Note: Most files are loaded using createHashmap, which sets originRuleset automatically.
// For other files containing IRulesetObject's we'll have to remember to do so manually - e.g. Tech.

1
core/src/com/unciv/models/ruleset/tile/Terrain.kt
View File

@ -187,7 +187,6 @@ class Terrain : RulesetStatsObject() {
type.name -> true
"Natural Wonder" -> type == TerrainType.NaturalWonder
"Terrain Feature" -> type == TerrainType.TerrainFeature
"Impassable" -> impassable
else -> false
}

3
core/src/com/unciv/models/ruleset/unique/UniqueType.kt
View File

@ -805,8 +805,7 @@ enum class UniqueType(
/////// tile conditionals
ConditionalNeighborTiles("with [nonNegativeAmount] to [nonNegativeAmount] neighboring [tileFilter] tiles", UniqueTarget.Conditional),
ConditionalInTiles("in [tileFilter] tiles", UniqueTarget.Conditional,
docDescription = "Can be used with FoundCity and FoundPuppetCity to only found cities in Water/Impassible tiles."),
ConditionalInTiles("in [tileFilter] tiles", UniqueTarget.Conditional),
ConditionalInTilesNot("in tiles without [tileFilter]", UniqueTarget.Conditional),
ConditionalNearTiles("within [positiveAmount] tiles of a [tileFilter]", UniqueTarget.Conditional),

98
core/src/com/unciv/models/ruleset/validation/UniqueValidator.kt
View File

@ -15,8 +15,6 @@ import com.unciv.models.ruleset.unique.UniqueParameterType
import com.unciv.models.ruleset.unique.UniqueTarget
import com.unciv.models.ruleset.unique.UniqueType
import com.unciv.models.ruleset.unique.expressions.Expressions
import yairm210.purity.annotations.Cache
import yairm210.purity.annotations.LocalState
import yairm210.purity.annotations.Readonly
class UniqueValidator(val ruleset: Ruleset) {
@ -66,7 +64,7 @@ class UniqueValidator(val ruleset: Ruleset) {
UniqueType.ConditionalNotAdjacentTo
)
@Readonly
@Readonly @Suppress("purity")
fun checkUnique(
unique: Unique,
tryFixUnknownUniques: Boolean,
@ -76,7 +74,7 @@ class UniqueValidator(val ruleset: Ruleset) {
val prefix by lazy { getUniqueContainerPrefix(uniqueContainer) + "\"${unique.text}\"" }
if (unique.type == null) return checkUntypedUnique(unique, tryFixUnknownUniques, uniqueContainer, prefix, reportRulesetSpecificErrors)
@LocalState val rulesetErrors = RulesetErrorList(ruleset)
val rulesetErrors = RulesetErrorList(ruleset)
if (uniqueContainer != null &&
!(unique.type.canAcceptUniqueTarget(uniqueContainer.getUniqueTarget()) ||
@ -109,14 +107,14 @@ class UniqueValidator(val ruleset: Ruleset) {
complianceError.errorSeverity.getRulesetErrorSeverity(), uniqueContainer, unique
)
rulesetErrors += getExpressionParseErrors(complianceError, uniqueContainer, unique)
addExpressionParseErrors(complianceError, rulesetErrors, uniqueContainer, unique)
}
for (conditional in unique.modifiers) {
rulesetErrors += getConditionalErrors(conditional, prefix, unique, uniqueContainer, reportRulesetSpecificErrors)
addConditionalErrors(conditional, rulesetErrors, prefix, unique, uniqueContainer, reportRulesetSpecificErrors)
}
rulesetErrors += getUniqueTypeSpecificErrors(prefix, unique, uniqueContainer, reportRulesetSpecificErrors)
addUniqueTypeSpecificErrors(rulesetErrors, prefix, unique, uniqueContainer, reportRulesetSpecificErrors)
val conditionals = unique.modifiers.filter { it.type?.canAcceptUniqueTarget(UniqueTarget.Conditional) == true }
if (conditionals.size > 1){
@ -146,19 +144,18 @@ class UniqueValidator(val ruleset: Ruleset) {
if (reportRulesetSpecificErrors)
// 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.
rulesetErrors += addDeprecationAnnotationErrors(unique, prefix, uniqueContainer)
addDeprecationAnnotationErrors(unique, prefix, rulesetErrors, uniqueContainer)
return rulesetErrors
}
@Readonly
private fun getExpressionParseErrors(
private fun addExpressionParseErrors(
complianceError: UniqueComplianceError,
rulesetErrors: RulesetErrorList,
uniqueContainer: IHasUniques?,
unique: Unique
): RulesetErrorList {
@LocalState val rulesetErrors = RulesetErrorList(ruleset)
if (!complianceError.acceptableParameterTypes.contains(UniqueParameterType.Countable)) return rulesetErrors
) {
if (!complianceError.acceptableParameterTypes.contains(UniqueParameterType.Countable)) return
val parseError = Expressions.getParsingError(complianceError.parameterName)
if (parseError != null) {
@ -170,7 +167,7 @@ class UniqueValidator(val ruleset: Ruleset) {
val text = "\"${complianceError.parameterName}\" could not be parsed as an expression due to:" +
" ${parseError.message}. \n$parameterWithErrorLocationMarked"
rulesetErrors.add(text, RulesetErrorSeverity.WarningOptionsOnly, uniqueContainer, unique)
return rulesetErrors
return
}
val countableErrors = Expressions.getCountableErrors(complianceError.parameterName, ruleset)
@ -179,7 +176,6 @@ class UniqueValidator(val ruleset: Ruleset) {
" ${countableErrors.joinToString(", ")}"
rulesetErrors.add(text, RulesetErrorSeverity.WarningOptionsOnly, uniqueContainer, unique)
}
return rulesetErrors
}
private val resourceUniques = setOf(UniqueType.ProvidesResources, UniqueType.ConsumesResources,
@ -192,37 +188,21 @@ class UniqueValidator(val ruleset: Ruleset) {
UniqueType.ConditionalWhenBelowAmountStatResource,
)
@Readonly
private fun getUniqueTypeSpecificErrors(
prefix: String, unique: Unique, uniqueContainer: IHasUniques?, reportRulesetSpecificErrors: Boolean
): RulesetErrorList {
@LocalState val rulesetErrors = RulesetErrorList(ruleset)
when (unique.type) {
UniqueType.RuinsUpgrade -> {
if (reportRulesetSpecificErrors && !anyAncientRuins)
rulesetErrors.add("$prefix is pointless - there are no ancient ruins", RulesetErrorSeverity.Warning, uniqueContainer, unique)
}
else -> {}
}
return rulesetErrors
}
@Readonly
private fun getConditionalErrors(
private fun addConditionalErrors(
conditional: Unique,
rulesetErrors: RulesetErrorList,
prefix: String,
unique: Unique,
uniqueContainer: IHasUniques?,
reportRulesetSpecificErrors: Boolean
): RulesetErrorList {
@LocalState val rulesetErrors = RulesetErrorList(ruleset)
) {
if (unique.hasFlag(UniqueFlag.NoConditionals)) {
rulesetErrors.add(
"$prefix contains the conditional \"${conditional.text}\"," +
" but the unique does not accept conditionals!",
RulesetErrorSeverity.Error, uniqueContainer, unique
)
return rulesetErrors
return
}
if (conditional.type == null) {
@ -241,7 +221,7 @@ class UniqueValidator(val ruleset: Ruleset) {
text,
RulesetErrorSeverity.Warning, uniqueContainer, unique
)
return rulesetErrors
return
}
if (conditional.type.targetTypes.none { it.modifierType != UniqueTarget.ModifierType.None })
@ -296,21 +276,30 @@ class UniqueValidator(val ruleset: Ruleset) {
complianceError.errorSeverity.getRulesetErrorSeverity(), uniqueContainer, unique
)
rulesetErrors += getExpressionParseErrors(complianceError, uniqueContainer, unique)
addExpressionParseErrors(complianceError, rulesetErrors, uniqueContainer, unique)
}
addDeprecationAnnotationErrors(conditional, "$prefix contains modifier \"${conditional.text}\" which", uniqueContainer)
return rulesetErrors
addDeprecationAnnotationErrors(conditional, "$prefix contains modifier \"${conditional.text}\" which", rulesetErrors, uniqueContainer)
}
private fun addUniqueTypeSpecificErrors(
rulesetErrors: RulesetErrorList, prefix: String, unique: Unique, uniqueContainer: IHasUniques?, reportRulesetSpecificErrors: Boolean
) {
when(unique.type) {
UniqueType.RuinsUpgrade -> {
if (reportRulesetSpecificErrors && !anyAncientRuins)
rulesetErrors.add("$prefix is pointless - there are no ancient ruins", RulesetErrorSeverity.Warning, uniqueContainer, unique)
}
else -> return
}
}
@Readonly
private fun addDeprecationAnnotationErrors(
unique: Unique,
prefix: String,
rulesetErrors: RulesetErrorList,
uniqueContainer: IHasUniques?
): RulesetErrorList {
@LocalState val rulesetErrors = RulesetErrorList(ruleset)
) {
val deprecationAnnotation = unique.getDeprecationAnnotation()
if (deprecationAnnotation != null) {
val replacementUniqueText = unique.getReplacementText(ruleset)
@ -325,13 +314,12 @@ class UniqueValidator(val ruleset: Ruleset) {
}
// Check for deprecated Countables
if (unique.type == null) return rulesetErrors
if (unique.type == null) return
val countables =
unique.type.parameterTypeMap.withIndex()
.filter { UniqueParameterType.Countable in it.value }
.map { unique.params[it.index] }
.mapNotNull { Countables.getMatching(it, ruleset) }
for (countable in countables) {
val deprecation = countable.getDeprecationAnnotation() ?: continue
// This is less flexible than unique.getReplacementText(ruleset)
@ -343,18 +331,14 @@ class UniqueValidator(val ruleset: Ruleset) {
else RulesetErrorSeverity.ErrorOptionsOnly // User visible in new game and red in options
rulesetErrors.add(text, severity, uniqueContainer, unique)
}
return rulesetErrors
}
/** Maps uncompliant parameters to their required types */
@Readonly
private fun getComplianceErrors(
unique: Unique,
): List<UniqueComplianceError> {
if (unique.type == null) return emptyList()
@LocalState val errorList = ArrayList<UniqueComplianceError>()
val errorList = ArrayList<UniqueComplianceError>()
for ((index, param) in unique.params.withIndex()) {
// Trying to catch the error at #11404
if (unique.type.parameterTypeMap.size != unique.params.size) {
@ -379,13 +363,11 @@ class UniqueValidator(val ruleset: Ruleset) {
return errorList
}
@Cache private val paramTypeErrorSeverityCache = HashMap<UniqueParameterType, HashMap<String, UniqueType.UniqueParameterErrorSeverity?>>()
@Readonly
private val paramTypeErrorSeverityCache = HashMap<UniqueParameterType, HashMap<String, UniqueType.UniqueParameterErrorSeverity?>>()
private fun getParamTypeErrorSeverityCached(uniqueParameterType: UniqueParameterType, param: String): UniqueType.UniqueParameterErrorSeverity? {
if (!paramTypeErrorSeverityCache.containsKey(uniqueParameterType))
paramTypeErrorSeverityCache[uniqueParameterType] = hashMapOf()
@LocalState val uniqueParamCache = paramTypeErrorSeverityCache[uniqueParameterType]!!
val uniqueParamCache = paramTypeErrorSeverityCache[uniqueParameterType]!!
if (uniqueParamCache.containsKey(param)) return uniqueParamCache[param]
@ -394,7 +376,6 @@ class UniqueValidator(val ruleset: Ruleset) {
return severity
}
@Readonly
private fun checkUntypedUnique(
unique: Unique,
tryFixUnknownUniques: Boolean,
@ -410,7 +391,7 @@ class UniqueValidator(val ruleset: Ruleset) {
)
// Support purely filtering Uniques without actual implementation
if (isFilteringUniqueAllowed(unique, reportRulesetSpecificErrors)) return RulesetErrorList(ruleset)
if (isFilteringUniqueAllowed(unique, reportRulesetSpecificErrors)) return RulesetErrorList()
if (tryFixUnknownUniques) {
val fixes = tryFixUnknownUnique(unique, uniqueContainer, prefix)
@ -424,7 +405,6 @@ class UniqueValidator(val ruleset: Ruleset) {
)
}
@Readonly
private fun isFilteringUniqueAllowed(unique: Unique, reportRulesetSpecificErrors: Boolean): Boolean {
// Isolate this decision, to allow easy change of approach
// This says: Must have no conditionals or parameters, and is used in any "filtering" parameter of another Unique
@ -433,7 +413,6 @@ class UniqueValidator(val ruleset: Ruleset) {
return unique.text in allUniqueParameters // referenced at least once from elsewhere
}
@Readonly
private fun tryFixUnknownUnique(unique: Unique, uniqueContainer: IHasUniques?, prefix: String): RulesetErrorList {
val similarUniques = UniqueType.entries.filter {
getRelativeTextDistance(
@ -464,14 +443,13 @@ class UniqueValidator(val ruleset: Ruleset) {
}.prependIndent("\t")
RulesetErrorList.of(text, RulesetErrorSeverity.OK, ruleset, uniqueContainer, unique)
}
else -> RulesetErrorList(ruleset)
else -> RulesetErrorList()
}
}
companion object {
const val whichDoesNotFitParameterType = "which does not fit parameter type"
@Readonly
internal fun getUniqueContainerPrefix(uniqueContainer: IHasUniques?) =
(if (uniqueContainer is IRulesetObject) "${uniqueContainer.originRuleset}: " else "") +
(if (uniqueContainer == null) "The" else "(${uniqueContainer.getUniqueTarget().name}) ${uniqueContainer.name}'s") +

4
core/src/com/unciv/ui/screens/worldscreen/unit/actions/UnitActionsFromUniques.kt
View File

@ -45,11 +45,11 @@ object UnitActionsFromUniques {
UnitActionModifiers.getUsableUnitActionUniques(unit,
UniqueType.FoundPuppetCity).firstOrNull() ?: return null
if (tile.isWater || tile.isImpassible()) return null
// Spain should still be able to build Conquistadors in a one city challenge - but can't settle them
if (unit.civ.isOneCityChallenger() && unit.civ.hasEverOwnedOriginalCapital) return null
if (!unit.hasMovement() || !tile.canBeSettled(unique))
if (!unit.hasMovement() || !tile.canBeSettled())
return UnitAction(UnitActionType.FoundCity, 80f, action = null)
val hasActionModifiers = unique.modifiers.any { it.type?.targetTypes?.contains(

2
docs/Modders/uniques.md
View File

@ -3535,8 +3535,6 @@ Simple unique parameters are explained by mouseover. Complex parameters are expl
Applicable to: Conditional
??? example "&lt;in [tileFilter] tiles&gt;"
Can be used with FoundCity and FoundPuppetCity to only found cities in Water/Impassible tiles.
Example: "&lt;in [Farm] tiles&gt;"
Applicable to: Conditional