Specialist information is now hybrid

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

@@ -252,19 +252,14 @@ class CityStats {
     }
 
     fun getStatsOfSpecialist(specialistName:String): Stats {
-        val stats = cityInfo.getRuleset().specialists[specialistName]!!.clone()
+        val specialist = cityInfo.getRuleset().specialists[specialistName]
+        if (specialist == null) return Stats()
+        val stats = specialist.clone()
         for (unique in cityInfo.civInfo.getMatchingUniques("[] from every specialist"))
             stats.add(Stats.parse(unique.params[0]))
         return stats
     }
 
-    private fun getStatsFromSpecialists(specialists: Stats): Stats {
-        val stats = Stats()
-        for (entry in specialists.toHashMap().filter { it.value > 0 })
-            stats.add(getStatsOfSpecialist(entry.key) * entry.value)
-        return stats
-    }
-
     private fun getStatsFromSpecialists(specialists: HashMap<String, Int>): Stats {
         val stats = Stats()
         for (entry in specialists.filter { it.value > 0 })

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

@@ -7,6 +7,8 @@ import com.unciv.models.stats.Stat
 import com.unciv.models.stats.Stats
 import com.unciv.ui.utils.withItem
 import com.unciv.ui.utils.withoutItem
+import kotlin.math.floor
+import kotlin.math.pow
 
 class PopulationManager {
     @Transient
@@ -18,17 +20,13 @@ class PopulationManager {
     // Being deprecated out
     val specialists = Stats()
 
-    fun getNewSpecialists(): HashMap<String, Int> {
+    fun getNewSpecialists() = convertStatsToSpecialistHashmap(specialists)
+
+    fun convertStatsToSpecialistHashmap(stats: Stats):HashMap<String,Int> {
         val specialistHashmap = HashMap<String, Int>()
-        for ((stat, amount) in specialists.toHashMap()) {
+        for ((stat, amount) in stats.toHashMap()) {
             if (amount == 0f) continue
-            val specialistName = when (stat) {
+            val specialistName = specialistNameByStat(stat)
-                Stat.Production -> "Engineer"
-                Stat.Gold -> "Merchant"
-                Stat.Science -> "Scientist"
-                Stat.Culture -> "Artist"
-                else -> TODO()
-            }
             specialistHashmap[specialistName] = amount.toInt()
         }
         return specialistHashmap
@@ -43,9 +41,7 @@ class PopulationManager {
         return toReturn
     }
 
-    fun getNumberOfSpecialists(): Int {
+    fun getNumberOfSpecialists() = getNewSpecialists().values.sum()
-        return getNewSpecialists().values.sum()
-    }
 
     fun getFreePopulation(): Int {
         val workingPopulation = cityInfo.workedTiles.size
@@ -54,7 +50,7 @@ class PopulationManager {
 
     fun getFoodToNextPopulation(): Int {
         // civ v math, civilization.wikia
-        var foodRequired =  15 + 6 * (population - 1) + Math.floor(Math.pow((population - 1).toDouble(), 1.8))
+        var foodRequired =  15 + 6 * (population - 1) + floor((population - 1).toDouble().pow(1.8))
         if(!cityInfo.civInfo.isPlayerCivilization())
             foodRequired *= cityInfo.civInfo.gameInfo.getDifficulty().aiCityGrowthModifier
         return foodRequired.toInt()
@@ -84,6 +80,16 @@ class PopulationManager {
 
     internal fun getStatsOfSpecialist(stat: Stat) = cityInfo.cityStats.getStatsOfSpecialist(stat)
 
+    internal fun getStatsOfSpecialist(name:String) = cityInfo.cityStats.getStatsOfSpecialist(name)
+
+    internal fun specialistNameByStat(stat: Stat) = when (stat) {
+        Stat.Production -> "Engineer"
+        Stat.Gold -> "Merchant"
+        Stat.Science -> "Scientist"
+        Stat.Culture -> "Artist"
+        else -> TODO()
+    }
+
     // todo - change tile choice according to city!
     // if small city, favor production above all, ignore gold!
     // if larger city, food should be worth less!
@@ -138,8 +144,10 @@ class PopulationManager {
             else {
                 cityInfo.workedTiles.asSequence()
                         .map { cityInfo.tileMap[it] }
-                        .minBy { Automation.rankTileForCityWork(it, cityInfo)
+                        .minBy {
-                            + (if(it.isLocked()) 10 else 0) }!!
+                            Automation.rankTileForCityWork(it, cityInfo)
+                            +(if (it.isLocked()) 10 else 0)
+                        }!!
             }
             val valueWorstTile = if (worstWorkedTile == null) 0f
             else Automation.rankTileForCityWork(worstWorkedTile, cityInfo)
@@ -158,9 +166,7 @@ class PopulationManager {
             if ((worstWorkedTile != null && valueWorstTile < valueWorstSpecialist)
                     || worstJob == null) {
                 cityInfo.workedTiles = cityInfo.workedTiles.withoutItem(worstWorkedTile!!.position)
-            } else {
+            } else specialists.add(worstJob, -1f)
-                specialists.add(worstJob, -1f)
-            }
         }
 
     }