City-States Influence rates; Wary status; Proximity calculations (#5198)

* Rates for natural influence change

* Minor civ wariness, proximity calculation

* CS can declare permanent war

* CS can in fact not declare permanent war

* adjustments, template.properties

* neater code

* fix failing test? .

* move proximity code, for reals fix failing check

* now?

* revisions

* BFS only once, better check for water map

* assign continents on pre-made maps as well

* now works on all pre-made maps

Author: SimonCeder

android/assets/jsons/translations/template.properties

@@ -182,6 +182,7 @@ Diplomatic Marriage ([amount] Gold) =
 We have married into the ruling family of [civName], bringing them under our control. = 
 [civName] has married into the ruling family of [civName2], bringing them under their control. = 
 You have broken your Pledge to Protect [civName]! = 
+City-States grow wary of your aggression. The resting point for Influence has decreased by [amount] for [civName]. = 
 
 Cultured = 
 Maritime = 

core/src/com/unciv/logic/GameStarter.kt

@@ -33,23 +33,29 @@ object GameStarter {
 
         // In the case where we used to have a mod, and now we don't, we cannot "unselect" it in the UI.
         // We need to remove the dead mods so there aren't problems later.
-        gameSetupInfo.gameParameters.mods.removeAll{ !RulesetCache.containsKey(it) }
+        gameSetupInfo.gameParameters.mods.removeAll { !RulesetCache.containsKey(it) }
 
         gameInfo.gameParameters = gameSetupInfo.gameParameters
         val ruleset = RulesetCache.getComplexRuleset(gameInfo.gameParameters.mods)
+        val mapGen = MapGenerator(ruleset)
 
         if (gameSetupInfo.mapParameters.name != "") runAndMeasure("loadMap") {
             tileMap = MapSaver.loadMap(gameSetupInfo.mapFile!!)
             // Don't override the map parameters - this can include if we world wrap or not!
         } else runAndMeasure("generateMap") {
-            tileMap = MapGenerator(ruleset).generateMap(gameSetupInfo.mapParameters)
+            tileMap = mapGen.generateMap(gameSetupInfo.mapParameters)
             tileMap.mapParameters = gameSetupInfo.mapParameters
         }
 
         runAndMeasure("addCivilizations") {
             gameInfo.tileMap = tileMap
-            tileMap.gameInfo = gameInfo // need to set this transient before placing units in the map
-            addCivilizations(gameSetupInfo.gameParameters, gameInfo, ruleset) // this is before gameInfo.setTransients, so gameInfo doesn't yet have the gameBasics
+            tileMap.gameInfo =
+                gameInfo // need to set this transient before placing units in the map
+            addCivilizations(
+                gameSetupInfo.gameParameters,
+                gameInfo,
+                ruleset
+            ) // this is before gameInfo.setTransients, so gameInfo doesn't yet have the gameBasics
         }
 
         runAndMeasure("Remove units") {
@@ -78,6 +84,11 @@ object GameStarter {
             addCivStats(gameInfo)
         }
 
+        runAndMeasure("assignContinents?") {
+            if (tileMap.continentSizes.isEmpty())   // Probably saved map without continent data
+                mapGen.assignContinents(tileMap)
+        }
+
         runAndMeasure("addCivStartingUnits") {
             // and only now do we add units for everyone, because otherwise both the gameInfo.setTransients() and the placeUnit will both add the unit to the civ's unit list!
             addCivStartingUnits(gameInfo)
@@ -334,19 +345,23 @@ object GameStarter {
         }
     }
 
+
     private fun getStartingLocations(civs: List<CivilizationInfo>, tileMap: TileMap, startScores: HashMap<TileInfo, Float>): HashMap<CivilizationInfo, TileInfo> {
-        var landTiles = tileMap.values
+        val landTilesInBigEnoughGroup = tileMap.landTilesInBigEnoughGroup
+        if (landTilesInBigEnoughGroup.isEmpty()) {
+            // Worst case - a pre-made map with continent data. This means we didn't re-run assignContinents,
+            // so we don't have a cached landTilesInBigEnoughGroup. So we need to do it the hard way.
+            var landTiles = tileMap.values
                 // Games starting on snow might as well start over...
                 .filter { it.isLand && !it.isImpassible() && it.baseTerrain != Constants.snow }
-
-        val landTilesInBigEnoughGroup = ArrayList<TileInfo>()
-        while (landTiles.any()) {
-            val bfs = BFS(landTiles.random()) { it.isLand && !it.isImpassible() }
-            bfs.stepToEnd()
-            val tilesInGroup = bfs.getReachedTiles()
-            landTiles = landTiles.filter { it !in tilesInGroup }
-            if (tilesInGroup.size > 20) // is this a good number? I dunno, but it's easy enough to change later on
-                landTilesInBigEnoughGroup.addAll(tilesInGroup)
+            while (landTiles.any()) {
+                val bfs = BFS(landTiles.random()) { it.isLand && !it.isImpassible() }
+                bfs.stepToEnd()
+                val tilesInGroup = bfs.getReachedTiles()
+                landTiles = landTiles.filter { it !in tilesInGroup }
+                if (tilesInGroup.size > 20) // is this a good number? I dunno, but it's easy enough to change later on
+                    landTilesInBigEnoughGroup.addAll(tilesInGroup)
+            }
         }
 
         val civsOrderedByAvailableLocations = civs.shuffled()   // Order should be random since it determines who gets best start

core/src/com/unciv/logic/city/CityInfo.kt

@@ -3,6 +3,7 @@ package com.unciv.logic.city
 import com.badlogic.gdx.math.Vector2
 import com.unciv.logic.battle.CityCombatant
 import com.unciv.logic.civilization.CivilizationInfo
+import com.unciv.logic.civilization.Proximity
 import com.unciv.logic.civilization.ReligionState
 import com.unciv.logic.civilization.diplomacy.DiplomacyFlags
 import com.unciv.logic.map.RoadStatus
@@ -129,6 +130,18 @@ class CityInfo {
         population.autoAssignPopulation()
         cityStats.update()
 
+        // Update proximity rankings for all civs
+        for (otherCiv in civInfo.gameInfo.getAliveMajorCivs()) {
+            if (civInfo.getProximity(otherCiv) != Proximity.Neighbors) // unless already neighbors
+                civInfo.updateProximity(otherCiv,
+                otherCiv.updateProximity(civInfo))
+        }
+        for (otherCiv in civInfo.gameInfo.getAliveCityStates()) {
+            if (civInfo.getProximity(otherCiv) != Proximity.Neighbors) // unless already neighbors
+                civInfo.updateProximity(otherCiv,
+                    otherCiv.updateProximity(civInfo))
+        }
+
         triggerCitiesSettledNearOtherCiv()
     }
 
@@ -556,6 +569,16 @@ class CityInfo {
         if (isCapital() && civInfo.cities.isNotEmpty()) { // Move the capital if destroyed (by a nuke or by razing)
             civInfo.cities.first().cityConstructions.addBuilding(capitalCityIndicator())
         }
+
+        // Update proximity rankings for all civs
+        for (otherCiv in civInfo.gameInfo.getAliveMajorCivs()) {
+            civInfo.updateProximity(otherCiv,
+                otherCiv.updateProximity(civInfo))
+        }
+        for (otherCiv in civInfo.gameInfo.getAliveCityStates()) {
+            civInfo.updateProximity(otherCiv,
+                otherCiv.updateProximity(civInfo))
+        }
     }
 
     fun annexCity() = CityInfoConquestFunctions(this).annexCity()

core/src/com/unciv/logic/city/CityInfoConquestFunctions.kt

@@ -276,6 +276,10 @@ class CityInfoConquestFunctions(val city: CityInfo){
 
             tryUpdateRoadStatus()
             cityStats.update()
+
+            // Update proximity rankings
+            civInfo.updateProximity(oldCiv,
+                oldCiv.updateProximity(civInfo))
         }
     }
 

core/src/com/unciv/logic/civilization/CityStateFunctions.kt

@@ -2,17 +2,16 @@ package com.unciv.logic.civilization
 
 import com.unciv.Constants
 import com.unciv.logic.automation.NextTurnAutomation
-import com.unciv.logic.civilization.diplomacy.DiplomacyFlags
-import com.unciv.logic.civilization.diplomacy.DiplomaticModifiers
-import com.unciv.logic.civilization.diplomacy.DiplomaticStatus
-import com.unciv.logic.civilization.diplomacy.RelationshipLevel
+import com.unciv.logic.civilization.diplomacy.*
 import com.unciv.models.metadata.GameSpeed
 import com.unciv.models.ruleset.Ruleset
 import com.unciv.models.stats.Stat
 import com.unciv.models.translations.getPlaceholderParameters
 import com.unciv.models.translations.getPlaceholderText
 import com.unciv.ui.victoryscreen.RankingType
+import java.util.*
 import kotlin.collections.HashMap
+import kotlin.collections.HashSet
 import kotlin.collections.LinkedHashMap
 import kotlin.math.max
 import kotlin.math.min
@@ -506,10 +505,58 @@ class CityStateFunctions(val civInfo: CivilizationInfo) {
         }
     }
 
-    /** A city state was attacked. What are its protectors going to do about it??? */
+    /** A city state was attacked. What are its protectors going to do about it??? Also checks for Wary */
     fun cityStateAttacked(attacker: CivilizationInfo) {
         if (!civInfo.isCityState()) return // What are we doing here?
 
+        // We might become wary!
+        if (attacker.isMinorCivWarmonger()) { // They've attacked a lot of city-states
+            civInfo.getDiplomacyManager(attacker).becomeWary()
+        }
+        else if (attacker.isMinorCivAggressor()) { // They've attacked a few
+            if (Random().nextBoolean()) { // 50% chance
+                civInfo.getDiplomacyManager(attacker).becomeWary()
+            }
+        }
+        // Others might become wary!
+        if (attacker.isMinorCivAggressor()) {
+            for (cityState in civInfo.gameInfo.getAliveCityStates()) {
+                if (cityState == civInfo) // Must be a different minor
+                    continue
+                if (cityState.getAllyCiv() == attacker.civName) // Must not be allied to the attacker
+                    continue
+                if (!cityState.knows(attacker)) // Must have met
+                    continue
+
+                var probability: Int
+                if (attacker.isMinorCivWarmonger()) {
+                    // High probability if very aggressive
+                    probability = when (cityState.getProximity(attacker)) {
+                        Proximity.Neighbors -> 100
+                        Proximity.Close     -> 75
+                        Proximity.Far       -> 50
+                        Proximity.Distant   -> 25
+                        else                -> 0
+                    }
+                } else {
+                    // Lower probability if only somewhat aggressive
+                    probability = when (cityState.getProximity(attacker)) {
+                        Proximity.Neighbors -> 50
+                        Proximity.Close     -> 20
+                        else                -> 0
+                    }
+                }
+
+                // Higher probability if already at war
+                if (cityState.isAtWarWith(attacker))
+                    probability += 50
+
+                if (Random().nextInt(100) <= probability) {
+                    cityState.getDiplomacyManager(attacker).becomeWary()
+                }
+            }
+        }
+
         for (protector in civInfo.getProtectorCivs()) {
             if (!protector.knows(attacker)) // Who?
                 continue

core/src/com/unciv/logic/civilization/CivilizationInfo.kt

@@ -10,9 +10,7 @@ import com.unciv.logic.civilization.RuinsManager.RuinsManager
 import com.unciv.logic.civilization.diplomacy.DiplomacyFlags
 import com.unciv.logic.civilization.diplomacy.DiplomacyManager
 import com.unciv.logic.civilization.diplomacy.DiplomaticStatus
-import com.unciv.logic.map.MapUnit
-import com.unciv.logic.map.TileInfo
-import com.unciv.logic.map.UnitMovementAlgorithms
+import com.unciv.logic.map.*
 import com.unciv.logic.trade.TradeEvaluation
 import com.unciv.logic.trade.TradeRequest
 import com.unciv.models.Counter
@@ -34,6 +32,14 @@ import kotlin.math.min
 import kotlin.math.roundToInt
 import kotlin.math.sqrt
 
+enum class Proximity {
+    None, // ie no cities
+    Neighbors,
+    Close,
+    Far,
+    Distant
+}
+
 class CivilizationInfo {
 
     @Transient
@@ -109,6 +115,7 @@ class CivilizationInfo {
     var victoryManager = VictoryManager()
     var ruinsManager = RuinsManager()
     var diplomacy = HashMap<String, DiplomacyManager>()
+    var proximity = HashMap<String, Proximity>()
     var notifications = ArrayList<Notification>()
     val popupAlerts = ArrayList<PopupAlert>()
     private var allyCivName: String? = null
@@ -143,6 +150,9 @@ class CivilizationInfo {
     // default false once we no longer want legacy save-game compatibility
     var hasEverOwnedOriginalCapital: Boolean? = null
 
+    // For Aggressor, Warmonger status
+    private var numMinorCivsAttacked = 0
+
     constructor()
 
     constructor(civName: String) {
@@ -167,6 +177,7 @@ class CivilizationInfo {
         toReturn.allyCivName = allyCivName
         for (diplomacyManager in diplomacy.values.map { it.clone() })
             toReturn.diplomacy[diplomacyManager.otherCivName] = diplomacyManager
+        toReturn.proximity.putAll(proximity)
         toReturn.cities = cities.map { it.clone() }
 
         // This is the only thing that is NOT switched out, which makes it a source of ConcurrentModification errors.
@@ -187,6 +198,7 @@ class CivilizationInfo {
             toReturn.boughtConstructionsWithGloballyIncreasingPrice.putAll(boughtConstructionsWithGloballyIncreasingPrice)
         //
         toReturn.hasEverOwnedOriginalCapital = hasEverOwnedOriginalCapital
+        toReturn.numMinorCivsAttacked = numMinorCivsAttacked
         return toReturn
     }
 
@@ -199,6 +211,9 @@ class CivilizationInfo {
     fun getDiplomacyManager(civInfo: CivilizationInfo) = getDiplomacyManager(civInfo.civName)
     fun getDiplomacyManager(civName: String) = diplomacy[civName]!!
 
+    fun getProximity(civInfo: CivilizationInfo) = getProximity(civInfo.civName)
+    fun getProximity(civName: String) = proximity[civName] ?: Proximity.None
+
     /** Returns only undefeated civs, aka the ones we care about */
     fun getKnownCivs() = diplomacy.values.map { it.otherCiv() }.filter { !it.isDefeated() }
     fun knows(otherCivName: String) = diplomacy.containsKey(otherCivName)
@@ -556,6 +571,9 @@ class CivilizationInfo {
     fun hasTechOrPolicy(techOrPolicyName: String) =
         tech.isResearched(techOrPolicyName) || policies.isAdopted(techOrPolicyName)
 
+    fun isMinorCivAggressor() = numMinorCivsAttacked >= 2
+    fun isMinorCivWarmonger() = numMinorCivsAttacked >= 4
+
     //endregion
 
     //region state-changing functions
@@ -612,6 +630,10 @@ class CivilizationInfo {
         updateDetailedCivResources()
     }
 
+    fun changeMinorCivsAttacked(count: Int) {
+        numMinorCivsAttacked += count
+    }
+
     // implementation in a separate class, to not clog up CivInfo
     fun initialSetCitiesConnectedToCapitalTransients() = transients().updateCitiesConnectedToCapital(true)
     fun updateHasActiveGreatWall() = transients().updateHasActiveGreatWall()
@@ -912,6 +934,81 @@ class CivilizationInfo {
         ).toInt()
     }
 
+    fun updateProximity(otherCiv: CivilizationInfo, preCalculated: Proximity? = null): Proximity {
+        if (otherCiv == this)   return Proximity.None
+        if (preCalculated != null) {
+            // We usually want to update this for a pair of civs at the same time
+            // Since this function *should* be symmetrical for both civs, we can just do it once
+            this.proximity[otherCiv.civName] = preCalculated
+            return preCalculated
+        }
+        if (cities.isEmpty() || otherCiv.cities.isEmpty()) {
+            proximity[otherCiv.civName] = Proximity.None
+            return Proximity.None
+        }
+
+        val mapParams = gameInfo.tileMap.mapParameters
+        var minDistance = 100000 // a long distance
+        var totalDistance = 0
+        var connections = 0
+
+        var proximity = Proximity.None
+
+        for (ourCity in cities) {
+            for (theirCity in otherCiv.cities) {
+                val distance = ourCity.getCenterTile().aerialDistanceTo(theirCity.getCenterTile())
+                totalDistance += distance
+                connections++
+                if (minDistance > distance) minDistance = distance
+            }
+        }
+
+        if (minDistance <= 7) {
+            proximity = Proximity.Neighbors
+        } else if (connections > 0) {
+            val averageDistance = totalDistance / connections
+            val mapFactor = if (mapParams.shape == MapShape.rectangular)
+                (mapParams.mapSize.height + mapParams.mapSize.width) / 2
+                else  (mapParams.mapSize.radius * 3) / 2 // slightly less area than equal size rect
+
+            val closeDistance = ((mapFactor * 25) / 100).coerceIn(10, 20)
+            val farDistance = ((mapFactor * 45) / 100).coerceIn(20, 50)
+
+            proximity = if (minDistance <= 11 && averageDistance <= closeDistance)
+                Proximity.Close
+            else if (averageDistance <= farDistance)
+                Proximity.Far
+            else
+                Proximity.Distant
+        }
+
+        // Check if different continents (unless already max distance, or water map)
+        if (connections > 0 && proximity != Proximity.Distant
+            && !gameInfo.tileMap.isWaterMap()) {
+
+            if (getCapital().getCenterTile().getContinent() != otherCiv.getCapital().getCenterTile().getContinent()) {
+                // Different continents - increase separation by one step
+                proximity = when (proximity) {
+                    Proximity.Far -> Proximity.Distant
+                    Proximity.Close -> Proximity.Far
+                    Proximity.Neighbors -> Proximity.Close
+                    else -> proximity
+                }
+            }
+        }
+
+        // If there aren't many players (left) we can't be that far
+        val numMajors = gameInfo.getAliveMajorCivs().count()
+        if (numMajors <= 2 && proximity > Proximity.Close)
+            proximity = Proximity.Close
+        if (numMajors <= 4 && proximity > Proximity.Far)
+            proximity = Proximity.Far
+
+        this.proximity[otherCiv.civName] = proximity
+
+        return proximity
+    }
+
     //////////////////////// City State wrapper functions ////////////////////////
 
     fun initCityState(ruleset: Ruleset, startingEra: String, unusedMajorCivs: Collection<String>)