diff --git a/core/src/com/unciv/logic/map/tile/TileInfo.kt b/core/src/com/unciv/logic/map/tile/TileInfo.kt
index 462960876b..23dea1d4ed 100644
--- a/core/src/com/unciv/logic/map/tile/TileInfo.kt
+++ b/core/src/com/unciv/logic/map/tile/TileInfo.kt
@@ -756,8 +756,6 @@ open class TileInfo : IsPartOfGameInfoSerialization {
     }
 
     fun setTerrainTransients() {
-        // Uninitialized tilemap - when you're displaying a tile in the civilopedia or map editor
-        if (::tileMap.isInitialized) convertHillToTerrainFeature()
         if (!ruleset.terrains.containsKey(baseTerrain))
             throw Exception("Terrain $baseTerrain does not exist in ruleset!")
         baseTerrainObject = ruleset.terrains[baseTerrain]!!
@@ -938,69 +936,6 @@ open class TileInfo : IsPartOfGameInfoSerialization {
         stopWorkingOnImprovement()
     }
 
-    fun normalizeToRuleset(ruleset: Ruleset) {
-        if (naturalWonder != null && !ruleset.terrains.containsKey(naturalWonder))
-            naturalWonder = null
-        if (naturalWonder != null) {
-            baseTerrain = this.getNaturalWonder().turnsInto!!
-            setTerrainFeatures(listOf())
-            resource = null
-            changeImprovement(null)
-        }
-
-        if (!ruleset.terrains.containsKey(baseTerrain))
-            baseTerrain = ruleset.terrains.values.first { it.type == TerrainType.Land && !it.impassable }.name
-
-        val newFeatures = ArrayList<String>()
-        for (terrainFeature in terrainFeatures) {
-            val terrainFeatureObject = ruleset.terrains[terrainFeature]
-                ?: continue
-            if (terrainFeatureObject.occursOn.isNotEmpty() && !terrainFeatureObject.occursOn.contains(baseTerrain))
-                continue
-            newFeatures.add(terrainFeature)
-        }
-        if (newFeatures.size != terrainFeatures.size)
-            setTerrainFeatures(newFeatures)
-
-        if (resource != null && !ruleset.tileResources.containsKey(resource)) resource = null
-        if (resource != null) {
-            val resourceObject = ruleset.tileResources[resource]!!
-            if (resourceObject.terrainsCanBeFoundOn.none { it == baseTerrain || terrainFeatures.contains(it) })
-                resource = null
-        }
-
-        // If we're checking this at gameInfo.setTransients, we can't check the top terrain
-        if (improvement != null && ::baseTerrainObject.isInitialized) normalizeTileImprovement(ruleset)
-        if (isWater || isImpassible())
-            removeRoad()
-    }
-
-    private fun normalizeTileImprovement(ruleset: Ruleset) {
-        val improvementObject = ruleset.tileImprovements[improvement]
-        if (improvementObject == null) {
-            changeImprovement(null)
-            return
-        }
-        changeImprovement(null) // Unset, and check if it can be reset. If so, do it, if not, invalid.
-        if (improvementFunctions.canImprovementBeBuiltHere(improvementObject, stateForConditionals = StateForConditionals.IgnoreConditionals))
-            changeImprovement(improvementObject.name)
-    }
-
-    private fun convertHillToTerrainFeature() {
-        if (baseTerrain == Constants.hill &&
-                ruleset.terrains[Constants.hill]?.type == TerrainType.TerrainFeature) {
-            val mostCommonBaseTerrain = neighbors.filter { it.isLand && !it.isImpassible() }
-                    .groupBy { it.baseTerrain }.maxByOrNull { it.value.size }
-            baseTerrain = mostCommonBaseTerrain?.key ?: Constants.grassland
-            //We have to add hill as first terrain feature
-            val copy = terrainFeatures.toTypedArray()
-            val newTerrainFeatures = ArrayList<String>()
-            newTerrainFeatures.add(Constants.hill)
-            newTerrainFeatures.addAll(copy)
-            // We set this directly since this is BEFORE the initial setTerrainFeatures
-            terrainFeatures = newTerrainFeatures
-        }
-    }
 
     /**
      * Assign a continent ID to this tile.
diff --git a/core/src/com/unciv/ui/mapeditor/TileInfoNormalizer.kt b/core/src/com/unciv/ui/mapeditor/TileInfoNormalizer.kt
new file mode 100644
index 0000000000..065ccd204f
--- /dev/null
+++ b/core/src/com/unciv/ui/mapeditor/TileInfoNormalizer.kt
@@ -0,0 +1,57 @@
+package com.unciv.ui.mapeditor
+
+import com.unciv.logic.map.tile.TileInfo
+import com.unciv.models.ruleset.Ruleset
+import com.unciv.models.ruleset.tile.TerrainType
+import com.unciv.models.ruleset.unique.StateForConditionals
+
+object TileInfoNormalizer {
+
+    fun normalizeToRuleset(tileInfo: TileInfo, ruleset: Ruleset) {
+        if (tileInfo.naturalWonder != null && !ruleset.terrains.containsKey(tileInfo.naturalWonder))
+            tileInfo.naturalWonder = null
+        if (tileInfo.naturalWonder != null) {
+            tileInfo.baseTerrain = tileInfo.getNaturalWonder().turnsInto!!
+            tileInfo.setTerrainFeatures(listOf())
+            tileInfo.resource = null
+            tileInfo.changeImprovement(null)
+        }
+
+        if (!ruleset.terrains.containsKey(tileInfo.baseTerrain))
+            tileInfo.baseTerrain = ruleset.terrains.values.first { it.type == TerrainType.Land && !it.impassable }.name
+
+        val newFeatures = ArrayList<String>()
+        for (terrainFeature in tileInfo.terrainFeatures) {
+            val terrainFeatureObject = ruleset.terrains[terrainFeature]
+                ?: continue
+            if (terrainFeatureObject.occursOn.isNotEmpty() && !terrainFeatureObject.occursOn.contains(tileInfo.baseTerrain))
+                continue
+            newFeatures.add(terrainFeature)
+        }
+        if (newFeatures.size != tileInfo.terrainFeatures.size)
+            tileInfo.setTerrainFeatures(newFeatures)
+
+        if (tileInfo.resource != null && !ruleset.tileResources.containsKey(tileInfo.resource)) tileInfo.resource = null
+        if (tileInfo.resource != null) {
+            val resourceObject = ruleset.tileResources[tileInfo.resource]!!
+            if (resourceObject.terrainsCanBeFoundOn.none { it == tileInfo.baseTerrain || tileInfo.terrainFeatures.contains(it) })
+                tileInfo.resource = null
+        }
+
+        // If we're checking this at gameInfo.setTransients, we can't check the top terrain
+        if (tileInfo.improvement != null) normalizeTileImprovement(tileInfo, ruleset)
+        if (tileInfo.isWater || tileInfo.isImpassible())
+            tileInfo.removeRoad()
+    }
+
+    private fun normalizeTileImprovement(tileInfo: TileInfo, ruleset: Ruleset) {
+        val improvementObject = ruleset.tileImprovements[tileInfo.improvement]
+        if (improvementObject == null) {
+            tileInfo.changeImprovement(null)
+            return
+        }
+        tileInfo.changeImprovement(null) // Unset, and check if it can be reset. If so, do it, if not, invalid.
+        if (tileInfo.improvementFunctions.canImprovementBeBuiltHere(improvementObject, stateForConditionals = StateForConditionals.IgnoreConditionals))
+            tileInfo.changeImprovement(improvementObject.name)
+    }
+}
diff --git a/core/src/com/unciv/ui/mapeditor/tabs/MapEditorEditTab.kt b/core/src/com/unciv/ui/mapeditor/tabs/MapEditorEditTab.kt
index 2b17f1a785..08cb034975 100644
--- a/core/src/com/unciv/ui/mapeditor/tabs/MapEditorEditTab.kt
+++ b/core/src/com/unciv/ui/mapeditor/tabs/MapEditorEditTab.kt
@@ -6,9 +6,9 @@ import com.badlogic.gdx.scenes.scene2d.Group
 import com.badlogic.gdx.scenes.scene2d.ui.Cell
 import com.badlogic.gdx.scenes.scene2d.ui.Table
 import com.unciv.logic.map.BFS
-import com.unciv.logic.map.tile.TileInfo
 import com.unciv.logic.map.mapgenerator.MapGenerationRandomness
 import com.unciv.logic.map.mapgenerator.RiverGenerator
+import com.unciv.logic.map.tile.TileInfo
 import com.unciv.models.ruleset.Ruleset
 import com.unciv.models.translations.tr
 import com.unciv.ui.civilopedia.FormattedLine
@@ -22,6 +22,7 @@ import com.unciv.ui.mapeditor.MapEditorEditStartsTab
 import com.unciv.ui.mapeditor.MapEditorEditTerrainTab
 import com.unciv.ui.mapeditor.MapEditorEditWondersTab
 import com.unciv.ui.mapeditor.MapEditorScreen
+import com.unciv.ui.mapeditor.TileInfoNormalizer
 import com.unciv.ui.mapeditor.tabs.MapEditorOptionsTab.TileMatchFuzziness
 import com.unciv.ui.popup.ToastPopup
 import com.unciv.ui.utils.BaseScreen
@@ -290,7 +291,7 @@ class MapEditorEditTab(
 
         brushAction(tile)
         tile.setTerrainTransients()
-        tile.normalizeToRuleset(ruleset)    // todo: this does not do what we need
+        TileInfoNormalizer.normalizeToRuleset(tile, ruleset)
         if (!paintedTile.isSimilarEnough(tile)) {
             // revert tile to original state
             tile.applyFrom(savedTile)
diff --git a/core/src/com/unciv/ui/mapeditor/tabs/MapEditorModsTab.kt b/core/src/com/unciv/ui/mapeditor/tabs/MapEditorModsTab.kt
index 2a7eb86a2d..ff0b281459 100644
--- a/core/src/com/unciv/ui/mapeditor/tabs/MapEditorModsTab.kt
+++ b/core/src/com/unciv/ui/mapeditor/tabs/MapEditorModsTab.kt
@@ -8,6 +8,7 @@ import com.unciv.Constants
 import com.unciv.models.ruleset.Ruleset
 import com.unciv.models.ruleset.RulesetCache
 import com.unciv.ui.mapeditor.MapEditorScreen
+import com.unciv.ui.mapeditor.TileInfoNormalizer
 import com.unciv.ui.newgamescreen.ModCheckboxTable
 import com.unciv.ui.newgamescreen.TranslatedSelectBox
 import com.unciv.ui.popup.Popup
@@ -146,6 +147,6 @@ class MapEditorModsTab(
 
     private fun fitMapToRuleset(newRuleset: Ruleset) {
         for (tile in editorScreen.tileMap.values)
-            tile.normalizeToRuleset(newRuleset)
+            TileInfoNormalizer.normalizeToRuleset(tile, newRuleset)
     }
 }