From 7d93b24d8cc47a2f60282c20394287bb6d44cded Mon Sep 17 00:00:00 2001 From: Yair Morgenstern Date: Thu, 2 Feb 2023 19:31:41 +0200 Subject: [PATCH] Renamed MapUnit.civInfo -> civ --- core/src/com/unciv/logic/GameInfo.kt | 4 +- .../com/unciv/logic/automation/Automation.kt | 2 +- .../automation/city/ConstructionAutomation.kt | 2 +- .../civilization/BarbarianAutomation.kt | 2 +- .../civilization/BarbarianManager.kt | 2 +- .../logic/automation/unit/BattleHelper.kt | 2 +- .../automation/unit/SpecificUnitAutomation.kt | 106 +++++++++--------- .../logic/automation/unit/UnitAutomation.kt | 86 +++++++------- .../logic/automation/unit/WorkerAutomation.kt | 20 ++-- core/src/com/unciv/logic/battle/Battle.kt | 14 +-- .../com/unciv/logic/battle/BattleDamage.kt | 2 +- .../battle/GreatGeneralImplementation.kt | 8 +- .../unciv/logic/battle/MapUnitCombatant.kt | 6 +- .../city/managers/CityExpansionManager.kt | 2 +- .../diplomacy/CityStateFunctions.kt | 4 +- .../transients/CivInfoTransientCache.kt | 2 +- .../com/unciv/logic/map/MapVisualization.kt | 4 +- core/src/com/unciv/logic/map/TileMap.kt | 2 +- .../com/unciv/logic/map/mapunit/MapUnit.kt | 94 ++++++++-------- .../map/mapunit/UnitMovementAlgorithms.kt | 64 +++++------ .../unciv/logic/map/mapunit/UnitPromotions.kt | 8 +- .../logic/map/mapunit/UnitTurnManager.kt | 34 +++--- .../logic/map/mapunit/UnitUpgradeManager.kt | 20 ++-- core/src/com/unciv/logic/map/tile/Tile.kt | 10 +- core/src/com/unciv/logic/trade/TradeLogic.kt | 2 +- .../models/ruleset/tile/TileImprovement.kt | 2 +- .../com/unciv/models/ruleset/unique/Unique.kt | 2 +- .../ruleset/unique/UniqueTriggerActivation.kt | 12 +- .../com/unciv/models/ruleset/unit/BaseUnit.kt | 2 +- .../ui/cityscreen/CitizenManagementTable.kt | 1 - .../ui/pickerscreens/PromotionPickerScreen.kt | 3 +- .../src/com/unciv/ui/tilegroups/CityButton.kt | 1 - .../com/unciv/ui/tilegroups/TileSetStrings.kt | 6 +- .../com/unciv/ui/tilegroups/WorldTileGroup.kt | 1 - .../ui/tilegroups/layers/TileLayerUnitArt.kt | 4 +- .../ui/tilegroups/layers/TileLayerUnitFlag.kt | 11 +- core/src/com/unciv/ui/utils/UnitGroup.kt | 7 +- .../com/unciv/ui/worldscreen/AlertPopup.kt | 2 +- .../unciv/ui/worldscreen/WorldMapHolder.kt | 14 +-- .../com/unciv/ui/worldscreen/WorldScreen.kt | 8 +- .../unciv/ui/worldscreen/unit/UnitTable.kt | 6 +- .../worldscreen/unit/actions/UnitActions.kt | 64 +++++------ .../unit/actions/UnitActionsGreatPerson.kt | 26 ++--- .../unit/actions/UnitActionsPillage.kt | 8 +- .../unit/actions/UnitActionsReligion.kt | 28 ++--- .../unit/actions/UnitActionsUpgrade.kt | 4 +- .../logic/map/UnitMovementAlgorithmsTests.kt | 14 +-- .../com/unciv/logic/map/VisibilityTests.kt | 4 +- .../com/unciv/testing/SerializationTests.kt | 2 +- 49 files changed, 364 insertions(+), 370 deletions(-) diff --git a/core/src/com/unciv/logic/GameInfo.kt b/core/src/com/unciv/logic/GameInfo.kt index 54964796df..68d0fdeb58 100644 --- a/core/src/com/unciv/logic/GameInfo.kt +++ b/core/src/com/unciv/logic/GameInfo.kt @@ -340,8 +340,8 @@ class GameInfo : IsPartOfGameInfoSerialization, HasGameInfoSerializationVersion val viewableInvisibleTiles = thisPlayer.viewableInvisibleUnitsTiles.map { it.position } val enemyUnitsCloseToTerritory = thisPlayer.viewableTiles .filter { - it.militaryUnit != null && it.militaryUnit!!.civInfo != thisPlayer - && thisPlayer.isAtWarWith(it.militaryUnit!!.civInfo) + it.militaryUnit != null && it.militaryUnit!!.civ != thisPlayer + && thisPlayer.isAtWarWith(it.militaryUnit!!.civ) && (it.getOwner() == thisPlayer || it.neighbors.any { neighbor -> neighbor.getOwner() == thisPlayer } && (!it.militaryUnit!!.isInvisible(thisPlayer) || viewableInvisibleTiles.contains(it.position))) } diff --git a/core/src/com/unciv/logic/automation/Automation.kt b/core/src/com/unciv/logic/automation/Automation.kt index 822ccdbff6..dbf050a591 100644 --- a/core/src/com/unciv/logic/automation/Automation.kt +++ b/core/src/com/unciv/logic/automation/Automation.kt @@ -149,7 +149,7 @@ object Automation { findWaterConnectedCitiesAndEnemies.stepToEnd() removeShips = findWaterConnectedCitiesAndEnemies.getReachedTiles().none { (it.isCityCenter() && it.getOwner() != city.civ) - || (it.militaryUnit != null && it.militaryUnit!!.civInfo != city.civ) + || (it.militaryUnit != null && it.militaryUnit!!.civ != city.civ) } // there is absolutely no reason for you to make water units on this body of water. } diff --git a/core/src/com/unciv/logic/automation/city/ConstructionAutomation.kt b/core/src/com/unciv/logic/automation/city/ConstructionAutomation.kt index 1a4ecc67de..8fa1368d3f 100644 --- a/core/src/com/unciv/logic/automation/city/ConstructionAutomation.kt +++ b/core/src/com/unciv/logic/automation/city/ConstructionAutomation.kt @@ -138,7 +138,7 @@ class ConstructionAutomation(val cityConstructions: CityConstructions){ val civilianUnit = cityInfo.getCenterTile().civilianUnit if (civilianUnit != null && civilianUnit.hasUnique(UniqueType.FoundCity) - && cityInfo.getCenterTile().getTilesInDistance(5).none { it.militaryUnit?.civInfo == civInfo }) + && cityInfo.getCenterTile().getTilesInDistance(5).none { it.militaryUnit?.civ == civInfo }) modifier = 5f // there's a settler just sitting here, doing nothing - BAD if (civInfo.playerType == PlayerType.Human) modifier /= 2 // Players prefer to make their own unit choices usually diff --git a/core/src/com/unciv/logic/automation/civilization/BarbarianAutomation.kt b/core/src/com/unciv/logic/automation/civilization/BarbarianAutomation.kt index c53f15b229..5545b798ec 100644 --- a/core/src/com/unciv/logic/automation/civilization/BarbarianAutomation.kt +++ b/core/src/com/unciv/logic/automation/civilization/BarbarianAutomation.kt @@ -25,7 +25,7 @@ class BarbarianAutomation(val civInfo: Civilization) { // 1 - Stay on current encampment if (unit.currentTile.improvement == Constants.barbarianEncampment) return - val campTiles = unit.civInfo.gameInfo.barbarians.camps.map { unit.civInfo.gameInfo.tileMap[it.key] } + val campTiles = unit.civ.gameInfo.barbarians.camps.map { unit.civ.gameInfo.tileMap[it.key] } .sortedBy { unit.currentTile.aerialDistanceTo(it) } val bestCamp = campTiles.firstOrNull { it.civilianUnit == null && unit.movement.canReach(it)} if (bestCamp != null) diff --git a/core/src/com/unciv/logic/automation/civilization/BarbarianManager.kt b/core/src/com/unciv/logic/automation/civilization/BarbarianManager.kt index d2ba846605..98797d82ee 100644 --- a/core/src/com/unciv/logic/automation/civilization/BarbarianManager.kt +++ b/core/src/com/unciv/logic/automation/civilization/BarbarianManager.kt @@ -225,7 +225,7 @@ class Encampment() : IsPartOfGameInfoSerialization { // Too many barbarians around already? val barbarianCiv = gameInfo.getBarbarianCivilization() - if (tile.getTilesInDistance(4).count { it.militaryUnit?.civInfo == barbarianCiv } > 2) + if (tile.getTilesInDistance(4).count { it.militaryUnit?.civ == barbarianCiv } > 2) return false val canSpawnBoats = gameInfo.turns > 30 diff --git a/core/src/com/unciv/logic/automation/unit/BattleHelper.kt b/core/src/com/unciv/logic/automation/unit/BattleHelper.kt index 3bfa4724b4..3c9eb76845 100644 --- a/core/src/com/unciv/logic/automation/unit/BattleHelper.kt +++ b/core/src/com/unciv/logic/automation/unit/BattleHelper.kt @@ -92,7 +92,7 @@ object BattleHelper { private fun checkTile(unit: MapUnit, tile: Tile, tilesToCheck: List?): Boolean { if (!containsAttackableEnemy(tile, MapUnitCombatant(unit))) return false - if (tile !in (tilesToCheck ?: unit.civInfo.viewableTiles)) return false + if (tile !in (tilesToCheck ?: unit.civ.viewableTiles)) return false val mapCombatant = Battle.getMapCombatantOfTile(tile) return (!unit.baseUnit.isMelee() || mapCombatant !is MapUnitCombatant || !mapCombatant.unit.isCivilian() || unit.movement.canPassThrough(tile)) } diff --git a/core/src/com/unciv/logic/automation/unit/SpecificUnitAutomation.kt b/core/src/com/unciv/logic/automation/unit/SpecificUnitAutomation.kt index 72be7c9099..6670b7c69c 100644 --- a/core/src/com/unciv/logic/automation/unit/SpecificUnitAutomation.kt +++ b/core/src/com/unciv/logic/automation/unit/SpecificUnitAutomation.kt @@ -27,10 +27,10 @@ object SpecificUnitAutomation { tile.isWater && tile.improvement == null && tile.hasViewableResource(civInfo) fun automateWorkBoats(unit: MapUnit) { - val closestReachableResource = unit.civInfo.cities.asSequence() + val closestReachableResource = unit.civ.cities.asSequence() .flatMap { city -> city.getWorkableTiles() } .filter { - hasWorkableSeaResource(it, unit.civInfo) + hasWorkableSeaResource(it, unit.civ) && (unit.currentTile == it || unit.movement.canMoveTo(it)) } .sortedBy { it.aerialDistanceTo(unit.currentTile) } @@ -60,16 +60,16 @@ object SpecificUnitAutomation { fun automateCitadelPlacer(unit: MapUnit): Boolean { // try to revenge and capture their tiles - val enemyCities = unit.civInfo.getKnownCivs() - .filter { unit.civInfo.getDiplomacyManager(it).hasModifier(DiplomaticModifiers.StealingTerritory) } + val enemyCities = unit.civ.getKnownCivs() + .filter { unit.civ.getDiplomacyManager(it).hasModifier(DiplomaticModifiers.StealingTerritory) } .flatMap { it.cities }.asSequence() // find the suitable tiles (or their neighbours) val tileToSteal = enemyCities.flatMap { it.getTiles() } // City tiles - .filter { it.neighbors.any { tile -> tile.getOwner() != unit.civInfo } } // Edge city tiles + .filter { it.neighbors.any { tile -> tile.getOwner() != unit.civ } } // Edge city tiles .flatMap { it.neighbors.asSequence() } // Neighbors of edge city tiles .filter { - it in unit.civInfo.viewableTiles // we can see them - && it.neighbors.any { tile -> tile.getOwner() == unit.civInfo }// they are close to our borders + it in unit.civ.viewableTiles // we can see them + && it.neighbors.any { tile -> tile.getOwner() == unit.civ }// they are close to our borders } .sortedBy { // get closest tiles @@ -90,7 +90,7 @@ object SpecificUnitAutomation { } // try to build a citadel for defensive purposes - if (WorkerAutomation.evaluateFortPlacement(unit.currentTile, unit.civInfo, true)) { + if (WorkerAutomation.evaluateFortPlacement(unit.currentTile, unit.civ, true)) { UnitActions.getImprovementConstructionActions(unit, unit.currentTile).firstOrNull()?.action?.invoke() return true } @@ -104,7 +104,7 @@ object SpecificUnitAutomation { unit.movement.canMoveTo(it) && unit.movement.canReach(it) } - val cityToGarrison = unit.civInfo.cities.asSequence().map { it.getCenterTile() } + val cityToGarrison = unit.civ.cities.asSequence().map { it.getCenterTile() } .sortedBy { it.aerialDistanceTo(unit.currentTile) } .firstOrNull { reachableTest(it) } ?: return @@ -117,7 +117,7 @@ object SpecificUnitAutomation { val tileForCitadel = cityToGarrison.getTilesInDistanceRange(3..4) .firstOrNull { reachableTest(it) && - WorkerAutomation.evaluateFortPlacement(it, unit.civInfo, true) + WorkerAutomation.evaluateFortPlacement(it, unit.civ, true) } if (tileForCitadel == null) { unit.movement.headTowards(cityToGarrison) @@ -150,17 +150,17 @@ object SpecificUnitAutomation { } fun automateSettlerActions(unit: MapUnit) { - val modConstants = unit.civInfo.gameInfo.ruleSet.modOptions.constants + val modConstants = unit.civ.gameInfo.ruleSet.modOptions.constants if (unit.getTile().militaryUnit == null // Don't move until you're accompanied by a military unit - && !unit.civInfo.isCityState() // ..unless you're a city state that was unable to settle its city on turn 1 + && !unit.civ.isCityState() // ..unless you're a city state that was unable to settle its city on turn 1 && unit.getDamageFromTerrain() < unit.health) return // Also make sure we won't die waiting val tilesNearCities = sequence { - for (city in unit.civInfo.gameInfo.getCities()) { + for (city in unit.civ.gameInfo.getCities()) { val center = city.getCenterTile() - if (unit.civInfo.knows(city.civ) && + if (unit.civ.knows(city.civ) && // If the CITY OWNER knows that the UNIT OWNER agreed not to settle near them - city.civ.getDiplomacyManager(unit.civInfo).hasFlag(DiplomacyFlags.AgreedToNotSettleNearUs) + city.civ.getDiplomacyManager(unit.civ).hasFlag(DiplomacyFlags.AgreedToNotSettleNearUs) ) { yieldAll(center.getTilesInDistance(6)) continue @@ -176,29 +176,29 @@ object SpecificUnitAutomation { // This is to improve performance - instead of ranking each tile in the area up to 19 times, do it once. val nearbyTileRankings = unit.getTile().getTilesInDistance(7) - .associateBy({ it }, { Automation.rankTile(it, unit.civInfo) }) + .associateBy({ it }, { Automation.rankTile(it, unit.civ) }) - val distanceFromHome = if (unit.civInfo.cities.isEmpty()) 0 - else unit.civInfo.cities.minOf { it.getCenterTile().aerialDistanceTo(unit.getTile()) } + val distanceFromHome = if (unit.civ.cities.isEmpty()) 0 + else unit.civ.cities.minOf { it.getCenterTile().aerialDistanceTo(unit.getTile()) } val range = max(1, min(5, 8 - distanceFromHome)) // Restrict vision when far from home to avoid death marches val possibleCityLocations = unit.getTile().getTilesInDistance(range) .filter { val tileOwner = it.getOwner() - it.isLand && !it.isImpassible() && (tileOwner == null || tileOwner == unit.civInfo) // don't allow settler to settle inside other civ's territory + it.isLand && !it.isImpassible() && (tileOwner == null || tileOwner == unit.civ) // don't allow settler to settle inside other civ's territory && (unit.currentTile == it || unit.movement.canMoveTo(it)) && it !in tilesNearCities }.toList() - val luxuryResourcesInCivArea = unit.civInfo.cities.asSequence() + val luxuryResourcesInCivArea = unit.civ.cities.asSequence() .flatMap { it.getTiles().asSequence() }.filter { it.resource != null } .map { it.tileResource }.filter { it.resourceType == ResourceType.Luxury } .distinct() - if (unit.civInfo.gameInfo.turns == 0) { // Special case, we want AI to settle in place on turn 1. + if (unit.civ.gameInfo.turns == 0) { // Special case, we want AI to settle in place on turn 1. val foundCityAction = UnitActions.getFoundCityAction(unit, unit.getTile()) // Depending on era and difficulty we might start with more than one settler. In that case settle the one with the best location - val otherSettlers = unit.civInfo.units.getCivUnits().filter { it.currentMovement > 0 && it.baseUnit == unit.baseUnit } + val otherSettlers = unit.civ.units.getCivUnits().filter { it.currentMovement > 0 && it.baseUnit == unit.baseUnit } if(foundCityAction?.action != null && otherSettlers.none { rankTileAsCityCenter(it.getTile(), nearbyTileRankings, emptySequence()) > rankTileAsCityCenter(unit.getTile(), nearbyTileRankings, emptySequence()) @@ -227,7 +227,7 @@ object SpecificUnitAutomation { .getTilesAtDistance(city.civ.gameInfo.ruleSet.modOptions.constants.minimalCityDistance + 1) .count { it.canBeSettled() && (it.getOwner() == null || it.getOwner() == city.civ ) } - val frontierCity = unit.civInfo.cities.maxByOrNull { getFrontierScore(it) } + val frontierCity = unit.civ.cities.maxByOrNull { getFrontierScore(it) } if (frontierCity != null && getFrontierScore(frontierCity) > 0 && unit.movement.canReach(frontierCity.getCenterTile())) unit.movement.headTowards(frontierCity.getCenterTile()) if (UnitAutomation.tryExplore(unit)) return // try to find new areas @@ -251,11 +251,11 @@ object SpecificUnitAutomation { val improvementBuildingUniques = unit.getMatchingUniques(UniqueType.ConstructImprovementConsumingUnit) val improvementName = improvementBuildingUniques.first().params[0] - val improvement = unit.civInfo.gameInfo.ruleSet.tileImprovements[improvementName] + val improvement = unit.civ.gameInfo.ruleSet.tileImprovements[improvementName] ?: return val relatedStat = improvement.maxByOrNull { it.value }?.key ?: Stat.Culture - val citiesByStatBoost = unit.civInfo.cities.sortedByDescending { + val citiesByStatBoost = unit.civ.cities.sortedByDescending { it.cityStats.statPercentBonusTree.totalStats[relatedStat] } @@ -264,7 +264,7 @@ object SpecificUnitAutomation { val applicableTiles = city.getWorkableTiles().filter { it.isLand && it.resource == null && !it.isCityCenter() && (unit.currentTile == it || unit.movement.canMoveTo(it)) - && !it.containsGreatImprovement() && it.improvementFunctions.canBuildImprovement(improvement, unit.civInfo) + && !it.containsGreatImprovement() && it.improvementFunctions.canBuildImprovement(improvement, unit.civ) } if (applicableTiles.none()) continue @@ -281,7 +281,7 @@ object SpecificUnitAutomation { val chosenTile = applicableTiles.sortedByDescending { Automation.rankTile( it, - unit.civInfo + unit.civ ) } .firstOrNull { unit.movement.canReach(it) } @@ -298,8 +298,8 @@ object SpecificUnitAutomation { } fun automateAddInCapital(unit: MapUnit) { - if (unit.civInfo.getCapital() == null) return // safeguard - val capitalTile = unit.civInfo.getCapital()!!.getCenterTile() + if (unit.civ.getCapital() == null) return // safeguard + val capitalTile = unit.civ.getCapital()!!.getCenterTile() if (unit.movement.canReach(capitalTile)) unit.movement.headTowards(capitalTile) if (unit.getTile() == capitalTile) { @@ -309,19 +309,19 @@ object SpecificUnitAutomation { } fun automateMissionary(unit: MapUnit) { - if (unit.religion != unit.civInfo.religionManager.religion?.name || unit.religion == null) + if (unit.religion != unit.civ.religionManager.religion?.name || unit.religion == null) return unit.disband() - val ourCitiesWithoutReligion = unit.civInfo.cities.filter { - it.religion.getMajorityReligion() != unit.civInfo.religionManager.religion + val ourCitiesWithoutReligion = unit.civ.cities.filter { + it.religion.getMajorityReligion() != unit.civ.religionManager.religion } val city = if (ourCitiesWithoutReligion.any()) ourCitiesWithoutReligion.minByOrNull { it.getCenterTile().aerialDistanceTo(unit.getTile()) } - else unit.civInfo.gameInfo.getCities().asSequence() - .filter { it.religion.getMajorityReligion() != unit.civInfo.religionManager.religion } - .filter { it.civ.knows(unit.civInfo) && !it.civ.isAtWarWith(unit.civInfo) } + else unit.civ.gameInfo.getCities().asSequence() + .filter { it.religion.getMajorityReligion() != unit.civ.religionManager.religion } + .filter { it.civ.knows(unit.civ) && !it.civ.isAtWarWith(unit.civ) } .filterNot { it.religion.isProtectedByInquisitor(unit.religion) } .minByOrNull { it.getCenterTile().aerialDistanceTo(unit.getTile()) } @@ -333,24 +333,24 @@ object SpecificUnitAutomation { unit.movement.headTowards(destination) - if (unit.getTile() in city.getTiles() && unit.civInfo.religionManager.maySpreadReligionNow(unit)) { + if (unit.getTile() in city.getTiles() && unit.civ.religionManager.maySpreadReligionNow(unit)) { doReligiousAction(unit, unit.getTile()) } } fun automateInquisitor(unit: MapUnit) { - val civReligion = unit.civInfo.religionManager.religion + val civReligion = unit.civ.religionManager.religion if (unit.religion != civReligion?.name || unit.religion == null) return unit.disband() // No need to keep a unit we can't use, as it only blocks religion spreads of religions other that its own - val holyCity = unit.civInfo.religionManager.getHolyCity() + val holyCity = unit.civ.religionManager.getHolyCity() val cityToConvert = determineBestInquisitorCityToConvert(unit) // Also returns null if the inquisitor can't convert cities val pressureDeficit = if (cityToConvert == null) 0 else cityToConvert.religion.getPressureDeficit(civReligion?.name) - val citiesToProtect = unit.civInfo.cities.asSequence() + val citiesToProtect = unit.civ.cities.asSequence() .filter { it.religion.getMajorityReligion() == civReligion } // We only look at cities that are not currently protected or are protected by us .filter { !it.religion.isProtectedByInquisitor() || unit.getTile() in it.getCenterTile().getTilesInDistance(1) } @@ -397,29 +397,29 @@ object SpecificUnitAutomation { private fun determineBestInquisitorCityToConvert( unit: MapUnit, ): City? { - if (unit.religion != unit.civInfo.religionManager.religion?.name || !unit.canDoReligiousAction(Constants.removeHeresy)) + if (unit.religion != unit.civ.religionManager.religion?.name || !unit.canDoReligiousAction(Constants.removeHeresy)) return null - val holyCity = unit.civInfo.religionManager.getHolyCity() - if (holyCity != null && holyCity.religion.getMajorityReligion() != unit.civInfo.religionManager.religion!!) + val holyCity = unit.civ.religionManager.getHolyCity() + if (holyCity != null && holyCity.religion.getMajorityReligion() != unit.civ.religionManager.religion!!) return holyCity - val blockedHolyCity = unit.civInfo.cities.firstOrNull { it.religion.isBlockedHolyCity && it.religion.religionThisIsTheHolyCityOf == unit.religion } + val blockedHolyCity = unit.civ.cities.firstOrNull { it.religion.isBlockedHolyCity && it.religion.religionThisIsTheHolyCityOf == unit.religion } if (blockedHolyCity != null) return blockedHolyCity - return unit.civInfo.cities.asSequence() + return unit.civ.cities.asSequence() .filter { it.religion.getMajorityReligion() != null } - .filter { it.religion.getMajorityReligion()!! != unit.civInfo.religionManager.religion } + .filter { it.religion.getMajorityReligion()!! != unit.civ.religionManager.religion } // Don't go if it takes too long .filter { it.getCenterTile().aerialDistanceTo(unit.currentTile) <= 20 } - .maxByOrNull { it.religion.getPressureDeficit(unit.civInfo.religionManager.religion?.name) } + .maxByOrNull { it.religion.getPressureDeficit(unit.civ.religionManager.religion?.name) } } fun automateFighter(unit: MapUnit) { val tilesInRange = unit.currentTile.getTilesInDistance(unit.getRange()) val enemyAirUnitsInRange = tilesInRange - .flatMap { it.airUnits.asSequence() }.filter { it.civInfo.isAtWarWith(unit.civInfo) } + .flatMap { it.airUnits.asSequence() }.filter { it.civ.isAtWarWith(unit.civ) } if (enemyAirUnitsInRange.any()) return // we need to be on standby in case they attack @@ -435,7 +435,7 @@ object SpecificUnitAutomation { key.getTilesInDistance(unit.getMaxMovementForAirUnits()) .count { val firstAirUnit = it.airUnits.firstOrNull() - firstAirUnit != null && firstAirUnit.civInfo.isAtWarWith(unit.civInfo) + firstAirUnit != null && firstAirUnit.civ.isAtWarWith(unit.civ) } } @@ -485,16 +485,16 @@ object SpecificUnitAutomation { for (tile in tilesInRange) { // For now AI will only use nukes against cities because in all honesty that's the best use for them. if (tile.isCityCenter() - && tile.getOwner()!!.isAtWarWith(unit.civInfo) + && tile.getOwner()!!.isAtWarWith(unit.civ) && tile.getCity()!!.health > tile.getCity()!!.getMaxHealth() / 2 && Battle.mayUseNuke(MapUnitCombatant(unit), tile)) { val blastRadius = unit.getMatchingUniques(UniqueType.BlastRadius) .firstOrNull()?.params?.get(0)?.toInt() ?: 2 val tilesInBlastRadius = tile.getTilesInDistance(blastRadius) val civsInBlastRadius = tilesInBlastRadius.mapNotNull { it.getOwner() } + - tilesInBlastRadius.mapNotNull { it.getFirstUnit()?.civInfo } + tilesInBlastRadius.mapNotNull { it.getFirstUnit()?.civ } // Don't nuke if it means we will be declaring war on someone! - if (civsInBlastRadius.none { it != unit.civInfo && !it.isAtWarWith(unit.civInfo) }) { + if (civsInBlastRadius.none { it != unit.civ && !it.isAtWarWith(unit.civ) }) { Battle.NUKE(MapUnitCombatant(unit), tile) return } @@ -515,7 +515,7 @@ object SpecificUnitAutomation { .filter { unit.movement.canMoveTo(it) } for (city in immediatelyReachableCities) if (city.getTilesInDistance(unit.getRange()) - .any { it.isCityCenter() && it.getOwner()!!.isAtWarWith(unit.civInfo) } + .any { it.isCityCenter() && it.getOwner()!!.isAtWarWith(unit.civ) } ) { unit.movement.moveToTile(city) return @@ -550,7 +550,7 @@ object SpecificUnitAutomation { fun foundReligion(unit: MapUnit) { val cityToFoundReligionAt = if (unit.getTile().isCityCenter() && !unit.getTile().owningCity!!.isHolyCity()) unit.getTile().owningCity - else unit.civInfo.cities.firstOrNull { + else unit.civ.cities.firstOrNull { !it.isHolyCity() && unit.movement.canMoveTo(it.getCenterTile()) && unit.movement.canReach(it.getCenterTile()) diff --git a/core/src/com/unciv/logic/automation/unit/UnitAutomation.kt b/core/src/com/unciv/logic/automation/unit/UnitAutomation.kt index 213bbe6fc4..c585b65cfd 100644 --- a/core/src/com/unciv/logic/automation/unit/UnitAutomation.kt +++ b/core/src/com/unciv/logic/automation/unit/UnitAutomation.kt @@ -27,8 +27,8 @@ object UnitAutomation { private fun isGoodTileToExplore(unit: MapUnit, tile: Tile): Boolean { return unit.movement.canMoveTo(tile) && (tile.getOwner() == null || !tile.getOwner()!!.isCityState()) - && tile.neighbors.any { !unit.civInfo.hasExplored(it) } - && (!unit.civInfo.isCityState() || tile.neighbors.any { it.getOwner() == unit.civInfo }) // Don't want city-states exploring far outside their borders + && tile.neighbors.any { !unit.civ.hasExplored(it) } + && (!unit.civ.isCityState() || tile.neighbors.any { it.getOwner() == unit.civ }) // Don't want city-states exploring far outside their borders && unit.getDamageFromTerrain(tile) <= 0 // Don't take unnecessary damage && tile.getTilesInDistance(3) // don't walk in range of enemy units .none { tile_it -> containsEnemyMilitaryUnit(unit, tile_it)} @@ -58,7 +58,7 @@ object UnitAutomation { } private fun tryGoToRuinAndEncampment(unit: MapUnit): Boolean { - if (!unit.civInfo.isMajorCiv()) return false // barbs don't have anything to do in ruins + if (!unit.civ.isMajorCiv()) return false // barbs don't have anything to do in ruins val tileWithRuinOrEncampment = unit.viewableTiles .firstOrNull { @@ -74,7 +74,7 @@ object UnitAutomation { // "Fog busting" is a strategy where you put your units slightly outside your borders to discourage barbarians from spawning private fun tryFogBust(unit: MapUnit): Boolean { - if (!Automation.afraidOfBarbarians(unit.civInfo)) return false // Not if we're not afraid + if (!Automation.afraidOfBarbarians(unit.civ)) return false // Not if we're not afraid val reachableTilesThisTurn = unit.movement.getDistanceToTiles().keys.filter { isGoodTileForFogBusting(unit, it) } @@ -96,8 +96,8 @@ object UnitAutomation { return unit.movement.canMoveTo(tile) && tile.getOwner() == null && tile.neighbors.all { it.getOwner() == null } - && unit.civInfo.hasExplored(tile) - && tile.getTilesInDistance(2).any { it.getOwner() == unit.civInfo } + && unit.civ.hasExplored(tile) + && tile.getTilesInDistance(2).any { it.getOwner() == unit.civ } && unit.getDamageFromTerrain(tile) <= 0 && unit.movement.canReach(tile) // expensive, evaluate last } @@ -111,7 +111,7 @@ object UnitAutomation { val reachableTilesMaxWalkingDistance = reachableTiles .filter { it.value.totalDistance == unit.currentMovement && unit.getDamageFromTerrain(it.key) <= 0 // Don't end turn on damaging terrain for no good reason - && (!stayInTerritory || it.key.getOwner() == unit.civInfo) } + && (!stayInTerritory || it.key.getOwner() == unit.civ) } if (reachableTilesMaxWalkingDistance.any()) unit.movement.moveToTile(reachableTilesMaxWalkingDistance.toList().random().first) else if (reachableTiles.any()) unit.movement.moveToTile(reachableTiles.keys.random()) } @@ -119,11 +119,11 @@ object UnitAutomation { internal fun tryUpgradeUnit(unit: MapUnit): Boolean { if (unit.baseUnit.upgradesTo == null) return false val upgradedUnit = unit.upgrade.getUnitToUpgradeTo() - if (!upgradedUnit.isBuildable(unit.civInfo)) return false // for resource reasons, usually + if (!upgradedUnit.isBuildable(unit.civ)) return false // for resource reasons, usually if (upgradedUnit.getResourceRequirements().keys.any { !unit.baseUnit.requiresResource(it) }) { // The upgrade requires new resource types, so check if we are willing to invest them - if (!Automation.allowSpendingResource(unit.civInfo, upgradedUnit)) return false + if (!Automation.allowSpendingResource(unit.civ, upgradedUnit)) return false } val upgradeAction = UnitActionsUpgrade.getUpgradeAction(unit) @@ -134,7 +134,7 @@ object UnitAutomation { } fun automateUnitMoves(unit: MapUnit) { - if (unit.civInfo.isBarbarian()) + if (unit.civ.isBarbarian()) throw IllegalStateException("Barbarians is not allowed here.") // Might die next turn - move! @@ -203,7 +203,7 @@ object UnitAutomation { if (tryFogBust(unit)) return // Idle CS units should wander so they don't obstruct players so much - if (unit.civInfo.isCityState()) + if (unit.civ.isCityState()) wander(unit, stayInTerritory = true) } @@ -212,7 +212,7 @@ object UnitAutomation { if (unit.currentTile.isCityCenter() && unit.currentTile.getCity()!!.isCapital() && !unit.hasUnique(UniqueType.AddInCapital) - && unit.civInfo.units.getCivUnits().any { unit.hasUnique(UniqueType.AddInCapital) }){ + && unit.civ.units.getCivUnits().any { unit.hasUnique(UniqueType.AddInCapital) }){ // First off get out of the way, then decide if you actually want to do something else val tilesCanMoveTo = unit.movement.getDistanceToTiles() .filter { unit.movement.canMoveTo(it.key) } @@ -227,14 +227,14 @@ object UnitAutomation { return WorkerAutomation.automateWorkerAction(unit) if (unit.hasUnique(UniqueType.MayFoundReligion) - && unit.civInfo.religionManager.religionState < ReligionState.Religion - && unit.civInfo.religionManager.mayFoundReligionAtAll(unit) + && unit.civ.religionManager.religionState < ReligionState.Religion + && unit.civ.religionManager.mayFoundReligionAtAll(unit) ) return SpecificUnitAutomation.foundReligion(unit) if (unit.hasUnique(UniqueType.MayEnhanceReligion) - && unit.civInfo.religionManager.religionState < ReligionState.EnhancedReligion - && unit.civInfo.religionManager.mayEnhanceReligionAtAll(unit) + && unit.civ.religionManager.religionState < ReligionState.EnhancedReligion + && unit.civ.religionManager.mayEnhanceReligionAtAll(unit) ) return SpecificUnitAutomation.enhanceReligion(unit) @@ -256,7 +256,7 @@ object UnitAutomation { if (unit.hasCitadelPlacementUnique || unit.hasStrengthBonusInRadiusUnique) return SpecificUnitAutomation.automateGreatGeneralFallback(unit) - if (unit.civInfo.religionManager.maySpreadReligionAtAll(unit)) + if (unit.civ.religionManager.maySpreadReligionAtAll(unit)) return SpecificUnitAutomation.automateMissionary(unit) if (unit.hasUnique(UniqueType.PreventSpreadingReligion) || unit.canDoReligiousAction(Constants.removeHeresy)) @@ -281,9 +281,9 @@ object UnitAutomation { private fun tryHeadTowardsEncampment(unit: MapUnit): Boolean { if (unit.hasUnique(UniqueType.SelfDestructs)) return false // don't use single-use units against barbarians... - val knownEncampments = unit.civInfo.gameInfo.tileMap.values.asSequence() - .filter { it.improvement == Constants.barbarianEncampment && unit.civInfo.hasExplored(it) } - val cities = unit.civInfo.cities + val knownEncampments = unit.civ.gameInfo.tileMap.values.asSequence() + .filter { it.improvement == Constants.barbarianEncampment && unit.civ.hasExplored(it) } + val cities = unit.civ.cities val encampmentsCloseToCities = knownEncampments .filter { cities.any { city -> city.getCenterTile().aerialDistanceTo(it) < 6 } } .sortedBy { it.aerialDistanceTo(unit.currentTile) } @@ -304,13 +304,13 @@ object UnitAutomation { val currentUnitTile = unit.getTile() val nearbyRangedEnemyUnits = unit.currentTile.getTilesInDistance(3) - .flatMap { tile -> tile.getUnits().filter { unit.civInfo.isAtWarWith(it.civInfo) } } + .flatMap { tile -> tile.getUnits().filter { unit.civ.isAtWarWith(it.civ) } } val tilesInRangeOfAttack = nearbyRangedEnemyUnits .flatMap { it.getTile().getTilesInDistance(it.getRange()) } val tilesWithinBombardmentRange = unit.currentTile.getTilesInDistance(3) - .filter { it.isCityCenter() && it.getCity()!!.civ.isAtWarWith(unit.civInfo) } + .filter { it.isCityCenter() && it.getCity()!!.civ.isAtWarWith(unit.civ) } .flatMap { it.getTilesInDistance(it.getCity()!!.range) } val tilesWithTerrainDamage = unit.currentTile.getTilesInDistance(3) @@ -325,7 +325,7 @@ object UnitAutomation { if (tilesByHealingRate.keys.all { it == 0 }) { // We can't heal here at all! We're probably embarked if (!unit.baseUnit.movesLikeAirUnits()) { - val reachableCityTile = unit.civInfo.cities.asSequence() + val reachableCityTile = unit.civ.cities.asSequence() .map { it.getCenterTile() } .sortedBy { it.aerialDistanceTo(unit.currentTile) } .firstOrNull { unit.movement.canReach(it) } @@ -334,7 +334,7 @@ object UnitAutomation { return true } // Try to get closer to an empty city - val emptyCities = unit.civInfo.cities.asSequence() + val emptyCities = unit.civ.cities.asSequence() .map { it.getCenterTile() } .filter { unit.movement.canMoveTo(it) } if (emptyCities.none()) return false // Nowhere to move to heal @@ -370,7 +370,7 @@ object UnitAutomation { .filter { it.value.totalDistance < unit.currentMovement }.keys .filter { unit.movement.canMoveTo(it) && UnitActions.canPillage(unit, it) && (it.canPillageTileImprovement() - || (it.canPillageRoad() && it.getRoadOwner() != null && unit.civInfo.isAtWarWith(it.getRoadOwner()!!)))} + || (it.canPillageRoad() && it.getRoadOwner() != null && unit.civ.isAtWarWith(it.getRoadOwner()!!)))} if (tilesThatCanWalkToAndThenPillage.isEmpty()) return false val tileToPillage = tilesThatCanWalkToAndThenPillage.maxByOrNull { it.getDefensiveBonus() }!! @@ -424,7 +424,7 @@ object UnitAutomation { } private fun tryAccompanySettlerOrGreatPerson(unit: MapUnit): Boolean { - val settlerOrGreatPersonToAccompany = unit.civInfo.units.getCivUnits() + val settlerOrGreatPersonToAccompany = unit.civ.units.getCivUnits() .firstOrNull { val tile = it.currentTile it.isCivilian() && @@ -437,10 +437,10 @@ object UnitAutomation { } private fun tryHeadTowardsOurSiegedCity(unit: MapUnit): Boolean { - val siegedCities = unit.civInfo.cities + val siegedCities = unit.civ.cities .asSequence() .filter { - unit.civInfo == it.civ && + unit.civ == it.civ && it.health < it.getMaxHealth() * 0.75 } //Weird health issues and making sure that not all forces move to good defenses @@ -460,15 +460,15 @@ object UnitAutomation { } fun tryHeadTowardsEnemyCity(unit: MapUnit): Boolean { - if (unit.civInfo.cities.isEmpty()) return false + if (unit.civ.cities.isEmpty()) return false // only focus on *attacking* 1 enemy at a time otherwise you'll lose on both fronts - val enemies = unit.civInfo.getKnownCivs() - .filter { unit.civInfo.isAtWarWith(it) && it.cities.isNotEmpty() } + val enemies = unit.civ.getKnownCivs() + .filter { unit.civ.isAtWarWith(it) && it.cities.isNotEmpty() } val closestEnemyCity = enemies - .mapNotNull { NextTurnAutomation.getClosestCities(unit.civInfo, it) } + .mapNotNull { NextTurnAutomation.getClosestCities(unit.civ, it) } .minByOrNull { it.aerialDistance }?.city2 ?: return false // no attackable cities found @@ -516,7 +516,7 @@ object UnitAutomation { val ourUnitsAroundEnemyCity = closestReachableEnemyCity.getTilesInDistance(6) .flatMap { it.getUnits() } - .filter { it.isMilitary() && it.civInfo == unit.civInfo } + .filter { it.isMilitary() && it.civ == unit.civ } val city = closestReachableEnemyCity.getCity()!! val cityCombatant = CityCombatant(city) @@ -548,7 +548,7 @@ object UnitAutomation { } fun tryEnterOwnClosestCity(unit: MapUnit): Boolean { - val closestCity = unit.civInfo.cities + val closestCity = unit.civ.cities .asSequence() .sortedBy { it.getCenterTile().aerialDistanceTo(unit.getTile()) } .firstOrNull { unit.movement.canReach(it.getCenterTile()) } @@ -591,11 +591,11 @@ object UnitAutomation { } private fun tryTakeBackCapturedCity(unit: MapUnit): Boolean { - var capturedCities = unit.civInfo.getKnownCivs().asSequence() + var capturedCities = unit.civ.getKnownCivs().asSequence() .flatMap { it.cities.asSequence() } .filter { - unit.civInfo.isAtWarWith(it.civ) && - unit.civInfo.civName == it.foundingCiv && + unit.civ.isAtWarWith(it.civ) && + unit.civ.civName == it.foundingCiv && it.isInResistance() && it.health < it.getMaxHealth() } //Most likely just been captured @@ -618,7 +618,7 @@ object UnitAutomation { private fun tryGarrisoningUnit(unit: MapUnit): Boolean { if (unit.baseUnit.isMelee() || unit.baseUnit.isWaterUnit()) return false // don't garrison melee units, they're not that good at it - val citiesWithoutGarrison = unit.civInfo.cities.filter { + val citiesWithoutGarrison = unit.civ.cities.filter { val centerTile = it.getCenterTile() centerTile.militaryUnit == null && unit.movement.canMoveTo(centerTile) @@ -626,14 +626,14 @@ object UnitAutomation { fun isCityThatNeedsDefendingInWartime(city: City): Boolean { if (city.health < city.getMaxHealth()) return true // this city is under attack! - for (enemyCivCity in unit.civInfo.diplomacy.values + for (enemyCivCity in unit.civ.diplomacy.values .filter { it.diplomaticStatus == DiplomaticStatus.War } .map { it.otherCiv() }.flatMap { it.cities }) if (city.getCenterTile().aerialDistanceTo(enemyCivCity.getCenterTile()) <= 5) return true // this is an edge city that needs defending return false } - val citiesToTry = if (!unit.civInfo.isAtWar()) { + val citiesToTry = if (!unit.civ.isAtWar()) { if (unit.getTile().isCityCenter()) return true // It's always good to have a unit in the city center, so if you haven't found anyone around to attack, forget it. citiesWithoutGarrison.asSequence() } else { @@ -657,7 +657,7 @@ object UnitAutomation { if (tryGoToRuinAndEncampment(unit) && (unit.currentMovement == 0f || unit.isDestroyed)) return if (unit.health < 80 && tryHealUnit(unit)) return if (tryExplore(unit)) return - unit.civInfo.addNotification("${unit.shortDisplayName()} finished exploring.", unit.currentTile.position, NotificationCategory.Units, unit.name, "OtherIcons/Sleep") + unit.civ.addNotification("${unit.shortDisplayName()} finished exploring.", unit.currentTile.position, NotificationCategory.Units, unit.name, "OtherIcons/Sleep") unit.action = null } @@ -689,7 +689,7 @@ object UnitAutomation { } val defensiveUnit = reachableTiles.keys .firstOrNull { - it.militaryUnit != null && it.militaryUnit!!.civInfo == unit.civInfo && it.civilianUnit == null + it.militaryUnit != null && it.militaryUnit!!.civ == unit.civ && it.civilianUnit == null } if (defensiveUnit != null) { unit.movement.moveToTile(defensiveUnit) @@ -712,6 +712,6 @@ object UnitAutomation { private fun containsEnemyMilitaryUnit(unit: MapUnit, tile: Tile) = tile.militaryUnit != null - && tile.militaryUnit!!.civInfo.isAtWarWith(unit.civInfo) + && tile.militaryUnit!!.civ.isAtWarWith(unit.civ) } diff --git a/core/src/com/unciv/logic/automation/unit/WorkerAutomation.kt b/core/src/com/unciv/logic/automation/unit/WorkerAutomation.kt index 92216930e7..541dcd07a8 100644 --- a/core/src/com/unciv/logic/automation/unit/WorkerAutomation.kt +++ b/core/src/com/unciv/logic/automation/unit/WorkerAutomation.kt @@ -108,7 +108,7 @@ class WorkerAutomation( companion object { /** Maps to instance [WorkerAutomation.automateWorkerAction] knowing only the MapUnit */ fun automateWorkerAction(unit: MapUnit) { - unit.civInfo.getWorkerAutomation().automateWorkerAction(unit) + unit.civ.getWorkerAutomation().automateWorkerAction(unit) } /** Convenience shortcut supports old calling syntax for [WorkerAutomation.getPriority] */ @@ -178,12 +178,12 @@ class WorkerAutomation( if (tryConnectingCities(unit)) return //nothing to do, try again to connect cities val citiesToNumberOfUnimprovedTiles = HashMap() - for (city in unit.civInfo.cities) { + for (city in unit.civ.cities) { citiesToNumberOfUnimprovedTiles[city.id] = city.getTiles() .count { it.isLand && it.civilianUnit == null && (tileCanBeImproved(unit, it) || it.isPillaged()) } } - val mostUndevelopedCity = unit.civInfo.cities.asSequence() + val mostUndevelopedCity = unit.civ.cities.asSequence() .filter { citiesToNumberOfUnimprovedTiles[it.id]!! > 0 } .sortedByDescending { citiesToNumberOfUnimprovedTiles[it.id] } .firstOrNull { unit.movement.canReach(it.getCenterTile()) } //goto most undeveloped city @@ -196,10 +196,10 @@ class WorkerAutomation( } debug("WorkerAutomation: %s -> nothing to do", unit.label()) - unit.civInfo.addNotification("${unit.shortDisplayName()} has no work to do.", currentTile.position, NotificationCategory.Units, unit.name, "OtherIcons/Sleep") + unit.civ.addNotification("${unit.shortDisplayName()} has no work to do.", currentTile.position, NotificationCategory.Units, unit.name, "OtherIcons/Sleep") // Idle CS units should wander so they don't obstruct players so much - if (unit.civInfo.isCityState()) + if (unit.civ.isCityState()) wander(unit, stayInTerritory = true) } @@ -288,7 +288,7 @@ class WorkerAutomation( && it.getTilesInDistance(2) // don't work in range of enemy cities .none { tile -> tile.isCityCenter() && tile.getCity()!!.civ.isAtWarWith(civInfo) } && it.getTilesInDistance(3) // don't work in range of enemy units - .none { tile -> tile.militaryUnit != null && tile.militaryUnit!!.civInfo.isAtWarWith(civInfo)} + .none { tile -> tile.militaryUnit != null && tile.militaryUnit!!.civ.isAtWarWith(civInfo)} } .sortedByDescending { getPriority(it) } @@ -323,7 +323,7 @@ class WorkerAutomation( val junkImprovement = tile.getTileImprovement()?.hasUnique(UniqueType.AutomatedWorkersWillReplace) if (tile.improvement != null && junkImprovement == false && !UncivGame.Current.settings.automatedWorkersReplaceImprovements - && unit.civInfo.isHuman()) + && unit.civ.isHuman()) return false @@ -366,13 +366,13 @@ class WorkerAutomation( val potentialTileImprovements = ruleSet.tileImprovements.filter { unit.canBuildImprovement(it.value, tile) && tile.improvementFunctions.canBuildImprovement(it.value, civInfo) - && (it.value.uniqueTo == null || it.value.uniqueTo == unit.civInfo.civName) + && (it.value.uniqueTo == null || it.value.uniqueTo == unit.civ.civName) } if (potentialTileImprovements.isEmpty()) return null val uniqueImprovement = potentialTileImprovements.values.asSequence() .filter { it.uniqueTo == civInfo.civName } - .maxByOrNull { Automation.rankStatsValue(it, unit.civInfo) } + .maxByOrNull { Automation.rankStatsValue(it, unit.civ) } val bestBuildableImprovement = potentialTileImprovements.values.asSequence() .map { Pair(it, Automation.rankStatsValue(it, civInfo)) } @@ -390,7 +390,7 @@ class WorkerAutomation( && isUnbuildableAndRemovable(lastTerrain) && !isResourceImprovementAllowedOnFeature(tile, potentialTileImprovements) -> Constants.remove + lastTerrain.name else -> tile.tileResource.getImprovements().filter { it in potentialTileImprovements || it==tile.improvement } - .maxByOrNull { Automation.rankStatsValue(ruleSet.tileImprovements[it]!!, unit.civInfo) } + .maxByOrNull { Automation.rankStatsValue(ruleSet.tileImprovements[it]!!, unit.civ) } } val improvementString = when { diff --git a/core/src/com/unciv/logic/battle/Battle.kt b/core/src/com/unciv/logic/battle/Battle.kt index 184a61e0e0..7bc42645b8 100644 --- a/core/src/com/unciv/logic/battle/Battle.kt +++ b/core/src/com/unciv/logic/battle/Battle.kt @@ -133,7 +133,7 @@ object Battle { if (defender.isDefeated() && defender is CityCombatant && attacker is MapUnitCombatant && attacker.isMelee() && !attacker.unit.hasUnique(UniqueType.CannotCaptureCities)) { // Barbarians can't capture cities - if (attacker.unit.civInfo.isBarbarian()) { + if (attacker.unit.civ.isBarbarian()) { defender.takeDamage(-1) // Back to 2 HP val ransom = min(200, defender.city.civ.gold) defender.city.civ.addGold(-ransom) @@ -483,7 +483,7 @@ object Battle { private fun addXp(thisCombatant: ICombatant, amount: Int, otherCombatant: ICombatant) { var baseXP = amount if (thisCombatant !is MapUnitCombatant) return - val modConstants = thisCombatant.unit.civInfo.gameInfo.ruleSet.modOptions.constants + val modConstants = thisCombatant.unit.civ.gameInfo.ruleSet.modOptions.constants if (thisCombatant.unit.promotions.totalXpProduced() >= modConstants.maxXPfromBarbarians && otherCombatant.getCivInfo().isBarbarian()) return @@ -589,7 +589,7 @@ object Battle { val capturedUnitTile = capturedUnit.getTile() val originalOwner = if (capturedUnit.originalOwner != null) - capturedUnit.civInfo.gameInfo.getCivilization(capturedUnit.originalOwner!!) + capturedUnit.civ.gameInfo.getCivilization(capturedUnit.originalOwner!!) else null var wasDestroyedInstead = false @@ -628,7 +628,7 @@ object Battle { capturedUnit.destroy() // This is so that future checks which check if a unit has been captured are caught give the right answer // For example, in postBattleMoveToAttackedTile - capturedUnit.civInfo = attacker.getCivInfo() + capturedUnit.civ = attacker.getCivInfo() attacker.getCivInfo().units.placeUnitNearTile(capturedUnitTile.position, Constants.worker) } else -> capturedUnit.capturedBy(attacker.getCivInfo()) @@ -709,7 +709,7 @@ object Battle { // Declare war on all potentially hit units. They'll try to intercept the nuke before it drops for(civWhoseUnitWasAttacked in hitTiles .flatMap { it.getUnits() } - .map { it.civInfo }.distinct() + .map { it.civ }.distinct() .filter{it != attackingCiv}) { tryDeclareWar(civWhoseUnitWasAttacked) if (attacker.unit.baseUnit.isAirUnit() && !attacker.isDefeated()) { @@ -725,7 +725,7 @@ object Battle { for (defender in targetTile.getUnits().filter { it != attacker.unit }.toList()) { defender.destroy() postBattleNotifications(attacker, MapUnitCombatant(defender), defender.getTile()) - destroyIfDefeated(defender.civInfo, attacker.getCivInfo()) + destroyIfDefeated(defender.civ, attacker.getCivInfo()) } for (tile in hitTiles) { @@ -871,7 +871,7 @@ object Battle { .shuffled() // randomize Civ .sortedByDescending { it.interceptChance() }) { // No chance of Interceptor to miss (unlike regular Interception). Always want to deal damage - val interceptingCiv = interceptor.civInfo + val interceptingCiv = interceptor.civ val interceptorName = interceptor.name // pairs of LocationAction for Notification val locations = LocationAction( diff --git a/core/src/com/unciv/logic/battle/BattleDamage.kt b/core/src/com/unciv/logic/battle/BattleDamage.kt index 0f6e7dd987..a45712741d 100644 --- a/core/src/com/unciv/logic/battle/BattleDamage.kt +++ b/core/src/com/unciv/logic/battle/BattleDamage.kt @@ -59,7 +59,7 @@ object BattleDamage { //https://www.carlsguides.com/strategy/civilization5/war/combatbonuses.php val adjacentUnits = combatant.getTile().neighbors.flatMap { it.getUnits() } - val strengthMalus = adjacentUnits.filter { it.civInfo.isAtWarWith(civInfo) } + val strengthMalus = adjacentUnits.filter { it.civ.isAtWarWith(civInfo) } .flatMap { it.getMatchingUniques(UniqueType.StrengthForAdjacentEnemies) } .filter { combatant.matchesCategory(it.params[1]) && combatant.getTile().matchesFilter(it.params[2]) } .maxByOrNull { it.params[0] } diff --git a/core/src/com/unciv/logic/battle/GreatGeneralImplementation.kt b/core/src/com/unciv/logic/battle/GreatGeneralImplementation.kt index 70ad115849..479aacb918 100644 --- a/core/src/com/unciv/logic/battle/GreatGeneralImplementation.kt +++ b/core/src/com/unciv/logic/battle/GreatGeneralImplementation.kt @@ -32,7 +32,7 @@ object GreatGeneralImplementation { combatAction: CombatAction ): Pair { val unit = ourUnitCombatant.unit - val civInfo = ourUnitCombatant.unit.civInfo + val civInfo = ourUnitCombatant.unit.civ val allGenerals = civInfo.units.getCivUnits() .filter { it.hasStrengthBonusInRadiusUnique } if (allGenerals.none()) return Pair("", 0) @@ -40,7 +40,7 @@ object GreatGeneralImplementation { val greatGeneral = allGenerals .flatMap { general -> general.getMatchingUniques(UniqueType.StrengthBonusInRadius, - StateForConditionals(unit.civInfo, ourCombatant = ourUnitCombatant, theirCombatant = enemy, combatAction = combatAction)) + StateForConditionals(unit.civ, ourCombatant = ourUnitCombatant, theirCombatant = enemy, combatAction = combatAction)) .map { GeneralBonusData(general, it) } }.filter { // Support the border case when a mod unit has several @@ -80,7 +80,7 @@ object GreatGeneralImplementation { .map { it.key } .filter { tile -> val militaryUnit = tile.militaryUnit - militaryUnit != null && militaryUnit.civInfo == general.civInfo + militaryUnit != null && militaryUnit.civ == general.civ && (tile.civilianUnit == null || tile.civilianUnit == general) && militaryUnit.getMaxMovement() <= unitMaxMovement && !tile.isCityCenter() @@ -93,7 +93,7 @@ object GreatGeneralImplementation { .maxByOrNull { unitTile -> unitTile.getTilesInDistance(unitBonusRadius).sumOf { auraTile -> val militaryUnit = auraTile.militaryUnit - if (militaryUnit == null || militaryUnit.civInfo != general.civInfo) 0 + if (militaryUnit == null || militaryUnit.civ != general.civ) 0 else generalBonusData.firstOrNull { // "Military" as commented above only a small optimization auraTile.aerialDistanceTo(unitTile) <= it.radius diff --git a/core/src/com/unciv/logic/battle/MapUnitCombatant.kt b/core/src/com/unciv/logic/battle/MapUnitCombatant.kt index 7b0835100a..bd0bf771c0 100644 --- a/core/src/com/unciv/logic/battle/MapUnitCombatant.kt +++ b/core/src/com/unciv/logic/battle/MapUnitCombatant.kt @@ -12,7 +12,7 @@ import com.unciv.models.ruleset.unit.UnitType class MapUnitCombatant(val unit: MapUnit) : ICombatant { override fun getHealth(): Int = unit.health override fun getMaxHealth() = 100 - override fun getCivInfo(): Civilization = unit.civInfo + override fun getCivInfo(): Civilization = unit.civ override fun getTile(): Tile = unit.getTile() override fun getName(): String = unit.name override fun isDefeated(): Boolean = unit.health <= 0 @@ -36,7 +36,7 @@ class MapUnitCombatant(val unit: MapUnit) : ICombatant { override fun getDefendingStrength(attackedByRanged: Boolean): Int { return if (unit.isEmbarked() && !isCivilian()) - unit.civInfo.getEra().embarkDefense + unit.civ.getEra().embarkDefense else if (isRanged() && attackedByRanged) unit.baseUnit().rangedStrength else unit.baseUnit().strength @@ -47,7 +47,7 @@ class MapUnitCombatant(val unit: MapUnit) : ICombatant { } override fun toString(): String { - return unit.name+" of "+unit.civInfo.civName + return unit.name+" of "+unit.civ.civName } fun getMatchingUniques(uniqueType: UniqueType, conditionalState: StateForConditionals, checkCivUniques: Boolean): Sequence = diff --git a/core/src/com/unciv/logic/city/managers/CityExpansionManager.kt b/core/src/com/unciv/logic/city/managers/CityExpansionManager.kt index a7b61852a6..0467b1c248 100644 --- a/core/src/com/unciv/logic/city/managers/CityExpansionManager.kt +++ b/core/src/com/unciv/logic/city/managers/CityExpansionManager.kt @@ -164,7 +164,7 @@ class CityExpansionManager : IsPartOfGameInfoSerialization { city.cityStats.update() for (unit in tile.getUnits().toList()) // toListed because we're modifying - if (!unit.civInfo.diplomacyFunctions.canPassThroughTiles(city.civ)) + if (!unit.civ.diplomacyFunctions.canPassThroughTiles(city.civ)) unit.movement.teleportToClosestMoveableTile() city.civ.cache.updateViewableTiles() diff --git a/core/src/com/unciv/logic/civilization/diplomacy/CityStateFunctions.kt b/core/src/com/unciv/logic/civilization/diplomacy/CityStateFunctions.kt index 5f63bf5c77..752e91f331 100644 --- a/core/src/com/unciv/logic/civilization/diplomacy/CityStateFunctions.kt +++ b/core/src/com/unciv/logic/civilization/diplomacy/CityStateFunctions.kt @@ -387,12 +387,12 @@ class CityStateFunctions(val civInfo: Civilization) { val bullyRange = (civInfo.gameInfo.tileMap.tileMatrix.size / 10).coerceIn(5, 10) // Longer range for larger maps val inRangeTiles = civInfo.getCapital()!!.getCenterTile().getTilesInDistanceRange(1..bullyRange) val forceNearCity = inRangeTiles - .sumOf { if (it.militaryUnit?.civInfo == demandingCiv) + .sumOf { if (it.militaryUnit?.civ == demandingCiv) it.militaryUnit!!.getForceEvaluation() else 0 } val csForce = CityCombatant(civInfo.getCapital()!!).getDefendingStrength().toFloat().pow(1.5f).toInt() + inRangeTiles - .sumOf { if (it.militaryUnit?.civInfo == civInfo) + .sumOf { if (it.militaryUnit?.civ == civInfo) it.militaryUnit!!.getForceEvaluation() else 0 } diff --git a/core/src/com/unciv/logic/civilization/transients/CivInfoTransientCache.kt b/core/src/com/unciv/logic/civilization/transients/CivInfoTransientCache.kt index 3bc04f32b8..e8b6acb47b 100644 --- a/core/src/com/unciv/logic/civilization/transients/CivInfoTransientCache.kt +++ b/core/src/com/unciv/logic/civilization/transients/CivInfoTransientCache.kt @@ -90,7 +90,7 @@ class CivInfoTransientCache(val civInfo: Civilization) { for (tile in civInfo.viewableTiles) { val tileOwner = tile.getOwner() if (tileOwner != null) viewedCivs[tileOwner] = tile - for (unit in tile.getUnits()) viewedCivs[unit.civInfo] = tile + for (unit in tile.getUnits()) viewedCivs[unit.civ] = tile } if (!civInfo.isBarbarian()) { diff --git a/core/src/com/unciv/logic/map/MapVisualization.kt b/core/src/com/unciv/logic/map/MapVisualization.kt index f6a8c671e6..9b16a18141 100644 --- a/core/src/com/unciv/logic/map/MapVisualization.kt +++ b/core/src/com/unciv/logic/map/MapVisualization.kt @@ -10,7 +10,7 @@ class MapVisualization(val gameInfo: GameInfo, val viewingCiv: Civilization) { /** @return Whether a unit's past movements should be visible to the player. */ fun isUnitPastVisible(unit: MapUnit): Boolean { - if (unit.civInfo == viewingCiv) + if (unit.civ == viewingCiv) return true val checkPositions = sequenceOf(unit.movementMemories.asSequence().map { it.position }, sequenceOf(unit.getTile().position)).flatten() return checkPositions.all { gameInfo.tileMap[it] in viewingCiv.viewableTiles } @@ -19,7 +19,7 @@ class MapVisualization(val gameInfo: GameInfo, val viewingCiv: Civilization) { } /** @return Whether a unit's planned movements should be visible to the player. */ - fun isUnitFutureVisible(unit: MapUnit) = (viewingCiv.isSpectator() || unit.civInfo == viewingCiv) + fun isUnitFutureVisible(unit: MapUnit) = (viewingCiv.isSpectator() || unit.civ == viewingCiv) // Plans should be visible always for own units and never for foreign units. /** @return Whether an attack by a unit to a target should be visible to the player. */ diff --git a/core/src/com/unciv/logic/map/TileMap.kt b/core/src/com/unciv/logic/map/TileMap.kt index f991118496..55e656a1de 100644 --- a/core/src/com/unciv/logic/map/TileMap.kt +++ b/core/src/com/unciv/logic/map/TileMap.kt @@ -584,7 +584,7 @@ class TileMap : IsPartOfGameInfoSerialization { tileList.forEach { for (unit in it.getUnits()) if (unit.owner == player.chosenCiv) { unit.owner = newNation.name - unit.civInfo = newCiv + unit.civ = newCiv } } for (element in startingLocations.filter { it.nation != player.chosenCiv }) { diff --git a/core/src/com/unciv/logic/map/mapunit/MapUnit.kt b/core/src/com/unciv/logic/map/mapunit/MapUnit.kt index fcb3a72d45..b3d76bc5f3 100644 --- a/core/src/com/unciv/logic/map/mapunit/MapUnit.kt +++ b/core/src/com/unciv/logic/map/mapunit/MapUnit.kt @@ -35,7 +35,7 @@ import kotlin.math.pow class MapUnit : IsPartOfGameInfoSerialization { @Transient - lateinit var civInfo: Civilization + lateinit var civ: Civilization @Transient lateinit var baseUnit: BaseUnit @@ -230,7 +230,7 @@ class MapUnit : IsPartOfGameInfoSerialization { val toReturn = MapUnit() toReturn.baseUnit = baseUnit toReturn.name = name - toReturn.civInfo = civInfo + toReturn.civ = civ toReturn.owner = owner toReturn.originalOwner = originalOwner toReturn.instanceName = instanceName @@ -267,19 +267,19 @@ class MapUnit : IsPartOfGameInfoSerialization { fun getMatchingUniques( uniqueType: UniqueType, - stateForConditionals: StateForConditionals = StateForConditionals(civInfo, unit=this), + stateForConditionals: StateForConditionals = StateForConditionals(civ, unit=this), checkCivInfoUniques: Boolean = false ) = sequence { yieldAll( tempUniquesMap.getMatchingUniques(uniqueType, stateForConditionals) ) if (checkCivInfoUniques) - yieldAll(civInfo.getMatchingUniques(uniqueType, stateForConditionals)) + yieldAll(civ.getMatchingUniques(uniqueType, stateForConditionals)) } fun hasUnique( uniqueType: UniqueType, - stateForConditionals: StateForConditionals = StateForConditionals(civInfo, unit=this), + stateForConditionals: StateForConditionals = StateForConditionals(civ, unit=this), checkCivInfoUniques: Boolean = false ): Boolean { return getMatchingUniques(uniqueType, stateForConditionals, checkCivInfoUniques).any() @@ -319,7 +319,7 @@ class MapUnit : IsPartOfGameInfoSerialization { } // Init shortcut flags noTerrainMovementUniques = doubleMovementInTerrain.isEmpty() && - !roughTerrainPenalty && !civInfo.nation.ignoreHillMovementCost + !roughTerrainPenalty && !civ.nation.ignoreHillMovementCost noBaseTerrainOrHillDoubleMovementUniques = doubleMovementInTerrain .none { it.value != DoubleMovementTerrainTarget.Feature } noFilteredDoubleMovementUniques = doubleMovementInTerrain @@ -331,7 +331,7 @@ class MapUnit : IsPartOfGameInfoSerialization { //todo: consider parameterizing [terrainFilter] in some of the following: canEnterIceTiles = hasUnique(UniqueType.CanEnterIceTiles) - cannotEnterOceanTiles = hasUnique(UniqueType.CannotEnterOcean, StateForConditionals(civInfo=civInfo, unit=this)) + cannotEnterOceanTiles = hasUnique(UniqueType.CannotEnterOcean, StateForConditionals(civInfo=civ, unit=this)) hasUniqueToBuildImprovements = hasUnique(UniqueType.BuildImprovements) canEnterForeignTerrain = hasUnique(UniqueType.CanEnterForeignTiles) @@ -339,7 +339,7 @@ class MapUnit : IsPartOfGameInfoSerialization { hasStrengthBonusInRadiusUnique = hasUnique(UniqueType.StrengthBonusInRadius) hasCitadelPlacementUnique = getMatchingUniques(UniqueType.ConstructImprovementConsumingUnit) - .mapNotNull { civInfo.gameInfo.ruleSet.tileImprovements[it.params[0]] } + .mapNotNull { civ.gameInfo.ruleSet.tileImprovements[it.params[0]] } .any { it.hasUnique(UniqueType.TakesOverAdjacentTiles) } } @@ -355,7 +355,7 @@ class MapUnit : IsPartOfGameInfoSerialization { newUnit.promotions = promotions.clone() - newUnit.updateUniques(civInfo.gameInfo.ruleSet) + newUnit.updateUniques(civ.gameInfo.ruleSet) newUnit.updateVisibleTiles() } @@ -381,7 +381,7 @@ class MapUnit : IsPartOfGameInfoSerialization { private fun getVisibilityRange(): Int { var visibilityRange = 2 - val conditionalState = StateForConditionals(civInfo = civInfo, unit = this) + val conditionalState = StateForConditionals(civInfo = civ, unit = this) if (isEmbarked() && !hasUnique(UniqueType.NormalVisionWhenEmbarked, conditionalState, checkCivInfoUniques = true)) { return 1 @@ -413,7 +413,7 @@ class MapUnit : IsPartOfGameInfoSerialization { // Set equality automatically determines if anything changed - https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-abstract-set/equals.html if (updateCivViewableTiles && oldViewableTiles != viewableTiles) - civInfo.cache.updateViewableTiles() + civ.cache.updateViewableTiles() } fun isActionUntilHealed() = action?.endsWith("until healed") == true @@ -553,7 +553,7 @@ class MapUnit : IsPartOfGameInfoSerialization { if (currentMovement == 0f) return // We've already done stuff this turn, and can't do any more stuff val enemyUnitsInWalkingDistance = movement.getDistanceToTiles().keys - .filter { it.militaryUnit != null && civInfo.isAtWarWith(it.militaryUnit!!.civInfo) } + .filter { it.militaryUnit != null && civ.isAtWarWith(it.militaryUnit!!.civ) } if (enemyUnitsInWalkingDistance.isNotEmpty()) { if (isMoving()) // stop on enemy in sight action = null @@ -591,7 +591,7 @@ class MapUnit : IsPartOfGameInfoSerialization { /** Returns the health points [MapUnit] will receive if healing on [tile] */ fun rankTileForHealing(tile: Tile): Int { - val isFriendlyTerritory = tile.isFriendlyTerritory(civInfo) + val isFriendlyTerritory = tile.isFriendlyTerritory(civ) var healing = when { tile.isCityCenter() -> 25 @@ -618,7 +618,7 @@ class MapUnit : IsPartOfGameInfoSerialization { } val maxAdjacentHealingBonus = currentTile.neighbors - .flatMap { it.getUnits().asSequence() }.filter { it.civInfo == civInfo } + .flatMap { it.getUnits().asSequence() }.filter { it.civ == civ } .map { it.adjacentHealingBonus() }.maxOrNull() if (maxAdjacentHealingBonus != null) healing += maxAdjacentHealingBonus @@ -628,11 +628,11 @@ class MapUnit : IsPartOfGameInfoSerialization { fun destroy(destroyTransportedUnit: Boolean = true) { val currentPosition = Vector2(getTile().position) - civInfo.attacksSinceTurnStart.addAll(attacksSinceTurnStart.asSequence().map { Civilization.HistoricalAttackMemory(this.name, currentPosition, it) }) + civ.attacksSinceTurnStart.addAll(attacksSinceTurnStart.asSequence().map { Civilization.HistoricalAttackMemory(this.name, currentPosition, it) }) currentMovement = 0f removeFromTile() - civInfo.units.removeUnit(this) - civInfo.cache.updateViewableTiles() + civ.units.removeUnit(this) + civ.cache.updateViewableTiles() if (destroyTransportedUnit) { // all transported units should be destroyed as well currentTile.getUnits().filter { it.isTransported && isTransportTypeOf(it) } @@ -643,8 +643,8 @@ class MapUnit : IsPartOfGameInfoSerialization { } fun gift(recipient: Civilization) { - civInfo.units.removeUnit(this) - civInfo.cache.updateViewableTiles() + civ.units.removeUnit(this) + civ.cache.updateViewableTiles() // all transported units should be destroyed as well currentTile.getUnits().filter { it.isTransported && isTransportTypeOf(it) } .toList() // because we're changing the list @@ -663,12 +663,12 @@ class MapUnit : IsPartOfGameInfoSerialization { if (!isGreatPerson()) return val gainedStats = Stats() - for (unique in civInfo.getMatchingUniques(UniqueType.ProvidesGoldWheneverGreatPersonExpended)) { - gainedStats.gold += (100 * civInfo.gameInfo.speed.goldCostModifier).toInt() + for (unique in civ.getMatchingUniques(UniqueType.ProvidesGoldWheneverGreatPersonExpended)) { + gainedStats.gold += (100 * civ.gameInfo.speed.goldCostModifier).toInt() } - for (unique in civInfo.getMatchingUniques(UniqueType.ProvidesStatsWheneverGreatPersonExpended)) { + for (unique in civ.getMatchingUniques(UniqueType.ProvidesStatsWheneverGreatPersonExpended)) { val uniqueStats = unique.stats - val speedModifiers = civInfo.gameInfo.speed.statCostModifiers + val speedModifiers = civ.gameInfo.speed.statCostModifiers for (stat in uniqueStats) { uniqueStats[stat.key] = stat.value * speedModifiers[stat.key]!! } @@ -678,9 +678,9 @@ class MapUnit : IsPartOfGameInfoSerialization { if (gainedStats.isEmpty()) return for (stat in gainedStats) - civInfo.addStat(stat.key, stat.value.toInt()) + civ.addStat(stat.key, stat.value.toInt()) - civInfo.addNotification("By expending your [$name] you gained [${gainedStats.toStringForNotifications()}]!", + civ.addNotification("By expending your [$name] you gained [${gainedStats.toStringForNotifications()}]!", getTile().position, NotificationCategory.Units, name) } @@ -691,20 +691,20 @@ class MapUnit : IsPartOfGameInfoSerialization { // getAncientRuinBonus, if it places a new unit, does too currentTile = tile - if (civInfo.isMajorCiv() + if (civ.isMajorCiv() && tile.improvement != null && tile.getTileImprovement()!!.isAncientRuinsEquivalent() ) { getAncientRuinBonus(tile) } - if (tile.improvement == Constants.barbarianEncampment && !civInfo.isBarbarian()) + if (tile.improvement == Constants.barbarianEncampment && !civ.isBarbarian()) clearEncampment(tile) // Check whether any civilians without military units are there. // Keep in mind that putInTile(), which calls this method, // might have already placed your military unit in this tile. val unguardedCivilian = tile.getUnguardedCivilian(this) // Capture Enemy Civilian Unit if you move on top of it - if (isMilitary() && unguardedCivilian != null && civInfo.isAtWarWith(unguardedCivilian.civInfo)) { + if (isMilitary() && unguardedCivilian != null && civ.isAtWarWith(unguardedCivilian.civ)) { Battle.captureCivilianUnit(MapUnitCombatant(this), MapUnitCombatant(tile.civilianUnit!!)) } @@ -738,16 +738,16 @@ class MapUnit : IsPartOfGameInfoSerialization { tile.changeImprovement(null) // Notify City-States that this unit cleared a Barbarian Encampment, required for quests - civInfo.gameInfo.getAliveCityStates() - .forEach { it.questManager.barbarianCampCleared(civInfo, tile.position) } + civ.gameInfo.getAliveCityStates() + .forEach { it.questManager.barbarianCampCleared(civ, tile.position) } var goldGained = - civInfo.getDifficulty().clearBarbarianCampReward * civInfo.gameInfo.speed.goldCostModifier - if (civInfo.hasUnique(UniqueType.TripleGoldFromEncampmentsAndCities)) + civ.getDifficulty().clearBarbarianCampReward * civ.gameInfo.speed.goldCostModifier + if (civ.hasUnique(UniqueType.TripleGoldFromEncampmentsAndCities)) goldGained *= 3f - civInfo.addGold(goldGained.toInt()) - civInfo.addNotification( + civ.addGold(goldGained.toInt()) + civ.addNotification( "We have captured a barbarian encampment and recovered [${goldGained.toInt()}] gold!", tile.position, NotificationCategory.War, @@ -780,24 +780,24 @@ class MapUnit : IsPartOfGameInfoSerialization { } destroy() - if (currentTile.getOwner() == civInfo) - civInfo.addGold(baseUnit.getDisbandGold(civInfo)) - if (civInfo.isDefeated()) civInfo.destroy() + if (currentTile.getOwner() == civ) + civ.addGold(baseUnit.getDisbandGold(civ)) + if (civ.isDefeated()) civ.destroy() } private fun getAncientRuinBonus(tile: Tile) { tile.changeImprovement(null) - civInfo.ruinsManager.selectNextRuinsReward(this) + civ.ruinsManager.selectNextRuinsReward(this) } fun assignOwner(civInfo: Civilization, updateCivInfo: Boolean = true) { owner = civInfo.civName - this.civInfo = civInfo + this.civ = civInfo civInfo.units.addUnit(this, updateCivInfo) } fun capturedBy(captor: Civilization) { - civInfo.units.removeUnit(this) + civ.units.removeUnit(this) assignOwner(captor) currentMovement = 0f // It's possible that the unit can no longer stand on the tile it was captured on. @@ -843,7 +843,7 @@ class MapUnit : IsPartOfGameInfoSerialization { fun getDamageFromTerrain(tile: Tile = currentTile): Int { - if (civInfo.nonStandardTerrainDamage) { + if (civ.nonStandardTerrainDamage) { for (unique in getMatchingUniques(UniqueType.DamagesContainingUnits)) { if (unique.params[0] in tile.allTerrains.map { it.name }) { return unique.params[1].toInt() // Use the damage from the unique @@ -878,9 +878,9 @@ class MapUnit : IsPartOfGameInfoSerialization { private fun isAlly(otherCiv: Civilization): Boolean { - return otherCiv == civInfo - || (otherCiv.isCityState() && otherCiv.getAllyCiv() == civInfo.civName) - || (civInfo.isCityState() && civInfo.getAllyCiv() == otherCiv.civName) + return otherCiv == civ + || (otherCiv.isCityState() && otherCiv.getAllyCiv() == civ.civName) + || (civ.isCityState() && civ.getAllyCiv() == otherCiv.civName) } /** Implements [UniqueParameterType.MapUnitFilter][com.unciv.models.ruleset.unique.UniqueParameterType.MapUnitFilter] */ @@ -891,8 +891,8 @@ class MapUnit : IsPartOfGameInfoSerialization { // todo: unit filters should be adjectives, fitting "[filterType] units" // This means converting "wounded units" to "Wounded", "Barbarians" to "Barbarian" "Wounded", "wounded units" -> health < 100 - Constants.barbarians, "Barbarian" -> civInfo.isBarbarian() - "City-State" -> civInfo.isCityState() + Constants.barbarians, "Barbarian" -> civ.isBarbarian() + "City-State" -> civ.isCityState() "Embarked" -> isEmbarked() "Non-City" -> true else -> { @@ -918,7 +918,7 @@ class MapUnit : IsPartOfGameInfoSerialization { fun getReligionDisplayName(): String? { if (religion == null) return null - return civInfo.gameInfo.religions[religion]!!.getReligionDisplayName() + return civ.gameInfo.religions[religion]!!.getReligionDisplayName() } fun religiousActionsUnitCanDo(): Sequence { diff --git a/core/src/com/unciv/logic/map/mapunit/UnitMovementAlgorithms.kt b/core/src/com/unciv/logic/map/mapunit/UnitMovementAlgorithms.kt index b0e1e6d1a6..1235d29b8d 100644 --- a/core/src/com/unciv/logic/map/mapunit/UnitMovementAlgorithms.kt +++ b/core/src/com/unciv/logic/map/mapunit/UnitMovementAlgorithms.kt @@ -63,7 +63,7 @@ class UnitMovementAlgorithms(val unit: MapUnit) { val areConnectedByRiver = from.isAdjacentToRiver() && to.isAdjacentToRiver() && from.isConnectedByRiver(to) if (areConnectedByRoad && (!areConnectedByRiver || civInfo.tech.roadsConnectAcrossRivers)) - return unit.civInfo.tech.movementSpeedOnRoads + extraCost + return unit.civ.tech.movementSpeedOnRoads + extraCost if (unit.ignoresTerrainCost) return 1f + extraCost if (areConnectedByRiver) return 100f // Rivers take the entire turn to cross @@ -107,7 +107,7 @@ class UnitMovementAlgorithms(val unit: MapUnit) { if (tile.isCityCenter() && civInfo.isAtWarWith(tile.getOwner()!!)) { yield(tile) } - else if (tile.militaryUnit != null && civInfo.isAtWarWith(tile.militaryUnit!!.civInfo)) { + else if (tile.militaryUnit != null && civInfo.isAtWarWith(tile.militaryUnit!!.civ)) { if (tile.militaryUnit!!.type.isWaterUnit() || (unit.type.isLandUnit() && !tile.militaryUnit!!.isEmbarked())) yield(tile) } @@ -147,7 +147,7 @@ class UnitMovementAlgorithms(val unit: MapUnit) { class ParentTileAndTotalDistance(val parentTile: Tile, val totalDistance: Float) - fun isUnknownTileWeShouldAssumeToBePassable(tile: Tile) = !unit.civInfo.hasExplored(tile) + fun isUnknownTileWeShouldAssumeToBePassable(tile: Tile) = !unit.civ.hasExplored(tile) /** * Does not consider if tiles can actually be entered, use canMoveTo for that. @@ -169,14 +169,14 @@ class UnitMovementAlgorithms(val unit: MapUnit) { for (neighbor in tileToCheck.neighbors) { if (tilesToIgnore?.contains(neighbor) == true) continue // ignore this tile var totalDistanceToTile: Float = when { - !unit.civInfo.hasExplored(neighbor) -> + !unit.civ.hasExplored(neighbor) -> distanceToTiles[tileToCheck]!!.totalDistance + 1f // If we don't know then we just guess it to be 1. !canPassThrough(neighbor) -> unitMovement // Can't go here. // The reason that we don't just "return" is so that when calculating how to reach an enemy, // You need to assume his tile is reachable, otherwise all movement algorithms on reaching enemy // cities and units goes kaput. else -> { - val distanceBetweenTiles = getMovementCostBetweenAdjacentTiles(tileToCheck, neighbor, unit.civInfo, considerZoneOfControl) + val distanceBetweenTiles = getMovementCostBetweenAdjacentTiles(tileToCheck, neighbor, unit.civ, considerZoneOfControl) distanceToTiles[tileToCheck]!!.totalDistance + distanceBetweenTiles } } @@ -206,7 +206,7 @@ class UnitMovementAlgorithms(val unit: MapUnit) { fun getShortestPath(destination: Tile, avoidDamagingTerrain: Boolean = false): List { if (unit.hasUnique(UniqueType.CannotMove)) return listOf() // First try and find a path without damaging terrain - if (!avoidDamagingTerrain && unit.civInfo.passThroughImpassableUnlocked && unit.baseUnit.isLandUnit()) { + if (!avoidDamagingTerrain && unit.civ.passThroughImpassableUnlocked && unit.baseUnit.isLandUnit()) { val damageFreePath = getShortestPath(destination, true) if (damageFreePath.isNotEmpty()) return damageFreePath } @@ -435,7 +435,7 @@ class UnitMovementAlgorithms(val unit: MapUnit) { distance++ allowedTile = unit.getTile().getTilesAtDistance(distance) // can the unit be placed safely there? Is tile either unowned or friendly? - .filter { canMoveTo(it) && it.getOwner()?.isAtWarWith(unit.civInfo) != true } + .filter { canMoveTo(it) && it.getOwner()?.isAtWarWith(unit.civ) != true } // out of those where it can be placed, can it reach them in any meaningful way? .firstOrNull { getPathBetweenTiles(unit.currentTile, it).contains(it) } } @@ -443,7 +443,7 @@ class UnitMovementAlgorithms(val unit: MapUnit) { // No tile within 4 spaces? move him to a city. val origin = unit.getTile() if (allowedTile == null) - allowedTile = unit.civInfo.cities.flatMap { it.getTiles() } + allowedTile = unit.civ.cities.flatMap { it.getTiles() } .sortedBy { it.aerialDistanceTo(origin) }.firstOrNull{ canMoveTo(it) } if (allowedTile != null) { @@ -493,8 +493,8 @@ class UnitMovementAlgorithms(val unit: MapUnit) { // As we can not reach our destination in a single turn if (unit.canGarrison() && (unit.getTile().isCityCenter() || destination.isCityCenter()) - && unit.civInfo.hasUnique(UniqueType.UnitsInCitiesNoMaintenance) - ) unit.civInfo.updateStatsForNextTurn() + && unit.civ.hasUnique(UniqueType.UnitsInCitiesNoMaintenance) + ) unit.civ.updateStatsForNextTurn() return } @@ -533,8 +533,8 @@ class UnitMovementAlgorithms(val unit: MapUnit) { unit.moveThroughTile(tile) // This fixes a bug where tiles in the fog of war would always only cost 1 mp - if (!unit.civInfo.gameInfo.gameParameters.godMode) - passingMovementSpent += getMovementCostBetweenAdjacentTiles(previousTile, tile, unit.civInfo) + if (!unit.civ.gameInfo.gameParameters.godMode) + passingMovementSpent += getMovementCostBetweenAdjacentTiles(previousTile, tile, unit.civ) // In case something goes wrong, cache the last tile we were able to end on // We can assume we can pass through this tile, as we would have broken earlier @@ -580,8 +580,8 @@ class UnitMovementAlgorithms(val unit: MapUnit) { // Unit maintenance changed if (unit.canGarrison() && (origin.isCityCenter() || finalTileReached.isCityCenter()) - && unit.civInfo.hasUnique(UniqueType.UnitsInCitiesNoMaintenance) - ) unit.civInfo.updateStatsForNextTurn() + && unit.civ.hasUnique(UniqueType.UnitsInCitiesNoMaintenance) + ) unit.civ.updateStatsForNextTurn() // Under rare cases (see #8044), we can be headed to a tile and *the entire path* is blocked by other units, so we can't "enter" that tile. // If, in such conditions, the *destination tile* is unenterable, needToFindNewRoute will trigger, so we need to catch this situation to avoid infinite loop @@ -652,20 +652,20 @@ class UnitMovementAlgorithms(val unit: MapUnit) { return false // even if they'll let us pass through, we can't enter their city - unless we just captured it - if (tile.isCityCenter() && tile.getOwner() != unit.civInfo && !tile.getCity()!!.hasJustBeenConquered) + if (tile.isCityCenter() && tile.getOwner() != unit.civ && !tile.getCity()!!.hasJustBeenConquered) return false return if (unit.isCivilian()) tile.civilianUnit == null && (tile.militaryUnit == null || tile.militaryUnit!!.owner == unit.owner) else // can skip checking for airUnit since not a city - tile.militaryUnit == null && (tile.civilianUnit == null || tile.civilianUnit!!.owner == unit.owner || unit.civInfo.isAtWarWith(tile.civilianUnit!!.civInfo)) + tile.militaryUnit == null && (tile.civilianUnit == null || tile.civilianUnit!!.owner == unit.owner || unit.civ.isAtWarWith(tile.civilianUnit!!.civ)) } private fun canAirUnitMoveTo(tile: Tile, unit: MapUnit): Boolean { // landing in the city if (tile.isCityCenter()) { - if (tile.airUnits.filter { !it.isTransported }.size < 6 && tile.getCity()?.civ == unit.civInfo) + if (tile.airUnits.filter { !it.isTransported }.size < 6 && tile.getCity()?.civ == unit.civ) return true // if city is free - no problem, get in } // let's check whether it enters city on carrier now... @@ -681,7 +681,7 @@ class UnitMovementAlgorithms(val unit: MapUnit) { if (unit.hasUnique(UniqueType.CannotMove)) return false // Can only move to land tiles within range that are visible and not impassible // Based on some testing done in the base game - if (!destination.isLand || destination.isImpassible() || !unit.civInfo.viewableTiles.contains(destination)) return false + if (!destination.isLand || destination.isImpassible() || !unit.civ.viewableTiles.contains(destination)) return false return true } @@ -700,7 +700,7 @@ class UnitMovementAlgorithms(val unit: MapUnit) { // helicopters can pass through impassable tiles like mountains if (!unit.canPassThroughImpassableTiles && !(unit.canEnterIceTiles && tile.terrainFeatures.contains(Constants.ice)) // carthage-like uniques sometimes allow passage through impassible tiles - && !(unit.civInfo.passThroughImpassableUnlocked && unit.civInfo.passableImpassables.contains(tile.getLastTerrain().name))) + && !(unit.civ.passThroughImpassableUnlocked && unit.civ.passableImpassables.contains(tile.getLastTerrain().name))) return false } if (tile.isLand @@ -709,20 +709,20 @@ class UnitMovementAlgorithms(val unit: MapUnit) { return false val unitSpecificAllowOcean: Boolean by lazy { - unit.civInfo.tech.specificUnitsCanEnterOcean && - unit.civInfo.getMatchingUniques(UniqueType.UnitsMayEnterOcean) + unit.civ.tech.specificUnitsCanEnterOcean && + unit.civ.getMatchingUniques(UniqueType.UnitsMayEnterOcean) .any { unit.matchesFilter(it.params[0]) } } if (tile.isWater && unit.baseUnit.isLandUnit()) { - if (!unit.civInfo.tech.unitsCanEmbark) return false - if (tile.isOcean && !unit.civInfo.tech.embarkedUnitsCanEnterOcean && !unitSpecificAllowOcean) + if (!unit.civ.tech.unitsCanEmbark) return false + if (tile.isOcean && !unit.civ.tech.embarkedUnitsCanEnterOcean && !unitSpecificAllowOcean) return false } - if (tile.isOcean && !unit.civInfo.tech.allUnitsCanEnterOcean) { // Apparently all Polynesian naval units can enter oceans + if (tile.isOcean && !unit.civ.tech.allUnitsCanEnterOcean) { // Apparently all Polynesian naval units can enter oceans if (!unitSpecificAllowOcean && unit.cannotEnterOceanTiles) return false } - if (!unit.canEnterForeignTerrain && !tile.canCivPassThrough(unit.civInfo)) return false + if (!unit.canEnterForeignTerrain && !tile.canCivPassThrough(unit.civ)) return false // The first unit is: // 1. Either military unit @@ -730,14 +730,14 @@ class UnitMovementAlgorithms(val unit: MapUnit) { // 3. or unprotected air unit while no civilians on tile val firstUnit = tile.getFirstUnit() // Moving to non-empty tile - if (firstUnit != null && unit.civInfo != firstUnit.civInfo) { + if (firstUnit != null && unit.civ != firstUnit.civ) { // Allow movement through unguarded, at-war Civilian Unit. Capture on the way // But not for Embarked Units capturing on Water if (!(unit.baseUnit.isLandUnit() && tile.isWater) - && firstUnit.isCivilian() && unit.civInfo.isAtWarWith(firstUnit.civInfo)) + && firstUnit.isCivilian() && unit.civ.isAtWarWith(firstUnit.civ)) return true // Cannot enter hostile tile with any unit in there - if (unit.civInfo.isAtWarWith(firstUnit.civInfo)) + if (unit.civ.isAtWarWith(firstUnit.civ)) return false } @@ -836,7 +836,7 @@ class PathfindingCache(private val unit: MapUnit) { private fun isValid(): Boolean = (movement == unit.currentMovement) && (unit.getTile() == currentTile) fun getShortestPathCache(destination: Tile): List { - if (unit.civInfo.isHuman()) return listOf() + if (unit.civ.isHuman()) return listOf() if (isValid() && this.destination == destination) { return shortestPathCache } @@ -844,7 +844,7 @@ class PathfindingCache(private val unit: MapUnit) { } fun setShortestPathCache(destination: Tile, newShortestPath: List) { - if (unit.civInfo.isHuman()) return + if (unit.civ.isHuman()) return if (isValid()) { shortestPathCache = newShortestPath this.destination = destination @@ -852,14 +852,14 @@ class PathfindingCache(private val unit: MapUnit) { } fun getDistanceToTiles(zoneOfControl: Boolean): PathsToTilesWithinTurn? { - if (unit.civInfo.isHuman()) return null + if (unit.civ.isHuman()) return null if (isValid()) return distanceToTilesCache[zoneOfControl] return null } fun setDistanceToTiles(zoneOfControl: Boolean, paths: PathsToTilesWithinTurn) { - if (unit.civInfo.isHuman()) return + if (unit.civ.isHuman()) return if (!isValid()) { clear() // we want to reset the entire cache at this point } diff --git a/core/src/com/unciv/logic/map/mapunit/UnitPromotions.kt b/core/src/com/unciv/logic/map/mapunit/UnitPromotions.kt index 25b3922459..d73a011ba0 100644 --- a/core/src/com/unciv/logic/map/mapunit/UnitPromotions.kt +++ b/core/src/com/unciv/logic/map/mapunit/UnitPromotions.kt @@ -33,7 +33,7 @@ class UnitPromotions : IsPartOfGameInfoSerialization { */ fun getPromotions(sorted: Boolean = false): Sequence = sequence { if (promotions.isEmpty()) return@sequence - val unitPromotions = unit.civInfo.gameInfo.ruleSet.unitPromotions + val unitPromotions = unit.civ.gameInfo.ruleSet.unitPromotions if (sorted && promotions.size > 1) { for (promotion in unitPromotions.values) if (promotion.name in promotions) yield(promotion) @@ -65,7 +65,7 @@ class UnitPromotions : IsPartOfGameInfoSerialization { numberOfPromotions++ } - val ruleset = unit.civInfo.gameInfo.ruleSet + val ruleset = unit.civ.gameInfo.ruleSet val promotion = ruleset.unitPromotions[promotionName]!! if (!promotion.hasUnique(UniqueType.SkipPromotion)) @@ -93,13 +93,13 @@ class UnitPromotions : IsPartOfGameInfoSerialization { * Checks unit type, already acquired promotions, prerequisites and incompatibility uniques. */ fun getAvailablePromotions(): Sequence { - return unit.civInfo.gameInfo.ruleSet.unitPromotions.values + return unit.civ.gameInfo.ruleSet.unitPromotions.values .asSequence() .filter { unit.type.name in it.unitTypes && it.name !in promotions } .filter { it.prerequisites.isEmpty() || it.prerequisites.any { p->p in promotions } } .filter { promotion -> promotion.uniqueObjects .none { it.type == UniqueType.OnlyAvailableWhen - && !it.conditionalsApply(StateForConditionals(unit.civInfo, unit = unit)) } + && !it.conditionalsApply(StateForConditionals(unit.civ, unit = unit)) } } } diff --git a/core/src/com/unciv/logic/map/mapunit/UnitTurnManager.kt b/core/src/com/unciv/logic/map/mapunit/UnitTurnManager.kt index fb376f49cc..797bc7a118 100644 --- a/core/src/com/unciv/logic/map/mapunit/UnitTurnManager.kt +++ b/core/src/com/unciv/logic/map/mapunit/UnitTurnManager.kt @@ -37,7 +37,7 @@ class UnitTurnManager(val unit: MapUnit) { if (unit.hasUnique(UniqueType.ReligiousUnit) && unit.getTile().getOwner() != null && !unit.getTile().getOwner()!!.isCityState() - && !unit.civInfo.diplomacyFunctions.canPassThroughTiles(unit.getTile().getOwner()!!) + && !unit.civ.diplomacyFunctions.canPassThroughTiles(unit.getTile().getOwner()!!) ) { val lostReligiousStrength = unit.getMatchingUniques(UniqueType.CanEnterForeignTilesButLosesReligiousStrength) @@ -46,7 +46,7 @@ class UnitTurnManager(val unit: MapUnit) { if (lostReligiousStrength != null) unit.religiousStrengthLost += lostReligiousStrength if (unit.religiousStrengthLost >= unit.baseUnit.religiousStrength) { - unit.civInfo.addNotification("Your [${unit.name}] lost its faith after spending too long inside enemy territory!", + unit.civ.addNotification("Your [${unit.name}] lost its faith after spending too long inside enemy territory!", unit.getTile().position, NotificationCategory.Units, unit.name) unit.destroy() } @@ -77,7 +77,7 @@ class UnitTurnManager(val unit: MapUnit) { .filter { it.getOwner() != null && it.getUnpillagedImprovement() != null - && unit.civInfo.isAtWarWith(it.getOwner()!!) + && unit.civ.isAtWarWith(it.getOwner()!!) }.map { tile -> tile to tile.getTileImprovement()!!.getMatchingUniques(UniqueType.DamagesAdjacentEnemyUnits) .sumOf { it.params[0].toInt() } @@ -87,7 +87,7 @@ class UnitTurnManager(val unit: MapUnit) { unit.health -= damage val locations = LocationAction(citadelTile.position, unit.currentTile.position) if (unit.health <= 0) { - unit.civInfo.addNotification( + unit.civ.addNotification( "An enemy [Citadel] has destroyed our [${unit.name}]", locations, NotificationCategory.War, @@ -100,7 +100,7 @@ class UnitTurnManager(val unit: MapUnit) { NotificationIcon.Citadel, NotificationIcon.Death, unit.name ) unit.destroy() - } else unit.civInfo.addNotification( + } else unit.civ.addNotification( "An enemy [Citadel] has attacked our [${unit.name}]", locations, NotificationCategory.War, @@ -114,7 +114,7 @@ class UnitTurnManager(val unit: MapUnit) { unit.health -= tileDamage if (unit.health <= 0) { - unit.civInfo.addNotification( + unit.civ.addNotification( "Our [${unit.name}] took [$tileDamage] tile damage and was destroyed", unit.currentTile.position, NotificationCategory.Units, @@ -122,7 +122,7 @@ class UnitTurnManager(val unit: MapUnit) { NotificationIcon.Death ) unit.destroy() - } else if (tileDamage > 0) unit.civInfo.addNotification( + } else if (tileDamage > 0) unit.civ.addNotification( "Our [${unit.name}] took [$tileDamage] tile damage", unit.currentTile.position, NotificationCategory.Units, @@ -154,14 +154,14 @@ class UnitTurnManager(val unit: MapUnit) { // Military units always but civilians only if not protected. if (unit.isSleeping() && (unit.isMilitary() || (unit.currentTile.militaryUnit == null && !unit.currentTile.isCityCenter())) && unit.currentTile.getTilesInDistance(3).any { - it.militaryUnit != null && it in unit.civInfo.viewableTiles && it.militaryUnit!!.civInfo.isAtWarWith(unit.civInfo) + it.militaryUnit != null && it in unit.civ.viewableTiles && it.militaryUnit!!.civ.isAtWarWith(unit.civ) } ) unit.action = null val tileOwner = unit.getTile().getOwner() if (tileOwner != null && !unit.canEnterForeignTerrain - && !unit.civInfo.diplomacyFunctions.canPassThroughTiles(tileOwner) + && !unit.civ.diplomacyFunctions.canPassThroughTiles(tileOwner) && !tileOwner.isCityState()) // if an enemy city expanded onto this tile while I was in it unit.movement.teleportToClosestMoveableTile() @@ -175,7 +175,7 @@ class UnitTurnManager(val unit: MapUnit) { tile.turnsToImprovement -= 1 if (tile.turnsToImprovement != 0) return - if (unit.civInfo.isCurrentPlayer()) + if (unit.civ.isCurrentPlayer()) UncivGame.Current.settings.addCompletedTutorialTask("Construct an improvement") when { @@ -190,7 +190,7 @@ class UnitTurnManager(val unit: MapUnit) { ) { // We removed a terrain (e.g. Forest) and the improvement (e.g. Lumber mill) requires it! tile.changeImprovement(null) - if (tile.resource != null) unit.civInfo.cache.updateCivResources() // unlikely, but maybe a mod makes a resource improvement dependent on a terrain feature + if (tile.resource != null) unit.civ.cache.updateCivResources() // unlikely, but maybe a mod makes a resource improvement dependent on a terrain feature } if (RoadStatus.values().any { tile.improvementInProgress == it.removeAction }) { tile.removeRoad() @@ -202,11 +202,11 @@ class UnitTurnManager(val unit: MapUnit) { tile.removeTerrainFeature(removedFeatureName) } } - tile.improvementInProgress == RoadStatus.Road.name -> tile.addRoad(RoadStatus.Road, unit.civInfo) - tile.improvementInProgress == RoadStatus.Railroad.name -> tile.addRoad(RoadStatus.Railroad, unit.civInfo) + tile.improvementInProgress == RoadStatus.Road.name -> tile.addRoad(RoadStatus.Road, unit.civ) + tile.improvementInProgress == RoadStatus.Railroad.name -> tile.addRoad(RoadStatus.Railroad, unit.civ) tile.improvementInProgress == Constants.repair -> tile.setRepaired() else -> { - val improvement = unit.civInfo.gameInfo.ruleSet.tileImprovements[tile.improvementInProgress]!! + val improvement = unit.civ.gameInfo.ruleSet.tileImprovements[tile.improvementInProgress]!! improvement.handleImprovementCompletion(unit) tile.changeImprovement(tile.improvementInProgress) } @@ -219,17 +219,17 @@ class UnitTurnManager(val unit: MapUnit) { private fun tryProvideProductionToClosestCity(removedTerrainFeature: String) { val tile = unit.getTile() - val closestCity = unit.civInfo.cities.minByOrNull { it.getCenterTile().aerialDistanceTo(tile) } + val closestCity = unit.civ.cities.minByOrNull { it.getCenterTile().aerialDistanceTo(tile) } @Suppress("FoldInitializerAndIfToElvis") if (closestCity == null) return val distance = closestCity.getCenterTile().aerialDistanceTo(tile) var productionPointsToAdd = if (distance == 1) 20 else 20 - (distance - 2) * 5 - if (tile.owningCity == null || tile.owningCity!!.civ != unit.civInfo) productionPointsToAdd = + if (tile.owningCity == null || tile.owningCity!!.civ != unit.civ) productionPointsToAdd = productionPointsToAdd * 2 / 3 if (productionPointsToAdd > 0) { closestCity.cityConstructions.addProductionPoints(productionPointsToAdd) val locations = LocationAction(tile.position, closestCity.location) - unit.civInfo.addNotification( + unit.civ.addNotification( "Clearing a [$removedTerrainFeature] has created [$productionPointsToAdd] Production for [${closestCity.name}]", locations, NotificationCategory.Production, NotificationIcon.Construction ) diff --git a/core/src/com/unciv/logic/map/mapunit/UnitUpgradeManager.kt b/core/src/com/unciv/logic/map/mapunit/UnitUpgradeManager.kt index 4c39ecfd95..36046348d0 100644 --- a/core/src/com/unciv/logic/map/mapunit/UnitUpgradeManager.kt +++ b/core/src/com/unciv/logic/map/mapunit/UnitUpgradeManager.kt @@ -15,7 +15,7 @@ class UnitUpgradeManager(val unit:MapUnit) { var currentUnit = unit.baseUnit val upgradeList = arrayListOf() while (currentUnit.upgradesTo != null){ - val nextUpgrade = unit.civInfo.getEquivalentUnit(currentUnit.upgradesTo!!) + val nextUpgrade = unit.civ.getEquivalentUnit(currentUnit.upgradesTo!!) currentUnit = nextUpgrade upgradeList.add(currentUnit) } @@ -30,10 +30,10 @@ class UnitUpgradeManager(val unit:MapUnit) { val upgradePath = getUpgradePath() fun isInvalidUpgradeDestination(baseUnit: BaseUnit): Boolean{ - if (baseUnit.requiredTech != null && !unit.civInfo.tech.isResearched(baseUnit.requiredTech!!)) + if (baseUnit.requiredTech != null && !unit.civ.tech.isResearched(baseUnit.requiredTech!!)) return true if (baseUnit.getMatchingUniques(UniqueType.OnlyAvailableWhen).any { - !it.conditionalsApply(StateForConditionals(unit.civInfo, unit = unit )) + !it.conditionalsApply(StateForConditionals(unit.civ, unit = unit )) }) return true return false } @@ -64,9 +64,9 @@ class UnitUpgradeManager(val unit:MapUnit) { // and the civ currently has 0 horses, we need to see if the upgrade will be buildable // WHEN THE CURRENT UNIT IS NOT HERE // TODO redesign without kludge: Inform getRejectionReasons about 'virtually available' resources somehow - unit.civInfo.units.removeUnit(unit) - val rejectionReasons = unitToUpgradeTo.getRejectionReasons(unit.civInfo) - unit.civInfo.units.addUnit(unit) + unit.civ.units.removeUnit(unit) + val rejectionReasons = unitToUpgradeTo.getRejectionReasons(unit.civ) + unit.civ.units.addUnit(unit) var relevantRejectionReasons = rejectionReasons.filterNot { it.type == RejectionReasonType.Unbuildable } if (ignoreRequirements) @@ -90,14 +90,14 @@ class UnitUpgradeManager(val unit:MapUnit) { var goldCostOfUpgrade = 0 - val ruleset = unit.civInfo.gameInfo.ruleSet + val ruleset = unit.civ.gameInfo.ruleSet val constants = ruleset.modOptions.constants.unitUpgradeCost // apply modifiers: Wonders (Pentagon), Policies (Professional Army). Cached outside loop despite // the UniqueType being allowed on a BaseUnit - we don't have a MapUnit in the loop. // Actually instantiating every intermediate to support such mods: todo var civModifier = 1f - val stateForConditionals = StateForConditionals(unit.civInfo, unit = unit) - for (unique in unit.civInfo.getMatchingUniques(UniqueType.UnitUpgradeCost, stateForConditionals)) + val stateForConditionals = StateForConditionals(unit.civ, unit = unit) + for (unique in unit.civ.getMatchingUniques(UniqueType.UnitUpgradeCost, stateForConditionals)) civModifier *= unique.params[0].toPercent() val upgradePath = getUpgradePath() @@ -110,7 +110,7 @@ class UnitUpgradeManager(val unit:MapUnit) { if (era != null) stepCost *= (1f + era.eraNumber * constants.eraMultiplier) stepCost = (stepCost * civModifier).pow(constants.exponent) - stepCost *= unit.civInfo.gameInfo.speed.modifier + stepCost *= unit.civ.gameInfo.speed.modifier goldCostOfUpgrade += (stepCost / constants.roundTo).toInt() * constants.roundTo if (baseUnit == unitToUpgradeTo) break // stop at requested BaseUnit to upgrade to diff --git a/core/src/com/unciv/logic/map/tile/Tile.kt b/core/src/com/unciv/logic/map/tile/Tile.kt index eb9ab72669..bdc5272d7d 100644 --- a/core/src/com/unciv/logic/map/tile/Tile.kt +++ b/core/src/com/unciv/logic/map/tile/Tile.kt @@ -607,8 +607,8 @@ open class Tile : IsPartOfGameInfoSerialization { if (naturalWonder != null) lineList += naturalWonder!! if (roadStatus !== RoadStatus.None && !isCityCenter()) lineList += roadStatus.name if (improvement != null) lineList += improvement!! - if (civilianUnit != null) lineList += civilianUnit!!.name + " - " + civilianUnit!!.civInfo.civName - if (militaryUnit != null) lineList += militaryUnit!!.name + " - " + militaryUnit!!.civInfo.civName + if (civilianUnit != null) lineList += civilianUnit!!.name + " - " + civilianUnit!!.civ.civName + if (militaryUnit != null) lineList += militaryUnit!!.name + " - " + militaryUnit!!.civ.civName if (this::baseTerrainObject.isInitialized && isImpassible()) lineList += Constants.impassable return lineList.joinToString() } @@ -701,12 +701,12 @@ open class Tile : IsPartOfGameInfoSerialization { } if (civilianUnit != null && isViewableToPlayer) - lineList += FormattedLine(civilianUnit!!.name.tr() + " - " + civilianUnit!!.civInfo.civName.tr(), + lineList += FormattedLine(civilianUnit!!.name.tr() + " - " + civilianUnit!!.civ.civName.tr(), link="Unit/${civilianUnit!!.name}") if (militaryUnit != null && isViewableToPlayer && (viewingCiv == null || !militaryUnit!!.isInvisible(viewingCiv))) { val milUnitString = militaryUnit!!.name.tr() + (if (militaryUnit!!.health < 100) "(" + militaryUnit!!.health + ")" else "") + - " - " + militaryUnit!!.civInfo.civName.tr() + " - " + militaryUnit!!.civ.civName.tr() lineList += FormattedLine(milUnitString, link="Unit/${militaryUnit!!.name}") } @@ -725,7 +725,7 @@ open class Tile : IsPartOfGameInfoSerialization { fun hasEnemyInvisibleUnit(viewingCiv: Civilization): Boolean { val unitsInTile = getUnits() if (unitsInTile.none()) return false - if (unitsInTile.first().civInfo != viewingCiv && + if (unitsInTile.first().civ != viewingCiv && unitsInTile.firstOrNull { it.isInvisible(viewingCiv) } != null) { return true } diff --git a/core/src/com/unciv/logic/trade/TradeLogic.kt b/core/src/com/unciv/logic/trade/TradeLogic.kt index 3b376203b8..5d04b0d189 100644 --- a/core/src/com/unciv/logic/trade/TradeLogic.kt +++ b/core/src/com/unciv/logic/trade/TradeLogic.kt @@ -99,7 +99,7 @@ class TradeLogic(val ourCivilization:Civilization, val otherCivilization: Civili .forEach { it.movement.teleportToClosestMoveableTile() } for (tile in city.getTiles()) { for (unit in tile.getUnits().toList()) { - if (!unit.civInfo.diplomacyFunctions.canPassThroughTiles(to) && !unit.canEnterForeignTerrain) + if (!unit.civ.diplomacyFunctions.canPassThroughTiles(to) && !unit.canEnterForeignTerrain) unit.movement.teleportToClosestMoveableTile() } } diff --git a/core/src/com/unciv/models/ruleset/tile/TileImprovement.kt b/core/src/com/unciv/models/ruleset/tile/TileImprovement.kt index d56b47e41e..fb00661f20 100644 --- a/core/src/com/unciv/models/ruleset/tile/TileImprovement.kt +++ b/core/src/com/unciv/models/ruleset/tile/TileImprovement.kt @@ -93,7 +93,7 @@ class TileImprovement : RulesetStatsObject() { removingAction in tile.ruleset.tileImprovements && !isAllowedOnFeature(feature) && tile.ruleset.tileImprovements[removingAction]!!.let { - it.techRequired == null || builder.civInfo.tech.isResearched(it.techRequired!!) + it.techRequired == null || builder.civ.tech.isResearched(it.techRequired!!) } } diff --git a/core/src/com/unciv/models/ruleset/unique/Unique.kt b/core/src/com/unciv/models/ruleset/unique/Unique.kt index 15513b6899..34e21e2d55 100644 --- a/core/src/com/unciv/models/ruleset/unique/Unique.kt +++ b/core/src/com/unciv/models/ruleset/unique/Unique.kt @@ -252,7 +252,7 @@ class Unique(val text: String, val sourceObjectType: UniqueTarget? = null, val s && relevantTile!!.neighbors.any { it.militaryUnit != null && it.militaryUnit != relevantUnit - && it.militaryUnit!!.civInfo == state.civInfo + && it.militaryUnit!!.civ == state.civInfo && it.militaryUnit!!.matchesFilter(condition.params[0]) } diff --git a/core/src/com/unciv/models/ruleset/unique/UniqueTriggerActivation.kt b/core/src/com/unciv/models/ruleset/unique/UniqueTriggerActivation.kt index d965e47b9c..de5ffdacc5 100644 --- a/core/src/com/unciv/models/ruleset/unique/UniqueTriggerActivation.kt +++ b/core/src/com/unciv/models/ruleset/unique/UniqueTriggerActivation.kt @@ -589,14 +589,14 @@ object UniqueTriggerActivation { UniqueType.OneTimeUnitHeal -> { unit.healBy(unique.params[0].toInt()) if (notification != null) - unit.civInfo.addNotification(notification, unit.getTile().position, NotificationCategory.Units) // Do we have a heal icon? + unit.civ.addNotification(notification, unit.getTile().position, NotificationCategory.Units) // Do we have a heal icon? return true } UniqueType.OneTimeUnitGainXP -> { if (!unit.baseUnit.isMilitary()) return false unit.promotions.XP += unique.params[0].toInt() if (notification != null) - unit.civInfo.addNotification(notification, unit.getTile().position, NotificationCategory.Units) + unit.civ.addNotification(notification, unit.getTile().position, NotificationCategory.Units) return true } UniqueType.OneTimeUnitUpgrade -> { @@ -604,7 +604,7 @@ object UniqueTriggerActivation { ?: return false upgradeAction.action!!() if (notification != null) - unit.civInfo.addNotification(notification, unit.getTile().position, NotificationCategory.Units) + unit.civ.addNotification(notification, unit.getTile().position, NotificationCategory.Units) return true } UniqueType.OneTimeUnitSpecialUpgrade -> { @@ -612,16 +612,16 @@ object UniqueTriggerActivation { ?: return false upgradeAction.action!!() if (notification != null) - unit.civInfo.addNotification(notification, unit.getTile().position, NotificationCategory.Units) + unit.civ.addNotification(notification, unit.getTile().position, NotificationCategory.Units) return true } UniqueType.OneTimeUnitGainPromotion -> { - val promotion = unit.civInfo.gameInfo.ruleSet.unitPromotions.keys + val promotion = unit.civ.gameInfo.ruleSet.unitPromotions.keys .firstOrNull { it == unique.params[0] } ?: return false unit.promotions.addPromotion(promotion, true) if (notification != null) - unit.civInfo.addNotification(notification, unit.getTile().position, NotificationCategory.Units, unit.name) + unit.civ.addNotification(notification, unit.getTile().position, NotificationCategory.Units, unit.name) return true } else -> return false diff --git a/core/src/com/unciv/models/ruleset/unit/BaseUnit.kt b/core/src/com/unciv/models/ruleset/unit/BaseUnit.kt index 8ef009189c..4fcb614c71 100644 --- a/core/src/com/unciv/models/ruleset/unit/BaseUnit.kt +++ b/core/src/com/unciv/models/ruleset/unit/BaseUnit.kt @@ -70,7 +70,7 @@ class BaseUnit : RulesetObject(), INonPerpetualConstruction { fun getMapUnit(civInfo: Civilization): MapUnit { val unit = MapUnit() unit.name = name - unit.civInfo = civInfo + unit.civ = civInfo unit.owner = civInfo.civName // must be after setting name & civInfo because it sets the baseUnit according to the name diff --git a/core/src/com/unciv/ui/cityscreen/CitizenManagementTable.kt b/core/src/com/unciv/ui/cityscreen/CitizenManagementTable.kt index 774ab98155..75645ee612 100644 --- a/core/src/com/unciv/ui/cityscreen/CitizenManagementTable.kt +++ b/core/src/com/unciv/ui/cityscreen/CitizenManagementTable.kt @@ -5,7 +5,6 @@ import com.badlogic.gdx.scenes.scene2d.Touchable import com.badlogic.gdx.scenes.scene2d.ui.Table import com.unciv.Constants import com.unciv.logic.city.CityFocus -import com.unciv.ui.images.ImageGetter import com.unciv.ui.utils.BaseScreen import com.unciv.ui.utils.ExpanderTab import com.unciv.ui.utils.extensions.onClick diff --git a/core/src/com/unciv/ui/pickerscreens/PromotionPickerScreen.kt b/core/src/com/unciv/ui/pickerscreens/PromotionPickerScreen.kt index 5a5c0d615a..05559018f8 100644 --- a/core/src/com/unciv/ui/pickerscreens/PromotionPickerScreen.kt +++ b/core/src/com/unciv/ui/pickerscreens/PromotionPickerScreen.kt @@ -24,7 +24,6 @@ import com.unciv.ui.utils.extensions.onClick import com.unciv.ui.utils.extensions.setFontColor import com.unciv.ui.utils.extensions.toLabel import com.unciv.ui.utils.extensions.toTextButton -import com.unciv.utils.Log import java.lang.Integer.max import kotlin.math.abs @@ -171,7 +170,7 @@ class PromotionPickerScreen(val unit: MapUnit) : PickerScreen(), RecreateOnResiz availablePromotionsGroup.defaults().pad(5f) val unitType = unit.type - val promotionsForUnitType = unit.civInfo.gameInfo.ruleSet.unitPromotions.values.filter { + val promotionsForUnitType = unit.civ.gameInfo.ruleSet.unitPromotions.values.filter { it.unitTypes.contains(unitType.name) || unit.promotions.promotions.contains(it.name) } //Always allow the user to rename the unit as many times as they like. diff --git a/core/src/com/unciv/ui/tilegroups/CityButton.kt b/core/src/com/unciv/ui/tilegroups/CityButton.kt index 26f11be2f8..191c2cd6f6 100644 --- a/core/src/com/unciv/ui/tilegroups/CityButton.kt +++ b/core/src/com/unciv/ui/tilegroups/CityButton.kt @@ -33,7 +33,6 @@ import com.unciv.ui.utils.extensions.toGroup import com.unciv.ui.utils.extensions.toLabel import kotlin.math.max import kotlin.math.min -import kotlin.math.roundToInt class InfluenceTable( influence: Float, diff --git a/core/src/com/unciv/ui/tilegroups/TileSetStrings.kt b/core/src/com/unciv/ui/tilegroups/TileSetStrings.kt index fc8cf64b40..e9a20944a5 100644 --- a/core/src/com/unciv/ui/tilegroups/TileSetStrings.kt +++ b/core/src/com/unciv/ui/tilegroups/TileSetStrings.kt @@ -132,7 +132,7 @@ class TileSetStrings(tileSet: String = UncivGame.Current.settings.tileSet, unitS else baseUnitIconLocation // no change } - val civInfo = unit.civInfo + val civInfo = unit.civ val style = civInfo.nation.getStyleOrCivName() var imageAttempter = ImageAttempter(baseUnitIconLocation) @@ -154,8 +154,8 @@ class TileSetStrings(tileSet: String = UncivGame.Current.settings.tileSet, unitS fun getUnitImageLocation(unit: MapUnit):String { val imageKey = getString( unit.name, tag, - unit.civInfo.getEra().name, tag, - unit.civInfo.nation.getStyleOrCivName(), tag, + unit.civ.getEra().name, tag, + unit.civ.nation.getStyleOrCivName(), tag, unit.isEmbarked().toString() ) // if in cache return that diff --git a/core/src/com/unciv/ui/tilegroups/WorldTileGroup.kt b/core/src/com/unciv/ui/tilegroups/WorldTileGroup.kt index a4bab1d5fe..05c4c1fb64 100644 --- a/core/src/com/unciv/ui/tilegroups/WorldTileGroup.kt +++ b/core/src/com/unciv/ui/tilegroups/WorldTileGroup.kt @@ -2,7 +2,6 @@ package com.unciv.ui.tilegroups import com.unciv.UncivGame import com.unciv.logic.civilization.Civilization -import com.unciv.logic.map.mapunit.MapUnit import com.unciv.logic.map.tile.Tile import com.unciv.ui.worldscreen.WorldScreen diff --git a/core/src/com/unciv/ui/tilegroups/layers/TileLayerUnitArt.kt b/core/src/com/unciv/ui/tilegroups/layers/TileLayerUnitArt.kt index 7b721653df..83a7a09c74 100644 --- a/core/src/com/unciv/ui/tilegroups/layers/TileLayerUnitArt.kt +++ b/core/src/com/unciv/ui/tilegroups/layers/TileLayerUnitArt.kt @@ -34,7 +34,7 @@ class TileLayerUnitArt(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, if (unit != null && isShown && UncivGame.Current.settings.showPixelUnits) { location = strings().getUnitImageLocation(unit) - nationName = "${unit.civInfo.civName}-" + nationName = "${unit.civ.civName}-" } if (locations[index] != "$nationName$location") { @@ -44,7 +44,7 @@ class TileLayerUnitArt(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, group.clear() if (location != "" && ImageGetter.imageExists(location)) { - val nation = unit!!.civInfo.nation + val nation = unit!!.civ.nation val pixelUnitImages = ImageGetter.getLayeredImageColored( location, null, diff --git a/core/src/com/unciv/ui/tilegroups/layers/TileLayerUnitFlag.kt b/core/src/com/unciv/ui/tilegroups/layers/TileLayerUnitFlag.kt index 86b7249dda..dc041fdfc3 100644 --- a/core/src/com/unciv/ui/tilegroups/layers/TileLayerUnitFlag.kt +++ b/core/src/com/unciv/ui/tilegroups/layers/TileLayerUnitFlag.kt @@ -11,7 +11,6 @@ import com.unciv.ui.tilegroups.TileGroup import com.unciv.ui.utils.BaseScreen import com.unciv.ui.utils.UnitGroup import com.unciv.ui.utils.extensions.center -import com.unciv.ui.utils.extensions.centerX import com.unciv.ui.utils.extensions.toLabel class TileLayerUnitFlag(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup, size) { @@ -66,11 +65,11 @@ class TileLayerUnitFlag(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup } // Fade out action indicator for own non-idle units - if (unit.civInfo == viewingCiv && !unit.isIdle()) + if (unit.civ == viewingCiv && !unit.isIdle()) newIcon.actionGroup?.color?.a = 0.5f * UncivGame.Current.settings.unitIconOpacity // Fade out flag for own out-of-moves units - if (unit.civInfo == viewingCiv && unit.currentMovement == 0f) + if (unit.civ == viewingCiv && unit.currentMovement == 0f) newIcon.color.a = 0.5f } @@ -80,8 +79,8 @@ class TileLayerUnitFlag(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup private fun getAirUnitTable(unit: MapUnit): Table { - val iconColor = unit.civInfo.nation.getOuterColor() - val bgColor = unit.civInfo.nation.getInnerColor() + val iconColor = unit.civ.nation.getOuterColor() + val bgColor = unit.civ.nation.getInnerColor() val airUnitTable = Table() airUnitTable.background = BaseScreen.skinStrings.getUiBackground( @@ -141,7 +140,7 @@ class TileLayerUnitFlag(tileGroup: TileGroup, size: Float) : TileLayer(tileGroup if (viewingCiv != null) { val unitsInTile = tile().getUnits() val shouldBeHighlighted = unitsInTile.any() - && unitsInTile.first().civInfo.isAtWarWith(viewingCiv) + && unitsInTile.first().civ.isAtWarWith(viewingCiv) && isViewable(viewingCiv) && showMilitaryUnit(viewingCiv) if (shouldBeHighlighted) diff --git a/core/src/com/unciv/ui/utils/UnitGroup.kt b/core/src/com/unciv/ui/utils/UnitGroup.kt index af408d3387..1613a8586f 100644 --- a/core/src/com/unciv/ui/utils/UnitGroup.kt +++ b/core/src/com/unciv/ui/utils/UnitGroup.kt @@ -1,6 +1,5 @@ package com.unciv.ui.utils -import com.badlogic.gdx.graphics.Color import com.badlogic.gdx.scenes.scene2d.Group import com.badlogic.gdx.scenes.scene2d.actions.Actions import com.badlogic.gdx.scenes.scene2d.actions.RepeatAction @@ -16,7 +15,7 @@ import com.unciv.ui.utils.extensions.surroundWithThinCircle class UnitGroup(val unit: MapUnit, val size: Float): Group() { var actionGroup :Group? = null - val flagIcon = ImageGetter.getUnitIcon(unit.name, unit.civInfo.nation.getInnerColor()) + val flagIcon = ImageGetter.getUnitIcon(unit.name, unit.civ.nation.getInnerColor()) .apply { if (unit.isCivilian()) setSize(size * 0.60f, size * 0.60f) @@ -47,12 +46,12 @@ class UnitGroup(val unit: MapUnit, val size: Float): Group() { // 0f (invisible) to 1f (fully opaque) flagIcon.color.a = UncivGame.Current.settings.unitIconOpacity - outerBg.color = unit.civInfo.nation.getInnerColor() + outerBg.color = unit.civ.nation.getInnerColor() outerBg.color.a = UncivGame.Current.settings.unitIconOpacity outerBg.setSize(sizeOuterBgX, sizeOuterBgY) outerBg.center(flagBg) - innerBg.color = unit.civInfo.nation.getOuterColor() + innerBg.color = unit.civ.nation.getOuterColor() innerBg.color.a = UncivGame.Current.settings.unitIconOpacity innerBg.setSize(sizeInnerBgX, sizeInnerBgY) innerBg.center(flagBg) diff --git a/core/src/com/unciv/ui/worldscreen/AlertPopup.kt b/core/src/com/unciv/ui/worldscreen/AlertPopup.kt index 579ec1e233..6de2023afd 100644 --- a/core/src/com/unciv/ui/worldscreen/AlertPopup.kt +++ b/core/src/com/unciv/ui/worldscreen/AlertPopup.kt @@ -368,7 +368,7 @@ class AlertPopup(val worldScreen: WorldScreen, val popupAlert: PopupAlert): Popu capturedUnit.destroy() // This is so that future checks which check if a unit has been captured are caught give the right answer // For example, in postBattleMoveToAttackedTile - capturedUnit.civInfo = captor + capturedUnit.civ = captor captor.units.placeUnitNearTile(tile.position, Constants.worker) } else capturedUnit.capturedBy(captor) diff --git a/core/src/com/unciv/ui/worldscreen/WorldMapHolder.kt b/core/src/com/unciv/ui/worldscreen/WorldMapHolder.kt index be8a155018..da438ddad4 100644 --- a/core/src/com/unciv/ui/worldscreen/WorldMapHolder.kt +++ b/core/src/com/unciv/ui/worldscreen/WorldMapHolder.kt @@ -186,7 +186,7 @@ class WorldMapHolder( if (previousSelectedCity != null && previousSelectedCity.canBombard() && selectedTile!!.getTilesInDistance(2).contains(previousSelectedCity.getCenterTile()) && unitsInTile.any() - && unitsInTile.first().civInfo.isAtWarWith(worldScreen.viewingCiv)) { + && unitsInTile.first().civ.isAtWarWith(worldScreen.viewingCiv)) { // try to select the closest city to bombard this guy unitTable.citySelected(previousSelectedCity) } @@ -391,7 +391,7 @@ class WorldMapHolder( && (tile.getOwner() == worldScreen.viewingCiv || worldScreen.viewingCiv.isSpectator())) { unitList.addAll(tile.getCity()!!.getCenterTile().getUnits()) } else if (tile.airUnits.isNotEmpty() - && (tile.airUnits.first().civInfo == worldScreen.viewingCiv || worldScreen.viewingCiv.isSpectator())) { + && (tile.airUnits.first().civ == worldScreen.viewingCiv || worldScreen.viewingCiv.isSpectator())) { unitList.addAll(tile.getUnits()) } @@ -432,8 +432,8 @@ class WorldMapHolder( val firstUnit = dto.unitToTurnsToDestination.keys.first() val unitIcon = if (dto.unitToTurnsToDestination.size == 1) UnitGroup(firstUnit, smallerCircleSizes) - else dto.unitToTurnsToDestination.size.toString().toLabel(fontColor = firstUnit.civInfo.nation.getInnerColor()).apply { setAlignment(Align.center) } - .surroundWithCircle(smallerCircleSizes).apply { circle.color = firstUnit.civInfo.nation.getOuterColor() } + else dto.unitToTurnsToDestination.size.toString().toLabel(fontColor = firstUnit.civ.nation.getInnerColor()).apply { setAlignment(Align.center) } + .surroundWithCircle(smallerCircleSizes).apply { circle.color = firstUnit.civ.nation.getOuterColor() } unitIcon.y = buttonSize - unitIcon.height moveHereButton.addActor(unitIcon) @@ -585,11 +585,11 @@ class WorldMapHolder( // Fade out population icons group.layerMisc.dimPopulation(true) - val shownImprovement = unit.civInfo.lastSeenImprovement[group.tile.position] + val shownImprovement = unit.civ.lastSeenImprovement[group.tile.position] // Fade out improvement icons (but not barb camps or ruins) if (shownImprovement != null && shownImprovement != Constants.barbarianEncampment - && !unit.civInfo.gameInfo.ruleSet.tileImprovements[shownImprovement]!!.isAncientRuinsEquivalent()) + && !unit.civ.gameInfo.ruleSet.tileImprovements[shownImprovement]!!.isAncientRuinsEquivalent()) group.layerMisc.dimImprovement(true) } } @@ -660,7 +660,7 @@ class WorldMapHolder( val attackableTiles: List = BattleHelper.getAttackableEnemies(unit, unit.movement.getDistanceToTiles()) - .filter { it.tileToAttack.isVisible(unit.civInfo) } + .filter { it.tileToAttack.isVisible(unit.civ) } .distinctBy { it.tileToAttack } for (attackableTile in attackableTiles) { diff --git a/core/src/com/unciv/ui/worldscreen/WorldScreen.kt b/core/src/com/unciv/ui/worldscreen/WorldScreen.kt index 3f3cbd276a..dc41c5963a 100644 --- a/core/src/com/unciv/ui/worldscreen/WorldScreen.kt +++ b/core/src/com/unciv/ui/worldscreen/WorldScreen.kt @@ -414,7 +414,7 @@ class WorldScreen( mapHolder.resetArrows() if (UncivGame.Current.settings.showUnitMovements) { val allUnits = gameInfo.civilizations.asSequence().flatMap { it.units.getCivUnits() } - val allAttacks = allUnits.map { unit -> unit.attacksSinceTurnStart.asSequence().map { attacked -> Triple(unit.civInfo, unit.getTile().position, attacked) } }.flatten() + + val allAttacks = allUnits.map { unit -> unit.attacksSinceTurnStart.asSequence().map { attacked -> Triple(unit.civ, unit.getTile().position, attacked) } }.flatten() + gameInfo.civilizations.asSequence().flatMap { civInfo -> civInfo.attacksSinceTurnStart.asSequence().map { Triple(civInfo, it.source, it.target) } } mapHolder.updateMovementOverlay( allUnits.filter(mapVisualization::isUnitPastVisible), @@ -535,7 +535,7 @@ class WorldScreen( // ... all tiles around those in range of an average melee unit // -> and now we look for a unit that could do the conquering because it's ours // no matter whether civilian, air or ranged, tell user he needs melee - .any { it.getUnits().any { unit -> unit.civInfo == viewingCiv } } + .any { it.getUnits().any { unit -> unit.civ == viewingCiv } } } displayTutorial(TutorialTrigger.AfterConquering) { viewingCiv.cities.any { it.hasJustBeenConquered } } @@ -550,7 +550,7 @@ class WorldScreen( private fun updateSelectedCiv() { when { - bottomUnitTable.selectedUnit != null -> selectedCiv = bottomUnitTable.selectedUnit!!.civInfo + bottomUnitTable.selectedUnit != null -> selectedCiv = bottomUnitTable.selectedUnit!!.civ bottomUnitTable.selectedCity != null -> selectedCiv = bottomUnitTable.selectedCity!!.civ else -> viewingCiv } @@ -844,7 +844,7 @@ class WorldScreen( if (!game.settings.showTutorials) return displayTutorial(TutorialTrigger.SlowStart) displayTutorial(TutorialTrigger.CityExpansion) { viewingCiv.cities.any { it.expansion.tilesClaimed() > 0 } } - displayTutorial(TutorialTrigger.BarbarianEncountered) { viewingCiv.viewableTiles.any { it.getUnits().any { unit -> unit.civInfo.isBarbarian() } } } + displayTutorial(TutorialTrigger.BarbarianEncountered) { viewingCiv.viewableTiles.any { it.getUnits().any { unit -> unit.civ.isBarbarian() } } } displayTutorial(TutorialTrigger.RoadsAndRailroads) { viewingCiv.cities.size > 2 } displayTutorial(TutorialTrigger.Happiness) { viewingCiv.getHappiness() < 5 } displayTutorial(TutorialTrigger.Unhappiness) { viewingCiv.getHappiness() < 0 } diff --git a/core/src/com/unciv/ui/worldscreen/unit/UnitTable.kt b/core/src/com/unciv/ui/worldscreen/unit/UnitTable.kt index 8d564ba542..8698a87ead 100644 --- a/core/src/com/unciv/ui/worldscreen/unit/UnitTable.kt +++ b/core/src/com/unciv/ui/worldscreen/unit/UnitTable.kt @@ -123,7 +123,7 @@ class UnitTable(val worldScreen: WorldScreen) : Table() { fun update() { if (selectedUnit != null) { isVisible = true - if (selectedUnit!!.civInfo != worldScreen.viewingCiv && !worldScreen.viewingCiv.isSpectator()) { // The unit that was selected, was captured. It exists but is no longer ours. + if (selectedUnit!!.civ != worldScreen.viewingCiv && !worldScreen.viewingCiv.isSpectator()) { // The unit that was selected, was captured. It exists but is no longer ours. selectUnit() selectedUnitHasChanged = true } else if (selectedUnit!! !in selectedUnit!!.getTile().getUnits()) { // The unit that was there no longer exists @@ -242,7 +242,7 @@ class UnitTable(val worldScreen: WorldScreen) : Table() { } ) } - + unitDescriptionTable.clear() unitDescriptionTable.defaults().pad(2f).padRight(5f) unitDescriptionTable.add("Strength".tr()) @@ -315,7 +315,7 @@ class UnitTable(val worldScreen: WorldScreen) : Table() { // Do no select a different unit while in Air Sweep mode if (selectedUnit != null && selectedUnit!!.isPreparingAirSweep()) return - fun MapUnit.isEligible(): Boolean = (this.civInfo == worldScreen.viewingCiv + fun MapUnit.isEligible(): Boolean = (this.civ == worldScreen.viewingCiv || worldScreen.viewingCiv.isSpectator()) && this !in selectedUnits fun MapUnit.isPrioritized(): Boolean = this.isGreatPerson() || this.hasUnique(UniqueType.FoundCity) diff --git a/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActions.kt b/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActions.kt index 0cf9b744f4..3222649c76 100644 --- a/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActions.kt +++ b/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActions.kt @@ -121,8 +121,8 @@ object UnitActions { private fun addDisbandAction(actionList: ArrayList, unit: MapUnit, worldScreen: WorldScreen) { actionList += UnitAction(type = UnitActionType.DisbandUnit, action = { if (!worldScreen.hasOpenPopups()) { - val disbandText = if (unit.currentTile.getOwner() == unit.civInfo) - "Disband this unit for [${unit.baseUnit.getDisbandGold(unit.civInfo)}] gold?".tr() + val disbandText = if (unit.currentTile.getOwner() == unit.civ) + "Disband this unit for [${unit.baseUnit.getDisbandGold(unit.civ)}] gold?".tr() else "Do you really want to disband this unit?".tr() ConfirmPopup(UncivGame.Current.worldScreen!!, disbandText, "Disband unit") { unit.disband() @@ -142,9 +142,9 @@ object UnitActions { val tile = unit.currentTile if (!tile.isWater || !unit.hasUnique(UniqueType.CreateWaterImprovements) || tile.resource == null) return null - val improvementName = tile.tileResource.getImprovingImprovement(tile, unit.civInfo) ?: return null + val improvementName = tile.tileResource.getImprovingImprovement(tile, unit.civ) ?: return null val improvement = tile.ruleset.tileImprovements[improvementName] ?: return null - if (!tile.improvementFunctions.canBuildImprovement(improvement, unit.civInfo)) return null + if (!tile.improvementFunctions.canBuildImprovement(improvement, unit.civ)) return null return UnitAction(UnitActionType.Create, "Create [$improvementName]", action = { @@ -176,14 +176,14 @@ object UnitActions { if (!unit.hasUnique(UniqueType.FoundCity) || 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.civInfo.isOneCityChallenger() && unit.civInfo.hasEverOwnedOriginalCapital == true) return null + if (unit.civ.isOneCityChallenger() && unit.civ.hasEverOwnedOriginalCapital == true) return null if (unit.currentMovement <= 0 || !tile.canBeSettled()) return UnitAction(UnitActionType.FoundCity, action = null) val foundAction = { UncivGame.Current.settings.addCompletedTutorialTask("Found city") - unit.civInfo.addCity(tile.position) + unit.civ.addCity(tile.position) if (tile.ruleset.tileImprovements.containsKey("City center")) tile.changeImprovement("City center") tile.removeRoad() @@ -191,7 +191,7 @@ object UnitActions { UncivGame.Current.worldScreen!!.shouldUpdate = true } - if (unit.civInfo.playerType == PlayerType.AI) + if (unit.civ.playerType == PlayerType.AI) return UnitAction(UnitActionType.FoundCity, action = foundAction) return UnitAction( @@ -199,7 +199,7 @@ object UnitActions { uncivSound = UncivSound.Chimes, action = { // check if we would be breaking a promise - val leaders = testPromiseNotToSettle(unit.civInfo, tile) + val leaders = testPromiseNotToSettle(unit.civ, tile) if (leaders == null) foundAction() else { @@ -263,7 +263,7 @@ object UnitActions { else unit.action = UnitActionType.Paradrop.value }.takeIf { unit.currentMovement == unit.getMaxMovement().toFloat() && - unit.currentTile.isFriendlyTerritory(unit.civInfo) && + unit.currentTile.isFriendlyTerritory(unit.civ) && !unit.isEmbarked() }) } @@ -307,7 +307,7 @@ object UnitActions { ): ArrayList? { if (!unit.baseUnit().hasUnique(UniqueType.CanTransform)) return null // can't upgrade to anything val unitTile = unit.getTile() - val civInfo = unit.civInfo + val civInfo = unit.civ val transformList = ArrayList() for (unique in unit.baseUnit().getMatchingUniques(UniqueType.CanTransform, StateForConditionals(unit = unit, civInfo = civInfo, tile = unitTile))) { @@ -362,8 +362,8 @@ object UnitActions { val couldConstruct = unit.currentMovement > 0 && !tile.isCityCenter() - && unit.civInfo.gameInfo.ruleSet.tileImprovements.values.any { - ImprovementPickerScreen.canReport(tile.improvementFunctions.getImprovementBuildingProblems(it, unit.civInfo).toSet()) + && unit.civ.gameInfo.ruleSet.tileImprovements.values.any { + ImprovementPickerScreen.canReport(tile.improvementFunctions.getImprovementBuildingProblems(it, unit.civ).toSet()) && unit.canBuildImprovement(it) } @@ -379,10 +379,10 @@ object UnitActions { val tile = unit.currentTile if (!tile.isPillaged()) return 0 if (tile.improvementInProgress == Constants.repair) return tile.turnsToImprovement - var repairTurns = tile.ruleset.tileImprovements[Constants.repair]!!.getTurnsToBuild(unit.civInfo, unit) + var repairTurns = tile.ruleset.tileImprovements[Constants.repair]!!.getTurnsToBuild(unit.civ, unit) val pillagedImprovement = tile.getImprovementToRepair()!! - val turnsToBuild = pillagedImprovement.getTurnsToBuild(unit.civInfo, unit) + val turnsToBuild = pillagedImprovement.getTurnsToBuild(unit.civ, unit) // cap repair to number of turns to build original improvement if (turnsToBuild < repairTurns) repairTurns = turnsToBuild return repairTurns @@ -432,9 +432,9 @@ object UnitActions { return UnitAction(UnitActionType.AddInCapital, title = "Add to [${unit.getMatchingUniques(UniqueType.AddInCapital).first().params[0]}]", action = { - unit.civInfo.victoryManager.currentsSpaceshipParts.add(unit.name, 1) + unit.civ.victoryManager.currentsSpaceshipParts.add(unit.name, 1) unit.destroy() - }.takeIf { tile.isCityCenter() && tile.getCity()!!.isCapital() && tile.getCity()!!.civ == unit.civInfo } + }.takeIf { tile.isCityCenter() && tile.getCity()!!.isCapital() && tile.getCity()!!.civ == unit.civ } ) } @@ -447,7 +447,7 @@ object UnitActions { fun getImprovementConstructionActions(unit: MapUnit, tile: Tile): ArrayList { val finalActions = ArrayList() val uniquesToCheck = unit.getMatchingUniques(UniqueType.ConstructImprovementConsumingUnit) - val civResources = unit.civInfo.getCivResourcesByName() + val civResources = unit.civ.getCivResourcesByName() for (unique in uniquesToCheck) { val improvementName = unique.params[0] @@ -471,7 +471,7 @@ object UnitActions { }.takeIf { resourcesAvailable && unit.currentMovement > 0f - && tile.improvementFunctions.canBuildImprovement(improvement, unit.civInfo) + && tile.improvementFunctions.canBuildImprovement(improvement, unit.civ) // Next test is to prevent interfering with UniqueType.CreatesOneImprovement - // not pretty, but users *can* remove the building from the city queue an thus clear this: && !tile.isMarkedForCreatesOneImprovement() @@ -492,7 +492,7 @@ object UnitActions { (if (city.isBeingRazed) 5 else 0) } fun fallbackNearestCity(unit: MapUnit) = - unit.civInfo.cities.minByOrNull { + unit.civ.cities.minByOrNull { it.getCenterTile().aerialDistanceTo(unit.currentTile) + (if (it.isBeingRazed) 5 else 0) }!! @@ -500,30 +500,30 @@ object UnitActions { // In the rare case more than one city owns tiles neighboring the citadel // this will prioritize the nearest one not being razed val nearestCity = unit.currentTile.neighbors - .filter { it.getOwner() == unit.civInfo } + .filter { it.getOwner() == unit.civ } .minByOrNull { priority(it) }?.getCity() ?: fallbackNearestCity(unit) // capture all tiles which do not belong to unit's civ and are not enemy cities // we use getTilesInDistance here, not neighbours to include the current tile as well val tilesToTakeOver = unit.currentTile.getTilesInDistance(1) - .filter { !it.isCityCenter() && it.getOwner() != unit.civInfo } + .filter { !it.isCityCenter() && it.getOwner() != unit.civ } val civsToNotify = mutableSetOf() for (tile in tilesToTakeOver) { val otherCiv = tile.getOwner() if (otherCiv != null) { // decrease relations for -10 pt/tile - if (!otherCiv.knows(unit.civInfo)) otherCiv.diplomacyFunctions.makeCivilizationsMeet(unit.civInfo) - otherCiv.getDiplomacyManager(unit.civInfo).addModifier(DiplomaticModifiers.StealingTerritory, -10f) + if (!otherCiv.knows(unit.civ)) otherCiv.diplomacyFunctions.makeCivilizationsMeet(unit.civ) + otherCiv.getDiplomacyManager(unit.civ).addModifier(DiplomaticModifiers.StealingTerritory, -10f) civsToNotify.add(otherCiv) } nearestCity.expansion.takeOwnership(tile) } for (otherCiv in civsToNotify) - otherCiv.addNotification("Your territory has been stolen by [${unit.civInfo}]!", - unit.currentTile.position, NotificationCategory.Cities, unit.civInfo.civName, NotificationIcon.War) + otherCiv.addNotification("Your territory has been stolen by [${unit.civ}]!", + unit.currentTile.position, NotificationCategory.Cities, unit.civ.civName, NotificationIcon.War) } private fun addFortifyActions(actionList: ArrayList, unit: MapUnit, showingAdditionalActions: Boolean) { @@ -577,7 +577,7 @@ object UnitActions { if (!tile.canPillageTile()) return false val tileOwner = tile.getOwner() // Can't pillage friendly tiles, just like you can't attack them - it's an 'act of war' thing - return tileOwner == null || unit.civInfo.isAtWarWith(tileOwner) + return tileOwner == null || unit.civ.isAtWarWith(tileOwner) } private fun addGiftAction(unit: MapUnit, actionList: ArrayList, tile: Tile) { @@ -591,7 +591,7 @@ object UnitActions { if (recipient == null || recipient.isCurrentPlayer()) return null if (recipient.isCityState()) { - if (recipient.isAtWarWith(unit.civInfo)) return null // No gifts to enemy CS + if (recipient.isAtWarWith(unit.civ)) return null // No gifts to enemy CS // City States only take military units (and units specifically allowed by uniques) if (!unit.isMilitary() && unit.getMatchingUniques(UniqueType.GainInfluenceWithUnitGiftToCityState, checkCivInfoUniques = true) @@ -599,7 +599,7 @@ object UnitActions { ) return null } // If gifting to major civ they need to be friendly - else if (!tile.isFriendlyTerritory(unit.civInfo)) return null + else if (!tile.isFriendlyTerritory(unit.civ)) return null if (unit.currentMovement <= 0) return UnitAction(UnitActionType.GiftUnit, action = null) @@ -608,14 +608,14 @@ object UnitActions { if (recipient.isCityState()) { for (unique in unit.getMatchingUniques(UniqueType.GainInfluenceWithUnitGiftToCityState, checkCivInfoUniques = true)) { if (unit.matchesFilter(unique.params[1])) { - recipient.getDiplomacyManager(unit.civInfo) + recipient.getDiplomacyManager(unit.civ) .addInfluence(unique.params[0].toFloat() - 5f) break } } - recipient.getDiplomacyManager(unit.civInfo).addInfluence(5f) - } else recipient.getDiplomacyManager(unit.civInfo) + recipient.getDiplomacyManager(unit.civ).addInfluence(5f) + } else recipient.getDiplomacyManager(unit.civ) .addModifier(DiplomaticModifiers.GaveUsUnits, 5f) if (recipient.isCityState() && unit.isGreatPerson()) @@ -632,7 +632,7 @@ object UnitActions { for (unique in unit.getUniques()) { if (!unique.conditionals.any { it.type == UniqueType.ConditionalConsumeUnit }) continue val unitAction = UnitAction(type = UnitActionType.TriggerUnique, unique.text){ - UniqueTriggerActivation.triggerCivwideUnique(unique, unit.civInfo) + UniqueTriggerActivation.triggerCivwideUnique(unique, unit.civ) unit.consume() } actionList += unitAction diff --git a/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsGreatPerson.kt b/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsGreatPerson.kt index aff44e2299..a79442ee9a 100644 --- a/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsGreatPerson.kt +++ b/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsGreatPerson.kt @@ -20,10 +20,10 @@ object UnitActionsGreatPerson { actionList += UnitAction( UnitActionType.HurryResearch, action = { - unit.civInfo.tech.addScience(unit.civInfo.tech.getScienceFromGreatScientist()) + unit.civ.tech.addScience(unit.civ.tech.getScienceFromGreatScientist()) unit.consume() - }.takeIf { unit.civInfo.tech.currentTechnologyName() != null - && !unit.civInfo.tech.currentTechnology()!!.hasUnique(UniqueType.CannotBeHurried) } + }.takeIf { unit.civ.tech.currentTechnologyName() != null + && !unit.civ.tech.currentTechnology()!!.hasUnique(UniqueType.CannotBeHurried) } ) } UniqueType.StartGoldenAge -> { @@ -31,9 +31,9 @@ object UnitActionsGreatPerson { actionList += UnitAction( UnitActionType.StartGoldenAge, action = { - unit.civInfo.goldenAges.enterGoldenAge(turnsToGoldenAge) + unit.civ.goldenAges.enterGoldenAge(turnsToGoldenAge) unit.consume() - }.takeIf { unit.currentTile.getOwner() != null && unit.currentTile.getOwner() == unit.civInfo } + }.takeIf { unit.currentTile.getOwner() != null && unit.currentTile.getOwner() == unit.civ } ) } UniqueType.CanSpeedupWonderConstruction -> { @@ -47,7 +47,7 @@ object UnitActionsGreatPerson { action = { tile.getCity()!!.cityConstructions.apply { //http://civilization.wikia.com/wiki/Great_engineer_(Civ5) - addProductionPoints(((300 + 30 * tile.getCity()!!.population.population) * unit.civInfo.gameInfo.speed.productionCostModifier).toInt()) + addProductionPoints(((300 + 30 * tile.getCity()!!.population.population) * unit.civ.gameInfo.speed.productionCostModifier).toInt()) constructIfEnough() } @@ -68,7 +68,7 @@ object UnitActionsGreatPerson { //http://civilization.wikia.com/wiki/Great_engineer_(Civ5) val productionPointsToAdd = min( - (300 + 30 * tile.getCity()!!.population.population) * unit.civInfo.gameInfo.speed.productionCostModifier, + (300 + 30 * tile.getCity()!!.population.population) * unit.civ.gameInfo.speed.productionCostModifier, cityConstructions.getRemainingWork(cityConstructions.currentConstructionFromQueue).toFloat() - 1 ).toInt() if (productionPointsToAdd <= 0) continue @@ -88,18 +88,18 @@ object UnitActionsGreatPerson { } UniqueType.CanTradeWithCityStateForGoldAndInfluence -> { val canConductTradeMission = tile.owningCity?.civ?.isCityState() == true - && tile.owningCity?.civ?.isAtWarWith(unit.civInfo) == false + && tile.owningCity?.civ?.isAtWarWith(unit.civ) == false val influenceEarned = unique.params[0].toFloat() actionList += UnitAction( UnitActionType.ConductTradeMission, action = { // http://civilization.wikia.com/wiki/Great_Merchant_(Civ5) - var goldEarned = (350 + 50 * unit.civInfo.getEraNumber()) * unit.civInfo.gameInfo.speed.goldCostModifier - for (goldUnique in unit.civInfo.getMatchingUniques(UniqueType.PercentGoldFromTradeMissions)) + var goldEarned = (350 + 50 * unit.civ.getEraNumber()) * unit.civ.gameInfo.speed.goldCostModifier + for (goldUnique in unit.civ.getMatchingUniques(UniqueType.PercentGoldFromTradeMissions)) goldEarned *= goldUnique.params[0].toPercent() - unit.civInfo.addGold(goldEarned.toInt()) - tile.owningCity!!.civ.getDiplomacyManager(unit.civInfo).addInfluence(influenceEarned) - unit.civInfo.addNotification("Your trade mission to [${tile.owningCity!!.civ}] has earned you [${goldEarned}] gold and [$influenceEarned] influence!", + unit.civ.addGold(goldEarned.toInt()) + tile.owningCity!!.civ.getDiplomacyManager(unit.civ).addInfluence(influenceEarned) + unit.civ.addNotification("Your trade mission to [${tile.owningCity!!.civ}] has earned you [${goldEarned}] gold and [$influenceEarned] influence!", NotificationCategory.General, tile.owningCity!!.civ.civName, NotificationIcon.Gold, NotificationIcon.Culture) unit.consume() }.takeIf { canConductTradeMission } diff --git a/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsPillage.kt b/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsPillage.kt index 28d7ba52a9..0e5c63cb0d 100644 --- a/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsPillage.kt +++ b/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsPillage.kt @@ -44,7 +44,7 @@ object UnitActionsPillage { fun getPillageAction(unit: MapUnit): UnitAction? { val tile = unit.currentTile - if (unit.isCivilian() || !tile.canPillageTile() || tile.getOwner() == unit.civInfo) return null + if (unit.isCivilian() || !tile.canPillageTile() || tile.getOwner() == unit.civ) return null return UnitAction( UnitActionType.Pillage, action = { @@ -79,7 +79,7 @@ object UnitActionsPillage { val pillageYield = Stats() val globalPillageYield = Stats() val toCityPillageYield = Stats() - val closestCity = unit.civInfo.cities.minByOrNull { it.getCenterTile().aerialDistanceTo(tile) } + val closestCity = unit.civ.cities.minByOrNull { it.getCenterTile().aerialDistanceTo(tile) } val improvement = tile.getImprovementToPillage()!! for (unique in improvement.getMatchingUniques(UniqueType.PillageYieldRandom)) { @@ -96,7 +96,7 @@ object UnitActionsPillage { for (stat in pillageYield) { if (stat.key in Stat.statsWithCivWideField) { - unit.civInfo.addStat(stat.key, stat.value.toInt()) + unit.civ.addStat(stat.key, stat.value.toInt()) globalPillageYield[stat.key] += stat.value } else if (closestCity != null) { @@ -109,6 +109,6 @@ object UnitActionsPillage { "We have looted [${toCityPillageYield.toStringWithoutIcons()}] from a [${improvement.name}] which has been sent to [${closestCity.name}]" else "We have looted [${globalPillageYield.toStringWithoutIcons()}] from a [${improvement.name}]" - unit.civInfo.addNotification(lootNotificationText, tile.position, NotificationCategory.War, "ImprovementIcons/${improvement.name}", NotificationIcon.War) + unit.civ.addNotification(lootNotificationText, tile.position, NotificationCategory.War, "ImprovementIcons/${improvement.name}", NotificationIcon.War) } } diff --git a/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsReligion.kt b/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsReligion.kt index 9ebbeed8df..7fa53802d9 100644 --- a/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsReligion.kt +++ b/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsReligion.kt @@ -16,33 +16,33 @@ object UnitActionsReligion { internal fun addFoundReligionAction(unit: MapUnit, actionList: ArrayList) { if (!unit.hasUnique(UniqueType.MayFoundReligion)) return - if (!unit.civInfo.religionManager.mayFoundReligionAtAll(unit)) return + if (!unit.civ.religionManager.mayFoundReligionAtAll(unit)) return actionList += UnitAction( UnitActionType.FoundReligion, - action = getFoundReligionAction(unit).takeIf { unit.civInfo.religionManager.mayFoundReligionNow(unit) } + action = getFoundReligionAction(unit).takeIf { unit.civ.religionManager.mayFoundReligionNow(unit) } ) } fun getFoundReligionAction(unit: MapUnit): () -> Unit { return { - unit.civInfo.religionManager.foundReligion(unit) + unit.civ.religionManager.foundReligion(unit) unit.consume() } } internal fun addEnhanceReligionAction(unit: MapUnit, actionList: ArrayList) { if (!unit.hasUnique(UniqueType.MayEnhanceReligion)) return - if (!unit.civInfo.religionManager.mayEnhanceReligionAtAll(unit)) return + if (!unit.civ.religionManager.mayEnhanceReligionAtAll(unit)) return actionList += UnitAction( UnitActionType.EnhanceReligion, - title = "Enhance [${unit.civInfo.religionManager.religion!!.getReligionDisplayName()}]", - action = getEnhanceReligionAction(unit).takeIf { unit.civInfo.religionManager.mayEnhanceReligionNow(unit) } + title = "Enhance [${unit.civ.religionManager.religion!!.getReligionDisplayName()}]", + action = getEnhanceReligionAction(unit).takeIf { unit.civ.religionManager.mayEnhanceReligionNow(unit) } ) } fun getEnhanceReligionAction(unit: MapUnit): () -> Unit { return { - unit.civInfo.religionManager.useProphetForEnhancingReligion(unit) + unit.civ.religionManager.useProphetForEnhancingReligion(unit) unit.consume() } } @@ -51,7 +51,7 @@ object UnitActionsReligion { val actionsToAdd = unit.religiousActionsUnitCanDo() if (actionsToAdd.none()) return - if (unit.religion == null || unit.civInfo.gameInfo.religions[unit.religion]!!.isPantheon()) return + if (unit.religion == null || unit.civ.gameInfo.religions[unit.religion]!!.isPantheon()) return val city = tile.getCity() ?: return for (action in actionsToAdd) { if (!unit.abilityUsesLeft.containsKey(action)) continue @@ -80,27 +80,27 @@ object UnitActionsReligion { } private fun addSpreadReligionActions(unit: MapUnit, actionList: ArrayList, city: City) { - if (!unit.civInfo.religionManager.maySpreadReligionAtAll(unit)) return + if (!unit.civ.religionManager.maySpreadReligionAtAll(unit)) return actionList += UnitAction( UnitActionType.SpreadReligion, title = "Spread [${unit.getReligionDisplayName()!!}]", action = { val followersOfOtherReligions = city.religion.getFollowersOfOtherReligionsThan(unit.religion!!) for (unique in unit.getMatchingUniques(UniqueType.StatsWhenSpreading, checkCivInfoUniques = true)) { - unit.civInfo.addStat(Stat.valueOf(unique.params[1]), followersOfOtherReligions * unique.params[0].toInt()) + unit.civ.addStat(Stat.valueOf(unique.params[1]), followersOfOtherReligions * unique.params[0].toInt()) } city.religion.addPressure(unit.religion!!, getPressureAddedFromSpread(unit)) if (unit.hasUnique(UniqueType.RemoveOtherReligions)) city.religion.removeAllPressuresExceptFor(unit.religion!!) unit.currentMovement = 0f useActionWithLimitedUses(unit, Constants.spreadReligion) - }.takeIf { unit.currentMovement > 0 && unit.civInfo.religionManager.maySpreadReligionNow(unit) } + }.takeIf { unit.currentMovement > 0 && unit.civ.religionManager.maySpreadReligionNow(unit) } ) } private fun addRemoveHeresyActions(unit: MapUnit, actionList: ArrayList, city: City) { - if (!unit.civInfo.gameInfo.isReligionEnabled()) return - if (city.civ != unit.civInfo) return + if (!unit.civ.gameInfo.isReligionEnabled()) return + if (city.civ != unit.civ) return // Only allow the action if the city actually has any foreign religion // This will almost be always due to pressure from cities close-by if (city.religion.getPressures().none { it.key != unit.religion!! }) return @@ -110,7 +110,7 @@ object UnitActionsReligion { action = { city.religion.removeAllPressuresExceptFor(unit.religion!!) if (city.religion.religionThisIsTheHolyCityOf != null) { - val religion = unit.civInfo.gameInfo.religions[city.religion.religionThisIsTheHolyCityOf]!! + val religion = unit.civ.gameInfo.religions[city.religion.religionThisIsTheHolyCityOf]!! if (city.religion.religionThisIsTheHolyCityOf != unit.religion && !city.religion.isBlockedHolyCity) { religion.getFounder().addNotification("An [${unit.baseUnit.name}] has removed your religion [${religion.getReligionDisplayName()}] from its Holy City [${city.name}]!", NotificationCategory.Religion) city.religion.isBlockedHolyCity = true diff --git a/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsUpgrade.kt b/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsUpgrade.kt index c1d316beb9..560e2b81bd 100644 --- a/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsUpgrade.kt +++ b/core/src/com/unciv/ui/worldscreen/unit/actions/UnitActionsUpgrade.kt @@ -26,7 +26,7 @@ object UnitActionsUpgrade{ val specialUpgradesTo = unit.baseUnit().getMatchingUniques(UniqueType.RuinsUpgrade).map { it.params[0] }.firstOrNull() if (unit.baseUnit().upgradesTo == null && specialUpgradesTo == null) return null // can't upgrade to anything val unitTile = unit.getTile() - val civInfo = unit.civInfo + val civInfo = unit.civ if (!isFree && unitTile.getOwner() != civInfo) return null val upgradesTo = unit.baseUnit().upgradesTo @@ -82,7 +82,7 @@ object UnitActionsUpgrade{ } }.takeIf { isFree || ( - unit.civInfo.gold >= goldCostOfUpgrade + unit.civ.gold >= goldCostOfUpgrade && unit.currentMovement > 0 && !unit.isEmbarked() && unit.upgrade.canUpgrade(unitToUpgradeTo = upgradedUnit) diff --git a/tests/src/com/unciv/logic/map/UnitMovementAlgorithmsTests.kt b/tests/src/com/unciv/logic/map/UnitMovementAlgorithmsTests.kt index e74e87e71e..3cd390e74f 100644 --- a/tests/src/com/unciv/logic/map/UnitMovementAlgorithmsTests.kt +++ b/tests/src/com/unciv/logic/map/UnitMovementAlgorithmsTests.kt @@ -42,7 +42,7 @@ class UnitMovementAlgorithmsTests { civInfo.gameInfo.speed = ruleSet.speeds[Speed.DEFAULTFORSIMULATION]!! civInfo.nation = Nation().apply { name = "My nation" } civInfo.gameInfo.civilizations.add(civInfo) - unit.civInfo = civInfo + unit.civ = civInfo unit.owner = civInfo.civName // Needed for convertHillToTerrainFeature to not crash @@ -217,7 +217,7 @@ class UnitMovementAlgorithmsTests { otherCiv.civName = Constants.barbarians // they are always enemies otherCiv.nation = Nation().apply { name = Constants.barbarians } val otherUnit = MapUnit() - otherUnit.civInfo = otherCiv + otherUnit.civ = otherCiv otherUnit.baseUnit = BaseUnit() // melee check otherUnit.baseUnit.strength = 1 @@ -368,7 +368,7 @@ class UnitMovementAlgorithmsTests { // Other unit on the way val otherUnit = MapUnit() - otherUnit.civInfo = civInfo + otherUnit.civ = civInfo otherUnit.owner = civInfo.civName otherUnit.baseUnit = BaseUnit().apply { unitType = "Melee Water"; strength = 1; ruleset = ruleSet } otherUnit.currentTile = newTiles[0] @@ -473,13 +473,13 @@ class UnitMovementAlgorithmsTests { otherUnit.currentTile = newTiles.last() newTiles.last().civilianUnit = otherUnit otherUnit.name = "Worker" - otherUnit.civInfo = thirdCiv + otherUnit.civ = thirdCiv otherUnit.owner = thirdCiv.civName unit.movement.teleportToClosestMoveableTile() Assert.assertTrue("Civilian unit must be captured by teleported unit", - unit.currentTile == newTiles.last() && otherUnit.civInfo == unit.civInfo) + unit.currentTile == newTiles.last() && otherUnit.civ == unit.civ) } @Test @@ -494,7 +494,7 @@ class UnitMovementAlgorithmsTests { setupMilitaryUnitInTheCurrentTile("Aircraft Carrier") unit.owner = civInfo.civName - unit.civInfo = civInfo + unit.civ = civInfo unit.baseUnit.uniques.add("Can carry [2] [Aircraft] units") unit.updateUniques(ruleSet) civInfo.units.addUnit(unit, false) @@ -504,7 +504,7 @@ class UnitMovementAlgorithmsTests { val newFighter = MapUnit() newFighter.baseUnit = BaseUnit().apply { unitType = "Fighter"; ruleset = ruleSet } newFighter.owner = civInfo.civName - newFighter.civInfo = civInfo + newFighter.civ = civInfo newFighter.currentTile = unit.getTile() tile.airUnits += newFighter newFighter.name = "Fighter" diff --git a/tests/src/com/unciv/logic/map/VisibilityTests.kt b/tests/src/com/unciv/logic/map/VisibilityTests.kt index 0272dc0800..f87ae5012b 100644 --- a/tests/src/com/unciv/logic/map/VisibilityTests.kt +++ b/tests/src/com/unciv/logic/map/VisibilityTests.kt @@ -33,10 +33,10 @@ class VisibilityTests { civInfo.gameInfo.civilizations.add(civInfo) civInfo.gameInfo.civilizations.add(enemyCivInfo) - unit.civInfo = civInfo + unit.civ = civInfo unit.owner = civInfo.civName - enemyUnit.civInfo = enemyCivInfo + enemyUnit.civ = enemyCivInfo enemyUnit.owner = enemyCivInfo.civName tileMap.ruleset = ruleSet diff --git a/tests/src/com/unciv/testing/SerializationTests.kt b/tests/src/com/unciv/testing/SerializationTests.kt index 42efbd482c..695304caa6 100644 --- a/tests/src/com/unciv/testing/SerializationTests.kt +++ b/tests/src/com/unciv/testing/SerializationTests.kt @@ -73,7 +73,7 @@ class SerializationTests { val civ = game.getCurrentPlayerCivilization() val unit = civ.units.getCivUnits().first { it.hasUnique(UniqueType.FoundCity) } val tile = unit.getTile() - unit.civInfo.addCity(tile.position) + unit.civ.addCity(tile.position) if (tile.ruleset.tileImprovements.containsKey("City center")) tile.changeImprovement("City center") unit.destroy()